1 /* Read ELF (Executable and Linking Format) object files for GDB.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
5 Written by Fred Fish at Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
33 #include "stabsread.h"
34 #include "gdb-stabs.h"
35 #include "complaints.h"
38 extern void _initialize_elfread (void);
40 /* The struct elfinfo is available only during ELF symbol table and
41 psymtab reading. It is destroyed at the completion of psymtab-reading.
42 It's local to elf_symfile_read. */
46 file_ptr dboffset
; /* Offset to dwarf debug section */
47 unsigned int dbsize
; /* Size of dwarf debug section */
48 file_ptr lnoffset
; /* Offset to dwarf line number section */
49 unsigned int lnsize
; /* Size of dwarf line number section */
50 asection
*stabsect
; /* Section pointer for .stab section */
51 asection
*stabindexsect
; /* Section pointer for .stab.index section */
52 asection
*mdebugsect
; /* Section pointer for .mdebug section */
55 static void free_elfinfo (void *);
57 /* We are called once per section from elf_symfile_read. We
58 need to examine each section we are passed, check to see
59 if it is something we are interested in processing, and
60 if so, stash away some access information for the section.
62 For now we recognize the dwarf debug information sections and
63 line number sections from matching their section names. The
64 ELF definition is no real help here since it has no direct
65 knowledge of DWARF (by design, so any debugging format can be
68 We also recognize the ".stab" sections used by the Sun compilers
69 released with Solaris 2.
71 FIXME: The section names should not be hardwired strings (what
72 should they be? I don't think most object file formats have enough
73 section flags to specify what kind of debug section it is
77 elf_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *eip
)
79 register struct elfinfo
*ei
;
81 ei
= (struct elfinfo
*) eip
;
82 if (STREQ (sectp
->name
, ".debug"))
84 ei
->dboffset
= sectp
->filepos
;
85 ei
->dbsize
= bfd_get_section_size_before_reloc (sectp
);
87 else if (STREQ (sectp
->name
, ".line"))
89 ei
->lnoffset
= sectp
->filepos
;
90 ei
->lnsize
= bfd_get_section_size_before_reloc (sectp
);
92 else if (STREQ (sectp
->name
, ".stab"))
96 else if (STREQ (sectp
->name
, ".stab.index"))
98 ei
->stabindexsect
= sectp
;
100 else if (STREQ (sectp
->name
, ".mdebug"))
102 ei
->mdebugsect
= sectp
;
106 #if 0 /* Currently unused */
109 elf_interpreter (bfd
*abfd
)
115 interp_sec
= bfd_get_section_by_name (abfd
, ".interp");
118 size
= bfd_section_size (abfd
, interp_sec
);
119 interp
= alloca (size
);
120 if (bfd_get_section_contents (abfd
, interp_sec
, interp
, (file_ptr
) 0,
123 interp
= savestring (interp
, size
- 1);
135 static struct minimal_symbol
*
136 record_minimal_symbol_and_info (char *name
, CORE_ADDR address
,
137 enum minimal_symbol_type ms_type
, char *info
, /* FIXME, is this really char *? */
138 asection
*bfd_section
, struct objfile
*objfile
)
140 if (ms_type
== mst_text
|| ms_type
== mst_file_text
)
141 address
= SMASH_TEXT_ADDRESS (address
);
143 return prim_record_minimal_symbol_and_info
144 (name
, address
, ms_type
, info
, bfd_section
->index
, bfd_section
, objfile
);
151 elf_symtab_read -- read the symbol table of an ELF file
155 void elf_symtab_read (struct objfile *objfile, int dynamic)
159 Given an objfile and a flag that specifies whether or not the objfile
160 is for an executable or not (may be shared library for example), add
161 all the global function and data symbols to the minimal symbol table.
163 In stabs-in-ELF, as implemented by Sun, there are some local symbols
164 defined in the ELF symbol table, which can be used to locate
165 the beginnings of sections from each ".o" file that was linked to
166 form the executable objfile. We gather any such info and record it
167 in data structures hung off the objfile's private data.
172 elf_symtab_read (struct objfile
*objfile
, int dynamic
)
176 asymbol
**symbol_table
;
177 long number_of_symbols
;
180 struct cleanup
*back_to
;
183 enum minimal_symbol_type ms_type
;
184 /* If sectinfo is nonNULL, it contains section info that should end up
185 filed in the objfile. */
186 struct stab_section_info
*sectinfo
= NULL
;
187 /* If filesym is nonzero, it points to a file symbol, but we haven't
188 seen any section info for it yet. */
189 asymbol
*filesym
= 0;
190 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
191 /* Name of filesym, as saved on the symbol_obstack. */
192 char *filesymname
= obsavestring ("", 0, &objfile
->symbol_obstack
);
194 struct dbx_symfile_info
*dbx
= objfile
->sym_stab_info
;
196 int stripped
= (bfd_get_symcount (objfile
->obfd
) == 0);
200 storage_needed
= bfd_get_dynamic_symtab_upper_bound (objfile
->obfd
);
202 /* Nothing to be done if there is no dynamic symtab. */
203 if (storage_needed
< 0)
208 storage_needed
= bfd_get_symtab_upper_bound (objfile
->obfd
);
209 if (storage_needed
< 0)
210 error ("Can't read symbols from %s: %s", bfd_get_filename (objfile
->obfd
),
211 bfd_errmsg (bfd_get_error ()));
213 if (storage_needed
> 0)
215 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
216 back_to
= make_cleanup (xfree
, symbol_table
);
218 number_of_symbols
= bfd_canonicalize_dynamic_symtab (objfile
->obfd
,
221 number_of_symbols
= bfd_canonicalize_symtab (objfile
->obfd
, symbol_table
);
222 if (number_of_symbols
< 0)
223 error ("Can't read symbols from %s: %s", bfd_get_filename (objfile
->obfd
),
224 bfd_errmsg (bfd_get_error ()));
226 for (i
= 0; i
< number_of_symbols
; i
++)
228 sym
= symbol_table
[i
];
229 if (sym
->name
== NULL
|| *sym
->name
== '\0')
231 /* Skip names that don't exist (shouldn't happen), or names
232 that are null strings (may happen). */
236 offset
= ANOFFSET (objfile
->section_offsets
, sym
->section
->index
);
238 && sym
->section
== &bfd_und_section
239 && (sym
->flags
& BSF_FUNCTION
))
241 struct minimal_symbol
*msym
;
243 /* Symbol is a reference to a function defined in
245 If its value is non zero then it is usually the address
246 of the corresponding entry in the procedure linkage table,
247 plus the desired section offset.
248 If its value is zero then the dynamic linker has to resolve
249 the symbol. We are unable to find any meaningful address
250 for this symbol in the executable file, so we skip it. */
251 symaddr
= sym
->value
;
255 msym
= record_minimal_symbol_and_info
256 ((char *) sym
->name
, symaddr
,
257 mst_solib_trampoline
, NULL
, sym
->section
, objfile
);
258 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
260 msym
->filename
= filesymname
;
265 /* If it is a nonstripped executable, do not enter dynamic
266 symbols, as the dynamic symbol table is usually a subset
267 of the main symbol table. */
268 if (dynamic
&& !stripped
)
270 if (sym
->flags
& BSF_FILE
)
272 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
273 Chain any old one onto the objfile; remember new sym. */
274 if (sectinfo
!= NULL
)
276 sectinfo
->next
= dbx
->stab_section_info
;
277 dbx
->stab_section_info
= sectinfo
;
281 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
283 obsavestring ((char *) filesym
->name
, strlen (filesym
->name
),
284 &objfile
->symbol_obstack
);
287 else if (sym
->flags
& (BSF_GLOBAL
| BSF_LOCAL
| BSF_WEAK
))
289 struct minimal_symbol
*msym
;
291 /* Select global/local/weak symbols. Note that bfd puts abs
292 symbols in their own section, so all symbols we are
293 interested in will have a section. */
294 /* Bfd symbols are section relative. */
295 symaddr
= sym
->value
+ sym
->section
->vma
;
296 /* Relocate all non-absolute symbols by the section offset. */
297 if (sym
->section
!= &bfd_abs_section
)
301 /* For non-absolute symbols, use the type of the section
302 they are relative to, to intuit text/data. Bfd provides
303 no way of figuring this out for absolute symbols. */
304 if (sym
->section
== &bfd_abs_section
)
306 /* This is a hack to get the minimal symbol type
307 right for Irix 5, which has absolute addresses
308 with special section indices for dynamic symbols. */
309 unsigned short shndx
=
310 ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_shndx
;
320 case SHN_MIPS_ACOMMON
:
327 /* If it is an Irix dynamic symbol, skip section name
328 symbols, relocate all others by section offset. */
329 if (ms_type
!= mst_abs
)
331 if (sym
->name
[0] == '.')
336 else if (sym
->section
->flags
& SEC_CODE
)
338 if (sym
->flags
& BSF_GLOBAL
)
342 else if ((sym
->name
[0] == '.' && sym
->name
[1] == 'L')
343 || ((sym
->flags
& BSF_LOCAL
)
344 && sym
->name
[0] == '$'
345 && sym
->name
[1] == 'L'))
346 /* Looks like a compiler-generated label. Skip
347 it. The assembler should be skipping these (to
348 keep executables small), but apparently with
349 gcc on the (OBSOLETE) delta m88k SVR4, it
350 loses. So to have us check too should be
351 harmless (but I encourage people to fix this in
352 the assembler instead of adding checks here). */
356 ms_type
= mst_file_text
;
359 else if (sym
->section
->flags
& SEC_ALLOC
)
361 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
363 if (sym
->section
->flags
& SEC_LOAD
)
372 else if (sym
->flags
& BSF_LOCAL
)
374 /* Named Local variable in a Data section. Check its
375 name for stabs-in-elf. The STREQ macro checks the
376 first character inline, so we only actually do a
377 strcmp function call on names that start with 'B'
379 index
= SECT_OFF_MAX
;
380 if (STREQ ("Bbss.bss", sym
->name
))
382 index
= SECT_OFF_BSS (objfile
);
384 else if (STREQ ("Ddata.data", sym
->name
))
386 index
= SECT_OFF_DATA (objfile
);
388 else if (STREQ ("Drodata.rodata", sym
->name
))
390 index
= SECT_OFF_RODATA (objfile
);
392 if (index
!= SECT_OFF_MAX
)
394 /* Found a special local symbol. Allocate a
395 sectinfo, if needed, and fill it in. */
396 if (sectinfo
== NULL
)
398 sectinfo
= (struct stab_section_info
*)
399 xmmalloc (objfile
->md
, sizeof (*sectinfo
));
404 complaint (&symfile_complaints
,
405 "elf/stab section information %s without a preceding file symbol",
411 (char *) filesym
->name
;
416 if (sectinfo
->sections
[index
] != 0)
418 complaint (&symfile_complaints
,
419 "duplicated elf/stab section information for %s",
424 internal_error (__FILE__
, __LINE__
,
425 "Section index uninitialized.");
426 /* Bfd symbols are section relative. */
427 symaddr
= sym
->value
+ sym
->section
->vma
;
428 /* Relocate non-absolute symbols by the section offset. */
429 if (sym
->section
!= &bfd_abs_section
)
434 sectinfo
->sections
[index
] = symaddr
;
436 internal_error (__FILE__
, __LINE__
,
437 "Section index uninitialized.");
438 /* The special local symbols don't go in the
439 minimal symbol table, so ignore this one. */
442 /* Not a special stabs-in-elf symbol, do regular
443 symbol processing. */
444 if (sym
->section
->flags
& SEC_LOAD
)
446 ms_type
= mst_file_data
;
450 ms_type
= mst_file_bss
;
455 ms_type
= mst_unknown
;
460 /* FIXME: Solaris2 shared libraries include lots of
461 odd "absolute" and "undefined" symbols, that play
462 hob with actions like finding what function the PC
463 is in. Ignore them if they aren't text, data, or bss. */
464 /* ms_type = mst_unknown; */
465 continue; /* Skip this symbol. */
467 /* Pass symbol size field in via BFD. FIXME!!! */
468 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
469 msym
= record_minimal_symbol_and_info
470 ((char *) sym
->name
, symaddr
,
471 ms_type
, (void *) size
, sym
->section
, objfile
);
472 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
474 msym
->filename
= filesymname
;
476 ELF_MAKE_MSYMBOL_SPECIAL (sym
, msym
);
479 do_cleanups (back_to
);
483 /* Scan and build partial symbols for a symbol file.
484 We have been initialized by a call to elf_symfile_init, which
485 currently does nothing.
487 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
488 in each section. We simplify it down to a single offset for all
491 MAINLINE is true if we are reading the main symbol
492 table (as opposed to a shared lib or dynamically loaded file).
494 This function only does the minimum work necessary for letting the
495 user "name" things symbolically; it does not read the entire symtab.
496 Instead, it reads the external and static symbols and puts them in partial
497 symbol tables. When more extensive information is requested of a
498 file, the corresponding partial symbol table is mutated into a full
499 fledged symbol table by going back and reading the symbols
502 We look for sections with specific names, to tell us what debug
503 format to look for: FIXME!!!
505 dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
506 elfstab_build_psymtabs() handles STABS symbols;
507 mdebug_build_psymtabs() handles ECOFF debugging information.
509 Note that ELF files have a "minimal" symbol table, which looks a lot
510 like a COFF symbol table, but has only the minimal information necessary
511 for linking. We process this also, and use the information to
512 build gdb's minimal symbol table. This gives us some minimal debugging
513 capability even for files compiled without -g. */
516 elf_symfile_read (struct objfile
*objfile
, int mainline
)
518 bfd
*abfd
= objfile
->obfd
;
520 struct cleanup
*back_to
;
523 init_minimal_symbol_collection ();
524 back_to
= make_cleanup_discard_minimal_symbols ();
526 memset ((char *) &ei
, 0, sizeof (ei
));
528 /* Allocate struct to keep track of the symfile */
529 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
530 xmmalloc (objfile
->md
, sizeof (struct dbx_symfile_info
));
531 memset ((char *) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
532 make_cleanup (free_elfinfo
, (void *) objfile
);
534 /* Process the normal ELF symbol table first. This may write some
535 chain of info into the dbx_symfile_info in objfile->sym_stab_info,
536 which can later be used by elfstab_offset_sections. */
538 elf_symtab_read (objfile
, 0);
540 /* Add the dynamic symbols. */
542 elf_symtab_read (objfile
, 1);
544 /* Now process debugging information, which is contained in
545 special ELF sections. */
547 /* If we are reinitializing, or if we have never loaded syms yet,
548 set table to empty. MAINLINE is cleared so that *_read_psymtab
549 functions do not all also re-initialize the psymbol table. */
552 init_psymbol_list (objfile
, 0);
556 /* We first have to find them... */
557 bfd_map_over_sections (abfd
, elf_locate_sections
, (void *) & ei
);
559 /* ELF debugging information is inserted into the psymtab in the
560 order of least informative first - most informative last. Since
561 the psymtab table is searched `most recent insertion first' this
562 increases the probability that more detailed debug information
563 for a section is found.
565 For instance, an object file might contain both .mdebug (XCOFF)
566 and .debug_info (DWARF2) sections then .mdebug is inserted first
567 (searched last) and DWARF2 is inserted last (searched first). If
568 we don't do this then the XCOFF info is found first - for code in
569 an included file XCOFF info is useless. */
573 const struct ecoff_debug_swap
*swap
;
575 /* .mdebug section, presumably holding ECOFF debugging
577 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
579 elfmdebug_build_psymtabs (objfile
, swap
, ei
.mdebugsect
);
585 /* Stab sections have an associated string table that looks like
586 a separate section. */
587 str_sect
= bfd_get_section_by_name (abfd
, ".stabstr");
589 /* FIXME should probably warn about a stab section without a stabstr. */
591 elfstab_build_psymtabs (objfile
,
593 ei
.stabsect
->filepos
,
594 bfd_section_size (abfd
, ei
.stabsect
),
596 bfd_section_size (abfd
, str_sect
));
598 if (dwarf2_has_info (abfd
))
600 /* DWARF 2 sections */
601 dwarf2_build_psymtabs (objfile
, mainline
);
603 else if (ei
.dboffset
&& ei
.lnoffset
)
606 dwarf_build_psymtabs (objfile
,
608 ei
.dboffset
, ei
.dbsize
,
609 ei
.lnoffset
, ei
.lnsize
);
612 if (DWARF2_BUILD_FRAME_INFO_P ())
613 DWARF2_BUILD_FRAME_INFO(objfile
);
615 /* Install any minimal symbols that have been collected as the current
616 minimal symbols for this objfile. */
618 install_minimal_symbols (objfile
);
620 do_cleanups (back_to
);
623 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
624 stab_section_info's, that might be dangling from it. */
627 free_elfinfo (void *objp
)
629 struct objfile
*objfile
= (struct objfile
*) objp
;
630 struct dbx_symfile_info
*dbxinfo
= objfile
->sym_stab_info
;
631 struct stab_section_info
*ssi
, *nssi
;
633 ssi
= dbxinfo
->stab_section_info
;
637 xmfree (objfile
->md
, ssi
);
641 dbxinfo
->stab_section_info
= 0; /* Just say No mo info about this. */
645 /* Initialize anything that needs initializing when a completely new symbol
646 file is specified (not just adding some symbols from another file, e.g. a
649 We reinitialize buildsym, since we may be reading stabs from an ELF file. */
652 elf_new_init (struct objfile
*ignore
)
654 stabsread_new_init ();
655 buildsym_new_init ();
658 /* Perform any local cleanups required when we are done with a particular
659 objfile. I.E, we are in the process of discarding all symbol information
660 for an objfile, freeing up all memory held for it, and unlinking the
661 objfile struct from the global list of known objfiles. */
664 elf_symfile_finish (struct objfile
*objfile
)
666 if (objfile
->sym_stab_info
!= NULL
)
668 xmfree (objfile
->md
, objfile
->sym_stab_info
);
672 /* ELF specific initialization routine for reading symbols.
674 It is passed a pointer to a struct sym_fns which contains, among other
675 things, the BFD for the file whose symbols are being read, and a slot for
676 a pointer to "private data" which we can fill with goodies.
678 For now at least, we have nothing in particular to do, so this function is
682 elf_symfile_init (struct objfile
*objfile
)
684 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
685 find this causes a significant slowdown in gdb then we could
686 set it in the debug symbol readers only when necessary. */
687 objfile
->flags
|= OBJF_REORDERED
;
690 /* When handling an ELF file that contains Sun STABS debug info,
691 some of the debug info is relative to the particular chunk of the
692 section that was generated in its individual .o file. E.g.
693 offsets to static variables are relative to the start of the data
694 segment *for that module before linking*. This information is
695 painfully squirreled away in the ELF symbol table as local symbols
696 with wierd names. Go get 'em when needed. */
699 elfstab_offset_sections (struct objfile
*objfile
, struct partial_symtab
*pst
)
701 char *filename
= pst
->filename
;
702 struct dbx_symfile_info
*dbx
= objfile
->sym_stab_info
;
703 struct stab_section_info
*maybe
= dbx
->stab_section_info
;
704 struct stab_section_info
*questionable
= 0;
708 /* The ELF symbol info doesn't include path names, so strip the path
709 (if any) from the psymtab filename. */
710 while (0 != (p
= strchr (filename
, '/')))
713 /* FIXME: This linear search could speed up significantly
714 if it was chained in the right order to match how we search it,
715 and if we unchained when we found a match. */
716 for (; maybe
; maybe
= maybe
->next
)
718 if (filename
[0] == maybe
->filename
[0]
719 && STREQ (filename
, maybe
->filename
))
721 /* We found a match. But there might be several source files
722 (from different directories) with the same name. */
723 if (0 == maybe
->found
)
725 questionable
= maybe
; /* Might use it later. */
729 if (maybe
== 0 && questionable
!= 0)
731 complaint (&symfile_complaints
,
732 "elf/stab section information questionable for %s", filename
);
733 maybe
= questionable
;
738 /* Found it! Allocate a new psymtab struct, and fill it in. */
740 pst
->section_offsets
= (struct section_offsets
*)
741 obstack_alloc (&objfile
->psymbol_obstack
, SIZEOF_SECTION_OFFSETS
);
742 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
743 (pst
->section_offsets
)->offsets
[i
] = maybe
->sections
[i
];
747 /* We were unable to find any offsets for this file. Complain. */
748 if (dbx
->stab_section_info
) /* If there *is* any info, */
749 complaint (&symfile_complaints
,
750 "elf/stab section information missing for %s", filename
);
753 /* Register that we are able to handle ELF object file formats. */
755 static struct sym_fns elf_sym_fns
=
757 bfd_target_elf_flavour
,
758 elf_new_init
, /* sym_new_init: init anything gbl to entire symtab */
759 elf_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
760 elf_symfile_read
, /* sym_read: read a symbol file into symtab */
761 elf_symfile_finish
, /* sym_finish: finished with file, cleanup */
762 default_symfile_offsets
, /* sym_offsets: Translate ext. to int. relocation */
763 NULL
/* next: pointer to next struct sym_fns */
767 _initialize_elfread (void)
769 add_symtab_fns (&elf_sym_fns
);