/* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
+ 1998, 1999, 2000, 2001, 2002, 2003, 2004, 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., 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 "inferior.h"
#include "ppc-tdep.h"
#include "rs6000-tdep.h"
#include "exec.h"
-#include "gdb_stdint.h"
#include "observer.h"
#include <sys/ptrace.h>
static void vmap_symtab (struct vmap *);
-static void exec_one_dummy_insn (void);
+static void exec_one_dummy_insn (struct gdbarch *);
extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
ISFLOAT to indicate whether REGNO is a floating point register. */
static int
-regmap (int regno, int *isfloat)
+regmap (struct gdbarch *gdbarch, int regno, int *isfloat)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
*isfloat = 0;
if (tdep->ppc_gp0_regnum <= regno
*isfloat = 1;
return regno - tdep->ppc_fp0_regnum + FPR0;
}
- else if (regno == gdbarch_pc_regnum (current_gdbarch))
+ else if (regno == gdbarch_pc_regnum (gdbarch))
return IAR;
else if (regno == tdep->ppc_ps_regnum)
return MSR;
static void
fetch_register (struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
int addr[MAX_REGISTER_SIZE];
int nr, isfloat;
/* Retrieved values may be -1, so infer errors from errno. */
errno = 0;
- nr = regmap (regno, &isfloat);
+ nr = regmap (gdbarch, regno, &isfloat);
/* Floating-point registers. */
if (isfloat)
/* Bogus register number. */
else if (nr < 0)
{
- if (regno >= gdbarch_num_regs (current_gdbarch))
+ if (regno >= gdbarch_num_regs (gdbarch))
fprintf_unfiltered (gdb_stderr,
"gdb error: register no %d not implemented.\n",
regno);
even if the register is really only 32 bits. */
long long buf;
rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
- if (register_size (current_gdbarch, regno) == 8)
+ if (register_size (gdbarch, regno) == 8)
memcpy (addr, &buf, 8);
else
*addr = buf;
static void
store_register (const struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
int addr[MAX_REGISTER_SIZE];
int nr, isfloat;
/* -1 can be a successful return value, so infer errors from errno. */
errno = 0;
- nr = regmap (regno, &isfloat);
+ nr = regmap (gdbarch, regno, &isfloat);
/* Floating-point registers. */
if (isfloat)
/* Bogus register number. */
else if (nr < 0)
{
- if (regno >= gdbarch_num_regs (current_gdbarch))
+ if (regno >= gdbarch_num_regs (gdbarch))
fprintf_unfiltered (gdb_stderr,
"gdb error: register no %d not implemented.\n",
regno);
/* Fixed-point registers. */
else
{
- if (regno == gdbarch_sp_regnum (current_gdbarch))
+ if (regno == gdbarch_sp_regnum (gdbarch))
/* Execute one dummy instruction (which is a breakpoint) in inferior
process to give kernel a chance to do internal housekeeping.
Otherwise the following ptrace(2) calls will mess up user stack
since kernel will get confused about the bottom of the stack
(%sp). */
- exec_one_dummy_insn ();
+ exec_one_dummy_insn (gdbarch);
/* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
the register's value is passed by value, but for 64-bit inferiors,
/* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
area, even if the register is really only 32 bits. */
long long buf;
- if (register_size (current_gdbarch, regno) == 8)
+ if (register_size (gdbarch, regno) == 8)
memcpy (&buf, addr, 8);
else
buf = *addr;
static void
rs6000_fetch_inferior_registers (struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
if (regno != -1)
fetch_register (regcache, regno);
else
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
/* Read 32 general purpose registers. */
for (regno = tdep->ppc_gp0_regnum;
fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
/* Read special registers. */
- fetch_register (regcache, gdbarch_pc_regnum (current_gdbarch));
+ fetch_register (regcache, gdbarch_pc_regnum (gdbarch));
fetch_register (regcache, tdep->ppc_ps_regnum);
fetch_register (regcache, tdep->ppc_cr_regnum);
fetch_register (regcache, tdep->ppc_lr_regnum);
static void
rs6000_store_inferior_registers (struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
if (regno != -1)
store_register (regcache, regno);
else
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
/* Write general purpose registers first. */
for (regno = tdep->ppc_gp0_regnum;
store_register (regcache, tdep->ppc_fp0_regnum + regno);
/* Write special registers. */
- store_register (regcache, gdbarch_pc_regnum (current_gdbarch));
+ store_register (regcache, gdbarch_pc_regnum (gdbarch));
store_register (regcache, tdep->ppc_ps_regnum);
store_register (regcache, tdep->ppc_cr_regnum);
store_register (regcache, tdep->ppc_lr_regnum);
do
{
set_sigint_trap ();
- set_sigio_trap ();
do
{
}
while (pid == -1 && errno == EINTR);
- clear_sigio_trap ();
clear_sigint_trap ();
if (pid == -1)
/* Claim it exited with unknown signal. */
ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
- return minus_one_ptid;
+ return inferior_ptid;
}
/* Ignore terminated detached child processes. */
including u_area. */
static void
-exec_one_dummy_insn (void)
+exec_one_dummy_insn (struct gdbarch *gdbarch)
{
-#define DUMMY_INSN_ADDR gdbarch_tdep (current_gdbarch)->text_segment_base+0x200
+#define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200
int ret, status, pid;
CORE_ADDR prev_pc;
last = 0;
/* FIXME??? am I tossing BFDs? bfd? */
while ((last = bfd_openr_next_archived_file (abfd, last)))
- if (DEPRECATED_STREQ (mem, last->filename))
+ if (strcmp (mem, last->filename) == 0)
break;
if (!last)
/* The filenames are not always sufficient to match on. */
- if ((name[0] == '/' && !DEPRECATED_STREQ (name, vp->name))
- || (memb[0] && !DEPRECATED_STREQ (memb, vp->member)))
+ if ((name[0] == '/' && strcmp (name, vp->name) != 0)
+ || (memb[0] && strcmp (memb, vp->member) != 0))
continue;
/* See if we are referring to the same file.
for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
{
- if (DEPRECATED_STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
+ if (strcmp (".text", exec_ops.to_sections[i].the_bfd_section->name) == 0)
{
exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
}
- else if (DEPRECATED_STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
+ else if (strcmp (".data",
+ exec_ops.to_sections[i].the_bfd_section->name) == 0)
{
exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
}
- else if (DEPRECATED_STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
+ else if (strcmp (".bss",
+ exec_ops.to_sections[i].the_bfd_section->name) == 0)
{
exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
/* Set the current architecture from the host running GDB. Called when
starting a child process. */
-static void (*super_create_inferior) (char *exec_file, char *allargs,
- char **env, int from_tty);
+static void (*super_create_inferior) (struct target_ops *,char *exec_file,
+ char *allargs, char **env, int from_tty);
static void
-rs6000_create_inferior (char *exec_file, char *allargs, char **env, int from_tty)
+rs6000_create_inferior (struct target_ops * ops, char *exec_file,
+ char *allargs, char **env, int from_tty)
{
enum bfd_architecture arch;
unsigned long mach;
bfd abfd;
struct gdbarch_info info;
- super_create_inferior (exec_file, allargs, env, from_tty);
+ super_create_inferior (ops, exec_file, allargs, env, from_tty);
if (__power_rs ())
{