/*** ntreg.c - processor-specific register structures
*
*   Copyright <C> 1990, Microsoft Corporation
*
*   Purpose:
*       Structures used to parse and access register and flag
*       fields.
*
*   Revision History:
*
*   [-]  01-Jul-1990 Richk      Created.
*
*************************************************************************/

#include <conio.h>
#include <string.h>
#include "ntsdp.h"
#include "86reg.h"
#if defined(KERNEL) && defined(i386)
#include <ntos.h>
#endif

#if defined(KERNEL) && defined(i386)
#include <ntos.h>
extern USHORT NtsdCurrentProcessor;
extern ULONG NumberProcessors;
extern BOOLEAN fSetGlobalDataBrkpts;
extern BOOLEAN fSwitched;
USHORT PreviousProcessor;
VDMCONTEXT SavedRegisterContext;
extern  BOOLEAN KdVerbose;                      //  from ntsym.c
#define fVerboseOutput KdVerbose
#endif

#define DPRINT(str) if (fVerboseOutput) dprintf str


extern  ADDR    EAaddr[2];              // from module ntdis.c
extern  ulong   EXPRLastExpression;     // from module ntexpr.c
extern  ulong   EXPRLastDump;           // from module ntcmd.c
extern  BOOLEAN STtrace;                // from module ntcmd.c
extern  ULONG   STeip, STebp, STesp;    // from module ntcmd.c
extern  int     fControlC;

extern  PUCHAR  UserRegs[10];

BOOLEAN X86fDelayInstruction(void);
void    X86OutputHelp(void);
#if defined(KERNEL) && defined(i386)
BOOLEAN fTraceFlag;
void    InitFirCache(ULONG, PUCHAR);
void    SaveProcessorState(void);
void    RestoreProcessorState(void);
BOOLEAN X86GetTraceFlag(void);
extern  NTSTATUS TaskGate2TrapFrame(USHORT, PKTRAP_FRAME, PULONG);
extern  NTSTATUS ReadTrapFrame(ULONG, PKTRAP_FRAME);
extern  DbgKdInitVirtualCacheEntry (ULONG, ULONG, PUCHAR);
#endif
ULONG   GetDregValue(ULONG);
void    SetDregValue(ULONG, ULONG);
void    X86ClearTraceFlag(void);
void    X86SetTraceFlag(void);

PUCHAR  X86RegNameFromIndex(ULONG);

extern PUCHAR  pchCommand;    //  current pointer in command buffer

#if defined(KERNEL) && defined(i386)
KSPECIAL_REGISTERS SpecialRegContext, SavedSpecialRegContext;
ULONG   TerseLevel = 1;
#endif

ULONG   VDMcbBrkptLength = 1L;
ULONG   VDMtrapInstr = 0xcc;
#if     !defined(KERNEL) && defined(i386)
ULONG   VDMContextType = VDMCONTEXT_CONTROL | VDMCONTEXT_INTEGER | VDMCONTEXT_SEGMENTS
                                      | VDMCONTEXT_DEBUG_REGISTERS;
#else
ULONG   VDMContextType = VDMCONTEXT_CONTROL | VDMCONTEXT_INTEGER | VDMCONTEXT_SEGMENTS;
#endif

#if defined(KERNEL) && defined(i386)
ULONG   contextState, SavedContextState;
#define CONTEXTNONE     5       //  no context
#define CONTEXTFIR      0       //  only unchanged FIR in context
#define CONTEXTVALID    1       //  full, but unchanged context
#define CONTEXTDIRTY    2       //  full, but changed context
#define CONTEXTSHORT    3       //  short context loaded (unchanged)
#define CONTEXTHALF     4       //  half context loaded


UCHAR FullContextPresent[] = { FALSE, TRUE, TRUE, FALSE, FALSE };
#endif

char    szGsReg[]    = "gs";
char    szFsReg[]    = "fs";
char    szEsReg[]    = "es";
char    szDsReg[]    = "ds";
char    szEdiReg[]   = "edi";
char    szEsiReg[]   = "esi";
char    szEbxReg[]   = "ebx";
char    szEdxReg[]   = "edx";
char    szEcxReg[]   = "ecx";
char    szEaxReg[]   = "eax";
char    szEbpReg[]   = "ebp";
char    szEipReg[]   = "eip";
char    szCsReg[]    = "cs";
char    szEflReg[]   = "efl";
char    szEspReg[]   = "esp";
char    szSsReg[]    = "ss";
#if defined(KERNEL) && defined(i386)
char    szCr0Reg[]   = "cr0";
char    szCr2Reg[]   = "cr2";
char    szCr3Reg[]   = "cr3";
char    szCr4Reg[]   = "cr4";
char    szDr0Reg[]   = "dr0";
char    szDr1Reg[]   = "dr1";
char    szDr2Reg[]   = "dr2";
char    szDr3Reg[]   = "dr3";
char    szDr6Reg[]   = "dr6";
char    szDr7Reg[]   = "dr7";
char    szGdtrReg[]  = "gdtr";
char    szGdtlReg[]  = "gdtl";
char    szIdtrReg[]  = "idtr";
char    szIdtlReg[]  = "idtl";
char    szTrReg[]    = "tr";
char    szLdtrReg[]  = "ldtr";
#endif
char    szDiReg[]    = "di";
char    szSiReg[]    = "si";
char    szBxReg[]    = "bx";
char    szDxReg[]    = "dx";
char    szCxReg[]    = "cx";
char    szAxReg[]    = "ax";
char    szBpReg[]    = "bp";
char    szIpReg[]    = "ip";
char    szFlReg[]    = "fl";
char    szSpReg[]    = "sp";
char    szBlReg[]    = "bl";
char    szDlReg[]    = "dl";
char    szClReg[]    = "cl";
char    szAlReg[]    = "al";
char    szBhReg[]    = "bh";
char    szDhReg[]    = "dh";
char    szChReg[]    = "ch";
char    szAhReg[]    = "ah";
char    szIoplFlag[] = "iopl";
char    szFlagOf[]   = "of";
char    szFlagDf[]   = "df";
char    szFlagIf[]   = "if";
char    szFlagTf[]   = "tf";
char    szFlagSf[]   = "sf";
char    szFlagZf[]   = "zf";
char    szFlagAf[]   = "af";
char    szFlagPf[]   = "pf";
char    szFlagCf[]   = "cf";
char    szFlagVip[]  = "vip";
char    szFlagVif[]  = "vif";

extern  char    szEaPReg[];
extern  char    szExpPReg[];
extern  char    szRaPReg[];
extern  char    szPPReg[];
extern  char    szU0Preg[];
extern  char    szU1Preg[];
extern  char    szU2Preg[];
extern  char    szU3Preg[];
extern  char    szU4Preg[];
extern  char    szU5Preg[];
extern  char    szU6Preg[];
extern  char    szU7Preg[];
extern  char    szU8Preg[];
extern  char    szU9Preg[];

struct Reg regname[] = {
        { szGsReg,    REGGS    },
        { szFsReg,    REGFS    },
        { szEsReg,    REGES    },
        { szDsReg,    REGDS    },
        { szEdiReg,   REGEDI   },
        { szEsiReg,   REGESI   },
        { szEbxReg,   REGEBX   },
        { szEdxReg,   REGEDX   },
        { szEcxReg,   REGECX   },
        { szEaxReg,   REGEAX   },
        { szEbpReg,   REGEBP   },
        { szEipReg,   REGEIP   },
        { szCsReg,    REGCS    },
        { szEflReg,   REGEFL   },
        { szEspReg,   REGESP   },
        { szSsReg,    REGSS    },
#if defined(KERNEL) && defined(i386)
        { szCr0Reg,   REGCR0   },
        { szCr2Reg,   REGCR2   },
        { szCr3Reg,   REGCR3   },
        { szCr4Reg,   REGCR4   },
        { szDr0Reg,   REGDR0   },
        { szDr1Reg,   REGDR1   },
        { szDr2Reg,   REGDR2   },
        { szDr3Reg,   REGDR3   },
        { szDr6Reg,   REGDR6   },
        { szDr7Reg,   REGDR7   },
        { szGdtrReg,  REGGDTR  },
        { szGdtlReg,  REGGDTL  },
        { szIdtrReg,  REGIDTR  },
        { szIdtlReg,  REGIDTL  },
        { szTrReg,    REGTR    },
        { szLdtrReg,  REGLDTR  },
#endif
        { szDiReg,    REGDI    },
        { szSiReg,    REGSI    },
        { szBxReg,    REGBX    },
        { szDxReg,    REGDX    },
        { szCxReg,    REGCX    },
        { szAxReg,    REGAX    },
        { szBpReg,    REGBP    },
        { szIpReg,    REGIP    },
        { szFlReg,    REGFL    },
        { szSpReg,    REGSP    },
        { szBlReg,    REGBL    },
        { szDlReg,    REGDL    },
        { szClReg,    REGCL    },
        { szAlReg,    REGAL    },
        { szBhReg,    REGBH    },
        { szDhReg,    REGDH    },
        { szChReg,    REGCH    },
        { szAhReg,    REGAH    },
        { szIoplFlag, FLAGIOPL },
        { szFlagOf,   FLAGOF   },
        { szFlagDf,   FLAGDF   },
        { szFlagIf,   FLAGIF   },
        { szFlagTf,   FLAGTF   },
        { szFlagSf,   FLAGSF   },
        { szFlagZf,   FLAGZF   },
        { szFlagAf,   FLAGAF   },
        { szFlagPf,   FLAGPF   },
        { szFlagCf,   FLAGCF   },
        { szFlagVip,  FLAGVIP  },
        { szFlagVif,  FLAGVIF  },
        { szEaPReg,   PREGEA   },
        { szExpPReg,  PREGEXP  },
        { szRaPReg,   PREGRA   },
        { szPPReg,    PREGP    },
        { szU0Preg,   PREGU0   },
        { szU1Preg,   PREGU1   },
        { szU2Preg,   PREGU2   },
        { szU3Preg,   PREGU3   },
        { szU4Preg,   PREGU4   },
        { szU5Preg,   PREGU5   },
        { szU6Preg,   PREGU6   },
        { szU7Preg,   PREGU7   },
        { szU8Preg,   PREGU8   },
        { szU9Preg,   PREGU9   },
        };

#define REGNAMESIZE (sizeof(regname) / sizeof(struct Reg))

struct SubReg X86subregname[] = {
        { REGEDI,  0, 0xffff },         //  DI register
        { REGESI,  0, 0xffff },         //  SI register
        { REGEBX,  0, 0xffff },         //  BX register
        { REGEDX,  0, 0xffff },         //  DX register
        { REGECX,  0, 0xffff },         //  CX register
        { REGEAX,  0, 0xffff },         //  AX register
        { REGEBP,  0, 0xffff },         //  BP register
        { REGEIP,  0, 0xffff },         //  IP register
        { REGEFL,  0, 0xffff },         //  FL register
        { REGESP,  0, 0xffff },         //  SP register
        { REGEBX,  0,   0xff },         //  BL register
        { REGEDX,  0,   0xff },         //  DL register
        { REGECX,  0,   0xff },         //  CL register
        { REGEAX,  0,   0xff },         //  AL register
        { REGEBX,  8,   0xff },         //  BH register
        { REGEDX,  8,   0xff },         //  DH register
        { REGECX,  8,   0xff },         //  CH register
        { REGEAX,  8,   0xff },         //  AH register
        { REGEFL, 12,      3 },         //  IOPL level value
        { REGEFL, 11,      1 },         //  OF (overflow flag)
        { REGEFL, 10,      1 },         //  DF (direction flag)
        { REGEFL,  9,      1 },         //  IF (interrupt enable flag)
        { REGEFL,  8,      1 },         //  TF (trace flag)
        { REGEFL,  7,      1 },         //  SF (sign flag)
        { REGEFL,  6,      1 },         //  ZF (zero flag)
        { REGEFL,  4,      1 },         //  AF (aux carry flag)
        { REGEFL,  2,      1 },         //  PF (parity flag)
        { REGEFL,  0,      1 },         //  CF (carry flag)
        { REGEFL, 20,      1 },         //  VIP (virtual interrupt pending)
        { REGEFL, 19,      1 }          //  VIF (virtual interrupt flag)
        };

/*** X86GetRegFlagValue - get register or flag value
*
*   Purpose:
*       Return the value of the specified register or flag.
*       This routine calls X86GetRegValue to get the register
*       value and shifts and masks appropriately to extract a
*       flag value.
*
*   Input:
*       regnum - register or flag specification
*
*   Returns:
*       Value of register or flag.
*
*************************************************************************/

ULONG
X86GetRegFlagValue (
    ULONG regnum
    )
{
    ULONG value;

    if (regnum < FLAGBASE) {
        value = X86GetRegValue(regnum);
    } else {
        regnum -= FLAGBASE;
        value = X86GetRegValue(X86subregname[regnum].regindex);
        value = (value >> X86subregname[regnum].shift) & X86subregname[regnum].mask;
    }
    return value;
}

/*** X86GetRegValue - get register value
*
*   Purpose:
*       Returns the value of the register from the processor
*       context structure.
*
*   Input:
*       regnum - register specification
*
*   Returns:
*       value of the register from the context structure
*
*************************************************************************/

ULONG
X86GetRegValue (
    ULONG regnum
    )
{
#if defined(KERNEL) && defined(i386)
    ULONG   cBytesRead;
    NTSTATUS NtStatus;

    //fprintf (stdout, "X86GetRegValue %d\n", regnum);
    switch (contextState) {
        case CONTEXTFIR:
            switch (regnum) {
                case REGEIP:    return VDMRegisterContext.Eip;
                case REGDR6:    return SpecialRegContext.KernelDr6;
                case REGDR7:    return SpecialRegContext.KernelDr7;
            }

            //
            // Requested register was not in CONTEXTFIR - go get the next
            // context level.  (we skip CONTEXTSMALL since that's the only
            // api we have)
            //

            if (!DbgGetThreadContext(NtsdCurrentProcessor, &VDMRegisterContext)) {
                dprintf("DbgKdGetContext failed\n");
                exit(1);
            }

            contextState = CONTEXTHALF;

            // Fallthrough!
        case CONTEXTSHORT:
            switch (regnum) {
                case REGCS:     return VDMRegisterContext.SegCs;
                case REGDS:     return VDMRegisterContext.SegDs;
                case REGES:     return VDMRegisterContext.SegEs;
                case REGFS:     return VDMRegisterContext.SegFs;
                case REGEIP:    return VDMRegisterContext.Eip;
                case REGEFL:    return VDMRegisterContext.EFlags;
                case REGDR6:    return SpecialRegContext.KernelDr6;
                case REGDR7:    return SpecialRegContext.KernelDr7;
            }

            //
            // Requested register was not in CONTEXTSHORT - go get the next
            // context level.
            //

        case CONTEXTNONE:
            if (contextState < CONTEXTHALF || contextState == CONTEXTNONE) {
                if (!DbgGetThreadContext(NtsdCurrentProcessor, &VDMRegisterContext)) {
                    dprintf("DbgKdGetContext failed\n");
                    exit(1);
                }
                contextState = CONTEXTHALF;
            }

            // Fallthrough!
        case CONTEXTHALF:
            switch (regnum) {
                case REGCS:     return VDMRegisterContext.SegCs;
                case REGDS:     return VDMRegisterContext.SegDs;
                case REGES:     return VDMRegisterContext.SegEs;
                case REGFS:     return VDMRegisterContext.SegFs;
                case REGEIP:    return VDMRegisterContext.Eip;
                case REGEFL:    return VDMRegisterContext.EFlags;
                case REGDR6:    return SpecialRegContext.KernelDr6;
                case REGDR7:    return SpecialRegContext.KernelDr7;

                case REGGS:     return VDMRegisterContext.SegGs;
                case REGSS:     return VDMRegisterContext.SegSs;
                case REGEDI:    return VDMRegisterContext.Edi;
                case REGESI:    return VDMRegisterContext.Esi;
                case REGEBX:    return VDMRegisterContext.Ebx;
                case REGEDX:    return VDMRegisterContext.Edx;
                case REGECX:    return VDMRegisterContext.Ecx;
                case REGEAX:    return VDMRegisterContext.Eax;
                case REGEBP:    return VDMRegisterContext.Ebp;
                case REGESP:    return VDMRegisterContext.Esp;

            }

            //
            // The requested register is not in our current context, load up
            // a complete context
            //

            NtStatus = DbgKdReadControlSpace(NtsdCurrentProcessor,
                                             (PVOID)sizeof(CONTEXT),
                                             (PVOID)&SpecialRegContext,
                                             sizeof(KSPECIAL_REGISTERS),
                                             &cBytesRead);
            if (!NT_SUCCESS(NtStatus) ||
                                      cBytesRead != sizeof(KSPECIAL_REGISTERS)) {
                dprintf("DbgKdReadControlSpace failed\n");
                exit(1);
                }

            contextState = CONTEXTVALID;
    }

    //
    // We must have a complete context...
    //

#endif
    switch (regnum) {
        case REGGS:
            return VDMRegisterContext.SegGs;
        case REGFS:
            return VDMRegisterContext.SegFs;
        case REGES:
            return VDMRegisterContext.SegEs;
        case REGDS:
            return VDMRegisterContext.SegDs;
        case REGEDI:
            return VDMRegisterContext.Edi;
        case REGESI:
            return VDMRegisterContext.Esi;
        case REGSI:
            return(VDMRegisterContext.Esi & 0xffff);
        case REGDI:
            return(VDMRegisterContext.Edi & 0xffff);
        case REGEBX:
            return VDMRegisterContext.Ebx;
        case REGEDX:
            return VDMRegisterContext.Edx;
        case REGECX:
            return VDMRegisterContext.Ecx;
        case REGEAX:
            return VDMRegisterContext.Eax;
        case REGEBP:
            return VDMRegisterContext.Ebp;
        case REGEIP:
            return VDMRegisterContext.Eip;
        case REGCS:
            return VDMRegisterContext.SegCs;
        case REGEFL:
            return VDMRegisterContext.EFlags;
        case REGESP:
            return VDMRegisterContext.Esp;
        case REGSS:
            return VDMRegisterContext.SegSs;
        case PREGEA:
            return EAaddr[0].flat;
        case PREGEXP:
            return EXPRLastExpression;
        case PREGRA: {
            ADDR   stackBP;
            struct {
                ULONG   oldBP;
                ULONG   retAddr;
                } stackRead;
            FormAddress(&stackBP, (ULONG)X86GetRegValue(REGSS), (ULONG)X86GetRegValue(REGEBP));
            GetMemString(&stackBP, (PUCHAR)&stackRead, sizeof(stackRead));
            return stackRead.retAddr;
            }
        case PREGP:
            return EXPRLastDump;
        case PREGU0:
        case PREGU1:
        case PREGU2:
        case PREGU3:
        case PREGU4:
        case PREGU5:
        case PREGU6:
        case PREGU7:
        case PREGU8:
        case PREGU9:
            return (ULONG)UserRegs[regnum - PREGU0];

#if defined(KERNEL) && defined(i386)
        case REGCR0:
            return SpecialRegContext.Cr0;
        case REGCR2:
            return SpecialRegContext.Cr2;
        case REGCR3:
            return SpecialRegContext.Cr3;
        case REGCR4:
            return SpecialRegContext.Cr4;
        case REGDR0:
            return SpecialRegContext.KernelDr0;
        case REGDR1:
            return SpecialRegContext.KernelDr1;
        case REGDR2:
            return SpecialRegContext.KernelDr2;
        case REGDR3:
            return SpecialRegContext.KernelDr3;
        case REGDR6:
            return SpecialRegContext.KernelDr6;
        case REGDR7:
            return SpecialRegContext.KernelDr7;
        case REGGDTR:
            return SpecialRegContext.Gdtr.Base;
        case REGGDTL:
            return (ULONG)SpecialRegContext.Gdtr.Limit;
        case REGIDTR:
            return SpecialRegContext.Idtr.Base;
        case REGIDTL:
            return (ULONG)SpecialRegContext.Idtr.Limit;
        case REGTR:
            return (ULONG)SpecialRegContext.Tr;
        case REGLDTR:
            return (ULONG)SpecialRegContext.Ldtr;
#endif

#if !defined(KERNEL) && defined(i386)
        case REGDR0:
            return VDMRegisterContext.Dr0;
        case REGDR1:
            return VDMRegisterContext.Dr1;
        case REGDR2:
            return VDMRegisterContext.Dr2;
        case REGDR3:
            return VDMRegisterContext.Dr3;
        case REGDR6:
            return VDMRegisterContext.Dr6;
        case REGDR7:
            return VDMRegisterContext.Dr7;
#endif
        default:
            dprintf("X86GetRegValue: unknown register %lx requested\n",regnum);
            return((ULONG)-1);
        }
}

/*** X86SetRegFlagValue - set register or flag value
*
*   Purpose:
*       Set the value of the specified register or flag.
*       This routine calls X86SetRegValue to set the register
*       value and shifts and masks appropriately to set a
*       flag value.
*
*   Input:
*       regnum - register or flag specification
*       regvalue - new register or flag value
*
*   Output:
*       None.
*
*   Exceptions:
*       error exit: OVERFLOW - value too large for flag
*
*   Notes:
*
*************************************************************************/

void X86SetRegFlagValue (ULONG regnum, ULONG regvalue)
{
    ULONG   regindex;
    ULONG   newvalue;
    PUCHAR  szValue;
    ULONG   index;

    if (regnum >= PREGU0 && regnum <= PREGU9) {
        szValue = (PUCHAR)regvalue;
        index = 0L;

        while (szValue[index] >= ' ')
            index++;
        szValue[index] = 0;
        if (szValue = UserRegs[regnum - PREGU0])
            free(szValue);
        szValue = UserRegs[regnum - PREGU0] =
                                malloc(strlen((PUCHAR)regvalue) + 1);
        if (szValue)
            strcpy(szValue, (PUCHAR)regvalue);
        }

    else if (regnum < PREGBASE)
        X86SetRegValue(regnum, regvalue);
    else if (regnum >= FLAGBASE) {
        regnum -= FLAGBASE;
        if (regvalue > X86subregname[regnum].mask)
            error(OVERFLOW);
        regindex = X86subregname[regnum].regindex;
        newvalue = X86GetRegValue(regindex) &
              (~(X86subregname[regnum].mask << X86subregname[regnum].shift)) |
              (regvalue << X86subregname[regnum].shift);
        X86SetRegValue(regindex, newvalue);
        }
}

/*** X86SetRegValue - set register value
*
*   Purpose:
*       Set the value of the register in the processor context
*       structure.
*
*   Input:
*       regnum - register specification
*       regvalue - new value to set the register
*
*   Output:
*       None.
*
*************************************************************************/

void X86SetRegValue (ULONG regnum, ULONG regvalue)
{
#if defined(KERNEL) && defined(i386)
    ULONG   cBytesRead;
    NTSTATUS NtStatus;

    if ((regnum == REGEIP && regvalue != VDMRegisterContext.Eip)
                        || (regnum != REGEIP && regnum != REGDR7)) {

        if (!FullContextPresent[contextState]) {
            if (!DbgGetThreadContext(NtsdCurrentProcessor, &VDMRegisterContext)) {
                dprintf("DbgKdGetContext failed\n");
                exit(1);
                }

            NtStatus = DbgKdReadControlSpace(NtsdCurrentProcessor,
                                             (PVOID)sizeof(CONTEXT),
                                             (PVOID)&SpecialRegContext,
                                             sizeof(KSPECIAL_REGISTERS),
                                             &cBytesRead);
            if (!NT_SUCCESS(NtStatus) ||
                                  cBytesRead != sizeof(KSPECIAL_REGISTERS)) {
                dprintf("DbgKdReadControlSpace failed\n");
                exit(1);
                }
            }

        contextState = CONTEXTDIRTY;
        }
#endif
    switch (regnum) {
        case REGGS:
            VDMRegisterContext.SegGs = regvalue;
            break;
        case REGFS:
            VDMRegisterContext.SegFs = regvalue;
            break;
        case REGES:
            VDMRegisterContext.SegEs = regvalue;
            break;
        case REGDS:
            VDMRegisterContext.SegDs = regvalue;
            break;
        case REGEDI:
            VDMRegisterContext.Edi = regvalue;
            break;
        case REGESI:
            VDMRegisterContext.Esi = regvalue;
            break;
        case REGEBX:
            VDMRegisterContext.Ebx = regvalue;
            break;
        case REGEDX:
            VDMRegisterContext.Edx = regvalue;
            break;
        case REGECX:
            VDMRegisterContext.Ecx = regvalue;
            break;
        case REGEAX:
            VDMRegisterContext.Eax = regvalue;
            break;
        case REGEBP:
            VDMRegisterContext.Ebp = regvalue;
            break;
        case REGEIP:
            VDMRegisterContext.Eip = regvalue;

            break;
        case REGCS:
            VDMRegisterContext.SegCs = regvalue;
            break;
        case REGEFL:
#if defined(KERNEL) && defined(i386)
            VDMRegisterContext.EFlags = regvalue & ~0x100;  // leave TF clear
#else
            VDMRegisterContext.EFlags = regvalue;           // allow TF set
#endif
            break;
        case REGESP:
            VDMRegisterContext.Esp = regvalue;
            break;
        case REGSS:
            VDMRegisterContext.SegSs = regvalue;
            break;
#if defined(KERNEL) && defined(i386)
        case REGCR0:
            SpecialRegContext.Cr0 = regvalue;
            break;
        case REGCR2:
            SpecialRegContext.Cr2 = regvalue;
            break;
        case REGCR3:
            SpecialRegContext.Cr3 = regvalue;
            break;
        case REGCR4:
            SpecialRegContext.Cr4 = regvalue;
            break;
        case REGDR0:
            SpecialRegContext.KernelDr0 = regvalue;
            break;
        case REGDR1:
            SpecialRegContext.KernelDr1 = regvalue;
            break;
        case REGDR2:
            SpecialRegContext.KernelDr2 = regvalue;
            break;
        case REGDR3:
            SpecialRegContext.KernelDr3 = regvalue;
            break;
        case REGDR6:
            SpecialRegContext.KernelDr6 = regvalue;
            break;
        case REGDR7:
            SpecialRegContext.KernelDr7 = regvalue;
            break;
        case REGGDTR:
            SpecialRegContext.Gdtr.Base = regvalue;
            break;
        case REGGDTL:
            SpecialRegContext.Gdtr.Limit = (USHORT)regvalue;
            break;
        case REGIDTR:
            SpecialRegContext.Idtr.Base = regvalue;
            break;
        case REGIDTL:
            SpecialRegContext.Idtr.Limit = (USHORT)regvalue;
            break;
        case REGTR:
            SpecialRegContext.Tr = (USHORT)regvalue;
            break;
        case REGLDTR:
            SpecialRegContext.Ldtr = (USHORT)regvalue;
            break;
#endif

#if !defined(KERNEL) && defined(i386)
        case REGDR0:
            VDMRegisterContext.Dr0 = regvalue;
            break;
        case REGDR1:
            VDMRegisterContext.Dr1 = regvalue;
            break;
        case REGDR2:
            VDMRegisterContext.Dr2 = regvalue;
            break;
        case REGDR3:
            VDMRegisterContext.Dr3 = regvalue;
            break;
        case REGDR6:
            VDMRegisterContext.Dr6 = regvalue;
            break;
        case REGDR7:
            VDMRegisterContext.Dr7 = regvalue;
            break;
#endif
        default:
            dprintf("X86SetRegValue: unknown register %lx requested\n",regnum);
        }
}

/*** X86GetRegName - get register name
*
*   Purpose:
*       Parse a register name from the current command line position.
*       If successful, return the register index value, else return -1.
*
*   Input:
*       pchCommand - present command string position
*
*   Returns:
*       register or flag index if found, else -1
*
*************************************************************************/

ULONG X86GetRegName (void)
{
    char    szregname[8];
    char    ch;
    int     count = 0;

    ch = (char)tolower(*pchCommand); pchCommand++;
    while (ch >= 'a' && ch <= 'z' || ch >= '0' && ch <= '9' || ch == '$') {
        if (count == 7)
            return (ULONG)-1;
        szregname[count++] = ch;
        ch = (char)tolower(*pchCommand); pchCommand++;
        }
    szregname[count] = '\0';
    pchCommand--;
    return X86GetRegString(szregname);
}

ULONG X86GetRegString (PUCHAR pszString)
{
    ULONG   count;

    for (count = 0; count < REGNAMESIZE; count++)
        if (!strcmp(pszString, regname[count].psz))
            return regname[count].value;
    return (ULONG)-1;
}

void X86GetRegPCValue (PADDR Address)
{

    Off(*Address)  = X86GetRegValue(REGEIP);

#ifdef MULTIMODE
    if (VM86(X86GetRegValue(REGEFL))) {
        Address->type = ADDR_V86;
        Address->seg  = (USHORT)X86GetRegValue(REGCS);
        ComputeFlatAddress(Address, NULL);
        }
    else {
        DESCRIPTOR_TABLE_ENTRY desc;
        static USHORT MainCodeSeg = 0;
        ULONG base;

        Address->seg  = (USHORT)(desc.Selector = X86GetRegValue(REGCS));
#ifdef i386
        DbgKdLookupSelector(NtsdCurrentProcessor, &desc);
        Address->type = desc.Descriptor.HighWord.Bits.Default_Big
                                                    ? ADDR_1632 : ADDR_16;
        if ( Address->type == ADDR_1632 ) {
            if ( MainCodeSeg == 0 ) {
                base =   ((ULONG)desc.Descriptor.HighWord.Bytes.BaseHi << 24)
                       + ((ULONG)desc.Descriptor.HighWord.Bytes.BaseMid << 16)
                       + ((ULONG)desc.Descriptor.BaseLow);
                if ( base == 0 ) {
                    MainCodeSeg = Address->seg;
                }
            }
            if ( Address->seg == MainCodeSeg ) {
                Address->type = ADDR_32;
            }
        }
#else
        Address->type = ADDR_16;
#endif
        ComputeFlatAddress(Address, &desc);
        }
#endif
    return;
}

PADDR X86GetRegFPValue (void)
{
    static ADDR addrFP;

    Off(addrFP) = X86GetRegValue(REGEBP);

#ifdef MULTIMODE
    if (VM86(X86GetRegValue(REGEFL))) {
        addrFP.type = ADDR_V86;
        addrFP.seg = (USHORT)X86GetRegValue(REGSS);
        ComputeFlatAddress(&addrFP, NULL);
        }
    else {
        DESCRIPTOR_TABLE_ENTRY desc;
        addrFP.seg = (USHORT)(desc.Selector = X86GetRegValue(REGSS));
#ifdef i386
        DbgKdLookupSelector(NtsdCurrentProcessor, &desc);
        addrFP.type = desc.Descriptor.HighWord.Bits.Default_Big
                                               ? ADDR_32 : ADDR_16;
#else
        addrFP.type = ADDR_16;
#endif
        ComputeFlatAddress(&addrFP, &desc);
        }
#endif
    return &addrFP;
}

void X86SetRegPCValue (PADDR paddr)
{
    // We set the EIP to the offset (the non-translated value),
    // because we may not be in "flat" mode !!!

    X86SetRegValue(REGEIP, Off(*paddr));
}

/*** X86OutputAllRegs - output all registers and present instruction
*
*   Purpose:
*       To output the current register state of the processor.
*       All integer registers are output as well as processor status
*       registers.  Important flag fields are also output separately.
*
*   Input:
*       fTerseReg - (kernel only) - if set, do not output all control
*                   register, just the more commonly useful ones.
*
*   Output:
*       None.
*
*************************************************************************/

void X86OutputAllRegs(void)
{
    dprintf("eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
                X86GetRegValue(REGEAX),
                X86GetRegValue(REGEBX),
                X86GetRegValue(REGECX),
                X86GetRegValue(REGEDX),
                X86GetRegValue(REGESI),
                X86GetRegValue(REGEDI));

    dprintf("eip=%08lx esp=%08lx ebp=%08lx iopl=%1lx "
        "%s %s %s %s %s %s %s %s %s %s\n",
                X86GetRegValue(REGEIP),
                X86GetRegValue(REGESP),
                X86GetRegValue(REGEBP),
                X86GetRegFlagValue(FLAGIOPL),
        X86GetRegFlagValue(FLAGVIP) ? "vip" : "   ",
        X86GetRegFlagValue(FLAGVIF) ? "vif" : "   ",
        X86GetRegFlagValue(FLAGOF) ? "ov" : "nv",
        X86GetRegFlagValue(FLAGDF) ? "dn" : "up",
        X86GetRegFlagValue(FLAGIF) ? "ei" : "di",
        X86GetRegFlagValue(FLAGSF) ? "ng" : "pl",
        X86GetRegFlagValue(FLAGZF) ? "zr" : "nz",
        X86GetRegFlagValue(FLAGAF) ? "ac" : "na",
        X86GetRegFlagValue(FLAGPF) ? "po" : "pe",
        X86GetRegFlagValue(FLAGCF) ? "cy" : "nc");
#if defined(KERNEL) && defined(i386)
    if (TerseLevel >= 3)
        return ;
#endif
    dprintf("cs=%04lx  ss=%04lx  ds=%04lx  es=%04lx  fs=%04lx  gs=%04lx"
        "             efl=%08lx\n",
                X86GetRegValue(REGCS),
                X86GetRegValue(REGSS),
                X86GetRegValue(REGDS),
                X86GetRegValue(REGES),
                X86GetRegValue(REGFS),
                X86GetRegValue(REGGS),
        X86GetRegFlagValue(REGEFL));
#if defined(KERNEL) && defined(i386)
    if (TerseLevel >= 2)
        return ;

    dprintf("cr0=%08lx cr2=%08lx cr3=%08lx",
                X86GetRegValue(REGCR0),
                X86GetRegValue(REGCR2),
                X86GetRegValue(REGCR3));

    if (TerseLevel >= 1) {
        dprintf("\n");
        return ;
    }

    dprintf(" dr0=%08lx dr1=%08lx dr2=%08lx\n",
            X86GetRegValue(REGDR0),
            X86GetRegValue(REGDR1),
            X86GetRegValue(REGDR2));
    dprintf("dr3=%08lx dr6=%08lx dr7=%08lx cr4=%08lx\n",
            X86GetRegValue(REGDR3),
            X86GetRegValue(REGDR6),
            X86GetRegValue(REGDR7),
            X86GetRegValue(REGCR4));
    dprintf("gdtr=%08lx   gdtl=%04lx idtr=%08lx   idtl=%04lx "
                                            "tr=%04lx  ldtr=%04x\n",
            X86GetRegValue(REGGDTR),
            X86GetRegValue(REGGDTL),
            X86GetRegValue(REGIDTR),
            X86GetRegValue(REGIDTL),
            X86GetRegValue(REGTR),
            X86GetRegValue(REGLDTR));
#endif
}


/*** X86OutputOneReg - output one register value
*
*   Purpose:
*       Function for the "r <regname>" command.
*
*       Output the value for the specified register or flag.
*
*   Input:
*       regnum - register or flag specification
*
*   Output:
*       None.
*
*************************************************************************/

VOID
X86OutputOneReg(
    ULONG regnum
    )
{
    ULONG value;

    value = X86GetRegFlagValue(regnum);
    if (regnum < FLAGBASE) {
        dprintf("%08lx\n", value);
    } else{
        dprintf("%lx\n", value);
    }
}

BOOLEAN X86fDelayInstruction (void)
{
    return FALSE;
}

/*** X86OutputHelp - output help text
*
*   Purpose:
*       To output a one-page summary help text.
*
*   Input:
*       None.
*
*   Output:
*       None.
*
*************************************************************************/

void X86OutputHelp (void)
{
#if defined(KERNEL) && defined(i386)
dprintf("A [<address>] - assemble              N [<radix>] - set / show radix\n");
dprintf("BA[#] <e|r|w|i><1|2|4> <addr> - addr bp P[R] [=<addr>] [<value>] - program step\n");
dprintf("BC[<bp>] - clear breakpoint(s)        Q - quit\n");
dprintf("BD[<bp>] - disable breakpoint(s)      R[T] [[<reg> [= <value>]]] - reg/flag\n");
dprintf("BE[<bp>] - enable breakpoint(s)       #R[T] - multiprocessor register dump\n");
dprintf("BL[<bp>] - list breakpoint(s)         S <range> <list> - search\n");
dprintf("BP[#] <address> - set breakpoint\n");
dprintf("C <range> <address> - compare         SS <n | a | w> - set symbol suffix\n");
dprintf("D[type][<range>] - dump memory        T[R] [=<address>] [<value>] - trace\n");
dprintf("E[type] <address> [<list>] - enter    U [<range>] - unassemble\n");
dprintf("F <range> <list> - fill               V [<range>] - view source lines\n");
dprintf("G [=<address> [<address>...]] - go    X [<*|module>!]<*|symbol> - view symbols\n");
dprintf("J<expr> [']cmd1['];[']cmd2['] - conditional execution\n");
dprintf("K[B] <count> - stacktrace             .logappend [<file>] - append to log file\n");
dprintf("LN <expr> - list near                 .logclose - close log file\n");
dprintf("M <range> <address> - move            .logopen [<file>] - open new log file\n");
dprintf("O<type> <port> <value> - write I/O    \n");
dprintf("~ - list threads status               ~#s - set default thread\n");
dprintf("~[.|#|*|ddd]f - freeze thread         ~[.|#|ddd]k[value] - backtrace stack\n");
dprintf("| - list processes status             |#s - set default process\n");
dprintf("|#<command> - default process override\n");
dprintf("? <expr> - display expression\n");
dprintf("#<string> [address] - search for a string in the dissasembly\n");
dprintf("$< <filename> - take input from a command file\n");
dprintf("\n");
dprintf("<expr> ops: + - * / not by wo dw poi mod(%) and(&) xor(^) or(|) hi low\n");
dprintf("       operands: number in current radix, public symbol, <reg>\n");
dprintf("<type> : B (byte), W (word), D (doubleword), A (ascii)\n");
dprintf("         C <dwordandChar>, U (unicode), L (list)\n");
dprintf("<pattern> : [(nt | <dll-name>)!]<var-name> (<var-name> can include ? and *)\n");
dprintf("<radix> : 8, 10, 16\n");
dprintf("<reg> : [e]ax, [e]bx, [e]cx, [e]dx, [e]si, [e]di, [e]bp, [e]sp, [e]ip, [e]fl,\n");
dprintf("        al, ah, bl, bh, cl, ch, dl, ch, cs, ds, es, fs, gs, ss\n");
dprintf("        cr0, cr2, cr3, cr4, dr0, dr1, dr2, dr3, dr6, dr7\n");
dprintf("        gdtr, gdtl, idtr, idtl, tr, ldtr, $u0-$u9, $ea, $exp, $ra, $p\n");
dprintf("<flag> : iopl, of, df, if, tf, sf, zf, af, pf, cf\n");
dprintf("<addr> : %<32-bit address>, #<16-bit protect-mode [seg:]address>,\n");
dprintf("         &<V86-mode [seg:]address>\n");
#else
dprintf("A [<address>] - assemble              O<type> <port> <value> - write I/O\n");
dprintf("BA[#] <e|r|w><1|2|4> <addr> - addr bp P[R] [=<addr>] [<value>] - program step\n");
dprintf("BC[<bp>] - clear breakpoint(s)        Q - quit\n");
dprintf("BD[<bp>] - disable breakpoint(s)      R[T] [[<reg> [= <value>]]] - reg/flag\n");
dprintf("BE[<bp>] - enable breakpoint(s)       #R[T] - multiprocessor register dump\n");
dprintf("BL[<bp>] - list breakpoint(s)         S <range> <list> - search\n");
dprintf("BP[#] <address> - set breakpoint\n");
dprintf("C <range> <address> - compare         SS <n | a | w> - set symbol suffix\n");
dprintf("D[type][<range>] - dump memory        T[R] [=<address>] [<value>] - trace\n");
dprintf("E[type] <address> [<list>] - enter    U [<range>] - unassemble\n");
dprintf("F <range> <list> - fill               V [<range>] - view source lines\n");
dprintf("G [=<address> [<address>...]] - go    X [<*|module>!]<*|symbol> - view symbols\n");
dprintf("I<type> <port> - read I/O port        .cache [size] - set vmem cache size\n");
dprintf("J<expr> [']cmd1['];[']cmd2['] - conditional execution\n");
dprintf("K[B] <count> - stacktrace             .logappend [<file>] - append to log file\n");
dprintf("LN <expr> - list near                 .logclose - close log file\n");
dprintf("M <range> <address> - move            .logopen [<file>] - open new log file\n");
dprintf("N [<radix>] - set / show radix        .reboot - reboot target machine\n");
dprintf("? <expr> - display expression         \n");
dprintf("#<string> [address] - search for a string in the dissasembly\n");
dprintf("$< <filename> - take input from a command file\n");
dprintf("\n");
dprintf("<expr> ops: + - * / not by wo dw poi mod(%) and(&) xor(^) or(|) hi low\n");
dprintf("       operands: number in current radix, public symbol, <reg>\n");
dprintf("<type> : B (byte), W (word), D (doubleword), A (ascii)\n");
dprintf("         U (unicode), L (list), O (object)\n");
dprintf("<pattern> : [(nt | <dll-name>)!]<var-name> (<var-name> can include ? and *)\n");
dprintf("<radix> : 8, 10, 16\n");
dprintf("<reg> : [e]ax, [e]bx, [e]cx, [e]dx, [e]si, [e]di, [e]bp, [e]sp, [e]ip, [e]fl,\n");
dprintf("        al, ah, bl, bh, cl, ch, dl, ch, cs, ds, es, fs, gs, ss\n");
dprintf("        cr0, cr2, cr3, cr4, dr0, dr1, dr2, dr3, dr6, dr7\n");
dprintf("        gdtr, gdtl, idtr, idtl, tr, ldtr, $u0-$u9, $ea, $exp, $ra, $p\n");
dprintf("<flag> : iopl, of, df, if, tf, sf, zf, af, pf, cf\n");
dprintf("<addr> : %<32-bit address>, #<16-bit protect-mode [seg:]address>,\n");
dprintf("         &<V86-mode [seg:]address>\n");
#endif
}

#if defined(KERNEL) && defined(i386)
BOOLEAN X86GetTraceFlag (void)
{
    return fTraceFlag;
}
#endif

void X86ClearTraceFlag (void)
{
#if defined(KERNEL) && defined(i386)
    fTraceFlag = FALSE;
#else
    X86SetRegFlagValue(FLAGTF, 0);
#endif
}

void X86SetTraceFlag (void)
{
#if defined(KERNEL) && defined(i386)
    fTraceFlag = TRUE;
#else
    X86SetRegFlagValue(FLAGTF, 1);
#endif
}

#if defined(KERNEL) && defined(i386)
/*** GetRegContext - return register context pointer
*
*   Purpose:
*       Return the pointer to the current register context.
*       For kernel debugging, ensure the context is read.
*
*   Input:
*       None.
*
*   Returns:
*       Pointer to the context.
*
*************************************************************************/

PCONTEXT GetRegContext (void)
{

    if (contextState == CONTEXTFIR) {
        if (!DbgGetThreadContext(NtsdCurrentProcessor, &RegisterContext)) {
            dprintf("DbgKdGetContext failed\n");
            exit(1);
            }
        contextState = CONTEXTVALID;
        }
    return &RegisterContext;
}

void ChangeKdRegContext(ULONG pcValue, PDBGKD_CONTROL_REPORT pCtlReport)
{
    ULONG   cBytesWritten;
    ULONG   cBytesRead;
    USHORT  Processor;
    NTSTATUS NtStatus;

    if (pcValue) {                      //  initial context
        contextState = CONTEXTFIR;
        VDMRegisterContext.Eip = pcValue;
        SpecialRegContext.KernelDr6 = pCtlReport->Dr6;
        SpecialRegContext.KernelDr7 = pCtlReport->Dr7;

        if (pCtlReport->ReportFlags & REPORT_INCLUDES_SEGS) {
            //
            // This is for backwards compatibility - older kernels
            // won't pass these registers in the report record.
            //

            contextState = CONTEXTSHORT;
            VDMRegisterContext.SegCs  = pCtlReport->SegCs;
            VDMRegisterContext.SegDs  = pCtlReport->SegDs;
            VDMRegisterContext.SegEs  = pCtlReport->SegEs;
            VDMRegisterContext.SegFs  = pCtlReport->SegFs;
            VDMRegisterContext.EFlags = pCtlReport->EFlags;
        }

    } else if (contextState == CONTEXTDIRTY) {    //  write final context
        if (!DbgSetThreadContext(NtsdCurrentProcessor, &VDMRegisterContext)) {
            dprintf("DbgKdSetContext failed\n");
            exit(1);
            }

        NtStatus = DbgKdWriteControlSpace(NtsdCurrentProcessor,
                                   (PVOID)sizeof(CONTEXT),
                                   (PVOID)&SpecialRegContext,
                                   sizeof(KSPECIAL_REGISTERS),
                                   &cBytesWritten);
        if (!NT_SUCCESS(NtStatus) ||
                           cBytesWritten != sizeof(KSPECIAL_REGISTERS)) {
            dprintf("DbgKdWriteControlSpace failed\n");
            exit(1);
            }

        if (fSetGlobalDataBrkpts && NumberProcessors > 1) {
            for ( Processor = 0; Processor < NumberProcessors; Processor++) {
                if (Processor != NtsdCurrentProcessor) {
                    NtStatus = DbgKdReadControlSpace((USHORT)Processor,
                                              (PVOID)sizeof(CONTEXT),
                                              (PVOID)&SavedSpecialRegContext,
                                              sizeof(KSPECIAL_REGISTERS),
                                              &cBytesRead);
                    if (!NT_SUCCESS(NtStatus) ||
                                  cBytesRead != sizeof(KSPECIAL_REGISTERS)) {
                        dprintf("DbgKdReadControlSpace failed\n");
                        exit(1);
                        }

                    memcpy(&SavedSpecialRegContext.KernelDr0,
                        &SpecialRegContext.KernelDr0, 6 * sizeof(ULONG));

                    NtStatus = DbgKdWriteControlSpace((USHORT)Processor,
                                               (PVOID)sizeof(CONTEXT),
                                               (PVOID)&SavedSpecialRegContext,
                                               sizeof(KSPECIAL_REGISTERS),
                                               &cBytesWritten);
                    if (!NT_SUCCESS(NtStatus) ||
                               cBytesWritten != sizeof(KSPECIAL_REGISTERS)) {
                        dprintf("DbgKdWriteControlSpace failed\n");
                        exit(1);
                        }
                    }
                }
            }
        }

}
#endif

#if defined(KERNEL) && defined(i386)
void InitFirCache (ULONG count, PUCHAR pstream)
{
    //
    // If we are in anything but 32-bit flat mode, then don't init cache
    //

    if (!fVm86 && !f16pm) {
        DbgKdInitVirtualCacheEntry (X86GetRegValue(REGEIP), count, pstream);
    }
}
#endif

ULONG
GetDregValue (
    ULONG index
    )
{
    if (index < 4) {
        index += REGDR0;
    } else {
        index += REGDR6 - 6;
    }
    return X86GetRegValue(index);
}

VOID
SetDregValue (
    ULONG index,
    ULONG value
    )
{
    if (index < 4) {
        index += REGDR0;
    } else {
        index += REGDR6 - 6;
    }
    X86SetRegValue(index, value);
}

#if defined(KERNEL) && defined(i386)
void SaveProcessorState(void)
{
    PreviousProcessor = NtsdCurrentProcessor;
    SavedRegisterContext = VDMRegisterContext;
    SavedSpecialRegContext = SpecialRegContext;
    SavedContextState = contextState;
    contextState = CONTEXTNONE;
}

void RestoreProcessorState(void)
{
    NtsdCurrentProcessor = PreviousProcessor;
    VDMRegisterContext = SavedRegisterContext;
    SpecialRegContext = SavedSpecialRegContext;
    contextState = SavedContextState;
}
#endif


#ifdef i386
ULONGLONG STGetRegValue (ULONG regnum)
{
    if (!STtrace) {
        return X86GetRegValue(regnum);
    }

    switch (regnum) {
        case REGEBP:    return STebp;
        case REGESP:    return STesp;
        default:
            DPRINT(("%s: bad regnum\n",DebuggerName));
            break;
    }

    return 0;
}
#endif

PUCHAR X86RegNameFromIndex (ULONG index)
{
    ULONG    count;

    for (count = 0; count < REGNAMESIZE; count++)
        if (regname[count].value == index)
            return regname[count].psz;
    return NULL;
}

#if defined(i386)
BOOL
DbgGetThreadContext(
    THREADORPROCESSOR TorP,
    PCONTEXT Context
    )
{
#ifdef KERNEL
    return NT_SUCCESS(DbgKdGetContext(TorP, Context));
#else  // KERNEL
    return GetThreadContext(TorP, Context);
#endif // KERNEL
}


BOOL
DbgSetThreadContext(
    THREADORPROCESSOR TorP,
    PCONTEXT Context
    )
{
#ifdef KERNEL
    return NT_SUCCESS(DbgKdSetContext(TorP, Context));
#else  // KERNEL
    return SetThreadContext(TorP, Context);
#endif // KERNEL
}
#endif // i386