/* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
- Copyright 1986, 1987, 1989, 1991, 1992, 1994, 1995, 1996, 1997,
- 1998, 2001
- Free Software Foundation, Inc.
+
+ Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+ Foundation, Inc.
This file is part of GDB.
#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 "exec.h"
#include <sys/ptrace.h>
#include <sys/reg.h>
#ifndef ARCH3264
# define ARCH64() 0
#else
-# define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
+# define ARCH64() (DEPRECATED_REGISTER_RAW_SIZE (0) == 8)
#endif
/* Union of 32-bit and 64-bit ".reg" core file sections. */
extern struct vmap *map_vmap (bfd * bf, bfd * arch);
-extern struct target_ops exec_ops;
-
static void vmap_exec (void);
static void vmap_ldinfo (LdInfo *);
static void exec_one_dummy_insn (void);
-extern void
-fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
+extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
-/* Conversion from gdb-to-system special purpose register numbers. */
+/* 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. */
-static int special_regs[] =
+static int
+regmap (int regno, int *isfloat)
{
- IAR, /* PC_REGNUM */
- MSR, /* PS_REGNUM */
- CR, /* CR_REGNUM */
- LR, /* LR_REGNUM */
- CTR, /* CTR_REGNUM */
- XER, /* XER_REGNUM */
- MQ /* MQ_REGNUM */
-};
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+ *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 (regno == tdep->ppc_fpscr_regnum)
+ return FPSCR;
+ else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
+ return MQ;
+ else
+ return -1;
+}
/* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
static int
-ptrace32 (int req, int id, int *addr, int data, int *buf)
+rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
{
int ret = ptrace (req, id, (int *)addr, data, buf);
#if 0
- printf ("ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
+ 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;
/* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
static int
-ptrace64 (int req, int id, long long addr, int data, int *buf)
+rs6000_ptrace64 (int req, int id, long long addr, int data, int *buf)
{
#ifdef ARCH3264
int ret = ptracex (req, id, addr, data, buf);
int ret = 0;
#endif
#if 0
- printf ("ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
+ printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
req, id, addr, data, (unsigned int)buf, ret);
#endif
return ret;
static void
fetch_register (int regno)
{
- int *addr = (int *) ®isters[REGISTER_BYTE (regno)];
- int nr;
+ int addr[MAX_REGISTER_SIZE];
+ int nr, isfloat;
/* Retrieved values may be -1, so infer errors from errno. */
errno = 0;
+ nr = regmap (regno, &isfloat);
+
/* Floating-point registers. */
- if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
- {
- nr = regno - FP0_REGNUM + FPR0;
- ptrace32 (PT_READ_FPR, inferior_pid, addr, nr, 0);
- }
+ if (isfloat)
+ rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
/* Bogus register number. */
- else if (regno > LAST_UISA_SP_REGNUM)
- fprintf_unfiltered (gdb_stderr,
- "gdb error: register no %d not implemented.\n",
- regno);
+ else if (nr < 0)
+ {
+ if (regno >= NUM_REGS)
+ fprintf_unfiltered (gdb_stderr,
+ "gdb error: register no %d not implemented.\n",
+ regno);
+ return;
+ }
/* Fixed-point registers. */
else
{
- if (regno >= FIRST_UISA_SP_REGNUM)
- nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
- else
- nr = regno;
-
if (!ARCH64 ())
- *addr = ptrace32 (PT_READ_GPR, inferior_pid, (int *)nr, 0, 0);
+ *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (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;
- ptrace64 (PT_READ_GPR, inferior_pid, nr, 0, (int *)&buf);
- if (REGISTER_RAW_SIZE (regno) == 8)
+ rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
+ if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 8)
memcpy (addr, &buf, 8);
else
*addr = buf;
}
if (!errno)
- register_valid[regno] = 1;
+ supply_register (regno, (char *) addr);
else
{
#if 0
static void
store_register (int regno)
{
- int *addr = (int *) ®isters[REGISTER_BYTE (regno)];
- int nr;
+ int addr[MAX_REGISTER_SIZE];
+ int nr, isfloat;
+
+ /* 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 (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
- {
- nr = regno - FP0_REGNUM + FPR0;
- ptrace32 (PT_WRITE_FPR, inferior_pid, addr, nr, 0);
- }
+ if (isfloat)
+ rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
/* Bogus register number. */
- else if (regno > LAST_UISA_SP_REGNUM)
+ else if (nr < 0)
{
if (regno >= NUM_REGS)
fprintf_unfiltered (gdb_stderr,
(%sp). */
exec_one_dummy_insn ();
- if (regno >= FIRST_UISA_SP_REGNUM)
- nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
- else
- nr = regno;
-
+ /* 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 ())
- ptrace32 (PT_WRITE_GPR, inferior_pid, (int *)nr, *addr, 0);
+ rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (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_RAW_SIZE (regno) == 8)
+ if (DEPRECATED_REGISTER_RAW_SIZE (regno) == 8)
memcpy (&buf, addr, 8);
else
buf = *addr;
- ptrace64 (PT_WRITE_GPR, inferior_pid, nr, 0, (int *)&buf);
+ rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
}
}
else
{
- /* read 32 general purpose registers. */
- for (regno = 0; regno < 32; regno++)
- fetch_register (regno);
+ 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. */
+ /* Read general purpose floating point registers. */
for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
fetch_register (regno);
- /* read special registers. */
- for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_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);
+ fetch_register (tdep->ppc_fpscr_regnum);
+ if (tdep->ppc_mq_regnum >= 0)
+ fetch_register (tdep->ppc_mq_regnum);
}
}
else
{
- /* write general purpose registers first! */
- for (regno = GPR0; regno <= GPR31; regno++)
- store_register (regno);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- /* write floating point registers now. */
+ /* 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. */
-
- for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_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);
+ store_register (tdep->ppc_fpscr_regnum);
+ if (tdep->ppc_mq_regnum >= 0)
+ store_register (tdep->ppc_mq_regnum);
}
}
errno = 0;
if (arch64)
- *to = ptrace64 (PT_READ_I, inferior_pid, from, 0, NULL);
+ *to = rs6000_ptrace64 (PT_READ_I, PIDGET (inferior_ptid), from, 0, NULL);
else
- *to = ptrace32 (PT_READ_I, inferior_pid, (int *)(long) from, 0, NULL);
+ *to = rs6000_ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
+ 0, NULL);
return !errno;
}
int
child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
- int write, struct target_ops *target)
+ int write, struct mem_attrib *attrib,
+ struct target_ops *target)
{
/* Round starting address down to 32-bit word boundary. */
int mask = sizeof (int) - 1;
/ 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 ();
/* Fetch trailing memory needed for alignment. */
if (addr + count * sizeof (int) > memaddr + len)
- if (!read_word (addr, buf + count - 1, arch64))
+ if (!read_word (addr + (count - 1) * sizeof (int),
+ buf + count - 1, arch64))
return 0;
/* Copy supplied data into memory buffer. */
for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
{
if (arch64)
- ptrace64 (PT_WRITE_D, inferior_pid, addr, buf[i], NULL);
+ rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);
else
- ptrace32 (PT_WRITE_D, inferior_pid, (int *)(long) addr,
+ rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,
buf[i], NULL);
if (errno)
prev_pc = read_pc ();
write_pc (DUMMY_INSN_ADDR);
if (ARCH64 ())
- ret = ptrace64 (PT_CONTINUE, inferior_pid, 1, 0, NULL);
+ ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
else
- ret = ptrace32 (PT_CONTINUE, inferior_pid, (int *)1, 0, NULL);
+ ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
if (ret != 0)
perror ("pt_continue");
{
pid = wait (&status);
}
- while (pid != inferior_pid);
+ while (pid != PIDGET (inferior_ptid));
write_pc (prev_pc);
target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
int which, CORE_ADDR reg_addr)
{
CoreRegs *regs;
- double *fprs;
- int arch64, i, size;
- void *gprs, *sprs[7];
+ int regi;
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (which != 0)
{
return;
}
- arch64 = ARCH64 ();
regs = (CoreRegs *) core_reg_sect;
- /* Retrieve register pointers. */
+ /* Put the register values from the core file section in the regcache. */
- if (arch64)
+ if (ARCH64 ())
{
- gprs = regs->r64.gpr;
- fprs = regs->r64.fpr;
- sprs[0] = ®s->r64.iar;
- sprs[1] = ®s->r64.msr;
- sprs[2] = ®s->r64.cr;
- sprs[3] = ®s->r64.lr;
- sprs[4] = ®s->r64.ctr;
- sprs[5] = ®s->r64.xer;
+ 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);
+ supply_register (tdep->ppc_fpscr_regnum, (char *) ®s->r64.fpscr);
}
else
{
- gprs = regs->r32.gpr;
- fprs = regs->r32.fpr;
- sprs[0] = ®s->r32.iar;
- sprs[1] = ®s->r32.msr;
- sprs[2] = ®s->r32.cr;
- sprs[3] = ®s->r32.lr;
- sprs[4] = ®s->r32.ctr;
- sprs[5] = ®s->r32.xer;
- sprs[6] = ®s->r32.mq;
- }
-
- /* Copy from pointers to registers[]. */
-
- memcpy (registers, gprs, 32 * (arch64 ? 8 : 4));
- memcpy (registers + REGISTER_BYTE (FP0_REGNUM), fprs, 32 * 8);
- for (i = FIRST_UISA_SP_REGNUM; i <= LAST_UISA_SP_REGNUM; i++)
- {
- size = REGISTER_RAW_SIZE (i);
- if (size)
- memcpy (registers + REGISTER_BYTE (i),
- sprs[i - FIRST_UISA_SP_REGNUM], size);
+ 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);
+ supply_register (tdep->ppc_fpscr_regnum, (char *) ®s->r32.fpscr);
+ if (tdep->ppc_mq_regnum >= 0)
+ supply_register (tdep->ppc_mq_regnum, (char *) ®s->r32.mq);
}
}
\f
static void
vmap_symtab (struct vmap *vp)
{
- register struct objfile *objfile;
+ struct objfile *objfile;
struct section_offsets *new_offsets;
int i;
/* If symbols are not yet loaded, offsets are not yet valid. */
return;
- new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
+ 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);
{
struct objfile *obj = (struct objfile *) arg;
- syms_from_objfile (obj, NULL, 0, 0);
+ syms_from_objfile (obj, NULL, 0, 0, 0, 0);
new_symfile_objfile (obj, 0, 0);
return 1;
}
add_vmap (LdInfo *ldi)
{
bfd *abfd, *last;
- register char *mem, *objname, *filename;
+ char *mem, *objname, *filename;
struct objfile *obj;
struct vmap *vp;
int fd;
last = 0;
/* FIXME??? am I tossing BFDs? bfd? */
while ((last = bfd_openr_next_archived_file (abfd, last)))
- if (STREQ (mem, last->filename))
+ if (DEPRECATED_STREQ (mem, last->filename))
break;
if (!last)
vmap_ldinfo (LdInfo *ldi)
{
struct stat ii, vi;
- register struct vmap *vp;
+ struct vmap *vp;
int got_one, retried;
int got_exec_file = 0;
uint next;
/* The filenames are not always sufficient to match on. */
- if ((name[0] == '/' && !STREQ (name, vp->name))
- || (memb[0] && !STREQ (memb, vp->member)))
+ 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.
/* 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. */
}
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\
+ 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).\n", gdb_stderr);
+symbols to the proper address).",
+ symfile_objfile->name);
free_objfile (symfile_objfile);
symfile_objfile = NULL;
}
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 (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 (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
+ 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 (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
+ 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;
arch = bfd_arch_powerpc;
mach = bfd_mach_ppc;
}
+
+ /* 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;
+
+ exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
+ if (arch == exec_bfd_arch_info->arch)
+ return;
+ }
+
bfd_default_set_arch_mach (&abfd, arch, mach);
- memset (&info, 0, sizeof info);
+ gdbarch_info_init (&info);
info.bfd_arch_info = bfd_get_arch_info (&abfd);
+ info.abfd = exec_bfd;
if (!gdbarch_update_p (info))
{
#endif
if (arch64)
- rc = ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
+ rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
else
- rc = ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
+ rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
if (rc == -1)
{
void
xcoff_relocate_core (struct target_ops *target)
{
- sec_ptr ldinfo_sec;
+ struct bfd_section *ldinfo_sec;
int offset = 0;
LdInfo *ldi;
struct vmap *vp;
}
vmap_symtab (vp);
+
+ 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 ();
: vp->objfile);
}
}
- error ("Unable to find TOC entry for pc 0x%x\n", pc);
+ 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. */
starting a child process. */
rs6000_set_host_arch_hook = set_host_arch;
- add_core_fns (&rs6000_core_fns);
+ deprecated_add_core_fns (&rs6000_core_fns);
}
projects / deliverable / binutils-gdb.git / blobdiff