1 /* Handle shared libraries for GDB, the GNU Debugger. 2 3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 4 2000, 2001, 2002, 2003, 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 <sys/types.h> 25 #include <fcntl.h> 26 #include "gdb_string.h" 27 #include "symtab.h" 28 #include "bfd.h" 29 #include "symfile.h" 30 #include "objfiles.h" 31 #include "exceptions.h" 32 #include "gdbcore.h" 33 #include "command.h" 34 #include "target.h" 35 #include "frame.h" 36 #include "gdb_regex.h" 37 #include "inferior.h" 38 #include "environ.h" 39 #include "language.h" 40 #include "gdbcmd.h" 41 #include "completer.h" 42 #include "filenames.h" /* for DOSish file names */ 43 #include "exec.h" 44 #include "solist.h" 45 #include "observer.h" 46 #include "readline/readline.h" 47 #include "remote.h" 48 #include "solib.h" 49 #include "interps.h" 50 51 /* Architecture-specific operations. */ 52 53 /* Per-architecture data key. */ 54 static struct gdbarch_data *solib_data; 55 56 static void * 57 solib_init (struct obstack *obstack) 58 { 59 struct target_so_ops **ops; 60 61 ops = OBSTACK_ZALLOC (obstack, struct target_so_ops *); 62 *ops = current_target_so_ops; 63 return ops; 64 } 65 66 static struct target_so_ops * 67 solib_ops (struct gdbarch *gdbarch) 68 { 69 struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data); 70 return *ops; 71 } 72 73 /* Set the solib operations for GDBARCH to NEW_OPS. */ 74 75 void 76 set_solib_ops (struct gdbarch *gdbarch, struct target_so_ops *new_ops) 77 { 78 struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data); 79 *ops = new_ops; 80 } 81 82 83 /* external data declarations */ 84 85 /* FIXME: gdbarch needs to control this variable, or else every 86 configuration needs to call set_solib_ops. */ 87 struct target_so_ops *current_target_so_ops; 88 89 /* local data declarations */ 90 91 static struct so_list *so_list_head; /* List of known shared objects */ 92 93 /* Local function prototypes */ 94 95 /* If non-empty, this is a search path for loading non-absolute shared library 96 symbol files. This takes precedence over the environment variables PATH 97 and LD_LIBRARY_PATH. */ 98 static char *solib_search_path = NULL; 99 static void 100 show_solib_search_path (struct ui_file *file, int from_tty, 101 struct cmd_list_element *c, const char *value) 102 { 103 fprintf_filtered (file, _("\ 104 The search path for loading non-absolute shared library symbol files is %s.\n"), 105 value); 106 } 107 108 /* 109 110 GLOBAL FUNCTION 111 112 solib_find -- Find a shared library file. 113 114 SYNOPSIS 115 116 char *solib_find (char *in_pathname, int *fd); 117 118 DESCRIPTION 119 120 Global variable GDB_SYSROOT is used as a prefix directory 121 to search for shared libraries if they have an absolute path. 122 123 Global variable SOLIB_SEARCH_PATH is used as a prefix directory 124 (or set of directories, as in LD_LIBRARY_PATH) to search for all 125 shared libraries if not found in GDB_SYSROOT. 126 127 Search algorithm: 128 * If there is a gdb_sysroot and path is absolute: 129 * Search for gdb_sysroot/path. 130 * else 131 * Look for it literally (unmodified). 132 * Look in SOLIB_SEARCH_PATH. 133 * If available, use target defined search function. 134 * If gdb_sysroot is NOT set, perform the following two searches: 135 * Look in inferior's $PATH. 136 * Look in inferior's $LD_LIBRARY_PATH. 137 * 138 * The last check avoids doing this search when targetting remote 139 * machines since gdb_sysroot will almost always be set. 140 141 RETURNS 142 143 Full pathname of the shared library file, or NULL if not found. 144 (The pathname is malloc'ed; it needs to be freed by the caller.) 145 *FD is set to either -1 or an open file handle for the library. */ 146 147 char * 148 solib_find (char *in_pathname, int *fd) 149 { 150 struct target_so_ops *ops = solib_ops (target_gdbarch); 151 int found_file = -1; 152 char *temp_pathname = NULL; 153 int gdb_sysroot_is_empty; 154 155 gdb_sysroot_is_empty = (gdb_sysroot == NULL || *gdb_sysroot == 0); 156 157 if (! IS_ABSOLUTE_PATH (in_pathname) || gdb_sysroot_is_empty) 158 temp_pathname = in_pathname; 159 else 160 { 161 int prefix_len = strlen (gdb_sysroot); 162 163 /* Remove trailing slashes from absolute prefix. */ 164 while (prefix_len > 0 165 && IS_DIR_SEPARATOR (gdb_sysroot[prefix_len - 1])) 166 prefix_len--; 167 168 /* Cat the prefixed pathname together. */ 169 temp_pathname = alloca (prefix_len + strlen (in_pathname) + 1); 170 strncpy (temp_pathname, gdb_sysroot, prefix_len); 171 temp_pathname[prefix_len] = '\0'; 172 strcat (temp_pathname, in_pathname); 173 } 174 175 /* Handle remote files. */ 176 if (remote_filename_p (temp_pathname)) 177 { 178 *fd = -1; 179 return xstrdup (temp_pathname); 180 } 181 182 /* Now see if we can open it. */ 183 found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0); 184 185 /* We try to find the library in various ways. After each attempt 186 (except for the one above), either found_file >= 0 and 187 temp_pathname is a malloc'd string, or found_file < 0 and 188 temp_pathname does not point to storage that needs to be 189 freed. */ 190 191 if (found_file < 0) 192 temp_pathname = NULL; 193 else 194 temp_pathname = xstrdup (temp_pathname); 195 196 /* If the search in gdb_sysroot failed, and the path name is 197 absolute at this point, make it relative. (openp will try and open the 198 file according to its absolute path otherwise, which is not what we want.) 199 Affects subsequent searches for this solib. */ 200 if (found_file < 0 && IS_ABSOLUTE_PATH (in_pathname)) 201 { 202 /* First, get rid of any drive letters etc. */ 203 while (!IS_DIR_SEPARATOR (*in_pathname)) 204 in_pathname++; 205 206 /* Next, get rid of all leading dir separators. */ 207 while (IS_DIR_SEPARATOR (*in_pathname)) 208 in_pathname++; 209 } 210 211 /* If not found, search the solib_search_path (if any). */ 212 if (found_file < 0 && solib_search_path != NULL) 213 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST, 214 in_pathname, O_RDONLY | O_BINARY, &temp_pathname); 215 216 /* If not found, next search the solib_search_path (if any) for the basename 217 only (ignoring the path). This is to allow reading solibs from a path 218 that differs from the opened path. */ 219 if (found_file < 0 && solib_search_path != NULL) 220 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST, 221 lbasename (in_pathname), O_RDONLY | O_BINARY, 222 &temp_pathname); 223 224 /* If not found, try to use target supplied solib search method */ 225 if (found_file < 0 && ops->find_and_open_solib) 226 found_file = ops->find_and_open_solib (in_pathname, O_RDONLY | O_BINARY, 227 &temp_pathname); 228 229 /* If not found, next search the inferior's $PATH environment variable. */ 230 if (found_file < 0 && gdb_sysroot_is_empty) 231 found_file = openp (get_in_environ (inferior_environ, "PATH"), 232 OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY, 233 &temp_pathname); 234 235 /* If not found, next search the inferior's $LD_LIBRARY_PATH 236 environment variable. */ 237 if (found_file < 0 && gdb_sysroot_is_empty) 238 found_file = openp (get_in_environ (inferior_environ, "LD_LIBRARY_PATH"), 239 OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY, 240 &temp_pathname); 241 242 *fd = found_file; 243 return temp_pathname; 244 } 245 246 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1, 247 it is used as file handle to open the file. Throws an error if the file 248 could not be opened. Handles both local and remote file access. 249 250 PATHNAME must be malloc'ed by the caller. If successful, the new BFD's 251 name will point to it. If unsuccessful, PATHNAME will be freed and the 252 FD will be closed (unless FD was -1). */ 253 254 bfd * 255 solib_bfd_fopen (char *pathname, int fd) 256 { 257 bfd *abfd; 258 259 if (remote_filename_p (pathname)) 260 { 261 gdb_assert (fd == -1); 262 abfd = remote_bfd_open (pathname, gnutarget); 263 } 264 else 265 { 266 abfd = bfd_fopen (pathname, gnutarget, FOPEN_RB, fd); 267 268 if (abfd) 269 bfd_set_cacheable (abfd, 1); 270 else if (fd != -1) 271 close (fd); 272 } 273 274 if (!abfd) 275 { 276 make_cleanup (xfree, pathname); 277 error (_("Could not open `%s' as an executable file: %s"), 278 pathname, bfd_errmsg (bfd_get_error ())); 279 } 280 281 return abfd; 282 } 283 284 /* Find shared library PATHNAME and open a BFD for it. */ 285 286 bfd * 287 solib_bfd_open (char *pathname) 288 { 289 char *found_pathname; 290 int found_file; 291 bfd *abfd; 292 const struct bfd_arch_info *b; 293 294 /* Search for shared library file. */ 295 found_pathname = solib_find (pathname, &found_file); 296 if (found_pathname == NULL) 297 perror_with_name (pathname); 298 299 /* Open bfd for shared library. */ 300 abfd = solib_bfd_fopen (found_pathname, found_file); 301 302 /* Check bfd format. */ 303 if (!bfd_check_format (abfd, bfd_object)) 304 { 305 bfd_close (abfd); 306 make_cleanup (xfree, found_pathname); 307 error (_("`%s': not in executable format: %s"), 308 found_pathname, bfd_errmsg (bfd_get_error ())); 309 } 310 311 /* Check bfd arch. */ 312 b = gdbarch_bfd_arch_info (target_gdbarch); 313 if (!b->compatible (b, bfd_get_arch_info (abfd))) 314 warning (_("`%s': Shared library architecture %s is not compatible " 315 "with target architecture %s."), found_pathname, 316 bfd_get_arch_info (abfd)->printable_name, b->printable_name); 317 318 return abfd; 319 } 320 321 322 /* 323 324 LOCAL FUNCTION 325 326 solib_map_sections -- open bfd and build sections for shared lib 327 328 SYNOPSIS 329 330 static int solib_map_sections (struct so_list *so) 331 332 DESCRIPTION 333 334 Given a pointer to one of the shared objects in our list 335 of mapped objects, use the recorded name to open a bfd 336 descriptor for the object, build a section table, and then 337 relocate all the section addresses by the base address at 338 which the shared object was mapped. 339 340 FIXMES 341 342 In most (all?) cases the shared object file name recorded in the 343 dynamic linkage tables will be a fully qualified pathname. For 344 cases where it isn't, do we really mimic the systems search 345 mechanism correctly in the below code (particularly the tilde 346 expansion stuff?). 347 */ 348 349 static int 350 solib_map_sections (void *arg) 351 { 352 struct so_list *so = (struct so_list *) arg; /* catch_errors bogon */ 353 struct target_so_ops *ops = solib_ops (target_gdbarch); 354 char *filename; 355 struct target_section *p; 356 struct cleanup *old_chain; 357 bfd *abfd; 358 359 filename = tilde_expand (so->so_name); 360 old_chain = make_cleanup (xfree, filename); 361 abfd = ops->bfd_open (filename); 362 do_cleanups (old_chain); 363 364 /* Leave bfd open, core_xfer_memory and "info files" need it. */ 365 so->abfd = gdb_bfd_ref (abfd); 366 367 /* copy full path name into so_name, so that later symbol_file_add 368 can find it */ 369 if (strlen (bfd_get_filename (abfd)) >= SO_NAME_MAX_PATH_SIZE) 370 error (_("Shared library file name is too long.")); 371 strcpy (so->so_name, bfd_get_filename (abfd)); 372 373 if (build_section_table (abfd, &so->sections, &so->sections_end)) 374 { 375 error (_("Can't find the file sections in `%s': %s"), 376 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ())); 377 } 378 379 for (p = so->sections; p < so->sections_end; p++) 380 { 381 /* Relocate the section binding addresses as recorded in the shared 382 object's file by the base address to which the object was actually 383 mapped. */ 384 ops->relocate_section_addresses (so, p); 385 386 /* If the target didn't provide information about the address 387 range of the shared object, assume we want the location of 388 the .text section. */ 389 if (so->addr_low == 0 && so->addr_high == 0 390 && strcmp (p->the_bfd_section->name, ".text") == 0) 391 { 392 so->addr_low = p->addr; 393 so->addr_high = p->endaddr; 394 } 395 } 396 397 return (1); 398 } 399 400 /* LOCAL FUNCTION 401 402 free_so --- free a `struct so_list' object 403 404 SYNOPSIS 405 406 void free_so (struct so_list *so) 407 408 DESCRIPTION 409 410 Free the storage associated with the `struct so_list' object SO. 411 If we have opened a BFD for SO, close it. 412 413 The caller is responsible for removing SO from whatever list it is 414 a member of. If we have placed SO's sections in some target's 415 section table, the caller is responsible for removing them. 416 417 This function doesn't mess with objfiles at all. If there is an 418 objfile associated with SO that needs to be removed, the caller is 419 responsible for taking care of that. */ 420 421 void 422 free_so (struct so_list *so) 423 { 424 struct target_so_ops *ops = solib_ops (target_gdbarch); 425 426 if (so->sections) 427 xfree (so->sections); 428 429 gdb_bfd_unref (so->abfd); 430 431 ops->free_so (so); 432 433 xfree (so); 434 } 435 436 437 /* Return address of first so_list entry in master shared object list. */ 438 struct so_list * 439 master_so_list (void) 440 { 441 return so_list_head; 442 } 443 444 static void 445 symbol_add_stub (struct so_list *so, int flags) 446 { 447 struct section_addr_info *sap; 448 449 /* Have we already loaded this shared object? */ 450 ALL_OBJFILES (so->objfile) 451 { 452 if (strcmp (so->objfile->name, so->so_name) == 0) 453 return; 454 } 455 456 sap = build_section_addr_info_from_section_table (so->sections, 457 so->sections_end); 458 459 so->objfile = symbol_file_add_from_bfd (so->abfd, flags, sap, OBJF_SHARED); 460 free_section_addr_info (sap); 461 462 return; 463 } 464 465 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS, 466 be chatty about it. Return non-zero if any symbols were actually 467 loaded. */ 468 469 int 470 solib_read_symbols (struct so_list *so, int flags) 471 { 472 const int from_tty = flags & SYMFILE_VERBOSE; 473 474 if (so->symbols_loaded) 475 { 476 if (from_tty || info_verbose) 477 printf_unfiltered (_("Symbols already loaded for %s\n"), so->so_name); 478 } 479 else if (so->abfd == NULL) 480 { 481 if (from_tty || info_verbose) 482 printf_unfiltered (_("Symbol file not found for %s\n"), so->so_name); 483 } 484 else 485 { 486 volatile struct gdb_exception exception; 487 TRY_CATCH (exception, RETURN_MASK_ALL) 488 { 489 symbol_add_stub (so, flags); 490 } 491 if (exception.reason != 0) 492 { 493 exception_fprintf (gdb_stderr, exception, 494 "Error while reading shared library symbols:\n"); 495 return 0; 496 } 497 if (from_tty || info_verbose) 498 printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name); 499 so->symbols_loaded = 1; 500 return 1; 501 } 502 503 return 0; 504 } 505 506 /* LOCAL FUNCTION 507 508 update_solib_list --- synchronize GDB's shared object list with inferior's 509 510 SYNOPSIS 511 512 void update_solib_list (int from_tty, struct target_ops *TARGET) 513 514 Extract the list of currently loaded shared objects from the 515 inferior, and compare it with the list of shared objects currently 516 in GDB's so_list_head list. Edit so_list_head to bring it in sync 517 with the inferior's new list. 518 519 If we notice that the inferior has unloaded some shared objects, 520 free any symbolic info GDB had read about those shared objects. 521 522 Don't load symbolic info for any new shared objects; just add them 523 to the list, and leave their symbols_loaded flag clear. 524 525 If FROM_TTY is non-null, feel free to print messages about what 526 we're doing. 527 528 If TARGET is non-null, add the sections of all new shared objects 529 to TARGET's section table. Note that this doesn't remove any 530 sections for shared objects that have been unloaded, and it 531 doesn't check to see if the new shared objects are already present in 532 the section table. But we only use this for core files and 533 processes we've just attached to, so that's okay. */ 534 535 static void 536 update_solib_list (int from_tty, struct target_ops *target) 537 { 538 struct target_so_ops *ops = solib_ops (target_gdbarch); 539 struct so_list *inferior = ops->current_sos(); 540 struct so_list *gdb, **gdb_link; 541 542 /* We can reach here due to changing solib-search-path or the 543 sysroot, before having any inferior. */ 544 if (target_has_execution && !ptid_equal (inferior_ptid, null_ptid)) 545 { 546 struct inferior *inf = current_inferior (); 547 548 /* If we are attaching to a running process for which we 549 have not opened a symbol file, we may be able to get its 550 symbols now! */ 551 if (inf->attach_flag && symfile_objfile == NULL) 552 catch_errors (ops->open_symbol_file_object, &from_tty, 553 "Error reading attached process's symbol file.\n", 554 RETURN_MASK_ALL); 555 } 556 557 /* GDB and the inferior's dynamic linker each maintain their own 558 list of currently loaded shared objects; we want to bring the 559 former in sync with the latter. Scan both lists, seeing which 560 shared objects appear where. There are three cases: 561 562 - A shared object appears on both lists. This means that GDB 563 knows about it already, and it's still loaded in the inferior. 564 Nothing needs to happen. 565 566 - A shared object appears only on GDB's list. This means that 567 the inferior has unloaded it. We should remove the shared 568 object from GDB's tables. 569 570 - A shared object appears only on the inferior's list. This 571 means that it's just been loaded. We should add it to GDB's 572 tables. 573 574 So we walk GDB's list, checking each entry to see if it appears 575 in the inferior's list too. If it does, no action is needed, and 576 we remove it from the inferior's list. If it doesn't, the 577 inferior has unloaded it, and we remove it from GDB's list. By 578 the time we're done walking GDB's list, the inferior's list 579 contains only the new shared objects, which we then add. */ 580 581 gdb = so_list_head; 582 gdb_link = &so_list_head; 583 while (gdb) 584 { 585 struct so_list *i = inferior; 586 struct so_list **i_link = &inferior; 587 588 /* Check to see whether the shared object *gdb also appears in 589 the inferior's current list. */ 590 while (i) 591 { 592 if (ops->same) 593 { 594 if (ops->same (gdb, i)) 595 break; 596 } 597 else 598 { 599 if (! strcmp (gdb->so_original_name, i->so_original_name)) 600 break; 601 } 602 603 i_link = &i->next; 604 i = *i_link; 605 } 606 607 /* If the shared object appears on the inferior's list too, then 608 it's still loaded, so we don't need to do anything. Delete 609 it from the inferior's list, and leave it on GDB's list. */ 610 if (i) 611 { 612 *i_link = i->next; 613 free_so (i); 614 gdb_link = &gdb->next; 615 gdb = *gdb_link; 616 } 617 618 /* If it's not on the inferior's list, remove it from GDB's tables. */ 619 else 620 { 621 /* Notify any observer that the shared object has been 622 unloaded before we remove it from GDB's tables. */ 623 observer_notify_solib_unloaded (gdb); 624 625 *gdb_link = gdb->next; 626 627 /* Unless the user loaded it explicitly, free SO's objfile. */ 628 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)) 629 free_objfile (gdb->objfile); 630 631 /* Some targets' section tables might be referring to 632 sections from so->abfd; remove them. */ 633 remove_target_sections (gdb->abfd); 634 635 free_so (gdb); 636 gdb = *gdb_link; 637 } 638 } 639 640 /* Now the inferior's list contains only shared objects that don't 641 appear in GDB's list --- those that are newly loaded. Add them 642 to GDB's shared object list. */ 643 if (inferior) 644 { 645 struct so_list *i; 646 647 /* Add the new shared objects to GDB's list. */ 648 *gdb_link = inferior; 649 650 /* Fill in the rest of each of the `struct so_list' nodes. */ 651 for (i = inferior; i; i = i->next) 652 { 653 i->from_tty = from_tty; 654 655 /* Fill in the rest of the `struct so_list' node. */ 656 catch_errors (solib_map_sections, i, 657 "Error while mapping shared library sections:\n", 658 RETURN_MASK_ALL); 659 660 /* Add the shared object's sections to the current set of 661 file section tables. Do this immediately after mapping 662 the object so that later nodes in the list can query this 663 object, as is needed in solib-osf.c. */ 664 add_target_sections (i->sections, i->sections_end); 665 666 /* Notify any observer that the shared object has been 667 loaded now that we've added it to GDB's tables. */ 668 observer_notify_solib_loaded (i); 669 } 670 } 671 } 672 673 674 /* Return non-zero if NAME is the libpthread shared library. 675 676 Uses a fairly simplistic heuristic approach where we check 677 the file name against "/libpthread". This can lead to false 678 positives, but this should be good enough in practice. */ 679 680 int 681 libpthread_name_p (const char *name) 682 { 683 return (strstr (name, "/libpthread") != NULL); 684 } 685 686 /* Return non-zero if SO is the libpthread shared library. */ 687 688 static int 689 libpthread_solib_p (struct so_list *so) 690 { 691 return libpthread_name_p (so->so_name); 692 } 693 694 /* GLOBAL FUNCTION 695 696 solib_add -- read in symbol info for newly added shared libraries 697 698 SYNOPSIS 699 700 void solib_add (char *pattern, int from_tty, struct target_ops 701 *TARGET, int readsyms) 702 703 DESCRIPTION 704 705 Read in symbolic information for any shared objects whose names 706 match PATTERN. (If we've already read a shared object's symbol 707 info, leave it alone.) If PATTERN is zero, read them all. 708 709 If READSYMS is 0, defer reading symbolic information until later 710 but still do any needed low level processing. 711 712 FROM_TTY and TARGET are as described for update_solib_list, above. */ 713 714 void 715 solib_add (char *pattern, int from_tty, struct target_ops *target, int readsyms) 716 { 717 struct so_list *gdb; 718 719 if (pattern) 720 { 721 char *re_err = re_comp (pattern); 722 723 if (re_err) 724 error (_("Invalid regexp: %s"), re_err); 725 } 726 727 update_solib_list (from_tty, target); 728 729 /* Walk the list of currently loaded shared libraries, and read 730 symbols for any that match the pattern --- or any whose symbols 731 aren't already loaded, if no pattern was given. */ 732 { 733 int any_matches = 0; 734 int loaded_any_symbols = 0; 735 const int flags = 736 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0); 737 738 for (gdb = so_list_head; gdb; gdb = gdb->next) 739 if (! pattern || re_exec (gdb->so_name)) 740 { 741 /* Normally, we would read the symbols from that library 742 only if READSYMS is set. However, we're making a small 743 exception for the pthread library, because we sometimes 744 need the library symbols to be loaded in order to provide 745 thread support (x86-linux for instance). */ 746 const int add_this_solib = 747 (readsyms || libpthread_solib_p (gdb)); 748 749 any_matches = 1; 750 if (add_this_solib && solib_read_symbols (gdb, flags)) 751 loaded_any_symbols = 1; 752 } 753 754 if (loaded_any_symbols) 755 breakpoint_re_set (); 756 757 if (from_tty && pattern && ! any_matches) 758 printf_unfiltered 759 ("No loaded shared libraries match the pattern `%s'.\n", pattern); 760 761 if (loaded_any_symbols) 762 { 763 struct target_so_ops *ops = solib_ops (target_gdbarch); 764 765 /* Getting new symbols may change our opinion about what is 766 frameless. */ 767 reinit_frame_cache (); 768 769 ops->special_symbol_handling (); 770 } 771 } 772 } 773 774 775 /* 776 777 LOCAL FUNCTION 778 779 info_sharedlibrary_command -- code for "info sharedlibrary" 780 781 SYNOPSIS 782 783 static void info_sharedlibrary_command () 784 785 DESCRIPTION 786 787 Walk through the shared library list and print information 788 about each attached library matching PATTERN. If PATTERN is elided, 789 print them all. 790 */ 791 792 static void 793 info_sharedlibrary_command (char *pattern, int from_tty) 794 { 795 struct so_list *so = NULL; /* link map state variable */ 796 int header_done = 0; 797 int so_missing_debug_info = 0; 798 int addr_width; 799 int nr_libs; 800 struct cleanup *table_cleanup; 801 struct gdbarch *gdbarch = target_gdbarch; 802 803 if (pattern) 804 { 805 char *re_err = re_comp (pattern); 806 807 if (re_err) 808 error (_("Invalid regexp: %s"), re_err); 809 } 810 811 /* "0x", a little whitespace, and two hex digits per byte of pointers. */ 812 addr_width = 4 + (gdbarch_ptr_bit (gdbarch) / 4); 813 814 update_solib_list (from_tty, 0); 815 816 /* make_cleanup_ui_out_table_begin_end needs to know the number of 817 rows, so we need to make two passes over the libs. */ 818 819 for (nr_libs = 0, so = so_list_head; so; so = so->next) 820 { 821 if (so->so_name[0]) 822 { 823 if (pattern && ! re_exec (so->so_name)) 824 continue; 825 ++nr_libs; 826 } 827 } 828 829 table_cleanup = 830 make_cleanup_ui_out_table_begin_end (uiout, 4, nr_libs, 831 "SharedLibraryTable"); 832 833 /* The "- 1" is because ui_out adds one space between columns. */ 834 ui_out_table_header (uiout, addr_width - 1, ui_left, "from", "From"); 835 ui_out_table_header (uiout, addr_width - 1, ui_left, "to", "To"); 836 ui_out_table_header (uiout, 12 - 1, ui_left, "syms-read", "Syms Read"); 837 ui_out_table_header (uiout, 0, ui_noalign, 838 "name", "Shared Object Library"); 839 840 ui_out_table_body (uiout); 841 842 for (so = so_list_head; so; so = so->next) 843 { 844 struct cleanup *lib_cleanup; 845 846 if (! so->so_name[0]) 847 continue; 848 if (pattern && ! re_exec (so->so_name)) 849 continue; 850 851 lib_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "lib"); 852 853 if (so->addr_high != 0) 854 { 855 ui_out_field_core_addr (uiout, "from", gdbarch, so->addr_low); 856 ui_out_field_core_addr (uiout, "to", gdbarch, so->addr_high); 857 } 858 else 859 { 860 ui_out_field_skip (uiout, "from"); 861 ui_out_field_skip (uiout, "to"); 862 } 863 864 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())) 865 && so->symbols_loaded 866 && !objfile_has_partial_symbols (so->objfile) 867 && !objfile_has_full_symbols (so->objfile)) 868 { 869 so_missing_debug_info = 1; 870 ui_out_field_string (uiout, "syms-read", "Yes (*)"); 871 } 872 else 873 ui_out_field_string (uiout, "syms-read", 874 so->symbols_loaded ? "Yes" : "No"); 875 876 ui_out_field_string (uiout, "name", so->so_name); 877 878 ui_out_text (uiout, "\n"); 879 880 do_cleanups (lib_cleanup); 881 } 882 883 do_cleanups (table_cleanup); 884 885 if (nr_libs == 0) 886 { 887 if (pattern) 888 ui_out_message (uiout, 0, 889 _("No shared libraries matched.\n")); 890 else 891 ui_out_message (uiout, 0, 892 _("No shared libraries loaded at this time.\n")); 893 } 894 else 895 { 896 if (so_missing_debug_info) 897 ui_out_message (uiout, 0, 898 _("(*): Shared library is missing debugging information.\n")); 899 } 900 } 901 902 /* Return 1 if ADDRESS lies within SOLIB. */ 903 904 int 905 solib_contains_address_p (const struct so_list *const solib, 906 CORE_ADDR address) 907 { 908 struct target_section *p; 909 910 for (p = solib->sections; p < solib->sections_end; p++) 911 if (p->addr <= address && address < p->endaddr) 912 return 1; 913 914 return 0; 915 } 916 917 /* 918 919 GLOBAL FUNCTION 920 921 solib_name_from_address -- if an address is in a shared lib, return 922 its name. 923 924 SYNOPSIS 925 926 char * solib_name_from_address (CORE_ADDR address) 927 928 DESCRIPTION 929 930 Provides a hook for other gdb routines to discover whether or 931 not a particular address is within the mapped address space of 932 a shared library. 933 934 For example, this routine is called at one point to disable 935 breakpoints which are in shared libraries that are not currently 936 mapped in. 937 */ 938 939 char * 940 solib_name_from_address (CORE_ADDR address) 941 { 942 struct so_list *so = 0; /* link map state variable */ 943 944 for (so = so_list_head; so; so = so->next) 945 if (solib_contains_address_p (so, address)) 946 return (so->so_name); 947 948 return (0); 949 } 950 951 /* Called by free_all_symtabs */ 952 953 void 954 clear_solib (void) 955 { 956 struct target_so_ops *ops = solib_ops (target_gdbarch); 957 958 /* This function is expected to handle ELF shared libraries. It is 959 also used on Solaris, which can run either ELF or a.out binaries 960 (for compatibility with SunOS 4), both of which can use shared 961 libraries. So we don't know whether we have an ELF executable or 962 an a.out executable until the user chooses an executable file. 963 964 ELF shared libraries don't get mapped into the address space 965 until after the program starts, so we'd better not try to insert 966 breakpoints in them immediately. We have to wait until the 967 dynamic linker has loaded them; we'll hit a bp_shlib_event 968 breakpoint (look for calls to create_solib_event_breakpoint) when 969 it's ready. 970 971 SunOS shared libraries seem to be different --- they're present 972 as soon as the process begins execution, so there's no need to 973 put off inserting breakpoints. There's also nowhere to put a 974 bp_shlib_event breakpoint, so if we put it off, we'll never get 975 around to it. 976 977 So: disable breakpoints only if we're using ELF shared libs. */ 978 if (exec_bfd != NULL 979 && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour) 980 disable_breakpoints_in_shlibs (); 981 982 while (so_list_head) 983 { 984 struct so_list *so = so_list_head; 985 so_list_head = so->next; 986 observer_notify_solib_unloaded (so); 987 if (so->abfd) 988 remove_target_sections (so->abfd); 989 free_so (so); 990 } 991 992 ops->clear_solib (); 993 } 994 995 /* GLOBAL FUNCTION 996 997 solib_create_inferior_hook -- shared library startup support 998 999 SYNOPSIS 1000 1001 void solib_create_inferior_hook () 1002 1003 DESCRIPTION 1004 1005 When gdb starts up the inferior, it nurses it along (through the 1006 shell) until it is ready to execute it's first instruction. At this 1007 point, this function gets called via expansion of the macro 1008 SOLIB_CREATE_INFERIOR_HOOK. */ 1009 1010 void 1011 solib_create_inferior_hook (void) 1012 { 1013 struct target_so_ops *ops = solib_ops (target_gdbarch); 1014 ops->solib_create_inferior_hook(); 1015 } 1016 1017 /* GLOBAL FUNCTION 1018 1019 in_solib_dynsym_resolve_code -- check to see if an address is in 1020 dynamic loader's dynamic symbol 1021 resolution code 1022 1023 SYNOPSIS 1024 1025 int in_solib_dynsym_resolve_code (CORE_ADDR pc) 1026 1027 DESCRIPTION 1028 1029 Determine if PC is in the dynamic linker's symbol resolution 1030 code. Return 1 if so, 0 otherwise. 1031 */ 1032 1033 int 1034 in_solib_dynsym_resolve_code (CORE_ADDR pc) 1035 { 1036 struct target_so_ops *ops = solib_ops (target_gdbarch); 1037 return ops->in_dynsym_resolve_code (pc); 1038 } 1039 1040 /* 1041 1042 LOCAL FUNCTION 1043 1044 sharedlibrary_command -- handle command to explicitly add library 1045 1046 SYNOPSIS 1047 1048 static void sharedlibrary_command (char *args, int from_tty) 1049 1050 DESCRIPTION 1051 1052 */ 1053 1054 static void 1055 sharedlibrary_command (char *args, int from_tty) 1056 { 1057 dont_repeat (); 1058 solib_add (args, from_tty, (struct target_ops *) 0, 1); 1059 } 1060 1061 /* LOCAL FUNCTION 1062 1063 no_shared_libraries -- handle command to explicitly discard symbols 1064 from shared libraries. 1065 1066 DESCRIPTION 1067 1068 Implements the command "nosharedlibrary", which discards symbols 1069 that have been auto-loaded from shared libraries. Symbols from 1070 shared libraries that were added by explicit request of the user 1071 are not discarded. Also called from remote.c. */ 1072 1073 void 1074 no_shared_libraries (char *ignored, int from_tty) 1075 { 1076 /* The order of the two routines below is important: clear_solib notifies 1077 the solib_unloaded observers, and some of these observers might need 1078 access to their associated objfiles. Therefore, we can not purge the 1079 solibs' objfiles before clear_solib has been called. */ 1080 1081 clear_solib (); 1082 objfile_purge_solibs (); 1083 } 1084 1085 static void 1086 reload_shared_libraries (char *ignored, int from_tty, 1087 struct cmd_list_element *e) 1088 { 1089 no_shared_libraries (NULL, from_tty); 1090 solib_add (NULL, from_tty, NULL, auto_solib_add); 1091 /* Creating inferior hooks here has two purposes. First, if we reload 1092 shared libraries then the address of solib breakpoint we've computed 1093 previously might be no longer valid. For example, if we forgot to set 1094 solib-absolute-prefix and are setting it right now, then the previous 1095 breakpoint address is plain wrong. Second, installing solib hooks 1096 also implicitly figures were ld.so is and loads symbols for it. 1097 Absent this call, if we've just connected to a target and set 1098 solib-absolute-prefix or solib-search-path, we'll lose all information 1099 about ld.so. */ 1100 if (target_has_execution) 1101 { 1102 #ifdef SOLIB_CREATE_INFERIOR_HOOK 1103 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid)); 1104 #else 1105 solib_create_inferior_hook (); 1106 #endif 1107 } 1108 /* We have unloaded and then reloaded debug info for all shared libraries. 1109 However, frames may still reference them, for example a frame's 1110 unwinder might still point of DWARF FDE structures that are now freed. 1111 Reinit frame cache to avoid crashing. */ 1112 reinit_frame_cache (); 1113 } 1114 1115 static void 1116 show_auto_solib_add (struct ui_file *file, int from_tty, 1117 struct cmd_list_element *c, const char *value) 1118 { 1119 fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"), 1120 value); 1121 } 1122 1123 1124 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call 1125 the library-specific handler if it is installed for the current target. */ 1126 1127 struct symbol * 1128 solib_global_lookup (const struct objfile *objfile, 1129 const char *name, 1130 const char *linkage_name, 1131 const domain_enum domain) 1132 { 1133 struct target_so_ops *ops = solib_ops (target_gdbarch); 1134 1135 if (ops->lookup_lib_global_symbol != NULL) 1136 return ops->lookup_lib_global_symbol (objfile, name, linkage_name, domain); 1137 return NULL; 1138 } 1139 1140 1141 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */ 1142 1143 void 1144 _initialize_solib (void) 1145 { 1146 struct cmd_list_element *c; 1147 1148 solib_data = gdbarch_data_register_pre_init (solib_init); 1149 1150 add_com ("sharedlibrary", class_files, sharedlibrary_command, 1151 _("Load shared object library symbols for files matching REGEXP.")); 1152 add_info ("sharedlibrary", info_sharedlibrary_command, 1153 _("Status of loaded shared object libraries.")); 1154 add_com ("nosharedlibrary", class_files, no_shared_libraries, 1155 _("Unload all shared object library symbols.")); 1156 1157 add_setshow_boolean_cmd ("auto-solib-add", class_support, 1158 &auto_solib_add, _("\ 1159 Set autoloading of shared library symbols."), _("\ 1160 Show autoloading of shared library symbols."), _("\ 1161 If \"on\", symbols from all shared object libraries will be loaded\n\ 1162 automatically when the inferior begins execution, when the dynamic linker\n\ 1163 informs gdb that a new library has been loaded, or when attaching to the\n\ 1164 inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'."), 1165 NULL, 1166 show_auto_solib_add, 1167 &setlist, &showlist); 1168 1169 add_setshow_filename_cmd ("sysroot", class_support, 1170 &gdb_sysroot, _("\ 1171 Set an alternate system root."), _("\ 1172 Show the current system root."), _("\ 1173 The system root is used to load absolute shared library symbol files.\n\ 1174 For other (relative) files, you can add directories using\n\ 1175 `set solib-search-path'."), 1176 reload_shared_libraries, 1177 NULL, 1178 &setlist, &showlist); 1179 1180 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0, 1181 &setlist); 1182 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0, 1183 &showlist); 1184 1185 add_setshow_optional_filename_cmd ("solib-search-path", class_support, 1186 &solib_search_path, _("\ 1187 Set the search path for loading non-absolute shared library symbol files."), _("\ 1188 Show the search path for loading non-absolute shared library symbol files."), _("\ 1189 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH."), 1190 reload_shared_libraries, 1191 show_solib_search_path, 1192 &setlist, &showlist); 1193 } 1194