GDB (xrefs)
Loading...
Searching...
No Matches
elfread.c
Go to the documentation of this file.
1/* Read ELF (Executable and Linking Format) object files for GDB.
2
3 Copyright (C) 1991-2023 Free Software Foundation, Inc.
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 "elf-bfd.h"
25#include "elf/common.h"
26#include "elf/internal.h"
27#include "elf/mips.h"
28#include "symtab.h"
29#include "symfile.h"
30#include "objfiles.h"
31#include "stabsread.h"
32#include "demangle.h"
33#include "psympriv.h"
34#include "filenames.h"
35#include "probe.h"
36#include "arch-utils.h"
37#include "gdbtypes.h"
38#include "value.h"
39#include "infcall.h"
40#include "gdbthread.h"
41#include "inferior.h"
42#include "regcache.h"
43#include "bcache.h"
44#include "gdb_bfd.h"
45#include "build-id.h"
46#include "location.h"
47#include "auxv.h"
48#include "mdebugread.h"
49#include "ctfread.h"
50#include "gdbsupport/gdb_string_view.h"
51#include "gdbsupport/scoped_fd.h"
52#include "debuginfod-support.h"
53#include "dwarf2/public.h"
54
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 *mdebugsect; /* Section pointer for .mdebug section */
63 asection *ctfsect; /* Section pointer for .ctf section */
64 };
65
66/* Type for per-BFD data. */
67
68typedef std::vector<std::unique_ptr<probe>> elfread_data;
69
70/* Per-BFD data for probe info. */
71
73
74/* Minimal symbols located at the GOT entries for .plt - that is the real
75 pointer where the given entry will jump to. It gets updated by the real
76 function address during lazy ld.so resolving in the inferior. These
77 minimal symbols are indexed for <tab>-completion. */
78
79#define SYMBOL_GOT_PLT_SUFFIX "@got.plt"
80
81/* Locate the segments in ABFD. */
82
85{
86 Elf_Internal_Phdr *phdrs, **segments;
87 long phdrs_size;
88 int num_phdrs, num_segments, num_sections, i;
89 asection *sect;
90
91 phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
92 if (phdrs_size == -1)
93 return NULL;
94
95 phdrs = (Elf_Internal_Phdr *) alloca (phdrs_size);
96 num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
97 if (num_phdrs == -1)
98 return NULL;
99
100 num_segments = 0;
101 segments = XALLOCAVEC (Elf_Internal_Phdr *, num_phdrs);
102 for (i = 0; i < num_phdrs; i++)
103 if (phdrs[i].p_type == PT_LOAD)
104 segments[num_segments++] = &phdrs[i];
105
106 if (num_segments == 0)
107 return NULL;
108
110 data->segments.reserve (num_segments);
111
112 for (i = 0; i < num_segments; i++)
113 data->segments.emplace_back (segments[i]->p_vaddr, segments[i]->p_memsz);
114
115 num_sections = bfd_count_sections (abfd);
116
117 /* All elements are initialized to 0 (map to no segment). */
118 data->segment_info.resize (num_sections);
119
120 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
121 {
122 int j;
123
124 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
125 continue;
126
127 Elf_Internal_Shdr *this_hdr = &elf_section_data (sect)->this_hdr;
128
129 for (j = 0; j < num_segments; j++)
130 if (ELF_SECTION_IN_SEGMENT (this_hdr, segments[j]))
131 {
132 data->segment_info[i] = j + 1;
133 break;
134 }
135
136 /* We should have found a segment for every non-empty section.
137 If we haven't, we will not relocate this section by any
138 offsets we apply to the segments. As an exception, do not
139 warn about SHT_NOBITS sections; in normal ELF execution
140 environments, SHT_NOBITS means zero-initialized and belongs
141 in a segment, but in no-OS environments some tools (e.g. ARM
142 RealView) use SHT_NOBITS for uninitialized data. Since it is
143 uninitialized, it doesn't need a program header. Such
144 binaries are not relocatable. */
145
146 /* Exclude debuginfo files from this warning, too, since those
147 are often not strictly compliant with the standard. See, e.g.,
148 ld/24717 for more discussion. */
149 if (!is_debuginfo_file (abfd)
150 && bfd_section_size (sect) > 0 && j == num_segments
151 && (bfd_section_flags (sect) & SEC_LOAD) != 0)
152 warning (_("Loadable section \"%s\" outside of ELF segments\n in %s"),
153 bfd_section_name (sect), bfd_get_filename (abfd));
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
175 section flags to specify what kind of debug section it is.
176 -kingdon). */
177
178static void
179elf_locate_sections (asection *sectp, struct elfinfo *ei)
180{
181 if (strcmp (sectp->name, ".stab") == 0)
182 {
183 ei->stabsect = sectp;
184 }
185 else if (strcmp (sectp->name, ".mdebug") == 0)
186 {
187 ei->mdebugsect = sectp;
188 }
189 else if (strcmp (sectp->name, ".ctf") == 0)
190 {
191 ei->ctfsect = sectp;
192 }
193}
194
195static struct minimal_symbol *
197 gdb::string_view name, bool copy_name,
198 CORE_ADDR address,
199 enum minimal_symbol_type ms_type,
200 asection *bfd_section, struct objfile *objfile)
201{
202 struct gdbarch *gdbarch = objfile->arch ();
203
204 if (ms_type == mst_text || ms_type == mst_file_text
205 || ms_type == mst_text_gnu_ifunc)
206 address = gdbarch_addr_bits_remove (gdbarch, address);
207
208 /* We only setup section information for allocatable sections. Usually
209 we'd only expect to find msymbols for allocatable sections, but if the
210 ELF is malformed then this might not be the case. In that case don't
211 create an msymbol that references an uninitialised section object. */
212 int section_index = 0;
213 if ((bfd_section_flags (bfd_section) & SEC_ALLOC) == SEC_ALLOC)
214 section_index = gdb_bfd_section_index (objfile->obfd.get (), bfd_section);
215
216 struct minimal_symbol *result
217 = reader.record_full (name, copy_name, address, ms_type, section_index);
218 if ((objfile->flags & OBJF_MAINLINE) == 0
219 && (ms_type == mst_data || ms_type == mst_bss))
220 result->maybe_copied = 1;
221
222 return result;
223}
224
225/* Read the symbol table of an ELF file.
226
227 Given an objfile, a symbol table, and a flag indicating whether the
228 symbol table contains regular, dynamic, or synthetic symbols, add all
229 the global function and data symbols to the minimal symbol table.
230
231 In stabs-in-ELF, as implemented by Sun, there are some local symbols
232 defined in the ELF symbol table, which can be used to locate
233 the beginnings of sections from each ".o" file that was linked to
234 form the executable objfile. We gather any such info and record it
235 in data structures hung off the objfile's private data. */
236
237#define ST_REGULAR 0
238#define ST_DYNAMIC 1
239#define ST_SYNTHETIC 2
240
241static void
243 struct objfile *objfile, int type,
244 long number_of_symbols, asymbol **symbol_table,
245 bool copy_names)
246{
247 struct gdbarch *gdbarch = objfile->arch ();
248 asymbol *sym;
249 long i;
250 CORE_ADDR symaddr;
251 enum minimal_symbol_type ms_type;
252 /* Name of the last file symbol. This is either a constant string or is
253 saved on the objfile's filename cache. */
254 const char *filesymname = "";
255 int stripped = (bfd_get_symcount (objfile->obfd.get ()) == 0);
256 int elf_make_msymbol_special_p
258
259 for (i = 0; i < number_of_symbols; i++)
260 {
261 sym = symbol_table[i];
262 if (sym->name == NULL || *sym->name == '\0')
263 {
264 /* Skip names that don't exist (shouldn't happen), or names
265 that are null strings (may happen). */
266 continue;
267 }
268
269 elf_symbol_type *elf_sym = (elf_symbol_type *) sym;
270
271 /* Skip "special" symbols, e.g. ARM mapping symbols. These are
272 symbols which do not correspond to objects in the symbol table,
273 but have some other target-specific meaning. */
274 if (bfd_is_target_special_symbol (objfile->obfd.get (), sym))
275 {
278 continue;
279 }
280
281 if (type == ST_DYNAMIC
282 && sym->section == bfd_und_section_ptr
283 && (sym->flags & BSF_FUNCTION))
284 {
285 struct minimal_symbol *msym;
286 bfd *abfd = objfile->obfd.get ();
287 asection *sect;
288
289 /* Symbol is a reference to a function defined in
290 a shared library.
291 If its value is non zero then it is usually the address
292 of the corresponding entry in the procedure linkage table,
293 plus the desired section offset.
294 If its value is zero then the dynamic linker has to resolve
295 the symbol. We are unable to find any meaningful address
296 for this symbol in the executable file, so we skip it. */
297 symaddr = sym->value;
298 if (symaddr == 0)
299 continue;
300
301 /* sym->section is the undefined section. However, we want to
302 record the section where the PLT stub resides with the
303 minimal symbol. Search the section table for the one that
304 covers the stub's address. */
305 for (sect = abfd->sections; sect != NULL; sect = sect->next)
306 {
307 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0)
308 continue;
309
310 if (symaddr >= bfd_section_vma (sect)
311 && symaddr < bfd_section_vma (sect)
312 + bfd_section_size (sect))
313 break;
314 }
315 if (!sect)
316 continue;
317
318 /* On ia64-hpux, we have discovered that the system linker
319 adds undefined symbols with nonzero addresses that cannot
320 be right (their address points inside the code of another
321 function in the .text section). This creates problems
322 when trying to determine which symbol corresponds to
323 a given address.
324
325 We try to detect those buggy symbols by checking which
326 section we think they correspond to. Normally, PLT symbols
327 are stored inside their own section, and the typical name
328 for that section is ".plt". So, if there is a ".plt"
329 section, and yet the section name of our symbol does not
330 start with ".plt", we ignore that symbol. */
331 if (!startswith (sect->name, ".plt")
332 && bfd_get_section_by_name (abfd, ".plt") != NULL)
333 continue;
334
336 (reader, sym->name, copy_names,
337 symaddr, mst_solib_trampoline, sect, objfile);
338 if (msym != NULL)
339 {
340 msym->filename = filesymname;
341 if (elf_make_msymbol_special_p)
343 }
344 continue;
345 }
346
347 /* If it is a nonstripped executable, do not enter dynamic
348 symbols, as the dynamic symbol table is usually a subset
349 of the main symbol table. */
350 if (type == ST_DYNAMIC && !stripped)
351 continue;
352 if (sym->flags & BSF_FILE)
353 filesymname = objfile->intern (sym->name);
354 else if (sym->flags & BSF_SECTION_SYM)
355 continue;
356 else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK
357 | BSF_GNU_UNIQUE))
358 {
359 struct minimal_symbol *msym;
360
361 /* Select global/local/weak symbols. Note that bfd puts abs
362 symbols in their own section, so all symbols we are
363 interested in will have a section. */
364 /* Bfd symbols are section relative. */
365 symaddr = sym->value + sym->section->vma;
366 /* For non-absolute symbols, use the type of the section
367 they are relative to, to intuit text/data. Bfd provides
368 no way of figuring this out for absolute symbols. */
369 if (sym->section == bfd_abs_section_ptr)
370 {
371 /* This is a hack to get the minimal symbol type
372 right for Irix 5, which has absolute addresses
373 with special section indices for dynamic symbols.
374
375 NOTE: uweigand-20071112: Synthetic symbols do not
376 have an ELF-private part, so do not touch those. */
377 unsigned int shndx = type == ST_SYNTHETIC ? 0 :
378 elf_sym->internal_elf_sym.st_shndx;
379
380 switch (shndx)
381 {
382 case SHN_MIPS_TEXT:
383 ms_type = mst_text;
384 break;
385 case SHN_MIPS_DATA:
386 ms_type = mst_data;
387 break;
388 case SHN_MIPS_ACOMMON:
389 ms_type = mst_bss;
390 break;
391 default:
392 ms_type = mst_abs;
393 }
394
395 /* If it is an Irix dynamic symbol, skip section name
396 symbols, relocate all others by section offset. */
397 if (ms_type != mst_abs)
398 {
399 if (sym->name[0] == '.')
400 continue;
401 }
402 }
403 else if (sym->section->flags & SEC_CODE)
404 {
405 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE))
406 {
407 if (sym->flags & BSF_GNU_INDIRECT_FUNCTION)
408 ms_type = mst_text_gnu_ifunc;
409 else
410 ms_type = mst_text;
411 }
412 /* The BSF_SYNTHETIC check is there to omit ppc64 function
413 descriptors mistaken for static functions starting with 'L'.
414 */
415 else if ((sym->name[0] == '.' && sym->name[1] == 'L'
416 && (sym->flags & BSF_SYNTHETIC) == 0)
417 || ((sym->flags & BSF_LOCAL)
418 && sym->name[0] == '$'
419 && sym->name[1] == 'L'))
420 /* Looks like a compiler-generated label. Skip
421 it. The assembler should be skipping these (to
422 keep executables small), but apparently with
423 gcc on the (deleted) delta m88k SVR4, it loses.
424 So to have us check too should be harmless (but
425 I encourage people to fix this in the assembler
426 instead of adding checks here). */
427 continue;
428 else
429 {
430 ms_type = mst_file_text;
431 }
432 }
433 else if (sym->section->flags & SEC_ALLOC)
434 {
435 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE))
436 {
437 if (sym->flags & BSF_GNU_INDIRECT_FUNCTION)
438 {
439 ms_type = mst_data_gnu_ifunc;
440 }
441 else if (sym->section->flags & SEC_LOAD)
442 {
443 ms_type = mst_data;
444 }
445 else
446 {
447 ms_type = mst_bss;
448 }
449 }
450 else if (sym->flags & BSF_LOCAL)
451 {
452 if (sym->section->flags & SEC_LOAD)
453 {
454 ms_type = mst_file_data;
455 }
456 else
457 {
458 ms_type = mst_file_bss;
459 }
460 }
461 else
462 {
463 ms_type = mst_unknown;
464 }
465 }
466 else
467 {
468 /* FIXME: Solaris2 shared libraries include lots of
469 odd "absolute" and "undefined" symbols, that play
470 hob with actions like finding what function the PC
471 is in. Ignore them if they aren't text, data, or bss. */
472 /* ms_type = mst_unknown; */
473 continue; /* Skip this symbol. */
474 }
476 (reader, sym->name, copy_names, symaddr,
477 ms_type, sym->section, objfile);
478
479 if (msym)
480 {
481 /* NOTE: uweigand-20071112: A synthetic symbol does not have an
482 ELF-private part. */
483 if (type != ST_SYNTHETIC)
484 {
485 /* Pass symbol size field in via BFD. FIXME!!! */
486 msym->set_size (elf_sym->internal_elf_sym.st_size);
487 }
488
489 msym->filename = filesymname;
490 if (elf_make_msymbol_special_p)
492 }
493
494 /* If we see a default versioned symbol, install it under
495 its version-less name. */
496 if (msym != NULL)
497 {
498 const char *atsign = strchr (sym->name, '@');
499 bool is_at_symbol = atsign != nullptr && atsign > sym->name;
500 bool is_plt = is_at_symbol && strcmp (atsign, "@plt") == 0;
501 int len = is_at_symbol ? atsign - sym->name : 0;
502
503 if (is_at_symbol
504 && !is_plt
505 && (elf_sym->version & VERSYM_HIDDEN) == 0)
506 record_minimal_symbol (reader,
507 gdb::string_view (sym->name, len),
508 true, symaddr, ms_type, sym->section,
509 objfile);
510 else if (is_plt)
511 {
512 /* For @plt symbols, also record a trampoline to the
513 destination symbol. The @plt symbol will be used
514 in disassembly, and the trampoline will be used
515 when we are trying to find the target. */
516 if (ms_type == mst_text && type == ST_SYNTHETIC)
517 {
518 struct minimal_symbol *mtramp;
519
520 mtramp = record_minimal_symbol
521 (reader, gdb::string_view (sym->name, len), true,
522 symaddr, mst_solib_trampoline, sym->section, objfile);
523 if (mtramp)
524 {
525 mtramp->set_size (msym->size());
526 mtramp->created_by_gdb = 1;
527 mtramp->filename = filesymname;
528 if (elf_make_msymbol_special_p)
530 sym, mtramp);
531 }
532 }
533 }
534 }
535 }
536 }
537}
538
539/* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX)
540 for later look ups of which function to call when user requests
541 a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target
542 library defining `function' we cannot yet know while reading OBJFILE which
543 of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later
544 DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */
545
546static void
548 struct objfile *objfile, asymbol **dyn_symbol_table)
549{
550 bfd *obfd = objfile->obfd.get ();
551 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
552 asection *relplt, *got_plt;
553 bfd_size_type reloc_count, reloc;
554 struct gdbarch *gdbarch = objfile->arch ();
555 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
556 size_t ptr_size = ptr_type->length ();
557
559 return;
560
561 got_plt = bfd_get_section_by_name (obfd, ".got.plt");
562 if (got_plt == NULL)
563 {
564 /* For platforms where there is no separate .got.plt. */
565 got_plt = bfd_get_section_by_name (obfd, ".got");
566 if (got_plt == NULL)
567 return;
568 }
569
570 /* Depending on system, we may find jump slots in a relocation
571 section for either .got.plt or .plt. */
572 asection *plt = bfd_get_section_by_name (obfd, ".plt");
573 int plt_elf_idx = (plt != NULL) ? elf_section_data (plt)->this_idx : -1;
574
575 int got_plt_elf_idx = elf_section_data (got_plt)->this_idx;
576
577 /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */
578 for (relplt = obfd->sections; relplt != NULL; relplt = relplt->next)
579 {
580 const auto &this_hdr = elf_section_data (relplt)->this_hdr;
581
582 if (this_hdr.sh_type == SHT_REL || this_hdr.sh_type == SHT_RELA)
583 {
584 if (this_hdr.sh_info == plt_elf_idx
585 || this_hdr.sh_info == got_plt_elf_idx)
586 break;
587 }
588 }
589 if (relplt == NULL)
590 return;
591
592 if (! bed->s->slurp_reloc_table (obfd, relplt, dyn_symbol_table, TRUE))
593 return;
594
595 std::string string_buffer;
596
597 /* Does ADDRESS reside in SECTION of OBFD? */
598 auto within_section = [obfd] (asection *section, CORE_ADDR address)
599 {
600 if (section == NULL)
601 return false;
602
603 return (bfd_section_vma (section) <= address
604 && (address < bfd_section_vma (section)
605 + bfd_section_size (section)));
606 };
607
608 reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize;
609 for (reloc = 0; reloc < reloc_count; reloc++)
610 {
611 const char *name;
612 struct minimal_symbol *msym;
613 CORE_ADDR address;
614 const char *got_suffix = SYMBOL_GOT_PLT_SUFFIX;
615 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
616
617 name = bfd_asymbol_name (*relplt->relocation[reloc].sym_ptr_ptr);
618 address = relplt->relocation[reloc].address;
619
620 asection *msym_section;
621
622 /* Does the pointer reside in either the .got.plt or .plt
623 sections? */
624 if (within_section (got_plt, address))
625 msym_section = got_plt;
626 else if (within_section (plt, address))
627 msym_section = plt;
628 else
629 continue;
630
631 /* We cannot check if NAME is a reference to
632 mst_text_gnu_ifunc/mst_data_gnu_ifunc as in OBJFILE the
633 symbol is undefined and the objfile having NAME defined may
634 not yet have been loaded. */
635
636 string_buffer.assign (name);
637 string_buffer.append (got_suffix, got_suffix + got_suffix_len);
638
639 msym = record_minimal_symbol (reader, string_buffer,
641 msym_section, objfile);
642 if (msym)
643 msym->set_size (ptr_size);
644 }
645}
646
647/* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */
648
649static const registry<objfile>::key<htab, htab_deleter>
651
652/* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */
653
655{
656 /* This is always a function entry address, not a function descriptor. */
657 CORE_ADDR addr;
658
659 char name[1];
660};
661
662/* htab_hash for elf_objfile_gnu_ifunc_cache_data. */
663
664static hashval_t
665elf_gnu_ifunc_cache_hash (const void *a_voidp)
666{
667 const struct elf_gnu_ifunc_cache *a
668 = (const struct elf_gnu_ifunc_cache *) a_voidp;
669
670 return htab_hash_string (a->name);
671}
672
673/* htab_eq for elf_objfile_gnu_ifunc_cache_data. */
674
675static int
676elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp)
677{
678 const struct elf_gnu_ifunc_cache *a
679 = (const struct elf_gnu_ifunc_cache *) a_voidp;
680 const struct elf_gnu_ifunc_cache *b
681 = (const struct elf_gnu_ifunc_cache *) b_voidp;
682
683 return strcmp (a->name, b->name) == 0;
684}
685
686/* Record the target function address of a STT_GNU_IFUNC function NAME is the
687 function entry address ADDR. Return 1 if NAME and ADDR are considered as
688 valid and therefore they were successfully recorded, return 0 otherwise.
689
690 Function does not expect a duplicate entry. Use
691 elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already
692 exists. */
693
694static int
695elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
696{
697 struct bound_minimal_symbol msym;
698 struct objfile *objfile;
699 htab_t htab;
700 struct elf_gnu_ifunc_cache entry_local, *entry_p;
701 void **slot;
702
704 if (msym.minsym == NULL)
705 return 0;
706 if (msym.value_address () != addr)
707 return 0;
708 objfile = msym.objfile;
709
710 /* If .plt jumps back to .plt the symbol is still deferred for later
711 resolution and it has no use for GDB. */
712 const char *target_name = msym.minsym->linkage_name ();
713 size_t len = strlen (target_name);
714
715 /* Note we check the symbol's name instead of checking whether the
716 symbol is in the .plt section because some systems have @plt
717 symbols in the .text section. */
718 if (len > 4 && strcmp (target_name + len - 4, "@plt") == 0)
719 return 0;
720
722 if (htab == NULL)
723 {
724 htab = htab_create_alloc (1, elf_gnu_ifunc_cache_hash,
726 NULL, xcalloc, xfree);
728 }
729
730 entry_local.addr = addr;
731 obstack_grow (&objfile->objfile_obstack, &entry_local,
732 offsetof (struct elf_gnu_ifunc_cache, name));
733 obstack_grow_str0 (&objfile->objfile_obstack, name);
734 entry_p
735 = (struct elf_gnu_ifunc_cache *) obstack_finish (&objfile->objfile_obstack);
736
737 slot = htab_find_slot (htab, entry_p, INSERT);
738 if (*slot != NULL)
739 {
740 struct elf_gnu_ifunc_cache *entry_found_p
741 = (struct elf_gnu_ifunc_cache *) *slot;
742 struct gdbarch *gdbarch = objfile->arch ();
743
744 if (entry_found_p->addr != addr)
745 {
746 /* This case indicates buggy inferior program, the resolved address
747 should never change. */
748
749 warning (_("gnu-indirect-function \"%s\" has changed its resolved "
750 "function_address from %s to %s"),
751 name, paddress (gdbarch, entry_found_p->addr),
752 paddress (gdbarch, addr));
753 }
754
755 /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */
756 }
757 *slot = entry_p;
758
759 return 1;
760}
761
762/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
763 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
764 is not NULL) and the function returns 1. It returns 0 otherwise.
765
766 Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this
767 function. */
768
769static int
770elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p)
771{
772 int found = 0;
773
774 /* FIXME: we only search the initial namespace.
775
776 To search other namespaces, we would need to provide context, e.g. in
777 form of an objfile in that namespace. */
779 (target_gdbarch (),
780 [name, &addr_p, &found] (struct objfile *objfile)
781 {
782 htab_t htab;
783 elf_gnu_ifunc_cache *entry_p;
784 void **slot;
785
787 if (htab == NULL)
788 return 0;
789
790 entry_p = ((elf_gnu_ifunc_cache *)
791 alloca (sizeof (*entry_p) + strlen (name)));
792 strcpy (entry_p->name, name);
793
794 slot = htab_find_slot (htab, entry_p, NO_INSERT);
795 if (slot == NULL)
796 return 0;
797 entry_p = (elf_gnu_ifunc_cache *) *slot;
798 gdb_assert (entry_p != NULL);
799
800 if (addr_p)
801 *addr_p = entry_p->addr;
802
803 found = 1;
804 return 1;
805 }, nullptr);
806
807 return found;
808}
809
810/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
811 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
812 is not NULL) and the function returns 1. It returns 0 otherwise.
813
814 Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function.
815 elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to
816 prevent cache entries duplicates. */
817
818static int
819elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p)
820{
821 char *name_got_plt;
822 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
823 int found = 0;
824
825 name_got_plt = (char *) alloca (strlen (name) + got_suffix_len + 1);
826 sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name);
827
828 /* FIXME: we only search the initial namespace.
829
830 To search other namespaces, we would need to provide context, e.g. in
831 form of an objfile in that namespace. */
833 (target_gdbarch (),
834 [name, name_got_plt, &addr_p, &found] (struct objfile *objfile)
835 {
836 bfd *obfd = objfile->obfd.get ();
837 struct gdbarch *gdbarch = objfile->arch ();
839 size_t ptr_size = ptr_type->length ();
840 CORE_ADDR pointer_address, addr;
841 asection *plt;
842 gdb_byte *buf = (gdb_byte *) alloca (ptr_size);
844
845 msym = lookup_minimal_symbol (name_got_plt, NULL, objfile);
846 if (msym.minsym == NULL)
847 return 0;
848 if (msym.minsym->type () != mst_slot_got_plt)
849 return 0;
850 pointer_address = msym.value_address ();
851
852 plt = bfd_get_section_by_name (obfd, ".plt");
853 if (plt == NULL)
854 return 0;
855
856 if (msym.minsym->size () != ptr_size)
857 return 0;
858 if (target_read_memory (pointer_address, buf, ptr_size) != 0)
859 return 0;
860 addr = extract_typed_address (buf, ptr_type);
862 (gdbarch, addr, current_inferior ()->top_target ());
863 addr = gdbarch_addr_bits_remove (gdbarch, addr);
864
866 {
867 if (addr_p != NULL)
868 *addr_p = addr;
869
870 found = 1;
871 return 1;
872 }
873
874 return 0;
875 }, nullptr);
876
877 return found;
878}
879
880/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
881 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
882 is not NULL) and the function returns true. It returns false otherwise.
883
884 Both the elf_objfile_gnu_ifunc_cache_data hash table and
885 SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */
886
887static bool
888elf_gnu_ifunc_resolve_name (const char *name, CORE_ADDR *addr_p)
889{
891 return true;
892
894 return true;
895
896 return false;
897}
898
899/* Call STT_GNU_IFUNC - a function returning addresss of a real function to
900 call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned
901 is the entry point of the resolved STT_GNU_IFUNC target function to call.
902 */
903
904static CORE_ADDR
906{
907 const char *name_at_pc;
908 CORE_ADDR start_at_pc, address;
909 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
910 struct value *function, *address_val;
911 CORE_ADDR hwcap = 0;
912 struct value *hwcap_val;
913
914 /* Try first any non-intrusive methods without an inferior call. */
915
916 if (find_pc_partial_function (pc, &name_at_pc, &start_at_pc, NULL)
917 && start_at_pc == pc)
918 {
919 if (elf_gnu_ifunc_resolve_name (name_at_pc, &address))
920 return address;
921 }
922 else
923 name_at_pc = NULL;
924
925 function = allocate_value (func_func_type);
926 VALUE_LVAL (function) = lval_memory;
927 set_value_address (function, pc);
928
929 /* STT_GNU_IFUNC resolver functions usually receive the HWCAP vector as
930 parameter. FUNCTION is the function entry address. ADDRESS may be a
931 function descriptor. */
932
933 target_auxv_search (AT_HWCAP, &hwcap);
935 ->builtin_unsigned_long, hwcap);
936 address_val = call_function_by_hand (function, NULL, hwcap_val);
937 address = value_as_address (address_val);
939 (gdbarch, address, current_inferior ()->top_target ());
941
942 if (name_at_pc)
944
945 return address;
946}
947
948/* Handle inferior hit of bp_gnu_ifunc_resolver, see its definition. */
949
950static void
952{
953 struct breakpoint *b_return;
955 struct frame_id prev_frame_id = get_stack_frame_id (prev_frame);
956 CORE_ADDR prev_pc = get_frame_pc (prev_frame);
957 int thread_id = inferior_thread ()->global_num;
958
959 gdb_assert (b->type == bp_gnu_ifunc_resolver);
960
961 for (b_return = b->related_breakpoint; b_return != b;
962 b_return = b_return->related_breakpoint)
963 {
964 gdb_assert (b_return->type == bp_gnu_ifunc_resolver_return);
965 gdb_assert (b_return->loc != NULL && b_return->loc->next == NULL);
966 gdb_assert (frame_id_p (b_return->frame_id));
967
968 if (b_return->thread == thread_id
969 && b_return->loc->requested_address == prev_pc
970 && b_return->frame_id == prev_frame_id)
971 break;
972 }
973
974 if (b_return == b)
975 {
976 /* No need to call find_pc_line for symbols resolving as this is only
977 a helper breakpointer never shown to the user. */
978
979 symtab_and_line sal;
981 sal.pc = prev_pc;
982 sal.section = find_pc_overlay (sal.pc);
983 sal.explicit_pc = 1;
984 b_return
985 = set_momentary_breakpoint (get_frame_arch (prev_frame), sal,
986 prev_frame_id,
988
989 /* set_momentary_breakpoint invalidates PREV_FRAME. */
990 prev_frame = NULL;
991
992 /* Add new b_return to the ring list b->related_breakpoint. */
993 gdb_assert (b_return->related_breakpoint == b_return);
995 b->related_breakpoint = b_return;
996 }
997}
998
999/* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition. */
1000
1001static void
1003{
1004 thread_info *thread = inferior_thread ();
1006 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
1007 struct type *value_type = func_func_type->target_type ();
1008 struct regcache *regcache = get_thread_regcache (thread);
1009 struct value *func_func;
1010 struct value *value;
1011 CORE_ADDR resolved_address, resolved_pc;
1012
1013 gdb_assert (b->type == bp_gnu_ifunc_resolver_return);
1014
1015 while (b->related_breakpoint != b)
1016 {
1017 struct breakpoint *b_next = b->related_breakpoint;
1018
1019 switch (b->type)
1020 {
1022 break;
1025 break;
1026 default:
1027 internal_error (_("handle_inferior_event: Invalid "
1028 "gnu-indirect-function breakpoint type %d"),
1029 (int) b->type);
1030 }
1031 b = (code_breakpoint *) b_next;
1032 }
1033 gdb_assert (b->type == bp_gnu_ifunc_resolver);
1034 gdb_assert (b->loc->next == NULL);
1035
1036 func_func = allocate_value (func_func_type);
1037 VALUE_LVAL (func_func) = lval_memory;
1038 set_value_address (func_func, b->loc->related_address);
1039
1042 value_contents_raw (value).data (), NULL);
1043 resolved_address = value_as_address (value);
1045 (gdbarch, resolved_address, current_inferior ()->top_target ());
1046 resolved_pc = gdbarch_addr_bits_remove (gdbarch, resolved_pc);
1047
1048 gdb_assert (current_program_space == b->pspace || b->pspace == NULL);
1049 elf_gnu_ifunc_record_cache (b->locspec->to_string (), resolved_pc);
1050
1051 b->type = bp_breakpoint;
1053 find_function_start_sal (resolved_pc, NULL, true),
1054 {});
1055}
1056
1057/* A helper function for elf_symfile_read that reads the minimal
1058 symbols. */
1059
1060static void
1061elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags,
1062 const struct elfinfo *ei)
1063{
1064 bfd *synth_abfd, *abfd = objfile->obfd.get ();
1065 long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
1066 asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
1067 asymbol *synthsyms;
1068
1069 symtab_create_debug_printf ("reading minimal symbols of objfile %s",
1071
1072 /* If we already have minsyms, then we can skip some work here.
1073 However, if there were stabs or mdebug sections, we go ahead and
1074 redo all the work anyway, because the psym readers for those
1075 kinds of debuginfo need extra information found here. This can
1076 go away once all types of symbols are in the per-BFD object. */
1078 && ei->stabsect == NULL
1079 && ei->mdebugsect == NULL
1080 && ei->ctfsect == NULL)
1081 {
1082 symtab_create_debug_printf ("minimal symbols were previously read");
1083 return;
1084 }
1085
1087
1088 /* Process the normal ELF symbol table first. */
1089
1090 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd.get ());
1091 if (storage_needed < 0)
1092 error (_("Can't read symbols from %s: %s"),
1093 bfd_get_filename (objfile->obfd.get ()),
1094 bfd_errmsg (bfd_get_error ()));
1095
1096 if (storage_needed > 0)
1097 {
1098 /* Memory gets permanently referenced from ABFD after
1099 bfd_canonicalize_symtab so it must not get freed before ABFD gets. */
1100
1101 symbol_table = (asymbol **) bfd_alloc (abfd, storage_needed);
1102 symcount = bfd_canonicalize_symtab (objfile->obfd.get (), symbol_table);
1103
1104 if (symcount < 0)
1105 error (_("Can't read symbols from %s: %s"),
1106 bfd_get_filename (objfile->obfd.get ()),
1107 bfd_errmsg (bfd_get_error ()));
1108
1109 elf_symtab_read (reader, objfile, ST_REGULAR, symcount, symbol_table,
1110 false);
1111 }
1112
1113 /* Add the dynamic symbols. */
1114
1115 storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd.get ());
1116
1117 if (storage_needed > 0)
1118 {
1119 /* Memory gets permanently referenced from ABFD after
1120 bfd_get_synthetic_symtab so it must not get freed before ABFD gets.
1121 It happens only in the case when elf_slurp_reloc_table sees
1122 asection->relocation NULL. Determining which section is asection is
1123 done by _bfd_elf_get_synthetic_symtab which is all a bfd
1124 implementation detail, though. */
1125
1126 dyn_symbol_table = (asymbol **) bfd_alloc (abfd, storage_needed);
1127 dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd.get (),
1128 dyn_symbol_table);
1129
1130 if (dynsymcount < 0)
1131 error (_("Can't read symbols from %s: %s"),
1132 bfd_get_filename (objfile->obfd.get ()),
1133 bfd_errmsg (bfd_get_error ()));
1134
1135 elf_symtab_read (reader, objfile, ST_DYNAMIC, dynsymcount,
1136 dyn_symbol_table, false);
1137
1138 elf_rel_plt_read (reader, objfile, dyn_symbol_table);
1139 }
1140
1141 /* Contrary to binutils --strip-debug/--only-keep-debug the strip command from
1142 elfutils (eu-strip) moves even the .symtab section into the .debug file.
1143
1144 bfd_get_synthetic_symtab on ppc64 for each function descriptor ELF symbol
1145 'name' creates a new BSF_SYNTHETIC ELF symbol '.name' with its code
1146 address. But with eu-strip files bfd_get_synthetic_symtab would fail to
1147 read the code address from .opd while it reads the .symtab section from
1148 a separate debug info file as the .opd section is SHT_NOBITS there.
1149
1150 With SYNTH_ABFD the .opd section will be read from the original
1151 backlinked binary where it is valid. */
1152
1154 synth_abfd = objfile->separate_debug_objfile_backlink->obfd.get ();
1155 else
1156 synth_abfd = abfd;
1157
1158 /* Add synthetic symbols - for instance, names for any PLT entries. */
1159
1160 synthcount = bfd_get_synthetic_symtab (synth_abfd, symcount, symbol_table,
1161 dynsymcount, dyn_symbol_table,
1162 &synthsyms);
1163 if (synthcount > 0)
1164 {
1165 long i;
1166
1167 std::unique_ptr<asymbol *[]>
1168 synth_symbol_table (new asymbol *[synthcount]);
1169 for (i = 0; i < synthcount; i++)
1170 synth_symbol_table[i] = synthsyms + i;
1171 elf_symtab_read (reader, objfile, ST_SYNTHETIC, synthcount,
1172 synth_symbol_table.get (), true);
1173
1174 xfree (synthsyms);
1175 synthsyms = NULL;
1176 }
1177
1178 /* Install any minimal symbols that have been collected as the current
1179 minimal symbols for this objfile. The debug readers below this point
1180 should not generate new minimal symbols; if they do it's their
1181 responsibility to install them. "mdebug" appears to be the only one
1182 which will do this. */
1183
1184 reader.install ();
1185
1186 symtab_create_debug_printf ("done reading minimal symbols");
1187}
1188
1189/* Dwarf-specific helper for elf_symfile_read. Return true if we managed to
1190 load dwarf debug info. */
1191
1192static bool
1194 symfile_add_flags symfile_flags)
1195{
1196 bool has_dwarf2 = true;
1197
1198 if (dwarf2_has_info (objfile, NULL, true))
1200 /* If the file has its own symbol tables it has no separate debug
1201 info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to
1202 SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with
1203 `.note.gnu.build-id'.
1204
1205 .gnu_debugdata is !objfile::has_partial_symbols because it contains only
1206 .symtab, not .debug_* section. But if we already added .gnu_debugdata as
1207 an objfile via find_separate_debug_file_in_section there was no separate
1208 debug info available. Therefore do not attempt to search for another one,
1209 objfile->separate_debug_objfile->separate_debug_objfile GDB guarantees to
1210 be NULL and we would possibly violate it. */
1211
1212 else if (!objfile->has_partial_symbols ()
1215 {
1216 std::string debugfile = find_separate_debug_file_by_buildid (objfile);
1217
1218 if (debugfile.empty ())
1220
1221 if (!debugfile.empty ())
1222 {
1223 gdb_bfd_ref_ptr debug_bfd (symfile_bfd_open (debugfile.c_str ()));
1224
1225 symbol_file_add_separate (debug_bfd, debugfile.c_str (),
1226 symfile_flags, objfile);
1227 }
1228 else
1229 {
1230 has_dwarf2 = false;
1231 const struct bfd_build_id *build_id
1232 = build_id_bfd_get (objfile->obfd.get ());
1233 const char *filename = bfd_get_filename (objfile->obfd.get ());
1234
1235 if (build_id != nullptr)
1236 {
1237 gdb::unique_xmalloc_ptr<char> symfile_path;
1238 scoped_fd fd (debuginfod_debuginfo_query (build_id->data,
1239 build_id->size,
1240 filename,
1241 &symfile_path));
1242
1243 if (fd.get () >= 0)
1244 {
1245 /* File successfully retrieved from server. */
1246 gdb_bfd_ref_ptr debug_bfd (symfile_bfd_open (symfile_path.get ()));
1247
1248 if (debug_bfd == nullptr)
1249 warning (_("File \"%s\" from debuginfod cannot be opened as bfd"),
1250 filename);
1251 else if (build_id_verify (debug_bfd.get (), build_id->size,
1252 build_id->data))
1253 {
1254 symbol_file_add_separate (debug_bfd, symfile_path.get (),
1255 symfile_flags, objfile);
1256 has_dwarf2 = true;
1257 }
1258 }
1259 }
1260 }
1261 }
1262
1263 return has_dwarf2;
1264}
1265
1266/* Scan and build partial symbols for a symbol file.
1267 We have been initialized by a call to elf_symfile_init, which
1268 currently does nothing.
1269
1270 This function only does the minimum work necessary for letting the
1271 user "name" things symbolically; it does not read the entire symtab.
1272 Instead, it reads the external and static symbols and puts them in partial
1273 symbol tables. When more extensive information is requested of a
1274 file, the corresponding partial symbol table is mutated into a full
1275 fledged symbol table by going back and reading the symbols
1276 for real.
1277
1278 We look for sections with specific names, to tell us what debug
1279 format to look for: FIXME!!!
1280
1281 elfstab_build_psymtabs() handles STABS symbols;
1282 mdebug_build_psymtabs() handles ECOFF debugging information.
1283
1284 Note that ELF files have a "minimal" symbol table, which looks a lot
1285 like a COFF symbol table, but has only the minimal information necessary
1286 for linking. We process this also, and use the information to
1287 build gdb's minimal symbol table. This gives us some minimal debugging
1288 capability even for files compiled without -g. */
1289
1290static void
1291elf_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
1292{
1293 bfd *abfd = objfile->obfd.get ();
1294 struct elfinfo ei;
1295
1296 memset ((char *) &ei, 0, sizeof (ei));
1297 if (!(objfile->flags & OBJF_READNEVER))
1298 {
1299 for (asection *sect : gdb_bfd_sections (abfd))
1300 elf_locate_sections (sect, &ei);
1301 }
1302
1303 elf_read_minimal_symbols (objfile, symfile_flags, &ei);
1304
1305 /* ELF debugging information is inserted into the psymtab in the
1306 order of least informative first - most informative last. Since
1307 the psymtab table is searched `most recent insertion first' this
1308 increases the probability that more detailed debug information
1309 for a section is found.
1310
1311 For instance, an object file might contain both .mdebug (XCOFF)
1312 and .debug_info (DWARF2) sections then .mdebug is inserted first
1313 (searched last) and DWARF2 is inserted last (searched first). If
1314 we don't do this then the XCOFF info is found first - for code in
1315 an included file XCOFF info is useless. */
1316
1317 if (ei.mdebugsect)
1318 {
1319 const struct ecoff_debug_swap *swap;
1320
1321 /* .mdebug section, presumably holding ECOFF debugging
1322 information. */
1323 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1324 if (swap)
1326 }
1327 if (ei.stabsect)
1328 {
1329 asection *str_sect;
1330
1331 /* Stab sections have an associated string table that looks like
1332 a separate section. */
1333 str_sect = bfd_get_section_by_name (abfd, ".stabstr");
1334
1335 /* FIXME should probably warn about a stab section without a stabstr. */
1336 if (str_sect)
1338 ei.stabsect,
1339 str_sect->filepos,
1340 bfd_section_size (str_sect));
1341 }
1342
1343 bool has_dwarf2 = elf_symfile_read_dwarf2 (objfile, symfile_flags);
1344
1345 /* Read the CTF section only if there is no DWARF info. */
1346 if (!has_dwarf2 && ei.ctfsect)
1347 {
1349 }
1350}
1351
1352/* Initialize anything that needs initializing when a completely new symbol
1353 file is specified (not just adding some symbols from another file, e.g. a
1354 shared library). */
1355
1356static void
1357elf_new_init (struct objfile *ignore)
1358{
1359}
1360
1361/* Perform any local cleanups required when we are done with a particular
1362 objfile. I.E, we are in the process of discarding all symbol information
1363 for an objfile, freeing up all memory held for it, and unlinking the
1364 objfile struct from the global list of known objfiles. */
1365
1366static void
1368{
1369}
1370
1371/* ELF specific initialization routine for reading symbols. */
1372
1373static void
1375{
1376 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
1377 find this causes a significant slowdown in gdb then we could
1378 set it in the debug symbol readers only when necessary. */
1380}
1381
1382/* Implementation of `sym_get_probes', as documented in symfile.h. */
1383
1384static const elfread_data &
1386{
1387 elfread_data *probes_per_bfd = probe_key.get (objfile->obfd.get ());
1388
1389 if (probes_per_bfd == NULL)
1390 {
1391 probes_per_bfd = probe_key.emplace (objfile->obfd.get ());
1392
1393 /* Here we try to gather information about all types of probes from the
1394 objfile. */
1395 for (const static_probe_ops *ops : all_static_probe_ops)
1396 ops->get_probes (probes_per_bfd, objfile);
1397 }
1398
1399 return *probes_per_bfd;
1400}
1401
1402
1403
1404/* Implementation `sym_probe_fns', as documented in symfile.h. */
1405
1406static const struct sym_probe_fns elf_probe_fns =
1407{
1408 elf_get_probes, /* sym_get_probes */
1409};
1410
1411/* Register that we are able to handle ELF object file formats. */
1412
1413static const struct sym_fns elf_sym_fns =
1414{
1415 elf_new_init, /* init anything gbl to entire symtab */
1416 elf_symfile_init, /* read initial info, setup for sym_read() */
1417 elf_symfile_read, /* read a symbol file into symtab */
1418 elf_symfile_finish, /* finished with file, cleanup */
1419 default_symfile_offsets, /* Translate ext. to int. relocation */
1420 elf_symfile_segments, /* Get segment information from a file. */
1421 NULL,
1422 default_symfile_relocate, /* Relocate a debug section. */
1423 &elf_probe_fns, /* sym_probe_fns */
1424};
1425
1426/* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */
1427
1429{
1434};
1435
1436void _initialize_elfread ();
1437void
1439{
1440 add_symtab_fns (bfd_target_elf_flavour, &elf_sym_fns);
1441
1443}
const char *const name
void xfree(void *)
void * xcalloc(size_t number, size_t size)
Definition alloc.c:85
struct gdbarch * target_gdbarch(void)
int target_auxv_search(const gdb::byte_vector &auxv, target_ops *ops, gdbarch *gdbarch, CORE_ADDR match, CORE_ADDR *valp)
Definition auxv.c:383
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition blockframe.c:373
void delete_breakpoint(struct breakpoint *bpt)
breakpoint_up set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
void update_breakpoint_locations(code_breakpoint *b, struct program_space *filter_pspace, gdb::array_view< const symtab_and_line > sals, gdb::array_view< const symtab_and_line > sals_end)
@ bp_gnu_ifunc_resolver_return
Definition breakpoint.h:211
@ bp_breakpoint
Definition breakpoint.h:86
@ bp_gnu_ifunc_resolver
Definition breakpoint.h:205
int build_id_verify(bfd *abfd, size_t check_len, const bfd_byte *check)
Definition build-id.c:49
std::string find_separate_debug_file_by_buildid(struct objfile *objfile)
Definition build-id.c:205
const struct bfd_build_id * build_id_bfd_get(bfd *abfd)
Definition build-id.c:33
bp_location * next
Definition breakpoint.h:339
CORE_ADDR requested_address
Definition breakpoint.h:463
CORE_ADDR related_address
Definition breakpoint.h:468
struct program_space * pspace
Definition inferior.h:547
struct minimal_symbol * record_full(gdb::string_view name, bool copy_name, CORE_ADDR address, enum minimal_symbol_type ms_type, int section)
Definition minsyms.c:1154
void set(unsigned key, void *datum)
Definition registry.h:204
void * get(unsigned key)
Definition registry.h:211
void elfctf_build_psymtabs(struct objfile *of)
Definition ctfread.c:1634
void elfstab_build_psymtabs(struct objfile *objfile, asection *stabsect, file_ptr stabstroffset, unsigned int stabstrsize)
Definition dbxread.c:3030
scoped_fd debuginfod_debuginfo_query(const unsigned char *build_id, int build_id_len, const char *filename, gdb::unique_xmalloc_ptr< char > *destname)
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition findvar.c:153
@ lval_memory
Definition defs.h:364
std::vector< std::unique_ptr< probe > > elfread_data
Definition elfread.c:68
static void elf_gnu_ifunc_resolver_stop(code_breakpoint *b)
Definition elfread.c:951
#define ST_DYNAMIC
Definition elfread.c:238
static const registry< bfd >::key< elfread_data > probe_key
Definition elfread.c:72
static void elf_new_init(struct objfile *ignore)
Definition elfread.c:1357
static void elf_symfile_init(struct objfile *objfile)
Definition elfread.c:1374
static void elf_read_minimal_symbols(struct objfile *objfile, int symfile_flags, const struct elfinfo *ei)
Definition elfread.c:1061
#define ST_SYNTHETIC
Definition elfread.c:239
static struct minimal_symbol * record_minimal_symbol(minimal_symbol_reader &reader, gdb::string_view name, bool copy_name, CORE_ADDR address, enum minimal_symbol_type ms_type, asection *bfd_section, struct objfile *objfile)
Definition elfread.c:196
#define ST_REGULAR
Definition elfread.c:237
static int elf_gnu_ifunc_cache_eq(const void *a_voidp, const void *b_voidp)
Definition elfread.c:676
static const struct sym_fns elf_sym_fns
Definition elfread.c:1413
static CORE_ADDR elf_gnu_ifunc_resolve_addr(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition elfread.c:905
static const registry< objfile >::key< htab, htab_deleter > elf_objfile_gnu_ifunc_cache_data
Definition elfread.c:650
static symfile_segment_data_up elf_symfile_segments(bfd *abfd)
Definition elfread.c:84
#define SYMBOL_GOT_PLT_SUFFIX
Definition elfread.c:79
void _initialize_elfread()
Definition elfread.c:1438
static int elf_gnu_ifunc_record_cache(const char *name, CORE_ADDR addr)
Definition elfread.c:695
static int elf_gnu_ifunc_resolve_by_cache(const char *name, CORE_ADDR *addr_p)
Definition elfread.c:770
static void elf_symfile_finish(struct objfile *objfile)
Definition elfread.c:1367
static void elf_symtab_read(minimal_symbol_reader &reader, struct objfile *objfile, int type, long number_of_symbols, asymbol **symbol_table, bool copy_names)
Definition elfread.c:242
static void elf_gnu_ifunc_resolver_return_stop(code_breakpoint *b)
Definition elfread.c:1002
static const elfread_data & elf_get_probes(struct objfile *objfile)
Definition elfread.c:1385
static bool elf_symfile_read_dwarf2(struct objfile *objfile, symfile_add_flags symfile_flags)
Definition elfread.c:1193
static hashval_t elf_gnu_ifunc_cache_hash(const void *a_voidp)
Definition elfread.c:665
static void elf_symfile_read(struct objfile *objfile, symfile_add_flags symfile_flags)
Definition elfread.c:1291
static bool elf_gnu_ifunc_resolve_name(const char *name, CORE_ADDR *addr_p)
Definition elfread.c:888
static const struct sym_probe_fns elf_probe_fns
Definition elfread.c:1406
static void elf_rel_plt_read(minimal_symbol_reader &reader, struct objfile *objfile, asymbol **dyn_symbol_table)
Definition elfread.c:547
static void elf_locate_sections(asection *sectp, struct elfinfo *ei)
Definition elfread.c:179
static int elf_gnu_ifunc_resolve_by_got(const char *name, CORE_ADDR *addr_p)
Definition elfread.c:819
static const struct gnu_ifunc_fns elf_gnu_ifunc_fns
Definition elfread.c:1428
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2592
struct frame_id get_stack_frame_id(frame_info_ptr next_frame)
Definition frame.c:638
bool frame_id_p(frame_id l)
Definition frame.c:735
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:2907
frame_info_ptr get_current_frame(void)
Definition frame.c:1615
frame_info_ptr get_prev_frame(frame_info_ptr this_frame)
Definition frame.c:2494
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition gdb_bfd.c:980
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:78
static gdb_bfd_section_range gdb_bfd_sections(bfd *abfd)
Definition gdb_bfd.h:222
bool gdbarch_record_special_symbol_p(struct gdbarch *gdbarch)
Definition gdbarch.c:4368
enum return_value_convention gdbarch_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition gdbarch.c:2579
void gdbarch_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype cb, struct objfile *current_objfile)
Definition gdbarch.c:4972
void gdbarch_elf_make_msymbol_special(struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
Definition gdbarch.c:3396
bool gdbarch_elf_make_msymbol_special_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3389
void gdbarch_record_special_symbol(struct gdbarch *gdbarch, struct objfile *objfile, asymbol *sym)
Definition gdbarch.c:4375
bfd * obfd
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition gdbarch.c:3087
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition gdbarch.c:3070
struct thread_info * inferior_thread(void)
Definition thread.c:83
struct value * call_function_by_hand(struct value *function, type *default_return_type, gdb::array_view< value * > args)
Definition infcall.c:781
struct inferior * current_inferior(void)
Definition inferior.c:54
void elfmdebug_build_psymtabs(struct objfile *objfile, const struct ecoff_debug_swap *swap, asection *sec)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
const struct gnu_ifunc_fns * gnu_ifunc_fns_p
Definition minsyms.c:1042
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition minsyms.c:977
@ OBJF_READNEVER
@ OBJF_MAINLINE
@ OBJF_REORDERED
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1308
std::string copy_name(struct stoken token)
Definition parse.c:407
std::vector< const static_probe_ops * > all_static_probe_ops
Definition probe.c:872
struct program_space * current_program_space
Definition progspace.c:39
void dwarf2_initialize_objfile(struct objfile *objfile)
Definition read.c:5356
int dwarf2_has_info(struct objfile *, const struct dwarf2_debug_sections *, bool=false)
Definition read.c:1553
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:397
struct objfile * objfile
Definition minsyms.h:54
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
bptype type
Definition breakpoint.h:733
location_spec_up locspec
Definition breakpoint.h:770
breakpoint * related_breakpoint
Definition breakpoint.h:798
bp_location * loc
Definition breakpoint.h:742
program_space * pspace
Definition breakpoint.h:767
struct frame_id frame_id
Definition breakpoint.h:762
struct type * builtin_data_ptr
Definition gdbtypes.h:2303
struct type * builtin_func_func
Definition gdbtypes.h:2319
asection * ctfsect
Definition elfread.c:63
asection * mdebugsect
Definition elfread.c:62
asection * stabsect
Definition elfread.c:61
CORE_ADDR address
Definition symtab.h:548
short section_index() const
Definition symtab.h:604
const char * linkage_name() const
Definition symtab.h:459
unsigned int created_by_gdb
Definition symtab.h:819
unsigned long size() const
Definition symtab.h:756
void set_size(unsigned long size)
Definition symtab.h:763
const char * filename
Definition symtab.h:811
minimal_symbol_type type() const
Definition symtab.h:742
unsigned maybe_copied
Definition symtab.h:836
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:743
struct objfile * separate_debug_objfile
Definition objfiles.h:738
struct gdbarch * arch() const
Definition objfiles.h:482
struct objfile_per_bfd_storage * per_bfd
Definition objfiles.h:657
gdb_bfd_ref_ptr obfd
Definition objfiles.h:653
const char * intern(const char *str)
Definition objfiles.h:469
objfile_flags flags
Definition objfiles.h:637
auto_obstack objfile_obstack
Definition objfiles.h:673
bool has_partial_symbols()
struct obj_section * section
Definition symtab.h:2265
CORE_ADDR pc
Definition symtab.h:2272
struct program_space * pspace
Definition symtab.h:2261
struct type * target_type() const
Definition gdbtypes.h:1000
ULONGEST length() const
Definition gdbtypes.h:954
Definition value.c:181
CORE_ADDR address
Definition value.c:246
gdb_bfd_ref_ptr symfile_bfd_open(const char *name)
Definition symfile.c:1702
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition symfile.c:3133
void add_symtab_fns(enum bfd_flavour flavour, const struct sym_fns *sf)
Definition symfile.c:1768
void default_symfile_offsets(struct objfile *objfile, const section_addr_info &addrs)
Definition symfile.c:627
void symbol_file_add_separate(const gdb_bfd_ref_ptr &bfd, const char *name, symfile_add_flags symfile_flags, struct objfile *objfile)
Definition symfile.c:1142
std::string find_separate_debug_file_by_debuglink(struct objfile *objfile)
Definition symfile.c:1514
bfd_byte * default_symfile_relocate(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition symfile.c:3561
std::unique_ptr< symfile_segment_data > symfile_segment_data_up
Definition symfile.h:104
symtab_and_line find_function_start_sal(CORE_ADDR func_addr, obj_section *section, bool funfirstline)
Definition symtab.c:3640
minimal_symbol_type
Definition symtab.h:653
@ mst_data_gnu_ifunc
Definition symtab.h:673
@ mst_abs
Definition symtab.h:679
@ mst_bss
Definition symtab.h:678
@ mst_data
Definition symtab.h:677
@ mst_unknown
Definition symtab.h:654
@ mst_solib_trampoline
Definition symtab.h:688
@ mst_file_text
Definition symtab.h:691
@ mst_slot_got_plt
Definition symtab.h:676
@ mst_file_data
Definition symtab.h:692
@ mst_text
Definition symtab.h:655
@ mst_text_gnu_ifunc
Definition symtab.h:664
@ mst_file_bss
Definition symtab.h:693
#define symtab_create_debug_printf(fmt,...)
Definition symtab.h:2617
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1771
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3114
struct type * value_type(const struct value *value)
Definition value.c:1109
struct value * allocate_value(struct type *type)
Definition value.c:1053
CORE_ADDR value_as_address(struct value *val)
Definition value.c:2804
void set_value_address(struct value *value, CORE_ADDR addr)
Definition value.c:1631
struct value * value_from_longest(struct type *type, LONGEST num)
Definition value.c:3625
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
Definition value.c:1167
#define VALUE_LVAL(val)
Definition value.h:438
const char target_name[]
Definition version.c:4