Subversion Repositories or1k

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

   Copyright 1993, 1996, 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.

   Written by the Center for Software Science at the Univerity of Utah

   and by Cygnus Support.  */

#include "defs.h"

#include "frame.h"

#include "bfd.h"

#include "som.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

/* Uncomment this to turn on some debugging output.

 */

/* #define SOLIB_DEBUG

 */

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

 */

extern struct target_ops exec_ops;

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

   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

/* TODO:

   * Most of this code should work for hp300 shared libraries.  Does

   anyone care enough to weed out any SOM-isms.

   * Support for hpux8 dynamic linker.  */

/* The basic structure which describes a dynamically loaded object.  This

   data structure is private to the dynamic linker and isn't found in

   any HPUX include file.  */

struct som_solib_mapped_entry

  {

    /* The name of the library.  */

    char *name;

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

    /* Next entry.  */

    struct som_solib_mapped_entry *next;

    /* There are other fields, but I don't have information as to what is

       contained in them.  */

    /* For versions from HPUX-10.30 and up */

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

    /* Following this are longwords holding:

     * ?, ?, ?, ptr to -1, ptr to-1, ptr to lib name (leaf name),

     * ptr to __data_start, ptr to __data_end

     */

  };

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

struct so_list

  {

    struct som_solib_mapped_entry som_solib;

    struct objfile *objfile;

    bfd *abfd;

    struct section_table *sections;

    struct section_table *sections_end;

/* elz: added this field to store the address in target space (in the

   library) of the library descriptor (handle) which we read into

   som_solib_mapped_entry structure */

    CORE_ADDR solib_addr;

    struct so_list *next;

  };

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 som_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 som_solib_st_size_threshold_exceeded;

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

  {

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

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

static LONGEST

som_solib_sizeof_symbol_table (filename)

     char *filename;

{

  bfd *abfd;

  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))     /* Reads in section info */

    {

      bfd_close (abfd);         /* This also closes desc */

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

  /* This contains non-DOC information. */

  sect = bfd_get_section_by_name (abfd, "$DEBUG$");

  if (sect)

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

  /* This contains DOC information. */

  sect = bfd_get_section_by_name (abfd, "$PINFO$");

  if (sect)

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

  bfd_close (abfd);             /* This also closes desc */

  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;

}

static void

som_solib_add_solib_objfile (so, name, from_tty, text_addr)

     struct so_list *so;

     char *name;

     int from_tty;

     CORE_ADDR text_addr;

{

  obj_private_data_t *obj_private;

  struct section_addr_info section_addrs;

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

  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;

  if (!bfd_check_format (so->abfd, bfd_object))

    {

      error ("\"%s\": not in executable format: %s.",

             name, bfd_errmsg (bfd_get_error ()));

    }

}

static void

som_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;

  int status;

  char buf[4];

  CORE_ADDR presumed_data_start;

#ifdef SOLIB_DEBUG

  printf ("--Adding symbols for shared library \"%s\"\n", name);

#endif

  som_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;

    }

  /* 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 old, new;

      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

som_solib_add (arg_string, from_tty, target)

     char *arg_string;

     int from_tty;

     struct target_ops *target;

{

  struct minimal_symbol *msymbol;

  struct so_list *so_list_tail;

  CORE_ADDR addr;

  asection *shlib_info;

  int status;

  unsigned int dld_flags;

  char buf[4], *re_err;

  int threshold_warning_given = 0;

  /* 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 som_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, "$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;

  msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);

  if (msymbol == NULL)

    {

      error ("Unable to find __dld_flags symbol in object file.\n");

      return;

    }

  addr = SYMBOL_VALUE_ADDRESS (msymbol);

  /* Read the current contents.  */

  status = target_read_memory (addr, buf, 4);

  if (status != 0)

    {

      error ("Unable to read __dld_flags\n");

      return;

    }

  dld_flags = extract_unsigned_integer (buf, 4);

  /* __dld_list may not be valid.  If not, then we punt, warning the user if

     we were called as a result of the add-symfile command.

   */

  if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)

    {

      if (from_tty)

        error ("__dld_list is not valid according to __dld_flags.\n");

      return;

    }

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

  msymbol = lookup_minimal_symbol ("__dld_list", NULL, NULL);

  if (!msymbol)

    {

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

      msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);

      if (!msymbol)

        {

          error ("Unable to find dynamic library list.\n");

          return;

        }

      addr = SYMBOL_VALUE_ADDRESS (msymbol) - 8;

    }

  else

    addr = SYMBOL_VALUE_ADDRESS (msymbol);

  status = target_read_memory (addr, buf, 4);

  if (status != 0)

    {

      error ("Unable to find dynamic library list.\n");

      return;

    }

  addr = extract_unsigned_integer (buf, 4);

  /* If addr is zero, then we're using an old dynamic loader which

     doesn't maintain __dld_list.  We'll have to use a completely

     different approach to get shared library information.  */

  if (addr == 0)

    goto old_dld;

  /* Using the information in __dld_list is the preferred method

     to get at shared library information.  It doesn't depend on

     any functions in /opt/langtools/lib/end.o and has a chance of working

     with hpux10 when it is released.  */

  status = target_read_memory (addr, buf, 4);

  if (status != 0)

    {

      error ("Unable to find dynamic library list.\n");

      return;

    }

  /* addr now holds the address of the first entry in the dynamic

     library list.  */

  addr = extract_unsigned_integer (buf, 4);

  /* Now that we have a pointer to the dynamic library list, walk

     through it and add the symbols for each library.  */

  so_list_tail = so_list_head;

  /* Find the end of the list of shared objects.  */

  while (so_list_tail && so_list_tail->next)

    so_list_tail = so_list_tail->next;

#ifdef SOLIB_DEBUG

  printf ("--About to read shared library list data\n");

#endif

  /* "addr" will always point to the base of the

   * current data entry describing the current

   * shared library.

   */

  while (1)

    {

      CORE_ADDR name_addr, text_addr;

      unsigned int name_len;

      char *name;

      struct so_list *new_so;

      struct so_list *so_list = so_list_head;

      struct stat statbuf;

      LONGEST st_size;

      int is_main_program;

      if (addr == 0)

        break;

      /* Get a pointer to the name of this library.  */

      status = target_read_memory (addr, buf, 4);

      if (status != 0)

        goto err;

      name_addr = extract_unsigned_integer (buf, 4);

      name_len = 0;

      while (1)

        {

          target_read_memory (name_addr + name_len, buf, 1);

          if (status != 0)

            goto err;

          name_len++;

          if (*buf == '\0')

            break;

        }

      name = alloca (name_len);

      status = target_read_memory (name_addr, name, name_len);

      if (status != 0)

        goto err;

      /* See if we've already loaded something with this name.  */

      while (so_list)

        {

          if (!strcmp (so_list->som_solib.name, name))

            break;

          so_list = so_list->next;

        }

      /* See if the file exists.  If not, give a warning, but don't

         die.  */

      status = stat (name, &statbuf);

      if (status == -1)

        {

          warning ("Can't find file %s referenced in dld_list.", name);

          status = target_read_memory (addr + 36, buf, 4);

          if (status != 0)

            goto err;

          addr = (CORE_ADDR) extract_unsigned_integer (buf, 4);

          continue;

        }

      /* If we've already loaded this one or it's the main program, skip it.  */

      is_main_program = (strcmp (name, symfile_objfile->name) == 0);

      if (so_list || is_main_program)

        {

          /* This is the "next" pointer in the strcuture.

           */

          status = target_read_memory (addr + 36, buf, 4);

          if (status != 0)

            goto err;

          addr = (CORE_ADDR) extract_unsigned_integer (buf, 4);

          /* Record the main program's symbol table size. */

          if (is_main_program && !so_list)

            {

              st_size = som_solib_sizeof_symbol_table (name);

              som_solib_total_st_size += st_size;

            }

          /* Was this a shlib that we noted but didn't load the symbols for?

             If so, were we invoked this time from the command-line, via

             a 'sharedlibrary' or 'add-symbol-file' command?  If yes to

             both, we'd better load the symbols this time.

           */

          if (from_tty && so_list && !is_main_program && (so_list->objfile == NULL))

            som_solib_load_symbols (so_list,

                                    name,

                                    from_tty,

                                    so_list->som_solib.text_addr,

                                    target);

          continue;

        }

      name = obsavestring (name, name_len - 1,

                           &symfile_objfile->symbol_obstack);

      status = target_read_memory (addr + 8, buf, 4);

      if (status != 0)

        goto err;

      text_addr = extract_unsigned_integer (buf, 4);

      new_so = (struct so_list *) xmalloc (sizeof (struct so_list));

      memset ((char *) new_so, 0, sizeof (struct so_list));

      if (so_list_head == NULL)

        {

          so_list_head = new_so;

          so_list_tail = new_so;

        }

      else

        {

          so_list_tail->next = new_so;

          so_list_tail = new_so;

        }

      /* Fill in all the entries in GDB's shared library list.

       */

      new_so->solib_addr = addr;

      new_so->som_solib.name = name;

      status = target_read_memory (addr + 4, buf, 4);

      if (status != 0)

        goto err;

      new_so->som_solib.struct_version = extract_unsigned_integer (buf + 3, 1);

      new_so->som_solib.bind_mode = extract_unsigned_integer (buf + 2, 1);

      /* Following is "high water mark", highest version number

       * seen, rather than plain version number.

       */

      new_so->som_solib.library_version = extract_unsigned_integer (buf, 2);

      new_so->som_solib.text_addr = text_addr;

      /* Q: What about longword at "addr + 8"?

       * A: It's read above, out of order, into "text_addr".

       */

      status = target_read_memory (addr + 12, buf, 4);

      if (status != 0)

        goto err;

      new_so->som_solib.text_link_addr = extract_unsigned_integer (buf, 4);

      status = target_read_memory (addr + 16, buf, 4);

      if (status != 0)

        goto err;

      new_so->som_solib.text_end = extract_unsigned_integer (buf, 4);

      status = target_read_memory (addr + 20, buf, 4);

      if (status != 0)

        goto err;

      new_so->som_solib.data_start = extract_unsigned_integer (buf, 4);

      status = target_read_memory (addr + 24, buf, 4);

      if (status != 0)

        goto err;

      new_so->som_solib.bss_start = extract_unsigned_integer (buf, 4);

      status = target_read_memory (addr + 28, buf, 4);

      if (status != 0)

        goto err;

      new_so->som_solib.data_end = extract_unsigned_integer (buf, 4);

      status = target_read_memory (addr + 32, buf, 4);

      if (status != 0)

        goto err;

      new_so->som_solib.got_value = extract_unsigned_integer (buf, 4);

      status = target_read_memory (addr + 36, buf, 4);

      if (status != 0)

        goto err;

      new_so->som_solib.next = (void *) extract_unsigned_integer (buf, 4);

      /* Note that we don't re-set "addr" to the next pointer

       * until after we've read the trailing data.

       */

      status = target_read_memory (addr + 40, buf, 4);

      new_so->som_solib.tsd_start_addr = extract_unsigned_integer (buf, 4);

      if (status != 0)

        goto err;

      /* Now indirect via that value!