X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Firix5-nat.c;h=c1549fc06239e18356756824d887997300c93be6;hb=9733f989bbfcefd612a9712683eeebff74329bf4;hp=55d6d3e3618f5bab3b28ff290d9bc783343426ad;hpb=ce2f21b2cd3c23f8ce9c8b56baf0028ecc36ec48;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/irix5-nat.c b/gdb/irix5-nat.c index 55d6d3e361..c1549fc062 100644 --- a/gdb/irix5-nat.c +++ b/gdb/irix5-nat.c @@ -1,35 +1,44 @@ /* Native support for the SGI Iris running IRIX version 5, for GDB. - Copyright 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. + Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, + 1999, 2000, 2001 Free Software Foundation, Inc. Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin. Implemented for Irix 4.x by Garrett A. Wollman. Modified for Irix 5.x by Ian Lance Taylor. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ #include "defs.h" #include "inferior.h" #include "gdbcore.h" #include "target.h" +#include "regcache.h" +#include "gdb_string.h" #include #include #include /* For JB_XXX. */ +/* Prototypes for supply_gregset etc. */ +#include "gregset.h" + +static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR); + /* Size of elements in jmpbuf */ #define JB_ELEMENT_SIZE 4 @@ -41,45 +50,62 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ * any MIPS SVR4 target. */ -void -supply_gregset (gregsetp) - gregset_t *gregsetp; +void +supply_gregset (gregset_t *gregsetp) { register int regi; register greg_t *regp = &(*gregsetp)[0]; + int gregoff = sizeof (greg_t) - MIPS_REGSIZE; + static char zerobuf[MAX_REGISTER_RAW_SIZE] = + {0}; + + for (regi = 0; regi <= CTX_RA; regi++) + supply_register (regi, (char *) (regp + regi) + gregoff); - for(regi = 0; regi <= CTX_RA; regi++) - supply_register (regi, (char *)(regp + regi)); + supply_register (PC_REGNUM, (char *) (regp + CTX_EPC) + gregoff); + supply_register (HI_REGNUM, (char *) (regp + CTX_MDHI) + gregoff); + supply_register (LO_REGNUM, (char *) (regp + CTX_MDLO) + gregoff); + supply_register (CAUSE_REGNUM, (char *) (regp + CTX_CAUSE) + gregoff); - supply_register (PC_REGNUM, (char *)(regp + CTX_EPC)); - supply_register (HI_REGNUM, (char *)(regp + CTX_MDHI)); - supply_register (LO_REGNUM, (char *)(regp + CTX_MDLO)); - supply_register (CAUSE_REGNUM, (char *)(regp + CTX_CAUSE)); + /* Fill inaccessible registers with zero. */ + supply_register (BADVADDR_REGNUM, zerobuf); } void -fill_gregset (gregsetp, regno) - gregset_t *gregsetp; - int regno; +fill_gregset (gregset_t *gregsetp, int regno) { int regi; register greg_t *regp = &(*gregsetp)[0]; + /* Under Irix6, if GDB is built with N32 ABI and is debugging an O32 + executable, we have to sign extend the registers to 64 bits before + filling in the gregset structure. */ + for (regi = 0; regi <= CTX_RA; regi++) if ((regno == -1) || (regno == regi)) - *(regp + regi) = *(greg_t *) ®isters[REGISTER_BYTE (regi)]; + *(regp + regi) = + extract_signed_integer (®isters[REGISTER_BYTE (regi)], + REGISTER_RAW_SIZE (regi)); if ((regno == -1) || (regno == PC_REGNUM)) - *(regp + CTX_EPC) = *(greg_t *) ®isters[REGISTER_BYTE (PC_REGNUM)]; + *(regp + CTX_EPC) = + extract_signed_integer (®isters[REGISTER_BYTE (PC_REGNUM)], + REGISTER_RAW_SIZE (PC_REGNUM)); if ((regno == -1) || (regno == CAUSE_REGNUM)) - *(regp + CTX_CAUSE) = *(greg_t *) ®isters[REGISTER_BYTE (PS_REGNUM)]; + *(regp + CTX_CAUSE) = + extract_signed_integer (®isters[REGISTER_BYTE (CAUSE_REGNUM)], + REGISTER_RAW_SIZE (CAUSE_REGNUM)); if ((regno == -1) || (regno == HI_REGNUM)) - *(regp + CTX_MDHI) = *(greg_t *) ®isters[REGISTER_BYTE (HI_REGNUM)]; + *(regp + CTX_MDHI) = + extract_signed_integer (®isters[REGISTER_BYTE (HI_REGNUM)], + REGISTER_RAW_SIZE (HI_REGNUM)); if ((regno == -1) || (regno == LO_REGNUM)) - *(regp + CTX_MDLO) = *(greg_t *) ®isters[REGISTER_BYTE (LO_REGNUM)]; + *(regp + CTX_MDLO) = + extract_signed_integer (®isters[REGISTER_BYTE (LO_REGNUM)], + REGISTER_RAW_SIZE (LO_REGNUM)); } /* @@ -91,40 +117,44 @@ fill_gregset (gregsetp, regno) */ void -supply_fpregset (fpregsetp) - fpregset_t *fpregsetp; +supply_fpregset (fpregset_t *fpregsetp) { register int regi; + static char zerobuf[MAX_REGISTER_RAW_SIZE] = + {0}; + + /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */ for (regi = 0; regi < 32; regi++) supply_register (FP0_REGNUM + regi, - (char *)&fpregsetp->fp_r.fp_regs[regi]); + (char *) &fpregsetp->fp_r.fp_regs[regi]); - supply_register (FCRCS_REGNUM, (char *)&fpregsetp->fp_csr); + supply_register (FCRCS_REGNUM, (char *) &fpregsetp->fp_csr); /* FIXME: how can we supply FCRIR_REGNUM? SGI doesn't tell us. */ + supply_register (FCRIR_REGNUM, zerobuf); } void -fill_fpregset (fpregsetp, regno) - fpregset_t *fpregsetp; - int regno; +fill_fpregset (fpregset_t *fpregsetp, int regno) { int regi; char *from, *to; + /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */ + for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++) { if ((regno == -1) || (regno == regi)) { from = (char *) ®isters[REGISTER_BYTE (regi)]; to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]); - memcpy(to, from, REGISTER_RAW_SIZE (regi)); + memcpy (to, from, REGISTER_RAW_SIZE (regi)); } } if ((regno == -1) || (regno == FCRCS_REGNUM)) - fpregsetp->fp_csr = *(unsigned *) ®isters[REGISTER_BYTE(FCRCS_REGNUM)]; + fpregsetp->fp_csr = *(unsigned *) ®isters[REGISTER_BYTE (FCRCS_REGNUM)]; } @@ -134,12 +164,12 @@ fill_fpregset (fpregsetp, regno) This routine returns true on success. */ int -get_longjmp_target (pc) - CORE_ADDR *pc; +get_longjmp_target (CORE_ADDR *pc) { - char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT]; + char *buf; CORE_ADDR jb_addr; + buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT); jb_addr = read_register (A0_REGNUM); if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf, @@ -151,28 +181,87 @@ get_longjmp_target (pc) return 1; } -void -fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) - char *core_reg_sect; - unsigned core_reg_size; - int which; /* Unused */ - unsigned int reg_addr; /* Unused */ +/* Provide registers to GDB from a core file. + + CORE_REG_SECT points to an array of bytes, which were obtained from + a core file which BFD thinks might contain register contents. + CORE_REG_SIZE is its size. + + Normally, WHICH says which register set corelow suspects this is: + 0 --- the general-purpose register set + 2 --- the floating-point register set + However, for Irix 5, WHICH isn't used. + + REG_ADDR is also unused. */ + +static void +fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, + int which, CORE_ADDR reg_addr) { - if (core_reg_size != REGISTER_BYTES) + if (core_reg_size == REGISTER_BYTES) + { + memcpy ((char *) registers, core_reg_sect, core_reg_size); + } + else if (MIPS_REGSIZE == 4 && + core_reg_size == (2 * MIPS_REGSIZE) * NUM_REGS) + { + /* This is a core file from a N32 executable, 64 bits are saved + for all registers. */ + char *srcp = core_reg_sect; + char *dstp = registers; + int regno; + + for (regno = 0; regno < NUM_REGS; regno++) + { + if (regno >= FP0_REGNUM && regno < (FP0_REGNUM + 32)) + { + /* FIXME, this is wrong, N32 has 64 bit FP regs, but GDB + currently assumes that they are 32 bit. */ + *dstp++ = *srcp++; + *dstp++ = *srcp++; + *dstp++ = *srcp++; + *dstp++ = *srcp++; + if (REGISTER_RAW_SIZE (regno) == 4) + { + /* copying 4 bytes from eight bytes? + I don't see how this can be right... */ + srcp += 4; + } + else + { + /* copy all 8 bytes (sizeof(double)) */ + *dstp++ = *srcp++; + *dstp++ = *srcp++; + *dstp++ = *srcp++; + *dstp++ = *srcp++; + } + } + else + { + srcp += 4; + *dstp++ = *srcp++; + *dstp++ = *srcp++; + *dstp++ = *srcp++; + *dstp++ = *srcp++; + } + } + } + else { warning ("wrong size gregset struct in core file"); return; } - memcpy ((char *)registers, core_reg_sect, core_reg_size); + registers_fetched (); } /* Irix 5 uses what appears to be a unique form of shared library support. This is a copy of solib.c modified for Irix 5. */ +/* FIXME: Most of this code could be merged with osfsolib.c and solib.c + by using next_link_map_member and xfer_link_map_member in solib.c. */ #include #include -#include #include #include @@ -182,6 +271,13 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) #define __SYM_H__ #define __SYMCONST_H__ #include +#ifdef HAVE_OBJLIST_H +#include +#endif + +#ifdef NEW_OBJ_INFO_MAGIC +#define HANDLE_NEW_OBJ_LIST +#endif #include "symtab.h" #include "bfd.h" @@ -189,124 +285,133 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr) #include "objfiles.h" #include "command.h" #include "frame.h" -#include "regex.h" +#include "gdb_regex.h" #include "inferior.h" #include "language.h" - -/* We need to set a breakpoint at a point when we know that the - mapping of shared libraries is complete. dbx simply breaks at main - (or, for FORTRAN, MAIN__), so we do the same. We can not break at - the very beginning of main, because the startup code will jump into - main after the GP initialization instructions. SOLIB_BKPT_OFFSET - is used to skip those instructions. */ - -#define SOLIB_BKPT_OFFSET 12 - -static char *bkpt_names[] = { - "main", - "MAIN__", - NULL -}; +#include "gdbcmd.h" /* The symbol which starts off the list of shared libraries. */ #define DEBUG_BASE "__rld_obj_head" -/* How to get the loaded address of a shared library. */ -#define LM_ADDR(so) ((so)->lm.o_base_address) +/* Irix 6.x introduces a new variant of object lists. + To be able to debug O32 executables under Irix 6, we have to handle both + variants. */ + +typedef enum +{ + OBJ_LIST_OLD, /* Pre Irix 6.x object list. */ + OBJ_LIST_32, /* 32 Bit Elf32_Obj_Info. */ + OBJ_LIST_64 /* 64 Bit Elf64_Obj_Info, FIXME not yet implemented. */ +} +obj_list_variant; + +/* Define our own link_map structure. + This will help to share code with osfsolib.c and solib.c. */ + +struct link_map + { + obj_list_variant l_variant; /* which variant of object list */ + CORE_ADDR l_lladdr; /* addr in inferior list was read from */ + CORE_ADDR l_next; /* address of next object list entry */ + }; + +/* Irix 5 shared objects are pre-linked to particular addresses + although the dynamic linker may have to relocate them if the + address ranges of the libraries used by the main program clash. + The offset is the difference between the address where the object + is mapped and the binding address of the shared library. */ +#define LM_OFFSET(so) ((so) -> offset) +/* Loaded address of shared library. */ +#define LM_ADDR(so) ((so) -> lmstart) char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */ -extern CORE_ADDR sigtramp_address, sigtramp_end; - -struct so_list { - struct so_list *next; /* next structure in linked list */ - struct obj_list ll; - struct obj lm; /* copy of link map from inferior */ - struct obj_list *lladdr; /* addr in inferior lm was read from */ - CORE_ADDR lmend; /* upper addr bound of mapped object */ - char symbols_loaded; /* flag: symbols read in yet? */ - char from_tty; /* flag: print msgs? */ - struct objfile *objfile; /* objfile for loaded lib */ - struct section_table *sections; - struct section_table *sections_end; - struct section_table *textsection; - bfd *abfd; -}; +struct so_list + { + struct so_list *next; /* next structure in linked list */ + struct link_map lm; + CORE_ADDR offset; /* prelink to load address offset */ + char *so_name; /* shared object lib name */ + CORE_ADDR lmstart; /* lower addr bound of mapped object */ + CORE_ADDR lmend; /* upper addr bound of mapped object */ + char symbols_loaded; /* flag: symbols read in yet? */ + char from_tty; /* flag: print msgs? */ + struct objfile *objfile; /* objfile for loaded lib */ + struct section_table *sections; + struct section_table *sections_end; + struct section_table *textsection; + bfd *abfd; + }; static struct so_list *so_list_head; /* List of known shared objects */ -static CORE_ADDR debug_base; /* Base of dynamic linker structures */ +static CORE_ADDR debug_base; /* Base of dynamic linker structures */ static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */ /* Local function prototypes */ -static void -sharedlibrary_command PARAMS ((char *, int)); +static void sharedlibrary_command (char *, int); -static int -enable_break PARAMS ((void)); +static int enable_break (void); -static int -disable_break PARAMS ((void)); +static int disable_break (void); -static void -info_sharedlibrary_command PARAMS ((char *, int)); +static void info_sharedlibrary_command (char *, int); -static int -symbol_add_stub PARAMS ((char *)); +static int symbol_add_stub (void *); -static struct so_list * -find_solib PARAMS ((struct so_list *)); +static struct so_list *find_solib (struct so_list *); -static struct obj_list * -first_link_map_member PARAMS ((void)); +static struct link_map *first_link_map_member (void); -static CORE_ADDR -locate_base PARAMS ((void)); +static struct link_map *next_link_map_member (struct so_list *); -static void -solib_map_sections PARAMS ((struct so_list *)); +static void xfer_link_map_member (struct so_list *, struct link_map *); + +static CORE_ADDR locate_base (void); + +static int solib_map_sections (void *); /* -LOCAL FUNCTION + LOCAL FUNCTION - solib_map_sections -- open bfd and build sections for shared lib + solib_map_sections -- open bfd and build sections for shared lib -SYNOPSIS + SYNOPSIS - static void solib_map_sections (struct so_list *so) + static int solib_map_sections (struct so_list *so) -DESCRIPTION + DESCRIPTION - Given a pointer to one of the shared objects in our list - of mapped objects, use the recorded name to open a bfd - descriptor for the object, build a section table, and then - relocate all the section addresses by the base address at - which the shared object was mapped. + Given a pointer to one of the shared objects in our list + of mapped objects, use the recorded name to open a bfd + descriptor for the object, build a section table, and then + relocate all the section addresses by the base address at + which the shared object was mapped. -FIXMES + FIXMES - In most (all?) cases the shared object file name recorded in the - dynamic linkage tables will be a fully qualified pathname. For - cases where it isn't, do we really mimic the systems search - mechanism correctly in the below code (particularly the tilde - expansion stuff?). + In most (all?) cases the shared object file name recorded in the + dynamic linkage tables will be a fully qualified pathname. For + cases where it isn't, do we really mimic the systems search + mechanism correctly in the below code (particularly the tilde + expansion stuff?). */ -static void -solib_map_sections (so) - struct so_list *so; +static int +solib_map_sections (void *arg) { + struct so_list *so = (struct so_list *) arg; /* catch_errors bogon */ char *filename; char *scratch_pathname; int scratch_chan; struct section_table *p; struct cleanup *old_chain; bfd *abfd; - - filename = tilde_expand (so -> lm.o_path); - old_chain = make_cleanup (free, filename); - + + filename = tilde_expand (so->so_name); + old_chain = make_cleanup (xfree, filename); + scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0, &scratch_pathname); if (scratch_chan < 0) @@ -328,92 +433,95 @@ solib_map_sections (so) scratch_pathname, bfd_errmsg (bfd_get_error ())); } /* Leave bfd open, core_xfer_memory and "info files" need it. */ - so -> abfd = abfd; - abfd -> cacheable = true; + so->abfd = abfd; + abfd->cacheable = true; if (!bfd_check_format (abfd, bfd_object)) { error ("\"%s\": not in executable format: %s.", scratch_pathname, bfd_errmsg (bfd_get_error ())); } - if (build_section_table (abfd, &so -> sections, &so -> sections_end)) + if (build_section_table (abfd, &so->sections, &so->sections_end)) { - error ("Can't find the file sections in `%s': %s", + error ("Can't find the file sections in `%s': %s", bfd_get_filename (exec_bfd), bfd_errmsg (bfd_get_error ())); } - for (p = so -> sections; p < so -> sections_end; p++) + for (p = so->sections; p < so->sections_end; p++) { /* Relocate the section binding addresses as recorded in the shared - object's file by the base address to which the object was actually - mapped. */ - p -> addr += (CORE_ADDR) LM_ADDR (so); - p -> endaddr += (CORE_ADDR) LM_ADDR (so); - so -> lmend = (CORE_ADDR) max (p -> endaddr, so -> lmend); - if (STREQ (p -> sec_ptr -> name, ".text")) + object's file by the offset to get the address to which the + object was actually mapped. */ + p->addr += LM_OFFSET (so); + p->endaddr += LM_OFFSET (so); + so->lmend = (CORE_ADDR) max (p->endaddr, so->lmend); + if (STREQ (p->the_bfd_section->name, ".text")) { - so -> textsection = p; + so->textsection = p; } } /* Free the file names, close the file now. */ do_cleanups (old_chain); + + /* must be non-zero */ + return (1); } /* -LOCAL FUNCTION + LOCAL FUNCTION - locate_base -- locate the base address of dynamic linker structs + locate_base -- locate the base address of dynamic linker structs -SYNOPSIS + SYNOPSIS - CORE_ADDR locate_base (void) + CORE_ADDR locate_base (void) -DESCRIPTION + DESCRIPTION - For both the SunOS and SVR4 shared library implementations, if the - inferior executable has been linked dynamically, there is a single - address somewhere in the inferior's data space which is the key to - locating all of the dynamic linker's runtime structures. This - address is the value of the symbol defined by the macro DEBUG_BASE. - The job of this function is to find and return that address, or to - return 0 if there is no such address (the executable is statically - linked for example). + For both the SunOS and SVR4 shared library implementations, if the + inferior executable has been linked dynamically, there is a single + address somewhere in the inferior's data space which is the key to + locating all of the dynamic linker's runtime structures. This + address is the value of the symbol defined by the macro DEBUG_BASE. + The job of this function is to find and return that address, or to + return 0 if there is no such address (the executable is statically + linked for example). - For SunOS, the job is almost trivial, since the dynamic linker and - all of it's structures are statically linked to the executable at - link time. Thus the symbol for the address we are looking for has - already been added to the minimal symbol table for the executable's - objfile at the time the symbol file's symbols were read, and all we - have to do is look it up there. Note that we explicitly do NOT want - to find the copies in the shared library. + For SunOS, the job is almost trivial, since the dynamic linker and + all of it's structures are statically linked to the executable at + link time. Thus the symbol for the address we are looking for has + already been added to the minimal symbol table for the executable's + objfile at the time the symbol file's symbols were read, and all we + have to do is look it up there. Note that we explicitly do NOT want + to find the copies in the shared library. - The SVR4 version is much more complicated because the dynamic linker - and it's structures are located in the shared C library, which gets - run as the executable's "interpreter" by the kernel. We have to go - to a lot more work to discover the address of DEBUG_BASE. Because - of this complexity, we cache the value we find and return that value - on subsequent invocations. Note there is no copy in the executable - symbol tables. + The SVR4 version is much more complicated because the dynamic linker + and it's structures are located in the shared C library, which gets + run as the executable's "interpreter" by the kernel. We have to go + to a lot more work to discover the address of DEBUG_BASE. Because + of this complexity, we cache the value we find and return that value + on subsequent invocations. Note there is no copy in the executable + symbol tables. - Irix 5 is basically like SunOS. + Irix 5 is basically like SunOS. - Note that we can assume nothing about the process state at the time - we need to find this address. We may be stopped on the first instruc- - tion of the interpreter (C shared library), the first instruction of - the executable itself, or somewhere else entirely (if we attached - to the process for example). + Note that we can assume nothing about the process state at the time + we need to find this address. We may be stopped on the first instruc- + tion of the interpreter (C shared library), the first instruction of + the executable itself, or somewhere else entirely (if we attached + to the process for example). */ static CORE_ADDR -locate_base () +locate_base (void) { struct minimal_symbol *msymbol; CORE_ADDR address = 0; - msymbol = lookup_minimal_symbol (DEBUG_BASE, symfile_objfile); + msymbol = lookup_minimal_symbol (DEBUG_BASE, NULL, symfile_objfile); if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0)) { address = SYMBOL_VALUE_ADDRESS (msymbol); @@ -423,136 +531,288 @@ locate_base () /* -LOCAL FUNCTION + LOCAL FUNCTION - first_link_map_member -- locate first member in dynamic linker's map + first_link_map_member -- locate first member in dynamic linker's map -SYNOPSIS + SYNOPSIS - static struct link_map *first_link_map_member (void) + static struct link_map *first_link_map_member (void) -DESCRIPTION + DESCRIPTION - Read in a copy of the first member in the inferior's dynamic - link map from the inferior's dynamic linker structures, and return - a pointer to the copy in our address space. -*/ + Read in a copy of the first member in the inferior's dynamic + link map from the inferior's dynamic linker structures, and return + a pointer to the link map descriptor. + */ -static struct obj_list * -first_link_map_member () +static struct link_map * +first_link_map_member (void) { - struct obj_list *lm; - struct obj_list s; + struct obj_list *listp; + struct obj_list list_old; + struct link_map *lm; + static struct link_map first_lm; + CORE_ADDR lladdr; + CORE_ADDR next_lladdr; + + /* We have not already read in the dynamic linking structures + from the inferior, lookup the address of the base structure. */ + debug_base = locate_base (); + if (debug_base == 0) + return NULL; - read_memory (debug_base, (char *) &lm, sizeof (struct obj_list *)); + /* Get address of first list entry. */ + read_memory (debug_base, (char *) &listp, sizeof (struct obj_list *)); - if (lm == NULL) + if (listp == NULL) return NULL; + /* Get first list entry. */ + /* The MIPS Sign extends addresses. */ + lladdr = host_pointer_to_address (listp); + read_memory (lladdr, (char *) &list_old, sizeof (struct obj_list)); + /* The first entry in the list is the object file we are debugging, so skip it. */ - read_memory ((CORE_ADDR) lm, (char *) &s, sizeof (struct obj_list)); + next_lladdr = host_pointer_to_address (list_old.next); + +#ifdef HANDLE_NEW_OBJ_LIST + if (list_old.data == NEW_OBJ_INFO_MAGIC) + { + Elf32_Obj_Info list_32; + + read_memory (lladdr, (char *) &list_32, sizeof (Elf32_Obj_Info)); + if (list_32.oi_size != sizeof (Elf32_Obj_Info)) + return NULL; + next_lladdr = (CORE_ADDR) list_32.oi_next; + } +#endif + + if (next_lladdr == 0) + return NULL; + + first_lm.l_lladdr = next_lladdr; + lm = &first_lm; + return lm; +} + +/* + + LOCAL FUNCTION + + next_link_map_member -- locate next member in dynamic linker's map + + SYNOPSIS + + static struct link_map *next_link_map_member (so_list_ptr) + + DESCRIPTION + + Read in a copy of the next member in the inferior's dynamic + link map from the inferior's dynamic linker structures, and return + a pointer to the link map descriptor. + */ + +static struct link_map * +next_link_map_member (struct so_list *so_list_ptr) +{ + struct link_map *lm = &so_list_ptr->lm; + CORE_ADDR next_lladdr = lm->l_next; + static struct link_map next_lm; + + if (next_lladdr == 0) + { + /* We have hit the end of the list, so check to see if any were + added, but be quiet if we can't read from the target any more. */ + int status = 0; + + if (lm->l_variant == OBJ_LIST_OLD) + { + struct obj_list list_old; + + status = target_read_memory (lm->l_lladdr, + (char *) &list_old, + sizeof (struct obj_list)); + next_lladdr = host_pointer_to_address (list_old.next); + } +#ifdef HANDLE_NEW_OBJ_LIST + else if (lm->l_variant == OBJ_LIST_32) + { + Elf32_Obj_Info list_32; + status = target_read_memory (lm->l_lladdr, + (char *) &list_32, + sizeof (Elf32_Obj_Info)); + next_lladdr = (CORE_ADDR) list_32.oi_next; + } +#endif + + if (status != 0 || next_lladdr == 0) + return NULL; + } + + next_lm.l_lladdr = next_lladdr; + lm = &next_lm; + return lm; +} + +/* + + LOCAL FUNCTION + + xfer_link_map_member -- set local variables from dynamic linker's map + + SYNOPSIS + + static void xfer_link_map_member (so_list_ptr, lm) + + DESCRIPTION + + Read in a copy of the requested member in the inferior's dynamic + link map from the inferior's dynamic linker structures, and fill + in the necessary so_list_ptr elements. + */ + +static void +xfer_link_map_member (struct so_list *so_list_ptr, struct link_map *lm) +{ + struct obj_list list_old; + CORE_ADDR lladdr = lm->l_lladdr; + struct link_map *new_lm = &so_list_ptr->lm; + int errcode; + + read_memory (lladdr, (char *) &list_old, sizeof (struct obj_list)); + + new_lm->l_variant = OBJ_LIST_OLD; + new_lm->l_lladdr = lladdr; + new_lm->l_next = host_pointer_to_address (list_old.next); + +#ifdef HANDLE_NEW_OBJ_LIST + if (list_old.data == NEW_OBJ_INFO_MAGIC) + { + Elf32_Obj_Info list_32; + + read_memory (lladdr, (char *) &list_32, sizeof (Elf32_Obj_Info)); + if (list_32.oi_size != sizeof (Elf32_Obj_Info)) + return; + new_lm->l_variant = OBJ_LIST_32; + new_lm->l_next = (CORE_ADDR) list_32.oi_next; + + target_read_string ((CORE_ADDR) list_32.oi_pathname, + &so_list_ptr->so_name, + list_32.oi_pathname_len + 1, &errcode); + if (errcode != 0) + memory_error (errcode, (CORE_ADDR) list_32.oi_pathname); + + LM_ADDR (so_list_ptr) = (CORE_ADDR) list_32.oi_ehdr; + LM_OFFSET (so_list_ptr) = + (CORE_ADDR) list_32.oi_ehdr - (CORE_ADDR) list_32.oi_orig_ehdr; + } + else +#endif + { +#if defined (_MIPS_SIM_NABI32) && _MIPS_SIM == _MIPS_SIM_NABI32 + /* If we are compiling GDB under N32 ABI, the alignments in + the obj struct are different from the O32 ABI and we will get + wrong values when accessing the struct. + As a workaround we use fixed values which are good for + Irix 6.2. */ + char buf[432]; + + read_memory ((CORE_ADDR) list_old.data, buf, sizeof (buf)); + + target_read_string (extract_address (&buf[236], 4), + &so_list_ptr->so_name, + INT_MAX, &errcode); + if (errcode != 0) + memory_error (errcode, extract_address (&buf[236], 4)); + + LM_ADDR (so_list_ptr) = extract_address (&buf[196], 4); + LM_OFFSET (so_list_ptr) = + extract_address (&buf[196], 4) - extract_address (&buf[248], 4); +#else + struct obj obj_old; + + read_memory ((CORE_ADDR) list_old.data, (char *) &obj_old, + sizeof (struct obj)); + + target_read_string ((CORE_ADDR) obj_old.o_path, + &so_list_ptr->so_name, + INT_MAX, &errcode); + if (errcode != 0) + memory_error (errcode, (CORE_ADDR) obj_old.o_path); + + LM_ADDR (so_list_ptr) = (CORE_ADDR) obj_old.o_praw; + LM_OFFSET (so_list_ptr) = + (CORE_ADDR) obj_old.o_praw - obj_old.o_base_address; +#endif + } - return s.next; + catch_errors (solib_map_sections, (char *) so_list_ptr, + "Error while mapping shared library sections:\n", + RETURN_MASK_ALL); } + /* -LOCAL FUNCTION + LOCAL FUNCTION - find_solib -- step through list of shared objects + find_solib -- step through list of shared objects -SYNOPSIS + SYNOPSIS - struct so_list *find_solib (struct so_list *so_list_ptr) + struct so_list *find_solib (struct so_list *so_list_ptr) -DESCRIPTION + DESCRIPTION - This module contains the routine which finds the names of any - loaded "images" in the current process. The argument in must be - NULL on the first call, and then the returned value must be passed - in on subsequent calls. This provides the capability to "step" down - the list of loaded objects. On the last object, a NULL value is - returned. + This module contains the routine which finds the names of any + loaded "images" in the current process. The argument in must be + NULL on the first call, and then the returned value must be passed + in on subsequent calls. This provides the capability to "step" down + the list of loaded objects. On the last object, a NULL value is + returned. */ static struct so_list * -find_solib (so_list_ptr) - struct so_list *so_list_ptr; /* Last lm or NULL for first one */ +find_solib (struct so_list *so_list_ptr) { struct so_list *so_list_next = NULL; - struct obj_list *lm = NULL; + struct link_map *lm = NULL; struct so_list *new; - + if (so_list_ptr == NULL) { /* We are setting up for a new scan through the loaded images. */ if ((so_list_next = so_list_head) == NULL) { - /* We have not already read in the dynamic linking structures - from the inferior, lookup the address of the base structure. */ - debug_base = locate_base (); - if (debug_base != 0) - { - /* Read the base structure in and find the address of the first - link map list member. */ - lm = first_link_map_member (); - } + /* Find the first link map list member. */ + lm = first_link_map_member (); } } else { /* We have been called before, and are in the process of walking - the shared library list. Advance to the next shared object. */ - if ((lm = so_list_ptr->ll.next) == NULL) - { - /* We have hit the end of the list, so check to see if any were - added, but be quiet if we can't read from the target any more. */ - int status = target_read_memory ((CORE_ADDR) so_list_ptr -> lladdr, - (char *) &(so_list_ptr -> ll), - sizeof (struct obj_list)); - if (status == 0) - { - lm = so_list_ptr->ll.next; - } - else - { - lm = NULL; - } - } - so_list_next = so_list_ptr -> next; + the shared library list. Advance to the next shared object. */ + lm = next_link_map_member (so_list_ptr); + so_list_next = so_list_ptr->next; } if ((so_list_next == NULL) && (lm != NULL)) { - int errcode; - char *buffer; - - /* Get next link map structure from inferior image and build a local - abbreviated load_map structure */ new = (struct so_list *) xmalloc (sizeof (struct so_list)); memset ((char *) new, 0, sizeof (struct so_list)); - new -> lladdr = lm; /* Add the new node as the next node in the list, or as the root - node if this is the first one. */ + node if this is the first one. */ if (so_list_ptr != NULL) { - so_list_ptr -> next = new; + so_list_ptr->next = new; } else { so_list_head = new; - } + } so_list_next = new; - read_memory ((CORE_ADDR) lm, (char *) &(new -> ll), - sizeof (struct obj_list)); - read_memory ((CORE_ADDR) new->ll.data, (char *) &(new -> lm), - sizeof (struct obj)); - target_read_string ((CORE_ADDR)new->lm.o_path, &buffer, - INT_MAX, &errcode); - if (errcode != 0) - memory_error (errcode, (CORE_ADDR)new->lm.o_path); - new->lm.o_path = buffer; - solib_map_sections (new); + xfer_link_map_member (new, lm); } return (so_list_next); } @@ -560,39 +820,58 @@ find_solib (so_list_ptr) /* A small stub to get us past the arg-passing pinhole of catch_errors. */ static int -symbol_add_stub (arg) - char *arg; +symbol_add_stub (void *arg) { - register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */ - - so -> objfile = symbol_file_add (so -> lm.o_path, so -> from_tty, - (unsigned int) so -> textsection -> addr, - 0, 0, 0); + register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */ + CORE_ADDR text_addr = 0; + struct section_addr_info section_addrs; + + memset (§ion_addrs, 0, sizeof (section_addrs)); + if (so->textsection) + text_addr = so->textsection->addr; + else if (so->abfd != NULL) + { + asection *lowest_sect; + + /* If we didn't find a mapped non zero sized .text section, set up + text_addr so that the relocation in symbol_file_add does no harm. */ + + lowest_sect = bfd_get_section_by_name (so->abfd, ".text"); + if (lowest_sect == NULL) + bfd_map_over_sections (so->abfd, find_lowest_section, + (PTR) &lowest_sect); + if (lowest_sect) + text_addr = bfd_section_vma (so->abfd, lowest_sect) + LM_OFFSET (so); + } + + + section_addrs.other[0].name = ".text"; + section_addrs.other[0].addr = text_addr; + so->objfile = symbol_file_add (so->so_name, so->from_tty, + §ion_addrs, 0, 0); + /* must be non-zero */ return (1); } /* -GLOBAL FUNCTION + GLOBAL FUNCTION - solib_add -- add a shared library file to the symtab and section list + solib_add -- add a shared library file to the symtab and section list -SYNOPSIS + SYNOPSIS - void solib_add (char *arg_string, int from_tty, - struct target_ops *target) + void solib_add (char *arg_string, int from_tty, + struct target_ops *target) -DESCRIPTION + DESCRIPTION -*/ + */ void -solib_add (arg_string, from_tty, target) - char *arg_string; - int from_tty; - struct target_ops *target; -{ - register struct so_list *so = NULL; /* link map state variable */ +solib_add (char *arg_string, int from_tty, struct target_ops *target) +{ + register struct so_list *so = NULL; /* link map state variable */ /* Last shared library that we read. */ struct so_list *so_last = NULL; @@ -600,42 +879,13 @@ solib_add (arg_string, from_tty, target) char *re_err; int count; int old; - + if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL) { error ("Invalid regexp: %s", re_err); } - - /* Getting new symbols may change our opinion about what is - frameless. */ - reinit_frame_cache (); - /* Not to mention where _sigtramp is. */ - sigtramp_address = 0; - - while ((so = find_solib (so)) != NULL) - { - if (so -> lm.o_path[0] && re_exec (so -> lm.o_path)) - { - so -> from_tty = from_tty; - if (so -> symbols_loaded) - { - if (from_tty) - { - printf_unfiltered ("Symbols already loaded for %s\n", so -> lm.o_path); - } - } - else if (catch_errors - (symbol_add_stub, (char *) so, - "Error while reading shared library symbols:\n", - RETURN_MASK_ALL)) - { - so_last = so; - so -> symbols_loaded = 1; - } - } - } - - /* Now add the shared library sections to the section table of the + + /* Add the shared library sections to the section table of the specified target, if any. */ if (target) { @@ -644,140 +894,150 @@ solib_add (arg_string, from_tty, target) count = 0; while ((so = find_solib (so)) != NULL) { - if (so -> lm.o_path[0]) + if (so->so_name[0]) { - count += so -> sections_end - so -> sections; + count += so->sections_end - so->sections; } } - + if (count) { - /* Reallocate the target's section table including the new size. */ - if (target -> to_sections) - { - old = target -> to_sections_end - target -> to_sections; - target -> to_sections = (struct section_table *) - xrealloc ((char *)target -> to_sections, - (sizeof (struct section_table)) * (count + old)); - } - else - { - old = 0; - target -> to_sections = (struct section_table *) - xmalloc ((sizeof (struct section_table)) * count); - } - target -> to_sections_end = target -> to_sections + (count + old); + old = target_resize_to_sections (target, count); /* Add these section table entries to the target's table. */ while ((so = find_solib (so)) != NULL) { - if (so -> lm.o_path[0]) + if (so->so_name[0]) { - count = so -> sections_end - so -> sections; - memcpy ((char *) (target -> to_sections + old), - so -> sections, + count = so->sections_end - so->sections; + memcpy ((char *) (target->to_sections + old), + so->sections, (sizeof (struct section_table)) * count); old += count; } } } } + + /* Now add the symbol files. */ + while ((so = find_solib (so)) != NULL) + { + if (so->so_name[0] && re_exec (so->so_name)) + { + so->from_tty = from_tty; + if (so->symbols_loaded) + { + if (from_tty) + { + printf_unfiltered ("Symbols already loaded for %s\n", so->so_name); + } + } + else if (catch_errors + (symbol_add_stub, (char *) so, + "Error while reading shared library symbols:\n", + RETURN_MASK_ALL)) + { + so_last = so; + so->symbols_loaded = 1; + } + } + } + + /* Getting new symbols may change our opinion about what is + frameless. */ + if (so_last) + reinit_frame_cache (); } /* -LOCAL FUNCTION + LOCAL FUNCTION - info_sharedlibrary_command -- code for "info sharedlibrary" + info_sharedlibrary_command -- code for "info sharedlibrary" -SYNOPSIS + SYNOPSIS - static void info_sharedlibrary_command () + static void info_sharedlibrary_command () -DESCRIPTION + DESCRIPTION - Walk through the shared library list and print information - about each attached library. -*/ + Walk through the shared library list and print information + about each attached library. + */ static void -info_sharedlibrary_command (ignore, from_tty) - char *ignore; - int from_tty; +info_sharedlibrary_command (char *ignore, int from_tty) { - register struct so_list *so = NULL; /* link map state variable */ + register struct so_list *so = NULL; /* link map state variable */ int header_done = 0; - + if (exec_bfd == NULL) { - printf_unfiltered ("No exec file.\n"); + printf_unfiltered ("No executable file.\n"); return; } while ((so = find_solib (so)) != NULL) { - if (so -> lm.o_path[0]) + if (so->so_name[0]) { if (!header_done) { - printf_unfiltered("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read", - "Shared Object Library"); + printf_unfiltered ("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read", + "Shared Object Library"); header_done++; } printf_unfiltered ("%-12s", - local_hex_string_custom ((unsigned long) LM_ADDR (so), - "08l")); + local_hex_string_custom ((unsigned long) LM_ADDR (so), + "08l")); printf_unfiltered ("%-12s", - local_hex_string_custom ((unsigned long) so -> lmend, - "08l")); - printf_unfiltered ("%-12s", so -> symbols_loaded ? "Yes" : "No"); - printf_unfiltered ("%s\n", so -> lm.o_path); + local_hex_string_custom ((unsigned long) so->lmend, + "08l")); + printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No"); + printf_unfiltered ("%s\n", so->so_name); } } if (so_list_head == NULL) { - printf_unfiltered ("No shared libraries loaded at this time.\n"); + printf_unfiltered ("No shared libraries loaded at this time.\n"); } } /* -GLOBAL FUNCTION + GLOBAL FUNCTION - solib_address -- check to see if an address is in a shared lib + solib_address -- check to see if an address is in a shared lib -SYNOPSIS + SYNOPSIS - int solib_address (CORE_ADDR address) + char *solib_address (CORE_ADDR address) -DESCRIPTION + DESCRIPTION - Provides a hook for other gdb routines to discover whether or - not a particular address is within the mapped address space of - a shared library. Any address between the base mapping address - and the first address beyond the end of the last mapping, is - considered to be within the shared library address space, for - our purposes. + Provides a hook for other gdb routines to discover whether or + not a particular address is within the mapped address space of + a shared library. Any address between the base mapping address + and the first address beyond the end of the last mapping, is + considered to be within the shared library address space, for + our purposes. - For example, this routine is called at one point to disable - breakpoints which are in shared libraries that are not currently - mapped in. + For example, this routine is called at one point to disable + breakpoints which are in shared libraries that are not currently + mapped in. */ -int -solib_address (address) - CORE_ADDR address; +char * +solib_address (CORE_ADDR address) { - register struct so_list *so = 0; /* link map state variable */ - + register struct so_list *so = 0; /* link map state variable */ + while ((so = find_solib (so)) != NULL) { - if (so -> lm.o_path[0]) + if (so->so_name[0]) { - if ((address >= (CORE_ADDR) so->lm.o_base_address) && - (address < (CORE_ADDR) so -> lmend)) - { - return (1); - } + if ((address >= (CORE_ADDR) LM_ADDR (so)) && + (address < (CORE_ADDR) so->lmend)) + return (so->so_name); } } return (0); @@ -785,32 +1045,36 @@ solib_address (address) /* Called by free_all_symtabs */ -void -clear_solib() +void +clear_solib (void) { struct so_list *next; char *bfd_filename; - + + disable_breakpoints_in_shlibs (1); + while (so_list_head) { - if (so_list_head -> sections) + if (so_list_head->sections) { - free ((PTR)so_list_head -> sections); + xfree (so_list_head->sections); } - if (so_list_head -> abfd) + if (so_list_head->abfd) { - bfd_filename = bfd_get_filename (so_list_head -> abfd); - bfd_close (so_list_head -> abfd); + bfd_filename = bfd_get_filename (so_list_head->abfd); + if (!bfd_close (so_list_head->abfd)) + warning ("cannot close \"%s\": %s", + bfd_filename, bfd_errmsg (bfd_get_error ())); } else /* This happens for the executable on SVR4. */ bfd_filename = NULL; - next = so_list_head -> next; + next = so_list_head->next; if (bfd_filename) - free ((PTR)bfd_filename); - free (so_list_head->lm.o_path); - free ((PTR)so_list_head); + xfree (bfd_filename); + xfree (so_list_head->so_name); + xfree (so_list_head); so_list_head = next; } debug_base = 0; @@ -818,23 +1082,23 @@ clear_solib() /* -LOCAL FUNCTION + LOCAL FUNCTION - disable_break -- remove the "mapping changed" breakpoint + disable_break -- remove the "mapping changed" breakpoint -SYNOPSIS + SYNOPSIS - static int disable_break () + static int disable_break () -DESCRIPTION + DESCRIPTION - Removes the breakpoint that gets hit when the dynamic linker - completes a mapping change. + Removes the breakpoint that gets hit when the dynamic linker + completes a mapping change. -*/ + */ static int -disable_break () +disable_break (void) { int status = 1; @@ -861,150 +1125,88 @@ disable_break () /* -LOCAL FUNCTION - - enable_break -- arrange for dynamic linker to hit breakpoint - -SYNOPSIS - - int enable_break (void) - -DESCRIPTION + LOCAL FUNCTION - Both the SunOS and the SVR4 dynamic linkers have, as part of their - debugger interface, support for arranging for the inferior to hit - a breakpoint after mapping in the shared libraries. This function - enables that breakpoint. + enable_break -- arrange for dynamic linker to hit breakpoint - For SunOS, there is a special flag location (in_debugger) which we - set to 1. When the dynamic linker sees this flag set, it will set - a breakpoint at a location known only to itself, after saving the - original contents of that place and the breakpoint address itself, - in it's own internal structures. When we resume the inferior, it - will eventually take a SIGTRAP when it runs into the breakpoint. - We handle this (in a different place) by restoring the contents of - the breakpointed location (which is only known after it stops), - chasing around to locate the shared libraries that have been - loaded, then resuming. + SYNOPSIS - For SVR4, the debugger interface structure contains a member (r_brk) - which is statically initialized at the time the shared library is - built, to the offset of a function (_r_debug_state) which is guaran- - teed to be called once before mapping in a library, and again when - the mapping is complete. At the time we are examining this member, - it contains only the unrelocated offset of the function, so we have - to do our own relocation. Later, when the dynamic linker actually - runs, it relocates r_brk to be the actual address of _r_debug_state(). + int enable_break (void) - The debugger interface structure also contains an enumeration which - is set to either RT_ADD or RT_DELETE prior to changing the mapping, - depending upon whether or not the library is being mapped or unmapped, - and then set to RT_CONSISTENT after the library is mapped/unmapped. + DESCRIPTION - Irix 5, on the other hand, has no such features. Instead, we - set a breakpoint at main. -*/ + This functions inserts a breakpoint at the entry point of the + main executable, where all shared libraries are mapped in. + */ static int -enable_break () +enable_break (void) { - int success = 0; - struct minimal_symbol *msymbol; - char **bkpt_namep; - CORE_ADDR bkpt_addr; - - /* Scan through the list of symbols, trying to look up the symbol and - set a breakpoint there. Terminate loop when we/if we succeed. */ - - breakpoint_addr = 0; - for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++) + if (symfile_objfile != NULL + && target_insert_breakpoint (symfile_objfile->ei.entry_point, + shadow_contents) == 0) { - msymbol = lookup_minimal_symbol (*bkpt_namep, symfile_objfile); - if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0)) - { - bkpt_addr = SYMBOL_VALUE_ADDRESS (msymbol); -#ifdef SOLIB_BKPT_OFFSET - /* We only want to skip if bkpt_addr is currently pointing - at a GP setting instruction. */ - { - char buf[4]; - - if (target_read_memory (bkpt_addr, buf, 4) == 0) - { - unsigned long insn; - - insn = extract_unsigned_integer (buf, 4); - if ((insn & 0xffff0000) == 0x3c1c0000) /* lui $gp,n */ - bkpt_addr += SOLIB_BKPT_OFFSET; - } - } -#endif - if (target_insert_breakpoint (bkpt_addr, shadow_contents) == 0) - { - breakpoint_addr = bkpt_addr; - success = 1; - break; - } - } + breakpoint_addr = symfile_objfile->ei.entry_point; + return 1; } - return (success); + return 0; } - + /* - -GLOBAL FUNCTION - - solib_create_inferior_hook -- shared library startup support - -SYNOPSIS - - void solib_create_inferior_hook() - -DESCRIPTION - - When gdb starts up the inferior, it nurses it along (through the - shell) until it is ready to execute it's first instruction. At this - point, this function gets called via expansion of the macro - SOLIB_CREATE_INFERIOR_HOOK. - - For SunOS executables, this first instruction is typically the - one at "_start", or a similar text label, regardless of whether - the executable is statically or dynamically linked. The runtime - startup code takes care of dynamically linking in any shared - libraries, once gdb allows the inferior to continue. - - For SVR4 executables, this first instruction is either the first - instruction in the dynamic linker (for dynamically linked - executables) or the instruction at "start" for statically linked - executables. For dynamically linked executables, the system - first exec's /lib/libc.so.N, which contains the dynamic linker, - and starts it running. The dynamic linker maps in any needed - shared libraries, maps in the actual user executable, and then - jumps to "start" in the user executable. - - For both SunOS shared libraries, and SVR4 shared libraries, we - can arrange to cooperate with the dynamic linker to discover the - names of shared libraries that are dynamically linked, and the - base addresses to which they are linked. - - This function is responsible for discovering those names and - addresses, and saving sufficient information about them to allow - their symbols to be read at a later time. - -FIXME - - Between enable_break() and disable_break(), this code does not - properly handle hitting breakpoints which the user might have - set in the startup code or in the dynamic linker itself. Proper - handling will probably have to wait until the implementation is - changed to use the "breakpoint handler function" method. - - Also, what if child has exit()ed? Must exit loop somehow. - */ - -void -solib_create_inferior_hook() + + GLOBAL FUNCTION + + solib_create_inferior_hook -- shared library startup support + + SYNOPSIS + + void solib_create_inferior_hook() + + DESCRIPTION + + When gdb starts up the inferior, it nurses it along (through the + shell) until it is ready to execute it's first instruction. At this + point, this function gets called via expansion of the macro + SOLIB_CREATE_INFERIOR_HOOK. + + For SunOS executables, this first instruction is typically the + one at "_start", or a similar text label, regardless of whether + the executable is statically or dynamically linked. The runtime + startup code takes care of dynamically linking in any shared + libraries, once gdb allows the inferior to continue. + + For SVR4 executables, this first instruction is either the first + instruction in the dynamic linker (for dynamically linked + executables) or the instruction at "start" for statically linked + executables. For dynamically linked executables, the system + first exec's /lib/libc.so.N, which contains the dynamic linker, + and starts it running. The dynamic linker maps in any needed + shared libraries, maps in the actual user executable, and then + jumps to "start" in the user executable. + + For both SunOS shared libraries, and SVR4 shared libraries, we + can arrange to cooperate with the dynamic linker to discover the + names of shared libraries that are dynamically linked, and the + base addresses to which they are linked. + + This function is responsible for discovering those names and + addresses, and saving sufficient information about them to allow + their symbols to be read at a later time. + + FIXME + + Between enable_break() and disable_break(), this code does not + properly handle hitting breakpoints which the user might have + set in the startup code or in the dynamic linker itself. Proper + handling will probably have to wait until the implementation is + changed to use the "breakpoint handler function" method. + + Also, what if child has exit()ed? Must exit loop somehow. + */ + +void +solib_create_inferior_hook (void) { if (!enable_break ()) { @@ -1019,15 +1221,14 @@ solib_create_inferior_hook() clear_proceed_status (); stop_soon_quietly = 1; - stop_signal = 0; + stop_signal = TARGET_SIGNAL_0; do { - target_resume (-1, 0, stop_signal); + target_resume (pid_to_ptid (-1), 0, stop_signal); wait_for_inferior (); } - while (stop_signal != SIGTRAP); - stop_soon_quietly = 0; - + while (stop_signal != TARGET_SIGNAL_TRAP); + /* We are now either at the "mapping complete" breakpoint (or somewhere else, a condition we aren't prepared to deal with anyway), so adjust the PC as necessary after a breakpoint, disable the breakpoint, and @@ -1044,38 +1245,73 @@ solib_create_inferior_hook() warning ("shared library handler failed to disable breakpoint"); } - solib_add ((char *) 0, 0, (struct target_ops *) 0); + /* solib_add will call reinit_frame_cache. + But we are stopped in the startup code and we might not have symbols + for the startup code, so heuristic_proc_start could be called + and will put out an annoying warning. + Delaying the resetting of stop_soon_quietly until after symbol loading + suppresses the warning. */ + if (auto_solib_add) + solib_add ((char *) 0, 0, (struct target_ops *) 0); + stop_soon_quietly = 0; } /* -LOCAL FUNCTION + LOCAL FUNCTION - sharedlibrary_command -- handle command to explicitly add library + sharedlibrary_command -- handle command to explicitly add library -SYNOPSIS + SYNOPSIS - static void sharedlibrary_command (char *args, int from_tty) + static void sharedlibrary_command (char *args, int from_tty) -DESCRIPTION + DESCRIPTION -*/ + */ static void -sharedlibrary_command (args, from_tty) -char *args; -int from_tty; +sharedlibrary_command (char *args, int from_tty) { dont_repeat (); solib_add (args, from_tty, (struct target_ops *) 0); } void -_initialize_solib() +_initialize_solib (void) { - add_com ("sharedlibrary", class_files, sharedlibrary_command, "Load shared object library symbols for files matching REGEXP."); - add_info ("sharedlibrary", info_sharedlibrary_command, + add_info ("sharedlibrary", info_sharedlibrary_command, "Status of loaded shared object libraries."); + + add_show_from_set + (add_set_cmd ("auto-solib-add", class_support, var_zinteger, + (char *) &auto_solib_add, + "Set autoloading of shared library symbols.\n\ +If nonzero, symbols from all shared object libraries will be loaded\n\ +automatically when the inferior begins execution or when the dynamic linker\n\ +informs gdb that a new library has been loaded. Otherwise, symbols\n\ +must be loaded manually, using `sharedlibrary'.", + &setlist), + &showlist); +} + + +/* Register that we are able to handle irix5 core file formats. + This really is bfd_target_unknown_flavour */ + +static struct core_fns irix5_core_fns = +{ + bfd_target_unknown_flavour, /* core_flavour */ + default_check_format, /* check_format */ + default_core_sniffer, /* core_sniffer */ + fetch_core_registers, /* core_read_registers */ + NULL /* next */ +}; + +void +_initialize_core_irix5 (void) +{ + add_core_fns (&irix5_core_fns); }