211 lines
7.3 KiB
C
211 lines
7.3 KiB
C
/*
|
|
* Debugger register handling
|
|
*
|
|
* Copyright 1995 Alexandre Julliard
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include "debugger.h"
|
|
|
|
SIGCONTEXT *DEBUG_context;
|
|
|
|
/***********************************************************************
|
|
* DEBUG_SetRegister
|
|
*
|
|
* Set a register value.
|
|
*/
|
|
void DEBUG_SetRegister( enum debug_regs reg, int val )
|
|
{
|
|
switch(reg)
|
|
{
|
|
case REG_EAX: EAX_reg(DEBUG_context) = val; break;
|
|
case REG_EBX: EBX_reg(DEBUG_context) = val; break;
|
|
case REG_ECX: ECX_reg(DEBUG_context) = val; break;
|
|
case REG_EDX: EDX_reg(DEBUG_context) = val; break;
|
|
case REG_ESI: ESI_reg(DEBUG_context) = val; break;
|
|
case REG_EDI: EDI_reg(DEBUG_context) = val; break;
|
|
case REG_EBP: EBP_reg(DEBUG_context) = val; break;
|
|
case REG_EFL: EFL_reg(DEBUG_context) = val; break;
|
|
case REG_EIP: EIP_reg(DEBUG_context) = val; break;
|
|
case REG_ESP: ESP_reg(DEBUG_context) = val; break;
|
|
case REG_AX: AX_reg(DEBUG_context) = val; break;
|
|
case REG_BX: BX_reg(DEBUG_context) = val; break;
|
|
case REG_CX: CX_reg(DEBUG_context) = val; break;
|
|
case REG_DX: DX_reg(DEBUG_context) = val; break;
|
|
case REG_SI: SI_reg(DEBUG_context) = val; break;
|
|
case REG_DI: DI_reg(DEBUG_context) = val; break;
|
|
case REG_BP: BP_reg(DEBUG_context) = val; break;
|
|
case REG_FL: FL_reg(DEBUG_context) = val; break;
|
|
case REG_IP: IP_reg(DEBUG_context) = val; break;
|
|
case REG_SP: SP_reg(DEBUG_context) = val; break;
|
|
case REG_CS: CS_reg(DEBUG_context) = val; break;
|
|
case REG_DS: DS_reg(DEBUG_context) = val; break;
|
|
case REG_ES: ES_reg(DEBUG_context) = val; break;
|
|
case REG_SS: SS_reg(DEBUG_context) = val; break;
|
|
#ifdef FS_reg
|
|
case REG_FS: FS_reg(DEBUG_context) = val; break;
|
|
#else
|
|
case REG_FS:
|
|
fprintf( stderr, "Register %fs not supported on this system\n" );
|
|
break;
|
|
#endif
|
|
#ifdef GS_reg
|
|
case REG_GS: GS_reg(DEBUG_context) = val; break;
|
|
#else
|
|
case REG_GS:
|
|
fprintf( stderr, "Register %gs not supported on this system\n" );
|
|
break;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* DEBUG_GetRegister
|
|
*
|
|
* Get a register value.
|
|
*/
|
|
int DEBUG_GetRegister( enum debug_regs reg )
|
|
{
|
|
switch(reg)
|
|
{
|
|
case REG_EAX: return EAX_reg(DEBUG_context);
|
|
case REG_EBX: return EBX_reg(DEBUG_context);
|
|
case REG_ECX: return ECX_reg(DEBUG_context);
|
|
case REG_EDX: return EDX_reg(DEBUG_context);
|
|
case REG_ESI: return ESI_reg(DEBUG_context);
|
|
case REG_EDI: return EDI_reg(DEBUG_context);
|
|
case REG_EBP: return EBP_reg(DEBUG_context);
|
|
case REG_EFL: return EFL_reg(DEBUG_context);
|
|
case REG_EIP: return EIP_reg(DEBUG_context);
|
|
case REG_ESP: return ESP_reg(DEBUG_context);
|
|
case REG_AX: return AX_reg(DEBUG_context);
|
|
case REG_BX: return BX_reg(DEBUG_context);
|
|
case REG_CX: return CX_reg(DEBUG_context);
|
|
case REG_DX: return DX_reg(DEBUG_context);
|
|
case REG_SI: return SI_reg(DEBUG_context);
|
|
case REG_DI: return DI_reg(DEBUG_context);
|
|
case REG_BP: return BP_reg(DEBUG_context);
|
|
case REG_FL: return FL_reg(DEBUG_context);
|
|
case REG_IP: return IP_reg(DEBUG_context);
|
|
case REG_SP: return SP_reg(DEBUG_context);
|
|
case REG_CS: return CS_reg(DEBUG_context);
|
|
case REG_DS: return DS_reg(DEBUG_context);
|
|
case REG_ES: return ES_reg(DEBUG_context);
|
|
case REG_SS: return SS_reg(DEBUG_context);
|
|
#ifdef FS_reg
|
|
case REG_FS: return FS_reg(DEBUG_context);
|
|
#else
|
|
case REG_FS:
|
|
fprintf( stderr, "Register %fs not supported on this system\n" );
|
|
return 0;
|
|
#endif
|
|
#ifdef GS_reg
|
|
case REG_GS: return GS_reg(DEBUG_context);
|
|
#else
|
|
case REG_GS:
|
|
fprintf( stderr, "Register %gs not supported on this system\n" );
|
|
return 0;
|
|
#endif
|
|
}
|
|
return 0; /* should not happen */
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
* DEBUG_InfoRegisters
|
|
*
|
|
* Display registers information.
|
|
*/
|
|
void DEBUG_InfoRegisters(void)
|
|
{
|
|
fprintf(stderr,"Register dump:\n");
|
|
|
|
/* First get the segment registers out of the way */
|
|
fprintf( stderr," CS:%04x SS:%04x DS:%04x ES:%04x",
|
|
CS_reg(DEBUG_context), SS_reg(DEBUG_context),
|
|
DS_reg(DEBUG_context), ES_reg(DEBUG_context) );
|
|
#ifdef FS_reg
|
|
fprintf( stderr, " FS:%04x", FS_reg(DEBUG_context) );
|
|
#endif
|
|
#ifdef GS_reg
|
|
fprintf( stderr, " GS:%04x", GS_reg(DEBUG_context) );
|
|
#endif
|
|
if (dbg_mode == 16)
|
|
{
|
|
fprintf( stderr,"\n IP:%04x SP:%04x BP:%04x FLAGS:%04x\n",
|
|
IP_reg(DEBUG_context), SP_reg(DEBUG_context),
|
|
BP_reg(DEBUG_context), FL_reg(DEBUG_context) );
|
|
fprintf( stderr," AX:%04x BX:%04x CX:%04x DX:%04x SI:%04x DI:%04x\n",
|
|
AX_reg(DEBUG_context), BX_reg(DEBUG_context),
|
|
CX_reg(DEBUG_context), DX_reg(DEBUG_context),
|
|
SI_reg(DEBUG_context), DI_reg(DEBUG_context) );
|
|
}
|
|
else /* 32-bit mode */
|
|
{
|
|
fprintf( stderr, "\n EIP:%08lx ESP:%08lx EBP:%08lx EFLAGS:%08lx\n",
|
|
EIP_reg(DEBUG_context), ESP_reg(DEBUG_context),
|
|
EBP_reg(DEBUG_context), EFL_reg(DEBUG_context) );
|
|
fprintf( stderr, " EAX:%08lx EBX:%08lx ECX:%08lx EDX:%08lx\n",
|
|
EAX_reg(DEBUG_context), EBX_reg(DEBUG_context),
|
|
ECX_reg(DEBUG_context), EDX_reg(DEBUG_context) );
|
|
fprintf( stderr, " ESI:%08lx EDI:%08lx\n",
|
|
ESI_reg(DEBUG_context), EDI_reg(DEBUG_context) );
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* DEBUG_ValidateRegisters
|
|
*
|
|
* Make sure all registers have a correct value for returning from
|
|
* the signal handler.
|
|
*/
|
|
BOOL32 DEBUG_ValidateRegisters(void)
|
|
{
|
|
/* Check that a selector is a valid ring-3 LDT selector, or a NULL selector */
|
|
#define CHECK_SEG(seg,name) \
|
|
if (((seg) & ~3) && \
|
|
((((seg) & 7) != 7) || IS_LDT_ENTRY_FREE(SELECTOR_TO_ENTRY(seg)))) \
|
|
{ \
|
|
fprintf( stderr, "*** Invalid value for %s register: %04x\n", \
|
|
(name), (seg) ); \
|
|
return FALSE; \
|
|
}
|
|
|
|
if (CS_reg(DEBUG_context) != WINE_CODE_SELECTOR)
|
|
CHECK_SEG( CS_reg(DEBUG_context), "CS" );
|
|
if (SS_reg(DEBUG_context) != WINE_DATA_SELECTOR)
|
|
CHECK_SEG( SS_reg(DEBUG_context), "SS" );
|
|
if (DS_reg(DEBUG_context) != WINE_DATA_SELECTOR)
|
|
CHECK_SEG( DS_reg(DEBUG_context), "DS" );
|
|
if (ES_reg(DEBUG_context) != WINE_DATA_SELECTOR)
|
|
CHECK_SEG( ES_reg(DEBUG_context), "ES" );
|
|
#ifdef FS_reg
|
|
if (FS_reg(DEBUG_context) != WINE_DATA_SELECTOR)
|
|
CHECK_SEG( FS_reg(DEBUG_context), "FS" );
|
|
#endif
|
|
#ifdef GS_reg
|
|
if (GS_reg(DEBUG_context) != WINE_DATA_SELECTOR)
|
|
CHECK_SEG( GS_reg(DEBUG_context), "GS" );
|
|
#endif
|
|
|
|
/* Check that CS and SS are not NULL */
|
|
|
|
if (!(CS_reg(DEBUG_context) & ~3))
|
|
{
|
|
fprintf( stderr, "*** Invalid value for CS register: %04x\n",
|
|
CS_reg(DEBUG_context) );
|
|
return FALSE;
|
|
}
|
|
if (!(SS_reg(DEBUG_context) & ~3))
|
|
{
|
|
fprintf( stderr, "*** Invalid value for SS register: %04x\n",
|
|
SS_reg(DEBUG_context) );
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
#undef CHECK_SEG
|
|
}
|