Softwae de sistemas
De Wikilibros, la colección de libros de texto de contenido libre.
Contenido
|
[editar] Unidad 1: Introducción
[editar] Revisión Modelo Von Newman
[editar] Del Problema al Programa Cargado
== Lenguajes Formales ==,
[editar] Editores
[editar] Editores De Carácter
[editar] Editores De Línea
[editar] Editores De Pantalla
[editar] Lenguajes De Programación
[editar] Niveles Lenguajes De Programación(Bajo, intermedio y alto)
[editar] Lenguajes De Programación Tipos (interpretes y compiladores)
[editar] Comparación Interpretes y Compiladores
[editar] Unidad 2: Ensamblador
[editar] Importancia Lenguaje Ensamblador
¿Por que es importante el lenguaje ensamblador? hay muchas razones, por ahora solo las enumero
Trabaja directamente en memoria Poco uso de memoria.
>
Esto no es completamente cierto, la principal importancia que tiene el lenguaje ensamblador, se da a medida de que si conoces que valores deben tomar los registros del cpu (ax, bx, cx, dx, ..etc) en funcion con las interrupciones para poder realizar alguna operacion, entonces no te encuentras limitado a lo que tu lenguaje de programacion te ofrezca, Ejemplo, en pascal, c, c++ , me refiero a las versiones de "turbo" que corren bajo ambiente DOS, ... estos tipos de lenguajes de programacion traen rutinas para hacer lo que deseemos mediante sus librerias, pero que pasa si yo deseo activar el raton??? entonces tengo que utilizar el lenguaje ensamblador, ya sea de manera cotidiana con el
asm {
mov ax, 10
add ax, 20
}
en caso de c/c++
o utilizando la libreria dos.h que permite trabajar el ensdamblador con lenguaje de alto nivel: con : union REGS r; y las interrupciones int86(0x33,&r,&r); para tener un codigo tal como:
r.x.ax = 0;
int86(0x33,&r,&r);
r.x.ax = 1;
int86(0x33,&r,&r);
Estas instrucciones, hacen referencia a AX del CPU, para alimentarlo de valores, que al llamar la interrupcion 33h (que es la encargada de alojar el raton de la pc) entonces permite mostrar el puntero del raton.
Escrito Por: PANCHO LOPEZ DEL <<<TEC>>>
[editar] Manejo De Memoria
[editar] Direccionamiento Memoria
[editar] Formato De Un Programa
[editar] Proceso de Ensamble y Ligado
[editar] Instrucciones
[editar] Instrucciones Aritméticas
[editar] Instrucciones De Comparación
[editar] Instrucciones De Saltos
[editar] Instrucciones Para Stack
[editar] Macros Ensamblador
[editar] Interrupciones Ensamblador
[editar] Unidad 3: Compiladores Funciones
[editar] Fases de un Compilador
[editar] Fase de Análisis Compilador
[editar] Análisis Lexicografico Compilador
Texto en negrita==== Análisis Sintáctico Compilador ==== Texto en cursiva
[editar] Análisis Semántica Compilador
[editar] Fase De Síntesis Compilador
[editar] Generación Optimización Código Intermedio
[editar] Generación Optimización Código Objeto
[editar] Diferencias entre Intérpretes y Compiladores
[editar] Unidad 4: Ligadores y cargadores
[editar] Ligadores
[editar] Liga de bibliotecas de código objeto
[editar] Ligadores Estáticos
Cuando se utilizan subrutinas en un programa, el código ejecutable de cada una de ellas debe encontrarse en memoria al tiempo de ejecución. Para esto, antes de cargar un programa, debe ligarse su código objeto con los códigos objeto (guardados en uno o más archivos) de cada una de las subrutinas invocadas por él, obteniendo así un programa ejecutable que contiene tanto el código del módulo invocador como el código de los módulos invocados. En este punto, es posible guardar el resultado del proceso de liga en un archivo que podrá ser utilizado por un cargador, o el mismo programa ligador puede también realizar la tarea de carga. Esto último evita el tener que guardar el código ejecutable en un archivo, con lo que se ahorra espacio en disco. Este ahorro de espacio en disco se paga con el tiempo gastado al tener que ligar todos los módulos cada vez que se necesite ejecutar el programa.
[editar] Ligadores Dinámicos
[editar] Cargadores
[editar] Carga Absoluta y Relocalizable
EL PROCESO DE CARGA ABSOLUTA Los cargadores absolutos existen en sistemas de los que los compiladores generan código absoluto (no relocalizables).De esta forma se obliga a que el programa se obliga a cargar las mismas posiciones son relativamente pero no permiten tener multiprogramación. La carga absoluta necesita que el modulo de carga ocupe siempre la misma posición de memoria principal. Así pues, todas las referencias del modulo de carga para el cargador deben ser direcciones especificas o absolutas en memoria principal. La asignación de direcciones específica a la referencia de memoria de un programa puede ser realizada tanto por el programador en tiempo de compilación o ensamblaje. Con este método se tienen varias desventajas las cuales son: ¤ Todos los programadores tendrán que conocer la estrategia de asignación deseada para situar los módulos en memoria principal. ¤ Si se hace alguna modificación en el programa que se suponga inserciones o borrados en el cuerpo modulo tendrán que cambiarse las direcciones por consiguiente es expresar simbólicamente y que se resuelvan en el momento de la compilación o ensamblaje. Cuando se prepara el modulo para la entrada a un cargador absoluto, el ensamblador o el compilador convertirá todas esas diferencias a direcciones. Se denomina cargador absoluto porque carga el programa ejecutable en una posición fija. En algunas cargadores absolutos la dirección de carga esta
denominada por un campo en el encabezado del archivo ejecutable .Aunque esta estrategia es un poco mas general que el empleo de una constante predefinida, la posición usada para el programa se sigue determinando al ensamblar y enlazar el programa. En esencia el cargador copia los segmentos de texto y datos de un archivo ejecutable a la memoria de la maquina. A continuación se presenta el pseudo código para un cargador sencillo /***definir la estructura del registro de encabezado ***/ struct enc_ejec{ unsigned int dir_ini; /* las otras partes del encabezado del archivo ejecutable */ }; /***prototipos para las funciones usadas por el cargador***/ struct enc_ejec leer_enc( FILE *); char leer_byte ( FILE *); /***--------el cargador ---------***/ char *carga (File *arch_ejec); { struct enc enc_ejec encabezado ; char *dire_byte; /* leer encabezado del archivo */* encabezado = leer enc(arch_ejec); /*copiar a la memoria los segmentos de texto y datos */ dir_byte = DIR_CARGA; while(leof(arch_ejec)){ dir_byte=leer (arch_ejec); dir_byte= dir_byte+1 ; } return (char*) encabezado dir_ini); } En este código, el cargador comienza leyendo la porción de encabezado contiene la dirección de inicio , ósea la dirección de la primera instrucción que ese ejecuta la .Después de leer el encabezado el cargador entra a u lazo en el cual se copian a la memoria de la maquina los demás bytes del archivo ejecutable (los segmentos de texto y datos ).Por ultimo , el cargador devuelve el valor del campo de dirección inicial del encabezado. Supuestamente, este valor se usa como destino de una instrucción de ramificación (o de salto o subrutina) cuando se ejecuta el programa.
Hay dos aspectos del programa cargador que requiera una mayor explicación: la variable dir_ byte el campo dir_ini. Comenzaremos por la variable dir_byte , que se declara como apuntadores a un carácter, ósea, es la dirección de un carácter. Es razonable suponer que la almacena un carácter usando un byte de memoria y que, por consiguiente, la variable dir_byte contiene la dirección de un byte de memoria .Inicialmente, esta variable se asigna igual a la constante DIR_CARGA. En cada interacción el lazo while, a la posición de memoria identificada por dir_byte se le asigna el siguiente byte del archivo ejecutable; después se incrementa en un valor de dir_byte. De esta manera, el contenido del archivo ejecutable se copia a posiciones consecutivas de la memoria de DIR_CARGA EL PROCESO DE CARGA RELOCALIZABLE En la relocalización dinámica se establece la correspondencia entre las direcciones usadas en el programa a y direcciones físicas cada vez que se utilizan durante la ejecución del programa. Las direcciones 1ógicas generadas por el ensamblador y el enlazador no se alteran durante la carga. Comenzaremos por ver un sencillo método en el cual el programa se carga en posiciones contiguas de la memoria; es decir, el programa no esta disperso por la memoria. En la figura 1.2 se presenta un cargador sencillo que puede usarse con la relocalización dinámica. En este caso, el cargador lee el encabezado del archivo ejecutable y determina la cantidad de espacio necesaria para el programa. Después asigna espacio suficiente para el programa y copia el archivo ejecutable a memoria. Cuando se carga el programa en la memoria, el cargador establece la correspondencia necesaria para el programa, pasando la dirección de carga y el tamaño del programa a una rutina llamada establecer_ correspondencia. AI leer este código, observe que la función de carga devuelve un entero sin signo en lugar de un apuntador. Esto refleja el hecho de que la dirección inicial es una dirección 1ógica y no una dirección física. Pseudo código para un cargador sencillo (relocalización dinámica) Struct enc_ejc{ Unsigned int dir_ini; Unsigned int tamaño_texto, tamaño_datos, tamaño_bss; /*otros campos del registro de encabezado*/ }; /***prototipo para las funciones usadas por el cargador***/ struct enc_leer_enc(FILE*); char leer_byte(FILE*); char*obtener_memoria(unsigned int); void establecer_correspondencia(char*unsigned int); /***el cargador***/ unsigned int*carga (FILE*arch_ejec) { struct enc_ejec encabezado; char*dir-byte, *dir_carga; unsigned int tamaño_prog; encabezado=leer_rnc(arch_ejec); /*determinar el tamaño del programa y asignar el espacio*/ tamaño_prog=encabezado.tamaño_texto + encabezado. Tamaño_datos+ encabezado.tamaño_bss; dir_carga=obtener_memoria (tamaño_prg); /*copiar los segmentos de texto y datos*/ dir_byte =dir_carga; while(!eof(arch_ejec){
- dir_byte=leer_byte(arch_ejec);
dir_byte=dir_byte+1; } /*establecer la correspondencia de direcciones*/ establecer_correspondencia(dir_carga,tamaño_prog); return ((char*)encabezado.dir_ini); } Con esto llegamos al hardware de correspondencia de direcciones, ilustrado en la figura 1.3. Cuando la UCP tiene que realizar un acceso a memoria (lectura o escritura), presenta al hardware de correspondencia de memoria el resultado del cálculo de la dirección efectiva. El hardware de correspondencia de direcciones traduce la dirección 1ógica a una dirección física.
Perspectiva operacional de la correspondencia de direcciones.
