Numerous small changes and a complete reorganization of solib.c, to support
authorFred Fish <fnf@specifix.com>
Mon, 16 Dec 1991 20:57:28 +0000 (20:57 +0000)
committerFred Fish <fnf@specifix.com>
Mon, 16 Dec 1991 20:57:28 +0000 (20:57 +0000)
SVR4 shared libraries in a manner very close to the original SunOS support.
See the ChangeLog for details.

gdb/ChangeLog
gdb/dwarfread.c
gdb/elfread.c
gdb/procfs.c
gdb/solib.c
gdb/tm-svr4.h

index d57bf91..3d20936 100644 (file)
@@ -1,3 +1,47 @@
+Mon Dec 16 12:31:46 1991  Fred Fish  (fnf at cygnus.com)
+
+       * solib.c:  Completely reorganized (rewritten) to support
+       SVR4 shared libraries in a manner very close to the original
+       SunOS implementation.  This support is expected to change and
+       become more general at some future time.  The SVR4 version
+       does not yet work for attached processes, for example.
+
+       * dwarfread.c:  Arrange in dwarf_build_psymtabs() for the 
+       relocation address to be valid whether or not symbols are
+       being read from a shared library or an executable.  Use the
+       relocation address recorded in the psymtab when reading
+       full symbol tables (in read_ofile_symtab).  Ensure that the
+       relocated address ranges are recorded in partial symtabs.
+
+       * elfread.c:  Add new function elf_interpreter() to return the
+       string from the ELF ".interp" section.  This is the interpreter
+       that the kernel tries to run and feed the executable to.
+       Expand arguments to record_misc_function to include a type arg.
+       Modify elf_symtab_read() to supply the type arg, and to do symbol
+       relocations for symbols read in from shared libraries.
+
+       * procfs.c:  Add new functions proc_base_address() and
+       proc_address_to_fd(), used by shared library support.
+
+       * tm-svr4.h:  Add macros to support SVR4 shared libraries.
+       Definitions for SOLIB_ADD, SOLIB_CREATE_INFERIOR_HOOK,
+       CLEAR_SOLIB, and DISABLE_UNSETTABLE_BREAK.
+
+Fri Dec 13 20:11:26 1991  John Gilmore  (gnu at cygnus.com)
+
+       * infrun.c, remote-eb.c, remote-nindy.c, remote-vx.c:  Remove
+       unused START_INFERIOR_HOOK.
+
+       * remote-eb.c:  Change timeout to 24 seconds (*10 fits in byte)
+       to account for slow loading from floppies.
+       (eb_create_inferior):  New fn, from eb_start and
+       nindy_create_inferior.
+       (eb_close):  Only use log_file if nonzero.
+       (eb_xfer_memory):  If not writing, then read!
+       (eb_read_inferior_memory, eb_write_inferior_memory):  Return length.
+       (eb_kill):  A new no-op.
+       (eb_mourn_inferior):  Remove breakpoints, then generically weep.
+
 Fri Dec 13 16:09:23 1991  Fred Fish  (fnf at cygnus.com)
 
        * breakpoint.c, findvar.c, infrun.c, putenv.c, stack.c:  Fix
@@ -5,6 +49,21 @@ Fri Dec 13 16:09:23 1991  Fred Fish  (fnf at cygnus.com)
        compiler warnings about comparison of integer with pointer, when
        NULL is ((void *) 0) rather than just a bare 0.
 
+Wed Dec 11 13:02:58 1991  John Gilmore  (gnu at cygnus.com)
+
+       * breakpoint.c (breakpoint_re_set_one):  Disable each breakpoint
+       while we reset it, in case of problems.  Print breakpoint number
+       in error messages.
+
+       * buildsym.c (read_struct_type):  Avoid sun3 compiler bug with
+       foo[--n].
+
+       * source.c (find_source_lines): If getting file mod time fails,
+       don't warn.
+
+       * target.c (target_xfer_memory):  If errno is set, return it,
+       rather than EIO.
+
 Tue Dec 10 04:07:22 1991  K. Richard Pixley  (rich at rtl.cygnus.com)
 
        * Makefile.in: infodir belongs in datadir.
index ab5b27f..65a4c3f 100644 (file)
@@ -535,6 +535,14 @@ DEFUN(dwarf_build_psymtabs,
       init_psymbol_list (1024);
     }
   
+  /* From this point on, we don't need to pass mainline around, so zap
+     addr to zero if we don't need relocation. */
+
+  if (mainline)
+    {
+      addr = 0;
+    }
+
   /* Follow the compilation unit sibling chain, building a partial symbol
      table entry for each one.  Save enough information about each compilation
      unit to locate the full DWARF information later. */
@@ -2356,7 +2364,6 @@ SYNOPSIS
 
 DESCRIPTION
 
-       OFFSET is a relocation offset which gets added to each symbol (FIXME).
  */
 
 static struct symtab *
@@ -2375,6 +2382,7 @@ DEFUN(read_ofile_symtab, (pst),
   dbbase = xmalloc (DBLENGTH(pst));
   dbroff = DBROFF(pst);
   foffset = DBFOFF(pst) + dbroff;
+  baseaddr = pst -> addr;
   if (bfd_seek (abfd, foffset, 0) ||
       (bfd_read (dbbase, DBLENGTH(pst), 1, abfd) != DBLENGTH(pst)))
     {
@@ -2407,7 +2415,7 @@ DEFUN(read_ofile_symtab, (pst),
       make_cleanup (free, lnbase);
     }
 
-  process_dies (dbbase, dbbase + DBLENGTH(pst), pst->objfile);
+  process_dies (dbbase, dbbase + DBLENGTH(pst), pst -> objfile);
   do_cleanups (back_to);
   return (symtab_list);
 }
@@ -2467,7 +2475,6 @@ DEFUN(psymtab_to_symtab_1,
   
   if (DBLENGTH(pst))           /* Otherwise it's a dummy */
     {
-      /* Init stuff necessary for reading in symbols */
       pst -> symtab = read_ofile_symtab (pst);
       if (info_verbose)
        {
@@ -2958,7 +2965,8 @@ DEFUN(scan_compilation_units,
          culength = nextdie - thisdie;
          curlnoffset = di.has_at_stmt_list ? lnoffset + di.at_stmt_list : 0;
          pst = start_psymtab (objfile, addr, di.at_name,
-                                    di.at_low_pc, di.at_high_pc,
+                                    di.at_low_pc + addr,
+                                    di.at_high_pc + addr,
                                     dbfoff, curoff, culength, curlnoffset,
                                     global_psymbols.next,
                                     static_psymbols.next);
index 5de3cd7..c7783e1 100644 (file)
@@ -93,6 +93,32 @@ DEFUN(elf_locate_sections, (abfd, sectp, ei),
     }
 }
 
+char *
+DEFUN(elf_interpreter, (abfd),
+      bfd *abfd)
+{
+  sec_ptr interp_sec;
+  unsigned size;
+  char *interp = NULL;
+
+  interp_sec = bfd_get_section_by_name (abfd, ".interp");
+  if (interp_sec)
+    {
+      size = bfd_section_size (abfd, interp_sec);
+      interp = alloca (size);
+      if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0,
+                                   size))
+       {
+         interp = savestring (interp, size - 1);
+       }
+      else
+       {
+         interp = NULL;
+       }
+    }
+  return (interp);
+}
+
 /*
 
 LOCAL FUNCTION
@@ -117,16 +143,37 @@ NOTES
  */
 
 static void
-DEFUN(record_misc_function, (name, address), char *name AND CORE_ADDR address)
+DEFUN(record_misc_function, (name, address, mf_type),
+      char *name AND CORE_ADDR address AND enum misc_function_type mf_type)
 {
   prim_record_misc_function (obsavestring (name, strlen (name)), address,
-                            mf_unknown);
+                            mf_type);
 }
 
+/*
+
+LOCAL FUNCTION
+
+       elf_symtab_read -- read the symbol table of an ELF file
+
+SYNOPSIS
+
+       void elf_symtab_read (bfd *abfd, CORE_ADDR addr, int mainline)
+
+DESCRIPTION
+
+       Given an open bfd, a base address to relocate symbols to, and a
+       flag that specifies whether or not this bfd is for an executable
+       or not (may be shared library for example), add all the global
+       function and data symbols to the miscellaneous function vector.
+
+*/
+
 static void
-DEFUN (elf_symtab_read, (abfd, addr),
+DEFUN (elf_symtab_read, (abfd, addr, mainline),
        bfd *abfd AND
-       CORE_ADDR addr)
+       CORE_ADDR addr AND
+       int mainline)
 {
   unsigned int storage_needed;
   asymbol *sym;
@@ -134,6 +181,8 @@ DEFUN (elf_symtab_read, (abfd, addr),
   unsigned int number_of_symbols;
   unsigned int i;
   struct cleanup *back_to;
+  CORE_ADDR symaddr;
+  enum misc_function_type mf_type;
   
   storage_needed = get_symtab_upper_bound (abfd);
 
@@ -151,7 +200,28 @@ DEFUN (elf_symtab_read, (abfd, addr),
          if (sym -> flags & BSF_GLOBAL
              && ((sym -> section != NULL) || (sym -> flags & BSF_ABSOLUTE)))
            {
-             record_misc_function ((char *) sym -> name, sym -> value);
+             symaddr = sym -> value;
+             if (!mainline)
+               {
+                 /* Relocate all symbols by base address */
+                 symaddr += addr;
+               }
+             /* For non-absolute symbols, use the type of the section
+                they are relative to, to intuit text/data.  Bfd provides
+                no way of figuring this out for absolute symbols. */
+             if (sym -> section && (sym -> section -> flags & SEC_CODE))
+               {
+                 mf_type = mf_text;
+               }
+             else if (sym -> section && (sym -> section -> flags & SEC_DATA))
+               {
+                 mf_type = mf_data;
+               }
+             else
+               {
+                 mf_type = mf_unknown;
+               }
+             record_misc_function ((char *) sym -> name, symaddr, mf_type);
            }
        }
       do_cleanups (back_to);
@@ -199,7 +269,7 @@ DEFUN(elf_symfile_read, (sf, addr, mainline),
 
   /* Process the normal ELF symbol table first. */
 
-  elf_symtab_read (abfd, addr);
+  elf_symtab_read (abfd, addr, mainline);
 
   /* Now process the DWARF debugging information, which is contained in
      special ELF sections.  We first have to find them... */
@@ -208,7 +278,6 @@ DEFUN(elf_symfile_read, (sf, addr, mainline),
   bfd_map_over_sections (abfd, elf_locate_sections, &ei);
   if (ei.dboffset && ei.lnoffset)
     {
-      addr = 0;        /* FIXME: force address base to zero for now */
       dwarf_build_psymtabs (fileno ((FILE *)(abfd -> iostream)),
                            bfd_get_filename (abfd),
                            addr, mainline,
index 95947e8..7990b10 100644 (file)
@@ -451,6 +451,93 @@ DEFUN_VOID(proc_set_exec_trap)
     }
 }
 
+/*
+
+GLOBAL FUNCTION
+
+       proc_base_address -- find base address for segment containing address
+
+SYNOPSIS
+
+       CORE_ADDR proc_base_address (CORE_ADDR addr)
+
+DESCRIPTION
+
+       Given an address of a location in the inferior, find and return
+       the base address of the mapped segment containing that address.
+
+       This is used for example, by the shared library support code,
+       where we have the pc value for some location in the shared library
+       where we are stopped, and need to know the base address of the
+       segment containing that address.
+*/
+
+
+CORE_ADDR
+DEFUN(proc_base_address, (addr),
+      CORE_ADDR addr)
+{
+  int nmap;
+  struct prmap *prmaps;
+  struct prmap *prmap;
+  CORE_ADDR baseaddr = 0;
+
+  if (ioctl (pi.fd, PIOCNMAP, &nmap) == 0)
+    {
+      prmaps = alloca ((nmap + 1) * sizeof (*prmaps));
+      if (ioctl (pi.fd, PIOCMAP, prmaps) == 0)
+       {
+         for (prmap = prmaps; prmap -> pr_size; ++prmap)
+           {
+             if ((prmap -> pr_vaddr <= (caddr_t) addr) &&
+                 (prmap -> pr_vaddr + prmap -> pr_size > (caddr_t) addr))
+               {
+                 baseaddr = (CORE_ADDR) prmap -> pr_vaddr;
+                 break;
+               }
+           }
+       }
+    }
+  return (baseaddr);
+}
+
+/*
+
+GLOBAL_FUNCTION
+
+       proc_address_to_fd -- return open fd for file mapped to address
+
+SYNOPSIS
+
+       int proc_address_to_fd (CORE_ADDR addr)
+
+DESCRIPTION
+
+       Given an address in the current inferior's address space, use the
+       /proc interface to find an open file descriptor for the file that
+       this address was mapped in from.  Return -1 if there is no current
+       inferior.  Print a warning message if there is an inferior but
+       the address corresponds to no file (IE a bogus address).
+
+*/
+
+int
+DEFUN(proc_address_to_fd, (addr),
+      CORE_ADDR addr)
+{
+  int fd = -1;
+
+  if (pi.valid)
+    {
+      if ((fd = ioctl (pi.fd, PIOCOPENM, (caddr_t *) &addr)) < 0)
+       {
+         print_sys_errmsg (pi.pathname, errno);
+         warning ("can't find mapped file for address 0x%x", addr);
+       }
+    }
+  return (fd);
+}
+
 
 #ifdef ATTACH_DETACH
 
index 6995e50..b1c78a4 100644 (file)
@@ -1,5 +1,6 @@
-/* Copyright (C) 1990 Free Software Foundation, Inc.
-
+/* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger.
+   Copyright 1990, 1991 Free Software Foundation, Inc.
+   
 This file is part of GDB.
 
 This program is free software; you can redistribute it and/or modify
@@ -16,17 +17,16 @@ 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.  */
 
-/*
-**     symbol definitions
-*/
+
 #include <sys/types.h>
+#include <signal.h>
 #include <string.h>
 #include <link.h>
 #include <sys/param.h>
 #include <fcntl.h>
 #include <stdio.h>
+
 #include "defs.h"
-#include "param.h"
 #include "symtab.h"
 #include "gdbcore.h"
 #include "command.h"
@@ -35,183 +35,510 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "regex.h"
 #include "inferior.h"
 
-extern char *getenv();
+extern char *getenv ();
+extern char *elf_interpreter ();       /* Interpreter name from exec file */
+extern char *re_comp ();
+
+#define MAX_PATH_SIZE 256              /* FIXME: Should be dynamic */
+
+/* On SVR4 systems, for the initial implementation, use main() as the
+   "startup mapping complete" breakpoint address.  The models for SunOS
+   and SVR4 dynamic linking debugger support are different in that SunOS
+   hits one breakpoint when all mapping is complete while using the SVR4
+   debugger support takes two breakpoint hits for each file mapped, and
+   there is no way to know when the "last" one is hit.  Both these
+   mechanisms should be tied to a "breakpoint service routine" that
+   gets automatically executed whenever one of the breakpoints indicating
+   a change in mapping is hit.  This is a future enhancement.  (FIXME) */
+
+#define BKPT_AT_MAIN 1
+
+/* local data declarations */
+
+#ifdef sun
+
+#define DEBUG_BASE "_DYNAMIC"
+#define LM_ADDR(so) ((so) -> lm.lm_addr)
+#define LM_NEXT(so) ((so) -> lm.lm_next)
+#define LM_NAME(so) ((so) -> lm.lm_name)
+static struct link_dynamic dynamic_copy;
+static struct link_dynamic_2 ld_2_copy;
+static struct ld_debug debug_copy;
+static CORE_ADDR debug_addr;
+static CORE_ADDR flag_addr;
+
+#else  /* !sun */
+
+#define DEBUG_BASE "_r_debug"
+#define LM_ADDR(so) ((so) -> lm.l_addr)
+#define LM_NEXT(so) ((so) -> lm.l_next)
+#define LM_NAME(so) ((so) -> lm.l_name)
+static struct r_debug debug_copy;
+static CORE_ADDR shlib_base;           /* Base address of shared library */
+char shadow_contents[BREAKPOINT_MAX];  /* Stash old bkpt addr contents */
+extern CORE_ADDR proc_base_address ();
+extern int proc_address_to_fd ();
+
+#endif /* sun */
 
-/*
-**     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;
+  struct so_list *next;                        /* next structure in linked list */
+  struct link_map lm;                  /* copy of link map from inferior */
+  struct link_map *lmaddr;             /* addr in inferior lm was read from */
+  CORE_ADDR lmend;                     /* upper addr bound of mapped object */
+  char so_name[MAX_PATH_SIZE];         /* shared object lib name (FIXME) */
+  char symbols_loaded;                 /* flag: symbols read in yet? */
+  char from_tty;                       /* flag: print msgs? */
+  bfd *so_bfd;                         /* bfd for so_name */
+  struct section_table *sections;
+  struct section_table *sections_end;
 };
 
-static struct so_list *so_list_head = 0;
+static struct so_list *so_list_head;   /* List of known shared objects */
+static CORE_ADDR debug_base;           /* Base of dynamic linker structures */
+static CORE_ADDR breakpoint_addr;      /* Address where end bkpt is set */
+
 
 /*
-** 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.
-*/
+
+LOCAL FUNCTION
+
+       solib_map_sections -- open bfd and build sections for shared lib
+
+SYNOPSIS
+
+       static void 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 void
-solib_map_sections(so)
-struct so_list *so;
+solib_map_sections (so)
+     struct so_list *so;
 {
   char *filename;
   char *scratch_pathname;
   int scratch_chan;
   struct section_table *p;
   
-  filename = tilde_expand (so->inferior_so_name);
+  filename = tilde_expand (so -> so_name);
   make_cleanup (free, filename);
   
   scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
-                           &scratch_pathname);
+                       &scratch_pathname);
   if (scratch_chan < 0)
-    scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename, O_RDONLY, 0,
-                           &scratch_pathname);
+    {
+      scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename,
+                           O_RDONLY, 0, &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));
-
-  for (p = so->sections; p < so->sections_end; p++)
-    {
-      if (strcmp (bfd_section_name (so->so_bfd, p->sec_ptr), ".text") == 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));
+    }
+
+  for (p = so -> sections; p < so -> sections_end; p++)
+    {
+      /* Relocate the section binding addresses as recorded in the shared
+        object's file by the base address to which the object was actually
+        mapped. */
+      p -> addr += (CORE_ADDR) LM_ADDR (so);
+      p -> endaddr += (CORE_ADDR) LM_ADDR (so);
+      so -> lmend = (CORE_ADDR) max (p -> endaddr, so -> lmend);
+    }
+}
+
+/*
+
+LOCAL FUNCTION
+
+       bfd_lookup_symbol -- lookup the value for a specific symbol
+
+SYNOPSIS
+
+       CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
+
+DESCRIPTION
+
+       An expensive way to lookup the value of a single symbol for
+       bfd's that are only temporary anyway.  This is used by the
+       shared library support to find the address of the debugger
+       interface structures in the shared library.
+
+       Note that 0 is specifically allowed as an error return (no
+       such symbol).
+
+       FIXME:  See if there is a less "expensive" way of doing this.
+       Also see if there is already another bfd or gdb function
+       that specifically does this, and if so, use it.
+*/
+
+static CORE_ADDR
+DEFUN (bfd_lookup_symbol, (abfd, symname),
+       bfd *abfd AND
+       char *symname)
+{
+  unsigned int storage_needed;
+  asymbol *sym;
+  asymbol **symbol_table;
+  unsigned int number_of_symbols;
+  unsigned int i;
+  struct cleanup *back_to;
+  CORE_ADDR symaddr = 0;
+  enum misc_function_type mf_type;
+  
+  storage_needed = get_symtab_upper_bound (abfd);
+
+  if (storage_needed > 0)
+    {
+      symbol_table = (asymbol **) bfd_xmalloc (storage_needed);
+      back_to = make_cleanup (free, symbol_table);
+      number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 
+  
+      for (i = 0; i < number_of_symbols; i++)
        {
-         /* 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;
+         sym = *symbol_table++;
+         if (strcmp (sym -> name, symname) == 0)
+           {
+             symaddr = sym -> value;
+             break;
+           }
        }
-      else
-       /* All other sections are ignored for now. */
-       p->addr = p->endaddr = 0;
+      do_cleanups (back_to);
     }
+  return (symaddr);
 }
 
-/*=======================================================================*/
-
-/*     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
+
+       locate_base -- locate the base address of dynamic linker structs
+
+SYNOPSIS
+
+       CORE_ADDR locate_base (void)
+
+DESCRIPTION
+
+       For both the SunOS and SVR4 shared library implementations, if the
+       inferior executable has been linked dynamically, there is a single
+       address somewhere in the inferior's data space which is the key to
+       locating all of the dynamic linker's runtime structures, and this
+       address is the value of the symbol defined by the macro DEBUG_BASE.
+       The job of this function is to find and return that address, or to
+       return 0 if there is no such address (the executable is statically
+       linked for example).
+
+       For SunOS, the job is almost trivial, since the dynamic linker and
+       all of it's structures are statically linked to the executable at
+       link time.  Thus the symbol for the address we are looking for has
+       already been added to the misc function vector at the time the symbol
+       file's symbols were read.
+
+       The SVR4 version is much more complicated because the dynamic linker
+       and it's structures are located in the shared library itself, which
+       gets run as the executable's "interpreter" by the kernel.  Because
+       of this complexity, we cache the value we find and return that value
+       on subsequent invocations, if it is non-zero.
+
+       First we must decide if we are stopped at the entry point of the
+       shared C library, which is set to be the entry point of the dynamic
+       linker code (the function _rt_boot() to be precise), or at the entry
+       point given in the inferior's exec file (for statically linked 
+       executables).
+
+       If we are not stopped at the inferior's exec file entry point then
+       we are either stopped at the interpreter's entry point or somewhere
+       else (I.E. totally lost).  Use the /proc interface to get an open
+       file descriptor on the file that is mapped at the current stop_pc
+       value and try to open a bfd for it.
+
+FIXME
+
+       The SVR4 strategy does NOT work when gdb is attaching to an existing
+       process because the stop_pc is not in the library code, so we can't
+       use the /proc interface to get an open fd for the library.  So we
+       need to rethink the method for finding the debugger interface struct.
+
+       For SunOS we could look around in the executable code to find
+       DEBUG_BASE, 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.  
+
+ */
+
+static CORE_ADDR
+locate_base ()
+{
+  CORE_ADDR address;
+
+#ifdef sun
+
+  int i;
+
+  i = lookup_misc_func (DEBUG_BASE);
+  if (i >= 0 && misc_function_vector[i].address != 0)
+    {
+      address = misc_function_vector[i].address;
+    }
+
+#else  /* !sun */
+
+  int stop_pc_fd;                      /* File descriptor for mapped file */
+  int interp_fd;                       /* File descriptor for interpreter */
+  char *interp_name;                   /* Name of interpreter */
+  char *full_interp_name;              /* Full pathname of interpreter */
+  bfd *interp_bfd;
+  CORE_ADDR interp_base;
+
+  if (debug_base > 0)
+    {
+      /* We have a currently valid address, so avoid doing all the work
+        again. */
+      return (debug_base);
+    }
+  if (bfd_get_start_address (exec_bfd) == stop_pc)
+    {
+      /* We are stopped at the entry point to the exec file, so there
+        are no shared libs to deal with. */
+      return (0);
+    }
+  if ((stop_pc_fd = proc_address_to_fd (stop_pc)) < 0)
+    {
+      /* We are stopped at an address for which we can't seem to get an open
+        file descriptor from the /proc interface.  We should already have
+        printed a suitable warning message. */
+      return (0);
+    }
+  if ((interp_name = elf_interpreter (exec_bfd)) == NULL)
+    {
+      /* There is no interpreter specified in the exec file, thus this is
+        not a normal dynamically linked file. */
+      return (0);
+    }
+  if ((interp_fd = openp (getenv ("PATH"), 1, interp_name, O_RDONLY, 0,
+                         &full_interp_name)) < 0)
+    {
+      /* We can't find and open the interpreter.  This is a problem. */
+      return (0);
+    }
+  if (!fdmatch (stop_pc_fd, interp_fd))
+    {
+      /* The file for the mapped region is not the interpreter, something
+        is strange... */
+      close (stop_pc_fd);
+      close (interp_fd);
+      free (full_interp_name);
+      return (0);
+    }
+  interp_bfd = bfd_fdopenr (full_interp_name, NULL, interp_fd);
+  if (!interp_bfd)
+    {
+      warning ("Could not open `%s' as an executable file: %s",
+            full_interp_name, bfd_errmsg (bfd_error));
+      return (0);
+    }
+  if (!bfd_check_format (interp_bfd, bfd_object))
+    {
+      warning ("\"%s\": not in executable format: %s.",
+            full_interp_name, bfd_errmsg (bfd_error));
+      return (0);
+    }
+
+  /* Lookup the unrelocated value of the symbol that defines the location
+     of the debugger interface structure for the dynamic linker in the shared
+     library.  Then find the base address of the text segment in the
+     inferior's mapped in dynamic library, which gives the relocation to
+     apply to find the actual mapped address of the debugger interface
+     structure. */
+
+  if ((address = bfd_lookup_symbol (interp_bfd, DEBUG_BASE)) == 0)
+    {
+      warning ("can't find symbol %s in shared library", DEBUG_BASE);
+      return (0);
+    }
+  if ((interp_base = proc_base_address (stop_pc)) == 0)
+    {
+      warning ("can't find base address for shared library text segment");
+      return (0);
+    }
+  shlib_base = interp_base;
+  address += interp_base;
+
+  if ((interp_base + bfd_get_start_address (interp_bfd)) != stop_pc)
+    {
+      /* We are not stopped at the entry point to the dynamic linker,
+        so grumble and skip startup shared library processing. */
+      warning ("not stopped at entry point of dynamic linker");
+      warning ("shared library processing suppressed");
+      return (0);
+    }
+
+  bfd_close (interp_bfd);
+
+#endif /* sun */
+
+  return (address);
+
+}
 
-struct so_list *find_solib(so_list_ptr)
-struct so_list *so_list_ptr;                   /* so_list_head position ptr */
+static struct link_map *
+first_link_map_member ()
 {
-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;
+  struct link_map *lm = NULL;
+
+#ifdef sun
+
+  read_memory (debug_base, &dynamic_copy, sizeof (dynamic_copy));
+  if (dynamic_copy.ld_version >= 2)
+    {
+      /* It is a version that we can deal with, so read in the secondary
+        structure and find the address of the link map list from it. */
+      read_memory ((CORE_ADDR) dynamic_copy.ld_un.ld_2, &ld_2_copy,
+                  sizeof (struct link_dynamic_2));
+      lm = ld_2_copy.ld_loaded;
+    }
+
+#else
+
+  read_memory (debug_base, &debug_copy, sizeof (struct r_debug));
+  lm = debug_copy.r_map;
+
 #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;
+  return (lm);
+}
+
+/*
+
+GLOBAL FUNCTION
+
+       find_solib -- step through list of shared objects
+
+SYNOPSIS
+
+       struct so_list *find_solib (struct so_list *so_list_ptr)
+
+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.
 
-        solib_map_sections (new);
+       The arg and return value are "struct link_map" pointers, as defined
+       in <link.h>.
+ */
 
-        so_list_next = new;
-     }
-     return(so_list_next);
+struct so_list *
+find_solib (so_list_ptr)
+     struct so_list *so_list_ptr;      /* Last lm or NULL for first one */
+{
+  struct so_list *so_list_next = NULL;
+  struct link_map *lm = NULL;
+  struct so_list *new;
+  
+  if (so_list_ptr == NULL)
+    {
+      /* We are setting up for a new scan through the loaded images. */
+      if ((so_list_next = so_list_head) == NULL)
+       {
+         /* We have not already read in the dynamic linking structures
+            from the inferior, lookup the address of the base structure. */
+         debug_base = locate_base ();
+         if (debug_base > 0)
+           {
+             /* Read the base structure in and find the address of the first
+                link map list member. */
+             lm = first_link_map_member ();
+           }
+       }
+    }
+  else
+    {
+      /* We have been called before, and are in the process of walking
+        the shared library list.  Advance to the next shared object. */
+      if ((lm = LM_NEXT (so_list_ptr)) == NULL)
+       {
+         /* We have hit the end of the list, so check to see if any were
+            added, but be quiet if we can't read from the target any more. */
+         int status = target_read_memory ((CORE_ADDR) so_list_ptr -> lmaddr,
+                                          (char *) &(so_list_ptr -> lm),
+                                          sizeof (struct link_map));
+         if (status == 0)
+           {
+             lm = LM_NEXT (so_list_ptr);
+           }
+         else
+           {
+             lm = NULL;
+           }
+       }
+      so_list_next = so_list_ptr -> next;
+    }
+  if ((so_list_next == NULL) && (lm != NULL))
+    {
+      /* Get next link map structure from inferior image and build a local
+        abbreviated load_map structure */
+      new = (struct so_list *) xmalloc (sizeof (struct so_list));
+      (void) memset ((char *) new, 0, sizeof (struct so_list));
+      new -> lmaddr = lm;
+      /* Add the new node as the next node in the list, or as the root
+        node if this is the first one. */
+      if (so_list_ptr != NULL)
+       {
+         so_list_ptr -> next = new;
+       }
+      else
+       {
+         so_list_head = new;
+       }      
+      so_list_next = new;
+      read_memory ((CORE_ADDR) lm, &(new -> lm), sizeof (struct link_map));
+      /* For the SVR4 version, there is one entry that has no name
+        (for the inferior executable) since it is not a shared object. */
+      if (LM_NAME (new) != 0)
+       {
+         read_memory((CORE_ADDR) LM_NAME (new), new -> so_name,
+                     MAX_PATH_SIZE - 1);
+         new -> so_name[MAX_PATH_SIZE - 1] = 0;
+         solib_map_sections (new);
+       }      
+    }
+  return (so_list_next);
 }
 
 /* A small stub to get us past the arg-passing pinhole of catch_errors.  */
@@ -220,15 +547,27 @@ static int
 symbol_add_stub (arg)
      char *arg;
 {
-  register struct so_list *so = (struct so_list *)arg; /* catch_errs bogon */
-
-  symbol_file_add (so->inferior_so_name, so->from_tty,
-                  (unsigned int)so->inferior_lm.lm_addr, 0);
-  return 1;
+  register struct so_list *so = (struct so_list *) arg;        /* catch_errs bogon */
+  
+  symbol_file_add (so -> so_name, so -> from_tty,
+                  (unsigned int) LM_ADDR (so), 0);
+  return (1);
 }
 
-/* The real work of adding a shared library file to the symtab and
-   the section list.  */
+/*
+
+GLOBAL FUNCTION
+
+       solib_add -- add a shared library file to the symtab and section list
+
+SYNOPSIS
+
+       void solib_add (char *arg_string, int from_tty,
+                       struct target_ops *target)
+
+DESCRIPTION
+
+*/
 
 void
 solib_add (arg_string, from_tty, target)
@@ -236,226 +575,516 @@ solib_add (arg_string, from_tty, target)
      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);
-  }
-
+  register struct so_list *so = NULL;          /* link map state variable */
+  char *re_err;
+  int count;
+  int old;
+  
+  if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
+    {
+      error ("Invalid regexp: %s", re_err);
+    }
+  
   /* Getting new symbols may change our opinion about what is
      frameless.  */
   reinit_frame_cache ();
-
-  if (from_tty) {
-    printf_filtered ("Shared libraries");
-    if (arg_string)
-      printf_filtered (" matching regular expresion \"%s\"", arg_string);
-    printf_filtered (":\n");
-  }
   
-  dont_repeat();
-
-  while (so = find_solib(so)) {
-      if (re_exec(so->inferior_so_name)) {
-         if (so->symbols_loaded) {
+  while ((so = find_solib (so)) != NULL)
+    {
+      if (so -> so_name[0] && re_exec (so -> 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");
-         }
-      }
-  }
-
+               {
+                 printf ("Symbols already loaded for %s\n", so -> 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");
+           }
+       }
+    }
+  
   /* 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;
-    }
-
-    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;
-      }
-    }
-  }
+  if (target)
+    {
+      /* Count how many new section_table entries there are.  */
+      so = NULL;
+      count = 0;
+      while ((so = find_solib (so)) != NULL)
+       {
+         if (so -> so_name[0])
+           {
+             count += so -> sections_end - so -> sections;
+           }
+       }
+      
+      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 ((so = find_solib (so)) != NULL)
+           {
+             if (so -> so_name[0])
+               {
+                 count = so -> sections_end - so -> sections;
+                 bcopy (so -> sections, (char *)(target -> sections + old), 
+                        (sizeof (struct section_table)) * count);
+                 old += count;
+               }
+           }
+       }
+    }
 }
 
-/*=======================================================================*/
+/*
 
-static void solib_info()
-{
-register struct so_list *so = 0;       /* link map state variable */
+LOCAL FUNCTION
+
+       info_sharedlibrary_command -- code for "info sharedlibrary"
+
+SYNOPSIS
+
+       static void info_sharedlibrary_command ()
+
+DESCRIPTION
 
-    while (so = find_solib(so)) {
-       if (so == so_list_head) {
-           printf("      Address Range     Syms Read    Shared Object Library\n");
+       Walk through the shared library list and print information
+       about each attached library.
+*/
+
+static void
+info_sharedlibrary_command ()
+{
+  register struct so_list *so = NULL;          /* link map state variable */
+  int header_done = 0;
+  
+  if (exec_bfd == NULL)
+    {
+      printf ("No exec file.\n");
+      return;
+    }
+  while ((so = find_solib (so)) != NULL)
+    {
+      if (so -> so_name[0])
+       {
+         if (!header_done)
+           {
+             printf("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read",
+                    "Shared Object Library");
+             header_done++;
+           }
+         printf ("%-12s", local_hex_string_custom (LM_ADDR (so), "08"));
+         printf ("%-12s", local_hex_string_custom (so -> lmend, "08"));
+         printf ("%-12s", so -> symbols_loaded ? "Yes" : "No");
+         printf ("%s\n",  so -> so_name);
        }
-       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 (so_list_head == NULL)
+    {
+      printf ("No shared libraries loaded at this time.\n");   
     }
 }
 
 /*
-** Called by Insert Breakpoint to see if Address is Shared Library Address 
-*/
+
+GLOBAL FUNCTION
+
+       solib_address -- check to see if an address is in a shared lib
+
+SYNOPSIS
+
+       int 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.  Any address between the base mapping address
+       and the first address beyond the end of the last mapping, is
+       considered to be within the shared library address space, for
+       our purposes.
+
+       For example, this routine is called at one point to disable
+       breakpoints which are in shared libraries that are not currently
+       mapped in.
+ */
+
 int
-solib_address(address)
+solib_address (address)
      CORE_ADDR address;
 {
-register struct so_list *so = 0;       /* link map state variable */
+  register struct so_list *so = 0;     /* link map state variable */
+  
+  while ((so = find_solib (so)) != NULL)
+    {
+      if (so -> so_name[0])
+       {
+         if ((address >= (CORE_ADDR) LM_ADDR (so)) &&
+             (address < (CORE_ADDR) so -> lmend))
+           {
+             return (1);
+           }
+       }
+    }
+  return (0);
+}
+
+/* Called by free_all_symtabs */
 
-    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;
+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;
     }
-    return 0;
+  debug_base = 0;
 }
 
 /*
-** Called by free_all_symtabs
+
+LOCAL FUNCTION
+
+       disable_break -- remove the "mapping changed" breakpoint
+
+SYNOPSIS
+
+       static int disable_break ()
+
+DESCRIPTION
+
+       Removes the breakpoint that gets hit when the dynamic linker
+       completes a mapping change.
+
 */
-void 
-clear_solib()
+
+static int
+disable_break ()
 {
-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;
-  }
+  int status = 1;
+
+#ifdef sun
+
+  /* FIXME: maybe we should add the common symbols from the ldd_cp chain
+     to the misc_function_vector ? */
+
+  int in_debugger = 0;
+  
+  /* Set `in_debugger' to zero now. */
+
+  write_memory (flag_addr, &in_debugger, sizeof (in_debugger));
+
+  /* Read the debugger structure from the inferior to retrieve the
+     address of the breakpoint and the original contents of the
+     breakpoint address.  Remove the breakpoint by writing the original
+     contents back. */
+
+  read_memory (debug_addr, &debug_copy, sizeof (debug_copy));
+  breakpoint_addr = (CORE_ADDR) debug_copy.ldd_bp_addr;
+  write_memory (breakpoint_addr, &debug_copy.ldd_bp_inst,
+               sizeof (debug_copy.ldd_bp_inst));
+
+#else  /* !sun */
+
+  /* Note that breakpoint address and original contents are in our address
+     space, so we just need to write the original contents back. */
+
+  if (memory_remove_breakpoint (breakpoint_addr, shadow_contents) != 0)
+    {
+      status = 0;
+    }
+
+#endif /* sun */
+
+  /* For the SVR4 version, we always know the breakpoint address.  For the
+     SunOS version we don't know it until the above code is executed.
+     Grumble if we are stopped anywhere besides the breakpoint address. */
+
+  if (stop_pc != breakpoint_addr)
+    {
+      warning ("stopped at unknown breakpoint while handling shared libraries");
+    }
+
+  return (status);
 }
 
-/* Called by child_create_inferior when the inferior is stopped at its
-   first instruction.  */
+/*
 
-void 
-solib_create_inferior_hook()
+LOCAL FUNCTION
+
+       enable_break -- arrange for dynamic linker to hit breakpoint
+
+SYNOPSIS
+
+       int enable_break (void)
+
+DESCRIPTION
+
+       Both the SunOS and the SVR4 dynamic linkers have, as part of their
+       debugger interface, support for arranging for the inferior to hit
+       a breakpoint after mapping in the shared libraries.  This function
+       enables that breakpoint.
+
+       For SunOS, there is a special flag location (in_debugger) which we
+       set to 1.  When the dynamic linker sees this flag set, it will set
+       a breakpoint at a location known only to itself, after saving the
+       original contents of that place and the breakpoint address itself,
+       in it's own internal structures.  When we resume the inferior, it
+       will eventually take a SIGTRAP when it runs into the breakpoint.
+       We handle this (in a different place) 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.
+
+       For SVR4, the debugger interface structure contains a member (r_brk)
+       which is statically initialized at the time the shared library is
+       built, to the offset of a function (_r_debug_state) which is guaran-
+       teed to be called once before mapping in a library, and again when
+       the mapping is complete.  At the time we are examining this member,
+       it contains only the unrelocated offset of the function, so we have
+       to do our own relocation.  Later, when the dynamic linker actually
+       runs, it relocates r_brk to be the actual address of _r_debug_state().
+
+       The debugger interface structure also contains an enumeration which
+       is set to either RT_ADD or RT_DELETE prior to changing the mapping,
+       depending upon whether or not the library is being mapped or unmapped,
+       and then set to RT_CONSISTENT after the library is mapped/unmapped.
+*/
+
+static int
+enable_break ()
 {
-  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;
+  int j;
+
+#ifdef sun
 
+  int in_debugger;
+  
   /* Get link_dynamic structure */
-  j = target_read_memory(misc_function_vector[i].address,
-             &inferior_dynamic_cpy,
-             sizeof(struct link_dynamic));
-  if (j)                                       /* unreadable */
-    return;
+
+  j = target_read_memory (debug_base, (char *) &dynamic_copy,
+                         sizeof (dynamic_copy));
+  if (j)
+    {
+      /* unreadable */
+      return (0);
+    }
 
   /* Calc address of debugger interface structure */
-  inferior_debug_addr = (CORE_ADDR)inferior_dynamic_cpy.ldd;
+
+  debug_addr = (CORE_ADDR) dynamic_copy.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);
+
+  flag_addr = debug_addr + (CORE_ADDR) ((char *) &debug_copy.ldd_in_debugger -
+                                       (char *) &debug_copy);
+
   /* 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.  */
+  write_memory (flag_addr, &in_debugger, sizeof (in_debugger));
+
+#else  /* !sun */
+
+#ifdef BKPT_AT_MAIN
+
+  int i;
+
+  i = lookup_misc_func ("main");
+  if (i >= 0 && misc_function_vector[i].address != 0)
+    {
+      breakpoint_addr = misc_function_vector[i].address;
+    }
+  else
+    {
+      return (0);
+    }
+
+  if (target_insert_breakpoint (breakpoint_addr, shadow_contents) != 0)
+    {
+      return (0);
+    }
+
+#else  /* !BKPT_AT_MAIN */
+
+  struct symtab_and_line sal;
+
+  /* Read the debugger interface structure directly. */
+
+  read_memory (debug_base, (char *) &debug_copy, sizeof (debug_copy));
+
+  /* Set breakpoint at the debugger interface stub routine that will
+     be called just prior to each mapping change and again after the
+     mapping change is complete.  Set up the (nonexistent) handler to
+     deal with hitting these breakpoints.  (FIXME). */
+
+  warning ("'%s': line %d: missing SVR4 support code", __FILE__, __LINE__);
+
+#endif /* BKPT_AT_MAIN */
+
+#endif /* sun */
+
+  return (1);
+}
+  
+/*
+  
+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.
+
+       For both SunOS shared libraries, and SVR4 shared libraries, we
+       can arrange to cooperate with the dynamic linker to discover the
+       names of shared libraries that are dynamically linked, and the
+       base addresses to which they are linked.
+
+       This function is responsible for discovering those names and
+       addresses, and saving sufficient information about them to allow
+       their symbols to be read at a later time.
+
+FIXME
+
+       Between enable_break() and disable_break(), this code does not
+       properly handle hitting breakpoints which the user might have
+       set in the startup code or in the dynamic linker itself.  Proper
+       handling will probably have to wait until the implementation is
+       changed to use the "breakpoint handler function" method.
+
+       Also, what if child has exit()ed?  Must exit loop somehow.
+  */
+
+void 
+solib_create_inferior_hook()
+{
+  CORE_ADDR debug_addr;
+  int in_debugger;
+  CORE_ADDR in_debugger_addr;
+  CORE_ADDR breakpoint_addr;
+  int i, j;
+  
+  if ((debug_base = locate_base ()) == 0)
+    {
+      /* Can't find the symbol or the executable is statically linked. */
+      return;
+    }
+
+  if (!enable_break ())
+    {
+      warning ("shared library handler failed to enable breakpoint");
+      return;
+    }
+
+  /* Now run the target.  It will eventually hit the breakpoint, at
+     which point all of the libraries will have been mapped in and we
+     can go groveling around in the dynamic linker structures to find
+     out what we need to know about them. */
 
   clear_proceed_status ();
   stop_soon_quietly = 1;
-  target_resume (0, 0);
-  wait_for_inferior ();
-  while (stop_signal != SIGTRAP)
+  stop_signal = 0;
+  do
     {
-      /* FIXME, what if child has exit()ed?  Must exit loop somehow */
       target_resume (0, stop_signal);
       wait_for_inferior ();
     }
+  while (stop_signal != SIGTRAP);
   stop_soon_quietly = 0;
+  
+  /* We are now either at the "mapping complete" breakpoint (or somewhere
+     else, a condition we aren't prepared to deal with anyway), so adjust
+     the PC as necessary after a breakpoint, disable the breakpoint, and
+     add any shared libraries that were mapped in. */
 
-  /* 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)
-    {
-      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);
-        }
-    }
-  solib_add ((char *)0, 0, (struct target_ops *)0);
+  if (DECR_PC_AFTER_BREAK)
+    {
+      stop_pc -= DECR_PC_AFTER_BREAK;
+      write_register (PC_REGNUM, stop_pc);
+    }
+
+  if (!disable_break ())
+    {
+      warning ("shared library handler failed to disable breakpoint");
+    }
+
+  solib_add ((char *) 0, 0, (struct target_ops *) 0);
 }
 
+/*
+
+GLOBAL FUNCTION
+
+       sharedlibrary_command -- handle command to explicitly add library
+
+SYNOPSIS
+
+       void sharedlibrary_command (char *args, int from_tty)
+
+DESCRIPTION
+
+*/
+
 void
 sharedlibrary_command (args, from_tty)
+char *args;
+int from_tty;
 {
-  solib_add (args, from_tty, (struct target_ops *)0);
+  dont_repeat ();
+  solib_add (args, from_tty, (struct target_ops *) 0);
 }
 
 void
 _initialize_solib()
 {
-
-  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.");
 }
index ed14214..f1eea20 100755 (executable)
@@ -18,4 +18,20 @@ 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.  */
 
-/* Currently empty */
+/* Support for SVR4 shared libraries. */
+
+#define CLEAR_SOLIB                    clear_solib
+extern void clear_solib ();                    /* solib.c */
+
+#define SOLIB_ADD(filename, from_tty, targ) solib_add (filename, from_tty, targ)
+extern void solib_add ();                      /* solib.c */
+
+#define SOLIB_CREATE_INFERIOR_HOOK     solib_create_inferior_hook
+extern void solib_create_inferior_hook();      /* solib.c */
+
+/* If we can't set a breakpoint, and it's in a shared library, just
+   disable it.  */
+
+#define DISABLE_UNSETTABLE_BREAK(addr) solib_address(addr)
+extern int solib_address ();                   /* solib.c */
+