Subversion Repositories or1k

/* Handle HP ELF shared libraries for GDB, the GNU Debugger.

   Copyright 1999 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 <dlfcn.h>

#include <elf.h>

#include <elf_hp.h>

#include "defs.h"

#include "frame.h"

#include "bfd.h"

#include "libhppa.h"

#include "gdbcore.h"

#include "symtab.h"

#include "breakpoint.h"

#include "symfile.h"

#include "objfiles.h"

#include "inferior.h"

#include "gdb-stabs.h"

#include "gdb_stat.h"

#include "gdbcmd.h"

#include "assert.h"

#include "language.h"

#include <fcntl.h>

#ifndef O_BINARY

#define O_BINARY 0

#endif

/* Defined in exec.c; used to prevent dangling pointer bug.  */

extern struct target_ops exec_ops;

static CORE_ADDR

  bfd_lookup_symbol PARAMS ((bfd *, char *));

/* This lives in hppa-tdep.c. */

extern struct unwind_table_entry *find_unwind_entry PARAMS ((CORE_ADDR pc));

/* These ought to be defined in some public interface, but aren't.  They

   identify dynamic linker events.  */

#define DLD_CB_LOAD     1

#define DLD_CB_UNLOAD   0

/* A structure to keep track of all the known shared objects.  */

struct so_list

  {

    bfd *abfd;

    char *name;

    struct so_list *next;

    struct objfile *objfile;

    CORE_ADDR pa64_solib_desc_addr;

    struct load_module_desc pa64_solib_desc;

    struct section_table *sections;

    struct section_table *sections_end;

    boolean loaded;

  };

static struct so_list *so_list_head;

/* This is the cumulative size in bytes of the symbol tables of all

   shared objects on the so_list_head list.  (When we say size, here

   we mean of the information before it is brought into memory and

   potentially expanded by GDB.)  When adding a new shlib, this value

   is compared against the threshold size, held by auto_solib_add

   (in megabytes).  If adding symbols for the new shlib would cause

   the total size to exceed the threshold, then the new shlib's symbols

   are not loaded.  */

static LONGEST pa64_solib_total_st_size;

/* When the threshold is reached for any shlib, we refuse to add

   symbols for subsequent shlibs, even if those shlibs' symbols would

   be small enough to fit under the threshold.  (Although this may

   result in one, early large shlib preventing the loading of later,

   smalller shlibs' symbols, it allows us to issue one informational

   message.  The alternative, to issue a message for each shlib whose

   symbols aren't loaded, could be a big annoyance where the threshold

   is exceeded due to a very large number of shlibs.) */

static int pa64_solib_st_size_threshold_exceeded;

/* When adding fields, be sure to clear them in _initialize_pa64_solib. */

typedef struct

  {

    CORE_ADDR dld_flags_addr;

    long long dld_flags;

    sec_ptr dyninfo_sect;

    boolean have_read_dld_descriptor;

    boolean 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 void pa64_sharedlibrary_info_command PARAMS ((char *, int));

static void pa64_solib_sharedlibrary_command PARAMS ((char *, int));

static void * pa64_target_read_memory PARAMS ((void *, CORE_ADDR, size_t, int));

static boolean read_dld_descriptor PARAMS ((struct target_ops *));

static boolean read_dynamic_info PARAMS ((asection *, dld_cache_t *));

static void add_to_solist PARAMS ((boolean, char *, struct load_module_desc *,

                                   CORE_ADDR, struct target_ops *));

/* When examining the shared library for debugging information we have to

   look for HP debug symbols, stabs and dwarf2 debug symbols.  */

static char *pa64_debug_section_names[] = {

  ".debug_header", ".debug_gntt", ".debug_lntt", ".debug_slt", ".debug_vt",

  ".stabs", ".stabstr", ".debug_info", ".debug_abbrev", ".debug_aranges",

  ".debug_macinfo", ".debug_line", ".debug_loc", ".debug_pubnames",

  ".debug_str", NULL

};

/* Return a ballbark figure for the amount of memory GDB will need to

   allocate to read in the debug symbols from FILENAME.  */

static LONGEST

pa64_solib_sizeof_symbol_table (filename)

     char *filename;

{

  bfd *abfd;

  int i;

  int desc;

  char *absolute_name;

  LONGEST st_size = (LONGEST) 0;

  asection *sect;

  /* We believe that filename was handed to us by the dynamic linker, and

     is therefore always an absolute path.  */

  desc = openp (getenv ("PATH"), 1, filename, O_RDONLY | O_BINARY,

                0, &absolute_name);

  if (desc < 0)

    {

      perror_with_name (filename);

    }

  filename = absolute_name;

  abfd = bfd_fdopenr (filename, gnutarget, desc);

  if (!abfd)

    {

      close (desc);

      make_cleanup (free, filename);

      error ("\"%s\": can't open to read symbols: %s.", filename,

             bfd_errmsg (bfd_get_error ()));

    }

  if (!bfd_check_format (abfd, bfd_object))

    {

      bfd_close (abfd);

      make_cleanup (free, filename);

      error ("\"%s\": can't read symbols: %s.", filename,

             bfd_errmsg (bfd_get_error ()));

    }

  /* Sum the sizes of the various sections that compose debug info. */

  for (i = 0; pa64_debug_section_names[i] != NULL; i++)

    {

      asection *sect;

      sect = bfd_get_section_by_name (abfd, pa64_debug_section_names[i]);

      if (sect)

        st_size += (LONGEST)bfd_section_size (abfd, sect);

    }

  bfd_close (abfd);

  free (filename);

  /* Unfortunately, just summing the sizes of various debug info

     sections isn't a very accurate measurement of how much heap

     space the debugger will need to hold them.  It also doesn't

     account for space needed by linker (aka "minimal") symbols.

     Anecdotal evidence suggests that just summing the sizes of

     debug-info-related sections understates the heap space needed

     to represent it internally by about an order of magnitude.

     Since it's not exactly brain surgery we're doing here, rather

     than attempt to more accurately measure the size of a shlib's

     symbol table in GDB's heap, we'll just apply a 10x fudge-

     factor to the debug info sections' size-sum.  No, this doesn't

     account for minimal symbols in non-debuggable shlibs.  But it

     all roughly washes out in the end.  */

  return st_size * (LONGEST) 10;

}

/* Add a shared library to the objfile list and load its symbols into

   GDB's symbol table.  */

static void

pa64_solib_add_solib_objfile (so, name, from_tty, text_addr)

     struct so_list *so;

     char *name;

     int from_tty;

     CORE_ADDR text_addr;

{

  bfd *tmp_bfd;

  asection *sec;

  obj_private_data_t *obj_private;

  struct section_addr_info section_addrs;

  memset (&section_addrs, 0, sizeof (section_addrs));

  /* We need the BFD so that we can look at its sections.  We open up the

     file temporarily, then close it when we are done.  */

  tmp_bfd = bfd_openr (name, gnutarget);

  if (tmp_bfd == NULL)

    {

      perror_with_name (name);

      return;

    }

  if (!bfd_check_format (tmp_bfd, bfd_object))

    {

      bfd_close (tmp_bfd);

      error ("\"%s\" is not an object file: %s", name,

             bfd_errmsg (bfd_get_error ()));

    }

  /* Undo some braindamage from symfile.c.

     First, symfile.c will subtract the VMA of the first .text section

     in the shared library that it finds.  Undo that.  */

  sec = bfd_get_section_by_name (tmp_bfd, ".text");

  text_addr += bfd_section_vma (tmp_bfd, sec);

  /* Now find the true lowest section in the shared library.  */

  sec = NULL;

  bfd_map_over_sections (tmp_bfd, find_lowest_section, (PTR) &sec);

  if (sec)

    {

      /* Subtract out the VMA of the lowest section.  */

      text_addr -= bfd_section_vma (tmp_bfd, sec);

      /* ??? Add back in the filepos of that lowest section. */

      text_addr += sec->filepos;

    }

  /* We are done with the temporary bfd.  Get rid of it and make sure

     nobody else can us it.  */

  bfd_close (tmp_bfd);

  tmp_bfd = NULL;

  /* Now let the generic code load up symbols for this library.  */

  section_addrs.text_addr = text_addr;

  so->objfile = symbol_file_add (name, from_tty, &section_addrs, 0, OBJF_SHARED);

  so->abfd = so->objfile->obfd;

  /* Mark this as a shared library and save private data.  */

  so->objfile->flags |= OBJF_SHARED;

  if (so->objfile->obj_private == NULL)

    {

      obj_private = (obj_private_data_t *)

        obstack_alloc (&so->objfile->psymbol_obstack,

                       sizeof (obj_private_data_t));

      obj_private->unwind_info = NULL;

      obj_private->so_info = NULL;

      so->objfile->obj_private = (PTR) obj_private;

    }

  obj_private = (obj_private_data_t *) so->objfile->obj_private;

  obj_private->so_info = so;

  obj_private->dp = so->pa64_solib_desc.linkage_ptr;

}

/* Load debugging information for a shared library.  TARGET may be

   NULL if we are not attaching to a process or reading a core file.  */

static void

pa64_solib_load_symbols (so, name, from_tty, text_addr, target)

     struct so_list *so;

     char *name;

     int from_tty;

     CORE_ADDR text_addr;

     struct target_ops *target;

{

  struct section_table *p;

  asection *sec;

  int status;

  char buf[4];

  CORE_ADDR presumed_data_start;

  if (text_addr == 0)

    text_addr = so->pa64_solib_desc.text_base;

  pa64_solib_add_solib_objfile (so, name, from_tty, text_addr);

  /* Now we need to build a section table for this library since

     we might be debugging a core file from a dynamically linked

     executable in which the libraries were not privately mapped.  */

  if (build_section_table (so->abfd,

                           &so->sections,

                           &so->sections_end))

    {

      error ("Unable to build section table for shared library\n.");

      return;

    }

  ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT)

    = so->pa64_solib_desc.text_base;

  ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA)

    = so->pa64_solib_desc.data_base;

  /* Relocate all the sections based on where they got loaded.  */

  for (p = so->sections; p < so->sections_end; p++)

    {

      if (p->the_bfd_section->flags & SEC_CODE)

        {

          p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT);

          p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT);

        }

      else if (p->the_bfd_section->flags & SEC_DATA)

        {

          p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA);

          p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA);

        }

    }

  /* Now see if we need to map in the text and data for this shared

     library (for example debugging a core file which does not use

     private shared libraries.).

     Carefully peek at the first text address in the library.  If the

     read succeeds, then the libraries were privately mapped and were

     included in the core dump file.

     If the peek failed, then the libraries were not privately mapped

     and are not in the core file, we'll have to read them in ourselves.  */

  status = target_read_memory (text_addr, buf, 4);

  if (status != 0)

    {

      int new, old;

      new = so->sections_end - so->sections;

      old = target_resize_to_sections (target, new);

      /* Copy over the old data before it gets clobbered.  */

      memcpy ((char *) (target->to_sections + old),

              so->sections,

              ((sizeof (struct section_table)) * new));

    }

}

/* Add symbols from shared libraries into the symtab list, unless the

   size threshold (specified by auto_solib_add, in megabytes) would

   be exceeded.  */

void

pa64_solib_add (arg_string, from_tty, target)

     char *arg_string;

     int from_tty;

     struct target_ops *target;

{

  struct minimal_symbol *msymbol;

  CORE_ADDR addr;

  asection *shlib_info;

  int status;

  unsigned int dld_flags;

  char buf[4], *re_err;

  int threshold_warning_given = 0;

  int dll_index;

  struct load_module_desc dll_desc;

  char *dll_path;

  /* First validate our arguments.  */

  if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)

    {

      error ("Invalid regexp: %s", re_err);

    }

  /* If we're debugging a core file, or have attached to a running

     process, then pa64_solib_create_inferior_hook will not have been

     called.

     We need to first determine if we're dealing with a dynamically

     linked executable.  If not, then return without an error or warning.

     We also need to examine __dld_flags to determine if the shared library

     list is valid and to determine if the libraries have been privately

     mapped.  */

  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 load map pointer if we have not done so already.  */

  if (! dld_cache.have_read_dld_descriptor)

    if (! read_dld_descriptor (target))

      return;

  /* 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\nbreakpoint in a shared library will not work until you rerun the program.\n");

  /* For each shaerd library, add it to the shared library list.  */

  for (dll_index = 1; ; dll_index++)

    {

      /* 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)

        return;

      /* 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)

        error ("pa64_solib_add, unable to read shared library path.");

      add_to_solist (from_tty, dll_path, &dll_desc, 0, target);

    }

}

/* 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.  */

void

pa64_solib_create_inferior_hook ()

{

  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)

        goto get_out;

      /* 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);

          goto get_out;

        }

      /* 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);

    }

get_out:

  /* Wipe out all knowledge of old shared libraries since their

     mapping can change from one exec to another!  */

  while (so_list_head)

    {

      struct so_list *temp;

      temp = so_list_head;

      free (so_list_head);

      so_list_head = temp->next;

    }

  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

   pa64_solib_create_inferior_hook.

   This operation does not remove any knowledge of shared libraries which

   GDB may already have been notified of.  */

void

pa64_solib_remove_inferior_hook (pid)

     int pid;

{

  /* Turn off the DT_HP_DEBUG_CALLBACK bit in the dynamic linker flags.  */

  dld_cache.dld_flags &= ~DT_HP_DEBUG_CALLBACK;

  target_write_memory (dld_cache.dld_flags_addr,

                       (char *)&dld_cache.dld_flags,

                       sizeof (dld_cache.dld_flags));

}

/* This function creates a breakpoint on the dynamic linker hook, which

   is called when e.g., a shl_load or shl_unload call is made.  This

   breakpoint will only trigger when a shl_load call is made.

   If filename is NULL, then loads of any dll will be caught.  Else,

   only loads of the file whose pathname is the string contained by

   filename will be caught.

   Undefined behaviour is guaranteed if this function is called before

   pa64_solib_create_inferior_hook.  */

void

pa64_solib_create_catch_load_hook (pid, tempflag, filename, cond_string)

     int pid;

     int tempflag;

     char *filename;

     char *cond_string;

{

  create_solib_load_event_breakpoint ("", tempflag, filename, cond_string);

}

/* This function creates a breakpoint on the dynamic linker hook, which

   is called when e.g., a shl_load or shl_unload call is made.  This

   breakpoint will only trigger when a shl_unload call is made.

   If filename is NULL, then unloads of any dll will be caught.  Else,

   only unloads of the file whose pathname is the string contained by

   filename will be caught.

   Undefined behaviour is guaranteed if this function is called before

   pa64_solib_create_inferior_hook.  */

void

pa64_solib_create_catch_unload_hook (pid, tempflag, filename, cond_string)

     int pid;

     int tempflag;

     char *filename;

     char *cond_string;

{

  create_solib_unload_event_breakpoint ("", tempflag, filename, cond_string);

}

/* Return nonzero if the dynamic linker has reproted that a library

   has been loaded.  */

int

pa64_solib_have_load_event (pid)

     int pid;

{

  CORE_ADDR event_kind;

  event_kind = read_register (ARG0_REGNUM);

  return (event_kind == DLD_CB_LOAD);

}

/* Return nonzero if the dynamic linker has reproted that a library

   has been unloaded.  */

int

pa64_solib_have_unload_event (pid)

     int pid;

{

  CORE_ADDR event_kind;

  event_kind = read_register (ARG0_REGNUM);

  return (event_kind == DLD_CB_UNLOAD);

}

/* Return a pointer to a string indicating the pathname of the most

   recently loaded library.

   The caller is reposible for copying the string before the inferior is

   restarted.  */

char *

pa64_solib_loaded_library_pathname (pid)

     int pid;

{

  static char dll_path[MAXPATHLEN];

  CORE_ADDR  dll_path_addr = read_register (ARG3_REGNUM);

  read_memory_string (dll_path_addr, dll_path, MAXPATHLEN);

  return dll_path;

}

/* Return a pointer to a string indicating the pathname of the most

   recently unloaded library.

   The caller is reposible for copying the string before the inferior is

   restarted.  */

char *

pa64_solib_unloaded_library_pathname (pid)

     int pid;

{

  static char dll_path[MAXPATHLEN];

  CORE_ADDR dll_path_addr = read_register (ARG3_REGNUM);

  read_memory_string (dll_path_addr, dll_path, MAXPATHLEN);

  return dll_path;

}

/* Return nonzero if PC is an address inside the dynamic linker.  */

int

pa64_solib_in_dynamic_linker (pid, pc)

     int pid;

     CORE_ADDR pc;

{

  asection *shlib_info;

  if (symfile_objfile == NULL)

    return 0;

  if (!dld_cache.have_read_dld_descriptor)

    if (!read_dld_descriptor (&current_target))

      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.  */