X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Frs6000-nat.c;h=705016cbcdb33d5238f4f1ad63ad5c2023637833;hb=3d68c10f9f11211d0f486e4978a6fd29dfd58c53;hp=dc6676d4141a0d8485bc90b19cd20d39b85c8f25;hpb=4e052eda914ce3a3c48b31a0d13bce89c364495e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c index dc6676d414..705016cbcd 100644 --- a/gdb/rs6000-nat.c +++ b/gdb/rs6000-nat.c @@ -1,7 +1,8 @@ /* 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 (C) 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. @@ -17,8 +18,8 @@ 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. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" #include "inferior.h" @@ -27,10 +28,14 @@ #include "xcoffsolib.h" #include "symfile.h" #include "objfiles.h" -#include "libbfd.h" /* For bfd_cache_lookup (FIXME) */ +#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 "ppc-tdep.h" +#include "exec.h" #include #include @@ -68,7 +73,7 @@ #ifndef ARCH3264 # define ARCH64() 0 #else -# define ARCH64() (REGISTER_RAW_SIZE (0) == 8) +# define ARCH64() (register_size (current_gdbarch, 0) == 8) #endif /* Union of 32-bit and 64-bit ".reg" core file sections. */ @@ -124,8 +129,6 @@ typedef union { 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 *); @@ -140,30 +143,58 @@ static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR); 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_gp0_regnum + ppc_num_gprs) + return regno; + else if (tdep->ppc_fp0_regnum >= 0 + && tdep->ppc_fp0_regnum <= regno + && regno < tdep->ppc_fp0_regnum + ppc_num_fprs) + { + *isfloat = 1; + return regno - tdep->ppc_fp0_regnum + FPR0; + } + else if (regno == 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_fpscr_regnum >= 0 + && regno == tdep->ppc_fpscr_regnum) + return FPSCR; + else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum) + return MQ; + else + 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; @@ -172,7 +203,7 @@ ptrace32 (int req, int id, int *addr, int data, int *buf) /* 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); @@ -180,7 +211,7 @@ ptrace64 (int req, int id, long long addr, int data, int *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; @@ -191,42 +222,40 @@ ptrace64 (int req, int id, long long addr, int data, int *buf) 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 (register_size (current_gdbarch, regno) == 8) memcpy (addr, &buf, 8); else *addr = buf; @@ -234,7 +263,7 @@ fetch_register (int regno) } if (!errno) - register_valid[regno] = 1; + regcache_raw_supply (current_regcache, regno, (char *) addr); else { #if 0 @@ -250,21 +279,23 @@ fetch_register (int regno) 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_raw_collect (current_regcache, 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, @@ -283,23 +314,21 @@ store_register (int regno) (%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 (register_size (current_gdbarch, 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); } } @@ -321,17 +350,32 @@ fetch_inferior_registers (int regno) else { - /* read 32 general purpose registers. */ - for (regno = 0; regno < 32; regno++) - fetch_register (regno); + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - /* read general purpose floating point registers. */ - for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++) - fetch_register (regno); + /* Read 32 general purpose registers. */ + for (regno = tdep->ppc_gp0_regnum; + regno < tdep->ppc_gp0_regnum + ppc_num_gprs; + regno++) + { + fetch_register (regno); + } - /* read special registers. */ - for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++) - fetch_register (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); + + /* 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_fpscr_regnum >= 0) + fetch_register (tdep->ppc_fpscr_regnum); + if (tdep->ppc_mq_regnum >= 0) + fetch_register (tdep->ppc_mq_regnum); } } @@ -347,18 +391,32 @@ store_inferior_registers (int regno) else { - /* write general purpose registers first! */ - for (regno = GPR0; regno <= GPR31; regno++) - store_register (regno); - - /* write floating point registers now. */ - for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++) - store_register (regno); + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - /* write special registers. */ + /* Write general purpose registers first. */ + for (regno = tdep->ppc_gp0_regnum; + regno < tdep->ppc_gp0_regnum + ppc_num_gprs; + regno++) + { + store_register (regno); + } - for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++) - store_register (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); + + /* 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_fpscr_regnum >= 0) + store_register (tdep->ppc_fpscr_regnum); + if (tdep->ppc_mq_regnum >= 0) + store_register (tdep->ppc_mq_regnum); } } @@ -373,9 +431,10 @@ read_word (CORE_ADDR from, int *to, int arch64) 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; } @@ -384,13 +443,13 @@ read_word (CORE_ADDR from, int *to, int arch64) 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. */ + 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. */ int -child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, +child_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write, struct mem_attrib *attrib, struct target_ops *target) { @@ -403,6 +462,9 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, / 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 (); @@ -431,7 +493,8 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, /* 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. */ @@ -441,9 +504,9 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, 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) @@ -464,15 +527,15 @@ exec_one_dummy_insn (void) { #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200 - char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */ 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. */ - target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents); + 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 @@ -482,9 +545,9 @@ exec_one_dummy_insn (void) 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"); @@ -493,10 +556,10 @@ exec_one_dummy_insn (void) { pid = wait (&status); } - while (pid != inferior_pid); + while (pid != PIDGET (inferior_ptid)); write_pc (prev_pc); - target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents); + deprecated_remove_raw_breakpoint (bp); } /* Fetch registers from the register section in core bfd. */ @@ -506,9 +569,8 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, 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) { @@ -518,45 +580,66 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, 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 < 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 { - 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 < 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); } } @@ -594,7 +677,7 @@ vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64) static void vmap_symtab (struct vmap *vp) { - register struct objfile *objfile; + struct objfile *objfile; struct section_offsets *new_offsets; int i; @@ -612,7 +695,9 @@ vmap_symtab (struct vmap *vp) /* 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); @@ -633,7 +718,7 @@ objfile_symbol_add (void *arg) { 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; } @@ -666,7 +751,7 @@ static struct vmap * add_vmap (LdInfo *ldi) { bfd *abfd, *last; - register char *mem, *objname, *filename; + char *mem, *objname, *filename; struct objfile *obj; struct vmap *vp; int fd; @@ -690,7 +775,7 @@ add_vmap (LdInfo *ldi) abfd = bfd_fdopenr (objname, gnutarget, fd); if (!abfd) { - warning ("Could not open `%s' as an executable file: %s", + warning (_("Could not open `%s' as an executable file: %s"), objname, bfd_errmsg (bfd_get_error ())); return NULL; } @@ -705,19 +790,19 @@ add_vmap (LdInfo *ldi) 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) { - warning ("\"%s\": member \"%s\" missing.", objname, mem); + warning (_("\"%s\": member \"%s\" missing."), objname, mem); bfd_close (abfd); return NULL; } if (!bfd_check_format (last, bfd_object)) { - warning ("\"%s\": member \"%s\" not in executable format: %s.", + warning (_("\"%s\": member \"%s\" not in executable format: %s."), objname, mem, bfd_errmsg (bfd_get_error ())); bfd_close (last); bfd_close (abfd); @@ -728,7 +813,7 @@ add_vmap (LdInfo *ldi) } else { - warning ("\"%s\": not in executable format: %s.", + warning (_("\"%s\": not in executable format: %s."), objname, bfd_errmsg (bfd_get_error ())); bfd_close (abfd); return NULL; @@ -749,7 +834,7 @@ static void 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; @@ -772,7 +857,7 @@ vmap_ldinfo (LdInfo *ldi) /* 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", + warning (_("%s (fd=%d) has disappeared, keeping its symbols"), name, fd); continue; } @@ -789,8 +874,8 @@ vmap_ldinfo (LdInfo *ldi) /* 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. @@ -801,7 +886,7 @@ vmap_ldinfo (LdInfo *ldi) || objfile->obfd == NULL || bfd_stat (objfile->obfd, &vi) < 0) { - warning ("Unable to stat %s, keeping its symbols", name); + warning (_("Unable to stat %s, keeping its symbols"), name); continue; } @@ -824,6 +909,11 @@ vmap_ldinfo (LdInfo *ldi) /* 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. */ } @@ -844,14 +934,12 @@ vmap_ldinfo (LdInfo *ldi) 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; } @@ -880,21 +968,21 @@ vmap_exec (void) execbfd = exec_bfd; if (!vmap || !exec_ops.to_sections) - error ("vmap_exec: vmap or exec_ops.to_sections == 0\n"); + error (_("vmap_exec: vmap or exec_ops.to_sections == 0.")); 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; @@ -923,21 +1011,38 @@ set_host_arch (int pid) 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)) - { - internal_error (__FILE__, __LINE__, - "set_host_arch: failed to select architecture"); - } + internal_error (__FILE__, __LINE__, + _("set_host_arch: failed to select architecture")); } /* xcoff_relocate_symtab - hook for symbol table relocation. - also reads shared libraries.. */ + also reads shared libraries. */ void xcoff_relocate_symtab (unsigned int pid) @@ -963,16 +1068,16 @@ xcoff_relocate_symtab (unsigned int pid) #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) { if (errno == ENOMEM) load_segs *= 2; else - perror_with_name ("ptrace ldinfo"); + perror_with_name (_("ptrace ldinfo")); } else { @@ -992,7 +1097,7 @@ xcoff_relocate_symtab (unsigned int pid) 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; @@ -1085,6 +1190,9 @@ xcoff_relocate_core (struct target_ops *target) } 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 (); @@ -1119,7 +1227,7 @@ find_toc_address (CORE_ADDR pc) : vp->objfile); } } - error ("Unable to find TOC entry for pc 0x%x\n", pc); + error (_("Unable to find TOC entry for pc %s."), hex_string (pc)); } /* Register that we are able to handle rs6000 core file formats. */ @@ -1136,13 +1244,13 @@ static struct core_fns rs6000_core_fns = void _initialize_core_rs6000 (void) { - /* Initialize hook in rs6000-tdep.c for determining the TOC address when - calling functions in the inferior. */ + /* 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. */ + /* 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); + deprecated_add_core_fns (&rs6000_core_fns); }