ref: 015c3ecea040a3e2b7fdacc73e4cc7d289924ad6
dir: /utils/libmach/8db.c/
#include <lib9.h>
#include <bio.h>
#include "mach.h"
/*
* i386-specific debugger interface
* also amd64 extensions
*/
static char *i386excep(Map*, Rgetter);
static int i386trace(Map*, uvlong, uvlong, uvlong, Tracer);
static uvlong i386frame(Map*, uvlong, uvlong, uvlong, uvlong);
static int i386foll(Map*, uvlong, Rgetter, uvlong*);
static int i386inst(Map*, uvlong, char, char*, int);
static int i386das(Map*, uvlong, char*, int);
static int i386instlen(Map*, uvlong);
static char STARTSYM[] = "_main";
static char PROFSYM[] = "_mainp";
static char FRAMENAME[] = ".frame";
static char *excname[65] =
{
/*[0]*/ "divide error",
/*[1]*/ "debug exception",
/*[2]*/ nil,
/*[3]*/ nil,
/*[4]*/ "overflow",
/*[5]*/ "bounds check",
/*[6]*/ "invalid opcode",
/*[7]*/ "math coprocessor emulation",
/*[8]*/ "double fault",
/*[9]*/ "math coprocessor overrun",
/*[10]*/ "invalid TSS",
/*[11]*/ "segment not present",
/*[12]*/ "stack exception",
/*[13]*/ "general protection violation",
/*[14]*/ "page fault",
/*[15]*/ nil,
/*[16]*/ "math coprocessor error",
/*[17]*/ "alignment check",
/*[18]*/ "machine check",
/*[19]*/ "floating-point exception",
/*[20]*/ nil,
/*[21]*/ nil,
/*[22]*/ nil,
/*[23]*/ nil,
/*[24]*/ "clock",
/*[25]*/ "keyboard",
/*[26]*/ nil,
/*[27]*/ "modem status",
/*[28]*/ "serial line status",
/*[29]*/ nil,
/*[30]*/ "floppy disk",
/*[31]*/ nil,
/*[32]*/ nil,
/*[33]*/ nil,
/*[34]*/ nil,
/*[35]*/ nil,
/*[36]*/ "mouse",
/*[37]*/ "math coprocessor",
/*[38]*/ "hard disk",
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,/* 39-54 */
0,0,0,0,0,0,0,0,0, /* 55-63 */
/*[64]*/ "system call",
};
Machdata i386mach =
{
{0xCC, 0, 0, 0}, /* break point: INT 3 */
1, /* break point size */
leswab, /* convert short to local byte order */
leswal, /* convert long to local byte order */
leswav, /* convert vlong to local byte order */
i386trace, /* C traceback */
i386frame, /* frame finder */
i386excep, /* print exception */
0, /* breakpoint fixup */
leieeesftos, /* single precision float printer */
leieeedftos, /* double precision float printer */
i386foll, /* following addresses */
i386inst, /* print instruction */
i386das, /* dissembler */
i386instlen, /* instruction size calculation */
};
static char*
i386excep(Map *map, Rgetter rget)
{
ulong c;
uvlong pc;
static char buf[16];
c = (*rget)(map, "TRAP");
if(c > 64 || excname[c] == 0) {
if (c == 3) {
pc = (*rget)(map, "PC");
if (get1(map, pc, (uchar*)buf, machdata->bpsize) > 0)
if (memcmp(buf, machdata->bpinst, machdata->bpsize) == 0)
return "breakpoint";
}
snprint(buf, sizeof(buf), "exception %ld", c);
return buf;
} else
return excname[c];
}
static int
i386trace(Map *map, uvlong pc, uvlong sp, uvlong link, Tracer trace)
{
int i;
uvlong osp;
Symbol s, f;
USED(link);
i = 0;
osp = 0;
while(findsym(pc, CTEXT, &s)) {
if (osp == sp)
break;
osp = sp;
if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
break;
if(pc != s.value) { /* not at first instruction */
if(findlocal(&s, FRAMENAME, &f) == 0)
break;
sp += f.value-mach->szaddr;
}
if (geta(map, sp, &pc) < 0)
break;
if(pc == 0)
break;
(*trace)(map, pc, sp, &s);
sp += mach->szaddr;
if(++i > 1000)
break;
}
return i;
}
static uvlong
i386frame(Map *map, uvlong addr, uvlong pc, uvlong sp, uvlong link)
{
Symbol s, f;
USED(link);
while (findsym(pc, CTEXT, &s)) {
if(strcmp(STARTSYM, s.name) == 0 || strcmp(PROFSYM, s.name) == 0)
break;
if(pc != s.value) { /* not first instruction */
if(findlocal(&s, FRAMENAME, &f) == 0)
break;
sp += f.value-mach->szaddr;
}
if (s.value == addr)
return sp;
if (geta(map, sp, &pc) < 0)
break;
sp += mach->szaddr;
}
return 0;
}
/* I386/486 - Disassembler and related functions */
/*
* an instruction
*/
typedef struct Instr Instr;
struct Instr
{
uchar mem[1+1+1+1+2+1+1+4+4]; /* raw instruction */
uvlong addr; /* address of start of instruction */
int n; /* number of bytes in instruction */
char *prefix; /* instr prefix */
char *segment; /* segment override */
uchar jumptype; /* set to the operand type for jump/ret/call */
uchar amd64;
uchar rex; /* REX prefix (or zero) */
char osize; /* 'W' or 'L' (or 'Q' on amd64) */
char asize; /* address size 'W' or 'L' (or 'Q' or amd64) */
uchar mod; /* bits 6-7 of mod r/m field */
uchar reg; /* bits 3-5 of mod r/m field */
char ss; /* bits 6-7 of SIB */
char index; /* bits 3-5 of SIB */
char base; /* bits 0-2 of SIB */
char rip; /* RIP-relative in amd64 mode */
uchar opre; /* f2/f3 could introduce media */
short seg; /* segment of far address */
ulong disp; /* displacement */
ulong imm; /* immediate */
ulong imm2; /* second immediate operand */
uvlong imm64; /* big immediate */
char *curr; /* fill level in output buffer */
char *end; /* end of output buffer */
char *err; /* error message */
};
/* 386 register (ha!) set */
enum{
AX=0,
CX,
DX,
BX,
SP,
BP,
SI,
DI,
/* amd64 */
R8,
R9,
R10,
R11,
R12,
R13,
R14,
R15
};
/* amd64 rex extension byte */
enum{
REXW = 1<<3, /* =1, 64-bit operand size */
REXR = 1<<2, /* extend modrm reg */
REXX = 1<<1, /* extend sib index */
REXB = 1<<0 /* extend modrm r/m, sib base, or opcode reg */
};
/* Operand Format codes */
/*
%A - address size register modifier (!asize -> 'E')
%C - Control register CR0/CR1/CR2
%D - Debug register DR0/DR1/DR2/DR3/DR6/DR7
%I - second immediate operand
%O - Operand size register modifier (!osize -> 'E')
%T - Test register TR6/TR7
%S - size code ('W' or 'L')
%W - Weird opcode: OSIZE == 'W' => "CBW"; else => "CWDE"
%d - displacement 16-32 bits
%e - effective address - Mod R/M value
%f - floating point register F0-F7 - from Mod R/M register
%g - segment register
%i - immediate operand 8-32 bits
%p - PC-relative - signed displacement in immediate field
%r - Reg from Mod R/M
%w - Weird opcode: OSIZE == 'W' => "CWD"; else => "CDQ"
*/
typedef struct Optable Optable;
struct Optable
{
int x;
char operand[2];
void *proto; /* actually either (char*) or (Optable*) */
};
/* Operand decoding codes */
enum {
Ib = 1, /* 8-bit immediate - (no sign extension)*/
Ibs, /* 8-bit immediate (sign extended) */
Jbs, /* 8-bit sign-extended immediate in jump or call */
Iw, /* 16-bit immediate -> imm */
Iw2, /* 16-bit immediate -> imm2 */
Iwd, /* Operand-sized immediate (no sign extension)*/
Iwdq, /* Operand-sized immediate, possibly 64 bits */
Awd, /* Address offset */
Iwds, /* Operand-sized immediate (sign extended) */
RM, /* Word or long R/M field with register (/r) */
RMB, /* Byte R/M field with register (/r) */
RMOP, /* Word or long R/M field with op code (/digit) */
RMOPB, /* Byte R/M field with op code (/digit) */
RMR, /* R/M register only (mod = 11) */
RMM, /* R/M memory only (mod = 0/1/2) */
R0, /* Base reg of Mod R/M is literal 0x00 */
R1, /* Base reg of Mod R/M is literal 0x01 */
FRMOP, /* Floating point R/M field with opcode */
FRMEX, /* Extended floating point R/M field with opcode */
JUMP, /* Jump or Call flag - no operand */
RET, /* Return flag - no operand */
OA, /* literal 0x0a byte */
PTR, /* Seg:Displacement addr (ptr16:16 or ptr16:32) */
AUX, /* Multi-byte op code - Auxiliary table */
AUXMM, /* multi-byte op code - auxiliary table chosen by prefix */
PRE, /* Instr Prefix */
OPRE, /* Instr Prefix or media op extension */
SEG, /* Segment Prefix */
OPOVER, /* Operand size override */
ADDOVER, /* Address size override */
};
static Optable optab0F00[8]=
{
0x00, 0,0, "MOVW LDT,%e",
0x01, 0,0, "MOVW TR,%e",
0x02, 0,0, "MOVW %e,LDT",
0x03, 0,0, "MOVW %e,TR",
0x04, 0,0, "VERR %e",
0x05, 0,0, "VERW %e",
};
static Optable optab0F01[8]=
{
0x00, 0,0, "MOVL GDTR,%e",
0x01, 0,0, "MOVL IDTR,%e",
0x02, 0,0, "MOVL %e,GDTR",
0x03, 0,0, "MOVL %e,IDTR",
0x04, 0,0, "MOVW MSW,%e", /* word */
0x06, 0,0, "MOVW %e,MSW", /* word */
0x07, 0,0, "INVLPG %e", /* or SWAPGS */
};
static Optable optab0F01F8[1]=
{
0x00, 0,0, "SWAPGS",
};
/* 0F71 */
/* 0F72 */
/* 0F73 */
static Optable optab0FAE[8]=
{
0x00, 0,0, "FXSAVE %e",
0x01, 0,0, "FXRSTOR %e",
0x02, 0,0, "LDMXCSR %e",
0x03, 0,0, "STMXCSR %e",
0x05, 0,0, "LFENCE",
0x06, 0,0, "MFENCE",
0x07, 0,0, "SFENCE",
};
/* 0F18 */
/* 0F0D */
static Optable optab0FBA[8]=
{
0x04, Ib,0, "BT%S %i,%e",
0x05, Ib,0, "BTS%S %i,%e",
0x06, Ib,0, "BTR%S %i,%e",
0x07, Ib,0, "BTC%S %i,%e",
};
static Optable optab0F0F[256]=
{
0x0c, 0,0, "PI2FW %m,%M",
0x0d, 0,0, "PI2L %m,%M",
0x1c, 0,0, "PF2IW %m,%M",
0x1d, 0,0, "PF2IL %m,%M",
0x8a, 0,0, "PFNACC %m,%M",
0x8e, 0,0, "PFPNACC %m,%M",
0x90, 0,0, "PFCMPGE %m,%M",
0x94, 0,0, "PFMIN %m,%M",
0x96, 0,0, "PFRCP %m,%M",
0x97, 0,0, "PFRSQRT %m,%M",
0x9a, 0,0, "PFSUB %m,%M",
0x9e, 0,0, "PFADD %m,%M",
0xa0, 0,0, "PFCMPGT %m,%M",
0xa4, 0,0, "PFMAX %m,%M",
0xa6, 0,0, "PFRCPIT1 %m,%M",
0xa7, 0,0, "PFRSQIT1 %m,%M",
0xaa, 0,0, "PFSUBR %m,%M",
0xae, 0,0, "PFACC %m,%M",
0xb0, 0,0, "PFCMPEQ %m,%M",
0xb4, 0,0, "PFMUL %m,%M",
0xb6, 0,0, "PFRCPI2T %m,%M",
0xb7, 0,0, "PMULHRW %m,%M",
0xbb, 0,0, "PSWAPL %m,%M",
};
static Optable optab0FC7[8]=
{
0x01, 0,0, "CMPXCHG8B %e",
};
static Optable optab660F71[8]=
{
0x02, Ib,0, "PSRLW %i,%X",
0x04, Ib,0, "PSRAW %i,%X",
0x06, Ib,0, "PSLLW %i,%X",
};
static Optable optab660F72[8]=
{
0x02, Ib,0, "PSRLL %i,%X",
0x04, Ib,0, "PSRAL %i,%X",
0x06, Ib,0, "PSLLL %i,%X",
};
static Optable optab660F73[8]=
{
0x02, Ib,0, "PSRLQ %i,%X",
0x03, Ib,0, "PSRLO %i,%X",
0x06, Ib,0, "PSLLQ %i,%X",
0x07, Ib,0, "PSLLO %i,%X",
};
static Optable optab660F[256]=
{
0x2B, RM,0, "MOVNTPD %x,%e",
0x2E, RM,0, "UCOMISD %x,%X",
0x2F, RM,0, "COMISD %x,%X",
0x5A, RM,0, "CVTPD2PS %x,%X",
0x5B, RM,0, "CVTPS2PL %x,%X",
0x6A, RM,0, "PUNPCKHLQ %x,%X",
0x6B, RM,0, "PACKSSLW %x,%X",
0x6C, RM,0, "PUNPCKLQDQ %x,%X",
0x6D, RM,0, "PUNPCKHQDQ %x,%X",
0x6E, RM,0, "MOV%S %e,%X",
0x6F, RM,0, "MOVO %x,%X", /* MOVDQA */
0x70, RM,Ib, "PSHUFL %i,%x,%X",
0x71, RMOP,0, optab660F71,
0x72, RMOP,0, optab660F72,
0x73, RMOP,0, optab660F73,
0x7E, RM,0, "MOV%S %X,%e",
0x7F, RM,0, "MOVO %X,%x",
0xC4, RM,Ib, "PINSRW %i,%e,%X",
0xC5, RMR,Ib, "PEXTRW %i,%X,%e",
0xD4, RM,0, "PADDQ %x,%X",
0xD5, RM,0, "PMULLW %x,%X",
0xD6, RM,0, "MOVQ %X,%x",
0xE6, RM,0, "CVTTPD2PL %x,%X",
0xE7, RM,0, "MOVNTO %X,%e",
0xF7, RM,0, "MASKMOVOU %x,%X",
};
static Optable optabF20F[256]=
{
0x10, RM,0, "MOVSD %x,%X",
0x11, RM,0, "MOVSD %X,%x",
0x2A, RM,0, "CVTS%S2SD %e,%X",
0x2C, RM,0, "CVTTSD2S%S %x,%r",
0x2D, RM,0, "CVTSD2S%S %x,%r",
0x5A, RM,0, "CVTSD2SS %x,%X",
0x6F, RM,0, "MOVOU %x,%X",
0x70, RM,Ib, "PSHUFLW %i,%x,%X",
0x7F, RM,0, "MOVOU %X,%x",
0xD6, RM,0, "MOVQOZX %M,%X",
0xE6, RM,0, "CVTPD2PL %x,%X",
};
static Optable optabF30F[256]=
{
0x10, RM,0, "MOVSS %x,%X",
0x11, RM,0, "MOVSS %X,%x",
0x2A, RM,0, "CVTS%S2SS %e,%X",
0x2C, RM,0, "CVTTSS2S%S %x,%r",
0x2D, RM,0, "CVTSS2S%S %x,%r",
0x5A, RM,0, "CVTSS2SD %x,%X",
0x5B, RM,0, "CVTTPS2PL %x,%X",
0x6F, RM,0, "MOVOU %x,%X",
0x70, RM,Ib, "PSHUFHW %i,%x,%X",
0x7E, RM,0, "MOVQOZX %x,%X",
0x7F, RM,0, "MOVOU %X,%x",
0xD6, RM,0, "MOVQOZX %m*,%X",
0xE6, RM,0, "CVTPL2PD %x,%X",
};
static Optable optab0F[256]=
{
0x00, RMOP,0, optab0F00,
0x01, RMOP,0, optab0F01,
0x02, RM,0, "LAR %e,%r",
0x03, RM,0, "LSL %e,%r",
0x05, 0,0, "SYSCALL",
0x06, 0,0, "CLTS",
0x07, 0,0, "SYSRET",
0x08, 0,0, "INVD",
0x09, 0,0, "WBINVD",
0x0B, 0,0, "UD2",
0x0F, RM,AUX, optab0F0F, /* 3DNow! */
0x10, RM,0, "MOVU%s %x,%X",
0x11, RM,0, "MOVU%s %X,%x",
0x12, RM,0, "MOV[H]L%s %x,%X", /* TO DO: H if source is XMM */
0x13, RM,0, "MOVL%s %X,%e",
0x14, RM,0, "UNPCKL%s %x,%X",
0x15, RM,0, "UNPCKH%s %x,%X",
0x16, RM,0, "MOV[L]H%s %x,%X", /* TO DO: L if source is XMM */
0x17, RM,0, "MOVH%s %X,%x",
0x20, RMR,0, "MOVL %C,%e",
0x21, RMR,0, "MOVL %D,%e",
0x22, RMR,0, "MOVL %e,%C",
0x23, RMR,0, "MOVL %e,%D",
0x24, RMR,0, "MOVL %T,%e",
0x26, RMR,0, "MOVL %e,%T",
0x28, RM,0, "MOVA%s %x,%X",
0x29, RM,0, "MOVA%s %X,%x",
0x2A, RM,0, "CVTPL2%s %m*,%X",
0x2B, RM,0, "MOVNT%s %X,%e",
0x2C, RM,0, "CVTT%s2PL %x,%M",
0x2D, RM,0, "CVT%s2PL %x,%M",
0x2E, RM,0, "UCOMISS %x,%X",
0x2F, RM,0, "COMISS %x,%X",
0x30, 0,0, "WRMSR",
0x31, 0,0, "RDTSC",
0x32, 0,0, "RDMSR",
0x33, 0,0, "RDPMC",
0x42, RM,0, "CMOVC %e,%r", /* CF */
0x43, RM,0, "CMOVNC %e,%r", /* ¬ CF */
0x44, RM,0, "CMOVZ %e,%r", /* ZF */
0x45, RM,0, "CMOVNZ %e,%r", /* ¬ ZF */
0x46, RM,0, "CMOVBE %e,%r", /* CF ∨ ZF */
0x47, RM,0, "CMOVA %e,%r", /* ¬CF ∧ ¬ZF */
0x48, RM,0, "CMOVS %e,%r", /* SF */
0x49, RM,0, "CMOVNS %e,%r", /* ¬ SF */
0x4A, RM,0, "CMOVP %e,%r", /* PF */
0x4B, RM,0, "CMOVNP %e,%r", /* ¬ PF */
0x4C, RM,0, "CMOVLT %e,%r", /* LT ≡ OF ≠ SF */
0x4D, RM,0, "CMOVGE %e,%r", /* GE ≡ ZF ∨ SF */
0x4E, RM,0, "CMOVLE %e,%r", /* LE ≡ ZF ∨ LT */
0x4F, RM,0, "CMOVGT %e,%r", /* GT ≡ ¬ZF ∧ GE */
0x50, RM,0, "MOVMSK%s %X,%r", /* TO DO: check */
0x51, RM,0, "SQRT%s %x,%X",
0x52, RM,0, "RSQRT%s %x,%X",
0x53, RM,0, "RCP%s %x,%X",
0x54, RM,0, "AND%s %x,%X",
0x55, RM,0, "ANDN%s %x,%X",
0x56, RM,0, "OR%s %x,%X", /* TO DO: S/D */
0x57, RM,0, "XOR%s %x,%X", /* S/D */
0x58, RM,0, "ADD%s %x,%X", /* S/P S/D */
0x59, RM,0, "MUL%s %x,%X",
0x5A, RM,0, "CVTPS2PD %x,%X",
0x5B, RM,0, "CVTPL2PS %x,%X",
0x5C, RM,0, "SUB%s %x,%X",
0x5D, RM,0, "MIN%s %x,%X",
0x5E, RM,0, "DIV%s %x,%X", /* TO DO: S/P S/D */
0x5F, RM,0, "MAX%s %x,%X",
0x60, RM,0, "PUNPCKLBW %m,%M",
0x61, RM,0, "PUNPCKLWL %m,%M",
0x62, RM,0, "PUNPCKLLQ %m,%M",
0x63, RM,0, "PACKSSWB %m,%M",
0x64, RM,0, "PCMPGTB %m,%M",
0x65, RM,0, "PCMPGTW %m,%M",
0x66, RM,0, "PCMPGTL %m,%M",
0x67, RM,0, "PACKUSWB %m,%M",
0x68, RM,0, "PUNPCKHBW %m,%M",
0x69, RM,0, "PUNPCKHWL %m,%M",
0x6A, RM,0, "PUNPCKHLQ %m,%M",
0x6B, RM,0, "PACKSSLW %m,%M",
0x6E, RM,0, "MOV%S %e,%M",
0x6F, RM,0, "MOVQ %m,%M",
0x70, RM,Ib, "PSHUFW %i,%m,%M",
0x74, RM,0, "PCMPEQB %m,%M",
0x75, RM,0, "PCMPEQW %m,%M",
0x76, RM,0, "PCMPEQL %m,%M",
0x7E, RM,0, "MOV%S %M,%e",
0x7F, RM,0, "MOVQ %M,%m",
0xAE, RMOP,0, optab0FAE,
0xAA, 0,0, "RSM",
0xB0, RM,0, "CMPXCHGB %r,%e",
0xB1, RM,0, "CMPXCHG%S %r,%e",
0xC0, RMB,0, "XADDB %r,%e",
0xC1, RM,0, "XADD%S %r,%e",
0xC2, RM,Ib, "CMP%s %i,%x,%X",
0xC3, RM,0, "MOVNTI%S %r,%e",
0xC6, RM,Ib, "SHUF%s %i,%x,%X",
0xC8, 0,0, "BSWAP AX",
0xC9, 0,0, "BSWAP CX",
0xCA, 0,0, "BSWAP DX",
0xCB, 0,0, "BSWAP BX",
0xCC, 0,0, "BSWAP SP",
0xCD, 0,0, "BSWAP BP",
0xCE, 0,0, "BSWAP SI",
0xCF, 0,0, "BSWAP DI",
0xD1, RM,0, "PSRLW %m,%M",
0xD2, RM,0, "PSRLL %m,%M",
0xD3, RM,0, "PSRLQ %m,%M",
0xD5, RM,0, "PMULLW %m,%M",
0xD6, RM,0, "MOVQOZX %m*,%X",
0xD7, RM,0, "PMOVMSKB %m,%r",
0xD8, RM,0, "PSUBUSB %m,%M",
0xD9, RM,0, "PSUBUSW %m,%M",
0xDA, RM,0, "PMINUB %m,%M",
0xDB, RM,0, "PAND %m,%M",
0xDC, RM,0, "PADDUSB %m,%M",
0xDD, RM,0, "PADDUSW %m,%M",
0xDE, RM,0, "PMAXUB %m,%M",
0xDF, RM,0, "PANDN %m,%M",
0xE0, RM,0, "PAVGB %m,%M",
0xE1, RM,0, "PSRAW %m,%M",
0xE2, RM,0, "PSRAL %m,%M",
0xE3, RM,0, "PAVGW %m,%M",
0xE4, RM,0, "PMULHUW %m,%M",
0xE5, RM,0, "PMULHW %m,%M",
0xE7, RM,0, "MOVNTQ %M,%e",
0xE8, RM,0, "PSUBSB %m,%M",
0xE9, RM,0, "PSUBSW %m,%M",
0xEA, RM,0, "PMINSW %m,%M",
0xEB, RM,0, "POR %m,%M",
0xEC, RM,0, "PADDSB %m,%M",
0xED, RM,0, "PADDSW %m,%M",
0xEE, RM,0, "PMAXSW %m,%M",
0xEF, RM,0, "PXOR %m,%M",
0xF1, RM,0, "PSLLW %m,%M",
0xF2, RM,0, "PSLLL %m,%M",
0xF3, RM,0, "PSLLQ %m,%M",
0xF4, RM,0, "PMULULQ %m,%M",
0xF5, RM,0, "PMADDWL %m,%M",
0xF6, RM,0, "PSADBW %m,%M",
0xF7, RMR,0, "MASKMOVQ %m,%M",
0xF8, RM,0, "PSUBB %m,%M",
0xF9, RM,0, "PSUBW %m,%M",
0xFA, RM,0, "PSUBL %m,%M",
0xFC, RM,0, "PADDB %m,%M",
0xFD, RM,0, "PADDW %m,%M",
0xFE, RM,0, "PADDL %m,%M",
0x80, Iwds,0, "JOS %p",
0x81, Iwds,0, "JOC %p",
0x82, Iwds,0, "JCS %p",
0x83, Iwds,0, "JCC %p",
0x84, Iwds,0, "JEQ %p",
0x85, Iwds,0, "JNE %p",
0x86, Iwds,0, "JLS %p",
0x87, Iwds,0, "JHI %p",
0x88, Iwds,0, "JMI %p",
0x89, Iwds,0, "JPL %p",
0x8a, Iwds,0, "JPS %p",
0x8b, Iwds,0, "JPC %p",
0x8c, Iwds,0, "JLT %p",
0x8d, Iwds,0, "JGE %p",
0x8e, Iwds,0, "JLE %p",
0x8f, Iwds,0, "JGT %p",
0x90, RMB,0, "SETOS %e",
0x91, RMB,0, "SETOC %e",
0x92, RMB,0, "SETCS %e",
0x93, RMB,0, "SETCC %e",
0x94, RMB,0, "SETEQ %e",
0x95, RMB,0, "SETNE %e",
0x96, RMB,0, "SETLS %e",
0x97, RMB,0, "SETHI %e",
0x98, RMB,0, "SETMI %e",
0x99, RMB,0, "SETPL %e",
0x9a, RMB,0, "SETPS %e",
0x9b, RMB,0, "SETPC %e",
0x9c, RMB,0, "SETLT %e",
0x9d, RMB,0, "SETGE %e",
0x9e, RMB,0, "SETLE %e",
0x9f, RMB,0, "SETGT %e",
0xa0, 0,0, "PUSHL FS",
0xa1, 0,0, "POPL FS",
0xa2, 0,0, "CPUID",
0xa3, RM,0, "BT%S %r,%e",
0xa4, RM,Ib, "SHLD%S %r,%i,%e",
0xa5, RM,0, "SHLD%S %r,CL,%e",
0xa8, 0,0, "PUSHL GS",
0xa9, 0,0, "POPL GS",
0xab, RM,0, "BTS%S %r,%e",
0xac, RM,Ib, "SHRD%S %r,%i,%e",
0xad, RM,0, "SHRD%S %r,CL,%e",
0xaf, RM,0, "IMUL%S %e,%r",
0xb2, RMM,0, "LSS %e,%r",
0xb3, RM,0, "BTR%S %r,%e",
0xb4, RMM,0, "LFS %e,%r",
0xb5, RMM,0, "LGS %e,%r",
0xb6, RMB,0, "MOVBZX %e,%R",
0xb7, RM,0, "MOVWZX %e,%R",
0xba, RMOP,0, optab0FBA,
0xbb, RM,0, "BTC%S %e,%r",
0xbc, RM,0, "BSF%S %e,%r",
0xbd, RM,0, "BSR%S %e,%r",
0xbe, RMB,0, "MOVBSX %e,%R",
0xbf, RM,0, "MOVWSX %e,%R",
0xc7, RMOP,0, optab0FC7,
};
static Optable optab80[8]=
{
0x00, Ib,0, "ADDB %i,%e",
0x01, Ib,0, "ORB %i,%e",
0x02, Ib,0, "ADCB %i,%e",
0x03, Ib,0, "SBBB %i,%e",
0x04, Ib,0, "ANDB %i,%e",
0x05, Ib,0, "SUBB %i,%e",
0x06, Ib,0, "XORB %i,%e",
0x07, Ib,0, "CMPB %e,%i",
};
static Optable optab81[8]=
{
0x00, Iwd,0, "ADD%S %i,%e",
0x01, Iwd,0, "OR%S %i,%e",
0x02, Iwd,0, "ADC%S %i,%e",
0x03, Iwd,0, "SBB%S %i,%e",
0x04, Iwd,0, "AND%S %i,%e",
0x05, Iwd,0, "SUB%S %i,%e",
0x06, Iwd,0, "XOR%S %i,%e",
0x07, Iwd,0, "CMP%S %e,%i",
};
static Optable optab83[8]=
{
0x00, Ibs,0, "ADD%S %i,%e",
0x01, Ibs,0, "OR%S %i,%e",
0x02, Ibs,0, "ADC%S %i,%e",
0x03, Ibs,0, "SBB%S %i,%e",
0x04, Ibs,0, "AND%S %i,%e",
0x05, Ibs,0, "SUB%S %i,%e",
0x06, Ibs,0, "XOR%S %i,%e",
0x07, Ibs,0, "CMP%S %e,%i",
};
static Optable optabC0[8] =
{
0x00, Ib,0, "ROLB %i,%e",
0x01, Ib,0, "RORB %i,%e",
0x02, Ib,0, "RCLB %i,%e",
0x03, Ib,0, "RCRB %i,%e",
0x04, Ib,0, "SHLB %i,%e",
0x05, Ib,0, "SHRB %i,%e",
0x07, Ib,0, "SARB %i,%e",
};
static Optable optabC1[8] =
{
0x00, Ib,0, "ROL%S %i,%e",
0x01, Ib,0, "ROR%S %i,%e",
0x02, Ib,0, "RCL%S %i,%e",
0x03, Ib,0, "RCR%S %i,%e",
0x04, Ib,0, "SHL%S %i,%e",
0x05, Ib,0, "SHR%S %i,%e",
0x07, Ib,0, "SAR%S %i,%e",
};
static Optable optabD0[8] =
{
0x00, 0,0, "ROLB %e",
0x01, 0,0, "RORB %e",
0x02, 0,0, "RCLB %e",
0x03, 0,0, "RCRB %e",
0x04, 0,0, "SHLB %e",
0x05, 0,0, "SHRB %e",
0x07, 0,0, "SARB %e",
};
static Optable optabD1[8] =
{
0x00, 0,0, "ROL%S %e",
0x01, 0,0, "ROR%S %e",
0x02, 0,0, "RCL%S %e",
0x03, 0,0, "RCR%S %e",
0x04, 0,0, "SHL%S %e",
0x05, 0,0, "SHR%S %e",
0x07, 0,0, "SAR%S %e",
};
static Optable optabD2[8] =
{
0x00, 0,0, "ROLB CL,%e",
0x01, 0,0, "RORB CL,%e",
0x02, 0,0, "RCLB CL,%e",
0x03, 0,0, "RCRB CL,%e",
0x04, 0,0, "SHLB CL,%e",
0x05, 0,0, "SHRB CL,%e",
0x07, 0,0, "SARB CL,%e",
};
static Optable optabD3[8] =
{
0x00, 0,0, "ROL%S CL,%e",
0x01, 0,0, "ROR%S CL,%e",
0x02, 0,0, "RCL%S CL,%e",
0x03, 0,0, "RCR%S CL,%e",
0x04, 0,0, "SHL%S CL,%e",
0x05, 0,0, "SHR%S CL,%e",
0x07, 0,0, "SAR%S CL,%e",
};
static Optable optabD8[8+8] =
{
0x00, 0,0, "FADDF %e,F0",
0x01, 0,0, "FMULF %e,F0",
0x02, 0,0, "FCOMF %e,F0",
0x03, 0,0, "FCOMFP %e,F0",
0x04, 0,0, "FSUBF %e,F0",
0x05, 0,0, "FSUBRF %e,F0",
0x06, 0,0, "FDIVF %e,F0",
0x07, 0,0, "FDIVRF %e,F0",
0x08, 0,0, "FADDD %f,F0",
0x09, 0,0, "FMULD %f,F0",
0x0a, 0,0, "FCOMD %f,F0",
0x0b, 0,0, "FCOMPD %f,F0",
0x0c, 0,0, "FSUBD %f,F0",
0x0d, 0,0, "FSUBRD %f,F0",
0x0e, 0,0, "FDIVD %f,F0",
0x0f, 0,0, "FDIVRD %f,F0",
};
/*
* optabD9 and optabDB use the following encoding:
* if (0 <= modrm <= 2) instruction = optabDx[modrm&0x07];
* else instruction = optabDx[(modrm&0x3f)+8];
*
* the instructions for MOD == 3, follow the 8 instructions
* for the other MOD values stored at the front of the table.
*/
static Optable optabD9[64+8] =
{
0x00, 0,0, "FMOVF %e,F0",
0x02, 0,0, "FMOVF F0,%e",
0x03, 0,0, "FMOVFP F0,%e",
0x04, 0,0, "FLDENV%S %e",
0x05, 0,0, "FLDCW %e",
0x06, 0,0, "FSTENV%S %e",
0x07, 0,0, "FSTCW %e",
0x08, 0,0, "FMOVD F0,F0", /* Mod R/M = 11xx xxxx*/
0x09, 0,0, "FMOVD F1,F0",
0x0a, 0,0, "FMOVD F2,F0",
0x0b, 0,0, "FMOVD F3,F0",
0x0c, 0,0, "FMOVD F4,F0",
0x0d, 0,0, "FMOVD F5,F0",
0x0e, 0,0, "FMOVD F6,F0",
0x0f, 0,0, "FMOVD F7,F0",
0x10, 0,0, "FXCHD F0,F0",
0x11, 0,0, "FXCHD F1,F0",
0x12, 0,0, "FXCHD F2,F0",
0x13, 0,0, "FXCHD F3,F0",
0x14, 0,0, "FXCHD F4,F0",
0x15, 0,0, "FXCHD F5,F0",
0x16, 0,0, "FXCHD F6,F0",
0x17, 0,0, "FXCHD F7,F0",
0x18, 0,0, "FNOP",
0x28, 0,0, "FCHS",
0x29, 0,0, "FABS",
0x2c, 0,0, "FTST",
0x2d, 0,0, "FXAM",
0x30, 0,0, "FLD1",
0x31, 0,0, "FLDL2T",
0x32, 0,0, "FLDL2E",
0x33, 0,0, "FLDPI",
0x34, 0,0, "FLDLG2",
0x35, 0,0, "FLDLN2",
0x36, 0,0, "FLDZ",
0x38, 0,0, "F2XM1",
0x39, 0,0, "FYL2X",
0x3a, 0,0, "FPTAN",
0x3b, 0,0, "FPATAN",
0x3c, 0,0, "FXTRACT",
0x3d, 0,0, "FPREM1",
0x3e, 0,0, "FDECSTP",
0x3f, 0,0, "FNCSTP",
0x40, 0,0, "FPREM",
0x41, 0,0, "FYL2XP1",
0x42, 0,0, "FSQRT",
0x43, 0,0, "FSINCOS",
0x44, 0,0, "FRNDINT",
0x45, 0,0, "FSCALE",
0x46, 0,0, "FSIN",
0x47, 0,0, "FCOS",
};
static Optable optabDA[8+8] =
{
0x00, 0,0, "FADDL %e,F0",
0x01, 0,0, "FMULL %e,F0",
0x02, 0,0, "FCOML %e,F0",
0x03, 0,0, "FCOMLP %e,F0",
0x04, 0,0, "FSUBL %e,F0",
0x05, 0,0, "FSUBRL %e,F0",
0x06, 0,0, "FDIVL %e,F0",
0x07, 0,0, "FDIVRL %e,F0",
0x0d, R1,0, "FUCOMPP",
};
static Optable optabDB[8+64] =
{
0x00, 0,0, "FMOVL %e,F0",
0x02, 0,0, "FMOVL F0,%e",
0x03, 0,0, "FMOVLP F0,%e",
0x05, 0,0, "FMOVX %e,F0",
0x07, 0,0, "FMOVXP F0,%e",
0x2a, 0,0, "FCLEX",
0x2b, 0,0, "FINIT",
};
static Optable optabDC[8+8] =
{
0x00, 0,0, "FADDD %e,F0",
0x01, 0,0, "FMULD %e,F0",
0x02, 0,0, "FCOMD %e,F0",
0x03, 0,0, "FCOMDP %e,F0",
0x04, 0,0, "FSUBD %e,F0",
0x05, 0,0, "FSUBRD %e,F0",
0x06, 0,0, "FDIVD %e,F0",
0x07, 0,0, "FDIVRD %e,F0",
0x08, 0,0, "FADDD F0,%f",
0x09, 0,0, "FMULD F0,%f",
0x0c, 0,0, "FSUBRD F0,%f",
0x0d, 0,0, "FSUBD F0,%f",
0x0e, 0,0, "FDIVRD F0,%f",
0x0f, 0,0, "FDIVD F0,%f",
};
static Optable optabDD[8+8] =
{
0x00, 0,0, "FMOVD %e,F0",
0x02, 0,0, "FMOVD F0,%e",
0x03, 0,0, "FMOVDP F0,%e",
0x04, 0,0, "FRSTOR%S %e",
0x06, 0,0, "FSAVE%S %e",
0x07, 0,0, "FSTSW %e",
0x08, 0,0, "FFREED %f",
0x0a, 0,0, "FMOVD %f,F0",
0x0b, 0,0, "FMOVDP %f,F0",
0x0c, 0,0, "FUCOMD %f,F0",
0x0d, 0,0, "FUCOMDP %f,F0",
};
static Optable optabDE[8+8] =
{
0x00, 0,0, "FADDW %e,F0",
0x01, 0,0, "FMULW %e,F0",
0x02, 0,0, "FCOMW %e,F0",
0x03, 0,0, "FCOMWP %e,F0",
0x04, 0,0, "FSUBW %e,F0",
0x05, 0,0, "FSUBRW %e,F0",
0x06, 0,0, "FDIVW %e,F0",
0x07, 0,0, "FDIVRW %e,F0",
0x08, 0,0, "FADDDP F0,%f",
0x09, 0,0, "FMULDP F0,%f",
0x0b, R1,0, "FCOMPDP",
0x0c, 0,0, "FSUBRDP F0,%f",
0x0d, 0,0, "FSUBDP F0,%f",
0x0e, 0,0, "FDIVRDP F0,%f",
0x0f, 0,0, "FDIVDP F0,%f",
};
static Optable optabDF[8+8] =
{
0x00, 0,0, "FMOVW %e,F0",
0x02, 0,0, "FMOVW F0,%e",
0x03, 0,0, "FMOVWP F0,%e",
0x04, 0,0, "FBLD %e",
0x05, 0,0, "FMOVL %e,F0",
0x06, 0,0, "FBSTP %e",
0x07, 0,0, "FMOVLP F0,%e",
0x0c, R0,0, "FSTSW %OAX",
};
static Optable optabF6[8] =
{
0x00, Ib,0, "TESTB %i,%e",
0x02, 0,0, "NOTB %e",
0x03, 0,0, "NEGB %e",
0x04, 0,0, "MULB AL,%e",
0x05, 0,0, "IMULB AL,%e",
0x06, 0,0, "DIVB AL,%e",
0x07, 0,0, "IDIVB AL,%e",
};
static Optable optabF7[8] =
{
0x00, Iwd,0, "TEST%S %i,%e",
0x02, 0,0, "NOT%S %e",
0x03, 0,0, "NEG%S %e",
0x04, 0,0, "MUL%S %OAX,%e",
0x05, 0,0, "IMUL%S %OAX,%e",
0x06, 0,0, "DIV%S %OAX,%e",
0x07, 0,0, "IDIV%S %OAX,%e",
};
static Optable optabFE[8] =
{
0x00, 0,0, "INCB %e",
0x01, 0,0, "DECB %e",
};
static Optable optabFF[8] =
{
0x00, 0,0, "INC%S %e",
0x01, 0,0, "DEC%S %e",
0x02, JUMP,0, "CALL* %e",
0x03, JUMP,0, "CALLF* %e",
0x04, JUMP,0, "JMP* %e",
0x05, JUMP,0, "JMPF* %e",
0x06, 0,0, "PUSHL %e",
};
static Optable optable[256+1] =
{
0x00, RMB,0, "ADDB %r,%e",
0x01, RM,0, "ADD%S %r,%e",
0x02, RMB,0, "ADDB %e,%r",
0x03, RM,0, "ADD%S %e,%r",
0x04, Ib,0, "ADDB %i,AL",
0x05, Iwd,0, "ADD%S %i,%OAX",
0x06, 0,0, "PUSHL ES",
0x07, 0,0, "POPL ES",
0x08, RMB,0, "ORB %r,%e",
0x09, RM,0, "OR%S %r,%e",
0x0a, RMB,0, "ORB %e,%r",
0x0b, RM,0, "OR%S %e,%r",
0x0c, Ib,0, "ORB %i,AL",
0x0d, Iwd,0, "OR%S %i,%OAX",
0x0e, 0,0, "PUSHL CS",
0x0f, AUXMM,0, optab0F,
0x10, RMB,0, "ADCB %r,%e",
0x11, RM,0, "ADC%S %r,%e",
0x12, RMB,0, "ADCB %e,%r",
0x13, RM,0, "ADC%S %e,%r",
0x14, Ib,0, "ADCB %i,AL",
0x15, Iwd,0, "ADC%S %i,%OAX",
0x16, 0,0, "PUSHL SS",
0x17, 0,0, "POPL SS",
0x18, RMB,0, "SBBB %r,%e",
0x19, RM,0, "SBB%S %r,%e",
0x1a, RMB,0, "SBBB %e,%r",
0x1b, RM,0, "SBB%S %e,%r",
0x1c, Ib,0, "SBBB %i,AL",
0x1d, Iwd,0, "SBB%S %i,%OAX",
0x1e, 0,0, "PUSHL DS",
0x1f, 0,0, "POPL DS",
0x20, RMB,0, "ANDB %r,%e",
0x21, RM,0, "AND%S %r,%e",
0x22, RMB,0, "ANDB %e,%r",
0x23, RM,0, "AND%S %e,%r",
0x24, Ib,0, "ANDB %i,AL",
0x25, Iwd,0, "AND%S %i,%OAX",
0x26, SEG,0, "ES:",
0x27, 0,0, "DAA",
0x28, RMB,0, "SUBB %r,%e",
0x29, RM,0, "SUB%S %r,%e",
0x2a, RMB,0, "SUBB %e,%r",
0x2b, RM,0, "SUB%S %e,%r",
0x2c, Ib,0, "SUBB %i,AL",
0x2d, Iwd,0, "SUB%S %i,%OAX",
0x2e, SEG,0, "CS:",
0x2f, 0,0, "DAS",
0x30, RMB,0, "XORB %r,%e",
0x31, RM,0, "XOR%S %r,%e",
0x32, RMB,0, "XORB %e,%r",
0x33, RM,0, "XOR%S %e,%r",
0x34, Ib,0, "XORB %i,AL",
0x35, Iwd,0, "XOR%S %i,%OAX",
0x36, SEG,0, "SS:",
0x37, 0,0, "AAA",
0x38, RMB,0, "CMPB %r,%e",
0x39, RM,0, "CMP%S %r,%e",
0x3a, RMB,0, "CMPB %e,%r",
0x3b, RM,0, "CMP%S %e,%r",
0x3c, Ib,0, "CMPB %i,AL",
0x3d, Iwd,0, "CMP%S %i,%OAX",
0x3e, SEG,0, "DS:",
0x3f, 0,0, "AAS",
0x40, 0,0, "INC%S %OAX",
0x41, 0,0, "INC%S %OCX",
0x42, 0,0, "INC%S %ODX",
0x43, 0,0, "INC%S %OBX",
0x44, 0,0, "INC%S %OSP",
0x45, 0,0, "INC%S %OBP",
0x46, 0,0, "INC%S %OSI",
0x47, 0,0, "INC%S %ODI",
0x48, 0,0, "DEC%S %OAX",
0x49, 0,0, "DEC%S %OCX",
0x4a, 0,0, "DEC%S %ODX",
0x4b, 0,0, "DEC%S %OBX",
0x4c, 0,0, "DEC%S %OSP",
0x4d, 0,0, "DEC%S %OBP",
0x4e, 0,0, "DEC%S %OSI",
0x4f, 0,0, "DEC%S %ODI",
0x50, 0,0, "PUSH%S %OAX",
0x51, 0,0, "PUSH%S %OCX",
0x52, 0,0, "PUSH%S %ODX",
0x53, 0,0, "PUSH%S %OBX",
0x54, 0,0, "PUSH%S %OSP",
0x55, 0,0, "PUSH%S %OBP",
0x56, 0,0, "PUSH%S %OSI",
0x57, 0,0, "PUSH%S %ODI",
0x58, 0,0, "POP%S %OAX",
0x59, 0,0, "POP%S %OCX",
0x5a, 0,0, "POP%S %ODX",
0x5b, 0,0, "POP%S %OBX",
0x5c, 0,0, "POP%S %OSP",
0x5d, 0,0, "POP%S %OBP",
0x5e, 0,0, "POP%S %OSI",
0x5f, 0,0, "POP%S %ODI",
0x60, 0,0, "PUSHA%S",
0x61, 0,0, "POPA%S",
0x62, RMM,0, "BOUND %e,%r",
0x63, RM,0, "ARPL %r,%e",
0x64, SEG,0, "FS:",
0x65, SEG,0, "GS:",
0x66, OPOVER,0, "",
0x67, ADDOVER,0, "",
0x68, Iwd,0, "PUSH%S %i",
0x69, RM,Iwd, "IMUL%S %e,%i,%r",
0x6a, Ib,0, "PUSH%S %i",
0x6b, RM,Ibs, "IMUL%S %e,%i,%r",
0x6c, 0,0, "INSB DX,(%ODI)",
0x6d, 0,0, "INS%S DX,(%ODI)",
0x6e, 0,0, "OUTSB (%ASI),DX",
0x6f, 0,0, "OUTS%S (%ASI),DX",
0x70, Jbs,0, "JOS %p",
0x71, Jbs,0, "JOC %p",
0x72, Jbs,0, "JCS %p",
0x73, Jbs,0, "JCC %p",
0x74, Jbs,0, "JEQ %p",
0x75, Jbs,0, "JNE %p",
0x76, Jbs,0, "JLS %p",
0x77, Jbs,0, "JHI %p",
0x78, Jbs,0, "JMI %p",
0x79, Jbs,0, "JPL %p",
0x7a, Jbs,0, "JPS %p",
0x7b, Jbs,0, "JPC %p",
0x7c, Jbs,0, "JLT %p",
0x7d, Jbs,0, "JGE %p",
0x7e, Jbs,0, "JLE %p",
0x7f, Jbs,0, "JGT %p",
0x80, RMOPB,0, optab80,
0x81, RMOP,0, optab81,
0x83, RMOP,0, optab83,
0x84, RMB,0, "TESTB %r,%e",
0x85, RM,0, "TEST%S %r,%e",
0x86, RMB,0, "XCHGB %r,%e",
0x87, RM,0, "XCHG%S %r,%e",
0x88, RMB,0, "MOVB %r,%e",
0x89, RM,0, "MOV%S %r,%e",
0x8a, RMB,0, "MOVB %e,%r",
0x8b, RM,0, "MOV%S %e,%r",
0x8c, RM,0, "MOVW %g,%e",
0x8d, RM,0, "LEA%S %e,%r",
0x8e, RM,0, "MOVW %e,%g",
0x8f, RM,0, "POP%S %e",
0x90, 0,0, "NOP",
0x91, 0,0, "XCHG %OCX,%OAX",
0x92, 0,0, "XCHG %ODX,%OAX",
0x93, 0,0, "XCHG %OBX,%OAX",
0x94, 0,0, "XCHG %OSP,%OAX",
0x95, 0,0, "XCHG %OBP,%OAX",
0x96, 0,0, "XCHG %OSI,%OAX",
0x97, 0,0, "XCHG %ODI,%OAX",
0x98, 0,0, "%W", /* miserable CBW or CWDE */
0x99, 0,0, "%w", /* idiotic CWD or CDQ */
0x9a, PTR,0, "CALL%S %d",
0x9b, 0,0, "WAIT",
0x9c, 0,0, "PUSHF",
0x9d, 0,0, "POPF",
0x9e, 0,0, "SAHF",
0x9f, 0,0, "LAHF",
0xa0, Awd,0, "MOVB %i,AL",
0xa1, Awd,0, "MOV%S %i,%OAX",
0xa2, Awd,0, "MOVB AL,%i",
0xa3, Awd,0, "MOV%S %OAX,%i",
0xa4, 0,0, "MOVSB (%ASI),(%ADI)",
0xa5, 0,0, "MOVS%S (%ASI),(%ADI)",
0xa6, 0,0, "CMPSB (%ASI),(%ADI)",
0xa7, 0,0, "CMPS%S (%ASI),(%ADI)",
0xa8, Ib,0, "TESTB %i,AL",
0xa9, Iwd,0, "TEST%S %i,%OAX",
0xaa, 0,0, "STOSB AL,(%ADI)",
0xab, 0,0, "STOS%S %OAX,(%ADI)",
0xac, 0,0, "LODSB (%ASI),AL",
0xad, 0,0, "LODS%S (%ASI),%OAX",
0xae, 0,0, "SCASB (%ADI),AL",
0xaf, 0,0, "SCAS%S (%ADI),%OAX",
0xb0, Ib,0, "MOVB %i,AL",
0xb1, Ib,0, "MOVB %i,CL",
0xb2, Ib,0, "MOVB %i,DL",
0xb3, Ib,0, "MOVB %i,BL",
0xb4, Ib,0, "MOVB %i,AH",
0xb5, Ib,0, "MOVB %i,CH",
0xb6, Ib,0, "MOVB %i,DH",
0xb7, Ib,0, "MOVB %i,BH",
0xb8, Iwdq,0, "MOV%S %i,%OAX",
0xb9, Iwdq,0, "MOV%S %i,%OCX",
0xba, Iwdq,0, "MOV%S %i,%ODX",
0xbb, Iwdq,0, "MOV%S %i,%OBX",
0xbc, Iwdq,0, "MOV%S %i,%OSP",
0xbd, Iwdq,0, "MOV%S %i,%OBP",
0xbe, Iwdq,0, "MOV%S %i,%OSI",
0xbf, Iwdq,0, "MOV%S %i,%ODI",
0xc0, RMOPB,0, optabC0,
0xc1, RMOP,0, optabC1,
0xc2, Iw,0, "RET %i",
0xc3, RET,0, "RET",
0xc4, RM,0, "LES %e,%r",
0xc5, RM,0, "LDS %e,%r",
0xc6, RMB,Ib, "MOVB %i,%e",
0xc7, RM,Iwd, "MOV%S %i,%e",
0xc8, Iw2,Ib, "ENTER %i,%I", /* loony ENTER */
0xc9, RET,0, "LEAVE", /* bizarre LEAVE */
0xca, Iw,0, "RETF %i",
0xcb, RET,0, "RETF",
0xcc, 0,0, "INT 3",
0xcd, Ib,0, "INTB %i",
0xce, 0,0, "INTO",
0xcf, 0,0, "IRET",
0xd0, RMOPB,0, optabD0,
0xd1, RMOP,0, optabD1,
0xd2, RMOPB,0, optabD2,
0xd3, RMOP,0, optabD3,
0xd4, OA,0, "AAM",
0xd5, OA,0, "AAD",
0xd7, 0,0, "XLAT",
0xd8, FRMOP,0, optabD8,
0xd9, FRMEX,0, optabD9,
0xda, FRMOP,0, optabDA,
0xdb, FRMEX,0, optabDB,
0xdc, FRMOP,0, optabDC,
0xdd, FRMOP,0, optabDD,
0xde, FRMOP,0, optabDE,
0xdf, FRMOP,0, optabDF,
0xe0, Jbs,0, "LOOPNE %p",
0xe1, Jbs,0, "LOOPE %p",
0xe2, Jbs,0, "LOOP %p",
0xe3, Jbs,0, "JCXZ %p",
0xe4, Ib,0, "INB %i,AL",
0xe5, Ib,0, "IN%S %i,%OAX",
0xe6, Ib,0, "OUTB AL,%i",
0xe7, Ib,0, "OUT%S %OAX,%i",
0xe8, Iwds,0, "CALL %p",
0xe9, Iwds,0, "JMP %p",
0xea, PTR,0, "JMP %d",
0xeb, Jbs,0, "JMP %p",
0xec, 0,0, "INB DX,AL",
0xed, 0,0, "IN%S DX,%OAX",
0xee, 0,0, "OUTB AL,DX",
0xef, 0,0, "OUT%S %OAX,DX",
0xf0, PRE,0, "LOCK",
0xf2, OPRE,0, "REPNE",
0xf3, OPRE,0, "REP",
0xf4, 0,0, "HLT",
0xf5, 0,0, "CMC",
0xf6, RMOPB,0, optabF6,
0xf7, RMOP,0, optabF7,
0xf8, 0,0, "CLC",
0xf9, 0,0, "STC",
0xfa, 0,0, "CLI",
0xfb, 0,0, "STI",
0xfc, 0,0, "CLD",
0xfd, 0,0, "STD",
0xfe, RMOPB,0, optabFE,
0xff, RMOP,0, optabFF,
0x100, RM,0, "MOVLQSX %r,%e",
};
static struct {
Optable *tab;
uint nel;
} optabtab[] = {
optab0F00, nelem(optab0F00),
optab0F01, nelem(optab0F01),
optab0F01F8, nelem(optab0F01F8),
optab0FAE, nelem(optab0FAE),
optab0FBA, nelem(optab0FBA),
optab0F0F, nelem(optab0F0F),
optab0FC7, nelem(optab0FC7),
optab660F71, nelem(optab660F71),
optab660F72, nelem(optab660F72),
optab660F73, nelem(optab660F73),
optab660F, nelem(optab660F),
optabF20F, nelem(optabF20F),
optabF30F, nelem(optabF30F),
optab0F, nelem(optab0F),
optab80, nelem(optab80),
optab81, nelem(optab81),
optab83, nelem(optab83),
optabC0, nelem(optabC0),
optabC1, nelem(optabC1),
optabD0, nelem(optabD0),
optabD1, nelem(optabD1),
optabD2, nelem(optabD2),
optabD3, nelem(optabD3),
optabD8, nelem(optabD8),
optabD9, nelem(optabD9),
optabDA, nelem(optabDA),
optabDB, nelem(optabDB),
optabDC, nelem(optabDC),
optabDD, nelem(optabDD),
optabDE, nelem(optabDE),
optabDF, nelem(optabDF),
optabF6, nelem(optabF6),
optabF7, nelem(optabF7),
optabFE, nelem(optabFE),
optabFF, nelem(optabFF),
optable, nelem(optable),
};
/*
* compensate for Microsoft's ageing compilers
*/
static void
ordertab(Optable *tab, int nel)
{
int i, x;
static Optable empty;
for(i = nel; --i >= 0;){
x = tab[i].x;
if(x != i){
tab[x] = tab[i];
tab[i] = empty;
}
}
}
static void
soptoms(void)
{
int i;
static int reordered; /* assumes non-concurrent use */
if(reordered)
return;
reordered = 1;
for(i = 0; i < nelem(optabtab); i++)
ordertab(optabtab[i].tab, optabtab[i].nel);
}
/*
* get a byte of the instruction
*/
static int
igetc(Map *map, Instr *ip, uchar *c)
{
if(ip->n+1 > sizeof(ip->mem)){
werrstr("instruction too long");
return -1;
}
if (get1(map, ip->addr+ip->n, c, 1) < 0) {
werrstr("can't read instruction: %r");
return -1;
}
ip->mem[ip->n++] = *c;
return 1;
}
/*
* get two bytes of the instruction
*/
static int
igets(Map *map, Instr *ip, ushort *sp)
{
uchar c;
ushort s;
if (igetc(map, ip, &c) < 0)
return -1;
s = c;
if (igetc(map, ip, &c) < 0)
return -1;
s |= (c<<8);
*sp = s;
return 1;
}
/*
* get 4 bytes of the instruction
*/
static int
igetl(Map *map, Instr *ip, ulong *lp)
{
ushort s;
long l;
if (igets(map, ip, &s) < 0)
return -1;
l = s;
if (igets(map, ip, &s) < 0)
return -1;
l |= (s<<16);
*lp = l;
return 1;
}
/*
* get 8 bytes of the instruction
*/
static int
igetq(Map *map, Instr *ip, vlong *qp)
{
ulong l;
uvlong q;
if (igetl(map, ip, &l) < 0)
return -1;
q = l;
if (igetl(map, ip, &l) < 0)
return -1;
q |= ((uvlong)l<<32);
*qp = q;
return 1;
}
static int
getdisp(Map *map, Instr *ip, int mod, int rm, int code, int pcrel)
{
uchar c;
ushort s;
if (mod > 2)
return 1;
if (mod == 1) {
if (igetc(map, ip, &c) < 0)
return -1;
if (c&0x80)
ip->disp = c|0xffffff00;
else
ip->disp = c&0xff;
} else if (mod == 2 || rm == code) {
if (ip->asize == 'E') {
if (igetl(map, ip, &ip->disp) < 0)
return -1;
if (mod == 0)
ip->rip = pcrel;
} else {
if (igets(map, ip, &s) < 0)
return -1;
if (s&0x8000)
ip->disp = s|0xffff0000;
else
ip->disp = s;
}
if (mod == 0)
ip->base = -1;
}
return 1;
}
static int
modrm(Map *map, Instr *ip, uchar c)
{
uchar rm, mod;
mod = (c>>6)&3;
rm = c&7;
ip->mod = mod;
ip->base = rm;
ip->reg = (c>>3)&7;
ip->rip = 0;
if (mod == 3) /* register */
return 1;
if (ip->asize == 0) { /* 16-bit mode */
switch(rm) {
case 0:
ip->base = BX; ip->index = SI;
break;
case 1:
ip->base = BX; ip->index = DI;
break;
case 2:
ip->base = BP; ip->index = SI;
break;
case 3:
ip->base = BP; ip->index = DI;
break;
case 4:
ip->base = SI;
break;
case 5:
ip->base = DI;
break;
case 6:
ip->base = BP;
break;
case 7:
ip->base = BX;
break;
default:
break;
}
return getdisp(map, ip, mod, rm, 6, 0);
}
if (rm == 4) { /* scummy sib byte */
if (igetc(map, ip, &c) < 0)
return -1;
ip->ss = (c>>6)&0x03;
ip->index = (c>>3)&0x07;
if (ip->index == 4)
ip->index = -1;
ip->base = c&0x07;
return getdisp(map, ip, mod, ip->base, 5, 0);
}
return getdisp(map, ip, mod, rm, 5, ip->amd64);
}
static Optable *
mkinstr(Map *map, Instr *ip, uvlong pc)
{
int i, n, norex;
uchar c;
ushort s;
Optable *op, *obase;
char buf[128];
soptoms();
memset(ip, 0, sizeof(*ip));
norex = 1;
ip->base = -1;
ip->index = -1;
if(asstype == AI8086)
ip->osize = 'W';
else {
ip->osize = 'L';
ip->asize = 'E';
ip->amd64 = asstype != AI386;
norex = 0;
}
ip->addr = pc;
if (igetc(map, ip, &c) < 0)
return 0;
obase = optable;
newop:
if(ip->amd64 && !norex){
if(c >= 0x40 && c <= 0x4f) {
ip->rex = c;
if(igetc(map, ip, &c) < 0)
return 0;
}
if(c == 0x63){
op = &obase[0x100]; /* MOVLQSX */
goto hack;
}
}
op = &obase[c];
hack:
if (op->proto == 0) {
badop:
n = snprint(buf, sizeof(buf), "opcode: ??");
for (i = 0; i < ip->n && n < sizeof(buf)-3; i++, n+=2)
_hexify(buf+n, ip->mem[i], 1);
strcpy(buf+n, "??");
werrstr(buf);
return 0;
}
for(i = 0; i < 2 && op->operand[i]; i++) {
switch(op->operand[i]) {
case Ib: /* 8-bit immediate - (no sign extension)*/
if (igetc(map, ip, &c) < 0)
return 0;
ip->imm = c&0xff;
ip->imm64 = ip->imm;
break;
case Jbs: /* 8-bit jump immediate (sign extended) */
if (igetc(map, ip, &c) < 0)
return 0;
if (c&0x80)
ip->imm = c|0xffffff00;
else
ip->imm = c&0xff;
ip->imm64 = (long)ip->imm;
ip->jumptype = Jbs;
break;
case Ibs: /* 8-bit immediate (sign extended) */
if (igetc(map, ip, &c) < 0)
return 0;
if (c&0x80)
if (ip->osize == 'L')
ip->imm = c|0xffffff00;
else
ip->imm = c|0xff00;
else
ip->imm = c&0xff;
ip->imm64 = (long)ip->imm;
break;
case Iw: /* 16-bit immediate -> imm */
if (igets(map, ip, &s) < 0)
return 0;
ip->imm = s&0xffff;
ip->imm64 = ip->imm;
ip->jumptype = Iw;
break;
case Iw2: /* 16-bit immediate -> in imm2*/
if (igets(map, ip, &s) < 0)
return 0;
ip->imm2 = s&0xffff;
break;
case Iwd: /* Operand-sized immediate (no sign extension unless 64 bits)*/
if (ip->osize == 'L') {
if (igetl(map, ip, &ip->imm) < 0)
return 0;
ip->imm64 = ip->imm;
if(ip->rex&REXW && (ip->imm & (1<<31)) != 0)
ip->imm64 |= (vlong)~0 << 32;
} else {
if (igets(map, ip, &s)< 0)
return 0;
ip->imm = s&0xffff;
ip->imm64 = ip->imm;
}
break;
case Iwdq: /* Operand-sized immediate, possibly big */
if (ip->osize == 'L') {
if (igetl(map, ip, &ip->imm) < 0)
return 0;
ip->imm64 = ip->imm;
if (ip->rex & REXW) {
ulong l;
if (igetl(map, ip, &l) < 0)
return 0;
ip->imm64 |= (uvlong)l << 32;
}
} else {
if (igets(map, ip, &s)< 0)
return 0;
ip->imm = s&0xffff;
}
break;
case Awd: /* Address-sized immediate (no sign extension)*/
if (ip->asize == 'E') {
if (igetl(map, ip, &ip->imm) < 0)
return 0;
/* TO DO: REX */
} else {
if (igets(map, ip, &s)< 0)
return 0;
ip->imm = s&0xffff;
}
break;
case Iwds: /* Operand-sized immediate (sign extended) */
if (ip->osize == 'L') {
if (igetl(map, ip, &ip->imm) < 0)
return 0;
} else {
if (igets(map, ip, &s)< 0)
return 0;
if (s&0x8000)
ip->imm = s|0xffff0000;
else
ip->imm = s&0xffff;
}
ip->jumptype = Iwds;
break;
case OA: /* literal 0x0a byte */
if (igetc(map, ip, &c) < 0)
return 0;
if (c != 0x0a)
goto badop;
break;
case R0: /* base register must be R0 */
if (ip->base != 0)
goto badop;
break;
case R1: /* base register must be R1 */
if (ip->base != 1)
goto badop;
break;
case RMB: /* R/M field with byte register (/r)*/
if (igetc(map, ip, &c) < 0)
return 0;
if (modrm(map, ip, c) < 0)
return 0;
ip->osize = 'B';
break;
case RM: /* R/M field with register (/r) */
if (igetc(map, ip, &c) < 0)
return 0;
if (modrm(map, ip, c) < 0)
return 0;
break;
case RMOPB: /* R/M field with op code (/digit) */
if (igetc(map, ip, &c) < 0)
return 0;
if (modrm(map, ip, c) < 0)
return 0;
c = ip->reg; /* secondary op code */
obase = (Optable*)op->proto;
ip->osize = 'B';
goto newop;
case RMOP: /* R/M field with op code (/digit) */
if (igetc(map, ip, &c) < 0)
return 0;
if (modrm(map, ip, c) < 0)
return 0;
obase = (Optable*)op->proto;
if(ip->amd64 && obase == optab0F01 && c == 0xF8)
return optab0F01F8;
c = ip->reg;
goto newop;
case FRMOP: /* FP R/M field with op code (/digit) */
if (igetc(map, ip, &c) < 0)
return 0;
if (modrm(map, ip, c) < 0)
return 0;
if ((c&0xc0) == 0xc0)
c = ip->reg+8; /* 16 entry table */
else
c = ip->reg;
obase = (Optable*)op->proto;
goto newop;
case FRMEX: /* Extended FP R/M field with op code (/digit) */
if (igetc(map, ip, &c) < 0)
return 0;
if (modrm(map, ip, c) < 0)
return 0;
if ((c&0xc0) == 0xc0)
c = (c&0x3f)+8; /* 64-entry table */
else
c = ip->reg;
obase = (Optable*)op->proto;
goto newop;
case RMR: /* R/M register only (mod = 11) */
if (igetc(map, ip, &c) < 0)
return 0;
if ((c&0xc0) != 0xc0) {
werrstr("invalid R/M register: %x", c);
return 0;
}
if (modrm(map, ip, c) < 0)
return 0;
break;
case RMM: /* R/M register only (mod = 11) */
if (igetc(map, ip, &c) < 0)
return 0;
if ((c&0xc0) == 0xc0) {
werrstr("invalid R/M memory mode: %x", c);
return 0;
}
if (modrm(map, ip, c) < 0)
return 0;
break;
case PTR: /* Seg:Displacement addr (ptr16:16 or ptr16:32) */
if (ip->osize == 'L') {
if (igetl(map, ip, &ip->disp) < 0)
return 0;
} else {
if (igets(map, ip, &s)< 0)
return 0;
ip->disp = s&0xffff;
}
if (igets(map, ip, (ushort*)&ip->seg) < 0)
return 0;
ip->jumptype = PTR;
break;
case AUXMM: /* Multi-byte op code; prefix determines table selection */
if (igetc(map, ip, &c) < 0)
return 0;
obase = (Optable*)op->proto;
switch (ip->opre) {
case 0x66: op = optab660F; break;
case 0xF2: op = optabF20F; break;
case 0xF3: op = optabF30F; break;
default: op = nil; break;
}
if(op != nil && op[c].proto != nil)
obase = op;
norex = 1; /* no more rex prefixes */
/* otherwise the optab entry captures it */
goto newop;
case AUX: /* Multi-byte op code - Auxiliary table */
obase = (Optable*)op->proto;
if (igetc(map, ip, &c) < 0)
return 0;
goto newop;
case OPRE: /* Instr Prefix or media op */
ip->opre = c;
/* fall through */
case PRE: /* Instr Prefix */
ip->prefix = (char*)op->proto;
if (igetc(map, ip, &c) < 0)
return 0;
if (ip->opre && c == 0x0F)
ip->prefix = 0;
goto newop;
case SEG: /* Segment Prefix */
ip->segment = (char*)op->proto;
if (igetc(map, ip, &c) < 0)
return 0;
goto newop;
case OPOVER: /* Operand size override */
ip->opre = c;
ip->osize = 'W';
if (igetc(map, ip, &c) < 0)
return 0;
if (c == 0x0F)
ip->osize = 'L';
else if (ip->amd64 && (c&0xF0) == 0x40)
ip->osize = 'Q';
goto newop;
case ADDOVER: /* Address size override */
ip->asize = 0;
if (igetc(map, ip, &c) < 0)
return 0;
goto newop;
case JUMP: /* mark instruction as JUMP or RET */
case RET:
ip->jumptype = op->operand[i];
break;
default:
werrstr("bad operand type %d", op->operand[i]);
return 0;
}
}
return op;
}
#pragma varargck argpos bprint 2
static void
bprint(Instr *ip, char *fmt, ...)
{
va_list arg;
va_start(arg, fmt);
ip->curr = vseprint(ip->curr, ip->end, fmt, arg);
va_end(arg);
}
/*
* if we want to call 16 bit regs AX,BX,CX,...
* and 32 bit regs EAX,EBX,ECX,... then
* change the defs of ANAME and ONAME to:
* #define ANAME(ip) ((ip->asize == 'E' ? "E" : "")
* #define ONAME(ip) ((ip)->osize == 'L' ? "E" : "")
*/
#define ANAME(ip) ""
#define ONAME(ip) ""
static char *reg[] = {
"AX",
"CX",
"DX",
"BX",
"SP",
"BP",
"SI",
"DI",
/* amd64 */
"R8",
"R9",
"R10",
"R11",
"R12",
"R13",
"R14",
"R15",
};
static char *breg[] = { "AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH" };
static char *breg64[] = { "AL", "CL", "DL", "BL", "SPB", "BPB", "SIB", "DIB",
"R8B", "R9B", "R10B", "R11B", "R12B", "R13B", "R14B", "R15B" };
static char *sreg[] = { "ES", "CS", "SS", "DS", "FS", "GS" };
static void
plocal(Instr *ip)
{
int ret;
long offset;
Symbol s;
char *reg;
offset = ip->disp;
if (!findsym(ip->addr, CTEXT, &s) || !findlocal(&s, FRAMENAME, &s)) {
bprint(ip, "%lux(SP)", offset);
return;
}
if (s.value > ip->disp) {
ret = getauto(&s, s.value-ip->disp-mach->szaddr, CAUTO, &s);
reg = "(SP)";
} else {
offset -= s.value;
ret = getauto(&s, offset, CPARAM, &s);
reg = "(FP)";
}
if (ret)
bprint(ip, "%s+", s.name);
else
offset = ip->disp;
bprint(ip, "%lux%s", offset, reg);
}
static int
isjmp(Instr *ip)
{
switch(ip->jumptype){
case Iwds:
case Jbs:
case JUMP:
return 1;
default:
return 0;
}
}
/*
* This is too smart for its own good, but it really is nice
* to have accurate translations when debugging, and it
* helps us identify which code is different in binaries that
* are changed on sources.
*/
static int
issymref(Instr *ip, Symbol *s, long w, long val)
{
Symbol next, tmp;
long isstring, size;
if (isjmp(ip))
return 1;
if (s->class==CTEXT && w==0)
return 1;
if (s->class==CDATA) {
/* use first bss symbol (or "end") rather than edata */
if (s->name[0]=='e' && strcmp(s->name, "edata") == 0){
if((s ->index >= 0 && globalsym(&tmp, s->index+1) && tmp.value==s->value)
|| (s->index > 0 && globalsym(&tmp, s->index-1) && tmp.value==s->value))
*s = tmp;
}
if (w == 0)
return 1;
for (next=*s; next.value==s->value; next=tmp)
if (!globalsym(&tmp, next.index+1))
break;
size = next.value - s->value;
if (w >= size)
return 0;
if (w > size-w)
w = size-w;
/* huge distances are usually wrong except in .string */
isstring = (s->name[0]=='.' && strcmp(s->name, ".string") == 0);
if (w > 8192 && !isstring)
return 0;
/* medium distances are tricky - look for constants */
/* near powers of two */
if ((val&(val-1)) == 0 || (val&(val+1)) == 0)
return 0;
return 1;
}
return 0;
}
static void
immediate(Instr *ip, vlong val)
{
Symbol s;
long w;
if (findsym(val, CANY, &s)) { /* TO DO */
w = val - s.value;
if (w < 0)
w = -w;
if (issymref(ip, &s, w, val)) {
if (w)
bprint(ip, "%s+%lux(SB)", s.name, w);
else
bprint(ip, "%s(SB)", s.name);
return;
}
/*
if (s.class==CDATA && globalsym(&s, s.index+1)) {
w = s.value - val;
if (w < 0)
w = -w;
if (w < 4096) {
bprint(ip, "%s-%lux(SB)", s.name, w);
return;
}
}
*/
}
if((ip->rex & REXW) == 0)
bprint(ip, "%lux", (long)val);
else
bprint(ip, "%llux", val);
}
static void
pea(Instr *ip)
{
if (ip->mod == 3) {
if (ip->osize == 'B')
bprint(ip, (ip->rex & REXB? breg64: breg)[ip->base]);
else if(ip->rex & REXB)
bprint(ip, "%s%s", ANAME(ip), reg[ip->base+8]);
else
bprint(ip, "%s%s", ANAME(ip), reg[ip->base]);
return;
}
if (ip->segment)
bprint(ip, ip->segment);
if (ip->asize == 'E' && ip->base == SP)
plocal(ip);
else {
if (ip->base < 0)
immediate(ip, ip->disp);
else {
bprint(ip, "%lux", ip->disp);
if(ip->rip)
bprint(ip, "(RIP)");
bprint(ip,"(%s%s)", ANAME(ip), reg[ip->rex&REXB? ip->base+8: ip->base]);
}
}
if (ip->index >= 0)
bprint(ip,"(%s%s*%d)", ANAME(ip), reg[ip->rex&REXX? ip->index+8: ip->index], 1<<ip->ss);
}
static void
prinstr(Instr *ip, char *fmt)
{
vlong v;
if (ip->prefix)
bprint(ip, "%s ", ip->prefix);
for (; *fmt && ip->curr < ip->end; fmt++) {
if (*fmt != '%'){
*ip->curr++ = *fmt;
continue;
}
switch(*++fmt){
case '%':
*ip->curr++ = '%';
break;
case 'A':
bprint(ip, "%s", ANAME(ip));
break;
case 'C':
bprint(ip, "CR%d", ip->reg);
break;
case 'D':
if (ip->reg < 4 || ip->reg == 6 || ip->reg == 7)
bprint(ip, "DR%d",ip->reg);
else
bprint(ip, "?");
break;
case 'I':
bprint(ip, "$");
immediate(ip, ip->imm2);
break;
case 'O':
bprint(ip,"%s", ONAME(ip));
break;
case 'i':
bprint(ip, "$");
v = ip->imm;
if(ip->rex & REXW)
v = ip->imm64;
immediate(ip, v);
break;
case 'R':
bprint(ip, "%s%s", ONAME(ip), reg[ip->rex&REXR? ip->reg+8: ip->reg]);
break;
case 'S':
if(ip->osize == 'Q' || ip->osize == 'L' && ip->rex & REXW)
bprint(ip, "Q");
else
bprint(ip, "%c", ip->osize);
break;
case 's':
if(ip->opre == 0 || ip->opre == 0x66)
bprint(ip, "P");
else
bprint(ip, "S");
if(ip->opre == 0xf2 || ip->opre == 0x66)
bprint(ip, "D");
else
bprint(ip, "S");
break;
case 'T':
if (ip->reg == 6 || ip->reg == 7)
bprint(ip, "TR%d",ip->reg);
else
bprint(ip, "?");
break;
case 'W':
if (ip->osize == 'Q' || ip->osize == 'L' && ip->rex & REXW)
bprint(ip, "CDQE");
else if (ip->osize == 'L')
bprint(ip,"CWDE");
else
bprint(ip, "CBW");
break;
case 'd':
bprint(ip,"%ux:%lux",ip->seg,ip->disp);
break;
case 'm':
if (ip->mod == 3 && ip->osize != 'B') {
if(fmt[1] != '*'){
if(ip->opre != 0) {
bprint(ip, "X%d", ip->rex&REXB? ip->base+8: ip->base);
break;
}
} else
fmt++;
bprint(ip, "M%d", ip->base);
break;
}
pea(ip);
break;
case 'e':
pea(ip);
break;
case 'f':
bprint(ip, "F%d", ip->base);
break;
case 'g':
if (ip->reg < 6)
bprint(ip,"%s",sreg[ip->reg]);
else
bprint(ip,"?");
break;
case 'p':
/*
* signed immediate in the ulong ip->imm.
*/
v = (long)ip->imm;
immediate(ip, v+ip->addr+ip->n);
break;
case 'r':
if (ip->osize == 'B')
bprint(ip,"%s", (ip->rex? breg64: breg)[ip->rex&REXR? ip->reg+8: ip->reg]);
else
bprint(ip, reg[ip->rex&REXR? ip->reg+8: ip->reg]);
break;
case 'w':
if (ip->osize == 'Q' || ip->rex & REXW)
bprint(ip, "CQO");
else if (ip->osize == 'L')
bprint(ip,"CDQ");
else
bprint(ip, "CWD");
break;
case 'M':
if(ip->opre != 0)
bprint(ip, "X%d", ip->rex&REXR? ip->reg+8: ip->reg);
else
bprint(ip, "M%d", ip->reg);
break;
case 'x':
if (ip->mod == 3 && ip->osize != 'B') {
bprint(ip, "X%d", ip->rex&REXB? ip->base+8: ip->base);
break;
}
pea(ip);
break;
case 'X':
bprint(ip, "X%d", ip->rex&REXR? ip->reg+8: ip->reg);
break;
default:
bprint(ip, "%%%c", *fmt);
break;
}
}
*ip->curr = 0; /* there's always room for 1 byte */
}
static int
i386inst(Map *map, uvlong pc, char modifier, char *buf, int n)
{
Instr instr;
Optable *op;
USED(modifier);
op = mkinstr(map, &instr, pc);
if (op == 0) {
errstr(buf, n);
return -1;
}
instr.curr = buf;
instr.end = buf+n-1;
prinstr(&instr, op->proto);
return instr.n;
}
static int
i386das(Map *map, uvlong pc, char *buf, int n)
{
Instr instr;
int i;
if (mkinstr(map, &instr, pc) == 0) {
errstr(buf, n);
return -1;
}
for(i = 0; i < instr.n && n > 2; i++) {
_hexify(buf, instr.mem[i], 1);
buf += 2;
n -= 2;
}
*buf = 0;
return instr.n;
}
static int
i386instlen(Map *map, uvlong pc)
{
Instr i;
if (mkinstr(map, &i, pc))
return i.n;
return -1;
}
static int
i386foll(Map *map, uvlong pc, Rgetter rget, uvlong *foll)
{
Instr i;
Optable *op;
ushort s;
uvlong l, addr;
vlong v;
int n;
op = mkinstr(map, &i, pc);
if (!op)
return -1;
n = 0;
switch(i.jumptype) {
case RET: /* RETURN or LEAVE */
case Iw: /* RETURN */
if (strcmp(op->proto, "LEAVE") == 0) {
if (geta(map, (*rget)(map, "BP"), &l) < 0)
return -1;
} else if (geta(map, (*rget)(map, mach->sp), &l) < 0)
return -1;
foll[0] = l;
return 1;
case Iwds: /* pc relative JUMP or CALL*/
case Jbs: /* pc relative JUMP or CALL */
v = (long)i.imm;
foll[0] = pc+v+i.n;
n = 1;
break;
case PTR: /* seg:displacement JUMP or CALL */
foll[0] = (i.seg<<4)+i.disp;
return 1;
case JUMP: /* JUMP or CALL EA */
if(i.mod == 3) {
foll[0] = (*rget)(map, reg[i.rex&REXB? i.base+8: i.base]);
return 1;
}
/* calculate the effective address */
addr = i.disp;
if (i.base >= 0) {
if (geta(map, (*rget)(map, reg[i.rex&REXB? i.base+8: i.base]), &l) < 0)
return -1;
addr += l;
}
if (i.index >= 0) {
if (geta(map, (*rget)(map, reg[i.rex&REXX? i.index+8: i.index]), &l) < 0)
return -1;
addr += l*(1<<i.ss);
}
/* now retrieve a seg:disp value at that address */
if (get2(map, addr, &s) < 0) /* seg */
return -1;
foll[0] = s<<4;
addr += 2;
if (i.asize == 'L') {
if (geta(map, addr, &l) < 0) /* disp32 */
return -1;
foll[0] += l;
} else { /* disp16 */
if (get2(map, addr, &s) < 0)
return -1;
foll[0] += s;
}
return 1;
default:
break;
}
if (strncmp(op->proto,"JMP", 3) == 0 || strncmp(op->proto,"CALL", 4) == 0)
return 1;
foll[n++] = pc+i.n;
return n;
}