1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger. 2 3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 4 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 24 #include "elf/external.h" 25 #include "elf/common.h" 26 #include "elf/mips.h" 27 28 #include "symtab.h" 29 #include "bfd.h" 30 #include "symfile.h" 31 #include "objfiles.h" 32 #include "gdbcore.h" 33 #include "target.h" 34 #include "inferior.h" 35 #include "regcache.h" 36 #include "gdbthread.h" 37 #include "observer.h" 38 39 #include "gdb_assert.h" 40 41 #include "solist.h" 42 #include "solib.h" 43 #include "solib-svr4.h" 44 45 #include "bfd-target.h" 46 #include "elf-bfd.h" 47 #include "exec.h" 48 #include "auxv.h" 49 #include "exceptions.h" 50 51 static struct link_map_offsets *svr4_fetch_link_map_offsets (void); 52 static int svr4_have_link_map_offsets (void); 53 54 /* Link map info to include in an allocated so_list entry */ 55 56 struct lm_info 57 { 58 /* Pointer to copy of link map from inferior. The type is char * 59 rather than void *, so that we may use byte offsets to find the 60 various fields without the need for a cast. */ 61 gdb_byte *lm; 62 63 /* Amount by which addresses in the binary should be relocated to 64 match the inferior. This could most often be taken directly 65 from lm, but when prelinking is involved and the prelink base 66 address changes, we may need a different offset, we want to 67 warn about the difference and compute it only once. */ 68 CORE_ADDR l_addr; 69 70 /* The target location of lm. */ 71 CORE_ADDR lm_addr; 72 }; 73 74 /* On SVR4 systems, a list of symbols in the dynamic linker where 75 GDB can try to place a breakpoint to monitor shared library 76 events. 77 78 If none of these symbols are found, or other errors occur, then 79 SVR4 systems will fall back to using a symbol as the "startup 80 mapping complete" breakpoint address. */ 81 82 static char *solib_break_names[] = 83 { 84 "r_debug_state", 85 "_r_debug_state", 86 "_dl_debug_state", 87 "rtld_db_dlactivity", 88 "_rtld_debug_state", 89 90 NULL 91 }; 92 93 static char *bkpt_names[] = 94 { 95 "_start", 96 "__start", 97 "main", 98 NULL 99 }; 100 101 static char *main_name_list[] = 102 { 103 "main_$main", 104 NULL 105 }; 106 107 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent 108 the same shared library. */ 109 110 static int 111 svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name) 112 { 113 if (strcmp (gdb_so_name, inferior_so_name) == 0) 114 return 1; 115 116 /* On Solaris, when starting inferior we think that dynamic linker is 117 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries 118 contains /lib/ld.so.1. Sometimes one file is a link to another, but 119 sometimes they have identical content, but are not linked to each 120 other. We don't restrict this check for Solaris, but the chances 121 of running into this situation elsewhere are very low. */ 122 if (strcmp (gdb_so_name, "/usr/lib/ld.so.1") == 0 123 && strcmp (inferior_so_name, "/lib/ld.so.1") == 0) 124 return 1; 125 126 /* Similarly, we observed the same issue with sparc64, but with 127 different locations. */ 128 if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0 129 && strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0) 130 return 1; 131 132 return 0; 133 } 134 135 static int 136 svr4_same (struct so_list *gdb, struct so_list *inferior) 137 { 138 return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name)); 139 } 140 141 /* link map access functions */ 142 143 static CORE_ADDR 144 LM_ADDR_FROM_LINK_MAP (struct so_list *so) 145 { 146 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 147 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 148 149 return extract_typed_address (so->lm_info->lm + lmo->l_addr_offset, 150 ptr_type); 151 } 152 153 static int 154 HAS_LM_DYNAMIC_FROM_LINK_MAP (void) 155 { 156 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 157 158 return lmo->l_ld_offset >= 0; 159 } 160 161 static CORE_ADDR 162 LM_DYNAMIC_FROM_LINK_MAP (struct so_list *so) 163 { 164 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 165 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 166 167 return extract_typed_address (so->lm_info->lm + lmo->l_ld_offset, 168 ptr_type); 169 } 170 171 static CORE_ADDR 172 LM_ADDR_CHECK (struct so_list *so, bfd *abfd) 173 { 174 if (so->lm_info->l_addr == (CORE_ADDR)-1) 175 { 176 struct bfd_section *dyninfo_sect; 177 CORE_ADDR l_addr, l_dynaddr, dynaddr, align = 0x1000; 178 179 l_addr = LM_ADDR_FROM_LINK_MAP (so); 180 181 if (! abfd || ! HAS_LM_DYNAMIC_FROM_LINK_MAP ()) 182 goto set_addr; 183 184 l_dynaddr = LM_DYNAMIC_FROM_LINK_MAP (so); 185 186 dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic"); 187 if (dyninfo_sect == NULL) 188 goto set_addr; 189 190 dynaddr = bfd_section_vma (abfd, dyninfo_sect); 191 192 if (dynaddr + l_addr != l_dynaddr) 193 { 194 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 195 { 196 Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header; 197 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr; 198 int i; 199 200 align = 1; 201 202 for (i = 0; i < ehdr->e_phnum; i++) 203 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align) 204 align = phdr[i].p_align; 205 } 206 207 /* Turn it into a mask. */ 208 align--; 209 210 /* If the changes match the alignment requirements, we 211 assume we're using a core file that was generated by the 212 same binary, just prelinked with a different base offset. 213 If it doesn't match, we may have a different binary, the 214 same binary with the dynamic table loaded at an unrelated 215 location, or anything, really. To avoid regressions, 216 don't adjust the base offset in the latter case, although 217 odds are that, if things really changed, debugging won't 218 quite work. */ 219 if ((l_addr & align) == ((l_dynaddr - dynaddr) & align)) 220 { 221 l_addr = l_dynaddr - dynaddr; 222 223 warning (_(".dynamic section for \"%s\" " 224 "is not at the expected address"), so->so_name); 225 warning (_("difference appears to be caused by prelink, " 226 "adjusting expectations")); 227 } 228 else 229 warning (_(".dynamic section for \"%s\" " 230 "is not at the expected address " 231 "(wrong library or version mismatch?)"), so->so_name); 232 } 233 234 set_addr: 235 so->lm_info->l_addr = l_addr; 236 } 237 238 return so->lm_info->l_addr; 239 } 240 241 static CORE_ADDR 242 LM_NEXT (struct so_list *so) 243 { 244 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 245 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 246 247 return extract_typed_address (so->lm_info->lm + lmo->l_next_offset, 248 ptr_type); 249 } 250 251 static CORE_ADDR 252 LM_NAME (struct so_list *so) 253 { 254 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 255 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 256 257 return extract_typed_address (so->lm_info->lm + lmo->l_name_offset, 258 ptr_type); 259 } 260 261 static int 262 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so) 263 { 264 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 265 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 266 267 /* Assume that everything is a library if the dynamic loader was loaded 268 late by a static executable. */ 269 if (exec_bfd && bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL) 270 return 0; 271 272 return extract_typed_address (so->lm_info->lm + lmo->l_prev_offset, 273 ptr_type) == 0; 274 } 275 276 /* Per-inferior SVR4 specific data. */ 277 278 struct svr4_info 279 { 280 int pid; 281 282 CORE_ADDR debug_base; /* Base of dynamic linker structures */ 283 284 /* Validity flag for debug_loader_offset. */ 285 int debug_loader_offset_p; 286 287 /* Load address for the dynamic linker, inferred. */ 288 CORE_ADDR debug_loader_offset; 289 290 /* Name of the dynamic linker, valid if debug_loader_offset_p. */ 291 char *debug_loader_name; 292 293 /* Load map address for the main executable. */ 294 CORE_ADDR main_lm_addr; 295 }; 296 297 /* List of known processes using solib-svr4 shared libraries, storing 298 the required bookkeeping for each. */ 299 300 typedef struct svr4_info *svr4_info_p; 301 DEF_VEC_P(svr4_info_p); 302 VEC(svr4_info_p) *svr4_info = NULL; 303 304 /* Get svr4 data for inferior PID (target id). If none is found yet, 305 add it now. This function always returns a valid object. */ 306 307 struct svr4_info * 308 get_svr4_info (int pid) 309 { 310 int ix; 311 struct svr4_info *it; 312 313 gdb_assert (pid != 0); 314 315 for (ix = 0; VEC_iterate (svr4_info_p, svr4_info, ix, it); ++ix) 316 { 317 if (it->pid == pid) 318 return it; 319 } 320 321 it = XZALLOC (struct svr4_info); 322 it->pid = pid; 323 324 VEC_safe_push (svr4_info_p, svr4_info, it); 325 326 return it; 327 } 328 329 /* Get rid of any svr4 related bookkeeping for inferior PID (target 330 id). */ 331 332 static void 333 remove_svr4_info (int pid) 334 { 335 int ix; 336 struct svr4_info *it; 337 338 for (ix = 0; VEC_iterate (svr4_info_p, svr4_info, ix, it); ++ix) 339 { 340 if (it->pid == pid) 341 { 342 VEC_unordered_remove (svr4_info_p, svr4_info, ix); 343 return; 344 } 345 } 346 } 347 348 /* This is an "inferior_exit" observer. Inferior PID (target id) is 349 being removed from the inferior list, because it exited, was 350 killed, detached, or we just dropped the connection to the debug 351 interface --- discard any solib-svr4 related bookkeeping for this 352 inferior. */ 353 354 static void 355 solib_svr4_inferior_exit (int pid) 356 { 357 remove_svr4_info (pid); 358 } 359 360 /* Local function prototypes */ 361 362 static int match_main (char *); 363 364 static CORE_ADDR bfd_lookup_symbol (bfd *, char *); 365 366 /* 367 368 LOCAL FUNCTION 369 370 bfd_lookup_symbol -- lookup the value for a specific symbol 371 372 SYNOPSIS 373 374 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname) 375 376 DESCRIPTION 377 378 An expensive way to lookup the value of a single symbol for 379 bfd's that are only temporary anyway. This is used by the 380 shared library support to find the address of the debugger 381 notification routine in the shared library. 382 383 The returned symbol may be in a code or data section; functions 384 will normally be in a code section, but may be in a data section 385 if this architecture uses function descriptors. 386 387 Note that 0 is specifically allowed as an error return (no 388 such symbol). 389 */ 390 391 static CORE_ADDR 392 bfd_lookup_symbol (bfd *abfd, char *symname) 393 { 394 long storage_needed; 395 asymbol *sym; 396 asymbol **symbol_table; 397 unsigned int number_of_symbols; 398 unsigned int i; 399 struct cleanup *back_to; 400 CORE_ADDR symaddr = 0; 401 402 storage_needed = bfd_get_symtab_upper_bound (abfd); 403 404 if (storage_needed > 0) 405 { 406 symbol_table = (asymbol **) xmalloc (storage_needed); 407 back_to = make_cleanup (xfree, symbol_table); 408 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 409 410 for (i = 0; i < number_of_symbols; i++) 411 { 412 sym = *symbol_table++; 413 if (strcmp (sym->name, symname) == 0 414 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0) 415 { 416 /* BFD symbols are section relative. */ 417 symaddr = sym->value + sym->section->vma; 418 break; 419 } 420 } 421 do_cleanups (back_to); 422 } 423 424 if (symaddr) 425 return symaddr; 426 427 /* On FreeBSD, the dynamic linker is stripped by default. So we'll 428 have to check the dynamic string table too. */ 429 430 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); 431 432 if (storage_needed > 0) 433 { 434 symbol_table = (asymbol **) xmalloc (storage_needed); 435 back_to = make_cleanup (xfree, symbol_table); 436 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table); 437 438 for (i = 0; i < number_of_symbols; i++) 439 { 440 sym = *symbol_table++; 441 442 if (strcmp (sym->name, symname) == 0 443 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0) 444 { 445 /* BFD symbols are section relative. */ 446 symaddr = sym->value + sym->section->vma; 447 break; 448 } 449 } 450 do_cleanups (back_to); 451 } 452 453 return symaddr; 454 } 455 456 457 /* Read program header TYPE from inferior memory. The header is found 458 by scanning the OS auxillary vector. 459 460 Return a pointer to allocated memory holding the program header contents, 461 or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the 462 size of those contents is returned to P_SECT_SIZE. Likewise, the target 463 architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE. */ 464 465 static gdb_byte * 466 read_program_header (int type, int *p_sect_size, int *p_arch_size) 467 { 468 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); 469 CORE_ADDR at_phdr, at_phent, at_phnum; 470 int arch_size, sect_size; 471 CORE_ADDR sect_addr; 472 gdb_byte *buf; 473 474 /* Get required auxv elements from target. */ 475 if (target_auxv_search (¤t_target, AT_PHDR, &at_phdr) <= 0) 476 return 0; 477 if (target_auxv_search (¤t_target, AT_PHENT, &at_phent) <= 0) 478 return 0; 479 if (target_auxv_search (¤t_target, AT_PHNUM, &at_phnum) <= 0) 480 return 0; 481 if (!at_phdr || !at_phnum) 482 return 0; 483 484 /* Determine ELF architecture type. */ 485 if (at_phent == sizeof (Elf32_External_Phdr)) 486 arch_size = 32; 487 else if (at_phent == sizeof (Elf64_External_Phdr)) 488 arch_size = 64; 489 else 490 return 0; 491 492 /* Find .dynamic section via the PT_DYNAMIC PHDR. */ 493 if (arch_size == 32) 494 { 495 Elf32_External_Phdr phdr; 496 int i; 497 498 /* Search for requested PHDR. */ 499 for (i = 0; i < at_phnum; i++) 500 { 501 if (target_read_memory (at_phdr + i * sizeof (phdr), 502 (gdb_byte *)&phdr, sizeof (phdr))) 503 return 0; 504 505 if (extract_unsigned_integer ((gdb_byte *)phdr.p_type, 506 4, byte_order) == type) 507 break; 508 } 509 510 if (i == at_phnum) 511 return 0; 512 513 /* Retrieve address and size. */ 514 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr, 515 4, byte_order); 516 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz, 517 4, byte_order); 518 } 519 else 520 { 521 Elf64_External_Phdr phdr; 522 int i; 523 524 /* Search for requested PHDR. */ 525 for (i = 0; i < at_phnum; i++) 526 { 527 if (target_read_memory (at_phdr + i * sizeof (phdr), 528 (gdb_byte *)&phdr, sizeof (phdr))) 529 return 0; 530 531 if (extract_unsigned_integer ((gdb_byte *)phdr.p_type, 532 4, byte_order) == type) 533 break; 534 } 535 536 if (i == at_phnum) 537 return 0; 538 539 /* Retrieve address and size. */ 540 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr, 541 8, byte_order); 542 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz, 543 8, byte_order); 544 } 545 546 /* Read in requested program header. */ 547 buf = xmalloc (sect_size); 548 if (target_read_memory (sect_addr, buf, sect_size)) 549 { 550 xfree (buf); 551 return NULL; 552 } 553 554 if (p_arch_size) 555 *p_arch_size = arch_size; 556 if (p_sect_size) 557 *p_sect_size = sect_size; 558 559 return buf; 560 } 561 562 563 /* Return program interpreter string. */ 564 static gdb_byte * 565 find_program_interpreter (void) 566 { 567 gdb_byte *buf = NULL; 568 569 /* If we have an exec_bfd, use its section table. */ 570 if (exec_bfd 571 && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour) 572 { 573 struct bfd_section *interp_sect; 574 575 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); 576 if (interp_sect != NULL) 577 { 578 CORE_ADDR sect_addr = bfd_section_vma (exec_bfd, interp_sect); 579 int sect_size = bfd_section_size (exec_bfd, interp_sect); 580 581 buf = xmalloc (sect_size); 582 bfd_get_section_contents (exec_bfd, interp_sect, buf, 0, sect_size); 583 } 584 } 585 586 /* If we didn't find it, use the target auxillary vector. */ 587 if (!buf) 588 buf = read_program_header (PT_INTERP, NULL, NULL); 589 590 return buf; 591 } 592 593 594 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is 595 returned and the corresponding PTR is set. */ 596 597 static int 598 scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr) 599 { 600 int arch_size, step, sect_size; 601 long dyn_tag; 602 CORE_ADDR dyn_ptr, dyn_addr; 603 gdb_byte *bufend, *bufstart, *buf; 604 Elf32_External_Dyn *x_dynp_32; 605 Elf64_External_Dyn *x_dynp_64; 606 struct bfd_section *sect; 607 608 if (abfd == NULL) 609 return 0; 610 611 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 612 return 0; 613 614 arch_size = bfd_get_arch_size (abfd); 615 if (arch_size == -1) 616 return 0; 617 618 /* Find the start address of the .dynamic section. */ 619 sect = bfd_get_section_by_name (abfd, ".dynamic"); 620 if (sect == NULL) 621 return 0; 622 dyn_addr = bfd_section_vma (abfd, sect); 623 624 /* Read in .dynamic from the BFD. We will get the actual value 625 from memory later. */ 626 sect_size = bfd_section_size (abfd, sect); 627 buf = bufstart = alloca (sect_size); 628 if (!bfd_get_section_contents (abfd, sect, 629 buf, 0, sect_size)) 630 return 0; 631 632 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */ 633 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn) 634 : sizeof (Elf64_External_Dyn); 635 for (bufend = buf + sect_size; 636 buf < bufend; 637 buf += step) 638 { 639 if (arch_size == 32) 640 { 641 x_dynp_32 = (Elf32_External_Dyn *) buf; 642 dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag); 643 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr); 644 } 645 else 646 { 647 x_dynp_64 = (Elf64_External_Dyn *) buf; 648 dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag); 649 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr); 650 } 651 if (dyn_tag == DT_NULL) 652 return 0; 653 if (dyn_tag == dyntag) 654 { 655 /* If requested, try to read the runtime value of this .dynamic 656 entry. */ 657 if (ptr) 658 { 659 struct type *ptr_type; 660 gdb_byte ptr_buf[8]; 661 CORE_ADDR ptr_addr; 662 663 ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 664 ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8; 665 if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0) 666 dyn_ptr = extract_typed_address (ptr_buf, ptr_type); 667 *ptr = dyn_ptr; 668 } 669 return 1; 670 } 671 } 672 673 return 0; 674 } 675 676 /* Scan for DYNTAG in .dynamic section of the target's main executable, 677 found by consulting the OS auxillary vector. If DYNTAG is found 1 is 678 returned and the corresponding PTR is set. */ 679 680 static int 681 scan_dyntag_auxv (int dyntag, CORE_ADDR *ptr) 682 { 683 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); 684 int sect_size, arch_size, step; 685 long dyn_tag; 686 CORE_ADDR dyn_ptr; 687 gdb_byte *bufend, *bufstart, *buf; 688 689 /* Read in .dynamic section. */ 690 buf = bufstart = read_program_header (PT_DYNAMIC, §_size, &arch_size); 691 if (!buf) 692 return 0; 693 694 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */ 695 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn) 696 : sizeof (Elf64_External_Dyn); 697 for (bufend = buf + sect_size; 698 buf < bufend; 699 buf += step) 700 { 701 if (arch_size == 32) 702 { 703 Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf; 704 dyn_tag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag, 705 4, byte_order); 706 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr, 707 4, byte_order); 708 } 709 else 710 { 711 Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf; 712 dyn_tag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag, 713 8, byte_order); 714 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr, 715 8, byte_order); 716 } 717 if (dyn_tag == DT_NULL) 718 break; 719 720 if (dyn_tag == dyntag) 721 { 722 if (ptr) 723 *ptr = dyn_ptr; 724 725 xfree (bufstart); 726 return 1; 727 } 728 } 729 730 xfree (bufstart); 731 return 0; 732 } 733 734 735 /* 736 737 LOCAL FUNCTION 738 739 elf_locate_base -- locate the base address of dynamic linker structs 740 for SVR4 elf targets. 741 742 SYNOPSIS 743 744 CORE_ADDR elf_locate_base (void) 745 746 DESCRIPTION 747 748 For SVR4 elf targets the address of the dynamic linker's runtime 749 structure is contained within the dynamic info section in the 750 executable file. The dynamic section is also mapped into the 751 inferior address space. Because the runtime loader fills in the 752 real address before starting the inferior, we have to read in the 753 dynamic info section from the inferior address space. 754 If there are any errors while trying to find the address, we 755 silently return 0, otherwise the found address is returned. 756 757 */ 758 759 static CORE_ADDR 760 elf_locate_base (void) 761 { 762 struct minimal_symbol *msymbol; 763 CORE_ADDR dyn_ptr; 764 765 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this 766 instead of DT_DEBUG, although they sometimes contain an unused 767 DT_DEBUG. */ 768 if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr) 769 || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr)) 770 { 771 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 772 gdb_byte *pbuf; 773 int pbuf_size = TYPE_LENGTH (ptr_type); 774 pbuf = alloca (pbuf_size); 775 /* DT_MIPS_RLD_MAP contains a pointer to the address 776 of the dynamic link structure. */ 777 if (target_read_memory (dyn_ptr, pbuf, pbuf_size)) 778 return 0; 779 return extract_typed_address (pbuf, ptr_type); 780 } 781 782 /* Find DT_DEBUG. */ 783 if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr) 784 || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr)) 785 return dyn_ptr; 786 787 /* This may be a static executable. Look for the symbol 788 conventionally named _r_debug, as a last resort. */ 789 msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile); 790 if (msymbol != NULL) 791 return SYMBOL_VALUE_ADDRESS (msymbol); 792 793 /* DT_DEBUG entry not found. */ 794 return 0; 795 } 796 797 /* 798 799 LOCAL FUNCTION 800 801 locate_base -- locate the base address of dynamic linker structs 802 803 SYNOPSIS 804 805 CORE_ADDR locate_base (struct svr4_info *) 806 807 DESCRIPTION 808 809 For both the SunOS and SVR4 shared library implementations, if the 810 inferior executable has been linked dynamically, there is a single 811 address somewhere in the inferior's data space which is the key to 812 locating all of the dynamic linker's runtime structures. This 813 address is the value of the debug base symbol. The job of this 814 function is to find and return that address, or to return 0 if there 815 is no such address (the executable is statically linked for example). 816 817 For SunOS, the job is almost trivial, since the dynamic linker and 818 all of it's structures are statically linked to the executable at 819 link time. Thus the symbol for the address we are looking for has 820 already been added to the minimal symbol table for the executable's 821 objfile at the time the symbol file's symbols were read, and all we 822 have to do is look it up there. Note that we explicitly do NOT want 823 to find the copies in the shared library. 824 825 The SVR4 version is a bit more complicated because the address 826 is contained somewhere in the dynamic info section. We have to go 827 to a lot more work to discover the address of the debug base symbol. 828 Because of this complexity, we cache the value we find and return that 829 value on subsequent invocations. Note there is no copy in the 830 executable symbol tables. 831 832 */ 833 834 static CORE_ADDR 835 locate_base (struct svr4_info *info) 836 { 837 /* Check to see if we have a currently valid address, and if so, avoid 838 doing all this work again and just return the cached address. If 839 we have no cached address, try to locate it in the dynamic info 840 section for ELF executables. There's no point in doing any of this 841 though if we don't have some link map offsets to work with. */ 842 843 if (info->debug_base == 0 && svr4_have_link_map_offsets ()) 844 info->debug_base = elf_locate_base (); 845 return info->debug_base; 846 } 847 848 /* Find the first element in the inferior's dynamic link map, and 849 return its address in the inferior. 850 851 FIXME: Perhaps we should validate the info somehow, perhaps by 852 checking r_version for a known version number, or r_state for 853 RT_CONSISTENT. */ 854 855 static CORE_ADDR 856 solib_svr4_r_map (struct svr4_info *info) 857 { 858 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 859 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 860 861 return read_memory_typed_address (info->debug_base + lmo->r_map_offset, 862 ptr_type); 863 } 864 865 /* Find r_brk from the inferior's debug base. */ 866 867 static CORE_ADDR 868 solib_svr4_r_brk (struct svr4_info *info) 869 { 870 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 871 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 872 873 return read_memory_typed_address (info->debug_base + lmo->r_brk_offset, 874 ptr_type); 875 } 876 877 /* Find the link map for the dynamic linker (if it is not in the 878 normal list of loaded shared objects). */ 879 880 static CORE_ADDR 881 solib_svr4_r_ldsomap (struct svr4_info *info) 882 { 883 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 884 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 885 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); 886 ULONGEST version; 887 888 /* Check version, and return zero if `struct r_debug' doesn't have 889 the r_ldsomap member. */ 890 version 891 = read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset, 892 lmo->r_version_size, byte_order); 893 if (version < 2 || lmo->r_ldsomap_offset == -1) 894 return 0; 895 896 return read_memory_typed_address (info->debug_base + lmo->r_ldsomap_offset, 897 ptr_type); 898 } 899 900 /* 901 902 LOCAL FUNCTION 903 904 open_symbol_file_object 905 906 SYNOPSIS 907 908 void open_symbol_file_object (void *from_tty) 909 910 DESCRIPTION 911 912 If no open symbol file, attempt to locate and open the main symbol 913 file. On SVR4 systems, this is the first link map entry. If its 914 name is here, we can open it. Useful when attaching to a process 915 without first loading its symbol file. 916 917 If FROM_TTYP dereferences to a non-zero integer, allow messages to 918 be printed. This parameter is a pointer rather than an int because 919 open_symbol_file_object() is called via catch_errors() and 920 catch_errors() requires a pointer argument. */ 921 922 static int 923 open_symbol_file_object (void *from_ttyp) 924 { 925 CORE_ADDR lm, l_name; 926 char *filename; 927 int errcode; 928 int from_tty = *(int *)from_ttyp; 929 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 930 struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; 931 int l_name_size = TYPE_LENGTH (ptr_type); 932 gdb_byte *l_name_buf = xmalloc (l_name_size); 933 struct cleanup *cleanups = make_cleanup (xfree, l_name_buf); 934 struct svr4_info *info = get_svr4_info (PIDGET (inferior_ptid)); 935 936 if (symfile_objfile) 937 if (!query (_("Attempt to reload symbols from process? "))) 938 return 0; 939 940 /* Always locate the debug struct, in case it has moved. */ 941 info->debug_base = 0; 942 if (locate_base (info) == 0) 943 return 0; /* failed somehow... */ 944 945 /* First link map member should be the executable. */ 946 lm = solib_svr4_r_map (info); 947 if (lm == 0) 948 return 0; /* failed somehow... */ 949 950 /* Read address of name from target memory to GDB. */ 951 read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size); 952 953 /* Convert the address to host format. */ 954 l_name = extract_typed_address (l_name_buf, ptr_type); 955 956 /* Free l_name_buf. */ 957 do_cleanups (cleanups); 958 959 if (l_name == 0) 960 return 0; /* No filename. */ 961 962 /* Now fetch the filename from target memory. */ 963 target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode); 964 make_cleanup (xfree, filename); 965 966 if (errcode) 967 { 968 warning (_("failed to read exec filename from attached file: %s"), 969 safe_strerror (errcode)); 970 return 0; 971 } 972 973 /* Have a pathname: read the symbol file. */ 974 symbol_file_add_main (filename, from_tty); 975 976 return 1; 977 } 978 979 /* If no shared library information is available from the dynamic 980 linker, build a fallback list from other sources. */ 981 982 static struct so_list * 983 svr4_default_sos (void) 984 { 985 struct inferior *inf = current_inferior (); 986 struct svr4_info *info = get_svr4_info (inf->pid); 987 988 struct so_list *head = NULL; 989 struct so_list **link_ptr = &head; 990 991 if (info->debug_loader_offset_p) 992 { 993 struct so_list *new = XZALLOC (struct so_list); 994 995 new->lm_info = xmalloc (sizeof (struct lm_info)); 996 997 /* Nothing will ever check the cached copy of the link 998 map if we set l_addr. */ 999 new->lm_info->l_addr = info->debug_loader_offset; 1000 new->lm_info->lm_addr = 0; 1001 new->lm_info->lm = NULL; 1002 1003 strncpy (new->so_name, info->debug_loader_name, 1004 SO_NAME_MAX_PATH_SIZE - 1); 1005 new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; 1006 strcpy (new->so_original_name, new->so_name); 1007 1008 *link_ptr = new; 1009 link_ptr = &new->next; 1010 } 1011 1012 return head; 1013 } 1014 1015 /* LOCAL FUNCTION 1016 1017 current_sos -- build a list of currently loaded shared objects 1018 1019 SYNOPSIS 1020 1021 struct so_list *current_sos () 1022 1023 DESCRIPTION 1024 1025 Build a list of `struct so_list' objects describing the shared 1026 objects currently loaded in the inferior. This list does not 1027 include an entry for the main executable file. 1028 1029 Note that we only gather information directly available from the 1030 inferior --- we don't examine any of the shared library files 1031 themselves. The declaration of `struct so_list' says which fields 1032 we provide values for. */ 1033 1034 static struct so_list * 1035 svr4_current_sos (void) 1036 { 1037 CORE_ADDR lm; 1038 struct so_list *head = 0; 1039 struct so_list **link_ptr = &head; 1040 CORE_ADDR ldsomap = 0; 1041 struct inferior *inf; 1042 struct svr4_info *info; 1043 1044 if (ptid_equal (inferior_ptid, null_ptid)) 1045 return NULL; 1046 1047 inf = current_inferior (); 1048 info = get_svr4_info (inf->pid); 1049 1050 /* Always locate the debug struct, in case it has moved. */ 1051 info->debug_base = 0; 1052 locate_base (info); 1053 1054 /* If we can't find the dynamic linker's base structure, this 1055 must not be a dynamically linked executable. Hmm. */ 1056 if (! info->debug_base) 1057 return svr4_default_sos (); 1058 1059 /* Walk the inferior's link map list, and build our list of 1060 `struct so_list' nodes. */ 1061 lm = solib_svr4_r_map (info); 1062 1063 while (lm) 1064 { 1065 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); 1066 struct so_list *new = XZALLOC (struct so_list); 1067 struct cleanup *old_chain = make_cleanup (xfree, new); 1068 1069 new->lm_info = xmalloc (sizeof (struct lm_info)); 1070 make_cleanup (xfree, new->lm_info); 1071 1072 new->lm_info->l_addr = (CORE_ADDR)-1; 1073 new->lm_info->lm_addr = lm; 1074 new->lm_info->lm = xzalloc (lmo->link_map_size); 1075 make_cleanup (xfree, new->lm_info->lm); 1076 1077 read_memory (lm, new->lm_info->lm, lmo->link_map_size); 1078 1079 lm = LM_NEXT (new); 1080 1081 /* For SVR4 versions, the first entry in the link map is for the 1082 inferior executable, so we must ignore it. For some versions of 1083 SVR4, it has no name. For others (Solaris 2.3 for example), it 1084 does have a name, so we can no longer use a missing name to 1085 decide when to ignore it. */ 1086 if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap == 0) 1087 { 1088 info->main_lm_addr = new->lm_info->lm_addr; 1089 free_so (new); 1090 } 1091 else 1092 { 1093 int errcode; 1094 char *buffer; 1095 1096 /* Extract this shared object's name. */ 1097 target_read_string (LM_NAME (new), &buffer, 1098 SO_NAME_MAX_PATH_SIZE - 1, &errcode); 1099 if (errcode != 0) 1100 warning (_("Can't read pathname for load map: %s."), 1101 safe_strerror (errcode)); 1102 else 1103 { 1104 strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1); 1105 new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; 1106 strcpy (new->so_original_name, new->so_name); 1107 } 1108 xfree (buffer); 1109 1110 /* If this entry has no name, or its name matches the name 1111 for the main executable, don't include it in the list. */ 1112 if (! new->so_name[0] 1113 || match_main (new->so_name)) 1114 free_so (new); 1115 else 1116 { 1117 new->next = 0; 1118 *link_ptr = new; 1119 link_ptr = &new->next; 1120 } 1121 } 1122 1123 /* On Solaris, the dynamic linker is not in the normal list of 1124 shared objects, so make sure we pick it up too. Having 1125 symbol information for the dynamic linker is quite crucial 1126 for skipping dynamic linker resolver code. */ 1127 if (lm == 0 && ldsomap == 0) 1128 lm = ldsomap = solib_svr4_r_ldsomap (info); 1129 1130 discard_cleanups (old_chain); 1131 } 1132 1133 if (head == NULL) 1134 return svr4_default_sos (); 1135 1136 return head; 1137 } 1138 1139 /* Get the address of the link_map for a given OBJFILE. */ 1140 1141 CORE_ADDR 1142 svr4_fetch_objfile_link_map (struct objfile *objfile) 1143 { 1144 struct so_list *so; 1145 struct svr4_info *info = get_svr4_info (PIDGET (inferior_ptid)); 1146 1147 /* Cause svr4_current_sos() to be run if it hasn't been already. */ 1148 if (info->main_lm_addr == 0) 1149 solib_add (NULL, 0, ¤t_target, auto_solib_add); 1150 1151 /* svr4_current_sos() will set main_lm_addr for the main executable. */ 1152 if (objfile == symfile_objfile) 1153 return info->main_lm_addr; 1154 1155 /* The other link map addresses may be found by examining the list 1156 of shared libraries. */ 1157 for (so = master_so_list (); so; so = so->next) 1158 if (so->objfile == objfile) 1159 return so->lm_info->lm_addr; 1160 1161 /* Not found! */ 1162 return 0; 1163 } 1164 1165 /* On some systems, the only way to recognize the link map entry for 1166 the main executable file is by looking at its name. Return 1167 non-zero iff SONAME matches one of the known main executable names. */ 1168 1169 static int 1170 match_main (char *soname) 1171 { 1172 char **mainp; 1173 1174 for (mainp = main_name_list; *mainp != NULL; mainp++) 1175 { 1176 if (strcmp (soname, *mainp) == 0) 1177 return (1); 1178 } 1179 1180 return (0); 1181 } 1182 1183 /* Return 1 if PC lies in the dynamic symbol resolution code of the 1184 SVR4 run time loader. */ 1185 static CORE_ADDR interp_text_sect_low; 1186 static CORE_ADDR interp_text_sect_high; 1187 static CORE_ADDR interp_plt_sect_low; 1188 static CORE_ADDR interp_plt_sect_high; 1189 1190 int 1191 svr4_in_dynsym_resolve_code (CORE_ADDR pc) 1192 { 1193 return ((pc >= interp_text_sect_low && pc < interp_text_sect_high) 1194 || (pc >= interp_plt_sect_low && pc < interp_plt_sect_high) 1195 || in_plt_section (pc, NULL)); 1196 } 1197 1198 /* Given an executable's ABFD and target, compute the entry-point 1199 address. */ 1200 1201 static CORE_ADDR 1202 exec_entry_point (struct bfd *abfd, struct target_ops *targ) 1203 { 1204 /* KevinB wrote ... for most targets, the address returned by 1205 bfd_get_start_address() is the entry point for the start 1206 function. But, for some targets, bfd_get_start_address() returns 1207 the address of a function descriptor from which the entry point 1208 address may be extracted. This address is extracted by 1209 gdbarch_convert_from_func_ptr_addr(). The method 1210 gdbarch_convert_from_func_ptr_addr() is the merely the identify 1211 function for targets which don't use function descriptors. */ 1212 return gdbarch_convert_from_func_ptr_addr (target_gdbarch, 1213 bfd_get_start_address (abfd), 1214 targ); 1215 } 1216 1217 /* 1218 1219 LOCAL FUNCTION 1220 1221 enable_break -- arrange for dynamic linker to hit breakpoint 1222 1223 SYNOPSIS 1224 1225 int enable_break (void) 1226 1227 DESCRIPTION 1228 1229 Both the SunOS and the SVR4 dynamic linkers have, as part of their 1230 debugger interface, support for arranging for the inferior to hit 1231 a breakpoint after mapping in the shared libraries. This function 1232 enables that breakpoint. 1233 1234 For SunOS, there is a special flag location (in_debugger) which we 1235 set to 1. When the dynamic linker sees this flag set, it will set 1236 a breakpoint at a location known only to itself, after saving the 1237 original contents of that place and the breakpoint address itself, 1238 in it's own internal structures. When we resume the inferior, it 1239 will eventually take a SIGTRAP when it runs into the breakpoint. 1240 We handle this (in a different place) by restoring the contents of 1241 the breakpointed location (which is only known after it stops), 1242 chasing around to locate the shared libraries that have been 1243 loaded, then resuming. 1244 1245 For SVR4, the debugger interface structure contains a member (r_brk) 1246 which is statically initialized at the time the shared library is 1247 built, to the offset of a function (_r_debug_state) which is guaran- 1248 teed to be called once before mapping in a library, and again when 1249 the mapping is complete. At the time we are examining this member, 1250 it contains only the unrelocated offset of the function, so we have 1251 to do our own relocation. Later, when the dynamic linker actually 1252 runs, it relocates r_brk to be the actual address of _r_debug_state(). 1253 1254 The debugger interface structure also contains an enumeration which 1255 is set to either RT_ADD or RT_DELETE prior to changing the mapping, 1256 depending upon whether or not the library is being mapped or unmapped, 1257 and then set to RT_CONSISTENT after the library is mapped/unmapped. 1258 */ 1259 1260 static int 1261 enable_break (struct svr4_info *info) 1262 { 1263 struct minimal_symbol *msymbol; 1264 char **bkpt_namep; 1265 asection *interp_sect; 1266 gdb_byte *interp_name; 1267 CORE_ADDR sym_addr; 1268 struct inferior *inf = current_inferior (); 1269 1270 /* First, remove all the solib event breakpoints. Their addresses 1271 may have changed since the last time we ran the program. */ 1272 remove_solib_event_breakpoints (); 1273 1274 interp_text_sect_low = interp_text_sect_high = 0; 1275 interp_plt_sect_low = interp_plt_sect_high = 0; 1276 1277 /* If we already have a shared library list in the target, and 1278 r_debug contains r_brk, set the breakpoint there - this should 1279 mean r_brk has already been relocated. Assume the dynamic linker 1280 is the object containing r_brk. */ 1281 1282 solib_add (NULL, 0, ¤t_target, auto_solib_add); 1283 sym_addr = 0; 1284 if (info->debug_base && solib_svr4_r_map (info) != 0) 1285 sym_addr = solib_svr4_r_brk (info); 1286 1287 if (sym_addr != 0) 1288 { 1289 struct obj_section *os; 1290 1291 sym_addr = gdbarch_addr_bits_remove 1292 (target_gdbarch, gdbarch_convert_from_func_ptr_addr (target_gdbarch, 1293 sym_addr, 1294 ¤t_target)); 1295 1296 os = find_pc_section (sym_addr); 1297 if (os != NULL) 1298 { 1299 /* Record the relocated start and end address of the dynamic linker 1300 text and plt section for svr4_in_dynsym_resolve_code. */ 1301 bfd *tmp_bfd; 1302 CORE_ADDR load_addr; 1303 1304 tmp_bfd = os->objfile->obfd; 1305 load_addr = ANOFFSET (os->objfile->section_offsets, 1306 os->objfile->sect_index_text); 1307 1308 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text"); 1309 if (interp_sect) 1310 { 1311 interp_text_sect_low = 1312 bfd_section_vma (tmp_bfd, interp_sect) + load_addr; 1313 interp_text_sect_high = 1314 interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect); 1315 } 1316 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt"); 1317 if (interp_sect) 1318 { 1319 interp_plt_sect_low = 1320 bfd_section_vma (tmp_bfd, interp_sect) + load_addr; 1321 interp_plt_sect_high = 1322 interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect); 1323 } 1324 1325 create_solib_event_breakpoint (target_gdbarch, sym_addr); 1326 return 1; 1327 } 1328 } 1329 1330 /* Find the program interpreter; if not found, warn the user and drop 1331 into the old breakpoint at symbol code. */ 1332 interp_name = find_program_interpreter (); 1333 if (interp_name) 1334 { 1335 CORE_ADDR load_addr = 0; 1336 int load_addr_found = 0; 1337 int loader_found_in_list = 0; 1338 struct so_list *so; 1339 bfd *tmp_bfd = NULL; 1340 struct target_ops *tmp_bfd_target; 1341 volatile struct gdb_exception ex; 1342 1343 sym_addr = 0; 1344 1345 /* Now we need to figure out where the dynamic linker was 1346 loaded so that we can load its symbols and place a breakpoint 1347 in the dynamic linker itself. 1348 1349 This address is stored on the stack. However, I've been unable 1350 to find any magic formula to find it for Solaris (appears to 1351 be trivial on GNU/Linux). Therefore, we have to try an alternate 1352 mechanism to find the dynamic linker's base address. */ 1353 1354 TRY_CATCH (ex, RETURN_MASK_ALL) 1355 { 1356 tmp_bfd = solib_bfd_open (interp_name); 1357 } 1358 if (tmp_bfd == NULL) 1359 goto bkpt_at_symbol; 1360 1361 /* Now convert the TMP_BFD into a target. That way target, as 1362 well as BFD operations can be used. Note that closing the 1363 target will also close the underlying bfd. */ 1364 tmp_bfd_target = target_bfd_reopen (tmp_bfd); 1365 1366 /* On a running target, we can get the dynamic linker's base 1367 address from the shared library table. */ 1368 so = master_so_list (); 1369 while (so) 1370 { 1371 if (svr4_same_1 (interp_name, so->so_original_name)) 1372 { 1373 load_addr_found = 1; 1374 loader_found_in_list = 1; 1375 load_addr = LM_ADDR_CHECK (so, tmp_bfd); 1376 break; 1377 } 1378 so = so->next; 1379 } 1380 1381 /* If we were not able to find the base address of the loader 1382 from our so_list, then try using the AT_BASE auxilliary entry. */ 1383 if (!load_addr_found) 1384 if (target_auxv_search (¤t_target, AT_BASE, &load_addr) > 0) 1385 load_addr_found = 1; 1386 1387 /* Otherwise we find the dynamic linker's base address by examining 1388 the current pc (which should point at the entry point for the 1389 dynamic linker) and subtracting the offset of the entry point. 1390 1391 This is more fragile than the previous approaches, but is a good 1392 fallback method because it has actually been working well in 1393 most cases. */ 1394 if (!load_addr_found) 1395 { 1396 struct regcache *regcache 1397 = get_thread_arch_regcache (inferior_ptid, target_gdbarch); 1398 load_addr = (regcache_read_pc (regcache) 1399 - exec_entry_point (tmp_bfd, tmp_bfd_target)); 1400 } 1401 1402 if (!loader_found_in_list) 1403 { 1404 info->debug_loader_name = xstrdup (interp_name); 1405 info->debug_loader_offset_p = 1; 1406 info->debug_loader_offset = load_addr; 1407 solib_add (NULL, 0, ¤t_target, auto_solib_add); 1408 } 1409 1410 /* Record the relocated start and end address of the dynamic linker 1411 text and plt section for svr4_in_dynsym_resolve_code. */ 1412 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text"); 1413 if (interp_sect) 1414 { 1415 interp_text_sect_low = 1416 bfd_section_vma (tmp_bfd, interp_sect) + load_addr; 1417 interp_text_sect_high = 1418 interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect); 1419 } 1420 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt"); 1421 if (interp_sect) 1422 { 1423 interp_plt_sect_low = 1424 bfd_section_vma (tmp_bfd, interp_sect) + load_addr; 1425 interp_plt_sect_high = 1426 interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect); 1427 } 1428 1429 /* Now try to set a breakpoint in the dynamic linker. */ 1430 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++) 1431 { 1432 sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep); 1433 if (sym_addr != 0) 1434 break; 1435 } 1436 1437 if (sym_addr != 0) 1438 /* Convert 'sym_addr' from a function pointer to an address. 1439 Because we pass tmp_bfd_target instead of the current 1440 target, this will always produce an unrelocated value. */ 1441 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch, 1442 sym_addr, 1443 tmp_bfd_target); 1444 1445 /* We're done with both the temporary bfd and target. Remember, 1446 closing the target closes the underlying bfd. */ 1447 target_close (tmp_bfd_target, 0); 1448 1449 if (sym_addr != 0) 1450 { 1451 create_solib_event_breakpoint (target_gdbarch, load_addr + sym_addr); 1452 xfree (interp_name); 1453 return 1; 1454 } 1455 1456 /* For whatever reason we couldn't set a breakpoint in the dynamic 1457 linker. Warn and drop into the old code. */ 1458 bkpt_at_symbol: 1459 xfree (interp_name); 1460 warning (_("Unable to find dynamic linker breakpoint function.\n" 1461 "GDB will be unable to debug shared library initializers\n" 1462 "and track explicitly loaded dynamic code.")); 1463 } 1464 1465 /* Scan through the lists of symbols, trying to look up the symbol and 1466 set a breakpoint there. Terminate loop when we/if we succeed. */ 1467 1468 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++) 1469 { 1470 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile); 1471 if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0)) 1472 { 1473 create_solib_event_breakpoint (target_gdbarch, 1474 SYMBOL_VALUE_ADDRESS (msymbol)); 1475 return 1; 1476 } 1477 } 1478 1479 for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++) 1480 { 1481 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile); 1482 if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0)) 1483 { 1484 create_solib_event_breakpoint (target_gdbarch, 1485 SYMBOL_VALUE_ADDRESS (msymbol)); 1486 return 1; 1487 } 1488 } 1489 return 0; 1490 } 1491 1492 /* 1493 1494 LOCAL FUNCTION 1495 1496 special_symbol_handling -- additional shared library symbol handling 1497 1498 SYNOPSIS 1499 1500 void special_symbol_handling () 1501 1502 DESCRIPTION 1503 1504 Once the symbols from a shared object have been loaded in the usual 1505 way, we are called to do any system specific symbol handling that 1506 is needed. 1507 1508 For SunOS4, this consisted of grunging around in the dynamic 1509 linkers structures to find symbol definitions for "common" symbols 1510 and adding them to the minimal symbol table for the runtime common 1511 objfile. 1512 1513 However, for SVR4, there's nothing to do. 1514 1515 */ 1516 1517 static void 1518 svr4_special_symbol_handling (void) 1519 { 1520 } 1521 1522 /* Relocate the main executable. This function should be called upon 1523 stopping the inferior process at the entry point to the program. 1524 The entry point from BFD is compared to the PC and if they are 1525 different, the main executable is relocated by the proper amount. 1526 1527 As written it will only attempt to relocate executables which 1528 lack interpreter sections. It seems likely that only dynamic 1529 linker executables will get relocated, though it should work 1530 properly for a position-independent static executable as well. */ 1531 1532 static void 1533 svr4_relocate_main_executable (void) 1534 { 1535 asection *interp_sect; 1536 struct regcache *regcache 1537 = get_thread_arch_regcache (inferior_ptid, target_gdbarch); 1538 CORE_ADDR pc = regcache_read_pc (regcache); 1539 1540 /* Decide if the objfile needs to be relocated. As indicated above, 1541 we will only be here when execution is stopped at the beginning 1542 of the program. Relocation is necessary if the address at which 1543 we are presently stopped differs from the start address stored in 1544 the executable AND there's no interpreter section. The condition 1545 regarding the interpreter section is very important because if 1546 there *is* an interpreter section, execution will begin there 1547 instead. When there is an interpreter section, the start address 1548 is (presumably) used by the interpreter at some point to start 1549 execution of the program. 1550 1551 If there is an interpreter, it is normal for it to be set to an 1552 arbitrary address at the outset. The job of finding it is 1553 handled in enable_break(). 1554 1555 So, to summarize, relocations are necessary when there is no 1556 interpreter section and the start address obtained from the 1557 executable is different from the address at which GDB is 1558 currently stopped. 1559 1560 [ The astute reader will note that we also test to make sure that 1561 the executable in question has the DYNAMIC flag set. It is my 1562 opinion that this test is unnecessary (undesirable even). It 1563 was added to avoid inadvertent relocation of an executable 1564 whose e_type member in the ELF header is not ET_DYN. There may 1565 be a time in the future when it is desirable to do relocations 1566 on other types of files as well in which case this condition 1567 should either be removed or modified to accomodate the new file 1568 type. (E.g, an ET_EXEC executable which has been built to be 1569 position-independent could safely be relocated by the OS if 1570 desired. It is true that this violates the ABI, but the ABI 1571 has been known to be bent from time to time.) - Kevin, Nov 2000. ] 1572 */ 1573 1574 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); 1575 if (interp_sect == NULL 1576 && (bfd_get_file_flags (exec_bfd) & DYNAMIC) != 0 1577 && (exec_entry_point (exec_bfd, &exec_ops) != pc)) 1578 { 1579 struct cleanup *old_chain; 1580 struct section_offsets *new_offsets; 1581 int i, changed; 1582 CORE_ADDR displacement; 1583 1584 /* It is necessary to relocate the objfile. The amount to 1585 relocate by is simply the address at which we are stopped 1586 minus the starting address from the executable. 1587 1588 We relocate all of the sections by the same amount. This 1589 behavior is mandated by recent editions of the System V ABI. 1590 According to the System V Application Binary Interface, 1591 Edition 4.1, page 5-5: 1592 1593 ... Though the system chooses virtual addresses for 1594 individual processes, it maintains the segments' relative 1595 positions. Because position-independent code uses relative 1596 addressesing between segments, the difference between 1597 virtual addresses in memory must match the difference 1598 between virtual addresses in the file. The difference 1599 between the virtual address of any segment in memory and 1600 the corresponding virtual address in the file is thus a 1601 single constant value for any one executable or shared 1602 object in a given process. This difference is the base 1603 address. One use of the base address is to relocate the 1604 memory image of the program during dynamic linking. 1605 1606 The same language also appears in Edition 4.0 of the System V 1607 ABI and is left unspecified in some of the earlier editions. */ 1608 1609 displacement = pc - exec_entry_point (exec_bfd, &exec_ops); 1610 changed = 0; 1611 1612 new_offsets = xcalloc (symfile_objfile->num_sections, 1613 sizeof (struct section_offsets)); 1614 old_chain = make_cleanup (xfree, new_offsets); 1615 1616 for (i = 0; i < symfile_objfile->num_sections; i++) 1617 { 1618 if (displacement != ANOFFSET (symfile_objfile->section_offsets, i)) 1619 changed = 1; 1620 new_offsets->offsets[i] = displacement; 1621 } 1622 1623 if (changed) 1624 objfile_relocate (symfile_objfile, new_offsets); 1625 1626 do_cleanups (old_chain); 1627 } 1628 } 1629 1630 /* 1631 1632 GLOBAL FUNCTION 1633 1634 svr4_solib_create_inferior_hook -- shared library startup support 1635 1636 SYNOPSIS 1637 1638 void svr4_solib_create_inferior_hook () 1639 1640 DESCRIPTION 1641 1642 When gdb starts up the inferior, it nurses it along (through the 1643 shell) until it is ready to execute it's first instruction. At this 1644 point, this function gets called via expansion of the macro 1645 SOLIB_CREATE_INFERIOR_HOOK. 1646 1647 For SunOS executables, this first instruction is typically the 1648 one at "_start", or a similar text label, regardless of whether 1649 the executable is statically or dynamically linked. The runtime 1650 startup code takes care of dynamically linking in any shared 1651 libraries, once gdb allows the inferior to continue. 1652 1653 For SVR4 executables, this first instruction is either the first 1654 instruction in the dynamic linker (for dynamically linked 1655 executables) or the instruction at "start" for statically linked 1656 executables. For dynamically linked executables, the system 1657 first exec's /lib/libc.so.N, which contains the dynamic linker, 1658 and starts it running. The dynamic linker maps in any needed 1659 shared libraries, maps in the actual user executable, and then 1660 jumps to "start" in the user executable. 1661 1662 For both SunOS shared libraries, and SVR4 shared libraries, we 1663 can arrange to cooperate with the dynamic linker to discover the 1664 names of shared libraries that are dynamically linked, and the 1665 base addresses to which they are linked. 1666 1667 This function is responsible for discovering those names and 1668 addresses, and saving sufficient information about them to allow 1669 their symbols to be read at a later time. 1670 1671 FIXME 1672 1673 Between enable_break() and disable_break(), this code does not 1674 properly handle hitting breakpoints which the user might have 1675 set in the startup code or in the dynamic linker itself. Proper 1676 handling will probably have to wait until the implementation is 1677 changed to use the "breakpoint handler function" method. 1678 1679 Also, what if child has exit()ed? Must exit loop somehow. 1680 */ 1681 1682 static void 1683 svr4_solib_create_inferior_hook (void) 1684 { 1685 struct inferior *inf; 1686 struct thread_info *tp; 1687 struct svr4_info *info; 1688 1689 info = get_svr4_info (PIDGET (inferior_ptid)); 1690 1691 /* Relocate the main executable if necessary. */ 1692 svr4_relocate_main_executable (); 1693 1694 if (!svr4_have_link_map_offsets ()) 1695 return; 1696 1697 if (!enable_break (info)) 1698 return; 1699 1700 #if defined(_SCO_DS) 1701 /* SCO needs the loop below, other systems should be using the 1702 special shared library breakpoints and the shared library breakpoint 1703 service routine. 1704 1705 Now run the target. It will eventually hit the breakpoint, at 1706 which point all of the libraries will have been mapped in and we 1707 can go groveling around in the dynamic linker structures to find 1708 out what we need to know about them. */ 1709 1710 inf = current_inferior (); 1711 tp = inferior_thread (); 1712 1713 clear_proceed_status (); 1714 inf->stop_soon = STOP_QUIETLY; 1715 tp->stop_signal = TARGET_SIGNAL_0; 1716 do 1717 { 1718 target_resume (pid_to_ptid (-1), 0, tp->stop_signal); 1719 wait_for_inferior (0); 1720 } 1721 while (tp->stop_signal != TARGET_SIGNAL_TRAP); 1722 inf->stop_soon = NO_STOP_QUIETLY; 1723 #endif /* defined(_SCO_DS) */ 1724 } 1725 1726 static void 1727 svr4_clear_solib (void) 1728 { 1729 remove_svr4_info (PIDGET (inferior_ptid)); 1730 } 1731 1732 static void 1733 svr4_free_so (struct so_list *so) 1734 { 1735 xfree (so->lm_info->lm); 1736 xfree (so->lm_info); 1737 } 1738 1739 1740 /* Clear any bits of ADDR that wouldn't fit in a target-format 1741 data pointer. "Data pointer" here refers to whatever sort of 1742 address the dynamic linker uses to manage its sections. At the 1743 moment, we don't support shared libraries on any processors where 1744 code and data pointers are different sizes. 1745 1746 This isn't really the right solution. What we really need here is 1747 a way to do arithmetic on CORE_ADDR values that respects the 1748 natural pointer/address correspondence. (For example, on the MIPS, 1749 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to 1750 sign-extend the value. There, simply truncating the bits above 1751 gdbarch_ptr_bit, as we do below, is no good.) This should probably 1752 be a new gdbarch method or something. */ 1753 static CORE_ADDR 1754 svr4_truncate_ptr (CORE_ADDR addr) 1755 { 1756 if (gdbarch_ptr_bit (target_gdbarch) == sizeof (CORE_ADDR) * 8) 1757 /* We don't need to truncate anything, and the bit twiddling below 1758 will fail due to overflow problems. */ 1759 return addr; 1760 else 1761 return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch)) - 1); 1762 } 1763 1764 1765 static void 1766 svr4_relocate_section_addresses (struct so_list *so, 1767 struct target_section *sec) 1768 { 1769 sec->addr = svr4_truncate_ptr (sec->addr + LM_ADDR_CHECK (so, 1770 sec->bfd)); 1771 sec->endaddr = svr4_truncate_ptr (sec->endaddr + LM_ADDR_CHECK (so, 1772 sec->bfd)); 1773 } 1774 1775 1776 /* Architecture-specific operations. */ 1777 1778 /* Per-architecture data key. */ 1779 static struct gdbarch_data *solib_svr4_data; 1780 1781 struct solib_svr4_ops 1782 { 1783 /* Return a description of the layout of `struct link_map'. */ 1784 struct link_map_offsets *(*fetch_link_map_offsets)(void); 1785 }; 1786 1787 /* Return a default for the architecture-specific operations. */ 1788 1789 static void * 1790 solib_svr4_init (struct obstack *obstack) 1791 { 1792 struct solib_svr4_ops *ops; 1793 1794 ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops); 1795 ops->fetch_link_map_offsets = NULL; 1796 return ops; 1797 } 1798 1799 /* Set the architecture-specific `struct link_map_offsets' fetcher for 1800 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */ 1801 1802 void 1803 set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch, 1804 struct link_map_offsets *(*flmo) (void)) 1805 { 1806 struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data); 1807 1808 ops->fetch_link_map_offsets = flmo; 1809 1810 set_solib_ops (gdbarch, &svr4_so_ops); 1811 } 1812 1813 /* Fetch a link_map_offsets structure using the architecture-specific 1814 `struct link_map_offsets' fetcher. */ 1815 1816 static struct link_map_offsets * 1817 svr4_fetch_link_map_offsets (void) 1818 { 1819 struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch, solib_svr4_data); 1820 1821 gdb_assert (ops->fetch_link_map_offsets); 1822 return ops->fetch_link_map_offsets (); 1823 } 1824 1825 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */ 1826 1827 static int 1828 svr4_have_link_map_offsets (void) 1829 { 1830 struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch, solib_svr4_data); 1831 return (ops->fetch_link_map_offsets != NULL); 1832 } 1833 1834 1835 /* Most OS'es that have SVR4-style ELF dynamic libraries define a 1836 `struct r_debug' and a `struct link_map' that are binary compatible 1837 with the origional SVR4 implementation. */ 1838 1839 /* Fetch (and possibly build) an appropriate `struct link_map_offsets' 1840 for an ILP32 SVR4 system. */ 1841 1842 struct link_map_offsets * 1843 svr4_ilp32_fetch_link_map_offsets (void) 1844 { 1845 static struct link_map_offsets lmo; 1846 static struct link_map_offsets *lmp = NULL; 1847 1848 if (lmp == NULL) 1849 { 1850 lmp = &lmo; 1851 1852 lmo.r_version_offset = 0; 1853 lmo.r_version_size = 4; 1854 lmo.r_map_offset = 4; 1855 lmo.r_brk_offset = 8; 1856 lmo.r_ldsomap_offset = 20; 1857 1858 /* Everything we need is in the first 20 bytes. */ 1859 lmo.link_map_size = 20; 1860 lmo.l_addr_offset = 0; 1861 lmo.l_name_offset = 4; 1862 lmo.l_ld_offset = 8; 1863 lmo.l_next_offset = 12; 1864 lmo.l_prev_offset = 16; 1865 } 1866 1867 return lmp; 1868 } 1869 1870 /* Fetch (and possibly build) an appropriate `struct link_map_offsets' 1871 for an LP64 SVR4 system. */ 1872 1873 struct link_map_offsets * 1874 svr4_lp64_fetch_link_map_offsets (void) 1875 { 1876 static struct link_map_offsets lmo; 1877 static struct link_map_offsets *lmp = NULL; 1878 1879 if (lmp == NULL) 1880 { 1881 lmp = &lmo; 1882 1883 lmo.r_version_offset = 0; 1884 lmo.r_version_size = 4; 1885 lmo.r_map_offset = 8; 1886 lmo.r_brk_offset = 16; 1887 lmo.r_ldsomap_offset = 40; 1888 1889 /* Everything we need is in the first 40 bytes. */ 1890 lmo.link_map_size = 40; 1891 lmo.l_addr_offset = 0; 1892 lmo.l_name_offset = 8; 1893 lmo.l_ld_offset = 16; 1894 lmo.l_next_offset = 24; 1895 lmo.l_prev_offset = 32; 1896 } 1897 1898 return lmp; 1899 } 1900 1901 1902 struct target_so_ops svr4_so_ops; 1903 1904 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a 1905 different rule for symbol lookup. The lookup begins here in the DSO, not in 1906 the main executable. */ 1907 1908 static struct symbol * 1909 elf_lookup_lib_symbol (const struct objfile *objfile, 1910 const char *name, 1911 const char *linkage_name, 1912 const domain_enum domain) 1913 { 1914 if (objfile->obfd == NULL 1915 || scan_dyntag (DT_SYMBOLIC, objfile->obfd, NULL) != 1) 1916 return NULL; 1917 1918 return lookup_global_symbol_from_objfile 1919 (objfile, name, linkage_name, domain); 1920 } 1921 1922 extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */ 1923 1924 void 1925 _initialize_svr4_solib (void) 1926 { 1927 solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init); 1928 1929 svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses; 1930 svr4_so_ops.free_so = svr4_free_so; 1931 svr4_so_ops.clear_solib = svr4_clear_solib; 1932 svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook; 1933 svr4_so_ops.special_symbol_handling = svr4_special_symbol_handling; 1934 svr4_so_ops.current_sos = svr4_current_sos; 1935 svr4_so_ops.open_symbol_file_object = open_symbol_file_object; 1936 svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code; 1937 svr4_so_ops.bfd_open = solib_bfd_open; 1938 svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol; 1939 svr4_so_ops.same = svr4_same; 1940 1941 observer_attach_inferior_exit (solib_svr4_inferior_exit); 1942 } 1943