* solib-svr4.c: Add include of "auxv.h".

[deliverable/binutils-gdb.git] / gdb / solib-svr4.c

diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 7dfe707e6e04d9cfa34846162301773ba51a2f6b..702e6f685bb53bcdf5e5cd6c8b0b979ef2ede299 100644 (file)
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -7,7 +7,7 @@
 
    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
 
    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
+   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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 
 
 #include "defs.h"
 


@@ -43,6 +41,7 @@
 #include "bfd-target.h"
 #include "elf-bfd.h"
 #include "exec.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);
 
 static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
 static int svr4_have_link_map_offsets (void);


@@ -84,16 +83,6 @@ static char *solib_break_names[] =
   "rtld_db_dlactivity",
   "_rtld_debug_state",
 
   "rtld_db_dlactivity",
   "_rtld_debug_state",
 

-  /* On the 64-bit PowerPC, the linker symbol with the same name as
-     the C function points to a function descriptor, not to the entry
-     point.  The linker symbol whose name is the C function name
-     prefixed with a '.' points to the function's entry point.  So
-     when we look through this table, we ignore symbols that point
-     into the data section (thus skipping the descriptor's symbol),
-     and eventually try this one, giving us the real entry point
-     address.  */
-  "._dl_debug_state",
-

   NULL
 };
 
   NULL
 };
 


@@ -194,7 +183,7 @@ LM_ADDR_CHECK (struct so_list *so, bfd *abfd)
             don't adjust the base offset in the latter case, although
             odds are that, if things really changed, debugging won't
             quite work.  */
             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) == 0 && ((dynaddr - l_dynaddr) & align) == 0)
+         if ((l_addr & align) == ((l_dynaddr - dynaddr) & align))

            {
              l_addr = l_dynaddr - dynaddr;
 
            {
              l_addr = l_dynaddr - dynaddr;
 


@@ -263,7 +252,7 @@ static char *debug_loader_name;
 
 static int match_main (char *);
 
 
 static int match_main (char *);
 

-static CORE_ADDR bfd_lookup_symbol (bfd *, char *, flagword);
+static CORE_ADDR bfd_lookup_symbol (bfd *, char *);

 
 /*
 
 
 /*
 


@@ -273,24 +262,25 @@ static CORE_ADDR bfd_lookup_symbol (bfd *, char *, flagword);
 
    SYNOPSIS
 
 
    SYNOPSIS
 

-   CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
+   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
 
    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

-   interface structures in the shared library.
+   notification routine in the shared library.

 
 

-   If SECT_FLAGS is non-zero, only match symbols in sections whose
-   flags include all those in SECT_FLAGS.
+   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
 
    Note that 0 is specifically allowed as an error return (no
    such symbol).
  */
 
 static CORE_ADDR

-bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
+bfd_lookup_symbol (bfd *abfd, char *symname)

 {
   long storage_needed;
   asymbol *sym;
 {
   long storage_needed;
   asymbol *sym;


@@ -312,9 +302,9 @@ bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
        {
          sym = *symbol_table++;
          if (strcmp (sym->name, symname) == 0
        {
          sym = *symbol_table++;
          if (strcmp (sym->name, symname) == 0

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

            {
            {

-             /* Bfd symbols are section relative. */
+             /* BFD symbols are section relative.  */

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


@@ -341,9 +331,9 @@ bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
          sym = *symbol_table++;
 
          if (strcmp (sym->name, symname) == 0
          sym = *symbol_table++;
 
          if (strcmp (sym->name, symname) == 0

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

            {
            {

-             /* Bfd symbols are section relative. */
+             /* BFD symbols are section relative.  */

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


@@ -363,7 +353,7 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
   int arch_size, step, sect_size;
   long dyn_tag;
   CORE_ADDR dyn_ptr, dyn_addr;
   int arch_size, step, sect_size;
   long dyn_tag;
   CORE_ADDR dyn_ptr, dyn_addr;

-  gdb_byte *bufend, *buf;
+  gdb_byte *bufend, *bufstart, *buf;

   Elf32_External_Dyn *x_dynp_32;
   Elf64_External_Dyn *x_dynp_64;
   struct bfd_section *sect;
   Elf32_External_Dyn *x_dynp_32;
   Elf64_External_Dyn *x_dynp_64;
   struct bfd_section *sect;


@@ -380,16 +370,13 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
     return 0;
   dyn_addr = bfd_section_vma (abfd, sect);
 
     return 0;
   dyn_addr = bfd_section_vma (abfd, sect);
 

-  /* Read in .dynamic section, silently ignore errors.  */
+  /* Read in .dynamic from the BFD.  We will get the actual value
+     from memory later.  */

   sect_size = bfd_section_size (abfd, sect);
   sect_size = bfd_section_size (abfd, sect);

-  buf = alloca (sect_size);
-  if (target_read_memory (dyn_addr, buf, sect_size))
-    {
-      /* If target_read_memory fails, try reading the BFD file.  */
-      if (!bfd_get_section_contents (abfd, sect,
-                                    buf, 0, sect_size))
-       return 0;
-    }
+  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)
 
   /* Iterate over BUF and scan for DYNTAG.  If found, set PTR and return.  */
   step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)


@@ -404,7 +391,7 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
        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);
       }
        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
+    else

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


@@ -414,9 +401,20 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
        return 0;
      if (dyn_tag == dyntag)
        {
        return 0;
      if (dyn_tag == dyntag)
        {

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

         if (ptr)
         if (ptr)

-          *ptr = dyn_ptr;
-         return 1;
+          {
+            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;

        }
   }
 
        }
   }
 


@@ -454,11 +452,9 @@ elf_locate_base (void)
   struct minimal_symbol *msymbol;
   CORE_ADDR dyn_ptr;
 
   struct minimal_symbol *msymbol;
   CORE_ADDR dyn_ptr;
 

-  /* Find DT_DEBUG.  */
-  if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr))
-    return dyn_ptr;
-
-  /* Find DT_MIPS_RLD_MAP.  */
+  /* 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;
   if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr))
     {
       gdb_byte *pbuf;


@@ -471,6 +467,10 @@ elf_locate_base (void)
       return extract_typed_address (pbuf, builtin_type_void_data_ptr);
     }
 
       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);
   /* 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);


@@ -632,6 +632,7 @@ open_symbol_file_object (void *from_ttyp)
 
   /* Now fetch the filename from target memory.  */
   target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
 
   /* 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)
     {
 
   if (errcode)
     {


@@ -640,7 +641,6 @@ open_symbol_file_object (void *from_ttyp)
       return 0;
     }
 
       return 0;
     }
 

-  make_cleanup (xfree, filename);

   /* Have a pathname: read the symbol file.  */
   symbol_file_add_main (filename, from_tty);
 
   /* Have a pathname: read the symbol file.  */
   symbol_file_add_main (filename, from_tty);
 


@@ -760,9 +760,9 @@ svr4_current_sos (void)
            {
              strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
              new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
            {
              strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
              new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';

-             xfree (buffer);

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

+         xfree (buffer);

 
          /* If this entry has no name, or its name matches the name
             for the main executable, don't include it in the list.  */
 
          /* If this entry has no name, or its name matches the name
             for the main executable, don't include it in the list.  */


@@ -848,8 +848,11 @@ svr4_fetch_objfile_link_map (struct objfile *objfile)
          /* Is this the linkmap for the file we want?  */
          /* If the file is not a shared library and has no name,
             we are sure it is the main executable, so we return that.  */
          /* Is this the linkmap for the file we want?  */
          /* If the file is not a shared library and has no name,
             we are sure it is the main executable, so we return that.  */

-         if ((buffer && strcmp (buffer, objfile->name) == 0)
-              || (!(objfile->flags & OBJF_SHARED) && (strcmp (buffer, "") == 0)))
+
+         if (buffer 
+             && ((strcmp (buffer, objfile->name) == 0)
+                 || (!(objfile->flags & OBJF_SHARED) 
+                     && (strcmp (buffer, "") == 0))))

            {
              do_cleanups (old_chain);
              return lm;
            {
              do_cleanups (old_chain);
              return lm;


@@ -1006,11 +1009,6 @@ enable_break (void)
          be trivial on GNU/Linux).  Therefore, we have to try an alternate
          mechanism to find the dynamic linker's base address.  */
 
          be trivial on GNU/Linux).  Therefore, we have to try an alternate
          mechanism to find the dynamic linker's base address.  */
 

-      /* TODO drow/2006-09-12: This is somewhat fragile, because it
-        relies on read_pc.  On both Solaris and GNU/Linux we can use
-        the AT_BASE auxilliary entry, which GDB now knows how to
-        access, to find the base address.  */
-

       tmp_fd = solib_open (buf, &tmp_pathname);
       if (tmp_fd >= 0)
        tmp_bfd = bfd_fopen (tmp_pathname, gnutarget, FOPEN_RB, tmp_fd);
       tmp_fd = solib_open (buf, &tmp_pathname);
       if (tmp_fd >= 0)
        tmp_bfd = bfd_fopen (tmp_pathname, gnutarget, FOPEN_RB, tmp_fd);


@@ -1033,7 +1031,7 @@ enable_break (void)
 
       /* On a running target, we can get the dynamic linker's base
          address from the shared library table.  */
 
       /* On a running target, we can get the dynamic linker's base
          address from the shared library table.  */

-      solib_add (NULL, 0, NULL, auto_solib_add);
+      solib_add (NULL, 0, &current_target, auto_solib_add);

       so = master_so_list ();
       while (so)
        {
       so = master_so_list ();
       while (so)
        {


@@ -1046,9 +1044,19 @@ enable_break (void)
          so = so->next;
        }
 
          so = so->next;
        }
 

+      /* If we were not able to find the base address of the loader
+         from our so_list, then try using the AT_BASE auxilliary entry.  */
+      if (!load_addr_found)
+        if (target_auxv_search (&current_target, AT_BASE, &load_addr) > 0)
+          load_addr_found = 1;
+

       /* Otherwise we find the dynamic linker's base address by examining
         the current pc (which should point at the entry point for the
       /* Otherwise we find the dynamic linker's base address by examining
         the current pc (which should point at the entry point for the

-        dynamic linker) and subtracting the offset of the entry point.  */
+        dynamic linker) and subtracting the offset of the entry point.
+
+         This is more fragile than the previous approaches, but is a good
+         fallback method because it has actually been working well in
+         most cases.  */

       if (!load_addr_found)
        {
          load_addr = (read_pc ()
       if (!load_addr_found)
        {
          load_addr = (read_pc ()


@@ -1056,7 +1064,7 @@ enable_break (void)
          debug_loader_name = xstrdup (buf);
          debug_loader_offset_p = 1;
          debug_loader_offset = load_addr;
          debug_loader_name = xstrdup (buf);
          debug_loader_offset_p = 1;
          debug_loader_offset = load_addr;

-         solib_add (NULL, 0, NULL, auto_solib_add);
+         solib_add (NULL, 0, &current_target, auto_solib_add);

        }
 
       /* Record the relocated start and end address of the dynamic linker
        }
 
       /* Record the relocated start and end address of the dynamic linker


@@ -1081,20 +1089,19 @@ enable_break (void)
       /* Now try to set a breakpoint in the dynamic linker.  */
       for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
        {
       /* Now try to set a breakpoint in the dynamic linker.  */
       for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
        {

-          /* On ABI's that use function descriptors, there are usually
-             two linker symbols associated with each C function: one
-             pointing at the actual entry point of the machine code,
-             and one pointing at the function's descriptor.  The
-             latter symbol has the same name as the C function.
-
-             What we're looking for here is the machine code entry
-             point, so we are only interested in symbols in code
-             sections.  */
-         sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep, SEC_CODE);
+         sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);

          if (sym_addr != 0)
            break;
        }
 
          if (sym_addr != 0)
            break;
        }
 

+      if (sym_addr != 0)
+       /* Convert 'sym_addr' from a function pointer to an address.
+          Because we pass tmp_bfd_target instead of the current
+          target, this will always produce an unrelocated value.  */
+       sym_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+                                                      sym_addr,
+                                                      tmp_bfd_target);
+

       /* We're done with both the temporary bfd and target.  Remember,
          closing the target closes the underlying bfd.  */
       target_close (tmp_bfd_target, 0);
       /* We're done with both the temporary bfd and target.  Remember,
          closing the target closes the underlying bfd.  */
       target_close (tmp_bfd_target, 0);


@@ -1108,6 +1115,7 @@ enable_break (void)
       /* For whatever reason we couldn't set a breakpoint in the dynamic
          linker.  Warn and drop into the old code.  */
     bkpt_at_symbol:
       /* For whatever reason we couldn't set a breakpoint in the dynamic
          linker.  Warn and drop into the old code.  */
     bkpt_at_symbol:

+      xfree (tmp_pathname);

       warning (_("Unable to find dynamic linker breakpoint function.\n"
                "GDB will be unable to debug shared library initializers\n"
                "and track explicitly loaded dynamic code."));
       warning (_("Unable to find dynamic linker breakpoint function.\n"
                "GDB will be unable to debug shared library initializers\n"
                "and track explicitly loaded dynamic code."));


@@ -1555,7 +1563,7 @@ elf_lookup_lib_symbol (const struct objfile *objfile,
      || scan_dyntag (DT_SYMBOLIC, objfile->obfd, NULL) != 1)
     return NULL;
 
      || scan_dyntag (DT_SYMBOLIC, objfile->obfd, NULL) != 1)
     return NULL;
 

-  return  lookup_global_symbol_from_objfile
+  return lookup_global_symbol_from_objfile

                (objfile, name, linkage_name, domain, symtab);
 }
 
                (objfile, name, linkage_name, domain, symtab);
 }