#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "gdbcore.h"
#include "regcache.h"
#include <sys/types.h>
#include <sys/param.h>
#include <signal.h>
#include <sys/user.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/procfs.h>
#include <sys/ptrace.h>
#include "gregset.h"
#include "ppc-tdep.h"
#ifndef PT_READ_U
#define PT_READ_U PTRACE_PEEKUSR
#endif
#ifndef PT_WRITE_U
#define PT_WRITE_U PTRACE_POKEUSR
#endif
#ifndef PTRACE_XFER_TYPE
#define PTRACE_XFER_TYPE int
#endif
int
kernel_u_size (void)
{
return (sizeof (struct user));
}
static int
ppc_register_u_addr (int regno)
{
int u_addr = -1;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (regno >= tdep->ppc_gp0_regnum && regno <= tdep->ppc_gplast_regnum )
u_addr = ((PT_R0 + regno) * 4);
if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
u_addr = ((PT_FPR0 + (regno - FP0_REGNUM) * 2) * 4);
if (regno == PC_REGNUM)
u_addr = PT_NIP * 4;
if (regno == tdep->ppc_lr_regnum)
u_addr = PT_LNK * 4;
if (regno == tdep->ppc_cr_regnum)
u_addr = PT_CCR * 4;
if (regno == tdep->ppc_xer_regnum)
u_addr = PT_XER * 4;
if (regno == tdep->ppc_ctr_regnum)
u_addr = PT_CTR * 4;
if (regno == tdep->ppc_mq_regnum)
u_addr = PT_MQ * 4;
if (regno == tdep->ppc_ps_regnum)
u_addr = PT_MSR * 4;
return u_addr;
}
static int
ppc_ptrace_cannot_fetch_store_register (int regno)
{
return (ppc_register_u_addr (regno) == -1);
}
static void
fetch_register (int regno)
{
char mess[128];
register int i;
unsigned int offset;
char *buf = alloca (MAX_REGISTER_RAW_SIZE);
int tid;
CORE_ADDR regaddr = ppc_register_u_addr (regno);
if (regaddr == -1)
{
memset (buf, '\0', REGISTER_RAW_SIZE (regno));
supply_register (regno, buf);
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
*(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
(PTRACE_ARG3_TYPE) regaddr, 0);
regaddr += sizeof (PTRACE_XFER_TYPE);
if (errno != 0)
{
sprintf (mess, "reading register %s (#%d)",
REGISTER_NAME (regno), regno);
perror_with_name (mess);
}
}
supply_register (regno, buf);
}
static void
fetch_ppc_registers (void)
{
int i;
int last_register = gdbarch_tdep (current_gdbarch)->ppc_mq_regnum;
for (i = 0; i <= last_register; i++)
fetch_register (i);
}
void
fetch_inferior_registers (int regno)
{
if (regno == -1)
fetch_ppc_registers ();
else
fetch_register (regno);
}
static void
store_register (int regno)
{
CORE_ADDR regaddr = ppc_register_u_addr (regno);
char mess[128];
register int i;
unsigned int offset;
int tid;
char *buf = alloca (MAX_REGISTER_RAW_SIZE);
if (regaddr == -1)
{
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
regcache_collect (regno, buf);
for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
*(PTRACE_XFER_TYPE *) & buf[i]);
regaddr += sizeof (PTRACE_XFER_TYPE);
if (errno != 0)
{
sprintf (mess, "writing register %s (#%d)",
REGISTER_NAME (regno), regno);
perror_with_name (mess);
}
}
}
static void
store_ppc_registers (void)
{
int i;
int last_register = gdbarch_tdep (current_gdbarch)->ppc_mq_regnum;
for (i = 0; i <= last_register; i++)
store_register (i);
}
void
store_inferior_registers (int regno)
{
if (regno >= 0)
store_register (regno);
else
store_ppc_registers ();
}
void
supply_gregset (gdb_gregset_t *gregsetp)
{
int regi;
register elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
for (regi = 0; regi < 32; regi++)
supply_register (regi, (char *) (regp + regi));
supply_register (PC_REGNUM, (char *) (regp + PT_NIP));
supply_register (tdep->ppc_lr_regnum, (char *) (regp + PT_LNK));
supply_register (tdep->ppc_cr_regnum, (char *) (regp + PT_CCR));
supply_register (tdep->ppc_xer_regnum, (char *) (regp + PT_XER));
supply_register (tdep->ppc_ctr_regnum, (char *) (regp + PT_CTR));
supply_register (tdep->ppc_mq_regnum, (char *) (regp + PT_MQ));
supply_register (tdep->ppc_ps_regnum, (char *) (regp + PT_MSR));
}
void
fill_gregset (gdb_gregset_t *gregsetp, int regno)
{
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || regno == regi)
regcache_collect (regi, regp + PT_R0 + regi);
}
if ((regno == -1) || regno == PC_REGNUM)
regcache_collect (PC_REGNUM, regp + PT_NIP);
if ((regno == -1)
|| regno == tdep->ppc_lr_regnum)
regcache_collect (tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1)
|| regno == tdep->ppc_cr_regnum)
regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
if ((regno == -1)
|| regno == tdep->ppc_xer_regnum)
regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
if ((regno == -1)
|| regno == tdep->ppc_ctr_regnum)
regcache_collect (tdep->ppc_ctr_regnum, regp + PT_CTR);
if ((regno == -1)
|| regno == tdep->ppc_mq_regnum)
regcache_collect (tdep->ppc_mq_regnum, regp + PT_MQ);
if ((regno == -1)
|| regno == tdep->ppc_ps_regnum)
regcache_collect (tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
supply_fpregset (gdb_fpregset_t * fpregsetp)
{
int regi;
for (regi = 0; regi < 32; regi++)
{
supply_register (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
}
}
void
fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
{
int regi;
for (regi = 0; regi < 32; regi++)
{
if ((regno == -1) || (regno == FP0_REGNUM + regi))
regcache_collect (FP0_REGNUM + regi, (char *) (*fpregsetp + regi));
}
}