X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Felfread.c;h=9ddf3d489b8f03535ae9ac485992d80677d06881;hb=1b831c9308be215e465dac7079ba18aca8d2e68f;hp=2669e9766c2bf26660ff14cce3c9811cbef8aa2b;hpb=e01b4200251c5922f8295cca58b23f316fb779a4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/elfread.c b/gdb/elfread.c index 2669e9766c..9ddf3d489b 100644 --- a/gdb/elfread.c +++ b/gdb/elfread.c @@ -1,22 +1,25 @@ /* Read ELF (Executable and Linking Format) object files for GDB. - Copyright 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc. + Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, + 2001, 2002 + Free Software Foundation, Inc. Written by Fred Fish at Cygnus Support. -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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 "bfd.h" @@ -32,60 +35,24 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "complaints.h" #include "demangle.h" +extern void _initialize_elfread (void); + /* The struct elfinfo is available only during ELF symbol table and - psymtab reading. It is destroyed at the complation of psymtab-reading. + psymtab reading. It is destroyed at the completion of psymtab-reading. It's local to elf_symfile_read. */ -struct elfinfo { - file_ptr dboffset; /* Offset to dwarf debug section */ - unsigned int dbsize; /* Size of dwarf debug section */ - file_ptr lnoffset; /* Offset to dwarf line number section */ - unsigned int lnsize; /* Size of dwarf line number section */ - asection *stabsect; /* Section pointer for .stab section */ - asection *stabindexsect; /* Section pointer for .stab.index section */ - asection *mdebugsect; /* Section pointer for .mdebug section */ -}; - -/* Various things we might complain about... */ - -struct complaint section_info_complaint = - {"elf/stab section information %s without a preceding file symbol", 0, 0}; - -struct complaint section_info_dup_complaint = - {"duplicated elf/stab section information for %s", 0, 0}; +struct elfinfo + { + file_ptr dboffset; /* Offset to dwarf debug section */ + unsigned int dbsize; /* Size of dwarf debug section */ + file_ptr lnoffset; /* Offset to dwarf line number section */ + unsigned int lnsize; /* Size of dwarf line number section */ + asection *stabsect; /* Section pointer for .stab section */ + asection *stabindexsect; /* Section pointer for .stab.index section */ + asection *mdebugsect; /* Section pointer for .mdebug section */ + }; -struct complaint stab_info_mismatch_complaint = - {"elf/stab section information missing for %s", 0, 0}; - -struct complaint stab_info_questionable_complaint = - {"elf/stab section information questionable for %s", 0, 0}; - -static void -elf_symfile_init PARAMS ((struct objfile *)); - -static void -elf_new_init PARAMS ((struct objfile *)); - -static void -elf_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int)); - -static void -elf_symfile_finish PARAMS ((struct objfile *)); - -static void -elf_symtab_read PARAMS ((bfd *, CORE_ADDR, struct objfile *, int)); - -static void -free_elfinfo PARAMS ((void *)); - -static struct minimal_symbol * -record_minimal_symbol_and_info PARAMS ((char *, CORE_ADDR, - enum minimal_symbol_type, char *, - asection *bfd_section, - struct objfile *)); - -static void -elf_locate_sections PARAMS ((bfd *, asection *, void *)); +static void free_elfinfo (void *); /* We are called once per section from elf_symfile_read. We need to examine each section we are passed, check to see @@ -107,43 +74,39 @@ elf_locate_sections PARAMS ((bfd *, asection *, void *)); -kingdon). */ static void -elf_locate_sections (ignore_abfd, sectp, eip) - bfd *ignore_abfd; - asection *sectp; - PTR eip; +elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip) { register struct elfinfo *ei; ei = (struct elfinfo *) eip; - if (STREQ (sectp -> name, ".debug")) + if (STREQ (sectp->name, ".debug")) { - ei -> dboffset = sectp -> filepos; - ei -> dbsize = bfd_get_section_size_before_reloc (sectp); + ei->dboffset = sectp->filepos; + ei->dbsize = bfd_get_section_size_before_reloc (sectp); } - else if (STREQ (sectp -> name, ".line")) + else if (STREQ (sectp->name, ".line")) { - ei -> lnoffset = sectp -> filepos; - ei -> lnsize = bfd_get_section_size_before_reloc (sectp); + ei->lnoffset = sectp->filepos; + ei->lnsize = bfd_get_section_size_before_reloc (sectp); } - else if (STREQ (sectp -> name, ".stab")) + else if (STREQ (sectp->name, ".stab")) { - ei -> stabsect = sectp; + ei->stabsect = sectp; } - else if (STREQ (sectp -> name, ".stab.index")) + else if (STREQ (sectp->name, ".stab.index")) { - ei -> stabindexsect = sectp; + ei->stabindexsect = sectp; } - else if (STREQ (sectp -> name, ".mdebug")) + else if (STREQ (sectp->name, ".mdebug")) { - ei -> mdebugsect = sectp; + ei->mdebugsect = sectp; } } -#if 0 /* Currently unused */ +#if 0 /* Currently unused */ char * -elf_interpreter (abfd) - bfd *abfd; +elf_interpreter (bfd *abfd) { sec_ptr interp_sec; unsigned size; @@ -154,7 +117,7 @@ elf_interpreter (abfd) { size = bfd_section_size (abfd, interp_sec); interp = alloca (size); - if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0, + if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr) 0, size)) { interp = savestring (interp, size - 1); @@ -170,77 +133,43 @@ elf_interpreter (abfd) #endif static struct minimal_symbol * -record_minimal_symbol_and_info (name, address, ms_type, info, bfd_section, - objfile) - char *name; - CORE_ADDR address; - enum minimal_symbol_type ms_type; - char *info; /* FIXME, is this really char *? */ - asection *bfd_section; - struct objfile *objfile; +record_minimal_symbol_and_info (char *name, CORE_ADDR address, + enum minimal_symbol_type ms_type, char *info, /* FIXME, is this really char *? */ + asection *bfd_section, struct objfile *objfile) { - int section; - - /* Guess the section from the type. This is likely to be wrong in - some cases. */ - switch (ms_type) - { - case mst_text: - case mst_file_text: - section = SECT_OFF_TEXT; -#ifdef SMASH_TEXT_ADDRESS - SMASH_TEXT_ADDRESS (address); -#endif - break; - case mst_data: - case mst_file_data: - section = SECT_OFF_DATA; - break; - case mst_bss: - case mst_file_bss: - section = SECT_OFF_BSS; - break; - default: - section = -1; - break; - } + if (ms_type == mst_text || ms_type == mst_file_text) + address = SMASH_TEXT_ADDRESS (address); return prim_record_minimal_symbol_and_info - (name, address, ms_type, info, section, bfd_section, objfile); + (name, address, ms_type, info, bfd_section->index, bfd_section, objfile); } /* -LOCAL FUNCTION + LOCAL FUNCTION - elf_symtab_read -- read the symbol table of an ELF file + elf_symtab_read -- read the symbol table of an ELF file -SYNOPSIS + SYNOPSIS - void elf_symtab_read (bfd *abfd, CORE_ADDR addr, - struct objfile *objfile, int dynamic) + void elf_symtab_read (struct objfile *objfile, int dynamic) -DESCRIPTION + DESCRIPTION - Given an open bfd, a base address to relocate symbols to, and a - flag that specifies whether or not this bfd is for an executable - or not (may be shared library for example), add all the global - function and data symbols to the minimal symbol table. + Given an objfile and a flag that specifies whether or not the objfile + is for an executable or not (may be shared library for example), add + all the global function and data symbols to the minimal symbol table. - In stabs-in-ELF, as implemented by Sun, there are some local symbols - defined in the ELF symbol table, which can be used to locate - the beginnings of sections from each ".o" file that was linked to - form the executable objfile. We gather any such info and record it - in data structures hung off the objfile's private data. + In stabs-in-ELF, as implemented by Sun, there are some local symbols + defined in the ELF symbol table, which can be used to locate + the beginnings of sections from each ".o" file that was linked to + form the executable objfile. We gather any such info and record it + in data structures hung off the objfile's private data. -*/ + */ static void -elf_symtab_read (abfd, addr, objfile, dynamic) - bfd *abfd; - CORE_ADDR addr; - struct objfile *objfile; - int dynamic; +elf_symtab_read (struct objfile *objfile, int dynamic) { long storage_needed; asymbol *sym; @@ -250,6 +179,7 @@ elf_symtab_read (abfd, addr, objfile, dynamic) int index; struct cleanup *back_to; CORE_ADDR symaddr; + CORE_ADDR offset; enum minimal_symbol_type ms_type; /* If sectinfo is nonNULL, it contains section info that should end up filed in the objfile. */ @@ -263,11 +193,11 @@ elf_symtab_read (abfd, addr, objfile, dynamic) #endif struct dbx_symfile_info *dbx = objfile->sym_stab_info; unsigned long size; - int stripped = (bfd_get_symcount (abfd) == 0); - + int stripped = (bfd_get_symcount (objfile->obfd) == 0); + if (dynamic) { - storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); + storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd); /* Nothing to be done if there is no dynamic symtab. */ if (storage_needed < 0) @@ -275,54 +205,56 @@ elf_symtab_read (abfd, addr, objfile, dynamic) } else { - storage_needed = bfd_get_symtab_upper_bound (abfd); + storage_needed = bfd_get_symtab_upper_bound (objfile->obfd); if (storage_needed < 0) - error ("Can't read symbols from %s: %s", bfd_get_filename (abfd), + error ("Can't read symbols from %s: %s", bfd_get_filename (objfile->obfd), bfd_errmsg (bfd_get_error ())); } if (storage_needed > 0) { symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (free, symbol_table); + back_to = make_cleanup (xfree, symbol_table); if (dynamic) - number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, + number_of_symbols = bfd_canonicalize_dynamic_symtab (objfile->obfd, symbol_table); else - number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); + number_of_symbols = bfd_canonicalize_symtab (objfile->obfd, symbol_table); if (number_of_symbols < 0) - error ("Can't read symbols from %s: %s", bfd_get_filename (abfd), + error ("Can't read symbols from %s: %s", bfd_get_filename (objfile->obfd), bfd_errmsg (bfd_get_error ())); + for (i = 0; i < number_of_symbols; i++) { sym = symbol_table[i]; - if (sym -> name == NULL || *sym -> name == '\0') + if (sym->name == NULL || *sym->name == '\0') { /* Skip names that don't exist (shouldn't happen), or names - that are null strings (may happen). */ + that are null strings (may happen). */ continue; } + offset = ANOFFSET (objfile->section_offsets, sym->section->index); if (dynamic - && sym -> section == &bfd_und_section - && (sym -> flags & BSF_FUNCTION)) + && sym->section == &bfd_und_section + && (sym->flags & BSF_FUNCTION)) { struct minimal_symbol *msym; /* Symbol is a reference to a function defined in - a shared library. - If its value is non zero then it is usually the address - of the corresponding entry in the procedure linkage table, - relative to the base address. - If its value is zero then the dynamic linker has to resolve - the symbol. We are unable to find any meaningful address - for this symbol in the executable file, so we skip it. */ - symaddr = sym -> value; + a shared library. + If its value is non zero then it is usually the address + of the corresponding entry in the procedure linkage table, + plus the desired section offset. + If its value is zero then the dynamic linker has to resolve + the symbol. We are unable to find any meaningful address + for this symbol in the executable file, so we skip it. */ + symaddr = sym->value; if (symaddr == 0) continue; - symaddr += addr; + symaddr += offset; msym = record_minimal_symbol_and_info - ((char *) sym -> name, symaddr, - mst_solib_trampoline, NULL, sym -> section, objfile); + ((char *) sym->name, symaddr, + mst_solib_trampoline, NULL, sym->section, objfile); #ifdef SOFUN_ADDRESS_MAYBE_MISSING if (msym != NULL) msym->filename = filesymname; @@ -335,47 +267,47 @@ elf_symtab_read (abfd, addr, objfile, dynamic) of the main symbol table. */ if (dynamic && !stripped) continue; - if (sym -> flags & BSF_FILE) + if (sym->flags & BSF_FILE) { /* STT_FILE debugging symbol that helps stabs-in-elf debugging. - Chain any old one onto the objfile; remember new sym. */ + Chain any old one onto the objfile; remember new sym. */ if (sectinfo != NULL) { - sectinfo -> next = dbx -> stab_section_info; - dbx -> stab_section_info = sectinfo; + sectinfo->next = dbx->stab_section_info; + dbx->stab_section_info = sectinfo; sectinfo = NULL; } filesym = sym; #ifdef SOFUN_ADDRESS_MAYBE_MISSING filesymname = - obsavestring ((char *)filesym->name, strlen (filesym->name), + obsavestring ((char *) filesym->name, strlen (filesym->name), &objfile->symbol_obstack); #endif } - else if (sym -> flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK)) + else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK)) { struct minimal_symbol *msym; /* Select global/local/weak symbols. Note that bfd puts abs - symbols in their own section, so all symbols we are - interested in will have a section. */ + symbols in their own section, so all symbols we are + interested in will have a section. */ /* Bfd symbols are section relative. */ - symaddr = sym -> value + sym -> section -> vma; - /* Relocate all non-absolute symbols by base address. */ - if (sym -> section != &bfd_abs_section) + symaddr = sym->value + sym->section->vma; + /* Relocate all non-absolute symbols by the section offset. */ + if (sym->section != &bfd_abs_section) { - symaddr += addr; + symaddr += offset; } /* For non-absolute symbols, use the type of the section - they are relative to, to intuit text/data. Bfd provides - no way of figuring this out for absolute symbols. */ - if (sym -> section == &bfd_abs_section) + they are relative to, to intuit text/data. Bfd provides + no way of figuring this out for absolute symbols. */ + if (sym->section == &bfd_abs_section) { /* This is a hack to get the minimal symbol type - right for Irix 5, which has absolute adresses + right for Irix 5, which has absolute addresses with special section indices for dynamic symbols. */ unsigned short shndx = - ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx; + ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx; switch (shndx) { @@ -393,52 +325,42 @@ elf_symtab_read (abfd, addr, objfile, dynamic) } /* If it is an Irix dynamic symbol, skip section name - symbols, relocate all others. */ + symbols, relocate all others by section offset. */ if (ms_type != mst_abs) { if (sym->name[0] == '.') continue; - symaddr += addr; + symaddr += offset; } } - else if (sym -> section -> flags & SEC_CODE) + else if (sym->section->flags & SEC_CODE) { - if (sym -> flags & BSF_GLOBAL) + if (sym->flags & BSF_GLOBAL) { ms_type = mst_text; } else if ((sym->name[0] == '.' && sym->name[1] == 'L') - || ((sym -> flags & BSF_LOCAL) + || ((sym->flags & BSF_LOCAL) && sym->name[0] == '$' && sym->name[1] == 'L')) - /* Looks like a compiler-generated label. Skip it. - The assembler should be skipping these (to keep - executables small), but apparently with gcc on the - delta m88k SVR4, it loses. So to have us check too - should be harmless (but I encourage people to fix this - in the assembler instead of adding checks here). */ + /* Looks like a compiler-generated label. Skip + it. The assembler should be skipping these (to + keep executables small), but apparently with + gcc on the (deleted) delta m88k SVR4, it loses. + So to have us check too should be harmless (but + I encourage people to fix this in the assembler + instead of adding checks here). */ continue; -#ifdef HARRIS_TARGET - else if (sym->name[0] == '.' && sym->name[1] == '.') - { - /* Looks like a Harris compiler generated label for the - purpose of marking instructions that are relevant to - DWARF dies. The assembler can't get rid of these - because they are relocatable addresses that the - linker needs to resolve. */ - continue; - } -#endif else { ms_type = mst_file_text; } } - else if (sym -> section -> flags & SEC_ALLOC) + else if (sym->section->flags & SEC_ALLOC) { - if (sym -> flags & BSF_GLOBAL) + if (sym->flags & (BSF_GLOBAL | BSF_WEAK)) { - if (sym -> section -> flags & SEC_LOAD) + if (sym->section->flags & SEC_LOAD) { ms_type = mst_data; } @@ -447,25 +369,25 @@ elf_symtab_read (abfd, addr, objfile, dynamic) ms_type = mst_bss; } } - else if (sym -> flags & BSF_LOCAL) + else if (sym->flags & BSF_LOCAL) { /* Named Local variable in a Data section. Check its - name for stabs-in-elf. The STREQ macro checks the - first character inline, so we only actually do a - strcmp function call on names that start with 'B' - or 'D' */ + name for stabs-in-elf. The STREQ macro checks the + first character inline, so we only actually do a + strcmp function call on names that start with 'B' + or 'D' */ index = SECT_OFF_MAX; - if (STREQ ("Bbss.bss", sym -> name)) + if (STREQ ("Bbss.bss", sym->name)) { - index = SECT_OFF_BSS; + index = SECT_OFF_BSS (objfile); } - else if (STREQ ("Ddata.data", sym -> name)) + else if (STREQ ("Ddata.data", sym->name)) { - index = SECT_OFF_DATA; + index = SECT_OFF_DATA (objfile); } - else if (STREQ ("Drodata.rodata", sym -> name)) + else if (STREQ ("Drodata.rodata", sym->name)) { - index = SECT_OFF_RODATA; + index = SECT_OFF_RODATA (objfile); } if (index != SECT_OFF_MAX) { @@ -474,39 +396,52 @@ elf_symtab_read (abfd, addr, objfile, dynamic) if (sectinfo == NULL) { sectinfo = (struct stab_section_info *) - xmmalloc (objfile -> md, sizeof (*sectinfo)); - memset ((PTR) sectinfo, 0, sizeof (*sectinfo)); + xmmalloc (objfile->md, sizeof (*sectinfo)); + memset (sectinfo, 0, + sizeof (*sectinfo)); if (filesym == NULL) { - complain (§ion_info_complaint, - sym -> name); + complaint (&symfile_complaints, + "elf/stab section information %s without a preceding file symbol", + sym->name); } else { - sectinfo -> filename = - (char *) filesym -> name; + sectinfo->filename = + (char *) filesym->name; } } - if (sectinfo -> sections[index] != 0) - { - complain (§ion_info_dup_complaint, - sectinfo -> filename); + if (index != -1) + { + if (sectinfo->sections[index] != 0) + { + complaint (&symfile_complaints, + "duplicated elf/stab section information for %s", + sectinfo->filename); + } } + else + internal_error (__FILE__, __LINE__, + "Section index uninitialized."); /* Bfd symbols are section relative. */ - symaddr = sym -> value + sym -> section -> vma; - /* Relocate non-absolute symbols by base address. */ - if (sym -> section != &bfd_abs_section) + symaddr = sym->value + sym->section->vma; + /* Relocate non-absolute symbols by the section offset. */ + if (sym->section != &bfd_abs_section) { - symaddr += addr; + symaddr += offset; } - sectinfo -> sections[index] = symaddr; + if (index != -1) + sectinfo->sections[index] = symaddr; + else + internal_error (__FILE__, __LINE__, + "Section index uninitialized."); /* The special local symbols don't go in the minimal symbol table, so ignore this one. */ continue; } /* Not a special stabs-in-elf symbol, do regular - symbol processing. */ - if (sym -> section -> flags & SEC_LOAD) + symbol processing. */ + if (sym->section->flags & SEC_LOAD) { ms_type = mst_file_data; } @@ -527,20 +462,18 @@ elf_symtab_read (abfd, addr, objfile, dynamic) hob with actions like finding what function the PC is in. Ignore them if they aren't text, data, or bss. */ /* ms_type = mst_unknown; */ - continue; /* Skip this symbol. */ + continue; /* Skip this symbol. */ } /* Pass symbol size field in via BFD. FIXME!!! */ - size = ((elf_symbol_type *) sym) -> internal_elf_sym.st_size; + size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size; msym = record_minimal_symbol_and_info - ((char *) sym -> name, symaddr, - ms_type, (PTR) size, sym -> section, objfile); + ((char *) sym->name, symaddr, + ms_type, (void *) size, sym->section, objfile); #ifdef SOFUN_ADDRESS_MAYBE_MISSING if (msym != NULL) msym->filename = filesymname; #endif -#ifdef ELF_MAKE_MSYMBOL_SPECIAL - ELF_MAKE_MSYMBOL_SPECIAL(sym,msym); -#endif + ELF_MAKE_MSYMBOL_SPECIAL (sym, msym); } } do_cleanups (back_to); @@ -580,10 +513,7 @@ elf_symtab_read (abfd, addr, objfile, dynamic) capability even for files compiled without -g. */ static void -elf_symfile_read (objfile, section_offsets, mainline) - struct objfile *objfile; - struct section_offsets *section_offsets; - int mainline; +elf_symfile_read (struct objfile *objfile, int mainline) { bfd *abfd = objfile->obfd; struct elfinfo ei; @@ -591,27 +521,25 @@ elf_symfile_read (objfile, section_offsets, mainline) CORE_ADDR offset; init_minimal_symbol_collection (); - back_to = make_cleanup (discard_minimal_symbols, 0); + back_to = make_cleanup_discard_minimal_symbols (); memset ((char *) &ei, 0, sizeof (ei)); /* Allocate struct to keep track of the symfile */ objfile->sym_stab_info = (struct dbx_symfile_info *) - xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info)); + xmmalloc (objfile->md, sizeof (struct dbx_symfile_info)); memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info)); - make_cleanup (free_elfinfo, (PTR) objfile); + make_cleanup (free_elfinfo, (void *) objfile); /* Process the normal ELF symbol table first. This may write some chain of info into the dbx_symfile_info in objfile->sym_stab_info, which can later be used by elfstab_offset_sections. */ - /* FIXME, should take a section_offsets param, not just an offset. */ - offset = ANOFFSET (section_offsets, 0); - elf_symtab_read (abfd, offset, objfile, 0); + elf_symtab_read (objfile, 0); /* Add the dynamic symbols. */ - elf_symtab_read (abfd, offset, objfile, 1); + elf_symtab_read (objfile, 1); /* Now process debugging information, which is contained in special ELF sections. */ @@ -626,7 +554,7 @@ elf_symfile_read (objfile, section_offsets, mainline) } /* We first have to find them... */ - bfd_map_over_sections (abfd, elf_locate_sections, (PTR) &ei); + bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei); /* ELF debugging information is inserted into the psymtab in the order of least informative first - most informative last. Since @@ -645,24 +573,22 @@ elf_symfile_read (objfile, section_offsets, mainline) const struct ecoff_debug_swap *swap; /* .mdebug section, presumably holding ECOFF debugging - information. */ + information. */ swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; if (swap) - elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect, - section_offsets); + elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect); } if (ei.stabsect) { asection *str_sect; /* Stab sections have an associated string table that looks like - a separate section. */ + a separate section. */ str_sect = bfd_get_section_by_name (abfd, ".stabstr"); /* FIXME should probably warn about a stab section without a stabstr. */ if (str_sect) elfstab_build_psymtabs (objfile, - section_offsets, mainline, ei.stabsect->filepos, bfd_section_size (abfd, ei.stabsect), @@ -672,17 +598,20 @@ elf_symfile_read (objfile, section_offsets, mainline) if (dwarf2_has_info (abfd)) { /* DWARF 2 sections */ - dwarf2_build_psymtabs (objfile, section_offsets, mainline); + dwarf2_build_psymtabs (objfile, mainline); } else if (ei.dboffset && ei.lnoffset) { /* DWARF sections */ dwarf_build_psymtabs (objfile, - section_offsets, mainline, + mainline, ei.dboffset, ei.dbsize, ei.lnoffset, ei.lnsize); } + if (DWARF2_BUILD_FRAME_INFO_P ()) + DWARF2_BUILD_FRAME_INFO(objfile); + /* Install any minimal symbols that have been collected as the current minimal symbols for this objfile. */ @@ -695,10 +624,9 @@ elf_symfile_read (objfile, section_offsets, mainline) stab_section_info's, that might be dangling from it. */ static void -free_elfinfo (objp) - PTR objp; +free_elfinfo (void *objp) { - struct objfile *objfile = (struct objfile *)objp; + struct objfile *objfile = (struct objfile *) objp; struct dbx_symfile_info *dbxinfo = objfile->sym_stab_info; struct stab_section_info *ssi, *nssi; @@ -706,7 +634,7 @@ free_elfinfo (objp) while (ssi) { nssi = ssi->next; - mfree (objfile->md, ssi); + xmfree (objfile->md, ssi); ssi = nssi; } @@ -721,8 +649,7 @@ free_elfinfo (objp) We reinitialize buildsym, since we may be reading stabs from an ELF file. */ static void -elf_new_init (ignore) - struct objfile *ignore; +elf_new_init (struct objfile *ignore) { stabsread_new_init (); buildsym_new_init (); @@ -734,12 +661,11 @@ elf_new_init (ignore) objfile struct from the global list of known objfiles. */ static void -elf_symfile_finish (objfile) - struct objfile *objfile; +elf_symfile_finish (struct objfile *objfile) { - if (objfile -> sym_stab_info != NULL) + if (objfile->sym_stab_info != NULL) { - mfree (objfile -> md, objfile -> sym_stab_info); + xmfree (objfile->md, objfile->sym_stab_info); } } @@ -753,8 +679,7 @@ elf_symfile_finish (objfile) just a stub. */ static void -elf_symfile_init (objfile) - struct objfile *objfile; +elf_symfile_init (struct objfile *objfile) { /* ELF objects may be reordered, so set OBJF_REORDERED. If we find this causes a significant slowdown in gdb then we could @@ -771,9 +696,7 @@ elf_symfile_init (objfile) with wierd names. Go get 'em when needed. */ void -elfstab_offset_sections (objfile, pst) - struct objfile *objfile; - struct partial_symtab *pst; +elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst) { char *filename = pst->filename; struct dbx_symfile_info *dbx = objfile->sym_stab_info; @@ -785,7 +708,7 @@ elfstab_offset_sections (objfile, pst) /* The ELF symbol info doesn't include path names, so strip the path (if any) from the psymtab filename. */ while (0 != (p = strchr (filename, '/'))) - filename = p+1; + filename = p + 1; /* FIXME: This linear search could speed up significantly if it was chained in the right order to match how we search it, @@ -799,13 +722,14 @@ elfstab_offset_sections (objfile, pst) (from different directories) with the same name. */ if (0 == maybe->found) break; - questionable = maybe; /* Might use it later. */ + questionable = maybe; /* Might use it later. */ } } if (maybe == 0 && questionable != 0) { - complain (&stab_info_questionable_complaint, filename); + complaint (&symfile_complaints, + "elf/stab section information questionable for %s", filename); maybe = questionable; } @@ -814,18 +738,16 @@ elfstab_offset_sections (objfile, pst) /* Found it! Allocate a new psymtab struct, and fill it in. */ maybe->found++; pst->section_offsets = (struct section_offsets *) - obstack_alloc (&objfile -> psymbol_obstack, - sizeof (struct section_offsets) + - sizeof (pst->section_offsets->offsets) * (SECT_OFF_MAX-1)); - + obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS); for (i = 0; i < SECT_OFF_MAX; i++) - ANOFFSET (pst->section_offsets, i) = maybe->sections[i]; + (pst->section_offsets)->offsets[i] = maybe->sections[i]; return; } /* We were unable to find any offsets for this file. Complain. */ - if (dbx->stab_section_info) /* If there *is* any info, */ - complain (&stab_info_mismatch_complaint, filename); + if (dbx->stab_section_info) /* If there *is* any info, */ + complaint (&symfile_complaints, + "elf/stab section information missing for %s", filename); } /* Register that we are able to handle ELF object file formats. */ @@ -833,17 +755,16 @@ elfstab_offset_sections (objfile, pst) static struct sym_fns elf_sym_fns = { bfd_target_elf_flavour, - elf_new_init, /* sym_new_init: init anything gbl to entire symtab */ - elf_symfile_init, /* sym_init: read initial info, setup for sym_read() */ - elf_symfile_read, /* sym_read: read a symbol file into symtab */ - elf_symfile_finish, /* sym_finish: finished with file, cleanup */ - default_symfile_offsets, - /* sym_offsets: Translate ext. to int. relocation */ - NULL /* next: pointer to next struct sym_fns */ + elf_new_init, /* sym_new_init: init anything gbl to entire symtab */ + elf_symfile_init, /* sym_init: read initial info, setup for sym_read() */ + elf_symfile_read, /* sym_read: read a symbol file into symtab */ + elf_symfile_finish, /* sym_finish: finished with file, cleanup */ + default_symfile_offsets, /* sym_offsets: Translate ext. to int. relocation */ + NULL /* next: pointer to next struct sym_fns */ }; void -_initialize_elfread () +_initialize_elfread (void) { add_symtab_fns (&elf_sym_fns); }