/* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
- Copyright 1986, 1987, 1989, 1991, 1992, 1994 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+ 1998, 1999, 2000, 2001, 2002
+ Free Software Foundation, Inc.
-This file is part of GDB.
+ 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
-(at your option) any later version.
+ 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
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
+ 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. */
#include "defs.h"
#include "inferior.h"
#include "xcoffsolib.h"
#include "symfile.h"
#include "objfiles.h"
-#include "libbfd.h" /* For bfd_cache_lookup (FIXME) */
+#include "libbfd.h" /* For bfd_cache_lookup (FIXME) */
#include "bfd.h"
+#include "gdb-stabs.h"
+#include "regcache.h"
+#include "arch-utils.h"
+#include "language.h" /* for local_hex_string(). */
+#include "ppc-tdep.h"
#include <sys/ptrace.h>
#include <sys/reg.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <fcntl.h>
+#include <errno.h>
#include <a.out.h>
#include <sys/file.h>
-#include <sys/stat.h>
+#include "gdb_stat.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;
+/* 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. */
-extern struct vmap * map_vmap PARAMS ((bfd *bf, bfd *arch));
+/* 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. */
+
+#ifdef __ld_info32
+# define ARCH3264
+#endif
+
+/* Return whether the current architecture is 64-bit. */
+
+#ifndef ARCH3264
+# define ARCH64() 0
+#else
+# define ARCH64() (REGISTER_RAW_SIZE (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);
extern struct target_ops exec_ops;
-static void
-exec_one_dummy_insn PARAMS ((void));
+static void vmap_exec (void);
-extern void
-add_text_to_loadinfo PARAMS ((CORE_ADDR textaddr, CORE_ADDR dataaddr));
+static void vmap_ldinfo (LdInfo *);
-extern void
-fixup_breakpoints PARAMS ((CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta));
-
-/* Conversion from gdb-to-system special purpose register numbers.. */
-
-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 */
-};
+static struct vmap *add_vmap (LdInfo *);
-void
-fetch_inferior_registers (regno)
- int regno;
-{
- int ii;
- extern char registers[];
+static int objfile_symbol_add (void *);
- if (regno < 0) { /* for all registers */
+static void vmap_symtab (struct vmap *);
- /* read 32 general purpose registers. */
+static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
- for (ii=0; ii < 32; ++ii)
- *(int*)®isters[REGISTER_BYTE (ii)] =
- ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii, 0, 0);
+static void exec_one_dummy_insn (void);
- /* read general purpose floating point registers. */
+extern void
+fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
- for (ii=0; ii < 32; ++ii)
- ptrace (PT_READ_FPR, inferior_pid,
- (PTRACE_ARG3_TYPE) ®isters [REGISTER_BYTE (FP0_REGNUM+ii)],
- FPR0+ii, 0);
+/* 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. */
- /* read special registers. */
- for (ii=0; ii <= LAST_SP_REGNUM-FIRST_SP_REGNUM; ++ii)
- *(int*)®isters[REGISTER_BYTE (FIRST_SP_REGNUM+ii)] =
- ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) special_regs[ii],
- 0, 0);
+static int
+regmap (int regno, int *isfloat)
+{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- 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) ®isters [REGISTER_BYTE (regno)],
- (regno-FP0_REGNUM+FPR0), 0);
- }
- else if (regno <= LAST_SP_REGNUM) { /* a special register */
- *(int*)®isters[REGISTER_BYTE (regno)] =
- ptrace (PT_READ_GPR, inferior_pid,
- (PTRACE_ARG3_TYPE) special_regs[regno-FIRST_SP_REGNUM], 0, 0);
- }
+ *isfloat = 0;
+ if (tdep->ppc_gp0_regnum <= regno && regno <= tdep->ppc_gplast_regnum)
+ return regno;
+ else if (FP0_REGNUM <= regno && regno <= FPLAST_REGNUM)
+ {
+ *isfloat = 1;
+ return regno - FP0_REGNUM + FPR0;
+ }
+ else if (regno == PC_REGNUM)
+ 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_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
+ return MQ;
else
- fprintf_unfiltered (gdb_stderr, "gdb error: register no %d not implemented.\n", regno);
+ return -1;
+}
- register_valid [regno] = 1;
+/* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
+
+static int
+rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
+{
+ int ret = ptrace (req, id, (int *)addr, data, buf);
+#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;
}
-/* 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 ptracex(REQ, ID, ADDR, DATA, BUF). */
-void
-store_inferior_registers (regno)
- int regno;
+static int
+rs6000_ptrace64 (int req, int id, long long addr, int data, int *buf)
{
- extern char registers[];
+#ifdef ARCH3264
+ int ret = ptracex (req, id, addr, data, buf);
+#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);
+#endif
+ return ret;
+}
+/* Fetch register REGNO from the inferior. */
+
+static void
+fetch_register (int regno)
+{
+ int *addr = alloca (MAX_REGISTER_RAW_SIZE);
+ int nr, isfloat;
+
+ /* Retrieved values may be -1, so infer errors from errno. */
errno = 0;
- if (regno == -1)
- { /* for all registers.. */
- int ii;
+ nr = regmap (regno, &isfloat);
- /* 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) */
+ /* Floating-point registers. */
+ if (isfloat)
+ rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
- exec_one_dummy_insn ();
+ /* Bogus register number. */
+ else if (nr < 0)
+ {
+ if (regno >= NUM_REGS)
+ fprintf_unfiltered (gdb_stderr,
+ "gdb error: register no %d not implemented.\n",
+ regno);
+ return;
+ }
- /* write general purpose registers first! */
- for ( ii=GPR0; ii<=GPR31; ++ii)
+ /* Fixed-point registers. */
+ else
+ {
+ if (!ARCH64 ())
+ *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
+ else
{
- ptrace (PT_WRITE_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii,
- *(int*)®isters[REGISTER_BYTE (ii)], 0);
- if (errno)
- {
- perror ("ptrace write_gpr");
- errno = 0;
- }
+ /* 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, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
+ if (REGISTER_RAW_SIZE (regno) == 8)
+ memcpy (addr, &buf, 8);
+ else
+ *addr = buf;
}
+ }
- /* write floating point registers now. */
- for ( ii=0; ii < 32; ++ii)
- {
- ptrace (PT_WRITE_FPR, inferior_pid,
- (PTRACE_ARG3_TYPE) ®isters[REGISTER_BYTE (FP0_REGNUM+ii)],
- FPR0+ii, 0);
- if (errno)
- {
- perror ("ptrace write_fpr");
- errno = 0;
- }
- }
+ if (!errno)
+ supply_register (regno, (char *) addr);
+ else
+ {
+#if 0
+ /* 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. */
+
+static void
+store_register (int regno)
+{
+ int *addr = alloca (MAX_REGISTER_RAW_SIZE);
+ int nr, isfloat;
- /* write special registers. */
- for (ii=0; ii <= LAST_SP_REGNUM-FIRST_SP_REGNUM; ++ii)
+ /* Fetch the register's value from the register cache. */
+ regcache_collect (regno, addr);
+
+ /* -1 can be a successful return value, so infer errors from errno. */
+ errno = 0;
+
+ nr = regmap (regno, &isfloat);
+
+ /* Floating-point registers. */
+ if (isfloat)
+ rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
+
+ /* Bogus register number. */
+ else if (nr < 0)
+ {
+ if (regno >= NUM_REGS)
+ fprintf_unfiltered (gdb_stderr,
+ "gdb error: register no %d not implemented.\n",
+ regno);
+ }
+
+ /* 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);
+ else
{
- ptrace (PT_WRITE_GPR, inferior_pid,
- (PTRACE_ARG3_TYPE) special_regs[ii],
- *(int*)®isters[REGISTER_BYTE (FIRST_SP_REGNUM+ii)], 0);
- if (errno)
- {
- perror ("ptrace write_gpr");
- errno = 0;
- }
+ /* 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_RAW_SIZE (regno) == 8)
+ memcpy (&buf, addr, 8);
+ else
+ buf = *addr;
+ rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
}
}
- /* else, a specific register number is given... */
-
- else if (regno < FP0_REGNUM) /* a GPR */
+ if (errno)
{
- ptrace (PT_WRITE_GPR, inferior_pid, (PTRACE_ARG3_TYPE) regno,
- *(int*)®isters[REGISTER_BYTE (regno)], 0);
+ perror ("ptrace write");
+ errno = 0;
}
+}
- else if (regno <= FPLAST_REGNUM) /* a FPR */
+/* Read from the inferior all registers if REGNO == -1 and just register
+ REGNO otherwise. */
+
+void
+fetch_inferior_registers (int regno)
+{
+ if (regno != -1)
+ fetch_register (regno);
+
+ else
{
- ptrace (PT_WRITE_FPR, inferior_pid,
- (PTRACE_ARG3_TYPE) ®isters[REGISTER_BYTE (regno)],
- regno - FP0_REGNUM + FPR0, 0);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+ /* Read 32 general purpose registers. */
+ for (regno = tdep->ppc_gp0_regnum;
+ regno <= tdep->ppc_gplast_regnum;
+ regno++)
+ {
+ fetch_register (regno);
+ }
+
+ /* Read general purpose floating point registers. */
+ for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
+ fetch_register (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);
+ if (tdep->ppc_mq_regnum >= 0)
+ fetch_register (tdep->ppc_mq_regnum);
}
+}
+
+/* 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). */
- else if (regno <= LAST_SP_REGNUM) /* a special register */
+void
+store_inferior_registers (int regno)
+{
+ if (regno != -1)
+ store_register (regno);
+
+ else
{
- ptrace (PT_WRITE_GPR, inferior_pid,
- (PTRACE_ARG3_TYPE) special_regs [regno-FIRST_SP_REGNUM],
- *(int*)®isters[REGISTER_BYTE (regno)], 0);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+ /* Write general purpose registers first. */
+ for (regno = tdep->ppc_gp0_regnum;
+ regno <= tdep->ppc_gplast_regnum;
+ regno++)
+ {
+ store_register (regno);
+ }
+
+ /* Write floating point registers. */
+ for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
+ store_register (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);
+ if (tdep->ppc_mq_regnum >= 0)
+ store_register (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
- fprintf_unfiltered (gdb_stderr, "Gdb error: register no %d not implemented.\n", regno);
+ *to = rs6000_ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
+ 0, NULL);
- if (errno)
+ 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 child_ops
+ doesn't allow memory operations to cross below us in the target stack
+ anyway. */
+
+int
+child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+ int write, struct mem_attrib *attrib,
+ struct target_ops *target)
+{
+ /* 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));
+
+ int arch64 = ARCH64 ();
+ int i;
+
+ if (!write)
{
- perror ("ptrace write");
- errno = 0;
+ /* Retrieve memory a word at a time. */
+ for (i = 0; i < count; i++, addr += sizeof (int))
+ {
+ 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, 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;
+ }
}
+
+ return len;
}
/* Execute one dummy breakpoint instruction. This way we give the kernel
including u_area. */
static void
-exec_one_dummy_insn ()
+exec_one_dummy_insn (void)
{
#define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
- char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
- unsigned int status, pid;
+ char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
+ int ret, 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. */
+ /* 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);
- errno = 0;
- ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) DUMMY_INSN_ADDR, 0, 0);
- if (errno)
+ /* 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");
- do {
- pid = wait (&status);
- } while (pid != inferior_pid);
-
+ do
+ {
+ pid = wait (&status);
+ }
+ while (pid != PIDGET (inferior_ptid));
+
+ write_pc (prev_pc);
target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
}
-void
-fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
- char *core_reg_sect;
- unsigned core_reg_size;
- int which;
- unsigned int reg_addr; /* Unused in this version */
+/* 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)
{
- /* fetch GPRs and special registers from the first register section
- in core bfd. */
- if (which == 0)
- {
- /* copy GPRs first. */
- memcpy (registers, core_reg_sect, 32 * 4);
+ CoreRegs *regs;
+ int regi;
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- /* 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_SP_REGNUM)], core_reg_sect,
- (LAST_SP_REGNUM - FIRST_SP_REGNUM + 1) * 4);
+ if (which != 0)
+ {
+ fprintf_unfiltered
+ (gdb_stderr,
+ "Gdb error: unknown parameter to fetch_core_registers().\n");
+ return;
}
- /* 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);
+ regs = (CoreRegs *) core_reg_sect;
+
+ /* Put the register values from the core file section in the regcache. */
+ if (ARCH64 ())
+ {
+ for (regi = 0; regi < 32; regi++)
+ supply_register (regi, (char *) ®s->r64.gpr[regi]);
+
+ for (regi = 0; regi < 32; regi++)
+ supply_register (FP0_REGNUM + regi, (char *) ®s->r64.fpr[regi]);
+
+ supply_register (PC_REGNUM, (char *) ®s->r64.iar);
+ supply_register (tdep->ppc_ps_regnum, (char *) ®s->r64.msr);
+ supply_register (tdep->ppc_cr_regnum, (char *) ®s->r64.cr);
+ supply_register (tdep->ppc_lr_regnum, (char *) ®s->r64.lr);
+ supply_register (tdep->ppc_ctr_regnum, (char *) ®s->r64.ctr);
+ supply_register (tdep->ppc_xer_regnum, (char *) ®s->r64.xer);
+ }
else
- fprintf_unfiltered (gdb_stderr, "Gdb error: unknown parameter to fetch_core_registers().\n");
+ {
+ for (regi = 0; regi < 32; regi++)
+ supply_register (regi, (char *) ®s->r32.gpr[regi]);
+
+ for (regi = 0; regi < 32; regi++)
+ supply_register (FP0_REGNUM + regi, (char *) ®s->r32.fpr[regi]);
+
+ supply_register (PC_REGNUM, (char *) ®s->r32.iar);
+ supply_register (tdep->ppc_ps_regnum, (char *) ®s->r32.msr);
+ supply_register (tdep->ppc_cr_regnum, (char *) ®s->r32.cr);
+ supply_register (tdep->ppc_lr_regnum, (char *) ®s->r32.lr);
+ supply_register (tdep->ppc_ctr_regnum, (char *) ®s->r32.ctr);
+ supply_register (tdep->ppc_xer_regnum, (char *) ®s->r32.xer);
+ if (tdep->ppc_mq_regnum >= 0)
+ supply_register (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 (vp)
- register struct vmap *vp;
+vmap_symtab (struct vmap *vp)
{
register struct objfile *objfile;
- asection *textsec;
- asection *datasec;
- asection *bsssec;
- CORE_ADDR text_delta;
- CORE_ADDR data_delta;
- CORE_ADDR bss_delta;
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. */
+ 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 = alloca
- (sizeof (struct section_offsets)
- + sizeof (new_offsets->offsets) * objfile->num_sections);
+ new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
for (i = 0; i < objfile->num_sections; ++i)
- ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i);
-
- textsec = bfd_get_section_by_name (vp->bfd, ".text");
- text_delta =
- vp->tstart - ANOFFSET (objfile->section_offsets, textsec->target_index);
- ANOFFSET (new_offsets, textsec->target_index) = vp->tstart;
-
- datasec = bfd_get_section_by_name (vp->bfd, ".data");
- data_delta =
- vp->dstart - ANOFFSET (objfile->section_offsets, datasec->target_index);
- ANOFFSET (new_offsets, datasec->target_index) = vp->dstart;
-
- bsssec = bfd_get_section_by_name (vp->bfd, ".bss");
- bss_delta =
- vp->dstart - ANOFFSET (objfile->section_offsets, bsssec->target_index);
- ANOFFSET (new_offsets, bsssec->target_index) = vp->dstart;
+ new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
- objfile_relocate (objfile, new_offsets);
+ /* 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;
- {
- struct obj_section *s;
- for (s = objfile->sections; s < objfile->sections_end; ++s)
- {
- if (s->the_bfd_section->target_index == textsec->target_index)
- {
- s->addr += text_delta;
- s->endaddr += text_delta;
- }
- else if (s->the_bfd_section->target_index == datasec->target_index)
- {
- s->addr += data_delta;
- s->endaddr += data_delta;
- }
- else if (s->the_bfd_section->target_index == bsssec->target_index)
- {
- s->addr += bss_delta;
- s->endaddr += bss_delta;
- }
- }
- }
-
- if (text_delta != 0)
- /* breakpoints need to be relocated as well. */
- fixup_breakpoints (0, TEXT_SEGMENT_BASE, text_delta);
+ objfile_relocate (objfile, new_offsets);
}
\f
/* Add symbols for an objfile. */
static int
-objfile_symbol_add (arg)
- char *arg;
+objfile_symbol_add (void *arg)
{
struct objfile *obj = (struct objfile *) arg;
- syms_from_objfile (obj, 0, 0, 0);
+ syms_from_objfile (obj, NULL, 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
Return the vmap new entry. */
static struct vmap *
-add_vmap (ldi)
- register struct ld_info *ldi;
+add_vmap (LdInfo *ldi)
{
bfd *abfd, *last;
- register char *mem, *objname;
+ register 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. */
- mem = ldi->ldinfo_filename + strlen (ldi->ldinfo_filename) + 1;
+ filename = LDI_FILENAME (ldi, arch64);
+ mem = filename + strlen (filename) + 1;
mem = savestring (mem, strlen (mem));
- objname = savestring (ldi->ldinfo_filename, strlen (ldi->ldinfo_filename));
+ objname = savestring (filename, strlen (filename));
- if (ldi->ldinfo_fd < 0)
+ 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, ldi->ldinfo_fd);
+ abfd = bfd_fdopenr (objname, gnutarget, fd);
if (!abfd)
- error ("Could not open `%s' as an executable file: %s",
- objname, bfd_errmsg (bfd_get_error ()));
+ {
+ 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 (!last)
{
+ warning ("\"%s\": member \"%s\" missing.", objname, mem);
bfd_close (abfd);
- /* FIXME -- should be error */
- warning ("\"%s\": member \"%s\" missing.", abfd->filename, mem);
- return;
+ return NULL;
}
- if (!bfd_check_format(last, bfd_object))
+ if (!bfd_check_format (last, bfd_object))
{
- bfd_close (last); /* XXX??? */
- goto obj_err;
+ warning ("\"%s\": member \"%s\" not in executable format: %s.",
+ objname, mem, bfd_errmsg (bfd_get_error ()));
+ bfd_close (last);
+ bfd_close (abfd);
+ return NULL;
}
vp = map_vmap (last, abfd);
}
else
{
- obj_err:
+ warning ("\"%s\": not in executable format: %s.",
+ objname, bfd_errmsg (bfd_get_error ()));
bfd_close (abfd);
- error ("\"%s\": not in executable format: %s.",
- objname, bfd_errmsg (bfd_get_error ()));
- /*NOTREACHED*/
+ return NULL;
}
obj = allocate_objfile (vp->bfd, 0);
vp->objfile = obj;
-#ifndef SOLIB_SYMBOLS_MANUAL
- if (catch_errors (objfile_symbol_add, (char *)obj,
- "Error while reading shared library symbols:\n",
- RETURN_MASK_ALL))
- {
- /* Note this is only done if symbol reading was successful. */
- vmap_symtab (vp);
- vp->loaded = 1;
- }
-#endif
+ /* Always add symbols for the main objfile. */
+ if (vp == vmap || auto_solib_add)
+ vmap_add_symbols (vp);
return vp;
}
\f
Input is ptr to ldinfo() results. */
static void
-vmap_ldinfo (ldi)
- register struct ld_info *ldi;
+vmap_ldinfo (LdInfo *ldi)
{
struct stat ii, vi;
register struct vmap *vp;
- register got_one, retried;
- CORE_ADDR ostart;
+ 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->ldinfo_filename;
- char *memb = name + strlen(name) + 1;
-
- retried = 0;
-
- if (fstat (ldi->ldinfo_fd, &ii) < 0)
- fatal ("cannot fstat(fd=%d) on %s", ldi->ldinfo_fd, name);
- retry:
- for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
- {
- FILE *io;
-
- /* 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, fins 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;
+ do
+ {
+ char *name = LDI_FILENAME (ldi, arch64);
+ char *memb = name + strlen (name) + 1;
+ int fd = LDI_FD (ldi, arch64);
- io = bfd_cache_lookup (vp->bfd); /* totally opaque! */
- if (!io)
- fatal ("cannot find BFD's iostream for %s", vp->name);
+ retried = 0;
- /* See if we are referring to the same file. */
- /* An error here is innocuous, most likely meaning that
- the file descriptor has become worthless. */
- if (fstat (fileno(io), &vi) < 0)
+ if (fstat (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, fd);
continue;
+ }
+ 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] == '/' && !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 (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
+ continue;
- if (!retried)
- close (ldi->ldinfo_fd);
+ if (!retried)
+ close (fd);
- ++got_one;
+ ++got_one;
- /* found a corresponding VMAP. remap! */
- ostart = vp->tstart;
+ /* 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;
+ vmap_secs (vp, ldi, arch64);
- if (vp->tadj)
- {
- vp->tstart += vp->tadj;
- vp->tend += vp->tadj;
- }
+ /* The objfile is only NULL for the exec file. */
+ if (vp->objfile == NULL)
+ got_exec_file = 1;
- /* relocate symbol table(s). */
- vmap_symtab (vp);
+ /* relocate symbol table(s). */
+ vmap_symtab (vp);
- /* there may be more, so we don't break out of the loop. */
- }
+ /* Announce new object files. Doing this after symbol relocation
+ makes aix-thread.c's job easier. */
+ if (target_new_objfile_hook && vp->objfile)
+ target_new_objfile_hook (vp->objfile);
- /* if there was no matching *vp, we must perforce create the sucker(s) */
- if (!got_one && !retried)
- {
- add_vmap (ldi);
- ++retried;
- goto retry;
- }
- } while (ldi->ldinfo_next
- && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
+ /* 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;
+ }
+ }
+ 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
`exec_sections' need to be relocated only once, as long as the exec
file remains unchanged.
-*/
+ */
static void
-vmap_exec ()
+vmap_exec (void)
{
static bfd *execbfd;
int i;
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++)
+ for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
{
- if (STREQ(".text", exec_ops.to_sections[i].the_bfd_section->name))
+ 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->tstart;
- exec_ops.to_sections[i].endaddr += vmap->tstart;
+ exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
+ exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
}
- else if (STREQ(".data", exec_ops.to_sections[i].the_bfd_section->name))
+ else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
{
- exec_ops.to_sections[i].addr += vmap->dstart;
- exec_ops.to_sections[i].endaddr += vmap->dstart;
+ exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
+ exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
}
}
}
-\f
-/* xcoff_relocate_symtab - hook for symbol table relocation.
- also reads shared libraries.. */
-void
-xcoff_relocate_symtab (pid)
- unsigned int pid;
+/* Set the current architecture from the host running GDB. Called when
+ starting a child process. */
+
+static void
+set_host_arch (int pid)
{
-#define MAX_LOAD_SEGS 64 /* maximum number of load segments */
+ enum bfd_architecture arch;
+ unsigned long mach;
+ bfd abfd;
+ struct gdbarch_info info;
- struct ld_info *ldi;
+ if (__power_rs ())
+ {
+ arch = bfd_arch_rs6000;
+ mach = bfd_mach_rs6k;
+ }
+ else
+ {
+ arch = bfd_arch_powerpc;
+ mach = bfd_mach_ppc;
+ }
- 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), ldi);
- if (errno)
- perror_with_name ("ptrace ldinfo");
+ gdbarch_info_init (&info);
+ info.bfd_arch_info = bfd_get_arch_info (&abfd);
+
+ if (!gdbarch_update_p (info))
+ {
+ internal_error (__FILE__, __LINE__,
+ "set_host_arch: failed to select architecture");
+ }
+}
- vmap_ldinfo (ldi);
+\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 {
- /* We are allowed to assume CORE_ADDR == pointer. This code is
- native only. */
- add_text_to_loadinfo ((CORE_ADDR) ldi->ldinfo_textorg,
- (CORE_ADDR) ldi->ldinfo_dataorg);
- } while (ldi->ldinfo_next
- && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
+ do
+ {
+ size = load_segs * ldisize;
+ ldi = (void *) xrealloc (ldi, size);
#if 0
- /* Now that we've jumbled things around, re-sort them. */
- sort_minimal_symbols ();
+ /* 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
- /* relocate the exec and core sections as well. */
- vmap_exec ();
+ 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. */
from the core file. */
void
-xcoff_relocate_core ()
+xcoff_relocate_core (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))
-
sec_ptr ldinfo_sec;
int offset = 0;
- struct ld_info *ldip;
+ 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 = LDINFO_SIZE;
+ int buffer_size = nonfilesz;
char *buffer = xmalloc (buffer_size);
struct cleanup *old = make_cleanup (free_current_contents, &buffer);
-
- /* 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)");
-
+
ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
if (ldinfo_sec == NULL)
{
/* Read in everything but the name. */
if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
- offset, LDINFO_SIZE) == 0)
+ offset, nonfilesz) == 0)
goto bfd_err;
/* Now the name. */
- i = LDINFO_SIZE;
+ i = nonfilesz;
do
{
if (i == buffer_size)
goto bfd_err;
if (buffer[i++] == '\0')
++names_found;
- } while (names_found < 2);
+ }
+ while (names_found < 2);
- ldip = (struct ld_info *) buffer;
+ ldi = (LdInfo *) buffer;
/* Can't use a file descriptor from the core file; need to open it. */
- ldip->ldinfo_fd = -1;
-
+ if (arch64)
+ ldi->l64.ldinfo_fd = -1;
+ else
+ ldi->l32.ldinfo_fd = -1;
+
/* The first ldinfo is for the exec file, allocated elsewhere. */
- if (offset == 0)
+ if (offset == 0 && vmap != NULL)
vp = vmap;
else
- vp = add_vmap (ldip);
-
- offset += ldip->ldinfo_next;
+ vp = add_vmap (ldi);
- /* 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;
+ /* Process next shared library upon error. */
+ offset += LDI_NEXT (ldi, arch64);
+ if (vp == NULL)
+ continue;
- if (vp->tadj != 0)
- {
- vp->tstart += vp->tadj;
- vp->tend += vp->tadj;
- }
+ vmap_secs (vp, ldi, arch64);
/* Unless this is the exec file,
- add our sections to the section table for the core target. */
+ add our sections to the section table for the core target. */
if (vp != vmap)
{
- int count;
struct section_table *stp;
-
- count = core_ops.to_sections_end - core_ops.to_sections;
- count += 2;
- core_ops.to_sections = (struct section_table *)
- xrealloc (core_ops.to_sections,
- sizeof (struct section_table) * count);
- core_ops.to_sections_end = core_ops.to_sections + count;
- stp = core_ops.to_sections_end - 2;
-
- /* "Why do we add bfd_section_vma?", I hear you cry.
- Well, the start of the section in the file is actually
- that far into the section as the struct vmap understands it.
- So for text sections, bfd_section_vma tends to be 0x200,
- and if vp->tstart is 0xd0002000, then the first byte of
- the text section on disk corresponds to address 0xd0002200. */
+
+ target_resize_to_sections (target, 2);
+ stp = target->to_sections_end - 2;
+
stp->bfd = vp->bfd;
stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
- stp->addr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->tstart;
- stp->endaddr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->tend;
+ 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 = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->dstart;
- stp->endaddr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->dend;
+ stp->addr = vp->dstart;
+ stp->endaddr = vp->dend;
}
vmap_symtab (vp);
- add_text_to_loadinfo ((CORE_ADDR)ldip->ldinfo_textorg,
- (CORE_ADDR)ldip->ldinfo_dataorg);
- } while (ldip->ldinfo_next != 0);
+ if (target_new_objfile_hook && vp != vmap && vp->objfile)
+ target_new_objfile_hook (vp->objfile);
+ }
+ while (LDI_NEXT (ldi, arch64) != 0);
vmap_exec ();
+ breakpoint_re_set ();
do_cleanups (old);
}
+
+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 (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);
+ }
+ }
+ error ("Unable to find TOC entry for pc %s\n", local_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 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;
+
+ add_core_fns (&rs6000_core_fns);
+}
projects / deliverable / binutils-gdb.git / blobdiff