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