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