You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1375 lines
52 KiB
1375 lines
52 KiB
/*++
|
|
|
|
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
|