INSTITUTO TECNOLÓGICO SUPERIOR DE IRAPUATO

Carrera: Sistemas Computacionales

Grupo: “A”
Materia: Lenguajes de Interfaz.

Tema: Introducción al lenguaje ensamblador.

Número y Nombre de la Práctica: 2. Arreglos y acceso a memoria.

Integrantes del Equipo 4:
- Aguilar Martínez Jozef Uriel.
- Fuerte Ramírez Luz Vanessa.
- Gallardo Tovar Luis Eduardo.
- Montoya Muñoz David Sebastián.
- Rojas Ledesma José Eduardo.
- Vargas Granados José Manuel.

IRAPUATO, GTO. 1 de febrero de 2023

Objetivos:
• Desarrollar un conocimiento más amplio sobre la elaboración de programas por medio
de código en un lenguaje ensamblador.
• Simular y resolver problemas por medio del uso de arreglos, ciclos e instrucciones dentro
de un código en lenguaje ensamblador, esto por medio de variables tipo palabra, además
de analizar el resultado que se obtendrá al terminar el proceso.

Lista De Material, Equipo Y Software Empleado:

• Laptop LENOVO.
• Emulador del chip microprocesador 8086 (emu8086).

Sustento Teórico:
Registros de segmento
Los registros de segmento son de 16 bits (como se ha dicho anteriormente) y contienen el valor
de segmento.
CS (segmento de código) contiene el valor de segmento donde se encuentra el código. Actúa
en conjunción con el registro IP para obtener la dirección de memoria que contiene la próxima
instrucción. Este registro es modificado por las instrucciones de saltos lejanos.
DS (segmento de datos) contiene el segmento donde están los datos.
ES (segmento extra de datos) es usado para acceder a otro segmento que contiene más
datos.
SS (segmento de pila) contiene el valor del segmento donde está la pila. Se usa juntamente
con el registro SP para obtener la dirección donde se encuentra el último valor almacenado en
la pila por el procesador.

Registro de índice
Estos registros son usados como índices por algunas instrucciones. También pueden ser
usados como operandos (excepto el registro IP).
IP (índice de programa) almacena el desplazamiento dentro del segmento de código. Este
registro junto al registro CS apunta a la dirección de la próxima instrucción. No puede ser usado
como operando en operaciones aritmético/lógicos.
SI (índice de origen) almacena el desplazamiento del operando de origen en memoria en
algunos tipos de operaciones (operaciones con operandos en memoria).
DI (índice de destino) almacena el desplazamiento del operando de destino en memoria en
algunos tipos de operaciones (operaciones con operandos en memoria).
SP (índice de pila) almacena el desplazamiento dentro del segmento depila, y apunta al último
elemento introducido en la pila. Se usa juntamente con el registro SS.
BP (índice de base) se usa para almacenar desplazamiento en los distintos segmentos. Por
defecto es el segmento de la pila.

Registros de banderas.
De los 16 bits del registro de banderas, nueve son comunes a toda la familia de procesadores
8086, y sirven para indicar el estado actual de la máquina y el resultado del procesamiento.
Muchas instrucciones que piden comparaciones y aritmética cambian el estado de las banderas,
algunas de cuyas instrucciones pueden realizar pruebas para determinar la acción subsecuente.
En resumen, los bits de las banderas comunes son como sigue:
OF (overflow, desbordamiento). Indica desbordamiento de un bit de orden alto (más a la
izquierda) después de una operación aritmética.
DF (dirección). Designa la dirección hacia la izquierda o hacia la derecha para mover o
comparar cadenas de caracteres.
IF (interrupción). Indica que una interrupción externa, como la entrada desde el teclado, sea
procesada o ignorada.
TF (trampa). Permite la operación del procesador en modo de un paso. Los programas
depuradores, como DEBUG, activan esta bandera de manera que usted pueda avanzar en la
ejecución de una sola instrucción a un tiempo, para examinar el efecto de esa instrucción sobre
los registros y la memoria.
SF (signo). Contiene el signo resultante de una operación aritmética (0 = positivo y 1 =
negativo).
ZF (cero). Indica el resultado de una operación aritmética o de comparación (0 = resultado
diferente de cero y 1 = resultado igual a cero).
AF (acarreo auxiliar). Contiene un acarreo externo del bit 3 en un dato de ocho bits, para
aritmética especializada.
PF (paridad). Indica paridad par o impar de una operación en datos de ocho bits de bajo orden
(más a la derecha).
CF (acarreo). Contiene el acarreo de orden más alto (más a la izquierda) después de una
operación aritmética; también lleva el contenido del último bit en una operación de corrimiento
o de rotación.
Las banderas en el registro estan en las siguientes posiciones:
Las banderas más importantes para la programación en ensamblador son O, S, Z y C, para
operaciones de comparación y aritméticas, y D para operaciones de cadenas de caracteres.

Arreglos
¿Qué es un arreglo?
Los arreglos son una colección de variables del mismo tipo y se referencia usando un nombre
común. Sus principales características son:
1. Consta de posiciones de memoria consecutivas.
2. La dirección más baja corresponde al primer elemento y la más alta al último.
3. Un arreglo puede tener una o varias dimensiones.
4. Un arreglo es una colección finita, homogénea y ordenada de números.

Declaración de Arreglos.
Para definir un arreglo en el segmento data, use las directivas normales:
• DB (BYTES)
• DW (PALABRAS)
• DD (PALABRAS DOBLES)
• DQ (PALABRAS CUÁDRUPLES)

Sintaxis.
La sintaxis de estas directivas, en el caso de la declaración de arreglos son:
[nomArreg] db exp [, exp]…
[nomArreg] dw exp [, exp]…
[nomArreg] ds exp [, exp]…
[nomArreg] dq exp [, exp]…
nomArreg = nombre del arreglo.
Exp = son expresiones constantes.
Ejemplo:
Bdatos db 0,1,2,3,4
; Arreglo de cinco variables de tipo byte
; inicializadas a los valores 0,1,2,3 y 4
Declaración de arreglos usando el operando dup.
En la declaración de arreglos se puede visualizar el operando dup para inicializar el arreglo a
valores duplicados. La sintaxis del operando dup es la siguiente:
cnta dup (exp[, exp]…)
cnta = define el número de veces que el dato definido por exp será repetido.
dup = Aparece después de una directiva para declarar variables db, dw, etc.
**Se puede anidar un operando dub dentro de exp de otro dup, hasta 17 niveles.
Ejemplo:
Bdtos db 5 dup(0)
; Arreglo de cinco variables de tipo byte
; inicializadas en 0.
Acceso a los elementos de un arreglo.
• Para acceder a un elemento del arreglo, se debe calcular su dirección.
• El primer elemento de un arreglo tiene un índice de cero.
• Si el arreglo es de bytes el índice y el desplazamiento son iguales.

Ejemplo:
bdtosx db 10 dup(0)
mov [bdtosx], 5 ;bdtosx[0] = 5
mov [bdtosx + 2], 6 ;bdtosx[2] = 6
Las instrucciones anteriores almacenan el valor de 5 en el primer elemento, índice 0, y
el valot de 6 en el terer elemento, índice 2, de bdtosx.

INSTRUCCIONES.
SALTOS
JNE: Su propósito es realizar un salto hacia una etiqueta especificada si la comparación de dos
operandos es diferente
Su sintaxis es la siguiente:

JNE Destino
Salta hasta la etiqueta destino si despues de la comparación los operandos resultan ser
diferentes
Ejemplo:
CMP op1, op2 ; se realiza la comparación de los operandos op1 y op2
JNE Etiqueta ; si los operandos son diferentes desde aquí saltará
mov ax,5 ; caso contrario vendrá por aquí
mov bx,8 ; por aquí
add ax,bx ; y por aquí
Etiqueta: ; hasta aquí
mov dx,1 ; sí se ejecutará

JNZ: Su propósito es realizar un salto hacia una etiqueta especificada si el resultado de una
resta aritmética es diferente de cero.
Su sintaxis es la siguiente:

JNZ Destino

Salta hasta la etiqueta destino si despues de una resta aritmética el resultado es diferente de
cero
Ejemplo:
SUB op1,op2 ; se realiza la operación aritmética resta entre los operandos op1 y op2
JNZ Etiqueta ; si el resultado es diferente de cero, entonces desde aquí .
;saltará
mov ax,5 ; caso contrario vendrá por aquí
mov bx,8 ; por aquí
add ax,bx ; y por aquí
Etiqueta: ; hasta aquí
mov dx,1 ; sí se ejecutará
COMPARADOR.
CMP: Su propósito es comparar dos operandos.
Su sintaxis es la siguiente:

CMP operando1,operando2

Si los operandos son iguales pone el registro bandera (ZF = 0), si los operandos son diferentes
pone a ZF en uno (ZF = 1)
Ejemplo:
CMP ax,cx ; la operación que realiza es: Si(ax==bx) entonces ZF=0
 ;si_no ZF=1;

INCREMENTO Y DECREMENTO
En ensamblador existen dos instrucciones que cumplen con el propósito de aumentar o reducir
el valor contenido dentro de un registro.
INC: Su propósito es ir incrementando en uno el valor contenido dentro del registro que se le
dé como parámetro
Su sintaxis es la siguiente:

INC AL ;Incrementa en 1 el valor del registro AL.

DEC: Su propósito es ir decrementando en uno el valor contenido dentro del registro que se le
dé como parámetro
Su sintaxis es la siguiente:

DEC AL ;Reduce en 1 el valor del registro AL.

Desarrollo:
Realizar un programa en lenguaje ensamblador cuyo objetivo será restar los elementos de 2
espacios de memoria y el resultado debe almacenarse en un tercer segmento de memoria.
La resta se realizará con los extremos de los segmentos 1 y 2, es decir S[0] - S[10], S[1] - S[9]…
Cada segmento es de 10 elementos.
1) Para el cuerpo del programa denotamos 3 segmentos de nombre: “SEGMENTO 1, (2),
(3)”.
Determinamos el segmento 1 para el conjunto de números que cumplirán el papel de
Minuendo al correr el programa. Este es un arreglo de 10 elementos cuyos valores en
decimal han sido elegidos arbitrariamente:
10, 9, 8, 7, 6, 11, 8, 15, 11, 15
El segundo segmento corresponde a la parte de sustraendo que serán restados a los
números del segmento 1. Al igual que con el primer conjunto, son valores al azar:
3, 9, 11, 7, 6, 2, 2, 3, 2, 13
 El tercer segmento definido corresponde al lugar donde se van a almacenar cada una de
las restas que se realicen entre los segmentos anteriores, dando un total de 10 espacios
de memoria (instrucción DUP) de tipo palabra e identificados con el número 0.

2) En la siguiente captura se muestra el código completo del programa realizado, es

importante presentarlo al inicio debido a que en pasos posteriores hemos de explicar
línea a línea el funcionamiento del este.

Este código de programa se compone de las siguientes partes:

Asignación de direcciones, indicación de índices y ciclo de programa.

3) Para fines de explicación, se procede a la ejecución del programa. La primera línea

únicamente permite inicializar un índice en CX en 0. En seguida se procede a copiar la
dirección del comienzo del segmento 1, en un registro índice fuente, llamado SI.
4) Al entrar a la sección de “Variables” dentro de la ventana
del programa en ejecución, podemos observar el registro
SI, cuyo valor luego de la segunda línea, se convierte en 0,
ya que esa dirección es donde comienza a guardar los
segmentos el programa.

5) En seguida de que el programa termina de asignar los espacios correspondientes al

primer segmento, y conforme al tipo de variables que son (Byte – 8 bits, Word – 16 bits),
el programa almacena el siguiente segmento (2). Entonces en el código de programa,
copiamos la dirección de inicio del SEGMENTO 2 a un registro índice llamado BP.

En las variables observamos que a BP se le ha asignado un valor de 20 (decimal), debido

a que el primer segmento terminó de almacenarse en el byte 19 por su tamaño de 20
bytes, comenzando desde la posición 0.
 6) Finalizando con la asignación de direcciones, utilizamos un
cuarto registro, de nombre: DI, para almacenar la dirección del
SEGMENTO 3 que contendrá los resultados de la operación
entre el SEGMENTO 1 y 2.

Observemos que el valor de DI después de esta instrucción es

40. Porque el SEGMENTO 2 termina en el Byte con dirección
39.

7) Lo siguiente será utilizar el registro BP para almacenar

la dirección del elemento del SEGMENTO 2 que
corresponde a la última posición, como la dirección
inicial debe desplazarse 18 posiciones para llegar a
este, al registro BP que almacenaba esta dirección se
le suma un desplazamiento.

Luego se copia al registro BX que almacena el

contenido de la dirección a la que apunta BP.
8) Por consiguiente, vamos a indicar que el registro BP sea
el índice para los elementos del SEGMENTO 2, entonces
con ayuda de la instrucción: MOV, copiamos el 38 que es
el valor de la dirección donde se encuentra el ultimo valor
del SEGMENTO 2.

Al igual que con las instrucciones anteriores, verificamos,

con la ventana de Variables, observando el valor de 38.

9) Ahora daremos comienzo a un ciclo que se repetirá hasta que

los 10 espacios que hemos asignado en el SEGMENTO 3 se
hayan llenado, con los valores que se descubrirán en los
siguientes pasos.
Como primer punto del ciclo, indicamos el movimiento de lo que
apunta SI (índice de SEGMENTO 1) a un registro de propósito
general, como AX.
EL valor de la dirección a la que apunta SI (Primera posición del
SEGMENTO 1) es 10, y verificamos en las Variables para AX.
10) Recordemos que BX se utilizó primero para almacenar
la dirección a la que apuntó BP, que fue el último valor
del SEGMENTO 2. Luego, con ayuda de la instrucción:
SUB, se realiza la resta de los valores que están
contenidos en AX y BX, que en cuyo caso son: Primer
elemento del SEGMENTO 1 – último elemento del
SEGMENTO 2 ó 10 – 13.
Revisamos que el resultado sea almacenado en AX
nuevamente, y que sea -3.

11) La siguiente línea será para que el resultado de la operación

que se almacenó en AX, sea colocado en la dirección a la que
apunta DI, que recordando, es la primera posición del
SEGMENTO 3.
 12) Ahora se incrementa a la siguiente palabra en el índice SI (del
primer segmento), así continuamos con la dirección del siguiente
valor. Nos apoyamos de la instrucción Suma o ADD y el número
2 siendo sumado al registro.

13) Como siguiente paso, decrementamos 2 bytes a BP

(índice del SEGMENTO 2) para indicar que se va a
desplazar a la palabra anterior contenida en este
segmento.
 14) Ahora se suma nuevamente 2, pero al registro DI
encargado de las posiciones de palabras en el SEGMENTO
3. Es entonces que se mueve a la segunda posición en este
segmento.

15) Lo siguiente en el ciclo será copiar a lo que apunta la

dirección almacenada en el registro BP, que es ahora la
dirección de la penúltima palabra en el SEGMENTO 2,
al registro BX, para dar lugar nuevamente a ser
sustraendo en la resta con el minuendo que se
encuentra en AX, que ahora tendrá el valor de la palabra
2 en el SEGMENTO 1 (por la suma de 2 posiciones).
16) Ahora queda por los últimos pasos incrementar el valor de nuestro registro CX que
funciona como un contador de nuestros ciclos, esto se logra con la instrucción INC, como
le dimos un valor de 0, al incrementarlo podemos observar que el valor se suma en 1,
Despues de ese incremento se busca comparar con la instrucción CMP, lo que estamos
comparando es si CX a llegado a un valor de 10, y despues con la última instrucción JNE
hacemos un salto hacia la etiqueta REPITE si el valor del contador NO es igual al valor
de 10. Como se puede comprobar en la imagen, el valor del contador (CX) es de 1, por
lo tanto, no es igual a 10, de esta manera sabemos que se dará un salto hacia la etiqueta
seleccionada, y asi será hasta cumplir con que CX sea igual a 10.
 17) Como se ha previsto que el programa detenga el ciclo
Repite, cuando 10 sea igual al valor del registro CX que
se ha ido incrementando en cada vuelta del ciclo.
Entonces, al llenar los espacios de memoria que
asignamos al SEGMENTO 3, que fueron 10, el
programa habrá terminado de realizar las operaciones
encargadas en el código de programa.
Comprobamos con ayuda de la ventana de variables,
referente a los segmentos, y obtenemos que efectivamente,
todos los campos del SEGMENTO 3 se han llenado con su
respectivo resultado de resta entre el primer elemento del
SEGMENTO 1 menos el último elemento del SEGMENTO 2.

Conclusión:
Para concluir, en esta práctica desarrollamos más conocimiento sobre los métodos de
direccionamiento para el manejo del acceso a la memoria y poder realizar operaciones por
medio de nuevas instrucciones que permiten hacer uso de ciclos, dentro de los cuales se
ejecutan ciertos direccionamientos, incrementos y decrementos dentro de un intervalo o
determinado número de iteraciones, en este caso con la finalidad de realizar restas de números
guardados en arreglos y almacenarlos en otro. De igual manera, se pudo reforzar el
entendimiento en cuanto a la forma que se guardan los valores en memoria al principio de la
ejecución, ya que la lógica de direccionamiento con palabras depende de cuántos espacios en
memoria (bytes) ocupa cada valor, así como de las posiciones de cada uno de ellos.
Referencias:
❖ Peter Abel, (1966). Lenguaje Ensamblador y programación para PC IBM y Compatibles,
3ª. Edición, Pearson Prentice Hall.
❖ Kip R. Irvine, (2008). Lenguaje ensamblador para computadoras basadas en Intel,
Pearson Prentice Hall, 5ª edición.
❖ Christopher L. Morgan & Mitchell Waite. Introducción al Microprocesador 8086/8088 (16
bits). Ed. Mc Graw Hill.