/* Native-dependent code for GNU/Linux m32r.
- Copyright 2004 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
+ 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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "inferior.h"
#include "gdbcore.h"
#include "regcache.h"
#include "linux-nat.h"
+#include "target.h"
#include "gdb_assert.h"
#include "gdb_string.h"
in *GREGSETP. */
void
-supply_gregset (elf_gregset_t * gregsetp)
+supply_gregset (struct regcache *regcache, const elf_gregset_t * gregsetp)
{
- elf_greg_t *regp = (elf_greg_t *) gregsetp;
+ const elf_greg_t *regp = (const elf_greg_t *) gregsetp;
int i;
unsigned long psw, bbpsw;
for (i = 0; i < M32R_LINUX_NUM_REGS; i++)
{
+ elf_greg_t regval;
+
switch (i)
{
case PSW_REGNUM:
- *(regp + regmap[i]) =
- ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
+ regval = ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8);
break;
case CBR_REGNUM:
- *(regp + regmap[i]) = ((psw >> 8) & 1);
+ regval = ((psw >> 8) & 1);
+ break;
+ default:
+ regval = *(regp + regmap[i]);
break;
}
if (i != M32R_SP_REGNUM)
- regcache_raw_supply (current_regcache, i, regp + regmap[i]);
+ regcache_raw_supply (regcache, i, ®val);
else if (psw & 0x8000)
- regcache_raw_supply (current_regcache, i, regp + SPU_REGMAP);
+ regcache_raw_supply (regcache, i, regp + SPU_REGMAP);
else
- regcache_raw_supply (current_regcache, i, regp + SPI_REGMAP);
+ regcache_raw_supply (regcache, i, regp + SPI_REGMAP);
}
}
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;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't get registers");
+ perror_with_name (_("Couldn't get registers"));
- supply_gregset (®s);
+ supply_gregset (regcache, (const elf_gregset_t *) ®s);
}
/* Fill register REGNO (if it is a general-purpose register) in
do this for all registers. */
void
-fill_gregset (elf_gregset_t * gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ elf_gregset_t * gregsetp, int regno)
{
elf_greg_t *regp = (elf_greg_t *) gregsetp;
int i;
continue;
if (i != M32R_SP_REGNUM)
- regcache_raw_collect (current_regcache, i, regp + regmap[i]);
+ regcache_raw_collect (regcache, i, regp + regmap[i]);
else if (psw & 0x8000)
- regcache_raw_collect (current_regcache, i, regp + SPU_REGMAP);
+ regcache_raw_collect (regcache, i, regp + SPU_REGMAP);
else
- regcache_raw_collect (current_regcache, i, regp + SPI_REGMAP);
+ regcache_raw_collect (regcache, i, regp + SPI_REGMAP);
}
}
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");
+ perror_with_name (_("Couldn't get registers"));
- fill_gregset (®s, regno);
+ fill_gregset (regcache, ®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
- perror_with_name ("Couldn't write registers");
+ perror_with_name (_("Couldn't write registers"));
}
\f
Since M32R has no floating-point registers, these functions do nothing. */
void
-supply_fpregset (gdb_fpregset_t *fpregs)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregs)
{
}
void
-fill_fpregset (gdb_fpregset_t *fpregs, int regno)
+fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregs, int regno)
{
}
\f
this for all registers (including the floating point and SSE
registers). */
-void
-fetch_inferior_registers (int regno)
+static void
+m32r_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
results. */
if (regno == -1 || GETREGS_SUPPLIES (regno))
{
- fetch_regs (tid);
+ fetch_regs (regcache, tid);
return;
}
internal_error (__FILE__, __LINE__,
- "Got request for bad register number %d.", regno);
+ _("Got request for bad register number %d."), regno);
}
/* Store register REGNO back into the child process. If REGNO is -1,
do this for all registers (including the floating point and SSE
registers). */
-void
-store_inferior_registers (int regno)
+static void
+m32r_linux_store_inferior_registers (struct regcache *regcache, int regno)
{
int tid;
transfers more registers in one system call. */
if (regno == -1 || GETREGS_SUPPLIES (regno))
{
- store_regs (tid, regno);
+ store_regs (regcache, tid, regno);
return;
}
internal_error (__FILE__, __LINE__,
- "Got request to store bad register number %d.", regno);
+ _("Got request to store bad register number %d."), regno);
+}
+
+void _initialize_m32r_linux_nat (void);
+
+void
+_initialize_m32r_linux_nat (void)
+{
+ struct target_ops *t;
+
+ /* Fill in the generic GNU/Linux methods. */
+ t = linux_target ();
+
+ /* Add our register access methods. */
+ t->to_fetch_registers = m32r_linux_fetch_inferior_registers;
+ t->to_store_registers = m32r_linux_store_inferior_registers;
+
+ /* Register the target. */
+ linux_nat_add_target (t);
}