1 /* Read ELF (Executable and Linking Format) object files for GDB.
2 Copyright 1991, 1992, 1993, 1994 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
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 section_offsets
*
82 elf_symfile_offsets
PARAMS ((struct objfile
*, CORE_ADDR
));
85 record_minimal_symbol_and_info
PARAMS ((char *, CORE_ADDR
,
86 enum minimal_symbol_type
, char *,
90 elf_locate_sections
PARAMS ((bfd
*, asection
*, void *));
92 /* We are called once per section from elf_symfile_read. We
93 need to examine each section we are passed, check to see
94 if it is something we are interested in processing, and
95 if so, stash away some access information for the section.
97 For now we recognize the dwarf debug information sections and
98 line number sections from matching their section names. The
99 ELF definition is no real help here since it has no direct
100 knowledge of DWARF (by design, so any debugging format can be
103 We also recognize the ".stab" sections used by the Sun compilers
104 released with Solaris 2.
106 FIXME: The section names should not be hardwired strings (what
107 should they be? I don't think most object file formats have enough
108 section flags to specify what kind of debug section it is
112 elf_locate_sections (ignore_abfd
, sectp
, eip
)
117 register struct elfinfo
*ei
;
119 ei
= (struct elfinfo
*) eip
;
120 if (STREQ (sectp
-> name
, ".debug"))
122 ei
-> dboffset
= sectp
-> filepos
;
123 ei
-> dbsize
= bfd_get_section_size_before_reloc (sectp
);
125 else if (STREQ (sectp
-> name
, ".line"))
127 ei
-> lnoffset
= sectp
-> filepos
;
128 ei
-> lnsize
= bfd_get_section_size_before_reloc (sectp
);
130 else if (STREQ (sectp
-> name
, ".stab"))
132 ei
-> stabsect
= sectp
;
134 else if (STREQ (sectp
-> name
, ".stab.index"))
136 ei
-> stabindexsect
= sectp
;
138 else if (STREQ (sectp
-> name
, ".mdebug"))
140 ei
-> mdebugsect
= sectp
;
144 #if 0 /* Currently unused */
147 elf_interpreter (abfd
)
154 interp_sec
= bfd_get_section_by_name (abfd
, ".interp");
157 size
= bfd_section_size (abfd
, interp_sec
);
158 interp
= alloca (size
);
159 if (bfd_get_section_contents (abfd
, interp_sec
, interp
, (file_ptr
)0,
162 interp
= savestring (interp
, size
- 1);
175 record_minimal_symbol_and_info (name
, address
, ms_type
, info
, objfile
)
178 enum minimal_symbol_type ms_type
;
179 char *info
; /* FIXME, is this really char *? */
180 struct objfile
*objfile
;
184 /* Guess the section from the type. This is likely to be wrong in
190 section
= SECT_OFF_TEXT
;
191 #ifdef SMASH_TEXT_ADDRESS
192 SMASH_TEXT_ADDRESS (address
);
197 section
= SECT_OFF_DATA
;
201 section
= SECT_OFF_BSS
;
208 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
209 prim_record_minimal_symbol_and_info (name
, address
, ms_type
, info
, section
,
217 elf_symtab_read -- read the symbol table of an ELF file
221 void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
222 struct objfile *objfile)
226 Given an open bfd, a base address to relocate symbols to, and a
227 flag that specifies whether or not this bfd is for an executable
228 or not (may be shared library for example), add all the global
229 function and data symbols to the minimal symbol table.
231 In stabs-in-ELF, as implemented by Sun, there are some local symbols
232 defined in the ELF symbol table, which can be used to locate
233 the beginnings of sections from each ".o" file that was linked to
234 form the executable objfile. We gather any such info and record it
235 in data structures hung off the objfile's private data.
240 elf_symtab_read (abfd
, addr
, objfile
, dynamic
)
243 struct objfile
*objfile
;
248 asymbol
**symbol_table
;
249 long number_of_symbols
;
252 struct cleanup
*back_to
;
254 enum minimal_symbol_type ms_type
;
255 /* If sectinfo is nonNULL, it contains section info that should end up
256 filed in the objfile. */
257 struct stab_section_info
*sectinfo
= NULL
;
258 /* If filesym is nonzero, it points to a file symbol, but we haven't
259 seen any section info for it yet. */
260 asymbol
*filesym
= 0;
261 struct dbx_symfile_info
*dbx
= (struct dbx_symfile_info
*)
262 objfile
->sym_stab_info
;
264 int stripped
= (bfd_get_symcount (abfd
) == 0);
267 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
269 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
270 if (storage_needed
< 0)
271 error ("Can't read symbols from %s: %s", bfd_get_filename (abfd
),
272 bfd_errmsg (bfd_get_error ()));
273 if (storage_needed
> 0)
275 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
276 back_to
= make_cleanup (free
, symbol_table
);
278 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
,
281 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
282 if (number_of_symbols
< 0)
283 error ("Can't read symbols from %s: %s", bfd_get_filename (abfd
),
284 bfd_errmsg (bfd_get_error ()));
285 for (i
= 0; i
< number_of_symbols
; i
++)
287 sym
= symbol_table
[i
];
288 if (sym
-> name
== NULL
|| *sym
-> name
== '\0')
290 /* Skip names that don't exist (shouldn't happen), or names
291 that are null strings (may happen). */
295 /* If it is a nonstripped executable, do not enter dynamic
296 symbols, as the dynamic symbol table is usually a subset
297 of the main symbol table.
298 On Irix 5 however, the symbols for the procedure linkage
299 table entries have meaningful values only in the dynamic
300 symbol table, so we always examine undefined symbols. */
301 if (dynamic
&& !stripped
&& sym
-> section
!= &bfd_und_section
)
303 if (sym
-> flags
& BSF_FILE
)
305 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
306 Chain any old one onto the objfile; remember new sym. */
307 if (sectinfo
!= NULL
)
309 sectinfo
-> next
= dbx
-> stab_section_info
;
310 dbx
-> stab_section_info
= sectinfo
;
315 else if (sym
-> flags
& (BSF_GLOBAL
| BSF_LOCAL
| BSF_WEAK
))
317 /* Select global/local/weak symbols. Note that bfd puts abs
318 symbols in their own section, so all symbols we are
319 interested in will have a section. */
320 /* Bfd symbols are section relative. */
321 symaddr
= sym
-> value
+ sym
-> section
-> vma
;
322 /* Relocate all non-absolute symbols by base address. */
323 if (sym
-> section
!= &bfd_abs_section
)
327 /* For non-absolute symbols, use the type of the section
328 they are relative to, to intuit text/data. Bfd provides
329 no way of figuring this out for absolute symbols. */
330 if (sym
-> section
== &bfd_und_section
331 && (sym
-> flags
& BSF_GLOBAL
)
332 && (sym
-> flags
& BSF_FUNCTION
))
334 /* Symbol is a reference to a function defined in
336 If its value is non zero then it is usually the
337 absolute address of the corresponding entry in
338 the procedure linkage table.
339 If its value is zero then the dynamic linker has to
340 resolve the symbol. We are unable to find any
341 meaningful address for this symbol in the
342 executable file, so we skip it.
343 Irix 5 has a zero value for all shared library functions
344 in the main symbol table, but the dynamic symbol table
345 provides the right values. */
346 ms_type
= mst_solib_trampoline
;
347 symaddr
= sym
-> value
;
352 else if (sym
-> section
== &bfd_abs_section
)
354 /* This is a hack to get the minimal symbol type
355 right for Irix 5, which has absolute adresses
356 with special section indices for dynamic symbols. */
357 unsigned short shndx
=
358 ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_shndx
;
368 case SHN_MIPS_ACOMMON
:
375 else if (sym
-> section
-> flags
& SEC_CODE
)
377 if (sym
-> flags
& BSF_GLOBAL
)
381 else if (sym
->name
[0] == '.' && sym
->name
[1] == 'L')
382 /* Looks like a compiler-generated label. Skip it.
383 The assembler should be skipping these (to keep
384 executables small), but apparently with gcc on the
385 delta m88k SVR4, it loses. So to have us check too
386 should be harmless (but I encourage people to fix this
387 in the assembler instead of adding checks here). */
391 ms_type
= mst_file_text
;
394 else if (sym
-> section
-> flags
& SEC_ALLOC
)
396 if (sym
-> flags
& BSF_GLOBAL
)
398 if (sym
-> section
-> flags
& SEC_LOAD
)
407 else if (sym
-> flags
& BSF_LOCAL
)
409 /* Named Local variable in a Data section. Check its
410 name for stabs-in-elf. The STREQ macro checks the
411 first character inline, so we only actually do a
412 strcmp function call on names that start with 'B'
414 index
= SECT_OFF_MAX
;
415 if (STREQ ("Bbss.bss", sym
-> name
))
417 index
= SECT_OFF_BSS
;
419 else if (STREQ ("Ddata.data", sym
-> name
))
421 index
= SECT_OFF_DATA
;
423 else if (STREQ ("Drodata.rodata", sym
-> name
))
425 index
= SECT_OFF_RODATA
;
427 if (index
!= SECT_OFF_MAX
)
429 /* Found a special local symbol. Allocate a
430 sectinfo, if needed, and fill it in. */
431 if (sectinfo
== NULL
)
433 sectinfo
= (struct stab_section_info
*)
434 xmmalloc (objfile
-> md
, sizeof (*sectinfo
));
435 memset ((PTR
) sectinfo
, 0, sizeof (*sectinfo
));
438 complain (§ion_info_complaint
,
443 sectinfo
-> filename
=
444 (char *) filesym
-> name
;
447 if (sectinfo
-> sections
[index
] != 0)
449 complain (§ion_info_dup_complaint
,
450 sectinfo
-> filename
);
452 /* Bfd symbols are section relative. */
453 symaddr
= sym
-> value
+ sym
-> section
-> vma
;
454 /* Relocate non-absolute symbols by base address. */
455 if (sym
-> section
!= &bfd_abs_section
)
459 sectinfo
-> sections
[index
] = symaddr
;
460 /* The special local symbols don't go in the
461 minimal symbol table, so ignore this one. */
464 /* Not a special stabs-in-elf symbol, do regular
465 symbol processing. */
466 if (sym
-> section
-> flags
& SEC_LOAD
)
468 ms_type
= mst_file_data
;
472 ms_type
= mst_file_bss
;
477 ms_type
= mst_unknown
;
482 /* FIXME: Solaris2 shared libraries include lots of
483 odd "absolute" and "undefined" symbols, that play
484 hob with actions like finding what function the PC
485 is in. Ignore them if they aren't text, data, or bss. */
486 /* ms_type = mst_unknown; */
487 continue; /* Skip this symbol. */
489 /* Pass symbol size field in via BFD. FIXME!!! */
490 size
= ((elf_symbol_type
*) sym
) -> internal_elf_sym
.st_size
;
491 record_minimal_symbol_and_info ((char *) sym
-> name
, symaddr
,
492 ms_type
, (PTR
) size
, objfile
);
495 do_cleanups (back_to
);
499 /* Scan and build partial symbols for a symbol file.
500 We have been initialized by a call to elf_symfile_init, which
501 currently does nothing.
503 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
504 in each section. We simplify it down to a single offset for all
507 MAINLINE is true if we are reading the main symbol
508 table (as opposed to a shared lib or dynamically loaded file).
510 This function only does the minimum work necessary for letting the
511 user "name" things symbolically; it does not read the entire symtab.
512 Instead, it reads the external and static symbols and puts them in partial
513 symbol tables. When more extensive information is requested of a
514 file, the corresponding partial symbol table is mutated into a full
515 fledged symbol table by going back and reading the symbols
518 We look for sections with specific names, to tell us what debug
519 format to look for: FIXME!!!
521 dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
522 elfstab_build_psymtabs() handles STABS symbols;
523 mdebug_build_psymtabs() handles ECOFF debugging information.
525 Note that ELF files have a "minimal" symbol table, which looks a lot
526 like a COFF symbol table, but has only the minimal information necessary
527 for linking. We process this also, and use the information to
528 build gdb's minimal symbol table. This gives us some minimal debugging
529 capability even for files compiled without -g. */
532 elf_symfile_read (objfile
, section_offsets
, mainline
)
533 struct objfile
*objfile
;
534 struct section_offsets
*section_offsets
;
537 bfd
*abfd
= objfile
->obfd
;
539 struct cleanup
*back_to
;
542 init_minimal_symbol_collection ();
543 back_to
= make_cleanup (discard_minimal_symbols
, 0);
545 memset ((char *) &ei
, 0, sizeof (ei
));
547 /* Allocate struct to keep track of the symfile */
548 objfile
->sym_stab_info
= (PTR
)
549 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
550 memset ((char *) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
551 make_cleanup (free_elfinfo
, (PTR
) objfile
);
553 /* Process the normal ELF symbol table first. This may write some
554 chain of info into the dbx_symfile_info in objfile->sym_stab_info,
555 which can later be used by elfstab_offset_sections. */
557 /* FIXME, should take a section_offsets param, not just an offset. */
558 offset
= ANOFFSET (section_offsets
, 0);
559 elf_symtab_read (abfd
, offset
, objfile
, 0);
561 /* Add the dynamic symbols. */
563 elf_symtab_read (abfd
, offset
, objfile
, 1);
565 /* Now process debugging information, which is contained in
566 special ELF sections. We first have to find them... */
568 bfd_map_over_sections (abfd
, elf_locate_sections
, (PTR
) &ei
);
569 if (ei
.dboffset
&& ei
.lnoffset
)
572 dwarf_build_psymtabs (objfile
,
573 section_offsets
, mainline
,
574 ei
.dboffset
, ei
.dbsize
,
575 ei
.lnoffset
, ei
.lnsize
);
581 /* Stab sections have an associated string table that looks like
582 a separate section. */
583 str_sect
= bfd_get_section_by_name (abfd
, ".stabstr");
585 /* FIXME should probably warn about a stab section without a stabstr. */
587 elfstab_build_psymtabs (objfile
,
590 ei
.stabsect
->filepos
,
591 bfd_section_size (abfd
, ei
.stabsect
),
593 bfd_section_size (abfd
, str_sect
));
597 const struct ecoff_debug_swap
*swap
;
599 /* .mdebug section, presumably holding ECOFF debugging
601 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
603 elfmdebug_build_psymtabs (objfile
, swap
, ei
.mdebugsect
,
607 /* Install any minimal symbols that have been collected as the current
608 minimal symbols for this objfile. */
610 install_minimal_symbols (objfile
);
612 do_cleanups (back_to
);
615 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
616 stab_section_info's, that might be dangling from it. */
622 struct objfile
*objfile
= (struct objfile
*)objp
;
623 struct dbx_symfile_info
*dbxinfo
= (struct dbx_symfile_info
*)
624 objfile
->sym_stab_info
;
625 struct stab_section_info
*ssi
, *nssi
;
627 ssi
= dbxinfo
->stab_section_info
;
631 mfree (objfile
->md
, ssi
);
635 dbxinfo
->stab_section_info
= 0; /* Just say No mo info about this. */
639 /* Initialize anything that needs initializing when a completely new symbol
640 file is specified (not just adding some symbols from another file, e.g. a
643 We reinitialize buildsym, since we may be reading stabs from an ELF file. */
646 elf_new_init (ignore
)
647 struct objfile
*ignore
;
649 stabsread_new_init ();
650 buildsym_new_init ();
653 /* Perform any local cleanups required when we are done with a particular
654 objfile. I.E, we are in the process of discarding all symbol information
655 for an objfile, freeing up all memory held for it, and unlinking the
656 objfile struct from the global list of known objfiles. */
659 elf_symfile_finish (objfile
)
660 struct objfile
*objfile
;
662 if (objfile
-> sym_stab_info
!= NULL
)
664 mfree (objfile
-> md
, objfile
-> sym_stab_info
);
668 /* ELF specific initialization routine for reading symbols.
670 It is passed a pointer to a struct sym_fns which contains, among other
671 things, the BFD for the file whose symbols are being read, and a slot for
672 a pointer to "private data" which we can fill with goodies.
674 For now at least, we have nothing in particular to do, so this function is
678 elf_symfile_init (ignore
)
679 struct objfile
*ignore
;
683 /* ELF specific parsing routine for section offsets.
685 Plain and simple for now. */
688 struct section_offsets
*
689 elf_symfile_offsets (objfile
, addr
)
690 struct objfile
*objfile
;
693 struct section_offsets
*section_offsets
;
696 objfile
->num_sections
= SECT_OFF_MAX
;
697 section_offsets
= (struct section_offsets
*)
698 obstack_alloc (&objfile
-> psymbol_obstack
,
699 sizeof (struct section_offsets
)
700 + sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
702 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
703 ANOFFSET (section_offsets
, i
) = addr
;
705 return section_offsets
;
708 /* When handling an ELF file that contains Sun STABS debug info,
709 some of the debug info is relative to the particular chunk of the
710 section that was generated in its individual .o file. E.g.
711 offsets to static variables are relative to the start of the data
712 segment *for that module before linking*. This information is
713 painfully squirreled away in the ELF symbol table as local symbols
714 with wierd names. Go get 'em when needed. */
717 elfstab_offset_sections (objfile
, pst
)
718 struct objfile
*objfile
;
719 struct partial_symtab
*pst
;
721 char *filename
= pst
->filename
;
722 struct dbx_symfile_info
*dbx
= (struct dbx_symfile_info
*)
723 objfile
->sym_stab_info
;
724 struct stab_section_info
*maybe
= dbx
->stab_section_info
;
725 struct stab_section_info
*questionable
= 0;
729 /* The ELF symbol info doesn't include path names, so strip the path
730 (if any) from the psymtab filename. */
731 while (0 != (p
= strchr (filename
, '/')))
734 /* FIXME: This linear search could speed up significantly
735 if it was chained in the right order to match how we search it,
736 and if we unchained when we found a match. */
737 for (; maybe
; maybe
= maybe
->next
)
739 if (filename
[0] == maybe
->filename
[0]
740 && STREQ (filename
, maybe
->filename
))
742 /* We found a match. But there might be several source files
743 (from different directories) with the same name. */
744 if (0 == maybe
->found
)
746 questionable
= maybe
; /* Might use it later. */
750 if (maybe
== 0 && questionable
!= 0)
752 complain (&stab_info_questionable_complaint
, filename
);
753 maybe
= questionable
;
758 /* Found it! Allocate a new psymtab struct, and fill it in. */
760 pst
->section_offsets
= (struct section_offsets
*)
761 obstack_alloc (&objfile
-> psymbol_obstack
,
762 sizeof (struct section_offsets
) +
763 sizeof (pst
->section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
765 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
766 ANOFFSET (pst
->section_offsets
, i
) = maybe
->sections
[i
];
770 /* We were unable to find any offsets for this file. Complain. */
771 if (dbx
->stab_section_info
) /* If there *is* any info, */
772 complain (&stab_info_mismatch_complaint
, filename
);
775 /* Register that we are able to handle ELF object file formats. */
777 static struct sym_fns elf_sym_fns
=
779 bfd_target_elf_flavour
,
780 elf_new_init
, /* sym_new_init: init anything gbl to entire symtab */
781 elf_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
782 elf_symfile_read
, /* sym_read: read a symbol file into symtab */
783 elf_symfile_finish
, /* sym_finish: finished with file, cleanup */
784 elf_symfile_offsets
, /* sym_offsets: Translate ext. to int. relocation */
785 NULL
/* next: pointer to next struct sym_fns */
789 _initialize_elfread ()
791 add_symtab_fns (&elf_sym_fns
);