Ensamblador x86. Ing. Jorge Castro-Godínez

Transcripción

1 Ensamblador x86 Lección 4 Ing. Jorge Castro-Godínez MT7003 Microprocesadores y Microcontroladores Área de Ingeniería Mecatrónica Instituto Tecnológico de Costa Rica I Semestre 2014 Jorge Castro-Godínez Ensamblador x86 1 / 45

2 Contenido Instrucción mov 1 Instrucción mov 2 3 Jorge Castro-Godínez Ensamblador x86 2 / 45

3 3 tipos de instrucciones Transferencia de datos entre memoria y registros Carga o load: de memoria a registros %reg = Mem[address] Almacenamiento o store: de registro a memoria. Mem[address] = %reg Recordar que la memoria es como un arreglo indexado Funciones aritméticas con datos en registros o en memoria. Transferencia de control Saltos incondicionales desde o hacia procedimientos. Saltos condicionales. Jorge Castro-Godínez Ensamblador x86 3 / 45

4 Moviendo datos: IA32 (1) movx source,destination x puede ser b, w, l movl src,dest: mueve 4 bytes, long word movw src,dest: mueve 2 bytes, word movb src,dest: mueve 1 bytes, byte Estas instrucciones son muy comunes en un código típico. %eax %ecx %edx %ebx %esi %edi %esp %ebp Jorge Castro-Godínez Ensamblador x86 4 / 45

5 Moviendo datos: IA32 (2) Tipos de operandos Inmediatos: dato constante entero. $0x400, $-533 Parecido a C, pero con $ como prefijo. Registro: uno de ocho registros. %eax, %edx Recordar que %esp, %ebp están reservados para propósitos específicos. Para algunas instrucciones en particular, los otros registros tienen una funcionalidad especial, e.g., multiplicaciones y divisiones. Memoria: x cantidad de bytes de la memoria direccionados por el valor de un registro. El ejemplo más simple ( %eax) Existen varios modos de direccionamiento. Jorge Castro-Godínez Ensamblador x86 5 / 45

6 Combinaciones de movl Source Dest Src,Dest C Analog Imm Reg Mem movl $0x4,%eax movl $-147,(%eax) var_a = 0x4; *p_a = -147; movl Reg Reg Mem movl %eax,%edx movl %eax,(%edx) var_d = var_a; *p_d = var_a; Mem Reg movl (%eax),%edx var_d = *p_a; No se pueden realizar transferencias entre direcciones de memoria en una sola instrucción! Jorge Castro-Godínez Ensamblador x86 6 / 45

7 Modos básicos de direccionamiento Indirecto (R) Mem[Reg[R]] Registro R especifica la dirección de memoria. movl ( %ecx), %eax Desplazamiento D(R) Mem[Reg[R]+D] Registro R especifica la dirección de memoria, e.g., el inicio de alguna región de memoria. D especifica un desplasamiento de la dirección dada por R (es un offset). movl 8( %ebp), %edx Jorge Castro-Godínez Ensamblador x86 7 / 45

8 Swap (1) void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } swap: pushl %ebp movl %esp,%ebp pushl %ebx movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) Set Up Body movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret Finish Jorge Castro-Godínez Ensamblador x86 8 / 45

9 Swap (2) void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } Register %ecx %edx %eax %ebx Value yp xp t1 t0 Offset yp xp Rtn adr Old %ebp Stack (in memory) %ebp movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx Old %ebx Jorge Castro-Godínez Ensamblador x86 9 / 45

10 Swap (3) %eax %edx %ecx %ebx %esi %edi %esp %ebp 0x104 yp xp movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) Offset %ebp x120 0x124 Rtn adr Address 0x124 0x120 0x11c 0x118 0x114 0x110 0x10c 0x108 0x104 0x100 # ecx = yp # edx = xp # eax = *yp (t1) # ebx = *xp (t0) # *xp = eax # *yp = ebx Jorge Castro-Godínez Ensamblador x86 10 / 45

11 Swap (4) %eax %edx %ecx %ebx %esi %edi %esp %ebp 0x124 0x120 0x104 yp xp movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) Offset %ebp x120 0x124 Rtn adr Address 0x124 0x120 0x11c 0x118 0x114 0x110 0x10c 0x108 0x104 0x100 # ecx = yp # edx = xp # eax = *yp (t1) # ebx = *xp (t0) # *xp = eax # *yp = ebx Jorge Castro-Godínez Ensamblador x86 11 / 45

12 Swap (5) %eax %edx %ecx %ebx %esi %edi %esp %ebp 456 0x124 0x120 0x104 yp xp movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) Offset %ebp x120 0x124 Rtn adr Address 0x124 0x120 0x11c 0x118 0x114 0x110 0x10c 0x108 0x104 0x100 # ecx = yp # edx = xp # eax = *yp (t1) # ebx = *xp (t0) # *xp = eax # *yp = ebx Jorge Castro-Godínez Ensamblador x86 12 / 45

13 Swap (6) %eax %edx %ecx %ebx %esi %edi %esp %ebp 456 0x124 0x x104 yp xp movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) Offset %ebp x120 0x124 Rtn adr Address 0x124 0x120 0x11c 0x118 0x114 0x110 0x10c 0x108 0x104 0x100 # ecx = yp # edx = xp # eax = *yp (t1) # ebx = *xp (t0) # *xp = eax # *yp = ebx Jorge Castro-Godínez Ensamblador x86 13 / 45

14 Swap (7) %eax %edx %ecx %ebx %esi %edi %esp %ebp x124 0x x104 yp xp movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) Offset %ebp x120 0x124 Rtn adr Address 0x124 0x120 0x11c 0x118 0x114 0x110 0x10c 0x108 0x104 0x100 # ecx = yp # edx = xp # eax = *yp (t1) # ebx = *xp (t0) # *xp = eax # *yp = ebx Jorge Castro-Godínez Ensamblador x86 14 / 45

15 Swap (8) %eax %edx %ecx %ebx %esi %edi %esp %ebp 456 0x124 0x x104 yp xp movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) Offset %ebp x120 0x124 Rtn adr Address 0x124 0x120 0x11c 0x118 0x114 0x110 0x10c 0x108 0x104 0x100 # ecx = yp # edx = xp # eax = *yp (t1) # ebx = *xp (t0) # *xp = eax # *yp = ebx Jorge Castro-Godínez Ensamblador x86 15 / 45

16 Modos de Direccionamiento (1) Las direcciones usadas para accesar memoria en mov y otras instrucciones, pueden ser calculadas de diferentes maneras. Forma general: D(Rb,Ri,S) Mem[Reg[Rb] + S*Reg[Ri] + D] D: Desplazamiento constante en 1, 2 o 4 bytes. Rb: Registro base: cualquiera de los 8 registros Ri: Registro índice: cualquiera de los registros, excepto %esp. S: Escala; 1, 2, 4 o 8 Jorge Castro-Godínez Ensamblador x86 16 / 45

17 Modos de Direccionamiento (2) Casos especiales: puede ser cualquer combinación de D, Rb, Ri y S. (Rb,Ri) Mem[Reg[Rb] + Reg[Ri]] D(Rb,Ri) Mem[Reg[Rb] + Reg[Ri] + D] (Rb,Ri,S) Mem[Reg[Rb] + S*Reg[Ri]] Jorge Castro-Godínez Ensamblador x86 17 / 45

18 Ejemplos Instrucción mov %edx %ecx 0xf000 0x100 (Rb,Ri) D(,Ri,S) (Rb,Ri,S) D(Rb) Mem[Reg[Rb]+Reg[Ri]] Mem[S*Reg[Ri]+D] Mem[Reg[Rb]+S*Reg[Ri]] Mem[Reg[Rb] +D] Expression Address Computation Address 0x8(%edx) 0xf x8 0xf008 (%edx,%ecx) 0xf x100 0xf100 (%edx,%ecx,4) 0xf *0x100 0xf400 0x80(,%edx,2) 2*0xf x80 0x1e080 Jorge Castro-Godínez Ensamblador x86 18 / 45

19 Cálculo de una dirección leal src,dest src es la expresión del modo de direccionamiento. dest tendrá la dirección calculada por la expresión lea: load effective address Ejemplo: leal ( %edx, %ecx,4), %eax Esta instrucción puede ser usada para realizar operaciones de la forma: x + k*i Jorge Castro-Godínez Ensamblador x86 19 / 45

20 Operaciones aritméticas Format Computation addl Src,Dest Dest = Dest + Src subl Src,Dest Dest = Dest - Src imull Src,Dest Dest = Dest * Src sall Src,Dest Dest = Dest << Src Also called shll sarl Src,Dest Dest = Dest >> Src Arithmetic shrl Src,Dest Dest = Dest >> Src Logical xorl Src,Dest Dest = Dest ^ Src andl Src,Dest Dest = Dest & Src orl Src,Dest Dest = Dest Src Watch out for argument order! (especially subl) Jorge Castro-Godínez Ensamblador x86 20 / 45

21 Operaciones aritméticas incl Dest Dest = Dest + 1 decl Dest Dest = Dest - 1 negl Dest Dest = -Dest notl Dest Dest = ~Dest Jorge Castro-Godínez Ensamblador x86 21 / 45

22 leal en operaciones aritméticas (1) int arith (int x, int y, int z) { int t1 = x+y; int t2 = z+t1; int t3 = x+4; int t4 = y * 48; int t5 = t3 + t4; int rval = t2 * t5; return rval; } arith: pushl %ebp movl %esp,%ebp movl 8(%ebp),%eax movl 12(%ebp),%edx leal (%edx,%eax),%ecx leal (%edx,%edx,2),%edx sall $4,%edx addl 16(%ebp),%ecx leal 4(%edx,%eax),%eax imull %ecx,%eax movl %ebp,%esp popl %ebp ret Set Up Body Finish Jorge Castro-Godínez Ensamblador x86 22 / 45

23 leal en operaciones aritméticas (2) int arith (int x, int y, int z) { int t1 = x+y; int t2 = z+t1; int t3 = x+4; int t4 = y * 48; int t5 = t3 + t4; int rval = t2 * t5; return rval; } Offset movl 8(%ebp),%eax # eax = x movl 12(%ebp),%edx # edx = y leal (%edx,%eax),%ecx # ecx = x+y (t1) leal (%edx,%edx,2),%edx # edx = y + 2*y = 3*y sall $4,%edx # edx = 48*y (t4) addl 16(%ebp),%ecx # ecx = z+t1 (t2) leal 4(%edx,%eax),%eax # eax = 4+t4+x (t5) imull %ecx,%eax # eax = t5*t2 (rval) z y x Rtn adr Old %ebp Stack %ebp Jorge Castro-Godínez Ensamblador x86 23 / 45

27 leal en operaciones aritméticas (6) arith int arith (int x, int y, int z) { int t1 = x+y; int t2 = z+t1; int t3 = x+4; int t4 = y * 48; int t5 = t3 + t4; int rval = t2 * t5; return rval; } Instructions in different order from C code Some expressions require multiple instructions Some instructions cover multiple expressions Get exact same code when compile: (x+y+z)*(x+4+48*y) movl 8(%ebp),%eax # eax = x movl 12(%ebp),%edx # edx = y leal (%edx,%eax),%ecx # ecx = x+y (t1) leal (%edx,%edx,2),%edx # edx = y + 2*y = 3*y sall $4,%edx # edx = 48*y (t4) addl 16(%ebp),%ecx # ecx = z+t1 (t2) leal 4(%edx,%eax),%eax # eax = 4+t4+x (t5) imull %ecx,%eax # eax = t5*t2 (rval) Jorge Castro-Godínez Ensamblador x86 27 / 45

28 Otro ejemplo (1) int logical(int x, int y) { int t1 = x^y; int t2 = t1 >> 17; int mask = (1<<13) - 7; int rval = t2 & mask; return rval; } logical: pushl %ebp movl %esp,%ebp movl 8(%ebp),%eax xorl 12(%ebp),%eax sarl $17,%eax andl $8185,%eax movl %ebp,%esp popl %ebp ret Set Up Body Finish movl 8(%ebp),%eax # eax = x xorl 12(%ebp),%eax # eax = x^y sarl $17,%eax # eax = t1>>17 andl $8185,%eax # eax = t2 & 8185 Offset 12 8 y x Stack 4 Rtn adr 0 Old %ebp %ebp Jorge Castro-Godínez Ensamblador x86 28 / 45

29 Otro ejemplo (2) int logical(int x, int y) { int t1 = x^y; int t2 = t1 >> 17; int mask = (1<<13) - 7; int rval = t2 & mask; return rval; } logical: pushl %ebp movl %esp,%ebp movl 8(%ebp),%eax xorl 12(%ebp),%eax sarl $17,%eax andl $8185,%eax movl %ebp,%esp popl %ebp ret Set Up Body Finish movl 8(%ebp),%eax eax = x xorl 12(%ebp),%eax eax = x^y (t1) sarl $17,%eax eax = t1>>17 (t2) andl $8185,%eax eax = t2 & 8185 Jorge Castro-Godínez Ensamblador x86 29 / 45

30 Otro ejemplo (3) int logical(int x, int y) { int t1 = x^y; int t2 = t1 >> 17; int mask = (1<<13) - 7; int rval = t2 & mask; return rval; } logical: pushl %ebp movl %esp,%ebp movl 8(%ebp),%eax xorl 12(%ebp),%eax sarl $17,%eax andl $8185,%eax movl %ebp,%esp popl %ebp ret Set Up Body Finish movl 8(%ebp),%eax eax = x xorl 12(%ebp),%eax eax = x^y (t1) sarl $17,%eax eax = t1>>17 (t2) andl $8185,%eax eax = t2 & 8185 Jorge Castro-Godínez Ensamblador x86 30 / 45

31 Otro ejemplo (4) int logical(int x, int y) { int t1 = x^y; int t2 = t1 >> 17; int mask = (1<<13) - 7; int rval = t2 & mask; return rval; } 2 13 = 8192, = , logical: pushl %ebp movl %esp,%ebp movl 8(%ebp),%eax xorl 12(%ebp),%eax sarl $17,%eax andl $8185,%eax movl %ebp,%esp popl %ebp ret Set Up Body Finish movl 8(%ebp),%eax eax = x xorl 12(%ebp),%eax eax = x^y (t1) sarl $17,%eax eax = t1>>17 (t2) andl $8185,%eax eax = t2 & 8185 Jorge Castro-Godínez Ensamblador x86 31 / 45

32 Condicionales Un salto condicional es suficiente para implementar la mayoría de construcciones de control de flujo presentes en lenguajes de alto nivel. if (condicion) then {...} else {...} while (condicion) then {...} do {...} while (condicion) for (inicializacion;condicion;iterativo) {...} Saltos incondicionales también implementan estructuras relativas a control de flujo. Tanto saltos condicionales como incondicionales se referencian como saltos. Jorge Castro-Godínez Ensamblador x86 32 / 45

33 Saltos Instrucción mov Instrucciones jx: saltar a una parte diferente del código dependiendo de las condiciones. jx Condition Description jmp 1 Unconditional je ZF Equal / Zero jne ~ZF Not Equal / Not Zero js SF Negative jns ~SF Nonnegative jg ~(SFÔF)&~ZF Greater (Signed) jge ~(SFÔF) Greater or Equal (Signed) jl (SFÔF) Less (Signed) jle (SFÔF) ZF Less or Equal (Signed) ja ~CF&~ZF Above (unsigned) jb CF Below (unsigned) Jorge Castro-Godínez Ensamblador x86 33 / 45

34 Estado del procesador (parcialmente) Información acerca del estado actual de la ejecución de un programa. %eax %ecx %edx %ebx %esi %edi %esp %ebp %eip General purpose registers Current stack top Current stack frame Instruction pointer CF ZF SF OF Condition codes Jorge Castro-Godínez Ensamblador x86 34 / 45

35 Códigos Condicionales - establecidos impĺıcitamente Registros de un solo bit. CF: bandera de acarreo (carry) ZF: bandera de cero SF: bandera de signo (para datos con signo) OF: bandera de desbordamiento (overflow) Establecidos impĺıcitamente por operaciones aritméticas. E.g., addl src,dest t = a + b CF es uno si se da un acarreo proveniente de los bits más significativos (desbordamiento sin signo) ZF es uno si t == 0 SF es uno si t < 0 OF es uno si se da un desbordamiento con datos con signo La instrucción lea no afecta estas banderas. Jorge Castro-Godínez Ensamblador x86 35 / 45

36 Códigos Condicionales - establecidos expĺıcitamente Establecidos expĺıcitamente por la instrucción de comparación. E.g., cmpl src1,src2 cmpl b,a es como a-b sin tener ningún destino del resultado. CF es uno si se da un acarreo del bit más significativo (usado en comparaciones sin signo). ZF es uno si a == b SF es uno si (a-b) < 0 (con signo). OF es uno si se da un desbordamiento con datos con signo. Jorge Castro-Godínez Ensamblador x86 36 / 45

37 Códigos Condicionales - establecidos expĺıcitamente Establecidos expĺıcitamente por la instrucción de prueba (test). E.g., testl src1,src2 testl b,a es como a & b sin tener ningún destino del resultado. Establece los códigos de condición basado en los valores de scr1 y scr2. Útil para tener uno de los operandos como una máscara. ZF es uno si a && b == 0 SF es uno si a & b < 0 Jorge Castro-Godínez Ensamblador x86 37 / 45

38 Ejemplo de salto condicional (1) int absdiff(int x, int y) { int result; if (x > y) { result = x-y; } else { result = y-x; } return result; } absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx movl 12(%ebp), %eax cmpl %eax, %edx jle.l7 subl %eax, %edx movl %edx, %eax.l8: leave ret.l7: subl %edx, %eax jmp.l8 Setup Body1 Finish Body2 Jorge Castro-Godínez Ensamblador x86 38 / 45

39 Ejemplo de salto condicional (2) int absdiff(int x, int y) { int result; if (x > y) { result = x-y; } else { result = y-x; } return result; } int goto_ad(int x, int y) { int result; if (x <= y) goto Else; result = x-y; Exit: return result; Else: result = y-x; goto Exit; } Jorge Castro-Godínez Ensamblador x86 39 / 45

40 Ejemplo de salto condicional (3) int goto_ad(int x, int y) { int result; if (x <= y) goto Else; result = x-y; Exit: return result; Else: result = y-x; goto Exit; } int x int y %edx %eax absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx movl 12(%ebp), %eax cmpl %eax, %edx jle.l7 subl %eax, %edx movl %edx, %eax.l8: leave ret.l7: subl %edx, %eax jmp.l8 Jorge Castro-Godínez Ensamblador x86 40 / 45

45 Direccionamiento relativo al PC Saltos relativos al PC son reubicados Aquellos saltos con posiciones absolutas no pueden ser reubicados. 0x100 cmp r2, r3 0x1000 0x102 je 0x70 0x1002 0x104 0x1004 0x172 add r3, r4 0x1072 Jorge Castro-Godínez Ensamblador x86 45 / 45