home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / sdktools / image / drwatson / regs.c < prev    next >
C/C++ Source or Header  |  1996-02-02  |  11KB  |  363 lines
  1. /*++
  2.  
  3. Copyright (c) 1993  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     regs.c
  8.  
  9. Abstract:
  10.  
  11.     This file provides access to the machine's register set.
  12.  
  13. Author:
  14.  
  15.     Wesley Witt (wesw) 1-May-1993  (ported from ntsd)
  16.  
  17. Environment:
  18.  
  19.     User Mode
  20.  
  21. --*/
  22.  
  23. #include <windows.h>
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26. #include <string.h>
  27.  
  28. #include "drwatson.h"
  29. #include "proto.h"
  30. #include "regs.h"
  31.  
  32.  
  33.  
  34. ULONG  GetDregValue (PDEBUGPACKET dp, ULONG index);
  35.  
  36.  
  37.  
  38.  
  39. char    szGsReg[]    = "gs";
  40. char    szFsReg[]    = "fs";
  41. char    szEsReg[]    = "es";
  42. char    szDsReg[]    = "ds";
  43. char    szEdiReg[]   = "edi";
  44. char    szEsiReg[]   = "esi";
  45. char    szEbxReg[]   = "ebx";
  46. char    szEdxReg[]   = "edx";
  47. char    szEcxReg[]   = "ecx";
  48. char    szEaxReg[]   = "eax";
  49. char    szEbpReg[]   = "ebp";
  50. char    szEipReg[]   = "eip";
  51. char    szCsReg[]    = "cs";
  52. char    szEflReg[]   = "efl";
  53. char    szEspReg[]   = "esp";
  54. char    szSsReg[]    = "ss";
  55. char    szDiReg[]    = "di";
  56. char    szSiReg[]    = "si";
  57. char    szBxReg[]    = "bx";
  58. char    szDxReg[]    = "dx";
  59. char    szCxReg[]    = "cx";
  60. char    szAxReg[]    = "ax";
  61. char    szBpReg[]    = "bp";
  62. char    szIpReg[]    = "ip";
  63. char    szFlReg[]    = "fl";
  64. char    szSpReg[]    = "sp";
  65. char    szBlReg[]    = "bl";
  66. char    szDlReg[]    = "dl";
  67. char    szClReg[]    = "cl";
  68. char    szAlReg[]    = "al";
  69. char    szBhReg[]    = "bh";
  70. char    szDhReg[]    = "dh";
  71. char    szChReg[]    = "ch";
  72. char    szAhReg[]    = "ah";
  73. char    szIoplFlag[] = "iopl";
  74. char    szFlagOf[]   = "of";
  75. char    szFlagDf[]   = "df";
  76. char    szFlagIf[]   = "if";
  77. char    szFlagTf[]   = "tf";
  78. char    szFlagSf[]   = "sf";
  79. char    szFlagZf[]   = "zf";
  80. char    szFlagAf[]   = "af";
  81. char    szFlagPf[]   = "pf";
  82. char    szFlagCf[]   = "cf";
  83. char    szFlagVip[]  = "vip";
  84. char    szFlagVif[]  = "vif";
  85.  
  86. struct Reg {
  87.         char    *psz;
  88.         ULONG   value;
  89.         };
  90.  
  91. struct SubReg {
  92.         ULONG   regindex;
  93.         ULONG   shift;
  94.         ULONG   mask;
  95.         };
  96.  
  97. struct Reg regname[] = {
  98.         { szGsReg,    REGGS    },
  99.         { szFsReg,    REGFS    },
  100.         { szEsReg,    REGES    },
  101.         { szDsReg,    REGDS    },
  102.         { szEdiReg,   REGEDI   },
  103.         { szEsiReg,   REGESI   },
  104.         { szEbxReg,   REGEBX   },
  105.         { szEdxReg,   REGEDX   },
  106.         { szEcxReg,   REGECX   },
  107.         { szEaxReg,   REGEAX   },
  108.         { szEbpReg,   REGEBP   },
  109.         { szEipReg,   REGEIP   },
  110.         { szCsReg,    REGCS    },
  111.         { szEflReg,   REGEFL   },
  112.         { szEspReg,   REGESP   },
  113.         { szSsReg,    REGSS    },
  114.         { szDiReg,    REGDI    },
  115.         { szSiReg,    REGSI    },
  116.         { szBxReg,    REGBX    },
  117.         { szDxReg,    REGDX    },
  118.         { szCxReg,    REGCX    },
  119.         { szAxReg,    REGAX    },
  120.         { szBpReg,    REGBP    },
  121.         { szIpReg,    REGIP    },
  122.         { szFlReg,    REGFL    },
  123.         { szSpReg,    REGSP    },
  124.         { szBlReg,    REGBL    },
  125.         { szDlReg,    REGDL    },
  126.         { szClReg,    REGCL    },
  127.         { szAlReg,    REGAL    },
  128.         { szBhReg,    REGBH    },
  129.         { szDhReg,    REGDH    },
  130.         { szChReg,    REGCH    },
  131.         { szAhReg,    REGAH    },
  132.         { szIoplFlag, FLAGIOPL },
  133.         { szFlagOf,   FLAGOF   },
  134.         { szFlagDf,   FLAGDF   },
  135.         { szFlagIf,   FLAGIF   },
  136.         { szFlagTf,   FLAGTF   },
  137.         { szFlagSf,   FLAGSF   },
  138.         { szFlagZf,   FLAGZF   },
  139.         { szFlagAf,   FLAGAF   },
  140.         { szFlagPf,   FLAGPF   },
  141.         { szFlagCf,   FLAGCF   },
  142.         { szFlagVip,  FLAGVIP  },
  143.         { szFlagVif,  FLAGVIF  },
  144.         };
  145.  
  146. #define REGNAMESIZE (sizeof(regname) / sizeof(struct Reg))
  147.  
  148. struct SubReg subregname[] = {
  149.         { REGEDI,  0, 0xffff },         //  DI register
  150.         { REGESI,  0, 0xffff },         //  SI register
  151.         { REGEBX,  0, 0xffff },         //  BX register
  152.         { REGEDX,  0, 0xffff },         //  DX register
  153.         { REGECX,  0, 0xffff },         //  CX register
  154.         { REGEAX,  0, 0xffff },         //  AX register
  155.         { REGEBP,  0, 0xffff },         //  BP register
  156.         { REGEIP,  0, 0xffff },         //  IP register
  157.         { REGEFL,  0, 0xffff },         //  FL register
  158.         { REGESP,  0, 0xffff },         //  SP register
  159.         { REGEBX,  0,   0xff },         //  BL register
  160.         { REGEDX,  0,   0xff },         //  DL register
  161.         { REGECX,  0,   0xff },         //  CL register
  162.         { REGEAX,  0,   0xff },         //  AL register
  163.         { REGEBX,  8,   0xff },         //  BH register
  164.         { REGEDX,  8,   0xff },         //  DH register
  165.         { REGECX,  8,   0xff },         //  CH register
  166.         { REGEAX,  8,   0xff },         //  AH register
  167.         { REGEFL, 12,      3 },         //  IOPL level value
  168.         { REGEFL, 11,      1 },         //  OF (overflow flag)
  169.         { REGEFL, 10,      1 },         //  DF (direction flag)
  170.         { REGEFL,  9,      1 },         //  IF (interrupt enable flag)
  171.         { REGEFL,  8,      1 },         //  TF (trace flag)
  172.         { REGEFL,  7,      1 },         //  SF (sign flag)
  173.         { REGEFL,  6,      1 },         //  ZF (zero flag)
  174.         { REGEFL,  4,      1 },         //  AF (aux carry flag)
  175.         { REGEFL,  2,      1 },         //  PF (parity flag)
  176.         { REGEFL,  0,      1 },         //  CF (carry flag)
  177.         { REGEFL, 20,      1 },         //  VIP (virtual interrupt pending)
  178.         { REGEFL, 19,      1 }          //  VIF (virtual interrupt flag)
  179.         };
  180.  
  181. DWORDLONG
  182. GetRegFlagValue (PDEBUGPACKET dp, ULONG regnum)
  183. {
  184.     DWORDLONG value;
  185.  
  186.     if (regnum < FLAGBASE)
  187.         value = GetRegValue(dp, regnum);
  188.     else {
  189.         regnum -= FLAGBASE;
  190.         value = GetRegValue(dp, subregname[regnum].regindex);
  191.         value = (value >> subregname[regnum].shift) & subregname[regnum].mask;
  192.         }
  193.     return value;
  194. }
  195.  
  196. DWORDLONG
  197. GetRegValue (
  198.     PDEBUGPACKET dp,
  199.     ULONG regnum
  200.     )
  201. {
  202.     switch (regnum) {
  203.         case REGGS:
  204.             return dp->tctx->context.SegGs;
  205.         case REGFS:
  206.             return dp->tctx->context.SegFs;
  207.         case REGES:
  208.             return dp->tctx->context.SegEs;
  209.         case REGDS:
  210.             return dp->tctx->context.SegDs;
  211.         case REGEDI:
  212.             return dp->tctx->context.Edi;
  213.         case REGESI:
  214.             return dp->tctx->context.Esi;
  215.         case REGSI:
  216.             return(dp->tctx->context.Esi & 0xffff);
  217.         case REGDI:
  218.             return(dp->tctx->context.Edi & 0xffff);
  219.         case REGEBX:
  220.             return dp->tctx->context.Ebx;
  221.         case REGEDX:
  222.             return dp->tctx->context.Edx;
  223.         case REGECX:
  224.             return dp->tctx->context.Ecx;
  225.         case REGEAX:
  226.             return dp->tctx->context.Eax;
  227.         case REGEBP:
  228.             return dp->tctx->context.Ebp;
  229.         case REGEIP:
  230.             return dp->tctx->context.Eip;
  231.         case REGCS:
  232.             return dp->tctx->context.SegCs;
  233.         case REGEFL:
  234.             return dp->tctx->context.EFlags;
  235.         case REGESP:
  236.             return dp->tctx->context.Esp;
  237.         case REGSS:
  238.             return dp->tctx->context.SegSs;
  239.         case PREGEA:
  240.             return 0;
  241.         case PREGEXP:
  242.             return 0;
  243.         case PREGRA: {
  244.             struct {
  245.                 ULONG   oldBP;
  246.                 ULONG   retAddr;
  247.             } stackRead;
  248.             DoMemoryRead( dp,
  249.                           (LPVOID)dp->tctx->context.Ebp,
  250.                           (LPVOID)&stackRead,
  251.                           sizeof(stackRead),
  252.                           NULL
  253.                         );
  254.             return stackRead.retAddr;
  255.             }
  256.         case PREGP:
  257.             return 0;
  258.         case REGDR0:
  259.             return dp->tctx->context.Dr0;
  260.         case REGDR1:
  261.             return dp->tctx->context.Dr1;
  262.         case REGDR2:
  263.             return dp->tctx->context.Dr2;
  264.         case REGDR3:
  265.             return dp->tctx->context.Dr3;
  266.         case REGDR6:
  267.             return dp->tctx->context.Dr6;
  268.         case REGDR7:
  269.             return dp->tctx->context.Dr7;
  270.         default:
  271.             return 0;
  272.         }
  273. }
  274.  
  275. ULONG
  276. GetRegString (PUCHAR pszString)
  277. {
  278.     ULONG   count;
  279.  
  280.     for (count = 0; count < REGNAMESIZE; count++) {
  281.         if (!strcmp(pszString, regname[count].psz)) {
  282.             return regname[count].value;
  283.         }
  284.     }
  285.     return (ULONG)-1;
  286. }
  287.  
  288. void
  289. OutputAllRegs( PDEBUGPACKET dp, BOOL Show64 )
  290. {
  291.     lprintfs("eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\r\n",
  292.                 (DWORD)GetRegValue(dp,REGEAX),
  293.                 (DWORD)GetRegValue(dp,REGEBX),
  294.                 (DWORD)GetRegValue(dp,REGECX),
  295.                 (DWORD)GetRegValue(dp,REGEDX),
  296.                 (DWORD)GetRegValue(dp,REGESI),
  297.                 (DWORD)GetRegValue(dp,REGEDI));
  298.  
  299.     lprintfs("eip=%08lx esp=%08lx ebp=%08lx iopl=%1lx "
  300.         "%s %s %s %s %s %s %s %s %s %s\r\n",
  301.                 (DWORD)GetRegValue(dp,REGEIP),
  302.                 (DWORD)GetRegValue(dp,REGESP),
  303.                 (DWORD)GetRegValue(dp,REGEBP),
  304.                 (DWORD)GetRegFlagValue(dp,FLAGIOPL),
  305.         (DWORD)GetRegFlagValue(dp,FLAGVIP) ? "vip" : "   ",
  306.         (DWORD)GetRegFlagValue(dp,FLAGVIF) ? "vif" : "   ",
  307.         (DWORD)GetRegFlagValue(dp,FLAGOF) ? "ov" : "nv",
  308.         (DWORD)GetRegFlagValue(dp,FLAGDF) ? "dn" : "up",
  309.         (DWORD)GetRegFlagValue(dp,FLAGIF) ? "ei" : "di",
  310.         (DWORD)GetRegFlagValue(dp,FLAGSF) ? "ng" : "pl",
  311.         (DWORD)GetRegFlagValue(dp,FLAGZF) ? "zr" : "nz",
  312.         (DWORD)GetRegFlagValue(dp,FLAGAF) ? "ac" : "na",
  313.         (DWORD)GetRegFlagValue(dp,FLAGPF) ? "po" : "pe",
  314.         (DWORD)GetRegFlagValue(dp,FLAGCF) ? "cy" : "nc");
  315.     lprintfs("cs=%04lx  ss=%04lx  ds=%04lx  es=%04lx  fs=%04lx  gs=%04lx"
  316.         "             efl=%08lx\r\n",
  317.                 (DWORD)GetRegValue(dp,REGCS),
  318.                 (DWORD)GetRegValue(dp,REGSS),
  319.                 (DWORD)GetRegValue(dp,REGDS),
  320.                 (DWORD)GetRegValue(dp,REGES),
  321.                 (DWORD)GetRegValue(dp,REGFS),
  322.                 (DWORD)GetRegValue(dp,REGGS),
  323.         (DWORD)GetRegFlagValue(dp,REGEFL));
  324.     lprintfs("\r\n\r\n");
  325. }
  326.  
  327. void
  328. OutputOneReg (PDEBUGPACKET dp, ULONG regnum, BOOL Show64)
  329. {
  330.     DWORD value;
  331.  
  332.     value = (DWORD)GetRegFlagValue(dp,regnum);
  333.     if (regnum < FLAGBASE) {
  334.         lprintfs("%08lx\r\n", value);
  335.     } else {
  336.         lprintfs("%lx\r\n", value);
  337.     }
  338. }
  339.  
  340. ULONG
  341. GetDregValue (PDEBUGPACKET dp, ULONG index)
  342. {
  343.     if (index < 4) {
  344.         index += REGDR0;
  345.     } else {
  346.         index += REGDR6 - 6;
  347.     }
  348.     return (DWORD)GetRegValue(dp,index);
  349. }
  350.  
  351. PUCHAR
  352. RegNameFromIndex (ULONG index)
  353. {
  354.     ULONG    count;
  355.  
  356.     for (count = 0; count < REGNAMESIZE; count++) {
  357.         if (regname[count].value == index) {
  358.             return regname[count].psz;
  359.         }
  360.     }
  361.     return NULL;
  362. }
  363.