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