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