1 /* Read ELF (Executable and Linking Format) object files for GDB.
2 Copyright 1991, 1992 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. */
23 #include <time.h> /* For time_t in libbfd.h. */
24 #include <sys/types.h> /* For time_t, if not in time.h. */
25 #include "libbfd.h" /* For bfd_elf_find_section */
31 #include "stabsread.h"
32 #include "gdb-stabs.h"
33 #include "complaints.h"
37 /* The struct elfinfo is available only during ELF symbol table and
38 psymtab reading. It is destroyed at the complation of psymtab-reading.
39 It's local to elf_symfile_read. */
42 file_ptr dboffset
; /* Offset to dwarf debug section */
43 unsigned int dbsize
; /* Size of dwarf debug section */
44 file_ptr lnoffset
; /* Offset to dwarf line number section */
45 unsigned int lnsize
; /* Size of dwarf line number section */
46 asection
*stabsect
; /* Section pointer for .stab section */
47 asection
*stabindexsect
; /* Section pointer for .stab.index section */
50 /* Various things we might complain about... */
52 struct complaint section_info_complaint
=
53 {"elf/stab section information %s without a preceding file symbol", 0, 0};
55 struct complaint section_info_dup_complaint
=
56 {"duplicated elf/stab section information for %s", 0, 0};
58 struct complaint stab_info_mismatch_complaint
=
59 {"elf/stab section information missing for %s", 0, 0};
61 struct complaint stab_info_questionable_complaint
=
62 {"elf/stab section information questionable for %s", 0, 0};
65 elf_symfile_init
PARAMS ((struct objfile
*));
68 elf_new_init
PARAMS ((struct objfile
*));
71 elf_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
74 elf_symfile_finish
PARAMS ((struct objfile
*));
77 elf_symtab_read
PARAMS ((bfd
*, CORE_ADDR
, struct objfile
*));
80 free_elfinfo
PARAMS ((PTR
));
82 static struct section_offsets
*
83 elf_symfile_offsets
PARAMS ((struct objfile
*, CORE_ADDR
));
86 record_minimal_symbol_and_info
PARAMS ((char *, CORE_ADDR
,
87 enum minimal_symbol_type
, char *,
91 elf_locate_sections
PARAMS ((bfd
*, asection
*, PTR
));
93 /* We are called once per section from elf_symfile_read. We
94 need to examine each section we are passed, check to see
95 if it is something we are interested in processing, and
96 if so, stash away some access information for the section.
98 For now we recognize the dwarf debug information sections and
99 line number sections from matching their section names. The
100 ELF definition is no real help here since it has no direct
101 knowledge of DWARF (by design, so any debugging format can be
104 We also recognize the ".stab" sections used by the Sun compilers
105 released with Solaris 2.
107 FIXME: The section names should not be hardwired strings (what
108 should they be? I don't think most object file formats have enough
109 section flags to specify what kind of debug section it is
113 elf_locate_sections (ignore_abfd
, sectp
, eip
)
118 register struct elfinfo
*ei
;
120 ei
= (struct elfinfo
*) eip
;
121 if (STREQ (sectp
-> name
, ".debug"))
123 ei
-> dboffset
= sectp
-> filepos
;
124 ei
-> dbsize
= bfd_get_section_size_before_reloc (sectp
);
126 else if (STREQ (sectp
-> name
, ".line"))
128 ei
-> lnoffset
= sectp
-> filepos
;
129 ei
-> lnsize
= bfd_get_section_size_before_reloc (sectp
);
131 else if (STREQ (sectp
-> name
, ".stab"))
133 ei
-> stabsect
= sectp
;
135 else if (STREQ (sectp
-> name
, ".stab.index"))
137 ei
-> stabindexsect
= 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);
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
;
191 section
= SECT_OFF_DATA
;
195 section
= SECT_OFF_BSS
;
202 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
203 prim_record_minimal_symbol_and_info (name
, address
, ms_type
, info
, section
);
210 elf_symtab_read -- read the symbol table of an ELF file
214 void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
215 struct objfile *objfile)
219 Given an open bfd, a base address to relocate symbols to, and a
220 flag that specifies whether or not this bfd is for an executable
221 or not (may be shared library for example), add all the global
222 function and data symbols to the minimal symbol table.
224 In stabs-in-ELF, as implemented by Sun, there are some local symbols
225 defined in the ELF symbol table, which can be used to locate
226 the beginnings of sections from each ".o" file that was linked to
227 form the executable objfile. We gather any such info and record it
228 in data structures hung off the objfile's private data.
233 elf_symtab_read (abfd
, addr
, objfile
)
236 struct objfile
*objfile
;
238 unsigned int storage_needed
;
240 asymbol
**symbol_table
;
241 unsigned int number_of_symbols
;
244 struct cleanup
*back_to
;
246 enum minimal_symbol_type ms_type
;
247 /* If sectinfo is nonNULL, it contains section info that should end up
248 filed in the objfile. */
249 struct stab_section_info
*sectinfo
= NULL
;
250 /* If filesym is nonzero, it points to a file symbol, but we haven't
251 seen any section info for it yet. */
252 asymbol
*filesym
= 0;
253 struct dbx_symfile_info
*dbx
= (struct dbx_symfile_info
*)
254 objfile
->sym_private
;
257 storage_needed
= get_symtab_upper_bound (abfd
);
258 if (storage_needed
> 0)
260 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
261 back_to
= make_cleanup (free
, symbol_table
);
262 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
263 for (i
= 0; i
< number_of_symbols
; i
++)
265 sym
= symbol_table
[i
];
266 if (sym
-> name
== NULL
|| *sym
-> name
== '\0')
268 /* Skip names that don't exist (shouldn't happen), or names
269 that are null strings (may happen). */
272 if (sym
-> flags
& BSF_FILE
)
274 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
275 Chain any old one onto the objfile; remember new sym. */
276 if (sectinfo
!= NULL
)
278 sectinfo
-> next
= dbx
-> stab_section_info
;
279 dbx
-> stab_section_info
= sectinfo
;
284 else if (sym
-> flags
& (BSF_GLOBAL
| BSF_LOCAL
| BSF_WEAK
))
286 /* Select global/local/weak symbols. Note that bfd puts abs
287 symbols in their own section, so all symbols we are
288 interested in will have a section. */
289 /* Bfd symbols are section relative. */
290 symaddr
= sym
-> value
+ sym
-> section
-> vma
;
291 /* Relocate all non-absolute symbols by base address. */
292 if (sym
-> section
!= &bfd_abs_section
)
296 /* For non-absolute symbols, use the type of the section
297 they are relative to, to intuit text/data. Bfd provides
298 no way of figuring this out for absolute symbols. */
299 if (sym
-> section
== &bfd_abs_section
)
303 else if (sym
-> section
-> flags
& SEC_CODE
)
305 if (sym
-> flags
& BSF_GLOBAL
)
309 else if (sym
->name
[0] == '.' && sym
->name
[1] == 'L')
310 /* Looks like a compiler-generated label. Skip it.
311 The assembler should be skipping these (to keep
312 executables small), but apparently with gcc on the
313 delta m88k SVR4, it loses. So to have us check too
314 should be harmless (but I encourage people to fix this
315 in the assembler instead of adding checks here). */
319 ms_type
= mst_file_text
;
322 else if (sym
-> section
-> flags
& SEC_DATA
)
324 if (sym
-> flags
& BSF_GLOBAL
)
326 if (sym
-> section
-> flags
& SEC_HAS_CONTENTS
)
335 else if (sym
-> flags
& BSF_LOCAL
)
337 /* Named Local variable in a Data section. Check its
338 name for stabs-in-elf. The STREQ macro checks the
339 first character inline, so we only actually do a
340 strcmp function call on names that start with 'B'
342 index
= SECT_OFF_MAX
;
343 if (STREQ ("Bbss.bss", sym
-> name
))
345 index
= SECT_OFF_BSS
;
347 else if (STREQ ("Ddata.data", sym
-> name
))
349 index
= SECT_OFF_DATA
;
351 else if (STREQ ("Drodata.rodata", sym
-> name
))
353 index
= SECT_OFF_RODATA
;
355 if (index
!= SECT_OFF_MAX
)
357 /* Found a special local symbol. Allocate a
358 sectinfo, if needed, and fill it in. */
359 if (sectinfo
== NULL
)
361 sectinfo
= (struct stab_section_info
*)
362 xmmalloc (objfile
-> md
, sizeof (*sectinfo
));
363 memset ((PTR
) sectinfo
, 0, sizeof (*sectinfo
));
366 complain (§ion_info_complaint
,
371 sectinfo
-> filename
=
372 (char *) filesym
-> name
;
375 if (sectinfo
-> sections
[index
] != 0)
377 complain (§ion_info_dup_complaint
,
378 sectinfo
-> filename
);
380 /* Bfd symbols are section relative. */
381 symaddr
= sym
-> value
+ sym
-> section
-> vma
;
382 /* Relocate non-absolute symbols by base address. */
383 if (sym
-> section
!= &bfd_abs_section
)
387 sectinfo
-> sections
[index
] = symaddr
;
388 /* The special local symbols don't go in the
389 minimal symbol table, so ignore this one. */
392 /* Not a special stabs-in-elf symbol, do regular
393 symbol processing. */
394 if (sym
-> section
-> flags
& SEC_HAS_CONTENTS
)
396 ms_type
= mst_file_data
;
400 ms_type
= mst_file_bss
;
405 ms_type
= mst_unknown
;
410 /* FIXME: Solaris2 shared libraries include lots of
411 odd "absolute" and "undefined" symbols, that play
412 hob with actions like finding what function the PC
413 is in. Ignore them if they aren't text, data, or bss. */
414 /* ms_type = mst_unknown; */
415 continue; /* Skip this symbol. */
417 /* Pass symbol size field in via BFD. FIXME!!! */
418 size
= ((elf_symbol_type
*) sym
) -> internal_elf_sym
.st_size
;
419 record_minimal_symbol_and_info ((char *) sym
-> name
, symaddr
,
420 ms_type
, (PTR
) size
, objfile
);
423 do_cleanups (back_to
);
427 /* Scan and build partial symbols for a symbol file.
428 We have been initialized by a call to elf_symfile_init, which
429 currently does nothing.
431 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
432 in each section. We simplify it down to a single offset for all
435 MAINLINE is true if we are reading the main symbol
436 table (as opposed to a shared lib or dynamically loaded file).
438 This function only does the minimum work necessary for letting the
439 user "name" things symbolically; it does not read the entire symtab.
440 Instead, it reads the external and static symbols and puts them in partial
441 symbol tables. When more extensive information is requested of a
442 file, the corresponding partial symbol table is mutated into a full
443 fledged symbol table by going back and reading the symbols
446 We look for sections with specific names, to tell us what debug
447 format to look for: FIXME!!!
449 dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
450 elfstab_build_psymtabs() handles STABS symbols.
452 Note that ELF files have a "minimal" symbol table, which looks a lot
453 like a COFF symbol table, but has only the minimal information necessary
454 for linking. We process this also, and use the information to
455 build gdb's minimal symbol table. This gives us some minimal debugging
456 capability even for files compiled without -g. */
459 elf_symfile_read (objfile
, section_offsets
, mainline
)
460 struct objfile
*objfile
;
461 struct section_offsets
*section_offsets
;
464 bfd
*abfd
= objfile
->obfd
;
466 struct cleanup
*back_to
;
469 init_minimal_symbol_collection ();
470 back_to
= make_cleanup (discard_minimal_symbols
, 0);
472 memset ((char *) &ei
, 0, sizeof (ei
));
474 /* Allocate struct to keep track of the symfile */
475 objfile
->sym_private
= (PTR
)
476 xmmalloc (objfile
-> md
, sizeof (struct dbx_symfile_info
));
477 memset ((char *) objfile
->sym_private
, 0, sizeof (struct dbx_symfile_info
));
478 make_cleanup (free_elfinfo
, (PTR
) objfile
);
480 /* Process the normal ELF symbol table first. This may write some
481 chain of info into the dbx_symfile_info in objfile->sym_private,
482 which can later be used by elfstab_offset_sections. */
484 /* FIXME, should take a section_offsets param, not just an offset. */
485 offset
= ANOFFSET (section_offsets
, 0);
486 elf_symtab_read (abfd
, offset
, objfile
);
488 /* Now process debugging information, which is contained in
489 special ELF sections. We first have to find them... */
491 bfd_map_over_sections (abfd
, elf_locate_sections
, (PTR
) &ei
);
492 if (ei
.dboffset
&& ei
.lnoffset
)
495 dwarf_build_psymtabs (objfile
,
496 section_offsets
, mainline
,
497 ei
.dboffset
, ei
.dbsize
,
498 ei
.lnoffset
, ei
.lnsize
);
504 /* FIXME: Sun didn't really know how to implement this well.
505 They made .stab sections that don't point to the .stabstr
506 section with the sh_link field. BFD doesn't make string table
507 sections visible to the caller. So we have to search the
508 ELF section table, not the BFD section table, for the string
510 struct elf32_internal_shdr
*elf_sect
;
512 elf_sect
= bfd_elf_find_section (abfd
, ".stabstr");
514 elfstab_build_psymtabs (objfile
,
517 ei
.stabsect
->filepos
, /* .stab offset */
518 bfd_get_section_size_before_reloc (ei
.stabsect
),/* .stab size */
519 (file_ptr
) elf_sect
->sh_offset
, /* .stabstr offset */
520 elf_sect
->sh_size
); /* .stabstr size */
523 if (!have_partial_symbols ())
526 printf_filtered ("(no debugging symbols found)...");
530 /* Install any minimal symbols that have been collected as the current
531 minimal symbols for this objfile. */
533 install_minimal_symbols (objfile
);
535 do_cleanups (back_to
);
538 /* This cleans up the objfile's sym_private pointer, and the chain of
539 stab_section_info's, that might be dangling from it. */
545 struct objfile
*objfile
= (struct objfile
*)objp
;
546 struct dbx_symfile_info
*dbxinfo
= (struct dbx_symfile_info
*)
547 objfile
->sym_private
;
548 struct stab_section_info
*ssi
, *nssi
;
550 ssi
= dbxinfo
->stab_section_info
;
554 mfree (objfile
->md
, ssi
);
558 dbxinfo
->stab_section_info
= 0; /* Just say No mo info about this. */
562 /* Initialize anything that needs initializing when a completely new symbol
563 file is specified (not just adding some symbols from another file, e.g. a
566 We reinitialize buildsym, since we may be reading stabs from an ELF file. */
569 elf_new_init (ignore
)
570 struct objfile
*ignore
;
572 stabsread_new_init ();
573 buildsym_new_init ();
576 /* Perform any local cleanups required when we are done with a particular
577 objfile. I.E, we are in the process of discarding all symbol information
578 for an objfile, freeing up all memory held for it, and unlinking the
579 objfile struct from the global list of known objfiles. */
582 elf_symfile_finish (objfile
)
583 struct objfile
*objfile
;
585 if (objfile
-> sym_private
!= NULL
)
587 mfree (objfile
-> md
, objfile
-> sym_private
);
591 /* ELF specific initialization routine for reading symbols.
593 It is passed a pointer to a struct sym_fns which contains, among other
594 things, the BFD for the file whose symbols are being read, and a slot for
595 a pointer to "private data" which we can fill with goodies.
597 For now at least, we have nothing in particular to do, so this function is
601 elf_symfile_init (ignore
)
602 struct objfile
*ignore
;
606 /* ELF specific parsing routine for section offsets.
608 Plain and simple for now. */
611 struct section_offsets
*
612 elf_symfile_offsets (objfile
, addr
)
613 struct objfile
*objfile
;
616 struct section_offsets
*section_offsets
;
619 section_offsets
= (struct section_offsets
*)
620 obstack_alloc (&objfile
-> psymbol_obstack
,
621 sizeof (struct section_offsets
) +
622 sizeof (section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
624 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
625 ANOFFSET (section_offsets
, i
) = addr
;
627 return section_offsets
;
630 /* When handling an ELF file that contains Sun STABS debug info,
631 some of the debug info is relative to the particular chunk of the
632 section that was generated in its individual .o file. E.g.
633 offsets to static variables are relative to the start of the data
634 segment *for that module before linking*. This information is
635 painfully squirreled away in the ELF symbol table as local symbols
636 with wierd names. Go get 'em when needed. */
639 elfstab_offset_sections (objfile
, pst
)
640 struct objfile
*objfile
;
641 struct partial_symtab
*pst
;
643 char *filename
= pst
->filename
;
644 struct dbx_symfile_info
*dbx
= (struct dbx_symfile_info
*)
645 objfile
->sym_private
;
646 struct stab_section_info
*maybe
= dbx
->stab_section_info
;
647 struct stab_section_info
*questionable
= 0;
651 /* The ELF symbol info doesn't include path names, so strip the path
652 (if any) from the psymtab filename. */
653 while (0 != (p
= strchr (filename
, '/')))
656 /* FIXME: This linear search could speed up significantly
657 if it was chained in the right order to match how we search it,
658 and if we unchained when we found a match. */
659 for (; maybe
; maybe
= maybe
->next
)
661 if (filename
[0] == maybe
->filename
[0]
662 && STREQ (filename
, maybe
->filename
))
664 /* We found a match. But there might be several source files
665 (from different directories) with the same name. */
666 if (0 == maybe
->found
)
668 questionable
= maybe
; /* Might use it later. */
672 if (maybe
== 0 && questionable
!= 0)
674 complain (&stab_info_questionable_complaint
, filename
);
675 maybe
= questionable
;
680 /* Found it! Allocate a new psymtab struct, and fill it in. */
682 pst
->section_offsets
= (struct section_offsets
*)
683 obstack_alloc (&objfile
-> psymbol_obstack
,
684 sizeof (struct section_offsets
) +
685 sizeof (pst
->section_offsets
->offsets
) * (SECT_OFF_MAX
-1));
687 for (i
= 0; i
< SECT_OFF_MAX
; i
++)
688 ANOFFSET (pst
->section_offsets
, i
) = maybe
->sections
[i
];
692 /* We were unable to find any offsets for this file. Complain. */
693 if (dbx
->stab_section_info
) /* If there *is* any info, */
694 complain (&stab_info_mismatch_complaint
, filename
);
697 /* Register that we are able to handle ELF object file formats and DWARF
700 Unlike other object file formats, where the debugging information format
701 is implied by the object file format, the ELF object file format and the
702 DWARF debugging information format are two distinct, and potentially
703 separate entities. I.E. it is perfectly possible to have ELF objects
704 with debugging formats other than DWARF. And it is conceivable that the
705 DWARF debugging format might be used with another object file format,
706 like COFF, by simply using COFF's custom section feature.
708 GDB, and to a lesser extent BFD, should support the notion of separate
709 object file formats and debugging information formats. For now, we just
710 use "elf" in the same sense as "a.out" or "coff", to imply both the ELF
711 object file format and the DWARF debugging format. */
713 static struct sym_fns elf_sym_fns
=
715 "elf", /* sym_name: name or name prefix of BFD target type */
716 3, /* sym_namelen: number of significant sym_name chars */
717 elf_new_init
, /* sym_new_init: init anything gbl to entire symtab */
718 elf_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
719 elf_symfile_read
, /* sym_read: read a symbol file into symtab */
720 elf_symfile_finish
, /* sym_finish: finished with file, cleanup */
721 elf_symfile_offsets
, /* sym_offsets: Translate ext. to int. relocation */
722 NULL
/* next: pointer to next struct sym_fns */
726 _initialize_elfread ()
728 add_symtab_fns (&elf_sym_fns
);