--- /dev/null
+/* 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
--- /dev/null
+/* 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;
+}
projects / binutils-gdb.git / commitdiff