departamento de sistemas e informática - escribiendo … · 2016-09-26 · microprocesadores y...

MICROPROCESADORES Y MICROORDENADORES Página 1 de 56 Ver sión del 29/08/07

ESCRIBIENDO PROGRAMAS EN

ASSEMBLER

ENRIQUE GIANDOMENICO DIGITAL II Departamento Sistemas e Imformática Facultad de Ingeniería Universidad Nacional de Rosario


1. EL CONTADOR DE POSICION ................................................................................................................................5 2. SIMBOLOS ............................................................................................................................................5 3. CONSTANTES ............................................................................................................................................5

3.1. Número Entero..........................................................................................................................................6 3.2. Numero Real .............................................................................................................................................6 3.3. Secuencia de Caracteres.............................................................................................................................6 3.4. Textos .......................................................................................................................................................6

4. DIRECTIVAS Y PSEUDO CODIGOS..........................................................................................................................6 4.1. Asignacion de valores a simbolos ..............................................................................................................6 4.2. Asignacion de espacio de memoria a variables...........................................................................................7

4.2.1. Formato para numeros de coma flotante .............................................................................................................. 8 4.2.1.1. Precisión simple....................................................................................................................................... 8 4.2.1.2. Precisión doble ........................................................................................................................................ 8 4.2.1.3. Precisión extendida .................................................................................................................................. 9

4.2.2. Ejemplos de definiciones y valores almacenados................................................................................................. 9 4.2.3. Otras formas de almacenar informacion: ........................................................................................................... 10

4.2.3.1. Código ASCII......................................................................................................................................... 10 4.2.3.2. Decimal Codificado En Binario No Empaquetado................................................................................... 10 4.2.3.3. Decimal Codificado En Binario Empaquetado ........................................................................................ 10

4.2.4. Instrucciones especiales para formatos especiales ............................................................................................. 10 4.2.4.1. AAA ASCII Adjust After Addition ........................................................................................................ 10 4.2.4.2. AAS ASCII Adjust After Subtraction..................................................................................................... 11 4.2.4.3. AAM ASCII Adjust After Multiply........................................................................................................ 11 4.2.4.4. AAD ASCII Adjust Before Division ....................................................................................................... 11 4.2.4.5. DAA Decimal adjust after division ........................................................................................................ 11 4.2.4.6. DAS Decimal adjust after subtraction..................................................................................................... 12

4.3. Identificacion del procesador ...................................................................................................................12 4.4. Directivas asociadas al manejo de los segmentos......................................................................................12 4.5. Directivas simplificadas...........................................................................................................................13

4.5.1. Directiva .MODEL........................................................................................................................................... 13 4.5.2. Directiva .STACK............................................................................................................................................ 14 4.5.3. Directiva .DATA.............................................................................................................................................. 14 4.5.4. Directiva .CODE .............................................................................................................................................. 15 4.5.5. Directivas .STARTUP, .EXIT y END ............................................................................................................... 15 4.5.6. Ejemplo de programa usando directivas simplificadas....................................................................................... 16

4.5.6.1. CODIGO FUENTE ................................................................................................................................ 16 4.5.6.2. LISTADO OBTENIDO EN LA COMPILACION.................................................................................... 17 4.5.6.3. LISTADO OBTENIDO AL LINKEDITAR ............................................................................................. 20 4.5.6.4. CODIGO CARGADO EN MEMORIA AL EJECUTARSE EL PROGRAMA.......................................... 21 4.5.6.5. ESQUEMA DE MEMORIA ARMADO ................................................................................................. 24 4.5.6.6. Expansión de la directiva STARTUP...................................................................................................... 24

4.6. Directivas Completas...............................................................................................................................26 4.6.1. Directiva Segment ............................................................................................................................................ 26 4.6.2. Directiva Group................................................................................................................................................ 27 4.6.3. Ejemplo de programa usando directivas Completas........................................................................................... 29

4.6.3.1. CODIGO FUENTE ................................................................................................................................ 29 4.6.3.2. LISTADO OBTENIDO EN LA COMPILACION.................................................................................... 31 4.6.3.3. LISTADO OBTENIDO AL LINKEDITAR ............................................................................................. 34 4.6.3.4. CODIGO CARGADO EN MEMORIA AL EJECUTARSE EL PROGRAMA.......................................... 34 4.6.3.5. ESQUEMA DE MEMORIA ARMADO ................................................................................................. 36

4.7. Caracteristicas STANDARD de las Directivas Simplificadas. ..................................................................38 4.8. Procedimientos ........................................................................................................................................39

4.8.1. Pasaje de parametros entre procedimientos. ...................................................................................................... 40


4.8.1.1. ¿CÓMO pasar los parámetros? ............................................................................................................... 40 4.8.1.2. ¿DÓNDE pasar los parámetros? ............................................................................................................. 40

4.8.2. Programa Ejemplo de Pasaje de Parametros. ..................................................................................................... 41 4.8.2.1. Codigo Fuente Propuesto........................................................................................................................ 43

4.9. Programas multimodulos .........................................................................................................................49 4.9.1. Directiva Include .............................................................................................................................................. 49 4.9.2. Directiva Public................................................................................................................................................ 49 4.9.3. Directiva Extern ............................................................................................................................................... 49 4.9.4. Directiva Exterdef ............................................................................................................................................ 50 4.9.5. Ejemplo de programa multimodulo. .................................................................................................................. 50 4.9.6. Listados asociados al programa multimodulo ejemplo ....................................................................................... 50

4.9.6.1. Salida del Linkeditor.............................................................................................................................. 51 4.9.6.2. Salida del ASS. Programa Principal........................................................................................................ 52 4.9.6.3. Salida del ASS. Modulo de uno de los Procedimientos ........................................................................... 54

5. EJERCICIOS ..........................................................................................................................................56

1.


ESCRIBIENDO PROGRAMAS EN ASSEMBLER El compilador ASS es un programa capaz de convertir instrucciones escritas siguiendo determinadas normas en instrucciones de maquina, es decir en el conjunto de ceros y unos que representan el código de cada instrucción. Una instrucción assembler tiene el siguiente formato: Label Mnemotécnico Operandos ; Comentarios

El label identifica la instrucción con un nombre. Dicho nombre puede luego utilizarse como dirección en instrucciones del tipo GOTO, JMP, CALL etc. El mnemotécnico es la sigla que representa al código de instrucción. Se distinguen tres tipos de mnemotécnicos

a) instrucción de maquina Ej. ADD SUB MUL CALL MOV b) Directivas al ASS No generan código de maquina. Solo condicionan la forma de actuar

del ASS c) pseudo código Generan código de maquina pero no ejecutable. Solo reservan lugar en la

memoria Ej. BYTE WORD DWORD etc.

1. EL CONTADOR DE POSICION Toda dirección del espacio de memoria consiste de un segmento y un desplazamiento dentro de ese segmento. El ASS en el proceso de convertir instrucciones en assembler (source code) a instrucciones de maquina ( object code) necesita conocer en todo momento en que lugar de memoria se ubicará cada una de las instrucciones de maquina que se generen. La variable CONTADOR DE POSICION se encarga de dicha tarea. Cuando se le informa al ASS que comienza un nuevo segmento dicha variable asume el valor cero y a partir de allí comienza a incrementarse con cada instrucción de maquina generada en la cantidad de bytes que dicha instrucción ocupe. El CONTADOR DE POSICION es impreso por el ASS en la primera columna de todos sus listados.

2. SIMBOLOS Son secuencias de dígitos, letras y/o caracteres especiales que se asocian a un determinado valor. Pueden usarse para representar: desplazamientos, constantes, direcciones de segmentos u operandos de instrucciones. Ejemplos de símbolos validos son: L1 Magoya Especial Cuenta_1 $imp @ARRP2R6trf ACA? Ejemplos de símbolos inválidos son: 1CUENTA comienza con un dígito Ana.Garcia los únicos caracteres especiales validos son @ $ _ ? $ no se admite solamente un carácter especial VOY AL FINAL no puede tener blancos intermedios

3. CONSTANTES Son símbolos cuyo valor asociado está implícito en la secuencia de dígitos, letras y/o caracteres especiales que lo identifican.


Existen cuatro tipos de constantes:

3.1. NÚMERO ENTERO Es un valor numérico expresado en binario, decimal, octal o hexadecimal. Una letra al final del numero indica el sistema utilizado (b, d o t, o, h ). En hexadecimal todo numero debe empezar con un dígito, por lo tanto si el primer dígito significativo correspondiese a una de las letras (A F) debe insertarse un cero como primer dígito. Si no se especifica letra alguna al final del numero el ASS asume que la base correspondiente es la base default. La base default se especifica con la directiva RADIX nn . Ejemplos 0100111b 125684d A5F6D8h

3.2. NUMERO REAL Representa un numero con el punto decimal incluido. Internamente serán representados como números de punto flotante. Ejemplos: 123.45 .34 123.00 12e3 258e12

3.3. SECUENCIA DE CARACTERES Es un conjunto de caracteres encerrados entre paréntesis o comillas. Ejemplos “ENRIQUE” ‘123 ACS 234/& WER’ ‘MAGOYA DIJO: “YO NO FUI” ’

3.4. TEXTOS Es una secuencia de caracteres encerrada entre los caracteres < y >, la cual será reemplaza textualmente por el ASS cuando sea compaginada. Por ejemplo el texto 5[bx] podría ser asociado con la contaste textual <VAR1>. Durante el proceso de compaginación la instrucción MOV ax, VAR1 sería reemplazada por MOV ax, 5[bx]. Esta facilidad permite al programador liberarse de escribir complicados operandos reiterativamente reemplazándolos por una sintaxis abreviada y luego dejar que el ASS realice el cambio.

4. DIRECTIVAS Y PSEUDO CODIGOS 4.1. ASIGNACION DE VALORES A SIMBOLOS Producida la asignación el símbolo representará dicho valor durante todo el proceso de la compaginación. Los formatos básicos son: Símbolo = expresión Símbolo equ expresión símbolo textequ expresión

El operando expresión es típicamente una constante numérica o del tipo text. Si se usa = la constante numérica debe ser entera. Ejemplos: NumElements = 16 . Array byte NumElements dup (?)


. mov cx, NumElements mov bx, 0 ClrLoop: mov Array[bx], 0

inc bx loop ClrLoop

La directiva TEXTEQU define un símbolo que será sustituido por un texto. La expresión en el campo del operando debe ser una constante de tipo text delimitada entre < y >. Cada vez que el ASS encuentre este símbolo lo reemplazará por dicha constante.

Count textequ <6[bp]> DataPtr textequ <8[bp]> . . .

les bx, DataPtr ;Same as les bx, 8[bp] mov cx, Count ;Same as mov cx, 6[bp] mov al, 0

ClrLp: mov es:[bx], al inc bx loop ClrLp

La directiva EQU incluye y amplia las capacidades del = y del TEXTEQU. Ella admite operandos del tipo numérico, text y secuencia de caracteres. Los que siguen son ejemplos validos del uso de equ One equ 1 Minus1 equ 1 TryAgain equ 'Y' StringEqu equ “Hello there” TxtEqu equ <4[si]> . HTString byte StringEqu ;Igual a HTString equ “Hello there” .

mov ax, TxtEqu ; Igual a mov ax, 4[si] .

mov bl, One ; Igual a mov bl, 1 cmp al, TryAgain ; Igual a cmp al, ‘Y’

4.2. ASIGNACION DE ESPACIO DE MEMORIA A VARIABLES La tabla siguiente muestra los distintos tipo de variables que pueden definirse en Assembler

Palabra clave que la define Espacio reservado Tipo de variable que normalmente contiene

DB, BYTE, SBYTE 8 BITS BINARIA DW, WORD, SWORD 16 BITS BINARIA DD, DWORD, SDWORD 32 BITS BINARIA QWORD 64 BITS BINARIA


TBYTE 80 BITS BINARIA REAL4 32 BITS FLOTANTE REAL8 64 BITS FLOTANTE REAL10 80 BITS FLOTANTE

La ‘s’ que antecede a algunas palabras claves indica que se almacenará en ellas un numero con sig no. Pero es solo indicativo, para que el programador sepa que la intención era guardar valores con signo. Si se almacenan números binarios con el primer dígito igual a uno los interpretará como nega tivos.

4.2.1. FORMATO PARA NUMEROS DE COMA FLOTANTE El numero representado es igual a: mantisa * 2 (exponente – exceso del exponente)

4.2.1.1. Pr ecisión simple

BIT DE EXPONENTE MANTISA SIGNO (El bit 24 de la mantisa es implícito y siempre igual a UNO)

El exponente es en exceso de 127, es decir 2 0 = 127 , 2 x = x + 127

4.2.1.2. Pr ecisión doble

BIT DE EXPONENTE MANTISA SIGNO (El bit 53 de la mantisa es implícito y siempre igual a UNO)

El exponente es en exceso de 1023, es decir 2 0 = 1023 , 2 x = x + 1023


4.2.1.3. Pr ecisión extendida

BIT DE EXPONENTE MANTISA SIGNO

El exponente es en exceso de 16383, es decir 2 0 = 16383 , 2 x = x + 16383 En este caso la mantisa es de 64 bits y no existe ninguno implícito.

4.2.2. EJEMPLOS DE DEFINICIONES Y VALORES ALMACENADOS

Instrucción assembler Bytes reservados

Valor almacenado en hexadecimal

VAR1 BYTE 04 1 04 VAR2 BYTE 123 1 7B VAR3 BYTE 00110011b 1 33 VAR4 WORD 04 2 0004 VAR5 WORD 123 2 007B VAR6 WORD 5D67h 2 5D67 VAR7 WORD “12” 2 3132 VAR8 DWORD 4294967295 4 FFFFFFFF VAR8 DWORD “QUIQ” 4 51554951 VAR9 TBYTE 123456789ABCDEF012h 10 00123456789ABCDEF012 VAR10 REAL4 1.0 4 3F800000

1.0*2**(127–127) VAR11 REAL8 6.5 8 401ª000000000000

1.625*2**(1025–1023) VAR12 REAL10 18.75 10 40039600000000000000

1.171875*2**(16387 16383)

VAR13 REAL4 0.625E3 4 BF200000 1.25*2** (126127)

VAR14 REAL8 0.00000000625 8 3E3AD7F29ABCAF48 VAR15 REAL10 18.75 10 C0039600000000000000


4.2.3. OTRAS FORMAS DE ALMACENAR INFORMACION:

4.2.3.1. Código ASCII. Asigna a cada configuración posible de ocho ceros y unos un símbolo de entre las letras minúsculas, las letras mayúsculas, los números de 0 a 9 y caracteres especiales. Por ejemplo el valor hexadecimal de los códigos asignados a los 10 dígitos numéricos es desde el 30 al 39. El valor hexadecimal de los códigos asignados a las 25 letras minúsculas del alfabeto es desde el 97 al 122. El valor hexadecimal de los códigos asignados a las 25 letras MAYUSCULAS del alfabeto es desde el 65 al 90.

4.2.3.2. Decimal Codificado En Binar io No Empaquetado Es para almacenar números codificados en BCD. Los cuatro bits menos significativo de cada byte representan al dígito decimal y los cuatro bits mas representativos deben ser CEROS. Por ejemplo el numero 493 se almacenaría así 040903h

4.2.3.3. Decimal Codificado En Binar io Empaquetado Es para almacenar números codificados en BCD. Los cuatro bits menos significativo de cada byte representan un dígito decimal y los cuatro bits mas representativos representan otro dígito Por ejemplo el numero 493 se almacenaría así 0493h

4.2.4. INSTRUCCIONES ESPECIALES PARA FORMATOS ESPECIALES Lamentablemente INTEL ha dado en llamar ASCII a la codificación BCD codificada en binario no empaquetada. De allí la confusión que pueden generar las instrucciones siguientes.

4.2.4.1. AAA ASCII Adjust After Addition Analiza los últimos cuatro bits de AL como un numero binario. Si resulta menor o igual a 9 y AF=0 no hace nada. Si resulta mayor a 9 o AF=1 le suma 6 a AL y 1 a AH forzando además a uno los flags CF y AF En ambos casos fuerza los cuatros bits mas significativos de AL a CEROS Ejemplos: Contenido del registro AX antes y después de ejecutar AAA 000D 0103; 310C 3202; 04D3 0403; 312C 3202; 545D 5503

Si se tiene en AX un BCD unpack al cual se le suma otro BCD unpack (de solamente 8 bits) la instrucción AAA es útil para realizar la corrección necesaria. Ejemplos: Valor en AX 0805, al sumarse con ADD AL,08 queda 080D y al ajustarse con AAA queda 0903 Valor en AX 0801, al sumarse con ADD AL,06 queda 0807 y al ajustarse con AAA queda 0807 Valor en AX 0808, al sumarse con ADD AL,09 queda 0811 y al ajustarse con AAA queda 0907 En este ultimo caso a pesar de ser AL = 9 actúa pues la suma anterior dejo AF=1


4.2.4.2. AAS ASCII Adjust After Subtr action Analiza los últimos cuatro bits de AL como un numero binario. Si resulta menor o igual a 9 y AF=0 no hace nada. Si resulta mayor a 9 o AF=1 le resta 6 a AL y 1 a AH forzando además a uno los flags CF y AF En ambos casos fuerza los cuatros bits mas significativos de AL a CEROS Ejemplos: Contenido del registro AX antes y después de ejecutar AAA 000D FF07; 310C 3006; 04D3 0403; 312C 3006; 545D 5307

Si se tiene en AX un BCD unpack al cual se le resta otro BCD unpack (de solamente 8 bits) la instrucción AAS es útil para realizar la corrección necesaria. Ejemplos: Valor en AX 0805, al restarse con SUB AL,08 queda 08FD y al ajustarse con AAS queda 0707 Valor en AX 0805, al restarse con SUB AL,03 queda 0802 y al ajustarse con AAS queda 0802 Valor en AX 0802, restarse con SUB AL,09 queda 08F9 y al ajustarse con AAS queda 0703 En este ultimo caso a pesar de ser AL = 9 actúa pues la suma anterior dejo AF=1

4.2.4.3. AAM ASCII Adjust After Multiply Analiza los últimos cuatro bits de AL como un numero binario. DEBEN representar un numero menor a 100 Coloca la decena en AH (formato BCD UNPACK) y la unidad en AL (formato BCD UNPACK).

Si se tienen dos números UNPACK de 8 bits cada uno y se los multiplica dejando el resultado en AX la instrucción AAM es útil para realizar la corrección necesaria. Ejemplos: Sean los números 08 y 07 que al multiplicarse dejan en AX 56)base 10, al ajustarse queda 0506.

4.2.4.4. AAD ASCII Adjust Befor e Division Si en AX existe un numero BCD UNPACK lo convierte en un valor binario

Si se desea dividir un numero BCD UMPACK de dos cifras por un numero BCD UNPACK de una cifra se debe actuar de la siguiente manera: Cargar en AX el numero BCD de dos cifras 0803 Convertirlo a binario con AAD 0053 Dividirlo por un valor de 8 bits con la instrucción DIV BL o DIV 04 u otra similar cociente en AL

Resto en AH 0314 Salvar AH en algún lugar si se lo requiere Ajustar el cociente con AAM 0200

Para el manejo de datos en el formato packed solo existen las instrucciones para los ajustes después de suma y resta

4.2.4.5. DAA Decimal adjust after division Convierte el contenido de AL interpretando que es el resultado de una suma BCD PACKED y por lo tanto hace (4 bits mas representativos) * 10 + (4 bits menos representativos) * 1 y del numero


resultante guarda la decena en los 4 bits mas representativos de AL y la unidad en los 4 bits menos representativos de AL. Si el numero resultó mayor a 99 fuerza a UNO al flag de carry. Ejemplos: Valor en AX 8833, al sumarse con add AL,AH queda 88BB, al ajustarse con daa queda 8821 y CF La presencia de carry indica que el resultado debe interpretarse como 21 + 100 = 121. Valor en AX 40B3, al sumarse con add AL,AH queda 40F3, al ajustarse con daa queda 4053 y CF La presencia de carry indica que el resultado debe interpretarse como 53 + 100 = 153. Valor en AX 8720, al sumarse con add AL,AH queda 87A7, al ajustarse con daa queda 8707 y CF La presencia de carry indica que el resultado debe interpretarse como 07 + 100 = 107.

Valor en AX 2035, al sumarse con add AL,AH queda 2055, al ajustarse con daa queda 2055

4.2.4.6. DAS Decimal adjust after subtr action Es similar a la anterior con la diferencia que, por el hecho de conocerse que la operación anterior fue una resta , se interpreta en forma diferente el flag CARRY. Este representa pedir prestado y por lo tanto su presencia indica que se deben 100. Ejemplos Valor en AX 8833, al restarse con sub AL,AH queda 88AB, al ajustarse con daa queda 8845 y CF. La presencia de carry indica que el resultado debe interpretarse como 45 100 = 55. Valor en AX 40B3, al restarse con sub AL,AH queda 4073., al ajustarse con daa queda 4073. Valor en AX 8720, al restarse con sub AL,AH queda 8799, al ajustarse con daa queda 8733 y CF La presencia de carry indica que el resultado debe interpretarse como 33 100 = 67 Valor en AX 2035, al restarse con sub AL,AH queda 2015, al ajustarse con daa queda 2015.

4.3. IDENTIFICACION DEL PROCESADOR Luego de procesar la directiva .186 el ASS permitirá solo instrucciones validas para este tipo de procesador. Las instrucciones que solo son validas para procesadores mas avanzados (286, 386, 485, Pentium, etc. ) serán rechazadas con error.

4.4. DIRECTIVAS ASOCIADAS AL MANEJO DE LOS SEGMENTOS. En primer lugar es importante destacar que el termino segmento tiene dos significados: Segmento Físico es un bloque de memoria de 64Kbytes que comienza en una dirección física múltiplo de 16, es decir que expresada en hexadecimal termina en cero. Constituyen el conjunto de direcciones que pueden accederse con un único valor del componente segmento de una dirección lógica. ( Segmento : Desplazamiento). Segmento Lógico es un bloque de memoria de tamaño variable que agrupa posiciones lógicamente relacionadas. En general un segmento lógico es ocupado por Código, Datos o pertenece al Stack. Existen dos formas para la definición de los segmentos: utilizado directivas simplificadas o directivas completas. Las directivas simplificadas asumen valores para la mayoría de los parámetros y es muy simple hacer uso de ellas. Las directivas completas permiten elegir el valor para cada uno de los parámetros requeridos y se utilizan en situaciones más complejas.


Para facilitar el aprendizaje de las directivas asociadas a los segmentos se analizaran primero las simplificadas y luego las complejas. Se limitará el análisis solo a los parámetros que tienen significación para el entorno de aplicaciones a las que se refiere esta publicación.

4.5. DIRECTIVAS SIMPLIFICADAS Son las siguientes .MODEL, .CODE, .CONST, .DATA, .DATA?, .FARDATA, .FARDATA?, .STACK, .STARTUP, .EXIT Un programa consiste de módulos hechos de segmentos. El modulo donde la ejecución del programa comienza se llama modulo principal. El modulo principal puede tener segmentos de código, datos y de Stack. Los módulos adicionales solo pueden tener segmentos de código y/o de datos. Todos deben comenzar con la directiva .MODEL El ejemplo que sigue muestra la estructura básica de un programa con un único modulo

.MODEL small, c ; Esta directiva es obligatoria antes que cualquier otra directiva simplificada

.STACK ; Al no especificar parámetro se asume tamaño igual a 1 KBytes

.DATA ; Comienza el segmento de datos

; Coloque aquí sus declaraciones de datos

.CODE ; Comienza el segmento de código

.STARTUP ; Genera instrucciones ejecutables para la inicialización del programa

; Coloque aquí sus instrucciones

.EXIT ; Genera instrucciones ejecutables para dar por terminado el programa END

4.5.1. DIRECTIVA .MODEL Define atributos que afectan a todo el modulo. Debe especificarse en el código fuente antes de cualquier otra directiva asociada a segmentos. Su sintaxis es: .MODEL ModeloDeMemoria, ConvensionParaNombresSegunLenguaje, DistanciaDelSTACK Modelo de Memoria Se dice que una dirección es cercana cuando tiene un nombre de segmento o un registro de segmento asociado implícitamente. Una dirección es lejana cuando tiene un registro de segmento asociado explícitamente. Cuando dentro de un programa se hace mención a una variable por su nombre o a un label es el programa ASS el que decide como traducirá su dirección en cuanto si será cercana o lejana. Para resolver direcciones lejanas de datos requiere información adicional, en los otros casos lo hace automáticamente. Si un programa solo tiene un segmento para código y otro, para datos y el Stack, todas sus direcciones podrán ser traducidas como direcciones cercanas. Existen seis modelos de memoria


TINY los datos y códigos se colocan en un único segmento. Por lo tanto el programa completo no puede superar los 64 KBytes. El default para el ASS es traducir todas las direcciones como cercanas.

SMALL Tanto los datos como el código ocupan un único segmento cada uno. El ASS traduce las direcciones como cercanas.

LARGE pueden existir múltiples segmentos de datos y de código. MEDIUM y COMPACT son modelos intermedios. El primero admite múltiples segmentos de

código y uno solo de datos y el segundo a la inversa. Existe otro modelo, llamado FLAT, que implica considerar toda el espacio de memoria como único, sin segmentar. (no tiene sentido en el entorno de esta publicación) Convención para nombres según el lenguaje Se sugiere utilizar siempre PASCAL o C Distancia del STACK Si se especifica NEARSTACK (la mas comúnmente usada) el ASS coloca el segmento del STACK dentro del mismo grupo que el segmento de datos. Si se especifica FARSTACK el ASS coloca el segmento del STACK fuera del grupo asignado a los segmentos de datos.(Ver agrupando segmentos más adelante)

4.5.2. DIRECTIVA .STACK El STACK es la sección de memoria utilizada para colocar y retirar datos mediante las instrucciones PUSH y POP. Es un buen lugar para guardar las variables temporales y locales. La directiva .STACK inicia un segmento cuyo nombre es “STACK”, le asigna el tamaño indicado en el único parámetro que admite la directiva (1024 Bytes si no se especifica ningún valor) y cierra el segmento.

4.5.3. DIRECTIVA .DATA Crea un segmento de datos cercano llamado _DATA. Esto implica que todas las variables que se definan en el serán direccionadas por el ASS con direcciones cercanas. Es conveniente, entonces, colocar en este segmento todas aquellas variables que vayan a utilizarse frecuentemente. Recordar la limitación que el tamaño máximo de un segmento es 64 KBytes. El ASS también genera automáticamente un grupo de segmentos llamado DGROUP donde es colocado el segmento _DATA. Pueden utilizarse también otras directivas más especificas para generar segmentos de datos. Ellas son: .DATA? se agrega al grupo DGROUP. Solo permite definir variables no inicializadas. .CONST se agrega al grupo DGROUP. Solo permite definir variables inicializadas y que no

vayan a modificarse durante la ejecución del programa. El ASS dará error si se intenta acceder a esta dirección con una instrucción de escritura.

.FARDATA y .FARDATA? son similares a .DATA y :DATA? Con la diferencia que generan segmentos que no son agrupados en el grupo DGROUP. Solo deberían usarse con modelos de memorias Compact o Large. Las variables que se definan dentro de estos segmentos tendrán direcciones lejanas y por lo tanto es importante realizar las siguientes dos actividades. a) Debe informarse al ASS que segmento se habrá de usar al direccionar estas variables. Esto se

logra con la directiva ASSUME RegDeSegmentoAUsar : Nombre del segmento


b) Debe, en tiempo de ejecución, cargarse el registro de segmento usado con el valor correspondiente.

En el ejemplo desarrollado al final se incluyen estas directivas.

4.5.4. DIRECTIVA .CODE Inicia un segmento de código. Si el modelo de memoria es SMALL o COMPACT todos los segmentos de código son agrupados en uno solo llamado _TEXT. En los otros modelos cada modulo genera un segmento llamado NombreDelModulo_TEXT

4.5.5. DIRECTIVAS .STARTUP, .EXIT Y END Son validas para comenzar y terminar programas bajo DOS. No son validas si el programa será ejecutado sin la presencia del sistema operativo. Se debe colocar .STARTUP donde se desea que el programa comience. Normalmente es a continuación de la directiva .CODE. La directiva .EXIT genera las instrucciones necesarias para terminar el programa bajo DOS. La directiva END informa al ASS que termina un modulo. Todo modulo debe terminar con END independientemente de que se hayan usado directivas simplificadas o completas. Si no se usa .STARTUP se debe dar la dirección de comienzo del programa como parámetro de la END. El parámetro es el valor del label que identifica a la que se desea sea la primera instrucción a ejecutar. El ejemplo que sigue muestra un típico programa codificado usando directivas simplificadas


4.5.6. EJEMPLO DE PROGRAMA USANDO DIRECTIVAS SIMPLIFICADAS 4.5.6.1. CODIGO FUENTE

1: ; Estructura de un Programa Principal usando directivas simplificadas 2: 3: .MODEL large, c ; Esta directiva es requerida previa a toda otra 4: ; directiva simplificada 5: 6: .STACK ; Se usar… el valor por default de 1kilobyte para el stack 7: 8: .DATA ; Comienza el segmento de datos cercano _DATA 9: 10: VAR1 BYTE 16 11: VAR2 BYTE 10 DUP (?) 12: VAR3 BYTE 10 13: 14: .FARDATA ;Comienza el segmento de datos lejanos FAR_DATA 15: ASSUME ES:FAR_DATA ;Se le informa al ASS que para toda variable 16: ; que pertenezca a este segmento utilice el reg 17: ; ES como registro de segmento 18: VAR10 BYTE 8 19: VAR11 WORD 230 20: 21: 22: .CODE ; Comienza el segmento de código 23: .STARTUP ; Genera las instrucciones ejecutables para inicializar 24: ; los registros requeridos bajo DOS 25: ; Codifique sus propias instrucciones aquí 26: 27: MOV AX, @fardata ; Carga en AX la dirección del segmento FARDATA 28: MOV DS, AX ; Carga en DS el valor de AX 29: 30: MOV AH,VAR1 31: MOV AL,VAR3 32: MOV AX,VAR11 33: MOV AL,VAR10 34:


35: 36: 37: .EXIT ; Genera las instrucciones ejecutables para terminar 38: ; el programa bajo DOS 39: END

4.5.6.2. LISTADO OBTENIDO EN LA COMPILACION

; Estructura de un Programa Principal usando directivas simplificadas

.MODEL large, c ; Esta directiva es requerida previa a toda otra ; directiva simplificada

.STACK ; Se usar… el valor por default de 1kilobyte pa ra el stack

0000 .DATA ; Comienza el segmento de datos cercano _DATA Al comenzar un nuevo segmento el Contador de posiciones asume el valor CERO

0000 10 VAR1 BYTE 16 En el desplazamiento 0000 se ubica la variable VAR1 cuyo valor es 10

0001 000A [ VAR2 BYTE 10 DUP (?) 00

] En el desplazamiento 0001 se ubica la variable VAR2 que tiene una long. de 10 Bytes

000B 0A VAR3 BYTE 10

0000 .FARDATA ;Comienza el segmento de datos lejanos FAR_DATA Al comenzar un nuevo segmento el Contador de posiciones asume el valor CERO

ASSUME ES:FAR_DATA ;Se le informa al ASS que para toda variable ; que pertenezca a este segmento utilice el reg ; ES como registro de segmento

0000 08 VAR10 BYTE 8 0001 00E6 VAR11 WORD 230


0000 .CODE ; Comienza el segmento de código Al comenzar un nuevo segmento el Contador de posiciones asume el valor CERO

.STARTUP ; Genera las instrucciones ejecutables para ini cializar ; los registros requeridos bajo DOS

0000 *@Startup: 0000 BA R * mov dx, DGROUP 0003 8E DA * mov ds, dx 0005 8C D3 * mov bx, ss 0007 2B DA * sub bx, dx 0009 D1 E3 * shl bx, 001h 000B D1 E3 * shl bx, 001h 000D D1 E3 * shl bx, 001h 000F D1 E3 * shl bx, 001h 0011 FA * cli 0012 8E D2 * mov ss, dx 0014 03 E3 * add sp, bx 0016 FB * sti

; Codifique sus propias instrucciones aquí

0017 B8 R MOV AX, @fardata Lugar reservado para colocar el valor a ser cargado en AX Código correspondiente a la instrucción Mov La letra R indica que la instrucción debe completarse a posteriori, en este caso en el momento de cargar el programa pues solo en ese memento se sabrá efectivamente donde estará cargado el segmento FARDATA

001A 8E D8 MOV DS, AX

001C 8A 26 0000 R MOV AH,VAR1 0000 es el actual valor del desplazamiento para VAR1 Código correspondiente a la instrucción Mov

Estas son las instrucciones ejecutables que inserta el ASS para cumplir con la inicialización requerida bajo el DOS. Ver explicación al


La letra R indica que la instrucción debe completarse a posteriori, en este caso luego de la linkedicción pues solo en ese memento se sabrá si el seg mento donde se encuentra VAR1 fue agrupado con otro o no.

0020 A0 000B R MOV AL,VAR3 0023 26: A1 0001 R MOV AX,VAR11

0001 es el actual valor del desplazamiento para VAR11 Código correspondiente a la instrucción Mov La letra R indica que la instrucción debe completarse a posteriori, en este caso luego de la linkedicción pues solo en ese memento se sabrá si el seg mento donde se encuentra VAR11 fue agrupado con otro o no. Indica que debe usarse como reg. de segmento ES en lugar del standard DS

0027 26: A0 0000 R MOV AL,VAR10

.EXIT ; Genera las instrucciones ejecutables para ;terminar el programa bajo DOS

002B B4 4C * mov ah, 04Ch 002D CD 21 * int 021h

END

Segments and Groups:

Para cada segmento generado se especifica: Size: el 16 indica que se usaran 16 bits para indicar el desplazamiento dentro de este seg

mento. Por lo tanto el tamaño máximo del segmento será de 64 KBytes. Length el tamaño actual del segmento Align, Combine y Class son propiedades de los segmentos que se describirán mas adelante.

N a m e Size Length Align Combine Class

DGROUP . . . . . . . . . . . . . GROUP

Son las instrucciones ejecutables que agrega el ASS para terminar el programa bajo DOS


_DATA . . . . . . . . . . . . . 16 Bit 000C Word Public 'DATA' STACK . . . . . . . . . . . . . 16 Bit 0400 Para Stack 'STACK' EJEMPLO_TEXT . . . . . . . . . . . 16 Bit 002F Word Public 'CODE' FAR_DATA . . . . . . . . . . . . 16 Bit 0003 Para Private 'FAR_DATA'

Symbols:

N a m e Type Value Attr

@CodeSize . . . . . . . . . . . Number 0001h @DataSize . . . . . . . . . . . Number 0001h @Interface . . . . . . . . . . . Number 0001h @Model . . . . . . . . . . . . . Number 0005h @Startup . . . . . . . . . . . . L Near 0000 EJEMPLO_TEXT @code . . . . . . . . . . . . . Text EJEMPLO_TEXT @data . . . . . . . . . . . . . Text DGROUP @fardata? . . . . . . . . . . . Text FAR_BSS @fardata . . . . . . . . . . . . Text FAR_DATA @stack . . . . . . . . . . . . . Text DGROUP VAR10 . . . . . . . . . . . . . Byte 0000 FAR_DATA VAR11 . . . . . . . . . . . . . Word 0001 FAR_DATA VAR1 . . . . . . . . . . . . . . Byte 0000 _DATA VAR2 . . . . . . . . . . . . . . Byte 0001 _DATA VAR3 . . . . . . . . . . . . . . Byte 000B _DATA

0 Warnings 0 Errors

4.5.6.3. LISTADO OBTENIDO AL LINKEDITAR

Para cada segmento generado se muestra: Dirección donde arranca y dirección donde termina. Longitud en hexadecimal.

Estas variables son del Sistema y siempre son definidas por el ASS

Estas son las variables definidas por el usuario. Para cada una se informa en que segmento se encuentra.


Nombre: _DATA, STACK, FAR_DATA son nombres standard dados por el ASS EJEMPLO_TEXT surge de anteponer al nombre standard dado por el ASS de _TEXT al segmen

to de código cercano el nombre de cada modulo que se obtiene del nombre del archivo .asm donde reside el código fuente. Si bien en este programa solo hay un segmento de código, su nombre no es _TEXT pues el modelo de memoria elegido fue LARGE

Start Stop Length Name Class 00000H 0002EH 0002FH EJEMPLO_TEXT CODE 16bit

at offset 00000H 0002FH bytes from EJEMPLO.obj (EJEMPLO.ASM)

00030H 0003BH 0000CH _DATA DATA 16bit at offset 00000H 0000CH bytes from EJEMPLO.obj (EJEMPLO.ASM)

00040H 0043FH 00400H STACK STACK 16bit at offset 00000H 00400H bytes from EJEMPLO.obj (EJEMPLO.ASM)

00440H 00442H 00003H FAR_DATA FAR_DATA 16bit at offset 00000H 00003H bytes from EJEMPLO.obj (EJEMPLO.ASM)

Origin Group 0003:0 DGROUP Indica que el grupo DGROUP será ubicado en una dirección 00300 mas arriba

que el punto de carga que se le de al programa. Por lo tanto DS deberá cargarse con el valor de CS mas 0003. Address Publics by Name Address Publics by Value

Program entry point at 0000:0000 Indica que el programa debe comenzar a ejecutarse en la instrucción ubicada el la dirección 0000:0000. Por supuesto esta dirección debe desplazarse en el valor correspondiente al punto de carga del programa. Será suficiente para ello cargar el registro CS con dicho valor.

4.5.6.4. CODIGO CARGADO EN MEMORIA AL EJECUTARSE EL PROGRAMA


El listado siguiente muestra el contenido de ciertas posiciones de memoria cuando el progra ma fue cargado para su ejecución. Es importante destacar que fue cargado para ejecución bajo DOS. El DOS se encarga por si mismo de cargar los siguientes registros con los valores indicados: CS con el punto de carga que le asignó al programa SP con el valor correspondiente al tamaño del STACK SS con el valor de dirección de segmento asignado por el linkeditor al segmento STACK des plazado por el valor correspondiente al punto de carga. En este caso en particular CS = 265B, SP = 0400 y SS = 265B + 4 = 265F

1: ; Estructura de un Programa Principal usando directivas simplificadas 2: 3: .MODEL large, c ; Esta directiva es requerida previa a toda otra 4: ; directiva simplificada 5: 6: .STACK ; Se usar… el valor por default de 1kilobyte para rl stack 7: 8: .DATA ; Comienza el segmento de datos cercano _DATA 9: 10: VAR1 BYTE 16 11: VAR2 BYTE 10 DUP (?) 12: VAR3 BYTE 10 13: 14: .FARDATA ;Comienza el segmento de datos lejanos FAR_DATA 15: ASSUME ES:FAR_DATA ;Se le informa al ASS que para toda variable 16: ; que pertenezca a este segmento utilice el reg 17: ; ES como registro de segmento 18: VAR10 BYTE 8 19: VAR11 WORD 230 20: 21: 22: .CODE ; Comienza el segmento de código 23: .STARTUP ; Genera las instrucciones ejecutables para inicializar 24: ; los registros requeridos bajo DOS 265B:0000 BA5E26 MOV DX,265E


La primera instrucción ejecutable se cargó en 265B:0000 El valor de 265E es la dirección del grupo DGROUP que le pasa el Linkeditor (0003 más que el punto de carga) Cada nueva instrucción es colocada con el mismo desplazamiento que fue indicando el Contador de Posiciones en el listado del ASS.

265B:0003 8EDA MOV DS,DX 265B:0005 8CD3 MOV BX,SS 265B:0007 2BDA SUB BX,DX 265B:0009 D1E3 SHL BX,1 265B:000B D1E3 SHL BX,1 265B:000D D1E3 SHL BX,1 265B:000F D1E3 SHL BX,1 265B:0011 FA CLI 265B:0012 8ED2 MOV SS,DX 265B:0014 03E3 ADD SP,BX 265B:0016 FB STI 25: ; Codifique sus propias instrucciones aquí 26: 27: MOV AX,@fardata 265B:0017 B89F26 MOV AX,269F El valor de 269F surge de la siguiente manera: El linkeditor informó que el segmento FARDATA se encontraba desplazado 00440 del co mienzo. En términos de direcciones lógicas 00440 se puede expresar como 0044:0000. Por lo tanto la dirección del segmento que corres ponde a FARDATA será 0044 superior al punto de carga del programa. 269F no es mas que 265B (punto de carga) mas 44h. 28: MOV DS,AX 265B:001A 8ED8 MOV DS,AX 29: 30: MOV AH,VAR1 265B:001C 8A260000 MOV AH,BYTE PTR [0000]

El desplazamiento de VAR1 dentro de su segmento no ha variado por razones de agrupamiento y por lo tan to sigue siendo 0000

31: MOV AL,VAR3 265B:0020 A00B00 MOV AL,BYTE PTR [000B] 32: MOV AX,VAR11 265B:0023 26A10100 MOV AX,WORD PTR [0001]

El desplazamiento de VAR11 dentro de su segmento no ha variado por razo nes de agrupamiento y por lo tanto sigue siendo 0000. Notar que, por de

Estas son las instrucciones ejecutables que inserta el ASS para cumplir con la inicialización requerida bajo el DOS. Ver explicación al final de los listados


finición del formato de la instrucción, el desplazamiento (de 2 bytes) se indica colocando primero el byte menos significativo y luego el más.

33: MOV AL,VAR10 265B:0027 26A00000 MOV AL,BYTE PTR [0000] 34: 35: 36: 37: .EXIT ; Genera las instrucciones ejecutables para terminar 38: ; el programa bajo DOS 265B:002B B44C MOV AH,4C 265B:002D CD21 INT 21 39: END

4.5.6.5. ESQUEMA DE MEMORIA ARMADO El esquema siguiente muestra como se ha asignado la memoria para este programa.

00442h DATOS LEJANOS TAMAÑO = 00442h – 00440h + 1 = 3h = 3d Bytes

0044:0000 = 00440h 0043Fh = 0003:040F

STACK TAMAÑO = 0043Fh – 00040h + 1 = 400h = 1024d Bytes 0003:0010 = 00040h

0003B = 0003:000B 0003:0000 = 00030h DATOS CERCANOS TAMAÑO = 0003Bh – 00030h + 1 = Ch = 12d Bytes

0002Fh = 0000:002F CODIGO TAMAÑO = 0002Fh – 00000h + 1 = 30h = 48d Bytes

0000:0000 = 00000h

STACK y DATOS CERTCANOS han sido agrupados en el mismo grupo y por lo tanto constituyen un único segmento físico Al cargarse el programa para su ejecución todas las direcciones se desplazan en el valor correspondiente al punto de carga.

4.5.6.6. Expansión de la directiva STARTUP Las instrucciones agregadas por el ASS como consecuencia del STARTUP sirven para la inicialización bajo DOS. mov dx, DGROUP carga en DX la dirección del segmento DGROUP y la mov ds, dx traspasa al registro DS mov bx, ss Carga en BX el valor que trae SS (dirección del segmento STACK)


sub bx, dx Le resta la dirección del segmento DGROUP shl bx, 001h Con los cuatro desplazamientos logra shl bx, 001h multiplicar BX por 16 shl bx, 001h shl bx, 001h cli mov ss, dx Carga SS con dirección segmento DGROUP add sp, bx Le suma a SP el valor calculado en BX que no es mas que la longitud

del área asignada a _DATA pues al agruparse _DATA y STACK en un úni co grupo el final del stack se ve desplazado en el tamaño de _DATA

sti


4.6. DIRECTIVAS COMPLETAS Las directivas simplificadas están orientadas a generar programas que ejecutaran bajo DOS. En ese marco permiten fácilmente generar la estructura requerida, de forma tal, que el programador se concentre en la solución de su propio problema. Cuando se desea generar un programa que ejecute sin la presencia de un sistema operativo (aplicaciones del tipo industrial) es necesario recurrir a las directivas completas.

4.6.1. DIRECTIVA SEGMENT Su formato es:

NombreDelSegmento SEGMENT READONLY, align, combine, use, ‘class’

NombreDelSegmento: es el nombre del segmento. ASS usa el nombre para tres actividades: combinar segmentos, determinar si es necesario un segment overr ide prefix y obtener la dirección del segmento. Es obligatorio especificar el nombre del segmento en la directiva ENDS que da por finalizado un segmento determinado. La única posibilidad admitida de que el nombre no sea único es que haya sido utilizado previamente para definir otro segmento. En dicho caso este segmento se considerará simplemente como una continuación del anterior. Cada vez que se inicia un segmento la variable Contador de Posición asume el valor cero, salvo que el segmento sea considerado como continuación de uno previo (con igual nombre) en cuyo caso asume el mismo valor que tenia cuando termino el segmento previo. Si se usa el nombre de un segmento como operando en una instrucción, el ASS codificará la instrucción como de direccionamiento inmediato dejando el valor de dirección en cero. Solo en tiempo de ejecución, cuando se conozca el valor del punto de carga del programa podrá conocerse la dirección real en donde fue cargado el segmento en cuestión. La dirección de un segmento es de cuatro dígitos hexadecimales pues siempre un segmento debe cargarse en direcciones físicas múltiplos de 16. Otro uso del nombre del segmento es proveer el componente segmento de una dirección lógica. La expresión SegUno:Var3 direcciona a la variable llamada Var3 que se encuentra definida en el segmento llamado SegUno. Para que el ASS sepa que registro utilizar como registro de segmento debe asociarse el nombre a un registro mediante la directiva ASSUNE. En este caso podría ser como ejemplo ASSUME ES : SegUno. En general el ASS genera los segmentos en el mismo orden en el que fueron especificados en el código fuente. La directiva .ALPHA indica al ASS que genere los segmentos en orden alfabético de sus nombres.

READONLY: indica que el segmento será de solo lectura. El ASS indicará un error si alguna instrucción intenta grabar en alguna dirección perteneciente a este segmento.

Align: puede asumir alguno de los siguientes valores byte, word, dword, para o page. Fija condiciones a la dirección del segmento que es coincidente con la dirección de su primer byte. byte implica que puede ser cualquiera, word que debe ser par, dword que debe ser múltiplo de 4, para múltiplo de 16 y page múltiplo de 256.


Combine: determina el orden en el que los segmento con igual nombre son escritos en el código objeto por el ASS. Los valores que puede asumir son public, stack , pr ivate o at El valor public y stack son básicamente similares. Ellos combinan segmentos con el mismo nombre en un único segmento continuo. Por supuesto los desplazamientos de las variables pertenecientes a los segmentos combinados son ajustados en correspondencia. La diferencia reside en la forma que el DOS inicializa los registros SS y SP. En un programa genérico, bajo DOS, debería existir al menos un segmento stack ( si no hay ninguno el linkeditor indica error de aviso) y todos los otros deberían ser public. El DOS cargará el registro SS con la dirección del segmento stack y el registro SP con el valor que representa el tamaño de dicho segmento. Private, que es el valor por default implica que el segmento no debe ser combinado con ningún otro. At debe ir acompañado de una constante entre 0000h y FFFFh. El valor de la constante indica la dirección en donde este segmento estará cargado en memoria. Cuando un segmento tiene indicada de esta forma su dirección de carga por supuesto se lo considera privado, no combinable ni agrupable. Es decir que tanto el ASS como el LINKEDITOR respetaran permanentemente como dirección del segmento a la dirección indicada. El parámetro private solo tiene significado en un programa multimódulo pues en un mismo modulo si dos segmentos tienen el mismo nombre siempre son combinados. Si provienen de módulos distintos solo lo son si tienen el parámetro public.

Use: indica el tamaño máximo de los segmentos a generar. En el caso del 80186 solo puede especificarse use16 que es el valor por default.

‘class’ especifica el orden en el que serán generados los segmentos que no tienen igual nombre. Puede asumir cualquier valor encerrado entre apóstrofes. Generalmente son usados los valores ‘CODE’, ‘DATA’, ‘STACK’ y a veces ‘CONST’, ‘FARDATA’, etc. La siguiente secuencia muestra el proceso de generación del archivo .EXE 1) El ASS combina los segmentos que tienen igual nombre 2) Una vez combinados los segmentos son grabados en el archivo OBJ en el orden en el que fueron

especificados en el código fuente. 3) El LinkEditor lee él o los distintos OBJ generados por el ASS y reacomoda los objetos al

generar el archivo .EXE. El primer segmento grabado en el .EXE es el primer segmento encontrado en el primer OBJ.

4) A continuación se grabaran todos los demás segmentos, independientemente de a que OBJ pertenezcan, que tengan la misma clase.

5) Una vez grabados todos los segmentos pertenecientes a la misma clase que se esta procesando se ubica en el archivo de OBJs el siguiente segmento cuya clase no haya sido procesada aun y se lo graba en el .EXE

6) Se repiten los pasos 4 y 5 hasta que la totalidad de los segmentos haya sido grabada en el .EXE.

4.6.2. DIRECTIVA GROUP En programas complejos, por razones de buena documentación y facilidades posteriores en el mantenimiento, la cantidad de segmentos definidos es grande. El tamaño de dichos segmentos generalmente es menor a 64Kbytes (en realidad resulta mucho menor). Si se cargaran en forma independiente sería necesario actualizar el contenido del segmento usado para direccionar cada ves que se acceda a variables ubicadas en distintos segmentos. Para hacer al código mas eficiente resulta


interesante agrupar varios segmentos en uno solo, lo cual es posible siempre y cuando el tamaño total no supere los 64 KBytes, con lo cual todas las variables pertenecientes al segmento resultante podrían direccionarse con el mismo registro de segmento y sin que este deba actualizar su valor. Esto se logra con la directiva GROUP cuyo formato es

NombreDelGrupo GROUP NombreDelSegmentoQueSeDeseaAgregarAlGrupo ,

Por supuesto, los desplazamientos calculados para las variables pertenecientes a los segmentos agrupados son recalculados en consecuencia. La necesidad de este recálculo se ejemplifica a continuación:

Si la variable Var1 tiene un desplazamiento de 10d dentro del segmento Seg1 el ASS codificará su dirección cuando Var1 sea operando en una instrucción como XX : 000A donde XX será el registro de segmento que corresponda. Si el Seg1 se combina con el Seg0 cuyo tamaño es 128d y se lo ubica en las posiciones mas altas el código previamente generado debe modificarse y quedar XX : 008A donde 8ª representa en hexadecimal la suma de 10 mas 128.


4.6.3. EJEMPLO DE PROGRAMA USANDO DIRECTIVAS COMPLETAS

Supóngase se desea codificar un programa para ser ejecutado, sin sistema operativo, en un equipo en el cual se han mapeado en su espacio de direcciones de memoria los siguientes dispositivos: Memoria ROM de 64Kbytes desde la posición 0F0000h hasta la 0FEEEEh (UCS) Memoria RAM de 16Kbytes desde la posición 00000h hasta la 04000h (LCS) Se deberán ubicar en la ROM los módulos de código y aquellos que contengan datos que permanezcan constantes durante toda la ejecución del programa. En la RAM deberá ubicarse un segmento para aquellas variables cuyo valor deba ser modificado y un segmento para el Stack. Recordar que las primeras 1024d direcciones del espacio de memoria deben reservarse para la tabla de vectores de Interrupciones. 4.6.3.1. CODIGO FUENTE 1: ; Ejemplo de programa para ejecutar sin dos 2: ; En la parte alta de memoria ROM con código y datos inicializados 3: ; En la parte baja de memoria RAM para Stack y variables que cambian su valor 4: 5: .186 6: 7: DSEGC SEGMENT PUBLIC 'CONST' 8: ;segmento para constantes 9: 10: ITEM1 BYTE 32 11: ITEM2 WORD 256 12: ITEM3 BYTE 'GIANDOMENICO' 13: DSEGC ENDS 14: 15: 16: CSEG SEGMENT PUBLIC 'CODE' 17: ASSUME DS:DSEGC,ES:DSEGV

La directiva previa informa al ASS que las direcciones de las variables que pertenecen al segmento DSEGC deben codificarse usando DS como componente segmento, las pertenecientes a DSEGV usarán ES.


Como este programa se ejecutará sin la presencia de un sistema operativo el mismo programa debe ocuparse de cargar con los valores correspondientes los registros de segmento. La CPU solo asegura la carga inicial de CS con el valor 0FFFFh e IP con 0000h pues todo programa comienza en la dirección FFFF :0000 = FFFF0h. Generalmente a partir de dicha dirección y hasta 0FFFFFh se graban las primeras instrucciones correspondientes al ‘reset’ que incluyen un ‘jump’ a la verdadera direc ción de comienzo del programa.

18: ;carga ds con la dirección del segmento dsegc 19: START: MOV AX, DSEGC 20: MOV DS,AX 21: ;carga es con la dirección del segmento dsegv 22: MOV AX,DSEGV 23: MOV ES,AX 24: ;carga ss con la dirección del segmento stck 25: MOV AX,STCK 26: MOV SS,AX 27: ;carga sp con el tamaño del stack 28: MOV AX,0400H 29: MOV SP,AX 30: ;instrucciones propias del programa en cuestión 31: MOV AX,ITEM2 32: MOV ITEM12,AX 33: MOV AL,ITEM1 34: MOV ITEM11,AL 35: ;termina bajo dos 36: FIN: MOV AH, 04CH 37: INT 021H 38: CSEG ENDS 39: 40: DSEGV SEGMENT 'ZZZZ' AT 0040H 41: ;segmento para variables que modifican su valor 42: ;si la dirección de carga es 0040h su dirección física será 0400h 43: ;justo donde termina la 'interrup vector table' 44: ITEM11 BYTE ? 45: ITEM12 WORD ?


46: DSEGV ENDS 47: STCK SEGMENT 'ZZZZ' AT 0050H 48: ;si la dirección de carga es 0050h su dirección física será 0500h 49: ;es decir se reservan 100h bytes para el segmento dsegv 50: STK WORD 1024 DUP (?) 51: STCK ENDS 52: 53: END START 54: _

4.6.3.2. LISTADO OBTENIDO EN LA COMPILACION

Microsoft (R) Macro Assembler Version 6.11 SAMPDIRE.ASM Page 1 1

; Ejemplo de programa para ejecutar sin dos ; En la parte alta de memoria ROM con código y datos inicializados

; En la parte baja de memoria RAM para Stack y variables que cambian su valor

.186

0000 DSEGC SEGMENT PUBLIC 'CONST' ;segmento para constantes

0000 20 ITEM1 BYTE 32 0001 0100 ITEM2 WORD 256 0003 47 49 41 4E 44 4F ITEM3 BYTE 'GIANDOMENICO'

4D 45 4E 49 43 4F 000F DSEGC ENDS

0000 CSEG SEGMENT PUBLIC 'CODE' ASSUME DS:DSEGC,ES:DSEGV

;carga ds con la dirección del segmento dsegc 0000 B8 R START: MOV AX, DSEGC


0003 8E D8 MOV DS,AX ;carga es con la dirección del segmento dsegv

0005 B8 R MOV AX,DSEGV 0008 8E C0 MOV ES,AX

;carga ss con la dirección del segmento stck 000A B8 R MOV AX,STCK 000D 8E D0 MOV SS,AX

;carga sp con el tamaño del Stack 000F B8 0400 MOV AX,0400H 0012 8B E0 MOV SP,AX

;instrucciones propias del programa en cuestión 0014 A1 0001 R MOV AX,ITEM2 0017 26: A3 0001 R MOV ITEM12,AX 001B A0 0000 R MOV AL,ITEM1 001E 26: A2 0000 R MOV ITEM11,AL

;termina bajo dos 0022 B4 4C FIN: MOV AH, 04CH 0024 CD 21 INT 021H 0026 CSEG ENDS

0000 DSEGV SEGMENT 'ZZZZ' AT 0040H ;segmento para variables que modifican su valor ;si la dirección de carga es 0040h su dirección física será 0400h ;justo donde termina la 'interrup vector table'

0000 00 ITEM11 BYTE ? 0001 0000 ITEM12 WORD ? 0003 DSEGV ENDS 0000 STCK SEGMENT 'ZZZZ' AT 0050H

;si la dirección de carga es 0050h su dirección física será 0500h ;es decir se reservan 100h bytes para el segmento dsegv

0000 0400 [ STK WORD 1024 DUP (?) 0000

] 0800 STCK ENDS

END START _


_Microsoft (R) Macro Assembler Version 6.11 SAMPDIRE.ASM Symbols 2 1

Segments and Groups:

N a m e Size Length Align Combine Class

CSEG . . . . . . . . . . . . . . 16 Bit 0026 Para Public 'CODE'

DSEGC . . . . . . . . . . . . . 16 Bit 000F Para Public 'CONST'

DSEGV . . . . . . . . . . . . . 16 Bit 0003 Abs Private 'ZZZZ'

STCK . . . . . . . . . . . . . . 16 Bit 0800 Abs Private 'ZZZZ'

El valor Abs para el parámetro combine indica que la dirección fue dada en forma absoluta y por lo tanto será respetada como tal.

Symbols:


FIN . . . . . . . . . . . . . . L Near 0022 CSEG ITEM11 . . . . . . . . . . . . . Byte 0000 DSEGV ITEM12 . . . . . . . . . . . . . Word 0001 DSEGV ITEM1 . . . . . . . . . . . . . Byte 0000 DSEGC ITEM2 . . . . . . . . . . . . . Word 0001 DSEGC ITEM3 . . . . . . . . . . . . . Byte 0003 DSEGC START . . . . . . . . . . . . . L Near 0000 CSEG STK . . . . . . . . . . . . . . Word 0000 STCK

0 Warnings 0 Errors


4.6.3.3. LISTADO OBTENIDO AL LINKEDITAR LINK : warning L4021: no stack segment

Start Stop Length Name Class 00000H 0000EH 0000FH DSEGC CONST 16bit

at offset 00000H 0000FH bytes from SAMPDIRE.obj (SAMPDIRE.ASM)

00010H 00035H 00026H CSEG CODE 16bit at offset 00000H 00026H bytes from SAMPDIRE.obj (SAMPDIRE.ASM)

Los segmentos con direcciones absolutas son ignorados por el linkeditor pues nada puede hacer con ellos.

Address Publics by Name

Address Publics by Value

Program entry point at 0001:0000 La primera instrucción ejecutable del programa se encuentra en la dirección conformada por desplazamiento cero y segmento igual a uno más que el punto de carga que se le asigne al programa

4.6.3.4. CODIGO CARGADO EN MEMORIA AL EJECUTARSE EL PROGRAMA

1: ; Ejemplo de programa para ejecutar sin dos 2: ; En la parte alta de memoria ROM con código y datos inicializados 3: ; En la parte baja de memoria RAM para Stack y variables que cambian su valor 4: 5: .186 6: 7: DSEGC SEGMENT PUBLIC 'CONST' 8: ;segmento para constantes 9: 10: ITEM1 BYTE 32 11: ITEM2 WORD 256


12: ITEM3 BYTE 'GIANDOMENICO' 13: DSEGC ENDS 14: 15: 16: CSEG SEGMENT PUBLIC 'CODE' 17: ASSUME DS:DSEGC,ES:DSEGV 18: ;carga ds con la dirección del segmento dsegc 19: START: MOV AX, DSEGC

La prueba de ejecución se realizo por comodidad bajo DOS. Por lo tanto el programa fue cargado por el DOS en la dirección 2663:0000 y el DOS se ocupó de cargar el registro CS con el valor 2664h.La primera instrucción ejecutable se ubicó entonces en 2364:0000

2664:0000 B86326 MOV AX,2663 2663 es la dirección del segmento DSEGC

20: MOV DS,AX 2664:0003 8ED8 MOV DS,AX 21: ;carga es con la dirección del segmento dsegv 22: MOV AX,DSEGV 2664:0005 B84000 MOV AX,0040

El LinkEditor generó la instrucción con la dirección 0040 incluida pues era absoluta 23: MOV ES,AX 2664:0008 8EC0 MOV ES,AX 24: ;carga ss con la dirección del segmento Stack 25: MOV AX,STCK 2664:000A B85000 MOV AX,0050

El LinkEditor generó la instrucción con la dirección 0050 incluida pues era absoluta 26: MOV SS,AX 2664:000D 8ED0 MOV SS,AX 27: ;carga sp con el tamaño del Stack 28: MOV AX,0400H 2664:000F B80004 MOV AX,0400 29: MOV SP,AX 2664:0012 8BE0 MOV SP,AX 30: ;instrucciones propias del programa en cuestión 31: MOV AX,ITEM2 2664:0014 A10100 MOV AX,WORD PTR [0001]


La codificación de la instrucción anterior usa DS como segmento y 0001 como desplaza miento para la dirección de ITEM2

32: MOV ITEM12,AX 2664:0017 26A30100 MOV WORD PTR [0001],AX

La codificación de la instrucción anterior usa ES como segmento (lo indica con el byte de ‘segment override’ al comienzo de la instrucción que tiene el valor 26) y 0001 como desplazamiento para la dirección de ITEM12

33: MOV AL,ITEM1 2664:001B A00000 MOV AL,BYTE PTR [0000] 34: MOV ITEM11,AL 2664:001E 26A20000 MOV BYTE PTR [0000],AL 35: ;termina bajo dos 36: FIN: MOV AH, 04CH 2664:0022 B44C MOV AH,4C 37: INT 021H 2664:0024 CD21 INT 21 38: CSEG ENDS 39: 40: DSEGV SEGMENT 'ZZZZ' AT 0040H 41: ;segmento para variables que modifican su valor 42: ;si la dirección de carga es 0040h su dirección física será 0400h 43: ;justo donde termina la 'interrup vector table' 44: ITEM11 BYTE ? 45: ITEM12 WORD ? 46: DSEGV ENDS 47: STCK SEGMENT 'ZZZZ' AT 0050H 48: ;si la dirección de carga es 0050h su dirección física será 0500h 49: ;es decir se reservan 100h bytes para el segmento dsegv 50: STK WORD 1024 DUP (?) 51: STCK ENDS 52: 53: END START 4.6.3.5. ESQUEMA DE MEMORIA RESULTANTE El esquema siguiente muestra como se ha asignado la memoria para este programa.

NO USADO


F0035h = F001:0025 CODIGO TAMAÑO = F0035h – F0010h + 1 = 26h = 38d Bytes

F001:0000 =F0010h F000Eh = F000:000E

CONSTANTES TAMAÑO = F000Eh – F0000h + 1 = Fh = 15d Bytes F000:0000 = F0000h

ROM NO MAPEADO

RAM

NO USADO 008FF = 0050:03FF

0050:0000 = 00500h STACK TAMAÑO = 008FFh – 00500h + 1 = 400h = 1024d Bytes 0043F = 0040:003F

0040:0000 = 00400h VARIABLES TAMAÑO = 0043Fh – 00400h + 1 = 40h = 64d Bytes 003FFh = 0000:03FF

TABLA VECTOR INTERR TAMAÑO = 003FFh – 00000h + 1 = 400h =1024d Bytes 0000:0000 = 00000h La versión cargada en memoria cuando se ejecutó bajo DOS debe ajustarse cuando se ejecute sin él haciendo que a partir de la posición FEEE0h se ejecute la instruccion JMP START.(Deberian agregarse todas las intrucciones para inicializar los dispositivos internos)


4.7. CARACTERISTICAS STANDARD DE LAS DIRECTIVAS SIMPLIFICADAS.

Las tablas que siguen muestran como se conforman las directivas simplificadas en los distintos modelos de memoria existentes. Si la directiva .Model es usada siempre se genera el segmento _TEXT aun si todos los segmentos .CODE especifican su propio nombre. El nombre default usado para segmentos de código lejanos esta compuesto por el nombre del archivo que contiene al modulo mas _TEXT. Los nombres default de los segmentos .CODE, .FARDATA y .FARDATA? pueden modificarse especificando un nombre en la directiva correspondiente. Las directivas ASSUME y GROUP que se generan automáticamente no son mostradas en los listados correspondientes. Para un programa que defina todos los segmentos posibles la GROUP generada será DGROUP GROUP _DATA, CONST, _BSS, STACK La directiva ASSUME dependerá del modelo de memoria usado Para Tiny ASSUME CS:DGROUP, DS: DGROUP, SS:DGROUP Para Small y Compact ASSUME CS:_TEXT, DS: DGROUP, SS:DGROUP Para Medium, Large y Huge ASSUME CS:Name_TEXT, DS: DGROUP, SS:DGROUP

Model Directive Name Align Combine Class Gr oup

Tiny .CODE _TEXT WORD PUBLIC 'CODE' DGROUP .FARDATA FAR_DATA PARA PRIVATE 'FAR_DATA' .FARDATA? FAR_BSS PARA PRIVATE 'FAR_BSS'

.DATA _DATA WORD PUBLIC 'DATA' DGROUP .CONST CONST WORD PUBLIC 'CONST' DGROUP .DATA? _BSS WORD PUBLIC 'BSS' DGROUP

Small .CODE _TEXT WORD PUBLIC 'CODE' .FARDATA FAR_DATA PARA PRIVATE 'FAR_DATA' .FARDATA? FAR_BSS PARA PRIVATE 'FAR_BSS'

.DATA _DATA WORD PUBLIC 'DATA' DGROUP .CONST CONST WORD PUBLIC 'CONST' DGROUP .DATA? _BSS WORD PUBLIC 'BSS' DGROUP .STACK STACK PARA STACK 'STACK' DGROUP*

Medium .CODE name_TEXT WORD PUBLIC 'CODE' .FARDATA FAR_DATA PARA PRIVATE 'FAR_DATA' .FARDATA? FAR_BSS PARA PRIVATE 'FAR_BSS'

.DATA _DATA WORD PUBLIC 'DATA' DGROUP .CONST CONST WORD PUBLIC 'CONST' DGROUP .DATA? _BSS WORD PUBLIC 'BSS' DGROUP .STACK STACK PARA STACK 'STACK' DGROUP*

Compact .CODE _TEXT WORD PUBLIC 'CODE' .FARDATA FAR_DATA PARA PRIVATE 'FAR_DATA' .FARDATA? FAR_BSS PARA PRIVATE 'FAR_BSS'

.DATA _DATA WORD PUBLIC 'DATA' DGROUP


.CONST CONST WORD PUBLIC 'CONST' DGROUP .DATA? _BSS WORD PUBLIC 'BSS' DGROUP .STACK STACK PARA STACK 'STACK' DGROUP*

Large or .CODE name_TEXT WORD PUBLIC 'CODE' Huge .FARDATA FAR_DATA PARA PRIVATE 'FAR_DATA'

.FARDATA? FAR_BSS PARA PRIVATE 'FAR_BSS' .DATA _DATA WORD PUBLIC 'DATA' DGROUP .CONST CONST WORD PUBLIC 'CONST' DGROUP .DATA? _BSS WORD PUBLIC 'BSS' DGROUP .STACK STACK PARA STACK 'STACK' DGROUP*

Flat .CODE _TEXT DWORD PUBLIC 'CODE' .FARDATA _DATA DWORD PUBLIC 'DATA' .FARDATA? _BSS DWORD PUBLIC 'BSS'

.DATA _DATA DWORD PUBLIC 'DATA' .CONST CONST DWORD PUBLIC 'CONST' .DATA? _BSS DWORD PUBLIC 'BSS' .STACK STACK DWORD PUBLIC 'STACK'

4.8. PROCEDIMIENTOS Los procedimientos son conjuntos de instrucciones lógicamente relacionados. Generalmente un programa está formado por varios procedimientos. La estructura básica de un procedimiento es:

NombreDelProced proc operandos . . <instrucciones> . NombreDelProced endp

MonbreDelProced debe ser único dentro de un programa El procedimiento recibe el control mediante una instrucción CALL MonbreDelProced y lo devuelve con la instrucción RET. Los operandos pueden ser NEAR o FAR. El ASS reconoce cuando un procedimiento es NEAR y por lo tanto el CALL que lo invoca solo indicará desplazamiento pues se supone se encuentra en el mismo segmento y por lo tanto CS contiene el valor correspondiente al Segmento de la dirección. En cambio si es FAR al invocárselo se especificará segmento y desplazamiento. Es importante destacar que la directiva ENDP solo le informa al ASS que terminó un procedimiento, no es una instrucción ejecutable, no hace que el procedimiento devuelva el control. En el ejemplo siguiente si se llama a Proc1 luego de la instrucción mov ax, 0 se ejecutará la primera instrucción del Proc2 Proc1 proc

mov ax, 0


Proc1 endp Proc2 proc

mov bx, 0FFFFH ret

Proc2 endp 4.8.1. PASAJE DE PARAMETROS ENTRE PROCEDIMIENTOS. Existen muchas y muy variadas formas de pasar parámetros entre procedimientos. Ellas surgen de las distintas formas de contestar las preguntas como? y donde?. A continuación se analizarán solo algunas de las formas posibles. 4.8.1.1. ¿CÓMO pasar los parámetros? Se pueden pasar valores o referencias. La figura que sigue muestra un típico caso

Procedimiento Proc1 Procedimiento Proc2

Var1 Byte 18 Recibe un byte Llama a Proc2 y lo muestra por pasándole Var1 pantalla

El procedimiento Proc1 tiene definida la variable Var1 y en un momento determinado llama al procedimiento Proc2 pasándole la variable Var1 para que Proc2 la muestre en pantalla. Pasar parámetros por valor significa que Proc1 le pasa en realidad el valor de Var1 a Proc2.( en este caso 18), Proc2 definirá su propia variable, le asignará el valor recibido y de allí en mas continuará con su proceso. Esto implica que si Proc2 modificara en algún momento la variable, que para él representa al parámetro recibido, Proc1 nunca se enteraría de ello. Dicho de otra forma, el parámetro pasado, para el procedimiento que lo recibe, solo puede ser de entrada. Finalizado Proc2 y vuelto el control a Proc1, Var1 seguirá siempre valiendo 18 En cambio si el pasaje se hiciese por referencias Proc1 en realidad le pasa a Proc2 la dirección de la variable Var1 y Proc2 considera a esta dirección como la representación del parámetro recibido. Toda modificación que realice Proc2 sobre el parámetro repercutirá por supuesto en Var1. Finalizado Proc2 y vuelto el control a Proc1, el valor de Var1 puede haber sido alterado por Proc2. En este caso puede decirse que el parámetro pasado, para el procedimiento que lo recibe, puede ser de entrada, de salida o de entrada/salida. 4.8.1.2. ¿DÓNDE pasar los par ámetros? a) Mediante el uso de los registros de uso general o de segmentos

Para el caso de pasajes por valor los 16 bits de cada registro puede representar alguna limitación Para el caso de pasajes por referencias, para una dirección cercana basta con un registro que especifique el offset de la variable en cuestión, para una dirección lejana deberán especificarse dos registros: uno para el segmento y el otro para el offset.

b) Mediante el uso del Stack Valen para este caso los mismo comentarios que para el caso anterior. Además, como el Stack es una facilidad de uso general y cuyo comportamiento se ve afectado por la historia, es importante asegurar que todo proceso que lo use lo deje tal cual lo recibió al terminar. Esto obliga a definir ciertas reglas en el uso del Stack para el pasaje de parámetros. Se adoptarán la siguiente:


El programa llamador colocará en el Stack primero los parámetros de entrada/salida o salida y al ultimo todos los de entrada solamente. El programa llamado será el encargado de retirar del Stack todos los parámetros recibidos que sean solo de entrada y actualizará el valor de los de entrada/salida y salida El programa llamador, por ultimo, retirará del Stack todos los parámetros de entrada/salida y salida que haya colocado.

c) Mediante valores insertados en el mismo código Este método solo sirve para pasar parámetros por valor. Implica colocar los valores a continuación de la instrucción ‘Call’ como si fueran una extensión de la misma instrucción. El programa llamado deberá ajustar el contador de programa para que cuando el control regrese al programa llamador el proceso continúe adecuadamente

d) Mediante variables locales o comunes. Este método es el menos recomendable.

4.8.2. PROGRAMA EJEMPLO DE PASAJE DE PARAMETROS.

Escribir un programa que en función de los datos definidos: dos números N1 y N2 y una secuencia de caracteres SecDada, coloque en una variable llamada SecResult (longitud máxima asegurada 255 bytes) la siguiente secuencia de caracteres: (N1 + N2) caracteres * , la secuencia SecDada y (N1 N2) caracteres @ y en la variable LongSecResult la longitud de la secuencia generada. Para resolver el problema generar y usar los siguientes procedimientos:

Proc SumaRegAyB Proc RestaP3deP2

Proc AlmacALEnDS_BX Proc AlmacCantDeP1EnP2_P3

Proc AlmacSecCaract

Los procedimientos definidos muestran distintos ejemplo de pasaje de parámetros: Por valor, mediante registros Ax y Bx en SumaRegAyB, Ax en AlmacAxEnDS_BX

Recibe en Ax y Bx dos numeros. Devuelve en Ax la suma de ambos

Recibe via el stack tres parametros P1, P2, P3. Coloca en P1 el resultado P2 –P3

Coloca el carácter recibido en AL en la direccion de memoria dada por: seg mento DS desplazamiento BX

Recibe via el stack tres parametros P1, P2, P3 Coloca el carácter recibido en P1 (8 bits menos signif.), la cantidad de veces indicada en los 8 bits mas significativos de P1 a partir de la direc cion de memoria dada por: segmento P2 desplazamiento P3

A continuacion de la instrucción Call que lo invoque deberá definirse una variables que contenga una secuencia de caracteres de longitud variable pero terminada con un byte con 00h Este procedimiento colocará en la direccion formada por DS:BX la secuencia de caracteres y de volvera en BX la longitud total de la secuencia de caracteres colocada


Por referencia, mediante registros Variable receptora en AlmacAxEnDS_BX Por valor, mediante el Stack P2 y P3 en RestaP3deP2, P1 en AlmacCantDeP1EnP2_ Por referencia, mediante el Stack Variable receptora en AlmacCantDeP1EnP2_P3 Mediante valores insertados en el mismo código, por valor secuencia de caracteres en AlmacSecCaract


4.8.2.1. Codigo Fuente Propuesto

; Programa ejemplo mostrando el pasaje de parámetros ; con directivas de segmento simplificadas.

.186

.MODEL small, c

.STACK

.DATA N1 BYTE 25 N2 BYTE 15 SECDADA EQU 'GIANDOMENICO ENRIQUE ESTEBAN',0 SECRESULT BYTE 255 DUP (?) LONGSECRESULT BYTE ? ASTER BYTE '*' ARROBA BYTE '@'

.CODE

.STARTUP ;Calcula la suma de N1 y N2

XOR AX,AX XOR BX,BX MOV AL,N1 MOV BL,N2 CALL SumaRegAyB

;Prepara para colocar los * MOV CX,AX ;CX cant. de bytes a transferir XOR AX,AX MOV AL,ASTER ;AL contiene carácter a transferir MOV BX,OFFSET SECRESULT ;BX desplazamiento variable receptora MOV DX,BX ADD DX,CX ;DX desplaz. primer lugar libre luego de los *

; loop que coloca la cantidad de caracteres requeridos en la variable receptora COLOCA_ASTER:

CALL AlmacALEnDS_BX INC BX LOOP COLOCA_ASTER


; coloca la secuencia de caracteres definida en SECDATA ; tal como lo exige el procedimiento a continuación del CALL se inserta ; la secuencia de caracteres a almacenar

MOV BX,DX CALL AlmacSecCaract

SECCAR BYTE SECDADA ; DX desplazamiento al primer lugar libre luego de la secuencia de caracteres

ADD DX,BX ; calcula N1 menos N2

PUSH AX ;reserva lugar para el resultado MOV AL,N1 PUSH AX ;coloca el parámetro P2 MOV AL,N2 PUSH AX ;coloca el parámetro P3 CALL RestaP3deP2

;prepara para colocar los @ POP BX ;BX = N1 –N2 MOV AX,BX SHL AX,8 MOV AL,ARROBA ;AX cant de bytes, carácter a insertar PUSH AX ;coloca parámetro P1 MOV AX, SEG DGROUP PUSH AX ;coloca parámetro P2 PUSH DX ;coloca parámetro P3

; DX desplazamiento al primer lugar libre luego de la secuencia @ ADD DX,BX

; coloca la cantidad de @ requeridos en la variable receptora CALL AlmacCantDeP1EnP2_P3

;coloca en la variable 'LongSecResult' la long de la secuencia generada SUB DX,OFFSET SECRESULT MOV LongSecResult,DL

;termina bajo dos .EXIT

;comienza la definición de los procedimientos.


SumaRegAyB PROC NEAR ADD AX,BX RET

SumaRegAyB ENDP ; RestaP3deP2 PROC NEAR ; coloque a continuación para cada uno de los parámetros que se hayan colocado en el Stack ; una directiva de la forma NombreDelParámetro EQU xx[BP]. Donde xx debe valer 04 para el ; ultimo parámetro, 06 para el anteúltimo y así sucesivamente aumentando de dos en dos hasta ; llegar al primer parámetro ParamResult EQU 8[BP] ParamN1 EQU 6[BP] ParamN2 EQU 4[BP] ; salve el valor de BP y cargue BP con el valor de SP

PUSH BP MOV BP, SP ; BP apunta ahora al comienzo del Stack

; salve los registros que se usaran en el procedimiento PUSH DX

;haciendo referencia al nombre dado a los parámetros resuelva el problema en cuestión MOV DX, ParamN1 SUB DX, ParamN2 MOV ParamResult, DX

;restituya a su valor original cada uno de los registros usados en el procedimiento POP DX

;restituya en BP el valor previamente salvado POP BP

;termine el procedimiento con RET indicando la cantidad de parámetros que el procedimiento ;elimina del Stack (son los parámetros de entrada), los restantes (de entrada/salida) ;deberán ser eliminados por el programa llamador

RET 4 RestaP3deP2 ENDP ; AlmacALEnDS_BX PROC NEAR

MOV DS:[BX],AL RET

AlmacALEnDS_BX ENDP


; AlmacCantDeP1EnP2_P3 PROC NEAR ; coloque a continuación para cada uno de los parámetros que se hayan colocado en el Stack ; una directiva de la forma NombreDelParámetro EQU xx[BP]. Donde xx debe valer 04 para el ; ultimo parámetro, 06 para el anteúltimo y así sucesivamente aumentando de dos en dos hasta ; llegar al primer parámetro ParamP1 EQU 8[BP] ParamP2 EQU 6[BP] ParamP3 EQU 4[BP] ; salve el valor de BP y cargue BP con el valor de SP


; salve los registros que se usaran en el procedimiento PUSH AX PUSH BX PUSH CX PUSH ES

;haciendo referencia al nombre dado a los parámetros resuelva el problema en cuestión MOV BX, ParamP3 MOV ES, ParamP2 MOV AX, ParamP1 XOR CX,CX MOV CL,AH

COLOCACRT: MOV ES:[BX],AL INC BX LOOP COLOCACRT

;restituya a su valor original cada uno de los registros usados en el procedimiento POP ES POP CX POP BX POP AX


;termine el procedimiento con RET indicando la cantidad de parámetros que el procedimiento ;elimina del Stack (son los parámetros de entrada), los restantes (de entrada/salida)


;deberán ser eliminados por el programa llamador RET 4

AlmacCantDeP1EnP2_P3 ENDP ; AlmacSecCaract PROC NEAR ; coloque a continuación para cada uno de los parámetros que se hayan colocado en el Stack ; una directiva de la forma NombreDelParámetro EQU xx[BP]. Donde xx debe valer 04 para el ; ultimo parámetro, 06 para el anteúltimo y así sucesivamente aumentando de dos en dos hasta ; llegar al primer parámetro ; ; salve el valor de BP y cargue BP con el valor de SP


; salve los registros que se usaran en el procedimiento PUSH DI PUSH AX

;haciendo referencia al nombre dado a los parámetros resuelva el problema en cuestión ; para acceder a las variables insertadas como código recuerde que el valor guardado en ; 2[BP] representa el desplazamiento del primer byte después del CALL, el segmento que ; completa la dirección es CS.

MOV DI, 2[BP] ;Coloca en DI la dirección siguiente al CALL ;que coincide con la dirección del primer carácter

COLOCACRT: MOV AL, CS:[DI] ;Coloca en AL el primer carácter CMP AL, 0 ;Cheque si el carácter es 00h JZ FINPRC ;en caso afirmativo termina el procedimiento MOV DS:[BX],AL ;si no mueve el carácter a la dirección DS:BX INC DI ;DI apunta al próximo carácter INC BX ;BX apunta al próximo lugar receptor JMP COLOCACRT ;analiza el carácter apuntado

FINPRC: INC DI ;DI apunta al primer byte después del 00h que ;coincide con la instrucción

MOV BX,DI ;BX almacena la cantidad de bytes que se colocaron SUB BX,2[BP] ;en el receptor sin considerar el 00h que da DEC BX ;por terminada la secuencia


MOV 2[BP], DI ;Coloca DI en el lugar del Stack donde debe estar el desplazamiento de la dirección de retorno

;restituya a su valor original cada uno de los registros usados en el procedimiento POP AX POP DI


;termine el procedimiento con RET indicando la cantidad de parámetros que el procedimiento ;elimina del Stack (son los parámetros de entrada), los restantes (de entrada/salida) ;deberán ser eliminados por el programa llamador

RET AlmacSecCaract ENDP ;

END


4.9. PROGRAMAS MULTIMODULOS Cuando el programa a desarrollar es complejo, conviene subdividirlo en módulos. Un modulo es un conjunto de datos y procedimientos lógicamente relacionados. Un modulo puede compaginarse en forma independiente dando origen a un archivo .OBJ. Luego dichos datos y/o procedimientos podrán ser usados desde cualquier programa si el archivo .OBJ del programa se linkedita conjuntamente con el archivo .OBJ del modulo. Esta técnica permite construir módulos con procedimientos de uso general que pueden ser invocados desde cualquier programa sin necesidad de repetir la codificación dentro de cada programa que requiera usarlos. El ASS provee varias directivas para implementar esta técnica.

4.9.1. DIRECTIVA INCLUDE Tiene la siguiente forma:

INCLUDE filename donde filename es el nombre de un archivo del tipo texto. Cuando el ASS encuentra una directiva Include abre el archivo indicado y lee todo su contenido. Encontrado el fin de archivo el ASS continua leyendo el archivo que contiene al código fuente a partir de la siguiente instrucción al include. Los archivos del tipo include son ideales entonces para contener todas aquellas declaraciones que son comunes a muchos programas. De esta forma se asegura consistencia y se reduce el esfuerzo de mantenimiento. Si mas que un modulo accederá al archivo include este no puede contener instrucciones que definan variables o reserven espacio de memoria pues en ese caso el ASS definirá las variables o reservará el espacio mas de una vez. Generalmente la directiva Include se coloca en los módulos antes de la definición de los segmentos de datos y/o código.

4.9.2. DIRECTIVA PUBLIC Tiene el siguiente formato:

Public TipodeLenguaje, nombre , donde TipoDeLenguaje indica la convención

acerca de como se manejan los nombres (usar C o SYSCALL) y nombre es el nombre que quiere hacerse publico. El nombre involucrado en la directiva public es publico y por lo tanto será reconocido por otros módulos.

4.9.3. DIRECTIVA EXTERN Su formato es:

EXTERN TipodeLenguaje nombre:TipodeVariable , donde:

TipoDeLenguaje: tiene el mismo significado que en Public y en .Model Nombre: identifica a la variable o label en cuestión TipoDeVarible identifica al tipo de la variable. Ej. Byte, word, Near, Far, etc.

La directiva Extern le informa al ASS que el nombre involucrado es externo. Por lo tanto el ASS no indica error al no poder resolverlo y deja que lo resuelva a posteriori el linkeditor.


4.9.4. DIRECTIVA EXTERDEF Esta directiva es una conjunción entre la public y la extern y permite que el mismo archivo del tipo include sea colocado en todos los módulos. La directiva EXTERNDEF actúa: igual que la PUBLIC para todos los nombres que ella menciona y se encuentran definidos en el modulo que se está compaginando, igual que la EXTERN para todos aquellos nombres que ella menciona y no se encuentran definidos en el modulo que se está compaginando. Tiene el mismo formato que la EXTERN.

4.9.5. EJEMPLO DE PROGRAMA MULTIMODULO. Se describen a continuación las acciones realizadas para convertir el programa desarrollado en el ejemplo de pasaje de parámetros en un programa multimódulo.

a) Se generó un archivo Declara.txt con las siguientes instrucciones: externdef SumaRegAyB:near, AlmacALEnDS_BX:near, AlmacSecCaract:near externdef RestaP3deP2:near, AlamcP1EnP2_P3:near

b) Se eliminaron del archivo fuente todas las instrucciones que constituían los cinco procedimientos definidos.

c) Con las instrucciones de cada uno de los procedimientos se generaron cinco archivos independientes del tipo .ASM, agregándosele al comienzo de cada uno las siguientes instrucciones:

.MODEL SMALL,syscall

.CODE Include declara.txt

y al final la instrucción END.

Cada archivo constituye ahora un modulo independiente y por lo tanto puede ser compilado por separado. En caso de ser necesaria una modificación en alguno de ellos puede realizársela y solo recompaginar el modulo en cuestión. Por supuesto el ejecutable del programa final debe linkeditarse nuevamente con el programa LINK e indicando que deben considerarse todos los .OBJ que conforman dicho programa. 4.9.6. LISTADOS ASOCIADOS AL PROGRAMA MULTIMODULO EJEMPLO A continuación se muestran algunos de los listados que se generaron al compilar y linkeditar el programa multimódulo.


4.9.6.1. Salida del Linkeditor Start Stop Length Name Class 00000H 000D8H 000D9H _TEXT CODE 16bit

at offset 00000H 0007AH bytes from CODFNTE.obj (CODFNTE.ASM) at offset 0007AH 00012H bytes from RESTAP23.obj (RESTAP23.ASM) at offset 0008CH 00003H bytes from STALDSBX.obj (STALDSBX.ASM) at offset 00090H 00022H bytes from STP1P2P3.obj (STP1P2P3.ASM) at offset 000B2H 00023H bytes from STSECCAR.obj (STSECCAR.ASM) at offset 000D6H 00003H bytes from SUMAAYB.obj (SUMAAYB.ASM)

000DAH 001DDH 00104H _DATA DATA 16bit at offset 00000H 00104H bytes from CODFNTE.obj (CODFNTE.ASM)

001E0H 005DFH 00400H STACK STACK 16bit at offset 00000H 00400H bytes from CODFNTE.obj (CODFNTE.ASM)

Origin Group 000D:0 DGROUP

Address Publics by Name

0000:0000 @Startup 0000:0090 AlamcP1EnP2_P3 0000:008C AlmacALEnDS_BX 0000:00B2 AlmacSecCaract 000D:010D ARROBA 000D:010C ASTER 0000:002C COLOCA_ASTER 000D:010B LONGSECRESULT 000D:000A N1 000D:000B N2 0000:007A RestaP3deP2 0000:0037 SECCAR 000D:000C SECRESULT 0000:00D6 SumaRegAyB

Address Publics by Value

0000:0000 @Startup 0000:002C COLOCA_ASTER 0000:0037 SECCAR 0000:007A RestaP3deP2 0000:008C AlmacALEnDS_BX 0000:0090 AlamcP1EnP2_P3 0000:00B2 AlmacSecCaract 0000:00D6 SumaRegAyB 000D:000A N1 000D:000B N2 000D:000C SECRESULT 000D:010B LONGSECRESULT 000D:010C ASTER


000D:010D ARROBA

Program entry point at 0000:0000

4.9.6.2. Salida del ASS. Pr ograma Pr incipal Microsoft (R) Macro Assembler Version 6.11 CODFNTE.ASM Page 1 1

; Programa ejemplo mostrando el pasaje de parametros ; con directivas de segmento simplificadas. Include declara.txt

C externdef SumaRegAyB:near,AlmacALEnDS_BX:near,AlmacSecCaract:near C externdef RestaP3deP2:near,AlamcP1EnP2_P3:near C

.186

.MODEL small, syscall

.STACK

0000 .DATA

0000 19 N1 BYTE 25 0001 0F N2 BYTE 15 = 'GIANDOMENICO ENRIQUE',0 SECDADA EQU 'GIANDOMENICO ENRIQUE',0 0002 00FF [ SECRESULT BYTE 255 DUP (?)

00 ]

0101 00 LONGSECRESULT BYTE ? 0102 2A ASTER BYTE '*' 0103 40 ARROBA BYTE '@'

0000 .CODE .STARTUP

0000 *@Startup: 0000 B8 R * mov ax, DGROUP 0003 8E D8 * mov ds, ax 0005 8C D3 * mov bx, ss 0007 2B D8 * sub bx, ax 0009 C1 E3 04 * shl bx, 004h 000C 8E D0 * mov ss, ax 000E 03 E3 * add sp, bx

;Calcula la suma de N1 y N2 0010 33 C0 XOR AX,AX 0012 33 DB XOR BX,BX 0014 A0 0000 R MOV AL,N1 0017 8A 1E 0001 R MOV BL,N2 001B E8 0000 E CALL SumaRegAyB

; 001E 8B C8 MOV CX,AX ; CX cant de bytes a transferir 0020 33 C0 XOR AX,AX 0022 A0 0102 R MOV AL,ASTER ; AL contiene caracter a transferir 0025 BB 0002 R MOV BX,OFFSET SECRESULT ; BX desplazamiento variable receptora 0028 8B D3 MOV DX,BX


002A 03 D1 ADD DX,CX ; DX desplazamiento nueva variable receptora ; loop que coloca la cantidad de caracteres requeridos en la variable receptora

002C COLOCA_ASTER: 002C E8 0000 E CALL AlmacALEnDS_BX 002F 43 INC BX 0030 E2 FA LOOP COLOCA_ASTER

; coloca la secuencia de caracteres a continuacion 0032 8B DA MOV BX,DX 0034 E8 0000 E CALL AlmacSecCaract 0037 47 49 41 4E 44 4F SECCAR BYTE SECDADA

4D 45 4E 49 43 4F 20 45 4E 52 49 51 55 45 00

; 004C 03 D3 ADD DX,BX ;DX desplazamiento nueva variable receptora

; calcula N1 menos N2 004E 50 PUSH AX ;reserva lugar para el resultado 004F A0 0000 R MOV AL,N1 0052 50 PUSH AX 0053 A0 0001 R MOV AL,N2 0056 50 PUSH AX 0057 E8 0000 E CALL RestaP3deP2

005A 5B POP BX 005B 8B C3 MOV AX,BX 005D C1 E0 08 SHL AX,8 0060 A0 0103 R MOV AL,ARROBA 0063 50 PUSH AX 0064 B8 R MOV AX, SEG DGROUP 0067 50 PUSH AX 0068 52 PUSH DX 0069 03 D3 ADD DX,BX

; coloca la cantidad de caracteres requeridos en la variable receptora 006B E8 0000 E CALL AlamcP1EnP2_P3

;coloca en la variable 'LongSecResult' la long de la secuencia generada 006E 81 EA 0002 R SUB DX,OFFSET SECRESULT 0072 88 16 0101 R MOV LONGSECRESULT,DL

;termina bajo dos .EXIT

0076 B4 4C * mov ah, 04Ch 0078 CD 21 * int 021h

END _Microsoft (R) Macro Assembler Version 6.11 04/04/99 18:49:35 CODFNTE.ASM Symbols 2 1 Segments and Groups: N a m e Size Length Align Combine Class

DGROUP . . . . . . . . . . . . . GROUP _DATA . . . . . . . . . . . . . 16 Bit 0104 Word Public 'DATA' STACK . . . . . . . . . . . . . 16 Bit 0400 Para Stack 'STACK' _TEXT . . . . . . . . . . . . . 16 Bit 007A Word Public 'CODE' Symbols:



@CodeSize . . . . . . . . . . . Number 0000h @DataSize . . . . . . . . . . . Number 0000h @Interface . . . . . . . . . . . Number 0002h @Model . . . . . . . . . . . . . Number 0002h @Startup . . . . . . . . . . . . L Near 0000 _TEXT @code . . . . . . . . . . . . . Text _TEXT @data . . . . . . . . . . . . . Text DGROUP @fardata? . . . . . . . . . . . Text FAR_BSS @fardata . . . . . . . . . . . . Text FAR_DATA @stack . . . . . . . . . . . . . Text DGROUP ARROBA . . . . . . . . . . . . . Byte 0103 _DATA ASTER . . . . . . . . . . . . . Byte 0102 _DATA AlamcP1EnP2_P3 . . . . . . . . . L Near 0000 External AlmacALEnDS_BX . . . . . . . . . L Near 0000 External AlmacSecCaract . . . . . . . . . L Near 0000 External COLOCA_ASTER . . . . . . . . . . L Near 002C _TEXT LONGSECRESULT . . . . . . . . . Byte 0101 _DATA N1 . . . . . . . . . . . . . . . Byte 0000 _DATA N2 . . . . . . . . . . . . . . . Byte 0001 _DATA RestaP3deP2 . . . . . . . . . . L Near 0000 External SECCAR . . . . . . . . . . . . . Byte 0037 _TEXT SECDADA . . . . . . . . . . . . Text 'GIANDOMENICO ENRIQUE',0 SECRESULT . . . . . . . . . . . Byte 0002 _DATA SumaRegAyB . . . . . . . . . . . L Near 0000 External

0 Warnings 0 Errors

4.9.6.3. Salida del ASS. Modulo de uno de los Procedimientos Microsoft (R) Macro Assembler Version 6.11 SUMAAYB.ASM Page 1 1

.MODEL SMALL,syscall 0000 .CODE

Include declara.txt C externdef SumaRegAyB:near,AlmacALEnDS_BX:near,AlmacSecCaract:near C externdef RestaP3deP2:near,AlamcP1EnP2_P3:near C ;PUBLIC SumaRegAyB

0000 SumaRegAyB PROC NEAR 0000 03 C3 ADD AX,BX 0002 C3 RET 0003 SumaRegAyB ENDP

END _Microsoft (R) Macro Assembler Version 6.11 SUMAAYB.ASM Symbols 2 1 Segments and Groups: N a m e Size Length Align Combine Class

DGROUP . . . . . . . . . . . . . GROUP _DATA . . . . . . . . . . . . . 16 Bit 0000 Word Public 'DATA' _TEXT . . . . . . . . . . . . . 16 Bit 0003 Word Public 'CODE' Procedures, parameters and locals: N a m e Type Value Attr


SumaRegAyB . . . . . . . . . . . P Near 0000 _TEXT Length= 0003 Public SYSCALL Symbols:


@CodeSize . . . . . . . . . . . Number 0000h @DataSize . . . . . . . . . . . Number 0000h @Interface . . . . . . . . . . . Number 0002h @Model . . . . . . . . . . . . . Number 0002h @code . . . . . . . . . . . . . Text _TEXT @data . . . . . . . . . . . . . Text DGROUP @fardata? . . . . . . . . . . . Text FAR_BSS @fardata . . . . . . . . . . . . Text FAR_DATA @stack . . . . . . . . . . . . . Text DGROUP AlamcP1EnP2_P3 . . . . . . . . . L Near 0000 _TEXT External SYSCALL AlmacALEnDS_BX . . . . . . . . . L Near 0000 _TEXT External SYSCALL AlmacSecCaract . . . . . . . . . L Near 0000 _TEXT External SYSCALL RestaP3deP2 . . . . . . . . . . L Near 0000 _TEXT External SYSCALL

0 Warnings 0 Errors


5. EJERCICIOS 1) Modifique el modelo dado en el punto Procedimientos para el pasaje de parametros mediante el

stack considerando un procedimiento lejano en lugar de uno cercano. 2) Escriba las instrucciones que permitan definir las siguientes variables:

Nonbre de la variable Cantidad de bits Valor inicial VAR1 8 SIN VALOR INICIAL VAR2 8 CARÁCTER ‘A’ VAR3 8 CARÁCTER ‘a’ VAR4 8 235d VAR5 16 12.534d VAR6 16 12d EMPAQUETADO VAR7 32 12d DESEMPAQUETADO VAR8 80 123.455Dd EMPAQUET. VAR9 80 23.456d DESEMPAQUET. VAR10 64 1,345d VAR11 32 123,80d

1) ¿Cuáles son los registros que el DOS se encarga de inicializar automaticameente, y con que valores?

2) ¿Qué registros son inicializados en el setup de la maquina automaticamente y con que valores? 3) Si en un programa dos segmentos tienen el mismo nombre, siempre serán combinados en uno

solo en el .EXE?. Justifique su respuesta. 4) ¿Qué significado tiene la letra R que suele aparecer al lado del codigo de maquina de algunas

instrucciones en el listado .lst que genera el ASS. 5) ¿Cómo sabe la CPU si en una instrucción determinada no debe usarse el registro de segmento

que le correspondería por default? 6) Un procesador 80186 tiene conectado un dispositivo con dos registros (R0 y R1), de 16 bits

cada uno, de forma tal que se accede a R0 en las direccion 00C0h y a R1 en 00C2h del espacio de entrada/salida. Escribir un programa que lea el registro R0, lo interprete como cuatro numeros BCD de cuatro bits cada uno y grabe en R1 el número binario equivalente. Si alguno de los conjuntos de cuatro bits de R0 no resultara un digito BCD válido se debe grabar en R1 0FFFFh.

departamento de sistemas e informática - escribiendo … · 2016-09-26 · microprocesadores y...

Documents