* top.c (init_main): Make `set history file name' complete on file
[deliverable/binutils-gdb.git] / gdb / solib.c
index 6995e5009e29f8f5f59d51c59993ad01c2f3d906..0b511f2ab9374f5f3e60d3f4760b3f5f06ac9025 100644 (file)
-/* Copyright (C) 1990 Free Software Foundation, Inc.
+/* Handle shared libraries for GDB, the GNU Debugger.
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   2000, 2001
+   Free Software Foundation, Inc.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
 
-/*
-**     symbol definitions
-*/
 #include <sys/types.h>
-#include <string.h>
-#include <link.h>
-#include <sys/param.h>
 #include <fcntl.h>
-#include <stdio.h>
-#include "defs.h"
-#include "param.h"
+#include "gdb_string.h"
 #include "symtab.h"
+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"
 #include "gdbcore.h"
 #include "command.h"
 #include "target.h"
 #include "frame.h"
-#include "regex.h"
+#include "gdb_regex.h"
 #include "inferior.h"
+#include "environ.h"
+#include "language.h"
+#include "gdbcmd.h"
+#include "completer.h"
+
+#include "solist.h"
+
+/* external data declarations */
+
+/* FIXME: gdbarch needs to control this variable */
+struct target_so_ops *current_target_so_ops;
 
-extern char *getenv();
+/* local data declarations */
+
+static struct so_list *so_list_head;   /* List of known shared objects */
+
+static int solib_cleanup_queued = 0;   /* make_run_cleanup called */
+
+/* Local function prototypes */
+
+static void do_clear_solib (PTR);
+
+/* If non-zero, this is a prefix that will be added to the front of the name
+   shared libraries with an absolute filename for loading.  */
+static char *solib_absolute_prefix = NULL;
+
+/* If non-empty, this is a search path for loading non-absolute shared library
+   symbol files.  This takes precedence over the environment variables PATH
+   and LD_LIBRARY_PATH.  */
+static char *solib_search_path = NULL;
 
 /*
-**     local data declarations
-*/
-#define MAX_PATH_SIZE 256
-struct so_list {
-    struct link_map inferior_lm;               /* inferior link map */
-    struct link_map *inferior_lm_add;
-    long   ld_text;
-    char inferior_so_name[MAX_PATH_SIZE];      /* Shared Object Library Name */
-    struct so_list *next;                      /* Next Structure */
-    char       symbols_loaded;                 /* Flag: loaded? */
-    char       from_tty;                       /* Flag: print msgs? */
-    bfd *so_bfd;
-    struct section_table *sections;
-    struct section_table *sections_end;
-};
-
-static struct so_list *so_list_head = 0;
+
+   GLOBAL FUNCTION
+
+   solib_open -- Find a shared library file and open it.
+
+   SYNOPSIS
+
+   int solib_open (char *in_patname, char **found_pathname);
+
+   DESCRIPTION
+
+   Global variable SOLIB_ABSOLUTE_PREFIX is used as a prefix directory
+   to search for shared libraries if they have an absolute path.
+
+   Global variable SOLIB_SEARCH_PATH is used as a prefix directory
+   (or set of directories, as in LD_LIBRARY_PATH) to search for all
+   shared libraries if not found in SOLIB_ABSOLUTE_PREFIX.
+
+   Search order:
+   * If path is absolute, look in SOLIB_ABSOLUTE_PREFIX.
+   * If path is absolute or relative, look for it literally (unmodified).
+   * Look in SOLIB_SEARCH_PATH.
+   * Look in inferior's $PATH.
+   * Look in inferior's $LD_LIBRARY_PATH.
+
+   RETURNS
+
+   file handle for opened solib, or -1 for failure.  */
+
+int
+solib_open (char *in_pathname, char **found_pathname)
+{
+  int found_file = -1;
+  char *temp_pathname = NULL;
+
+  if (strchr (in_pathname, SLASH_CHAR))
+    {
+      if (! ROOTED_P (in_pathname) || solib_absolute_prefix == NULL)
+        temp_pathname = in_pathname;
+      else
+       {
+         int prefix_len = strlen (solib_absolute_prefix);
+
+         /* Remove trailing slashes from absolute prefix.  */
+         while (prefix_len > 0
+                && SLASH_P (solib_absolute_prefix[prefix_len - 1]))
+           prefix_len--;
+
+         /* Cat the prefixed pathname together.  */
+         temp_pathname = alloca (prefix_len + strlen (in_pathname) + 1);
+         strncpy (temp_pathname, solib_absolute_prefix, prefix_len);
+         temp_pathname[prefix_len] = '\0';
+         strcat (temp_pathname, in_pathname);
+       }
+
+      /* Now see if we can open it.  */
+      found_file = open (temp_pathname, O_RDONLY, 0);
+    }
+
+  /* If not found, next search the solib_search_path (if any).  */
+  if (found_file < 0 && solib_search_path != NULL)
+    found_file = openp (solib_search_path,
+                       1, in_pathname, O_RDONLY, 0, &temp_pathname);
+
+  /* If not found, next search the inferior's $PATH environment variable. */
+  if (found_file < 0 && solib_search_path != NULL)
+    found_file = openp (get_in_environ (inferior_environ, "PATH"),
+                       1, in_pathname, O_RDONLY, 0, &temp_pathname);
+
+  /* If not found, next search the inferior's $LD_LIBRARY_PATH 
+     environment variable. */
+  if (found_file < 0 && solib_search_path != NULL)
+    found_file = openp (get_in_environ (inferior_environ, "LD_LIBRARY_PATH"),
+                       1, in_pathname, O_RDONLY, 0, &temp_pathname);
+
+  /* Done.  If not found, tough luck.  Return found_file and 
+     (optionally) found_pathname.  */
+  if (found_pathname != NULL && temp_pathname != NULL)
+    *found_pathname = xstrdup (temp_pathname);
+  return found_file;
+}
+
 
 /*
-** Build a section map for a shared library, record its text size in
-** the so_list structure and set up the text section of the shared lib.
-*/
-static void
-solib_map_sections(so)
-struct so_list *so;
+
+   LOCAL FUNCTION
+
+   solib_map_sections -- open bfd and build sections for shared lib
+
+   SYNOPSIS
+
+   static int solib_map_sections (struct so_list *so)
+
+   DESCRIPTION
+
+   Given a pointer to one of the shared objects in our list
+   of mapped objects, use the recorded name to open a bfd
+   descriptor for the object, build a section table, and then
+   relocate all the section addresses by the base address at
+   which the shared object was mapped.
+
+   FIXMES
+
+   In most (all?) cases the shared object file name recorded in the
+   dynamic linkage tables will be a fully qualified pathname.  For
+   cases where it isn't, do we really mimic the systems search
+   mechanism correctly in the below code (particularly the tilde
+   expansion stuff?).
+ */
+
+static int
+solib_map_sections (PTR arg)
 {
+  struct so_list *so = (struct so_list *) arg; /* catch_errors bogon */
   char *filename;
   char *scratch_pathname;
   int scratch_chan;
   struct section_table *p;
-  
-  filename = tilde_expand (so->inferior_so_name);
-  make_cleanup (free, filename);
-  
-  scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
-                           &scratch_pathname);
-  if (scratch_chan < 0)
-    scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename, O_RDONLY, 0,
-                           &scratch_pathname);
+  struct cleanup *old_chain;
+  bfd *abfd;
+
+  filename = tilde_expand (so->so_name);
+
+  old_chain = make_cleanup (xfree, filename);
+  scratch_chan = solib_open (filename, &scratch_pathname);
+
   if (scratch_chan < 0)
-       perror_with_name (filename);
-
-  so->so_bfd = bfd_fdopenr (scratch_pathname, NULL, scratch_chan);
-  if (!so->so_bfd)
-    error ("Could not open `%s' as an executable file: %s",
-          scratch_pathname, bfd_errmsg (bfd_error));
-  if (!bfd_check_format (so->so_bfd, bfd_object))
-    error ("\"%s\": not in executable format: %s.",
-          scratch_pathname, bfd_errmsg (bfd_error));
-  if (build_section_table (so->so_bfd, &so->sections, &so->sections_end))
-    error ("Can't find the file sections in `%s': %s", 
-          exec_bfd->filename, bfd_errmsg (bfd_error));
+    {
+      perror_with_name (filename);
+    }
+
+  /* Leave scratch_pathname allocated.  abfd->name will point to it.  */
+  abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
+  if (!abfd)
+    {
+      close (scratch_chan);
+      error ("Could not open `%s' as an executable file: %s",
+            scratch_pathname, bfd_errmsg (bfd_get_error ()));
+    }
+
+  /* Leave bfd open, core_xfer_memory and "info files" need it.  */
+  so->abfd = abfd;
+  abfd->cacheable = true;
+
+  /* copy full path name into so_name, so that later symbol_file_add
+     can find it */
+  if (strlen (scratch_pathname) >= SO_NAME_MAX_PATH_SIZE)
+    error ("Full path name length of shared library exceeds SO_NAME_MAX_PATH_SIZE in so_list structure.");
+  strcpy (so->so_name, scratch_pathname);
+
+  if (!bfd_check_format (abfd, bfd_object))
+    {
+      error ("\"%s\": not in executable format: %s.",
+            scratch_pathname, bfd_errmsg (bfd_get_error ()));
+    }
+  if (build_section_table (abfd, &so->sections, &so->sections_end))
+    {
+      error ("Can't find the file sections in `%s': %s",
+            bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
+    }
 
   for (p = so->sections; p < so->sections_end; p++)
     {
-      if (strcmp (bfd_section_name (so->so_bfd, p->sec_ptr), ".text") == 0)
+      /* Relocate the section binding addresses as recorded in the shared
+         object's file by the base address to which the object was actually
+         mapped. */
+      TARGET_SO_RELOCATE_SECTION_ADDRESSES (so, p);
+      if (STREQ (p->the_bfd_section->name, ".text"))
        {
-         /* Determine length of text section and relocate it. */
-         so->ld_text = p->endaddr - p->addr;
-         p->addr += (CORE_ADDR)so->inferior_lm.lm_addr;
-         p->endaddr += (CORE_ADDR)so->inferior_lm.lm_addr;
+         so->textsection = p;
        }
-      else
-       /* All other sections are ignored for now. */
-       p->addr = p->endaddr = 0;
     }
+
+  /* Free the file names, close the file now.  */
+  do_cleanups (old_chain);
+
+  return (1);
 }
 
-/*=======================================================================*/
-
-/*     find_solib
-**
-**Description:
-**
-**     This module contains the routine which finds the names of any loaded
-**     "images" in the current process. The argument in must be NULL on the
-**     first call, and then the returned value must be passed in on
-**     subsequent calls. This provides the capability to "step" down the
-**     list of loaded objects. On the last object, a NULL value is returned.
-**     The arg and return value are "struct link_map" pointers, as defined
-**     in <link.h>.
-**
-**     NOTE: This only works under SunOS4.0.
-*/
+/* LOCAL FUNCTION
+
+   free_so --- free a `struct so_list' object
+
+   SYNOPSIS
+
+   void free_so (struct so_list *so)
+
+   DESCRIPTION
+
+   Free the storage associated with the `struct so_list' object SO.
+   If we have opened a BFD for SO, close it.  
 
-struct so_list *find_solib(so_list_ptr)
-struct so_list *so_list_ptr;                   /* so_list_head position ptr */
+   The caller is responsible for removing SO from whatever list it is
+   a member of.  If we have placed SO's sections in some target's
+   section table, the caller is responsible for removing them.
+
+   This function doesn't mess with objfiles at all.  If there is an
+   objfile associated with SO that needs to be removed, the caller is
+   responsible for taking care of that.  */
+
+void
+free_so (struct so_list *so)
 {
-struct so_list *so_list_next = 0;
-struct link_map *inferior_lm = 0;
-struct link_dynamic inferior_dynamic_cpy;
-struct link_dynamic_2 inferior_ld_2_cpy;
-struct so_list *new;
-int i;
-
-     if (!so_list_ptr) {
-        if (!(so_list_next = so_list_head)) {
-            i = lookup_misc_func ("_DYNAMIC");
-            if (i >= 0) {
-                read_memory(misc_function_vector[i].address,
-                            &inferior_dynamic_cpy,
-                            sizeof(struct link_dynamic));
-                if (inferior_dynamic_cpy.ld_version == 3) {
-                    read_memory((CORE_ADDR)inferior_dynamic_cpy.ld_un.ld_2,
-                                &inferior_ld_2_cpy,
-                                sizeof(struct link_dynamic_2));
-                    inferior_lm = inferior_ld_2_cpy.ld_loaded;
-                }
-            }
-        }
-     } else {
-        /*
-        ** Advance to next local abbreviated load_map structure
-        */
-        if (!(inferior_lm = so_list_ptr->inferior_lm.lm_next)) {
-            /* See if any were added, but be quiet if we can't read
-               from the target any more.  */
-            int status;
-
-            status = target_read_memory (
-                       (CORE_ADDR)so_list_ptr->inferior_lm_add,
-                       (char *)&so_list_ptr->inferior_lm,
-                       sizeof(struct link_map));
-            if (status == 0)
-              inferior_lm = so_list_ptr->inferior_lm.lm_next;
-            else
-              inferior_lm = 0;
-        }
-        so_list_next = so_list_ptr->next;
-     }
-     if ((!so_list_next) && inferior_lm) {
-        /* 
-        ** Get Next LM Structure from inferior image and build
-        ** an local abbreviated load_map structure
-        */
-        new = (struct so_list *) xmalloc(sizeof(struct so_list));
-         new->inferior_lm_add = inferior_lm;
-        read_memory((CORE_ADDR)inferior_lm,
-                    &new->inferior_lm,
-                    sizeof(struct link_map));
-
-        read_memory((CORE_ADDR)new->inferior_lm.lm_name,
-                    new->inferior_so_name,
-                    MAX_PATH_SIZE - 1);
-        new->inferior_so_name[MAX_PATH_SIZE - 1] = 0;
-        /* Zero everything after the first terminating null */
-        strncpy(new->inferior_so_name, new->inferior_so_name, MAX_PATH_SIZE);
-
-#if 0
-        /* This doesn't work for core files, so instead get ld_text
-           using solib_map_sections (below).  */
-        read_memory((CORE_ADDR)new->inferior_lm.lm_ld,
-                    &inferior_dynamic_cpy,
-                    sizeof(struct link_dynamic));
-        read_memory((CORE_ADDR)inferior_dynamic_cpy.ld_un.ld_2,
-                    &inferior_ld_2_cpy,
-                    sizeof(struct link_dynamic_2));
-        new->ld_text = inferior_ld_2_cpy.ld_text;
-#endif
-
-        new->next = 0;
-        new->symbols_loaded = 0;
-        new->so_bfd = NULL;
-        new->sections = NULL;
-        if (so_list_ptr)
-            so_list_ptr->next = new;
-        else
-            so_list_head = new;
-
-        solib_map_sections (new);
-
-        so_list_next = new;
-     }
-     return(so_list_next);
+  char *bfd_filename = 0;
+
+  if (so->sections)
+    xfree (so->sections);
+      
+  if (so->abfd)
+    {
+      bfd_filename = bfd_get_filename (so->abfd);
+      if (! bfd_close (so->abfd))
+       warning ("cannot close \"%s\": %s",
+                bfd_filename, bfd_errmsg (bfd_get_error ()));
+    }
+
+  if (bfd_filename)
+    xfree (bfd_filename);
+
+  TARGET_SO_FREE_SO (so);
+
+  xfree (so);
 }
 
+
 /* A small stub to get us past the arg-passing pinhole of catch_errors.  */
 
 static int
-symbol_add_stub (arg)
-     char *arg;
+symbol_add_stub (PTR arg)
 {
-  register struct so_list *so = (struct so_list *)arg; /* catch_errs bogon */
+  register struct so_list *so = (struct so_list *) arg;  /* catch_errs bogon */
+  struct section_addr_info *sap;
+
+  /* Have we already loaded this shared object?  */
+  ALL_OBJFILES (so->objfile)
+    {
+      if (strcmp (so->objfile->name, so->so_name) == 0)
+       return 1;
+    }
+
+  sap = build_section_addr_info_from_section_table (so->sections,
+                                                    so->sections_end);
+
+  so->objfile = symbol_file_add (so->so_name, so->from_tty,
+                                sap, 0, OBJF_SHARED);
+  free_section_addr_info (sap);
 
-  symbol_file_add (so->inferior_so_name, so->from_tty,
-                  (unsigned int)so->inferior_lm.lm_addr, 0);
-  return 1;
+  return (1);
 }
 
-/* The real work of adding a shared library file to the symtab and
-   the section list.  */
+
+/* LOCAL FUNCTION
+
+   update_solib_list --- synchronize GDB's shared object list with inferior's
+
+   SYNOPSIS
+
+   void update_solib_list (int from_tty, struct target_ops *TARGET)
+
+   Extract the list of currently loaded shared objects from the
+   inferior, and compare it with the list of shared objects currently
+   in GDB's so_list_head list.  Edit so_list_head to bring it in sync
+   with the inferior's new list.
+
+   If we notice that the inferior has unloaded some shared objects,
+   free any symbolic info GDB had read about those shared objects.
+
+   Don't load symbolic info for any new shared objects; just add them
+   to the list, and leave their symbols_loaded flag clear.
+
+   If FROM_TTY is non-null, feel free to print messages about what
+   we're doing.
+
+   If TARGET is non-null, add the sections of all new shared objects
+   to TARGET's section table.  Note that this doesn't remove any
+   sections for shared objects that have been unloaded, and it
+   doesn't check to see if the new shared objects are already present in
+   the section table.  But we only use this for core files and
+   processes we've just attached to, so that's okay.  */
 
 void
-solib_add (arg_string, from_tty, target)
-     char *arg_string;
-     int from_tty;
-     struct target_ops *target;
-{      
-  register struct so_list *so = 0;     /* link map state variable */
-  char *val;
-  int count, old;
-  struct section_table *sec;
-
-  if (arg_string == 0)
-      re_comp (".");
-  else if (val = (char *) re_comp (arg_string)) {
-      error ("Invalid regexp: %s", val);
-  }
+update_solib_list (int from_tty, struct target_ops *target)
+{
+  struct so_list *inferior = TARGET_SO_CURRENT_SOS ();
+  struct so_list *gdb, **gdb_link;
+
+  /* If we are attaching to a running process for which we 
+     have not opened a symbol file, we may be able to get its 
+     symbols now!  */
+  if (attach_flag &&
+      symfile_objfile == NULL)
+    catch_errors (TARGET_SO_OPEN_SYMBOL_FILE_OBJECT, (PTR) &from_tty, 
+                 "Error reading attached process's symbol file.\n",
+                 RETURN_MASK_ALL);
+
+  /* Since this function might actually add some elements to the
+     so_list_head list, arrange for it to be cleaned up when
+     appropriate.  */
+  if (!solib_cleanup_queued)
+    {
+      make_run_cleanup (do_clear_solib, NULL);
+      solib_cleanup_queued = 1;
+    }
 
-  /* Getting new symbols may change our opinion about what is
-     frameless.  */
-  reinit_frame_cache ();
+  /* GDB and the inferior's dynamic linker each maintain their own
+     list of currently loaded shared objects; we want to bring the
+     former in sync with the latter.  Scan both lists, seeing which
+     shared objects appear where.  There are three cases:
+
+     - A shared object appears on both lists.  This means that GDB
+     knows about it already, and it's still loaded in the inferior.
+     Nothing needs to happen.
+
+     - A shared object appears only on GDB's list.  This means that
+     the inferior has unloaded it.  We should remove the shared
+     object from GDB's tables.
+
+     - A shared object appears only on the inferior's list.  This
+     means that it's just been loaded.  We should add it to GDB's
+     tables.
+
+     So we walk GDB's list, checking each entry to see if it appears
+     in the inferior's list too.  If it does, no action is needed, and
+     we remove it from the inferior's list.  If it doesn't, the
+     inferior has unloaded it, and we remove it from GDB's list.  By
+     the time we're done walking GDB's list, the inferior's list
+     contains only the new shared objects, which we then add.  */
+
+  gdb = so_list_head;
+  gdb_link = &so_list_head;
+  while (gdb)
+    {
+      struct so_list *i = inferior;
+      struct so_list **i_link = &inferior;
 
-  if (from_tty) {
-    printf_filtered ("Shared libraries");
-    if (arg_string)
-      printf_filtered (" matching regular expresion \"%s\"", arg_string);
-    printf_filtered (":\n");
-  }
-  
-  dont_repeat();
+      /* Check to see whether the shared object *gdb also appears in
+        the inferior's current list.  */
+      while (i)
+       {
+         if (! strcmp (gdb->so_original_name, i->so_original_name))
+           break;
 
-  while (so = find_solib(so)) {
-      if (re_exec(so->inferior_so_name)) {
-         if (so->symbols_loaded) {
-             if (from_tty)
-               printf("Symbols already loaded for %s\n", so->inferior_so_name);
-         } else {
-             so->symbols_loaded = 1;
-             so->from_tty = from_tty;
-                     catch_errors (symbol_add_stub, (char *)so,
-                   "Error while reading shared library symbols:\n");
-         }
-      }
-  }
+         i_link = &i->next;
+         i = *i_link;
+       }
+
+      /* If the shared object appears on the inferior's list too, then
+         it's still loaded, so we don't need to do anything.  Delete
+         it from the inferior's list, and leave it on GDB's list.  */
+      if (i)
+       {
+         *i_link = i->next;
+         free_so (i);
+         gdb_link = &gdb->next;
+         gdb = *gdb_link;
+       }
+
+      /* If it's not on the inferior's list, remove it from GDB's tables.  */
+      else
+       {
+         *gdb_link = gdb->next;
 
-  /* Now add the shared library sections to the section table of the
-     specified target, if any.  */
-  if (target) {
-    /* Count how many new section_table entries there are.  */
-    so = 0;
-    count = 0;
-    while (0 != (so = find_solib (so))) {
-      count += so->sections_end - so->sections;
+         /* Unless the user loaded it explicitly, free SO's objfile.  */
+         if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED))
+           free_objfile (gdb->objfile);
+
+         /* Some targets' section tables might be referring to
+            sections from so->abfd; remove them.  */
+         remove_target_sections (gdb->abfd);
+
+         free_so (gdb);
+         gdb = *gdb_link;
+       }
     }
 
-    if (count) {
-      /* Reallocate the target's section table including the new size.  */
-      if (target->sections) {
-       old = target->sections_end - target->sections;
-       target->sections = (struct section_table *)
-           realloc ((char *)target->sections,
-             (sizeof (struct section_table)) * (count + old));
-      } else {
-       old = 0;
-       target->sections = (struct section_table *)
-           malloc ((sizeof (struct section_table)) * count);
-      }
-      target->sections_end = target->sections + (count + old);
-
-      /* Add these section table entries to the target's table.  */
-      while (0 != (so = find_solib (so))) {
-       count = so->sections_end - so->sections;
-       bcopy (so->sections, (char *)(target->sections + old), 
-              (sizeof (struct section_table)) * count);
-       old += count;
-      }
+  /* Now the inferior's list contains only shared objects that don't
+     appear in GDB's list --- those that are newly loaded.  Add them
+     to GDB's shared object list.  */
+  if (inferior)
+    {
+      struct so_list *i;
+
+      /* Add the new shared objects to GDB's list.  */
+      *gdb_link = inferior;
+
+      /* Fill in the rest of each of the `struct so_list' nodes.  */
+      for (i = inferior; i; i = i->next)
+       {
+         i->from_tty = from_tty;
+
+         /* Fill in the rest of the `struct so_list' node.  */
+         catch_errors (solib_map_sections, i,
+                       "Error while mapping shared library sections:\n",
+                       RETURN_MASK_ALL);
+       }
+
+      /* If requested, add the shared objects' sections to the the
+        TARGET's section table.  */
+      if (target)
+       {
+         int new_sections;
+
+         /* Figure out how many sections we'll need to add in total.  */
+         new_sections = 0;
+         for (i = inferior; i; i = i->next)
+           new_sections += (i->sections_end - i->sections);
+
+         if (new_sections > 0)
+           {
+             int space = target_resize_to_sections (target, new_sections);
+
+             for (i = inferior; i; i = i->next)
+               {
+                 int count = (i->sections_end - i->sections);
+                 memcpy (target->to_sections + space,
+                         i->sections,
+                         count * sizeof (i->sections[0]));
+                 space += count;
+               }
+           }
+       }
     }
-  }
 }
 
-/*=======================================================================*/
 
-static void solib_info()
+/* GLOBAL FUNCTION
+
+   solib_add -- read in symbol info for newly added shared libraries
+
+   SYNOPSIS
+
+   void solib_add (char *pattern, int from_tty, struct target_ops *TARGET)
+
+   DESCRIPTION
+
+   Read in symbolic information for any shared objects whose names
+   match PATTERN.  (If we've already read a shared object's symbol
+   info, leave it alone.)  If PATTERN is zero, read them all.
+
+   FROM_TTY and TARGET are as described for update_solib_list, above.  */
+
+void
+solib_add (char *pattern, int from_tty, struct target_ops *target)
 {
-register struct so_list *so = 0;       /* link map state variable */
+  struct so_list *gdb;
 
-    while (so = find_solib(so)) {
-       if (so == so_list_head) {
-           printf("      Address Range     Syms Read    Shared Object Library\n");
-       }
-       printf(" 0x%08x - 0x%08x   %s   %s\n", 
-           so->inferior_lm.lm_addr, 
-           so->inferior_lm.lm_addr + so->ld_text - 1,
-           (so->symbols_loaded ? "Yes" : "No "),
-           so->inferior_so_name);
-    }
-    if (!so_list_head) {
-       printf("No shared libraries loaded at this time.\n");   
+  if (pattern)
+    {
+      char *re_err = re_comp (pattern);
+
+      if (re_err)
+       error ("Invalid regexp: %s", re_err);
     }
+
+  update_solib_list (from_tty, target);
+
+  /* Walk the list of currently loaded shared libraries, and read
+     symbols for any that match the pattern --- or any whose symbols
+     aren't already loaded, if no pattern was given.  */
+  {
+    int any_matches = 0;
+    int loaded_any_symbols = 0;
+
+    for (gdb = so_list_head; gdb; gdb = gdb->next)
+      if (! pattern || re_exec (gdb->so_name))
+       {
+         any_matches = 1;
+
+         if (gdb->symbols_loaded)
+           {
+             if (from_tty)
+               printf_unfiltered ("Symbols already loaded for %s\n",
+                                  gdb->so_name);
+           }
+         else
+           {
+             if (catch_errors
+                 (symbol_add_stub, gdb,
+                  "Error while reading shared library symbols:\n",
+                  RETURN_MASK_ALL))
+               {
+                 if (from_tty)
+                   printf_unfiltered ("Loaded symbols for %s\n",
+                                      gdb->so_name);
+                 gdb->symbols_loaded = 1;
+                 loaded_any_symbols = 1;
+               }
+           }
+       }
+
+    if (from_tty && pattern && ! any_matches)
+      printf_unfiltered
+       ("No loaded shared libraries match the pattern `%s'.\n", pattern);
+
+    if (loaded_any_symbols)
+      {
+       /* Getting new symbols may change our opinion about what is
+          frameless.  */
+       reinit_frame_cache ();
+
+       TARGET_SO_SPECIAL_SYMBOL_HANDLING ();
+      }
+  }
 }
 
+
 /*
-** Called by Insert Breakpoint to see if Address is Shared Library Address 
-*/
-int
-solib_address(address)
-     CORE_ADDR address;
+
+   LOCAL FUNCTION
+
+   info_sharedlibrary_command -- code for "info sharedlibrary"
+
+   SYNOPSIS
+
+   static void info_sharedlibrary_command ()
+
+   DESCRIPTION
+
+   Walk through the shared library list and print information
+   about each attached library.
+ */
+
+static void
+info_sharedlibrary_command (char *ignore, int from_tty)
 {
-register struct so_list *so = 0;       /* link map state variable */
+  register struct so_list *so = NULL;  /* link map state variable */
+  int header_done = 0;
+  int addr_width;
+  char *addr_fmt;
+  int arch_size;
+
+  if (exec_bfd == NULL)
+    {
+      printf_unfiltered ("No executable file.\n");
+      return;
+    }
+
+  arch_size = bfd_get_arch_size (exec_bfd);
+  /* Default to 32-bit in case of failure (non-elf). */
+  if (arch_size == 32 || arch_size == -1)
+    {
+      addr_width = 8 + 4;
+      addr_fmt = "08l";
+    }
+  else if (arch_size == 64)
+    {
+      addr_width = 16 + 4;
+      addr_fmt = "016l";
+    }
+  else
+    {
+      internal_error (__FILE__, __LINE__,
+                     "bfd_get_arch_size() returned unknown size %d",
+                     arch_size);
+    }
+
+  update_solib_list (from_tty, 0);
 
-    while (so = find_solib(so)) {
-       if ((address >= (CORE_ADDR) so->inferior_lm.lm_addr) &&
-           (address < (CORE_ADDR) so->inferior_lm.lm_addr + so->ld_text))
-         return 1;
+  for (so = so_list_head; so; so = so->next)
+    {
+      if (so->so_name[0])
+       {
+         if (!header_done)
+           {
+             printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From",
+                                addr_width, "To", "Syms Read",
+                                "Shared Object Library");
+             header_done++;
+           }
+
+         printf_unfiltered ("%-*s", addr_width,
+                            so->textsection != NULL 
+                              ? longest_local_hex_string_custom (
+                                  (LONGEST) so->textsection->addr,
+                                  addr_fmt)
+                              : "");
+         printf_unfiltered ("%-*s", addr_width,
+                            so->textsection != NULL 
+                              ? longest_local_hex_string_custom (
+                                  (LONGEST) so->textsection->endaddr,
+                                  addr_fmt)
+                              : "");
+         printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
+         printf_unfiltered ("%s\n", so->so_name);
+       }
+    }
+  if (so_list_head == NULL)
+    {
+      printf_unfiltered ("No shared libraries loaded at this time.\n");
     }
-    return 0;
 }
 
 /*
-** Called by free_all_symtabs
-*/
-void 
-clear_solib()
-{
-struct so_list *next;
-
-  while (so_list_head) {
-    if (so_list_head->sections)
-      free (so_list_head->sections);
-    if (so_list_head->so_bfd)
-      bfd_close (so_list_head->so_bfd);
-    next = so_list_head->next;
-    free(so_list_head);
-    so_list_head = next;
-  }
-}
 
-/* Called by child_create_inferior when the inferior is stopped at its
-   first instruction.  */
+   GLOBAL FUNCTION
 
-void 
-solib_create_inferior_hook()
+   solib_address -- check to see if an address is in a shared lib
+
+   SYNOPSIS
+
+   char * solib_address (CORE_ADDR address)
+
+   DESCRIPTION
+
+   Provides a hook for other gdb routines to discover whether or
+   not a particular address is within the mapped address space of
+   a shared library.
+
+   For example, this routine is called at one point to disable
+   breakpoints which are in shared libraries that are not currently
+   mapped in.
+ */
+
+char *
+solib_address (CORE_ADDR address)
 {
-  struct link_dynamic inferior_dynamic_cpy;
-  CORE_ADDR inferior_debug_addr;
-  struct ld_debug inferior_debug_cpy;
-  int in_debugger;
-  CORE_ADDR in_debugger_addr;
-  CORE_ADDR breakpoint_addr;
-  int i, j;
-
-  /* FIXME:  We should look around in the executable code to find _DYNAMIC,
-     if it isn't in the symbol table.  It's not that hard to find... 
-     Then we can debug stripped executables using shared library symbols.  */
-  i = lookup_misc_func ("_DYNAMIC");
-  if (i < 0)                   /* Can't find shared lib ptr. */
-    return;
-  if (misc_function_vector[i].address == 0)    /* statically linked program */
-    return;
-
-  /* Get link_dynamic structure */
-  j = target_read_memory(misc_function_vector[i].address,
-             &inferior_dynamic_cpy,
-             sizeof(struct link_dynamic));
-  if (j)                                       /* unreadable */
-    return;
-
-  /* Calc address of debugger interface structure */
-  inferior_debug_addr = (CORE_ADDR)inferior_dynamic_cpy.ldd;
-  /* Calc address of `in_debugger' member of debugger interface structure */
-  in_debugger_addr = inferior_debug_addr + (CORE_ADDR)((char *)&inferior_debug_cpy.ldd_in_debugger - (char *)&inferior_debug_cpy);
-  /* Write a value of 1 to this member.  */
-  in_debugger = 1;
-  write_memory(in_debugger_addr, &in_debugger, sizeof(in_debugger));
-
-  /* Now run the target.  Seeing `in_debugger' set, it will set a
-     breakpoint at some convenient place, remember the original contents
-     of that place, and eventually take a SIGTRAP when it runs into the
-     breakpoint.  We handle this by restoring the contents of the
-     breakpointed location (which is only known after it stops), 
-     chasing around to locate the shared libraries that have been
-     loaded, then resuming.  */
-
-  clear_proceed_status ();
-  stop_soon_quietly = 1;
-  target_resume (0, 0);
-  wait_for_inferior ();
-  while (stop_signal != SIGTRAP)
+  register struct so_list *so = 0;     /* link map state variable */
+
+  for (so = so_list_head; so; so = so->next)
     {
-      /* FIXME, what if child has exit()ed?  Must exit loop somehow */
-      target_resume (0, stop_signal);
-      wait_for_inferior ();
+      struct section_table *p;
+
+      for (p = so->sections; p < so->sections_end; p++)
+       {
+         if (p->addr <= address && address < p->endaddr)
+           return (so->so_name);
+       }
     }
-  stop_soon_quietly = 0;
-
-  /* Set `in_debugger' to zero now.  WHY, is this needed?  */
-  in_debugger = 0;
-  write_memory(in_debugger_addr, &in_debugger, sizeof(in_debugger));
-  read_memory(inferior_debug_addr, &inferior_debug_cpy, sizeof(inferior_debug_cpy));
-  /* FIXME: maybe we should add the common symbols from the ldd_cp chain
-   * to the misc_function_vector ?
-   */
-  breakpoint_addr = (CORE_ADDR)inferior_debug_cpy.ldd_bp_addr;
-  if (stop_pc - DECR_PC_AFTER_BREAK == breakpoint_addr)
+
+  return (0);
+}
+
+/* Called by free_all_symtabs */
+
+void
+clear_solib (void)
+{
+  /* This function is expected to handle ELF shared libraries.  It is
+     also used on Solaris, which can run either ELF or a.out binaries
+     (for compatibility with SunOS 4), both of which can use shared
+     libraries.  So we don't know whether we have an ELF executable or
+     an a.out executable until the user chooses an executable file.
+
+     ELF shared libraries don't get mapped into the address space
+     until after the program starts, so we'd better not try to insert
+     breakpoints in them immediately.  We have to wait until the
+     dynamic linker has loaded them; we'll hit a bp_shlib_event
+     breakpoint (look for calls to create_solib_event_breakpoint) when
+     it's ready.
+
+     SunOS shared libraries seem to be different --- they're present
+     as soon as the process begins execution, so there's no need to
+     put off inserting breakpoints.  There's also nowhere to put a
+     bp_shlib_event breakpoint, so if we put it off, we'll never get
+     around to it.
+
+     So: disable breakpoints only if we're using ELF shared libs.  */
+  if (exec_bfd != NULL
+      && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
+    disable_breakpoints_in_shlibs (1);
+
+  while (so_list_head)
     {
-      write_memory(breakpoint_addr, &inferior_debug_cpy.ldd_bp_inst, sizeof(inferior_debug_cpy.ldd_bp_inst));
-      if (DECR_PC_AFTER_BREAK)
-        {
-          stop_pc -= DECR_PC_AFTER_BREAK;
-          write_register (PC_REGNUM, stop_pc);
-        }
+      struct so_list *so = so_list_head;
+      so_list_head = so->next;
+      free_so (so);
     }
-  solib_add ((char *)0, 0, (struct target_ops *)0);
+
+  TARGET_SO_CLEAR_SOLIB ();
 }
 
+static void
+do_clear_solib (PTR dummy)
+{
+  solib_cleanup_queued = 0;
+  clear_solib ();
+}
+
+/* GLOBAL FUNCTION
+
+   solib_create_inferior_hook -- shared library startup support
+
+   SYNOPSIS
+
+   void solib_create_inferior_hook()
+
+   DESCRIPTION
+
+   When gdb starts up the inferior, it nurses it along (through the
+   shell) until it is ready to execute it's first instruction.  At this
+   point, this function gets called via expansion of the macro
+   SOLIB_CREATE_INFERIOR_HOOK.  */
+
 void
-sharedlibrary_command (args, from_tty)
+solib_create_inferior_hook (void)
 {
-  solib_add (args, from_tty, (struct target_ops *)0);
+  TARGET_SO_SOLIB_CREATE_INFERIOR_HOOK ();
 }
 
+/* GLOBAL FUNCTION
+
+   in_solib_dynsym_resolve_code -- check to see if an address is in
+                                   dynamic loader's dynamic symbol
+                                  resolution code
+
+   SYNOPSIS
+
+   int in_solib_dynsym_resolve_code (CORE_ADDR pc)
+
+   DESCRIPTION
+
+   Determine if PC is in the dynamic linker's symbol resolution
+   code.  Return 1 if so, 0 otherwise.
+*/
+
+int
+in_solib_dynsym_resolve_code (CORE_ADDR pc)
+{
+  return TARGET_SO_IN_DYNSYM_RESOLVE_CODE (pc);
+}
+
+/*
+
+   LOCAL FUNCTION
+
+   sharedlibrary_command -- handle command to explicitly add library
+
+   SYNOPSIS
+
+   static void sharedlibrary_command (char *args, int from_tty)
+
+   DESCRIPTION
+
+ */
+
+static void
+sharedlibrary_command (char *args, int from_tty)
+{
+  dont_repeat ();
+  solib_add (args, from_tty, (struct target_ops *) 0);
+}
+
+
 void
-_initialize_solib()
+_initialize_solib (void)
 {
+  struct cmd_list_element *c;
 
-  add_com("sharedlibrary", class_files, sharedlibrary_command,
+  add_com ("sharedlibrary", class_files, sharedlibrary_command,
           "Load shared object library symbols for files matching REGEXP.");
-  add_info("sharedlibrary", solib_info, 
-          "Status of loaded shared object libraries");
+  add_info ("sharedlibrary", info_sharedlibrary_command,
+           "Status of loaded shared object libraries.");
+
+  add_show_from_set
+    (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
+                 (char *) &auto_solib_add,
+                 "Set autoloading of shared library symbols.\n\
+If nonzero, symbols from all shared object libraries will be loaded\n\
+automatically when the inferior begins execution or when the dynamic linker\n\
+informs gdb that a new library has been loaded.  Otherwise, symbols\n\
+must be loaded manually, using `sharedlibrary'.",
+                 &setlist),
+     &showlist);
+
+  c = add_set_cmd ("solib-absolute-prefix", class_support, var_filename,
+                  (char *) &solib_absolute_prefix,
+                  "Set prefix for loading absolute shared library symbol files.\n\
+For other (relative) files, you can add values using `set solib-search-path'.",
+                  &setlist);
+  add_show_from_set (c, &showlist);
+  c->completer = filename_completer;
+
+  c = add_set_cmd ("solib-search-path", class_support, var_string,
+                  (char *) &solib_search_path,
+                  "Set the search path for loading non-absolute shared library symbol files.\n\
+This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
+                  &setlist);
+  add_show_from_set (c, &showlist);
+  c->completer = filename_completer;
 }
This page took 0.045397 seconds and 4 git commands to generate.