debugger/registers.c

   1 /*
   2  * Debugger register handling
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include "debugger.h"
   9
  10 CONTEXT DEBUG_context;
  11
  12 /***********************************************************************
  13  *           DEBUG_SetRegister
  14  *
  15  * Set a register value.
  16  */
  17 void DEBUG_SetRegister( enum debug_regs reg, int val )
  18 {
  19     switch(reg)
  20     {
  21         case REG_EAX: EAX_reg(&DEBUG_context) = val; break;
  22         case REG_EBX: EBX_reg(&DEBUG_context) = val; break;
  23         case REG_ECX: ECX_reg(&DEBUG_context) = val; break;
  24         case REG_EDX: EDX_reg(&DEBUG_context) = val; break;
  25         case REG_ESI: ESI_reg(&DEBUG_context) = val; break;
  26         case REG_EDI: EDI_reg(&DEBUG_context) = val; break;
  27         case REG_EBP: EBP_reg(&DEBUG_context) = val; break;
  28         case REG_EFL: EFL_reg(&DEBUG_context) = val; break;
  29         case REG_EIP: EIP_reg(&DEBUG_context) = val; break;
  30         case REG_ESP: ESP_reg(&DEBUG_context) = val; break;
  31         case REG_AX:  AX_reg(&DEBUG_context)  = val; break;
  32         case REG_BX:  BX_reg(&DEBUG_context)  = val; break;
  33         case REG_CX:  CX_reg(&DEBUG_context)  = val; break;
  34         case REG_DX:  DX_reg(&DEBUG_context)  = val; break;
  35         case REG_SI:  SI_reg(&DEBUG_context)  = val; break;
  36         case REG_DI:  DI_reg(&DEBUG_context)  = val; break;
  37         case REG_BP:  BP_reg(&DEBUG_context)  = val; break;
  38         case REG_FL:  FL_reg(&DEBUG_context)  = val; break;
  39         case REG_IP:  IP_reg(&DEBUG_context)  = val; break;
  40         case REG_SP:  SP_reg(&DEBUG_context)  = val; break;
  41         case REG_CS:  CS_reg(&DEBUG_context)  = val; break;
  42         case REG_DS:  DS_reg(&DEBUG_context)  = val; break;
  43         case REG_ES:  ES_reg(&DEBUG_context)  = val; break;
  44         case REG_SS:  SS_reg(&DEBUG_context)  = val; break;
  45         case REG_FS:  FS_reg(&DEBUG_context)  = val; break;
  46         case REG_GS:  GS_reg(&DEBUG_context)  = val; break;
  47     }
  48 }
  49
  50
  51 int
  52 DEBUG_PrintRegister(enum debug_regs reg)
  53 {
  54     switch(reg)
  55     {
  56         case REG_EAX: fprintf(stderr, "%%eax"); break;
  57         case REG_EBX: fprintf(stderr, "%%ebx"); break;
  58         case REG_ECX: fprintf(stderr, "%%ecx"); break;
  59         case REG_EDX: fprintf(stderr, "%%edx"); break;
  60         case REG_ESI: fprintf(stderr, "%%esi"); break;
  61         case REG_EDI: fprintf(stderr, "%%edi"); break;
  62         case REG_EBP: fprintf(stderr, "%%ebp"); break;
  63         case REG_EFL: fprintf(stderr, "%%efl"); break;
  64         case REG_EIP: fprintf(stderr, "%%eip"); break;
  65         case REG_ESP: fprintf(stderr, "%%esp"); break;
  66         case REG_AX:  fprintf(stderr, "%%ax"); break;
  67         case REG_BX:  fprintf(stderr, "%%bx"); break;
  68         case REG_CX:  fprintf(stderr, "%%cx"); break;
  69         case REG_DX:  fprintf(stderr, "%%dx"); break;
  70         case REG_SI:  fprintf(stderr, "%%si"); break;
  71         case REG_DI:  fprintf(stderr, "%%di"); break;
  72         case REG_BP:  fprintf(stderr, "%%bp"); break;
  73         case REG_FL:  fprintf(stderr, "%%fl"); break;
  74         case REG_IP:  fprintf(stderr, "%%ip"); break;
  75         case REG_SP:  fprintf(stderr, "%%sp"); break;
  76         case REG_CS:  fprintf(stderr, "%%cs"); break;
  77         case REG_DS:  fprintf(stderr, "%%ds"); break;
  78         case REG_ES:  fprintf(stderr, "%%es"); break;
  79         case REG_SS:  fprintf(stderr, "%%ss"); break;
  80         case REG_FS:  fprintf(stderr, "%%fs"); break;
  81         case REG_GS:  fprintf(stderr, "%%gs"); break;
  82     }
  83     return TRUE;
  84 }
  85
  86 /***********************************************************************
  87  *           DEBUG_GetRegister
  88  *
  89  * Get a register value.
  90  */
  91 int DEBUG_GetRegister( enum debug_regs reg )
  92 {
  93     switch(reg)
  94     {
  95         case REG_EAX: return EAX_reg(&DEBUG_context);
  96         case REG_EBX: return EBX_reg(&DEBUG_context);
  97         case REG_ECX: return ECX_reg(&DEBUG_context);
  98         case REG_EDX: return EDX_reg(&DEBUG_context);
  99         case REG_ESI: return ESI_reg(&DEBUG_context);
 100         case REG_EDI: return EDI_reg(&DEBUG_context);
 101         case REG_EBP: return EBP_reg(&DEBUG_context);
 102         case REG_EFL: return EFL_reg(&DEBUG_context);
 103         case REG_EIP: return EIP_reg(&DEBUG_context);
 104         case REG_ESP: return ESP_reg(&DEBUG_context);
 105         case REG_AX:  return AX_reg(&DEBUG_context);
 106         case REG_BX:  return BX_reg(&DEBUG_context);
 107         case REG_CX:  return CX_reg(&DEBUG_context);
 108         case REG_DX:  return DX_reg(&DEBUG_context);
 109         case REG_SI:  return SI_reg(&DEBUG_context);
 110         case REG_DI:  return DI_reg(&DEBUG_context);
 111         case REG_BP:  return BP_reg(&DEBUG_context);
 112         case REG_FL:  return FL_reg(&DEBUG_context);
 113         case REG_IP:  return IP_reg(&DEBUG_context);
 114         case REG_SP:  return SP_reg(&DEBUG_context);
 115         case REG_CS:  return CS_reg(&DEBUG_context);
 116         case REG_DS:  return DS_reg(&DEBUG_context);
 117         case REG_ES:  return ES_reg(&DEBUG_context);
 118         case REG_SS:  return SS_reg(&DEBUG_context);
 119         case REG_FS:  return FS_reg(&DEBUG_context);
 120         case REG_GS:  return GS_reg(&DEBUG_context);
 121     }
 122     return 0;  /* should not happen */
 123 }
 124
 125
 126 /***********************************************************************
 127  *           DEBUG_SetSigContext
 128  *
 129  * Set the register values from a sigcontext.
 130  */
 131 void DEBUG_SetSigContext( const SIGCONTEXT *sigcontext )
 132 {
 133     EAX_reg(&DEBUG_context) = EAX_sig(sigcontext);
 134     EBX_reg(&DEBUG_context) = EBX_sig(sigcontext);
 135     ECX_reg(&DEBUG_context) = ECX_sig(sigcontext);
 136     EDX_reg(&DEBUG_context) = EDX_sig(sigcontext);
 137     ESI_reg(&DEBUG_context) = ESI_sig(sigcontext);
 138     EDI_reg(&DEBUG_context) = EDI_sig(sigcontext);
 139     EBP_reg(&DEBUG_context) = EBP_sig(sigcontext);
 140     EFL_reg(&DEBUG_context) = EFL_sig(sigcontext);
 141     EIP_reg(&DEBUG_context) = EIP_sig(sigcontext);
 142     ESP_reg(&DEBUG_context) = ESP_sig(sigcontext);
 143     CS_reg(&DEBUG_context)  = LOWORD(CS_sig(sigcontext));
 144     DS_reg(&DEBUG_context)  = LOWORD(DS_sig(sigcontext));
 145     ES_reg(&DEBUG_context)  = LOWORD(ES_sig(sigcontext));
 146     SS_reg(&DEBUG_context)  = LOWORD(SS_sig(sigcontext));
 147 #ifdef FS_sig
 148     FS_reg(&DEBUG_context)  = LOWORD(FS_sig(sigcontext));
 149 #else
 150     GET_FS( FS_reg(&DEBUG_context) );
 151     FS_reg(&DEBUG_context) &= 0xffff;
 152 #endif
 153 #ifdef GS_sig
 154     GS_reg(&DEBUG_context)  = LOWORD(GS_sig(sigcontext));
 155 #else
 156     GET_GS( GS_reg(&DEBUG_context) );
 157     GS_reg(&DEBUG_context) &= 0xffff;
 158 #endif
 159 }
 160
 161
 162 /***********************************************************************
 163  *           DEBUG_GetSigContext
 164  *
 165  * Build a sigcontext from the register values.
 166  */
 167 void DEBUG_GetSigContext( SIGCONTEXT *sigcontext )
 168 {
 169     EAX_sig(sigcontext) = EAX_reg(&DEBUG_context);
 170     EBX_sig(sigcontext) = EBX_reg(&DEBUG_context);
 171     ECX_sig(sigcontext) = ECX_reg(&DEBUG_context);
 172     EDX_sig(sigcontext) = EDX_reg(&DEBUG_context);
 173     ESI_sig(sigcontext) = ESI_reg(&DEBUG_context);
 174     EDI_sig(sigcontext) = EDI_reg(&DEBUG_context);
 175     EBP_sig(sigcontext) = EBP_reg(&DEBUG_context);
 176     EFL_sig(sigcontext) = EFL_reg(&DEBUG_context);
 177     EIP_sig(sigcontext) = EIP_reg(&DEBUG_context);
 178     ESP_sig(sigcontext) = ESP_reg(&DEBUG_context);
 179     CS_sig(sigcontext)  = CS_reg(&DEBUG_context);
 180     DS_sig(sigcontext)  = DS_reg(&DEBUG_context);
 181     ES_sig(sigcontext)  = ES_reg(&DEBUG_context);
 182     SS_sig(sigcontext)  = SS_reg(&DEBUG_context);
 183 #ifdef FS_sig
 184     FS_sig(sigcontext)  = FS_reg(&DEBUG_context);
 185 #else
 186     SET_FS( FS_reg(&DEBUG_context) );
 187 #endif
 188 #ifdef GS_sig
 189     GS_sig(sigcontext)  = GS_reg(&DEBUG_context);
 190 #else
 191     SET_GS( GS_reg(&DEBUG_context) );
 192 #endif
 193 }
 194
 195
 196 /***********************************************************************
 197  *           DEBUG_InfoRegisters
 198  *
 199  * Display registers information.
 200  */
 201 void DEBUG_InfoRegisters(void)
 202 {
 203     fprintf(stderr,"Register dump:\n");
 204
 205     /* First get the segment registers out of the way */
 206     fprintf( stderr," CS:%04x SS:%04x DS:%04x ES:%04x FS:%04x GS:%04x",
 207              (WORD)CS_reg(&DEBUG_context), (WORD)SS_reg(&DEBUG_context),
 208              (WORD)DS_reg(&DEBUG_context), (WORD)ES_reg(&DEBUG_context),
 209              (WORD)FS_reg(&DEBUG_context), (WORD)GS_reg(&DEBUG_context) );
 210     if (dbg_mode == 16)
 211     {
 212         fprintf( stderr,"\n IP:%04x SP:%04x BP:%04x FLAGS:%04x\n",
 213                  IP_reg(&DEBUG_context), SP_reg(&DEBUG_context),
 214                  BP_reg(&DEBUG_context), FL_reg(&DEBUG_context) );
 215         fprintf( stderr," AX:%04x BX:%04x CX:%04x DX:%04x SI:%04x DI:%04x\n",
 216                  AX_reg(&DEBUG_context), BX_reg(&DEBUG_context),
 217                  CX_reg(&DEBUG_context), DX_reg(&DEBUG_context),
 218                  SI_reg(&DEBUG_context), DI_reg(&DEBUG_context) );
 219     }
 220     else  /* 32-bit mode */
 221     {
 222         fprintf( stderr, "\n EIP:%08lx ESP:%08lx EBP:%08lx EFLAGS:%08lx\n",
 223                  EIP_reg(&DEBUG_context), ESP_reg(&DEBUG_context),
 224                  EBP_reg(&DEBUG_context), EFL_reg(&DEBUG_context) );
 225         fprintf( stderr, " EAX:%08lx EBX:%08lx ECX:%08lx EDX:%08lx\n",
 226                  EAX_reg(&DEBUG_context), EBX_reg(&DEBUG_context),
 227                  ECX_reg(&DEBUG_context), EDX_reg(&DEBUG_context) );
 228         fprintf( stderr, " ESI:%08lx EDI:%08lx\n",
 229                  ESI_reg(&DEBUG_context), EDI_reg(&DEBUG_context) );
 230     }
 231 }
 232
 233
 234 /***********************************************************************
 235  *           DEBUG_ValidateRegisters
 236  *
 237  * Make sure all registers have a correct value for returning from
 238  * the signal handler.
 239  */
 240 BOOL32 DEBUG_ValidateRegisters(void)
 241 {
 242     WORD cs, ds;
 243
 244 /* Check that a selector is a valid ring-3 LDT selector, or a NULL selector */
 245 #define CHECK_SEG(seg,name) \
 246     if (((seg) & ~3) && \
 247         ((((seg) & 7) != 7) || IS_LDT_ENTRY_FREE(SELECTOR_TO_ENTRY(seg)))) \
 248     { \
 249         fprintf( stderr, "*** Invalid value for %s register: %04x\n", \
 250                  (name), (WORD)(seg) ); \
 251         return FALSE; \
 252     }
 253
 254     GET_CS(cs);
 255     GET_DS(ds);
 256     if (CS_reg(&DEBUG_context) != cs) CHECK_SEG(CS_reg(&DEBUG_context), "CS");
 257     if (SS_reg(&DEBUG_context) != ds) CHECK_SEG(SS_reg(&DEBUG_context), "SS");
 258     if (DS_reg(&DEBUG_context) != ds) CHECK_SEG(DS_reg(&DEBUG_context), "DS");
 259     if (ES_reg(&DEBUG_context) != ds) CHECK_SEG(ES_reg(&DEBUG_context), "ES");
 260     if (FS_reg(&DEBUG_context) != ds) CHECK_SEG(FS_reg(&DEBUG_context), "FS");
 261     if (GS_reg(&DEBUG_context) != ds) CHECK_SEG(GS_reg(&DEBUG_context), "GS");
 262
 263     /* Check that CS and SS are not NULL */
 264
 265     if (!(CS_reg(&DEBUG_context) & ~3))
 266     {
 267         fprintf( stderr, "*** Invalid value for CS register: %04x\n",
 268                  (WORD)CS_reg(&DEBUG_context) );
 269         return FALSE;
 270     }
 271     if (!(SS_reg(&DEBUG_context) & ~3))
 272     {
 273         fprintf( stderr, "*** Invalid value for SS register: %04x\n",
 274                  (WORD)SS_reg(&DEBUG_context) );
 275         return FALSE;
 276     }
 277     return TRUE;
 278 #undef CHECK_SEG
 279 }