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