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