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 /* If it is an Irix dynamic symbol, skip section name
394 symbols, relocate all others. */
395 if (ms_type
!= mst_abs
)
397 if (sym
->name
[0] == '.')
402 else if (sym
-> section
-> flags
& SEC_CODE
)
404 if (sym
-> flags
& BSF_GLOBAL
)
408 else if ((sym
->name
[0] == '.' && sym
->name
[1] == 'L')
409 || ((sym
-> flags
& BSF_LOCAL
)
410 && sym
->name
[0] == '$'
411 && sym
->name
[1] == 'L'))
412 /* Looks like a compiler-generated label. Skip it.
413 The assembler should be skipping these (to keep
414 executables small), but apparently with gcc on the
415 delta m88k SVR4, it loses. So to have us check too
416 should be harmless (but I encourage people to fix this
417 in the assembler instead of adding checks here). */
420 else if (sym
->name
[0] == '.' && sym
->name
[1] == '.')
422 /* Looks like a Harris compiler generated label for the
423 purpose of marking instructions that are relevant to
424 DWARF dies. The assembler can't get rid of these
425 because they are relocatable addresses that the
426 linker needs to resolve. */
432 ms_type
= mst_file_text
;
435 else if (sym
-> section
-> flags
& SEC_ALLOC
)
437 if (sym
-> flags
& BSF_GLOBAL
)
439 if (sym
-> section
-> flags
& SEC_LOAD
)
448 else if (sym
-> flags
& BSF_LOCAL
)
450 /* Named Local variable in a Data section. Check its
451 name for stabs-in-elf. The STREQ macro checks the
452 first character inline, so we only actually do a
453 strcmp function call on names that start with 'B'
455 index
= SECT_OFF_MAX
;
456 if (STREQ ("Bbss.bss", sym
-> name
))
458 index
= SECT_OFF_BSS
;
460 else if (STREQ ("Ddata.data", sym
-> name
))
462 index
= SECT_OFF_DATA
;
464 else if (STREQ ("Drodata.rodata", sym
-> name
))
466 index
= SECT_OFF_RODATA
;
468 if (index
!= SECT_OFF_MAX
)
470 /* Found a special local symbol. Allocate a
471 sectinfo, if needed, and fill it in. */
472 if (sectinfo
== NULL
)
474 sectinfo
= (struct stab_section_info
*)
475 xmmalloc (objfile
-> md
, sizeof (*sectinfo
));
476 memset ((PTR
) sectinfo
, 0, sizeof (*sectinfo
));
479 complain (§ion_info_complaint
,
484 sectinfo
-> filename
=
485 (char *) filesym
-> name
;
488 if (sectinfo
-> sections
[index
] != 0)
490 complain (§ion_info_dup_complaint
,
491 sectinfo
-> filename
);
493 /* Bfd symbols are section relative. */
494 symaddr
= sym
-> value
+ sym
-> section
-> vma
;
495 /* Relocate non-absolute symbols by base address. */
496 if (sym
-> section
!= &bfd_abs_section
)
500 sectinfo
-> sections
[index
] = symaddr
;
501 /* The special local symbols don't go in the
502 minimal symbol table, so ignore this one. */
505 /* Not a special stabs-in-elf symbol, do regular
506 symbol processing. */
507 if (sym
-> section
-> flags
& SEC_LOAD
)
509 ms_type
= mst_file_data
;
513 ms_type
= mst_file_bss
;
518 ms_type
= mst_unknown
;
523 /* FIXME: Solaris2 shared libraries include lots of
524 odd "absolute" and "undefined" symbols, that play
525 hob with actions like finding what function the PC
526 is in. Ignore them if they aren't text, data, or bss. */
527 /* ms_type = mst_unknown; */
528 continue; /* Skip this symbol. */
530 /* Pass symbol size field in via BFD. FIXME!!! */
531 size
= ((elf_symbol_type
*) sym
) -> internal_elf_sym
.st_size
;
532 msym
= record_minimal_symbol_and_info
533 ((char *) sym
-> name
, symaddr
,
534 ms_type
, (PTR
) size
, objfile
);
535 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
537 msym
->filename
= filesymname
;
541 do_cleanups (back_to
);
545 /* Scan and build partial symbols for a symbol file.
546 We have been initialized by a call to elf_symfile_init, which
547 currently does nothing.
549 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
550 in each section. We simplify it down to a single offset for all
553 MAINLINE is true if we are reading the main symbol
554 table (as opposed to a shared lib or dynamically loaded file).
556 This function only does the minimum work necessary for letting the
557 user "name" things symbolically; it does not read the entire symtab.
558 Instead, it reads the external and static symbols and puts them in partial
559 symbol tables. When more extensive information is requested of a
560 file, the corresponding partial symbol table is mutated into a full
561 fledged symbol table by going back and reading the symbols
564 We look for sections with specific names, to tell us what debug
565 format to look for: FIXME!!!
567 dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
568 elfstab_build_psymtabs() handles STABS symbols;
569 mdebug_build_psymtabs() handles ECOFF debugging information.
571 Note that ELF files have a "minimal" symbol table, which looks a lot
572 like a COFF symbol table, but has only the minimal information necessary
573 for linking. We process this also, and use the information to
574 build gdb's minimal symbol table. This gives us some minimal debugging
575 capability even for files compiled without -g. */
578 elf_symfile_read (objfile
, section_offsets
, mainline
)
579 struct objfile
*objfile
;
580 struct section_offsets
*section_offsets
;
583 bfd
*abfd
= objfile
->obfd
;
585 struct cleanup
*back_to
;
588 init_minimal_symbol_collection ();
589 back_to
= make_cleanup (discard_minimal_symbols
, 0);
591 memset ((char *) &ei
, 0, sizeof (ei
));
593 /* Allocate struct to keep track of the symfile */
594 objfile
->sym_stab_info
= (PTR
)
595 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
596 memset ((char *) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
597 make_cleanup (free_elfinfo
, (PTR
) objfile
);
599 /* Process the normal ELF symbol table first. This may write some
600 chain of info into the dbx_symfile_info in objfile->sym_stab_info,
601 which can later be used by elfstab_offset_sections. */
603 /* FIXME, should take a section_offsets param, not just an offset. */
604 offset
= ANOFFSET (section_offsets
, 0);
605 elf_symtab_read (abfd
, offset
, objfile
, 0);
607 /* Add the dynamic symbols. */
609 elf_symtab_read (abfd
, offset
, objfile
, 1);
611 /* Now process debugging information, which is contained in
612 special ELF sections. We first have to find them... */
614 bfd_map_over_sections (abfd
, elf_locate_sections
, (PTR
) &ei
);
615 if (dwarf2_has_info (abfd
))
617 /* DWARF 2 sections */
618 dwarf2_build_psymtabs (objfile
, section_offsets
, mainline
);
620 else if (ei
.dboffset
&& ei
.lnoffset
)
623 dwarf_build_psymtabs (objfile
,
624 section_offsets
, mainline
,
625 ei
.dboffset
, ei
.dbsize
,
626 ei
.lnoffset
, ei
.lnsize
);
632 /* Stab sections have an associated string table that looks like
633 a separate section. */
634 str_sect
= bfd_get_section_by_name (abfd
, ".stabstr");
636 /* FIXME should probably warn about a stab section without a stabstr. */
638 elfstab_build_psymtabs (objfile
,
641 ei
.stabsect
->filepos
,
642 bfd_section_size (abfd
, ei
.stabsect
),
644 bfd_section_size (abfd
, str_sect
));
648 const struct ecoff_debug_swap
*swap
;
650 /* .mdebug section, presumably holding ECOFF debugging
652 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
654 elfmdebug_build_psymtabs (objfile
, swap
, ei
.mdebugsect
,
658 /* Install any minimal symbols that have been collected as the current
659 minimal symbols for this objfile. */
661 install_minimal_symbols (objfile
);
663 do_cleanups (back_to
);
666 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
667 stab_section_info's, that might be dangling from it. */
673 struct objfile
*objfile
= (struct objfile
*)objp
;
674 struct dbx_symfile_info
*dbxinfo
= (struct dbx_symfile_info
*)
675 objfile
->sym_stab_info
;
676 struct stab_section_info
*ssi
, *nssi
;
678 ssi
= dbxinfo
->stab_section_info
;
682 mfree (objfile
->md
, ssi
);
686 dbxinfo
->stab_section_info
= 0; /* Just say No mo info about this. */
690 /* Initialize anything that needs initializing when a completely new symbol
691 file is specified (not just adding some symbols from another file, e.g. a
694 We reinitialize buildsym, since we may be reading stabs from an ELF file. */
697 elf_new_init (ignore
)
698 struct objfile
*ignore
;
700 stabsread_new_init ();
701 buildsym_new_init ();
704 /* Perform any local cleanups required when we are done with a particular
705 objfile. I.E, we are in the process of discarding all symbol information
706 for an objfile, freeing up all memory held for it, and unlinking the
707 objfile struct from the global list of known objfiles. */
710 elf_symfile_finish (objfile
)
711 struct objfile
*objfile
;
713 if (objfile
-> sym_stab_info
!= NULL
)
715 mfree (objfile
-> md
, objfile
-> sym_stab_info
);
719 /* ELF specific initialization routine for reading symbols.
721 It is passed a pointer to a struct sym_fns which contains, among other
722 things, the BFD for the file whose symbols are being read, and a slot for
723 a pointer to "private data" which we can fill with goodies.
725 For now at least, we have nothing in particular to do, so this function is
729 elf_symfile_init (objfile
)
730 struct objfile
*objfile
;
732 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
733 find this causes a significant slowdown in gdb then we could
734 set it in the debug symbol readers only when necessary. */
735 objfile
->flags
|= OBJF_REORDERED
;
738 /* When handling an ELF file that contains Sun STABS debug info,
739 some of the debug info is relative to the particular chunk of the
740 section that was generated in its individual .o file. E.g.
741 offsets to static variables are relative to the start of the data
742 segment *for that module before linking*. This information is
743 painfully squirreled away in the ELF symbol table as local symbols
744 with wierd names. Go get 'em when needed. */
747 elfstab_offset_sections (objfile
, pst
)
748 struct objfile
*objfile
;
749 struct partial_symtab
*pst
;
751 char *filename
= pst
->filename
;
752 struct dbx_symfile_info
*dbx
= (struct dbx_symfile_info
*)
753 objfile
->sym_stab_info
;
754 struct stab_section_info
*maybe
= dbx
->stab_section_info
;
755 struct stab_section_info
*questionable
= 0;
759 /* The ELF symbol info doesn't include path names, so strip the path
760 (if any) from the psymtab filename. */
761 while (0 != (p
= strchr (filename
, '/')))
764 /* FIXME: This linear search could speed up significantly
765 if it was chained in the right order to match how we search it,
766 and if we unchained when we found a match. */
767 for (; maybe
; maybe
= maybe
->next
)
769 if (filename
[0] == maybe
->filename
[0]
770 && STREQ (filename
, maybe
->filename
))
772 /* We found a match. But there might be several source files
773 (from different directories) with the same name. */
774 if (0 == maybe
->found
)
776 questionable
= maybe
; /* Might use it later. */
780 if (maybe
== 0 && questionable
!= 0)
782 complain (&stab_info_questionable_complaint
, filename
);
783 maybe
= questionable
;
788 /* Found it! Allocate a new psymtab struct, and fill it in. */
790 pst
->section_offsets
= (struct section_offsets
*)
791 obstack_alloc (&objfile
-> psymbol_obstack
,
792 sizeof (struct section_offsets
) +
793 sizeof (pst
->section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
795 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
796 ANOFFSET (pst
->section_offsets
, i
) = maybe
->sections
[i
];
800 /* We were unable to find any offsets for this file. Complain. */
801 if (dbx
->stab_section_info
) /* If there *is* any info, */
802 complain (&stab_info_mismatch_complaint
, filename
);
805 /* Register that we are able to handle ELF object file formats. */
807 static struct sym_fns elf_sym_fns
=
809 bfd_target_elf_flavour
,
810 elf_new_init
, /* sym_new_init: init anything gbl to entire symtab */
811 elf_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
812 elf_symfile_read
, /* sym_read: read a symbol file into symtab */
813 elf_symfile_finish
, /* sym_finish: finished with file, cleanup */
814 default_symfile_offsets
,
815 /* sym_offsets: Translate ext. to int. relocation */
816 NULL
/* next: pointer to next struct sym_fns */
820 _initialize_elfread ()
822 add_symtab_fns (&elf_sym_fns
);