1 /* Read ELF (Executable and Linking Format) object files for GDB.
3 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
6 Written by Fred Fish at Cygnus Support.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
27 #include "gdb_string.h"
34 #include "stabsread.h"
35 #include "gdb-stabs.h"
36 #include "complaints.h"
39 extern void _initialize_elfread (void);
41 /* The struct elfinfo is available only during ELF symbol table and
42 psymtab reading. It is destroyed at the completion of psymtab-reading.
43 It's local to elf_symfile_read. */
47 file_ptr dboffset
; /* Offset to dwarf debug section */
48 unsigned int dbsize
; /* Size of dwarf debug section */
49 file_ptr lnoffset
; /* Offset to dwarf line number section */
50 unsigned int lnsize
; /* Size of dwarf line number section */
51 asection
*stabsect
; /* Section pointer for .stab section */
52 asection
*stabindexsect
; /* Section pointer for .stab.index section */
53 asection
*mdebugsect
; /* Section pointer for .mdebug section */
56 static void free_elfinfo (void *);
58 /* We are called once per section from elf_symfile_read. We
59 need to examine each section we are passed, check to see
60 if it is something we are interested in processing, and
61 if so, stash away some access information for the section.
63 For now we recognize the dwarf debug information sections and
64 line number sections from matching their section names. The
65 ELF definition is no real help here since it has no direct
66 knowledge of DWARF (by design, so any debugging format can be
69 We also recognize the ".stab" sections used by the Sun compilers
70 released with Solaris 2.
72 FIXME: The section names should not be hardwired strings (what
73 should they be? I don't think most object file formats have enough
74 section flags to specify what kind of debug section it is
78 elf_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *eip
)
82 ei
= (struct elfinfo
*) eip
;
83 if (STREQ (sectp
->name
, ".debug"))
85 ei
->dboffset
= sectp
->filepos
;
86 ei
->dbsize
= bfd_get_section_size_before_reloc (sectp
);
88 else if (STREQ (sectp
->name
, ".line"))
90 ei
->lnoffset
= sectp
->filepos
;
91 ei
->lnsize
= bfd_get_section_size_before_reloc (sectp
);
93 else if (STREQ (sectp
->name
, ".stab"))
97 else if (STREQ (sectp
->name
, ".stab.index"))
99 ei
->stabindexsect
= sectp
;
101 else if (STREQ (sectp
->name
, ".mdebug"))
103 ei
->mdebugsect
= sectp
;
107 #if 0 /* Currently unused */
110 elf_interpreter (bfd
*abfd
)
116 interp_sec
= bfd_get_section_by_name (abfd
, ".interp");
119 size
= bfd_section_size (abfd
, interp_sec
);
120 interp
= alloca (size
);
121 if (bfd_get_section_contents (abfd
, interp_sec
, interp
, (file_ptr
) 0,
124 interp
= savestring (interp
, size
- 1);
136 static struct minimal_symbol
*
137 record_minimal_symbol_and_info (char *name
, CORE_ADDR address
,
138 enum minimal_symbol_type ms_type
, char *info
, /* FIXME, is this really char *? */
139 asection
*bfd_section
, struct objfile
*objfile
)
141 if (ms_type
== mst_text
|| ms_type
== mst_file_text
)
142 address
= SMASH_TEXT_ADDRESS (address
);
144 return prim_record_minimal_symbol_and_info
145 (name
, address
, ms_type
, info
, bfd_section
->index
, bfd_section
, objfile
);
152 elf_symtab_read -- read the symbol table of an ELF file
156 void elf_symtab_read (struct objfile *objfile, int dynamic)
160 Given an objfile and a flag that specifies whether or not the objfile
161 is for an executable or not (may be shared library for example), add
162 all the global function and data symbols to the minimal symbol table.
164 In stabs-in-ELF, as implemented by Sun, there are some local symbols
165 defined in the ELF symbol table, which can be used to locate
166 the beginnings of sections from each ".o" file that was linked to
167 form the executable objfile. We gather any such info and record it
168 in data structures hung off the objfile's private data.
173 elf_symtab_read (struct objfile
*objfile
, int dynamic
)
177 asymbol
**symbol_table
;
178 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 (deleted) delta m88k SVR4, it loses.
350 So to have us check too should be harmless (but
351 I encourage people to fix this in the assembler
352 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.
375 Check its name for stabs-in-elf. The STREQ
376 macro checks the first character inline, so
377 we only actually do a strcmp function call on
378 names that start with 'B' or 'D'. */
379 int special_local_sect
;
380 if (strcmp ("Bbss.bss", sym
->name
) == 0)
381 special_local_sect
= SECT_OFF_BSS (objfile
);
382 else if (strcmp ("Ddata.data", sym
->name
) == 0)
383 special_local_sect
= SECT_OFF_DATA (objfile
);
384 else if (strcmp ("Drodata.rodata", sym
->name
) == 0)
385 special_local_sect
= SECT_OFF_RODATA (objfile
);
387 special_local_sect
= -1;
388 if (special_local_sect
>= 0)
390 /* Found a special local symbol. Allocate a
391 sectinfo, if needed, and fill it in. */
392 if (sectinfo
== NULL
)
398 = max (SECT_OFF_BSS (objfile
),
399 max (SECT_OFF_DATA (objfile
),
400 SECT_OFF_RODATA (objfile
)));
402 /* max_index is the largest index we'll
403 use into this array, so we must
404 allocate max_index+1 elements for it.
405 However, 'struct stab_section_info'
406 already includes one element, so we
407 need to allocate max_index aadditional
409 size
= (sizeof (struct stab_section_info
)
410 + (sizeof (CORE_ADDR
)
412 sectinfo
= (struct stab_section_info
*)
413 xmmalloc (objfile
->md
, size
);
414 memset (sectinfo
, 0, size
);
415 sectinfo
->num_sections
= max_index
;
418 complaint (&symfile_complaints
,
419 "elf/stab section information %s without a preceding file symbol",
425 (char *) filesym
->name
;
428 if (sectinfo
->sections
[special_local_sect
] != 0)
429 complaint (&symfile_complaints
,
430 "duplicated elf/stab section information for %s",
432 /* BFD symbols are section relative. */
433 symaddr
= sym
->value
+ sym
->section
->vma
;
434 /* Relocate non-absolute symbols by the
436 if (sym
->section
!= &bfd_abs_section
)
438 sectinfo
->sections
[special_local_sect
] = symaddr
;
439 /* The special local symbols don't go in the
440 minimal symbol table, so ignore this one. */
443 /* Not a special stabs-in-elf symbol, do regular
444 symbol processing. */
445 if (sym
->section
->flags
& SEC_LOAD
)
447 ms_type
= mst_file_data
;
451 ms_type
= mst_file_bss
;
456 ms_type
= mst_unknown
;
461 /* FIXME: Solaris2 shared libraries include lots of
462 odd "absolute" and "undefined" symbols, that play
463 hob with actions like finding what function the PC
464 is in. Ignore them if they aren't text, data, or bss. */
465 /* ms_type = mst_unknown; */
466 continue; /* Skip this symbol. */
468 /* Pass symbol size field in via BFD. FIXME!!! */
469 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
470 msym
= record_minimal_symbol_and_info
471 ((char *) sym
->name
, symaddr
,
472 ms_type
, (void *) size
, sym
->section
, objfile
);
473 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
475 msym
->filename
= filesymname
;
477 ELF_MAKE_MSYMBOL_SPECIAL (sym
, msym
);
480 do_cleanups (back_to
);
484 /* Scan and build partial symbols for a symbol file.
485 We have been initialized by a call to elf_symfile_init, which
486 currently does nothing.
488 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
489 in each section. We simplify it down to a single offset for all
492 MAINLINE is true if we are reading the main symbol
493 table (as opposed to a shared lib or dynamically loaded file).
495 This function only does the minimum work necessary for letting the
496 user "name" things symbolically; it does not read the entire symtab.
497 Instead, it reads the external and static symbols and puts them in partial
498 symbol tables. When more extensive information is requested of a
499 file, the corresponding partial symbol table is mutated into a full
500 fledged symbol table by going back and reading the symbols
503 We look for sections with specific names, to tell us what debug
504 format to look for: FIXME!!!
506 dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
507 elfstab_build_psymtabs() handles STABS symbols;
508 mdebug_build_psymtabs() handles ECOFF debugging information.
510 Note that ELF files have a "minimal" symbol table, which looks a lot
511 like a COFF symbol table, but has only the minimal information necessary
512 for linking. We process this also, and use the information to
513 build gdb's minimal symbol table. This gives us some minimal debugging
514 capability even for files compiled without -g. */
517 elf_symfile_read (struct objfile
*objfile
, int mainline
)
519 bfd
*abfd
= objfile
->obfd
;
521 struct cleanup
*back_to
;
524 init_minimal_symbol_collection ();
525 back_to
= make_cleanup_discard_minimal_symbols ();
527 memset ((char *) &ei
, 0, sizeof (ei
));
529 /* Allocate struct to keep track of the symfile */
530 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
531 xmmalloc (objfile
->md
, sizeof (struct dbx_symfile_info
));
532 memset ((char *) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
533 make_cleanup (free_elfinfo
, (void *) objfile
);
535 /* Process the normal ELF symbol table first. This may write some
536 chain of info into the dbx_symfile_info in objfile->sym_stab_info,
537 which can later be used by elfstab_offset_sections. */
539 elf_symtab_read (objfile
, 0);
541 /* Add the dynamic symbols. */
543 elf_symtab_read (objfile
, 1);
545 /* Install any minimal symbols that have been collected as the current
546 minimal symbols for this objfile. The debug readers below this point
547 should not generate new minimal symbols; if they do it's their
548 responsibility to install them. "mdebug" appears to be the only one
549 which will do this. */
551 install_minimal_symbols (objfile
);
552 do_cleanups (back_to
);
554 /* Now process debugging information, which is contained in
555 special ELF sections. */
557 /* If we are reinitializing, or if we have never loaded syms yet,
558 set table to empty. MAINLINE is cleared so that *_read_psymtab
559 functions do not all also re-initialize the psymbol table. */
562 init_psymbol_list (objfile
, 0);
566 /* We first have to find them... */
567 bfd_map_over_sections (abfd
, elf_locate_sections
, (void *) & ei
);
569 /* ELF debugging information is inserted into the psymtab in the
570 order of least informative first - most informative last. Since
571 the psymtab table is searched `most recent insertion first' this
572 increases the probability that more detailed debug information
573 for a section is found.
575 For instance, an object file might contain both .mdebug (XCOFF)
576 and .debug_info (DWARF2) sections then .mdebug is inserted first
577 (searched last) and DWARF2 is inserted last (searched first). If
578 we don't do this then the XCOFF info is found first - for code in
579 an included file XCOFF info is useless. */
583 const struct ecoff_debug_swap
*swap
;
585 /* .mdebug section, presumably holding ECOFF debugging
587 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
589 elfmdebug_build_psymtabs (objfile
, swap
, ei
.mdebugsect
);
595 /* Stab sections have an associated string table that looks like
596 a separate section. */
597 str_sect
= bfd_get_section_by_name (abfd
, ".stabstr");
599 /* FIXME should probably warn about a stab section without a stabstr. */
601 elfstab_build_psymtabs (objfile
,
605 bfd_section_size (abfd
, str_sect
));
607 if (dwarf2_has_info (abfd
))
609 /* DWARF 2 sections */
610 dwarf2_build_psymtabs (objfile
, mainline
);
612 else if (ei
.dboffset
&& ei
.lnoffset
)
615 dwarf_build_psymtabs (objfile
,
617 ei
.dboffset
, ei
.dbsize
,
618 ei
.lnoffset
, ei
.lnsize
);
621 /* FIXME: kettenis/20030504: This still needs to be integrated with
622 dwarf2read.c in a better way. */
623 dwarf2_build_frame_info (objfile
);
626 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
627 stab_section_info's, that might be dangling from it. */
630 free_elfinfo (void *objp
)
632 struct objfile
*objfile
= (struct objfile
*) objp
;
633 struct dbx_symfile_info
*dbxinfo
= objfile
->sym_stab_info
;
634 struct stab_section_info
*ssi
, *nssi
;
636 ssi
= dbxinfo
->stab_section_info
;
640 xmfree (objfile
->md
, ssi
);
644 dbxinfo
->stab_section_info
= 0; /* Just say No mo info about this. */
648 /* Initialize anything that needs initializing when a completely new symbol
649 file is specified (not just adding some symbols from another file, e.g. a
652 We reinitialize buildsym, since we may be reading stabs from an ELF file. */
655 elf_new_init (struct objfile
*ignore
)
657 stabsread_new_init ();
658 buildsym_new_init ();
661 /* Perform any local cleanups required when we are done with a particular
662 objfile. I.E, we are in the process of discarding all symbol information
663 for an objfile, freeing up all memory held for it, and unlinking the
664 objfile struct from the global list of known objfiles. */
667 elf_symfile_finish (struct objfile
*objfile
)
669 if (objfile
->sym_stab_info
!= NULL
)
671 xmfree (objfile
->md
, objfile
->sym_stab_info
);
675 /* ELF specific initialization routine for reading symbols.
677 It is passed a pointer to a struct sym_fns which contains, among other
678 things, the BFD for the file whose symbols are being read, and a slot for
679 a pointer to "private data" which we can fill with goodies.
681 For now at least, we have nothing in particular to do, so this function is
685 elf_symfile_init (struct objfile
*objfile
)
687 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
688 find this causes a significant slowdown in gdb then we could
689 set it in the debug symbol readers only when necessary. */
690 objfile
->flags
|= OBJF_REORDERED
;
693 /* When handling an ELF file that contains Sun STABS debug info,
694 some of the debug info is relative to the particular chunk of the
695 section that was generated in its individual .o file. E.g.
696 offsets to static variables are relative to the start of the data
697 segment *for that module before linking*. This information is
698 painfully squirreled away in the ELF symbol table as local symbols
699 with wierd names. Go get 'em when needed. */
702 elfstab_offset_sections (struct objfile
*objfile
, struct partial_symtab
*pst
)
704 char *filename
= pst
->filename
;
705 struct dbx_symfile_info
*dbx
= objfile
->sym_stab_info
;
706 struct stab_section_info
*maybe
= dbx
->stab_section_info
;
707 struct stab_section_info
*questionable
= 0;
711 /* The ELF symbol info doesn't include path names, so strip the path
712 (if any) from the psymtab filename. */
713 while (0 != (p
= strchr (filename
, '/')))
716 /* FIXME: This linear search could speed up significantly
717 if it was chained in the right order to match how we search it,
718 and if we unchained when we found a match. */
719 for (; maybe
; maybe
= maybe
->next
)
721 if (filename
[0] == maybe
->filename
[0]
722 && STREQ (filename
, maybe
->filename
))
724 /* We found a match. But there might be several source files
725 (from different directories) with the same name. */
726 if (0 == maybe
->found
)
728 questionable
= maybe
; /* Might use it later. */
732 if (maybe
== 0 && questionable
!= 0)
734 complaint (&symfile_complaints
,
735 "elf/stab section information questionable for %s", filename
);
736 maybe
= questionable
;
741 /* Found it! Allocate a new psymtab struct, and fill it in. */
743 pst
->section_offsets
= (struct section_offsets
*)
744 obstack_alloc (&objfile
->psymbol_obstack
,
745 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
746 for (i
= 0; i
< maybe
->num_sections
; i
++)
747 (pst
->section_offsets
)->offsets
[i
] = maybe
->sections
[i
];
751 /* We were unable to find any offsets for this file. Complain. */
752 if (dbx
->stab_section_info
) /* If there *is* any info, */
753 complaint (&symfile_complaints
,
754 "elf/stab section information missing for %s", filename
);
757 /* Register that we are able to handle ELF object file formats. */
759 static struct sym_fns elf_sym_fns
=
761 bfd_target_elf_flavour
,
762 elf_new_init
, /* sym_new_init: init anything gbl to entire symtab */
763 elf_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
764 elf_symfile_read
, /* sym_read: read a symbol file into symtab */
765 elf_symfile_finish
, /* sym_finish: finished with file, cleanup */
766 default_symfile_offsets
, /* sym_offsets: Translate ext. to int. relocation */
767 NULL
/* next: pointer to next struct sym_fns */
771 _initialize_elfread (void)
773 add_symtab_fns (&elf_sym_fns
);