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 /* 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, 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, 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, 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,
 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, 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, 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_fdopenr (scratch_pathname, gnutarget, 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   if (TARGET_PTR_BIT == 32)
 702     addr_width = 8 + 4;
 703   else if (TARGET_PTR_BIT == 64)
 704     addr_width = 16 + 4;
 705   else
 706     {
 707       internal_error (__FILE__, __LINE__,
 708                       _("TARGET_PTR_BIT returned unknown size %d"),
 709                       TARGET_PTR_BIT);
 710     }
 711
 712   update_solib_list (from_tty, 0);
 713
 714   for (so = so_list_head; so; so = so->next)
 715     {
 716       if (so->so_name[0])
 717         {
 718           if (!header_done)
 719             {
 720               printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From",
 721                                  addr_width, "To", "Syms Read",
 722                                  "Shared Object Library");
 723               header_done++;
 724             }
 725
 726           printf_unfiltered ("%-*s", addr_width,
 727                              so->textsection != NULL
 728                                ? hex_string_custom (
 729                                    (LONGEST) so->textsection->addr,
 730                                    addr_width - 4)
 731                                : "");
 732           printf_unfiltered ("%-*s", addr_width,
 733                              so->textsection != NULL
 734                                ? hex_string_custom (
 735                                    (LONGEST) so->textsection->endaddr,
 736                                    addr_width - 4)
 737                                : "");
 738           printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
 739           printf_unfiltered ("%s\n", so->so_name);
 740         }
 741     }
 742   if (so_list_head == NULL)
 743     {
 744       printf_unfiltered (_("No shared libraries loaded at this time.\n"));
 745     }
 746 }
 747
 748 /*
 749
 750    GLOBAL FUNCTION
 751
 752    solib_address -- check to see if an address is in a shared lib
 753
 754    SYNOPSIS
 755
 756    char * solib_address (CORE_ADDR address)
 757
 758    DESCRIPTION
 759
 760    Provides a hook for other gdb routines to discover whether or
 761    not a particular address is within the mapped address space of
 762    a shared library.
 763
 764    For example, this routine is called at one point to disable
 765    breakpoints which are in shared libraries that are not currently
 766    mapped in.
 767  */
 768
 769 char *
 770 solib_address (CORE_ADDR address)
 771 {
 772   struct so_list *so = 0;       /* link map state variable */
 773
 774   for (so = so_list_head; so; so = so->next)
 775     {
 776       struct section_table *p;
 777
 778       for (p = so->sections; p < so->sections_end; p++)
 779         {
 780           if (p->addr <= address && address < p->endaddr)
 781             return (so->so_name);
 782         }
 783     }
 784
 785   return (0);
 786 }
 787
 788 /* Called by free_all_symtabs */
 789
 790 void
 791 clear_solib (void)
 792 {
 793   struct target_so_ops *ops = solib_ops (current_gdbarch);
 794
 795   /* This function is expected to handle ELF shared libraries.  It is
 796      also used on Solaris, which can run either ELF or a.out binaries
 797      (for compatibility with SunOS 4), both of which can use shared
 798      libraries.  So we don't know whether we have an ELF executable or
 799      an a.out executable until the user chooses an executable file.
 800
 801      ELF shared libraries don't get mapped into the address space
 802      until after the program starts, so we'd better not try to insert
 803      breakpoints in them immediately.  We have to wait until the
 804      dynamic linker has loaded them; we'll hit a bp_shlib_event
 805      breakpoint (look for calls to create_solib_event_breakpoint) when
 806      it's ready.
 807
 808      SunOS shared libraries seem to be different --- they're present
 809      as soon as the process begins execution, so there's no need to
 810      put off inserting breakpoints.  There's also nowhere to put a
 811      bp_shlib_event breakpoint, so if we put it off, we'll never get
 812      around to it.
 813
 814      So: disable breakpoints only if we're using ELF shared libs.  */
 815   if (exec_bfd != NULL
 816       && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
 817     disable_breakpoints_in_shlibs (1);
 818
 819   while (so_list_head)
 820     {
 821       struct so_list *so = so_list_head;
 822       so_list_head = so->next;
 823       if (so->abfd)
 824         remove_target_sections (so->abfd);
 825       free_so (so);
 826     }
 827
 828   ops->clear_solib ();
 829 }
 830
 831 static void
 832 do_clear_solib (void *dummy)
 833 {
 834   solib_cleanup_queued = 0;
 835   clear_solib ();
 836 }
 837
 838 /* GLOBAL FUNCTION
 839
 840    solib_create_inferior_hook -- shared library startup support
 841
 842    SYNOPSIS
 843
 844    void solib_create_inferior_hook ()
 845
 846    DESCRIPTION
 847
 848    When gdb starts up the inferior, it nurses it along (through the
 849    shell) until it is ready to execute it's first instruction.  At this
 850    point, this function gets called via expansion of the macro
 851    SOLIB_CREATE_INFERIOR_HOOK.  */
 852
 853 void
 854 solib_create_inferior_hook (void)
 855 {
 856   struct target_so_ops *ops = solib_ops (current_gdbarch);
 857   ops->solib_create_inferior_hook();
 858 }
 859
 860 /* GLOBAL FUNCTION
 861
 862    in_solib_dynsym_resolve_code -- check to see if an address is in
 863                                    dynamic loader's dynamic symbol
 864                                    resolution code
 865
 866    SYNOPSIS
 867
 868    int in_solib_dynsym_resolve_code (CORE_ADDR pc)
 869
 870    DESCRIPTION
 871
 872    Determine if PC is in the dynamic linker's symbol resolution
 873    code.  Return 1 if so, 0 otherwise.
 874 */
 875
 876 int
 877 in_solib_dynsym_resolve_code (CORE_ADDR pc)
 878 {
 879   struct target_so_ops *ops = solib_ops (current_gdbarch);
 880   return ops->in_dynsym_resolve_code (pc);
 881 }
 882
 883 /*
 884
 885    LOCAL FUNCTION
 886
 887    sharedlibrary_command -- handle command to explicitly add library
 888
 889    SYNOPSIS
 890
 891    static void sharedlibrary_command (char *args, int from_tty)
 892
 893    DESCRIPTION
 894
 895  */
 896
 897 static void
 898 sharedlibrary_command (char *args, int from_tty)
 899 {
 900   dont_repeat ();
 901   solib_add (args, from_tty, (struct target_ops *) 0, 1);
 902 }
 903
 904 /* LOCAL FUNCTION
 905
 906    no_shared_libraries -- handle command to explicitly discard symbols
 907    from shared libraries.
 908
 909    DESCRIPTION
 910
 911    Implements the command "nosharedlibrary", which discards symbols
 912    that have been auto-loaded from shared libraries.  Symbols from
 913    shared libraries that were added by explicit request of the user
 914    are not discarded.  Also called from remote.c.  */
 915
 916 void
 917 no_shared_libraries (char *ignored, int from_tty)
 918 {
 919   objfile_purge_solibs ();
 920   do_clear_solib (NULL);
 921 }
 922
 923 static void
 924 reload_shared_libraries (char *ignored, int from_tty,
 925                          struct cmd_list_element *e)
 926 {
 927   no_shared_libraries (NULL, from_tty);
 928   solib_add (NULL, from_tty, NULL, auto_solib_add);
 929 }
 930
 931 static void
 932 show_auto_solib_add (struct ui_file *file, int from_tty,
 933                      struct cmd_list_element *c, const char *value)
 934 {
 935   fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"),
 936                     value);
 937 }
 938
 939
 940 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
 941
 942 void
 943 _initialize_solib (void)
 944 {
 945   struct cmd_list_element *c;
 946
 947   solib_data = gdbarch_data_register_pre_init (solib_init);
 948
 949   add_com ("sharedlibrary", class_files, sharedlibrary_command,
 950            _("Load shared object library symbols for files matching REGEXP."));
 951   add_info ("sharedlibrary", info_sharedlibrary_command,
 952             _("Status of loaded shared object libraries."));
 953   add_com ("nosharedlibrary", class_files, no_shared_libraries,
 954            _("Unload all shared object library symbols."));
 955
 956   add_setshow_boolean_cmd ("auto-solib-add", class_support,
 957                            &auto_solib_add, _("\
 958 Set autoloading of shared library symbols."), _("\
 959 Show autoloading of shared library symbols."), _("\
 960 If \"on\", symbols from all shared object libraries will be loaded\n\
 961 automatically when the inferior begins execution, when the dynamic linker\n\
 962 informs gdb that a new library has been loaded, or when attaching to the\n\
 963 inferior.  Otherwise, symbols must be loaded manually, using `sharedlibrary'."),
 964                            NULL,
 965                            show_auto_solib_add,
 966                            &setlist, &showlist);
 967
 968   add_setshow_filename_cmd ("solib-absolute-prefix", class_support,
 969                             &solib_absolute_prefix, _("\
 970 Set prefix for loading absolute shared library symbol files."), _("\
 971 Show prefix for loading absolute shared library symbol files."), _("\
 972 For other (relative) files, you can add values using `set solib-search-path'."),
 973                             reload_shared_libraries,
 974                             NULL,
 975                             &setlist, &showlist);
 976
 977   /* Set the default value of "solib-absolute-prefix" from the sysroot, if
 978      one is set.  */
 979   solib_absolute_prefix = xstrdup (gdb_sysroot);
 980
 981   add_setshow_optional_filename_cmd ("solib-search-path", class_support,
 982                                      &solib_search_path, _("\
 983 Set the search path for loading non-absolute shared library symbol files."), _("\
 984 Show the search path for loading non-absolute shared library symbol files."), _("\
 985 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH."),
 986                                      reload_shared_libraries,
 987                                      show_solib_search_path,
 988                                      &setlist, &showlist);
 989 }