X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fobjfiles.c;h=12a3c47e9e57c9e7700e13ab811fbf656d252a0e;hb=c96451db277044482060eac8629154b76688af3b;hp=9b30c0fb4dc657874a57da494b00339419da6e99;hpb=346168a2c65e34dc6f2d073bbc0d158fb1aaa219;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/objfiles.c b/gdb/objfiles.c index 9b30c0fb4d..12a3c47e9e 100644 --- a/gdb/objfiles.c +++ b/gdb/objfiles.c @@ -26,6 +26,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "symtab.h" #include "symfile.h" #include "objfiles.h" +#include "gdb-stabs.h" +#include "target.h" #include #include @@ -60,6 +62,54 @@ struct objfile *symfile_objfile; /* Main symbol table loaded from */ int mapped_symbol_files; /* Try to use mapped symbol files */ +/* Locate all mappable sections of a BFD file. + objfile_p_char is a char * to get it through + bfd_map_over_sections; we cast it back to its proper type. */ + +static void +add_to_objfile_sections (abfd, asect, objfile_p_char) + bfd *abfd; + sec_ptr asect; + PTR objfile_p_char; +{ + struct objfile *objfile = (struct objfile *) objfile_p_char; + struct obj_section section; + flagword aflag; + + aflag = bfd_get_section_flags (abfd, asect); + /* FIXME, we need to handle BSS segment here...it alloc's but doesn't load */ + if (!(aflag & SEC_LOAD)) + return; + if (0 == bfd_section_size (abfd, asect)) + return; + section.offset = 0; + section.objfile = objfile; + section.sec_ptr = asect; + section.addr = bfd_section_vma (abfd, asect); + section.endaddr = section.addr + bfd_section_size (abfd, asect); + obstack_grow (&objfile->psymbol_obstack, §ion, sizeof(section)); + objfile->sections_end = (struct obj_section *) (((unsigned long) objfile->sections_end) + 1); +} + +/* Builds a section table for OBJFILE. + Returns 0 if OK, 1 on error (in which case bfd_error contains the + error). */ + +int +build_objfile_section_table (objfile) + struct objfile *objfile; +{ + if (objfile->sections) + abort(); + + objfile->sections_end = 0; + bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *)objfile); + objfile->sections = (struct obj_section *) + obstack_finish (&objfile->psymbol_obstack); + objfile->sections_end = objfile->sections + (unsigned long) objfile->sections_end; + return(0); +} + /* Given a pointer to an initialized bfd (ABFD) and a flag that indicates whether or not an objfile is to be mapped (MAPPED), allocate a new objfile struct, fill it in as best we can, link it into the list of all known @@ -71,79 +121,88 @@ allocate_objfile (abfd, mapped) int mapped; { struct objfile *objfile = NULL; - int fd; - void *md; - CORE_ADDR mapto; mapped |= mapped_symbol_files; #if !defined(NO_MMALLOC) && defined(HAVE_MMAP) - - /* If we can support mapped symbol files, try to open/reopen the mapped file - that corresponds to the file from which we wish to read symbols. If the - objfile is to be mapped, we must malloc the structure itself using the - mmap version, and arrange that all memory allocation for the objfile uses - the mmap routines. If we are reusing an existing mapped file, from which - we get our objfile pointer, we have to make sure that we update the - pointers to the alloc/free functions in the obstack, in case these - functions have moved within the current gdb. */ - - fd = open_mapped_file (bfd_get_filename (abfd), bfd_get_mtime (abfd), - mapped); - if (fd >= 0) - { - if (((mapto = map_to_address ()) == 0) || - ((md = mmalloc_attach (fd, (void *) mapto)) == NULL)) - { - (void) close (fd); - } - else if ((objfile = (struct objfile *) mmalloc_getkey (md, 0)) != NULL) - { - /* Update memory corruption handler function addresses. */ - init_malloc (md); - objfile -> md = md; - objfile -> mmfd = fd; - /* Update pointers to functions to *our* copies */ - obstack_chunkfun (&objfile -> psymbol_obstack, xmmalloc); - obstack_freefun (&objfile -> psymbol_obstack, mfree); - obstack_chunkfun (&objfile -> symbol_obstack, xmmalloc); - obstack_freefun (&objfile -> symbol_obstack, mfree); - obstack_chunkfun (&objfile -> type_obstack, xmmalloc); - obstack_freefun (&objfile -> type_obstack, mfree); - /* If already in objfile list, unlink it. */ - unlink_objfile (objfile); - /* Forget things specific to a particular gdb, may have changed. */ - objfile -> sf = NULL; - } - else - { - /* Set up to detect internal memory corruption. MUST be done before - the first malloc. See comments in init_malloc() and mmcheck(). */ - init_malloc (md); - objfile = (struct objfile *) xmmalloc (md, sizeof (struct objfile)); - (void) memset (objfile, 0, sizeof (struct objfile)); - objfile -> md = md; - objfile -> mmfd = fd; - objfile -> flags |= OBJF_MAPPED; - mmalloc_setkey (objfile -> md, 0, objfile); - obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, - xmmalloc, mfree, objfile -> md, - OBSTACK_MMALLOC_LIKE); - obstack_full_begin (&objfile -> symbol_obstack, 0, 0, - xmmalloc, mfree, objfile -> md, - OBSTACK_MMALLOC_LIKE); - obstack_full_begin (&objfile -> type_obstack, 0, 0, - xmmalloc, mfree, objfile -> md, - OBSTACK_MMALLOC_LIKE); - } - } - - if (mapped && (objfile == NULL)) - { - warning ("symbol table for '%s' will not be mapped", - bfd_get_filename (abfd)); - } - + { + + /* If we can support mapped symbol files, try to open/reopen the + mapped file that corresponds to the file from which we wish to + read symbols. If the objfile is to be mapped, we must malloc + the structure itself using the mmap version, and arrange that + all memory allocation for the objfile uses the mmap routines. + If we are reusing an existing mapped file, from which we get + our objfile pointer, we have to make sure that we update the + pointers to the alloc/free functions in the obstack, in case + these functions have moved within the current gdb. */ + + int fd; + + fd = open_mapped_file (bfd_get_filename (abfd), bfd_get_mtime (abfd), + mapped); + if (fd >= 0) + { + CORE_ADDR mapto; + PTR md; + + if (((mapto = map_to_address ()) == 0) || + ((md = mmalloc_attach (fd, (PTR) mapto)) == NULL)) + { + close (fd); + } + else if ((objfile = (struct objfile *) mmalloc_getkey (md, 0)) != NULL) + { + /* Update memory corruption handler function addresses. */ + init_malloc (md); + objfile -> md = md; + objfile -> mmfd = fd; + /* Update pointers to functions to *our* copies */ + obstack_chunkfun (&objfile -> psymbol_obstack, xmmalloc); + obstack_freefun (&objfile -> psymbol_obstack, mfree); + obstack_chunkfun (&objfile -> symbol_obstack, xmmalloc); + obstack_freefun (&objfile -> symbol_obstack, mfree); + obstack_chunkfun (&objfile -> type_obstack, xmmalloc); + obstack_freefun (&objfile -> type_obstack, mfree); + /* If already in objfile list, unlink it. */ + unlink_objfile (objfile); + /* Forget things specific to a particular gdb, may have changed. */ + objfile -> sf = NULL; + } + else + { + + /* Set up to detect internal memory corruption. MUST be + done before the first malloc. See comments in + init_malloc() and mmcheck(). */ + + init_malloc (md); + + objfile = (struct objfile *) + xmmalloc (md, sizeof (struct objfile)); + memset (objfile, 0, sizeof (struct objfile)); + objfile -> md = md; + objfile -> mmfd = fd; + objfile -> flags |= OBJF_MAPPED; + mmalloc_setkey (objfile -> md, 0, objfile); + obstack_specify_allocation_with_arg (&objfile -> psymbol_obstack, + 0, 0, xmmalloc, mfree, + objfile -> md); + obstack_specify_allocation_with_arg (&objfile -> symbol_obstack, + 0, 0, xmmalloc, mfree, + objfile -> md); + obstack_specify_allocation_with_arg (&objfile -> type_obstack, + 0, 0, xmmalloc, mfree, + objfile -> md); + } + } + + if (mapped && (objfile == NULL)) + { + warning ("symbol table for '%s' will not be mapped", + bfd_get_filename (abfd)); + } + } #else /* defined(NO_MMALLOC) || !defined(HAVE_MMAP) */ if (mapped) @@ -166,15 +225,14 @@ allocate_objfile (abfd, mapped) if (objfile == NULL) { objfile = (struct objfile *) xmalloc (sizeof (struct objfile)); - (void) memset (objfile, 0, sizeof (struct objfile)); + memset (objfile, 0, sizeof (struct objfile)); objfile -> md = NULL; - obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, xmalloc, free, - (void *) 0, 0); - obstack_full_begin (&objfile -> symbol_obstack, 0, 0, xmalloc, free, - (void *) 0, 0); - obstack_full_begin (&objfile -> type_obstack, 0, 0, xmalloc, free, - (void *) 0, 0); - + obstack_specify_allocation (&objfile -> psymbol_obstack, 0, 0, xmalloc, + free); + obstack_specify_allocation (&objfile -> symbol_obstack, 0, 0, xmalloc, + free); + obstack_specify_allocation (&objfile -> type_obstack, 0, 0, xmalloc, + free); } /* Update the per-objfile information that comes from the bfd, ensuring @@ -189,6 +247,14 @@ allocate_objfile (abfd, mapped) objfile -> name = mstrsave (objfile -> md, bfd_get_filename (abfd)); objfile -> mtime = bfd_get_mtime (abfd); + /* Build section table. */ + + if (build_objfile_section_table (objfile)) + { + error ("Can't find the file sections in `%s': %s", + objfile -> name, bfd_errmsg (bfd_error)); + } + /* Push this file onto the head of the linked list of other such files. */ objfile -> next = object_files; @@ -248,9 +314,6 @@ void free_objfile (objfile) struct objfile *objfile; { - struct objfile *ofp; - int mmfd; - /* First do any symbol file specific actions required when we are finished with a particular symbol file. Note that if the objfile is using reusable symbol information (via mmalloc) then each of @@ -283,10 +346,19 @@ free_objfile (objfile) is unknown, but we play it safe for now and keep each action until it is shown to be no longer needed. */ - clear_symtab_users_once (); #if defined (CLEAR_SOLIB) CLEAR_SOLIB (); + /* CLEAR_SOLIB closes the bfd's for any shared libraries. But + the to_sections for a core file might refer to those bfd's. So + detach any core file. */ + { + struct target_ops *t = find_core_target (); + if (t != NULL) + (t->to_detach) (NULL, 0); + } #endif + /* I *think* all our callers call clear_symtab_users. If so, no need + to call this here. */ clear_pc_function_cache (); /* The last thing we do is free the objfile struct itself for the @@ -300,10 +372,12 @@ free_objfile (objfile) { /* Remember the fd so we can close it. We can't close it before doing the detach, and after the detach the objfile is gone. */ + int mmfd; + mmfd = objfile -> mmfd; mmalloc_detach (objfile -> md); objfile = NULL; - (void) close (mmfd); + close (mmfd); } #endif /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */ @@ -331,7 +405,7 @@ free_objfile (objfile) } -/* Free all the object files at once. */ +/* Free all the object files at once and clean up their users. */ void free_all_objfiles () @@ -342,8 +416,128 @@ free_all_objfiles () { free_objfile (objfile); } + clear_symtab_users (); } - + +/* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS + entries in new_offsets. */ +void +objfile_relocate (objfile, new_offsets) + struct objfile *objfile; + struct section_offsets *new_offsets; +{ + struct section_offsets *delta = (struct section_offsets *) alloca + (sizeof (struct section_offsets) + + objfile->num_sections * sizeof (delta->offsets)); + + { + int i; + int something_changed = 0; + for (i = 0; i < objfile->num_sections; ++i) + { + ANOFFSET (delta, i) = + ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i); + if (ANOFFSET (delta, i) != 0) + something_changed = 1; + } + if (!something_changed) + return; + } + + /* OK, get all the symtabs. */ + { + struct symtab *s; + + for (s = objfile->symtabs; s; s = s->next) + { + struct linetable *l; + struct blockvector *bv; + int i; + + /* First the line table. */ + l = LINETABLE (s); + if (l) + { + for (i = 0; i < l->nitems; ++i) + l->item[i].pc += ANOFFSET (delta, s->block_line_section); + } + + /* Don't relocate a shared blockvector more than once. */ + if (!s->primary) + continue; + + bv = BLOCKVECTOR (s); + for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i) + { + struct block *b; + int j; + + b = BLOCKVECTOR_BLOCK (bv, i); + BLOCK_START (b) += ANOFFSET (delta, s->block_line_section); + BLOCK_END (b) += ANOFFSET (delta, s->block_line_section); + + for (j = 0; j < BLOCK_NSYMS (b); ++j) + { + struct symbol *sym = BLOCK_SYM (b, j); + /* The RS6000 code from which this was taken skipped + any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE. + But I'm leaving out that test, on the theory that + they can't possibly pass the tests below. */ + if ((SYMBOL_CLASS (sym) == LOC_LABEL + || SYMBOL_CLASS (sym) == LOC_STATIC) + && SYMBOL_SECTION (sym) >= 0) + { + SYMBOL_VALUE_ADDRESS (sym) += + ANOFFSET (delta, SYMBOL_SECTION (sym)); + } + } + } + } + } + + { + struct partial_symtab *p; + + ALL_OBJFILE_PSYMTABS (objfile, p) + { + /* FIXME: specific to symbol readers which use gdb-stabs.h. + We can only get away with it since objfile_relocate is only + used on XCOFF, which lacks psymtabs, and for gdb-stabs.h + targets. */ + p->textlow += ANOFFSET (delta, SECT_OFF_TEXT); + p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT); + } + } + + { + struct partial_symbol *psym; + + for (psym = objfile->global_psymbols.list; + psym < objfile->global_psymbols.next; + psym++) + if (SYMBOL_SECTION (psym) >= 0) + SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym)); + for (psym = objfile->static_psymbols.list; + psym < objfile->static_psymbols.next; + psym++) + if (SYMBOL_SECTION (psym) >= 0) + SYMBOL_VALUE_ADDRESS (psym) += ANOFFSET (delta, SYMBOL_SECTION (psym)); + } + + { + struct minimal_symbol *msym; + ALL_OBJFILE_MSYMBOLS (objfile, msym) + if (SYMBOL_SECTION (msym) >= 0) + SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym)); + } + + { + int i; + for (i = 0; i < objfile->num_sections; ++i) + ANOFFSET (objfile->section_offsets, i) = ANOFFSET (new_offsets, i); + } +} + /* Many places in gdb want to test just to see if we have any partial symbols available. This function returns zero if none are currently available, nonzero otherwise. */ @@ -437,14 +631,15 @@ open_existing_mapped_file (symsfilename, mtime, mapped) { if (!mapped) { - warning ("mapped symbol file `%s' is out of date", symsfilename); + warning ("mapped symbol file `%s' is out of date, ignored it", + symsfilename); } } else if ((fd = open (symsfilename, O_RDWR)) < 0) { if (error_pre_print) { - printf (error_pre_print); + printf_unfiltered (error_pre_print); } print_sys_errmsg (symsfilename, errno); } @@ -514,7 +709,7 @@ open_mapped_file (filename, mtime, mapped) { if (error_pre_print) { - printf (error_pre_print); + printf_unfiltered (error_pre_print); } print_sys_errmsg (symsfilename, errno); } @@ -571,3 +766,20 @@ map_to_address () #endif /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */ +/* Returns a section whose range includes PC or NULL if none found. */ + +struct obj_section * +find_pc_section(pc) + CORE_ADDR pc; +{ + struct obj_section *s; + struct objfile *objfile; + + ALL_OBJFILES (objfile) + for (s = objfile->sections; s < objfile->sections_end; ++s) + if (s->addr <= pc + && pc < s->endaddr) + return(s); + + return(NULL); +}