1 /* Read ELF (Executable and Linking Format) object files for GDB. 2 3 Copyright (C) 1991-2021 Free Software Foundation, Inc. 4 5 Written by Fred Fish at Cygnus Support. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "bfd.h" 24 #include "elf-bfd.h" 25 #include "elf/common.h" 26 #include "elf/internal.h" 27 #include "elf/mips.h" 28 #include "symtab.h" 29 #include "symfile.h" 30 #include "objfiles.h" 31 #include "stabsread.h" 32 #include "complaints.h" 33 #include "demangle.h" 34 #include "psympriv.h" 35 #include "filenames.h" 36 #include "probe.h" 37 #include "arch-utils.h" 38 #include "gdbtypes.h" 39 #include "value.h" 40 #include "infcall.h" 41 #include "gdbthread.h" 42 #include "inferior.h" 43 #include "regcache.h" 44 #include "bcache.h" 45 #include "gdb_bfd.h" 46 #include "build-id.h" 47 #include "location.h" 48 #include "auxv.h" 49 #include "mdebugread.h" 50 #include "ctfread.h" 51 #include "gdbsupport/gdb_string_view.h" 52 #include "gdbsupport/scoped_fd.h" 53 #include "debuginfod-support.h" 54 #include "dwarf2/public.h" 55 56 /* The struct elfinfo is available only during ELF symbol table and 57 psymtab reading. It is destroyed at the completion of psymtab-reading. 58 It's local to elf_symfile_read. */ 59 60 struct elfinfo 61 { 62 asection *stabsect; /* Section pointer for .stab section */ 63 asection *mdebugsect; /* Section pointer for .mdebug section */ 64 asection *ctfsect; /* Section pointer for .ctf section */ 65 }; 66 67 /* Type for per-BFD data. */ 68 69 typedef std::vector<std::unique_ptr<probe>> elfread_data; 70 71 /* Per-BFD data for probe info. */ 72 73 static const struct bfd_key<elfread_data> probe_key; 74 75 /* Minimal symbols located at the GOT entries for .plt - that is the real 76 pointer where the given entry will jump to. It gets updated by the real 77 function address during lazy ld.so resolving in the inferior. These 78 minimal symbols are indexed for <tab>-completion. */ 79 80 #define SYMBOL_GOT_PLT_SUFFIX "@got.plt" 81 82 /* Locate the segments in ABFD. */ 83 84 static symfile_segment_data_up 85 elf_symfile_segments (bfd *abfd) 86 { 87 Elf_Internal_Phdr *phdrs, **segments; 88 long phdrs_size; 89 int num_phdrs, num_segments, num_sections, i; 90 asection *sect; 91 92 phdrs_size = bfd_get_elf_phdr_upper_bound (abfd); 93 if (phdrs_size == -1) 94 return NULL; 95 96 phdrs = (Elf_Internal_Phdr *) alloca (phdrs_size); 97 num_phdrs = bfd_get_elf_phdrs (abfd, phdrs); 98 if (num_phdrs == -1) 99 return NULL; 100 101 num_segments = 0; 102 segments = XALLOCAVEC (Elf_Internal_Phdr *, num_phdrs); 103 for (i = 0; i < num_phdrs; i++) 104 if (phdrs[i].p_type == PT_LOAD) 105 segments[num_segments++] = &phdrs[i]; 106 107 if (num_segments == 0) 108 return NULL; 109 110 symfile_segment_data_up data (new symfile_segment_data); 111 data->segments.reserve (num_segments); 112 113 for (i = 0; i < num_segments; i++) 114 data->segments.emplace_back (segments[i]->p_vaddr, segments[i]->p_memsz); 115 116 num_sections = bfd_count_sections (abfd); 117 118 /* All elements are initialized to 0 (map to no segment). */ 119 data->segment_info.resize (num_sections); 120 121 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) 122 { 123 int j; 124 125 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0) 126 continue; 127 128 Elf_Internal_Shdr *this_hdr = &elf_section_data (sect)->this_hdr; 129 130 for (j = 0; j < num_segments; j++) 131 if (ELF_SECTION_IN_SEGMENT (this_hdr, segments[j])) 132 { 133 data->segment_info[i] = j + 1; 134 break; 135 } 136 137 /* We should have found a segment for every non-empty section. 138 If we haven't, we will not relocate this section by any 139 offsets we apply to the segments. As an exception, do not 140 warn about SHT_NOBITS sections; in normal ELF execution 141 environments, SHT_NOBITS means zero-initialized and belongs 142 in a segment, but in no-OS environments some tools (e.g. ARM 143 RealView) use SHT_NOBITS for uninitialized data. Since it is 144 uninitialized, it doesn't need a program header. Such 145 binaries are not relocatable. */ 146 147 /* Exclude debuginfo files from this warning, too, since those 148 are often not strictly compliant with the standard. See, e.g., 149 ld/24717 for more discussion. */ 150 if (!is_debuginfo_file (abfd) 151 && bfd_section_size (sect) > 0 && j == num_segments 152 && (bfd_section_flags (sect) & SEC_LOAD) != 0) 153 warning (_("Loadable section \"%s\" outside of ELF segments\n in %s"), 154 bfd_section_name (sect), bfd_get_filename (abfd)); 155 } 156 157 return data; 158 } 159 160 /* We are called once per section from elf_symfile_read. We 161 need to examine each section we are passed, check to see 162 if it is something we are interested in processing, and 163 if so, stash away some access information for the section. 164 165 For now we recognize the dwarf debug information sections and 166 line number sections from matching their section names. The 167 ELF definition is no real help here since it has no direct 168 knowledge of DWARF (by design, so any debugging format can be 169 used). 170 171 We also recognize the ".stab" sections used by the Sun compilers 172 released with Solaris 2. 173 174 FIXME: The section names should not be hardwired strings (what 175 should they be? I don't think most object file formats have enough 176 section flags to specify what kind of debug section it is. 177 -kingdon). */ 178 179 static void 180 elf_locate_sections (asection *sectp, struct elfinfo *ei) 181 { 182 if (strcmp (sectp->name, ".stab") == 0) 183 { 184 ei->stabsect = sectp; 185 } 186 else if (strcmp (sectp->name, ".mdebug") == 0) 187 { 188 ei->mdebugsect = sectp; 189 } 190 else if (strcmp (sectp->name, ".ctf") == 0) 191 { 192 ei->ctfsect = sectp; 193 } 194 } 195 196 static struct minimal_symbol * 197 record_minimal_symbol (minimal_symbol_reader &reader, 198 gdb::string_view name, bool copy_name, 199 CORE_ADDR address, 200 enum minimal_symbol_type ms_type, 201 asection *bfd_section, struct objfile *objfile) 202 { 203 struct gdbarch *gdbarch = objfile->arch (); 204 205 if (ms_type == mst_text || ms_type == mst_file_text 206 || ms_type == mst_text_gnu_ifunc) 207 address = gdbarch_addr_bits_remove (gdbarch, address); 208 209 /* We only setup section information for allocatable sections. Usually 210 we'd only expect to find msymbols for allocatable sections, but if the 211 ELF is malformed then this might not be the case. In that case don't 212 create an msymbol that references an uninitialised section object. */ 213 int section_index = 0; 214 if ((bfd_section_flags (bfd_section) & SEC_ALLOC) == SEC_ALLOC) 215 section_index = gdb_bfd_section_index (objfile->obfd, bfd_section); 216 217 struct minimal_symbol *result 218 = reader.record_full (name, copy_name, address, ms_type, section_index); 219 if ((objfile->flags & OBJF_MAINLINE) == 0 220 && (ms_type == mst_data || ms_type == mst_bss)) 221 result->maybe_copied = 1; 222 223 return result; 224 } 225 226 /* Read the symbol table of an ELF file. 227 228 Given an objfile, a symbol table, and a flag indicating whether the 229 symbol table contains regular, dynamic, or synthetic symbols, add all 230 the global function and data symbols to the minimal symbol table. 231 232 In stabs-in-ELF, as implemented by Sun, there are some local symbols 233 defined in the ELF symbol table, which can be used to locate 234 the beginnings of sections from each ".o" file that was linked to 235 form the executable objfile. We gather any such info and record it 236 in data structures hung off the objfile's private data. */ 237 238 #define ST_REGULAR 0 239 #define ST_DYNAMIC 1 240 #define ST_SYNTHETIC 2 241 242 static void 243 elf_symtab_read (minimal_symbol_reader &reader, 244 struct objfile *objfile, int type, 245 long number_of_symbols, asymbol **symbol_table, 246 bool copy_names) 247 { 248 struct gdbarch *gdbarch = objfile->arch (); 249 asymbol *sym; 250 long i; 251 CORE_ADDR symaddr; 252 enum minimal_symbol_type ms_type; 253 /* Name of the last file symbol. This is either a constant string or is 254 saved on the objfile's filename cache. */ 255 const char *filesymname = ""; 256 int stripped = (bfd_get_symcount (objfile->obfd) == 0); 257 int elf_make_msymbol_special_p 258 = gdbarch_elf_make_msymbol_special_p (gdbarch); 259 260 for (i = 0; i < number_of_symbols; i++) 261 { 262 sym = symbol_table[i]; 263 if (sym->name == NULL || *sym->name == '\0') 264 { 265 /* Skip names that don't exist (shouldn't happen), or names 266 that are null strings (may happen). */ 267 continue; 268 } 269 270 /* Skip "special" symbols, e.g. ARM mapping symbols. These are 271 symbols which do not correspond to objects in the symbol table, 272 but have some other target-specific meaning. */ 273 if (bfd_is_target_special_symbol (objfile->obfd, sym)) 274 { 275 if (gdbarch_record_special_symbol_p (gdbarch)) 276 gdbarch_record_special_symbol (gdbarch, objfile, sym); 277 continue; 278 } 279 280 if (type == ST_DYNAMIC 281 && sym->section == bfd_und_section_ptr 282 && (sym->flags & BSF_FUNCTION)) 283 { 284 struct minimal_symbol *msym; 285 bfd *abfd = objfile->obfd; 286 asection *sect; 287 288 /* Symbol is a reference to a function defined in 289 a shared library. 290 If its value is non zero then it is usually the address 291 of the corresponding entry in the procedure linkage table, 292 plus the desired section offset. 293 If its value is zero then the dynamic linker has to resolve 294 the symbol. We are unable to find any meaningful address 295 for this symbol in the executable file, so we skip it. */ 296 symaddr = sym->value; 297 if (symaddr == 0) 298 continue; 299 300 /* sym->section is the undefined section. However, we want to 301 record the section where the PLT stub resides with the 302 minimal symbol. Search the section table for the one that 303 covers the stub's address. */ 304 for (sect = abfd->sections; sect != NULL; sect = sect->next) 305 { 306 if ((bfd_section_flags (sect) & SEC_ALLOC) == 0) 307 continue; 308 309 if (symaddr >= bfd_section_vma (sect) 310 && symaddr < bfd_section_vma (sect) 311 + bfd_section_size (sect)) 312 break; 313 } 314 if (!sect) 315 continue; 316 317 /* On ia64-hpux, we have discovered that the system linker 318 adds undefined symbols with nonzero addresses that cannot 319 be right (their address points inside the code of another 320 function in the .text section). This creates problems 321 when trying to determine which symbol corresponds to 322 a given address. 323 324 We try to detect those buggy symbols by checking which 325 section we think they correspond to. Normally, PLT symbols 326 are stored inside their own section, and the typical name 327 for that section is ".plt". So, if there is a ".plt" 328 section, and yet the section name of our symbol does not 329 start with ".plt", we ignore that symbol. */ 330 if (!startswith (sect->name, ".plt") 331 && bfd_get_section_by_name (abfd, ".plt") != NULL) 332 continue; 333 334 msym = record_minimal_symbol 335 (reader, sym->name, copy_names, 336 symaddr, mst_solib_trampoline, sect, objfile); 337 if (msym != NULL) 338 { 339 msym->filename = filesymname; 340 if (elf_make_msymbol_special_p) 341 gdbarch_elf_make_msymbol_special (gdbarch, sym, msym); 342 } 343 continue; 344 } 345 346 /* If it is a nonstripped executable, do not enter dynamic 347 symbols, as the dynamic symbol table is usually a subset 348 of the main symbol table. */ 349 if (type == ST_DYNAMIC && !stripped) 350 continue; 351 if (sym->flags & BSF_FILE) 352 filesymname = objfile->intern (sym->name); 353 else if (sym->flags & BSF_SECTION_SYM) 354 continue; 355 else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK 356 | BSF_GNU_UNIQUE)) 357 { 358 struct minimal_symbol *msym; 359 360 /* Select global/local/weak symbols. Note that bfd puts abs 361 symbols in their own section, so all symbols we are 362 interested in will have a section. */ 363 /* Bfd symbols are section relative. */ 364 symaddr = sym->value + sym->section->vma; 365 /* For non-absolute symbols, use the type of the section 366 they are relative to, to intuit text/data. Bfd provides 367 no way of figuring this out for absolute symbols. */ 368 if (sym->section == bfd_abs_section_ptr) 369 { 370 /* This is a hack to get the minimal symbol type 371 right for Irix 5, which has absolute addresses 372 with special section indices for dynamic symbols. 373 374 NOTE: uweigand-20071112: Synthetic symbols do not 375 have an ELF-private part, so do not touch those. */ 376 unsigned int shndx = type == ST_SYNTHETIC ? 0 : 377 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx; 378 379 switch (shndx) 380 { 381 case SHN_MIPS_TEXT: 382 ms_type = mst_text; 383 break; 384 case SHN_MIPS_DATA: 385 ms_type = mst_data; 386 break; 387 case SHN_MIPS_ACOMMON: 388 ms_type = mst_bss; 389 break; 390 default: 391 ms_type = mst_abs; 392 } 393 394 /* If it is an Irix dynamic symbol, skip section name 395 symbols, relocate all others by section offset. */ 396 if (ms_type != mst_abs) 397 { 398 if (sym->name[0] == '.') 399 continue; 400 } 401 } 402 else if (sym->section->flags & SEC_CODE) 403 { 404 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) 405 { 406 if (sym->flags & BSF_GNU_INDIRECT_FUNCTION) 407 ms_type = mst_text_gnu_ifunc; 408 else 409 ms_type = mst_text; 410 } 411 /* The BSF_SYNTHETIC check is there to omit ppc64 function 412 descriptors mistaken for static functions starting with 'L'. 413 */ 414 else if ((sym->name[0] == '.' && sym->name[1] == 'L' 415 && (sym->flags & BSF_SYNTHETIC) == 0) 416 || ((sym->flags & BSF_LOCAL) 417 && sym->name[0] == '$' 418 && sym->name[1] == 'L')) 419 /* Looks like a compiler-generated label. Skip 420 it. The assembler should be skipping these (to 421 keep executables small), but apparently with 422 gcc on the (deleted) delta m88k SVR4, it loses. 423 So to have us check too should be harmless (but 424 I encourage people to fix this in the assembler 425 instead of adding checks here). */ 426 continue; 427 else 428 { 429 ms_type = mst_file_text; 430 } 431 } 432 else if (sym->section->flags & SEC_ALLOC) 433 { 434 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) 435 { 436 if (sym->flags & BSF_GNU_INDIRECT_FUNCTION) 437 { 438 ms_type = mst_data_gnu_ifunc; 439 } 440 else if (sym->section->flags & SEC_LOAD) 441 { 442 ms_type = mst_data; 443 } 444 else 445 { 446 ms_type = mst_bss; 447 } 448 } 449 else if (sym->flags & BSF_LOCAL) 450 { 451 if (sym->section->flags & SEC_LOAD) 452 { 453 ms_type = mst_file_data; 454 } 455 else 456 { 457 ms_type = mst_file_bss; 458 } 459 } 460 else 461 { 462 ms_type = mst_unknown; 463 } 464 } 465 else 466 { 467 /* FIXME: Solaris2 shared libraries include lots of 468 odd "absolute" and "undefined" symbols, that play 469 hob with actions like finding what function the PC 470 is in. Ignore them if they aren't text, data, or bss. */ 471 /* ms_type = mst_unknown; */ 472 continue; /* Skip this symbol. */ 473 } 474 msym = record_minimal_symbol 475 (reader, sym->name, copy_names, symaddr, 476 ms_type, sym->section, objfile); 477 478 if (msym) 479 { 480 /* NOTE: uweigand-20071112: A synthetic symbol does not have an 481 ELF-private part. */ 482 if (type != ST_SYNTHETIC) 483 { 484 /* Pass symbol size field in via BFD. FIXME!!! */ 485 elf_symbol_type *elf_sym = (elf_symbol_type *) sym; 486 SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size); 487 } 488 489 msym->filename = filesymname; 490 if (elf_make_msymbol_special_p) 491 gdbarch_elf_make_msymbol_special (gdbarch, sym, msym); 492 } 493 494 /* If we see a default versioned symbol, install it under 495 its version-less name. */ 496 if (msym != NULL) 497 { 498 const char *atsign = strchr (sym->name, '@'); 499 500 if (atsign != NULL && atsign[1] == '@' && atsign > sym->name) 501 { 502 int len = atsign - sym->name; 503 504 record_minimal_symbol (reader, 505 gdb::string_view (sym->name, len), 506 true, symaddr, ms_type, sym->section, 507 objfile); 508 } 509 } 510 511 /* For @plt symbols, also record a trampoline to the 512 destination symbol. The @plt symbol will be used in 513 disassembly, and the trampoline will be used when we are 514 trying to find the target. */ 515 if (msym && ms_type == mst_text && type == ST_SYNTHETIC) 516 { 517 int len = strlen (sym->name); 518 519 if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0) 520 { 521 struct minimal_symbol *mtramp; 522 523 mtramp = record_minimal_symbol 524 (reader, gdb::string_view (sym->name, len - 4), true, 525 symaddr, mst_solib_trampoline, sym->section, objfile); 526 if (mtramp) 527 { 528 SET_MSYMBOL_SIZE (mtramp, MSYMBOL_SIZE (msym)); 529 mtramp->created_by_gdb = 1; 530 mtramp->filename = filesymname; 531 if (elf_make_msymbol_special_p) 532 gdbarch_elf_make_msymbol_special (gdbarch, 533 sym, mtramp); 534 } 535 } 536 } 537 } 538 } 539 } 540 541 /* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX) 542 for later look ups of which function to call when user requests 543 a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target 544 library defining `function' we cannot yet know while reading OBJFILE which 545 of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later 546 DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */ 547 548 static void 549 elf_rel_plt_read (minimal_symbol_reader &reader, 550 struct objfile *objfile, asymbol **dyn_symbol_table) 551 { 552 bfd *obfd = objfile->obfd; 553 const struct elf_backend_data *bed = get_elf_backend_data (obfd); 554 asection *relplt, *got_plt; 555 bfd_size_type reloc_count, reloc; 556 struct gdbarch *gdbarch = objfile->arch (); 557 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 558 size_t ptr_size = TYPE_LENGTH (ptr_type); 559 560 if (objfile->separate_debug_objfile_backlink) 561 return; 562 563 got_plt = bfd_get_section_by_name (obfd, ".got.plt"); 564 if (got_plt == NULL) 565 { 566 /* For platforms where there is no separate .got.plt. */ 567 got_plt = bfd_get_section_by_name (obfd, ".got"); 568 if (got_plt == NULL) 569 return; 570 } 571 572 /* Depending on system, we may find jump slots in a relocation 573 section for either .got.plt or .plt. */ 574 asection *plt = bfd_get_section_by_name (obfd, ".plt"); 575 int plt_elf_idx = (plt != NULL) ? elf_section_data (plt)->this_idx : -1; 576 577 int got_plt_elf_idx = elf_section_data (got_plt)->this_idx; 578 579 /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */ 580 for (relplt = obfd->sections; relplt != NULL; relplt = relplt->next) 581 { 582 const auto &this_hdr = elf_section_data (relplt)->this_hdr; 583 584 if (this_hdr.sh_type == SHT_REL || this_hdr.sh_type == SHT_RELA) 585 { 586 if (this_hdr.sh_info == plt_elf_idx 587 || this_hdr.sh_info == got_plt_elf_idx) 588 break; 589 } 590 } 591 if (relplt == NULL) 592 return; 593 594 if (! bed->s->slurp_reloc_table (obfd, relplt, dyn_symbol_table, TRUE)) 595 return; 596 597 std::string string_buffer; 598 599 /* Does ADDRESS reside in SECTION of OBFD? */ 600 auto within_section = [obfd] (asection *section, CORE_ADDR address) 601 { 602 if (section == NULL) 603 return false; 604 605 return (bfd_section_vma (section) <= address 606 && (address < bfd_section_vma (section) 607 + bfd_section_size (section))); 608 }; 609 610 reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize; 611 for (reloc = 0; reloc < reloc_count; reloc++) 612 { 613 const char *name; 614 struct minimal_symbol *msym; 615 CORE_ADDR address; 616 const char *got_suffix = SYMBOL_GOT_PLT_SUFFIX; 617 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX); 618 619 name = bfd_asymbol_name (*relplt->relocation[reloc].sym_ptr_ptr); 620 address = relplt->relocation[reloc].address; 621 622 asection *msym_section; 623 624 /* Does the pointer reside in either the .got.plt or .plt 625 sections? */ 626 if (within_section (got_plt, address)) 627 msym_section = got_plt; 628 else if (within_section (plt, address)) 629 msym_section = plt; 630 else 631 continue; 632 633 /* We cannot check if NAME is a reference to 634 mst_text_gnu_ifunc/mst_data_gnu_ifunc as in OBJFILE the 635 symbol is undefined and the objfile having NAME defined may 636 not yet have been loaded. */ 637 638 string_buffer.assign (name); 639 string_buffer.append (got_suffix, got_suffix + got_suffix_len); 640 641 msym = record_minimal_symbol (reader, string_buffer, 642 true, address, mst_slot_got_plt, 643 msym_section, objfile); 644 if (msym) 645 SET_MSYMBOL_SIZE (msym, ptr_size); 646 } 647 } 648 649 /* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */ 650 651 static const struct objfile_key<htab, htab_deleter> 652 elf_objfile_gnu_ifunc_cache_data; 653 654 /* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */ 655 656 struct elf_gnu_ifunc_cache 657 { 658 /* This is always a function entry address, not a function descriptor. */ 659 CORE_ADDR addr; 660 661 char name[1]; 662 }; 663 664 /* htab_hash for elf_objfile_gnu_ifunc_cache_data. */ 665 666 static hashval_t 667 elf_gnu_ifunc_cache_hash (const void *a_voidp) 668 { 669 const struct elf_gnu_ifunc_cache *a 670 = (const struct elf_gnu_ifunc_cache *) a_voidp; 671 672 return htab_hash_string (a->name); 673 } 674 675 /* htab_eq for elf_objfile_gnu_ifunc_cache_data. */ 676 677 static int 678 elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp) 679 { 680 const struct elf_gnu_ifunc_cache *a 681 = (const struct elf_gnu_ifunc_cache *) a_voidp; 682 const struct elf_gnu_ifunc_cache *b 683 = (const struct elf_gnu_ifunc_cache *) b_voidp; 684 685 return strcmp (a->name, b->name) == 0; 686 } 687 688 /* Record the target function address of a STT_GNU_IFUNC function NAME is the 689 function entry address ADDR. Return 1 if NAME and ADDR are considered as 690 valid and therefore they were successfully recorded, return 0 otherwise. 691 692 Function does not expect a duplicate entry. Use 693 elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already 694 exists. */ 695 696 static int 697 elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr) 698 { 699 struct bound_minimal_symbol msym; 700 struct objfile *objfile; 701 htab_t htab; 702 struct elf_gnu_ifunc_cache entry_local, *entry_p; 703 void **slot; 704 705 msym = lookup_minimal_symbol_by_pc (addr); 706 if (msym.minsym == NULL) 707 return 0; 708 if (BMSYMBOL_VALUE_ADDRESS (msym) != addr) 709 return 0; 710 objfile = msym.objfile; 711 712 /* If .plt jumps back to .plt the symbol is still deferred for later 713 resolution and it has no use for GDB. */ 714 const char *target_name = msym.minsym->linkage_name (); 715 size_t len = strlen (target_name); 716 717 /* Note we check the symbol's name instead of checking whether the 718 symbol is in the .plt section because some systems have @plt 719 symbols in the .text section. */ 720 if (len > 4 && strcmp (target_name + len - 4, "@plt") == 0) 721 return 0; 722 723 htab = elf_objfile_gnu_ifunc_cache_data.get (objfile); 724 if (htab == NULL) 725 { 726 htab = htab_create_alloc (1, elf_gnu_ifunc_cache_hash, 727 elf_gnu_ifunc_cache_eq, 728 NULL, xcalloc, xfree); 729 elf_objfile_gnu_ifunc_cache_data.set (objfile, htab); 730 } 731 732 entry_local.addr = addr; 733 obstack_grow (&objfile->objfile_obstack, &entry_local, 734 offsetof (struct elf_gnu_ifunc_cache, name)); 735 obstack_grow_str0 (&objfile->objfile_obstack, name); 736 entry_p 737 = (struct elf_gnu_ifunc_cache *) obstack_finish (&objfile->objfile_obstack); 738 739 slot = htab_find_slot (htab, entry_p, INSERT); 740 if (*slot != NULL) 741 { 742 struct elf_gnu_ifunc_cache *entry_found_p 743 = (struct elf_gnu_ifunc_cache *) *slot; 744 struct gdbarch *gdbarch = objfile->arch (); 745 746 if (entry_found_p->addr != addr) 747 { 748 /* This case indicates buggy inferior program, the resolved address 749 should never change. */ 750 751 warning (_("gnu-indirect-function \"%s\" has changed its resolved " 752 "function_address from %s to %s"), 753 name, paddress (gdbarch, entry_found_p->addr), 754 paddress (gdbarch, addr)); 755 } 756 757 /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */ 758 } 759 *slot = entry_p; 760 761 return 1; 762 } 763 764 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC 765 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P 766 is not NULL) and the function returns 1. It returns 0 otherwise. 767 768 Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this 769 function. */ 770 771 static int 772 elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p) 773 { 774 for (objfile *objfile : current_program_space->objfiles ()) 775 { 776 htab_t htab; 777 struct elf_gnu_ifunc_cache *entry_p; 778 void **slot; 779 780 htab = elf_objfile_gnu_ifunc_cache_data.get (objfile); 781 if (htab == NULL) 782 continue; 783 784 entry_p = ((struct elf_gnu_ifunc_cache *) 785 alloca (sizeof (*entry_p) + strlen (name))); 786 strcpy (entry_p->name, name); 787 788 slot = htab_find_slot (htab, entry_p, NO_INSERT); 789 if (slot == NULL) 790 continue; 791 entry_p = (struct elf_gnu_ifunc_cache *) *slot; 792 gdb_assert (entry_p != NULL); 793 794 if (addr_p) 795 *addr_p = entry_p->addr; 796 return 1; 797 } 798 799 return 0; 800 } 801 802 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC 803 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P 804 is not NULL) and the function returns 1. It returns 0 otherwise. 805 806 Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. 807 elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to 808 prevent cache entries duplicates. */ 809 810 static int 811 elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p) 812 { 813 char *name_got_plt; 814 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX); 815 816 name_got_plt = (char *) alloca (strlen (name) + got_suffix_len + 1); 817 sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name); 818 819 for (objfile *objfile : current_program_space->objfiles ()) 820 { 821 bfd *obfd = objfile->obfd; 822 struct gdbarch *gdbarch = objfile->arch (); 823 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 824 size_t ptr_size = TYPE_LENGTH (ptr_type); 825 CORE_ADDR pointer_address, addr; 826 asection *plt; 827 gdb_byte *buf = (gdb_byte *) alloca (ptr_size); 828 struct bound_minimal_symbol msym; 829 830 msym = lookup_minimal_symbol (name_got_plt, NULL, objfile); 831 if (msym.minsym == NULL) 832 continue; 833 if (MSYMBOL_TYPE (msym.minsym) != mst_slot_got_plt) 834 continue; 835 pointer_address = BMSYMBOL_VALUE_ADDRESS (msym); 836 837 plt = bfd_get_section_by_name (obfd, ".plt"); 838 if (plt == NULL) 839 continue; 840 841 if (MSYMBOL_SIZE (msym.minsym) != ptr_size) 842 continue; 843 if (target_read_memory (pointer_address, buf, ptr_size) != 0) 844 continue; 845 addr = extract_typed_address (buf, ptr_type); 846 addr = gdbarch_convert_from_func_ptr_addr 847 (gdbarch, addr, current_inferior ()->top_target ()); 848 addr = gdbarch_addr_bits_remove (gdbarch, addr); 849 850 if (elf_gnu_ifunc_record_cache (name, addr)) 851 { 852 if (addr_p != NULL) 853 *addr_p = addr; 854 return 1; 855 } 856 } 857 858 return 0; 859 } 860 861 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC 862 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P 863 is not NULL) and the function returns true. It returns false otherwise. 864 865 Both the elf_objfile_gnu_ifunc_cache_data hash table and 866 SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */ 867 868 static bool 869 elf_gnu_ifunc_resolve_name (const char *name, CORE_ADDR *addr_p) 870 { 871 if (elf_gnu_ifunc_resolve_by_cache (name, addr_p)) 872 return true; 873 874 if (elf_gnu_ifunc_resolve_by_got (name, addr_p)) 875 return true; 876 877 return false; 878 } 879 880 /* Call STT_GNU_IFUNC - a function returning addresss of a real function to 881 call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned 882 is the entry point of the resolved STT_GNU_IFUNC target function to call. 883 */ 884 885 static CORE_ADDR 886 elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc) 887 { 888 const char *name_at_pc; 889 CORE_ADDR start_at_pc, address; 890 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func; 891 struct value *function, *address_val; 892 CORE_ADDR hwcap = 0; 893 struct value *hwcap_val; 894 895 /* Try first any non-intrusive methods without an inferior call. */ 896 897 if (find_pc_partial_function (pc, &name_at_pc, &start_at_pc, NULL) 898 && start_at_pc == pc) 899 { 900 if (elf_gnu_ifunc_resolve_name (name_at_pc, &address)) 901 return address; 902 } 903 else 904 name_at_pc = NULL; 905 906 function = allocate_value (func_func_type); 907 VALUE_LVAL (function) = lval_memory; 908 set_value_address (function, pc); 909 910 /* STT_GNU_IFUNC resolver functions usually receive the HWCAP vector as 911 parameter. FUNCTION is the function entry address. ADDRESS may be a 912 function descriptor. */ 913 914 target_auxv_search (current_inferior ()->top_target (), AT_HWCAP, &hwcap); 915 hwcap_val = value_from_longest (builtin_type (gdbarch) 916 ->builtin_unsigned_long, hwcap); 917 address_val = call_function_by_hand (function, NULL, hwcap_val); 918 address = value_as_address (address_val); 919 address = gdbarch_convert_from_func_ptr_addr 920 (gdbarch, address, current_inferior ()->top_target ()); 921 address = gdbarch_addr_bits_remove (gdbarch, address); 922 923 if (name_at_pc) 924 elf_gnu_ifunc_record_cache (name_at_pc, address); 925 926 return address; 927 } 928 929 /* Handle inferior hit of bp_gnu_ifunc_resolver, see its definition. */ 930 931 static void 932 elf_gnu_ifunc_resolver_stop (struct breakpoint *b) 933 { 934 struct breakpoint *b_return; 935 struct frame_info *prev_frame = get_prev_frame (get_current_frame ()); 936 struct frame_id prev_frame_id = get_stack_frame_id (prev_frame); 937 CORE_ADDR prev_pc = get_frame_pc (prev_frame); 938 int thread_id = inferior_thread ()->global_num; 939 940 gdb_assert (b->type == bp_gnu_ifunc_resolver); 941 942 for (b_return = b->related_breakpoint; b_return != b; 943 b_return = b_return->related_breakpoint) 944 { 945 gdb_assert (b_return->type == bp_gnu_ifunc_resolver_return); 946 gdb_assert (b_return->loc != NULL && b_return->loc->next == NULL); 947 gdb_assert (frame_id_p (b_return->frame_id)); 948 949 if (b_return->thread == thread_id 950 && b_return->loc->requested_address == prev_pc 951 && frame_id_eq (b_return->frame_id, prev_frame_id)) 952 break; 953 } 954 955 if (b_return == b) 956 { 957 /* No need to call find_pc_line for symbols resolving as this is only 958 a helper breakpointer never shown to the user. */ 959 960 symtab_and_line sal; 961 sal.pspace = current_inferior ()->pspace; 962 sal.pc = prev_pc; 963 sal.section = find_pc_overlay (sal.pc); 964 sal.explicit_pc = 1; 965 b_return 966 = set_momentary_breakpoint (get_frame_arch (prev_frame), sal, 967 prev_frame_id, 968 bp_gnu_ifunc_resolver_return).release (); 969 970 /* set_momentary_breakpoint invalidates PREV_FRAME. */ 971 prev_frame = NULL; 972 973 /* Add new b_return to the ring list b->related_breakpoint. */ 974 gdb_assert (b_return->related_breakpoint == b_return); 975 b_return->related_breakpoint = b->related_breakpoint; 976 b->related_breakpoint = b_return; 977 } 978 } 979 980 /* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition. */ 981 982 static void 983 elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b) 984 { 985 thread_info *thread = inferior_thread (); 986 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); 987 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func; 988 struct type *value_type = TYPE_TARGET_TYPE (func_func_type); 989 struct regcache *regcache = get_thread_regcache (thread); 990 struct value *func_func; 991 struct value *value; 992 CORE_ADDR resolved_address, resolved_pc; 993 994 gdb_assert (b->type == bp_gnu_ifunc_resolver_return); 995 996 while (b->related_breakpoint != b) 997 { 998 struct breakpoint *b_next = b->related_breakpoint; 999 1000 switch (b->type) 1001 { 1002 case bp_gnu_ifunc_resolver: 1003 break; 1004 case bp_gnu_ifunc_resolver_return: 1005 delete_breakpoint (b); 1006 break; 1007 default: 1008 internal_error (__FILE__, __LINE__, 1009 _("handle_inferior_event: Invalid " 1010 "gnu-indirect-function breakpoint type %d"), 1011 (int) b->type); 1012 } 1013 b = b_next; 1014 } 1015 gdb_assert (b->type == bp_gnu_ifunc_resolver); 1016 gdb_assert (b->loc->next == NULL); 1017 1018 func_func = allocate_value (func_func_type); 1019 VALUE_LVAL (func_func) = lval_memory; 1020 set_value_address (func_func, b->loc->related_address); 1021 1022 value = allocate_value (value_type); 1023 gdbarch_return_value (gdbarch, func_func, value_type, regcache, 1024 value_contents_raw (value), NULL); 1025 resolved_address = value_as_address (value); 1026 resolved_pc = gdbarch_convert_from_func_ptr_addr 1027 (gdbarch, resolved_address, current_inferior ()->top_target ()); 1028 resolved_pc = gdbarch_addr_bits_remove (gdbarch, resolved_pc); 1029 1030 gdb_assert (current_program_space == b->pspace || b->pspace == NULL); 1031 elf_gnu_ifunc_record_cache (event_location_to_string (b->location.get ()), 1032 resolved_pc); 1033 1034 b->type = bp_breakpoint; 1035 update_breakpoint_locations (b, current_program_space, 1036 find_function_start_sal (resolved_pc, NULL, true), 1037 {}); 1038 } 1039 1040 /* A helper function for elf_symfile_read that reads the minimal 1041 symbols. */ 1042 1043 static void 1044 elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags, 1045 const struct elfinfo *ei) 1046 { 1047 bfd *synth_abfd, *abfd = objfile->obfd; 1048 long symcount = 0, dynsymcount = 0, synthcount, storage_needed; 1049 asymbol **symbol_table = NULL, **dyn_symbol_table = NULL; 1050 asymbol *synthsyms; 1051 1052 if (symtab_create_debug) 1053 { 1054 fprintf_unfiltered (gdb_stdlog, 1055 "Reading minimal symbols of objfile %s ...\n", 1056 objfile_name (objfile)); 1057 } 1058 1059 /* If we already have minsyms, then we can skip some work here. 1060 However, if there were stabs or mdebug sections, we go ahead and 1061 redo all the work anyway, because the psym readers for those 1062 kinds of debuginfo need extra information found here. This can 1063 go away once all types of symbols are in the per-BFD object. */ 1064 if (objfile->per_bfd->minsyms_read 1065 && ei->stabsect == NULL 1066 && ei->mdebugsect == NULL 1067 && ei->ctfsect == NULL) 1068 { 1069 if (symtab_create_debug) 1070 fprintf_unfiltered (gdb_stdlog, 1071 "... minimal symbols previously read\n"); 1072 return; 1073 } 1074 1075 minimal_symbol_reader reader (objfile); 1076 1077 /* Process the normal ELF symbol table first. */ 1078 1079 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd); 1080 if (storage_needed < 0) 1081 error (_("Can't read symbols from %s: %s"), 1082 bfd_get_filename (objfile->obfd), 1083 bfd_errmsg (bfd_get_error ())); 1084 1085 if (storage_needed > 0) 1086 { 1087 /* Memory gets permanently referenced from ABFD after 1088 bfd_canonicalize_symtab so it must not get freed before ABFD gets. */ 1089 1090 symbol_table = (asymbol **) bfd_alloc (abfd, storage_needed); 1091 symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table); 1092 1093 if (symcount < 0) 1094 error (_("Can't read symbols from %s: %s"), 1095 bfd_get_filename (objfile->obfd), 1096 bfd_errmsg (bfd_get_error ())); 1097 1098 elf_symtab_read (reader, objfile, ST_REGULAR, symcount, symbol_table, 1099 false); 1100 } 1101 1102 /* Add the dynamic symbols. */ 1103 1104 storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd); 1105 1106 if (storage_needed > 0) 1107 { 1108 /* Memory gets permanently referenced from ABFD after 1109 bfd_get_synthetic_symtab so it must not get freed before ABFD gets. 1110 It happens only in the case when elf_slurp_reloc_table sees 1111 asection->relocation NULL. Determining which section is asection is 1112 done by _bfd_elf_get_synthetic_symtab which is all a bfd 1113 implementation detail, though. */ 1114 1115 dyn_symbol_table = (asymbol **) bfd_alloc (abfd, storage_needed); 1116 dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd, 1117 dyn_symbol_table); 1118 1119 if (dynsymcount < 0) 1120 error (_("Can't read symbols from %s: %s"), 1121 bfd_get_filename (objfile->obfd), 1122 bfd_errmsg (bfd_get_error ())); 1123 1124 elf_symtab_read (reader, objfile, ST_DYNAMIC, dynsymcount, 1125 dyn_symbol_table, false); 1126 1127 elf_rel_plt_read (reader, objfile, dyn_symbol_table); 1128 } 1129 1130 /* Contrary to binutils --strip-debug/--only-keep-debug the strip command from 1131 elfutils (eu-strip) moves even the .symtab section into the .debug file. 1132 1133 bfd_get_synthetic_symtab on ppc64 for each function descriptor ELF symbol 1134 'name' creates a new BSF_SYNTHETIC ELF symbol '.name' with its code 1135 address. But with eu-strip files bfd_get_synthetic_symtab would fail to 1136 read the code address from .opd while it reads the .symtab section from 1137 a separate debug info file as the .opd section is SHT_NOBITS there. 1138 1139 With SYNTH_ABFD the .opd section will be read from the original 1140 backlinked binary where it is valid. */ 1141 1142 if (objfile->separate_debug_objfile_backlink) 1143 synth_abfd = objfile->separate_debug_objfile_backlink->obfd; 1144 else 1145 synth_abfd = abfd; 1146 1147 /* Add synthetic symbols - for instance, names for any PLT entries. */ 1148 1149 synthcount = bfd_get_synthetic_symtab (synth_abfd, symcount, symbol_table, 1150 dynsymcount, dyn_symbol_table, 1151 &synthsyms); 1152 if (synthcount > 0) 1153 { 1154 long i; 1155 1156 std::unique_ptr<asymbol *[]> 1157 synth_symbol_table (new asymbol *[synthcount]); 1158 for (i = 0; i < synthcount; i++) 1159 synth_symbol_table[i] = synthsyms + i; 1160 elf_symtab_read (reader, objfile, ST_SYNTHETIC, synthcount, 1161 synth_symbol_table.get (), true); 1162 1163 xfree (synthsyms); 1164 synthsyms = NULL; 1165 } 1166 1167 /* Install any minimal symbols that have been collected as the current 1168 minimal symbols for this objfile. The debug readers below this point 1169 should not generate new minimal symbols; if they do it's their 1170 responsibility to install them. "mdebug" appears to be the only one 1171 which will do this. */ 1172 1173 reader.install (); 1174 1175 if (symtab_create_debug) 1176 fprintf_unfiltered (gdb_stdlog, "Done reading minimal symbols.\n"); 1177 } 1178 1179 /* Scan and build partial symbols for a symbol file. 1180 We have been initialized by a call to elf_symfile_init, which 1181 currently does nothing. 1182 1183 This function only does the minimum work necessary for letting the 1184 user "name" things symbolically; it does not read the entire symtab. 1185 Instead, it reads the external and static symbols and puts them in partial 1186 symbol tables. When more extensive information is requested of a 1187 file, the corresponding partial symbol table is mutated into a full 1188 fledged symbol table by going back and reading the symbols 1189 for real. 1190 1191 We look for sections with specific names, to tell us what debug 1192 format to look for: FIXME!!! 1193 1194 elfstab_build_psymtabs() handles STABS symbols; 1195 mdebug_build_psymtabs() handles ECOFF debugging information. 1196 1197 Note that ELF files have a "minimal" symbol table, which looks a lot 1198 like a COFF symbol table, but has only the minimal information necessary 1199 for linking. We process this also, and use the information to 1200 build gdb's minimal symbol table. This gives us some minimal debugging 1201 capability even for files compiled without -g. */ 1202 1203 static void 1204 elf_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) 1205 { 1206 bfd *abfd = objfile->obfd; 1207 struct elfinfo ei; 1208 bool has_dwarf2 = true; 1209 1210 memset ((char *) &ei, 0, sizeof (ei)); 1211 if (!(objfile->flags & OBJF_READNEVER)) 1212 { 1213 for (asection *sect : gdb_bfd_sections (abfd)) 1214 elf_locate_sections (sect, &ei); 1215 } 1216 1217 elf_read_minimal_symbols (objfile, symfile_flags, &ei); 1218 1219 /* ELF debugging information is inserted into the psymtab in the 1220 order of least informative first - most informative last. Since 1221 the psymtab table is searched `most recent insertion first' this 1222 increases the probability that more detailed debug information 1223 for a section is found. 1224 1225 For instance, an object file might contain both .mdebug (XCOFF) 1226 and .debug_info (DWARF2) sections then .mdebug is inserted first 1227 (searched last) and DWARF2 is inserted last (searched first). If 1228 we don't do this then the XCOFF info is found first - for code in 1229 an included file XCOFF info is useless. */ 1230 1231 if (ei.mdebugsect) 1232 { 1233 const struct ecoff_debug_swap *swap; 1234 1235 /* .mdebug section, presumably holding ECOFF debugging 1236 information. */ 1237 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 1238 if (swap) 1239 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect); 1240 } 1241 if (ei.stabsect) 1242 { 1243 asection *str_sect; 1244 1245 /* Stab sections have an associated string table that looks like 1246 a separate section. */ 1247 str_sect = bfd_get_section_by_name (abfd, ".stabstr"); 1248 1249 /* FIXME should probably warn about a stab section without a stabstr. */ 1250 if (str_sect) 1251 elfstab_build_psymtabs (objfile, 1252 ei.stabsect, 1253 str_sect->filepos, 1254 bfd_section_size (str_sect)); 1255 } 1256 1257 if (dwarf2_has_info (objfile, NULL, true)) 1258 dwarf2_initialize_objfile (objfile); 1259 /* If the file has its own symbol tables it has no separate debug 1260 info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to 1261 SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with 1262 `.note.gnu.build-id'. 1263 1264 .gnu_debugdata is !objfile::has_partial_symbols because it contains only 1265 .symtab, not .debug_* section. But if we already added .gnu_debugdata as 1266 an objfile via find_separate_debug_file_in_section there was no separate 1267 debug info available. Therefore do not attempt to search for another one, 1268 objfile->separate_debug_objfile->separate_debug_objfile GDB guarantees to 1269 be NULL and we would possibly violate it. */ 1270 1271 else if (!objfile->has_partial_symbols () 1272 && objfile->separate_debug_objfile == NULL 1273 && objfile->separate_debug_objfile_backlink == NULL) 1274 { 1275 std::string debugfile = find_separate_debug_file_by_buildid (objfile); 1276 1277 if (debugfile.empty ()) 1278 debugfile = find_separate_debug_file_by_debuglink (objfile); 1279 1280 if (!debugfile.empty ()) 1281 { 1282 gdb_bfd_ref_ptr debug_bfd (symfile_bfd_open (debugfile.c_str ())); 1283 1284 symbol_file_add_separate (debug_bfd.get (), debugfile.c_str (), 1285 symfile_flags, objfile); 1286 } 1287 else 1288 { 1289 has_dwarf2 = false; 1290 const struct bfd_build_id *build_id = build_id_bfd_get (objfile->obfd); 1291 1292 if (build_id != nullptr) 1293 { 1294 gdb::unique_xmalloc_ptr<char> symfile_path; 1295 scoped_fd fd (debuginfod_debuginfo_query (build_id->data, 1296 build_id->size, 1297 objfile->original_name, 1298 &symfile_path)); 1299 1300 if (fd.get () >= 0) 1301 { 1302 /* File successfully retrieved from server. */ 1303 gdb_bfd_ref_ptr debug_bfd (symfile_bfd_open (symfile_path.get ())); 1304 1305 if (debug_bfd == nullptr) 1306 warning (_("File \"%s\" from debuginfod cannot be opened as bfd"), 1307 objfile->original_name); 1308 else if (build_id_verify (debug_bfd.get (), build_id->size, build_id->data)) 1309 { 1310 symbol_file_add_separate (debug_bfd.get (), symfile_path.get (), 1311 symfile_flags, objfile); 1312 has_dwarf2 = true; 1313 } 1314 } 1315 } 1316 } 1317 } 1318 1319 /* Read the CTF section only if there is no DWARF info. */ 1320 if (!has_dwarf2 && ei.ctfsect) 1321 { 1322 elfctf_build_psymtabs (objfile); 1323 } 1324 } 1325 1326 /* Initialize anything that needs initializing when a completely new symbol 1327 file is specified (not just adding some symbols from another file, e.g. a 1328 shared library). */ 1329 1330 static void 1331 elf_new_init (struct objfile *ignore) 1332 { 1333 } 1334 1335 /* Perform any local cleanups required when we are done with a particular 1336 objfile. I.E, we are in the process of discarding all symbol information 1337 for an objfile, freeing up all memory held for it, and unlinking the 1338 objfile struct from the global list of known objfiles. */ 1339 1340 static void 1341 elf_symfile_finish (struct objfile *objfile) 1342 { 1343 } 1344 1345 /* ELF specific initialization routine for reading symbols. */ 1346 1347 static void 1348 elf_symfile_init (struct objfile *objfile) 1349 { 1350 /* ELF objects may be reordered, so set OBJF_REORDERED. If we 1351 find this causes a significant slowdown in gdb then we could 1352 set it in the debug symbol readers only when necessary. */ 1353 objfile->flags |= OBJF_REORDERED; 1354 } 1355 1356 /* Implementation of `sym_get_probes', as documented in symfile.h. */ 1357 1358 static const elfread_data & 1359 elf_get_probes (struct objfile *objfile) 1360 { 1361 elfread_data *probes_per_bfd = probe_key.get (objfile->obfd); 1362 1363 if (probes_per_bfd == NULL) 1364 { 1365 probes_per_bfd = probe_key.emplace (objfile->obfd); 1366 1367 /* Here we try to gather information about all types of probes from the 1368 objfile. */ 1369 for (const static_probe_ops *ops : all_static_probe_ops) 1370 ops->get_probes (probes_per_bfd, objfile); 1371 } 1372 1373 return *probes_per_bfd; 1374 } 1375 1376 1377 1378 /* Implementation `sym_probe_fns', as documented in symfile.h. */ 1379 1380 static const struct sym_probe_fns elf_probe_fns = 1381 { 1382 elf_get_probes, /* sym_get_probes */ 1383 }; 1384 1385 /* Register that we are able to handle ELF object file formats. */ 1386 1387 static const struct sym_fns elf_sym_fns = 1388 { 1389 elf_new_init, /* init anything gbl to entire symtab */ 1390 elf_symfile_init, /* read initial info, setup for sym_read() */ 1391 elf_symfile_read, /* read a symbol file into symtab */ 1392 elf_symfile_finish, /* finished with file, cleanup */ 1393 default_symfile_offsets, /* Translate ext. to int. relocation */ 1394 elf_symfile_segments, /* Get segment information from a file. */ 1395 NULL, 1396 default_symfile_relocate, /* Relocate a debug section. */ 1397 &elf_probe_fns, /* sym_probe_fns */ 1398 }; 1399 1400 /* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */ 1401 1402 static const struct gnu_ifunc_fns elf_gnu_ifunc_fns = 1403 { 1404 elf_gnu_ifunc_resolve_addr, 1405 elf_gnu_ifunc_resolve_name, 1406 elf_gnu_ifunc_resolver_stop, 1407 elf_gnu_ifunc_resolver_return_stop 1408 }; 1409 1410 void _initialize_elfread (); 1411 void 1412 _initialize_elfread () 1413 { 1414 add_symtab_fns (bfd_target_elf_flavour, &elf_sym_fns); 1415 1416 gnu_ifunc_fns_p = &elf_gnu_ifunc_fns; 1417 } 1418