INSTITUTO TECNOLOGICO SUPERIO DE JEREZ
LENGUAJES Y AUTOMATAS II
TAREA_7_RESUMEN FUNCIONES
ALUMNA:
LIZETH GUADALUPE GIRON ALVARADO
MODULO 13
1-NOVIEMBRE-2013
___________________________________________________________________________________
El proceso de la compilación se desglosa en lenguaje fuente (etapa
inicial o front-end ) y lenguaje objeto (etapa final o back-end), 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; siendo La generación de código
es la tarea más complicada de un compilador.
Una representación
intermedia: es una
estructura de datos que representa al programa fuente durante el proceso de la traducción
a código objeto, en un árbol de análisis sintáctico como junto con la tabla de símbolos.
El código intermedio puede ser considerado como un atributo sintetizado,
y es visto como una cadena de caracteres y se puede diseñar un esquema de traducción
dirigido por la sintaxis (ETDS) que genere dicho código al recorrer el árbol de
análisis sintáctico en orden postfijo.
*La optimización de código
intermedio, se puede realizar a nivel local: solo
utilizan la información de un bloque básico para realizar la optimización. A
nivel global: que usan información de varios bloques básicos.
El termino optimización de código es inadecuado ya que no se garantiza
el obtener, en el sentido matemático, el mejor código posible atendiendo a maximizar
o minimizar una función objetivo (tiempo de ejecución y espacio). El termino de
mejora de código sería más apropiado que el de optimización. Además de
la optimización a nivel de código intermedio, se puede reducir el tiempo de ejecución
de un programa actuando a otros niveles: a nivel de código fuente y a nivel de código
objeto.
*El código de tres
direcciones: es una secuencia de proposiciones de la forma
general
x = y op z
Donde op representa cualquier operador; x, y, z representan variables
definidas por el programador o variables temporales generadas por el
compilador.es también una representación
linealizada (de izquierda a derecha) del árbol sintáctico en la que los nombres
temporales corresponden a los nodos internos.
Contienen instrucciones para el
flujo de control (goto). Una etiqueta simbólica representa el índice de una proposición
de 3-direcciones en la lista de instrucciones. Una proposición de código
de 3-direcciones se puede implantar como una estructura tipo registro con
campos para el operador, los operandos y el resultado. La representación final será
entonces una lista enlazada o un vector de proposiciones.
Un archivo de salida en lugar de construir la lista de proposiciones
en el atributo cod, lo que facilita la implementación.
*Implementación
mediante cuádruplos: es una estructura tipo registro con cuatro
campos que se llaman (op, result, arg1, arg2). El campo op contiene un código
interno para el operador.
*Implementación
mediante tripletes:
En la notación de tripletes se necesita menor espacio y el compilador
no necesita generar los nombre 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. Por simplicidad se podrían considerar
los campos result, arg1, arg2 como punteros a carácter.
*Reutilización de
nombres temporales
Los nombres temporales se pueden reutilizar mediante un sencillo método
que consiste en llevar una cuenta c, iniciada a cero, de variables
temporales. Cuando se utilice un nombre temporal como operando hay que
decrementar el valor de c en 1. Siempre que se genere un nuevo nombre
temporal se usa el valor del contador (sprintf (símbolo, ‘‘t %d’’, c)) y se
incrementa el valor de c en 1.
*Traducción de
expresiones booleanas
Las expresiones booleanas se utilizan principalmente como parte de las
proposiciones condicionales que alteran el flujo de control del programa, if-then,
if-then-else, while-do. Las expresiones booleanas se componen de los operadores
booleanos and, or, not aplicados a variables booleanas o expresiones relacionales.
Por ejemplo Uno de los metodos para traducir expresiones booleanas a código
de 3-direcciones consiste en codificar numéricamente los valores true y false y
evaluar una expresión booleana como una expresión aritmética, siguiendo unas
prioridades.
*Traducción de
proposiciones de control
Para generar el código correspondiente a esta proposición habrá que añadir
a la función generadora de código () un nuevo caso para la sentencia switch que
contemple este tipo de nodo en el árbol sintáctico, nodo n if-then.
*Traducción de
funciones
La generación de código para las funciones es la parte más complicada porque
depende de la maquina objeto y de la organización del entorno de ejecución. La traducción
de funciones implica dos etapas: la definición de la función; crea un nombre, parámetros
y código del cuerpo de la función pero no se ejecuta la función en ese punto. La
llamada a la función desde una parte del programa (trataremos a los procedimientos
como funciones que no devuelven valores). Una llamada crea los valores actuales
para los parámetros y realiza un salto al código de entrada de la función que
se ejecuta y retorna al punto de la llamada.
*Cuerpo de la función
Para traducir el cuerpo de la función bastara recorrer el árbol hasta
encontrar un nodo de tipo n function a partir del cual colgara el bloque de
sentencias del cuerpo de la función.
Esto implica las siguientes tareas:
1. Recoger la dirección libre actual y utilizarla como dirección para
rellenar (relleno con retroceso) las llamadas a la función que estamos deteniendo.
2. Generar código para desopilar los argumentos de la función y
meterlos en las variables correspondientes.
3. Generar código para el bloque de sentencias S.
4. Desopilar la dirección de retorno.
5. Generar la salida de la función con RETURN.
6. Unir los trozos de código para tenerlos en una única lista de
Cuádruplos.
*Eliminación de subexpreciones
comunes
Si una expresión se calcula más de una vez, se puede remplazar el cálculo
de la segunda por el valor de la primera expresión.
*Propagación de
copias
La propagación de copias considera las proposiciones de la forma a =
b. Después de esta sentencia sabemos que ha y b tienen el mismo
valor, por tanto, podemos remplazar cada vez que aparezca a por b,
con la esperanza de que podamos remplazar todas las ocurrencias de a hasta
que se convierta en un nombre muerto y se pueda entonces eliminar la proposición
de copia.
*Eliminación de código
muerto
El código muerto aparece como consecuencia de la propagación de copias
y es esto lo que hace que la técnica de propagación de copias sea tan útil. Aunque
es poco probable que el programador introduzca código muerto o inactivo, este
puede aparecer como resultado de transformaciones.
*Transformaciones
aritméticas:
Para reducir la cantidad de computación transformando operaciones más
costosas por otras menos costosas. Existen tres tipos de transformaciones
algebraicas básicas.
1. Cálculo previo de constantes:
Se trata de calcular a nivel de compilación el valor previo de constantes en
vez de hacerlo en tiempo de ejecución que retardara la ejecución de un
programa.
2. Reducción de intensidad: En la mayoría de las maquinas las
operaciones de multiplicación y division son substancialmente más costosas que
las operaciones de suma y resta.
3. Empaquetamiento de temporales: Se trata de reusar los temporales
con el fin de ahorrar espacio.
Después de haber optimizado el código es normal pensar que se puedan
usar menos temporales y sería conveniente entonces renombrar estos temporales.
*Traslado de código
Esta transformación toma una expresión que produce el mismo resultado
independientemente del número de veces que se ejecute un lazo y la coloca antes
del lazo.
*Variables de inducción
Se trata de identificar las variables que permanecen ligadas entre sí
en la ejecución, están relacionadas entre sí de forma que conocido el valor de
una se puede obtener el de la otra.
0 comentarios:
Publicar un comentario