1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger. 2 3 Copyright (C) 1990-2020 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 22 #include "elf/external.h" 23 #include "elf/common.h" 24 #include "elf/mips.h" 25 26 #include "symtab.h" 27 #include "bfd.h" 28 #include "symfile.h" 29 #include "objfiles.h" 30 #include "gdbcore.h" 31 #include "target.h" 32 #include "inferior.h" 33 #include "infrun.h" 34 #include "regcache.h" 35 #include "gdbthread.h" 36 #include "observable.h" 37 38 #include "solist.h" 39 #include "solib.h" 40 #include "solib-svr4.h" 41 42 #include "bfd-target.h" 43 #include "elf-bfd.h" 44 #include "exec.h" 45 #include "auxv.h" 46 #include "gdb_bfd.h" 47 #include "probe.h" 48 49 static struct link_map_offsets *svr4_fetch_link_map_offsets (void); 50 static int svr4_have_link_map_offsets (void); 51 static void svr4_relocate_main_executable (void); 52 static void svr4_free_library_list (void *p_list); 53 static void probes_table_remove_objfile_probes (struct objfile *objfile); 54 static void svr4_iterate_over_objfiles_in_search_order ( 55 struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, 56 void *cb_data, struct objfile *objfile); 57 58 59 /* On SVR4 systems, a list of symbols in the dynamic linker where 60 GDB can try to place a breakpoint to monitor shared library 61 events. 62 63 If none of these symbols are found, or other errors occur, then 64 SVR4 systems will fall back to using a symbol as the "startup 65 mapping complete" breakpoint address. */ 66 67 static const char * const solib_break_names[] = 68 { 69 "r_debug_state", 70 "_r_debug_state", 71 "_dl_debug_state", 72 "rtld_db_dlactivity", 73 "__dl_rtld_db_dlactivity", 74 "_rtld_debug_state", 75 76 NULL 77 }; 78 79 static const char * const bkpt_names[] = 80 { 81 "_start", 82 "__start", 83 "main", 84 NULL 85 }; 86 87 static const char * const main_name_list[] = 88 { 89 "main_$main", 90 NULL 91 }; 92 93 /* What to do when a probe stop occurs. */ 94 95 enum probe_action 96 { 97 /* Something went seriously wrong. Stop using probes and 98 revert to using the older interface. */ 99 PROBES_INTERFACE_FAILED, 100 101 /* No action is required. The shared object list is still 102 valid. */ 103 DO_NOTHING, 104 105 /* The shared object list should be reloaded entirely. */ 106 FULL_RELOAD, 107 108 /* Attempt to incrementally update the shared object list. If 109 the update fails or is not possible, fall back to reloading 110 the list in full. */ 111 UPDATE_OR_RELOAD, 112 }; 113 114 /* A probe's name and its associated action. */ 115 116 struct probe_info 117 { 118 /* The name of the probe. */ 119 const char *name; 120 121 /* What to do when a probe stop occurs. */ 122 enum probe_action action; 123 }; 124 125 /* A list of named probes and their associated actions. If all 126 probes are present in the dynamic linker then the probes-based 127 interface will be used. */ 128 129 static const struct probe_info probe_info[] = 130 { 131 { "init_start", DO_NOTHING }, 132 { "init_complete", FULL_RELOAD }, 133 { "map_start", DO_NOTHING }, 134 { "map_failed", DO_NOTHING }, 135 { "reloc_complete", UPDATE_OR_RELOAD }, 136 { "unmap_start", DO_NOTHING }, 137 { "unmap_complete", FULL_RELOAD }, 138 }; 139 140 #define NUM_PROBES ARRAY_SIZE (probe_info) 141 142 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent 143 the same shared library. */ 144 145 static int 146 svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name) 147 { 148 if (strcmp (gdb_so_name, inferior_so_name) == 0) 149 return 1; 150 151 /* On Solaris, when starting inferior we think that dynamic linker is 152 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries 153 contains /lib/ld.so.1. Sometimes one file is a link to another, but 154 sometimes they have identical content, but are not linked to each 155 other. We don't restrict this check for Solaris, but the chances 156 of running into this situation elsewhere are very low. */ 157 if (strcmp (gdb_so_name, "/usr/lib/ld.so.1") == 0 158 && strcmp (inferior_so_name, "/lib/ld.so.1") == 0) 159 return 1; 160 161 /* Similarly, we observed the same issue with amd64 and sparcv9, but with 162 different locations. */ 163 if (strcmp (gdb_so_name, "/usr/lib/amd64/ld.so.1") == 0 164 && strcmp (inferior_so_name, "/lib/amd64/ld.so.1") == 0) 165 return 1; 166 167 if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0 168 && strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0) 169 return 1; 170 171 return 0; 172 } 173 174 static int 175 svr4_same (struct so_list *gdb, struct so_list *inferior) 176 { 177 return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name)); 178 } 179 180 static std::unique_ptr<lm_info_svr4> 181 lm_info_read (CORE_ADDR lm_addr) 182 { 183 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 184 std::unique_ptr<lm_info_svr4> lm_info; 185 186 gdb::byte_vector lm (lmo->link_map_size); 187 188 if (target_read_memory (lm_addr, lm.data (), lmo->link_map_size) != 0) 189 warning (_("Error reading shared library list entry at %s"), 190 paddress (target_gdbarch (), lm_addr)); 191 else 192 { 193 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 194 195 lm_info.reset (new lm_info_svr4); 196 lm_info->lm_addr = lm_addr; 197 198 lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset], 199 ptr_type); 200 lm_info->l_ld = extract_typed_address (&lm[lmo->l_ld_offset], ptr_type); 201 lm_info->l_next = extract_typed_address (&lm[lmo->l_next_offset], 202 ptr_type); 203 lm_info->l_prev = extract_typed_address (&lm[lmo->l_prev_offset], 204 ptr_type); 205 lm_info->l_name = extract_typed_address (&lm[lmo->l_name_offset], 206 ptr_type); 207 } 208 209 return lm_info; 210 } 211 212 static int 213 has_lm_dynamic_from_link_map (void) 214 { 215 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 216 217 return lmo->l_ld_offset >= 0; 218 } 219 220 static CORE_ADDR 221 lm_addr_check (const struct so_list *so, bfd *abfd) 222 { 223 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; 224 225 if (!li->l_addr_p) 226 { 227 struct bfd_section *dyninfo_sect; 228 CORE_ADDR l_addr, l_dynaddr, dynaddr; 229 230 l_addr = li->l_addr_inferior; 231 232 if (! abfd || ! has_lm_dynamic_from_link_map ()) 233 goto set_addr; 234 235 l_dynaddr = li->l_ld; 236 237 dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic"); 238 if (dyninfo_sect == NULL) 239 goto set_addr; 240 241 dynaddr = bfd_section_vma (dyninfo_sect); 242 243 if (dynaddr + l_addr != l_dynaddr) 244 { 245 CORE_ADDR align = 0x1000; 246 CORE_ADDR minpagesize = align; 247 248 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 249 { 250 Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header; 251 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr; 252 int i; 253 254 align = 1; 255 256 for (i = 0; i < ehdr->e_phnum; i++) 257 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align) 258 align = phdr[i].p_align; 259 260 minpagesize = get_elf_backend_data (abfd)->minpagesize; 261 } 262 263 /* Turn it into a mask. */ 264 align--; 265 266 /* If the changes match the alignment requirements, we 267 assume we're using a core file that was generated by the 268 same binary, just prelinked with a different base offset. 269 If it doesn't match, we may have a different binary, the 270 same binary with the dynamic table loaded at an unrelated 271 location, or anything, really. To avoid regressions, 272 don't adjust the base offset in the latter case, although 273 odds are that, if things really changed, debugging won't 274 quite work. 275 276 One could expect more the condition 277 ((l_addr & align) == 0 && ((l_dynaddr - dynaddr) & align) == 0) 278 but the one below is relaxed for PPC. The PPC kernel supports 279 either 4k or 64k page sizes. To be prepared for 64k pages, 280 PPC ELF files are built using an alignment requirement of 64k. 281 However, when running on a kernel supporting 4k pages, the memory 282 mapping of the library may not actually happen on a 64k boundary! 283 284 (In the usual case where (l_addr & align) == 0, this check is 285 equivalent to the possibly expected check above.) 286 287 Even on PPC it must be zero-aligned at least for MINPAGESIZE. */ 288 289 l_addr = l_dynaddr - dynaddr; 290 291 if ((l_addr & (minpagesize - 1)) == 0 292 && (l_addr & align) == ((l_dynaddr - dynaddr) & align)) 293 { 294 if (info_verbose) 295 printf_unfiltered (_("Using PIC (Position Independent Code) " 296 "prelink displacement %s for \"%s\".\n"), 297 paddress (target_gdbarch (), l_addr), 298 so->so_name); 299 } 300 else 301 { 302 /* There is no way to verify the library file matches. prelink 303 can during prelinking of an unprelinked file (or unprelinking 304 of a prelinked file) shift the DYNAMIC segment by arbitrary 305 offset without any page size alignment. There is no way to 306 find out the ELF header and/or Program Headers for a limited 307 verification if it they match. One could do a verification 308 of the DYNAMIC segment. Still the found address is the best 309 one GDB could find. */ 310 311 warning (_(".dynamic section for \"%s\" " 312 "is not at the expected address " 313 "(wrong library or version mismatch?)"), so->so_name); 314 } 315 } 316 317 set_addr: 318 li->l_addr = l_addr; 319 li->l_addr_p = 1; 320 } 321 322 return li->l_addr; 323 } 324 325 /* Per pspace SVR4 specific data. */ 326 327 struct svr4_info 328 { 329 svr4_info () = default; 330 ~svr4_info (); 331 332 /* Base of dynamic linker structures. */ 333 CORE_ADDR debug_base = 0; 334 335 /* Validity flag for debug_loader_offset. */ 336 int debug_loader_offset_p = 0; 337 338 /* Load address for the dynamic linker, inferred. */ 339 CORE_ADDR debug_loader_offset = 0; 340 341 /* Name of the dynamic linker, valid if debug_loader_offset_p. */ 342 char *debug_loader_name = nullptr; 343 344 /* Load map address for the main executable. */ 345 CORE_ADDR main_lm_addr = 0; 346 347 CORE_ADDR interp_text_sect_low = 0; 348 CORE_ADDR interp_text_sect_high = 0; 349 CORE_ADDR interp_plt_sect_low = 0; 350 CORE_ADDR interp_plt_sect_high = 0; 351 352 /* Nonzero if the list of objects was last obtained from the target 353 via qXfer:libraries-svr4:read. */ 354 int using_xfer = 0; 355 356 /* Table of struct probe_and_action instances, used by the 357 probes-based interface to map breakpoint addresses to probes 358 and their associated actions. Lookup is performed using 359 probe_and_action->prob->address. */ 360 htab_up probes_table; 361 362 /* List of objects loaded into the inferior, used by the probes- 363 based interface. */ 364 struct so_list *solib_list = nullptr; 365 }; 366 367 /* Per-program-space data key. */ 368 static const struct program_space_key<svr4_info> solib_svr4_pspace_data; 369 370 /* Free the probes table. */ 371 372 static void 373 free_probes_table (struct svr4_info *info) 374 { 375 info->probes_table.reset (nullptr); 376 } 377 378 /* Free the solib list. */ 379 380 static void 381 free_solib_list (struct svr4_info *info) 382 { 383 svr4_free_library_list (&info->solib_list); 384 info->solib_list = NULL; 385 } 386 387 svr4_info::~svr4_info () 388 { 389 free_solib_list (this); 390 } 391 392 /* Get the svr4 data for program space PSPACE. If none is found yet, add it now. 393 This function always returns a valid object. */ 394 395 static struct svr4_info * 396 get_svr4_info (program_space *pspace) 397 { 398 struct svr4_info *info = solib_svr4_pspace_data.get (pspace); 399 400 if (info == NULL) 401 info = solib_svr4_pspace_data.emplace (pspace); 402 403 return info; 404 } 405 406 /* Local function prototypes */ 407 408 static int match_main (const char *); 409 410 /* Read program header TYPE from inferior memory. The header is found 411 by scanning the OS auxiliary vector. 412 413 If TYPE == -1, return the program headers instead of the contents of 414 one program header. 415 416 Return vector of bytes holding the program header contents, or an empty 417 optional on failure. If successful and P_ARCH_SIZE is non-NULL, the target 418 architecture size (32-bit or 64-bit) is returned to *P_ARCH_SIZE. Likewise, 419 the base address of the section is returned in *BASE_ADDR. */ 420 421 static gdb::optional<gdb::byte_vector> 422 read_program_header (int type, int *p_arch_size, CORE_ADDR *base_addr) 423 { 424 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 425 CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0; 426 int arch_size, sect_size; 427 CORE_ADDR sect_addr; 428 int pt_phdr_p = 0; 429 430 /* Get required auxv elements from target. */ 431 if (target_auxv_search (current_top_target (), AT_PHDR, &at_phdr) <= 0) 432 return {}; 433 if (target_auxv_search (current_top_target (), AT_PHENT, &at_phent) <= 0) 434 return {}; 435 if (target_auxv_search (current_top_target (), AT_PHNUM, &at_phnum) <= 0) 436 return {}; 437 if (!at_phdr || !at_phnum) 438 return {}; 439 440 /* Determine ELF architecture type. */ 441 if (at_phent == sizeof (Elf32_External_Phdr)) 442 arch_size = 32; 443 else if (at_phent == sizeof (Elf64_External_Phdr)) 444 arch_size = 64; 445 else 446 return {}; 447 448 /* Find the requested segment. */ 449 if (type == -1) 450 { 451 sect_addr = at_phdr; 452 sect_size = at_phent * at_phnum; 453 } 454 else if (arch_size == 32) 455 { 456 Elf32_External_Phdr phdr; 457 int i; 458 459 /* Search for requested PHDR. */ 460 for (i = 0; i < at_phnum; i++) 461 { 462 int p_type; 463 464 if (target_read_memory (at_phdr + i * sizeof (phdr), 465 (gdb_byte *)&phdr, sizeof (phdr))) 466 return {}; 467 468 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type, 469 4, byte_order); 470 471 if (p_type == PT_PHDR) 472 { 473 pt_phdr_p = 1; 474 pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr, 475 4, byte_order); 476 } 477 478 if (p_type == type) 479 break; 480 } 481 482 if (i == at_phnum) 483 return {}; 484 485 /* Retrieve address and size. */ 486 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr, 487 4, byte_order); 488 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz, 489 4, byte_order); 490 } 491 else 492 { 493 Elf64_External_Phdr phdr; 494 int i; 495 496 /* Search for requested PHDR. */ 497 for (i = 0; i < at_phnum; i++) 498 { 499 int p_type; 500 501 if (target_read_memory (at_phdr + i * sizeof (phdr), 502 (gdb_byte *)&phdr, sizeof (phdr))) 503 return {}; 504 505 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type, 506 4, byte_order); 507 508 if (p_type == PT_PHDR) 509 { 510 pt_phdr_p = 1; 511 pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr, 512 8, byte_order); 513 } 514 515 if (p_type == type) 516 break; 517 } 518 519 if (i == at_phnum) 520 return {}; 521 522 /* Retrieve address and size. */ 523 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr, 524 8, byte_order); 525 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz, 526 8, byte_order); 527 } 528 529 /* PT_PHDR is optional, but we really need it 530 for PIE to make this work in general. */ 531 532 if (pt_phdr_p) 533 { 534 /* at_phdr is real address in memory. pt_phdr is what pheader says it is. 535 Relocation offset is the difference between the two. */ 536 sect_addr = sect_addr + (at_phdr - pt_phdr); 537 } 538 539 /* Read in requested program header. */ 540 gdb::byte_vector buf (sect_size); 541 if (target_read_memory (sect_addr, buf.data (), sect_size)) 542 return {}; 543 544 #if defined(__NetBSD__) && defined(__m68k__) 545 /* 546 * XXX PR toolchain/56268 547 * 548 * For NetBSD/m68k, program header is erroneously readable from core dump, 549 * although a page containing it is missing. This spoils relocation for 550 * the main executable, and debugging with core dumps becomes impossible, 551 * as described in toolchain/56268. 552 * 553 * In order to avoid this failure, we carry out consistency check for 554 * program header; for NetBSD, 1st entry of program header refers program 555 * header itself. If this is not the case, we should be reading random 556 * garbage from core dump. 557 */ 558 if (type == -1 && arch_size == 32) 559 { 560 Elf32_External_Phdr phdr; 561 int p_type, p_filesz, p_memsz; 562 563 if (target_read_memory (at_phdr, (gdb_byte *)&phdr, sizeof (phdr))) 564 return {}; 565 566 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type, 4, 567 byte_order); 568 p_filesz = extract_unsigned_integer ((gdb_byte *)phdr.p_filesz, 4, 569 byte_order); 570 p_memsz = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz, 4, 571 byte_order); 572 573 if (p_type != PT_PHDR || p_filesz != sect_size || p_memsz != sect_size) 574 return {}; 575 } 576 #endif 577 578 if (p_arch_size) 579 *p_arch_size = arch_size; 580 if (base_addr) 581 *base_addr = sect_addr; 582 583 return buf; 584 } 585 586 587 /* Return program interpreter string. */ 588 static gdb::optional<gdb::byte_vector> 589 find_program_interpreter (void) 590 { 591 /* If we have an exec_bfd, use its section table. */ 592 if (exec_bfd 593 && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour) 594 { 595 struct bfd_section *interp_sect; 596 597 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); 598 if (interp_sect != NULL) 599 { 600 int sect_size = bfd_section_size (interp_sect); 601 602 gdb::byte_vector buf (sect_size); 603 bfd_get_section_contents (exec_bfd, interp_sect, buf.data (), 0, 604 sect_size); 605 return buf; 606 } 607 } 608 609 /* If we didn't find it, use the target auxiliary vector. */ 610 return read_program_header (PT_INTERP, NULL, NULL); 611 } 612 613 614 /* Scan for DESIRED_DYNTAG in .dynamic section of ABFD. If DESIRED_DYNTAG is 615 found, 1 is returned and the corresponding PTR is set. */ 616 617 static int 618 scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr, 619 CORE_ADDR *ptr_addr) 620 { 621 int arch_size, step, sect_size; 622 long current_dyntag; 623 CORE_ADDR dyn_ptr, dyn_addr; 624 gdb_byte *bufend, *bufstart, *buf; 625 Elf32_External_Dyn *x_dynp_32; 626 Elf64_External_Dyn *x_dynp_64; 627 struct bfd_section *sect; 628 struct target_section *target_section; 629 630 if (abfd == NULL) 631 return 0; 632 633 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 634 return 0; 635 636 arch_size = bfd_get_arch_size (abfd); 637 if (arch_size == -1) 638 return 0; 639 640 /* Find the start address of the .dynamic section. */ 641 sect = bfd_get_section_by_name (abfd, ".dynamic"); 642 if (sect == NULL) 643 return 0; 644 645 for (target_section = current_target_sections->sections; 646 target_section < current_target_sections->sections_end; 647 target_section++) 648 if (sect == target_section->the_bfd_section) 649 break; 650 if (target_section < current_target_sections->sections_end) 651 dyn_addr = target_section->addr; 652 else 653 { 654 /* ABFD may come from OBJFILE acting only as a symbol file without being 655 loaded into the target (see add_symbol_file_command). This case is 656 such fallback to the file VMA address without the possibility of 657 having the section relocated to its actual in-memory address. */ 658 659 dyn_addr = bfd_section_vma (sect); 660 } 661 662 /* Read in .dynamic from the BFD. We will get the actual value 663 from memory later. */ 664 sect_size = bfd_section_size (sect); 665 buf = bufstart = (gdb_byte *) alloca (sect_size); 666 if (!bfd_get_section_contents (abfd, sect, 667 buf, 0, sect_size)) 668 return 0; 669 670 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */ 671 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn) 672 : sizeof (Elf64_External_Dyn); 673 for (bufend = buf + sect_size; 674 buf < bufend; 675 buf += step) 676 { 677 if (arch_size == 32) 678 { 679 x_dynp_32 = (Elf32_External_Dyn *) buf; 680 current_dyntag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag); 681 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr); 682 } 683 else 684 { 685 x_dynp_64 = (Elf64_External_Dyn *) buf; 686 current_dyntag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag); 687 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr); 688 } 689 if (current_dyntag == DT_NULL) 690 return 0; 691 if (current_dyntag == desired_dyntag) 692 { 693 /* If requested, try to read the runtime value of this .dynamic 694 entry. */ 695 if (ptr) 696 { 697 struct type *ptr_type; 698 gdb_byte ptr_buf[8]; 699 CORE_ADDR ptr_addr_1; 700 701 ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 702 ptr_addr_1 = dyn_addr + (buf - bufstart) + arch_size / 8; 703 if (target_read_memory (ptr_addr_1, ptr_buf, arch_size / 8) == 0) 704 dyn_ptr = extract_typed_address (ptr_buf, ptr_type); 705 *ptr = dyn_ptr; 706 if (ptr_addr) 707 *ptr_addr = dyn_addr + (buf - bufstart); 708 } 709 return 1; 710 } 711 } 712 713 return 0; 714 } 715 716 /* Scan for DESIRED_DYNTAG in .dynamic section of the target's main executable, 717 found by consulting the OS auxillary vector. If DESIRED_DYNTAG is found, 1 718 is returned and the corresponding PTR is set. */ 719 720 static int 721 scan_dyntag_auxv (const int desired_dyntag, CORE_ADDR *ptr, 722 CORE_ADDR *ptr_addr) 723 { 724 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 725 int arch_size, step; 726 long current_dyntag; 727 CORE_ADDR dyn_ptr; 728 CORE_ADDR base_addr; 729 730 /* Read in .dynamic section. */ 731 gdb::optional<gdb::byte_vector> ph_data 732 = read_program_header (PT_DYNAMIC, &arch_size, &base_addr); 733 if (!ph_data) 734 return 0; 735 736 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */ 737 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn) 738 : sizeof (Elf64_External_Dyn); 739 for (gdb_byte *buf = ph_data->data (), *bufend = buf + ph_data->size (); 740 buf < bufend; buf += step) 741 { 742 if (arch_size == 32) 743 { 744 Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf; 745 746 current_dyntag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag, 747 4, byte_order); 748 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr, 749 4, byte_order); 750 } 751 else 752 { 753 Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf; 754 755 current_dyntag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag, 756 8, byte_order); 757 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr, 758 8, byte_order); 759 } 760 if (current_dyntag == DT_NULL) 761 break; 762 763 if (current_dyntag == desired_dyntag) 764 { 765 if (ptr) 766 *ptr = dyn_ptr; 767 768 if (ptr_addr) 769 *ptr_addr = base_addr + buf - ph_data->data (); 770 771 return 1; 772 } 773 } 774 775 return 0; 776 } 777 778 /* Locate the base address of dynamic linker structs for SVR4 elf 779 targets. 780 781 For SVR4 elf targets the address of the dynamic linker's runtime 782 structure is contained within the dynamic info section in the 783 executable file. The dynamic section is also mapped into the 784 inferior address space. Because the runtime loader fills in the 785 real address before starting the inferior, we have to read in the 786 dynamic info section from the inferior address space. 787 If there are any errors while trying to find the address, we 788 silently return 0, otherwise the found address is returned. */ 789 790 static CORE_ADDR 791 elf_locate_base (void) 792 { 793 struct bound_minimal_symbol msymbol; 794 CORE_ADDR dyn_ptr, dyn_ptr_addr; 795 796 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this 797 instead of DT_DEBUG, although they sometimes contain an unused 798 DT_DEBUG. */ 799 if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr, NULL) 800 || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr, NULL)) 801 { 802 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 803 gdb_byte *pbuf; 804 int pbuf_size = TYPE_LENGTH (ptr_type); 805 806 pbuf = (gdb_byte *) alloca (pbuf_size); 807 /* DT_MIPS_RLD_MAP contains a pointer to the address 808 of the dynamic link structure. */ 809 if (target_read_memory (dyn_ptr, pbuf, pbuf_size)) 810 return 0; 811 return extract_typed_address (pbuf, ptr_type); 812 } 813 814 /* Then check DT_MIPS_RLD_MAP_REL. MIPS executables now use this form 815 because of needing to support PIE. DT_MIPS_RLD_MAP will also exist 816 in non-PIE. */ 817 if (scan_dyntag (DT_MIPS_RLD_MAP_REL, exec_bfd, &dyn_ptr, &dyn_ptr_addr) 818 || scan_dyntag_auxv (DT_MIPS_RLD_MAP_REL, &dyn_ptr, &dyn_ptr_addr)) 819 { 820 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 821 gdb_byte *pbuf; 822 int pbuf_size = TYPE_LENGTH (ptr_type); 823 824 pbuf = (gdb_byte *) alloca (pbuf_size); 825 /* DT_MIPS_RLD_MAP_REL contains an offset from the address of the 826 DT slot to the address of the dynamic link structure. */ 827 if (target_read_memory (dyn_ptr + dyn_ptr_addr, pbuf, pbuf_size)) 828 return 0; 829 return extract_typed_address (pbuf, ptr_type); 830 } 831 832 /* Find DT_DEBUG. */ 833 if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr, NULL) 834 || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr, NULL)) 835 return dyn_ptr; 836 837 /* This may be a static executable. Look for the symbol 838 conventionally named _r_debug, as a last resort. */ 839 msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile); 840 if (msymbol.minsym != NULL) 841 return BMSYMBOL_VALUE_ADDRESS (msymbol); 842 843 /* DT_DEBUG entry not found. */ 844 return 0; 845 } 846 847 /* Locate the base address of dynamic linker structs. 848 849 For both the SunOS and SVR4 shared library implementations, if the 850 inferior executable has been linked dynamically, there is a single 851 address somewhere in the inferior's data space which is the key to 852 locating all of the dynamic linker's runtime structures. This 853 address is the value of the debug base symbol. The job of this 854 function is to find and return that address, or to return 0 if there 855 is no such address (the executable is statically linked for example). 856 857 For SunOS, the job is almost trivial, since the dynamic linker and 858 all of it's structures are statically linked to the executable at 859 link time. Thus the symbol for the address we are looking for has 860 already been added to the minimal symbol table for the executable's 861 objfile at the time the symbol file's symbols were read, and all we 862 have to do is look it up there. Note that we explicitly do NOT want 863 to find the copies in the shared library. 864 865 The SVR4 version is a bit more complicated because the address 866 is contained somewhere in the dynamic info section. We have to go 867 to a lot more work to discover the address of the debug base symbol. 868 Because of this complexity, we cache the value we find and return that 869 value on subsequent invocations. Note there is no copy in the 870 executable symbol tables. */ 871 872 static CORE_ADDR 873 locate_base (struct svr4_info *info) 874 { 875 /* Check to see if we have a currently valid address, and if so, avoid 876 doing all this work again and just return the cached address. If 877 we have no cached address, try to locate it in the dynamic info 878 section for ELF executables. There's no point in doing any of this 879 though if we don't have some link map offsets to work with. */ 880 881 if (info->debug_base == 0 && svr4_have_link_map_offsets ()) 882 info->debug_base = elf_locate_base (); 883 return info->debug_base; 884 } 885 886 /* Find the first element in the inferior's dynamic link map, and 887 return its address in the inferior. Return zero if the address 888 could not be determined. 889 890 FIXME: Perhaps we should validate the info somehow, perhaps by 891 checking r_version for a known version number, or r_state for 892 RT_CONSISTENT. */ 893 894 static CORE_ADDR 895 solib_svr4_r_map (struct svr4_info *info) 896 { 897 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 898 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 899 CORE_ADDR addr = 0; 900 901 try 902 { 903 addr = read_memory_typed_address (info->debug_base + lmo->r_map_offset, 904 ptr_type); 905 } 906 catch (const gdb_exception_error &ex) 907 { 908 exception_print (gdb_stderr, ex); 909 } 910 911 return addr; 912 } 913 914 /* Find r_brk from the inferior's debug base. */ 915 916 static CORE_ADDR 917 solib_svr4_r_brk (struct svr4_info *info) 918 { 919 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 920 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 921 922 return read_memory_typed_address (info->debug_base + lmo->r_brk_offset, 923 ptr_type); 924 } 925 926 /* Find the link map for the dynamic linker (if it is not in the 927 normal list of loaded shared objects). */ 928 929 static CORE_ADDR 930 solib_svr4_r_ldsomap (struct svr4_info *info) 931 { 932 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 933 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 934 enum bfd_endian byte_order = type_byte_order (ptr_type); 935 ULONGEST version = 0; 936 937 try 938 { 939 /* Check version, and return zero if `struct r_debug' doesn't have 940 the r_ldsomap member. */ 941 version 942 = read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset, 943 lmo->r_version_size, byte_order); 944 } 945 catch (const gdb_exception_error &ex) 946 { 947 exception_print (gdb_stderr, ex); 948 } 949 950 if (version < 2 || lmo->r_ldsomap_offset == -1) 951 return 0; 952 953 return read_memory_typed_address (info->debug_base + lmo->r_ldsomap_offset, 954 ptr_type); 955 } 956 957 /* On Solaris systems with some versions of the dynamic linker, 958 ld.so's l_name pointer points to the SONAME in the string table 959 rather than into writable memory. So that GDB can find shared 960 libraries when loading a core file generated by gcore, ensure that 961 memory areas containing the l_name string are saved in the core 962 file. */ 963 964 static int 965 svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size) 966 { 967 struct svr4_info *info; 968 CORE_ADDR ldsomap; 969 CORE_ADDR name_lm; 970 971 info = get_svr4_info (current_program_space); 972 973 info->debug_base = 0; 974 locate_base (info); 975 if (!info->debug_base) 976 return 0; 977 978 ldsomap = solib_svr4_r_ldsomap (info); 979 if (!ldsomap) 980 return 0; 981 982 std::unique_ptr<lm_info_svr4> li = lm_info_read (ldsomap); 983 name_lm = li != NULL ? li->l_name : 0; 984 985 return (name_lm >= vaddr && name_lm < vaddr + size); 986 } 987 988 /* See solist.h. */ 989 990 static int 991 open_symbol_file_object (int from_tty) 992 { 993 CORE_ADDR lm, l_name; 994 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 995 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 996 int l_name_size = TYPE_LENGTH (ptr_type); 997 gdb::byte_vector l_name_buf (l_name_size); 998 struct svr4_info *info = get_svr4_info (current_program_space); 999 symfile_add_flags add_flags = 0; 1000 1001 if (from_tty) 1002 add_flags |= SYMFILE_VERBOSE; 1003 1004 if (symfile_objfile) 1005 if (!query (_("Attempt to reload symbols from process? "))) 1006 return 0; 1007 1008 /* Always locate the debug struct, in case it has moved. */ 1009 info->debug_base = 0; 1010 if (locate_base (info) == 0) 1011 return 0; /* failed somehow... */ 1012 1013 /* First link map member should be the executable. */ 1014 lm = solib_svr4_r_map (info); 1015 if (lm == 0) 1016 return 0; /* failed somehow... */ 1017 1018 /* Read address of name from target memory to GDB. */ 1019 read_memory (lm + lmo->l_name_offset, l_name_buf.data (), l_name_size); 1020 1021 /* Convert the address to host format. */ 1022 l_name = extract_typed_address (l_name_buf.data (), ptr_type); 1023 1024 if (l_name == 0) 1025 return 0; /* No filename. */ 1026 1027 /* Now fetch the filename from target memory. */ 1028 gdb::unique_xmalloc_ptr<char> filename 1029 = target_read_string (l_name, SO_NAME_MAX_PATH_SIZE - 1); 1030 1031 if (filename == nullptr) 1032 { 1033 warning (_("failed to read exec filename from attached file")); 1034 return 0; 1035 } 1036 1037 /* Have a pathname: read the symbol file. */ 1038 symbol_file_add_main (filename.get (), add_flags); 1039 1040 return 1; 1041 } 1042 1043 /* Data exchange structure for the XML parser as returned by 1044 svr4_current_sos_via_xfer_libraries. */ 1045 1046 struct svr4_library_list 1047 { 1048 struct so_list *head, **tailp; 1049 1050 /* Inferior address of struct link_map used for the main executable. It is 1051 NULL if not known. */ 1052 CORE_ADDR main_lm; 1053 }; 1054 1055 /* This module's 'free_objfile' observer. */ 1056 1057 static void 1058 svr4_free_objfile_observer (struct objfile *objfile) 1059 { 1060 probes_table_remove_objfile_probes (objfile); 1061 } 1062 1063 /* Implementation for target_so_ops.free_so. */ 1064 1065 static void 1066 svr4_free_so (struct so_list *so) 1067 { 1068 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; 1069 1070 delete li; 1071 } 1072 1073 /* Implement target_so_ops.clear_so. */ 1074 1075 static void 1076 svr4_clear_so (struct so_list *so) 1077 { 1078 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; 1079 1080 if (li != NULL) 1081 li->l_addr_p = 0; 1082 } 1083 1084 /* Free so_list built so far (called via cleanup). */ 1085 1086 static void 1087 svr4_free_library_list (void *p_list) 1088 { 1089 struct so_list *list = *(struct so_list **) p_list; 1090 1091 while (list != NULL) 1092 { 1093 struct so_list *next = list->next; 1094 1095 free_so (list); 1096 list = next; 1097 } 1098 } 1099 1100 /* Copy library list. */ 1101 1102 static struct so_list * 1103 svr4_copy_library_list (struct so_list *src) 1104 { 1105 struct so_list *dst = NULL; 1106 struct so_list **link = &dst; 1107 1108 while (src != NULL) 1109 { 1110 struct so_list *newobj; 1111 1112 newobj = XNEW (struct so_list); 1113 memcpy (newobj, src, sizeof (struct so_list)); 1114 1115 lm_info_svr4 *src_li = (lm_info_svr4 *) src->lm_info; 1116 newobj->lm_info = new lm_info_svr4 (*src_li); 1117 1118 newobj->next = NULL; 1119 *link = newobj; 1120 link = &newobj->next; 1121 1122 src = src->next; 1123 } 1124 1125 return dst; 1126 } 1127 1128 #ifdef HAVE_LIBEXPAT 1129 1130 #include "xml-support.h" 1131 1132 /* Handle the start of a <library> element. Note: new elements are added 1133 at the tail of the list, keeping the list in order. */ 1134 1135 static void 1136 library_list_start_library (struct gdb_xml_parser *parser, 1137 const struct gdb_xml_element *element, 1138 void *user_data, 1139 std::vector<gdb_xml_value> &attributes) 1140 { 1141 struct svr4_library_list *list = (struct svr4_library_list *) user_data; 1142 const char *name 1143 = (const char *) xml_find_attribute (attributes, "name")->value.get (); 1144 ULONGEST *lmp 1145 = (ULONGEST *) xml_find_attribute (attributes, "lm")->value.get (); 1146 ULONGEST *l_addrp 1147 = (ULONGEST *) xml_find_attribute (attributes, "l_addr")->value.get (); 1148 ULONGEST *l_ldp 1149 = (ULONGEST *) xml_find_attribute (attributes, "l_ld")->value.get (); 1150 struct so_list *new_elem; 1151 1152 new_elem = XCNEW (struct so_list); 1153 lm_info_svr4 *li = new lm_info_svr4; 1154 new_elem->lm_info = li; 1155 li->lm_addr = *lmp; 1156 li->l_addr_inferior = *l_addrp; 1157 li->l_ld = *l_ldp; 1158 1159 strncpy (new_elem->so_name, name, sizeof (new_elem->so_name) - 1); 1160 new_elem->so_name[sizeof (new_elem->so_name) - 1] = 0; 1161 strcpy (new_elem->so_original_name, new_elem->so_name); 1162 1163 *list->tailp = new_elem; 1164 list->tailp = &new_elem->next; 1165 } 1166 1167 /* Handle the start of a <library-list-svr4> element. */ 1168 1169 static void 1170 svr4_library_list_start_list (struct gdb_xml_parser *parser, 1171 const struct gdb_xml_element *element, 1172 void *user_data, 1173 std::vector<gdb_xml_value> &attributes) 1174 { 1175 struct svr4_library_list *list = (struct svr4_library_list *) user_data; 1176 const char *version 1177 = (const char *) xml_find_attribute (attributes, "version")->value.get (); 1178 struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm"); 1179 1180 if (strcmp (version, "1.0") != 0) 1181 gdb_xml_error (parser, 1182 _("SVR4 Library list has unsupported version \"%s\""), 1183 version); 1184 1185 if (main_lm) 1186 list->main_lm = *(ULONGEST *) main_lm->value.get (); 1187 } 1188 1189 /* The allowed elements and attributes for an XML library list. 1190 The root element is a <library-list>. */ 1191 1192 static const struct gdb_xml_attribute svr4_library_attributes[] = 1193 { 1194 { "name", GDB_XML_AF_NONE, NULL, NULL }, 1195 { "lm", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL }, 1196 { "l_addr", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL }, 1197 { "l_ld", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL }, 1198 { NULL, GDB_XML_AF_NONE, NULL, NULL } 1199 }; 1200 1201 static const struct gdb_xml_element svr4_library_list_children[] = 1202 { 1203 { 1204 "library", svr4_library_attributes, NULL, 1205 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL, 1206 library_list_start_library, NULL 1207 }, 1208 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 1209 }; 1210 1211 static const struct gdb_xml_attribute svr4_library_list_attributes[] = 1212 { 1213 { "version", GDB_XML_AF_NONE, NULL, NULL }, 1214 { "main-lm", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL }, 1215 { NULL, GDB_XML_AF_NONE, NULL, NULL } 1216 }; 1217 1218 static const struct gdb_xml_element svr4_library_list_elements[] = 1219 { 1220 { "library-list-svr4", svr4_library_list_attributes, svr4_library_list_children, 1221 GDB_XML_EF_NONE, svr4_library_list_start_list, NULL }, 1222 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } 1223 }; 1224 1225 /* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if 1226 1227 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such 1228 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be 1229 empty, caller is responsible for freeing all its entries. */ 1230 1231 static int 1232 svr4_parse_libraries (const char *document, struct svr4_library_list *list) 1233 { 1234 auto cleanup = make_scope_exit ([&] () 1235 { 1236 svr4_free_library_list (&list->head); 1237 }); 1238 1239 memset (list, 0, sizeof (*list)); 1240 list->tailp = &list->head; 1241 if (gdb_xml_parse_quick (_("target library list"), "library-list-svr4.dtd", 1242 svr4_library_list_elements, document, list) == 0) 1243 { 1244 /* Parsed successfully, keep the result. */ 1245 cleanup.release (); 1246 return 1; 1247 } 1248 1249 return 0; 1250 } 1251 1252 /* Attempt to get so_list from target via qXfer:libraries-svr4:read packet. 1253 1254 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such 1255 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be 1256 empty, caller is responsible for freeing all its entries. 1257 1258 Note that ANNEX must be NULL if the remote does not explicitly allow 1259 qXfer:libraries-svr4:read packets with non-empty annexes. Support for 1260 this can be checked using target_augmented_libraries_svr4_read (). */ 1261 1262 static int 1263 svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list, 1264 const char *annex) 1265 { 1266 gdb_assert (annex == NULL || target_augmented_libraries_svr4_read ()); 1267 1268 /* Fetch the list of shared libraries. */ 1269 gdb::optional<gdb::char_vector> svr4_library_document 1270 = target_read_stralloc (current_top_target (), TARGET_OBJECT_LIBRARIES_SVR4, 1271 annex); 1272 if (!svr4_library_document) 1273 return 0; 1274 1275 return svr4_parse_libraries (svr4_library_document->data (), list); 1276 } 1277 1278 #else 1279 1280 static int 1281 svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list, 1282 const char *annex) 1283 { 1284 return 0; 1285 } 1286 1287 #endif 1288 1289 /* If no shared library information is available from the dynamic 1290 linker, build a fallback list from other sources. */ 1291 1292 static struct so_list * 1293 svr4_default_sos (svr4_info *info) 1294 { 1295 struct so_list *newobj; 1296 1297 if (!info->debug_loader_offset_p) 1298 return NULL; 1299 1300 newobj = XCNEW (struct so_list); 1301 lm_info_svr4 *li = new lm_info_svr4; 1302 newobj->lm_info = li; 1303 1304 /* Nothing will ever check the other fields if we set l_addr_p. */ 1305 li->l_addr = info->debug_loader_offset; 1306 li->l_addr_p = 1; 1307 1308 strncpy (newobj->so_name, info->debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1); 1309 newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; 1310 strcpy (newobj->so_original_name, newobj->so_name); 1311 1312 return newobj; 1313 } 1314 1315 /* Read the whole inferior libraries chain starting at address LM. 1316 Expect the first entry in the chain's previous entry to be PREV_LM. 1317 Add the entries to the tail referenced by LINK_PTR_PTR. Ignore the 1318 first entry if IGNORE_FIRST and set global MAIN_LM_ADDR according 1319 to it. Returns nonzero upon success. If zero is returned the 1320 entries stored to LINK_PTR_PTR are still valid although they may 1321 represent only part of the inferior library list. */ 1322 1323 static int 1324 svr4_read_so_list (svr4_info *info, CORE_ADDR lm, CORE_ADDR prev_lm, 1325 struct so_list ***link_ptr_ptr, int ignore_first) 1326 { 1327 CORE_ADDR first_l_name = 0; 1328 CORE_ADDR next_lm; 1329 1330 for (; lm != 0; prev_lm = lm, lm = next_lm) 1331 { 1332 so_list_up newobj (XCNEW (struct so_list)); 1333 1334 lm_info_svr4 *li = lm_info_read (lm).release (); 1335 newobj->lm_info = li; 1336 if (li == NULL) 1337 return 0; 1338 1339 next_lm = li->l_next; 1340 1341 if (li->l_prev != prev_lm) 1342 { 1343 warning (_("Corrupted shared library list: %s != %s"), 1344 paddress (target_gdbarch (), prev_lm), 1345 paddress (target_gdbarch (), li->l_prev)); 1346 return 0; 1347 } 1348 1349 /* For SVR4 versions, the first entry in the link map is for the 1350 inferior executable, so we must ignore it. For some versions of 1351 SVR4, it has no name. For others (Solaris 2.3 for example), it 1352 does have a name, so we can no longer use a missing name to 1353 decide when to ignore it. */ 1354 if (ignore_first && li->l_prev == 0) 1355 { 1356 first_l_name = li->l_name; 1357 info->main_lm_addr = li->lm_addr; 1358 continue; 1359 } 1360 1361 /* Extract this shared object's name. */ 1362 gdb::unique_xmalloc_ptr<char> buffer 1363 = target_read_string (li->l_name, SO_NAME_MAX_PATH_SIZE - 1); 1364 if (buffer == nullptr) 1365 { 1366 /* If this entry's l_name address matches that of the 1367 inferior executable, then this is not a normal shared 1368 object, but (most likely) a vDSO. In this case, silently 1369 skip it; otherwise emit a warning. */ 1370 if (first_l_name == 0 || li->l_name != first_l_name) 1371 warning (_("Can't read pathname for load map.")); 1372 continue; 1373 } 1374 1375 strncpy (newobj->so_name, buffer.get (), SO_NAME_MAX_PATH_SIZE - 1); 1376 newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; 1377 strcpy (newobj->so_original_name, newobj->so_name); 1378 1379 /* If this entry has no name, or its name matches the name 1380 for the main executable, don't include it in the list. */ 1381 if (! newobj->so_name[0] || match_main (newobj->so_name)) 1382 continue; 1383 1384 newobj->next = 0; 1385 /* Don't free it now. */ 1386 **link_ptr_ptr = newobj.release (); 1387 *link_ptr_ptr = &(**link_ptr_ptr)->next; 1388 } 1389 1390 return 1; 1391 } 1392 1393 /* Read the full list of currently loaded shared objects directly 1394 from the inferior, without referring to any libraries read and 1395 stored by the probes interface. Handle special cases relating 1396 to the first elements of the list. */ 1397 1398 static struct so_list * 1399 svr4_current_sos_direct (struct svr4_info *info) 1400 { 1401 CORE_ADDR lm; 1402 struct so_list *head = NULL; 1403 struct so_list **link_ptr = &head; 1404 int ignore_first; 1405 struct svr4_library_list library_list; 1406 1407 /* Fall back to manual examination of the target if the packet is not 1408 supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp 1409 tests a case where gdbserver cannot find the shared libraries list while 1410 GDB itself is able to find it via SYMFILE_OBJFILE. 1411 1412 Unfortunately statically linked inferiors will also fall back through this 1413 suboptimal code path. */ 1414 1415 info->using_xfer = svr4_current_sos_via_xfer_libraries (&library_list, 1416 NULL); 1417 if (info->using_xfer) 1418 { 1419 if (library_list.main_lm) 1420 info->main_lm_addr = library_list.main_lm; 1421 1422 return library_list.head ? library_list.head : svr4_default_sos (info); 1423 } 1424 1425 /* Always locate the debug struct, in case it has moved. */ 1426 info->debug_base = 0; 1427 locate_base (info); 1428 1429 /* If we can't find the dynamic linker's base structure, this 1430 must not be a dynamically linked executable. Hmm. */ 1431 if (! info->debug_base) 1432 return svr4_default_sos (info); 1433 1434 /* Assume that everything is a library if the dynamic loader was loaded 1435 late by a static executable. */ 1436 if (exec_bfd && bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL) 1437 ignore_first = 0; 1438 else 1439 ignore_first = 1; 1440 1441 auto cleanup = make_scope_exit ([&] () 1442 { 1443 svr4_free_library_list (&head); 1444 }); 1445 1446 /* Walk the inferior's link map list, and build our list of 1447 `struct so_list' nodes. */ 1448 lm = solib_svr4_r_map (info); 1449 if (lm) 1450 svr4_read_so_list (info, lm, 0, &link_ptr, ignore_first); 1451 1452 /* On Solaris, the dynamic linker is not in the normal list of 1453 shared objects, so make sure we pick it up too. Having 1454 symbol information for the dynamic linker is quite crucial 1455 for skipping dynamic linker resolver code. */ 1456 lm = solib_svr4_r_ldsomap (info); 1457 if (lm) 1458 svr4_read_so_list (info, lm, 0, &link_ptr, 0); 1459 1460 cleanup.release (); 1461 1462 if (head == NULL) 1463 return svr4_default_sos (info); 1464 1465 return head; 1466 } 1467 1468 /* Implement the main part of the "current_sos" target_so_ops 1469 method. */ 1470 1471 static struct so_list * 1472 svr4_current_sos_1 (svr4_info *info) 1473 { 1474 /* If the solib list has been read and stored by the probes 1475 interface then we return a copy of the stored list. */ 1476 if (info->solib_list != NULL) 1477 return svr4_copy_library_list (info->solib_list); 1478 1479 /* Otherwise obtain the solib list directly from the inferior. */ 1480 return svr4_current_sos_direct (info); 1481 } 1482 1483 /* Implement the "current_sos" target_so_ops method. */ 1484 1485 static struct so_list * 1486 svr4_current_sos (void) 1487 { 1488 svr4_info *info = get_svr4_info (current_program_space); 1489 struct so_list *so_head = svr4_current_sos_1 (info); 1490 struct mem_range vsyscall_range; 1491 1492 /* Filter out the vDSO module, if present. Its symbol file would 1493 not be found on disk. The vDSO/vsyscall's OBJFILE is instead 1494 managed by symfile-mem.c:add_vsyscall_page. */ 1495 if (gdbarch_vsyscall_range (target_gdbarch (), &vsyscall_range) 1496 && vsyscall_range.length != 0) 1497 { 1498 struct so_list **sop; 1499 1500 sop = &so_head; 1501 while (*sop != NULL) 1502 { 1503 struct so_list *so = *sop; 1504 1505 /* We can't simply match the vDSO by starting address alone, 1506 because lm_info->l_addr_inferior (and also l_addr) do not 1507 necessarily represent the real starting address of the 1508 ELF if the vDSO's ELF itself is "prelinked". The l_ld 1509 field (the ".dynamic" section of the shared object) 1510 always points at the absolute/resolved address though. 1511 So check whether that address is inside the vDSO's 1512 mapping instead. 1513 1514 E.g., on Linux 3.16 (x86_64) the vDSO is a regular 1515 0-based ELF, and we see: 1516 1517 (gdb) info auxv 1518 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffb000 1519 (gdb) p/x *_r_debug.r_map.l_next 1520 $1 = {l_addr = 0x7ffff7ffb000, ..., l_ld = 0x7ffff7ffb318, ...} 1521 1522 And on Linux 2.6.32 (x86_64) we see: 1523 1524 (gdb) info auxv 1525 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffe000 1526 (gdb) p/x *_r_debug.r_map.l_next 1527 $5 = {l_addr = 0x7ffff88fe000, ..., l_ld = 0x7ffff7ffe580, ... } 1528 1529 Dumping that vDSO shows: 1530 1531 (gdb) info proc mappings 1532 0x7ffff7ffe000 0x7ffff7fff000 0x1000 0 [vdso] 1533 (gdb) dump memory vdso.bin 0x7ffff7ffe000 0x7ffff7fff000 1534 # readelf -Wa vdso.bin 1535 [...] 1536 Entry point address: 0xffffffffff700700 1537 [...] 1538 Section Headers: 1539 [Nr] Name Type Address Off Size 1540 [ 0] NULL 0000000000000000 000000 000000 1541 [ 1] .hash HASH ffffffffff700120 000120 000038 1542 [ 2] .dynsym DYNSYM ffffffffff700158 000158 0000d8 1543 [...] 1544 [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0 1545 */ 1546 1547 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; 1548 1549 if (address_in_mem_range (li->l_ld, &vsyscall_range)) 1550 { 1551 *sop = so->next; 1552 free_so (so); 1553 break; 1554 } 1555 1556 sop = &so->next; 1557 } 1558 } 1559 1560 return so_head; 1561 } 1562 1563 /* Get the address of the link_map for a given OBJFILE. */ 1564 1565 CORE_ADDR 1566 svr4_fetch_objfile_link_map (struct objfile *objfile) 1567 { 1568 struct svr4_info *info = get_svr4_info (objfile->pspace); 1569 1570 /* Cause svr4_current_sos() to be run if it hasn't been already. */ 1571 if (info->main_lm_addr == 0) 1572 solib_add (NULL, 0, auto_solib_add); 1573 1574 /* svr4_current_sos() will set main_lm_addr for the main executable. */ 1575 if (objfile == symfile_objfile) 1576 return info->main_lm_addr; 1577 1578 /* If OBJFILE is a separate debug object file, look for the 1579 original object file. */ 1580 if (objfile->separate_debug_objfile_backlink != NULL) 1581 objfile = objfile->separate_debug_objfile_backlink; 1582 1583 /* The other link map addresses may be found by examining the list 1584 of shared libraries. */ 1585 for (struct so_list *so : current_program_space->solibs ()) 1586 if (so->objfile == objfile) 1587 { 1588 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; 1589 1590 return li->lm_addr; 1591 } 1592 1593 /* Not found! */ 1594 return 0; 1595 } 1596 1597 /* On some systems, the only way to recognize the link map entry for 1598 the main executable file is by looking at its name. Return 1599 non-zero iff SONAME matches one of the known main executable names. */ 1600 1601 static int 1602 match_main (const char *soname) 1603 { 1604 const char * const *mainp; 1605 1606 for (mainp = main_name_list; *mainp != NULL; mainp++) 1607 { 1608 if (strcmp (soname, *mainp) == 0) 1609 return (1); 1610 } 1611 1612 return (0); 1613 } 1614 1615 /* Return 1 if PC lies in the dynamic symbol resolution code of the 1616 SVR4 run time loader. */ 1617 1618 int 1619 svr4_in_dynsym_resolve_code (CORE_ADDR pc) 1620 { 1621 struct svr4_info *info = get_svr4_info (current_program_space); 1622 1623 return ((pc >= info->interp_text_sect_low 1624 && pc < info->interp_text_sect_high) 1625 || (pc >= info->interp_plt_sect_low 1626 && pc < info->interp_plt_sect_high) 1627 || in_plt_section (pc) 1628 || in_gnu_ifunc_stub (pc)); 1629 } 1630 1631 /* Given an executable's ABFD and target, compute the entry-point 1632 address. */ 1633 1634 static CORE_ADDR 1635 exec_entry_point (struct bfd *abfd, struct target_ops *targ) 1636 { 1637 CORE_ADDR addr; 1638 1639 /* KevinB wrote ... for most targets, the address returned by 1640 bfd_get_start_address() is the entry point for the start 1641 function. But, for some targets, bfd_get_start_address() returns 1642 the address of a function descriptor from which the entry point 1643 address may be extracted. This address is extracted by 1644 gdbarch_convert_from_func_ptr_addr(). The method 1645 gdbarch_convert_from_func_ptr_addr() is the merely the identify 1646 function for targets which don't use function descriptors. */ 1647 addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), 1648 bfd_get_start_address (abfd), 1649 targ); 1650 return gdbarch_addr_bits_remove (target_gdbarch (), addr); 1651 } 1652 1653 /* A probe and its associated action. */ 1654 1655 struct probe_and_action 1656 { 1657 /* The probe. */ 1658 probe *prob; 1659 1660 /* The relocated address of the probe. */ 1661 CORE_ADDR address; 1662 1663 /* The action. */ 1664 enum probe_action action; 1665 1666 /* The objfile where this probe was found. */ 1667 struct objfile *objfile; 1668 }; 1669 1670 /* Returns a hash code for the probe_and_action referenced by p. */ 1671 1672 static hashval_t 1673 hash_probe_and_action (const void *p) 1674 { 1675 const struct probe_and_action *pa = (const struct probe_and_action *) p; 1676 1677 return (hashval_t) pa->address; 1678 } 1679 1680 /* Returns non-zero if the probe_and_actions referenced by p1 and p2 1681 are equal. */ 1682 1683 static int 1684 equal_probe_and_action (const void *p1, const void *p2) 1685 { 1686 const struct probe_and_action *pa1 = (const struct probe_and_action *) p1; 1687 const struct probe_and_action *pa2 = (const struct probe_and_action *) p2; 1688 1689 return pa1->address == pa2->address; 1690 } 1691 1692 /* Traversal function for probes_table_remove_objfile_probes. */ 1693 1694 static int 1695 probes_table_htab_remove_objfile_probes (void **slot, void *info) 1696 { 1697 probe_and_action *pa = (probe_and_action *) *slot; 1698 struct objfile *objfile = (struct objfile *) info; 1699 1700 if (pa->objfile == objfile) 1701 htab_clear_slot (get_svr4_info (objfile->pspace)->probes_table.get (), 1702 slot); 1703 1704 return 1; 1705 } 1706 1707 /* Remove all probes that belong to OBJFILE from the probes table. */ 1708 1709 static void 1710 probes_table_remove_objfile_probes (struct objfile *objfile) 1711 { 1712 svr4_info *info = get_svr4_info (objfile->pspace); 1713 if (info->probes_table != nullptr) 1714 htab_traverse_noresize (info->probes_table.get (), 1715 probes_table_htab_remove_objfile_probes, objfile); 1716 } 1717 1718 /* Register a solib event probe and its associated action in the 1719 probes table. */ 1720 1721 static void 1722 register_solib_event_probe (svr4_info *info, struct objfile *objfile, 1723 probe *prob, CORE_ADDR address, 1724 enum probe_action action) 1725 { 1726 struct probe_and_action lookup, *pa; 1727 void **slot; 1728 1729 /* Create the probes table, if necessary. */ 1730 if (info->probes_table == NULL) 1731 info->probes_table.reset (htab_create_alloc (1, hash_probe_and_action, 1732 equal_probe_and_action, 1733 xfree, xcalloc, xfree)); 1734 1735 lookup.address = address; 1736 slot = htab_find_slot (info->probes_table.get (), &lookup, INSERT); 1737 gdb_assert (*slot == HTAB_EMPTY_ENTRY); 1738 1739 pa = XCNEW (struct probe_and_action); 1740 pa->prob = prob; 1741 pa->address = address; 1742 pa->action = action; 1743 pa->objfile = objfile; 1744 1745 *slot = pa; 1746 } 1747 1748 /* Get the solib event probe at the specified location, and the 1749 action associated with it. Returns NULL if no solib event probe 1750 was found. */ 1751 1752 static struct probe_and_action * 1753 solib_event_probe_at (struct svr4_info *info, CORE_ADDR address) 1754 { 1755 struct probe_and_action lookup; 1756 void **slot; 1757 1758 lookup.address = address; 1759 slot = htab_find_slot (info->probes_table.get (), &lookup, NO_INSERT); 1760 1761 if (slot == NULL) 1762 return NULL; 1763 1764 return (struct probe_and_action *) *slot; 1765 } 1766 1767 /* Decide what action to take when the specified solib event probe is 1768 hit. */ 1769 1770 static enum probe_action 1771 solib_event_probe_action (struct probe_and_action *pa) 1772 { 1773 enum probe_action action; 1774 unsigned probe_argc = 0; 1775 struct frame_info *frame = get_current_frame (); 1776 1777 action = pa->action; 1778 if (action == DO_NOTHING || action == PROBES_INTERFACE_FAILED) 1779 return action; 1780 1781 gdb_assert (action == FULL_RELOAD || action == UPDATE_OR_RELOAD); 1782 1783 /* Check that an appropriate number of arguments has been supplied. 1784 We expect: 1785 arg0: Lmid_t lmid (mandatory) 1786 arg1: struct r_debug *debug_base (mandatory) 1787 arg2: struct link_map *new (optional, for incremental updates) */ 1788 try 1789 { 1790 probe_argc = pa->prob->get_argument_count (get_frame_arch (frame)); 1791 } 1792 catch (const gdb_exception_error &ex) 1793 { 1794 exception_print (gdb_stderr, ex); 1795 probe_argc = 0; 1796 } 1797 1798 /* If get_argument_count throws an exception, probe_argc will be set 1799 to zero. However, if pa->prob does not have arguments, then 1800 get_argument_count will succeed but probe_argc will also be zero. 1801 Both cases happen because of different things, but they are 1802 treated equally here: action will be set to 1803 PROBES_INTERFACE_FAILED. */ 1804 if (probe_argc == 2) 1805 action = FULL_RELOAD; 1806 else if (probe_argc < 2) 1807 action = PROBES_INTERFACE_FAILED; 1808 1809 return action; 1810 } 1811 1812 /* Populate the shared object list by reading the entire list of 1813 shared objects from the inferior. Handle special cases relating 1814 to the first elements of the list. Returns nonzero on success. */ 1815 1816 static int 1817 solist_update_full (struct svr4_info *info) 1818 { 1819 free_solib_list (info); 1820 info->solib_list = svr4_current_sos_direct (info); 1821 1822 return 1; 1823 } 1824 1825 /* Update the shared object list starting from the link-map entry 1826 passed by the linker in the probe's third argument. Returns 1827 nonzero if the list was successfully updated, or zero to indicate 1828 failure. */ 1829 1830 static int 1831 solist_update_incremental (struct svr4_info *info, CORE_ADDR lm) 1832 { 1833 struct so_list *tail; 1834 CORE_ADDR prev_lm; 1835 1836 /* svr4_current_sos_direct contains logic to handle a number of 1837 special cases relating to the first elements of the list. To 1838 avoid duplicating this logic we defer to solist_update_full 1839 if the list is empty. */ 1840 if (info->solib_list == NULL) 1841 return 0; 1842 1843 /* Fall back to a full update if we are using a remote target 1844 that does not support incremental transfers. */ 1845 if (info->using_xfer && !target_augmented_libraries_svr4_read ()) 1846 return 0; 1847 1848 /* Walk to the end of the list. */ 1849 for (tail = info->solib_list; tail->next != NULL; tail = tail->next) 1850 /* Nothing. */; 1851 1852 lm_info_svr4 *li = (lm_info_svr4 *) tail->lm_info; 1853 prev_lm = li->lm_addr; 1854 1855 /* Read the new objects. */ 1856 if (info->using_xfer) 1857 { 1858 struct svr4_library_list library_list; 1859 char annex[64]; 1860 1861 xsnprintf (annex, sizeof (annex), "start=%s;prev=%s", 1862 phex_nz (lm, sizeof (lm)), 1863 phex_nz (prev_lm, sizeof (prev_lm))); 1864 if (!svr4_current_sos_via_xfer_libraries (&library_list, annex)) 1865 return 0; 1866 1867 tail->next = library_list.head; 1868 } 1869 else 1870 { 1871 struct so_list **link = &tail->next; 1872 1873 /* IGNORE_FIRST may safely be set to zero here because the 1874 above check and deferral to solist_update_full ensures 1875 that this call to svr4_read_so_list will never see the 1876 first element. */ 1877 if (!svr4_read_so_list (info, lm, prev_lm, &link, 0)) 1878 return 0; 1879 } 1880 1881 return 1; 1882 } 1883 1884 /* Disable the probes-based linker interface and revert to the 1885 original interface. We don't reset the breakpoints as the 1886 ones set up for the probes-based interface are adequate. */ 1887 1888 static void 1889 disable_probes_interface (svr4_info *info) 1890 { 1891 warning (_("Probes-based dynamic linker interface failed.\n" 1892 "Reverting to original interface.")); 1893 1894 free_probes_table (info); 1895 free_solib_list (info); 1896 } 1897 1898 /* Update the solib list as appropriate when using the 1899 probes-based linker interface. Do nothing if using the 1900 standard interface. */ 1901 1902 static void 1903 svr4_handle_solib_event (void) 1904 { 1905 struct svr4_info *info = get_svr4_info (current_program_space); 1906 struct probe_and_action *pa; 1907 enum probe_action action; 1908 struct value *val = NULL; 1909 CORE_ADDR pc, debug_base, lm = 0; 1910 struct frame_info *frame = get_current_frame (); 1911 1912 /* Do nothing if not using the probes interface. */ 1913 if (info->probes_table == NULL) 1914 return; 1915 1916 /* If anything goes wrong we revert to the original linker 1917 interface. */ 1918 auto cleanup = make_scope_exit ([info] () 1919 { 1920 disable_probes_interface (info); 1921 }); 1922 1923 pc = regcache_read_pc (get_current_regcache ()); 1924 pa = solib_event_probe_at (info, pc); 1925 if (pa == NULL) 1926 return; 1927 1928 action = solib_event_probe_action (pa); 1929 if (action == PROBES_INTERFACE_FAILED) 1930 return; 1931 1932 if (action == DO_NOTHING) 1933 { 1934 cleanup.release (); 1935 return; 1936 } 1937 1938 /* evaluate_argument looks up symbols in the dynamic linker 1939 using find_pc_section. find_pc_section is accelerated by a cache 1940 called the section map. The section map is invalidated every 1941 time a shared library is loaded or unloaded, and if the inferior 1942 is generating a lot of shared library events then the section map 1943 will be updated every time svr4_handle_solib_event is called. 1944 We called find_pc_section in svr4_create_solib_event_breakpoints, 1945 so we can guarantee that the dynamic linker's sections are in the 1946 section map. We can therefore inhibit section map updates across 1947 these calls to evaluate_argument and save a lot of time. */ 1948 { 1949 scoped_restore inhibit_updates 1950 = inhibit_section_map_updates (current_program_space); 1951 1952 try 1953 { 1954 val = pa->prob->evaluate_argument (1, frame); 1955 } 1956 catch (const gdb_exception_error &ex) 1957 { 1958 exception_print (gdb_stderr, ex); 1959 val = NULL; 1960 } 1961 1962 if (val == NULL) 1963 return; 1964 1965 debug_base = value_as_address (val); 1966 if (debug_base == 0) 1967 return; 1968 1969 /* Always locate the debug struct, in case it moved. */ 1970 info->debug_base = 0; 1971 if (locate_base (info) == 0) 1972 { 1973 /* It's possible for the reloc_complete probe to be triggered before 1974 the linker has set the DT_DEBUG pointer (for example, when the 1975 linker has finished relocating an LD_AUDIT library or its 1976 dependencies). Since we can't yet handle libraries from other link 1977 namespaces, we don't lose anything by ignoring them here. */ 1978 struct value *link_map_id_val; 1979 try 1980 { 1981 link_map_id_val = pa->prob->evaluate_argument (0, frame); 1982 } 1983 catch (const gdb_exception_error) 1984 { 1985 link_map_id_val = NULL; 1986 } 1987 /* glibc and illumos' libc both define LM_ID_BASE as zero. */ 1988 if (link_map_id_val != NULL && value_as_long (link_map_id_val) != 0) 1989 action = DO_NOTHING; 1990 else 1991 return; 1992 } 1993 1994 /* GDB does not currently support libraries loaded via dlmopen 1995 into namespaces other than the initial one. We must ignore 1996 any namespace other than the initial namespace here until 1997 support for this is added to GDB. */ 1998 if (debug_base != info->debug_base) 1999 action = DO_NOTHING; 2000 2001 if (action == UPDATE_OR_RELOAD) 2002 { 2003 try 2004 { 2005 val = pa->prob->evaluate_argument (2, frame); 2006 } 2007 catch (const gdb_exception_error &ex) 2008 { 2009 exception_print (gdb_stderr, ex); 2010 return; 2011 } 2012 2013 if (val != NULL) 2014 lm = value_as_address (val); 2015 2016 if (lm == 0) 2017 action = FULL_RELOAD; 2018 } 2019 2020 /* Resume section map updates. Closing the scope is 2021 sufficient. */ 2022 } 2023 2024 if (action == UPDATE_OR_RELOAD) 2025 { 2026 if (!solist_update_incremental (info, lm)) 2027 action = FULL_RELOAD; 2028 } 2029 2030 if (action == FULL_RELOAD) 2031 { 2032 if (!solist_update_full (info)) 2033 return; 2034 } 2035 2036 cleanup.release (); 2037 } 2038 2039 /* Helper function for svr4_update_solib_event_breakpoints. */ 2040 2041 static bool 2042 svr4_update_solib_event_breakpoint (struct breakpoint *b) 2043 { 2044 struct bp_location *loc; 2045 2046 if (b->type != bp_shlib_event) 2047 { 2048 /* Continue iterating. */ 2049 return false; 2050 } 2051 2052 for (loc = b->loc; loc != NULL; loc = loc->next) 2053 { 2054 struct svr4_info *info; 2055 struct probe_and_action *pa; 2056 2057 info = solib_svr4_pspace_data.get (loc->pspace); 2058 if (info == NULL || info->probes_table == NULL) 2059 continue; 2060 2061 pa = solib_event_probe_at (info, loc->address); 2062 if (pa == NULL) 2063 continue; 2064 2065 if (pa->action == DO_NOTHING) 2066 { 2067 if (b->enable_state == bp_disabled && stop_on_solib_events) 2068 enable_breakpoint (b); 2069 else if (b->enable_state == bp_enabled && !stop_on_solib_events) 2070 disable_breakpoint (b); 2071 } 2072 2073 break; 2074 } 2075 2076 /* Continue iterating. */ 2077 return false; 2078 } 2079 2080 /* Enable or disable optional solib event breakpoints as appropriate. 2081 Called whenever stop_on_solib_events is changed. */ 2082 2083 static void 2084 svr4_update_solib_event_breakpoints (void) 2085 { 2086 iterate_over_breakpoints (svr4_update_solib_event_breakpoint); 2087 } 2088 2089 /* Create and register solib event breakpoints. PROBES is an array 2090 of NUM_PROBES elements, each of which is vector of probes. A 2091 solib event breakpoint will be created and registered for each 2092 probe. */ 2093 2094 static void 2095 svr4_create_probe_breakpoints (svr4_info *info, struct gdbarch *gdbarch, 2096 const std::vector<probe *> *probes, 2097 struct objfile *objfile) 2098 { 2099 for (int i = 0; i < NUM_PROBES; i++) 2100 { 2101 enum probe_action action = probe_info[i].action; 2102 2103 for (probe *p : probes[i]) 2104 { 2105 CORE_ADDR address = p->get_relocated_address (objfile); 2106 2107 create_solib_event_breakpoint (gdbarch, address); 2108 register_solib_event_probe (info, objfile, p, address, action); 2109 } 2110 } 2111 2112 svr4_update_solib_event_breakpoints (); 2113 } 2114 2115 /* Find all the glibc named probes. Only if all of the probes are found, then 2116 create them and return true. Otherwise return false. If WITH_PREFIX is set 2117 then add "rtld" to the front of the probe names. */ 2118 static bool 2119 svr4_find_and_create_probe_breakpoints (svr4_info *info, 2120 struct gdbarch *gdbarch, 2121 struct obj_section *os, 2122 bool with_prefix) 2123 { 2124 std::vector<probe *> probes[NUM_PROBES]; 2125 2126 for (int i = 0; i < NUM_PROBES; i++) 2127 { 2128 const char *name = probe_info[i].name; 2129 char buf[32]; 2130 2131 /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4 shipped with an early 2132 version of the probes code in which the probes' names were prefixed 2133 with "rtld_" and the "map_failed" probe did not exist. The locations 2134 of the probes are otherwise the same, so we check for probes with 2135 prefixed names if probes with unprefixed names are not present. */ 2136 if (with_prefix) 2137 { 2138 xsnprintf (buf, sizeof (buf), "rtld_%s", name); 2139 name = buf; 2140 } 2141 2142 probes[i] = find_probes_in_objfile (os->objfile, "rtld", name); 2143 2144 /* The "map_failed" probe did not exist in early 2145 versions of the probes code in which the probes' 2146 names were prefixed with "rtld_". */ 2147 if (with_prefix && streq (name, "rtld_map_failed")) 2148 continue; 2149 2150 /* Ensure at least one probe for the current name was found. */ 2151 if (probes[i].empty ()) 2152 return false; 2153 2154 /* Ensure probe arguments can be evaluated. */ 2155 for (probe *p : probes[i]) 2156 { 2157 if (!p->can_evaluate_arguments ()) 2158 return false; 2159 /* This will fail if the probe is invalid. This has been seen on Arm 2160 due to references to symbols that have been resolved away. */ 2161 try 2162 { 2163 p->get_argument_count (gdbarch); 2164 } 2165 catch (const gdb_exception_error &ex) 2166 { 2167 exception_print (gdb_stderr, ex); 2168 warning (_("Initializing probes-based dynamic linker interface " 2169 "failed.\nReverting to original interface.")); 2170 return false; 2171 } 2172 } 2173 } 2174 2175 /* All probes found. Now create them. */ 2176 svr4_create_probe_breakpoints (info, gdbarch, probes, os->objfile); 2177 return true; 2178 } 2179 2180 /* Both the SunOS and the SVR4 dynamic linkers call a marker function 2181 before and after mapping and unmapping shared libraries. The sole 2182 purpose of this method is to allow debuggers to set a breakpoint so 2183 they can track these changes. 2184 2185 Some versions of the glibc dynamic linker contain named probes 2186 to allow more fine grained stopping. Given the address of the 2187 original marker function, this function attempts to find these 2188 probes, and if found, sets breakpoints on those instead. If the 2189 probes aren't found, a single breakpoint is set on the original 2190 marker function. */ 2191 2192 static void 2193 svr4_create_solib_event_breakpoints (svr4_info *info, struct gdbarch *gdbarch, 2194 CORE_ADDR address) 2195 { 2196 struct obj_section *os = find_pc_section (address); 2197 2198 if (os == nullptr 2199 || (!svr4_find_and_create_probe_breakpoints (info, gdbarch, os, false) 2200 && !svr4_find_and_create_probe_breakpoints (info, gdbarch, os, true))) 2201 create_solib_event_breakpoint (gdbarch, address); 2202 } 2203 2204 /* Helper function for gdb_bfd_lookup_symbol. */ 2205 2206 static int 2207 cmp_name_and_sec_flags (const asymbol *sym, const void *data) 2208 { 2209 return (strcmp (sym->name, (const char *) data) == 0 2210 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0); 2211 } 2212 /* Arrange for dynamic linker to hit breakpoint. 2213 2214 Both the SunOS and the SVR4 dynamic linkers have, as part of their 2215 debugger interface, support for arranging for the inferior to hit 2216 a breakpoint after mapping in the shared libraries. This function 2217 enables that breakpoint. 2218 2219 For SunOS, there is a special flag location (in_debugger) which we 2220 set to 1. When the dynamic linker sees this flag set, it will set 2221 a breakpoint at a location known only to itself, after saving the 2222 original contents of that place and the breakpoint address itself, 2223 in it's own internal structures. When we resume the inferior, it 2224 will eventually take a SIGTRAP when it runs into the breakpoint. 2225 We handle this (in a different place) by restoring the contents of 2226 the breakpointed location (which is only known after it stops), 2227 chasing around to locate the shared libraries that have been 2228 loaded, then resuming. 2229 2230 For SVR4, the debugger interface structure contains a member (r_brk) 2231 which is statically initialized at the time the shared library is 2232 built, to the offset of a function (_r_debug_state) which is guaran- 2233 teed to be called once before mapping in a library, and again when 2234 the mapping is complete. At the time we are examining this member, 2235 it contains only the unrelocated offset of the function, so we have 2236 to do our own relocation. Later, when the dynamic linker actually 2237 runs, it relocates r_brk to be the actual address of _r_debug_state(). 2238 2239 The debugger interface structure also contains an enumeration which 2240 is set to either RT_ADD or RT_DELETE prior to changing the mapping, 2241 depending upon whether or not the library is being mapped or unmapped, 2242 and then set to RT_CONSISTENT after the library is mapped/unmapped. */ 2243 2244 static int 2245 enable_break (struct svr4_info *info, int from_tty) 2246 { 2247 struct bound_minimal_symbol msymbol; 2248 const char * const *bkpt_namep; 2249 asection *interp_sect; 2250 CORE_ADDR sym_addr; 2251 2252 info->interp_text_sect_low = info->interp_text_sect_high = 0; 2253 info->interp_plt_sect_low = info->interp_plt_sect_high = 0; 2254 2255 /* If we already have a shared library list in the target, and 2256 r_debug contains r_brk, set the breakpoint there - this should 2257 mean r_brk has already been relocated. Assume the dynamic linker 2258 is the object containing r_brk. */ 2259 2260 solib_add (NULL, from_tty, auto_solib_add); 2261 sym_addr = 0; 2262 if (info->debug_base && solib_svr4_r_map (info) != 0) 2263 sym_addr = solib_svr4_r_brk (info); 2264 2265 if (sym_addr != 0) 2266 { 2267 struct obj_section *os; 2268 2269 sym_addr = gdbarch_addr_bits_remove 2270 (target_gdbarch (), 2271 gdbarch_convert_from_func_ptr_addr (target_gdbarch (), 2272 sym_addr, 2273 current_top_target ())); 2274 2275 /* On at least some versions of Solaris there's a dynamic relocation 2276 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if 2277 we get control before the dynamic linker has self-relocated. 2278 Check if SYM_ADDR is in a known section, if it is assume we can 2279 trust its value. This is just a heuristic though, it could go away 2280 or be replaced if it's getting in the way. 2281 2282 On ARM we need to know whether the ISA of rtld_db_dlactivity (or 2283 however it's spelled in your particular system) is ARM or Thumb. 2284 That knowledge is encoded in the address, if it's Thumb the low bit 2285 is 1. However, we've stripped that info above and it's not clear 2286 what all the consequences are of passing a non-addr_bits_remove'd 2287 address to svr4_create_solib_event_breakpoints. The call to 2288 find_pc_section verifies we know about the address and have some 2289 hope of computing the right kind of breakpoint to use (via 2290 symbol info). It does mean that GDB needs to be pointed at a 2291 non-stripped version of the dynamic linker in order to obtain 2292 information it already knows about. Sigh. */ 2293 2294 os = find_pc_section (sym_addr); 2295 if (os != NULL) 2296 { 2297 /* Record the relocated start and end address of the dynamic linker 2298 text and plt section for svr4_in_dynsym_resolve_code. */ 2299 bfd *tmp_bfd; 2300 CORE_ADDR load_addr; 2301 2302 tmp_bfd = os->objfile->obfd; 2303 load_addr = os->objfile->text_section_offset (); 2304 2305 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text"); 2306 if (interp_sect) 2307 { 2308 info->interp_text_sect_low 2309 = bfd_section_vma (interp_sect) + load_addr; 2310 info->interp_text_sect_high 2311 = info->interp_text_sect_low + bfd_section_size (interp_sect); 2312 } 2313 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt"); 2314 if (interp_sect) 2315 { 2316 info->interp_plt_sect_low 2317 = bfd_section_vma (interp_sect) + load_addr; 2318 info->interp_plt_sect_high 2319 = info->interp_plt_sect_low + bfd_section_size (interp_sect); 2320 } 2321 2322 svr4_create_solib_event_breakpoints (info, target_gdbarch (), sym_addr); 2323 return 1; 2324 } 2325 } 2326 2327 /* Find the program interpreter; if not found, warn the user and drop 2328 into the old breakpoint at symbol code. */ 2329 gdb::optional<gdb::byte_vector> interp_name_holder 2330 = find_program_interpreter (); 2331 if (interp_name_holder) 2332 { 2333 const char *interp_name = (const char *) interp_name_holder->data (); 2334 CORE_ADDR load_addr = 0; 2335 int load_addr_found = 0; 2336 int loader_found_in_list = 0; 2337 struct target_ops *tmp_bfd_target; 2338 2339 sym_addr = 0; 2340 2341 /* Now we need to figure out where the dynamic linker was 2342 loaded so that we can load its symbols and place a breakpoint 2343 in the dynamic linker itself. 2344 2345 This address is stored on the stack. However, I've been unable 2346 to find any magic formula to find it for Solaris (appears to 2347 be trivial on GNU/Linux). Therefore, we have to try an alternate 2348 mechanism to find the dynamic linker's base address. */ 2349 2350 gdb_bfd_ref_ptr tmp_bfd; 2351 try 2352 { 2353 tmp_bfd = solib_bfd_open (interp_name); 2354 } 2355 catch (const gdb_exception &ex) 2356 { 2357 } 2358 2359 if (tmp_bfd == NULL) 2360 goto bkpt_at_symbol; 2361 2362 /* Now convert the TMP_BFD into a target. That way target, as 2363 well as BFD operations can be used. target_bfd_reopen 2364 acquires its own reference. */ 2365 tmp_bfd_target = target_bfd_reopen (tmp_bfd.get ()); 2366 2367 /* On a running target, we can get the dynamic linker's base 2368 address from the shared library table. */ 2369 for (struct so_list *so : current_program_space->solibs ()) 2370 { 2371 if (svr4_same_1 (interp_name, so->so_original_name)) 2372 { 2373 load_addr_found = 1; 2374 loader_found_in_list = 1; 2375 load_addr = lm_addr_check (so, tmp_bfd.get ()); 2376 break; 2377 } 2378 } 2379 2380 /* If we were not able to find the base address of the loader 2381 from our so_list, then try using the AT_BASE auxilliary entry. */ 2382 if (!load_addr_found) 2383 if (target_auxv_search (current_top_target (), AT_BASE, &load_addr) > 0) 2384 { 2385 int addr_bit = gdbarch_addr_bit (target_gdbarch ()); 2386 2387 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so 2388 that `+ load_addr' will overflow CORE_ADDR width not creating 2389 invalid addresses like 0x101234567 for 32bit inferiors on 64bit 2390 GDB. */ 2391 2392 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)) 2393 { 2394 CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit; 2395 CORE_ADDR tmp_entry_point = exec_entry_point (tmp_bfd.get (), 2396 tmp_bfd_target); 2397 2398 gdb_assert (load_addr < space_size); 2399 2400 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked 2401 64bit ld.so with 32bit executable, it should not happen. */ 2402 2403 if (tmp_entry_point < space_size 2404 && tmp_entry_point + load_addr >= space_size) 2405 load_addr -= space_size; 2406 } 2407 2408 load_addr_found = 1; 2409 } 2410 2411 /* Otherwise we find the dynamic linker's base address by examining 2412 the current pc (which should point at the entry point for the 2413 dynamic linker) and subtracting the offset of the entry point. 2414 2415 This is more fragile than the previous approaches, but is a good 2416 fallback method because it has actually been working well in 2417 most cases. */ 2418 if (!load_addr_found) 2419 { 2420 struct regcache *regcache 2421 = get_thread_arch_regcache (current_inferior ()->process_target (), 2422 inferior_ptid, target_gdbarch ()); 2423 2424 load_addr = (regcache_read_pc (regcache) 2425 - exec_entry_point (tmp_bfd.get (), tmp_bfd_target)); 2426 } 2427 2428 if (!loader_found_in_list) 2429 { 2430 info->debug_loader_name = xstrdup (interp_name); 2431 info->debug_loader_offset_p = 1; 2432 info->debug_loader_offset = load_addr; 2433 solib_add (NULL, from_tty, auto_solib_add); 2434 } 2435 2436 /* Record the relocated start and end address of the dynamic linker 2437 text and plt section for svr4_in_dynsym_resolve_code. */ 2438 interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".text"); 2439 if (interp_sect) 2440 { 2441 info->interp_text_sect_low 2442 = bfd_section_vma (interp_sect) + load_addr; 2443 info->interp_text_sect_high 2444 = info->interp_text_sect_low + bfd_section_size (interp_sect); 2445 } 2446 interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".plt"); 2447 if (interp_sect) 2448 { 2449 info->interp_plt_sect_low 2450 = bfd_section_vma (interp_sect) + load_addr; 2451 info->interp_plt_sect_high 2452 = info->interp_plt_sect_low + bfd_section_size (interp_sect); 2453 } 2454 2455 /* Now try to set a breakpoint in the dynamic linker. */ 2456 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++) 2457 { 2458 sym_addr = gdb_bfd_lookup_symbol (tmp_bfd.get (), 2459 cmp_name_and_sec_flags, 2460 *bkpt_namep); 2461 if (sym_addr != 0) 2462 break; 2463 } 2464 2465 if (sym_addr != 0) 2466 /* Convert 'sym_addr' from a function pointer to an address. 2467 Because we pass tmp_bfd_target instead of the current 2468 target, this will always produce an unrelocated value. */ 2469 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), 2470 sym_addr, 2471 tmp_bfd_target); 2472 2473 /* We're done with both the temporary bfd and target. Closing 2474 the target closes the underlying bfd, because it holds the 2475 only remaining reference. */ 2476 target_close (tmp_bfd_target); 2477 2478 if (sym_addr != 0) 2479 { 2480 svr4_create_solib_event_breakpoints (info, target_gdbarch (), 2481 load_addr + sym_addr); 2482 return 1; 2483 } 2484 2485 /* For whatever reason we couldn't set a breakpoint in the dynamic 2486 linker. Warn and drop into the old code. */ 2487 bkpt_at_symbol: 2488 warning (_("Unable to find dynamic linker breakpoint function.\n" 2489 "GDB will be unable to debug shared library initializers\n" 2490 "and track explicitly loaded dynamic code.")); 2491 } 2492 2493 /* Scan through the lists of symbols, trying to look up the symbol and 2494 set a breakpoint there. Terminate loop when we/if we succeed. */ 2495 2496 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++) 2497 { 2498 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile); 2499 if ((msymbol.minsym != NULL) 2500 && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0)) 2501 { 2502 sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol); 2503 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), 2504 sym_addr, 2505 current_top_target ()); 2506 svr4_create_solib_event_breakpoints (info, target_gdbarch (), 2507 sym_addr); 2508 return 1; 2509 } 2510 } 2511 2512 if (interp_name_holder && !current_inferior ()->attach_flag) 2513 { 2514 for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++) 2515 { 2516 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile); 2517 if ((msymbol.minsym != NULL) 2518 && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0)) 2519 { 2520 sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol); 2521 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), 2522 sym_addr, 2523 current_top_target ()); 2524 svr4_create_solib_event_breakpoints (info, target_gdbarch (), 2525 sym_addr); 2526 return 1; 2527 } 2528 } 2529 } 2530 return 0; 2531 } 2532 2533 /* Read the ELF program headers from ABFD. */ 2534 2535 static gdb::optional<gdb::byte_vector> 2536 read_program_headers_from_bfd (bfd *abfd) 2537 { 2538 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd); 2539 int phdrs_size = ehdr->e_phnum * ehdr->e_phentsize; 2540 if (phdrs_size == 0) 2541 return {}; 2542 2543 gdb::byte_vector buf (phdrs_size); 2544 if (bfd_seek (abfd, ehdr->e_phoff, SEEK_SET) != 0 2545 || bfd_bread (buf.data (), phdrs_size, abfd) != phdrs_size) 2546 return {}; 2547 2548 return buf; 2549 } 2550 2551 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior 2552 exec_bfd. Otherwise return 0. 2553 2554 We relocate all of the sections by the same amount. This 2555 behavior is mandated by recent editions of the System V ABI. 2556 According to the System V Application Binary Interface, 2557 Edition 4.1, page 5-5: 2558 2559 ... Though the system chooses virtual addresses for 2560 individual processes, it maintains the segments' relative 2561 positions. Because position-independent code uses relative 2562 addressing between segments, the difference between 2563 virtual addresses in memory must match the difference 2564 between virtual addresses in the file. The difference 2565 between the virtual address of any segment in memory and 2566 the corresponding virtual address in the file is thus a 2567 single constant value for any one executable or shared 2568 object in a given process. This difference is the base 2569 address. One use of the base address is to relocate the 2570 memory image of the program during dynamic linking. 2571 2572 The same language also appears in Edition 4.0 of the System V 2573 ABI and is left unspecified in some of the earlier editions. 2574 2575 Decide if the objfile needs to be relocated. As indicated above, we will 2576 only be here when execution is stopped. But during attachment PC can be at 2577 arbitrary address therefore regcache_read_pc can be misleading (contrary to 2578 the auxv AT_ENTRY value). Moreover for executable with interpreter section 2579 regcache_read_pc would point to the interpreter and not the main executable. 2580 2581 So, to summarize, relocations are necessary when the start address obtained 2582 from the executable is different from the address in auxv AT_ENTRY entry. 2583 2584 [ The astute reader will note that we also test to make sure that 2585 the executable in question has the DYNAMIC flag set. It is my 2586 opinion that this test is unnecessary (undesirable even). It 2587 was added to avoid inadvertent relocation of an executable 2588 whose e_type member in the ELF header is not ET_DYN. There may 2589 be a time in the future when it is desirable to do relocations 2590 on other types of files as well in which case this condition 2591 should either be removed or modified to accomodate the new file 2592 type. - Kevin, Nov 2000. ] */ 2593 2594 static int 2595 svr4_exec_displacement (CORE_ADDR *displacementp) 2596 { 2597 /* ENTRY_POINT is a possible function descriptor - before 2598 a call to gdbarch_convert_from_func_ptr_addr. */ 2599 CORE_ADDR entry_point, exec_displacement; 2600 2601 if (exec_bfd == NULL) 2602 return 0; 2603 2604 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries 2605 being executed themselves and PIE (Position Independent Executable) 2606 executables are ET_DYN. */ 2607 2608 if ((bfd_get_file_flags (exec_bfd) & DYNAMIC) == 0) 2609 return 0; 2610 2611 if (target_auxv_search (current_top_target (), AT_ENTRY, &entry_point) <= 0) 2612 return 0; 2613 2614 exec_displacement = entry_point - bfd_get_start_address (exec_bfd); 2615 2616 /* Verify the EXEC_DISPLACEMENT candidate complies with the required page 2617 alignment. It is cheaper than the program headers comparison below. */ 2618 2619 if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour) 2620 { 2621 const struct elf_backend_data *elf = get_elf_backend_data (exec_bfd); 2622 2623 /* p_align of PT_LOAD segments does not specify any alignment but 2624 only congruency of addresses: 2625 p_offset % p_align == p_vaddr % p_align 2626 Kernel is free to load the executable with lower alignment. */ 2627 2628 if ((exec_displacement & (elf->minpagesize - 1)) != 0) 2629 return 0; 2630 } 2631 2632 /* Verify that the auxilliary vector describes the same file as exec_bfd, by 2633 comparing their program headers. If the program headers in the auxilliary 2634 vector do not match the program headers in the executable, then we are 2635 looking at a different file than the one used by the kernel - for 2636 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */ 2637 2638 if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour) 2639 { 2640 /* Be optimistic and return 0 only if GDB was able to verify the headers 2641 really do not match. */ 2642 int arch_size; 2643 2644 gdb::optional<gdb::byte_vector> phdrs_target 2645 = read_program_header (-1, &arch_size, NULL); 2646 gdb::optional<gdb::byte_vector> phdrs_binary 2647 = read_program_headers_from_bfd (exec_bfd); 2648 if (phdrs_target && phdrs_binary) 2649 { 2650 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 2651 2652 /* We are dealing with three different addresses. EXEC_BFD 2653 represents current address in on-disk file. target memory content 2654 may be different from EXEC_BFD as the file may have been prelinked 2655 to a different address after the executable has been loaded. 2656 Moreover the address of placement in target memory can be 2657 different from what the program headers in target memory say - 2658 this is the goal of PIE. 2659 2660 Detected DISPLACEMENT covers both the offsets of PIE placement and 2661 possible new prelink performed after start of the program. Here 2662 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory 2663 content offset for the verification purpose. */ 2664 2665 if (phdrs_target->size () != phdrs_binary->size () 2666 || bfd_get_arch_size (exec_bfd) != arch_size) 2667 return 0; 2668 else if (arch_size == 32 2669 && phdrs_target->size () >= sizeof (Elf32_External_Phdr) 2670 && phdrs_target->size () % sizeof (Elf32_External_Phdr) == 0) 2671 { 2672 Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header; 2673 Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr; 2674 CORE_ADDR displacement = 0; 2675 int i; 2676 2677 /* DISPLACEMENT could be found more easily by the difference of 2678 ehdr2->e_entry. But we haven't read the ehdr yet, and we 2679 already have enough information to compute that displacement 2680 with what we've read. */ 2681 2682 for (i = 0; i < ehdr2->e_phnum; i++) 2683 if (phdr2[i].p_type == PT_LOAD) 2684 { 2685 Elf32_External_Phdr *phdrp; 2686 gdb_byte *buf_vaddr_p, *buf_paddr_p; 2687 CORE_ADDR vaddr, paddr; 2688 CORE_ADDR displacement_vaddr = 0; 2689 CORE_ADDR displacement_paddr = 0; 2690 2691 phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i]; 2692 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr; 2693 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr; 2694 2695 vaddr = extract_unsigned_integer (buf_vaddr_p, 4, 2696 byte_order); 2697 displacement_vaddr = vaddr - phdr2[i].p_vaddr; 2698 2699 paddr = extract_unsigned_integer (buf_paddr_p, 4, 2700 byte_order); 2701 displacement_paddr = paddr - phdr2[i].p_paddr; 2702 2703 if (displacement_vaddr == displacement_paddr) 2704 displacement = displacement_vaddr; 2705 2706 break; 2707 } 2708 2709 /* Now compare program headers from the target and the binary 2710 with optional DISPLACEMENT. */ 2711 2712 for (i = 0; 2713 i < phdrs_target->size () / sizeof (Elf32_External_Phdr); 2714 i++) 2715 { 2716 Elf32_External_Phdr *phdrp; 2717 Elf32_External_Phdr *phdr2p; 2718 gdb_byte *buf_vaddr_p, *buf_paddr_p; 2719 CORE_ADDR vaddr, paddr; 2720 asection *plt2_asect; 2721 2722 phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i]; 2723 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr; 2724 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr; 2725 phdr2p = &((Elf32_External_Phdr *) phdrs_binary->data ())[i]; 2726 2727 /* PT_GNU_STACK is an exception by being never relocated by 2728 prelink as its addresses are always zero. */ 2729 2730 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0) 2731 continue; 2732 2733 /* Check also other adjustment combinations - PR 11786. */ 2734 2735 vaddr = extract_unsigned_integer (buf_vaddr_p, 4, 2736 byte_order); 2737 vaddr -= displacement; 2738 store_unsigned_integer (buf_vaddr_p, 4, byte_order, vaddr); 2739 2740 paddr = extract_unsigned_integer (buf_paddr_p, 4, 2741 byte_order); 2742 paddr -= displacement; 2743 store_unsigned_integer (buf_paddr_p, 4, byte_order, paddr); 2744 2745 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0) 2746 continue; 2747 2748 /* Strip modifies the flags and alignment of PT_GNU_RELRO. 2749 CentOS-5 has problems with filesz, memsz as well. 2750 Strip also modifies memsz of PT_TLS. 2751 See PR 11786. */ 2752 if (phdr2[i].p_type == PT_GNU_RELRO 2753 || phdr2[i].p_type == PT_TLS) 2754 { 2755 Elf32_External_Phdr tmp_phdr = *phdrp; 2756 Elf32_External_Phdr tmp_phdr2 = *phdr2p; 2757 2758 memset (tmp_phdr.p_filesz, 0, 4); 2759 memset (tmp_phdr.p_memsz, 0, 4); 2760 memset (tmp_phdr.p_flags, 0, 4); 2761 memset (tmp_phdr.p_align, 0, 4); 2762 memset (tmp_phdr2.p_filesz, 0, 4); 2763 memset (tmp_phdr2.p_memsz, 0, 4); 2764 memset (tmp_phdr2.p_flags, 0, 4); 2765 memset (tmp_phdr2.p_align, 0, 4); 2766 2767 if (memcmp (&tmp_phdr, &tmp_phdr2, sizeof (tmp_phdr)) 2768 == 0) 2769 continue; 2770 } 2771 2772 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */ 2773 plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt"); 2774 if (plt2_asect) 2775 { 2776 int content2; 2777 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz; 2778 CORE_ADDR filesz; 2779 2780 content2 = (bfd_section_flags (plt2_asect) 2781 & SEC_HAS_CONTENTS) != 0; 2782 2783 filesz = extract_unsigned_integer (buf_filesz_p, 4, 2784 byte_order); 2785 2786 /* PLT2_ASECT is from on-disk file (exec_bfd) while 2787 FILESZ is from the in-memory image. */ 2788 if (content2) 2789 filesz += bfd_section_size (plt2_asect); 2790 else 2791 filesz -= bfd_section_size (plt2_asect); 2792 2793 store_unsigned_integer (buf_filesz_p, 4, byte_order, 2794 filesz); 2795 2796 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0) 2797 continue; 2798 } 2799 2800 return 0; 2801 } 2802 } 2803 else if (arch_size == 64 2804 && phdrs_target->size () >= sizeof (Elf64_External_Phdr) 2805 && phdrs_target->size () % sizeof (Elf64_External_Phdr) == 0) 2806 { 2807 Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header; 2808 Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr; 2809 CORE_ADDR displacement = 0; 2810 int i; 2811 2812 /* DISPLACEMENT could be found more easily by the difference of 2813 ehdr2->e_entry. But we haven't read the ehdr yet, and we 2814 already have enough information to compute that displacement 2815 with what we've read. */ 2816 2817 for (i = 0; i < ehdr2->e_phnum; i++) 2818 if (phdr2[i].p_type == PT_LOAD) 2819 { 2820 Elf64_External_Phdr *phdrp; 2821 gdb_byte *buf_vaddr_p, *buf_paddr_p; 2822 CORE_ADDR vaddr, paddr; 2823 CORE_ADDR displacement_vaddr = 0; 2824 CORE_ADDR displacement_paddr = 0; 2825 2826 phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i]; 2827 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr; 2828 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr; 2829 2830 vaddr = extract_unsigned_integer (buf_vaddr_p, 8, 2831 byte_order); 2832 displacement_vaddr = vaddr - phdr2[i].p_vaddr; 2833 2834 paddr = extract_unsigned_integer (buf_paddr_p, 8, 2835 byte_order); 2836 displacement_paddr = paddr - phdr2[i].p_paddr; 2837 2838 if (displacement_vaddr == displacement_paddr) 2839 displacement = displacement_vaddr; 2840 2841 break; 2842 } 2843 2844 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */ 2845 2846 for (i = 0; 2847 i < phdrs_target->size () / sizeof (Elf64_External_Phdr); 2848 i++) 2849 { 2850 Elf64_External_Phdr *phdrp; 2851 Elf64_External_Phdr *phdr2p; 2852 gdb_byte *buf_vaddr_p, *buf_paddr_p; 2853 CORE_ADDR vaddr, paddr; 2854 asection *plt2_asect; 2855 2856 phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i]; 2857 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr; 2858 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr; 2859 phdr2p = &((Elf64_External_Phdr *) phdrs_binary->data ())[i]; 2860 2861 /* PT_GNU_STACK is an exception by being never relocated by 2862 prelink as its addresses are always zero. */ 2863 2864 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0) 2865 continue; 2866 2867 /* Check also other adjustment combinations - PR 11786. */ 2868 2869 vaddr = extract_unsigned_integer (buf_vaddr_p, 8, 2870 byte_order); 2871 vaddr -= displacement; 2872 store_unsigned_integer (buf_vaddr_p, 8, byte_order, vaddr); 2873 2874 paddr = extract_unsigned_integer (buf_paddr_p, 8, 2875 byte_order); 2876 paddr -= displacement; 2877 store_unsigned_integer (buf_paddr_p, 8, byte_order, paddr); 2878 2879 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0) 2880 continue; 2881 2882 /* Strip modifies the flags and alignment of PT_GNU_RELRO. 2883 CentOS-5 has problems with filesz, memsz as well. 2884 Strip also modifies memsz of PT_TLS. 2885 See PR 11786. */ 2886 if (phdr2[i].p_type == PT_GNU_RELRO 2887 || phdr2[i].p_type == PT_TLS) 2888 { 2889 Elf64_External_Phdr tmp_phdr = *phdrp; 2890 Elf64_External_Phdr tmp_phdr2 = *phdr2p; 2891 2892 memset (tmp_phdr.p_filesz, 0, 8); 2893 memset (tmp_phdr.p_memsz, 0, 8); 2894 memset (tmp_phdr.p_flags, 0, 4); 2895 memset (tmp_phdr.p_align, 0, 8); 2896 memset (tmp_phdr2.p_filesz, 0, 8); 2897 memset (tmp_phdr2.p_memsz, 0, 8); 2898 memset (tmp_phdr2.p_flags, 0, 4); 2899 memset (tmp_phdr2.p_align, 0, 8); 2900 2901 if (memcmp (&tmp_phdr, &tmp_phdr2, sizeof (tmp_phdr)) 2902 == 0) 2903 continue; 2904 } 2905 2906 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */ 2907 plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt"); 2908 if (plt2_asect) 2909 { 2910 int content2; 2911 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz; 2912 CORE_ADDR filesz; 2913 2914 content2 = (bfd_section_flags (plt2_asect) 2915 & SEC_HAS_CONTENTS) != 0; 2916 2917 filesz = extract_unsigned_integer (buf_filesz_p, 8, 2918 byte_order); 2919 2920 /* PLT2_ASECT is from on-disk file (exec_bfd) while 2921 FILESZ is from the in-memory image. */ 2922 if (content2) 2923 filesz += bfd_section_size (plt2_asect); 2924 else 2925 filesz -= bfd_section_size (plt2_asect); 2926 2927 store_unsigned_integer (buf_filesz_p, 8, byte_order, 2928 filesz); 2929 2930 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0) 2931 continue; 2932 } 2933 2934 return 0; 2935 } 2936 } 2937 else 2938 return 0; 2939 } 2940 } 2941 2942 if (info_verbose) 2943 { 2944 /* It can be printed repeatedly as there is no easy way to check 2945 the executable symbols/file has been already relocated to 2946 displacement. */ 2947 2948 printf_unfiltered (_("Using PIE (Position Independent Executable) " 2949 "displacement %s for \"%s\".\n"), 2950 paddress (target_gdbarch (), exec_displacement), 2951 bfd_get_filename (exec_bfd)); 2952 } 2953 2954 *displacementp = exec_displacement; 2955 return 1; 2956 } 2957 2958 /* Relocate the main executable. This function should be called upon 2959 stopping the inferior process at the entry point to the program. 2960 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are 2961 different, the main executable is relocated by the proper amount. */ 2962 2963 static void 2964 svr4_relocate_main_executable (void) 2965 { 2966 CORE_ADDR displacement; 2967 2968 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS 2969 probably contains the offsets computed using the PIE displacement 2970 from the previous run, which of course are irrelevant for this run. 2971 So we need to determine the new PIE displacement and recompute the 2972 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS 2973 already contains pre-computed offsets. 2974 2975 If we cannot compute the PIE displacement, either: 2976 2977 - The executable is not PIE. 2978 2979 - SYMFILE_OBJFILE does not match the executable started in the target. 2980 This can happen for main executable symbols loaded at the host while 2981 `ld.so --ld-args main-executable' is loaded in the target. 2982 2983 Then we leave the section offsets untouched and use them as is for 2984 this run. Either: 2985 2986 - These section offsets were properly reset earlier, and thus 2987 already contain the correct values. This can happen for instance 2988 when reconnecting via the remote protocol to a target that supports 2989 the `qOffsets' packet. 2990 2991 - The section offsets were not reset earlier, and the best we can 2992 hope is that the old offsets are still applicable to the new run. */ 2993 2994 if (! svr4_exec_displacement (&displacement)) 2995 return; 2996 2997 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file 2998 addresses. */ 2999 3000 if (symfile_objfile) 3001 { 3002 section_offsets new_offsets (symfile_objfile->section_offsets.size (), 3003 displacement); 3004 objfile_relocate (symfile_objfile, new_offsets); 3005 } 3006 else if (exec_bfd) 3007 { 3008 asection *asect; 3009 3010 for (asect = exec_bfd->sections; asect != NULL; asect = asect->next) 3011 exec_set_section_address (bfd_get_filename (exec_bfd), asect->index, 3012 bfd_section_vma (asect) + displacement); 3013 } 3014 } 3015 3016 /* Implement the "create_inferior_hook" target_solib_ops method. 3017 3018 For SVR4 executables, this first instruction is either the first 3019 instruction in the dynamic linker (for dynamically linked 3020 executables) or the instruction at "start" for statically linked 3021 executables. For dynamically linked executables, the system 3022 first exec's /lib/libc.so.N, which contains the dynamic linker, 3023 and starts it running. The dynamic linker maps in any needed 3024 shared libraries, maps in the actual user executable, and then 3025 jumps to "start" in the user executable. 3026 3027 We can arrange to cooperate with the dynamic linker to discover the 3028 names of shared libraries that are dynamically linked, and the base 3029 addresses to which they are linked. 3030 3031 This function is responsible for discovering those names and 3032 addresses, and saving sufficient information about them to allow 3033 their symbols to be read at a later time. */ 3034 3035 static void 3036 svr4_solib_create_inferior_hook (int from_tty) 3037 { 3038 struct svr4_info *info; 3039 3040 info = get_svr4_info (current_program_space); 3041 3042 /* Clear the probes-based interface's state. */ 3043 free_probes_table (info); 3044 free_solib_list (info); 3045 3046 /* Relocate the main executable if necessary. */ 3047 svr4_relocate_main_executable (); 3048 3049 /* No point setting a breakpoint in the dynamic linker if we can't 3050 hit it (e.g., a core file, or a trace file). */ 3051 if (!target_has_execution) 3052 return; 3053 3054 if (!svr4_have_link_map_offsets ()) 3055 return; 3056 3057 if (!enable_break (info, from_tty)) 3058 return; 3059 } 3060 3061 static void 3062 svr4_clear_solib (void) 3063 { 3064 struct svr4_info *info; 3065 3066 info = get_svr4_info (current_program_space); 3067 info->debug_base = 0; 3068 info->debug_loader_offset_p = 0; 3069 info->debug_loader_offset = 0; 3070 xfree (info->debug_loader_name); 3071 info->debug_loader_name = NULL; 3072 } 3073 3074 /* Clear any bits of ADDR that wouldn't fit in a target-format 3075 data pointer. "Data pointer" here refers to whatever sort of 3076 address the dynamic linker uses to manage its sections. At the 3077 moment, we don't support shared libraries on any processors where 3078 code and data pointers are different sizes. 3079 3080 This isn't really the right solution. What we really need here is 3081 a way to do arithmetic on CORE_ADDR values that respects the 3082 natural pointer/address correspondence. (For example, on the MIPS, 3083 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to 3084 sign-extend the value. There, simply truncating the bits above 3085 gdbarch_ptr_bit, as we do below, is no good.) This should probably 3086 be a new gdbarch method or something. */ 3087 static CORE_ADDR 3088 svr4_truncate_ptr (CORE_ADDR addr) 3089 { 3090 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8) 3091 /* We don't need to truncate anything, and the bit twiddling below 3092 will fail due to overflow problems. */ 3093 return addr; 3094 else 3095 return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1); 3096 } 3097 3098 3099 static void 3100 svr4_relocate_section_addresses (struct so_list *so, 3101 struct target_section *sec) 3102 { 3103 bfd *abfd = sec->the_bfd_section->owner; 3104 3105 sec->addr = svr4_truncate_ptr (sec->addr + lm_addr_check (so, abfd)); 3106 sec->endaddr = svr4_truncate_ptr (sec->endaddr + lm_addr_check (so, abfd)); 3107 } 3108 3109 3110 /* Architecture-specific operations. */ 3111 3112 /* Per-architecture data key. */ 3113 static struct gdbarch_data *solib_svr4_data; 3114 3115 struct solib_svr4_ops 3116 { 3117 /* Return a description of the layout of `struct link_map'. */ 3118 struct link_map_offsets *(*fetch_link_map_offsets)(void); 3119 }; 3120 3121 /* Return a default for the architecture-specific operations. */ 3122 3123 static void * 3124 solib_svr4_init (struct obstack *obstack) 3125 { 3126 struct solib_svr4_ops *ops; 3127 3128 ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops); 3129 ops->fetch_link_map_offsets = NULL; 3130 return ops; 3131 } 3132 3133 /* Set the architecture-specific `struct link_map_offsets' fetcher for 3134 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */ 3135 3136 void 3137 set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch, 3138 struct link_map_offsets *(*flmo) (void)) 3139 { 3140 struct solib_svr4_ops *ops 3141 = (struct solib_svr4_ops *) gdbarch_data (gdbarch, solib_svr4_data); 3142 3143 ops->fetch_link_map_offsets = flmo; 3144 3145 set_solib_ops (gdbarch, &svr4_so_ops); 3146 set_gdbarch_iterate_over_objfiles_in_search_order 3147 (gdbarch, svr4_iterate_over_objfiles_in_search_order); 3148 } 3149 3150 /* Fetch a link_map_offsets structure using the architecture-specific 3151 `struct link_map_offsets' fetcher. */ 3152 3153 static struct link_map_offsets * 3154 svr4_fetch_link_map_offsets (void) 3155 { 3156 struct solib_svr4_ops *ops 3157 = (struct solib_svr4_ops *) gdbarch_data (target_gdbarch (), 3158 solib_svr4_data); 3159 3160 gdb_assert (ops->fetch_link_map_offsets); 3161 return ops->fetch_link_map_offsets (); 3162 } 3163 3164 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */ 3165 3166 static int 3167 svr4_have_link_map_offsets (void) 3168 { 3169 struct solib_svr4_ops *ops 3170 = (struct solib_svr4_ops *) gdbarch_data (target_gdbarch (), 3171 solib_svr4_data); 3172 3173 return (ops->fetch_link_map_offsets != NULL); 3174 } 3175 3176 3177 /* Most OS'es that have SVR4-style ELF dynamic libraries define a 3178 `struct r_debug' and a `struct link_map' that are binary compatible 3179 with the original SVR4 implementation. */ 3180 3181 /* Fetch (and possibly build) an appropriate `struct link_map_offsets' 3182 for an ILP32 SVR4 system. */ 3183 3184 struct link_map_offsets * 3185 svr4_ilp32_fetch_link_map_offsets (void) 3186 { 3187 static struct link_map_offsets lmo; 3188 static struct link_map_offsets *lmp = NULL; 3189 3190 if (lmp == NULL) 3191 { 3192 lmp = &lmo; 3193 3194 lmo.r_version_offset = 0; 3195 lmo.r_version_size = 4; 3196 lmo.r_map_offset = 4; 3197 lmo.r_brk_offset = 8; 3198 lmo.r_ldsomap_offset = 20; 3199 3200 /* Everything we need is in the first 20 bytes. */ 3201 lmo.link_map_size = 20; 3202 lmo.l_addr_offset = 0; 3203 lmo.l_name_offset = 4; 3204 lmo.l_ld_offset = 8; 3205 lmo.l_next_offset = 12; 3206 lmo.l_prev_offset = 16; 3207 } 3208 3209 return lmp; 3210 } 3211 3212 /* Fetch (and possibly build) an appropriate `struct link_map_offsets' 3213 for an LP64 SVR4 system. */ 3214 3215 struct link_map_offsets * 3216 svr4_lp64_fetch_link_map_offsets (void) 3217 { 3218 static struct link_map_offsets lmo; 3219 static struct link_map_offsets *lmp = NULL; 3220 3221 if (lmp == NULL) 3222 { 3223 lmp = &lmo; 3224 3225 lmo.r_version_offset = 0; 3226 lmo.r_version_size = 4; 3227 lmo.r_map_offset = 8; 3228 lmo.r_brk_offset = 16; 3229 lmo.r_ldsomap_offset = 40; 3230 3231 /* Everything we need is in the first 40 bytes. */ 3232 lmo.link_map_size = 40; 3233 lmo.l_addr_offset = 0; 3234 lmo.l_name_offset = 8; 3235 lmo.l_ld_offset = 16; 3236 lmo.l_next_offset = 24; 3237 lmo.l_prev_offset = 32; 3238 } 3239 3240 return lmp; 3241 } 3242 3243 3244 struct target_so_ops svr4_so_ops; 3245 3246 /* Search order for ELF DSOs linked with -Bsymbolic. Those DSOs have a 3247 different rule for symbol lookup. The lookup begins here in the DSO, not in 3248 the main executable. */ 3249 3250 static void 3251 svr4_iterate_over_objfiles_in_search_order 3252 (struct gdbarch *gdbarch, 3253 iterate_over_objfiles_in_search_order_cb_ftype *cb, 3254 void *cb_data, struct objfile *current_objfile) 3255 { 3256 bool checked_current_objfile = false; 3257 if (current_objfile != nullptr) 3258 { 3259 bfd *abfd; 3260 3261 if (current_objfile->separate_debug_objfile_backlink != nullptr) 3262 current_objfile = current_objfile->separate_debug_objfile_backlink; 3263 3264 if (current_objfile == symfile_objfile) 3265 abfd = exec_bfd; 3266 else 3267 abfd = current_objfile->obfd; 3268 3269 if (abfd != nullptr 3270 && scan_dyntag (DT_SYMBOLIC, abfd, nullptr, nullptr) == 1) 3271 { 3272 checked_current_objfile = true; 3273 if (cb (current_objfile, cb_data) != 0) 3274 return; 3275 } 3276 } 3277 3278 for (objfile *objfile : current_program_space->objfiles ()) 3279 { 3280 if (checked_current_objfile && objfile == current_objfile) 3281 continue; 3282 if (cb (objfile, cb_data) != 0) 3283 return; 3284 } 3285 } 3286 3287 void _initialize_svr4_solib (); 3288 void 3289 _initialize_svr4_solib () 3290 { 3291 solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init); 3292 3293 svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses; 3294 svr4_so_ops.free_so = svr4_free_so; 3295 svr4_so_ops.clear_so = svr4_clear_so; 3296 svr4_so_ops.clear_solib = svr4_clear_solib; 3297 svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook; 3298 svr4_so_ops.current_sos = svr4_current_sos; 3299 svr4_so_ops.open_symbol_file_object = open_symbol_file_object; 3300 svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code; 3301 svr4_so_ops.bfd_open = solib_bfd_open; 3302 svr4_so_ops.same = svr4_same; 3303 svr4_so_ops.keep_data_in_core = svr4_keep_data_in_core; 3304 svr4_so_ops.update_breakpoints = svr4_update_solib_event_breakpoints; 3305 svr4_so_ops.handle_event = svr4_handle_solib_event; 3306 3307 gdb::observers::free_objfile.attach (svr4_free_objfile_observer); 3308 } 3309