1 /* Read ELF (Executable and Linking Format) object files for GDB.
3 Copyright (C) 1991-2020 Free Software Foundation, Inc.
5 Written by Fred Fish at Cygnus Support.
7 This file is part of GDB.
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.
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.
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/>. */
25 #include "elf/common.h"
26 #include "elf/internal.h"
31 #include "stabsread.h"
32 #include "complaints.h"
35 #include "filenames.h"
37 #include "arch-utils.h"
41 #include "gdbthread.h"
49 #include "mdebugread.h"
51 #include "gdbsupport/gdb_string_view.h"
52 #include "gdbsupport/scoped_fd.h"
53 #include "debuginfod-support.h"
55 /* Forward declarations. */
56 extern const struct sym_fns elf_sym_fns_gdb_index
;
57 extern const struct sym_fns elf_sym_fns_debug_names
;
58 extern const struct sym_fns elf_sym_fns_lazy_psyms
;
60 /* The struct elfinfo is available only during ELF symbol table and
61 psymtab reading. It is destroyed at the completion of psymtab-reading.
62 It's local to elf_symfile_read. */
66 asection
*stabsect
; /* Section pointer for .stab section */
67 asection
*mdebugsect
; /* Section pointer for .mdebug section */
68 asection
*ctfsect
; /* Section pointer for .ctf section */
71 /* Type for per-BFD data. */
73 typedef std::vector
<std::unique_ptr
<probe
>> elfread_data
;
75 /* Per-BFD data for probe info. */
77 static const struct bfd_key
<elfread_data
> probe_key
;
79 /* Minimal symbols located at the GOT entries for .plt - that is the real
80 pointer where the given entry will jump to. It gets updated by the real
81 function address during lazy ld.so resolving in the inferior. These
82 minimal symbols are indexed for <tab>-completion. */
84 #define SYMBOL_GOT_PLT_SUFFIX "@got.plt"
86 /* Locate the segments in ABFD. */
88 static symfile_segment_data_up
89 elf_symfile_segments (bfd
*abfd
)
91 Elf_Internal_Phdr
*phdrs
, **segments
;
93 int num_phdrs
, num_segments
, num_sections
, i
;
96 phdrs_size
= bfd_get_elf_phdr_upper_bound (abfd
);
100 phdrs
= (Elf_Internal_Phdr
*) alloca (phdrs_size
);
101 num_phdrs
= bfd_get_elf_phdrs (abfd
, phdrs
);
106 segments
= XALLOCAVEC (Elf_Internal_Phdr
*, num_phdrs
);
107 for (i
= 0; i
< num_phdrs
; i
++)
108 if (phdrs
[i
].p_type
== PT_LOAD
)
109 segments
[num_segments
++] = &phdrs
[i
];
111 if (num_segments
== 0)
114 symfile_segment_data_up
data (new symfile_segment_data
);
115 data
->num_segments
= num_segments
;
116 data
->segment_bases
= XCNEWVEC (CORE_ADDR
, num_segments
);
117 data
->segment_sizes
= XCNEWVEC (CORE_ADDR
, num_segments
);
119 for (i
= 0; i
< num_segments
; i
++)
121 data
->segment_bases
[i
] = segments
[i
]->p_vaddr
;
122 data
->segment_sizes
[i
] = segments
[i
]->p_memsz
;
125 num_sections
= bfd_count_sections (abfd
);
126 data
->segment_info
= XCNEWVEC (int, num_sections
);
128 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
132 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
135 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (sect
)->this_hdr
;
137 for (j
= 0; j
< num_segments
; j
++)
138 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segments
[j
]))
140 data
->segment_info
[i
] = j
+ 1;
144 /* We should have found a segment for every non-empty section.
145 If we haven't, we will not relocate this section by any
146 offsets we apply to the segments. As an exception, do not
147 warn about SHT_NOBITS sections; in normal ELF execution
148 environments, SHT_NOBITS means zero-initialized and belongs
149 in a segment, but in no-OS environments some tools (e.g. ARM
150 RealView) use SHT_NOBITS for uninitialized data. Since it is
151 uninitialized, it doesn't need a program header. Such
152 binaries are not relocatable. */
153 if (bfd_section_size (sect
) > 0 && j
== num_segments
154 && (bfd_section_flags (sect
) & SEC_LOAD
) != 0)
155 warning (_("Loadable section \"%s\" outside of ELF segments"),
156 bfd_section_name (sect
));
162 /* We are called once per section from elf_symfile_read. We
163 need to examine each section we are passed, check to see
164 if it is something we are interested in processing, and
165 if so, stash away some access information for the section.
167 For now we recognize the dwarf debug information sections and
168 line number sections from matching their section names. The
169 ELF definition is no real help here since it has no direct
170 knowledge of DWARF (by design, so any debugging format can be
173 We also recognize the ".stab" sections used by the Sun compilers
174 released with Solaris 2.
176 FIXME: The section names should not be hardwired strings (what
177 should they be? I don't think most object file formats have enough
178 section flags to specify what kind of debug section it is.
182 elf_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *eip
)
186 ei
= (struct elfinfo
*) eip
;
187 if (strcmp (sectp
->name
, ".stab") == 0)
189 ei
->stabsect
= sectp
;
191 else if (strcmp (sectp
->name
, ".mdebug") == 0)
193 ei
->mdebugsect
= sectp
;
195 else if (strcmp (sectp
->name
, ".ctf") == 0)
201 static struct minimal_symbol
*
202 record_minimal_symbol (minimal_symbol_reader
&reader
,
203 gdb::string_view name
, bool copy_name
,
205 enum minimal_symbol_type ms_type
,
206 asection
*bfd_section
, struct objfile
*objfile
)
208 struct gdbarch
*gdbarch
= objfile
->arch ();
210 if (ms_type
== mst_text
|| ms_type
== mst_file_text
211 || ms_type
== mst_text_gnu_ifunc
)
212 address
= gdbarch_addr_bits_remove (gdbarch
, address
);
214 /* We only setup section information for allocatable sections. Usually
215 we'd only expect to find msymbols for allocatable sections, but if the
216 ELF is malformed then this might not be the case. In that case don't
217 create an msymbol that references an uninitialised section object. */
218 int section_index
= 0;
219 if ((bfd_section_flags (bfd_section
) & SEC_ALLOC
) == SEC_ALLOC
)
220 section_index
= gdb_bfd_section_index (objfile
->obfd
, bfd_section
);
222 struct minimal_symbol
*result
223 = reader
.record_full (name
, copy_name
, address
, ms_type
, section_index
);
224 if ((objfile
->flags
& OBJF_MAINLINE
) == 0
225 && (ms_type
== mst_data
|| ms_type
== mst_bss
))
226 result
->maybe_copied
= 1;
231 /* Read the symbol table of an ELF file.
233 Given an objfile, a symbol table, and a flag indicating whether the
234 symbol table contains regular, dynamic, or synthetic symbols, add all
235 the global function and data symbols to the minimal symbol table.
237 In stabs-in-ELF, as implemented by Sun, there are some local symbols
238 defined in the ELF symbol table, which can be used to locate
239 the beginnings of sections from each ".o" file that was linked to
240 form the executable objfile. We gather any such info and record it
241 in data structures hung off the objfile's private data. */
245 #define ST_SYNTHETIC 2
248 elf_symtab_read (minimal_symbol_reader
&reader
,
249 struct objfile
*objfile
, int type
,
250 long number_of_symbols
, asymbol
**symbol_table
,
253 struct gdbarch
*gdbarch
= objfile
->arch ();
257 enum minimal_symbol_type ms_type
;
258 /* Name of the last file symbol. This is either a constant string or is
259 saved on the objfile's filename cache. */
260 const char *filesymname
= "";
261 int stripped
= (bfd_get_symcount (objfile
->obfd
) == 0);
262 int elf_make_msymbol_special_p
263 = gdbarch_elf_make_msymbol_special_p (gdbarch
);
265 for (i
= 0; i
< number_of_symbols
; i
++)
267 sym
= symbol_table
[i
];
268 if (sym
->name
== NULL
|| *sym
->name
== '\0')
270 /* Skip names that don't exist (shouldn't happen), or names
271 that are null strings (may happen). */
275 /* Skip "special" symbols, e.g. ARM mapping symbols. These are
276 symbols which do not correspond to objects in the symbol table,
277 but have some other target-specific meaning. */
278 if (bfd_is_target_special_symbol (objfile
->obfd
, sym
))
280 if (gdbarch_record_special_symbol_p (gdbarch
))
281 gdbarch_record_special_symbol (gdbarch
, objfile
, sym
);
285 if (type
== ST_DYNAMIC
286 && sym
->section
== bfd_und_section_ptr
287 && (sym
->flags
& BSF_FUNCTION
))
289 struct minimal_symbol
*msym
;
290 bfd
*abfd
= objfile
->obfd
;
293 /* Symbol is a reference to a function defined in
295 If its value is non zero then it is usually the address
296 of the corresponding entry in the procedure linkage table,
297 plus the desired section offset.
298 If its value is zero then the dynamic linker has to resolve
299 the symbol. We are unable to find any meaningful address
300 for this symbol in the executable file, so we skip it. */
301 symaddr
= sym
->value
;
305 /* sym->section is the undefined section. However, we want to
306 record the section where the PLT stub resides with the
307 minimal symbol. Search the section table for the one that
308 covers the stub's address. */
309 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
311 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
314 if (symaddr
>= bfd_section_vma (sect
)
315 && symaddr
< bfd_section_vma (sect
)
316 + bfd_section_size (sect
))
322 /* On ia64-hpux, we have discovered that the system linker
323 adds undefined symbols with nonzero addresses that cannot
324 be right (their address points inside the code of another
325 function in the .text section). This creates problems
326 when trying to determine which symbol corresponds to
329 We try to detect those buggy symbols by checking which
330 section we think they correspond to. Normally, PLT symbols
331 are stored inside their own section, and the typical name
332 for that section is ".plt". So, if there is a ".plt"
333 section, and yet the section name of our symbol does not
334 start with ".plt", we ignore that symbol. */
335 if (!startswith (sect
->name
, ".plt")
336 && bfd_get_section_by_name (abfd
, ".plt") != NULL
)
339 msym
= record_minimal_symbol
340 (reader
, sym
->name
, copy_names
,
341 symaddr
, mst_solib_trampoline
, sect
, objfile
);
344 msym
->filename
= filesymname
;
345 if (elf_make_msymbol_special_p
)
346 gdbarch_elf_make_msymbol_special (gdbarch
, sym
, msym
);
351 /* If it is a nonstripped executable, do not enter dynamic
352 symbols, as the dynamic symbol table is usually a subset
353 of the main symbol table. */
354 if (type
== ST_DYNAMIC
&& !stripped
)
356 if (sym
->flags
& BSF_FILE
)
357 filesymname
= objfile
->intern (sym
->name
);
358 else if (sym
->flags
& BSF_SECTION_SYM
)
360 else if (sym
->flags
& (BSF_GLOBAL
| BSF_LOCAL
| BSF_WEAK
363 struct minimal_symbol
*msym
;
365 /* Select global/local/weak symbols. Note that bfd puts abs
366 symbols in their own section, so all symbols we are
367 interested in will have a section. */
368 /* Bfd symbols are section relative. */
369 symaddr
= sym
->value
+ sym
->section
->vma
;
370 /* For non-absolute symbols, use the type of the section
371 they are relative to, to intuit text/data. Bfd provides
372 no way of figuring this out for absolute symbols. */
373 if (sym
->section
== bfd_abs_section_ptr
)
375 /* This is a hack to get the minimal symbol type
376 right for Irix 5, which has absolute addresses
377 with special section indices for dynamic symbols.
379 NOTE: uweigand-20071112: Synthetic symbols do not
380 have an ELF-private part, so do not touch those. */
381 unsigned int shndx
= type
== ST_SYNTHETIC
? 0 :
382 ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_shndx
;
392 case SHN_MIPS_ACOMMON
:
399 /* If it is an Irix dynamic symbol, skip section name
400 symbols, relocate all others by section offset. */
401 if (ms_type
!= mst_abs
)
403 if (sym
->name
[0] == '.')
407 else if (sym
->section
->flags
& SEC_CODE
)
409 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
))
411 if (sym
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
412 ms_type
= mst_text_gnu_ifunc
;
416 /* The BSF_SYNTHETIC check is there to omit ppc64 function
417 descriptors mistaken for static functions starting with 'L'.
419 else if ((sym
->name
[0] == '.' && sym
->name
[1] == 'L'
420 && (sym
->flags
& BSF_SYNTHETIC
) == 0)
421 || ((sym
->flags
& BSF_LOCAL
)
422 && sym
->name
[0] == '$'
423 && sym
->name
[1] == 'L'))
424 /* Looks like a compiler-generated label. Skip
425 it. The assembler should be skipping these (to
426 keep executables small), but apparently with
427 gcc on the (deleted) delta m88k SVR4, it loses.
428 So to have us check too should be harmless (but
429 I encourage people to fix this in the assembler
430 instead of adding checks here). */
434 ms_type
= mst_file_text
;
437 else if (sym
->section
->flags
& SEC_ALLOC
)
439 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
))
441 if (sym
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
443 ms_type
= mst_data_gnu_ifunc
;
445 else if (sym
->section
->flags
& SEC_LOAD
)
454 else if (sym
->flags
& BSF_LOCAL
)
456 if (sym
->section
->flags
& SEC_LOAD
)
458 ms_type
= mst_file_data
;
462 ms_type
= mst_file_bss
;
467 ms_type
= mst_unknown
;
472 /* FIXME: Solaris2 shared libraries include lots of
473 odd "absolute" and "undefined" symbols, that play
474 hob with actions like finding what function the PC
475 is in. Ignore them if they aren't text, data, or bss. */
476 /* ms_type = mst_unknown; */
477 continue; /* Skip this symbol. */
479 msym
= record_minimal_symbol
480 (reader
, sym
->name
, copy_names
, symaddr
,
481 ms_type
, sym
->section
, objfile
);
485 /* NOTE: uweigand-20071112: A synthetic symbol does not have an
487 if (type
!= ST_SYNTHETIC
)
489 /* Pass symbol size field in via BFD. FIXME!!! */
490 elf_symbol_type
*elf_sym
= (elf_symbol_type
*) sym
;
491 SET_MSYMBOL_SIZE (msym
, elf_sym
->internal_elf_sym
.st_size
);
494 msym
->filename
= filesymname
;
495 if (elf_make_msymbol_special_p
)
496 gdbarch_elf_make_msymbol_special (gdbarch
, sym
, msym
);
499 /* If we see a default versioned symbol, install it under
500 its version-less name. */
503 const char *atsign
= strchr (sym
->name
, '@');
505 if (atsign
!= NULL
&& atsign
[1] == '@' && atsign
> sym
->name
)
507 int len
= atsign
- sym
->name
;
509 record_minimal_symbol (reader
,
510 gdb::string_view (sym
->name
, len
),
511 true, symaddr
, ms_type
, sym
->section
,
516 /* For @plt symbols, also record a trampoline to the
517 destination symbol. The @plt symbol will be used in
518 disassembly, and the trampoline will be used when we are
519 trying to find the target. */
520 if (msym
&& ms_type
== mst_text
&& type
== ST_SYNTHETIC
)
522 int len
= strlen (sym
->name
);
524 if (len
> 4 && strcmp (sym
->name
+ len
- 4, "@plt") == 0)
526 struct minimal_symbol
*mtramp
;
528 mtramp
= record_minimal_symbol
529 (reader
, gdb::string_view (sym
->name
, len
- 4), true,
530 symaddr
, mst_solib_trampoline
, sym
->section
, objfile
);
533 SET_MSYMBOL_SIZE (mtramp
, MSYMBOL_SIZE (msym
));
534 mtramp
->created_by_gdb
= 1;
535 mtramp
->filename
= filesymname
;
536 if (elf_make_msymbol_special_p
)
537 gdbarch_elf_make_msymbol_special (gdbarch
,
546 /* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX)
547 for later look ups of which function to call when user requests
548 a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target
549 library defining `function' we cannot yet know while reading OBJFILE which
550 of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later
551 DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */
554 elf_rel_plt_read (minimal_symbol_reader
&reader
,
555 struct objfile
*objfile
, asymbol
**dyn_symbol_table
)
557 bfd
*obfd
= objfile
->obfd
;
558 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
559 asection
*relplt
, *got_plt
;
560 bfd_size_type reloc_count
, reloc
;
561 struct gdbarch
*gdbarch
= objfile
->arch ();
562 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
563 size_t ptr_size
= TYPE_LENGTH (ptr_type
);
565 if (objfile
->separate_debug_objfile_backlink
)
568 got_plt
= bfd_get_section_by_name (obfd
, ".got.plt");
571 /* For platforms where there is no separate .got.plt. */
572 got_plt
= bfd_get_section_by_name (obfd
, ".got");
577 /* Depending on system, we may find jump slots in a relocation
578 section for either .got.plt or .plt. */
579 asection
*plt
= bfd_get_section_by_name (obfd
, ".plt");
580 int plt_elf_idx
= (plt
!= NULL
) ? elf_section_data (plt
)->this_idx
: -1;
582 int got_plt_elf_idx
= elf_section_data (got_plt
)->this_idx
;
584 /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */
585 for (relplt
= obfd
->sections
; relplt
!= NULL
; relplt
= relplt
->next
)
587 const auto &this_hdr
= elf_section_data (relplt
)->this_hdr
;
589 if (this_hdr
.sh_type
== SHT_REL
|| this_hdr
.sh_type
== SHT_RELA
)
591 if (this_hdr
.sh_info
== plt_elf_idx
592 || this_hdr
.sh_info
== got_plt_elf_idx
)
599 if (! bed
->s
->slurp_reloc_table (obfd
, relplt
, dyn_symbol_table
, TRUE
))
602 std::string string_buffer
;
604 /* Does ADDRESS reside in SECTION of OBFD? */
605 auto within_section
= [obfd
] (asection
*section
, CORE_ADDR address
)
610 return (bfd_section_vma (section
) <= address
611 && (address
< bfd_section_vma (section
)
612 + bfd_section_size (section
)));
615 reloc_count
= relplt
->size
/ elf_section_data (relplt
)->this_hdr
.sh_entsize
;
616 for (reloc
= 0; reloc
< reloc_count
; reloc
++)
619 struct minimal_symbol
*msym
;
621 const char *got_suffix
= SYMBOL_GOT_PLT_SUFFIX
;
622 const size_t got_suffix_len
= strlen (SYMBOL_GOT_PLT_SUFFIX
);
624 name
= bfd_asymbol_name (*relplt
->relocation
[reloc
].sym_ptr_ptr
);
625 address
= relplt
->relocation
[reloc
].address
;
627 asection
*msym_section
;
629 /* Does the pointer reside in either the .got.plt or .plt
631 if (within_section (got_plt
, address
))
632 msym_section
= got_plt
;
633 else if (within_section (plt
, address
))
638 /* We cannot check if NAME is a reference to
639 mst_text_gnu_ifunc/mst_data_gnu_ifunc as in OBJFILE the
640 symbol is undefined and the objfile having NAME defined may
641 not yet have been loaded. */
643 string_buffer
.assign (name
);
644 string_buffer
.append (got_suffix
, got_suffix
+ got_suffix_len
);
646 msym
= record_minimal_symbol (reader
, string_buffer
,
647 true, address
, mst_slot_got_plt
,
648 msym_section
, objfile
);
650 SET_MSYMBOL_SIZE (msym
, ptr_size
);
654 /* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */
656 static const struct objfile_key
<htab
, htab_deleter
>
657 elf_objfile_gnu_ifunc_cache_data
;
659 /* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */
661 struct elf_gnu_ifunc_cache
663 /* This is always a function entry address, not a function descriptor. */
669 /* htab_hash for elf_objfile_gnu_ifunc_cache_data. */
672 elf_gnu_ifunc_cache_hash (const void *a_voidp
)
674 const struct elf_gnu_ifunc_cache
*a
675 = (const struct elf_gnu_ifunc_cache
*) a_voidp
;
677 return htab_hash_string (a
->name
);
680 /* htab_eq for elf_objfile_gnu_ifunc_cache_data. */
683 elf_gnu_ifunc_cache_eq (const void *a_voidp
, const void *b_voidp
)
685 const struct elf_gnu_ifunc_cache
*a
686 = (const struct elf_gnu_ifunc_cache
*) a_voidp
;
687 const struct elf_gnu_ifunc_cache
*b
688 = (const struct elf_gnu_ifunc_cache
*) b_voidp
;
690 return strcmp (a
->name
, b
->name
) == 0;
693 /* Record the target function address of a STT_GNU_IFUNC function NAME is the
694 function entry address ADDR. Return 1 if NAME and ADDR are considered as
695 valid and therefore they were successfully recorded, return 0 otherwise.
697 Function does not expect a duplicate entry. Use
698 elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already
702 elf_gnu_ifunc_record_cache (const char *name
, CORE_ADDR addr
)
704 struct bound_minimal_symbol msym
;
705 struct objfile
*objfile
;
707 struct elf_gnu_ifunc_cache entry_local
, *entry_p
;
710 msym
= lookup_minimal_symbol_by_pc (addr
);
711 if (msym
.minsym
== NULL
)
713 if (BMSYMBOL_VALUE_ADDRESS (msym
) != addr
)
715 objfile
= msym
.objfile
;
717 /* If .plt jumps back to .plt the symbol is still deferred for later
718 resolution and it has no use for GDB. */
719 const char *target_name
= msym
.minsym
->linkage_name ();
720 size_t len
= strlen (target_name
);
722 /* Note we check the symbol's name instead of checking whether the
723 symbol is in the .plt section because some systems have @plt
724 symbols in the .text section. */
725 if (len
> 4 && strcmp (target_name
+ len
- 4, "@plt") == 0)
728 htab
= elf_objfile_gnu_ifunc_cache_data
.get (objfile
);
731 htab
= htab_create_alloc (1, elf_gnu_ifunc_cache_hash
,
732 elf_gnu_ifunc_cache_eq
,
733 NULL
, xcalloc
, xfree
);
734 elf_objfile_gnu_ifunc_cache_data
.set (objfile
, htab
);
737 entry_local
.addr
= addr
;
738 obstack_grow (&objfile
->objfile_obstack
, &entry_local
,
739 offsetof (struct elf_gnu_ifunc_cache
, name
));
740 obstack_grow_str0 (&objfile
->objfile_obstack
, name
);
742 = (struct elf_gnu_ifunc_cache
*) obstack_finish (&objfile
->objfile_obstack
);
744 slot
= htab_find_slot (htab
, entry_p
, INSERT
);
747 struct elf_gnu_ifunc_cache
*entry_found_p
748 = (struct elf_gnu_ifunc_cache
*) *slot
;
749 struct gdbarch
*gdbarch
= objfile
->arch ();
751 if (entry_found_p
->addr
!= addr
)
753 /* This case indicates buggy inferior program, the resolved address
754 should never change. */
756 warning (_("gnu-indirect-function \"%s\" has changed its resolved "
757 "function_address from %s to %s"),
758 name
, paddress (gdbarch
, entry_found_p
->addr
),
759 paddress (gdbarch
, addr
));
762 /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */
769 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
770 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
771 is not NULL) and the function returns 1. It returns 0 otherwise.
773 Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this
777 elf_gnu_ifunc_resolve_by_cache (const char *name
, CORE_ADDR
*addr_p
)
779 for (objfile
*objfile
: current_program_space
->objfiles ())
782 struct elf_gnu_ifunc_cache
*entry_p
;
785 htab
= elf_objfile_gnu_ifunc_cache_data
.get (objfile
);
789 entry_p
= ((struct elf_gnu_ifunc_cache
*)
790 alloca (sizeof (*entry_p
) + strlen (name
)));
791 strcpy (entry_p
->name
, name
);
793 slot
= htab_find_slot (htab
, entry_p
, NO_INSERT
);
796 entry_p
= (struct elf_gnu_ifunc_cache
*) *slot
;
797 gdb_assert (entry_p
!= NULL
);
800 *addr_p
= entry_p
->addr
;
807 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
808 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
809 is not NULL) and the function returns 1. It returns 0 otherwise.
811 Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function.
812 elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to
813 prevent cache entries duplicates. */
816 elf_gnu_ifunc_resolve_by_got (const char *name
, CORE_ADDR
*addr_p
)
819 const size_t got_suffix_len
= strlen (SYMBOL_GOT_PLT_SUFFIX
);
821 name_got_plt
= (char *) alloca (strlen (name
) + got_suffix_len
+ 1);
822 sprintf (name_got_plt
, "%s" SYMBOL_GOT_PLT_SUFFIX
, name
);
824 for (objfile
*objfile
: current_program_space
->objfiles ())
826 bfd
*obfd
= objfile
->obfd
;
827 struct gdbarch
*gdbarch
= objfile
->arch ();
828 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
829 size_t ptr_size
= TYPE_LENGTH (ptr_type
);
830 CORE_ADDR pointer_address
, addr
;
832 gdb_byte
*buf
= (gdb_byte
*) alloca (ptr_size
);
833 struct bound_minimal_symbol msym
;
835 msym
= lookup_minimal_symbol (name_got_plt
, NULL
, objfile
);
836 if (msym
.minsym
== NULL
)
838 if (MSYMBOL_TYPE (msym
.minsym
) != mst_slot_got_plt
)
840 pointer_address
= BMSYMBOL_VALUE_ADDRESS (msym
);
842 plt
= bfd_get_section_by_name (obfd
, ".plt");
846 if (MSYMBOL_SIZE (msym
.minsym
) != ptr_size
)
848 if (target_read_memory (pointer_address
, buf
, ptr_size
) != 0)
850 addr
= extract_typed_address (buf
, ptr_type
);
851 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
852 current_top_target ());
853 addr
= gdbarch_addr_bits_remove (gdbarch
, addr
);
855 if (elf_gnu_ifunc_record_cache (name
, addr
))
866 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
867 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
868 is not NULL) and the function returns true. It returns false otherwise.
870 Both the elf_objfile_gnu_ifunc_cache_data hash table and
871 SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */
874 elf_gnu_ifunc_resolve_name (const char *name
, CORE_ADDR
*addr_p
)
876 if (elf_gnu_ifunc_resolve_by_cache (name
, addr_p
))
879 if (elf_gnu_ifunc_resolve_by_got (name
, addr_p
))
885 /* Call STT_GNU_IFUNC - a function returning addresss of a real function to
886 call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned
887 is the entry point of the resolved STT_GNU_IFUNC target function to call.
891 elf_gnu_ifunc_resolve_addr (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
893 const char *name_at_pc
;
894 CORE_ADDR start_at_pc
, address
;
895 struct type
*func_func_type
= builtin_type (gdbarch
)->builtin_func_func
;
896 struct value
*function
, *address_val
;
898 struct value
*hwcap_val
;
900 /* Try first any non-intrusive methods without an inferior call. */
902 if (find_pc_partial_function (pc
, &name_at_pc
, &start_at_pc
, NULL
)
903 && start_at_pc
== pc
)
905 if (elf_gnu_ifunc_resolve_name (name_at_pc
, &address
))
911 function
= allocate_value (func_func_type
);
912 VALUE_LVAL (function
) = lval_memory
;
913 set_value_address (function
, pc
);
915 /* STT_GNU_IFUNC resolver functions usually receive the HWCAP vector as
916 parameter. FUNCTION is the function entry address. ADDRESS may be a
917 function descriptor. */
919 target_auxv_search (current_top_target (), AT_HWCAP
, &hwcap
);
920 hwcap_val
= value_from_longest (builtin_type (gdbarch
)
921 ->builtin_unsigned_long
, hwcap
);
922 address_val
= call_function_by_hand (function
, NULL
, hwcap_val
);
923 address
= value_as_address (address_val
);
924 address
= gdbarch_convert_from_func_ptr_addr (gdbarch
, address
, current_top_target ());
925 address
= gdbarch_addr_bits_remove (gdbarch
, address
);
928 elf_gnu_ifunc_record_cache (name_at_pc
, address
);
933 /* Handle inferior hit of bp_gnu_ifunc_resolver, see its definition. */
936 elf_gnu_ifunc_resolver_stop (struct breakpoint
*b
)
938 struct breakpoint
*b_return
;
939 struct frame_info
*prev_frame
= get_prev_frame (get_current_frame ());
940 struct frame_id prev_frame_id
= get_stack_frame_id (prev_frame
);
941 CORE_ADDR prev_pc
= get_frame_pc (prev_frame
);
942 int thread_id
= inferior_thread ()->global_num
;
944 gdb_assert (b
->type
== bp_gnu_ifunc_resolver
);
946 for (b_return
= b
->related_breakpoint
; b_return
!= b
;
947 b_return
= b_return
->related_breakpoint
)
949 gdb_assert (b_return
->type
== bp_gnu_ifunc_resolver_return
);
950 gdb_assert (b_return
->loc
!= NULL
&& b_return
->loc
->next
== NULL
);
951 gdb_assert (frame_id_p (b_return
->frame_id
));
953 if (b_return
->thread
== thread_id
954 && b_return
->loc
->requested_address
== prev_pc
955 && frame_id_eq (b_return
->frame_id
, prev_frame_id
))
961 /* No need to call find_pc_line for symbols resolving as this is only
962 a helper breakpointer never shown to the user. */
965 sal
.pspace
= current_inferior ()->pspace
;
967 sal
.section
= find_pc_overlay (sal
.pc
);
970 = set_momentary_breakpoint (get_frame_arch (prev_frame
), sal
,
972 bp_gnu_ifunc_resolver_return
).release ();
974 /* set_momentary_breakpoint invalidates PREV_FRAME. */
977 /* Add new b_return to the ring list b->related_breakpoint. */
978 gdb_assert (b_return
->related_breakpoint
== b_return
);
979 b_return
->related_breakpoint
= b
->related_breakpoint
;
980 b
->related_breakpoint
= b_return
;
984 /* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition. */
987 elf_gnu_ifunc_resolver_return_stop (struct breakpoint
*b
)
989 thread_info
*thread
= inferior_thread ();
990 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
991 struct type
*func_func_type
= builtin_type (gdbarch
)->builtin_func_func
;
992 struct type
*value_type
= TYPE_TARGET_TYPE (func_func_type
);
993 struct regcache
*regcache
= get_thread_regcache (thread
);
994 struct value
*func_func
;
996 CORE_ADDR resolved_address
, resolved_pc
;
998 gdb_assert (b
->type
== bp_gnu_ifunc_resolver_return
);
1000 while (b
->related_breakpoint
!= b
)
1002 struct breakpoint
*b_next
= b
->related_breakpoint
;
1006 case bp_gnu_ifunc_resolver
:
1008 case bp_gnu_ifunc_resolver_return
:
1009 delete_breakpoint (b
);
1012 internal_error (__FILE__
, __LINE__
,
1013 _("handle_inferior_event: Invalid "
1014 "gnu-indirect-function breakpoint type %d"),
1019 gdb_assert (b
->type
== bp_gnu_ifunc_resolver
);
1020 gdb_assert (b
->loc
->next
== NULL
);
1022 func_func
= allocate_value (func_func_type
);
1023 VALUE_LVAL (func_func
) = lval_memory
;
1024 set_value_address (func_func
, b
->loc
->related_address
);
1026 value
= allocate_value (value_type
);
1027 gdbarch_return_value (gdbarch
, func_func
, value_type
, regcache
,
1028 value_contents_raw (value
), NULL
);
1029 resolved_address
= value_as_address (value
);
1030 resolved_pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
,
1032 current_top_target ());
1033 resolved_pc
= gdbarch_addr_bits_remove (gdbarch
, resolved_pc
);
1035 gdb_assert (current_program_space
== b
->pspace
|| b
->pspace
== NULL
);
1036 elf_gnu_ifunc_record_cache (event_location_to_string (b
->location
.get ()),
1039 b
->type
= bp_breakpoint
;
1040 update_breakpoint_locations (b
, current_program_space
,
1041 find_function_start_sal (resolved_pc
, NULL
, true),
1045 /* A helper function for elf_symfile_read that reads the minimal
1049 elf_read_minimal_symbols (struct objfile
*objfile
, int symfile_flags
,
1050 const struct elfinfo
*ei
)
1052 bfd
*synth_abfd
, *abfd
= objfile
->obfd
;
1053 long symcount
= 0, dynsymcount
= 0, synthcount
, storage_needed
;
1054 asymbol
**symbol_table
= NULL
, **dyn_symbol_table
= NULL
;
1057 if (symtab_create_debug
)
1059 fprintf_unfiltered (gdb_stdlog
,
1060 "Reading minimal symbols of objfile %s ...\n",
1061 objfile_name (objfile
));
1064 /* If we already have minsyms, then we can skip some work here.
1065 However, if there were stabs or mdebug sections, we go ahead and
1066 redo all the work anyway, because the psym readers for those
1067 kinds of debuginfo need extra information found here. This can
1068 go away once all types of symbols are in the per-BFD object. */
1069 if (objfile
->per_bfd
->minsyms_read
1070 && ei
->stabsect
== NULL
1071 && ei
->mdebugsect
== NULL
1072 && ei
->ctfsect
== NULL
)
1074 if (symtab_create_debug
)
1075 fprintf_unfiltered (gdb_stdlog
,
1076 "... minimal symbols previously read\n");
1080 minimal_symbol_reader
reader (objfile
);
1082 /* Process the normal ELF symbol table first. */
1084 storage_needed
= bfd_get_symtab_upper_bound (objfile
->obfd
);
1085 if (storage_needed
< 0)
1086 error (_("Can't read symbols from %s: %s"),
1087 bfd_get_filename (objfile
->obfd
),
1088 bfd_errmsg (bfd_get_error ()));
1090 if (storage_needed
> 0)
1092 /* Memory gets permanently referenced from ABFD after
1093 bfd_canonicalize_symtab so it must not get freed before ABFD gets. */
1095 symbol_table
= (asymbol
**) bfd_alloc (abfd
, storage_needed
);
1096 symcount
= bfd_canonicalize_symtab (objfile
->obfd
, symbol_table
);
1099 error (_("Can't read symbols from %s: %s"),
1100 bfd_get_filename (objfile
->obfd
),
1101 bfd_errmsg (bfd_get_error ()));
1103 elf_symtab_read (reader
, objfile
, ST_REGULAR
, symcount
, symbol_table
,
1107 /* Add the dynamic symbols. */
1109 storage_needed
= bfd_get_dynamic_symtab_upper_bound (objfile
->obfd
);
1111 if (storage_needed
> 0)
1113 /* Memory gets permanently referenced from ABFD after
1114 bfd_get_synthetic_symtab so it must not get freed before ABFD gets.
1115 It happens only in the case when elf_slurp_reloc_table sees
1116 asection->relocation NULL. Determining which section is asection is
1117 done by _bfd_elf_get_synthetic_symtab which is all a bfd
1118 implementation detail, though. */
1120 dyn_symbol_table
= (asymbol
**) bfd_alloc (abfd
, storage_needed
);
1121 dynsymcount
= bfd_canonicalize_dynamic_symtab (objfile
->obfd
,
1124 if (dynsymcount
< 0)
1125 error (_("Can't read symbols from %s: %s"),
1126 bfd_get_filename (objfile
->obfd
),
1127 bfd_errmsg (bfd_get_error ()));
1129 elf_symtab_read (reader
, objfile
, ST_DYNAMIC
, dynsymcount
,
1130 dyn_symbol_table
, false);
1132 elf_rel_plt_read (reader
, objfile
, dyn_symbol_table
);
1135 /* Contrary to binutils --strip-debug/--only-keep-debug the strip command from
1136 elfutils (eu-strip) moves even the .symtab section into the .debug file.
1138 bfd_get_synthetic_symtab on ppc64 for each function descriptor ELF symbol
1139 'name' creates a new BSF_SYNTHETIC ELF symbol '.name' with its code
1140 address. But with eu-strip files bfd_get_synthetic_symtab would fail to
1141 read the code address from .opd while it reads the .symtab section from
1142 a separate debug info file as the .opd section is SHT_NOBITS there.
1144 With SYNTH_ABFD the .opd section will be read from the original
1145 backlinked binary where it is valid. */
1147 if (objfile
->separate_debug_objfile_backlink
)
1148 synth_abfd
= objfile
->separate_debug_objfile_backlink
->obfd
;
1152 /* Add synthetic symbols - for instance, names for any PLT entries. */
1154 synthcount
= bfd_get_synthetic_symtab (synth_abfd
, symcount
, symbol_table
,
1155 dynsymcount
, dyn_symbol_table
,
1161 std::unique_ptr
<asymbol
*[]>
1162 synth_symbol_table (new asymbol
*[synthcount
]);
1163 for (i
= 0; i
< synthcount
; i
++)
1164 synth_symbol_table
[i
] = synthsyms
+ i
;
1165 elf_symtab_read (reader
, objfile
, ST_SYNTHETIC
, synthcount
,
1166 synth_symbol_table
.get (), true);
1172 /* Install any minimal symbols that have been collected as the current
1173 minimal symbols for this objfile. The debug readers below this point
1174 should not generate new minimal symbols; if they do it's their
1175 responsibility to install them. "mdebug" appears to be the only one
1176 which will do this. */
1180 if (symtab_create_debug
)
1181 fprintf_unfiltered (gdb_stdlog
, "Done reading minimal symbols.\n");
1184 /* Scan and build partial symbols for a symbol file.
1185 We have been initialized by a call to elf_symfile_init, which
1186 currently does nothing.
1188 This function only does the minimum work necessary for letting the
1189 user "name" things symbolically; it does not read the entire symtab.
1190 Instead, it reads the external and static symbols and puts them in partial
1191 symbol tables. When more extensive information is requested of a
1192 file, the corresponding partial symbol table is mutated into a full
1193 fledged symbol table by going back and reading the symbols
1196 We look for sections with specific names, to tell us what debug
1197 format to look for: FIXME!!!
1199 elfstab_build_psymtabs() handles STABS symbols;
1200 mdebug_build_psymtabs() handles ECOFF debugging information.
1202 Note that ELF files have a "minimal" symbol table, which looks a lot
1203 like a COFF symbol table, but has only the minimal information necessary
1204 for linking. We process this also, and use the information to
1205 build gdb's minimal symbol table. This gives us some minimal debugging
1206 capability even for files compiled without -g. */
1209 elf_symfile_read (struct objfile
*objfile
, symfile_add_flags symfile_flags
)
1211 bfd
*abfd
= objfile
->obfd
;
1213 bool has_dwarf2
= true;
1215 memset ((char *) &ei
, 0, sizeof (ei
));
1216 if (!(objfile
->flags
& OBJF_READNEVER
))
1217 bfd_map_over_sections (abfd
, elf_locate_sections
, (void *) & ei
);
1219 elf_read_minimal_symbols (objfile
, symfile_flags
, &ei
);
1221 /* ELF debugging information is inserted into the psymtab in the
1222 order of least informative first - most informative last. Since
1223 the psymtab table is searched `most recent insertion first' this
1224 increases the probability that more detailed debug information
1225 for a section is found.
1227 For instance, an object file might contain both .mdebug (XCOFF)
1228 and .debug_info (DWARF2) sections then .mdebug is inserted first
1229 (searched last) and DWARF2 is inserted last (searched first). If
1230 we don't do this then the XCOFF info is found first - for code in
1231 an included file XCOFF info is useless. */
1235 const struct ecoff_debug_swap
*swap
;
1237 /* .mdebug section, presumably holding ECOFF debugging
1239 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1241 elfmdebug_build_psymtabs (objfile
, swap
, ei
.mdebugsect
);
1247 /* Stab sections have an associated string table that looks like
1248 a separate section. */
1249 str_sect
= bfd_get_section_by_name (abfd
, ".stabstr");
1251 /* FIXME should probably warn about a stab section without a stabstr. */
1253 elfstab_build_psymtabs (objfile
,
1256 bfd_section_size (str_sect
));
1259 if (dwarf2_has_info (objfile
, NULL
, true))
1261 dw_index_kind index_kind
;
1263 /* elf_sym_fns_gdb_index cannot handle simultaneous non-DWARF
1264 debug information present in OBJFILE. If there is such debug
1265 info present never use an index. */
1266 if (!objfile_has_partial_symbols (objfile
)
1267 && dwarf2_initialize_objfile (objfile
, &index_kind
))
1271 case dw_index_kind::GDB_INDEX
:
1272 objfile_set_sym_fns (objfile
, &elf_sym_fns_gdb_index
);
1274 case dw_index_kind::DEBUG_NAMES
:
1275 objfile_set_sym_fns (objfile
, &elf_sym_fns_debug_names
);
1281 /* It is ok to do this even if the stabs reader made some
1282 partial symbols, because OBJF_PSYMTABS_READ has not been
1283 set, and so our lazy reader function will still be called
1285 objfile_set_sym_fns (objfile
, &elf_sym_fns_lazy_psyms
);
1288 /* If the file has its own symbol tables it has no separate debug
1289 info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to
1290 SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with
1291 `.note.gnu.build-id'.
1293 .gnu_debugdata is !objfile_has_partial_symbols because it contains only
1294 .symtab, not .debug_* section. But if we already added .gnu_debugdata as
1295 an objfile via find_separate_debug_file_in_section there was no separate
1296 debug info available. Therefore do not attempt to search for another one,
1297 objfile->separate_debug_objfile->separate_debug_objfile GDB guarantees to
1298 be NULL and we would possibly violate it. */
1300 else if (!objfile_has_partial_symbols (objfile
)
1301 && objfile
->separate_debug_objfile
== NULL
1302 && objfile
->separate_debug_objfile_backlink
== NULL
)
1304 std::string debugfile
= find_separate_debug_file_by_buildid (objfile
);
1306 if (debugfile
.empty ())
1307 debugfile
= find_separate_debug_file_by_debuglink (objfile
);
1309 if (!debugfile
.empty ())
1311 gdb_bfd_ref_ptr
debug_bfd (symfile_bfd_open (debugfile
.c_str ()));
1313 symbol_file_add_separate (debug_bfd
.get (), debugfile
.c_str (),
1314 symfile_flags
, objfile
);
1319 const struct bfd_build_id
*build_id
= build_id_bfd_get (objfile
->obfd
);
1321 if (build_id
!= nullptr)
1323 gdb::unique_xmalloc_ptr
<char> symfile_path
;
1324 scoped_fd
fd (debuginfod_debuginfo_query (build_id
->data
,
1326 objfile
->original_name
,
1331 /* File successfully retrieved from server. */
1332 gdb_bfd_ref_ptr
debug_bfd (symfile_bfd_open (symfile_path
.get ()));
1334 if (debug_bfd
== nullptr)
1335 warning (_("File \"%s\" from debuginfod cannot be opened as bfd"),
1336 objfile
->original_name
);
1337 else if (build_id_verify (debug_bfd
.get (), build_id
->size
, build_id
->data
))
1339 symbol_file_add_separate (debug_bfd
.get (), symfile_path
.get (),
1340 symfile_flags
, objfile
);
1348 /* Read the CTF section only if there is no DWARF info. */
1349 if (!has_dwarf2
&& ei
.ctfsect
)
1351 elfctf_build_psymtabs (objfile
);
1355 /* Callback to lazily read psymtabs. */
1358 read_psyms (struct objfile
*objfile
)
1360 if (dwarf2_has_info (objfile
, NULL
))
1361 dwarf2_build_psymtabs (objfile
);
1364 /* Initialize anything that needs initializing when a completely new symbol
1365 file is specified (not just adding some symbols from another file, e.g. a
1369 elf_new_init (struct objfile
*ignore
)
1373 /* Perform any local cleanups required when we are done with a particular
1374 objfile. I.E, we are in the process of discarding all symbol information
1375 for an objfile, freeing up all memory held for it, and unlinking the
1376 objfile struct from the global list of known objfiles. */
1379 elf_symfile_finish (struct objfile
*objfile
)
1383 /* ELF specific initialization routine for reading symbols. */
1386 elf_symfile_init (struct objfile
*objfile
)
1388 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
1389 find this causes a significant slowdown in gdb then we could
1390 set it in the debug symbol readers only when necessary. */
1391 objfile
->flags
|= OBJF_REORDERED
;
1394 /* Implementation of `sym_get_probes', as documented in symfile.h. */
1396 static const elfread_data
&
1397 elf_get_probes (struct objfile
*objfile
)
1399 elfread_data
*probes_per_bfd
= probe_key
.get (objfile
->obfd
);
1401 if (probes_per_bfd
== NULL
)
1403 probes_per_bfd
= probe_key
.emplace (objfile
->obfd
);
1405 /* Here we try to gather information about all types of probes from the
1407 for (const static_probe_ops
*ops
: all_static_probe_ops
)
1408 ops
->get_probes (probes_per_bfd
, objfile
);
1411 return *probes_per_bfd
;
1416 /* Implementation `sym_probe_fns', as documented in symfile.h. */
1418 static const struct sym_probe_fns elf_probe_fns
=
1420 elf_get_probes
, /* sym_get_probes */
1423 /* Register that we are able to handle ELF object file formats. */
1425 static const struct sym_fns elf_sym_fns
=
1427 elf_new_init
, /* init anything gbl to entire symtab */
1428 elf_symfile_init
, /* read initial info, setup for sym_read() */
1429 elf_symfile_read
, /* read a symbol file into symtab */
1430 NULL
, /* sym_read_psymbols */
1431 elf_symfile_finish
, /* finished with file, cleanup */
1432 default_symfile_offsets
, /* Translate ext. to int. relocation */
1433 elf_symfile_segments
, /* Get segment information from a file. */
1435 default_symfile_relocate
, /* Relocate a debug section. */
1436 &elf_probe_fns
, /* sym_probe_fns */
1440 /* The same as elf_sym_fns, but not registered and lazily reads
1443 const struct sym_fns elf_sym_fns_lazy_psyms
=
1445 elf_new_init
, /* init anything gbl to entire symtab */
1446 elf_symfile_init
, /* read initial info, setup for sym_read() */
1447 elf_symfile_read
, /* read a symbol file into symtab */
1448 read_psyms
, /* sym_read_psymbols */
1449 elf_symfile_finish
, /* finished with file, cleanup */
1450 default_symfile_offsets
, /* Translate ext. to int. relocation */
1451 elf_symfile_segments
, /* Get segment information from a file. */
1453 default_symfile_relocate
, /* Relocate a debug section. */
1454 &elf_probe_fns
, /* sym_probe_fns */
1458 /* The same as elf_sym_fns, but not registered and uses the
1459 DWARF-specific GNU index rather than psymtab. */
1460 const struct sym_fns elf_sym_fns_gdb_index
=
1462 elf_new_init
, /* init anything gbl to entire symab */
1463 elf_symfile_init
, /* read initial info, setup for sym_red() */
1464 elf_symfile_read
, /* read a symbol file into symtab */
1465 NULL
, /* sym_read_psymbols */
1466 elf_symfile_finish
, /* finished with file, cleanup */
1467 default_symfile_offsets
, /* Translate ext. to int. relocation */
1468 elf_symfile_segments
, /* Get segment information from a file. */
1470 default_symfile_relocate
, /* Relocate a debug section. */
1471 &elf_probe_fns
, /* sym_probe_fns */
1472 &dwarf2_gdb_index_functions
1475 /* The same as elf_sym_fns, but not registered and uses the
1476 DWARF-specific .debug_names index rather than psymtab. */
1477 const struct sym_fns elf_sym_fns_debug_names
=
1479 elf_new_init
, /* init anything gbl to entire symab */
1480 elf_symfile_init
, /* read initial info, setup for sym_red() */
1481 elf_symfile_read
, /* read a symbol file into symtab */
1482 NULL
, /* sym_read_psymbols */
1483 elf_symfile_finish
, /* finished with file, cleanup */
1484 default_symfile_offsets
, /* Translate ext. to int. relocation */
1485 elf_symfile_segments
, /* Get segment information from a file. */
1487 default_symfile_relocate
, /* Relocate a debug section. */
1488 &elf_probe_fns
, /* sym_probe_fns */
1489 &dwarf2_debug_names_functions
1492 /* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */
1494 static const struct gnu_ifunc_fns elf_gnu_ifunc_fns
=
1496 elf_gnu_ifunc_resolve_addr
,
1497 elf_gnu_ifunc_resolve_name
,
1498 elf_gnu_ifunc_resolver_stop
,
1499 elf_gnu_ifunc_resolver_return_stop
1502 void _initialize_elfread ();
1504 _initialize_elfread ()
1506 add_symtab_fns (bfd_target_elf_flavour
, &elf_sym_fns
);
1508 gnu_ifunc_fns_p
= &elf_gnu_ifunc_fns
;