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