static void
i386bsd_fetch_inferior_registers (struct target_ops *ops,
struct regcache *regcache, int regnum)
{
pid_t pid = get_ptrace_pid (regcache_get_ptid (regcache));
if (regnum == -1 || GETREGS_SUPPLIES (regnum))
{
struct reg regs;
if (ptrace (PT_GETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
i386bsd_supply_gregset (regcache, ®s);
if (regnum != -1)
return;
}
if (regnum == -1 || regnum >= I386_ST0_REGNUM)
{
struct fpreg fpregs;
#ifdef HAVE_PT_GETXMMREGS
char xmmregs[512];
#endif
#ifdef PT_GETXSTATE_INFO
if (x86bsd_xsave_len != 0)
{
void *xstateregs;
xstateregs = alloca (x86bsd_xsave_len);
if (ptrace (PT_GETXSTATE, pid,
(PTRACE_TYPE_ARG3) xstateregs, 0) == -1)
perror_with_name (_("Couldn't get extended state status"));
i387_supply_xsave (regcache, -1, xstateregs);
return;
}
#endif
#ifdef HAVE_PT_GETXMMREGS
if (have_ptrace_xmmregs != 0
&& ptrace(PT_GETXMMREGS, pid, (PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
{
have_ptrace_xmmregs = 1;
i387_supply_fxsave (regcache, -1, xmmregs);
}
else
{
have_ptrace_xmmregs = 0;
#endif
if (ptrace (PT_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
i387_supply_fsave (regcache, -1, &fpregs);
#ifdef HAVE_PT_GETXMMREGS
}
#endif
}
}
static void
i386nto_supply_fpregset (char *fpregs)
{
if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR)
i387_supply_fxsave (current_regcache, -1, fpregs);
else
i387_supply_fsave (current_regcache, -1, fpregs);
}
ps_err_e
ps_lsetxmmregs (struct ps_prochandle *ph, lwpid_t lwpid,
const char *xmmregs)
{
struct cleanup *old_chain;
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
i387_supply_fxsave (current_regcache, -1, xmmregs);
target_store_registers (-1);
do_cleanups (old_chain);
return PS_OK;
}
static void
fbsd_thread_fetch_registers (struct target_ops *ops,
struct regcache *regcache, int regnum)
{
prgregset_t gregset;
prfpregset_t fpregset;
td_thrhandle_t th;
td_err_e err;
#ifdef PT_GETXMMREGS
char xmmregs[512];
#endif
if (!IS_THREAD (inferior_ptid))
{
fbsd_lwp_fetch_registers (ops, regcache, regnum);
return;
}
err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
if (err != TD_OK)
error ("Cannot find thread %d: Thread ID=%ld, %s",
pid_to_thread_id (inferior_ptid),
GET_THREAD (inferior_ptid), thread_db_err_str (err));
err = td_thr_getgregs_p (&th, gregset);
if (err != TD_OK)
error ("Cannot fetch general-purpose registers for thread %d: Thread ID=%ld, %s",
pid_to_thread_id (inferior_ptid),
GET_THREAD (inferior_ptid), thread_db_err_str (err));
#ifdef PT_GETXMMREGS
err = td_thr_getxmmregs_p (&th, xmmregs);
if (err == TD_OK)
{
i387_supply_fxsave (regcache, -1, xmmregs);
}
else
{
#endif
err = td_thr_getfpregs_p (&th, &fpregset);
if (err != TD_OK)
error ("Cannot get floating-point registers for thread %d: Thread ID=%ld, %s",
pid_to_thread_id (inferior_ptid),
GET_THREAD (inferior_ptid), thread_db_err_str (err));
supply_fpregset (regcache, &fpregset);
#ifdef PT_GETXMMREGS
}
#endif
supply_gregset (regcache, gregset);
}
ps_err_e
ps_lsetxmmregs (struct ps_prochandle *ph, lwpid_t lwpid,
const char *xmmregs)
{
struct cleanup *old_chain;
struct regcache *regcache;
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
i387_supply_fxsave (regcache, -1, xmmregs);
target_store_registers (regcache, -1);
do_cleanups (old_chain);
return PS_OK;
}
void
amd64_supply_fxsave(struct regcache *regcache, int regnum,
const void *fxsave)
{
i387_supply_fxsave(regcache, regnum, fxsave);
if (fxsave && (gdbarch_ptr_bit(get_regcache_arch(regcache)) == 64))
{
const gdb_byte *regs = (const gdb_byte *)fxsave;
if ((regnum == -1) || (regnum == I387_FISEG_REGNUM))
regcache_raw_supply(regcache, I387_FISEG_REGNUM, regs + 12);
if ((regnum == -1) || (regnum == I387_FOSEG_REGNUM))
regcache_raw_supply(regcache, I387_FOSEG_REGNUM, regs + 20);
}
}
static void
i386bsd_fetch_inferior_registers (struct target_ops *ops,
struct regcache *regcache, int regnum)
{
if (regnum == -1 || GETREGS_SUPPLIES (regnum))
{
struct reg regs;
if (ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
i386bsd_supply_gregset (regcache, ®s);
if (regnum != -1)
return;
}
if (regnum == -1 || regnum >= I386_ST0_REGNUM)
{
struct fpreg fpregs;
#ifdef HAVE_PT_GETXMMREGS
char xmmregs[512];
if (have_ptrace_xmmregs != 0
&& ptrace(PT_GETXMMREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) xmmregs, 0) == 0)
{
have_ptrace_xmmregs = 1;
i387_supply_fxsave (regcache, -1, xmmregs);
}
else
{
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
i387_supply_fsave (regcache, -1, &fpregs);
}
#else
if (ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
i387_supply_fsave (regcache, -1, &fpregs);
#endif
}
}
static void
fbsd_lwp_fetch_registers (struct target_ops *ops,
struct regcache *regcache, int regnum)
{
gregset_t gregs;
fpregset_t fpregs;
lwpid_t lwp;
#ifdef PT_GETXMMREGS
char xmmregs[512];
#endif
if (!target_has_execution)
{
struct target_ops *beneath = find_target_beneath (ops);
beneath->to_fetch_registers (ops, regcache, regnum);
return;
}
lwp = GET_LWP (inferior_ptid);
if (ptrace (PT_GETREGS, lwp, (caddr_t) &gregs, 0) == -1)
error ("Cannot get lwp %d registers: %s\n", lwp, safe_strerror (errno));
supply_gregset (regcache, &gregs);
#ifdef PT_GETXMMREGS
if (ptrace (PT_GETXMMREGS, lwp, xmmregs, 0) == 0)
{
i387_supply_fxsave (regcache, -1, xmmregs);
}
else
{
#endif
if (ptrace (PT_GETFPREGS, lwp, (caddr_t) &fpregs, 0) == -1)
error ("Cannot get lwp %d registers: %s\n ", lwp, safe_strerror (errno));
supply_fpregset (regcache, &fpregs);
#ifdef PT_GETXMMREGS
}
#endif
}
static int
fetch_fpxregs (struct regcache *regcache, int tid)
{
elf_fpxregset_t fpxregs;
if (! have_ptrace_getfpxregs)
return 0;
if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
{
if (errno == EIO)
{
have_ptrace_getfpxregs = 0;
return 0;
}
perror_with_name (_("Couldn't read floating-point and SSE registers"));
}
i387_supply_fxsave (regcache, -1, (const elf_fpxregset_t *) &fpxregs);
return 1;
}
static void
fbsd_lwp_fetch_registers (int regno)
{
gregset_t gregs;
fpregset_t fpregs;
lwpid_t lwp;
#ifdef PT_GETXMMREGS
char xmmregs[512];
#endif
if (!target_has_execution)
{
orig_core_ops.to_fetch_registers (-1);
return;
}
/* XXX: We've replaced the pid with the lwpid for GDB's benefit. */
lwp = GET_PID (inferior_ptid);
if (ptrace (PT_GETREGS, lwp, (caddr_t) &gregs, 0) == -1)
error ("Cannot get lwp %d registers: %s\n", lwp, safe_strerror (errno));
supply_gregset (&gregs);
#ifdef PT_GETXMMREGS
if (ptrace (PT_GETXMMREGS, lwp, xmmregs, 0) == 0)
{
i387_supply_fxsave (current_regcache, -1, xmmregs);
}
else
{
#endif
if (ptrace (PT_GETFPREGS, lwp, (caddr_t) &fpregs, 0) == -1)
error ("Cannot get lwp %d registers: %s\n ", lwp, safe_strerror (errno));
supply_fpregset (&fpregs);
#ifdef PT_GETXMMREGS
}
#endif
}
/* Read register values from the inferior process.
If REGNO is -1, do this for all registers.
Otherwise, REGNO specifies which register (so we can save time). */
static void
i386_darwin_fetch_inferior_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
thread_t current_thread = ptid_get_tid (inferior_ptid);
int fetched = 0;
struct gdbarch *gdbarch = get_regcache_arch (regcache);
#ifdef BFD64
if (gdbarch_ptr_bit (gdbarch) == 64)
{
if (regno == -1 || amd64_native_gregset_supplies_p (gdbarch, regno))
{
x86_thread_state_t gp_regs;
unsigned int gp_count = x86_THREAD_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state
(current_thread, x86_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error calling thread_get_state for "
"GP registers for thread 0x%ulx"),
current_thread);
MACH_CHECK_ERROR (ret);
}
amd64_supply_native_gregset (regcache, &gp_regs.uts, -1);
fetched++;
}
if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno))
{
x86_float_state_t fp_regs;
unsigned int fp_count = x86_FLOAT_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state
(current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs,
&fp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error calling thread_get_state for "
"float registers for thread 0x%ulx"),
current_thread);
MACH_CHECK_ERROR (ret);
}
amd64_supply_fxsave (regcache, -1, &fp_regs.ufs.fs64.__fpu_fcw);
fetched++;
}
}
else
#endif
{
if (regno == -1 || regno < I386_NUM_GREGS)
{
i386_thread_state_t gp_regs;
unsigned int gp_count = i386_THREAD_STATE_COUNT;
kern_return_t ret;
int i;
ret = thread_get_state
(current_thread, i386_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error calling thread_get_state for "
"GP registers for thread 0x%ulx"),
current_thread);
MACH_CHECK_ERROR (ret);
}
for (i = 0; i < I386_NUM_GREGS; i++)
regcache_raw_supply
(regcache, i,
(char *)&gp_regs + i386_darwin_thread_state_reg_offset[i]);
fetched++;
}
if (regno == -1
|| (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS))
{
i386_float_state_t fp_regs;
unsigned int fp_count = i386_FLOAT_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state
(current_thread, i386_FLOAT_STATE, (thread_state_t) & fp_regs,
&fp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered (_("Error calling thread_get_state for "
"float registers for thread 0x%ulx"),
current_thread);
MACH_CHECK_ERROR (ret);
}
i387_supply_fxsave (regcache, -1, &fp_regs.__fpu_fcw);
fetched++;
}
}
if (! fetched)
{
warning (_("unknown register %d"), regno);
regcache_raw_supply (regcache, regno, NULL);
}
}
void
supply_fpxregset (elf_fpxregset_t *fpxregsetp)
{
i387_supply_fxsave (current_regcache, -1, fpxregsetp);
}
void
supply_fpxregset (struct regcache *regcache,
const elf_fpxregset_t *fpxregsetp)
{
i387_supply_fxsave (regcache, -1, fpxregsetp);
}
