/* Motorola m68k native support for GNU/Linux.
- Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
- Free Software Foundation, Inc.
+ Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+ 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "frame.h"
int
getfpregs_supplies (int regno)
{
- return FP0_REGNUM <= regno && regno <= M68K_FPI_REGNUM;
+ return M68K_FP0_REGNUM <= regno && regno <= M68K_FPI_REGNUM;
}
/* Does the current host support the GETREGS request? */
/* Fetching registers directly from the U area, one at a time. */
-/* FIXME: This duplicates code from `inptrace.c'. The problem is that we
- define FETCH_INFERIOR_REGISTERS since we want to use our own versions
- of {fetch,store}_inferior_registers that use the GETREGS request. This
- means that the code in `infptrace.c' is #ifdef'd out. But we need to
- fall back on that code when GDB is running on top of a kernel that
- doesn't support the GETREGS request. */
-
-#ifndef PT_READ_U
-#define PT_READ_U PTRACE_PEEKUSR
-#endif
-#ifndef PT_WRITE_U
-#define PT_WRITE_U PTRACE_POKEUSR
-#endif
-
/* Fetch one register. */
static void
fetch_register (struct regcache *regcache, int regno)
{
- /* This isn't really an address. But ptrace thinks of it as one. */
- CORE_ADDR regaddr;
- char mess[128]; /* For messages */
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ long regaddr;
int i;
char buf[MAX_REGISTER_SIZE];
int tid;
- if (gdbarch_cannot_fetch_register (current_gdbarch, regno))
- {
- memset (buf, '\0', register_size (current_gdbarch, regno)); /* Supply zeroes */
- regcache_raw_supply (regcache, regno, buf);
- return;
- }
-
/* Overload thread id onto process id */
tid = TIDGET (inferior_ptid);
if (tid == 0)
tid = PIDGET (inferior_ptid); /* no thread id, just use process id */
regaddr = 4 * regmap[regno];
- for (i = 0; i < register_size (current_gdbarch, regno);
- i += sizeof (PTRACE_TYPE_RET))
+ for (i = 0; i < register_size (gdbarch, regno); i += sizeof (long))
{
errno = 0;
- *(PTRACE_TYPE_RET *) &buf[i] = ptrace (PT_READ_U, tid,
- (PTRACE_TYPE_ARG3) regaddr, 0);
- regaddr += sizeof (PTRACE_TYPE_RET);
+ *(long *) &buf[i] = ptrace (PTRACE_PEEKUSER, tid, regaddr, 0);
+ regaddr += sizeof (long);
if (errno != 0)
- {
- sprintf (mess, "reading register %s (#%d)",
- gdbarch_register_name (current_gdbarch, regno), regno);
- perror_with_name (mess);
- }
+ error (_("Couldn't read register %s (#%d): %s."),
+ gdbarch_register_name (gdbarch, regno),
+ regno, safe_strerror (errno));
}
regcache_raw_supply (regcache, regno, buf);
}
}
else
{
- for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
+ for (regno = 0;
+ regno < gdbarch_num_regs (get_regcache_arch (regcache));
+ regno++)
{
fetch_register (regcache, regno);
}
static void
store_register (const struct regcache *regcache, int regno)
{
- /* This isn't really an address. But ptrace thinks of it as one. */
- CORE_ADDR regaddr;
- char mess[128]; /* For messages */
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ long regaddr;
int i;
int tid;
char buf[MAX_REGISTER_SIZE];
- if (gdbarch_cannot_store_register (current_gdbarch, regno))
- return;
-
/* Overload thread id onto process id */
tid = TIDGET (inferior_ptid);
if (tid == 0)
regcache_raw_collect (regcache, regno, buf);
/* Store the local buffer into the inferior a chunk at the time. */
- for (i = 0; i < register_size (current_gdbarch, regno);
- i += sizeof (PTRACE_TYPE_RET))
+ for (i = 0; i < register_size (gdbarch, regno); i += sizeof (long))
{
errno = 0;
- ptrace (PT_WRITE_U, tid, (PTRACE_TYPE_ARG3) regaddr,
- *(PTRACE_TYPE_RET *) (buf + i));
- regaddr += sizeof (PTRACE_TYPE_RET);
+ ptrace (PTRACE_POKEUSER, tid, regaddr, *(long *) &buf[i]);
+ regaddr += sizeof (long);
if (errno != 0)
- {
- sprintf (mess, "writing register %s (#%d)",
- gdbarch_register_name (current_gdbarch, regno), regno);
- perror_with_name (mess);
- }
+ error (_("Couldn't write register %s (#%d): %s."),
+ gdbarch_register_name (gdbarch, regno),
+ regno, safe_strerror (errno));
}
}
}
else
{
- for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
+ for (regno = 0;
+ regno < gdbarch_num_regs (get_regcache_arch (regcache));
+ regno++)
{
store_register (regcache, regno);
}
void
supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
const elf_greg_t *regp = (const elf_greg_t *) gregsetp;
int regi;
- for (regi = M68K_D0_REGNUM; regi <= SP_REGNUM; regi++)
+ for (regi = M68K_D0_REGNUM;
+ regi <= gdbarch_sp_regnum (gdbarch);
+ regi++)
regcache_raw_supply (regcache, regi, ®p[regmap[regi]]);
- regcache_raw_supply (regcache, PS_REGNUM, ®p[PT_SR]);
- regcache_raw_supply (regcache, PC_REGNUM, ®p[PT_PC]);
+ regcache_raw_supply (regcache, gdbarch_ps_regnum (gdbarch),
+ ®p[PT_SR]);
+ regcache_raw_supply (regcache,
+ gdbarch_pc_regnum (gdbarch), ®p[PT_PC]);
}
/* Fill register REGNO (if it is a general-purpose register) in
void
supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regi;
- for (regi = FP0_REGNUM; regi < FP0_REGNUM + 8; regi++)
+ for (regi = gdbarch_fp0_regnum (gdbarch);
+ regi < gdbarch_fp0_regnum (gdbarch) + 8; regi++)
regcache_raw_supply (regcache, regi,
- FPREG_ADDR (fpregsetp, regi - FP0_REGNUM));
+ FPREG_ADDR (fpregsetp,
+ regi - gdbarch_fp0_regnum (gdbarch)));
regcache_raw_supply (regcache, M68K_FPC_REGNUM, &fpregsetp->fpcntl[0]);
regcache_raw_supply (regcache, M68K_FPS_REGNUM, &fpregsetp->fpcntl[1]);
regcache_raw_supply (regcache, M68K_FPI_REGNUM, &fpregsetp->fpcntl[2]);
fill_fpregset (const struct regcache *regcache,
elf_fpregset_t *fpregsetp, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i;
/* Fill in the floating-point registers. */
- for (i = FP0_REGNUM; i < FP0_REGNUM + 8; i++)
+ for (i = gdbarch_fp0_regnum (gdbarch);
+ i < gdbarch_fp0_regnum (gdbarch) + 8; i++)
if (regno == -1 || regno == i)
regcache_raw_collect (regcache, i,
- FPREG_ADDR (fpregsetp, i - FP0_REGNUM));
+ FPREG_ADDR (fpregsetp,
+ i - gdbarch_fp0_regnum (gdbarch)));
/* Fill in the floating-point control registers. */
for (i = M68K_FPC_REGNUM; i <= M68K_FPI_REGNUM; i++)
registers). */
static void
-m68k_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
+m68k_linux_fetch_inferior_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
int tid;
do this for all registers (including the floating point and SSE
registers). */
static void
-m68k_linux_store_inferior_registers (struct regcache *regcache, int regno)
+m68k_linux_store_inferior_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
int tid;
projects / deliverable / binutils-gdb.git / blobdiff