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. */
21 /************************************************************************
25 * This file is still under construction. When it is complete, this *
26 * notice will be removed. Until then, direct any questions or changes *
27 * to Fred Fish at Cygnus Support (fnf@cygnus.com) *
29 * FIXME Still needs support for shared libraries. *
30 * FIXME Still needs support for core files. *
31 * FIXME The ".debug" and ".line" section names are hardwired. *
33 ************************************************************************/
36 #include "elf/common.h"
37 #include "elf/external.h"
38 #include "elf/internal.h"
45 #define STREQ(a,b) (strcmp((a),(b))==0)
48 unsigned int dboffset
; /* Offset to dwarf debug section */
49 unsigned int dbsize
; /* Size of dwarf debug section */
50 unsigned int lnoffset
; /* Offset to dwarf line number section */
51 unsigned int lnsize
; /* Size of dwarf line number section */
55 elf_symfile_init
PARAMS ((struct objfile
*));
58 elf_new_init
PARAMS ((struct objfile
*));
61 elf_symfile_read
PARAMS ((struct objfile
*, CORE_ADDR
, int));
64 elf_symfile_finish
PARAMS ((struct objfile
*));
67 elf_symtab_read
PARAMS ((bfd
*, CORE_ADDR
, struct objfile
*));
70 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, enum minimal_symbol_type
,
74 elf_locate_sections
PARAMS ((bfd
*, asection
*, PTR
));
76 /* We are called once per section from elf_symfile_read. We
77 need to examine each section we are passed, check to see
78 if it is something we are interested in processing, and
79 if so, stash away some access information for the section.
81 For now we recognize the dwarf debug information sections and
82 line number sections from matching their section names. The
83 ELF definition is no real help here since it has no direct
84 knowledge of DWARF (by design, so any debugging format can be
87 FIXME: The section names should not be hardwired strings. */
90 elf_locate_sections (ignore_abfd
, sectp
, eip
)
95 register struct elfinfo
*ei
;
97 ei
= (struct elfinfo
*) eip
;
98 if (STREQ (sectp
-> name
, ".debug"))
100 ei
-> dboffset
= sectp
-> filepos
;
101 ei
-> dbsize
= bfd_get_section_size_before_reloc (sectp
);
103 else if (STREQ (sectp
-> name
, ".line"))
105 ei
-> lnoffset
= sectp
-> filepos
;
106 ei
-> lnsize
= bfd_get_section_size_before_reloc (sectp
);
110 #if 0 /* Currently unused */
113 elf_interpreter (abfd
)
120 interp_sec
= bfd_get_section_by_name (abfd
, ".interp");
123 size
= bfd_section_size (abfd
, interp_sec
);
124 interp
= alloca (size
);
125 if (bfd_get_section_contents (abfd
, interp_sec
, interp
, (file_ptr
)0,
128 interp
= savestring (interp
, size
- 1);
144 record_minimal_symbol -- add entry to minimal symbol table
148 static void record_minimal_symbol (char *name, CORE_ADDR address)
152 Given a pointer to the name of a symbol that should be added to the
153 minimal symbol table and the address associated with that symbol, records
154 this information for later use in building the minimal symbol table.
159 record_minimal_symbol (name
, address
, ms_type
, objfile
)
162 enum minimal_symbol_type ms_type
;
163 struct objfile
*objfile
;
165 name
= obsavestring (name
, strlen (name
), &objfile
-> symbol_obstack
);
166 prim_record_minimal_symbol (name
, address
, ms_type
);
173 elf_symtab_read -- read the symbol table of an ELF file
177 void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
178 struct objfile *objfile)
182 Given an open bfd, a base address to relocate symbols to, and a
183 flag that specifies whether or not this bfd is for an executable
184 or not (may be shared library for example), add all the global
185 function and data symbols to the minimal symbol table.
190 elf_symtab_read (abfd
, addr
, objfile
)
193 struct objfile
*objfile
;
195 unsigned int storage_needed
;
197 asymbol
**symbol_table
;
198 unsigned int number_of_symbols
;
200 struct cleanup
*back_to
;
202 enum minimal_symbol_type ms_type
;
204 storage_needed
= get_symtab_upper_bound (abfd
);
206 if (storage_needed
> 0)
208 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
209 back_to
= make_cleanup (free
, symbol_table
);
210 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
212 for (i
= 0; i
< number_of_symbols
; i
++)
214 sym
= *symbol_table
++;
215 /* Select global/weak symbols that are defined in a specific section.
216 Note that bfd now puts abs symbols in their own section, so
217 all symbols we are interested in will have a section. */
218 if ((sym
-> flags
& (BSF_GLOBAL
| BSF_WEAK
))
219 && (sym
-> section
!= NULL
))
221 symaddr
= sym
-> value
;
222 /* Relocate all non-absolute symbols by base address. */
223 if (sym
-> section
!= &bfd_abs_section
)
227 /* For non-absolute symbols, use the type of the section
228 they are relative to, to intuit text/data. Bfd provides
229 no way of figuring this out for absolute symbols. */
230 if (sym
-> section
-> flags
& SEC_CODE
)
234 else if (sym
-> section
-> flags
& SEC_DATA
)
240 ms_type
= mst_unknown
;
242 record_minimal_symbol ((char *) sym
-> name
, symaddr
, ms_type
, objfile
);
245 do_cleanups (back_to
);
249 /* Scan and build partial symbols for a symbol file.
250 We have been initialized by a call to elf_symfile_init, which
251 currently does nothing.
253 ADDR is the address relative to which the symbols in it are (e.g.
254 the base address of the text segment).
256 MAINLINE is true if we are reading the main symbol
257 table (as opposed to a shared lib or dynamically loaded file).
259 This function only does the minimum work necessary for letting the
260 user "name" things symbolically; it does not read the entire symtab.
261 Instead, it reads the external and static symbols and puts them in partial
262 symbol tables. When more extensive information is requested of a
263 file, the corresponding partial symbol table is mutated into a full
264 fledged symbol table by going back and reading the symbols
265 for real. The function dwarf_psymtab_to_symtab() is the function that
266 does this for DWARF symbols.
268 Note that ELF files have a "minimal" symbol table, which looks a lot
269 like a COFF symbol table, but has only the minimal information necessary
270 for linking. We process this also, and just use the information to
271 add to gdb's minimal symbol table. This gives us some minimal debugging
272 capability even for files compiled without -g.
276 elf_symfile_read (objfile
, addr
, mainline
)
277 struct objfile
*objfile
;
281 bfd
*abfd
= objfile
->obfd
;
283 struct cleanup
*back_to
;
286 init_minimal_symbol_collection ();
287 back_to
= make_cleanup (discard_minimal_symbols
, 0);
289 /* Compute the amount to relocate all symbols by. The value passed in
290 as ADDR is typically either the actual address of the text section,
291 or a user specified address. By subtracting off the actual address
292 of the text section, we can compute the relocation amount. */
294 text_sect
= bfd_get_section_by_name (objfile
-> obfd
, ".text");
295 addr
-= bfd_section_vma (objfile
-> obfd
, text_sect
);
297 /* Process the normal ELF symbol table first. */
299 elf_symtab_read (abfd
, addr
, objfile
);
301 /* Now process the DWARF debugging information, which is contained in
302 special ELF sections. We first have to find them... */
304 (void) memset ((char *) &ei
, 0, sizeof (ei
));
305 bfd_map_over_sections (abfd
, elf_locate_sections
, (PTR
) &ei
);
306 if (ei
.dboffset
&& ei
.lnoffset
)
308 dwarf_build_psymtabs (fileno ((FILE *)(abfd
-> iostream
)),
309 bfd_get_filename (abfd
),
311 ei
.dboffset
, ei
.dbsize
,
312 ei
.lnoffset
, ei
.lnsize
, objfile
);
315 if (!have_partial_symbols ())
318 printf_filtered ("(no debugging symbols found)...");
322 /* Install any minimal symbols that have been collected as the current
323 minimal symbols for this objfile. */
325 install_minimal_symbols (objfile
);
327 do_cleanups (back_to
);
330 /* Initialize anything that needs initializing when a completely new symbol
331 file is specified (not just adding some symbols from another file, e.g. a
334 For now at least, we have nothing in particular to do, so this function is
338 elf_new_init (ignore
)
339 struct objfile
*ignore
;
341 buildsym_new_init ();
344 /* Perform any local cleanups required when we are done with a particular
345 objfile. I.E, we are in the process of discarding all symbol information
346 for an objfile, freeing up all memory held for it, and unlinking the
347 objfile struct from the global list of known objfiles. */
350 elf_symfile_finish (objfile
)
351 struct objfile
*objfile
;
353 if (objfile
-> sym_private
!= NULL
)
355 mfree (objfile
-> md
, objfile
-> sym_private
);
359 /* ELF specific initialization routine for reading symbols.
361 It is passed a pointer to a struct sym_fns which contains, among other
362 things, the BFD for the file whose symbols are being read, and a slot for
363 a pointer to "private data" which we can fill with goodies.
365 For now at least, we have nothing in particular to do, so this function is
369 elf_symfile_init (ignore
)
370 struct objfile
*ignore
;
375 /* Register that we are able to handle ELF object file formats and DWARF
378 Unlike other object file formats, where the debugging information format
379 is implied by the object file format, the ELF object file format and the
380 DWARF debugging information format are two distinct, and potentially
381 separate entities. I.E. it is perfectly possible to have ELF objects
382 with debugging formats other than DWARF. And it is conceivable that the
383 DWARF debugging format might be used with another object file format,
384 like COFF, by simply using COFF's custom section feature.
386 GDB, and to a lesser extent BFD, should support the notion of separate
387 object file formats and debugging information formats. For now, we just
388 use "elf" in the same sense as "a.out" or "coff", to imply both the ELF
389 object file format and the DWARF debugging format. */
391 static struct sym_fns elf_sym_fns
=
393 "elf", /* sym_name: name or name prefix of BFD target type */
394 3, /* sym_namelen: number of significant sym_name chars */
395 elf_new_init
, /* sym_new_init: init anything gbl to entire symtab */
396 elf_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
397 elf_symfile_read
, /* sym_read: read a symbol file into symtab */
398 elf_symfile_finish
, /* sym_finish: finished with file, cleanup */
399 NULL
/* next: pointer to next struct sym_fns */
403 _initialize_elfread ()
405 add_symtab_fns (&elf_sym_fns
);