/* 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
- Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 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 "target.h"
#include "gdbcore.h"
-#include "xcoffsolib.h"
#include "symfile.h"
#include "objfiles.h"
-#include "libbfd.h" /* For bfd_default_set_arch_mach (FIXME) */
#include "bfd.h"
-#include "exceptions.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 "observable.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 <sys/ioctl.h>
#include <fcntl.h>
-#include <errno.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 */
/* 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. */
+ accessing fields in the appropriate structures. */
/* 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. */
+ works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
-#ifdef __ld_info32
+#if defined (__ld_info32) || defined (__ld_info64)
# define ARCH3264
#endif
-/* Return whether the current architecture is 64-bit. */
+/* Return whether the current architecture is 64-bit. */
#ifndef ARCH3264
# define ARCH64() 0
#else
-# define ARCH64() (register_size (current_gdbarch, 0) == 8)
+# define ARCH64() (register_size (target_gdbarch (), 0) == 8)
#endif
-/* Union of 32-bit and 64-bit ".reg" core file sections. */
-
-typedef union {
-#ifdef ARCH3264
- struct __context64 r64;
-#else
- struct mstsave r64;
-#endif
- struct mstsave r32;
-} CoreRegs;
-
-/* Union of 32-bit and 64-bit versions of ld_info. */
-
-typedef union {
-#ifndef ARCH3264
- struct ld_info l32;
- struct ld_info l64;
-#else
- struct __ld_info32 l32;
- struct __ld_info64 l64;
-#endif
-} LdInfo;
-
-/* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
- declare and initialize a variable named VAR suitable for use as the arch64
- parameter to the various LDI_*() macros. */
-
-#ifndef ARCH3264
-# define ARCH64_DECL(var)
-#else
-# define ARCH64_DECL(var) int var = ARCH64 ()
-#endif
-
-/* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
- otherwise. This technique only works for FIELDs with the same data type in
- 32-bit and 64-bit versions of ld_info. */
-
-#ifndef ARCH3264
-# define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
-#else
-# define LDI_FIELD(ldi, arch64, field) \
- (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
-#endif
-
-/* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
- process otherwise. */
-
-#define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
-#define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
-#define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
-
-extern struct vmap *map_vmap (bfd * bf, bfd * arch);
-
-static void vmap_exec (void);
-
-static void vmap_ldinfo (LdInfo *);
-
-static struct vmap *add_vmap (LdInfo *);
-
-static int objfile_symbol_add (void *);
-
-static void vmap_symtab (struct vmap *);
-
-static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
-
-static void exec_one_dummy_insn (void);
+class rs6000_nat_target final : public inf_ptrace_target
+{
+public:
+ void fetch_registers (struct regcache *, int) override;
+ void store_registers (struct regcache *, int) override;
+
+ enum target_xfer_status xfer_partial (enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len) override;
+
+ void create_inferior (const char *, const std::string &,
+ char **, int) override;
+
+ ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+
+private:
+ enum target_xfer_status
+ xfer_shared_libraries (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len);
+};
-extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
+static rs6000_nat_target the_rs6000_nat_target;
/* Given REGNO, a gdb register number, return the corresponding
number suitable for use as a ptrace() parameter. Return -1 if
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 == PC_REGNUM)
+ else if (regno == gdbarch_pc_regnum (gdbarch))
return IAR;
else if (regno == tdep->ppc_ps_regnum)
return MSR;
return -1;
}
-/* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
+/* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
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);
return ret;
}
-/* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
+/* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
static int
-rs6000_ptrace64 (int req, int id, long long addr, int data, int *buf)
+rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
{
#ifdef ARCH3264
- int ret = ptracex (req, id, addr, data, buf);
+# 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, 0x%llx, %08x, 0x%x) = 0x%x\n",
- req, id, addr, data, (unsigned int)buf, ret);
+ 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;
}
-/* Fetch register REGNO from the inferior. */
+/* Fetch register REGNO from the inferior. */
static void
-fetch_register (int regno)
+fetch_register (struct regcache *regcache, int regno)
{
- int addr[MAX_REGISTER_SIZE];
+ struct gdbarch *gdbarch = regcache->arch ();
+ int addr[PPC_MAX_REGISTER_SIZE];
int nr, isfloat;
+ pid_t pid = ptid_get_pid (regcache_get_ptid (regcache));
- /* Retrieved values may be -1, so infer errors from errno. */
+ /* Retrieved values may be -1, so infer errors from errno. */
errno = 0;
- nr = regmap (regno, &isfloat);
+ nr = regmap (gdbarch, regno, &isfloat);
- /* Floating-point registers. */
+ /* Floating-point registers. */
if (isfloat)
- rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
+ rs6000_ptrace32 (PT_READ_FPR, pid, addr, nr, 0);
- /* Bogus register number. */
+ /* Bogus register number. */
else if (nr < 0)
{
- if (regno >= NUM_REGS)
+ if (regno >= gdbarch_num_regs (gdbarch))
fprintf_unfiltered (gdb_stderr,
"gdb error: register no %d not implemented.\n",
regno);
return;
}
- /* Fixed-point registers. */
+ /* Fixed-point registers. */
else
{
if (!ARCH64 ())
- *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
+ *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. */
+ even if the register is really only 32 bits. */
long long buf;
- rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
- if (register_size (current_gdbarch, regno) == 8)
+ 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 (current_regcache, regno, (char *) addr);
+ regcache_raw_supply (regcache, regno, (char *) addr);
else
{
#if 0
- /* FIXME: this happens 3 times at the start of each 64-bit program. */
- perror ("ptrace read");
+ /* FIXME: this happens 3 times at the start of each 64-bit program. */
+ perror (_("ptrace read"));
#endif
errno = 0;
}
}
-/* Store register REGNO back into the inferior. */
+/* Store register REGNO back into the inferior. */
static void
-store_register (int regno)
+store_register (struct regcache *regcache, int regno)
{
- int addr[MAX_REGISTER_SIZE];
+ struct gdbarch *gdbarch = regcache->arch ();
+ int addr[PPC_MAX_REGISTER_SIZE];
int nr, isfloat;
+ pid_t pid = ptid_get_pid (regcache_get_ptid (regcache));
/* Fetch the register's value from the register cache. */
- regcache_raw_collect (current_regcache, regno, addr);
+ regcache_raw_collect (regcache, regno, addr);
- /* -1 can be a successful return value, so infer errors from errno. */
+ /* -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. */
+ /* Floating-point registers. */
if (isfloat)
- rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
+ rs6000_ptrace32 (PT_WRITE_FPR, pid, addr, nr, 0);
- /* Bogus register number. */
+ /* Bogus register number. */
else if (nr < 0)
{
- if (regno >= NUM_REGS)
+ if (regno >= gdbarch_num_regs (gdbarch))
fprintf_unfiltered (gdb_stderr,
"gdb error: register no %d not implemented.\n",
regno);
}
- /* Fixed-point registers. */
+ /* Fixed-point registers. */
else
{
- if (regno == SP_REGNUM)
- /* 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 ();
-
/* 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, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
+ 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. */
+ 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;
- rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
+ rs6000_ptrace64 (PT_WRITE_GPR, pid, nr, 0, &buf);
}
}
if (errno)
{
- perror ("ptrace write");
+ perror (_("ptrace write"));
errno = 0;
}
}
/* Read from the inferior all registers if REGNO == -1 and just register
- REGNO otherwise. */
+ REGNO otherwise. */
void
-fetch_inferior_registers (int regno)
+rs6000_nat_target::fetch_registers (struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = regcache->arch ();
if (regno != -1)
- fetch_register (regno);
+ 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;
regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
regno++)
{
- fetch_register (regno);
+ fetch_register (regcache, regno);
}
/* Read general purpose floating point registers. */
if (tdep->ppc_fp0_regnum >= 0)
for (regno = 0; regno < ppc_num_fprs; regno++)
- fetch_register (tdep->ppc_fp0_regnum + regno);
+ fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
/* Read special registers. */
- fetch_register (PC_REGNUM);
- fetch_register (tdep->ppc_ps_regnum);
- fetch_register (tdep->ppc_cr_regnum);
- fetch_register (tdep->ppc_lr_regnum);
- fetch_register (tdep->ppc_ctr_regnum);
- fetch_register (tdep->ppc_xer_regnum);
+ 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 (tdep->ppc_fpscr_regnum);
+ fetch_register (regcache, tdep->ppc_fpscr_regnum);
if (tdep->ppc_mq_regnum >= 0)
- fetch_register (tdep->ppc_mq_regnum);
+ fetch_register (regcache, tdep->ppc_mq_regnum);
}
}
Otherwise, REGNO specifies which register (so we can save time). */
void
-store_inferior_registers (int regno)
+rs6000_nat_target::store_registers (struct regcache *regcache, int regno)
{
+ struct gdbarch *gdbarch = regcache->arch ();
if (regno != -1)
- store_register (regno);
+ 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;
regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
regno++)
{
- store_register (regno);
+ store_register (regcache, regno);
}
/* Write floating point registers. */
if (tdep->ppc_fp0_regnum >= 0)
for (regno = 0; regno < ppc_num_fprs; regno++)
- store_register (tdep->ppc_fp0_regnum + regno);
+ store_register (regcache, tdep->ppc_fp0_regnum + regno);
/* Write special registers. */
- store_register (PC_REGNUM);
- store_register (tdep->ppc_ps_regnum);
- store_register (tdep->ppc_cr_regnum);
- store_register (tdep->ppc_lr_regnum);
- store_register (tdep->ppc_ctr_regnum);
- store_register (tdep->ppc_xer_regnum);
+ 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 (tdep->ppc_fpscr_regnum);
+ store_register (regcache, tdep->ppc_fpscr_regnum);
if (tdep->ppc_mq_regnum >= 0)
- store_register (tdep->ppc_mq_regnum);
+ store_register (regcache, tdep->ppc_mq_regnum);
}
}
-/* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
- process, which is 64-bit if ARCH64 and 32-bit otherwise. Return
- success. */
-
-static int
-read_word (CORE_ADDR from, int *to, int arch64)
-{
- /* Retrieved values may be -1, so infer errors from errno. */
- errno = 0;
-
- if (arch64)
- *to = rs6000_ptrace64 (PT_READ_I, PIDGET (inferior_ptid), from, 0, NULL);
- else
- *to = rs6000_ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
- 0, NULL);
-
- return !errno;
-}
-
-/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
- to debugger memory starting at MYADDR. Copy to inferior if
- WRITE is nonzero.
-
- Returns the length copied, which is either the LEN argument or
- zero. This xfer function does not do partial moves, since
- deprecated_child_ops doesn't allow memory operations to cross below
- us in the target stack anyway. */
+/* Implement the to_xfer_partial target_ops method. */
-int
-child_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
- int write, struct mem_attrib *attrib,
- struct target_ops *target)
+enum target_xfer_status
+rs6000_nat_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
{
- /* Round starting address down to 32-bit word boundary. */
- int mask = sizeof (int) - 1;
- CORE_ADDR addr = memaddr & ~(CORE_ADDR)mask;
-
- /* Round ending address up to 32-bit word boundary. */
- int count = ((memaddr + len - addr + mask) & ~(CORE_ADDR)mask)
- / sizeof (int);
-
- /* Allocate word transfer buffer. */
- /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
- because it uses alloca to allocate a buffer of arbitrary size.
- For very large xfers, this could crash GDB's stack. */
- int *buf = (int *) alloca (count * sizeof (int));
-
+ pid_t pid = ptid_get_pid (inferior_ptid);
int arch64 = ARCH64 ();
- int i;
- if (!write)
+ switch (object)
{
- /* Retrieve memory a word at a time. */
- for (i = 0; i < count; i++, addr += sizeof (int))
+ case TARGET_OBJECT_LIBRARIES_AIX:
+ return xfer_shared_libraries (object, annex,
+ readbuf, writebuf,
+ offset, len, xfered_len);
+ case TARGET_OBJECT_MEMORY:
+ {
+ union
{
- if (!read_word (addr, buf + i, arch64))
- return 0;
- QUIT;
- }
-
- /* Copy memory to supplied buffer. */
- addr -= count * sizeof (int);
- memcpy (myaddr, (char *)buf + (memaddr - addr), len);
- }
- else
- {
- /* Fetch leading memory needed for alignment. */
- if (addr < memaddr)
- if (!read_word (addr, buf, arch64))
- return 0;
-
- /* Fetch trailing memory needed for alignment. */
- if (addr + count * sizeof (int) > memaddr + len)
- if (!read_word (addr + (count - 1) * sizeof (int),
- buf + count - 1, arch64))
- return 0;
-
- /* Copy supplied data into memory buffer. */
- memcpy ((char *)buf + (memaddr - addr), myaddr, len);
-
- /* Store memory one word at a time. */
- for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
- {
- if (arch64)
- rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);
- else
- rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,
- buf[i], NULL);
-
- if (errno)
- return 0;
- QUIT;
- }
+ 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;
}
-
- return len;
}
-/* 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. */
+/* 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. */
-static void
-exec_one_dummy_insn (void)
+ptid_t
+rs6000_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
+ int options)
{
-#define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
-
- int ret, status, pid;
- CORE_ADDR prev_pc;
- void *bp;
-
- /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
- assume that this address will never be executed again by the real
- code. */
-
- bp = deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR);
-
- /* 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);
- if (ARCH64 ())
- ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
- else
- ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
-
- if (ret != 0)
- perror ("pt_continue");
+ pid_t pid;
+ int status, save_errno;
do
{
- pid = wait (&status);
- }
- while (pid != PIDGET (inferior_ptid));
-
- write_pc (prev_pc);
- deprecated_remove_raw_breakpoint (bp);
-}
-
-/* Fetch registers from the register section in core bfd. */
-
-static void
-fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
- int which, CORE_ADDR reg_addr)
-{
- CoreRegs *regs;
- int regi;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
-
- if (which != 0)
- {
- fprintf_unfiltered
- (gdb_stderr,
- "Gdb error: unknown parameter to fetch_core_registers().\n");
- return;
- }
-
- regs = (CoreRegs *) core_reg_sect;
-
- /* Put the register values from the core file section in the regcache. */
-
- if (ARCH64 ())
- {
- for (regi = 0; regi < ppc_num_gprs; regi++)
- regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
- (char *) ®s->r64.gpr[regi]);
-
- if (tdep->ppc_fp0_regnum >= 0)
- for (regi = 0; regi < ppc_num_fprs; regi++)
- regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
- (char *) ®s->r64.fpr[regi]);
-
- regcache_raw_supply (current_regcache, PC_REGNUM,
- (char *) ®s->r64.iar);
- regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
- (char *) ®s->r64.msr);
- regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
- (char *) ®s->r64.cr);
- regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
- (char *) ®s->r64.lr);
- regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
- (char *) ®s->r64.ctr);
- regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
- (char *) ®s->r64.xer);
- if (tdep->ppc_fpscr_regnum >= 0)
- regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
- (char *) ®s->r64.fpscr);
- }
- else
- {
- for (regi = 0; regi < ppc_num_gprs; regi++)
- regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
- (char *) ®s->r32.gpr[regi]);
-
- if (tdep->ppc_fp0_regnum >= 0)
- for (regi = 0; regi < ppc_num_fprs; regi++)
- regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
- (char *) ®s->r32.fpr[regi]);
-
- regcache_raw_supply (current_regcache, PC_REGNUM,
- (char *) ®s->r32.iar);
- regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
- (char *) ®s->r32.msr);
- regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
- (char *) ®s->r32.cr);
- regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
- (char *) ®s->r32.lr);
- regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
- (char *) ®s->r32.ctr);
- regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
- (char *) ®s->r32.xer);
- if (tdep->ppc_fpscr_regnum >= 0)
- regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
- (char *) ®s->r32.fpscr);
- if (tdep->ppc_mq_regnum >= 0)
- regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
- (char *) ®s->r32.mq);
- }
-}
-\f
-
-/* Copy information about text and data sections from LDI to VP for a 64-bit
- process if ARCH64 and for a 32-bit process otherwise. */
-
-static void
-vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
-{
- if (arch64)
- {
- vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
- vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
- vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
- vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
- }
- else
- {
- vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
- vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
- vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
- vp->dend = vp->dstart + ldi->l32.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;
-}
-
-/* handle symbol translation on vmapping */
-
-static void
-vmap_symtab (struct vmap *vp)
-{
- struct objfile *objfile;
- struct section_offsets *new_offsets;
- int i;
-
- objfile = vp->objfile;
- if (objfile == NULL)
- {
- /* 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;
- }
- else if (!vp->loaded)
- /* If symbols are not yet loaded, offsets are not yet valid. */
- return;
-
- new_offsets =
- (struct section_offsets *)
- alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
-
- for (i = 0; i < objfile->num_sections; ++i)
- new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
-
- /* The symbols in the object file are linked to the VMA of the section,
- relocate them VMA relative. */
- new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
- new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
- new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
-
- objfile_relocate (objfile, new_offsets);
-}
-\f
-/* Add symbols for an objfile. */
-
-static int
-objfile_symbol_add (void *arg)
-{
- struct objfile *obj = (struct objfile *) arg;
-
- syms_from_objfile (obj, NULL, 0, 0, 0, 0);
- new_symfile_objfile (obj, 0, 0);
- return 1;
-}
-
-/* Add symbols for a vmap. Return zero upon error. */
-
-int
-vmap_add_symbols (struct vmap *vp)
-{
- if (catch_errors (objfile_symbol_add, vp->objfile,
- "Error while reading shared library symbols:\n",
- RETURN_MASK_ALL))
- {
- /* Note this is only done if symbol reading was successful. */
- vp->loaded = 1;
- vmap_symtab (vp);
- return 1;
- }
- return 0;
-}
-
-/* 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. */
-
-static struct vmap *
-add_vmap (LdInfo *ldi)
-{
- bfd *abfd, *last;
- char *mem, *objname, *filename;
- struct objfile *obj;
- struct vmap *vp;
- int fd;
- ARCH64_DECL (arch64);
-
- /* 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. */
-
- filename = LDI_FILENAME (ldi, arch64);
- mem = filename + strlen (filename) + 1;
- mem = savestring (mem, strlen (mem));
- objname = savestring (filename, strlen (filename));
-
- fd = LDI_FD (ldi, arch64);
- if (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, fd);
- if (!abfd)
- {
- warning (_("Could not open `%s' as an executable file: %s"),
- objname, bfd_errmsg (bfd_get_error ()));
- return NULL;
- }
-
- /* 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))
- {
- last = 0;
- /* FIXME??? am I tossing BFDs? bfd? */
- while ((last = bfd_openr_next_archived_file (abfd, last)))
- if (DEPRECATED_STREQ (mem, last->filename))
- break;
-
- if (!last)
- {
- warning (_("\"%s\": member \"%s\" missing."), objname, mem);
- bfd_close (abfd);
- return NULL;
- }
+ set_sigint_trap ();
- if (!bfd_check_format (last, bfd_object))
+ do
{
- warning (_("\"%s\": member \"%s\" not in executable format: %s."),
- objname, mem, bfd_errmsg (bfd_get_error ()));
- bfd_close (last);
- bfd_close (abfd);
- return NULL;
+ pid = waitpid (ptid_get_pid (ptid), &status, 0);
+ save_errno = errno;
}
+ while (pid == -1 && errno == EINTR);
- vp = map_vmap (last, abfd);
- }
- else
- {
- warning (_("\"%s\": not in executable format: %s."),
- objname, bfd_errmsg (bfd_get_error ()));
- bfd_close (abfd);
- return NULL;
- }
- obj = allocate_objfile (vp->bfd, 0);
- vp->objfile = obj;
-
- /* Always add symbols for the main objfile. */
- if (vp == vmap || auto_solib_add)
- vmap_add_symbols (vp);
- return vp;
-}
-\f
-/* update VMAP info with ldinfo() information
- Input is ptr to ldinfo() results. */
-
-static void
-vmap_ldinfo (LdInfo *ldi)
-{
- struct stat ii, vi;
- struct vmap *vp;
- int got_one, retried;
- int got_exec_file = 0;
- uint next;
- int arch64 = ARCH64 ();
-
- /* 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. */
-
- do
- {
- char *name = LDI_FILENAME (ldi, arch64);
- char *memb = name + strlen (name) + 1;
- int fd = LDI_FD (ldi, arch64);
+ clear_sigint_trap ();
- retried = 0;
-
- if (fstat (fd, &ii) < 0)
+ if (pid == -1)
{
- /* 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, fd);
- continue;
+ 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;
}
- retry:
- for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
- {
- 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] == '/' && !DEPRECATED_STREQ (name, vp->name))
- || (memb[0] && !DEPRECATED_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 (fd);
-
- ++got_one;
-
- /* Found a corresponding VMAP. Remap! */
-
- vmap_secs (vp, ldi, arch64);
-
- /* The objfile is only NULL for the exec file. */
- if (vp->objfile == NULL)
- got_exec_file = 1;
-
- /* relocate symbol table(s). */
- vmap_symtab (vp);
-
- /* Announce new object files. Doing this after symbol relocation
- makes aix-thread.c's job easier. */
- if (deprecated_target_new_objfile_hook && vp->objfile)
- deprecated_target_new_objfile_hook (vp->objfile);
-
- /* There may be more, so we don't break out of the loop. */
- }
-
- /* if there was no matching *vp, we must perforce create the sucker(s) */
- if (!got_one && !retried)
- {
- add_vmap (ldi);
- ++retried;
- goto retry;
- }
+ /* Ignore terminated detached child processes. */
+ if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
+ pid = -1;
}
- while ((next = LDI_NEXT (ldi, arch64))
- && (ldi = (void *) (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 (_("Symbol file %s\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)."),
- symfile_objfile->name);
- free_objfile (symfile_objfile);
- symfile_objfile = NULL;
- }
- breakpoint_re_set ();
-}
-\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.
- */
-
-static void
-vmap_exec (void)
-{
- static bfd *execbfd;
- int i;
+ while (pid == -1);
- if (execbfd == exec_bfd)
- return;
+ /* AIX has a couple of strange returns from wait(). */
- execbfd = exec_bfd;
-
- if (!vmap || !exec_ops.to_sections)
- error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
+ /* 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);
- 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))
- {
- 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))
- {
- 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))
- {
- exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
- exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
- }
- }
+ return pid_to_ptid (pid);
}
+\f
/* Set the current architecture from the host running GDB. Called when
- starting a child process. */
+ starting a child process. */
-static void
-set_host_arch (int pid)
+void
+rs6000_nat_target::create_inferior (const char *exec_file,
+ const std::string &allargs,
+ char **env, int from_tty)
{
enum bfd_architecture arch;
unsigned long mach;
bfd abfd;
struct gdbarch_info info;
+ inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty);
+
if (__power_rs ())
{
arch = bfd_arch_rs6000;
if (!gdbarch_update_p (info))
internal_error (__FILE__, __LINE__,
- _("set_host_arch: failed to select architecture"));
+ _("rs6000_create_inferior: failed "
+ "to select architecture"));
}
-
\f
-/* xcoff_relocate_symtab - hook for symbol table relocation.
- also reads shared libraries. */
-void
-xcoff_relocate_symtab (unsigned int pid)
-{
- int load_segs = 64; /* number of load segments */
- int rc;
- LdInfo *ldi = NULL;
- int arch64 = ARCH64 ();
- int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
- int size;
-
- do
- {
- size = load_segs * ldisize;
- ldi = (void *) xrealloc (ldi, size);
+/* Shared Object support. */
-#if 0
- /* 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. */
- usleep (36000);
-#endif
+/* Return the LdInfo data for the given process. Raises an error
+ if the data could not be obtained. */
- if (arch64)
- rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
- else
- rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
-
- if (rc == -1)
- {
- if (errno == ENOMEM)
- load_segs *= 2;
- else
- perror_with_name (_("ptrace ldinfo"));
- }
- else
- {
- vmap_ldinfo (ldi);
- vmap_exec (); /* relocate the exec and core sections as well. */
- }
- } while (rc == -1);
- if (ldi)
- xfree (ldi);
-}
-\f
-/* Core file stuff. */
-
-/* Relocate symtabs and read in shared library info, based on symbols
- from the core file. */
-
-void
-xcoff_relocate_core (struct target_ops *target)
+static gdb::byte_vector
+rs6000_ptrace_ldinfo (ptid_t ptid)
{
- struct bfd_section *ldinfo_sec;
- int offset = 0;
- LdInfo *ldi;
- struct vmap *vp;
- int arch64 = ARCH64 ();
-
- /* Size of a struct ld_info except for the variable-length filename. */
- int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
-
- /* Allocated size of buffer. */
- int buffer_size = nonfilesz;
- char *buffer = xmalloc (buffer_size);
- struct cleanup *old = make_cleanup (free_current_contents, &buffer);
+ const int pid = ptid_get_pid (ptid);
+ gdb::byte_vector ldi (1024);
+ 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, nonfilesz) == 0)
- goto bfd_err;
-
- /* Now the name. */
- i = nonfilesz;
- 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);
-
- ldi = (LdInfo *) buffer;
-
- /* Can't use a file descriptor from the core file; need to open it. */
- if (arch64)
- ldi->l64.ldinfo_fd = -1;
+ if (ARCH64 ())
+ rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi.data (),
+ ldi.size (), NULL);
else
- ldi->l32.ldinfo_fd = -1;
+ rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi.data (),
+ ldi.size (), NULL);
- /* The first ldinfo is for the exec file, allocated elsewhere. */
- if (offset == 0 && vmap != NULL)
- vp = vmap;
- else
- vp = add_vmap (ldi);
+ if (rc != -1)
+ break; /* Success, we got the entire ld_info data. */
- /* Process next shared library upon error. */
- offset += LDI_NEXT (ldi, arch64);
- if (vp == NULL)
- continue;
+ if (errno != ENOMEM)
+ perror_with_name (_("ptrace ldinfo"));
- vmap_secs (vp, ldi, arch64);
+ /* ldi is not big enough. Double it and try again. */
+ ldi.resize (ldi.size () * 2);
+ }
- /* Unless this is the exec file,
- add our sections to the section table for the core target. */
- if (vp != vmap)
- {
- struct section_table *stp;
+ return ldi;
+}
- target_resize_to_sections (target, 2);
- stp = target->to_sections_end - 2;
+/* Implement the to_xfer_partial target_ops method for
+ TARGET_OBJECT_LIBRARIES_AIX objects. */
- 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++;
+enum target_xfer_status
+rs6000_nat_target::xfer_shared_libraries
+ (enum target_object object,
+ const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+{
+ ULONGEST result;
- stp->bfd = vp->bfd;
- stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
- stp->addr = vp->dstart;
- stp->endaddr = vp->dend;
- }
+ /* This function assumes that it is being run with a live process.
+ Core files are handled via gdbarch. */
+ gdb_assert (target_has_execution);
- vmap_symtab (vp);
+ if (writebuf)
+ return TARGET_XFER_E_IO;
- if (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile)
- deprecated_target_new_objfile_hook (vp->objfile);
- }
- while (LDI_NEXT (ldi, arch64) != 0);
- vmap_exec ();
- breakpoint_re_set ();
- do_cleanups (old);
-}
+ gdb::byte_vector ldi_buf = rs6000_ptrace_ldinfo (inferior_ptid);
+ result = rs6000_aix_ld_info_to_xml (target_gdbarch (), ldi_buf.data (),
+ readbuf, offset, len, 1);
-int
-kernel_u_size (void)
-{
- 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 (CORE_ADDR pc)
-{
- struct vmap *vp;
- extern CORE_ADDR get_toc_offset (struct objfile *); /* xcoffread.c */
-
- 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 %s."), hex_string (pc));
}
-\f
-/* Register that we are able to handle rs6000 core file formats. */
-
-static struct core_fns rs6000_core_fns =
-{
- bfd_target_xcoff_flavour, /* core_flavour */
- default_check_format, /* check_format */
- default_core_sniffer, /* core_sniffer */
- fetch_core_registers, /* core_read_registers */
- NULL /* next */
-};
void
-_initialize_core_rs6000 (void)
+_initialize_rs6000_nat (void)
{
- /* Initialize hook in rs6000-tdep.c for determining the TOC address
- when calling functions in the inferior. */
- rs6000_find_toc_address_hook = find_toc_address;
-
- /* Initialize hook in rs6000-tdep.c to set the current architecture
- when starting a child process. */
- rs6000_set_host_arch_hook = set_host_arch;
-
- deprecated_add_core_fns (&rs6000_core_fns);
+ add_target (&the_rs6000_nat_target);
}
projects / thirdparty / binutils-gdb.git / blobdiff