cos2000v2/lib/debug.c

3471 lines
62 KiB
C

/*******************************************************************************/
/* COS2000 - Compatible Operating System - LGPL v3 - Hordé Nicolas */
/* */
#include "types.h"
#include "video.h"
#include "debug.h"
u8 *r8[] = { "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh" };
u8 *r16[] = { "ax", "cx", "dx", "bx", "sp", "bp", "si", "di" };
u8 *r32[] = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi" };
u8 *rseg[] = { "ds", "es", "fs", "gs", "ss", "cs", "ip" };
/*******************************************************************************/
/* Efface un breakpoint sur une adresse */
void cleardebugreg(u8 * address)
{
for (u8 i = 0; i < 4; i++)
if (getdebugreg(i) == address)
setdebugreg(i, 0x0, DBG_CLEAR);
}
/*******************************************************************************/
/* Permet de manipuler dr0-dr7 pour mettre en place des breakpoints */
u8 *getdebugreg(u8 number)
{
u8 *address;
if (number == 0)
asm("mov %%dr0,%%eax; mov %%eax,%[address]":[address]
"=m"
(address)::);
else if (number == 1)
asm("mov %%dr1,%%eax; movl %%eax,%[address]":[address]
"=m"
(address)::);
else if (number == 2)
asm("mov %%dr2,%%eax; movl %%eax,%[address]":[address]
"=m"
(address)::);
else if (number == 3)
asm("mov %%dr0,%%eax; movl %%eax,%[address]":[address]
"=m"
(address)::);
return address;
}
/*******************************************************************************/
/* Permet de manipuler dr0-dr7 pour mettre en place des breakpoints */
void setdebugreg(u8 number, u8 * address, u8 type)
{
u32 dr7 = 0;
asm("movl %%dr7,%%eax; mov %%eax,%[dr7]":[dr7] "=m"(dr7)::);
if (type == DBG_WRITE || type == DBG_READWRITE)
dr7 |= 0x3 << 8;
if (type != DBG_CLEAR)
dr7 |= 0x3 << (number << 1);
else
dr7 &= ~(0x3 << (number << 1));
dr7 &= ~(0x3 << (16 + (number << 2)));
dr7 |= type << (16 + (number << 2));
dr7 &= ~(0x3 << (16 + ((number << 2) + 2)));
asm("movl %[dr7],%%eax; mov %%eax,%%dr7"::[dr7] "m"(dr7):);
if (number == 0)
asm("movl %[address],%%eax; mov %%eax,%%dr0"::[address] "m"(address):);
else if (number == 1)
asm("movl %[address],%%eax; mov %%eax,%%dr1"::[address] "m"(address):);
else if (number == 2)
asm("movl %[address],%%eax; mov %%eax,%%dr2"::[address] "m"(address):);
else if (number == 3)
asm("movl %[address],%%eax; mov %%eax,%%dr3"::[address] "m"(address):);
else
return;
}
/*******************************************************************************/
/* Fonctions de déboguage */
u16 decodeModSM(bool show, u8 * a, u8 * op, u16 order, u32 Gsz, u32 Esz)
{
u32 len = 0;
u32 reg = 0;
u32 scale = 0;
u8 *b = a;
u8 *E, *G, *indx, *base, *disp = "\0";
u8 ebuf[32] = { 0 };
setG();
if (Esz)
{
switch (*b & 0xc7)
{
case 0x00:
E = "[bx+si]";
break;
case 0x01:
E = "[bx+di]";
break;
case 0x02:
E = "[bp+si]";
break;
case 0x03:
E = "[bp+di]";
break;
case 0x04:
E = "[si]";
break;
case 0x05:
E = "[di]";
break;
case 0x06:
snprintf(ebuf, sizeof(ebuf), "ds:%x",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x07:
E = "[bx]";
break;
case 0x40:
snprintf(ebuf, sizeof(ebuf), "[bx+si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x41:
snprintf(ebuf, sizeof(ebuf), "[bx+di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x42:
snprintf(ebuf, sizeof(ebuf), "[bp+si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x43:
snprintf(ebuf, sizeof(ebuf), "[bp+di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x44:
snprintf(ebuf, sizeof(ebuf), "[si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x45:
snprintf(ebuf, sizeof(ebuf), "[di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x46:
snprintf(ebuf, sizeof(ebuf), "[bp+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x47:
snprintf(ebuf, sizeof(ebuf), "[bx+%x]",
*(u8 *)++ b);
E = ebuf;
case 0x80:
snprintf(ebuf, sizeof(ebuf), "[bx+si+%x]",
*(u8 *)++ b);
E = ebuf;
++b;
break;
case 0x81:
snprintf(ebuf, sizeof(ebuf), "[bx+di+%x]",
*(u8 *)++ b);
E = ebuf;
++b;
break;
case 0x82:
snprintf(ebuf, sizeof(ebuf), "[bp+si+%x]",
*(u8 *)++ b);
E = ebuf;
++b;
break;
case 0x83:
snprintf(ebuf, sizeof(ebuf), "[bp+di+%x]",
*(u8 *)++ b);
E = ebuf;
++b;
break;
case 0x84:
snprintf(ebuf, sizeof(ebuf), "[si+%x]",
*(u8 *)++ b);
E = ebuf;
++b;
break;
case 0x85:
snprintf(ebuf, sizeof(ebuf), "[di+%x]",
*(u8 *)++ b);
E = ebuf;
++b;
break;
case 0x86:
snprintf(ebuf, sizeof(ebuf), "[bp+%x]",
*(u8 *)++ b);
E = ebuf;
++b;
break;
case 0x87:
snprintf(ebuf, sizeof(ebuf), "[bx+%x]",
*(u8 *)++ b);
E = ebuf;
++b;
break;
case 0xc0:
E = "al";
break;
case 0xc1:
E = "cl";
break;
case 0xc2:
E = "dl";
break;
case 0xc3:
E = "bl";
break;
case 0xc4:
E = "ah";
break;
case 0xc5:
E = "ch";
break;
case 0xc6:
E = "dh";
break;
case 0xc7:
E = "bh";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
}
else
{
switch (*b & 0xc7)
{
case 0x00:
E = "[eax]";
break;
case 0x01:
E = "[ecx]";
break;
case 0x02:
E = "[edx]";
break;
case 0x03:
E = "[ebx]";
break;
case 0x04:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf),
"[%s]", base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s]", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i]", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s]", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i]", base, indx,
scale);
}
E = ebuf;
break;
case 0x05:
snprintf(ebuf, sizeof(ebuf), "ds:%x",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x06:
E = "[esi]";
break;
case 0x07:
E = "[edi]";
break;
case 0x40:
snprintf(ebuf, sizeof(ebuf), "[eax+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x41:
snprintf(ebuf, sizeof(ebuf), "[ecx+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x42:
snprintf(ebuf, sizeof(ebuf), "[edx+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x43:
snprintf(ebuf, sizeof(ebuf), "[ebx+%x]",
*(u8 *)++ b);
E = ebuf;
case 0x44:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf), "[%s",
base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i", base, indx,
scale);
}
len = strlen(ebuf);
snprintf(ebuf + len, sizeof(ebuf) - len,
"+%x]", *(u8 *)++ b);
E = ebuf;
break;
case 0x45:
snprintf(ebuf, sizeof(ebuf), "[ebp+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x46:
snprintf(ebuf, sizeof(ebuf), "[esi+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x47:
snprintf(ebuf, sizeof(ebuf), "[edi+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x80:
snprintf(ebuf, sizeof(ebuf), "[eax+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x81:
snprintf(ebuf, sizeof(ebuf), "[ecx+%x]",
*(u32 *)++ b);
E = ebuf;
break;
case 0x82:
snprintf(ebuf, sizeof(ebuf), "[edx+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x83:
snprintf(ebuf, sizeof(ebuf), "[ebx+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x84:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf), "[%s",
base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i", base, indx,
scale);
}
len = strlen(ebuf);
snprintf(ebuf + len, sizeof(ebuf) - len,
"+%x]", *(u32 *)++ b);
b += 3;
E = ebuf;
break;
case 0x85:
snprintf(ebuf, sizeof(ebuf), "[ebp+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x86:
snprintf(ebuf, sizeof(ebuf), "[esi+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x87:
snprintf(ebuf, sizeof(ebuf), "[edi+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0xc0:
E = Esz == 1 ? "ax" : "eax";
break;
case 0xc1:
E = Esz == 1 ? "cx" : "ecx";
break;
case 0xc2:
E = Esz == 1 ? "dx" : "edx";
break;
case 0xc3:
E = Esz == 1 ? "bx" : "ebx";
break;
case 0xc4:
E = Esz == 1 ? "sp" : "esp";
break;
case 0xc5:
E = Esz == 1 ? "bp" : "ebp";
break;
case 0xc6:
E = Esz == 1 ? "si" : "esi";
break;
case 0xc7:
E = Esz == 1 ? "di" : "edi";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
}
if (order)
{
snprintf(op, opBufSz, "%s", E);
len = strlen(op);
if (Gsz)
{
snprintf(op + len, opBufSz - len, ", %s", G);
}
}
else
{
snprintf(op, opBufSz, "%s, ", G);
len = strlen(op);
snprintf(op + len, opBufSz - len, "%s", E);
}
return b - a;
}
u32 decodeModSM_float(bool show, u8 * a, u8 * op, u32 order, u32 Gsz,
u32 Esz)
{
u32 len = 0;
u32 reg = 0;
u32 scale = 0;
u8 *b = a;
u8 *E, *G, *indx, *base, *disp = "\0";
u8 ebuf[32] = { 0 };
setG();
if (Esz)
{
switch (*b & 0xc7)
{
case 0x00:
E = "[bx+si]";
break;
case 0x01:
E = "[bx+di]";
break;
case 0x02:
E = "[bp+si]";
break;
case 0x03:
E = "[bp+di]";
break;
case 0x04:
E = "[si]";
break;
case 0x05:
E = "[di]";
break;
case 0x06:
snprintf(ebuf, sizeof(ebuf), "ds:%x",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x07:
E = "[bx]";
break;
case 0x40:
snprintf(ebuf, sizeof(ebuf), "[bx+si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x41:
snprintf(ebuf, sizeof(ebuf), "[bx+di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x42:
snprintf(ebuf, sizeof(ebuf), "[bp+si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x43:
snprintf(ebuf, sizeof(ebuf), "[bp+di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x44:
snprintf(ebuf, sizeof(ebuf), "[si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x45:
snprintf(ebuf, sizeof(ebuf), "[di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x46:
snprintf(ebuf, sizeof(ebuf), "[bp+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x47:
snprintf(ebuf, sizeof(ebuf), "[bx+%x]",
*(u8 *)++ b);
E = ebuf;
case 0x80:
snprintf(ebuf, sizeof(ebuf), "[bx+si+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x81:
snprintf(ebuf, sizeof(ebuf), "[bx+di+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x82:
snprintf(ebuf, sizeof(ebuf), "[bp+si+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x83:
snprintf(ebuf, sizeof(ebuf), "[bp+di+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x84:
snprintf(ebuf, sizeof(ebuf), "[si+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x85:
snprintf(ebuf, sizeof(ebuf), "[di+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x86:
snprintf(ebuf, sizeof(ebuf), "[bp+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x87:
snprintf(ebuf, sizeof(ebuf), "[bx+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0xc0:
E = "st(0)";
break;
case 0xc1:
E = "st(1)";
break;
case 0xc2:
E = "st(2)";
break;
case 0xc3:
E = "st(3)";
break;
case 0xc4:
E = "st(4)";
break;
case 0xc5:
E = "st(5)";
break;
case 0xc6:
E = "st(6)";
break;
case 0xc7:
E = "st(7)";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
}
else
{
switch (*b & 0xc7)
{
case 0x00:
E = "[eax]";
break;
case 0x01:
E = "[ecx]";
break;
case 0x02:
E = "[edx]";
break;
case 0x03:
E = "[ebx]";
break;
case 0x04:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf),
"[%s]", base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s]", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i]", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s]", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i]", base, indx,
scale);
}
E = ebuf;
break;
case 0x05:
snprintf(ebuf, sizeof(ebuf), "ds:%x",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x06:
E = "[esi]";
break;
case 0x07:
E = "[edi]";
break;
case 0x40:
snprintf(ebuf, sizeof(ebuf), "[eax+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x41:
snprintf(ebuf, sizeof(ebuf), "[ecx+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x42:
snprintf(ebuf, sizeof(ebuf), "[edx+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x43:
snprintf(ebuf, sizeof(ebuf), "[ebx+%x]",
*(u8 *)++ b);
E = ebuf;
case 0x44:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf), "[%s",
base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i", base, indx,
scale);
}
len = strlen(ebuf);
snprintf(ebuf + len, sizeof(ebuf) - len,
"+%x]", *(u8 *)++ b);
E = ebuf;
break;
case 0x45:
snprintf(ebuf, sizeof(ebuf), "[ebp+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x46:
snprintf(ebuf, sizeof(ebuf), "[esi+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x47:
snprintf(ebuf, sizeof(ebuf), "[edi+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x80:
snprintf(ebuf, sizeof(ebuf), "[eax+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x81:
snprintf(ebuf, sizeof(ebuf), "[ecx+%x]",
*(u32 *)++ b);
E = ebuf;
break;
case 0x82:
snprintf(ebuf, sizeof(ebuf), "[edx+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x83:
snprintf(ebuf, sizeof(ebuf), "[ebx+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x84:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf), "[%s",
base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i", base, indx,
scale);
}
len = strlen(ebuf);
snprintf(ebuf + len, sizeof(ebuf) - len,
"+%x]", *(u32 *)++ b);
b += 3;
E = ebuf;
break;
case 0x85:
snprintf(ebuf, sizeof(ebuf), "[ebp+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x86:
snprintf(ebuf, sizeof(ebuf), "[esi+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x87:
snprintf(ebuf, sizeof(ebuf), "[edi+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0xc0:
E = "st(0)";
break;
case 0xc1:
E = "st(1)";
break;
case 0xc2:
E = "st(2)";
break;
case 0xc3:
E = "st(3)";
break;
case 0xc4:
E = "st(4)";
break;
case 0xc5:
E = "st(5)";
break;
case 0xc6:
E = "st(6)";
break;
case 0xc7:
E = "st(7)";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
}
if (order)
{
snprintf(op, opBufSz, "%s", E);
len = strlen(op);
if (Gsz)
{
snprintf(op + len, opBufSz - len, ", %s", G);
}
}
else
{
snprintf(op, opBufSz, "%s, ", G);
len = strlen(op);
snprintf(op + len, opBufSz - len, "%s", E);
}
return b - a;
}
u32 decodeModSM_memonly(bool show, u8 * a, u8 * op, u32 order, u32 Gsz,
u32 Esz)
{
u32 len = 0;
u32 reg = 0;
u32 scale = 0;
u8 *b = a;
u8 *E, *G, *indx, *base, *disp = "\0";
u8 ebuf[32] = { 0 };
setG();
if (Esz)
{
switch (*b & 0xc7)
{
case 0x00:
E = "[bx+si]";
break;
case 0x01:
E = "[bx+di]";
break;
case 0x02:
E = "[bp+si]";
break;
case 0x03:
E = "[bp+di]";
break;
case 0x04:
E = "[si]";
break;
case 0x05:
E = "[di]";
break;
case 0x06:
snprintf(ebuf, sizeof(ebuf), "ds:%x",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x07:
E = "[bx]";
break;
case 0x40:
snprintf(ebuf, sizeof(ebuf), "[bx+si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x41:
snprintf(ebuf, sizeof(ebuf), "[bx+di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x42:
snprintf(ebuf, sizeof(ebuf), "[bp+si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x43:
snprintf(ebuf, sizeof(ebuf), "[bp+di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x44:
snprintf(ebuf, sizeof(ebuf), "[si+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x45:
snprintf(ebuf, sizeof(ebuf), "[di+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x46:
snprintf(ebuf, sizeof(ebuf), "[bp+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x47:
snprintf(ebuf, sizeof(ebuf), "[bx+%x]",
*(u8 *)++ b);
E = ebuf;
case 0x80:
snprintf(ebuf, sizeof(ebuf), "[bx+si+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x81:
snprintf(ebuf, sizeof(ebuf), "[bx+di+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x82:
snprintf(ebuf, sizeof(ebuf), "[bp+si+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x83:
snprintf(ebuf, sizeof(ebuf), "[bp+di+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x84:
snprintf(ebuf, sizeof(ebuf), "[si+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x85:
snprintf(ebuf, sizeof(ebuf), "[di+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x86:
snprintf(ebuf, sizeof(ebuf), "[bp+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
case 0x87:
snprintf(ebuf, sizeof(ebuf), "[bx+%x]",
*(u16 *)++ b);
E = ebuf;
++b;
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
}
else
{
switch (*b & 0xc7)
{
case 0x00:
E = "[eax]";
break;
case 0x01:
E = "[ecx]";
break;
case 0x02:
E = "[edx]";
break;
case 0x03:
E = "[ebx]";
break;
case 0x04:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf),
"[%s]", base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s]", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i]", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s]", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i]", base, indx,
scale);
}
E = ebuf;
break;
case 0x05:
snprintf(ebuf, sizeof(ebuf), "ds:%x",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x06:
E = "[esi]";
break;
case 0x07:
E = "[edi]";
break;
case 0x40:
snprintf(ebuf, sizeof(ebuf), "[eax+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x41:
snprintf(ebuf, sizeof(ebuf), "[ecx+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x42:
snprintf(ebuf, sizeof(ebuf), "[edx+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x43:
snprintf(ebuf, sizeof(ebuf), "[ebx+%x]",
*(u8 *)++ b);
E = ebuf;
case 0x44:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf), "[%s",
base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i", base, indx,
scale);
}
len = strlen(ebuf);
snprintf(ebuf + len, sizeof(ebuf) - len,
"+%x]", *(u8 *)++ b);
E = ebuf;
break;
case 0x45:
snprintf(ebuf, sizeof(ebuf), "[ebp+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x46:
snprintf(ebuf, sizeof(ebuf), "[esi+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x47:
snprintf(ebuf, sizeof(ebuf), "[edi+%x]",
*(u8 *)++ b);
E = ebuf;
break;
case 0x80:
snprintf(ebuf, sizeof(ebuf), "[eax+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x81:
snprintf(ebuf, sizeof(ebuf), "[ecx+%x]",
*(u32 *)++ b);
E = ebuf;
break;
case 0x82:
snprintf(ebuf, sizeof(ebuf), "[edx+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x83:
snprintf(ebuf, sizeof(ebuf), "[ebx+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x84:
++b;
decodeSIB();
if (!indx)
{
snprintf(ebuf, sizeof(ebuf), "[%s",
base);
}
else if (!base)
{
if (!scale)
{
snprintf(ebuf,
sizeof(ebuf),
"[%s", indx);
}
else
{
snprintf(ebuf,
sizeof(ebuf),
"[%s*%i", indx,
scale);
}
}
else if (!scale)
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s", base, indx);
}
else
{
snprintf(ebuf, sizeof(ebuf),
"[%s+%s*%i", base, indx,
scale);
}
len = strlen(ebuf);
snprintf(ebuf + len, sizeof(ebuf) - len,
"+%x]", *(u32 *)++ b);
b += 3;
E = ebuf;
break;
case 0x85:
snprintf(ebuf, sizeof(ebuf), "[ebp+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x86:
snprintf(ebuf, sizeof(ebuf), "[esi+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
case 0x87:
snprintf(ebuf, sizeof(ebuf), "[edi+%x]",
*(u32 *)++ b);
E = ebuf;
b += 3;
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
}
if (order)
{
snprintf(op, opBufSz, "%s", E);
len = strlen(op);
if (Gsz)
{
snprintf(op + len, opBufSz - len, ", %s", G);
}
}
else
{
snprintf(op, opBufSz, "%s, ", G);
len = strlen(op);
snprintf(op + len, opBufSz - len, "%s", E);
}
return b - a;
}
/*******************************************************************************/
/* Décode une adresse mémoire au format intel */
u32 disasm(u8 * a, u8 * string, bool show)
{
u8 *f_entry;
u16 entry;
u8 *b = a;
u32 len = 0;
u32 flip_addr_sz = 0;
u32 flip_imm_sz = 0;
u32 EG = 1;
u32 B = 1;
u8 *s, *prefix, *seg_oride = "\0";
u8 op1[opBufSz] = { 0 };
if (*b == 0xf3)
{
prefix = "rep";
++b;
}
else if (*b == 0xf2)
{
prefix = "repnz";
++b;
}
else if (*b == 0xf0)
{
prefix = "lock";
++b;
}
if (*b == 0x67)
{
flip_addr_sz = 1;
++b;
}
if (*b == 0x66)
{
flip_imm_sz = 1;
++b;
}
switch (*b)
{
case 0x2e:
seg_oride = "cs";
++b;
break;
case 0x36:
seg_oride = "ss";
++b;
break;
case 0x3e:
seg_oride = "ds";
++b;
break;
case 0x26:
seg_oride = "es";
++b;
break;
case 0x64:
seg_oride = "fs";
++b;
break;
case 0x65:
seg_oride = "gs";
++b;
}
if (*b == 0x0f)
{
if (show)
print("Extended opcodes not implimented.\r\n");
return 1000;
}
else
{
switch (*b)
{
case 0x00:
s = "add";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x01:
s = "add";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x02:
s = "add";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x03:
s = "add";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x04:
s = "add";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0x05:
s = "add";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0x06:
s = "push es";
break;
case 0x07:
s = "pop es";
break;
case 0x08:
s = "or";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x09:
s = "or";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x0a:
s = "or";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x0b:
s = "or";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x0c:
s = "or";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0x0d:
s = "or";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0x0e:
s = "push cs";
break;
case 0x10:
s = "adc";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x11:
s = "adc";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x12:
s = "adc";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x13:
s = "adc";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x14:
s = "adc";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0x15:
s = "adc";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0x16:
s = "push ss";
break;
case 0x17:
s = "pop ss";
break;
case 0x18:
s = "sbb";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x19:
s = "sbb";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x1a:
s = "sbb";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x1b:
s = "sbb";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x1c:
s = "sbb";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0x1d:
s = "sbb";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0x1e:
s = "push ds";
break;
case 0x1f:
s = "pop ds";
break;
case 0x20:
s = "and";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x21:
s = "and";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x22:
s = "and";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x23:
s = "and";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x24:
s = "and";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0x25:
s = "and";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0x27:
s = "daa";
break;
case 0x28:
s = "sub";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x29:
s = "sub";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x2a:
s = "sub";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x2b:
s = "sub";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x2c:
s = "sub";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0x2d:
s = "sub";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0x2f:
s = "das";
break;
case 0x30:
s = "xor";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x31:
s = "xor";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x32:
s = "xor";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x33:
s = "xor";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x34:
s = "xor";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0x35:
s = "xor";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0x37:
s = "aaa";
break;
case 0x38:
s = "cmp";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x39:
s = "cmp";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x3a:
s = "cmp";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x3b:
s = "cmp";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x3c:
s = "cmp";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0x3d:
s = "cmp";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0x3f:
s = "aas";
break;
case 0x40:
s = flip_imm_sz ? "inc ax" :
"inc eax";
break;
case 0x41:
s = flip_imm_sz ? "inc cx" :
"inc ecx";
break;
case 0x42:
s = flip_imm_sz ? "inc dx" :
"inc edx";
break;
case 0x43:
s = flip_imm_sz ? "inc bx" :
"inc ebx";
break;
case 0x44:
s = flip_imm_sz ? "inc sp" :
"inc esp";
break;
case 0x45:
s = flip_imm_sz ? "inc bp" :
"inc ebp";
break;
case 0x46:
s = flip_imm_sz ? "inc si" :
"inc esi";
break;
case 0x47:
s = flip_imm_sz ? "inc di" :
"inc edi";
break;
case 0x48:
s = flip_imm_sz ? "dec ax" :
"dec eax";
break;
case 0x49:
s = flip_imm_sz ? "dec cx" :
"dec ecx";
break;
case 0x4a:
s = flip_imm_sz ? "dec dx" :
"dec edx";
break;
case 0x4b:
s = flip_imm_sz ? "dec bx" :
"dec ebx";
break;
case 0x4c:
s = flip_imm_sz ? "dec sp" :
"dec esp";
break;
case 0x4d:
s = flip_imm_sz ? "dec bp" :
"dec ebp";
break;
case 0x4e:
s = flip_imm_sz ? "dec si" :
"dec esi";
break;
case 0x4f:
s = flip_imm_sz ? "dec di" :
"dec edi";
break;
case 0x50:
s = flip_imm_sz ? "push ax" :
"push eax";
break;
case 0x51:
s = flip_imm_sz ? "push cx" :
"push ecx";
break;
case 0x52:
s = flip_imm_sz ? "push dx" :
"push edx";
break;
case 0x53:
s = flip_imm_sz ? "push bx" :
"push ebx";
break;
case 0x54:
s = flip_imm_sz ? "push sp" :
"push esp";
break;
case 0x55:
s = flip_imm_sz ? "push bp" :
"push ebp";
break;
case 0x56:
s = flip_imm_sz ? "push si" :
"push esi";
break;
case 0x57:
s = flip_imm_sz ? "push di" :
"push edi";
break;
case 0x58:
s = flip_imm_sz ? "pop ax" :
"pop eax";
break;
case 0x59:
s = flip_imm_sz ? "pop cx" :
"pop ecx";
break;
case 0x5a:
s = flip_imm_sz ? "pop dx" :
"pop edx";
break;
case 0x5b:
s = flip_imm_sz ? "pop bx" :
"pop ebx";
break;
case 0x5c:
s = flip_imm_sz ? "pop sp" :
"pop esp";
break;
case 0x5d:
s = flip_imm_sz ? "pop bp" :
"pop ebp";
break;
case 0x5e:
s = flip_imm_sz ? "pop si" :
"pop esi";
break;
case 0x5f:
s = flip_imm_sz ? "pop di" :
"pop edi";
break;
case 0x60:
s = flip_imm_sz ? "pushaw" : "pusha";
break;
case 0x61:
s = flip_imm_sz ? "popaw" : "popa";
break;
case 0x63:
s = "arpl";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x68:
s = "push";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1), "%x",
*(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1), "%x",
*(u32 *)++ b);
b += 3;
}
break;
case 0x69:
s = "imul";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
len = strlen(op1);
if (flip_imm_sz)
{
snprintf(op1 + len,
sizeof(op1) - len, ", %x",
*(u16 *)++ b);
++b;
}
else
{
snprintf(op1 + len,
sizeof(op1) - len, ", %x",
*(u32 *)++ b);
b += 3;
}
break;
case 0x6a:
s = "push";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) *b);
case 0x6b:
s = "imul";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", %x", *(u8 *)++ b);
break;
case 0x6c:
s = flip_addr_sz ?
"ins bytes ptr es:[di], dx" :
"insb";
break;
case 0x6d:
if (flip_addr_sz)
{
s = flip_imm_sz ?
"ins word ptr es:[di], dx"
:
"ins dword ptr es:[di], dx";
}
else
{
s = flip_imm_sz ? "insw" : "insd";
}
break;
case 0x6e:
s = flip_addr_sz ?
"outs dx, byte ptr [si]" :
"outsb";
break;
case 0x6f:
if (flip_addr_sz)
{
s = flip_imm_sz ?
"outs dx, word ptr [si]"
:
"outs dx, dword ptr [si]";
}
else
{
s = flip_imm_sz ? "outsw" :
"outsd";
}
break;
case 0x70:
s = "jo";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x71:
s = "jno";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x72:
s = "jb";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x73:
s = "jnb";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x74:
s = "jz";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x75:
s = "jnz";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x76:
s = "jbe";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x77:
s = "ja";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x78:
s = "js";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x79:
s = "jns";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x7a:
s = "jp";
++b;
break;
case 0x7b:
s = "jnp";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x7c:
s = "jl";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x7d:
s = "jnl";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x7e:
s = "jle";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x7f:
s = "jnle";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0x80:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "add";
break;
case 1:
s = "or";
break;
case 2:
s = "adc";
break;
case 3:
s = "sbb";
break;
case 4:
s = "and";
break;
case 5:
s = "sub";
break;
case 6:
s = "xor";
break;
case 7:
s = "cmp";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", %x", *(u8 *)++ b);
break;
case 0x81:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "add";
break;
case 1:
s = "or";
break;
case 2:
s = "adc";
break;
case 3:
s = "sbb";
break;
case 4:
s = "and";
break;
case 5:
s = "sub";
break;
case 6:
s = "xor";
break;
case 7:
s = "cmp";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
if (flip_imm_sz)
{
snprintf(op1 + len,
sizeof(op1) - len, ", %x",
*(u16 *)++ b);
++b;
}
else
{
snprintf(op1 + len,
sizeof(op1) - len, ", %x",
*(u32 *)++ b);
b += 3;
}
break;
case 0x82:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "add";
break;
case 1:
s = "or";
break;
case 2:
s = "adc";
break;
case 3:
s = "sbb";
break;
case 4:
s = "and";
break;
case 5:
s = "sub";
break;
case 6:
s = "xor";
break;
case 7:
s = "cmp";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", %x", *(u8 *)++ b);
break;
case 0x83:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "add";
break;
case 1:
s = "or";
break;
case 2:
s = "adc";
break;
case 3:
s = "sbb";
break;
case 4:
s = "and";
break;
case 5:
s = "sub";
break;
case 6:
s = "xor";
break;
case 7:
s = "cmp";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", %x", *(u8 *)++ b);
break;
case 0x84:
s = "test";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x85:
s = "test";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x86:
s = "xchg";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x87:
s = "xchg";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x88:
s = "mov";
b += decodeModSM(show, ++b, op1, 1, 1,
flip_addr_sz);
break;
case 0x89:
s = "mov";
b += decodeModSM(show, ++b, op1, 1,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x8a:
s = "mov";
b += decodeModSM(show, ++b, op1, 0, 1,
flip_addr_sz);
break;
case 0x8b:
s = "mov";
b += decodeModSM(show, ++b, op1, 0,
flip_imm_sz ? 2 : 3,
flip_addr_sz);
break;
case 0x8c:
s = "mov";
b += decodeModSM(show, ++b, op1, 1, 4,
flip_addr_sz);
break;
case 0x8d:
s = "lea";
b += decodeModSM_memonly(show, ++b, op1, 0,
flip_imm_sz ? 2 :
3, flip_addr_sz);
break;
case 0x8e:
s = "mov";
b += decodeModSM(show, ++b, op1, 0, 4,
flip_addr_sz);
break;
case 0x8f:
s = "pop";
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
break;
case 0x90:
s = flip_imm_sz ? "xchg ax, ax" : "nop";
break;
case 0x91:
s = flip_imm_sz ? "xchg ax, cx" :
"xchg eax, ecx";
break;
case 0x92:
s = flip_imm_sz ? "xchg ax, dx" :
"xchg eax, edx";
break;
case 0x93:
s = flip_imm_sz ? "xchg ax, bx" :
"xchg eax, ebx";
break;
case 0x94:
s = flip_imm_sz ? "xchg ax, sp" :
"xchg eax, esp";
break;
case 0x95:
s = flip_imm_sz ? "xchg ax, bp" :
"xchg eax, ebp";
break;
case 0x96:
s = flip_imm_sz ? "xchg ax, si" :
"xchg eax, esi";
break;
case 0x97:
s = flip_imm_sz ? "xchg ax, di" :
"xchg eax, edi";
break;
case 0x98:
s = flip_imm_sz ? "cbw" : "cwde";
break;
case 0x99:
s = flip_imm_sz ? "cwd" : "cdq";
break;
case 0x9a:
s = "call";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1), "%x:%x",
*(u16 *) (b + 2),
*(u16 *)++ b);
b += 3;
}
else
{
snprintf(op1, sizeof(op1),
"far ptr %x:%x",
*(u16 *) (b + 4),
*(u32 *)++ b);
b += 5;
}
break;
case 0x9b:
s = "wait";
break;
case 0x9c:
s = flip_imm_sz ? "pushfw" : "pushf";
break;
case 0x9d:
s = flip_imm_sz ? "popfw" : "popf";
break;
case 0x9e:
s = "sahf";
break;
case 0x9f:
s = "lahf";
break;
case 0xa0:
s = "mov";
snprintf(op1, sizeof(op1), "al, ds:%x",
*(u32 *)++ b);
b += 3;
break;
case 0xa1:
s = "mov";
snprintf(op1, sizeof(op1),
flip_imm_sz ? "ax, ds:%x" :
"eax, ds:%x", *(u32 *)++ b);
b += 3;
break;
case 0xa2:
s = "mov";
snprintf(op1, sizeof(op1), "ds:%x, al",
*(u32 *)++ b);
b += 3;
break;
case 0xa3:
s = "mov";
snprintf(op1, sizeof(op1),
flip_imm_sz ? "ds:%x, ax" :
"ds:%x, eax", *(u32 *)++ b);
b += 3;
break;
case 0xa4:
s = flip_addr_sz ?
"movs byte ptr es:[di], byte ptr [si]"
: "movsb";
break;
case 0xa5:
if (flip_addr_sz)
{
s = flip_imm_sz ?
"movs word ptr es:[di], word ptr [si]"
:
"movs dword ptr es:[di], dword ptr [si]";
}
else
{
s = flip_imm_sz ? "movsw" :
"movsd";
}
break;
case 0xa6:
s = flip_addr_sz ?
"cmps byte ptr [si], byte ptr es:[di]"
: "cmpsb";
break;
case 0xa7:
if (flip_addr_sz)
{
s = flip_imm_sz ?
"movs word ptr [si], word ptr es:[di]"
:
"movs dword ptr [si], dword ptr es:[di]";
}
else
{
s = flip_imm_sz ? "cmpsw" :
"cmpsd";
}
break;
case 0xa8:
s = "test";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0xa9:
s = "test";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
b += 3;
}
break;
case 0xaa:
s = flip_addr_sz ?
"stos byte ptr es:[di]" :
"stosb";
break;
case 0xab:
if (flip_addr_sz)
{
s = flip_imm_sz ?
"stos word ptr es:[di]"
:
"stos dword ptr es:[di]";
}
else
{
s = flip_imm_sz ? "stosw" :
"stosd";
}
break;
case 0xac:
s = flip_addr_sz ? "lods byte ptr [si]"
: "lodsb";
break;
case 0xad:
if (flip_addr_sz)
{
s = flip_imm_sz ?
"lods word ptr [si]" :
"lods dword ptr [si]";
}
else
{
s = flip_imm_sz ? "lodsw" :
"lodsd";
}
break;
case 0xae:
s = flip_addr_sz ?
"scas byte ptr es:[di]" :
"scasb";
break;
case 0xaf:
if (flip_addr_sz)
{
s = flip_imm_sz ?
"scas word ptr es:[di]"
:
"scas dword ptr es:[di]";
}
else
{
s = flip_imm_sz ? "scasw" :
"scasd";
}
break;
case 0xb0:
s = "mov";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0xb1:
s = "mov";
++b;
snprintf(op1, sizeof(op1), "cl, %x",
(void *) *b);
break;
case 0xb2:
s = "mov";
++b;
snprintf(op1, sizeof(op1), "dl, %x",
(void *) *b);
break;
case 0xb3:
s = "mov";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0xb4:
s = "mov";
++b;
snprintf(op1, sizeof(op1), "ah, %x",
(void *) *b);
break;
case 0xb5:
s = "mov";
++b;
snprintf(op1, sizeof(op1), "ch, %x",
(void *) *b);
break;
case 0xb6:
s = "mov";
++b;
snprintf(op1, sizeof(op1), "dh, %x",
(void *) *b);
break;
case 0xb7:
s = "mov";
++b;
snprintf(op1, sizeof(op1), "bh, %x",
(void *) *b);
break;
case 0xb8:
s = "mov";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"ax, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"eax, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0xb9:
s = "mov";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"cx, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"ecx, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0xba:
s = "mov";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"dx, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"edx, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0xbb:
s = "mov";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"bx, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"ebx, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0xbc:
s = "mov";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"sp, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"esp, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0xbd:
s = "mov";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"bp, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"ebp, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0xbe:
s = "mov";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"si, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"esi, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0xbf:
s = "mov";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"di, %x", *(u16 *)++ b);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"edi, %x", *(u32 *)++ b);
b += 3;
}
break;
case 0xc0:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "rol";
break;
case 1:
s = "ror";
break;
case 2:
s = "rcl";
break;
case 3:
s = "rcr";
break;
case 4:
s = "shl";
break;
case 5:
s = "shr";
break;
case 6:
s = "shl";
break;
case 7:
s = "sar";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", %x", *(u8 *)++ b);
break;
case 0xc1:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "rol";
break;
case 1:
s = "ror";
break;
case 2:
s = "rcl";
break;
case 3:
s = "rcr";
break;
case 4:
s = "shl";
break;
case 5:
s = "shr";
break;
case 6:
s = "shl";
break;
case 7:
s = "sar";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", %x", *(u8 *)++ b);
break;
case 0xc2:
s = "retn";
snprintf(op1, sizeof(op1), "%x",
*(u16 *)++ b);
++b;
break;
case 0xc3:
s = "retn";
break;
case 0xc4:
s = "les";
b += decodeModSM_memonly(show, ++b, op1, 0,
flip_imm_sz ? 2 :
3, flip_addr_sz);
break;
case 0xc5:
s = "lds";
b += decodeModSM_memonly(show, ++b, op1, 0,
flip_imm_sz ? 2 :
3, flip_addr_sz);
break;
case 0xc6:
s = "mov";
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", %x", *(u8 *)++ b);
break;
case 0xc7:
s = "mov";
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
len = strlen(op1);
if (flip_imm_sz)
{
snprintf(op1 + len,
sizeof(op1) - len, ", %x",
*(u16 *)++ b);
++b;
}
else
{
snprintf(op1 + len,
sizeof(op1) - len, ", %x",
*(u32 *)++ b);
b += 3;
}
break;
case 0xc8:
s = "enter";
snprintf(op1, sizeof(op1), "%x, %x",
*(u16 *) (b + 1),
*(u8 *) (b + 3));
b += 3;
break;
case 0xc9:
s = "leave";
break;
case 0xca:
s = "retf";
snprintf(op1, sizeof(op1), "%x",
*(u16 *)++ b);
++b;
break;
case 0xcb:
s = "retf";
break;
case 0xcc:
s = "int 3";
break;
case 0xcd:
s = "int";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) *b);
break;
case 0xce:
s = "into";
break;
case 0xcf:
s = "iret";
break;
case 0xd0:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "rol";
break;
case 1:
s = "ror";
break;
case 2:
s = "rcl";
break;
case 3:
s = "rcr";
break;
case 4:
s = "shl";
break;
case 5:
s = "shr";
break;
case 6:
s = "shl";
break;
case 7:
s = "sar";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", 1");
break;
case 0xd1:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "rol";
break;
case 1:
s = "ror";
break;
case 2:
s = "rcl";
break;
case 3:
s = "rcr";
break;
case 4:
s = "shl";
break;
case 5:
s = "shr";
break;
case 6:
s = "shl";
break;
case 7:
s = "sar";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", 1");
break;
case 0xd2:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "rol";
break;
case 1:
s = "ror";
break;
case 2:
s = "rcl";
break;
case 3:
s = "rcr";
break;
case 4:
s = "shl";
break;
case 5:
s = "shr";
break;
case 6:
s = "shl";
break;
case 7:
s = "sar";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", cl");
break;
case 0xd3:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "rol";
break;
case 1:
s = "ror";
break;
case 2:
s = "rcl";
break;
case 3:
s = "rcr";
break;
case 4:
s = "shl";
break;
case 5:
s = "shr";
break;
case 6:
s = "shl";
break;
case 7:
s = "sar";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
len = strlen(op1);
snprintf(op1 + len, sizeof(op1) - len,
", cl");
break;
case 0xd4:
s = "aam";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) *b);
break;
case 0xd5:
s = "aad";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) *b);
break;
case 0xd6:
s = "salc";
break;
case 0xd7:
s = "xlat";
break;
case 0xd8:
if (*++b == 0xd1)
{
s = "fcom st(1)";
}
else if (*b == 0xd9)
{
s = "fcomp st(1)";
}
else
{
switch ((*b & 0x38) >> 3)
{
case 0:
s = "fadd";
b += decodeModSM_float(show, b, op1, 1, 0, flip_addr_sz);
break;
case 1:
s = "fmul";
b += decodeModSM_float(show, b, op1, 1, 0, flip_addr_sz);
break;
case 2:
s = "fcom";
b += decodeModSM_float(show, b, op1, 1, 0, flip_addr_sz);
break;
case 3:
s = "fcomp";
b += decodeModSM_float(show, b, op1, 1, 0, flip_addr_sz);
break;
case 4:
s = "fsub";
b += decodeModSM_float(show, b, op1, 1, 0, flip_addr_sz);
break;
case 5:
s = "fsubr";
b += decodeModSM_float(show, b, op1, 1, 0, flip_addr_sz);
break;
case 6:
s = "fdiv";
b += decodeModSM_float(show, b, op1, 1, 0, flip_addr_sz);
break;
case 7:
s = "fdivr";
b += decodeModSM_float(show, b, op1, 1, 0, flip_addr_sz);
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
}
break;
case 0xe0:
s = "loopnz";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0xe1:
s = "loopz";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0xe2:
s = "loop";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0xe3:
s = "jcxz";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0xe4:
s = "in";
++b;
snprintf(op1, sizeof(op1), "al, %x",
(void *) *b);
break;
case 0xe5:
s = "in";
++b;
snprintf(op1, sizeof(op1),
flip_imm_sz ? "ax, %x" :
"eax, %x", (void *) *b);
break;
case 0xe6:
s = "out";
++b;
snprintf(op1, sizeof(op1), "%x, al",
(void *) *b);
break;
case 0xe7:
s = "in";
++b;
snprintf(op1, sizeof(op1),
flip_imm_sz ? "%x, ax" :
"%x, eax", (void *) *b);
break;
case 0xe8:
s = "call";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1), "%x",
entry + (u32) b -
(u32) f_entry +
*(u16 *)++ b + 3);
b += 2;
}
else
{
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry +
*(u32 *)++ b + 4);
b += 3;
}
break;
case 0xe9:
s = "jmp";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1),
"near ptr %x",
entry + (u32) b -
(u32) f_entry +
*(u16 *)++ b + 3);
++b;
}
else
{
snprintf(op1, sizeof(op1),
"near ptr %x",
(void *) entry + (u32) b -
(u32) f_entry +
*(u32 *)++ b + 4);
b += 3;
}
break;
case 0xea:
s = "jmp";
if (flip_imm_sz)
{
snprintf(op1, sizeof(op1), "%x:%x",
*(u16 *) (b + 2),
*(u16 *)++ b);
b += 3;
}
else
{
snprintf(op1, sizeof(op1), "%x:%x",
*(u16 *) (b + 4),
*(u32 *)++ b);
b += 5;
}
break;
case 0xeb:
s = "jmp";
++b;
snprintf(op1, sizeof(op1), "%x",
(void *) entry + (u32) b -
(u32) f_entry + *b + 1);
break;
case 0xec:
s = "in al, dx";
break;
case 0xed:
s = flip_imm_sz ? "in ax, dx" :
"in eax, dx";
break;
case 0xee:
s = "out dx, al";
break;
case 0xef:
s = flip_imm_sz ? "out dx, ax" :
"out dx, eax";
break;
case 0xf1:
s = "int 1";
break;
case 0xf4:
s = "hlt";
break;
case 0xf5:
s = "cmc";
break;
case 0xf6:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "test";
len = strlen(op1);
snprintf(op1 + len,
sizeof(op1) - len,
"%x",
*(u8 *)++ b);
break;
case 1:
s = "test";
len = strlen(op1);
snprintf(op1 + len,
sizeof(op1) - len,
"%x",
*(u8 *)++ b);
break;
case 2:
s = "not";
break;
case 3:
s = "neg";
break;
case 4:
s = "mul ax, al, ";
break;
case 5:
s = "imul ax, al, ";
break;
case 6:
s = "div al, ah, ax, ";
break;
case 7:
s = "idiv al, ah, ax, ";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
break;
case 0xf7:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
switch ((*b & 0x38) / 8)
{
case 0:
s = "test";
len = strlen(op1);
if (flip_imm_sz)
{
snprintf(op1 + len,
sizeof
(op1) -
len, "%x",
*(u16 *)++
b);
++b;
}
else
{
snprintf(op1 + len,
sizeof
(op1) -
len, "%x",
*(u32 *)++
b);
b += 3;
}
break;
case 1:
s = "test";
len = strlen(op1);
if (flip_imm_sz)
{
snprintf(op1 + len,
sizeof
(op1) -
len, "%x",
*(u16 *)++
b);
++b;
}
else
{
snprintf(op1 + len,
sizeof
(op1) -
len, "%x",
*(u32 *)++
b);
b += 3;
}
break;
case 2:
s = "not";
break;
case 3:
s = "neg";
break;
case 4:
s = "mul rdx, rax, ";
break;
case 5:
s = "imul rdx, rax, ";
break;
case 6:
s = "div rdx, rax, ";
break;
case 7:
s = "idiv rdx, rax, ";
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
break;
case 0xf8:
s = "clc";
break;
case 0xf9:
s = "stc";
break;
case 0xfa:
s = "cli";
break;
case 0xfb:
s = "sti";
break;
case 0xfc:
s = "cld";
break;
case 0xfd:
s = "std";
break;
case 0xfe:
b += decodeModSM(show, ++b, op1, 1, 0,
flip_addr_sz);
if (!((*b & 0x38) / 8))
{
s = "inc";
}
else if ((*b & 0x38) / 8 == 1)
{
s = "dec";
}
else
{
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
break;
case 0xff:
switch ((*++b & 0x38) >> 3)
{
case 0:
s = "inc";
b += decodeModSM(show, b,
op1, 1, 0,
flip_addr_sz);
break;
case 1:
s = "dec";
b += decodeModSM(show, b,
op1, 1, 0,
flip_addr_sz);
break;
case 2:
s = "call";
b += decodeModSM(show, b,
op1, 1, 0,
flip_addr_sz);
break;
case 3:
s = "callf";
b += decodeModSM_memonly
(show, b, op1, 1,
0, flip_addr_sz);
break;
case 4:
s = "jmp";
b += decodeModSM(show, b,
op1, 1, 0,
flip_addr_sz);
break;
case 5:
s = "jmpf";
b += decodeModSM_memonly
(show, b, op1, 1,
0, flip_addr_sz);
break;
case 6:
s = "push";
b += decodeModSM(show, b,
op1, 1, 0,
flip_addr_sz);
break;
default:
if (show)
print("Invalid Mod R/M byte.");
return 1000;
}
break;
default:
if (show)
print("invalid opcode\r\n");
return 1000;
}
strcompressdelimiter(s, ' ');
if (show)
printf(" %X: %s %s\r\n", (u32) a, s, op1);
else if (string != NULL)
sprintf(string, " %X: %s %s\r\n", (u32) a, s,
op1);
++b;
}
return b - a;
}