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