UNIVERSIDAD TECNICA FEDERICO SANTA MARIA DEPARTAMENTO DE ELECTRONICA Assembler MSP430

Transcripción

1 Interfaz C-Assembler. Código de arranque: Se compila el siguiente programa: void main(void) { ; La memoria flash de 60 KB se inicia en 0x Los vectores de interrupción, están en la zona alta de la memoria flash, desde 0xFFE0 hasta 0xFFFF. Cuando se le da energía al controlador, o se genera una señal de reset externo, se coloca en PC la dirección almacenada en el vector asociado a RESET (0x0FFFE). La RAM, de 2 KB, ocupa desde: 0x0200 hasta 0x09FF. El stack se inicia en el tope de la RAM+2; es decir en 0x0A00. De este modo al efectuar un llamado a subrutina, se decrementa en 2 el valor almacenado en el stack, y se deposita la dirección de PC de orno en el tope del stack. En el caso de rutinas de servicio de interrupción además de empujar la dirección de orno, se almacena el valor del registro de estado del controlador (SR). El código de autoarranque del compilador IAR: setea el stack, el vector de interrupción para reset, y define el la rutina exit, cuya finalidad es detener la ejecución de instrucciones después de ejecutada la rutina principal. En este caso simple, el programa principal es traducido a la instrucción de máquina. #include "msp430x14x.h" ORG 01100h ; Programa en Flash RESET: mov.w #0A00h, SP ; Inicia stackpointer call #main call #exit _exit: br # exit exit jmp # exit main: exit: br #_exit ; Prof. Leopoldo Silva Bijit

2 ; Vector de interrupción asociado a Reset ORG 0FFFEh ; MSP430 RESET Vector DW RESET ; END Variables locales en registros. El siguiente programa define una variable local dentro de la función main: void main(void) { int i1=2; i1+=1; Se dispone de 12 registros, comienzan a usarse desde el número 15. Se ilustra ahora sólo el código assembler de main: main: MOV.W #0x2, R15 ; i1=r15 = 2 ADD.W #0x1, R15 ; i1+=1; RET El símbolo # indica direccionamiento inmediato Uso de registros para variables locales. Si se definen dos variables, se ocupan el R15 para i1, y el registro R14 para i2. void main(void) { int i1=2, i2=-1; i1+=1; i2-=1; Se traduce a: main: MOV.W #0x2, R15 ; i1 = R15 = 2 MOV.W #0xffff, R14 ; i2 = R14 = -1; ADD.W #0x1, R15 ; i1+=1 ADD.W #0xffff, R14 ; i2-=1 RET Prof. Leopoldo Silva Bijit

3 Empleo de registros temporales. Si se siguen empleando registros vemos que el R10 y el R11 son preservados. Y que emplea el R11 como temporal. Como se verá el compilador salva el contenido de los registros R4 a R11. Los registros R12 a R15 no son salvados. void main(void) { int i1=-1; int i2=0; int i3=1; int i4 = 5+1; int i5=1<<5; i1+=1; i2-=1; i3=i1+i2+i4; i4=i3 i2; i5=i5+2*3*4; Para evitar warnings por definir variables que no se empleen, las variables se leen y escriben. main: PUSH.W R10 ;se salvan registros PUSH.W R11 MOV.W #0xffff, R15 ; i1 = R15 = -1 MOV.W #0x0, R14 ; i2 = R14 = 0; MOV.W #0x1, R12 ; i3 = R12 = 1; MOV.W #0x6, R13 ; i4 = R13 = 5+1 = 6 MOV.W #0x20, R10 ; i5 = R10 = 1<<5 = 32 = 0x20 ADD.W #0x1, R15 ; i1+=1 ADD.W #0xffff, R14 ; i2-=1 MOV.W R15, R11 ; R11 se emplea como temporal. ADD.W R14, R11 ADD.W R13, R11 MOV.W R11, R12 ; i3=i1+i2+i4 MOV.W R12, R11 BIS.W R14, R11 MOV.W R11, R13 ; i4=i3 i2 ADD.W #0x18, R10 ; i5=i5+2*3*4; POP.W R11 POP.W R10 RET Prof. Leopoldo Silva Bijit

4 Variables locales en el frame. Cuando el número de locales es mayor que los registros disponibles, se almacenan en el frame de la función. Se emplean registros temporales para la compilación de expresiones que requieren almacenamientos intermedios. void main(void) { int i1 = 1, i2 = 2, i3 = 3, i4 = 4; int i5 = 5, i6 = 6, i7 = 7, i8 = 8; int i9 = 9, i10 = 10, i11 = 11, i12 = 12; i1= i2+i3; i2= i1-i2; i3= i1 & i4; i4= i3 i2; i5= i3 ^i4; main: PUSH.W R10 ;salva registros tipo save PUSH.W R11 PUSH.W R8 PUSH.W R9 PUSH.W R6 PUSH.W R7 PUSH.W R4 PUSH.W R5 SUB.W #0x2, SP ; crea frame MOV.W #0x1, R4 ; i1 = R4 = 1; MOV.W #0x2, R5 ; i2 = R5 = 2; MOV.W #0x3, R14 ; i3 = R14 = 3; MOV.W #0x4, R12 ; i4 = R12 = 4; MOV.W #0x5, R13 ; i5 = R13 = 5; MOV.W #0x6, 0x0(SP) ; tope = 6; Direccionamiento indexado. MOV.W #0x7, R10 ; i7 = R10 = 7; MOV.W #0x8, R11 ; i8 = R11 = 8; MOV.W #0x9, R8 ; i9 = R8 = 9; MOV.W #0xa, R9 ; i10 = R9 = 10; MOV.W #0xb, R6 ; i11 = R6 = 11; MOV.W #0xc, R7 ; i12 = R7 = 12; MOV.W R5, R15 ; emplea R15 como temporal ADD.W R14, R15 MOV.W R15, R4 ; i1= i2+i3; MOV.W R4, R15 SUB.W R5, R15 MOV.W R15, R5 ; i2= i1-i2; MOV.W R4, R15 Prof. Leopoldo Silva Bijit

5 AND.W R12, R15 MOV.W R15, R14 ; i3= i1 & i4; MOV.W R14, R15 BIS.W R5, R15 MOV.W R15, R12 ; i4= i3 i2; MOV.W R14, R15 XOR.W R12, R15 MOV.W R15, R13 ; i5= i3 ^ i4; ADD.W #0x2, SP ; desarma el frame BR #?Epilogue8 ; rótulos automáticos?epilogue8: pop.w R5 ; restaura registros que deben preservarse?epilogue7: pop.w R4 ; por ser modificados dentro de la función.?epilogue6: pop.w R7?Epilogue5: pop.w R6?Epilogue4: pop.w R9?Epilogue3: pop.w R8 pop.w R11 pop.w R10 Variables globales inicializadas. Consideremos las siguientes definiciones de variables globales inicializadas. int i1 = 1; int i2 = 2; int i3 = 3; int i4 = 4; int i5 = 5; int i6 = 6; int i7 = 7; int i8 = 8; int i9 = 9; int i10 = 10; int i11 = 11; int i12 = 12; void main(void) { i1= i2+i3; i2= i1-i2; i3= i1 & i4; i4= i3 i2; i5= i3 ^i4; Prof. Leopoldo Silva Bijit

6 Las variables globales (definidas fuera de las funciones) son almacenadas en RAM, a partir de la dirección 0x200. Los inicializadores se almacenan en la memoria flash, a continuación de la última instrucción del programa. Antes de invocar a main, además de iniciar el stack pointer, se inicializan las variables estáticas en RAM, mediante la función memcpy que es automáticamente insertada por el código de arranque. #include "msp430x14x.h" ORG 01100h ; Programa en Flash RESET: mov.w #0A00h, SP ; Inicia stackpointer mov.w #0x200, R12 ; inicio RAM mov.w #Inicializadores, R14 ; valores iniciales de globales push.w #0xA ; se pasa en el tope el número call #memcpy incd.w SP ;pop call #main call #exit _exit: br # exit exit jmp # exit El código en C, para la función estándar memcpy es el siguiente: void *memcpy(void * destino, const void * fuente, register int n) { register char *d = (char *)destino; register const char *s= (char *)fuente; while(n--) *d++ = *s++; urn destino; memcpy Copia un bloque de n bytes desde la dirección fuente hacia la dirección destino. La siguiente implementación assembler de memcpy, copia n bytes desde la dirección fuente (que se pasa en R14, la cual apunta a la zona de los valores iniciales de las variables globales que se escriben en la memoria flash, inmediatamente después de la última instrucción del programa) hacia la dirección destino (que se pasa en R12, la cual apunta al inicio del segmento de memoria RAM). Entonces memcpy queda: memcpy: push.w R10 mov.w 0x4(SP), R13 ; R13 =número de bytes mov.w R12, R10 jmp testn cpy: mov.w R10, R15 Prof. Leopoldo Silva Bijit

7 inc.w R10 ;d++ ;de flash a ram. s++ testn: mov.w R13, R15 add.w #0xFFFF, R13 ; n-- tst.w R15 jne cpy pop.w R10 ;última instrucción del programa. Inicializadores: DW 0100 ;valor inicial de i1 DW 0200 ;inicializador de i2 DW 0300 DW 0400 DW 0500 El es indirecto. Usa R14 como puntero. Nótese que no se crea el espacio para variables globales que no se emplean en el programa, es el caso de las variables i6 a i12, en el ejemplo que se está desarrollando. ; Segmento RAM, después de memcpy ORG 00200h ; MSP430 Inicio RAM i1: DW 00001h ; 200 i2: DW 00002h ; 202 i3: DW 00003h ; 204 i4: DW 00004h ; 206 i5: DW 00005h ; 208 END El código de main ilustra el direccionamiento empleando variables en la zona de RAM. También se muestra operadores de suma y resta, y operadores al bit. main: mov.w &i2, R15 ;El & es direccionamiento absoluto. add.w &i3, R15 mov.w R15, &i1 ; i1= i2+i3; mov.w &i1,r15 sub.w &i2,r15 mov.w R15,&i2 ; i2= i1-i2; mov.w &i1, R15 and.w &i4, R15 mov.w R15, &i3 ; i3= i1 & i4 Prof. Leopoldo Silva Bijit

8 mov.w &i3,r15 bis.w &i2,r15 mov.w R15,&i4 ; i4= i3 i2; mov.w &i3,r15 xor.w &i4,r15 mov.w R15,&i5 ; i5= i3 ^i4; Variables globales no inicializadas. Consideremos las siguientes definiciones de variables globales no inicializadas. Se ilustra además el tratamiento de arreglos. int i1; int arr[4]; int main(void) { i1=-1; arr[0]=0; arr[1]=1; arr[2]=2; arr[3]=3; arr[0]=arr[1]+i1; urn(0) ; Se crean las globales en RAM y se las inicia automáticamente con valores nulos, antes de invocar a main. Lo anterior se logra invocando a la rutina memset, que inserta el código de arranque. #include "msp430x14x.h" ORG 01100h ; Programa en Flash RESET: mov.w #0A00h, SP ; Inicia stackpointer mov.w #0x200, R12 ; inicio RAM clr.w R14 ; valor a setear en RAM push.w #0xA ; se pasa en el tope el número de bytes a setear call #memset incd.w SP ;pop call #main Prof. Leopoldo Silva Bijit

9 call #exit _exit: br # exit exit jmp # exit Se puede describir en C, el código de memset: void memset(void * destino, const int valor, register int n) { register char *d = (char *)destino; while(n--) *d++ = valor; El código de memset que genera IAR: memset: push.w R10 push.w R11 mov.w 0x6(SP), R13 ;número queda en frame mov.w R12, R10 ;en R10 inicio de RAM jmp testn setram: mov.b R14,R15 mov.w R10,R11 inc.w R10 ;d++ mov.b R15,0x0(R11) testn: mov.w R13, R15 add.w #0xFFFF,R13 ;n-- tst.w R15 jne setram pop.w R11 pop.w R10 ; Segmento RAM, después de memset ORG 00200h ; MSP430 Inicio RAM i1: DW 00000h ; 200 arr: DW 00000h ; 202 arr[0] DW 00000h ; 204 arr[1] DW 00000h ; 206 arr[2] DW 00000h ; 208 arr[3] END El código de main ilustra la manipulación de componentes de un arreglo: Prof. Leopoldo Silva Bijit

10 main: mov.w #0xFFFF,&i1 ; i1=-1; clr.w &arr ; arr[0]=0; mov.w #0x1,&0x204 ; arr[1]=1; mov.w #0x2,&0x206 ; arr[2]=2; mov.w #0x3,&0x208 ; arr[3]=3; mov.w &0x204,R15 add.w &i1,r15 mov.w R15,&arr ; arr[0]=arr[1]+i1; clr.w R12 ; urn(0) ; En este ejemplo, la función main orna un valor entero. El valor de orno de la función se efectúa a través de R12. Definición de punteros. En el siguiente código se definen dos globales iniciadas, y un puntero a entero sin iniciar. int *pi; int x=1; int y=2; int main(void) { pi=&x; y = *pi; urn(0) ; El código de arranque invoca a memcpy para iniciar en RAM las variables enteras y a memset para definir en RAM el puntero a entero, iniciado con valor nulo. ; Segmento RAM, después de memcpy y memset ORG 00200h ; MSP430 Inicio RAM x: DW 00001h ; 200 y: DW 00002h ; 202 pi: DW 00000h ; 204 END Prof. Leopoldo Silva Bijit

11 La función main: main: mov.w #0x200, &pi ; pi = &x mov.w &pi, R15 ; temp=pi &y ; y = *temp; clr.w R12 ; urn(0) ; En los ejemplos a continuación se emplearán variables globales, ya que el direccionamiento hace referencia a los nombres de las variables, y de este modo es más sencillo seguir los ejemplos. Si se emplearan locales, habría que asociar variables a registros, y considerar que algunos pueden ser usados como variables temporales. Alternativas. Ilustra el uso de la instrucción compare y los saltos condicionales. ;if (v8>v7) v6++; else v5--; cmp.w &v8, &v7 jge else ; va a else si: &v8 <=&v7 inc.w &v6 jmp endif else: add.w #0xFFFF,&v5 endif: Luego de compilar la condición, mediante un salto condicional se genera el salto al bloque de acciones asociados al else. ;if (v8>=v7) v6++; else v5--; cmp.w &v7,&v8 jl else ; va a else si: &v7 > &v8 inc.w &v6 jmp endif else: add.w #0xFFFF,&v5 endif: ;if (v8<v7) v6++; else v5--; cmp.w &v7,&v8 jge else ; va a else si: &v7 <=&v8 inc.w &v6 jmp endif else: add.w #0xFFFF,&v5 endif: Prof. Leopoldo Silva Bijit

12 ;if (v8<=v7) v6++; else v5--; cmp.w &v8,&v7 jl else ; va a else si: &v8 > &v7 inc.w &v6 jmp endif else: add.w #0xFFFF,&v5 endif: ;if (v8==v7) v6++; else v5--; cmp.w &v7,&v8 jne else ; va a else si: &v7!= &v8 inc.w &v6 jmp endif else: add.w #0xFFFF,&v5 endif: ;if (v8!=v7) v6++; else v5--; cmp.w &v7,&v8 jeq else ; va a else si: &v7 == &v8 inc.w &v6 jmp endif else: add.w #0xFFFF,&v5 endif: Iteraciones. ;while (v8>v0) v0++; lazo: cmp.w &v8,&v0 jge endwhile ;termina iteración si &v8 <= &v0 inc.w &v0 jmp lazo endwhile: ;do {v1++; while (v8>v1); repeat: inc.w &v1 cmp.w &v8,&v1 jl repeat ;repite si &v8 > &v1 Prof. Leopoldo Silva Bijit

13 ; for(v8=0;v8<v7;v8++) v0--; clr.w &v8 testfor: cmp.w &v7,&v8 jge endfor ;termina si &v7 <= &v8 add.w #0xFFFF,&v0 inc.w &v8 jmp testfor endfor: Condicional. ;v8= (v7>v6)? v7 : v6; cmp.w &v7,&v6 jge else mov.w &v7,&v8 jmp fuera else: mov.w &v6,&v8 fuera: Switch. switch (v7) { case 1: case 2: v2++; break; case 3: v3--; break; default: v3=++v5; ;switch (v7) { mov.w &v7,r15 dec.w R15 jeq caso1 ;si es caso 1 dec.w R15 jeq caso2 ;si es 2 dec.w R15 jeq caso3 ;si es 3 jmp default caso1: Prof. Leopoldo Silva Bijit

14 caso2: inc.w &v2 ; v2++; jmp siga caso3: add.w #0xFFFF,&v3 ; v3--; jmp siga default: inc.w &v5 ; v3=++v5; mov.w &v5,&v3 ; siga: Break y Continue en iteraciones. ;for(v8=0 ;v8<10 ;v8++ ) { v6++; if(v6>8) break; v5++; clr.w &v8 testfor: cmp.w #0xA,&v8 jge endfor inc.w &v6 cmp.w #0x9,&v6 jge endfor ; es el break. Fuera del lazo. inc.w &v5 inc.w &v8 jmp testfor endfor: ;for(v8=0 ;v8<10 ;v8++ ) { v6++; if(v6>8) continue; v5++; clr.w &v8 testfor: cmp.w #0xA,&v8 jge endfor inc.w &v6 cmp.w #0x9,&v6 jge incfor ; es el continue. Al incremento del lazo inc.w &v5 incfor: inc.w &v8 jmp testfor endfor: Ejemplos de diseños de funciones. Ejemplo1. Sea una función f1 de tres variables. Prof. Leopoldo Silva Bijit

15 El llamado a la función en C, v5=f1(v8,v7,v6); Asumiendo que las variables locales están asociadas a registros: v5 con R9, v6 con R8, v7 con R11 y v8 con R10. Se pasa el valor de v6 en el tope del stack. Luego en R14 el valor de v7 y en R12 el valor de v8. La forma de pasar los argumentos es una política del compilador, que en el caso de pasar paso por registros depende de los que ya estén en uso. Es indispensable conocer ese orden para el diseño de la función. La compilación del llamado queda como sigue: ;v5=f1(v8,v7,v6); push.w R8 ;empuja tercer argumento mov.w R11,R14 ;pasa en R14 segundo argumento mov.w R10,R12 ;pasa en R12 primer argumento call #f1 incd.w sp ;recupera posición de sp dir: mov.w R12,R9 ;se asume valor de orno en R12 Después de invocar a f1, los frames en el stack pueden visualizarse según: sp dir valor v6 Fondo y tope del frame de f1 Tope del frame de función que llama a f1 Para compilar el llamado lo único que se necesita conocer es el prototipo de la función f1: int f1(int, int, int ); Si se desea incorporar el código de la función f1 en assembler, debe indicarse en el prototipo que su definición está en otro archivo. Esto se logra anteponiendo la palabra reservada extern, según se indica: exter int f1(int, int, int ); Esta declaración debe figurar, en el texto en C, antes del llamado. Para compilar la función se requiere su definición, y la forma en que se han pasado los argumentos. Prof. Leopoldo Silva Bijit

16 int f1(int a0, int a1, int a2) { a0=a1+a2; a1=a0+a2; urn(a0); f1: mov.w 0x2(SP),R15 ;deja en R15 el valor del argumento a2 mov.w R14,R13 ;en R14 se tiene a1 add.w R15,R13 ; R13 se usa como registro temporal mov.w R13,R12 ; en R12 se tiene a0 mov.w R12,R13 add.w R15,R13 mov.w R13,R14 Ejemplo 2. Si aumentamos el número de argumentos de la función, y también el número de variables locales en registros, tendremos una visualización de la política de asignación que el compilador utiliza para la asignación de registros. int f1(int a0,int a1,int a2,int a3, int a4) { a0=a1+a2+a3+a4; a1=a0+a2; urn(a0); int main(void) { register int v8=8,v7=7,v6=6,v5=5,v4=4,v3=3,v2=2,v1=1; v3=f1(v8,v7,v6,v5,v4); urn(0) ; main: push.w R10 ;salva registros que se usan en locales. push.w R11 push.w R8 push.w R9 push.w R6 push.w R7 Prof. Leopoldo Silva Bijit

17 push.w R4 push.w R5 mov.w #0x8,R7 ;inicio de locales mov.w #0x7,R10 mov.w #0x6,R11 mov.w #0x5,R8 mov.w #0x4,R9 mov.w #0x3,R6 mov.w #0x2,R5 mov.w #0x1,R4 push.w R9 ;paso de argumentos en frame. a4 push.w R8 ;a3 push.w R11 ;a2 mov.w R10,R14 ;al menos dos argumento se pasan en registros. a1 mov.w R7,R12 ;a0 call #f1 dr1: mov.w R12,R6 ; orno de f1 en R12 clr.w R12 ;orno de main. add.w #0x6,SP ;desarma frame de la función main pop.w R5 ;restaura registros usado en locales. pop.w R4 pop.w R7 pop.w R6 pop.w R9 pop.w R8 pop.w R11 pop.w R10 Frame de main en el stack, inmediatamente después de la invocación a f1. sp dr1 a2 a3 a4 R5 R4 R7 R6 R9 R8 R11 R10 dr0 Fondo del frame de f1 Tope del frame de main Fondo del frame de main Prof. Leopoldo Silva Bijit

18 Frame de f1, luego de salvar los registros R10 y R11(tipo save): sp 6 8 A R11 R10 dr1 a2 a3 a4 R5 R4 R7 R6 R9 R8 R11 R10 dr0 Tope del frame de f1 Fondo del frame de f1 Tope del frame de main Fondo del frame de main f1: push.w R10 ; salva R10 que ocupa para a4 push.w R11 ; salva R11 que usa como temporal mov.w 0x6(SP),R15 ; deja en R15 el argumento a2 mov.w 0x8(SP),R13 ; deja en R13 el argumento a3 mov.w 0xA(SP),R10 ; deja en R10 el argumento a4 mov.w R14,R11 add.w R15,R11 add.w R13,R11 add.w R10,R11 mov.w R11,R12 ; a0=a1+a2+a3+a4; mov.w R12,R11 add.w R15,R11 mov.w R11,R14 ; a1=a0+a2; pop.w R11 ;restaura salvados pop.w R10 Prof. Leopoldo Silva Bijit

19 Corrimientos aritméticos. Asumiendo variables globales, la traducción de los corrimientos por constante y por variable se ilustra a continuación: v8=v7<<3; /*corrimiento por constante */ v8=v7>>6; v8=v7>>v6; /*corrimiento por variable */ v8=v7<<v6; El assembler implementa algunas rotaciones como sumas. Además sólo rota un bit a la vez. Por ejemplo, empleando R12 como temporal, el desplazamiento con signo a la izquierda en tres posiciones puede compilarse según: mov.w rla.w rla.w rla.w mov.w &v7,r12 R12 R12 R12 R12,&v8 También pueden desarrollarse rutinas más generales, para corrimientos de 0 a 16 posiciones. Se ilustran los códigos, a continuación, generados por el compilador IAR. mov.w &v7,r12 call #?ShiftLeft16_3 mov.w R12,&v8 ; v8=v7<<3; mov.w &v7,r12 call #?ShiftRight16s_6 mov.w R12,&v8 ; v8=v7>>6; mov.w &v7,r12 mov.w &v6,r14 call #?ShiftRight16s mov.w R12,&v8 ; v8=v7>>v6; mov.w &v7,r12 mov.w &v6,r14 call #?ShiftLeft16 mov.w R12,&v8 ; v8=v7<<v6; Las rutinas tienen diversos puntos de entrada, de acuerdo al número de corrimientos que deben efectuarse. Prof. Leopoldo Silva Bijit

20 ; R12=R12>>R14?ShiftLeft16: lazoshlf: skipshlf?shiftleft16_7:?shiftleft16_6:?shiftleft16_5:?shiftleft16_4:?shiftleft16_3: tst.b R14 jeq skipshlf rla.w R12 dec.b R14 jne lazoshlf rla.w R12 rla.w R12 rla.w R12 rla.w R12 rla.w R12 rla.w R12 rla.w R12 A la derecha con signo:?shiftright8s: sxt R12?ShiftRight16s: tst.b R14 jeq skipshrt lazoshrt: rra.w R12 dec.b R14 jne lazoshrt skipshrt:?shiftright16s_7: rra.w R12?ShiftRight16s_6: rra.w R12?ShiftRight16s_5: rra.w R12?ShiftRight16s_4:?ShiftRight16s_3: rra.w R12 rra.w R12 rra.w R1 rra.w R12 Si las variables son sin signo, los llamados para corrimientos a la izquierda no cambian; pero los corrimientos a la derecha deben convertirse en rotaciones lógicas. Para corrimiento sin signo, se limpia el carry. A la derecha sin signo:?shiftright8u: and.b #0xFF,R12?ShiftRight16u: tst.b R14 jeq skipsru lazosru: clrc rrc.w R12 Prof. Leopoldo Silva Bijit

21 skipsru:?shiftright16u_7:?shiftright16u_6:?shiftright16u_5:?shiftright16u_4:?shiftright16u_3: dec.b R14 jne lazosru clrc rrc.w R12 clrc rrc.w R12 clrc rrc.w R12 clrc rrc.w R12 clrc rrc.w R12 rra.w R12 rra.w R12 Si el número de corrimientos es mayor que 15 el compilador debería generar un cero (cuestión que IAR realiza). También deberían tratarse en forma especial situaciones que podrían producir pérdidas del signo del número. División de enteros sin signo y con signo. La división de enteros sin signo se implementa mediante algoritmos usuales. El siguiente segmento ilustra el llamado mov.w &v7,r12 mov.w &v6,r14 call #?DivMod16u mov.w R12,&v8 ; v8=v7/v6;?divmod8u: and.b #0xFF,R12 ;para enteros sin signo de 8 bits and.b #0xFF,R14?DivMod16u: mov.w R14,R15 ;R12/R14 clr.w R14 mov.w #0x1,R13 rot1: bit.w #0x1,R13 rlc.w R12 rlc.w R14 cmp.w R15,R14 ;R14-R15 Prof. Leopoldo Silva Bijit

22 jnc rot2 sub.w R15,R14 rot2: rlc.w R13 jnc rot1 rra.w R13 rlc.w R12 La división con signo, determina el signo del resultado (dejando positivos los operandos) y efectúa la división sin signo. Luego coloca el signo del cuociente y el resto.?divmod8s: sxt R12 sxt R14?DivMod16s: push.w R9 clr.w R9 tst.w R14 jge test1 inv.w R14 inc.w R14 bis.w #0x1,R9 test1: tst.w R12 jge test2 inv.w R12 inc.w R12 inv.w R9 test2: call #?DivMod16u bit.w #0x1,R9 jeq set1 inv.w R12 inc.w R12 set1: bit.w #0x2,R9 jeq set2 inv.w R14 inc.w R14 set2: pop.w R9 Prof. Leopoldo Silva Bijit

23 Multiplicación de enteros con signo. El microcontrolador tiene una unidad aritmética que efectúa multiplicación de enteros. En caso de multiplicaciones por potencias de dos, es más eficiente realizar la multiplicación mediante sumas que utilizar el hardware de multiplicación. ;v8=v7*2; mov.w rla.w mov.w &v7,r15 R15 R15,&v8 ; v8=v7*v6; mov.w mov.w call mov.w &v7,r12 &v6,r14 #?Mul16Hw R12,&v8?Mul8Hw: and.b #0xFF,R12 ;operandos de 8 bits and.b #0xFF,R14?Mul16Hw: push.w SR dint ;no se puede interrumpir nop mov.w R12,&MPY mov.w R14,&OP2 mov.w &RESLO,R12 mov.w &RESHI,R13 ;orno en R12 y R13 i PC ;recupera SR Operaciones lógicas. Se implementan con cortocircuitos y asignan valores 0 y 1. ; v8=v7&&v6; tst.w &v7 jeq esfalso ;primer operando falso tst.w &v6 jeq esfalso mov.b #0x1,R15 ;ambos verdaderos jmp esverdad Prof. Leopoldo Silva Bijit

24 esfalso: clr.b R15 esverdad: and.w #0xFF,R15 mov.w R15,&v8 ;v7=v6 v5; tst.w &v6 jne yaesverdad tst.w &v5 jeq esfalso ;ambos son falsos yaesverdad: mov.b #0x1,R15 jmp esverdad esfalso: clr.b R15 esverdad: and.w #0xFF,R15 mov.w R15,&v7 v7=!v6; tst.w &v6 jne argverdad mov.b #0x1,R15 ;setea a uno jmp setvalor argverdad: clr.b R15 setvalor: and.w #0xFF,R15 mov.w R15,&v7 Se ilustra la composición de una expresión. ;v8=(v7&&v6)&&v5; tst.w &v7 jeq esfalso tst.w &v6 jeq esfalso tst.w &v5 jeq esfalso mov.b #0x1,R15 jmp setvalor esfalso: clr.b R15 setvalor: and.w #0xFF,R15 mov.w R15,&v8 Prof. Leopoldo Silva Bijit