02 Nivel Maquina 3 Procedimientosx2

14/10/2011
Grado Informática, 2º Curso Estructura de Computadores
Programación a Nivel‐Máquina III:

Sentencias switch y Procedimientos IA32
Estructura de Computadores
Semana 4
Bibliografía:
[BRY11] Cap.3 Computer Systems: A Programmer’s Perspective. Bryant, O’Hallaron. Pearson, 2011
Signatura ESIIT/C.1 BRY com
Transparencias del libro CS:APP, Cap.3

Introduction to Computer Systems: a Programmer’s Perspective
Autores: Randal E. Bryant y David R. O’Hallaron
Guía de trabajo autónomo (4h/s)

 Lectura: del Cap.3 CS:APP (Bryant/O’Hallaron)
 Switch Statements, Procedures.
– 3.6.7 ‐ 3.7 pp.247‐266 (3.7.1 – 3.7.2 sugeridos previamente)
 Ejercicios: del Cap.3 CS:APP (Bryant/O’Hallaron)

 Probl. 3.28 ‐ 3.34 pp.251‐52, 257‐58, 262, 265‐66
Bibliografía:
1
14/10/2011
Progr. Máquina III: switch/Procedimientos

 Sentencias switch
 Procedimientos IA 32
 Estructura de la Pila
 Convenciones de Llamada
 Ejemplos ilustrativos de Recursividad & Punteros
long switch_eg
(long x, long y, long z) Ejemplo de sentencia
{
long w = 1; switch
switch(x) {
case 1:
w = y*z;  Etiquetas de caso múltiples
break;  Aquí: 5 & 6
case 2:
w = y/z;  Caídas en cascada*
/* Fall Through */  Aquí: 2
case 3:
w += z;  Casos ausentes*
break;  Aquí: 4
case 5:
case 6:
w -= z;
break;
default:
w = 2;
}
return w;
}
* “fall through cases”, “missing cases”, en inglés 4
2
14/10/2011
Estructura de una Tabla de Saltos

Forma switch Tabla Saltos* Destinos salto*
switch(x) { JTab: Targ0
Targ0: Code Block
case val_0: 0
Block 0 Targ1
case val_1: Targ2 Targ1: Code Block
Block 1 •
••• 1
•
case val_n-1: •
Block n–1 Targ2: Code Block
} Targn-1
2
•
Traducción Aproximada •
target = JTab[x]; * •
g
goto *target;
g
Targn-1: Code Block
n–1
* “jump table”, “jump targets”, en inglés 5
Ejemplo de Sentencia Switch (IA32)

long switch_eg(long x, long y, long z)
{
long w = 1;
switch(x) {
. . .
} ¿Qué rango de
return w; valores cubre
}
default?
Inicialización*:
switch_eg:
pushl %ebp # Setup
movl %esp, %ebp # Setup
movl 8(%ebp), %eax # %eax = x
cmpl $6, %eax # Compare x:6
ja .L2 # If unsigned > goto default
jmp *.L7(,%eax,4) # Goto *JTab[x] Notar que w no
* “setup” = ajuste inicial, “unsigned >” = “above” = mayor sin signo
se inicializa aquí 6
3
14/10/2011
Ejemplo de Sentencia Switch (IA32)

long switch_eg(long x, long y, long z)
{
long w = 1;
switch(x) {
. . .
Tabla de saltos
.section .rodata
}
.align 4
return w; .L7:
} .long .L2 # x = 0
.long .L3 # x = 1
.long .L4 # x = 2
Inicialización: .long .L5 # x = 3
.long .L2 # x = 4
switch_eg: .long .L6 # x = 5
pushl %ebp # Setup .long .L6 # x = 6
movl %esp, %ebp # Setup
movl 8(%ebp), %eax # eax = x
cmpl $6, %eax # Compare x:6
Salto jmp *.L7(,%eax,4) # Goto *JTab[x]
indirecto
* “Ln” = “Label n” = etiqueta (de salto) n 7
Explicación Inicialización Ensamblador

 Estructura de la Tabla Tabla de saltos
 Cada destino salto requiere 4 bytes .section .rodata
 Dirección base es .L7 .align 4
.L7:
.long .L2 # x = 0
.long .L3 # x = 1
 Saltos .long .L4 # x = 2
 Directo: jmp .L2 .long .L5 # x = 3
.long .L2 # x = 4
 Destino salto indicado por etiqueta .L2 .long .L6 # x = 5
.long .L6 # x = 6
 Indirecto: jmp *.L7(,%eax,4)
 Inicio de la tabla de saltos: .L7
 Se debe escalar por factor 4 (etiquetas tienen 32‐bits = 4 Bytes en IA32)
 Captar destino (dir. salto) desde la Dirección Efectiva .L7 + eax*4
 Sólo para 0 ≤ x ≤ 6
4
14/10/2011
Tabla de Saltos
Tabla de saltos
switch(x) {
.section .rodata case 1: // .L3
.align 4 w = y*z;
.L7:
break;
.long .L2 # x = 0
.long .L3 # x = 1 case 2: // .L4
.long .L4 # x = 2 w = y/z;
.long .L5 # x = 3 /* Fall Through */
.long .L2 # x = 4 case 3: // .L5
.long .L6 # x = 5 w += z;
.long .L6 # x = 6 break;
case 5:
case 6: // .L6
w -= z;
break;
default: // .L2
w = 2;
}
Tratamiento de Caídas en Cascada

long w = 1;
case 3:
. . .
w = 1;
switch(x) {
goto merge;
. . .
case 2:
w = y/z;
/* Fall Through */
case 3: case 2:
w += z; w = y/z;
break;
. . . merge:
} w += z;
10
5
14/10/2011
Bloques de Código (Parcial)

switch(x) { .L2: # Default
case 1: // .L3 movl $2, %eax # w = 2
w = y*z; jmp .L8 # Goto done
break;
. . . .L5: # x == 3
case 3: // .L5 movl $1, %eax # w = 1
w += z; jmp .L9 # Goto merge
break;
. . . .L3: # x == 1
default: // .L2 movl 16(%ebp), %eax # z
w = 2; imull 12(%ebp), %eax # w = y*z
} jmp .L8 # Goto done
11
Bloques de Código (Resto)

switch(x) { .L4: # x == 2
. . . movl 12(%ebp), %edx
case 2: // .L4 movl %edx, %eax
w = y/z; sarl $31, %edx
/* Fall Through */ idivl 16(%ebp) # w = y/z
merge: // .L9
w += z; .L9: # merge:
break; addl 16(%ebp), %eax # w += z
case 5: jmp .L8 # goto done
case 6: // .L6
w -= z; .L6: # x == 5, 6
break; movl $1, %eax # w = 1
} subl 16(%ebp), %eax # w = 1-z
12
6
14/10/2011
Código switch (Final)

.L8: # done:
return w;
popl %ebp
ret
 Características notables
 La tabla de saltos ahorra secuenciar a través de los casos
 Tiempo constante, en vez de lineal
 Usar la tabla de saltos para gestionar huecos y etiquetas múltiples*
 Usar secuenciación del programa para gestionar caída en cascada
 No inicializar w = 1 a menos de que realmente se necesite
* ver pág.4 13
Implementación switch x86‐64

 Misma idea general, adaptada a código 64‐bit
 Entradas tabla de 64 bits (punteros)
 Casos usan código actualiz. x86‐64
Tabla Saltos
switch(x) { .section .rodata
case 1: // .L3 .align 8
w = y*z; .L7:
break; .quad .L2 # x = 0
. . . .quad .L3 # x = 1
} .quad .L4 # x = 2
.quad .L5 # x = 3
.quad .L2 # x = 4
.L3:
.quad .L6 # X = 5
movq %rdx, %rax
.quad .L6 # x = 6
imulq %rsi, %rax
ret
14
7
14/10/2011
Código Objeto IA32

 Inicialización
 Etiqueta .L2 se convierte en dirección 0x8048422
 Etiqueta .L7 se convierte en dirección 0x8048660
Código Ensamblador
switch_eg:
. . .
jmp *.L7(,%eax,4) # Goto *JTab[x]
Código Objeto Desensamblado

08048410 <switch_eg>:
. . .
8048419: 77 07 ja 8048422 <switch_eg+0x12>
804841b: ff 24 85 60 86 04 08 jmp *0x8048660(,%eax,4)
15
Código Objeto IA32 (cont.)

 Tabla de Saltos
 No aparece en código desensamblado
 Se puede inspeccionar usando GDB
 gdb switch
 (gdb) x/7xw 0x8048660
 Examinar 7 (formato) hexadecimal (palabras) “words” (4‐bytes cada)
 Usar el comando “help x” para obtener documentación de formatos
0x8048660: 0x08048422 0x08048432 0x0804843b 0x08048429

0x8048670: 0x08048422 0x0804844b 0x0804844b
16
8
14/10/2011
Código Objeto IA32 (cont.)

 Descifrando la Tabla de Saltos
0x8048660: 0x08048422 0x08048432 0x0804843b 0x08048429
0x8048670: 0x08048422 0x0804844b 0x0804844b
Dirección Valor x
0x8048660 0x8048422 0
0x8048664 0x8048432 1
0x8048668 0x804843b 2
0x804866c 0x8048429 3
0x8048670 0x8048422 4
0x8048674 0x804844b 5
0x8048678 0x804844b 6
17
Destinos desensamblados
8048422: b8 02 00 00 00 mov $0x2,%eax
8048427: eb 2a jmp 8048453 <switch_eg+0x43>
8048429: b8 01 00 00 00 mov $0x1,%eax
804842e: 66 90 xchg %ax,%ax # noop
8048430: eb 14 jmp 8048446 <switch_eg+0x36>
8048432: 8b 45 10 mov 0x10(%ebp),%eax
8048435: 0f af 45 0c imul 0xc(%ebp),%eax
8048439: eb 18 jmp 8048453 <switch_eg+0x43>
804843b: 8b 55 0c mov 0xc(%ebp),%edx
804843e: 89 d0 mov %edx,%eax
8048440: c1 fa 1f sar $0x1f,%edx
8048443: f7 7d 10 idivl 0x10(%ebp)
8048446: 03 45 10 add 0x10(%ebp),%eax
8048449: eb 08 jmp 8048453 <switch_eg+0x43>
804844b: b8 01 00 00 00 mov $0x1,%eax
8048450: 2b 45 10 sub 0x10(%ebp),%eax
8048453: 5d pop %ebp
8048454: c3 ret
18
9
14/10/2011
Emparejando destinos desensamblados

8048422: mov $0x2,%eax
8048427: jmp 8048453 <switch_eg+0x43>
8048429: mov $0x1,%eax
804842e: xchg %ax,%ax
Valor 8048430: jmp 8048446 <switch_eg+0x36>
8048432: mov 0x10(%ebp),%eax
0x8048422 8048435: imul 0xc(%ebp),%eax
8048439: jmp 8048453 <switch_eg+0x43>
0x8048432 804843b: mov 0xc(%ebp),%edx
0x804843b 804843e: mov %edx,%eax
8048440: sar $0x1f,%edx
0x8048429 8048443: idivl 0x10(%ebp)
8048446: add 0x10(%ebp),%eax
0x8048422 8048449: jmp 8048453 <switch_eg+0x43>
804844b: mov $0x1,%eax
0x804844b 8048450: sub 0x10(%ebp),%eax
0x804844b 8048453: pop %ebp
8048454: ret
19
long switch_eg
(long x, long y, long z)
{
long w = 1;
switch(x) {
case 1:
w = y*z;
break;
case 2:
w = y/z;
/* Fall Through */
case 3:
w += z;
break;
case 5:
case 6:
w -= z;
break;
default:
w = 2;
}
return w;
}
20
10
14/10/2011
Resumen (Control)
 Control C
 if‐then‐else
 do‐while
 while, for
 switch
 Control Ensamblador
 Salto condicional
 Movimiento condicional
 Salto indirecto
 Compilador genera secuencia código p/implementar control más complejo
 Técnicas estándar
 Bucles convertidos a forma do‐while
 Sentencias switch grandes usan tablas de saltos
 Sentencias switch poco densas podrían usar árboles decisión
21

22
11
14/10/2011
Pila IA32
“Fondo” de Pila **
 Región de memoria gestionada
con disciplina de pila
 Crece hacia posiciones inferiores Direcciones
Crecientes
 El registro %esp contiene

la dirección más baja* de la pila
 dirección del elemento “tope”
La Pila
crece hacia
“Abajo”
Puntero de Pila: %esp
“Tope” de Pila
* por el momento, en el instante actual,

y es la dirección del byte más bajo de los 4B que ocupa el elemento tope ** “top” = tope, “bottom” = fondo 23
Pila IA32: Push

“Fondo” Pila
 pushl Src
 Capta el operando en Src
 Decrementa %esp en 4 Direcciones
Crecientes
 Escribe operando en dir.*indicada por %esp
La Pila
crece hacia
“Abajo”
Puntero Pila: %esp
‐4
“Tope” Pila
* ocupando por tanto ese byte (el más bajo) y los 3 inmediatamente encima ** “push” = empujar 24
12
14/10/2011
Pila IA32 : Pop

“Fondo” Pila
 popl Dest
 Capta operando de dir. indicada por %esp
 Incrementa %esp en 4 Direcciones
Crecientes
 Escribe el operando en Dest
La Pila
crece hacia
+4 “Abajo”
Puntero Pila: %esp
“Tope” Pila
* “pop” = saltar (con pequeño ruido explosivo), salir 25
Flujo de Control para Procedimientos

 Se usa pila para soportar llamadas y retornos de procedimientos
 Llamada a procedimiento: call label
 Recuerda* la dirección de retorno en la pila
 Salta a etiqueta label
 Dirección de retorno:
 Dirección de la siguiente instrucción justo después de la llamada (call)
 Ejemplo de un desensamblado
804854e: e8 3d 06 00 00 call 8048b90 <main>
8048553: 50 pushl %eax
 Dirección de retorno = 0x8048553
 Retorno de procedimiento: ret
 Recupera* la dirección (de retorno) de la pila
 Salta a dicha dirección
* usando “push/pop” 26
13
14/10/2011
Ejemplo de Llamada a Procedimiento

804854e: e8 3d 06 00 00 call 8048b90 <main>
8048553: 50 pushl %eax
call 8048b90
0x110 0x110
0x10c 0x10c
0x108 123 0x108 123
0x104 0x8048553
%esp 0x108 %esp 0x104
%eip 0x804854e %eip 0x8048b90
%eip: contador de programa

27
Ejemplo de Retorno de Procedimiento

8048591: c3 ret
ret
0x110 0x110
0x10c 0x10c
0x108 123 0x108 123
0x104 0x8048553 0x8048553
%esp 0x104 %esp 0x108
%eip 0x8048591 %eip 0x8048553
%eip: contador de programa * notar que dir.ret. sigue escrita en memoria, pero más allá del tope,
así que ya no se considera que esté en la pila (que sea elemento válido pila) 28
14
14/10/2011
Lenguajes basados en pila*

 Lenguajes que soportan recursividad
 P.ej., C, Pascal, Java
 El código debe ser “Reentrante”
Múltiples instanciaciones** simultáneas de un mismo procedimiento

 Se necesita algún lugar para guardar el estado de cada instanciación
 Argumentos
 Variables locales
 Puntero (dirección) de retorno
 Disciplina de pila
 Estado para un procedimiento dado, necesario por tiempo limitado
Desde que se le llama hasta que retorna
 El invocado† retorna antes de que lo haga el invocante†
 La pila se reserva en Marcos†† † “callee/caller” en inglés
 estado para una sola instanciación procedimiento †† “allocated in frames” en inglés
* “block structured” en terminología Intel
** “instantiate” = crear nuevos ejemplares 29
Ejemplo de secuencia de llamadas

Ejemplo
yoo(…) Sec. Llamadas
{
• yoo
• who(…)
who(); { who
• • • •
• amI();
} amI(…) amI amI
• • • {
amI(); •
• • • amI
•
} amI();
• amI
•
}
El procedimiento amI() es recursivo
* “call chain” en inglés

“yoo” suena a “you” = tú, “who” = quién, “am I” = soy yo 30
15
14/10/2011
Marcos de Pila
Marco
 Contenido Anterior
 Información para retorno
Puntero de Marco: %ebp
 Espacio temporal
Marco para
proc
Puntero de Pila: %esp
 Gestión
 Espacio se reserva al entrar el procedimiento “Tope” Pila
 Código de “Inicialización”*
 Se libera al retornar
 Código de “Finalización” *
* “ajuste inicial/fin” en desensamblados y dibujos pila anteriores 31
Pila
Ejemplo
yoo(…) yoo
%ebp
{
yoo
yoo
• who %esp
•
who();
• amI amI
•
} amI
amI
32
16
14/10/2011
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
who
• • • •
amI(); %ebp
who();
• • • • amI amI who
• amI(); %esp
} • • •
} amI
amI
33
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
amI(…) who
• • • •
{
amI();
who();
• • •• • amI amI who
•
amI();
•
• •amI();
• %ebp
}
} • amI amI
• %esp
}
amI
34
17
14/10/2011
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
amI(…) who
• • • •
{
amI();
who();amI(…)
• who
• • • {• amI amI
•
• amI();•
• amI();
• •
}
} • • amI amI
• amI();
} • %ebp
• amI
} amI
%esp
35
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
amI(…) who
• • • •
{
amI();
who(); amI(…)
• • •• {• amI amI who
•
• amI();• amI(…)
} • •amI();
• {
} • • • amI amI
• amI();
} • •
• amI(); amI
} • amI
•
} %ebp
amI
%esp
36
18
14/10/2011
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
amI(…) who
• • • •
{
amI();
who();amI(…)
• who
• • • {• amI amI
•
• amI();•
• amI();
• •
}
} • • amI amI
• amI();
} • %ebp
• amI
} amI
%esp
37
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
amI(…) who
• • • •
{
amI();
who();
•
amI();
•
• •amI();
• %ebp
}
} • amI amI
• %esp
}
amI
38
19
14/10/2011
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
who
• • • •
amI(); %ebp
who();
• amI(); %esp
} • • •
} amI
amI
39
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
amI(…) who
• • • •
{
amI();
who();
•
amI();
•
• •amI();
• %ebp
}
} • amI amI
• %esp
}
amI
40
20
14/10/2011
Pila
Ejemplo
yoo(…) yoo
{ who(…)
•{ yoo
yoo
who
• • • •
amI(); %ebp
who();
• amI(); %esp
} • • •
} amI
amI
41
Pila
Ejemplo
yoo
yoo(…) %ebp
{ yoo
yoo
• who %esp
•
who(); amI amI
•
•
} amI
amI
42
21
14/10/2011
Marco de Pila IA32/Linux

 Marco de Pila Actual (de “Tope” a Fondo)
 “Preparación de argumentos”:
Parámetros para función a punto llamar Marco del
Invocante
Si no se pueden mantener en registros* Argumentos
 Contexto (de registros) salvado Puntero de Marco Dir. Retorno
 Antiguo puntero de marco %ebp Ant. %ebp
Registros
 Marco de Pila del Invocante Salvados
+
 Dirección de retorno Variables
 Salvada por la instrucción call Locales
 Argumentos para esta llamada (invocación)
Preparación
… Puntero de Pila
Argumentos
%esp
* Si el compilador no puede resolver la compilacion del procedimiento usando sólo registros 43
Volviendo a ver swap

Llamando a swap desde call_swap
int course1 = 15213; call_swap:
int course2 = 18243; • • •
subl $8, %esp
void call_swap() { movl $course2, 4(%esp)
swap(&course1, &course2); movl $course1, (%esp)
} call swap
• • •
Pila
void swap(int *xp, int *yp) • Resultante
{ •
int t0 = *xp; •
int t1 = *yp; %esp
*xp = t1;
&course2 subl
*yp = t0;
} &course1 %esp
call
Dir. ret. %esp
44
22
14/10/2011
Volviendo a ver swap

swap:
pushl %ebp
void swap(int *xp, int *yp) movl %esp, %ebp Ajuste
{ pushl %ebx Inicial
int t0 = *xp;
int t1 = *yp; movl 8(%ebp), %edx
*xp = t1; movl 12(%ebp), %ecx
*yp = t0; movl (%edx), %ebx Cuerpo
} movl (%ecx), %eax
movl %eax, (%edx)
movl %ebx, (%ecx)
popl %ebx
popl %ebp Fin
ret
45
swap Ajuste #1
Pila a la Entrada Pila Resultante
%ebp %ebp
• •
• •
• •
&course2 yp
&course1 xp
Dir. ret. %esp Dir. ret.
Ant. %ebp %esp
swap:
pushl %ebp
movl %esp,%ebp
pushl %ebx
46
23
14/10/2011
swap Ajuste #2
%ebp
• •
• •
• •
&course2 yp
&course1 xp
%ebp
Ant. %ebp %esp
swap:
pushl %ebp
movl %esp,%ebp
pushl %ebx
47
swap Ajuste #3
%ebp
• •
• •
• •
&course2 yp
&course1 xp
Ant. %ebp %ebp
Ant. %ebx %esp
swap:
pushl %ebp
movl %esp,%ebp
pushl %ebx
48
24
14/10/2011
swap Cuerpo
%ebp
• •
• •
• •
Offset relativo a %ebp
&course2 12 yp
&course1 8 xp
Dir. ret. %esp 4 Dir. ret.
Ant. %ebp %ebp
Ant. %ebx %esp
movl 8(%ebp),%edx # obtener xp

movl 12(%ebp),%ecx # obtener yp
. . .
49
swap Fin
Pila antes de Fin Pila Resultante
%ebp
• •
• •
• •
yp yp
xp xp
Dir. ret. Dir. ret. %esp
Ant. %ebp %ebp
Ant. %ebx %esp  Observación
 Se salva y recupera registro %ebx
...  No sucede así con %eax, %ecx, %edx
popl %ebx
popl %ebp
ret 50
25
14/10/2011
Desensamblado de swap
08048384 <swap>:
8048384: 55 push %ebp
8048385: 89 e5 mov %esp,%ebp
8048387: 53 push %ebx
8048388: 8b 55 08 mov 0x8(%ebp),%edx
804838b: 8b 4d 0c mov 0xc(%ebp),%ecx
804838e: 8b 1a mov (%edx),%ebx
8048390: 8b 01 mov (%ecx),%eax
8048392: 89 02 mov %eax,(%edx)
8048394: 89 19 mov %ebx,(%ecx)
8048396: 5b pop %ebx
8048397: 5d pop %ebp
8048398: c3 ret
Código Llamada
80483b4: movl $0x8049658,0x4(%esp) # Copiar &course2
80483bc: movl $0x8049654,(%esp) # Copiar &course1
80483c3: call 8048384 <swap> # Llamar swap
80483c8: leave # Preparar retorno
80483c9: ret # Retornar
* LEAVE deshace ENTER previo: ESP←EBP, POP EBP. 51
52
26
14/10/2011
Convenciones de Preservación de Registros*

 Cuando el procedimiento yoo llama a who:
 yoo es el que llama (invocante, llamante)
 who es el llamado (invocado)
 ¿Se puede usar un registro para almacenamiento temporal?
yoo: who:
• • • • • •
movl $15213, %edx movl 8(%ebp), %edx
call who addl $18243, %edx
addl %edx, %eax • • •
• • • ret
ret
 Contenidos del registro %edx sobrescritos por who

 Podría causar problemas ➙ ¡debería hacerse algo!
 Necesita alguna coordinación
* “register saving conventions” en inglés 53
Convenciones de Preservación de Registros

 Cuando el procedimiento yoo llama a who:
 yoo es el que llama (invocante, llamante)
 who es el llamado (invocado)
 ¿Se puede usar un registro para almacenamiento temporal?
 Convenciones*
 “Salva Invocante”
 El que llama salva valores temporales en su marco antes de la llamada
 “Salva Invocado”
 El llamado salva valores temporales en su marco antes de reusar regs.
* “caller/callee save” en inglés 54
27
14/10/2011
Uso de Registros en IA32/Linux+Windows

 %eax, %edx, %ecx
%eax
 Invocante salva antes de llamada Temporales
si los valores se usan después S‐Invocante %edx
%ecx
 %eax %ebx
 tb. usado para devolver v. entero Temporales
S‐Invocado %esi
%edi
 %ebx, %esi, %edi
 Invocado salva si quiere usarlos %esp
Especiales
%ebp
 %esp, %ebp
 forma especial de invocado‐salva
 Restaurados a su valor original al
salir del procedimiento
* Consultar Wikipedia: “X86 calling conventions”, cdecl/stdcall 55

56
28
14/10/2011
Función Recursiva pcount_r:

pushl %ebp
/* Recursive popcount */ movl %esp, %ebp
int pcount_r(unsigned x) { pushl %ebx
if (x == 0) subl $4, %esp
return 0; movl 8(%ebp), %ebx
else return movl $0, %eax
(x & 1) + pcount_r(x >> 1); testl %ebx, %ebx
} je .L3
movl %ebx, %eax
shrl %eax
movl %eax, (%esp)
 Registros call pcount_r
 %eax, %edx usados sin salvarlos movl %ebx, %edx
primero andl $1, %edx
leal (%edx,%eax), %eax
 %ebx usado, pero salvado al .L3:
principio & restaurado al final addl $4, %esp
popl %ebx
popl %ebp
ret
* “population count”, ver pág.38 lección anterior 57
pcount_r:
Función Recursiva #1 pushl %ebp
movl %esp, %ebp
/* Recursive popcount */ pushl %ebx
int pcount_r(unsigned x) { subl $4, %esp
if (x == 0) movl 8(%ebp), %ebx
return 0; • • •
else return
(x & 1) + pcount_r(x >> 1);
}
•
•
•
 Acciones
 Salvar en pila antiguo valor %ebx x
 Reservar espacio para argumento Dir. ret.
de llamada recursiva
Ant. %ebp %ebp
 Almacenar x en %ebx
Ant. %ebx
%ebx x %esp
58
29
14/10/2011
Función Recursiva #2 • • •
movl $0, %eax
/* Recursive popcount */ testl %ebx, %ebx
int pcount_r(unsigned x) { je .L3
if (x == 0) • • •
return 0; .L3:
else return • • •
(x & 1) + pcount_r(x >> 1); ret
}
 Acciones
 Si x == 0, retornar
 con %eax puesto a 0
%ebx x
59
Función Recursiva #3 • • •
movl %ebx, %eax
/* Recursive popcount */ shrl %eax
int pcount_r(unsigned x) { movl %eax, (%esp)
if (x == 0) call pcount_r
return 0; • • •
else return
(x & 1) + pcount_r(x >> 1);
}
 Acciones •
•
 Almacenar (pasar) x >> 1 en pila •
 Hacer llamada recursiva
 Efecto Dir. ret.
 %eax puesto a resultado función Ant. %ebp %ebp
 %ebx aún tiene valor de x Ant. %ebx
x >> 1 %esp
%ebx x
60
30
14/10/2011
Función Recursiva #4
/* Recursive popcount */ • • •
int pcount_r(unsigned x) { movl %ebx, %edx
if (x == 0) andl $1, %edx
return 0; leal (%edx,%eax), %eax
else return • • •
(x & 1) + pcount_r(x >> 1);
}
 Asumir
 %eax contiene valor de llam. recursiva
 %ebx contiene x %ebx x
 Acciones
 Calcular (x & 1) + valor retornado
 Efecto
 %eax puesto a resultado función
61
Función Recursiva #5
/* Recursive popcount */ • • •
int pcount_r(unsigned x) { L3:
if (x == 0) addl $4, %esp
return 0; popl %ebx
else return popl %ebp
(x & 1) + pcount_r(x >> 1); ret
}
%ebp
 Acciones
• •
 Restaurar valores de • •
%ebx y %ebp • •
 Restaurar %esp %esp
Dir. ret.
Ant. %ebp %ebp
%ebx
Ant. %ebx
%esp Ant. %ebx
62
31
14/10/2011
Observaciones Sobre la Recursividad

 Manejada sin Especiales Consideraciones
 Marcos pila implican que cada llamada a función tiene almcnmto. privado
Registros & variables locales salvadas

Dirección de retorno salvada

 Convenciones preservación registros previenen que una llamada a función
corrompa los datos de otra
 Disciplina de pila sigue el patrón de llamadas / retornos
 Si P llama a Q, entonces Q retorna antes que P
 Primero en entrar, último en salir (Last‐In, First‐Out)*
 También funciona con recursividad mutua**

 P llama a Q; Q llama a P
* pila = lista LIFO

** funciona incluso con reentrancia 63
Código para Punteros

Generando un Puntero
/* Compute x + 3 */
int add3(int x) {
int localx = x;
incrk(&localx, 3);
return localx;
}
Referenciando un Puntero
/* Increment value by k */
void incrk(int *ip, int k) {
*ip += k;
}
 add3 crea un puntero y se lo pasa a incrk

* Los autores que dicen “references” (no “pointers”), llaman “dereferencing” (no “referencing”) a la operación de seguir el puntero 64
32
14/10/2011
Creando e Inicializando Variable Local

int add3(int x) {  La variable localx debe almacenarse
int localx = x; en la pila
incrk(&localx, 3);
return localx;  Porque: Hay que crear puntero a ella
}  Calcular puntero como ‐4(%ebp)
8 x
4 Dir. ret.
0 Ant. %ebp %ebp
Parte inicial de add3
-4 localx = x
add3:
pushl%ebp -8
movl %esp, %ebp -12 Sin usar
subl $24, %esp # Alloc. 24 bytes
movl 8(%ebp), %eax -16
movl %eax, -4(%ebp) # Set localx to x -20
-24 %esp
65
Creando Puntero para Argumento

int add3(int x) {  Usar instrucción leal para calcular
int localx = x; dirección de localx
incrk(&localx, 3);
return localx;
}
8 x
4 Dir. ret.
0 Ant. %ebp %ebp
Parte intermedia de add3
-4 localx
movl $3, 4(%esp) # 2nd arg = 3
leal -4(%ebp), %eax # &localx -8
movl %eax, (%esp) # 1st arg = &localx -12 Sin usar
call incrk
-16
-20 3 %esp+4
-24 %esp
66
33
14/10/2011
Recuperando variable local

int add3(int x) {  Recuperar localx de la pila como
int localx = x; valor de retorno
incrk(&localx, 3);
return localx;
}
8 x
4 Dir. ret.
0 Ant. %ebp %ebp
Parte final de add3
-4 localx
movl -4(%ebp), %eax # Return val= localx
leave -8
ret -12 Sin usar
-16
-20
-24 %esp
67
Resumen (Procedimientos en IA 32)

 Puntos Importantes
 Pila es la estructura de datos correcta para
llamada / retorno procedimientos Marco del
Invocante
 Si P llama a Q, entonces Q retorna antes que P
Argumentos
 Recursividad (& recursividad mutua) con
mismas convenciones de llamada normales Dir. Retorno
%ebp Ant. %ebp
 Se pueden almacenar valores tranquilamente en el
marco de pila local y en registros salva‐invocado Registros
 Poner argumentos de la función en tope de pila Salvados
+
 Devolver resultado en %eax
Variables
 Punteros son direcciones de valores Locales
 Global o en pila
Preparación
Argumentos
%esp
68
34
14/10/2011
Guía de trabajo autónomo (4h/s)

 Estudio: del Cap.3 CS:APP (Bryant/O’Hallaron)
 Switch Statements, Procedures.
– 3.6.7 ‐ 3.7 pp.247‐266
 Probl. 3.28 ‐ 3.34 pp.251‐52, 257‐58, 262, 265‐66
Bibliografía:
69
35

02 Nivel Maquina 3 Procedimientosx2

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

02 Nivel Maquina 3 Procedimientosx2

Cargado por

Copyright:

Formatos disponibles

14/10/2011

Grado Informática, 2º Curso Estructura de Computadores

Programación a Nivel‐Máquina III:

Transparencias del libro CS:APP, Cap.3

Grado Informática, 2º Curso Estructura de Computadores

Guía de trabajo autónomo (4h/s)

 Ejercicios: del Cap.3 CS:APP (Bryant/O’Hallaron)

Grado Informática, 2º Curso Estructura de Computadores

Progr. Máquina III: switch/Procedimientos

Grado Informática, 2º Curso Estructura de Computadores

Grado Informática, 2º Curso Estructura de Computadores

Estructura de una Tabla de Saltos

Grado Informática, 2º Curso Estructura de Computadores

Ejemplo de Sentencia Switch (IA32)

Grado Informática, 2º Curso Estructura de Computadores

Ejemplo de Sentencia Switch (IA32)

Grado Informática, 2º Curso Estructura de Computadores

Explicación Inicialización Ensamblador

Grado Informática, 2º Curso Estructura de Computadores

Grado Informática, 2º Curso Estructura de Computadores

Tratamiento de Caídas en Cascada

Grado Informática, 2º Curso Estructura de Computadores

Bloques de Código (Parcial)

Grado Informática, 2º Curso Estructura de Computadores

Bloques de Código (Resto)

Grado Informática, 2º Curso Estructura de Computadores

Código switch (Final)

Grado Informática, 2º Curso Estructura de Computadores

Implementación switch x86‐64

Grado Informática, 2º Curso Estructura de Computadores

Código Objeto IA32

Código Objeto Desensamblado

Grado Informática, 2º Curso Estructura de Computadores

Código Objeto IA32 (cont.)

0x8048660: 0x08048422 0x08048432 0x0804843b 0x08048429

Grado Informática, 2º Curso Estructura de Computadores

Código Objeto IA32 (cont.)

Grado Informática, 2º Curso Estructura de Computadores

Grado Informática, 2º Curso Estructura de Computadores

Emparejando destinos desensamblados

Grado Informática, 2º Curso Estructura de Computadores

Grado Informática, 2º Curso Estructura de Computadores

Grado Informática, 2º Curso Estructura de Computadores

Progr. Máquina III: switch/Procedimientos

Grado Informática, 2º Curso Estructura de Computadores

 El registro %esp contiene

* por el momento, en el instante actual,

Grado Informática, 2º Curso Estructura de Computadores

Pila IA32: Push

Grado Informática, 2º Curso Estructura de Computadores

Pila IA32 : Pop

* “pop” = saltar (con pequeño ruido explosivo), salir 25

Grado Informática, 2º Curso Estructura de Computadores

Flujo de Control para Procedimientos

Grado Informática, 2º Curso Estructura de Computadores

Ejemplo de Llamada a Procedimiento

%esp 0x108 %esp 0x104

%eip 0x804854e %eip 0x8048b90

%eip: contador de programa

Grado Informática, 2º Curso Estructura de Computadores

Ejemplo de Retorno de Procedimiento

%esp 0x104 %esp 0x108

%eip 0x8048591 %eip 0x8048553