Contenido1. CODIGO MÁQUINA........................................................................................................3

1.1. Introducción................................................................................................................3

1.2. Definición....................................................................................................................3

1.3. Clasificación del lenguaje máquina...........................................................................4

1.4. Codificación................................................................................................................4

1.5. Intérpretes y ensambladores......................................................................................7

1.6. Ejecución.....................................................................................................................7

1.7. Ventajas del Lenguaje Máquina................................................................................8

1.8. Desventajas del Lenguaje Máquina..........................................................................8

1.9. Ejemplo.......................................................................................................................8

2. DEBUG.............................................................................................................................10

2.1. Uso De Debug............................................................................................................10

2.2. Comandos de Debug.................................................................................................10

2.3. Descripción de comandos debug...............................................................................11

2.3.1. Assemble (A)......................................................................................................11

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. Aritmética Hexadecimal (H)............................................................................14

2.3.8. Input (I).............................................................................................................14

2.3.9. Load (L).............................................................................................................14

2.3.10. Move (M)...........................................................................................................14

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

CÓDIGO MAQUINA Y DEBUG

1. CODIGO MÁQUINA1.1. Introducción

El lenguaje de máquina o código máquina es el sistema de códigos directamente interpretable por un circuito microprogramable, como el microprocesador de una computadora o el microcontrolador de un autómata. Este lenguaje está compuesto por un conjunto de instrucciones que determinan acciones al ser tomadas por la máquina. Un programa consiste en una cadena de estas instrucciones más 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 máquina es específico de la arquitectura de la máquina, 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 tensión. Dichos niveles, por abstracción, se simbolizan con los números 0 y 1, por eso el lenguaje de máquina sólo utiliza dichos signos. Esto permite el empleo de las teorías del álgebra booleana y del sistema binario en el diseño de este tipo de circuitos y en su programación.

Ejemplo de códigos de operación, 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. Definición

El CODIGO DE MAQUINA o CÓDIGO BINARIO es una codificación 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 fácil confundir una cifra con otra y trabajoso acordarse del código de operación de cada una de las instrucciones de la máquina.

Por esa razón se inventaron los lenguajes simbólicos, que se llaman así porque utilizan símbolos para representar las operaciones a realizar por cada instrucción y las direcciones de memoria sobre las que actúa.

1.3. Clasificación del lenguaje máquina 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 instrucción de salida o escritura, se lleva el dato de la memoria a la unidad de salida.

Instrucciones de tratamiento: Se trata de las instrucciones aritmético-lógicas y las de desplazamientos. Así como suma de datos, comparaciones.

Instrucciones de flujo de control o de bifurcación y salto: Las instrucciones de flujo de control son aquellas instrucciones que alteran el orden secuencial de la ejecución de un programa. También hay instrucciones que posibilitan la interrupción de la ejecución o saltar a ejecutar otro programa. Cuando termina cualquiera de estas instrucciones, el programa continúa ejecutándose desde el punto en el que se interrumpió.

Direccionamiento de lenguaje maquina: Es la forma en cómo 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 también recibe el nombre de direccionamiento absoluto y el acceso a las direcciones se hace de manera directa.

El direccionamiento indirecto también recibe el nombre de direccionamiento relativo y se basa a partir de una dirección genérica, generalmente el inicio del programa.

Para acceder a una dirección relativa se suma a la dirección base el número de espacios de memorias necesarias, e direccionamiento relativo hace a los programas relocalizables e independientes, si la dirección base es el inicio de la memoria fija el direccionamiento pasa a ser un variante de direccionamiento absoluto.

1.4. Codificación

Basándonos en los códigos definidos anteriormente, iremos definendo las posiciones de memoria.

Campos:

Instrucciones:

La memoria quedaría 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

instrucción con una secuencia de letras que nos sirva para recordarla y nos de una idea de la operación que debe realizar. A esto se le denomina representación simbólica o código nemotécnico.

Se verá que es más fácil recordar el código nemotécnico o simbólico que los números de código máquina.

Sigamos simplificando, cuando nos refiramos a los registros en lugar de llamarlos 01 y 10 llamaremos al registro índice "I" y al registro aritmético "A".

Por último, cada vez que nos refiramos a una posición de memoria en lugar de recordar el valor numérico de su dirección, le daremos un nombre o literal, este literal tiene el valor de la dirección que representa y se le conoce con el nombre genérico de etiqueta.

Entonces diremos que la representación simbólica de una instrucción es la siguiente:

Codificación del supuesto en lenguaje simbólico:

Campos:

Cuando ponemos el número entre paréntesis indicamos el contenido del campo, y cuando se pone el signo "=" nos referimos al valor que tiene el literal. Cualquier simbólico tiene que diferenciar entre dirección y contenido.

Instrucciones:

1.5. Intérpretes y ensambladores

Un intérprete sería un programa que fuera leyendo una a una todas las instrucciones, pasándolas al código máquina y dándoselas 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 detrás de otra en lenguaje máquina, calculan las direcciones relativas de cada campo o etiqueta y dan como resultado un programa en código máquina que se llama código objeto. Este programa posteriormente se carga en una posición de memoria de la máquina y ese cargador le suma a las direcciones relativas el valor de la dirección 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 máquina imaginaria, el programa absoluto es la primera secuencia de números que hicimos.

1.6. Ejecución

El programa absoluto en código máquina lo ejecuta el microprocesador directamente según los siguientes pasos:

Lee instrucción Incrementa puntero siguiente instrucción Ejecuta instrucción

Cuando hay una instrucción que modifica la secuencia del programa lo que hace es modificar el puntero de la siguiente instrucción (de forma equivalente a un GOTO en BASIC, pero en vez de mandar a un número de línea, manda a una posición de memoria apuntada por una etiqueta).

Como se ve, la ejecución de un programa absoluto no requiere la participación de ningún otro programa, como en el caso del BASIC que requiere la actuación del programa MONITOR, por lo cual es muchísimo más rápido.

Tanto el lenguaje de máquina como el simbólico hasta aquí visto es imaginario, sólo nos ha valido para la mayor comprensión del tema. Hemos ideado un microprocesador sumamente sencillo con el fin de que el lector comprendiera fácilmente lo que es un código máquina. A partir de ahora, nos ceñiremos al microprocesador Z-80 de ZILOG, su repertorio de instrucciones abarca más de 500, el formato de instrucción no es tan sencillo como el visto aquí y trabaja sobre posiciones de memoria de 8 bits; no obstante, los principios básicos de funcionamiento son los mismos.

1.7. Ventajas del Lenguaje Máquina

Posibilidad de cargar (transferir un programa a la memoria) sin necesidad de traducción posterior, lo que supone una velocidad de ejecución superior a cualquier otro lenguaje de programación

1.8. Desventajas del Lenguaje Máquina

Dificultad y lentitud en la codificación. 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 más fácil manipular grupos de caracteres y la traducción se haría de manera automática. Por ejemplo, se podría escribir:

Esto indicaría que el contenido de la posición 11010110 había que pasarlo a la posición 00011101 si se sabe que al grupo alfabético ALMACENAR le corresponde la secuencia de bits 11110101.

La máquina traduciría la anterior instrucción como:

A los programas que permiten pasar del programa escrito de esta manera (programa fuente, en ensamblador) al lenguaje máquina también se les denomina normalmente ensambladores. Estos traductores, como ya se ha dicho, se fueron complicando cada vez más para que la labor del programador fuera más fácil, incluyendo las denominadas directivas del ensamblador, que son órdenes o informacion que el programador da al traductor, no instrucciones de lenguaje máquina.

El código máquina, o lenguaje de máquina, está formado por instrucciones sencillas, que dependiendo de la estructura del procesador pueden especificar:

Registros específicos para operaciones aritméticas, direccionamiento o control de funciones.

Posiciones de memoria específicas (offset). Modos de direccionamiento usados para interpretar operandos.

Las instrucciones de máquina 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 más complejas se realizan combinando estas instrucciones sencillas, que pueden ser ejecutadas secuencialmente o mediante instrucciones de control de flujo.

Las operaciones disponibles en la mayoría de los conjuntos de instrucciones incluyen:

Movero Llenar un registro con un valor constante

o Mover datos de una posición de memoria a un registro o viceversa

o Escribir y leer datos de dispositivos

Computaro Sumar, restar, multiplicar o dividir los valores de dos registros,

colocando el resultado en uno de ellos o en otro registroo Realizar operaciones binarias, incluyendo operaciones lógicas

(AND/OR/XOR/NOT)o Comparar valores entre registros (mayor, menor, igual)

Afectar el flujo del programao Saltar a otra posición en el programa y ejecutar instrucciones allí

o Saltar si se cumplen ciertas condiciones (IF)

o Saltar a otra posición, 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, también en Windows en la ventana de ejecución de comandos. Es un depurador de aspecto sencillo, pero potente. Posee multitud de poderosas características, como mostrar y modificar el valor de los registros de sistema, desensamblar y ensamblar código máquina, etc. No distingue entre mayúsculas y minúsculas y asume el formato numérico 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 extensión, todos los programas y utilidades que sirven para escudriñar los datos y el código a bajo nivel, se identifican genéricamente con esta denominación.

2.1. Uso De Debug

Usando DEBUG es posible observar el comportamiento de las instrucciones, la forma cómo éstas afectan a las banderas, los contenidos de la memoria, el código de las instrucciones; además permite ensamblar código elemental usando los mnemotécnicos del 8086.

2.2. Comandos de Debug

ensamblar     A [dirección]comparar      C dirección de intervalovolcar        D [intervalo]escribir      E dirección [lista de valores]llenar        F lista de intervalosir            G [=dirección] [direcciones]hex           H valor1 valor2entrada       I puertocargar        L [dirección] [unidad] [primer_sector] [número]mover         M dirección de intervalonombre        N [nombre_ruta] [lista_argumentos]salida        O byte de puertoproceder      P [=dirección] [número]salir         Qregistrar     R [registrar]buscar        S lista de intervalosseguimiento   T [=dirección] [valor]desensamblar  U [intervalo]

escribir      W [dirección] [unidad] [primer_sector] [número]asignar memoria expandida              XA [#páginas]desasignar memoria expandida           XD [identificador]asignar páginas de memoria expandida   XM [Lpágina] [Ppágina] [identificador]mostrar estado de la memoria expandida XS

La mayoría de los comandos de debug ejecutan una acción y vuelven al indicador del shell, pero si es un comando largo, como puede ser mostrar un trozo grande de código, puede detenerse pulsando CTRL-Pausa o interrumpirse con CTRL-C para volver al shell.

Una característica 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.  Después del último, que debe ser una "Q" para salir de debug, es conveniente dejar una línea en blanco pulsando INTRO dos veces.  Las líneas pueden contener comentarios.  Cualquier cosa a partir del carácter punto y coma (;) hasta el final de la línea, será ignorado.

; esto es un comentarioD   ; 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 redirección en la siguiente forma:

DEBUG < Ordenes.txt

También puede conseguirse que el programa redireccione la salida hacia un fichero que puede ser inspeccionado más 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 podría obtenerse un fichero Result.txt con el siguiente comando:

DEBUG < Ordenes.txt > Result.txt

2.3. Descripción de comandos debug

2.3.1. Assemble (A)

El comando A se usa para introducir mnemotécnicos de ensamblador y que éstos se traduzcan directamente a lenguaje de máquina en memoria.

La sintaxis es:

A <dirección>

Prácticamente cualquier mnemotécnico es soportado por DEBUG, incluyendo los especificadores de "override" de segmento (CS:, DS:, ES:, SS:).

Una excepción 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> <dirección>

<bloque> es la dirección de inicio y fin de un bloque o, si se preceden con "L", la dirección de inicio y la longitud del bloque; <dirección> 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 <dirección1> <dirección2>

Ambas direcciones son opcionales. La 1a es la dirección de inicio de despliegue; la 2a es la dirección de fin.

2.3.4. Enter (E)

Este comando permite cambiar los contenidos de localidades específicas de memoria.

La sintaxis es:

E <dirección> <cambios>

<dirección> es el inicio de los cambios y <cambios> es una lista opcional de los cambios deseados. Los cambios pueden ser especificados en la línea de comandos en cualquier combinación de números hexadecimales o caracteres ASCII; los caracteres ASCII deben estar entre comillas simples o dobles.

Por ejemplo:

E 100 'Buenas Tardes'

Establece el patrón "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 <dirección>. 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 específico o una serie de valores.

La sintaxis es:

F <bloque> <valor de relleno>

<bloque> es la dirección de inicio y final o , si se preceden con "L", la dirección 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 líneas 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 código en memoria. Si se está depurando un programa, permite ejecutar el código cargado en memoria. También permite establecer puntos de quiebre

(breakpoints) que son direcciones en las que se detiene la ejecución del programa.

La sintaxis es:

G =<inicio> <quiebre1> <quiebre2> ... <quiebre10>

<inicio> es la dirección de inicio de ejecución; <quiebre1> hasta <quiebre10> son direcciones opcionales de paro del programa. Si no se especifica <inicio>, Go inicia con la dirección contenida en CS:IP. Para lograr los quiebres, DEBUG reemplaza el código en las direcciones de quiebre por el valor hexadecimal CC, que es el código de interrupción. Si DEBUG llega a CC todos los puntos de quiebre son restituidos, los

registros se despliegan (como con el comando R [véase adelante]) y se para la ejecución.

2.3.7. Aritmética 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 dirección 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 dirección en donde se carga la información; <numdisco> es el número (opcional) del disco de donde se leerá la información (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 más de 80H (128) sectores. Si no se suministra la combinación <numdisco> <sectorini>

<numsector> DEBUG presume que se desea leer un archivo. En este caso <buffer> es opcional.

Debe usarse el comando N (ver más 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> <dirección>

<bloque> es como arriba (ver 2.1.5.); <dirección> es la dirección destino. El bloque de origen y la dirección 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 especificación de archivo completa que será "parseada" y colocada en el bloque de control en CS:005C. <nomarch2> es la especificación de archivo que será colocada en CS:006C.

La expresión tal cual se tecleó se almacena en CS:0081, precedida por el número 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 sinónimos.

2.3.15. Search (S)

Este comando permite buscar en un bloque de memoria una secuencia específica de valores. La sintaxis es:

S <bloque> <valor_a_buscar>

<bloque> se define como antes (ver la sección 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 ejecución paso-a-paso de las instrucciones de máquina. Después de cada instrucción se muestra el estado de los registros. La sintaxis es:

T =<inicio> <cuenta>

<inicio> es la dirección de inicio de la traza

<cuenta> es el número de instrucciones a trazar

2.3.17. Unassemble (U)

Este comando decodifica los valores de un grupo de localidades de memoria a mnemotécnicos 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 dirección 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 dirección de donde se carga la información; <numdisco> es el número (opcional) del disco en donde se escribirá la información (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 más de 80H (128) sectores. Si no se suministra la combinación

<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 número de bytes que desean grabarse.

W no puede escribir a archivos con la extensión 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 numéricos proporcionados son hexadecimales, y cuando se trate de direcciones de memoria, deben introducirse en forma segmentada.  A su vez,

los resultados son mostrados también 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 posición señalada 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 representación 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 razón de que éste tipo de salida pueda ser listado a impresora, el bloque derecho no contiene en realidad la representación ASCII de todos los caracteres (algunos ni siquiera tienen una representación 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 carácter imprimible.  Esto no significa que dichas posiciones representen efectivamente tales valores para la aplicación 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 número).

3. BIBLIOGRAFIA

Lenguaje máquina http://www.sites.upiicsa.ipn.mx/polilibros/portal/Polilibros/P_terminados/PolilibroFC/Unidad_III/Unidad%20III_5.htm

Código Máquina: http://www.mastermagazine.info/termino/4330.php Libro Codigo máquina http://biblioteca.museo8bits.com/cpc/Codigo

%20Maquina%20Para%20Principiantes%20Con%20Amstrad%20OCR.pdf Codigo Máquina: http://curso-cm.speccy.org/contenido/cap1.html Código

Máquina: http://www.linux10.com.ar/Glosario/terminos/codigo_maquina.htm

Libro de Código Máquina ftp://ftp.worldofspectrum.org/pub/sinclair/books/LibroDelCodigoMaquinaDelSpectrumEl.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