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