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