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 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 = 1;
 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
 622   if (TARGET_PTR_BIT == 32)
 623     {
 624       addr_width = 8 + 4;
 625       addr_fmt = "08l";
 626     }
 627   else if (TARGET_PTR_BIT == 64)
 628     {
 629       addr_width = 16 + 4;
 630       addr_fmt = "016l";
 631     }
 632   else
 633     {
 634       internal_error (__FILE__, __LINE__,
 635                       "TARGET_PTR_BIT returned unknown size %d",
 636                       TARGET_PTR_BIT);
 637     }
 638
 639   update_solib_list (from_tty, 0);
 640
 641   for (so = so_list_head; so; so = so->next)
 642     {
 643       if (so->so_name[0])
 644         {
 645           if (!header_done)
 646             {
 647               printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From",
 648                                  addr_width, "To", "Syms Read",
 649                                  "Shared Object Library");
 650               header_done++;
 651             }
 652
 653           printf_unfiltered ("%-*s", addr_width,
 654                              so->textsection != NULL
 655                                ? local_hex_string_custom (
 656                                    (LONGEST) so->textsection->addr,
 657                                    addr_fmt)
 658                                : "");
 659           printf_unfiltered ("%-*s", addr_width,
 660                              so->textsection != NULL
 661                                ? local_hex_string_custom (
 662                                    (LONGEST) so->textsection->endaddr,
 663                                    addr_fmt)
 664                                : "");
 665           printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
 666           printf_unfiltered ("%s\n", so->so_name);
 667         }
 668     }
 669   if (so_list_head == NULL)
 670     {
 671       printf_unfiltered ("No shared libraries loaded at this time.\n");
 672     }
 673 }
 674
 675 /*
 676
 677    GLOBAL FUNCTION
 678
 679    solib_address -- check to see if an address is in a shared lib
 680
 681    SYNOPSIS
 682
 683    char * solib_address (CORE_ADDR address)
 684
 685    DESCRIPTION
 686
 687    Provides a hook for other gdb routines to discover whether or
 688    not a particular address is within the mapped address space of
 689    a shared library.
 690
 691    For example, this routine is called at one point to disable
 692    breakpoints which are in shared libraries that are not currently
 693    mapped in.
 694  */
 695
 696 char *
 697 solib_address (CORE_ADDR address)
 698 {
 699   register struct so_list *so = 0;      /* link map state variable */
 700
 701   for (so = so_list_head; so; so = so->next)
 702     {
 703       struct section_table *p;
 704
 705       for (p = so->sections; p < so->sections_end; p++)
 706         {
 707           if (p->addr <= address && address < p->endaddr)
 708             return (so->so_name);
 709         }
 710     }
 711
 712   return (0);
 713 }
 714
 715 /* Called by free_all_symtabs */
 716
 717 void
 718 clear_solib (void)
 719 {
 720   /* This function is expected to handle ELF shared libraries.  It is
 721      also used on Solaris, which can run either ELF or a.out binaries
 722      (for compatibility with SunOS 4), both of which can use shared
 723      libraries.  So we don't know whether we have an ELF executable or
 724      an a.out executable until the user chooses an executable file.
 725
 726      ELF shared libraries don't get mapped into the address space
 727      until after the program starts, so we'd better not try to insert
 728      breakpoints in them immediately.  We have to wait until the
 729      dynamic linker has loaded them; we'll hit a bp_shlib_event
 730      breakpoint (look for calls to create_solib_event_breakpoint) when
 731      it's ready.
 732
 733      SunOS shared libraries seem to be different --- they're present
 734      as soon as the process begins execution, so there's no need to
 735      put off inserting breakpoints.  There's also nowhere to put a
 736      bp_shlib_event breakpoint, so if we put it off, we'll never get
 737      around to it.
 738
 739      So: disable breakpoints only if we're using ELF shared libs.  */
 740   if (exec_bfd != NULL
 741       && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
 742     disable_breakpoints_in_shlibs (1);
 743
 744   while (so_list_head)
 745     {
 746       struct so_list *so = so_list_head;
 747       so_list_head = so->next;
 748       if (so->abfd)
 749         remove_target_sections (so->abfd);
 750       free_so (so);
 751     }
 752
 753   TARGET_SO_CLEAR_SOLIB ();
 754 }
 755
 756 static void
 757 do_clear_solib (PTR dummy)
 758 {
 759   solib_cleanup_queued = 0;
 760   clear_solib ();
 761 }
 762
 763 /* GLOBAL FUNCTION
 764
 765    solib_create_inferior_hook -- shared library startup support
 766
 767    SYNOPSIS
 768
 769    void solib_create_inferior_hook()
 770
 771    DESCRIPTION
 772
 773    When gdb starts up the inferior, it nurses it along (through the
 774    shell) until it is ready to execute it's first instruction.  At this
 775    point, this function gets called via expansion of the macro
 776    SOLIB_CREATE_INFERIOR_HOOK.  */
 777
 778 void
 779 solib_create_inferior_hook (void)
 780 {
 781   TARGET_SO_SOLIB_CREATE_INFERIOR_HOOK ();
 782 }
 783
 784 /* GLOBAL FUNCTION
 785
 786    in_solib_dynsym_resolve_code -- check to see if an address is in
 787                                    dynamic loader's dynamic symbol
 788                                    resolution code
 789
 790    SYNOPSIS
 791
 792    int in_solib_dynsym_resolve_code (CORE_ADDR pc)
 793
 794    DESCRIPTION
 795
 796    Determine if PC is in the dynamic linker's symbol resolution
 797    code.  Return 1 if so, 0 otherwise.
 798 */
 799
 800 int
 801 in_solib_dynsym_resolve_code (CORE_ADDR pc)
 802 {
 803   return TARGET_SO_IN_DYNSYM_RESOLVE_CODE (pc);
 804 }
 805
 806 /*
 807
 808    LOCAL FUNCTION
 809
 810    sharedlibrary_command -- handle command to explicitly add library
 811
 812    SYNOPSIS
 813
 814    static void sharedlibrary_command (char *args, int from_tty)
 815
 816    DESCRIPTION
 817
 818  */
 819
 820 static void
 821 sharedlibrary_command (char *args, int from_tty)
 822 {
 823   dont_repeat ();
 824   solib_add (args, from_tty, (struct target_ops *) 0, 1);
 825 }
 826
 827 /* LOCAL FUNCTION
 828
 829    no_shared_libraries -- handle command to explicitly discard symbols
 830    from shared libraries.
 831
 832    DESCRIPTION
 833
 834    Implements the command "nosharedlibrary", which discards symbols
 835    that have been auto-loaded from shared libraries.  Symbols from
 836    shared libraries that were added by explicit request of the user
 837    are not discarded.  Also called from remote.c.  */
 838
 839 void
 840 no_shared_libraries (char *ignored, int from_tty)
 841 {
 842   objfile_purge_solibs ();
 843   do_clear_solib (NULL);
 844 }
 845
 846 void
 847 _initialize_solib (void)
 848 {
 849   struct cmd_list_element *c;
 850
 851   add_com ("sharedlibrary", class_files, sharedlibrary_command,
 852            "Load shared object library symbols for files matching REGEXP.");
 853   add_info ("sharedlibrary", info_sharedlibrary_command,
 854             "Status of loaded shared object libraries.");
 855   add_com ("nosharedlibrary", class_files, no_shared_libraries,
 856            "Unload all shared object library symbols.");
 857
 858   add_show_from_set
 859     (add_set_cmd ("auto-solib-add", class_support, var_boolean,
 860                   (char *) &auto_solib_add,
 861                   "Set autoloading of shared library symbols.\n\
 862 If \"on\", symbols from all shared object libraries will be loaded\n\
 863 automatically when the inferior begins execution, when the dynamic linker\n\
 864 informs gdb that a new library has been loaded, or when attaching to the\n\
 865 inferior.  Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
 866                   &setlist),
 867      &showlist);
 868
 869   c = add_set_cmd ("solib-absolute-prefix", class_support, var_filename,
 870                    (char *) &solib_absolute_prefix,
 871                    "Set prefix for loading absolute shared library symbol files.\n\
 872 For other (relative) files, you can add values using `set solib-search-path'.",
 873                    &setlist);
 874   add_show_from_set (c, &showlist);
 875   set_cmd_completer (c, filename_completer);
 876
 877   c = add_set_cmd ("solib-search-path", class_support, var_string,
 878                    (char *) &solib_search_path,
 879                    "Set the search path for loading non-absolute shared library symbol files.\n\
 880 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
 881                    &setlist);
 882   add_show_from_set (c, &showlist);
 883   set_cmd_completer (c, filename_completer);
 884 }