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