13 Generacion de Codigo

Compiladores
Generación de Código No
Optimizado
De la Representación Intermedia a
Código de Máquina
Resumen
• Introducción
• Overview de un procesador moderno
• Lenguaje de Máquina
• Convenciones de Llamado
• Generación de Expresiones
• Generación de Control de Flujo
• Generación de Procedimientos
• Linking
Oscar Bonilla 2 Universidad Galileo

Anatomía de un Compilador
Programa (character stream)
Analizador Léxico (Scanner)
Token
Analizador SintácticoStream
(Parser)
Arbol de Parseo
Generador de Código Intermedio
Representación Intermedia
Optimizador de Código Intermedio
Representación Intermedia Optimizada
Generador de Código
Código en Assembler
Anatomía de un Compilador
Token
(Parser)
Arbol de Parseo
High-level IR
Low-level IR
Representación en Formato Intermedio
while (i < v.length && v[i] != 0) { entry

i = i+1;
} cbr
<
ldl i len
cbr ldf v
!=
stl i
lda 0 exit
+
ldf v ldl i
ldl i 0

El Generador de Código debe...
• Traducir todas las instrucciones en la
representación intermedia a lenguaje
ensamblador
• Asignar espacio para variables, arreglos, etc.
• Adherirse a las convenciones de llamado
• Crear la información simbólica necesaria

Resumen
• Introducción
• Resumen de un procesador moderno
• Linking

Resumen de un Procesador Moderno
• ALU Memory
• Control
• Memoria Registers ALU
• Registros Control

Arithmetic and Logic Unit
• Hace la mayoría de operaciones Memory
• Con forma:
OP Rdest, Rsrc1, Rsrc2
Registers ALU
• Operaciones son:
– Operaciones aritméticas (add, sub, mul) Control
– Operaciones lógicas (and, sll)

– Operaciones de comparación (seq, sge,
slt)

Arithmetic and Logic Unit
• Muchas operaciones aritméticas pueden
Memory
causar una excepción
– overflow y underflow
• Puede operar en distintos tipos de datos Registers ALU
– 8, 16, 32 bits
– Aritmética con y sin signo Control
– Operaciones de punto flotante (ALU separada)

– Instrucciones para convertir entre formatos
(cvt.s.d)

Control
• Maneja la secuencia de Instrucciones Memory
• Ejecución de Instrucciones
– Todas las instrucciones están en
Registers ALU
memoria
– Fetch de la instrucción a la que apunta Control
el PC y ejecutarla
– Para instrucciones generales,
incrementar el PC para que apunte a la
siguiente posición de memoria

Control
• Saltos no condicionales
– Fetch de la siguiente instrucción de una localidad Memory
diferente
– Salto incondicional a una dirección dada
j label Registers ALU
– Salto incondicional a una dirección en un registro
jr rsrc Control
– Para manejar llamadas a procedimientos, se hace
un salto incondicional, pero se guarda la
siguiente dirección en la secuencia actual en un
registro
jal label jalr rsrc

Control
• Saltos Condicionales
Memory
– Ejectuamos un test,
si es éxitoso, fetch de instrucciones de
una nueva dirección, Registers ALU
de otra forma fetch de la siguiente
instrucción Control
– Las instrucciones son de la forma:
brelop Rsrc1, Rsrc2, label
– relop es de la forma:
eq, ne, gt, ge, lt, le

Control
• Transferencia de control en casos
especiales (raros) Memory
– traps y excepciones
– Mecanismo
Registers ALU
• Guardar la posición de la siguiente
instrucción (o la actual)
Control
• Encontrar la dirección a la que hay que
saltar (de un vector de excepciones)
• Saltar a esa posición

Memory
• Espacio de Direcciones plano Memory
– Compuesto de words
– Direccionable por bytes
Registers ALU
• Necesitamos guardar
– Programa Control
– Variables locales
– Stack
– Heap

Memory
Stack locales
Memory
(parámetros)
Registers ALU
Objetos Control
Heap
Arrays
Código Generado

Registers
• Arquitectura load/store Memory
– Todas las operaciones se ejecutan en
registros
– Necesitamos mover datos de/a memoria Registers ALU
a/de registros
Control
• Importante para rendimiento

– Limitados en número

Otras Interacciones
• Otras operaciones Memory
– Input/Output
– Operaciones Privilegiadas / seguras
– Manejo de hardware especial Registers ALU
• TLBs, Caches etc.

Control
• La mayoría via system calls

– Codificadas a mano en assembler
– El compilador las puede tratar como una llamada
normal a una función

Resumen
• Introducción
• Linking

Las máquinas entienden...
location data
0x4009b0: 3c1c0fc0
0x4009b4: 279c7640
0x4009b8: 0399e021
0x4009bc: 8f998044
0x4009c0: 27bdffe0
0x4009c4: afbf001c
0x4009c8: afbc0018
0x4009cc: 0320f809
0x4009d0: 2404000a
0x4009d4: 8fbf001c
0x4009d8: 8fbc0018
0x4009dc: 27bd0020
0x4009e0: 03e00008
0x4009e4: 00001025

Las máquinas entienden...
location data assembly instruction
main:
[test.c: 3] 0x4009b0: 3c1c0fc0 lui gp,0xfc0
[test.c: 3] 0x4009b4: 279c7640 addiu gp,gp,30272
[test.c: 3] 0x4009b8: 0399e021 addu gp,gp,t9
[test.c: 3] 0x4009bc: 8f998044 lw t9,-32700(gp)
[test.c: 3] 0x4009c0: 27bdffe0 addiu sp,sp,-32
[test.c: 3] 0x4009c4: afbf001c sw ra,28(sp)
[test.c: 3] 0x4009c8: afbc0018 sw gp,24(sp)
[test.c: 3] 0x4009cc: 0320f809 jalr ra,t9
[test.c: 3] 0x4009d0: 2404000a li a0,10
[test.c: 3] 0x4009d4: 8fbf001c lw ra,28(sp)
[test.c: 3] 0x4009d8: 8fbc0018 lw gp,24(sp)
[test.c: 3] 0x4009dc: 27bd0020 addiu sp,sp,32
[test.c: 3] 0x4009e0: 03e00008 jr ra
[test.c: 3] 0x4009e4: 00001025 move v0,zero

Token
(Parser)
Arbol de Parseo
High-level IR
Low-level IR

Token
(Parser)
Arbol de Parseo
High-level IR
Low-level IR
Assembler & linker
Binario Ejecutable
Procesador
Lenguaje Ensamblador
• Ventajas
– Simplifica la generación de código debido al uso de
instrucciones simbólicas y nombres simbólicos
– Capa de abstracción lógica
– Las arquitecturas pueden ser descritas por un
lenguaje ensamblador
 podemos modificar la implementación
• Instrucciones de macro assembler
• Desventajas
– Proceso adicional de ensamblaje y linking

Lenguaje Ensamblador
• Lenguaje de Máquina Reposicionable (object
modules)
– Todas las posiciones (direcciones) representadas por
símbolos
– Mapeadas a direcciones de memoria en tiempo de linking y
loading
– Flexibilidad de compilación separada
• Lenguaje de Máquina Absoluto
– Direcciones hard-coded
– Implementación simple y directa
– Inflexible – difícil de recargar el código generado

Ejemplo de Assembler
item:
.word 1
.text
fib:
subu $sp, 40
sw $31, 28($sp)
sw $4, 40($sp)
sw $16, 20($sp)
.frame $sp, 40, $31
# 7 if(n == 0) return 0;
lw $14, 40($sp)
bne $14, 0, $32
move $2, $0
b lab2
lab1:
lw $15, 40($sp)
bne $15, 1, $33
li $2, 1
b lab1

Resumen
• Introducción
• Linking

Compatibilidad
• Necesitamos Manejar
– Procedimientos múltiples
– Llamadas a librerías
– Código compilado por otros compiladores, escrito
en lenguajes distintos, assembler escrito a mano
• Convenciones de llamado
– Layout de memoria
– Registros
– Stack

Layout de Memoria
0x7fffffff
• Inicio del Stack Stack locals
(parameters)
• Manejo del Heap
– free lists
• Posición de inicio
en el segmento de Objects
texto Heap
Arrays
Text segment
0x400000
Reserved
Disciplinas de paso de parámetros
• Muchos métodos distintos
– Llamada por referencia
– Llamada por valor
– Llamada por valor-resultado
• ¿Cómo pasamos los parámetros?
– Por el stack
– Por los registros
– O una combinación

20
Registros
• No es un registro, hard-wired a la constante 0
0 zero hard-wired to zero

Registros
• Return Address de una llamada (call)
– Implicitamente copiada por jal y jalr
31 ra return address
Registros
• Frame pointer
• Stack pointer
• Pointer to global area
28 gp pointer to global area

29 sp stack pointer
30 fp frame pointer
Registros
• Reservado para uso del ensamblador
– Se necesita almacenamiento para manejar
instrucciones de assembler compuestas
1 at Reserved for asm

29 sp stack pointer
30 fp frame pointer
Registros
• Retornan los resultados
– Copiar el resultado cuando estamos listos para retornar
– Usados para evaluar expresiones (si quieren)
2 - 3 v0 - v1 expr. eval and return of results

29 sp stack pointer
30 fp frame pointer
Registros
• Primeros cuatro argumentos de una llamada
– Se pueden usar para otra cosa si los argumentos no importan
– Si hay más argumentos  se pasan por el stack
2-3 v0 - v1 expr. eval and return of results
4-7 a0 - a3 arguments 1 to 4

29 sp stack pointer
30 fp frame pointer
Registros
• El resto son temporales

8 - 25 keep temporary values

29 sp stack pointer
30 fp frame pointer
Registros
• En una llamada a procedimiento los temporales:
– Son guardados por el caller
– Son guardados por el callee
– Alguna combinación de ambos
8 - 25 keep temporary values

29 sp stack pointer
30 fp frame pointer
21
Pregunta:
• ¿Cuáles son las ventajas/desventajas de que:
– El callee guarde los registros?
– El caller guarde los registros?
• ¿Qué registros deben ser usados por el caller y
callee si la mitad es guardada por el caller y la
otra mitad es guardada por el callee?
– Caller-saved t0 - t9
– Calliee-saved s0-s7

Registros
• En una llamada a procedimiento los temporales:
– Son guardados por el caller
– Son guardados por el callee
– Alguna combinación de ambos
8-15 t0 - t7 caller saved temporary
16 - 23 s0 - s7 calliee saved temporary
24, 25 t8, t9 caller saved temporary
29 sp stack pointer
30 fp frame pointer
23
Stack
• Guarda los parámetros y las variables locales
– Cada invocación obtiene una nueva copia
• Caller tiene que guardar
– Cualquier registro caller-saved que tiene un valor
– Cualesquiera parámetros pasados
– Return address (de cuando se hizo el branch)
• Callee tiene que guardar
– Dirección anterior del stack pointer
– Cualquier registro callee-saved que use
...
Stack argument 5
argument 4
fp
old frame pointer
return address
• Dirección del n-ésimo Calliee saved
registers
argumento es -(n-4)*4*$fp Local variables
• Variables locales son Stack temporaries
constantes positivas de $fp Dynamic area

sp

... 24
Stack argument 5
argument 4
fp
• Al llamar un nuevo old frame pointer
return address
Calliee saved
procedimiento registers
Local variables
Stack temporaries
Dynamic area
sp

...
Stack argument 5
argument 4
fp
return address
Calliee saved
procedimiento, el caller: registers
Local variables
Stack temporaries
Dynamic area
sp

...
Stack argument 5
argument 4
fp
return address
Calliee saved
– push de cualquier t0-t9 que Local variables
tenga un valor importante al Stack temporaries
stack Dynamic area
Caller saved registers

sp

...
Stack argument 5
argument 4
fp
return address
Calliee saved
stack Dynamic area
– poner argumentos 1-4 en Caller saved registers
registros a0-a3 arguments
sp
– push del resto de los
argumentos al stack

...
Stack argument 5
argument 4
fp
return address
Calliee saved
stack Dynamic area
– poner argumentos 1-4 en Caller saved registers
registros a0-a3 arguments
sp
– push del resto de los
argumentos al stack
– hacer un jal o jalr

... 25
Stack argument 5
argument 4
fp
• En el procedimiento, el old frame pointer
return address
Calliee saved
calliee al principio: registers
Local variables
Stack temporaries
Dynamic area

arguments
sp

...
Stack argument 5
argument 4

return address
Calliee saved
calliee al principio : registers
– copiar $sp a $fp Local variables
Stack temporaries
Dynamic area

arguments fp
sp

...
Stack argument 5
argument 4

return address
Calliee saved
– push $fp al stack Stack temporaries

Dynamic area

arguments
fp
old frame pointer sp

...
Stack argument 5
argument 4

return address
Calliee saved
– push $ra al stack Dynamic area

arguments
fp
old frame pointer
return address sp

...
Stack argument 5
argument 4

return address
Calliee saved
– si cualquier s0-s7 es usado Caller saved registers

arguments
en el procedimiento, fp
old frame pointer
guardarlo en el stack return address
Calliee saved
registers sp

...
Stack argument 5
argument 4

return address
Calliee saved
– si cualquier s0-s7 es usado Caller saved registers

arguments
en el procedimiento, fp
old frame pointer
guardarlo en el stack return address
Calliee saved
– crear espacio para variables registers
locales en el stack Local variables
sp

...
Stack argument 5
argument 4

return address
calliee al principio : Calliee saved
registers
– si cualquier s0-s7 es usado en Caller saved registers

arguments
el procedimiento, guardarlo
fp
en el stack old frame pointer
return address
Calliee saved
– crear espacio para variables registers
locales en el stack Local variables
– ejecutar al calliee... Dynamic area
sp
... 26
Stack argument 5
argument 4
old frame pointer
• En el procedimiento, el calliee return address
Calliee saved
al final : registers
Local variables
Stack temporaries
Dynamic area

arguments
fp
old frame pointer
return address
Calliee saved
registers
Local variables
Dynamic area
sp
...
Stack argument 5
argument 4
old frame pointer
Calliee saved
– poner valores de retorno en v0,v1 Local variables
Stack temporaries
Dynamic area

arguments
fp
old frame pointer
return address
Calliee saved
registers
Local variables
Dynamic area
sp
...
Stack argument 5
argument 4
old frame pointer
Calliee saved
– actualizar $sp usando $fp Stack temporaries
($fp+4) + ... Dynamic area

arguments
fp
old frame pointer
return address
Calliee saved
registers sp

...
Stack argument 5
argument 4
old frame pointer
Calliee saved
– Pop los registros callee-saved del
stack arguments
fp
old frame pointer
return address
Calliee saved
sp
registers

...
Stack argument 5
argument 4
old frame pointer
Calliee saved
stack arguments
– restaurar $ra del stack fp
old frame pointer sp
return address

...
Stack argument 5
argument 4
fp
old frame pointer
Calliee saved
– actualizar $sp usando $fp ($fp+4) Stack temporaries
+ ... Dynamic area
stack arguments
– restaurar $ra del stack sp
old frame pointer
– restaurar $fp del stack

...
Stack argument 5
argument 4
fp
old frame pointer
• En el procedimiento, el calliee al return address
Calliee saved
final : registers
– actualizar $sp usando $fp ($fp+4) Stack temporaries
+ ... Dynamic area
stack arguments
– restaurar $ra del stack sp
– ejecutar jr ra para regresar al
caller

... 27
Stack argument 5
argument 4
fp
• Al regresar de la llamada al old frame pointer
return address
Calliee saved
Local variables
Stack temporaries
Dynamic area

arguments
sp

...
Stack argument 5
argument 4
fp
return address
Calliee saved
– actualizar $sp para ignorar Local variables
argumentos Stack temporaries
Dynamic area

sp

...
Stack argument 5
argument 4
fp
return address
Calliee saved
– pop de los registros caller Dynamic area
sp
saved Caller saved registers

...
Stack argument 5
argument 4
fp
return address
Calliee saved
– pop de los registros caller Dynamic area
sp
saved
– continuar...

30
Pregunta:
• ¿es necesario el $fp?
• ¿cuáles son las ventajas y desventajas de tener
$fp?

Programa Ejemplo
class auxmath {
int sum3d(int ax, int ay, int az,
int bx, int by, int bz)
{
int dx, dy, dz;
if(ax > ay)
dx = ax - bx;
else
dx = bx - ax;
…
retrun dx + dy + dz;
}
}

Programa Ejemplo
class auxmath {
int sum3d(int ax, int ay, int az,
int bx, int by, int bz)
{
int dx, dy, dz;
if(ax > ay)
dx = ax - bx;
else
dx = bx - ax;
…
retrun dx + dy + dz;
}
}
…
int px, py, pz;
…
auxmath am;
am.sum3d(px, py, pz, 0, 0, 0);

Programa Ejemplo v0
v1
??
??
class auxmath { a0 this
int sum3d(int ax, int ay, int az, a1 ax (10)
int bx, int by, int bz) a2 ay (20)
{ a3 az (30)
int dx, dy, dz; v0 ??
if(ax > ay) v1 ??
dx = ax - bx; t0 ??
else t1 ??
dx = bx - ax;
… Dynamic area
retrun dx + dy + dz; Caller saved registers
}
} Argument 7: bz (-1)
Argument 6: by (1)
Argument 5: bx (0)
… fp
int px, py, pz;
px = 10; py = 20; pz = 30;
auxmath am;
am.sum3d(px, py, pz, 0, 1, -1);

Programa Ejemplo v0
v1
??
??
{ a3 az (30)
if(ax > ay) v1 ??
dx = ax - bx; t0 ??
else t1 ??
dx = bx - ax;
… Dynamic area
}
Argument 6: by (1)
Argument 5: bx (0)
…
old frame pointer
fp
int px, py, pz;
return address sp
px = 10; py = 20; pz = 30;
auxmath am;
am.sum3d(px, py, pz, 0, 1, -1);

Programa Ejemplo v0
v1
??
??
{ a3 az (30)
if(ax > ay) v1 ??
dx = ax - bx; t0 ??
else t1 ??
dx = bx - ax;
… Dynamic area
}
Argument 6: by (1)
Argument 5: bx (0)
…
old frame pointer
fp
int px, py, pz;
return address
px = 10; py = 20; pz = 30; Local variable dx (??)
auxmath am; Local variable dy (??)
am.sum3d(px, py, pz, 0, 1, -1); Local variable dz (??) sp
Resumen
• Introducción
• Linking

Creación de Expresiones
• Algoritmo ingenuo de generación de código
x = y op z
– Seleccionar un registro Rsrc1 (digamos $t0) para cargar el
valor y
– Generar instrucción para copiar, si y está:
• En otro registro (digamos $t7) add $t0, $t7, zero
• Es constante (digamos 1024) li $t0, 1024
• En memoria (digamos que $t7 apunta a y) lw $t0, $t7
• En una dirección simbólica (digamos lab1) la $t0, lab1
– Seleccionar registro Rsrc2 (digamos $t1) y cargar el valor z
– Seleccionar registro Rdest (digamos $t2) para guardar x
– Hacer la operación (digamos and) and $t2, $t1, $t0

v0 ??
Programa Ejemplo v1
a0
??
this
class auxmath { a1 ax (10)
int sum3d(int ax, int ay, int az, a2 ay (20)
int bx, int by, int bz) a3 az (30)
{ v0 ??
if(ax > ay) t0 ??
dx = ax - bx; t1 ??
t2 ??
Dynamic area
Argument 7: bz (-1)
Argument 6: by (1)
Argument 5: bx (0)
old frame pointer
fp
return address
Local variable dx (??)
Local variable dy (??)
Local variable dz (??) sp
v0 ??
Programa Ejemplo v1
a0
??
this
class auxmath { a1 ax (10)
int sum3d(int ax, int ay, int az, a2 ay (20)
int bx, int by, int bz) a3 az (30)
{ v0 ??address
if(ax > ay) t0 ?? src1
dx = ax - bx; t1 ?? src2
t2 ?? dest
Dynamic area
add $t0, $a1, zero Caller saved registers
lw $t1, 0($fp) Argument 7: bz (-1)
sub $t2, $t0, $t1 Argument 6: by (1)
Argument 5: bx (0)
sw $t2, -12($fp) old frame pointer
fp
return address
Cuidado
• Los temporales son limitados
– Cuándo el árbol es grande, 18 registros temporales pueden
ser insuficientes  asignar espacio en el stack
• No hay instrucción de máquina
– Puede ser que haya que expandir la operación intermedia a
múltiples operaciones de máquina
• Muy ineficiente
– Muchas copias, sumas con cero, etc.
– No se preocupen, vamos a arreglarlas en la optimización
– Mantengan el generador de código muy muy simple

Resumen
• Introducción
• Linking

Generación de control de flujo
• Aplanar la estructura del control
– Usar un template
• Poner etiquetas únicas para puntos donde el
control se une (join points)
• Ahora generamos el código apropiado

38
Template para condicionales

if (test)
true_body
else
false_body
<do the test>

boper …, lab_true
<false_body>
j lab_end
lab_true:
<true_body>
lab_end:

v0 ??
Programa Ejemplo v1
a0
??
this
if(ax > bx) a1 ax (10)
dx = ax - bx; a2 ay (20)
else
dx = bx - ax; a3 az (30)
v0 ??address
v1 ??
t0 ?? src1
<do test> t1 ?? src2
t2 ?? dest
boper ..., ..., lab0
Dynamic area
<false body> Caller saved registers

Argument 7: bz (-1)
Argument 6: by (1)
j lab1 Argument 5: bx (0)
lab0: old frame pointer
fp
return address
<true body> Local variable dy (??)
lab1:
v0 ??
Programa Ejemplo v1
a0
??
this
dx = ax - bx; a2 ay (20)
else
dx = bx - ax; a3 az (30)
v0 ??address
v1 ??
add $t0, $a1, zero t0 ?? src1
lw $t1, 0($fp) t1 ?? src2
t2 ?? dest
bgt $t0, $t1, lab0
Dynamic area
<fale body>
Argument 7: bz (-1)
Argument 6: by (1)
j lab1 Argument 5: bx (0)
lab0: old frame pointer
fp
return address
<true body> Local variable dy (??)
lab1:
v0 ??
Programa Ejemplo v1
a0
??
this
dx = ax - bx; a2 ay (20)
else
dx = bx - ax; a3 az (30)
v0 ??address
v1 ??
lw $t1, 0($fp) t1 ?? src2
bgt $t0, $t1, lab0 t2 ?? dest
lw $t0, 0($fp)
Dynamic area
add $t1, $a1, zero
sub $t2, $t0, $t1 Caller saved registers
sw $t2, -12($fp) Argument 7: bz (-1)
j lab1 Argument 6: by (1)
lab0: Argument 5: bx (0)
old frame pointer
fp
<true body> return address
lab1: Local variable dz (??) sp
v0 ??
Programa Ejemplo v1
a0
??
this
dx = ax - bx; a2 ay (20)
else
dx = bx - ax; a3 az (30)
v0 ??address
v1 ??
t1 ?? src2
lw $t1, 0($fp)
t2 ?? dest
bgt $t0, $t1, lab0
lw $t0, 0($fp) Dynamic area
add $t1, $a1, zero Caller saved registers
sub $t2, $t0, $t1
Argument 7: bz (-1)
sw $t2, -12($fp)
Argument 6: by (1)
j lab1
Argument 5: bx (0)
lab0: add $t0, $a1, zero old frame pointer
fp
lw $t1, 0($fp) return address
sub $t2, $t0, $t1 Local variable dx (??)
sw $t2, -12($fp) Local variable dz (??) sp
lab1:
Template para ciclos while
while (test)
body

lab_cont:
while (test) <do the test>
body boper …, lab_body
j lab_end
lab_body:
<body>
j lab_cont
lab_end:

43

lab_cont:
while (test) <do the test>
body boper …, lab_body
j lab_end
lab_body:
<body>
j lab_cont
lab_end:
• Una template optimizada
lab_cont:
<do the test>
boper …, lab_end
<body>
j lab_cont
lab_end:
Pregunta:
• ¿Cuál es la template para?
do
body
while (test)

44
Question:
• ¿Cuál es la template para?
do
body
while (test)
lab_begin:
<body>
<do test>
boper …, lab_begin
Resumen
• Introducción
• Linking

Procedure Call
• En el procedimiento, el calliee
al principio :
– copiar $sp a $fp
– push $fp al stack
– push $ra al stack
Dynamic area
– si cualquier s0-s7 es usado en el
procedimiento, guardarlo en el Caller saved registers
stack arguments
fp
– crear espacio para variables old frame pointer
return address
locales en el stack Calliee saved
registers
– ejecutar al calliee...
Local variables
Dynamic area
sp
46
Procedure Call
• En el procedimiento, el calliee
al principio :
– copiar $sp a $fp
– push $fp al stack
– push $ra al stack
procedimiento, guardarlo en el
stack
– crear espacio para variables
locales en el stack

48
Procedure Call
proc_entry:
• En el procedimiento, el calliee add $t0, $fp, zero
al principio : add $fp, $sp, zero
– copiar $sp a $fp addi $sp, $sp, -4
sw $t0, ($sp)
– push $fp al stack addi $sp, $sp, -4
– push $ra al stack sw $ra, ($sp)
procedimiento, guardarlo en el
stack
– crear espacio para variables
locales en el stack

Procedure Call
proc_entry:
• Ejecutar el cuerpo del add $t0, $fp, zero
procedimiento callee add $fp, $sp, zero
addi $sp, $sp, -4
– Acceso a variables sw $t0, ($sp)
addi $sp, $sp, -4
locales y parámetros sw $ra, ($sp)
como offsets del $fp . . .

Procedure Call
proc_entry:
• En el procedimiento, el calliee al add $t0, $fp, zero
add $fp, $sp, zero
final : addi $sp, $sp, -4
– poner valores de retorno en v0,v1 sw $t0, ($sp)
addi $sp, $sp, -4
– actualizar $sp usando $fp ($fp+4) + ...sw $ra, ($sp)
– Pop los registros callee-saved del . . .
stack
– restaurar $ra del stack
– ejecutar jr ra para regresar al caller

51
Procedure Call proc_entry:

• En el procedimiento, el calliee al add $t0, $fp, zero
add $fp, $sp, zero
final : addi $sp, $sp, -4
sw $t0, ($sp)
addi $sp, $sp, -4
– poner valores de retorno en v0,v1
sw $ra, ($sp)
. . .
– actualizar $sp usando $fp ($fp+4) + ...
– Pop los registros callee-saved deladd $v0, $t2
stack lw $sp, -8($fp)
addi $sp, $sp, -8
– restaurar $ra del stack lw $ra, ($sp)
addi $sp, $sp, 4
– restaurar $fp del stack lw $fp, ($sp)
addi $sp, $sp, 4
– ejecutar jr ra para regresar al caller
jr $ra

Resumen
• Introducción
• Linking

Símbolos
• Ejecutable es una colección
– Compilaciones separadas
– Librerías linkeadas estática y dinámicamente
• Por lo tanto, no podemos crear una imagen de
memoria en tiempo de compilación
• Fase adicional del linker para juntarlo todo y
crear la imagen final de memoria

Salida del compilador
• Crear código objeto con direcciones simbólicas
que pueden ser reposicionadas
• Direcciones simbólicas de todos los datos y
principios de procedimientos que otros
necesitan accesar son exportados
• Exportar los nombres de símbolos de
referencias externas

Símbolos exportados por el compilador
Symbols from test.o:
[Index] Value Class Type Section Name

[0]| 0| File |ref=6 |Text | test.c
[1]| 0| Proc |end=3 int |Text | main
[2]| 56| Proc |end=5 int |Text | fib
[3]| 0| Global | |Bss | internal_var
[4]| 0| Proc |ref=1 |Text | main
[5]| 56| Proc |ref=3 |Text | fib
[6]| 0| Global | |Undefined| external_var
[7]| 0| Proc | |Undefined| foo
[8]| 0| Global | |Undefined| _gp_disp

Linker
• Ver todos los object files para encontrar
símbolos no resueltos
• Hacer match de los símbolos y encontrar las
partes necesarias en las librerías
• Layout en una sola imagen de memoria
• Resolver todos los nombres simbólicos a las
direcciones correctas de memoria y offsets
adecuados

Lecturas
• Ballena
– Capítulo 7
• Dragón (opcional)
– Capítulo 9, 10.1, 10.2, 10.3, 10.4

13 Generacion de Codigo

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

13 Generacion de Codigo

Cargado por

Copyright:

Formatos disponibles

Compiladores

Oscar Bonilla 2 Universidad Galileo

while (i < v.length && v[i] != 0) { entry

Oscar Bonilla 5 Universidad Galileo

Oscar Bonilla 6 Universidad Galileo

Oscar Bonilla 7 Universidad Galileo

Oscar Bonilla 8 Universidad Galileo

– Operaciones lógicas (and, sll)

Oscar Bonilla 9 Universidad Galileo

– Operaciones de punto flotante (ALU separada)

Oscar Bonilla 10 Universidad Galileo

Oscar Bonilla 11 Universidad Galileo

Oscar Bonilla 12 Universidad Galileo

Oscar Bonilla 13 Universidad Galileo

Oscar Bonilla 14 Universidad Galileo

Oscar Bonilla 15 Universidad Galileo

Oscar Bonilla 16 Universidad Galileo

• Importante para rendimiento

Oscar Bonilla 17 Universidad Galileo

• TLBs, Caches etc.

• La mayoría via system calls

Oscar Bonilla 18 Universidad Galileo

Oscar Bonilla 19 Universidad Galileo

Oscar Bonilla 20 Universidad Galileo

Oscar Bonilla 21 Universidad Galileo

Oscar Bonilla 22 Universidad Galileo

Oscar Bonilla 24 Universidad Galileo

Oscar Bonilla 25 Universidad Galileo

Oscar Bonilla 26 Universidad Galileo

Oscar Bonilla 27 Universidad Galileo

Oscar Bonilla 28 Universidad Galileo

Oscar Bonilla 30 Universidad Galileo

0 zero hard-wired to zero

Oscar Bonilla 31 Universidad Galileo

0 zero hard-wired to zero

28 gp pointer to global area

28 gp pointer to global area

28 gp pointer to global area

28 gp pointer to global area

0 zero hard-wired to zero

8 - 25 keep temporary values

28 gp pointer to global area

8 - 25 keep temporary values

28 gp pointer to global area

Oscar Bonilla 39 Universidad Galileo

• Variables locales son Stack temporaries

constantes positivas de $fp Dynamic area

Oscar Bonilla 42 Universidad Galileo

Oscar Bonilla 43 Universidad Galileo

Oscar Bonilla 44 Universidad Galileo

Caller saved registers

Oscar Bonilla 45 Universidad Galileo

Oscar Bonilla 46 Universidad Galileo

Oscar Bonilla 47 Universidad Galileo

Caller saved registers

Oscar Bonilla 48 Universidad Galileo

• En el procedimiento, el old frame pointer

Caller saved registers

Oscar Bonilla 49 Universidad Galileo

• En el procedimiento, el old frame pointer

– push $fp al stack Stack temporaries

Caller saved registers

Oscar Bonilla 50 Universidad Galileo