Código de tres direcciones - Página personal de César Ignacio

Transcripción

Introducción
• En el modelo de análisis y síntesis de un compilador, la etapa inicial traduce
un programa fuente a una representación intermedia a partir de la cual la
etapa final genera el código objeto. Los detalles del lenguaje objeto se
confinan en la etapa final, si esto es posible.
• Al generar el código intermedio facilito la independencia de la máquina,
además es más fácil la optimización del código intermedio.
a la entrada para b
id
1
• Los códigos intermedios pueden ser:
a la entrada para c
id
2
asigna
– Árbol sintáctico
– Notación postfija
– Código de 3 direcciones
a
+
Ejemplo: a:=b*-c+b*-c
*
asigna
b
a
3
4
5
6
7
8
menosu
+
*
b
Código
para el
árbol
César Ignacio García Osorio. Universidad de Burgos.
t1:=-c
t2:=b*t1
t5:=t2+t2
a:=t5
a la entrada para a
a la entrada
para a
+
*
c
id
a la entrada
para b
a la entrada
para c
PL. Generación de código
Código de tres direcciones
• Es una especie de código máquina de la forma general:
x:=y op z
donde x, y y z son nombres, constantes o variables temporales
generadas por el compilador, op representan cualquier operador.
• No se permite ninguna expresión aritmética compuesta, pues sólo
hay un operador en el lado derecho de una proposición.
• El uso de nombres para los valores intermedios calculados por un
programa permite que el código de tres direcciones se reorganice
fácilmente – a diferencia de la notación postfija –.
• Es una representación linealizada de un árbol sintáctico o un GDA
en la que los nombres explícitos corresponden a los nodos
interiores del grafo.
t1:=-c
t2:=b*c
t3:=-c
t4:=b*t3
t5:=t2+t4
a:=t5
5
id
menosu
Ejemplos
6
menosu
a b c menosu * b c menosu * + asigna
(1)
3
4
id
*
menosu b
1
1
4
asigna
c
c
-
*
+
id
:=
2
(2)
• Tipos de proposiciones de tres direcciones
1. Asignación de operadores binarios:
• x:=y op z
2. Asignación de operadores unarios:
• x:=op y
3. Proposiciones de copia:
• x:=y
4. Salto incondicional:
• goto E
5. Saltos condicionales:
• if x oprel y goto E
Código
para el
GDA
6. Llamadas a procedimientos:
• param x
• call p, n
• return y
3
4
(3)
• D.D.S. para producir código de tres direcciones
7. Asignaciones con índices:
• x:=y[i]
• x[i]:=y
PRODUCCIÓN
S → id := E
E → E1 + E2
8. Asignaciones de direcciones y apuntadores:
• x:=&y
• x:=*y
• *x:=y
E → E1 * E2
E → - E1
E → ( E1 )
E → id
• El conjunto de operadores debe ser lo bastante rico como para
implantar las operaciones del lenguaje fuente.
5
(5)
• Esquema de traducción para producir código de tres direcciones
id:= E {emite(id.lugar ':=' E.lugar) }
E1+E2 {E.lugar:= tempnuevo; emite(E.lugar ':=' E1.lugar '+' E2.lugar) }
E1*E2 {E.lugar:= tempnuevo; emite(E.lugar ':=' E1.lugar '*' E2.lugar) }
-E1
{E.lugar:=tempnuevo; emite(E.lugar ':=' 'menosu' E1.lugar) }
{E.lugar:=E1.lugar }
(E1)
{E.lugar:=id.lugar }
id
while {S.comienzo:=etiqnueva; S.después:=etiqnueva; emite(S.comienzo ':') }
E do {emite('if' E.lugar '=' '0' 'goto' S.despues)}
{emite('goto' S.comienzo); emite(S.despues ':') }
S1
{I.falso:=etiqnueva;}
S→ if
E then {emite('if' E.lugar '=' '0' 'goto' I.falso); }
S1 I
I→ endif {emite(I.falso ':') }
{I.después:=etiqnueva; emite('goto' I.después); emite(I.falso ':') }
I→ else
S endif {emite(I.después ':') }
E.lugar:= E1.lugar;
E.lugar:= id.lugar;
E.código:= E1.código
E.código:= ' '
S→
E→
E→
E→
E→
E→
S→
REGLAS SEMÁNTICAS
S.código:= E.código || gen(id.lugar ':=' E.lugar)
E.lugar:= tempnuevo;
E.código:= E1.código||E2.código||gen(E.lugar ':=' E1.lugar '+' E2.lugar)
/* similar al operador de suma de la regla anterior */
E.lugar:= tempnuevo;
E.código:= E1.código || gen(E.lugar ':=' 'menosu' E1.lugar)
S → while E do S1 S.comienzo:= etiqnueva;
S.después:= etiqnueva;
S.código:= gen(S.comienzo ':') || E.código ||
gen('if' E.lugar '=' '0' 'goto' S.despues) ||
S1.código || gen('goto' S.comienzo) ||
gen(S.despues ':')
– Aunque un conjunto de operadores pequeño es más fácil de implantar,
un conjunto de instrucciones limitado puede obligar a la etapa inicial a
generar largas secuencias de proposiciones para algunas operaciones del
lenguaje fuente lo que obliga a trabajar más al optimizador y al
generador de código para producir buen código.
(4)
7
6
(5)
• Implantación de proposiciones de tres direcciones
– Cuádruplos: Es una estructura tipo registro con cuatro campos, que se
llamarán op, arg1, arg2 y resultado. El campo op contiene un código
interno para el operador. La proposición de tres direcciones x:=y op z
se representan poniendo y en arg1, z en arg2 y x en resultado.
– Los contenidos de los campos arg1, arg2 y resultado son generalmente
apuntadores a las entradas de la tabla de símbolos.
Ejemplo
op
arg1 arg2 resultado
a:=b*-c+b*-c
(0) menosu
c
(1)
b
*
t1
t1
t2
(2) menosu
c
(3)
*
b
t3
t4
(4)
+
t2
t4
t5
(5)
:=
t5
t3
a
8
(6)
– Triples: Estructura tipo registro con sólo tres campos: op, arg1 y arg2.
– Para evitar introducir nombres temporales en la TS, se hace referencia a
un valor temporal según la posición de la proposición que lo calcula.
– Los campos arg1 y arg2 son apuntadores a la tabla de símbolos o
apuntadores dentro de la estructura de triple.
Ejemplos
op
a:=b*-c+b*-c
arg1
(0) menosu
c
(1)
b
*
arg2
(0)
(2) menosu
c
(3)
*
b
(2)
(4)
+
(1)
(3)
a
(4)
(5) asigna
(0)
arg1
arg2
[]=
x
i
(0)
(14)
(14) menosu
c
(0)
y
(1)
(15)
(15)
b
(2)
(16)
(16) menosu
c
x[i]:=y
arg2
(3)
(17)
(17)
*
b
(16)
=[]
y
i
(4)
(18)
(18)
+
(1)
(17)
x
(0)
(5)
(19)
(19)
:=
a
(18)
(1) asigna
x:=y[i]
9
(1)
10
(2)
• Proceso de declaraciones en procedimientos anidados
{ desplazamiento:=0 }
{ introduce(id.nombre, T.tipo, desplazamiento);
desplazamiento := desplazamiento + T.ancho }
{ T.tipo:=integer; T.ancho:=4 }
{ T.tipo:=real; T.ancho:=8 }
{ T.tipo:=array(núm.val, T1.tipo);T.ancho:= núm.val×T1.ancho }
{ T.tipo:=pointer(T1.tipo); T.ancho:= 4}
• introduce(nombre, tipo, desplazamiento) crea una entrada en la TS para nombre, le
da el tipo tipo y la dirección relativa desplazamiento en su área de datos.
• El atributo tipo representa una expresión de tipos construida a partir de los tipos
básicos integer y real aplicando los constructores de tipos pointer y array. Si las
expresiones de tipos se representan por medio de grafos, entonces el atributo tipo
puede ser un apuntador al nodo que representa una expresión de tipo.
Declaraciones
P→MD
(14)
arg1
• Cálculo de los tipos y direcciones relativas de nombres declarados
T → integer
T → real
T → array [ núm ] of T1
T → ^T1
*
op
Declaraciones
P→MD
M→ ε
D → D1 ; D2
D → id : T
– Triples indirectos: Se utiliza una lista de los apuntadores a triples, en
lugar de hacer una lista de los triples mismos.
– Esta implantación tiene la ventaja de que en un compilador optimizador
no sería necesario cambiar los triples (y por tanto el índice mediante el
que son referenciados) sino únicamente el índice en la matriz
proposición.
Ejemplo
op
arg1 arg2
proposición
op
(1) asigna
(0)
(7)
11
{ añadeancho(tope(tblpn), tope(desplazamiento));
saca(tblapn); saca(desplazamiento) }
{ t:=creatabla(nil); mete(t, tblapn); mete(0, desplazamiento) }
M→ ε
D → D1 ; D2
D → proc id ; N D1 ; S { t:=tope(tblapn);
añadeancho(t, tope(desplazamiento));
saca(tblapn); saca(desplazamiento);
introduceproc(tope(tblapn), id.nombre, t); }
{ introduce(tope(tblapn), id.nombre, T.tipo, tope(desplazamiento));
D → id : T
tope(desplazamiento):= tope(desplazamiento) + T.ancho }
{ t:=creatabla(tope(tblapn));
N→ ε
mete(t, tblapn); mete(0, desplazamiento) }
{ T.tipo:=record(tope(tblapn)); T.ancho:=tope(desplazamiento));
T → record L D end
saca(tblapn); saca(desplazamiento) }
{ t:=creatabla(tope(tblapn));
L→ ε
mete(t, tblapn); mete(0, desplazamiento) }
12
Proposiciones de asignación
(1)
Almacenamiento en memoria de
una matriz A de dimensiones
(n1=2)×(n2=3)×(n3=4)
if p≠nil then
emite(p ':=' E.lugar)
E → E1 * E2
E → - E1
E → ( E1 )
E → id
base
else error }
{ E.lugar:=tempnuevo;
emite(E.lugar ':=' E1.lugar '+' E2.lugar) }
emite(E.lugar ':=' E1.lugar '*' E2.lugar) }
emite(E.lugar ':=' 'menosu' E1.lugar) }
A[inf1, inf2, inf3+3]
E→(E1)
E→L
A[inf1+1,*,*]
13
(3)
base+(i3−inf3+n3·(i2−inf2+n2·(i1−inf1)))·a
{ E.lugar:= E1.lugar }
{ if L.desplazamiento=null then E.lugar:=L.lugar
else begin E.lugar:=tempnuevo;
emite(E.lugar ':=' L.lugar '[ ' L.desplazamiento ']');
end}
{ L.lugar:=tempnuevo;
L.desplazamiento:=tempnuevo;
emite(L.lugar ':=' c(listaE.matriz));
emite(L.desplazamiento ':=' listaE.lugar '*' ancho(listaE.matriz)); }
{ L.lugar:=id.lugar; L.desplazamiento:=null }
L→id
listaE→listaE1,E { t:=tempnuevo;
m:= listaE1.ndim+1 ;
emite(t ':=' límite(listaE1.matriz,m) '*' listaE1.lugar);
emite(t ':=' E.lugar '+' t);
listaE.matriz:=listaE1.matriz; listaE.lugar:=t; listaE.ndim:=m }
{ listaE.matriz:=id.lugar; listaE.lugar:=E.lugar; listaE.ndim:=1 }
listaE→ id[E
L→listaE]
[base−(inf3+n3·(inf2+n2·inf1)))·a]+(i3+n3·(i2+n2·i1)))·a
Esta fórmula se puede generalizar a una matriz de k
dimensiones n1×n2×... ×nk con nm=supm−infm+1 para
la que los elementos que dependen de los índices se
pueden calcular utilizando la recurrencia:
e1=i1
em=im+nm·em-1
14
(4)
• Conversión de tipo dentro de asignaciones
• En la práctica, hay muchos tipos diferentes de variables y constantes, así que el
compilador debe rechazar algunas operaciones de tipos mixtos o bien generar las
instrucciones de coerción (conversión de tipos) apropiadas.
• Por ejemplo, para la producción E→E1+E2 se podría tener la siguiente acción semántica.
E.lugar:=tempnuevo
if E1.tipo=integer and E1.tipo=integer then begin
emite(E.lugar ':=' E1.lugar '+ent' E2.lugar);
E.tipo=integer
end else if E1.tipo=real and E2.tipo=real then begin
emite(E.lugar ':=' E1.lugar '+real' E2.lugar);
E.tipo=real
end else if E1.tipo=integer and E2.tipo=real then begin
u:=tempnuevo;
emite(u ':=' 'entareal' E1.lugar);
E.tipo=real
emite(E.lugar ':=' u '+real' E2.lugar);
end else if E1.tipo=real and E2.tipo=integer then begin
u:=tempnuevo;
emite(u ':=' 'entareal' E2.lugar);
E.tipo=real
emite(E.lugar ':=' E1.lugar '+real' u);
end else E.tipo=error_tipo;
{ if L.desplazamiento=null then emite(L.lugar ':=' E.lugar);
else emite(L.lugar '[ ' L.desplazamiento ']' ':=' E.lugar); }
{ E.lugar:=tempnuevo; emite(E.lugar ':=' E1.lugar '+' E2.lugar) }
base+ n3·a
base+n3·n2·a
• Esquema de traducción para acceder a elementos de matrices
E→E1+E2
base+(n3·n2·(i1−inf1)+n3·(i2−inf2) +(i3−inf3))·a
Factorizando queda:
A[inf1, inf2+2, *]
S→L:=E
La posición del elemento A[i1,i2,i3] en esta matriz
viene dada por la fórmula:
Separando los elementos que dependen
exclusivamente de la estructura de la matriz:
{ p:=busca(id.nombre);
if p≠nil then
E.lugar:= p
else error }
(2)
• Acceso a elementos de matrices
• Esquema de traducción para producir cód. de 3 direcciones para las asignaciones
{ p:=busca(id.nombre);
S → id := E
E → E1 + E2
15
16
Expresiones booleanas
• Esq. traduc. utilizando una representación numérica para los valores booleanos
E → E1 or E2
emite(E.lugar ':=' E1.lugar 'or' E2.lugar) }
E → E1 and E2
emite(E.lugar ':=' E1.lugar 'and' E2.lugar) }
E → not E1
emite(E.lugar ':=' 'not' E1.lugar) }
E → ( E1 )
E → id1 oprel id2
después:=etiqnueva;
cierto:=etiqnueva;
emite('if' id1.lugar oprel.op id2.lugar 'goto' cierto);
emite(E.lugar ':=' '0'); emite('goto' después);
emite(cierto ':');
emite(E.lugar ':=' '1');
emite(después ':');
E → true
E → false
}
}
}
17

Código de tres direcciones - Página personal de César Ignacio

Transcripción

Documentos relacionados

¿Emite o refleja la luz?

FORMATO ACTIVOS PARA DAR DE BAJA

Flujo de Planificación de Proyecto de Vinculación