---

x86dasm.cpp File Reference

#include "global.h"
#include <cstring>
#include "x86dasm.h"
#include "x86istr.h"
#include "x86table.h"
#include "utils/compilecheck.hpp"

Go to the source code of this file.

Defines
#define	U8TOI(num)   (((num)^0x80)-0x80)
#define	U16TOI(num)   (((num)^0x8000)-0x8000)
#define	IsRelocation(addr)   (reloc.GetRelocation(addr)!=NULL)
#define	SUCC(n, m)   (REG(n)+1) == REG(m)
#define	_REAL_GETREGS(n, m)   ((reg_t)(REG(al)+(((n)*8)+(m))))
#define	_REAL_GETSEGREGS(n)   ((reg_t)(REG(es)+(n)))
#define	_REAL_GETFPREGS(n)   ((reg_t)(REG(st0)+(n)))
#define	_REAL_GETCTRLREGS(n, m)   ((reg_t)(REG(cr0)+(((n)*8)+(m))))
#define	GETREGS(n, m)   _REAL_GETREGS(n,m)
#define	GETSEGREGS(n)   _REAL_GETSEGREGS(n)
#define	GETFPREGS(n)   _REAL_GETFPREGS(n)
#define	GETCTRLREGS(n, m)   _REAL_GETCTRLREGS(n,m)
#define	INSTPROCDECL(name)   int InstructionDecoder::name(InstructionDecoder* _this, uchar opcode, int special, Instruction& instruction)
Functions
	COMPILE_CHECK (iRegCheck, SUCC(al, cl)&&SUCC(cl, dl)&&SUCC(dl, bl)&&SUCC(bl, ah)&&SUCC(ah, ch)&&SUCC(ch, dh)&&SUCC(dh, bh)&&SUCC(bh, ax)&&SUCC(ax, cx)&&SUCC(cx, dx)&&SUCC(dx, bx)&&SUCC(bx, sp)&&SUCC(sp, bp)&&SUCC(bp, si)&&SUCC(si, di)&&SUCC(di, eax)&&SUCC(eax, ecx)&&SUCC(ecx, edx)&&SUCC(edx, ebx)&&SUCC(ebx, esp)&&SUCC(esp, ebp)&&SUCC(ebp, esi)&&SUCC(esi, edi)&&SUCC(edi, mm0)&&SUCC(mm0, mm1)&&SUCC(mm1, mm2)&&SUCC(mm2, mm3)&&SUCC(mm3, mm4)&&SUCC(mm4, mm5)&&SUCC(mm5, mm6)&&SUCC(mm6, mm7)&&SUCC(mm7, xmm0)&&SUCC(xmm0, xmm1)&&SUCC(xmm1, xmm2)&&SUCC(xmm2, xmm3)&&SUCC(xmm3, xmm4)&&SUCC(xmm4, xmm5)&&SUCC(xmm5, xmm6)&&SUCC(xmm6, xmm7))
	COMPILE_CHECK (segRegCheck, SUCC(es, cs)&&SUCC(cs, ss)&&SUCC(ss, ds)&&SUCC(ds, fs)&&SUCC(fs, gs))
	COMPILE_CHECK (fpRegCheck, SUCC(st0, st1)&&SUCC(st1, st2)&&SUCC(st2, st3)&&SUCC(st3, st4)&&SUCC(st4, st5)&&SUCC(st5, st6)&&SUCC(st6, st7))
	COMPILE_CHECK (controlRegCheck, SUCC(cr0, cr1)&&SUCC(cr1, cr2)&&SUCC(cr2, cr3)&&SUCC(cr3, cr4)&&SUCC(cr4, cr5)&&SUCC(cr5, cr6)&&SUCC(cr6, cr7)&&SUCC(cr7, dr0)&&SUCC(dr0, dr1)&&SUCC(dr1, dr2)&&SUCC(dr2, dr3)&&SUCC(dr3, dr4)&&SUCC(dr4, dr5)&&SUCC(dr5, dr6)&&SUCC(dr6, dr7)&&SUCC(dr7, tr0)&&SUCC(tr0, tr1)&&SUCC(tr1, tr2)&&SUCC(tr2, tr3)&&SUCC(tr3, tr4)&&SUCC(tr4, tr5)&&SUCC(tr5, tr6)&&SUCC(tr6, tr7))
reg_t	get_regnum (int reg)
void	inst_init ()
	INSTPROCDECL (stub)
	INSTPROCDECL (conv_byte)
	INSTPROCDECL (one_byte)
	INSTPROCDECL (two_byte)
	INSTPROCDECL (five_byte)
Param::MemoryTypes	RegSizeToMemType (int reg_size)
	INSTPROCDECL (in_out)
	INSTPROCDECL (enter)
	INSTPROCDECL (disp8)
	INSTPROCDECL (wait)
	INSTPROCDECL (prefix)
	INSTPROCDECL (adrsize_over)
int	mod3 (uchar r_m, int size, Param &param)
	INSTPROCDECL (mod_reg)
	INSTPROCDECL (group1)
	INSTPROCDECL (k6_3dnow)
Variables
int	segment_mode = 386
int	segment_bytes = 4
bool	p3enable = true
bool	k6_3DNow_enable = true
bool	k6_en_3DNow_enable = true
bool	athlon_enable = true
const reg_t	addr_mode2 [8][2]
const int	op_grp [16][8]
const int	rm_size_invalid = 5
int	over_seg = -1
bool	over_opsize = false
bool	over_adrsize = false
bool	size_large = true
bool	addr_large = true
int	size_bytes = 4
int	addr_bytes = 4

---

Define Documentation

#define _REAL_GETCTRLREGS (  n, m    )     ((reg_t)(REG(cr0)+(((n)*8)+(m))))

Definition at line 94 of file x86dasm.cpp.

#define _REAL_GETFPREGS (  n    )     ((reg_t)(REG(st0)+(n)))

Definition at line 93 of file x86dasm.cpp.

#define _REAL_GETREGS (  n, m    )     ((reg_t)(REG(al)+(((n)*8)+(m))))

Definition at line 91 of file x86dasm.cpp.

#define _REAL_GETSEGREGS (  n    )     ((reg_t)(REG(es)+(n)))

Definition at line 92 of file x86dasm.cpp.

#define GETCTRLREGS (  n, m    )     _REAL_GETCTRLREGS(n,m)

Definition at line 125 of file x86dasm.cpp.

#define GETFPREGS (  n    )     _REAL_GETFPREGS(n)

Definition at line 124 of file x86dasm.cpp.

#define GETREGS (  n, m    )     _REAL_GETREGS(n,m)

Definition at line 122 of file x86dasm.cpp. Referenced by InstructionDecoder::do_sib(), get_regnum(), INSTPROCDECL(), InstructionDecoder::mod0(), InstructionDecoder::mod1(), InstructionDecoder::mod2(), mod3(), and InstructionDecoder::mod_reg2().

#define GETSEGREGS (  n    )     _REAL_GETSEGREGS(n)

Definition at line 123 of file x86dasm.cpp. Referenced by get_regnum().

#define INSTPROCDECL (  name    )     int InstructionDecoder::name(InstructionDecoder* _this, uchar opcode, int special, Instruction& instruction)

Definition at line 240 of file x86dasm.cpp.

#define IsRelocation (  addr    )     (reloc.GetRelocation(addr)!=NULL)

Definition at line 40 of file x86dasm.cpp. Referenced by InstructionDecoder::get_checkc().

#define SUCC (  n, m    )     (REG(n)+1) == REG(m)

Definition at line 60 of file x86dasm.cpp.

#define U16TOI (  num    )     (((num)^0x8000)-0x8000)

Definition at line 38 of file x86dasm.cpp.

#define U8TOI (  num    )     (((num)^0x80)-0x80)

Definition at line 37 of file x86dasm.cpp. Referenced by InstructionDecoder::mod1(), and InstructionDecoder::mod_reg2().

---

Function Documentation

COMPILE_CHECK (  controlRegCheck   , SUCC(cr0, cr1)&&SUCC(cr1, cr2)&&SUCC(cr2, cr3)&&SUCC(cr3, cr4)&&SUCC(cr4, cr5)&&SUCC(cr5, cr6)&&SUCC(cr6, cr7)&&SUCC(cr7, dr0)&&SUCC(dr0, dr1)&&SUCC(dr1, dr2)&&SUCC(dr2, dr3)&&SUCC(dr3, dr4)&&SUCC(dr4, dr5)&&SUCC(dr5, dr6)&&SUCC(dr6, dr7)&&SUCC(dr7, tr0)&&SUCC(tr0, tr1)&&SUCC(tr1, tr2)&&SUCC(tr2, tr3)&&SUCC(tr3, tr4)&&SUCC(tr4, tr5)&&SUCC(tr5, tr6)&&SUCC(tr6, tr7)    )

COMPILE_CHECK (  fpRegCheck   , SUCC(st0, st1)&&SUCC(st1, st2)&&SUCC(st2, st3)&&SUCC(st3, st4)&&SUCC(st4, st5)&&SUCC(st5, st6)&&SUCC(st6, st7)    )

COMPILE_CHECK (  segRegCheck   , SUCC(es, cs)&&SUCC(cs, ss)&&SUCC(ss, ds)&&SUCC(ds, fs)&&SUCC(fs, gs)    )

COMPILE_CHECK (  iRegCheck   , SUCC(al, cl)&&SUCC(cl, dl)&&SUCC(dl, bl)&&SUCC(bl, ah)&&SUCC(ah, ch)&&SUCC(ch, dh)&&SUCC(dh, bh)&&SUCC(bh, ax)&&SUCC(ax, cx)&&SUCC(cx, dx)&&SUCC(dx, bx)&&SUCC(bx, sp)&&SUCC(sp, bp)&&SUCC(bp, si)&&SUCC(si, di)&&SUCC(di, eax)&&SUCC(eax, ecx)&&SUCC(ecx, edx)&&SUCC(edx, ebx)&&SUCC(ebx, esp)&&SUCC(esp, ebp)&&SUCC(ebp, esi)&&SUCC(esi, edi)&&SUCC(edi, mm0)&&SUCC(mm0, mm1)&&SUCC(mm1, mm2)&&SUCC(mm2, mm3)&&SUCC(mm3, mm4)&&SUCC(mm4, mm5)&&SUCC(mm5, mm6)&&SUCC(mm6, mm7)&&SUCC(mm7, xmm0)&&SUCC(xmm0, xmm1)&&SUCC(xmm1, xmm2)&&SUCC(xmm2, xmm3)&&SUCC(xmm3, xmm4)&&SUCC(xmm4, xmm5)&&SUCC(xmm5, xmm6)&&SUCC(xmm6, xmm7)    )

reg_t get_regnum (  int    reg )  [static]

Definition at line 169 of file x86dasm.cpp. References GETREGS, GETSEGREGS, and reg_t. Referenced by INSTPROCDECL(). { if ( reg < 9 ) /* Byte sized half register */ return GETREGS(0,reg-1); if ( reg < 17 ) /* Word/DWord sized general register */ { if ( size_large ) return GETREGS(2,reg-9); return GETREGS(1,reg-9); } return GETSEGREGS(reg-17); }

void inst_init (    )  [static]

Definition at line 185 of file x86dasm.cpp. References addr_bytes, addr_large, over_adrsize, over_opsize, over_seg, segment_bytes, segment_mode, size_bytes, and size_large. { over_seg = -1; /* Setup for the next instruction */ over_opsize = false; over_adrsize = false; if ( segment_mode == 386 ) { size_large = true; addr_large = true; } else { size_large = false; addr_large = false; } size_bytes = segment_bytes; addr_bytes = segment_bytes; }

INSTPROCDECL (  k6_3dnow    )

Definition at line 1799 of file x86dasm.cpp. References _PRG_ASSERT, k6_3DNow_enable, k6_en_3DNow_enable, and modregPqQq. { _PRG_ASSERT(special == modregPqQq); if (!k6_3DNow_enable) return 0; uint32_t mod_reg; if ( _this->get_checkc( &mod_reg ) ) return 0; int result = _this->mod_reg2( opcode,special,mod_reg, instruction); // read opcode suffix if ( result == 0 || _this->get_checkc( &mod_reg ) ) { return 0; } _PRG_ASSERT(mod_reg < 256); // get instruction instruction.instruction = k6_3DNow_instr[mod_reg].instruction; if ( instruction.instruction == -1 ) return 0; // check for enhanched enabled if ( mod_reg == 0xBB || (mod_reg&0xF) == 0xC || (mod_reg&0xF9) == 0x80 ) { _PRG_ASSERT( mod_reg==0xBB || mod_reg==0x8A || mod_reg==0x8E || mod_reg==0x0C || mod_reg==0x1C ); if (!k6_en_3DNow_enable) return 0; } return 1+result; }

INSTPROCDECL (  group1    )

Definition at line 1372 of file x86dasm.cpp. References op_grp. { uint32_t mod_reg; if ( _this->get_checkc( &mod_reg ) ) return 0; instruction.instruction = op_grp[0][(uchar)((mod_reg & 0x38) >> 3)]; return _this->mod_reg2( opcode,special,mod_reg, instruction); }

INSTPROCDECL (  mod_reg    )

Definition at line 1240 of file x86dasm.cpp. { uint32_t mod_reg; if ( _this->get_checkc( &mod_reg ) ) return 0; return _this->mod_reg2( opcode,special,mod_reg, instruction); }

INSTPROCDECL (  adrsize_over    )

Definition at line 826 of file x86dasm.cpp. References addr_bytes, addr_large, and over_adrsize. { int valid; int save_bytes; bool save_large; save_large = addr_large; save_bytes = addr_bytes; if (!over_adrsize) { addr_large = !addr_large; /* Toggle address */ if ( addr_bytes == 2 ) { addr_bytes = 4; } else { addr_bytes = 2; } over_adrsize = true; } valid = _this->check_forward( instrTable, instruction ); addr_large = save_large; addr_bytes = save_bytes; over_adrsize = false; if ( valid ) return( valid+1 ); else return( 0 ); }

INSTPROCDECL (  prefix    )

Definition at line 712 of file x86dasm.cpp. { // !!! should verify next instruction instruction.numArg = 0; return 1; }

INSTPROCDECL (  wait    )

Definition at line 702 of file x86dasm.cpp. { // !!! always print instruction instruction.numArg = 0; return 1; }

INSTPROCDECL (  disp8    )

Definition at line 638 of file x86dasm.cpp. References addr_bytes, Param::Literal, and uchar. { uint32_t offset; uint32_t dest; // if ( over_seg != -1 ) { /* No segment overide allowed */ // return( 0 ); // } instruction.numArg = 1; // !!! check relocation offset = _this->reader->ReadByte(); // if ( offset == 0xFFFFFFFFL ) { /* This would generate a label in */ // return( 0 ); /* the middle of the jmp statement */ // } /* thereby preventing it anyway */ dest = _this->reader->Tell() + (signed char)offset; instruction.Args[0] = Param(Param::Literal,dest,(uchar)addr_bytes); return 2; }

INSTPROCDECL (  enter    )

Definition at line 594 of file x86dasm.cpp. References _PRG_ASSERT, Param::Literal, and uchar. { uint32_t num_bytes; uint32_t nest_level; // !!! check for no relocation num_bytes = _this->reader->ReadWord(); if ( _this->get_checkc( &nest_level) ) return 0; instruction.numArg = 2; _PRG_ASSERT(instruction.instruction == istr_enter); instruction.Args[0] = Param(Param::Literal,num_bytes, (uchar)2); instruction.Args[1] = Param(Param::Literal,nest_level,(uchar)1); return 4; }

INSTPROCDECL (  in_out    )

Definition at line 488 of file x86dasm.cpp. References _PRG_ASSERT, dx, GETREGS, REG, Param::Registry, and size_large. { int dir; int size; instruction.numArg = 2; dir = ( opcode & 0x02 ) >> 1; size = ( opcode & 0x01 ); if ( size == 1 && size_large ) size = 2; if ( dir == 0 ) { _PRG_ASSERT(size>=0 && size<=2); instruction.Args[0] = Param(Param::Registry,GETREGS(size,0)); instruction.Args[1] = Param(Param::Registry,REG(dx)); } else { instruction.Args[0] = Param(Param::Registry,REG(dx)); _PRG_ASSERT(size>=0 && size<=2); instruction.Args[1] = Param(Param::Registry,GETREGS(size,0)); } return 1; }

INSTPROCDECL (  five_byte    )

Definition at line 353 of file x86dasm.cpp. References Param::FarLiteral, size_bytes, size_large, and uchar. { uint32_t offset; uint32_t segment; int data_size; // if ( over_seg != -1 ) { // No segment overide allowed // return(0); // } data_size = size_bytes; // !!! check relocation offset = _this->ReadVar( size_large ); segment = _this->reader->ReadWord(); instruction.numArg = 1; instruction.Args[0] = Param(Param::FarLiteral,offset,(uchar)data_size,segment); return( 3 + data_size ); }

INSTPROCDECL (  two_byte    )

Definition at line 281 of file x86dasm.cpp. References get_regnum(), Param::Literal, Param::Registry, regNone, and uchar. { uint32_t offset; if ( _this->get_checkc( &offset ) ) { return( 0 ); } instruction.numArg = 1; if (special != regNone) { instruction.numArg = 2; instruction.Args[0] = Param(Param::Registry,get_regnum(special)); } // unsigned byte instruction.Args[instruction.numArg-1] = Param(Param::Literal,offset,(uchar)1); return 2; }

INSTPROCDECL (  one_byte    )

Definition at line 267 of file x86dasm.cpp. References get_regnum(), Param::Registry, and regNone. { instruction.numArg = 0; if (special != regNone) { instruction.numArg = 1; instruction.Args[0] = Param(Param::Registry,get_regnum(special)); } return 1; }

INSTPROCDECL (  conv_byte    )

Definition at line 255 of file x86dasm.cpp. References _PRG_ASSERT. { _PRG_ASSERT( opcode == 0x98 || opcode == 0x99 ); instruction.numArg = 0; if ( size_large ) instruction.instruction = special; return 1; }

INSTPROCDECL (  stub    )

Definition at line 247 of file x86dasm.cpp. { return 0; }

int mod3 (  uchar    r_m, int    size, Param &    param )  [static]

Definition at line 953 of file x86dasm.cpp. References GETREGS, Param::Registry, and uchar. Referenced by InstructionDecoder::do_mod_rm(). { if (unsigned(size)>4u) // 0-4 valid return -1; param = Param(Param::Registry,GETREGS(size,r_m)); return 0; }

Param::MemoryTypes RegSizeToMemType (  int    reg_size )

Definition at line 419 of file x86dasm.cpp. References _PRG_ASSERT, Param::memInt8, Param::memMmx, Param::memNone, Param::MemoryTypes, and Param::memXmm. Referenced by InstructionDecoder::mod_reg2(). { switch (reg_size) { case 0: return Param::memInt8; case 1: return Param::memInt16; case 2: return Param::memInt32; case 3: return Param::memMmx; case 4: return Param::memXmm; default: _PRG_ASSERT(0); return Param::memNone; } }

---

Variable Documentation

int addr_bytes = 4

Definition at line 166 of file x86dasm.cpp. Referenced by InstructionDecoder::Decode(), inst_init(), INSTPROCDECL(), InstructionDecoder::mod0(), and InstructionDecoder::mod2().

bool addr_large = true [static]

Definition at line 164 of file x86dasm.cpp. Referenced by InstructionDecoder::Decode(), inst_init(), INSTPROCDECL(), InstructionDecoder::mod0(), and InstructionDecoder::mod2().

const reg_t addr_mode2[8][2] [static]

Initial value: { { REG(bx),REG(si) }, { REG(bx),REG(di) }, { REG(bp),REG(si) }, { REG(bp),REG(di) }, { REG(si),null_reg }, { REG(di),null_reg }, { REG(bp),null_reg }, { REG(bx),null_reg } } Definition at line 128 of file x86dasm.cpp. Referenced by InstructionDecoder::mod0(), InstructionDecoder::mod1(), and InstructionDecoder::mod2().

bool athlon_enable = true

Definition at line 53 of file x86dasm.cpp.

bool k6_3DNow_enable = true

Definition at line 49 of file x86dasm.cpp. Referenced by INSTPROCDECL().

bool k6_en_3DNow_enable = true

Definition at line 51 of file x86dasm.cpp. Referenced by INSTPROCDECL().

const int op_grp[16][8] [static]

Initial value: { { istr_add, istr_or, istr_adc, istr_sbb, istr_and, istr_sub, istr_xor, istr_cmp }, { istr_rol, istr_ror, istr_rcl, istr_rcr, istr_shl, istr_shr, -1, istr_sar }, { istr_test, -1, istr_not, istr_neg, istr_mul, istr_imul, istr_div, istr_idiv }, { istr_inc, istr_dec, -1, -1, -1, -1, -1, -1 }, { istr_inc, istr_dec, istr_call, istr_call, istr_jmp, istr_jmp, istr_push, -1 }, { istr_sldt, istr_str, istr_lldt, istr_ltr, istr_verr, istr_verw, -1, -1 }, { istr_sgdt, istr_sidt, istr_lgdt, istr_lidt, istr_smsw, -1, istr_lmsw,istr_invlpg }, { -1, -1, -1, -1, istr_bt, istr_bts, istr_btr, istr_btc }, { -1, istr_cmpxchg8b, -1, -1, -1, -1, -1, -1 }, { -1, -1, -1, -1, -1, -1, -1, -1 }, { -1, -1, -1, -1, -1, -1, -1, -1 }, { -1, -1, istr_psrlw, -1, istr_psraw, -1, istr_psllw, -1 }, { -1, -1, istr_psrld, -1, istr_psrad, -1, istr_pslld, -1 }, { -1, -1, istr_psrlq, -1, -1, -1, istr_psllq, -1 }, { istr_fxsave,istr_fxrstor,istr_ldmxcsr,istr_stmxcsr,-1, -1, -1, -1 }, { istr_prefetchnta,istr_prefetch0,istr_prefetch1,istr_prefetch2,-1,-1, -1, -1 } } Definition at line 139 of file x86dasm.cpp. Referenced by INSTPROCDECL().

bool over_adrsize = false [static]

Definition at line 162 of file x86dasm.cpp. Referenced by inst_init(), and INSTPROCDECL().

bool over_opsize = false [static]

Definition at line 161 of file x86dasm.cpp. Referenced by inst_init().

int over_seg = -1 [static]

Definition at line 160 of file x86dasm.cpp. Referenced by InstructionDecoder::Decode(), inst_init(), and InstructionDecoder::mod_reg2().

bool p3enable = true

Definition at line 47 of file x86dasm.cpp.

const int rm_size_invalid = 5 [static]

Definition at line 158 of file x86dasm.cpp. Referenced by InstructionDecoder::mod_reg2().

int segment_bytes = 4

Definition at line 44 of file x86dasm.cpp. Referenced by inst_init().

int segment_mode = 386

Definition at line 43 of file x86dasm.cpp. Referenced by inst_init().

int size_bytes = 4 [static]

Definition at line 165 of file x86dasm.cpp. Referenced by InstructionDecoder::Decode(), inst_init(), INSTPROCDECL(), and InstructionDecoder::mod_reg2().

bool size_large = true [static]

Definition at line 163 of file x86dasm.cpp. Referenced by InstructionDecoder::Decode(), inst_init(), INSTPROCDECL(), and InstructionDecoder::mod_reg2().

---