/*
 * 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
}