generacion de codigo intermedio unidad 2

Procesadores de LenguajesIngeniería Técnica superior de Ingeniería Informática

Departamento de Lenguajes y Sistemas informáticos

Javier Vélez [email protected]

Departamento de Lenguajes Y Sistemas InformáticosUNED

Generación de código intermedio I

Sentencias y expresiones

Javier Vélez Reyes [email protected]

Generación de código intermedio. Sentencias y expresionesObjetivos

Objetivos

› Aprender en qué consiste la generación de código intermedio

› Aprender qué es el código intermedio

› Conocer los distintos tipos de lenguajes intermedios

› Valorar la importaría de realizar una buena elección del lenguaje intermedio

› Conocer cómo son los lenguajes intermedios lineales

› Entender el significado de las variables temporales en el código intermedio lineal

› Entender el significado de las etiquetas en el código intermedio lineal

› Aprender a construir esquemas de traducción para generar código intermedio

› Conocer los artefactos computacionales que son necesarios para darles soporte

› Aprender a generar código intermedio para expresiones

› Aprender a generar código intermedio para sentencias de control


Generación de código intermedio. Sentencias y expresionesÍndice

Índice

› Introducción

› Qué es el código intermedio

› La fase de generación de código intermedio

› El código intermedio como punto de desacoplamiento

› Lenguajes intermedios

› Representaciones jerárquicas de código intermedio

› Representaciones lineales de código intermedio

› Generación de código intermedio en la práctica

› Artefactos para la generación de código intermedio

› Generación de código intermedio para expresiones

› Generación de código intermedio para sentencias

› Desarrollo paso a paso

› Bibliografía


Generación de código intermedio. Sentencias y expresionesIntroducción

¿Qué es el código intermedio?Una vez superadas todas las fases de análisis del código fuente, el compilador debe ser capaz degenerar una representación simbólica del programa lo más aproximada a los potenciales lenguajesobjetivos al que se va a traducir el mismo pero lo suficientemente distante de éstos como paragarantizar su aplicabilidad en distintas arquitecturas físicas finales

El código intermedio es una representación abstracta del programa cercana a

los lenguajes objetivos potenciales pero independiente de cualquier

consideración específica de una arquitectura física concreta

I. Independencia del entorno de ejecución II. Independencia del juego de instrucciones

La independencia del entorno de ejecución serefiere al hecho de que el código intermediodebe ser agnóstico del modelo de organizaciónde memoria, el número, tipo y propósito deregistros, etc. Esto implica que todas lasreferencias a datos en código intermediosiguen haciéndose a través de símbolosregistrados o generados durante el proceso decompilación

El código intermedio de un programa esuna abstracción establecida a través de uncompromiso de consenso entre los equiposdedicados al análisis de lenguajes y losdedicados a la síntesis. Esto significa que lacolección de operadores disponibles en uncódigo intermedio se debe mantenerindependiente y equidistante de cualquierlenguaje y juego de instrucciones propio deuna arquitectura física real para garantizarla traducción a distintos códigos finales



La fase de generación de código intermedioLa fase de generación de código intermedio se encarga de traducir el programa a una representaciónde código intermedio para que luego ésta pueda ser transformada en las fases subsiguientes a uncódigo ejecutable en una determinada arquitectura física

› Expertos en lenguajes

› Independencia de arquitectura

› Dependencia de lenguaje

› Optimización de lenguajes

Ana

lizad

or lé

xico

Ana

lizad

or s

intá

ctic

o

Ana

lizad

or

sem

ánti

co

Códi

go in

term

edio

Códi

go fi

nal

e · l · i · h · w <WHILE, PR> S

WHILE E DO S

E > E

S

WHILE E DO S

E > E

√ 0000 0011 0000 00110100 00010100 00000001 0010…

While ( a > b ) doa := a + 1;

Etapa de análisis Etapa de síntesis

› Expertos en arquitecturas

› Dependencia de arquitectura

› Independencia de lenguaje

› Optimización de ejecución

LD a t1LD b t2GRT t3 t1 t2BRZ t3 L1 …



El código intermedio como punto de desacoplamientoEl código intermedio permite multiplexar los esfuerzos de desarrollo de los equipos de análisis delenguajes y de síntesis de manera que se pueden crear M x N compiladores distintos a partir de Mespecificaciones y N traducciones a arquitecturas físicas reales

Analizador léxico

Analizador sintáctico

Analizador semántico

Código intermedio

While ( a > b ) doa := a + 1;

Equi

po d

e Le

ngua

je

Optimización Código intermedio

Código final

Analizador léxico

Analizador sintáctico

Analizador semántico

Código intermedio

Optimización Código intermedio

Código final

LD a t1LD b t2GRT t3 t1 t2BRZ t3 L1 …

Equi

po d

e

arqu

itect

ura

Pascal C

Intel Solaris

Código

intermedio

M

N

…

…

while ( a > b ) a++;


Generación de código intermedio. Sentencias y expresionesLenguajes intermedios

Lenguajes intermediosEl primer paro para la generación de código intermedio consiste en el diseño de un lenguaje intermedioque permita representar de forma fiel y suficientemente abstracta los programas de un compilador.Existen distintas alternativas que describiremos a continuación

Leng

uaje

s in

term

edio

s

I. Representaciones jerárquicas

II. Representaciones lineales

Las representaciones jerárquicas decódigo intermedio reflejan los programasde un lenguaje como una estructurarelacional de nodos y arcos entre nodos.Estas representaciones son aconsejablespara tareas de análisis y transformaciónpero no para sintetizar ejecutables en unaarquitectura física real

I.I Arboles sintácticos abstractos

I.I Grafos dirigidos acíclicos

Son una representación similar a los árboles deanálisis sintácticos donde los artefactossemánticamente superfluos se omiten y los noterminales se sustituyen por operadores

Cuando los nodos de un árbol sintácticoabstracto son referenciados por más de unpadre surgen los grafos dirigidos acíclicos

Las representaciones lineales de códigointermedio codifican un programa comouna secuencia de instrucciones de bajonivel abstractas próximas al lenguajeensamblador. Este tipo de lenguajesresultan más apropiados para la etapa desíntesis puesto que se encuentran máscercanas a la estructura típica loslenguajes objetivos más comunes

II.I Lenguajes de tercetos o tripletas

II.II Lenguajes de cuartetos o cuádruplas

En los lenguajes de tercetos cada operacióntiene hasta dos operandos de entrada y uno desalida que se sobrescribe sobre alguno de losde entrada

En los lenguajes de cuartetos cada operacióntiene hasta 2 operandos de entrada y unoindependiente de salida para el resultado

Foco de atención



Representaciones jerárquicasLas representaciones jerárquicas describen el código fuente de un programa como una colección denodos relacionados entre sí a través de arcos con el mismo nivel de abstracción que lo hacen losárboles de análisis sintáctico

Árboles sintácticos abstractos

while (a>b) do a++

SWhile

WHILE ( E ) DO S

E > E

while (a>b) do a++

WHILE

> ++

ID ID ID

Los arboles sintácticos abstractos representan elcódigo fuente de un programa de acuerdo a unaestructura jerárquica de forma similar a como lo haceslos árboles de análisis sintáctico. En estasrepresentaciones no obstante se omiten todos tipo desímbolos semánticamente superfluos y se eliden los noterminales que dan información sobre el proceso dederivación gramatical

transformación

Árbol de análisis sintáctico Código intermedio

› Apto para análisis semántico

› Apto para procesos de transformación

› Inadecuado para la etapa de síntesis

› Representación excesivamente abstracta



Representaciones jerárquicasLas representaciones jerárquicas describen el código fuente de un programa como una colección denodos relacionados entre sí a través de arcos con el mismo nivel de abstracción que lo hacen losárboles de análisis sintáctico

Grafos dirigidos acíclicos

a := b * c + b * c

Asignación

ID

a := b * c + b * c

:=

Los arboles dirigidos acíclicos realizan unarepresentación del código fuente en forma de grafo. Elmétodo constructivo es similar al de los árbolessintácticos con la diferencia de que aquí se reutilizanlos nodos que reflejen la misma estructura én aras aresultar más eficiente su representación en memoria

transformación

Árbol de análisis sintáctico Código intermedio

› Apto para análisis semántico

› Apto para procesos de transformación

› Inadecuado para la etapa de síntesis

› Representación excesivamente abstracta

:= E

E E+

E E* E E*

+

*

ID ID

ID



Representaciones linealesLas representaciones lineales suponen un secuenciamiento de la información codificada en los árbolesde análisis sintácticos en forma de una colección de instrucciones abstractas de bajo nivel peromanteniendo las referencias simbólicas introducidas por el programador. Para articular el proceso desecuenciamiento se utilizan varios elementos como operandos de dichas instrucciones que seránutilizados en lo venidero a lo largo del tema

I. Valores literales II. Variables

En numerosas ocasiones las operaciones decódigo intermedio utilizan operandos querepresentan valores literales enteros con o sinsigno. La fase de traducción a código final seencarga posteriormente de traducir esosvalores a la representación numéricacorrespondiente utilizada por la arquitectura

Muchos de los símbolos declarados por elprogramador, tales como constantes,variables globales o locales y parámetros,son referidos de forma general dentro delcódigo intermedio como operandos de tipo‘variable’

Los valores literales utilizados como

operandos en las operaciones de los

lenguajes de código intermedio lineales

representan valores enteros con signo

Las variables de código intermedio

representan las constantes, variables

globales o locales y parámetros declarados

por el programador a lo largo del código

fuente



Representaciones linealesLas representaciones lineales suponen un secuenciamiento de la información codificada en los árbolesde análisis sintácticos en forma de una colección de instrucciones abstractas de bajo nivel peromanteniendo las referencias simbólicas introducidas por el programador. Para articular el proceso desecuenciamiento se utilizan varios elementos como operandos de dichas instrucciones que seránutilizados en lo venidero a lo largo del tema

III. Variables temporales IV. Etiquetas de código

El secuenciamiento de expresiones complejasrequiere del almacenamiento temporal de losresultados parciales de las subexpresiones enespacios de memoria específicamentereservados para ello. Los elementos de códigointermedio que se utilizan para referencias esasdirecciones se llaman variables temporales

Muchas de las sentencias de un lenguaje dealto nivel (control de flujo, invocación desubprogramas, etc.) requieren insertaretiquetas en el código final para luego realizarsaltos a ellas. La forma de referirse a estasetiquetas en código intermedio es mediantelas etiquetas de código

Una variable temporal es la representación

simbólica en código intermedio de un

espacio de memoria destinado a almacenar

un resultado parcial de alguna expresión

Una etiqueta de código es una referencia de

código intermedio a una zona de memoria

donde comienza cierta porción de código

final



Representaciones linealesLas representaciones lineales suponen un secuenciamiento de la información codificada en los árbolesde análisis sintácticos en forma de una colección de instrucciones abstractas de bajo nivel peromanteniendo las referencias simbólicas introducidas por el programador. A continuación describimos los2 tipos de representaciones lineales

Lenguajes de tercetosLas representaciones de código intermedio basadas entercetos están formados por una secuencia deinstrucciones constituida por 3 elementos: un código deoperación, un operando de entrada y otro de entrada ysalida para almacenar el resultado

› Apto para la etapa de síntesis

› Representación cercana al lenguaje objetivo

› Complejidad en la traducción de construcciones

ADD x y

El código de operación es unacrónimo que representa el tipode operación que se aplicanentre los operandos del terceto

Código de operación

Los operandos identifican los elementossobre los que se efectúa la operaciónreferida por el código de operación.Pueden ser valores literales, variables,variables temporales o etiquetas

Operandos

En los lenguajes de tercetos uno de losoperandos hace de almacén para el resultadode la operación lo que supone que eloperando de entrada se pierde tras suejecución

Resultado




Lenguajes de tercetosLas representaciones de código intermedio basadas entercetos están formados por una secuencia deinstrucciones constituida por 3 elementos: un código deoperación, un operando de entrada y otro de entrada ysalida para almacenar el resultado



› Complejidad en la traducción de construcciones

a := b * c

Asignación

ID

a := b * c

transformación

Árbol de análisis sintáctico

Código intermedio

:= E

E E*

ID ID

(a)

(b) (c)

LOAD t0 bLOAD t1 cMUL t1 t0STORE t1 a

t0 bt1 ct1 t1 * t0 t1 a




Lenguajes de cuartetosLas representaciones de código intermedio basadas encuartetos están formados por una secuencia deinstrucciones constituida por 4 elementos: un código deoperación, dos operando de entrada y otro de salidapara almacenar el resultado



› Mayor sencillez en la traducción de construcciones

ADD x y z

El código de operación es unacrónimo que representa el tipode operación que se aplicanentre los operandos del terceto

Código de operación

Los operandos identifican los elementossobre los que se efectúa la operaciónreferida por el código de operación.Pueden ser valores literales, variables,variables temporales o etiquetas

Operandos

En los lenguajes de cuartetos el almacénpara el resultado de la operación es unoperando de salida independiente lo quesupone que no hay perdida de informacióntras la ejecución de la operación

Resultado




Lenguajes de cuartetos

a := b * c

Asignación

ID

a := b * c

transformación

Árbol de análisis sintáctico

Código intermedio

:= E

E E*

ID ID

(a)

(b) (c)

LOAD t0 bLOAD t1 cMUL t2 t1 t0STORE t2 a

t0 bt1 ct2 t1 * t0t2 a

Las representaciones de código intermedio basadas encuartetos están formados por una secuencia deinstrucciones constituida por 4 elementos: un código deoperación, dos operando de entrada y otro de salidapara almacenar el resultado



› Mayor sencillez en la traducción de construcciones


Generación de código intermedio. Sentencias y expresionesGeneración de código intermedio en la práctica

Artefactos para la generación de código intermedioLa generación de código intermedio se realiza a través de la definición de accesos semánticas en losesquemas de traducción gramaticales. Para llevar esto a cabo, el framework de desarrollo proporcionauna colección de artefactos que conviene conocer

ScopeManager

TemporalTable Scope SymbolTable

Create >

SymbolIF

Label

Temporal Value

Variable

TypeTable TypeIF

Quadruple

LabelFactory

TemporalFactoryCreate >

Reference to >

IntermediateCodeBuilder Create >< uses

OperandIF




CuádruplasLas cuádruplas son el elemento central de la arquitectura. Representan cada una de las operacionesatómicas que pueden ser referenciadas dentro del código intermedio para que surtan cierto efecto orealicen cierto cálculo a partir de los operandos

Quadruple

+ String getOperation ()

+ void setOperation ()

+ OperandIF getFirstOperand ()

+ void setFirstOperand (OperandIF o)

+ OperandIF getSecondOperand ()

+ void setSecondOperand (OperandIF o)

+ OperandIF getResult ()

+ void setResult (OperandIF o)

Los objetos de tipo Quadruple se utilizan pararepresentar operaciones atómicas del códigointermedio. Una cuadrupla está formado por un códigode operación, un operando opcional resultado y a losumo dos operandos de entrada también opcionales.En efecto, en función del tipo de operación el numerode operandos puede variar. Puede haberinstrucciones con ningún operando ni resultado, comoHALT. Puede haber otras con un sólo operando comolos saltos del tipo BR L. O puede haber instruccionescon un resultado y dos operandos como en la sumaADD t3 t1 t2.




Variables, temporales, valores y etiquetasLos operandos sobre los que operan las cuádruplas son de uno de cuatro tipos: variables, variablestemporales, valores literales enteros y etiquetas. Dentro de la arquitectura existe una clase abiertapara representar cada uno de estos tipos que el alumno debe carácter con atributos

Variable

-String name

-ScopeIF scope

-Boolean isGlobal

Temporal

-String name

-ScopeIF scope

-Integer address

Label

-String name

-ScopeIF scope

Value

-Integer value




Tabla de temporalesLos temporales que se van generando a medida que el compilador procesa las expresiones dellenguaje deben almacenarse en una tabla de temporales asociada a cada ámbito. Este es un aspectoimportante para las fases posteriores. El artefacto TemporalTable gestiona los temporales de unámbito

TemporalTable

-ScopeIF scope

-List <TemporalIF> temporals

+ ScopeIF getScope ()

+ TemporalTable (ScopeIF scope)

+ List <TemporalIF> getTemporals ()

+ void addTemporal (TemporalIF temporal)

+ boolean containsTemporal (TemporalIF temporal)

Cada tabla de temporales se crea de formaautomática asociada a un ámbito cuando estees abierto a través del gestor de ámbitos. Portanto existe una tabla de temporales para cadaámbito. La responsabilidad de este artefacto esgestionar la colección de temporalesgenerados durante el proceso de compilacióndel bloque sintáctico asociado al ámbito. Losmétodos addTemporal y getTemporals sirvenpara registrar y tener acceso a los temporalesrespectivamente y son de utilidad en ésta y enlas fases posteriores de generación de códigofinal




Factorías de etiquetas y temporalesAunque la construcción de temporales y etiquetas puede realizarse haciendo uso directo de losconstructores en sendas clases, el framework proporciona dos tipos de factorías cuyo uso paraconstruir objetos de estas clases resulta recomendable por las ventajas que ello supone

TemporalFactory

+ TemporalFactory (ScopeIF scope)

+ TemporalIF create (String name)

+ TemporalIF create ()

LabelFactory

+ LabelFactory (ScopeIF scope)

+ LabelIF create (String name)

+ LabelIF create ()

La factoría de temporales es un artefacto asociado aun ámbito pasado como argumento en el constructorque se utiliza para crear temporales. El primer métodocreate construye un temporal con nombre propio y loregistra automáticamente en la tabla de temporales. Ladiferencia del segundo create, es que éste métodoconstruye el temporal con un nombre autogeneradoque garantiza la unicidad dentro del ámbito

La factoría de etiquetas es un que se utiliza para crearetiquetas. El primer método create construye unaetiqueta con nombre propio. La diferencia del segundocreate, es que éste método construye la etiqueta conun nombre autogenerado que garantiza la unicidad




IntermediateCodeBuilderLa construcción de las cuádruplas que componen el código intermedio puede realizarse porinvocación de sus constructores de clase. No obstante, resulta más sencillo y económico utilizarinstancias de IntermediateCodeBuilder para realizar esta labor

IntermediateCodeBuilder

+ void addQuadruple (String op, r)

+ void addQuadruple (String op, r, o1)

+ void addQuadruple (String op, r, o1, o2)

+ void addQuadruple (QuadrupleIF q)

+ void addQuadruples (List <QuiadrupleIF> code)

+ List <QuadrupleIF> create ()

Las operaciones addQuadruple se encargan deinsertar un nuevo cuarteto dentro de la listainterna de código intermedio. Sin embargo susemántica depende del tipo y formato de losoperandos

Primero se instancia el code builder pasándolecomo argumento de constructo el ámbito. Despuésse utilizan los métodos addQuadruple para iracumulando cuartetos internamente. Al finalizar laacción semántica el código se obtiene invocando elmétodo create ()

› Si es de tipo OperandIF se inserta tal cual

› Si es de tipo int se crea un Value y se inserta

› Si es de tipo String

› Si comienza por “L_” se crea Label y se inserta

› Si comienza por “T_” se crea Temporal y se inserta

› Sino se busca en TS’s, se crea Variable y se inserta



Diseño del lenguaje intermedio Antes de proceder con la generación de código intermedio es necesario determinar el juego deinstrucciones (cuartetos) que será empleado. Estudie para ello el/los lenguajes objetivos finales

Cuarteto Descripción

NOP

ADD x y z

SUB x y z

MUL x y z

DIV x y z

MOD x y z

INC x y

DEC x y

NEG x y

GR x y z

EQ x y z

LS x y z

AND x y z

OR x y z

XOR x y z

Nada

x := y + z

x := y – z

x := y * z

x := y / z

x := y % z

x := y + 1

x := y – 1

x := – y

x := (y > z) ? 1 : 0

x := (y == z) ? 1 : 0

x := (y < z) ? 1 : 0

x := y && z

x := y || z

x := y ^ z

Cuarteto Descripción

NOT x y

BR L

BRT x L

BRF x L

INL L

MV x y

MVP x y

MVA x y

STP x y

STA x y

PUSH x

POP x

CALL f

RET x

HALT

x := !y

Salto a L

Si x, salto a L

Si !x, salto a L

Insertar L:

x := y

x := *y

x := &y

*x := y

&x := y

*SP := x ; SP++

x := *SP ; SP --

Llamada a función f

Retorno de f con valor x

Stop



Generación de código intermedio en CupUna vez que conocemos los artefactos proporcionados por el framework para la fase de generación decódigo y diseñado un lenguaje de código intermedio apropiado, estamos en disposición de articulardicha generación dentro del esquema de traducción dirigida por la sintaxis de cup

Expresiones Expresiones

exp ::= exp:e1 MAS exp:e2 {:

Exp e = new Exp();

<<comprobación de tipos de e1 y e2>>

ScopeIF scope = scopeManager.getCurrentScope();

TemporalFactory tF = new TemporalFactory (scope);

IntermediateCodeBuilder cb = new …Builder (scope)

TemporalIF temp1 = e1.getTemporal ();


TemporalIF temp = tF.create ();

cb.addQuadruples (e1.getCode ());


cb.addQuadruple (“ADD”, temp, temp1, temp2);

e.setTemporal (temp);

e.setCode (cb.create());

RESULT = e

:}

exp ::= exp:e1 MENOS exp:e2 {: ... :}

exp ::= exp:e1 POR exp:e2 {: ... :}

...

exp ::= exp:e1 AND exp:e2 {: ... :}

exp ::= exp:e1 OR exp:e2 {: ... :}

exp ::= NOT exp:e1 {: ...







cb.addQuadruple (“NOT”, temp, temp1);



RESULT = e :}




Expresiones Expresionesexp ::= PI exp:e1 PD {:

RESULT = e1;

:}

exp ::= rNumero:rn {:

Exp e = new Exp ();

Integer value = rn.getValue ();

<<Comprobación de tipos>>



IntermediateCodeBuilder cb = new …Builder (scope);


cb.addQuadruple (“MV”, temp, value);

e.setTemp (temp);

e.setCode (cb.create ()):

RESULT = e;

:}

exp ::= MENOS exp:e1 {:

Exp e = new Exp();

<<comprobación de tipos de e1 y e2>>







cb.addQuadruple (“NEG”, temp, temp1);



RESULT = e;

:}




Expresiones Referencias

exp ::= referencia:r {:

Exp e = new Exp ();

e.setType (r.getType ());




TemporalIF rTemp = r.getTemporal ();


cb.addQuadruples (r.getCode ());

cb.addQuadruple (“MVP”, temp, rTemp);

e.setTemp (temp);

e.setCode (cb.create ()):

RESULT = e;

:}

referencia ::= ID:id {:

Referencia r = new Referencia ();

String name = id.getLexema ();






SymbolVariable sV = scopeManager.searchSymbol (name);

Variable var = new Variable (name, sV.getScope ());

cb.addQuadruple (“MVA”, temp, var);

referencia.setTemporal (temp);

referencia.setCode (cb.create ());

RESULT = referencia;

:}




Referencias a elementos de Arrays

referencia ::= ID:id {:

Referencia r = new Referencia ();







TemporalIF tempI = tF.create ();

cb.addQuadruple (“MVA”, temp, name);

cb.addQuadruple (“MV”, tempI, 0);

referencia.setTemporal (temp);

referencia.setTemporalIndex (tempI);

referencia.setCode (cb.create ());

RESULT = referencia;

:}

D1

V [i][j][k]

i

D2

D3

k

V

&v + i x (D2 x D3 x size)

+ j x (D3 x size)

+ k x size

size

t1 := 0

t2 := t1 x D1 + i

t3 := t2 x D2 + j

t4 := t3 x D3 + k

t5 := &v + t4 x size

=

j





referencia ::= referencia:r CI exp:e CD {:

Referencia rn = new Referencia ();

<<comprobación de tipos>>

TypeIF rType = r.getType();

int rDim = rType.getMax () – rType.getMin () + 1;

TemporalFactoryIF tF = new TemporalFactory (scope);


TemporalIF rTempI = r.getTemporalIndex ();

TemporalIF eTemp = e.getTemporal ();

TemporalIF rnTempI = tF.create ();

IntermadiateCodeBuilder cb = new …Builder (scope);

cb.addQuadruples (e.getCode ());


cb.addQuadruple (“MUL”, rnTempI, rTempI, rDim);

cb.addQuadruple (“ADD”, rnTempI, rnTempI, eTemp);

rn.setType (rType.getBaseType());

rn.setTemporal (rTemp); rn.setTemporalIndex (rnTempI);

r.setCode (cb.create()); RESULT = rn; :}

D1

V [i][j][k]

i

D2

D3

k

V


+ j x (D3 x size)

+ k x size

size

t1 := 0

t2 := t1 x D1 + i

t3 := t2 x D2 + j

t4 := t3 x D3 + k


=

j





exp ::= referencia:r {:

Exp e = new Exp ();


ScopeIF scope = scopeManager.getCurrentScope ();




TemporalIF eTemp = tF.create ();


int rSize = rType.getSize ();



cb.addQuadruple (“MUL”, eTemp, rTempI, rSize);

cb.addQuadruple (“ADD”, eTemp, eTemp, rTemp);

cb.addQuadruple (“MVP”, eTemp, eTemp);

e.setTemporal (eTemp);


RESULT = e; :}

D1

V [i][j][k]

i

D2

D3

k

V


+ j x (D3 x size)

+ k x size

size

t1 := 0

t2 := t1 x D1 + i

t3 := t2 x D2 + j

t4 := t3 x D3 + k


=

j




Referencia a campos de registro Referencia a campos de registro

referencia ::= referencia:r PUNTO ID:id {:

Referencia rn = new Referencia ();







TemporalIF rTempO = tF.create ();



TypeRecord rType = r.getType ();

int idOffset = rType.getOffset (name);

cb.addQuadruple (“MV”, rTempO, idOffset);

rn.setTemporal (rTemp);

rn.setTemporalIndex (rTempI);

rn.setTemporalOffset (rTempO) ;

rn.serCode (cb.create()); RESULT = rn; :}

expr ::= referencia:r {:

Exp e = new Exp ();






TemporalIF rTempO = r.getTemporalOffset ();

TemporalIF eTemp = tF.create ();


int rSize = rType.getSize ();



cb.addQuadruple (“MUL”, eTemp, rTempI, rSize);

cb.addQuadruple (“ADD”, eTemp, eTemp, rTemp);

cb.addQuadruple (“ADD”, eTemp, eTemp, rTempO);

cb.addQuadruple (“MVP”, eTemp, eTemp);

e.setTemporal (eTemp); e.setCode (cb.create()); RESULT = e; :}




Sentencia asignación Sentencia If

sentenciaAsignacion ::= referencia:r IGUAL exp:e {:

SentenciaAsignacion sa = new SAsignacion ();







TemporalIF rTempO = r.getTemporalOffset ();





cb.addQuadruple (“MUL”, temp, rTempI, rSize);

cb.addQuadruple (“ADD”, temp, temp, rTemp);

cb.addQuadruple (“ADD”, temp, temp, rTempO);

cb.addQuadruple (“STP”, temp, eTemp);

sa.setCode (cb.create()); RESULT = sa; :}

sentenciaIF ::= IF PI exp:e PD s:s1 ELSE s:s2 {:

SentenciaIf sIf = new SIf ();



LabelFactoryIF lF = new LabelFactory (scope);

LabelIF l1 = lF.create ();





cb.addQuadruple (“BRF”, eTemp, l1);

cb.addQuadruples (s1.getCode ());

cb.addQuadruple (“BR”, l2);

cb.addQuadruple (“INL”, l1);



sIF.setCode (cb.create ());

RESULT = sIF; :}




Sentencia While Sentencia For

sentenciaWhile ::= WHILE PI exp:e PD s:s1 {:

SentenciaWhile sWhile = new SWhile ();














sWhile.setCode (cb.create ());

RESULT = sWhile; :}

sentenciaFor ::= FOR sAsignacion:sa TO exp:e DO s:s1 {:

SentenciaFor sFor = new SFor ();








cb.addQuadruples (sa.getCode ());







sFor.setCode (cb.create ());

RESULT = sFor; :}



1. Diseñar un lenguaje intermedio

- Identificar todas las operaciones necesarias y asignarles un acrónimo y semántica

- Tomar como referencia el lenguaje objeto de la arquitectura real

- Comenzar por un juego sencillo e ir refinándolo bajo demanda

2. Implementar las clases necesarias del framework

- Caracterizar mediante atributos los operandos: Variable, Temporal, Label, Value

- Incluir atributos necesarios a cada no terminal (Expresión, Sentencias, Referencias, …)

- Considerar revisar la definición de otros artefactos: TypeIF, …

3. Implementar las acciones semánticas que generan código intermedio

- Código intermedio para expresiones, referencias, sentencias…

- Incorporar este código al del comprobador de tipos implementado en la fase anterior

4. Probar el código intermedio

- Ejecutar el finalTestCase

- semanticErrorManager.debug en reglas para que imprima el código intermedio generado

Desarrollo paso a pasoLa fase de generación de código intermedio requiere de la implementación de acciones semánticas enel esquema de traducción dirigidas a producir un código lineal cercano al código objeto peroindependiente de una arquitectura física real. A continuación se resumen los pasos recomendados paraesta fase


Generación de código intermedio. Sentencias y expresionesBibliografía

Material de estudio

Bibliografía básica

Construcción de compiladores: principios y práctica

Kenneth C. Louden International Thomson Editores,

2004 ISBN 970-686-299-4


Generación de código intermedio. Sentencias y expresionesBibliografía

Material de estudio

Bibliografía complementaria

Compiladores: Principios, técnicas y herramientas.

Segunda Edición Aho, Lam, Sethi, Ullman

Addison – Wesley, Pearson Educación, México 2008

Diseño de compiladores. A. Garrido, J. Iñesta, F. Moreno

y J. Pérez. 2002. Edita Universidad de Alicante

generacion de codigo intermedio unidad 2

Documents