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