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, 2010 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 #include "filesystem.h" 51 52 /* Architecture-specific operations. */ 53 54 /* Per-architecture data key. */ 55 static struct gdbarch_data *solib_data; 56 57 static void * 58 solib_init (struct obstack *obstack) 59 { 60 struct target_so_ops **ops; 61 62 ops = OBSTACK_ZALLOC (obstack, struct target_so_ops *); 63 *ops = current_target_so_ops; 64 return ops; 65 } 66 67 static struct target_so_ops * 68 solib_ops (struct gdbarch *gdbarch) 69 { 70 struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data); 71 72 return *ops; 73 } 74 75 /* Set the solib operations for GDBARCH to NEW_OPS. */ 76 77 void 78 set_solib_ops (struct gdbarch *gdbarch, struct target_so_ops *new_ops) 79 { 80 struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data); 81 82 *ops = new_ops; 83 } 84 85 86 /* external data declarations */ 87 88 /* FIXME: gdbarch needs to control this variable, or else every 89 configuration needs to call set_solib_ops. */ 90 struct target_so_ops *current_target_so_ops; 91 92 /* List of known shared objects */ 93 #define so_list_head current_program_space->so_list 94 95 /* Local function prototypes */ 96 97 /* If non-empty, this is a search path for loading non-absolute shared library 98 symbol files. This takes precedence over the environment variables PATH 99 and LD_LIBRARY_PATH. */ 100 static char *solib_search_path = NULL; 101 static void 102 show_solib_search_path (struct ui_file *file, int from_tty, 103 struct cmd_list_element *c, const char *value) 104 { 105 fprintf_filtered (file, _("\ 106 The search path for loading non-absolute shared library symbol files is %s.\n"), 107 value); 108 } 109 110 /* Same as HAVE_DOS_BASED_FILE_SYSTEM, but useable as an rvalue. */ 111 #if (HAVE_DOS_BASED_FILE_SYSTEM) 112 # define DOS_BASED_FILE_SYSTEM 1 113 #else 114 # define DOS_BASED_FILE_SYSTEM 0 115 #endif 116 117 /* 118 119 GLOBAL FUNCTION 120 121 solib_find -- Find a shared library file. 122 123 SYNOPSIS 124 125 char *solib_find (char *in_pathname, int *fd); 126 127 DESCRIPTION 128 129 Global variable GDB_SYSROOT is used as a prefix directory 130 to search for shared libraries if they have an absolute path. 131 132 Global variable SOLIB_SEARCH_PATH is used as a prefix directory 133 (or set of directories, as in LD_LIBRARY_PATH) to search for all 134 shared libraries if not found in GDB_SYSROOT. 135 136 Search algorithm: 137 * If there is a gdb_sysroot and path is absolute: 138 * Search for gdb_sysroot/path. 139 * else 140 * Look for it literally (unmodified). 141 * Look in SOLIB_SEARCH_PATH. 142 * If available, use target defined search function. 143 * If gdb_sysroot is NOT set, perform the following two searches: 144 * Look in inferior's $PATH. 145 * Look in inferior's $LD_LIBRARY_PATH. 146 * 147 * The last check avoids doing this search when targetting remote 148 * machines since gdb_sysroot will almost always be set. 149 150 RETURNS 151 152 Full pathname of the shared library file, or NULL if not found. 153 (The pathname is malloc'ed; it needs to be freed by the caller.) 154 *FD is set to either -1 or an open file handle for the library. */ 155 156 char * 157 solib_find (char *in_pathname, int *fd) 158 { 159 struct target_so_ops *ops = solib_ops (target_gdbarch); 160 int found_file = -1; 161 char *temp_pathname = NULL; 162 int gdb_sysroot_is_empty; 163 const char *solib_symbols_extension 164 = gdbarch_solib_symbols_extension (target_gdbarch); 165 const char *fskind = effective_target_file_system_kind (); 166 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); 167 char *sysroot = NULL; 168 169 /* If solib_symbols_extension is set, replace the file's 170 extension. */ 171 if (solib_symbols_extension) 172 { 173 char *p = in_pathname + strlen (in_pathname); 174 175 while (p > in_pathname && *p != '.') 176 p--; 177 178 if (*p == '.') 179 { 180 char *new_pathname; 181 182 new_pathname = alloca (p - in_pathname + 1 183 + strlen (solib_symbols_extension) + 1); 184 memcpy (new_pathname, in_pathname, p - in_pathname + 1); 185 strcpy (new_pathname + (p - in_pathname) + 1, 186 solib_symbols_extension); 187 188 in_pathname = new_pathname; 189 } 190 } 191 192 gdb_sysroot_is_empty = (gdb_sysroot == NULL || *gdb_sysroot == 0); 193 194 if (!gdb_sysroot_is_empty) 195 { 196 int prefix_len = strlen (gdb_sysroot); 197 198 /* Remove trailing slashes from absolute prefix. */ 199 while (prefix_len > 0 200 && IS_DIR_SEPARATOR (gdb_sysroot[prefix_len - 1])) 201 prefix_len--; 202 203 sysroot = savestring (gdb_sysroot, prefix_len); 204 make_cleanup (xfree, sysroot); 205 } 206 207 /* If we're on a non-DOS-based system, backslashes won't be 208 understood as directory separator, so, convert them to forward 209 slashes, iff we're supposed to handle DOS-based file system 210 semantics for target paths. */ 211 if (!DOS_BASED_FILE_SYSTEM && fskind == file_system_kind_dos_based) 212 { 213 char *p; 214 215 /* Avoid clobbering our input. */ 216 p = alloca (strlen (in_pathname) + 1); 217 strcpy (p, in_pathname); 218 in_pathname = p; 219 220 for (; *p; p++) 221 { 222 if (*p == '\\') 223 *p = '/'; 224 } 225 } 226 227 /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not 228 IS_ABSOLUTE_PATH. The latter is for host paths only, while 229 IN_PATHNAME is a target path. For example, if we're supposed to 230 be handling DOS-like semantics we want to consider a 231 'c:/foo/bar.dll' path as an absolute path, even on a Unix box. 232 With such a path, before giving up on the sysroot, we'll try: 233 234 1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll 235 2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll 236 3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll 237 */ 238 239 if (!IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname) || gdb_sysroot_is_empty) 240 temp_pathname = xstrdup (in_pathname); 241 else 242 { 243 int need_dir_separator; 244 245 need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[0]); 246 247 /* Cat the prefixed pathname together. */ 248 temp_pathname = concat (sysroot, 249 need_dir_separator ? SLASH_STRING : "", 250 in_pathname, (char *) NULL); 251 } 252 253 /* Handle remote files. */ 254 if (remote_filename_p (temp_pathname)) 255 { 256 *fd = -1; 257 return temp_pathname; 258 } 259 260 /* Now see if we can open it. */ 261 found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0); 262 if (found_file < 0) 263 xfree (temp_pathname); 264 265 /* If the search in gdb_sysroot failed, and the path name has a 266 drive spec (e.g, c:/foo), try stripping ':' from the drive spec, 267 and retrying in the sysroot: 268 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */ 269 270 if (found_file < 0 271 && !gdb_sysroot_is_empty 272 && HAS_TARGET_DRIVE_SPEC (fskind, in_pathname)) 273 { 274 int need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[2]); 275 char *drive = savestring (in_pathname, 1); 276 277 temp_pathname = concat (sysroot, 278 SLASH_STRING, 279 drive, 280 need_dir_separator ? SLASH_STRING : "", 281 in_pathname + 2, (char *) NULL); 282 xfree (drive); 283 284 found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0); 285 if (found_file < 0) 286 { 287 xfree (temp_pathname); 288 289 /* If the search in gdb_sysroot still failed, try fully 290 stripping the drive spec, and trying once more in the 291 sysroot before giving up. 292 293 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */ 294 295 temp_pathname = concat (sysroot, 296 need_dir_separator ? SLASH_STRING : "", 297 in_pathname + 2, (char *) NULL); 298 299 found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0); 300 if (found_file < 0) 301 xfree (temp_pathname); 302 } 303 } 304 305 do_cleanups (old_chain); 306 307 /* We try to find the library in various ways. After each attempt, 308 either found_file >= 0 and temp_pathname is a malloc'd string, or 309 found_file < 0 and temp_pathname does not point to storage that 310 needs to be freed. */ 311 312 if (found_file < 0) 313 temp_pathname = NULL; 314 315 /* If not found, search the solib_search_path (if any). */ 316 if (found_file < 0 && solib_search_path != NULL) 317 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST, 318 in_pathname, O_RDONLY | O_BINARY, &temp_pathname); 319 320 /* If the search in gdb_sysroot failed, and the path name is 321 absolute at this point, make it relative. (openp will try and open the 322 file according to its absolute path otherwise, which is not what we want.) 323 Affects subsequent searches for this solib. */ 324 if (found_file < 0 && IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname)) 325 { 326 /* First, get rid of any drive letters etc. */ 327 while (!IS_TARGET_DIR_SEPARATOR (fskind, *in_pathname)) 328 in_pathname++; 329 330 /* Next, get rid of all leading dir separators. */ 331 while (IS_TARGET_DIR_SEPARATOR (fskind, *in_pathname)) 332 in_pathname++; 333 } 334 335 /* If not found, search the solib_search_path (if any). */ 336 if (found_file < 0 && solib_search_path != NULL) 337 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST, 338 in_pathname, O_RDONLY | O_BINARY, &temp_pathname); 339 340 /* If not found, next search the solib_search_path (if any) for the basename 341 only (ignoring the path). This is to allow reading solibs from a path 342 that differs from the opened path. */ 343 if (found_file < 0 && solib_search_path != NULL) 344 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST, 345 target_lbasename (fskind, in_pathname), 346 O_RDONLY | O_BINARY, &temp_pathname); 347 348 /* If not found, try to use target supplied solib search method */ 349 if (found_file < 0 && ops->find_and_open_solib) 350 found_file = ops->find_and_open_solib (in_pathname, O_RDONLY | O_BINARY, 351 &temp_pathname); 352 353 /* If not found, next search the inferior's $PATH environment variable. */ 354 if (found_file < 0 && gdb_sysroot_is_empty) 355 found_file = openp (get_in_environ (current_inferior ()->environment, 356 "PATH"), 357 OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY, 358 &temp_pathname); 359 360 /* If not found, next search the inferior's $LD_LIBRARY_PATH 361 environment variable. */ 362 if (found_file < 0 && gdb_sysroot_is_empty) 363 found_file = openp (get_in_environ (current_inferior ()->environment, 364 "LD_LIBRARY_PATH"), 365 OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY, 366 &temp_pathname); 367 368 *fd = found_file; 369 return temp_pathname; 370 } 371 372 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1, 373 it is used as file handle to open the file. Throws an error if the file 374 could not be opened. Handles both local and remote file access. 375 376 PATHNAME must be malloc'ed by the caller. If successful, the new BFD's 377 name will point to it. If unsuccessful, PATHNAME will be freed and the 378 FD will be closed (unless FD was -1). */ 379 380 bfd * 381 solib_bfd_fopen (char *pathname, int fd) 382 { 383 bfd *abfd; 384 385 if (remote_filename_p (pathname)) 386 { 387 gdb_assert (fd == -1); 388 abfd = remote_bfd_open (pathname, gnutarget); 389 } 390 else 391 { 392 abfd = bfd_fopen (pathname, gnutarget, FOPEN_RB, fd); 393 394 if (abfd) 395 bfd_set_cacheable (abfd, 1); 396 else if (fd != -1) 397 close (fd); 398 } 399 400 if (!abfd) 401 { 402 make_cleanup (xfree, pathname); 403 error (_("Could not open `%s' as an executable file: %s"), 404 pathname, bfd_errmsg (bfd_get_error ())); 405 } 406 407 return abfd; 408 } 409 410 /* Find shared library PATHNAME and open a BFD for it. */ 411 412 bfd * 413 solib_bfd_open (char *pathname) 414 { 415 char *found_pathname; 416 int found_file; 417 bfd *abfd; 418 const struct bfd_arch_info *b; 419 420 /* Search for shared library file. */ 421 found_pathname = solib_find (pathname, &found_file); 422 if (found_pathname == NULL) 423 { 424 /* Return failure if the file could not be found, so that we can 425 accumulate messages about missing libraries. */ 426 if (errno == ENOENT) 427 return NULL; 428 429 perror_with_name (pathname); 430 } 431 432 /* Open bfd for shared library. */ 433 abfd = solib_bfd_fopen (found_pathname, found_file); 434 435 /* Check bfd format. */ 436 if (!bfd_check_format (abfd, bfd_object)) 437 { 438 bfd_close (abfd); 439 make_cleanup (xfree, found_pathname); 440 error (_("`%s': not in executable format: %s"), 441 found_pathname, bfd_errmsg (bfd_get_error ())); 442 } 443 444 /* Check bfd arch. */ 445 b = gdbarch_bfd_arch_info (target_gdbarch); 446 if (!b->compatible (b, bfd_get_arch_info (abfd))) 447 warning (_("`%s': Shared library architecture %s is not compatible " 448 "with target architecture %s."), found_pathname, 449 bfd_get_arch_info (abfd)->printable_name, b->printable_name); 450 451 return abfd; 452 } 453 454 455 /* 456 457 LOCAL FUNCTION 458 459 solib_map_sections -- open bfd and build sections for shared lib 460 461 SYNOPSIS 462 463 static int solib_map_sections (struct so_list *so) 464 465 DESCRIPTION 466 467 Given a pointer to one of the shared objects in our list 468 of mapped objects, use the recorded name to open a bfd 469 descriptor for the object, build a section table, and then 470 relocate all the section addresses by the base address at 471 which the shared object was mapped. 472 473 FIXMES 474 475 In most (all?) cases the shared object file name recorded in the 476 dynamic linkage tables will be a fully qualified pathname. For 477 cases where it isn't, do we really mimic the systems search 478 mechanism correctly in the below code (particularly the tilde 479 expansion stuff?). 480 */ 481 482 static int 483 solib_map_sections (struct so_list *so) 484 { 485 struct target_so_ops *ops = solib_ops (target_gdbarch); 486 char *filename; 487 struct target_section *p; 488 struct cleanup *old_chain; 489 bfd *abfd; 490 491 filename = tilde_expand (so->so_name); 492 old_chain = make_cleanup (xfree, filename); 493 abfd = ops->bfd_open (filename); 494 do_cleanups (old_chain); 495 496 if (abfd == NULL) 497 return 0; 498 499 /* Leave bfd open, core_xfer_memory and "info files" need it. */ 500 so->abfd = gdb_bfd_ref (abfd); 501 502 /* copy full path name into so_name, so that later symbol_file_add 503 can find it */ 504 if (strlen (bfd_get_filename (abfd)) >= SO_NAME_MAX_PATH_SIZE) 505 error (_("Shared library file name is too long.")); 506 strcpy (so->so_name, bfd_get_filename (abfd)); 507 508 if (build_section_table (abfd, &so->sections, &so->sections_end)) 509 { 510 error (_("Can't find the file sections in `%s': %s"), 511 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ())); 512 } 513 514 for (p = so->sections; p < so->sections_end; p++) 515 { 516 /* Relocate the section binding addresses as recorded in the shared 517 object's file by the base address to which the object was actually 518 mapped. */ 519 ops->relocate_section_addresses (so, p); 520 521 /* If the target didn't provide information about the address 522 range of the shared object, assume we want the location of 523 the .text section. */ 524 if (so->addr_low == 0 && so->addr_high == 0 525 && strcmp (p->the_bfd_section->name, ".text") == 0) 526 { 527 so->addr_low = p->addr; 528 so->addr_high = p->endaddr; 529 } 530 } 531 532 /* Add the shared object's sections to the current set of file 533 section tables. Do this immediately after mapping the object so 534 that later nodes in the list can query this object, as is needed 535 in solib-osf.c. */ 536 add_target_sections (so->sections, so->sections_end); 537 538 return 1; 539 } 540 541 /* Free symbol-file related contents of SO. If we have opened a BFD 542 for SO, close it. If we have placed SO's sections in some target's 543 section table, the caller is responsible for removing them. 544 545 This function doesn't mess with objfiles at all. If there is an 546 objfile associated with SO that needs to be removed, the caller is 547 responsible for taking care of that. */ 548 549 static void 550 free_so_symbols (struct so_list *so) 551 { 552 if (so->sections) 553 { 554 xfree (so->sections); 555 so->sections = so->sections_end = NULL; 556 } 557 558 gdb_bfd_unref (so->abfd); 559 so->abfd = NULL; 560 561 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */ 562 so->symbols_loaded = 0; 563 so->objfile = NULL; 564 565 so->addr_low = so->addr_high = 0; 566 567 /* Restore the target-supplied file name. SO_NAME may be the path 568 of the symbol file. */ 569 strcpy (so->so_name, so->so_original_name); 570 } 571 572 /* LOCAL FUNCTION 573 574 free_so --- free a `struct so_list' object 575 576 SYNOPSIS 577 578 void free_so (struct so_list *so) 579 580 DESCRIPTION 581 582 Free the storage associated with the `struct so_list' object SO. 583 If we have opened a BFD for SO, close it. 584 585 The caller is responsible for removing SO from whatever list it is 586 a member of. If we have placed SO's sections in some target's 587 section table, the caller is responsible for removing them. 588 589 This function doesn't mess with objfiles at all. If there is an 590 objfile associated with SO that needs to be removed, the caller is 591 responsible for taking care of that. */ 592 593 void 594 free_so (struct so_list *so) 595 { 596 struct target_so_ops *ops = solib_ops (target_gdbarch); 597 598 free_so_symbols (so); 599 ops->free_so (so); 600 601 xfree (so); 602 } 603 604 605 /* Return address of first so_list entry in master shared object list. */ 606 struct so_list * 607 master_so_list (void) 608 { 609 return so_list_head; 610 } 611 612 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS, 613 be chatty about it. Return non-zero if any symbols were actually 614 loaded. */ 615 616 int 617 solib_read_symbols (struct so_list *so, int flags) 618 { 619 const int from_tty = flags & SYMFILE_VERBOSE; 620 621 if (so->symbols_loaded) 622 { 623 /* If needed, we've already warned in our caller. */ 624 } 625 else if (so->abfd == NULL) 626 { 627 /* We've already warned about this library, when trying to open 628 it. */ 629 } 630 else 631 { 632 volatile struct gdb_exception e; 633 634 TRY_CATCH (e, RETURN_MASK_ERROR) 635 { 636 struct section_addr_info *sap; 637 638 /* Have we already loaded this shared object? */ 639 ALL_OBJFILES (so->objfile) 640 { 641 if (strcmp (so->objfile->name, so->so_name) == 0) 642 break; 643 } 644 if (so->objfile != NULL) 645 break; 646 647 sap = build_section_addr_info_from_section_table (so->sections, 648 so->sections_end); 649 so->objfile = symbol_file_add_from_bfd (so->abfd, 650 flags, sap, OBJF_SHARED); 651 free_section_addr_info (sap); 652 } 653 654 if (e.reason < 0) 655 { 656 if (from_tty) 657 exception_fprintf 658 (gdb_stderr, e, 659 _("Error while reading shared library symbols:\n")); 660 } 661 else 662 { 663 if (from_tty || info_verbose) 664 printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name); 665 so->symbols_loaded = 1; 666 } 667 return 1; 668 } 669 670 return 0; 671 } 672 673 /* LOCAL FUNCTION 674 675 update_solib_list --- synchronize GDB's shared object list with inferior's 676 677 SYNOPSIS 678 679 void update_solib_list (int from_tty, struct target_ops *TARGET) 680 681 Extract the list of currently loaded shared objects from the 682 inferior, and compare it with the list of shared objects currently 683 in GDB's so_list_head list. Edit so_list_head to bring it in sync 684 with the inferior's new list. 685 686 If we notice that the inferior has unloaded some shared objects, 687 free any symbolic info GDB had read about those shared objects. 688 689 Don't load symbolic info for any new shared objects; just add them 690 to the list, and leave their symbols_loaded flag clear. 691 692 If FROM_TTY is non-null, feel free to print messages about what 693 we're doing. 694 695 If TARGET is non-null, add the sections of all new shared objects 696 to TARGET's section table. Note that this doesn't remove any 697 sections for shared objects that have been unloaded, and it 698 doesn't check to see if the new shared objects are already present in 699 the section table. But we only use this for core files and 700 processes we've just attached to, so that's okay. */ 701 702 static void 703 update_solib_list (int from_tty, struct target_ops *target) 704 { 705 struct target_so_ops *ops = solib_ops (target_gdbarch); 706 struct so_list *inferior = ops->current_sos(); 707 struct so_list *gdb, **gdb_link; 708 709 /* We can reach here due to changing solib-search-path or the 710 sysroot, before having any inferior. */ 711 if (target_has_execution && !ptid_equal (inferior_ptid, null_ptid)) 712 { 713 struct inferior *inf = current_inferior (); 714 715 /* If we are attaching to a running process for which we 716 have not opened a symbol file, we may be able to get its 717 symbols now! */ 718 if (inf->attach_flag && symfile_objfile == NULL) 719 catch_errors (ops->open_symbol_file_object, &from_tty, 720 "Error reading attached process's symbol file.\n", 721 RETURN_MASK_ALL); 722 } 723 724 /* GDB and the inferior's dynamic linker each maintain their own 725 list of currently loaded shared objects; we want to bring the 726 former in sync with the latter. Scan both lists, seeing which 727 shared objects appear where. There are three cases: 728 729 - A shared object appears on both lists. This means that GDB 730 knows about it already, and it's still loaded in the inferior. 731 Nothing needs to happen. 732 733 - A shared object appears only on GDB's list. This means that 734 the inferior has unloaded it. We should remove the shared 735 object from GDB's tables. 736 737 - A shared object appears only on the inferior's list. This 738 means that it's just been loaded. We should add it to GDB's 739 tables. 740 741 So we walk GDB's list, checking each entry to see if it appears 742 in the inferior's list too. If it does, no action is needed, and 743 we remove it from the inferior's list. If it doesn't, the 744 inferior has unloaded it, and we remove it from GDB's list. By 745 the time we're done walking GDB's list, the inferior's list 746 contains only the new shared objects, which we then add. */ 747 748 gdb = so_list_head; 749 gdb_link = &so_list_head; 750 while (gdb) 751 { 752 struct so_list *i = inferior; 753 struct so_list **i_link = &inferior; 754 755 /* Check to see whether the shared object *gdb also appears in 756 the inferior's current list. */ 757 while (i) 758 { 759 if (ops->same) 760 { 761 if (ops->same (gdb, i)) 762 break; 763 } 764 else 765 { 766 if (! strcmp (gdb->so_original_name, i->so_original_name)) 767 break; 768 } 769 770 i_link = &i->next; 771 i = *i_link; 772 } 773 774 /* If the shared object appears on the inferior's list too, then 775 it's still loaded, so we don't need to do anything. Delete 776 it from the inferior's list, and leave it on GDB's list. */ 777 if (i) 778 { 779 *i_link = i->next; 780 free_so (i); 781 gdb_link = &gdb->next; 782 gdb = *gdb_link; 783 } 784 785 /* If it's not on the inferior's list, remove it from GDB's tables. */ 786 else 787 { 788 /* Notify any observer that the shared object has been 789 unloaded before we remove it from GDB's tables. */ 790 observer_notify_solib_unloaded (gdb); 791 792 *gdb_link = gdb->next; 793 794 /* Unless the user loaded it explicitly, free SO's objfile. */ 795 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)) 796 free_objfile (gdb->objfile); 797 798 /* Some targets' section tables might be referring to 799 sections from so->abfd; remove them. */ 800 remove_target_sections (gdb->abfd); 801 802 free_so (gdb); 803 gdb = *gdb_link; 804 } 805 } 806 807 /* Now the inferior's list contains only shared objects that don't 808 appear in GDB's list --- those that are newly loaded. Add them 809 to GDB's shared object list. */ 810 if (inferior) 811 { 812 int not_found = 0; 813 const char *not_found_filename = NULL; 814 815 struct so_list *i; 816 817 /* Add the new shared objects to GDB's list. */ 818 *gdb_link = inferior; 819 820 /* Fill in the rest of each of the `struct so_list' nodes. */ 821 for (i = inferior; i; i = i->next) 822 { 823 volatile struct gdb_exception e; 824 825 i->pspace = current_program_space; 826 827 TRY_CATCH (e, RETURN_MASK_ERROR) 828 { 829 /* Fill in the rest of the `struct so_list' node. */ 830 if (!solib_map_sections (i)) 831 { 832 not_found++; 833 if (not_found_filename == NULL) 834 not_found_filename = i->so_original_name; 835 } 836 } 837 838 if (e.reason < 0) 839 exception_fprintf (gdb_stderr, e, _("\ 840 Error while mapping shared library sections:\n")); 841 842 /* Notify any observer that the shared object has been 843 loaded now that we've added it to GDB's tables. */ 844 observer_notify_solib_loaded (i); 845 } 846 847 /* If a library was not found, issue an appropriate warning 848 message. We have to use a single call to warning in case the 849 front end does something special with warnings, e.g., pop up 850 a dialog box. It Would Be Nice if we could get a "warning: " 851 prefix on each line in the CLI front end, though - it doesn't 852 stand out well. */ 853 854 if (not_found == 1) 855 warning (_("\ 856 Could not load shared library symbols for %s.\n\ 857 Do you need \"set solib-search-path\" or \"set sysroot\"?"), 858 not_found_filename); 859 else if (not_found > 1) 860 warning (_("\ 861 Could not load shared library symbols for %d libraries, e.g. %s.\n\ 862 Use the \"info sharedlibrary\" command to see the complete listing.\n\ 863 Do you need \"set solib-search-path\" or \"set sysroot\"?"), 864 not_found, not_found_filename); 865 } 866 } 867 868 869 /* Return non-zero if NAME is the libpthread shared library. 870 871 Uses a fairly simplistic heuristic approach where we check 872 the file name against "/libpthread". This can lead to false 873 positives, but this should be good enough in practice. */ 874 875 int 876 libpthread_name_p (const char *name) 877 { 878 return (strstr (name, "/libpthread") != NULL); 879 } 880 881 /* Return non-zero if SO is the libpthread shared library. */ 882 883 static int 884 libpthread_solib_p (struct so_list *so) 885 { 886 return libpthread_name_p (so->so_name); 887 } 888 889 /* GLOBAL FUNCTION 890 891 solib_add -- read in symbol info for newly added shared libraries 892 893 SYNOPSIS 894 895 void solib_add (char *pattern, int from_tty, struct target_ops 896 *TARGET, int readsyms) 897 898 DESCRIPTION 899 900 Read in symbolic information for any shared objects whose names 901 match PATTERN. (If we've already read a shared object's symbol 902 info, leave it alone.) If PATTERN is zero, read them all. 903 904 If READSYMS is 0, defer reading symbolic information until later 905 but still do any needed low level processing. 906 907 FROM_TTY and TARGET are as described for update_solib_list, above. */ 908 909 void 910 solib_add (char *pattern, int from_tty, struct target_ops *target, int readsyms) 911 { 912 struct so_list *gdb; 913 914 if (pattern) 915 { 916 char *re_err = re_comp (pattern); 917 918 if (re_err) 919 error (_("Invalid regexp: %s"), re_err); 920 } 921 922 update_solib_list (from_tty, target); 923 924 /* Walk the list of currently loaded shared libraries, and read 925 symbols for any that match the pattern --- or any whose symbols 926 aren't already loaded, if no pattern was given. */ 927 { 928 int any_matches = 0; 929 int loaded_any_symbols = 0; 930 const int flags = 931 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0); 932 933 for (gdb = so_list_head; gdb; gdb = gdb->next) 934 if (! pattern || re_exec (gdb->so_name)) 935 { 936 /* Normally, we would read the symbols from that library 937 only if READSYMS is set. However, we're making a small 938 exception for the pthread library, because we sometimes 939 need the library symbols to be loaded in order to provide 940 thread support (x86-linux for instance). */ 941 const int add_this_solib = 942 (readsyms || libpthread_solib_p (gdb)); 943 944 any_matches = 1; 945 if (add_this_solib) 946 { 947 if (gdb->symbols_loaded) 948 { 949 /* If no pattern was given, be quiet for shared 950 libraries we have already loaded. */ 951 if (pattern && (from_tty || info_verbose)) 952 printf_unfiltered (_("Symbols already loaded for %s\n"), 953 gdb->so_name); 954 } 955 else if (solib_read_symbols (gdb, flags)) 956 loaded_any_symbols = 1; 957 } 958 } 959 960 if (loaded_any_symbols) 961 breakpoint_re_set (); 962 963 if (from_tty && pattern && ! any_matches) 964 printf_unfiltered 965 ("No loaded shared libraries match the pattern `%s'.\n", pattern); 966 967 if (loaded_any_symbols) 968 { 969 struct target_so_ops *ops = solib_ops (target_gdbarch); 970 971 /* Getting new symbols may change our opinion about what is 972 frameless. */ 973 reinit_frame_cache (); 974 975 ops->special_symbol_handling (); 976 } 977 } 978 } 979 980 981 /* 982 983 LOCAL FUNCTION 984 985 info_sharedlibrary_command -- code for "info sharedlibrary" 986 987 SYNOPSIS 988 989 static void info_sharedlibrary_command () 990 991 DESCRIPTION 992 993 Walk through the shared library list and print information 994 about each attached library matching PATTERN. If PATTERN is elided, 995 print them all. 996 */ 997 998 static void 999 info_sharedlibrary_command (char *pattern, int from_tty) 1000 { 1001 struct so_list *so = NULL; /* link map state variable */ 1002 int so_missing_debug_info = 0; 1003 int addr_width; 1004 int nr_libs; 1005 struct cleanup *table_cleanup; 1006 struct gdbarch *gdbarch = target_gdbarch; 1007 1008 if (pattern) 1009 { 1010 char *re_err = re_comp (pattern); 1011 1012 if (re_err) 1013 error (_("Invalid regexp: %s"), re_err); 1014 } 1015 1016 /* "0x", a little whitespace, and two hex digits per byte of pointers. */ 1017 addr_width = 4 + (gdbarch_ptr_bit (gdbarch) / 4); 1018 1019 update_solib_list (from_tty, 0); 1020 1021 /* make_cleanup_ui_out_table_begin_end needs to know the number of 1022 rows, so we need to make two passes over the libs. */ 1023 1024 for (nr_libs = 0, so = so_list_head; so; so = so->next) 1025 { 1026 if (so->so_name[0]) 1027 { 1028 if (pattern && ! re_exec (so->so_name)) 1029 continue; 1030 ++nr_libs; 1031 } 1032 } 1033 1034 table_cleanup = 1035 make_cleanup_ui_out_table_begin_end (uiout, 4, nr_libs, 1036 "SharedLibraryTable"); 1037 1038 /* The "- 1" is because ui_out adds one space between columns. */ 1039 ui_out_table_header (uiout, addr_width - 1, ui_left, "from", "From"); 1040 ui_out_table_header (uiout, addr_width - 1, ui_left, "to", "To"); 1041 ui_out_table_header (uiout, 12 - 1, ui_left, "syms-read", "Syms Read"); 1042 ui_out_table_header (uiout, 0, ui_noalign, 1043 "name", "Shared Object Library"); 1044 1045 ui_out_table_body (uiout); 1046 1047 for (so = so_list_head; so; so = so->next) 1048 { 1049 struct cleanup *lib_cleanup; 1050 1051 if (! so->so_name[0]) 1052 continue; 1053 if (pattern && ! re_exec (so->so_name)) 1054 continue; 1055 1056 lib_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "lib"); 1057 1058 if (so->addr_high != 0) 1059 { 1060 ui_out_field_core_addr (uiout, "from", gdbarch, so->addr_low); 1061 ui_out_field_core_addr (uiout, "to", gdbarch, so->addr_high); 1062 } 1063 else 1064 { 1065 ui_out_field_skip (uiout, "from"); 1066 ui_out_field_skip (uiout, "to"); 1067 } 1068 1069 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())) 1070 && so->symbols_loaded 1071 && !objfile_has_symbols (so->objfile)) 1072 { 1073 so_missing_debug_info = 1; 1074 ui_out_field_string (uiout, "syms-read", "Yes (*)"); 1075 } 1076 else 1077 ui_out_field_string (uiout, "syms-read", 1078 so->symbols_loaded ? "Yes" : "No"); 1079 1080 ui_out_field_string (uiout, "name", so->so_name); 1081 1082 ui_out_text (uiout, "\n"); 1083 1084 do_cleanups (lib_cleanup); 1085 } 1086 1087 do_cleanups (table_cleanup); 1088 1089 if (nr_libs == 0) 1090 { 1091 if (pattern) 1092 ui_out_message (uiout, 0, 1093 _("No shared libraries matched.\n")); 1094 else 1095 ui_out_message (uiout, 0, 1096 _("No shared libraries loaded at this time.\n")); 1097 } 1098 else 1099 { 1100 if (so_missing_debug_info) 1101 ui_out_message (uiout, 0, 1102 _("(*): Shared library is missing debugging information.\n")); 1103 } 1104 } 1105 1106 /* Return 1 if ADDRESS lies within SOLIB. */ 1107 1108 int 1109 solib_contains_address_p (const struct so_list *const solib, 1110 CORE_ADDR address) 1111 { 1112 struct target_section *p; 1113 1114 for (p = solib->sections; p < solib->sections_end; p++) 1115 if (p->addr <= address && address < p->endaddr) 1116 return 1; 1117 1118 return 0; 1119 } 1120 1121 /* 1122 1123 GLOBAL FUNCTION 1124 1125 solib_name_from_address -- if an address is in a shared lib, return 1126 its name. 1127 1128 SYNOPSIS 1129 1130 char * solib_name_from_address (CORE_ADDR address) 1131 1132 DESCRIPTION 1133 1134 Provides a hook for other gdb routines to discover whether or 1135 not a particular address is within the mapped address space of 1136 a shared library. 1137 1138 For example, this routine is called at one point to disable 1139 breakpoints which are in shared libraries that are not currently 1140 mapped in. 1141 */ 1142 1143 char * 1144 solib_name_from_address (struct program_space *pspace, CORE_ADDR address) 1145 { 1146 struct so_list *so = NULL; 1147 1148 for (so = pspace->so_list; so; so = so->next) 1149 if (solib_contains_address_p (so, address)) 1150 return (so->so_name); 1151 1152 return (0); 1153 } 1154 1155 /* Return whether the data starting at VADDR, size SIZE, must be kept 1156 in a core file for shared libraries loaded before "gcore" is used 1157 to be handled correctly when the core file is loaded. This only 1158 applies when the section would otherwise not be kept in the core 1159 file (in particular, for readonly sections). */ 1160 1161 int 1162 solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size) 1163 { 1164 struct target_so_ops *ops = solib_ops (target_gdbarch); 1165 1166 if (ops->keep_data_in_core) 1167 return ops->keep_data_in_core (vaddr, size); 1168 else 1169 return 0; 1170 } 1171 1172 /* Called by free_all_symtabs */ 1173 1174 void 1175 clear_solib (void) 1176 { 1177 struct target_so_ops *ops = solib_ops (target_gdbarch); 1178 1179 /* This function is expected to handle ELF shared libraries. It is 1180 also used on Solaris, which can run either ELF or a.out binaries 1181 (for compatibility with SunOS 4), both of which can use shared 1182 libraries. So we don't know whether we have an ELF executable or 1183 an a.out executable until the user chooses an executable file. 1184 1185 ELF shared libraries don't get mapped into the address space 1186 until after the program starts, so we'd better not try to insert 1187 breakpoints in them immediately. We have to wait until the 1188 dynamic linker has loaded them; we'll hit a bp_shlib_event 1189 breakpoint (look for calls to create_solib_event_breakpoint) when 1190 it's ready. 1191 1192 SunOS shared libraries seem to be different --- they're present 1193 as soon as the process begins execution, so there's no need to 1194 put off inserting breakpoints. There's also nowhere to put a 1195 bp_shlib_event breakpoint, so if we put it off, we'll never get 1196 around to it. 1197 1198 So: disable breakpoints only if we're using ELF shared libs. */ 1199 if (exec_bfd != NULL 1200 && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour) 1201 disable_breakpoints_in_shlibs (); 1202 1203 while (so_list_head) 1204 { 1205 struct so_list *so = so_list_head; 1206 1207 so_list_head = so->next; 1208 observer_notify_solib_unloaded (so); 1209 if (so->abfd) 1210 remove_target_sections (so->abfd); 1211 free_so (so); 1212 } 1213 1214 ops->clear_solib (); 1215 } 1216 1217 /* GLOBAL FUNCTION 1218 1219 solib_create_inferior_hook -- shared library startup support 1220 1221 SYNOPSIS 1222 1223 void solib_create_inferior_hook (int from_tty) 1224 1225 DESCRIPTION 1226 1227 When gdb starts up the inferior, it nurses it along (through the 1228 shell) until it is ready to execute it's first instruction. At this 1229 point, this function gets called via expansion of the macro 1230 SOLIB_CREATE_INFERIOR_HOOK. */ 1231 1232 void 1233 solib_create_inferior_hook (int from_tty) 1234 { 1235 struct target_so_ops *ops = solib_ops (target_gdbarch); 1236 1237 ops->solib_create_inferior_hook (from_tty); 1238 } 1239 1240 /* GLOBAL FUNCTION 1241 1242 in_solib_dynsym_resolve_code -- check to see if an address is in 1243 dynamic loader's dynamic symbol 1244 resolution code 1245 1246 SYNOPSIS 1247 1248 int in_solib_dynsym_resolve_code (CORE_ADDR pc) 1249 1250 DESCRIPTION 1251 1252 Determine if PC is in the dynamic linker's symbol resolution 1253 code. Return 1 if so, 0 otherwise. 1254 */ 1255 1256 int 1257 in_solib_dynsym_resolve_code (CORE_ADDR pc) 1258 { 1259 struct target_so_ops *ops = solib_ops (target_gdbarch); 1260 1261 return ops->in_dynsym_resolve_code (pc); 1262 } 1263 1264 /* 1265 1266 LOCAL FUNCTION 1267 1268 sharedlibrary_command -- handle command to explicitly add library 1269 1270 SYNOPSIS 1271 1272 static void sharedlibrary_command (char *args, int from_tty) 1273 1274 DESCRIPTION 1275 1276 */ 1277 1278 static void 1279 sharedlibrary_command (char *args, int from_tty) 1280 { 1281 dont_repeat (); 1282 solib_add (args, from_tty, (struct target_ops *) 0, 1); 1283 } 1284 1285 /* LOCAL FUNCTION 1286 1287 no_shared_libraries -- handle command to explicitly discard symbols 1288 from shared libraries. 1289 1290 DESCRIPTION 1291 1292 Implements the command "nosharedlibrary", which discards symbols 1293 that have been auto-loaded from shared libraries. Symbols from 1294 shared libraries that were added by explicit request of the user 1295 are not discarded. Also called from remote.c. */ 1296 1297 void 1298 no_shared_libraries (char *ignored, int from_tty) 1299 { 1300 /* The order of the two routines below is important: clear_solib notifies 1301 the solib_unloaded observers, and some of these observers might need 1302 access to their associated objfiles. Therefore, we can not purge the 1303 solibs' objfiles before clear_solib has been called. */ 1304 1305 clear_solib (); 1306 objfile_purge_solibs (); 1307 } 1308 1309 /* Reload shared libraries, but avoid reloading the same symbol file 1310 we already have loaded. */ 1311 1312 static void 1313 reload_shared_libraries_1 (int from_tty) 1314 { 1315 struct so_list *so; 1316 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); 1317 1318 for (so = so_list_head; so != NULL; so = so->next) 1319 { 1320 char *filename, *found_pathname = NULL; 1321 bfd *abfd; 1322 int was_loaded = so->symbols_loaded; 1323 const int flags = 1324 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0); 1325 1326 filename = tilde_expand (so->so_original_name); 1327 abfd = solib_bfd_open (filename); 1328 if (abfd != NULL) 1329 { 1330 found_pathname = xstrdup (bfd_get_filename (abfd)); 1331 make_cleanup (xfree, found_pathname); 1332 gdb_bfd_close_or_warn (abfd); 1333 } 1334 1335 /* If this shared library is no longer associated with its previous 1336 symbol file, close that. */ 1337 if ((found_pathname == NULL && was_loaded) 1338 || (found_pathname != NULL 1339 && strcmp (found_pathname, so->so_name) != 0)) 1340 { 1341 if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED)) 1342 free_objfile (so->objfile); 1343 remove_target_sections (so->abfd); 1344 free_so_symbols (so); 1345 } 1346 1347 /* If this shared library is now associated with a new symbol 1348 file, open it. */ 1349 if (found_pathname != NULL 1350 && (!was_loaded 1351 || strcmp (found_pathname, so->so_name) != 0)) 1352 { 1353 volatile struct gdb_exception e; 1354 1355 TRY_CATCH (e, RETURN_MASK_ERROR) 1356 solib_map_sections (so); 1357 1358 if (e.reason < 0) 1359 exception_fprintf (gdb_stderr, e, _("\ 1360 Error while mapping shared library sections:\n")); 1361 else if (auto_solib_add || was_loaded || libpthread_solib_p (so)) 1362 solib_read_symbols (so, flags); 1363 } 1364 } 1365 1366 do_cleanups (old_chain); 1367 } 1368 1369 static void 1370 reload_shared_libraries (char *ignored, int from_tty, 1371 struct cmd_list_element *e) 1372 { 1373 struct target_so_ops *ops; 1374 1375 reload_shared_libraries_1 (from_tty); 1376 1377 ops = solib_ops (target_gdbarch); 1378 1379 /* Creating inferior hooks here has two purposes. First, if we reload 1380 shared libraries then the address of solib breakpoint we've computed 1381 previously might be no longer valid. For example, if we forgot to set 1382 solib-absolute-prefix and are setting it right now, then the previous 1383 breakpoint address is plain wrong. Second, installing solib hooks 1384 also implicitly figures were ld.so is and loads symbols for it. 1385 Absent this call, if we've just connected to a target and set 1386 solib-absolute-prefix or solib-search-path, we'll lose all information 1387 about ld.so. */ 1388 if (target_has_execution) 1389 { 1390 /* Reset or free private data structures not associated with 1391 so_list entries. */ 1392 ops->clear_solib (); 1393 1394 /* Remove any previous solib event breakpoint. This is usually 1395 done in common code, at breakpoint_init_inferior time, but 1396 we're not really starting up the inferior here. */ 1397 remove_solib_event_breakpoints (); 1398 1399 #ifdef SOLIB_CREATE_INFERIOR_HOOK 1400 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid)); 1401 #else 1402 solib_create_inferior_hook (from_tty); 1403 #endif 1404 } 1405 1406 /* Sometimes the platform-specific hook loads initial shared 1407 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be 1408 incorrectly 0 but such solib targets should be fixed anyway. If we 1409 made all the inferior hook methods consistent, this call could be 1410 removed. Call it only after the solib target has been initialized by 1411 solib_create_inferior_hook. */ 1412 1413 solib_add (NULL, 0, NULL, auto_solib_add); 1414 1415 breakpoint_re_set (); 1416 1417 /* We may have loaded or unloaded debug info for some (or all) 1418 shared libraries. However, frames may still reference them. For 1419 example, a frame's unwinder might still point at DWARF FDE 1420 structures that are now freed. Also, getting new symbols may 1421 change our opinion about what is frameless. */ 1422 reinit_frame_cache (); 1423 1424 ops->special_symbol_handling (); 1425 } 1426 1427 static void 1428 show_auto_solib_add (struct ui_file *file, int from_tty, 1429 struct cmd_list_element *c, const char *value) 1430 { 1431 fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"), 1432 value); 1433 } 1434 1435 1436 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call 1437 the library-specific handler if it is installed for the current target. */ 1438 1439 struct symbol * 1440 solib_global_lookup (const struct objfile *objfile, 1441 const char *name, 1442 const domain_enum domain) 1443 { 1444 struct target_so_ops *ops = solib_ops (target_gdbarch); 1445 1446 if (ops->lookup_lib_global_symbol != NULL) 1447 return ops->lookup_lib_global_symbol (objfile, name, domain); 1448 return NULL; 1449 } 1450 1451 1452 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */ 1453 1454 void 1455 _initialize_solib (void) 1456 { 1457 solib_data = gdbarch_data_register_pre_init (solib_init); 1458 1459 add_com ("sharedlibrary", class_files, sharedlibrary_command, 1460 _("Load shared object library symbols for files matching REGEXP.")); 1461 add_info ("sharedlibrary", info_sharedlibrary_command, 1462 _("Status of loaded shared object libraries.")); 1463 add_com ("nosharedlibrary", class_files, no_shared_libraries, 1464 _("Unload all shared object library symbols.")); 1465 1466 add_setshow_boolean_cmd ("auto-solib-add", class_support, 1467 &auto_solib_add, _("\ 1468 Set autoloading of shared library symbols."), _("\ 1469 Show autoloading of shared library symbols."), _("\ 1470 If \"on\", symbols from all shared object libraries will be loaded\n\ 1471 automatically when the inferior begins execution, when the dynamic linker\n\ 1472 informs gdb that a new library has been loaded, or when attaching to the\n\ 1473 inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'."), 1474 NULL, 1475 show_auto_solib_add, 1476 &setlist, &showlist); 1477 1478 add_setshow_filename_cmd ("sysroot", class_support, 1479 &gdb_sysroot, _("\ 1480 Set an alternate system root."), _("\ 1481 Show the current system root."), _("\ 1482 The system root is used to load absolute shared library symbol files.\n\ 1483 For other (relative) files, you can add directories using\n\ 1484 `set solib-search-path'."), 1485 reload_shared_libraries, 1486 NULL, 1487 &setlist, &showlist); 1488 1489 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0, 1490 &setlist); 1491 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0, 1492 &showlist); 1493 1494 add_setshow_optional_filename_cmd ("solib-search-path", class_support, 1495 &solib_search_path, _("\ 1496 Set the search path for loading non-absolute shared library symbol files."), _("\ 1497 Show the search path for loading non-absolute shared library symbol files."), _("\ 1498 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH."), 1499 reload_shared_libraries, 1500 show_solib_search_path, 1501 &setlist, &showlist); 1502 } 1503