X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Felfread.c;h=d4400bbd79bbc669badee97bc20111c1933e838a;hb=35fd2deb6916e972248d52b1bc1d584fa9059f8f;hp=3aec3526a0bb587ee79550ee910e0cb9f8d787bc;hpb=2750ef27997b6114da090a25a314396eaf85a87a;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/elfread.c b/gdb/elfread.c index 3aec3526a0..d4400bbd79 100644 --- a/gdb/elfread.c +++ b/gdb/elfread.c @@ -1,6 +1,6 @@ /* Read ELF (Executable and Linking Format) object files for GDB. - Copyright (C) 1991-2014 Free Software Foundation, Inc. + Copyright (C) 1991-2016 Free Software Foundation, Inc. Written by Fred Fish at Cygnus Support. @@ -21,7 +21,6 @@ #include "defs.h" #include "bfd.h" -#include #include "elf-bfd.h" #include "elf/common.h" #include "elf/internal.h" @@ -46,12 +45,13 @@ #include "bcache.h" #include "gdb_bfd.h" #include "build-id.h" +#include "location.h" extern void _initialize_elfread (void); /* Forward declarations. */ -static const struct sym_fns elf_sym_fns_gdb_index; -static const struct sym_fns elf_sym_fns_lazy_psyms; +extern const struct sym_fns elf_sym_fns_gdb_index; +extern const struct sym_fns elf_sym_fns_lazy_psyms; /* The struct elfinfo is available only during ELF symbol table and psymtab reading. It is destroyed at the completion of psymtab-reading. @@ -63,11 +63,9 @@ struct elfinfo asection *mdebugsect; /* Section pointer for .mdebug section */ }; -/* Per-objfile data for probe info. */ +/* Per-BFD data for probe info. */ -static const struct objfile_data *probe_key = NULL; - -static void free_elfinfo (void *); +static const struct bfd_data *probe_key = NULL; /* 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 @@ -91,13 +89,13 @@ elf_symfile_segments (bfd *abfd) if (phdrs_size == -1) return NULL; - phdrs = alloca (phdrs_size); + phdrs = (Elf_Internal_Phdr *) 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); + segments = XALLOCAVEC (Elf_Internal_Phdr *, num_phdrs); for (i = 0; i < num_phdrs; i++) if (phdrs[i].p_type == PT_LOAD) segments[num_segments++] = &phdrs[i]; @@ -237,17 +235,13 @@ elf_symtab_read (struct objfile *objfile, int type, CORE_ADDR symaddr; CORE_ADDR offset; 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; - /* Name of filesym. This is either a constant string or is saved on - the objfile's filename cache. */ + /* Name of the last file symbol. This is either a constant string or is + saved on the objfile's filename cache. */ const char *filesymname = ""; struct dbx_symfile_info *dbx = DBX_SYMFILE_INFO (objfile); int stripped = (bfd_get_symcount (objfile->obfd) == 0); + int elf_make_msymbol_special_p + = gdbarch_elf_make_msymbol_special_p (gdbarch); for (i = 0; i < number_of_symbols; i++) { @@ -321,7 +315,7 @@ elf_symtab_read (struct objfile *objfile, int type, 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 + if (!startswith (sect->name, ".plt") && bfd_get_section_by_name (abfd, ".plt") != NULL) continue; @@ -329,7 +323,11 @@ elf_symtab_read (struct objfile *objfile, int type, (sym->name, strlen (sym->name), copy_names, symaddr, mst_solib_trampoline, sect, objfile); if (msym != NULL) - msym->filename = filesymname; + { + msym->filename = filesymname; + if (elf_make_msymbol_special_p) + gdbarch_elf_make_msymbol_special (gdbarch, sym, msym); + } continue; } @@ -340,17 +338,9 @@ elf_symtab_read (struct objfile *objfile, int type, 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) - { - sectinfo->next = dbx->stab_section_info; - dbx->stab_section_info = sectinfo; - sectinfo = NULL; - } - filesym = sym; - filesymname = bcache (filesym->name, strlen (filesym->name) + 1, - objfile->per_bfd->filename_cache); + filesymname + = (const char *) bcache (sym->name, strlen (sym->name) + 1, + objfile->per_bfd->filename_cache); } else if (sym->flags & BSF_SECTION_SYM) continue; @@ -446,77 +436,6 @@ elf_symtab_read (struct objfile *objfile, int type, } else if (sym->flags & BSF_LOCAL) { - /* Named Local variable in a Data section. - Check its name for stabs-in-elf. */ - int special_local_sect; - - 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) - { - /* Found a special local symbol. Allocate a - sectinfo, if needed, and fill it in. */ - if (sectinfo == NULL) - { - int max_index; - size_t size; - - 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; - - /* 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. */ - size = (sizeof (struct stab_section_info) - + (sizeof (CORE_ADDR) * max_index)); - sectinfo = (struct stab_section_info *) - xmalloc (size); - memset (sectinfo, 0, size); - sectinfo->num_sections = max_index; - if (filesym == NULL) - { - complaint (&symfile_complaints, - _("elf/stab section information %s " - "without a preceding file symbol"), - sym->name); - } - else - { - sectinfo->filename = - (char *) filesym->name; - } - } - if (sectinfo->sections[special_local_sect] != 0) - complaint (&symfile_complaints, - _("duplicated elf/stab section " - "information for %s"), - sectinfo->filename); - /* BFD symbols are section relative. */ - symaddr = sym->value + sym->section->vma; - /* Relocate non-absolute symbols by the - section offset. */ - if (sym->section != bfd_abs_section_ptr) - 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; @@ -556,7 +475,8 @@ elf_symtab_read (struct objfile *objfile, int type, } msym->filename = filesymname; - gdbarch_elf_make_msymbol_special (gdbarch, sym, msym); + if (elf_make_msymbol_special_p) + gdbarch_elf_make_msymbol_special (gdbarch, sym, msym); } /* If we see a default versioned symbol, install it under @@ -595,7 +515,9 @@ elf_symtab_read (struct objfile *objfile, int type, SET_MSYMBOL_SIZE (mtramp, MSYMBOL_SIZE (msym)); mtramp->created_by_gdb = 1; mtramp->filename = filesymname; - gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp); + if (elf_make_msymbol_special_p) + gdbarch_elf_make_msymbol_special (gdbarch, + sym, mtramp); } } } @@ -682,7 +604,7 @@ elf_rel_plt_read (struct objfile *objfile, asymbol **dyn_symbol_table) if (string_buffer_size < name_len + got_suffix_len + 1) { string_buffer_size = 2 * (name_len + got_suffix_len); - string_buffer = xrealloc (string_buffer, string_buffer_size); + string_buffer = (char *) xrealloc (string_buffer, string_buffer_size); } memcpy (string_buffer, name, name_len); memcpy (&string_buffer[name_len], SYMBOL_GOT_PLT_SUFFIX, @@ -717,7 +639,8 @@ struct elf_gnu_ifunc_cache static hashval_t elf_gnu_ifunc_cache_hash (const void *a_voidp) { - const struct elf_gnu_ifunc_cache *a = a_voidp; + const struct elf_gnu_ifunc_cache *a + = (const struct elf_gnu_ifunc_cache *) a_voidp; return htab_hash_string (a->name); } @@ -727,8 +650,10 @@ elf_gnu_ifunc_cache_hash (const void *a_voidp) 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; + const struct elf_gnu_ifunc_cache *a + = (const struct elf_gnu_ifunc_cache *) a_voidp; + const struct elf_gnu_ifunc_cache *b + = (const struct elf_gnu_ifunc_cache *) b_voidp; return strcmp (a->name, b->name) == 0; } @@ -766,7 +691,7 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr) if (strcmp (bfd_get_section_name (objfile->obfd, sect), ".plt") == 0) return 0; - htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data); + htab = (htab_t) objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data); if (htab == NULL) { htab = htab_create_alloc_ex (1, elf_gnu_ifunc_cache_hash, @@ -781,12 +706,14 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_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); + entry_p + = (struct elf_gnu_ifunc_cache *) obstack_finish (&objfile->objfile_obstack); slot = htab_find_slot (htab, entry_p, INSERT); if (*slot != NULL) { - struct elf_gnu_ifunc_cache *entry_found_p = *slot; + struct elf_gnu_ifunc_cache *entry_found_p + = (struct elf_gnu_ifunc_cache *) *slot; struct gdbarch *gdbarch = get_objfile_arch (objfile); if (entry_found_p->addr != addr) @@ -825,17 +752,18 @@ elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p) struct elf_gnu_ifunc_cache *entry_p; void **slot; - htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data); + htab = (htab_t) objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data); if (htab == NULL) continue; - entry_p = alloca (sizeof (*entry_p) + strlen (name)); + entry_p = ((struct elf_gnu_ifunc_cache *) + alloca (sizeof (*entry_p) + strlen (name))); strcpy (entry_p->name, name); slot = htab_find_slot (htab, entry_p, NO_INSERT); if (slot == NULL) continue; - entry_p = *slot; + entry_p = (struct elf_gnu_ifunc_cache *) *slot; gdb_assert (entry_p != NULL); if (addr_p) @@ -861,7 +789,7 @@ elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p) struct objfile *objfile; const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX); - name_got_plt = alloca (strlen (name) + got_suffix_len + 1); + name_got_plt = (char *) alloca (strlen (name) + got_suffix_len + 1); sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name); ALL_PSPACE_OBJFILES (current_program_space, objfile) @@ -872,7 +800,7 @@ elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p) size_t ptr_size = TYPE_LENGTH (ptr_type); CORE_ADDR pointer_address, addr; asection *plt; - gdb_byte *buf = alloca (ptr_size); + gdb_byte *buf = (gdb_byte *) alloca (ptr_size); struct bound_minimal_symbol msym; msym = lookup_minimal_symbol (name_got_plt, NULL, objfile); @@ -974,7 +902,7 @@ elf_gnu_ifunc_resolver_stop (struct breakpoint *b) 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); + int thread_id = ptid_to_global_thread_id (inferior_ptid); gdb_assert (b->type == bp_gnu_ifunc_resolver); @@ -1069,7 +997,8 @@ elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b) resolved_pc = gdbarch_addr_bits_remove (gdbarch, resolved_pc); gdb_assert (current_program_space == b->pspace || b->pspace == NULL); - elf_gnu_ifunc_record_cache (b->addr_string, resolved_pc); + elf_gnu_ifunc_record_cache (event_location_to_string (b->location), + resolved_pc); sal = find_pc_line (resolved_pc, 0); sals.nelts = 1; @@ -1077,14 +1006,15 @@ elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b) sals_end.nelts = 0; b->type = bp_breakpoint; - update_breakpoint_locations (b, sals, sals_end); + update_breakpoint_locations (b, current_program_space, sals, sals_end); } /* A helper function for elf_symfile_read that reads the minimal symbols. */ static void -elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags) +elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags, + const struct elfinfo *ei) { bfd *synth_abfd, *abfd = objfile->obfd; struct cleanup *back_to; @@ -1100,17 +1030,29 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags) objfile_name (objfile)); } + /* If we already have minsyms, then we can skip some work here. + However, if there were stabs or mdebug sections, we go ahead and + redo all the work anyway, because the psym readers for those + kinds of debuginfo need extra information found here. This can + go away once all types of symbols are in the per-BFD object. */ + if (objfile->per_bfd->minsyms_read + && ei->stabsect == NULL + && ei->mdebugsect == NULL) + { + if (symtab_create_debug) + fprintf_unfiltered (gdb_stdlog, + "... minimal symbols previously read\n"); + return; + } + init_minimal_symbol_collection (); back_to = make_cleanup_discard_minimal_symbols (); /* Allocate struct to keep track of the symfile. */ dbx = XCNEW (struct dbx_symfile_info); set_objfile_data (objfile, dbx_objfile_data_key, dbx); - make_cleanup (free_elfinfo, (void *) objfile); - /* Process the normal ELF symbol table first. This may write some - chain of info into the dbx_symfile_info of the objfile, which can - later be used by elfstab_offset_sections. */ + /* Process the normal ELF symbol table first. */ storage_needed = bfd_get_symtab_upper_bound (objfile->obfd); if (storage_needed < 0) @@ -1120,8 +1062,10 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags) if (storage_needed > 0) { - symbol_table = (asymbol **) xmalloc (storage_needed); - make_cleanup (xfree, symbol_table); + /* Memory gets permanently referenced from ABFD after + bfd_canonicalize_symtab so it must not get freed before ABFD gets. */ + + symbol_table = (asymbol **) bfd_alloc (abfd, storage_needed); symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table); if (symcount < 0) @@ -1145,7 +1089,7 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags) done by _bfd_elf_get_synthetic_symtab which is all a bfd implementation detail, though. */ - dyn_symbol_table = bfd_alloc (abfd, storage_needed); + dyn_symbol_table = (asymbol **) bfd_alloc (abfd, storage_needed); dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd, dyn_symbol_table); @@ -1187,7 +1131,7 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags) long i; make_cleanup (xfree, synthsyms); - synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount); + synth_symbol_table = XNEWVEC (asymbol *, synthcount); for (i = 0; i < synthcount; i++) synth_symbol_table[i] = synthsyms + i; make_cleanup (xfree, synth_symbol_table); @@ -1212,10 +1156,6 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags) We have been initialized by a call to elf_symfile_init, which 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 @@ -1242,16 +1182,11 @@ elf_symfile_read (struct objfile *objfile, int symfile_flags) bfd *abfd = objfile->obfd; struct elfinfo ei; - elf_read_minimal_symbols (objfile, symfile_flags); - memset ((char *) &ei, 0, sizeof (ei)); - - /* Now process debugging information, which is contained in - special ELF sections. */ - - /* We first have to find them... */ bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei); + elf_read_minimal_symbols (objfile, symfile_flags, &ei); + /* 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 @@ -1352,28 +1287,6 @@ read_psyms (struct objfile *objfile) dwarf2_build_psymtabs (objfile); } -/* This cleans up the objfile's dbx symfile info, and the chain of - stab_section_info's, that might be dangling from it. */ - -static void -free_elfinfo (void *objp) -{ - struct objfile *objfile = (struct objfile *) objp; - struct dbx_symfile_info *dbxinfo = DBX_SYMFILE_INFO (objfile); - struct stab_section_info *ssi, *nssi; - - ssi = dbxinfo->stab_section_info; - while (ssi) - { - nssi = ssi->next; - xfree (ssi); - 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). @@ -1399,14 +1312,7 @@ elf_symfile_finish (struct objfile *objfile) dwarf2_free_objfile (objfile); } -/* 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 - just a stub. */ +/* ELF specific initialization routine for reading symbols. */ static void elf_symfile_init (struct objfile *objfile) @@ -1417,80 +1323,17 @@ elf_symfile_init (struct objfile *objfile) 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 -elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst) -{ - const char *filename = pst->filename; - struct dbx_symfile_info *dbx = DBX_SYMFILE_INFO (objfile); - 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. */ - filename = lbasename (filename); - - /* FIXME: This linear search could speed up significantly - if it was chained in the right order to match how we search it, - and if we unchained when we found a match. */ - for (; maybe; maybe = maybe->next) - { - if (filename[0] == maybe->filename[0] - && filename_cmp (filename, maybe->filename) == 0) - { - /* We found a match. But there might be several source files - (from different directories) with the same name. */ - if (0 == maybe->found) - break; - questionable = maybe; /* Might use it later. */ - } - } - - if (maybe == 0 && questionable != 0) - { - complaint (&symfile_complaints, - _("elf/stab section information questionable for %s"), - filename); - maybe = questionable; - } - - if (maybe) - { - /* Found it! Allocate a new psymtab struct, and fill it in. */ - maybe->found++; - pst->section_offsets = (struct section_offsets *) - obstack_alloc (&objfile->objfile_obstack, - SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); - for (i = 0; i < maybe->num_sections; i++) - (pst->section_offsets)->offsets[i] = maybe->sections[i]; - return; - } - - /* We were unable to find any offsets for this file. Complain. */ - if (dbx->stab_section_info) /* If there *is* any info, */ - complaint (&symfile_complaints, - _("elf/stab section information missing for %s"), filename); -} - /* 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; + VEC (probe_p) *probes_per_bfd; /* Have we parsed this objfile's probes already? */ - probes_per_objfile = objfile_data (objfile, probe_key); + probes_per_bfd = (VEC (probe_p) *) bfd_data (objfile->obfd, probe_key); - if (!probes_per_objfile) + if (!probes_per_bfd) { int ix; const struct probe_ops *probe_ops; @@ -1499,43 +1342,28 @@ elf_get_probes (struct objfile *objfile) objfile. */ for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops); ix++) - probe_ops->get_probes (&probes_per_objfile, objfile); + probe_ops->get_probes (&probes_per_bfd, objfile); - if (probes_per_objfile == NULL) + if (probes_per_bfd == NULL) { - VEC_reserve (probe_p, probes_per_objfile, 1); - gdb_assert (probes_per_objfile != NULL); + VEC_reserve (probe_p, probes_per_bfd, 1); + gdb_assert (probes_per_bfd != NULL); } - set_objfile_data (objfile, probe_key, probes_per_objfile); + set_bfd_data (objfile->obfd, probe_key, probes_per_bfd); } - return probes_per_objfile; -} - -/* Implementation of `sym_relocate_probe', as documented in symfile.h. */ - -static void -elf_symfile_relocate_probe (struct objfile *objfile, - const struct section_offsets *new_offsets, - const 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))); + return probes_per_bfd; } /* Helper function used to free the space allocated for storing SystemTap probe information. */ static void -probe_key_free (struct objfile *objfile, void *d) +probe_key_free (bfd *abfd, void *d) { int ix; - VEC (probe_p) *probes = d; + VEC (probe_p) *probes = (VEC (probe_p) *) d; struct probe *probe; for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++) @@ -1551,7 +1379,6 @@ probe_key_free (struct objfile *objfile, void *d) static const struct sym_probe_fns elf_probe_fns = { elf_get_probes, /* sym_get_probes */ - elf_symfile_relocate_probe, /* sym_relocate_probe */ }; /* Register that we are able to handle ELF object file formats. */ @@ -1574,7 +1401,7 @@ static const struct sym_fns elf_sym_fns = /* The same as elf_sym_fns, but not registered and lazily reads psymbols. */ -static const struct sym_fns elf_sym_fns_lazy_psyms = +const struct sym_fns elf_sym_fns_lazy_psyms = { elf_new_init, /* init anything gbl to entire symtab */ elf_symfile_init, /* read initial info, setup for sym_read() */ @@ -1591,7 +1418,7 @@ static const struct sym_fns elf_sym_fns_lazy_psyms = /* The same as elf_sym_fns, but not registered and uses the DWARF-specific GNU index rather than psymtab. */ -static const struct sym_fns elf_sym_fns_gdb_index = +const struct sym_fns elf_sym_fns_gdb_index = { elf_new_init, /* init anything gbl to entire symab */ elf_symfile_init, /* read initial info, setup for sym_red() */ @@ -1619,7 +1446,7 @@ static const struct gnu_ifunc_fns elf_gnu_ifunc_fns = void _initialize_elfread (void) { - probe_key = register_objfile_data_with_cleanup (NULL, probe_key_free); + probe_key = register_bfd_data_with_cleanup (NULL, probe_key_free); add_symtab_fns (bfd_target_elf_flavour, &elf_sym_fns); elf_objfile_gnu_ifunc_cache_data = register_objfile_data ();