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