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