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"
/* Prototypes for supply_gregset etc. */
#include "gregset.h"
\f
-/* This table must line up with REGISTER_NAME in "m68k-tdep.c". */
+/* This table must line up with gdbarch_register_name in "m68k-tdep.c". */
static const int regmap[] =
{
PT_D0, PT_D1, PT_D2, PT_D3, PT_D4, PT_D5, PT_D6, PT_D7,
int
getfpregs_supplies (int regno)
{
- return FP0_REGNUM <= regno && regno <= M68K_FPI_REGNUM;
+ return gdbarch_fp0_regnum (current_gdbarch) <= regno
+ && regno <= M68K_FPI_REGNUM;
}
/* Does the current host support the GETREGS request? */
/* Fetch one register. */
static void
-fetch_register (int regno)
+fetch_register (struct regcache *regcache, int regno)
{
/* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr;
char buf[MAX_REGISTER_SIZE];
int tid;
- if (CANNOT_FETCH_REGISTER (regno))
+ if (gdbarch_cannot_fetch_register (current_gdbarch, regno))
{
memset (buf, '\0', register_size (current_gdbarch, regno)); /* Supply zeroes */
- regcache_raw_supply (current_regcache, regno, buf);
+ regcache_raw_supply (regcache, regno, buf);
return;
}
if (errno != 0)
{
sprintf (mess, "reading register %s (#%d)",
- REGISTER_NAME (regno), regno);
+ gdbarch_register_name (current_gdbarch, regno), regno);
perror_with_name (mess);
}
}
- regcache_raw_supply (current_regcache, regno, buf);
+ regcache_raw_supply (regcache, regno, buf);
}
/* Fetch register values from the inferior.
Otherwise, REGNO specifies which register (so we can save time). */
static void
-old_fetch_inferior_registers (int regno)
+old_fetch_inferior_registers (struct regcache *regcache, int regno)
{
if (regno >= 0)
{
- fetch_register (regno);
+ fetch_register (regcache, regno);
}
else
{
- for (regno = 0; regno < NUM_REGS; regno++)
+ for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
{
- fetch_register (regno);
+ fetch_register (regcache, regno);
}
}
}
/* Store one register. */
static void
-store_register (int regno)
+store_register (const struct regcache *regcache, int regno)
{
/* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr;
int tid;
char buf[MAX_REGISTER_SIZE];
- if (CANNOT_STORE_REGISTER (regno))
- {
- return;
- }
+ if (gdbarch_cannot_store_register (current_gdbarch, regno))
+ return;
/* Overload thread id onto process id */
tid = TIDGET (inferior_ptid);
regaddr = 4 * regmap[regno];
/* Put the contents of regno into a local buffer */
- regcache_raw_collect (current_regcache, regno, buf);
+ 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);
if (errno != 0)
{
sprintf (mess, "writing register %s (#%d)",
- REGISTER_NAME (regno), regno);
+ gdbarch_register_name (current_gdbarch, regno), regno);
perror_with_name (mess);
}
}
Otherwise, REGNO specifies which register (so we can save time). */
static void
-old_store_inferior_registers (int regno)
+old_store_inferior_registers (const struct regcache *regcache, int regno)
{
if (regno >= 0)
{
- store_register (regno);
+ store_register (regcache, regno);
}
else
{
- for (regno = 0; regno < NUM_REGS; regno++)
+ for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
{
- store_register (regno);
+ store_register (regcache, regno);
}
}
}
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 (current_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 (current_gdbarch),
+ ®p[PT_SR]);
+ regcache_raw_supply (regcache,
+ gdbarch_pc_regnum (current_gdbarch), ®p[PT_PC]);
}
/* Fill register REGNO (if it is a general-purpose register) in
store their values in GDB's register array. */
static void
-fetch_regs (int tid)
+fetch_regs (struct regcache *regcache, int tid)
{
elf_gregset_t regs;
perror_with_name (_("Couldn't get registers"));
}
- supply_gregset (current_regcache, (const elf_gregset_t *) ®s);
+ supply_gregset (regcache, (const elf_gregset_t *) ®s);
}
/* Store all valid general-purpose registers in GDB's register array
into the process/thread specified by TID. */
static void
-store_regs (int tid, int regno)
+store_regs (const struct regcache *regcache, 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 (current_regcache, ®s, regno);
+ fill_gregset (regcache, ®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) {}
+static void fetch_regs (struct regcache *regcache, int tid) {}
+static void store_regs (const struct regcache *regcache, int tid, int regno) {}
#endif
{
int regi;
- for (regi = FP0_REGNUM; regi < FP0_REGNUM + 8; regi++)
+ for (regi = gdbarch_fp0_regnum (current_gdbarch);
+ regi < gdbarch_fp0_regnum (current_gdbarch) + 8; regi++)
regcache_raw_supply (regcache, regi,
- FPREG_ADDR (fpregsetp, regi - FP0_REGNUM));
+ FPREG_ADDR (fpregsetp,
+ regi - gdbarch_fp0_regnum
+ (current_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]);
int i;
/* Fill in the floating-point registers. */
- for (i = FP0_REGNUM; i < FP0_REGNUM + 8; i++)
+ for (i = gdbarch_fp0_regnum (current_gdbarch);
+ i < gdbarch_fp0_regnum (current_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
+ (current_gdbarch)));
/* Fill in the floating-point control registers. */
for (i = M68K_FPC_REGNUM; i <= M68K_FPI_REGNUM; i++)
thier values in GDB's register array. */
static void
-fetch_fpregs (int tid)
+fetch_fpregs (struct regcache *regcache, 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 (current_regcache, (const elf_fpregset_t *) &fpregs);
+ supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs);
}
/* Store all valid floating-point registers in GDB's register array
into the process/thread specified by TID. */
static void
-store_fpregs (int tid, int regno)
+store_fpregs (const struct regcache *regcache, 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 (current_regcache, &fpregs, regno);
+ fill_fpregset (regcache, &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) {}
+static void fetch_fpregs (struct regcache *regcache, int tid) {}
+static void store_fpregs (const struct regcache *regcache, int tid, int regno) {}
#endif
\f
registers). */
static void
-m68k_linux_fetch_inferior_registers (int regno)
+m68k_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
GETREGS request isn't available. */
if (! have_ptrace_getregs)
{
- old_fetch_inferior_registers (regno);
+ old_fetch_inferior_registers (regcache, regno);
return;
}
zero. */
if (regno == -1)
{
- fetch_regs (tid);
+ fetch_regs (regcache, tid);
/* The call above might reset `have_ptrace_getregs'. */
if (! have_ptrace_getregs)
{
- old_fetch_inferior_registers (-1);
+ old_fetch_inferior_registers (regcache, -1);
return;
}
- fetch_fpregs (tid);
+ fetch_fpregs (regcache, tid);
return;
}
if (getregs_supplies (regno))
{
- fetch_regs (tid);
+ fetch_regs (regcache, tid);
return;
}
if (getfpregs_supplies (regno))
{
- fetch_fpregs (tid);
+ fetch_fpregs (regcache, tid);
return;
}
do this for all registers (including the floating point and SSE
registers). */
static void
-m68k_linux_store_inferior_registers (int regno)
+m68k_linux_store_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
SETREGS request isn't available. */
if (! have_ptrace_getregs)
{
- old_store_inferior_registers (regno);
+ old_store_inferior_registers (regcache, regno);
return;
}
store_fpregs can fail, and return zero. */
if (regno == -1)
{
- store_regs (tid, regno);
- store_fpregs (tid, regno);
+ store_regs (regcache, tid, regno);
+ store_fpregs (regcache, tid, regno);
return;
}
if (getregs_supplies (regno))
{
- store_regs (tid, regno);
+ store_regs (regcache, tid, regno);
return;
}
if (getfpregs_supplies (regno))
{
- store_fpregs (tid, regno);
+ store_fpregs (regcache, tid, regno);
return;
}
projects / thirdparty / binutils-gdb.git / blobdiff