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, 2011 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, _("The search path for loading non-absolute " 106 "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 (filename_cmp (so->objfile->name, so->so_name) == 0 642 && so->objfile->addr_low == so->addr_low) 643 break; 644 } 645 if (so->objfile != NULL) 646 break; 647 648 sap = build_section_addr_info_from_section_table (so->sections, 649 so->sections_end); 650 so->objfile = symbol_file_add_from_bfd (so->abfd, 651 flags, sap, OBJF_SHARED); 652 so->objfile->addr_low = so->addr_low; 653 free_section_addr_info (sap); 654 } 655 656 if (e.reason < 0) 657 exception_fprintf (gdb_stderr, e, _("Error while reading shared" 658 " library symbols for %s:\n"), 659 so->so_name); 660 else 661 { 662 if (from_tty || info_verbose) 663 printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name); 664 so->symbols_loaded = 1; 665 } 666 return 1; 667 } 668 669 return 0; 670 } 671 672 /* LOCAL FUNCTION 673 674 update_solib_list --- synchronize GDB's shared object list with inferior's 675 676 SYNOPSIS 677 678 void update_solib_list (int from_tty, struct target_ops *TARGET) 679 680 Extract the list of currently loaded shared objects from the 681 inferior, and compare it with the list of shared objects currently 682 in GDB's so_list_head list. Edit so_list_head to bring it in sync 683 with the inferior's new list. 684 685 If we notice that the inferior has unloaded some shared objects, 686 free any symbolic info GDB had read about those shared objects. 687 688 Don't load symbolic info for any new shared objects; just add them 689 to the list, and leave their symbols_loaded flag clear. 690 691 If FROM_TTY is non-null, feel free to print messages about what 692 we're doing. 693 694 If TARGET is non-null, add the sections of all new shared objects 695 to TARGET's section table. Note that this doesn't remove any 696 sections for shared objects that have been unloaded, and it 697 doesn't check to see if the new shared objects are already present in 698 the section table. But we only use this for core files and 699 processes we've just attached to, so that's okay. */ 700 701 static void 702 update_solib_list (int from_tty, struct target_ops *target) 703 { 704 struct target_so_ops *ops = solib_ops (target_gdbarch); 705 struct so_list *inferior = ops->current_sos(); 706 struct so_list *gdb, **gdb_link; 707 708 /* We can reach here due to changing solib-search-path or the 709 sysroot, before having any inferior. */ 710 if (target_has_execution && !ptid_equal (inferior_ptid, null_ptid)) 711 { 712 struct inferior *inf = current_inferior (); 713 714 /* If we are attaching to a running process for which we 715 have not opened a symbol file, we may be able to get its 716 symbols now! */ 717 if (inf->attach_flag && symfile_objfile == NULL) 718 catch_errors (ops->open_symbol_file_object, &from_tty, 719 "Error reading attached process's symbol file.\n", 720 RETURN_MASK_ALL); 721 } 722 723 /* GDB and the inferior's dynamic linker each maintain their own 724 list of currently loaded shared objects; we want to bring the 725 former in sync with the latter. Scan both lists, seeing which 726 shared objects appear where. There are three cases: 727 728 - A shared object appears on both lists. This means that GDB 729 knows about it already, and it's still loaded in the inferior. 730 Nothing needs to happen. 731 732 - A shared object appears only on GDB's list. This means that 733 the inferior has unloaded it. We should remove the shared 734 object from GDB's tables. 735 736 - A shared object appears only on the inferior's list. This 737 means that it's just been loaded. We should add it to GDB's 738 tables. 739 740 So we walk GDB's list, checking each entry to see if it appears 741 in the inferior's list too. If it does, no action is needed, and 742 we remove it from the inferior's list. If it doesn't, the 743 inferior has unloaded it, and we remove it from GDB's list. By 744 the time we're done walking GDB's list, the inferior's list 745 contains only the new shared objects, which we then add. */ 746 747 gdb = so_list_head; 748 gdb_link = &so_list_head; 749 while (gdb) 750 { 751 struct so_list *i = inferior; 752 struct so_list **i_link = &inferior; 753 754 /* Check to see whether the shared object *gdb also appears in 755 the inferior's current list. */ 756 while (i) 757 { 758 if (ops->same) 759 { 760 if (ops->same (gdb, i)) 761 break; 762 } 763 else 764 { 765 if (! filename_cmp (gdb->so_original_name, i->so_original_name)) 766 break; 767 } 768 769 i_link = &i->next; 770 i = *i_link; 771 } 772 773 /* If the shared object appears on the inferior's list too, then 774 it's still loaded, so we don't need to do anything. Delete 775 it from the inferior's list, and leave it on GDB's list. */ 776 if (i) 777 { 778 *i_link = i->next; 779 free_so (i); 780 gdb_link = &gdb->next; 781 gdb = *gdb_link; 782 } 783 784 /* If it's not on the inferior's list, remove it from GDB's tables. */ 785 else 786 { 787 /* Notify any observer that the shared object has been 788 unloaded before we remove it from GDB's tables. */ 789 observer_notify_solib_unloaded (gdb); 790 791 *gdb_link = gdb->next; 792 793 /* Unless the user loaded it explicitly, free SO's objfile. */ 794 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)) 795 free_objfile (gdb->objfile); 796 797 /* Some targets' section tables might be referring to 798 sections from so->abfd; remove them. */ 799 remove_target_sections (gdb->abfd); 800 801 free_so (gdb); 802 gdb = *gdb_link; 803 } 804 } 805 806 /* Now the inferior's list contains only shared objects that don't 807 appear in GDB's list --- those that are newly loaded. Add them 808 to GDB's shared object list. */ 809 if (inferior) 810 { 811 int not_found = 0; 812 const char *not_found_filename = NULL; 813 814 struct so_list *i; 815 816 /* Add the new shared objects to GDB's list. */ 817 *gdb_link = inferior; 818 819 /* Fill in the rest of each of the `struct so_list' nodes. */ 820 for (i = inferior; i; i = i->next) 821 { 822 volatile struct gdb_exception e; 823 824 i->pspace = current_program_space; 825 826 TRY_CATCH (e, RETURN_MASK_ERROR) 827 { 828 /* Fill in the rest of the `struct so_list' node. */ 829 if (!solib_map_sections (i)) 830 { 831 not_found++; 832 if (not_found_filename == NULL) 833 not_found_filename = i->so_original_name; 834 } 835 } 836 837 if (e.reason < 0) 838 exception_fprintf (gdb_stderr, e, 839 _("Error while mapping shared " 840 "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 (_("Could not load shared library symbols for %s.\n" 856 "Do you need \"set solib-search-path\" " 857 "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, 911 struct target_ops *target, int readsyms) 912 { 913 struct so_list *gdb; 914 915 if (pattern) 916 { 917 char *re_err = re_comp (pattern); 918 919 if (re_err) 920 error (_("Invalid regexp: %s"), re_err); 921 } 922 923 update_solib_list (from_tty, target); 924 925 /* Walk the list of currently loaded shared libraries, and read 926 symbols for any that match the pattern --- or any whose symbols 927 aren't already loaded, if no pattern was given. */ 928 { 929 int any_matches = 0; 930 int loaded_any_symbols = 0; 931 const int flags = 932 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0); 933 934 for (gdb = so_list_head; gdb; gdb = gdb->next) 935 if (! pattern || re_exec (gdb->so_name)) 936 { 937 /* Normally, we would read the symbols from that library 938 only if READSYMS is set. However, we're making a small 939 exception for the pthread library, because we sometimes 940 need the library symbols to be loaded in order to provide 941 thread support (x86-linux for instance). */ 942 const int add_this_solib = 943 (readsyms || libpthread_solib_p (gdb)); 944 945 any_matches = 1; 946 if (add_this_solib) 947 { 948 if (gdb->symbols_loaded) 949 { 950 /* If no pattern was given, be quiet for shared 951 libraries we have already loaded. */ 952 if (pattern && (from_tty || info_verbose)) 953 printf_unfiltered (_("Symbols already loaded for %s\n"), 954 gdb->so_name); 955 } 956 else if (solib_read_symbols (gdb, flags)) 957 loaded_any_symbols = 1; 958 } 959 } 960 961 if (loaded_any_symbols) 962 breakpoint_re_set (); 963 964 if (from_tty && pattern && ! any_matches) 965 printf_unfiltered 966 ("No loaded shared libraries match the pattern `%s'.\n", pattern); 967 968 if (loaded_any_symbols) 969 { 970 struct target_so_ops *ops = solib_ops (target_gdbarch); 971 972 /* Getting new symbols may change our opinion about what is 973 frameless. */ 974 reinit_frame_cache (); 975 976 ops->special_symbol_handling (); 977 } 978 } 979 } 980 981 982 /* 983 984 LOCAL FUNCTION 985 986 info_sharedlibrary_command -- code for "info sharedlibrary" 987 988 SYNOPSIS 989 990 static void info_sharedlibrary_command () 991 992 DESCRIPTION 993 994 Walk through the shared library list and print information 995 about each attached library matching PATTERN. If PATTERN is elided, 996 print them all. 997 */ 998 999 static void 1000 info_sharedlibrary_command (char *pattern, int from_tty) 1001 { 1002 struct so_list *so = NULL; /* link map state variable */ 1003 int so_missing_debug_info = 0; 1004 int addr_width; 1005 int nr_libs; 1006 struct cleanup *table_cleanup; 1007 struct gdbarch *gdbarch = target_gdbarch; 1008 1009 if (pattern) 1010 { 1011 char *re_err = re_comp (pattern); 1012 1013 if (re_err) 1014 error (_("Invalid regexp: %s"), re_err); 1015 } 1016 1017 /* "0x", a little whitespace, and two hex digits per byte of pointers. */ 1018 addr_width = 4 + (gdbarch_ptr_bit (gdbarch) / 4); 1019 1020 update_solib_list (from_tty, 0); 1021 1022 /* make_cleanup_ui_out_table_begin_end needs to know the number of 1023 rows, so we need to make two passes over the libs. */ 1024 1025 for (nr_libs = 0, so = so_list_head; so; so = so->next) 1026 { 1027 if (so->so_name[0]) 1028 { 1029 if (pattern && ! re_exec (so->so_name)) 1030 continue; 1031 ++nr_libs; 1032 } 1033 } 1034 1035 table_cleanup = 1036 make_cleanup_ui_out_table_begin_end (uiout, 4, nr_libs, 1037 "SharedLibraryTable"); 1038 1039 /* The "- 1" is because ui_out adds one space between columns. */ 1040 ui_out_table_header (uiout, addr_width - 1, ui_left, "from", "From"); 1041 ui_out_table_header (uiout, addr_width - 1, ui_left, "to", "To"); 1042 ui_out_table_header (uiout, 12 - 1, ui_left, "syms-read", "Syms Read"); 1043 ui_out_table_header (uiout, 0, ui_noalign, 1044 "name", "Shared Object Library"); 1045 1046 ui_out_table_body (uiout); 1047 1048 for (so = so_list_head; so; so = so->next) 1049 { 1050 struct cleanup *lib_cleanup; 1051 1052 if (! so->so_name[0]) 1053 continue; 1054 if (pattern && ! re_exec (so->so_name)) 1055 continue; 1056 1057 lib_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "lib"); 1058 1059 if (so->addr_high != 0) 1060 { 1061 ui_out_field_core_addr (uiout, "from", gdbarch, so->addr_low); 1062 ui_out_field_core_addr (uiout, "to", gdbarch, so->addr_high); 1063 } 1064 else 1065 { 1066 ui_out_field_skip (uiout, "from"); 1067 ui_out_field_skip (uiout, "to"); 1068 } 1069 1070 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())) 1071 && so->symbols_loaded 1072 && !objfile_has_symbols (so->objfile)) 1073 { 1074 so_missing_debug_info = 1; 1075 ui_out_field_string (uiout, "syms-read", "Yes (*)"); 1076 } 1077 else 1078 ui_out_field_string (uiout, "syms-read", 1079 so->symbols_loaded ? "Yes" : "No"); 1080 1081 ui_out_field_string (uiout, "name", so->so_name); 1082 1083 ui_out_text (uiout, "\n"); 1084 1085 do_cleanups (lib_cleanup); 1086 } 1087 1088 do_cleanups (table_cleanup); 1089 1090 if (nr_libs == 0) 1091 { 1092 if (pattern) 1093 ui_out_message (uiout, 0, 1094 _("No shared libraries matched.\n")); 1095 else 1096 ui_out_message (uiout, 0, 1097 _("No shared libraries loaded at this time.\n")); 1098 } 1099 else 1100 { 1101 if (so_missing_debug_info) 1102 ui_out_message (uiout, 0, 1103 _("(*): Shared library is missing " 1104 "debugging information.\n")); 1105 } 1106 } 1107 1108 /* Return 1 if ADDRESS lies within SOLIB. */ 1109 1110 int 1111 solib_contains_address_p (const struct so_list *const solib, 1112 CORE_ADDR address) 1113 { 1114 struct target_section *p; 1115 1116 for (p = solib->sections; p < solib->sections_end; p++) 1117 if (p->addr <= address && address < p->endaddr) 1118 return 1; 1119 1120 return 0; 1121 } 1122 1123 /* 1124 1125 GLOBAL FUNCTION 1126 1127 solib_name_from_address -- if an address is in a shared lib, return 1128 its name. 1129 1130 SYNOPSIS 1131 1132 char * solib_name_from_address (CORE_ADDR address) 1133 1134 DESCRIPTION 1135 1136 Provides a hook for other gdb routines to discover whether or 1137 not a particular address is within the mapped address space of 1138 a shared library. 1139 1140 For example, this routine is called at one point to disable 1141 breakpoints which are in shared libraries that are not currently 1142 mapped in. 1143 */ 1144 1145 char * 1146 solib_name_from_address (struct program_space *pspace, CORE_ADDR address) 1147 { 1148 struct so_list *so = NULL; 1149 1150 for (so = pspace->so_list; so; so = so->next) 1151 if (solib_contains_address_p (so, address)) 1152 return (so->so_name); 1153 1154 return (0); 1155 } 1156 1157 /* Return whether the data starting at VADDR, size SIZE, must be kept 1158 in a core file for shared libraries loaded before "gcore" is used 1159 to be handled correctly when the core file is loaded. This only 1160 applies when the section would otherwise not be kept in the core 1161 file (in particular, for readonly sections). */ 1162 1163 int 1164 solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size) 1165 { 1166 struct target_so_ops *ops = solib_ops (target_gdbarch); 1167 1168 if (ops->keep_data_in_core) 1169 return ops->keep_data_in_core (vaddr, size); 1170 else 1171 return 0; 1172 } 1173 1174 /* Called by free_all_symtabs */ 1175 1176 void 1177 clear_solib (void) 1178 { 1179 struct target_so_ops *ops = solib_ops (target_gdbarch); 1180 1181 /* This function is expected to handle ELF shared libraries. It is 1182 also used on Solaris, which can run either ELF or a.out binaries 1183 (for compatibility with SunOS 4), both of which can use shared 1184 libraries. So we don't know whether we have an ELF executable or 1185 an a.out executable until the user chooses an executable file. 1186 1187 ELF shared libraries don't get mapped into the address space 1188 until after the program starts, so we'd better not try to insert 1189 breakpoints in them immediately. We have to wait until the 1190 dynamic linker has loaded them; we'll hit a bp_shlib_event 1191 breakpoint (look for calls to create_solib_event_breakpoint) when 1192 it's ready. 1193 1194 SunOS shared libraries seem to be different --- they're present 1195 as soon as the process begins execution, so there's no need to 1196 put off inserting breakpoints. There's also nowhere to put a 1197 bp_shlib_event breakpoint, so if we put it off, we'll never get 1198 around to it. 1199 1200 So: disable breakpoints only if we're using ELF shared libs. */ 1201 if (exec_bfd != NULL 1202 && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour) 1203 disable_breakpoints_in_shlibs (); 1204 1205 while (so_list_head) 1206 { 1207 struct so_list *so = so_list_head; 1208 1209 so_list_head = so->next; 1210 observer_notify_solib_unloaded (so); 1211 if (so->abfd) 1212 remove_target_sections (so->abfd); 1213 free_so (so); 1214 } 1215 1216 ops->clear_solib (); 1217 } 1218 1219 /* GLOBAL FUNCTION 1220 1221 solib_create_inferior_hook -- shared library startup support 1222 1223 SYNOPSIS 1224 1225 void solib_create_inferior_hook (int from_tty) 1226 1227 DESCRIPTION 1228 1229 When gdb starts up the inferior, it nurses it along (through the 1230 shell) until it is ready to execute it's first instruction. At this 1231 point, this function gets called via expansion of the macro 1232 SOLIB_CREATE_INFERIOR_HOOK. */ 1233 1234 void 1235 solib_create_inferior_hook (int from_tty) 1236 { 1237 struct target_so_ops *ops = solib_ops (target_gdbarch); 1238 1239 ops->solib_create_inferior_hook (from_tty); 1240 } 1241 1242 /* GLOBAL FUNCTION 1243 1244 in_solib_dynsym_resolve_code -- check to see if an address is in 1245 dynamic loader's dynamic symbol 1246 resolution code 1247 1248 SYNOPSIS 1249 1250 int in_solib_dynsym_resolve_code (CORE_ADDR pc) 1251 1252 DESCRIPTION 1253 1254 Determine if PC is in the dynamic linker's symbol resolution 1255 code. Return 1 if so, 0 otherwise. 1256 */ 1257 1258 int 1259 in_solib_dynsym_resolve_code (CORE_ADDR pc) 1260 { 1261 struct target_so_ops *ops = solib_ops (target_gdbarch); 1262 1263 return ops->in_dynsym_resolve_code (pc); 1264 } 1265 1266 /* 1267 1268 LOCAL FUNCTION 1269 1270 sharedlibrary_command -- handle command to explicitly add library 1271 1272 SYNOPSIS 1273 1274 static void sharedlibrary_command (char *args, int from_tty) 1275 1276 DESCRIPTION 1277 1278 */ 1279 1280 static void 1281 sharedlibrary_command (char *args, int from_tty) 1282 { 1283 dont_repeat (); 1284 solib_add (args, from_tty, (struct target_ops *) 0, 1); 1285 } 1286 1287 /* LOCAL FUNCTION 1288 1289 no_shared_libraries -- handle command to explicitly discard symbols 1290 from shared libraries. 1291 1292 DESCRIPTION 1293 1294 Implements the command "nosharedlibrary", which discards symbols 1295 that have been auto-loaded from shared libraries. Symbols from 1296 shared libraries that were added by explicit request of the user 1297 are not discarded. Also called from remote.c. */ 1298 1299 void 1300 no_shared_libraries (char *ignored, int from_tty) 1301 { 1302 /* The order of the two routines below is important: clear_solib notifies 1303 the solib_unloaded observers, and some of these observers might need 1304 access to their associated objfiles. Therefore, we can not purge the 1305 solibs' objfiles before clear_solib has been called. */ 1306 1307 clear_solib (); 1308 objfile_purge_solibs (); 1309 } 1310 1311 /* Reload shared libraries, but avoid reloading the same symbol file 1312 we already have loaded. */ 1313 1314 static void 1315 reload_shared_libraries_1 (int from_tty) 1316 { 1317 struct so_list *so; 1318 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); 1319 1320 for (so = so_list_head; so != NULL; so = so->next) 1321 { 1322 char *filename, *found_pathname = NULL; 1323 bfd *abfd; 1324 int was_loaded = so->symbols_loaded; 1325 const int flags = 1326 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0); 1327 1328 filename = tilde_expand (so->so_original_name); 1329 make_cleanup (xfree, filename); 1330 abfd = solib_bfd_open (filename); 1331 if (abfd != NULL) 1332 { 1333 found_pathname = xstrdup (bfd_get_filename (abfd)); 1334 make_cleanup (xfree, found_pathname); 1335 gdb_bfd_close_or_warn (abfd); 1336 } 1337 1338 /* If this shared library is no longer associated with its previous 1339 symbol file, close that. */ 1340 if ((found_pathname == NULL && was_loaded) 1341 || (found_pathname != NULL 1342 && filename_cmp (found_pathname, so->so_name) != 0)) 1343 { 1344 if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED)) 1345 free_objfile (so->objfile); 1346 remove_target_sections (so->abfd); 1347 free_so_symbols (so); 1348 } 1349 1350 /* If this shared library is now associated with a new symbol 1351 file, open it. */ 1352 if (found_pathname != NULL 1353 && (!was_loaded 1354 || filename_cmp (found_pathname, so->so_name) != 0)) 1355 { 1356 volatile struct gdb_exception e; 1357 1358 TRY_CATCH (e, RETURN_MASK_ERROR) 1359 solib_map_sections (so); 1360 1361 if (e.reason < 0) 1362 exception_fprintf (gdb_stderr, e, 1363 _("Error while mapping " 1364 "shared library sections:\n")); 1365 else if (auto_solib_add || was_loaded || libpthread_solib_p (so)) 1366 solib_read_symbols (so, flags); 1367 } 1368 } 1369 1370 do_cleanups (old_chain); 1371 } 1372 1373 static void 1374 reload_shared_libraries (char *ignored, int from_tty, 1375 struct cmd_list_element *e) 1376 { 1377 struct target_so_ops *ops; 1378 1379 reload_shared_libraries_1 (from_tty); 1380 1381 ops = solib_ops (target_gdbarch); 1382 1383 /* Creating inferior hooks here has two purposes. First, if we reload 1384 shared libraries then the address of solib breakpoint we've computed 1385 previously might be no longer valid. For example, if we forgot to set 1386 solib-absolute-prefix and are setting it right now, then the previous 1387 breakpoint address is plain wrong. Second, installing solib hooks 1388 also implicitly figures were ld.so is and loads symbols for it. 1389 Absent this call, if we've just connected to a target and set 1390 solib-absolute-prefix or solib-search-path, we'll lose all information 1391 about ld.so. */ 1392 if (target_has_execution) 1393 { 1394 /* Reset or free private data structures not associated with 1395 so_list entries. */ 1396 ops->clear_solib (); 1397 1398 /* Remove any previous solib event breakpoint. This is usually 1399 done in common code, at breakpoint_init_inferior time, but 1400 we're not really starting up the inferior here. */ 1401 remove_solib_event_breakpoints (); 1402 1403 #ifdef SOLIB_CREATE_INFERIOR_HOOK 1404 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid)); 1405 #else 1406 solib_create_inferior_hook (from_tty); 1407 #endif 1408 } 1409 1410 /* Sometimes the platform-specific hook loads initial shared 1411 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be 1412 incorrectly 0 but such solib targets should be fixed anyway. If we 1413 made all the inferior hook methods consistent, this call could be 1414 removed. Call it only after the solib target has been initialized by 1415 solib_create_inferior_hook. */ 1416 1417 solib_add (NULL, 0, NULL, auto_solib_add); 1418 1419 breakpoint_re_set (); 1420 1421 /* We may have loaded or unloaded debug info for some (or all) 1422 shared libraries. However, frames may still reference them. For 1423 example, a frame's unwinder might still point at DWARF FDE 1424 structures that are now freed. Also, getting new symbols may 1425 change our opinion about what is frameless. */ 1426 reinit_frame_cache (); 1427 1428 ops->special_symbol_handling (); 1429 } 1430 1431 static void 1432 show_auto_solib_add (struct ui_file *file, int from_tty, 1433 struct cmd_list_element *c, const char *value) 1434 { 1435 fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"), 1436 value); 1437 } 1438 1439 1440 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call 1441 the library-specific handler if it is installed for the current target. */ 1442 1443 struct symbol * 1444 solib_global_lookup (const struct objfile *objfile, 1445 const char *name, 1446 const domain_enum domain) 1447 { 1448 struct target_so_ops *ops = solib_ops (target_gdbarch); 1449 1450 if (ops->lookup_lib_global_symbol != NULL) 1451 return ops->lookup_lib_global_symbol (objfile, name, domain); 1452 return NULL; 1453 } 1454 1455 1456 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */ 1457 1458 void 1459 _initialize_solib (void) 1460 { 1461 solib_data = gdbarch_data_register_pre_init (solib_init); 1462 1463 add_com ("sharedlibrary", class_files, sharedlibrary_command, 1464 _("Load shared object library symbols for files matching REGEXP.")); 1465 add_info ("sharedlibrary", info_sharedlibrary_command, 1466 _("Status of loaded shared object libraries.")); 1467 add_com ("nosharedlibrary", class_files, no_shared_libraries, 1468 _("Unload all shared object library symbols.")); 1469 1470 add_setshow_boolean_cmd ("auto-solib-add", class_support, 1471 &auto_solib_add, _("\ 1472 Set autoloading of shared library symbols."), _("\ 1473 Show autoloading of shared library symbols."), _("\ 1474 If \"on\", symbols from all shared object libraries will be loaded\n\ 1475 automatically when the inferior begins execution, when the dynamic linker\n\ 1476 informs gdb that a new library has been loaded, or when attaching to the\n\ 1477 inferior. Otherwise, symbols must be loaded manually, using \ 1478 `sharedlibrary'."), 1479 NULL, 1480 show_auto_solib_add, 1481 &setlist, &showlist); 1482 1483 add_setshow_filename_cmd ("sysroot", class_support, 1484 &gdb_sysroot, _("\ 1485 Set an alternate system root."), _("\ 1486 Show the current system root."), _("\ 1487 The system root is used to load absolute shared library symbol files.\n\ 1488 For other (relative) files, you can add directories using\n\ 1489 `set solib-search-path'."), 1490 reload_shared_libraries, 1491 NULL, 1492 &setlist, &showlist); 1493 1494 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0, 1495 &setlist); 1496 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0, 1497 &showlist); 1498 1499 add_setshow_optional_filename_cmd ("solib-search-path", class_support, 1500 &solib_search_path, _("\ 1501 Set the search path for loading non-absolute shared library symbol files."), 1502 _("\ 1503 Show the search path for loading non-absolute shared library symbol files."), 1504 _("\ 1505 This takes precedence over the environment variables \ 1506 PATH and LD_LIBRARY_PATH."), 1507 reload_shared_libraries, 1508 show_solib_search_path, 1509 &setlist, &showlist); 1510 } 1511