X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Frs6000-nat.c;h=705016cbcdb33d5238f4f1ad63ad5c2023637833;hb=3d68c10f9f11211d0f486e4978a6fd29dfd58c53;hp=b9ad387b05d44658fdea895b933108a07d157db4;hpb=a466b86aac9e055dbaf4b1e5087deb52265ff8d5;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c index b9ad387b05..705016cbcd 100644 --- a/gdb/rs6000-nat.c +++ b/gdb/rs6000-nat.c @@ -1,22 +1,25 @@ /* IBM RS/6000 native-dependent code for GDB, the GNU debugger. - Copyright 1986, 1987, 1989, 1991, 1992, 1994, 1995, 1996 - Free Software Foundation, Inc. -This file is part of GDB. + Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, + 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software + Foundation, Inc. -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 file is part of GDB. -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 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. -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. */ + 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., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" #include "inferior.h" @@ -25,9 +28,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #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 @@ -38,186 +46,476 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include +#include #include #include #include "gdb_stat.h" #include +#define __LDINFO_PTRACE32__ /* for __ld_info32 */ +#define __LDINFO_PTRACE64__ /* for __ld_info64 */ #include +#include -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. */ -extern struct target_ops exec_ops; +#ifdef __ld_info32 +# define ARCH3264 +#endif -static void -exec_one_dummy_insn PARAMS ((void)); +/* Return whether the current architecture is 64-bit. */ -extern void -add_text_to_loadinfo PARAMS ((CORE_ADDR textaddr, CORE_ADDR dataaddr)); +#ifndef ARCH3264 +# define ARCH64() 0 +#else +# define ARCH64() (register_size (current_gdbarch, 0) == 8) +#endif -extern void -fixup_breakpoints PARAMS ((CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta)); +/* Union of 32-bit and 64-bit ".reg" core file sections. */ -/* Conversion from gdb-to-system special purpose register numbers.. */ +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; -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 */ -}; +/* 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. */ -void -fetch_inferior_registers (regno) - int regno; -{ - int ii; - extern char registers[]; +#ifndef ARCH3264 +# define ARCH64_DECL(var) +#else +# define ARCH64_DECL(var) int var = ARCH64 () +#endif - if (regno < 0) { /* for all registers */ +/* 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. */ - /* read 32 general purpose registers. */ +#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 - for (ii=0; ii < 32; ++ii) - *(int*)®isters[REGISTER_BYTE (ii)] = - ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii, 0, 0); +/* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit + process otherwise. */ - /* read general purpose floating point registers. */ +#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) - for (ii=0; ii < 32; ++ii) - ptrace (PT_READ_FPR, inferior_pid, - (PTRACE_ARG3_TYPE) ®isters [REGISTER_BYTE (FP0_REGNUM+ii)], - FPR0+ii, 0); +extern struct vmap *map_vmap (bfd * bf, bfd * arch); - /* 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 void vmap_exec (void); - 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); - } +static void vmap_ldinfo (LdInfo *); + +static struct vmap *add_vmap (LdInfo *); + +static int objfile_symbol_add (void *); + +static void vmap_symtab (struct vmap *); + +static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR); + +static void exec_one_dummy_insn (void); + +extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta); + +/* 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 +regmap (int regno, int *isfloat) +{ + 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 - 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[MAX_REGISTER_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_size (current_gdbarch, 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) + regcache_raw_supply (current_regcache, 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[MAX_REGISTER_SIZE]; + int nr, isfloat; + + /* Fetch the register's value from the register cache. */ + regcache_raw_collect (current_regcache, regno, addr); - /* write special registers. */ - for (ii=0; ii <= LAST_SP_REGNUM-FIRST_SP_REGNUM; ++ii) + /* -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_size (current_gdbarch, 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; } +} + +/* 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 if (regno <= FPLAST_REGNUM) /* a FPR */ + 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_gp0_regnum + ppc_num_gprs; + 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); } +} + +/* 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). */ + +void +store_inferior_registers (int regno) +{ + if (regno != -1) + store_register (regno); - else if (regno <= LAST_SP_REGNUM) /* a special register */ + 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_gp0_regnum + ppc_num_gprs; + 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); } +} +/* 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 + deprecated_child_ops doesn't allow memory operations to cross below + us in the target stack anyway. */ + +int +child_xfer_memory (CORE_ADDR memaddr, gdb_byte *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 + (count - 1) * sizeof (int), + buf + count - 1, arch64)) + return 0; + + /* Copy supplied data into memory buffer. */ + memcpy ((char *)buf + (memaddr - addr), myaddr, len); + + /* Store memory one word at a time. */ + for (i = 0, errno = 0; i < count; i++, addr += sizeof (int)) + { + if (arch64) + rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL); + else + rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr, + buf[i], NULL); + + if (errno) + return 0; + QUIT; + } } + + return len; } /* Execute one dummy breakpoint instruction. This way we give the kernel @@ -225,20 +523,19 @@ store_inferior_registers (regno) 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; + 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. */ + /* 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; + 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 @@ -247,92 +544,169 @@ exec_one_dummy_insn () powerpc-ibm-aix4.1.3 works correctly). */ prev_pc = read_pc (); write_pc (DUMMY_INSN_ADDR); - ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE)1, 0, 0); + 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 (errno) + 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); + deprecated_remove_raw_breakpoint (bp); } +/* Fetch registers from the register section in core bfd. */ + static 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_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); - - /* 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); + CoreRegs *regs; + int regi; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + + if (which != 0) + { + fprintf_unfiltered + (gdb_stderr, + "Gdb error: unknown parameter to fetch_core_registers().\n"); + return; } - /* 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 < 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 - fprintf_unfiltered (gdb_stderr, "Gdb error: unknown parameter to fetch_core_registers().\n"); + { + 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); + } } + +/* 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; - CORE_ADDR text_delta; - CORE_ADDR data_delta; - CORE_ADDR bss_delta; + struct objfile *objfile; struct section_offsets *new_offsets; int i; - + objfile = vp->objfile; if (objfile == NULL) { /* OK, it's not an objfile we opened ourselves. - Currently, that can only happen with the exec file, so - relocate the symbols for the symfile. */ + 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_N_SECTION_OFFSETS (objfile->num_sections)); for (i = 0; i < objfile->num_sections; ++i) - ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i); - - text_delta = - vp->tstart - ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT); - ANOFFSET (new_offsets, SECT_OFF_TEXT) = vp->tstart; - - data_delta = - vp->dstart - ANOFFSET (objfile->section_offsets, SECT_OFF_DATA); - ANOFFSET (new_offsets, SECT_OFF_DATA) = vp->dstart; - - bss_delta = - vp->dstart - ANOFFSET (objfile->section_offsets, SECT_OFF_BSS); - ANOFFSET (new_offsets, SECT_OFF_BSS) = vp->dstart; + new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i); + + /* The symbols in the object file are linked to the VMA of the section, + relocate them VMA relative. */ + new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma; + new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma; + new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma; objfile_relocate (objfile, new_offsets); } @@ -340,16 +714,32 @@ vmap_symtab (vp) /* 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, 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 @@ -358,31 +748,37 @@ objfile_symbol_add (arg) 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; + 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 */ @@ -394,46 +790,40 @@ add_vmap (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); 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; } @@ -441,102 +831,102 @@ add_vmap (ldi) 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; + struct vmap *vp; int got_one, retried; - int got_exec_file; + 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; + do + { + char *name = LDI_FILENAME (ldi, arch64); + char *memb = name + strlen (name) + 1; + int fd = LDI_FD (ldi, arch64); - retried = 0; + 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) - { - /* 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... */ + 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] == '/' && !DEPRECATED_STREQ (name, vp->name)) + || (memb[0] && !DEPRECATED_STREQ (memb, vp->member))) + continue; + + /* See if we are referring to the same file. + We have to check objfile->obfd, symfile.c:reread_symbols might + have updated the obfd after a change. */ + objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile; + if (objfile == NULL + || objfile->obfd == NULL + || bfd_stat (objfile->obfd, &vi) < 0) + { + warning (_("Unable to stat %s, keeping its symbols"), name); + continue; + } - /* The filenames are not always sufficient to match on. */ + if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino) + continue; - if ((name[0] == '/' && !STREQ(name, vp->name)) - || (memb[0] && !STREQ(memb, vp->member))) - continue; + if (!retried) + close (fd); - /* See if we are referring to the same file. */ - if (bfd_stat (vp->bfd, &vi) < 0) - /* An error here is innocuous, most likely meaning that - the file descriptor has become worthless. - FIXME: What does it mean for a file descriptor to become - "worthless"? What makes it happen? What error does it - produce (ENOENT? others?)? Should we at least provide - a warning? */ - continue; + ++got_one; - if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino) - continue; + /* Found a corresponding VMAP. Remap! */ - if (!retried) - close (ldi->ldinfo_fd); - - ++got_one; - - /* Found a corresponding VMAP. Remap! */ - - /* We can assume pointer == CORE_ADDR, this code is native only. */ - vp->tstart = (CORE_ADDR) ldi->ldinfo_textorg; - vp->tend = vp->tstart + ldi->ldinfo_textsize; - vp->dstart = (CORE_ADDR) ldi->ldinfo_dataorg; - vp->dend = vp->dstart + ldi->ldinfo_datasize; - - 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; - -#ifdef DONT_RELOCATE_SYMFILE_OBJFILE - if (vp->objfile == symfile_objfile - || vp->objfile == NULL) - { - ldi->ldinfo_dataorg = 0; - vp->dstart = (CORE_ADDR) 0; - vp->dend = ldi->ldinfo_datasize; - } -#endif + vmap_secs (vp, ldi, arch64); - /* relocate symbol table(s). */ - vmap_symtab (vp); + /* The objfile is only NULL for the exec file. */ + if (vp->objfile == NULL) + got_exec_file = 1; - /* There may be more, so we don't break out of the loop. */ - } + /* relocate symbol table(s). */ + vmap_symtab (vp); - /* 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))); + /* Announce new object files. Doing this after symbol relocation + makes aix-thread.c's job easier. */ + if (deprecated_target_new_objfile_hook && vp->objfile) + deprecated_target_new_objfile_hook (vp->objfile); + + /* There may be more, so we don't break out of the loop. */ + } + + /* if there was no matching *vp, we must perforce create the sucker(s) */ + if (!got_one && !retried) + { + add_vmap (ldi); + ++retried; + goto retry; + } + } + 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 @@ -544,14 +934,12 @@ vmap_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; } @@ -566,10 +954,10 @@ symbols to the proper address).\n", gdb_stderr); `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; @@ -580,66 +968,125 @@ vmap_exec () 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++) + 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; - exec_ops.to_sections[i].endaddr += vmap->tstart; + 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; - 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; + } + 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; } } } - -/* 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; + + if (__power_rs ()) + { + arch = bfd_arch_rs6000; + mach = bfd_mach_rs6k; + } + else + { + arch = bfd_arch_powerpc; + mach = bfd_mach_ppc; + } - struct ld_info *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; - ldi = (void *) alloca(MAX_LOAD_SEGS * sizeof (*ldi)); + exec_bfd_arch_info = bfd_get_arch_info (exec_bfd); + if (arch == exec_bfd_arch_info->arch) + return; + } - /* 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. */ + bfd_default_set_arch_mach (&abfd, arch, mach); - usleep (36000); + gdbarch_info_init (&info); + info.bfd_arch_info = bfd_get_arch_info (&abfd); + info.abfd = exec_bfd; - errno = 0; - ptrace (PT_LDINFO, pid, (PTRACE_ARG3_TYPE) ldi, - MAX_LOAD_SEGS * sizeof(*ldi), ldi); - if (errno) - perror_with_name ("ptrace ldinfo"); + if (!gdbarch_update_p (info)) + internal_error (__FILE__, __LINE__, + _("set_host_arch: failed to select architecture")); +} - vmap_ldinfo (ldi); + +/* 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); } /* Core file stuff. */ @@ -648,33 +1095,22 @@ xcoff_relocate_symtab (pid) from the core file. */ void -xcoff_relocate_core (target) - struct target_ops *target; +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; + struct bfd_section *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) { @@ -691,11 +1127,11 @@ xcoff_relocate_core (target) /* 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) @@ -708,115 +1144,113 @@ xcoff_relocate_core (target) 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; - - /* 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; + vp = add_vmap (ldi); -#ifdef DONT_RELOCATE_SYMFILE_OBJFILE - if (vp == vmap) - { - vp->dstart = (CORE_ADDR) 0; - vp->dend = ldip->ldinfo_datasize; - } -#endif + /* 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; - int update_coreops; - - /* We must update the to_sections field in the core_ops structure - now to avoid dangling pointer dereferences. */ - update_coreops = core_ops.to_sections == target->to_sections; - - count = target->to_sections_end - target->to_sections; - count += 2; - target->to_sections = (struct section_table *) - xrealloc (target->to_sections, - sizeof (struct section_table) * count); - target->to_sections_end = target->to_sections + count; - - /* Update the to_sections field in the core_ops structure - if needed. */ - if (update_coreops) - { - core_ops.to_sections = target->to_sections; - core_ops.to_sections_end = target->to_sections_end; - } + + target_resize_to_sections (target, 2); stp = target->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. */ 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 (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile) + deprecated_target_new_objfile_hook (vp->objfile); + } + while (LDI_NEXT (ldi, arch64) != 0); vmap_exec (); breakpoint_re_set (); do_cleanups (old); } int -kernel_u_size () +kernel_u_size (void) { return (sizeof (struct user)); } + +/* 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."), hex_string (pc)); +} /* Register that we are able to handle rs6000 core file formats. */ static struct core_fns rs6000_core_fns = { - bfd_target_coff_flavour, - fetch_core_registers, - NULL + 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 () +_initialize_core_rs6000 (void) { - add_core_fns (&rs6000_core_fns); + /* Initialize hook in rs6000-tdep.c for determining the TOC address + when calling functions in the inferior. */ + rs6000_find_toc_address_hook = find_toc_address; + + /* Initialize hook in rs6000-tdep.c to set the current architecture + when starting a child process. */ + rs6000_set_host_arch_hook = set_host_arch; + + deprecated_add_core_fns (&rs6000_core_fns); }