/*++

Copyright (c) 1993  Microsoft Corporation

Module Name:

    regs.c

Abstract:

    This file provides access to the machine's register set.

Author:

    Wesley Witt (wesw) 1-May-1993  (ported from ntsd)

Environment:

    User Mode

--*/

#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "drwatson.h"
#include "proto.h"
#include "regs.h"



ULONG  GetDregValue (PDEBUGPACKET dp, ULONG index);




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";
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";

struct Reg {
        char    *psz;
        ULONG   value;
        };

struct SubReg {
        ULONG   regindex;
        ULONG   shift;
        ULONG   mask;
        };

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    },
        { 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  },
        };

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

struct SubReg subregname[] = {
        { 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)
        };

DWORDLONG
GetRegFlagValue (PDEBUGPACKET dp, ULONG regnum)
{
    DWORDLONG value;

    if (regnum < FLAGBASE)
        value = GetRegValue(dp, regnum);
    else {
        regnum -= FLAGBASE;
        value = GetRegValue(dp, subregname[regnum].regindex);
        value = (value >> subregname[regnum].shift) & subregname[regnum].mask;
        }
    return value;
}

DWORDLONG
GetRegValue (
    PDEBUGPACKET dp,
    ULONG regnum
    )
{
    switch (regnum) {
        case REGGS:
            return dp->tctx->context.SegGs;
        case REGFS:
            return dp->tctx->context.SegFs;
        case REGES:
            return dp->tctx->context.SegEs;
        case REGDS:
            return dp->tctx->context.SegDs;
        case REGEDI:
            return dp->tctx->context.Edi;
        case REGESI:
            return dp->tctx->context.Esi;
        case REGSI:
            return(dp->tctx->context.Esi & 0xffff);
        case REGDI:
            return(dp->tctx->context.Edi & 0xffff);
        case REGEBX:
            return dp->tctx->context.Ebx;
        case REGEDX:
            return dp->tctx->context.Edx;
        case REGECX:
            return dp->tctx->context.Ecx;
        case REGEAX:
            return dp->tctx->context.Eax;
        case REGEBP:
            return dp->tctx->context.Ebp;
        case REGEIP:
            return dp->tctx->context.Eip;
        case REGCS:
            return dp->tctx->context.SegCs;
        case REGEFL:
            return dp->tctx->context.EFlags;
        case REGESP:
            return dp->tctx->context.Esp;
        case REGSS:
            return dp->tctx->context.SegSs;
        case PREGEA:
            return 0;
        case PREGEXP:
            return 0;
        case PREGRA: {
            struct {
                ULONG   oldBP;
                ULONG   retAddr;
            } stackRead;
            DoMemoryRead( dp,
                          (LPVOID)dp->tctx->context.Ebp,
                          (LPVOID)&stackRead,
                          sizeof(stackRead),
                          NULL
                        );
            return stackRead.retAddr;
            }
        case PREGP:
            return 0;
        case REGDR0:
            return dp->tctx->context.Dr0;
        case REGDR1:
            return dp->tctx->context.Dr1;
        case REGDR2:
            return dp->tctx->context.Dr2;
        case REGDR3:
            return dp->tctx->context.Dr3;
        case REGDR6:
            return dp->tctx->context.Dr6;
        case REGDR7:
            return dp->tctx->context.Dr7;
        default:
            return 0;
        }
}

ULONG
GetRegString (PUCHAR pszString)
{
    ULONG   count;

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

void
OutputAllRegs( PDEBUGPACKET dp, BOOL Show64 )
{
    lprintfs("eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\r\n",
                (DWORD)GetRegValue(dp,REGEAX),
                (DWORD)GetRegValue(dp,REGEBX),
                (DWORD)GetRegValue(dp,REGECX),
                (DWORD)GetRegValue(dp,REGEDX),
                (DWORD)GetRegValue(dp,REGESI),
                (DWORD)GetRegValue(dp,REGEDI));

    lprintfs("eip=%08lx esp=%08lx ebp=%08lx iopl=%1lx "
        "%s %s %s %s %s %s %s %s %s %s\r\n",
                (DWORD)GetRegValue(dp,REGEIP),
                (DWORD)GetRegValue(dp,REGESP),
                (DWORD)GetRegValue(dp,REGEBP),
                (DWORD)GetRegFlagValue(dp,FLAGIOPL),
        (DWORD)GetRegFlagValue(dp,FLAGVIP) ? "vip" : "   ",
        (DWORD)GetRegFlagValue(dp,FLAGVIF) ? "vif" : "   ",
        (DWORD)GetRegFlagValue(dp,FLAGOF) ? "ov" : "nv",
        (DWORD)GetRegFlagValue(dp,FLAGDF) ? "dn" : "up",
        (DWORD)GetRegFlagValue(dp,FLAGIF) ? "ei" : "di",
        (DWORD)GetRegFlagValue(dp,FLAGSF) ? "ng" : "pl",
        (DWORD)GetRegFlagValue(dp,FLAGZF) ? "zr" : "nz",
        (DWORD)GetRegFlagValue(dp,FLAGAF) ? "ac" : "na",
        (DWORD)GetRegFlagValue(dp,FLAGPF) ? "po" : "pe",
        (DWORD)GetRegFlagValue(dp,FLAGCF) ? "cy" : "nc");
    lprintfs("cs=%04lx  ss=%04lx  ds=%04lx  es=%04lx  fs=%04lx  gs=%04lx"
        "             efl=%08lx\r\n",
                (DWORD)GetRegValue(dp,REGCS),
                (DWORD)GetRegValue(dp,REGSS),
                (DWORD)GetRegValue(dp,REGDS),
                (DWORD)GetRegValue(dp,REGES),
                (DWORD)GetRegValue(dp,REGFS),
                (DWORD)GetRegValue(dp,REGGS),
        (DWORD)GetRegFlagValue(dp,REGEFL));
    lprintfs("\r\n\r\n");
}

void
OutputOneReg (PDEBUGPACKET dp, ULONG regnum, BOOL Show64)
{
    DWORD value;

    value = (DWORD)GetRegFlagValue(dp,regnum);
    if (regnum < FLAGBASE) {
        lprintfs("%08lx\r\n", value);
    } else {
        lprintfs("%lx\r\n", value);
    }
}

ULONG
GetDregValue (PDEBUGPACKET dp, ULONG index)
{
    if (index < 4) {
        index += REGDR0;
    } else {
        index += REGDR6 - 6;
    }
    return (DWORD)GetRegValue(dp,index);
}

PUCHAR
RegNameFromIndex (ULONG index)
{
    ULONG    count;

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