mirror of https://github.com/lianthony/NT4.0
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.
1660 lines
58 KiB
1660 lines
58 KiB
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include "asm.h"
|
|
|
|
//
|
|
|
|
|
|
LPBYTE SearchOpcode(LPBYTE);
|
|
|
|
// type and size table is ordered on enum of operand types
|
|
|
|
OPNDTYPE mapOpndType[] = {
|
|
{ typAX, sizeB }, // opnAL - AL register - byte
|
|
{ typAX, sizeW }, // opnAX - AX register - word
|
|
{ typAX, sizeV }, // opneAX - eAX register - (d)word
|
|
{ typCL, sizeB }, // opnCL - CX register - byte
|
|
{ typDX, sizeW }, // opnDX - DX register - word (DX)
|
|
{ typAbs, sizeV }, // opnAp - absolute pointer (16:16/32)
|
|
{ typExp, sizeB }, // opnEb - expression (mem/reg) - byte
|
|
{ typExp, sizeW }, // opnEw - expression (mem/reg) - word
|
|
{ typExp, sizeV }, // opnEv - expression (mem/reg) - (d)word
|
|
{ typGen, sizeB }, // opnGb - general register - byte
|
|
{ typGen, sizeW }, // opnGw - general register - word
|
|
{ typGen, sizeV }, // opnGv - general register - (d)word
|
|
{ typGen, sizeD }, // opnGd - general register - dword
|
|
{ typIm1, sizeB }, // opnIm1 - immediate - value 1
|
|
{ typIm3, sizeB }, // opnIm3 - immediate - value 3
|
|
{ typImm, sizeB }, // opnIb - immediate - byte
|
|
{ typImm, sizeW }, // opnIw - immediate - word
|
|
{ typImm, sizeV }, // opnIv - immediate - (d)word
|
|
{ typJmp, sizeB }, // opnJb - relative jump - byte
|
|
{ typJmp, sizeV }, // opnJv - relative jump - (d)word
|
|
{ typMem, sizeX }, // opnM - memory pointer - nosize
|
|
{ typMem, sizeA }, // opnMa - memory pointer - (16:16, 32:32)
|
|
{ typMem, sizeB }, // opnMb - memory pointer - byte
|
|
{ typMem, sizeW }, // opnMw - memory pointer - word
|
|
{ typMem, sizeD }, // opnMd - memory pointer - dword
|
|
{ typMem, sizeP }, // opnMp - memory pointer - (d)(f)word
|
|
{ typMem, sizeS }, // opnMs - memory pointer - sword
|
|
{ typMem, sizeQ }, // opnMq - memory pointer - qword
|
|
{ typMem, sizeT }, // opnMt - memory pointer - ten-byte
|
|
{ typMem, sizeV }, // opnMv - memory pointer - (d)word
|
|
{ typCtl, sizeD }, // opnCd - control register - dword
|
|
{ typDbg, sizeD }, // opnDd - debug register - dword
|
|
{ typTrc, sizeD }, // opnTd - trace register - dword
|
|
{ typReg, sizeD }, // opnRd - general register - dword
|
|
{ typSt, sizeT }, // opnSt - floating point top-of-stack
|
|
{ typSti, sizeT }, // opnSti - floating point index-on-stack
|
|
{ typSeg, sizeW }, // opnSeg - segment register - PUSH / POP
|
|
{ typSgr, sizeW }, // opnSw - segment register - MOV
|
|
{ typXsi, sizeB }, // opnXb - string source - byte
|
|
{ typXsi, sizeV }, // opnXv - string source - (d)word
|
|
{ typYdi, sizeB }, // opnYb - string destination - byte
|
|
{ typYdi, sizeV }, // opnYv - string destination - (d)word
|
|
{ typOff, sizeB }, // opnOb - memory offset - byte
|
|
{ typOff, sizeV } // opnOv - memory offset - (d)word
|
|
};
|
|
|
|
BYTE szAAA[] = {
|
|
'a', 'a', 'a', '\0',
|
|
0x37, asNone + tEnd + eEnd };
|
|
|
|
BYTE szAAD[] = {
|
|
'a', 'a', 'd', '\0',
|
|
0xd5, as0x0a + tEnd + eEnd };
|
|
|
|
BYTE szAAM[] = {
|
|
'a', 'a', 'm', '\0',
|
|
0xd4, as0x0a + tEnd + eEnd };
|
|
|
|
BYTE szAAS[] = {
|
|
'a', 'a', 's', '\0',
|
|
0x3f, asNone + tEnd + eEnd };
|
|
|
|
BYTE szADC[] = {
|
|
'a', 'd', 'c', '\0',
|
|
0x14, opnAL, opnIb + tEnd,
|
|
0x15, opneAX, opnIv + tEnd,
|
|
0x80, asReg2, opnEb, opnIb + tEnd,
|
|
0x83, asReg2, opnEv, opnIb + tEnd,
|
|
0x81, asReg2, opnEv, opnIv + tEnd,
|
|
0x10, opnEb, opnGb + tEnd,
|
|
0x11, opnEv, opnGv + tEnd,
|
|
0x12, opnGb, opnEb + tEnd,
|
|
0x13, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szADD[] = {
|
|
'a', 'd', 'd', '\0',
|
|
0x04, opnAL, opnIb + tEnd,
|
|
0x05, opneAX, opnIv + tEnd,
|
|
0x80, asReg0, opnEb, opnIb + tEnd,
|
|
0x83, asReg0, opnEv, opnIb + tEnd,
|
|
0x81, asReg0, opnEv, opnIv + tEnd,
|
|
0x00, opnEb, opnGb + tEnd,
|
|
0x01, opnEv, opnGv + tEnd,
|
|
0x02, opnGb, opnEb + tEnd,
|
|
0x03, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szAND[] = {
|
|
'a', 'n', 'd', '\0',
|
|
0x24, opnAL, opnIb + tEnd,
|
|
0x25, opneAX, opnIv + tEnd,
|
|
0x80, asReg4, opnEb, opnIb + tEnd,
|
|
0x83, asReg4, opnEv, opnIb + tEnd,
|
|
0x81, asReg4, opnEv, opnIv + tEnd,
|
|
0x20, opnEb, opnGb + tEnd,
|
|
0x21, opnEv, opnGv + tEnd,
|
|
0x22, opnGb, opnEb + tEnd,
|
|
0x23, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szARPL[] = {
|
|
'a', 'r', 'p', 'l', '\0',
|
|
0x63, opnEw, opnGw + tEnd + eEnd };
|
|
|
|
BYTE szBOUND[] = {
|
|
'b', 'o', 'u', 'n', 'd', '\0',
|
|
0x62, opnGv, opnMa + tEnd + eEnd };
|
|
|
|
BYTE szBSF[] = {
|
|
'b', 's', 'f', '\0',
|
|
0x0f, 0xbc, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szBSR[] = {
|
|
'b', 's', 'r', '\0',
|
|
0x0f, 0xbd, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szBSWAP[] = {
|
|
'b', 's', 'w', 'a', 'p', '\0',
|
|
0x0f, 0xc8, asOpRg, opnGd + tEnd + eEnd };
|
|
|
|
BYTE szBT[] = {
|
|
'b', 't', '\0',
|
|
0x0f, 0xa3, opnEv, opnGv + tEnd,
|
|
0x0f, 0xba, asReg4, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szBTC[] = {
|
|
'b', 't', 'c', '\0',
|
|
0x0f, 0xbb, opnEv, opnGv + tEnd,
|
|
0x0f, 0xba, asReg7, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szBTR[] = {
|
|
'b', 't', 'r', '\0',
|
|
0x0f, 0xb3, opnEv, opnGv + tEnd,
|
|
0x0f, 0xba, asReg6, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szBTS[] = {
|
|
'b', 't', 's', '\0',
|
|
0x0f, 0xab, opnEv, opnGv + tEnd,
|
|
0x0f, 0xba, asReg5, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szCALL[] = {
|
|
'c', 'a', 'l', 'l', '\0',
|
|
0xe8, opnJv + tEnd,
|
|
0xff, asReg2, asMpNx, opnEv + tEnd,
|
|
0xff, asReg3, opnMp + tEnd,
|
|
0x9a, opnAp + tEnd + eEnd };
|
|
|
|
BYTE szCBW[] = {
|
|
'c', 'b', 'w', '\0',
|
|
0x98, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szCDQ[] = {
|
|
'c', 'd', 'q', '\0',
|
|
0x99, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szCLC[] = {
|
|
'c', 'l', 'c', '\0',
|
|
0xf8, asNone + tEnd + eEnd };
|
|
|
|
BYTE szCLD[] = {
|
|
'c', 'l', 'd', '\0',
|
|
0xfc, asNone + tEnd + eEnd };
|
|
|
|
BYTE szCLI[] = {
|
|
'c', 'l', 'i', '\0',
|
|
0xfa, asNone + tEnd + eEnd };
|
|
|
|
BYTE szCLTS[] = {
|
|
'c', 'l', 't', 's', '\0',
|
|
0x0f, 0x06, asNone + tEnd + eEnd };
|
|
|
|
BYTE szCMC[] = {
|
|
'c', 'm', 'c', '\0',
|
|
0xf5, asNone + tEnd + eEnd };
|
|
|
|
BYTE szCMP[] = {
|
|
'c', 'm', 'p', '\0',
|
|
0x3c, opnAL, opnIb + tEnd,
|
|
0x3d, opneAX, opnIv + tEnd,
|
|
0x80, asReg7, opnEb, opnIb + tEnd,
|
|
0x83, asReg7, opnEv, opnIb + tEnd,
|
|
0x81, asReg7, opnEv, opnIv + tEnd,
|
|
0x38, opnEb, opnGb + tEnd,
|
|
0x39, opnEv, opnGv + tEnd,
|
|
0x3a, opnGb, opnEb + tEnd,
|
|
0x3b, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szCMPS[] = {
|
|
'c', 'm', 'p', 's', '\0',
|
|
0xa6, opnXb, opnYb + tEnd,
|
|
0xa7, opnXv, opnYv + tEnd + eEnd };
|
|
|
|
BYTE szCMPSB[] = {
|
|
'c', 'm', 'p', 's', 'b', '\0',
|
|
0xa6, asNone + tEnd + eEnd };
|
|
|
|
BYTE szCMPSD[] = {
|
|
'c', 'm', 'p', 's', 'd', '\0',
|
|
0xa7, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szCMPSW[] = {
|
|
'c', 'm', 'p', 's', 'w', '\0',
|
|
0xa7, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szCMPXCHG[] = {
|
|
'c', 'm', 'p', 'x', 'c', 'h', 'g', '\0',
|
|
0x0f, 0xa6, opnEb, opnGb + tEnd,
|
|
0x0f, 0xa7, opnEv, opnGv + tEnd + eEnd };
|
|
|
|
BYTE szCS_A[] = {
|
|
'c', 's', ':', '\0',
|
|
0x2e, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szCWD[] = {
|
|
'c', 'w', 'd', '\0',
|
|
0x99, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szCWDE[] = {
|
|
'c', 'w', 'd', 'e', '\0',
|
|
0x98, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szDAA[] = {
|
|
'd', 'a', 'a', '\0',
|
|
0x27, asNone + tEnd + eEnd };
|
|
|
|
BYTE szDAS[] = {
|
|
'd', 'a', 's', '\0',
|
|
0x2f, asNone + tEnd + eEnd };
|
|
|
|
BYTE szDEC[] = {
|
|
'd', 'e', 'c', '\0',
|
|
0x48, asOpRg, opnGv + tEnd,
|
|
0xfe, asReg1, opnEb + tEnd,
|
|
0xff, asReg1, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szDIV[] = {
|
|
'd', 'i', 'v', '\0',
|
|
0xf6, asReg6, opnEb + tEnd,
|
|
0xf7, asReg6, opnEv + tEnd,
|
|
0xf6, asReg6, opnAL, opnEb + tEnd,
|
|
0xf7, asReg6, opneAX, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szDS_A[] = {
|
|
'd', 's', ':', '\0',
|
|
0x3e, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szENTER[] = {
|
|
'e', 'n', 't', 'e', 'r', '\0',
|
|
0xc8, opnIw, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szES_A[] = {
|
|
'e', 's', ':', '\0',
|
|
0x36, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szF2XM1[] = {
|
|
'f', '2', 'x', 'm', '1', '\0',
|
|
0xd8, 0xf0, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFABS[] = {
|
|
'f', 'a', 'b', 's', '\0',
|
|
0xd9, 0xe1, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFADD[] = {
|
|
'f', 'a', 'd', 'd', '\0',
|
|
0xd8, asReg0, opnMd, asFSiz + tEnd,
|
|
0xdc, asReg0, opnMq + tEnd,
|
|
0xd8, 0xc0, opnSt, opnSti + tEnd,
|
|
0xdc, 0xc0, opnSti, opnSt + tEnd,
|
|
0xdc, 0xc1, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFADDP[] = {
|
|
'f', 'a', 'd', 'd', 'p', '\0',
|
|
0xde, 0xc0, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFBLD[] = {
|
|
'f', 'b', 'l', 'd', '\0',
|
|
0xdf, asReg4, opnMt + tEnd + eEnd };
|
|
|
|
BYTE szFBSTP[] = {
|
|
'f', 'b', 's', 't', 'p', '\0',
|
|
0xdf, asReg6, opnMt + tEnd + eEnd };
|
|
|
|
BYTE szFCHS[] = {
|
|
'f', 'c', 'h', 's', '\0',
|
|
0xd9, 0xe0, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFCLEX[] = {
|
|
'f', 'c', 'l', 'e', 'x', '\0',
|
|
0xdb, 0xe2, asWait + tEnd + eEnd };
|
|
|
|
BYTE szFCOM[] = {
|
|
'f', 'c', 'o', 'm', '\0',
|
|
0xd8, 0xd1, asNone + tEnd,
|
|
0xd8, 0xd0, opnSti + tEnd,
|
|
0xd8, asReg2, opnMd, asFSiz + tEnd,
|
|
0xdc, asReg2, opnMq + tEnd + eEnd };
|
|
|
|
BYTE szFCOMP[] = {
|
|
'f', 'c', 'o', 'm', 'p', '\0',
|
|
0xd8, 0xd9, asNone + tEnd,
|
|
0xd8, 0xd8, opnSti + tEnd,
|
|
0xd8, asReg3, opnMd, asFSiz + tEnd,
|
|
0xdc, asReg3, opnMq + tEnd + eEnd };
|
|
|
|
BYTE szFCOMPP[] = {
|
|
'f', 'c', 'o', 'm', 'p', 'p', '\0',
|
|
0xde, 0xd9, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFCOS[] = {
|
|
'f', 'c', 'o', 's', '\0',
|
|
0xd9, 0xff, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFDECSTP[] = {
|
|
'f', 'd', 'e', 'c', 's', 't', 'p', '\0',
|
|
0xd9, 0xf6, asWait + tEnd + eEnd };
|
|
|
|
BYTE szFDISI[] = {
|
|
'f', 'd', 'i', 's', 'i', '\0',
|
|
0xdb, 0xe1, asWait + tEnd + eEnd };
|
|
|
|
BYTE szFDIV[] = {
|
|
'f', 'd', 'i', 'v', '\0',
|
|
0xdc, 0xf9, asNone + tEnd,
|
|
0xd8, asReg6, opnMd, asFSiz + tEnd,
|
|
0xdc, asReg6, opnMq + tEnd,
|
|
0xd8, 0xf0, opnSt, opnSti + tEnd,
|
|
0xdc, 0xf8, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFDIVP[] = {
|
|
'f', 'd', 'i', 'v', 'p', '\0',
|
|
0xde, 0xf8, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFDIVR[] = {
|
|
'f', 'd', 'i', 'v', 'r', '\0',
|
|
0xde, 0xf1, asNone + tEnd,
|
|
0xd8, asReg7, opnMd, asFSiz + tEnd,
|
|
0xdc, asReg7, opnMq + tEnd,
|
|
0xd8, 0xf8, opnSt, opnSti + tEnd,
|
|
0xdc, 0xf0, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFDIVRP[] = {
|
|
'f', 'd', 'i', 'v', 'r', 'p', '\0',
|
|
0xde, 0xf0, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFENI[] = {
|
|
'f', 'e', 'n', 'i', '\0',
|
|
0xdb, 0xe0, asWait + tEnd + eEnd };
|
|
|
|
BYTE szFFREE[] = {
|
|
'f', 'f', 'r', 'e', 'e', '\0',
|
|
0xdd, 0xc0, asWait, opnSti + tEnd + eEnd };
|
|
|
|
BYTE szFIADD[] = {
|
|
'f', 'i', 'a', 'd', 'd', '\0',
|
|
0xde, asReg0, opnMw, asFSiz + tEnd,
|
|
0xda, asReg0, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFICOM[] = {
|
|
'f', 'i', 'c', 'o', 'm', '\0',
|
|
0xde, asReg2, opnMw, asFSiz + tEnd,
|
|
0xda, asReg2, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFICOMP[] = {
|
|
'f', 'i', 'c', 'o', 'm', 'p', '\0',
|
|
0xde, asReg3, opnMw, asFSiz + tEnd,
|
|
0xda, asReg3, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFIDIV[] = {
|
|
'f', 'i', 'd', 'i', 'v', '\0',
|
|
0xde, asReg6, opnMw, asFSiz + tEnd,
|
|
0xda, asReg6, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFIDIVR[] = {
|
|
'f', 'i', 'd', 'i', 'v', 'r', '\0',
|
|
0xde, asReg7, opnMw, asFSiz + tEnd,
|
|
0xda, asReg7, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFILD[] = {
|
|
'f', 'i', 'l', 'd', '\0',
|
|
0xdf, asReg0, opnMw, asFSiz + tEnd,
|
|
0xdb, asReg0, opnMd + tEnd,
|
|
0xdf, asReg5, opnMq + tEnd + eEnd };
|
|
|
|
BYTE szFIMUL[] = {
|
|
'f', 'i', 'm', 'u', 'l', '\0',
|
|
0xde, asReg1, opnMw, asFSiz + tEnd,
|
|
0xda, asReg1, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFINCSTP[] = {
|
|
'f', 'i', 'n', 'c', 's', 't', 'p', '\0',
|
|
0xd9, 0xf7, asWait + tEnd + eEnd };
|
|
|
|
BYTE szFINIT[] = {
|
|
'f', 'i', 'n', 'i', 't', '\0',
|
|
0xdb, 0xe3, asWait + tEnd + eEnd };
|
|
|
|
BYTE szFIST[] = {
|
|
'f', 'i', 's', 't', '\0',
|
|
0xdf, asReg2, opnMw, asFSiz + tEnd,
|
|
0xdb, asReg2, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFISTP[] = {
|
|
'f', 'i', 's', 't', 'p', '\0',
|
|
0xdf, asReg3, opnMw, asFSiz + tEnd,
|
|
0xdb, asReg3, opnMd + tEnd,
|
|
0xdf, asReg7, opnMq + tEnd + eEnd };
|
|
|
|
BYTE szFISUB[] = {
|
|
'f', 'i', 's', 'u', 'b', '\0',
|
|
0xde, asReg4, opnMw, asFSiz + tEnd,
|
|
0xda, asReg4, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFISUBR[] = {
|
|
'f', 'i', 's', 'u', 'b', 'r', '\0',
|
|
0xde, asReg5, opnMw, asFSiz + tEnd,
|
|
0xda, asReg5, opnMd + tEnd + eEnd };
|
|
|
|
BYTE szFLD[] = {
|
|
'f', 'l', 'd', '\0',
|
|
0xd9, asReg0, opnMd, asFSiz + tEnd,
|
|
0xdd, asReg0, opnMq + tEnd,
|
|
0xdb, asReg5, opnMt + tEnd,
|
|
0xd9, 0xc0, opnSti + tEnd + eEnd };
|
|
|
|
BYTE szFLD1[] = {
|
|
'f', 'l', 'd', '1', '\0',
|
|
0xd9, 0xe8, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFLDCW[] = {
|
|
'f', 'l', 'd', 'c', 'w', '\0',
|
|
0xd9, asWait, asReg5, opnMw + tEnd + eEnd };
|
|
|
|
BYTE szFLDENV[] = {
|
|
'f', 'l', 'd', 'e', 'n', 'v', '\0',
|
|
0xd9, asWait, asReg4, opnMw + tEnd + eEnd };
|
|
|
|
BYTE szFLDL2E[] = {
|
|
'f', 'l', 'd', 'l', '2', 'e', '\0',
|
|
0xd9, 0xea, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFLDL2T[] = {
|
|
'f', 'l', 'd', 'l', '2', 't', '\0',
|
|
0xd9, 0xe9, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFLDLG2[] = {
|
|
'f', 'l', 'd', 'l', 'g', '2', '\0',
|
|
0xd9, 0xec, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFLDLN2[] = {
|
|
'f', 'l', 'd', 'l', 'n', '2', '\0',
|
|
0xd9, 0xed, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFLDPI[] = {
|
|
'f', 'l', 'd', 'p', 'i', '\0',
|
|
0xd9, 0xeb, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFLDZ[] = {
|
|
'f', 'l', 'd', 'z', '\0',
|
|
0xd9, 0xee, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFMUL[] = {
|
|
'f', 'm', 'u', 'l', '\0',
|
|
0xde, 0xc9, asNone + tEnd,
|
|
0xd8, asReg1, opnMd, asFSiz + tEnd,
|
|
0xdc, asReg1, opnMq + tEnd,
|
|
0xd8, 0xc8, opnSt, opnSti + tEnd,
|
|
0xdc, 0xc8, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFMULP[] = {
|
|
'f', 'm', 'u', 'l', 'p', '\0',
|
|
0xde, 0xc8, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFNCLEX[] = {
|
|
'f', 'n', 'c', 'l', 'e', 'x', '\0',
|
|
0xdb, 0xe2, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFNDISI[] = {
|
|
'f', 'n', 'd', 'i', 's', 'i', '\0',
|
|
0xdb, 0xe1, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFNENI[] = {
|
|
'f', 'n', 'e', 'n', 'i', '\0',
|
|
0xdb, 0xe0, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFNINIT[] = {
|
|
'f', 'n', 'i', 'n', 'i', 't', '\0',
|
|
0xdb, 0xe3, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFNOP[] = {
|
|
'f', 'n', 'o', 'p', '\0',
|
|
0xd9, 0xd0, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFNSAVE[] = {
|
|
'f', 'n', 's', 'a', 'v', 'e', '\0',
|
|
0xdd, asReg6, opnM + tEnd + eEnd };
|
|
|
|
BYTE szFNSTCW[] = {
|
|
'f', 'n', 's', 't', 'c', 'w', '\0',
|
|
0xd9, asReg7, opnMw + tEnd + eEnd };
|
|
|
|
BYTE szFNSTENV[] = {
|
|
'f', 'n', 's', 't', 'e', 'n', 'v', '\0',
|
|
0xd9, asReg6, opnM + tEnd + eEnd };
|
|
|
|
BYTE szFNSTSW[] = {
|
|
'f', 'n', 's', 't', 's', 'w', '\0',
|
|
0xdf, 0xe0, asNone + tEnd,
|
|
0xdf, 0xe0, opnAX + tEnd,
|
|
0xdf, asReg7, opnMw + tEnd + eEnd };
|
|
|
|
BYTE szFPATAN[] = {
|
|
'f', 'p', 'a', 't', 'a', 'n', '\0',
|
|
0xd9, 0xf3, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFPREM[] = {
|
|
'f', 'p', 'r', 'e', 'm', '\0',
|
|
0xd9, 0xf8, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFPREM1[] = {
|
|
'f', 'p', 'r', 'e', 'm', '1', '\0',
|
|
0xd9, 0xf5, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFPTAN[] = {
|
|
'f', 'p', 't', 'a', 'n', '\0',
|
|
0xd9, 0xf2, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFRNDINT[] = {
|
|
'f', 'r', 'n', 'd', 'i', 'n', 't', '\0',
|
|
0xd9, 0xfc, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFRSTOR[] = {
|
|
'f', 'r', 's', 't', 'o', 'r', '\0',
|
|
0xdd, asWait, asReg4, opnM + tEnd + eEnd };
|
|
|
|
BYTE szFS_A[] = {
|
|
'f', 's', ':', '\0',
|
|
0x64, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szFSAVE[] = {
|
|
'f', 's', 'a', 'v', 'e', '\0',
|
|
0xdd, asWait, asReg6, opnM + tEnd + eEnd };
|
|
|
|
BYTE szFSCALE[] = {
|
|
'f', 's', 'c', 'a', 'l', 'e', '\0',
|
|
0xd9, 0xfd, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFSETPM[] = {
|
|
'f', 's', 'e', 't', 'p', 'm', '\0',
|
|
0xdb, 0xe4, asWait + tEnd + eEnd };
|
|
|
|
BYTE szFSIN[] = {
|
|
'f', 's', 'i', 'n', '\0',
|
|
0xd9, 0xfe, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFSINCOS[] = {
|
|
'f', 's', 'i', 'n', 'c', 'o', 's', '\0',
|
|
0xd9, 0xfb, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFSQRT[] = {
|
|
'f', 's', 'q', 'r', 't', '\0',
|
|
0xd9, 0xfa, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFST[] = {
|
|
'f', 's', 't', '\0',
|
|
0xd9, asReg2, opnMd, asFSiz + tEnd,
|
|
0xdd, asReg2, opnMq + tEnd,
|
|
0xdd, 0xd0, opnSti + tEnd + eEnd };
|
|
|
|
BYTE szFSTCW[] = {
|
|
'f', 's', 't', 'c', 'w', '\0',
|
|
0xd9, asWait, asReg7, opnMw + tEnd + eEnd };
|
|
|
|
BYTE szFSTENV[] = {
|
|
'f', 's', 't', 'e', 'n', 'v', '\0',
|
|
0xd9, asWait, asReg6, opnM + tEnd + eEnd };
|
|
|
|
BYTE szFSTP[] = {
|
|
'f', 's', 't', 'p', '\0',
|
|
0xd9, asReg3, opnMd, asFSiz + tEnd,
|
|
0xdd, asReg3, opnMq + tEnd,
|
|
0xdb, asReg7, opnMt + tEnd,
|
|
0xdd, 0xd8, opnSti + tEnd + eEnd };
|
|
|
|
BYTE szFSTSW[] = {
|
|
'f', 's', 't', 's', 'w', '\0',
|
|
0xdf, 0xe0, asWait + tEnd,
|
|
0xdf, 0xe0, asWait, opnAX + tEnd,
|
|
0xdd, asWait, asReg7, opnMw + tEnd + eEnd };
|
|
|
|
BYTE szFSUB[] = {
|
|
'f', 's', 'u', 'b', '\0',
|
|
0xde, 0xe9, asNone + tEnd,
|
|
0xd8, asReg4, opnMd, asFSiz + tEnd,
|
|
0xdc, asReg4, opnMq + tEnd,
|
|
0xd8, 0xe0, opnSt, opnSti + tEnd,
|
|
0xdc, 0xe8, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFSUBP[] = {
|
|
'f', 's', 'u', 'b', 'p', '\0',
|
|
0xde, 0xe8, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFSUBR[] = {
|
|
'f', 's', 'u', 'b', 'r', '\0',
|
|
0xde, 0xe1, asNone + tEnd,
|
|
0xd8, asReg5, opnMd, asFSiz + tEnd,
|
|
0xdc, asReg5, opnMq + tEnd,
|
|
0xd8, 0xe8, opnSt, opnSti + tEnd,
|
|
0xdc, 0xe0, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFSUBRP[] = {
|
|
'f', 's', 'u', 'b', 'r', 'p', '\0',
|
|
0xde, 0xe0, opnSti, opnSt + tEnd + eEnd };
|
|
|
|
BYTE szFTST[] = {
|
|
'f', 't', 's', 't', '\0',
|
|
0xd9, 0xe4, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFUCOM[] = {
|
|
'f', 'u', 'c', 'o', 'm', '\0',
|
|
0xdd, 0xe1, asNone, + tEnd,
|
|
0xdd, 0xe0, opnSti + tEnd + eEnd };
|
|
|
|
BYTE szFUCOMP[] = {
|
|
'f', 'u', 'c', 'o', 'm', 'p', '\0',
|
|
0xdd, 0xe9, asNone + tEnd,
|
|
0xdd, 0xe8, opnSti + tEnd + eEnd };
|
|
|
|
BYTE szFUCOMPP[] = {
|
|
'f', 'u', 'c', 'o', 'm', 'p', 'p', '\0',
|
|
0xda, 0xe9, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFWAIT[] = { // same as WAIT
|
|
'f', 'w', 'a', 'i', 't', '\0',
|
|
0x9b, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szFXAM[] = {
|
|
'f', 'x', 'a', 'm', '\0',
|
|
0xd9, 0xe5, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFXCH[] = {
|
|
'f', 'x', 'c', 'h', '\0',
|
|
0xd9, 0xc9, asNone + tEnd,
|
|
0xd9, 0xc8, opnSti + tEnd + eEnd };
|
|
|
|
BYTE szFXTRACT[] = {
|
|
'f', 'x', 't', 'r', 'a', 'c', 't', '\0',
|
|
0xd9, 0xf4, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFYL2X[] = {
|
|
'f', 'y', 'l', '2', 'x', '\0',
|
|
0xd9, 0xf1, asNone + tEnd + eEnd };
|
|
|
|
BYTE szFYL2XP1[] = {
|
|
'f', 'y', 'l', '2', 'x', 'p', '1', '\0',
|
|
0xd9, 0xf9, asNone + tEnd + eEnd };
|
|
|
|
BYTE szGS_A[] = {
|
|
'g', 's', ':', '\0',
|
|
0x65, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szHLT[] = {
|
|
'h', 'l', 't', '\0',
|
|
0xf4, asNone + tEnd + eEnd };
|
|
|
|
BYTE szIDIV[] = {
|
|
'i', 'd', 'i', 'v', '\0',
|
|
0xf6, asReg7, opnEb + tEnd,
|
|
0xf7, asReg7, opnEv + tEnd,
|
|
0xf6, asReg7, opnAL, opnEb + tEnd,
|
|
0xf7, asReg7, opneAX, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szIMUL[] = {
|
|
'i', 'm', 'u', 'l', '\0',
|
|
0xf6, asReg5, opnEb + tEnd,
|
|
0xf7, asReg5, opnEv + tEnd,
|
|
0xf6, asReg5, opnAL, opnEb + tEnd,
|
|
0xf7, asReg5, opneAX, opnEv + tEnd,
|
|
0x0f, 0xaf, opnGv, opnEv + tEnd,
|
|
0x6b, opnGv, opnIb + tEnd,
|
|
0x69, opnGv, opnIv + tEnd,
|
|
0x6b, opnGv, opnEv, opnIb + tEnd,
|
|
0x69, opnGv, opnEv, opnIv + tEnd + eEnd };
|
|
|
|
BYTE szIN[] = {
|
|
'i', 'n', '\0',
|
|
0xe4, opnAL, opnIb + tEnd,
|
|
0xe5, opneAX, opnIb + tEnd,
|
|
0xec, opnAL, opnDX + tEnd,
|
|
0xed, opneAX, opnDX + tEnd + eEnd };
|
|
|
|
BYTE szINC[] = {
|
|
'i', 'n', 'c', '\0',
|
|
0x40, asOpRg, opnGv + tEnd,
|
|
0xfe, asReg0, opnEb + tEnd,
|
|
0xff, asReg0, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szINS[] = {
|
|
'i', 'n', 's', '\0',
|
|
0x6c, opnYb, opnDX + tEnd,
|
|
0x6d, opnYv, opnDX + tEnd + eEnd };
|
|
|
|
BYTE szINSB[] = {
|
|
'i', 'n', 's', 'b', '\0',
|
|
0x6c, asNone + tEnd + eEnd };
|
|
|
|
BYTE szINSD[] = {
|
|
'i', 'n', 's', 'd', '\0',
|
|
0x6d, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szINSW[] = {
|
|
'i', 'n', 's', 'w', '\0',
|
|
0x6d, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szINT[] = {
|
|
'i', 'n', 't', '\0',
|
|
0xcc, opnIm3 + tEnd,
|
|
0xcd, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szINTO[] = {
|
|
'i', 'n', 't', 'o', '\0',
|
|
0xce, asNone + tEnd + eEnd };
|
|
|
|
BYTE szINVD[] = {
|
|
'i', 'n', 'v', 'd', '\0',
|
|
0x0f, 0x08, asNone + tEnd + eEnd };
|
|
|
|
BYTE szINVLPG[] = {
|
|
'i', 'n', 'v', 'l', 'p', 'g', '\0',
|
|
0x0f, 0x01, asReg7, opnM + tEnd + eEnd };
|
|
|
|
BYTE szIRET[] = {
|
|
'i', 'r', 'e', 't', '\0',
|
|
0xcf, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szIRETD[] = {
|
|
'i', 'r', 'e', 't', 'd', '\0',
|
|
0xcf, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szJA[] = { // same as JNBE
|
|
'j', 'a', '\0',
|
|
0x77, opnJb + tEnd,
|
|
0x0f, 0x87, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJAE[] = { // same as JNB, JNC
|
|
'j', 'a', 'e', '\0',
|
|
0x73, opnJb + tEnd,
|
|
0x0f, 0x83, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJB[] = { // same as JC, JNAE
|
|
'j', 'b', '\0',
|
|
0x72, opnJb + tEnd,
|
|
0x0f, 0x82, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJBE[] = { // same as JNA
|
|
'j', 'b', 'e', '\0',
|
|
0x76, opnJb + tEnd,
|
|
0x0f, 0x86, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJC[] = { // same as JB, JNAE
|
|
'j', 'c', '\0',
|
|
0x72, opnJb + tEnd,
|
|
0x0f, 0x82, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJCXZ[] = {
|
|
'j', 'c', 'x', 'z', '\0',
|
|
0xe3, asSiz0, opnJb + tEnd + eEnd };
|
|
|
|
BYTE szJECXZ[] = {
|
|
'j', 'e', 'c', 'x', 'z', '\0',
|
|
0xe3, asSiz1, opnJb + tEnd + eEnd };
|
|
|
|
BYTE szJE[] = { // same as JZ
|
|
'j', 'e', '\0',
|
|
0x74, opnJb + tEnd,
|
|
0x0f, 0x84, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJG[] = { // same as JNLE
|
|
'j', 'g', '\0',
|
|
0x7f, opnJb + tEnd,
|
|
0x0f, 0x8f, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJGE[] = { // same as JNL
|
|
'j', 'g', 'e', '\0',
|
|
0x7d, opnJb + tEnd,
|
|
0x0f, 0x8d, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJL[] = { // same as JNGE
|
|
'j', 'l', '\0',
|
|
0x7c, opnJb + tEnd,
|
|
0x0f, 0x8c, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJLE[] = { // same as JNG
|
|
'j', 'l', 'e', '\0',
|
|
0x7e, opnJb + tEnd,
|
|
0x0f, 0x8e, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJMP[] = {
|
|
'j', 'm', 'p', '\0',
|
|
0xeb, opnJb + tEnd,
|
|
0xe9, opnJv + tEnd,
|
|
0xff, asReg4, opnEv, asMpNx + tEnd,
|
|
0xff, asReg5, opnMp + tEnd,
|
|
0xea, opnAp + tEnd, + eEnd };
|
|
|
|
BYTE szJNA[] = { // same as JBE
|
|
'j', 'n', 'a', '\0',
|
|
0x76, opnJb + tEnd,
|
|
0x0f, 0x86, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNAE[] = { // same as JB, JC
|
|
'j', 'n', 'a', 'e','\0',
|
|
0x72, opnJb + tEnd,
|
|
0x0f, 0x82, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNB[] = { // same as JAE, JNC
|
|
'j', 'n', 'b', '\0',
|
|
0x73, opnJb + tEnd,
|
|
0x0f, 0x83, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNBE[] = { // same as JA
|
|
'j', 'n', 'b', 'e', '\0',
|
|
0x77, opnJb + tEnd,
|
|
0x0f, 0x87, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNC[] = { // same as JAE, JNB
|
|
'j', 'n', 'c', '\0',
|
|
0x73, opnJb + tEnd,
|
|
0x0f, 0x83, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNG[] = { // same as JLE
|
|
'j', 'n', 'g', '\0',
|
|
0x7e, opnJb + tEnd,
|
|
0x0f, 0x8e, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNGE[] = { // same as JNL
|
|
'j', 'n', 'g', 'e', '\0',
|
|
0x7c, opnJb + tEnd,
|
|
0x0f, 0x8c, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNE[] = { // same as JNZ
|
|
'j', 'n', 'e', '\0',
|
|
0x75, opnJb + tEnd,
|
|
0x0f, 0x85, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNL[] = { // same as JGE
|
|
'j', 'n', 'l', '\0',
|
|
0x7d, opnJb + tEnd,
|
|
0x0f, 0x8d, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNLE[] = { // same as JNG
|
|
'j', 'n', 'l', 'e', '\0',
|
|
0x7f, opnJb + tEnd,
|
|
0x0f, 0x8f, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNO[] = {
|
|
'j', 'n', 'o', '\0',
|
|
0x71, opnJb + tEnd,
|
|
0x0f, 0x81, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNP[] = { // same as JPO
|
|
'j', 'n', 'p', '\0',
|
|
0x7b, opnJb + tEnd,
|
|
0x0f, 0x8b, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNS[] = {
|
|
'j', 'n', 's', '\0',
|
|
0x79, opnJb + tEnd,
|
|
0x0f, 0x89, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJNZ[] = { // same as JNE
|
|
'j', 'n', 'z', '\0',
|
|
0x75, opnJb + tEnd,
|
|
0x0f, 0x85, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJO[] = {
|
|
'j', 'o', '\0',
|
|
0x70, opnJb + tEnd,
|
|
0x0f, 0x80, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJP[] = { // same as JPE
|
|
'j', 'p', '\0',
|
|
0x7a, opnJb + tEnd,
|
|
0x0f, 0x8a, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJPE[] = { // same as JP
|
|
'j', 'p', 'e', '\0',
|
|
0x7a, opnJb + tEnd,
|
|
0x0f, 0x8a, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJPO[] = { // same as JNP
|
|
'j', 'p', 'o', '\0',
|
|
0x7b, opnJb + tEnd,
|
|
0x0f, 0x8b, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJS[] = {
|
|
'j', 's', '\0',
|
|
0x78, opnJb + tEnd,
|
|
0x0f, 0x88, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szJZ[] = { // same as JE
|
|
'j', 'z', '\0',
|
|
0x74, opnJb + tEnd,
|
|
0x0f, 0x84, opnJv + tEnd + eEnd };
|
|
|
|
BYTE szLAHF[] = {
|
|
'l', 'a', 'h', 'f', '\0',
|
|
0x9f, asNone + tEnd + eEnd };
|
|
|
|
BYTE szLAR[] = {
|
|
'l', 'a', 'r', '\0',
|
|
0x0f, 0x02, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szLDS[] = {
|
|
'l', 'd', 's', '\0',
|
|
0xc5, opnGv, opnMp + tEnd + eEnd };
|
|
|
|
BYTE szLEA[] = {
|
|
'l', 'e', 'a', '\0',
|
|
0x8d, opnGv, opnM + tEnd + eEnd };
|
|
|
|
BYTE szLEAVE[] = {
|
|
'l', 'e', 'a', 'v', 'e', '\0',
|
|
0xc9, asNone + tEnd + eEnd };
|
|
|
|
BYTE szLES[] = {
|
|
'l', 'e', 's', '\0',
|
|
0xc4, opnGv, opnMp + tEnd + eEnd };
|
|
|
|
BYTE szLFS[] = {
|
|
'l', 'f', 's', '\0',
|
|
0x0f, 0xb4, opnGv, opnMp + tEnd + eEnd };
|
|
|
|
BYTE szLGDT[] = {
|
|
'l', 'g', 'd', 't', '\0',
|
|
0x0f, 0x01, asReg2, opnMs + tEnd + eEnd };
|
|
|
|
BYTE szLGS[] = {
|
|
'l', 'g', 's', '\0',
|
|
0x0f, 0xb5, opnGv, opnMp + tEnd + eEnd };
|
|
|
|
BYTE szLIDT[] = {
|
|
'l', 'i', 'd', 't', '\0',
|
|
0x0f, 0x01, asReg3, opnMs + tEnd + eEnd };
|
|
|
|
BYTE szLLDT[] = {
|
|
'l', 'l', 'd', 't', '\0',
|
|
0x0f, 0x00, asReg2, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szLMSW[] = {
|
|
'l', 'm', 's', 'w', '\0',
|
|
0x0f, 0x01, asReg6, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szLOCK[] = {
|
|
'l', 'o', 'c', 'k', '\0',
|
|
0xf0, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szLODS[] = {
|
|
'l', 'o', 'd', 's', '\0',
|
|
0xac, opnXb + tEnd,
|
|
0xad, opnXv + tEnd + eEnd };
|
|
|
|
BYTE szLODSB[] = {
|
|
'l', 'o', 'd', 's', 'b', '\0',
|
|
0xac, asNone + tEnd + eEnd };
|
|
|
|
BYTE szLODSD[] = {
|
|
'l', 'o', 'd', 's', 'd', '\0',
|
|
0xad, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szLODSW[] = {
|
|
'l', 'o', 'd', 's', 'w', '\0',
|
|
0xad, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szLOOP[] = {
|
|
'l', 'o', 'o', 'p', '\0',
|
|
0xe2, opnJb + tEnd + eEnd };
|
|
|
|
BYTE szLOOPE[] = { // same as LOOPZ
|
|
'l', 'o', 'o', 'p', 'e', '\0',
|
|
0xe1, opnJb + tEnd + eEnd };
|
|
|
|
BYTE szLOOPNE[] = { // same as LOOPNZ
|
|
'l', 'o', 'o', 'p', 'n', 'e', '\0',
|
|
0xe0, opnJb + tEnd + eEnd };
|
|
|
|
BYTE szLOOPNZ[] = { // same as LOOPNE
|
|
'l', 'o', 'o', 'p', 'n', 'z', '\0',
|
|
0xe0, opnJb + tEnd + eEnd };
|
|
|
|
BYTE szLOOPZ[] = { // same as LOOPE
|
|
'l', 'o', 'o', 'p', 'z', '\0',
|
|
0xe1, opnJb + tEnd + eEnd };
|
|
|
|
BYTE szLSL[] = {
|
|
'l', 's', 'l', '\0',
|
|
0x0f, 0x03, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szLSS[] = {
|
|
'l', 's', 's', '\0',
|
|
0x0f, 0xb2, opnGv, opnMp + tEnd + eEnd };
|
|
|
|
BYTE szLTR[] = {
|
|
'l', 't', 'r', '\0',
|
|
0x0f, 0x00, asReg3, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szMOV[] = {
|
|
'm', 'o', 'v', '\0',
|
|
0xa0, opnAL, opnOb + tEnd,
|
|
0xa1, opneAX, opnOv + tEnd,
|
|
0xa2, opnOb, opnAL + tEnd,
|
|
0xa3, opnOv, opneAX + tEnd,
|
|
0x8a, opnGb, opnEb + tEnd,
|
|
0x8b, opnGv, opnEv + tEnd,
|
|
0x88, opnEb, opnGb + tEnd,
|
|
0x89, opnEv, opnGv + tEnd,
|
|
0x8c, asSiz0, opnEw, opnSw + tEnd,
|
|
0x8e, asSiz0, opnSw, opnEw + tEnd,
|
|
0xb0, asOpRg, opnGb, opnIb + tEnd,
|
|
0xb8, asOpRg, opnGv, opnIv + tEnd,
|
|
0xc6, opnEb, opnIb + tEnd,
|
|
0xc7, opnEv, opnIv + tEnd,
|
|
0x0f, 0x20, opnRd, opnCd + tEnd,
|
|
0x0f, 0x21, opnRd, opnDd + tEnd,
|
|
0x0f, 0x22, opnCd, opnRd + tEnd,
|
|
0x0f, 0x23, opnDd, opnRd + tEnd,
|
|
0x0f, 0x24, opnRd, opnTd + tEnd,
|
|
0x0f, 0x26, opnTd, opnRd + tEnd + eEnd };
|
|
|
|
BYTE szMOVS[] = {
|
|
'm', 'o', 'v', 's', '\0',
|
|
0xa4, opnXb, opnYb + tEnd,
|
|
0xa5, opnXv, opnYv + tEnd + eEnd };
|
|
|
|
BYTE szMOVSB[] = {
|
|
'm', 'o', 'v', 's', 'b', '\0',
|
|
0xa4, asNone + tEnd + eEnd };
|
|
|
|
BYTE szMOVSD[] = {
|
|
'm', 'o', 'v', 's', 'd', '\0',
|
|
0xa5, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szMOVSW[] = {
|
|
'm', 'o', 'v', 's', 'w', '\0',
|
|
0xa5, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szMOVSX[] = {
|
|
'm', 'o', 'v', 's', 'x', '\0',
|
|
0x0f, 0xbe, opnGv, opnEb + tEnd,
|
|
0x0f, 0xbf, opnGv, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szMOVZX[] = {
|
|
'm', 'o', 'v', 'z', 'x', '\0',
|
|
0x0f, 0xb6, opnGv, opnEb + tEnd,
|
|
0x0f, 0xb7, opnGv, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szMUL[] = {
|
|
'm', 'u', 'l', '\0',
|
|
0xf6, asReg4, opnEb + tEnd,
|
|
0xf7, asReg4, opnEv + tEnd,
|
|
0xf6, asReg4, opnAL, opnEb + tEnd,
|
|
0xf7, asReg4, opneAX, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szNEG[] = {
|
|
'n', 'e', 'g', '\0',
|
|
0xf6, asReg3, opnEb + tEnd,
|
|
0xf7, asReg3, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szNOP[] = {
|
|
'n', 'o', 'p', '\0',
|
|
0x90, asNone + tEnd };
|
|
|
|
BYTE szNOT[] = {
|
|
'n', 'o', 't', '\0',
|
|
0xf6, asReg2, opnEb + tEnd,
|
|
0xf7, asReg2, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szOR[] = {
|
|
'o', 'r', '\0',
|
|
0x0c, opnAL, opnIb + tEnd,
|
|
0x0d, opneAX, opnIv + tEnd,
|
|
0x80, asReg1, opnEb, opnIb + tEnd,
|
|
0x83, asReg1, opnEv, opnIb + tEnd,
|
|
0x81, asReg1, opnEv, opnIv + tEnd,
|
|
0x08, opnEb, opnGb + tEnd,
|
|
0x09, opnEv, opnGv + tEnd,
|
|
0x0a, opnGb, opnEb + tEnd,
|
|
0x0b, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szOUT[] = {
|
|
'o', 'u', 't', '\0',
|
|
0xe6, opnIb, opnAL + tEnd,
|
|
0xe7, opnIb, opneAX + tEnd,
|
|
0xee, opnDX, opnAL + tEnd,
|
|
0xef, opnDX, opneAX + tEnd + eEnd };
|
|
|
|
BYTE szOUTS[] = {
|
|
'o', 'u', 't', 's', '\0',
|
|
0x6e, opnDX, opnYb + tEnd,
|
|
0x6f, opnDX, opnYv + tEnd + eEnd };
|
|
|
|
BYTE szOUTSB[] = {
|
|
'o', 'u', 't', 's', 'b', '\0',
|
|
0x6e, asNone + tEnd + eEnd };
|
|
|
|
BYTE szOUTSD[] = {
|
|
'o', 'u', 't', 's', 'd', '\0',
|
|
0x6f, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szOUTSW[] = {
|
|
'o', 'u', 't', 's', 'w', '\0',
|
|
0x6f, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szPOP[] = {
|
|
'p', 'o', 'p', '\0',
|
|
0x58, asOpRg, opnGv + tEnd,
|
|
0x8f, asReg0, opnMv + tEnd,
|
|
0x1f, opnSeg, segDS, asNone+ tEnd,
|
|
0x07, opnSeg, segES, asNone+ tEnd,
|
|
0x17, opnSeg, segSS, asNone+ tEnd,
|
|
0x0f, 0xa1, opnSeg, segFS, asNone+ tEnd,
|
|
0x0f, 0xa9, opnSeg, segGS, asNone+ tEnd + eEnd };
|
|
|
|
BYTE szPOPA[] = {
|
|
'p', 'o', 'p', 'a', '\0',
|
|
0x61, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szPOPAD[] = {
|
|
'p', 'o', 'p', 'a', 'd', '\0',
|
|
0x61, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szPOPF[] = {
|
|
'p', 'o', 'p', 'f', '\0',
|
|
0x9d, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szPOPFD[] = {
|
|
'p', 'o', 'p', 'f', 'd', '\0',
|
|
0x9d, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szPUSH[] = {
|
|
'p', 'u', 's', 'h', '\0',
|
|
0x50, asOpRg, opnGv + tEnd,
|
|
0xff, asReg6, opnMv + tEnd,
|
|
0x6a, opnIb + tEnd,
|
|
0x68, opnIv + tEnd,
|
|
0x0e, opnSeg, segCS, asNone+ tEnd,
|
|
0x1e, opnSeg, segDS, asNone+ tEnd,
|
|
0x06, opnSeg, segES, asNone+ tEnd,
|
|
0x16, opnSeg, segSS, asNone+ tEnd,
|
|
0x0f, 0xa0, opnSeg, segFS, asNone+ tEnd,
|
|
0x0f, 0xa8, opnSeg, segGS, asNone+ tEnd + eEnd };
|
|
|
|
BYTE szPUSHA[] = {
|
|
'p', 'u', 's', 'h', 'a', '\0',
|
|
0x60, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szPUSHAD[] = {
|
|
'p', 'u', 's', 'h', 'a', 'd', '\0',
|
|
0x60, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szPUSHF[] = {
|
|
'p', 'u', 's', 'h', 'f', '\0',
|
|
0x9c, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szPUSHFD[] = {
|
|
'p', 'u', 's', 'h', 'f', 'd', '\0',
|
|
0x9c, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szRCL[] = {
|
|
'r', 'c', 'l', '\0',
|
|
0xd0, asReg2, opnEb, opnIm1 + tEnd,
|
|
0xd2, asReg2, opnEb, opnCL + tEnd,
|
|
0xc0, asReg2, opnEb, opnIb + tEnd,
|
|
0xd1, asReg2, opnEv, opnIm1 + tEnd,
|
|
0xd3, asReg2, opnEv, opnCL + tEnd,
|
|
0xc1, asReg2, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szRCR[] = {
|
|
'r', 'c', 'r', '\0',
|
|
0xd0, asReg3, opnEb, opnIm1 + tEnd,
|
|
0xd2, asReg3, opnEb, opnCL + tEnd,
|
|
0xc0, asReg3, opnEb, opnIb + tEnd,
|
|
0xd1, asReg3, opnEv, opnIm1 + tEnd,
|
|
0xd3, asReg3, opnEv, opnCL + tEnd,
|
|
0xc1, asReg3, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szREP[] = { // same as REPE, REPZ
|
|
'r', 'e', 'p', '\0',
|
|
0xf3, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szREPE[] = { // same as REP, REPZ
|
|
'r', 'e', 'p', 'e', '\0',
|
|
0xf3, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szREPZ[] = { // same as REP, REPE
|
|
'r', 'e', 'p', 'z', '\0',
|
|
0xf3, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szREPNE[] = { // same as REPNZ
|
|
'r', 'e', 'p', 'n', 'e', '\0',
|
|
0xf2, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szREPNZ[] = { // same as REPNE
|
|
'r', 'e', 'p', 'n', 'z', '\0',
|
|
0xf2, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szRET[] = { // same as RETN
|
|
'r', 'e', 't', '\0',
|
|
0xc3, asNone + tEnd,
|
|
0xc2, opnIw + tEnd + eEnd };
|
|
|
|
BYTE szRETF[] = {
|
|
'r', 'e', 't', 'f', '\0',
|
|
0xcb, asNone + tEnd,
|
|
0xca, opnIw + tEnd + eEnd };
|
|
|
|
BYTE szRETN[] = { // same as RET
|
|
'r', 'e', 't', 'n', '\0',
|
|
0xc3, asNone + tEnd,
|
|
0xc2, opnIw + tEnd + eEnd };
|
|
|
|
BYTE szROL[] = {
|
|
'r', 'o', 'l', '\0',
|
|
0xd0, asReg0, opnEb, opnIm1 + tEnd,
|
|
0xd2, asReg0, opnEb, opnCL + tEnd,
|
|
0xc0, asReg0, opnEb, opnIb + tEnd,
|
|
0xd1, asReg0, opnEv, opnIm1 + tEnd,
|
|
0xd3, asReg0, opnEv, opnCL + tEnd,
|
|
0xc1, asReg0, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szROR[] = {
|
|
'r', 'o', 'r', '\0',
|
|
0xd0, asReg1, opnEb, opnIm1 + tEnd,
|
|
0xd2, asReg1, opnEb, opnCL + tEnd,
|
|
0xc0, asReg1, opnEb, opnIb + tEnd,
|
|
0xd1, asReg1, opnEv, opnIm1 + tEnd,
|
|
0xd3, asReg1, opnEv, opnCL + tEnd,
|
|
0xc1, asReg1, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szSAHF[] = {
|
|
's', 'a', 'h', 'f', '\0',
|
|
0x9e, asNone + tEnd + eEnd };
|
|
|
|
BYTE szSAL[] = {
|
|
's', 'a', 'l', '\0',
|
|
0xd0, asReg4, opnEb, opnIm1 + tEnd,
|
|
0xd2, asReg4, opnEb, opnCL + tEnd,
|
|
0xc0, asReg4, opnEb, opnIb + tEnd,
|
|
0xd1, asReg4, opnEv, opnIm1 + tEnd,
|
|
0xd3, asReg4, opnEv, opnCL + tEnd,
|
|
0xc1, asReg4, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szSAR[] = {
|
|
's', 'a', 'r', '\0',
|
|
0xd0, asReg7, opnEb, opnIm1 + tEnd,
|
|
0xd2, asReg7, opnEb, opnCL + tEnd,
|
|
0xc0, asReg7, opnEb, opnIb + tEnd,
|
|
0xd1, asReg7, opnEv, opnIm1 + tEnd,
|
|
0xd3, asReg7, opnEv, opnCL + tEnd,
|
|
0xc1, asReg7, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szSBB[] = {
|
|
's', 'b', 'b', '\0',
|
|
0x1c, opnAL, opnIb + tEnd,
|
|
0x1d, opneAX, opnIv + tEnd,
|
|
0x80, asReg3, opnEb, opnIb + tEnd,
|
|
0x83, asReg3, opnEv, opnIb + tEnd,
|
|
0x81, asReg3, opnEv, opnIv + tEnd,
|
|
0x18, opnEb, opnGb + tEnd,
|
|
0x19, opnEv, opnGv + tEnd,
|
|
0x1a, opnGb, opnEb + tEnd,
|
|
0x1b, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
|
|
BYTE szSCAS[] = {
|
|
's', 'c', 'a', 's', '\0',
|
|
0xae, opnYb + tEnd,
|
|
0xaf, opnYv + tEnd + eEnd };
|
|
|
|
BYTE szSCASB[] = {
|
|
's', 'c', 'a', 's', 'b', '\0',
|
|
0xae, asNone + tEnd + eEnd };
|
|
|
|
BYTE szSCASD[] = {
|
|
's', 'c', 'a', 's', 'd', '\0',
|
|
0xaf, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szSCASW[] = {
|
|
's', 'c', 'a', 's', 'w', '\0',
|
|
0xaf, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szSETA[] = { // same as SETNBE
|
|
's', 'e', 't', 'a', '\0',
|
|
0x0f, 0x97, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETAE[] = { // same as SETNB, SETNC
|
|
's', 'e', 't', 'a', 'e', '\0',
|
|
0x0f, 0x93, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETB[] = { // same as SETC, SETNAE
|
|
's', 'e', 't', 'b', '\0',
|
|
0x0f, 0x92, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETBE[] = { // same as SETNA
|
|
's', 'e', 't', 'b', 'e', '\0',
|
|
0x0f, 0x96, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETC[] = { // same as SETB, SETNAE
|
|
's', 'e', 't', 'c', '\0',
|
|
0x0f, 0x92, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETE[] = { // same as SETZ
|
|
's', 'e', 't', 'e', '\0',
|
|
0x0f, 0x94, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETG[] = { // same as SETNLE
|
|
's', 'e', 't', 'g', '\0',
|
|
0x0f, 0x9f, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETGE[] = { // same as SETNL
|
|
's', 'e', 't', 'g', 'e', '\0',
|
|
0x0f, 0x9d, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETL[] = { // same as SETNGE
|
|
's', 'e', 't', 'l', '\0',
|
|
0x0f, 0x9c, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETLE[] = { // same as SETNG
|
|
's', 'e', 't', 'l', 'e', '\0',
|
|
0x0f, 0x9e, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNA[] = { // same as SETBE
|
|
's', 'e', 't', 'n', 'a', '\0',
|
|
0x0f, 0x96, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNAE[] = { // same as SETB, SETC
|
|
's', 'e', 't', 'n', 'a', 'e', '\0',
|
|
0x0f, 0x92, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNB[] = { // same as SETAE, SETNC
|
|
's', 'e', 't', 'n', 'b', '\0',
|
|
0x0f, 0x93, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNBE[] = { // same as SETA
|
|
's', 'e', 't', 'n', 'b', 'e', '\0',
|
|
0x0f, 0x97, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNC[] = { // same as SETAE, SETNC
|
|
's', 'e', 't', 'n', 'c', '\0',
|
|
0x0f, 0x93, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNE[] = { // same as SETNZ
|
|
's', 'e', 't', 'n', 'e', '\0',
|
|
0x0f, 0x95, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNG[] = { // same as SETLE
|
|
's', 'e', 't', 'n', 'g', '\0',
|
|
0x0f, 0x9e, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNGE[] = { // same as SETL
|
|
's', 'e', 't', 'n', 'g', 'e', '\0',
|
|
0x0f, 0x9c, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNL[] = { // same as SETGE
|
|
's', 'e', 't', 'n', 'l', '\0',
|
|
0x0f, 0x9d, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNLE[] = { // same as SETG
|
|
's', 'e', 't', 'n', 'l', 'e', '\0',
|
|
0x0f, 0x9f, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNO[] = {
|
|
's', 'e', 't', 'n', 'o', '\0',
|
|
0x0f, 0x91, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNP[] = { // same as SETPO
|
|
's', 'e', 't', 'n', 'p', '\0',
|
|
0x0f, 0x9b, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNS[] = {
|
|
's', 'e', 't', 'n', 's', '\0',
|
|
0x0f, 0x99, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETNZ[] = { // same as SETNE
|
|
's', 'e', 't', 'n', 'z', '\0',
|
|
0x0f, 0x95, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETO[] = {
|
|
's', 'e', 't', 'o', '\0',
|
|
0x0f, 0x90, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETP[] = { // same as SETPE
|
|
's', 'e', 't', 'p', '\0',
|
|
0x0f, 0x9a, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETPE[] = { // same as SETP
|
|
's', 'e', 't', 'p', 'e', '\0',
|
|
0x0f, 0x9a, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETPO[] = { // same as SETNP
|
|
's', 'e', 't', 'p', 'o', '\0',
|
|
0x0f, 0x9b, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETS[] = {
|
|
's', 'e', 't', 's', '\0',
|
|
0x0f, 0x98, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSETZ[] = { // same as SETE
|
|
's', 'e', 't', 'z', '\0',
|
|
0x0f, 0x94, opnEb + tEnd + eEnd };
|
|
|
|
BYTE szSGDT[] = {
|
|
's', 'g', 'd', 't', '\0',
|
|
0x0f, 0x01, asReg0, opnMs + tEnd + eEnd };
|
|
|
|
BYTE szSHL[] = {
|
|
's', 'h', 'l', '\0',
|
|
0xd0, asReg4, opnEb, opnIm1 + tEnd,
|
|
0xd2, asReg4, opnEb, opnCL + tEnd,
|
|
0xc0, asReg4, opnEb, opnIb + tEnd,
|
|
0xd1, asReg4, opnEv, opnIm1 + tEnd,
|
|
0xd3, asReg4, opnEv, opnCL + tEnd,
|
|
0xc1, asReg4, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szSHLD[] = {
|
|
's', 'h', 'l', 'd', '\0',
|
|
0x0f, 0xa4, opnEv, opnGv, opnIb + tEnd,
|
|
0x0f, 0xa5, opnEv, opnGv, opnCL + tEnd + eEnd };
|
|
|
|
BYTE szSHR[] = {
|
|
's', 'h', 'r', '\0',
|
|
0xd0, asReg5, opnEb, opnIm1 + tEnd,
|
|
0xd2, asReg5, opnEb, opnCL + tEnd,
|
|
0xc0, asReg5, opnEb, opnIb + tEnd,
|
|
0xd1, asReg5, opnEv, opnIm1 + tEnd,
|
|
0xd3, asReg5, opnEv, opnCL + tEnd,
|
|
0xc1, asReg5, opnEv, opnIb + tEnd + eEnd };
|
|
|
|
BYTE szSHRD[] = {
|
|
's', 'h', 'r', 'd', '\0',
|
|
0x0f, 0xac, opnEv, opnGv, opnIb + tEnd,
|
|
0x0f, 0xad, opnEv, opnGv, opnCL + tEnd + eEnd };
|
|
|
|
BYTE szSIDT[] = {
|
|
's', 'i', 'd', 't', '\0',
|
|
0x0f, 0x01, asReg1, opnMs + tEnd + eEnd };
|
|
|
|
BYTE szSLDT[] = {
|
|
's', 'l', 'd', 't', '\0',
|
|
0x0f, 0x00, asReg0, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szSMSW[] = {
|
|
's', 'm', 's', 'w', '\0',
|
|
0x0f, 0x01, asReg4, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szSS_A[] = {
|
|
's', 's', ':', '\0',
|
|
0x26, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szSTC[] = {
|
|
's', 't', 'c', '\0',
|
|
0xf9, asNone + tEnd + eEnd };
|
|
|
|
BYTE szSTD[] = {
|
|
's', 't', 'd', '\0',
|
|
0xfd, asNone + tEnd + eEnd };
|
|
|
|
BYTE szSTI[] = {
|
|
's', 't', 'i', '\0',
|
|
0xfb, asNone + tEnd + eEnd };
|
|
|
|
BYTE szSTOS[] = {
|
|
's', 't', 'o', 's', '\0',
|
|
0xaa, opnYb + tEnd,
|
|
0xab, opnYv + tEnd + eEnd };
|
|
|
|
BYTE szSTOSB[] = {
|
|
's', 't', 'o', 's', 'b', '\0',
|
|
0xaa, asNone + tEnd + eEnd };
|
|
|
|
BYTE szSTOSD[] = {
|
|
's', 't', 'o', 's', 'd', '\0',
|
|
0xab, asSiz1 + tEnd + eEnd };
|
|
|
|
BYTE szSTOSW[] = {
|
|
's', 't', 'o', 's', 'w', '\0',
|
|
0xab, asSiz0 + tEnd + eEnd };
|
|
|
|
BYTE szSTR[] = {
|
|
's', 't', 'r', '\0',
|
|
0x0f, 0x00, asReg1, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szSUB[] = {
|
|
's', 'u', 'b', '\0',
|
|
0x2c, opnAL, opnIb + tEnd,
|
|
0x2d, opneAX, opnIv + tEnd,
|
|
0x80, asReg5, opnEb, opnIb + tEnd,
|
|
0x83, asReg5, opnEv, opnIb + tEnd,
|
|
0x81, asReg5, opnEv, opnIv + tEnd,
|
|
0x28, opnEb, opnGb + tEnd,
|
|
0x29, opnEv, opnGv + tEnd,
|
|
0x2a, opnGb, opnEb + tEnd,
|
|
0x2b, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
BYTE szTEST[] = {
|
|
't', 'e', 's', 't', '\0',
|
|
0xa8, opnAL, opnIb + tEnd,
|
|
0xa9, opneAX, opnIv + tEnd,
|
|
0xf6, asReg0, opnEb, opnIb + tEnd,
|
|
0xf7, asReg0, opnEv, opnIv + tEnd,
|
|
0x84, opnEb, opnGb + tEnd,
|
|
0x85, opnEv, opnGv + tEnd + eEnd };
|
|
|
|
BYTE szVERR[] = {
|
|
'v', 'e', 'r', 'r', '\0',
|
|
0x0f, 0x00, asReg4, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szVERW[] = {
|
|
'v', 'e', 'r', 'w', '\0',
|
|
0x0f, 0x00, asReg5, opnEw + tEnd + eEnd };
|
|
|
|
BYTE szWAIT[] = { // same as FWAIT
|
|
'w', 'a', 'i', 't', '\0',
|
|
0x9b, asPrfx + tEnd + eEnd };
|
|
|
|
BYTE szWBINVD[] = {
|
|
'w', 'b', 'i', 'n', 'v', 'd', '\0',
|
|
0x0f, 0x09, asNone + tEnd + eEnd };
|
|
|
|
BYTE szXADD[] = {
|
|
'x', 'a', 'd', 'd', '\0',
|
|
0x0f, 0xc0, opnEb, opnGb + tEnd,
|
|
0x0f, 0xc1, opnEv, opnGv + tEnd + eEnd };
|
|
|
|
BYTE szXCHG[] = {
|
|
'x', 'c', 'h', 'g', '\0',
|
|
0x90, asOpRg, opneAX, opnGv + tEnd,
|
|
0x90, asOpRg, opnGv, opneAX + tEnd,
|
|
0x86, opnGb, opnEb + tEnd,
|
|
0x86, opnEb, opnGb + tEnd,
|
|
0x87, opnGv, opnEv + tEnd,
|
|
0x87, opnEv, opnGv + tEnd + eEnd };
|
|
|
|
BYTE szXLAT[] = {
|
|
'x', 'l', 'a', 't', '\0',
|
|
0xd7, asNone + tEnd,
|
|
0xd7, asSeg, opnM + tEnd + eEnd };
|
|
|
|
BYTE szXOR[] = {
|
|
'x', 'o', 'r', '\0',
|
|
0x34, opnAL, opnIb + tEnd,
|
|
0x35, opneAX, opnIv + tEnd,
|
|
0x80, asReg6, opnEb, opnIb + tEnd,
|
|
0x83, asReg6, opnEv, opnIb + tEnd,
|
|
0x81, asReg6, opnEv, opnIv + tEnd,
|
|
0x30, opnEb, opnGb + tEnd,
|
|
0x31, opnEv, opnGv + tEnd,
|
|
0x32, opnGb, opnEb + tEnd,
|
|
0x33, opnGv, opnEv + tEnd + eEnd };
|
|
|
|
LPBYTE OpTable[] = {
|
|
szAAA, szAAD, szAAM, szAAS, szADC, szADD,
|
|
szAND, szARPL, szBOUND, szBSF, szBSR, szBSWAP,
|
|
szBT, szBTC, szBTR, szBTS, szCALL, szCBW,
|
|
szCDQ, szCLC, szCLD, szCLI, szCLTS, szCMC,
|
|
szCMP, szCMPS, szCMPSB, szCMPSD, szCMPSW, szCMPXCHG,
|
|
szCS_A, szCWD, szCWDE, szDAA, szDAS, szDEC,
|
|
szDIV, szDS_A, szENTER, szES_A, szF2XM1, szFABS,
|
|
szFADD, szFADDP, szFBLD, szFBSTP, szFCHS, szFCLEX,
|
|
szFCOM, szFCOMP, szFCOMPP, szFCOS, szFDECSTP, szFDISI,
|
|
szFDIV, szFDIVP, szFDIVR, szFDIVRP, szFENI, szFFREE,
|
|
szFIADD, szFICOM, szFICOMP, szFIDIV, szFIDIVR, szFILD,
|
|
szFIMUL, szFINCSTP, szFINIT, szFIST, szFISTP, szFISUB,
|
|
szFISUBR, szFLD, szFLD1, szFLDCW, szFLDENV, szFLDL2E,
|
|
szFLDL2T, szFLDLG2, szFLDLN2, szFLDPI, szFLDZ, szFMUL,
|
|
szFMULP, szFNCLEX, szFNDISI, szFNENI, szFNINIT, szFNOP,
|
|
szFNSAVE, szFNSTCW, szFNSTENV, szFNSTSW, szFPATAN, szFPREM,
|
|
szFPREM1, szFPTAN, szFRNDINT, szFRSTOR, szFS_A, szFSAVE,
|
|
szFSCALE, szFSETPM, szFSIN, szFSINCOS, szFSQRT, szFST,
|
|
szFSTCW, szFSTENV, szFSTP, szFSTSW, szFSUB, szFSUBP,
|
|
szFSUBR, szFSUBRP, szFTST, szFUCOM, szFUCOMP, szFUCOMPP,
|
|
szFWAIT, szFXAM, szFXCH, szFXTRACT, szFYL2X, szFYL2XP1,
|
|
szGS_A, szHLT, szIDIV, szIMUL, szIN, szINC,
|
|
szINS, szINSB, szINSD, szINSW, szINT, szINTO,
|
|
szINVD, szINVLPG, szIRET, szIRETD, szJA, szJAE,
|
|
szJB, szJBE, szJC, szJCXZ, szJE, szJECXZ,
|
|
szJG, szJGE, szJL, szJLE, szJMP, szJNA,
|
|
szJNAE, szJNB, szJNBE, szJNC, szJNE, szJNG,
|
|
szJNGE, szJNL, szJNLE, szJNO, szJNP, szJNS,
|
|
szJNZ, szJO, szJP, szJPE, szJPO, szJS,
|
|
szJZ, szLAHF, szLAR, szLDS, szLEA, szLEAVE,
|
|
szLES, szLFS, szLGDT, szLGS, szLIDT, szLLDT,
|
|
szLMSW, szLOCK, szLODS, szLODSB, szLODSD, szLODSW,
|
|
szLOOP, szLOOPE, szLOOPNE, szLOOPNZ, szLOOPZ, szLSL,
|
|
szLSS, szLTR, szMOV, szMOVS, szMOVSB, szMOVSD,
|
|
szMOVSW, szMOVSX, szMOVZX, szMUL, szNEG, szNOP,
|
|
szNOT, szOR, szOUT, szOUTS, szOUTSB, szOUTSD,
|
|
szOUTSW, szPOP, szPOPA, szPOPAD, szPOPF, szPOPFD,
|
|
szPUSH, szPUSHA, szPUSHAD, szPUSHF, szPUSHFD, szRCL,
|
|
szRCR, szREP, szREPE, szREPNE, szREPNZ, szREPZ,
|
|
szRET, szRETF, szRETN, szROL, szROR, szSAHF,
|
|
szSAL, szSAR, szSBB, szSCAS, szSCASB, szSCASD,
|
|
szSCASW, szSETA, szSETAE, szSETB, szSETBE, szSETC,
|
|
szSETE, szSETG, szSETGE, szSETL, szSETLE, szSETNA,
|
|
szSETNAE, szSETNB, szSETNBE, szSETNC, szSETNE, szSETNG,
|
|
szSETNGE, szSETNL, szSETNLE, szSETNO, szSETNP, szSETNS,
|
|
szSETNZ, szSETO, szSETP, szSETPE, szSETPO, szSETS,
|
|
szSETZ, szSGDT, szSHL, szSHLD, szSHR, szSHRD,
|
|
szSIDT, szSLDT, szSMSW, szSS_A, szSTC, szSTD,
|
|
szSTI, szSTOS, szSTOSB, szSTOSD, szSTOSW, szSTR,
|
|
szSUB, szTEST, szVERR, szVERW, szWAIT, szWBINVD,
|
|
szXADD, szXCHG, szXLAT, szXOR
|
|
};
|
|
|
|
#define OPTABLESIZE (sizeof(OpTable) / sizeof(LPBYTE))
|
|
|
|
|
|
/*** SearchOpcode - search for opcode
|
|
*
|
|
* Purpose:
|
|
* Search the opcode table for a match with the string
|
|
* pointed by *pszOp.
|
|
*
|
|
* Input:
|
|
* *pszOp - string to search as opcode
|
|
*
|
|
* Returns:
|
|
* if not -1, index of match entry in opcode table
|
|
* if -1, not found
|
|
*
|
|
*************************************************************************/
|
|
|
|
LPBYTE SearchOpcode ( LPBYTE pszop ) {
|
|
ULONG low = 0;
|
|
ULONG mid;
|
|
ULONG high = OPTABLESIZE - 1;
|
|
ULONG match;
|
|
|
|
while (low <= high) {
|
|
mid = (low + high) / 2;
|
|
match = (ULONG)strcmp(pszop, OpTable[mid]);
|
|
if (match == -1)
|
|
high = mid - 1;
|
|
else if (match == 1)
|
|
low = mid + 1;
|
|
else
|
|
return OpTable[mid] + strlen(OpTable[mid]) + 1;
|
|
}
|
|
return NULL;
|
|
}
|