1 /* Read ELF (Executable and Linking Format) object files for GDB.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
30 #include "stabsread.h"
31 #include "gdb-stabs.h"
32 #include "complaints.h"
35 /* The struct elfinfo is available only during ELF symbol table and
36 psymtab reading. It is destroyed at the complation of psymtab-reading.
37 It's local to elf_symfile_read. */
40 file_ptr dboffset; /* Offset to dwarf debug section */
41 unsigned int dbsize; /* Size of dwarf debug section */
42 file_ptr lnoffset; /* Offset to dwarf line number section */
43 unsigned int lnsize; /* Size of dwarf line number section */
44 asection *stabsect; /* Section pointer for .stab section */
45 asection *stabindexsect; /* Section pointer for .stab.index section */
46 asection *mdebugsect; /* Section pointer for .mdebug section */
49 /* Various things we might complain about... */
51 struct complaint section_info_complaint =
52 {"elf/stab section information %s without a preceding file symbol", 0, 0};
54 struct complaint section_info_dup_complaint =
55 {"duplicated elf/stab section information for %s", 0, 0};
57 struct complaint stab_info_mismatch_complaint =
58 {"elf/stab section information missing for %s", 0, 0};
60 struct complaint stab_info_questionable_complaint =
61 {"elf/stab section information questionable for %s", 0, 0};
64 elf_symfile_init PARAMS ((struct objfile *));
67 elf_new_init PARAMS ((struct objfile *));
70 elf_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
73 elf_symfile_finish PARAMS ((struct objfile *));
76 elf_symtab_read PARAMS ((bfd *, CORE_ADDR, struct objfile *, int));
79 free_elfinfo PARAMS ((void *));
81 static struct minimal_symbol *
82 record_minimal_symbol_and_info PARAMS ((char *, CORE_ADDR,
83 enum minimal_symbol_type, char *,
87 elf_locate_sections PARAMS ((bfd *, asection *, void *));
89 /* We are called once per section from elf_symfile_read. We
90 need to examine each section we are passed, check to see
91 if it is something we are interested in processing, and
92 if so, stash away some access information for the section.
94 For now we recognize the dwarf debug information sections and
95 line number sections from matching their section names. The
96 ELF definition is no real help here since it has no direct
97 knowledge of DWARF (by design, so any debugging format can be
100 We also recognize the ".stab" sections used by the Sun compilers
101 released with Solaris 2.
103 FIXME: The section names should not be hardwired strings (what
104 should they be? I don't think most object file formats have enough
105 section flags to specify what kind of debug section it is
109 elf_locate_sections (ignore_abfd, sectp, eip)
114 register struct elfinfo *ei;
116 ei = (struct elfinfo *) eip;
117 if (STREQ (sectp -> name, ".debug"))
119 ei -> dboffset = sectp -> filepos;
120 ei -> dbsize = bfd_get_section_size_before_reloc (sectp);
122 else if (STREQ (sectp -> name, ".line"))
124 ei -> lnoffset = sectp -> filepos;
125 ei -> lnsize = bfd_get_section_size_before_reloc (sectp);
127 else if (STREQ (sectp -> name, ".stab"))
129 ei -> stabsect = sectp;
131 else if (STREQ (sectp -> name, ".stab.index"))
133 ei -> stabindexsect = sectp;
135 else if (STREQ (sectp -> name, ".mdebug"))
137 ei -> mdebugsect = sectp;
141 #if 0 /* Currently unused */
144 elf_interpreter (abfd)
151 interp_sec = bfd_get_section_by_name (abfd, ".interp");
154 size = bfd_section_size (abfd, interp_sec);
155 interp = alloca (size);
156 if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0,
159 interp = savestring (interp, size - 1);
171 static struct minimal_symbol *
172 record_minimal_symbol_and_info (name, address, ms_type, info, objfile)
175 enum minimal_symbol_type ms_type;
176 char *info; /* FIXME, is this really char *? */
177 struct objfile *objfile;
181 /* Guess the section from the type. This is likely to be wrong in
187 section = SECT_OFF_TEXT;
188 #ifdef SMASH_TEXT_ADDRESS
189 SMASH_TEXT_ADDRESS (address);
194 section = SECT_OFF_DATA;
198 section = SECT_OFF_BSS;
205 return prim_record_minimal_symbol_and_info
206 (name, address, ms_type, info, section, objfile);
213 elf_symtab_read -- read the symbol table of an ELF file
217 void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
218 struct objfile *objfile, int dynamic)
222 Given an open bfd, a base address to relocate symbols to, and a
223 flag that specifies whether or not this bfd is for an executable
224 or not (may be shared library for example), add all the global
225 function and data symbols to the minimal symbol table.
227 In stabs-in-ELF, as implemented by Sun, there are some local symbols
228 defined in the ELF symbol table, which can be used to locate
229 the beginnings of sections from each ".o" file that was linked to
230 form the executable objfile. We gather any such info and record it
231 in data structures hung off the objfile's private data.
236 elf_symtab_read (abfd, addr, objfile, dynamic)
239 struct objfile *objfile;
244 asymbol **symbol_table;
245 long number_of_symbols;
248 struct cleanup *back_to;
250 enum minimal_symbol_type ms_type;
251 /* If sectinfo is nonNULL, it contains section info that should end up
252 filed in the objfile. */
253 struct stab_section_info *sectinfo = NULL;
254 /* If filesym is nonzero, it points to a file symbol, but we haven't
255 seen any section info for it yet. */
256 asymbol *filesym = 0;
257 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
258 /* Name of filesym, as saved on the symbol_obstack. */
259 char *filesymname = obsavestring ("", 0, &objfile->symbol_obstack);
261 struct dbx_symfile_info *dbx = (struct dbx_symfile_info *)
262 objfile->sym_stab_info;
264 int stripped = (bfd_get_symcount (abfd) == 0);
268 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
270 /* Nothing to be done if there is no dynamic symtab. */
271 if (storage_needed < 0)
276 storage_needed = bfd_get_symtab_upper_bound (abfd);
277 if (storage_needed < 0)
278 error ("Can't read symbols from %s: %s", bfd_get_filename (abfd),
279 bfd_errmsg (bfd_get_error ()));
281 if (storage_needed > 0)
283 symbol_table = (asymbol **) xmalloc (storage_needed);
284 back_to = make_cleanup (free, symbol_table);
286 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd,
289 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
290 if (number_of_symbols < 0)
291 error ("Can't read symbols from %s: %s", bfd_get_filename (abfd),
292 bfd_errmsg (bfd_get_error ()));
293 for (i = 0; i < number_of_symbols; i++)
295 sym = symbol_table[i];
296 if (sym -> name == NULL || *sym -> name == '\0')
298 /* Skip names that don't exist (shouldn't happen), or names
299 that are null strings (may happen). */
304 && sym -> section == &bfd_und_section
305 && (sym -> flags & BSF_FUNCTION))
307 struct minimal_symbol *msym;
309 /* Symbol is a reference to a function defined in
311 If its value is non zero then it is usually the address
312 of the corresponding entry in the procedure linkage table,
313 relative to the base address.
314 If its value is zero then the dynamic linker has to resolve
315 the symbol. We are unable to find any meaningful address
316 for this symbol in the executable file, so we skip it. */
317 symaddr = sym -> value;
321 msym = record_minimal_symbol_and_info
322 ((char *) sym -> name, symaddr,
323 mst_solib_trampoline, NULL, objfile);
324 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
326 msym->filename = filesymname;
331 /* If it is a nonstripped executable, do not enter dynamic
332 symbols, as the dynamic symbol table is usually a subset
333 of the main symbol table. */
334 if (dynamic && !stripped)
336 if (sym -> flags & BSF_FILE)
338 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
339 Chain any old one onto the objfile; remember new sym. */
340 if (sectinfo != NULL)
342 sectinfo -> next = dbx -> stab_section_info;
343 dbx -> stab_section_info = sectinfo;
347 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
349 obsavestring ((char *)filesym->name, strlen (filesym->name),
350 &objfile->symbol_obstack);
353 else if (sym -> flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
355 struct minimal_symbol *msym;
357 /* Select global/local/weak symbols. Note that bfd puts abs
358 symbols in their own section, so all symbols we are
359 interested in will have a section. */
360 /* Bfd symbols are section relative. */
361 symaddr = sym -> value + sym -> section -> vma;
362 /* Relocate all non-absolute symbols by base address. */
363 if (sym -> section != &bfd_abs_section)
367 /* For non-absolute symbols, use the type of the section
368 they are relative to, to intuit text/data. Bfd provides
369 no way of figuring this out for absolute symbols. */
370 if (sym -> section == &bfd_abs_section)
372 /* This is a hack to get the minimal symbol type
373 right for Irix 5, which has absolute adresses
374 with special section indices for dynamic symbols. */
375 unsigned short shndx =
376 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
386 case SHN_MIPS_ACOMMON:
393 else if (sym -> section -> flags & SEC_CODE)
395 if (sym -> flags & BSF_GLOBAL)
399 else if ((sym->name[0] == '.' && sym->name[1] == 'L')
400 || ((sym -> flags & BSF_LOCAL)
401 && sym->name[0] == '$'
402 && sym->name[1] == 'L'))
403 /* Looks like a compiler-generated label. Skip it.
404 The assembler should be skipping these (to keep
405 executables small), but apparently with gcc on the
406 delta m88k SVR4, it loses. So to have us check too
407 should be harmless (but I encourage people to fix this
408 in the assembler instead of adding checks here). */
412 ms_type = mst_file_text;
415 else if (sym -> section -> flags & SEC_ALLOC)
417 if (sym -> flags & BSF_GLOBAL)
419 if (sym -> section -> flags & SEC_LOAD)
428 else if (sym -> flags & BSF_LOCAL)
430 /* Named Local variable in a Data section. Check its
431 name for stabs-in-elf. The STREQ macro checks the
432 first character inline, so we only actually do a
433 strcmp function call on names that start with 'B'
435 index = SECT_OFF_MAX;
436 if (STREQ ("Bbss.bss", sym -> name))
438 index = SECT_OFF_BSS;
440 else if (STREQ ("Ddata.data", sym -> name))
442 index = SECT_OFF_DATA;
444 else if (STREQ ("Drodata.rodata", sym -> name))
446 index = SECT_OFF_RODATA;
448 if (index != SECT_OFF_MAX)
450 /* Found a special local symbol. Allocate a
451 sectinfo, if needed, and fill it in. */
452 if (sectinfo == NULL)
454 sectinfo = (struct stab_section_info *)
455 xmmalloc (objfile -> md, sizeof (*sectinfo));
456 memset ((PTR) sectinfo, 0, sizeof (*sectinfo));
459 complain (§ion_info_complaint,
464 sectinfo -> filename =
465 (char *) filesym -> name;
468 if (sectinfo -> sections[index] != 0)
470 complain (§ion_info_dup_complaint,
471 sectinfo -> filename);
473 /* Bfd symbols are section relative. */
474 symaddr = sym -> value + sym -> section -> vma;
475 /* Relocate non-absolute symbols by base address. */
476 if (sym -> section != &bfd_abs_section)
480 sectinfo -> sections[index] = symaddr;
481 /* The special local symbols don't go in the
482 minimal symbol table, so ignore this one. */
485 /* Not a special stabs-in-elf symbol, do regular
486 symbol processing. */
487 if (sym -> section -> flags & SEC_LOAD)
489 ms_type = mst_file_data;
493 ms_type = mst_file_bss;
498 ms_type = mst_unknown;
503 /* FIXME: Solaris2 shared libraries include lots of
504 odd "absolute" and "undefined" symbols, that play
505 hob with actions like finding what function the PC
506 is in. Ignore them if they aren't text, data, or bss. */
507 /* ms_type = mst_unknown; */
508 continue; /* Skip this symbol. */
510 /* Pass symbol size field in via BFD. FIXME!!! */
511 size = ((elf_symbol_type *) sym) -> internal_elf_sym.st_size;
512 msym = record_minimal_symbol_and_info
513 ((char *) sym -> name, symaddr,
514 ms_type, (PTR) size, objfile);
515 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
517 msym->filename = filesymname;
521 do_cleanups (back_to);
525 /* Scan and build partial symbols for a symbol file.
526 We have been initialized by a call to elf_symfile_init, which
527 currently does nothing.
529 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
530 in each section. We simplify it down to a single offset for all
533 MAINLINE is true if we are reading the main symbol
534 table (as opposed to a shared lib or dynamically loaded file).
536 This function only does the minimum work necessary for letting the
537 user "name" things symbolically; it does not read the entire symtab.
538 Instead, it reads the external and static symbols and puts them in partial
539 symbol tables. When more extensive information is requested of a
540 file, the corresponding partial symbol table is mutated into a full
541 fledged symbol table by going back and reading the symbols
544 We look for sections with specific names, to tell us what debug
545 format to look for: FIXME!!!
547 dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
548 elfstab_build_psymtabs() handles STABS symbols;
549 mdebug_build_psymtabs() handles ECOFF debugging information.
551 Note that ELF files have a "minimal" symbol table, which looks a lot
552 like a COFF symbol table, but has only the minimal information necessary
553 for linking. We process this also, and use the information to
554 build gdb's minimal symbol table. This gives us some minimal debugging
555 capability even for files compiled without -g. */
558 elf_symfile_read (objfile, section_offsets, mainline)
559 struct objfile *objfile;
560 struct section_offsets *section_offsets;
563 bfd *abfd = objfile->obfd;
565 struct cleanup *back_to;
568 init_minimal_symbol_collection ();
569 back_to = make_cleanup (discard_minimal_symbols, 0);
571 memset ((char *) &ei, 0, sizeof (ei));
573 /* Allocate struct to keep track of the symfile */
574 objfile->sym_stab_info = (PTR)
575 xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
576 memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
577 make_cleanup (free_elfinfo, (PTR) objfile);
579 /* Process the normal ELF symbol table first. This may write some
580 chain of info into the dbx_symfile_info in objfile->sym_stab_info,
581 which can later be used by elfstab_offset_sections. */
583 /* FIXME, should take a section_offsets param, not just an offset. */
584 offset = ANOFFSET (section_offsets, 0);
585 elf_symtab_read (abfd, offset, objfile, 0);
587 /* Add the dynamic symbols. */
589 elf_symtab_read (abfd, offset, objfile, 1);
591 /* Now process debugging information, which is contained in
592 special ELF sections. We first have to find them... */
594 bfd_map_over_sections (abfd, elf_locate_sections, (PTR) &ei);
595 if (ei.dboffset && ei.lnoffset)
598 dwarf_build_psymtabs (objfile,
599 section_offsets, mainline,
600 ei.dboffset, ei.dbsize,
601 ei.lnoffset, ei.lnsize);
607 /* Stab sections have an associated string table that looks like
608 a separate section. */
609 str_sect = bfd_get_section_by_name (abfd, ".stabstr");
611 /* FIXME should probably warn about a stab section without a stabstr. */
613 elfstab_build_psymtabs (objfile,
616 ei.stabsect->filepos,
617 bfd_section_size (abfd, ei.stabsect),
619 bfd_section_size (abfd, str_sect));
623 const struct ecoff_debug_swap *swap;
625 /* .mdebug section, presumably holding ECOFF debugging
627 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
629 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect,
633 /* Install any minimal symbols that have been collected as the current
634 minimal symbols for this objfile. */
636 install_minimal_symbols (objfile);
638 do_cleanups (back_to);
641 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
642 stab_section_info's, that might be dangling from it. */
648 struct objfile *objfile = (struct objfile *)objp;
649 struct dbx_symfile_info *dbxinfo = (struct dbx_symfile_info *)
650 objfile->sym_stab_info;
651 struct stab_section_info *ssi, *nssi;
653 ssi = dbxinfo->stab_section_info;
657 mfree (objfile->md, ssi);
661 dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */
665 /* Initialize anything that needs initializing when a completely new symbol
666 file is specified (not just adding some symbols from another file, e.g. a
669 We reinitialize buildsym, since we may be reading stabs from an ELF file. */
672 elf_new_init (ignore)
673 struct objfile *ignore;
675 stabsread_new_init ();
676 buildsym_new_init ();
679 /* Perform any local cleanups required when we are done with a particular
680 objfile. I.E, we are in the process of discarding all symbol information
681 for an objfile, freeing up all memory held for it, and unlinking the
682 objfile struct from the global list of known objfiles. */
685 elf_symfile_finish (objfile)
686 struct objfile *objfile;
688 if (objfile -> sym_stab_info != NULL)
690 mfree (objfile -> md, objfile -> sym_stab_info);
694 /* ELF specific initialization routine for reading symbols.
696 It is passed a pointer to a struct sym_fns which contains, among other
697 things, the BFD for the file whose symbols are being read, and a slot for
698 a pointer to "private data" which we can fill with goodies.
700 For now at least, we have nothing in particular to do, so this function is
704 elf_symfile_init (objfile)
705 struct objfile *objfile;
707 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
708 find this causes a significant slowdown in gdb then we could
709 set it in the debug symbol readers only when necessary. */
710 objfile->flags |= OBJF_REORDERED;
713 /* When handling an ELF file that contains Sun STABS debug info,
714 some of the debug info is relative to the particular chunk of the
715 section that was generated in its individual .o file. E.g.
716 offsets to static variables are relative to the start of the data
717 segment *for that module before linking*. This information is
718 painfully squirreled away in the ELF symbol table as local symbols
719 with wierd names. Go get 'em when needed. */
722 elfstab_offset_sections (objfile, pst)
723 struct objfile *objfile;
724 struct partial_symtab *pst;
726 char *filename = pst->filename;
727 struct dbx_symfile_info *dbx = (struct dbx_symfile_info *)
728 objfile->sym_stab_info;
729 struct stab_section_info *maybe = dbx->stab_section_info;
730 struct stab_section_info *questionable = 0;
734 /* The ELF symbol info doesn't include path names, so strip the path
735 (if any) from the psymtab filename. */
736 while (0 != (p = strchr (filename, '/')))
739 /* FIXME: This linear search could speed up significantly
740 if it was chained in the right order to match how we search it,
741 and if we unchained when we found a match. */
742 for (; maybe; maybe = maybe->next)
744 if (filename[0] == maybe->filename[0]
745 && STREQ (filename, maybe->filename))
747 /* We found a match. But there might be several source files
748 (from different directories) with the same name. */
749 if (0 == maybe->found)
751 questionable = maybe; /* Might use it later. */
755 if (maybe == 0 && questionable != 0)
757 complain (&stab_info_questionable_complaint, filename);
758 maybe = questionable;
763 /* Found it! Allocate a new psymtab struct, and fill it in. */
765 pst->section_offsets = (struct section_offsets *)
766 obstack_alloc (&objfile -> psymbol_obstack,
767 sizeof (struct section_offsets) +
768 sizeof (pst->section_offsets->offsets) * (SECT_OFF_MAX-1));
770 for (i = 0; i < SECT_OFF_MAX; i++)
771 ANOFFSET (pst->section_offsets, i) = maybe->sections[i];
775 /* We were unable to find any offsets for this file. Complain. */
776 if (dbx->stab_section_info) /* If there *is* any info, */
777 complain (&stab_info_mismatch_complaint, filename);
780 /* Register that we are able to handle ELF object file formats. */
782 static struct sym_fns elf_sym_fns =
784 bfd_target_elf_flavour,
785 elf_new_init, /* sym_new_init: init anything gbl to entire symtab */
786 elf_symfile_init, /* sym_init: read initial info, setup for sym_read() */
787 elf_symfile_read, /* sym_read: read a symbol file into symtab */
788 elf_symfile_finish, /* sym_finish: finished with file, cleanup */
789 default_symfile_offsets,
790 /* sym_offsets: Translate ext. to int. relocation */
791 NULL /* next: pointer to next struct sym_fns */
795 _initialize_elfread ()
797 add_symtab_fns (&elf_sym_fns);