Contenido

1. CODIGO MQUINA ......................................................................................................... 3

1.1. Introduccin ................................................................................................................. 3
1.2. Definicin ..................................................................................................................... 4
1.3. Clasificacin del lenguaje mquina ........................................................................... 4
1.4. Codificacin ................................................................................................................. 5
1.5. Intrpretes y ensambladores ...................................................................................... 7
1.6. Ejecucin ...................................................................................................................... 8
1.7. Ventajas del Lenguaje Mquina ................................................................................ 8
1.8. Desventajas del Lenguaje Mquina ........................................................................... 8
1.9. Ejemplo ........................................................................................................................ 8
2. DEBUG ............................................................................................................................... 10
2.1. Uso De Debug ............................................................................................................. 10
2.2. Comandos de Debug.................................................................................................. 10
2.3. Descripcin de comandos debug ............................................................................... 11
2.3.1. Assemble (A) ....................................................................................................... 12
2.3.2. Compare (C) ...................................................................................................... 12
2.3.3. Dump (D) ............................................................................................................ 12
2.3.4. Enter (E) ............................................................................................................. 12
2.3.5. Fill (F) ................................................................................................................. 13
2.3.6. Go (G) ................................................................................................................. 13
2.3.7. Aritmtica Hexadecimal (H)............................................................................. 14
2.3.8. Input (I) .............................................................................................................. 14
2.3.9. Load (L) .............................................................................................................. 14
2.3.10. Move (M) ............................................................................................................ 15
2.3.11. Name (N) ............................................................................................................ 15
2.3.12. Output (O) .......................................................................................................... 15
2.3.13. Quit (Q) .............................................................................................................. 15
2.3.14. Register (R) ........................................................................................................ 15
2.3.15. Search (S) ........................................................................................................... 16
2.3.16. Trace (T)............................................................................................................. 16
2.3.17. Unassemble (U) .................................................................................................. 17
2.3.18. . Write (W) ......................................................................................................... 17
2.4. Error ........................................................................................................................... 17
2.5. Entradas y Salidas ........................................................................................................ 17
3. BIBLIOGRAFIA ..................................................................................................................... 19






















CDIGO MAQUINA Y DEBUG

1. CODIGO MQUINA
1.1.Introduccin
El lenguaje de mquina o cdigo mquina es el sistema de cdigos directamente
interpretable por un circuito microprogramable, como el microprocesador de una
computadora o el microcontrolador de un autmata. Este lenguaje est compuesto por
un conjunto de instrucciones que determinan acciones al ser tomadas por la mquina.
Un programa consiste en una cadena de estas instrucciones ms un conjunto de datos
sobre el cual se trabaja. Estas instrucciones son normalmente ejecutadas en secuencia,
con eventuales cambios de flujo causados por el propio programa o eventos externos. El
lenguaje de mquina es especfico de la arquitectura de la mquina, aunque el conjunto
de instrucciones disponibles pueda ser similar entre arquitecturas distintas.
Los circuitos microprogramables son sistemas digitales, lo que significa que trabajan
con dos nicos niveles de tensin. Dichos niveles, por abstraccin, se simbolizan con
los nmeros 0 y 1, por eso el lenguaje de mquina slo utiliza dichos signos. Esto
permite el empleo de las teoras del lgebra booleana y del sistema binario en el diseo
de este tipo de circuitos y en su programacin.


Ejemplo de cdigos de operacin, que se aplican a los microprocesadores de Intel.
00000101 ADD Sumar al acumular
00101101 SUB Restar al acumular
010000xx INC Incrementar el registro xx
010010xx DEC Decrementar el registro xx
11101011 JMP Saltar incondicional
101110xx MOV Cargar registro xx desde memoria





1.2. Definicin
El CODIGO DE MAQUINA o CDIGO BINARIO es una codificacin de programas
en sistema binario que es el nico que puede ser directamente ejecutado por una
computadora.
Sin embargo, para los seres humanos, programar en sistema binario es molesto y
propenso a errores. Incluso con la abreviatura octal o hexadecimal, es fcil confundir
una cifra con otra y trabajoso acordarse del cdigo de operacin de cada una de las
instrucciones de la mquina.
Por esa razn se inventaron los lenguajes simblicos, que se llaman as porque utilizan
smbolos para representar las operaciones a realizar por cada instruccin y las
direcciones de memoria sobre las que acta.
1.3. Clasificacin del lenguaje mquina
Instrucciones de transferencias de datos: Son aquellas de entrada o lectura y de
salida o escritura. En el caso de las instrucciones de entrada o lectura, se lleva el
dato de entrada o lectura desde la unidad de entrada a la memoria. Si por el
contrario es una instruccin de salida o escritura, se lleva el dato de la memoria a
la unidad de salida.
Instrucciones de tratamiento: Se trata de las instrucciones aritmtico-lgicas y
las de desplazamientos. As como suma de datos, comparaciones.
Instrucciones de flujo de control o de bifurcacin y salto: Las instrucciones de
flujo de control son aquellas instrucciones que alteran el orden secuencial de la
ejecucin de un programa. Tambin hay instrucciones que posibilitan la
interrupcin de la ejecucin o saltar a ejecutar otro programa. Cuando termina
cualquiera de estas instrucciones, el programa contina ejecutndose desde el
punto en el que se interrumpi.
Direccionamiento de lenguaje maquina: Es la forma en cmo se accede a la memoria,
recordamos que un programa no puede ejecutarse sino se encuentra en memoria
principal, la forma de acceder a la memoria depende del microprocesador, pero en
general existen dos tipos de direccionamiento: directo e indirecto.
El direccionamiento directo tambin recibe el nombre de direccionamiento
absoluto y el acceso a las direcciones se hace de manera directa.
El direccionamiento indirecto tambin recibe el nombre de direccionamiento
relativo y se basa a partir de una direccin genrica, generalmente el inicio del
programa.
Para acceder a una direccin relativa se suma a la direccin base el nmero de espacios
de memorias necesarias, e direccionamiento relativo hace a los programas relocalizables
e independientes, si la direccin base es el inicio de la memoria fija el direccionamiento
pasa a ser un variante de direccionamiento absoluto.

1.4.Codificacin
Basndonos en los cdigos definidos anteriormente, iremos definendo las posiciones de
memoria.
Campos:

Instrucciones:

La memoria quedara configurada de la siguiente manera:
Memoria:

Como se puede ver, esto supone un trabajo tremendo, y la facilidad de cometer errores
es evidente. Siguiendo nuestro desarrollo de microprocesador simulado, tenemos que
buscar una manera de facilitar el trabajo, para lo cual vamos a hacer corresponder a cada
instruccin con una secuencia de letras que nos sirva para recordarla y nos de una idea
de la operacin que debe realizar. A esto se le denomina representacin simblica o
cdigo nemotcnico.


Se ver que es ms fcil recordar el cdigo nemotcnico o simblico que los nmeros
de cdigo mquina.
Sigamos simplificando, cuando nos refiramos a los registros en lugar de llamarlos 01 y
10 llamaremos al registro ndice "I" y al registro aritmtico "A".

Por ltimo, cada vez que nos refiramos a una posicin de memoria en lugar de recordar
el valor numrico de su direccin, le daremos un nombre o literal, este literal tiene el
valor de la direccin que representa y se le conoce con el nombre genrico de etiqueta.
Entonces diremos que la representacin simblica de una instruccin es la siguiente:

Codificacin del supuesto en lenguaje simblico:
Campos:

Cuando ponemos el nmero entre parntesis indicamos el contenido del campo, y
cuando se pone el signo "=" nos referimos al valor que tiene el literal. Cualquier
simblico tiene que diferenciar entre direccin y contenido.

Instrucciones:


1.5.Intrpretes y ensambladores
Un intrprete sera un programa que fuera leyendo una a una todas las instrucciones,
pasndolas al cdigo mquina y dndoselas de esa manera al microprocesador para que
las ejecute. Algo as como ocurre con el BASIC.
En un lenguaje ASSEMBLER esto no es rentable, lo que se usa son unos programas
llamados ENSAMBLADORES o COMPILADORES que cogen las instrucciones, las
colocan una detrs de otra en lenguaje mquina, calculan las direcciones relativas de
cada campo o etiqueta y dan como resultado un programa en cdigo mquina que se
llama cdigo objeto. Este programa posteriormente se carga en una posicin de
memoria de la mquina y ese cargador le suma a las direcciones relativas el valor de la
direccin de carga con lo cual tenemos un programa listo para ejecutarse, a este
programa se le llama absoluto. Todos los ensambladores que existen para el Spectrum,
dan como resultado un programa absoluto.
En el supuesto que hemos realizado en una mquina imaginaria, el programa absoluto es
la primera secuencia de nmeros que hicimos.
1.6.Ejecucin
El programa absoluto en cdigo mquina lo ejecuta el microprocesador directamente
segn los siguientes pasos:
Lee instruccin
Incrementa puntero siguiente instruccin
Ejecuta instruccin
Cuando hay una instruccin que modifica la secuencia del programa lo que hace es
modificar el puntero de la siguiente instruccin (de forma equivalente a un GOTO en
BASIC, pero en vez de mandar a un nmero de lnea, manda a una posicin de memoria
apuntada por una etiqueta).
Como se ve, la ejecucin de un programa absoluto no requiere la participacin de
ningn otro programa, como en el caso del BASIC que requiere la actuacin del
programa MONITOR, por lo cual es muchsimo ms rpido.
Tanto el lenguaje de mquina como el simblico hasta aqu visto es imaginario, slo nos
ha valido para la mayor comprensin del tema. Hemos ideado un microprocesador
sumamente sencillo con el fin de que el lector comprendiera fcilmente lo que es un
cdigo mquina. A partir de ahora, nos ceiremos al microprocesador Z-80 de ZILOG,
su repertorio de instrucciones abarca ms de 500, el formato de instruccin no es tan
sencillo como el visto aqu y trabaja sobre posiciones de memoria de 8 bits; no obstante,
los principios bsicos de funcionamiento son los mismos.
1.7. Ventajas del Lenguaje Mquina

Posibilidad de cargar (transferir un programa a la memoria) sin necesidad de
traduccin posterior, lo que supone una velocidad de ejecucin superior a
cualquier otro lenguaje de programacin

1.8.Desventajas del Lenguaje Mquina

Dificultad y lentitud en la codificacin.
Poca fiabilidad.
Gran dificultad para verificar y poner a punto los programas.
Los programas solo son ejecutables en el mismo procesador (CPU).

1.9.Ejemplo

Las ventajas de esto son evidentes, ya que para el hombre resulta ms fcil
manipular grupos de caracteres y la traduccin se hara de manera automtica. Por
ejemplo, se podra escribir:

Esto indicara que el contenido de la posicin 11010110 haba que pasarlo a la
posicin 00011101 si se sabe que al grupo alfabtico ALMACENAR le corresponde
la secuencia de bits 11110101.
La mquina traducira la anterior instruccin como:

A los programas que permiten pasar del programa escrito de esta manera (programa
fuente, en ensamblador) al lenguaje mquina tambin se les denomina normalmente
ensambladores. Estos traductores, como ya se ha dicho, se fueron complicando cada vez
ms para que la labor del programador fuera ms fcil, incluyendo las denominadas
directivas del ensamblador, que son rdenes o informacion que el programador da al
traductor, no instrucciones de lenguaje mquina.
El cdigo mquina, o lenguaje de mquina, est formado por instrucciones sencillas,
que dependiendo de la estructura del procesador pueden especificar:
Registros especficos para operaciones aritmticas, direccionamiento o control
de funciones.
Posiciones de memoria especficas (offset).
Modos de direccionamiento usados para interpretar operandos.
Las instrucciones de mquina o instrucciones del computador son las que determinan el
funcionamiento de la CPU que las ejecuta, la CPU puede realizar una diversidad de
funciones que son el reflejo de la variedad de las instrucciones definidas para dicha
CPU, el programador tiene un repertorio de instrucciones como medio para controlar la
CPU.
Las operaciones ms complejas se realizan combinando estas instrucciones sencillas,
que pueden ser ejecutadas secuencialmente o mediante instrucciones de control de flujo.
Las operaciones disponibles en la mayora de los conjuntos de instrucciones incluyen:
Mover
o Llenar un registro con un valor constante
o Mover datos de una posicin de memoria a un registro o viceversa
o Escribir y leer datos de dispositivos
Computar
o Sumar, restar, multiplicar o dividir los valores de dos registros,
colocando el resultado en uno de ellos o en otro registro
o Realizar operaciones binarias, incluyendo operaciones lgicas
(AND/OR/XOR/NOT)
o Comparar valores entre registros (mayor, menor, igual)
Afectar el flujo del programa
o Saltar a otra posicin en el programa y ejecutar instrucciones all
o Saltar si se cumplen ciertas condiciones (IF)
o Saltar a otra posicin, pero guardar el punto de salida para retornar
(CALL, llamada a subrutinas)

2. DEBUG
El programa Debug.com est presente en casi todas las versiones del sistema operativo
MS-DOS, tambin en Windows en la ventana de ejecucin de comandos. Es un
depurador de aspecto sencillo, pero potente. Posee multitud de poderosas caractersticas,
como mostrar y modificar el valor de los registros de sistema, desensamblar y
ensamblar cdigo mquina, etc. No distingue entre maysculas y minsculas y asume el
formato numrico hexadecimal.
"Bug" significa fallo, defecto en un programa; "debug" significa depurar (escrutar y
eliminar fallos). La palabra ha quedado como verbo (depurar), de la que han derivado
otras. Por ejemplo: "Debugger" (depurador). Por extensin, todos los programas y
utilidades que sirven para escudriar los datos y el cdigo a bajo nivel, se identifican
genricamente con esta denominacin.
2.1.Uso De Debug
Usando DEBUG es posible observar el comportamiento de las instrucciones, la forma
cmo stas afectan a las banderas, los contenidos de la memoria, el cdigo de las
instrucciones; adems permite ensamblar cdigo elemental usando los mnemotcnicos
del 8086.
2.2.Comandos de Debug

ensamblar A [direccin]
comparar C direccin de intervalo
volcar D [intervalo]
escribir E direccin [lista de valores]
llenar F lista de intervalos
ir G [=direccin] [direcciones]
hex H valor1 valor2
entrada I puerto
cargar L [direccin] [unidad] [primer_sector] [nmero]
mover M direccin de intervalo
nombre N [nombre_ruta] [lista_argumentos]
salida O byte de puerto
proceder P [=direccin] [nmero]
salir Q
registrar R [registrar]
buscar S lista de intervalos
seguimiento T [=direccin] [valor]
desensamblar U [intervalo]
escribir W [direccin] [unidad] [primer_sector] [nmero]
asignar memoria expandida XA [#pginas]
desasignar memoria expandida XD [identificador]
asignar pginas de memoria expandida XM [Lpgina] [Ppgina]
[identificador]
mostrar estado de la memoria expandida XS
La mayora de los comandos de debug ejecutan una accin y vuelven al indicador del
shell, pero si es un comando largo, como puede ser mostrar un trozo grande de cdigo,
puede detenerse pulsando CTRL-Pausa o interrumpirse con CTRL-C para volver al
shell.
Una caracterstica poco conocida, es que debug puede aceptar entradas desde un fichero
"Script", que puede ser un simple fichero de texto ASCII en el que cada comando est
separado del anterior por un INTRO. Despus del ltimo, que debe ser una "Q" para
salir de debug, es conveniente dejar una lnea en blanco pulsando INTRO dos
veces. Las lneas pueden contener comentarios. Cualquier cosa a partir del carcter
punto y coma (;) hasta el final de la lnea, ser ignorado.
; esto es un comentario
D ; aqu se mostrar algo...
Suponiendo que tengamos un fichero "Script" de nombre Ordenes.txt, puede ser
utilizado como entrada para debug mediante un comando de redireccin en la siguiente
forma:
DEBUG < Ordenes.txt
Tambin puede conseguirse que el programa redireccione la salida hacia un fichero que
puede ser inspeccionado ms tarde. Aunque tiene la dificultad de tener que trabajar "a
ciegas", puede ser de utilidad en determinadas circunstancias. Por ejemplo, cuando se
desea un volcado de determinadas zonas de la memoria. En el caso anterior podra
obtenerse un fichero Result.txt con el siguiente comando:
DEBUG < Ordenes.txt > Result.txt
2.3.Descripcin de comandos debug

2.3.1. Assemble (A)
El comando A se usa para introducir mnemotcnicos de ensamblador y que stos se
traduzcan directamente a lenguaje de mquina en memoria.
La sintaxis es:
A <direccin>
Prcticamente cualquier mnemotcnico es soportado por DEBUG, incluyendo los
especificadores de "override" de segmento (CS:, DS:, ES:, SS:).
Una excepcin es que DEBUG no puede diferenciar entre NEAR y FAR returns; asume
que RET es "near" y RETF es "far".

2.3.2. Compare (C)
Este comando compara y reporta diferencias entre los contenidos de dos bloques de
memoria.
La sintaxis es:
C <bloque> <direccin>
<bloque> es la direccin de inicio y fin de un bloque o, si se preceden con "L", la
direccin de inicio y la longitud del bloque; <direccin> es el inicio de otro bloque. Se
presupone que la longitud de ambos bloques es la misma.
2.3.3. Dump (D)
Este comando despliega el contenido de una serie de localidades de memoria-
La sintaxis es:
D <direccin1> <direccin2>
Ambas direcciones son opcionales. La 1a es la direccin de inicio de despliegue; la 2a
es la direccin de fin.
2.3.4. Enter (E)
Este comando permite cambiar los contenidos de localidades especficas de memoria.
La sintaxis es:
E <direccin> <cambios>
<direccin> es el inicio de los cambios y <cambios> es una lista opcional de los
cambios deseados. Los cambios pueden ser especificados en la lnea de comandos en
cualquier combinacin de nmeros hexadecimales o caracteres ASCII; los caracteres
ASCII deben estar entre comillas simples o dobles.
Por ejemplo:
E 100 'Buenas Tardes'
Establece el patrn "42 75 65 6E 61 73 20 54 61 72 64 65 73" en memoria a partir de la
localidad
100H. Cuando no se especifica <cambios> se entra en un modo especial en el que
DEBUG despliega los valores de <direccin>. Entonces es posible teclear nuevos
valores que reemplacen a los que se muestran. Si se teclea "-" DEBUG regresa a la
localidad anterior. Si se activa la barra espaciadora DEBUG pasa a la siguiente
localidad.
2.3.5. Fill (F)
Este comando llena un bloque de memoria con un valor especfico o una serie de
valores.
La sintaxis es:
F <bloque> <valor de relleno>
<bloque> es la direccin de inicio y final o , si se preceden con "L", la direccin de
inicio y la longitud del bloque; <valor de relleno> es(son) el(los) valor(es) con los que
debe de llenarse el bloque. Si <valor de relleno> representa menor bytes que los que se
necesitan para llenar el bloque, la serie se repite hasta llenar el bloque.
Por ejemplo, cualquiera de las siguientes dos lneas llena (con 0s) el bloque DS:00FF:
F DS:0000 DS:00FF 0
F DS:0000 LFF 0
2.3.6. Go (G)
Este comando ejecuta el cdigo en memoria. Si se est depurando un programa,
permite ejecutar el cdigo cargado en memoria. Tambin permite establecer puntos de
quiebre
(breakpoints) que son direcciones en las que se detiene la ejecucin del programa.
La sintaxis es:
G =<inicio> <quiebre1> <quiebre2> ... <quiebre10>
<inicio> es la direccin de inicio de ejecucin; <quiebre1> hasta <quiebre10> son
direcciones opcionales de paro del programa. Si no se especifica <inicio>, Go inicia con
la direccin contenida en CS:IP. Para lograr los quiebres, DEBUG reemplaza el cdigo
en las direcciones de quiebre por el valor hexadecimal CC, que es el cdigo de
interrupcin. Si DEBUG llega a CC todos los puntos de quiebre son restituidos, los
registros se despliegan (como con el comando R [vase adelante]) y se para la
ejecucin.
2.3.7. Aritmtica Hexadecimal (H)
Este comando ejecuta restas y suma hexadecimales.
La sintaxis es:
H <valor1> <valor2>
Como resultado de lo anterior, DEBUG regresa dos valores: la suma y la resta de los
argumentos en hexa.
2.3.8. Input (I)
Este comando "jala" un byte de un puerto.
La sintaxis es:
I <puerto>
<puerto> es la direccin del puerto a leer. Se lee el dato y se despliega en pantalla.
2.3.9. Load (L)
Este comando se usa para cargar un archivo o sectores de disco a memoria.
La sintaxis es:
L <buffer> <numdisco> <sectorini> <numsector>
<buffer> es la direccin en donde se carga la informacin; <numdisco> es el nmero
(opcional) del disco de donde se leer la informacin (0=A, 1=B, 2=C, etc.); <sectorini>
es el sector de disco absoluto (en hexadecimal) a leer; <numsector> es la cantidad de
sectores a leer. No se pueden leer ms de 80H (128) sectores. Si no se suministra la
combinacin <numdisco> <sectorini>
<numsector> DEBUG presume que se desea leer un archivo. En este caso <buffer> es
opcional.
Debe usarse el comando N (ver ms adelante) para especificar el archivo a leer. ste se
carga en CS:0100.
2.3.10. Move (M)
Este comando mueve un bloque de memoria de una localidad a otra.
La sintaxis es:
M <bloque> <direccin>
<bloque> es como arriba (ver 2.1.5.); <direccin> es la direccin destino. El bloque de
origen y la direccin destino pueden traslaparse.
2.3.11. Name (N)
Este comando se usa para especificar el nombre del archivo usado por los comandos
LOAD y WRITE. La sintaxis es:
N <nomarch1< <nomarch2>
<nomarch1> es la especificacin de archivo completa que ser "parseada" y colocada en
el bloque de control en CS:005C. <nomarch2> es la especificacin de archivo que ser
colocada en CS:006C.
La expresin tal cual se tecle se almacena en CS:0081, precedida por el nmero de
bytes tecleados.
2.3.12. Output (O)
Este comando pone un byte en el puerto especificado.
La sintaxis es:
O <puerto< <valor>
<valor> es el byte hexadecimal a escribir en <puerto>.
2.3.13. Quit (Q)
Este comando se usa para salir de DEBUG.
2.3.14. Register (R)
Este comando despliega los registros del CPU y los valores de las banderas.
La sintaxis es:
R <registro>
<registro> es el nombre opcional y puede ser alguno de los siguientes: AX, BX, CX,
DX, SP, BP, SI, DI, DS, ES, SS, CS, IP, PC o F. IP y PC son sinnimos.

2.3.15. Search (S)
Este comando permite buscar en un bloque de memoria una secuencia especfica de
valores. La sintaxis es:
S <bloque> <valor_a_buscar>
<bloque> se define como antes (ver la seccin 2_1_1).
<valor_a_buscar> es(son) el(los) valor(es) que deseamos buscar en el bloque.
2.3.16. Trace (T)
Este comando permite ejecucin paso-a-paso de las instrucciones de mquina. Despus
de cada instruccin se muestra el estado de los registros. La sintaxis es:
T =<inicio> <cuenta>
<inicio> es la direccin de inicio de la traza
<cuenta> es el nmero de instrucciones a trazar

2.3.17. Unassemble (U)
Este comando decodifica los valores de un grupo de localidades de memoria a
mnemotcnicos de 8086.
La sintaxis es la siguiente:
U <alcance>
<alcance>, que es opcional, es ya sea un par de direcciones de inicio y fin o, si se
precede con "L", la direccin de inicio y la longitud del rea a desensamblar.
2.3.18. . Write (W)
Este comando se usa para escribir un archivo a sectores individuales de disco a disco.
La sintaxis es:
W <buffer> <numdisco> <sectorini> <numsector>
<buffer> es la direccin de donde se carga la informacin; <numdisco> es el nmero
(opcional) del disco en donde se escribir la informacin (0=A, 1=B, 2=C, etc.);
<sectorini> es el sector de disco absoluto (en hexadecimal) en donde empieza la
escritura; <numsector> es la cantidad de sectores a leer. No se pueden escribir ms de
80H (128) sectores. Si no se suministra la combinacin
<numdisco> <sectorini> <numsector> DEBUG presume que el inicio de archivo es
CS:100. En este caso <buffer> es opcional. Debe usarse el comando N (ver arriba) para
especificar el archivo a escribir.
Antes de escribir BX:CX debe ajustarse al nmero de bytes que desean grabarse.
W no puede escribir a archivos con la extensin EXE o HEX.
Ejemplo:
N <nomarchivo> <cr>
BX:CX <--- 2000 <cr>
W <cr>
2.4. Error
Cuando debug no sabe interpretar un comando, muestra un mensaje de error y un
indicador "^" debajo del sitio del comando donde est el error.
2.5.Entradas y Salidas
DEBUG asume que los datos numricos proporcionados son hexadecimales, y cuando
se trate de direcciones de memoria, deben introducirse en forma segmentada. A su vez,
los resultados son mostrados tambin en formato hexadecimal cuando se refieren a
direcciones de memoria. Cuando se trata simplemente del contenido de ciertas
posiciones de memoria, el resultado es mostrado en formato hexadecimal y en
ASCII. Por ejemplo, una salida puede presentar el siguiente aspecto:

Cada fila muestra 16 posiciones de memoria a partir de la posicin sealada por las
columnas de la izquierda, que las muestran como desplazamiento: segmento. El bloque
central muestra el contenido hexadecimal de cada byte, mientras que el bloque derecho
contiene la representacin ASCII. Por ejemplo, la 5 fila muestra el contenido de las
posiciones 177C:01C0 a 177C:01CF (ambas inclusive). Sus dos ltimos bytes
contienen respectivamente los caracteres 5 y a, que corresponden a las cantidades 35h y
61h del bloque central. Que como sabemos, equivalen a los decimales 53 y 97, que son
precisamente los valores ASCII de los caracteres mencionados.
Por razn de que ste tipo de salida pueda ser listado a impresora, el bloque
derecho no contiene en realidad la representacin ASCII de todos los caracteres
(algunos ni siquiera tienen una representacin imprimible). En realidad solo se
muestran los caracteres imprimibles del primer bloque (US-ASCII). El resto est
representado por un punto.
No perder de vista que, a pesar de que algunas posiciones de memoria puedan contener
valores cuya equivalencia ASCII sea un carcter imprimible. Esto no significa que
dichas posiciones representen efectivamente tales valores para la aplicacin que las
utiliza. Por ejemplo, puede que en realidad, las dos posiciones de memoria mencionadas
(dos octetos), en vez de los caracteres 5 y a, representen una palabra de 16 bits en
formato Little Endian, que a su vez representan una cantidad entera (un nmero).







3. BIBLIOGRAFIA


Lenguaje mquina
http://www.sites.upiicsa.ipn.mx/polilibros/portal/Polilibros/P_terminados/Poli
libroFC/Unidad_III/Unidad%20III_5.htm
Cdigo Mquina: http://www.mastermagazine.info/termino/4330.php
Libro Codigo mquina
http://biblioteca.museo8bits.com/cpc/Codigo%20Maquina%20Para%20Princi
piantes%20Con%20Amstrad%20OCR.pdf
Codigo Mquina: http://curso-cm.speccy.org/contenido/cap1.html
Cdigo
Mquina: http://www.linux10.com.ar/Glosario/terminos/codigo_maquina.ht
m
Libro de Cdigo Mquina
ftp://ftp.worldofspectrum.org/pub/sinclair/books/LibroDelCodigoMaquinaDel
SpectrumEl.pdf
Debug
http://www.abreojosensamblador.net/Productos/AOE/html/Pags/ApC.html
Entradas y salidas http://www.zator.com/Hardware/H1_7_1.htm
Comandos debug http://halcon.webcindario.com/USO%20DEBUG.pdf