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