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