反汇编的一段源码

#include "stdafx.h"
#include "ASM.h"
#include <Strsafe.h>

CASM::CASM(int OpcodLength) :
m_stcModR_M(0)
, m_OpcodLength(OpcodLength)
, m_IsModR_M(0)
, m_CodeSeg(_DS_)
{

}

//OpCode表
OPCODE g_stcOPCode[] = {
 /*     Code       Instruction       Operation1         Operation2        Operation3
 /*    0x00*/{     L"ADD",           _E_ | _b_,        _G_ | _b_ ,    0},
 /*    0x01*/{     L"ADD",           _E_ | _v_,        _G_ | _v_ ,    0},
 /*    0x02*/{     L"ADD",   _G_ | _b_,    _E_ | _b_ ,    0},
 /*    0x03*/{   L"ADD",   _G_ | _v_,    _E_ | _v_ ,    0},
 /*    0x04*/{   L"ADD",   _AL_  ,    _I_ | _b_ ,    0},
 /*    0x05*/{   L"ADD",      _EAX_    ,        _I_ | _z_ ,    0},
 /*    0x06*/{     L"PUSH",          _ES_     ,        0   ,    0},
 /*    0x07*/{     L"POP",           _ES_     ,        0   ,    0},
 /*    0x08*/{   L"OR",            _E_ | _b_,    _G_ | _b_ ,    0},
 /*    0x09*/{   L"OR",   _E_ | _v_,    _G_ | _v_ ,    0},
 /*    0x0A*/{     L"OR",      _G_ | _b_,    _E_ | _b_ ,    0},
 /*    0x0B*/{   L"OR",            _G_|_v_  ,        _E_|_v_ ,    0},
 /*    0x0C*/{     L"OR",   _AL_     ,    _I_ | _b_ ,    0},
 /*    0x0D*/{     L"OR",   _EAX_    ,    _I_ | _z_ ,    0},
 /*    0x0E*/{     L"PUSH",   _CS_     ,    0   ,    0},
 /*    0x0F*/{     L"2_byte",         0       ,        0         ,       0},

 /*   0x10*/{     L"ADC",      _E_|_b_  ,        _G_|_b_   ,          0},
 /*   0x11*/{     L"ADC",           _E_|_v_  ,        _G_|_v_   ,          0},
 /*   0x12*/{   L"ADC",           _G_|_b_  ,        _E_|_b_   ,          0},
 /*   0x13*/{   L"ADC",           _G_|_v_  ,        _E_|_v_   ,          0},
 /*   0x14*/{     L"ADC",           _AL_     ,        _I_|_b_   ,          0},
 /*    0x15*/{   L"ADC",           _EAX_    ,        _I_|_z_   ,          0},
 /*    0x16*/{   L"PUSH",          _SS_     ,        0         ,          0},
 /*    0x17*/{   L"POP",           _SS_     ,        0         ,          0},
 /*    0x18*/{   L"SBB",           _E_|_b_  ,        _G_|_b_ ,    0},
 /*    0x19*/{   L"SBB",           _E_|_v_  ,        _G_|_v_ ,    0},
 /*    0x1A*/{   L"SBB",           _G_|_b_  ,        _E_|_b_ ,    0},
 /*    0x1B*/{   L"SBB",           _G_|_v_  ,        _E_|_v_ ,    0},
 /*    0x1C*/{   L"SBB",           _AL_     ,        _I_|_b_   ,          0},
 /*    0x1D*/{   L"SBB",           _EAX_    ,        _I_|_z_   ,          0},
 /*    0x1E*/{   L"PUSH ",          _DS_     ,        0         ,          0},
 /*    0x1F*/{   L"POP ",          _DS_     ,        0         ,          0},
 /*    0x20*/{   L"AND",      _E_|_b_  ,   _G_|_b_    ,    0},
 /*    0x21*/{   L"AND",      _E_|_v_  ,   _G_|_v_    ,    0},
 /*    0x22*/{   L"AND",      _G_|_b_  ,   _E_|_b_    ,    0},
 /*    0x23*/{   L"AND",      _G_|_v_  ,   _E_|_v_    ,    0},
 /*    0x24*/{   L"AND",      _AL_  ,   _I_|_b_    ,    0},
 /*    0x25*/{   L"AND",      _EAX_  ,   _I_|_z_    ,    0},
 /*    0x26*/{   L"PREFIX",        _ES_     ,       0          ,          0},
 /*    0x27*/{   L"DAA",           0        ,       0          ,          0},    
 /*    0x28*/{   L"SUB",      _E_|_b_  ,   _G_|_b_ ,    0},
 /*    0x29*/{   L"SUB",      _E_|_v_  ,   _G_|_v_ ,    0},
 /*    0x2A*/{   L"SUB",      _G_|_b_  ,   _E_|_b_ ,    0},
 /*    0x2B*/{   L"SUB",      _G_|_v_  ,   _E_|_v_ ,    0},
 /*    0x2C*/{   L"SUB",      _AL_     ,   _I_|_b_ ,    0},
 /*    0x2D*/{   L"SUB",      _EAX_  ,   _I_|_z_ ,    0},
 /*    0x2E*/{   L"PREFIX",     _CS_  ,   0   ,    0},
 /*    0x2F*/{   L"DAS",      0   ,   0          ,    0},
 /*    0x30*/{   L"XOR",      _E_|_b_  ,   _G_|_b_ ,    0},
 /*    0x31*/{   L"XOR",      _E_|_v_  ,   _G_|_v_ ,    0},
 /*    0x32*/{   L"XOR",      _G_|_b_  ,   _E_|_b_ ,    0},
 /*    0x33*/{   L"XOR",      _G_|_v_  ,   _E_|_v_ ,    0},
 /*    0x34*/{   L"XOR",      _AL_  ,       _I_|_b_ ,    0},
 /*    0x35*/{   L"XOR",      _EAX_  ,      _I_|_z_ ,    0},
 /*    0x36*/{   L"PREFIX",     _SS_     ,   0          ,          0},
 /*    0x37*/{   L"AAA",      0      ,   0          ,          0},
 /*    0x38*/{   L"CMP",      _E_|_b_  ,   _G_|_b_ ,    0},
 /*    0x39*/{   L"CMP",      _E_|_v_  ,   _G_|_v_ ,    0},
 /*    0x3A*/{   L"CMP",      _G_|_b_  ,   _E_|_b_ ,    0},
 /*    0x3B*/{   L"CMP",      _G_|_v_  ,   _E_|_v_ ,    0},
 /*    0x3C*/{   L"CMP",      _AL_  ,   _I_|_b_ ,    0},
 /*    0x3D*/{   L"CMP",      _EAX_  ,   _I_|_z_ ,    0},
 /*    0x3E*/{   L"PREFIX",     _DS_     ,       0          ,          0},
 /*    0x3F*/{   L"AAS",           0        ,       0          ,          0},
 /*    0x40*/{   L"INC ",      _EAX_  ,   0   ,      0},
 /*    0x41*/{   L"INC ",      _ECX_  ,   0   ,    0},
 /*    0x42*/{   L"INC ",      _EDX_  ,   0   ,    0},
 /*    0x43*/{   L"INC ",      _EBX_  ,   0   ,    0},
 /*    0x44*/{   L"INC ",      _ESP_  ,   0   ,    0},
 /*    0x45*/{   L"INC ",      _EBP_  ,   0   ,    0},
 /*    0x46*/{   L"INC ",      _ESI_  ,   0   ,    0},
 /*    0x47*/{   L"INC ",      _EDI_  ,   0   ,    0},
 /*    0x48*/{   L"DEC ",      _EAX_  ,   0   ,    0},
 /*    0x49*/{   L"DEC ",      _ECX_  ,   0   ,    0},
 /*    0x4A*/{   L"DEC ",      _EDX_  ,   0   ,    0},
 /*    0x4B*/{   L"DEC ",      _EBX_  ,   0   ,    0},
 /*    0x4C*/{   L"DEC ",      _ESP_  ,   0   ,    0},
 /*    0x4D*/{   L"DEC ",      _EBP_  ,   0   ,    0},
 /*    0x4E*/{   L"DEC ",      _ESI_  ,   0   ,    0},
 /*    0x4F*/{   L"DEC ",      _EDI_  ,   0   ,    0},
 /*    0x50*/{   L"PUSH ",         _EAX_  ,       0          ,          0},
 /*    0x51*/{   L"PUSH ",         _ECX_  ,       0          ,          0},
 /*    0x52*/{   L"PUSH ",         _EDX_  ,       0          ,          0},
 /*    0x53*/{   L"PUSH ",         _EBX_  ,       0          ,          0},
 /*    0x54*/{   L"PUSH ",         _ESP_  ,       0          ,          0},
 /*    0x55*/{   L"PUSH ",         _EBP_  ,       0          ,          0},
 /*    0x56*/{   L"PUSH ",         _ESI_  ,       0          ,          0},
 /*    0x57*/{   L"PUSH ",         _EDI_  ,       0          ,          0},
 /*    0x58*/{   L"POP ",          _EAX_  ,       0          ,          0},
 /*    0x59*/{   L"POP ",          _ECX_  ,       0          ,          0},
 /*    0x5A*/{   L"POP ",          _EDX_  ,       0          ,          0},
 /*    0x5B*/{   L"POP ",          _EBX_  ,       0          ,          0},
 /*    0x5C*/{   L"POP ",          _ESP_  ,       0          ,          0},
 /*    0x5D*/{   L"POP ",          _EBP_  ,       0          ,          0},
 /*    0x5E*/{   L"POP ",          _ESI_  ,       0          ,          0},
 /*    0x5F*/{   L"POP ",          _EDI_  ,       0          ,          0},
 /*    0x60*/{   L"PUSHAD",     0      ,       0          ,    0},
 /*    0x61*/{   L"POPAD",      0      ,       0          ,       0},
 /*    0x62*/{   L"BOUND",      _G_|_v_  ,      _M_|_a_    ,          0},
 /*    0x63*/{   L"ARPL",      _E_|_w_  ,      _G_|_w_    ,          0},
 /*    0x64*/{   L"PREFIX",     _FS_  ,   0   ,    0},
 /*    0x65*/{   L"PREFIX",     _GS_     ,   0   ,    0},
 /*    0x66*/{   L"PREFIX",     0      ,   0   ,    0},
 /*    0x67*/{   L"PREFIX",     0      ,   0   ,    0},
 /*    0x68*/{   L"PUSH",      _I_ | _z_,       0          ,          0},
 /*    0x69*/{   L"IMUL",      _G_ | _v_,      _E_|_v_     ,    _I_|_z_},
 /*    0x6A*/{   L"PUSH",      _I_|_b_  ,      0           ,          0},
 /*    0x6B*/{   L"IMUL",          _G_|_v_  ,      _E_|_v_     ,    _I_|_b_},  
 /*    0x6C*/{   L"INS",           _Y_|_b_  ,      _DX_        ,          0},
 /*    0x6D*/{   L"INS",      _Y_|_z_  ,     _DX_        ,       0},
 /*    0x6E*/{   L"OUTS",      _DX_     ,     _X_|_b_     ,       0},
 /*    0x6F*/{   L"OUTS",      _DX_     ,     _X_|_z_     ,       0},
 /*    0x70*/{   L"JO  ",      _J_|_b_  ,      0   ,    0},       
 /*    0x71*/{   L"JNO ",      _J_|_b_  ,      0   ,    0},
 /*    0x72*/{   L"JC  ",      _J_|_b_  ,      0   ,    0},
 /*    0x73*/{   L"JNC ",      _J_|_b_  ,      0   ,    0},
 /*    0x74*/{   L"JE  ",      _J_|_b_  ,      0   ,    0},
 /*    0x75*/{   L"JNE ",      _J_|_b_  ,      0   ,    0},
 /*    0x76*/{   L"JBE ",      _J_|_b_  ,      0   ,    0},
 /*    0x77*/{   L"JNBE ",      _J_|_b_  ,      0   ,    0},
 /*    0x78*/{   L"JS  ",      _J_|_b_  ,      0   ,    0},
 /*    0x79*/{   L"JNS ",      _J_|_b_  ,      0   ,    0},
 /*    0x7A*/{   L"JP  ",      _J_|_b_  ,      0   ,    0},
 /*    0x7B*/{   L"JNP ",      _J_|_b_  ,      0   ,    0},
 /*    0x7C*/{   L"JL  ",      _J_|_b_  ,      0   ,    0},
 /*    0x7D*/{   L"JNL ",      _J_|_b_  ,      0   ,    0},
 /*    0x7E*/{   L"JLE ",      _J_|_b_  ,      0   ,    0},
 /*    0x7F*/{   L"JNLE ",      _J_|_b_  ,      0   ,    0},
                             
 /*    0x80*/{   L"Grp1",      _E_|_b_  ,  _I_|_b_     ,          0},
 /*    0x81*/{   L"Grp1",      _E_|_v_  ,  _I_|_z_     ,          0},
 /*    0x82*/{   L"Grp1",      _E_|_b_  ,  _I_|_b_     ,          0},
 /*    0x83*/{   L"Grp1",      _E_|_v_  ,  _I_|_b_     ,          0},
 /*    0x84*/{   L"TEST",      _E_|_b_  ,  _G_|_b_     ,          0},
 /*    0x85*/{   L"TEST",      _E_|_v_  ,  _G_|_v_     ,          0},
 /*    0x86*/{   L"XCHG",      _E_|_b_  ,  _G_|_b_     ,          0},
 /*    0x87*/{   L"XCHG",      _E_|_v_  ,  _G_|_v_     ,          0},
 /*    0x88*/{   L"MOV",      _E_|_b_  ,      _G_|_b_     ,          0},
 /*    0x89*/{   L"MOV",      _E_|_v_  ,      _G_|_v_     ,          0},
 /*    0x8A*/{   L"MOV",      _G_|_b_  ,      _E_|_b_     ,          0},
 /*    0x8B*/{   L"MOV",      _G_|_v_  ,      _E_|_v_     ,          0},
 /*    0x8C*/{   L"MOV",      _E_|_v_  ,      _S_|_w_     ,          0},
 /*    0x8D*/{   L"LEA",      _G_|_v_  ,      _M_         ,          0},
 /*    0x8E*/{   L"MOV",      _S_|_w_  ,      _E_|_w_     ,          0},
 /*    0x8F*/{   L"POP",           _E_|_v_  ,      0           ,          0},  //Grp 1A
 /*    0x90*/{   L"NOP",           0        ,      0           ,          0},
 /*    0x91*/{   L"XCHG ",         _ECX_    ,      0           ,          0},
 /*    0x92*/{   L"XCHG ",         _EDX_    ,      0           ,          0},
 /*    0x93*/{   L"XCHG ",         _EBX_    ,      0           ,          0},
 /*    0x94*/{   L"XCHG ",         _ESP_    ,      0           ,          0},
 /*    0x95*/{   L"XCHG ",         _EBP_    ,      0           ,          0},
 /*    0x96*/{   L"XCHG ",      _ESI_  ,  0      ,    0},
 /*    0x97*/{   L"XCHG ",      _EDI_    ,      0   ,    0},
 /*    0x98*/{   L"CWDE",      0   ,  0      ,    0},
 /*    0x99*/{   L"CDQ",      0   ,  0   ,       0},
 /*    0x9A*/{   L"CALLF",      _A_|_p_  ,     0   ,    0},
 /*    0x9B*/{   L"FWAIT",      0   ,  0   ,    0},
 /*    0x9C*/{   L"PUSHFD",     _F_|_v_  ,     0   ,    0},
 /*    0x9D*/{   L"POPFD",      _F_|_v_  ,  0   ,    0},
 /*    0x9E*/{   L"SAHF",      0   ,  0   ,    0},
 /*    0x9F*/{   L"LAHF",      0   ,     0   ,    0},
                 
 /*    0xA0*/{   L"MOV",      _AL_  ,  _O_|_b_     ,    0},
 /*    0xA1*/{   L"MOV",      _EAX_  ,  _O_|_v_  ,    0},
 /*    0xA2*/{   L"MOV",      _O_|_b_  ,  _AL_  ,    0},
 /*    0xA3*/{   L"MOV",      _O_|_v_  ,  _EAX_  ,       0},
 /*    0xA4*/{   L"MOVS",      _Y_|_b_  ,  _X_|_b_  ,       0},
 /*    0xA5*/{   L"MOVS",      _Y_|_v_  ,  _X_|_v_  ,       0},
 /*    0xA6*/{   L"CMPS",      _X_|_b_  ,  _Y_|_b_  ,       0},
 /*    0xA7*/{   L"CMPS",      _X_|_v_  ,  _Y_|_v_  ,       0},
 /*    0xA8*/{   L"TEST",      _AL_     ,     _I_|_b_     ,          0},
 /*    0xA9*/{   L"TEST",          _EAX_    ,      _I_|_z_     ,          0},
 /*    0xAA*/{   L"STOS",          _Y_|_v_  ,      _AL_        ,       0},
 /*    0xAB*/{   L"STOS",      _Y_|_v_  ,      _EAX_  ,       0},
 /*    0xAC*/{   L"LODS",      _AL_  ,      _X_|_b_  ,       0},
 /*    0xAD*/{   L"LODS",      _EAX_  ,      _X_|_v_  ,       0},
 /*    0xAE*/{   L"SCAS",      _AL_  ,      _Y_|_b_  ,       0},
 /*    0xAF*/{   L"SCAS",      _EAX_  ,      _X_|_v_  ,       0},
                          
 /*    0xB0*/{   L"MOV",      _AL_     ,     _I_|_b_      ,    0},
 /*    0xB1*/{   L"MOV",      _CL_     ,     _I_|_b_      ,    0},
 /*    0xB2*/{   L"MOV",      _DL_     ,     _I_|_b_      ,    0},
 /*    0xB3*/{   L"MOV",      _BL_     ,     _I_|_b_      ,    0},
 /*    0xB4*/{   L"MOV",      _AH_     ,     _I_|_b_      ,    0},
 /*    0xB5*/{   L"MOV",      _CH_     ,     _I_|_b_      ,    0},
 /*    0xB6*/{   L"MOV",      _DH_     ,     _I_|_b_      ,    0},
 /*    0xB7*/{   L"MOV",      _BH_     ,     _I_|_b_      ,    0},
 /*    0xB8*/{   L"MOV",      _EAX_    ,    _I_|_v_  ,    0},
 /*    0xB9*/{   L"MOV",      _ECX_    ,    _I_|_v_  ,    0},
 /*    0xBA*/{   L"MOV",      _EDX_    ,    _I_|_v_  ,    0},
 /*    0xBB*/{   L"MOV",      _EBX_    ,    _I_|_v_  ,    0},
 /*    0xBC*/{   L"MOV",      _ESP_    ,    _I_|_v_  ,    0},
 /*    0xBD*/{   L"MOV",      _EBP_    ,    _I_|_v_  ,    0},
 /*    0xBE*/{   L"MOV",      _ESI_    ,    _I_|_v_  ,    0},
 /*    0xBF*/{   L"MOV",      _EDI_    ,    _I_|_v_  ,    0},
                 
 /*    0xC0*/{   L"Grp2",          _E_|_b_  ,    _I_|_b_  ,       0},
 /*    0xC1*/{   L"Grp2",          _E_|_b_  ,    _I_|_b_  ,       0},
 /*    0xC2*/{   L"RETN",          _I_|_w_  ,    0   ,       0},
 /*    0xC3*/{   L"RETN",          0   ,    0   ,       0},
 /*    0xC4*/{   L"LES",           _G_|_z_  ,    _M_|_p_  ,       0},
 /*    0xC5*/{   L"LDS",           _G_|_z_  ,    _M_|_p_  ,       0},
 /*    0xC6*/{   L"MOV",           _E_|_b_  ,    _I_|_b_  ,       0}, //Grp11
 /*    0xC7*/{   L"MOV",           _E_|_v_  ,    _I_|_v_  ,       0}, //Grp11
 /*    0xC8*/{   L"ENTER",         _I_|_w_  ,    _I_|_b_  ,       0},
 /*    0xC9*/{   L"LEAVE",   0   ,    0   ,       0},
 /*    0xCA*/{   L"RETF",   _I_|_w_  ,    0   ,       0},
 /*    0xCB*/{   L"RETF",   0   ,    0   ,       0},
 /*    0xCC*/{   L"INT 3",   0   ,    0   ,       0},
 /*    0xCD*/{   L"INT",   _I_|_b_  ,    0   ,       0},
 /*    0xCE*/{   L"INTO",   0   ,    0   ,       0},
 /*    0xCF*/{   L"IRETD",   0   ,    0   ,       0},
                    
 /*    0xD0*/{   L"Grp2",     _E_|_b_  ,   _1_      ,       0},
 /*    0xD1*/{   L"Grp2",     _E_|_v_  ,   _1_      ,       0},
 /*    0xD2*/{   L"Grp2",     _E_|_b_  ,   _CL_      ,       0},
 /*    0xD3*/{   L"Grp2",     _E_|_v_  ,   _CL_      ,       0},
 /*    0xD4*/{   L"AAM",     _I_|_b_  ,   0       ,       0},
 /*    0xD5*/{   L"AAD",     _I_|_b_  ,   0       ,       0},
 /*    0xD6*/{   L"NULL",   0   ,   0       ,    0},
 /*    0xD7*/{   L"XLAT",   0   ,   0       ,    0},
 /*    0xD8*/{   L"ESC",   0   ,   0       ,    0},
 /*    0xD9*/{   L"ESC",   0   ,   0       ,    0},
 /*    0xDA*/{   L"ESC",   0   ,   0       ,    0},
 /*    0xDB*/{   L"ESC",   0   ,   0       ,    0},
 /*    0xDC*/{   L"ESC",   0   ,   0       ,    0},
 /*    0xDD*/{   L"ESC",   0   ,   0       ,    0},
 /*    0xDE*/{   L"ESC",   0   ,   0       ,    0},
 /*    0xDF*/{   L"ESC",   0   ,   0       ,    0},
         
 /*    0xE0*/{   L"LOOPNE",  _J_|_b_  ,   0       ,       0},
 /*    0xE1*/{   L"LOOPE",   _J_|_b_  ,   0       ,       0},
 /*    0xE2*/{   L"LOOP",   _J_|_b_  ,   0       ,       0},
 /*    0xE3*/{   L"JECXZ",   _J_|_b_  ,   0       ,       0},  
 /*    0xE4*/{   L"IN",   _AL_  ,   _I_|_b_     ,    0},
 /*    0xE5*/{   L"IN",   _EAX_  ,   _I_|_b_     ,    0},
 /*    0xE6*/{   L"OUT",   _I_|_b_  ,   _AL_      ,    0},
 /*    0xE7*/{   L"OUT",   _I_|_b_  ,   _EAX_      ,    0},
 /*    0xE8*/{   L"CALL",   _J_|_z_  ,   0       ,    0},
 /*    0xE9*/{   L"JMP",   _J_|_z_  ,   0       ,    0},
 /*    0xEA*/{   L"JMP",   _A_|_p_  ,   0       ,    0},
 /*    0xEB*/{   L"JMP",   _J_|_b_  ,   0       ,    0},
 /*    0xEC*/{   L"IN",   _AL_  ,   _DX_      ,    0},
 /*    0xED*/{   L"IN",   _EAX_  ,   _DX_      ,    0},
 /*    0xEE*/{   L"OUT",   _DX_  ,   _AL_      ,    0},
 /*    0xEF*/{   L"OUT",   _DX_  ,   _EAX_      ,    0},
           
 /*    0xF0*/{   L"LOCK",   0      ,   0       ,    0},
 /*    0xF1*/{   L"NULL",   0      ,   0       ,    0},
 /*    0xF2*/{   L"REPNE",   0      ,   0       ,    0},
 /*    0xF3*/{   L"HLT",   0      ,   0       ,    0},
 /*    0xF4*/{   L"HLT",   0      ,   0       ,    0},
 /*    0xF5*/{   L"CMC",   0      ,   0       ,    0},
 /*    0xF6*/{   L"Grp3",   _E_|_b_  ,   0    ,    0},
 /*    0xF7*/{   L"Grp3",   _E_|_v_  ,   0    ,    0},
 /*    0xF8*/{   L"CLC",   0   ,   0    ,    0},
 /*    0xF9*/{   L"STC",   0   ,   0    ,    0},
 /*    0xFA*/{   L"CLI",   0   ,   0    ,    0},
 /*    0xFB*/{   L"STI",   0   ,   0    ,    0},
 /*    0xFC*/{   L"CLD",   0   ,   0    ,    0},
 /*    0xFD*/{   L"STD",   0   ,   0    ,    0},
 /*    0xFE*/{   L"Grp4",   0   ,   0    ,    0},
 /*    0xFF*/{   L"Grp5",   0   ,   0    ,    0}
                };

//mod R/M 表
WCHAR g_szRM[8][8] = {
 /*Mod0*/L"EAX", L"ECX", L"EDX", L"EBX", L"[-][-]", L"EBP", L"ESI", L"EDI" };
           

WCHAR g_szRM3[5][8][6] = {
 /*r 8*/{ L"AL",   L"CL",   L"DL",   L"BL",   L"AH",   L"CH",   L"DH",   L"BH"   },
 /*r16*/{ L"AX",   L"CX",   L"DX",   L"BX",   L"SP",   L"BP",   L"SI",   L"DI"   },
 /*r32*/{ L"EAX",  L"ECX",  L"EDX",  L"EBX",  L"ESP",  L"EBP",  L"ESI",  L"EDI"  },
 /*mm*/ { L"MM0",  L"MM1",  L"MM2",  L"MM3",  L"MM4",  L"MM5",  L"MM6",  L"MM7"  },
 /*xmm*/{ L"XMM0", L"XMM1", L"XMM2", L"XMM3", L"XMM4", L"XMM5", L"XMM6", L"EMM7" }
            };
//REG表
WCHAR g_szREG[5][8][6] = {
 /*r 8*/{ L"AL",   L"CL",   L"DL",   L"BL",   L"AH",   L"CH",   L"DH",   L"BH"   },
 /*r16*/{ L"AX",   L"CX",   L"DX",   L"BX",   L"SP",   L"BP",   L"SI",   L"DI"   },
 /*r32*/{ L"EAX",  L"ECX",  L"EDX",  L"EBX",  L"ESP",  L"EBP",  L"ESI",  L"EDI"  },
 /*mm*/ { L"MM0",  L"MM1",  L"MM2",  L"MM3",  L"MM4",  L"MM5",  L"MM6",  L"MM7"  },
 /*xmm*/{ L"XMM0", L"XMM1", L"XMM2", L"XMM3", L"XMM4", L"XMM5", L"XMM6", L"EMM7" }
            };

//SIB表
WCHAR g_szBASE[8][4] = {
 /*r32*/  L"EAX", L"ECX", L"EDX", L"EBX", L"ESP", L"[*]", L"ESI", L"EDI" };
WCHAR g_szSCALED[4][8][8] = {
 /*SS0*/{ L"EAX",   L"ECX",   L"EDX",   L"EBX",   L"none", L"EBP",   L"ESI",   L"EDI"   },
 /*SS1*/{ L"EAX*2", L"ECX*2", L"EDX*2", L"EBX*2", L"none", L"EBP*2", L"ESI*2", L"EDI*2" },
 /*SS2*/{ L"EAX*4", L"ECX*4", L"EDX*4", L"EBX*4", L"none", L"EBP*4", L"ESI*4", L"EDI*4" },
 /*SS3*/{ L"EAX*8", L"ECX*8", L"EDX*8", L"EBX*8", L"none", L"EBP*8", L"ESI*8", L"EDI*8" }
           };
WCHAR g_Grp[5][8][8] = {
 /*Grp1*/{ L"ADD",  L"OR",  L"ADC",   L"SBB",   L"AND",  L"SUB",  L"XOR",  L"CMP"  },
 /*Grp2*/{ L"ROL",  L"ROR", L"RCL",   L"RCR",   L"SHL",  L"SHR",  L"",     L"SAR"  },
 /*Grp3*/{ L"TEST", L"",    L"NOT",   L"NEG",   L"MUL",  L"IMUL", L"DIV",  L"IDIV" },
 /*Grp4*/{ L"INC",  L"DEC"                                                         },
 /*Grp5*/{ L"INC",  L"DEC", L"CALLN", L"CALLF", L"JMPN", L"JMPF", L"PUSH"          },
            };

//************************************
// 方法:      主要的逻辑函数
// 函数名称:  CASM::Diasm
// 继承关系:  public
// 返回值:    int
// Qualifier:
// 参数:      PBYTE pCodeBuf
// 参数:      wchar_t pASM[]
// 参数:      int nCount
//************************************
int CASM::Diasm(PBYTE pCodeBuf, wchar_t pASM[], int nCount)
{
    //这里的pASM暂时没有用到  
 while (m_OpcodLength>0)       //根据长度判断是否结束解析
 {
  WCHAR Code[MAX_PATH] = {};
  BYTE  byCode = *pCodeBuf;
  //获取指令
  GetInstruction(pCodeBuf, Code);
  //解析第一个操作数
  UINT uOperation1 = g_stcOPCode[byCode].Operation1;
  if (uOperation1)    //判断是操作数是否为0
  {
   GetOperation(pCodeBuf, Code, uOperation1);  
  }
  //3.2解析操作数2
  UINT uOperation2 = g_stcOPCode[byCode].Operation2;
  if (uOperation2)
  {
   swprintf_s(Code, L"%s%s", Code, L",");
   GetOperation(pCodeBuf, Code, uOperation2);
   swprintf_s(Code, L"%s%s", Code, L"\n");
  }
  wprintf(L"%s", Code);

  m_IsModR_M = FALSE;
 }
 
 return 0;
}

//************************************
// 方法:      操作数的长度      用于MODR_M表中 mod=3或reg时
// 函数名称:  CASM::GetOPcodSize
// 继承关系:  public
// 返回值:    int
// Qualifier:
// 参数:      BYTE byOpcodSize
//************************************

//就用了最常见的几种 具体如要用到浮点等在修改
int CASM::GetOPcodSize(BYTE byOpcodSize)
{
 switch (byOpcodSize)
 {
 case _a_:      // 操作数为内存中的WORD或者DWORD,取决于操作数尺寸
 case _b_:      // 一个字节,忽略操作数尺寸属性
 case _c_:   // 一个字节或者word,取决于操作数尺寸
  return 0;  //1byte
 case _w_:   // WORD 忽略操作数尺寸
 case _z_:   // 16位操作数尺寸模式下是WORD,32或者64位操作数尺寸模式是DWORD
 case _y_:     // DWORD或者QWORD(在64位模式下),取决于操作数尺寸
 case _si:      // DWORD的整数寄存器(例如：eax)
  return 1;  //2byte
 case _p_:   // 32位,48位或者80位的指针,取决于操作数尺寸
 case _d_:   // DWORD，忽略操作数尺寸
 case _v_:   // WORD DWORD或者QWORD,取决于操作数尺寸
 case _sd:      // 128 位双精度浮点数据的标量
 case _ss:   // 128位单精度负点数据的标准
  return 3;
 case _pd:   // 128位或者256位双精度浮点数
 case _dq:   // DQWORD(double quadword),忽略操作数尺寸
 case _pi:   // QWORD MMX寄存器
 case _ps:   // 128位或者256位单精度浮点数
 case _q_:   // QWORD,忽略操作数尺寸
 case _qq:   // QQWORD(256位),忽略操作数尺寸
 case _s_:      // QQWORD(256位),忽略操作数尺寸
 case _x_:   // dq或者qq,取决于操作数尺寸
  return 3;
 }
 return 0;
}

//************************************
// 方法:      直接匹配寄存器
// 函数名称:  CASM::GetReg
// 继承关系:  public
// 返回值:    void
// 参数:      UINT uOperType
// 参数:      WCHAR Code[MAX_PATH]
//************************************
void CASM::GetReg(UINT uOperType, WCHAR Code[MAX_PATH])
{
 switch (uOperType)
 {
 case _EAX_:
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"EAX");
  break;             
 case _EBX_:             
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"EBX");
  break;             
 case _ECX_:             
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"ECX");
  break;             
 case _EDX_:             
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"EDX");
  break;             
 case _ESP_:             
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"ESP");
  break;             
 case _EBP_:             
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"EBP");
  break;             
 case _ESI_:             
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"ESI");
  break;             
 case _EDI_:             
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"EDI");
  break;

 case _AL_:
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"AL");
  break;         
 case _BL_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"BL");
  break;         
 case _CL_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"CL");
  break;         
 case _DL_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"DL");
  break;         
 case _AX_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"AX");
  break;         
 case _BX_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"BX");
  break;         
 case _CX_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"CX");
  break;         
 case _DX_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"DX");
  break;         
            
 case _AH_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"AH");
  break;         
 case _BH_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"BH");
  break;         
 case _CH_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"CH");
  break;         
 case _DH_:         
  swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"DH");
  break;
 }
}

//************************************
// 方法:      解析操作数
// 函数名称:  CASM::GetOperation
// 继承关系:  public
// 返回值:    void
// 参数:      PBYTE & pCodeBuf    //opcode数组地址
// 参数:      WCHAR Code[MAX_PATH]   //返回解析后的指令
// 参数:      UINT uOperation    //操作数的类型
//************************************
//操作数中还未解决问题 当加上一个FF开头的数时 实际应该为减
void CASM::GetOperation(PBYTE &pCodeBuf, WCHAR Code[MAX_PATH], UINT uOperation)
{
  if (uOperation >= 0x2000)                    //判断操作数是否不需要查MOD表
  {
   //操作数直接为寄存器时
   GetReg(uOperation, Code);
   return;
  }
  UINT uOperType = uOperation & 0xFF00;
  if (uOperType==_E_||uOperType == _G_)    //当操作数为寄存器或内存时才会获取mod
  {
   if (!m_IsModR_M)
   {
    m_stcModR_M = (PMODR_M)pCodeBuf++;  //取出 MOD R/M
    m_OpcodLength--;
    m_IsModR_M = TRUE;
   }  
  }
  switch (uOperType)        //是否有指令
  {
    case _E_:          //当操作数为 E时查 mod r/m
    {
   switch (m_stcModR_M->MOD)
   {
     case 0:                     //MOD 0
     {
//       if (4 == m_stcModR_M->R_M)   //R_M == 4 需要查SIB表
//       {
//        wchar_t szSIB[30] = {};
//        GetSib(pCodeBuf, szSIB);   //
//        swprintf_s(Code, MAX_PATH, L"%s %s", Code, szSIB);
//        break;
//       }
      if (5 == m_stcModR_M->R_M)
      {
       swprintf_s(Code, MAX_PATH, L"%s 0x%x%x%x%x", Code, *pCodeBuf++, *pCodeBuf++, *pCodeBuf++, *pCodeBuf++);
       m_OpcodLength -= 4;
      }
    
      swprintf_s(Code, MAX_PATH, L"%s [%s]", Code, g_szRM[m_stcModR_M->R_M]);
     }
    break;
//      case 1:            //mod 1
//      {
//       if (4 == m_stcModR_M->R_M)   //查SIB
//       {
//          wchar_t szSIB[30] = {};
//        GetSib(pCodeBuf, szSIB);
//        swprintf_s(Code, MAX_PATH, L"%s %s", Code, szSIB);
//        break;
//       }
//       swprintf_s(Code, MAX_PATH, L"%s [%s+0x%x]", Code, g_szRM[m_stcModR_M->R_M], *pCodeBuf++);
//       m_OpcodLength--;
//      }
//     break;
//      case 2:         //mod 2
//      {
//       if (4 == m_stcModR_M->R_M)   //SIB
//       {
//        wchar_t szSIB[30] = {};
//        GetSib(pCodeBuf, szSIB);
//        swprintf_s(Code, MAX_PATH, L"%s %s", Code, szSIB);
//        break;
//       }
//       swprintf_s(Code, MAX_PATH, L"%s [%s+0x%x%x%x%x]", Code, g_szRM[m_stcModR_M->R_M],
//                                                *pCodeBuf++, *pCodeBuf++, *pCodeBuf++, *pCodeBuf++);
//       m_OpcodLength -= 4;
//      }
    break;
     case 3:          //当mod=3时，要通过指令大小来判断到底是eax还是ax,al
     {
      BYTE byOpcodSize = uOperation & 0xFF;      //计算大小  也就是操作的  _b_,_v_.....
      byOpcodSize = GetOPcodSize(byOpcodSize);
      swprintf_s(Code, MAX_PATH, L"%s %s", Code, g_szRM3[byOpcodSize-1][m_stcModR_M->R_M]);
     }
    break;
   }
    }
     break;
    case _G_:               //直接到寄存器表中索引
    {
     BYTE byOpcodSize = uOperation & 0xFF;          //计算大小
     byOpcodSize = GetOPcodSize(byOpcodSize);
     swprintf_s(Code, MAX_PATH, L"%s %s", Code, g_szREG[byOpcodSize-1][m_stcModR_M->REG]);
    }
     break;
    case _I_:               //立即数
    {
     BYTE byOpcodSize = uOperation & 0xFF; //计算大小
     swprintf_s(Code,MAX_PATH, L"%s %s", Code, L"0x");
     byOpcodSize = GetOPcodSize(byOpcodSize);   //大小
     //例如当前要取出4字节 循环4次
     //因为在前面已经对pCodeBuf数组地址有加1操作，所以要指向第四个字节只用加3.
     for (int i = byOpcodSize; i >= 0; i--)
     {
      if (!*(pCodeBuf + i))       //从第四个字节开始判断 如果byOpcodSize为1 则从第二个字节开始
      {
       //如果取出内容为0，则手动将其改为00
       swprintf_s(Code, MAX_PATH, L"%s%s", Code, L"00");
       m_OpcodLength--;      
       continue;
      }
      swprintf_s(Code, MAX_PATH, L"%s%x", Code, *(pCodeBuf + i));
      m_OpcodLength--;
     }
     pCodeBuf += byOpcodSize + 1;         //最后将pCodeBuf地址设为当前使用过的立即数之后的地址
     break;
    }
    case _O_:            //偏移 需要将偏移加[]
    {
     BYTE byOpcodSize = uOperation & 0xFF; //计算大小
     swprintf_s(Code, MAX_PATH, L"%s %s", Code, L"[0x");
     byOpcodSize = GetOPcodSize(byOpcodSize);   //和立即数的逻辑一样
     for (int i = byOpcodSize; i >= 0; i--)
     {
      if (!*(pCodeBuf+i))
      {
       swprintf_s(Code, MAX_PATH, L"%s%s", Code,L"00");
       m_OpcodLength--;
       continue;
      }
      swprintf_s(Code, MAX_PATH, L"%s%x", Code, *(pCodeBuf+i));
      m_OpcodLength--;
     }
     pCodeBuf += byOpcodSize+1;
     swprintf_s(Code, MAX_PATH, L"%s%s", Code, L"]");
    }
  }
}   

//************************************
// 方法:      获取指令名字
// 函数名称:  CASM::GetInstruction
// 继承关系:  public
// 返回值:    void
// 参数:      PBYTE & pbyCodeBuf   //opcode数组地址
// 参数:      WCHAR Code[MAX_PATH]   //返回解析后的指令
//************************************
void CASM::GetInstruction(PBYTE &pbyCodeBuf, WCHAR Code[MAX_PATH])
{
 PMODR_M Modr_m = (PMODR_M)(pbyCodeBuf + 1);
 switch (*pbyCodeBuf)
 { 
 case 0x80:       //Grp1
 case 0x81:
 case 0x82:
 case 0x83:
 {
  StringCchCopy(Code, MAX_PATH,g_Grp[0][Modr_m->REG]);
  return;
 }
 case 0xC0:       //Grp2
 case 0xC1:
 case 0xD0:
 case 0xD1:
 case 0xD2:
 case 0xD3:
 {
  StringCchCopy(Code, MAX_PATH, g_Grp[1][Modr_m->REG]);
  break;
 }
 case 0xF6:       //Grp3
 case 0xF7:
 {
  StringCchCopy(Code, MAX_PATH, g_Grp[2][Modr_m->REG]);
  break;
 }
 case 0xFE:       //Grp4
 {
  StringCchCopy(Code, MAX_PATH, g_Grp[3][Modr_m->REG]);
  break;
 }
 case 0xFF:       //Grp5
 {
  StringCchCopy(Code, MAX_PATH, g_Grp[4][Modr_m->REG]);
  break;
 }
 default:
  StringCchCopy(Code, MAX_PATH, g_stcOPCode[*pbyCodeBuf].szInstruction);  //当不是组时，按正常解析
 }
 pbyCodeBuf++;      //地址指抽下一个字节
 m_OpcodLength--;     //所有指令的长度减1  相当于将传进来的数组长度减1
}