static void
gdbsim_fetch_register (int regno)
{
if (regno == -1)
{
for (regno = 0; regno < NUM_REGS; regno++)
gdbsim_fetch_register (regno);
return;
}
switch (REGISTER_SIM_REGNO (regno))
{
case LEGACY_SIM_REGNO_IGNORE:
break;
case SIM_REGNO_DOES_NOT_EXIST:
{
/* For moment treat a `does not exist' register the same way
as an ``unavailable'' register. */
char buf[MAX_REGISTER_SIZE];
int nr_bytes;
memset (buf, 0, MAX_REGISTER_SIZE);
regcache_raw_supply (current_regcache, regno, buf);
set_register_cached (regno, -1);
break;
}
default:
{
static int warn_user = 1;
char buf[MAX_REGISTER_SIZE];
int nr_bytes;
gdb_assert (regno >= 0 && regno < NUM_REGS);
memset (buf, 0, MAX_REGISTER_SIZE);
nr_bytes = sim_fetch_register (gdbsim_desc,
REGISTER_SIM_REGNO (regno),
buf, register_size (current_gdbarch, regno));
if (nr_bytes > 0 && nr_bytes != register_size (current_gdbarch, regno) && warn_user)
{
fprintf_unfiltered (gdb_stderr,
"Size of register %s (%d/%d) incorrect (%d instead of %d))",
REGISTER_NAME (regno),
regno, REGISTER_SIM_REGNO (regno),
nr_bytes, register_size (current_gdbarch, regno));
warn_user = 0;
}
/* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
indicating that GDB and the SIM have different ideas about
which registers are fetchable. */
/* Else if (nr_bytes < 0): an old simulator, that doesn't
think to return the register size. Just assume all is ok. */
regcache_raw_supply (current_regcache, regno, buf);
if (sr_get_debug ())
{
printf_filtered ("gdbsim_fetch_register: %d", regno);
/* FIXME: We could print something more intelligible. */
dump_mem (buf, register_size (current_gdbarch, regno));
}
break;
}
}
}
void
fetch_inferior_registers (int regno)
{
int i;
thread_t current_thread = ptid_get_tid (inferior_ptid);
kern_return_t ret = KERN_SUCCESS;
if (TARGET_OSABI == GDB_OSABI_UNKNOWN)
arm_set_osabi_from_host_info ();
if ((regno == -1) || ARM_MACOSX_IS_GP_RELATED_REGNUM (regno))
{
struct gdb_arm_thread_state gp_regs;
unsigned int gp_count = GDB_ARM_THREAD_STATE_COUNT;
ret = thread_get_state
(current_thread, GDB_ARM_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
if (ret != KERN_SUCCESS)
{
printf ("Error calling thread_get_state for GP registers for thread 0x%ulx",
current_thread);
MACH_CHECK_ERROR (ret);
}
MACH_CHECK_ERROR (ret);
arm_macosx_fetch_gp_registers (&gp_regs);
}
if ((regno == -1) || ARM_MACOSX_IS_FP_RELATED_REGNUM (regno))
{
/* We don't have F0-F7, though they need to exist in our register
numbering scheme so we can connect to remote gdbserver's that use
FSF register numbers. */
for (i = ARM_F0_REGNUM; i <= ARM_F7_REGNUM; i++)
set_register_cached (i, 1);
set_register_cached (ARM_FPS_REGNUM, 1);
}
if ((regno == -1) || ARM_MACOSX_IS_VFP_RELATED_REGNUM (regno))
{
enum arm_vfp_version vfp_version;
vfp_version = gdbarch_tdep (current_gdbarch)->vfp_version;
int fp_byte_size = -1;
switch (vfp_version)
{
case ARM_VFP_UNSUPPORTED:
/* No VFP support, so nothing to do. */
fp_byte_size = 0;
break;
case ARM_VFP_VERSION_1:
{
gdb_arm_thread_vfpv1_state_t fp_regs;
mach_msg_type_number_t fp_count = GDB_ARM_THREAD_FPSTATE_VFPV1_COUNT;
ret = thread_get_state (current_thread, GDB_ARM_THREAD_FPSTATE,
(thread_state_t) & fp_regs,
&fp_count);
if (ret != KERN_SUCCESS)
{
printf ("Error calling thread_get_state for VFP registers for thread 0x%ulx",
current_thread);
MACH_CHECK_ERROR (ret);
}
arm_macosx_fetch_vfpv1_regs (&fp_regs);
}
break;
case ARM_VFP_VERSION_3:
{
gdb_arm_thread_vfpv3_state_t fp_regs;
mach_msg_type_number_t fp_count = GDB_ARM_THREAD_FPSTATE_VFPV3_COUNT;
ret = thread_get_state (current_thread, GDB_ARM_THREAD_FPSTATE,
(thread_state_t) & fp_regs,
&fp_count);
if (ret != KERN_SUCCESS)
{
printf ("Error calling thread_get_state for VFP registers for thread 0x%ulx",
current_thread);
MACH_CHECK_ERROR (ret);
}
arm_macosx_fetch_vfpv3_regs (&fp_regs);
}
break;
default:
error ("fetch_inferior_registers: unable to fetch ARM_THREAD_FPSTATE: "
"unsupported vfp version: %d", (int)vfp_version);
break;
}
}
}
