1 /* Read ELF (Executable and Linking Format) object files for GDB. 2 3 Copyright (C) 1991-2013 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 "gdb_string.h" 25 #include "elf-bfd.h" 26 #include "elf/common.h" 27 #include "elf/internal.h" 28 #include "elf/mips.h" 29 #include "symtab.h" 30 #include "symfile.h" 31 #include "objfiles.h" 32 #include "buildsym.h" 33 #include "stabsread.h" 34 #include "gdb-stabs.h" 35 #include "complaints.h" 36 #include "demangle.h" 37 #include "psympriv.h" 38 #include "filenames.h" 39 #include "probe.h" 40 #include "arch-utils.h" 41 #include "gdbtypes.h" 42 #include "value.h" 43 #include "infcall.h" 44 #include "gdbthread.h" 45 #include "regcache.h" 46 #include "bcache.h" 47 #include "gdb_bfd.h" 48 49 extern void _initialize_elfread (void); 50 51 /* Forward declarations. */ 52 static const struct sym_fns elf_sym_fns_gdb_index; 53 static const struct sym_fns elf_sym_fns_lazy_psyms; 54 55 /* The struct elfinfo is available only during ELF symbol table and 56 psymtab reading. It is destroyed at the completion of psymtab-reading. 57 It's local to elf_symfile_read. */ 58 59 struct elfinfo 60 { 61 asection *stabsect; /* Section pointer for .stab section */ 62 asection *stabindexsect; /* Section pointer for .stab.index section */ 63 asection *mdebugsect; /* Section pointer for .mdebug section */ 64 }; 65 66 /* Per-objfile data for probe info. */ 67 68 static const struct objfile_data *probe_key = NULL; 69 70 static void free_elfinfo (void *); 71 72 /* Minimal symbols located at the GOT entries for .plt - that is the real 73 pointer where the given entry will jump to. It gets updated by the real 74 function address during lazy ld.so resolving in the inferior. These 75 minimal symbols are indexed for <tab>-completion. */ 76 77 #define SYMBOL_GOT_PLT_SUFFIX "@got.plt" 78 79 /* Locate the segments in ABFD. */ 80 81 static struct symfile_segment_data * 82 elf_symfile_segments (bfd *abfd) 83 { 84 Elf_Internal_Phdr *phdrs, **segments; 85 long phdrs_size; 86 int num_phdrs, num_segments, num_sections, i; 87 asection *sect; 88 struct symfile_segment_data *data; 89 90 phdrs_size = bfd_get_elf_phdr_upper_bound (abfd); 91 if (phdrs_size == -1) 92 return NULL; 93 94 phdrs = alloca (phdrs_size); 95 num_phdrs = bfd_get_elf_phdrs (abfd, phdrs); 96 if (num_phdrs == -1) 97 return NULL; 98 99 num_segments = 0; 100 segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs); 101 for (i = 0; i < num_phdrs; i++) 102 if (phdrs[i].p_type == PT_LOAD) 103 segments[num_segments++] = &phdrs[i]; 104 105 if (num_segments == 0) 106 return NULL; 107 108 data = XZALLOC (struct symfile_segment_data); 109 data->num_segments = num_segments; 110 data->segment_bases = XCALLOC (num_segments, CORE_ADDR); 111 data->segment_sizes = XCALLOC (num_segments, CORE_ADDR); 112 113 for (i = 0; i < num_segments; i++) 114 { 115 data->segment_bases[i] = segments[i]->p_vaddr; 116 data->segment_sizes[i] = segments[i]->p_memsz; 117 } 118 119 num_sections = bfd_count_sections (abfd); 120 data->segment_info = XCALLOC (num_sections, int); 121 122 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) 123 { 124 int j; 125 CORE_ADDR vma; 126 127 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) 128 continue; 129 130 vma = bfd_get_section_vma (abfd, sect); 131 132 for (j = 0; j < num_segments; j++) 133 if (segments[j]->p_memsz > 0 134 && vma >= segments[j]->p_vaddr 135 && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz) 136 { 137 data->segment_info[i] = j + 1; 138 break; 139 } 140 141 /* We should have found a segment for every non-empty section. 142 If we haven't, we will not relocate this section by any 143 offsets we apply to the segments. As an exception, do not 144 warn about SHT_NOBITS sections; in normal ELF execution 145 environments, SHT_NOBITS means zero-initialized and belongs 146 in a segment, but in no-OS environments some tools (e.g. ARM 147 RealView) use SHT_NOBITS for uninitialized data. Since it is 148 uninitialized, it doesn't need a program header. Such 149 binaries are not relocatable. */ 150 if (bfd_get_section_size (sect) > 0 && j == num_segments 151 && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0) 152 warning (_("Loadable section \"%s\" outside of ELF segments"), 153 bfd_section_name (abfd, sect)); 154 } 155 156 return data; 157 } 158 159 /* We are called once per section from elf_symfile_read. We 160 need to examine each section we are passed, check to see 161 if it is something we are interested in processing, and 162 if so, stash away some access information for the section. 163 164 For now we recognize the dwarf debug information sections and 165 line number sections from matching their section names. The 166 ELF definition is no real help here since it has no direct 167 knowledge of DWARF (by design, so any debugging format can be 168 used). 169 170 We also recognize the ".stab" sections used by the Sun compilers 171 released with Solaris 2. 172 173 FIXME: The section names should not be hardwired strings (what 174 should they be? I don't think most object file formats have enough 175 section flags to specify what kind of debug section it is. 176 -kingdon). */ 177 178 static void 179 elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip) 180 { 181 struct elfinfo *ei; 182 183 ei = (struct elfinfo *) eip; 184 if (strcmp (sectp->name, ".stab") == 0) 185 { 186 ei->stabsect = sectp; 187 } 188 else if (strcmp (sectp->name, ".stab.index") == 0) 189 { 190 ei->stabindexsect = sectp; 191 } 192 else if (strcmp (sectp->name, ".mdebug") == 0) 193 { 194 ei->mdebugsect = sectp; 195 } 196 } 197 198 static struct minimal_symbol * 199 record_minimal_symbol (const char *name, int name_len, int copy_name, 200 CORE_ADDR address, 201 enum minimal_symbol_type ms_type, 202 asection *bfd_section, struct objfile *objfile) 203 { 204 struct gdbarch *gdbarch = get_objfile_arch (objfile); 205 206 if (ms_type == mst_text || ms_type == mst_file_text 207 || ms_type == mst_text_gnu_ifunc) 208 address = gdbarch_addr_bits_remove (gdbarch, address); 209 210 return prim_record_minimal_symbol_full (name, name_len, copy_name, address, 211 ms_type, bfd_section->index, 212 bfd_section, objfile); 213 } 214 215 /* Read the symbol table of an ELF file. 216 217 Given an objfile, a symbol table, and a flag indicating whether the 218 symbol table contains regular, dynamic, or synthetic symbols, add all 219 the global function and data symbols to the minimal symbol table. 220 221 In stabs-in-ELF, as implemented by Sun, there are some local symbols 222 defined in the ELF symbol table, which can be used to locate 223 the beginnings of sections from each ".o" file that was linked to 224 form the executable objfile. We gather any such info and record it 225 in data structures hung off the objfile's private data. */ 226 227 #define ST_REGULAR 0 228 #define ST_DYNAMIC 1 229 #define ST_SYNTHETIC 2 230 231 static void 232 elf_symtab_read (struct objfile *objfile, int type, 233 long number_of_symbols, asymbol **symbol_table, 234 int copy_names) 235 { 236 struct gdbarch *gdbarch = get_objfile_arch (objfile); 237 asymbol *sym; 238 long i; 239 CORE_ADDR symaddr; 240 CORE_ADDR offset; 241 enum minimal_symbol_type ms_type; 242 /* If sectinfo is nonNULL, it contains section info that should end up 243 filed in the objfile. */ 244 struct stab_section_info *sectinfo = NULL; 245 /* If filesym is nonzero, it points to a file symbol, but we haven't 246 seen any section info for it yet. */ 247 asymbol *filesym = 0; 248 /* Name of filesym. This is either a constant string or is saved on 249 the objfile's filename cache. */ 250 const char *filesymname = ""; 251 struct dbx_symfile_info *dbx = DBX_SYMFILE_INFO (objfile); 252 int stripped = (bfd_get_symcount (objfile->obfd) == 0); 253 254 for (i = 0; i < number_of_symbols; i++) 255 { 256 sym = symbol_table[i]; 257 if (sym->name == NULL || *sym->name == '\0') 258 { 259 /* Skip names that don't exist (shouldn't happen), or names 260 that are null strings (may happen). */ 261 continue; 262 } 263 264 /* Skip "special" symbols, e.g. ARM mapping symbols. These are 265 symbols which do not correspond to objects in the symbol table, 266 but have some other target-specific meaning. */ 267 if (bfd_is_target_special_symbol (objfile->obfd, sym)) 268 { 269 if (gdbarch_record_special_symbol_p (gdbarch)) 270 gdbarch_record_special_symbol (gdbarch, objfile, sym); 271 continue; 272 } 273 274 offset = ANOFFSET (objfile->section_offsets, sym->section->index); 275 if (type == ST_DYNAMIC 276 && sym->section == bfd_und_section_ptr 277 && (sym->flags & BSF_FUNCTION)) 278 { 279 struct minimal_symbol *msym; 280 bfd *abfd = objfile->obfd; 281 asection *sect; 282 283 /* Symbol is a reference to a function defined in 284 a shared library. 285 If its value is non zero then it is usually the address 286 of the corresponding entry in the procedure linkage table, 287 plus the desired section offset. 288 If its value is zero then the dynamic linker has to resolve 289 the symbol. We are unable to find any meaningful address 290 for this symbol in the executable file, so we skip it. */ 291 symaddr = sym->value; 292 if (symaddr == 0) 293 continue; 294 295 /* sym->section is the undefined section. However, we want to 296 record the section where the PLT stub resides with the 297 minimal symbol. Search the section table for the one that 298 covers the stub's address. */ 299 for (sect = abfd->sections; sect != NULL; sect = sect->next) 300 { 301 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) 302 continue; 303 304 if (symaddr >= bfd_get_section_vma (abfd, sect) 305 && symaddr < bfd_get_section_vma (abfd, sect) 306 + bfd_get_section_size (sect)) 307 break; 308 } 309 if (!sect) 310 continue; 311 312 /* On ia64-hpux, we have discovered that the system linker 313 adds undefined symbols with nonzero addresses that cannot 314 be right (their address points inside the code of another 315 function in the .text section). This creates problems 316 when trying to determine which symbol corresponds to 317 a given address. 318 319 We try to detect those buggy symbols by checking which 320 section we think they correspond to. Normally, PLT symbols 321 are stored inside their own section, and the typical name 322 for that section is ".plt". So, if there is a ".plt" 323 section, and yet the section name of our symbol does not 324 start with ".plt", we ignore that symbol. */ 325 if (strncmp (sect->name, ".plt", 4) != 0 326 && bfd_get_section_by_name (abfd, ".plt") != NULL) 327 continue; 328 329 symaddr += ANOFFSET (objfile->section_offsets, sect->index); 330 331 msym = record_minimal_symbol 332 (sym->name, strlen (sym->name), copy_names, 333 symaddr, mst_solib_trampoline, sect, objfile); 334 if (msym != NULL) 335 msym->filename = filesymname; 336 continue; 337 } 338 339 /* If it is a nonstripped executable, do not enter dynamic 340 symbols, as the dynamic symbol table is usually a subset 341 of the main symbol table. */ 342 if (type == ST_DYNAMIC && !stripped) 343 continue; 344 if (sym->flags & BSF_FILE) 345 { 346 /* STT_FILE debugging symbol that helps stabs-in-elf debugging. 347 Chain any old one onto the objfile; remember new sym. */ 348 if (sectinfo != NULL) 349 { 350 sectinfo->next = dbx->stab_section_info; 351 dbx->stab_section_info = sectinfo; 352 sectinfo = NULL; 353 } 354 filesym = sym; 355 filesymname = bcache (filesym->name, strlen (filesym->name) + 1, 356 objfile->per_bfd->filename_cache); 357 } 358 else if (sym->flags & BSF_SECTION_SYM) 359 continue; 360 else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK 361 | BSF_GNU_UNIQUE)) 362 { 363 struct minimal_symbol *msym; 364 365 /* Select global/local/weak symbols. Note that bfd puts abs 366 symbols in their own section, so all symbols we are 367 interested in will have a section. */ 368 /* Bfd symbols are section relative. */ 369 symaddr = sym->value + sym->section->vma; 370 /* Relocate all non-absolute and non-TLS symbols by the 371 section offset. */ 372 if (sym->section != bfd_abs_section_ptr 373 && !(sym->section->flags & SEC_THREAD_LOCAL)) 374 { 375 symaddr += offset; 376 } 377 /* For non-absolute symbols, use the type of the section 378 they are relative to, to intuit text/data. Bfd provides 379 no way of figuring this out for absolute symbols. */ 380 if (sym->section == bfd_abs_section_ptr) 381 { 382 /* This is a hack to get the minimal symbol type 383 right for Irix 5, which has absolute addresses 384 with special section indices for dynamic symbols. 385 386 NOTE: uweigand-20071112: Synthetic symbols do not 387 have an ELF-private part, so do not touch those. */ 388 unsigned int shndx = type == ST_SYNTHETIC ? 0 : 389 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx; 390 391 switch (shndx) 392 { 393 case SHN_MIPS_TEXT: 394 ms_type = mst_text; 395 break; 396 case SHN_MIPS_DATA: 397 ms_type = mst_data; 398 break; 399 case SHN_MIPS_ACOMMON: 400 ms_type = mst_bss; 401 break; 402 default: 403 ms_type = mst_abs; 404 } 405 406 /* If it is an Irix dynamic symbol, skip section name 407 symbols, relocate all others by section offset. */ 408 if (ms_type != mst_abs) 409 { 410 if (sym->name[0] == '.') 411 continue; 412 symaddr += offset; 413 } 414 } 415 else if (sym->section->flags & SEC_CODE) 416 { 417 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) 418 { 419 if (sym->flags & BSF_GNU_INDIRECT_FUNCTION) 420 ms_type = mst_text_gnu_ifunc; 421 else 422 ms_type = mst_text; 423 } 424 /* The BSF_SYNTHETIC check is there to omit ppc64 function 425 descriptors mistaken for static functions starting with 'L'. 426 */ 427 else if ((sym->name[0] == '.' && sym->name[1] == 'L' 428 && (sym->flags & BSF_SYNTHETIC) == 0) 429 || ((sym->flags & BSF_LOCAL) 430 && sym->name[0] == '$' 431 && sym->name[1] == 'L')) 432 /* Looks like a compiler-generated label. Skip 433 it. The assembler should be skipping these (to 434 keep executables small), but apparently with 435 gcc on the (deleted) delta m88k SVR4, it loses. 436 So to have us check too should be harmless (but 437 I encourage people to fix this in the assembler 438 instead of adding checks here). */ 439 continue; 440 else 441 { 442 ms_type = mst_file_text; 443 } 444 } 445 else if (sym->section->flags & SEC_ALLOC) 446 { 447 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) 448 { 449 if (sym->section->flags & SEC_LOAD) 450 { 451 ms_type = mst_data; 452 } 453 else 454 { 455 ms_type = mst_bss; 456 } 457 } 458 else if (sym->flags & BSF_LOCAL) 459 { 460 /* Named Local variable in a Data section. 461 Check its name for stabs-in-elf. */ 462 int special_local_sect; 463 464 if (strcmp ("Bbss.bss", sym->name) == 0) 465 special_local_sect = SECT_OFF_BSS (objfile); 466 else if (strcmp ("Ddata.data", sym->name) == 0) 467 special_local_sect = SECT_OFF_DATA (objfile); 468 else if (strcmp ("Drodata.rodata", sym->name) == 0) 469 special_local_sect = SECT_OFF_RODATA (objfile); 470 else 471 special_local_sect = -1; 472 if (special_local_sect >= 0) 473 { 474 /* Found a special local symbol. Allocate a 475 sectinfo, if needed, and fill it in. */ 476 if (sectinfo == NULL) 477 { 478 int max_index; 479 size_t size; 480 481 max_index = SECT_OFF_BSS (objfile); 482 if (objfile->sect_index_data > max_index) 483 max_index = objfile->sect_index_data; 484 if (objfile->sect_index_rodata > max_index) 485 max_index = objfile->sect_index_rodata; 486 487 /* max_index is the largest index we'll 488 use into this array, so we must 489 allocate max_index+1 elements for it. 490 However, 'struct stab_section_info' 491 already includes one element, so we 492 need to allocate max_index aadditional 493 elements. */ 494 size = (sizeof (struct stab_section_info) 495 + (sizeof (CORE_ADDR) * max_index)); 496 sectinfo = (struct stab_section_info *) 497 xmalloc (size); 498 memset (sectinfo, 0, size); 499 sectinfo->num_sections = max_index; 500 if (filesym == NULL) 501 { 502 complaint (&symfile_complaints, 503 _("elf/stab section information %s " 504 "without a preceding file symbol"), 505 sym->name); 506 } 507 else 508 { 509 sectinfo->filename = 510 (char *) filesym->name; 511 } 512 } 513 if (sectinfo->sections[special_local_sect] != 0) 514 complaint (&symfile_complaints, 515 _("duplicated elf/stab section " 516 "information for %s"), 517 sectinfo->filename); 518 /* BFD symbols are section relative. */ 519 symaddr = sym->value + sym->section->vma; 520 /* Relocate non-absolute symbols by the 521 section offset. */ 522 if (sym->section != bfd_abs_section_ptr) 523 symaddr += offset; 524 sectinfo->sections[special_local_sect] = symaddr; 525 /* The special local symbols don't go in the 526 minimal symbol table, so ignore this one. */ 527 continue; 528 } 529 /* Not a special stabs-in-elf symbol, do regular 530 symbol processing. */ 531 if (sym->section->flags & SEC_LOAD) 532 { 533 ms_type = mst_file_data; 534 } 535 else 536 { 537 ms_type = mst_file_bss; 538 } 539 } 540 else 541 { 542 ms_type = mst_unknown; 543 } 544 } 545 else 546 { 547 /* FIXME: Solaris2 shared libraries include lots of 548 odd "absolute" and "undefined" symbols, that play 549 hob with actions like finding what function the PC 550 is in. Ignore them if they aren't text, data, or bss. */ 551 /* ms_type = mst_unknown; */ 552 continue; /* Skip this symbol. */ 553 } 554 msym = record_minimal_symbol 555 (sym->name, strlen (sym->name), copy_names, symaddr, 556 ms_type, sym->section, objfile); 557 558 if (msym) 559 { 560 /* NOTE: uweigand-20071112: A synthetic symbol does not have an 561 ELF-private part. */ 562 if (type != ST_SYNTHETIC) 563 { 564 /* Pass symbol size field in via BFD. FIXME!!! */ 565 elf_symbol_type *elf_sym = (elf_symbol_type *) sym; 566 SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size); 567 } 568 569 msym->filename = filesymname; 570 gdbarch_elf_make_msymbol_special (gdbarch, sym, msym); 571 } 572 573 /* For @plt symbols, also record a trampoline to the 574 destination symbol. The @plt symbol will be used in 575 disassembly, and the trampoline will be used when we are 576 trying to find the target. */ 577 if (msym && ms_type == mst_text && type == ST_SYNTHETIC) 578 { 579 int len = strlen (sym->name); 580 581 if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0) 582 { 583 struct minimal_symbol *mtramp; 584 585 mtramp = record_minimal_symbol (sym->name, len - 4, 1, 586 symaddr, 587 mst_solib_trampoline, 588 sym->section, objfile); 589 if (mtramp) 590 { 591 SET_MSYMBOL_SIZE (mtramp, MSYMBOL_SIZE (msym)); 592 mtramp->created_by_gdb = 1; 593 mtramp->filename = filesymname; 594 gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp); 595 } 596 } 597 } 598 } 599 } 600 } 601 602 /* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX) 603 for later look ups of which function to call when user requests 604 a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target 605 library defining `function' we cannot yet know while reading OBJFILE which 606 of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later 607 DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */ 608 609 static void 610 elf_rel_plt_read (struct objfile *objfile, asymbol **dyn_symbol_table) 611 { 612 bfd *obfd = objfile->obfd; 613 const struct elf_backend_data *bed = get_elf_backend_data (obfd); 614 asection *plt, *relplt, *got_plt; 615 int plt_elf_idx; 616 bfd_size_type reloc_count, reloc; 617 char *string_buffer = NULL; 618 size_t string_buffer_size = 0; 619 struct cleanup *back_to; 620 struct gdbarch *gdbarch = objfile->gdbarch; 621 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 622 size_t ptr_size = TYPE_LENGTH (ptr_type); 623 624 if (objfile->separate_debug_objfile_backlink) 625 return; 626 627 plt = bfd_get_section_by_name (obfd, ".plt"); 628 if (plt == NULL) 629 return; 630 plt_elf_idx = elf_section_data (plt)->this_idx; 631 632 got_plt = bfd_get_section_by_name (obfd, ".got.plt"); 633 if (got_plt == NULL) 634 return; 635 636 /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */ 637 for (relplt = obfd->sections; relplt != NULL; relplt = relplt->next) 638 if (elf_section_data (relplt)->this_hdr.sh_info == plt_elf_idx 639 && (elf_section_data (relplt)->this_hdr.sh_type == SHT_REL 640 || elf_section_data (relplt)->this_hdr.sh_type == SHT_RELA)) 641 break; 642 if (relplt == NULL) 643 return; 644 645 if (! bed->s->slurp_reloc_table (obfd, relplt, dyn_symbol_table, TRUE)) 646 return; 647 648 back_to = make_cleanup (free_current_contents, &string_buffer); 649 650 reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize; 651 for (reloc = 0; reloc < reloc_count; reloc++) 652 { 653 const char *name; 654 struct minimal_symbol *msym; 655 CORE_ADDR address; 656 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX); 657 size_t name_len; 658 659 name = bfd_asymbol_name (*relplt->relocation[reloc].sym_ptr_ptr); 660 name_len = strlen (name); 661 address = relplt->relocation[reloc].address; 662 663 /* Does the pointer reside in the .got.plt section? */ 664 if (!(bfd_get_section_vma (obfd, got_plt) <= address 665 && address < bfd_get_section_vma (obfd, got_plt) 666 + bfd_get_section_size (got_plt))) 667 continue; 668 669 /* We cannot check if NAME is a reference to mst_text_gnu_ifunc as in 670 OBJFILE the symbol is undefined and the objfile having NAME defined 671 may not yet have been loaded. */ 672 673 if (string_buffer_size < name_len + got_suffix_len + 1) 674 { 675 string_buffer_size = 2 * (name_len + got_suffix_len); 676 string_buffer = xrealloc (string_buffer, string_buffer_size); 677 } 678 memcpy (string_buffer, name, name_len); 679 memcpy (&string_buffer[name_len], SYMBOL_GOT_PLT_SUFFIX, 680 got_suffix_len + 1); 681 682 msym = record_minimal_symbol (string_buffer, name_len + got_suffix_len, 683 1, address, mst_slot_got_plt, got_plt, 684 objfile); 685 if (msym) 686 SET_MSYMBOL_SIZE (msym, ptr_size); 687 } 688 689 do_cleanups (back_to); 690 } 691 692 /* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */ 693 694 static const struct objfile_data *elf_objfile_gnu_ifunc_cache_data; 695 696 /* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */ 697 698 struct elf_gnu_ifunc_cache 699 { 700 /* This is always a function entry address, not a function descriptor. */ 701 CORE_ADDR addr; 702 703 char name[1]; 704 }; 705 706 /* htab_hash for elf_objfile_gnu_ifunc_cache_data. */ 707 708 static hashval_t 709 elf_gnu_ifunc_cache_hash (const void *a_voidp) 710 { 711 const struct elf_gnu_ifunc_cache *a = a_voidp; 712 713 return htab_hash_string (a->name); 714 } 715 716 /* htab_eq for elf_objfile_gnu_ifunc_cache_data. */ 717 718 static int 719 elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp) 720 { 721 const struct elf_gnu_ifunc_cache *a = a_voidp; 722 const struct elf_gnu_ifunc_cache *b = b_voidp; 723 724 return strcmp (a->name, b->name) == 0; 725 } 726 727 /* Record the target function address of a STT_GNU_IFUNC function NAME is the 728 function entry address ADDR. Return 1 if NAME and ADDR are considered as 729 valid and therefore they were successfully recorded, return 0 otherwise. 730 731 Function does not expect a duplicate entry. Use 732 elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already 733 exists. */ 734 735 static int 736 elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr) 737 { 738 struct minimal_symbol *msym; 739 asection *sect; 740 struct objfile *objfile; 741 htab_t htab; 742 struct elf_gnu_ifunc_cache entry_local, *entry_p; 743 void **slot; 744 745 msym = lookup_minimal_symbol_by_pc (addr); 746 if (msym == NULL) 747 return 0; 748 if (SYMBOL_VALUE_ADDRESS (msym) != addr) 749 return 0; 750 /* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL. */ 751 sect = SYMBOL_OBJ_SECTION (msym)->the_bfd_section; 752 objfile = SYMBOL_OBJ_SECTION (msym)->objfile; 753 754 /* If .plt jumps back to .plt the symbol is still deferred for later 755 resolution and it has no use for GDB. Besides ".text" this symbol can 756 reside also in ".opd" for ppc64 function descriptor. */ 757 if (strcmp (bfd_get_section_name (objfile->obfd, sect), ".plt") == 0) 758 return 0; 759 760 htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data); 761 if (htab == NULL) 762 { 763 htab = htab_create_alloc_ex (1, elf_gnu_ifunc_cache_hash, 764 elf_gnu_ifunc_cache_eq, 765 NULL, &objfile->objfile_obstack, 766 hashtab_obstack_allocate, 767 dummy_obstack_deallocate); 768 set_objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data, htab); 769 } 770 771 entry_local.addr = addr; 772 obstack_grow (&objfile->objfile_obstack, &entry_local, 773 offsetof (struct elf_gnu_ifunc_cache, name)); 774 obstack_grow_str0 (&objfile->objfile_obstack, name); 775 entry_p = obstack_finish (&objfile->objfile_obstack); 776 777 slot = htab_find_slot (htab, entry_p, INSERT); 778 if (*slot != NULL) 779 { 780 struct elf_gnu_ifunc_cache *entry_found_p = *slot; 781 struct gdbarch *gdbarch = objfile->gdbarch; 782 783 if (entry_found_p->addr != addr) 784 { 785 /* This case indicates buggy inferior program, the resolved address 786 should never change. */ 787 788 warning (_("gnu-indirect-function \"%s\" has changed its resolved " 789 "function_address from %s to %s"), 790 name, paddress (gdbarch, entry_found_p->addr), 791 paddress (gdbarch, addr)); 792 } 793 794 /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */ 795 } 796 *slot = entry_p; 797 798 return 1; 799 } 800 801 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC 802 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P 803 is not NULL) and the function returns 1. It returns 0 otherwise. 804 805 Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this 806 function. */ 807 808 static int 809 elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p) 810 { 811 struct objfile *objfile; 812 813 ALL_PSPACE_OBJFILES (current_program_space, objfile) 814 { 815 htab_t htab; 816 struct elf_gnu_ifunc_cache *entry_p; 817 void **slot; 818 819 htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data); 820 if (htab == NULL) 821 continue; 822 823 entry_p = alloca (sizeof (*entry_p) + strlen (name)); 824 strcpy (entry_p->name, name); 825 826 slot = htab_find_slot (htab, entry_p, NO_INSERT); 827 if (slot == NULL) 828 continue; 829 entry_p = *slot; 830 gdb_assert (entry_p != NULL); 831 832 if (addr_p) 833 *addr_p = entry_p->addr; 834 return 1; 835 } 836 837 return 0; 838 } 839 840 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC 841 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P 842 is not NULL) and the function returns 1. It returns 0 otherwise. 843 844 Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. 845 elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to 846 prevent cache entries duplicates. */ 847 848 static int 849 elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p) 850 { 851 char *name_got_plt; 852 struct objfile *objfile; 853 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX); 854 855 name_got_plt = alloca (strlen (name) + got_suffix_len + 1); 856 sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name); 857 858 ALL_PSPACE_OBJFILES (current_program_space, objfile) 859 { 860 bfd *obfd = objfile->obfd; 861 struct gdbarch *gdbarch = objfile->gdbarch; 862 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 863 size_t ptr_size = TYPE_LENGTH (ptr_type); 864 CORE_ADDR pointer_address, addr; 865 asection *plt; 866 gdb_byte *buf = alloca (ptr_size); 867 struct minimal_symbol *msym; 868 869 msym = lookup_minimal_symbol (name_got_plt, NULL, objfile); 870 if (msym == NULL) 871 continue; 872 if (MSYMBOL_TYPE (msym) != mst_slot_got_plt) 873 continue; 874 pointer_address = SYMBOL_VALUE_ADDRESS (msym); 875 876 plt = bfd_get_section_by_name (obfd, ".plt"); 877 if (plt == NULL) 878 continue; 879 880 if (MSYMBOL_SIZE (msym) != ptr_size) 881 continue; 882 if (target_read_memory (pointer_address, buf, ptr_size) != 0) 883 continue; 884 addr = extract_typed_address (buf, ptr_type); 885 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, 886 ¤t_target); 887 888 if (addr_p) 889 *addr_p = addr; 890 if (elf_gnu_ifunc_record_cache (name, addr)) 891 return 1; 892 } 893 894 return 0; 895 } 896 897 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC 898 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P 899 is not NULL) and the function returns 1. It returns 0 otherwise. 900 901 Both the elf_objfile_gnu_ifunc_cache_data hash table and 902 SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */ 903 904 static int 905 elf_gnu_ifunc_resolve_name (const char *name, CORE_ADDR *addr_p) 906 { 907 if (elf_gnu_ifunc_resolve_by_cache (name, addr_p)) 908 return 1; 909 910 if (elf_gnu_ifunc_resolve_by_got (name, addr_p)) 911 return 1; 912 913 return 0; 914 } 915 916 /* Call STT_GNU_IFUNC - a function returning addresss of a real function to 917 call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned 918 is the entry point of the resolved STT_GNU_IFUNC target function to call. 919 */ 920 921 static CORE_ADDR 922 elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc) 923 { 924 const char *name_at_pc; 925 CORE_ADDR start_at_pc, address; 926 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func; 927 struct value *function, *address_val; 928 929 /* Try first any non-intrusive methods without an inferior call. */ 930 931 if (find_pc_partial_function (pc, &name_at_pc, &start_at_pc, NULL) 932 && start_at_pc == pc) 933 { 934 if (elf_gnu_ifunc_resolve_name (name_at_pc, &address)) 935 return address; 936 } 937 else 938 name_at_pc = NULL; 939 940 function = allocate_value (func_func_type); 941 set_value_address (function, pc); 942 943 /* STT_GNU_IFUNC resolver functions have no parameters. FUNCTION is the 944 function entry address. ADDRESS may be a function descriptor. */ 945 946 address_val = call_function_by_hand (function, 0, NULL); 947 address = value_as_address (address_val); 948 address = gdbarch_convert_from_func_ptr_addr (gdbarch, address, 949 ¤t_target); 950 951 if (name_at_pc) 952 elf_gnu_ifunc_record_cache (name_at_pc, address); 953 954 return address; 955 } 956 957 /* Handle inferior hit of bp_gnu_ifunc_resolver, see its definition. */ 958 959 static void 960 elf_gnu_ifunc_resolver_stop (struct breakpoint *b) 961 { 962 struct breakpoint *b_return; 963 struct frame_info *prev_frame = get_prev_frame (get_current_frame ()); 964 struct frame_id prev_frame_id = get_stack_frame_id (prev_frame); 965 CORE_ADDR prev_pc = get_frame_pc (prev_frame); 966 int thread_id = pid_to_thread_id (inferior_ptid); 967 968 gdb_assert (b->type == bp_gnu_ifunc_resolver); 969 970 for (b_return = b->related_breakpoint; b_return != b; 971 b_return = b_return->related_breakpoint) 972 { 973 gdb_assert (b_return->type == bp_gnu_ifunc_resolver_return); 974 gdb_assert (b_return->loc != NULL && b_return->loc->next == NULL); 975 gdb_assert (frame_id_p (b_return->frame_id)); 976 977 if (b_return->thread == thread_id 978 && b_return->loc->requested_address == prev_pc 979 && frame_id_eq (b_return->frame_id, prev_frame_id)) 980 break; 981 } 982 983 if (b_return == b) 984 { 985 struct symtab_and_line sal; 986 987 /* No need to call find_pc_line for symbols resolving as this is only 988 a helper breakpointer never shown to the user. */ 989 990 init_sal (&sal); 991 sal.pspace = current_inferior ()->pspace; 992 sal.pc = prev_pc; 993 sal.section = find_pc_overlay (sal.pc); 994 sal.explicit_pc = 1; 995 b_return = set_momentary_breakpoint (get_frame_arch (prev_frame), sal, 996 prev_frame_id, 997 bp_gnu_ifunc_resolver_return); 998 999 /* set_momentary_breakpoint invalidates PREV_FRAME. */ 1000 prev_frame = NULL; 1001 1002 /* Add new b_return to the ring list b->related_breakpoint. */ 1003 gdb_assert (b_return->related_breakpoint == b_return); 1004 b_return->related_breakpoint = b->related_breakpoint; 1005 b->related_breakpoint = b_return; 1006 } 1007 } 1008 1009 /* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition. */ 1010 1011 static void 1012 elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b) 1013 { 1014 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); 1015 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func; 1016 struct type *value_type = TYPE_TARGET_TYPE (func_func_type); 1017 struct regcache *regcache = get_thread_regcache (inferior_ptid); 1018 struct value *func_func; 1019 struct value *value; 1020 CORE_ADDR resolved_address, resolved_pc; 1021 struct symtab_and_line sal; 1022 struct symtabs_and_lines sals, sals_end; 1023 1024 gdb_assert (b->type == bp_gnu_ifunc_resolver_return); 1025 1026 while (b->related_breakpoint != b) 1027 { 1028 struct breakpoint *b_next = b->related_breakpoint; 1029 1030 switch (b->type) 1031 { 1032 case bp_gnu_ifunc_resolver: 1033 break; 1034 case bp_gnu_ifunc_resolver_return: 1035 delete_breakpoint (b); 1036 break; 1037 default: 1038 internal_error (__FILE__, __LINE__, 1039 _("handle_inferior_event: Invalid " 1040 "gnu-indirect-function breakpoint type %d"), 1041 (int) b->type); 1042 } 1043 b = b_next; 1044 } 1045 gdb_assert (b->type == bp_gnu_ifunc_resolver); 1046 gdb_assert (b->loc->next == NULL); 1047 1048 func_func = allocate_value (func_func_type); 1049 set_value_address (func_func, b->loc->related_address); 1050 1051 value = allocate_value (value_type); 1052 gdbarch_return_value (gdbarch, func_func, value_type, regcache, 1053 value_contents_raw (value), NULL); 1054 resolved_address = value_as_address (value); 1055 resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch, 1056 resolved_address, 1057 ¤t_target); 1058 1059 gdb_assert (current_program_space == b->pspace || b->pspace == NULL); 1060 elf_gnu_ifunc_record_cache (b->addr_string, resolved_pc); 1061 1062 sal = find_pc_line (resolved_pc, 0); 1063 sals.nelts = 1; 1064 sals.sals = &sal; 1065 sals_end.nelts = 0; 1066 1067 b->type = bp_breakpoint; 1068 update_breakpoint_locations (b, sals, sals_end); 1069 } 1070 1071 /* Locate NT_GNU_BUILD_ID from ABFD and return its content. */ 1072 1073 static const struct elf_build_id * 1074 build_id_bfd_get (bfd *abfd) 1075 { 1076 if (!bfd_check_format (abfd, bfd_object) 1077 || bfd_get_flavour (abfd) != bfd_target_elf_flavour 1078 || elf_tdata (abfd)->build_id == NULL) 1079 return NULL; 1080 1081 return elf_tdata (abfd)->build_id; 1082 } 1083 1084 /* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */ 1085 1086 static int 1087 build_id_verify (const char *filename, const struct elf_build_id *check) 1088 { 1089 bfd *abfd; 1090 const struct elf_build_id *found; 1091 int retval = 0; 1092 1093 /* We expect to be silent on the non-existing files. */ 1094 abfd = gdb_bfd_open_maybe_remote (filename); 1095 if (abfd == NULL) 1096 return 0; 1097 1098 found = build_id_bfd_get (abfd); 1099 1100 if (found == NULL) 1101 warning (_("File \"%s\" has no build-id, file skipped"), filename); 1102 else if (found->size != check->size 1103 || memcmp (found->data, check->data, found->size) != 0) 1104 warning (_("File \"%s\" has a different build-id, file skipped"), 1105 filename); 1106 else 1107 retval = 1; 1108 1109 gdb_bfd_unref (abfd); 1110 1111 return retval; 1112 } 1113 1114 static char * 1115 build_id_to_debug_filename (const struct elf_build_id *build_id) 1116 { 1117 char *link, *debugdir, *retval = NULL; 1118 VEC (char_ptr) *debugdir_vec; 1119 struct cleanup *back_to; 1120 int ix; 1121 1122 /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */ 1123 link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1 1124 + 2 * build_id->size + (sizeof ".debug" - 1) + 1); 1125 1126 /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will 1127 cause "/.build-id/..." lookups. */ 1128 1129 debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory); 1130 back_to = make_cleanup_free_char_ptr_vec (debugdir_vec); 1131 1132 for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix) 1133 { 1134 size_t debugdir_len = strlen (debugdir); 1135 const gdb_byte *data = build_id->data; 1136 size_t size = build_id->size; 1137 char *s; 1138 1139 memcpy (link, debugdir, debugdir_len); 1140 s = &link[debugdir_len]; 1141 s += sprintf (s, "/.build-id/"); 1142 if (size > 0) 1143 { 1144 size--; 1145 s += sprintf (s, "%02x", (unsigned) *data++); 1146 } 1147 if (size > 0) 1148 *s++ = '/'; 1149 while (size-- > 0) 1150 s += sprintf (s, "%02x", (unsigned) *data++); 1151 strcpy (s, ".debug"); 1152 1153 /* lrealpath() is expensive even for the usually non-existent files. */ 1154 if (access (link, F_OK) == 0) 1155 retval = lrealpath (link); 1156 1157 if (retval != NULL && !build_id_verify (retval, build_id)) 1158 { 1159 xfree (retval); 1160 retval = NULL; 1161 } 1162 1163 if (retval != NULL) 1164 break; 1165 } 1166 1167 do_cleanups (back_to); 1168 return retval; 1169 } 1170 1171 static char * 1172 find_separate_debug_file_by_buildid (struct objfile *objfile) 1173 { 1174 const struct elf_build_id *build_id; 1175 1176 build_id = build_id_bfd_get (objfile->obfd); 1177 if (build_id != NULL) 1178 { 1179 char *build_id_name; 1180 1181 build_id_name = build_id_to_debug_filename (build_id); 1182 /* Prevent looping on a stripped .debug file. */ 1183 if (build_id_name != NULL 1184 && filename_cmp (build_id_name, objfile->name) == 0) 1185 { 1186 warning (_("\"%s\": separate debug info file has no debug info"), 1187 build_id_name); 1188 xfree (build_id_name); 1189 } 1190 else if (build_id_name != NULL) 1191 return build_id_name; 1192 } 1193 return NULL; 1194 } 1195 1196 /* Scan and build partial symbols for a symbol file. 1197 We have been initialized by a call to elf_symfile_init, which 1198 currently does nothing. 1199 1200 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols 1201 in each section. We simplify it down to a single offset for all 1202 symbols. FIXME. 1203 1204 This function only does the minimum work necessary for letting the 1205 user "name" things symbolically; it does not read the entire symtab. 1206 Instead, it reads the external and static symbols and puts them in partial 1207 symbol tables. When more extensive information is requested of a 1208 file, the corresponding partial symbol table is mutated into a full 1209 fledged symbol table by going back and reading the symbols 1210 for real. 1211 1212 We look for sections with specific names, to tell us what debug 1213 format to look for: FIXME!!! 1214 1215 elfstab_build_psymtabs() handles STABS symbols; 1216 mdebug_build_psymtabs() handles ECOFF debugging information. 1217 1218 Note that ELF files have a "minimal" symbol table, which looks a lot 1219 like a COFF symbol table, but has only the minimal information necessary 1220 for linking. We process this also, and use the information to 1221 build gdb's minimal symbol table. This gives us some minimal debugging 1222 capability even for files compiled without -g. */ 1223 1224 static void 1225 elf_symfile_read (struct objfile *objfile, int symfile_flags) 1226 { 1227 bfd *synth_abfd, *abfd = objfile->obfd; 1228 struct elfinfo ei; 1229 struct cleanup *back_to; 1230 long symcount = 0, dynsymcount = 0, synthcount, storage_needed; 1231 asymbol **symbol_table = NULL, **dyn_symbol_table = NULL; 1232 asymbol *synthsyms; 1233 struct dbx_symfile_info *dbx; 1234 1235 if (symtab_create_debug) 1236 { 1237 fprintf_unfiltered (gdb_stdlog, 1238 "Reading minimal symbols of objfile %s ...\n", 1239 objfile->name); 1240 } 1241 1242 init_minimal_symbol_collection (); 1243 back_to = make_cleanup_discard_minimal_symbols (); 1244 1245 memset ((char *) &ei, 0, sizeof (ei)); 1246 1247 /* Allocate struct to keep track of the symfile. */ 1248 dbx = XCNEW (struct dbx_symfile_info); 1249 set_objfile_data (objfile, dbx_objfile_data_key, dbx); 1250 make_cleanup (free_elfinfo, (void *) objfile); 1251 1252 /* Process the normal ELF symbol table first. This may write some 1253 chain of info into the dbx_symfile_info of the objfile, which can 1254 later be used by elfstab_offset_sections. */ 1255 1256 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd); 1257 if (storage_needed < 0) 1258 error (_("Can't read symbols from %s: %s"), 1259 bfd_get_filename (objfile->obfd), 1260 bfd_errmsg (bfd_get_error ())); 1261 1262 if (storage_needed > 0) 1263 { 1264 symbol_table = (asymbol **) xmalloc (storage_needed); 1265 make_cleanup (xfree, symbol_table); 1266 symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table); 1267 1268 if (symcount < 0) 1269 error (_("Can't read symbols from %s: %s"), 1270 bfd_get_filename (objfile->obfd), 1271 bfd_errmsg (bfd_get_error ())); 1272 1273 elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0); 1274 } 1275 1276 /* Add the dynamic symbols. */ 1277 1278 storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd); 1279 1280 if (storage_needed > 0) 1281 { 1282 /* Memory gets permanently referenced from ABFD after 1283 bfd_get_synthetic_symtab so it must not get freed before ABFD gets. 1284 It happens only in the case when elf_slurp_reloc_table sees 1285 asection->relocation NULL. Determining which section is asection is 1286 done by _bfd_elf_get_synthetic_symtab which is all a bfd 1287 implementation detail, though. */ 1288 1289 dyn_symbol_table = bfd_alloc (abfd, storage_needed); 1290 dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd, 1291 dyn_symbol_table); 1292 1293 if (dynsymcount < 0) 1294 error (_("Can't read symbols from %s: %s"), 1295 bfd_get_filename (objfile->obfd), 1296 bfd_errmsg (bfd_get_error ())); 1297 1298 elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0); 1299 1300 elf_rel_plt_read (objfile, dyn_symbol_table); 1301 } 1302 1303 /* Contrary to binutils --strip-debug/--only-keep-debug the strip command from 1304 elfutils (eu-strip) moves even the .symtab section into the .debug file. 1305 1306 bfd_get_synthetic_symtab on ppc64 for each function descriptor ELF symbol 1307 'name' creates a new BSF_SYNTHETIC ELF symbol '.name' with its code 1308 address. But with eu-strip files bfd_get_synthetic_symtab would fail to 1309 read the code address from .opd while it reads the .symtab section from 1310 a separate debug info file as the .opd section is SHT_NOBITS there. 1311 1312 With SYNTH_ABFD the .opd section will be read from the original 1313 backlinked binary where it is valid. */ 1314 1315 if (objfile->separate_debug_objfile_backlink) 1316 synth_abfd = objfile->separate_debug_objfile_backlink->obfd; 1317 else 1318 synth_abfd = abfd; 1319 1320 /* Add synthetic symbols - for instance, names for any PLT entries. */ 1321 1322 synthcount = bfd_get_synthetic_symtab (synth_abfd, symcount, symbol_table, 1323 dynsymcount, dyn_symbol_table, 1324 &synthsyms); 1325 if (synthcount > 0) 1326 { 1327 asymbol **synth_symbol_table; 1328 long i; 1329 1330 make_cleanup (xfree, synthsyms); 1331 synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount); 1332 for (i = 0; i < synthcount; i++) 1333 synth_symbol_table[i] = synthsyms + i; 1334 make_cleanup (xfree, synth_symbol_table); 1335 elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, 1336 synth_symbol_table, 1); 1337 } 1338 1339 /* Install any minimal symbols that have been collected as the current 1340 minimal symbols for this objfile. The debug readers below this point 1341 should not generate new minimal symbols; if they do it's their 1342 responsibility to install them. "mdebug" appears to be the only one 1343 which will do this. */ 1344 1345 install_minimal_symbols (objfile); 1346 do_cleanups (back_to); 1347 1348 /* Now process debugging information, which is contained in 1349 special ELF sections. */ 1350 1351 /* We first have to find them... */ 1352 bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei); 1353 1354 /* ELF debugging information is inserted into the psymtab in the 1355 order of least informative first - most informative last. Since 1356 the psymtab table is searched `most recent insertion first' this 1357 increases the probability that more detailed debug information 1358 for a section is found. 1359 1360 For instance, an object file might contain both .mdebug (XCOFF) 1361 and .debug_info (DWARF2) sections then .mdebug is inserted first 1362 (searched last) and DWARF2 is inserted last (searched first). If 1363 we don't do this then the XCOFF info is found first - for code in 1364 an included file XCOFF info is useless. */ 1365 1366 if (ei.mdebugsect) 1367 { 1368 const struct ecoff_debug_swap *swap; 1369 1370 /* .mdebug section, presumably holding ECOFF debugging 1371 information. */ 1372 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 1373 if (swap) 1374 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect); 1375 } 1376 if (ei.stabsect) 1377 { 1378 asection *str_sect; 1379 1380 /* Stab sections have an associated string table that looks like 1381 a separate section. */ 1382 str_sect = bfd_get_section_by_name (abfd, ".stabstr"); 1383 1384 /* FIXME should probably warn about a stab section without a stabstr. */ 1385 if (str_sect) 1386 elfstab_build_psymtabs (objfile, 1387 ei.stabsect, 1388 str_sect->filepos, 1389 bfd_section_size (abfd, str_sect)); 1390 } 1391 1392 if (symtab_create_debug) 1393 fprintf_unfiltered (gdb_stdlog, "Done reading minimal symbols.\n"); 1394 1395 if (dwarf2_has_info (objfile, NULL)) 1396 { 1397 /* elf_sym_fns_gdb_index cannot handle simultaneous non-DWARF debug 1398 information present in OBJFILE. If there is such debug info present 1399 never use .gdb_index. */ 1400 1401 if (!objfile_has_partial_symbols (objfile) 1402 && dwarf2_initialize_objfile (objfile)) 1403 objfile->sf = &elf_sym_fns_gdb_index; 1404 else 1405 { 1406 /* It is ok to do this even if the stabs reader made some 1407 partial symbols, because OBJF_PSYMTABS_READ has not been 1408 set, and so our lazy reader function will still be called 1409 when needed. */ 1410 objfile->sf = &elf_sym_fns_lazy_psyms; 1411 } 1412 } 1413 /* If the file has its own symbol tables it has no separate debug 1414 info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to 1415 SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with 1416 `.note.gnu.build-id'. 1417 1418 .gnu_debugdata is !objfile_has_partial_symbols because it contains only 1419 .symtab, not .debug_* section. But if we already added .gnu_debugdata as 1420 an objfile via find_separate_debug_file_in_section there was no separate 1421 debug info available. Therefore do not attempt to search for another one, 1422 objfile->separate_debug_objfile->separate_debug_objfile GDB guarantees to 1423 be NULL and we would possibly violate it. */ 1424 1425 else if (!objfile_has_partial_symbols (objfile) 1426 && objfile->separate_debug_objfile == NULL 1427 && objfile->separate_debug_objfile_backlink == NULL) 1428 { 1429 char *debugfile; 1430 1431 debugfile = find_separate_debug_file_by_buildid (objfile); 1432 1433 if (debugfile == NULL) 1434 debugfile = find_separate_debug_file_by_debuglink (objfile); 1435 1436 if (debugfile) 1437 { 1438 struct cleanup *cleanup = make_cleanup (xfree, debugfile); 1439 bfd *abfd = symfile_bfd_open (debugfile); 1440 1441 make_cleanup_bfd_unref (abfd); 1442 symbol_file_add_separate (abfd, symfile_flags, objfile); 1443 do_cleanups (cleanup); 1444 } 1445 } 1446 } 1447 1448 /* Callback to lazily read psymtabs. */ 1449 1450 static void 1451 read_psyms (struct objfile *objfile) 1452 { 1453 if (dwarf2_has_info (objfile, NULL)) 1454 dwarf2_build_psymtabs (objfile); 1455 } 1456 1457 /* This cleans up the objfile's dbx symfile info, and the chain of 1458 stab_section_info's, that might be dangling from it. */ 1459 1460 static void 1461 free_elfinfo (void *objp) 1462 { 1463 struct objfile *objfile = (struct objfile *) objp; 1464 struct dbx_symfile_info *dbxinfo = DBX_SYMFILE_INFO (objfile); 1465 struct stab_section_info *ssi, *nssi; 1466 1467 ssi = dbxinfo->stab_section_info; 1468 while (ssi) 1469 { 1470 nssi = ssi->next; 1471 xfree (ssi); 1472 ssi = nssi; 1473 } 1474 1475 dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */ 1476 } 1477 1478 1479 /* Initialize anything that needs initializing when a completely new symbol 1480 file is specified (not just adding some symbols from another file, e.g. a 1481 shared library). 1482 1483 We reinitialize buildsym, since we may be reading stabs from an ELF 1484 file. */ 1485 1486 static void 1487 elf_new_init (struct objfile *ignore) 1488 { 1489 stabsread_new_init (); 1490 buildsym_new_init (); 1491 } 1492 1493 /* Perform any local cleanups required when we are done with a particular 1494 objfile. I.E, we are in the process of discarding all symbol information 1495 for an objfile, freeing up all memory held for it, and unlinking the 1496 objfile struct from the global list of known objfiles. */ 1497 1498 static void 1499 elf_symfile_finish (struct objfile *objfile) 1500 { 1501 dwarf2_free_objfile (objfile); 1502 } 1503 1504 /* ELF specific initialization routine for reading symbols. 1505 1506 It is passed a pointer to a struct sym_fns which contains, among other 1507 things, the BFD for the file whose symbols are being read, and a slot for 1508 a pointer to "private data" which we can fill with goodies. 1509 1510 For now at least, we have nothing in particular to do, so this function is 1511 just a stub. */ 1512 1513 static void 1514 elf_symfile_init (struct objfile *objfile) 1515 { 1516 /* ELF objects may be reordered, so set OBJF_REORDERED. If we 1517 find this causes a significant slowdown in gdb then we could 1518 set it in the debug symbol readers only when necessary. */ 1519 objfile->flags |= OBJF_REORDERED; 1520 } 1521 1522 /* When handling an ELF file that contains Sun STABS debug info, 1523 some of the debug info is relative to the particular chunk of the 1524 section that was generated in its individual .o file. E.g. 1525 offsets to static variables are relative to the start of the data 1526 segment *for that module before linking*. This information is 1527 painfully squirreled away in the ELF symbol table as local symbols 1528 with wierd names. Go get 'em when needed. */ 1529 1530 void 1531 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst) 1532 { 1533 const char *filename = pst->filename; 1534 struct dbx_symfile_info *dbx = DBX_SYMFILE_INFO (objfile); 1535 struct stab_section_info *maybe = dbx->stab_section_info; 1536 struct stab_section_info *questionable = 0; 1537 int i; 1538 1539 /* The ELF symbol info doesn't include path names, so strip the path 1540 (if any) from the psymtab filename. */ 1541 filename = lbasename (filename); 1542 1543 /* FIXME: This linear search could speed up significantly 1544 if it was chained in the right order to match how we search it, 1545 and if we unchained when we found a match. */ 1546 for (; maybe; maybe = maybe->next) 1547 { 1548 if (filename[0] == maybe->filename[0] 1549 && filename_cmp (filename, maybe->filename) == 0) 1550 { 1551 /* We found a match. But there might be several source files 1552 (from different directories) with the same name. */ 1553 if (0 == maybe->found) 1554 break; 1555 questionable = maybe; /* Might use it later. */ 1556 } 1557 } 1558 1559 if (maybe == 0 && questionable != 0) 1560 { 1561 complaint (&symfile_complaints, 1562 _("elf/stab section information questionable for %s"), 1563 filename); 1564 maybe = questionable; 1565 } 1566 1567 if (maybe) 1568 { 1569 /* Found it! Allocate a new psymtab struct, and fill it in. */ 1570 maybe->found++; 1571 pst->section_offsets = (struct section_offsets *) 1572 obstack_alloc (&objfile->objfile_obstack, 1573 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); 1574 for (i = 0; i < maybe->num_sections; i++) 1575 (pst->section_offsets)->offsets[i] = maybe->sections[i]; 1576 return; 1577 } 1578 1579 /* We were unable to find any offsets for this file. Complain. */ 1580 if (dbx->stab_section_info) /* If there *is* any info, */ 1581 complaint (&symfile_complaints, 1582 _("elf/stab section information missing for %s"), filename); 1583 } 1584 1585 /* Implementation of `sym_get_probes', as documented in symfile.h. */ 1586 1587 static VEC (probe_p) * 1588 elf_get_probes (struct objfile *objfile) 1589 { 1590 VEC (probe_p) *probes_per_objfile; 1591 1592 /* Have we parsed this objfile's probes already? */ 1593 probes_per_objfile = objfile_data (objfile, probe_key); 1594 1595 if (!probes_per_objfile) 1596 { 1597 int ix; 1598 const struct probe_ops *probe_ops; 1599 1600 /* Here we try to gather information about all types of probes from the 1601 objfile. */ 1602 for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops); 1603 ix++) 1604 probe_ops->get_probes (&probes_per_objfile, objfile); 1605 1606 if (probes_per_objfile == NULL) 1607 { 1608 VEC_reserve (probe_p, probes_per_objfile, 1); 1609 gdb_assert (probes_per_objfile != NULL); 1610 } 1611 1612 set_objfile_data (objfile, probe_key, probes_per_objfile); 1613 } 1614 1615 return probes_per_objfile; 1616 } 1617 1618 /* Implementation of `sym_get_probe_argument_count', as documented in 1619 symfile.h. */ 1620 1621 static unsigned 1622 elf_get_probe_argument_count (struct probe *probe) 1623 { 1624 return probe->pops->get_probe_argument_count (probe); 1625 } 1626 1627 /* Implementation of `sym_evaluate_probe_argument', as documented in 1628 symfile.h. */ 1629 1630 static struct value * 1631 elf_evaluate_probe_argument (struct probe *probe, unsigned n) 1632 { 1633 return probe->pops->evaluate_probe_argument (probe, n); 1634 } 1635 1636 /* Implementation of `sym_compile_to_ax', as documented in symfile.h. */ 1637 1638 static void 1639 elf_compile_to_ax (struct probe *probe, 1640 struct agent_expr *expr, 1641 struct axs_value *value, 1642 unsigned n) 1643 { 1644 probe->pops->compile_to_ax (probe, expr, value, n); 1645 } 1646 1647 /* Implementation of `sym_relocate_probe', as documented in symfile.h. */ 1648 1649 static void 1650 elf_symfile_relocate_probe (struct objfile *objfile, 1651 struct section_offsets *new_offsets, 1652 struct section_offsets *delta) 1653 { 1654 int ix; 1655 VEC (probe_p) *probes = objfile_data (objfile, probe_key); 1656 struct probe *probe; 1657 1658 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++) 1659 probe->pops->relocate (probe, ANOFFSET (delta, SECT_OFF_TEXT (objfile))); 1660 } 1661 1662 /* Helper function used to free the space allocated for storing SystemTap 1663 probe information. */ 1664 1665 static void 1666 probe_key_free (struct objfile *objfile, void *d) 1667 { 1668 int ix; 1669 VEC (probe_p) *probes = d; 1670 struct probe *probe; 1671 1672 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++) 1673 probe->pops->destroy (probe); 1674 1675 VEC_free (probe_p, probes); 1676 } 1677 1678 1679 1680 /* Implementation `sym_probe_fns', as documented in symfile.h. */ 1681 1682 static const struct sym_probe_fns elf_probe_fns = 1683 { 1684 elf_get_probes, /* sym_get_probes */ 1685 elf_get_probe_argument_count, /* sym_get_probe_argument_count */ 1686 elf_evaluate_probe_argument, /* sym_evaluate_probe_argument */ 1687 elf_compile_to_ax, /* sym_compile_to_ax */ 1688 elf_symfile_relocate_probe, /* sym_relocate_probe */ 1689 }; 1690 1691 /* Register that we are able to handle ELF object file formats. */ 1692 1693 static const struct sym_fns elf_sym_fns = 1694 { 1695 bfd_target_elf_flavour, 1696 elf_new_init, /* init anything gbl to entire symtab */ 1697 elf_symfile_init, /* read initial info, setup for sym_read() */ 1698 elf_symfile_read, /* read a symbol file into symtab */ 1699 NULL, /* sym_read_psymbols */ 1700 elf_symfile_finish, /* finished with file, cleanup */ 1701 default_symfile_offsets, /* Translate ext. to int. relocation */ 1702 elf_symfile_segments, /* Get segment information from a file. */ 1703 NULL, 1704 default_symfile_relocate, /* Relocate a debug section. */ 1705 &elf_probe_fns, /* sym_probe_fns */ 1706 &psym_functions 1707 }; 1708 1709 /* The same as elf_sym_fns, but not registered and lazily reads 1710 psymbols. */ 1711 1712 static const struct sym_fns elf_sym_fns_lazy_psyms = 1713 { 1714 bfd_target_elf_flavour, 1715 elf_new_init, /* init anything gbl to entire symtab */ 1716 elf_symfile_init, /* read initial info, setup for sym_read() */ 1717 elf_symfile_read, /* read a symbol file into symtab */ 1718 read_psyms, /* sym_read_psymbols */ 1719 elf_symfile_finish, /* finished with file, cleanup */ 1720 default_symfile_offsets, /* Translate ext. to int. relocation */ 1721 elf_symfile_segments, /* Get segment information from a file. */ 1722 NULL, 1723 default_symfile_relocate, /* Relocate a debug section. */ 1724 &elf_probe_fns, /* sym_probe_fns */ 1725 &psym_functions 1726 }; 1727 1728 /* The same as elf_sym_fns, but not registered and uses the 1729 DWARF-specific GNU index rather than psymtab. */ 1730 static const struct sym_fns elf_sym_fns_gdb_index = 1731 { 1732 bfd_target_elf_flavour, 1733 elf_new_init, /* init anything gbl to entire symab */ 1734 elf_symfile_init, /* read initial info, setup for sym_red() */ 1735 elf_symfile_read, /* read a symbol file into symtab */ 1736 NULL, /* sym_read_psymbols */ 1737 elf_symfile_finish, /* finished with file, cleanup */ 1738 default_symfile_offsets, /* Translate ext. to int. relocatin */ 1739 elf_symfile_segments, /* Get segment information from a file. */ 1740 NULL, 1741 default_symfile_relocate, /* Relocate a debug section. */ 1742 &elf_probe_fns, /* sym_probe_fns */ 1743 &dwarf2_gdb_index_functions 1744 }; 1745 1746 /* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */ 1747 1748 static const struct gnu_ifunc_fns elf_gnu_ifunc_fns = 1749 { 1750 elf_gnu_ifunc_resolve_addr, 1751 elf_gnu_ifunc_resolve_name, 1752 elf_gnu_ifunc_resolver_stop, 1753 elf_gnu_ifunc_resolver_return_stop 1754 }; 1755 1756 void 1757 _initialize_elfread (void) 1758 { 1759 probe_key = register_objfile_data_with_cleanup (NULL, probe_key_free); 1760 add_symtab_fns (&elf_sym_fns); 1761 1762 elf_objfile_gnu_ifunc_cache_data = register_objfile_data (); 1763 gnu_ifunc_fns_p = &elf_gnu_ifunc_fns; 1764 } 1765