/* 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 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? */
static void
fetch_register (struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
/* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr;
char mess[128]; /* For messages */
char buf[MAX_REGISTER_SIZE];
int tid;
- if (gdbarch_cannot_fetch_register (current_gdbarch, regno))
+ if (gdbarch_cannot_fetch_register (gdbarch, regno))
{
- memset (buf, '\0', register_size (current_gdbarch, regno)); /* Supply zeroes */
+ memset (buf, '\0', register_size (gdbarch, regno)); /* Supply zeroes */
regcache_raw_supply (regcache, regno, buf);
return;
}
tid = PIDGET (inferior_ptid); /* no thread id, just use process id */
regaddr = 4 * regmap[regno];
- for (i = 0; i < register_size (current_gdbarch, regno);
+ for (i = 0; i < register_size (gdbarch, regno);
i += sizeof (PTRACE_TYPE_RET))
{
errno = 0;
if (errno != 0)
{
sprintf (mess, "reading register %s (#%d)",
- gdbarch_register_name (current_gdbarch, regno), regno);
+ gdbarch_register_name (gdbarch, regno), regno);
perror_with_name (mess);
}
}
}
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)
{
+ struct gdbarch *gdbarch = reg_regcache_arch (regcache);
/* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr;
char mess[128]; /* For messages */
int tid;
char buf[MAX_REGISTER_SIZE];
- if (gdbarch_cannot_store_register (current_gdbarch, regno))
+ if (gdbarch_cannot_store_register (gdbarch, regno))
return;
/* Overload thread id onto process id */
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);
+ for (i = 0; i < register_size (gdbarch, regno);
i += sizeof (PTRACE_TYPE_RET))
{
errno = 0;
if (errno != 0)
{
sprintf (mess, "writing register %s (#%d)",
- gdbarch_register_name (current_gdbarch, regno), regno);
+ gdbarch_register_name (gdbarch, regno), regno);
perror_with_name (mess);
}
}
}
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++)