gdb/solib.c

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