UNIVERSIDAD LIBRE

FACULTAD INGENIERIA
INGENIERIA DE SISTEMAS
PRACTICA LABORATORIO REGISTROS CPU

Nombre: Operaciones básicas entre registros y dispositivos del sistema utilizando el debug
Duración: Tres horas
Objetivo: Comprender la programación de los registros de una CPU compatible con la arquitectura CISC
INTEL, su capacidad, herramientas disponibles y su relación con el S.O. establecido.

Elementos y Equipos Necesarios

1 Computador personal compatible INTEL arquitectura CISC con DOS de 32 bits, (Win98, Windows XP, Vista, 7 o 10),
con unidad de CD o DVD, o puerto USB o con acceso a internet.

Desarrollo
Para la creación de un programa es necesario seguir cinco pasos. Diseño del algoritmo, codificación de este, su
traducción a lenguaje de máquina. La prueba del programa y su depuración en la etapa de diseño, se plantea el
programa a resolver y se propone la mejor solución, creando diagramas esquemáticos para el mejor planteamiento de
la solución. La codificación del programa consiste en escribir el programa en algún lenguaje de programación, en este
caso específico en ensamblador, tomando como base la solución propuesta en el paso anterior. La traducción a
lenguaje de máquina es la creación del programa objeto solución. El programa tiene como una secuencia de ceros y
unos que puede ser interpretada por el microprocesador. La prueba del programa consiste en verificar que el programa
funcione sin errores, o sea, que haga lo que tiene que hacer. La última etapa es la eliminación de las fallas detectadas
en el programa durante la fase de prueba. La corrección de una falla normalmente requiere la repetición de los pasos
comenzando desde el primero o el segundo.

Para crear un programa en ensamblador existen dos opciones, la primera es utilizar un compilador como el MASM
(Macro Assembler de Microsoft) o el TASM (Macro Assembler de Borland) y la segunda es utilizar el debugger, en
esta primera práctica utilizaremos este último ya que se encuentra en cualquier PC con el sistema operativo MS-
DOS o posterior (Windows), lo cual se pone a nuestro alcance. Debug.exe solo puede crear archivos con extensión
.COM y por las características de este tipo de archivos no pueden ser mayores a 64Kb, además deben comenzar en
el desplazamiento, [0100] o dirección de memoria 0100H dentro del segmento específico. El debugger tiene un
conjunto de comandos que permiten realizar un gran número de operaciones bastante útiles, la siguiente tabla
resume tales comandos:

Comandos de
Significado
Debug.exe
A Ensambla instrucciones simbólicas en código de máquina
C Compara contenidos entre dos áreas de memoria
D Presenta el contenido de un área de memoria
E Introduce datos en memoria comenzando en una posición específica
F Completa un rango con un valor
G Ejecuta el programa en memoria
H Suma y resta dos valores en Hexadecimal
I Asigna puerto de entrada
L Carga programa
M Asigna un valor a un área de memoria
N Pone un nombre al programa
 P Procesa o ejecuta un conjunto de instrucciones relacionadas
Q Sale del debugger
R Presenta el contenido de uno o más registros
S Busca un valor especifico en memoria
T Traza el contenido de una instrucción
U Desensambla código de máquina en código simbólico
W Escribe el programa en el disco

La CPU tiene 14 registros internos, cada uno de 16 bits. Los primeros cuatro AX, BX, CX, DX, son registros de uso
general y también pueden ser utilizados como registros de 8 bits, para utilizarlos como tales es necesario referirse a
una parte de ellos, como por ejemplo: AH y AL, que son los bytes alto (high) y bajo (low) del registro A. Esta
nomenclatura es aplicable también a los registros B, C y D. Los registros son conocidos por sus nombres
específicos:

Registro Nombre del Registro

AX Acumulador
BX Registro Base
CX Registro Contador
DX Registro de Datos
DS Registro del Segmento de Datos
ES Registro del segmento Extra
SS Registro del segmento de Pila
CS Registro del segmento de código
BP Registro de apuntadores base
SI Registro índice fuente
DI Registro índice destino
SP Registro del Apuntador de la Pila
IP Registro de apuntador de siguiente instrucción
F Registro de banderas (Flag)

Es posible visualizar los valores de los registros internos de la CPU utilizando el prompt debug.exe. para empezar a
trabajar con Debug.exe digite en el programa del computador:

C:\> debug [Enter]

En la siguiente línea aparecerá un guion, este es el indicador del Debug.exe, en este momento se pueden introducir
las instrucciones del Debug.exe, utilizando el comando:

- r [Enter]

Se desplegarán todos los contenidos de los registros internos de la CPU, una forma alternativa de mostrarlos es usar
el comando “r” utilizando como parámetro el nombre del registro cuyo valor se quiera visualizar. Por ejemplo:
- r bx

Esta instrucción desplegará únicamente el contenido del registro BX, y cambia el indicador del Debug.exe de “-“ a
“:” Estando así el prompt es posible cambiar el valor del registro que se visualiza tecleando el nuevo valor y
a continuación [Enter] sin teclear ningún valor. Es posible cambiar el valor del registro de banderas, así como
utilizarlo como estructura de control en nuestros programas.
En el lenguaje ensamblador las líneas de código constan de dos partes, la primera es el nombre de la instrucción
que se va a ejecutar y la segunda son los parámetros del comando u operandos. Por ejemplo:

add ah, bh

Aquí “add” es el comando a ejecutar (en este caso una suma) y tanto “ah” como “bh” son los parámetros. El nombre
de las instrucciones en este lenguaje esta formado por dos, tres o cuatro letras, a estas instrucciones también se les
llama comandos o códigos de operación, ya que representan alguna función que habrá de realizar el procesador
(normalmente una abreviación de un nombre en ingles). Existen algunos comandos que no requieren parámetros
para su operación así como otros que requieren solo un parámetro. Algunas veces se utilizan las instrucciones como
sigue:

Add AL, [170]

Los corchetes en el segundo parámetro nos indican que vamos a trabajar con el contenido de la casilla de memoria
numero 170 y no con el valor 170, a esto se le conoce como direccionamiento directo.

En esta primera sesión se trabajará con el Debug del sistema operativo, puede ejecutar cada programa ensamblador
utilizando el comando “g” (go). Como primera medida, cargue el programa Debug.exe de la siguiente forma, en la
ventana del DOS escriba, por ejemplo:

C:\>debug
-a 0100[Enter]
1678:0100 MOV AX,0006
1678:0103 MOV BX,0004
1678:0106 ADD AX,BX
1678:0108 INT 20
1678:010A [Enter]

Miremos que significan cada una de estas líneas:

-a 0100

Para ensamblar un programa en el Debug.exe se utiliza el comando “a” (assembler), cuando se utiliza este comando
se le puede dar como parámetro donde se desea que se inicie el ensamblado, si se omite este parámetro, el
ensamblador se iniciara en la localidad especificada por CS:IP, usualmente 0100H, que es la localidad donde se
deben iniciar los programas con extensión *.COM, y será la localidad que utilizaremos debido a que deb ug.exe solo
puede crear este tipo específico de programas. Aunque en este momento no es necesario darle un parámetro al
comando “a” es recomendable hacerlo para evitar problemas una vez que se haga uso de los registros CS:PI. Al
hacer esto, aparecerá en la pantalla algo como: 1678:0100 y el cursor se posiciona a la derecha de estos números,
nótese que los primeros cuatro dígitos (en sistema hexadecimal) pueden ser diferentes, pero las ultimas cuatro
deben ser 0100, ya que es la dirección que indicamos como inicio. Ahora podemos introducir las instrucciones., no
es necesario escribir los comentarios que van después del “;”, una vez digitado el último comando, Int 20, se le da
[Enter] sin escribir nada mas, para volver al prompt del debugger.
La última línea escrita no es propiamente una instrucción de ensamblador, es una llamada a una interrupción del
sistema operativo. Ahora, escriba el comando g, por ejemplo:

-g [Enter]
El programa ha finalizado con normalidad
Normalmente con un mensaje como este no podemos estar seguros que el programa haya hecho la suma que se le
indicó en este caso, pero existe una forma sencilla de verificarlo, utilizando el comando “r” del Debug.exe podemos
ver los contenidos de todos los registros del procesador simplemente escrita:

-r [Enter]

Aparecerá en pantalla cada registro con su respectivo valor actual:

AX=0006BX=0004CX=0000DC=0000SP=FFEEBP=0000SI=0000DI=0000
DS=0C1BES=0C1BSS=0C1BCS=0C1BIP=010ª NV UP E1 PL NZNAPONC
0C1B:010A OF DB OF

Existe la posibilidad de que los registros contengan valores diferentes, pero AX y BX deben ser los mismos, ya que
son los que acabamos de modificar. Otra forma de ver los valores, mientras se ejecuta el programa es utilizando
como parámetro para “g” la dirección donde queremos que termine la ejecución y muestre los valores de los registros
en este caso sería g 108, esta instrucción ejecuta el programa, se detiene en la dirección 108 y muestra los
contenidos de los registros. También se puede llevar un seguimiento de lo que pasa en los registros utilizando el
comando “t” (trace), la función de este comando es ejecutar línea por línea lo que se ensambla, mostrando cada vez
los contenidos de los registros, para salir del Debug.exe utiliza el comando “q” (quit).

• Guardar y cargar los programas

No sería práctico tener que digitar todo un programa cada vez que se necesite para evitar eso es
posible guardar un programa en el disco, con la enorme ventaja de que ya ensamblado no será
necesario correr de nuevo Debug.exe para ejecutarlo. Los pasos a seguir para guardar un programa
ya almacenado en la memoria son los siguientes:
• Obtener la longitud del programa restando la dirección final de la dirección inicial, naturalmente en
sistema hexadecimal.
• Darle un nombre al programa y extensión.
• Poner la longitud del programa en el registro CX
• Ordenar a Debug.exe que escriba el programa en el disco.

Utilizando como ejemplo el programa anterior tendremos una idea mas clara de cómo realizar estos pasos, al
terminar de ensamblar el programa se vería así:

0C1B:0100 MOV AX,0006

0C1B:0103 MOV BX,0004
0C1B:0106 ADD AX,BX
0C1B:0108 INT 20
0C1B:010A
- h 10a 100
020a 000a
n prueba.com
- r cx
CX 0000
000a
-w
Escribiendo 0000A bytes
Para obtener la longitud de un programa se utiliza el comando “h”, el cual nos muestra la suma y resta de dos
números en hexadecimal. Para obtener la longitud del nuestro, le proporcionamos como parámetros el valor de la
dirección final de nuestro programa (010A) y el valor de la dirección inicial (0100). El primer resultado que nos
muestra el comando es la suma de los parámetros y el segundo es la resta. El comando “n” nos permite poner un
nombre al programa. El comando “r cx” nos permite cambiar el contenido del registro CX al valor que obtuvimos del
tamaño del archivo con “h”, en este caso 000a, ya que nos interesa el resultado de la resta de la dirección inicial a la
dirección final. Por último el comando “w” escribe nuestro programa en el disco indicándonos cuantos bytes escribió.
Para cargar un archivo ya guardado son necesarios dos pasos.

• Proporcionar el nombre del archivo que se cargará

• Cargarlo utilizando el comando “l” (load)
Para obtener el resultado correcto de los siguientes pasos es necesario que previamente se haya creado el
programa anterior. Dentro del Debug.exe escribimos lo siguiente:

- n prueba.com
- l
- u 100 109
- OC3D:0100 B80200 MOV AX,0002
- OC3D:0103 BB0400 MOV BX,0004
- OC3D:0106 01D8 ADD AX,BX
- OC3D:0108 CD20 INT 20

El último comando “u” se utiliza para verificar que el programa se carga en memoria, lo que hace es desensamblar el
código y mostrarlo ya desensamblado. Los parámetros le indican a Debug.exe desde donde y hasta donde
desensamblar. Debug.exe siempre carga los programas en memoria en la dirección 100H, a menos que se le indique
alguna otra dirección.
A continuación se presentan cuatro programas en lenguaje ensamblador, el trabajo a realizar con cada uno de ellos
será el mismo y consistirá en:

• Escribir el programa línea por línea.

• Verificar su correcto funcionamiento
• Escribir el programa al disco duro en un archivo *.COM
• Cargar y ejecutar el programa escrito.

Miremos entonces el primer programa; este simplemente guarda dos valores en dos registros y luego los suma
(ejemplo visto anteriormente), el listado es el siguiente:

- a100
- 297D:0100 MOV AX,0006; Coloca el valor 0006 en el registro AX
- 297D:0103 MOV BX,0004; Coloca el valor 0004 en el registro BX
- 297D:0106 ADD AX,BX; Suma BX al contenido de AX
- 297D:0108 INT 20; Causa el fin de el programa

El segundo programa es el siguiente:

- A 100
- 0C1B:0100 jmp 125; salta a la dirección 125H
 - 0C1B:0102 [Enter]

- a 102 “Hola como estás” ‘0d0a’ ‘s’

- a 125
0C1B:0125 MOV DX,0102; Copia la cadena al registro DX
0C1B:0128 MOV CX,000F; Número de veces que la cadena se presentará
0C1B:012B MOV AH,09; Copia el valor 09 al registro AH
0C1B:012D INT 21; Presenta la cadena
0C1B:012F DEC CX, Reduce en 1 CX
0C1B:0130 JCXZ ,0134; Si CX es igual a 0 salta a 0134
0C1B:0132 JMP,012D; Salta a la dirección 012D
0C1B:0134 INT 20; Termina el programa

El tercer programa se presenta a continuación:

-a 100
297D:0100 MOV AH,01 ; Función para cambiar el cursor
297D:0102 MOV CX,0007; Forma el cursor
297D:0105 INT 10 ; Llamada para el BIOS
297D:0107 INT 20 ; Termina el programa

El cuarto y último programa utiliza la interrupción 21H del S.O. y usa dos funciones:

-a 100
297D:0100 MOV AH,01 ; Función 1 (lee el teclado)
297D:0102 INT 21 ; Llamada para el DOS
297D:0104 CMP AL,0D ; Compara para determinar si lo que lee es un retorno del carro
297D:0106 INZ 0100 ; si no, lee otro carácter
297D:0108 MOV AH,02 ; Función 2 (escribe en la pantalla)
297D:010A MOV DL,AL ; Carácter a escribir en AL
297D:010C INT 21 ; Llamada para el DOS
297D:010E INT 20 ; Fin del programa
(Que hace c/u de ellas y como funcionan?)

Para el informe responda las siguientes preguntas, y realice las tareas propuestas en un documento donde:
1. Identifique, describa y corrija los posibles errores de sintaxis encontrados en cada programa.
2. Con la sintaxis corregida, identifique y describa en forma detallada la operación de cada uno de los cuatro
programas desarrollados.
3. Realice un MAPA CONCEPTUAL (p.e. usando CMAPTOOLS), detallando del funcionamiento de cada uno
de los programas.
4. Diseñe una carpeta con el nombre y apellido del autor e incluya los cuatro archivos *.COM generados en el
laboratorio, asignándoles así mismo su nombre y apellido al nombre de cada archivo, p.e.
norbertonovoa1.com, norbertonovoa2.com, norber………etc., comprimidos en formato .ZIP o .RAR.
5. Elabore el informe en un archivo PDF marcado con su nombre y súbalo a la plataforma Moodle, junto con la
carpeta del punto anterior.

Msc. NORBERTO NOVOA TORRES

Docente Facultad Ingeniería
Universidad Libre