+/* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX)
+ for later look ups of which function to call when user requests
+ a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target
+ library defining `function' we cannot yet know while reading OBJFILE which
+ of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later
+ DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */
+
+static void
+elf_rel_plt_read (struct objfile *objfile, asymbol **dyn_symbol_table)
+{
+ bfd *obfd = objfile->obfd;
+ const struct elf_backend_data *bed = get_elf_backend_data (obfd);
+ asection *plt, *relplt, *got_plt;
+ int plt_elf_idx;
+ bfd_size_type reloc_count, reloc;
+ char *string_buffer = NULL;
+ size_t string_buffer_size = 0;
+ struct cleanup *back_to;
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
+ size_t ptr_size = TYPE_LENGTH (ptr_type);
+
+ if (objfile->separate_debug_objfile_backlink)
+ return;
+
+ plt = bfd_get_section_by_name (obfd, ".plt");
+ if (plt == NULL)
+ return;
+ plt_elf_idx = elf_section_data (plt)->this_idx;
+
+ got_plt = bfd_get_section_by_name (obfd, ".got.plt");
+ if (got_plt == NULL)
+ {
+ /* For platforms where there is no separate .got.plt. */
+ got_plt = bfd_get_section_by_name (obfd, ".got");
+ if (got_plt == NULL)
+ return;
+ }
+
+ /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */
+ for (relplt = obfd->sections; relplt != NULL; relplt = relplt->next)
+ if (elf_section_data (relplt)->this_hdr.sh_info == plt_elf_idx
+ && (elf_section_data (relplt)->this_hdr.sh_type == SHT_REL
+ || elf_section_data (relplt)->this_hdr.sh_type == SHT_RELA))
+ break;
+ if (relplt == NULL)
+ return;
+
+ if (! bed->s->slurp_reloc_table (obfd, relplt, dyn_symbol_table, TRUE))
+ return;
+
+ back_to = make_cleanup (free_current_contents, &string_buffer);
+
+ reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize;
+ for (reloc = 0; reloc < reloc_count; reloc++)
+ {
+ const char *name;
+ struct minimal_symbol *msym;
+ CORE_ADDR address;
+ const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
+ size_t name_len;
+
+ name = bfd_asymbol_name (*relplt->relocation[reloc].sym_ptr_ptr);
+ name_len = strlen (name);
+ address = relplt->relocation[reloc].address;
+
+ /* Does the pointer reside in the .got.plt section? */
+ if (!(bfd_get_section_vma (obfd, got_plt) <= address
+ && address < bfd_get_section_vma (obfd, got_plt)
+ + bfd_get_section_size (got_plt)))
+ continue;
+
+ /* We cannot check if NAME is a reference to mst_text_gnu_ifunc as in
+ OBJFILE the symbol is undefined and the objfile having NAME defined
+ may not yet have been loaded. */
+
+ if (string_buffer_size < name_len + got_suffix_len + 1)
+ {
+ string_buffer_size = 2 * (name_len + got_suffix_len);
+ string_buffer = (char *) xrealloc (string_buffer, string_buffer_size);
+ }
+ memcpy (string_buffer, name, name_len);
+ memcpy (&string_buffer[name_len], SYMBOL_GOT_PLT_SUFFIX,
+ got_suffix_len + 1);
+
+ msym = record_minimal_symbol (string_buffer, name_len + got_suffix_len,
+ 1, address, mst_slot_got_plt, got_plt,
+ objfile);
+ if (msym)
+ SET_MSYMBOL_SIZE (msym, ptr_size);
+ }
+
+ do_cleanups (back_to);
+}
+
+/* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */
+
+static const struct objfile_data *elf_objfile_gnu_ifunc_cache_data;
+
+/* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */
+
+struct elf_gnu_ifunc_cache
+{
+ /* This is always a function entry address, not a function descriptor. */
+ CORE_ADDR addr;
+
+ char name[1];
+};
+
+/* htab_hash for elf_objfile_gnu_ifunc_cache_data. */
+
+static hashval_t
+elf_gnu_ifunc_cache_hash (const void *a_voidp)
+{
+ const struct elf_gnu_ifunc_cache *a
+ = (const struct elf_gnu_ifunc_cache *) a_voidp;
+
+ return htab_hash_string (a->name);
+}
+
+/* htab_eq for elf_objfile_gnu_ifunc_cache_data. */
+
+static int
+elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp)
+{
+ const struct elf_gnu_ifunc_cache *a
+ = (const struct elf_gnu_ifunc_cache *) a_voidp;
+ const struct elf_gnu_ifunc_cache *b
+ = (const struct elf_gnu_ifunc_cache *) b_voidp;
+
+ return strcmp (a->name, b->name) == 0;
+}
+
+/* Record the target function address of a STT_GNU_IFUNC function NAME is the
+ function entry address ADDR. Return 1 if NAME and ADDR are considered as
+ valid and therefore they were successfully recorded, return 0 otherwise.
+
+ Function does not expect a duplicate entry. Use
+ elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already
+ exists. */
+
+static int
+elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
+{
+ struct bound_minimal_symbol msym;
+ asection *sect;
+ struct objfile *objfile;
+ htab_t htab;
+ struct elf_gnu_ifunc_cache entry_local, *entry_p;
+ void **slot;
+
+ msym = lookup_minimal_symbol_by_pc (addr);
+ if (msym.minsym == NULL)
+ return 0;
+ if (BMSYMBOL_VALUE_ADDRESS (msym) != addr)
+ return 0;
+ /* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL. */
+ sect = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym)->the_bfd_section;
+ objfile = msym.objfile;
+
+ /* If .plt jumps back to .plt the symbol is still deferred for later
+ resolution and it has no use for GDB. Besides ".text" this symbol can
+ reside also in ".opd" for ppc64 function descriptor. */
+ if (strcmp (bfd_get_section_name (objfile->obfd, sect), ".plt") == 0)
+ return 0;
+
+ htab = (htab_t) objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
+ if (htab == NULL)
+ {
+ htab = htab_create_alloc_ex (1, elf_gnu_ifunc_cache_hash,
+ elf_gnu_ifunc_cache_eq,
+ NULL, &objfile->objfile_obstack,
+ hashtab_obstack_allocate,
+ dummy_obstack_deallocate);
+ set_objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data, htab);
+ }
+
+ entry_local.addr = addr;
+ obstack_grow (&objfile->objfile_obstack, &entry_local,
+ offsetof (struct elf_gnu_ifunc_cache, name));
+ obstack_grow_str0 (&objfile->objfile_obstack, name);
+ entry_p
+ = (struct elf_gnu_ifunc_cache *) obstack_finish (&objfile->objfile_obstack);
+
+ slot = htab_find_slot (htab, entry_p, INSERT);
+ if (*slot != NULL)
+ {
+ struct elf_gnu_ifunc_cache *entry_found_p
+ = (struct elf_gnu_ifunc_cache *) *slot;
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+
+ if (entry_found_p->addr != addr)
+ {
+ /* This case indicates buggy inferior program, the resolved address
+ should never change. */
+
+ warning (_("gnu-indirect-function \"%s\" has changed its resolved "
+ "function_address from %s to %s"),
+ name, paddress (gdbarch, entry_found_p->addr),
+ paddress (gdbarch, addr));
+ }
+
+ /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */
+ }
+ *slot = entry_p;
+
+ return 1;
+}
+
+/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
+ function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
+ is not NULL) and the function returns 1. It returns 0 otherwise.
+
+ Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this
+ function. */
+
+static int
+elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p)
+{
+ struct objfile *objfile;
+
+ ALL_PSPACE_OBJFILES (current_program_space, objfile)
+ {
+ htab_t htab;
+ struct elf_gnu_ifunc_cache *entry_p;
+ void **slot;
+
+ htab = (htab_t) objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
+ if (htab == NULL)
+ continue;
+
+ entry_p = ((struct elf_gnu_ifunc_cache *)
+ alloca (sizeof (*entry_p) + strlen (name)));
+ strcpy (entry_p->name, name);
+
+ slot = htab_find_slot (htab, entry_p, NO_INSERT);
+ if (slot == NULL)
+ continue;
+ entry_p = (struct elf_gnu_ifunc_cache *) *slot;
+ gdb_assert (entry_p != NULL);
+
+ if (addr_p)
+ *addr_p = entry_p->addr;
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
+ function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
+ is not NULL) and the function returns 1. It returns 0 otherwise.
+
+ Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function.
+ elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to
+ prevent cache entries duplicates. */
+
+static int
+elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p)
+{
+ char *name_got_plt;
+ struct objfile *objfile;
+ const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
+
+ name_got_plt = (char *) alloca (strlen (name) + got_suffix_len + 1);
+ sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name);
+
+ ALL_PSPACE_OBJFILES (current_program_space, objfile)
+ {
+ bfd *obfd = objfile->obfd;
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
+ size_t ptr_size = TYPE_LENGTH (ptr_type);
+ CORE_ADDR pointer_address, addr;
+ asection *plt;
+ gdb_byte *buf = (gdb_byte *) alloca (ptr_size);
+ struct bound_minimal_symbol msym;
+
+ msym = lookup_minimal_symbol (name_got_plt, NULL, objfile);
+ if (msym.minsym == NULL)
+ continue;
+ if (MSYMBOL_TYPE (msym.minsym) != mst_slot_got_plt)
+ continue;
+ pointer_address = BMSYMBOL_VALUE_ADDRESS (msym);
+
+ plt = bfd_get_section_by_name (obfd, ".plt");
+ if (plt == NULL)
+ continue;
+
+ if (MSYMBOL_SIZE (msym.minsym) != ptr_size)
+ continue;
+ if (target_read_memory (pointer_address, buf, ptr_size) != 0)
+ continue;
+ addr = extract_typed_address (buf, ptr_type);
+ addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
+ ¤t_target);
+ addr = gdbarch_addr_bits_remove (gdbarch, addr);
+
+ if (addr_p)
+ *addr_p = addr;
+ if (elf_gnu_ifunc_record_cache (name, addr))
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
+ function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
+ is not NULL) and the function returns 1. It returns 0 otherwise.
+
+ Both the elf_objfile_gnu_ifunc_cache_data hash table and
+ SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */
+
+static int
+elf_gnu_ifunc_resolve_name (const char *name, CORE_ADDR *addr_p)
+{
+ if (elf_gnu_ifunc_resolve_by_cache (name, addr_p))
+ return 1;
+
+ if (elf_gnu_ifunc_resolve_by_got (name, addr_p))
+ return 1;
+
+ return 0;
+}
+
+/* Call STT_GNU_IFUNC - a function returning addresss of a real function to
+ call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned
+ is the entry point of the resolved STT_GNU_IFUNC target function to call.
+ */
+
+static CORE_ADDR
+elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+ const char *name_at_pc;
+ CORE_ADDR start_at_pc, address;
+ struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
+ struct value *function, *address_val;
+
+ /* Try first any non-intrusive methods without an inferior call. */
+
+ if (find_pc_partial_function (pc, &name_at_pc, &start_at_pc, NULL)
+ && start_at_pc == pc)
+ {
+ if (elf_gnu_ifunc_resolve_name (name_at_pc, &address))
+ return address;
+ }
+ else
+ name_at_pc = NULL;
+
+ function = allocate_value (func_func_type);
+ set_value_address (function, pc);
+
+ /* STT_GNU_IFUNC resolver functions have no parameters. FUNCTION is the
+ function entry address. ADDRESS may be a function descriptor. */
+
+ address_val = call_function_by_hand (function, 0, NULL);
+ address = value_as_address (address_val);
+ address = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
+ ¤t_target);
+ address = gdbarch_addr_bits_remove (gdbarch, address);
+
+ if (name_at_pc)
+ elf_gnu_ifunc_record_cache (name_at_pc, address);
+
+ return address;
+}
+
+/* Handle inferior hit of bp_gnu_ifunc_resolver, see its definition. */
+
+static void
+elf_gnu_ifunc_resolver_stop (struct breakpoint *b)
+{
+ struct breakpoint *b_return;
+ struct frame_info *prev_frame = get_prev_frame (get_current_frame ());
+ struct frame_id prev_frame_id = get_stack_frame_id (prev_frame);
+ CORE_ADDR prev_pc = get_frame_pc (prev_frame);
+ int thread_id = ptid_to_global_thread_id (inferior_ptid);
+
+ gdb_assert (b->type == bp_gnu_ifunc_resolver);
+
+ for (b_return = b->related_breakpoint; b_return != b;
+ b_return = b_return->related_breakpoint)
+ {
+ gdb_assert (b_return->type == bp_gnu_ifunc_resolver_return);
+ gdb_assert (b_return->loc != NULL && b_return->loc->next == NULL);
+ gdb_assert (frame_id_p (b_return->frame_id));
+
+ if (b_return->thread == thread_id
+ && b_return->loc->requested_address == prev_pc
+ && frame_id_eq (b_return->frame_id, prev_frame_id))
+ break;
+ }
+
+ if (b_return == b)
+ {
+ struct symtab_and_line sal;
+
+ /* No need to call find_pc_line for symbols resolving as this is only
+ a helper breakpointer never shown to the user. */
+
+ init_sal (&sal);
+ sal.pspace = current_inferior ()->pspace;
+ sal.pc = prev_pc;
+ sal.section = find_pc_overlay (sal.pc);
+ sal.explicit_pc = 1;
+ b_return = set_momentary_breakpoint (get_frame_arch (prev_frame), sal,
+ prev_frame_id,
+ bp_gnu_ifunc_resolver_return);
+
+ /* set_momentary_breakpoint invalidates PREV_FRAME. */
+ prev_frame = NULL;
+
+ /* Add new b_return to the ring list b->related_breakpoint. */
+ gdb_assert (b_return->related_breakpoint == b_return);
+ b_return->related_breakpoint = b->related_breakpoint;
+ b->related_breakpoint = b_return;
+ }
+}
+
+/* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition. */
+
+static void
+elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b)
+{
+ struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
+ struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
+ struct type *value_type = TYPE_TARGET_TYPE (func_func_type);
+ struct regcache *regcache = get_thread_regcache (inferior_ptid);
+ struct value *func_func;
+ struct value *value;
+ CORE_ADDR resolved_address, resolved_pc;
+ struct symtab_and_line sal;
+ struct symtabs_and_lines sals, sals_end;
+
+ gdb_assert (b->type == bp_gnu_ifunc_resolver_return);
+
+ while (b->related_breakpoint != b)
+ {
+ struct breakpoint *b_next = b->related_breakpoint;
+
+ switch (b->type)
+ {
+ case bp_gnu_ifunc_resolver:
+ break;
+ case bp_gnu_ifunc_resolver_return:
+ delete_breakpoint (b);
+ break;
+ default:
+ internal_error (__FILE__, __LINE__,
+ _("handle_inferior_event: Invalid "
+ "gnu-indirect-function breakpoint type %d"),
+ (int) b->type);
+ }
+ b = b_next;
+ }
+ gdb_assert (b->type == bp_gnu_ifunc_resolver);
+ gdb_assert (b->loc->next == NULL);
+
+ func_func = allocate_value (func_func_type);
+ set_value_address (func_func, b->loc->related_address);
+
+ value = allocate_value (value_type);
+ gdbarch_return_value (gdbarch, func_func, value_type, regcache,
+ value_contents_raw (value), NULL);
+ resolved_address = value_as_address (value);
+ resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
+ resolved_address,
+ ¤t_target);
+ resolved_pc = gdbarch_addr_bits_remove (gdbarch, resolved_pc);
+
+ gdb_assert (current_program_space == b->pspace || b->pspace == NULL);
+ elf_gnu_ifunc_record_cache (event_location_to_string (b->location),
+ resolved_pc);
+
+ sal = find_pc_line (resolved_pc, 0);
+ sals.nelts = 1;
+ sals.sals = &sal;
+ sals_end.nelts = 0;
+
+ b->type = bp_breakpoint;
+ update_breakpoint_locations (b, current_program_space, sals, sals_end);
+}
+
+/* A helper function for elf_symfile_read that reads the minimal
+ symbols. */
+
+static void
+elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags,
+ const struct elfinfo *ei)
+{
+ bfd *synth_abfd, *abfd = objfile->obfd;
+ struct cleanup *back_to;
+ long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
+ asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
+ asymbol *synthsyms;
+ struct dbx_symfile_info *dbx;
+
+ if (symtab_create_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "Reading minimal symbols of objfile %s ...\n",
+ objfile_name (objfile));
+ }
+
+ /* If we already have minsyms, then we can skip some work here.
+ However, if there were stabs or mdebug sections, we go ahead and
+ redo all the work anyway, because the psym readers for those
+ kinds of debuginfo need extra information found here. This can
+ go away once all types of symbols are in the per-BFD object. */
+ if (objfile->per_bfd->minsyms_read
+ && ei->stabsect == NULL
+ && ei->mdebugsect == NULL)
+ {
+ if (symtab_create_debug)
+ fprintf_unfiltered (gdb_stdlog,
+ "... minimal symbols previously read\n");
+ return;
+ }
+
+ init_minimal_symbol_collection ();
+ back_to = make_cleanup_discard_minimal_symbols ();
+
+ /* Allocate struct to keep track of the symfile. */
+ dbx = XCNEW (struct dbx_symfile_info);
+ set_objfile_data (objfile, dbx_objfile_data_key, dbx);
+
+ /* Process the normal ELF symbol table first. */
+
+ storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
+ if (storage_needed < 0)
+ error (_("Can't read symbols from %s: %s"),
+ bfd_get_filename (objfile->obfd),
+ bfd_errmsg (bfd_get_error ()));
+
+ if (storage_needed > 0)
+ {
+ /* Memory gets permanently referenced from ABFD after
+ bfd_canonicalize_symtab so it must not get freed before ABFD gets. */
+
+ symbol_table = (asymbol **) bfd_alloc (abfd, storage_needed);
+ symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
+
+ if (symcount < 0)
+ error (_("Can't read symbols from %s: %s"),
+ bfd_get_filename (objfile->obfd),
+ bfd_errmsg (bfd_get_error ()));
+
+ elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
+ }
+
+ /* Add the dynamic symbols. */
+
+ storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
+
+ if (storage_needed > 0)
+ {
+ /* Memory gets permanently referenced from ABFD after
+ bfd_get_synthetic_symtab so it must not get freed before ABFD gets.
+ It happens only in the case when elf_slurp_reloc_table sees
+ asection->relocation NULL. Determining which section is asection is
+ done by _bfd_elf_get_synthetic_symtab which is all a bfd
+ implementation detail, though. */
+
+ dyn_symbol_table = (asymbol **) bfd_alloc (abfd, storage_needed);
+ dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
+ dyn_symbol_table);
+
+ if (dynsymcount < 0)
+ error (_("Can't read symbols from %s: %s"),
+ bfd_get_filename (objfile->obfd),
+ bfd_errmsg (bfd_get_error ()));
+
+ elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
+
+ elf_rel_plt_read (objfile, dyn_symbol_table);
+ }
+
+ /* Contrary to binutils --strip-debug/--only-keep-debug the strip command from
+ elfutils (eu-strip) moves even the .symtab section into the .debug file.
+
+ bfd_get_synthetic_symtab on ppc64 for each function descriptor ELF symbol
+ 'name' creates a new BSF_SYNTHETIC ELF symbol '.name' with its code
+ address. But with eu-strip files bfd_get_synthetic_symtab would fail to
+ read the code address from .opd while it reads the .symtab section from
+ a separate debug info file as the .opd section is SHT_NOBITS there.
+
+ With SYNTH_ABFD the .opd section will be read from the original
+ backlinked binary where it is valid. */
+
+ if (objfile->separate_debug_objfile_backlink)
+ synth_abfd = objfile->separate_debug_objfile_backlink->obfd;
+ else
+ synth_abfd = abfd;