Compiladores Traducción a Formatos Intermedios. Oscar Bonilla 2Universidad Galileo Resumen Metas de...

CompiladoresTraducción a Formatos

Intermedios

Oscar Bonilla 2 Universidad Galileo

Resumen

• Metas de Representación de Programas

• Formato de datos en código en ejecución

• Tareas de Compilación

• Tablas de Símbolos

• Representación de Código de Alto Nivel

• Eliminando el Control de Flujo Estructurado

• Convirtiendo a un Espacio de Direcciones Plano


Metas de Representación de Programas

• Permitir el análisis y transformación del programa– Optimizaciones

• Estructurar la traducción a código de máquina– Secuencia de Pasos

Arbolde

Parseo

Representaciónintermedia de alto nivel

Representaciónintermedia debajo nivel

Código deMáquina


High Level IR

• Preserva la estructura de los Objetos• Adecuada para Optimizaciones Orientadas a Objetos

– Asignación Inline de Objetos

– Optimizaciones de Dynamic Dispatch

• Preserva el Control de Flujo Estructurado• Adecuada para Optimizaciones a nivel de Loops

– Bloquearse por Cache

– Loop Interchange, Fusion, Unrolling, etc.


Low Level IR

• Mueve el modelo de datos a un Espacio de Direcciones Plano

• Elimina el Control de Flujo Estructurado

• Adecuada para tareas de compilación de bajo nivel– Register Allocation– Instruction Selection


Ejemplos de Representación de Objetos y Ejecución de Programas


Ejemplo: Vector Classclass vector {

int v[];

void add(int x) {

int i;

i = 0;

while (i < v.length) { v[i] = v[i]+x; i = i+1; }

}

}


• Items almacenados contiguamente en memoria• Largo almacenado en la primera Word

• Código de Colores– Rojo – generado por el compilador automáticamente

– Azul, Amarillo, Rosado – datos o código de programa

– Magenta – datos o código de ejecución

Representando Arreglos

3 7 4 8


Representando Objetos Vector

• Primer Word apunta a información de la clase– Tabla de métodos

• Siguiente Word tiene campos (fields)– Para vectors, Primer Word es una referencia al array

Método add para vector

3 7 4 8


Invocando el Método Add

vect.add(1);

• Crear Activation Record

Método Add para Vector

3 7 4 8



vect.add(1);

• Crear Activation Record– this va al stack

this


3 7 4 8



vect.add(1);

• Crear Activation Record– this va al stack– Parámetros al stack

1 xthis


3 7 4 8



vect.add(1);

• Crear Activation Record– this va al stack– Parámetros al stack– Espacio para locales al stack

1 xi

this


3 7 4 8


Ejecutando el Método Add

void add(int x) {

int i;

i = 0;

while (i < v.length)

v[i] = v[i]+x;

i = i+1;

}

1 xi

this


3 7 4 8



void add(int x) {

int i;

i = 0;


v[i] = v[i]+x;

i = i+1;

}

10

xi

this


3 7 4 8



void add(int x) {

int i;

i = 0;


v[i] = v[i]+x;

i = i+1;

}

10

xi

this


3 8 4 8



void add(int x) {

int i;

i = 0;


v[i] = v[i]+x;

i = i+1;

}

11

xi

this


3 8 4 8



void add(int x) {

int i;

i = 0;


v[i] = v[i]+x;

i = i+1;

}

13

xi

this


3 8 5 9


Tareas de Compilación

• Determinar el Formato de los Objetos y Arrays en Memoria

• Determinar el Formato del Stack de Llamada en Memoria

• Generar Código para Leer Valores– this, párametros, elementos de arreglo, campos de objetos

• Generar Código para Computar Nuevos Valores• Generar Código para Escribir Valores• Generar Código para Construcciones de Control


Ejemplo: Clase Point

class point {

int c;

int getColor() { return(c); }

int distance() { return(0); }

}


Subclases de Point

class cartesianPoint extends point{

int x, y;

int distance() { return(x*x + y*y); }

}

class polarPoint extends point {

int r, t;

int distance() { return(r*r); }

int angle() { return(t); }

}


Dynamic Dispatch

if (x == 0) {

p = new point();

} else if (x < 0) {

p = new cartesianPoint();

} else if (x > 0) {

p = new polarPoint();

}

y = p.distance();

¿Qué método distance es ejecutado?

• Si p es pointreturn(0)

• Si p es cartesianPoint return(x*x + y*y)

• Si p es polarPoint return(r*r)

• ¡Método Invocado depende del Tipo del Receptor!


Implementando Dynamic Dispatch

• Mecanismo Básico: Tabla de Métodos

Método getColor para pointMétodo distance para cartesianPoint

Método getColor para pointMétodo distance para polarPoint

Método getColor para pointMétodo distance para point

Tabla de métodospara objetos point

Tabla de métodospara objetoscartessianPoint

Tabla de métodospara objetospolarPoint Método angle para polarPoint


Implementando Object Fields

• Cada objeto es un pedazo contiguo de memoria

• Campos de la jerarquía de herencia asignados secuencialmente en un pedazo de memoria

• Primer word es un pointer a tabla de métodos

• Ejemplo: objeto polarPointMétodo getColor para point

2 Método distance para polarPoint12

crt

Método angle para polarPoint


Objetos Point

Método getColor para point1 Método distance para cartesianPoint

Método getColor para point4 Método distance para polarPoint

Método getColor para point2

13

46

Método distance para pointc

cxy

crt



Invocando Métodos

• Compilador numera los métodos en cada jerarquía de herencia– getColor es Método 0– distance es Método 1– angle es Método 2

• Los puntos de invocación de Métodos accesan la entrada correspondiente en la tabla de métodos


Tareas de Compilación

• Determinar el Formato de Objetos en Memoria– Campos de las clases padres– Campos de la clase actual

• Numerar los Métodos y crear la Tabla de Métodos– Métodos de las clases padres– Métodos de la clase actual

• Generar Código para los Métodos– Accesos a Campos, Variables Locales y Parámetros– Invocaciones a Métodos


Tablas de Símbolos• Compilador usa información de la Tabla de

Símbolos para Producir– Layout de Objetos en Memoria– Tablas de Métodos– Código para accesar los Campos de Objetos,

Variables Locales y Parámetros


Tablas de Símbolos durante la traducción del Parse Tree al IR

• Tablas de Símbolos mapean identificadores (strings) a Descriptores (información acerca de los identificadores)

• Operación Básica: Lookup– Dado un string, encontrar el Descriptor

– Implementación Típica: Tabla Hash

• Ejemplos– Dado un nombre de clase, encontrar el descriptor de la clase

– Dado un nombre de variable, encontrar el descriptor• Descriptor local, descriptor de parámetro, descriptor de campo


Jerarquía de Tablas de Símbolos

• Jerarquía viene de– Scopes Anidados

• Scope Local dentro del Scope de Campos

– Herencia• Clases hijas dentro de una clase padre

• Tabla de Símbolos Jerárquica refleja estas jerarquías

• Lookup procede hacia arriba en la jerarquía hasta que se encuentre un descriptor


Jerarquía en método add de vector

i descriptor para local i

x descriptor para parámetro x

v descriptor para campo v

Tabla de Símbolos paraCampos de clase vector

Tabla de Símbolospara Parámetros de add

Tabla de Símbolospara Locales de add

this descriptor para this


Tabla de Símbolos del Programa

• Mapea los nombres de clases a descriptores de clases

• Implementación Típica: Tabla Hash

vectorpoint

cartesianPointpolarPoint

class descriptor para vectorclass descriptor para pointclass descriptor para cartesianPointclass descriptor para polarPoint


Class Descriptor

• Tabla de Símbolos para Métodos– Tabla de Símbolos Padre es la Tabla de Símbolos

de la Clase Padre

• Tabla de Símbolos para Campos– Tabla de Símbolos Padre es la Tabla de Símbolos

de la Clase Padre

• Referencia al Descriptor de la Clase Padre


Class Descriptors para point y cartesianPoint

yx field descriptor para x

field descriptor para y

distance method descriptor para distance

c field descriptor para c

getColor method descriptor para getColor

class descriptorpara point

class descriptorpara cartesianPoint


Descriptores de Campo, Parámetro, Local y Tipo

• Descriptores de Campo, Parámetro y Local se refieren a Descriptores de Tipo– Descriptores de Tipo Base: int, boolean– Descriptor de Tipo Array, que contiene referencia a

descriptor de tipo para elementos del array– Descriptor de Clase

• Descriptores de Tipo relativamente simples• Descriptores de Tipo Base y Descriptores de

Array guardados en Tabla de Símbolos de Tipos


Ejemplo Tabla de Símbolos de Tipos

boolean boolean descriptor

int int descriptorint [] array descriptor

boolean [] array descriptorvector [] array descriptor class descriptor

para vector


Descriptores de Método

• Contienen Referencia al Código para el Método

• Contienen Referencia a Tabla de Símbolos Local para Variables Locales al Método

• Tabla de Símbolos Padre de Tabla de Símbolos Local es la Tabla de Símbolos de Parámetros de los Parámetros del Método


Method Descriptor para Método add

this

i

this descriptor

local descriptor

field symbol tablepara vector class

Tabla de símbolosde variables locales

x

Tabla de símbolosde parámetros

parameter descriptor

Código para método add

Method descriptorpara add


Resumen de Tablas de Símbolos• Tabla de Símbolos del Programa (Descriptores de Clases) • Descriptores de Clases

Tabla de Símbolos de Campos (Descriptores de Campos) Tabla de Símbolos para SuperClass

Tabla de Símbolos de Métodos (Descriptores de Métodos) Tabla de Símbolos de Métodos para Superclass

• Descriptores de Métodos Tabla de Símbolos para Variables Locales (Descriptores de

Variable Local) Tabla de Símbolos de Parámetros (Descriptores de Parámetros)

Tabla de Símbolos de Campos de la Clase Receptora• Descriptores Locales, de Parámetros y de Campos

Descriptores de Tipo en Tabla de Símbolos de Tipo o Descriptores de Clase


v field descriptor

addclass descriptorpara vector

this

i

this descriptor

local descriptor

x parameter descriptor



boolean boolean descriptor

int int descriptorint [] array descriptor

boolean [] array descriptorvector [] array descriptor

class_decl

vector field_decl

int v []


Traduciendo de Parse Trees a Tablas de Símbolos


De Parse Trees a Tablas de Símbolos

• Recorrer recursivamente el Parse Tree

• Contruir la tabla de símbolos a medida que hacemos el recorrido


Recorriendo Declaraciones de Clases• Extraer Nombre de Clase y Nombre de Superclase• Crear Descriptor de Clase (tablas de símbolos de campos y

métodos), poner el descriptor en la Tabla de Símbolos de Clases• Poner Descriptores de Array en Tabla de Símbolos de Tipos• Buscar (lookup) el nombre de la Superclase en la Tabla de

Símbolos de Clases, hacer el link a la Superclase en el Descriptor de Clase al Descriptor de Clase Encontrado

• Recorrer Declaraciones de Campos para llenar la Tabla de Símbolos de Campos

• Recorrer Declaraciones de métodos para llenar la Tabla de Símbolos de Métodos


class_decl

vector field_decl

int v []

method_decl

add

int x

param_decl var_decl

int i

statements

class symboltable


class descriptorpara vector

class_decl

vector field_decl

int v []

method_decl

add

int x

param_decl var_decl

int i

statements

class symboltable

vector


v field descriptor

class descriptorpara vector

class_decl

vector field_decl

int v []

method_decl

add

int x

param_decl var_decl

int i

statements

class symboltable

vector


v field descriptor


this this descriptor


class_decl

vector field_decl

int v []

method_decl

add

int x

param_decl var_decl

int i

statements

class symboltable

vector


v field descriptor


this this descriptorx parameter descriptor


class_decl

vector field_decl

int v []

method_decl

add

int x

param_decl var_decl

int i

statements

class symboltable

vector


v field descriptor


this

i

this descriptor

local descriptor



class_decl

vector field_decl

int v []

method_decl

add

int x

param_decl var_decl

int i

statements

class symboltable

vector


v field descriptor


this

i

this descriptor

local descriptor



class_decl

vector field_decl

int v []

method_decl

add

int x

param_decl var_decl

int i

statements


class symboltable

vector


Representando Código en High-Level Intermediate

Representation


Idea Básica

• Moverse hacia lenguaje ensamblador• Preservar estructura de alto nivel

– Formato de objetos– Control de flujo estructurado– Distinción entre parámetros, locales y campos

• Abstracciones de alto nivel de lenguaje ensamblador– Nodos load y store– Acceso mediante locales, parámetros y campos

abstractos, no a directamente a memoria


Representando Expresiones• Expression Trees Representan Expressions

– Nodos Internos – Operaciones como +, -, etc.– Hojas – Nodos Load Representan Accesos a Variables

• Nodos Load– ldf nodo para accesos a campos – descriptor de campo

• (implícitamente accesa this – puede agregar una referencia al objeto accesado)

– ldl nodo para accesos a variables locales – descriptor local– ldp nodo para accesos a parámetros – descriptor de parámetro– lda nodo para accesos a arreglos

• expression tree para array• expression tree para índice


Ejemplo

x*x + y*y +

ldf

Descriptor de campo para xen tabla de símbolos de campospara clase cartesianPoint

*

ldf ldf

*

ldf

Descriptor de campo para yen tabla de símbolos de campospara clase cartesianPoint


Ejemplo

v[i]+x

lda

+

ldp

Descriptor de campo para v en tabla de símbolos de campos para clase vector

Descriptor localpara I en tabla de símboloslocales del método add de laclase vector

Descriptor de parámetropara x en tabla de símbolos deparámetros para método add declase vector

ldlldf


Caso Especial: Operador de Largo de Arreglo

• Nodo len representa el largo del arreglo– expression tree para array

• Ejemplo: v.lengthlen

descriptor de campo para ven tabla de símbolos de campospara clase vector

ldf


Representando Statements de Asignación

• Nodos Store– stf para stores a campos

• Descriptor de campo

• expression tree para valor guardado

– stl para stores a variables locales • Descriptor local


– sta para stores a elementos de array• expression tree para array

• expression tree para index



Ejemplov[i]=v[i]+x

lda

+

ldp

Descriptor de campopara v en tabla de símbolosde campos para clasevector

Descriptor local paraI en tabla de símbolosde locales para métodoadd de clase vector

Descriptor de parámetropara x en tabla de símbolosde parámetros para métodoadd de clase vector

ldl

sta

ldlldf


Representando Control de Flujo• Nodos de Statement

– Nodo sequence - primer statement, siguiente statement

– Nodo if• expression tree para condición• Nodo para statement then y nodo para statement else

– Nodo while• expression tree para condición• statement node para loop body

– Nodo return• expression tree para return value


Ejemplo


v[i] = v[i]+x;

local descriptor para i

ldl

field descriptor para v parameter descriptor para x

while

<

len lda

+

ldp

ldl

sta

ldl

ldf

ldf

ldf


De Parse Trees a Representación Intermedia


De Parse Trees a Representación Intermedia

• Recorrer Recursivamente el Parse Tree• Construir la Representación Bottom-Up

– Buscar identificadores de variables en Tablas de Símbolos

– Construir Nodos Load para Accesar Variables

– Construir Expresiones a partir de Nodos Load y Nodos Operador

– Construir Nodos Store para Statements de Asignación

– Combinar Nodos Store con Nodos de Control de Flujo



v[i] = v[i]+x;

local descriptor para ifield descriptor para v parameter descriptor para x



v[i] = v[i]+x;

ldl




v[i] = v[i]+x;

ldl

ldf




v[i] = v[i]+x;

ldl len

ldf




v[i] = v[i]+x;

ldl

<

len

ldf




v[i] = v[i]+x;

ldl

<

len

ldfldf




v[i] = v[i]+x;

ldl

<

len

ldlldfldf




v[i] = v[i]+x;

ldl

<

len lda

ldlldfldf




v[i] = v[i]+x;

ldl

<

len lda ldp

ldlldfldf




v[i] = v[i]+x;

ldl

<

len lda

+

ldp

ldlldfldf




v[i] = v[i]+x;

ldl

<

len lda

+

ldp

ldlldf

ldf

ldf




v[i] = v[i]+x;

ldl

<

len lda

+

ldp

ldl

ldl

ldf

ldf

ldf




v[i] = v[i]+x;

ldl

<

len lda

+

ldp

ldl

sta

ldl

ldf

ldf

ldf




v[i] = v[i]+x;

ldl

while

<

len lda

+

ldp

ldl

sta

ldl

ldf

ldf

ldf



Notación Abreviada


v[i] = v[i]+x;

ldl i

while

<

len lda

+

ldp x

ldl i

sta

ldl i

ldf v

ldf v

ldf v


Conversión a Representación Intermedia de Bajo Nivel

• Convertir el Control de Flujo Estructurado a Control de Flujo por Saltos (Branches)– Conditional Branches

• Convertir el Modelo Estructurado de Memoria a Modelo Plano de Memoria– Stack Addressing para Locales– Flat Addressing para Campos– Flat Addressing para Arrays


MetaMantener la Independencia

de Máquina

PeroAcercarnos al Modelo de una

Máquina Estándar (espacio de direcciones plano, branches)


Convirtiendo el Control de Flujo Estructurado a Control de Flujo No

Estructurado


Representación del Programa

• Control Flow Graph (CFG)– Nodos CFG son Nodos de Instrucción

• Nodos stl, sta, stf, cbr nodes son instruction nodes

• Nodos ldl, lda, ldp, len, +, <, ... son expression nodes

– Aristas de CFG Representan el Flujo del Control– Divisiones (forks) en Instrucciones de Jump

Condicional– Uniones (merges) Cuándo el Control puede llegar a

un punto de múltiples formas– Nodos de Entrada y Salida (Entry & Exit Nodes)


ldl i

<

len

lda

+

ldp x

ldl i

sta

ldl i

ldf v

ldf v

ldf v

cbr

entry

exit

while (i < v.length)v[i] = v[i]+x;

Aristas deControl deFlujo

Aristas de Instrucción yExpresión


if (x < y) { a = 0;

} else { a = 1;

}

entry

ldl x ldl y

<

cbr

stl a 0 stl a 1

exit


Short-Circuit Conditionalswhile (i < v.length && v[i] != 0) {

i = i+1;}

entry

ldl i len

<

cbr

stl iexit

ldf v

lda 0

!=

cbr

ldf v ldl ildl i 0

+


Más Short-Circuit Conditionalsif (a < b || c != 0) {

i = i+1;}

entry

ldl a

<

cbr

stl i

exit

cbr

ldl i 0

+

ldl b

ldl c 0

!=


Rutinas para Desestructurar la Representación del Programa

destruct(n)genera forma de más bajo nivel para código representado por n retorna (b,e) - b es begin node, e es end node en forma desestructurada

shortcircuit(c, t, f)genera forma short-circuit del condicional representado por csi c es true, control va a nodo tsi c es false, control va a nodo fretorna b - b es begin node para evaluación de condición

Nuevo tipo de nodo - nop node


Desestructurando Seq Nodes destruct(n)

genera forma de más bajo nivel para código representado por n retorna (b,e) - b es begin node, e es end node en forma desestructuradasi n es de la forma seq x y

1: (bx,ex) = destruct(x); 2: (by,ey) = destruct(y); 3: next(ex) = by; 4: return (bx, ey);

seq

x y

bx

ex by

ey


Desestructurando Seq Nodes

destruct(n)

genera forma de más bajo nivel para código representado por n

retorna (b,e) - b es begin node, e es end node en forma desestructurada

si n es de la forma seq x y

1: (bx,ex) = destruct(x);

seq

x y

bx

ex



destruct(n)




1: (bx,ex) = destruct(x); 2: (by,ey) = destruct(y);

seq

x y

bx

ex by

ey



destruct(n)





3: next(ex) = by;

seq

x y

bx

ex by

ey



destruct(n)





3: next(ex) = by; 4: return (bx, ey);

seq

x y

bx

ex by

ey


Desestructurando If Nodes destruct(n)



si n es de la forma if c x y


3: e = new nop; 4: next(ex) = e; 5: next(ey) = e;

6: bc = shortcircuit(c, bx, by); 7: return (bc, e);

if

c ybc

bx ex

ex by ey


Desestructurando If Nodesdestruct(n)




1: (bx,ex) = destruct(x);

if

c y

bx ex

x







if

c y

bx ex

x by ey







3: e = new nop;

if

c y

bx ex

ex by ey








if

c y

bx ex

ex by ey








6: bc = shortcircuit(c, bx, by);

if

c ybc

bx ex

ex by ey








6: bc = shortcircuit(c, bx, by); 7: return (bc, e);

if

c ybc

bx ex

ex by ey


Desestructurando While Nodes

destruct(n)



si n es de la forma while c x

1: e = new nop; 2: (bx,ex) = destruct(x);

3: bc = shortcircuit(c, bx, e); 4: next(ex) = bc; 5: return (bc, e);

while

c x

bc

ebx

ex



destruct(n)




1: e = new nop;

while

c x

e



destruct(n)





while

c x

ebx

ex



destruct(n)





3: bc = shortcircuit(c, bx, e);

while

c x

bc

ebx

ex



destruct(n)





3: bc = shortcircuit(c, bx, e); 4: next(ex) = bc;

while

c x

bc

ebx

ex



destruct(n)





3: bc = shortcircuit(c, bx, e); 4: next(ex) = bc; 5: return (bc, e);

while

c x

bc

ebx

ex


Shortcircuiting Condiciones “And”

shortcircuit(c, t, f)

genera forma short-circuit del condicional representado por c

retorna b - b es begin node para forma shortcircuit

si c es de la forma c1 && c2

1: b2 = shortcircuit(c2, t, f); 2: b1 = shortcircuit(c1, b2, f);

3: return (b1);

c1 && c2

b1

fb2

t







1: b2 = shortcircuit(c2, t, f);

c1 && c2

fb2

t








c1 && c2

b1

fb2

t








3: return (b1);

c1 && c2

b1

fb2

t


Shortcircuiting Condiciones “Or”




si c es de la forma c1 || c2

1: b2 = shortcircuit(c2, t, f); 2: b1 = shortcircuit(c1, t, b2);

3: return (b1);

c1 || c2

b1

f

b2t







1: b2 = shortcircuit(c2, t, f);

c1 || c2

f

b2t








c1 || c2

b1

f

b2t








3: return (b1);

c1 || c2

b1

f

b2t


Shortcircuiting Condiciones “Not”




si c es de la forma ! c1

1: b = shortcircuit(c1, f, t); return(b);

b

f t

! c1


Condiciones Computadas




si c es de la forma e1 < e2

1: b = new cbr(e1 < e2, t, f); 2: return (b);

e1 < e2

e1 e2

<

cbr

t f


Nops En Representación Desestructurada

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

+

nop


Eliminando Nops Via Peephole Optimization

nop

... ...


Convirtiendo A Flat Address Space


Modelo de Memoria para Target Machine• Una sola memoria plana

– Compuesta de words– Direccionable por bytes

• Nodos Modelan Instrucciones Load y Store– ld addr,offset – resultado es contenido de memoria

en localidad addr+offset– st addr,offset,value - guarda value en localidad

addr+offset– Vamos a reemplazar nodos lda, ldf, ldl con nodos ld– Vamos a reemplazar nodos sta, stf, stl con nodos st


Layout de Memoria

Stack

Código Generado

HeapObjetos

Arreglos

locales(parámetros)

• ¿Cuándo se establece el código generado?

• ¿Cuándo crece ydisminuye el stack?

• ¿Cuándo crece ydisminuye el heap?


Parámetros

• La Mayoría de Máquinas tienen Convenciones de Llamado – Primer Parámetros en registro 5,

– Segundo Parámetro en registro 6, …

• Las Convenciones de Llamado varían entre máquinas• Asumimos que cada parámetro es un Word• Direccionamos los Parámetros por Número

– ldp <número de parámetro>

– this es el parámetro 0


Layouts de Objetos y Arrays

• Asignación Contigua para Objetos y Arrays• Campos Colocados Consecutivamente

– Tabla de Métodos en el Primer Word

• Elementos de Arrays Colocados Consecutivamente– Largo en Primer Word 3 7 4 8

Método getColor para point4 Método distance para polarPoint13

crt



Accesando Campos

• Asumimos que this apunta al principio del objeto• ¿Cuál es la dirección del campo r?

– Asumimos que cada campo ocupa 4 bytes

• this+(2*4), o base+field offset

Método getColor para point4 Método distance para polarPoint13

crt


this


Convirtiendo Nodos ldf a Nodos ld

• Computar los offsets de los campos– Recorrer la jerarquía de clase (tablas de símbolos de

campos)– Offsets para subclases comienzan donde terminan

los offsets de superclases– Guardar offsets en tabla de símbolos de campos

• Usar offsets para reemplazar nodos ldf con nodos ld


Cartesian Point Field Offsets

yx field descriptor para x (8)

field descriptor para y (12)

distance method descriptor para distance

c field descriptor para c (4)

getColor method descriptor para getColor

class descriptorpara point

class descriptorpara cartesianPoint


ldp 0

ld 8

ldp 0

ld 12

ldp 0

ld 12

ldp 0

ld 8

+ +

**

ldf

field descriptor para x (8)

+

ldf ldf

+

ldf

field descriptor para y (12)

Expresión Ejemplox*x + y*y


Accesando Elementos de Arrays

• Asumimos que variable array apunta al principio del array

• Elementos del array guardados contiguamente• No olvidar que el largo está al principio del array• ¿Cuál es la dirección de v[5]?• Asumimos enteros de 4 bytes• (dirección en v) + 4 + (5*4)• Base de Array + 4 + (índice * tamaño de elemento)


Convirtiendo Nodos lda a Nodos ld

• Computar Dirección de Elemento del Array– Base + 4 + (índice * tamaño de elemento)

• ld de esa dirección

• Offset de nodo ld es 0

• Optimización– Poner offset para saltarse el largo en instrucción ld


Ejemplo: v[5]+x

lda

+

ldp

field descriptor para v (4)

parameter descriptorpara x (1)

5ldf

ldp 0

ld 4 +

4 *

5 4

+

ld 0

+

ldp 1


Offset de Largo en Instrucción ld

lda

+

ldp



5ldf

ldp 0

ld 4 *

5 4

+

ld 4

+

ldp 1


Variables Locales

• Asumimos que están asignadas en el stack

• Direccionamos usando offsets de un call stack pointer

• Recordar, el stack crece para abajo, no para arriba, así que los offsets son positivos

• Símbolo especial sp contiene el stack pointer


Acciones al Invocar un Método• Caller

– Arreglar los parámetros usando convención– Arreglar dirección de retorno usando convención– Saltar al callee

• Callee– Asignar stack frame = Decrementar stack pointer– Computar– Arreglar valor de retorno usando convención– Liberar stack frame = Incrementar stack pointer– Retornar al caller


Administración del Stack

• Computar tamaño del stack frame– Asignado al entrar al método

– Liberado al retornar

– Tiene las variables locales

– Más espacio para todos los parámetros

– Asumimos que todos los locales y parámetros miden un word

• Computar offsets de locales y parámetros– Guardar en tablas de símbolos de locales y parámetros

– Todavía usamos nodos ldp para accesar parámetros


Eliminando Nodos ldl

• Usamos los offsets en tabla de símbolos de locales y el sp

• Reemplazamos todos los nodos ldl con nodos ld


Ejemplo de Offsets de Locales y Parámetros

this

i

this descriptor (8)

local descriptor (4)

field symbol tablepara vector class

local variablesymbol table

x

parametersymbol table

parameter descriptor (12)




Ejemplo: v[i]+x

lda

+

ldp



ldf

ldp 0

ld 4 *

4

+

ld 4

+

ldp 1

local descriptor para i (-4)

ldl

sp

ld 4


Nodos Enter y Nodos Exit para método add

void add(int x) {

int i;

...

}

• ¿Qué tan grande es el stack frame para add? – 12 bytes (espacio para this, x, i)– Asumiendo words de 4 bytes

enter 12

exit 12

....


ldp 0

ld 4 *

4

+

ld 4

+

ldp 1

sp

ld 4

ldp 0

ld 4 *

4

+

sp

ld 4

st 4

sp

ld 4

<

ldp 0

ld 4

Ejemplo con Direcciones

cbr

st 4

sp

ld 4+

1sp

st 4

sp 0

enter 12

exit 12

ld 0


Resumen• Accesos a Campos se traducen a nodos ld o st

– Dirección es pointer a objeto, offset es offset de campo

• Accesos a arrays se traducen a nodos ld o st– Dirección es pointer a array + 4 + (índice * tamaño de

elemento)– Ponemos el offset del largo (4) en instrucción ld o st

• Accesos locales se traducen a nodos ld o st– Dirección es sp, offset es offset de la variable local

• Accesos a parámetros se traducen a– Instrucciones lpd – específicando el número de parámetro

• Nodos Enter y Nodos Exit especifican el tamaño del stack frame

Compiladores Traducción a Formatos Intermedios. Oscar Bonilla 2Universidad Galileo Resumen Metas de...

Documents

Transcript of Compiladores Traducción a Formatos Intermedios. Oscar Bonilla 2Universidad Galileo Resumen Metas de...