X-Git-Url: https://git.efficios.com/?a=blobdiff_plain;f=gdb%2Felfread.c;h=75bdd75250b11cf56ad26ad8552e0981056a95b2;hb=b5b098c2c9b0ea5588e4198740b8b6dfdb740ffd;hp=82437f8acc7e3f4b25b2069c1e16e67ccb27f802;hpb=1adeb822668d3bd7182ca9b8cf42a7261deb3c7f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/elfread.c b/gdb/elfread.c index 82437f8acc..75bdd75250 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-2018 Free Software Foundation, Inc. + Copyright (C) 1991-2020 Free Software Foundation, Inc. Written by Fred Fish at Cygnus Support. @@ -28,9 +28,7 @@ #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" #include "psympriv.h" @@ -41,12 +39,18 @@ #include "value.h" #include "infcall.h" #include "gdbthread.h" +#include "inferior.h" #include "regcache.h" #include "bcache.h" #include "gdb_bfd.h" #include "build-id.h" #include "location.h" #include "auxv.h" +#include "mdebugread.h" +#include "ctfread.h" +#include "gdbsupport/gdb_string_view.h" +#include "gdbsupport/scoped_fd.h" +#include "debuginfod-support.h" /* Forward declarations. */ extern const struct sym_fns elf_sym_fns_gdb_index; @@ -61,11 +65,16 @@ struct elfinfo { asection *stabsect; /* Section pointer for .stab section */ asection *mdebugsect; /* Section pointer for .mdebug section */ + asection *ctfsect; /* Section pointer for .ctf section */ }; +/* Type for per-BFD data. */ + +typedef std::vector> elfread_data; + /* Per-BFD data for probe info. */ -static const struct bfd_data *probe_key = NULL; +static const struct bfd_key probe_key; /* 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 @@ -76,14 +85,13 @@ static const struct bfd_data *probe_key = NULL; /* Locate the segments in ABFD. */ -static struct symfile_segment_data * +static symfile_segment_data_up 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) @@ -103,34 +111,28 @@ elf_symfile_segments (bfd *abfd) if (num_segments == 0) return NULL; - data = XCNEW (struct symfile_segment_data); - data->num_segments = num_segments; - data->segment_bases = XCNEWVEC (CORE_ADDR, num_segments); - data->segment_sizes = XCNEWVEC (CORE_ADDR, num_segments); + symfile_segment_data_up data (new symfile_segment_data); + data->segments.reserve (num_segments); for (i = 0; i < num_segments; i++) - { - data->segment_bases[i] = segments[i]->p_vaddr; - data->segment_sizes[i] = segments[i]->p_memsz; - } + data->segments.emplace_back (segments[i]->p_vaddr, segments[i]->p_memsz); num_sections = bfd_count_sections (abfd); - data->segment_info = XCNEWVEC (int, num_sections); + + /* All elements are initialized to 0 (map to no segment). */ + data->segment_info.resize (num_sections); 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) + if ((bfd_section_flags (sect) & SEC_ALLOC) == 0) continue; - vma = bfd_get_section_vma (abfd, sect); + Elf_Internal_Shdr *this_hdr = &elf_section_data (sect)->this_hdr; for (j = 0; j < num_segments; j++) - if (segments[j]->p_memsz > 0 - && vma >= segments[j]->p_vaddr - && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz) + if (ELF_SECTION_IN_SEGMENT (this_hdr, segments[j])) { data->segment_info[i] = j + 1; break; @@ -145,10 +147,10 @@ elf_symfile_segments (bfd *abfd) 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) + if (bfd_section_size (sect) > 0 && j == num_segments + && (bfd_section_flags (sect) & SEC_LOAD) != 0) warning (_("Loadable section \"%s\" outside of ELF segments"), - bfd_section_name (abfd, sect)); + bfd_section_name (sect)); } return data; @@ -187,25 +189,40 @@ elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip) { ei->mdebugsect = sectp; } + else if (strcmp (sectp->name, ".ctf") == 0) + { + ei->ctfsect = sectp; + } } static struct minimal_symbol * record_minimal_symbol (minimal_symbol_reader &reader, - const char *name, int name_len, bool copy_name, + gdb::string_view name, bool copy_name, CORE_ADDR address, enum minimal_symbol_type ms_type, asection *bfd_section, struct objfile *objfile) { - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); if (ms_type == mst_text || ms_type == mst_file_text || ms_type == mst_text_gnu_ifunc) address = gdbarch_addr_bits_remove (gdbarch, address); - return reader.record_full (name, name_len, copy_name, address, - ms_type, - gdb_bfd_section_index (objfile->obfd, - bfd_section)); + /* We only setup section information for allocatable sections. Usually + we'd only expect to find msymbols for allocatable sections, but if the + ELF is malformed then this might not be the case. In that case don't + create an msymbol that references an uninitialised section object. */ + int section_index = 0; + if ((bfd_section_flags (bfd_section) & SEC_ALLOC) == SEC_ALLOC) + section_index = gdb_bfd_section_index (objfile->obfd, bfd_section); + + struct minimal_symbol *result + = reader.record_full (name, copy_name, address, ms_type, section_index); + if ((objfile->flags & OBJF_MAINLINE) == 0 + && (ms_type == mst_data || ms_type == mst_bss)) + result->maybe_copied = 1; + + return result; } /* Read the symbol table of an ELF file. @@ -230,7 +247,7 @@ elf_symtab_read (minimal_symbol_reader &reader, long number_of_symbols, asymbol **symbol_table, bool copy_names) { - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); asymbol *sym; long i; CORE_ADDR symaddr; @@ -288,12 +305,12 @@ elf_symtab_read (minimal_symbol_reader &reader, covers the stub's address. */ for (sect = abfd->sections; sect != NULL; sect = sect->next) { - if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) + if ((bfd_section_flags (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)) + if (symaddr >= bfd_section_vma (sect) + && symaddr < bfd_section_vma (sect) + + bfd_section_size (sect)) break; } if (!sect) @@ -317,7 +334,7 @@ elf_symtab_read (minimal_symbol_reader &reader, continue; msym = record_minimal_symbol - (reader, sym->name, strlen (sym->name), copy_names, + (reader, sym->name, copy_names, symaddr, mst_solib_trampoline, sect, objfile); if (msym != NULL) { @@ -334,11 +351,7 @@ elf_symtab_read (minimal_symbol_reader &reader, if (type == ST_DYNAMIC && !stripped) continue; if (sym->flags & BSF_FILE) - { - filesymname - = (const char *) bcache (sym->name, strlen (sym->name) + 1, - objfile->per_bfd->filename_cache); - } + filesymname = objfile->intern (sym->name); else if (sym->flags & BSF_SECTION_SYM) continue; else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK @@ -422,7 +435,11 @@ elf_symtab_read (minimal_symbol_reader &reader, { if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) { - if (sym->section->flags & SEC_LOAD) + if (sym->flags & BSF_GNU_INDIRECT_FUNCTION) + { + ms_type = mst_data_gnu_ifunc; + } + else if (sym->section->flags & SEC_LOAD) { ms_type = mst_data; } @@ -457,7 +474,7 @@ elf_symtab_read (minimal_symbol_reader &reader, continue; /* Skip this symbol. */ } msym = record_minimal_symbol - (reader, sym->name, strlen (sym->name), copy_names, symaddr, + (reader, sym->name, copy_names, symaddr, ms_type, sym->section, objfile); if (msym) @@ -486,8 +503,10 @@ elf_symtab_read (minimal_symbol_reader &reader, { int len = atsign - sym->name; - record_minimal_symbol (reader, sym->name, len, true, symaddr, - ms_type, sym->section, objfile); + record_minimal_symbol (reader, + gdb::string_view (sym->name, len), + true, symaddr, ms_type, sym->section, + objfile); } } @@ -503,10 +522,9 @@ elf_symtab_read (minimal_symbol_reader &reader, { struct minimal_symbol *mtramp; - mtramp = record_minimal_symbol (reader, sym->name, len - 4, - true, symaddr, - mst_solib_trampoline, - sym->section, objfile); + mtramp = record_minimal_symbol + (reader, gdb::string_view (sym->name, len - 4), true, + symaddr, mst_solib_trampoline, sym->section, objfile); if (mtramp) { SET_MSYMBOL_SIZE (mtramp, MSYMBOL_SIZE (msym)); @@ -537,7 +555,7 @@ elf_rel_plt_read (minimal_symbol_reader &reader, const struct elf_backend_data *bed = get_elf_backend_data (obfd); asection *relplt, *got_plt; bfd_size_type reloc_count, reloc; - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; size_t ptr_size = TYPE_LENGTH (ptr_type); @@ -586,9 +604,9 @@ elf_rel_plt_read (minimal_symbol_reader &reader, if (section == NULL) return false; - return (bfd_get_section_vma (obfd, section) <= address - && (address < bfd_get_section_vma (obfd, section) - + bfd_get_section_size (section))); + return (bfd_section_vma (section) <= address + && (address < bfd_section_vma (section) + + bfd_section_size (section))); }; reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize; @@ -614,15 +632,15 @@ elf_rel_plt_read (minimal_symbol_reader &reader, else 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. */ + /* We cannot check if NAME is a reference to + mst_text_gnu_ifunc/mst_data_gnu_ifunc as in OBJFILE the + symbol is undefined and the objfile having NAME defined may + not yet have been loaded. */ string_buffer.assign (name); string_buffer.append (got_suffix, got_suffix + got_suffix_len); - msym = record_minimal_symbol (reader, string_buffer.c_str (), - string_buffer.size (), + msym = record_minimal_symbol (reader, string_buffer, true, address, mst_slot_got_plt, msym_section, objfile); if (msym) @@ -632,7 +650,8 @@ elf_rel_plt_read (minimal_symbol_reader &reader, /* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */ -static const struct objfile_data *elf_objfile_gnu_ifunc_cache_data; +static const struct objfile_key + elf_objfile_gnu_ifunc_cache_data; /* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */ @@ -694,7 +713,7 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr) /* If .plt jumps back to .plt the symbol is still deferred for later resolution and it has no use for GDB. */ - const char *target_name = MSYMBOL_LINKAGE_NAME (msym.minsym); + const char *target_name = msym.minsym->linkage_name (); size_t len = strlen (target_name); /* Note we check the symbol's name instead of checking whether the @@ -703,15 +722,13 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr) if (len > 4 && strcmp (target_name + len - 4, "@plt") == 0) return 0; - htab = (htab_t) objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data); + htab = elf_objfile_gnu_ifunc_cache_data.get (objfile); 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); + htab = htab_create_alloc (1, elf_gnu_ifunc_cache_hash, + elf_gnu_ifunc_cache_eq, + NULL, xcalloc, xfree); + elf_objfile_gnu_ifunc_cache_data.set (objfile, htab); } entry_local.addr = addr; @@ -726,7 +743,7 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr) { struct elf_gnu_ifunc_cache *entry_found_p = (struct elf_gnu_ifunc_cache *) *slot; - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); if (entry_found_p->addr != addr) { @@ -756,15 +773,13 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr) 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) + for (objfile *objfile : current_program_space->objfiles ()) { htab_t htab; struct elf_gnu_ifunc_cache *entry_p; void **slot; - htab = (htab_t) objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data); + htab = elf_objfile_gnu_ifunc_cache_data.get (objfile); if (htab == NULL) continue; @@ -798,16 +813,15 @@ static int elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p) { char *name_got_plt; - struct objfile *objfile; const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX); name_got_plt = (char *) alloca (strlen (name) + got_suffix_len + 1); sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name); - ALL_PSPACE_OBJFILES (current_program_space, objfile) + for (objfile *objfile : current_program_space->objfiles ()) { bfd *obfd = objfile->obfd; - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; size_t ptr_size = TYPE_LENGTH (ptr_type); CORE_ADDR pointer_address, addr; @@ -832,7 +846,7 @@ elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p) continue; addr = extract_typed_address (buf, ptr_type); addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, - ¤t_target); + current_top_target ()); addr = gdbarch_addr_bits_remove (gdbarch, addr); if (elf_gnu_ifunc_record_cache (name, addr)) @@ -848,21 +862,21 @@ elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p) /* 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. + is not NULL) and the function returns true. It returns false otherwise. Both the elf_objfile_gnu_ifunc_cache_data hash table and SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */ -static int +static bool elf_gnu_ifunc_resolve_name (const char *name, CORE_ADDR *addr_p) { if (elf_gnu_ifunc_resolve_by_cache (name, addr_p)) - return 1; + return true; if (elf_gnu_ifunc_resolve_by_got (name, addr_p)) - return 1; + return true; - return 0; + return false; } /* Call STT_GNU_IFUNC - a function returning addresss of a real function to @@ -899,13 +913,12 @@ elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc) parameter. FUNCTION is the function entry address. ADDRESS may be a function descriptor. */ - target_auxv_search (¤t_target, AT_HWCAP, &hwcap); + target_auxv_search (current_top_target (), AT_HWCAP, &hwcap); hwcap_val = value_from_longest (builtin_type (gdbarch) ->builtin_unsigned_long, hwcap); - address_val = call_function_by_hand (function, NULL, 1, &hwcap_val); + address_val = call_function_by_hand (function, NULL, hwcap_val); address = value_as_address (address_val); - address = gdbarch_convert_from_func_ptr_addr (gdbarch, address, - ¤t_target); + address = gdbarch_convert_from_func_ptr_addr (gdbarch, address, current_top_target ()); address = gdbarch_addr_bits_remove (gdbarch, address); if (name_at_pc) @@ -923,7 +936,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 = ptid_to_global_thread_id (inferior_ptid); + int thread_id = inferior_thread ()->global_num; gdb_assert (b->type == bp_gnu_ifunc_resolver); @@ -970,10 +983,11 @@ elf_gnu_ifunc_resolver_stop (struct breakpoint *b) static void elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b) { + thread_info *thread = inferior_thread (); struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func; struct type *value_type = TYPE_TARGET_TYPE (func_func_type); - struct regcache *regcache = get_thread_regcache (inferior_ptid); + struct regcache *regcache = get_thread_regcache (thread); struct value *func_func; struct value *value; CORE_ADDR resolved_address, resolved_pc; @@ -1012,7 +1026,7 @@ elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b) resolved_address = value_as_address (value); resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch, resolved_address, - ¤t_target); + current_top_target ()); resolved_pc = gdbarch_addr_bits_remove (gdbarch, resolved_pc); gdb_assert (current_program_space == b->pspace || b->pspace == NULL); @@ -1021,7 +1035,8 @@ elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b) b->type = bp_breakpoint; update_breakpoint_locations (b, current_program_space, - find_pc_line (resolved_pc, 0), {}); + find_function_start_sal (resolved_pc, NULL, true), + {}); } /* A helper function for elf_symfile_read that reads the minimal @@ -1035,7 +1050,6 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags, long symcount = 0, dynsymcount = 0, synthcount, storage_needed; asymbol **symbol_table = NULL, **dyn_symbol_table = NULL; asymbol *synthsyms; - struct dbx_symfile_info *dbx; if (symtab_create_debug) { @@ -1051,7 +1065,8 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags, 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) + && ei->mdebugsect == NULL + && ei->ctfsect == NULL) { if (symtab_create_debug) fprintf_unfiltered (gdb_stdlog, @@ -1061,10 +1076,6 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags, minimal_symbol_reader reader (objfile); - /* Allocate struct to keep track of the symfile. */ - dbx = XCNEW (struct dbx_symfile_info); - set_objfile_data (objfile, dbx_objfile_data_key, dbx); - /* Process the normal ELF symbol table first. */ storage_needed = bfd_get_symtab_upper_bound (objfile->obfd); @@ -1196,6 +1207,7 @@ elf_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) { bfd *abfd = objfile->obfd; struct elfinfo ei; + bool has_dwarf2 = true; memset ((char *) &ei, 0, sizeof (ei)); if (!(objfile->flags & OBJF_READNEVER)) @@ -1238,10 +1250,10 @@ elf_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) elfstab_build_psymtabs (objfile, ei.stabsect, str_sect->filepos, - bfd_section_size (abfd, str_sect)); + bfd_section_size (str_sect)); } - if (dwarf2_has_info (objfile, NULL)) + if (dwarf2_has_info (objfile, NULL, true)) { dw_index_kind index_kind; @@ -1293,11 +1305,47 @@ elf_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) if (!debugfile.empty ()) { - gdb_bfd_ref_ptr abfd (symfile_bfd_open (debugfile.c_str ())); + gdb_bfd_ref_ptr debug_bfd (symfile_bfd_open (debugfile.c_str ())); - symbol_file_add_separate (abfd.get (), debugfile.c_str (), + symbol_file_add_separate (debug_bfd.get (), debugfile.c_str (), symfile_flags, objfile); } + else + { + has_dwarf2 = false; + const struct bfd_build_id *build_id = build_id_bfd_get (objfile->obfd); + + if (build_id != nullptr) + { + gdb::unique_xmalloc_ptr symfile_path; + scoped_fd fd (debuginfod_debuginfo_query (build_id->data, + build_id->size, + objfile->original_name, + &symfile_path)); + + if (fd.get () >= 0) + { + /* File successfully retrieved from server. */ + gdb_bfd_ref_ptr debug_bfd (symfile_bfd_open (symfile_path.get ())); + + if (debug_bfd == nullptr) + warning (_("File \"%s\" from debuginfod cannot be opened as bfd"), + objfile->original_name); + else if (build_id_verify (debug_bfd.get (), build_id->size, build_id->data)) + { + symbol_file_add_separate (debug_bfd.get (), symfile_path.get (), + symfile_flags, objfile); + has_dwarf2 = true; + } + } + } + } + } + + /* Read the CTF section only if there is no DWARF info. */ + if (!has_dwarf2 && ei.ctfsect) + { + elfctf_build_psymtabs (objfile); } } @@ -1312,16 +1360,11 @@ read_psyms (struct objfile *objfile) /* 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). - - We reinitialize buildsym, since we may be reading stabs from an ELF - file. */ + shared library). */ static void elf_new_init (struct objfile *ignore) { - stabsread_new_init (); - buildsym_new_init (); } /* Perform any local cleanups required when we are done with a particular @@ -1332,7 +1375,6 @@ elf_new_init (struct objfile *ignore) static void elf_symfile_finish (struct objfile *objfile) { - dwarf2_free_objfile (objfile); } /* ELF specific initialization routine for reading symbols. */ @@ -1348,43 +1390,24 @@ elf_symfile_init (struct objfile *objfile) /* Implementation of `sym_get_probes', as documented in symfile.h. */ -static const std::vector & +static const elfread_data & elf_get_probes (struct objfile *objfile) { - std::vector *probes_per_bfd; - - /* Have we parsed this objfile's probes already? */ - probes_per_bfd = (std::vector *) bfd_data (objfile->obfd, probe_key); + elfread_data *probes_per_bfd = probe_key.get (objfile->obfd); if (probes_per_bfd == NULL) { - probes_per_bfd = new std::vector; + probes_per_bfd = probe_key.emplace (objfile->obfd); /* Here we try to gather information about all types of probes from the objfile. */ for (const static_probe_ops *ops : all_static_probe_ops) ops->get_probes (probes_per_bfd, objfile); - - set_bfd_data (objfile->obfd, probe_key, probes_per_bfd); } return *probes_per_bfd; } -/* Helper function used to free the space allocated for storing SystemTap - probe information. */ - -static void -probe_key_free (bfd *abfd, void *d) -{ - std::vector *probes = (std::vector *) d; - - for (probe *p : *probes) - delete p; - - delete probes; -} - /* Implementation `sym_probe_fns', as documented in symfile.h. */ @@ -1438,7 +1461,7 @@ const struct sym_fns elf_sym_fns_gdb_index = elf_symfile_read, /* read a symbol file into symtab */ NULL, /* sym_read_psymbols */ elf_symfile_finish, /* finished with file, cleanup */ - default_symfile_offsets, /* Translate ext. to int. relocatin */ + 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. */ @@ -1455,7 +1478,7 @@ const struct sym_fns elf_sym_fns_debug_names = elf_symfile_read, /* read a symbol file into symtab */ NULL, /* sym_read_psymbols */ elf_symfile_finish, /* finished with file, cleanup */ - default_symfile_offsets, /* Translate ext. to int. relocatin */ + 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. */ @@ -1473,12 +1496,11 @@ static const struct gnu_ifunc_fns elf_gnu_ifunc_fns = elf_gnu_ifunc_resolver_return_stop }; +void _initialize_elfread (); void -_initialize_elfread (void) +_initialize_elfread () { - 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 (); gnu_ifunc_fns_p = &elf_gnu_ifunc_fns; }