Tutorial assembler en Debug - Rocio Balbin Lazo

Arquitectura y Tecnología de los Computadores. Departamento de Automática. Universidad de Alcalá.

MANUAL BREVE DE “DEBUG” Se trata de una utilidad muy poco amigable, sin menús y -sólo en versiones recientes- con ayuda mínima, pero una vez aprendidos unos cuantos comandos es extremadamente potente. Hay quien lo considera como el mejor programa que ha hecho Microsoft. Debug, invocado sin parámetros, se carga y pasa a mostrar un lacónico guión, a la espera de órdenes del usuario. Todas -a excepción de las relativas a operaciones con memoria expandida, que no se verán aquí- constan de una única letra seguida o no de parámetros. Si se va a desensamblar un programa, se le puede indicar a debug que lo cargue también tras cargarse él escribiendo: debug nombre-del-program nombre-del-programa a argumentos-del-pr argumentos-del-programa ograma

C:\> Debug [Enter] En la siguiente línea aparecerá un guión, éste es el indicador del Debug, en este momento se pueden introducir las instrucciones del Debug. Utilizando los comandos:

A: ASSEMBLE Sin parámetros ensambla las instrucciones que se introduzcan, guardándolas en la dirección siguiente a la que se llegó en el último "a". Cuando se utiliza este comando se le puede dar como parámetro la dirección donde se desea que se inicie el ensamblado, si se omite el parámetro el ensamblado se iniciará en la localización especificada por CS:IP, usualmente 0100H, que es la localización donde deben iniciar los programas con extensión .COM, y será la localización que utilizaremos debido a que debug solo puede crear este tipo específico de programas. También se le puede decir qué zona se desea ver con a pudiendo ser la dirección absoluta (a segmento:desplazamiento) (a segmento:desplazamiento ) o relativa al segmento de código actual (a desplazamiento ). Parámetros: Resultados: se pueden escribir instrucciones en ensamblador a partir de la dirección de memoria CS:, hasta que se pulse INTRO. Si no especificamos el parámetro se toma como dirección de inicio CS:IP Ejemplo: Vamos a usar la instrucción MOV, que como veremos más adelante, sirve para copiar datos de la memoria a los registros y viceversa, además de copiar datos entre registros, que es justo lo que vamos a usar en el ejemplo. -a 2048: 20 48:010 0106 6 mo mov v ax ax,bx ,bx

Laboratorio de Estructura de Computadores

- 1-


2048:010 2048: 0108 8 mo mov v bx bx,cx ,cx 2048:010A -u 106 10 108 8 2048: 20 48:010 0106 6 89 89D8 D8 MO MOV V AX,BX AX,BX 2048: 20 48:010 0108 8 89 89CB CB MO MOV V BX,CX BX,CX

Como veremos más adelante, la instrucción 'U' sirve para hacer volcados de memoria, pero no viendo el contenido de la misma, sino interpretándola como instrucciones en lenguaje ensamblador. ; Ejemplo 2 -r cs CS 20 2048 48 :2050 -a 20 200 0 2050: 20 50:020 0200 0 mo mov v ax ax,bx ,bx 2050:0202 -u 200 20 200 0 2050: 20 50:020 0200 0 89 89D8 D8 MO MOV V AX,BX AX,BX

D: DUMP Muestra el contenido de una zona de memoria en hexadecimal y en ASCII. Sin parámetros muestra los primeros 128 bytes a partir de la posición a la que se llegó en el último "d". Si se le da un rango, mostrará ese rango. Parámetros: ; Dirección de comienzo del volcado [] ; Dirección final del volcado. Resultado: Presenta por pantalla el contenido de las direcciones de memoria entre DS: y DS: ( si no se ha especificado el segundo parámetro, nos hace un volcado desde Ejemplo: -d 100 2048:0100 2048:0110 2048:0120 2048:0130 2048:0140 2048:0150 2048:0160 2048:0170

92 D3 3D 64 00 77 0B 3D-50 00 73 03 05 64 00 05 ..=d.w.=P.s..d.. 6C 07 A3 BF E1 E8 4C 00-B0 08 F8 5F 34 00 37 20 l.....L...._4.7 FF EB F8 33 C0 51 B9 0A-00 80 3C 30 72 12 80 3C ...3.Q....<0r..< 39 77 0D F6 E1 02 04 80-D4 00 2D 2D 30 00 46 EB E9 E9 9w........-0.F.. 59 C3 AC 3A 06 2B E1 74-0E 3C 2F 74 0A 3C 2D 74 Y..:.+.t.<-t 06 3C 2E 74 02 F9 C3 80-3C 30 72 F9 80 3C 39 77 .<.t....<0r..<9w F4 F8 EB F2 50 53 8B 1E-8E 1E-8E D3 B8 C6 DB DB E8 31 FE ....PS........1. 3B 77 09 77 03 5B 58 C3-FF 06 8E D3 8B 1E 8E 8E D3 ;w.w.[X.........


- 2-


-d 100 110 2048:0100 92 D3 3D 64 00 77 0B 3D-50 00 73 03 05 64 00 05 ..=d.w.=P.s..d.. 2048:0110 6C l (NOTA: El contenido de la memoria seguramente no coincide.)

E DIRECCION: EDIT Permite editar, byte por byte, una zona de memoria. Muestra -en hexadecimal- el byte de esa posición y permite escribir otro valor para cambiarlo. Pulsando espacio pasa al byte siguiente, dejando como estaba el anterior si no se ha cambiado, o guardando los cambios si sí se ha hecho. Para terminar la edición se pulsa INTRO. Parámetros: [lista de palabras a escribir] e scribir] Resultados: Se escribe a partir de la dirección de memoria DS: la lista de palabras (dos dígitos hexadecimales) del segundo parámetro. Si no se especifica un segundo parámetro entonces DEBUG no permite introducir palabra a palabra los datos que queramos, a partir de la dirección DS:. Podemos pasar a la palabra siguiente de memoria presionando la tecla ESPACIO, cuando hayamos terminado de introducir los datos que queramos, hay que pulsar INTRO Ejemplo: -e 100 00 01 02 -d 100 10 102 2 2048 20 48: :01 0100 00 00 01 02 .. ... .

; Ejemplo 2 -e 10 100 0 2048: 20 48:010 0100 0 00 00. . 01 01.04 .04 02.05 02.05 64. -d 100 10 103 3 2048 20 48: :01 0100 00 00 04 05 64 .. ...d .d

F: FILL Llena una zona de memoria con un valor determinado. Como al terminar un programa la zona de memoria en que se residía no se borra (poniéndola a cero, por ejemplo), a menudo es útil para distinguir entre lo que son datos del programa actual y lo que es basura del anterior. Parámetros: Parámetros: ; Palabra con la que queremos rellenar Resultados: Rellenamos las direcciones de memoria entre DS: y DS: con el patrón especificado Laboratorio de Estructura de Computadores

- 3-


Ejemplo: -f 100 10 105 5 66 -d 100 10 105 5 2048 20 48: :01 0100 00 66 66 66 66 66 66 ff ffff ffff ff

Ejemplo: -f 100 FFFF 0

Llena de ceros lo que hay desde la posición 100 (hexadecimal) hasta el final del segmento.

G: GO Sin parámetros, empieza a ejecutar desde la posición cs:ip hasta que se acabe el programa. Si la orden es "g "g ", ", la ejecución empieza en cs:ip y termina (debug pone un break point) justo antes de ejecutar la instrucción que se encuentra en . Parámetros: [<=dir_origen>] ( NOTA: HAY QUE INCLUIR EL '=' ) Resultados: se ejecutan instrucciones desde CS: hasta CS:, si no se especifica la dirección origen, se toma como dirección origen CS:IP. Por cierto no se os ocurra ejecutar el comando 'G' a secas, porque podéis parar en alguna instrucción que no tiene sentido o podéis obtener un bonito cuelgue de la ventana MS-DOS o un bloqueo del sistema, si lo estás ejecutando A PANTALLA COMPLETA; a no ser que por casualidades del destino, DEBUG encuentre una int 20h, o cualquier cosa peor. Ejemplo: Vamos a usar una interrupción de MS-DOS para presentar una letra por pantalla, esta subrutina es el servicio 02h de la interrupción 21h, y pasándole como parámetro el valor hexadecimal del carácter ASCII a. -r AX=00 AX =0000 00 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0000 00 SP SP=FF =FFEE EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 IP IP=0 =01 100 NV UP EI PL NZ NA PO NC 2048: 20 48:010 0100 0 92 XC XCHG HG DX DX,AX ,AX -a 10 100 0 20 2048: 48:010 0100 0 mo mov v ax ax,02 ,0200 00 2048: 20 48:010 0103 3 mo mov v dl dl,61 ,61 2048: 20 48:010 0105 5 in int t 21 2048:0107 -g 10 107 7

a AX=02 AX =0261 61 BX=0 BX=0000 000 CX=000 CX=0000 0 DX DX=00 =0061 61 SP SP=FF =FFEE EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 IP IP=0 =01 107 NV UP EI PL NZ NA PO NC


- 4-


2048:010 2048: 0107 7 3D 3D500 5000 0 CM CMP P AX AX,0 ,005 050 0 -g =1 =100 00 107 a AX=02 AX =0261 61 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0061 61 SP SP=FF =FFEE EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 IP IP=0 =01 107 NV UP EI PL NZ NA PO NC 2048: 20 48:010 0107 7 3D 3D500 5000 0 CM CMP P AX AX,0 ,005 050 0

H NUM1 NUM2: HEX Muestra por pantalla el resultado (en hexadecimal) de las operaciones num1+num2 y num1num2. num2. Parámetros: 2 números hexadecimales de 4 dígitos ( máximo ) >" nos devuelve la suma y la resta ( en complemento a dos Uso: la instrucción "H ) de los dos operandos suministrados su ministrados

Resultado: ; Es la suma ( + ), ; es la resta ( - ) Ejemplo: -h 00 0003 03 00 0002 02 0005 00 05 0001 0001 -h 00 0000 00 00 0001 01 0001 00 01 FFFF FFFF

Como se observa, el resultado de la segunda operación es FFFF que es el equivalente en complemento a 2 de -1

L: LOAD [direccion] ion] [unidad [unidad] ] [sector [sector] ] [n sector sectores] es]. Si se le dan todos La sintaxis completa es l [direcc los parámetros lee de la unidad dada, empezando en el sector indicado, tantos sectores como determine "nsectores" y los guarda en la posición de memoria especificada por "dirección". Poniendo sólo l dirección intenta cargar el fichero definido con la orden n (ver abajo) en esa posición.

Parámetros: Resultados: Esta instrucción carga en comenzando en la dirección de memoria DS: el de sectores especificados de la ( NOTA: A= 0, B=1, C=2, ... ) Ejemplo: voy a leer el sector 0 del disco A y lo vuelco a partir de la dirección DS:100, ( ESTO NO QUIERE DECIR QUE OS TENGA QUE SALIR LO MISMO EN VUESTRO VOLCADO )


- 5-


-l 100 0 0 1 -d 100 30 300 0 2048 2048:0 :010 100 0 2048 2048:0 :011 110 0 2048 2048:0 :012 120 0 2048 2048: :0130 0130 2048 2048:0 :014 140 0 2048 2048:0 :015 150 0 2048 2048:0 :016 160 0 2048 2048:0 :017 170 0 2048 2048:0 :018 180 0 2048 2048:0 :019 190 0 2048 2048:0 :01A 1A0 0 2048 2048:0 :01B 1B0 0 2048 2048:0 :01C 1C0 0 2048 2048:0 :01D 1D0 0 2048 2048:0 :01E 1E0 0 2048 2048:0 :01F 1F0 0 2048 2048:0 :020 200 0 2048 2048:0 :021 210 0 2048 2048:0 :022 220 0 2048 2048:0 :023 230 0 2048 2048:0 :024 240 0 2048 2048:0 :025 250 0 2048 2048:0 :026 260 0 2048 2048:0 :027 270 0 2048 2048:0 :028 280 0 2048 2048:0 :029 290 0 2048 2048:0 :02A 2A0 0 2048 2048: :02B0 02B0 2048 2048:0 :02C 2C0 0 2048 2048: :02D0 02D0 2048 2048:0 :02E 2E0 0 2048 2048:0 :02F 2F0 0 2048:03 2048:0300 00

EB 02 00 4D FA 1E F3 F9 66 46 03 8B 8B 3B 75 74 BE CD 48 B1 00 33 F2 13 03 72 72 62 72 61 53 00 BE

3E E0 00 45 33 56 A4 FB 16 FC C3 FB 76 FB 99 09 81 19 8A 04 02 D2 8A 59 18 72 20 69 65 20 59 57 .

90 00 00 20 C9 16 06 38 03 89 48 B1 3E 72 BE B4 7D BE 4E E8 42 F7 56 5A 01 65 45 65 73 20 53 49

29 40 00 20 8E 55 1F 66 46 56 F7 01 F3 E5 80 0E EB 82 0D 16 4A 76 24 58 27 63 2F 20 69 20 4D 4E

79 0B 00 20 D1 BF BD 24 1C FE F3 E8 A6 EB 7D BB E0 7D F7 00 75 18 8A 72 0D 74 53 65 6F 20 53 42

3B F0 00 20 BC 22 00 7C 13 B8 01 94 5E D7 AC 07 33 8B E1 5B 9F 91 E8 09 0A 6F 20 6C 6E 0D 44 4F

46 09 29 46 FC 05 7C 04 56 20 46 00 74 2B 98 00 C0 7D 03 72 EA F7 D0 40 44 20 20 20 65 0A 4F 4F

5D-4 5D-49 9 00-1 00-12 2 5D-4 5D-46 6 41-5 41-54 4 7B-1 7B-16 6 89-7 89-7E E C6-4 C6-45 5 CD-1 CD-13 3 1E-0 1E-03 3 00-8 00-8B B FC-1 FC-11 1 72-4 72-47 7 4A-4 4A-4E E C9-B C9-B8 8 03-F 03-F0 0 CD-1 CD-10 0 CD-1 CD-16 6 0F-8 0F-83 3 46-F 46-FC C C8-8 C8-81 1 00-0 00-02 2 76-1 76-18 8 CC-D CC-D0 0 75-0 75-01 1 69-7 69-73 3 20-20 20-20 20-20 20-20 64-6 64-69 9 20-75 20-75 00-4 00-49 9 53-20 53-20 54-2 54-20 0

48 00 DB 31 07 00 FE 72 46 76 4E 38 74 D8 AC EB 5E FF 13 3F 70 42 CC 42 63 FF 20 73 6E 4F 20 53

43 02 1C 32 BD 89 0F 3C 0E 11 FE 2D 0B 7D 84 EE 1F 02 56 4D 00 87 0A 03 6F 0D FF 63 61 20 20 59

00 00 4E 20 78 4E 8B 8A 13 F7 5A 74 03 87 C0 BE 8F 72 FE 5A 50 CA CC 5E 20 0A 0D 6F 20 20 53 53

02 00 4F 20 00 02 46 46 D1 E6 58 19 F9 46 74 83 04 C8 BB 75 52 F7 B8 0B 69 45 0A 20 74 20 59 00

01 00 20 20 C5 B1 18 10 50 8B BB B1 83 3E 17 7D 8F 8B 00 A7 51 76 01 E2 6E 72 43 79 65 20 53 00

01 00 4E F1 76 0B 88 98 52 5E 00 0B C7 3C 3C EB 44 C7 07 81 91 1A 02 CC 63 72 61 20 63 20 80 55

00 00 41 7D 00 FC 45 F7 89 0B 07 56 15 D8 FF E5 02 48 53 BF 92 8A CD C3 6F 6F 6D 70 6C 20 01 AA

.>.) .>.)y; y;F] F]IH IHC. C... .... .. ...@ ...@.. .... .... .... .... .... .. .... ...... ..)] )]F. F..N .NO O NA ME FAT12 FAT12 .} .3.. .3.... ...{ .{.. ...x .x.. ..v. v. .V.U .V.U." .".. ..~. ~..N .N.. .... .. .... ...... ..|. |.E. E... ..F. F..E .E ..8f ..8f$| $|.. ...r .r<. <.F. F... .. f..F f..F.. ..V. V..F .F.. ...P .PR. R. F..V F..V.. .. ..v.. ..v.... ..^. ^. ..H. ..H... ..F. F..N .N.Z .ZX. X... .. .... ...... ...r .rG8 G8-t -t.. ...V .V .v>. .v>..^ .^tJ tJNt Nt.. .... .... .. ;.r. ;.r... ..+. +... ..}. }.F> F><. <. u... u...}. }... .... .... ..t. t.<. <. t... t..... .... .... .... ...} .}.. .. ..}. ..}..3 .3.. ...^ .^.. .... ..D. D. .... ....}. }.}. }... ...r .r.. ...H .H H.N. H.N... ...F .F.. ..V. V... ...S .S .... .....[ .[r. r..? .?MZ MZu. u... .. ..BJ ..BJu. u... ...p .p.P .PRQ RQ.. .. 3..v 3..v.. ...v .v.B .B.. ...v .v.. .. ..V$ ..V$.. .... .... .... .... .... .. .YZX .YZXr. r.@u @u.B .B.^ .^.. .... .. ...' ...'.. ..Di Disc sco o inco inco rrec rrecto to ...Er ...Erro ro r E/S E/S ...C ...Cam am bie bie el disc disco o y p resi resion one e una una tecl tecl a ...IO ..IO SYSM SYSMSD SDOS OS SYS.. SYS.. .WIN .WINBO BOOT OT SYS. SYS..U .U. .

M RANGO DIRECCION: MOVE Mueve la zona de memoria delimitada por "rango" a la dirección "dirección "dirección". ".

N NOMBRE: NAME Da un nombre de fichero sobre el que actúan l y w. P: STEP Trace puede ser incómodo si no se quiere depurar el código de las rutinas de interrupción , o si ya se sabe el código que hay en las subrutinas y tan sólo interesa seguir avanzando sin entrar en ellas. En estos casos se usa p usa p.. Parámetros: <=dir_origen> Resultados: es como el comando 'T' sin embargo si llamamos a una subrutina y usáramos el comando 'T' entraríamos dentro del código de la subrutina, por lo que si ejecutamos una interrupción de MS-DOS no sabríamos que estamos haciendo Ejemplo:


- 6-


-r AX=02 AX =0261 61 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0061 61 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 2048: 20 48:010 0107 7 3D 3D500 5000 0 CM CMP P AX AX,0 ,005 050 0 -a 10 100 0 2048:01 2048:0100 00 mov ax,020 ax,0200 0 2048: 20 48:010 0103 3 mo mov v dl dl,61 ,61 2048: 20 48:010 0105 5 in int t 21 2048:0107 -p =100 3 AX=02 AX =0200 00 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0061 61 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 2048: 20 48:010 0103 3 B2 B261 61 MO MOV V DL,61 DL,61 AX=02 AX =0200 00 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0061 61 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 2048: 20 48:010 0105 5 CD CD21 21 IN INT T 21 a AX=02 AX =0261 61 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0061 61 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 2048: 20 48:010 0107 7 3D 3D500 5000 0 CM CMP P AX AX,0 ,005 050 0

SP=FFEE SP=FF EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 IP=0 IP =01 107 NV UP EI PL NZ NA PO NC

SP=FFEE SP=FF EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 IP=0 IP =01 103 NV UP EI PL NZ NA PO NC SP=FFEE SP=FF EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 IP=0 IP =01 105 NV UP EI PL NZ NA PO NC

SP=FFEE SP=FF EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 IP=0 IP =01 107 NV UP EI PL NZ NA PO NC

Q: QUIT Salir de debug y volver al DOS.

R: REGISTERS Sin parámetros, muestra el contenido de los registros de la CPU, así como la próxima instrucción a ejecutar. r registro muestra el contenido del registro especificado y cambia el prompt de "-" a ":" invitando a que se cambie su valor. Pulsando Enter sin más lo deja como estaba. Parámetros: [registro] Resultado: Si especificamos un registro, DEBUG nos permite modificar el contenido de ese registro, si no lo hemos especificado, nos presenta por pantalla el contenido de los registros principales del procesador, además nos muestra la instrucción apuntada por CS:IP Registro de flags: Para poder cambiar el registro de flags, hay que usar el comando aparecerá algo tal que así:

" H F"

y

NV UP EI PL NZ NA PO NC - ; meter aquí una lista de los indicadores que se

quieran.


- 7-


Desbordamiento ( si/no) Poner: OV Quitar: NV Direccion(reducción / incremento) poner: DN quitar UP Interrupción(activar/desactivar) poner: EI quitar: DI Signo (negativo / positivo) poner: NG quitar: PL Cero ( sí / no) poner: ZR quitar: NZ Acarrero Auxiliar ( sí / no ) poner: AC quitar: NA Paridad ( par / impar ) poner: PE quitar: PO Acarreo (sí / no ) poner: CY quitar: NC Ejemplo: -r AX=00 AX =0000 00 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0000 00 SP SP=FF =FFEE EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 IP IP=0 =01 100 NV UP EI PL NZ NA PO NC 2048: 20 48:010 0100 0 92 XC XCHG HG DX DX,AX ,AX

; Ejemplo 2 -r ax AX 00 0000 00 :01 -r AX=00 AX =0001 01 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0000 00 SP SP=FF =FFEE EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 IP IP=0 =01 100 NV UP EI PL NZ NA PO NC 2048: 20 48:010 0100 0 92 XC XCHG HG DX DX,AX ,AX

S: SEARCH


- 8-


Busca una secuencia de bytes o una cadena en el rango especificado, mostrando la dirección en que aparece en pantalla. s 100 500 cd 13 Busca todas las llamadas a la interrupción 13h 100:0 0 ffff ffff "vir "virus us" " muestra las zonas de memoria del segmento (código máquina cdh 13h). s 100: 100h en que aparece la palabra "virus".

T: TRACE Ejecuta la instrucción apuntada por cs:ip y vuelve a debug. Permite ejecutar paso a paso un programa y observar en cada instrucción instrucción el efecto producido. Si haciendo "trace" se se llega a una subrutina (CALL) o a una interrupción (INT) la siguiente instrucción que se ejecutará será la primera de la subrutina o la primera de la rutina de atención de la interrupción correspondiente. Parámetros: [< =dirección>] ; Dirección a partir de la cual se quiere que se tracee (OJO: HAY QUE PONER EL '=' ) ; Número de instrucciones que hay que ejecutar Resultados: se ejecutan las instrucciones a partir de CS: ( si se ha especificado ) o se ejecutan a partir de CS:IP, si no se especifica el parámetro se ejecuta una única instrucción Ejemplo: -r AX=00 AX =0000 00 BX BX=0 =0000 000 CX=000 CX=0000 0 DX DX=00 =0000 00 SP SP=FF =FFEE EE BP BP=0 =0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 IP IP=0 =01 100 NV UP EI PL NZ NA PO NC 2048: 20 48:010 0100 0 3D 3D000 0000 0 CM CMP P AX AX,0 ,000 000 0 -r bx BX 00 0000 00 :2 -a 10 100 0 2048: 20 48:010 0100 0 mo mov v ax ax,bx ,bx 2048:0102 -t AX=00 AX =0002 02 BX BX=0 =0002 002 CX=000 CX=0000 0 DX DX=00 =0000 00 SP SP=FF =FFEE EE BP BP=0 =0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 IP IP=0 =01 102 NV UP EI PL NZ NA PO NC 2048:01 2048:0102 02 00AC01D 00AC01D8 8 ADD [SI+D80 [SI+D801],C 1],CH H DS:D80 DS:D801=7 1=74 4 ; Ej Eje emp mplo lo 2 -r AX=00 AX =0000 00 BX BX=0 =0007 007 CX=000 CX=0000 0 DX DX=00 =0000 00 SP SP=FF =FFEE EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 IP IP=0 =01 100 NV UP EI PL NZ NA PO NC 2048: 20 48:010 0100 0 3D 3D000 0000 0 CM CMP P AX AX,0 ,000 000 0 -a 10 100 0 2048: 20 48:010 0100 0 mo mov v ax ax,bx ,bx 2048: 20 48:010 0102 2 mo mov v cx cx,bx ,bx


- 9-


2048:0104 -t 2 AX=00 AX =0007 07 BX BX=0 =0007 007 CX=000 CX=0000 0 DX DX=00 =0000 00 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 2048: 20 48:010 0102 2 89 89D9 D9 MO MOV V CX,BX CX,BX AX=00 AX =0007 07 BX BX=0 =0007 007 CX=000 CX=0007 7 DX DX=00 =0000 00 DS=2 DS =20 048 ES= S=2 204 048 8 SS SS= =20 2048 48 CS CS=2 =204 048 8 2048: 20 48:010 0104 4 01 01D8 D8 AD ADD D AX,BX AX,BX

SP=FFEE SP=FF EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 IP=0 IP =01 102 NV UP EI PL NZ NA PO NC SP=FFEE SP=FF EE BP=0 BP=0000 000 SI SI=0 =0000 000 DI=000 DI=0000 0 IP=0 IP =01 104 NV UP EI PL NZ NA PO NC

U : UNASSEMBLE Desensambla una zona de memoria. Si no se le dan parámetros empieza a hacerlo en la dirección apuntada por cs:ip. También se le puede decir qué zona se quiere ver con u pudiendo ser la dirección absoluta (u (u segmento:desplazamiento) segmento:desplazamiento ) o relativa al segmento de código actual (u (u desplazamiento). desplazamiento ). 1000 2000 2000 desensambla el código Si se da un rango de direcciones desensamblará esa zona: u 1000 que haya desde cs:1000 a cs:2000. Todos los números son tratados como hexadecimales, así que u 1000 empieza a desensamblar desde la posición 4096 (decimal) del segmento de código.

Parámetros: [] Resultados: se desensamblan las direcciones de memoria a partir de CS: hasta CS: ( es opcional ) Ejemplo: -u 100 11 11e e 2050: 20 50:010 0100 0 74 7403 03 JZ 01 0105 05 2050: 20 50:010 0102 2 E9 E97F0 7F00 0 JM JMP P 01 0184 84 2050:01 2050:0105 05 8B4EFA 8B4EFA MOV CX,[BP CX,[BP-06 -06] ] 2050: 20 50:010 0108 8 E3 E303 03 JC JCXZ XZ 010D 010D 2050: 20 50:010 010A A B9 B9020 0200 0 MO MOV V CX CX,0 ,000 002 2 2050: 20 50:010 010D D 83 83C10 C108 8 AD ADD D CX CX,+ ,+08 08 2050: 20 50:011 0110 0 B8 B8287 2871 1 MO MOV V AX AX,7 ,712 128 8 2050 20 50:0 :011 113 3 50 PU PUSH SH AX 2050 20 50:0 :011 114 4 51 PU PUSH SH CX 2050:01 2050:0115 15 9A1A025 9A1A025D2F D2F CALL CALL 2F5D:021 2F5D:021A A 2050: 20 50:011 011A A 0B 0BC0 C0 OR AX AX,AX ,AX 2050: 20 50:011 011C C 74 7463 63 JZ 01 0181 81 2050:01 2050:011E 1E 8B3E2A7 8B3E2A71 1 MOV DI,[712 DI,[712A] A]

; Ejemplo 2


- 10-


-u 10 100 0 2050: 20 50:010 0100 0 2050: 20 50:010 0102 2 2050:01 2050:0105 05 2050: 20 50:010 0108 8 2050: 20 50:010 010A A 2050: 20 50:010 010D D 2050: 20 50:011 0110 0 2050 20 50:0 :011 113 3 2050 20 50:0 :011 114 4 2050:01 2050:0115 15 2050: 20 50:011 011A A 2050: 20 50:011 011C C 2050:01 2050:011E 1E

7403 JZ 01 7403 0105 05 E97F0 E9 7F00 0 JM JMP P 01 0184 84 8B4EFA 8B4EFA MOV CX,[BP CX,[BP-06 -06] ] E303 E3 03 JC JCXZ XZ 010D 010D B9020 B9 0200 0 MO MOV V CX CX,0 ,000 002 2 83C10 83 C108 8 AD ADD D CX CX,+ ,+08 08 B8287 B8 2871 1 MO MOV V AX AX,7 ,712 128 8 50 PU PUSH SH AX 51 PU PUSH SH CX 9A1A025 9A1A025D2F D2F CALL CALL 2F5D:021 2F5D:021A A 0BC0 0B C0 OR AX AX,AX ,AX 7463 74 63 JZ 01 0181 81 8B3E2A7 8B3E2A71 1 MOV DI,[712 DI,[712A] A]

W: WRITE La sintaxis completa es w [dirección] [unidad] [sector] [n sectores] Con todos los parámetros escribe en la unidad y sectores dados el contenido de la dirección de memoria. Pasándole sólo la dirección escribe en el fichero definido con n tantos bytes como determinen el par de registros BX:CX a partir de la posición de memoria dada.

?: AYUDA? En versiones recientes de MS-DOS (por lo menos a partir de la 5) muestra una mini-ayuda.

Existen algunas órdenes más para tratar con memoria expandida y otras operaciones que no serán de especial relevancia para el tema que nos ocupa. Es posible cambiar el valor del registro de banderas, así como utilizarlo como estructura de control en nuestros programas como se verá mas adelante. Cada bit del registro tiene un nombre y significado especial, la lista dada a continuación describe el valor de cada bit, tanto apagado como prendido y su relación con las operaciones del procesador: Overflow NV = no hay desbordamiento; OV = sí lo hay Direction UP = hacia adelante; DN = hacia atras; Interrupts DI = desactivadas;


- 11-


EI = activadas Sign PL = positivo; NG = negativo Zero NZ = no es cero; ZR = sí lo es Auxiliary Carry NA = no hay acarreo auxiliar; AC = hay acarreo auxiliar Parity PO = paridad non; PE = paridad par; Carry NC = no hay acarreo; CY = Sí lo hay

Para asentar ideas y de paso aprender algunos pasos útiles a los que se hará referencia varias veces, unos ejemplos.

Ej e m p l o c o m p l e t o : Escribir y comprobar un programa que imprime el contenido del puerto 378h como numero hexadecimal. Las entradas del operador son en negrita. Los comentarios son en latina (no les consideras como entrada):

C:\>debug Como pedir ayuda de DEBUG – entrar ?. -a100

Assembly a partir de CS:100 No utilizar las direcciones CS:0 – CS:100 – en estas direcciones se encuentran los PSP y COM del programa.

106E:0100 mov dx,378 106E:0103 in al,dx 106E:0104 call 140

Todos los números en DEBUG son en HEX.

Tal como no hay etiquetas tenemos que utilizar direcciones absolutas. En este punto necesitamos un programa que convierte el AL en una cadena de caracteres (dígitos hex). 106E:0107 int 3 Este es un punto de parada (interrupción del programa, breakpoint). Lo entramos a mano (notar que no utilizamos mov AX,4c00// int 21 o int 20). Se utiliza int 3 porque ocupa solo un byte y puede remplazar cualquier instrucción .


- 12-


106E:0108

Salimos del ensamblador con entrada de una línea vacía.

-a104

Ensamblador de nuevo a partir de la dirección 104 (mirar arriba)

106E:0104 mov di,200 106E:0107 call 140

; seria la dirección donde se encuentra la cadena de salida. ; el programa que convierte AL a cadena de dos caracteres

106E:010A mov dx,200 106E:010D mov ah,9 106E:010F int 21 106E:0111 int 3

; Escribimos en CON: “sea lo que sea CON:”

; La parada cómoda de DEBUG. Por la diferencia de INT 20h escribe el contenido de los registros.

106E:0112 -a140 ; Esto seria el programa de conversión de AL en HEX 106E:0140 cld 106E:0141 call 143 ; Supongamos que a partir de la siguiente instrucción instrucció n hay un programa que convierte la parte alta de al a carácter ASCII (HEX). Calculamos y es erróneo , la dirección de la siguiente instrucción no esta en 141+2-> 143). 106E:0144 rol al,1 ; Nos hemos equivocado – la siguiente instrucción empieza en 144. ; Volvemos a entrar a partir de 144. 106E:0146 -a141 106E:0141 call 144 106E:0144 rol al,1 106E:0146 rol al,1 106E:0148 rol al,1 106E:014A rol al,1 106E:014C push ax 106E:014D and al,0f 106E:014F cmp al,a ; Si al esta fuera del rango 0-a ; no hay caracteres 106E:0151 jna 156 ; No sabemos donde saltar, porque seria muy complicado memorizar la longitud de todas las instrucciones y calcular direcciones en hex sentándose ante un ordenador, pero sabemos que esta cerca de esta dirección. Apostamos por 156 106E:0153 add al,6 ; tenemos de añadir ‘A’-(‘9’+1) que es mas o menos 6. 106E:0155 add al,a 106E:0157 stosb 106E:0158 pop ax 106E:0159 ret Corregimos la instrucción equivocada (la dirección no es 156 pero 155). -a151 106E:0151 jna 155 106E:0153 Todo esta listo para ejecutar: Ultima mirada antes de ejecutar: -u100 Laboratorio de Estructura de Computadores

- 13-


106E:0100 106E:0103 106E:0104 106E:0107 106E:010A 106E:010D 106E:010F 106E:0111 106E:0112

BA7803 EC BF0002 E83600 BA0002 B409 CD21 CC 2BC6

MOV IN MOV CALL MOV MOV INT IN T SUB

DX,0378 AL,D X DI,0200 0140 DX,0200 AH,0 9 21 3 AX,S I ; Esto Esto es basu basura ra. . Pued Puede e ; ser ser muy muy dist distin into to

106E:0114 106E:0116 106E:0119 106E:011C 106E:011E 106E:011F

8BC8 E87BF4 83F97F 3400 5D 1000

MOV CALL CMP XOR PO P ADC

FC E80000 D0C0 D0C0 D0C0 D0C0 50 240F 3C0A 7602 0406 040A AA 58 C3 215F5E

CLD CALL ROL ROL ROL ROL PUSH AND CMP JBE ADD ADD STOS B PO P RET AND

CX,A X F594 CX,+7F AL,0 0 BP [BX+SI],AL

-u140 106E:0140 106E:0141 106E:0144 106E:0146 106E:0148 106E:014A 106E:014C 106E:014D 106E:014F 106E:0151 106E:0153 106E:0155 106E:0157 106E:0158 106E:0159 106E:015A

0144 AL,1 AL,1 AL,1 AL,1 AX AL,0 F AL,0 A 0155 AL,0 6 AL,0 A AX [BX+5E],BX

; basu basura ra

Ejecutamos paso a paso a partir de CS:100 -t=100 Significa Trace – ejecutar la siguiente instrucción (con el flag T de 8086 a partir de la dirección 100h) AX=0000 BX=0000 CX=0000 DX=0378 SP=FFEE BP=0000 SI=0000 DI=0000 DS=106E ES=106E SS=106E CS=106E IP=0103 NV UP EI PL NZ NA PO NC 106E:0103 EC IN AL,DX Después de ejecutar la instrucción en 100 (mov dx,378) el DEBUG escribe el contenido de los registros y la siguiente instrucción de ejecutar (IN AL,DX). Notar que DX tiene valor 378. ; Sin dirección significa que se ejecuta la siguiente instrucción -t AX=0000 BX=0000 CX=0000 DX=0378 SP=FFEE BP=0000 SI=0000 DI=0000


- 14-


DS=106E ES=106E SS=106E CS=106E IP=0104 NV UP EI PL NZ NA PO NC 106E:0104 BF0002 MOV DI,0200 -t ; Parece trivial, tal como en el puerto 378 había 00 (AL=00). Seria mucho mas instructivo si había 0B5h en AL. Cambiamos el contenido de AL con 0B5h: -r AX AX 0000 :00B5 AX=00B5 BX=0000 CX=0000 DX=0378 SP=FFEE BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0107 NV UP EI PL NZ NA PO NC 106E:0107 E83600 CALL 0140 t ; seguimos - t AX=00B5 BX=0000 CX=0000 DX=0378 SP=FFE6 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0140 NV UP EI NG NZ AC PE CY 106E:0140 FC CLD -t ; Seguimos. Observamos que se prepara STOBS, pero nos hemos olvidado de ES. Por ‘suerte’ ES es igual a CS y DS. AX=00B5 BX=0000 CX=0000 DX=0378 SP=FFE6 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0141 NV UP EI NG NZ AC PE CY 106E:0141 E80000 CALL 0144 -t ; Entramos a escribir un carácter en la memoria. AX=00B5 BX=0000 CX=0000 DX=0378 SP=FFE4 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0144 NV UP EI NG NZ AC PE CY 106E:0144 D0C0 ROL AL,1 -t AX=006B BX=0000 CX=0000 DX=0378 SP=FFE4 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0146 OV UP EI NG NZ AC PE CY 106E:0146 D0C0 ROL AL,1 -t AX=00D6 BX=0000 CX=0000 DX=0378 SP=FFE4 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0148 OV UP EI NG NZ AC PE NC 106E:0148 D0C0 ROL AL,1 -t AX=00AD BX=0000 CX=0000 DX=0378 SP=FFE4 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=014A NV UP EI NG NZ AC PE CY 106E:014A D0C0 ROL AL,1 -t AX=005B BX=0000 CX=0000 DX=0378 SP=FFE4 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=014C OV UP EI NG NZ AC PE CY Laboratorio de Estructura de Computadores

- 15-


106E:014C 50 -t

PUSH

AX

AX=005B BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=014D OV UP EI NG NZ AC PE CY 106E:014D 240F AND AL,0F -t ; los nibbles (unidades de 4 bits) se han cambiado – correcto) AX=000B BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=014F NV UP EI PL NZ NA PO NC 106E:014F 3C0A CMP AL,0A -t ; en AL esta B – el primer dígito de escribir AX=000B BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0151 NV UP EI PL NZ NA PO NC 106E:0151 7602 JBE 0155 -t AX=000B BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0153 NV UP EI PL NZ NA PO NC 106E:0153 0406 ADD AL,06 -t AX=0011 BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0155 NV UP EI PL NZ AC PE NC 106E:0155 0430 ADD AL,30 -t AX=0041 BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0157 NV UP EI PL NZ NA PE NC 106E:0157 AA STOSB -t AX=0041 BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0201 DS=106E ES=106E SS=106E CS=106E IP=0158 NV UP EI PL NZ NA PE NC 106E:0158 58 POP AX Veamos que hay en la memoria es:200 -d es:200 L1 ; Dump de un byte (L1) a partir de es:200 106E:0200 41 A --------------HEX-------------------------------COMO ASCII. Es erróneo! Queremos que escriba ‘B’ de ‘B5’. Nos hemos equivocado con la instrucción ADD AL,6, que tiene que estar ADD AL,7. Corregimos. Buscamos la instrucción: instrucción : -u140 … … … (como antes) Laboratorio de Estructura de Computadores

- 16-


-a153 106E:0153 add al,7 -u140 (por sea caso). …. (con instrucción correcta). ; veamos donde estamos -r AX=0041 BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0201 DS=106E ES=106E SS=106E CS=106E IP=0158 NV UP EI PL NZ NA PE NC 106E:0158 58 POP AX ; Seguimos.

-t AX=005B BX=0000 CX=0000 DX=0378 SP=FFE4 BP=0000 SI=0000 DI=0201 DS=106E ES=106E SS=106E CS=106E IP=0159 NV UP EI PL NZ NA PE NC 106E:0159 C3 RET -t AX=005B BX=0000 CX=0000 DX=0378 SP=FFE6 BP=0000 SI=0000 DI=0201 DS=106E ES=106E SS=106E CS=106E IP=0144 NV UP EI PL NZ NA PE NC 106E:0144 D0C0 ROL AL,1 ; Esto ya lo hemos visto. Andamos un poco mas deprisa.

-u 106E:0144 106E:0146 106E:0148 106E:014A 106E:014C 106E:014D 106E:014F 106E:0151 106E:0153 106E:0155 106E:0157 106E:0158 106E:0159

D0C0 D0C0 D0C0 D0C0 50 240F 3C0A 7602 0407 0430 AA 58 C3

ROL ROL ROL ROL PUSH AND CMP JBE ADD ADD STOS B PO P RET

AL,1 AL,1 AL,1 AL,1 AX AL,0 F AL,0 A 0155 AL,0 7 AL,3 0 AX

; Notar que se desensambla (u de un-assembly) desde la posición actual (CS:IP). Vamos hasta RET. En AL es:200..201 podemos ver los caracteres que se han escrito. -g 159 ; g de GO mas el punto de control (breakpoint) 159. El DEBUG sustituye el contenido de CS:159 con INT 3 y después ejecuta el programa desde la dirección actual (CS:IP). Notar que la parada del programa no se garantiza garantiza (si el programa no ejecuta la instrucción de CS:159 no hay garantía que va a parar. Además 159 puede estar incluso en la mitad de una instrucción. AX=00B5 BX=0000 CX=0000 DX=0378 SP=FFE6 BP=0000 SI=0000 DI=0202 DS=106E ES=106E SS=106E CS=106E IP=0159 NV UP EI PL NZ NA PE NC 106E:0159 C3 RET -d200 201 ; Utilizamos la forma de dirección 200 hasta dirección 201 .


- 17-


106E:0200 41 35 A5 Menos mal – el segundo carácter es 5 de ‘B5’ – es correcto. -t AX=00B5 BX=0000 CX=0000 DX=0378 SP=FFE8 BP=0000 SI=0000 DI=0202 DS=106E ES=106E SS=106E CS=106E IP=010A NV UP EI PL NZ NA PE NC 106E:010A BA0002 MOV DX,0200 -t AX=00B5 BX=0000 CX=0000 DX=0200 SP=FFE8 BP=0000 SI=0000 DI=0202 DS=106E ES=106E SS=106E CS=106E IP=010D NV UP EI PL NZ NA PE NC 106E:010D B409 MOV AH,09 -t AX=09B5 BX=0000 CX=0000 DX=0200 SP=FFE8 BP=0000 SI=0000 DI=0202 DS=106E ES=106E SS=106E CS=106E IP=010F NV UP EI PL NZ NA PE NC 106E:010F CD21 INT 21 ; En este punto es necesario ver si todo esta correcto en la memoria DS:200. -d200 ; Sin longitud el DEBUG nos imprime 80 bytes . 106E 106E:0 :020 200 0 106E 106E:0 :021 210 0 106E 106E:0 :022 220 0 106E 106E:0 :023 230 0 106E 106E:0 :024 240 0 106E 106E:0 :025 250 0 106E 106E:0 :026 260 0 106E 106E:0 :027 270 0

41 00 3B D2 0B D5 2F D8

35 03 75 80 00 E2 E7 B0

D7 F1 F6 3E E8 00 BB FF

D7 E8 4E 43 59 74 40 86

C3 03 C3 04 00 F7 00 47

BE 00 1E 00 5F 1E BA 18

BC 3C 52 75 5E 0E 01 A2

DB-8 DB-8B B 0D-C 0D-C3 3 50-5 50-53 3 0D-F 0D-F6 6 59-5 59-5B B 1F-B 1F-BE E 00-3 00-33 3 18-0 18-00 0

4C AC 51 06 58 D5 FF C3

05 E8 56 21 5A E2 CD 0E

8B 04 57 04 1F E8 21 1F

74 F9 2E FF C3 98 1F E8

09 75 8E 75 2E 02 72 D2

E8 04 1E 06 80 2E 0B 00

08 3C FE E8 3E A1 8B 3D

A5.. A5.... .... ...L .L.. ..t. t... .. .... ...... ..<. <... .... ...u .u.< .< ;u.N ;u.N.. ..RP RPSQ SQVW VW.. .... .. ..>C ..>C.. ..u. u... ..!. !..u .u.. .. ...Y ...Y._ ._^Y ^Y[X [XZ. Z... ...> .> ...t ...t.. .... .... .... .... .... .. /..@ /..@.. .... ..3. 3..! .!.r .r.. .. .... ....G. G... .... .... .... ...= .=

; ERRROOOORRR!! La cadena no termina con ‘$’. Si ejecutamos int 21 puede ocurrir cualquier cosa. ; Otro error – escribimos en ES:DI pero imprimimos imprimim os de DS:DI. Por ‘suerte’ el DEBUG asigna el mismo valor de todos los registros del segmento. Cambiamos el contenido de la memoria. Añadimos CR LF y ‘$’. -e202 106E:0202 0D.0d 0A.a Después de 0d tenemos de teclear espacio. Después del ultimo byte tenemos de teclear salto de linea. Entramos ‘$’ como símbolo: -e204 ‘$’ Comprobamos -d200 106E:0200 41 35 0D 0A 24 BE BC DB-8B 4C 05 8B 74 09 E8 08 A5..$....L..t... …. Ahora esta bien. -r ; donde estamos AX=09B5 BX=0000 CX=0000 DX=0200 SP=FFE8 BP=0000 SI=0000 DI=0202 DS=106E ES=106E SS=106E CS=106E IP=010F NV UP EI PL NZ NA PE NC 106E:010F CD21 INT 21


- 18-


Estamos antes de ejecutar INT 21h con AH=9 y DX=200. Tenemos que ejecutar esta instrucción pero no nos interesa entrar en DOS. Por esto ejecutamos INT 21 no con t pero con p. El comando p sustituye la siguiente instrucción con INT 3 (que en este caso es también INT 3) y ejecuta el programa como si entramos G. -p A5 AX=0924 BX=0000 CX=0000 DX=0200 SP=FFE8 BP=0000 SI=0000 DI=0202 DS=106E ES=106E SS=106E CS=106E IP=0111 NV UP EI PL NZ NA PE NC 106E:0111 CC INT 3 Bien! El programa escribe A5 (después de la línea de p), como debe ser (casi, tal como tiene que escribir B5). Tal como hemos ayudando al programa ‘a mano’ de conseguir su tarea, corregimos añadiendo un patch en 180 (a partir de este momento no escribo los comandos U necesarios): -a180 106E:0180 push ds 106E:0181 pop es 106E:0182 call 140 106E:0185 mov al,d ; el CR 106E:0187 stosb 106E:0188 mov al,a ; El LF 106E:018A stosb 106E:018B mov al,24 ; El ‘$’. Podemos verlo en la memoria ES:204 106E:018D stosb 106E:018E ret 106E:018F -a107 106E:0107 call 180 ; entramos en el patch y no en 140 106E:010A ponemos en puerto 378 el valor que vamos a escribir: -o378 5D ; esto es equivalente al programa: MOV DX,378h // MOV al,5Dh // OUT dx,al Comprobamos el contenido del puerto: -i378 ; Esto es casi equivalente al nuestro programa 5D ; Correcto, tal como el puerto es un simple I/O buffer. Ejecutamos -g=100 107 ; esta parte ya la sabemos Un poco mas despacio con la nueva parte. AX=095D BX=0000 CX=0000 DX=0378 SP=FFE2 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0107 NV UP DI PL NZ NA PE NC 106E:0107 E87600 CALL 0180 -t AX=095D BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0180 NV UP DI PL NZ NA PE NC Laboratorio de Estructura de Computadores

- 19-


106E:0180 1E -t

PUSH

DS

AX=095D BX=0000 CX=0000 DX=0378 SP=FFDE BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0181 NV UP DI PL NZ NA PE NC 106E:0181 07 POP ES -t AX=095D BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0200 DS=106E ES=106E SS=106E CS=106E IP=0182 NV UP DI PL NZ NA PE NC 106E:0182 E8BBFF CALL 0140 Con esto – a toda marcha. Ya lo sabemos.

-p AX=095D BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0202 DS=106E ES=106E SS=106E CS=106E IP=0185 NV UP DI PL NZ NA PE NC 106E:0185 B00D MOV AL,0D -t AX=090D BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0202 DS=106E ES=106E SS=106E CS=106E IP=0187 NV UP DI PL NZ NA PE NC 106E:0187 AA STOSB -t AX=090D BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0203 DS=106E ES=106E SS=106E CS=106E IP=0188 NV UP DI PL NZ NA PE NC 106E:0188 B00A MOV AL,0A -t AX=090A BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0203 DS=106E ES=106E SS=106E CS=106E IP=018A NV UP DI PL NZ NA PE NC 106E:018A AA STOSB -t AX=090A BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0204 DS=106E ES=106E SS=106E CS=106E IP=018B NV UP DI PL NZ NA PE NC 106E:018B B024 MOV AL,24 -t AX=0924 BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0204 DS=106E ES=106E SS=106E CS=106E IP=018D NV UP DI PL NZ NA PE NC 106E:018D AA STOSB -t AX=0924 BX=0000 CX=0000 DX=0378 SP=FFE0 BP=0000 SI=0000 DI=0205 DS=106E ES=106E SS=106E CS=106E IP=018E NV UP DI PL NZ NA PE NC 106E:018E C3 RET Laboratorio de Estructura de Computadores

- 20-


-t Comprobamos la memoria -d200 106E:0200 35 44 0D 0A 24 BE BC DB-8B 4C 05 8B 74 09 E8 08 5D..$....L..t... …. Y a toda marcha hasta el final. -g 5D AX=0924 BX=0000 CX=0000 DX=0200 SP=FFE2 BP=0000 SI=0000 DI=0205 DS=106E ES=106E SS=106E CS=106E IP=0111 NV UP DI PL NZ NA PE NC 106E:0111 CC INT 3 Lo hemos conseguido. Lo único malo de este ‘programa’ de DOS es que no termina correcto. Arreglamos el problema: -a111 106E:0111 int 20 Ahora ejecutamos desde el principio: -g=100 ; ejecutamos desde dirección CS:100 sin paradas. Salvamos el programa en el disco. -r CX ; En BX:CX – 4 bytes de longitud del fichero. Cuidado con BX! CX 0000 :100 ; Todo el código nuestro esta desde 100 (por defecto) hasta 200h – la longitud el de 100h bytes. Damos un nombre (see378.com) del fichero: -nsee378.com Escribimos el fichero: -w Salimos del DEBUG: -q Ahora tenemos el programa SEE378.COM, SEE378.COM , tal como empieza en 100h, es menos de 32K y el fichero tiene extensión .COM. El programa que escribe el contenido del puerto 378 en la pantalla. Ejecutamos: Ejecutamos: C:\>see378 5D Efectivamente. Si queremos volver a manejar este programa con DEBUG, podemos ejecutar: C:\>debug see378.com -u100.

Lista de los comandos de DEBUG utilizados: -q – Salir del programa Laboratorio de Estructura de Computadores

- 21-


-? – Pedir ayuda. -d – Dump de memoria. -e – Edit (cambio) de memoria. -a – ensamblador de lenguaje de maquina 8086 -u – Un - ensamblador de lenguaje de maquina 8086. -t – Ejecutar paso a paso -p – Ejecutar la siguiente instrucción sin entrar en ella (CALL o INT). -g – Ejecutar desde una dirección con paradas (breakpoints). -r – Ver/cambiar registro. -n – Dar nombre de fichero. -w – Escribir en un fichero.


- 22-

Tutorial assembler en Debug - Rocio Balbin Lazo

Recommend Documents