[rfc] first cut of solib-som.[ch]

[rfc] first cut of solib-som.[ch]

[Randolph Chung]

Here's a first cut at SOM solib support using the new solib
infrastructure. I hope this is somewhat cleaner than the original
somsolib.c.  The in_dynsym_resolve_code method is still really ugly; i
hope to revisit that later. Can someone please review this and let me
know if i'm on the right track? I've done some light testing with this
using hppa2.0w-hp-hpux11.11. In some ways it works better than the
existing code (e.g. info sharedlib will segfault the current gdb in
cvs, but using this version works)

If this is ok, i'll check it in without linking it to anything. Will
work on converting pa64solib next, and once that is ready we can enable
that for hpux targets.

One interesting bit for hpux is that for hppa64-hpux, to support both
32-bit and 64-bit debugging at the same time, we will need multiarched
solib support as well. My plan is to call either som_solib_select () 
[below] or pa64_solib_select () in the osabi sniffer to set the correct 
current_target_so_ops. Is that how it is supposed to work?

thanks
randolph



2004-12-06  Randolph Chung  <tausq@debian.org>

	* solib-som.h: New file.
	* solib-som.c: New file.

--- /dev/null	Tue Dec  7 00:15:15 2004
+++ solib-som.h	Tue Dec  7 00:17:21 2004
@@ -0,0 +1,41 @@
+/* Handle SOM shared libraries for GDB, the GNU Debugger.
+
+   Copyright 2004 Free Software Foundation, Inc.
+
+   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 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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef SOLIB_SOM_H
+#define SOLIB_SOM_H
+
+struct objfile;
+struct section_offsets;
+struct so_list;
+
+void som_solib_select (void);
+
+int som_solib_section_offsets (struct objfile *objfile,
+			       struct section_offsets *offsets);
+
+CORE_ADDR som_solib_get_got_by_pc (CORE_ADDR addr);
+
+CORE_ADDR som_solib_thread_start_addr (struct so_list *so);
+
+CORE_ADDR som_solib_get_solib_by_pc (CORE_ADDR addr);
+
+#endif
+
--- /dev/null	Tue Dec  7 00:15:15 2004
+++ solib-som.c	Mon Dec  6 23:56:47 2004
@@ -0,0 +1,903 @@
+/* Handle SOM shared libraries for GDB, the GNU Debugger.
+
+   Copyright 2004 Free Software Foundation, Inc.
+
+   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 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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "som.h"
+#include "symtab.h"
+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "inferior.h"
+
+#include "hppa-tdep.h"
+#include "solist.h"
+
+#undef SOLIB_SOM_DBG 
+
+/* These ought to be defined in some public interface, but aren't.  They
+   define the meaning of the various bits in the distinguished __dld_flags
+   variable that is declared in every debuggable a.out on HP-UX, and that
+   is shared between the debugger and the dynamic linker.
+ */
+#define DLD_FLAGS_MAPPRIVATE    0x1
+#define DLD_FLAGS_HOOKVALID     0x2
+#define DLD_FLAGS_LISTVALID     0x4
+#define DLD_FLAGS_BOR_ENABLE    0x8
+
+struct lm_info
+  {
+    /* Version of this structure (it is expected to change again in hpux10).  */
+    unsigned char struct_version;
+
+    /* Binding mode for this library.  */
+    unsigned char bind_mode;
+
+    /* Version of this library.  */
+    short library_version;
+
+    /* Start of text address,
+       link-time text location (length of text area),
+       end of text address.  */
+    CORE_ADDR text_addr;
+    CORE_ADDR text_link_addr;
+    CORE_ADDR text_end;
+
+    /* Start of data, start of bss and end of data.  */
+    CORE_ADDR data_start;
+    CORE_ADDR bss_start;
+    CORE_ADDR data_end;
+
+    /* Value of linkage pointer (%r19).  */
+    CORE_ADDR got_value;
+
+    /* Address in target of offset from thread-local register of
+       start of this thread's data.  I.e., the first thread-local
+       variable in this shared library starts at *(tsd_start_addr)
+       from that area pointed to by cr27 (mpsfu_hi).
+      
+       We do the indirection as soon as we read it, so from then
+       on it's the offset itself.  */
+    CORE_ADDR tsd_start_addr;
+
+    /* Address of the link map entry in the loader.  */
+    CORE_ADDR lm_addr;
+  };
+
+/* These addresses should be filled in by som_solib_create_inferior_hook.
+   They are also used elsewhere in this module.
+ */
+typedef struct
+  {
+    CORE_ADDR address;
+    struct unwind_table_entry *unwind;
+  }
+addr_and_unwind_t;
+
+/* When adding fields, be sure to clear them in _initialize_som_solib. */
+static struct
+  {
+    int is_valid;
+    addr_and_unwind_t hook;
+    addr_and_unwind_t hook_stub;
+    addr_and_unwind_t load;
+    addr_and_unwind_t load_stub;
+    addr_and_unwind_t unload;
+    addr_and_unwind_t unload2;
+    addr_and_unwind_t unload_stub;
+  }
+dld_cache;
+
+static void
+som_relocate_section_addresses (struct so_list *so,
+				struct section_table *sec)
+{
+  flagword aflag = bfd_get_section_flags(so->abfd, sec->the_bfd_section);
+
+  /* solib.c does something similar, but it only recognizes ".text", SOM calls
+     the text section "$CODE$".  */
+  if (strcmp (sec->the_bfd_section->name, "$CODE$") == 0)
+    {
+      so->textsection = sec;
+    }
+
+  if (aflag & SEC_CODE)
+    {
+      sec->addr    += so->lm_info->text_addr - so->lm_info->text_link_addr; 
+      sec->endaddr += so->lm_info->text_addr - so->lm_info->text_link_addr;
+    }
+  else if (aflag & SEC_DATA)
+    {
+      sec->addr    += so->lm_info->data_start; 
+      sec->endaddr += so->lm_info->data_start;
+    }
+  else
+    ;
+}
+
+/* This hook gets called just before the first instruction in the
+   inferior process is executed.
+
+   This is our opportunity to set magic flags in the inferior so
+   that GDB can be notified when a shared library is mapped in and
+   to tell the dynamic linker that a private copy of the library is
+   needed (so GDB can set breakpoints in the library).
+
+   __dld_flags is the location of the magic flags; as of this implementation
+   there are 3 flags of interest:
+
+   bit 0 when set indicates that private copies of the libraries are needed
+   bit 1 when set indicates that the callback hook routine is valid
+   bit 2 when set indicates that the dynamic linker should maintain the
+   __dld_list structure when loading/unloading libraries.
+
+   Note that shared libraries are not mapped in at this time, so we have
+   run the inferior until the libraries are mapped in.  Typically this
+   means running until the "_start" is called.  */
+
+static void
+som_solib_create_inferior_hook (void)
+{
+  struct minimal_symbol *msymbol;
+  unsigned int dld_flags, status, have_endo;
+  asection *shlib_info;
+  char buf[4];
+  struct objfile *objfile;
+  CORE_ADDR anaddr;
+
+  /* First, remove all the solib event breakpoints.  Their addresses
+     may have changed since the last time we ran the program.  */
+  remove_solib_event_breakpoints ();
+
+  if (symfile_objfile == NULL)
+    return;
+
+  /* First see if the objfile was dynamically linked.  */
+  shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
+  if (!shlib_info)
+    return;
+
+  /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
+  if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
+    return;
+
+  have_endo = 0;
+  /* Slam the pid of the process into __d_pid.
+
+     We used to warn when this failed, but that warning is only useful
+     on very old HP systems (hpux9 and older).  The warnings are an
+     annoyance to users of modern systems and foul up the testsuite as
+     well.  As a result, the warnings have been disabled.  */
+  msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    goto keep_going;
+
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  store_unsigned_integer (buf, 4, PIDGET (inferior_ptid));
+  status = target_write_memory (anaddr, buf, 4);
+  if (status != 0)
+    {
+      warning ("Unable to write __d_pid");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      goto keep_going;
+    }
+
+  /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
+     This will force the dynamic linker to call __d_trap when significant
+     events occur.
+
+     Note that the above is the pre-HP-UX 9.0 behaviour.  At 9.0 and above,
+     the dld provides an export stub named "__d_trap" as well as the
+     function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
+     We'll look first for the old flavor and then the new.
+   */
+  msymbol = lookup_minimal_symbol ("_DLD_HOOK", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    {
+      warning ("Unable to find _DLD_HOOK symbol in object file.");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      goto keep_going;
+    }
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  dld_cache.hook.address = anaddr;
+
+  /* Grrr, this might not be an export symbol!  We have to find the
+     export stub.  */
+  ALL_OBJFILES (objfile)
+  {
+    struct unwind_table_entry *u;
+    struct minimal_symbol *msymbol2;
+
+    /* What a crock.  */
+    msymbol2 =
+      lookup_minimal_symbol_solib_trampoline (SYMBOL_LINKAGE_NAME (msymbol),
+					      objfile);
+    /* Found a symbol with the right name.  */
+    if (msymbol2)
+      {
+	struct unwind_table_entry *u;
+	/* It must be a shared library trampoline.  */
+	if (SYMBOL_TYPE (msymbol2) != mst_solib_trampoline)
+	  continue;
+
+	/* It must also be an export stub.  */
+	u = find_unwind_entry (SYMBOL_VALUE (msymbol2));
+	if (!u || u->stub_unwind.stub_type != EXPORT)
+	  continue;
+
+	/* OK.  Looks like the correct import stub.  */
+	anaddr = SYMBOL_VALUE (msymbol2);
+	dld_cache.hook_stub.address = anaddr;
+      }
+  }
+  store_unsigned_integer (buf, 4, anaddr);
+
+  msymbol = lookup_minimal_symbol ("__dld_hook", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    {
+      warning ("Unable to find __dld_hook symbol in object file.");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      goto keep_going;
+    }
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  status = target_write_memory (anaddr, buf, 4);
+
+  /* Now set a shlib_event breakpoint at __d_trap so we can track
+     significant shared library events.  */
+  msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    {
+      warning ("Unable to find __dld_d_trap symbol in object file.");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      goto keep_going;
+    }
+  create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
+
+  /* We have all the support usually found in end.o, so we can track
+     shl_load and shl_unload calls.  */
+  have_endo = 1;
+
+keep_going:
+
+  /* Get the address of __dld_flags, if no such symbol exists, then we can
+     not debug the shared code.  */
+  msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
+  if (msymbol == NULL)
+    {
+      error ("Unable to find __dld_flags symbol in object file.\n");
+    }
+
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+
+  /* Read the current contents.  */
+  status = target_read_memory (anaddr, buf, 4);
+  if (status != 0)
+    {
+      error ("Unable to read __dld_flags\n");
+    }
+  dld_flags = extract_unsigned_integer (buf, 4);
+
+  /* Turn on the flags we care about.  */
+  dld_flags |= DLD_FLAGS_MAPPRIVATE;
+  if (have_endo)
+    dld_flags |= DLD_FLAGS_HOOKVALID;
+  store_unsigned_integer (buf, 4, dld_flags);
+  status = target_write_memory (anaddr, buf, 4);
+  if (status != 0)
+    {
+      error ("Unable to write __dld_flags\n");
+    }
+
+  /* Now find the address of _start and set a breakpoint there. 
+     We still need this code for two reasons:
+
+     * Not all sites have /opt/langtools/lib/end.o, so it's not always
+     possible to track the dynamic linker's events.
+
+     * At this time no events are triggered for shared libraries
+     loaded at startup time (what a crock).  */
+
+  msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    {
+      error ("Unable to find _start symbol in object file.\n");
+    }
+
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+
+  /* Make the breakpoint at "_start" a shared library event breakpoint.  */
+  create_solib_event_breakpoint (anaddr);
+
+  clear_symtab_users ();
+}
+
+/* This operation removes the "hook" between GDB and the dynamic linker,
+   which causes the dld to notify GDB of shared library events.
+
+   After this operation completes, the dld will no longer notify GDB of
+   shared library events.  To resume notifications, GDB must call
+   som_solib_create_inferior_hook.
+
+   This operation does not remove any knowledge of shared libraries which
+   GDB may already have been notified of.
+ */
+static void
+som_solib_remove_inferior_hook (int pid)
+{
+  CORE_ADDR addr;
+  struct minimal_symbol *msymbol;
+  int status;
+  char dld_flags_buffer[4];
+  unsigned int dld_flags_value;
+  struct cleanup *old_cleanups = save_inferior_ptid ();
+
+  /* Ensure that we're really operating on the specified process. */
+  inferior_ptid = pid_to_ptid (pid);
+
+  /* We won't bother to remove the solib breakpoints from this process.
+
+     In fact, on PA64 the breakpoint is hard-coded into the dld callback,
+     and thus we're not supposed to remove it.
+
+     Rather, we'll merely clear the dld_flags bit that enables callbacks.
+   */
+  msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
+
+  addr = SYMBOL_VALUE_ADDRESS (msymbol);
+  status = target_read_memory (addr, dld_flags_buffer, 4);
+
+  dld_flags_value = extract_unsigned_integer (dld_flags_buffer, 4);
+
+  dld_flags_value &= ~DLD_FLAGS_HOOKVALID;
+  store_unsigned_integer (dld_flags_buffer, 4, dld_flags_value);
+  status = target_write_memory (addr, dld_flags_buffer, 4);
+
+  do_cleanups (old_cleanups);
+}
+
+static void
+som_special_symbol_handling (void)
+{
+}
+
+static void
+som_solib_desire_dynamic_linker_symbols (void)
+{
+  struct objfile *objfile;
+  struct unwind_table_entry *u;
+  struct minimal_symbol *dld_msymbol;
+
+  /* Do we already know the value of these symbols?  If so, then
+     we've no work to do.
+
+     (If you add clauses to this test, be sure to likewise update the
+     test within the loop.)
+   */
+  if (dld_cache.is_valid)
+    return;
+
+  ALL_OBJFILES (objfile)
+  {
+    dld_msymbol = lookup_minimal_symbol ("shl_load", NULL, objfile);
+    if (dld_msymbol != NULL)
+      {
+	dld_cache.load.address = SYMBOL_VALUE (dld_msymbol);
+	dld_cache.load.unwind = find_unwind_entry (dld_cache.load.address);
+      }
+
+    dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_load",
+							  objfile);
+    if (dld_msymbol != NULL)
+      {
+	if (SYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
+	  {
+	    u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
+	    if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
+	      {
+		dld_cache.load_stub.address = SYMBOL_VALUE (dld_msymbol);
+		dld_cache.load_stub.unwind = u;
+	      }
+	  }
+      }
+
+    dld_msymbol = lookup_minimal_symbol ("shl_unload", NULL, objfile);
+    if (dld_msymbol != NULL)
+      {
+	dld_cache.unload.address = SYMBOL_VALUE (dld_msymbol);
+	dld_cache.unload.unwind = find_unwind_entry (dld_cache.unload.address);
+
+	/* ??rehrauer: I'm not sure exactly what this is, but it appears
+	   that on some HPUX 10.x versions, there's two unwind regions to
+	   cover the body of "shl_unload", the second being 4 bytes past
+	   the end of the first.  This is a large hack to handle that
+	   case, but since I don't seem to have any legitimate way to
+	   look for this thing via the symbol table...
+	 */
+	if (dld_cache.unload.unwind != NULL)
+	  {
+	    u = find_unwind_entry (dld_cache.unload.unwind->region_end + 4);
+	    if (u != NULL)
+	      {
+		dld_cache.unload2.address = u->region_start;
+		dld_cache.unload2.unwind = u;
+	      }
+	  }
+      }
+
+    dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_unload",
+							  objfile);
+    if (dld_msymbol != NULL)
+      {
+	if (SYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
+	  {
+	    u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
+	    if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
+	      {
+		dld_cache.unload_stub.address = SYMBOL_VALUE (dld_msymbol);
+		dld_cache.unload_stub.unwind = u;
+	      }
+	  }
+      }
+
+    /* Did we find everything we were looking for?  If so, stop. */
+    if ((dld_cache.load.address != 0)
+	&& (dld_cache.load_stub.address != 0)
+	&& (dld_cache.unload.address != 0)
+	&& (dld_cache.unload_stub.address != 0))
+      {
+	dld_cache.is_valid = 1;
+	break;
+      }
+  }
+
+  dld_cache.hook.unwind = find_unwind_entry (dld_cache.hook.address);
+  dld_cache.hook_stub.unwind = find_unwind_entry (dld_cache.hook_stub.address);
+
+  /* We're prepared not to find some of these symbols, which is why
+     this function is a "desire" operation, and not a "require".
+   */
+}
+
+static int
+som_in_dynsym_resolve_code (CORE_ADDR pc)
+{
+  struct unwind_table_entry *u_pc;
+
+  /* Are we in the dld itself?
+
+     ??rehrauer: Large hack -- We'll assume that any address in a
+     shared text region is the dld's text.  This would obviously
+     fall down if the user attached to a process, whose shlibs
+     weren't mapped to a (writeable) private region.  However, in
+     that case the debugger probably isn't able to set the fundamental
+     breakpoint in the dld callback anyways, so this hack should be
+     safe.
+   */
+  if ((pc & (CORE_ADDR) 0xc0000000) == (CORE_ADDR) 0xc0000000)
+    return 1;
+
+  /* Cache the address of some symbols that are part of the dynamic
+     linker, if not already known.
+   */
+  som_solib_desire_dynamic_linker_symbols ();
+
+  /* Are we in the dld callback?  Or its export stub? */
+  u_pc = find_unwind_entry (pc);
+  if (u_pc == NULL)
+    return 0;
+
+  if ((u_pc == dld_cache.hook.unwind) || (u_pc == dld_cache.hook_stub.unwind))
+    return 1;
+
+  /* Or the interface of the dld (i.e., "shl_load" or friends)? */
+  if ((u_pc == dld_cache.load.unwind)
+      || (u_pc == dld_cache.unload.unwind)
+      || (u_pc == dld_cache.unload2.unwind)
+      || (u_pc == dld_cache.load_stub.unwind)
+      || (u_pc == dld_cache.unload_stub.unwind))
+    return 1;
+
+  /* Apparently this address isn't part of the dld's text. */
+  return 0;
+}
+
+static void
+som_clear_solib (void)
+{
+}
+
+enum dld_list_offsets {
+  DLD_LIST_OFFSET_NAME 			= 0,
+  DLD_LIST_OFFSET_INFO 			= 4,
+  DLD_LIST_OFFSET_TEXT_ADDR 		= 8,
+  DLD_LIST_OFFSET_TEXT_LINK_ADDR 	= 12,
+  DLD_LIST_OFFSET_TEXT_END 		= 16,
+  DLD_LIST_OFFSET_DATA_START 		= 20,
+  DLD_LIST_OFFSET_BSS_START 		= 24,
+  DLD_LIST_OFFSET_DATA_END 		= 28,
+  DLD_LIST_OFFSET_GOT_VALUE 		= 32,
+  DLD_LIST_OFFSET_NEXT 			= 36,
+  DLD_LIST_OFFSET_TSD_START_ADDR_PTR 	= 40,
+  DLD_LIST_ENTRY_SIZE			= 44
+};
+
+static CORE_ADDR
+link_map_start (void)
+{
+  struct minimal_symbol *sym;
+  CORE_ADDR addr;
+  char buf[4];
+  unsigned int dld_flags;
+
+  sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
+  if (!sym)
+    {
+      error ("Unable to find __dld_flags symbol in object file.\n");
+      return 0;
+    }
+  addr = SYMBOL_VALUE_ADDRESS (sym);
+  read_memory (addr, buf, 4);
+  dld_flags = extract_unsigned_integer (buf, 4);
+  if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)
+    {
+      error ("__dld_list is not valid according to __dld_flags.\n");
+      return 0;
+    }
+
+  /* If the libraries were not mapped private, warn the user.  */
+  if ((dld_flags & DLD_FLAGS_MAPPRIVATE) == 0)
+    warning ("The shared libraries were not privately mapped; setting a\n"
+	     "breakpoint in a shared library will not work until you rerun the "
+	     "program.\n");
+
+  sym = lookup_minimal_symbol ("__dld_list", NULL, NULL);
+  if (!sym)
+    {
+      /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
+         but the data is still available if you know where to look.  */
+      sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
+      if (!sym)
+	{
+	  error ("Unable to find dynamic library list.\n");
+	  return 0;
+	}
+      addr = SYMBOL_VALUE_ADDRESS (sym) - 8;
+    }
+  else
+    addr = SYMBOL_VALUE_ADDRESS (sym);
+
+  read_memory (addr, buf, 4);
+  addr = extract_unsigned_integer (buf, 4);
+  if (addr == 0)
+    {
+      error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
+      return 0;
+    }
+
+  read_memory (addr, buf, 4);
+  return extract_unsigned_integer (buf, 4);
+}
+
+/* Does this so's name match the main binary? */
+static int
+match_main (const char *name)
+{
+  return strcmp (name, symfile_objfile->name) == 0;
+}
+
+static struct so_list *
+som_current_sos (void)
+{
+  CORE_ADDR lm;
+  struct so_list *head = 0;
+  struct so_list **link_ptr = &head;
+
+  for (lm = link_map_start (); lm; )
+    {
+      char *namebuf;
+      CORE_ADDR addr;
+      struct so_list *new;
+      struct cleanup *old_chain;
+      int errcode;
+      char dbuf[DLD_LIST_ENTRY_SIZE];
+      char tsdbuf[4];
+
+      new = (struct so_list *) xmalloc (sizeof (struct so_list));
+      old_chain = make_cleanup (xfree, new);
+
+      memset (new, 0, sizeof (*new));
+      new->lm_info = xmalloc (sizeof (struct lm_info));
+      make_cleanup (xfree, new->lm_info);
+
+      read_memory (lm, dbuf, DLD_LIST_ENTRY_SIZE);
+
+      addr = extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_NAME], 4);
+      target_read_string (addr, &namebuf, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
+      if (errcode != 0)
+	{
+	  warning ("current_sos: Can't read pathname for load map: %s\n",
+		   safe_strerror (errcode));
+	}
+      else
+	{
+	  strncpy (new->so_name, namebuf, SO_NAME_MAX_PATH_SIZE - 1);
+	  new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
+	  xfree (namebuf);
+	  strcpy (new->so_original_name, new->so_name);
+	}
+
+	if (new->so_name[0] && !match_main (new->so_name))
+	  {
+	    struct lm_info *lmi = new->lm_info;
+	    unsigned int tmp;
+
+	    lmi->lm_addr = lm;
+
+	    lmi->text_addr =
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_TEXT_ADDR], 4);
+	    tmp = 
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_INFO], 4);
+
+	    lmi->library_version = (tmp >> 16) & 0xffff;
+	    lmi->bind_mode = (tmp >> 8) & 0xff;
+	    lmi->struct_version = tmp & 0xff;
+
+	    lmi->text_link_addr =
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_TEXT_LINK_ADDR], 4);
+	    lmi->text_end =
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_TEXT_END], 4);
+	    lmi->data_start =
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_DATA_START], 4);
+	    lmi->bss_start =
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_BSS_START], 4);
+	    lmi->data_end =
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_DATA_END], 4);
+	    lmi->got_value =
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_GOT_VALUE], 4);
+	    tmp =
+	      extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_TSD_START_ADDR_PTR], 4);
+	    read_memory (tmp, tsdbuf, 4);
+	    lmi->tsd_start_addr = extract_unsigned_integer (tsdbuf, 4);
+
+#ifdef SOLIB_SOM_DBG
+	    printf ("\n+ library \"%s\" is described at 0x%s\n", new->so_name, 
+	    	    paddr_nz (lm));
+	    printf ("  'version' is %d\n", new->lm_info->struct_version);
+	    printf ("  'bind_mode' is %d\n", new->lm_info->bind_mode);
+	    printf ("  'library_version' is %d\n", 
+	    	    new->lm_info->library_version);
+	    printf ("  'text_addr' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->text_addr));
+	    printf ("  'text_link_addr' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->text_link_addr));
+	    printf ("  'text_end' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->text_end));
+	    printf ("  'data_start' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->data_start));
+	    printf ("  'bss_start' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->bss_start));
+	    printf ("  'data_end' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->data_end));
+	    printf ("  'got_value' is %s\n", 
+	    	    paddr_nz (new->lm_info->got_value));
+	    printf ("  'tsd_start_addr' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->tsd_start_addr));
+#endif
+
+	    /* Link the new object onto the list.  */
+	    new->next = NULL;
+	    *link_ptr = new;
+	    link_ptr = &new->next;
+	  }
+ 	else
+	  {
+	    free_so (new);
+	  }
+
+      lm = extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_NEXT], 4);
+      discard_cleanups (old_chain);
+    }
+
+  /* TODO: The original somsolib code has logic to detect and eliminate 
+     duplicate entries.  Do we need that?  */
+
+  return head;
+}
+
+static int
+som_open_symbol_file_object (void *from_ttyp)
+{
+  CORE_ADDR lm, l_name;
+  char *filename;
+  int errcode;
+  int from_tty = *(int *)from_ttyp;
+  char buf[4];
+
+  if (symfile_objfile)
+    if (!query ("Attempt to reload symbols from process? "))
+      return 0;
+
+  /* First link map member should be the executable.  */
+  if ((lm = link_map_start ()) == 0)
+    return 0;	/* failed somehow... */
+
+  /* Read address of name from target memory to GDB.  */
+  read_memory (lm + DLD_LIST_OFFSET_NAME, buf, 4);
+
+  /* Convert the address to host format.  Assume that the address is
+     unsigned.  */
+  l_name = extract_unsigned_integer (buf, 4);
+
+  if (l_name == 0)
+    return 0;		/* No filename.  */
+
+  /* Now fetch the filename from target memory.  */
+  target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
+
+  if (errcode)
+    {
+      warning ("failed to read exec filename from attached file: %s",
+	       safe_strerror (errcode));
+      return 0;
+    }
+
+  make_cleanup (xfree, filename);
+  /* Have a pathname: read the symbol file.  */
+  symbol_file_add_main (filename, from_tty);
+
+  return 1;
+}
+
+static void
+som_free_so (struct so_list *so)
+{
+  xfree (so->lm_info);
+}
+
+static struct target_so_ops som_so_ops;
+
+extern initialize_file_ftype _initialize_som_solib; /* -Wmissing-prototypes */
+
+void
+_initialize_som_solib (void)
+{
+  som_so_ops.relocate_section_addresses = som_relocate_section_addresses;
+  som_so_ops.free_so = som_free_so;
+  som_so_ops.clear_solib = som_clear_solib;
+  som_so_ops.solib_create_inferior_hook = som_solib_create_inferior_hook;
+  som_so_ops.special_symbol_handling = som_special_symbol_handling;
+  som_so_ops.current_sos = som_current_sos;
+  som_so_ops.open_symbol_file_object = som_open_symbol_file_object;
+  som_so_ops.in_dynsym_resolve_code = som_in_dynsym_resolve_code;
+}
+
+void som_solib_select (void)
+{
+  current_target_so_ops = &som_so_ops;
+}
+
+/* The rest of these functions are not part of the solib interface; they 
+   are used by somread.c or hppa-hpux-tdep.c */
+
+int
+som_solib_section_offsets (struct objfile *objfile,
+			   struct section_offsets *offsets)
+{
+  struct so_list *so_list = master_so_list ();
+
+  while (so_list)
+    {
+      /* Oh what a pain!  We need the offsets before so_list->objfile
+         is valid.  The BFDs will never match.  Make a best guess.  */
+      if (strstr (objfile->name, so_list->so_name))
+	{
+	  asection *private_section;
+
+	  /* The text offset is easy.  */
+	  offsets->offsets[SECT_OFF_TEXT (objfile)]
+	    = (so_list->lm_info->text_addr
+	       - so_list->lm_info->text_link_addr);
+	  offsets->offsets[SECT_OFF_RODATA (objfile)]
+	    = ANOFFSET (offsets, SECT_OFF_TEXT (objfile));
+
+	  /* We should look at presumed_dp in the SOM header, but
+	     that's not easily available.  This should be OK though.  */
+	  private_section = bfd_get_section_by_name (objfile->obfd,
+						     "$PRIVATE$");
+	  if (!private_section)
+	    {
+	      warning ("Unable to find $PRIVATE$ in shared library!");
+	      offsets->offsets[SECT_OFF_DATA (objfile)] = 0;
+	      offsets->offsets[SECT_OFF_BSS (objfile)] = 0;
+	      return 1;
+	    }
+	  offsets->offsets[SECT_OFF_DATA (objfile)]
+	    = (so_list->lm_info->data_start - private_section->vma);
+	  offsets->offsets[SECT_OFF_BSS (objfile)]
+	    = ANOFFSET (offsets, SECT_OFF_DATA (objfile));
+	  return 1;
+	}
+      so_list = so_list->next;
+    }
+  return 0;
+}
+
+/* Return the GOT value for the shared library in which ADDR belongs.  If
+   ADDR isn't in any known shared library, return zero.  */
+
+CORE_ADDR
+som_solib_get_got_by_pc (CORE_ADDR addr)
+{
+  struct so_list *so_list = master_so_list ();
+  CORE_ADDR got_value = 0;
+
+  while (so_list)
+    {
+      if (so_list->lm_info->text_addr <= addr
+	  && so_list->lm_info->text_end > addr)
+	{
+	  got_value = so_list->lm_info->got_value;
+	  break;
+	}
+      so_list = so_list->next;
+    }
+  return got_value;
+}
+
+/* Get some HPUX-specific data from a shared lib.
+ */
+CORE_ADDR
+som_solib_thread_start_addr (struct so_list *so)
+{
+  return so->lm_info->tsd_start_addr;
+}
+
+/* Return the address of the handle of the shared library in which ADDR belongs.
+   If ADDR isn't in any known shared library, return zero.  */
+/* this function is used in initialize_hp_cxx_exception_support in 
+   hppa-hpux-tdep.c  */
+
+CORE_ADDR
+som_solib_get_solib_by_pc (CORE_ADDR addr)
+{
+  struct so_list *so_list = master_so_list ();
+
+  while (so_list)
+    {
+      if (so_list->lm_info->text_addr <= addr
+	  && so_list->lm_info->text_end > addr)
+	{
+	  break;
+	}
+      so_list = so_list->next;
+    }
+  if (so_list)
+    return so_list->lm_info->lm_addr;
+  else
+    return 0;
+}
-- 
Randolph Chung
Debian GNU/Linux Developer, hppa/ia64 ports
http://www.tausq.org/

Re: [rfc] first cut of solib-som.[ch]

[Kevin Buettner]

On Mon, 6 Dec 2004 21:24:24 -0800
Randolph Chung <randolph@tausq.org> wrote:

> Here's a first cut at SOM solib support using the new solib
> infrastructure. I hope this is somewhat cleaner than the original
> somsolib.c.  The in_dynsym_resolve_code method is still really ugly; i
> hope to revisit that later. Can someone please review this and let me
> know if i'm on the right track?

Yes, you're definitely on the right track.  Thanks for doing this work!

> I've done some light testing with this
> using hppa2.0w-hp-hpux11.11. In some ways it works better than the
> existing code (e.g. info sharedlib will segfault the current gdb in
> cvs, but using this version works)
> 
> If this is ok, i'll check it in without linking it to anything. Will
> work on converting pa64solib next, and once that is ready we can enable
> that for hpux targets.

Sure, sounds good to me.

> One interesting bit for hpux is that for hppa64-hpux, to support both
> 32-bit and 64-bit debugging at the same time, we will need multiarched
> solib support as well. My plan is to call either som_solib_select () 
> [below] or pa64_solib_select () in the osabi sniffer to set the correct 
> current_target_so_ops. Is that how it is supposed to work?

Yes, this seems reasonable.  (At least for the short term; I think Mark
is working on something for the long term...)

Just one comment about the way you structured things...

> +enum dld_list_offsets {
> +  DLD_LIST_OFFSET_NAME 			= 0,
> +  DLD_LIST_OFFSET_INFO 			= 4,
> +  DLD_LIST_OFFSET_TEXT_ADDR 		= 8,
> +  DLD_LIST_OFFSET_TEXT_LINK_ADDR 	= 12,
> +  DLD_LIST_OFFSET_TEXT_END 		= 16,
> +  DLD_LIST_OFFSET_DATA_START 		= 20,
> +  DLD_LIST_OFFSET_BSS_START 		= 24,
> +  DLD_LIST_OFFSET_DATA_END 		= 28,
> +  DLD_LIST_OFFSET_GOT_VALUE 		= 32,
> +  DLD_LIST_OFFSET_NEXT 			= 36,
> +  DLD_LIST_OFFSET_TSD_START_ADDR_PTR 	= 40,
> +  DLD_LIST_ENTRY_SIZE			= 44
> +};

I have no real quarrel with using offsets as you do above; in fact, 
I think such offsets have worked out quite well for solib-svr4.  However,
given that you have only one set of offsets to worry about, it might be
easier in some respects to use an actual struct where each member is
a char array.  (Daniel J showed me this trick...)  So, for the above,
you might instead do:

struct dld_list {
  unsigned char name[4];
  unsigned char info[4];
  unsigned char text_addr[4];
  ...
};

And then, for example, in som_current_sos(), instead of doing:

      char dbuf[DLD_LIST_ENTRY_SIZE];
      ...
      addr = extract_unsigned_integer (&dbuf[DLD_LIST_OFFSET_NAME], 4);

You, could instead do:

      struct dld_list dbuf;
      ...
      addr = extract_unsigned_integer (&dbuf.name, sizeof(dbuf.name));

Kevin

Re: [rfc] first cut of solib-som.[ch]

[Randolph Chung]

> > One interesting bit for hpux is that for hppa64-hpux, to support both
> > 32-bit and 64-bit debugging at the same time, we will need multiarched
> > solib support as well. My plan is to call either som_solib_select () 
> > [below] or pa64_solib_select () in the osabi sniffer to set the correct 
> > current_target_so_ops. Is that how it is supposed to work?
> 
> Yes, this seems reasonable.  (At least for the short term; I think Mark
> is working on something for the long term...)

ok, one more twist...

there are some hpux specific solib methods that are required. i'm
assuming that these should go into the gdbarch_tdep vector, i.e. i'm
adding these to the hppa tdep structure:

  /* These are solib-dependent methods.  They are really HPUX only, but
     we don't have a HPUX-specific tdep vector at the moment.  */
  CORE_ADDR (*solib_thread_start_addr) (struct so_list *so);
  CORE_ADDR (*solib_get_got_by_pc) (CORE_ADDR addr);
  CORE_ADDR (*solib_get_solib_by_pc) (CORE_ADDR addr);

and these pointers are initizlied by som_solib_select () or
pa64_solib_select () to the corresponding implementation. this will get
rid of the PA_SOM_ONLY hack i added some time back to get
hppa64-hp-hpux11.11 to build...

is this ok?
randolph
-- 
Randolph Chung
Debian GNU/Linux Developer, hppa/ia64 ports
http://www.tausq.org/

Re: [rfc] first cut of solib-som.[ch]

[Kevin Buettner]

On Tue, 7 Dec 2004 13:17:35 -0800
Randolph Chung <randolph@tausq.org> wrote:

> > > One interesting bit for hpux is that for hppa64-hpux, to support both
> > > 32-bit and 64-bit debugging at the same time, we will need multiarched
> > > solib support as well. My plan is to call either som_solib_select () 
> > > [below] or pa64_solib_select () in the osabi sniffer to set the correct 
> > > current_target_so_ops. Is that how it is supposed to work?
> > 
> > Yes, this seems reasonable.  (At least for the short term; I think Mark
> > is working on something for the long term...)
> 
> ok, one more twist...
> 
> there are some hpux specific solib methods that are required. i'm
> assuming that these should go into the gdbarch_tdep vector, i.e. i'm
> adding these to the hppa tdep structure:
> 
>   /* These are solib-dependent methods.  They are really HPUX only, but
>      we don't have a HPUX-specific tdep vector at the moment.  */
>   CORE_ADDR (*solib_thread_start_addr) (struct so_list *so);
>   CORE_ADDR (*solib_get_got_by_pc) (CORE_ADDR addr);
>   CORE_ADDR (*solib_get_solib_by_pc) (CORE_ADDR addr);

So far, so good.

> and these pointers are initizlied by som_solib_select () or
> pa64_solib_select () to the corresponding implementation. this will get
> rid of the PA_SOM_ONLY hack i added some time back to get
> hppa64-hp-hpux11.11 to build...

The other way to do it is to initialize the HPUX specific tdep struct
from the same function which calls som_solib_select() or pa64_solib_select().
That way, you might not have to #include "hppa-tdep.h" in solib-som.c.

> is this ok?

I'm comfortable with either approach.  It makes a certain amount of
sense to initialize the solib related portions of the tdep struct from
within a solib-*.c file.  OTOH, it also makes sense to not clutter the
solib-*.c file with knowledge of a particular architecture's tdep
struct.  In this case, solib-som.c will probably not be used by any
other architectures, so it doesn't make much difference.  I'll leave
it to you to choose the approach which you like better.

Kevin

Re: [rfc] first cut of solib-som.[ch]

[Randolph Chung]

> I'm comfortable with either approach.  It makes a certain amount of
> sense to initialize the solib related portions of the tdep struct from
> within a solib-*.c file.  OTOH, it also makes sense to not clutter the
> solib-*.c file with knowledge of a particular architecture's tdep
> struct.  In this case, solib-som.c will probably not be used by any
> other architectures, so it doesn't make much difference.  I'll leave
> it to you to choose the approach which you like better.

well, for me it boils down to a dependency problem, which is still a bit
tricky at the moment.

what i would like to see is:
32-bit hpux targets will build only solib-som.*, and only support 32-bit
	debugging
64-bit hpux targets will build both solib-som.* and solib-pa64.*, and
	support both 32-bit and 64-bit debugging

the problem in this scenario is that in the common hpux file (i.e.
hppa-hpux-tdep.c), in order to support both configurations, we cannot
refer to anything that is in solib-pa64.*.

this is already a problem if i need to call e.g. pa64_solib_select (),
and it becomes worse if we expose the solib methods to the tdep file.

i'm thinking that the best way to do this is:
- have the 32-bit hpux configs define PA_SOM_ONLY (as they do now)
- unconditionally build both solib-som.c and solib-pa64.c into all hpux
  targets
- in solib-pa64.c, make everything compile out if PA_SOM_ONLY is
  defined, except for a stub pa64_solib_select ()

is there a cleaner way?

randolph
-- 
Randolph Chung
Debian GNU/Linux Developer, hppa/ia64 ports
http://www.tausq.org/

Re: [rfc] first cut of solib-som.[ch]

[Kevin Buettner]

On Tue, 7 Dec 2004 15:08:16 -0800
Randolph Chung <randolph@tausq.org> wrote:

> > I'm comfortable with either approach.  It makes a certain amount of
> > sense to initialize the solib related portions of the tdep struct from
> > within a solib-*.c file.  OTOH, it also makes sense to not clutter the
> > solib-*.c file with knowledge of a particular architecture's tdep
> > struct.  In this case, solib-som.c will probably not be used by any
> > other architectures, so it doesn't make much difference.  I'll leave
> > it to you to choose the approach which you like better.
> 
> well, for me it boils down to a dependency problem, which is still a bit
> tricky at the moment.
> 
> what i would like to see is:
> 32-bit hpux targets will build only solib-som.*, and only support 32-bit
> 	debugging
> 64-bit hpux targets will build both solib-som.* and solib-pa64.*, and
> 	support both 32-bit and 64-bit debugging
> 
> the problem in this scenario is that in the common hpux file (i.e.
> hppa-hpux-tdep.c), in order to support both configurations, we cannot
> refer to anything that is in solib-pa64.*.
> 
> this is already a problem if i need to call e.g. pa64_solib_select (),
> and it becomes worse if we expose the solib methods to the tdep file.

Thanks for explaining this.  Given this background, I think that your
original approach of initializing a portion of the tdep struct from
within solib-*.c is preferable.

> i'm thinking that the best way to do this is:
> - have the 32-bit hpux configs define PA_SOM_ONLY (as they do now)
> - unconditionally build both solib-som.c and solib-pa64.c into all hpux
>   targets
> - in solib-pa64.c, make everything compile out if PA_SOM_ONLY is
>   defined, except for a stub pa64_solib_select ()
> 
> is there a cleaner way?

I can't think of one at the moment.  So... go ahead with this approach.

Kevin

[commit] First cut of SOM and PA64 solib support

[Randolph Chung]

ok, i've committed the following 4 new files for SOM and pa64 solib
support. Lightly tested against hppa2.0w-hp-hpux11.11 and
hppa64-hp-hpux11.11. The supporting changes to the Makefile and target
files are not included. Since Mark is planning to change the hpux target
to use his new inf-ttrace interface i don't want to change the solib
support at the same time, so I will defer to his changes going in first.

One question -- none of the solib* files have entries in fnchange.lst.
Are any entries needed?

2004-12-07  Randolph Chung  <tausq@debian.org>

	* solib-som.c: New file.
	* solib-som.h: New file.
	* solib-pa64.c: New file.
	* solib-pa64.h: New file.
 	
Index: solib-pa64.c
===================================================================
RCS file: solib-pa64.c
diff -N solib-pa64.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ solib-pa64.c	8 Dec 2004 01:33:42 -0000
@@ -0,0 +1,653 @@
+/* Handle PA64 shared libraries for GDB, the GNU Debugger.
+
+   Copyright 2004 Free Software Foundation, Inc.
+
+   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 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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  
+   
+   HP in their infinite stupidity choose not to use standard ELF dynamic
+   linker interfaces.  They also choose not to make their ELF dymamic
+   linker interfaces compatible with the SOM dynamic linker.  The
+   net result is we can not use either of the existing somsolib.c or
+   solib.c.  What a crock.
+
+   Even more disgusting.  This file depends on functions provided only
+   in certain PA64 libraries.  Thus this file is supposed to only be
+   used native.  When will HP ever learn that they need to provide the
+   same functionality in all their libraries!  */
+
+#include "defs.h"
+#include <dlfcn.h>
+#include <elf.h>
+#include <elf_hp.h>
+#include "symtab.h"
+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "inferior.h"
+
+#include "hppa-tdep.h"
+#include "solist.h"
+#include "solib-pa64.h"
+
+#undef SOLIB_PA64_DBG
+
+/* If we are building for a SOM-only target, then we don't need this.  */
+#ifndef PA_SOM_ONLY
+
+struct lm_info {
+  struct load_module_desc desc;
+  CORE_ADDR desc_addr;
+};
+
+/* When adding fields, be sure to clear them in _initialize_pa64_solib. */
+typedef struct
+  {
+    CORE_ADDR dld_flags_addr;
+    LONGEST dld_flags;
+    struct bfd_section *dyninfo_sect;
+    int have_read_dld_descriptor;
+    int is_valid;
+    CORE_ADDR load_map;
+    CORE_ADDR load_map_addr;
+    struct load_module_desc dld_desc;
+  }
+dld_cache_t;
+
+static dld_cache_t dld_cache;
+
+static int
+read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p);
+
+static void
+pa64_relocate_section_addresses (struct so_list *so,
+				 struct section_table *sec)
+{
+}
+
+static void
+pa64_free_so (struct so_list *so)
+{
+  xfree (so->lm_info);
+}
+
+static void
+pa64_clear_solib (void)
+{
+}
+
+/* Wrapper for target_read_memory for dlgetmodinfo.  */
+
+static void *
+pa64_target_read_memory (void *buffer, CORE_ADDR ptr, size_t bufsiz, int ident)
+{
+  if (target_read_memory (ptr, buffer, bufsiz) != 0)
+    return 0;
+  return buffer;
+}
+
+/* Read the dynamic linker's internal shared library descriptor.
+
+   This must happen after dld starts running, so we can't do it in
+   read_dynamic_info.  Record the fact that we have loaded the
+   descriptor.  If the library is archive bound, then return zero, else
+   return nonzero.  */
+
+static int
+read_dld_descriptor (void)
+{
+  char *dll_path;
+  asection *dyninfo_sect;
+
+  /* If necessary call read_dynamic_info to extract the contents of the
+     .dynamic section from the shared library.  */
+  if (!dld_cache.is_valid) 
+    {
+      if (symfile_objfile == NULL)
+	error ("No object file symbols.");
+
+      dyninfo_sect = bfd_get_section_by_name (symfile_objfile->obfd, 
+					      ".dynamic");
+      if (!dyninfo_sect) 
+	{
+	  return 0;
+	}
+
+      if (!read_dynamic_info (dyninfo_sect, &dld_cache))
+	error ("Unable to read in .dynamic section information.");
+    }
+
+  /* Read the load map pointer.  */
+  if (target_read_memory (dld_cache.load_map_addr,
+			  (char *) &dld_cache.load_map,
+			  sizeof (dld_cache.load_map))
+      != 0)
+    {
+      error ("Error while reading in load map pointer.");
+    }
+
+  /* Read in the dld load module descriptor */
+  if (dlgetmodinfo (-1, 
+		    &dld_cache.dld_desc,
+		    sizeof (dld_cache.dld_desc), 
+		    pa64_target_read_memory, 
+		    0, 
+		    dld_cache.load_map)
+      == 0)
+    {
+      error ("Error trying to get information about dynamic linker.");
+    }
+
+  /* Indicate that we have loaded the dld descriptor.  */
+  dld_cache.have_read_dld_descriptor = 1;
+
+  return 1;
+}
+
+
+/* Read the .dynamic section and extract the information of interest,
+   which is stored in dld_cache.  The routine elf_locate_base in solib.c 
+   was used as a model for this.  */
+
+static int
+read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p)
+{
+  char *buf;
+  char *bufend;
+  CORE_ADDR dyninfo_addr;
+  int dyninfo_sect_size;
+  CORE_ADDR entry_addr;
+
+  /* Read in .dynamic section, silently ignore errors.  */
+  dyninfo_addr = bfd_section_vma (symfile_objfile->obfd, dyninfo_sect);
+  dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
+  buf = alloca (dyninfo_sect_size);
+  if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
+    return 0;
+
+  /* Scan the .dynamic section and record the items of interest. 
+     In particular, DT_HP_DLD_FLAGS */
+  for (bufend = buf + dyninfo_sect_size, entry_addr = dyninfo_addr;
+       buf < bufend;
+       buf += sizeof (Elf64_Dyn), entry_addr += sizeof (Elf64_Dyn))
+    {
+      Elf64_Dyn *x_dynp = (Elf64_Dyn*)buf;
+      Elf64_Sxword dyn_tag;
+      CORE_ADDR	dyn_ptr;
+      char *pbuf;
+
+      pbuf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
+      dyn_tag = bfd_h_get_64 (symfile_objfile->obfd, 
+			      (bfd_byte*) &x_dynp->d_tag);
+
+      /* We can't use a switch here because dyn_tag is 64 bits and HP's
+	 lame comiler does not handle 64bit items in switch statements.  */
+      if (dyn_tag == DT_NULL)
+	break;
+      else if (dyn_tag == DT_HP_DLD_FLAGS)
+	{
+	  /* Set dld_flags_addr and dld_flags in *dld_cache_p */
+	  dld_cache_p->dld_flags_addr = entry_addr + offsetof(Elf64_Dyn, d_un);
+	  if (target_read_memory (dld_cache_p->dld_flags_addr,
+	  			  (char*) &dld_cache_p->dld_flags, 
+				  sizeof (dld_cache_p->dld_flags))
+	      != 0)
+	    {
+	      error ("Error while reading in .dynamic section of the program.");
+	    }
+	}
+      else if (dyn_tag == DT_HP_LOAD_MAP)
+	{
+	  /* Dld will place the address of the load map at load_map_addr
+	     after it starts running.  */
+	  if (target_read_memory (entry_addr + offsetof(Elf64_Dyn, 
+							d_un.d_ptr),
+				  (char*) &dld_cache_p->load_map_addr,
+				  sizeof (dld_cache_p->load_map_addr))
+	      != 0)
+	    {
+	      error ("Error while reading in .dynamic section of the program.");
+	    }
+	}
+      else 
+	{
+	  /* tag is not of interest */
+	}
+    }
+
+  /* Record other information and set is_valid to 1. */
+  dld_cache_p->dyninfo_sect = dyninfo_sect;
+
+  /* Verify that we read in required info.  These fields are re-set to zero
+     in pa64_solib_restart.  */
+
+  if (dld_cache_p->dld_flags_addr != 0 && dld_cache_p->load_map_addr != 0) 
+    dld_cache_p->is_valid = 1;
+  else 
+    return 0;
+
+  return 1;
+}
+
+/*
+   bfd_lookup_symbol -- lookup the value for a specific symbol
+
+   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).
+ */
+
+static CORE_ADDR
+bfd_lookup_symbol (bfd *abfd, 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;
+
+  storage_needed = bfd_get_symtab_upper_bound (abfd);
+
+  if (storage_needed > 0)
+    {
+      symbol_table = (asymbol **) xmalloc (storage_needed);
+      back_to = make_cleanup (xfree, symbol_table);
+      number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
+
+      for (i = 0; i < number_of_symbols; i++)
+	{
+	  sym = *symbol_table++;
+	  if (strcmp (sym->name, symname) == 0)
+	    {
+	      /* Bfd symbols are section relative. */
+	      symaddr = sym->value + sym->section->vma;
+	      break;
+	    }
+	}
+      do_cleanups (back_to);
+    }
+  return (symaddr);
+}
+
+
+/* This hook gets called just before the first instruction in the
+   inferior process is executed.
+
+   This is our opportunity to set magic flags in the inferior so
+   that GDB can be notified when a shared library is mapped in and
+   to tell the dynamic linker that a private copy of the library is
+   needed (so GDB can set breakpoints in the library).
+
+   We need to set two flag bits in this routine.
+
+     DT_HP_DEBUG_PRIVATE to indicate that shared libraries should be
+     mapped private.
+
+     DT_HP_DEBUG_CALLBACK to indicate that we want the dynamic linker to
+     call the breakpoint routine for significant events.  */
+
+static void
+pa64_solib_create_inferior_hook (void)
+{
+  struct minimal_symbol *msymbol;
+  unsigned int dld_flags, status;
+  asection *shlib_info, *interp_sect;
+  char buf[4];
+  struct objfile *objfile;
+  CORE_ADDR anaddr;
+
+  /* First, remove all the solib event breakpoints.  Their addresses
+     may have changed since the last time we ran the program.  */
+  remove_solib_event_breakpoints ();
+
+  if (symfile_objfile == NULL)
+    return;
+
+  /* First see if the objfile was dynamically linked.  */
+  shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic");
+  if (!shlib_info)
+    return;
+
+  /* It's got a .dynamic section, make sure it's not empty.  */
+  if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
+    return;
+
+  /* Read in the .dynamic section.  */
+  if (! read_dynamic_info (shlib_info, &dld_cache))
+    error ("Unable to read the .dynamic section.");
+
+  /* Turn on the flags we care about.  */
+  dld_cache.dld_flags |= DT_HP_DEBUG_PRIVATE;
+  dld_cache.dld_flags |= DT_HP_DEBUG_CALLBACK;
+  status = target_write_memory (dld_cache.dld_flags_addr,
+				(char *) &dld_cache.dld_flags,
+				sizeof (dld_cache.dld_flags));
+  if (status != 0)
+    error ("Unable to modify dynamic linker flags.");
+
+  /* Now we have to create a shared library breakpoint in the dynamic
+     linker.  This can be somewhat tricky since the symbol is inside
+     the dynamic linker (for which we do not have symbols or a base
+     load address!   Luckily I wrote this code for solib.c years ago.  */
+  interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
+  if (interp_sect)
+    {
+      unsigned int interp_sect_size;
+      char *buf;
+      CORE_ADDR load_addr;
+      bfd *tmp_bfd;
+      CORE_ADDR sym_addr = 0;
+
+      /* Read the contents of the .interp section into a local buffer;
+	 the contents specify the dynamic linker this program uses.  */
+      interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
+      buf = alloca (interp_sect_size);
+      bfd_get_section_contents (exec_bfd, interp_sect,
+				buf, 0, interp_sect_size);
+
+      /* Now we need to figure out where the dynamic linker was
+	 loaded so that we can load its symbols and place a breakpoint
+	 in the dynamic linker itself.
+
+	 This address is stored on the stack.  However, I've been unable
+	 to find any magic formula to find it for Solaris (appears to
+	 be trivial on GNU/Linux).  Therefore, we have to try an alternate
+	 mechanism to find the dynamic linker's base address.  */
+      tmp_bfd = bfd_openr (buf, gnutarget);
+      if (tmp_bfd == NULL)
+	return;
+
+      /* Make sure the dynamic linker's really a useful object.  */
+      if (!bfd_check_format (tmp_bfd, bfd_object))
+	{
+	  warning ("Unable to grok dynamic linker %s as an object file", buf);
+	  bfd_close (tmp_bfd);
+	  return;
+	}
+
+      /* We find the dynamic linker's base address by examining the
+	 current pc (which point at the entry point for the dynamic
+	 linker) and subtracting the offset of the entry point. 
+
+	 Also note the breakpoint is the second instruction in the
+	 routine.  */
+      load_addr = read_pc () - tmp_bfd->start_address;
+      sym_addr = bfd_lookup_symbol (tmp_bfd, "__dld_break");
+      sym_addr = load_addr + sym_addr + 4;
+      
+      /* Create the shared library breakpoint.  */
+      {
+	struct breakpoint *b
+	  = create_solib_event_breakpoint (sym_addr);
+
+	/* The breakpoint is actually hard-coded into the dynamic linker,
+	   so we don't need to actually insert a breakpoint instruction
+	   there.  In fact, the dynamic linker's code is immutable, even to
+	   ttrace, so we shouldn't even try to do that.  For cases like
+	   this, we have "permanent" breakpoints.  */
+	make_breakpoint_permanent (b);
+      }
+
+      /* We're done with the temporary bfd.  */
+      bfd_close (tmp_bfd);
+    }
+}
+
+static void
+pa64_special_symbol_handling (void)
+{
+}
+
+static struct so_list *
+pa64_current_sos (void)
+{
+  struct so_list *head = 0;
+  struct so_list **link_ptr = &head;
+  int dll_index;
+
+  /* Read in the load map pointer if we have not done so already.  */
+  if (! dld_cache.have_read_dld_descriptor)
+    if (! read_dld_descriptor ())
+      return NULL;
+
+  /* If the libraries were not mapped private, warn the user.  */
+  if ((dld_cache.dld_flags & DT_HP_DEBUG_PRIVATE) == 0)
+    warning ("The shared libraries were not privately mapped; setting a\n"
+    	     "breakpoint in a shared library will not work until you rerun "
+	     "the program.\n");
+
+  for (dll_index = 1; ; dll_index++)
+    {
+      struct load_module_desc dll_desc;
+      char *dll_path;
+      struct so_list *new;
+      struct cleanup *old_chain;
+
+      /* Read in the load module descriptor.  */
+      if (dlgetmodinfo (dll_index, &dll_desc, sizeof (dll_desc),
+			pa64_target_read_memory, 0, dld_cache.load_map)
+	  == 0)
+	break;
+
+      /* Get the name of the shared library.  */
+      dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
+			    pa64_target_read_memory,
+			    0, dld_cache.load_map);
+
+      if (dll_path == NULL)
+        dll_path = "";
+
+      new = (struct so_list *) xmalloc (sizeof (struct so_list));
+      memset (new, 0, sizeof (struct so_list));
+      new->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
+      memset (new->lm_info, 0, sizeof (struct lm_info));
+
+      strncpy (new->so_name, dll_path, SO_NAME_MAX_PATH_SIZE - 1);
+      new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
+      strcpy (new->so_original_name, new->so_name);
+
+      memcpy (&new->lm_info->desc, &dll_desc, sizeof (dll_desc));
+
+#ifdef SOLIB_PA64_DBG
+      {
+        struct load_module_desc *d = &new->lm_info->desc;
+	printf ("\n+ library \"%s\" is described at index %d\n", new->so_name, 
+		dll_index);
+	printf ("    text_base = 0x%llx\n", d->text_base); 
+	printf ("    text_size = 0x%llx\n", d->text_size); 
+	printf ("    data_base = 0x%llx\n", d->data_base); 
+	printf ("    data_size = 0x%llx\n", d->data_size); 
+	printf ("    unwind_base = 0x%llx\n", d->unwind_base); 
+	printf ("    linkage_ptr = 0x%llx\n", d->linkage_ptr); 
+	printf ("    phdr_base = 0x%llx\n", d->phdr_base); 
+	printf ("    tls_size = 0x%llx\n", d->tls_size); 
+	printf ("    tls_start_addr = 0x%llx\n", d->tls_start_addr); 
+	printf ("    unwind_size = 0x%llx\n", d->unwind_size); 
+	printf ("    tls_index = 0x%llx\n", d->tls_index); 
+      }
+#endif
+
+      /* Link the new object onto the list.  */
+      new->next = NULL;
+      *link_ptr = new;
+      link_ptr = &new->next;
+    }
+
+  return head;
+}
+
+static int
+pa64_open_symbol_file_object (void *from_ttyp)
+{
+  int from_tty = *(int *)from_ttyp;
+  char buf[4];
+  struct load_module_desc dll_desc;
+  char *dll_path;
+
+  if (symfile_objfile)
+    if (!query ("Attempt to reload symbols from process? "))
+      return 0;
+
+  /* Read in the load map pointer if we have not done so already.  */
+  if (! dld_cache.have_read_dld_descriptor)
+    if (! read_dld_descriptor ())
+      return 0;
+
+  /* Read in the load module descriptor.  */
+  if (dlgetmodinfo (0, &dll_desc, sizeof (dll_desc),
+		    pa64_target_read_memory, 0, dld_cache.load_map) == 0)
+    return 0;
+
+  /* Get the name of the shared library.  */
+  dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
+				pa64_target_read_memory,
+				0, dld_cache.load_map);
+
+  /* Have a pathname: read the symbol file.  */
+  symbol_file_add_main (dll_path, from_tty);
+
+  return 1;
+}
+
+/* Return nonzero if PC is an address inside the dynamic linker.  */
+static int
+pa64_in_dynsym_resolve_code (CORE_ADDR pc)
+{
+  asection *shlib_info;
+
+  if (symfile_objfile == NULL)
+    return 0;
+
+  if (!dld_cache.have_read_dld_descriptor)
+    if (!read_dld_descriptor ())
+      return 0;
+
+  return (pc >= dld_cache.dld_desc.text_base
+	  && pc < dld_cache.dld_desc.text_base + dld_cache.dld_desc.text_size);
+}
+
+
+/* Return the GOT value for the shared library in which ADDR belongs.  If
+   ADDR isn't in any known shared library, return zero.  */
+
+static CORE_ADDR
+pa64_solib_get_got_by_pc (CORE_ADDR addr)
+{
+  struct so_list *so_list = master_so_list ();
+  CORE_ADDR got_value = 0;
+
+  while (so_list)
+    {
+      if (so_list->lm_info->desc.text_base <= addr
+	  && ((so_list->lm_info->desc.text_base
+	       + so_list->lm_info->desc.text_size)
+	      > addr))
+	{
+	  got_value = so_list->lm_info->desc.linkage_ptr;
+	  break;
+	}
+      so_list = so_list->next;
+    }
+  return got_value;
+}
+
+/* Get some HPUX-specific data from a shared lib.  */
+static CORE_ADDR
+pa64_solib_thread_start_addr (struct so_list *so)
+{
+  return so->lm_info->desc.tls_start_addr;
+}
+
+
+/* Return the address of the handle of the shared library in which ADDR
+   belongs.  If ADDR isn't in any known shared library, return zero. 
+
+   This function is used in hppa_fix_call_dummy in hppa-tdep.c.  */
+
+static CORE_ADDR
+pa64_solib_get_solib_by_pc (CORE_ADDR addr)
+{
+  struct so_list *so_list = master_so_list ();
+  CORE_ADDR retval = 0;
+
+  while (so_list)
+    {
+      if (so_list->lm_info->desc.text_base <= addr
+	  && ((so_list->lm_info->desc.text_base
+	       + so_list->lm_info->desc.text_size)
+	      > addr))
+	{
+	  retval = so_list->lm_info->desc_addr;
+	  break;
+	}
+      so_list = so_list->next;
+    }
+  return retval;
+}
+
+static struct target_so_ops pa64_so_ops;
+
+extern initialize_file_ftype _initialize_pa64_solib; /* -Wmissing-prototypes */
+
+void
+_initialize_pa64_solib (void)
+{
+  pa64_so_ops.relocate_section_addresses = pa64_relocate_section_addresses;
+  pa64_so_ops.free_so = pa64_free_so;
+  pa64_so_ops.clear_solib = pa64_clear_solib;
+  pa64_so_ops.solib_create_inferior_hook = pa64_solib_create_inferior_hook;
+  pa64_so_ops.special_symbol_handling = pa64_special_symbol_handling;
+  pa64_so_ops.current_sos = pa64_current_sos;
+  pa64_so_ops.open_symbol_file_object = pa64_open_symbol_file_object;
+  pa64_so_ops.in_dynsym_resolve_code = pa64_in_dynsym_resolve_code;
+
+  memset (&dld_cache, 0, sizeof (dld_cache));
+}
+
+void pa64_solib_select (struct gdbarch_tdep *tdep)
+{
+  current_target_so_ops = &pa64_so_ops;
+
+  tdep->solib_thread_start_addr = pa64_solib_thread_start_addr;
+  tdep->solib_get_got_by_pc = pa64_solib_get_got_by_pc;
+  tdep->solib_get_solib_by_pc = pa64_solib_get_solib_by_pc;
+}
+
+#else /* PA_SOM_ONLY */
+
+extern initialize_file_ftype _initialize_pa64_solib; /* -Wmissing-prototypes */
+
+void
+_initialize_pa64_solib (void)
+{
+}
+
+void pa64_solib_select (struct gdbarch_tdep *tdep)
+{
+  /* For a SOM-only target, there is no pa64 solib support.  This is needed
+     for hppa-hpux-tdep.c to build.  */
+  error ("Cannot select pa64 solib support for this configuration.\n");
+}
+#endif
Index: solib-pa64.h
===================================================================
RCS file: solib-pa64.h
diff -N solib-pa64.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ solib-pa64.h	8 Dec 2004 01:33:42 -0000
@@ -0,0 +1,27 @@
+/* Handle PA64 shared libraries for GDB, the GNU Debugger.
+
+   Copyright 2004 Free Software Foundation, Inc.
+
+   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 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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef SOLIB_PA64_H
+#define SOLIB_PA64_H
+
+void pa64_solib_select (struct gdbarch_tdep *tdep);
+
+#endif
Index: solib-som.c
===================================================================
RCS file: solib-som.c
diff -N solib-som.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ solib-som.c	8 Dec 2004 01:33:43 -0000
@@ -0,0 +1,898 @@
+/* Handle SOM shared libraries for GDB, the GNU Debugger.
+
+   Copyright 2004 Free Software Foundation, Inc.
+
+   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 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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "som.h"
+#include "symtab.h"
+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "inferior.h"
+
+#include "hppa-tdep.h"
+#include "solist.h"
+
+#undef SOLIB_SOM_DBG 
+
+/* These ought to be defined in some public interface, but aren't.  They
+   define the meaning of the various bits in the distinguished __dld_flags
+   variable that is declared in every debuggable a.out on HP-UX, and that
+   is shared between the debugger and the dynamic linker.
+ */
+#define DLD_FLAGS_MAPPRIVATE    0x1
+#define DLD_FLAGS_HOOKVALID     0x2
+#define DLD_FLAGS_LISTVALID     0x4
+#define DLD_FLAGS_BOR_ENABLE    0x8
+
+struct lm_info
+  {
+    /* Version of this structure (it is expected to change again in hpux10).  */
+    unsigned char struct_version;
+
+    /* Binding mode for this library.  */
+    unsigned char bind_mode;
+
+    /* Version of this library.  */
+    short library_version;
+
+    /* Start of text address,
+       link-time text location (length of text area),
+       end of text address.  */
+    CORE_ADDR text_addr;
+    CORE_ADDR text_link_addr;
+    CORE_ADDR text_end;
+
+    /* Start of data, start of bss and end of data.  */
+    CORE_ADDR data_start;
+    CORE_ADDR bss_start;
+    CORE_ADDR data_end;
+
+    /* Value of linkage pointer (%r19).  */
+    CORE_ADDR got_value;
+
+    /* Address in target of offset from thread-local register of
+       start of this thread's data.  I.e., the first thread-local
+       variable in this shared library starts at *(tsd_start_addr)
+       from that area pointed to by cr27 (mpsfu_hi).
+      
+       We do the indirection as soon as we read it, so from then
+       on it's the offset itself.  */
+    CORE_ADDR tsd_start_addr;
+
+    /* Address of the link map entry in the loader.  */
+    CORE_ADDR lm_addr;
+  };
+
+/* These addresses should be filled in by som_solib_create_inferior_hook.
+   They are also used elsewhere in this module.
+ */
+typedef struct
+  {
+    CORE_ADDR address;
+    struct unwind_table_entry *unwind;
+  }
+addr_and_unwind_t;
+
+/* When adding fields, be sure to clear them in _initialize_som_solib. */
+static struct
+  {
+    int is_valid;
+    addr_and_unwind_t hook;
+    addr_and_unwind_t hook_stub;
+    addr_and_unwind_t load;
+    addr_and_unwind_t load_stub;
+    addr_and_unwind_t unload;
+    addr_and_unwind_t unload2;
+    addr_and_unwind_t unload_stub;
+  }
+dld_cache;
+
+static void
+som_relocate_section_addresses (struct so_list *so,
+				struct section_table *sec)
+{
+  flagword aflag = bfd_get_section_flags(so->abfd, sec->the_bfd_section);
+
+  /* solib.c does something similar, but it only recognizes ".text", SOM calls
+     the text section "$CODE$".  */
+  if (strcmp (sec->the_bfd_section->name, "$CODE$") == 0)
+    {
+      so->textsection = sec;
+    }
+
+  if (aflag & SEC_CODE)
+    {
+      sec->addr    += so->lm_info->text_addr - so->lm_info->text_link_addr; 
+      sec->endaddr += so->lm_info->text_addr - so->lm_info->text_link_addr;
+    }
+  else if (aflag & SEC_DATA)
+    {
+      sec->addr    += so->lm_info->data_start; 
+      sec->endaddr += so->lm_info->data_start;
+    }
+  else
+    ;
+}
+
+/* This hook gets called just before the first instruction in the
+   inferior process is executed.
+
+   This is our opportunity to set magic flags in the inferior so
+   that GDB can be notified when a shared library is mapped in and
+   to tell the dynamic linker that a private copy of the library is
+   needed (so GDB can set breakpoints in the library).
+
+   __dld_flags is the location of the magic flags; as of this implementation
+   there are 3 flags of interest:
+
+   bit 0 when set indicates that private copies of the libraries are needed
+   bit 1 when set indicates that the callback hook routine is valid
+   bit 2 when set indicates that the dynamic linker should maintain the
+   __dld_list structure when loading/unloading libraries.
+
+   Note that shared libraries are not mapped in at this time, so we have
+   run the inferior until the libraries are mapped in.  Typically this
+   means running until the "_start" is called.  */
+
+static void
+som_solib_create_inferior_hook (void)
+{
+  struct minimal_symbol *msymbol;
+  unsigned int dld_flags, status, have_endo;
+  asection *shlib_info;
+  char buf[4];
+  struct objfile *objfile;
+  CORE_ADDR anaddr;
+
+  /* First, remove all the solib event breakpoints.  Their addresses
+     may have changed since the last time we ran the program.  */
+  remove_solib_event_breakpoints ();
+
+  if (symfile_objfile == NULL)
+    return;
+
+  /* First see if the objfile was dynamically linked.  */
+  shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
+  if (!shlib_info)
+    return;
+
+  /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
+  if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
+    return;
+
+  have_endo = 0;
+  /* Slam the pid of the process into __d_pid.
+
+     We used to warn when this failed, but that warning is only useful
+     on very old HP systems (hpux9 and older).  The warnings are an
+     annoyance to users of modern systems and foul up the testsuite as
+     well.  As a result, the warnings have been disabled.  */
+  msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    goto keep_going;
+
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  store_unsigned_integer (buf, 4, PIDGET (inferior_ptid));
+  status = target_write_memory (anaddr, buf, 4);
+  if (status != 0)
+    {
+      warning ("Unable to write __d_pid");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      goto keep_going;
+    }
+
+  /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
+     This will force the dynamic linker to call __d_trap when significant
+     events occur.
+
+     Note that the above is the pre-HP-UX 9.0 behaviour.  At 9.0 and above,
+     the dld provides an export stub named "__d_trap" as well as the
+     function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
+     We'll look first for the old flavor and then the new.
+   */
+  msymbol = lookup_minimal_symbol ("_DLD_HOOK", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    {
+      warning ("Unable to find _DLD_HOOK symbol in object file.");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      goto keep_going;
+    }
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  dld_cache.hook.address = anaddr;
+
+  /* Grrr, this might not be an export symbol!  We have to find the
+     export stub.  */
+  ALL_OBJFILES (objfile)
+  {
+    struct unwind_table_entry *u;
+    struct minimal_symbol *msymbol2;
+
+    /* What a crock.  */
+    msymbol2 =
+      lookup_minimal_symbol_solib_trampoline (SYMBOL_LINKAGE_NAME (msymbol),
+					      objfile);
+    /* Found a symbol with the right name.  */
+    if (msymbol2)
+      {
+	struct unwind_table_entry *u;
+	/* It must be a shared library trampoline.  */
+	if (SYMBOL_TYPE (msymbol2) != mst_solib_trampoline)
+	  continue;
+
+	/* It must also be an export stub.  */
+	u = find_unwind_entry (SYMBOL_VALUE (msymbol2));
+	if (!u || u->stub_unwind.stub_type != EXPORT)
+	  continue;
+
+	/* OK.  Looks like the correct import stub.  */
+	anaddr = SYMBOL_VALUE (msymbol2);
+	dld_cache.hook_stub.address = anaddr;
+      }
+  }
+  store_unsigned_integer (buf, 4, anaddr);
+
+  msymbol = lookup_minimal_symbol ("__dld_hook", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    {
+      warning ("Unable to find __dld_hook symbol in object file.");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      goto keep_going;
+    }
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  status = target_write_memory (anaddr, buf, 4);
+
+  /* Now set a shlib_event breakpoint at __d_trap so we can track
+     significant shared library events.  */
+  msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    {
+      warning ("Unable to find __dld_d_trap symbol in object file.");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      goto keep_going;
+    }
+  create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
+
+  /* We have all the support usually found in end.o, so we can track
+     shl_load and shl_unload calls.  */
+  have_endo = 1;
+
+keep_going:
+
+  /* Get the address of __dld_flags, if no such symbol exists, then we can
+     not debug the shared code.  */
+  msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
+  if (msymbol == NULL)
+    {
+      error ("Unable to find __dld_flags symbol in object file.\n");
+    }
+
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+
+  /* Read the current contents.  */
+  status = target_read_memory (anaddr, buf, 4);
+  if (status != 0)
+    {
+      error ("Unable to read __dld_flags\n");
+    }
+  dld_flags = extract_unsigned_integer (buf, 4);
+
+  /* Turn on the flags we care about.  */
+  dld_flags |= DLD_FLAGS_MAPPRIVATE;
+  if (have_endo)
+    dld_flags |= DLD_FLAGS_HOOKVALID;
+  store_unsigned_integer (buf, 4, dld_flags);
+  status = target_write_memory (anaddr, buf, 4);
+  if (status != 0)
+    {
+      error ("Unable to write __dld_flags\n");
+    }
+
+  /* Now find the address of _start and set a breakpoint there. 
+     We still need this code for two reasons:
+
+     * Not all sites have /opt/langtools/lib/end.o, so it's not always
+     possible to track the dynamic linker's events.
+
+     * At this time no events are triggered for shared libraries
+     loaded at startup time (what a crock).  */
+
+  msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
+  if (msymbol == NULL)
+    {
+      error ("Unable to find _start symbol in object file.\n");
+    }
+
+  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+
+  /* Make the breakpoint at "_start" a shared library event breakpoint.  */
+  create_solib_event_breakpoint (anaddr);
+
+  clear_symtab_users ();
+}
+
+/* This operation removes the "hook" between GDB and the dynamic linker,
+   which causes the dld to notify GDB of shared library events.
+
+   After this operation completes, the dld will no longer notify GDB of
+   shared library events.  To resume notifications, GDB must call
+   som_solib_create_inferior_hook.
+
+   This operation does not remove any knowledge of shared libraries which
+   GDB may already have been notified of.
+ */
+static void
+som_solib_remove_inferior_hook (int pid)
+{
+  CORE_ADDR addr;
+  struct minimal_symbol *msymbol;
+  int status;
+  char dld_flags_buffer[4];
+  unsigned int dld_flags_value;
+  struct cleanup *old_cleanups = save_inferior_ptid ();
+
+  /* Ensure that we're really operating on the specified process. */
+  inferior_ptid = pid_to_ptid (pid);
+
+  /* We won't bother to remove the solib breakpoints from this process.
+
+     In fact, on PA64 the breakpoint is hard-coded into the dld callback,
+     and thus we're not supposed to remove it.
+
+     Rather, we'll merely clear the dld_flags bit that enables callbacks.
+   */
+  msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
+
+  addr = SYMBOL_VALUE_ADDRESS (msymbol);
+  status = target_read_memory (addr, dld_flags_buffer, 4);
+
+  dld_flags_value = extract_unsigned_integer (dld_flags_buffer, 4);
+
+  dld_flags_value &= ~DLD_FLAGS_HOOKVALID;
+  store_unsigned_integer (dld_flags_buffer, 4, dld_flags_value);
+  status = target_write_memory (addr, dld_flags_buffer, 4);
+
+  do_cleanups (old_cleanups);
+}
+
+static void
+som_special_symbol_handling (void)
+{
+}
+
+static void
+som_solib_desire_dynamic_linker_symbols (void)
+{
+  struct objfile *objfile;
+  struct unwind_table_entry *u;
+  struct minimal_symbol *dld_msymbol;
+
+  /* Do we already know the value of these symbols?  If so, then
+     we've no work to do.
+
+     (If you add clauses to this test, be sure to likewise update the
+     test within the loop.)
+   */
+  if (dld_cache.is_valid)
+    return;
+
+  ALL_OBJFILES (objfile)
+  {
+    dld_msymbol = lookup_minimal_symbol ("shl_load", NULL, objfile);
+    if (dld_msymbol != NULL)
+      {
+	dld_cache.load.address = SYMBOL_VALUE (dld_msymbol);
+	dld_cache.load.unwind = find_unwind_entry (dld_cache.load.address);
+      }
+
+    dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_load",
+							  objfile);
+    if (dld_msymbol != NULL)
+      {
+	if (SYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
+	  {
+	    u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
+	    if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
+	      {
+		dld_cache.load_stub.address = SYMBOL_VALUE (dld_msymbol);
+		dld_cache.load_stub.unwind = u;
+	      }
+	  }
+      }
+
+    dld_msymbol = lookup_minimal_symbol ("shl_unload", NULL, objfile);
+    if (dld_msymbol != NULL)
+      {
+	dld_cache.unload.address = SYMBOL_VALUE (dld_msymbol);
+	dld_cache.unload.unwind = find_unwind_entry (dld_cache.unload.address);
+
+	/* ??rehrauer: I'm not sure exactly what this is, but it appears
+	   that on some HPUX 10.x versions, there's two unwind regions to
+	   cover the body of "shl_unload", the second being 4 bytes past
+	   the end of the first.  This is a large hack to handle that
+	   case, but since I don't seem to have any legitimate way to
+	   look for this thing via the symbol table...
+	 */
+	if (dld_cache.unload.unwind != NULL)
+	  {
+	    u = find_unwind_entry (dld_cache.unload.unwind->region_end + 4);
+	    if (u != NULL)
+	      {
+		dld_cache.unload2.address = u->region_start;
+		dld_cache.unload2.unwind = u;
+	      }
+	  }
+      }
+
+    dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_unload",
+							  objfile);
+    if (dld_msymbol != NULL)
+      {
+	if (SYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
+	  {
+	    u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
+	    if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
+	      {
+		dld_cache.unload_stub.address = SYMBOL_VALUE (dld_msymbol);
+		dld_cache.unload_stub.unwind = u;
+	      }
+	  }
+      }
+
+    /* Did we find everything we were looking for?  If so, stop. */
+    if ((dld_cache.load.address != 0)
+	&& (dld_cache.load_stub.address != 0)
+	&& (dld_cache.unload.address != 0)
+	&& (dld_cache.unload_stub.address != 0))
+      {
+	dld_cache.is_valid = 1;
+	break;
+      }
+  }
+
+  dld_cache.hook.unwind = find_unwind_entry (dld_cache.hook.address);
+  dld_cache.hook_stub.unwind = find_unwind_entry (dld_cache.hook_stub.address);
+
+  /* We're prepared not to find some of these symbols, which is why
+     this function is a "desire" operation, and not a "require".
+   */
+}
+
+static int
+som_in_dynsym_resolve_code (CORE_ADDR pc)
+{
+  struct unwind_table_entry *u_pc;
+
+  /* Are we in the dld itself?
+
+     ??rehrauer: Large hack -- We'll assume that any address in a
+     shared text region is the dld's text.  This would obviously
+     fall down if the user attached to a process, whose shlibs
+     weren't mapped to a (writeable) private region.  However, in
+     that case the debugger probably isn't able to set the fundamental
+     breakpoint in the dld callback anyways, so this hack should be
+     safe.
+   */
+  if ((pc & (CORE_ADDR) 0xc0000000) == (CORE_ADDR) 0xc0000000)
+    return 1;
+
+  /* Cache the address of some symbols that are part of the dynamic
+     linker, if not already known.
+   */
+  som_solib_desire_dynamic_linker_symbols ();
+
+  /* Are we in the dld callback?  Or its export stub? */
+  u_pc = find_unwind_entry (pc);
+  if (u_pc == NULL)
+    return 0;
+
+  if ((u_pc == dld_cache.hook.unwind) || (u_pc == dld_cache.hook_stub.unwind))
+    return 1;
+
+  /* Or the interface of the dld (i.e., "shl_load" or friends)? */
+  if ((u_pc == dld_cache.load.unwind)
+      || (u_pc == dld_cache.unload.unwind)
+      || (u_pc == dld_cache.unload2.unwind)
+      || (u_pc == dld_cache.load_stub.unwind)
+      || (u_pc == dld_cache.unload_stub.unwind))
+    return 1;
+
+  /* Apparently this address isn't part of the dld's text. */
+  return 0;
+}
+
+static void
+som_clear_solib (void)
+{
+}
+
+struct dld_list {
+  char name[4];
+  char info[4];
+  char text_addr[4];
+  char text_link_addr[4];
+  char text_end[4];
+  char data_start[4];
+  char bss_start[4];
+  char data_end[4];
+  char got_value[4];
+  char next[4];
+  char tsd_start_addr_ptr[4];
+};
+
+static CORE_ADDR
+link_map_start (void)
+{
+  struct minimal_symbol *sym;
+  CORE_ADDR addr;
+  char buf[4];
+  unsigned int dld_flags;
+
+  sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
+  if (!sym)
+    {
+      error ("Unable to find __dld_flags symbol in object file.\n");
+      return 0;
+    }
+  addr = SYMBOL_VALUE_ADDRESS (sym);
+  read_memory (addr, buf, 4);
+  dld_flags = extract_unsigned_integer (buf, 4);
+  if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)
+    {
+      error ("__dld_list is not valid according to __dld_flags.\n");
+      return 0;
+    }
+
+  /* If the libraries were not mapped private, warn the user.  */
+  if ((dld_flags & DLD_FLAGS_MAPPRIVATE) == 0)
+    warning ("The shared libraries were not privately mapped; setting a\n"
+	     "breakpoint in a shared library will not work until you rerun the "
+	     "program.\n");
+
+  sym = lookup_minimal_symbol ("__dld_list", NULL, NULL);
+  if (!sym)
+    {
+      /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
+         but the data is still available if you know where to look.  */
+      sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
+      if (!sym)
+	{
+	  error ("Unable to find dynamic library list.\n");
+	  return 0;
+	}
+      addr = SYMBOL_VALUE_ADDRESS (sym) - 8;
+    }
+  else
+    addr = SYMBOL_VALUE_ADDRESS (sym);
+
+  read_memory (addr, buf, 4);
+  addr = extract_unsigned_integer (buf, 4);
+  if (addr == 0)
+    {
+      error ("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported.\n");
+      return 0;
+    }
+
+  read_memory (addr, buf, 4);
+  return extract_unsigned_integer (buf, 4);
+}
+
+/* Does this so's name match the main binary? */
+static int
+match_main (const char *name)
+{
+  return strcmp (name, symfile_objfile->name) == 0;
+}
+
+static struct so_list *
+som_current_sos (void)
+{
+  CORE_ADDR lm;
+  struct so_list *head = 0;
+  struct so_list **link_ptr = &head;
+
+  for (lm = link_map_start (); lm; )
+    {
+      char *namebuf;
+      CORE_ADDR addr;
+      struct so_list *new;
+      struct cleanup *old_chain;
+      int errcode;
+      struct dld_list dbuf;
+      char tsdbuf[4];
+
+      new = (struct so_list *) xmalloc (sizeof (struct so_list));
+      old_chain = make_cleanup (xfree, new);
+
+      memset (new, 0, sizeof (*new));
+      new->lm_info = xmalloc (sizeof (struct lm_info));
+      make_cleanup (xfree, new->lm_info);
+
+      read_memory (lm, (char *)&dbuf, sizeof (struct dld_list));
+
+      addr = extract_unsigned_integer (&dbuf.name, sizeof (dbuf.name));
+      target_read_string (addr, &namebuf, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
+      if (errcode != 0)
+	{
+	  warning ("current_sos: Can't read pathname for load map: %s\n",
+		   safe_strerror (errcode));
+	}
+      else
+	{
+	  strncpy (new->so_name, namebuf, SO_NAME_MAX_PATH_SIZE - 1);
+	  new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
+	  xfree (namebuf);
+	  strcpy (new->so_original_name, new->so_name);
+	}
+
+	if (new->so_name[0] && !match_main (new->so_name))
+	  {
+	    struct lm_info *lmi = new->lm_info;
+	    unsigned int tmp;
+
+	    lmi->lm_addr = lm;
+
+#define EXTRACT(_fld) \
+  extract_unsigned_integer (&dbuf._fld, sizeof (dbuf._fld));
+
+	    lmi->text_addr = EXTRACT (text_addr);
+	    tmp = EXTRACT (info);
+	    lmi->library_version = (tmp >> 16) & 0xffff;
+	    lmi->bind_mode = (tmp >> 8) & 0xff;
+	    lmi->struct_version = tmp & 0xff;
+	    lmi->text_link_addr = EXTRACT (text_link_addr);
+	    lmi->text_end = EXTRACT (text_end);
+	    lmi->data_start = EXTRACT (data_start);
+	    lmi->bss_start = EXTRACT (bss_start);
+	    lmi->data_end = EXTRACT (data_end);
+	    lmi->got_value = EXTRACT (got_value);
+	    tmp = EXTRACT (tsd_start_addr_ptr);
+	    read_memory (tmp, tsdbuf, 4);
+	    lmi->tsd_start_addr = extract_unsigned_integer (tsdbuf, 4);
+
+#ifdef SOLIB_SOM_DBG
+	    printf ("\n+ library \"%s\" is described at 0x%s\n", new->so_name, 
+	    	    paddr_nz (lm));
+	    printf ("  'version' is %d\n", new->lm_info->struct_version);
+	    printf ("  'bind_mode' is %d\n", new->lm_info->bind_mode);
+	    printf ("  'library_version' is %d\n", 
+	    	    new->lm_info->library_version);
+	    printf ("  'text_addr' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->text_addr));
+	    printf ("  'text_link_addr' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->text_link_addr));
+	    printf ("  'text_end' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->text_end));
+	    printf ("  'data_start' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->data_start));
+	    printf ("  'bss_start' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->bss_start));
+	    printf ("  'data_end' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->data_end));
+	    printf ("  'got_value' is %s\n", 
+	    	    paddr_nz (new->lm_info->got_value));
+	    printf ("  'tsd_start_addr' is 0x%s\n", 
+	    	    paddr_nz (new->lm_info->tsd_start_addr));
+#endif
+
+	    /* Link the new object onto the list.  */
+	    new->next = NULL;
+	    *link_ptr = new;
+	    link_ptr = &new->next;
+	  }
+ 	else
+	  {
+	    free_so (new);
+	  }
+
+      lm = EXTRACT (next);
+      discard_cleanups (old_chain);
+#undef EXTRACT
+    }
+
+  /* TODO: The original somsolib code has logic to detect and eliminate 
+     duplicate entries.  Do we need that?  */
+
+  return head;
+}
+
+static int
+som_open_symbol_file_object (void *from_ttyp)
+{
+  CORE_ADDR lm, l_name;
+  char *filename;
+  int errcode;
+  int from_tty = *(int *)from_ttyp;
+  char buf[4];
+
+  if (symfile_objfile)
+    if (!query ("Attempt to reload symbols from process? "))
+      return 0;
+
+  /* First link map member should be the executable.  */
+  if ((lm = link_map_start ()) == 0)
+    return 0;	/* failed somehow... */
+
+  /* Read address of name from target memory to GDB.  */
+  read_memory (lm + offsetof (struct dld_list, name), buf, 4);
+
+  /* Convert the address to host format.  Assume that the address is
+     unsigned.  */
+  l_name = extract_unsigned_integer (buf, 4);
+
+  if (l_name == 0)
+    return 0;		/* No filename.  */
+
+  /* Now fetch the filename from target memory.  */
+  target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
+
+  if (errcode)
+    {
+      warning ("failed to read exec filename from attached file: %s",
+	       safe_strerror (errcode));
+      return 0;
+    }
+
+  make_cleanup (xfree, filename);
+  /* Have a pathname: read the symbol file.  */
+  symbol_file_add_main (filename, from_tty);
+
+  return 1;
+}
+
+static void
+som_free_so (struct so_list *so)
+{
+  xfree (so->lm_info);
+}
+
+static CORE_ADDR
+som_solib_thread_start_addr (struct so_list *so)
+{
+  return so->lm_info->tsd_start_addr;
+}
+
+/* Return the GOT value for the shared library in which ADDR belongs.  If
+   ADDR isn't in any known shared library, return zero.  */
+
+static CORE_ADDR
+som_solib_get_got_by_pc (CORE_ADDR addr)
+{
+  struct so_list *so_list = master_so_list ();
+  CORE_ADDR got_value = 0;
+
+  while (so_list)
+    {
+      if (so_list->lm_info->text_addr <= addr
+	  && so_list->lm_info->text_end > addr)
+	{
+	  got_value = so_list->lm_info->got_value;
+	  break;
+	}
+      so_list = so_list->next;
+    }
+  return got_value;
+}
+
+/* Return the address of the handle of the shared library in which ADDR belongs.
+   If ADDR isn't in any known shared library, return zero.  */
+/* this function is used in initialize_hp_cxx_exception_support in 
+   hppa-hpux-tdep.c  */
+
+static CORE_ADDR
+som_solib_get_solib_by_pc (CORE_ADDR addr)
+{
+  struct so_list *so_list = master_so_list ();
+
+  while (so_list)
+    {
+      if (so_list->lm_info->text_addr <= addr
+	  && so_list->lm_info->text_end > addr)
+	{
+	  break;
+	}
+      so_list = so_list->next;
+    }
+  if (so_list)
+    return so_list->lm_info->lm_addr;
+  else
+    return 0;
+}
+
+
+static struct target_so_ops som_so_ops;
+
+extern initialize_file_ftype _initialize_som_solib; /* -Wmissing-prototypes */
+
+void
+_initialize_som_solib (void)
+{
+  som_so_ops.relocate_section_addresses = som_relocate_section_addresses;
+  som_so_ops.free_so = som_free_so;
+  som_so_ops.clear_solib = som_clear_solib;
+  som_so_ops.solib_create_inferior_hook = som_solib_create_inferior_hook;
+  som_so_ops.special_symbol_handling = som_special_symbol_handling;
+  som_so_ops.current_sos = som_current_sos;
+  som_so_ops.open_symbol_file_object = som_open_symbol_file_object;
+  som_so_ops.in_dynsym_resolve_code = som_in_dynsym_resolve_code;
+}
+
+void som_solib_select (struct gdbarch_tdep *tdep)
+{
+  current_target_so_ops = &som_so_ops;
+
+  tdep->solib_thread_start_addr = som_solib_thread_start_addr;
+  tdep->solib_get_got_by_pc = som_solib_get_got_by_pc;
+  tdep->solib_get_solib_by_pc = som_solib_get_solib_by_pc;
+}
+
+/* The rest of these functions are not part of the solib interface; they 
+   are used by somread.c or hppa-hpux-tdep.c */
+
+int
+som_solib_section_offsets (struct objfile *objfile,
+			   struct section_offsets *offsets)
+{
+  struct so_list *so_list = master_so_list ();
+
+  while (so_list)
+    {
+      /* Oh what a pain!  We need the offsets before so_list->objfile
+         is valid.  The BFDs will never match.  Make a best guess.  */
+      if (strstr (objfile->name, so_list->so_name))
+	{
+	  asection *private_section;
+
+	  /* The text offset is easy.  */
+	  offsets->offsets[SECT_OFF_TEXT (objfile)]
+	    = (so_list->lm_info->text_addr
+	       - so_list->lm_info->text_link_addr);
+	  offsets->offsets[SECT_OFF_RODATA (objfile)]
+	    = ANOFFSET (offsets, SECT_OFF_TEXT (objfile));
+
+	  /* We should look at presumed_dp in the SOM header, but
+	     that's not easily available.  This should be OK though.  */
+	  private_section = bfd_get_section_by_name (objfile->obfd,
+						     "$PRIVATE$");
+	  if (!private_section)
+	    {
+	      warning ("Unable to find $PRIVATE$ in shared library!");
+	      offsets->offsets[SECT_OFF_DATA (objfile)] = 0;
+	      offsets->offsets[SECT_OFF_BSS (objfile)] = 0;
+	      return 1;
+	    }
+	  offsets->offsets[SECT_OFF_DATA (objfile)]
+	    = (so_list->lm_info->data_start - private_section->vma);
+	  offsets->offsets[SECT_OFF_BSS (objfile)]
+	    = ANOFFSET (offsets, SECT_OFF_DATA (objfile));
+	  return 1;
+	}
+      so_list = so_list->next;
+    }
+  return 0;
+}
Index: solib-som.h
===================================================================
RCS file: solib-som.h
diff -N solib-som.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ solib-som.h	8 Dec 2004 01:33:43 -0000
@@ -0,0 +1,35 @@
+/* Handle SOM shared libraries for GDB, the GNU Debugger.
+
+   Copyright 2004 Free Software Foundation, Inc.
+
+   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 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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef SOLIB_SOM_H
+#define SOLIB_SOM_H
+
+struct objfile;
+struct section_offsets;
+struct gdbarch_tdep;
+
+void som_solib_select (struct gdbarch_tdep *tdep);
+
+int som_solib_section_offsets (struct objfile *objfile,
+			       struct section_offsets *offsets);
+
+#endif
+

Re: [commit] First cut of SOM and PA64 solib support

[Kevin Buettner]

On Tue, 7 Dec 2004 17:38:49 -0800
Randolph Chung <randolph@tausq.org> wrote:

> One question -- none of the solib* files have entries in fnchange.lst.
> Are any entries needed?

I don't believe so.  Although the filename prefixes (before the ".")
are longer than eight characters, they're all distinguishable from
existing names in the first eight characters.  More concretely,
"solib-so" (from solib-som.[hc]) and "solib-pa" (from
"solib-pa64.[hc]) don't conflict in the first eight characters of any
existing names.  Note that if you ever added a solib-pa32.c, you'd
have to add an entry to fnchange.lst.

(I'm sure that someone who deals with 8.3 systems more than I do will
correct me if I'm wrong...)

Kevin

Re: [commit] First cut of SOM and PA64 solib support

[Eli Zaretskii]

> Date: Tue, 7 Dec 2004 17:38:49 -0800
> From: Randolph Chung <randolph@tausq.org>
> 
> One question -- none of the solib* files have entries in fnchange.lst.
> Are any entries needed?

Not at present, since their names are unique in the first 8
characters.

Btw, does this patch add something to the list of platforms/OS that
support solib?  We have a list of such platforms in gdb.texinfo (in
the "Files" node), so I'm wondering whether we need to add something
to that list.

Thanks.

Re: [commit] First cut of SOM and PA64 solib support

[Randolph Chung]

> Btw, does this patch add something to the list of platforms/OS that
> support solib?  We have a list of such platforms in gdb.texinfo (in
> the "Files" node), so I'm wondering whether we need to add something
> to that list.

are you talking about this bit?

@cindex shared libraries
@value{GDBN} supports HP-UX, SunOS, SVr4, Irix 5, and IBM RS/6000 shared
libraries.

if so i think that list is fine as is. this patch is just to modernize
the HPUX shared lib support; it does not add new functionality.

thanks
randolph
-- 
Randolph Chung
Debian GNU/Linux Developer, hppa/ia64 ports
http://www.tausq.org/

Re: [commit] First cut of SOM and PA64 solib support

[Eli Zaretskii]

> Date: Tue, 7 Dec 2004 22:05:12 -0800
> From: Randolph Chung <randolph@tausq.org>
> Cc: gdb-patches@sources.redhat.com
> 
> are you talking about this bit?
> 
> @cindex shared libraries
> @value{GDBN} supports HP-UX, SunOS, SVr4, Irix 5, and IBM RS/6000 shared
> libraries.

Yes.

> if so i think that list is fine as is. this patch is just to modernize
> the HPUX shared lib support; it does not add new functionality.

Okay, thanks for checking.