1/* Handle shared libraries for GDB, the GNU Debugger. 2 3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 4 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23#include "defs.h" 24 25#include <sys/types.h> 26#include <fcntl.h> 27#include "gdb_string.h" 28#include "symtab.h" 29#include "bfd.h" 30#include "symfile.h" 31#include "objfiles.h" 32#include "gdbcore.h" 33#include "command.h" 34#include "target.h" 35#include "frame.h" 36#include "gdb_regex.h" 37#include "inferior.h" 38#include "environ.h" 39#include "language.h" 40#include "gdbcmd.h" 41#include "completer.h" 42#include "filenames.h" /* for DOSish file names */ 43#include "exec.h" 44#include "solist.h" 45#include "observer.h" 46#include "readline/readline.h" 47 48/* external data declarations */ 49 50/* FIXME: gdbarch needs to control this variable */ 51struct target_so_ops *current_target_so_ops; 52 53/* local data declarations */ 54 55static struct so_list *so_list_head; /* List of known shared objects */ 56 57static int solib_cleanup_queued = 0; /* make_run_cleanup called */ 58 59/* Local function prototypes */ 60 61static void do_clear_solib (void *); 62 63/* If non-zero, this is a prefix that will be added to the front of the name 64 shared libraries with an absolute filename for loading. */ 65static char *solib_absolute_prefix = NULL; 66 67/* If non-empty, this is a search path for loading non-absolute shared library 68 symbol files. This takes precedence over the environment variables PATH 69 and LD_LIBRARY_PATH. */ 70static char *solib_search_path = NULL; 71 72/* 73 74 GLOBAL FUNCTION 75 76 solib_open -- Find a shared library file and open it. 77 78 SYNOPSIS 79 80 int solib_open (char *in_patname, char **found_pathname); 81 82 DESCRIPTION 83 84 Global variable SOLIB_ABSOLUTE_PREFIX is used as a prefix directory 85 to search for shared libraries if they have an absolute path. 86 87 Global variable SOLIB_SEARCH_PATH is used as a prefix directory 88 (or set of directories, as in LD_LIBRARY_PATH) to search for all 89 shared libraries if not found in SOLIB_ABSOLUTE_PREFIX. 90 91 Search algorithm: 92 * If there is a solib_absolute_prefix and path is absolute: 93 * Search for solib_absolute_prefix/path. 94 * else 95 * Look for it literally (unmodified). 96 * Look in SOLIB_SEARCH_PATH. 97 * If available, use target defined search function. 98 * If solib_absolute_prefix is NOT set, perform the following two searches: 99 * Look in inferior's $PATH. 100 * Look in inferior's $LD_LIBRARY_PATH. 101 * 102 * The last check avoids doing this search when targetting remote 103 * machines since solib_absolute_prefix will almost always be set. 104 105 RETURNS 106 107 file handle for opened solib, or -1 for failure. */ 108 109int 110solib_open (char *in_pathname, char **found_pathname) 111{ 112 int found_file = -1; 113 char *temp_pathname = NULL; 114 char *p = in_pathname; 115 116 while (*p && !IS_DIR_SEPARATOR (*p)) 117 p++; 118 119 if (*p) 120 { 121 if (! IS_ABSOLUTE_PATH (in_pathname) || solib_absolute_prefix == NULL) 122 temp_pathname = in_pathname; 123 else 124 { 125 int prefix_len = strlen (solib_absolute_prefix); 126 127 /* Remove trailing slashes from absolute prefix. */ 128 while (prefix_len > 0 129 && IS_DIR_SEPARATOR (solib_absolute_prefix[prefix_len - 1])) 130 prefix_len--; 131 132 /* Cat the prefixed pathname together. */ 133 temp_pathname = alloca (prefix_len + strlen (in_pathname) + 1); 134 strncpy (temp_pathname, solib_absolute_prefix, prefix_len); 135 temp_pathname[prefix_len] = '\0'; 136 strcat (temp_pathname, in_pathname); 137 } 138 139 /* Now see if we can open it. */ 140 found_file = open (temp_pathname, O_RDONLY, 0); 141 } 142 143 /* If the search in solib_absolute_prefix failed, and the path name is 144 absolute at this point, make it relative. (openp will try and open the 145 file according to its absolute path otherwise, which is not what we want.) 146 Affects subsequent searches for this solib. */ 147 if (found_file < 0 && IS_ABSOLUTE_PATH (in_pathname)) 148 { 149 /* First, get rid of any drive letters etc. */ 150 while (!IS_DIR_SEPARATOR (*in_pathname)) 151 in_pathname++; 152 153 /* Next, get rid of all leading dir separators. */ 154 while (IS_DIR_SEPARATOR (*in_pathname)) 155 in_pathname++; 156 } 157 158 /* If not found, search the solib_search_path (if any). */ 159 if (found_file < 0 && solib_search_path != NULL) 160 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST, 161 in_pathname, O_RDONLY, 0, &temp_pathname); 162 163 /* If not found, next search the solib_search_path (if any) for the basename 164 only (ignoring the path). This is to allow reading solibs from a path 165 that differs from the opened path. */ 166 if (found_file < 0 && solib_search_path != NULL) 167 found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST, 168 lbasename (in_pathname), O_RDONLY, 0, 169 &temp_pathname); 170 171 /* If not found, try to use target supplied solib search method */ 172 if (found_file < 0 && TARGET_SO_FIND_AND_OPEN_SOLIB != NULL) 173 found_file = TARGET_SO_FIND_AND_OPEN_SOLIB 174 (in_pathname, O_RDONLY, &temp_pathname); 175 176 /* If not found, next search the inferior's $PATH environment variable. */ 177 if (found_file < 0 && solib_absolute_prefix == NULL) 178 found_file = openp (get_in_environ (inferior_environ, "PATH"), 179 OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY, 0, 180 &temp_pathname); 181 182 /* If not found, next search the inferior's $LD_LIBRARY_PATH 183 environment variable. */ 184 if (found_file < 0 && solib_absolute_prefix == NULL) 185 found_file = openp (get_in_environ (inferior_environ, "LD_LIBRARY_PATH"), 186 OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY, 0, 187 &temp_pathname); 188 189 /* Done. If not found, tough luck. Return found_file and 190 (optionally) found_pathname. */ 191 if (found_pathname != NULL && temp_pathname != NULL) 192 *found_pathname = xstrdup (temp_pathname); 193 return found_file; 194} 195 196 197/* 198 199 LOCAL FUNCTION 200 201 solib_map_sections -- open bfd and build sections for shared lib 202 203 SYNOPSIS 204 205 static int solib_map_sections (struct so_list *so) 206 207 DESCRIPTION 208 209 Given a pointer to one of the shared objects in our list 210 of mapped objects, use the recorded name to open a bfd 211 descriptor for the object, build a section table, and then 212 relocate all the section addresses by the base address at 213 which the shared object was mapped. 214 215 FIXMES 216 217 In most (all?) cases the shared object file name recorded in the 218 dynamic linkage tables will be a fully qualified pathname. For 219 cases where it isn't, do we really mimic the systems search 220 mechanism correctly in the below code (particularly the tilde 221 expansion stuff?). 222 */ 223 224static int 225solib_map_sections (void *arg) 226{ 227 struct so_list *so = (struct so_list *) arg; /* catch_errors bogon */ 228 char *filename; 229 char *scratch_pathname; 230 int scratch_chan; 231 struct section_table *p; 232 struct cleanup *old_chain; 233 bfd *abfd; 234 235 filename = tilde_expand (so->so_name); 236 237 old_chain = make_cleanup (xfree, filename); 238 scratch_chan = solib_open (filename, &scratch_pathname); 239 240 if (scratch_chan < 0) 241 { 242 perror_with_name (filename); 243 } 244 245 /* Leave scratch_pathname allocated. abfd->name will point to it. */ 246 abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan); 247 if (!abfd) 248 { 249 close (scratch_chan); 250 error ("Could not open `%s' as an executable file: %s", 251 scratch_pathname, bfd_errmsg (bfd_get_error ())); 252 } 253 254 /* Leave bfd open, core_xfer_memory and "info files" need it. */ 255 so->abfd = abfd; 256 bfd_set_cacheable (abfd, 1); 257 258 /* copy full path name into so_name, so that later symbol_file_add 259 can find it */ 260 if (strlen (scratch_pathname) >= SO_NAME_MAX_PATH_SIZE) 261 error ("Full path name length of shared library exceeds SO_NAME_MAX_PATH_SIZE in so_list structure."); 262 strcpy (so->so_name, scratch_pathname); 263 264 if (!bfd_check_format (abfd, bfd_object)) 265 { 266 error ("\"%s\": not in executable format: %s.", 267 scratch_pathname, bfd_errmsg (bfd_get_error ())); 268 } 269 if (build_section_table (abfd, &so->sections, &so->sections_end)) 270 { 271 error ("Can't find the file sections in `%s': %s", 272 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ())); 273 } 274 275 for (p = so->sections; p < so->sections_end; p++) 276 { 277 /* Relocate the section binding addresses as recorded in the shared 278 object's file by the base address to which the object was actually 279 mapped. */ 280 TARGET_SO_RELOCATE_SECTION_ADDRESSES (so, p); 281 if (strcmp (p->the_bfd_section->name, ".text") == 0) 282 { 283 so->textsection = p; 284 } 285 } 286 287 /* Free the file names, close the file now. */ 288 do_cleanups (old_chain); 289 290 return (1); 291} 292 293/* LOCAL FUNCTION 294 295 free_so --- free a `struct so_list' object 296 297 SYNOPSIS 298 299 void free_so (struct so_list *so) 300 301 DESCRIPTION 302 303 Free the storage associated with the `struct so_list' object SO. 304 If we have opened a BFD for SO, close it. 305 306 The caller is responsible for removing SO from whatever list it is 307 a member of. If we have placed SO's sections in some target's 308 section table, the caller is responsible for removing them. 309 310 This function doesn't mess with objfiles at all. If there is an 311 objfile associated with SO that needs to be removed, the caller is 312 responsible for taking care of that. */ 313 314void 315free_so (struct so_list *so) 316{ 317 char *bfd_filename = 0; 318 319 if (so->sections) 320 xfree (so->sections); 321 322 if (so->abfd) 323 { 324 bfd_filename = bfd_get_filename (so->abfd); 325 if (! bfd_close (so->abfd)) 326 warning ("cannot close \"%s\": %s", 327 bfd_filename, bfd_errmsg (bfd_get_error ())); 328 } 329 330 if (bfd_filename) 331 xfree (bfd_filename); 332 333 TARGET_SO_FREE_SO (so); 334 335 xfree (so); 336} 337 338 339/* Return address of first so_list entry in master shared object list. */ 340struct so_list * 341master_so_list (void) 342{ 343 return so_list_head; 344} 345 346 347/* A small stub to get us past the arg-passing pinhole of catch_errors. */ 348 349static int 350symbol_add_stub (void *arg) 351{ 352 struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */ 353 struct section_addr_info *sap; 354 355 /* Have we already loaded this shared object? */ 356 ALL_OBJFILES (so->objfile) 357 { 358 if (strcmp (so->objfile->name, so->so_name) == 0) 359 return 1; 360 } 361 362 sap = build_section_addr_info_from_section_table (so->sections, 363 so->sections_end); 364 365 so->objfile = symbol_file_add (so->so_name, so->from_tty, 366 sap, 0, OBJF_SHARED); 367 free_section_addr_info (sap); 368 369 return (1); 370} 371 372 373/* LOCAL FUNCTION 374 375 update_solib_list --- synchronize GDB's shared object list with inferior's 376 377 SYNOPSIS 378 379 void update_solib_list (int from_tty, struct target_ops *TARGET) 380 381 Extract the list of currently loaded shared objects from the 382 inferior, and compare it with the list of shared objects currently 383 in GDB's so_list_head list. Edit so_list_head to bring it in sync 384 with the inferior's new list. 385 386 If we notice that the inferior has unloaded some shared objects, 387 free any symbolic info GDB had read about those shared objects. 388 389 Don't load symbolic info for any new shared objects; just add them 390 to the list, and leave their symbols_loaded flag clear. 391 392 If FROM_TTY is non-null, feel free to print messages about what 393 we're doing. 394 395 If TARGET is non-null, add the sections of all new shared objects 396 to TARGET's section table. Note that this doesn't remove any 397 sections for shared objects that have been unloaded, and it 398 doesn't check to see if the new shared objects are already present in 399 the section table. But we only use this for core files and 400 processes we've just attached to, so that's okay. */ 401 402static void 403update_solib_list (int from_tty, struct target_ops *target) 404{ 405 struct so_list *inferior = TARGET_SO_CURRENT_SOS (); 406 struct so_list *gdb, **gdb_link; 407 408 /* If we are attaching to a running process for which we 409 have not opened a symbol file, we may be able to get its 410 symbols now! */ 411 if (attach_flag && 412 symfile_objfile == NULL) 413 catch_errors (TARGET_SO_OPEN_SYMBOL_FILE_OBJECT, &from_tty, 414 "Error reading attached process's symbol file.\n", 415 RETURN_MASK_ALL); 416 417 /* Since this function might actually add some elements to the 418 so_list_head list, arrange for it to be cleaned up when 419 appropriate. */ 420 if (!solib_cleanup_queued) 421 { 422 make_run_cleanup (do_clear_solib, NULL); 423 solib_cleanup_queued = 1; 424 } 425 426 /* GDB and the inferior's dynamic linker each maintain their own 427 list of currently loaded shared objects; we want to bring the 428 former in sync with the latter. Scan both lists, seeing which 429 shared objects appear where. There are three cases: 430 431 - A shared object appears on both lists. This means that GDB 432 knows about it already, and it's still loaded in the inferior. 433 Nothing needs to happen. 434 435 - A shared object appears only on GDB's list. This means that 436 the inferior has unloaded it. We should remove the shared 437 object from GDB's tables. 438 439 - A shared object appears only on the inferior's list. This 440 means that it's just been loaded. We should add it to GDB's 441 tables. 442 443 So we walk GDB's list, checking each entry to see if it appears 444 in the inferior's list too. If it does, no action is needed, and 445 we remove it from the inferior's list. If it doesn't, the 446 inferior has unloaded it, and we remove it from GDB's list. By 447 the time we're done walking GDB's list, the inferior's list 448 contains only the new shared objects, which we then add. */ 449 450 gdb = so_list_head; 451 gdb_link = &so_list_head; 452 while (gdb) 453 { 454 struct so_list *i = inferior; 455 struct so_list **i_link = &inferior; 456 457 /* Check to see whether the shared object *gdb also appears in 458 the inferior's current list. */ 459 while (i) 460 { 461 if (! strcmp (gdb->so_original_name, i->so_original_name)) 462 break; 463 464 i_link = &i->next; 465 i = *i_link; 466 } 467 468 /* If the shared object appears on the inferior's list too, then 469 it's still loaded, so we don't need to do anything. Delete 470 it from the inferior's list, and leave it on GDB's list. */ 471 if (i) 472 { 473 *i_link = i->next; 474 free_so (i); 475 gdb_link = &gdb->next; 476 gdb = *gdb_link; 477 } 478 479 /* If it's not on the inferior's list, remove it from GDB's tables. */ 480 else 481 { 482 /* Notify any observer that the SO has been unloaded 483 before we remove it from the gdb tables. */ 484 observer_notify_solib_unloaded (gdb); 485 486 *gdb_link = gdb->next; 487 488 /* Unless the user loaded it explicitly, free SO's objfile. */ 489 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)) 490 free_objfile (gdb->objfile); 491 492 /* Some targets' section tables might be referring to 493 sections from so->abfd; remove them. */ 494 remove_target_sections (gdb->abfd); 495 496 free_so (gdb); 497 gdb = *gdb_link; 498 } 499 } 500 501 /* Now the inferior's list contains only shared objects that don't 502 appear in GDB's list --- those that are newly loaded. Add them 503 to GDB's shared object list. */ 504 if (inferior) 505 { 506 struct so_list *i; 507 508 /* Add the new shared objects to GDB's list. */ 509 *gdb_link = inferior; 510 511 /* Fill in the rest of each of the `struct so_list' nodes. */ 512 for (i = inferior; i; i = i->next) 513 { 514 i->from_tty = from_tty; 515 516 /* Fill in the rest of the `struct so_list' node. */ 517 catch_errors (solib_map_sections, i, 518 "Error while mapping shared library sections:\n", 519 RETURN_MASK_ALL); 520 521 /* If requested, add the shared object's sections to the TARGET's 522 section table. Do this immediately after mapping the object so 523 that later nodes in the list can query this object, as is needed 524 in solib-osf.c. */ 525 if (target) 526 { 527 int count = (i->sections_end - i->sections); 528 if (count > 0) 529 { 530 int space = target_resize_to_sections (target, count); 531 memcpy (target->to_sections + space, 532 i->sections, 533 count * sizeof (i->sections[0])); 534 } 535 } 536 } 537 } 538} 539 540 541/* GLOBAL FUNCTION 542 543 solib_add -- read in symbol info for newly added shared libraries 544 545 SYNOPSIS 546 547 void solib_add (char *pattern, int from_tty, struct target_ops 548 *TARGET, int readsyms) 549 550 DESCRIPTION 551 552 Read in symbolic information for any shared objects whose names 553 match PATTERN. (If we've already read a shared object's symbol 554 info, leave it alone.) If PATTERN is zero, read them all. 555 556 If READSYMS is 0, defer reading symbolic information until later 557 but still do any needed low level processing. 558 559 FROM_TTY and TARGET are as described for update_solib_list, above. */ 560 561void 562solib_add (char *pattern, int from_tty, struct target_ops *target, int readsyms) 563{ 564 struct so_list *gdb; 565 566 if (pattern) 567 { 568 char *re_err = re_comp (pattern); 569 570 if (re_err) 571 error ("Invalid regexp: %s", re_err); 572 } 573 574 update_solib_list (from_tty, target); 575 576 /* Walk the list of currently loaded shared libraries, and read 577 symbols for any that match the pattern --- or any whose symbols 578 aren't already loaded, if no pattern was given. */ 579 { 580 int any_matches = 0; 581 int loaded_any_symbols = 0; 582 583 for (gdb = so_list_head; gdb; gdb = gdb->next) 584 if (! pattern || re_exec (gdb->so_name)) 585 { 586 any_matches = 1; 587 588 if (gdb->symbols_loaded) 589 { 590 if (from_tty) 591 printf_unfiltered ("Symbols already loaded for %s\n", 592 gdb->so_name); 593 } 594 else if (readsyms) 595 { 596 if (catch_errors 597 (symbol_add_stub, gdb, 598 "Error while reading shared library symbols:\n", 599 RETURN_MASK_ALL)) 600 { 601 if (from_tty) 602 printf_unfiltered ("Loaded symbols for %s\n", 603 gdb->so_name); 604 gdb->symbols_loaded = 1; 605 loaded_any_symbols = 1; 606 } 607 } 608 } 609 610 if (from_tty && pattern && ! any_matches) 611 printf_unfiltered 612 ("No loaded shared libraries match the pattern `%s'.\n", pattern); 613 614 if (loaded_any_symbols) 615 { 616 /* Getting new symbols may change our opinion about what is 617 frameless. */ 618 reinit_frame_cache (); 619 620 TARGET_SO_SPECIAL_SYMBOL_HANDLING (); 621 } 622 } 623} 624 625 626/* 627 628 LOCAL FUNCTION 629 630 info_sharedlibrary_command -- code for "info sharedlibrary" 631 632 SYNOPSIS 633 634 static void info_sharedlibrary_command () 635 636 DESCRIPTION 637 638 Walk through the shared library list and print information 639 about each attached library. 640 */ 641 642static void 643info_sharedlibrary_command (char *ignore, int from_tty) 644{ 645 struct so_list *so = NULL; /* link map state variable */ 646 int header_done = 0; 647 int addr_width; 648 649 if (TARGET_PTR_BIT == 32) 650 addr_width = 8 + 4; 651 else if (TARGET_PTR_BIT == 64) 652 addr_width = 16 + 4; 653 else 654 { 655 internal_error (__FILE__, __LINE__, 656 "TARGET_PTR_BIT returned unknown size %d", 657 TARGET_PTR_BIT); 658 } 659 660 update_solib_list (from_tty, 0); 661 662 for (so = so_list_head; so; so = so->next) 663 { 664 if (so->so_name[0]) 665 { 666 if (!header_done) 667 { 668 printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From", 669 addr_width, "To", "Syms Read", 670 "Shared Object Library"); 671 header_done++; 672 } 673 674 printf_unfiltered ("%-*s", addr_width, 675 so->textsection != NULL 676 ? hex_string_custom ( 677 (LONGEST) so->textsection->addr, 678 addr_width - 4) 679 : ""); 680 printf_unfiltered ("%-*s", addr_width, 681 so->textsection != NULL 682 ? hex_string_custom ( 683 (LONGEST) so->textsection->endaddr, 684 addr_width - 4) 685 : ""); 686 printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No"); 687 printf_unfiltered ("%s\n", so->so_name); 688 } 689 } 690 if (so_list_head == NULL) 691 { 692 printf_unfiltered ("No shared libraries loaded at this time.\n"); 693 } 694} 695 696/* 697 698 GLOBAL FUNCTION 699 700 solib_address -- check to see if an address is in a shared lib 701 702 SYNOPSIS 703 704 char * solib_address (CORE_ADDR address) 705 706 DESCRIPTION 707 708 Provides a hook for other gdb routines to discover whether or 709 not a particular address is within the mapped address space of 710 a shared library. 711 712 For example, this routine is called at one point to disable 713 breakpoints which are in shared libraries that are not currently 714 mapped in. 715 */ 716 717char * 718solib_address (CORE_ADDR address) 719{ 720 struct so_list *so = 0; /* link map state variable */ 721 722 for (so = so_list_head; so; so = so->next) 723 { 724 struct section_table *p; 725 726 for (p = so->sections; p < so->sections_end; p++) 727 { 728 if (p->addr <= address && address < p->endaddr) 729 return (so->so_name); 730 } 731 } 732 733 return (0); 734} 735 736/* Called by free_all_symtabs */ 737 738void 739clear_solib (void) 740{ 741 /* This function is expected to handle ELF shared libraries. It is 742 also used on Solaris, which can run either ELF or a.out binaries 743 (for compatibility with SunOS 4), both of which can use shared 744 libraries. So we don't know whether we have an ELF executable or 745 an a.out executable until the user chooses an executable file. 746 747 ELF shared libraries don't get mapped into the address space 748 until after the program starts, so we'd better not try to insert 749 breakpoints in them immediately. We have to wait until the 750 dynamic linker has loaded them; we'll hit a bp_shlib_event 751 breakpoint (look for calls to create_solib_event_breakpoint) when 752 it's ready. 753 754 SunOS shared libraries seem to be different --- they're present 755 as soon as the process begins execution, so there's no need to 756 put off inserting breakpoints. There's also nowhere to put a 757 bp_shlib_event breakpoint, so if we put it off, we'll never get 758 around to it. 759 760 So: disable breakpoints only if we're using ELF shared libs. */ 761 if (exec_bfd != NULL 762 && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour) 763 disable_breakpoints_in_shlibs (1); 764 765 while (so_list_head) 766 { 767 struct so_list *so = so_list_head; 768 so_list_head = so->next; 769 if (so->abfd) 770 remove_target_sections (so->abfd); 771 free_so (so); 772 } 773 774 TARGET_SO_CLEAR_SOLIB (); 775} 776 777static void 778do_clear_solib (void *dummy) 779{ 780 solib_cleanup_queued = 0; 781 clear_solib (); 782} 783 784/* GLOBAL FUNCTION 785 786 solib_create_inferior_hook -- shared library startup support 787 788 SYNOPSIS 789 790 void solib_create_inferior_hook() 791 792 DESCRIPTION 793 794 When gdb starts up the inferior, it nurses it along (through the 795 shell) until it is ready to execute it's first instruction. At this 796 point, this function gets called via expansion of the macro 797 SOLIB_CREATE_INFERIOR_HOOK. */ 798 799void 800solib_create_inferior_hook (void) 801{ 802 TARGET_SO_SOLIB_CREATE_INFERIOR_HOOK (); 803} 804 805/* GLOBAL FUNCTION 806 807 in_solib_dynsym_resolve_code -- check to see if an address is in 808 dynamic loader's dynamic symbol 809 resolution code 810 811 SYNOPSIS 812 813 int in_solib_dynsym_resolve_code (CORE_ADDR pc) 814 815 DESCRIPTION 816 817 Determine if PC is in the dynamic linker's symbol resolution 818 code. Return 1 if so, 0 otherwise. 819*/ 820 821int 822in_solib_dynsym_resolve_code (CORE_ADDR pc) 823{ 824 return TARGET_SO_IN_DYNSYM_RESOLVE_CODE (pc); 825} 826 827/* 828 829 LOCAL FUNCTION 830 831 sharedlibrary_command -- handle command to explicitly add library 832 833 SYNOPSIS 834 835 static void sharedlibrary_command (char *args, int from_tty) 836 837 DESCRIPTION 838 839 */ 840 841static void 842sharedlibrary_command (char *args, int from_tty) 843{ 844 dont_repeat (); 845 solib_add (args, from_tty, (struct target_ops *) 0, 1); 846} 847 848/* LOCAL FUNCTION 849 850 no_shared_libraries -- handle command to explicitly discard symbols 851 from shared libraries. 852 853 DESCRIPTION 854 855 Implements the command "nosharedlibrary", which discards symbols 856 that have been auto-loaded from shared libraries. Symbols from 857 shared libraries that were added by explicit request of the user 858 are not discarded. Also called from remote.c. */ 859 860void 861no_shared_libraries (char *ignored, int from_tty) 862{ 863 objfile_purge_solibs (); 864 do_clear_solib (NULL); 865} 866 867static void 868reload_shared_libraries (char *ignored, int from_tty) 869{ 870 no_shared_libraries (NULL, from_tty); 871 solib_add (NULL, from_tty, NULL, auto_solib_add); 872} 873 874extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */ 875 876void 877_initialize_solib (void) 878{ 879 struct cmd_list_element *c; 880 881 add_com ("sharedlibrary", class_files, sharedlibrary_command, 882 "Load shared object library symbols for files matching REGEXP."); 883 add_info ("sharedlibrary", info_sharedlibrary_command, 884 "Status of loaded shared object libraries."); 885 add_com ("nosharedlibrary", class_files, no_shared_libraries, 886 "Unload all shared object library symbols."); 887 888 deprecated_add_show_from_set 889 (add_set_cmd ("auto-solib-add", class_support, var_boolean, 890 (char *) &auto_solib_add, 891 "Set autoloading of shared library symbols.\n\ 892If \"on\", symbols from all shared object libraries will be loaded\n\ 893automatically when the inferior begins execution, when the dynamic linker\n\ 894informs gdb that a new library has been loaded, or when attaching to the\n\ 895inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.", 896 &setlist), 897 &showlist); 898 899 c = add_set_cmd ("solib-absolute-prefix", class_support, var_filename, 900 (char *) &solib_absolute_prefix, 901 "Set prefix for loading absolute shared library symbol files.\n\ 902For other (relative) files, you can add values using `set solib-search-path'.", 903 &setlist); 904 deprecated_add_show_from_set (c, &showlist); 905 set_cmd_cfunc (c, reload_shared_libraries); 906 set_cmd_completer (c, filename_completer); 907 908 /* Set the default value of "solib-absolute-prefix" from the sysroot, if 909 one is set. */ 910 solib_absolute_prefix = xstrdup (gdb_sysroot); 911 912 c = add_set_cmd ("solib-search-path", class_support, var_string, 913 (char *) &solib_search_path, 914 "Set the search path for loading non-absolute shared library symbol files.\n\ 915This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.", 916 &setlist); 917 deprecated_add_show_from_set (c, &showlist); 918 set_cmd_cfunc (c, reload_shared_libraries); 919 set_cmd_completer (c, filename_completer); 920} 921