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