1 /* Read ELF (Executable and Linking Format) object files for GDB.
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.
7 Written by Fred Fish at Cygnus Support.
9 This file is part of GDB.
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.
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.
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/>. */
26 #include "gdb_string.h"
28 #include "elf/common.h"
29 #include "elf/internal.h"
35 #include "stabsread.h"
36 #include "gdb-stabs.h"
37 #include "complaints.h"
40 #include "filenames.h"
45 extern void _initialize_elfread (void);
47 /* Forward declarations. */
48 static const struct sym_fns elf_sym_fns_gdb_index;
49 static const struct sym_fns elf_sym_fns_lazy_psyms;
51 /* The struct elfinfo is available only during ELF symbol table and
52 psymtab reading. It is destroyed at the completion of psymtab-reading.
53 It's local to elf_symfile_read. */
57 asection *stabsect; /* Section pointer for .stab section */
58 asection *stabindexsect; /* Section pointer for .stab.index section */
59 asection *mdebugsect; /* Section pointer for .mdebug section */
62 static void free_elfinfo (void *);
64 /* Minimal symbols located at the GOT entries for .plt - that is the real
65 pointer where the given entry will jump to. It gets updated by the real
66 function address during lazy ld.so resolving in the inferior. These
67 minimal symbols are indexed for <tab>-completion. */
69 #define SYMBOL_GOT_PLT_SUFFIX "@got.plt"
71 /* Locate the segments in ABFD. */
73 static struct symfile_segment_data *
74 elf_symfile_segments (bfd *abfd)
76 Elf_Internal_Phdr *phdrs, **segments;
78 int num_phdrs, num_segments, num_sections, i;
80 struct symfile_segment_data *data;
82 phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
86 phdrs = alloca (phdrs_size);
87 num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
92 segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
93 for (i = 0; i < num_phdrs; i++)
94 if (phdrs[i].p_type == PT_LOAD)
95 segments[num_segments++] = &phdrs[i];
97 if (num_segments == 0)
100 data = XZALLOC (struct symfile_segment_data);
101 data->num_segments = num_segments;
102 data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
103 data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
105 for (i = 0; i < num_segments; i++)
107 data->segment_bases[i] = segments[i]->p_vaddr;
108 data->segment_sizes[i] = segments[i]->p_memsz;
111 num_sections = bfd_count_sections (abfd);
112 data->segment_info = XCALLOC (num_sections, int);
114 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
119 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
122 vma = bfd_get_section_vma (abfd, sect);
124 for (j = 0; j < num_segments; j++)
125 if (segments[j]->p_memsz > 0
126 && vma >= segments[j]->p_vaddr
127 && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz)
129 data->segment_info[i] = j + 1;
133 /* We should have found a segment for every non-empty section.
134 If we haven't, we will not relocate this section by any
135 offsets we apply to the segments. As an exception, do not
136 warn about SHT_NOBITS sections; in normal ELF execution
137 environments, SHT_NOBITS means zero-initialized and belongs
138 in a segment, but in no-OS environments some tools (e.g. ARM
139 RealView) use SHT_NOBITS for uninitialized data. Since it is
140 uninitialized, it doesn't need a program header. Such
141 binaries are not relocatable. */
142 if (bfd_get_section_size (sect) > 0 && j == num_segments
143 && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
144 warning (_("Loadable segment \"%s\" outside of ELF segments"),
145 bfd_section_name (abfd, sect));
151 /* We are called once per section from elf_symfile_read. We
152 need to examine each section we are passed, check to see
153 if it is something we are interested in processing, and
154 if so, stash away some access information for the section.
156 For now we recognize the dwarf debug information sections and
157 line number sections from matching their section names. The
158 ELF definition is no real help here since it has no direct
159 knowledge of DWARF (by design, so any debugging format can be
162 We also recognize the ".stab" sections used by the Sun compilers
163 released with Solaris 2.
165 FIXME: The section names should not be hardwired strings (what
166 should they be? I don't think most object file formats have enough
167 section flags to specify what kind of debug section it is.
171 elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
175 ei = (struct elfinfo *) eip;
176 if (strcmp (sectp->name, ".stab") == 0)
178 ei->stabsect = sectp;
180 else if (strcmp (sectp->name, ".stab.index") == 0)
182 ei->stabindexsect = sectp;
184 else if (strcmp (sectp->name, ".mdebug") == 0)
186 ei->mdebugsect = sectp;
190 static struct minimal_symbol *
191 record_minimal_symbol (const char *name, int name_len, int copy_name,
193 enum minimal_symbol_type ms_type,
194 asection *bfd_section, struct objfile *objfile)
196 struct gdbarch *gdbarch = get_objfile_arch (objfile);
198 if (ms_type == mst_text || ms_type == mst_file_text
199 || ms_type == mst_text_gnu_ifunc)
200 address = gdbarch_smash_text_address (gdbarch, address);
202 return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
203 ms_type, bfd_section->index,
204 bfd_section, objfile);
211 elf_symtab_read -- read the symbol table of an ELF file
215 void elf_symtab_read (struct objfile *objfile, int type,
216 long number_of_symbols, asymbol **symbol_table)
220 Given an objfile, a symbol table, and a flag indicating whether the
221 symbol table contains regular, dynamic, or synthetic symbols, add all
222 the global function and data symbols to the minimal symbol table.
224 In stabs-in-ELF, as implemented by Sun, there are some local symbols
225 defined in the ELF symbol table, which can be used to locate
226 the beginnings of sections from each ".o" file that was linked to
227 form the executable objfile. We gather any such info and record it
228 in data structures hung off the objfile's private data.
234 #define ST_SYNTHETIC 2
237 elf_symtab_read (struct objfile *objfile, int type,
238 long number_of_symbols, asymbol **symbol_table,
241 struct gdbarch *gdbarch = get_objfile_arch (objfile);
246 enum minimal_symbol_type ms_type;
247 /* If sectinfo is nonNULL, it contains section info that should end up
248 filed in the objfile. */
249 struct stab_section_info *sectinfo = NULL;
250 /* If filesym is nonzero, it points to a file symbol, but we haven't
251 seen any section info for it yet. */
252 asymbol *filesym = 0;
253 /* Name of filesym. This is either a constant string or is saved on
254 the objfile's obstack. */
255 char *filesymname = "";
256 struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
257 int stripped = (bfd_get_symcount (objfile->obfd) == 0);
258 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
260 for (i = 0; i < number_of_symbols; i++)
262 sym = symbol_table[i];
263 if (sym->name == NULL || *sym->name == '\0')
265 /* Skip names that don't exist (shouldn't happen), or names
266 that are null strings (may happen). */
270 /* Skip "special" symbols, e.g. ARM mapping symbols. These are
271 symbols which do not correspond to objects in the symbol table,
272 but have some other target-specific meaning. */
273 if (bfd_is_target_special_symbol (objfile->obfd, sym))
275 if (gdbarch_record_special_symbol_p (gdbarch))
276 gdbarch_record_special_symbol (gdbarch, objfile, sym);
280 offset = ANOFFSET (objfile->section_offsets, sym->section->index);
281 if (type == ST_DYNAMIC
282 && sym->section == &bfd_und_section
283 && (sym->flags & BSF_FUNCTION))
285 struct minimal_symbol *msym;
286 bfd *abfd = objfile->obfd;
289 /* Symbol is a reference to a function defined in
291 If its value is non zero then it is usually the address
292 of the corresponding entry in the procedure linkage table,
293 plus the desired section offset.
294 If its value is zero then the dynamic linker has to resolve
295 the symbol. We are unable to find any meaningful address
296 for this symbol in the executable file, so we skip it. */
297 symaddr = sym->value;
301 /* sym->section is the undefined section. However, we want to
302 record the section where the PLT stub resides with the
303 minimal symbol. Search the section table for the one that
304 covers the stub's address. */
305 for (sect = abfd->sections; sect != NULL; sect = sect->next)
307 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
310 if (symaddr >= bfd_get_section_vma (abfd, sect)
311 && symaddr < bfd_get_section_vma (abfd, sect)
312 + bfd_get_section_size (sect))
318 symaddr += ANOFFSET (objfile->section_offsets, sect->index);
320 msym = record_minimal_symbol
321 (sym->name, strlen (sym->name), copy_names,
322 symaddr, mst_solib_trampoline, sect, objfile);
324 msym->filename = filesymname;
328 /* If it is a nonstripped executable, do not enter dynamic
329 symbols, as the dynamic symbol table is usually a subset
330 of the main symbol table. */
331 if (type == ST_DYNAMIC && !stripped)
333 if (sym->flags & BSF_FILE)
335 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
336 Chain any old one onto the objfile; remember new sym. */
337 if (sectinfo != NULL)
339 sectinfo->next = dbx->stab_section_info;
340 dbx->stab_section_info = sectinfo;
345 obsavestring ((char *) filesym->name, strlen (filesym->name),
346 &objfile->objfile_obstack);
348 else if (sym->flags & BSF_SECTION_SYM)
350 else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
352 struct minimal_symbol *msym;
354 /* Select global/local/weak symbols. Note that bfd puts abs
355 symbols in their own section, so all symbols we are
356 interested in will have a section. */
357 /* Bfd symbols are section relative. */
358 symaddr = sym->value + sym->section->vma;
359 /* Relocate all non-absolute and non-TLS symbols by the
361 if (sym->section != &bfd_abs_section
362 && !(sym->section->flags & SEC_THREAD_LOCAL))
366 /* For non-absolute symbols, use the type of the section
367 they are relative to, to intuit text/data. Bfd provides
368 no way of figuring this out for absolute symbols. */
369 if (sym->section == &bfd_abs_section)
371 /* This is a hack to get the minimal symbol type
372 right for Irix 5, which has absolute addresses
373 with special section indices for dynamic symbols.
375 NOTE: uweigand-20071112: Synthetic symbols do not
376 have an ELF-private part, so do not touch those. */
377 unsigned int shndx = type == ST_SYNTHETIC ? 0 :
378 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
388 case SHN_MIPS_ACOMMON:
395 /* If it is an Irix dynamic symbol, skip section name
396 symbols, relocate all others by section offset. */
397 if (ms_type != mst_abs)
399 if (sym->name[0] == '.')
404 else if (sym->section->flags & SEC_CODE)
406 if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
408 if (sym->flags & BSF_GNU_INDIRECT_FUNCTION)
409 ms_type = mst_text_gnu_ifunc;
413 else if ((sym->name[0] == '.' && sym->name[1] == 'L')
414 || ((sym->flags & BSF_LOCAL)
415 && sym->name[0] == '$'
416 && sym->name[1] == 'L'))
417 /* Looks like a compiler-generated label. Skip
418 it. The assembler should be skipping these (to
419 keep executables small), but apparently with
420 gcc on the (deleted) delta m88k SVR4, it loses.
421 So to have us check too should be harmless (but
422 I encourage people to fix this in the assembler
423 instead of adding checks here). */
427 ms_type = mst_file_text;
430 else if (sym->section->flags & SEC_ALLOC)
432 if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
434 if (sym->section->flags & SEC_LOAD)
443 else if (sym->flags & BSF_LOCAL)
445 /* Named Local variable in a Data section.
446 Check its name for stabs-in-elf. */
447 int special_local_sect;
449 if (strcmp ("Bbss.bss", sym->name) == 0)
450 special_local_sect = SECT_OFF_BSS (objfile);
451 else if (strcmp ("Ddata.data", sym->name) == 0)
452 special_local_sect = SECT_OFF_DATA (objfile);
453 else if (strcmp ("Drodata.rodata", sym->name) == 0)
454 special_local_sect = SECT_OFF_RODATA (objfile);
456 special_local_sect = -1;
457 if (special_local_sect >= 0)
459 /* Found a special local symbol. Allocate a
460 sectinfo, if needed, and fill it in. */
461 if (sectinfo == NULL)
466 max_index = SECT_OFF_BSS (objfile);
467 if (objfile->sect_index_data > max_index)
468 max_index = objfile->sect_index_data;
469 if (objfile->sect_index_rodata > max_index)
470 max_index = objfile->sect_index_rodata;
472 /* max_index is the largest index we'll
473 use into this array, so we must
474 allocate max_index+1 elements for it.
475 However, 'struct stab_section_info'
476 already includes one element, so we
477 need to allocate max_index aadditional
479 size = (sizeof (struct stab_section_info)
480 + (sizeof (CORE_ADDR) * max_index));
481 sectinfo = (struct stab_section_info *)
483 make_cleanup (xfree, sectinfo);
484 memset (sectinfo, 0, size);
485 sectinfo->num_sections = max_index;
488 complaint (&symfile_complaints,
489 _("elf/stab section information %s "
490 "without a preceding file symbol"),
496 (char *) filesym->name;
499 if (sectinfo->sections[special_local_sect] != 0)
500 complaint (&symfile_complaints,
501 _("duplicated elf/stab section "
502 "information for %s"),
504 /* BFD symbols are section relative. */
505 symaddr = sym->value + sym->section->vma;
506 /* Relocate non-absolute symbols by the
508 if (sym->section != &bfd_abs_section)
510 sectinfo->sections[special_local_sect] = symaddr;
511 /* The special local symbols don't go in the
512 minimal symbol table, so ignore this one. */
515 /* Not a special stabs-in-elf symbol, do regular
516 symbol processing. */
517 if (sym->section->flags & SEC_LOAD)
519 ms_type = mst_file_data;
523 ms_type = mst_file_bss;
528 ms_type = mst_unknown;
533 /* FIXME: Solaris2 shared libraries include lots of
534 odd "absolute" and "undefined" symbols, that play
535 hob with actions like finding what function the PC
536 is in. Ignore them if they aren't text, data, or bss. */
537 /* ms_type = mst_unknown; */
538 continue; /* Skip this symbol. */
540 msym = record_minimal_symbol
541 (sym->name, strlen (sym->name), copy_names, symaddr,
542 ms_type, sym->section, objfile);
546 /* Pass symbol size field in via BFD. FIXME!!! */
547 elf_symbol_type *elf_sym;
549 /* NOTE: uweigand-20071112: A synthetic symbol does not have an
550 ELF-private part. However, in some cases (e.g. synthetic
551 'dot' symbols on ppc64) the udata.p entry is set to point back
552 to the original ELF symbol it was derived from. Get the size
554 if (type != ST_SYNTHETIC)
555 elf_sym = (elf_symbol_type *) sym;
557 elf_sym = (elf_symbol_type *) sym->udata.p;
560 MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
562 msym->filename = filesymname;
563 gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
566 /* For @plt symbols, also record a trampoline to the
567 destination symbol. The @plt symbol will be used in
568 disassembly, and the trampoline will be used when we are
569 trying to find the target. */
570 if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
572 int len = strlen (sym->name);
574 if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
576 struct minimal_symbol *mtramp;
578 mtramp = record_minimal_symbol (sym->name, len - 4, 1,
580 mst_solib_trampoline,
581 sym->section, objfile);
584 MSYMBOL_SIZE (mtramp) = MSYMBOL_SIZE (msym);
585 mtramp->filename = filesymname;
586 gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
592 do_cleanups (back_to);
595 /* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX)
596 for later look ups of which function to call when user requests
597 a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target
598 library defining `function' we cannot yet know while reading OBJFILE which
599 of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later
600 DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */
603 elf_rel_plt_read (struct objfile *objfile, asymbol **dyn_symbol_table)
605 bfd *obfd = objfile->obfd;
606 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
607 asection *plt, *relplt, *got_plt;
610 bfd_size_type reloc_count, reloc;
611 char *string_buffer = NULL;
612 size_t string_buffer_size = 0;
613 struct cleanup *back_to;
614 struct gdbarch *gdbarch = objfile->gdbarch;
615 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
616 size_t ptr_size = TYPE_LENGTH (ptr_type);
618 if (objfile->separate_debug_objfile_backlink)
621 plt = bfd_get_section_by_name (obfd, ".plt");
624 plt_elf_idx = elf_section_data (plt)->this_idx;
626 got_plt = bfd_get_section_by_name (obfd, ".got.plt");
630 /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */
631 for (relplt = obfd->sections; relplt != NULL; relplt = relplt->next)
632 if (elf_section_data (relplt)->this_hdr.sh_info == plt_elf_idx
633 && (elf_section_data (relplt)->this_hdr.sh_type == SHT_REL
634 || elf_section_data (relplt)->this_hdr.sh_type == SHT_RELA))
639 if (! bed->s->slurp_reloc_table (obfd, relplt, dyn_symbol_table, TRUE))
642 back_to = make_cleanup (free_current_contents, &string_buffer);
644 reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize;
645 for (reloc = 0; reloc < reloc_count; reloc++)
647 const char *name, *name_got_plt;
648 struct minimal_symbol *msym;
650 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
653 name = bfd_asymbol_name (*relplt->relocation[reloc].sym_ptr_ptr);
654 name_len = strlen (name);
655 address = relplt->relocation[reloc].address;
657 /* Does the pointer reside in the .got.plt section? */
658 if (!(bfd_get_section_vma (obfd, got_plt) <= address
659 && address < bfd_get_section_vma (obfd, got_plt)
660 + bfd_get_section_size (got_plt)))
663 /* We cannot check if NAME is a reference to mst_text_gnu_ifunc as in
664 OBJFILE the symbol is undefined and the objfile having NAME defined
665 may not yet have been loaded. */
667 if (string_buffer_size < name_len + got_suffix_len)
669 string_buffer_size = 2 * (name_len + got_suffix_len);
670 string_buffer = xrealloc (string_buffer, string_buffer_size);
672 memcpy (string_buffer, name, name_len);
673 memcpy (&string_buffer[name_len], SYMBOL_GOT_PLT_SUFFIX,
676 msym = record_minimal_symbol (string_buffer, name_len + got_suffix_len,
677 1, address, mst_slot_got_plt, got_plt,
680 MSYMBOL_SIZE (msym) = ptr_size;
683 do_cleanups (back_to);
686 /* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */
688 static const struct objfile_data *elf_objfile_gnu_ifunc_cache_data;
690 /* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */
692 struct elf_gnu_ifunc_cache
694 /* This is always a function entry address, not a function descriptor. */
700 /* htab_hash for elf_objfile_gnu_ifunc_cache_data. */
703 elf_gnu_ifunc_cache_hash (const void *a_voidp)
705 const struct elf_gnu_ifunc_cache *a = a_voidp;
707 return htab_hash_string (a->name);
710 /* htab_eq for elf_objfile_gnu_ifunc_cache_data. */
713 elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp)
715 const struct elf_gnu_ifunc_cache *a = a_voidp;
716 const struct elf_gnu_ifunc_cache *b = b_voidp;
718 return strcmp (a->name, b->name) == 0;
721 /* Record the target function address of a STT_GNU_IFUNC function NAME is the
722 function entry address ADDR. Return 1 if NAME and ADDR are considered as
723 valid and therefore they were successfully recorded, return 0 otherwise.
725 Function does not expect a duplicate entry. Use
726 elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already
730 elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
732 struct minimal_symbol *msym;
734 struct objfile *objfile;
736 struct elf_gnu_ifunc_cache entry_local, *entry_p;
739 msym = lookup_minimal_symbol_by_pc (addr);
742 if (SYMBOL_VALUE_ADDRESS (msym) != addr)
744 /* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL. */
745 sect = SYMBOL_OBJ_SECTION (msym)->the_bfd_section;
746 objfile = SYMBOL_OBJ_SECTION (msym)->objfile;
748 /* If .plt jumps back to .plt the symbol is still deferred for later
749 resolution and it has no use for GDB. Besides ".text" this symbol can
750 reside also in ".opd" for ppc64 function descriptor. */
751 if (strcmp (bfd_get_section_name (objfile->obfd, sect), ".plt") == 0)
754 htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
757 htab = htab_create_alloc_ex (1, elf_gnu_ifunc_cache_hash,
758 elf_gnu_ifunc_cache_eq,
759 NULL, &objfile->objfile_obstack,
760 hashtab_obstack_allocate,
761 dummy_obstack_deallocate);
762 set_objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data, htab);
765 entry_local.addr = addr;
766 obstack_grow (&objfile->objfile_obstack, &entry_local,
767 offsetof (struct elf_gnu_ifunc_cache, name));
768 obstack_grow_str0 (&objfile->objfile_obstack, name);
769 entry_p = obstack_finish (&objfile->objfile_obstack);
771 slot = htab_find_slot (htab, entry_p, INSERT);
774 struct elf_gnu_ifunc_cache *entry_found_p = *slot;
775 struct gdbarch *gdbarch = objfile->gdbarch;
777 if (entry_found_p->addr != addr)
779 /* This case indicates buggy inferior program, the resolved address
780 should never change. */
782 warning (_("gnu-indirect-function \"%s\" has changed its resolved "
783 "function_address from %s to %s"),
784 name, paddress (gdbarch, entry_found_p->addr),
785 paddress (gdbarch, addr));
788 /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */
795 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
796 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
797 is not NULL) and the function returns 1. It returns 0 otherwise.
799 Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this
803 elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p)
805 struct objfile *objfile;
807 ALL_PSPACE_OBJFILES (current_program_space, objfile)
810 struct elf_gnu_ifunc_cache *entry_p;
813 htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
817 entry_p = alloca (sizeof (*entry_p) + strlen (name));
818 strcpy (entry_p->name, name);
820 slot = htab_find_slot (htab, entry_p, NO_INSERT);
824 gdb_assert (entry_p != NULL);
827 *addr_p = entry_p->addr;
834 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
835 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
836 is not NULL) and the function returns 1. It returns 0 otherwise.
838 Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function.
839 elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to
840 prevent cache entries duplicates. */
843 elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p)
846 struct objfile *objfile;
847 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
849 name_got_plt = alloca (strlen (name) + got_suffix_len + 1);
850 sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name);
852 ALL_PSPACE_OBJFILES (current_program_space, objfile)
854 bfd *obfd = objfile->obfd;
855 struct gdbarch *gdbarch = objfile->gdbarch;
856 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
857 size_t ptr_size = TYPE_LENGTH (ptr_type);
858 CORE_ADDR pointer_address, addr;
860 gdb_byte *buf = alloca (ptr_size);
861 struct minimal_symbol *msym;
863 msym = lookup_minimal_symbol (name_got_plt, NULL, objfile);
866 if (MSYMBOL_TYPE (msym) != mst_slot_got_plt)
868 pointer_address = SYMBOL_VALUE_ADDRESS (msym);
870 plt = bfd_get_section_by_name (obfd, ".plt");
874 if (MSYMBOL_SIZE (msym) != ptr_size)
876 if (target_read_memory (pointer_address, buf, ptr_size) != 0)
878 addr = extract_typed_address (buf, ptr_type);
879 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
884 if (elf_gnu_ifunc_record_cache (name, addr))
891 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
892 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
893 is not NULL) and the function returns 1. It returns 0 otherwise.
895 Both the elf_objfile_gnu_ifunc_cache_data hash table and
896 SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */
899 elf_gnu_ifunc_resolve_name (const char *name, CORE_ADDR *addr_p)
901 if (elf_gnu_ifunc_resolve_by_cache (name, addr_p))
904 if (elf_gnu_ifunc_resolve_by_got (name, addr_p))
910 /* Call STT_GNU_IFUNC - a function returning addresss of a real function to
911 call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned
912 is the entry point of the resolved STT_GNU_IFUNC target function to call.
916 elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
919 CORE_ADDR start_at_pc, address;
920 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
921 struct value *function, *address_val;
923 /* Try first any non-intrusive methods without an inferior call. */
925 if (find_pc_partial_function (pc, &name_at_pc, &start_at_pc, NULL)
926 && start_at_pc == pc)
928 if (elf_gnu_ifunc_resolve_name (name_at_pc, &address))
934 function = allocate_value (func_func_type);
935 set_value_address (function, pc);
937 /* STT_GNU_IFUNC resolver functions have no parameters. FUNCTION is the
938 function entry address. ADDRESS may be a function descriptor. */
940 address_val = call_function_by_hand (function, 0, NULL);
941 address = value_as_address (address_val);
942 address = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
946 elf_gnu_ifunc_record_cache (name_at_pc, address);
957 /* Locate NT_GNU_BUILD_ID from ABFD and return its content. */
959 static struct build_id *
960 build_id_bfd_get (bfd *abfd)
962 struct build_id *retval;
964 if (!bfd_check_format (abfd, bfd_object)
965 || bfd_get_flavour (abfd) != bfd_target_elf_flavour
966 || elf_tdata (abfd)->build_id == NULL)
969 retval = xmalloc (sizeof *retval - 1 + elf_tdata (abfd)->build_id_size);
970 retval->size = elf_tdata (abfd)->build_id_size;
971 memcpy (retval->data, elf_tdata (abfd)->build_id, retval->size);
976 /* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */
979 build_id_verify (const char *filename, struct build_id *check)
982 struct build_id *found = NULL;
985 /* We expect to be silent on the non-existing files. */
986 abfd = bfd_open_maybe_remote (filename);
990 found = build_id_bfd_get (abfd);
993 warning (_("File \"%s\" has no build-id, file skipped"), filename);
994 else if (found->size != check->size
995 || memcmp (found->data, check->data, found->size) != 0)
996 warning (_("File \"%s\" has a different build-id, file skipped"),
1001 gdb_bfd_close_or_warn (abfd);
1009 build_id_to_debug_filename (struct build_id *build_id)
1011 char *link, *debugdir, *retval = NULL;
1013 /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
1014 link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
1015 + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
1017 /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1018 cause "/.build-id/..." lookups. */
1020 debugdir = debug_file_directory;
1023 char *s, *debugdir_end;
1024 gdb_byte *data = build_id->data;
1025 size_t size = build_id->size;
1027 while (*debugdir == DIRNAME_SEPARATOR)
1030 debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
1031 if (debugdir_end == NULL)
1032 debugdir_end = &debugdir[strlen (debugdir)];
1034 memcpy (link, debugdir, debugdir_end - debugdir);
1035 s = &link[debugdir_end - debugdir];
1036 s += sprintf (s, "/.build-id/");
1040 s += sprintf (s, "%02x", (unsigned) *data++);
1045 s += sprintf (s, "%02x", (unsigned) *data++);
1046 strcpy (s, ".debug");
1048 /* lrealpath() is expensive even for the usually non-existent files. */
1049 if (access (link, F_OK) == 0)
1050 retval = lrealpath (link);
1052 if (retval != NULL && !build_id_verify (retval, build_id))
1061 debugdir = debugdir_end;
1063 while (*debugdir != 0);
1069 find_separate_debug_file_by_buildid (struct objfile *objfile)
1071 struct build_id *build_id;
1073 build_id = build_id_bfd_get (objfile->obfd);
1074 if (build_id != NULL)
1076 char *build_id_name;
1078 build_id_name = build_id_to_debug_filename (build_id);
1080 /* Prevent looping on a stripped .debug file. */
1081 if (build_id_name != NULL
1082 && filename_cmp (build_id_name, objfile->name) == 0)
1084 warning (_("\"%s\": separate debug info file has no debug info"),
1086 xfree (build_id_name);
1088 else if (build_id_name != NULL)
1089 return build_id_name;
1094 /* Scan and build partial symbols for a symbol file.
1095 We have been initialized by a call to elf_symfile_init, which
1096 currently does nothing.
1098 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
1099 in each section. We simplify it down to a single offset for all
1102 This function only does the minimum work necessary for letting the
1103 user "name" things symbolically; it does not read the entire symtab.
1104 Instead, it reads the external and static symbols and puts them in partial
1105 symbol tables. When more extensive information is requested of a
1106 file, the corresponding partial symbol table is mutated into a full
1107 fledged symbol table by going back and reading the symbols
1110 We look for sections with specific names, to tell us what debug
1111 format to look for: FIXME!!!
1113 elfstab_build_psymtabs() handles STABS symbols;
1114 mdebug_build_psymtabs() handles ECOFF debugging information.
1116 Note that ELF files have a "minimal" symbol table, which looks a lot
1117 like a COFF symbol table, but has only the minimal information necessary
1118 for linking. We process this also, and use the information to
1119 build gdb's minimal symbol table. This gives us some minimal debugging
1120 capability even for files compiled without -g. */
1123 elf_symfile_read (struct objfile *objfile, int symfile_flags)
1125 bfd *abfd = objfile->obfd;
1127 struct cleanup *back_to;
1128 long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
1129 asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
1132 init_minimal_symbol_collection ();
1133 back_to = make_cleanup_discard_minimal_symbols ();
1135 memset ((char *) &ei, 0, sizeof (ei));
1137 /* Allocate struct to keep track of the symfile. */
1138 objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
1139 xmalloc (sizeof (struct dbx_symfile_info));
1140 memset ((char *) objfile->deprecated_sym_stab_info,
1141 0, sizeof (struct dbx_symfile_info));
1142 make_cleanup (free_elfinfo, (void *) objfile);
1144 /* Process the normal ELF symbol table first. This may write some
1145 chain of info into the dbx_symfile_info in
1146 objfile->deprecated_sym_stab_info, which can later be used by
1147 elfstab_offset_sections. */
1149 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
1150 if (storage_needed < 0)
1151 error (_("Can't read symbols from %s: %s"),
1152 bfd_get_filename (objfile->obfd),
1153 bfd_errmsg (bfd_get_error ()));
1155 if (storage_needed > 0)
1157 symbol_table = (asymbol **) xmalloc (storage_needed);
1158 make_cleanup (xfree, symbol_table);
1159 symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
1162 error (_("Can't read symbols from %s: %s"),
1163 bfd_get_filename (objfile->obfd),
1164 bfd_errmsg (bfd_get_error ()));
1166 elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
1169 /* Add the dynamic symbols. */
1171 storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
1173 if (storage_needed > 0)
1175 /* Memory gets permanently referenced from ABFD after
1176 bfd_get_synthetic_symtab so it must not get freed before ABFD gets.
1177 It happens only in the case when elf_slurp_reloc_table sees
1178 asection->relocation NULL. Determining which section is asection is
1179 done by _bfd_elf_get_synthetic_symtab which is all a bfd
1180 implementation detail, though. */
1182 dyn_symbol_table = bfd_alloc (abfd, storage_needed);
1183 dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
1186 if (dynsymcount < 0)
1187 error (_("Can't read symbols from %s: %s"),
1188 bfd_get_filename (objfile->obfd),
1189 bfd_errmsg (bfd_get_error ()));
1191 elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
1193 elf_rel_plt_read (objfile, dyn_symbol_table);
1196 /* Add synthetic symbols - for instance, names for any PLT entries. */
1198 synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
1199 dynsymcount, dyn_symbol_table,
1203 asymbol **synth_symbol_table;
1206 make_cleanup (xfree, synthsyms);
1207 synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
1208 for (i = 0; i < synthcount; i++)
1209 synth_symbol_table[i] = synthsyms + i;
1210 make_cleanup (xfree, synth_symbol_table);
1211 elf_symtab_read (objfile, ST_SYNTHETIC, synthcount,
1212 synth_symbol_table, 1);
1215 /* Install any minimal symbols that have been collected as the current
1216 minimal symbols for this objfile. The debug readers below this point
1217 should not generate new minimal symbols; if they do it's their
1218 responsibility to install them. "mdebug" appears to be the only one
1219 which will do this. */
1221 install_minimal_symbols (objfile);
1222 do_cleanups (back_to);
1224 /* Now process debugging information, which is contained in
1225 special ELF sections. */
1227 /* We first have to find them... */
1228 bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
1230 /* ELF debugging information is inserted into the psymtab in the
1231 order of least informative first - most informative last. Since
1232 the psymtab table is searched `most recent insertion first' this
1233 increases the probability that more detailed debug information
1234 for a section is found.
1236 For instance, an object file might contain both .mdebug (XCOFF)
1237 and .debug_info (DWARF2) sections then .mdebug is inserted first
1238 (searched last) and DWARF2 is inserted last (searched first). If
1239 we don't do this then the XCOFF info is found first - for code in
1240 an included file XCOFF info is useless. */
1244 const struct ecoff_debug_swap *swap;
1246 /* .mdebug section, presumably holding ECOFF debugging
1248 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1250 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
1256 /* Stab sections have an associated string table that looks like
1257 a separate section. */
1258 str_sect = bfd_get_section_by_name (abfd, ".stabstr");
1260 /* FIXME should probably warn about a stab section without a stabstr. */
1262 elfstab_build_psymtabs (objfile,
1265 bfd_section_size (abfd, str_sect));
1268 if (dwarf2_has_info (objfile))
1270 if (dwarf2_initialize_objfile (objfile))
1271 objfile->sf = &elf_sym_fns_gdb_index;
1274 /* It is ok to do this even if the stabs reader made some
1275 partial symbols, because OBJF_PSYMTABS_READ has not been
1276 set, and so our lazy reader function will still be called
1278 objfile->sf = &elf_sym_fns_lazy_psyms;
1281 /* If the file has its own symbol tables it has no separate debug
1282 info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to
1283 SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with
1284 `.note.gnu.build-id'. */
1285 else if (!objfile_has_partial_symbols (objfile))
1289 debugfile = find_separate_debug_file_by_buildid (objfile);
1291 if (debugfile == NULL)
1292 debugfile = find_separate_debug_file_by_debuglink (objfile);
1296 bfd *abfd = symfile_bfd_open (debugfile);
1298 symbol_file_add_separate (abfd, symfile_flags, objfile);
1304 /* Callback to lazily read psymtabs. */
1307 read_psyms (struct objfile *objfile)
1309 if (dwarf2_has_info (objfile))
1310 dwarf2_build_psymtabs (objfile);
1313 /* This cleans up the objfile's deprecated_sym_stab_info pointer, and
1314 the chain of stab_section_info's, that might be dangling from
1318 free_elfinfo (void *objp)
1320 struct objfile *objfile = (struct objfile *) objp;
1321 struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
1322 struct stab_section_info *ssi, *nssi;
1324 ssi = dbxinfo->stab_section_info;
1332 dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */
1336 /* Initialize anything that needs initializing when a completely new symbol
1337 file is specified (not just adding some symbols from another file, e.g. a
1340 We reinitialize buildsym, since we may be reading stabs from an ELF
1344 elf_new_init (struct objfile *ignore)
1346 stabsread_new_init ();
1347 buildsym_new_init ();
1350 /* Perform any local cleanups required when we are done with a particular
1351 objfile. I.E, we are in the process of discarding all symbol information
1352 for an objfile, freeing up all memory held for it, and unlinking the
1353 objfile struct from the global list of known objfiles. */
1356 elf_symfile_finish (struct objfile *objfile)
1358 if (objfile->deprecated_sym_stab_info != NULL)
1360 xfree (objfile->deprecated_sym_stab_info);
1363 dwarf2_free_objfile (objfile);
1366 /* ELF specific initialization routine for reading symbols.
1368 It is passed a pointer to a struct sym_fns which contains, among other
1369 things, the BFD for the file whose symbols are being read, and a slot for
1370 a pointer to "private data" which we can fill with goodies.
1372 For now at least, we have nothing in particular to do, so this function is
1376 elf_symfile_init (struct objfile *objfile)
1378 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
1379 find this causes a significant slowdown in gdb then we could
1380 set it in the debug symbol readers only when necessary. */
1381 objfile->flags |= OBJF_REORDERED;
1384 /* When handling an ELF file that contains Sun STABS debug info,
1385 some of the debug info is relative to the particular chunk of the
1386 section that was generated in its individual .o file. E.g.
1387 offsets to static variables are relative to the start of the data
1388 segment *for that module before linking*. This information is
1389 painfully squirreled away in the ELF symbol table as local symbols
1390 with wierd names. Go get 'em when needed. */
1393 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
1395 const char *filename = pst->filename;
1396 struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
1397 struct stab_section_info *maybe = dbx->stab_section_info;
1398 struct stab_section_info *questionable = 0;
1401 /* The ELF symbol info doesn't include path names, so strip the path
1402 (if any) from the psymtab filename. */
1403 filename = lbasename (filename);
1405 /* FIXME: This linear search could speed up significantly
1406 if it was chained in the right order to match how we search it,
1407 and if we unchained when we found a match. */
1408 for (; maybe; maybe = maybe->next)
1410 if (filename[0] == maybe->filename[0]
1411 && filename_cmp (filename, maybe->filename) == 0)
1413 /* We found a match. But there might be several source files
1414 (from different directories) with the same name. */
1415 if (0 == maybe->found)
1417 questionable = maybe; /* Might use it later. */
1421 if (maybe == 0 && questionable != 0)
1423 complaint (&symfile_complaints,
1424 _("elf/stab section information questionable for %s"),
1426 maybe = questionable;
1431 /* Found it! Allocate a new psymtab struct, and fill it in. */
1433 pst->section_offsets = (struct section_offsets *)
1434 obstack_alloc (&objfile->objfile_obstack,
1435 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
1436 for (i = 0; i < maybe->num_sections; i++)
1437 (pst->section_offsets)->offsets[i] = maybe->sections[i];
1441 /* We were unable to find any offsets for this file. Complain. */
1442 if (dbx->stab_section_info) /* If there *is* any info, */
1443 complaint (&symfile_complaints,
1444 _("elf/stab section information missing for %s"), filename);
1447 /* Register that we are able to handle ELF object file formats. */
1449 static const struct sym_fns elf_sym_fns =
1451 bfd_target_elf_flavour,
1452 elf_new_init, /* init anything gbl to entire symtab */
1453 elf_symfile_init, /* read initial info, setup for sym_read() */
1454 elf_symfile_read, /* read a symbol file into symtab */
1455 NULL, /* sym_read_psymbols */
1456 elf_symfile_finish, /* finished with file, cleanup */
1457 default_symfile_offsets, /* Translate ext. to int. relocation */
1458 elf_symfile_segments, /* Get segment information from a file. */
1460 default_symfile_relocate, /* Relocate a debug section. */
1464 /* The same as elf_sym_fns, but not registered and lazily reads
1467 static const struct sym_fns elf_sym_fns_lazy_psyms =
1469 bfd_target_elf_flavour,
1470 elf_new_init, /* init anything gbl to entire symtab */
1471 elf_symfile_init, /* read initial info, setup for sym_read() */
1472 elf_symfile_read, /* read a symbol file into symtab */
1473 read_psyms, /* sym_read_psymbols */
1474 elf_symfile_finish, /* finished with file, cleanup */
1475 default_symfile_offsets, /* Translate ext. to int. relocation */
1476 elf_symfile_segments, /* Get segment information from a file. */
1478 default_symfile_relocate, /* Relocate a debug section. */
1482 /* The same as elf_sym_fns, but not registered and uses the
1483 DWARF-specific GNU index rather than psymtab. */
1484 static const struct sym_fns elf_sym_fns_gdb_index =
1486 bfd_target_elf_flavour,
1487 elf_new_init, /* init anything gbl to entire symab */
1488 elf_symfile_init, /* read initial info, setup for sym_red() */
1489 elf_symfile_read, /* read a symbol file into symtab */
1490 NULL, /* sym_read_psymbols */
1491 elf_symfile_finish, /* finished with file, cleanup */
1492 default_symfile_offsets, /* Translate ext. to int. relocatin */
1493 elf_symfile_segments, /* Get segment information from a file. */
1495 default_symfile_relocate, /* Relocate a debug section. */
1496 &dwarf2_gdb_index_functions
1499 /* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */
1501 static const struct gnu_ifunc_fns elf_gnu_ifunc_fns =
1503 elf_gnu_ifunc_resolve_addr,
1504 elf_gnu_ifunc_resolve_name,
1508 _initialize_elfread (void)
1510 add_symtab_fns (&elf_sym_fns);
1512 elf_objfile_gnu_ifunc_cache_data = register_objfile_data ();
1513 gnu_ifunc_fns_p = &elf_gnu_ifunc_fns;