Generación de Código No Optimizado

CompiladoresGeneración de Código No

Optimizado

De la Representación Intermedia a Código de Máquina

Oscar Bonilla 2 Universidad Galileo

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


Anatomía de un Compilador

Optimizador de Código Intermedio

Generador de Código

Representación Intermedia Optimizada

Código en Assembler

Generador de Código Intermedio

Representación Intermedia

Analizador Léxico (Scanner)

Analizador Sintáctico (Parser)

Token Stream

Arbol de Parseo

Programa (character stream)


Anatomía de un Compilador




High-level IR


Analizador Sintáctico (Parser)

Token Stream

Arbol de Parseo


Low-level IR



Representación en Formato Intermedio

while (i < v.length && v[i] != 0) { i = i+1;

}

entry

ldl i len

<

cbr

stl i

exit

ldf v

lda 0

!=

cbr

ldf v ldl ildl 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• Lenguaje de Máquina • Convenciones de Llamado• Generación de Expresiones• Generación de Control de Flujo• Generación de Procedimientos• Linking


Resumen de un Procesador Moderno

• ALU

• Control

• Memoria

• Registros

Memory

Registers ALU

Control


Arithmetic and Logic Unit

• Hace la mayoría de operaciones

• Con forma:OP Rdest, Rsrc1, Rsrc2

• Operaciones son:– Operaciones aritméticas (add, sub, mul)– Operaciones lógicas (and, sll)– Operaciones de comparación (seq, sge,

slt)

Memory

Registers

Control

ALU


Arithmetic and Logic Unit

• Muchas operaciones aritméticas pueden causar una excepción– overflow y underflow

• Puede operar en distintos tipos de datos– 8, 16, 32 bits

– Aritmética con y sin signo

– Operaciones de punto flotante (ALU separada)

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

Memory

Registers

Control

ALU


Control

• Maneja la secuencia de Instrucciones

• Ejecución de Instrucciones– Todas las instrucciones están en

memoria– Fetch de la instrucción a la que apunta

el PC y ejecutarla– Para instrucciones generales,

incrementar el PC para que apunte a la siguiente posición de memoria

Memory

Registers ALU

Control


Control• Saltos no condicionales

– Fetch de la siguiente instrucción de una localidad diferente

– Salto incondicional a una dirección dadaj label

– Salto incondicional a una dirección en un registro

jr rsrc

– 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

Memory

Registers ALU

Control


Control

• Saltos Condicionales– Ejectuamos un test,

si es éxitoso, fetch de instrucciones de una nueva dirección,de otra forma fetch de la siguiente instrucción

– Las instrucciones son de la forma: brelop Rsrc1, Rsrc2, label

– relop es de la forma: eq, ne, gt, ge, lt, le

Memory

Registers ALU

Control


Control• Transferencia de control en casos

especiales (raros)– traps y excepciones– Mecanismo

• Guardar la posición de la siguiente instrucción (o la actual)

• Encontrar la dirección a la que hay que saltar (de un vector de excepciones)

• Saltar a esa posición

Memory

Registers ALU

Control


Memory

• Espacio de Direcciones plano– Compuesto de words– Direccionable por bytes

• Necesitamos guardar– Programa– Variables locales– Stack– Heap

Memory

Registers ALU

Control


Memory

Memory

Registers ALU

Control

Stack

Código Generado

HeapObjetos

Arrays

locales(parámetros)


Registers

• Arquitectura load/store– Todas las operaciones se ejecutan en

registros– Necesitamos mover datos de/a memoria

a/de registros

• Importante para rendimiento– Limitados en número

ALU

Control

Memory

Registers


Otras Interacciones

• Otras operaciones– Input/Output– Operaciones Privilegiadas / seguras– Manejo de hardware especial

• TLBs, Caches etc.

• La mayoría via system calls – Codificadas a mano en assembler– El compilador las puede tratar como una llamada

normal a una función

ALU

Control

Memory

Registers


Resumen



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






High-level IR


Analizador Sintáctico (Parser)Token Stream

Arbol de Parseo

Low-level IR







High-level IR


Analizador Sintáctico (Parser)Token Stream

Arbol de Parseo

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 Assembleritem:

.word 1

.textfib:

subu $sp, 40sw $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, $32move $2, $0b lab2

lab1:lw $15, 40($sp)bne $15, 1, $33li $2, 1b lab1


Resumen



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

• Inicio del Stack

• Manejo del Heap– free lists

• Posición de inicio en el segmento de texto

Stack

Text segment

HeapObjects

Arrays

locals(parameters)

0x7fffffff

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


Registros

• No es un registro, hard-wired a la constante 0

0 zero hard-wired to zero

20


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 area29 sp stack pointer30 fp frame pointer31 ra return address


Registros

• Reservado para uso del ensamblador– Se necesita almacenamiento para manejar

instrucciones de assembler compuestas0 zero hard-wired to zero1 at Reserved for asm



Registros

• Retornan los resultados– Copiar el resultado cuando estamos listos para retornar

– Usados para evaluar expresiones (si quieren)

0 zero hard-wired to zero1 at Reserved for asm

2 - 3 v0 - v1 expr. eval and return of results



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 results4 - 7 a0 - a3 arguments 1 to 4



Registros

• El resto son temporales



8 - 25 keep temporary values



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



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

21


Registros


2 - 3 v0 - v1 expr. eval and return of results4 - 7 a0 - a3 arguments 1 to 48-15 t0 - t7 caller saved temporary

16 - 23 s0 - s7 calliee saved temporary24, 25 t8, t9 caller saved temporary


• En una llamada a procedimiento los temporales:– Son guardados por el caller– Son guardados por el callee– Alguna combinación de ambos


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

23


return addressold frame pointer

Stack

Local variables

Calliee savedregisters

Stack temporaries

... argument 5argument 4

Dynamic area

fp

sp

• Dirección del n-ésimo argumento es -(n-4)*4*$fp

• Variables locales son constantes positivas de $fp



Stack

Local variables


Stack temporaries


Dynamic area

fp

sp

• Al llamar un nuevo procedimiento

24



Stack

Local variables


Stack temporaries


Dynamic area

fp

sp

• Al llamar un nuevo procedimiento, el caller:



Stack

Local variables


Stack temporaries


Dynamic area

Caller saved registers

fp

sp

• Al llamar un nuevo procedimiento, el caller:– push de cualquier t0-t9 que

tenga un valor importante al stack



Stack

Local variables


Stack temporaries


Dynamic area

Caller saved registers arguments

fp

sp



– poner argumentos 1-4 en registros a0-a3

– push del resto de los argumentos al stack



Stack

Local variables


Stack temporaries


Dynamic area


fp

sp



– poner argumentos 1-4 en registros a0-a3

– push del resto de los argumentos al stack

– hacer un jal o jalr



Stack

Local variables


Stack temporaries


Dynamic area


fp

sp

• En el procedimiento, el calliee al principio:

25



Stack

Local variables


Stack temporaries


Dynamic area

Caller saved registers arguments fp

• En el procedimiento, el calliee al principio :– copiar $sp a $fp

sp


old frame pointer


Stack

Local variables


Stack temporaries


Dynamic area


fpsp

• En el procedimiento, el calliee al principio :– copiar $sp a $fp– push $fp al stack




Stack

Local variables


Stack temporaries


Dynamic area


fp

sp

• En el procedimiento, el calliee al principio :– copiar $sp a $fp– push $fp al stack– push $ra al stack




Stack

Local variables


Stack temporaries


Dynamic area



fp

sp

• En el procedimiento, el calliee al principio :– copiar $sp a $fp– push $fp al stack– push $ra al stack– si cualquier s0-s7 es usado

en el procedimiento, guardarlo en el stack




Stack

Local variables


Stack temporaries


Dynamic area

Local variables



fp

sp



– crear espacio para variables locales en el stack




Stack

Local variables


Stack temporaries


Dynamic area

Local variables



Dynamic area

fp

sp




– ejecutar al calliee...




Stack

Local variables


Stack temporaries


Dynamic area

Local variables



Dynamic area

• En el procedimiento, el calliee al final :

fp

sp

26




Stack

Local variables


Stack temporaries


Dynamic area

Local variables



Dynamic area

• En el procedimiento, el calliee al final :– poner valores de retorno en v0,v1

fp

sp




Stack

Local variables


Stack temporaries


Dynamic area




– actualizar $sp usando $fp ($fp+4) + ...

fp

sp




Stack

Local variables


Stack temporaries


Dynamic area




– Pop los registros callee-saved del stack

fp

spCalliee saved

registers




Stack

Local variables


Stack temporaries


Dynamic area





– restaurar $ra del stack fpsp


old frame pointer


Stack

Local variables


Stack temporaries


Dynamic area





– restaurar $ra del stack

– restaurar $fp del stack

fp

sp



Stack

Local variables


Stack temporaries


Dynamic area







– ejecutar jr ra para regresar al caller

fp

sp


Stack• Al regresar de la llamada al

procedimiento, el caller:return address

old frame pointer

Local variables


Stack temporaries


Dynamic area


fp

sp

27



procedimiento, el caller:– actualizar $sp para ignorar

argumentos


Local variables


Stack temporaries


Dynamic area


fp

sp




argumentos– pop de los registros caller

saved


Local variables


Stack temporaries


Dynamic area


fp

sp




argumentos– pop de los registros caller

saved– continuar...


Local variables


Stack temporaries


Dynamic area

fp

sp


Pregunta:

• ¿es necesario el $fp?

• ¿cuáles son las ventajas y desventajas de tener $fp?

30


Programa Ejemploclass 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;}

}





dx = ax - bx;else

dx = bx - ax; …


}

…int px, py, pz;…auxmath am;am.sum3d(px, py, pz, 0, 0, 0);





dx = ax - bx;else

dx = bx - ax; …


}

…int px, py, pz;px = 10; py = 20; pz = 30;auxmath am;am.sum3d(px, py, pz, 0, 1, -1);

Dynamic area


Argument 7: bz (-1)

fpArgument 6: by (1)Argument 5: bx (0)

v0 ??v1 ??a0 thisa1 ax (10)a2 ay (20)a3 az (30)v0 ??v1 ??t0 ??t1 ??





dx = ax - bx;else

dx = bx - ax; …


}



Dynamic area


Argument 7: bz (-1)

fp

sp

Argument 6: by (1)Argument 5: bx (0)






dx = ax - bx;else

dx = bx - ax; …


}



Dynamic area


Argument 7: bz (-1)

fp

sp


Local variable dx (??) Local variable dy (??) Local variable dz (??)



Resumen



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





dx = ax - bx;

sp


Dynamic area


Argument 7: bz (-1)

fp

sp



v0 ??v1 ??a0 thisa1 ax (10)a2 ay (20)a3 az (30)v0 ??v1 ??t0 ??t1 ??t2 ??





dx = ax - bx;

sp


Dynamic area


Argument 7: bz (-1)

fp

sp




add $t0, $a1, zerolw $t1, 0($fp)sub $t2, $t0, $t1sw $t2, -12($fp)

address

src1src2dest


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



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


Template para condicionales

if (test)true_body

elsefalse_body

<do the test>

boper …, lab_true

<false_body>

j lab_end

lab_true:

<true_body>

lab_end:

38


Programa Ejemploif(ax > bx)

dx = ax - bx;else

dx = bx - ax;


Dynamic area


Argument 7: bz (-1)

fp

sp




address

src1src2dest

<do test>

boper ..., ..., lab0

<false body>

j lab1lab0:

<true body>

lab1:



dx = ax - bx;else

dx = bx - ax;


Dynamic area


Argument 7: bz (-1)

fp

sp




address

src1src2dest

add $t0, $a1, zero

lw $t1, 0($fp)

bgt $t0, $t1, lab0

<fale body>

j lab1

lab0:

<true body>

lab1:



dx = ax - bx;else

dx = bx - ax;


Dynamic area


Argument 7: bz (-1)

fp

sp




address

src1src2dest

add $t0, $a1, zero

lw $t1, 0($fp)

bgt $t0, $t1, lab0

lw $t0, 0($fp)

add $t1, $a1, zero

sub $t2, $t0, $t1

sw $t2, -12($fp)

j lab1

lab0:

<true body>

lab1:



dx = ax - bx;else

dx = bx - ax;


Dynamic area


Argument 7: bz (-1)

fp

sp




address

src1src2dest

add $t0, $a1, zero

lw $t1, 0($fp)

bgt $t0, $t1, lab0

lw $t0, 0($fp)

add $t1, $a1, zero

sub $t2, $t0, $t1

sw $t2, -12($fp)

j lab1

lab0: add $t0, $a1, zero

lw $t1, 0($fp)

sub $t2, $t0, $t1

sw $t2, -12($fp)

lab1:


Template para ciclos while

while (test)body



while (test)body

lab_cont:<do the test>boper …, lab_bodyj lab_end

lab_body:<body>j lab_cont

lab_end:



while (test)body

lab_cont:<do the test>boper …, lab_bodyj lab_end

lab_body:<body>j lab_cont

lab_end:

• Una template optimizada

43

lab_cont:<do the test>boper …, lab_end<body>j lab_cont

lab_end:


Pregunta:

• ¿Cuál es la template para?

dobody

while (test)


Question:

• ¿Cuál es la template para?

dobody

while (test)

lab_begin:

<body>

<do test>

boper …, lab_begin

44


Resumen




Procedure Call

Dynamic area

Local variables



Dynamic area

fp

sp

• En el procedimiento, el calliee al principio :– copiar $sp a $fp

– push $fp al stack

– push $ra al stack

– si cualquier s0-s7 es usado en el procedimiento, guardarlo en el stack




Procedure Call• En el procedimiento, el calliee

al principio :– copiar $sp a $fp






46


Procedure Call• En el procedimiento, el calliee

al principio :– copiar $sp a $fp






proc_entry:add $t0, $fp,

zeroadd $fp, $sp,

zeroaddi $sp, $sp, -4sw $t0, ($sp)addi $sp, $sp, -4sw $ra, ($sp)

48


Procedure Call• Ejecutar el cuerpo del

procedimiento callee– Acceso a variables

locales y parámetros como offsets del $fp

proc_entry:add $t0, $fp,

zeroadd $fp, $sp,

zeroaddi $sp, $sp, -4sw $t0, ($sp)addi $sp, $sp, -4sw $ra, ($sp). . .


Procedure Callproc_entry:

add $t0, $fp, zero

add $fp, $sp, zero

addi $sp, $sp, -4sw $t0, ($sp)addi $sp, $sp, -4sw $ra, ($sp). . .








Procedure Callproc_entry:

add $t0, $fp, zeroadd $fp, $sp, zeroaddi $sp, $sp, -4sw $t0, ($sp)addi $sp, $sp, -4sw $ra, ($sp). . .







add $v0, $t2lw $sp, -8($fp)addi $sp, $sp, -8lw $ra, ($sp)addi $sp, $sp, 4lw $fp, ($sp)addi $sp, $sp, 4jr $ra

51


Resumen



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


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

Generación de Código No Optimizado

Documents

Transcript of Generación de Código No Optimizado