PC XT Cruz Ferreyros Layme Polanco

Universidad Nacional de San Agustín
Facultad de Producción y Servicios

Escuela Profesional de Ing. Electrónica
CURSO:
ARQUITECTURA DE COMPUTADORAS
TURNO: “B”
Miércoles: 07:00 – 08:40
GRUPO – G1
TAREA 01: PC XT
Estudiantes:
 Cruz Huachaca, Frank Jhonathan 20170307

 Ferreyros Lazo, Boris Jhonat 20180286
 Layme Polanco, Arnold Bill 20162731
Fecha de entrega:
12/09/2021
AREQUIPA – 2021
Contenido
1 INTRODUCCION.................................................................................................................................3
2 Hardware Computadora Personal PC XT 8088-8086.........................................................................3
2.1 Sistemas que componen la computadora XT.............................................................................4
2.2 Características del procesador 8088/8086................................................................................4
2.3 Funcionamiento en general.......................................................................................................5
2.4 Sistema descrito por bloques y por circuitos.............................................................................6
2.5 Esquemático del sistema completo Sistema de Aplicación........................................................6
2.6 Muestra de una Mainboard XT con identificación de dispositivos Etiquetado y accesorios......8
2.7 Registros del 8088.....................................................................................................................8
2.7.1 Registros de Almacenamiento Temporal o de Datos:........................................................9
2.7.2 Registros de Segmento:.....................................................................................................9
2.7.3 Registros de la Pila:............................................................................................................9
2.7.4 Registros Índices:...............................................................................................................9
2.7.5 Registros de Instrucción:....................................................................................................9
2.8 Modos de direccionamiento....................................................................................................10
2.9 Set de instrucciones del 8088..................................................................................................11
2.9.1 Instrucciones de transferencia de datos (No afectan flags).............................................11
2.9.2 Instrucciones aritméticas (Afectan los flags AF, CF, OF, PF, SF, ZF)..................................12
2.9.3 Instrucciones lógicas (Afectan AF, CF, OF, PF, SF, ZF).......................................................13
2.10 Lenguaje máquina, macroensamblador del 8088....................................................................13
2.10.1 ENSAMBLADORES Y MACROENSAMBLADORES:..............................................................13
2.10.2 Macro Ensamblador IBM.-...............................................................................................13
2.10.3 Macro Ensamblador de Microsoft.-.................................................................................14
2.11 Debuger, y simuladores del 8088/8086...................................................................................14
3 Ensamblador 8088/8086 Hoja de Datos INTEL................................................................................15
4 Codificación, Debug, EMU8086 (programa: suma, promedio, ordenamiento)................................58
4.1 Aplicaciones.............................................................................................................................78
5 BIBLIOGRAFIA..................................................................................................................................79
1 INTRODUCCION
El cerebro del ordenador es el procesador. Su función es ejecutar los programas almacenados en la

memoria principal tomando las instrucciones, examinándolas y ejecutándolas una tras otra. Para ello,
el procesador realiza todas las operaciones aritméticas, lógicas y de control que son necesarias.
En junio de 1978 Intel lanzó al mercado el primer microprocesador de 16 bits: el 8086. En junio de
1979 apareció el 8088 (internamente igual que el 8086 pero con bus de datos de 8 bits) y en 1980 los
coprocesadores 8087 (matemático) y 8089 (de entrada y salida). El primer fabricante que desarrolló
software y hardware para estos chips fue la propia Intel. Reconociendo la necesidad de dar soporte a
estos circuitos integrados, la empresa invirtió gran cantidad de dinero en un gran y moderno edificio en
Santa Clara, California, dedicado al diseño, fabricación y venta de sus sistemas de desarrollo que, como
se explicó anteriormente, son computadoras autosuficientes con el hardware y software necesario
para desarrollar software de microprocesadores.
El desarrollo más notable para la familia 8086/8088 fue la elección de la CPU 8088 por parte de IBM
(International Business Machines) cuando en 1981 entró en el campo de las computadoras personales.
Esta computadora se desarrolló bajo un proyecto con el nombre "Acorn" (Proyecto "Bellota") pero se
vendió bajo un nombre menos imaginativo, pero más correcto: "Computadora Personal IBM", con un
precio inicial entre 1260 dólares y 3830 dólares según la configuración (con 48KB de memoria RAM y
una unidad de discos flexibles con capacidad de 160KB costaba 2235 dólares). Esta computadora entró
en competencia directa con las ofrecidas por Apple (basado en el 6502) y por Radio Shack (basado en
el Z-80).
2 Hardware Computadora Personal PC XT 8088-8086
En primer lugar, la computadora personal PC XT tenía como corazón al microprocesador 8088 de Intel,
lo cual vendría a ser la unidad central de proceso o CPU. El 8088 era en sí una versión simplificada de
su antecesor, el 8086 que contaba con registros y bus de datos de 16 bits.
Figura 1: PC XT 8088 de IBM
La computadora contaba con una “disquetera” o unidad de disquetes, memoria RAM, memoria ROM,
Discos de almacenamiento, controladores y una serie de periféricos.
2.1 Sistemas que componen la computadora XT
La PC XT contaba además con una serie de componentes integrados:
 CPU : Intel 8088 (4.77 Mhz)

 Memoria RAM : 128-256 Kb
 Memoria ROM : 64 Kb
 Disco : 5.25" 360 Kb - 10 Mb
 Sistema Operativo : IBM BIOS / PC-DOS 2.0
 Puertos : 8 ranuras de expansión ISA
 Alimentación : 130W conector 16 pines
Otro componente del PC XT era el teclado, el cual al igual que en el caso de su predecesor, el PC
Original no era compatible con aquellos de los equipos más modernos (el AT o superior).
2.2 Características del procesador 8088/8086

El 8088 contaba con registros de 16 bits, con un bus de datos de 8 bits y de direcciones de 20 bits. La
ventaja se encontraba en que el bus de 8 bits coincidía con el bus de datos de la placa base. Sin
embargo se requería la ayuda de un Coprocesador Intel 8087 para operaciones aritméticas de coma
flotante
La diferencia en el ancho del bus no hace que el 8086 sea el doble de rápido que el 8088. El 8088
ejecuta sus instrucciones desde una cola interna la cual se llena tan pronto como hay una localidad
vacía; así, es posible que se traslapen los ciclos de ejecución y búsqueda.
Características
 Arquitectura interna de 16 bits

 Soporta 1 MB de memoria
 Aritmética con signo y sin signo de 8 y 16 bits, tanto en binario como en decimal.
 14 registros de 16 bits.
 Interrupción enmascarable y no enmascarable.
 24 modos de direccionamiento de operandos.
 Acceso directo a memoria
 Soporte para coprocesadores de bus local.
 Soporte para E/S mapeada en memoria.
 Operaciones de cadena
Una manera de aprender acerca del 8088 es conocer las funciones de sus pines. La figura que se
mostrará a continuación, muestra un diagrama funcional a bloques (Functional Block Diagram) y un
diagrama de la definición de las patitas (Pin Diagram) del 8088:
Figura 2: Diagrama de bloques del funcionamiento del CPU 8088
La ventaja de esta división fue el ahorro de esfuerzo necesario para producir el 8088. Sólo una mitad
del 8086 (el BIU) tuvo que rediseñarse para producir el 8088.
El procesador opera a 4.77 MHz, frecuencia que es derivada del cristal de 14.31818 MHz la cual es
dividida por tres por el reloj del procesador; y por cuatro se obtiene 3.58 MHz (la señal requerida para
los televisores de color).
El procesador es respaldado por el set de funciones provistas por cuatro canales de 20 bits de acceso
directo a memoria o DMA, tres grupos de canales del Timer de 16 bits y ocho niveles de interrupciones.
Tres de los cuatro canales de DMA están disponibles en el bus de Entrada/Salida y hay una alta
velocidad para transferencia de datos entre las memorias y los canales de Entrada/Salida sin
intervención de la memoria del procesador.
El cuarto canal es programado para refrescar el sistema dinámico de memoria, esto está hecho para el
programa del Timer-contador e informe periódicamente de la transferencia DMA.
2.3 Funcionamiento en general
El funcionamiento general de la computadora es ejecutar programas, los cuales están compuesto de

un conjunto de instrucciones almacenadas en memoria. La CPU es la encargada de ejecutar las
instrucciones específicas del programa.
Para comprender esta función debe considerarse el detalle del proceso de ejecución del programa.
Desde el punto de vista más simple, se considera el procesamiento de una instrucción en dos etapas: la
CPU lee (busca, trae; “fetch” en inglés) la instrucción de memoria y la ejecuta.
El procesamiento de una instrucción se denomina ciclo de instrucción y se representa en la figura

siguiente. Los dos pasos se denotan como ciclo de búsqueda y ciclo de ejecución. La ejecución del
programa se detiene sólo si la computadora se desconecta, se produce algún error o se encuentra una
instrucción que detiene la computadora.
Buscar una instrucción es una operación común a todas las instrucciones, y consiste en la lectura de la
instrucción de una localidad de memoria. La ejecución de la instrucción puede suponer varias
operaciones y depende de la naturaleza de la instrucción.
2.4 Sistema descrito por bloques y por circuitos
La PC XT estaba esencialmente basada en la misma arquitectura de la IBM PC Original. La IBM PC

original fue un sistema basado en disquete con una memoria de 32K y cinco ranuras o slots de
expansión. La IBM PC soportaba uno o dos disquetes, cada uno con capacidad de 160KB y se le podían
agregar externamente dos manejadores de disco flexible. La PC original usó el microprocesador 8088
de Intel corriendo a 4.77 MHz. A continuación se muestra la PC original descrita por bloques:
Figura 3: Diagrama de bloques del PC XT.

Para estar a la vanguardia de las tecnologías competentes en ese entonces, la IBM PC rápidamente
requirió varias mejoras, para mantenerse a la par con el desarrollo de software y la necesidad de más
RAM y capacidad en disco.
Esta necesidad se satisfizo con la introducción de la PC XT la cual adoptó las siguientes mejoras:
 Se aumentó el número de ranuras de expansión a 8.

 Se agregó adaptador de disco y disco duro.
 Se agregó un puerto serie y un paralelo como equipo estándar.
 La capacidad en RAM de la tarjeta madre se incrementó a 256KB.
 La fuente de energía se aumenta de 65 a 130 watts.
 La capacidad del disco flexible se mejoró de un solo lado a doble lado para una capacidad total
de 360K.
2.5 Esquemático del sistema completo Sistema de Aplicación.

La unidad de ejecución es la encargada de realizar todas las operaciones mientras que la unidad de
interfaz del bus es la encargada de acceder a datos e instrucciones del mundo exterior. Las unidades de
ejecución son idénticas en ambos microprocesadores, pero las unidades de interfaz del bus son
diferentes en varias cuestiones, como se desprende del siguiente diagrama en bloques:
Figura 4: Diagrama de bloques del EU y BIU.

La explicación del diagrama en bloques es la siguiente:
 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.
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).
 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.
2.6 Muestra de una Mainboard XT con identificación de dispositivos Etiquetado

y accesorios
Figura 5: Mainboard de PC XT con dispositivos.

2.7 Registros del 8088
Para ayudar al funcionamiento de las instrucciones, para poder manejar variables en memoria y para
su propio funcionamiento, el microprocesador dispone de una serie de “variables” internas de
nombres fijos que son los registros internos. En total hay 14 de estos registros, cada uno de los cuales
está pensado principalmente para alguna función concreta. En seguida se dan detallan cada uno de
estos registros, divididos según áreas de funcionalidad:
2.7.1 Registros de Almacenamiento Temporal o de Datos:
En primer lugar se tiene:
 AX (Registro Acumulador): Es usado sobre todo en operaciones aritméticas como primer

operando y también como registro de propósito general a disposición del programador.
 BX (Registro Base): Se usa principalmente para indicar posiciones de memoria (offset).
 CX (Registro Contador): Este registro se usa siempre que se necesite un contador en
operaciones repetitivas y bucles.
 DX (Registro Dato): Se usa como registro auxiliar en operaciones aritméticas y como
contenedor de datos a la hora de usar instrucciones de comunicación de puertos
Estos cuatro registros, como todos los restantes, son de 16 bits, pero para permitir la realización de
operaciones de tipo byte (8 bits) cada uno de estos cuatro registros está dividido en dos subregistros
de 8 bits a los que se puede acceder de forma independiente.
2.7.2 Registros de Segmento:

Son cuatro registros de 16 bits usados para indicar direcciones de memoria:
 CS (Code Segment): Este registro es usado por el procesador, junto con el registro IP, para
conocer dónde está la instrucción actual que está siendo ejecutada.
 DS (Data Segment): Se usa para indicar dónde están todos los datos del programa en ejecución.
 SS (Stack Segment): En este registro se indica al procesador dónde está la zona de memoria
que se usa como segmento de pila.
 ES (Extra Segment): Es el registro que referencia al segmento extra, y se usa como apuntador
de memoria auxiliar en operaciones complejas donde se necesitan dos punteros de datos
simultáneos.
2.7.3 Registros de la Pila:

La pila es un área de memoria importante. Tiene, en vez de uno, dos registros que se usan como
desplazamiento (offset) para apuntar su contenido. Se usan como complemento al registro SS y son:
 SP (Stack Pointer): Es el registro que se reserva el procesador para uso propio en instrucciones
de manipulación de la pila.
 BP (Base Pointer): Se usa como registro auxiliar.
2.7.4 Registros Índices:

Se utilizan como desplazamientos complementarios para DS y ES a la hora de indicar la posición donde
se encuentran los datos a los que se desea acceder. Son: 18 Hardware PC XT 8088-8086 Arquitectura
de Computadoras
 SI (Source index): Se usa como puntero origen en operaciones de desplazamiento de datos

entre dos zonas de memoria.
 DI (Destination index): Se usa como destino en operaciones de desplazamiento de datos.
2.7.5 Registros de Instrucción:

Sólo hay uno, el registro IP (Instruction Pointer), es usado por la CPU para conocer la posición relativa
a la base CS donde se encuentra la instrucción que se está ejecutando actualmente. Este registro no
puede ser modificado directamente por parte del programador. Este puntero cambia su contenido
automáticamente cada vez que se ejecuta una instrucción o cuando se salta a otro punto del programa
mediante una instrucción de salto.
2.8 Modos de direccionamiento

Estos procesadores tienen 27 modos de direccionamiento (una cantidad bastante más grande que los
microprocesadores anteriores) o reglas para localizar un operando de una instrucción. Tres de ellos son
comunes a microprocesadores anteriores: direccionamiento inmediato (el operando es un número que
se encuentra en la misma instrucción), direccionamiento a registro (el operando es un registro del
microprocesador) y direccionamiento inherente (el operando está implícito en la instrucción, por
ejemplo, en la multiplicación uno de los operandos siempre es el acumulador). El resto de los modos
sirve para localizar un operando en memoria. Para facilitar la explicación de estos modos, se pueden
resumir de la siguiente manera:
Deben sumarse cuatro cantidades: 1
) dirección de segmento, 2) dirección base, 3) una cantidad índice y 4) un desplazamiento.
El 8088 puede direccionar más de los 65536 bytes de datos especificados por los 16 bits. El 8088 tiene
una dirección de 20 bits que permite un tamaño de memoria física de 1, 048,576 bytes. Tomando en
cuenta el criterio del programador, el almacenamiento está limitado a una región de 64 KB, sin
embargo el programador puede mover esta región de 64 KB a alguna demarcación en el espacio de 1
MB.
Esto se logra manipulando los contenidos del Registro de Segmento. El valor cargado en el Registro de
Segmento se usa para localizar la región de 64 KB en el espacio de 1 MB. Debido a que este Registro es
también de 16 bits, no puede por sí mismo especificar alguna demarcación en el espacio de 1 MB. A
pesar de esto, el registro de 16 bits puede especificar 64 KB regiones diferentes.
La dirección de memoria física se forma corriendo a la izquierda 4 bits el contenido del registro de
segmento y sumándolo a la dirección de 16 bits. La figura ilustra la generación de la dirección física.
Figura 6: Generación de dirección física.

2.9 Set de instrucciones del 8088
Las instrucciones del 8088 se pueden clasificar en los siguientes grupos
 Transferencia de datos
 Aritmeticas
 Operaciones Lógicas
 Corrimientos y rotaciones
 Gestión de bits
 Gestión de cadenas
 Control de Programa
 Control de sistema
2.9.1 Instrucciones de transferencia de datos (No afectan flags)

MOV dest,src
Copia el contenido del operando fuente (src) en el destino (dest).
Operación: dest <- src
Las posibilidades son:
MOV reg,{reg|mem|inmed}
MOV mem,{reg|inmed}
MOV {reg16|mem16},{CS|DS|ES|SS}
MOV {DS|ES|SS},{reg16|mem16}
PUSH src
Pone el valor en el tope del stack.

Operación: SP <- SP - 2, [SP+1:SP] <- src donde src = {reg16|mem16|CS|DS|ES|SS}.
POP dest
Retira el valor del tope del stack poniéndolo en el lugar indicado.
Operación: dest <- [SP+1:SP], SP <- SP + 2 donde dest = {reg16|mem16|DS|ES|SS}.
XCHG reg,{reg|mem}
Intercambia ambos valores.
IN {AL|AX},{DX|inmed (1 byte)}
Pone en el acumulador el valor hallado en el port indicado.
OUT {DX|inmed (1 byte)},{AL|AX}
Pone en el port indicado el valor del acumulador.
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]
LEA reg,mem
Almacena la dirección efectiva del operando de memoria en un registro.
Operación: reg <- dirección mem
LDS reg,mem32
Operación: reg <- [mem], DS <- [mem+2]
LES reg,mem32
Operación: reg <- [mem], ES <- [mem+2]
LAHF
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
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
PUSHF
Almacena los flags en la pila.
Operación: SP <- SP - 2, [SP+1:SP] <- Flags.
POPF
Pone en los flags el valor que hay en la pila.
Operación: Flags <- [SP+1:SP], SP <- SP + 2
2.9.2 Instrucciones aritméticas (Afectan los flags AF, CF, OF, PF, SF, ZF)
ADD dest,src
Operación: dest <- dest + src.
ADC dest,src
Operación: dest <- dest + src + CF.
SUB dest,src
Operación: dest <- dest - src.
SBB dest,src
Operación: dest <- dest - src - CF.
CMP dest,src
Operación: dest - src (sólo afecta flags).
INC dest
Operación: dest <- dest + 1 (no afecta CF).
DEC dest
Operación: dest <- dest - 1 (no afecta CF).
NEG dest
Operación: dest <- - dest.
donde dest = {reg|mem} y src = {reg|mem|inmed} no pudiendo ambos operandos estar en memoria.
DAA
Corrige el resultado de una suma de dos valores BCD empaquetados en el registro AL (debe estar
inmediatamente después de una instrucción ADD o ADC). OF es indefinido después de la operación.
DAS
Igual que DAA pero para resta (debe estar inmediatamente después de una instrucción SUB o SBB).
AAA
Lo mismo que DAA para números BCD desempaquetados.
AAS
Lo mismo que DAS para números BCD desempaquetados.
AAD
Convierte AH:AL en BCD desempaquetado a AL en binario.
Operación: AL <- AH * 0Ah + AL, AH <- 0. Afecta PF, SF, ZF, mientras que AF, CF y OF quedan
indefinidos.
AAM
Convierte AL en binario a AH:AL en BCD desempaquetado.
Operación: AH <- AL / 0Ah, AL <- AL mod 0Ah. Afecta PF, SF, ZF, mientras que AF, CF y OF quedan
indefinidos.
MUL {reg8|mem8}
Realiza una multiplicación con operandos no signados de 8 por 8 bits.
Operación: AX <- AL * {reg8|mem8}. CF=OF=0 si AH = 0, CF=OF=1 en caso contrario. AF, PF, SF, ZF
quedan indefinidos.
MUL {reg16|mem16}
Realiza una multiplicación con operandos no signados de 16 por 16 bits.
Operación: DX:AX <- AX * {reg16|mem16}. CF=OF=0 si DX = 0, CF=OF=1 en caso contrario. AF, PF, SF, ZF
quedan indefinidos.
IMUL {reg8|mem8}
Realiza una multiplicación con operandos con signo de 8 por 8 bits.
Operación: AX <- AL * {reg8|mem8} realizando la multiplicación con signo. CF = OF = 0 si el resultado
entra en un byte, en caso contrario valdrán 1. AF, PF, SF, ZF quedan indefinidos.
IMUL {reg16|mem16}
Realiza una multiplicación con operandos con signo de 16 por 16 bits.
Operación: DX:AX <- AX * {reg16|mem16} realizando la multiplicación con signo. CF = OF = 0 si el
resultado entra en dos bytes, en caso contrario valdrán 1. AF, PF, SF, ZF quedan indefinidos.
CBW
Extiende el signo de AL en AX. No se afectan los flags.
CWD
Extiende el signo de AX en DX:AX. No se afectan flags.
2.9.3 Instrucciones lógicas (Afectan AF, CF, OF, PF, SF, ZF)
AND dest,src
Operación: dest <- dest and src.
TEST dest,src
Operación: dest and src. Sólo afecta flags.
OR dest,src
Operación: dest <- dest or src.
XOR dest,src
Operación: dest <- dest xor src.
Las cuatro instrucciones anteriores ponen CF = OF = 0, AF queda indefinido y PF, SF y ZF dependen del
resultado.
NOT dest
Operación: dest <- Complemento a 1 de dest. No afecta los flags.
SHL/SAL dest,{1|CL}
Realiza un desplazamiento lógico o aritmético a la izquierda.
SHR dest,{1|CL}
Realiza un desplazamiento lógico a la derecha.
SAR dest,{1|CL}
Realiza un desplazamiento aritmético a la derecha.
ROL dest,{1|CL}
Realiza una rotación hacia la izquierda.
ROR dest,{1|CL}
Realiza una rotación hacia la derecha.
RCL dest,{1|CL}
Realiza una rotación hacia la izquierda usando el CF.
RCR dest,{1|CL}
Realiza una rotación hacia la derecha usando el CF.
En las siete instrucciones anteriores la cantidad de veces que se rota o desplaza puede ser un bit o la
cantidad de bits indicado en CL.
2.10 Lenguaje máquina, macroensamblador del 8088

El lenguaje máquina es el único que entiende directamente la computadora, utiliza el alfabeto binario
que consta de los dos únicos símbolos 0 y 1, denominados bits (abreviatura inglesa de dígitos binarios).
2.10.1 ENSAMBLADORES Y MACROENSAMBLADORES:

Existen varios ensambladores disponibles para ambiente MS-DOS: el IBM Macro Assembler, el Turbo
Assembler de Borland, el Turbo Editassm de Speedware, por citar algunos. Una breve descripción de
cada uno se propociona a continuación.
2.10.2 Macro Ensamblador IBM.-

Está integrado por un ensamblador y un macroensamblador. En gran medida su funcionamiento y
forma de invocarlo es sumamente similar al de Microsoft. Su forma de uso consiste en generar un
archivo fuente en código ASCII, se procede a generar un programa objeto que es ligado y se genera un
programa .EXE. Opcionalmente puede recurrirse a la utilería EXE2BIN de MS-DOS para transformarlo
a .COM. Es capaz de generar un listado con información del proceso de ensamble y referencias
cruzadas.
2.10.3 Macro Ensamblador de Microsoft.-

Dependiendo de la versión, este ensamblador es capaz de soportar el juego de instrucciones de
distintos tipos de microprocesadores Intel de la serie 80xx/80x86. En su versión 4.0 este soporta desde
el 8086 al 80286 y los coprocesadores 8087 y 80287. Requiere 128KB de memoria y sistema operativo
MS-DOS v2.0 o superior. Trabaja con un archivo de código fuente creado a partir de un editor y
grabado en formato ASCII. Este archivo es usado para el proceso de ensamble y generación de código
objeto. Posteriormente, y con un ligador, es creado el código ejecutable en formato .EXE.
2.11 Debuger, y simuladores del 8088/8086
Un Depurador (en inglés, debugger), es un programa que permite depurar o limpiar los errores de otro
programa informático. Al Iniciarse la depuración, el depurador lanza el programa a depurar.
Este se ejecuta normalmente hasta que el depurador detiene su ejecución, permitiendo al usuario
examinar la situación.
El depurador permite detener el programa en:
 Un punto determinado mediante un punto de ruptura.

 Un punto determinado bajo ciertas condiciones mediante un punto de ruptura condicional.
 Un momento determinado cuando se cumplan ciertas condiciones.
 Un momento determinado a petición del usuario.
Durante esa interrupción, el usuario puede:
 Examinar y modificar la memoria y las variables del programa.

 Examinar el contenido de los registros del procesador.
 Examinar la pila de llamadas que han desembocado en la situación actual.
 Cambiar el punto de ejecución, de manera que el programa continúe su ejecución en un punto
diferente al punto en el que fue detenido.
 Ejecutar instrucción a instrucción.
 Ejecutar partes determinadas del código, como el interior de una función, o el resto de código
antes de salir de una función.
El depurador depende de la arquitectura y sistema en el que se ejecute, por lo que sus funcionalidades
cambian de un sistema a otro. Aquí se han mostrado las más comunes.
En cuanto a la Depuración: para poder aprovechar todas las posibilidades de depuración es necesario
que, al compilar el programa a depurar, se indique al compilador que debe incluir instrucciones e
información extra para la depuración del código.
Dicha información extra consiste básicamente en la correspondencia entre las instrucciones del código
ejecutable y las instrucciones del código fuente que las originan, así como información sobre nombres
de variables y funciones. Aún si no se incluye esta información de depuración, sigue siendo posible
monitorizar la ejecución del programa. Sin embargo, resultará más difícil y compleja debido a esa falta
de información del contexto en el que se ejecuta el programa. Un depurador también puede usarse
para realizar ingeniería inversa o evitar protecciones de copia.
Mediante el uso del depurador se puede conocer el funcionamiento interno del programa examinado,
ayudando al proceso de ingeniería inversa o permitiendo desarrollar técnicas para evadir las
restricciones impuestas por el programa.
Un programa que está siendo depurado puede presentar un comportamiento diferente a si se ejecuta
en solitario debido a que el depurador cambia ligeramente los tiempos internos del programa. Estos
cambios en los tiempos de ejecución afectan especialmente a sistemas complejos multihebra o
sistemas distribuidos.
Ejemplos de depuradores
 GNU Debugger (gdb)

 SoftICE
 OllyDbg
 Trw2000
 Ida Pro
3 Ensamblador 8088/8086 Hoja de Datos INTEL

Ahora bien, enlistaremos las instrucciones del 8086/8088.
AAA – Ajuste ASCII en suma (Ascii Adjust for Addition)
Uso: AAA
Flags que modifica: AF CF (OF, PF, SF, ZF indefinidos)
Descripción: Corrige el resultado en AL de una suma de dos números decimales

desempaquetados, convirtiéndolo en un valor decimal desempaquetado. La
operación que realiza es la siguiente:
Si bits 3 a 0 de AL > 9 o
AF = 1 AL = AL + 6
AH = AH + 1
AF = 1, CF = AF
Bits 7 a 4 de AL = 0000b
AAD – Ajuste ASCII en división (ASCII Adjust for Division)
Uso: AAD
Flags que modifica: SF ZF PF (AF, CF, OF indefinidos)
Descripción: Realiza un ajuste del dividendo en AL antes de hacer la división de dos

números decimales desempaquetados, para que el resultado de esta división
(cociente) sea un valor decimal desempaquetado. La lógica que usa es la siguiente:
AL :=
10*AH+A
L AH := 0
AAM – Ajuste ASCII en multiplicación (ASCII Adjust for Multiplication)
Uso: AAM
Flags que modifica: PF SF ZF (AF, CF, OF indefinidos)
Descripción: Corrige el resultado en AX del producto de dos números decimales

desempaquetados, convirtiéndolo en un valor decimal desempaquetado. La lógica
que emplea es la siguiente:
AH := AL /
10 AL :=
AL mod 10
AAS –Ajuste ASCII en resta (ASCII Adjust for Subtraction)
Uso: AAS
Flags que modifica: AF CF (OF, PF, SF, ZF indefinidos)
Descripción: Corrige el resultado en AL de la resta de dos números decimales

desempaquetados, convirtiéndolos en un valor decimal desempaquetado. La lógica
que emplea es la siguiente:
Si bits 3 a 0 de AL > 9 o
AF = 1 AL = AL –6
AH = AH –1
AF = 1, CF = AF
Bits 7 a 4 de AL = 0000b
ADC – Sumar con acarreo (Add With Carry)
Uso: ADC dest,src
Flags que modifica: AF CF OF SF PF ZF
Descripción: Suma los dos operandos. Además, añade 1 a la suma si está activada la
bandera de acarreo (CF). El resultado se almacena en el operando destino. Los
operandos deben ser del mismo tipo (byte o palabra).
ADD – Suma aritmética (Arithmetic Addition)
Uso: ADD dest,src

Flags que modifica: AF CF OF PF SF ZF
Descripción: Suma los dos operandos. El resultado se almacena en el operando destino.
Los operandos deben ser del mismo tipo (byte o palabra).
AND – Y lógico (Logical And)
Uso: AND dest,src
Flags que modifica: CF OF PF SF ZF (AF indefinidos)
Descripción: Operación “y lógica” a nivel de bit entre los dos operandos. El resultado se
almacena en el operando destino. Los operandos deben ser del mismo tipo (byte o
palabra).
CALL – Llamada a una función o procedimiento (Procedure Call)
Uso: CALL destination
Flags que modifica: Ninguno

Descripción: Bifurca a un procedimiento fuera de línea, salvando previamente en la pila la
dirección de la instrucción siguiente, para poder volver a esta instrucción una vez
ejecutado el procedimiento.
CBW – Convertir byte en palabra. (Convert Byte to Word)
Uso: CBW
Descripción: Copia el bit 7 del registro AL en todos los bits del registro AH; es decir,
expande el bit de signo de AL.
CLC – Borrar bandera de acarreo (Clear Carry)
Uso: CLC
Flags que modifica: CF
Descripción: Borra la bandera de acarreo (CF) sin afectar a ninguna otra bandera.
CLD – Borrar bandera de dirección (Clear Direction Flag)
Uso: CLD
Flags que modifica: DF
Descripción: Pone a 0 la bandera de dirección (DF), por lo que en la ejecución de las

instrucciones de manejo de cadenas los registros índices SI y/o DI se autoincrementan en una
unidad si el (los) operando(s) son de tipo byte, y en dos, si son de tipo word.
CLI – Borrar (desactivar) bandera de interrupciones (Clear Interrupt Flag)
Uso: CLI
Flags que modifica: IF
Descripción: Borra la bandera de activación de interrupciones (IF) y desactiva las

interrupciones enmascarables (las que aparecen sobre la línea INTR del
procesador). Las interrupciones enmascarables se pueden activar (permitir) o
desactivar (no permitir). Las interrupciones no enmascarables (las que aparecen
sobre la línea NMI) no se pueden desactivar.
CMC – Complementar bandera de acarreo (Complement Carry Flag)
Uso: CMC
Descripción: Complementa la bandera de acarreo (CF); es decir, la pone en el estado

contrario.
CMP – Comparar dos operandos (Compare)
Uso: CMP dest,src
Descripción: Resta fuente de destino, pero no retorna el resultado. Los operandos quedan
inalterados, pero las banderas se actualizan, pudiéndose consultar a continuación
mediante una instrucción de bifurcación condicional. Los operandos pueden ser de
tipo byte o palabra, pero ambos del mismo tipo.
CMPS - Comparar cadenas (Compare String -Byte, Word or Doubleword-)
Uso: CMPS
dest
,src
CMPSB
CMPS
W
Descripción: Sirve para comparar dos operandos de memoria (tipo byte o palabra). Para
ello realiza la operación:
Cadena fuente – cadena destino
afectando a las banderas, pero sin almacenar el resultado. La cadena fuente está
direccionada por SI en el segmento de datos, es decir, DS:[SI]. La cadena destino
está direcionada por DI en el segmento extra, es decir, ES:[DI]. Los registros SI y
DI se actualizan para que apunten al siguiente elemento de la cadena. Si la bandera
de dirección es cero (DF=0), ambos SI y DI se incrementan. Si DF=1, ambos se
decrementan.
En la instrucción CMPSB, se realiza la resta entre bytes DS:[SI] – ES:

[DI].
En la instrucción CMPSW, se realiza la resta entre palabras DS:[SI] – ES:

[DI].
CWD – Convertir palabra en doble palabra (Convert Word to Doubleword)
Uso: CWD
Descripción: Expande el bit de signo del registro AX (bit 15) sobre el registro DX.
DAA – Ajuste decimal en suma (Decimal Adjust for Addition)
Uso: DAA
Flags que modifica: AF CF PF SF ZF (OF indefinidos)

Descripción: Corrige el resultado en AL de la suma de dos números decimales
empaquetados, convirtiéndolo en un valor decimal empaquetado.
DAS – Ajuste decimal en resta (Decimal Adjust for Subtraction)
Uso: DAS
Flags que modifica: AF CF PF SF ZF (OF indefinidos)
Descripción: Corrige el resultado en AL de la resta de dos números decimales

empaquetados, convirtiéndolo en un valor decimal empaquetado.
DEC – Decrementar destino en uno (Decrement)
Uso: DEC dest
Flags que modifica: AF OF PF SF ZF
Descripción: Resta una unidad del operando destino. El operando puede ser byte o palabra.
DIV – División (Divide)
Uso: DIV src
Flags que modifica: (AF, CF, OF, PF, SF, ZF indefinidos)
Descripción: Divide, sin considerar el signo, un número contenido en el acumulador y su

extensión (AH, AL si el operando es de tipo byte o DX, AX si el operando es de
tipo palabra) entre el operando fuente. El cociente se almacena en el acumulador
(AL o AX, según que el operando fuente sea de tipo byte o palabra). El resto se
almacena en la extensión del acumulador (AH o DX, según que el operando fuente
sea de tipo byte o palabra).
ESC – Escape (Escape)

Uso: ESC immed,src
Descripción: Esta instrucción suministra un mecanismo de comunicación con otros

coprocesadores. Se usa para indicar a un coprocesador que comienza a realizar
alguna tarea. A su vez, el 8086/8088 continúa ejecutando la instrucción siguiente.
Se usa en combinación con WAIT.
El primer operando es un valor inmediato de 6 bits (0 a 63) y sirve para denotar, a la

vez, al coprocesador y la operación a ejecutar. El segundo operando es tipo registro
o memoria y especifica el dato a pasar al coprocesador.
HLT – Detener CPU – (Halt CPU)
Uso: HLT
Descripción: El procesador se para. Sólo abandona ese estado en uno de estos casos:
- Se restaura el sistema (activación de la línea RESET).
- Se recibe una interrupción no enmascarable sobre la línea NML
- Se recibe una interrupción enmascarable sobre la línea INTR (si las interrupciones
están permitidas).
IDIV – Dividir con signo (Signed Integer Division)
Uso: IDIV src
Flags que modifica: (AF, CF, OF, PF, SF, ZF indefinidos)
Descripción: Divide, considerando el signo, un número contenido en el acumulador y su

extensión (AH, AL si el operando es de tipo byte o DX, AX si es de tipo palabra)
entre el operando fuente. El cociente se almacena en el acumulador (AL o AX,
según que el operando fuente sea de tipo byte o palabra). El resto se almacena en la
extensión del acumulador (AH o DX, según que el operando fuente sea de tipo byte
o palabra).
IMUL – Multiplicar con signo (Signed Multiply)
Uso: IMUL src
Flags que modifica: CF OF (AF, PF, SF, ZF indefinidos)
Descripción: Multiplica, considerando el signo, el acumulador (AL o AX) por el operando

fuente, según que el tipo de este operando fuente sea byte o palabra. Si el operando
fuente es de tipo byte, el resultado se almacena en AX. Si el operando fuente es de
tipo palabra, el resultado se almacena en AX (palabra inferior) y DX (palabra
superior).
IN – Entrada de byte o palabra (Input Byte or Word From Port)
Uso: IN accum,puerto

Descripción: Transfiere un byte o una palabra de una puerta de entrada del procesador al
registro AL o AX, respectivamente. El número de la puerta se puede especificar
mediante:
- un valor fijo (de 0 a 255).
- un valor variable, el contenido en el registro DX (de 0 a 65535),
pudiéndose acceder a 64K puertas de entrada.
INC – Incremento (Increment)
Uso: INC dest
Flags que modifica: AF OF PF SF ZF
Descripción: Suma una unidad del operando destino. El operando puede ser byte o palabra.
INT – Interrupción (Interrupt)
Uso: INT num
Flags que modifica: TF IF

Descripción: INT activa el procedimiento de interrupción especificado por el operando. La
dirección del vector de interrupción se calcula multiplicando por 4 el operando, que
es un valor entre 0 y
255. El vector de interrupción se compone de dos palabras: desplazamiento y

segmento. Se bifurca a la dirección especificada por el vector de interrupción,
salvando previamente las banderas y la dirección de retorno (CS, IP).
INTO – Interrupción si desbordamiento (Interrupt on Overflow)
Uso: INTO
Flags que modifica: IF TF
Descripción: Genera una interrupción tipo 4 si existe desbordamiento (overflow), es decir,

si OF=1. En caso contrario se continúa la ejecución con la instrucción siguiente, sin
ejecutar el procedimiento de interrupción.
IRET – Retornar de una interrupción (Interrupt Return)
Uso: IRET
Flags que modifica: AF CF DF IF PF SF TF ZF
Descripción: Devuelve el control a la dirección de retorno salvada en la pila por una

operación de interrupción previa y restaura los registros de banderas. IRET se
utiliza para finalizar un procedimiento de interrupción.
Jxx – Saltos condicionales Conditional Jumps

Instrucció Descripción Condición de salto
JA Saltar si Superior CF=0 y ZF=0
JAE Saltar si Superior o Igual CF=0
JB Saltar si Inferior CF=1
JBE Saltar si Inferior o Igual CF=1 o ZF=1
JC Saltar si hay acarreo CF=1
JCXZ Saltar si CX es cero CX=0
JE Saltar si Igual ZF=1
JG Saltar si Mayor (con signo) ZF=0 y SF=OF
JGE Saltar si Mayor o Igual (con signo) SF=OF
JL Saltar si Menor (con signo) SF != OF
JLE Saltar si Menor o Igual (con signo) ZF=1 o SF != OF
JNA Saltar si No Superior CF=1 o ZF=1
JNAE Saltar si No Superior o Igual CF=1
JNB Saltar si No Inferior CF=0
JNBE Saltar si No Inferior o Igual CF=0 y ZF=0
JNC Saltar si No hay acarreo CF=0
JNE Saltar si No Igual ZF=0
JNG Saltar si No Mayor (con signo) ZF=1 o SF != OF
JNGE Saltar si No Mayor o Igual (con signo) SF != OF
JNL Saltar si No Menor (con signo) SF=OF
JNLE Saltar si No Menor o Igual (con signo) ZF=0 y SF=OF
JNO Saltar si No Overflow (con signo) OF=0
JNS Saltar si Positivo SF=0
JNZ Saltar si No Cero ZF=0
JO Saltar si Overflow (con signo) OF=1
JP /JPE Saltar si Par PF=1
JPO/JNP Saltar si Impar PF=0
JS Saltar si negativo (si hay signo) SF=1
JZ Saltar si cero ZF=1
JCXZ – Bifurcar si CX es cero (Jump if Register CX is Zero)
Uso: JCXZ label
Descripción: Transfiere el control a la instrucción IP + desplazamiento si se cumple la

condición de CX
= 0. Si CX no es 0, no hay transferencia de control. El desplazamiento debe estar

comprendido entre –128 y +127 bytes de esta instrucción, es decir, desplazamiento
es un valor con signo de 8 bits (1 byte).
JMP – Salto incondicional (Unconditional Jump)
Uso: JMP dirección
Descripción: Transfiere el control incondicionalmente a la dirección indicada. El salto

puede ser cercano (dentro del mismo segmento) o lejano (a otro segmento).
LAHF – Cargar AH con banderas (Load Register AH From Flags)
Uso: LAHF
Descripción: Copia las banderas SF, ZF, AF, PF y CF en los bits 7, 6, 4, 2 y 0,

respectivamente del registro AH. Los otros bits quedan indefinidos. El contenido de AH
queda, entonces, así:
AH ← SF ZF xx AF xx PF xx CF
LDS – Cargar registro de segmento de datos (Load Pointer Using DS)
Uso: LDS dest,src
Descripción: Transfiere un puntero de 32 bits (dirección completa compuesta por

desplazamiento y segmento, en este orden) correspondiente al segundo operando
(que debe ser un operando de memoria de doble palabra).
LEA – Cargar dirección efectiva (Load Effective Address)
Uso: LEA dest,src
Descripción: Transfiere el desplazamiento del operando fuente al operando destino. El

operando fuente debe ser un operando de memoria (byte o palabra). El operando
destino es un registro de 16 bits, pero no un registro de segmento. Permite
especificar registros índices en el operando fuente, al contrario que con el operador
OFFSET.
LES – Cargar registro de segmento extra (Load Pointer Using ES)
Uso: LES dest,src
Descripción: Transfiere un puntero de 32 bits (dirección completa compuesta por

desplazamiento y segmento, en este orden) correspondiente al segundo operando
(que debe ser un operando de memoria de doble palabra).
LOCK – Bloquear el bus (Lock Bus)
Uso: LOCK
Descripción: LOCK es un prefijo de un byte que acompaña a una instrucción y que activa
la señal LOCK mientras dicha instrucción se ejecuta; es decir, impide la utilización
del bus por otros procesadores, impidiendo de esta forma el acceso a los recursos
compartidos por éstos. En sistemas de múltiples procesadores con recursos
compartidos es necesario un mecanismo de este tipo para el control del acceso a
estos recursos.
LODS – Cargar cadena (Load String - Byte, Word or Double-)
Uso: LODS src
LO
DS
B
LO
DS
W

Descripción: Transfiere un byte o una palabra de la cadena fuente (direccionada por DS:SI)
al registro acumulador AL o AX. Actualiza el registro SI para que apunte al
siguiente elemento de la cadena a cargar:
- Si el operando es de tipo byte, se transfiere un byte y el registro SI cambia

una unidad.
- Si el operando es de tipo palabra, se transfiere una palabra y el registro SI
cambia dos unidades.
- Si la bandera de dirección es cero (DF=0), SI se incrementa. Si
DF=1, se decrementa (véanse las instrucciones CLD y STD).
En la instrucción LODSB se transfiere el byte DS:(SI) al registro AL. SI se

actualiza en una unidad. En la instrucción LODSW se transfiere la palabra DS:(SI)
al registro AX. SI se actualiza en dos unidades.
El operando especificado en LODS lo utiliza el ensamblador únicamente para

verificar el tipo (byte o palabra) y para ver si se ha especificado un registro de
segmento. LODS mueve realmente el byte o palabra de DS:(SI) al registro AL o
AX, sin usar realmente el operando de la instrucción.
LOOP – Bucle (Decrement CX and Loop if CX Not Zero)
Uso: LOOP label
Descripción: Decrementa el registro contador (CX). Si CX es distinto de cero, entonces IP
= IP + desplazamiento (expandiendo el signo a 16 bits). Si CX es cero, entonces se

ejecuta la siguiente instrucción.
El desplazamiento debe estar comprendido entre -128 y +127 bytes de esta

instrucción, es decir, desplazamiento es un valor con signo de 8 bits (1 byte).
LOOPE/LOOPZ – Bucle si igual / Bucle si cero (Loop While Equal / Loop While Zero)
Uso: LOOPE label
LOOPZ label
Descripción: Decrementa el registro contador (CX). Si ZF = 1 y CX es distinto de cero,

entonces IP = IP + desplazamiento (expandiendo el signo del desplazamiento a 16
bits). Si ZF = 0 o CX = 0, entonces se ejecuta la instrucción siguiente. El
desplazamiento debe estar comprendido ente - 128 y +127 bytes de esta instrucción,
es decir, desplazamiento es un valor con signo de 8 bits (1 byte).
LOOPNZ – Bucle si no cero (Loop While Not Zero)
LOOPNE –Bucle si distinto (Loop While Not Equal)
Uso:LOOPNZ label
LOOPNE label

Descripción: Decrementa el registro contador (CX). Si ZF = 0 y CX es distinto de cero,
entonces IP = IP + desplazamiento (expandiendo el signo del desplazamiento a 16
bits). Si ZF = 1 o CX = 0, entonces se ejecuta la instrucción siguiente.
El desplazamiento debe estar comprendido entre -128 y +127 bytes de esta

instrucción, es decir, desplazamiento es un valor con signo de 8 bits (1 byte).
MOV – Mover (Move Byte
Word)
Uso: MOV dest,src
Descripción: Transfiere un byte o una palabra desde el operando fuente al operando destino.
El operando destino puede ser un registro o un elemento de memoria (byte o

palabra). El operando fuente puede ser un registro, un elemento de memoria o un
valor inmediato. Ambos operandos deben ser del mismo tipo (byte o palabra).
El contenido especificado por el elemento fuente se copia sobre el elemento de

destino, quedando inalterado el elemento fuente
MOVS – Mover cadena (Move String - Byte or Word-)
Uso: MOVS
dest,src
MOVSB
MOVSW
Descripción: Transfiere un byte o una palabra de la cadena fuente (direccionada por SI) en
el segmento de datos a la cadena de destino (direccionada por DI) en el segmento
extra. Actualiza los registros SI y DI para que apunten al siguiente elemento de la
cadena:
Si los operandos son de tipo byte, se transfiere un byte y los registros SI y DI

cambian una unidad. Si los operando son de tipo palabra, se transfiere una palabra y
los registros SI y DI cambian dos unidades.
Si la bandera de dirección es cero (DF = 0), ambos SI y DI se incrementan. Si DF =
1, ambos se decrementan (véanse las instrucciones CLD y STD).
En la instrucción MOVSB, se transfiere el byte DS:[SI] a ES:[DI]. En la instrucción
MOVSW, se transfiere la palabra DS: [SI] a ES: [DI].
Los operandos especificados en MOVS los utiliza el ensamblador únicamente para

segmento. MOVS mueve realmente el byte o la palabra apuntada por DS:[SI] a ES:
[DI], sin usar realmente los operandos de la instrucción.
Cuando se usa con REP, se realiza una transferencia de una cadena completa (de
bytes o de palabras), siendo el número de elementos a mover el especificado en el
registro CX.
En MOVS se puede reasignar el elemento fuente, pero no el destino; es decir, se

puede especificar, por ejemplo,
MOVS DESTINO,ES:FUENTE
En este caso, habría una transferencia de un elemento del segmento, direccionado

por ES, al mismo segmento. Para mover elementos dentro del segmento
direccionado por DS, habría que hacer ES = DS.
MUL – Multiplicar sin signo (Unsigned Multiply)
Uso: MUL src
Flags que modifica: CF OF (AF, PF, SF, ZF indefinidos)
Descripción: Multiplica, sin considerar el signo, el acumulador (AL o AX) por el operando
fuente, según que el tipo de este operando fuente sea byte o palabra. Si el operando
fuente es de tipo palabra, el resultado se almacena en AX (palabra inferior) y DX
(palabra superior). Si la mitad superior del resultado (AH para el caso de operando
tipo byte o DX para el caso de operando tipo palabra) no es cero, se activan las
banderas CF y OF, indicando que esta mitad superior contiene dígitos significativos
del resultado.
NEG – Complemento a dos (Two's Complement Negation)
Uso: NEG dest
Flags que modifica: AF CF OF PF SF Z

Descripción: Calcula el valor negativo del operando, es decir, resta el operando de cero y devuelve
el resultado en el mismo operando (byte o palabra). Para hacer esto, el operando destino se resta del
número compuesto por todo unos y se le añade 1. Esto es lo mismo que el complemento a 2 del
número.
NEG destino es equivalente a las

instrucciones NOT destino
INC destino
NOP – No operación (No Operation -90h-)
Uso: NOP
Descripción: El procesador no hace nada. Pasa a ejecutar la instrucción siguiente.
NOT – No lógico (One's Compliment Negation -Logical NOT-)
Uso: NOT dest
Descripción: Cambia los bits unos por ceros y los bits ceros por unos, es decir, realiza el
complemento a uno del operando y devuelve el resultado en el mismo operando
(byte o palabra).
OR – O lógico inclusivo (Inclusive Logical OR)
Uso: OR dest,src
Descripción: Realiza la operación "o lógico inclusivo" a nivel de bit entre los dos
operandos. El resultado se almacena en destino.
La tabla de la operación OR (para las cuatro combinaciones posibles de bits) es:

Op Op2 Dest
OUT – Salida de byte o palabra (Output Data to Port)
Uso: OUT port,accum
Descripción: Transfiere un byte o una palabra del registro AL o AX a una puerta de salida
del procesador. El número de la puerta se puede especificar mediante:
- un valor fijo (de 0 a 255);
- un valor variable, el contenido en el registro DX (de 0 a 65535),
pudiéndose acceder a 64K puertos de salida.
OUTS – Salida de cadena (Output String to Port) (80188+)
Uso: OUTS
por
t,src
OUTSB
OUTSW
Descripción: Transfiere un byte (OUTSB) o un word (OUTSW) desde src al puerto

especificado. En las instrucciones OUTSB y OUTSW el operando se encuentra en
DS:SI, y el registro SI se incrementa o decrementa con el tamaño del dato leído
según el valor del flag DF.
POP – Quitar palabra de la pila (Pop Word off Stack)
Uso: POP dest

Descripción: Transfiere el elemento (tipo palabra) que se encuentra en lo alto de la pila

(apuntando por el registro SP) al operando destino (tipo palabra), y luego
incrementa en dos el registro SP. El registro CS no se puede especificar como
destino. La instrucción que realiza la función opuesta de POP es PUSH.
POPA – Quitar registros de la pila (Pop All Registers onto Stack) (80188+)
Uso: POPA
Descripción: Transdiere los 8 registros de propósito general desde la pila, en el siguiente

orden: DI; SI; BP; SP, DX, CX y AX.
POPF – Quitar banderas de la pila (Pop Flags off Stack)
Uso: POPF
Flags que modifica: all flags
Descripción: Transfiere bits específicos de la palabra que se encuentra en lo alto de la pila

(apuntado por el registro SP) a las banderas, reemplazando así los valores que
contenían previamente. El registro SP se incrementa luego en 2.
bit 11 -- OF
bit 10 -- DF
bit 9 -- IF
bit 8 – TF
bit 7 – SG
bit 6 – ZF
bit 4 – AF
bit 2 – PF
bit 0 -- CF
La instrucción que realiza la función opuesta de POPF es PUSHF.

PUSH – Poner palabra en la pila (Push Word onto Stack)
Uso: PUSH src
PUSH immed (80188+ only)
Descripción: Decrementa el puntero de la pila (SP) en 2 y luego transfiere la palabra

especificada en el operando fuente a lo alto de la pila (ahora apuntada por el
registro SP). El registro CS no se puede especificar como fuente.
La instrucción que realiza la función opuesta de PUSH es POP.
PUSHA – Poner registros en la pila (Push All Registers onto Stack) (80188+)
Uso: PUSHA
Descripción: Transfiere a la pila los 8 registros de propósito general, en el siguiente orden:

DI; SI; BP; SP, DX, CX y AX.
PUSHF – Poner banderas en la pila (Push Flags onto Stack)
Uso: PUSHF
Descripción: Decrementa el puntero de la pila (SP) en 2 y luego transfiere los valores de

las banderas a bits específicos de la palabra de la pila direccionada por el registro
SP:
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
La instrucción que realiza la función opuesta de PUSHF es POPF.
RCL – Rotar a la izquierda a través del acarreo (Rotate Through Carry Left)
Uso: RCL dest,count
Flags que modifica: CF OF
Descripción: Rotar a la izquierda los bits del operando destino junto con la bandera de
acarreo (CF) el número de bits especificado en el segundo operando.
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.
RCR – Rotar a la derecha a través del acarreo (Rotate Through Carry Right)
Uso: RCR dest,count

Descripción: Rotar a la derecha los bits del operando destino junto con la bandera de acarreo
(CF) el número de bits especificado en el segundo operando.

REP – Repetir operación de cadena (Repeat String Operation)
Uso: REP
Descripción: Hace que la siguiente instrucción de cadena se repita un determinado

número de veces, el especificado en el registro contador (CX).
REP se usa en conjunción con las instrucciones MOVS (mover cadena) y STOS
(almacenar cadena).
REPE y REPZ son idénticas y generan el mismo código (un byte) que REP, pero se
utilizan en las instrucciones CMPS (comparar cadena) y SCAS (explorar cadena),
pero necesitan que ZF
= 1 (es decir, que el resultado de la comparación o exploración haya dado igual o
cero).
REPNE y REPNZ son idénticas y generan el mismo código (un byte). Se utilizan
como (REPE y REPZ) en las instrucciones CMPS y SCAS, pero necesitan que ZF
= 0 (es decir, que el resultado de la comparación o exploración haya dado diferente
o distinto de cero).
En resumen:
Instrucción Función Instrucciones
REPE = REPZ Repetir CX veces mientras ZF = CMPS, SCAS

REPNE, REPNZ Repetir CX veces mientras CMPS, SCAS
Las operaciones repetitivas con cadenas son interrumpibles, es decir, el procesador

reconocerá la interrupción antes de procesar el siguiente elemento. Esta instrucción
genera un byte prefijo. Otros bytes prefijos son:
-· LOCK.
-· especificación de registro de segmento.
Se pueden combinar diferentes prefijos, pero deben desactivarse las interrupciones,

pues la interrupción devuelve el control a la instrucción interrumpida o al prefijo
anterior a esa instrucción.
REPE/REPZ – Repetir operación de cadena si es igual / si cero (Repeat Equal / Repeat
Zero)
Uso: REPE
REPZ
Descripción: (Ver instrucción REP)

REPNE/REPNZ – Repetir operación de cadena si es distinto / si no cero (Repeat Not
Equal / Repeat Not Zero)
Uso: REPE
REPZ
Descripción: (Ver instrucción REP)
RET/RETF – Retornar de un procedimiento (Return From Procedure)
Uso: RET nBytes

RETF nBytes
RETN nBytes
Descripción: Retorna de un procedimiento, previamente invocado mediante CALL,

utilizando como dirección de retorno la dirección salvada en la pila por CALL, que
corresponde a la instrucción siguiente a dicha sentencia CALL.
El ensamblador genera un retorno distinto, según se haya definido el procedimiento:
- Procedimiento definido como NEAR:
En este caso, se quita de la pila una palabra, que corresponde al
desplazamiento de la dirección de retorno. Se genera un retorno dentro del

mismo segmento.
- Procedimiento definido como FAR:
En este caso, se quitan de la pila dos palabras, que corresponden al
desplazamiento (primera palabra) y al segmento (segunda palabra) de la

dirección de retorno. Se genera un retorno a un segmento distinto.
El valor opcional que se especifica en RET es el valor que hay que sumar al registro
SP, con objeto de descartar parámetros. Si los parámetros son direcciones de
memoria, cada parámetro ocupa:
- 1 palabra (desplazamiento), si procedimiento NEAR.
- 2 palabras (desplazamiento y segmento), si procedimiento FAR.
ROL – Rotación a la izquierda (Rotate Left)
Uso: ROL dest,count
Descripción: Rotar a la izquierda los bits del operando destino el número de bits
especificado en el segundo operando. Si el número de bits a desplazar es 1, se
puede especificar directamente. Si es mayor que 1, su valor debe cargase en CL y
especificar CL como segundo operando.
ROR – Rotación a la derecha (Rotate Right)
Uso: ROR dest,count

Descripción: Rotar a la derecha los bits del operando destino el número de bits
especificado en el segundo operando. 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.
SAHF – Almacenar AH en las banderas (Store AH Register into FLAGS)
Uso: SAHF
Flags que modifica: AF CF PF SF ZF
Descripción: Transfiere bits específicos del registro AH a los registro de banderas SF, ZF,
PF y CF.
SF = bit 7
ZF = bit 6
AF = bit 4
PF = bit 2
CF = bit 0
SAL – Desplazamiento aritmético a la izquierda (Shift Arithmetic Left)
Uso: SAL dest,count
Descripción: SHL y SAL realizan la misma operación y son físicamente la mima

instrucción.
Desplaza a la izquierda los bits del operando destino el número de bits especificado
en el segundo operando. Los bits de la derecha se rellenan con cero.
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.
SAR – Desplazamiento aritmético a la izquierda (Shift Arithmetic Right)
Uso: SAR dest,count
Descripción: Desplaza a la derecha los bits del operando destino el número de bits
especificado en el segundo operando. Los bits de la izquierda se rellenan con el bit
del signo del primer operando.
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.
SBB – Restar con acarreo (Subtract with Borrow/Carry)
Uso: SBB dest,src
Descripción: Resta el operando fuente del operando destino. Resta uno si está activada la
bandera de acarreo (CF). El resultado se almacena en el operando destino. Los
operando deben ser del mismo tipo (byte o palabra).
SCAS – Explorar cadena (Scan String -Byte, Word or Doubleword- )
Uso: SCAS string

SCASB
SCASW
Descripción: Sirve para explorar una cadena de bytes o palabras. Para ello realiza la
operación: acumulador (AL o AX)-cadena_destino
afectando a las banderas, pero sin almacenar el resultado. La cadena destino está
direccionada por DI en el segmento extra, o sea, ES:[DI]. Es decir, que se realiza la
operación: acumulador (Al o AX)-ES:[DI]
Actualiza el registro DI para que apunte al siguiente elemento de la cadena:
- Si los operandos son de tipo byte, la resta es a nivel byte (con AL) y el registro DI
cambia una unidad.
- Si los operandos son de tipo palabra, la resta es a nivel palabra (con AX) y el
registro DI cambia dos unidades.
Si la bandera de dirección es cero (DI = O), ambos SI y DI se

incrementan. Si DF = 1, ambos se decrementan (véanse las
instrucciones CLD y STD). En la instrucción SCASB se realiza
la resta entre bytes AL-ES:[DI].
En la instrucción SCASW se realiza la resta entre palabras AX-ES:[DI].
El operando especificado en SCAS lo utiliza el ensamblador únicamente para

segmento. SCAS realiza la operación sin usar realmente el operando de la
instrucción.
Se pueden utilizar los prefijos REPE (REPZ) o REPNE (REPNZ). Se aplican para
realizar una búsqueda de un elemento de la cadena que cumpla alguna condición
determinada. El número de elementos a explorar se especifica en el registro CX.
SHL – Desplazamiento lógico a la izquierda (Shift Logical Left)
Uso: SHL dest,count

Descripción: SHL y SAL realizan la misma operación y son físicamente la mima

instrucción.
Desplaza a la izquierda los bits del operando destino el número de bits especificado
en el segundo operando. Los bits de la derecha se rellenan con ceros. 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.
SHR – Desplazamiento lógico a la derecha (Shift Logical Right)
Uso: SHR dest,count
Descripción: Desplazar a la derecha los bits del operando destino el número de bits
especificado en el segundo operando. Los bits de la izquierda se rellenan con cero.
STC – Poner bandera de acarreo (Set Carry)
Uso: STC
Descripción: Pone a 1 la bandera de acarreo (CF) sin afectar a ninguna otra bandera.
STD – Poner bandera de dirección (Set Direction Flag)
Uso: STD
Flags que modifica: DF
Descripción: Pone a 1 la bandera de acarreo (DF), por lo que en la ejecución de las

instrucciones de manejo de cadenas los registros índices SI y/o DI se auto
decrementan de modo automático:
-· en 1 si el(los) operando(s) son de tipo byte.

-· en 2 si el(los) operando(s) son de tipo palabra.
STI – Poner bandera de interrupción (Set Interrupt Flag -Enable Interrupts-)
Uso: STI
Flags que modifica: IF
Descripción: Pone a 1 la bandera de activación de interrupciones (IF) y activa las

interrupciones enmascarables (las que aparecen sobre la línea INTR del
procesador). Una interrupción pendiente no será reconocida hasta que no se haya
ejecutado la instrucción que sigue a STI.
STOS – Almacenar cadena (Store String -Byte, Word or Doubleword-)
Uso: STOS dest

STOSB
STOSW
STOSD
Descripción: Transfiere un byte o una palabra desde el registro acumulador AL o AX al

operando destino (direccionado por ES:DI). Actualiza el registro DI para que apunte
al siguiente elemento de la cadena a almacenar:
· Si el operando es de tipo byte, se transfiere un byte y el registro DI cambia

una unidad.
· Si el operando es de tipo palabra, se transfiere una palabra y el registro DI
cambia dos unidades.
Si la bandera de dirección es cero (DF = 0), DI se incrementa. Si DF = 1, se

decrementa (véanse las instrucciones CLD y STD).
En la instrucción STOSB se transfiere el registro AL al byte ES:[DI]. DI se
actualiza en una unidad. En la instrucción STOSW se transfiere el registro AX a la
palabra ES:[DI]. DI se actualiza en una unidad. El operando especificado en STOS
lo utiliza el ensamblador únicamente para verificar el tipo (byte o palabra) y para
ver si se ha especificado un registro de segmento. STOS mueve realmente el
registro AL o AX a ES:[DI], sin usar realmente el operando de la instrucción.
Cuando se usa con REP, se puede rellenar una cadena con un valor determinado,
especificándose el número de elementos de la cadena en el registro CX.
SUB – Restar (Subtract)
Uso: SUB dest,src
Descripción: Resta el operando fuente del operando destino. El resultado se almacena en el

operando destino. Los operandos deben ser del mismo tipo (byte o palabra).
TEST – Comparación lógica (Test For Bit Pattern)
Uso: TEST dest,src
Descripción: Realiza la operación "y lógica" a nivel de bit entre los dos operandos, pero el
resultado no se almacena en destino y únicamente se alteran los flags. Tras esta
instrucción se pueden consultar las banderas mediante una instrucción de
bifurcación condicional.
WAIT – Esperar (Event Wait)
Uso: WAIT
Descripción: Esta instrucción, junto con ESC, permiten la comunicación con otros
coprocesadores. WAIT sirve para poner al procesador en estado de espera, estado
que abandona cuando se activa la línea TEST. La línea TEST la activa el
coprocesador cuando está libre o preparado para ejecución. WAIT chequea la línea
TEST a intervalos fijos (cinco intervalos de reloj).
XCHG – Intercambiar (eXCHGange)
Uso: XCHG dest,src
Descripción: Intercambia el contenido entre los dos operandos (tipo byte o palabra).
No pueden utilizarse registros de segmento como operandos.
XLAT – Traducir (Translate)
Uso: XLAT translation-table

Descripción: XLAT realiza un posicionamiento sobre una tabla de bytes para obtener el
valor correspondiente a un índice. El valor de AL se usa como índice
(desplazamiento) sobre la tabla. El valor correspondiente se carga sobre el propio
AL. Se supone que el registro BX apunta al comienzo de la tabla. La longitud
máxima de la tabla es de 256 bytes.
El primer byte de la tabla tiene desplazamiento cero. La tabla debe ser
tipo byte. La mejor Descripción: de esta instrucción es MOV

AL,[BX+AL]
XOR – O exclusiva (Exclusive OR)
Uso: XOR dest,src
Descripción: Operación "o lógico exclusivo" a nivel de bit entre los dos operandos. El
resultado no almacena en destino.
La tabla de la operación XOR (para las cuatro combinaciones posibles de bits) es:
Op1 Op2 Dest
0 0 0
0 1 1
1 0 1
1 1 0
ARQUITECTURA INTEL 8086
Algunas características del Intel 8086
• Procesador de 16 bits
• Bus de direcciones de 20 bits: 1 Mbyte
• Bus de datos interno de 16 bits
• Bus de datos externo de
• 16 bits en el 8086
• 8 bits en el 8088
• Original del IBM PC/XT
• 89 instrucciones
• No tiene coprocesador
El cual maneja los siguientes tipos de datos
• ASCII
• BCD
• Entero sin signo
8 bits 0...255
16 bits 0...65535
• Entero con signo
8 bits -128...127
16 bits -32768...32767
• Cadenas secuencia de bytes o palabras
Que a la vez posee un juego de registros
14 registros de 16 bits
• 4 generales: AX, BX, CX, DX
• 2 índices: SI, DI
• 2 punteros: SP, BP
• 4 segmentos: DS, CS, ES, SS
• 1 estado: Flag
• 1 contador de programa: IP Registro de flags
C: acarreo en la suma y arrastre en la resta
P: paridad del dato (0, impar y 1, par)
A: acarreo auxiliar. Indica el acarreo o arrastre entre los bits 3 y 4
Z: indicación de resultado igual a cero
S: indicador de signo del resultado. 0, positivo y 1, negativo
T: trampa. Habilita la característica de depuración del procesador
I: habilitación de interrupciones de hardware
D: selección de incremento o decremento en los índices
O: sobreflujo
4 Codificación, Debug, EMU8086 (programa: suma, promedio,
ordenamiento)
EMU8086
Emu8086 combina un editor de código fuente avanzado, ensamblador, desensamblador y emulador de
software (Virtual PC) con depurador y tutoriales paso a paso. Este programa es extremadamente útil
para aquellos que recién comienzan a estudiar el lenguaje ensamblador. Compila el código fuente y lo
ejecuta en el emulador paso a paso.
Es muy fácil trabajar con la interfaz visual. Puede ver registros, banderas y memoria mientras se
ejecuta su programa.
La unidad aritmética y lógica (ALU) muestra el trabajo interno del procesador central
unidad (CPU). El emulador ejecuta programas en una PC virtual, esto bloquea completamente su
programa para que no acceda a hardware real, como discos duros y memoria, ya que su código
ensamblador se ejecuta en una máquina virtual, esto hace que la depuración sea mucho más fácil.
El código de máquina 8086 es totalmente compatible con todas las próximas generaciones de
microprocesadores Intel, incluidos Pentium II y Pentium 4, estoy seguro de que Pentium 5 también
admitirá 8086. Esto hace que el código 8086 sea muy portátil, ya que se ejecuta tanto en sistemas
informáticos antiguos como modernos. Otra ventaja del conjunto de instrucciones 8086 es que es
mucho
más pequeño y, por lo tanto, más fácil de aprender.
Codificación
1. Instrucciones principales:
Se pueden clasificar en los siguientes grupos:
1.1. Instrucciones Lógicas:
Son operaciones bit a bit que trabajan sobre octetos o palabras completas:
NOT negación
AND producto lógico
OR suma lógica
XOR suma lógica exclusiva
1.2. Instrucciones aritméticas:
Estas instrucciones son las que realiza directamente el 8086/8088
a. Grupo de adición:
ADD suma
ADC suma con acarreo

AAA ajuste ASCII para la suma
DAA ajuste decimal para la suma
b. Grupo de sustracción:
SUB resta
SBB resta con acarreo negativo

AAS ajuste ASCII para la resta
DAS ajuste decimal para la resta
c. Grupo de multiplicación:
MUL multiplicación
IMUL multiplicación entera
AAM ajuste ASCII para la multiplicación
d. Grupo de división:
DIV división
IDIV división entera

AAD ajuste ASCII para la división
e. Conversiones:
CBW pasar octeto a palabra
CWD pasar palabra a doble palabra
NEG negación
f. Tratamiento de cadenas:
Permiten el movimiento, comparación o búsqueda rápida en bloques de datos:
MOVC transferir carácter de una cadena

MOVW transferir palabra de una cadena
CMPC comparar carácter de una cadena
CMPW comparar palabra de una cadena
SCAC buscar carácter de una cadena
SCAW buscar palabra de una cadena
LODC cargar carácter de una cadena
LODW cargar palabra de una cadena
STOC guardar carácter de una cadena
STOW guardar palabra de una cadena
REP repetir
CLD poner a 0 el indicador de dirección
STD poner a 1 el indicador de dirección
1.3. Instrucciones de Pila:
Una de las funciones de la pila del sistema es la de salvaguardar (conservar) datos (la otra
es la de salvaguardar las direcciones de retorno de las llamadas a subrutinas):
PUSH introducir
POP extraer
PUSHF introducir indicadores
POPF extraer indicadores
1.4. Instrucciones de control del microprocesador:
Hay varias instrucciones para el control de la CPU, ya sea a ella sola, o en conjunción con
otros procesadores:
NOP no operación
HLT parada
WAIT espera
LOCK bloquea
ESC escape
1.5. Instrucciones de Transferencia de Datos:
Estas instrucciones mueven datos de una parte a otra del sistema; desde y hacia la
memoria principal, de y a los registros de datos, puertos de E/S y registros de
segmentación. Las instrucciones de transferencia de datos son las siguientes:
MOV transfiere
XCHG intercambia
IN entrada
OUT salida
XLAT traduce usando una tabla
LEA carga la dirección efectiva

LDS carga el segmento de datos
LES carga el segmento extra
LAHF carga los indicadores en AH

SAHF guarda AH en los indicadores
PUSH FUENTE (sp) fuente
POP DESTINO destino (sp)
1.6. Instrucciones de Interrupción:
STI poner a 1 el indicador de interrupción

CLI borrar el indicador de interrupción
INT interrupción
INTO interrupción por capacidad excedida (desbordamiento)
IRET retorno de interrupción
1.7. Instrucciones de control de bucle:
Las instrucciones de control de bucles son las siguientes:
INC incrementar DEC

decrementar LOOP
realizar un bucle
LOOPZ, LOOPE realizar un bucle si es cero

LOOPNZ, LOOPNE realizar un bucle si no es cero
JCXZ salta si CX es cero
1.8. Instrucciones de Desplazamiento, rotación y adeudos:

Básicamente permiten multiplicar y dividir por potencias de 2
SHL, SAL desplazar a la izquierda (desplazamiento aritmético)
SHR desplazar a la derecha
SAR desplazamiento aritmético a la derecha
ROL rotación a la izquierda
ROR rotación a la derecha
RCL rotación con acarreo a la izquierda

RCR rotación con acarreo a la derecha
CLC borrar acarreo
STC poner acarreo a 1
1.9. Instrucciones de llamado y retorno de subrutinas:
CALL llamada a subrutina
RET retorno al programa o subrutina que llamó
1.10. Instrucciones de prueba, comparación y saltos:
TEST verifica
CMP compara
JMP salta
JE, JZ salta si es igual a cero

JNE, JNZ salta si no igual a cero
JS salta si signo negativo
JNS salta si signo no negativo

JP, JPE salta si paridad par JNP,
JOP salta si paridad impar JO
salta si hay capacidad excedida
JNO salta si no hay capacidad excedida
JB, JNAE salta si por abajo (no encima o igual)

JNB, JAE salta si no está por abajo (encima o igual)
JBE, JNA salta si por abajo o igual (no encima)
JNBE, JA salta si no por abajo o igual (encima)
JL, JNGE salta si menor que (no mayor o igual)

JNL, JGE salta si no menor que (mayor o igual)
JLE, JNG salta si menor que o igual (no mayor)
JNLE, JG salta si no menor que o igual (mayor)
Debug
Usamos el DEBUG para ejecutar el programa en lenguaje de máquina DEBUG.EXE (o

DEBUG.COM) es un programa DOS que permite a los programas de 16 bits que se ejecute una
instrucción a la vez con pausas para buscar en los registros y la memoria.
Ejecutarlo desde la línea de comandos MS-DOS como:

DEBUG name.EXE
Donde nombre es el nombre del archivo ejecutable.
DEBUG tiene una interfaz de usuario de línea de comandos.
Cada línea comienza con una letra clave posiblemente seguida de otra información.
Todos los números están en hexadecimal.
Por lo general, puede omitir los espacios en blanco - a veces es necesario hacerlo.
El "mini-lenguaje ensamblador" en adelante sólo entiende un código op y números hexadecimales y

registrar los nombres - que no entiende las etiquetas del programa.
A continuación, se muestra un resumen de comandos. Las piezas que comienzan con / / son las
explicaciones no parte de los comandos. La notación xxxx representa un número hexadecimal
arbitrario (podría ser menos dígitos).
q / / quit DEBUG
r / / buscar en los registros y la siguiente instrucción a ser ejecutada
/ u / o desmontaje del lenguaje de máquina de nuevo en asamblea.
Sin embargo, note: NO hay etiquetas de dirección. Se dan las direcciones en hexadecimal.
u xxxx / / desmonte a partir de la dirección xxxx
d xxxx / / volcado de memoria en formato hexadecimal y ASCII a partir de la dirección xxxx
t / / Ejecutar una sola instrucción
p / / Trace través de una llamada procedimiento o instrucción int.

g xxxx / / Ejecutar las instrucciones hasta que llegue a la instrucción en la dirección xxxx. Si la
ejecución falla que las instrucciones de su programa pueden salirse de control.
g / / Ejecuta el programa hasta que sale (o nunca). Los valores de registro se muestran no son los que
dan al final de la ejecución de su programa.
r nn / / Donde nn es un nombre de registro. Muestra el valor actual del registro y luego a: Puede
escribir un nuevo valor para el registro y, a continuación, presione ENTRAR. O simplemente se
presiona Enter para salir del valor anterior sin cambios
a / xxxx / Empieza a traducir las líneas de lenguaje ensamblador en ML y poner la instrucción ML por
primera vez en la dirección xxxx. Las líneas siguientes de AL irán a las direcciones de la máquina
posterior. Al pulsar Intro en una línea vacía AL saldrá de este "mini-ensamblador modo".
e xxxx / / Inicia el examen de bytes individuales a partir de la uno a la dirección xxxx. Si escribe un
espacio que pasa al siguiente byte. Si escribe un número hexadecimal, se cambia el byte de edad en lo
que ha escrito. Si se pulsa enter, sale este "examinar" el modo.
NSSS / / ¿Dónde sss es uno o más caracteres ASCII dando un nombre de archivo? Este sss registros
como el nombre de archivo predeterminado.
l / / Esta es la carta de él, NO la de un dígito. Esto carga el archivo con el nombre de archivo
predeterminado en la memoria. Si se trata de un archivo. Exe, que se carga correctamente y establece

las SS, CS e IP para el inicio del programa.
w / / Graba la memoria en el archivo con el nombre de archivo predeterminado. El número de bytes

escritos está dado por la división de entero de 32 bits entre los registros BX y CX. BX es el más alto
en 15 bits, CX es el más bajo en 15 bits. Esto presenta problemas para crear un programa
ejecutable. Se puede utilizar para crear un programa. Com.
Utilizando el emulador de un microprocesador
Si desea cargar el código en el emulador, haga clic en
Emular . Pero también se puede utilizar para cargar ejecutables emuladores incluso si usted no
tiene el código
fuente original. Seleccione Mostrar emulador desde el menú del emulador.

Características del código ensamblador
El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido ya que su
estructura se acerca al lenguaje máquina, es decir, es un lenguaje de bajo nivel.
Los programas hechos, por un programador experto, en lenguaje ensamblador, son generalmente
mucho
más rápidos y consumen menos recursos del sistema (memoria RAM y ROM.)- (utilizados en
programación de juegos)
Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por un
microprocesador ya que, se dispone de instrucciones del CPU que generalmente no están en los
lenguajes de alto nivel.
A continuación, vamos a citar un ejemplo de un programa de operaciones aritméticas básicas en el

lenguaje ensamblador con EMU8086.
.
model small
.stack 64
.data
;declarando variables globales

numero1 db 0
numero2 db 0
suma db 0 resta db
0 multiplicacion db
0 division db 0
modulo db
msjn1 db 10,13, "Ingrese el primer numero= ",'$';ingrese n1
msjn2 db 10,13, "Ingrese el segundo numero= ",'$';ingrese n2
;mensaje para mostrar los resultados
msjnS db 10,13, "La suma es= ",'$'
msjnR db 10,13, "La resta= ",'$'
msjnM db 10,13, "La Multiplicacion es= ",'$'

msjnD db 10,13, "La division es = ",'$'
msjnMod db 10,13, "El modulo es = ",'$'
.code
begin proc far
;direccionamiento del procedimiento
mov ax, @data
mov ds,ax
;solicitar del teclado numero 1
mov ah, 09
lea dx, msjn1
int 21h
mov ah, 01
int 21h
sub al, 30h
mov numero1,al
;solicitar del teclado numero 2
mov ah, 09
lea dx, msjn2
int 21h
mov ah, 01
int 21h
sub al, 30h
mov numero2,al
;operaciones aritmeticas
;SUMA
mov al,numero1
add al,numero2
mov suma,al
;RESTA
mov al,numero1
sub al,numero2
mov resta,al
;MULTIPLICACION
mov al,numero1
mul numero2
mov multiplicacion,al
;DIVISION
mov al,numero1
div numero2
mov division,al
;MODULO
mov al, numero1
div numero2
mov modulo,ah
;Mostrar los mensajes de los resultados
;mostrando la suma
mov ah,09
lea dx,msjnS
int 21h
mov dl,suma
add dl,30h
mov ah,02
int 21h
;mostrando la resta
mov ah,09
lea dx,msjnR
int 21h
mov dl,resta
add dl,30h
mov ah,02
int 21h
;mostrando la multiplicacion
mov ah,09
lea dx,msjnM
int 21h
mov dl,multiplicacion
add dl,30h
mov ah,02
int 21h
;mostrando la division
mov ah,09
lea dx,msjnD
int 21h
mov dl,division
add dl,30h
mov ah,02
int 21h
;mostrando el modulo
mov ah,09
lea dx,msjnMod
int 21h
mov dl,modulo
add dl,30h
mov ah,02
int 21h
;cierre del programa
mov ah,4ch
int 21h
begin endp
end
Esquemático de una PC-XT IBM (INTEL)
· Memoria
· Unidad Aritmético-Lógica ALU ("Arithmetic and Logic Unit”)
· Unidad de Control CU ("Control Unit”)
· Bus interno
· Conexiones con el exterior

4.1 Aplicaciones
Encontramos una especial utilidad del EOG en:
- Diagnóstico de distrofias del Epitelio Pigmentario Retinal:
* Enfermedad de Best
79
5 BIBLIOGRAFIA
 Dario Alejandro, Los microprocesadores 8086 y 8088.
URL: https://www.alpertron.com.ar/8088.HTM
 Universidad de Malaga, Las partes de un PC IBM XT 5160. +Visión. 2018
URL: http://uciencia.uma.es/Coleccion-cientifico-tecnica/Informatica/Galeria/Partes-de-un-PC-
IBM-XT-5160
 Generación de computadoras, American Academy of Tecnologies. 2010
URL: https://www.tecnologia-informatica.com/generaciones-computadoras-sexta-generacion/
 Electronica UNICROM. Historia de la PC. 2014
URL: https://unicrom.com/historia-de-la-pc2/
 Sistema asistencial basado en computador con IBM, Universidad de Oviedo. 2000
URL:
79

PC XT Cruz Ferreyros Layme Polanco

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PC XT Cruz Ferreyros Layme Polanco

Cargado por

Copyright:

Formatos disponibles

Universidad Nacional de San Agustín

Facultad de Producción y Servicios

 Cruz Huachaca, Frank Jhonathan 20170307

El cerebro del ordenador es el procesador. Su función es ejecutar los programas almacenados en la

2 Hardware Computadora Personal PC XT 8088-8086

Figura 1: PC XT 8088 de IBM

 CPU : Intel 8088 (4.77 Mhz)

2.2 Características del procesador 8088/8086

 Arquitectura interna de 16 bits

2.3 Funcionamiento en general

El funcionamiento general de la computadora es ejecutar programas, los cuales están compuesto de

El procesamiento de una instrucción se denomina ciclo de instrucción y se representa en la figura

2.4 Sistema descrito por bloques y por circuitos

La PC XT estaba esencialmente basada en la misma arquitectura de la IBM PC Original. La IBM PC

Figura 3: Diagrama de bloques del PC XT.

 Se aumentó el número de ranuras de expansión a 8.

2.5 Esquemático del sistema completo Sistema de Aplicación.

Figura 4: Diagrama de bloques del EU y BIU.

 AX = Registro acumulador, dividido en AH y AL (8 bits cada uno).

2.6 Muestra de una Mainboard XT con identificación de dispositivos Etiquetado

Figura 5: Mainboard de PC XT con dispositivos.

 AX (Registro Acumulador): Es usado sobre todo en operaciones aritméticas como primer

2.7.2 Registros de Segmento:

2.7.3 Registros de la Pila:

2.7.4 Registros Índices:

 SI (Source index): Se usa como puntero origen en operaciones de desplazamiento de datos

2.7.5 Registros de Instrucción:

2.8 Modos de direccionamiento

Deben sumarse cuatro cantidades: 1

) dirección de segmento, 2) dirección base, 3) una cantidad índice y 4) un desplazamiento.

Figura 6: Generación de dirección física.

2.9.1 Instrucciones de transferencia de datos (No afectan flags)

Pone el valor en el tope del stack.

2.10 Lenguaje máquina, macroensamblador del 8088

2.10.1 ENSAMBLADORES Y MACROENSAMBLADORES:

2.10.2 Macro Ensamblador IBM.-

2.10.3 Macro Ensamblador de Microsoft.-

2.11 Debuger, y simuladores del 8088/8086

El depurador permite detener el programa en:

 Un punto determinado mediante un punto de ruptura.

Durante esa interrupción, el usuario puede:

 Examinar y modificar la memoria y las variables del programa.

 GNU Debugger (gdb)

3 Ensamblador 8088/8086 Hoja de Datos INTEL

AAA – Ajuste ASCII en suma (Ascii Adjust for Addition)

Flags que modifica: AF CF (OF, PF, SF, ZF indefinidos)

Descripción: Corrige el resultado en AL de una suma de dos números decimales

Flags que modifica: SF ZF PF (AF, CF, OF indefinidos)

Descripción: Realiza un ajuste del dividendo en AL antes de hacer la división de dos

AAM – Ajuste ASCII en multiplicación (ASCII Adjust for Multiplication)

Flags que modifica: PF SF ZF (AF, CF, OF indefinidos)

Descripción: Corrige el resultado en AX del producto de dos números decimales

Flags que modifica: AF CF (OF, PF, SF, ZF indefinidos)

Descripción: Corrige el resultado en AL de la resta de dos números decimales

ADC – Sumar con acarreo (Add With Carry)

Uso: ADC dest,src

Flags que modifica: AF CF OF SF PF ZF

ADD – Suma aritmética (Arithmetic Addition)

Uso: ADD dest,src

Descripción: Suma los dos operandos. El resultado se almacena en el operando destino.

Los operandos deben ser del mismo tipo (byte o palabra).

AND – Y lógico (Logical And)

Uso: AND dest,src