/* Store at least register REGNO, or all regs if REGNO == -1. */
static void
gnu_store_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
struct proc *thread;
struct gdbarch *gdbarch = regcache->arch ();
ptid_t ptid = regcache->ptid ();
/* Make sure we know about new threads. */
inf_update_procs (gnu_current_inf);
thread = inf_tid_to_thread (gnu_current_inf, ptid.lwp ());
if (!thread)
error (_("Couldn't store registers into thread %s: No such thread"),
target_pid_to_str (ptid));
if (regno < I386_NUM_GREGS || regno == -1)
{
thread_state_t state;
thread_state_data_t old_state;
int was_aborted = thread->aborted;
int was_valid = thread->state_valid;
int trace;
if (!was_aborted && was_valid)
memcpy (&old_state, &thread->state, sizeof (old_state));
state = proc_get_state (thread, 1);
if (!state)
{
warning (_("Couldn't store registers into %s"),
proc_string (thread));
return;
}
/* Save the T bit. We might try to restore the %eflags register
below, but changing the T bit would seriously confuse GDB. */
trace = ((struct i386_thread_state *)state)->efl & 0x100;
if (!was_aborted && was_valid)
/* See which registers have changed after aborting the thread. */
{
int check_regno;
for (check_regno = 0; check_regno < I386_NUM_GREGS; check_regno++)
if ((thread->fetched_regs & (1 << check_regno))
&& memcpy (REG_ADDR (&old_state, check_regno),
REG_ADDR (state, check_regno),
register_size (gdbarch, check_regno)))
/* Register CHECK_REGNO has changed! Ack! */
{
warning (_("Register %s changed after the thread was aborted"),
gdbarch_register_name (gdbarch, check_regno));
if (regno >= 0 && regno != check_regno)
/* Update GDB's copy of the register. */
regcache->raw_supply (check_regno,
REG_ADDR (state, check_regno));
else
warning (_("... also writing this register! "
"Suspicious..."));
}
}
if (regno == -1)
{
int i;
proc_debug (thread, "storing all registers");
for (i = 0; i < I386_NUM_GREGS; i++)
if (REG_VALID == regcache->get_register_status (i))
regcache->raw_collect (i, REG_ADDR (state, i));
}
else
{
proc_debug (thread, "storing register %s",
gdbarch_register_name (gdbarch, regno));
gdb_assert (REG_VALID == regcache->get_register_status (regno));
regcache->raw_collect (regno, REG_ADDR (state, regno));
}
/* Restore the T bit. */
((struct i386_thread_state *)state)->efl &= ~0x100;
((struct i386_thread_state *)state)->efl |= trace;
}
if (regno >= I386_NUM_GREGS || regno == -1)
{
proc_debug (thread, "storing floating-point registers");
store_fpregs (regcache, thread, regno);
}
}
/* Store register REGNO back into the child process. If REGNO is -1,
do this for all registers (including the floating point and SSE
registers). */
static void
i386_linux_store_inferior_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
int tid;
/* Use the old method of poking around in `struct user' if the
SETREGS request isn't available. */
if (!have_ptrace_getregs)
{
int i;
for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
if (regno == -1 || regno == i)
store_register (regcache, i);
return;
}
/* GNU/Linux LWP ID's are process ID's. */
tid = ptid_get_lwp (inferior_ptid);
if (tid == 0)
tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
/* Use the PTRACE_SETFPXREGS requests whenever possible, since it
transfers more registers in one system call. But remember that
store_fpxregs can fail, and return zero. */
if (regno == -1)
{
store_regs (regcache, tid, regno);
if (store_xstateregs (regcache, tid, regno))
return;
if (store_fpxregs (regcache, tid, regno))
return;
store_fpregs (regcache, tid, regno);
return;
}
if (GETREGS_SUPPLIES (regno))
{
store_regs (regcache, tid, regno);
return;
}
if (GETXSTATEREGS_SUPPLIES (regno))
{
if (store_xstateregs (regcache, tid, regno))
return;
}
if (GETFPXREGS_SUPPLIES (regno))
{
if (store_fpxregs (regcache, tid, regno))
return;
/* Either our processor or our kernel doesn't support the SSE
registers, so just write the FP registers in the traditional
way. */
store_fpregs (regcache, tid, regno);
return;
}
internal_error (__FILE__, __LINE__,
_("Got request to store bad register number %d."), regno);
}
/* Store at least register REGNO, or all regs if REGNO == -1. */
void
gnu_store_registers (int regno)
{
struct proc *thread;
/* Make sure we know about new threads. */
inf_update_procs (current_inferior);
thread = inf_tid_to_thread (current_inferior, PIDGET (inferior_ptid));
if (!thread)
error ("Couldn't store registers into thread %d: No such thread",
PIDGET (inferior_ptid));
if (regno < I386_NUM_GREGS || regno == -1)
{
thread_state_t state;
thread_state_data_t old_state;
int was_aborted = thread->aborted;
int was_valid = thread->state_valid;
int trace;
if (!was_aborted && was_valid)
memcpy (&old_state, &thread->state, sizeof (old_state));
state = proc_get_state (thread, 1);
if (!state)
{
warning ("Couldn't store registers into %s", proc_string (thread));
return;
}
/* Save the T bit. We might try to restore the %eflags register
below, but changing the T bit would seriously confuse GDB. */
trace = ((struct i386_thread_state *)state)->efl & 0x100;
if (!was_aborted && was_valid)
/* See which registers have changed after aborting the thread. */
{
int check_regno;
for (check_regno = 0; check_regno < I386_NUM_GREGS; check_regno++)
if ((thread->fetched_regs & (1 << check_regno))
&& memcpy (REG_ADDR (&old_state, check_regno),
REG_ADDR (state, check_regno),
REGISTER_RAW_SIZE (check_regno)))
/* Register CHECK_REGNO has changed! Ack! */
{
warning ("Register %s changed after the thread was aborted",
REGISTER_NAME (check_regno));
if (regno >= 0 && regno != check_regno)
/* Update GDB's copy of the register. */
supply_register (check_regno, REG_ADDR (state, check_regno));
else
warning ("... also writing this register! Suspicious...");
}
}
#define fill(state, regno) \
memcpy (REG_ADDR(state, regno), ®isters[REGISTER_BYTE (regno)], \
REGISTER_RAW_SIZE (regno))
if (regno == -1)
{
int i;
proc_debug (thread, "storing all registers");
for (i = 0; i < I386_NUM_GREGS; i++)
if (register_valid[i])
fill (state, i);
}
else
{
proc_debug (thread, "storing register %s", REGISTER_NAME (regno));
gdb_assert (register_valid[regno]);
fill (state, regno);
}
/* Restore the T bit. */
((struct i386_thread_state *)state)->efl &= ~0x100;
((struct i386_thread_state *)state)->efl |= trace;
}
#undef fill
if (regno >= I386_NUM_GREGS || regno == -1)
{
proc_debug (thread, "storing floating-point registers");
store_fpregs (thread, regno);
}
}
