1999-04-16 03:35:26 +02:00
|
|
|
|
/* Read ELF (Executable and Linking Format) object files for GDB.
|
2003-01-13 Andrew Cagney <ac131313@redhat.com>
* ax-gdb.c, c-valprint.c, charset.c, corefile.c: Update copyright.
* demangle.c, disasm.c, dwarf2cfi.c, dwarfread.c: Update copyright.
* elfread.c, eval.c, expprint.c, expression.h: Update copyright.
* f-typeprint.c, findvar.c, gcore.c, gdb_mbuild.sh: Update copyright.
* gdbtypes.h, gnu-v2-abi.c, inferior.h, inftarg.c: Update copyright.
* language.c, language.h, m32r-tdep.c: Update copyright.
* mn10200-tdep.c, scm-lang.c, scm-lang.h: Update copyright.
* somsolib.c, somsolib.h, symfile.c, symtab.h: Update copyright.
* thread-db.c, typeprint.c, utils.c, valarith.c: Update copyright.
* values.c, win32-nat.c, x86-64-linux-nat.c: Update copyright.
* x86-64-linux-tdep.c, z8k-tdep.c: Update copyright.
* cli/cli-decode.h, config/h8500/tm-h8500.h: Update copyright.
Index: mi/ChangeLog
2003-01-13 Andrew Cagney <ac131313@redhat.com>
* mi-cmd-env.c: Update copyright.
2003-01-14 01:49:06 +01:00
|
|
|
|
|
2012-01-04 09:17:56 +01:00
|
|
|
|
Copyright (C) 1991-2012 Free Software Foundation, Inc.
|
2003-01-13 Andrew Cagney <ac131313@redhat.com>
* ax-gdb.c, c-valprint.c, charset.c, corefile.c: Update copyright.
* demangle.c, disasm.c, dwarf2cfi.c, dwarfread.c: Update copyright.
* elfread.c, eval.c, expprint.c, expression.h: Update copyright.
* f-typeprint.c, findvar.c, gcore.c, gdb_mbuild.sh: Update copyright.
* gdbtypes.h, gnu-v2-abi.c, inferior.h, inftarg.c: Update copyright.
* language.c, language.h, m32r-tdep.c: Update copyright.
* mn10200-tdep.c, scm-lang.c, scm-lang.h: Update copyright.
* somsolib.c, somsolib.h, symfile.c, symtab.h: Update copyright.
* thread-db.c, typeprint.c, utils.c, valarith.c: Update copyright.
* values.c, win32-nat.c, x86-64-linux-nat.c: Update copyright.
* x86-64-linux-tdep.c, z8k-tdep.c: Update copyright.
* cli/cli-decode.h, config/h8500/tm-h8500.h: Update copyright.
Index: mi/ChangeLog
2003-01-13 Andrew Cagney <ac131313@redhat.com>
* mi-cmd-env.c: Update copyright.
2003-01-14 01:49:06 +01:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
Written by Fred Fish at Cygnus Support.
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This file is part of GDB.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
2007-08-23 20:08:50 +02:00
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
1999-07-07 22:19:36 +02:00
|
|
|
|
(at your option) any later version.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
2007-08-23 20:08:50 +02:00
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
|
#include "bfd.h"
|
|
|
|
|
#include "gdb_string.h"
|
|
|
|
|
#include "elf-bfd.h"
|
2007-06-18 17:46:38 +02:00
|
|
|
|
#include "elf/common.h"
|
|
|
|
|
#include "elf/internal.h"
|
1999-04-16 03:35:26 +02:00
|
|
|
|
#include "elf/mips.h"
|
|
|
|
|
#include "symtab.h"
|
|
|
|
|
#include "symfile.h"
|
|
|
|
|
#include "objfiles.h"
|
|
|
|
|
#include "buildsym.h"
|
|
|
|
|
#include "stabsread.h"
|
|
|
|
|
#include "gdb-stabs.h"
|
|
|
|
|
#include "complaints.h"
|
|
|
|
|
#include "demangle.h"
|
gdb
* xcoffread.c: Include psymtab.h.
(xcoff_sym_fns): Update.
* symtab.h (struct partial_symbol): Remove.
(PSYMBOL_DOMAIN, PSYMBOL_CLASS): Remove.
(struct partial_symtab): Remove.
(PSYMTAB_TO_SYMTAB): Remove.
(lookup_partial_symbol, lookup_partial_symtab, find_pc_psymtab)
(find_pc_sect_psymtab): Remove.
(find_pc_sect_symtab_via_partial): Declare.
(find_pc_psymtab, find_pc_sect_psymbol, psymtab_to_symtab)
(find_main_psymtab): Remove.
(find_main_filename): Declare.
(fixup_psymbol_section): Remove.
(fixup_section): Declare.
* symtab.c: Include psymtab.h.
(lookup_symtab): Use lookup_symtab method.
(lookup_partial_symtab): Remove.
(find_pc_sect_psymtab_closer): Remove.
(find_pc_sect_psymtab): Remove.
(find_pc_sect_symtab_via_partial): New function.
(find_pc_psymtab, find_pc_sect_psymbol, find_pc_psymbol): Remove.
(fixup_section): No longer static.
(fixup_psymbol_section): Remove.
(lookup_symbol_aux): Use lookup_symbol_aux_quick.
(lookup_global_symbol_from_objfile): Likewise.
(lookup_symbol_aux_psymtabs): Remove.
(lookup_symbol_aux_quick): New function.
(lookup_symbol_global): Use lookup_symbol_aux_quick.
(lookup_partial_symbol): Remove.
(basic_lookup_transparent_type_quick): New function.
(basic_lookup_transparent_type): Use it.
(find_main_psymtab): Remove.
(find_main_filename): New function.
(find_pc_sect_symtab): Use find_pc_sect_symtab method.
(find_line_symtab): Use expand_symtabs_with_filename method.
(output_partial_symbol_filename): New function.
(sources_info): Use map_partial_symbol_filenames.
(struct search_symbols_data): New type.
(search_symbols_file_matches): New function.
(search_symbols_name_matches): Likewise.
(search_symbols): Use expand_symtabs_matching method.
(struct add_name_data): Rename from add_macro_name_data.
(add_macro_name): Update.
(add_partial_symbol_name): New function.
(default_make_symbol_completion_list): Use
map_partial_symbol_names.
(struct add_partial_symbol_name): New type.
(maybe_add_partial_symtab_filename): New function.
(make_source_files_completion_list): Use
map_partial_symbol_filenames.
(expand_line_sal): Use expand_symtabs_with_filename method.
* symmisc.c: Include psymtab.h.
(print_objfile_statistics): Use print_stats method.
(dump_objfile): Use dump method.
(dump_psymtab, maintenance_print_psymbols)
(maintenance_info_psymtabs, maintenance_check_symtabs)
(extend_psymbol_list): Remove.
* symfile.h (struct quick_symbol_functions): New struct.
(struct sym_fns) <qf>: New field.
(sort_pst_symbols): Remove.
(increment_reading_symtab): Declare.
* symfile.c: Include psymtab.h.
(compare_psymbols, sort_pst_symbols): Remove.
(psymtab_to_symtab): Remove.
(increment_reading_symtab): New function.
(symbol_file_add_with_addrs_or_offsets): Use expand_all_symtabs
method.
(set_initial_language): Use find_main_filename.
(allocate_psymtab, discard_psymtab, cashier_psymtab): Remove.
(free_named_symtabs): Remove unused code.
(start_psymtab_common, add_psymbol_to_bcache)
(append_psymbol_to_list, add_psymbol_to_list, init_psymbol_list):
Remove.
* stack.c: Include psymtab.h, symfile.h.
(backtrace_command_1): Use find_pc_sect_symtab_via_partial.
* source.h (psymtab_to_fullname): Don't declare.
* source.c: Include psymtab.h.
(select_source_symtab): Use find_last_source_symtab method.
(forget_cached_source_info): Use forget_cached_source_info
method.
(find_and_open_source): No longer static.
(psymtab_to_fullname): Remove.
* somread.c: Include psymtab.h.
(som_sym_fns): Update.
* psympriv.h: New file.
* psymtab.h: New file.
* psymtab.c: New file.
* objfiles.h: (ALL_OBJFILE_PSYMTABS): Remove.
(ALL_PSYMTABS, ALL_PSPACE_PSYMTABS): Likewise.
* objfiles.c: Include psymtab.h.
(objfile_relocate1): Use relocate method.
(objfile_has_partial_symbols): Use has_symbols method.
* mipsread.c: Include psymtab.h.
(ecoff_sym_fns): Update.
* mi/mi-cmd-file.c: Include psymtab.h.
(print_partial_file_name): New function.
(mi_cmd_file_list_exec_source_files): Use
map_partial_symbol_filenames.
* mdebugread.c: Include psympriv.h.
* machoread.c: Include psympriv.h.
(macho_sym_fns): Update.
* m2-exp.y (yylex): Use lookup_symtab.
* elfread.c: Include psympriv.h.
(elf_sym_fns): Update.
* dwarf2read.c: Include psympriv.h.
* dbxread.c: Include psympriv.h.
(aout_sym_fns): Update.
* cp-support.c: Include psymtab.h.
(read_in_psymtabs): Remove.
(make_symbol_overload_list_qualified): Use
expand_symtabs_for_function method.
* coffread.c: Include psympriv.h.
(coff_sym_fns): Update.
* blockframe.c: Include psymtab.h.
(find_pc_partial_function): Use find_pc_sect_symtab method.
* ada-lang.h (ada_update_initial_language): Update.
* ada-lang.c: Include psymtab.h.
(ada_update_initial_language): Remove 'main_pst' argument.
(ada_lookup_partial_symbol): Remove.
(struct ada_psym_data): New type.
(ada_add_psyms): New function.
(ada_add_non_local_symbols): Use map_ada_symtabs method.
(struct add_partial_datum): New type.
(ada_add_partial_symbol_completions): New function.
(ada_make_symbol_completion_list): Use map_partial_symbol_names.
(ada_exception_support_info_sniffer): Update.
* Makefile.in (SFILES): Add psymtab.c.
(COMMON_OBS): Add psymtab.o.
(HFILES_NO_SRCDIR): Add psymtab.h, psympriv.h.
gdb/doc
* gdbint.texinfo (Symbol Handling): Update.
2010-03-10 19:20:08 +01:00
|
|
|
|
#include "psympriv.h"
|
2011-03-23 19:23:56 +01:00
|
|
|
|
#include "filenames.h"
|
2012-04-27 22:47:57 +02:00
|
|
|
|
#include "probe.h"
|
|
|
|
|
#include "arch-utils.h"
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
#include "gdbtypes.h"
|
|
|
|
|
#include "value.h"
|
|
|
|
|
#include "infcall.h"
|
2011-03-28 22:29:51 +02:00
|
|
|
|
#include "gdbthread.h"
|
|
|
|
|
#include "regcache.h"
|
2011-12-21 22:30:31 +01:00
|
|
|
|
#include "bcache.h"
|
* dwarf2read.c (try_open_dwo_file): Use gdb_bfd_ref and
gdb_bfd_unref.
(free_dwo_file): Use gdb_bfd_unref.
* cli/cli-dump.c: Include gdb_bfd.h.
(bfd_openw_with_cleanup): Use gdb_bfd_ref.
(bfd_openr_with_cleanup): Likewise.
* windows-nat.c (windows_make_so): Use gdb_bfd_ref,
gdb_bfd_unref.
* utils.c: Include gdb_bfd.h.
(do_bfd_close_cleanup): Use gdb_bfd_unref.
* symfile.c: Include gdb_bfd.h.
(separate_debug_file_exists): Use gdb_bfd_unref.
(bfd_open_maybe_remote): Use gdb_bfd_ref.
(symfile_bfd_open): Use gdb_bfd_ref, gdb_bfd_unref.
(generic_load): Use gdb_bfd_ref.
(reread_symbols): Use gdb_bfd_unref.
* symfile-mem.c: Include gdb_bfd.h.
(symbol_file_add_from_memory): Use make_cleanup_bfd_close.
* spu-linux-nat.c (spu_bfd_open): Use gdb_bfd_ref, gdb_bfd_unref.
* solib.c: Include gdb_bfd.h.
(solib_bfd_fopen): Use gdb_bfd_ref.
(solib_bfd_open): Use gdb_bfd_unref.
(free_so_symbols): Use gdb_bfd_unref.
(reload_shared_libraries_1): Use gdb_bfd_unref.
* solib-spu.c: Include gdb_bfd.h.
(spu_bfd_fopen): Use gdb_bfd_ref, gdb_bfd_unref.
* solib-pa64.c (pa64_solib_create_inferior_hook): Use gdb_bfd_ref,
gdb_bfd_unref.
* solib-frv.c: Include gdb_bfd.h.
(enable_break2): Use gdb_bfd_unref.
* solib-dsbt.c: Include gdb_bfd.h.
(enable_break2): Use gdb_bfd_unref.
* solib-darwin.c: Include gdb_bfd.h.
(darwin_solib_get_all_image_info_addr_at_init): Use gdb_bfd_ref,
gdb_bfd_unref.
(darwin_bfd_open): Use gdb_bfd_unref.
* rs6000-nat.c (add_vmap): Use gdb_bfd_ref, gdb_bfd_unref.
* remote-mips.c: Include gdb_bfd.h.
(mips_load_srec): Use gdb_bfd_ref.
(pmon_load_fast): Use gdb_bfd_ref.
* remote-m32r-sdi.c: Include gdb_bfd.h.
(m32r_load): Use gdb_bfd_ref.
* record.c: Include gdb_bfd.h.
(record_save_cleanups): Use gdb_bfd_unref.
(cmd_record_save): Use gdb_bfd_unref.
* procfs.c (insert_dbx_link_bpt_in_file): Use gdb_bfd_ref,
gdb_bfd_unref.
* objfiles.h (gdb_bfd_close_or_warn): Remove.
(gdb_bfd_ref, gdb_bfd_unref): Move to gdb_bfd.h.
* objfiles.c: Include gdb_bfd.h.
(free_objfile): Use gdb_bfd_unref.
(gdb_bfd_close_or_warn, gdb_bfd_ref, gdb_bfd_unref): Move to
gdb_bfd.c.
* machoread.c (macho_add_oso_symfile): Use gdb_bfd_unref.
(macho_symfile_read_all_oso): Use gdb_bfd_ref, gdb_bfd_unref.
(macho_check_dsym): Likewise.
* m32r-rom.c: Include gdb_bfd.h.
(m32r_load): Use gdb_bfd_ref.
(m32r_upload_command): Use gdb_bfd_ref.
* jit.c: Include gdb_bfd.h.
(jit_bfd_try_read_symtab): Use gdb_bfd_ref, gdb_bfd_unref.
* gdb_bfd.h: New file.
* gdb_bfd.c: New file.
* gcore.c: Include gdb_bfd.h.
(create_gcore_bfd): Use gdb_bfd_ref.
(do_bfd_delete_cleanup): Use gdb_bfd_unref.
(gcore_command): Use gdb_bfd_unref.
* exec.c: Include gdb_bfd.h.
(exec_close): Use gdb_bfd_unref.
(exec_close_1): Use gdb_bfd_unref.
(exec_file_attach): Use gdb_bfd_ref.
* elfread.c: Include gdb_bfd.h.
(build_id_verify): Use gdb_bfd_unref.
* dsrec.c: Include gdb_bfd.h.
(load_srec): Use gdb_bfd_ref.
* corelow.c: Include gdb_bfd.h.
(core_close): Use gdb_bfd_unref.
(core_open): Use gdb_bfd_ref.
* bfd-target.c: Include gdb_bfd.h.
(target_bfd_xclose): Use gdb_bfd_unref.
(target_bfd_reopen): Use gdb_bfd_ref.
* Makefile.in (SFILES): Add gdb_bfd.c.
(HFILES_NO_SRCDIR): Add gdb_bfd.h.
(COMMON_OBS): Add gdb_bfd.o.
2012-07-18 21:33:34 +02:00
|
|
|
|
#include "gdb_bfd.h"
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
extern void _initialize_elfread (void);
|
1999-05-25 20:09:09 +02:00
|
|
|
|
|
2011-03-07 17:17:29 +01:00
|
|
|
|
/* Forward declarations. */
|
2010-09-30 21:14:30 +02:00
|
|
|
|
static const struct sym_fns elf_sym_fns_gdb_index;
|
2011-03-07 17:17:29 +01:00
|
|
|
|
static const struct sym_fns elf_sym_fns_lazy_psyms;
|
2010-07-13 22:51:34 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* The struct elfinfo is available only during ELF symbol table and
|
1999-09-28 23:55:21 +02:00
|
|
|
|
psymtab reading. It is destroyed at the completion of psymtab-reading.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
It's local to elf_symfile_read. */
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
struct elfinfo
|
|
|
|
|
{
|
|
|
|
|
asection *stabsect; /* Section pointer for .stab section */
|
|
|
|
|
asection *stabindexsect; /* Section pointer for .stab.index section */
|
|
|
|
|
asection *mdebugsect; /* Section pointer for .mdebug section */
|
|
|
|
|
};
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2012-04-27 22:47:57 +02:00
|
|
|
|
/* Per-objfile data for probe info. */
|
|
|
|
|
|
|
|
|
|
static const struct objfile_data *probe_key = NULL;
|
|
|
|
|
|
2002-03-19 20:00:04 +01:00
|
|
|
|
static void free_elfinfo (void *);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
/* Minimal symbols located at the GOT entries for .plt - that is the real
|
|
|
|
|
pointer where the given entry will jump to. It gets updated by the real
|
|
|
|
|
function address during lazy ld.so resolving in the inferior. These
|
|
|
|
|
minimal symbols are indexed for <tab>-completion. */
|
|
|
|
|
|
|
|
|
|
#define SYMBOL_GOT_PLT_SUFFIX "@got.plt"
|
|
|
|
|
|
2007-06-18 17:46:38 +02:00
|
|
|
|
/* Locate the segments in ABFD. */
|
|
|
|
|
|
|
|
|
|
static struct symfile_segment_data *
|
|
|
|
|
elf_symfile_segments (bfd *abfd)
|
|
|
|
|
{
|
|
|
|
|
Elf_Internal_Phdr *phdrs, **segments;
|
|
|
|
|
long phdrs_size;
|
|
|
|
|
int num_phdrs, num_segments, num_sections, i;
|
|
|
|
|
asection *sect;
|
|
|
|
|
struct symfile_segment_data *data;
|
|
|
|
|
|
|
|
|
|
phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
|
|
|
|
|
if (phdrs_size == -1)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
phdrs = alloca (phdrs_size);
|
|
|
|
|
num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
|
|
|
|
|
if (num_phdrs == -1)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
num_segments = 0;
|
|
|
|
|
segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
|
|
|
|
|
for (i = 0; i < num_phdrs; i++)
|
|
|
|
|
if (phdrs[i].p_type == PT_LOAD)
|
|
|
|
|
segments[num_segments++] = &phdrs[i];
|
|
|
|
|
|
|
|
|
|
if (num_segments == 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
data = XZALLOC (struct symfile_segment_data);
|
|
|
|
|
data->num_segments = num_segments;
|
|
|
|
|
data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
|
|
|
|
|
data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_segments; i++)
|
|
|
|
|
{
|
|
|
|
|
data->segment_bases[i] = segments[i]->p_vaddr;
|
|
|
|
|
data->segment_sizes[i] = segments[i]->p_memsz;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
num_sections = bfd_count_sections (abfd);
|
|
|
|
|
data->segment_info = XCALLOC (num_sections, int);
|
|
|
|
|
|
|
|
|
|
for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
|
|
|
|
|
{
|
|
|
|
|
int j;
|
|
|
|
|
CORE_ADDR vma;
|
|
|
|
|
|
|
|
|
|
if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
vma = bfd_get_section_vma (abfd, sect);
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < num_segments; j++)
|
|
|
|
|
if (segments[j]->p_memsz > 0
|
|
|
|
|
&& vma >= segments[j]->p_vaddr
|
2008-07-21 07:05:23 +02:00
|
|
|
|
&& (vma - segments[j]->p_vaddr) < segments[j]->p_memsz)
|
2007-06-18 17:46:38 +02:00
|
|
|
|
{
|
|
|
|
|
data->segment_info[i] = j + 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-02 18:16:14 +01:00
|
|
|
|
/* We should have found a segment for every non-empty section.
|
|
|
|
|
If we haven't, we will not relocate this section by any
|
|
|
|
|
offsets we apply to the segments. As an exception, do not
|
|
|
|
|
warn about SHT_NOBITS sections; in normal ELF execution
|
|
|
|
|
environments, SHT_NOBITS means zero-initialized and belongs
|
|
|
|
|
in a segment, but in no-OS environments some tools (e.g. ARM
|
|
|
|
|
RealView) use SHT_NOBITS for uninitialized data. Since it is
|
|
|
|
|
uninitialized, it doesn't need a program header. Such
|
|
|
|
|
binaries are not relocatable. */
|
|
|
|
|
if (bfd_get_section_size (sect) > 0 && j == num_segments
|
|
|
|
|
&& (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
|
2012-02-21 07:44:13 +01:00
|
|
|
|
warning (_("Loadable section \"%s\" outside of ELF segments"),
|
2007-06-18 17:46:38 +02:00
|
|
|
|
bfd_section_name (abfd, sect));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return data;
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* We are called once per section from elf_symfile_read. We
|
|
|
|
|
need to examine each section we are passed, check to see
|
|
|
|
|
if it is something we are interested in processing, and
|
|
|
|
|
if so, stash away some access information for the section.
|
|
|
|
|
|
|
|
|
|
For now we recognize the dwarf debug information sections and
|
|
|
|
|
line number sections from matching their section names. The
|
|
|
|
|
ELF definition is no real help here since it has no direct
|
|
|
|
|
knowledge of DWARF (by design, so any debugging format can be
|
|
|
|
|
used).
|
|
|
|
|
|
|
|
|
|
We also recognize the ".stab" sections used by the Sun compilers
|
|
|
|
|
released with Solaris 2.
|
|
|
|
|
|
|
|
|
|
FIXME: The section names should not be hardwired strings (what
|
|
|
|
|
should they be? I don't think most object file formats have enough
|
2011-01-07 20:36:19 +01:00
|
|
|
|
section flags to specify what kind of debug section it is.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
-kingdon). */
|
|
|
|
|
|
|
|
|
|
static void
|
2002-03-19 20:00:04 +01:00
|
|
|
|
elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2003-09-14 Andrew Cagney <cagney@redhat.com>
* alpha-nat.c: Remove some occurances of "register".
* alpha-tdep.c, arm-tdep.c, blockframe.c, breakpoint.c: Ditto.
* buildsym.c, c-typeprint.c, c-valprint.c, coffread.c: Ditto.
* corefile.c, cp-support.c, cp-valprint.c, cris-tdep.c: Ditto.
* dbxread.c, dcache.c, dwarf2read.c, elfread.c: Ditto.
* environ.c, eval.c, event-top.c, f-typeprint.c: Ditto.
* f-valprint.c, findvar.c, frame.c, gdbtypes.c: Ditto.
* h8300-tdep.c, hppa-tdep.c, hppab-nat.c, hppah-nat.c: Ditto.
* hppam3-nat.c, hpread.c, ia64-aix-nat.c, ia64-linux-nat.c: Ditto.
* infcall.c, infcmd.c, inflow.c, infptrace.c, infrun.c: Ditto.
* infttrace.c, irix5-nat.c, jv-typeprint.c: Ditto.
* jv-valprint.c, m68k-tdep.c, m68klinux-nat.c, main.c: Ditto.
* mdebugread.c, minsyms.c, mips-linux-tdep.c: Ditto.
* mips-nat.c, mips-tdep.c, mipsread.c, mipsv4-nat.c: Ditto.
* ns32k-tdep.c, objfiles.c, p-typeprint.c: Ditto.
* p-valprint.c, ppc-linux-nat.c, printcmd.c: Ditto.
* remote-mips.c, remote-vx.c, rs6000-nat.c: Ditto.
* rs6000-tdep.c, scm-exp.c, sh-tdep.c, sh64-tdep.c: Ditto.
* solib.c, somread.c, source.c, sparc-tdep.c: Ditto.
* stabsread.c, stack.c, standalone.c, symfile.c: Ditto.
* symmisc.c, symtab.c, top.c, tracepoint.c: Ditto.
* typeprint.c, utils.c, valarith.c, valops.c: Ditto.
* values.c, vax-tdep.c, xcoffread.c: Ditto.
2003-09-14 18:32:14 +02:00
|
|
|
|
struct elfinfo *ei;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
ei = (struct elfinfo *) eip;
|
* MAINTAINERS: Remove d10v entry.
* Makefile.in (SFILES): Remove dwarfread.c.
(COMMON_OBS): Remove dwarfread.o.
(gdb_sim_d10v_h, abug-rom.o, cpu32bug-rom.o, d10v-tdep.o, dwarfread.o)
(remote-est.o, rom68k-rom.o): Delete.
* NEWS: Mention removal of d10v, target abug, target cpu32bug,
target est, target rom68k, and DWARF 1.
* configure.tgt: Mark d10v as removed.
* dwarf2read.c: Doc update.
* elfread.c (struct elfinfo): Remove dboffset, dbsize, lnoffset,
and lnsize.
(elf_locate_sections): Do not set them.
(elf_symfile_read): Do not call dwarf_build_psymtabs.
* symfile.h (dwarf_build_psymtabs): Delete prototype.
* config/m68k/monitor.mt (TDEPFILES): Prune.
* abug-rom.c, cpu32bug-rom.c, d10v-tdep.c, dwarfread.c,
remote-est.c, rom68k-rom.c, config/d10v/d10v.mt: Delete.
* gdb.texinfo (M68K): Remove obsolete ROM monitors.
* gdbint.texinfo (DWARF 1): Delete section and other dwarfread.c
references.
* gdb.asm/asm-source.exp: Remove d10v case.
* lib/gdb.exp (skip_cplus_tests): Likewise.
* gdb.asm/d10v.inc: Deleted.
2007-03-30 19:21:48 +02:00
|
|
|
|
if (strcmp (sectp->name, ".stab") == 0)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ei->stabsect = sectp;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2003-11-08 01:13:03 +01:00
|
|
|
|
else if (strcmp (sectp->name, ".stab.index") == 0)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ei->stabindexsect = sectp;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2003-11-08 01:13:03 +01:00
|
|
|
|
else if (strcmp (sectp->name, ".mdebug") == 0)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ei->mdebugsect = sectp;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct minimal_symbol *
|
2009-11-16 19:40:23 +01:00
|
|
|
|
record_minimal_symbol (const char *name, int name_len, int copy_name,
|
|
|
|
|
CORE_ADDR address,
|
2003-11-11 21:04:52 +01:00
|
|
|
|
enum minimal_symbol_type ms_type,
|
|
|
|
|
asection *bfd_section, struct objfile *objfile)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2008-03-26 15:53:28 +01:00
|
|
|
|
struct gdbarch *gdbarch = get_objfile_arch (objfile);
|
|
|
|
|
|
2011-03-28 22:21:04 +02:00
|
|
|
|
if (ms_type == mst_text || ms_type == mst_file_text
|
|
|
|
|
|| ms_type == mst_text_gnu_ifunc)
|
2008-03-26 15:53:28 +01:00
|
|
|
|
address = gdbarch_smash_text_address (gdbarch, address);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2009-11-16 19:40:23 +01:00
|
|
|
|
return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
|
|
|
|
|
ms_type, bfd_section->index,
|
|
|
|
|
bfd_section, objfile);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
2011-08-09 Pedro Alves <pedro@codesourcery.com>
gdb/
* elfread.c (elf_symtab_read): Ditto.
* maint.c (maintenance_command): Ditto.
* somread.c (som_symtab_read): Ditto.
* solib.c (solib_find, solib_map_sections, update_solib_list)
(solib_add, info_sharedlibrary_command, solib_name_from_address)
(solib_create_inferior_hook, in_solib_dynsym_resolve_code)
(sharedlibrary_command, no_shared_libraries): Rework comments.
* solib-irix.c (locate_base, disable_break, enable_break)
(irix_solib_create_inferior_hook, irix_solib_create_inferior_hook)
(irix_current_sos, irix_open_symbol_file_object)
(irix_special_symbol_handling): Ditto.
* solib-sunos.c (locate_base, first_link_map_member)
(sunos_current_sos, disable_break, enable_break)
(sunos_special_symbol_handling, sunos_solib_create_inferior_hook):
Ditto.
* solib-svr4.c (bfd_lookup_symbol, elf_locate_base, locate_base)
(open_symbol_file_object, svr4_current_sos, enable_break)
(svr4_special_symbol_handling, svr4_solib_create_inferior_hook):
Ditto.
* solib-frv.c (bfd_lookup_symbol, open_symbol_file_object)
(frv_current_sos, enable_break, frv_special_symbol_handling)
(frv_solib_create_inferior_hook): Ditto.
* solist.h (struct target_so_ops): Extend the comments of the
special_symbol_handling, current_sos and open_symbol_file_object
methods.
2011-08-09 14:51:47 +02:00
|
|
|
|
/* Read the symbol table of an ELF file.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2005-11-04 03:44:25 +01:00
|
|
|
|
Given an objfile, a symbol table, and a flag indicating whether the
|
2007-11-16 00:48:00 +01:00
|
|
|
|
symbol table contains regular, dynamic, or synthetic symbols, add all
|
|
|
|
|
the global function and data symbols to the minimal symbol table.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
In stabs-in-ELF, as implemented by Sun, there are some local symbols
|
|
|
|
|
defined in the ELF symbol table, which can be used to locate
|
|
|
|
|
the beginnings of sections from each ".o" file that was linked to
|
|
|
|
|
form the executable objfile. We gather any such info and record it
|
2011-08-09 Pedro Alves <pedro@codesourcery.com>
gdb/
* elfread.c (elf_symtab_read): Ditto.
* maint.c (maintenance_command): Ditto.
* somread.c (som_symtab_read): Ditto.
* solib.c (solib_find, solib_map_sections, update_solib_list)
(solib_add, info_sharedlibrary_command, solib_name_from_address)
(solib_create_inferior_hook, in_solib_dynsym_resolve_code)
(sharedlibrary_command, no_shared_libraries): Rework comments.
* solib-irix.c (locate_base, disable_break, enable_break)
(irix_solib_create_inferior_hook, irix_solib_create_inferior_hook)
(irix_current_sos, irix_open_symbol_file_object)
(irix_special_symbol_handling): Ditto.
* solib-sunos.c (locate_base, first_link_map_member)
(sunos_current_sos, disable_break, enable_break)
(sunos_special_symbol_handling, sunos_solib_create_inferior_hook):
Ditto.
* solib-svr4.c (bfd_lookup_symbol, elf_locate_base, locate_base)
(open_symbol_file_object, svr4_current_sos, enable_break)
(svr4_special_symbol_handling, svr4_solib_create_inferior_hook):
Ditto.
* solib-frv.c (bfd_lookup_symbol, open_symbol_file_object)
(frv_current_sos, enable_break, frv_special_symbol_handling)
(frv_solib_create_inferior_hook): Ditto.
* solist.h (struct target_so_ops): Extend the comments of the
special_symbol_handling, current_sos and open_symbol_file_object
methods.
2011-08-09 14:51:47 +02:00
|
|
|
|
in data structures hung off the objfile's private data. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2007-11-16 00:48:00 +01:00
|
|
|
|
#define ST_REGULAR 0
|
|
|
|
|
#define ST_DYNAMIC 1
|
|
|
|
|
#define ST_SYNTHETIC 2
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static void
|
2007-11-16 00:48:00 +01:00
|
|
|
|
elf_symtab_read (struct objfile *objfile, int type,
|
2009-11-16 19:40:23 +01:00
|
|
|
|
long number_of_symbols, asymbol **symbol_table,
|
|
|
|
|
int copy_names)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2008-03-26 15:53:28 +01:00
|
|
|
|
struct gdbarch *gdbarch = get_objfile_arch (objfile);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
asymbol *sym;
|
|
|
|
|
long i;
|
|
|
|
|
CORE_ADDR symaddr;
|
1999-09-09 02:02:17 +02:00
|
|
|
|
CORE_ADDR offset;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
enum minimal_symbol_type ms_type;
|
|
|
|
|
/* If sectinfo is nonNULL, it contains section info that should end up
|
|
|
|
|
filed in the objfile. */
|
|
|
|
|
struct stab_section_info *sectinfo = NULL;
|
|
|
|
|
/* If filesym is nonzero, it points to a file symbol, but we haven't
|
|
|
|
|
seen any section info for it yet. */
|
|
|
|
|
asymbol *filesym = 0;
|
2009-11-05 20:53:04 +01:00
|
|
|
|
/* Name of filesym. This is either a constant string or is saved on
|
2011-12-21 22:30:31 +01:00
|
|
|
|
the objfile's filename cache. */
|
|
|
|
|
const char *filesymname = "";
|
2004-10-23 18:18:09 +02:00
|
|
|
|
struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
|
1999-09-09 02:02:17 +02:00
|
|
|
|
int stripped = (bfd_get_symcount (objfile->obfd) == 0);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2005-11-13 19:56:34 +01:00
|
|
|
|
for (i = 0; i < number_of_symbols; i++)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
sym = symbol_table[i];
|
|
|
|
|
if (sym->name == NULL || *sym->name == '\0')
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
/* Skip names that don't exist (shouldn't happen), or names
|
2011-01-07 20:36:19 +01:00
|
|
|
|
that are null strings (may happen). */
|
2005-11-13 19:56:34 +01:00
|
|
|
|
continue;
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2006-02-21 21:38:48 +01:00
|
|
|
|
/* Skip "special" symbols, e.g. ARM mapping symbols. These are
|
|
|
|
|
symbols which do not correspond to objects in the symbol table,
|
|
|
|
|
but have some other target-specific meaning. */
|
|
|
|
|
if (bfd_is_target_special_symbol (objfile->obfd, sym))
|
2008-05-02 22:38:16 +02:00
|
|
|
|
{
|
|
|
|
|
if (gdbarch_record_special_symbol_p (gdbarch))
|
|
|
|
|
gdbarch_record_special_symbol (gdbarch, objfile, sym);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-02-21 21:38:48 +01:00
|
|
|
|
|
2005-11-13 19:56:34 +01:00
|
|
|
|
offset = ANOFFSET (objfile->section_offsets, sym->section->index);
|
2007-11-16 00:48:00 +01:00
|
|
|
|
if (type == ST_DYNAMIC
|
2012-05-05 05:05:32 +02:00
|
|
|
|
&& sym->section == bfd_und_section_ptr
|
2005-11-13 19:56:34 +01:00
|
|
|
|
&& (sym->flags & BSF_FUNCTION))
|
|
|
|
|
{
|
|
|
|
|
struct minimal_symbol *msym;
|
2007-10-31 20:09:14 +01:00
|
|
|
|
bfd *abfd = objfile->obfd;
|
2011-07-26 00:23:38 +02:00
|
|
|
|
asection *sect;
|
2005-11-13 19:56:34 +01:00
|
|
|
|
|
|
|
|
|
/* Symbol is a reference to a function defined in
|
|
|
|
|
a shared library.
|
|
|
|
|
If its value is non zero then it is usually the address
|
|
|
|
|
of the corresponding entry in the procedure linkage table,
|
|
|
|
|
plus the desired section offset.
|
|
|
|
|
If its value is zero then the dynamic linker has to resolve
|
2011-01-07 20:36:19 +01:00
|
|
|
|
the symbol. We are unable to find any meaningful address
|
2005-11-13 19:56:34 +01:00
|
|
|
|
for this symbol in the executable file, so we skip it. */
|
|
|
|
|
symaddr = sym->value;
|
|
|
|
|
if (symaddr == 0)
|
|
|
|
|
continue;
|
2007-10-31 20:09:14 +01:00
|
|
|
|
|
|
|
|
|
/* sym->section is the undefined section. However, we want to
|
|
|
|
|
record the section where the PLT stub resides with the
|
|
|
|
|
minimal symbol. Search the section table for the one that
|
|
|
|
|
covers the stub's address. */
|
|
|
|
|
for (sect = abfd->sections; sect != NULL; sect = sect->next)
|
|
|
|
|
{
|
|
|
|
|
if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (symaddr >= bfd_get_section_vma (abfd, sect)
|
|
|
|
|
&& symaddr < bfd_get_section_vma (abfd, sect)
|
|
|
|
|
+ bfd_get_section_size (sect))
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (!sect)
|
|
|
|
|
continue;
|
|
|
|
|
|
2011-12-19 05:36:29 +01:00
|
|
|
|
/* On ia64-hpux, we have discovered that the system linker
|
|
|
|
|
adds undefined symbols with nonzero addresses that cannot
|
|
|
|
|
be right (their address points inside the code of another
|
|
|
|
|
function in the .text section). This creates problems
|
|
|
|
|
when trying to determine which symbol corresponds to
|
|
|
|
|
a given address.
|
|
|
|
|
|
|
|
|
|
We try to detect those buggy symbols by checking which
|
|
|
|
|
section we think they correspond to. Normally, PLT symbols
|
|
|
|
|
are stored inside their own section, and the typical name
|
|
|
|
|
for that section is ".plt". So, if there is a ".plt"
|
|
|
|
|
section, and yet the section name of our symbol does not
|
|
|
|
|
start with ".plt", we ignore that symbol. */
|
|
|
|
|
if (strncmp (sect->name, ".plt", 4) != 0
|
|
|
|
|
&& bfd_get_section_by_name (abfd, ".plt") != NULL)
|
|
|
|
|
continue;
|
|
|
|
|
|
2007-10-31 20:09:14 +01:00
|
|
|
|
symaddr += ANOFFSET (objfile->section_offsets, sect->index);
|
|
|
|
|
|
2005-11-13 19:56:34 +01:00
|
|
|
|
msym = record_minimal_symbol
|
2009-11-16 19:40:23 +01:00
|
|
|
|
(sym->name, strlen (sym->name), copy_names,
|
|
|
|
|
symaddr, mst_solib_trampoline, sect, objfile);
|
2005-11-13 19:56:34 +01:00
|
|
|
|
if (msym != NULL)
|
|
|
|
|
msym->filename = filesymname;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2005-11-13 19:56:34 +01:00
|
|
|
|
/* If it is a nonstripped executable, do not enter dynamic
|
|
|
|
|
symbols, as the dynamic symbol table is usually a subset
|
|
|
|
|
of the main symbol table. */
|
2007-11-16 00:48:00 +01:00
|
|
|
|
if (type == ST_DYNAMIC && !stripped)
|
2005-11-13 19:56:34 +01:00
|
|
|
|
continue;
|
|
|
|
|
if (sym->flags & BSF_FILE)
|
|
|
|
|
{
|
|
|
|
|
/* STT_FILE debugging symbol that helps stabs-in-elf debugging.
|
|
|
|
|
Chain any old one onto the objfile; remember new sym. */
|
|
|
|
|
if (sectinfo != NULL)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
sectinfo->next = dbx->stab_section_info;
|
|
|
|
|
dbx->stab_section_info = sectinfo;
|
|
|
|
|
sectinfo = NULL;
|
|
|
|
|
}
|
|
|
|
|
filesym = sym;
|
2011-12-21 22:30:31 +01:00
|
|
|
|
filesymname = bcache (filesym->name, strlen (filesym->name) + 1,
|
2012-08-22 18:01:09 +02:00
|
|
|
|
objfile->per_bfd->filename_cache);
|
2005-11-13 19:56:34 +01:00
|
|
|
|
}
|
|
|
|
|
else if (sym->flags & BSF_SECTION_SYM)
|
|
|
|
|
continue;
|
|
|
|
|
else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
|
|
|
|
|
{
|
|
|
|
|
struct minimal_symbol *msym;
|
|
|
|
|
|
|
|
|
|
/* Select global/local/weak symbols. Note that bfd puts abs
|
|
|
|
|
symbols in their own section, so all symbols we are
|
2011-01-07 20:36:19 +01:00
|
|
|
|
interested in will have a section. */
|
|
|
|
|
/* Bfd symbols are section relative. */
|
2005-11-13 19:56:34 +01:00
|
|
|
|
symaddr = sym->value + sym->section->vma;
|
2008-08-22 00:28:00 +02:00
|
|
|
|
/* Relocate all non-absolute and non-TLS symbols by the
|
|
|
|
|
section offset. */
|
2012-05-05 05:05:32 +02:00
|
|
|
|
if (sym->section != bfd_abs_section_ptr
|
2008-08-22 00:28:00 +02:00
|
|
|
|
&& !(sym->section->flags & SEC_THREAD_LOCAL))
|
2005-11-13 19:56:34 +01:00
|
|
|
|
{
|
|
|
|
|
symaddr += offset;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2005-11-13 19:56:34 +01:00
|
|
|
|
/* For non-absolute symbols, use the type of the section
|
|
|
|
|
they are relative to, to intuit text/data. Bfd provides
|
2011-01-07 20:36:19 +01:00
|
|
|
|
no way of figuring this out for absolute symbols. */
|
2012-05-05 05:05:32 +02:00
|
|
|
|
if (sym->section == bfd_abs_section_ptr)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
/* This is a hack to get the minimal symbol type
|
|
|
|
|
right for Irix 5, which has absolute addresses
|
2007-11-16 00:48:00 +01:00
|
|
|
|
with special section indices for dynamic symbols.
|
|
|
|
|
|
|
|
|
|
NOTE: uweigand-20071112: Synthetic symbols do not
|
|
|
|
|
have an ELF-private part, so do not touch those. */
|
2011-07-26 00:23:38 +02:00
|
|
|
|
unsigned int shndx = type == ST_SYNTHETIC ? 0 :
|
2005-11-13 19:56:34 +01:00
|
|
|
|
((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
|
|
|
|
|
|
|
|
|
|
switch (shndx)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
case SHN_MIPS_TEXT:
|
|
|
|
|
ms_type = mst_text;
|
|
|
|
|
break;
|
|
|
|
|
case SHN_MIPS_DATA:
|
|
|
|
|
ms_type = mst_data;
|
|
|
|
|
break;
|
|
|
|
|
case SHN_MIPS_ACOMMON:
|
|
|
|
|
ms_type = mst_bss;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ms_type = mst_abs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If it is an Irix dynamic symbol, skip section name
|
2011-01-07 20:36:19 +01:00
|
|
|
|
symbols, relocate all others by section offset. */
|
2005-11-13 19:56:34 +01:00
|
|
|
|
if (ms_type != mst_abs)
|
|
|
|
|
{
|
|
|
|
|
if (sym->name[0] == '.')
|
|
|
|
|
continue;
|
1999-09-09 02:02:17 +02:00
|
|
|
|
symaddr += offset;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2005-11-13 19:56:34 +01:00
|
|
|
|
}
|
|
|
|
|
else if (sym->section->flags & SEC_CODE)
|
|
|
|
|
{
|
2006-12-01 19:14:30 +01:00
|
|
|
|
if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2011-03-28 22:21:04 +02:00
|
|
|
|
if (sym->flags & BSF_GNU_INDIRECT_FUNCTION)
|
|
|
|
|
ms_type = mst_text_gnu_ifunc;
|
|
|
|
|
else
|
|
|
|
|
ms_type = mst_text;
|
2005-11-13 19:56:34 +01:00
|
|
|
|
}
|
2011-04-17 20:09:02 +02:00
|
|
|
|
/* The BSF_SYNTHETIC check is there to omit ppc64 function
|
|
|
|
|
descriptors mistaken for static functions starting with 'L'.
|
|
|
|
|
*/
|
|
|
|
|
else if ((sym->name[0] == '.' && sym->name[1] == 'L'
|
|
|
|
|
&& (sym->flags & BSF_SYNTHETIC) == 0)
|
2005-11-13 19:56:34 +01:00
|
|
|
|
|| ((sym->flags & BSF_LOCAL)
|
|
|
|
|
&& sym->name[0] == '$'
|
|
|
|
|
&& sym->name[1] == 'L'))
|
|
|
|
|
/* Looks like a compiler-generated label. Skip
|
|
|
|
|
it. The assembler should be skipping these (to
|
|
|
|
|
keep executables small), but apparently with
|
|
|
|
|
gcc on the (deleted) delta m88k SVR4, it loses.
|
|
|
|
|
So to have us check too should be harmless (but
|
|
|
|
|
I encourage people to fix this in the assembler
|
|
|
|
|
instead of adding checks here). */
|
|
|
|
|
continue;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ms_type = mst_file_text;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2005-11-13 19:56:34 +01:00
|
|
|
|
}
|
|
|
|
|
else if (sym->section->flags & SEC_ALLOC)
|
|
|
|
|
{
|
|
|
|
|
if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
if (sym->section->flags & SEC_LOAD)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
ms_type = mst_data;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
ms_type = mst_bss;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2005-11-13 19:56:34 +01:00
|
|
|
|
else if (sym->flags & BSF_LOCAL)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
/* Named Local variable in a Data section.
|
|
|
|
|
Check its name for stabs-in-elf. */
|
|
|
|
|
int special_local_sect;
|
2010-05-14 20:35:11 +02:00
|
|
|
|
|
2005-11-13 19:56:34 +01:00
|
|
|
|
if (strcmp ("Bbss.bss", sym->name) == 0)
|
|
|
|
|
special_local_sect = SECT_OFF_BSS (objfile);
|
|
|
|
|
else if (strcmp ("Ddata.data", sym->name) == 0)
|
|
|
|
|
special_local_sect = SECT_OFF_DATA (objfile);
|
|
|
|
|
else if (strcmp ("Drodata.rodata", sym->name) == 0)
|
|
|
|
|
special_local_sect = SECT_OFF_RODATA (objfile);
|
|
|
|
|
else
|
|
|
|
|
special_local_sect = -1;
|
|
|
|
|
if (special_local_sect >= 0)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
/* Found a special local symbol. Allocate a
|
|
|
|
|
sectinfo, if needed, and fill it in. */
|
|
|
|
|
if (sectinfo == NULL)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
int max_index;
|
|
|
|
|
size_t size;
|
|
|
|
|
|
2009-04-30 23:59:03 +02:00
|
|
|
|
max_index = SECT_OFF_BSS (objfile);
|
|
|
|
|
if (objfile->sect_index_data > max_index)
|
|
|
|
|
max_index = objfile->sect_index_data;
|
|
|
|
|
if (objfile->sect_index_rodata > max_index)
|
|
|
|
|
max_index = objfile->sect_index_rodata;
|
2005-11-13 19:56:34 +01:00
|
|
|
|
|
|
|
|
|
/* max_index is the largest index we'll
|
|
|
|
|
use into this array, so we must
|
|
|
|
|
allocate max_index+1 elements for it.
|
|
|
|
|
However, 'struct stab_section_info'
|
|
|
|
|
already includes one element, so we
|
|
|
|
|
need to allocate max_index aadditional
|
|
|
|
|
elements. */
|
2011-07-26 00:23:38 +02:00
|
|
|
|
size = (sizeof (struct stab_section_info)
|
2011-03-07 12:13:08 +01:00
|
|
|
|
+ (sizeof (CORE_ADDR) * max_index));
|
2005-11-13 19:56:34 +01:00
|
|
|
|
sectinfo = (struct stab_section_info *)
|
|
|
|
|
xmalloc (size);
|
|
|
|
|
memset (sectinfo, 0, size);
|
|
|
|
|
sectinfo->num_sections = max_index;
|
|
|
|
|
if (filesym == NULL)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
complaint (&symfile_complaints,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
_("elf/stab section information %s "
|
|
|
|
|
"without a preceding file symbol"),
|
2005-11-13 19:56:34 +01:00
|
|
|
|
sym->name);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
sectinfo->filename =
|
|
|
|
|
(char *) filesym->name;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2005-11-13 19:56:34 +01:00
|
|
|
|
if (sectinfo->sections[special_local_sect] != 0)
|
|
|
|
|
complaint (&symfile_complaints,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
_("duplicated elf/stab section "
|
|
|
|
|
"information for %s"),
|
2005-11-13 19:56:34 +01:00
|
|
|
|
sectinfo->filename);
|
|
|
|
|
/* BFD symbols are section relative. */
|
|
|
|
|
symaddr = sym->value + sym->section->vma;
|
|
|
|
|
/* Relocate non-absolute symbols by the
|
|
|
|
|
section offset. */
|
2012-05-05 05:05:32 +02:00
|
|
|
|
if (sym->section != bfd_abs_section_ptr)
|
2005-11-13 19:56:34 +01:00
|
|
|
|
symaddr += offset;
|
|
|
|
|
sectinfo->sections[special_local_sect] = symaddr;
|
|
|
|
|
/* The special local symbols don't go in the
|
|
|
|
|
minimal symbol table, so ignore this one. */
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
/* Not a special stabs-in-elf symbol, do regular
|
|
|
|
|
symbol processing. */
|
|
|
|
|
if (sym->section->flags & SEC_LOAD)
|
|
|
|
|
{
|
|
|
|
|
ms_type = mst_file_data;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
ms_type = mst_file_bss;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2005-11-13 19:56:34 +01:00
|
|
|
|
ms_type = mst_unknown;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2005-11-13 19:56:34 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* FIXME: Solaris2 shared libraries include lots of
|
2011-07-26 00:23:38 +02:00
|
|
|
|
odd "absolute" and "undefined" symbols, that play
|
2005-11-13 19:56:34 +01:00
|
|
|
|
hob with actions like finding what function the PC
|
|
|
|
|
is in. Ignore them if they aren't text, data, or bss. */
|
|
|
|
|
/* ms_type = mst_unknown; */
|
2011-01-07 20:36:19 +01:00
|
|
|
|
continue; /* Skip this symbol. */
|
2005-11-13 19:56:34 +01:00
|
|
|
|
}
|
|
|
|
|
msym = record_minimal_symbol
|
2009-11-16 19:40:23 +01:00
|
|
|
|
(sym->name, strlen (sym->name), copy_names, symaddr,
|
2005-11-13 19:56:34 +01:00
|
|
|
|
ms_type, sym->section, objfile);
|
2007-11-16 00:48:00 +01:00
|
|
|
|
|
2005-11-13 19:56:34 +01:00
|
|
|
|
if (msym)
|
|
|
|
|
{
|
|
|
|
|
/* Pass symbol size field in via BFD. FIXME!!! */
|
2007-11-16 00:48:00 +01:00
|
|
|
|
elf_symbol_type *elf_sym;
|
|
|
|
|
|
|
|
|
|
/* NOTE: uweigand-20071112: A synthetic symbol does not have an
|
|
|
|
|
ELF-private part. However, in some cases (e.g. synthetic
|
|
|
|
|
'dot' symbols on ppc64) the udata.p entry is set to point back
|
|
|
|
|
to the original ELF symbol it was derived from. Get the size
|
2011-07-26 00:23:38 +02:00
|
|
|
|
from that symbol. */
|
2007-11-16 00:48:00 +01:00
|
|
|
|
if (type != ST_SYNTHETIC)
|
|
|
|
|
elf_sym = (elf_symbol_type *) sym;
|
|
|
|
|
else
|
|
|
|
|
elf_sym = (elf_symbol_type *) sym->udata.p;
|
|
|
|
|
|
|
|
|
|
if (elf_sym)
|
2012-09-11 23:26:16 +02:00
|
|
|
|
SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size);
|
2011-07-26 00:23:38 +02:00
|
|
|
|
|
2009-11-13 23:47:13 +01:00
|
|
|
|
msym->filename = filesymname;
|
|
|
|
|
gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
|
2005-11-13 19:56:34 +01:00
|
|
|
|
}
|
2008-05-14 20:14:34 +02:00
|
|
|
|
|
|
|
|
|
/* For @plt symbols, also record a trampoline to the
|
|
|
|
|
destination symbol. The @plt symbol will be used in
|
|
|
|
|
disassembly, and the trampoline will be used when we are
|
|
|
|
|
trying to find the target. */
|
|
|
|
|
if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
|
|
|
|
|
{
|
|
|
|
|
int len = strlen (sym->name);
|
|
|
|
|
|
|
|
|
|
if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
|
|
|
|
|
{
|
|
|
|
|
struct minimal_symbol *mtramp;
|
|
|
|
|
|
2009-11-16 19:40:23 +01:00
|
|
|
|
mtramp = record_minimal_symbol (sym->name, len - 4, 1,
|
|
|
|
|
symaddr,
|
2008-05-14 20:14:34 +02:00
|
|
|
|
mst_solib_trampoline,
|
|
|
|
|
sym->section, objfile);
|
|
|
|
|
if (mtramp)
|
|
|
|
|
{
|
2012-09-11 23:26:16 +02:00
|
|
|
|
SET_MSYMBOL_SIZE (mtramp, MSYMBOL_SIZE (msym));
|
2012-06-19 02:53:35 +02:00
|
|
|
|
mtramp->created_by_gdb = 1;
|
2008-05-14 20:14:34 +02:00
|
|
|
|
mtramp->filename = filesymname;
|
|
|
|
|
gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
/* 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 = objfile->gdbarch;
|
|
|
|
|
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)
|
|
|
|
|
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++)
|
|
|
|
|
{
|
2012-05-18 23:02:52 +02:00
|
|
|
|
const char *name;
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
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. */
|
|
|
|
|
|
2011-07-23 18:49:16 +02:00
|
|
|
|
if (string_buffer_size < name_len + got_suffix_len + 1)
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
{
|
|
|
|
|
string_buffer_size = 2 * (name_len + got_suffix_len);
|
|
|
|
|
string_buffer = xrealloc (string_buffer, string_buffer_size);
|
|
|
|
|
}
|
|
|
|
|
memcpy (string_buffer, name, name_len);
|
|
|
|
|
memcpy (&string_buffer[name_len], SYMBOL_GOT_PLT_SUFFIX,
|
2011-07-23 18:49:16 +02:00
|
|
|
|
got_suffix_len + 1);
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
|
|
|
|
|
msym = record_minimal_symbol (string_buffer, name_len + got_suffix_len,
|
|
|
|
|
1, address, mst_slot_got_plt, got_plt,
|
|
|
|
|
objfile);
|
|
|
|
|
if (msym)
|
2012-09-11 23:26:16 +02:00
|
|
|
|
SET_MSYMBOL_SIZE (msym, ptr_size);
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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 = 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 = a_voidp;
|
|
|
|
|
const struct elf_gnu_ifunc_cache *b = 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 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 == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
if (SYMBOL_VALUE_ADDRESS (msym) != addr)
|
|
|
|
|
return 0;
|
|
|
|
|
/* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL. */
|
|
|
|
|
sect = SYMBOL_OBJ_SECTION (msym)->the_bfd_section;
|
|
|
|
|
objfile = SYMBOL_OBJ_SECTION (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 = 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 = obstack_finish (&objfile->objfile_obstack);
|
|
|
|
|
|
|
|
|
|
slot = htab_find_slot (htab, entry_p, INSERT);
|
|
|
|
|
if (*slot != NULL)
|
|
|
|
|
{
|
|
|
|
|
struct elf_gnu_ifunc_cache *entry_found_p = *slot;
|
|
|
|
|
struct gdbarch *gdbarch = objfile->gdbarch;
|
|
|
|
|
|
|
|
|
|
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 = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
|
|
|
|
|
if (htab == NULL)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
entry_p = 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 = *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 = 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 = objfile->gdbarch;
|
|
|
|
|
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 = alloca (ptr_size);
|
|
|
|
|
struct minimal_symbol *msym;
|
|
|
|
|
|
|
|
|
|
msym = lookup_minimal_symbol (name_got_plt, NULL, objfile);
|
|
|
|
|
if (msym == NULL)
|
|
|
|
|
continue;
|
|
|
|
|
if (MSYMBOL_TYPE (msym) != mst_slot_got_plt)
|
|
|
|
|
continue;
|
|
|
|
|
pointer_address = SYMBOL_VALUE_ADDRESS (msym);
|
|
|
|
|
|
|
|
|
|
plt = bfd_get_section_by_name (obfd, ".plt");
|
|
|
|
|
if (plt == NULL)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (MSYMBOL_SIZE (msym) != 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);
|
|
|
|
|
|
|
|
|
|
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;
|
2011-07-26 00:23:38 +02:00
|
|
|
|
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
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)
|
|
|
|
|
{
|
2012-02-02 21:19:17 +01:00
|
|
|
|
const char *name_at_pc;
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
if (name_at_pc)
|
|
|
|
|
elf_gnu_ifunc_record_cache (name_at_pc, address);
|
|
|
|
|
|
|
|
|
|
return address;
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-28 22:29:51 +02:00
|
|
|
|
/* 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 = pid_to_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);
|
|
|
|
|
|
2012-02-29 15:52:44 +01:00
|
|
|
|
/* set_momentary_breakpoint invalidates PREV_FRAME. */
|
|
|
|
|
prev_frame = NULL;
|
|
|
|
|
|
2011-03-28 22:29:51 +02:00
|
|
|
|
/* 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);
|
2012-05-16 16:35:09 +02:00
|
|
|
|
struct value *func_func;
|
2011-03-28 22:29:51 +02:00
|
|
|
|
struct value *value;
|
|
|
|
|
CORE_ADDR resolved_address, resolved_pc;
|
|
|
|
|
struct symtab_and_line sal;
|
2011-03-31 16:32:49 +02:00
|
|
|
|
struct symtabs_and_lines sals, sals_end;
|
2011-03-28 22:29:51 +02:00
|
|
|
|
|
|
|
|
|
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);
|
2012-05-16 16:35:09 +02:00
|
|
|
|
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);
|
2011-03-28 22:29:51 +02:00
|
|
|
|
|
the "ambiguous linespec" series
gdb
2011-12-06 Joel Brobecker <brobecker@acacore.com>
* language.h (struct language_defn): Add new component
la_symbol_name_compare.
* symfile.h (struct quick_symbol_functions): Update the profile
of parameter "name_matcher" for the expand_symtabs_matching
method. Update the documentation accordingly.
* ada-lang.h (ada_name_for_lookup): Add declaration.
* ada-lang.c (ada_name_for_lookup): New function, extracted out
from ada_iterate_over_symbols.
(ada_iterate_over_symbols): Do not encode symbol name anymore.
(ada_expand_partial_symbol_name): Adjust profile.
(ada_language_defn): Add value for la_symbol_name_compare field.
* linespec.c: #include "ada-lang.h".
(iterate_name_matcher): Add language parameter. Replace call
to strcmp_iw by call to language->la_symbol_name_compare.
(decode_variable): Encode COPY if current language is Ada.
* dwarf2read.c (dw2_expand_symtabs_matching): Adjust profile
of name_matcher parameter. Adjust call to name_matcher.
* psymtab.c (expand_symtabs_matching_via_partial): Likewise.
(expand_partial_symbol_names): Update profile of parameter "fun".
* psymtab.h (expand_partial_symbol_names): Update profile of
parameter "fun".
* symtab.c (demangle_for_lookup): Update function documentation.
(search_symbols_name_matches): Add language parameter.
(expand_partial_symbol_name): Likewise.
* c-lang.c (c_language_defn, cplus_language_defn)
(asm_language_defn, minimal_language_defn): Add value for
la_symbol_name_compare field.
* d-lang.c (d_language_defn): Likewise.
* f-lang.c (f_language_defn): Ditto.
* jv-lang.c (java_language_defn): Ditto.
* m2-lang.c (m2_language_defn): Ditto.
* objc-lang.c (objc_language_defn): Ditto.
* opencl-lang.c (opencl_language_defn): Ditto.
* p-lang.c (pascal_language_defn): Ditto.
* language.c (unknown_language_defn, auto_language_defn)
(local_language_defn): Ditto.
2011-12-06 Tom Tromey <tromey@redhat.com>
* linespec.c (iterate_over_all_matching_symtabs): Use
LA_ITERATE_OVER_SYMBOLS.
(lookup_prefix_sym, add_matching_symbols_to_info): Likewise.
(find_function_symbols, decode_variable): Remove Ada special
case.
* language.h (struct language_defn) <la_iterate_over_symbols>: New
field.
(LA_ITERATE_OVER_SYMBOLS): New macro.
* language.c (unknown_language_defn, auto_language_defn)
(local_language_defn): Update.
* c-lang.c (c_language_defn, cplus_language_defn)
(asm_language_defn, minimal_language_defn): Update.
* d-lang.c (d_language_defn): Update.
* f-lang.c (f_language_defn): Update.
* jv-lang.c (java_language_defn): Update.
* m2-lang.c (m2_language_defn): Update.
* objc-lang.c (objc_language_defn): Update.
* opencl-lang.c (opencl_language_defn): Update.
* p-lang.c (pascal_language_defn): Update.
* ada-lang.c (ada_iterate_over_symbols): New function.
(ada_language_defn): Update.
2011-12-06 Tom Tromey <tromey@redhat.com>
Joel Brobecker <brobecker@acacore.com>
PR breakpoints/13105, PR objc/8341, PR objc/8343, PR objc/8366,
PR objc/8535, PR breakpoints/11657, PR breakpoints/11970,
PR breakpoints/12023, PR breakpoints/12334, PR breakpoints/12856,
PR shlibs/8929, PR shlibs/7393:
* python/py-type.c (compare_maybe_null_strings): Rename from
compare_strings.
(check_types_equal): Update.
* utils.c (compare_strings): New function.
* tui/tui-winsource.c (tui_update_breakpoint_info): Update for
location changes.
* tracepoint.c (scope_info): Update.
(trace_find_line_command): Use DECODE_LINE_FUNFIRSTLINE.
* symtab.h (iterate_over_minimal_symbols)
(iterate_over_some_symtabs, iterate_over_symtabs)
(find_pcs_for_symtab_line, iterate_over_symbols)
(demangle_for_lookup): Declare.
(expand_line_sal): Remove.
* symtab.c (iterate_over_some_symtabs, iterate_over_symtabs)
(lookup_symtab_callback): New functions.
(lookup_symtab): Rewrite.
(demangle_for_lookup): New function, extract from
lookup_symbol_in_language.
(lookup_symbol_in_language): Use it.
(iterate_over_symbols): New function.
(find_line_symtab): Update.
(find_pcs_for_symtab_line): New functions.
(find_line_common): Add 'start' argument.
(decode_line_spec): Update. Change argument to 'flags', change
interpretation.
(append_expanded_sal): Remove.
(append_exact_match_to_sals): Remove.
(expand_line_sal): Remove.
* symfile.h (struct quick_symbol_functions) <lookup_symtab>:
Remove.
<map_symtabs_matching_filename>: New field.
* stack.c (func_command): Only look in the current program space.
Use DECODE_LINE_FUNFIRSTLINE.
* source.c (line_info): Set pspace on sal. Check program space in
the loop. Use DECODE_LINE_LIST_MODE.
(select_source_symtab): Use DECODE_LINE_FUNFIRSTLINE.
* solib-target.c: Remove DEF_VEC_I(CORE_ADDR).
* python/python.c (gdbpy_decode_line): Update.
* psymtab.c (partial_map_expand_apply): New function.
(partial_map_symtabs_matching_filename): Rename from
lookup_partial_symbol. Update arguments.
(lookup_symtab_via_partial_symtab): Remove.
(psym_functions): Update.
* objc-lang.h (parse_selector, parse_method): Don't declare.
(find_imps): Update.
* objc-lang.c (parse_selector, parse_method): Now static.
(find_methods): Change arguments. Fill in a vector of symbol
names.
(uniquify_strings): New function.
(find_imps): Change arguments.
* minsyms.c (iterate_over_minimal_symbols): New function.
* linespec.h (enum decode_line_flags): New.
(struct linespec_sals): New.
(struct linespec_result) <canonical>: Remove.
<pre_expanded, addr_string, sals>: New fields.
(destroy_linespec_result, make_cleanup_destroy_linespec_result)
(decode_line_full): Declare.
(decode_line_1): Update.
* linespec.c (struct address_entry, struct linespec_state, struct
collect_info): New types.
(add_sal_to_sals_basic, add_sal_to_sals, hash_address_entry)
(eq_address_entry, maybe_add_address): New functions.
(total_number_of_methods): Remove.
(iterate_name_matcher, iterate_over_all_matching_symtabs): New
functions.
(find_methods): Change arguments. Don't canonicalize input.
Simplify logic.
(add_matching_methods, add_constructors)
(build_canonical_line_spec): Remove.
(filter_results, convert_results_to_lsals): New functions.
(decode_line_2): Change arguments. Rewrite for new data
structures.
(decode_line_internal): Rename from decode_line_1. Change
arguments. Add cleanups. Update for new data structures.
(linespec_state_constructor, linespec_state_destructor)
(decode_line_full, decode_line_1): New functions.
(decode_indirect): Change arguments. Update.
(locate_first_half): Use skip_spaces.
(decode_objc): Change arguments. Update for new data structures.
Simplify logic.
(decode_compound): Change arguments. Add cleanups. Remove
fallback code, replace with error.
(struct decode_compound_collector): New type.
(collect_one_symbol): New function.
(lookup_prefix_sym): Change arguments. Update.
(compare_symbol_name, add_all_symbol_names_from_pspace)
(find_superclass_methods ): New functions.
(find_method): Rewrite.
(struct symtab_collector): New type.
(add_symtabs_to_list, collect_symtabs_from_filename): New
functions.
(symtabs_from_filename): Change API. Rename from
symtab_from_filename.
(collect_function_symbols): New function.
(find_function_symbols): Change API. Rename from
find_function_symbol. Rewrite.
(decode_all_digits): Change arguments. Rewrite.
(decode_dollar): Change arguments. Use decode_variable.
(decode_label): Change arguments. Rewrite.
(collect_symbols): New function.
(minsym_found): Change arguments. Rewrite.
(check_minsym, search_minsyms_for_name)
(add_matching_symbols_to_info): New function.
(decode_variable): Change arguments. Iterate over all symbols.
(symbol_found): Remove.
(symbol_to_sal): New function.
(init_linespec_result, destroy_linespec_result)
(cleanup_linespec_result, make_cleanup_destroy_linespec_result):
New functions.
(decode_digits_list_mode, decode_digits_ordinary): New functions.
* dwarf2read.c (dw2_map_expand_apply): New function.
(dw2_map_symtabs_matching_filename): Rename from
dw2_lookup_symtab. Change arguments.
(dwarf2_gdb_index_functions): Update.
* dwarf2loc.c: Remove DEF_VEC_I(CORE_ADDR).
* defs.h (compare_strings): Declare.
* cli/cli-cmds.c (compare_strings): Move to utils.c.
(edit_command, list_command): Use DECODE_LINE_LIST_MODE. Call
filter_sals.
(compare_symtabs, filter_sals): New functions.
* breakpoint.h (struct bp_location) <line_number, source_file>:
New fields.
(struct breakpoint) <line_number, source_file>: Remove.
<filter>: New field.
* breakpoint.c (print_breakpoint_location, init_raw_breakpoint)
(momentary_breakpoint_from_master, add_location_to_breakpoint):
Update for changes to locations.
(init_breakpoint_sal): Add 'filter' argument. Set 'filter' on
breakpoint.
(create_breakpoint_sal): Add 'filter' argument.
(remove_sal, expand_line_sal_maybe): Remove.
(create_breakpoints_sal): Remove 'sals' argument. Handle
pre-expanded sals and the filter.
(parse_breakpoint_sals): Use decode_line_full.
(check_fast_tracepoint_sals): Use get_sal_arch.
(create_breakpoint): Create a linespec_sals. Update.
(break_range_command): Use decode_line_full. Update.
(until_break_command): Update.
(clear_command): Update match conditions for linespec.c changes.
Use DECODE_LINE_LIST_MODE.
(say_where): Update for changes to locations.
(bp_location_dtor): Free 'source_file'.
(base_breakpoint_dtor): Free 'filter'. Don't free 'source_file'.
(update_static_tracepoint): Update for changes to locations.
(update_breakpoint_locations): Disable ranged breakpoint if too
many locations match. Update.
(addr_string_to_sals): Use decode_line_full. Resolve all sal
PCs.
(breakpoint_re_set_default): Don't call expand_line_sal_maybe.
(decode_line_spec_1): Update. Change argument name to 'flags',
change interpretation.
* block.h (block_containing_function): Declare.
* block.c (block_containing_function): New function.
* skip.c (skip_function_command): Update.
(skip_re_set): Update.
* infcmd.c (jump_command): Use DECODE_LINE_FUNFIRSTLINE.
* mi/mi-main.c (mi_cmd_trace_find): Use DECODE_LINE_FUNFIRSTLINE.
* NEWS: Add entry.
2011-12-06 Tom Tromey <tromey@redhat.com>
* elfread.c (elf_gnu_ifunc_resolver_return_stop): Allow
breakpoint's pspace to be NULL.
* breakpoint.h (struct breakpoint) <pspace>: Update comment.
* breakpoint.c (init_raw_breakpoint): Conditionally set
breakpoint's pspace.
(init_breakpoint_sal): Don't set breakpoint's pspace.
(prepare_re_set_context): Conditionally switch program space.
(addr_string_to_sals): Check executing_startup on location's
program space.
2011-12-06 Tom Tromey <tromey@redhat.com>
* breakpoint.h (enum enable_state) <bp_startup_disabled>: Remove.
* breakpoint.c (should_be_inserted): Explicitly check if program
space is executing startup.
(describe_other_breakpoints): Update.
(disable_breakpoints_before_startup): Change executing_startup
earlier. Remove loop.
(enable_breakpoints_after_startup): Likewise.
(init_breakpoint_sal): Don't use bp_startup_disabled.
(create_breakpoint): Don't use bp_startup_disabled.
(update_global_location_list): Use should_be_inserted.
(bkpt_re_set): Update.
gdb/testsuite
2011-12-06 Joel Brobecker <brobecker@acacore.com>
* gdb.ada/fullname_bp.exp: Add tests for other valid linespecs
involving a fully qualified function name.
2011-12-06 Tom Tromey <tromey@redhat.com>
* gdb.ada/homonym.exp: Add three breakpoint tests.
2011-12-06 Tom Tromey <tromey@redhat.com>
* gdb.base/solib-weak.exp (do_test): Remove kfail.
* gdb.trace/tracecmd.exp: Disable pending breakpoints earlier.
* gdb.objc/objcdecode.exp: Update for output changes.
* gdb.linespec/linespec.exp: New file.
* gdb.linespec/lspec.cc: New file.
* gdb.linespec/lspec.h: New file.
* gdb.linespec/body.h: New file.
* gdb.linespec/base/two/thefile.cc: New file.
* gdb.linespec/base/one/thefile.cc: New file.
* gdb.linespec/Makefile.in: New file.
* gdb.cp/templates.exp (test_template_breakpoints): Update for
output changes.
* gdb.cp/re-set-overloaded.exp: Remove kfail.
* gdb.cp/ovldbreak.exp: Update for output changes. "all" test now
makes one breakpoint.
* gdb.cp/method2.exp (test_break): Update for output changes.
* gdb.cp/mb-templates.exp: Update for output changes.
* gdb.cp/mb-inline.exp: Update for output changes.
* gdb.cp/mb-ctor.exp: Update for output changes.
* gdb.cp/ovsrch.exp: Use fully-qualified names.
* gdb.base/solib-symbol.exp: Run to main later. Breakpoint now
has multiple matches.
* gdb.base/sepdebug.exp: Disable pending breakpoints. Update for
error message change.
* gdb.base/list.exp (test_list_filename_and_number): Update for
error message change.
* gdb.base/break.exp: Disable pending breakpoints. Update for
output changes.
* configure.ac: Add gdb.linespec.
* configure: Rebuild.
* Makefile.in (ALL_SUBDIRS): Add gdb.linespec.
gdb/doc
2011-12-06 Tom Tromey <tromey@redhat.com>
* gdb.texinfo (Set Breaks): Update for new behavior.
2011-12-06 19:54:43 +01:00
|
|
|
|
gdb_assert (current_program_space == b->pspace || b->pspace == NULL);
|
2011-03-28 22:29:51 +02:00
|
|
|
|
elf_gnu_ifunc_record_cache (b->addr_string, resolved_pc);
|
|
|
|
|
|
|
|
|
|
sal = find_pc_line (resolved_pc, 0);
|
|
|
|
|
sals.nelts = 1;
|
|
|
|
|
sals.sals = &sal;
|
2011-03-31 16:32:49 +02:00
|
|
|
|
sals_end.nelts = 0;
|
2011-03-28 22:29:51 +02:00
|
|
|
|
|
|
|
|
|
b->type = bp_breakpoint;
|
2011-03-31 16:32:49 +02:00
|
|
|
|
update_breakpoint_locations (b, sals, sals_end);
|
2011-03-28 22:29:51 +02:00
|
|
|
|
}
|
|
|
|
|
|
2009-12-14 13:50:39 +01:00
|
|
|
|
struct build_id
|
|
|
|
|
{
|
|
|
|
|
size_t size;
|
|
|
|
|
gdb_byte data[1];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Locate NT_GNU_BUILD_ID from ABFD and return its content. */
|
|
|
|
|
|
|
|
|
|
static struct build_id *
|
|
|
|
|
build_id_bfd_get (bfd *abfd)
|
|
|
|
|
{
|
|
|
|
|
struct build_id *retval;
|
|
|
|
|
|
|
|
|
|
if (!bfd_check_format (abfd, bfd_object)
|
|
|
|
|
|| bfd_get_flavour (abfd) != bfd_target_elf_flavour
|
|
|
|
|
|| elf_tdata (abfd)->build_id == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
retval = xmalloc (sizeof *retval - 1 + elf_tdata (abfd)->build_id_size);
|
|
|
|
|
retval->size = elf_tdata (abfd)->build_id_size;
|
|
|
|
|
memcpy (retval->data, elf_tdata (abfd)->build_id, retval->size);
|
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
build_id_verify (const char *filename, struct build_id *check)
|
|
|
|
|
{
|
|
|
|
|
bfd *abfd;
|
|
|
|
|
struct build_id *found = NULL;
|
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
|
|
/* We expect to be silent on the non-existing files. */
|
2012-07-23 17:03:59 +02:00
|
|
|
|
abfd = gdb_bfd_open_maybe_remote (filename);
|
2009-12-14 13:50:39 +01:00
|
|
|
|
if (abfd == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
found = build_id_bfd_get (abfd);
|
|
|
|
|
|
|
|
|
|
if (found == NULL)
|
|
|
|
|
warning (_("File \"%s\" has no build-id, file skipped"), filename);
|
|
|
|
|
else if (found->size != check->size
|
|
|
|
|
|| memcmp (found->data, check->data, found->size) != 0)
|
2011-01-05 23:22:53 +01:00
|
|
|
|
warning (_("File \"%s\" has a different build-id, file skipped"),
|
|
|
|
|
filename);
|
2009-12-14 13:50:39 +01:00
|
|
|
|
else
|
|
|
|
|
retval = 1;
|
|
|
|
|
|
* dwarf2read.c (try_open_dwo_file): Use gdb_bfd_ref and
gdb_bfd_unref.
(free_dwo_file): Use gdb_bfd_unref.
* cli/cli-dump.c: Include gdb_bfd.h.
(bfd_openw_with_cleanup): Use gdb_bfd_ref.
(bfd_openr_with_cleanup): Likewise.
* windows-nat.c (windows_make_so): Use gdb_bfd_ref,
gdb_bfd_unref.
* utils.c: Include gdb_bfd.h.
(do_bfd_close_cleanup): Use gdb_bfd_unref.
* symfile.c: Include gdb_bfd.h.
(separate_debug_file_exists): Use gdb_bfd_unref.
(bfd_open_maybe_remote): Use gdb_bfd_ref.
(symfile_bfd_open): Use gdb_bfd_ref, gdb_bfd_unref.
(generic_load): Use gdb_bfd_ref.
(reread_symbols): Use gdb_bfd_unref.
* symfile-mem.c: Include gdb_bfd.h.
(symbol_file_add_from_memory): Use make_cleanup_bfd_close.
* spu-linux-nat.c (spu_bfd_open): Use gdb_bfd_ref, gdb_bfd_unref.
* solib.c: Include gdb_bfd.h.
(solib_bfd_fopen): Use gdb_bfd_ref.
(solib_bfd_open): Use gdb_bfd_unref.
(free_so_symbols): Use gdb_bfd_unref.
(reload_shared_libraries_1): Use gdb_bfd_unref.
* solib-spu.c: Include gdb_bfd.h.
(spu_bfd_fopen): Use gdb_bfd_ref, gdb_bfd_unref.
* solib-pa64.c (pa64_solib_create_inferior_hook): Use gdb_bfd_ref,
gdb_bfd_unref.
* solib-frv.c: Include gdb_bfd.h.
(enable_break2): Use gdb_bfd_unref.
* solib-dsbt.c: Include gdb_bfd.h.
(enable_break2): Use gdb_bfd_unref.
* solib-darwin.c: Include gdb_bfd.h.
(darwin_solib_get_all_image_info_addr_at_init): Use gdb_bfd_ref,
gdb_bfd_unref.
(darwin_bfd_open): Use gdb_bfd_unref.
* rs6000-nat.c (add_vmap): Use gdb_bfd_ref, gdb_bfd_unref.
* remote-mips.c: Include gdb_bfd.h.
(mips_load_srec): Use gdb_bfd_ref.
(pmon_load_fast): Use gdb_bfd_ref.
* remote-m32r-sdi.c: Include gdb_bfd.h.
(m32r_load): Use gdb_bfd_ref.
* record.c: Include gdb_bfd.h.
(record_save_cleanups): Use gdb_bfd_unref.
(cmd_record_save): Use gdb_bfd_unref.
* procfs.c (insert_dbx_link_bpt_in_file): Use gdb_bfd_ref,
gdb_bfd_unref.
* objfiles.h (gdb_bfd_close_or_warn): Remove.
(gdb_bfd_ref, gdb_bfd_unref): Move to gdb_bfd.h.
* objfiles.c: Include gdb_bfd.h.
(free_objfile): Use gdb_bfd_unref.
(gdb_bfd_close_or_warn, gdb_bfd_ref, gdb_bfd_unref): Move to
gdb_bfd.c.
* machoread.c (macho_add_oso_symfile): Use gdb_bfd_unref.
(macho_symfile_read_all_oso): Use gdb_bfd_ref, gdb_bfd_unref.
(macho_check_dsym): Likewise.
* m32r-rom.c: Include gdb_bfd.h.
(m32r_load): Use gdb_bfd_ref.
(m32r_upload_command): Use gdb_bfd_ref.
* jit.c: Include gdb_bfd.h.
(jit_bfd_try_read_symtab): Use gdb_bfd_ref, gdb_bfd_unref.
* gdb_bfd.h: New file.
* gdb_bfd.c: New file.
* gcore.c: Include gdb_bfd.h.
(create_gcore_bfd): Use gdb_bfd_ref.
(do_bfd_delete_cleanup): Use gdb_bfd_unref.
(gcore_command): Use gdb_bfd_unref.
* exec.c: Include gdb_bfd.h.
(exec_close): Use gdb_bfd_unref.
(exec_close_1): Use gdb_bfd_unref.
(exec_file_attach): Use gdb_bfd_ref.
* elfread.c: Include gdb_bfd.h.
(build_id_verify): Use gdb_bfd_unref.
* dsrec.c: Include gdb_bfd.h.
(load_srec): Use gdb_bfd_ref.
* corelow.c: Include gdb_bfd.h.
(core_close): Use gdb_bfd_unref.
(core_open): Use gdb_bfd_ref.
* bfd-target.c: Include gdb_bfd.h.
(target_bfd_xclose): Use gdb_bfd_unref.
(target_bfd_reopen): Use gdb_bfd_ref.
* Makefile.in (SFILES): Add gdb_bfd.c.
(HFILES_NO_SRCDIR): Add gdb_bfd.h.
(COMMON_OBS): Add gdb_bfd.o.
2012-07-18 21:33:34 +02:00
|
|
|
|
gdb_bfd_unref (abfd);
|
2009-12-14 13:50:39 +01:00
|
|
|
|
|
|
|
|
|
xfree (found);
|
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
|
build_id_to_debug_filename (struct build_id *build_id)
|
|
|
|
|
{
|
|
|
|
|
char *link, *debugdir, *retval = NULL;
|
gdb/
Code cleanup.
* charset.c (find_charset_names): Remove variables ix and elt.
Use free_char_ptr_vec.
* elfread.c (build_id_to_debug_filename): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end. New variable debugdir_len.
* gdb_vecs.h (free_char_ptr_vec, make_cleanup_free_char_ptr_vec)
(dirnames_to_char_ptr_vec_append, dirnames_to_char_ptr_vec): New
declarations.
* progspace.c (clear_program_space_solib_cache): Remove variables ix
and elt. Use free_char_ptr_vec.
* source.c (add_path): Remove variables argv, arg and argv_index.
New variables dir_vec, back_to, ix and name.
Use dirnames_to_char_ptr_vec_append. Use freeargv instead of
make_cleanup_freeargv. Remove variable separator. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
(openp): Remove variable p, p1 and len. New variables dir_vec,
back_to, ix and dir. Use dirnames_to_char_ptr_vec. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
* symfile.c (find_separate_debug_file): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end.
* utils.c (free_char_ptr_vec, do_free_char_ptr_vec)
(make_cleanup_free_char_ptr_vec, dirnames_to_char_ptr_vec_append)
(dirnames_to_char_ptr_vec): New functions.
2012-04-17 17:47:09 +02:00
|
|
|
|
VEC (char_ptr) *debugdir_vec;
|
|
|
|
|
struct cleanup *back_to;
|
|
|
|
|
int ix;
|
2009-12-14 13:50:39 +01:00
|
|
|
|
|
|
|
|
|
/* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
|
|
|
|
|
link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
|
|
|
|
|
+ 2 * build_id->size + (sizeof ".debug" - 1) + 1);
|
|
|
|
|
|
|
|
|
|
/* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
|
|
|
|
|
cause "/.build-id/..." lookups. */
|
|
|
|
|
|
gdb/
Code cleanup.
* charset.c (find_charset_names): Remove variables ix and elt.
Use free_char_ptr_vec.
* elfread.c (build_id_to_debug_filename): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end. New variable debugdir_len.
* gdb_vecs.h (free_char_ptr_vec, make_cleanup_free_char_ptr_vec)
(dirnames_to_char_ptr_vec_append, dirnames_to_char_ptr_vec): New
declarations.
* progspace.c (clear_program_space_solib_cache): Remove variables ix
and elt. Use free_char_ptr_vec.
* source.c (add_path): Remove variables argv, arg and argv_index.
New variables dir_vec, back_to, ix and name.
Use dirnames_to_char_ptr_vec_append. Use freeargv instead of
make_cleanup_freeargv. Remove variable separator. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
(openp): Remove variable p, p1 and len. New variables dir_vec,
back_to, ix and dir. Use dirnames_to_char_ptr_vec. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
* symfile.c (find_separate_debug_file): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end.
* utils.c (free_char_ptr_vec, do_free_char_ptr_vec)
(make_cleanup_free_char_ptr_vec, dirnames_to_char_ptr_vec_append)
(dirnames_to_char_ptr_vec): New functions.
2012-04-17 17:47:09 +02:00
|
|
|
|
debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory);
|
|
|
|
|
back_to = make_cleanup_free_char_ptr_vec (debugdir_vec);
|
|
|
|
|
|
|
|
|
|
for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix)
|
2009-12-14 13:50:39 +01:00
|
|
|
|
{
|
gdb/
Code cleanup.
* charset.c (find_charset_names): Remove variables ix and elt.
Use free_char_ptr_vec.
* elfread.c (build_id_to_debug_filename): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end. New variable debugdir_len.
* gdb_vecs.h (free_char_ptr_vec, make_cleanup_free_char_ptr_vec)
(dirnames_to_char_ptr_vec_append, dirnames_to_char_ptr_vec): New
declarations.
* progspace.c (clear_program_space_solib_cache): Remove variables ix
and elt. Use free_char_ptr_vec.
* source.c (add_path): Remove variables argv, arg and argv_index.
New variables dir_vec, back_to, ix and name.
Use dirnames_to_char_ptr_vec_append. Use freeargv instead of
make_cleanup_freeargv. Remove variable separator. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
(openp): Remove variable p, p1 and len. New variables dir_vec,
back_to, ix and dir. Use dirnames_to_char_ptr_vec. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
* symfile.c (find_separate_debug_file): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end.
* utils.c (free_char_ptr_vec, do_free_char_ptr_vec)
(make_cleanup_free_char_ptr_vec, dirnames_to_char_ptr_vec_append)
(dirnames_to_char_ptr_vec): New functions.
2012-04-17 17:47:09 +02:00
|
|
|
|
size_t debugdir_len = strlen (debugdir);
|
2009-12-14 13:50:39 +01:00
|
|
|
|
gdb_byte *data = build_id->data;
|
|
|
|
|
size_t size = build_id->size;
|
gdb/
Code cleanup.
* charset.c (find_charset_names): Remove variables ix and elt.
Use free_char_ptr_vec.
* elfread.c (build_id_to_debug_filename): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end. New variable debugdir_len.
* gdb_vecs.h (free_char_ptr_vec, make_cleanup_free_char_ptr_vec)
(dirnames_to_char_ptr_vec_append, dirnames_to_char_ptr_vec): New
declarations.
* progspace.c (clear_program_space_solib_cache): Remove variables ix
and elt. Use free_char_ptr_vec.
* source.c (add_path): Remove variables argv, arg and argv_index.
New variables dir_vec, back_to, ix and name.
Use dirnames_to_char_ptr_vec_append. Use freeargv instead of
make_cleanup_freeargv. Remove variable separator. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
(openp): Remove variable p, p1 and len. New variables dir_vec,
back_to, ix and dir. Use dirnames_to_char_ptr_vec. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
* symfile.c (find_separate_debug_file): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end.
* utils.c (free_char_ptr_vec, do_free_char_ptr_vec)
(make_cleanup_free_char_ptr_vec, dirnames_to_char_ptr_vec_append)
(dirnames_to_char_ptr_vec): New functions.
2012-04-17 17:47:09 +02:00
|
|
|
|
char *s;
|
2009-12-14 13:50:39 +01:00
|
|
|
|
|
gdb/
Code cleanup.
* charset.c (find_charset_names): Remove variables ix and elt.
Use free_char_ptr_vec.
* elfread.c (build_id_to_debug_filename): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end. New variable debugdir_len.
* gdb_vecs.h (free_char_ptr_vec, make_cleanup_free_char_ptr_vec)
(dirnames_to_char_ptr_vec_append, dirnames_to_char_ptr_vec): New
declarations.
* progspace.c (clear_program_space_solib_cache): Remove variables ix
and elt. Use free_char_ptr_vec.
* source.c (add_path): Remove variables argv, arg and argv_index.
New variables dir_vec, back_to, ix and name.
Use dirnames_to_char_ptr_vec_append. Use freeargv instead of
make_cleanup_freeargv. Remove variable separator. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
(openp): Remove variable p, p1 and len. New variables dir_vec,
back_to, ix and dir. Use dirnames_to_char_ptr_vec. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
* symfile.c (find_separate_debug_file): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end.
* utils.c (free_char_ptr_vec, do_free_char_ptr_vec)
(make_cleanup_free_char_ptr_vec, dirnames_to_char_ptr_vec_append)
(dirnames_to_char_ptr_vec): New functions.
2012-04-17 17:47:09 +02:00
|
|
|
|
memcpy (link, debugdir, debugdir_len);
|
|
|
|
|
s = &link[debugdir_len];
|
2009-12-14 13:50:39 +01:00
|
|
|
|
s += sprintf (s, "/.build-id/");
|
|
|
|
|
if (size > 0)
|
|
|
|
|
{
|
|
|
|
|
size--;
|
|
|
|
|
s += sprintf (s, "%02x", (unsigned) *data++);
|
|
|
|
|
}
|
|
|
|
|
if (size > 0)
|
|
|
|
|
*s++ = '/';
|
|
|
|
|
while (size-- > 0)
|
|
|
|
|
s += sprintf (s, "%02x", (unsigned) *data++);
|
|
|
|
|
strcpy (s, ".debug");
|
|
|
|
|
|
|
|
|
|
/* lrealpath() is expensive even for the usually non-existent files. */
|
|
|
|
|
if (access (link, F_OK) == 0)
|
|
|
|
|
retval = lrealpath (link);
|
|
|
|
|
|
|
|
|
|
if (retval != NULL && !build_id_verify (retval, build_id))
|
|
|
|
|
{
|
|
|
|
|
xfree (retval);
|
|
|
|
|
retval = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (retval != NULL)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
gdb/
Code cleanup.
* charset.c (find_charset_names): Remove variables ix and elt.
Use free_char_ptr_vec.
* elfread.c (build_id_to_debug_filename): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end. New variable debugdir_len.
* gdb_vecs.h (free_char_ptr_vec, make_cleanup_free_char_ptr_vec)
(dirnames_to_char_ptr_vec_append, dirnames_to_char_ptr_vec): New
declarations.
* progspace.c (clear_program_space_solib_cache): Remove variables ix
and elt. Use free_char_ptr_vec.
* source.c (add_path): Remove variables argv, arg and argv_index.
New variables dir_vec, back_to, ix and name.
Use dirnames_to_char_ptr_vec_append. Use freeargv instead of
make_cleanup_freeargv. Remove variable separator. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
(openp): Remove variable p, p1 and len. New variables dir_vec,
back_to, ix and dir. Use dirnames_to_char_ptr_vec. Simplify the code
no longer expecting DIRNAME_SEPARATOR.
* symfile.c (find_separate_debug_file): New variables debugdir_vec,
back_to and ix. Use dirnames_to_char_ptr_vec. Remove variable
debugdir_end.
* utils.c (free_char_ptr_vec, do_free_char_ptr_vec)
(make_cleanup_free_char_ptr_vec, dirnames_to_char_ptr_vec_append)
(dirnames_to_char_ptr_vec): New functions.
2012-04-17 17:47:09 +02:00
|
|
|
|
do_cleanups (back_to);
|
2009-12-14 13:50:39 +01:00
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
|
find_separate_debug_file_by_buildid (struct objfile *objfile)
|
|
|
|
|
{
|
|
|
|
|
struct build_id *build_id;
|
|
|
|
|
|
|
|
|
|
build_id = build_id_bfd_get (objfile->obfd);
|
|
|
|
|
if (build_id != NULL)
|
|
|
|
|
{
|
|
|
|
|
char *build_id_name;
|
|
|
|
|
|
|
|
|
|
build_id_name = build_id_to_debug_filename (build_id);
|
|
|
|
|
xfree (build_id);
|
|
|
|
|
/* Prevent looping on a stripped .debug file. */
|
2011-03-23 19:23:56 +01:00
|
|
|
|
if (build_id_name != NULL
|
|
|
|
|
&& filename_cmp (build_id_name, objfile->name) == 0)
|
2009-12-14 13:50:39 +01:00
|
|
|
|
{
|
|
|
|
|
warning (_("\"%s\": separate debug info file has no debug info"),
|
|
|
|
|
build_id_name);
|
|
|
|
|
xfree (build_id_name);
|
|
|
|
|
}
|
|
|
|
|
else if (build_id_name != NULL)
|
|
|
|
|
return build_id_name;
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Scan and build partial symbols for a symbol file.
|
2011-07-26 00:23:38 +02:00
|
|
|
|
We have been initialized by a call to elf_symfile_init, which
|
1999-04-16 03:35:26 +02:00
|
|
|
|
currently does nothing.
|
|
|
|
|
|
|
|
|
|
SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
|
|
|
|
|
in each section. We simplify it down to a single offset for all
|
|
|
|
|
symbols. FIXME.
|
|
|
|
|
|
|
|
|
|
This function only does the minimum work necessary for letting the
|
|
|
|
|
user "name" things symbolically; it does not read the entire symtab.
|
|
|
|
|
Instead, it reads the external and static symbols and puts them in partial
|
|
|
|
|
symbol tables. When more extensive information is requested of a
|
|
|
|
|
file, the corresponding partial symbol table is mutated into a full
|
|
|
|
|
fledged symbol table by going back and reading the symbols
|
|
|
|
|
for real.
|
|
|
|
|
|
|
|
|
|
We look for sections with specific names, to tell us what debug
|
|
|
|
|
format to look for: FIXME!!!
|
|
|
|
|
|
|
|
|
|
elfstab_build_psymtabs() handles STABS symbols;
|
|
|
|
|
mdebug_build_psymtabs() handles ECOFF debugging information.
|
|
|
|
|
|
|
|
|
|
Note that ELF files have a "minimal" symbol table, which looks a lot
|
|
|
|
|
like a COFF symbol table, but has only the minimal information necessary
|
|
|
|
|
for linking. We process this also, and use the information to
|
|
|
|
|
build gdb's minimal symbol table. This gives us some minimal debugging
|
|
|
|
|
capability even for files compiled without -g. */
|
|
|
|
|
|
|
|
|
|
static void
|
2009-12-07 10:47:40 +01:00
|
|
|
|
elf_symfile_read (struct objfile *objfile, int symfile_flags)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2011-04-17 20:38:46 +02:00
|
|
|
|
bfd *synth_abfd, *abfd = objfile->obfd;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
struct elfinfo ei;
|
|
|
|
|
struct cleanup *back_to;
|
2005-11-04 03:44:25 +01:00
|
|
|
|
long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
|
|
|
|
|
asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
|
|
|
|
|
asymbol *synthsyms;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2012-06-26 22:14:03 +02:00
|
|
|
|
if (symtab_create_debug)
|
|
|
|
|
{
|
|
|
|
|
fprintf_unfiltered (gdb_stdlog,
|
|
|
|
|
"Reading minimal symbols of objfile %s ...\n",
|
|
|
|
|
objfile->name);
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
init_minimal_symbol_collection ();
|
2000-05-16 06:07:39 +02:00
|
|
|
|
back_to = make_cleanup_discard_minimal_symbols ();
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
memset ((char *) &ei, 0, sizeof (ei));
|
|
|
|
|
|
2011-01-07 20:36:19 +01:00
|
|
|
|
/* Allocate struct to keep track of the symfile. */
|
2004-10-23 18:18:09 +02:00
|
|
|
|
objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
|
2004-08-10 21:37:47 +02:00
|
|
|
|
xmalloc (sizeof (struct dbx_symfile_info));
|
2011-01-05 23:22:53 +01:00
|
|
|
|
memset ((char *) objfile->deprecated_sym_stab_info,
|
|
|
|
|
0, sizeof (struct dbx_symfile_info));
|
2002-03-19 20:00:04 +01:00
|
|
|
|
make_cleanup (free_elfinfo, (void *) objfile);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2011-01-05 23:22:53 +01:00
|
|
|
|
/* Process the normal ELF symbol table first. This may write some
|
|
|
|
|
chain of info into the dbx_symfile_info in
|
|
|
|
|
objfile->deprecated_sym_stab_info, which can later be used by
|
|
|
|
|
elfstab_offset_sections. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2005-11-04 03:44:25 +01:00
|
|
|
|
storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
|
|
|
|
|
if (storage_needed < 0)
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("Can't read symbols from %s: %s"),
|
|
|
|
|
bfd_get_filename (objfile->obfd),
|
2005-11-04 03:44:25 +01:00
|
|
|
|
bfd_errmsg (bfd_get_error ()));
|
|
|
|
|
|
|
|
|
|
if (storage_needed > 0)
|
|
|
|
|
{
|
|
|
|
|
symbol_table = (asymbol **) xmalloc (storage_needed);
|
|
|
|
|
make_cleanup (xfree, symbol_table);
|
|
|
|
|
symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
|
|
|
|
|
|
|
|
|
|
if (symcount < 0)
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("Can't read symbols from %s: %s"),
|
|
|
|
|
bfd_get_filename (objfile->obfd),
|
2005-11-04 03:44:25 +01:00
|
|
|
|
bfd_errmsg (bfd_get_error ()));
|
|
|
|
|
|
2009-11-16 19:40:23 +01:00
|
|
|
|
elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
|
2005-11-04 03:44:25 +01:00
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Add the dynamic symbols. */
|
|
|
|
|
|
2005-11-04 03:44:25 +01:00
|
|
|
|
storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
|
|
|
|
|
|
|
|
|
|
if (storage_needed > 0)
|
|
|
|
|
{
|
2010-11-19 23:30:47 +01:00
|
|
|
|
/* 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 = bfd_alloc (abfd, storage_needed);
|
2005-11-04 03:44:25 +01:00
|
|
|
|
dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
|
|
|
|
|
dyn_symbol_table);
|
|
|
|
|
|
|
|
|
|
if (dynsymcount < 0)
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("Can't read symbols from %s: %s"),
|
|
|
|
|
bfd_get_filename (objfile->obfd),
|
2005-11-04 03:44:25 +01:00
|
|
|
|
bfd_errmsg (bfd_get_error ()));
|
|
|
|
|
|
2009-11-16 19:40:23 +01:00
|
|
|
|
elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
|
|
|
|
|
elf_rel_plt_read (objfile, dyn_symbol_table);
|
2005-11-04 03:44:25 +01:00
|
|
|
|
}
|
|
|
|
|
|
2011-04-17 20:38:46 +02:00
|
|
|
|
/* 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;
|
|
|
|
|
|
2005-11-04 03:44:25 +01:00
|
|
|
|
/* Add synthetic symbols - for instance, names for any PLT entries. */
|
|
|
|
|
|
2011-04-17 20:38:46 +02:00
|
|
|
|
synthcount = bfd_get_synthetic_symtab (synth_abfd, symcount, symbol_table,
|
2005-11-04 03:44:25 +01:00
|
|
|
|
dynsymcount, dyn_symbol_table,
|
|
|
|
|
&synthsyms);
|
|
|
|
|
if (synthcount > 0)
|
|
|
|
|
{
|
|
|
|
|
asymbol **synth_symbol_table;
|
|
|
|
|
long i;
|
|
|
|
|
|
|
|
|
|
make_cleanup (xfree, synthsyms);
|
|
|
|
|
synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
|
|
|
|
|
for (i = 0; i < synthcount; i++)
|
2005-12-27 05:09:40 +01:00
|
|
|
|
synth_symbol_table[i] = synthsyms + i;
|
2005-11-04 03:44:25 +01:00
|
|
|
|
make_cleanup (xfree, synth_symbol_table);
|
2011-01-05 23:22:53 +01:00
|
|
|
|
elf_symtab_read (objfile, ST_SYNTHETIC, synthcount,
|
|
|
|
|
synth_symbol_table, 1);
|
2005-11-04 03:44:25 +01:00
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2003-02-20 19:31:14 +01:00
|
|
|
|
/* Install any minimal symbols that have been collected as the current
|
|
|
|
|
minimal symbols for this objfile. The debug readers below this point
|
|
|
|
|
should not generate new minimal symbols; if they do it's their
|
|
|
|
|
responsibility to install them. "mdebug" appears to be the only one
|
|
|
|
|
which will do this. */
|
|
|
|
|
|
|
|
|
|
install_minimal_symbols (objfile);
|
|
|
|
|
do_cleanups (back_to);
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Now process debugging information, which is contained in
|
2011-01-07 20:36:19 +01:00
|
|
|
|
special ELF sections. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2011-01-07 20:36:19 +01:00
|
|
|
|
/* We first have to find them... */
|
2002-03-19 20:00:04 +01:00
|
|
|
|
bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* ELF debugging information is inserted into the psymtab in the
|
|
|
|
|
order of least informative first - most informative last. Since
|
|
|
|
|
the psymtab table is searched `most recent insertion first' this
|
|
|
|
|
increases the probability that more detailed debug information
|
|
|
|
|
for a section is found.
|
|
|
|
|
|
|
|
|
|
For instance, an object file might contain both .mdebug (XCOFF)
|
|
|
|
|
and .debug_info (DWARF2) sections then .mdebug is inserted first
|
|
|
|
|
(searched last) and DWARF2 is inserted last (searched first). If
|
|
|
|
|
we don't do this then the XCOFF info is found first - for code in
|
2011-01-07 20:36:19 +01:00
|
|
|
|
an included file XCOFF info is useless. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
if (ei.mdebugsect)
|
|
|
|
|
{
|
|
|
|
|
const struct ecoff_debug_swap *swap;
|
|
|
|
|
|
|
|
|
|
/* .mdebug section, presumably holding ECOFF debugging
|
1999-07-07 22:19:36 +02:00
|
|
|
|
information. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
|
|
|
|
|
if (swap)
|
1999-09-09 02:02:17 +02:00
|
|
|
|
elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
if (ei.stabsect)
|
|
|
|
|
{
|
|
|
|
|
asection *str_sect;
|
|
|
|
|
|
|
|
|
|
/* Stab sections have an associated string table that looks like
|
1999-07-07 22:19:36 +02:00
|
|
|
|
a separate section. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
str_sect = bfd_get_section_by_name (abfd, ".stabstr");
|
|
|
|
|
|
|
|
|
|
/* FIXME should probably warn about a stab section without a stabstr. */
|
|
|
|
|
if (str_sect)
|
|
|
|
|
elfstab_build_psymtabs (objfile,
|
2003-01-31 20:22:18 +01:00
|
|
|
|
ei.stabsect,
|
1999-04-16 03:35:26 +02:00
|
|
|
|
str_sect->filepos,
|
|
|
|
|
bfd_section_size (abfd, str_sect));
|
|
|
|
|
}
|
2010-07-13 22:51:34 +02:00
|
|
|
|
|
2011-05-26 09:47:10 +02:00
|
|
|
|
if (dwarf2_has_info (objfile, NULL))
|
2011-03-07 17:17:29 +01:00
|
|
|
|
{
|
2011-04-25 21:38:16 +02:00
|
|
|
|
/* elf_sym_fns_gdb_index cannot handle simultaneous non-DWARF debug
|
|
|
|
|
information present in OBJFILE. If there is such debug info present
|
|
|
|
|
never use .gdb_index. */
|
|
|
|
|
|
|
|
|
|
if (!objfile_has_partial_symbols (objfile)
|
|
|
|
|
&& dwarf2_initialize_objfile (objfile))
|
2011-03-07 17:17:29 +01:00
|
|
|
|
objfile->sf = &elf_sym_fns_gdb_index;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* It is ok to do this even if the stabs reader made some
|
|
|
|
|
partial symbols, because OBJF_PSYMTABS_READ has not been
|
|
|
|
|
set, and so our lazy reader function will still be called
|
|
|
|
|
when needed. */
|
|
|
|
|
objfile->sf = &elf_sym_fns_lazy_psyms;
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-01-05 23:22:53 +01:00
|
|
|
|
/* If the file has its own symbol tables it has no separate debug
|
|
|
|
|
info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to
|
|
|
|
|
SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with
|
|
|
|
|
`.note.gnu.build-id'. */
|
2011-03-07 17:17:29 +01:00
|
|
|
|
else if (!objfile_has_partial_symbols (objfile))
|
2009-12-09 14:44:53 +01:00
|
|
|
|
{
|
|
|
|
|
char *debugfile;
|
|
|
|
|
|
|
|
|
|
debugfile = find_separate_debug_file_by_buildid (objfile);
|
|
|
|
|
|
|
|
|
|
if (debugfile == NULL)
|
|
|
|
|
debugfile = find_separate_debug_file_by_debuglink (objfile);
|
|
|
|
|
|
|
|
|
|
if (debugfile)
|
|
|
|
|
{
|
2012-07-23 16:58:44 +02:00
|
|
|
|
struct cleanup *cleanup = make_cleanup (xfree, debugfile);
|
2009-12-09 14:44:53 +01:00
|
|
|
|
bfd *abfd = symfile_bfd_open (debugfile);
|
2010-05-14 20:35:11 +02:00
|
|
|
|
|
2012-07-23 16:58:44 +02:00
|
|
|
|
make_cleanup_bfd_unref (abfd);
|
2009-12-09 14:44:53 +01:00
|
|
|
|
symbol_file_add_separate (abfd, symfile_flags, objfile);
|
2012-07-23 16:58:44 +02:00
|
|
|
|
do_cleanups (cleanup);
|
2009-12-09 14:44:53 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2012-06-26 22:14:03 +02:00
|
|
|
|
|
|
|
|
|
if (symtab_create_debug)
|
|
|
|
|
fprintf_unfiltered (gdb_stdlog, "Done reading minimal symbols.\n");
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
2011-03-07 17:17:29 +01:00
|
|
|
|
/* Callback to lazily read psymtabs. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
read_psyms (struct objfile *objfile)
|
|
|
|
|
{
|
2011-05-26 09:47:10 +02:00
|
|
|
|
if (dwarf2_has_info (objfile, NULL))
|
2011-03-07 17:17:29 +01:00
|
|
|
|
dwarf2_build_psymtabs (objfile);
|
|
|
|
|
}
|
|
|
|
|
|
2004-10-23 18:18:09 +02:00
|
|
|
|
/* This cleans up the objfile's deprecated_sym_stab_info pointer, and
|
|
|
|
|
the chain of stab_section_info's, that might be dangling from
|
|
|
|
|
it. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2002-03-19 20:00:04 +01:00
|
|
|
|
free_elfinfo (void *objp)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
struct objfile *objfile = (struct objfile *) objp;
|
2004-10-23 18:18:09 +02:00
|
|
|
|
struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
struct stab_section_info *ssi, *nssi;
|
|
|
|
|
|
|
|
|
|
ssi = dbxinfo->stab_section_info;
|
|
|
|
|
while (ssi)
|
|
|
|
|
{
|
|
|
|
|
nssi = ssi->next;
|
2004-08-10 23:52:05 +02:00
|
|
|
|
xfree (ssi);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ssi = nssi;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Initialize anything that needs initializing when a completely new symbol
|
|
|
|
|
file is specified (not just adding some symbols from another file, e.g. a
|
|
|
|
|
shared library).
|
|
|
|
|
|
2011-01-05 23:22:53 +01:00
|
|
|
|
We reinitialize buildsym, since we may be reading stabs from an ELF
|
|
|
|
|
file. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
elf_new_init (struct objfile *ignore)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
stabsread_new_init ();
|
|
|
|
|
buildsym_new_init ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Perform any local cleanups required when we are done with a particular
|
|
|
|
|
objfile. I.E, we are in the process of discarding all symbol information
|
|
|
|
|
for an objfile, freeing up all memory held for it, and unlinking the
|
2011-01-07 20:36:19 +01:00
|
|
|
|
objfile struct from the global list of known objfiles. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
elf_symfile_finish (struct objfile *objfile)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2004-10-23 18:18:09 +02:00
|
|
|
|
if (objfile->deprecated_sym_stab_info != NULL)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2004-10-23 18:18:09 +02:00
|
|
|
|
xfree (objfile->deprecated_sym_stab_info);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2007-10-22 03:16:34 +02:00
|
|
|
|
|
|
|
|
|
dwarf2_free_objfile (objfile);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* ELF specific initialization routine for reading symbols.
|
|
|
|
|
|
|
|
|
|
It is passed a pointer to a struct sym_fns which contains, among other
|
|
|
|
|
things, the BFD for the file whose symbols are being read, and a slot for
|
|
|
|
|
a pointer to "private data" which we can fill with goodies.
|
|
|
|
|
|
|
|
|
|
For now at least, we have nothing in particular to do, so this function is
|
2011-01-07 20:36:19 +01:00
|
|
|
|
just a stub. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
elf_symfile_init (struct objfile *objfile)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* ELF objects may be reordered, so set OBJF_REORDERED. If we
|
|
|
|
|
find this causes a significant slowdown in gdb then we could
|
|
|
|
|
set it in the debug symbol readers only when necessary. */
|
|
|
|
|
objfile->flags |= OBJF_REORDERED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* When handling an ELF file that contains Sun STABS debug info,
|
|
|
|
|
some of the debug info is relative to the particular chunk of the
|
|
|
|
|
section that was generated in its individual .o file. E.g.
|
|
|
|
|
offsets to static variables are relative to the start of the data
|
|
|
|
|
segment *for that module before linking*. This information is
|
|
|
|
|
painfully squirreled away in the ELF symbol table as local symbols
|
|
|
|
|
with wierd names. Go get 'em when needed. */
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2010-10-01 22:26:11 +02:00
|
|
|
|
const char *filename = pst->filename;
|
2004-10-23 18:18:09 +02:00
|
|
|
|
struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
struct stab_section_info *maybe = dbx->stab_section_info;
|
|
|
|
|
struct stab_section_info *questionable = 0;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* The ELF symbol info doesn't include path names, so strip the path
|
|
|
|
|
(if any) from the psymtab filename. */
|
2011-03-23 19:23:56 +01:00
|
|
|
|
filename = lbasename (filename);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* FIXME: This linear search could speed up significantly
|
|
|
|
|
if it was chained in the right order to match how we search it,
|
2011-01-07 20:36:19 +01:00
|
|
|
|
and if we unchained when we found a match. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
for (; maybe; maybe = maybe->next)
|
|
|
|
|
{
|
|
|
|
|
if (filename[0] == maybe->filename[0]
|
2011-03-23 19:23:56 +01:00
|
|
|
|
&& filename_cmp (filename, maybe->filename) == 0)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* We found a match. But there might be several source files
|
|
|
|
|
(from different directories) with the same name. */
|
|
|
|
|
if (0 == maybe->found)
|
|
|
|
|
break;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
questionable = maybe; /* Might use it later. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (maybe == 0 && questionable != 0)
|
|
|
|
|
{
|
2002-12-17 01:39:08 +01:00
|
|
|
|
complaint (&symfile_complaints,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
_("elf/stab section information questionable for %s"),
|
|
|
|
|
filename);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
maybe = questionable;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (maybe)
|
|
|
|
|
{
|
|
|
|
|
/* Found it! Allocate a new psymtab struct, and fill it in. */
|
|
|
|
|
maybe->found++;
|
|
|
|
|
pst->section_offsets = (struct section_offsets *)
|
2011-07-26 00:23:38 +02:00
|
|
|
|
obstack_alloc (&objfile->objfile_obstack,
|
2003-06-07 01:33:00 +02:00
|
|
|
|
SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
|
|
|
|
|
for (i = 0; i < maybe->num_sections; i++)
|
2000-08-07 17:02:48 +02:00
|
|
|
|
(pst->section_offsets)->offsets[i] = maybe->sections[i];
|
1999-04-16 03:35:26 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We were unable to find any offsets for this file. Complain. */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (dbx->stab_section_info) /* If there *is* any info, */
|
2002-12-17 01:39:08 +01:00
|
|
|
|
complaint (&symfile_complaints,
|
2005-02-11 Andrew Cagney <cagney@gnu.org>
Mark up error_no_arg, query, perror_with_name, complaint, and
internal_error.
* breakpoint.c, cp-abi.c, cp-namespace.c, cp-support.c: Update.
* cris-tdep.c, dbxread.c, dictionary.c, dsrec.c: Update.
* dummy-frame.c, dve3900-rom.c, dwarf2-frame.c, dwarf2expr.c: Update.
* dwarf2read.c, dwarfread.c, elfread.c, event-loop.c: Update.
* exceptions.c, exec.c, f-lang.c, findvar.c, fork-child.c: Update.
* frame-unwind.c, frame.c, frv-linux-tdep.c, frv-tdep.c: Update.
* gdb_assert.h, gdbarch.c, gdbtypes.c, gnu-nat.c: Update.
* go32-nat.c, hppa-tdep.c, hppabsd-nat.c, hpread.c: Update.
* i386-linux-nat.c, i386-nat.c, i386-tdep.c, i386bsd-nat.c: Update.
* i386fbsd-nat.c, inf-ptrace.c, inf-ttrace.c, infcall.c: Update.
* infcmd.c, inflow.c, infptrace.c, infrun.c, inftarg.c: Update.
* interps.c, language.c, linespec.c, linux-nat.c: Update.
* m32r-linux-nat.c, m68k-tdep.c, m68kbsd-nat.c: Update.
* m68klinux-nat.c, m88kbsd-nat.c, macroexp.c, macroscope.c: Update.
* macrotab.c, maint.c, mdebugread.c, memattr.c: Update.
* mips-linux-tdep.c, mips-tdep.c, mips64obsd-nat.c: Update.
* mipsnbsd-nat.c, mn10300-tdep.c, monitor.c, nto-procfs.c: Update.
* objc-lang.c, objfiles.c, objfiles.h, ocd.c, osabi.c: Update.
* parse.c, ppc-bdm.c, ppc-linux-nat.c, ppc-sysv-tdep.c: Update.
* ppcnbsd-nat.c, ppcobsd-nat.c, printcmd.c, procfs.c: Update.
* regcache.c, reggroups.c, remote-e7000.c, remote-mips.c: Update.
* remote-rdp.c, remote-sds.c, remote-sim.c, remote-st.c: Update.
* remote-utils.c, remote.c, rs6000-nat.c, rs6000-tdep.c: Update.
* s390-nat.c, s390-tdep.c, sentinel-frame.c, serial.c: Update.
* sh-tdep.c, sh3-rom.c, sh64-tdep.c, shnbsd-nat.c: Update.
* solib-aix5.c, solib-svr4.c, solib.c, source.c: Update.
* sparc-nat.c, stabsread.c, stack.c, symfile.c, symtab.c: Update.
* symtab.h, target.c, tracepoint.c, ui-file.c, ui-out.c: Update.
* utils.c, valops.c, valprint.c, vax-nat.c, vaxbsd-nat.c: Update.
* win32-nat.c, xcoffread.c, xstormy16-tdep.c: Update.
* cli/cli-cmds.c, cli/cli-logging.c, cli/cli-script.c: Update.
* cli/cli-setshow.c, mi/mi-cmd-break.c, mi/mi-cmds.c: Update.
* mi/mi-console.c, mi/mi-getopt.c, mi/mi-out.c: Update.
* tui/tui-file.c, tui/tui-interp.c: Update.
2005-02-11 19:13:55 +01:00
|
|
|
|
_("elf/stab section information missing for %s"), filename);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2012-04-27 22:47:57 +02:00
|
|
|
|
|
|
|
|
|
/* Implementation of `sym_get_probes', as documented in symfile.h. */
|
|
|
|
|
|
|
|
|
|
static VEC (probe_p) *
|
|
|
|
|
elf_get_probes (struct objfile *objfile)
|
|
|
|
|
{
|
|
|
|
|
VEC (probe_p) *probes_per_objfile;
|
|
|
|
|
|
|
|
|
|
/* Have we parsed this objfile's probes already? */
|
|
|
|
|
probes_per_objfile = objfile_data (objfile, probe_key);
|
|
|
|
|
|
|
|
|
|
if (!probes_per_objfile)
|
|
|
|
|
{
|
|
|
|
|
int ix;
|
|
|
|
|
const struct probe_ops *probe_ops;
|
|
|
|
|
|
|
|
|
|
/* Here we try to gather information about all types of probes from the
|
|
|
|
|
objfile. */
|
|
|
|
|
for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops);
|
|
|
|
|
ix++)
|
|
|
|
|
probe_ops->get_probes (&probes_per_objfile, objfile);
|
|
|
|
|
|
|
|
|
|
if (probes_per_objfile == NULL)
|
|
|
|
|
{
|
|
|
|
|
VEC_reserve (probe_p, probes_per_objfile, 1);
|
|
|
|
|
gdb_assert (probes_per_objfile != NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set_objfile_data (objfile, probe_key, probes_per_objfile);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return probes_per_objfile;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implementation of `sym_get_probe_argument_count', as documented in
|
|
|
|
|
symfile.h. */
|
|
|
|
|
|
|
|
|
|
static unsigned
|
2012-07-18 18:12:17 +02:00
|
|
|
|
elf_get_probe_argument_count (struct probe *probe)
|
2012-04-27 22:47:57 +02:00
|
|
|
|
{
|
2012-07-18 18:12:17 +02:00
|
|
|
|
return probe->pops->get_probe_argument_count (probe);
|
2012-04-27 22:47:57 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implementation of `sym_evaluate_probe_argument', as documented in
|
|
|
|
|
symfile.h. */
|
|
|
|
|
|
|
|
|
|
static struct value *
|
2012-07-18 18:12:17 +02:00
|
|
|
|
elf_evaluate_probe_argument (struct probe *probe, unsigned n)
|
2012-04-27 22:47:57 +02:00
|
|
|
|
{
|
2012-07-18 18:12:17 +02:00
|
|
|
|
return probe->pops->evaluate_probe_argument (probe, n);
|
2012-04-27 22:47:57 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implementation of `sym_compile_to_ax', as documented in symfile.h. */
|
|
|
|
|
|
|
|
|
|
static void
|
2012-07-18 18:12:17 +02:00
|
|
|
|
elf_compile_to_ax (struct probe *probe,
|
2012-04-27 22:47:57 +02:00
|
|
|
|
struct agent_expr *expr,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
unsigned n)
|
|
|
|
|
{
|
2012-07-18 18:12:17 +02:00
|
|
|
|
probe->pops->compile_to_ax (probe, expr, value, n);
|
2012-04-27 22:47:57 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Implementation of `sym_relocate_probe', as documented in symfile.h. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
elf_symfile_relocate_probe (struct objfile *objfile,
|
|
|
|
|
struct section_offsets *new_offsets,
|
|
|
|
|
struct section_offsets *delta)
|
|
|
|
|
{
|
|
|
|
|
int ix;
|
|
|
|
|
VEC (probe_p) *probes = objfile_data (objfile, probe_key);
|
|
|
|
|
struct probe *probe;
|
|
|
|
|
|
|
|
|
|
for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
|
|
|
|
|
probe->pops->relocate (probe, ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Helper function used to free the space allocated for storing SystemTap
|
|
|
|
|
probe information. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
probe_key_free (struct objfile *objfile, void *d)
|
|
|
|
|
{
|
|
|
|
|
int ix;
|
|
|
|
|
VEC (probe_p) *probes = d;
|
|
|
|
|
struct probe *probe;
|
|
|
|
|
|
|
|
|
|
for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
|
|
|
|
|
probe->pops->destroy (probe);
|
|
|
|
|
|
|
|
|
|
VEC_free (probe_p, probes);
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2012-04-27 22:47:57 +02:00
|
|
|
|
|
|
|
|
|
/* Implementation `sym_probe_fns', as documented in symfile.h. */
|
|
|
|
|
|
|
|
|
|
static const struct sym_probe_fns elf_probe_fns =
|
|
|
|
|
{
|
|
|
|
|
elf_get_probes, /* sym_get_probes */
|
|
|
|
|
elf_get_probe_argument_count, /* sym_get_probe_argument_count */
|
|
|
|
|
elf_evaluate_probe_argument, /* sym_evaluate_probe_argument */
|
|
|
|
|
elf_compile_to_ax, /* sym_compile_to_ax */
|
|
|
|
|
elf_symfile_relocate_probe, /* sym_relocate_probe */
|
|
|
|
|
};
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Register that we are able to handle ELF object file formats. */
|
|
|
|
|
|
2010-09-30 21:14:30 +02:00
|
|
|
|
static const struct sym_fns elf_sym_fns =
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
bfd_target_elf_flavour,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
elf_new_init, /* init anything gbl to entire symtab */
|
|
|
|
|
elf_symfile_init, /* read initial info, setup for sym_read() */
|
|
|
|
|
elf_symfile_read, /* read a symbol file into symtab */
|
2011-03-07 17:17:29 +01:00
|
|
|
|
NULL, /* sym_read_psymbols */
|
|
|
|
|
elf_symfile_finish, /* finished with file, cleanup */
|
|
|
|
|
default_symfile_offsets, /* Translate ext. to int. relocation */
|
|
|
|
|
elf_symfile_segments, /* Get segment information from a file. */
|
|
|
|
|
NULL,
|
|
|
|
|
default_symfile_relocate, /* Relocate a debug section. */
|
2012-04-27 22:47:57 +02:00
|
|
|
|
&elf_probe_fns, /* sym_probe_fns */
|
2011-03-07 17:17:29 +01:00
|
|
|
|
&psym_functions
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* The same as elf_sym_fns, but not registered and lazily reads
|
|
|
|
|
psymbols. */
|
|
|
|
|
|
|
|
|
|
static const struct sym_fns elf_sym_fns_lazy_psyms =
|
|
|
|
|
{
|
|
|
|
|
bfd_target_elf_flavour,
|
|
|
|
|
elf_new_init, /* init anything gbl to entire symtab */
|
|
|
|
|
elf_symfile_init, /* read initial info, setup for sym_read() */
|
|
|
|
|
elf_symfile_read, /* read a symbol file into symtab */
|
|
|
|
|
read_psyms, /* sym_read_psymbols */
|
2011-01-05 23:22:53 +01:00
|
|
|
|
elf_symfile_finish, /* finished with file, cleanup */
|
|
|
|
|
default_symfile_offsets, /* Translate ext. to int. relocation */
|
|
|
|
|
elf_symfile_segments, /* Get segment information from a file. */
|
|
|
|
|
NULL,
|
|
|
|
|
default_symfile_relocate, /* Relocate a debug section. */
|
2012-04-27 22:47:57 +02:00
|
|
|
|
&elf_probe_fns, /* sym_probe_fns */
|
2010-09-30 21:14:30 +02:00
|
|
|
|
&psym_functions
|
1999-04-16 03:35:26 +02:00
|
|
|
|
};
|
|
|
|
|
|
2010-07-13 22:51:34 +02:00
|
|
|
|
/* The same as elf_sym_fns, but not registered and uses the
|
|
|
|
|
DWARF-specific GNU index rather than psymtab. */
|
2010-09-30 21:14:30 +02:00
|
|
|
|
static const struct sym_fns elf_sym_fns_gdb_index =
|
2010-07-13 22:51:34 +02:00
|
|
|
|
{
|
|
|
|
|
bfd_target_elf_flavour,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
elf_new_init, /* init anything gbl to entire symab */
|
|
|
|
|
elf_symfile_init, /* read initial info, setup for sym_red() */
|
|
|
|
|
elf_symfile_read, /* read a symbol file into symtab */
|
2011-03-07 17:17:29 +01:00
|
|
|
|
NULL, /* sym_read_psymbols */
|
2011-01-05 23:22:53 +01:00
|
|
|
|
elf_symfile_finish, /* finished with file, cleanup */
|
|
|
|
|
default_symfile_offsets, /* Translate ext. to int. relocatin */
|
|
|
|
|
elf_symfile_segments, /* Get segment information from a file. */
|
|
|
|
|
NULL,
|
|
|
|
|
default_symfile_relocate, /* Relocate a debug section. */
|
2012-04-27 22:47:57 +02:00
|
|
|
|
&elf_probe_fns, /* sym_probe_fns */
|
2010-09-30 21:14:30 +02:00
|
|
|
|
&dwarf2_gdb_index_functions
|
2010-07-13 22:51:34 +02:00
|
|
|
|
};
|
|
|
|
|
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
/* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */
|
|
|
|
|
|
|
|
|
|
static const struct gnu_ifunc_fns elf_gnu_ifunc_fns =
|
|
|
|
|
{
|
|
|
|
|
elf_gnu_ifunc_resolve_addr,
|
|
|
|
|
elf_gnu_ifunc_resolve_name,
|
2011-03-28 22:29:51 +02:00
|
|
|
|
elf_gnu_ifunc_resolver_stop,
|
|
|
|
|
elf_gnu_ifunc_resolver_return_stop
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
};
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
_initialize_elfread (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2012-04-27 22:47:57 +02:00
|
|
|
|
probe_key = register_objfile_data_with_cleanup (NULL, probe_key_free);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
add_symtab_fns (&elf_sym_fns);
|
gdb/
STT_GNU_IFUNC reader implementation.
* elfread.c: Include gdbtypes.h, value.h and infcall.h.
(SYMBOL_GOT_PLT_SUFFIX, elf_rel_plt_read)
(elf_objfile_gnu_ifunc_cache_data, struct elf_gnu_ifunc_cache)
(elf_gnu_ifunc_cache_hash, elf_gnu_ifunc_cache_eq)
(elf_gnu_ifunc_record_cache, elf_gnu_ifunc_resolve_by_cache)
(elf_gnu_ifunc_resolve_by_got, elf_gnu_ifunc_resolve_name)
(elf_gnu_ifunc_resolve_addr): New.
(elf_symfile_read): Call elf_rel_plt_read.
(elf_gnu_ifunc_fns): New.
(_initialize_elfread): Initialize elf_objfile_gnu_ifunc_cache_data.
Install elf_gnu_ifunc_fns.
* infcall.c (find_function_return_type): New function.
(find_function_addr): Resolve TYPE_GNU_IFUNC functions, if possible.
* minsyms.c (stub_gnu_ifunc_resolve_addr)
(stub_gnu_ifunc_resolve_name): New functions.
(stub_gnu_ifunc_fns, gnu_ifunc_fns_p): New variables.
* symtab.h (struct gnu_ifunc_fns, gnu_ifunc_resolve_addr)
(gnu_ifunc_resolve_name, gnu_ifunc_fns_p): New.
2011-03-28 22:26:24 +02:00
|
|
|
|
|
|
|
|
|
elf_objfile_gnu_ifunc_cache_data = register_objfile_data ();
|
|
|
|
|
gnu_ifunc_fns_p = &elf_gnu_ifunc_fns;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|