gdb/solib.c

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