Subversion Repositories openrisc

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

   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,

   2001, 2003, 2004, 2005, 2006, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "elf/external.h"

#include "elf/common.h"

#include "elf/mips.h"

#include "symtab.h"

#include "bfd.h"

#include "symfile.h"

#include "objfiles.h"

#include "gdbcore.h"

#include "target.h"

#include "inferior.h"

#include "gdb_assert.h"

#include "solist.h"

#include "solib.h"

#include "solib-svr4.h"

#include "bfd-target.h"

#include "elf-bfd.h"

#include "exec.h"

#include "auxv.h"

static struct link_map_offsets *svr4_fetch_link_map_offsets (void);

static int svr4_have_link_map_offsets (void);

/* Link map info to include in an allocated so_list entry */

struct lm_info

  {

    /* Pointer to copy of link map from inferior.  The type is char *

       rather than void *, so that we may use byte offsets to find the

       various fields without the need for a cast.  */

    gdb_byte *lm;

    /* Amount by which addresses in the binary should be relocated to

       match the inferior.  This could most often be taken directly

       from lm, but when prelinking is involved and the prelink base

       address changes, we may need a different offset, we want to

       warn about the difference and compute it only once.  */

    CORE_ADDR l_addr;

  };

/* On SVR4 systems, a list of symbols in the dynamic linker where

   GDB can try to place a breakpoint to monitor shared library

   events.

   If none of these symbols are found, or other errors occur, then

   SVR4 systems will fall back to using a symbol as the "startup

   mapping complete" breakpoint address.  */

static char *solib_break_names[] =

{

  "r_debug_state",

  "_r_debug_state",

  "_dl_debug_state",

  "rtld_db_dlactivity",

  "_rtld_debug_state",

  NULL

};

#define BKPT_AT_SYMBOL 1

#if defined (BKPT_AT_SYMBOL)

static char *bkpt_names[] =

{

#ifdef SOLIB_BKPT_NAME

  SOLIB_BKPT_NAME,              /* Prefer configured name if it exists. */

#endif

  "_start",

  "__start",

  "main",

  NULL

};

#endif

static char *main_name_list[] =

{

  "main_$main",

  NULL

};

/* link map access functions */

static CORE_ADDR

LM_ADDR_FROM_LINK_MAP (struct so_list *so)

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  return extract_typed_address (so->lm_info->lm + lmo->l_addr_offset,

                                builtin_type_void_data_ptr);

}

static int

HAS_LM_DYNAMIC_FROM_LINK_MAP ()

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  return lmo->l_ld_offset >= 0;

}

static CORE_ADDR

LM_DYNAMIC_FROM_LINK_MAP (struct so_list *so)

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  return extract_typed_address (so->lm_info->lm + lmo->l_ld_offset,

                                builtin_type_void_data_ptr);

}

static CORE_ADDR

LM_ADDR_CHECK (struct so_list *so, bfd *abfd)

{

  if (so->lm_info->l_addr == (CORE_ADDR)-1)

    {

      struct bfd_section *dyninfo_sect;

      CORE_ADDR l_addr, l_dynaddr, dynaddr, align = 0x1000;

      l_addr = LM_ADDR_FROM_LINK_MAP (so);

      if (! abfd || ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())

        goto set_addr;

      l_dynaddr = LM_DYNAMIC_FROM_LINK_MAP (so);

      dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");

      if (dyninfo_sect == NULL)

        goto set_addr;

      dynaddr = bfd_section_vma (abfd, dyninfo_sect);

      if (dynaddr + l_addr != l_dynaddr)

        {

          if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)

            {

              Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;

              Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;

              int i;

              align = 1;

              for (i = 0; i < ehdr->e_phnum; i++)

                if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)

                  align = phdr[i].p_align;

            }

          /* Turn it into a mask.  */

          align--;

          /* If the changes match the alignment requirements, we

             assume we're using a core file that was generated by the

             same binary, just prelinked with a different base offset.

             If it doesn't match, we may have a different binary, the

             same binary with the dynamic table loaded at an unrelated

             location, or anything, really.  To avoid regressions,

             don't adjust the base offset in the latter case, although

             odds are that, if things really changed, debugging won't

             quite work.  */

          if ((l_addr & align) == ((l_dynaddr - dynaddr) & align))

            {

              l_addr = l_dynaddr - dynaddr;

              warning (_(".dynamic section for \"%s\" "

                     "is not at the expected address"), so->so_name);

              warning (_("difference appears to be caused by prelink, "

                         "adjusting expectations"));

            }

          else

            warning (_(".dynamic section for \"%s\" "

                       "is not at the expected address "

                       "(wrong library or version mismatch?)"), so->so_name);

        }

    set_addr:

      so->lm_info->l_addr = l_addr;

    }

  return so->lm_info->l_addr;

}

static CORE_ADDR

LM_NEXT (struct so_list *so)

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  return extract_typed_address (so->lm_info->lm + lmo->l_next_offset,

                                builtin_type_void_data_ptr);

}

static CORE_ADDR

LM_NAME (struct so_list *so)

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  return extract_typed_address (so->lm_info->lm + lmo->l_name_offset,

                                builtin_type_void_data_ptr);

}

static int

IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so)

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  /* Assume that everything is a library if the dynamic loader was loaded

     late by a static executable.  */

  if (bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)

    return 0;

  return extract_typed_address (so->lm_info->lm + lmo->l_prev_offset,

                                builtin_type_void_data_ptr) == 0;

}

static CORE_ADDR debug_base;    /* Base of dynamic linker structures */

/* Validity flag for debug_loader_offset.  */

static int debug_loader_offset_p;

/* Load address for the dynamic linker, inferred.  */

static CORE_ADDR debug_loader_offset;

/* Name of the dynamic linker, valid if debug_loader_offset_p.  */

static char *debug_loader_name;

/* Local function prototypes */

static int match_main (char *);

static CORE_ADDR bfd_lookup_symbol (bfd *, char *);

/*

   LOCAL FUNCTION

   bfd_lookup_symbol -- lookup the value for a specific symbol

   SYNOPSIS

   CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)

   DESCRIPTION

   An expensive way to lookup the value of a single symbol for

   bfd's that are only temporary anyway.  This is used by the

   shared library support to find the address of the debugger

   notification routine in the shared library.

   The returned symbol may be in a code or data section; functions

   will normally be in a code section, but may be in a data section

   if this architecture uses function descriptors.

   Note that 0 is specifically allowed as an error return (no

   such symbol).

 */

static CORE_ADDR

bfd_lookup_symbol (bfd *abfd, char *symname)

{

  long 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

              && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)

            {

              /* BFD symbols are section relative.  */

              symaddr = sym->value + sym->section->vma;

              break;

            }

        }

      do_cleanups (back_to);

    }

  if (symaddr)

    return symaddr;

  /* On FreeBSD, the dynamic linker is stripped by default.  So we'll

     have to check the dynamic string table too.  */

  storage_needed = bfd_get_dynamic_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_dynamic_symtab (abfd, symbol_table);

      for (i = 0; i < number_of_symbols; i++)

        {

          sym = *symbol_table++;

          if (strcmp (sym->name, symname) == 0

              && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)

            {

              /* BFD symbols are section relative.  */

              symaddr = sym->value + sym->section->vma;

              break;

            }

        }

      do_cleanups (back_to);

    }

  return symaddr;

}

/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is

   returned and the corresponding PTR is set.  */

static int

scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)

{

  int arch_size, step, sect_size;

  long dyn_tag;

  CORE_ADDR dyn_ptr, dyn_addr;

  gdb_byte *bufend, *bufstart, *buf;

  Elf32_External_Dyn *x_dynp_32;

  Elf64_External_Dyn *x_dynp_64;

  struct bfd_section *sect;

  if (abfd == NULL)

    return 0;

  arch_size = bfd_get_arch_size (abfd);

  if (arch_size == -1)

   return 0;

  /* Find the start address of the .dynamic section.  */

  sect = bfd_get_section_by_name (abfd, ".dynamic");

  if (sect == NULL)

    return 0;

  dyn_addr = bfd_section_vma (abfd, sect);

  /* Read in .dynamic from the BFD.  We will get the actual value

     from memory later.  */

  sect_size = bfd_section_size (abfd, sect);

  buf = bufstart = alloca (sect_size);

  if (!bfd_get_section_contents (abfd, sect,

                                 buf, 0, sect_size))

    return 0;

  /* Iterate over BUF and scan for DYNTAG.  If found, set PTR and return.  */

  step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)

                           : sizeof (Elf64_External_Dyn);

  for (bufend = buf + sect_size;

       buf < bufend;

       buf += step)

  {

    if (arch_size == 32)

      {

        x_dynp_32 = (Elf32_External_Dyn *) buf;

        dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);

        dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);

      }

    else

      {

        x_dynp_64 = (Elf64_External_Dyn *) buf;

        dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);

        dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);

      }

     if (dyn_tag == DT_NULL)

       return 0;

     if (dyn_tag == dyntag)

       {

         /* If requested, try to read the runtime value of this .dynamic

            entry.  */

         if (ptr)

           {

             gdb_byte ptr_buf[8];

             CORE_ADDR ptr_addr;

             ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;

             if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)

               dyn_ptr = extract_typed_address (ptr_buf,

                                                builtin_type_void_data_ptr);

             *ptr = dyn_ptr;

           }

         return 1;

       }

  }

  return 0;

}

/*

   LOCAL FUNCTION

   elf_locate_base -- locate the base address of dynamic linker structs

   for SVR4 elf targets.

   SYNOPSIS

   CORE_ADDR elf_locate_base (void)

   DESCRIPTION

   For SVR4 elf targets the address of the dynamic linker's runtime

   structure is contained within the dynamic info section in the

   executable file.  The dynamic section is also mapped into the

   inferior address space.  Because the runtime loader fills in the

   real address before starting the inferior, we have to read in the

   dynamic info section from the inferior address space.

   If there are any errors while trying to find the address, we

   silently return 0, otherwise the found address is returned.

 */

static CORE_ADDR

elf_locate_base (void)

{

  struct minimal_symbol *msymbol;

  CORE_ADDR dyn_ptr;

  /* Look for DT_MIPS_RLD_MAP first.  MIPS executables use this

     instead of DT_DEBUG, although they sometimes contain an unused

     DT_DEBUG.  */

  if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr))

    {

      gdb_byte *pbuf;

      int pbuf_size = TYPE_LENGTH (builtin_type_void_data_ptr);

      pbuf = alloca (pbuf_size);

      /* DT_MIPS_RLD_MAP contains a pointer to the address

         of the dynamic link structure.  */

      if (target_read_memory (dyn_ptr, pbuf, pbuf_size))

        return 0;

      return extract_typed_address (pbuf, builtin_type_void_data_ptr);

    }

  /* Find DT_DEBUG.  */

  if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr))

    return dyn_ptr;

  /* This may be a static executable.  Look for the symbol

     conventionally named _r_debug, as a last resort.  */

  msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);

  if (msymbol != NULL)

    return SYMBOL_VALUE_ADDRESS (msymbol);

  /* DT_DEBUG entry not found.  */

  return 0;

}

/*

   LOCAL FUNCTION

   locate_base -- locate the base address of dynamic linker structs

   SYNOPSIS

   CORE_ADDR locate_base (void)

   DESCRIPTION

   For both the SunOS and SVR4 shared library implementations, if the

   inferior executable has been linked dynamically, there is a single

   address somewhere in the inferior's data space which is the key to

   locating all of the dynamic linker's runtime structures.  This

   address is the value of the debug base symbol.  The job of this

   function is to find and return that address, or to return 0 if there

   is no such address (the executable is statically linked for example).

   For SunOS, the job is almost trivial, since the dynamic linker and

   all of it's structures are statically linked to the executable at

   link time.  Thus the symbol for the address we are looking for has

   already been added to the minimal symbol table for the executable's

   objfile at the time the symbol file's symbols were read, and all we

   have to do is look it up there.  Note that we explicitly do NOT want

   to find the copies in the shared library.

   The SVR4 version is a bit more complicated because the address

   is contained somewhere in the dynamic info section.  We have to go

   to a lot more work to discover the address of the debug base symbol.

   Because of this complexity, we cache the value we find and return that

   value on subsequent invocations.  Note there is no copy in the

   executable symbol tables.

 */

static CORE_ADDR

locate_base (void)

{

  /* Check to see if we have a currently valid address, and if so, avoid

     doing all this work again and just return the cached address.  If

     we have no cached address, try to locate it in the dynamic info

     section for ELF executables.  There's no point in doing any of this

     though if we don't have some link map offsets to work with.  */

  if (debug_base == 0 && svr4_have_link_map_offsets ())

    {

      if (exec_bfd != NULL

          && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)

        debug_base = elf_locate_base ();

    }

  return (debug_base);

}

/* Find the first element in the inferior's dynamic link map, and

   return its address in the inferior.

   FIXME: Perhaps we should validate the info somehow, perhaps by

   checking r_version for a known version number, or r_state for

   RT_CONSISTENT.  */

static CORE_ADDR

solib_svr4_r_map (void)

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  return read_memory_typed_address (debug_base + lmo->r_map_offset,

                                    builtin_type_void_data_ptr);

}

/* Find r_brk from the inferior's debug base.  */

static CORE_ADDR

solib_svr4_r_brk (void)

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  return read_memory_typed_address (debug_base + lmo->r_brk_offset,

                                    builtin_type_void_data_ptr);

}

/* Find the link map for the dynamic linker (if it is not in the

   normal list of loaded shared objects).  */

static CORE_ADDR

solib_svr4_r_ldsomap (void)

{

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  ULONGEST version;

  /* Check version, and return zero if `struct r_debug' doesn't have

     the r_ldsomap member.  */

  version = read_memory_unsigned_integer (debug_base + lmo->r_version_offset,

                                          lmo->r_version_size);

  if (version < 2 || lmo->r_ldsomap_offset == -1)

    return 0;

  return read_memory_typed_address (debug_base + lmo->r_ldsomap_offset,

                                    builtin_type_void_data_ptr);

}

/*

  LOCAL FUNCTION

  open_symbol_file_object

  SYNOPSIS

  void open_symbol_file_object (void *from_tty)

  DESCRIPTION

  If no open symbol file, attempt to locate and open the main symbol

  file.  On SVR4 systems, this is the first link map entry.  If its

  name is here, we can open it.  Useful when attaching to a process

  without first loading its symbol file.

  If FROM_TTYP dereferences to a non-zero integer, allow messages to

  be printed.  This parameter is a pointer rather than an int because

  open_symbol_file_object() is called via catch_errors() and

  catch_errors() requires a pointer argument. */

static int

open_symbol_file_object (void *from_ttyp)

{

  CORE_ADDR lm, l_name;

  char *filename;

  int errcode;

  int from_tty = *(int *)from_ttyp;

  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

  int l_name_size = TYPE_LENGTH (builtin_type_void_data_ptr);

  gdb_byte *l_name_buf = xmalloc (l_name_size);

  struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);

  if (symfile_objfile)

    if (!query ("Attempt to reload symbols from process? "))

      return 0;

  /* Always locate the debug struct, in case it has moved.  */

  debug_base = 0;

  if (locate_base () == 0)

    return 0;    /* failed somehow... */

  /* First link map member should be the executable.  */

  lm = solib_svr4_r_map ();

  if (lm == 0)

    return 0;    /* failed somehow... */

  /* Read address of name from target memory to GDB.  */

  read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size);

  /* Convert the address to host format.  */

  l_name = extract_typed_address (l_name_buf, builtin_type_void_data_ptr);

  /* Free l_name_buf.  */

  do_cleanups (cleanups);

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

  make_cleanup (xfree, filename);

  if (errcode)

    {

      warning (_("failed to read exec filename from attached file: %s"),

               safe_strerror (errcode));

      return 0;

    }

  /* Have a pathname: read the symbol file.  */

  symbol_file_add_main (filename, from_tty);

  return 1;

}

/* If no shared library information is available from the dynamic

   linker, build a fallback list from other sources.  */

static struct so_list *

svr4_default_sos (void)

{

  struct so_list *head = NULL;

  struct so_list **link_ptr = &head;

  if (debug_loader_offset_p)

    {

      struct so_list *new = XZALLOC (struct so_list);

      new->lm_info = xmalloc (sizeof (struct lm_info));

      /* Nothing will ever check the cached copy of the link

         map if we set l_addr.  */

      new->lm_info->l_addr = debug_loader_offset;

      new->lm_info->lm = NULL;

      strncpy (new->so_name, debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1);

      new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';

      strcpy (new->so_original_name, new->so_name);

      *link_ptr = new;

      link_ptr = &new->next;

    }

  return head;

}

/* LOCAL FUNCTION

   current_sos -- build a list of currently loaded shared objects

   SYNOPSIS

   struct so_list *current_sos ()

   DESCRIPTION

   Build a list of `struct so_list' objects describing the shared

   objects currently loaded in the inferior.  This list does not

   include an entry for the main executable file.

   Note that we only gather information directly available from the

   inferior --- we don't examine any of the shared library files

   themselves.  The declaration of `struct so_list' says which fields

   we provide values for.  */

static struct so_list *

svr4_current_sos (void)

{

  CORE_ADDR lm;

  struct so_list *head = 0;

  struct so_list **link_ptr = &head;

  CORE_ADDR ldsomap = 0;

  /* Always locate the debug struct, in case it has moved.  */

  debug_base = 0;

  locate_base ();

  /* If we can't find the dynamic linker's base structure, this

     must not be a dynamically linked executable.  Hmm.  */

  if (! debug_base)

    return svr4_default_sos ();

  /* Walk the inferior's link map list, and build our list of

     `struct so_list' nodes.  */

  lm = solib_svr4_r_map ();

  while (lm)

    {

      struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();

      struct so_list *new = XZALLOC (struct so_list);

      struct cleanup *old_chain = make_cleanup (xfree, new);

      new->lm_info = xmalloc (sizeof (struct lm_info));

      make_cleanup (xfree, new->lm_info);