/* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
- Copyright 1986, 1987, 1989, 1991, 1992, 1994, 1995, 1996, 1997, 1998
- Free Software Foundation, Inc.
+
+ Copyright (C) 1986-2017 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 "target.h"
#include "gdbcore.h"
-#include "xcoffsolib.h"
#include "symfile.h"
#include "objfiles.h"
-#include "libbfd.h" /* For bfd_cache_lookup (FIXME) */
#include "bfd.h"
#include "gdb-stabs.h"
+#include "regcache.h"
+#include "arch-utils.h"
+#include "inf-child.h"
+#include "inf-ptrace.h"
+#include "ppc-tdep.h"
+#include "rs6000-tdep.h"
+#include "rs6000-aix-tdep.h"
+#include "exec.h"
+#include "observer.h"
+#include "xcoffread.h"
#include <sys/ptrace.h>
#include <sys/reg.h>
-#include <sys/param.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <signal.h>
#include <a.out.h>
#include <sys/file.h>
-#include "gdb_stat.h"
+#include <sys/stat.h>
+#include "gdb_bfd.h"
#include <sys/core.h>
+#define __LDINFO_PTRACE32__ /* for __ld_info32 */
+#define __LDINFO_PTRACE64__ /* for __ld_info64 */
#include <sys/ldr.h>
+#include <sys/systemcfg.h>
-extern int errno;
-
-extern struct vmap *map_vmap PARAMS ((bfd * bf, bfd * arch));
-
-extern struct target_ops exec_ops;
-
-static void
-vmap_exec PARAMS ((void));
-
-static void
-vmap_ldinfo PARAMS ((struct ld_info *));
+/* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
+ debugging 32-bit and 64-bit processes. Define a typedef and macros for
+ accessing fields in the appropriate structures. */
-static struct vmap *
- add_vmap PARAMS ((struct ld_info *));
+/* In 32-bit compilation mode (which is the only mode from which ptrace()
+ works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
-static int
-objfile_symbol_add PARAMS ((char *));
-
-static void
-vmap_symtab PARAMS ((struct vmap *));
+#if defined (__ld_info32) || defined (__ld_info64)
+# define ARCH3264
+#endif
-static void
-fetch_core_registers PARAMS ((char *, unsigned int, int, CORE_ADDR));
+/* Return whether the current architecture is 64-bit. */
-static void
-exec_one_dummy_insn PARAMS ((void));
-
-extern void
-fixup_breakpoints PARAMS ((CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta));
+#ifndef ARCH3264
+# define ARCH64() 0
+#else
+# define ARCH64() (register_size (target_gdbarch (), 0) == 8)
+#endif
-/* Conversion from gdb-to-system special purpose register numbers.. */
+static target_xfer_partial_ftype rs6000_xfer_shared_libraries;
-static int special_regs[] =
-{
- IAR, /* PC_REGNUM */
- MSR, /* PS_REGNUM */
- CR, /* CR_REGNUM */
- LR, /* LR_REGNUM */
- CTR, /* CTR_REGNUM */
- XER, /* XER_REGNUM */
- MQ /* MQ_REGNUM */
-};
+/* Given REGNO, a gdb register number, return the corresponding
+ number suitable for use as a ptrace() parameter. Return -1 if
+ there's no suitable mapping. Also, set the int pointed to by
+ ISFLOAT to indicate whether REGNO is a floating point register. */
-void
-fetch_inferior_registers (regno)
- int regno;
+static int
+regmap (struct gdbarch *gdbarch, int regno, int *isfloat)
{
- int ii;
-
- if (regno < 0)
- { /* for all registers */
-
- /* read 32 general purpose registers. */
-
- for (ii = 0; ii < 32; ++ii)
- *(int *) ®isters[REGISTER_BYTE (ii)] =
- ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii, 0, 0);
-
- /* read general purpose floating point registers. */
-
- for (ii = 0; ii < 32; ++ii)
- ptrace (PT_READ_FPR, inferior_pid,
- (PTRACE_ARG3_TYPE) & registers[REGISTER_BYTE (FP0_REGNUM + ii)],
- FPR0 + ii, 0);
-
- /* read special registers. */
- for (ii = 0; ii <= LAST_UISA_SP_REGNUM - FIRST_UISA_SP_REGNUM; ++ii)
- *(int *) ®isters[REGISTER_BYTE (FIRST_UISA_SP_REGNUM + ii)] =
- ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) special_regs[ii],
- 0, 0);
-
- registers_fetched ();
- return;
- }
-
- /* else an individual register is addressed. */
-
- else if (regno < FP0_REGNUM)
- { /* a GPR */
- *(int *) ®isters[REGISTER_BYTE (regno)] =
- ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) regno, 0, 0);
- }
- else if (regno <= FPLAST_REGNUM)
- { /* a FPR */
- ptrace (PT_READ_FPR, inferior_pid,
- (PTRACE_ARG3_TYPE) & registers[REGISTER_BYTE (regno)],
- (regno - FP0_REGNUM + FPR0), 0);
- }
- else if (regno <= LAST_UISA_SP_REGNUM)
- { /* a special register */
- *(int *) ®isters[REGISTER_BYTE (regno)] =
- ptrace (PT_READ_GPR, inferior_pid,
- (PTRACE_ARG3_TYPE) special_regs[regno - FIRST_UISA_SP_REGNUM],
- 0, 0);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+ *isfloat = 0;
+ if (tdep->ppc_gp0_regnum <= regno
+ && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
+ return regno;
+ else if (tdep->ppc_fp0_regnum >= 0
+ && tdep->ppc_fp0_regnum <= regno
+ && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
+ {
+ *isfloat = 1;
+ return regno - tdep->ppc_fp0_regnum + FPR0;
}
+ else if (regno == gdbarch_pc_regnum (gdbarch))
+ return IAR;
+ else if (regno == tdep->ppc_ps_regnum)
+ return MSR;
+ else if (regno == tdep->ppc_cr_regnum)
+ return CR;
+ else if (regno == tdep->ppc_lr_regnum)
+ return LR;
+ else if (regno == tdep->ppc_ctr_regnum)
+ return CTR;
+ else if (regno == tdep->ppc_xer_regnum)
+ return XER;
+ else if (tdep->ppc_fpscr_regnum >= 0
+ && regno == tdep->ppc_fpscr_regnum)
+ return FPSCR;
+ else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
+ return MQ;
else
- fprintf_unfiltered (gdb_stderr,
- "gdb error: register no %d not implemented.\n",
- regno);
-
- register_valid[regno] = 1;
+ return -1;
}
-/* Store our register values back into the inferior.
- If REGNO is -1, do this for all registers.
- Otherwise, REGNO specifies which register (so we can save time). */
+/* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
-void
-store_inferior_registers (regno)
- int regno;
+static int
+rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
{
+#ifdef HAVE_PTRACE64
+ int ret = ptrace64 (req, id, (uintptr_t) addr, data, buf);
+#else
+ int ret = ptrace (req, id, (int *)addr, data, buf);
+#endif
+#if 0
+ printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
+ req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
+#endif
+ return ret;
+}
- errno = 0;
-
- if (regno == -1)
- { /* for all registers.. */
- int ii;
-
- /* execute one dummy instruction (which is a breakpoint) in inferior
- process. So give kernel a chance to do internal house keeping.
- Otherwise the following ptrace(2) calls will mess up user stack
- since kernel will get confused about the bottom of the stack (%sp) */
+/* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
- exec_one_dummy_insn ();
+static int
+rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
+{
+#ifdef ARCH3264
+# ifdef HAVE_PTRACE64
+ int ret = ptrace64 (req, id, addr, data, (PTRACE_TYPE_ARG5) buf);
+# else
+ int ret = ptracex (req, id, addr, data, (PTRACE_TYPE_ARG5) buf);
+# endif
+#else
+ int ret = 0;
+#endif
+#if 0
+ printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
+ req, id, hex_string (addr), data, (unsigned int)buf, ret);
+#endif
+ return ret;
+}
- /* write general purpose registers first! */
- for (ii = GPR0; ii <= GPR31; ++ii)
- {
- ptrace (PT_WRITE_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii,
- *(int *) ®isters[REGISTER_BYTE (ii)], 0);
- if (errno)
- {
- perror ("ptrace write_gpr");
- errno = 0;
- }
- }
+/* Fetch register REGNO from the inferior. */
- /* write floating point registers now. */
- for (ii = 0; ii < 32; ++ii)
- {
- ptrace (PT_WRITE_FPR, inferior_pid,
- (PTRACE_ARG3_TYPE) & registers[REGISTER_BYTE (FP0_REGNUM + ii)],
- FPR0 + ii, 0);
- if (errno)
- {
- perror ("ptrace write_fpr");
- errno = 0;
- }
- }
+static void
+fetch_register (struct regcache *regcache, int regno)
+{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ int addr[PPC_MAX_REGISTER_SIZE];
+ int nr, isfloat;
+ pid_t pid = ptid_get_pid (regcache_get_ptid (regcache));
- /* write special registers. */
- for (ii = 0; ii <= LAST_UISA_SP_REGNUM - FIRST_UISA_SP_REGNUM; ++ii)
- {
- ptrace (PT_WRITE_GPR, inferior_pid,
- (PTRACE_ARG3_TYPE) special_regs[ii],
- *(int *) ®isters[REGISTER_BYTE (FIRST_UISA_SP_REGNUM + ii)],
- 0);
- if (errno)
- {
- perror ("ptrace write_gpr");
- errno = 0;
- }
- }
- }
+ /* Retrieved values may be -1, so infer errors from errno. */
+ errno = 0;
- /* else, a specific register number is given... */
+ nr = regmap (gdbarch, regno, &isfloat);
- else if (regno < FP0_REGNUM) /* a GPR */
- {
- ptrace (PT_WRITE_GPR, inferior_pid, (PTRACE_ARG3_TYPE) regno,
- *(int *) ®isters[REGISTER_BYTE (regno)], 0);
- }
+ /* Floating-point registers. */
+ if (isfloat)
+ rs6000_ptrace32 (PT_READ_FPR, pid, addr, nr, 0);
- else if (regno <= FPLAST_REGNUM) /* a FPR */
+ /* Bogus register number. */
+ else if (nr < 0)
{
- ptrace (PT_WRITE_FPR, inferior_pid,
- (PTRACE_ARG3_TYPE) & registers[REGISTER_BYTE (regno)],
- regno - FP0_REGNUM + FPR0, 0);
+ if (regno >= gdbarch_num_regs (gdbarch))
+ fprintf_unfiltered (gdb_stderr,
+ "gdb error: register no %d not implemented.\n",
+ regno);
+ return;
}
- else if (regno <= LAST_UISA_SP_REGNUM) /* a special register */
+ /* Fixed-point registers. */
+ else
{
- ptrace (PT_WRITE_GPR, inferior_pid,
- (PTRACE_ARG3_TYPE) special_regs[regno - FIRST_UISA_SP_REGNUM],
- *(int *) ®isters[REGISTER_BYTE (regno)], 0);
+ if (!ARCH64 ())
+ *addr = rs6000_ptrace32 (PT_READ_GPR, pid, (int *) nr, 0, 0);
+ else
+ {
+ /* PT_READ_GPR requires the buffer parameter to point to long long,
+ even if the register is really only 32 bits. */
+ long long buf;
+ rs6000_ptrace64 (PT_READ_GPR, pid, nr, 0, &buf);
+ if (register_size (gdbarch, regno) == 8)
+ memcpy (addr, &buf, 8);
+ else
+ *addr = buf;
+ }
}
+ if (!errno)
+ regcache_raw_supply (regcache, regno, (char *) addr);
else
- fprintf_unfiltered (gdb_stderr,
- "Gdb error: register no %d not implemented.\n",
- regno);
-
- if (errno)
{
- perror ("ptrace write");
+#if 0
+ /* FIXME: this happens 3 times at the start of each 64-bit program. */
+ perror (_("ptrace read"));
+#endif
errno = 0;
}
}
-/* Execute one dummy breakpoint instruction. This way we give the kernel
- a chance to do some housekeeping and update inferior's internal data,
- including u_area. */
+/* Store register REGNO back into the inferior. */
static void
-exec_one_dummy_insn ()
+store_register (struct regcache *regcache, int regno)
{
-#define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ int addr[PPC_MAX_REGISTER_SIZE];
+ int nr, isfloat;
+ pid_t pid = ptid_get_pid (regcache_get_ptid (regcache));
- char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
- int status, pid;
- CORE_ADDR prev_pc;
-
- /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
- assume that this address will never be executed again by the real
- code. */
-
- target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
+ /* Fetch the register's value from the register cache. */
+ regcache_raw_collect (regcache, regno, addr);
+ /* -1 can be a successful return value, so infer errors from errno. */
errno = 0;
- /* You might think this could be done with a single ptrace call, and
- you'd be correct for just about every platform I've ever worked
- on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
- the inferior never hits the breakpoint (it's also worth noting
- powerpc-ibm-aix4.1.3 works correctly). */
- prev_pc = read_pc ();
- write_pc (DUMMY_INSN_ADDR);
- ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, 0, 0);
+ nr = regmap (gdbarch, regno, &isfloat);
- if (errno)
- perror ("pt_continue");
+ /* Floating-point registers. */
+ if (isfloat)
+ rs6000_ptrace32 (PT_WRITE_FPR, pid, addr, nr, 0);
- do
+ /* Bogus register number. */
+ else if (nr < 0)
{
- pid = wait (&status);
+ if (regno >= gdbarch_num_regs (gdbarch))
+ fprintf_unfiltered (gdb_stderr,
+ "gdb error: register no %d not implemented.\n",
+ regno);
}
- while (pid != inferior_pid);
-
- write_pc (prev_pc);
- target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
-}
-static void
-fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
- char *core_reg_sect;
- unsigned core_reg_size;
- int which;
- CORE_ADDR reg_addr; /* Unused in this version */
-{
- /* fetch GPRs and special registers from the first register section
- in core bfd. */
- if (which == 0)
+ /* Fixed-point registers. */
+ else
{
- /* copy GPRs first. */
- memcpy (registers, core_reg_sect, 32 * 4);
-
- /* gdb's internal register template and bfd's register section layout
- should share a common include file. FIXMEmgo */
- /* then comes special registes. They are supposed to be in the same
- order in gdb template and bfd `.reg' section. */
- core_reg_sect += (32 * 4);
- memcpy (®isters[REGISTER_BYTE (FIRST_UISA_SP_REGNUM)],
- core_reg_sect,
- (LAST_UISA_SP_REGNUM - FIRST_UISA_SP_REGNUM + 1) * 4);
+ /* 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,
+ the address of a buffer containing the value is passed. */
+ if (!ARCH64 ())
+ rs6000_ptrace32 (PT_WRITE_GPR, pid, (int *) nr, *addr, 0);
+ else
+ {
+ /* 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 (gdbarch, regno) == 8)
+ memcpy (&buf, addr, 8);
+ else
+ buf = *addr;
+ rs6000_ptrace64 (PT_WRITE_GPR, pid, nr, 0, &buf);
+ }
}
- /* fetch floating point registers from register section 2 in core bfd. */
- else if (which == 2)
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 32 * 8);
-
- else
- fprintf_unfiltered
- (gdb_stderr,
- "Gdb error: unknown parameter to fetch_core_registers().\n");
+ if (errno)
+ {
+ perror (_("ptrace write"));
+ errno = 0;
+ }
}
-\f
-/* handle symbol translation on vmapping */
+
+/* Read from the inferior all registers if REGNO == -1 and just register
+ REGNO otherwise. */
static void
-vmap_symtab (vp)
- register struct vmap *vp;
+rs6000_fetch_inferior_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
- register struct objfile *objfile;
- struct section_offsets *new_offsets;
- int i;
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ if (regno != -1)
+ fetch_register (regcache, regno);
- objfile = vp->objfile;
- if (objfile == NULL)
+ else
{
- /* OK, it's not an objfile we opened ourselves.
- Currently, that can only happen with the exec file, so
- relocate the symbols for the symfile. */
- if (symfile_objfile == NULL)
- return;
- objfile = symfile_objfile;
- }
-
- new_offsets = alloca
- (sizeof (struct section_offsets)
- + sizeof (new_offsets->offsets) * objfile->num_sections);
-
- for (i = 0; i < objfile->num_sections; ++i)
- ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- /* The symbols in the object file are linked to the VMA of the section,
- relocate them VMA relative. */
- ANOFFSET (new_offsets, SECT_OFF_TEXT) = vp->tstart - vp->tvma;
- ANOFFSET (new_offsets, SECT_OFF_DATA) = vp->dstart - vp->dvma;
- ANOFFSET (new_offsets, SECT_OFF_BSS) = vp->dstart - vp->dvma;
-
- objfile_relocate (objfile, new_offsets);
-}
-\f
-/* Add symbols for an objfile. */
-
-static int
-objfile_symbol_add (arg)
- char *arg;
-{
- struct objfile *obj = (struct objfile *) arg;
+ /* Read 32 general purpose registers. */
+ for (regno = tdep->ppc_gp0_regnum;
+ regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
+ regno++)
+ {
+ fetch_register (regcache, regno);
+ }
- syms_from_objfile (obj, 0, 0, 0);
- new_symfile_objfile (obj, 0, 0);
- return 1;
+ /* Read general purpose floating point registers. */
+ if (tdep->ppc_fp0_regnum >= 0)
+ for (regno = 0; regno < ppc_num_fprs; regno++)
+ fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
+
+ /* Read special registers. */
+ 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);
+ fetch_register (regcache, tdep->ppc_ctr_regnum);
+ fetch_register (regcache, tdep->ppc_xer_regnum);
+ if (tdep->ppc_fpscr_regnum >= 0)
+ fetch_register (regcache, tdep->ppc_fpscr_regnum);
+ if (tdep->ppc_mq_regnum >= 0)
+ fetch_register (regcache, tdep->ppc_mq_regnum);
+ }
}
-/* Add a new vmap entry based on ldinfo() information.
-
- If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
- core file), the caller should set it to -1, and we will open the file.
-
- Return the vmap new entry. */
+/* Store our register values back into the inferior.
+ If REGNO is -1, do this for all registers.
+ Otherwise, REGNO specifies which register (so we can save time). */
-static struct vmap *
-add_vmap (ldi)
- register struct ld_info *ldi;
+static void
+rs6000_store_inferior_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
- bfd *abfd, *last;
- register char *mem, *objname;
- struct objfile *obj;
- struct vmap *vp;
-
- /* This ldi structure was allocated using alloca() in
- xcoff_relocate_symtab(). Now we need to have persistent object
- and member names, so we should save them. */
-
- mem = ldi->ldinfo_filename + strlen (ldi->ldinfo_filename) + 1;
- mem = savestring (mem, strlen (mem));
- objname = savestring (ldi->ldinfo_filename, strlen (ldi->ldinfo_filename));
-
- if (ldi->ldinfo_fd < 0)
- /* Note that this opens it once for every member; a possible
- enhancement would be to only open it once for every object. */
- abfd = bfd_openr (objname, gnutarget);
- else
- abfd = bfd_fdopenr (objname, gnutarget, ldi->ldinfo_fd);
- if (!abfd)
- error ("Could not open `%s' as an executable file: %s",
- objname, bfd_errmsg (bfd_get_error ()));
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ if (regno != -1)
+ store_register (regcache, regno);
- /* make sure we have an object file */
-
- if (bfd_check_format (abfd, bfd_object))
- vp = map_vmap (abfd, 0);
-
- else if (bfd_check_format (abfd, bfd_archive))
+ else
{
- last = 0;
- /* FIXME??? am I tossing BFDs? bfd? */
- while ((last = bfd_openr_next_archived_file (abfd, last)))
- if (STREQ (mem, last->filename))
- break;
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- if (!last)
+ /* Write general purpose registers first. */
+ for (regno = tdep->ppc_gp0_regnum;
+ regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
+ regno++)
{
- bfd_close (abfd);
- /* FIXME -- should be error */
- warning ("\"%s\": member \"%s\" missing.", abfd->filename, mem);
- return 0;
+ store_register (regcache, regno);
}
- if (!bfd_check_format (last, bfd_object))
- {
- bfd_close (last); /* XXX??? */
- goto obj_err;
- }
-
- vp = map_vmap (last, abfd);
- }
- else
- {
- obj_err:
- bfd_close (abfd);
- error ("\"%s\": not in executable format: %s.",
- objname, bfd_errmsg (bfd_get_error ()));
- /*NOTREACHED */
+ /* Write floating point registers. */
+ if (tdep->ppc_fp0_regnum >= 0)
+ for (regno = 0; regno < ppc_num_fprs; regno++)
+ store_register (regcache, tdep->ppc_fp0_regnum + regno);
+
+ /* Write special registers. */
+ 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);
+ store_register (regcache, tdep->ppc_ctr_regnum);
+ store_register (regcache, tdep->ppc_xer_regnum);
+ if (tdep->ppc_fpscr_regnum >= 0)
+ store_register (regcache, tdep->ppc_fpscr_regnum);
+ if (tdep->ppc_mq_regnum >= 0)
+ store_register (regcache, tdep->ppc_mq_regnum);
}
- obj = allocate_objfile (vp->bfd, 0, 0, 0);
- vp->objfile = obj;
+}
+
+/* Implement the to_xfer_partial target_ops method. */
+
+static enum target_xfer_status
+rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+{
+ pid_t pid = ptid_get_pid (inferior_ptid);
+ int arch64 = ARCH64 ();
-#ifndef SOLIB_SYMBOLS_MANUAL
- if (catch_errors (objfile_symbol_add, (char *) obj,
- "Error while reading shared library symbols:\n",
- RETURN_MASK_ALL))
+ switch (object)
{
- /* Note this is only done if symbol reading was successful. */
- vmap_symtab (vp);
- vp->loaded = 1;
+ case TARGET_OBJECT_LIBRARIES_AIX:
+ return rs6000_xfer_shared_libraries (ops, object, annex,
+ readbuf, writebuf,
+ offset, len, xfered_len);
+ case TARGET_OBJECT_MEMORY:
+ {
+ union
+ {
+ PTRACE_TYPE_RET word;
+ gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
+ } buffer;
+ ULONGEST rounded_offset;
+ LONGEST partial_len;
+
+ /* Round the start offset down to the next long word
+ boundary. */
+ rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
+
+ /* Since ptrace will transfer a single word starting at that
+ rounded_offset the partial_len needs to be adjusted down to
+ that (remember this function only does a single transfer).
+ Should the required length be even less, adjust it down
+ again. */
+ partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
+ if (partial_len > len)
+ partial_len = len;
+
+ if (writebuf)
+ {
+ /* If OFFSET:PARTIAL_LEN is smaller than
+ ROUNDED_OFFSET:WORDSIZE then a read/modify write will
+ be needed. Read in the entire word. */
+ if (rounded_offset < offset
+ || (offset + partial_len
+ < rounded_offset + sizeof (PTRACE_TYPE_RET)))
+ {
+ /* Need part of initial word -- fetch it. */
+ if (arch64)
+ buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
+ rounded_offset, 0, NULL);
+ else
+ buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
+ (int *) (uintptr_t)
+ rounded_offset,
+ 0, NULL);
+ }
+
+ /* Copy data to be written over corresponding part of
+ buffer. */
+ memcpy (buffer.byte + (offset - rounded_offset),
+ writebuf, partial_len);
+
+ errno = 0;
+ if (arch64)
+ rs6000_ptrace64 (PT_WRITE_D, pid,
+ rounded_offset, buffer.word, NULL);
+ else
+ rs6000_ptrace32 (PT_WRITE_D, pid,
+ (int *) (uintptr_t) rounded_offset,
+ buffer.word, NULL);
+ if (errno)
+ return TARGET_XFER_EOF;
+ }
+
+ if (readbuf)
+ {
+ errno = 0;
+ if (arch64)
+ buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
+ rounded_offset, 0, NULL);
+ else
+ buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
+ (int *)(uintptr_t)rounded_offset,
+ 0, NULL);
+ if (errno)
+ return TARGET_XFER_EOF;
+
+ /* Copy appropriate bytes out of the buffer. */
+ memcpy (readbuf, buffer.byte + (offset - rounded_offset),
+ partial_len);
+ }
+
+ *xfered_len = (ULONGEST) partial_len;
+ return TARGET_XFER_OK;
+ }
+
+ default:
+ return TARGET_XFER_E_IO;
}
-#endif
- return vp;
}
-\f
-/* update VMAP info with ldinfo() information
- Input is ptr to ldinfo() results. */
-static void
-vmap_ldinfo (ldi)
- register struct ld_info *ldi;
-{
- struct stat ii, vi;
- register struct vmap *vp;
- int got_one, retried;
- int got_exec_file = 0;
+/* Wait for the child specified by PTID to do something. Return the
+ process ID of the child, or MINUS_ONE_PTID in case of error; store
+ the status in *OURSTATUS. */
- /* For each *ldi, see if we have a corresponding *vp.
- If so, update the mapping, and symbol table.
- If not, add an entry and symbol table. */
+static ptid_t
+rs6000_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus, int options)
+{
+ pid_t pid;
+ int status, save_errno;
do
{
- char *name = ldi->ldinfo_filename;
- char *memb = name + strlen (name) + 1;
+ set_sigint_trap ();
- retried = 0;
-
- if (fstat (ldi->ldinfo_fd, &ii) < 0)
- {
- /* The kernel sets ld_info to -1, if the process is still using the
- object, and the object is removed. Keep the symbol info for the
- removed object and issue a warning. */
- warning ("%s (fd=%d) has disappeared, keeping its symbols",
- name, ldi->ldinfo_fd);
- continue;
- }
- retry:
- for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
+ do
{
- struct objfile *objfile;
-
- /* First try to find a `vp', which is the same as in ldinfo.
- If not the same, just continue and grep the next `vp'. If same,
- relocate its tstart, tend, dstart, dend values. If no such `vp'
- found, get out of this for loop, add this ldi entry as a new vmap
- (add_vmap) and come back, find its `vp' and so on... */
-
- /* The filenames are not always sufficient to match on. */
-
- if ((name[0] == '/' && !STREQ (name, vp->name))
- || (memb[0] && !STREQ (memb, vp->member)))
- continue;
-
- /* See if we are referring to the same file.
- We have to check objfile->obfd, symfile.c:reread_symbols might
- have updated the obfd after a change. */
- objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
- if (objfile == NULL
- || objfile->obfd == NULL
- || bfd_stat (objfile->obfd, &vi) < 0)
- {
- warning ("Unable to stat %s, keeping its symbols", name);
- continue;
- }
-
- if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
- continue;
-
- if (!retried)
- close (ldi->ldinfo_fd);
-
- ++got_one;
-
- /* Found a corresponding VMAP. Remap! */
-
- /* We can assume pointer == CORE_ADDR, this code is native only. */
- vp->tstart = (CORE_ADDR) ldi->ldinfo_textorg;
- vp->tend = vp->tstart + ldi->ldinfo_textsize;
- vp->dstart = (CORE_ADDR) ldi->ldinfo_dataorg;
- vp->dend = vp->dstart + ldi->ldinfo_datasize;
-
- /* The run time loader maps the file header in addition to the text
- section and returns a pointer to the header in ldinfo_textorg.
- Adjust the text start address to point to the real start address
- of the text section. */
- vp->tstart += vp->toffs;
-
- /* The objfile is only NULL for the exec file. */
- if (vp->objfile == NULL)
- got_exec_file = 1;
-
- /* relocate symbol table(s). */
- vmap_symtab (vp);
-
- /* There may be more, so we don't break out of the loop. */
+ pid = waitpid (ptid_get_pid (ptid), &status, 0);
+ save_errno = errno;
}
+ while (pid == -1 && errno == EINTR);
+
+ clear_sigint_trap ();
- /* if there was no matching *vp, we must perforce create the sucker(s) */
- if (!got_one && !retried)
+ if (pid == -1)
{
- add_vmap (ldi);
- ++retried;
- goto retry;
+ fprintf_unfiltered (gdb_stderr,
+ _("Child process unexpectedly missing: %s.\n"),
+ safe_strerror (save_errno));
+
+ /* Claim it exited with unknown signal. */
+ ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+ ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
+ return inferior_ptid;
}
+
+ /* Ignore terminated detached child processes. */
+ if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
+ pid = -1;
}
- while (ldi->ldinfo_next
- && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
-
- /* If we don't find the symfile_objfile anywhere in the ldinfo, it
- is unlikely that the symbol file is relocated to the proper
- address. And we might have attached to a process which is
- running a different copy of the same executable. */
- if (symfile_objfile != NULL && !got_exec_file)
- {
- warning_begin ();
- fputs_unfiltered ("Symbol file ", gdb_stderr);
- fputs_unfiltered (symfile_objfile->name, gdb_stderr);
- fputs_unfiltered ("\nis not mapped; discarding it.\n\
-If in fact that file has symbols which the mapped files listed by\n\
-\"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
-\"add-symbol-file\" commands (note that you must take care of relocating\n\
-symbols to the proper address).\n", gdb_stderr);
- free_objfile (symfile_objfile);
- symfile_objfile = NULL;
- }
- breakpoint_re_set ();
+ while (pid == -1);
+
+ /* AIX has a couple of strange returns from wait(). */
+
+ /* stop after load" status. */
+ if (status == 0x57c)
+ ourstatus->kind = TARGET_WAITKIND_LOADED;
+ /* signal 0. I have no idea why wait(2) returns with this status word. */
+ else if (status == 0x7f)
+ ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+ /* A normal waitstatus. Let the usual macros deal with it. */
+ else
+ store_waitstatus (ourstatus, status);
+
+ return pid_to_ptid (pid);
}
\f
-/* As well as symbol tables, exec_sections need relocation. After
- the inferior process' termination, there will be a relocated symbol
- table exist with no corresponding inferior process. At that time, we
- need to use `exec' bfd, rather than the inferior process's memory space
- to look up symbols.
- `exec_sections' need to be relocated only once, as long as the exec
- file remains unchanged.
- */
+/* Set the current architecture from the host running GDB. Called when
+ starting a child process. */
+static void (*super_create_inferior) (struct target_ops *,
+ const char *exec_file,
+ const std::string &allargs,
+ char **env, int from_tty);
static void
-vmap_exec ()
+rs6000_create_inferior (struct target_ops * ops, const char *exec_file,
+ const std::string &allargs, char **env, int from_tty)
{
- static bfd *execbfd;
- int i;
+ enum bfd_architecture arch;
+ unsigned long mach;
+ bfd abfd;
+ struct gdbarch_info info;
- if (execbfd == exec_bfd)
- return;
+ super_create_inferior (ops, exec_file, allargs, env, from_tty);
- execbfd = exec_bfd;
-
- if (!vmap || !exec_ops.to_sections)
- error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
-
- for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
+ if (__power_rs ())
{
- if (STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
- {
- exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
- exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
- }
- else if (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
- {
- exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
- exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
- }
- else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
- {
- exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
- exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
- }
+ arch = bfd_arch_rs6000;
+ mach = bfd_mach_rs6k;
+ }
+ else
+ {
+ arch = bfd_arch_powerpc;
+ mach = bfd_mach_ppc;
}
-}
-\f
-/* xcoff_relocate_symtab - hook for symbol table relocation.
- also reads shared libraries.. */
-
-void
-xcoff_relocate_symtab (pid)
- unsigned int pid;
-{
-#define MAX_LOAD_SEGS 64 /* maximum number of load segments */
-
- struct ld_info *ldi;
- ldi = (void *) alloca (MAX_LOAD_SEGS * sizeof (*ldi));
+ /* FIXME: schauer/2002-02-25:
+ We don't know if we are executing a 32 or 64 bit executable,
+ and have no way to pass the proper word size to rs6000_gdbarch_init.
+ So we have to avoid switching to a new architecture, if the architecture
+ matches already.
+ Blindly calling rs6000_gdbarch_init used to work in older versions of
+ GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
+ determine the wordsize. */
+ if (exec_bfd)
+ {
+ const struct bfd_arch_info *exec_bfd_arch_info;
- /* According to my humble theory, AIX has some timing problems and
- when the user stack grows, kernel doesn't update stack info in time
- and ptrace calls step on user stack. That is why we sleep here a little,
- and give kernel to update its internals. */
+ exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
+ if (arch == exec_bfd_arch_info->arch)
+ return;
+ }
- usleep (36000);
+ bfd_default_set_arch_mach (&abfd, arch, mach);
- errno = 0;
- ptrace (PT_LDINFO, pid, (PTRACE_ARG3_TYPE) ldi,
- MAX_LOAD_SEGS * sizeof (*ldi), (int *) ldi);
- if (errno)
- perror_with_name ("ptrace ldinfo");
+ gdbarch_info_init (&info);
+ info.bfd_arch_info = bfd_get_arch_info (&abfd);
+ info.abfd = exec_bfd;
- vmap_ldinfo (ldi);
-
- /* relocate the exec and core sections as well. */
- vmap_exec ();
+ if (!gdbarch_update_p (info))
+ internal_error (__FILE__, __LINE__,
+ _("rs6000_create_inferior: failed "
+ "to select architecture"));
}
\f
-/* Core file stuff. */
-
-/* Relocate symtabs and read in shared library info, based on symbols
- from the core file. */
-
-void
-xcoff_relocate_core (target)
- struct target_ops *target;
-{
-/* Offset of member MEMBER in a struct of type TYPE. */
-#ifndef offsetof
-#define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
-#endif
-/* Size of a struct ld_info except for the variable-length filename. */
-#define LDINFO_SIZE (offsetof (struct ld_info, ldinfo_filename))
+/* Shared Object support. */
- sec_ptr ldinfo_sec;
- int offset = 0;
- struct ld_info *ldip;
- struct vmap *vp;
+/* Return the LdInfo data for the given process. Raises an error
+ if the data could not be obtained.
- /* Allocated size of buffer. */
- int buffer_size = LDINFO_SIZE;
- char *buffer = xmalloc (buffer_size);
- struct cleanup *old = make_cleanup (free_current_contents, &buffer);
+ The returned value must be deallocated after use. */
- /* FIXME, this restriction should not exist. For now, though I'll
- avoid coredumps with error() pending a real fix. */
- if (vmap == NULL)
- error
- ("Can't debug a core file without an executable file (on the RS/6000)");
+static gdb_byte *
+rs6000_ptrace_ldinfo (ptid_t ptid)
+{
+ const int pid = ptid_get_pid (ptid);
+ int ldi_size = 1024;
+ void *ldi = xmalloc (ldi_size);
+ int rc = -1;
- ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
- if (ldinfo_sec == NULL)
- {
- bfd_err:
- fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
- bfd_errmsg (bfd_get_error ()));
- do_cleanups (old);
- return;
- }
- do
+ while (1)
{
- int i;
- int names_found = 0;
-
- /* Read in everything but the name. */
- if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
- offset, LDINFO_SIZE) == 0)
- goto bfd_err;
+ if (ARCH64 ())
+ rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, ldi_size,
+ NULL);
+ else
+ rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, ldi_size, NULL);
- /* Now the name. */
- i = LDINFO_SIZE;
- do
- {
- if (i == buffer_size)
- {
- buffer_size *= 2;
- buffer = xrealloc (buffer, buffer_size);
- }
- if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
- offset + i, 1) == 0)
- goto bfd_err;
- if (buffer[i++] == '\0')
- ++names_found;
- }
- while (names_found < 2);
+ if (rc != -1)
+ break; /* Success, we got the entire ld_info data. */
- ldip = (struct ld_info *) buffer;
+ if (errno != ENOMEM)
+ perror_with_name (_("ptrace ldinfo"));
- /* Can't use a file descriptor from the core file; need to open it. */
- ldip->ldinfo_fd = -1;
+ /* ldi is not big enough. Double it and try again. */
+ ldi_size *= 2;
+ ldi = xrealloc (ldi, ldi_size);
+ }
- /* The first ldinfo is for the exec file, allocated elsewhere. */
- if (offset == 0)
- vp = vmap;
- else
- vp = add_vmap (ldip);
+ return (gdb_byte *) ldi;
+}
- offset += ldip->ldinfo_next;
+/* Implement the to_xfer_partial target_ops method for
+ TARGET_OBJECT_LIBRARIES_AIX objects. */
- /* We can assume pointer == CORE_ADDR, this code is native only. */
- vp->tstart = (CORE_ADDR) ldip->ldinfo_textorg;
- vp->tend = vp->tstart + ldip->ldinfo_textsize;
- vp->dstart = (CORE_ADDR) ldip->ldinfo_dataorg;
- vp->dend = vp->dstart + ldip->ldinfo_datasize;
+static enum target_xfer_status
+rs6000_xfer_shared_libraries
+ (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+{
+ gdb_byte *ldi_buf;
+ ULONGEST result;
+ struct cleanup *cleanup;
- /* The run time loader maps the file header in addition to the text
- section and returns a pointer to the header in ldinfo_textorg.
- Adjust the text start address to point to the real start address
- of the text section. */
- vp->tstart += vp->toffs;
+ /* This function assumes that it is being run with a live process.
+ Core files are handled via gdbarch. */
+ gdb_assert (target_has_execution);
- /* Unless this is the exec file,
- add our sections to the section table for the core target. */
- if (vp != vmap)
- {
- int count;
- struct section_table *stp;
- int update_coreops;
-
- /* We must update the to_sections field in the core_ops structure
- now to avoid dangling pointer dereferences. */
- update_coreops = core_ops.to_sections == target->to_sections;
-
- count = target->to_sections_end - target->to_sections;
- count += 2;
- target->to_sections = (struct section_table *)
- xrealloc (target->to_sections,
- sizeof (struct section_table) * count);
- target->to_sections_end = target->to_sections + count;
-
- /* Update the to_sections field in the core_ops structure
- if needed. */
- if (update_coreops)
- {
- core_ops.to_sections = target->to_sections;
- core_ops.to_sections_end = target->to_sections_end;
- }
- stp = target->to_sections_end - 2;
-
- stp->bfd = vp->bfd;
- stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
- stp->addr = vp->tstart;
- stp->endaddr = vp->tend;
- stp++;
-
- stp->bfd = vp->bfd;
- stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
- stp->addr = vp->dstart;
- stp->endaddr = vp->dend;
- }
+ if (writebuf)
+ return TARGET_XFER_E_IO;
- vmap_symtab (vp);
- }
- while (ldip->ldinfo_next != 0);
- vmap_exec ();
- breakpoint_re_set ();
- do_cleanups (old);
-}
+ ldi_buf = rs6000_ptrace_ldinfo (inferior_ptid);
+ gdb_assert (ldi_buf != NULL);
+ cleanup = make_cleanup (xfree, ldi_buf);
+ result = rs6000_aix_ld_info_to_xml (target_gdbarch (), ldi_buf,
+ readbuf, offset, len, 1);
+ xfree (ldi_buf);
-int
-kernel_u_size ()
-{
- return (sizeof (struct user));
-}
-\f
-/* Under AIX, we have to pass the correct TOC pointer to a function
- when calling functions in the inferior.
- We try to find the relative toc offset of the objfile containing PC
- and add the current load address of the data segment from the vmap. */
-
-static CORE_ADDR
-find_toc_address (pc)
- CORE_ADDR pc;
-{
- struct vmap *vp;
+ do_cleanups (cleanup);
- for (vp = vmap; vp; vp = vp->nxt)
+ if (result == 0)
+ return TARGET_XFER_EOF;
+ else
{
- if (pc >= vp->tstart && pc < vp->tend)
- {
- /* vp->objfile is only NULL for the exec file. */
- return vp->dstart + get_toc_offset (vp->objfile == NULL
- ? symfile_objfile
- : vp->objfile);
- }
+ *xfered_len = result;
+ return TARGET_XFER_OK;
}
- error ("Unable to find TOC entry for pc 0x%x\n", pc);
}
-\f
-/* Register that we are able to handle rs6000 core file formats. */
-static struct core_fns rs6000_core_fns =
-{
- bfd_target_coff_flavour,
- fetch_core_registers,
- NULL
-};
+void _initialize_rs6000_nat (void);
void
-_initialize_core_rs6000 ()
+_initialize_rs6000_nat (void)
{
- /* Initialize hook in rs6000-tdep.c for determining the TOC address when
- calling functions in the inferior. */
- find_toc_address_hook = &find_toc_address;
-
- /* For native configurations, where this module is included, inform
- the xcoffsolib module where it can find the function for symbol table
- relocation at runtime. */
- xcoff_relocate_symtab_hook = &xcoff_relocate_symtab;
- add_core_fns (&rs6000_core_fns);
+ struct target_ops *t;
+
+ t = inf_ptrace_target ();
+ t->to_fetch_registers = rs6000_fetch_inferior_registers;
+ t->to_store_registers = rs6000_store_inferior_registers;
+ t->to_xfer_partial = rs6000_xfer_partial;
+
+ super_create_inferior = t->to_create_inferior;
+ t->to_create_inferior = rs6000_create_inferior;
+
+ t->to_wait = rs6000_wait;
+
+ add_target (t);
}
projects / deliverable / binutils-gdb.git / blobdiff