windows-server-2003/base/mvdm/vdmexts/disasm.c

/*++

Copyright (c) 1995  Microsoft Corporation

Module Name:

    disasm.c

Abstract:

    This file contains the x86 disassmbler invoked by "!bde.u <16:16 address>"

Author:

    Barry Bond    (BarryBo)

Revision History:

    09-May-1995 Barry Bond  (BarryBo)   Created
    15-Jan-1996 Neil Sandlin (NeilSa)   Merged with vdmexts
                                        32 bit segments fixes

--*/

#include <precomp.h>
#pragma hdrstop

WORD  gSelector = 0;
ULONG gOffset = 0;
int gMode = 0;

VOID
u(
    CMD_ARGLIST
) {
    VDMCONTEXT      ThreadContext;
    WORD            selector;
    ULONG           offset;
    int             mode;
    char            rgchOutput[128];
    char            rgchExtra[128];
    BYTE            rgbInstruction[64];
    CHAR            sym_text[255];
    CHAR            sym_prev[255] = "";
    DWORD           dist;
    int             cb;
    int             i;
    int             j;
    int             count=10;
    ULONG           Base;
    SELECTORINFO    si;
    ULONG           BPNum;
    UCHAR           BPData;
    BOOL            bIsBP;

    CMD_INIT();

    mode = GetContext( &ThreadContext );

    if (!GetNextToken()) {
        if (!gSelector && !gOffset) {
            selector = (WORD) ThreadContext.SegCs;
            offset   = ThreadContext.Eip;
        } else {
            mode = gMode;
            selector = gSelector;
            offset = gOffset;
        }
    } else if (!ParseIntelAddress(&mode, &selector, &offset)) {
        return;
    }

    if (GetNextToken()) {
        count = (int) EXPRESSION(lpArgumentString);
        if (count > 1000) {
            PRINTF("Count too large - ignored\n");
            count=10;
        }
    }

    if ( mode != PROT_MODE && mode != V86_MODE) {
        PRINTF(" Disassembly of flat mode code not allowed.\n");
        return;
    }

    LoadBreakPointCache();
    Base = GetInfoFromSelector( selector, mode, &si ) + GetIntelBase();

    for (i=0; i<count; ++i) {

        if (FindSymbol(selector, offset, sym_text, &dist, BEFORE, mode )) {
            if (_stricmp(sym_text, sym_prev)) {
                if ( dist == 0 ) {
                    PRINTF("%s:\n", sym_text );
                } else {
                    PRINTF("%s+0x%lx:\n", sym_text, dist );
                }
                strcpy(sym_prev, sym_text);
            }
        }

        cb = sizeof(rgbInstruction);
        if ((DWORD)(offset+cb) >= si.Limit)
            cb -= offset+cb-si.Limit;
        if (!READMEM((LPVOID)(Base+offset), rgbInstruction, cb)) {
            PRINTF("%04x:%08x: <Error Reading Memory>\n", selector, offset);
            return;
        }

        if (bIsBP = IsVdmBreakPoint(selector,
                                    offset,
                                    mode==PROT_MODE,
                                    &BPNum,
                                    &BPData)) {
            rgbInstruction[0] = BPData;
        }

        cb = unassemble_one(rgbInstruction,
                si.bBig,
                selector, offset,
                rgchOutput,
                rgchExtra,
                &ThreadContext,
                mode);

        gOffset += cb;

        if (offset > 0xffff) {
            PRINTF("%04x:%08x ", selector, offset);
        } else {
            PRINTF("%04x:%04x ", selector, offset);
        }

        for (j=0; j<cb; ++j)
            PRINTF("%02x", rgbInstruction[j]);
        for (; j<8; ++j)
            PRINTF("  ");

        PRINTF("%s\t%s", rgchOutput, rgchExtra);

        if (bIsBP) {
            PRINTF("; BP%d",BPNum);
        }

        PRINTF("\n");
        offset+=cb;
    }
}


typedef struct _ADDR {
    ULONG     sOff;
    USHORT    sSeg;
} ADDR;


LPBYTE checkprefixes(LPBYTE);
void AppendPrefixes(void);
void DisplayAddress(int mod, int rm, int sOff, int size);
int DisplayBOP(void);

#define modrmB      1
#define modrmW      2
#define reg1B       3
#define reg1W       4
#define reg2B       5
#define reg2W       6
#define eeeControl  7
#define eeeDebug    8
#define eeeTest     9
#define regSeg      10
#define ALreg       11
#define AHreg       12
#define BLreg       13
#define BHreg       14
#define CLreg       15
#define CHreg       16
#define DLreg       17
#define DHreg       18
#define AXreg       19
#define BXreg       20
#define CXreg       21
#define DXreg       22
#define SIreg       23
#define DIreg       24
#define SPreg       25
#define BPreg       26
#define CSreg       27
#define SSreg       28
#define DSreg       29
#define ESreg       30
#define FSreg       31
#define GSreg       32
#define ImmB        33
#define ImmBEnter   34
#define ImmBS       35
#define ImmW        36
#define ImmW1       37
#define jmpB        38
#define jmpW        39
#define memB        40
#define memW        41
#define memD        42
#define indirmodrmW 43
#define indirFARmodrmW 44
#define memB1       45


int DmodrmB(LPBYTE);
int DmodrmW(LPBYTE);
int Dreg1B(LPBYTE);
int Dreg1W(LPBYTE);
int Dreg2B(LPBYTE);
int Dreg2W(LPBYTE);
int DeeeControl(LPBYTE);
int DeeeDebug(LPBYTE);
int DeeeTest(LPBYTE);
int DregSeg(LPBYTE);
int DALreg(LPBYTE);
int DAHreg(LPBYTE);
int DBLreg(LPBYTE);
int DBHreg(LPBYTE);
int DCLreg(LPBYTE);
int DCHreg(LPBYTE);
int DDLreg(LPBYTE);
int DDHreg(LPBYTE);
int DAXreg(LPBYTE);
int DBXreg(LPBYTE);
int DCXreg(LPBYTE);
int DDXreg(LPBYTE);
int DSIreg(LPBYTE);
int DDIreg(LPBYTE);
int DSPreg(LPBYTE);
int DBPreg(LPBYTE);
int DCSreg(LPBYTE);
int DSSreg(LPBYTE);
int DDSreg(LPBYTE);
int DESreg(LPBYTE);
int DFSreg(LPBYTE);
int DGSreg(LPBYTE);
int DImmB(LPBYTE);
int DImmBEnter(LPBYTE);
int DImmBS(LPBYTE);
int DImmW(LPBYTE);
int DImmW1(LPBYTE); // immediate-16 for 1-byte instructions
int DjmpB(LPBYTE);
int DjmpW(LPBYTE);
int DmemB(LPBYTE);
int DmemB1(LPBYTE);
int DmemW(LPBYTE);
int DmemD(LPBYTE);
int DindirmodrmW(LPBYTE);
int DindirFARmodrmW(LPBYTE);

struct {
    int (*pfn)(LPBYTE);
} rgpfn[] = {

 0,         // 0th entry is reserved
 DmodrmB,
 DmodrmW,
 Dreg1B,
 Dreg1W,
 Dreg2B,
 Dreg2W,
 DeeeControl,
 DeeeDebug,
 DeeeTest,
 DregSeg,
 DALreg,
 DAHreg,
 DBLreg,
 DBHreg,
 DCLreg,
 DCHreg,
 DDLreg,
 DDHreg,
 DAXreg,
 DBXreg,
 DCXreg,
 DDXreg,
 DSIreg,
 DDIreg,
 DSPreg,
 DBPreg,
 DCSreg,
 DSSreg,
 DDSreg,
 DESreg,
 DFSreg,
 DGSreg,
 DImmB,
 DImmBEnter,
 DImmBS,
 DImmW,
 DImmW1, // immediate-16 for 1-byte instructions
 DjmpB,
 DjmpW,
 DmemB,
 DmemW,
 DmemD,
 DindirmodrmW,
 DindirFARmodrmW,
 DmemB1
};

VDMCONTEXT  *g_pThreadContext;
int         g_mode;
char *g_pchOutput;  // the disassembled instruction
char *g_pchExtra;   // contents of memory (if any) modified by this instr.
int prefixes;

//NOTE: if first byte = 0x0f, then the instruction is two bytes long

char *szRegsB[] = {"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh"};
char *szRegsW[] = {"ax", "cx", "dx", "bx", "sp", "bp", "si", "di"};
char *szRegsD[] = {"eax","ecx","edx","ebx","esp","ebp","esi","edi"};
char *szRegsSeg[] = {"es", "cs", "ss", "ds", "fs", "gs", "(bad)", "(bad)"};
char *szMod[]   = {"[bx+si", "[bx+di", "[bp+si", "[bp+di", "[si", "[di", "[bp", "[bx"};

#define PREFIX_REPZ 1
#define PREFIX_REPNZ 2
#define PREFIX_LOCK 4
#define PREFIX_CS 8
#define PREFIX_SS 0x10
#define PREFIX_DS 0x20
#define PREFIX_ES 0x40
#define PREFIX_FS 0x80
#define PREFIX_GS 0x100
#define PREFIX_DATA 0x200
#define PREFIX_ADR 0x400
#define PREFIX_FWAIT 0x800

#define GROUP_1B    -1
#define GROUP_1WS   -2
#define GROUP_1W    -3
#define GROUP_2B    -4
#define GROUP_2W    -5
#define GROUP_2B_1  -6
#define GROUP_2W_1  -7
#define GROUP_2B_CL -8
#define GROUP_2W_CL -9
#define GROUP_3B    -10
#define GROUP_3W    -11
#define GROUP_4     -12
#define GROUP_5     -13
#define GROUP_6     -14
#define GROUP_7     -15
#define GROUP_8     -16

#define FLOATCODE   -51
#define FLOAT       FLOATCODE

// WARNING: This list must remain in sync with the szInstructions[] array
#define szAdc   1
#define szAdd   2
#define szAnd   3
#define szBad   4
#define szCmp   5
#define szDec   6
#define szIn    7
#define szInc   8
#define szJmp   9
#define szMov   10
#define szOr    11
#define szOut   12
#define szRcl   13
#define szRcr   14
#define szRol   15
#define szRor   16
#define szSar   17
#define szSbb   18
#define szShl   19
#define szShr   20
#define szSub   21
#define szTest  22
#define szPop   23
#define szPush  24
#define szXchg  25
#define szXor   26
#define szDaa   27
#define szDas   28
#define szPusha 29
#define szPopa  30
#define szBound 31
#define szArpl  32
#define szAaa   33
#define szAas   34
#define szImul  35
#define szIdiv  36
#define szJo    37
#define szJno   38
#define szJb    39
#define szJae   40
#define szJe    41
#define szJne   42
#define szJbe   43
#define szJa    44
#define szJs    45
#define szJns   46
#define szJp    47
#define szJnp   48
#define szJl    49
#define szJnl   50
#define szJle   51
#define szJg    52
#define szNop   53
#define szLea   54
#define szCbw   55
#define szCwd   56
#define szCall  57
#define szPushf 58
#define szPopf  59
#define szSahf  60
#define szLahf  61
#define szMovsb 62
#define szMovsw 63
#define szCmpsb 64
#define szCmpsw 65
#define szStosb 66
#define szStosw 67
#define szLodsb 68
#define szLodsw 69
#define szScasb 70
#define szScasw 71
#define szRetn  72
#define szLes   73
#define szLds   74
#define szEnter 75
#define szLeave 76
#define szRetf  77
#define szInt3  78
#define szInt   79
#define szInto  80
#define szIret  81
#define szAam   82
#define szAad   83
#define szXlat  84
#define szLoopne 85
#define szLoope 86
#define szLoop  87
#define szJcxz  88
#define szHalt  89
#define szCmc   90
#define szClc   91
#define szStc   92
#define szCli   93
#define szSti   94
#define szCld   95
#define szStd   96
#define szLar   97
#define szLsl   98
#define szClts  99
#define szSeto  100
#define szSetno 101
#define szSetb  102
#define szSetae 103
#define szSete  104
#define szSetne 105
#define szSetbe 106
#define szSeta  107
#define szSets  108
#define szSetns 109
#define szSetp  110
#define szSetnp 111
#define szSetl  112
#define szSetge 113
#define szSetle 114
#define szSetg  115
#define szBt    116
#define szShld  117
#define szBts   118
#define szShrd  119
#define szShdr  120
#define szLss   121
#define szBtr   122
#define szLfs   123
#define szLgs   124
#define szMovzx 125
#define szBtc   126
#define szBsf   127
#define szBsr   128
#define szMovsx 129
#define szNot   130
#define szNeg   131
#define szMul   132
#define szDiv   133
#define szSldt  134
#define szStr   135
#define szLldt  136
#define szLtr   137
#define szVerr  138
#define szVerw  139
#define szSgdt  140
#define szSidt  141
#define szLgdt  142
#define szLidt  143
#define szSmsw  144
#define szLmsw  145

// WARNING: This must stay in sync with the #define list above
char *szInstructions[] = {
    "",     //used to indicate groups
    "adc",
    "add",
    "and",
    "(bad)",
    "cmp",
    "dec",
    "in",
    "inc",
    "jmp",
    // 10
    "mov",
    "or",
    "out",
    "rcl",
    "rcr",
    "rol",
    "ror",
    "sar",
    "sbb",
    "shl",
    // 20
    "shr",
    "sub",
    "test",
    "pop",
    "push",
    "xchg",
    "xor",
    "daa",
    "das",
    "pusha",
    // 30
    "popa",
    "bound",
    "arpl",
    "aaa",
    "aas",
    "imul",
    "idiv",
    "jo",
    "jno",
    "jb",
    // 40
    "jae",
    "je",
    "jne",
    "jbe",
    "ja",
    "js",
    "jns",
    "jp",
    "jnp",
    "jl",
    // 50
    "jnl",
    "jle",
    "jg",
    "nop",
    "lea",
    "cbw",
    "cwd",
    "call",
    "pushf",
    "popf",
    // 60
    "sahf",
    "lahf",
    "movsb",
    "movsw",
    "cmpsb",
    "cmpsw",
    "stosb",
    "stosw",
    "lodsb",
    "lodsw",
    // 70
    "scasb",
    "scasw",
    "retn",
    "les",
    "lds",
    "enter",
    "leave",
    "retf",
    "int3",
    "int",
    // 80
    "into",
    "iret",
    "aam",
    "aad",
    "xlat",
    "loopne",
    "loope",
    "loop",
    "jcxz",
    "halt",
    // 90
    "cmc",
    "clc",
    "stc",
    "cli",
    "sti",
    "cld",
    "std",
    "lar",
    "lsl",
    "clts",
    // 100
    "seto",
    "setno",
    "setb",
    "setae",
    "sete",
    "setne",
    "setbe",
    "seta",
    "sets",
    "setns",
    // 110
    "setp",
    "setnp",
    "setl",
    "setge",
    "setle",
    "setg",
    "bt",
    "shld",
    "bts",
    "shrd",
    // 120
    "shdr",
    "lss",
    "btr",
    "lfs",
    "lgs",
    "movzx",
    "btc",
    "bsf",
    "bsr",
    "movsx",
    // 130
    "not",
    "neg",
    "mul",
    "div",
    "sldt",
    "str",
    "lldt",
    "ltr",
    "verr",
    "verw",
    // 140
    "sgdt",
    "sidt",
    "lgdt",
    "lidt",
    "smsw",
    "lmsw"
};

struct dis {
    int     szName;
    char    iPart1;
    char    iPart2;
    char    iPart3;
};

struct dis dis386[] = {
    // 0
    { szAdd, modrmB, reg1B },
    { szAdd, modrmW, reg1W },
    { szAdd, reg1B, modrmB },
    { szAdd, reg1W, modrmW },
    { szAdd, ALreg, ImmB },
    { szAdd, AXreg, ImmW },
    { szPush, ESreg },
    { szPop, ESreg},
    // 8
    { szOr, modrmB, reg1B },
    { szOr, modrmW, reg1W },
    { szOr, reg1B, modrmB },
    { szOr, reg1W, modrmW },
    { szOr, ALreg, ImmB },
    { szOr, AXreg, ImmW },
    { szPush, CSreg },
    { szBad },                  // 0x0f is the 2-byte instr prefix
    // 10
    { szAdc, modrmB, reg1B },
    { szAdc, modrmW, reg1W },
    { szAdc, reg1B, modrmB },
    { szAdc, reg1W, modrmW },
    { szAdc, ALreg, ImmB },
    { szAdc, AXreg, ImmW },
    { szPush, SSreg },
    { szPop, SSreg },
    // 18
    { szSbb, modrmB, reg1B },
    { szSbb, modrmW, reg1W },
    { szSbb, reg1B, modrmB },
    { szSbb, reg1W, modrmW },
    { szSbb, ALreg, ImmB },
    { szSbb, AXreg, ImmW },
    { szPush, DSreg },
    { szPop, DSreg },
    // 20
    { szAnd, modrmB, reg1B },
    { szAnd, modrmW, reg1W },
    { szAnd, reg1B, modrmB },
    { szAnd, reg1W, modrmW },
    { szAnd, ALreg, ImmB },
    { szAnd, AXreg, ImmW },
    { szBad },                  // ES override prefix
    { szDaa },
    // 28
    { szSub, modrmB, reg1B },
    { szSub, modrmW, reg1W },
    { szSub, reg1B, modrmB },
    { szSub, reg1W, modrmW },
    { szSub, ALreg, ImmB },
    { szSub, AXreg, ImmW },
    { szBad },                  // CS override prefix
    { szDas },
    // 30
    { szXor, modrmB, reg1B },
    { szXor, modrmW, reg1W },
    { szXor, reg1B, modrmB },
    { szXor, reg1W, modrmW },
    { szXor, ALreg, ImmB },
    { szXor, AXreg, ImmW },
    { szBad},                   // SS override prefix
    { szAaa },
    // 38
    { szCmp, modrmB, reg1B },
    { szCmp, modrmW, reg1W },
    { szCmp, reg1B, modrmB },
    { szCmp, reg1W, modrmW },
    { szCmp, ALreg, ImmB },
    { szCmp, AXreg, ImmW },
    { szBad },
    { szAas },
    // 40
    { szInc, AXreg },
    { szInc, CXreg },
    { szInc, DXreg },
    { szInc, BXreg },
    { szInc, SPreg },
    { szInc, BPreg },
    { szInc, SIreg },
    { szInc, DIreg },
    // 48
    { szDec, AXreg },
    { szDec, CXreg },
    { szDec, DXreg },
    { szDec, BXreg },
    { szDec, SPreg },
    { szDec, BPreg },
    { szDec, SIreg },
    { szDec, DIreg },
    // 50
    { szPush, AXreg },
    { szPush, CXreg },
    { szPush, DXreg },
    { szPush, BXreg },
    { szPush, SPreg },
    { szPush, BPreg },
    { szPush, SIreg },
    { szPush, DIreg },
    // 58
    { szPop, AXreg },
    { szPop, CXreg },
    { szPop, DXreg },
    { szPop, BXreg },
    { szPop, SPreg },
    { szPop, BPreg },
    { szPop, SIreg },
    { szPop, DIreg },
    // 60
    { szPusha },
    { szPopa },
    { szBound, reg1W, modrmW },
    { szArpl, reg1W, reg2W },
    { szBad },                  // FS segment override
    { szBad },                  // GS segment override
    { szBad },                  // op size prefix
    { szBad },                  // addr size prefix
    // 68
    { szPush, ImmW},
    { szImul, reg1W, modrmW },
    { szPush, ImmBS},
    { szImul, reg1B, modrmB },
    { szIn, ImmB, DXreg },
    { szIn, ImmW, DXreg },
    { szOut, ImmB, DXreg },
    { szOut, ImmW, DXreg },
    // 70
    { szJo, jmpB },
    { szJno, jmpB },
    { szJb, jmpB },
    { szJae, jmpB },
    { szJe, jmpB },
    { szJne, jmpB },
    { szJbe, jmpB },
    { szJa, jmpB },
    // 78
    { szJs, jmpB },
    { szJns, jmpB },
    { szJp, jmpB },
    { szJnp, jmpB },
    { szJl, jmpB },
    { szJnl, jmpB },
    { szJle, jmpB },
    { szJg, jmpB },
    // 80
    { GROUP_1B },
    { GROUP_1W },
    { szBad },
    { GROUP_1WS },
    { szTest, reg1B, modrmB },
    { szTest, reg1W, modrmW },
    { szXchg, reg1B, modrmB },
    { szXchg, reg1W, modrmW },
    // 88
    { szMov, modrmB, reg1B },
    { szMov, modrmW, reg1W },
    { szMov, reg1B, modrmB  },
    { szMov, reg1W, modrmW },
    { szMov, modrmW, regSeg },
    { szLea, reg1W, modrmW },
    { szMov, regSeg, modrmW },
    { szPop, modrmW },
    // 90
    { szNop },
    { szXchg, AXreg, CXreg },
    { szXchg, AXreg, DXreg },
    { szXchg, AXreg, BXreg },
    { szXchg, AXreg, SPreg },
    { szXchg, AXreg, BPreg },
    { szXchg, AXreg, SIreg },
    { szXchg, AXreg, DIreg },
    // 98
    { szCbw },
    { szCwd },
    { szCall, memD },
    { szBad },
    { szPushf },
    { szPopf },
    { szSahf },
    { szLahf },
    // a0
    { szMov, ALreg, memB },
    { szMov, AXreg, memW },
    { szMov, memB, ALreg },
    { szMov, memW, AXreg },
    { szMovsb },
    { szMovsw },
    { szCmpsb },
    { szCmpsw },
    // a8
    { szTest, ALreg, ImmB },
    { szTest, AXreg, ImmW },
    { szStosb },
    { szStosw },
    { szLodsb },
    { szLodsw },
    { szScasb },
    { szScasw },
    // b0
    { szMov, ALreg, ImmB },
    { szMov, CLreg, ImmB },
    { szMov, DLreg, ImmB },
    { szMov, BLreg, ImmB },
    { szMov, AHreg, ImmB },
    { szMov, CHreg, ImmB },
    { szMov, DHreg, ImmB },
    { szMov, BHreg, ImmB },
    // b8
    { szMov, AXreg, ImmW },
    { szMov, CXreg, ImmW },
    { szMov, DXreg, ImmW },
    { szMov, BXreg, ImmW },
    { szMov, SPreg, ImmW },
    { szMov, BPreg, ImmW },
    { szMov, SIreg, ImmW },
    { szMov, DIreg, ImmW },
    // c0
    { GROUP_2B },
    { GROUP_2W },
    { szRetn, ImmW },
    { szRetn },
    { szLes, reg1W, modrmW },
    { szLds, reg1W, modrmW },
    { szMov, modrmB, ImmB },
    { szMov, modrmW, ImmW },
    // c8
    { szEnter, ImmW, ImmBEnter },
    { szLeave },
    { szRetf, ImmW1 },
    { szRetf },
    { szInt3 },
    { szInt, ImmB },
    { szInto },
    { szIret },
    // d0
    { GROUP_2B_1 },
    { GROUP_2W_1 },
    { GROUP_2B_CL },
    { GROUP_2W_CL },
    { szAam, ImmB },
    { szAad, ImmB },
    { szBad },
    { szXlat },
    // d8
    { FLOAT },
    { FLOAT },
    { FLOAT },
    { FLOAT },
    { FLOAT },
    { FLOAT },
    { FLOAT },
    { FLOAT },
    // e0
    { szLoopne, jmpB },
    { szLoope, jmpB },
    { szLoop, jmpB },
    { szJcxz, jmpB },
    { szIn, ALreg, memB1 },
    { szIn, AXreg, memB1 },
    { szOut, memB1, ALreg },
    { szOut, memB1, AXreg },
    // e8
    { szCall, jmpW },
    { szJmp, jmpW },
    { szJmp, memD },
    { szJmp, jmpB },
    { szIn, ALreg, DXreg },
    { szIn, AXreg, DXreg },
    { szOut, DXreg, ALreg },
    { szOut, DXreg, AXreg },
    // f0
    { szBad },      // lock prefix
    { szBad },
    { szBad },      // repne prefix
    { szBad },      // repz prefix
    { szHalt },
    { szCmc },
    { GROUP_3B },
    { GROUP_3W },
    // f8
    { szClc },
    { szStc },
    { szCli },
    { szSti },
    { szCld },
    { szStd },
    { GROUP_4 },
    { GROUP_5 },
};


struct dis dis386_2[] = {
    // 00
    { GROUP_6 },
    { GROUP_7 },
    { szLar, reg1W, modrmW },
    { szLsl, reg1W, modrmW },
    { szBad },
    { szBad },
    { szClts },
    { szBad },
    // 08
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 10
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 18
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 20
    { szMov, reg2W, eeeControl },
    { szMov, reg2W, eeeDebug },
    { szMov, eeeControl, reg2W },
    { szMov, eeeDebug, reg2W },
    { szMov, reg2W, eeeTest },
    { szBad },
    { szMov, eeeTest, reg2W },
    { szBad },
    // 28
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 30
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 38
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 40
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 48
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 50
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 58
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 60
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 68
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 70
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 78
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // 80
    { szJo, jmpW },
    { szJno, jmpW },
    { szJb, jmpW },
    { szJae, jmpW },
    { szJe, jmpW },
    { szJne, jmpW },
    { szJbe, jmpW },
    { szJa, jmpW },
    // 88
    { szJs, jmpW },
    { szJns, jmpW },
    { szJp, jmpW },
    { szJnp, jmpW },
    { szJl, jmpW },
    { szJnl, jmpW },
    { szJle, jmpW },
    { szJg, jmpW },
    // 90
    { szSeto, modrmB },
    { szSetno, modrmB },
    { szSetb, modrmB },
    { szSetae, modrmB },
    { szSete, modrmB },
    { szSetne, modrmB },
    { szSetbe, modrmB },
    { szSeta, modrmB },
    // 98
    { szSets, modrmB },
    { szSetns, modrmB },
    { szSetp, modrmB },
    { szSetnp, modrmB },
    { szSetl, modrmB },
    { szSetge, modrmB },
    { szSetle, modrmB },
    { szSetg, modrmB },
    // a0
    { szPush, FSreg },
    { szPop, FSreg },
    { szBad },
    { szBt, modrmW, reg1W },
    { szShld, reg1W, modrmW, ImmB },
    { szShld, reg1W, modrmW, CLreg },
    { szBad },
    { szBad },
    // a8
    { szPush, GSreg },
    { szPop, GSreg },
    { szBad },
    { szBts, modrmW, reg1W },
    { szShrd, reg1W, modrmW, ImmB },
    { szShdr, reg1W, modrmW, CLreg },
    { szBad },
    { szImul, reg1W, modrmW },
    // b0
    { szBad },
    { szBad },
    { szLss, reg1W, modrmW },
    { szBtr, modrmW, reg1W },
    { szLfs, reg1W, modrmW },
    { szLgs, reg1W, modrmW },
    { szMovzx, reg1B, modrmB },
    { szMovzx, reg1W, modrmW },
    // b8
    { szBad },
    { szBad },
    { GROUP_8 },
    { szBtc, modrmW, reg1W },
    { szBsf, reg1W, modrmW },
    { szBsr, reg1W, modrmW },
    { szMovsx, reg1B, modrmB },
    { szMovsx, reg1W, modrmW },
    // c0
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // c8
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // d0
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // d8
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // e0
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // e8
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // f0
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    // f8
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
    { szBad },
};

struct dis dis386_groups[][8] = {
    // GROUP_1B
    {
        { szAdd, modrmB, ImmB },
        { szOr,  modrmB, ImmB },
        { szAdc, modrmB, ImmB },
        { szSbb, modrmB, ImmB },
        { szAnd, modrmB, ImmB },
        { szSub, modrmB, ImmB },
        { szXor, modrmB, ImmB },
        { szCmp, modrmB, ImmB }
    },
    // GROUP_1WS
    {
        { szAdd, modrmW, ImmBS },
        { szOr,  modrmW, ImmBS },
        { szAdc, modrmW, ImmBS },
        { szSbb, modrmW, ImmBS },
        { szAnd, modrmW, ImmBS },
        { szSub, modrmW, ImmBS },
        { szXor, modrmW, ImmBS },
        { szCmp, modrmW, ImmBS }
    },
    // GROUP_1W
    {
        { szAdd, modrmW, ImmW },
        { szOr,  modrmW, ImmW },
        { szAdc, modrmW, ImmW },
        { szSbb, modrmW, ImmW },
        { szAnd, modrmW, ImmW },
        { szSub, modrmW, ImmW },
        { szXor, modrmW, ImmW },
        { szCmp, modrmW, ImmW }
    },
    // GROUP_2B
    {
        { szRol, modrmB, ImmB },
        { szRor, modrmB, ImmB },
        { szRcl, modrmB, ImmB },
        { szRcr, modrmB, ImmB },
        { szShl, modrmB, ImmB },
        { szShr, modrmB, ImmB },
        { szBad },
        { szSar, modrmB, ImmB }
    },
    // GROUP_2W
    {
        { szRol, modrmW, ImmB },
        { szRor, modrmW, ImmB },
        { szRcl, modrmW, ImmB },
        { szRcr, modrmW, ImmB },
        { szShl, modrmW, ImmB },
        { szShr, modrmW, ImmB },
        { szBad },
        { szSar, modrmW, ImmB }
    },
    // GROUP_2B_1
    {
        { szRol, modrmB },
        { szRor, modrmB },
        { szRcl, modrmB },
        { szRcr, modrmB },
        { szShl, modrmB },
        { szShr, modrmB },
        { szBad },
        { szSar, modrmB }
    },
    // GROUP_2W_1
    {
        { szRol, modrmW },
        { szRor, modrmW },
        { szRcl, modrmW },
        { szRcr, modrmW },
        { szShl, modrmW },
        { szShr, modrmW },
        { szBad },
        { szSar, modrmW }
    },
    // GROUP_2B_CL
    {
        { szRol, modrmB, CLreg },
        { szRor, modrmB, CLreg },
        { szRcl, modrmB, CLreg },
        { szRcr, modrmB, CLreg },
        { szShl, modrmB, CLreg },
        { szShr, modrmB, CLreg },
        { szBad },
        { szSar, modrmB, CLreg }
    },
    // GROUP_2W_CL
    {
        { szRol, modrmW, CLreg },
        { szRor, modrmW, CLreg },
        { szRcl, modrmW, CLreg },
        { szRcr, modrmW, CLreg },
        { szShl, modrmW, CLreg },
        { szShr, modrmW, CLreg },
        { szBad },
        { szSar, modrmW, CLreg }
    },
    // GROUP_3B
    {
        { szTest, modrmB, ImmB },
        { szBad },
        { szNot, modrmB },
        { szNeg, modrmB },
        { szMul, ALreg, modrmB },
        { szImul, ALreg, modrmB },
        { szDiv, ALreg, modrmB },
        { szIdiv, ALreg, modrmB }
    },
    // GROUP_3W
    {
        { szTest, modrmW, ImmW },
        { szBad },
        { szNot, modrmW },
        { szNeg, modrmW },
        { szMul, AXreg, modrmW },
        { szImul, AXreg, modrmW },
        { szDiv, AXreg, modrmW },
        { szIdiv, AXreg, modrmW }
    },
    // GROUP_4
    {
        { szInc, modrmB },
        { szDec, modrmB },
        { szBad },
        { szBad },
        { szBad },
        { szBad },
        { szBad },
        { szBad }
    },
    // GROUP_5
    {
        { szInc, modrmW },
        { szDec, modrmW },
        { szCall, indirmodrmW },
        { szCall, indirFARmodrmW },
        { szJmp, indirmodrmW },
        { szJmp, indirFARmodrmW },
        { szPush, modrmW },
        { szBad }
    },
    // GROUP_6
    {
        { szSldt, modrmW },
        { szStr, modrmW },
        { szLldt, modrmW },
        { szLtr, modrmW },
        { szVerr, modrmW },
        { szVerw, modrmW },
        { szBad },
        { szBad }
    },
    // GROUP_7
    {
        { szSgdt, modrmW },
        { szSidt, modrmW },
        { szLgdt, modrmW },
        { szLidt, modrmW },
        { szSmsw, modrmW },
        { szBad },
        { szLmsw, modrmW },
        { szBad }
    },
    // GROUP_8
    {
        { szBad },
        { szBad },
        { szBad },
        { szBad },
        { szBt, modrmW, ImmB },
        { szBts, modrmW, ImmB },
        { szBtr, modrmW, ImmB },
        { szBtc, modrmW, ImmB }
    }
};

UCHAR OpcodeSize;
BYTE *pData;
ADDR g_InstrAddr;
BOOL bBig;

void AppendString(char *str)
{
    strcpy(g_pchOutput, (str));
    g_pchOutput+=strlen(g_pchOutput);
}

void ExtraString(char *str)
{
    strcpy(g_pchExtra, (str));
    g_pchExtra+=strlen(g_pchExtra);
}

#define AppendChar(c)      {*g_pchOutput++ = (c);}
#define AppendNumber(d) {_ultoa((ULONG)d,g_pchOutput, 16); g_pchOutput+=strlen(g_pchOutput);}

#define ExtraChar(c)       {*g_pchExtra++ = (c);}
#define ExtraNumber(d)     {_ultoa((ULONG)d,g_pchExtra, 16); g_pchExtra+=strlen(g_pchExtra);}
#define OPERAND_32 ((prefixes & PREFIX_DATA) ^ bBig)
#define ADDR_32 ((prefixes & PREFIX_ADR) ^ bBig)

int unassemble_one(
    BYTE        *pInstrStart,   // instruction to decode (can be local buffer)
    BOOL            bDefaultBig,
    WORD            wInstrSeg,      // selector of instruction
    DWORD       dwInstrOff,     // offset of instruction
    char        *pchOutput,     // [out] disassembled instruction
    char        *pchExtra,      // [out] extra info (ie. "es:[53]=1234")
                                //       (can be NULL)
    VDMCONTEXT  *pThreadContext,
    int         mode
) {
    int         i;
    int         cb;
    BYTE        *pInstr = pInstrStart;
    struct dis      *pszDecode;

    g_pThreadContext = pThreadContext;
    g_mode = mode;

    g_pchOutput = pchOutput;
    g_InstrAddr.sSeg = wInstrSeg;
    g_InstrAddr.sOff = dwInstrOff;
    bBig = bDefaultBig;

    gMode = mode;
    gSelector = wInstrSeg;
    gOffset = dwInstrOff;

    if (pchExtra)
        *pchExtra = '\0';

    g_pchExtra = pchExtra;

    if (*(UNALIGNED USHORT*)pInstr == 0xc4c4) {
        pData = pInstr;
        pData+=2;
        return DisplayBOP();
    }

    pInstr = checkprefixes(pInstr);

    OpcodeSize = 1;

    if (*pInstr == 0x0f) {
        OpcodeSize++;
        pInstr++;
        pszDecode = &dis386_2[*pInstr];
    } else {
        pszDecode = &dis386[*pInstr];
    }

    if (prefixes & PREFIX_REPZ)
        AppendString("repz ");
    if (prefixes & PREFIX_REPNZ)
        AppendString("repnz ");
    if (prefixes & PREFIX_LOCK)
        AppendString("lock ");
    if ((prefixes & PREFIX_FWAIT) && ((*pInstr < 0xd8) || (*pInstr > 0xdf))) {
        /* fwait not followed by floating point instruction */
        AppendString("fwait");
        return (1);
    }

    pInstr++;
    pData = pInstr;
    if (pszDecode->szName < 0) {    // found a GROUP_ or FLOAT entry...
        i = (-pszDecode->szName)-1;
        if (pszDecode->szName == FLOATCODE) {
            AppendString("*float* ");
            //Later: mputs("Floating point instructions NYI\n");
            return 1;
        } else {
            pszDecode = &dis386_groups[i][(*pInstr>>3)&7];
        }
    }

    AppendString(szInstructions[pszDecode->szName]);

    if (pszDecode->iPart1) {

        AppendChar('\t');

        i = (*(rgpfn[pszDecode->iPart1].pfn))(pInstr);

        if (pszDecode->iPart2) {

            AppendString(", ");
            i+=(*(rgpfn[pszDecode->iPart2].pfn))(pInstr);

            if (pszDecode->iPart3) {

                AppendString(", ");
                i+=(*(rgpfn[pszDecode->iPart3].pfn))(pInstr);

            }
        }

        pInstr+=i;
    }

    AppendChar('\0');
    cb = pInstr - pInstrStart;    // return length of instruction

    return cb;
}

BOOL safe_read_byte(
    ADDR        addr,
    BYTE        *pb
) {
    ULONG       Base;

    *pb = 0xbb;
    Base = GetInfoFromSelector( addr.sSeg, g_mode, NULL );
    if (Base == (ULONG)-1 || Base == 0) {
    return FALSE;
    }

    Base += GetIntelBase();

    return READMEM((LPVOID)(Base+(ULONG)addr.sOff), pb, 1);
}

BOOL safe_read_short(
    ADDR        addr,
    SHORT       *ps
) {
    ULONG       Base;

    Base = GetInfoFromSelector( addr.sSeg, g_mode, NULL );
    if (Base == (ULONG)-1 || Base == 0) {
    return FALSE;
    }

    Base += GetIntelBase();

    return READMEM((LPVOID)(Base+(ULONG)addr.sOff), ps, 2);
}

BOOL safe_read_long(
    ADDR        addr,
    LONG        *pl
) {
    ULONG       Base;

    Base = GetInfoFromSelector( addr.sSeg, g_mode, NULL );
    if (Base == (ULONG)-1 || Base == 0) {
    return FALSE;
    }

    Base += GetIntelBase();

    return READMEM((LPVOID)(Base+(ULONG)addr.sOff), pl, 4);
}


int Dreg1B(LPBYTE lpB)
{
    BYTE b = (*lpB >> 3) & 7;

    AppendString(szRegsB[b]);

    return 0;
}

int Dreg1W(LPBYTE lpB)
{
    BYTE b = (*lpB >> 3) & 7;

    if (OPERAND_32)
        AppendString(szRegsD[b]);
    else
        AppendString(szRegsW[b]);

    return 0;
}

int Dreg2B(LPBYTE lpB)
{
    BYTE b = *lpB & 7;

    AppendString(szRegsB[b]);

    return 0;
}

int Dreg2W(LPBYTE lpB)
{
    BYTE b = *lpB & 7;

    if (OPERAND_32)
        AppendString(szRegsD[b]);
    else
        AppendString(szRegsW[b]);

    return 0;
}

int DmodrmB(LPBYTE lpB)
{
    BYTE rm = *lpB & 0x07;
    BYTE mod = *lpB >> 6;
    unsigned short num;
    int iRet;

    pData++;                                // skip past mod r/m
    if (mod == 3) {
        AppendPrefixes();
        AppendString(szRegsB[rm]);
        return 1;
    }

    iRet = 0;
    AppendString("byte ptr ");
    AppendPrefixes();
    AppendString(szMod[rm]);
    AppendChar('+');

    switch (mod) {
        case 0:
            if (rm == 6) {
                g_pchOutput-=3; // back up over the 'BP+'
                num = *((UNALIGNED USHORT*)pData);
                AppendNumber(num);
                pData+=2;
                iRet = 3;
            } else {
                num = 0;
                g_pchOutput--;
                iRet = 1;
            }
            break;

        case 1:
            num = *pData;
            AppendNumber(num);
            pData++;
            iRet = 2;
            break;

        case 2:
            num = *((UNALIGNED USHORT*)pData);
            AppendNumber(num);
            pData += 2;
            iRet = 3;
            break;
    }

    AppendChar(']');

    DisplayAddress(mod, rm, num, 1);

    return iRet;
}

int DmodrmW(LPBYTE lpB)
{
    BYTE rm = *lpB & 0x07;
    BYTE mod = *lpB >> 6;
    ULONG num;
    int iRet;

    pData++;                                // skip past mod r/m
    AppendPrefixes();

    if (mod == 3) {
        if (OPERAND_32)
            AppendString(szRegsD[rm]);
        else
            AppendString(szRegsW[rm]);
        return 1;
    }

    if (ADDR_32) {
        AppendChar('[');
        AppendString(szRegsD[rm]);
    } else {
        AppendString(szMod[rm]);
    }
    AppendChar('+');

    switch (mod) {
        case 0:
            //
            // Handle special cases of ModRM
            //
            if ((rm == 6) && !ADDR_32) {
                g_pchOutput-=3; // back up over 'BP+'
                num = *((UNALIGNED USHORT*)pData);
                AppendNumber(num);
                pData+=2;
                iRet = 3;
            } else if ((rm == 5) && ADDR_32) {
                g_pchOutput-=4; // back up over 'EBP+'
                num = *((UNALIGNED ULONG*)pData);
                AppendNumber(num);
                pData+=4;
                iRet = 5;
            } else {
                g_pchOutput--;  // else back up over '+' alone
                num=0;
                iRet = 1;
            }
            break;

        case 1:
            num = *pData;
            AppendNumber(num);
            pData++;
            iRet = 2;
            break;

        case 2:
            num = *((UNALIGNED USHORT *)pData);
            AppendNumber(num);
            pData+=2;
            iRet = 3;
            break;
    }

    AppendChar(']');

    DisplayAddress(mod, rm, num, ADDR_32 ? 4 : 2);

    return iRet;
}


void DisplayAddress(int mod, int rm, int sOff, int size)
{
    ADDR addr;

    // if caller of unassemble_one() didn't want extra info, return now
    if (g_pchExtra == NULL)
    return;

    // no memory reference
    if (mod == 3)
    return;

    // display prefix

    if (prefixes & PREFIX_DS) {
    ExtraChar('D');
    addr.sSeg = (USHORT)g_pThreadContext->SegDs;
    } else if (prefixes & PREFIX_ES) {
    ExtraChar('E');
    addr.sSeg = (USHORT)g_pThreadContext->SegEs;
    } else if (prefixes & PREFIX_FS) {
    ExtraChar('F');
    addr.sSeg = (USHORT)g_pThreadContext->SegFs;
    } else if (prefixes & PREFIX_GS) {
    ExtraChar('G');
    addr.sSeg = (USHORT)g_pThreadContext->SegGs;
    } else if (prefixes & PREFIX_CS) {
    ExtraChar('C');
    addr.sSeg = (USHORT)g_pThreadContext->SegCs;
    } else if ( (prefixes & PREFIX_SS) || rm==2 || rm == 3) {
    ExtraChar('S');
    addr.sSeg = (USHORT)g_pThreadContext->SegSs;
    } else if (rm == 6 && mod != 0) {
    ExtraChar('S');
    addr.sSeg = (USHORT)g_pThreadContext->SegSs;
    } else {
    ExtraChar('D');
    addr.sSeg = (USHORT)g_pThreadContext->SegDs;
    }

    ExtraString("S:[");

    switch (rm) {
    case 0:
        addr.sOff = (USHORT)(g_pThreadContext->Ebx + g_pThreadContext->Esi);
        break;

    case 1:
        addr.sOff = (USHORT)(g_pThreadContext->Ebx + g_pThreadContext->Edi);
        break;

    case 2:
        addr.sOff = (USHORT)(g_pThreadContext->Ebp + g_pThreadContext->Esi);
        break;

    case 3:
        addr.sOff = (USHORT)(g_pThreadContext->Ebp + g_pThreadContext->Edi);
        break;

    case 4:
        addr.sOff = (USHORT)g_pThreadContext->Esi;
        break;

    case 5:
        addr.sOff = (USHORT)g_pThreadContext->Edi;
        break;

    case 6:
        if (mod == 0)
        addr.sOff = 0;
        else
        addr.sOff = (USHORT)g_pThreadContext->Ebp;
        break;

    default:
        addr.sOff = (USHORT)g_pThreadContext->Ebx;

    }

    addr.sOff += sOff;
    ExtraNumber(addr.sOff);
    ExtraString("]=");
    if (size == 2) {
    SHORT s;
    if (safe_read_short(addr, &s)) {
        ExtraNumber( s );
    } else {
        ExtraString("????");
    }
    } else if (size == 1) {
    BYTE b;
    if (safe_read_byte(addr, &b)) {
        ExtraNumber( b );
    } else {
        ExtraString("??");
    }
    } else if (size == 4) {
    LONG l;
    if (safe_read_long(addr, &l)) {
        ExtraNumber( l );
    } else {
        ExtraString("????????");
    }
    } else {
    ExtraString("Unknown size!");
    }
}

int DisplayBOP(void)
{
    UCHAR mjcode;
    int InstSize = 3;

    AppendString("BOP   ");

    mjcode = *((UCHAR *)pData);
    pData++;
    AppendNumber(mjcode);

    switch (mjcode) {
    case 0x50:
    case 0x52:
    case 0x53:
    case 0x54:
    case 0x58:
        //
        // This BOP has a minor function code
        //
        InstSize++;
        AppendString(", ");
        AppendNumber(*((UCHAR *)pData));
    }
    return InstSize;
}

int DALreg(LPBYTE lpB)
{
    AppendString("al");

    return 0;
}

int DAHreg(LPBYTE lpB)
{
    AppendString("ah");

    return 0;
}

int DBLreg(LPBYTE lpB)
{
    AppendString("bl");

    return 0;
}

int DBHreg(LPBYTE lpB)
{
    AppendString("bh");

    return 0;
}

int DCLreg(LPBYTE lpB)
{
    AppendString("cl");

    return 0;
}

int DCHreg(LPBYTE lpB)
{
    AppendString("ch");

    return 0;
}

int DDLreg(LPBYTE lpB)
{
    AppendString("dl");

    return 0;
}

int DDHreg(LPBYTE lpB)
{
    AppendString("dh");

    return 0;
}

int DAXreg(LPBYTE lpB)
{
    if (OPERAND_32)
        AppendChar('e');

    AppendString("ax");

    return 0;
}

int DBXreg(LPBYTE lpB)
{
    if (OPERAND_32)
        AppendChar('e');

    AppendString("bx");

    return 0;
}

int DCXreg(LPBYTE lpB)
{
    if (OPERAND_32)
        AppendChar('e');

    AppendString("cx");

    return 0;
}

int DDXreg(LPBYTE lpB)
{
    if (OPERAND_32)
        AppendChar('e');

    AppendString("dx");

    return 0;
}

int DBPreg(LPBYTE lpB)
{
    if (OPERAND_32)
        AppendChar('e');

    AppendString("bp");

    return 0;
}

int DSPreg(LPBYTE lpB)
{
    if (OPERAND_32)
        AppendChar('e');

    AppendString("sp");

    return 0;
}

int DSIreg(LPBYTE lpB)
{
    if (OPERAND_32)
        AppendChar('e');

    AppendString("si");

    return 0;
}

int DDIreg(LPBYTE lpB)
{
    if (OPERAND_32)
        AppendChar('e');

    AppendString("di");

    return 0;
}

int DCSreg(LPBYTE lpB)
{
    AppendString("cs");

    return 0;
}

int DDSreg(LPBYTE lpB)
{
    AppendString("ds");

    return 0;
}

int DSSreg(LPBYTE lpB)
{
    AppendString("es");

    return 0;
}

int DESreg(LPBYTE lpB)
{
    AppendString("es");

    return 0;
}

int DFSreg(LPBYTE lpB)
{
    AppendString("fs");

    return 0;
}

int DGSreg(LPBYTE lpB)
{
    AppendString("gs");

    return 0;
}

int DImmB(LPBYTE lpB)
{
    AppendNumber(*((UCHAR *)pData));
    pData++;

    return 1;
}

int DImmBEnter(LPBYTE lpB)
{
    AppendNumber(*((UCHAR *)pData));
    pData++;

    return 1;
}

int DImmBS(LPBYTE lpB)  // sign-extend 8-bit value to 16 bits
{
    int i = (signed char)*(pData);

    AppendNumber((USHORT)i);
    pData++;

    return 1;
}

int DImmW(LPBYTE lpB)
{
    if (OPERAND_32) {

            AppendNumber( *((UNALIGNED ULONG*)pData) );
            pData+=4;
            return 4;

        } else {

            AppendNumber( *((UNALIGNED USHORT*)pData) );
            pData+=2;
            return 2;

        }
}

int DImmW1(LPBYTE lpB)
{
    AppendNumber( *((UNALIGNED SHORT*)(pData)) );
    pData++;

    return 2;
}

int DjmpB(LPBYTE lpB)
{
    ULONG Dest = g_InstrAddr.sOff + (LONG)*((UNALIGNED CHAR *)lpB) + OpcodeSize + 1;

    if (OPERAND_32) {
        AppendNumber(Dest);
    } else {
        AppendNumber((USHORT)Dest);
    }

    return 1;
}

int DjmpW(LPBYTE lpB)
{

    if (OPERAND_32) {
        AppendNumber(g_InstrAddr.sOff + *((UNALIGNED ULONG *)lpB) + OpcodeSize + 4);
        return 4;
    } else {
        AppendNumber(LOWORD(g_InstrAddr.sOff + (ULONG)*((UNALIGNED USHORT *)lpB) + OpcodeSize + 2));
        return 2;
    }
}

int DregSeg(LPBYTE lpB)
{
    BYTE b = (*lpB >> 3) & 7;

    AppendString(szRegsSeg[b]);

    return 0;
}


int DmemB(LPBYTE lpB)
{
    ADDR addr;

    addr.sOff = *(lpB+1);

    AppendChar('[');
    AppendNumber( addr.sOff );
    AppendChar(']');

    if (g_pchExtra) {
        BYTE b;

        if (prefixes & PREFIX_DS) {
            ExtraChar('D');
            addr.sSeg = (USHORT)g_pThreadContext->SegDs;
        } else if (prefixes & PREFIX_ES) {
            ExtraChar('E');
            addr.sSeg = (USHORT)g_pThreadContext->SegEs;
        } else if (prefixes & PREFIX_FS) {
            ExtraChar('F');
            addr.sSeg = (USHORT)g_pThreadContext->SegFs;
        } else if (prefixes & PREFIX_GS) {
            ExtraChar('G');
            addr.sSeg = (USHORT)g_pThreadContext->SegGs;
        } else if (prefixes & PREFIX_CS) {
            ExtraChar('C');
            addr.sSeg = (USHORT)g_pThreadContext->SegCs;
        } else if (prefixes & PREFIX_SS) {
            ExtraChar('S');
            addr.sSeg = (USHORT)g_pThreadContext->SegSs;
        } else {
            ExtraChar('D');
            addr.sSeg = (USHORT)g_pThreadContext->SegDs;
        }

        ExtraString("S:[");
        ExtraNumber( addr.sOff );
        ExtraString("]=");
        if (safe_read_byte(addr, &b)) {
            ExtraNumber( b );
        } else {
            ExtraString("??");
        }

    }

    return 1;
}

int DmemB1(LPBYTE lpB)
{
    AppendNumber( *lpB );

    return 1;
}

int DmemW(LPBYTE lpB)
{
    int i;
    ADDR addr;

    addr.sOff = *(lpB+1);

    AppendChar('[');
    if (ADDR_32) {
        AppendNumber( *((UNALIGNED long*)lpB) );
        i=4;
    } else {
        addr.sOff = *((UNALIGNED short *)lpB);
        AppendNumber( addr.sOff );
        i=2;
    }
    AppendChar(']');

    if (g_pchExtra) {

        if (prefixes & PREFIX_DS) {
            ExtraChar('D');
            addr.sSeg = (USHORT)g_pThreadContext->SegDs;
        } else if (prefixes & PREFIX_ES) {
            ExtraChar('E');
            addr.sSeg = (USHORT)g_pThreadContext->SegEs;
        } else if (prefixes & PREFIX_FS) {
            ExtraChar('F');
            addr.sSeg = (USHORT)g_pThreadContext->SegFs;
        } else if (prefixes & PREFIX_GS) {
            ExtraChar('G');
            addr.sSeg = (USHORT)g_pThreadContext->SegGs;
        } else if (prefixes & PREFIX_CS) {
            ExtraChar('C');
            addr.sSeg = (USHORT)g_pThreadContext->SegCs;
        } else if (prefixes & PREFIX_SS) {
            ExtraChar('S');
            addr.sSeg = (USHORT)g_pThreadContext->SegSs;
        } else {
            ExtraChar('D');
            addr.sSeg = (USHORT)g_pThreadContext->SegDs;
        }

        ExtraString("S:[");
        ExtraNumber( addr.sOff );
        ExtraString("]=");
        if (i == 2) {
            SHORT s;
            if (safe_read_short(addr, &s)) {
                ExtraNumber( s );
            } else {
                ExtraString( "????" );
            }
        } else {
            LONG l;

            if (safe_read_long(addr, &l)) {
                ExtraNumber( l );
            } else {
                ExtraString( "????????" );
            }
        }
    }

    return i;
}


int DmemD(LPBYTE lpB)
{
    int i;

    if (OPERAND_32) {
        AppendNumber( *(((UNALIGNED SHORT*)lpB)+2) );
        AppendChar(':');
        AppendNumber( *((UNALIGNED long*)lpB) );
        i=6;
    } else {
        USHORT sel, off;

        sel = *(((UNALIGNED SHORT*)lpB)+1);
        off = *((UNALIGNED SHORT*)lpB);
        AppendNumber( sel );
        AppendChar(':');
        AppendNumber( off );
        i=4;

        if (g_pchExtra) {
            char sym_text[1000];
            LONG dist;

            // if the exact symbol name was found, print it
            if (FindSymbol(   sel,
                   off,
                   sym_text,
                   &dist,
                   BEFORE,
                   g_mode)) {
                ExtraString("= ");
                ExtraString(sym_text);
                if (dist) {
                    ExtraString(" + ");
                    ExtraNumber( dist );
                }
            }
        }

    }

    return i;
}

int DindirmodrmW(LPBYTE lpB)
{
    int i;

    AppendString("FAR PTR ");
    i = DmodrmW(lpB);
    AppendChar(']');

    return i;
}


int DindirFARmodrmW(LPBYTE lpB)
{
    int i;

    AppendString("FAR PTR ");
    i = DmodrmW(lpB);
    AppendChar(']');

    return i;
}


int DeeeControl(LPBYTE lpB)
{
    AppendChar('c');
    AppendChar('r');
    AppendChar('0'+ ((*lpB >> 3) & 7) );

    return 1;
}

int DeeeDebug(LPBYTE lpB)
{
    AppendChar('d');
    AppendChar('r');
    AppendChar('0'+ ((*lpB >> 3) & 7) );

    return 1;
}

int DeeeTest(LPBYTE lpB)
{
    AppendChar('t');
    AppendChar('r');
    AppendChar('0'+ ((*lpB >> 3) & 7) );

    return 1;
}


LPBYTE checkprefixes(LPBYTE lpB)
{
    prefixes = 0;

    for (;;) {

        switch (*lpB) {
            case 0xf3:
                prefixes |= PREFIX_REPZ;
                break;
            case 0xf2:
                prefixes |= PREFIX_REPNZ;
                break;
            case 0xf0:
                prefixes |= PREFIX_LOCK;
                break;
            case 0x2e:
                prefixes |= PREFIX_CS;
                break;
            case 0x36:
                prefixes |= PREFIX_SS;
                break;
            case 0x3e:
                prefixes |= PREFIX_DS;
                break;
            case 0x26:
                prefixes |= PREFIX_ES;
                break;
            case 0x64:
                prefixes |= PREFIX_FS;
                break;
            case 0x65:
                prefixes |= PREFIX_GS;
                break;
            case 0x66:
                prefixes |= PREFIX_DATA;
                break;
            case 0x67:
                prefixes |= PREFIX_ADR;
                break;
            case 0x9b:
                prefixes |= PREFIX_FWAIT;
                break;
            default:
                return lpB;
        }
    lpB++;
    }
}


void AppendPrefixes(void)
{
    if (prefixes & PREFIX_CS)
        AppendString("cs:");
    if (prefixes & PREFIX_DS)
        AppendString("ds:");
    if (prefixes & PREFIX_SS)
        AppendString("ss:");
    if (prefixes & PREFIX_ES)
        AppendString("es:");
    if (prefixes & PREFIX_FS)
        AppendString("fs:");
    if (prefixes & PREFIX_GS)
        AppendString("gs:");
}