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