]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/elfread.c
import gdb-1999-07-07 post reformat
[thirdparty/binutils-gdb.git] / gdb / elfread.c
CommitLineData
c906108c
SS
1/* Read ELF (Executable and Linking Format) object files for GDB.
2 Copyright 1991, 92, 93, 94, 95, 96, 1998 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support.
4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b
JM
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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
c906108c
SS
21
22#include "defs.h"
23#include "bfd.h"
24#include "gdb_string.h"
25#include "elf-bfd.h"
26#include "elf/mips.h"
27#include "symtab.h"
28#include "symfile.h"
29#include "objfiles.h"
30#include "buildsym.h"
31#include "stabsread.h"
32#include "gdb-stabs.h"
33#include "complaints.h"
34#include "demangle.h"
35
392a587b
JM
36extern void _initialize_elfread PARAMS ((void));
37
c906108c
SS
38/* The struct elfinfo is available only during ELF symbol table and
39 psymtab reading. It is destroyed at the complation of psymtab-reading.
40 It's local to elf_symfile_read. */
41
c5aa993b
JM
42struct elfinfo
43 {
44 file_ptr dboffset; /* Offset to dwarf debug section */
45 unsigned int dbsize; /* Size of dwarf debug section */
46 file_ptr lnoffset; /* Offset to dwarf line number section */
47 unsigned int lnsize; /* Size of dwarf line number section */
48 asection *stabsect; /* Section pointer for .stab section */
49 asection *stabindexsect; /* Section pointer for .stab.index section */
50 asection *mdebugsect; /* Section pointer for .mdebug section */
51 };
c906108c
SS
52
53/* Various things we might complain about... */
54
c5aa993b
JM
55struct complaint section_info_complaint =
56{"elf/stab section information %s without a preceding file symbol", 0, 0};
c906108c 57
c5aa993b
JM
58struct complaint section_info_dup_complaint =
59{"duplicated elf/stab section information for %s", 0, 0};
c906108c 60
c5aa993b
JM
61struct complaint stab_info_mismatch_complaint =
62{"elf/stab section information missing for %s", 0, 0};
c906108c 63
c5aa993b
JM
64struct complaint stab_info_questionable_complaint =
65{"elf/stab section information questionable for %s", 0, 0};
c906108c
SS
66
67static void
68elf_symfile_init PARAMS ((struct objfile *));
69
70static void
71elf_new_init PARAMS ((struct objfile *));
72
73static void
74elf_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
75
76static void
77elf_symfile_finish PARAMS ((struct objfile *));
78
79static void
c5aa993b 80elf_symtab_read PARAMS ((bfd *, CORE_ADDR, struct objfile *, int));
c906108c
SS
81
82static void
83free_elfinfo PARAMS ((void *));
84
85static struct minimal_symbol *
c5aa993b
JM
86 record_minimal_symbol_and_info PARAMS ((char *, CORE_ADDR,
87 enum minimal_symbol_type, char *,
88 asection * bfd_section,
89 struct objfile *));
c906108c
SS
90
91static void
92elf_locate_sections PARAMS ((bfd *, asection *, void *));
93
94/* We are called once per section from elf_symfile_read. We
95 need to examine each section we are passed, check to see
96 if it is something we are interested in processing, and
97 if so, stash away some access information for the section.
98
99 For now we recognize the dwarf debug information sections and
100 line number sections from matching their section names. The
101 ELF definition is no real help here since it has no direct
102 knowledge of DWARF (by design, so any debugging format can be
103 used).
104
105 We also recognize the ".stab" sections used by the Sun compilers
106 released with Solaris 2.
107
108 FIXME: The section names should not be hardwired strings (what
109 should they be? I don't think most object file formats have enough
110 section flags to specify what kind of debug section it is
111 -kingdon). */
112
113static void
114elf_locate_sections (ignore_abfd, sectp, eip)
115 bfd *ignore_abfd;
116 asection *sectp;
117 PTR eip;
118{
119 register struct elfinfo *ei;
120
121 ei = (struct elfinfo *) eip;
c5aa993b 122 if (STREQ (sectp->name, ".debug"))
c906108c 123 {
c5aa993b
JM
124 ei->dboffset = sectp->filepos;
125 ei->dbsize = bfd_get_section_size_before_reloc (sectp);
c906108c 126 }
c5aa993b 127 else if (STREQ (sectp->name, ".line"))
c906108c 128 {
c5aa993b
JM
129 ei->lnoffset = sectp->filepos;
130 ei->lnsize = bfd_get_section_size_before_reloc (sectp);
c906108c 131 }
c5aa993b 132 else if (STREQ (sectp->name, ".stab"))
c906108c 133 {
c5aa993b 134 ei->stabsect = sectp;
c906108c 135 }
c5aa993b 136 else if (STREQ (sectp->name, ".stab.index"))
c906108c 137 {
c5aa993b 138 ei->stabindexsect = sectp;
c906108c 139 }
c5aa993b 140 else if (STREQ (sectp->name, ".mdebug"))
c906108c 141 {
c5aa993b 142 ei->mdebugsect = sectp;
c906108c
SS
143 }
144}
145
c5aa993b 146#if 0 /* Currently unused */
c906108c
SS
147
148char *
149elf_interpreter (abfd)
150 bfd *abfd;
151{
152 sec_ptr interp_sec;
153 unsigned size;
154 char *interp = NULL;
155
156 interp_sec = bfd_get_section_by_name (abfd, ".interp");
157 if (interp_sec)
158 {
159 size = bfd_section_size (abfd, interp_sec);
160 interp = alloca (size);
c5aa993b 161 if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr) 0,
c906108c
SS
162 size))
163 {
164 interp = savestring (interp, size - 1);
165 }
166 else
167 {
168 interp = NULL;
169 }
170 }
171 return (interp);
172}
173
174#endif
175
176static struct minimal_symbol *
177record_minimal_symbol_and_info (name, address, ms_type, info, bfd_section,
178 objfile)
179 char *name;
180 CORE_ADDR address;
181 enum minimal_symbol_type ms_type;
182 char *info; /* FIXME, is this really char *? */
183 asection *bfd_section;
184 struct objfile *objfile;
185{
186 int section;
187
188 /* Guess the section from the type. This is likely to be wrong in
189 some cases. */
190 switch (ms_type)
191 {
192 case mst_text:
193 case mst_file_text:
194 section = SECT_OFF_TEXT;
195#ifdef SMASH_TEXT_ADDRESS
196 SMASH_TEXT_ADDRESS (address);
197#endif
198 break;
199 case mst_data:
200 case mst_file_data:
201 section = SECT_OFF_DATA;
202 break;
203 case mst_bss:
204 case mst_file_bss:
205 section = SECT_OFF_BSS;
206 break;
207 default:
208 section = -1;
209 break;
210 }
211
212 return prim_record_minimal_symbol_and_info
213 (name, address, ms_type, info, section, bfd_section, objfile);
214}
215
216/*
217
c5aa993b 218 LOCAL FUNCTION
c906108c 219
c5aa993b 220 elf_symtab_read -- read the symbol table of an ELF file
c906108c 221
c5aa993b 222 SYNOPSIS
c906108c 223
c5aa993b
JM
224 void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
225 struct objfile *objfile, int dynamic)
c906108c 226
c5aa993b 227 DESCRIPTION
c906108c 228
c5aa993b
JM
229 Given an open bfd, a base address to relocate symbols to, and a
230 flag that specifies whether or not this bfd is for an executable
231 or not (may be shared library for example), add all the global
232 function and data symbols to the minimal symbol table.
c906108c 233
c5aa993b
JM
234 In stabs-in-ELF, as implemented by Sun, there are some local symbols
235 defined in the ELF symbol table, which can be used to locate
236 the beginnings of sections from each ".o" file that was linked to
237 form the executable objfile. We gather any such info and record it
238 in data structures hung off the objfile's private data.
c906108c 239
c5aa993b 240 */
c906108c
SS
241
242static void
243elf_symtab_read (abfd, addr, objfile, dynamic)
244 bfd *abfd;
245 CORE_ADDR addr;
246 struct objfile *objfile;
247 int dynamic;
248{
249 long storage_needed;
250 asymbol *sym;
251 asymbol **symbol_table;
252 long number_of_symbols;
253 long i;
254 int index;
255 struct cleanup *back_to;
256 CORE_ADDR symaddr;
257 enum minimal_symbol_type ms_type;
258 /* If sectinfo is nonNULL, it contains section info that should end up
259 filed in the objfile. */
260 struct stab_section_info *sectinfo = NULL;
261 /* If filesym is nonzero, it points to a file symbol, but we haven't
262 seen any section info for it yet. */
263 asymbol *filesym = 0;
264#ifdef SOFUN_ADDRESS_MAYBE_MISSING
265 /* Name of filesym, as saved on the symbol_obstack. */
266 char *filesymname = obsavestring ("", 0, &objfile->symbol_obstack);
267#endif
268 struct dbx_symfile_info *dbx = objfile->sym_stab_info;
269 unsigned long size;
270 int stripped = (bfd_get_symcount (abfd) == 0);
c5aa993b 271
c906108c
SS
272 if (dynamic)
273 {
274 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
275
276 /* Nothing to be done if there is no dynamic symtab. */
277 if (storage_needed < 0)
278 return;
279 }
280 else
281 {
282 storage_needed = bfd_get_symtab_upper_bound (abfd);
283 if (storage_needed < 0)
284 error ("Can't read symbols from %s: %s", bfd_get_filename (abfd),
285 bfd_errmsg (bfd_get_error ()));
286 }
287 if (storage_needed > 0)
288 {
289 symbol_table = (asymbol **) xmalloc (storage_needed);
290 back_to = make_cleanup (free, symbol_table);
291 if (dynamic)
c5aa993b 292 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd,
c906108c
SS
293 symbol_table);
294 else
c5aa993b 295 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
c906108c
SS
296 if (number_of_symbols < 0)
297 error ("Can't read symbols from %s: %s", bfd_get_filename (abfd),
298 bfd_errmsg (bfd_get_error ()));
299 for (i = 0; i < number_of_symbols; i++)
300 {
301 sym = symbol_table[i];
c5aa993b 302 if (sym->name == NULL || *sym->name == '\0')
c906108c
SS
303 {
304 /* Skip names that don't exist (shouldn't happen), or names
c5aa993b 305 that are null strings (may happen). */
c906108c
SS
306 continue;
307 }
308
309 if (dynamic
c5aa993b
JM
310 && sym->section == &bfd_und_section
311 && (sym->flags & BSF_FUNCTION))
c906108c
SS
312 {
313 struct minimal_symbol *msym;
314
315 /* Symbol is a reference to a function defined in
c5aa993b
JM
316 a shared library.
317 If its value is non zero then it is usually the address
318 of the corresponding entry in the procedure linkage table,
319 relative to the base address.
320 If its value is zero then the dynamic linker has to resolve
321 the symbol. We are unable to find any meaningful address
322 for this symbol in the executable file, so we skip it. */
323 symaddr = sym->value;
c906108c
SS
324 if (symaddr == 0)
325 continue;
326 symaddr += addr;
327 msym = record_minimal_symbol_and_info
c5aa993b
JM
328 ((char *) sym->name, symaddr,
329 mst_solib_trampoline, NULL, sym->section, objfile);
c906108c
SS
330#ifdef SOFUN_ADDRESS_MAYBE_MISSING
331 if (msym != NULL)
332 msym->filename = filesymname;
333#endif
334 continue;
335 }
336
337 /* If it is a nonstripped executable, do not enter dynamic
338 symbols, as the dynamic symbol table is usually a subset
339 of the main symbol table. */
340 if (dynamic && !stripped)
341 continue;
c5aa993b 342 if (sym->flags & BSF_FILE)
c906108c
SS
343 {
344 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
c5aa993b 345 Chain any old one onto the objfile; remember new sym. */
c906108c
SS
346 if (sectinfo != NULL)
347 {
c5aa993b
JM
348 sectinfo->next = dbx->stab_section_info;
349 dbx->stab_section_info = sectinfo;
c906108c
SS
350 sectinfo = NULL;
351 }
352 filesym = sym;
353#ifdef SOFUN_ADDRESS_MAYBE_MISSING
354 filesymname =
c5aa993b 355 obsavestring ((char *) filesym->name, strlen (filesym->name),
c906108c
SS
356 &objfile->symbol_obstack);
357#endif
358 }
c5aa993b 359 else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
c906108c
SS
360 {
361 struct minimal_symbol *msym;
362
363 /* Select global/local/weak symbols. Note that bfd puts abs
c5aa993b
JM
364 symbols in their own section, so all symbols we are
365 interested in will have a section. */
c906108c 366 /* Bfd symbols are section relative. */
c5aa993b 367 symaddr = sym->value + sym->section->vma;
c906108c 368 /* Relocate all non-absolute symbols by base address. */
c5aa993b 369 if (sym->section != &bfd_abs_section)
c906108c
SS
370 {
371 symaddr += addr;
372 }
373 /* For non-absolute symbols, use the type of the section
c5aa993b
JM
374 they are relative to, to intuit text/data. Bfd provides
375 no way of figuring this out for absolute symbols. */
376 if (sym->section == &bfd_abs_section)
c906108c
SS
377 {
378 /* This is a hack to get the minimal symbol type
379 right for Irix 5, which has absolute adresses
380 with special section indices for dynamic symbols. */
381 unsigned short shndx =
c5aa993b 382 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
c906108c
SS
383
384 switch (shndx)
385 {
386 case SHN_MIPS_TEXT:
387 ms_type = mst_text;
388 break;
389 case SHN_MIPS_DATA:
390 ms_type = mst_data;
391 break;
392 case SHN_MIPS_ACOMMON:
393 ms_type = mst_bss;
394 break;
395 default:
396 ms_type = mst_abs;
397 }
398
399 /* If it is an Irix dynamic symbol, skip section name
400 symbols, relocate all others. */
401 if (ms_type != mst_abs)
402 {
403 if (sym->name[0] == '.')
404 continue;
405 symaddr += addr;
406 }
407 }
c5aa993b 408 else if (sym->section->flags & SEC_CODE)
c906108c 409 {
c5aa993b 410 if (sym->flags & BSF_GLOBAL)
c906108c
SS
411 {
412 ms_type = mst_text;
413 }
414 else if ((sym->name[0] == '.' && sym->name[1] == 'L')
c5aa993b 415 || ((sym->flags & BSF_LOCAL)
c906108c
SS
416 && sym->name[0] == '$'
417 && sym->name[1] == 'L'))
418 /* Looks like a compiler-generated label. Skip it.
419 The assembler should be skipping these (to keep
420 executables small), but apparently with gcc on the
421 delta m88k SVR4, it loses. So to have us check too
422 should be harmless (but I encourage people to fix this
423 in the assembler instead of adding checks here). */
424 continue;
425#ifdef HARRIS_TARGET
426 else if (sym->name[0] == '.' && sym->name[1] == '.')
427 {
428 /* Looks like a Harris compiler generated label for the
c5aa993b
JM
429 purpose of marking instructions that are relevant to
430 DWARF dies. The assembler can't get rid of these
431 because they are relocatable addresses that the
432 linker needs to resolve. */
c906108c
SS
433 continue;
434 }
c5aa993b 435#endif
c906108c
SS
436 else
437 {
438 ms_type = mst_file_text;
439 }
440 }
c5aa993b 441 else if (sym->section->flags & SEC_ALLOC)
c906108c 442 {
c5aa993b 443 if (sym->flags & BSF_GLOBAL)
c906108c 444 {
c5aa993b 445 if (sym->section->flags & SEC_LOAD)
c906108c
SS
446 {
447 ms_type = mst_data;
448 }
449 else
450 {
451 ms_type = mst_bss;
452 }
453 }
c5aa993b 454 else if (sym->flags & BSF_LOCAL)
c906108c
SS
455 {
456 /* Named Local variable in a Data section. Check its
c5aa993b
JM
457 name for stabs-in-elf. The STREQ macro checks the
458 first character inline, so we only actually do a
459 strcmp function call on names that start with 'B'
460 or 'D' */
c906108c 461 index = SECT_OFF_MAX;
c5aa993b 462 if (STREQ ("Bbss.bss", sym->name))
c906108c
SS
463 {
464 index = SECT_OFF_BSS;
465 }
c5aa993b 466 else if (STREQ ("Ddata.data", sym->name))
c906108c
SS
467 {
468 index = SECT_OFF_DATA;
469 }
c5aa993b 470 else if (STREQ ("Drodata.rodata", sym->name))
c906108c
SS
471 {
472 index = SECT_OFF_RODATA;
473 }
474 if (index != SECT_OFF_MAX)
475 {
476 /* Found a special local symbol. Allocate a
477 sectinfo, if needed, and fill it in. */
478 if (sectinfo == NULL)
479 {
480 sectinfo = (struct stab_section_info *)
c5aa993b 481 xmmalloc (objfile->md, sizeof (*sectinfo));
c906108c
SS
482 memset ((PTR) sectinfo, 0, sizeof (*sectinfo));
483 if (filesym == NULL)
484 {
485 complain (&section_info_complaint,
c5aa993b 486 sym->name);
c906108c
SS
487 }
488 else
489 {
c5aa993b
JM
490 sectinfo->filename =
491 (char *) filesym->name;
c906108c
SS
492 }
493 }
c5aa993b 494 if (sectinfo->sections[index] != 0)
c906108c
SS
495 {
496 complain (&section_info_dup_complaint,
c5aa993b 497 sectinfo->filename);
c906108c
SS
498 }
499 /* Bfd symbols are section relative. */
c5aa993b 500 symaddr = sym->value + sym->section->vma;
c906108c 501 /* Relocate non-absolute symbols by base address. */
c5aa993b 502 if (sym->section != &bfd_abs_section)
c906108c
SS
503 {
504 symaddr += addr;
505 }
c5aa993b 506 sectinfo->sections[index] = symaddr;
c906108c
SS
507 /* The special local symbols don't go in the
508 minimal symbol table, so ignore this one. */
509 continue;
510 }
511 /* Not a special stabs-in-elf symbol, do regular
c5aa993b
JM
512 symbol processing. */
513 if (sym->section->flags & SEC_LOAD)
c906108c
SS
514 {
515 ms_type = mst_file_data;
516 }
517 else
518 {
519 ms_type = mst_file_bss;
520 }
521 }
522 else
523 {
524 ms_type = mst_unknown;
525 }
526 }
527 else
528 {
529 /* FIXME: Solaris2 shared libraries include lots of
530 odd "absolute" and "undefined" symbols, that play
531 hob with actions like finding what function the PC
532 is in. Ignore them if they aren't text, data, or bss. */
533 /* ms_type = mst_unknown; */
c5aa993b 534 continue; /* Skip this symbol. */
c906108c
SS
535 }
536 /* Pass symbol size field in via BFD. FIXME!!! */
c5aa993b 537 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
c906108c 538 msym = record_minimal_symbol_and_info
c5aa993b
JM
539 ((char *) sym->name, symaddr,
540 ms_type, (PTR) size, sym->section, objfile);
c906108c
SS
541#ifdef SOFUN_ADDRESS_MAYBE_MISSING
542 if (msym != NULL)
543 msym->filename = filesymname;
544#endif
545#ifdef ELF_MAKE_MSYMBOL_SPECIAL
c5aa993b 546 ELF_MAKE_MSYMBOL_SPECIAL (sym, msym);
c906108c
SS
547#endif
548 }
549 }
550 do_cleanups (back_to);
551 }
552}
553
554/* Scan and build partial symbols for a symbol file.
555 We have been initialized by a call to elf_symfile_init, which
556 currently does nothing.
557
558 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
559 in each section. We simplify it down to a single offset for all
560 symbols. FIXME.
561
562 MAINLINE is true if we are reading the main symbol
563 table (as opposed to a shared lib or dynamically loaded file).
564
565 This function only does the minimum work necessary for letting the
566 user "name" things symbolically; it does not read the entire symtab.
567 Instead, it reads the external and static symbols and puts them in partial
568 symbol tables. When more extensive information is requested of a
569 file, the corresponding partial symbol table is mutated into a full
570 fledged symbol table by going back and reading the symbols
571 for real.
572
573 We look for sections with specific names, to tell us what debug
574 format to look for: FIXME!!!
575
576 dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
577 elfstab_build_psymtabs() handles STABS symbols;
578 mdebug_build_psymtabs() handles ECOFF debugging information.
579
580 Note that ELF files have a "minimal" symbol table, which looks a lot
581 like a COFF symbol table, but has only the minimal information necessary
582 for linking. We process this also, and use the information to
583 build gdb's minimal symbol table. This gives us some minimal debugging
584 capability even for files compiled without -g. */
585
586static void
587elf_symfile_read (objfile, section_offsets, mainline)
588 struct objfile *objfile;
589 struct section_offsets *section_offsets;
590 int mainline;
591{
592 bfd *abfd = objfile->obfd;
593 struct elfinfo ei;
594 struct cleanup *back_to;
595 CORE_ADDR offset;
596
597 init_minimal_symbol_collection ();
598 back_to = make_cleanup ((make_cleanup_func) discard_minimal_symbols, 0);
599
600 memset ((char *) &ei, 0, sizeof (ei));
601
602 /* Allocate struct to keep track of the symfile */
603 objfile->sym_stab_info = (struct dbx_symfile_info *)
c5aa993b 604 xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
c906108c
SS
605 memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
606 make_cleanup (free_elfinfo, (PTR) objfile);
607
608 /* Process the normal ELF symbol table first. This may write some
609 chain of info into the dbx_symfile_info in objfile->sym_stab_info,
610 which can later be used by elfstab_offset_sections. */
611
612 /* FIXME, should take a section_offsets param, not just an offset. */
613 offset = ANOFFSET (section_offsets, 0);
614 elf_symtab_read (abfd, offset, objfile, 0);
615
616 /* Add the dynamic symbols. */
617
618 elf_symtab_read (abfd, offset, objfile, 1);
619
620 /* Now process debugging information, which is contained in
621 special ELF sections. */
622
623 /* If we are reinitializing, or if we have never loaded syms yet,
624 set table to empty. MAINLINE is cleared so that *_read_psymtab
625 functions do not all also re-initialize the psymbol table. */
626 if (mainline)
627 {
628 init_psymbol_list (objfile, 0);
629 mainline = 0;
630 }
631
632 /* We first have to find them... */
c5aa993b 633 bfd_map_over_sections (abfd, elf_locate_sections, (PTR) & ei);
c906108c
SS
634
635 /* ELF debugging information is inserted into the psymtab in the
636 order of least informative first - most informative last. Since
637 the psymtab table is searched `most recent insertion first' this
638 increases the probability that more detailed debug information
639 for a section is found.
640
641 For instance, an object file might contain both .mdebug (XCOFF)
642 and .debug_info (DWARF2) sections then .mdebug is inserted first
643 (searched last) and DWARF2 is inserted last (searched first). If
644 we don't do this then the XCOFF info is found first - for code in
645 an included file XCOFF info is useless. */
646
647 if (ei.mdebugsect)
648 {
649 const struct ecoff_debug_swap *swap;
650
651 /* .mdebug section, presumably holding ECOFF debugging
c5aa993b 652 information. */
c906108c
SS
653 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
654 if (swap)
655 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect,
656 section_offsets);
657 }
658 if (ei.stabsect)
659 {
660 asection *str_sect;
661
662 /* Stab sections have an associated string table that looks like
c5aa993b 663 a separate section. */
c906108c
SS
664 str_sect = bfd_get_section_by_name (abfd, ".stabstr");
665
666 /* FIXME should probably warn about a stab section without a stabstr. */
667 if (str_sect)
668 elfstab_build_psymtabs (objfile,
669 section_offsets,
670 mainline,
671 ei.stabsect->filepos,
672 bfd_section_size (abfd, ei.stabsect),
673 str_sect->filepos,
674 bfd_section_size (abfd, str_sect));
675 }
676 if (dwarf2_has_info (abfd))
677 {
678 /* DWARF 2 sections */
679 dwarf2_build_psymtabs (objfile, section_offsets, mainline);
680 }
681 else if (ei.dboffset && ei.lnoffset)
682 {
683 /* DWARF sections */
684 dwarf_build_psymtabs (objfile,
685 section_offsets, mainline,
686 ei.dboffset, ei.dbsize,
687 ei.lnoffset, ei.lnsize);
688 }
689
690 /* Install any minimal symbols that have been collected as the current
691 minimal symbols for this objfile. */
692
693 install_minimal_symbols (objfile);
694
695 do_cleanups (back_to);
696}
697
698/* This cleans up the objfile's sym_stab_info pointer, and the chain of
699 stab_section_info's, that might be dangling from it. */
700
701static void
702free_elfinfo (objp)
703 PTR objp;
704{
c5aa993b 705 struct objfile *objfile = (struct objfile *) objp;
c906108c
SS
706 struct dbx_symfile_info *dbxinfo = objfile->sym_stab_info;
707 struct stab_section_info *ssi, *nssi;
708
709 ssi = dbxinfo->stab_section_info;
710 while (ssi)
711 {
712 nssi = ssi->next;
713 mfree (objfile->md, ssi);
714 ssi = nssi;
715 }
716
717 dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */
718}
719
720
721/* Initialize anything that needs initializing when a completely new symbol
722 file is specified (not just adding some symbols from another file, e.g. a
723 shared library).
724
725 We reinitialize buildsym, since we may be reading stabs from an ELF file. */
726
727static void
728elf_new_init (ignore)
729 struct objfile *ignore;
730{
731 stabsread_new_init ();
732 buildsym_new_init ();
733}
734
735/* Perform any local cleanups required when we are done with a particular
736 objfile. I.E, we are in the process of discarding all symbol information
737 for an objfile, freeing up all memory held for it, and unlinking the
738 objfile struct from the global list of known objfiles. */
739
740static void
741elf_symfile_finish (objfile)
742 struct objfile *objfile;
743{
c5aa993b 744 if (objfile->sym_stab_info != NULL)
c906108c 745 {
c5aa993b 746 mfree (objfile->md, objfile->sym_stab_info);
c906108c
SS
747 }
748}
749
750/* ELF specific initialization routine for reading symbols.
751
752 It is passed a pointer to a struct sym_fns which contains, among other
753 things, the BFD for the file whose symbols are being read, and a slot for
754 a pointer to "private data" which we can fill with goodies.
755
756 For now at least, we have nothing in particular to do, so this function is
757 just a stub. */
758
759static void
760elf_symfile_init (objfile)
761 struct objfile *objfile;
762{
763 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
764 find this causes a significant slowdown in gdb then we could
765 set it in the debug symbol readers only when necessary. */
766 objfile->flags |= OBJF_REORDERED;
767}
768
769/* When handling an ELF file that contains Sun STABS debug info,
770 some of the debug info is relative to the particular chunk of the
771 section that was generated in its individual .o file. E.g.
772 offsets to static variables are relative to the start of the data
773 segment *for that module before linking*. This information is
774 painfully squirreled away in the ELF symbol table as local symbols
775 with wierd names. Go get 'em when needed. */
776
777void
778elfstab_offset_sections (objfile, pst)
779 struct objfile *objfile;
780 struct partial_symtab *pst;
781{
782 char *filename = pst->filename;
783 struct dbx_symfile_info *dbx = objfile->sym_stab_info;
784 struct stab_section_info *maybe = dbx->stab_section_info;
785 struct stab_section_info *questionable = 0;
786 int i;
787 char *p;
788
789 /* The ELF symbol info doesn't include path names, so strip the path
790 (if any) from the psymtab filename. */
791 while (0 != (p = strchr (filename, '/')))
c5aa993b 792 filename = p + 1;
c906108c
SS
793
794 /* FIXME: This linear search could speed up significantly
795 if it was chained in the right order to match how we search it,
796 and if we unchained when we found a match. */
797 for (; maybe; maybe = maybe->next)
798 {
799 if (filename[0] == maybe->filename[0]
800 && STREQ (filename, maybe->filename))
801 {
802 /* We found a match. But there might be several source files
803 (from different directories) with the same name. */
804 if (0 == maybe->found)
805 break;
c5aa993b 806 questionable = maybe; /* Might use it later. */
c906108c
SS
807 }
808 }
809
810 if (maybe == 0 && questionable != 0)
811 {
812 complain (&stab_info_questionable_complaint, filename);
813 maybe = questionable;
814 }
815
816 if (maybe)
817 {
818 /* Found it! Allocate a new psymtab struct, and fill it in. */
819 maybe->found++;
820 pst->section_offsets = (struct section_offsets *)
c5aa993b 821 obstack_alloc (&objfile->psymbol_obstack,
c906108c 822 sizeof (struct section_offsets) +
c5aa993b 823 sizeof (pst->section_offsets->offsets) * (SECT_OFF_MAX - 1));
c906108c
SS
824
825 for (i = 0; i < SECT_OFF_MAX; i++)
826 ANOFFSET (pst->section_offsets, i) = maybe->sections[i];
827 return;
828 }
829
830 /* We were unable to find any offsets for this file. Complain. */
c5aa993b 831 if (dbx->stab_section_info) /* If there *is* any info, */
c906108c
SS
832 complain (&stab_info_mismatch_complaint, filename);
833}
834\f
835/* Register that we are able to handle ELF object file formats. */
836
837static struct sym_fns elf_sym_fns =
838{
839 bfd_target_elf_flavour,
c5aa993b
JM
840 elf_new_init, /* sym_new_init: init anything gbl to entire symtab */
841 elf_symfile_init, /* sym_init: read initial info, setup for sym_read() */
842 elf_symfile_read, /* sym_read: read a symbol file into symtab */
843 elf_symfile_finish, /* sym_finish: finished with file, cleanup */
c906108c
SS
844 default_symfile_offsets,
845 /* sym_offsets: Translate ext. to int. relocation */
c5aa993b 846 NULL /* next: pointer to next struct sym_fns */
c906108c
SS
847};
848
849void
850_initialize_elfread ()
851{
852 add_symtab_fns (&elf_sym_fns);
853}