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; } } }