void
alphabsd_fill_fpreg (char *fpregs, int regno)
{
int i;
for (i = FP0_REGNUM; i < FP0_REGNUM + NUM_FPREGS; i++)
if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i))
regcache_collect (i, fpregs + ((i - FP0_REGNUM) * 8));
if (regno == ALPHA_FPCR_REGNUM || regno == -1)
regcache_collect (ALPHA_FPCR_REGNUM, fpregs + (32 * 8));
}
void
alphabsd_fill_reg (char *regs, int regno)
{
int i;
for (i = 0; i < NUM_GREGS; i++)
if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i))
regcache_collect (i, regs + (i * 8));
/* The PC travels in the ZERO slot. */
if (regno == PC_REGNUM || regno == -1)
regcache_collect (PC_REGNUM, regs + (31 * 8));
}
void
ppcnbsd_fill_fpreg (char *fpregs, int regno)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int i;
for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
{
if (regno == i || regno == -1)
regcache_collect (i, fpregs + FPREG_FPR_OFFSET (i - FP0_REGNUM));
}
if (regno == tdep->ppc_fpscr_regnum || regno == -1)
regcache_collect (tdep->ppc_fpscr_regnum, fpregs + FPREG_FPSCR_OFFSET);
}
static int
i386nto_regset_fill (int regset, char *data)
{
if (regset == NTO_REG_GENERAL)
{
int regno;
for (regno = 0; regno < NUM_GPREGS; regno++)
{
int offset = nto_reg_offset (regno);
if (offset != -1)
regcache_collect (regno, data + offset);
}
}
else if (regset == NTO_REG_FLOAT)
{
if (nto_cpuinfo_valid && nto_cpuinfo_flags | X86_CPU_FXSR)
i387_fill_fxsave (data, -1);
else
i387_fill_fsave (data, -1);
}
else
return -1;
return 0;
}
void
fill_gregset (struct reg *gregset, int regno)
{
int i;
for (i = ARM_A1_REGNUM; i < ARM_SP_REGNUM; i++)
if ((regno == -1 || regno == i))
regcache_collect (i, &gregset->r[i]);
if (regno == -1 || regno == ARM_SP_REGNUM)
regcache_collect (ARM_SP_REGNUM, &gregset->r_sp);
if (regno == -1 || regno == ARM_LR_REGNUM)
regcache_collect (ARM_LR_REGNUM, &gregset->r_lr);
if (regno == -1 || regno == ARM_PC_REGNUM)
regcache_collect (ARM_PC_REGNUM, &gregset->r_pc);
if (regno == -1 || regno == ARM_PS_REGNUM)
regcache_collect (ARM_PS_REGNUM, &gregset->r_cpsr);
}
void
mipsfbsd_fill_reg (char *regs, int regno)
{
int i;
for (i = 0; i <= PC_REGNUM; i++)
if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i))
regcache_collect (i, regs + (i * mips_regsize (current_gdbarch)));
}
void
fill_gregset (gregset_t *gregsetp, int regno)
{
greg_t *regp = (greg_t *) gregsetp;
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
if (regno == -1 || regno == i)
regcache_collect (i, regp + regmap[i]);
}
void
mipsfbsd_fill_fpreg (char *fpregs, int regno)
{
int i;
for (i = FP0_REGNUM; i <= mips_regnum (current_gdbarch)->fp_control_status;
i++)
if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i))
regcache_collect (i,
fpregs + ((i - FP0_REGNUM) * mips_regsize (current_gdbarch)));
}
void
ppcnbsd_fill_reg (char *regs, int regno)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int i;
for (i = 0; i <= 31; i++)
{
if (regno == i || regno == -1)
regcache_collect (i, regs + REG_FIXREG_OFFSET (i));
}
if (regno == tdep->ppc_lr_regnum || regno == -1)
regcache_collect (tdep->ppc_lr_regnum, regs + REG_LR_OFFSET);
if (regno == tdep->ppc_cr_regnum || regno == -1)
regcache_collect (tdep->ppc_cr_regnum, regs + REG_CR_OFFSET);
if (regno == tdep->ppc_xer_regnum || regno == -1)
regcache_collect (tdep->ppc_xer_regnum, regs + REG_XER_OFFSET);
if (regno == tdep->ppc_ctr_regnum || regno == -1)
regcache_collect (tdep->ppc_ctr_regnum, regs + REG_CTR_OFFSET);
if (regno == PC_REGNUM || regno == -1)
regcache_collect (PC_REGNUM, regs + REG_PC_OFFSET);
}
static void
store_fp_regs (void)
{
struct fpreg inferior_fp_registers;
int ret;
int regno;
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
regcache_collect
(regno, (char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
regcache_collect (ARM_FPS_REGNUM, (char *) &inferior_fp_registers.fpr_fpsr);
#ifndef CROSS_DEBUGGER
ret = ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) &inferior_fp_registers, 0);
if (ret < 0)
warning ("unable to store floating-point registers");
#endif
}
static void
store_fp_register (int regno)
{
struct fpreg inferior_fp_registers;
#ifndef CROSS_DEBUGGER
int ret;
ret = ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) &inferior_fp_registers, 0);
if (ret < 0)
{
warning ("unable to fetch floating-point registers");
return;
}
#endif
switch (regno)
{
case ARM_FPS_REGNUM:
regcache_collect (ARM_FPS_REGNUM,
(char *) &inferior_fp_registers.fpr_fpsr);
break;
default:
regcache_collect
(regno, (char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
break;
}
#ifndef CROSS_DEBUGGER
ret = ptrace (PT_SETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) &inferior_fp_registers, 0);
if (ret < 0)
warning ("unable to write register %d to inferior", regno);
#endif
}
static void
store_regs (void)
{
struct reg inferior_registers;
int ret;
int regno;
for (regno = ARM_A1_REGNUM; regno < ARM_SP_REGNUM; regno++)
regcache_collect (regno, (char *) &inferior_registers.r[regno]);
regcache_collect (ARM_SP_REGNUM, (char *) &inferior_registers.r_sp);
regcache_collect (ARM_LR_REGNUM, (char *) &inferior_registers.r_lr);
if (arm_apcs_32)
{
regcache_collect (ARM_PC_REGNUM, (char *) &inferior_registers.r_pc);
regcache_collect (ARM_PS_REGNUM, (char *) &inferior_registers.r_cpsr);
}
else
{
unsigned pc_val;
unsigned psr_val;
regcache_collect (ARM_PC_REGNUM, (char *) &pc_val);
regcache_collect (ARM_PS_REGNUM, (char *) &psr_val);
pc_val = ADDR_BITS_REMOVE (pc_val);
psr_val ^= ADDR_BITS_REMOVE (psr_val);
inferior_registers.r_pc = pc_val | psr_val;
}
#ifndef CROSS_DEBUGGER
ret = ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) &inferior_registers, 0);
if (ret < 0)
warning ("unable to store general registers");
#endif
}
static void
fbsd_thread_store_registers (int regno)
{
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_store_registers (regno);
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));
if (regno != -1)
{
char old_value[MAX_REGISTER_SIZE];
regcache_collect (regno, old_value);
err = td_thr_getgregs_p (&th, gregset);
if (err != TD_OK)
error ("%s: td_thr_getgregs %s", __func__, thread_db_err_str (err));
#ifdef PT_GETXMMREGS
err = td_thr_getxmmregs_p (&th, xmmregs);
if (err != TD_OK)
{
#endif
err = td_thr_getfpregs_p (&th, &fpregset);
if (err != TD_OK)
error ("%s: td_thr_getfpgregs %s", __func__, thread_db_err_str (err));
#ifdef PT_GETXMMREGS
}
#endif
supply_register (regno, old_value);
}
fill_gregset (gregset, regno);
err = td_thr_setgregs_p (&th, gregset);
if (err != TD_OK)
error ("Cannot store general-purpose registers for thread %d: Thread ID=%d, %s",
pid_to_thread_id (inferior_ptid), GET_THREAD (inferior_ptid),
thread_db_err_str (err));
#ifdef PT_GETXMMREGS
i387_fill_fxsave (xmmregs, regno);
err = td_thr_setxmmregs_p (&th, xmmregs);
if (err == TD_OK)
return;
#endif
fill_fpregset (&fpregset, regno);
err = td_thr_setfpregs_p (&th, &fpregset);
if (err != TD_OK)
error ("Cannot store floating-point registers for thread %d: Thread ID=%d, %s",
pid_to_thread_id (inferior_ptid), GET_THREAD (inferior_ptid),
thread_db_err_str (err));
}
static void
store_register (int regno)
{
struct reg inferior_registers;
#ifndef CROSS_DEBUGGER
int ret;
ret = ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) &inferior_registers, 0);
if (ret < 0)
{
warning ("unable to fetch general registers");
return;
}
#endif
switch (regno)
{
case ARM_SP_REGNUM:
regcache_collect (ARM_SP_REGNUM, (char *) &inferior_registers.r_sp);
break;
case ARM_LR_REGNUM:
regcache_collect (ARM_LR_REGNUM, (char *) &inferior_registers.r_lr);
break;
case ARM_PC_REGNUM:
if (arm_apcs_32)
regcache_collect (ARM_PC_REGNUM, (char *) &inferior_registers.r_pc);
else
{
unsigned pc_val;
regcache_collect (ARM_PC_REGNUM, (char *) &pc_val);
pc_val = ADDR_BITS_REMOVE (pc_val);
inferior_registers.r_pc
^= ADDR_BITS_REMOVE (inferior_registers.r_pc);
inferior_registers.r_pc |= pc_val;
}
break;
case ARM_PS_REGNUM:
if (arm_apcs_32)
regcache_collect (ARM_PS_REGNUM, (char *) &inferior_registers.r_cpsr);
else
{
unsigned psr_val;
regcache_collect (ARM_PS_REGNUM, (char *) &psr_val);
psr_val ^= ADDR_BITS_REMOVE (psr_val);
inferior_registers.r_pc = ADDR_BITS_REMOVE (inferior_registers.r_pc);
inferior_registers.r_pc |= psr_val;
}
break;
default:
regcache_collect (regno, (char *) &inferior_registers.r[regno]);
break;
}
#ifndef CROSS_DEBUGGER
ret = ptrace (PT_SETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) &inferior_registers, 0);
if (ret < 0)
warning ("unable to write register %d to inferior", regno);
#endif
}
static void
sol_thread_store_registers (int regno)
{
thread_t thread;
td_thrhandle_t thandle;
td_err_e val;
prgregset_t gregset;
prfpregset_t fpregset;
#if 0
int xregsize;
caddr_t xregset;
#endif
if (!is_thread (inferior_ptid))
{ /* LWP: pass the request on to procfs.c */
procfs_ops.to_store_registers (regno);
return;
}
/* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
thread = GET_THREAD (inferior_ptid);
val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
if (val != TD_OK)
error ("sol_thread_store_registers: td_ta_map_id2thr %s",
td_err_string (val));
if (regno != -1)
{ /* Not writing all the regs */
char old_value[MAX_REGISTER_SIZE];
/* Save new register value. */
regcache_collect (regno, old_value);
val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
error ("sol_thread_store_registers: td_thr_getgregs %s",
td_err_string (val));
val = p_td_thr_getfpregs (&thandle, &fpregset);
if (val != TD_OK)
error ("sol_thread_store_registers: td_thr_getfpregs %s",
td_err_string (val));
/* Restore new register value. */
supply_register (regno, old_value);
#if 0
/* thread_db doesn't seem to handle this right */
val = td_thr_getxregsize (&thandle, &xregsize);
if (val != TD_OK && val != TD_NOXREGS)
error ("sol_thread_store_registers: td_thr_getxregsize %s",
td_err_string (val));
if (val == TD_OK)
{
xregset = alloca (xregsize);
val = td_thr_getxregs (&thandle, xregset);
if (val != TD_OK)
error ("sol_thread_store_registers: td_thr_getxregs %s",
td_err_string (val));
}
#endif
}
fill_gregset ((gdb_gregset_t *) &gregset, regno);
fill_fpregset ((gdb_fpregset_t *) &fpregset, regno);
val = p_td_thr_setgregs (&thandle, gregset);
if (val != TD_OK)
error ("sol_thread_store_registers: td_thr_setgregs %s",
td_err_string (val));
val = p_td_thr_setfpregs (&thandle, &fpregset);
if (val != TD_OK)
error ("sol_thread_store_registers: td_thr_setfpregs %s",
td_err_string (val));
#if 0
/* thread_db doesn't seem to handle this right */
val = td_thr_getxregsize (&thandle, &xregsize);
if (val != TD_OK && val != TD_NOXREGS)
error ("sol_thread_store_registers: td_thr_getxregsize %s",
td_err_string (val));
/* Should probably do something about writing the xregs here, but what are
they? */
#endif
}