Antologia de Pro Todo

2010
ANTOLOGIA PROGRAMACION DE SISTEMAS

UNIDADES 5,6,7,8
ALUMNOS: AMAN JOACHIN PALAFOX MELCHOR NOVELO HERNANDEZ LUIS JILBERTO ACOSTA MENDEZ MIGUEL MORENO CHAMIZ
INSTITUTO TECNOLOGICO SUPERIOR DE CHAMPOTON 14/12/2010
PROGRAMACION DE SISTEMAS
INDICE
Unidad 5: Anlisis semntico.................................................................................................... 4 Semntica de instrucciones condicionales ..................................................................... 5 Semntica de etiquetas y GOTO ..................................................................................... 6 5.1 ANALIZADOR SEMNTICO .......................................................................................... 7 5.2 VERIFICACIN DE TIPOS EN EXPRESIONES ........................................................ 8 5.3 CONVERSIN DE TIPOS............................................................................................ 11 5.4 Acciones agregadas en un analizador sintctico descendente (top-down).......... 14 5.5 Pila semntica en un analizador sintctico ascendente (bottom-up). ................... 15 5.6 Administracin de la tabla de smbolos ...................................................................... 16 5.7 Manejo de errores semnticos. ................................................................................... 20 6. GENERACION DE CODIGO INTERMEDIO ................................................................... 24 6.1Generador de cdigo intermedio .................................................................................. 24 6.2 Notaciones ...................................................................................................................... 25 6.2.1Infija ........................................................................................................................... 25 6.2.2 Postfija ...................................................................................................................... 25 6.2.3 Prefija ....................................................................................................................... 25 6.3 Representacin de cdigointermedio ......................................................................... 26 6.3.1 Notacin Polaca ...................................................................................................... 26 6.3.2 Cdigo P .................................................................................................................. 26 6.3.3 Triplos ....................................................................................................................... 26 6.3.4 Cudruplos .............................................................................................................. 27 6.4 Esquemas de generacin ............................................................................................. 27 6.4.1 Expresiones ............................................................................................................. 27 6.4.2 Declaracin de variables,constantes ................................................................... 27 6.4.3 Estatuto de asignacin .......................................................................................... 27 6.4.4 Estatuto condicional ............................................................................................... 28 6.4.5 Estatuto de ciclos.................................................................................................... 28 6.4.6 Arreglos .................................................................................................................... 28 6.4.7 Funciones ................................................................................................................ 28 7. Optimizacin ......................................................................................................................... 29
PROGRAMACION DE SISTEMAS 7.1. Tipos de Optimizacin.................................................................................................. 29 7.1.1. Locales .................................................................................................................... 29 7.1.2. Globales .................................................................................................................. 30 7.1.3 Bucles ....................................................................................................................... 31 7.1.4 De mirilla .................................................................................................................. 31 7.2. Costos............................................................................................................................. 31 7.2.1. Maquinas Virtuales ................................................................................................ 31 7.2.2. Criterios de Mejoramiento .................................................................................... 33 7.2.3 herramientas para el anlisis del flujo de datos................................................. 33 8. Generacin de cdigo objeto. ............................................................................................ 34 8.1 Lenguaje mquina. ........................................................................................................ 34 8.1.1 Caractersticas ...................................................................................................... 36 8.1.2 Direccionamiento ................................................................................................. 37 8.2 Lenguaje ensamblador ................................................................................................. 38 8.2.1 Caractersticas ........................................................................................................ 38 8.2.2 Almacenamiento ..................................................................................................... 39 8.3 Registros........................................................................................................................ 39 8.3.1 Distribucin .............................................................................................................. 41 8.3.2 Asignacin ............................................................................................................... 41 8.4 Administracin de memoria .......................................................................................... 42 Bibliografa ................................................................................................................................. 43
INTRODUCCION En esta investigacin de las ultimas unidades de la materia se estudiara la forma en la que debemos utilizar algunas mtodos a la hora de la elaboracin de un lenguaje para la programacin, la cual tiene que cumplir con las necesidades de un programador y que dicho lenguaje funcione correctamente y pueda cumplir con las expectativas del programador as como del programa a elaborar en dicho lenguaje y cumplir con las caractersticas de un lenguaje de programacin. Algunos de los temas que se abordaran en esta investigacin son anlisis semntico que se ayudara en la verificacin de la semntica utilizada en un lenguaje as como de igual manera en otros aspectos de igual importancia en un compilador de lenguaje, tambin en la optimizacin del lenguaje para ver con que este va a trabajar, como la generacin de cdigo objetos q interpreta o interpretaran diferentes formas como la interaccin con el lenguaje mquina y a su vez en lenguaje ensamblador.
Unidad 5: Anlisis semntico Se compone de un conjunto de rutinas independientes, llamadas por los analizadores morfolgico y sintctico. El anlisis semntico utiliza como entrada el rbol sintctico detectado por el anlisis sintctico para comprobar restricciones de tipo y otras limitaciones semnticas y preparar la generacin de cdigo. En compiladores de un solo paso, las llamadas a las rutinas semnticas se realizan directamente desde el analizador sintctico y son dichas rutinas las que llaman al generador de cdigo. El instrumento ms utilizado para conseguirlo es la gramtica de atributos. En compiladores de dos o ms pasos, el anlisis semntico se realiza independientemente de la generacin de cdigo, pasndose informacin a travs de un archivo intermedio, que normalmente contiene informacin sobre el rbol sintctico en forma linealizada (para facilitar su manejo y hacer posible su almacenamiento en memoria auxiliar). En cualquier caso, las rutinas semnticas suelen hacer uso de una pila (la pila semntica) que contiene la informacin semntica asociada a los operandos (y a veces a los operadores) en forma de registros semnticos. Semntica de instrucciones condicionales Sean las reglas <Instr> ::= If <Expr> S2 then <Instr> S1 | If <Expr> S2 then <Instr> else S3 <Instr> S1 Una secuencia de cudruplas equivalente a "If E1 then I1 else I2" (p-1) (?,?,?,t1) Anlisis de E1 (p) (TRZ,(q+1),t1,) S2: Crear cudrupla (p) | Push p ... Anlisis de I1 (q) (TR,(r),,) S3: Crear cudrupla (q) Poner (cl.sig.) en top | Pop Push (q) (q+1) ... Anlisis de I2 (r) S1: Poner (cl.sig.) en top | Pop Una secuencia de cudruplas equivalente a "If E1 then I1" (p-1) (?,?,?,t1) Anlisis de E1 (p) (TRZ,(r),t1,) S2: Crear cudrupla (p) | Push p ... Anlisis de I1 (r) S1: Poner (cl.sig.) en top | Pop
Al generar la cudrupla (p) no conocemos el valor de (q). Guardamos en una pila el nmero de la cudrupla asociada y lo rellenamos ms tarde, como indican los ejemplos. Semntica de etiquetas y GOTO Suponemos que las etiquetas aparecen en la tabla de smbolos con tres valores asociados: (tipo=etiqueta, bit=declarada/no declarada, nmero de cudrupla). Sea la regla <Instr> ::= id : <Instr> Semntica asociada: { Buscar id en la tabla de smbolos; if (no est) Insertar id,valor=(etiqueta, declarada, cudrupla siguiente); else { if (tipo==etiqueta && bit==no declarada) { i=nmero de cudrupla; while (i) { j=cudrupla[i][2]; cudrupla[i][2]=cudrupla siguiente; i=j; } Cambiar valor a (etiqueta, declarada, cudrupla siguiente); } else error(); } } Sea la regla <Instr> ::= GOTO id Semntica asociada: { Buscar id en la tabla de smbolos; if (no est) { Insertar id,valor=(etiqueta, no declarada, cudr.siguiente); Generar cudrupla (TR,,,); } else { if (tipo==etiqueta) { if (bit==declarada) Generar cudrupla (TR,nmero de cudrupla,,);
else if (bit==no declarada) { i=nmero de cudrupla; Cambiar valor a (etiqueta, no declarada, cudr.siguiente); Generar cudrupla (TR,i,,); } } else error(); } } Si se permiten etiquetas locales a bloques, podemos encontrar el siguiente caso: L: ... { ... GOTO L; ... Tenemos ambigedad: GOTO L puede ir a la etiqueta externa (ya definida o no) o a una etiqueta local al bloque posterior a la instruccin. Tenemos tres posibilidades: Un compilador en dos pasos. Forzar declaraciones de etiquetas. Tratar L en el bloque como si fuera local. Si al final del bloque descubrimos que no ha sido declarada, tratarla como si fuera global. La lista de referencias debera fundirse con la de L global (si L global no ha sido definida an) o rellenarse con el valor de L (si ya ha sido definida). Si L global no existe, debe crearse, y pasarle la lista de referencias de L local.
5.1 ANALIZADOR SEMNTICO Ajuste significativo Comprobacin de tipos: operandos-operadores Comprobacin del flujo de control: for (;;) } break; w= a+2; {
Comprobacin de unicidad int a;
char a; //una sola vez Comprobacin relacionada con nombres Tabla de smbolos: Estructura en memoria Almacena informacin sobre los tipos Sistemas de tipo: Tipo bsico: entero, carcter, real, lgico Nombres de tipo Constructores de tipo: estructuras, uniones, Objetos Apuntadores: referencias a tipos Funciones a=suma (); Sistema de tipos: conjunto de reglas que determinan el criterio para asignar expresiones de tipo a las diferentes partes del cdigo fuente. Cada analizador semntico implementa un sistema de tipos Comprobacin dinmica y esttica Esttica: compilacin Dinmica: Ejecucin char a [5]; strcpy(a, abcdefghijk); Fuertemente tipificado Dbilmente tipificado Smbolo } nombre; tipo ; mbito; {
5.2 VERIFICACIN DE TIPOS EN EXPRESIONES Se emplean para establecer el tipo de una construccin del lenguaje; esta puede ser o un tipo simple (predefinido por el lenguaje), o estar formado por la aplicacin del operador especial llamado constructor de tipos a otras expresiones de tipos. Tipos simples.- Son los tipos predefinidos por el lenguaje. Como por ejemplo int, float, double Nuevos tipos simples.- En algunos lenguajes es posible definir nuevos tipos simples. Estos nuevos tipos simples suelen ser subintervalos de tipos simples o los tipos enumerated. Tipos estructurados.- Son tipos creados por constructores de tipo, tales como array, record o struct. Tales constructores toman los tipos ya creados como parmetros y devuelven nuevos tipos con una estructura que depende del constructor.
- Array: Toma dos parmetros de tipo el tipo ndice y el tipo componente. Para tener acceso a un componente del tipo array, se hace uso del ndice. Con frecuencia existen restricciones acerca de los tipos que se pueden presentar como tipos ndice. Normalmente los tipos que se utilizan son ordinales, para los cuales hay un predecesor y un sucesor. Una complicacin de estos tipos suelen ser los tipos multidimensionales. - Record: Un constructor de este tipo toma una lista de nombres y tipos asociados construyendo un nuevo tipo. Para tener acceso a un componente del tipo record se hace uso del nombre del componente al cual se quiere acceder. - Pointer: Si T es una expresin de tipo, pointer (T) es una expresin de tipo que indica un apuntador a un objeto T. Nombres de tipo.- Son alias que se le pueden dar a los tipos. Inferencia y verificacin de tipos La inferencia y verificacin de tipos se realizan teniendo en cuenta tres acciones, las declaraciones las sentencias y las expresiones. Las declaraciones causan que el tipo de un identificador se introduzca en la tabla de smbolos, asocindole un tipo al mismo. Ej; i : int se corresponde con la regla gramatical: var-decl id : tipo-exp y la accin semntica asociada insert (id.name, tipo-exp.type) que aade un identificador en la tabla de smbolos y le asocia un tipo. Las sentencias no tienen tipos en s mismas sino subestructuras que es necesario verificar en cuanto a la exactitud del tipo Ej; If expresin then sentencia Se corresponde con la regla gramatical: Sent if exp then sent Y la accin semntica asociada If not typeEqual (exp.type, bolean) then type-error (sent) que lo que hace es comprobar que exp es de tipo booleano, y si no es as enva un error. Las expresiones constantes como nmeros y valores bolanos, tienen los tipos implcitamente definidos. Los nombres de variables tienen sus tipos determinados mediante una bsqueda en la tabla de smbolos. Las subexpresiones tienen que ser del tipo correcto para la operacin indicada en la expresin. Ej; - sent id:= exp Provoca la accin semntica If not typeEqual (lookup(id.name),exp.type) then type-error (sent)
- exp1 exp2 or exp3 Provoca la accin semntica If not (typeEqual (exp2.type, boolean) and typeEqual (exp3.type, Boolean)) then type-error (exp1);
Equivalencias de expresiones de tipo En el apartado anterior hemos utilizado la funcin typeEqual (t1,t2: TypeExp) : boolean. Todo verificador de tipos debe saber cuando dos expresiones de tipo representan al mismo tipo, y de eso es de lo que se encarga esta funcin. La equivalencia de tipos se puede explicar haciendo uso de los conceptos de equivalencia estructural y equivalencia de nombre. El anlisis se hace mediante una representacin de grafos de las expresiones de tipos, con hojas para los tipos bsicos y nodos interiores para los constructores de tipo. Ejemplo; La expresin de tipo: Record X: pointer to real Y: array [10] of in End Esta expresin se puede representar mediante el rbol sintctico.
Record
Var (x)
Var (y)
Pointer
Array (10)
Real
Int
10
Ya que las expresiones de tipos se construyen a partir de tipos bsicos y constructores, una nocin natural de equivalencia entre dos expresiones de tipos es la equivalencia estructural; es decir dos expresiones son, o bien el mismo tipo bsico, o estn formadas aplicando el mismo constructor a tipos estructuralmente equivalentes. Dada la siguiente gramtica: PD;E DD;D D id : T T char T integer TT T array [ nm ] of T
1 1
La verificacin de los tipos de datos se hace asignando el valor de tipo de cada una de los componentes lxicos. Estos valores se comparan para verificar que los tipos de datos coincidan y sean congruentes, de lo contrario no se pueden realizar los clculos.
5.3 CONVERSIN DE TIPOS En ciencias de la computacin la conversin de tipos (type casting en ingls) se refiere a la transformacin de un tipo de dato en otro. Esto se hace para tomar las ventajas que pueda ofrecer el tipo a que se va a convertir. Por ejemplo, los valores de un conjunto ms limitado, como nmeros enteros, se pueden almacenar en un formato ms compacto y ms tarde convertidos a un formato diferente que permita las operaciones que anteriormente no eran posibles, tales como la divisin con decimales. Hay dos tipos de conversin: la implcita y la explcita. En la implcita se convierte un tipo de dato de menor rango a un supertipo (tipo de dato de mayor rango); este tipo de conversin lo realiza el compilador, ya que no hay prdida de datos si, por ejemplo, se pasa un int (tipo entero) a long. En la conversin explcita, el compilador no es capaz de realizarla por s solo y por ello debe definirse explcitamente en el programa. Existen varios tipos de conversin explcita:
11
controlada: antes de realizar la conversin se controla en tiempo de ejecucin si el tipo de destino puede tener el valor de origen, y si no se produce un error. no controlada: no se realiza ningn control, si el tipo de dato destino no puede contener al de origen el resultado es indefinido (generalmente se produce un desbordamiento de bfer y en algunos casos como en java el cambio se produce sin mayores consecuencias). patrn de bits: La representacin de bits en bruto de la fuente es una copia literal, y se reinterpreta de acuerdo con el tipo de destino. Esto tambin puede lograrse a travs de aliasing. Hay situaciones en las cuales se tiene un valor de un tipo dado y se desea almacenar ese valor en una variable de un tipo diferente. En algunos tipos es posible almacenar simplemente el valor sin una conversin de tipos; lo que se denomina conversin automtica. Esto slo es posible en algn lenguaje de programacin, si el compilador reconoce que la variable destino tiene la suficiente precisin para contener el valor origen. En Java se puede almacenar un valor byte en una variable int, dado que este tipo de datos es de mayor precisin que el primero.
A esto se le llama ensanchamiento o promocin, dado que el tipo ms pequeo se ensancha o promociona al tipo compatible ms grande. Si por el contrario, se desea asignar un valor de variable int a una variable byte se necesita realizar una Conversin de tipos explcita. En algunos casos se puede realizar la conversin pero se pueden perder datos, como por ejemplo al pasar un valor flotante a un entero. A esto se le llama estrechamiento, dado que se estrecha explcitamente el valor para que quepa en el destino. La conversin de un tipo se realiza poniendo delante un nombre de tipo entre parntesis, por ejemplo, (tipo) valor. byte a; int b; a=(byte) b; Existen dos tipos de comprobacin: esttica y dinmica. La comprobacin ayuda a evitar la mayora de los errores de programacin. Ejemplos: Comprobacin de tipos. Para saber si el operador aplicado a los operadores es correcto Comprobacin de flujo de control. Se debe verifica que las instrucciones que cambia el flujo de un programa sean vlidos. Ejemplo: break, goto. Comprobacin de unicidad: definir un objeto una sola vez.
12
Comprobacin relacionadas con nombres. El mismo nombre debe aparecer dos veces. Variables que se declaran pero no utilizan. La comprobacin de tipos es la ms complicada. Las dems comprobaciones son rutinarias. El operador % ocupa que los dos operandos sean enteros. es una funcin suma(a,b) que est sobrecargada para distintos tipos de datos. Siempre se disean reglas de tipos como los valores numricos se convierten al de mayor jerarqua o el tipo de datos punteros slo apunta al tipo de datos declarado. Algunos lenguajes revisan el tamao de los arreglos (Java) de manera esttica otros lo hacen de manera dinmica (en tiempo de ejecucin). Diferenciar el uso de +, * enteros que con puntero (aritmtica de punteros) Al conjunto de reglas que se definen para la comprobacin de los tipos de datos se denomina sistema de tipos La mayora de veces la recuperacin de errores se l suele omitir ya que el programa no finaliza pero tal vez no obtenga los valores deseados.
Generalmente en la etapa de anlisis sintctico se suelen agregar los tipos a la tabla de smbolos. Se revisa el rbol sintctico para comprobar los tipos asignados. Existen conversiones explcitas en las cuales el usuario indica el tipo de datos a = (int)(23.3/18.2); Las conversiones implcitas requieren de mayor tiempo de ejecucin. Un ciclo de 1 a N tard 5.4 y 48.4 nanosegundos utilizando conversiones implcitas. Polimorfismo: una funcin puede tener el mismo nombre con diferentes elementos. El tipo de datos debe ser diferente. Un ejemplo de polimorfismo son las plantillas en algn lenguaje de programacin. Se debe considerar el mbito de las variables (locales y globales). Conversin de tipos Una extensin comn de las reglas de tipo de un lenguaje es permitir expresiones aritmticas de tipo mezclado tal como 2 + 3.1 donde se suman un nmero real y un nmero entero. En tales casos, debe hallarse un tipo comn que sea compatible con todos los tipos de las subexpresiones y deben aplicarse operaciones para convertir los valores en tiempo de ejecucin a las representaciones apropiadas antes de aplicar el operador. En el ejemplo anterior el entero 2 debera convertirse a punto flotante antes de la suma, y la expresin resultante ser del tipo suma. Existen dos formas que un lenguaje pueda tomar para tales conversiones.
13
Una forma que el programador suministrase la funcin de conversin de manera que ejemplo anterior sera FLOAT(2) + 3.1 o se causar un error de tipo. El otro mtodo consistira en que el verificador de tipo suministre la operacin de conversin de manera automtica, basndose en los tipos de las subexpresiones. Las conversiones automticas se conocen como coercin. La coercin se puede expresar de manera implcita mediante el verificador de tipo, ya que el tipo inferido de una expresin cambia a partir de una sobreexpresin.
5.4 Acciones agregadas en un analizador sintctico descendente (topdown) Muchas de las actividades que realiza un analizador semntico no son estndares, dependern del objetivo del lenguaje de programacin; por ejemplo, en algunas aplicaciones es interesante conocer que los datos estn en algn rango vlido o que ciertos valores se utilicen para uso reservado En algunas ocasiones nos interesa conocer el significado de las palabras de algn lenguaje dependiendo del contexto (gramticas de tipo 1) para diferenciar palabras poli semnticas. La Web es una base de datos en la mayora de los casos sin sentidos por lo que la tercera generacin de la Web ser la llamada Web semntica. ntica en un . En un parser recursivo-descendente, el cdigo de las acciones semnticas es mezclado dentro del flujo de control de las acciones del parser. En un parser especificado en java CC, las acciones semnticas son fragmentos de cdigo de programa en java unido a las producciones gramaticales. Cada smbolo terminal y no terminal puede asociarse con su propio tipo de valor semntico. Por ejemplo en la siguiente gramtica para YACC de una calculadora simple, el tipo asociado con exp e INT podra ser int: %token INT PLUS MINUS TIMES UMINUS %start exp %left PLUS MINUS %left TIMES %left UMINIS exp: INT | exp PLUS exp | exp MINUS exp | exp TIMES exp 1 MINUS exp %prec UMINUS Los otros tokens no necesitaran tener un valor. Por otra parte el tipo asociado a un token debe por supuesto coincidir con el tipo de token que el scanner retorne. Para una regla ABCD, la accin semntica debe retornar un valor cuyo tipo es el asociado al no terminal A. Pero puede
14
construir este valor de los valores asociados a los terminales y no terminales B, C, D.
Recursivo-descendente En un parser recursivo-descendente, las acciones semnticas son los valores retornados por las funciones de parsing, o los efectos laterales de esas funciones o ambos. Por cada smbolo terminal y no terminal, asociamos un tipo (desde el lenguaje de implementacin del LP del compilador) de valor semntico representando frases derivadas desde ese smbolo. El siguiente programa es un intrprete recursivo descendente para una parte de la gramtica en la cual eliminamos la recursin por la izquierda (por conveniencia la volvemos a mostrar): S E$ E T E E + T E E - T E E l T F T T * F T T / F T T l F id F num F (E)
5.5 Pila semntica en un analizador sintctico ascendente (bottom-up).
Como fue visto en el capitulo anterior (4), un parser ascendente utiliza durante el anlisis una pila. En esta va guardando datos que le permiten ir haciendo las operaciones de reduccin que necesita. Para incorporar acciones semnticas como lo es construir el rbol sintctico, es necesario incorporar a la pila del parser otra columna que guarde los atributos de los smbolos que se van analizando. Estos atributos estaran ligados a la correspondiente produccin en la tabla de parsing (consultar seccin 5.3 del libro de Aho, Ullman, Sethi para ver ms detalles de la implementacin). El diseo ascendente se refiere a la identificacin de aquellos procesos que necesitan computarizarse con forme vayan apareciendo, su anlisis como sistema y su codificacin, o bien, la adquisicin de paquetes de software para satisfacer el problema inmediato.
15
Pila semntica Los problemas de integracin entre los subsistemas son sumamente costosos y muchos de ellos no se solucionan hasta que la programacin alcanza la fecha lmite para la integracin total del sistema. Se necesita una memoria auxiliar que nos permita guardar los datos intermedios para poder hacer la comparacin.
5.6 Administracin de la tabla de smbolos
La tabla de smbolos tambin recibe el nombre de ambiente. Un ambiente contiene un conjunto de parmetros que slo son visibles en ese ambiente. La tabla de smbolos se mantiene durante todo el proceso de traduccin agregando elementos especficos en cada paso. Operaciones sobre la tabla de smbolos Inserta(smbolo) Existe(nombre) Tipo(nombre) TIPO {tipo = obtengo (yytext());} Declaracin listavar PYC var {inserta(smbolo);} | var Listavar {Inserta (smbolo) ; } ID {simbolo=yytext; smbolo.tipo=tipo; Var simbolo.amb=ambito;} Operaciones sobre la tabla de smbolos PI exprlog {A=A;} PD Exprlog |NOT exprlog {A=A;} |exprlog {A1=A;} OPLOG exprlog {A2=A If(A1==INT && A2==INT) A=INT; Else A=ERROR_TIPO;} El anlisis semntico conecta las definiciones de las variables con sus usos, checa que cada expresin tenga un tipo correcto y traduce la sintaxis abstracta a una representacin mas simple para generar cdigo mquina.
16
Esta fase es caracterizada por el mantener la tabla de smbolos (tambin llamada environment) la cual mapea identificadores con sus tipos y localidades. Cada variable local en un programa tiene un mbito (scope) dentro del cual es visible. Por ejemplo, en un mtodo Mini Java m, todos los parmetros formales y variables locales declarados en m son visibles solo hasta que finalice m. Un ambiente es un conjunto de atados (bindings) denotados por . Por ejemplo, podemos decir que el ambiente z0 contiene los atados {gstring,aint}, que significa que el identificador a es una variable entero y g es una variable string. Ejemplo
Suponer que compilamos esta clase en el ambiente z0. Las declaraciones de campo en lnea 2 nos da la tabla z1 igual a z0 + {aint,bint,cint}. Los identificadores en lnea 4 pueden encontrarse (look up) en ambiente z1. En lnea 5, la tabla o ambiente z2=z1+{jint} es creada; y en lnea 6, z3=z2+{astring} es creada. Implementacin de la Tabla Existen dos opciones: El estilo funcional donde cuando z1 existe y z2 es creado, z1 sigue existiendo. Y el imperativo en donde z1 es destruido al crearse z2. Mientras z2 existe no podemos mirar z1. Pero al morir z2, z1 de nuevo existe. Mltiple Tablas de Smbolos En algunos LP pueden existir varios ambientes a la vez: Cada mdulo, o clase o registro en el programa tiene una tabla de smbolos z propia. Ejemplos (ML y Java).
17
Al analizar los 2 programas anteriores, sea z0 el ambiente base conteniendo funciones predefinidas, y sea z1={aint} z2={Ez1} z3={bint,aint} z4={Nz3} z5={dint} z6={Dz5} z7=z2+z4+z6 En ML, N es compilado usando el ambiente z0+z2 para buscar los identificadores en la tabla;D es compilado usando z0+z2+z4 y el resultado del anlisis es {Mz7}. En Java, referencias adelantadas son permitidas (dentro de N la expresin D.d sera legal), asi E,N y D son compilados en el ambiente z7. TABLAS DE SIMBOLOS EN LENGUAJES IMPERATIVOS Un programa grande puede contener miles de distintos identificadores. Esto hace que la bsqueda en la tabla (loock up) tenga que ser eficiente. En ambientes imperativos usualmente se usan tablas de dispersin. La operacin z=z+{at} es implementada insertando t en la tabla de dispersin usando la llave a. Una tabla de dispersin con encadenamiento externo funciona bien y soporta eliminacin fcil de at para recuperar z al final del mbito de a. El siguiente programa implementa una tabla de dispersin. El bucket i es una lista ligada de todos los elementos cuya llave genere i mod SIZE.
18
Considere z+{at2} cuando z ya contiene at1. La funcin insert deja at1 en el bucket y pone at2 antes en la lista. Entonces, cuando pop se realiza despus del ambito de a, z es restaurado. SIMBOLOS Para evitar comparaciones innecesarias de cadenas podemos convertir cada cadena a un smbolo, y as todas las diferentes ocurrencias de cualquier cadena se conviertan a un mismo objeto smbolo. El mdulo smbolo implementa los smbolos y tiene estas propiedades: Comparar smbolos por igualdad o por mayor es rpido (comparacin por apuntador o por entero). Extraer una llave hash de tipo entero es rpido Los ambientes son implementados en la clase Symbol.Table como Tables mapeando Symbols a ligados (bindings). Para eso se manejan ligaduras para diferentes propsitos en el compilador ligadura para tipos, para variables, para funciones, etc. Entonces, una ligadura es un Objeto. Para implementar la clase Symbol, usaremos el mtodo intern() (java.lang.String), para darnos un objeto nico a partir de una cadena de caracteres. Para el uso de la tabla de smbolos usaremos java.util.Hashtable. La funcin beginScope recuerda el estado actual de la tabla y endScope restaura la tabla a donde estaba en el mas reciente beginScope que no ha terminado. Cuando la atadura xb es metido a la tabla (table.put(x,b)), x es dispersado a un ndice i, y un objeto binder xb es puesto en la cabeza de la lista ligada para el bucket i. Si la tabla ya tiene una ligadura xb, esto permanecera en el bucket, pero escondido por xb. Esto es importante ya que soportara la implementacin de undo (beginScope y endScope). Tambin deber existir una pila auxiliar, que muestre en que orden los smbolos son metidos (pushed) a la tabla de smbolos. Cuando xb es encontrado, entonces x es metido a la pila (beginScope). Entonces, para implementar endScope, los smbolos deben sacarse de la pila. Por ejemplo, considere la siguiente figura, que muestra un programa y su tabla de smbolos.
19
5.7 Manejo de errores semnticos.
Los errores semnticos son pocos y los que existen no se pueden detectar tan fcilmente. Hasta esta etapa los errores son mostrados a los usuarios. Los dems errores ya son muy difciles de detectar y generalmente se dan en tiempo de ejecucin Algunos problemas se presentan durante la fase de gestin de memoria al pasar argumentos o al crear la pila semntica. Muchos errores se generan durante la etapa del enlazador, al tratar de obtener cdigo existente de algunas funciones/mtodos ya implementadas en bibliotecas/APIs Cuando el checador de tipos detecta un error de tipos o un identificador no declarado, debe imprimir el mensaje de error y continuar. Esto debido a que normalmente el programador prefiere que le describan todos los errores posibles del programa fuente. Esto quiere decir, que si un error de tipos es encontrado, no debe producirse un programa objeto por parte del compilador. As, las siguientes fases no deben ejecutarse. Hasta esta etapa (chequeo de tipos), la parte del compilador se conoce con el nombre de front End. REGISTROS DE ACTIVACION En casi cualquier LP, una funcin (mtodo) puede tener variables locales que son creadas cuando se llama la funcin (al entrar a esta). Diferentes invocaciones a la funcin pueden existir a la vez, y cada invocacin tiene su propia instanciacin de variables. En el siguiente mtodo de Java
20
Una nueva instancia de x es creada (e inicializada por el llamador de f) cada vez que f es llamada. Debido a que existen llamadas recursivas, muchas de esas x existen simultneamente. Similarmente, una nueva instancia de y es creada cada vez que el cuerpo f es iniciado. En muchos LP (incluyendo Pascal, C y java), las variables locales son destruidas cuando una funcin retorna. Ya que las variables locales son creadas y destruidas en una forma LIFO, podemos usar una pila para manejarlas. MARCOS DE PILA Debido a que se trabaja con bloques de datos por funcin un push y pop no funciona. Entonces la pila es tratada como si fuera un gran arreglo, con un registro especial- el stack pointer que apunta a una localidad. Todas las localidades despus del apuntador son basura y todas las que estn antes estn asignadas. El rea en la pila dedicada a las variables locales, parmetros, direccin de retorno y otras variables temporales para una funcin es llamada el registro de activacin o marco de pila de la funcin. El diseo de la estructura de los marcos es de acuerdo con la arquitectura y el LP que se compila. Aunque normalmente el constructor de la arquitectura define un diseo de marco standard para todos los compiladores para esa arquitectura.
21
Marco de Pila Los argumentos de entrada son los pasados por el llamador (tcnicamente son parte del marco anterior pero pueden accesarse usando un desplazamiento del apuntador de marco). Cuando la funcin actual llama otras funciones, puede usar el espacio de los argumentos de salida para pasar parmetros. La direccin de retorno es creada por la instruccin CALL. Las variables locales tambin tienen su espacio. Las variables mantenidas en registros algunas veces son salvadas a memoria. El Apuntador de Marco (FP) Suponer que una funcin g() llama la funcin f(a 1,an). Diremos que g es el llamador (caller) y f el llamado (callee). Al entrar a f, el apuntador de la pila (SP) apunta al primer argumento que g pasa a f. Al entrar, f coloca un marco solo con restar el tamao del marco de el SP. El viejo SP se convierte en el actual FP y el viejo FP es salvado en el marco. Cuando FP termina, solo copia FP de regreso a SP y regresa el valor viejo salvado de FP. Si los marcos son siempre del mismo tamao entonces no es necesario contar con FP y todo se simplifica sumando o restando la constante framesize a SP. Registros Por eficiencia, es importante mantener las variables locales, resultados intermedios y otros valores en registros en lugar de la pila de marcos. Si funcin f llama a g y ambas hacen uso de registro r, entonces r debe ser salvado (dentro de la pila de marcos) antes de que lo use g y restaurado (desde la pila) despus de que termine g. de quien es responsabilidad de salvar r? de f o g? si lo salva f se dice que r es un registro caller-save; si lo salva g se llama callee-save. Pase de Parmetros Estudios actuales han mostrado que raramente una funcin pasa mas de 4 parmetros. Debido a esto, la mayora de las mquinas definen que los primeros k argumentos (con k=4) se pasan en registros y el resto en memoria.
22
Direcciones de Retorno Si g llama a f, entonces si la instruccin call dentro de g est en direccin a, el lugar de retorno en g es a+1, la siguiente instruccin del call. En mquinas modernas la direccin de retorno es pasada a un registro en lugar de la memoria. En funciones hoja la direccin no necesita ponerse en la pila. Registros vs. Memoria Registros siempre deben usarse en asignacin a menos que: La variable sea pasada por referencia La variable es accesada por una funcin anidada dentro de la funcin actual. El valor es demasiado grande para un registro. La variable es un arreglo, donde es necesario realizar aritmtica de direcciones. El registro que contiene la variable es necesitado para otros propsitos. Existen demasiadas variables locales y valores temporales Ligas Estticas (Static Links) En LP que admiten funciones anidadas (Pascal,ML y Java) las funciones de mas adentro pueden usar variables declaradas en funciones de mas afuera (Estructuras de Bloque). En el siguiente programa (sig. Diapositiva) la funcin write hace referencia a la variable de afuera output e indent hace referencia a n y output. Para cumplir con esto, indent debe tener acceso no solo a su propio marco (para i y s) sino tambin a los marcos de show (por n) y prettyprint (por output). Programa de funciones Anidadas
23
Existen varios mtodos para solucionar lo anterior: Siempre que una funcin f sea llamada, puede pasarse un apuntador a el marco de la funcin que estticamente encierra a f; este apuntador es la liga esttica. Un arreglo global puede mantenerse, conteniendo -en posicin i un apuntador a el marco del procedimiento mas recientemente activado cuyo profundidad de anidamiento esttico es i. Este arreglo es llamado un display.
6. GENERACION DE CODIGO INTERMEDIO
6.1Generador de cdigo intermedio La administracin de la memoria se da enesta etapa. Se debe considerar tanto la memoria estticacomo dinmica, y en esta se utilizangeneralmente pilas. Los lenguajes intermedios generalmentetienen rboles de derivacin ms pequeosque su contraparte original. Se puede representar un rbol sintctico conun Grafo Dirigido As clic (GDA). La notacin postfija es una maneralinealizada de representar un rbol sintctico. a := b*-c+b*-c abc -*bc -*+= x := y op z x+y*z t1:=y*z t2:=x+t1 Los lenguajes intermedios nos sirven pararepresentar la produccin final de nuestrolenguaje fuente. Existen muchos lenguajes intermedios, la mayora de ellos son una representacinms simplificada del cdigo original parafacilitar la traduccin hacia el cdigo final. Otros lenguajes intermedios sirven de base ocomo representacin parcial de otrosprocesos.
24
Por ejemplo al compilar un programa en C en Windows o DOS, se produce un cdigoobjeto con extensin .obj para queposteriormente el enlazador cree finalmenteel cdigo ejecutable .exe 6.2 Notaciones Las notaciones sirven de base para expresarsentencias bien definidas. El uso ms extendido de las notaciones sirve para expresar operaciones aritmticas. Las expresiones aritmticas se pueden expresar de tres formas distintas: infija, prefija y postfija.
6.2.1Infija La notacin infija es la ms utilizada por los humanos porque es la ms comprensible yaque ponen el operador entre los dosoperandos. Por ejemplo a+b-5. No existe una estructura simple pararepresentar este tipo de notacin en la computadora por esta razn se utilizan otrasnotaciones.
6.2.2 Postfija La notacin postfija pone el operador al finalde los dos operandos, por lo que laexpresin queda: ab+5La notacin posftfija utiliza una estructura del tipo LIFO (Last In FirstOut) pila, la cual es la ms utilizada para la implementacin.
6.2.3 Prefija La notacin prefija pone el operador primeroque los dos operandos, por lo que laexpresin anterior queda: +ab-5. Esto se representa con una estructura del tipo FIFO(First In FirstOut) o cola. Las estructuras FIFO son ampliamente utilizadas pero tienen problemas con elanidamiento aritmtico.
25
6.3 Representacin de cdigointermedio
Existen maneras formales para representar cdigo intermedio. Estas notaciones simplifican la traduccin de nuestro cdigo fuente a nuestro cdigo objeto ya que ahorran y acotan smbolos de la tabla de smbolos
6.3.1 Notacin Polaca
La notacin polaca, tambin conocida como notacin de prefijo o notacin prefija, es una forma de notacin para la lgica, la aritmtica, y el lgebra. Su caracterstica distintiva es que coloca los operadores a la izquierda de sus operandos. Si la aridad de los operadores es fija, el resultado es una sintaxis que carece de parntesis u otros signos de agrupacin, y todava puede ser analizada sin ambigedad. El lgico polacoJanukasiewicz invent esta notacin alrededor de 1920 para simplificar la lgica proposicional.
Notacin polaca.
6.3.2 Cdigo P El cdigo P hace referencia a mquinas que utilizan o se auxilian de pilas para generar cdigo objeto. En muchos caso la P se asociado a cdigo portable el cual garantiza que el cdigo compilado en una mquina se puedaejecutar en otras. Para garantizar la portabilidad del cdigo senecesita que el lenguaje este estandarizadopor algn instituto y que dicho cdigo notenga extensiones particulares.
6.3.3 Triplos Las proposiciones de tres direcciones se parecen mucho al ensamblador, el cual es unlenguaje intermedio ms entendible para la mquina. Las estructuras de control (if, switch, while,do-while, for) son realmente etiquetas gotodisfrazadas. El problema de utilizar cudruplos radica en que se tienen que colocar los valorestemporales en la tabla de smbolo.
26
Cuando se utilizan triples se ocupan punteros a la misma estructura de los triples. * b t1 t2 //cudruplos * b (0) //triple
6.3.4 Cudruplos
Es una estructura tipo registro con cuatros campos que se llaman: op, arg1, arg2 y resultado. OP tiene un cdigo intermedio. Los operadores unarios como x:=-y no utilizan arg2. Generalmente arg1, arg2 y resultado son valores de tipo puntero yapuntan a una entrada en la tabla de smbolos. 6.4 Esquemas de generacin
Los esquemas de generacin son las estrategias o acciones que se debern realizarse y tomarse en cuenta en el momento de generar cdigo intermedio. Los esquemas de generacin dependen de cada lenguaje. Tomaremos algunosesquemas de generacin del lenguaje C.
6.4.1 Expresiones Para generar expresiones estas debenrepresentarse de manera ms simple y msliteral para que su conversin sea ms rpida. Por ejemplo la traduccin de operaciones aritmticas debe especificarse una por una,de tal forma que una expresin sea lo ms mnimo posible. 6.4.2 Declaracin de variables,constantes
Las declaraciones de variables y constantes deben separarse de tal manera que quedenlas expresiones una por una de manera simple. Por ejemplo inta,b,c; se descompone a int a;int b; intc; respectivamente.
6.4.3 Estatuto de asignacin Las operaciones de asignacin deben quedar expresadas por una expresinsencilla, si est es compleja se debe reducir hasta quedar un operador sencillo. Por ejemplo: x = a+b/5; debe quedar de laforma y = b/5; z = a+y; x=z.
27
6.4.4 Estatuto condicional Las condiciones deben expresarse de manera lo ms sencilla posible de tal forma que puedan evaluarse en cortocircuito. Porejemplo una instruccin como: if (a == b &&f!=5 && f%3==0) se evala primero x = (a==b&& f!=5) y = x && f%3==0; if (y) Las instrucciones de decisin compleja comoswitch se reducen a una versin complejasde ifs.
6.4.5 Estatuto de ciclos
Los ciclos se descomponen en un ciclo genrico, por lo que ciclos while, for y dowhiletienen la misma representacin interna.En el caso de C, todo queda en forma dewhile.Las condiciones lgicas tambin pueden ser evaluadas en cortocircuito y reducidas.
6.4.6 Arreglos Los arreglos se descomponen en estructurasbsicas de manejo de manera simple, as porejemplo: char *a=Hola; se reduce a: a[0]=H; a[1]=o; a[2]=l; a[3]=a; a[4]=\0;
6.4.7 Funciones Las funciones pueden reducir a en lnea, loque se hace es expander el cdigo originalde la funcin. Las funciones se descomponen simplificando los parmetros de manera individual al igualque el valor de retorno.
28
7. Optimizacin 7.1. Tipos de Optimizacin 7.1.1. Locales Se realiza despus de la generacin de cdigo de todo el programa o de un elemento ejecutable del programa (funcin, procedimiento, etc). Dependiente del contexto
Objetivo Obtener cdigo que se ejecuta ms eficientemente segn los criterios Tiempo de ejecucin (optimizacin temporal) Espacio de memoria utilizado (optimizacin espacial) Funcionamiento Revisa el cdigo generado a varios niveles de abstraccin y realiza las optimizaciones aplicables al nivel de abstraccin Representaciones de cdigo intermedio de ms a menos abstractas rbol sintctico abstracto: optimizar subexpresiones redundantes, reduccin de frecuencia, etc. Tuplas o cuadruplas: optimizar en uso de los registros o de las variables temporales. Ensamblador/Cdigo mquina: convertir saltos a saltos cortos, reordenar instrucciones
Las optimizaciones locales se realizan sobre el bloque bsico Optimizaciones locales Folding Propagacin de constantes Reduccin de potencia Reduccin de subexpresiones comunes
29
Un bloque bsico es un fragmento de cdigo que tiene una nica entrada y salida, y cuyas instrucciones se ejecutan secuencialmente. Implicaciones: Si se ejecuta una instruccin del bloque se ejecutan todas en un orden conocido en tiempo de compilacin. La idea del bloque bsico es encontrar partes del programa cuyo anlisis necesario para la optimizacin sea lo ms simple posible.
7.1.2. Globales
Grafo del flujo de ejecucin Antes de realizar una optimizacin global es necesario crear el grafo de flujo de ejecucin. El grafo de flujo de ejecucin representa todos los caminos posibles de ejecucin del programa. La informacin contenida en el grafo es til para el programador y el optimizador La optimizacin global a partir del anlisis del grafo del flujo de ejecucin permite Una propagacin de constantes fuera del bloque bsico. Problema: la optimizacin global es muy costosa en tiempo de compilacin
Construccin del Grafo del Flujo de Ejecucin Tipos de grafo Orientado a procedimiento/funcin Grafo de llamadas Ejemplo int fact(int n) { int r; r=1; i=1; while (i<=n) { r=r*i; ++i; } return r; }
30
7.1.3 Bucles
Los ciclos son una de las partes ms esenciales en el rendimiento de un programa dado que realizan acciones repetitivas, y si dichas acciones estn mal realizadas, el problema se hace N veces ms grandes. La mayora de las optimizaciones sobre ciclos tratan de encontrar elementos que no deben repetirse en un ciclo. Ciclos while(a == b) { int c = a; c = 5; ; } En este caso es mejor pasar el int c =a; fuera del ciclo de ser posible. El problema de la optimizacin en ciclos y en general radica es que muy difcil saber el uso exacto de algunas instrucciones. As que no todo cdigo de proceso puede ser optimizado. Otros uso de la optimizacin pueden ser el mejoramiento de consultas en SQL o en aplicaciones remotas (sockets, E/S, etc.) 7.1.4 De mirilla La optimizacin de mirilla trata de estructurar de manera eficiente el flujo del programa, sobre todo en instrucciones de bifurcacin como son las decisiones, ciclos y saltos de rutinas. La idea es tener los saltos lo ms cerca de las llamadas, siendo el salto lo ms pequeo posible 7.2. Costos 7.2.1. Maquinas Virtuales
Las MV se construyeron para simplificar el proceso del control del hardware de un ordenador porque extienden y enmascaran la funcionalidad del hardware a travs de procedimientos y datos abstractos. Se pueden identificar dos tipos de MV concretas: las que juegan un papel en la preparacin de un programa para su ejecucin (tiempo de compilacin) y las que permiten la ejecucin de dicho programa Las MV suelen aparecer en una jerarqua (como se ver acontinuacion ). Usamos la jerarqua de MV de compilacin, por ejemplo, cada vez que
31
invocamos el compilador de C++. Y dos ejemplos muy comunes del papel de una MV en la jerarqua de MV de ejecucin son PostScript (que define una MV para una impresora) y MSDOS bajo MS Windows (que define una MV que permite que antiguos programas de DOS funcionen bajo Windows). PostScript es una MV que incluye el estado grfico, la ruta actual, el estado del diccionario y, aunque sea bastante complejo, presenta una visin de alto nivel de muchos tipos distintos de impresoras, aislando las caractersticas de las impresoras de las aplicaciones que las usan.
Jerarquas de mquinas virtuales
La realidad es que el desarrollador de un lenguaje suele implementar las MV (de compilacin y/o ejecucin) de su lenguaje en trminos de otras MV ya existentes. Y en el futuro, un programador de aplicaciones utilizar las MV implementadas por el desarrollador del lenguaje para producir programas que a su vez puedan servir como MV para otras aplicaciones, etc. La conclusin, como puede verse, es que una MV no suele existir aislada, sino como parte de una jerarqua de MV. A continuacin se va a ver el papel de las jerarquas de MV en el tiempo de compilacin y de ejecucin. En primer lugar, se va a considerar el papel de la jerarqua de MV en el tiempo de compilacin. En el caso de C++, como lenguaje de alto nivel que se compila a un lenguaje tan cerca del nivel de mquina como sea posible, se puede ver que el proceso de compilacin de un programa de C++ consiste en la interaccin de la jerarqua de MV (aunque puede haber diferencias entre compiladores de C++; por ejemplo, aqu se supone que es un proceso de compilacin que usa C como cdigo intermedio). El pre-procesador acepta el cdigo C++ como fuente y produce otra versin del mismo cdigo C++ con algunas extensiones e incorporaciones resueltas. El traductor convierte el cdigo fuente C++ estndar a cdigo fuente C. El compilador C acepta este cdigo como fuente y lo traduce a cdigo ensamblador (una representacin simblica del cdigo mquina). El ensamblador traduce este cdigo simblico a un cdigo mquina reubicable. Y por fin, el cargador de libreras acepta este cdigo mquina como entrada y produce un programa simple ejecutable, compuesto por el cdigo mquina de entrada y todos los subprogramas necesarios con direcciones de memoria contiguas. Adems del proceso de compilacin, la traduccin completa de los programas de alto nivel (previa a su ejecucin) en una forma que corre sobre la mquina, tambin existe otro proceso, que se llama interpretacin, que tiene ms que ver con el papel de las MV en el tiempo de ejecucin que en el tiempo de compilacin.
32
7.2.2. Criterios de Mejoramiento
La mejor manera de optimizar el cdigo es hacer ver a los programadores que optimicen su cdigo desde el inicio, el problema radica en que el costo podra ser muy grande ya que tendra que codificar mas y/o hacer su cdigo mas legible. Los criterios de optimizacin siempre estn definidos por el copilador Muchos de estos criterios pueden modificarse con directivas del compilador desde el cdigo o de manera externa. Este proceso lo realizan algunas herramientasdel sistema como los ofuscadores para cdigo mvil y codifo para dispositivos mviles
7.2.3 herramientas para el anlisis del flujo de datos
Existen algunas herramientas que permiten el anlisis de los flujos de datos, entre ellas tenemos los depuradores y desambladores. La optimizacin al igual que la programacin es un arte y no se ha podido sistematizar del todo.
33
8. Generacin de cdigo objeto.
8.1 Lenguaje mquina. Se denomina lenguaje mquina a la serie de datos que la parte fsica de la computadora o hardware, es capaz de interpretar. Una computadora digital o, mejor dicho, su parte fsica, slo distingue datos de tipo binario, es decir, constituidos por dos nicos valores a los que se denomina valor 0 y valor 1 y que, fsicamente, se materializan con tensiones comprendidas entre 0 y 4.0 voltios y entre 4 y 5 voltios, respectivamente. Para representar datos que contengan una informacin se utilizan una serie de unos y ceros cuyo conjunto indica dicha informacin. La informacin que hace que el hardware de la computadora realice una determinada actividad de llama instruccin. Por consiguiente una instruccin es un conjunto de unos y ceros. Las instrucciones as formadas equivalen a acciones elementales de la mquina, por lo que al conjunto de dichas instrucciones que son interpretadas directamente por la mquina se denomina lenguaje mquina.
34
El lenguaje mquina fue el primero que empleo el hombre para la programacin de las primeras computadoras. Una instruccin en lenguaje mquina puede representarse de la siguiente forma: 011011001010010011110110. Esta secuencia es fcilmente ejecutada por la computadora, pero es de difcil interpretacin, siendo aun mas difcil la interpretacin de un programa (conjunto de instrucciones) escrito de esta forma. Esta dificultad hace que los errores sean frecuentes y la correccin de los mismos costosa, cuando no imposible, al igual que la verificacin y modificacin de los programas. La anterior secuencia de dgitos binarios (bits) puede indicar a la computadora que: <<Traslade el contenido de la posicin de memoria X a la posicin de memoria Y.>> Si lo vemos escrito de esta forma, lo entenderemos fcilmente, ya que est en nuestro lenguaje natural, pero la mquina elemental ser incapaz de entender nada. Vemos, pues, que la forma de indicar a la mquina lo que debe hacer es totalmente diferente de la indicar a un ser humano lo mismo, por lo que deben emplearse sistemas de traduccin de una forma a otra. Ya se ha dicho que en un principio el programador empleaba directamente el lenguaje mquina. En este caso el traductor era el programador; pero vimos tambin los problemas que esto causaba. Con la prctica en el manejo de la mquina se cay en la cuenta de que se podra utilizar la propia mquina para ayudar en la traduccin de estos programas. Es decir, que si a una mquina elemental se le dotaba de un programa, tambin elemental, que tradujera un nmero determinado de caracteres de caracteres alfabticos en una secuencia de unos y ceros, se podra escribir un programa constituido por una secuencia de grupos de caracteres alfabticos, en la que cada uno de los grupos indicara una accin a realizar por el ordenador y, una vez escrito el programa, sera la propia mquina la que pasara los grupos de caracteres a bits. Las ventajas de esto son evidentes, ya que para el hombre resulta mas fcil manipular grupos de caracteres y la traduccin se hara de manera automtica. Por ejemplo, se podra escribir: TRASLADAR 11010110, 00011101. Esto indicara que el contenido de la posicin 11010110 haba que pasarlo a la posicin 00011101 si se sabe que al grupo alfabtico TRASLADAR le corresponde la secuencia de bits 11110101. La mquina traducira la anterior instruccin como: 11110101 11010110 00011101
35
Al grupo alfabtico se le denomina mnemotcnico, y existir un mnemotcnico por cada instruccin. Se le da este nombre porque sirve para recordar con mayor facilidad el conjunto de instrucciones de una determinada mquina. De esta forma aparecieron los lenguajes ensambladores (Assembler, en ingls). Poco a poco, con el avance de la programacin (Software), estas primeras y sencillas ayudas se fueron haciendo ms complejas, permitiendo que, adems de los mnemotcnicos correspondientes a la operacin a realizar, se pudieran emplear otros para indicar, por ejemplo, los operandos. La anterior instruccin se podra escribir de la siguiente forma: TRASLADAR POS-A POS-B Que nos resulta de ms fcil comprensin. Tambin se introdujo la posibilidad de indicar a la computadora la direccin de un salto en la secuencia de ejecucin de un programa mediante la utilizacin de etiquetas. A los programas que permiten pasar del programa escrito de esta manera (programa fuente, en ensamblador) al lenguaje mquina tambin se les denomina normalmente ensambladores. Estos traductores, como ya se ha dicho, se fueron complicando cada vez ms para que la labor del programador fuera ms fcil, incluyendo los denominados directivos del ensamblador, que son rdenes o informaciones que el programador da al traductor, no instrucciones de lenguaje mquina. Aun con todas estas sofisticaciones y ayudas, el programador de lenguaje ensamblador debe conocer perfectamente el sistema fsico (Hardware) de la mquina con que trabaja, pues aunque emplee mnemotcnicos, etiquetas, etc., stas sirven para indicar una posicin de memoria determinada, un registro o cualquier otra parte de la mquina. Por eso se dice que el lenguaje ensamblador es un lenguaje de bajo nivel, es decir, ligado con el <<hard>> concreto de una determinada mquina. Aqu radica la diferencia importante con los lenguajes ms complejos, llamados de alto nivel, como el Basic, Pascal, Cobol, etc., ya que en stos el programador no tiene porque reconocer el <<hard>> de la mquina. Trabaja con variables, constantes e instrucciones simblicas, y es el traductor quien las transforma en las direcciones apropiadas. 8.1.1 Caractersticas El lenguaje mquina realiza un conjunto de operaciones predeterminadas llamadas micro operaciones. Las micro operaciones slo realizan operaciones del tipo aritmtica (+,-,*, /), lgicas (AND, OR, NOT) y de control (secuencial, decisin, repetitiva) Caractersticas
36
El lenguaje mquina es dependiente del tipo de arquitectura. As un programa mquina para una arquitectura intel x86 no se ejecutar en una arquitectura Power PC de IBM (al menos de manera nativa). Algunos microprocesadores implementan ms funcionalidades llamado CISC, pero son ms lentos que los RISC ya que estos tienen registros ms grandes.
8.1.2 Direccionamiento Es la forma en cmo se accede a la memoria. Recordar que un programa no puede ejecutarse sino se encuentra en memoria principal. La forma de acceder a la memoria depende del microprocesador, pero en general existen dos tipos de direccionamiento: directo e indirecto. Direccionamiento El direccionamiento directo tambin recibe el nombre de direccionamiento absoluto y el acceso a las direcciones se hace de manera directa. El direccionamiento indirecto tambin recibe el nombre de direccionamiento relativo y se basa a partir de una direccin genrica, generalmente el inicio del programa.
Direccionamiento Para acceder a una direccin relativa se suma a ladireccin base el nmero de espacios de memorias necesarias. El direccionamiento relativo hace a los programas relocalizables e independientes. Si la direccin base es el inicio de la memoria fi direccionamiento pasa a ser un variante de direccionamiento absoluto
37
8.2 Lenguaje ensamblador El lenguaje ensamblador, o assembler (assembly language en ingls ) es un lenguaje de programacin de bajo nivel para los computadores, microprocesadores, microcontroladores, y otros circuitos integrados programables. Implementa una representacin simblica de los cdigos de mquina binarios y otras constantes necesarias para programar una arquitectura dada de CPU y constituye la representacin ms directa del cdigo mquina especfico para cada arquitectura legible por un programador. Esta representacin es usualmente definida por el fabricante de hardware, y est basada en los mnemnicos que simbolizan los pasos de procesamiento (las instrucciones), los registros del procesador, las posiciones de memoria, y otras caractersticas del lenguaje. Un lenguaje ensamblador es por lo tanto especfico a cierta arquitectura de computador fsica (o virtual). Esto est en contraste con la mayora de los lenguajes de programacin de alto nivel, que, idealmente son portables. Un programa utilitario llamado ensamblador es usado para traducir sentencias del lenguaje ensamblador al cdigo de mquina del computador objetivo. El ensamblador realiza una traduccin ms o menos isomorfa (un mapeo de uno a uno) desde las sentencias mnemnicas a las instrucciones y datos de mquina. Esto est en contraste con los lenguajes de alto nivel, en los cuales una sola declaracin generalmente da lugar a muchas instrucciones de mquina. Muchos sofisticados ensambladores ofrecen mecanismos adicionales para facilitar el desarrollo del programa, controlar el proceso de ensamblaje, y la ayuda de depuracin. Particularmente, la mayora de los ensambladores modernos incluyen una facilidad de macro (descrita ms abajo), y son llamados macro ensambladores. Fue usado principalmente en los inicios del desarrollo de software, cuando an no se contaba con potentes lenguajes de alto nivel y los recursos eran limitados. Muchos dispositivos programables (como los microcontroladores) aun cuentan con el ensamblador como la nica manera de ser manipulados.
8.2.1 Caractersticas El cdigo escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido ya que su estructura se acerca al lenguaje mquina, es decir, es un lenguaje de bajo nivel.
38
El lenguaje ensamblador es difcilmente portable, es decir, un cdigo escrito para un microprocesador, puede necesitar ser modificado, para poder ser usado en otra mquina distinta. Al cambiar a una mquina con arquitectura diferente, generalmente es necesario reescribirlo completamente. Los programas hechos, por un programador experto, en lenguaje ensamblador, son generalmente mucho ms rpidos y consumen menos recursos del sistema (memoria RAM y ROM) que el programa equivalente compilado desde un lenguaje de alto nivel. Al programar cuidadosamente en lenguaje ensamblador se pueden crear programas que se ejecutan ms rpidamente y ocupan menos espacio que con lenguajes de alto nivel. Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por un microprocesador por lo que se pueden crear segmentos de cdigo difciles y/o muy ineficientes de programar en un lenguaje de alto nivel, ya que, entre otras cosas, en el lenguaje ensamblador se dispone de instrucciones del CPU que generalmente no estn disponibles en los lenguajes de alto nivel. Tambin se puede controlar el tiempo en que tarda una rutina en ejecutarse, e impedir que se interrumpa durante su ejecucin.
8.2.2 Almacenamiento
Una de las principales ventajas del uso del ensamblador, es que se encarga de administrar de manera transparente para el usuario la creacin de memoria, las bifurcaciones y el paso de parmetros. Adems nos permite acceder directamente a los recursos de la mquina para un mejor desempeo.
8.3 Registros Los registros del procesador se emplean para controlar instrucciones en ejecucin, manejar direccionamiento de memoria y proporcionar capacidad aritmtica. Los registros son espacios fsicos dentro del microprocesador con capacidad de 4 bits hasta 64 bits dependiendo del microprocesador que se emplee. Los registros son direccionables por medio de una vieta, que es una direccin de memoria. Los bits, por conveniencia, se numeran de derecha a izquierda (15, 14, 13. 3, 2, 1, 0), los registros estn divididos en seis grupos los cuales tienen un fin especfico. Los registros se dividen en: Registros de segmento
39

Registros de apuntadores de instrucciones Registros apuntadores Registros de propsitos generales Registro ndice Registro de bandera.
Registros de uso general AX = Registro acumulador, dividido en AH y AL (8 bits cada uno).- Interviene en las operaciones aritmticas y lgicas, despus de la operacin arroja un resultado. BX = Registro base, dividido en BH y BL.- Se utiliza en transferencias de datos entre la memoria y el procesador. CX = Registro contador, dividido en CH y CL.- Se utiliza como contador en bucles(LOOP), en operaciones con cadenas(REP), y en desplazamientos(CL). DX = Registro de datos, dividido en DH y DL.- Se utiliza en operaciones de multiplicacin y divisin junto con Ax y en operaciones de entrada y salida de puertos, su mitad inferior DL contiene el nmero de puertos. Registros de segmento. Un registro de segmento se utiliza para alinear en un limite de prrafo o dicho de otra forma codifica la direccin de inicio de cada segmento y su direccin en un registro de segmento supone cuatro bits 0 a su derecha. Un registro de segmento tiene 16 bits de longitud y facilita un rea de memoria para direccionamientos conocidos como el segmento actual. Los registros de segmento son: CS (cdigo), DS (datos), SS (pila), ES , FS y GS. Registro Apuntador de instrucciones.(IP) El registro apuntador de instrucciones (IP) de 16 bits contiene el desplazamiento de direccin de la siguiente instruccin que se ejecuta. Registro ndice. Los registros SI y DI estn disponibles para direccionamientos indexados y para sumas y restas. Que son las operaciones de punta.
40
Registro de bandera. Los registros de banderas sirven parar indicar el estado actual de la maquina y el resultado del procesamiento, Cuando algunas instrucciones piden comparaciones o clculos aritmticos cambian el estado de las banderas.
8.3.1 Distribucin
La distribucin es el proceso en el que el programa generado puede ejecutarse en otras mquinas. Con respecto al ensamblador, la mayora del direccionamiento se hace relativo para que el programa sea relocalizable por un programa llamado cargador. En el caso de programas compilados se necesitan de las libreras, si son estticas se incluyen en el ejecutable por lo que el programa se hace grfico, si son dinmicas no pero el programa es ms pequeo. Debido a la complejidad del software actual se necesitan de asistentes para poder instalar y ejecutar un programa.
8.3.2 Asignacin
La asignacin de valores a variables se hace a travs de un proceso de mover el contenido de memoria a registro, o de registro a memoria, pero nunca de memoria a memoria. Cuando se trata de memoria dinmica se debe seguir el rastro de los datos.
41
8.4 Administracin de memoria
La administracin de memoria se refiere a los distintos mtodos y operaciones que se encargan de obtener la mxima utilidad de la memoria, organizando los procesos y programas que se ejecutan de manera tal que se aproveche de la mejor manera posible el espacio disponible. Para poder lograrlo, la operacin principal que realiza es la de trasladar la informacin que deber ser ejecutada por el procesador, a la memoria principal. Actualmente esta administracin se conoce como Memoria Virtual ya que no es la memoria fsica del procesador sino una memoria virtual que la representa. Entre algunas ventajas, esta memoria permite que el sistema cuente con una memoria ms extensa teniendo la misma memoria real, con lo que esta se puede utilizar de manera ms eficiente. Y por supuesto, que los programas que son utilizados no ocupen lugar innecesario. Entre las principales operaciones que desarrolla la administracin de memoria se encuentran la reubicacin, que consiste en trasladar procesos activos dentro y fuera e la memoria principal para maximizar la utilizacin del procesador; la proteccin, mecanismos que protegen los procesos que se ejecutan de interferencias de otros procesos; uso compartido de cdigos y datos, con lo que el mecanismo de proteccin permite que ciertos procesos de un mismo programa que comparten una tarea tengan memoria en comn.
42
Bibliografa
(s.f.). Recuperado el LUNES de DICIEMBRE de 2010, de http://arantxa.ii.uam.es/alfonsec/docs/compila5.html
(s.f.). Recuperado el LUNES de DICIEMBRE de 2010, de http://serdis.dis.ulpgc.es/~a013775/asignaturas/itisti2/TI2/Apuntes%20del%20curso%202004-2005/An_lisis_sem_nticoby_Ermis.pdf
(s.f.). Recuperado el MARTES de DICIEMBRE de 2010, de http://es.wikipedia.org/wiki/Conversi%C3%B3n_de_tipos
(s.f.). Recuperado el MARTES de DICIEMBRE de 2010, de http://es.wikipedia.org/wiki/Lenguaje_ensamblador
(s.f.). Recuperado el MARTES de DICIEMBRE de 2010, de http://www.mastermagazine.info/termino/3780.php
(s.f.). Recuperado el MIERCOLES de DICIEMBRE de 2010, de http://www.unse-prog2.comxa.com/downloads/Sesion-10.pdf
(s.f.). Recuperado el MIERCOLES de DICIEMBRE de 2010, de http://www.mitecnologico.com/Main/RegistrosLenguajeEnsamblador
(s.f.). Recuperado el JUEVES de DICIEMBRE de 2010, de http://148.202.148.5/cursos/cc206/programaciondesistemas_1_3.html
43
44

Antologia de Pro Todo

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Antologia de Pro Todo

Caricato da

Copyright:

Formati disponibili

2010

ANTOLOGIA PROGRAMACION DE SISTEMAS

INSTITUTO TECNOLOGICO SUPERIOR DE CHAMPOTON 14/12/2010

Comprobacin de unicidad int a;

construir este valor de los valores asociados a los terminales y no terminales B, C, D.

5.5 Pila semntica en un analizador sintctico ascendente (bottom-up).

5.6 Administracin de la tabla de smbolos

5.7 Manejo de errores semnticos.

6. GENERACION DE CODIGO INTERMEDIO

6.3 Representacin de cdigointermedio

6.3.1 Notacin Polaca

6.4.5 Estatuto de ciclos

Jerarquas de mquinas virtuales

7.2.2. Criterios de Mejoramiento

7.2.3 herramientas para el anlisis del flujo de datos

8. Generacin de cdigo objeto.

8.4 Administracin de memoria

(s.f.). Recuperado el LUNES de DICIEMBRE de 2010, de http://arantxa.ii.uam.es/alfonsec/docs/compila5.html

(s.f.). Recuperado el LUNES de DICIEMBRE de 2010, de http://serdis.dis.ulpgc.es/~a013775/asignaturas/itisti2/TI2/Apuntes%20del%20curso%202004-2005/An_lisis_sem_nticoby_Ermis.pdf

(s.f.). Recuperado el MARTES de DICIEMBRE de 2010, de http://es.wikipedia.org/wiki/Conversi%C3%B3n_de_tipos

(s.f.). Recuperado el MARTES de DICIEMBRE de 2010, de http://es.wikipedia.org/wiki/Lenguaje_ensamblador

(s.f.). Recuperado el MARTES de DICIEMBRE de 2010, de http://www.mastermagazine.info/termino/3780.php

(s.f.). Recuperado el MIERCOLES de DICIEMBRE de 2010, de http://www.unse-prog2.comxa.com/downloads/Sesion-10.pdf

(s.f.). Recuperado el MIERCOLES de DICIEMBRE de 2010, de http://www.mitecnologico.com/Main/RegistrosLenguajeEnsamblador

(s.f.). Recuperado el JUEVES de DICIEMBRE de 2010, de http://148.202.148.5/cursos/cc206/programaciondesistemas_1_3.html

Potrebbero piacerti anche