Upgrade GDB from 7.0 and 7.2 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / elfread.c
CommitLineData
5796c8dc
SS
1/* Read ELF (Executable and Linking Format) object files for GDB.
2
3 Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
cf7f2e2d 4 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5796c8dc
SS
5 Free Software Foundation, Inc.
6
7 Written by Fred Fish at Cygnus Support.
8
9 This file is part of GDB.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23
24#include "defs.h"
25#include "bfd.h"
26#include "gdb_string.h"
27#include "elf-bfd.h"
28#include "elf/common.h"
29#include "elf/internal.h"
30#include "elf/mips.h"
31#include "symtab.h"
32#include "symfile.h"
33#include "objfiles.h"
34#include "buildsym.h"
35#include "stabsread.h"
36#include "gdb-stabs.h"
37#include "complaints.h"
38#include "demangle.h"
cf7f2e2d 39#include "psympriv.h"
5796c8dc
SS
40
41extern void _initialize_elfread (void);
42
43/* The struct elfinfo is available only during ELF symbol table and
44 psymtab reading. It is destroyed at the completion of psymtab-reading.
45 It's local to elf_symfile_read. */
46
47struct elfinfo
48 {
49 asection *stabsect; /* Section pointer for .stab section */
50 asection *stabindexsect; /* Section pointer for .stab.index section */
51 asection *mdebugsect; /* Section pointer for .mdebug section */
52 };
53
54static void free_elfinfo (void *);
55
56/* Locate the segments in ABFD. */
57
58static struct symfile_segment_data *
59elf_symfile_segments (bfd *abfd)
60{
61 Elf_Internal_Phdr *phdrs, **segments;
62 long phdrs_size;
63 int num_phdrs, num_segments, num_sections, i;
64 asection *sect;
65 struct symfile_segment_data *data;
66
67 phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
68 if (phdrs_size == -1)
69 return NULL;
70
71 phdrs = alloca (phdrs_size);
72 num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
73 if (num_phdrs == -1)
74 return NULL;
75
76 num_segments = 0;
77 segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
78 for (i = 0; i < num_phdrs; i++)
79 if (phdrs[i].p_type == PT_LOAD)
80 segments[num_segments++] = &phdrs[i];
81
82 if (num_segments == 0)
83 return NULL;
84
85 data = XZALLOC (struct symfile_segment_data);
86 data->num_segments = num_segments;
87 data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
88 data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
89
90 for (i = 0; i < num_segments; i++)
91 {
92 data->segment_bases[i] = segments[i]->p_vaddr;
93 data->segment_sizes[i] = segments[i]->p_memsz;
94 }
95
96 num_sections = bfd_count_sections (abfd);
97 data->segment_info = XCALLOC (num_sections, int);
98
99 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
100 {
101 int j;
102 CORE_ADDR vma;
103
104 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
105 continue;
106
107 vma = bfd_get_section_vma (abfd, sect);
108
109 for (j = 0; j < num_segments; j++)
110 if (segments[j]->p_memsz > 0
111 && vma >= segments[j]->p_vaddr
112 && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz)
113 {
114 data->segment_info[i] = j + 1;
115 break;
116 }
117
cf7f2e2d
JM
118 /* We should have found a segment for every non-empty section.
119 If we haven't, we will not relocate this section by any
120 offsets we apply to the segments. As an exception, do not
121 warn about SHT_NOBITS sections; in normal ELF execution
122 environments, SHT_NOBITS means zero-initialized and belongs
123 in a segment, but in no-OS environments some tools (e.g. ARM
124 RealView) use SHT_NOBITS for uninitialized data. Since it is
125 uninitialized, it doesn't need a program header. Such
126 binaries are not relocatable. */
127 if (bfd_get_section_size (sect) > 0 && j == num_segments
128 && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
5796c8dc
SS
129 warning (_("Loadable segment \"%s\" outside of ELF segments"),
130 bfd_section_name (abfd, sect));
131 }
132
133 return data;
134}
135
136/* We are called once per section from elf_symfile_read. We
137 need to examine each section we are passed, check to see
138 if it is something we are interested in processing, and
139 if so, stash away some access information for the section.
140
141 For now we recognize the dwarf debug information sections and
142 line number sections from matching their section names. The
143 ELF definition is no real help here since it has no direct
144 knowledge of DWARF (by design, so any debugging format can be
145 used).
146
147 We also recognize the ".stab" sections used by the Sun compilers
148 released with Solaris 2.
149
150 FIXME: The section names should not be hardwired strings (what
151 should they be? I don't think most object file formats have enough
152 section flags to specify what kind of debug section it is
153 -kingdon). */
154
155static void
156elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
157{
158 struct elfinfo *ei;
159
160 ei = (struct elfinfo *) eip;
161 if (strcmp (sectp->name, ".stab") == 0)
162 {
163 ei->stabsect = sectp;
164 }
165 else if (strcmp (sectp->name, ".stab.index") == 0)
166 {
167 ei->stabindexsect = sectp;
168 }
169 else if (strcmp (sectp->name, ".mdebug") == 0)
170 {
171 ei->mdebugsect = sectp;
172 }
173}
174
175static struct minimal_symbol *
cf7f2e2d
JM
176record_minimal_symbol (const char *name, int name_len, int copy_name,
177 CORE_ADDR address,
5796c8dc
SS
178 enum minimal_symbol_type ms_type,
179 asection *bfd_section, struct objfile *objfile)
180{
181 struct gdbarch *gdbarch = get_objfile_arch (objfile);
182
183 if (ms_type == mst_text || ms_type == mst_file_text)
184 address = gdbarch_smash_text_address (gdbarch, address);
185
cf7f2e2d
JM
186 return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
187 ms_type, bfd_section->index,
188 bfd_section, objfile);
5796c8dc
SS
189}
190
191/*
192
193 LOCAL FUNCTION
194
195 elf_symtab_read -- read the symbol table of an ELF file
196
197 SYNOPSIS
198
199 void elf_symtab_read (struct objfile *objfile, int type,
200 long number_of_symbols, asymbol **symbol_table)
201
202 DESCRIPTION
203
204 Given an objfile, a symbol table, and a flag indicating whether the
205 symbol table contains regular, dynamic, or synthetic symbols, add all
206 the global function and data symbols to the minimal symbol table.
207
208 In stabs-in-ELF, as implemented by Sun, there are some local symbols
209 defined in the ELF symbol table, which can be used to locate
210 the beginnings of sections from each ".o" file that was linked to
211 form the executable objfile. We gather any such info and record it
212 in data structures hung off the objfile's private data.
213
214 */
215
216#define ST_REGULAR 0
217#define ST_DYNAMIC 1
218#define ST_SYNTHETIC 2
219
220static void
221elf_symtab_read (struct objfile *objfile, int type,
cf7f2e2d
JM
222 long number_of_symbols, asymbol **symbol_table,
223 int copy_names)
5796c8dc
SS
224{
225 struct gdbarch *gdbarch = get_objfile_arch (objfile);
5796c8dc
SS
226 asymbol *sym;
227 long i;
228 CORE_ADDR symaddr;
229 CORE_ADDR offset;
230 enum minimal_symbol_type ms_type;
231 /* If sectinfo is nonNULL, it contains section info that should end up
232 filed in the objfile. */
233 struct stab_section_info *sectinfo = NULL;
234 /* If filesym is nonzero, it points to a file symbol, but we haven't
235 seen any section info for it yet. */
236 asymbol *filesym = 0;
cf7f2e2d
JM
237 /* Name of filesym. This is either a constant string or is saved on
238 the objfile's obstack. */
239 char *filesymname = "";
5796c8dc
SS
240 struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
241 int stripped = (bfd_get_symcount (objfile->obfd) == 0);
242
243 for (i = 0; i < number_of_symbols; i++)
244 {
245 sym = symbol_table[i];
246 if (sym->name == NULL || *sym->name == '\0')
247 {
248 /* Skip names that don't exist (shouldn't happen), or names
249 that are null strings (may happen). */
250 continue;
251 }
252
253 /* Skip "special" symbols, e.g. ARM mapping symbols. These are
254 symbols which do not correspond to objects in the symbol table,
255 but have some other target-specific meaning. */
256 if (bfd_is_target_special_symbol (objfile->obfd, sym))
257 {
258 if (gdbarch_record_special_symbol_p (gdbarch))
259 gdbarch_record_special_symbol (gdbarch, objfile, sym);
260 continue;
261 }
262
263 offset = ANOFFSET (objfile->section_offsets, sym->section->index);
264 if (type == ST_DYNAMIC
265 && sym->section == &bfd_und_section
266 && (sym->flags & BSF_FUNCTION))
267 {
268 struct minimal_symbol *msym;
269 bfd *abfd = objfile->obfd;
270 asection *sect;
271
272 /* Symbol is a reference to a function defined in
273 a shared library.
274 If its value is non zero then it is usually the address
275 of the corresponding entry in the procedure linkage table,
276 plus the desired section offset.
277 If its value is zero then the dynamic linker has to resolve
278 the symbol. We are unable to find any meaningful address
279 for this symbol in the executable file, so we skip it. */
280 symaddr = sym->value;
281 if (symaddr == 0)
282 continue;
283
284 /* sym->section is the undefined section. However, we want to
285 record the section where the PLT stub resides with the
286 minimal symbol. Search the section table for the one that
287 covers the stub's address. */
288 for (sect = abfd->sections; sect != NULL; sect = sect->next)
289 {
290 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
291 continue;
292
293 if (symaddr >= bfd_get_section_vma (abfd, sect)
294 && symaddr < bfd_get_section_vma (abfd, sect)
295 + bfd_get_section_size (sect))
296 break;
297 }
298 if (!sect)
299 continue;
300
301 symaddr += ANOFFSET (objfile->section_offsets, sect->index);
302
303 msym = record_minimal_symbol
cf7f2e2d
JM
304 (sym->name, strlen (sym->name), copy_names,
305 symaddr, mst_solib_trampoline, sect, objfile);
5796c8dc
SS
306 if (msym != NULL)
307 msym->filename = filesymname;
308 continue;
309 }
310
311 /* If it is a nonstripped executable, do not enter dynamic
312 symbols, as the dynamic symbol table is usually a subset
313 of the main symbol table. */
314 if (type == ST_DYNAMIC && !stripped)
315 continue;
316 if (sym->flags & BSF_FILE)
317 {
318 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
319 Chain any old one onto the objfile; remember new sym. */
320 if (sectinfo != NULL)
321 {
322 sectinfo->next = dbx->stab_section_info;
323 dbx->stab_section_info = sectinfo;
324 sectinfo = NULL;
325 }
326 filesym = sym;
327 filesymname =
328 obsavestring ((char *) filesym->name, strlen (filesym->name),
329 &objfile->objfile_obstack);
330 }
331 else if (sym->flags & BSF_SECTION_SYM)
332 continue;
333 else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
334 {
335 struct minimal_symbol *msym;
336
337 /* Select global/local/weak symbols. Note that bfd puts abs
338 symbols in their own section, so all symbols we are
339 interested in will have a section. */
340 /* Bfd symbols are section relative. */
341 symaddr = sym->value + sym->section->vma;
342 /* Relocate all non-absolute and non-TLS symbols by the
343 section offset. */
344 if (sym->section != &bfd_abs_section
345 && !(sym->section->flags & SEC_THREAD_LOCAL))
346 {
347 symaddr += offset;
348 }
349 /* For non-absolute symbols, use the type of the section
350 they are relative to, to intuit text/data. Bfd provides
351 no way of figuring this out for absolute symbols. */
352 if (sym->section == &bfd_abs_section)
353 {
354 /* This is a hack to get the minimal symbol type
355 right for Irix 5, which has absolute addresses
356 with special section indices for dynamic symbols.
357
358 NOTE: uweigand-20071112: Synthetic symbols do not
359 have an ELF-private part, so do not touch those. */
360 unsigned int shndx = type == ST_SYNTHETIC ? 0 :
361 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
362
363 switch (shndx)
364 {
365 case SHN_MIPS_TEXT:
366 ms_type = mst_text;
367 break;
368 case SHN_MIPS_DATA:
369 ms_type = mst_data;
370 break;
371 case SHN_MIPS_ACOMMON:
372 ms_type = mst_bss;
373 break;
374 default:
375 ms_type = mst_abs;
376 }
377
378 /* If it is an Irix dynamic symbol, skip section name
379 symbols, relocate all others by section offset. */
380 if (ms_type != mst_abs)
381 {
382 if (sym->name[0] == '.')
383 continue;
384 symaddr += offset;
385 }
386 }
387 else if (sym->section->flags & SEC_CODE)
388 {
389 if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
390 {
391 ms_type = mst_text;
392 }
393 else if ((sym->name[0] == '.' && sym->name[1] == 'L')
394 || ((sym->flags & BSF_LOCAL)
395 && sym->name[0] == '$'
396 && sym->name[1] == 'L'))
397 /* Looks like a compiler-generated label. Skip
398 it. The assembler should be skipping these (to
399 keep executables small), but apparently with
400 gcc on the (deleted) delta m88k SVR4, it loses.
401 So to have us check too should be harmless (but
402 I encourage people to fix this in the assembler
403 instead of adding checks here). */
404 continue;
405 else
406 {
407 ms_type = mst_file_text;
408 }
409 }
410 else if (sym->section->flags & SEC_ALLOC)
411 {
412 if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
413 {
414 if (sym->section->flags & SEC_LOAD)
415 {
416 ms_type = mst_data;
417 }
418 else
419 {
420 ms_type = mst_bss;
421 }
422 }
423 else if (sym->flags & BSF_LOCAL)
424 {
425 /* Named Local variable in a Data section.
426 Check its name for stabs-in-elf. */
427 int special_local_sect;
cf7f2e2d 428
5796c8dc
SS
429 if (strcmp ("Bbss.bss", sym->name) == 0)
430 special_local_sect = SECT_OFF_BSS (objfile);
431 else if (strcmp ("Ddata.data", sym->name) == 0)
432 special_local_sect = SECT_OFF_DATA (objfile);
433 else if (strcmp ("Drodata.rodata", sym->name) == 0)
434 special_local_sect = SECT_OFF_RODATA (objfile);
435 else
436 special_local_sect = -1;
437 if (special_local_sect >= 0)
438 {
439 /* Found a special local symbol. Allocate a
440 sectinfo, if needed, and fill it in. */
441 if (sectinfo == NULL)
442 {
443 int max_index;
444 size_t size;
445
446 max_index = SECT_OFF_BSS (objfile);
447 if (objfile->sect_index_data > max_index)
448 max_index = objfile->sect_index_data;
449 if (objfile->sect_index_rodata > max_index)
450 max_index = objfile->sect_index_rodata;
451
452 /* max_index is the largest index we'll
453 use into this array, so we must
454 allocate max_index+1 elements for it.
455 However, 'struct stab_section_info'
456 already includes one element, so we
457 need to allocate max_index aadditional
458 elements. */
459 size = (sizeof (struct stab_section_info)
460 + (sizeof (CORE_ADDR)
461 * max_index));
462 sectinfo = (struct stab_section_info *)
463 xmalloc (size);
464 memset (sectinfo, 0, size);
465 sectinfo->num_sections = max_index;
466 if (filesym == NULL)
467 {
468 complaint (&symfile_complaints,
469 _("elf/stab section information %s without a preceding file symbol"),
470 sym->name);
471 }
472 else
473 {
474 sectinfo->filename =
475 (char *) filesym->name;
476 }
477 }
478 if (sectinfo->sections[special_local_sect] != 0)
479 complaint (&symfile_complaints,
480 _("duplicated elf/stab section information for %s"),
481 sectinfo->filename);
482 /* BFD symbols are section relative. */
483 symaddr = sym->value + sym->section->vma;
484 /* Relocate non-absolute symbols by the
485 section offset. */
486 if (sym->section != &bfd_abs_section)
487 symaddr += offset;
488 sectinfo->sections[special_local_sect] = symaddr;
489 /* The special local symbols don't go in the
490 minimal symbol table, so ignore this one. */
491 continue;
492 }
493 /* Not a special stabs-in-elf symbol, do regular
494 symbol processing. */
495 if (sym->section->flags & SEC_LOAD)
496 {
497 ms_type = mst_file_data;
498 }
499 else
500 {
501 ms_type = mst_file_bss;
502 }
503 }
504 else
505 {
506 ms_type = mst_unknown;
507 }
508 }
509 else
510 {
511 /* FIXME: Solaris2 shared libraries include lots of
512 odd "absolute" and "undefined" symbols, that play
513 hob with actions like finding what function the PC
514 is in. Ignore them if they aren't text, data, or bss. */
515 /* ms_type = mst_unknown; */
516 continue; /* Skip this symbol. */
517 }
518 msym = record_minimal_symbol
cf7f2e2d 519 (sym->name, strlen (sym->name), copy_names, symaddr,
5796c8dc
SS
520 ms_type, sym->section, objfile);
521
522 if (msym)
523 {
524 /* Pass symbol size field in via BFD. FIXME!!! */
525 elf_symbol_type *elf_sym;
526
527 /* NOTE: uweigand-20071112: A synthetic symbol does not have an
528 ELF-private part. However, in some cases (e.g. synthetic
529 'dot' symbols on ppc64) the udata.p entry is set to point back
530 to the original ELF symbol it was derived from. Get the size
531 from that symbol. */
532 if (type != ST_SYNTHETIC)
533 elf_sym = (elf_symbol_type *) sym;
534 else
535 elf_sym = (elf_symbol_type *) sym->udata.p;
536
537 if (elf_sym)
538 MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
cf7f2e2d
JM
539
540 msym->filename = filesymname;
541 gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
5796c8dc 542 }
5796c8dc
SS
543
544 /* For @plt symbols, also record a trampoline to the
545 destination symbol. The @plt symbol will be used in
546 disassembly, and the trampoline will be used when we are
547 trying to find the target. */
548 if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
549 {
550 int len = strlen (sym->name);
551
552 if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
553 {
5796c8dc
SS
554 struct minimal_symbol *mtramp;
555
cf7f2e2d
JM
556 mtramp = record_minimal_symbol (sym->name, len - 4, 1,
557 symaddr,
5796c8dc
SS
558 mst_solib_trampoline,
559 sym->section, objfile);
560 if (mtramp)
561 {
562 MSYMBOL_SIZE (mtramp) = MSYMBOL_SIZE (msym);
563 mtramp->filename = filesymname;
564 gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
565 }
566 }
567 }
568 }
569 }
570}
571
cf7f2e2d
JM
572struct build_id
573 {
574 size_t size;
575 gdb_byte data[1];
576 };
577
578/* Locate NT_GNU_BUILD_ID from ABFD and return its content. */
579
580static struct build_id *
581build_id_bfd_get (bfd *abfd)
582{
583 struct build_id *retval;
584
585 if (!bfd_check_format (abfd, bfd_object)
586 || bfd_get_flavour (abfd) != bfd_target_elf_flavour
587 || elf_tdata (abfd)->build_id == NULL)
588 return NULL;
589
590 retval = xmalloc (sizeof *retval - 1 + elf_tdata (abfd)->build_id_size);
591 retval->size = elf_tdata (abfd)->build_id_size;
592 memcpy (retval->data, elf_tdata (abfd)->build_id, retval->size);
593
594 return retval;
595}
596
597/* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */
598
599static int
600build_id_verify (const char *filename, struct build_id *check)
601{
602 bfd *abfd;
603 struct build_id *found = NULL;
604 int retval = 0;
605
606 /* We expect to be silent on the non-existing files. */
607 abfd = bfd_open_maybe_remote (filename);
608 if (abfd == NULL)
609 return 0;
610
611 found = build_id_bfd_get (abfd);
612
613 if (found == NULL)
614 warning (_("File \"%s\" has no build-id, file skipped"), filename);
615 else if (found->size != check->size
616 || memcmp (found->data, check->data, found->size) != 0)
617 warning (_("File \"%s\" has a different build-id, file skipped"), filename);
618 else
619 retval = 1;
620
621 gdb_bfd_close_or_warn (abfd);
622
623 xfree (found);
624
625 return retval;
626}
627
628static char *
629build_id_to_debug_filename (struct build_id *build_id)
630{
631 char *link, *debugdir, *retval = NULL;
632
633 /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
634 link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
635 + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
636
637 /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
638 cause "/.build-id/..." lookups. */
639
640 debugdir = debug_file_directory;
641 do
642 {
643 char *s, *debugdir_end;
644 gdb_byte *data = build_id->data;
645 size_t size = build_id->size;
646
647 while (*debugdir == DIRNAME_SEPARATOR)
648 debugdir++;
649
650 debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
651 if (debugdir_end == NULL)
652 debugdir_end = &debugdir[strlen (debugdir)];
653
654 memcpy (link, debugdir, debugdir_end - debugdir);
655 s = &link[debugdir_end - debugdir];
656 s += sprintf (s, "/.build-id/");
657 if (size > 0)
658 {
659 size--;
660 s += sprintf (s, "%02x", (unsigned) *data++);
661 }
662 if (size > 0)
663 *s++ = '/';
664 while (size-- > 0)
665 s += sprintf (s, "%02x", (unsigned) *data++);
666 strcpy (s, ".debug");
667
668 /* lrealpath() is expensive even for the usually non-existent files. */
669 if (access (link, F_OK) == 0)
670 retval = lrealpath (link);
671
672 if (retval != NULL && !build_id_verify (retval, build_id))
673 {
674 xfree (retval);
675 retval = NULL;
676 }
677
678 if (retval != NULL)
679 break;
680
681 debugdir = debugdir_end;
682 }
683 while (*debugdir != 0);
684
685 return retval;
686}
687
688static char *
689find_separate_debug_file_by_buildid (struct objfile *objfile)
690{
691 struct build_id *build_id;
692
693 build_id = build_id_bfd_get (objfile->obfd);
694 if (build_id != NULL)
695 {
696 char *build_id_name;
697
698 build_id_name = build_id_to_debug_filename (build_id);
699 xfree (build_id);
700 /* Prevent looping on a stripped .debug file. */
701 if (build_id_name != NULL && strcmp (build_id_name, objfile->name) == 0)
702 {
703 warning (_("\"%s\": separate debug info file has no debug info"),
704 build_id_name);
705 xfree (build_id_name);
706 }
707 else if (build_id_name != NULL)
708 return build_id_name;
709 }
710 return NULL;
711}
712
5796c8dc
SS
713/* Scan and build partial symbols for a symbol file.
714 We have been initialized by a call to elf_symfile_init, which
715 currently does nothing.
716
717 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
718 in each section. We simplify it down to a single offset for all
719 symbols. FIXME.
720
5796c8dc
SS
721 This function only does the minimum work necessary for letting the
722 user "name" things symbolically; it does not read the entire symtab.
723 Instead, it reads the external and static symbols and puts them in partial
724 symbol tables. When more extensive information is requested of a
725 file, the corresponding partial symbol table is mutated into a full
726 fledged symbol table by going back and reading the symbols
727 for real.
728
729 We look for sections with specific names, to tell us what debug
730 format to look for: FIXME!!!
731
732 elfstab_build_psymtabs() handles STABS symbols;
733 mdebug_build_psymtabs() handles ECOFF debugging information.
734
735 Note that ELF files have a "minimal" symbol table, which looks a lot
736 like a COFF symbol table, but has only the minimal information necessary
737 for linking. We process this also, and use the information to
738 build gdb's minimal symbol table. This gives us some minimal debugging
739 capability even for files compiled without -g. */
740
741static void
cf7f2e2d 742elf_symfile_read (struct objfile *objfile, int symfile_flags)
5796c8dc
SS
743{
744 bfd *abfd = objfile->obfd;
745 struct elfinfo ei;
746 struct cleanup *back_to;
5796c8dc
SS
747 long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
748 asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
749 asymbol *synthsyms;
750
751 init_minimal_symbol_collection ();
752 back_to = make_cleanup_discard_minimal_symbols ();
753
754 memset ((char *) &ei, 0, sizeof (ei));
755
756 /* Allocate struct to keep track of the symfile */
757 objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
758 xmalloc (sizeof (struct dbx_symfile_info));
759 memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
760 make_cleanup (free_elfinfo, (void *) objfile);
761
762 /* Process the normal ELF symbol table first. This may write some
763 chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
764 which can later be used by elfstab_offset_sections. */
765
766 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
767 if (storage_needed < 0)
768 error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
769 bfd_errmsg (bfd_get_error ()));
770
771 if (storage_needed > 0)
772 {
773 symbol_table = (asymbol **) xmalloc (storage_needed);
774 make_cleanup (xfree, symbol_table);
775 symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
776
777 if (symcount < 0)
778 error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
779 bfd_errmsg (bfd_get_error ()));
780
cf7f2e2d 781 elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
5796c8dc
SS
782 }
783
784 /* Add the dynamic symbols. */
785
786 storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
787
788 if (storage_needed > 0)
789 {
790 dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
791 make_cleanup (xfree, dyn_symbol_table);
792 dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
793 dyn_symbol_table);
794
795 if (dynsymcount < 0)
796 error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
797 bfd_errmsg (bfd_get_error ()));
798
cf7f2e2d 799 elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
5796c8dc
SS
800 }
801
802 /* Add synthetic symbols - for instance, names for any PLT entries. */
803
804 synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
805 dynsymcount, dyn_symbol_table,
806 &synthsyms);
807 if (synthcount > 0)
808 {
809 asymbol **synth_symbol_table;
810 long i;
811
812 make_cleanup (xfree, synthsyms);
813 synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
814 for (i = 0; i < synthcount; i++)
815 synth_symbol_table[i] = synthsyms + i;
816 make_cleanup (xfree, synth_symbol_table);
cf7f2e2d 817 elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, synth_symbol_table, 1);
5796c8dc
SS
818 }
819
820 /* Install any minimal symbols that have been collected as the current
821 minimal symbols for this objfile. The debug readers below this point
822 should not generate new minimal symbols; if they do it's their
823 responsibility to install them. "mdebug" appears to be the only one
824 which will do this. */
825
826 install_minimal_symbols (objfile);
827 do_cleanups (back_to);
828
829 /* Now process debugging information, which is contained in
830 special ELF sections. */
831
5796c8dc
SS
832 /* We first have to find them... */
833 bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
834
835 /* ELF debugging information is inserted into the psymtab in the
836 order of least informative first - most informative last. Since
837 the psymtab table is searched `most recent insertion first' this
838 increases the probability that more detailed debug information
839 for a section is found.
840
841 For instance, an object file might contain both .mdebug (XCOFF)
842 and .debug_info (DWARF2) sections then .mdebug is inserted first
843 (searched last) and DWARF2 is inserted last (searched first). If
844 we don't do this then the XCOFF info is found first - for code in
845 an included file XCOFF info is useless. */
846
847 if (ei.mdebugsect)
848 {
849 const struct ecoff_debug_swap *swap;
850
851 /* .mdebug section, presumably holding ECOFF debugging
852 information. */
853 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
854 if (swap)
855 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
856 }
857 if (ei.stabsect)
858 {
859 asection *str_sect;
860
861 /* Stab sections have an associated string table that looks like
862 a separate section. */
863 str_sect = bfd_get_section_by_name (abfd, ".stabstr");
864
865 /* FIXME should probably warn about a stab section without a stabstr. */
866 if (str_sect)
867 elfstab_build_psymtabs (objfile,
5796c8dc
SS
868 ei.stabsect,
869 str_sect->filepos,
870 bfd_section_size (abfd, str_sect));
871 }
872 if (dwarf2_has_info (objfile))
873 {
874 /* DWARF 2 sections */
cf7f2e2d 875 dwarf2_build_psymtabs (objfile);
5796c8dc
SS
876 }
877
cf7f2e2d
JM
878 /* If the file has its own symbol tables it has no separate debug info.
879 `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to SYMTABS/PSYMTABS.
880 `.gnu_debuglink' may no longer be present with `.note.gnu.build-id'. */
881 if (!objfile_has_partial_symbols (objfile))
882 {
883 char *debugfile;
884
885 debugfile = find_separate_debug_file_by_buildid (objfile);
886
887 if (debugfile == NULL)
888 debugfile = find_separate_debug_file_by_debuglink (objfile);
889
890 if (debugfile)
891 {
892 bfd *abfd = symfile_bfd_open (debugfile);
893
894 symbol_file_add_separate (abfd, symfile_flags, objfile);
895 xfree (debugfile);
896 }
897 }
5796c8dc
SS
898}
899
900/* This cleans up the objfile's deprecated_sym_stab_info pointer, and
901 the chain of stab_section_info's, that might be dangling from
902 it. */
903
904static void
905free_elfinfo (void *objp)
906{
907 struct objfile *objfile = (struct objfile *) objp;
908 struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
909 struct stab_section_info *ssi, *nssi;
910
911 ssi = dbxinfo->stab_section_info;
912 while (ssi)
913 {
914 nssi = ssi->next;
915 xfree (ssi);
916 ssi = nssi;
917 }
918
919 dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */
920}
921
922
923/* Initialize anything that needs initializing when a completely new symbol
924 file is specified (not just adding some symbols from another file, e.g. a
925 shared library).
926
927 We reinitialize buildsym, since we may be reading stabs from an ELF file. */
928
929static void
930elf_new_init (struct objfile *ignore)
931{
932 stabsread_new_init ();
933 buildsym_new_init ();
934}
935
936/* Perform any local cleanups required when we are done with a particular
937 objfile. I.E, we are in the process of discarding all symbol information
938 for an objfile, freeing up all memory held for it, and unlinking the
939 objfile struct from the global list of known objfiles. */
940
941static void
942elf_symfile_finish (struct objfile *objfile)
943{
944 if (objfile->deprecated_sym_stab_info != NULL)
945 {
946 xfree (objfile->deprecated_sym_stab_info);
947 }
948
949 dwarf2_free_objfile (objfile);
950}
951
952/* ELF specific initialization routine for reading symbols.
953
954 It is passed a pointer to a struct sym_fns which contains, among other
955 things, the BFD for the file whose symbols are being read, and a slot for
956 a pointer to "private data" which we can fill with goodies.
957
958 For now at least, we have nothing in particular to do, so this function is
959 just a stub. */
960
961static void
962elf_symfile_init (struct objfile *objfile)
963{
964 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
965 find this causes a significant slowdown in gdb then we could
966 set it in the debug symbol readers only when necessary. */
967 objfile->flags |= OBJF_REORDERED;
968}
969
970/* When handling an ELF file that contains Sun STABS debug info,
971 some of the debug info is relative to the particular chunk of the
972 section that was generated in its individual .o file. E.g.
973 offsets to static variables are relative to the start of the data
974 segment *for that module before linking*. This information is
975 painfully squirreled away in the ELF symbol table as local symbols
976 with wierd names. Go get 'em when needed. */
977
978void
979elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
980{
981 char *filename = pst->filename;
982 struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
983 struct stab_section_info *maybe = dbx->stab_section_info;
984 struct stab_section_info *questionable = 0;
985 int i;
986 char *p;
987
988 /* The ELF symbol info doesn't include path names, so strip the path
989 (if any) from the psymtab filename. */
990 while (0 != (p = strchr (filename, '/')))
991 filename = p + 1;
992
993 /* FIXME: This linear search could speed up significantly
994 if it was chained in the right order to match how we search it,
995 and if we unchained when we found a match. */
996 for (; maybe; maybe = maybe->next)
997 {
998 if (filename[0] == maybe->filename[0]
999 && strcmp (filename, maybe->filename) == 0)
1000 {
1001 /* We found a match. But there might be several source files
1002 (from different directories) with the same name. */
1003 if (0 == maybe->found)
1004 break;
1005 questionable = maybe; /* Might use it later. */
1006 }
1007 }
1008
1009 if (maybe == 0 && questionable != 0)
1010 {
1011 complaint (&symfile_complaints,
1012 _("elf/stab section information questionable for %s"), filename);
1013 maybe = questionable;
1014 }
1015
1016 if (maybe)
1017 {
1018 /* Found it! Allocate a new psymtab struct, and fill it in. */
1019 maybe->found++;
1020 pst->section_offsets = (struct section_offsets *)
1021 obstack_alloc (&objfile->objfile_obstack,
1022 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
1023 for (i = 0; i < maybe->num_sections; i++)
1024 (pst->section_offsets)->offsets[i] = maybe->sections[i];
1025 return;
1026 }
1027
1028 /* We were unable to find any offsets for this file. Complain. */
1029 if (dbx->stab_section_info) /* If there *is* any info, */
1030 complaint (&symfile_complaints,
1031 _("elf/stab section information missing for %s"), filename);
1032}
1033\f
1034/* Register that we are able to handle ELF object file formats. */
1035
1036static struct sym_fns elf_sym_fns =
1037{
1038 bfd_target_elf_flavour,
1039 elf_new_init, /* sym_new_init: init anything gbl to entire symtab */
1040 elf_symfile_init, /* sym_init: read initial info, setup for sym_read() */
1041 elf_symfile_read, /* sym_read: read a symbol file into symtab */
1042 elf_symfile_finish, /* sym_finish: finished with file, cleanup */
1043 default_symfile_offsets, /* sym_offsets: Translate ext. to int. relocation */
1044 elf_symfile_segments, /* sym_segments: Get segment information from
1045 a file. */
1046 NULL, /* sym_read_linetable */
cf7f2e2d
JM
1047 default_symfile_relocate, /* sym_relocate: Relocate a debug section. */
1048 &psym_functions,
5796c8dc
SS
1049 NULL /* next: pointer to next struct sym_fns */
1050};
1051
1052void
1053_initialize_elfread (void)
1054{
1055 add_symtab_fns (&elf_sym_fns);
1056}