Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                

2.2.3 Triplos

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 11

2.2.

3 TRIPLOS
• En la historia de los compiladores han sido utilizadas una amplia
variedad de representaciones intermedias como lo es la
siguiente clase de representación de código intermedio de un
árbol de 3 direcciones,2 para los operandos y una para la
ubicación del resultado
• Para evitar tener que introducir nombres temporales en la
tabla de símbolos, se hace referencia a un valor temporal según
la posición de la proposición que lo calcula.
• Con una estructura de tres campos se puede omitir añadir los
valores temporales, dicha estructura recibe el nombre de
triples.
• Las proposiciones de tres direcciones se parecen mucho al ensamblador,
el cual es un lenguaje intermedio más entendible para la máquina. •
• La notación de tres direcciones es una forma abstracta de código
intermedio.
• Esta notación se puede implementar como registros con campos para el
operador y operadores.
DIFERENCIAS ENTRE TRIPLOS Y NOTACIÓN POSFIJA

• La principal diferencia entre estas notaciones y la notación posfija es


que ellos incluyen referencias explicitas para los resultados de los
cálculos intermedios, mientras que la notación posfija los resultados
son implícitos al representarlos en una pila.
TRIPLOS Y CUADRUPLOS

• La diferencia entre triples y cuadruplos es que con los triples es


referenciado el valor intermedio hacia el numero del triple que lo
creo, pero en los cuádruplos requiere que ellos tengan nombre
implícitos.
• Los triples tienen una ventaja obvia de ser mas consistente, pero
ellos dependen de su posición, y hacen que la optimización presente
cambios de código mucho mas compleja.
• En la notación de tripletes se necesita menor espacio y el compilador no
necesita generar los nombres temporales. Sin embargo, en esta notación,
trasladar una proposición que defina un valor temporal exige que se modifiquen
todas las referencias a esa proposición. Lo cual supone un inconveniente a la
hora de optimizar el código, pues a menudo es necesario cambiar proposiciones
de lugar.
• Una forma de solucionar esto consiste en listar las posiciones a las tripletas en
lugar de listar las tripletas mismas. De esta manera, un optimizador podría mover
una instrucción reordenando la lista, sin tener que mover las tripletas en sí.
<operador>, <operando1>, <operando2>
• El resultado se asocia al número de tripleta
• Ejemplo: W*X+(Y+Z)
1. *, W, X
2. +,Y, Z
3. +, (1), (2)
CONTROL DE FLUJO

• IF X>Y THEN Z=X ELSE Z=Y+1


1. >, X,Y
2. Saltar si falso, (1), 5
3. =, Z, X
4. Saltar,, 7 Problema
5. +,Y, 1 La optimización supone mover
tripletas y hay que recalcular las
6. =, Z, (5) referencias
.
EJEMPLO

• A := B+C*D

oper op1 op2

* C D

+ B T1

= A R2
INTÉRPRETES

• Los intérpretes generalmente utilizan este triplos para generar


el código intermedio para ejecutarse una vez considerado la
instrucción como válido.
• En este sentido, un compilador es más difícil de implementar ya
que tendrá que mantener todas las estructuras generadas que
en muchas ocasiones serán cuádruplos.

También podría gustarte