Upgrade GDB from 7.4.1 to 7.6.1 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
ef5ccd6c 3 Copyright (C) 1991-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 Written by Fred Fish at Cygnus Support.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22#include "defs.h"
23#include "bfd.h"
24#include "gdb_string.h"
25#include "elf-bfd.h"
26#include "elf/common.h"
27#include "elf/internal.h"
28#include "elf/mips.h"
29#include "symtab.h"
30#include "symfile.h"
31#include "objfiles.h"
32#include "buildsym.h"
33#include "stabsread.h"
34#include "gdb-stabs.h"
35#include "complaints.h"
36#include "demangle.h"
cf7f2e2d 37#include "psympriv.h"
c50c785c 38#include "filenames.h"
ef5ccd6c
JM
39#include "probe.h"
40#include "arch-utils.h"
c50c785c
JM
41#include "gdbtypes.h"
42#include "value.h"
43#include "infcall.h"
44#include "gdbthread.h"
45#include "regcache.h"
ef5ccd6c
JM
46#include "bcache.h"
47#include "gdb_bfd.h"
5796c8dc
SS
48
49extern void _initialize_elfread (void);
50
c50c785c
JM
51/* Forward declarations. */
52static const struct sym_fns elf_sym_fns_gdb_index;
53static const struct sym_fns elf_sym_fns_lazy_psyms;
54
5796c8dc
SS
55/* The struct elfinfo is available only during ELF symbol table and
56 psymtab reading. It is destroyed at the completion of psymtab-reading.
57 It's local to elf_symfile_read. */
58
59struct elfinfo
60 {
61 asection *stabsect; /* Section pointer for .stab section */
62 asection *stabindexsect; /* Section pointer for .stab.index section */
63 asection *mdebugsect; /* Section pointer for .mdebug section */
64 };
65
ef5ccd6c
JM
66/* Per-objfile data for probe info. */
67
68static const struct objfile_data *probe_key = NULL;
69
5796c8dc
SS
70static void free_elfinfo (void *);
71
c50c785c
JM
72/* Minimal symbols located at the GOT entries for .plt - that is the real
73 pointer where the given entry will jump to. It gets updated by the real
74 function address during lazy ld.so resolving in the inferior. These
75 minimal symbols are indexed for <tab>-completion. */
76
77#define SYMBOL_GOT_PLT_SUFFIX "@got.plt"
78
5796c8dc
SS
79/* Locate the segments in ABFD. */
80
81static struct symfile_segment_data *
82elf_symfile_segments (bfd *abfd)
83{
84 Elf_Internal_Phdr *phdrs, **segments;
85 long phdrs_size;
86 int num_phdrs, num_segments, num_sections, i;
87 asection *sect;
88 struct symfile_segment_data *data;
89
90 phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
91 if (phdrs_size == -1)
92 return NULL;
93
94 phdrs = alloca (phdrs_size);
95 num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
96 if (num_phdrs == -1)
97 return NULL;
98
99 num_segments = 0;
100 segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
101 for (i = 0; i < num_phdrs; i++)
102 if (phdrs[i].p_type == PT_LOAD)
103 segments[num_segments++] = &phdrs[i];
104
105 if (num_segments == 0)
106 return NULL;
107
108 data = XZALLOC (struct symfile_segment_data);
109 data->num_segments = num_segments;
110 data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
111 data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
112
113 for (i = 0; i < num_segments; i++)
114 {
115 data->segment_bases[i] = segments[i]->p_vaddr;
116 data->segment_sizes[i] = segments[i]->p_memsz;
117 }
118
119 num_sections = bfd_count_sections (abfd);
120 data->segment_info = XCALLOC (num_sections, int);
121
122 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
123 {
124 int j;
125 CORE_ADDR vma;
126
127 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
128 continue;
129
130 vma = bfd_get_section_vma (abfd, sect);
131
132 for (j = 0; j < num_segments; j++)
133 if (segments[j]->p_memsz > 0
134 && vma >= segments[j]->p_vaddr
135 && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz)
136 {
137 data->segment_info[i] = j + 1;
138 break;
139 }
140
cf7f2e2d
JM
141 /* We should have found a segment for every non-empty section.
142 If we haven't, we will not relocate this section by any
143 offsets we apply to the segments. As an exception, do not
144 warn about SHT_NOBITS sections; in normal ELF execution
145 environments, SHT_NOBITS means zero-initialized and belongs
146 in a segment, but in no-OS environments some tools (e.g. ARM
147 RealView) use SHT_NOBITS for uninitialized data. Since it is
148 uninitialized, it doesn't need a program header. Such
149 binaries are not relocatable. */
150 if (bfd_get_section_size (sect) > 0 && j == num_segments
151 && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
ef5ccd6c 152 warning (_("Loadable section \"%s\" outside of ELF segments"),
5796c8dc
SS
153 bfd_section_name (abfd, sect));
154 }
155
156 return data;
157}
158
159/* We are called once per section from elf_symfile_read. We
160 need to examine each section we are passed, check to see
161 if it is something we are interested in processing, and
162 if so, stash away some access information for the section.
163
164 For now we recognize the dwarf debug information sections and
165 line number sections from matching their section names. The
166 ELF definition is no real help here since it has no direct
167 knowledge of DWARF (by design, so any debugging format can be
168 used).
169
170 We also recognize the ".stab" sections used by the Sun compilers
171 released with Solaris 2.
172
173 FIXME: The section names should not be hardwired strings (what
174 should they be? I don't think most object file formats have enough
c50c785c 175 section flags to specify what kind of debug section it is.
5796c8dc
SS
176 -kingdon). */
177
178static void
179elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
180{
181 struct elfinfo *ei;
182
183 ei = (struct elfinfo *) eip;
184 if (strcmp (sectp->name, ".stab") == 0)
185 {
186 ei->stabsect = sectp;
187 }
188 else if (strcmp (sectp->name, ".stab.index") == 0)
189 {
190 ei->stabindexsect = sectp;
191 }
192 else if (strcmp (sectp->name, ".mdebug") == 0)
193 {
194 ei->mdebugsect = sectp;
195 }
196}
197
198static struct minimal_symbol *
cf7f2e2d
JM
199record_minimal_symbol (const char *name, int name_len, int copy_name,
200 CORE_ADDR address,
5796c8dc
SS
201 enum minimal_symbol_type ms_type,
202 asection *bfd_section, struct objfile *objfile)
203{
204 struct gdbarch *gdbarch = get_objfile_arch (objfile);
205
c50c785c
JM
206 if (ms_type == mst_text || ms_type == mst_file_text
207 || ms_type == mst_text_gnu_ifunc)
ef5ccd6c 208 address = gdbarch_addr_bits_remove (gdbarch, address);
5796c8dc 209
cf7f2e2d
JM
210 return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
211 ms_type, bfd_section->index,
212 bfd_section, objfile);
5796c8dc
SS
213}
214
a45ae5f8 215/* Read the symbol table of an ELF file.
5796c8dc
SS
216
217 Given an objfile, a symbol table, and a flag indicating whether the
218 symbol table contains regular, dynamic, or synthetic symbols, add all
219 the global function and data symbols to the minimal symbol table.
220
221 In stabs-in-ELF, as implemented by Sun, there are some local symbols
222 defined in the ELF symbol table, which can be used to locate
223 the beginnings of sections from each ".o" file that was linked to
224 form the executable objfile. We gather any such info and record it
a45ae5f8 225 in data structures hung off the objfile's private data. */
5796c8dc
SS
226
227#define ST_REGULAR 0
228#define ST_DYNAMIC 1
229#define ST_SYNTHETIC 2
230
231static void
232elf_symtab_read (struct objfile *objfile, int type,
cf7f2e2d
JM
233 long number_of_symbols, asymbol **symbol_table,
234 int copy_names)
5796c8dc
SS
235{
236 struct gdbarch *gdbarch = get_objfile_arch (objfile);
5796c8dc
SS
237 asymbol *sym;
238 long i;
239 CORE_ADDR symaddr;
240 CORE_ADDR offset;
241 enum minimal_symbol_type ms_type;
242 /* If sectinfo is nonNULL, it contains section info that should end up
243 filed in the objfile. */
244 struct stab_section_info *sectinfo = NULL;
245 /* If filesym is nonzero, it points to a file symbol, but we haven't
246 seen any section info for it yet. */
247 asymbol *filesym = 0;
cf7f2e2d 248 /* Name of filesym. This is either a constant string or is saved on
ef5ccd6c
JM
249 the objfile's filename cache. */
250 const char *filesymname = "";
251 struct dbx_symfile_info *dbx = DBX_SYMFILE_INFO (objfile);
5796c8dc
SS
252 int stripped = (bfd_get_symcount (objfile->obfd) == 0);
253
254 for (i = 0; i < number_of_symbols; i++)
255 {
256 sym = symbol_table[i];
257 if (sym->name == NULL || *sym->name == '\0')
258 {
259 /* Skip names that don't exist (shouldn't happen), or names
c50c785c 260 that are null strings (may happen). */
5796c8dc
SS
261 continue;
262 }
263
264 /* Skip "special" symbols, e.g. ARM mapping symbols. These are
265 symbols which do not correspond to objects in the symbol table,
266 but have some other target-specific meaning. */
267 if (bfd_is_target_special_symbol (objfile->obfd, sym))
268 {
269 if (gdbarch_record_special_symbol_p (gdbarch))
270 gdbarch_record_special_symbol (gdbarch, objfile, sym);
271 continue;
272 }
273
274 offset = ANOFFSET (objfile->section_offsets, sym->section->index);
275 if (type == ST_DYNAMIC
ef5ccd6c 276 && sym->section == bfd_und_section_ptr
5796c8dc
SS
277 && (sym->flags & BSF_FUNCTION))
278 {
279 struct minimal_symbol *msym;
280 bfd *abfd = objfile->obfd;
a45ae5f8 281 asection *sect;
5796c8dc
SS
282
283 /* Symbol is a reference to a function defined in
284 a shared library.
285 If its value is non zero then it is usually the address
286 of the corresponding entry in the procedure linkage table,
287 plus the desired section offset.
288 If its value is zero then the dynamic linker has to resolve
c50c785c 289 the symbol. We are unable to find any meaningful address
5796c8dc
SS
290 for this symbol in the executable file, so we skip it. */
291 symaddr = sym->value;
292 if (symaddr == 0)
293 continue;
294
295 /* sym->section is the undefined section. However, we want to
296 record the section where the PLT stub resides with the
297 minimal symbol. Search the section table for the one that
298 covers the stub's address. */
299 for (sect = abfd->sections; sect != NULL; sect = sect->next)
300 {
301 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
302 continue;
303
304 if (symaddr >= bfd_get_section_vma (abfd, sect)
305 && symaddr < bfd_get_section_vma (abfd, sect)
306 + bfd_get_section_size (sect))
307 break;
308 }
309 if (!sect)
310 continue;
311
ef5ccd6c
JM
312 /* On ia64-hpux, we have discovered that the system linker
313 adds undefined symbols with nonzero addresses that cannot
314 be right (their address points inside the code of another
315 function in the .text section). This creates problems
316 when trying to determine which symbol corresponds to
317 a given address.
318
319 We try to detect those buggy symbols by checking which
320 section we think they correspond to. Normally, PLT symbols
321 are stored inside their own section, and the typical name
322 for that section is ".plt". So, if there is a ".plt"
323 section, and yet the section name of our symbol does not
324 start with ".plt", we ignore that symbol. */
325 if (strncmp (sect->name, ".plt", 4) != 0
326 && bfd_get_section_by_name (abfd, ".plt") != NULL)
327 continue;
328
5796c8dc
SS
329 symaddr += ANOFFSET (objfile->section_offsets, sect->index);
330
331 msym = record_minimal_symbol
cf7f2e2d
JM
332 (sym->name, strlen (sym->name), copy_names,
333 symaddr, mst_solib_trampoline, sect, objfile);
5796c8dc
SS
334 if (msym != NULL)
335 msym->filename = filesymname;
336 continue;
337 }
338
339 /* If it is a nonstripped executable, do not enter dynamic
340 symbols, as the dynamic symbol table is usually a subset
341 of the main symbol table. */
342 if (type == ST_DYNAMIC && !stripped)
343 continue;
344 if (sym->flags & BSF_FILE)
345 {
346 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
347 Chain any old one onto the objfile; remember new sym. */
348 if (sectinfo != NULL)
349 {
350 sectinfo->next = dbx->stab_section_info;
351 dbx->stab_section_info = sectinfo;
352 sectinfo = NULL;
353 }
354 filesym = sym;
ef5ccd6c
JM
355 filesymname = bcache (filesym->name, strlen (filesym->name) + 1,
356 objfile->per_bfd->filename_cache);
5796c8dc
SS
357 }
358 else if (sym->flags & BSF_SECTION_SYM)
359 continue;
ef5ccd6c
JM
360 else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK
361 | BSF_GNU_UNIQUE))
5796c8dc
SS
362 {
363 struct minimal_symbol *msym;
364
365 /* Select global/local/weak symbols. Note that bfd puts abs
366 symbols in their own section, so all symbols we are
c50c785c
JM
367 interested in will have a section. */
368 /* Bfd symbols are section relative. */
5796c8dc
SS
369 symaddr = sym->value + sym->section->vma;
370 /* Relocate all non-absolute and non-TLS symbols by the
371 section offset. */
ef5ccd6c 372 if (sym->section != bfd_abs_section_ptr
5796c8dc
SS
373 && !(sym->section->flags & SEC_THREAD_LOCAL))
374 {
375 symaddr += offset;
376 }
377 /* For non-absolute symbols, use the type of the section
378 they are relative to, to intuit text/data. Bfd provides
c50c785c 379 no way of figuring this out for absolute symbols. */
ef5ccd6c 380 if (sym->section == bfd_abs_section_ptr)
5796c8dc
SS
381 {
382 /* This is a hack to get the minimal symbol type
383 right for Irix 5, which has absolute addresses
384 with special section indices for dynamic symbols.
385
386 NOTE: uweigand-20071112: Synthetic symbols do not
387 have an ELF-private part, so do not touch those. */
a45ae5f8 388 unsigned int shndx = type == ST_SYNTHETIC ? 0 :
5796c8dc
SS
389 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
390
391 switch (shndx)
392 {
393 case SHN_MIPS_TEXT:
394 ms_type = mst_text;
395 break;
396 case SHN_MIPS_DATA:
397 ms_type = mst_data;
398 break;
399 case SHN_MIPS_ACOMMON:
400 ms_type = mst_bss;
401 break;
402 default:
403 ms_type = mst_abs;
404 }
405
406 /* If it is an Irix dynamic symbol, skip section name
c50c785c 407 symbols, relocate all others by section offset. */
5796c8dc
SS
408 if (ms_type != mst_abs)
409 {
410 if (sym->name[0] == '.')
411 continue;
412 symaddr += offset;
413 }
414 }
415 else if (sym->section->flags & SEC_CODE)
416 {
ef5ccd6c 417 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE))
5796c8dc 418 {
c50c785c
JM
419 if (sym->flags & BSF_GNU_INDIRECT_FUNCTION)
420 ms_type = mst_text_gnu_ifunc;
421 else
422 ms_type = mst_text;
5796c8dc 423 }
a45ae5f8
JM
424 /* The BSF_SYNTHETIC check is there to omit ppc64 function
425 descriptors mistaken for static functions starting with 'L'.
426 */
427 else if ((sym->name[0] == '.' && sym->name[1] == 'L'
428 && (sym->flags & BSF_SYNTHETIC) == 0)
5796c8dc
SS
429 || ((sym->flags & BSF_LOCAL)
430 && sym->name[0] == '$'
431 && sym->name[1] == 'L'))
432 /* Looks like a compiler-generated label. Skip
433 it. The assembler should be skipping these (to
434 keep executables small), but apparently with
435 gcc on the (deleted) delta m88k SVR4, it loses.
436 So to have us check too should be harmless (but
437 I encourage people to fix this in the assembler
438 instead of adding checks here). */
439 continue;
440 else
441 {
442 ms_type = mst_file_text;
443 }
444 }
445 else if (sym->section->flags & SEC_ALLOC)
446 {
ef5ccd6c 447 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE))
5796c8dc
SS
448 {
449 if (sym->section->flags & SEC_LOAD)
450 {
451 ms_type = mst_data;
452 }
453 else
454 {
455 ms_type = mst_bss;
456 }
457 }
458 else if (sym->flags & BSF_LOCAL)
459 {
460 /* Named Local variable in a Data section.
461 Check its name for stabs-in-elf. */
462 int special_local_sect;
cf7f2e2d 463
5796c8dc
SS
464 if (strcmp ("Bbss.bss", sym->name) == 0)
465 special_local_sect = SECT_OFF_BSS (objfile);
466 else if (strcmp ("Ddata.data", sym->name) == 0)
467 special_local_sect = SECT_OFF_DATA (objfile);
468 else if (strcmp ("Drodata.rodata", sym->name) == 0)
469 special_local_sect = SECT_OFF_RODATA (objfile);
470 else
471 special_local_sect = -1;
472 if (special_local_sect >= 0)
473 {
474 /* Found a special local symbol. Allocate a
475 sectinfo, if needed, and fill it in. */
476 if (sectinfo == NULL)
477 {
478 int max_index;
479 size_t size;
480
481 max_index = SECT_OFF_BSS (objfile);
482 if (objfile->sect_index_data > max_index)
483 max_index = objfile->sect_index_data;
484 if (objfile->sect_index_rodata > max_index)
485 max_index = objfile->sect_index_rodata;
486
487 /* max_index is the largest index we'll
488 use into this array, so we must
489 allocate max_index+1 elements for it.
490 However, 'struct stab_section_info'
491 already includes one element, so we
492 need to allocate max_index aadditional
493 elements. */
a45ae5f8 494 size = (sizeof (struct stab_section_info)
c50c785c 495 + (sizeof (CORE_ADDR) * max_index));
5796c8dc
SS
496 sectinfo = (struct stab_section_info *)
497 xmalloc (size);
498 memset (sectinfo, 0, size);
499 sectinfo->num_sections = max_index;
500 if (filesym == NULL)
501 {
502 complaint (&symfile_complaints,
c50c785c
JM
503 _("elf/stab section information %s "
504 "without a preceding file symbol"),
5796c8dc
SS
505 sym->name);
506 }
507 else
508 {
509 sectinfo->filename =
510 (char *) filesym->name;
511 }
512 }
513 if (sectinfo->sections[special_local_sect] != 0)
514 complaint (&symfile_complaints,
c50c785c
JM
515 _("duplicated elf/stab section "
516 "information for %s"),
5796c8dc
SS
517 sectinfo->filename);
518 /* BFD symbols are section relative. */
519 symaddr = sym->value + sym->section->vma;
520 /* Relocate non-absolute symbols by the
521 section offset. */
ef5ccd6c 522 if (sym->section != bfd_abs_section_ptr)
5796c8dc
SS
523 symaddr += offset;
524 sectinfo->sections[special_local_sect] = symaddr;
525 /* The special local symbols don't go in the
526 minimal symbol table, so ignore this one. */
527 continue;
528 }
529 /* Not a special stabs-in-elf symbol, do regular
530 symbol processing. */
531 if (sym->section->flags & SEC_LOAD)
532 {
533 ms_type = mst_file_data;
534 }
535 else
536 {
537 ms_type = mst_file_bss;
538 }
539 }
540 else
541 {
542 ms_type = mst_unknown;
543 }
544 }
545 else
546 {
547 /* FIXME: Solaris2 shared libraries include lots of
a45ae5f8 548 odd "absolute" and "undefined" symbols, that play
5796c8dc
SS
549 hob with actions like finding what function the PC
550 is in. Ignore them if they aren't text, data, or bss. */
551 /* ms_type = mst_unknown; */
c50c785c 552 continue; /* Skip this symbol. */
5796c8dc
SS
553 }
554 msym = record_minimal_symbol
cf7f2e2d 555 (sym->name, strlen (sym->name), copy_names, symaddr,
5796c8dc
SS
556 ms_type, sym->section, objfile);
557
558 if (msym)
559 {
5796c8dc 560 /* NOTE: uweigand-20071112: A synthetic symbol does not have an
ef5ccd6c 561 ELF-private part. */
5796c8dc 562 if (type != ST_SYNTHETIC)
ef5ccd6c
JM
563 {
564 /* Pass symbol size field in via BFD. FIXME!!! */
565 elf_symbol_type *elf_sym = (elf_symbol_type *) sym;
566 SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size);
567 }
a45ae5f8 568
cf7f2e2d
JM
569 msym->filename = filesymname;
570 gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
5796c8dc 571 }
5796c8dc
SS
572
573 /* For @plt symbols, also record a trampoline to the
574 destination symbol. The @plt symbol will be used in
575 disassembly, and the trampoline will be used when we are
576 trying to find the target. */
577 if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
578 {
579 int len = strlen (sym->name);
580
581 if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
582 {
5796c8dc
SS
583 struct minimal_symbol *mtramp;
584
cf7f2e2d
JM
585 mtramp = record_minimal_symbol (sym->name, len - 4, 1,
586 symaddr,
5796c8dc
SS
587 mst_solib_trampoline,
588 sym->section, objfile);
589 if (mtramp)
590 {
ef5ccd6c
JM
591 SET_MSYMBOL_SIZE (mtramp, MSYMBOL_SIZE (msym));
592 mtramp->created_by_gdb = 1;
5796c8dc
SS
593 mtramp->filename = filesymname;
594 gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
595 }
596 }
597 }
598 }
599 }
600}
601
c50c785c
JM
602/* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX)
603 for later look ups of which function to call when user requests
604 a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target
605 library defining `function' we cannot yet know while reading OBJFILE which
606 of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later
607 DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */
608
609static void
610elf_rel_plt_read (struct objfile *objfile, asymbol **dyn_symbol_table)
611{
612 bfd *obfd = objfile->obfd;
613 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
614 asection *plt, *relplt, *got_plt;
c50c785c
JM
615 int plt_elf_idx;
616 bfd_size_type reloc_count, reloc;
617 char *string_buffer = NULL;
618 size_t string_buffer_size = 0;
619 struct cleanup *back_to;
620 struct gdbarch *gdbarch = objfile->gdbarch;
621 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
622 size_t ptr_size = TYPE_LENGTH (ptr_type);
623
624 if (objfile->separate_debug_objfile_backlink)
625 return;
626
627 plt = bfd_get_section_by_name (obfd, ".plt");
628 if (plt == NULL)
629 return;
630 plt_elf_idx = elf_section_data (plt)->this_idx;
631
632 got_plt = bfd_get_section_by_name (obfd, ".got.plt");
633 if (got_plt == NULL)
634 return;
635
636 /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */
637 for (relplt = obfd->sections; relplt != NULL; relplt = relplt->next)
638 if (elf_section_data (relplt)->this_hdr.sh_info == plt_elf_idx
639 && (elf_section_data (relplt)->this_hdr.sh_type == SHT_REL
640 || elf_section_data (relplt)->this_hdr.sh_type == SHT_RELA))
641 break;
642 if (relplt == NULL)
643 return;
644
645 if (! bed->s->slurp_reloc_table (obfd, relplt, dyn_symbol_table, TRUE))
646 return;
647
648 back_to = make_cleanup (free_current_contents, &string_buffer);
649
650 reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize;
651 for (reloc = 0; reloc < reloc_count; reloc++)
652 {
ef5ccd6c 653 const char *name;
c50c785c
JM
654 struct minimal_symbol *msym;
655 CORE_ADDR address;
656 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
657 size_t name_len;
658
659 name = bfd_asymbol_name (*relplt->relocation[reloc].sym_ptr_ptr);
660 name_len = strlen (name);
661 address = relplt->relocation[reloc].address;
662
663 /* Does the pointer reside in the .got.plt section? */
664 if (!(bfd_get_section_vma (obfd, got_plt) <= address
665 && address < bfd_get_section_vma (obfd, got_plt)
666 + bfd_get_section_size (got_plt)))
667 continue;
668
669 /* We cannot check if NAME is a reference to mst_text_gnu_ifunc as in
670 OBJFILE the symbol is undefined and the objfile having NAME defined
671 may not yet have been loaded. */
672
a45ae5f8 673 if (string_buffer_size < name_len + got_suffix_len + 1)
c50c785c
JM
674 {
675 string_buffer_size = 2 * (name_len + got_suffix_len);
676 string_buffer = xrealloc (string_buffer, string_buffer_size);
677 }
678 memcpy (string_buffer, name, name_len);
679 memcpy (&string_buffer[name_len], SYMBOL_GOT_PLT_SUFFIX,
a45ae5f8 680 got_suffix_len + 1);
c50c785c
JM
681
682 msym = record_minimal_symbol (string_buffer, name_len + got_suffix_len,
683 1, address, mst_slot_got_plt, got_plt,
684 objfile);
685 if (msym)
ef5ccd6c 686 SET_MSYMBOL_SIZE (msym, ptr_size);
c50c785c
JM
687 }
688
689 do_cleanups (back_to);
690}
691
692/* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */
693
694static const struct objfile_data *elf_objfile_gnu_ifunc_cache_data;
695
696/* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */
697
698struct elf_gnu_ifunc_cache
699{
700 /* This is always a function entry address, not a function descriptor. */
701 CORE_ADDR addr;
702
703 char name[1];
704};
705
706/* htab_hash for elf_objfile_gnu_ifunc_cache_data. */
707
708static hashval_t
709elf_gnu_ifunc_cache_hash (const void *a_voidp)
710{
711 const struct elf_gnu_ifunc_cache *a = a_voidp;
712
713 return htab_hash_string (a->name);
714}
715
716/* htab_eq for elf_objfile_gnu_ifunc_cache_data. */
717
718static int
719elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp)
720{
721 const struct elf_gnu_ifunc_cache *a = a_voidp;
722 const struct elf_gnu_ifunc_cache *b = b_voidp;
723
724 return strcmp (a->name, b->name) == 0;
725}
726
727/* Record the target function address of a STT_GNU_IFUNC function NAME is the
728 function entry address ADDR. Return 1 if NAME and ADDR are considered as
729 valid and therefore they were successfully recorded, return 0 otherwise.
730
731 Function does not expect a duplicate entry. Use
732 elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already
733 exists. */
734
735static int
736elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
737{
738 struct minimal_symbol *msym;
739 asection *sect;
740 struct objfile *objfile;
741 htab_t htab;
742 struct elf_gnu_ifunc_cache entry_local, *entry_p;
743 void **slot;
744
745 msym = lookup_minimal_symbol_by_pc (addr);
746 if (msym == NULL)
747 return 0;
748 if (SYMBOL_VALUE_ADDRESS (msym) != addr)
749 return 0;
750 /* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL. */
751 sect = SYMBOL_OBJ_SECTION (msym)->the_bfd_section;
752 objfile = SYMBOL_OBJ_SECTION (msym)->objfile;
753
754 /* If .plt jumps back to .plt the symbol is still deferred for later
755 resolution and it has no use for GDB. Besides ".text" this symbol can
756 reside also in ".opd" for ppc64 function descriptor. */
757 if (strcmp (bfd_get_section_name (objfile->obfd, sect), ".plt") == 0)
758 return 0;
759
760 htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
761 if (htab == NULL)
762 {
763 htab = htab_create_alloc_ex (1, elf_gnu_ifunc_cache_hash,
764 elf_gnu_ifunc_cache_eq,
765 NULL, &objfile->objfile_obstack,
766 hashtab_obstack_allocate,
767 dummy_obstack_deallocate);
768 set_objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data, htab);
769 }
770
771 entry_local.addr = addr;
772 obstack_grow (&objfile->objfile_obstack, &entry_local,
773 offsetof (struct elf_gnu_ifunc_cache, name));
774 obstack_grow_str0 (&objfile->objfile_obstack, name);
775 entry_p = obstack_finish (&objfile->objfile_obstack);
776
777 slot = htab_find_slot (htab, entry_p, INSERT);
778 if (*slot != NULL)
779 {
780 struct elf_gnu_ifunc_cache *entry_found_p = *slot;
781 struct gdbarch *gdbarch = objfile->gdbarch;
782
783 if (entry_found_p->addr != addr)
784 {
785 /* This case indicates buggy inferior program, the resolved address
786 should never change. */
787
788 warning (_("gnu-indirect-function \"%s\" has changed its resolved "
789 "function_address from %s to %s"),
790 name, paddress (gdbarch, entry_found_p->addr),
791 paddress (gdbarch, addr));
792 }
793
794 /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */
795 }
796 *slot = entry_p;
797
798 return 1;
799}
800
801/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
802 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
803 is not NULL) and the function returns 1. It returns 0 otherwise.
804
805 Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this
806 function. */
807
808static int
809elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p)
810{
811 struct objfile *objfile;
812
813 ALL_PSPACE_OBJFILES (current_program_space, objfile)
814 {
815 htab_t htab;
816 struct elf_gnu_ifunc_cache *entry_p;
817 void **slot;
818
819 htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
820 if (htab == NULL)
821 continue;
822
823 entry_p = alloca (sizeof (*entry_p) + strlen (name));
824 strcpy (entry_p->name, name);
825
826 slot = htab_find_slot (htab, entry_p, NO_INSERT);
827 if (slot == NULL)
828 continue;
829 entry_p = *slot;
830 gdb_assert (entry_p != NULL);
831
832 if (addr_p)
833 *addr_p = entry_p->addr;
834 return 1;
835 }
836
837 return 0;
838}
839
840/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
841 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
842 is not NULL) and the function returns 1. It returns 0 otherwise.
843
844 Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function.
845 elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to
846 prevent cache entries duplicates. */
847
848static int
849elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p)
850{
851 char *name_got_plt;
852 struct objfile *objfile;
853 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
854
855 name_got_plt = alloca (strlen (name) + got_suffix_len + 1);
856 sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name);
857
858 ALL_PSPACE_OBJFILES (current_program_space, objfile)
859 {
860 bfd *obfd = objfile->obfd;
861 struct gdbarch *gdbarch = objfile->gdbarch;
862 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
863 size_t ptr_size = TYPE_LENGTH (ptr_type);
864 CORE_ADDR pointer_address, addr;
865 asection *plt;
866 gdb_byte *buf = alloca (ptr_size);
867 struct minimal_symbol *msym;
868
869 msym = lookup_minimal_symbol (name_got_plt, NULL, objfile);
870 if (msym == NULL)
871 continue;
872 if (MSYMBOL_TYPE (msym) != mst_slot_got_plt)
873 continue;
874 pointer_address = SYMBOL_VALUE_ADDRESS (msym);
875
876 plt = bfd_get_section_by_name (obfd, ".plt");
877 if (plt == NULL)
878 continue;
879
880 if (MSYMBOL_SIZE (msym) != ptr_size)
881 continue;
882 if (target_read_memory (pointer_address, buf, ptr_size) != 0)
883 continue;
884 addr = extract_typed_address (buf, ptr_type);
885 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
886 &current_target);
887
888 if (addr_p)
889 *addr_p = addr;
890 if (elf_gnu_ifunc_record_cache (name, addr))
891 return 1;
892 }
893
894 return 0;
895}
896
897/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
898 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
899 is not NULL) and the function returns 1. It returns 0 otherwise.
900
901 Both the elf_objfile_gnu_ifunc_cache_data hash table and
902 SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */
903
904static int
905elf_gnu_ifunc_resolve_name (const char *name, CORE_ADDR *addr_p)
906{
907 if (elf_gnu_ifunc_resolve_by_cache (name, addr_p))
908 return 1;
a45ae5f8 909
c50c785c
JM
910 if (elf_gnu_ifunc_resolve_by_got (name, addr_p))
911 return 1;
912
913 return 0;
914}
915
916/* Call STT_GNU_IFUNC - a function returning addresss of a real function to
917 call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned
918 is the entry point of the resolved STT_GNU_IFUNC target function to call.
919 */
920
921static CORE_ADDR
922elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
923{
ef5ccd6c 924 const char *name_at_pc;
c50c785c
JM
925 CORE_ADDR start_at_pc, address;
926 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
927 struct value *function, *address_val;
928
929 /* Try first any non-intrusive methods without an inferior call. */
930
931 if (find_pc_partial_function (pc, &name_at_pc, &start_at_pc, NULL)
932 && start_at_pc == pc)
933 {
934 if (elf_gnu_ifunc_resolve_name (name_at_pc, &address))
935 return address;
936 }
937 else
938 name_at_pc = NULL;
939
940 function = allocate_value (func_func_type);
941 set_value_address (function, pc);
942
943 /* STT_GNU_IFUNC resolver functions have no parameters. FUNCTION is the
944 function entry address. ADDRESS may be a function descriptor. */
945
946 address_val = call_function_by_hand (function, 0, NULL);
947 address = value_as_address (address_val);
948 address = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
949 &current_target);
950
951 if (name_at_pc)
952 elf_gnu_ifunc_record_cache (name_at_pc, address);
953
954 return address;
955}
956
957/* Handle inferior hit of bp_gnu_ifunc_resolver, see its definition. */
958
959static void
960elf_gnu_ifunc_resolver_stop (struct breakpoint *b)
961{
962 struct breakpoint *b_return;
963 struct frame_info *prev_frame = get_prev_frame (get_current_frame ());
964 struct frame_id prev_frame_id = get_stack_frame_id (prev_frame);
965 CORE_ADDR prev_pc = get_frame_pc (prev_frame);
966 int thread_id = pid_to_thread_id (inferior_ptid);
967
968 gdb_assert (b->type == bp_gnu_ifunc_resolver);
969
970 for (b_return = b->related_breakpoint; b_return != b;
971 b_return = b_return->related_breakpoint)
972 {
973 gdb_assert (b_return->type == bp_gnu_ifunc_resolver_return);
974 gdb_assert (b_return->loc != NULL && b_return->loc->next == NULL);
975 gdb_assert (frame_id_p (b_return->frame_id));
976
977 if (b_return->thread == thread_id
978 && b_return->loc->requested_address == prev_pc
979 && frame_id_eq (b_return->frame_id, prev_frame_id))
980 break;
981 }
982
983 if (b_return == b)
984 {
985 struct symtab_and_line sal;
986
987 /* No need to call find_pc_line for symbols resolving as this is only
988 a helper breakpointer never shown to the user. */
989
990 init_sal (&sal);
991 sal.pspace = current_inferior ()->pspace;
992 sal.pc = prev_pc;
993 sal.section = find_pc_overlay (sal.pc);
994 sal.explicit_pc = 1;
995 b_return = set_momentary_breakpoint (get_frame_arch (prev_frame), sal,
996 prev_frame_id,
997 bp_gnu_ifunc_resolver_return);
998
ef5ccd6c
JM
999 /* set_momentary_breakpoint invalidates PREV_FRAME. */
1000 prev_frame = NULL;
1001
c50c785c
JM
1002 /* Add new b_return to the ring list b->related_breakpoint. */
1003 gdb_assert (b_return->related_breakpoint == b_return);
1004 b_return->related_breakpoint = b->related_breakpoint;
1005 b->related_breakpoint = b_return;
1006 }
1007}
1008
1009/* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition. */
1010
1011static void
1012elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b)
1013{
1014 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
1015 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
1016 struct type *value_type = TYPE_TARGET_TYPE (func_func_type);
1017 struct regcache *regcache = get_thread_regcache (inferior_ptid);
ef5ccd6c 1018 struct value *func_func;
c50c785c
JM
1019 struct value *value;
1020 CORE_ADDR resolved_address, resolved_pc;
1021 struct symtab_and_line sal;
1022 struct symtabs_and_lines sals, sals_end;
1023
1024 gdb_assert (b->type == bp_gnu_ifunc_resolver_return);
1025
c50c785c
JM
1026 while (b->related_breakpoint != b)
1027 {
1028 struct breakpoint *b_next = b->related_breakpoint;
1029
1030 switch (b->type)
1031 {
1032 case bp_gnu_ifunc_resolver:
1033 break;
1034 case bp_gnu_ifunc_resolver_return:
1035 delete_breakpoint (b);
1036 break;
1037 default:
1038 internal_error (__FILE__, __LINE__,
1039 _("handle_inferior_event: Invalid "
1040 "gnu-indirect-function breakpoint type %d"),
1041 (int) b->type);
1042 }
1043 b = b_next;
1044 }
1045 gdb_assert (b->type == bp_gnu_ifunc_resolver);
ef5ccd6c
JM
1046 gdb_assert (b->loc->next == NULL);
1047
1048 func_func = allocate_value (func_func_type);
1049 set_value_address (func_func, b->loc->related_address);
1050
1051 value = allocate_value (value_type);
1052 gdbarch_return_value (gdbarch, func_func, value_type, regcache,
1053 value_contents_raw (value), NULL);
1054 resolved_address = value_as_address (value);
1055 resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
1056 resolved_address,
1057 &current_target);
c50c785c 1058
a45ae5f8 1059 gdb_assert (current_program_space == b->pspace || b->pspace == NULL);
c50c785c
JM
1060 elf_gnu_ifunc_record_cache (b->addr_string, resolved_pc);
1061
1062 sal = find_pc_line (resolved_pc, 0);
1063 sals.nelts = 1;
1064 sals.sals = &sal;
1065 sals_end.nelts = 0;
1066
1067 b->type = bp_breakpoint;
1068 update_breakpoint_locations (b, sals, sals_end);
1069}
1070
cf7f2e2d
JM
1071/* Locate NT_GNU_BUILD_ID from ABFD and return its content. */
1072
ef5ccd6c 1073static const struct elf_build_id *
cf7f2e2d
JM
1074build_id_bfd_get (bfd *abfd)
1075{
cf7f2e2d
JM
1076 if (!bfd_check_format (abfd, bfd_object)
1077 || bfd_get_flavour (abfd) != bfd_target_elf_flavour
1078 || elf_tdata (abfd)->build_id == NULL)
1079 return NULL;
1080
ef5ccd6c 1081 return elf_tdata (abfd)->build_id;
cf7f2e2d
JM
1082}
1083
1084/* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */
1085
1086static int
ef5ccd6c 1087build_id_verify (const char *filename, const struct elf_build_id *check)
cf7f2e2d
JM
1088{
1089 bfd *abfd;
ef5ccd6c 1090 const struct elf_build_id *found;
cf7f2e2d
JM
1091 int retval = 0;
1092
1093 /* We expect to be silent on the non-existing files. */
ef5ccd6c 1094 abfd = gdb_bfd_open_maybe_remote (filename);
cf7f2e2d
JM
1095 if (abfd == NULL)
1096 return 0;
1097
1098 found = build_id_bfd_get (abfd);
1099
1100 if (found == NULL)
1101 warning (_("File \"%s\" has no build-id, file skipped"), filename);
1102 else if (found->size != check->size
1103 || memcmp (found->data, check->data, found->size) != 0)
c50c785c
JM
1104 warning (_("File \"%s\" has a different build-id, file skipped"),
1105 filename);
cf7f2e2d
JM
1106 else
1107 retval = 1;
1108
ef5ccd6c 1109 gdb_bfd_unref (abfd);
cf7f2e2d
JM
1110
1111 return retval;
1112}
1113
1114static char *
ef5ccd6c 1115build_id_to_debug_filename (const struct elf_build_id *build_id)
cf7f2e2d
JM
1116{
1117 char *link, *debugdir, *retval = NULL;
ef5ccd6c
JM
1118 VEC (char_ptr) *debugdir_vec;
1119 struct cleanup *back_to;
1120 int ix;
cf7f2e2d
JM
1121
1122 /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
1123 link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
1124 + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
1125
1126 /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1127 cause "/.build-id/..." lookups. */
1128
ef5ccd6c
JM
1129 debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory);
1130 back_to = make_cleanup_free_char_ptr_vec (debugdir_vec);
1131
1132 for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix)
cf7f2e2d 1133 {
ef5ccd6c
JM
1134 size_t debugdir_len = strlen (debugdir);
1135 const gdb_byte *data = build_id->data;
cf7f2e2d 1136 size_t size = build_id->size;
ef5ccd6c 1137 char *s;
cf7f2e2d 1138
ef5ccd6c
JM
1139 memcpy (link, debugdir, debugdir_len);
1140 s = &link[debugdir_len];
cf7f2e2d
JM
1141 s += sprintf (s, "/.build-id/");
1142 if (size > 0)
1143 {
1144 size--;
1145 s += sprintf (s, "%02x", (unsigned) *data++);
1146 }
1147 if (size > 0)
1148 *s++ = '/';
1149 while (size-- > 0)
1150 s += sprintf (s, "%02x", (unsigned) *data++);
1151 strcpy (s, ".debug");
1152
1153 /* lrealpath() is expensive even for the usually non-existent files. */
1154 if (access (link, F_OK) == 0)
1155 retval = lrealpath (link);
1156
1157 if (retval != NULL && !build_id_verify (retval, build_id))
1158 {
1159 xfree (retval);
1160 retval = NULL;
1161 }
1162
1163 if (retval != NULL)
1164 break;
cf7f2e2d 1165 }
cf7f2e2d 1166
ef5ccd6c 1167 do_cleanups (back_to);
cf7f2e2d
JM
1168 return retval;
1169}
1170
1171static char *
1172find_separate_debug_file_by_buildid (struct objfile *objfile)
1173{
ef5ccd6c 1174 const struct elf_build_id *build_id;
cf7f2e2d
JM
1175
1176 build_id = build_id_bfd_get (objfile->obfd);
1177 if (build_id != NULL)
1178 {
1179 char *build_id_name;
1180
1181 build_id_name = build_id_to_debug_filename (build_id);
cf7f2e2d 1182 /* Prevent looping on a stripped .debug file. */
c50c785c
JM
1183 if (build_id_name != NULL
1184 && filename_cmp (build_id_name, objfile->name) == 0)
cf7f2e2d
JM
1185 {
1186 warning (_("\"%s\": separate debug info file has no debug info"),
1187 build_id_name);
1188 xfree (build_id_name);
1189 }
1190 else if (build_id_name != NULL)
1191 return build_id_name;
1192 }
1193 return NULL;
1194}
1195
5796c8dc 1196/* Scan and build partial symbols for a symbol file.
a45ae5f8 1197 We have been initialized by a call to elf_symfile_init, which
5796c8dc
SS
1198 currently does nothing.
1199
1200 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
1201 in each section. We simplify it down to a single offset for all
1202 symbols. FIXME.
1203
5796c8dc
SS
1204 This function only does the minimum work necessary for letting the
1205 user "name" things symbolically; it does not read the entire symtab.
1206 Instead, it reads the external and static symbols and puts them in partial
1207 symbol tables. When more extensive information is requested of a
1208 file, the corresponding partial symbol table is mutated into a full
1209 fledged symbol table by going back and reading the symbols
1210 for real.
1211
1212 We look for sections with specific names, to tell us what debug
1213 format to look for: FIXME!!!
1214
1215 elfstab_build_psymtabs() handles STABS symbols;
1216 mdebug_build_psymtabs() handles ECOFF debugging information.
1217
1218 Note that ELF files have a "minimal" symbol table, which looks a lot
1219 like a COFF symbol table, but has only the minimal information necessary
1220 for linking. We process this also, and use the information to
1221 build gdb's minimal symbol table. This gives us some minimal debugging
1222 capability even for files compiled without -g. */
1223
1224static void
cf7f2e2d 1225elf_symfile_read (struct objfile *objfile, int symfile_flags)
5796c8dc 1226{
a45ae5f8 1227 bfd *synth_abfd, *abfd = objfile->obfd;
5796c8dc
SS
1228 struct elfinfo ei;
1229 struct cleanup *back_to;
5796c8dc
SS
1230 long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
1231 asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
1232 asymbol *synthsyms;
ef5ccd6c
JM
1233 struct dbx_symfile_info *dbx;
1234
1235 if (symtab_create_debug)
1236 {
1237 fprintf_unfiltered (gdb_stdlog,
1238 "Reading minimal symbols of objfile %s ...\n",
1239 objfile->name);
1240 }
5796c8dc
SS
1241
1242 init_minimal_symbol_collection ();
1243 back_to = make_cleanup_discard_minimal_symbols ();
1244
1245 memset ((char *) &ei, 0, sizeof (ei));
1246
c50c785c 1247 /* Allocate struct to keep track of the symfile. */
ef5ccd6c
JM
1248 dbx = XCNEW (struct dbx_symfile_info);
1249 set_objfile_data (objfile, dbx_objfile_data_key, dbx);
5796c8dc
SS
1250 make_cleanup (free_elfinfo, (void *) objfile);
1251
c50c785c 1252 /* Process the normal ELF symbol table first. This may write some
ef5ccd6c
JM
1253 chain of info into the dbx_symfile_info of the objfile, which can
1254 later be used by elfstab_offset_sections. */
5796c8dc
SS
1255
1256 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
1257 if (storage_needed < 0)
c50c785c
JM
1258 error (_("Can't read symbols from %s: %s"),
1259 bfd_get_filename (objfile->obfd),
5796c8dc
SS
1260 bfd_errmsg (bfd_get_error ()));
1261
1262 if (storage_needed > 0)
1263 {
1264 symbol_table = (asymbol **) xmalloc (storage_needed);
1265 make_cleanup (xfree, symbol_table);
1266 symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
1267
1268 if (symcount < 0)
c50c785c
JM
1269 error (_("Can't read symbols from %s: %s"),
1270 bfd_get_filename (objfile->obfd),
5796c8dc
SS
1271 bfd_errmsg (bfd_get_error ()));
1272
cf7f2e2d 1273 elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
5796c8dc
SS
1274 }
1275
1276 /* Add the dynamic symbols. */
1277
1278 storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
1279
1280 if (storage_needed > 0)
1281 {
c50c785c
JM
1282 /* Memory gets permanently referenced from ABFD after
1283 bfd_get_synthetic_symtab so it must not get freed before ABFD gets.
1284 It happens only in the case when elf_slurp_reloc_table sees
1285 asection->relocation NULL. Determining which section is asection is
1286 done by _bfd_elf_get_synthetic_symtab which is all a bfd
1287 implementation detail, though. */
1288
1289 dyn_symbol_table = bfd_alloc (abfd, storage_needed);
5796c8dc
SS
1290 dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
1291 dyn_symbol_table);
1292
1293 if (dynsymcount < 0)
c50c785c
JM
1294 error (_("Can't read symbols from %s: %s"),
1295 bfd_get_filename (objfile->obfd),
5796c8dc
SS
1296 bfd_errmsg (bfd_get_error ()));
1297
cf7f2e2d 1298 elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
c50c785c
JM
1299
1300 elf_rel_plt_read (objfile, dyn_symbol_table);
5796c8dc
SS
1301 }
1302
a45ae5f8
JM
1303 /* Contrary to binutils --strip-debug/--only-keep-debug the strip command from
1304 elfutils (eu-strip) moves even the .symtab section into the .debug file.
1305
1306 bfd_get_synthetic_symtab on ppc64 for each function descriptor ELF symbol
1307 'name' creates a new BSF_SYNTHETIC ELF symbol '.name' with its code
1308 address. But with eu-strip files bfd_get_synthetic_symtab would fail to
1309 read the code address from .opd while it reads the .symtab section from
1310 a separate debug info file as the .opd section is SHT_NOBITS there.
1311
1312 With SYNTH_ABFD the .opd section will be read from the original
1313 backlinked binary where it is valid. */
1314
1315 if (objfile->separate_debug_objfile_backlink)
1316 synth_abfd = objfile->separate_debug_objfile_backlink->obfd;
1317 else
1318 synth_abfd = abfd;
1319
5796c8dc
SS
1320 /* Add synthetic symbols - for instance, names for any PLT entries. */
1321
a45ae5f8 1322 synthcount = bfd_get_synthetic_symtab (synth_abfd, symcount, symbol_table,
5796c8dc
SS
1323 dynsymcount, dyn_symbol_table,
1324 &synthsyms);
1325 if (synthcount > 0)
1326 {
1327 asymbol **synth_symbol_table;
1328 long i;
1329
1330 make_cleanup (xfree, synthsyms);
1331 synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
1332 for (i = 0; i < synthcount; i++)
1333 synth_symbol_table[i] = synthsyms + i;
1334 make_cleanup (xfree, synth_symbol_table);
c50c785c
JM
1335 elf_symtab_read (objfile, ST_SYNTHETIC, synthcount,
1336 synth_symbol_table, 1);
5796c8dc
SS
1337 }
1338
1339 /* Install any minimal symbols that have been collected as the current
1340 minimal symbols for this objfile. The debug readers below this point
1341 should not generate new minimal symbols; if they do it's their
1342 responsibility to install them. "mdebug" appears to be the only one
1343 which will do this. */
1344
1345 install_minimal_symbols (objfile);
1346 do_cleanups (back_to);
1347
1348 /* Now process debugging information, which is contained in
c50c785c 1349 special ELF sections. */
5796c8dc 1350
c50c785c 1351 /* We first have to find them... */
5796c8dc
SS
1352 bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
1353
1354 /* ELF debugging information is inserted into the psymtab in the
1355 order of least informative first - most informative last. Since
1356 the psymtab table is searched `most recent insertion first' this
1357 increases the probability that more detailed debug information
1358 for a section is found.
1359
1360 For instance, an object file might contain both .mdebug (XCOFF)
1361 and .debug_info (DWARF2) sections then .mdebug is inserted first
1362 (searched last) and DWARF2 is inserted last (searched first). If
1363 we don't do this then the XCOFF info is found first - for code in
c50c785c 1364 an included file XCOFF info is useless. */
5796c8dc
SS
1365
1366 if (ei.mdebugsect)
1367 {
1368 const struct ecoff_debug_swap *swap;
1369
1370 /* .mdebug section, presumably holding ECOFF debugging
1371 information. */
1372 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1373 if (swap)
1374 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
1375 }
1376 if (ei.stabsect)
1377 {
1378 asection *str_sect;
1379
1380 /* Stab sections have an associated string table that looks like
1381 a separate section. */
1382 str_sect = bfd_get_section_by_name (abfd, ".stabstr");
1383
1384 /* FIXME should probably warn about a stab section without a stabstr. */
1385 if (str_sect)
1386 elfstab_build_psymtabs (objfile,
5796c8dc
SS
1387 ei.stabsect,
1388 str_sect->filepos,
1389 bfd_section_size (abfd, str_sect));
1390 }
c50c785c 1391
ef5ccd6c
JM
1392 if (symtab_create_debug)
1393 fprintf_unfiltered (gdb_stdlog, "Done reading minimal symbols.\n");
1394
a45ae5f8 1395 if (dwarf2_has_info (objfile, NULL))
5796c8dc 1396 {
c50c785c
JM
1397 /* elf_sym_fns_gdb_index cannot handle simultaneous non-DWARF debug
1398 information present in OBJFILE. If there is such debug info present
1399 never use .gdb_index. */
1400
1401 if (!objfile_has_partial_symbols (objfile)
1402 && dwarf2_initialize_objfile (objfile))
1403 objfile->sf = &elf_sym_fns_gdb_index;
1404 else
1405 {
1406 /* It is ok to do this even if the stabs reader made some
1407 partial symbols, because OBJF_PSYMTABS_READ has not been
1408 set, and so our lazy reader function will still be called
1409 when needed. */
1410 objfile->sf = &elf_sym_fns_lazy_psyms;
1411 }
5796c8dc 1412 }
c50c785c
JM
1413 /* If the file has its own symbol tables it has no separate debug
1414 info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to
1415 SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with
ef5ccd6c
JM
1416 `.note.gnu.build-id'.
1417
1418 .gnu_debugdata is !objfile_has_partial_symbols because it contains only
1419 .symtab, not .debug_* section. But if we already added .gnu_debugdata as
1420 an objfile via find_separate_debug_file_in_section there was no separate
1421 debug info available. Therefore do not attempt to search for another one,
1422 objfile->separate_debug_objfile->separate_debug_objfile GDB guarantees to
1423 be NULL and we would possibly violate it. */
1424
1425 else if (!objfile_has_partial_symbols (objfile)
1426 && objfile->separate_debug_objfile == NULL
1427 && objfile->separate_debug_objfile_backlink == NULL)
cf7f2e2d
JM
1428 {
1429 char *debugfile;
1430
1431 debugfile = find_separate_debug_file_by_buildid (objfile);
1432
1433 if (debugfile == NULL)
1434 debugfile = find_separate_debug_file_by_debuglink (objfile);
1435
1436 if (debugfile)
1437 {
ef5ccd6c 1438 struct cleanup *cleanup = make_cleanup (xfree, debugfile);
cf7f2e2d
JM
1439 bfd *abfd = symfile_bfd_open (debugfile);
1440
ef5ccd6c 1441 make_cleanup_bfd_unref (abfd);
cf7f2e2d 1442 symbol_file_add_separate (abfd, symfile_flags, objfile);
ef5ccd6c 1443 do_cleanups (cleanup);
cf7f2e2d
JM
1444 }
1445 }
5796c8dc
SS
1446}
1447
c50c785c
JM
1448/* Callback to lazily read psymtabs. */
1449
1450static void
1451read_psyms (struct objfile *objfile)
1452{
a45ae5f8 1453 if (dwarf2_has_info (objfile, NULL))
c50c785c
JM
1454 dwarf2_build_psymtabs (objfile);
1455}
1456
ef5ccd6c
JM
1457/* This cleans up the objfile's dbx symfile info, and the chain of
1458 stab_section_info's, that might be dangling from it. */
5796c8dc
SS
1459
1460static void
1461free_elfinfo (void *objp)
1462{
1463 struct objfile *objfile = (struct objfile *) objp;
ef5ccd6c 1464 struct dbx_symfile_info *dbxinfo = DBX_SYMFILE_INFO (objfile);
5796c8dc
SS
1465 struct stab_section_info *ssi, *nssi;
1466
1467 ssi = dbxinfo->stab_section_info;
1468 while (ssi)
1469 {
1470 nssi = ssi->next;
1471 xfree (ssi);
1472 ssi = nssi;
1473 }
1474
1475 dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */
1476}
1477
1478
1479/* Initialize anything that needs initializing when a completely new symbol
1480 file is specified (not just adding some symbols from another file, e.g. a
1481 shared library).
1482
c50c785c
JM
1483 We reinitialize buildsym, since we may be reading stabs from an ELF
1484 file. */
5796c8dc
SS
1485
1486static void
1487elf_new_init (struct objfile *ignore)
1488{
1489 stabsread_new_init ();
1490 buildsym_new_init ();
1491}
1492
1493/* Perform any local cleanups required when we are done with a particular
1494 objfile. I.E, we are in the process of discarding all symbol information
1495 for an objfile, freeing up all memory held for it, and unlinking the
c50c785c 1496 objfile struct from the global list of known objfiles. */
5796c8dc
SS
1497
1498static void
1499elf_symfile_finish (struct objfile *objfile)
1500{
5796c8dc
SS
1501 dwarf2_free_objfile (objfile);
1502}
1503
1504/* ELF specific initialization routine for reading symbols.
1505
1506 It is passed a pointer to a struct sym_fns which contains, among other
1507 things, the BFD for the file whose symbols are being read, and a slot for
1508 a pointer to "private data" which we can fill with goodies.
1509
1510 For now at least, we have nothing in particular to do, so this function is
c50c785c 1511 just a stub. */
5796c8dc
SS
1512
1513static void
1514elf_symfile_init (struct objfile *objfile)
1515{
1516 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
1517 find this causes a significant slowdown in gdb then we could
1518 set it in the debug symbol readers only when necessary. */
1519 objfile->flags |= OBJF_REORDERED;
1520}
1521
1522/* When handling an ELF file that contains Sun STABS debug info,
1523 some of the debug info is relative to the particular chunk of the
1524 section that was generated in its individual .o file. E.g.
1525 offsets to static variables are relative to the start of the data
1526 segment *for that module before linking*. This information is
1527 painfully squirreled away in the ELF symbol table as local symbols
1528 with wierd names. Go get 'em when needed. */
1529
1530void
1531elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
1532{
c50c785c 1533 const char *filename = pst->filename;
ef5ccd6c 1534 struct dbx_symfile_info *dbx = DBX_SYMFILE_INFO (objfile);
5796c8dc
SS
1535 struct stab_section_info *maybe = dbx->stab_section_info;
1536 struct stab_section_info *questionable = 0;
1537 int i;
5796c8dc
SS
1538
1539 /* The ELF symbol info doesn't include path names, so strip the path
1540 (if any) from the psymtab filename. */
c50c785c 1541 filename = lbasename (filename);
5796c8dc
SS
1542
1543 /* FIXME: This linear search could speed up significantly
1544 if it was chained in the right order to match how we search it,
c50c785c 1545 and if we unchained when we found a match. */
5796c8dc
SS
1546 for (; maybe; maybe = maybe->next)
1547 {
1548 if (filename[0] == maybe->filename[0]
c50c785c 1549 && filename_cmp (filename, maybe->filename) == 0)
5796c8dc
SS
1550 {
1551 /* We found a match. But there might be several source files
1552 (from different directories) with the same name. */
1553 if (0 == maybe->found)
1554 break;
1555 questionable = maybe; /* Might use it later. */
1556 }
1557 }
1558
1559 if (maybe == 0 && questionable != 0)
1560 {
1561 complaint (&symfile_complaints,
c50c785c
JM
1562 _("elf/stab section information questionable for %s"),
1563 filename);
5796c8dc
SS
1564 maybe = questionable;
1565 }
1566
1567 if (maybe)
1568 {
1569 /* Found it! Allocate a new psymtab struct, and fill it in. */
1570 maybe->found++;
1571 pst->section_offsets = (struct section_offsets *)
a45ae5f8 1572 obstack_alloc (&objfile->objfile_obstack,
5796c8dc
SS
1573 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
1574 for (i = 0; i < maybe->num_sections; i++)
1575 (pst->section_offsets)->offsets[i] = maybe->sections[i];
1576 return;
1577 }
1578
1579 /* We were unable to find any offsets for this file. Complain. */
1580 if (dbx->stab_section_info) /* If there *is* any info, */
1581 complaint (&symfile_complaints,
1582 _("elf/stab section information missing for %s"), filename);
1583}
ef5ccd6c
JM
1584
1585/* Implementation of `sym_get_probes', as documented in symfile.h. */
1586
1587static VEC (probe_p) *
1588elf_get_probes (struct objfile *objfile)
1589{
1590 VEC (probe_p) *probes_per_objfile;
1591
1592 /* Have we parsed this objfile's probes already? */
1593 probes_per_objfile = objfile_data (objfile, probe_key);
1594
1595 if (!probes_per_objfile)
1596 {
1597 int ix;
1598 const struct probe_ops *probe_ops;
1599
1600 /* Here we try to gather information about all types of probes from the
1601 objfile. */
1602 for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops);
1603 ix++)
1604 probe_ops->get_probes (&probes_per_objfile, objfile);
1605
1606 if (probes_per_objfile == NULL)
1607 {
1608 VEC_reserve (probe_p, probes_per_objfile, 1);
1609 gdb_assert (probes_per_objfile != NULL);
1610 }
1611
1612 set_objfile_data (objfile, probe_key, probes_per_objfile);
1613 }
1614
1615 return probes_per_objfile;
1616}
1617
1618/* Implementation of `sym_get_probe_argument_count', as documented in
1619 symfile.h. */
1620
1621static unsigned
1622elf_get_probe_argument_count (struct probe *probe)
1623{
1624 return probe->pops->get_probe_argument_count (probe);
1625}
1626
1627/* Implementation of `sym_evaluate_probe_argument', as documented in
1628 symfile.h. */
1629
1630static struct value *
1631elf_evaluate_probe_argument (struct probe *probe, unsigned n)
1632{
1633 return probe->pops->evaluate_probe_argument (probe, n);
1634}
1635
1636/* Implementation of `sym_compile_to_ax', as documented in symfile.h. */
1637
1638static void
1639elf_compile_to_ax (struct probe *probe,
1640 struct agent_expr *expr,
1641 struct axs_value *value,
1642 unsigned n)
1643{
1644 probe->pops->compile_to_ax (probe, expr, value, n);
1645}
1646
1647/* Implementation of `sym_relocate_probe', as documented in symfile.h. */
1648
1649static void
1650elf_symfile_relocate_probe (struct objfile *objfile,
1651 struct section_offsets *new_offsets,
1652 struct section_offsets *delta)
1653{
1654 int ix;
1655 VEC (probe_p) *probes = objfile_data (objfile, probe_key);
1656 struct probe *probe;
1657
1658 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
1659 probe->pops->relocate (probe, ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
1660}
1661
1662/* Helper function used to free the space allocated for storing SystemTap
1663 probe information. */
1664
1665static void
1666probe_key_free (struct objfile *objfile, void *d)
1667{
1668 int ix;
1669 VEC (probe_p) *probes = d;
1670 struct probe *probe;
1671
1672 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
1673 probe->pops->destroy (probe);
1674
1675 VEC_free (probe_p, probes);
1676}
1677
5796c8dc 1678\f
ef5ccd6c
JM
1679
1680/* Implementation `sym_probe_fns', as documented in symfile.h. */
1681
1682static const struct sym_probe_fns elf_probe_fns =
1683{
1684 elf_get_probes, /* sym_get_probes */
1685 elf_get_probe_argument_count, /* sym_get_probe_argument_count */
1686 elf_evaluate_probe_argument, /* sym_evaluate_probe_argument */
1687 elf_compile_to_ax, /* sym_compile_to_ax */
1688 elf_symfile_relocate_probe, /* sym_relocate_probe */
1689};
1690
5796c8dc
SS
1691/* Register that we are able to handle ELF object file formats. */
1692
c50c785c 1693static const struct sym_fns elf_sym_fns =
5796c8dc
SS
1694{
1695 bfd_target_elf_flavour,
c50c785c
JM
1696 elf_new_init, /* init anything gbl to entire symtab */
1697 elf_symfile_init, /* read initial info, setup for sym_read() */
1698 elf_symfile_read, /* read a symbol file into symtab */
1699 NULL, /* sym_read_psymbols */
1700 elf_symfile_finish, /* finished with file, cleanup */
1701 default_symfile_offsets, /* Translate ext. to int. relocation */
1702 elf_symfile_segments, /* Get segment information from a file. */
1703 NULL,
1704 default_symfile_relocate, /* Relocate a debug section. */
ef5ccd6c 1705 &elf_probe_fns, /* sym_probe_fns */
c50c785c
JM
1706 &psym_functions
1707};
1708
1709/* The same as elf_sym_fns, but not registered and lazily reads
1710 psymbols. */
1711
1712static const struct sym_fns elf_sym_fns_lazy_psyms =
1713{
1714 bfd_target_elf_flavour,
1715 elf_new_init, /* init anything gbl to entire symtab */
1716 elf_symfile_init, /* read initial info, setup for sym_read() */
1717 elf_symfile_read, /* read a symbol file into symtab */
1718 read_psyms, /* sym_read_psymbols */
1719 elf_symfile_finish, /* finished with file, cleanup */
1720 default_symfile_offsets, /* Translate ext. to int. relocation */
1721 elf_symfile_segments, /* Get segment information from a file. */
1722 NULL,
1723 default_symfile_relocate, /* Relocate a debug section. */
ef5ccd6c 1724 &elf_probe_fns, /* sym_probe_fns */
c50c785c
JM
1725 &psym_functions
1726};
1727
1728/* The same as elf_sym_fns, but not registered and uses the
1729 DWARF-specific GNU index rather than psymtab. */
1730static const struct sym_fns elf_sym_fns_gdb_index =
1731{
1732 bfd_target_elf_flavour,
1733 elf_new_init, /* init anything gbl to entire symab */
1734 elf_symfile_init, /* read initial info, setup for sym_red() */
1735 elf_symfile_read, /* read a symbol file into symtab */
1736 NULL, /* sym_read_psymbols */
1737 elf_symfile_finish, /* finished with file, cleanup */
1738 default_symfile_offsets, /* Translate ext. to int. relocatin */
1739 elf_symfile_segments, /* Get segment information from a file. */
1740 NULL,
1741 default_symfile_relocate, /* Relocate a debug section. */
ef5ccd6c 1742 &elf_probe_fns, /* sym_probe_fns */
c50c785c
JM
1743 &dwarf2_gdb_index_functions
1744};
1745
1746/* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */
1747
1748static const struct gnu_ifunc_fns elf_gnu_ifunc_fns =
1749{
1750 elf_gnu_ifunc_resolve_addr,
1751 elf_gnu_ifunc_resolve_name,
1752 elf_gnu_ifunc_resolver_stop,
1753 elf_gnu_ifunc_resolver_return_stop
5796c8dc
SS
1754};
1755
1756void
1757_initialize_elfread (void)
1758{
ef5ccd6c 1759 probe_key = register_objfile_data_with_cleanup (NULL, probe_key_free);
5796c8dc 1760 add_symtab_fns (&elf_sym_fns);
c50c785c
JM
1761
1762 elf_objfile_gnu_ifunc_cache_data = register_objfile_data ();
1763 gnu_ifunc_fns_p = &elf_gnu_ifunc_fns;
5796c8dc 1764}