gdb/solib.c

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