Diseño de compiladores. Representación intermedia Ambientes de ejecución

Transcripción

1 Diseño de compiladores Representación intermedia Ambientes de ejecución

2 Generación de la RI Es la ultima etapa del frontend de un compilador El objetivo es traducir el programa en el formato que espera el backend del compilador El código intermedio generado no tiene porque ser ensamblador, puede ser de mayor nivel

3 Por que una RI? Simplificación del código El código maquina (objeto) tiene ciertas restricciones que hacen que no podamos realizar ciertas operaciones a ese nivel El lenguaje intermedio puede ser una aproximación a ese lenguaje final, en donde podamos realizar las operaciones deseadas Ejemplo: No tener multiplicación en el lenguaje destino? La implementamos como secuencia de sumas!

4 Por que una RI? Manejar con un solo backend, múltiples frontends Por ejemplo, gcc permite manejar C, C++, Java, Fortran y muchos mas Cada frontend traduce su código a un lenguaje intermedio denominado GENERIC Muy similar al enfoque.net, pero sin el runtime que controle el código ejecutable

5 Por que una RI? Manejar múltiples backends, para el mismo frontend La idea es utilizar el mismo lenguaje intermedio, y luego traducirlo a diferentes plataformas usando backends diferentes Las optimizaciones se tratan de hacer sobre el código intermedio en la mayoría de los casos Es similar a la idea de Java con el runtime (bytecode a código nativo, JIT)

6 Representación Intermedia Son difíciles de lograr, ya que deben balancear dos necesidades opuestas Por un lado tenemos las necesidades del lenguaje de alto nivel y por el otro las de bajo nivel Si la RI es muy de alto nivel, entonces no podemos hacer ciertas optimizaciones de bajo nivel Si la RI es muy de bajo nivel, entonces no podemos usar el conocimiento del alto nivel para mejorar el código

7 Código Fuente Un ejemplo, la arquitectura de GCC, de relativamente bajo nivel

8 Código Fuente AST

9 Código Fuente GENERIC AST

10 Código Fuente GENERIC AST HIGH GIMPLE

11 Código Fuente GENERIC AST HIGH GIMPLE SSA

12 Código Fuente GENERIC AST HIGH GIMPLE SSA LOW GIMPLE

13 Código Fuente GENERIC AST HIGH GIMPLE SSA LOW GIMPLE RTL

14 Código Fuente GENERIC AST HIGH GIMPLE SSA LOW GIMPLE Código Maquina RTL

15 Código Fuente GENERIC AST HIGH GIMPLE SSA LOW GIMPLE Código Maquina RTL

16 RI de alto nivel Algunos ejemplos Java Bytecode Cpython bytecode LLVM IR Microsoft CIL Aspectos interesantes: Mantienen la estructura de alto nivel del programa Permiten compilación a lenguajes de mas bajo nivel Permiten INTERPRETACION O JIT (Just In Time Compilation)

17 Que nos importa en esta etapa? Ambientes de ejecución Como implementamos las características de un lenguaje en el código maquina (especialmente si el código maquina no las soporta) Un ejemplo, que pasa con la recursión Que estructuras de datos necesitamos? Código de Tres Direcciones (C3D) Que ventajas tiene, porque es interesante Como podemos generar el C3D? Veremos con ejemplos

18 AMBIENTES DE EJECUCIÓN

19 Un problema importante Los lenguajes de programación manejan aspectos de alto nivel Funciones Objetos Excepciones Tipado dinámico y estático Introspección Estructuras de control

20 Un problema importante Pero la maquina destino suele operar en términos mucho mas primitivos Aritmética Movimiento de datos Estructuras de control muy simples, generalmente saltos y secuencias Soporte básico de acceso a memoria Acceso directo Acceso en formato PILA

21 Ambiente de ejecución Es una forma de representar estos conceptos de alto nivel, usando lo que tenemos disponible en la plataforma destino para nuestro lenguaje

22 Ambiente de ejecución Es una serie de estructuras de datos y procedimientos que se mantienen en runtime de forma de implementar los conceptos de alto nivel Ejemplos: Stack, Heap, Área estática, Tablas de funciones, etc. Depende FUERTEMENTE de las características del lenguaje origen y el lenguaje/plataforma destino

23 Por ejemplo Si tenemos un lenguaje tipo Java, debemos considerar Como se ven los objetos en memoria Como se ven las funciones en memoria Donde se colocan en la memoria Como se implementan las llamadas a funciones Como se implementa la herencia Lo mejor, es que no hay una única respuesta a estas consideraciones!

24 Representación de datos Nos interesa determinar como se colocan los datos en memoria La maquina por lo general soporta opciones limitadas Enteros de largo fijo: 8 bits, 16 bits, 32 bits, con signo, sin signo Flotantes: 32 bits, 64 bits, 80 bits IEEE 754 Debemos codificar nuestros tipos usando estos elementos disponibles

25 Representando tipos primitivos Tipos primitivos integrales byte, char, short, int, long, unsigned, uint16_t Se mapean directo a los tipos de la maquina destino Tipos primitivos reales float, double, long double Se mapean directo a los tipos de la maquina destino

26 Representando tipos primitivos Punteros Típicamente representados como enteros, que contienen la dirección de memoria destino que nos interesa El tamaño del entero depende de la arquitectura destino Tenemos enteros de 32 bits, 64 bits

27 Representando arrays Arrays tipo C Los elementos del array se colocan uno atrás del otro en memoria Arr[0] Arr[1] Arr[2]... Arr[n-1]

28 Representando arrays Arrays tipo Java Los elementos del array se colocan uno atrás del otro en memoria Se coloca el tamaño del array al principio n Arr[0] Arr[1] Arr[2]... Arr[n-1]

29 Representando arrays Arrays tipo D Los elementos del array se colocan uno atrás del otro en memoria Se coloca un punteo al primer y post-ultimo elemento Arr[0] Arr[1] Arr[2]... Arr[n-1] First Past-End

30 Representando arrays multidim. Se representan como arrays de arrays La forma de los arrays en memoria depende del tipo de array usado Arrays tipo C: int a[3][2] a[0][0] a[0][1] a[1][0] a[1][1] a[2][0] a[2][1]

31 Representando arrays multidim. Se representan como arrays de arrays La forma de los arrays en memoria depende del tipo de array usado Arrays tipo C: int a[3][2] a[0][0] a[0][1] a[1][0] a[1][1] a[2][0] a[2][1] Array de tamaño 2 Array de tamaño 2 Array de tamaño 2

32 Representando arrays multidim. Se representan como arrays de arrays La forma de los arrays en memoria depende del tipo de array usado Arrays tipo Java: int[][] a = new int[3][2] 3 a[0] a[1] a[2] 2 a[0][0] a[0][1] 2 a[1][0] a[1][1] 2 a[2][0] a[2][1]

33 Representando funciones Algunas cosas a responder Como funciona la ejecución dinámica de funciones Donde se coloca el código ejecutable de las funciones Como se pasan los parámetros y como se devuelven los resultados Donde se almacenan las variables locales La respuesta depende de lo que soporte el lenguaje destino

34 Stack Generalmente las llamadas a funciones se implementan utilizando un stack de registros de activación (stack frames) Al llamar a una función, hacemos un push de un nuevo registro de activación Al retornar de una función, hacemos un pop del registro de activación actual

35 Árbol de activaciones Es un árbol que representa todas las llamadas a funciones hechas por un programa en una ejecución particular No siempre puede ser determinado en tiempo de compilación Depende del comportamiento en runtime El equivalente estático es un grafo de llamadas

36 Árbol de activaciones Cada nodo del árbol representa una llamada a una función Cada registro de activación contiene un link de control al registro de activación de la función que lo invoco Este link también es conocido como enlace de control Permite armar una cadena de llamadores Recordar tipado dinámico!

37 int main() { fibonacci(3); } main int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n 1) + fibonacci(n 2); }

38 int main() { fibonacci(3); } int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n 1) + fibonacci(n 2); } main fibonacci n = 3

39 int main() { fibonacci(3); } int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n 1) + fibonacci(n 2); } main fibonacci n = 3 fibonacci n = 2

40 int main() { fibonacci(3); } int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n 1) + fibonacci(n 2); } main fibonacci n = 3 fibonacci n = 2 fibonacci n = 1

41 int main() { fibonacci(3); } int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n 1) + fibonacci(n 2); } main fibonacci n = 3 fibonacci n = 2 fibonacci n = 1 fibonacci n = 0

42 int main() { fibonacci(3); } int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n 1) + fibonacci(n 2); } main fibonacci n = 3 fibonacci n = 2 fibonacci n = 1 fibonacci n = 1 fibonacci n = 0

43 Un árbol de activación no necesita ser mantenido en memoria para siempre SOLO nos interesa la rama actual Esto es equivalente a realizar una recorrida en profundidad

44 Por que podemos optimizar? El stack se puede optimizar por 2 grandes razones Una vez que una función retorna, su registro de activación no necesita ser referenciado nuevamente No necesitamos nodos viejos del árbol de activación

45 Por que podemos optimizar? El stack se puede optimizar por 2 grandes razones En un momento de tiempo, un registro de activación ha terminado de ejecutar, o es un ancestro del registro de activación actual No necesitamos múltiples ramas del árbol activas a la vez

46 Enlaces de control y activación El enlace de control de una función, es un puntero al registro de activación de la función que lo llamo Usado para determinar donde reanudar la ejecución después que la función retorna

47 Enlaces de control y activación El enlace de acceso de una función, es un puntero al registro de activación de la función donde esta definida la primera Usado para determinar el valor de variables fuera de scope

48 Un ejemplo Supongamos un lenguaje tipo Java o C Vamos a usar un runtime stack Cada registro de activación debe almacenar Parámetros Variables locales Variables temporales (introducidas por la RI) Enlaces de acceso y de control

49 Stack Frame La organización lógica del stack frame, es creada por el generador de RI Ignora detalles específicos de la maquina destino La organización física del stack frame, es creada por el generador de código Basada en la organización lógica Incluye aspectos de la maquina destino, como por ejemplo punteros, registros, etc.

50 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales

51 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M

52 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1

53 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1...

54 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1

55 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 Locales y Temporales

56 Stack Frame para la invocación f(a1,a2,...,an) Stack Frame para la invocación g(b1,b2,...,bm) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 Locales y Temporales

57 Convenciones de llamada El llamador es el responsable de pushear y popear el espacio necesario para los parámetros de la función llamada El llamado, es el responsable de pushear y popear el espacio necesario para sus variables locales y temporales

58 Objetos Es difícil construir un lenguaje orientado a objetos, expresivo y eficiente Algunos conceptos son difíciles de implementar Despacho dinámico Interfaces Herencia múltiple Control de tipos dinámico (instanceof)

59 structs tipo C Una estructura es un tipo que contiene valores nombrados Un enfoque común? colocar cada campo en memoria según el orden en que fue declarado

60 structs tipo C Una estructura es un tipo que contiene valores nombrados Un enfoque común? colocar cada campo en memoria según el orden en que fue declarado struct Struct { int myint; char mychar; double mydouble; }; 4 Bytes 1 Byte 8 bytes

61 structs tipo C En realidad en memoria, el direccionamiento se hace en multiplos de 8 bytes (o 32, o 64, etc) No podemos ocupar solo 5 bytes de memoria struct Struct { int myint; char mychar; double mydouble; }; 4 Bytes 1 Byte 8 bytes

62 structs tipo C En realidad en memoria, el direccionamiento se hace en múltiplos de 4 bytes (u 8, 16, 32, 64, etc.) No podemos ocupar solo 5 bytes de memoria struct Struct { int myint; char mychar; double mydouble; }; 4 Bytes 1 Byte 3 Bytes 8 bytes

63 Accediendo a los campos Una vez que los campos se han colocado en memoria, estamos solo ante una tira de bytes Como sabemos a que corresponde cada cosa? 4 Bytes 1 Byte 3 Bytes 8 bytes

64 Accediendo a los campos Una idea: Mantenemos una tabla, interna al compilador, contiendo el offset necesario para acceder a cada campo 4 Bytes 1 Byte 3 Bytes 8 bytes Cuando queremos acceder a un campo, comenzamos por la dirección del struct, y luego avanzamos según el offset elegido

65 struct Struct { int x; char y; double z; }; 4 Bytes 1 Byte 3 Bytes 8 bytes

66 struct Struct { int x; char y; double z; }; 4 Bytes 1 Byte 3 Bytes 8 bytes Struct* st = new Struct; st->x = 137; st->y = 'A'; st->z = 2.71;

67 struct Struct { int x; char y; double z; }; 4 Bytes 1 Byte 3 Bytes 8 bytes Struct* st = new Struct; st 0x F8 st->x = 137; st->y = 'A'; st->z = 2.71;

68 struct Struct { int x; char y; double z; }; 4 Bytes 1 Byte 3 Bytes 8 bytes Struct* st = new Struct; st->x = 137; st->y = 'A'; st->z = 2.71; st 0x F8 137 st + 0 bytes A st + 4 bytes 2.71 st + 8 bytes

69 Herencia Como se vería en memoria esto? class Base { int x; int y; } class Derived extends Base { int z; }

70 4 Bytes 4 Bytes class Base { int x; int y; };

71 class Base { int x; int y; }; 4 Bytes 4 Bytes 4 Bytes 4 Bytes 4 Bytes class Derived extends Base { int z; };

72 Accediendo a los campos El acceso a los campos de un objeto, en el caso de tener herencia, es muy similar a las estructuras antes vistas Usamos la dirección de la instancia, y un offset para cada campo que queramos acceder

73 class Base { int x; int y; }; 4 Bytes 4 Bytes class Derived extends Base { int z; }; 4 Bytes 4 Bytes 4 Bytes Base bs = new Base(); bs.x = 137; bs.y = 42; bs 0x F8 137 bs + 0 bytes 42 bs + 4 bytes

74 class Base { int x; int y; }; 4 Bytes 4 Bytes class Derived extends Base { int z; }; 4 Bytes 4 Bytes 4 Bytes Base bs = new Derived(); bs 0x F8 bs.x = 137; 137 bs + 0 bytes bs.y = 42; 42 bs + 4 bytes

75 class Base { int x; int y; }; 4 Bytes 4 Bytes class Derived extends Base { int z; }; 4 Bytes 4 Bytes 4 Bytes Base bs = new Base(); bs.x = 137; bs.y = 42; bs 0x F8 137 bs + 0 bytes 42 bs + 4 bytes Base dr = new Derived(); dr 0x F8 dr.x = 137; 137 dr + 0 bytes dr.y = 42; 42 dr + 4 bytes

76 Herencia simple El diagramado de memoria de una clase D que extiende a una clase B, esta dado por el diagramado de memoria de la clase B, seguido por el diagramado de memoria de la clase D Intuitivamente: Una referencia de tipo B, apuntando a un objeto de tipo D, aun ve el objeto B dentro de D

77 Herencia simple B B D ptr1 : referencia de tipo B ptr2 : referencia de tipo B ptr3 : referencia de tipo D

78 Métodos Los métodos de una clase, son como funciones tradicionales, pero con dos complicaciones Como sabemos cual es el objeto sobre el que se esta aplicando la función? Como sabemos cual función llamar en runtime, por ejemplo para casos de overloading u overriding?

79 this Dentro de una función miembro de una clase, la palabra clave this (o cualquiera de sus variantes), referencia el objeto sobre el que la función aplica Idea: Tratamos this como el primer parámetro implícito de toda función miembro de una clase Cualquier función de N argumentos, es en realidad una función de N+1 argumentos

80 class TheClass { int x; void thefunction(int value) { this.x = value; } } TheClass t = new TheClass(); t.thefunction(42);

81 class TheClass { int x; void thefunction(int value) { this.x = value; } } TheClass t = new TheClass(); t.thefunction(42);

82 class TheClass { int x; } void TheClass_theFunction(TheClass this, int value) { this.x = value; } TheClass t = new TheClass(); t.thefunction(42);

83 class TheClass { int x; } void TheClass_theFunction(TheClass this, int value) { this.x = value; } TheClass t = new TheClass(); t.thefunction(42);

84 class TheClass { int x; } void TheClass_theFunction(TheClass this, int value) { this.x = value; } TheClass t = new TheClass(); TheClass_theFunction(t, 42);

85 Algunas reglas para this Cuando generamos código para llamar a una función miembro de otro objeto, debemos pasar ese objeto como primer parámetro de la función Permite representar el this dentro de la función llamada Dentro de la función, tratamos this como un parámetro mas this puede ser usado como una estructura, en la que hacemos el lookup de los campos con los métodos anteriores

86 Despacho dinámico El despacho dinámico implica determinar que función llamar en runtime, en base al tipo dinámico del objeto sobre el que se invoca la función Conceptualmente, la idea es simple:

87 Despacho dinámico Primero, obtenemos una lista de todas las clases en nuestro programa Luego, generamos código en la RI similar a este: Si el objeto es de tipo A Llamamos a la versión de la clase A de la función Si el objeto es de tipo B Llamamos a la versión de la clase B de la función Si el objeto es de tipo C Llamamos a la versión de la clase C de la función

88 Despacho dinámico Generalmente, en la practica no es buena idea implementar literalmente lo anterior Por dos motivos Es lento El numero de chequeos es O(N), donde N es el numero de clases No es implementable en la mayoría de los lenguajes Que pasa si soporta carga dinámica de clases?

89 Despacho dinámico Podemos usar un enfoque similar al usado para los campos de una clase y su clase derivada Lo hacemos en base a tablas de funciones

90 class Base { int x; void sayhi() { Print("Base"); } } class Derived extends Base{ int y; void sayhi() { Print("Derived"); } } Base.x Base.x Derived.y Código para Base.sayHi Código para Derived.sayHi

91 class Base { int x; void sayhi() { Print("Base"); } } class Derived extends Base{ int y; void sayhi() { Print("Derived"); } } sayhi Base.x sayhi Base.x Derived.y Código para Base.sayHi Código para Derived.sayHi

92 class Base { int x; void sayhi() { Print("Base"); } } class Derived extends Base{ int y; void sayhi() { Print("Derived"); } } sayhi Base.x sayhi Base.x Derived.y Código para Base.sayHi Código para Derived.sayHi

93 class Base { int x; void sayhi() { Print("Base"); } } class Derived extends Base{ int y; void sayhi() { Print("Derived"); } } sayhi Base.x sayhi Base.x Derived.y Código para Base.sayHi Código para Derived.sayHi Base b = new Base(); b.sayhi(); fn = Dirección de b + 0 bytes Invocar fn(b)

94 class Base { int x; void sayhi() { Print("Base"); } } class Derived extends Base{ int y; void sayhi() { Print("Derived"); } } sayhi Base.x sayhi Base.x Derived.y Código para Base.sayHi Código para Derived.sayHi Base b = new Derived(); b.sayhi(); fn = Dirección de b + 0 bytes Invocar fn(b)

95 Virtual Function Tables Una vtable (Virtual Function Table), es un array de punteros a implementaciones de funciones miembro de una clase Para invocar a una función miembro Determinamos el índice en la vtable Obtenemos una referencia al código de la función a través de dicho índice Invocamos a la función

96 Virtual Function Tables Según el tipo de objeto con el que estemos trabajando, podemos tener variantes en las vtables Por ejemplo Que pasa cuando usamos interfaces? Que pasa cuando tenemos herencia múltiple? Que pasa cuando combinamos herencia múltiple con interfaces?

97 Chequeo dinámico de tipos Muchos lenguajes orientados a objetos, requieren alguna forma de control dinamico de tipos Por ejemplo En Java, instanceof En C++, dynamic_cast En C# is a Queremos determinar si un tipo es convertible en otro tipo, NO si son iguales

98 class A { void f() {} } class B extends A { void f() {} } class C extends A { void f() {} } class D extends B { void f() {} } class E extends C { void f() {} }

99 class A { void f() {} } class B extends A { void f() {} } class C extends A { void f() {} } class D extends B { void f() {} } class E extends C { void f() {} } Parent A.f() Parent B.f() Parent C.f() Parent D.f() Parent E.f()

100 Una idea simple Hacemos que cada vtable de un objeto, apunte a la clase padre Para chequear si el objeto es convertible a un tipo T, recorremos los punteros en la vtable de los objetos, hasta encontrar una clase T, o llegar a un tipo sin padre El tiempo de búsqueda es O(d), donde d es la profundidad de la clase en la jerarquía

101 Otra idea mucho mejor Hay una forma mucho mas inteligente y rápida de controlar en runtime la convertibilidad, en tiempo O(1) Asumimos: Que en general no hay muchas clases derivadas de una misma clase (por ejemplo, máximo 10) Un chequeo en runtime de convertibilidad de B a A, solo es posible si B <= A Todos los tipos son conocidos estáticamente

102 Parent A.f() Parent B.f() Parent C.f() Parent Parent Parent Parent D.f() E.f() F.f() G.f()

103 Parent A.f() Parent B.f() Parent C.f() Parent Parent Parent Parent D.f() E.f() F.f() G.f()

104 1 A.f() 2 B.f() 3 C.f() 2*5 2*7 3*11 3*13 D.f() E.f() F.f() G.f()

105 1 A.f() 2 B.f() 3 C.f() D.f() E.f() F.f() G.f()

106 1 A.f() 2 B.f() 3 C.f() D.f() E.f() F.f() G.f() A myobject = /* */ if (myobject instanceof C) { /* */ }

107 1 A.f() 2 B.f() 3 C.f() D.f() E.f() F.f() G.f() A myobject = /* */ if (myobject instanceof C) { /* */ }

108 1 A.f() 2 B.f() 3 C.f() D.f() E.f() F.f() G.f() A myobject = /* */ if (myobject->vtable.key % 3 == 0) { /* */ }

109 CDT mediante números primos Asignamos a cada clase, un numero primo único Podemos reusar primero en jerarquías diferentes Establecemos la clave de esa clase, como el producto de ese primo, por todos los primos de sus superclases

110 CDT mediante números primos Para chequear en runtime si un objeto es convertible a un tipo T Buscamos la clave del objeto (según su clase) Si la clave de T divide a la clave del objeto, entonces el objeto es convertible Sino, no es convertible Asumiendo que el producto de los primos, cabe en un entero (de ahí la limitación de tamaño), el control se puede hacer en O(1)

111 CÓDIGO DE TRES DIRECCIONES

112 C3D / TAC C3D = Código de 3 Direcciones TAC = Three Address Code Es un lenguaje ensamblador de alto nivel, en donde toda operación tiene como máximo tres operandos Usa un stack explicito para representar las llamadas a funciones Usa vtables para despacho dinámico de funciones

113 int x; int y; int x2 = x * x; int y2 = y * y; int r2 = x2 + y2; x2 = x * x; y2 = y * y; r2 = x2 + y2;

114 int a; int b; int c; int d; a = b + c + d; b = a * a + b * b; _t0 = b + c; a = _t0 + d; _t1 = a * a; _t2 = b * b; b = _t1 + _t2;

115 int a; int b; int c; int d; a = b + c + d; b = a * a + b * b; _t0 = b + c; a = _t0 + d; _t1 = a * a; _t2 = b * b; b = _t1 + _t2;

116 Variables temporales El código de tres direcciones puede tener como máximo tres operandos Evaluar una expresión con mas de tres operandos, implica romper la expresión en sub expresiones, introduciendo variables temporales

117 También podemos tener menos de tres operandos El máximo es tres int a; int b; a = * b; _t0 = 5; _t1 = 2 * b; a = _t0 + _t1;

118 Instrucciones de asignación Asignación de variables var = constant; var1 = var2; var1 = var2 op var3; var1 = constant op var2; var1 = var2 op constant; var = constant1 op constant2; Operadores: +, -, *, /, %

119 Booleanos int x; int y; bool b1; bool b2; bool b3; b1 = x + x < y b2 = x + x == y b3 = x + x > y _t0 = x + x; _t1 = y; b1 = _t0 < _t1; _t2 = x + x; _t3 = y; b2 = _t2 == _t3; _t4 = x + x; _t5 = y; b3 = _t5 < _t4;

120 C3D con booleanos Las variables booleanas se representan con enteros, que pueden tener valor 0 o diferente de 0 Agregamos los operadores: <, ==,, && Por ejemplo: b = (x <= y) _t0 = x < y; _t1 = x == y; b = _t0 _t1;

121 Flujo de control int x; int y; int z; if (x < y) z = x; else z = y; _t0 = x < y; IfZ _t0 Goto _L0; z = x; Goto _L1; _L0: z = y; _L1: z = z * z; z = z * z;

122 Flujo de control int x; int y; int z; if (x < y) z = x; else z = y; _t0 = x < y; IfZ _t0 Goto _L0; z = x; Goto _L1; _L0: z = y; _L1: z = z * z; z = z * z;

123 Flujo de control int x; int y; int z; if (x < y) z = x; else z = y; _t0 = x < y; IfZ _t0 Goto _L0; z = x; Goto _L1; _L0: z = y; _L1: z = z * z; z = z * z;

124 Etiquetas El C3D permite el uso de etiquetas, las que marcan puntos nombrados dentro del programa, a los cuales podemos saltar en la ejecución Tenemos 2 instrucciones para el control de flujo Goto LABEL IfZ value Goto LABEL IfZ siempre va asociado con un Goto

125 Flujo de control int x; int y; while (x < y) { x = x * 2; } y = x; _L0: _t0 = x < y; IfZ _t0 Goto _L1; x = x * 2; Goto _L0; _L1: y = x;

126 Un programa completo void main() { int x, y; int m2 = x * x + y * y; while (m2 > 5) { m2 = m2 x; } } main: BeginFunc 24; _t0 = x * x; _t1 = y * y; m2 = _t0 + _t1; _L0: _t2 = 5 < m2; IfZ _t2 Goto _L1; m2 = m2 x; Goto _L0; _L1: EndFunc;

127 Compilando funciones Una función consiste en Una etiqueta indicando el comienzo de la función Una instrucción BeginFunc N; reservando N bytes para almacenamiento local y temporal El cuerpo de la función Una instrucción EndFunc; marcando el final de la función Al llegar a esta instrucción, eliminamos el stack frame y retornamos

128 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales

129 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M

130 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1

131 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1...

132 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1

133 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 Locales y Temporales

134 Stack Frame para la invocación f(a1,a2,...,an) Stack Frame para la invocación g(b1,b2,...,bm) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 Locales y Temporales

135 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1

136 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales

137 Compilando llamadas a funciones void SimpleFn(int z) { int x, y; x = x * y * z; } void main() { SimpleFn(100); } _SimpleFn: BeginFunc 16; _t0 = x * y; _t1 = _t0 * z; x = _t1; EndFunc; main: BeginFunc 4; _t0 = 137; PushParam _t0; LCall _SimpleFn; PopParams 4; EndFunc;

138 Gestión del Stack BeginFunc N; solo reserva espacio para locales y temporales EndFunc; solo reclama el espacio reservado por el BeginFunc N; correspondiente Un parámetro se pushea en el stack usando la instrucción PushParam var; El espacio ocupado por los parámetros es reclamado por el llamador usando la instrucción PopParams N; N mide la cantidad de bytes, no una cantidad

139 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales

140 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M PushParam var;

141 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1 PushParam var; PushParam var;

142 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... PushParam var; PushParam var; PushParam var;

143 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 PushParam var; PushParam var; PushParam var; PushParam var;

144 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 Locales y Temporales PushParam var; PushParam var; PushParam var; PushParam var; BeginFunc N;

145 Stack Frame para la invocación f(a1,a2,...,an) Stack Frame para la invocación g(b1,b2,...,bm) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 Locales y Temporales PushParam var; PushParam var; PushParam var; PushParam var; BeginFunc N;

146 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 Locales y Temporales

147 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 Locales y Temporales EndFunc;

148 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1

149 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales Param M Param M-1... Param 1 PopParams K;

150 Stack Frame para la invocación f(a1,a2,...,an) Param N Param N-1... Param 1 Locales y Temporales

151 Storage El C3D no especifica donde las variables y los temporales son almacenados Esto generalmente es gestionado en la etapa de generación de código

152 Frame Pointer Param N Param N-1... Param 1 Locales y Temporales

153 Frame Pointer Param N Param N-1... Param 1 Locales y Temporales Frame Pointer

154 Frame Pointer Param N Param N-1... Param 1 Locales y Temporales Frame Pointer Param N Param N-1... Param 1

155 Frame Pointer Param N Param N-1... Param 1 Locales y Temporales Frame Pointer Param N Param N-1... Param 1 Locales y Temporales

156 Frame Pointer Param N Param N-1... Param 1 Locales y Temporales Frame Pointer Param N Param N-1... Param 1 Locales y Temporales

157 Frame Pointer Param N Param N-1... Param 1 Locales y Temporales Frame Pointer Param N Param N-1... Param 1

158 Frame Pointer Param N Param N-1... Param 1 Locales y Temporales Frame Pointer

159 Frame Pointer Param N Param N-1... Param 1 Locales y Temporales Frame Pointer

160 Stack lógico vs Stack físico Param N Param N-1... Param 1 Locales y Temporales Param N Param N-1... Param 1 fp llamador Locales y Temporales Frame Pointer

161 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer

162 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer Param N... Param 1

163 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer Param N... Param 1 fp llamador

164 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer Param N... Param 1 fp llamador

165 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer Param N... Param 1 fp llamador Locales y Temporales

166 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer Param N... Param 1 fp llamador

167 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer Param N... Param 1 fp llamador

168 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer Param N... Param 1

169 Frame Pointer Param N... Param 1 fp llamador Locales y Temporales Frame Pointer

170 Dirección de retorno Internamente, el procesador tiene un registro especial denominado IP (Instruction Pointer), el cual almacena la dirección de la próxima instrucción a ejecutar Cuando una función retorna, debe restaurar el IP de forma de que la función llamadora pueda continuar desde donde se quedo Agregamos al stack físico la dirección de retorno

171 Return Address Param N... Param 1 fp llamador ra llamador Locales y Temporales Frame Pointer

172 Return Address Param N... Param 1 fp llamador ra llamador Locales y Temporales Frame Pointer Param N... Param 1

173 Return Address Param N... Param 1 fp llamador ra llamador Locales y Temporales Frame Pointer Param N... Param 1 fp llamador

174 Return Address Param N... Param 1 fp llamador ra llamador Locales y Temporales Frame Pointer Param N... Param 1 fp llamador ra llamador

175 Return Address Param N... Param 1 fp llamador ra llamador Locales y Temporales Frame Pointer Param N... Param 1 fp llamador ra llamador Locales y Temporales

176 Entonces En el generador de código, debemos asignar a cada temporal, variable local y parámetro su propia dirección Estas direcciones ocurren siempre en un stack frame especifico, y son siempre relativas al frame pointer (fp-relative)

177 Entonces Los parámetros comienzan siempre en la dirección fp + 4, creciendo hacia arriba en el stack (esto es una convención) Los locales y temporales comienzan en la dirección fp 8, creciendo hacia abajo en el stack (esto es una convención)

178 Entonces Frame Pointer Param N... Param 1 fp llamador ra llamador Local 0... Local M fp + 4N fp + 4 fp + 0 fp - 4 fp 8 fp 4 4M

179 Valor de retorno En forma análoga a los casos anteriores, debemos poder devolver un valor desde la función a la cual llamamos Debemos reservar espacio para el valor de retorno de la función Este valor debe ser colocado por la función llamadora

180 Valor de retorno Frame Pointer Param N... Param 1 fp llamador ra llamador Local 0... Local M fp + 4N + 4 fp + 8 Return Value fp + 4 fp + 0 fp - 4 fp 8 fp 4 4M

181 Global Pointer Existen lenguajes que soportan este tipo de construcciones: int globalvariable; int main() { globalvariable = 137; } Existe un registro especial, denominado Global Pointer, el cual permite indexar la información de las variables globales

182 Global Pointer Global Pointer Global Variable N... Global Variable 2 Global Variable 1 gp + 4N gp + 4 gp + 0

183 Objetos class A { void fn(int x) { int y; y = x; } } int main() { A a; a.fn(137); } _A.fn: BeginFunc 4; y = x; EndFunc; main: BeginFunc 8; _t0 = 137; PushParam _t0; PushParam a; LCall _A.fn; PopParams 8; EndFunc;

184 Objetos class A { int y; int z; void fn(int x) { y = x; x = z; } } int main() { A a; a.fn(100); } _A.fn: BeginFunc 4; *(this + 4) = x; x = *(this + 8); EndFunc; main: BeginFunc 8; _t0 = 137; PushParam _t0; PushParam a; LCall _A.fn; PopParams 8; EndFunc;

185 Objetos class A { int y; int z; void fn(int x) { y = x; x = z; } } int main() { A a; a.fn(100); } _A.fn: BeginFunc 4; *(this + 4) = x; x = *(this + 8); EndFunc; main: BeginFunc 8; _t0 = 137; PushParam _t0; PushParam a; LCall _A.fn; PopParams 8; EndFunc;

186 Instrucciones de memoria Agregamos estas operaciones de acceso var1 = *var2 var1 = *(var2 + constant) *var1 = var2 *(var1 + constant) = var2

187 GENERANDO C3D

188 Donde estamos? En este punto de la compilación, tenemos Un AST (Árbol Sintáctico) Anotado con información de scope Anotado con información de tipos Para generar el C3D, hacemos una recorrida recursiva de dicho árbol Generamos C3D para los nodos internos Componemos el resultado para armar C3D

189 C3D para expresiones Podemos generar el código de tres direcciones en forma recursiva Los casos base son las expresiones que no tienen hijos Estas, basta ponerlas en temporales Para expresiones que tienen hijos, lo que hacemos es generar recursivamente para estas el código de tres direcciones Vamos a necesitan una función para generar nombres de temporales

190 C3D para expresiones Supongamos una estructura de partida de la forma: Tipo: Operador Valor: + Tipo: Numero Valor: 20 Tipo: Numero Valor: 10

191

192 C3D para sentencias Podemos extender la función anterior para operar sobre sentencias A diferencia de la versión para expresiones, en este caso no retornamos el nombre del temporal usado, ya que una sentencia no genera un valor

193 Estructuras para representar C3D Al momento de representar C3D, necesitamos almacenar: El operador Los operandos Los argumentos para el operador El resultado de la operación Podemos utilizar triples y cuádruplos

194 Cuádruplos

195 Triples