#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "language.h"
#include "gdbcore.h"
#include "gdb_string.h"
#include "regcache.h"
#include "m68k-tdep.h"
#ifdef USG
#include <sys/types.h>
#endif
#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>
#include <sys/ptrace.h>
#include <sys/user.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/procfs.h>
#ifdef HAVE_SYS_REG_H
#include <sys/reg.h>
#endif
#include <sys/file.h>
#include "gdb_stat.h"
#include "floatformat.h"
#include "target.h"
static const int regmap[] =
{
PT_D0, PT_D1, PT_D2, PT_D3, PT_D4, PT_D5, PT_D6, PT_D7,
PT_A0, PT_A1, PT_A2, PT_A3, PT_A4, PT_A5, PT_A6, PT_USP,
PT_SR, PT_PC,
21, 24, 27, 30, 33, 36, 39, 42,
45, 46, 47
};
#define NUM_GREGS (18)
#define MAX_NUM_REGS (NUM_GREGS + 11)
int
getregs_supplies (int regno)
{
return 0 <= regno && regno < NUM_GREGS;
}
int
getfpregs_supplies (int regno)
{
return FP0_REGNUM <= regno && regno <= M68K_FPI_REGNUM;
}
int have_ptrace_getregs =
#ifdef HAVE_PTRACE_GETREGS
1
#else
0
#endif
;
int
m68k_linux_register_u_addr (int blockend, int regnum)
{
return (blockend + 4 * regmap[regnum]);
}
#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
static void
fetch_register (int regno)
{
CORE_ADDR regaddr;
char mess[128];
register int i;
unsigned int offset;
char buf[MAX_REGISTER_RAW_SIZE];
int tid;
if (CANNOT_FETCH_REGISTER (regno))
{
memset (buf, '\0', REGISTER_RAW_SIZE (regno));
supply_register (regno, buf);
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
offset = U_REGS_OFFSET;
regaddr = register_addr (regno, offset);
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);
}
void
old_fetch_inferior_registers (int regno)
{
if (regno >= 0)
{
fetch_register (regno);
}
else
{
for (regno = 0; regno < NUM_REGS; regno++)
{
fetch_register (regno);
}
}
}
static void
store_register (int regno)
{
CORE_ADDR regaddr;
char mess[128];
register int i;
unsigned int offset;
int tid;
char *buf = alloca (MAX_REGISTER_RAW_SIZE);
if (CANNOT_STORE_REGISTER (regno))
{
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
offset = U_REGS_OFFSET;
regaddr = register_addr (regno, offset);
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);
}
}
}
void
old_store_inferior_registers (int regno)
{
if (regno >= 0)
{
store_register (regno);
}
else
{
for (regno = 0; regno < NUM_REGS; regno++)
{
store_register (regno);
}
}
}
#ifndef USE_PROC_FS
#include "gregset.h"
void
supply_gregset (elf_gregset_t *gregsetp)
{
elf_greg_t *regp = (elf_greg_t *) gregsetp;
int regi;
for (regi = M68K_D0_REGNUM; regi <= SP_REGNUM; regi++)
supply_register (regi, (char *) ®p[regmap[regi]]);
supply_register (PS_REGNUM, (char *) ®p[PT_SR]);
supply_register (PC_REGNUM, (char *) ®p[PT_PC]);
}
void
fill_gregset (elf_gregset_t *gregsetp, int regno)
{
elf_greg_t *regp = (elf_greg_t *) gregsetp;
int i;
for (i = 0; i < NUM_GREGS; i++)
if ((regno == -1 || regno == i))
regcache_collect (i, regp + regmap[i]);
}
#ifdef HAVE_PTRACE_GETREGS
static void
fetch_regs (int tid)
{
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
{
if (errno == EIO)
{
have_ptrace_getregs = 0;
return;
}
perror_with_name ("Couldn't get registers");
}
supply_gregset (®s);
}
static void
store_regs (int tid, int regno)
{
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
perror_with_name ("Couldn't get registers");
fill_gregset (®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
perror_with_name ("Couldn't write registers");
}
#else
static void fetch_regs (int tid) {}
static void store_regs (int tid, int regno) {}
#endif
#define FPREG_ADDR(f, n) ((char *) &(f)->fpregs[(n) * 3])
void
supply_fpregset (elf_fpregset_t *fpregsetp)
{
int regi;
for (regi = FP0_REGNUM; regi < FP0_REGNUM + 8; regi++)
supply_register (regi, FPREG_ADDR (fpregsetp, regi - FP0_REGNUM));
supply_register (M68K_FPC_REGNUM, (char *) &fpregsetp->fpcntl[0]);
supply_register (M68K_FPS_REGNUM, (char *) &fpregsetp->fpcntl[1]);
supply_register (M68K_FPI_REGNUM, (char *) &fpregsetp->fpcntl[2]);
}
void
fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
{
int i;
for (i = FP0_REGNUM; i < FP0_REGNUM + 8; i++)
if (regno == -1 || regno == i)
regcache_collect (regno, FPREG_ADDR (fpregsetp, regno - FP0_REGNUM));
for (i = M68K_FPC_REGNUM; i <= M68K_FPI_REGNUM; i++)
if (regno == -1 || regno == i)
regcache_collect (regno, (char *) &fpregsetp->fpcntl[regno - M68K_FPC_REGNUM]);
}
#ifdef HAVE_PTRACE_GETREGS
static void
fetch_fpregs (int tid)
{
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name ("Couldn't get floating point status");
supply_fpregset (&fpregs);
}
static void
store_fpregs (int tid, int regno)
{
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name ("Couldn't get floating point status");
fill_fpregset (&fpregs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name ("Couldn't write floating point status");
}
#else
static void fetch_fpregs (int tid) {}
static void store_fpregs (int tid, int regno) {}
#endif
#endif
void
fetch_inferior_registers (int regno)
{
int tid;
if (! have_ptrace_getregs)
{
old_fetch_inferior_registers (regno);
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
if (regno == -1)
{
fetch_regs (tid);
if (! have_ptrace_getregs)
{
old_fetch_inferior_registers (-1);
return;
}
fetch_fpregs (tid);
return;
}
if (getregs_supplies (regno))
{
fetch_regs (tid);
return;
}
if (getfpregs_supplies (regno))
{
fetch_fpregs (tid);
return;
}
internal_error (__FILE__, __LINE__,
"Got request for bad register number %d.", regno);
}
void
store_inferior_registers (int regno)
{
int tid;
if (! have_ptrace_getregs)
{
old_store_inferior_registers (regno);
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
if (regno == -1)
{
store_regs (tid, regno);
store_fpregs (tid, regno);
return;
}
if (getregs_supplies (regno))
{
store_regs (tid, regno);
return;
}
if (getfpregs_supplies (regno))
{
store_fpregs (tid, regno);
return;
}
internal_error (__FILE__, __LINE__,
"Got request to store bad register number %d.", regno);
}
static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
int which, CORE_ADDR reg_addr)
{
elf_gregset_t gregset;
elf_fpregset_t fpregset;
switch (which)
{
case 0:
if (core_reg_size != sizeof (gregset))
warning ("Wrong size gregset in core file.");
else
{
memcpy (&gregset, core_reg_sect, sizeof (gregset));
supply_gregset (&gregset);
}
break;
case 2:
if (core_reg_size != sizeof (fpregset))
warning ("Wrong size fpregset in core file.");
else
{
memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
supply_fpregset (&fpregset);
}
break;
default:
break;
}
}
int
kernel_u_size (void)
{
return (sizeof (struct user));
}
static struct core_fns linux_elf_core_fns =
{
bfd_target_elf_flavour,
default_check_format,
default_core_sniffer,
fetch_core_registers,
NULL
};
void
_initialize_m68k_linux_nat (void)
{
add_core_fns (&linux_elf_core_fns);
}