1 /* Read ELF (Executable and Linking Format) object files for GDB.
2 Copyright (C) 1991 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@cygint) *
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. *
32 * FIXME Still needs support ELF symbol tables (as distinct *
33 * from DWARF support). Can use them to build the misc *
34 * function vector at least. This is fairly trivial once *
35 * bfd is extended to handle ELF symbol tables. *
37 ************************************************************************/
42 #include "elf/common.h"
43 #include "elf/external.h"
44 #include "elf/internal.h"
50 extern int EXFUN (strcmp
, (CONST
char *a
, CONST
char *b
));
51 extern int EXFUN (dwarf_build_psymtabs
,
52 (int desc
, char *filename
, CORE_ADDR addr
, int mainline
,
53 unsigned int dbfoff
, unsigned int dbsize
, unsigned int lnoffset
,
54 unsigned int lnsize
, struct objfile
*objfile
));
56 #define STREQ(a,b) (strcmp((a),(b))==0)
59 unsigned int dboffset
; /* Offset to dwarf debug section */
60 unsigned int dbsize
; /* Size of dwarf debug section */
61 unsigned int lnoffset
; /* Offset to dwarf line number section */
62 unsigned int lnsize
; /* Size of dwarf line number section */
65 /* We are called once per section from elf_symfile_read. We
66 need to examine each section we are passed, check to see
67 if it is something we are interested in processing, and
68 if so, stash away some access information for the section.
70 For now we recognize the dwarf debug information sections and
71 line number sections from matching their section names. The
72 ELF definition is no real help here since it has no direct
73 knowledge of DWARF (by design, so any debugging format can be
76 FIXME: The section names should not be hardwired strings. */
79 DEFUN(elf_locate_sections
, (abfd
, sectp
, ei
),
84 if (STREQ (sectp
-> name
, ".debug"))
86 ei
-> dboffset
= sectp
-> filepos
;
87 ei
-> dbsize
= sectp
-> size
;
89 else if (STREQ (sectp
-> name
, ".line"))
91 ei
-> lnoffset
= sectp
-> filepos
;
92 ei
-> lnsize
= sectp
-> size
;
100 record_misc_function -- add entry to miscellaneous function vector
104 static void record_misc_function (char *name, CORE_ADDR address)
108 Given a pointer to the name of a symbol that should be added to the
109 miscellaneous function vector, and the address associated with that
110 symbol, records this information for later use in building the
111 miscellaneous function vector.
115 FIXME: For now we just use mf_unknown as the type. This should be
120 DEFUN(record_misc_function
, (name
, address
), char *name AND CORE_ADDR address
)
122 prim_record_misc_function (obsavestring (name
, strlen (name
)), address
,
127 DEFUN (elf_symtab_read
, (abfd
, addr
),
131 unsigned int storage_needed
;
133 asymbol
**symbol_table
;
134 unsigned int number_of_symbols
;
136 struct cleanup
*back_to
;
138 storage_needed
= get_symtab_upper_bound (abfd
);
140 if (storage_needed
> 0)
142 symbol_table
= (asymbol
**) bfd_xmalloc (storage_needed
);
143 back_to
= make_cleanup (free
, symbol_table
);
144 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
146 for (i
= 0; i
< number_of_symbols
; i
++)
148 sym
= *symbol_table
++;
149 /* Select global symbols that are defined in a specific section
151 if (sym
-> flags
& BSF_GLOBAL
152 && ((sym
-> section
!= NULL
) || (sym
-> flags
& BSF_ABSOLUTE
)))
154 record_misc_function ((char *) sym
-> name
, sym
-> value
);
157 do_cleanups (back_to
);
161 /* Scan and build partial symbols for a symbol file.
162 We have been initialized by a call to elf_symfile_init, which
163 currently does nothing.
165 ADDR is the address relative to which the symbols in it are (e.g.
166 the base address of the text segment).
168 MAINLINE is true if we are reading the main symbol
169 table (as opposed to a shared lib or dynamically loaded file).
171 This function only does the minimum work necessary for letting the
172 user "name" things symbolically; it does not read the entire symtab.
173 Instead, it reads the external and static symbols and puts them in partial
174 symbol tables. When more extensive information is requested of a
175 file, the corresponding partial symbol table is mutated into a full
176 fledged symbol table by going back and reading the symbols
177 for real. The function dwarf_psymtab_to_symtab() is the function that
178 does this for DWARF symbols.
180 Note that ELF files have a "minimal" symbol table, which looks a lot
181 like a COFF symbol table, but has only the minimal information necessary
182 for linking. We process this also, and just use the information to
183 add to the misc function vector. This gives us some minimal debugging
184 capability even for files compiled without -g.
188 DEFUN(elf_symfile_read
, (sf
, addr
, mainline
),
189 struct sym_fns
*sf AND
193 bfd
*abfd
= sf
->objfile
->obfd
;
195 struct cleanup
*back_to
;
197 init_misc_bunches ();
198 back_to
= make_cleanup (discard_misc_bunches
, 0);
200 /* Process the normal ELF symbol table first. */
202 elf_symtab_read (abfd
, addr
);
204 /* Now process the DWARF debugging information, which is contained in
205 special ELF sections. We first have to find them... */
207 (void) memset ((char *) &ei
, 0, sizeof (ei
));
208 bfd_map_over_sections (abfd
, elf_locate_sections
, &ei
);
209 if (ei
.dboffset
&& ei
.lnoffset
)
211 addr
= 0; /* FIXME: force address base to zero for now */
212 dwarf_build_psymtabs (fileno ((FILE *)(abfd
-> iostream
)),
213 bfd_get_filename (abfd
),
215 ei
.dboffset
, ei
.dbsize
,
216 ei
.lnoffset
, ei
.lnsize
, sf
->objfile
);
219 if (!partial_symtab_list
)
222 printf_filtered ("(no debugging symbols found)...");
226 /* Go over the miscellaneous functions and install them in the
227 miscellaneous function vector. */
229 condense_misc_bunches (!mainline
);
230 do_cleanups (back_to
);
233 /* Initialize anything that needs initializing when a completely new symbol
234 file is specified (not just adding some symbols from another file, e.g. a
237 For now at least, we have nothing in particular to do, so this function is
241 DEFUN_VOID (elf_new_init
)
245 /* ELF specific initialization routine for reading symbols.
247 It is passed a pointer to a struct sym_fns which contains, among other
248 things, the BFD for the file whose symbols are being read, and a slot for
249 a pointer to "private data" which we can fill with goodies.
251 For now at least, we have nothing in particular to do, so this function is
255 DEFUN(elf_symfile_init
, (sf
),
261 /* Register that we are able to handle ELF object file formats and DWARF
264 Unlike other object file formats, where the debugging information format
265 is implied by the object file format, the ELF object file format and the
266 DWARF debugging information format are two distinct, and potentially
267 separate entities. I.E. it is perfectly possible to have ELF objects
268 with debugging formats other than DWARF. And it is conceivable that the
269 DWARF debugging format might be used with another object file format,
270 like COFF, by simply using COFF's custom section feature.
272 GDB, and to a lesser extent BFD, should support the notion of separate
273 object file formats and debugging information formats. For now, we just
274 use "elf" in the same sense as "a.out" or "coff", to imply both the ELF
275 object file format and the DWARF debugging format. */
277 static struct sym_fns elf_sym_fns
= {
278 "elf", /* sym_name: name or name prefix of BFD target type */
279 3, /* sym_namelen: number of significant sym_name chars */
280 elf_new_init
, /* sym_new_init: init anything gbl to entire symtab */
281 elf_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
282 elf_symfile_read
, /* sym_read: read a symbol file into symtab */
283 NULL
, /* sym_bfd: accessor for symbol file being read */
284 NULL
, /* sym_private: sym_init & sym_read shared info */
285 NULL
/* next: pointer to next struct sym_fns */
289 DEFUN_VOID (_initialize_elfread
)
291 add_symtab_fns (&elf_sym_fns
);