1/* Handle SVR4 shared libraries for GDB, the GNU Debugger. 2 3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 4 2000, 2001, 2003, 2004 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 2 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, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#include "defs.h" 25 26#include "elf/external.h" 27#include "elf/common.h" 28#include "elf/mips.h" 29 30#include "symtab.h" 31#include "bfd.h" 32#include "symfile.h" 33#include "objfiles.h" 34#include "gdbcore.h" 35#include "target.h" 36#include "inferior.h" 37 38#include "solist.h" 39#include "solib-svr4.h" 40 41#include "bfd-target.h" 42#include "exec.h" 43 44#ifndef SVR4_FETCH_LINK_MAP_OFFSETS 45#define SVR4_FETCH_LINK_MAP_OFFSETS() svr4_fetch_link_map_offsets () 46#endif 47 48static struct link_map_offsets *svr4_fetch_link_map_offsets (void); 49static struct link_map_offsets *legacy_fetch_link_map_offsets (void); 50static int svr4_have_link_map_offsets (void); 51 52/* fetch_link_map_offsets_gdbarch_data is a handle used to obtain the 53 architecture specific link map offsets fetching function. */ 54 55static struct gdbarch_data *fetch_link_map_offsets_gdbarch_data; 56 57/* legacy_svr4_fetch_link_map_offsets_hook is a pointer to a function 58 which is used to fetch link map offsets. It will only be set 59 by solib-legacy.c, if at all. */ 60 61struct link_map_offsets *(*legacy_svr4_fetch_link_map_offsets_hook)(void) = 0; 62 63/* Link map info to include in an allocated so_list entry */ 64 65struct lm_info 66 { 67 /* Pointer to copy of link map from inferior. The type is char * 68 rather than void *, so that we may use byte offsets to find the 69 various fields without the need for a cast. */ 70 char *lm; 71 }; 72 73/* On SVR4 systems, a list of symbols in the dynamic linker where 74 GDB can try to place a breakpoint to monitor shared library 75 events. 76 77 If none of these symbols are found, or other errors occur, then 78 SVR4 systems will fall back to using a symbol as the "startup 79 mapping complete" breakpoint address. */ 80 81static char *solib_break_names[] = 82{ 83 "r_debug_state", 84 "_r_debug_state", 85 "_dl_debug_state", 86 "rtld_db_dlactivity", 87 "_rtld_debug_state", 88 89 /* On the 64-bit PowerPC, the linker symbol with the same name as 90 the C function points to a function descriptor, not to the entry 91 point. The linker symbol whose name is the C function name 92 prefixed with a '.' points to the function's entry point. So 93 when we look through this table, we ignore symbols that point 94 into the data section (thus skipping the descriptor's symbol), 95 and eventually try this one, giving us the real entry point 96 address. */ 97 ".r_debug_state", 98 "._dl_debug_state", 99 100 NULL 101}; 102 103#define BKPT_AT_SYMBOL 1 104 105#if defined (BKPT_AT_SYMBOL) 106static char *bkpt_names[] = 107{ 108#ifdef SOLIB_BKPT_NAME 109 SOLIB_BKPT_NAME, /* Prefer configured name if it exists. */ 110#endif 111 "_start", 112 "__start", 113 "main", 114 NULL 115}; 116#endif 117 118static char *main_name_list[] = 119{ 120 "main_$main", 121 NULL 122}; 123 124/* Macro to extract an address from a solib structure. When GDB is 125 configured for some 32-bit targets (e.g. Solaris 2.7 sparc), BFD is 126 configured to handle 64-bit targets, so CORE_ADDR is 64 bits. We 127 have to extract only the significant bits of addresses to get the 128 right address when accessing the core file BFD. 129 130 Assume that the address is unsigned. */ 131 132#define SOLIB_EXTRACT_ADDRESS(MEMBER) \ 133 extract_unsigned_integer (&(MEMBER), sizeof (MEMBER)) 134 135/* local data declarations */ 136 137/* link map access functions */ 138 139static CORE_ADDR 140LM_ADDR (struct so_list *so) 141{ 142 struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS (); 143 144 return (CORE_ADDR) extract_signed_integer (so->lm_info->lm + lmo->l_addr_offset, 145 lmo->l_addr_size); 146} 147 148static CORE_ADDR 149LM_NEXT (struct so_list *so) 150{ 151 struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS (); 152 153 /* Assume that the address is unsigned. */ 154 return extract_unsigned_integer (so->lm_info->lm + lmo->l_next_offset, 155 lmo->l_next_size); 156} 157 158static CORE_ADDR 159LM_NAME (struct so_list *so) 160{ 161 struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS (); 162 163 /* Assume that the address is unsigned. */ 164 return extract_unsigned_integer (so->lm_info->lm + lmo->l_name_offset, 165 lmo->l_name_size); 166} 167 168static int 169IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so) 170{ 171 struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS (); 172 173 /* Assume that the address is unsigned. */ 174 return extract_unsigned_integer (so->lm_info->lm + lmo->l_prev_offset, 175 lmo->l_prev_size) == 0; 176} 177 178static CORE_ADDR debug_base; /* Base of dynamic linker structures */ 179static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */ 180 181/* Local function prototypes */ 182 183static int match_main (char *); 184 185static CORE_ADDR bfd_lookup_symbol (bfd *, char *, flagword); 186 187/* 188 189 LOCAL FUNCTION 190 191 bfd_lookup_symbol -- lookup the value for a specific symbol 192 193 SYNOPSIS 194 195 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags) 196 197 DESCRIPTION 198 199 An expensive way to lookup the value of a single symbol for 200 bfd's that are only temporary anyway. This is used by the 201 shared library support to find the address of the debugger 202 interface structures in the shared library. 203 204 If SECT_FLAGS is non-zero, only match symbols in sections whose 205 flags include all those in SECT_FLAGS. 206 207 Note that 0 is specifically allowed as an error return (no 208 such symbol). 209 */ 210 211static CORE_ADDR 212bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags) 213{ 214 long storage_needed; 215 asymbol *sym; 216 asymbol **symbol_table; 217 unsigned int number_of_symbols; 218 unsigned int i; 219 struct cleanup *back_to; 220 CORE_ADDR symaddr = 0; 221 222 storage_needed = bfd_get_symtab_upper_bound (abfd); 223 224 if (storage_needed > 0) 225 { 226 symbol_table = (asymbol **) xmalloc (storage_needed); 227 back_to = make_cleanup (xfree, symbol_table); 228 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 229 230 for (i = 0; i < number_of_symbols; i++) 231 { 232 sym = *symbol_table++; 233 if (strcmp (sym->name, symname) == 0 234 && (sym->section->flags & sect_flags) == sect_flags) 235 { 236 /* Bfd symbols are section relative. */ 237 symaddr = sym->value + sym->section->vma; 238 break; 239 } 240 } 241 do_cleanups (back_to); 242 } 243 244 if (symaddr) 245 return symaddr; 246 247 /* On FreeBSD, the dynamic linker is stripped by default. So we'll 248 have to check the dynamic string table too. */ 249 250 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); 251 252 if (storage_needed > 0) 253 { 254 symbol_table = (asymbol **) xmalloc (storage_needed); 255 back_to = make_cleanup (xfree, symbol_table); 256 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table); 257 258 for (i = 0; i < number_of_symbols; i++) 259 { 260 sym = *symbol_table++; 261 262 if (strcmp (sym->name, symname) == 0 263 && (sym->section->flags & sect_flags) == sect_flags) 264 { 265 /* Bfd symbols are section relative. */ 266 symaddr = sym->value + sym->section->vma; 267 break; 268 } 269 } 270 do_cleanups (back_to); 271 } 272 273 return symaddr; 274} 275 276#ifdef HANDLE_SVR4_EXEC_EMULATORS 277 278/* 279 Solaris BCP (the part of Solaris which allows it to run SunOS4 280 a.out files) throws in another wrinkle. Solaris does not fill 281 in the usual a.out link map structures when running BCP programs, 282 the only way to get at them is via groping around in the dynamic 283 linker. 284 The dynamic linker and it's structures are located in the shared 285 C library, which gets run as the executable's "interpreter" by 286 the kernel. 287 288 Note that we can assume nothing about the process state at the time 289 we need to find these structures. We may be stopped on the first 290 instruction of the interpreter (C shared library), the first 291 instruction of the executable itself, or somewhere else entirely 292 (if we attached to the process for example). 293 */ 294 295static char *debug_base_symbols[] = 296{ 297 "r_debug", /* Solaris 2.3 */ 298 "_r_debug", /* Solaris 2.1, 2.2 */ 299 NULL 300}; 301 302static int look_for_base (int, CORE_ADDR); 303 304/* 305 306 LOCAL FUNCTION 307 308 look_for_base -- examine file for each mapped address segment 309 310 SYNOPSYS 311 312 static int look_for_base (int fd, CORE_ADDR baseaddr) 313 314 DESCRIPTION 315 316 This function is passed to proc_iterate_over_mappings, which 317 causes it to get called once for each mapped address space, with 318 an open file descriptor for the file mapped to that space, and the 319 base address of that mapped space. 320 321 Our job is to find the debug base symbol in the file that this 322 fd is open on, if it exists, and if so, initialize the dynamic 323 linker structure base address debug_base. 324 325 Note that this is a computationally expensive proposition, since 326 we basically have to open a bfd on every call, so we specifically 327 avoid opening the exec file. 328 */ 329 330static int 331look_for_base (int fd, CORE_ADDR baseaddr) 332{ 333 bfd *interp_bfd; 334 CORE_ADDR address = 0; 335 char **symbolp; 336 337 /* If the fd is -1, then there is no file that corresponds to this 338 mapped memory segment, so skip it. Also, if the fd corresponds 339 to the exec file, skip it as well. */ 340 341 if (fd == -1 342 || (exec_bfd != NULL 343 && fdmatch (fileno ((FILE *) (exec_bfd->iostream)), fd))) 344 { 345 return (0); 346 } 347 348 /* Try to open whatever random file this fd corresponds to. Note that 349 we have no way currently to find the filename. Don't gripe about 350 any problems we might have, just fail. */ 351 352 if ((interp_bfd = bfd_fdopenr ("unnamed", gnutarget, fd)) == NULL) 353 { 354 return (0); 355 } 356 if (!bfd_check_format (interp_bfd, bfd_object)) 357 { 358 /* FIXME-leak: on failure, might not free all memory associated with 359 interp_bfd. */ 360 bfd_close (interp_bfd); 361 return (0); 362 } 363 364 /* Now try to find our debug base symbol in this file, which we at 365 least know to be a valid ELF executable or shared library. */ 366 367 for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++) 368 { 369 address = bfd_lookup_symbol (interp_bfd, *symbolp, 0); 370 if (address != 0) 371 { 372 break; 373 } 374 } 375 if (address == 0) 376 { 377 /* FIXME-leak: on failure, might not free all memory associated with 378 interp_bfd. */ 379 bfd_close (interp_bfd); 380 return (0); 381 } 382 383 /* Eureka! We found the symbol. But now we may need to relocate it 384 by the base address. If the symbol's value is less than the base 385 address of the shared library, then it hasn't yet been relocated 386 by the dynamic linker, and we have to do it ourself. FIXME: Note 387 that we make the assumption that the first segment that corresponds 388 to the shared library has the base address to which the library 389 was relocated. */ 390 391 if (address < baseaddr) 392 { 393 address += baseaddr; 394 } 395 debug_base = address; 396 /* FIXME-leak: on failure, might not free all memory associated with 397 interp_bfd. */ 398 bfd_close (interp_bfd); 399 return (1); 400} 401#endif /* HANDLE_SVR4_EXEC_EMULATORS */ 402 403/* 404 405 LOCAL FUNCTION 406 407 elf_locate_base -- locate the base address of dynamic linker structs 408 for SVR4 elf targets. 409 410 SYNOPSIS 411 412 CORE_ADDR elf_locate_base (void) 413 414 DESCRIPTION 415 416 For SVR4 elf targets the address of the dynamic linker's runtime 417 structure is contained within the dynamic info section in the 418 executable file. The dynamic section is also mapped into the 419 inferior address space. Because the runtime loader fills in the 420 real address before starting the inferior, we have to read in the 421 dynamic info section from the inferior address space. 422 If there are any errors while trying to find the address, we 423 silently return 0, otherwise the found address is returned. 424 425 */ 426 427static CORE_ADDR 428elf_locate_base (void) 429{ 430 struct bfd_section *dyninfo_sect; 431 int dyninfo_sect_size; 432 CORE_ADDR dyninfo_addr; 433 char *buf; 434 char *bufend; 435 int arch_size; 436 437 /* Find the start address of the .dynamic section. */ 438 dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic"); 439 if (dyninfo_sect == NULL) 440 return 0; 441 dyninfo_addr = bfd_section_vma (exec_bfd, dyninfo_sect); 442 443 /* Read in .dynamic section, silently ignore errors. */ 444 dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect); 445 buf = alloca (dyninfo_sect_size); 446 if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size)) 447 return 0; 448 449 /* Find the DT_DEBUG entry in the the .dynamic section. 450 For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has 451 no DT_DEBUG entries. */ 452 453 arch_size = bfd_get_arch_size (exec_bfd); 454 if (arch_size == -1) /* failure */ 455 return 0; 456 457 if (arch_size == 32) 458 { /* 32-bit elf */ 459 for (bufend = buf + dyninfo_sect_size; 460 buf < bufend; 461 buf += sizeof (Elf32_External_Dyn)) 462 { 463 Elf32_External_Dyn *x_dynp = (Elf32_External_Dyn *) buf; 464 long dyn_tag; 465 CORE_ADDR dyn_ptr; 466 467 dyn_tag = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_tag); 468 if (dyn_tag == DT_NULL) 469 break; 470 else if (dyn_tag == DT_DEBUG) 471 { 472 dyn_ptr = bfd_h_get_32 (exec_bfd, 473 (bfd_byte *) x_dynp->d_un.d_ptr); 474 return dyn_ptr; 475 } 476 else if (dyn_tag == DT_MIPS_RLD_MAP) 477 { 478 char *pbuf; 479 int pbuf_size = TARGET_PTR_BIT / HOST_CHAR_BIT; 480 481 pbuf = alloca (pbuf_size); 482 /* DT_MIPS_RLD_MAP contains a pointer to the address 483 of the dynamic link structure. */ 484 dyn_ptr = bfd_h_get_32 (exec_bfd, 485 (bfd_byte *) x_dynp->d_un.d_ptr); 486 if (target_read_memory (dyn_ptr, pbuf, pbuf_size)) 487 return 0; 488 return extract_unsigned_integer (pbuf, pbuf_size); 489 } 490 } 491 } 492 else /* 64-bit elf */ 493 { 494 for (bufend = buf + dyninfo_sect_size; 495 buf < bufend; 496 buf += sizeof (Elf64_External_Dyn)) 497 { 498 Elf64_External_Dyn *x_dynp = (Elf64_External_Dyn *) buf; 499 long dyn_tag; 500 CORE_ADDR dyn_ptr; 501 502 dyn_tag = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_tag); 503 if (dyn_tag == DT_NULL) 504 break; 505 else if (dyn_tag == DT_DEBUG) 506 { 507 dyn_ptr = bfd_h_get_64 (exec_bfd, 508 (bfd_byte *) x_dynp->d_un.d_ptr); 509 return dyn_ptr; 510 } 511 else if (dyn_tag == DT_MIPS_RLD_MAP) 512 { 513 char *pbuf; 514 int pbuf_size = TARGET_PTR_BIT / HOST_CHAR_BIT; 515 516 pbuf = alloca (pbuf_size); 517 /* DT_MIPS_RLD_MAP contains a pointer to the address 518 of the dynamic link structure. */ 519 dyn_ptr = bfd_h_get_64 (exec_bfd, 520 (bfd_byte *) x_dynp->d_un.d_ptr); 521 if (target_read_memory (dyn_ptr, pbuf, pbuf_size)) 522 return 0; 523 return extract_unsigned_integer (pbuf, pbuf_size); 524 } 525 } 526 } 527 528 /* DT_DEBUG entry not found. */ 529 return 0; 530} 531 532/* 533 534 LOCAL FUNCTION 535 536 locate_base -- locate the base address of dynamic linker structs 537 538 SYNOPSIS 539 540 CORE_ADDR locate_base (void) 541 542 DESCRIPTION 543 544 For both the SunOS and SVR4 shared library implementations, if the 545 inferior executable has been linked dynamically, there is a single 546 address somewhere in the inferior's data space which is the key to 547 locating all of the dynamic linker's runtime structures. This 548 address is the value of the debug base symbol. The job of this 549 function is to find and return that address, or to return 0 if there 550 is no such address (the executable is statically linked for example). 551 552 For SunOS, the job is almost trivial, since the dynamic linker and 553 all of it's structures are statically linked to the executable at 554 link time. Thus the symbol for the address we are looking for has 555 already been added to the minimal symbol table for the executable's 556 objfile at the time the symbol file's symbols were read, and all we 557 have to do is look it up there. Note that we explicitly do NOT want 558 to find the copies in the shared library. 559 560 The SVR4 version is a bit more complicated because the address 561 is contained somewhere in the dynamic info section. We have to go 562 to a lot more work to discover the address of the debug base symbol. 563 Because of this complexity, we cache the value we find and return that 564 value on subsequent invocations. Note there is no copy in the 565 executable symbol tables. 566 567 */ 568 569static CORE_ADDR 570locate_base (void) 571{ 572 /* Check to see if we have a currently valid address, and if so, avoid 573 doing all this work again and just return the cached address. If 574 we have no cached address, try to locate it in the dynamic info 575 section for ELF executables. There's no point in doing any of this 576 though if we don't have some link map offsets to work with. */ 577 578 if (debug_base == 0 && svr4_have_link_map_offsets ()) 579 { 580 if (exec_bfd != NULL 581 && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour) 582 debug_base = elf_locate_base (); 583#ifdef HANDLE_SVR4_EXEC_EMULATORS 584 /* Try it the hard way for emulated executables. */ 585 else if (!ptid_equal (inferior_ptid, null_ptid) && target_has_execution) 586 proc_iterate_over_mappings (look_for_base); 587#endif 588 } 589 return (debug_base); 590} 591 592/* 593 594 LOCAL FUNCTION 595 596 first_link_map_member -- locate first member in dynamic linker's map 597 598 SYNOPSIS 599 600 static CORE_ADDR first_link_map_member (void) 601 602 DESCRIPTION 603 604 Find the first element in the inferior's dynamic link map, and 605 return its address in the inferior. This function doesn't copy the 606 link map entry itself into our address space; current_sos actually 607 does the reading. */ 608 609static CORE_ADDR 610first_link_map_member (void) 611{ 612 CORE_ADDR lm = 0; 613 struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS (); 614 char *r_map_buf = xmalloc (lmo->r_map_size); 615 struct cleanup *cleanups = make_cleanup (xfree, r_map_buf); 616 617 read_memory (debug_base + lmo->r_map_offset, r_map_buf, lmo->r_map_size); 618 619 /* Assume that the address is unsigned. */ 620 lm = extract_unsigned_integer (r_map_buf, lmo->r_map_size); 621 622 /* FIXME: Perhaps we should validate the info somehow, perhaps by 623 checking r_version for a known version number, or r_state for 624 RT_CONSISTENT. */ 625 626 do_cleanups (cleanups); 627 628 return (lm); 629} 630 631/* 632 633 LOCAL FUNCTION 634 635 open_symbol_file_object 636 637 SYNOPSIS 638 639 void open_symbol_file_object (void *from_tty) 640 641 DESCRIPTION 642 643 If no open symbol file, attempt to locate and open the main symbol 644 file. On SVR4 systems, this is the first link map entry. If its 645 name is here, we can open it. Useful when attaching to a process 646 without first loading its symbol file. 647 648 If FROM_TTYP dereferences to a non-zero integer, allow messages to 649 be printed. This parameter is a pointer rather than an int because 650 open_symbol_file_object() is called via catch_errors() and 651 catch_errors() requires a pointer argument. */ 652 653static int 654open_symbol_file_object (void *from_ttyp) 655{ 656 CORE_ADDR lm, l_name; 657 char *filename; 658 int errcode; 659 int from_tty = *(int *)from_ttyp; 660 struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS (); 661 char *l_name_buf = xmalloc (lmo->l_name_size); 662 struct cleanup *cleanups = make_cleanup (xfree, l_name_buf); 663 664 if (symfile_objfile) 665 if (!query ("Attempt to reload symbols from process? ")) 666 return 0; 667 668 if ((debug_base = locate_base ()) == 0) 669 return 0; /* failed somehow... */ 670 671 /* First link map member should be the executable. */ 672 if ((lm = first_link_map_member ()) == 0) 673 return 0; /* failed somehow... */ 674 675 /* Read address of name from target memory to GDB. */ 676 read_memory (lm + lmo->l_name_offset, l_name_buf, lmo->l_name_size); 677 678 /* Convert the address to host format. Assume that the address is 679 unsigned. */ 680 l_name = extract_unsigned_integer (l_name_buf, lmo->l_name_size); 681 682 /* Free l_name_buf. */ 683 do_cleanups (cleanups); 684 685 if (l_name == 0) 686 return 0; /* No filename. */ 687 688 /* Now fetch the filename from target memory. */ 689 target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode); 690 691 if (errcode) 692 { 693 warning ("failed to read exec filename from attached file: %s", 694 safe_strerror (errcode)); 695 return 0; 696 } 697 698 make_cleanup (xfree, filename); 699 /* Have a pathname: read the symbol file. */ 700 symbol_file_add_main (filename, from_tty); 701 702 return 1; 703} 704 705/* LOCAL FUNCTION 706 707 current_sos -- build a list of currently loaded shared objects 708 709 SYNOPSIS 710 711 struct so_list *current_sos () 712 713 DESCRIPTION 714 715 Build a list of `struct so_list' objects describing the shared 716 objects currently loaded in the inferior. This list does not 717 include an entry for the main executable file. 718 719 Note that we only gather information directly available from the 720 inferior --- we don't examine any of the shared library files 721 themselves. The declaration of `struct so_list' says which fields 722 we provide values for. */ 723 724static struct so_list * 725svr4_current_sos (void) 726{ 727 CORE_ADDR lm; 728 struct so_list *head = 0; 729 struct so_list **link_ptr = &head; 730 731 /* Make sure we've looked up the inferior's dynamic linker's base 732 structure. */ 733 if (! debug_base) 734 { 735 debug_base = locate_base (); 736 737 /* If we can't find the dynamic linker's base structure, this 738 must not be a dynamically linked executable. Hmm. */ 739 if (! debug_base) 740 return 0; 741 } 742 743 /* Walk the inferior's link map list, and build our list of 744 `struct so_list' nodes. */ 745 lm = first_link_map_member (); 746 while (lm) 747 { 748 struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS (); 749 struct so_list *new 750 = (struct so_list *) xmalloc (sizeof (struct so_list)); 751 struct cleanup *old_chain = make_cleanup (xfree, new); 752 753 memset (new, 0, sizeof (*new)); 754 755 new->lm_info = xmalloc (sizeof (struct lm_info)); 756 make_cleanup (xfree, new->lm_info); 757 758 new->lm_info->lm = xmalloc (lmo->link_map_size); 759 make_cleanup (xfree, new->lm_info->lm); 760 memset (new->lm_info->lm, 0, lmo->link_map_size); 761 762 read_memory (lm, new->lm_info->lm, lmo->link_map_size); 763 764 lm = LM_NEXT (new); 765 766 /* For SVR4 versions, the first entry in the link map is for the 767 inferior executable, so we must ignore it. For some versions of 768 SVR4, it has no name. For others (Solaris 2.3 for example), it 769 does have a name, so we can no longer use a missing name to 770 decide when to ignore it. */ 771 if (IGNORE_FIRST_LINK_MAP_ENTRY (new)) 772 free_so (new); 773 else 774 { 775 int errcode; 776 char *buffer; 777 778 /* Extract this shared object's name. */ 779 target_read_string (LM_NAME (new), &buffer, 780 SO_NAME_MAX_PATH_SIZE - 1, &errcode); 781 if (errcode != 0) 782 { 783 warning ("current_sos: Can't read pathname for load map: %s\n", 784 safe_strerror (errcode)); 785 } 786 else 787 { 788 strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1); 789 new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; 790 xfree (buffer); 791 strcpy (new->so_original_name, new->so_name); 792 } 793 794 /* If this entry has no name, or its name matches the name 795 for the main executable, don't include it in the list. */ 796 if (! new->so_name[0] 797 || match_main (new->so_name)) 798 free_so (new); 799 else 800 { 801 new->next = 0; 802 *link_ptr = new; 803 link_ptr = &new->next; 804 } 805 } 806 807 discard_cleanups (old_chain); 808 } 809 810 return head; 811} 812 813/* Get the address of the link_map for a given OBJFILE. Loop through 814 the link maps, and return the address of the one corresponding to 815 the given objfile. Note that this function takes into account that 816 objfile can be the main executable, not just a shared library. The 817 main executable has always an empty name field in the linkmap. */ 818 819CORE_ADDR 820svr4_fetch_objfile_link_map (struct objfile *objfile) 821{ 822 CORE_ADDR lm; 823 824 if ((debug_base = locate_base ()) == 0) 825 return 0; /* failed somehow... */ 826 827 /* Position ourselves on the first link map. */ 828 lm = first_link_map_member (); 829 while (lm) 830 { 831 /* Get info on the layout of the r_debug and link_map structures. */ 832 struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS (); 833 int errcode; 834 char *buffer; 835 struct lm_info objfile_lm_info; 836 struct cleanup *old_chain; 837 CORE_ADDR name_address; 838 char *l_name_buf = xmalloc (lmo->l_name_size); 839 old_chain = make_cleanup (xfree, l_name_buf); 840 841 /* Set up the buffer to contain the portion of the link_map 842 structure that gdb cares about. Note that this is not the 843 whole link_map structure. */ 844 objfile_lm_info.lm = xmalloc (lmo->link_map_size); 845 make_cleanup (xfree, objfile_lm_info.lm); 846 memset (objfile_lm_info.lm, 0, lmo->link_map_size); 847 848 /* Read the link map into our internal structure. */ 849 read_memory (lm, objfile_lm_info.lm, lmo->link_map_size); 850 851 /* Read address of name from target memory to GDB. */ 852 read_memory (lm + lmo->l_name_offset, l_name_buf, lmo->l_name_size); 853 854 /* Extract this object's name. Assume that the address is 855 unsigned. */ 856 name_address = extract_unsigned_integer (l_name_buf, lmo->l_name_size); 857 target_read_string (name_address, &buffer, 858 SO_NAME_MAX_PATH_SIZE - 1, &errcode); 859 make_cleanup (xfree, buffer); 860 if (errcode != 0) 861 { 862 warning ("svr4_fetch_objfile_link_map: Can't read pathname for load map: %s\n", 863 safe_strerror (errcode)); 864 } 865 else 866 { 867 /* Is this the linkmap for the file we want? */ 868 /* If the file is not a shared library and has no name, 869 we are sure it is the main executable, so we return that. */ 870 if ((buffer && strcmp (buffer, objfile->name) == 0) 871 || (!(objfile->flags & OBJF_SHARED) && (strcmp (buffer, "") == 0))) 872 { 873 do_cleanups (old_chain); 874 return lm; 875 } 876 } 877 /* Not the file we wanted, continue checking. Assume that the 878 address is unsigned. */ 879 lm = extract_unsigned_integer (objfile_lm_info.lm + lmo->l_next_offset, 880 lmo->l_next_size); 881 do_cleanups (old_chain); 882 } 883 return 0; 884} 885 886/* On some systems, the only way to recognize the link map entry for 887 the main executable file is by looking at its name. Return 888 non-zero iff SONAME matches one of the known main executable names. */ 889 890static int 891match_main (char *soname) 892{ 893 char **mainp; 894 895 for (mainp = main_name_list; *mainp != NULL; mainp++) 896 { 897 if (strcmp (soname, *mainp) == 0) 898 return (1); 899 } 900 901 return (0); 902} 903 904/* Return 1 if PC lies in the dynamic symbol resolution code of the 905 SVR4 run time loader. */ 906static CORE_ADDR interp_text_sect_low; 907static CORE_ADDR interp_text_sect_high; 908static CORE_ADDR interp_plt_sect_low; 909static CORE_ADDR interp_plt_sect_high; 910 911static int 912svr4_in_dynsym_resolve_code (CORE_ADDR pc) 913{ 914 return ((pc >= interp_text_sect_low && pc < interp_text_sect_high) 915 || (pc >= interp_plt_sect_low && pc < interp_plt_sect_high) 916 || in_plt_section (pc, NULL)); 917} 918 919/* Given an executable's ABFD and target, compute the entry-point 920 address. */ 921 922static CORE_ADDR 923exec_entry_point (struct bfd *abfd, struct target_ops *targ) 924{ 925 /* KevinB wrote ... for most targets, the address returned by 926 bfd_get_start_address() is the entry point for the start 927 function. But, for some targets, bfd_get_start_address() returns 928 the address of a function descriptor from which the entry point 929 address may be extracted. This address is extracted by 930 gdbarch_convert_from_func_ptr_addr(). The method 931 gdbarch_convert_from_func_ptr_addr() is the merely the identify 932 function for targets which don't use function descriptors. */ 933 return gdbarch_convert_from_func_ptr_addr (current_gdbarch, 934 bfd_get_start_address (abfd), 935 targ); 936} 937 938/* 939 940 LOCAL FUNCTION 941 942 enable_break -- arrange for dynamic linker to hit breakpoint 943 944 SYNOPSIS 945 946 int enable_break (void) 947 948 DESCRIPTION 949 950 Both the SunOS and the SVR4 dynamic linkers have, as part of their 951 debugger interface, support for arranging for the inferior to hit 952 a breakpoint after mapping in the shared libraries. This function 953 enables that breakpoint. 954 955 For SunOS, there is a special flag location (in_debugger) which we 956 set to 1. When the dynamic linker sees this flag set, it will set 957 a breakpoint at a location known only to itself, after saving the 958 original contents of that place and the breakpoint address itself, 959 in it's own internal structures. When we resume the inferior, it 960 will eventually take a SIGTRAP when it runs into the breakpoint. 961 We handle this (in a different place) by restoring the contents of 962 the breakpointed location (which is only known after it stops), 963 chasing around to locate the shared libraries that have been 964 loaded, then resuming. 965 966 For SVR4, the debugger interface structure contains a member (r_brk) 967 which is statically initialized at the time the shared library is 968 built, to the offset of a function (_r_debug_state) which is guaran- 969 teed to be called once before mapping in a library, and again when 970 the mapping is complete. At the time we are examining this member, 971 it contains only the unrelocated offset of the function, so we have 972 to do our own relocation. Later, when the dynamic linker actually 973 runs, it relocates r_brk to be the actual address of _r_debug_state(). 974 975 The debugger interface structure also contains an enumeration which 976 is set to either RT_ADD or RT_DELETE prior to changing the mapping, 977 depending upon whether or not the library is being mapped or unmapped, 978 and then set to RT_CONSISTENT after the library is mapped/unmapped. 979 */ 980 981static int 982enable_break (void) 983{ 984 int success = 0; 985 986#ifdef BKPT_AT_SYMBOL 987 988 struct minimal_symbol *msymbol; 989 char **bkpt_namep; 990 asection *interp_sect; 991 992 /* First, remove all the solib event breakpoints. Their addresses 993 may have changed since the last time we ran the program. */ 994 remove_solib_event_breakpoints (); 995 996 interp_text_sect_low = interp_text_sect_high = 0; 997 interp_plt_sect_low = interp_plt_sect_high = 0; 998 999 /* Find the .interp section; if not found, warn the user and drop 1000 into the old breakpoint at symbol code. */ 1001 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); 1002 if (interp_sect) 1003 { 1004 unsigned int interp_sect_size; 1005 char *buf; 1006 CORE_ADDR load_addr = 0; 1007 int load_addr_found = 0; 1008 struct so_list *inferior_sos; 1009 bfd *tmp_bfd = NULL; 1010 struct target_ops *tmp_bfd_target; 1011 int tmp_fd = -1; 1012 char *tmp_pathname = NULL; 1013 CORE_ADDR sym_addr = 0; 1014 1015 /* Read the contents of the .interp section into a local buffer; 1016 the contents specify the dynamic linker this program uses. */ 1017 interp_sect_size = bfd_section_size (exec_bfd, interp_sect); 1018 buf = alloca (interp_sect_size); 1019 bfd_get_section_contents (exec_bfd, interp_sect, 1020 buf, 0, interp_sect_size); 1021 1022 /* Now we need to figure out where the dynamic linker was 1023 loaded so that we can load its symbols and place a breakpoint 1024 in the dynamic linker itself. 1025 1026 This address is stored on the stack. However, I've been unable 1027 to find any magic formula to find it for Solaris (appears to 1028 be trivial on GNU/Linux). Therefore, we have to try an alternate 1029 mechanism to find the dynamic linker's base address. */ 1030 1031 tmp_fd = solib_open (buf, &tmp_pathname); 1032 if (tmp_fd >= 0) 1033 tmp_bfd = bfd_fdopenr (tmp_pathname, gnutarget, tmp_fd); 1034 1035 if (tmp_bfd == NULL) 1036 goto bkpt_at_symbol; 1037 1038 /* Make sure the dynamic linker's really a useful object. */ 1039 if (!bfd_check_format (tmp_bfd, bfd_object)) 1040 { 1041 warning ("Unable to grok dynamic linker %s as an object file", buf); 1042 bfd_close (tmp_bfd); 1043 goto bkpt_at_symbol; 1044 } 1045 1046 /* Now convert the TMP_BFD into a target. That way target, as 1047 well as BFD operations can be used. Note that closing the 1048 target will also close the underlying bfd. */ 1049 tmp_bfd_target = target_bfd_reopen (tmp_bfd); 1050 1051 /* If the entry in _DYNAMIC for the dynamic linker has already 1052 been filled in, we can read its base address from there. */ 1053 inferior_sos = svr4_current_sos (); 1054 if (inferior_sos) 1055 { 1056 /* Connected to a running target. Update our shared library table. */ 1057 solib_add (NULL, 0, NULL, auto_solib_add); 1058 } 1059 while (inferior_sos) 1060 { 1061 if (strcmp (buf, inferior_sos->so_original_name) == 0) 1062 { 1063 load_addr_found = 1; 1064 load_addr = LM_ADDR (inferior_sos); 1065 break; 1066 } 1067 inferior_sos = inferior_sos->next; 1068 } 1069 1070 /* Otherwise we find the dynamic linker's base address by examining 1071 the current pc (which should point at the entry point for the 1072 dynamic linker) and subtracting the offset of the entry point. */ 1073 if (!load_addr_found) 1074 load_addr = (read_pc () 1075 - exec_entry_point (tmp_bfd, tmp_bfd_target)); 1076 1077 /* Record the relocated start and end address of the dynamic linker 1078 text and plt section for svr4_in_dynsym_resolve_code. */ 1079 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text"); 1080 if (interp_sect) 1081 { 1082 interp_text_sect_low = 1083 bfd_section_vma (tmp_bfd, interp_sect) + load_addr; 1084 interp_text_sect_high = 1085 interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect); 1086 } 1087 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt"); 1088 if (interp_sect) 1089 { 1090 interp_plt_sect_low = 1091 bfd_section_vma (tmp_bfd, interp_sect) + load_addr; 1092 interp_plt_sect_high = 1093 interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect); 1094 } 1095 1096 /* Now try to set a breakpoint in the dynamic linker. */ 1097 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++) 1098 { 1099 /* On ABI's that use function descriptors, there are usually 1100 two linker symbols associated with each C function: one 1101 pointing at the actual entry point of the machine code, 1102 and one pointing at the function's descriptor. The 1103 latter symbol has the same name as the C function. 1104 1105 What we're looking for here is the machine code entry 1106 point, so we are only interested in symbols in code 1107 sections. */ 1108 sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep, SEC_CODE); 1109 if (sym_addr != 0) 1110 break; 1111 } 1112 1113 /* We're done with both the temporary bfd and target. Remember, 1114 closing the target closes the underlying bfd. */ 1115 target_close (tmp_bfd_target, 0); 1116 1117 if (sym_addr != 0) 1118 { 1119 create_solib_event_breakpoint (load_addr + sym_addr); 1120 return 1; 1121 } 1122 1123 /* For whatever reason we couldn't set a breakpoint in the dynamic 1124 linker. Warn and drop into the old code. */ 1125 bkpt_at_symbol: 1126 warning ("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code."); 1127 } 1128 1129 /* Scan through the list of symbols, trying to look up the symbol and 1130 set a breakpoint there. Terminate loop when we/if we succeed. */ 1131 1132 breakpoint_addr = 0; 1133 for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++) 1134 { 1135 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile); 1136 if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0)) 1137 { 1138 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol)); 1139 return 1; 1140 } 1141 } 1142 1143 /* Nothing good happened. */ 1144 success = 0; 1145 1146#endif /* BKPT_AT_SYMBOL */ 1147 1148 return (success); 1149} 1150 1151/* 1152 1153 LOCAL FUNCTION 1154 1155 special_symbol_handling -- additional shared library symbol handling 1156 1157 SYNOPSIS 1158 1159 void special_symbol_handling () 1160 1161 DESCRIPTION 1162 1163 Once the symbols from a shared object have been loaded in the usual 1164 way, we are called to do any system specific symbol handling that 1165 is needed. 1166 1167 For SunOS4, this consisted of grunging around in the dynamic 1168 linkers structures to find symbol definitions for "common" symbols 1169 and adding them to the minimal symbol table for the runtime common 1170 objfile. 1171 1172 However, for SVR4, there's nothing to do. 1173 1174 */ 1175 1176static void 1177svr4_special_symbol_handling (void) 1178{ 1179} 1180 1181/* Relocate the main executable. This function should be called upon 1182 stopping the inferior process at the entry point to the program. 1183 The entry point from BFD is compared to the PC and if they are 1184 different, the main executable is relocated by the proper amount. 1185 1186 As written it will only attempt to relocate executables which 1187 lack interpreter sections. It seems likely that only dynamic 1188 linker executables will get relocated, though it should work 1189 properly for a position-independent static executable as well. */ 1190 1191static void 1192svr4_relocate_main_executable (void) 1193{ 1194 asection *interp_sect; 1195 CORE_ADDR pc = read_pc (); 1196 1197 /* Decide if the objfile needs to be relocated. As indicated above, 1198 we will only be here when execution is stopped at the beginning 1199 of the program. Relocation is necessary if the address at which 1200 we are presently stopped differs from the start address stored in 1201 the executable AND there's no interpreter section. The condition 1202 regarding the interpreter section is very important because if 1203 there *is* an interpreter section, execution will begin there 1204 instead. When there is an interpreter section, the start address 1205 is (presumably) used by the interpreter at some point to start 1206 execution of the program. 1207 1208 If there is an interpreter, it is normal for it to be set to an 1209 arbitrary address at the outset. The job of finding it is 1210 handled in enable_break(). 1211 1212 So, to summarize, relocations are necessary when there is no 1213 interpreter section and the start address obtained from the 1214 executable is different from the address at which GDB is 1215 currently stopped. 1216 1217 [ The astute reader will note that we also test to make sure that 1218 the executable in question has the DYNAMIC flag set. It is my 1219 opinion that this test is unnecessary (undesirable even). It 1220 was added to avoid inadvertent relocation of an executable 1221 whose e_type member in the ELF header is not ET_DYN. There may 1222 be a time in the future when it is desirable to do relocations 1223 on other types of files as well in which case this condition 1224 should either be removed or modified to accomodate the new file 1225 type. (E.g, an ET_EXEC executable which has been built to be 1226 position-independent could safely be relocated by the OS if 1227 desired. It is true that this violates the ABI, but the ABI 1228 has been known to be bent from time to time.) - Kevin, Nov 2000. ] 1229 */ 1230 1231 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); 1232 if (interp_sect == NULL 1233 && (bfd_get_file_flags (exec_bfd) & DYNAMIC) != 0 1234 && (exec_entry_point (exec_bfd, &exec_ops) != pc)) 1235 { 1236 struct cleanup *old_chain; 1237 struct section_offsets *new_offsets; 1238 int i, changed; 1239 CORE_ADDR displacement; 1240 1241 /* It is necessary to relocate the objfile. The amount to 1242 relocate by is simply the address at which we are stopped 1243 minus the starting address from the executable. 1244 1245 We relocate all of the sections by the same amount. This 1246 behavior is mandated by recent editions of the System V ABI. 1247 According to the System V Application Binary Interface, 1248 Edition 4.1, page 5-5: 1249 1250 ... Though the system chooses virtual addresses for 1251 individual processes, it maintains the segments' relative 1252 positions. Because position-independent code uses relative 1253 addressesing between segments, the difference between 1254 virtual addresses in memory must match the difference 1255 between virtual addresses in the file. The difference 1256 between the virtual address of any segment in memory and 1257 the corresponding virtual address in the file is thus a 1258 single constant value for any one executable or shared 1259 object in a given process. This difference is the base 1260 address. One use of the base address is to relocate the 1261 memory image of the program during dynamic linking. 1262 1263 The same language also appears in Edition 4.0 of the System V 1264 ABI and is left unspecified in some of the earlier editions. */ 1265 1266 displacement = pc - exec_entry_point (exec_bfd, &exec_ops); 1267 changed = 0; 1268 1269 new_offsets = xcalloc (symfile_objfile->num_sections, 1270 sizeof (struct section_offsets)); 1271 old_chain = make_cleanup (xfree, new_offsets); 1272 1273 for (i = 0; i < symfile_objfile->num_sections; i++) 1274 { 1275 if (displacement != ANOFFSET (symfile_objfile->section_offsets, i)) 1276 changed = 1; 1277 new_offsets->offsets[i] = displacement; 1278 } 1279 1280 if (changed) 1281 objfile_relocate (symfile_objfile, new_offsets); 1282 1283 do_cleanups (old_chain); 1284 } 1285} 1286 1287/* 1288 1289 GLOBAL FUNCTION 1290 1291 svr4_solib_create_inferior_hook -- shared library startup support 1292 1293 SYNOPSIS 1294 1295 void svr4_solib_create_inferior_hook() 1296 1297 DESCRIPTION 1298 1299 When gdb starts up the inferior, it nurses it along (through the 1300 shell) until it is ready to execute it's first instruction. At this 1301 point, this function gets called via expansion of the macro 1302 SOLIB_CREATE_INFERIOR_HOOK. 1303 1304 For SunOS executables, this first instruction is typically the 1305 one at "_start", or a similar text label, regardless of whether 1306 the executable is statically or dynamically linked. The runtime 1307 startup code takes care of dynamically linking in any shared 1308 libraries, once gdb allows the inferior to continue. 1309 1310 For SVR4 executables, this first instruction is either the first 1311 instruction in the dynamic linker (for dynamically linked 1312 executables) or the instruction at "start" for statically linked 1313 executables. For dynamically linked executables, the system 1314 first exec's /lib/libc.so.N, which contains the dynamic linker, 1315 and starts it running. The dynamic linker maps in any needed 1316 shared libraries, maps in the actual user executable, and then 1317 jumps to "start" in the user executable. 1318 1319 For both SunOS shared libraries, and SVR4 shared libraries, we 1320 can arrange to cooperate with the dynamic linker to discover the 1321 names of shared libraries that are dynamically linked, and the 1322 base addresses to which they are linked. 1323 1324 This function is responsible for discovering those names and 1325 addresses, and saving sufficient information about them to allow 1326 their symbols to be read at a later time. 1327 1328 FIXME 1329 1330 Between enable_break() and disable_break(), this code does not 1331 properly handle hitting breakpoints which the user might have 1332 set in the startup code or in the dynamic linker itself. Proper 1333 handling will probably have to wait until the implementation is 1334 changed to use the "breakpoint handler function" method. 1335 1336 Also, what if child has exit()ed? Must exit loop somehow. 1337 */ 1338 1339static void 1340svr4_solib_create_inferior_hook (void) 1341{ 1342 /* Relocate the main executable if necessary. */ 1343 svr4_relocate_main_executable (); 1344 1345 if (!svr4_have_link_map_offsets ()) 1346 { 1347 warning ("no shared library support for this OS / ABI"); 1348 return; 1349 1350 } 1351 1352 if (!enable_break ()) 1353 { 1354 warning ("shared library handler failed to enable breakpoint"); 1355 return; 1356 } 1357 1358#if defined(_SCO_DS) 1359 /* SCO needs the loop below, other systems should be using the 1360 special shared library breakpoints and the shared library breakpoint 1361 service routine. 1362 1363 Now run the target. It will eventually hit the breakpoint, at 1364 which point all of the libraries will have been mapped in and we 1365 can go groveling around in the dynamic linker structures to find 1366 out what we need to know about them. */ 1367 1368 clear_proceed_status (); 1369 stop_soon = STOP_QUIETLY; 1370 stop_signal = TARGET_SIGNAL_0; 1371 do 1372 { 1373 target_resume (pid_to_ptid (-1), 0, stop_signal); 1374 wait_for_inferior (); 1375 } 1376 while (stop_signal != TARGET_SIGNAL_TRAP); 1377 stop_soon = NO_STOP_QUIETLY; 1378#endif /* defined(_SCO_DS) */ 1379} 1380 1381static void 1382svr4_clear_solib (void) 1383{ 1384 debug_base = 0; 1385} 1386 1387static void 1388svr4_free_so (struct so_list *so) 1389{ 1390 xfree (so->lm_info->lm); 1391 xfree (so->lm_info); 1392} 1393 1394 1395/* Clear any bits of ADDR that wouldn't fit in a target-format 1396 data pointer. "Data pointer" here refers to whatever sort of 1397 address the dynamic linker uses to manage its sections. At the 1398 moment, we don't support shared libraries on any processors where 1399 code and data pointers are different sizes. 1400 1401 This isn't really the right solution. What we really need here is 1402 a way to do arithmetic on CORE_ADDR values that respects the 1403 natural pointer/address correspondence. (For example, on the MIPS, 1404 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to 1405 sign-extend the value. There, simply truncating the bits above 1406 TARGET_PTR_BIT, as we do below, is no good.) This should probably 1407 be a new gdbarch method or something. */ 1408static CORE_ADDR 1409svr4_truncate_ptr (CORE_ADDR addr) 1410{ 1411 if (TARGET_PTR_BIT == sizeof (CORE_ADDR) * 8) 1412 /* We don't need to truncate anything, and the bit twiddling below 1413 will fail due to overflow problems. */ 1414 return addr; 1415 else 1416 return addr & (((CORE_ADDR) 1 << TARGET_PTR_BIT) - 1); 1417} 1418 1419 1420static void 1421svr4_relocate_section_addresses (struct so_list *so, 1422 struct section_table *sec) 1423{ 1424 sec->addr = svr4_truncate_ptr (sec->addr + LM_ADDR (so)); 1425 sec->endaddr = svr4_truncate_ptr (sec->endaddr + LM_ADDR (so)); 1426} 1427 1428 1429/* Fetch a link_map_offsets structure for native targets using struct 1430 definitions from link.h. See solib-legacy.c for the function 1431 which does the actual work. 1432 1433 Note: For non-native targets (i.e. cross-debugging situations), 1434 a target specific fetch_link_map_offsets() function should be 1435 defined and registered via set_solib_svr4_fetch_link_map_offsets(). */ 1436 1437static struct link_map_offsets * 1438legacy_fetch_link_map_offsets (void) 1439{ 1440 if (legacy_svr4_fetch_link_map_offsets_hook) 1441 return legacy_svr4_fetch_link_map_offsets_hook (); 1442 else 1443 { 1444 internal_error (__FILE__, __LINE__, 1445 "legacy_fetch_link_map_offsets called without legacy " 1446 "link_map support enabled."); 1447 return 0; 1448 } 1449} 1450 1451/* Fetch a link_map_offsets structure using the method registered in the 1452 architecture vector. */ 1453 1454static struct link_map_offsets * 1455svr4_fetch_link_map_offsets (void) 1456{ 1457 struct link_map_offsets *(*flmo)(void) = 1458 gdbarch_data (current_gdbarch, fetch_link_map_offsets_gdbarch_data); 1459 1460 if (flmo == NULL) 1461 { 1462 internal_error (__FILE__, __LINE__, 1463 "svr4_fetch_link_map_offsets: fetch_link_map_offsets " 1464 "method not defined for this architecture."); 1465 return 0; 1466 } 1467 else 1468 return (flmo ()); 1469} 1470 1471/* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */ 1472static int 1473svr4_have_link_map_offsets (void) 1474{ 1475 struct link_map_offsets *(*flmo)(void) = 1476 gdbarch_data (current_gdbarch, fetch_link_map_offsets_gdbarch_data); 1477 if (flmo == NULL 1478 || (flmo == legacy_fetch_link_map_offsets 1479 && legacy_svr4_fetch_link_map_offsets_hook == NULL)) 1480 return 0; 1481 else 1482 return 1; 1483} 1484 1485/* set_solib_svr4_fetch_link_map_offsets() is intended to be called by 1486 a <arch>_gdbarch_init() function. It is used to establish an 1487 architecture specific link_map_offsets fetcher for the architecture 1488 being defined. */ 1489 1490void 1491set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch, 1492 struct link_map_offsets *(*flmo) (void)) 1493{ 1494 set_gdbarch_data (gdbarch, fetch_link_map_offsets_gdbarch_data, flmo); 1495} 1496 1497/* Initialize the architecture-specific link_map_offsets fetcher. 1498 This is called after <arch>_gdbarch_init() has set up its `struct 1499 gdbarch' for the new architecture, and is only called if the 1500 link_map_offsets fetcher isn't already initialized (which is 1501 usually done by calling set_solib_svr4_fetch_link_map_offsets() 1502 above in <arch>_gdbarch_init()). Therefore we attempt to provide a 1503 reasonable alternative (for native targets anyway) if the 1504 <arch>_gdbarch_init() fails to call 1505 set_solib_svr4_fetch_link_map_offsets(). */ 1506 1507static void * 1508init_fetch_link_map_offsets (struct gdbarch *gdbarch) 1509{ 1510 return legacy_fetch_link_map_offsets; 1511} 1512 1513/* Most OS'es that have SVR4-style ELF dynamic libraries define a 1514 `struct r_debug' and a `struct link_map' that are binary compatible 1515 with the origional SVR4 implementation. */ 1516 1517/* Fetch (and possibly build) an appropriate `struct link_map_offsets' 1518 for an ILP32 SVR4 system. */ 1519 1520struct link_map_offsets * 1521svr4_ilp32_fetch_link_map_offsets (void) 1522{ 1523 static struct link_map_offsets lmo; 1524 static struct link_map_offsets *lmp = NULL; 1525 1526 if (lmp == NULL) 1527 { 1528 lmp = &lmo; 1529 1530 /* Everything we need is in the first 8 bytes. */ 1531 lmo.r_debug_size = 8; 1532 lmo.r_map_offset = 4; 1533 lmo.r_map_size = 4; 1534 1535 /* Everything we need is in the first 20 bytes. */ 1536 lmo.link_map_size = 20; 1537 lmo.l_addr_offset = 0; 1538 lmo.l_addr_size = 4; 1539 lmo.l_name_offset = 4; 1540 lmo.l_name_size = 4; 1541 lmo.l_next_offset = 12; 1542 lmo.l_next_size = 4; 1543 lmo.l_prev_offset = 16; 1544 lmo.l_prev_size = 4; 1545 } 1546 1547 return lmp; 1548} 1549 1550/* Fetch (and possibly build) an appropriate `struct link_map_offsets' 1551 for an LP64 SVR4 system. */ 1552 1553struct link_map_offsets * 1554svr4_lp64_fetch_link_map_offsets (void) 1555{ 1556 static struct link_map_offsets lmo; 1557 static struct link_map_offsets *lmp = NULL; 1558 1559 if (lmp == NULL) 1560 { 1561 lmp = &lmo; 1562 1563 /* Everything we need is in the first 16 bytes. */ 1564 lmo.r_debug_size = 16; 1565 lmo.r_map_offset = 8; 1566 lmo.r_map_size = 8; 1567 1568 /* Everything we need is in the first 40 bytes. */ 1569 lmo.link_map_size = 40; 1570 lmo.l_addr_offset = 0; 1571 lmo.l_addr_size = 8; 1572 lmo.l_name_offset = 8; 1573 lmo.l_name_size = 8; 1574 lmo.l_next_offset = 24; 1575 lmo.l_next_size = 8; 1576 lmo.l_prev_offset = 32; 1577 lmo.l_prev_size = 8; 1578 } 1579 1580 return lmp; 1581} 1582 1583 1584static struct target_so_ops svr4_so_ops; 1585 1586extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */ 1587 1588void 1589_initialize_svr4_solib (void) 1590{ 1591 fetch_link_map_offsets_gdbarch_data = 1592 register_gdbarch_data (init_fetch_link_map_offsets); 1593 1594 svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses; 1595 svr4_so_ops.free_so = svr4_free_so; 1596 svr4_so_ops.clear_solib = svr4_clear_solib; 1597 svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook; 1598 svr4_so_ops.special_symbol_handling = svr4_special_symbol_handling; 1599 svr4_so_ops.current_sos = svr4_current_sos; 1600 svr4_so_ops.open_symbol_file_object = open_symbol_file_object; 1601 svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code; 1602 1603 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */ 1604 current_target_so_ops = &svr4_so_ops; 1605} 1606