Hola, estoy trabajando en un desensamblador para x86 (32 bits). Ya logré hacer la parte que identifica los prefijos. Pero tengo un problema, ahora estoy en la parte de decodificar los opcodes.

Al principio, he estado pensando en esta idea: Mantener una tabla con los opcodes, y comparar el byte actual contra la tabla. Y según cada caso, tomar la decision apropiada: Por ejemplo leer si hay un byte mod r/m, si tiene SIB, leer desplazamiento e immediate value (haciendo esto tras leer primero el mod r/m).

Y si no coincide con ningun opcode, declarar el byte desde donde se empezó a analizar la instruccion como basura.

Pero, he estado pensando que esa idea puede ser muy ineficiente, ¿será que alguien tiene una mejor manera de hacerlo?

Por ejemplo: En vez de comparar cada byte con una tabla, usar algun principio de generalizacion, por ejemplo: Si los primeros cuatro bits son 1001, es un mov. Luego analizar y determinar el mov especifico correspondiente (mover 8bits/16bits/32bits). ¿Será que es posible? ¿O esa es solo la unica manera?

PD: Ya he estado leyendo algunos sources de programas open source, pero muchos usan esa estrategia, al menos en apariencia. Los estoy leyendo a fondo.

Gracias de antemano.

No queda otra que entender los PDFs que INTEL o AMD presentan en su web.
Es un tema complicado por el arrastre que los procesadores x86 han acumulado.
Muchos prefijos a entender.

Por ejemplo lo primero que interpreta la CPU es la instrucción que
suelen saltar de 8 en 8 unidades , dependiendo del valor :

0000 add [bx+si],al
0800 or [bx+si],al
1000 adc [bx+si],al
1800 sbb [bx+si],al
2000 and [bx+si],al
2800 sub [bx+si],al
3000 xor [bx+si],al
3800 cmp [bx+si],al
40 inc ax

esos 8 espacios permiten decidir operandos o no.
Pero no todo es tan predecible, hay muchas variaciones.
y prefijos como los nuevos 0F que designan instrucciones modernas.

Animo y que no decaiga el interés.

Claro si tienes algun problema comentalo, pero como te dije antes y ahora en las pag y capitulo que cite esta todo bien detallado.

Si no te gustan los AMD lee los Intel, aun que sera practicamente igual.

Un saludo.

Hola gracias a todos por sus respuestas. Por favor, ¿será que me pueden decir un método que sea rápido y eficiente para reconocer opcodes de un byte? He estado tratando que saber si ciertos bits están activados, y en ese caso reconocer si es un opcode valido (en ese caso se podría generalizar la instrucción push, descartando e ignorando los tres últimos bits).

He estado intentando con hacer un AND entre una máscara de bits (que selecciona cuáles bits debe considerar) y el byte a verificar si es opcode, y luego comparar el resultado con el opcode general.

Por ahora me ha dado algunos resultados, pero seguiré probandolo. ¿Será que alguien me puede decir si estoy procediendo de la mejor forma? ¿O habrá otra mejor?

Ah, reconocer opcodes de 16 bits no me interesa mucho, estoy centrado en 32 bits. Realmente solo quiero hacer un desensamblador que me reconozca las instrucciones de 32 bits, al menos las más usadas.

Gracias a todos de antemano.

Gracias cpu2 por tu ayuda. Bueno, si al parecer no hay otro método, seguiré por esa linea. Ah, en cuanto al byte Mod R/M ya he leído algo, específicamente he aprendido que puede estar embebido dentro del opcode en algunas ocasiones.

E incluso, (si no me equivoco), una parte del opcode, puede ir dentro del mod R/M. Bueno, seguiré leyendo más sobre x86 en los manuales de Intel.

Gracias por clarificarme de nuevo las cosas sobre Mod R/M.