Registrarse
  • ¡Vuelven los concursos de mapas! ¿Quién será el mejor diseñador en esta ocasión? ¿Te ves capaz de demostrar todas tus habilidades en el mapeo, Invitado? ¡Inscríbete ya dándole al botón!

    El periodo de inscripción acaba el día 20 de septiembre.

[RH - ASM] Clase 4

Estado
Cerrado para nuevas respuestas.

Annatar

A la luz del quinto día, mira al este
Antes de comenzar la clase quiero aclarar mi ausencia de la escuela, y por lo general de la comunidad de este último periodo de tiempo. Por motivos personales no me he visto con las ganas ni con el tiempo de continuar con la escuela hasta hoy. Espero que seáis comprensivos y lo entendáis.

CLASE 4​

En la clase hoy no vamos a aprender cosas sobre las rutinas en si, sino más bien sobre como lidiar con los fallos que se puedan originar a la hora de desarrollar una rutina. Este apartado es sumamente aconsejable y es de vital importancia aprender a usar el debugger.

¿Qué debugger usaremos?

Bueno, debuggers hay para elegir, pero yo os enseñaré a usar el VBA-SDL-H, pero podeis usar el que más os guste o el que mas comodo os parezca. Lo priemro será obtener la herramientas en si. Y para ello lo buscais en Internet, vagos.

Es broma, el la segunda clase dejé un archivo subido a Mediafire que contenía ciertas herramientas, por si no os acordáis dentro de la carpeta había tres cosas fundamentales, un compilador, un debugger y un desensamblador.

Por lo tanto, si no lo tenis descargado ya descargad el archivo que os dejé en la segunda clase.

¿Como abro el juego y accedo al modo debugger?

Para abrir una ROM limpia de Pokemon Fire Red USA simplemente arrastrad el archivo llamado “Fire Red” al archivo VBA-SDL-H.exe y se os abrirá el programa como si fuese un emulador más:



Para acceder al modo debugger debéis pulsar la tecla F11, (Fn + F11 en ciertos ordenadores). A continuación se os abrirá una ventana idéntica a esta:


¿Como funciona la herramienta?

El debugger tiene varios comandos que podéis ejecutar. Para ver la lista completa simplemente escribid lo siguiente:

Código:
h
y aparecerán los distintos comandos a ejecutar, los que aparecen son los siguientes:

Código:
?         Shows this help information. Type ? <command> for command help
ba        Adds an ARM breakpoint
bd        Deletes a breakpoint
bl        Lists breakpoints
bpr       Break on read*
bprc      Clear break on read*
bpw       Break on write*
bpwc      Clear break on write*
bt        Adds a THUMB breakpoint
c         Continues execution*
d         Disassembles instructions*
da        Disassembles ARM instructions
db        Don't break at the following address.
dbc       Clear the Don't Break list.
dload     Load raw data dump from file
dsave     Dump raw data to file
dn        Disassembles instructions near PC
dt        Disassembles Thumb instructions
eb        Modify memory location (byte)
eh        Modify memory location (half-word)
er        Modify register
eval      Evaluate expression
ew        Modify memory location (word)
ft        Search memory for ASCII-string.
fh        Search memory for hex-string.*
fr        Resume current search.
h         Shows this help information. Type h <command> for command help
io        Show I/O registers status
load      Loads a Fx type savegame
mb        Shows memory contents (bytes)*
mh        Shows memory contents (half-words)*
mw        Shows memory contents (words)*
n         Executes the next instruction*
q         Quits the emulator
r         Shows ARM registers
rt        Run to address
rta       Run to address (ARM)
rtt       Run to address (Thumb)
save      Creates a Fx type savegame
sbreak    Adds a breakpoint on the given function
sradix    Sets the print radix
sprint    Print the value of a expression (if known)
ssymbols  List symbols
sverbose  Change verbose setting
swhere    Shows call chain
trace     Control tracer
var       Define variables
Los que he puesto con asterisco son los que voy a explcuar, los demás no me parecen adecuados para el momento, pero podéis aprender vosotros mismo lo que hacen el resto de comandos.

Break point on read y clear break point on read

El bpr será uno de los comandos con los que vayamos a empezar nuestra tarea con el debugger. Antes de explicar su sintaxis quiero dejar claro su uso.

Si queremos saber lo que falla en una rutina tendremos que poner un break point on read antes de testear la rutina, para que una vez empiece a ejecutarse se abrá el debugger y podamos analizarlo en profundidad.

Imaginad que al principio (no necesariamente el primero comado claro esta, sino de los primeros) de mi rutina he puesto este comando:

Código:
ldr r0, [r0]
Como bien sabéis (y si no es así id a leer las clases anteriores) este comando lee una word del offset almacenado en r0 y lo guarda en r0 asi sobreescribiendo el valor del registro.

Imaginad que la rutina que quiero probar se ejecuta al hablar con un NPC, pues antes de hablar con él, abro el modo debugger y pondré el comado bpr, pulso enter y A continuación escribiré “c” y pulso enter de nuevo.

En consecuencia, una vez que hable con el NPC y se empiece a ejecutar la rutina veré que justo al principio el break point saltará y se abrirá el debugger.

Su sintaxis es la siguiente:

Código:
bpr {offset} {cantidad de bytes a leer}]/CODE]

	Ya sois mayorcitos para saber que no basta con poner un offset de seis caracteres, hay que especificar a que memoria nos referimos. Es decir, si el offset es la ROM un 08 por delante, y si es a la RAM 02 (si es I/O RAM creo que era 03, pero es igual).

	Para elimiar los bpr que hayamos puesto simplemente escribid:

[CODE]bprc

Una vez que hayamos puesto el comando bpr y haya saltado la alarma, por así decirlo, nos aparecerá la siguiente información útil:

Código:
R00=00000001 R04=00000000 R08=00000000 R12=00000040
R01=00000004 R05=030030e4 R09=00000000 R13=03007e24
R02=030030f0 R06=030030e4 R10=00000000 R14=080004ab
R03=00000001 R07=030030f0 R11=00000000 R15=080008b0
CPSR=0000003f (......T Mode: 1f)
080008ac  1c18 add r0, r3, #0x0
> 080008ae  4008 and r0, r1
080008b0  2800 cmp r0, #0x0
debugger>
Por una parte está el valor que tiene cada registro antes de ser ejecutada esa línea, lo cual es de vital importancia para saber que ocurre exactamente en la rutina y por otro lado tendremos el comando que se haya ejecutado antes, el que se va a ejecutar y el próximo en ejecutarse.

Ahora iremos ejecutando cada comando de uno en uno, usando el comando n, luego lo explico, y así ver el valor de cada registro en cada momento, lo cual nos sirve para detectar bugs. Si no se entiende preguntad sin miedo.

Break Point on Write y Clear Break Point on Write

Este comando se parece mucho al anterior explicado, pero en vez de detectar cuando la rutina lee unos determinados bytes detecta cuando la rutina sobrescribe unos bytes de un offset especifico.

Por lo tanto, su sintaxis es la sigueinte:

Código:
bpw {offset} {cantidad de bytes sobreescritos}
Recordad determinar a que memoria os estáis refiriendo. Aunque bien pensado es absurdo poner 08, pues la ROM (Read Only Memory) no se puede editar a la hora de ser ejecutado el juego.

Para eliminar estos tipos de bp simplemente:

Código:
bpwc
Continuar

Es un comando simple y llano, hace que se ejecute la próxima línea, no tiene más misterio. Para hacerlo simplemente ejecutad este comando:

Código:
c
Y despues enter, que todo hay que decirlo.

Desensamblar

Me veo en la obligación de explicarlo pero me parece una tontería. Para desensamblar ya os he dejado una base de datos mucho más clara donde podreís analizar las rutinas del juego. Además, para desensamblar vuestras rutinas no hace más que volver a ver la rutina en el Notepad. Pero bueno, este comando muestra los comandos alrededor del comando que se está ejecutando al momento. Su uso es:

Código:
d
Y os aparecerá algo así, depende del caso evidentemente:

Código:
debugger> d
080008ae  4008 and r0, r1
080008b0  2800 cmp r0, #0x0
080008b2  d0fa beq $080008aa
080008b4  bc01 pop {r0}
080008b6  4700 bx r0
080008b8  30f0 add r0, #0xf0
080008ba  0300 lsl r0, r0, #0x0c
080008bc  fffe blh $0ffc
080008be  0000 lsl r0, r0, #0x00
080008c0  4901 ldr r1, [$080008c8] (=$030030f0)
080008c2  6208 str r0, [r1, #0x20]
080008c4  4770 bx lr
080008c6  0000 lsl r0, r0, #0x00
080008c8  30f0 add r0, #0xf0
080008ca  0300 lsl r0, r0, #0x0c
080008cc  4901 ldr r1, [$080008d4] (=$030030f0)
080008ce  2000 mov r0, #0x0
080008d0  6208 str r0, [r1, #0x20]
080008d2  4770 bx lr
080008d4  30f0 add r0, #0xf0
debugger>
Como os digo, para eso usad la base de datos que os he dejado.

Buscador de memoria

Este comando sirve para buscar una cadena de valores hexadecimales referente a textos a través de todas las memorias. Una vez ejecutado el comando se mostrarán las primeras x busquedas exitosas que se hayan encontrado, donde x lo has determinado tú. Por ejemplo:

Código:
fh 0 30 C4BBC8C3BDBF
Empieza a buscar desde el offset 0 y nos mostrará las primeras, como mucho 30 veces, los valores que haya escrito, en este caso, nos aparecerá lo siguiente:

Código:
Search result (0): 0823fcec
Search result (1): 08243a04
Search result (2): 08243a2c
Search completed.
Como veis hay tres offsets en la RAM donde estén esos caracteres escritos. Para los curiosos, convertido de hex a nuestro alfabeto el teto significa JANICE, el nombre de una entrenadora.

Os aconsejo usar números alto como el 30 para que no os saltéis ningún resultado.

Mostrar Memoria

Son unos comandos muy útiles que nos muestran la memoria a partir de un offset que hayamos determinado, está se puede alinear por bytes, half words o words, para cada uno se usa el comando mb, mh y mw respectivamente. Se usa así:

Código:
mb/h/w {offset}
Y nos enseña una parte de la memoria a partir de ese offset. Por ejemplo,

Código:
debugger> mb 083D463E
083d463e e8 08 a0 70 e8 08 28 70 e8 08 a0 70 e8 08 28 70 ...p..(p...p..(p
083d464e e8 08 a0 70 e8 08 28 70 e8 08 a0 70 e8 08 b0 a6 ...p..(p...p....
083d465e e8 08 84 a7 e8 08 a4 a7 e8 08 6c a8 e8 08 8c a8 ..........l.....
083d466e e8 08 68 a9 e8 08 90 a9 e8 08 6c aa e8 08 8c aa ..h.......l.....
083d467e e8 08 6c ab e8 08 8c ab e8 08 64 ac e8 08 84 ac ..l.......d.....
083d468e e8 08 44 ad e8 08 64 ad e8 08 38 ae e8 08 5c ae ..D...d...8...\.
083d469e e8 08 40 af e8 08 64 af e8 08 44 b0 e8 08 64 b0 ..@...d...D...d.
083d46ae e8 08 2c b1 e8 08 48 b1 e8 08 e0 b1 e8 08 00 b2 ..,...H.........
083d46be e8 08 e8 b2 e8 08 10 b3 e8 08 d0 b3 e8 08 f4 b3 ................
083d46ce e8 08 b4 b4 e8 08 d8 b4 e8 08 bc b5 e8 08 e0 b5 ................
083d46de e8 08 c8 b6 e8 08 ec b6 e8 08 a4 b7 e8 08 c8 b7 ................
083d46ee e8 08 8c b8 e8 08 b0 b8 e8 08 84 b9 e8 08 a8 b9 ................
083d46fe e8 08 60 ba e8 08 7c ba e8 08 48 bb e8 08 6c bb ..`...|...H...l.
083d470e e8 08 34 bc e8 08 58 bc e8 08 3c bd e8 08 60 bd ..4...X...<...`.
083d471e e8 08 1c be e8 08 40 be e8 08 2c bf e8 08 4c bf ......@...,...L.
083d472e e8 08 34 c0 e8 08 58 c0 e8 08 38 c1 e8 08 5c c1 ..4...X...8...\.
Debugger>
Ejecutar próxima instrucción

Es un simple comando que su función es ejecutar la próxima instrucción, como antes he mostrado cada vez se mostrará la instrucción actual, la anterior y la siguiente y el valor de cada registro. Para usarlo simplemente:

Código:
n
Cabe mencionar que al escribir cualquier comando hay que darle al Enter para que se ejecute, aclaro esto porque hay de todo en este loco octano nuestro.


No se si esta será la última clase o si haré más, de todas formas os mantendré informado y gracias por la espera ;)
 

Ancer

Usuario de Oro
Una pregunta ya la e echo pero nadie sabe como es
Como se escribe en la pantalla con asm obvio me refiero en pokemon
 
Estado
Cerrado para nuevas respuestas.
Arriba