Programacin avanzada en Ensamblador

Cesreo Fernndez Martnez lvaro Snchez Miralles

Tareas que realiza el programa ensamblador

Traduce el fuente .a66 a cdigo mquina .obj
mov Rx, Ry
F0
Cdigo de instruccin Escribir programa en el editor
Fichero *.a66

x y
Nmero de GPR

mov reg, #dato

E6
Cdigo de instruccin

reg
Nmero de SFR

dato
Ensamblador

Nmero de 16 bits

Cdigo mquina Libreras .obj Fichero *.obj

Resuelve los valores de las etiquetas

Lleva un contador direcciones en memoria de las instrucciones. La etiqueta toma el valor de la direccin de memoria de la instruccin asociada
Enlazar
Cdigo mquina Fichero *.

Ejecutar

Ttulo Presentacin - 2

Ejemplo de ensamblador
Las etiquetas facilitan la programacin en ASS

Etiquetas (op)

bucle:

MOV MOV MOV MOV CMP JMPR ADD ADD JMPS

R0,#0 0xfa00,R0 R0,#1 R1,#1 R0,#5 cc_sgt,fin 0xfa00,R1 R0,#1 bucle

; ; ; ; ; ; ;

r0 (i) auxiliar if i>N then goto fin j += 1 i += 1 = jmpr cc_uc,

fin:

Instruccin

Operandos

Comentarios (opcional)

Ttulo Presentacin - 3

Nmeros con y sin signo

Un nmero negativo es el que sumado a el mismo positivo da como resultado 0. Cmo hacerlo?
Ejemplo en 16 bits: 0xFFFF + 0x0001 = 0x0000 (ya que el resultado no cabe en 16 bits)
Nmero + 0x0001 (1) 0x0002 (2) 0x0003 (3) Nmero 0xFFFF (-1) 0xFFFE (-2) 0xFFFD (-3)

Ejemplo en 8 bits: 0xFF + 0x01 = 0x00 (ya que el resultado no cabe en 8 bits)

Ttulo Presentacin - 4

Nmeros con y sin signo

Aritmtica en Coma fija complemento a 2
Nmeros positivos: bit ms significativo (bit 15) a 0. Nmeros negativos: bit ms significativo (bit 15) a 1.

nmero _ negativo = 2 nmero _ de _ bits nmero _ positivo 0 xFFFE = 216 0 x0002

Overflow (Flag V del registro PSW)
Cuando operando dos nmeros positivos se obtiene un nmero negativo 0x7FFF + 0x0001 = 0x8000 (Overflow; V = 1) 0x7FFE + 0x0001 = 0x7FFF (V = 0)

Carry (Flag C del registro PSW)

Cuando operando dos nmeros no cabe el resultado en 16 bits 0x8000 + 0x8000 = 0x0000 (Carry; C = 1) 0x8000 + 0x7FFF = 0xFFFF (C = 0)
Ttulo Presentacin - 5

Nmeros con y sin signo

Cmo se calcula un nmero negativo?
En decimal se aplica la formula cual es el negativo de 2 en 8 bits?

nmero _ negativo = 2 nmero _ de _ bits nmero _ positivo 254 = 28 2

En binario o hexadecimal (0000 0010 B) Se hace el complemento a 1 del nmero (1111 1101 B) Se le suma uno (1111 1110 B) El nmero negativo de 2 en 8 bits es el 254 0xFE 11111110B.

Como el micro slo entiende de 0's y 1's cuando hay un nmero en la memoria (por ejemplo 1111 1110) Qu significa?
Si se interpreta con signo es el nmero negativo de 2 -2 Si se interpreta sin signo es el nmero 254 Depende del programador y de las instrucciones que use el que le da una interpretacin u otra.
Ttulo Presentacin - 6

Instruccin MOV.
Directo a registro
MOV r0,r1 r0,#3 r0,0fa00H r0,[r1] r0,[r1+] r0,[-r1] r0,[r1+#4] rl0,#3 rh0,[r1+] ; R0 <- R1 ; R0 <- 3 (no olvidar # !) ; R0 <- Mem[fa00 H] ; R0 <- Mem[R1] (R1 Puntero) ; R0 <- Mem[R1], R1 <- R1 + 2 ; R1 <- R1 - 2, R0 <- Mem[R1] ; R0 <- Mem[R1+#4] ; R0 <- 3 ; R0 <- Mem[R1], R1 <- R1 + 1

Inmediato
MOV MOV MOV MOV MOV MOV MOVB MOVB

directo a memoria Indirecto (normal, post-incremento, pre-decremento)

A nivel de byte

Ttulo Presentacin - 7

Mov con extensin de signo.

Extensin de signo
MOVBZ Carga el byte en parte baja, extiende (a los 16 bits) con ceros
MOVBZ MOVBZ R0,#0xFF ; r0 <- 0x00FF R0,#-1 ; r0 <- 255 no respeta el signo

MOVBS Carga el byte en parte baja, extiende (a los 16 bits) con bit de signo
MOVBS MOVBS R0,#0xFF ; r0 <- 0xFFFF R0,#-1 ; r0 <- -1 respeta el signo

8 bits con signo 0xFF 0x80 -1 -128

8 bits sin signo 255 128

16 sin extender signo 255 (0x00FF) 128 (0x0080)

16 bits extendiendo signo -1 (0xFFFF) -128 (0xFF80)

Ttulo Presentacin - 8

Programando con etiquetas (para datos)

La pseudoinstruccin EQU permite dar nombres a los distintos datos de programa
Variables (posiciones de memoria, ej 0fa00h)
var1 var2 equ equ MOVB MOVB MOVB MOVB 0fa00h 0fa01h RL0,var1 RL1,var2 var2,RL0 var1,RL1

Constantes
el_uno equ MOVB 1 RL0,#el_uno

Cmo se sabe si el 1 es una constante o una variable?

Ttulo Presentacin - 9

Little/Big Endian
En la operacin (16 bits)
mov r0,0fa00H ; R0 <- Mem[fa00 H]

Little-Endian: el byte (8 bits) almacenado en la posicin

0fa00H
Va a la PARTE BAJA del REGISTRO (a RL0) El byte almacenado en 0xfa01 va a la PARTE ALTA (RH0)

El C167 es un Little-Endian En los procesadores MOTOROLA

Al revs En ambos casos NO se permite extraer un word (16 bits) de una direccin impar de memoria.

Ttulo Presentacin - 10

Instrucciones aritmticas
Instruccin ADD
Suma a nivel de word (16b) Ej: ADD Rx, op ; Rx <- Rx + op

MOV MOV ADD ADD

R0,#0x0001 0xFA00,R0 R0,#0x0009 0xFA00,R0

Qu vale R0?

Instruccin ADDB
Suma a nivel de byte
MOV ADDB R0,#0x0001 Rh0,#0x01

Qu vale R0?

Ttulo Presentacin - 11

Instrucciones aritmticas
Instruccin SUB
Resta a nivel de word (16b) Ej: SUB Rx, op
MOV MOV SUB ADD R0,#0x01FF 0xFA00,R0 R0,#0x0009 0xFA00,R0

; Rx <- Rx - op

Qu vale R0?

Instruccin SUBB
Resta a nivel de byte
MOV SUBB R0,#0x01FF Rh0,#0x01

Qu vale R0?

Ttulo Presentacin - 12

Instrucciones aritmticas
Instruccin NEG
Complemento a dos de un nmero Un cambio de signo NEG Rx ; Rx <- 0 - Rx
MOV NEG R0,#0x01FF R0

Qu vale R0?

Instruccin NEGB
Cambio de signo a nivel de byte
MOV NEGB R0,#0x01FF Rl0

Qu vale R0?

Ttulo Presentacin - 13

Instrucciones aritmticas
Instruccin MUL
Multiplica dos nmeros con signo Resultado en 32 bits en el registro MD MDL: Parte baja de MD (16 bits). MDH: Parte alta de MD (16 bits). MUL Rx, Ry ; [MDH, MDL] <- Rx * Ry

Instruccin MULU
Multiplica dos nmeros sin signo

MOV MOV MUL MOV MOV MULU

R0,#0xFFFF R1,#0xFFFF R0,R1 R2,MDL R3,MDH R0,R1

Qu vale MDL, MDH, R2 y R3?

Ttulo Presentacin - 14

Instrucciones aritmticas
Instruccin DIV
Divide dos nmeros (MDL y un GPR) con signo Resultado en dos registros de 16 bits MDL: Almacena el cociente de la divisin (16 bits). MDH: Almacena el resto de la divisin (16 bits). DIV Rx ; MDL <- MDL / Rx MDH <- MDL mod Rx

Instruccin DIVU
Divide dos nmeros sin signo
MOV MOV MOV DIV MOV MOV MOV MOV DIVU R3,#0xFFFF MDL,R3 R0,#0x0001 R0 R1,MDL R2,MDH R3,#0xFFFF MDL,R3 R0

Qu vale MDL, MDH, R1 y R2?

Ttulo Presentacin - 15

Instrucciones lgicas
Instruccin AND
Realiza un AND bit a bit de dos nmeros Ej: AND Rx, op ; Rx <- Rx and op

MOV AND

R0,#0x0001 R0,#0x0009

Qu vale R0?

Sirve como mscara: una especie de filtro para seleccionar nicamente ciertos bits de un registro
Se quiere poner el bit 1 del registro R0 a 0. O lo que es lo mismo, se seleccionan el resto de bits del registro R0

AND

R0,#0xFFFD

Ttulo Presentacin - 16

Instrucciones lgicas
Instruccin OR
Realiza un OR bit a bit de dos nmeros Ej: OR Rx, op ; Rx <- Rx or op
MOV OR R0,#0x0001 R0,#0x0009

Qu vale R0?

Sirve como mscara: una especie de filtro para seleccionar nicamente ciertos bits de un registro
Se quiere poner el bit 1 del registro R0 igual que el bit 1 del registro R1.
AND MOV AND OR OR R0,#0x0002

Se quiere poner el bit 1 del registro R0 a 1. O lo que es lo mismo, se seleccionan el resto de bits del registro R0

R0,#0xFFFD R2,R1 R2,#0x0002 R0,R2

; ; ; ;

se pone a 0 el bit 1 de R0 para no modificar R1 se selecciona el bit 1 de R2 R0.1 = R2.1 = R1.1

Ttulo Presentacin - 17

Instrucciones lgicas
Instruccin XOR
Realiza un XOR bit a bit de dos nmeros Ej: XOR Rx, op ; Rx <- Rx xor op
MOV XOR R0,#0x0101 R0,#0xFFFF

Si se usa con 0xFFFF se cambian todos los bits de un registro

; R0 <- 0xFEFE

Instruccin CPL
Realiza el complemento a 1 de un nmero CPL Rx ; Rx <- complemento a 1 de Rx

MOV CPL

R0,#0x0101 R0

; R0 <- 0xFEFE

Ttulo Presentacin - 18

Desplazamientos
SHL (SHift Left) o SHR (SHift Right)
SHL Rx, #num Desplaza num veces a la izquierda los bits de Rx SHL Rx, Ry Desplaza a la izquierda Rx, el nmero de posiciones indicadas en Ry Introduce ceros por la derecha
MOV SHL R0,#0x0001 R0,#9

Qu vale R0? Se quiere poner el bit 1 del registro R0 igual que el bit 0 del registro R1.

0
AND MOV AND SHL OR

Rx 16 bits

C
; ; ; ; ;

R0,#0xFFFD R2,R1 R2,#0x0001 R2,#1 R0,R2

se pone a 0 el bit 1 de R0 para no modificar R1 se selecciona el bit 0 de R2 el bit 0 pasa a ser el bit 1 R0.1 = R2.1 = R1.1

Ttulo Presentacin - 19

Rotaciones
ROL (ROtate Left) o ROR (ROtate Right)
ROL Rx, #num Desplaza num veces a la izquierda los bits de Rx Rota los bits usando el bit de carry C ROL Rx, Ry Desplaza a la izquierda Rx, el nmero de posiciones indicadas en Ry Rota los bits usando el bit de carry C Rx 16 bits

Qu vale R0?

MOV ROL

R0,#0x8001 R0,#9

Ttulo Presentacin - 20

10

Control de flujo de programa. Saltos.

Comparacin
Ej: CMP Rx, Ry ; Actualiza PSW como una resta Rx - Ry

Saltos
JMPR va precedido de CMP (compara), de forma que despus de comparar se realiza el salto segn una condicin.
CMP JMPR .... R0,R1 cc_ugt,next

;si R0 > R1

JMPR: Jmpr Jmpr Jmpr Jmpr Jmpr Jmpr ...

next:

cc_eq, dir (equal, salta si igual) cc_uc, dir (unconditional, salta siempre) cc_ne, dir (not equal, salta si no igual) cc_ugt, dir (unsigned greater than) cc_sgt, dir (signed greater than) cc_ule, dir (unsigned less or equal)

Ttulo Presentacin - 21

Saltos a nivel de bit

Salto si el bit est a 1
JB bit, dir
SFRs acceso bit a bit SFRs SFRs
FE00 FF00 FFFF

Salto si el bit est a 0

JNB bit, dir

Consideraciones
Slo en zonas bit a bit No necesitan CMP antes
RAM

Acceso bit a bit

FD00

GPRs
FC00

STACK
F600

JB .... next:

C,next

;si C = 1 salta next

Ttulo Presentacin - 22

11

move a nivel de bit

Poner un bit a 1
BSET bit ; bit = 1

Poner un bit a 0
BCLR bit ; bit = 0

Mover un bit Lgicas (a nivel de bit)

;activa bit 1 del P2 BSET P2.1 ; BCLR C ; Carry = 0 BMOV V,C ; V=C

BMOV bit1, bit2 ; bit1 = bit2 BAND bit1, bit2 ; bit1 <- bit1 and bit2 BOR bit1, bit2 ; bit1 <- bit1 or bit2 BXOR bit1, bit2 ; bit1 <- bit1 xor bit2

Consideraciones
Slo en zonas bit a bit

Ttulo Presentacin - 23

C y Ensamblador
if ( )
Alto nivel
if (a == b) ...; else ...;

Ensamblador
MOV R0,a CMP R0,b JMPR cc_ne,else ; condicin if .. JMPR cc_uc,endif ; condicin else ..

else: endif:

Ttulo Presentacin - 24

12

Bucles
for ( )
Alto nivel
for (i=START; i <= STOP; i++){ a = STOP - i;

Ensamblador

for:

test: next:

MOV MOV SUB JMPR MOV SUB ADD CMP JMPR

R0,#START R1,#STOP R1,R0 cc_uc,test a,R1 R1,#1 R0,#1 R0,#STOP cc_slt,for

; r0 (i) ; r1 (STOP-START)

; i += 1 ; i <= STOP

Ttulo Presentacin - 25

Otro ejemplo
while ( )
Alto nivel
i = 0; while (i<10) { a[i] = i; i += 1; }

Ensamblador
MOV MOV MOV CMP JMPR MOV ADD ADD JMPR R0,#0 ; R0 es i R1,#1 ; es el incremento de i R2,#0xfa00 ;R2 almacena la direccin de memoria de a R0,#10 cc_sge,next [R2],R0 R0,R1 R2,#2 cc_uc,otro

otro:

next:

Ttulo Presentacin - 26

13

Directivas. Pseudoinstrucciones
Las directivas a usar en el while anterior :
maxdata $nonsegmented equ 0x10 ; constante section data at 200H dsw 10 ; array de datos ends section proc MOV MOV MOV CMP JMPR MOV ADD ADD JMPR NOP endp ends end code at 300H NEAR R0,#0 R1,#1 R2,#j R0,#maxdata cc_sge,next [R2],R0 R0,R1 R2,#2 cc_uc,otro

Seccin de datos D100 en direccin 0x200

D100 j D100 ej ej1

Procedimiento ej1 Seccin de cdigo ej en direccin 0x300

otro:

next: ej1 ej

Final de programa

Ttulo Presentacin - 27

Directivas. Pseudoinstrucciones
El ensamblador de Keil (Siemens) no tiene ORG ! Section: Comienzo de una seccin

De cdigo (programa) datos, a partir de una POS de memoria Ends: Cierra la seccin

Proc : Comienzo de un procedimiento (subrutina/funcin)

Endp: Cierra el procedimiento

dsw: Reserva espacio para un word (dsb: para un byte) equ: Fuera de las secciones
Define una constante/variable (para esto ltimo se prefiere dsw)

Ttulo Presentacin - 28

14

Subrutinas (funciones)
f(x), ejemplo pow2(x)
Alto nivel
pot = pow2(n);

Ensamblador

MOV call . . Pow2: MOV SHL RET

R1,#n pow2

; main ; llamada (pow2)

R0,#1 R0,R1

; 2^n ; Vuelta a main

Ttulo Presentacin - 29

Subrutinas: stack
Cmo se encuentra la direccin de vuelta de una subrutina?
Est almacenada en el STACK

CALL
SP <- SP - 2 ; SP (Stack Pointer) (SP) <- IP SP SP ; almacena la dir de vuelta en el stack
FC00 FBFE FC00

SP FBFE IP IP <- pow2 ; IP apunta a la direccin de pow2 (primera instruccin)

RET
IP <- (SP)
FC00 FBFE IP

SP

SP <- SP + 2 ;Todo queda como estaba antes de llamar a pow2

FC00 FBFE

SP SP
Ttulo Presentacin - 30

15

Push y Pop
PUSH R0
SP <- SP - 2 SP SP
FC00 FBFE R0

FC00 FBFE

(SP) <- R0 ; guarda R0 en el stack

SP

POP R0
R0 <- (SP)
FC00 FBFE R0

SP
FC00 FBFE

SP SP

SP <- SP + 2 ; recupera R0 (vaca stack)

Push y Pop sirven para poder reutilizar los GPRs en las funciones llamadas (dentro de la funcin se comportan como las variables locales de C)

Ttulo Presentacin - 31

16