gdb/solib.c

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