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