git.oblomov.eu Git - wine/blob - debugger/registers.c

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