gdb/solib.c

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