1376 lines
51 KiB
C
1376 lines
51 KiB
C
/*++
|
||
|
||
Copyright (c) 1994 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
data.c
|
||
|
||
Abstract:
|
||
|
||
This module contains global data for the x86 bios emulator.
|
||
|
||
Author:
|
||
|
||
David N. Cutler (davec) 10-Sep-1994
|
||
|
||
Environment:
|
||
|
||
Kernel mode only.
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "nthal.h"
|
||
#include "emulate.h"
|
||
|
||
//
|
||
// Define emulator initialized variable.
|
||
//
|
||
|
||
BOOLEAN XmEmulatorInitialized = FALSE;
|
||
|
||
//
|
||
// Define emulator context structure.
|
||
//
|
||
|
||
XM_CONTEXT XmContext;
|
||
|
||
//
|
||
// Define operand decode table.
|
||
//
|
||
// This table contains the execution routine for each of the operand types.
|
||
//
|
||
// N.B. There is a cross indexing between the operand decode field of the
|
||
// opcode control array and the decode table.
|
||
//
|
||
|
||
const POPERAND_DECODE XmOperandDecodeTable[] = {
|
||
XmPushPopSegment,
|
||
XmPushPopSegment,
|
||
XmPushPopSegment,
|
||
XmPushPopSegment,
|
||
XmPushPopSegment,
|
||
XmPushPopSegment,
|
||
XmLoadSegment,
|
||
XmLoadSegment,
|
||
XmLoadSegment,
|
||
XmLoadSegment,
|
||
XmLoadSegment,
|
||
XmLoadSegment,
|
||
XmGroup1General,
|
||
XmGroup1Immediate,
|
||
XmGroup2By1,
|
||
XmGroup2ByCL,
|
||
XmGroup2ByByte,
|
||
XmGroup3General,
|
||
XmGroup45General,
|
||
XmGroup45General,
|
||
XmGroup8BitOffset,
|
||
XmOpcodeRegister,
|
||
XmLongJump,
|
||
XmShortJump,
|
||
XmSetccByte,
|
||
XmAccumImmediate,
|
||
XmAccumRegister,
|
||
XmMoveGeneral,
|
||
XmMoveImmediate,
|
||
XmMoveRegImmediate,
|
||
XmSegmentOffset,
|
||
XmMoveSegment,
|
||
XmMoveXxGeneral,
|
||
XmFlagsRegister,
|
||
XmPushImmediate,
|
||
XmPopGeneral,
|
||
XmImulImmediate,
|
||
XmStringOperands,
|
||
XmEffectiveOffset,
|
||
XmImmediateJump,
|
||
XmImmediateEnter,
|
||
XmGeneralBitOffset,
|
||
XmShiftDouble,
|
||
XmPortImmediate,
|
||
XmPortDX,
|
||
XmBitScanGeneral,
|
||
XmByteImmediate,
|
||
XmXlatOpcode,
|
||
XmGeneralRegister,
|
||
XmNoOperands,
|
||
XmOpcodeEscape,
|
||
XmPrefixOpcode
|
||
};
|
||
|
||
//
|
||
// Define opcode function table.
|
||
//
|
||
// This table contains the execution routine for each opcode.
|
||
//
|
||
// N.B. There is cross indexing between the function index field of the
|
||
// opcode control array and the function table. The function index
|
||
// in the opcode control array may be the index of the execution
|
||
// function, the base index of the execution function, or a switch
|
||
// value to be used in selecting the function (i.e., prefix opcodes).
|
||
//
|
||
|
||
const POPCODE_FUNCTION XmOpcodeFunctionTable[] = {
|
||
|
||
//
|
||
// ASCII operators.
|
||
//
|
||
|
||
XmAaaOp,
|
||
XmAadOp,
|
||
XmAamOp,
|
||
XmAasOp,
|
||
XmDaaOp,
|
||
XmDasOp,
|
||
|
||
//
|
||
// Group 1 operators.
|
||
//
|
||
|
||
XmAddOp,
|
||
XmOrOp,
|
||
XmAdcOp,
|
||
XmSbbOp,
|
||
XmAndOp,
|
||
XmSubOp,
|
||
XmXorOp,
|
||
XmCmpOp,
|
||
|
||
//
|
||
// Group 2 operators.
|
||
//
|
||
|
||
XmRolOp,
|
||
XmRorOp,
|
||
XmRclOp,
|
||
XmRcrOp,
|
||
XmShlOp,
|
||
XmShrOp,
|
||
XmIllOp,
|
||
XmSarOp,
|
||
|
||
//
|
||
// Group 3 operators.
|
||
//
|
||
|
||
XmTestOp,
|
||
XmIllOp,
|
||
XmNotOp,
|
||
XmNegOp,
|
||
XmMulOp,
|
||
XmImulxOp,
|
||
XmDivOp,
|
||
XmIdivOp,
|
||
|
||
//
|
||
// Group 4 and 5 operators.
|
||
//
|
||
|
||
XmIncOp,
|
||
XmDecOp,
|
||
XmCallOp,
|
||
XmCallOp,
|
||
XmJmpOp,
|
||
XmJmpOp,
|
||
XmPushOp,
|
||
XmIllOp,
|
||
|
||
//
|
||
// Group 8 operators.
|
||
//
|
||
|
||
XmBtOp,
|
||
XmBtsOp,
|
||
XmBtrOp,
|
||
XmBtcOp,
|
||
|
||
//
|
||
// Stack push and pop operators.
|
||
//
|
||
|
||
XmPopOp,
|
||
XmPushaOp,
|
||
XmPopaOp,
|
||
|
||
//
|
||
// Conditional jump operators.
|
||
//
|
||
|
||
XmJxxOp,
|
||
XmLoopOp,
|
||
XmJcxzOp,
|
||
|
||
//
|
||
// Control operators.
|
||
//
|
||
|
||
XmEnterOp,
|
||
XmHltOp,
|
||
XmIntOp,
|
||
XmIretOp,
|
||
XmLeaveOp,
|
||
XmRetOp,
|
||
|
||
//
|
||
// Set boolean byte value based on condition.
|
||
//
|
||
|
||
XmSxxOp,
|
||
|
||
//
|
||
// Condition code operators.
|
||
//
|
||
|
||
XmCmcOp,
|
||
XmClcOp,
|
||
XmStcOp,
|
||
XmCliOp,
|
||
XmStiOp,
|
||
XmCldOp,
|
||
XmStdOp,
|
||
XmLahfOp,
|
||
XmSahfOp,
|
||
|
||
//
|
||
// General move operators.
|
||
//
|
||
|
||
XmMovOp,
|
||
XmXchgOp,
|
||
|
||
//
|
||
// Convert operators.
|
||
//
|
||
|
||
XmCbwOp,
|
||
XmCwdOp,
|
||
|
||
//
|
||
// Single multiply operator.
|
||
//
|
||
|
||
XmImulOp,
|
||
|
||
//
|
||
// String operators.
|
||
//
|
||
|
||
XmCmpsOp,
|
||
XmInsOp,
|
||
XmLodsOp,
|
||
XmMovsOp,
|
||
XmOutsOp,
|
||
XmScasOp,
|
||
XmStosOp,
|
||
|
||
//
|
||
// Effective address operators.
|
||
//
|
||
|
||
XmBoundOp,
|
||
XmMovOp,
|
||
|
||
//
|
||
// Double Shift operators.
|
||
//
|
||
|
||
XmShldOp,
|
||
XmShrdOp,
|
||
|
||
//
|
||
// I/O operators.
|
||
//
|
||
|
||
XmInOp,
|
||
XmOutOp,
|
||
|
||
//
|
||
// Bit scan operators.
|
||
//
|
||
|
||
XmBsfOp,
|
||
XmBsrOp,
|
||
|
||
//
|
||
// Byte swap operators.
|
||
//
|
||
|
||
XmBswapOp,
|
||
|
||
//
|
||
// Add/Compare exchange operators.
|
||
//
|
||
|
||
XmXaddOp,
|
||
XmCmpxchgOp,
|
||
|
||
//
|
||
// No operation.
|
||
//
|
||
|
||
XmNopOp,
|
||
|
||
//
|
||
// Illegal opcode.
|
||
//
|
||
|
||
XmIllOp
|
||
};
|
||
|
||
//
|
||
// Define opcode control table.
|
||
//
|
||
// There are two opcode tables which control the emulation of each x86
|
||
// opcode. One table is for single byte opcodes and the other is for
|
||
// two byte opcodes.
|
||
//
|
||
|
||
const OPCODE_CONTROL XmOpcodeControlTable1[] = {
|
||
{X86_ADD_OP, FormatGroup1General}, // 0x00 - add Eb,Gb
|
||
{X86_ADD_OP, FormatGroup1General}, // 0x01 - add Ev,Gv
|
||
{X86_ADD_OP, FormatGroup1General}, // 0x02 - add Gb,Eb
|
||
{X86_ADD_OP, FormatGroup1General}, // 0x03 - add Gv,Ev
|
||
{X86_ADD_OP, FormatAccumImmediate}, // 0x04 - add AL,Ib
|
||
{X86_ADD_OP, FormatAccumImmediate}, // 0x05 - add eAX,Iv
|
||
{X86_PUSH_OP, FormatSegmentES}, // 0x06 - push ES
|
||
{X86_POP_OP, FormatSegmentES}, // 0x07 - pop ES
|
||
{X86_OR_OP, FormatGroup1General}, // 0x08 - or Eb,Gb
|
||
{X86_OR_OP, FormatGroup1General}, // 0x09 - or Ev,Gv
|
||
{X86_OR_OP, FormatGroup1General}, // 0x0a - or Gb,Eb
|
||
{X86_OR_OP, FormatGroup1General}, // 0x0b - or Gv,Ev
|
||
{X86_OR_OP, FormatAccumImmediate}, // 0x0c - or AL,Ib
|
||
{X86_OR_OP, FormatAccumImmediate}, // 0x0d - or eAX,Iv
|
||
{X86_PUSH_OP, FormatSegmentCS}, // 0x0e - push CS
|
||
{0, FormatOpcodeEscape}, // 0x0f - escape:
|
||
{X86_ADC_OP, FormatGroup1General}, // 0x10 - adc Eb,Gb
|
||
{X86_ADC_OP, FormatGroup1General}, // 0x11 - adc Ev,Gv
|
||
{X86_ADC_OP, FormatGroup1General}, // 0x12 - adc Gb,Eb
|
||
{X86_ADC_OP, FormatGroup1General}, // 0x13 - adc Gv,Ev
|
||
{X86_ADC_OP, FormatAccumImmediate}, // 0x14 - adc AL,Ib
|
||
{X86_ADC_OP, FormatAccumImmediate}, // 0x15 - adc eAX,Iv
|
||
{X86_PUSH_OP, FormatSegmentSS}, // 0x16 - push SS
|
||
{X86_POP_OP, FormatSegmentSS}, // 0x17 - pop SS
|
||
{X86_SBB_OP, FormatGroup1General}, // 0x18 - sbb Eb,Gb
|
||
{X86_SBB_OP, FormatGroup1General}, // 0x19 - sbb Ev,Gv
|
||
{X86_SBB_OP, FormatGroup1General}, // 0x1a - sbb Gb,Eb
|
||
{X86_SBB_OP, FormatGroup1General}, // 0x1b - sbb Gv,Ev
|
||
{X86_SBB_OP, FormatAccumImmediate}, // 0x1c - sbb AL,Ib
|
||
{X86_SBB_OP, FormatAccumImmediate}, // 0x1d - sbb eAX,Iv
|
||
{X86_PUSH_OP, FormatSegmentDS}, // 0x1e - push DS
|
||
{X86_POP_OP, FormatSegmentDS}, // 0x1f - pop DS
|
||
{X86_AND_OP, FormatGroup1General}, // 0x20 - and Eb,Gb
|
||
{X86_AND_OP, FormatGroup1General}, // 0x21 - and Ev,Gv
|
||
{X86_AND_OP, FormatGroup1General}, // 0x22 - and Gb,Eb
|
||
{X86_AND_OP, FormatGroup1General}, // 0x23 - and Gv,Ev
|
||
{X86_AND_OP, FormatAccumImmediate}, // 0x24 - and AL,Ib
|
||
{X86_AND_OP, FormatAccumImmediate}, // 0x25 - and eAX,Iv
|
||
{X86_ES_OP, FormatPrefixOpcode}, // 0x26 - ES:
|
||
{X86_DAA_OP, FormatNoOperands}, // 0x27 - daa
|
||
{X86_SUB_OP, FormatGroup1General}, // 0x28 - sub Eb,Gb
|
||
{X86_SUB_OP, FormatGroup1General}, // 0x29 - sub Ev,Gv
|
||
{X86_SUB_OP, FormatGroup1General}, // 0x2a - sub Gb,Eb
|
||
{X86_SUB_OP, FormatGroup1General}, // 0x2b - sub Gv,Ev
|
||
{X86_SUB_OP, FormatAccumImmediate}, // 0x2c - sub AL,Ib
|
||
{X86_SUB_OP, FormatAccumImmediate}, // 0x2d - sub eAX,Iv
|
||
{X86_CS_OP, FormatPrefixOpcode}, // 0x2e - CS:
|
||
{X86_DAS_OP, FormatNoOperands}, // 0x2f - das
|
||
{X86_XOR_OP, FormatGroup1General}, // 0x30 - xor Eb,Gb
|
||
{X86_XOR_OP, FormatGroup1General}, // 0x31 - xor Ev,Gv
|
||
{X86_XOR_OP, FormatGroup1General}, // 0x32 - xor Gb,Eb
|
||
{X86_XOR_OP, FormatGroup1General}, // 0x33 - xor Gv,Ev
|
||
{X86_XOR_OP, FormatAccumImmediate}, // 0x34 - xor AL,Ib
|
||
{X86_XOR_OP, FormatAccumImmediate}, // 0x35 - xor eAX,Iv
|
||
{X86_SS_OP, FormatPrefixOpcode}, // 0x36 - SS:
|
||
{X86_AAA_OP, FormatNoOperands}, // 0x37 - aaa
|
||
{X86_CMP_OP, FormatGroup1General}, // 0x38 - cmp Eb,Gb
|
||
{X86_CMP_OP, FormatGroup1General}, // 0x39 - cmp Ev,Gv
|
||
{X86_CMP_OP, FormatGroup1General}, // 0x3a - cmp Gb,Eb
|
||
{X86_CMP_OP, FormatGroup1General}, // 0x3b - cmp Gv,Ev
|
||
{X86_CMP_OP, FormatAccumImmediate}, // 0x3c - cmp AL,Ib
|
||
{X86_CMP_OP, FormatAccumImmediate}, // 0x3d - cmp eAX,Iv
|
||
{X86_DS_OP, FormatPrefixOpcode}, // 0x3e - DS:
|
||
{X86_AAS_OP, FormatNoOperands}, // 0x3f - aas
|
||
{X86_INC_OP, FormatOpcodeRegister}, // 0x40 - inc eAX
|
||
{X86_INC_OP, FormatOpcodeRegister}, // 0x41 - inc eCX
|
||
{X86_INC_OP, FormatOpcodeRegister}, // 0x42 - inc eDX
|
||
{X86_INC_OP, FormatOpcodeRegister}, // 0x43 - inc eBX
|
||
{X86_INC_OP, FormatOpcodeRegister}, // 0x44 - inc eSP
|
||
{X86_INC_OP, FormatOpcodeRegister}, // 0x45 - inc eBP
|
||
{X86_INC_OP, FormatOpcodeRegister}, // 0x46 - inc eSI
|
||
{X86_INC_OP, FormatOpcodeRegister}, // 0x47 - inc eDI
|
||
{X86_DEC_OP, FormatOpcodeRegister}, // 0x48 - dec eAX
|
||
{X86_DEC_OP, FormatOpcodeRegister}, // 0x49 - dec eCX
|
||
{X86_DEC_OP, FormatOpcodeRegister}, // 0x4a - dec eDX
|
||
{X86_DEC_OP, FormatOpcodeRegister}, // 0x4b - dec eBX
|
||
{X86_DEC_OP, FormatOpcodeRegister}, // 0x4c - dec eSP
|
||
{X86_DEC_OP, FormatOpcodeRegister}, // 0x4d - dec eBP
|
||
{X86_DEC_OP, FormatOpcodeRegister}, // 0x4e - dec eSI
|
||
{X86_DEC_OP, FormatOpcodeRegister}, // 0x4f - dec eDI
|
||
{X86_PUSH_OP, FormatOpcodeRegister}, // 0x50 - push eAX
|
||
{X86_PUSH_OP, FormatOpcodeRegister}, // 0x51 - push eCX
|
||
{X86_PUSH_OP, FormatOpcodeRegister}, // 0x52 - push eDX
|
||
{X86_PUSH_OP, FormatOpcodeRegister}, // 0x53 - push eBX
|
||
{X86_PUSH_OP, FormatOpcodeRegister}, // 0x54 - push eSP
|
||
{X86_PUSH_OP, FormatOpcodeRegister}, // 0x55 - push eBP
|
||
{X86_PUSH_OP, FormatOpcodeRegister}, // 0x56 - push eSI
|
||
{X86_PUSH_OP, FormatOpcodeRegister}, // 0x57 - push eDI
|
||
{X86_POP_OP, FormatOpcodeRegister}, // 0x58 - pop eAX
|
||
{X86_POP_OP, FormatOpcodeRegister}, // 0x59 - pop eCX
|
||
{X86_POP_OP, FormatOpcodeRegister}, // 0x5a - pop eDX
|
||
{X86_POP_OP, FormatOpcodeRegister}, // 0x5b - pop eBX
|
||
{X86_POP_OP, FormatOpcodeRegister}, // 0x5c - pop eSP
|
||
{X86_POP_OP, FormatOpcodeRegister}, // 0x5d - pop eBP
|
||
{X86_POP_OP, FormatOpcodeRegister}, // 0x5e - pop eSI
|
||
{X86_POP_OP, FormatOpcodeRegister}, // 0x5f - pop eDI
|
||
{X86_PUSHA_OP, FormatNoOperands}, // 0x60 - pusha
|
||
{X86_POPA_OP, FormatNoOperands}, // 0x61 - popa
|
||
{X86_BOUND_OP, FormatEffectiveOffset}, // 0x62 - bound Gv,Ma
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x63 - arpl Ew,Rw
|
||
{X86_FS_OP, FormatPrefixOpcode}, // 0x64 - FS:
|
||
{X86_GS_OP, FormatPrefixOpcode}, // 0x65 - GS:
|
||
{X86_OPSZ_OP, FormatPrefixOpcode}, // 0x66 - opsize
|
||
{X86_ADSZ_OP, FormatPrefixOpcode}, // 0x67 - opaddr
|
||
{X86_PUSH_OP, FormatPushImmediate}, // 0x68 - push iv
|
||
{X86_IMUL_OP, FormatImulImmediate}, // 0x69 - imul
|
||
{X86_PUSH_OP, FormatPushImmediate}, // 0x6a - push ib
|
||
{X86_IMUL_OP, FormatImulImmediate}, // 0x6b - imul
|
||
{X86_INS_OP, FormatPortDX}, // 0x6c - insb
|
||
{X86_INS_OP, FormatPortDX}, // 0x6d - insw/d
|
||
{X86_OUTS_OP, FormatPortDX}, // 0x6e - outsb
|
||
{X86_OUTS_OP, FormatPortDX}, // 0x6f - outsw/d
|
||
{X86_JXX_OP, FormatShortJump}, // 0x70 - jo jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x71 - jno jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x72 - jb jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x73 - jnb jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x74 - jz jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x75 - jnz jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x76 - jbe jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x77 - jnbe jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x78 - js jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x79 - jns jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x7a - jp jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x7b - jnp jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x7c - jl jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x7d - jnl jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x7e - jle jb
|
||
{X86_JXX_OP, FormatShortJump}, // 0x7f - jnle jb
|
||
{X86_ADD_OP, FormatGroup1Immediate}, // 0x80 - group1 Eb,Ib
|
||
{X86_ADD_OP, FormatGroup1Immediate}, // 0x81 - group1 Ev,Iv
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x82 - illegal
|
||
{X86_ADD_OP, FormatGroup1Immediate}, // 0x83 - group1 Ev,Ib
|
||
{X86_TEST_OP, FormatGroup1General}, // 0x84 - test Eb,Gb
|
||
{X86_TEST_OP, FormatGroup1General}, // 0x85 - test Ev,Gv
|
||
{X86_XCHG_OP, FormatGroup1General}, // 0x86 - xchg Eb,Gb
|
||
{X86_XCHG_OP, FormatGroup1General}, // 0x87 = xchg Ev,Gv
|
||
{X86_MOV_OP, FormatMoveGeneral}, // 0x88 - mov Eb,Gb
|
||
{X86_MOV_OP, FormatMoveGeneral}, // 0x89 - mov Ev,Gv
|
||
{X86_MOV_OP, FormatMoveGeneral}, // 0x8a - mov Gb,Eb
|
||
{X86_MOV_OP, FormatMoveGeneral}, // 0x8b - mov Gv,Ev
|
||
{X86_MOV_OP, FormatMoveSegment}, // 0x8c - mov Ew,Sw
|
||
{X86_LEA_OP, FormatEffectiveOffset}, // 0x8d - lea Gv,Ma
|
||
{X86_MOV_OP, FormatMoveSegment}, // 0x8e - mov Sw,Ew
|
||
{X86_POP_OP, FormatPopGeneral}, // 0x8f - pop Ev
|
||
{X86_NOP_OP, FormatNoOperands}, // 0x90 - nop
|
||
{X86_XCHG_OP, FormatAccumRegister}, // 0x91 - xchg eCX,eAX
|
||
{X86_XCHG_OP, FormatAccumRegister}, // 0x92 - xchg eDX,eAX
|
||
{X86_XCHG_OP, FormatAccumRegister}, // 0x93 - xchg eBX,eAX
|
||
{X86_XCHG_OP, FormatAccumRegister}, // 0x94 - xchg eSP,eAX
|
||
{X86_XCHG_OP, FormatAccumRegister}, // 0x95 - xchg eBP,eAX
|
||
{X86_XCHG_OP, FormatAccumRegister}, // 0x96 - xchg eSI,eAX
|
||
{X86_XCHG_OP, FormatAccumRegister}, // 0x97 - xchg eDI,eAX
|
||
{X86_CBW_OP, FormatNoOperands}, // 0x98 - cbw
|
||
{X86_CWD_OP, FormatNoOperands}, // 0x99 - cwd
|
||
{X86_CALL_OP, FormatImmediateJump}, // 0x9a - call Ap
|
||
{X86_NOP_OP, FormatNoOperands}, // 0x9b - wait
|
||
{X86_PUSH_OP, FormatFlagsRegister}, // 0x9c - pushf
|
||
{X86_POP_OP, FormatFlagsRegister}, // 0x9d - popf
|
||
{X86_SAHF_OP, FormatNoOperands}, // 0x9e - sahf
|
||
{X86_LAHF_OP, FormatNoOperands}, // 0x9f - lahf
|
||
{X86_MOV_OP, FormatSegmentOffset}, // 0xa0 - mov AL,Ob
|
||
{X86_MOV_OP, FormatSegmentOffset}, // 0xa1 - mov eAX,Ov
|
||
{X86_MOV_OP, FormatSegmentOffset}, // 0xa2 - mov Ob,AL
|
||
{X86_MOV_OP, FormatSegmentOffset}, // 0xa3 - mov Ov,eAX
|
||
{X86_MOVS_OP, FormatStringOperands}, // 0xa4 - movsb
|
||
{X86_MOVS_OP, FormatStringOperands}, // 0xa5 - movsw/d
|
||
{X86_CMPS_OP, FormatStringOperands}, // 0xa6 - cmpsb
|
||
{X86_CMPS_OP, FormatStringOperands}, // 0xa7 - cmpsw/d
|
||
{X86_TEST_OP, FormatAccumImmediate}, // 0xa8 - test AL,Ib
|
||
{X86_TEST_OP, FormatAccumImmediate}, // 0xa9 - test eAX,Iv
|
||
{X86_STOS_OP, FormatStringOperands}, // 0xaa - stosb
|
||
{X86_STOS_OP, FormatStringOperands}, // 0xab - stosw/d
|
||
{X86_LODS_OP, FormatStringOperands}, // 0xac - lodsb
|
||
{X86_LODS_OP, FormatStringOperands}, // 0xad - lodsw.d
|
||
{X86_SCAS_OP, FormatStringOperands}, // 0xae - scasb
|
||
{X86_SCAS_OP, FormatStringOperands}, // 0xaf - scasw/d
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb0 mov AL,Ib
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb1 mov Cl,Ib
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb2 mov DL,Ib
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb3 mov BL,Ib
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb4 mov AH,Ib
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb5 mov CH,Ib
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb6 mov DH,Ib
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb7 mov BH,Ib
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb8 mov eAX,Iv
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xb9 mov eCX,Iv
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xba mov eDX,Iv
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xbb mov eBX,Iv
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xbc mov eSP,Iv
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xbd mov eBP,Iv
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xbe mov eSI,Iv
|
||
{X86_MOV_OP, FormatMoveRegImmediate}, // 0xbf mov eDI,Iv
|
||
{X86_ROL_OP, FormatGroup2ByByte}, // 0xc0 - group2 Eb,Ib
|
||
{X86_ROL_OP, FormatGroup2ByByte}, // 0xc1 - group2 Ev,Ib
|
||
{X86_RET_OP, FormatNoOperands}, // 0xc2 - ret Iw (near)
|
||
{X86_RET_OP, FormatNoOperands}, // 0xc3 - ret (near)
|
||
{X86_MOV_OP, FormatLoadSegmentES}, // 0xc4 - les Gv,Mp
|
||
{X86_MOV_OP, FormatLoadSegmentDS}, // 0xc5 - lds Gv,Mp
|
||
{X86_MOV_OP, FormatMoveImmediate}, // 0xc6 - mov Eb,Ib
|
||
{X86_MOV_OP, FormatMoveImmediate}, // 0xc7 - mov Ev,Iv
|
||
{X86_ENTER_OP, FormatImmediateEnter}, // 0xc8 - enter Iw,Ib
|
||
{X86_LEAVE_OP, FormatNoOperands}, // 0xc9 - leave
|
||
{X86_RET_OP, FormatNoOperands}, // 0xca - ret Iw (far)
|
||
{X86_RET_OP, FormatNoOperands}, // 0xcb - ret (far)
|
||
{X86_INT_OP, FormatNoOperands}, // 0xcc - int 3
|
||
{X86_INT_OP, FormatByteImmediate}, // 0xcd - int Ib
|
||
{X86_INT_OP, FormatNoOperands}, // 0xce - into
|
||
{X86_IRET_OP, FormatNoOperands}, // 0xcf - iret
|
||
{X86_ROL_OP, FormatGroup2By1}, // 0xd0 - group2 Eb,1
|
||
{X86_ROL_OP, FormatGroup2By1}, // 0xd1 - group2 Ev,1
|
||
{X86_ROL_OP, FormatGroup2ByCL}, // 0xd2 - group2 Eb,CL
|
||
{X86_ROL_OP, FormatGroup2ByCL}, // 0xd3 - group2 Ev,CL
|
||
{X86_AAM_OP, FormatByteImmediate}, // 0xd4 - aam
|
||
{X86_AAD_OP, FormatByteImmediate}, // 0xd5 - aad
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd6 - illegal
|
||
{X86_MOV_OP, FormatXlatOpcode}, // 0xd7 - xlat
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd8 - esc0
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd9 - esc1
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xda - esc2
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xdb - esc3
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xdc - esc4
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xdd - esc5
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xde - esc6
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xdf - esc7
|
||
{X86_LOOP_OP, FormatShortJump}, // 0xe0 - loopnz
|
||
{X86_LOOP_OP, FormatShortJump}, // 0xe1 - loopz
|
||
{X86_LOOP_OP, FormatShortJump}, // 0xe2 - loop
|
||
{X86_JCXZ_OP, FormatShortJump}, // 0xe3 - jcxz
|
||
{X86_IN_OP, FormatPortImmediate}, // 0xe4 - inb AL,Ib
|
||
{X86_IN_OP, FormatPortImmediate}, // 0xe5 - inw/d eAX,Ib
|
||
{X86_OUT_OP, FormatPortImmediate}, // 0xe6 - outb Ib,AL
|
||
{X86_OUT_OP, FormatPortImmediate}, // 0xe7 - outw/d Ib,eAX
|
||
{X86_CALL_OP, FormatLongJump}, // 0xe8 - call Jv
|
||
{X86_JMP_OP, FormatLongJump}, // 0xe9 - jmp Jv
|
||
{X86_JMP_OP, FormatImmediateJump}, // 0xea - jmp Ap
|
||
{X86_JMP_OP, FormatShortJump}, // 0xeb - jmp Jb
|
||
{X86_IN_OP, FormatPortDX}, // 0xec - inb AL,DX
|
||
{X86_IN_OP, FormatPortDX}, // 0xed - inw/d eAX,DX
|
||
{X86_OUT_OP, FormatPortDX}, // 0xee - outb Ib,DX
|
||
{X86_OUT_OP, FormatPortDX}, // 0xef - outw/d eAX,DX
|
||
{X86_LOCK_OP, FormatPrefixOpcode}, // 0xf0 - lock
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf1 - illegal
|
||
{X86_REPNZ_OP, FormatPrefixOpcode}, // 0xf2 - repnz
|
||
{X86_REPZ_OP, FormatPrefixOpcode}, // 0xf3 - repz
|
||
{X86_HLT_OP, FormatNoOperands}, // 0xf4 - hlt
|
||
{X86_CMC_OP, FormatNoOperands}, // 0xf5 - cmc
|
||
{X86_TEST_OP, FormatGroup3General}, // 0xf6 - group3 Eb,?
|
||
{X86_TEST_OP, FormatGroup3General}, // 0xf7 - group3 Ev,?
|
||
{X86_CLC_OP, FormatNoOperands}, // 0xf8 - clc
|
||
{X86_STC_OP, FormatNoOperands}, // 0xf9 - stc
|
||
{X86_CLI_OP, FormatNoOperands}, // 0xfa - cli
|
||
{X86_STI_OP, FormatNoOperands}, // 0xfb - sti
|
||
{X86_CLD_OP, FormatNoOperands}, // 0xfc - cld
|
||
{X86_STD_OP, FormatNoOperands}, // 0xfd - std
|
||
{X86_INC_OP, FormatGroup4General}, // 0xfe - group4 Eb
|
||
{X86_INC_OP, FormatGroup5General}, // 0xff - group5 Ev
|
||
};
|
||
|
||
const OPCODE_CONTROL XmOpcodeControlTable2[] = {
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x00 - group6
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x01 - group7
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x02 - lar
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x03 - lsl
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x04 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x05 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x06 - clts
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x07 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x08 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x09 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x0a - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x0b - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x0c - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x0d - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x0e - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x0f - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x10 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x11 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x12 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x13 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x14 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x15 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x16 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x17 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x18 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x19 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x1a - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x1b - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x1c - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x1d - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x1e - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x1f - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x20 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x21 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x22 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x23 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x34 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x25 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x26 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x27 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x28 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x29 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x2a - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x2b - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x2c - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x2d - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x2e - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x2f - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x30 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x31 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x32 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x33 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x34 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x35 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x36 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x37 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x38 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x39 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x3a - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x3b - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x3c - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x3d - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x3e - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x3f - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x40 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x41 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x42 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x43 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x44 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x45 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x46 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x47 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x48 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x49 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x4a - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x4b - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x4c - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x4d - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x4e - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x4f - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x50 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x51 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x52 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x53 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x54 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x55 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x56 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x57 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x58 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x59 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x5a - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x5b - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x5c - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x5d - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x5e - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x5f - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x60 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x61 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x62 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x63 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x64 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x65 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x66 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x67 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x68 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x69 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x6a - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x6b - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x6c - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x6d - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x6e - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x6f - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x70 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x71 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x72 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x73 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x74 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x75 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x76 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x77 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x78 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x79 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x7a - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x7b - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x7c - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x7d - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x7e - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0x7f - illegal
|
||
{X86_JXX_OP, FormatLongJump}, // 0x80 - jo jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x81 - jno jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x82 - jb jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x83 - jnb jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x84 - jz jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x85 - jnz jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x86 - jbe jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x87 - jnbe jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x88 - js jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x89 - jns jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x8a - jp jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x8b - jnp jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x8c - jl jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x8d - jnl jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x8e - jle jv
|
||
{X86_JXX_OP, FormatLongJump}, // 0x8f - jnle jv
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x90 - seto Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x91 - setno Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x92 - setb Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x93 - setnb Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x94 - setz Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x95 - setnz Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x96 - setbe Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x97 - setnbe Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x98 - sets Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x99 - setns Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x9a - setp Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x9b - setnp Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x9c - setl Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x9d - setnl Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x9e - setle Eb
|
||
{X86_SXX_OP, FormatSetccByte}, // 0x9f - setnle Eb
|
||
{X86_PUSH_OP, FormatSegmentFS}, // 0xa0 - push FS
|
||
{X86_POP_OP, FormatSegmentFS}, // 0xa1 - pop FS
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xa2 - illegal
|
||
{X86_BT_OP, FormatGeneralBitOffset}, // 0xa3 - bt Ev,Gv
|
||
{X86_SHLD_OP, FormatShiftDouble}, // 0xa4 - shld Ev,Gv,Ib
|
||
{X86_SHLD_OP, FormatShiftDouble}, // 0xa5 - shld Ev,Gv,cl
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xa6 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xa6 - illegal
|
||
{X86_PUSH_OP, FormatSegmentGS}, // 0xa8 - push GS
|
||
{X86_POP_OP, FormatSegmentGS}, // 0xa9 - pop GS
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xaa - illegal
|
||
{X86_BTS_OP, FormatGeneralBitOffset}, // 0xab - bts Ev,Gv
|
||
{X86_SHRD_OP, FormatShiftDouble}, // 0xac - shdr Ev,Gv,Ib
|
||
{X86_SHRD_OP, FormatShiftDouble}, // 0xad - shdr Rv,Gv,cl
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xae - illegal
|
||
{X86_IMUL_OP, FormatGroup1General}, // 0xaf - imul Gv,Ev
|
||
{X86_CMPXCHG_OP, FormatGroup1General}, // 0xb0 - cmpxchg Eb,Gb
|
||
{X86_CMPXCHG_OP, FormatGroup1General}, // 0xb1 - cmpxchg Ev,Gv
|
||
{X86_MOV_OP, FormatLoadSegmentSS}, // 0xb2 - lss Gv,Mp
|
||
{X86_BTR_OP, FormatGeneralBitOffset}, // 0xb3 - btr Ev,Gv
|
||
{X86_MOV_OP, FormatLoadSegmentFS}, // 0xb4 - lfs Gv,Mp
|
||
{X86_MOV_OP, FormatLoadSegmentGS}, // 0xb5 - lgd Gv,Mp
|
||
{X86_MOV_OP, FormatMoveXxGeneral}, // 0xb6 - movzb Gv,Eb
|
||
{X86_MOV_OP, FormatMoveXxGeneral}, // 0xb7 - movsw Gv,Ew
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xb8 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xb9 - illegal
|
||
{X86_BT_OP, FormatGroup8BitOffset}, // 0xba - group8 Ev,Ib
|
||
{X86_BTC_OP, FormatGeneralBitOffset}, // 0xbb - btc Ev,Gv
|
||
{X86_BSF_OP, FormatBitScanGeneral}, // 0xbc - bsf Gv,Ev
|
||
{X86_BSR_OP, FormatBitScanGeneral}, // 0xbd - bsr Gv,Ev
|
||
{X86_MOV_OP, FormatMoveXxGeneral}, // 0xbe - movsb Gv,Eb
|
||
{X86_MOV_OP, FormatMoveXxGeneral}, // 0xbf - movsw Gv,Ew
|
||
{X86_XADD_OP, FormatGroup1General}, // 0xc0 - xadd Eb,Gb
|
||
{X86_XADD_OP, FormatGroup1General}, // 0xc1 - xadd Ev,Gv
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xc2 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xc3 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xc4 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xc5 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xc6 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xc7 - illegal
|
||
{X86_BSWAP_OP, FormatGeneralRegister}, // 0xc8 - bswap Gv
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xc9 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xca - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xcb - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xcc - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xcd - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xce - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xcf - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd0 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd1 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd2 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd3 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd4 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd5 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd6 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd7 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd8 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xd9 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xda - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xdb - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xdc - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xdd - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xde - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xdf - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe0 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe1 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe2 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe3 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe4 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe5 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe6 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe7 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe8 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xe9 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xea - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xeb - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xec - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xed - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xee - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xef - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf0 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf1 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf2 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf3 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf4 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf5 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf6 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf7 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf8 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xf9 - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xfa - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xfb - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xfc - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xfd - illegal
|
||
{X86_ILL_OP, FormatNoOperands}, // 0xfe - illegal
|
||
{X86_ILL_OP, FormatNoOperands} // 0xff - illegal
|
||
};
|
||
|
||
//
|
||
// Define opcode name tables.
|
||
//
|
||
|
||
#if defined(XM_DEBUG)
|
||
|
||
const PCHAR XmOpcodeNameTable1[] = {
|
||
"add Eb,Gb ", // 0x00
|
||
"add Ev,Gv ", // 0x01
|
||
"add Gb,Eb ", // 0x02
|
||
"add Gv,Ev ", // 0x03
|
||
"add AL,Ib ", // 0x04
|
||
"add eAX,Iv ", // 0x05
|
||
"push ES ", // 0x06
|
||
"pop ES ", // 0x07
|
||
"or Eb,Gb ", // 0x08
|
||
"or Ev,Gv ", // 0x09
|
||
"or Gb,Eb ", // 0x0a
|
||
"or Gv,Ev ", // 0x0b
|
||
"or AL,Ib ", // 0x0c
|
||
"or eAX,Iv ", // 0x0d
|
||
"push CS ", // 0x0e
|
||
"escape: ", // 0x0f
|
||
"adc Eb,Gb ", // 0x10
|
||
"adc Ev,Gv ", // 0x11
|
||
"adc Gb,Eb ", // 0x12
|
||
"adc Gv,Ev ", // 0x13
|
||
"adc AL,Ib ", // 0x14
|
||
"adc eAX,Iv ", // 0x15
|
||
"push SS ", // 0x16
|
||
"pop SS ", // 0x17
|
||
"sbb Eb,Gb ", // 0x18
|
||
"sbb Ev,Gv ", // 0x19
|
||
"sbb Gb,Eb ", // 0x1a
|
||
"sbb Gv,Ev ", // 0x1b
|
||
"sbb AL,Ib ", // 0x1c
|
||
"sbb eAX,Iv ", // 0x1d
|
||
"push DS ", // 0x1e
|
||
"pop DS ", // 0x1f
|
||
"and Eb,Gb ", // 0x20
|
||
"and Ev,Gv ", // 0x21
|
||
"and Gb,Eb ", // 0x22
|
||
"and Gv,Ev ", // 0x23
|
||
"and AL,Ib ", // 0x24
|
||
"and eAX,Iv ", // 0x25
|
||
"ES: ", // 0x26
|
||
"daa ", // 0x27
|
||
"sub Eb,Gb ", // 0x28
|
||
"sub Ev,Gv ", // 0x29
|
||
"sub Gb,Eb ", // 0x2a
|
||
"sub Gv,Ev ", // 0x2b
|
||
"sub AL,Ib ", // 0x2c
|
||
"sub eAX,Iv ", // 0x2d
|
||
"CS: ", // 0x2e
|
||
"das ", // 0x2f
|
||
"xor Eb,Gb ", // 0x30
|
||
"xor Ev,Gv ", // 0x31
|
||
"xor Gb,Eb ", // 0x32
|
||
"xor Gv,Ev ", // 0x33
|
||
"xor AL,Ib ", // 0x34
|
||
"xor eAX,Iv ", // 0x35
|
||
"SS: ", // 0x36
|
||
"aaa ", // 0x37
|
||
"cmp Eb,Gb ", // 0x38
|
||
"cmp Ev,Gv ", // 0x39
|
||
"cmp Gb,Eb ", // 0x3a
|
||
"cmp Gv,Ev ", // 0x3b
|
||
"cmp AL,Ib ", // 0x3c
|
||
"cmp eAX,Iv ", // 0x3d
|
||
"DS: ", // 0x3e
|
||
"aas ", // 0x3f
|
||
"inc eAX ", // 0x40
|
||
"inc eCX ", // 0x41
|
||
"inc eDX ", // 0x42
|
||
"inc eBX ", // 0x43
|
||
"inc eSP ", // 0x44
|
||
"inc eBP ", // 0x45
|
||
"inc eSI ", // 0x46
|
||
"inc eDI ", // 0x47
|
||
"dec eAX ", // 0x48
|
||
"dec eCX ", // 0x49
|
||
"dec eDX ", // 0x4a
|
||
"dec eBX ", // 0x4b
|
||
"dec eSP ", // 0x4c
|
||
"dec eBP ", // 0x4d
|
||
"dec eSI ", // 0x4e
|
||
"dec eDI ", // 0x4f
|
||
"push eAX ", // 0x50
|
||
"push eCX ", // 0x51
|
||
"push eDX ", // 0x52
|
||
"push eBX ", // 0x53
|
||
"push eSP ", // 0x54
|
||
"push eBP ", // 0x55
|
||
"push eSI ", // 0x56
|
||
"push eDI ", // 0x57
|
||
"pop eAX ", // 0x58
|
||
"pop eCX ", // 0x59
|
||
"pop eDX ", // 0x5a
|
||
"pop eBX ", // 0x5b
|
||
"pop eSP ", // 0x5c
|
||
"pop eBP ", // 0x5d
|
||
"pop eSI ", // 0x5e
|
||
"pop eDI ", // 0x5f
|
||
"pusha ", // 0x60
|
||
"popa ", // 0x61
|
||
"bound Gv,Ma ", // 0x62
|
||
"arpl Ew,Rw ", // 0x63
|
||
"FS: ", // 0x64
|
||
"GS: ", // 0x65
|
||
"opsize: ", // 0x66
|
||
"opaddr: ", // 0x67
|
||
"push Iv ", // 0x68
|
||
"imul Gv,Ev,Iv ", // 0x69
|
||
"push Ib ", // 0x6a
|
||
"imul Gv,Ev,Ib ", // 0x6b
|
||
"insb ", // 0x6c
|
||
"insw/d ", // 0x6d
|
||
"outsb ", // 0x6e
|
||
"outsw/d ", // 0x6f
|
||
"jo Jb ", // 0x70
|
||
"jno Jb ", // 0x71
|
||
"jb Jb ", // 0x72
|
||
"jnb Jb ", // 0x73
|
||
"jz Jb ", // 0x74
|
||
"jnz Jb ", // 0x75
|
||
"jbe Jb ", // 0x76
|
||
"jnbe Jb ", // 0x77
|
||
"js Jb ", // 0x78
|
||
"jns Jb ", // 0x79
|
||
"jp Jb ", // 0x7a
|
||
"jnp Jb ", // 0x7b
|
||
"jl Jb ", // 0x7c
|
||
"jnl Jb ", // 0x7d
|
||
"jle Jb ", // 0x7e
|
||
"jnle Jb ", // 0x7f
|
||
"group1 Eb,Ib ", // 0x80
|
||
"group1 Ev,Ib ", // 0x81
|
||
"illegal ", // 0x82
|
||
"group1 Ev,Ib ", // 0x83
|
||
"test Eb,Gb ", // 0x84
|
||
"test Ev,Gv ", // 0x85
|
||
"xchg Eb,Gb ", // 0x86
|
||
"xchg Ev,Gv ", // 0x87
|
||
"mov Eb,Gb ", // 0x88
|
||
"mov Ev,Gv ", // 0x89
|
||
"mov Gb,Eb ", // 0x8a
|
||
"mov Gv,Ev ", // 0x8b
|
||
"mov Ew,Sw ", // 0x8c
|
||
"lea Gv,Ma ", // 0x8d
|
||
"mov Sw,Ew ", // 0x8e
|
||
"pop Ev ", // 0x8f
|
||
"nop ", // 0x90
|
||
"xchg eCX,eAX ", // 0x91
|
||
"xchg eDX,eAX ", // 0x92
|
||
"xchg eBX,eAX ", // 0x93
|
||
"xchg eSP,eAX ", // 0x94
|
||
"xchg eBP,eAX ", // 0x95
|
||
"xchg eSI,eAX ", // 0x96
|
||
"xchg eDI,eAX ", // 0x97
|
||
"cbw ", // 0x98
|
||
"cwd ", // 0x99
|
||
"call Ap ", // 0x9a
|
||
"wait ", // 0x9b
|
||
"pushf ", // 0x9c
|
||
"popf ", // 0x9d
|
||
"sahf ", // 0x9e
|
||
"lahf ", // 0x9f
|
||
"mov AL,Ob ", // 0xa0
|
||
"mov eAX,Ov ", // 0xa1
|
||
"mov Ob,AL ", // 0xa2
|
||
"mov Ov,eAX ", // 0xa3
|
||
"movsb ", // 0xa4
|
||
"movsw/d ", // 0xa5
|
||
"cmpsb ", // 0xa6
|
||
"cmpsw/d ", // 0xa7
|
||
"test AL,Ib ", // 0xa8
|
||
"test eAX,Iv ", // 0xa9
|
||
"stosb ", // 0xaa
|
||
"stosw/d ", // 0xab
|
||
"lodsb ", // 0xac
|
||
"lodsw/d ", // 0xad
|
||
"scasb ", // 0xae
|
||
"scasw/d ", // 0xaf
|
||
"mov AL,Ib ", // 0xb0
|
||
"mov Cl,Ib ", // 0xb1
|
||
"mov DL,Ib ", // 0xb2
|
||
"mov BL,Ib ", // 0xb3
|
||
"mov AH,Ib ", // 0xb4
|
||
"mov CH,Ib ", // 0xb5
|
||
"mov DH,Ib ", // 0xb6
|
||
"mov BH,Ib ", // 0xb7
|
||
"mov eAX,Iv ", // 0xb8
|
||
"mov eCX,Iv ", // 0xb9
|
||
"mov eDX,Iv ", // 0xba
|
||
"mov eBX,Iv ", // 0xbb
|
||
"mov eSP,Iv ", // 0xbc
|
||
"mov eBP,Iv ", // 0xbd
|
||
"mov eSI,Iv ", // 0xbe
|
||
"mov eDI,Iv ", // 0xbf
|
||
"group2 Eb,Ib ", // 0xc0
|
||
"group2 Ev,Ib ", // 0xc1
|
||
"ret Iw near ", // 0xc2
|
||
"ret near ", // 0xc3
|
||
"les Gv,Mp ", // 0xc4
|
||
"lds Gv,Mp ", // 0xc5
|
||
"mov Eb,Ib ", // 0xc6
|
||
"mov Ev,Iv ", // 0xc7
|
||
"enter Iw,Ib ", // 0xc8
|
||
"leave ", // 0xc9
|
||
"ret Iw far ", // 0xca
|
||
"ret far ", // 0xcb
|
||
"int 3 ", // 0xcc
|
||
"int Ib ", // 0xcd
|
||
"into ", // 0xce
|
||
"iret ", // 0xcf
|
||
"group2 Eb,1 ", // 0xd0
|
||
"group2 Ev,1 ", // 0xd1
|
||
"group2 Eb,CL ", // 0xd2
|
||
"group2 Ev,Cl ", // 0xd3
|
||
"aam ", // 0xd4
|
||
"aad ", // 0xd5
|
||
"illegal ", // 0xd6
|
||
"xlat ", // 0xd7
|
||
"illegal ", // 0xd8
|
||
"illegal ", // 0xd9
|
||
"illegal ", // 0xda
|
||
"illegal ", // 0xdb
|
||
"illegal ", // 0xdc
|
||
"illegal ", // 0xdd
|
||
"illegal ", // 0xde
|
||
"illegal ", // 0xdf
|
||
"loopnz ", // 0xe0
|
||
"loopz ", // 0xe1
|
||
"loop ", // 0xe2
|
||
"jcxz ", // 0xe3
|
||
"inb AL,Ib ", // 0xe4
|
||
"inw/d eAX,Ib ", // 0xe5
|
||
"outb Ib,AL ", // 0xe6
|
||
"outw/d Ib,eAX ", // 0xe7
|
||
"call Jv ", // 0xe8
|
||
"jmp Jv ", // 0xe9
|
||
"jmp Ap ", // 0xea
|
||
"jmp Jb ", // 0xeb
|
||
"inb AL,DX ", // 0xec
|
||
"inw/d Ib,DX ", // 0xed
|
||
"outb DX,AL ", // 0xee
|
||
"outw/d DX,eAX ", // 0xef
|
||
"lock: ", // 0xf0
|
||
"illegal ", // 0xf1
|
||
"repnz: ", // 0xf2
|
||
"repz: ", // 0xf3
|
||
"hlt ", // 0xf4
|
||
"cmc ", // 0xf5
|
||
"group3 Eb,? ", // 0xf6
|
||
"group3 Ev,? ", // 0xf7
|
||
"clc ", // 0xf8
|
||
"stc ", // 0xf9
|
||
"cli ", // 0xfa
|
||
"sti ", // 0xfb
|
||
"cld ", // 0xfc
|
||
"std ", // 0xfd
|
||
"group4 Eb ", // 0xfe
|
||
"group5 Ev " // 0xff
|
||
};
|
||
|
||
const PCHAR XmOpcodeNameTable2[] = {
|
||
"group6 ", // 0x00
|
||
"group7 ", // 0x01
|
||
"lar ", // 0x02
|
||
"lsl ", // 0x03
|
||
"illegal ", // 0x04
|
||
"illegal ", // 0x05
|
||
"clts ", // 0x06
|
||
"illegal ", // 0x07
|
||
"illegal ", // 0x08
|
||
"illegal ", // 0x09
|
||
"illegal ", // 0x0a
|
||
"illegal ", // 0x0b
|
||
"illegal ", // 0x0c
|
||
"illegal ", // 0x0d
|
||
"illegal ", // 0x0e
|
||
"illegal ", // 0x0f
|
||
"illegal ", // 0x10
|
||
"illegal ", // 0x11
|
||
"illegal ", // 0x12
|
||
"illegal ", // 0x13
|
||
"illegal ", // 0x14
|
||
"illegal ", // 0x15
|
||
"illegal ", // 0x16
|
||
"illegal ", // 0x17
|
||
"illegal ", // 0x18
|
||
"illegal ", // 0x19
|
||
"illegal ", // 0x1a
|
||
"illegal ", // 0x1b
|
||
"illegal ", // 0x1c
|
||
"illegal ", // 0x1d
|
||
"illegal ", // 0x1e
|
||
"illegal ", // 0x1f
|
||
"mov Cd,Rd ", // 0x20
|
||
"mov Dd,Rd ", // 0x21
|
||
"mov Rd,Cd ", // 0x22
|
||
"mov Rd,Dd ", // 0x23
|
||
"mov Td,Rd ", // 0x24
|
||
"illegal ", // 0x25
|
||
"mov Rd,Td ", // 0x26
|
||
"illegal ", // 0x27
|
||
"illegal ", // 0x28
|
||
"illegal ", // 0x29
|
||
"illegal ", // 0x2a
|
||
"illegal ", // 0x2b
|
||
"illegal ", // 0x2c
|
||
"illegal ", // 0x2d
|
||
"illegal ", // 0x2e
|
||
"illegal ", // 0x2f
|
||
"illegal ", // 0x30
|
||
"illegal ", // 0x31
|
||
"illegal ", // 0x32
|
||
"illegal ", // 0x33
|
||
"illegal ", // 0x34
|
||
"illegal ", // 0x35
|
||
"illegal ", // 0x36
|
||
"illegal ", // 0x37
|
||
"illegal ", // 0x38
|
||
"illegal ", // 0x39
|
||
"illegal ", // 0x3a
|
||
"illegal ", // 0x3b
|
||
"illegal ", // 0x3c
|
||
"illegal ", // 0x3d
|
||
"illegal ", // 0x3e
|
||
"illegal ", // 0x3f
|
||
"illegal ", // 0x40
|
||
"illegal ", // 0x41
|
||
"illegal ", // 0x42
|
||
"illegal ", // 0x43
|
||
"illegal ", // 0x44
|
||
"illegal ", // 0x45
|
||
"illegal ", // 0x46
|
||
"illegal ", // 0x47
|
||
"illegal ", // 0x48
|
||
"illegal ", // 0x49
|
||
"illegal ", // 0x4a
|
||
"illegal ", // 0x4b
|
||
"illegal ", // 0x4c
|
||
"illegal ", // 0x4d
|
||
"illegal ", // 0x4e
|
||
"illegal ", // 0x4f
|
||
"illegal ", // 0x50
|
||
"illegal ", // 0x51
|
||
"illegal ", // 0x52
|
||
"illegal ", // 0x53
|
||
"illegal ", // 0x54
|
||
"illegal ", // 0x55
|
||
"illegal ", // 0x56
|
||
"illegal ", // 0x57
|
||
"illegal ", // 0x58
|
||
"illegal ", // 0x59
|
||
"illegal ", // 0x5a
|
||
"illegal ", // 0x5b
|
||
"illegal ", // 0x5c
|
||
"illegal ", // 0x5d
|
||
"illegal ", // 0x5e
|
||
"illegal ", // 0x5f
|
||
"illegal ", // 0x60
|
||
"illegal ", // 0x61
|
||
"illegal ", // 0x62
|
||
"illegal ", // 0x63
|
||
"illegal ", // 0x64
|
||
"illegal ", // 0x65
|
||
"illegal ", // 0x66
|
||
"illegal ", // 0x67
|
||
"illegal ", // 0x68
|
||
"illegal ", // 0x69
|
||
"illegal ", // 0x6a
|
||
"illegal ", // 0x6b
|
||
"illegal ", // 0x6c
|
||
"illegal ", // 0x6d
|
||
"illegal ", // 0x6e
|
||
"illegal ", // 0x6f
|
||
"illegal ", // 0x70
|
||
"illegal ", // 0x71
|
||
"illegal ", // 0x72
|
||
"illegal ", // 0x73
|
||
"illegal ", // 0x74
|
||
"illegal ", // 0x75
|
||
"illegal ", // 0x76
|
||
"illegal ", // 0x77
|
||
"illegal ", // 0x78
|
||
"illegal ", // 0x79
|
||
"illegal ", // 0x7a
|
||
"illegal ", // 0x7b
|
||
"illegal ", // 0x7c
|
||
"illegal ", // 0x7d
|
||
"illegal ", // 0x7e
|
||
"illegal ", // 0x7f
|
||
"jo Jv ", // 0x80
|
||
"jno Jv ", // 0x81
|
||
"jb Jv ", // 0x82
|
||
"jnb Jv ", // 0x83
|
||
"jz Jv ", // 0x84
|
||
"jnz Jv ", // 0x85
|
||
"jbe Jv ", // 0x86
|
||
"jnbe Jv ", // 0x87
|
||
"js Jv ", // 0x88
|
||
"jns Jv ", // 0x89
|
||
"jp Jv ", // 0x8a
|
||
"jnp Jv ", // 0x8b
|
||
"jl Jv ", // 0x8c
|
||
"jnl Jv ", // 0x8d
|
||
"jle Jv ", // 0x8e
|
||
"jnle Jv ", // 0x8f
|
||
"seto ", // 0x90
|
||
"setno ", // 0x91
|
||
"setb ", // 0x92
|
||
"setnb ", // 0x93
|
||
"setz ", // 0x94
|
||
"setnz ", // 0x95
|
||
"setbe ", // 0x96
|
||
"setnbe ", // 0x97
|
||
"sets ", // 0x98
|
||
"setns ", // 0x99
|
||
"setp ", // 0x9a
|
||
"setnp ", // 0x9b
|
||
"setl ", // 0x9c
|
||
"setnl ", // 0x9d
|
||
"setle ", // 0x9e
|
||
"setnle ", // 0x9f
|
||
"push FS ", // 0xa0
|
||
"pop FS ", // 0xa1
|
||
"illegal ", // 0xa2
|
||
"bt Ev,Gv ", // 0xa3
|
||
"shld Ev,Gv,Ib ", // 0xa4
|
||
"Shld Ev,Gv,vl ", // 0xa5
|
||
"illegal ", // 0xa6
|
||
"illegal ", // 0xa7
|
||
"push GS ", // 0xa8
|
||
"pop GS ", // 0xa9
|
||
"illegal ", // 0xaa
|
||
"bts Ev,Gv ", // 0xab
|
||
"shrd Ev,Gv,Ib ", // 0xac
|
||
"shrd Ev,Gv,cl ", // 0xad
|
||
"illegal ", // 0xae
|
||
"imul Gv,Ev ", // 0xaf
|
||
"cmpxchg Eb,Gv ", // 0xb0
|
||
"cmpxchg Ev,Gv ", // 0xb1
|
||
"lss Gv,Mp ", // 0xb2
|
||
"btr Ev,Gv ", // 0xb3
|
||
"lfs Gv,Mp ", // 0xb4
|
||
"lgs Gv,Mp ", // 0xb5
|
||
"movzb Gv,Eb ", // 0xb6
|
||
"movzw Gv,Ew ", // 0xb7
|
||
"illegal ", // 0xb8
|
||
"illegal ", // 0xb9
|
||
"group8 Ev,Ib ", // 0xba
|
||
"btc Ev,Gv ", // 0xbb
|
||
"bsf Gv,Ev ", // 0xbc
|
||
"bsr Gv,Ev ", // 0xbd
|
||
"movsb Gv,Eb ", // 0xbe
|
||
"movsw Gv,Ew ", // 0xbf
|
||
"xadd Eb,Gb ", // 0xc0
|
||
"xadd Ev,Gv ", // 0xc1
|
||
"illegal ", // 0xc2
|
||
"illegal ", // 0xc3
|
||
"illegal ", // 0xc4
|
||
"illegal ", // 0xc5
|
||
"illegal ", // 0xc6
|
||
"illegal ", // 0xc7
|
||
"bswap Gv ", // 0xc8
|
||
"illegal ", // 0xc9
|
||
"illegal ", // 0xca
|
||
"illegal ", // 0xcb
|
||
"illegal ", // 0xcc
|
||
"illegal ", // 0xcd
|
||
"illegal ", // 0xce
|
||
"illegal ", // 0xcf
|
||
"illegal ", // 0xd0
|
||
"illegal ", // 0xd1
|
||
"illegal ", // 0xd2
|
||
"illegal ", // 0xd3
|
||
"illegal ", // 0xd4
|
||
"illegal ", // 0xd5
|
||
"illegal ", // 0xd6
|
||
"illegal ", // 0xd7
|
||
"illegal ", // 0xd8
|
||
"illegal ", // 0xd9
|
||
"illegal ", // 0xda
|
||
"illegal ", // 0xdb
|
||
"illegal ", // 0xdc
|
||
"illegal ", // 0xdd
|
||
"illegal ", // 0xde
|
||
"illegal ", // 0xdf
|
||
"illegal ", // 0xe0
|
||
"illegal ", // 0xe1
|
||
"illegal ", // 0xe2
|
||
"illegal ", // 0xe3
|
||
"illegal ", // 0xe4
|
||
"illegal ", // 0xe5
|
||
"illegal ", // 0xe6
|
||
"illegal ", // 0xe7
|
||
"illegal ", // 0xe8
|
||
"illegal ", // 0xe9
|
||
"illegal ", // 0xea
|
||
"illegal ", // 0xeb
|
||
"illegal ", // 0xec
|
||
"illegal ", // 0xed
|
||
"illegal ", // 0xee
|
||
"illegal ", // 0xef
|
||
"illegal ", // 0xf0
|
||
"illegal ", // 0xf1
|
||
"illegal ", // 0xf2
|
||
"illegal ", // 0xf3
|
||
"illegal ", // 0xf4
|
||
"illegal ", // 0xf5
|
||
"illegal ", // 0xf6
|
||
"illegal ", // 0xf7
|
||
"illegal ", // 0xf8
|
||
"illegal ", // 0xf9
|
||
"illegal ", // 0xfa
|
||
"illegal ", // 0xfb
|
||
"illegal ", // 0xfc
|
||
"illegal ", // 0xfd
|
||
"illegal ", // 0xfe
|
||
"illegal " // 0xff
|
||
};
|
||
|
||
ULONG XmDebugFlags = 0x00; //0x7f;
|
||
|
||
#endif
|