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