void
fetch_inferior_registers (int regno)
{
register unsigned int regaddr;
char buf[MAX_REGISTER_RAW_SIZE];
register int i;
registers_fetched ();
for (regno = 1; regno < NUM_REGS; regno++)
{
regaddr = REGISTER_PTRACE_ADDR (regno);
for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
{
*(int *) &buf[i] = ptrace (PT_READ_U, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) regaddr, 0);
regaddr += sizeof (int);
}
supply_register (regno, buf);
}
supply_register (ZERO_REGNUM, zerobuf);
/* Frame ptr reg must appear to be 0; it is faked by stack handling code. */
supply_register (FP_REGNUM, zerobuf);
}
/* All of this stuff is only relevant if both host and target are sun3. */
void
fetch_inferior_registers ()
{
struct regs inferior_registers;
#ifdef FP0_REGNUM
struct fp_status inferior_fp_registers;
#endif
extern char registers[];
registers_fetched ();
ptrace (PTRACE_GETREGS, inferior_pid,
(PTRACE_ARG3_TYPE) &inferior_registers, 0);
#ifdef FP0_REGNUM
ptrace (PTRACE_GETFPREGS, inferior_pid,
(PTRACE_ARG3_TYPE) &inferior_fp_registers, 0);
#endif
bcopy (&inferior_registers, registers, 16 * 4);
#ifdef FP0_REGNUM
bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.fps_regs);
#endif
*(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
*(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
#ifdef FP0_REGNUM
bcopy (&inferior_fp_registers.fps_control,
®isters[REGISTER_BYTE (FPC_REGNUM)],
sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
#endif
}
void
fetch_inferior_registers (int regno)
{
struct regs inferior_registers;
struct fp_status inferior_fp_registers;
registers_fetched ();
ptrace (PTRACE_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers);
if (FP0_REGNUM >= 0)
ptrace (PTRACE_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers);
memcpy (registers, &inferior_registers, 16 * 4);
if (FP0_REGNUM >= 0)
memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof inferior_fp_registers.fps_regs);
*(int *) ®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
*(int *) ®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
if (FP0_REGNUM >= 0)
memcpy (®isters[REGISTER_BYTE (FPC_REGNUM)],
&inferior_fp_registers.fps_control,
sizeof inferior_fp_registers -
sizeof inferior_fp_registers.fps_regs);
}
/* Get registers from a core file. REG_ADDR is unused. */
static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
unsigned int reg_addr)
{
struct coreregs *core_reg;
core_reg = (struct coreregs *) core_reg_sect;
/*
* We have *all* registers
* in the first core section.
* Ignore which.
*/
if (core_reg_size < sizeof (*core_reg))
{
fprintf_unfiltered (gdb_stderr, "Couldn't read regs from core file\n");
return;
}
/* Integer registers */
RF (R0_REGNUM + 0, core_reg->intreg.r_r0);
RF (R0_REGNUM + 1, core_reg->intreg.r_r1);
RF (R0_REGNUM + 2, core_reg->intreg.r_r2);
RF (R0_REGNUM + 3, core_reg->intreg.r_r3);
RF (R0_REGNUM + 4, core_reg->intreg.r_r4);
RF (R0_REGNUM + 5, core_reg->intreg.r_r5);
RF (R0_REGNUM + 6, core_reg->intreg.r_r6);
RF (R0_REGNUM + 7, core_reg->intreg.r_r7);
RF (SP_REGNUM, core_reg->intreg.r_sp);
RF (FP_REGNUM, core_reg->intreg.r_fp);
RF (PC_REGNUM, core_reg->intreg.r_pc);
RF (PS_REGNUM, core_reg->intreg.r_psr);
/* Floating point registers */
RF (FPS_REGNUM, core_reg->freg.r_fsr);
RF (FP0_REGNUM + 0, core_reg->freg.r_freg[0]);
RF (FP0_REGNUM + 2, core_reg->freg.r_freg[2]);
RF (FP0_REGNUM + 4, core_reg->freg.r_freg[4]);
RF (FP0_REGNUM + 6, core_reg->freg.r_freg[6]);
RF (LP0_REGNUM + 1, core_reg->freg.r_freg[1]);
RF (LP0_REGNUM + 3, core_reg->freg.r_freg[3]);
RF (LP0_REGNUM + 5, core_reg->freg.r_freg[5]);
RF (LP0_REGNUM + 7, core_reg->freg.r_freg[7]);
registers_fetched ();
}
void
fetch_inferior_registers (int regno)
{
struct reg inferior_registers;
struct fpreg inferior_fp_registers;
ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, 0);
memcpy (®isters[REGISTER_BYTE (0)], &inferior_registers,
sizeof (inferior_registers));
ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers, 0);
memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
sizeof (inferior_fp_registers));
registers_fetched ();
}
/*
* Get registers from a kernel crash dump or live kernel.
* Called by kcore-nbsd.c:get_kcore_registers().
*/
void
fetch_kcore_registers (struct pcb *pcb)
{
struct switchframe sf;
struct reg intreg;
int dummy;
/* Integer registers */
if (target_read_memory ((CORE_ADDR) pcb->pcb_ksp, (char *) &sf, sizeof sf))
error ("Cannot read integer registers.");
/* We use the psr at kernel entry */
if (target_read_memory ((CORE_ADDR) pcb->pcb_onstack, (char *) &intreg, sizeof intreg))
error ("Cannot read processor status register.");
dummy = 0;
RF (R0_REGNUM + 0, dummy);
RF (R0_REGNUM + 1, dummy);
RF (R0_REGNUM + 2, dummy);
RF (R0_REGNUM + 3, sf.sf_r3);
RF (R0_REGNUM + 4, sf.sf_r4);
RF (R0_REGNUM + 5, sf.sf_r5);
RF (R0_REGNUM + 6, sf.sf_r6);
RF (R0_REGNUM + 7, sf.sf_r7);
dummy = pcb->pcb_kfp + 8;
RF (SP_REGNUM, dummy);
RF (FP_REGNUM, sf.sf_fp);
RF (PC_REGNUM, sf.sf_pc);
RF (PS_REGNUM, intreg.r_psr);
/* Floating point registers */
RF (FPS_REGNUM, pcb->pcb_fsr);
RF (FP0_REGNUM + 0, pcb->pcb_freg[0]);
RF (FP0_REGNUM + 2, pcb->pcb_freg[2]);
RF (FP0_REGNUM + 4, pcb->pcb_freg[4]);
RF (FP0_REGNUM + 6, pcb->pcb_freg[6]);
RF (LP0_REGNUM + 1, pcb->pcb_freg[1]);
RF (LP0_REGNUM + 3, pcb->pcb_freg[3]);
RF (LP0_REGNUM + 5, pcb->pcb_freg[5]);
RF (LP0_REGNUM + 7, pcb->pcb_freg[7]);
registers_fetched ();
}
void
fetch_inferior_registers (int regno)
{
struct reg inferior_registers;
struct fpreg inferior_fpregisters;
ptrace (PT_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers, 0);
ptrace (PT_GETFPREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fpregisters, 0);
RF (R0_REGNUM + 0, inferior_registers.r_r0);
RF (R0_REGNUM + 1, inferior_registers.r_r1);
RF (R0_REGNUM + 2, inferior_registers.r_r2);
RF (R0_REGNUM + 3, inferior_registers.r_r3);
RF (R0_REGNUM + 4, inferior_registers.r_r4);
RF (R0_REGNUM + 5, inferior_registers.r_r5);
RF (R0_REGNUM + 6, inferior_registers.r_r6);
RF (R0_REGNUM + 7, inferior_registers.r_r7);
RF (SP_REGNUM, inferior_registers.r_sp);
RF (FP_REGNUM, inferior_registers.r_fp);
RF (PC_REGNUM, inferior_registers.r_pc);
RF (PS_REGNUM, inferior_registers.r_psr);
RF (FPS_REGNUM, inferior_fpregisters.r_fsr);
RF (FP0_REGNUM + 0, inferior_fpregisters.r_freg[0]);
RF (FP0_REGNUM + 2, inferior_fpregisters.r_freg[2]);
RF (FP0_REGNUM + 4, inferior_fpregisters.r_freg[4]);
RF (FP0_REGNUM + 6, inferior_fpregisters.r_freg[6]);
RF (LP0_REGNUM + 1, inferior_fpregisters.r_freg[1]);
RF (LP0_REGNUM + 3, inferior_fpregisters.r_freg[3]);
RF (LP0_REGNUM + 5, inferior_fpregisters.r_freg[5]);
RF (LP0_REGNUM + 7, inferior_fpregisters.r_freg[7]);
registers_fetched ();
}
void
fetch_inferior_registers (int ignored)
{
struct ptrace_$data_regs_m68k inferior_registers;
struct ptrace_$floating_regs_m68k inferior_fp_registers;
struct ptrace_$control_regs_m68k inferior_control_registers;
ptrace_$init_control (&inferior_control_registers);
inferior_fp_registers.size = sizeof (inferior_fp_registers);
registers_fetched ();
ptrace (PTRACE_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_registers,
ptrace_$data_set,
(PTRACE_ARG3_TYPE) & inferior_registers,
ptrace_$data_set);
ptrace (PTRACE_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_fp_registers,
ptrace_$floating_set_m68k,
(PTRACE_ARG3_TYPE) & inferior_fp_registers,
ptrace_$floating_set_m68k);
ptrace (PTRACE_GETREGS, PIDGET (inferior_ptid),
(PTRACE_ARG3_TYPE) & inferior_control_registers,
ptrace_$control_set_m68k,
(PTRACE_ARG3_TYPE) & inferior_control_registers,
ptrace_$control_set_m68k);
bcopy (&inferior_registers, registers, 16 * 4);
bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
sizeof inferior_fp_registers.regs);
*(int *) ®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_control_registers.sr;
*(int *) ®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_control_registers.pc;
}
/* Fech thread's registers. if regno == -1, fetch all regs */
void
fetch_inferior_registers (int regno)
{
kern_return_t ret;
thread_state_data_t state;
struct mips_exc_state exc_state;
int stateCnt = MIPS_THREAD_STATE_COUNT;
int which_regs = 0; /* A bit mask */
if (!MACH_PORT_VALID (current_thread))
error ("fetch inferior registers: Invalid thread");
if (regno < -1 || regno >= NUM_REGS)
error ("invalid register %d supplied to fetch_inferior_registers", regno);
if (regno == -1)
which_regs = REGS_ALL;
else if (regno == ZERO_REGNUM)
{
int zero = 0;
supply_register (ZERO_REGNUM, &zero);
return;
}
else if ((ZERO_REGNUM < regno && regno < PS_REGNUM)
|| regno == FP_REGNUM
|| regno == LO_REGNUM
|| regno == HI_REGNUM
|| regno == PC_REGNUM)
which_regs = REGS_NORMAL;
else if (FP0_REGNUM <= regno && regno <= FCRIR_REGNUM)
which_regs = REGS_COP1 | REGS_EXC;
else
which_regs = REGS_EXC;
/* fetch regs saved to mips_thread_state */
if (which_regs & REGS_NORMAL)
{
ret = thread_get_state (current_thread,
MIPS_THREAD_STATE,
state,
&stateCnt);
CHK ("fetch inferior registers: thread_get_state", ret);
if (which_regs == REGS_NORMAL)
{
/* Fetch also FP_REGNUM if fetching MACH_FP_REGNUM and vice versa */
if (regno == MACH_FP_REGNUM || regno == FP_REGNUM)
{
supply_register (FP_REGNUM,
(char *) state + reg_offset[MACH_FP_REGNUM]);
supply_register (MACH_FP_REGNUM,
(char *) state + reg_offset[MACH_FP_REGNUM]);
}
else
supply_register (regno,
(char *) state + reg_offset[regno]);
return;
}
/* ZERO_REGNUM is always zero */
*(int *) registers = 0;
/* Copy thread saved regs 1..31 to gdb's reg value array
* Luckily, they are contiquous
*/
FETCH_REGS (state, 1, 31);
/* Copy mdlo and mdhi */
FETCH_REGS (state, LO_REGNUM, 2);
/* Copy PC */
FETCH_REGS (state, PC_REGNUM, 1);
/* Mach 3.0 saves FP to MACH_FP_REGNUM.
* For some reason gdb wants to assign a pseudo register for it.
*/
FETCH_REGS (state, FP_REGNUM, 1);
}
/* Read exc state. Also read if need to fetch floats */
if (which_regs & REGS_EXC)
{
stateCnt = MIPS_EXC_STATE_COUNT;
ret = thread_get_state (current_thread,
MIPS_EXC_STATE,
(thread_state_t) & exc_state,
&stateCnt);
CHK ("fetch inferior regs (exc): thread_get_state", ret);
/* We need to fetch exc_state to see if the floating
* state is valid for the thread.
*/
/* cproc_state: Which coprocessors the thread uses */
supply_register (PS_REGNUM,
(char *) &exc_state + reg_offset[PS_REGNUM]);
if (which_regs == REGS_EXC || which_regs == REGS_ALL)
{
supply_register (BADVADDR_REGNUM,
(char *) &exc_state + reg_offset[BADVADDR_REGNUM]);
supply_register (CAUSE_REGNUM,
(char *) &exc_state + reg_offset[CAUSE_REGNUM]);
if (which_regs == REGS_EXC)
return;
}
}
if (which_regs & REGS_COP1)
{
/* If the thread does not have saved COPROC1, set regs to zero */
if (!(exc_state.coproc_state & MIPS_STATUS_USE_COP1))
bzero (®isters[REGISTER_BYTE (FP0_REGNUM)],
sizeof (struct mips_float_state));
else
{
stateCnt = MIPS_FLOAT_STATE_COUNT;
ret = thread_get_state (current_thread,
MIPS_FLOAT_STATE,
state,
&stateCnt);
CHK ("fetch inferior regs (floats): thread_get_state", ret);
if (regno != -1)
{
supply_register (regno,
(char *) state + reg_offset[regno]);
return;
}
FETCH_REGS (state, FP0_REGNUM, 34);
}
}
/* All registers are valid, if not returned yet */
registers_fetched ();
}
