Universidad de El Salvador

Facultad de Ingeniería y Arquitectura

Escuela de Ingeniería Eléctrica

Sistemas Digitales Programables 1

Laboratorio # 1
Catedrático: Ing. Ricardo Cortéz

Integrantes:
- Siguenza Diaz, Karen Marcela SD15001
- Sermeño Linares, Jonathan Josue SL15001

Miercoles 7 de Marzo del 2018

INTRODUCCIÓN
El presente trabajo, contiene una breve información sobre lo que son los primeros
microprocesadores, el Intel 8086 y el Intel 8088, los cuales son los primeros miembros de la
arquitectura x86, mostrando también los distintos registros de uso general del 8086/8088 que
existen.

A través del trabajo, se presentará la solución de diferentes asignaciones así como también
la explicación de un código paso por paso, con el cual se pretende conocer su uso y sus
limitaciones del Software EMU8086 y a la vez se tomará como guía para la resolución de los
demás códigos mostrando con ayuda de capturas el resultado que se da al compilarlo.

Al pasar a las asignaciones se puede observar que la complejidad de los programas aumenta
por lo que es necesario leer el texto de clase para poder aplicar instrucciones que faciliten el
desarrollo. Por último se presenta una serie de instrucciones con su definición y para mayor
compresión, su respectivo ejemplo.
OBJETIVOS:

 Objetivo General:
Comprender y conocer el funcionamiento y conceptos básicos del software
EMU8086.

 Objetivos Específicos:
i. Identificar las distintas instrucciones y banderas así como sus usos.

ii. Aplicar lo conceptos aprendidos en clases tales como MOV, ORG, así
como también los registros comunes AX, BX, CX, DX entre otras
instrucciones.
MARCO TEORICO
El Intel 8086 y el Intel 8088 son los primeros microprocesadores de 16 bits diseñados por
Intel. Son los primeros miembros de la arquitectura x86. Fue lanzado al mercado en 1978 y
el 8088 en 1979. El 8086 y 8088 ejecutan el mismo número de instrucciones. Comparándolos
internamente son idénticos a excepción del 8086 que posee una cola de 6 bytes para
instrucciones y el 8088 solo posee 4. Exteriormente la diferencia es que el 8086 tiene un bus
de 16 bits y el 8088 su bus es de 8 bits, por lo tanto, el 8086 es más rápido, aunque el 8088
permite la fabricación de sistemas más económicos. En la primera computadora personal de
IBM fue utilizado el microprocesador 8088, la IBM PC.

La introducción del microprocesador 8086 en 1978 sentó las bases para un estándar de la
industria mundial que se convertiría en la base de la arquitectura de cada computadora
fabricada hoy en día, independientemente del sistema operativo. Este chip tiene un conjunto
de características que llevaron a que se convierta en el chip en el que casi todos los
procesadores modernos están basados.
16-Bit de transferencia de datos: El 8086 fue uno de los primeros chips en utilizar un bus
de 16-bit de transferencia de datos, por lo que es un software mucho más rápido y fácil de
usar que los antiguos de 8 bits. Esto permitió que el procesador transfiriera datos más rápido,
aumentando enormemente la velocidad e incrementando las capacidades posibles del
software. También permitió que este dispositivo hiciera frente a mayores cantidades de
memoria.
Todo procesador, grande o pequeño, desde el de una calculadora hasta el de un
supercomputador, ya sea de propósito general o específico, posee un lenguaje único que es
capaz de reconocer y ejecutar. El lenguaje de máquina está compuesto por una serie de
instrucciones, que son las únicas que pueden ser reconocidas y ejecutadas por el
microprocesador. Este lenguaje es un conjunto de números que representan las operaciones
que realiza el microprocesador a través de su circuitería interna. Estas instrucciones están
grabadas o "alambradas" en el hardware y no pueden ser cambiadas. El nivel más bajo al que
podemos aspirar a llegar en el control de un microprocesador es precisamente el del lenguaje
de máquina.
La dirección de inicio nos indica en qué localidad de memoria comienza un programa, y en
consecuencia que datos deberemos considerar como instrucciones. El estado del
microprocesador nos permite saber cuándo éste espera una instrucción y cuándo éste espera
un dato.
Existe una correspondencia 1 a 1 entre las instrucciones del lenguaje de máquina y las del
lenguaje ensamblador. Cada uno de los valores numéricos del lenguaje de máquina tiene una
representación simbólica de 3 a 5 letras como instrucción del lenguaje ensamblador.
Adicionalmente, este lenguaje proporciona un conjunto de pseudo-operaciones (también
conocidas como directivas del ensamblador) que sirven para definir datos, rutinas y todo tipo
de información para que el programa ejecutable sea creado de determinada forma y en
determinado lugar.
El software EMU8086 es sumamente útil para aprender lenguaje ensamblador (Assembler),
ya que incorpora un editor avanzado, un ensamblador, una PC virtual y tutoriales paso a paso.
También incluye dispositivos virtuales como impresoras, displays de LEDs, termómetros,
etc.
Registros de uso general del 8086/8088:

Tienen 16 bits cada uno y son ocho:

AX = Registro acumulador, dividido en AH y AL (8 bits cada uno). Usándolo se produce

(en general) una instrucción que ocupa un byte menos que si se utilizaran otros registros de
uso general. Su parte más baja, AL, también tiene esta propiedad. El último registro
mencionado es el equivalente al acumulador de los procesadores anteriores (8080 y 8085).
Además, hay instrucciones como DAA; DAS; AAA; AAS; AAM; AAD; LAHF; SAHF;
CBW; IN y OUT que trabajan con AX o con uno de sus dos bytes (AH o AL). También se
utiliza este registro (junto con DX a veces) en multiplicaciones y divisiones.

BX = Registro base, dividido en BH y BL. Es el registro base de propósito similar (se usa
para direccionamiento indirecto) y es una versión más potente del par de registros HL de los
procesadores anteriores.

CX = Registro contador, dividido en CH y CL. Se utiliza como contador en bucles

(instrucción LOOP), en operaciones con cadenas (usando el prefijo REP) y en
desplazamientos y rotaciones (usando el registro CL en los dos últimos casos).

DX = Registro de datos, dividido en DH y DL. Se utiliza junto con el registro AX en

multiplicaciones y divisiones, en la instrucción CWD y en IN y OUT para direccionamiento
indirecto de puertos (el registro DX indica el número de puerto de entrada/salida).

SP = Puntero de pila (no se puede subdividir). Aunque es un registro de uso general, debe
utilizarse sólo como puntero de pila, la cual sirve para almacenar las direcciones de retorno
de subrutinas y los datos temporarios (mediante las instrucciones PUSH y POP). Al
introducir (push) un valor en la pila a este registro 7 se le resta dos, mientras que al extraer
(pop) un valor de la pila este a registro se le suma dos.

BP = Puntero base (no se puede subdividir). Generalmente se utiliza para realizar

direccionamiento indirecto dentro de la pila.

SI = Puntero índice (no se puede subdividir). Sirve como puntero fuente para las operaciones
con cadenas. También sirve para realizar direccionamiento indirecto.

DI = Puntero destino (no se puede subdividir). Sirve como puntero destino para las
operaciones con cadenas. También sirve para realizar direccionamiento indirecto.
Desarrollo de la practica

Diseñar el programa para sumar dos números que se encuentran a partir de la dirección
1000H dejando el resultado en 1002H.

1.
2. org 1000h
3. mov [1000h],2
4. mov [1001h],3
5. add al,[1000h]
6. add al,[1001h]
7. mov [1002h],al
8. ret
Se inicia con direccionar el inicio del programa a 1000h, luego se ingresan los valores a
sumar en las direcciones 1000h y 1001h. Realiza la suma en el registro al y finalmente lo
direcciona a 1002h.
Asignacion 1
Ejecute en el EMU8086 el programa que se encuentra en el anexo, y explique cada uno de
los pasos que lo conforman, colocando cada una de las ventanas que se alteran en el
EMU8086.

1. ; This example prints out

2. ; "HELLO WORLD!"
3. ; by writing directly to
4. ; Video Memory.
5. #make_BIN# ; Directiva que explica el archivo a generar por el
compilador,
6. ; en este caso del
tipo BIN donde se pueden definir valores de
7. ; todos los registros,
segmento y offset de memoria cuando se carga.
8.
9. ; set segment register:
10. MOV AX, 0B800h ; Copiar el numero 0B800h al
registro de proposito general AX
11. MOV DS, AX ; Mover el valor de 16 bits
ubicado en AX a DS. El valor 0b800h contiene
12. ; la direccion de
la memoria de video y prepara para escribir directamente
13. ; a ella.
14.
15. ; print "HELLO" using DS
16. ; as segment:
17. MOV [52h], 'H' ; Mueve el caracter ASCII 'H'
a la ubicacion de memoria de video DS:[52h] =
18. ;0B800h + 52h
19. MOV [54h], 'E' ; DS:[54h] = OB800h + 54h
20. MOV [56h], 'L' ; DS:[56h] = OB800h +
56h
21. MOV [58h], 'L' ; DS:[58h] = OB800h + 58h
22. MOV [5Ah], 'O' ; DS:[60h] = OB800h + 5Ah
23.
24. ; print "WORD!" using ES
25. ; as segment (better since
26. ; this way you won't loose
27. ; access to variables declared
28. ; in code segment).
29. ; set segment registers:
30.
31. PUSH CS ; Guardamos el valor de CS al stack
32. POP DS ; Obtenemos el ultimo valor de stack y lo
guardamos en DS.
33. ; Como el ultimo que entro fue CS
entonces DS=CS.
34. ; Esta operacion es util pues de esta
manera DS puede seguir apuntando al
 35. ; segmento de datos mientras CS
apunta a la direccion de video
36.
37. MOV AX, 0B800h ; Movemos el valor de la direccion
de memoria de video OB800h a AX
38. MOV ES, AX ; Guardamos le valor de 16
bits almacenado en AX y lo guardamos en ES
39. MOV ES:[5Eh], 'W' ; Mueve el caracter ASCII 'W' a la
ubicacion de memoria de video
40. ;ES:[5Eh] = 0B800h + 5Eh
41. MOV ES:[60h], 'O' ; DS:[60h] = OB800h + 60h
42. MOV ES:[62h], 'R' ; DS:[62h] = OB800h + 54h
43. MOV ES:[64h], 'L' ; DS:[64h] = OB800h + 54h
44. MOV ES:[66h], 'D' ; DS:[66h] = OB800h + 54h
45. MOV ES:[68h], '!' ; DS:[68h] = OB800h + 54h
46. HLT ; Instrucción HALT
para ordenar al cpu entrar en modo de espera

A travez deñ registro DS y a traves del regitro extra de segmento ES se puede observar la
escritura en la memoria de video. Al utilizar diferentes registros de segmento se puede
direccionar a memoria sin perder acceso a los segmentos direccionados por otros, como DS.

Aquí puede observarse como el programa ya ha establecido el segmento de memoria que

empieza en 0B800h. Este es el área de memoria de video.
Aquí el programa ha comenzado a escribir en el segmento 0B800h y por lo tanto a mostrar
en pantalla los caracteres ASCII.

Asignacion 2
Diseñe un programa el cual solicite el ingreso de 10 caracteres (5 números de un digito y 5
letras, las cuales deben de ser vocales), los números deben ser almacenados en la tabla NUMS
y las vocales en la tabla VCLS, y luego se deben mostrarse en pantalla los elementos de la
tabla NUMS y de la tabla VCLS, en el orden que fueron ingresado.

1. mov cx,10
2. mov ah,01
3. mov di,0
4. mov si,0
5.
6.
7. jmp Start
8. mensaje1 db "Vocales Ingresadas$"
9. mensaje2 db "Numeros ingresados$"
10. vcls db 10 dup (?)
11. nums db 10 dup (?)
12. Start:
13.
14.
15. Insert:
16. int 21h ;Interrupcion
17. cmp al,40h
18. ja vocal
19.
20. mov nums[si],al
21. inc si
22. jmp continuar
23.
24. vocal:
25. mov vcls[di],al ; ingreso de vocales
26. inc di ; Se da un incremento en DI para que no se
sobrepongan los datos
27.
28. continuar:
29. loop Insert
30.
31. mov ah,02
32. mov dl,10
33. int 21h ;Interrupcion
34. int 21h ;Interrupcion
35. mov dl,13
36. int 21h
37. mov ah,09h
38. mov dl, offset mensaje1
39. int 21h ;Interrupcion
40.
41. mov cx,si
42. mov si,0
43.
44. imprimirnums:; Mostrar mumeros en pantalla
45. mov ah, 02
46. mov dl, 10
47. int 21H
48. mov dl, 13
49. int 21h
50. mov ah,02h
51. mov dl, nums[si]
52. int 21h
53. inc si ; Se da un incremento en SI para que no se
sobrepongan los datos
54. loop imprimirnums
55.
56. mov ah, 02
57. mov dl, 10
58. int 21h ;Interrupcion
59. int 21h ;Interrupcion
60. mov dl, 13
61. int 21h ;Interrupcion
62. mov ah, 09h
63. mov dl, offset mensaje2
64. int 21h
65.
66. mov cx,di
67. mov di,0
68.
69. imprimirvcls: ; Mostrar vocales en pantalla
70. mov ah, 02
71. mov dl, 10
 72. int 21h ;Interrupcion
73. mov dl,13
74. int 21h ;Interrupcion
75. mov ah, 02h
76. mov dl, vcls[di]
77. int 21h ;Interrupcion
78. inc di
79. loop imprimirvcls
80.
81. ret

El código solicita al estudiante cinco números y cinco vocales, este código ha sido diseñado
para que se ingresen primero las vocales y después los numeros. Cuando termina de ingresar
los caracteres estos se almacenan en una tabla, NUMS y VCLS, respectivamente.
Asignacion 3
Diseñar un programa que almacene 4 números, 2 en la tabla NUMS1 y 2 en otra tabla
NUMS2. Posteriormente realizar la suma, resta, multiplicación y división. Entre los
elementos de las tablas y los resultados deben de ser almacenados en la tabla RESUL
1. jmp comienzo ; se definen las entradas de los numeros(tablas)
2. palabra1 db "Numeros_1$"
3. palabra2 db "Numeros_2$"
4. palabra3 db " $"
5. palabra4 db "Resulatado$"
6. NUMS1 db 2 dup (?)
7. NUMS2 db 2 dup (?)
8. RESUL db 2 dup (?)
9. comienzo:
10.
11. mov ah,08
12. mov si,0 ;inicializa datos antes de las operaciones
13.
14. int 21h
15. mov NUMS1[si], al
16. int 21h
17. inc si
18. mov NUMS1[si], al
19.
20. mov si,0 ;inicializa datos antes de las operaciones
21. int 21h
22. mov NUMS2[si], al
23. int 21h
24. inc si
25. mov NUMS2[si], al
26.
27. mov si, 0 ;inicializa datos antes de las operaciones
28. mov di, 0
29. mov cx, 2
30.
31. proceso:;se realizan las operaciones aritmeticas con los
registros
32.
33. ;suma
34. mov al, NUMS1[si]
35. mov ah, NUMS2[si]
36. sub ax, 3030h
37. add al, ah ;salto de posicion en la tabla
38. add al, 30h ;salto de posicion en la tabla
39. mov RESUL[di], al
40.
41. ;resta
42. mov al, NUMS1[si]
43. mov ah, NUMS2[si]
44. sub ax, 3030h
45. sub al, ah
46. add al, 30h
47. inc di ;salto de posicion en la tabla
48. mov RESUL[di], al ;guarda el resultado en la tabla
49.
50. ;multiplicacion
51. mov al, NUMS1[si]
52. mov bl, NUMS2[si]
53. sub ax, 3030h
54. sub bl, 30h
55.

mov ah, 0

56. mul bl
57. add al, 30h
58. inc di ;salto de posicion en la tabla
59. mov RESUL[di], al ;guarda el resultado en la tabla
60.
61. ;division
62. mov al, NUMS1[si]
63. mov bl, NUMS2[si]
64. mov ah, 0
65. sub al, 30h
66. sub bl, 30h
67. div bl
68. add al, 30h
69. inc di ;salto de posicion en la tabla
70. mov RESUL[di], al ;guarda el resultado en la tabla
71. inc di
72. inc si
73. loop proceso
74.
75. mov ah, 09h
76. mov dl, offset palabra1
77. int 21h
78. mov ah, 09h
79. mov dl, offset palabra3
80. int 21h
81. mov ah, 09h
82. mov dl, offset palabra2
83. int 21h
84.
85. mov cx, 2
86. mov si, 0 ;inicializa datos antes de las operaciones
87.
88. imprimir_numeros: ;proceso para mostrar resultados en
pantalla
89. mov ah, 02
90. mov dl, 10
91. int 21h
92. mov dl, 13
93. int 21h
94. mov ah, 02h
95. mov dl, NUMS1[si] ;adquiere los datos de las tablas
96. int 21h
97.

mov ah, 09h

98. mov dl, offset palabra3

99. int 21h
100. int 21h
101. mov ah, 02h
102. mov dl, NUMS2[si]
103. int 21h
104. inc si
105. loop imprimir_numeros
106.
107. mov ah, 02
108. mov dl, 10
109. int 21h
110. int 21h
111. mov dl, 13
112. int 21h
113. mov ah, 09h
114. mov dl, offset palabra4
115. int 21h
116.
117. mov si,0 ;inicializa datos antes de las operaciones
118. mov cx,8
119.
120. imprimir:
121. mov ah, 02
122. mov dl, 10
123. int 21h
124. mov dl, 13
125. int 21h
126. mov ah, 06h
127. mov dl, RESUL[si]
128. int 21h
 129. inc si
130. loop imprimir
131.
132. ret

El desarrollo del programa se divide en diferentes partes específicas y necesarias para lograr
los resultados. El primer segmento de codigo es tiene la finalidad de capturar los datos
ingresados, y guardarlos en sus tablas especificadas en el enunciado de la asignación. Luego
se utiliza un segmento de codigo por cada operación aritmética, en ellas se obtiene los datos
de las tablas de números de entrada y se guardan en una sola tabla de resultados con un orden
específico. Finalmente, se realiza la impresión de la tabla de resultados.
Asignacion 4
Diseñe un programa que almacene 5 números en una tabla llamada NUMS, que los compare,
y muestre en pantalla cual es el promedio, y cuál es el número menor.

1. org 100h
2.
3.
4. mov si,0 ;apunta a la primera direccion de la tabla
5. mov cx,5 ;contador de numeros de datos obtenidos
6. MOUSE:
7.
8. mov ah,09h ;peticion para desplegar
9. lea dx,mensaje1
10. int 21h ;llama al DOS
11. ;codigo para leer numero con eco
12. mov ah,01h ;peticion de leer numero, se guarda en AL
13. int 21h
14.
15. cmp al,29h ;
16. jb malo ;
17. cmp al,30h ;Comprueba que el valor sea un digito
18. cmp al,39h ;
19. ja malo ;
20.
21. mov ah,0h
22. sub al,30h ;introduce el valor no el hexa del ascii
23. mov NUMS[si],al ;introduce el num en la tabla NUMS_1
24. inc si
25. loop MOUSE
26. mov ah,09h
27. lea dx,mensaje2
28. int 21h
29.
30. mov si,0
31. mov di,0
32. mov ah,0
33.
34. mov al, NUMS[di]
35. comparador:
36. inc si ;cuando ya se haya comparado los 5 numeros
37. cmp si,5h
38. je print
39. mov bl, NUMS[si] ;
40. cmp al,bl
41. jb menor
42. ja mayor
43. loop comparador
44.
45. menor: ;si el dato es el menor, se guarda
46. mov VAR[0],al ;y se sigue comparando el mismo numero
47. jmp comparador
48.
49. mayor: ;si el dato es el mayor, se intercambian
50. mov bl,NUMS[di] ;para luego regresar y capturar siempre
51. mov al, NUMS[si]
52. jmp comparador
53.
54. ;Imprime resultados
55.
56. print:
57.
58. mov bh,0h ;para evitar errores
59. mov bl,al
60. add bl,30h ;se corrige el valor
61. mov ah,06h
62. mov dl,bl ;se imprime
63. int 21h
64.
65. mov ah,09h
66. lea dx,msgprom ;imprime enunciado msgprom
67. int 21h
68.
69. mov cx,4
70. mov si,0
71. mov bx,0
72. mov bl,NUMS[si]
73. sum:
74. inc si
75. add bl,NUMS[si] ;sumatoria de los numerod en bl
76. loop sum
77.
78. mov ah,0h ;para evitar errores
79. printprom:
80.
81. mov al,bl ;manda la sumatoria a al
82. mov bl,5
83. div bl ;obtiene el promedio
84. mov bl,al
85. add bl,30h ;corrige el dato
86. mov ah,06h
87. mov dl,bl ;imprime
88. int 21h
89. jmp salida
90.
91. malo:
92. mov ah,09h ;Mensaje de advertencia,
93. lea dx,msgERROR ;el dato ingresado no es un numero
94. int 21h
95. jmp MOUSE
96.
97. salida:
98. hlt
99.
100.
 101. ;Variables
102. mensaje1 db 10,13,"Ingrese un numero:","$"
103. mensaje2 db 10,13,"El menor es:","$"
104.
105. negativo db 10,13,"-","$"
106. msgERROR db 10,13,"ERROR$"
107. msgprom db 10,13,"El promedio es: ","$"
108. NUMS db 5 dup(?)
109. VAR db 1 dup (?)

El código consiste en crear como primer paso una tabla que contenga 5 números de los cuales
se podrá elegir cuál de todos ellos es del menor valor.Otro aspecto importante a resaltar es la
hora en que se va comparando cada elemento de la tabla por medio de un ciclo repetitivo
para que finalmente por medio de las interrupciones necesarias se pueda imprimir el
respectivo mensaje que indica cual fue el número menor.

Asignacion 5
Defina el registro de banderas y explique la función de cada bit que lo conforma

El registro FLAGS es el registro de estado en los microprocesadores Intel x86 que contiene
el estado actual del procesador. Este registro es de 16 bits de ancho. Sus sucesores, los
registros EFLAGS y RFLAGS, son de 32 bits y 64 bits de ancho, respectivamente. El más
amplio de los registros mantiene la compatibilidad con sus predecesores más pequeños.

Las banderas proveen una manera de obtener información acerca de del estado actual de la
máquina y el resultado de procesamiento de una instrucción. El registro de banderas es un
registro de 16 bits, pero no todos los bits se usan.
CF (acarreo): Contiene el acarreo de los bits de mayor orden después de una operación
aritmética; también almacena el contenido del último bit en una operación de corrimiento o
de rotación.
PF (paridad): Indica paridad par o impar en una operación de datos de ocho bits (0=paridad
impar; 1=paridad par).
AF (acarreo auxiliar): Contiene un acarreo externo del bit 3 en un dato de 8 bits, para
aritmética especializada. Esta bandera se prueba con las instrucciones DAA y DAS para
ajustar el valor de AL después de una suma o resta BCD.
OF (overflow, desbordamiento): Indica desbordamiento del bit de mayor orden después de
una operación aritmética de números signados (1=existe overflow; 0=no existe overflow).
Para operaciones sin signo, no se toma en cuenta esta bandera.
DF (dirección): Controla la selección de incremento o decremento de los registros SI o DI
en las operaciones con cadenas de caracteres (1=decremento automático; 0=incremento). La
bandera DF se controla con las instrucciones STD y CLD.
TF (trampa): Permite la operación del procesador en modo de depuración (paso a paso)
SF (signo): Contiene el signo resultante de una operación aritmética (0=positivo;
1=negativo).
ZF (cero): Indica el resultado de una operación aritmética o de comparación (0=resultado
diferente de cero; 1=resultado igual a cero).
RF (continuación):
La bandera de continuación se utiliza con la depuración para controlar la continuación de la
ejecución después de la siguiente instrucción.
VM (modo virtual):
El bit de bandera VM selecciona la operación en modo virtual en un sistema de modo
protegido. Un sistema de modo virtual permite que coexistan varias particiones de memoria
de DOS de 1 Mbyte de longitud en el sistema de memoria. En esencia, esto permite al
programa del sistema ejecutar varios programas de DOS. VM se utiliza para simular el DOS
en el entorno moderno Windows.
AC (comprobación de alineación):
El bit de bandera de comprobación de alineación se activa si se direcciona una palabra o
doble palabra en un límite que no sea de palabra o de doble palabra. Sólo el microprocesador
80486SX contiene el bit de comprobación de alineación que es utilizado para sincronización
principalmente por el coprocesador numérico 80487SX que lo acompaña.
VIF (interrupción virtual):
El VIF es una copia del bit de bandera de interrupción disponible para los microprocesadores
del Pentium al Pentium 4.
VIP (interrupción virtual pendiente)
VIP proporciona información sobre una interrupción en modo virtual para los
microprocesadores del Pentium al Pentium 4. Se utiliza en entornos multitarea para
proporcionar banderas de interrupción virtual al sistema operativo, además de información
de interrupciones pendientes.
ID (identificación):
La bandera ID indica que los microprocesadores del Pentium al Pentium 4 soportan la
instrucción CPUID. Esta instrucción proporciona información al sistema sobre el
microprocesador Pentium, como su número de versión y el fabricante.

Asignacion 6
Investigar el uso de las siguientes instrucciones y realizar un pequeño ejemplo con cada una
de ellas.

 XCHG  BSWAP  ROL

 LAHF  CMOV  RCR
 SAHF  SHL  ROR
 XLAT  SHR
 MOVZX  RCL
XCHG:
Intercambia el contenido de dos registros, o bien el contenido de un registro y el de
una posición de memoria.
Sintaxis: XCHG registro, registro/memoria
XCHG viene del inglés EXCHANGE (Cambio).
Ejemplo:
XCHG AX,WORD PTR [BX] o XCHG AX, [BX], o XCHG AX, BX
MOV AL, 5
MOV AH, 2
XCHG AL, AH ; AL = 2, AH = 5
XCHG AL, AH ; AL = 5, AH = 2
RET

LAHF:
Propósito: Transfiere al registro AH el contenido de las banderas
Sintaxis: LAHF
Esta instrucción es útil para verificar el estado de las banderas durante la ejecución
de nuestro programa.
Las banderas quedan en el siguiente orden dentro del registro:
SF ZF ¿? AF ¿? PF ¿? CF
El símbolo "¿?" significa que en esos bits habrá un valor indefinido.
Copia en el registro AH la imagen de los ocho bits menos significativos del registro
de indicadores.
Operación: AH <- SF:ZF:X:AF:X:PF:X:CF
Ejemplo: AH = flags register

SAHF:
Almacena en los ocho bits menos significativos del registro de indicadores el valor
del registro AH.
Operación: SF:ZF:X:AF:X:PF:X:CF <- AH
Ejemplo : flags register = AH

XLAT:
Realiza una operación de traducción de un código de un byte a otro código de un
byte mediante una tabla. Operación: AL <- [BX+AL]. La instrucción XLAT tabla
carga en el registro AL el contenido de la posición [BX][AL], en donde el registro
BX ha de apuntar al comienzo de una tabla. Dicho de otra manera, AL hace de
índice de la tabla y de almacén destino del contenido de la tabla.
Ejemplo:
MOV BX, OFFSET TABLA
MOV AL, 4
XLAT TABLA
MOVZX:
Destino, origen (Move with Zero Extension, mover con extensión de ceros)
Exactamente como MOVZX, sólo que en vez de extender el signo rellena de 0s.
BSWAP:
Toma el contenido de cualquier registro de 32 bits e intercambia el primer byte con
el cuarto, y el segundo con el tercero. Se utiliza para convertir datos entre los
formatos Little Endian y Big Endian.
CMOV:
Las instrucciones CMOVcc comprueban el estado de uno o más de los indicadores
de estado en el registro EFLAGS (CF, OF, PF, SF y ZF) y realizan una operación
de movimiento si los indicadores están en un estado (o condición) especificado. Un
código de condición (cc) está asociado con cada instrucción para indicar la condición
que se está probando. Si la condición no se cumple, no se realiza un movimiento y la
ejecución continúa con la instrucción que sigue a la instrucción CMOVcc.

Estas instrucciones pueden mover un valor de 16 o 32 bits de la memoria a un registro de

propósito general o de un registro de propósito general a otro. Los movimientos
condicionales de los operandos de registro de 8 bits no son compatibles.

- CMOVNE/CMOVNZ- Movimiento condicional si no es igual/Movimiento condicional si

no es cero.
- CMOVA/CMOVNBE- Movimiento condicional si está arriba/Movimiento condicional si
no está debajo o es igual.
- CMOVAE/CMOVNB- Movimiento condicional si está arriba o es igual/Movimiento
condicional si no está debajo.
- CMOVB/CMOVNAE- Movimiento condicional si está debajo/Movimiento condicional si
no está arriba o es igual.
- CMOVBE/CMOVNA- Movimiento condicional si está abajo o es igual/Movimiento
condicional si no está arriba.
- CMOVG/CMOVNLE- Movimiento condicional si es mayor/Movimiento condicional si
no es menor o igual.
-CMOVGE/CMOVNL- Movimiento condicional si es mayor o igual/Movimiento
condicional si no es menor.
- CMOVC- Movimiento condicional si hay acarreo.
- CMOVNC- Movimiento condicional si no hay acarreo.
- CMOVO- Movimiento condicional si hay desbordamiento.
- CMOVNO- Movimiento condicional si no hay desbordamiento.
- CMOVS- Movimiento condicional si hay signo (negativo).
- CMOVNS- Movimiento condicional si no hay signo (no negativo).
- CMOVP/CMOVPE- Movimiento condicional si hay paridad/Movimiento condicional si
la paridad es par.

Instrucciones de Rotación y Traslación:

RCL, RCR, ROL, ROR, SAL, SHL, SAR, SHR
Este grupo de instrucciones nos permitirán tratar la información almacenada en
registros o en memoria mediante el tratamiento unitario de sus bits.
SHR:
(Desplazamiento aritmético hacia la derecha).
El formato es: SAR operando, contador. Copia en cada bit del operando el contenido
previo del bit de la izquierda. En el bit de mayor peso se almacena un 0. El contenido
previo del bit de menor peso se copia en el flag de acarreo (CF). Es equivalente a
dividir el operando por dos para números sin signo. Si el número de bits a desplazar
es 1, se puede especificar directamente. Si es mayor que 1, su valor debe cargarse en
CL y especificar CL como segundo operando.
Ejemplo:
MOV cl, 2 ; Desplazar 2 bits
SHR al, cl
o SHR al,1
RCL:
(Rotar a la izquierda con acarreo).
El formato es: RCL operando, contador.
Rota a la izquierda los bits del operando junto con la bandera de acarreo, CF, el
número de bits especificado en el segundo operando. Si el número a desplazar es 1,
se puede especificar directamente (Por ejemplo: RCL AL, 1). Si es mayor que 1, su
valor debe cargarse en CL y especificar CL como segundo operando.
Ejemplo RCL:
MOV cl, 3 ; Rotar 3 bits
RCL al, cl
o RCL al,1

ROL:
(Rotar a la izquierda).
El formato es: ROL operando, contador. Rota a la izquierda los bits del operando de
tal forma que el bits del extremo izquierdo del operando destino para al bit extremo
derecho de dicho operando y al mismo tiempo para el bit de acarreo (CF). Si el
número a desplazar es 1, se puede especificar directamente (Por ejemplo: ROL AL,
1). Si es mayor que 1, su valor debe cargarse en CL y especificar CL como segundo
operando.
Ejemplo:
MOV cl, 2 ; Rotar 2 bits
 RCR al, cl
o ROL al,1

RCR:
(Rotar a la derecha con acarreo).
El formato es: RCR operando, contador. Rota a la derecha los bits del operando junto
con la bandera de acarreo, CF, el número de bits especificado en el segundo operando.
Si el número a desplazar es 1, se puede especificar directamente (Por ejemplo: RCR
AL, 1). Si es mayor que 1, su valor debe cargarse en CL y especificar CL como
segundo operando.
Ejemplo:
MOV cl, 3 ; Rotar 3 bits
RCR al, cl
o RCR al,1
ROR:
(Rotar a la derecha).
El formato es: ROR operando, contador.
Rota a la derecha los bits del operando de tal forma que el bits del extremo derecho
del operando destino para al bit extremo izquierdo de dicho operando y al mismo
tiempo para el bit de acarreo (CF). Si el número a desplazar es 1, se puede especificar
directamente (Por ejemplo: ROR AL, 1). Si es mayor que 1, su valor debe cargarse
en CL y especificar CL como segundo operando.
Ejemplo:
MOV cl, 2 ; Rotar 2 bits
RCR al, cl
o ROR al,1
SHL/SAL:
(Desplazamiento aritmético a la izquierda).
Es equivalente a SHL (Desplazamiento lógico a la izquierda).
El formato es: SAL operando, contador. SHL y SAL realizan la misma operación y
son físicamente la misma instrucción. Copia en cada bit del operando el contenido
previo del bit de su derecha. El bit de menor peso se pone a cero. El contenido previo
del bit de mayor peso se copia en el flag de acarreo (CF). Es equivalente a multiplicar
el operando por dos, tanto para números sin signo como para número en complemento
a 2, siempre el resultado no se salga del rango. Si el número de bits a desplazar es 1,
se puede especificar directamente (Por ejemplo: SAL AL, 1). Si es mayor que 1, su
valor debe cargarse en CL y especificar CL como segundo operando.
Ejemplo:
MOV cl, 2 ; Desplazar 2 bits
SAL al, cl
o SAL al,1
CONCLUSIÓN
Al terminar esta guía pudimos observar que el emulador 8086 permite la oportunidad de
simular programas capaces de ser ejecutados por el microprocesador 8086 diseñado por Intel,
ya que su lenguaje ensamblador permite una comprensión de la arquitectura interna del
microprocesador 8086 la cual es necesaria para el diseño correcto de códigos.

También pudimos observar que los programas no solo se pueden ejecutar utilizando un
mismo tipo de instrucciones, ya que depende de nosotros para poder optimizar los códigos
tal como el ejemplo del código de la asignación de ‘HELLO WORLD’ comparado con el
código proporcionado de la asignación 1.