Implement support for archives with 64-bit symbol table

Signed-off-by: Petr Machata <pmachata@redhat.com>

diff --git a/libdwfl/ChangeLog b/libdwfl/ChangeLog
index 86f6fba47b78376a11633d4d4c49e78ff6e19f94..36db7a327ea712e1aba08bbac47ef07ad30acb1f 100644 (file)
--- a/libdwfl/ChangeLog
+++ b/libdwfl/ChangeLog
@@ -1,3 +1,7 @@
+2012-08-01  Petr Machata  <pmachata@redhat.com>
+
+       * offline.c (process_archive_member): Ignore entry "/SYM64/".
+
 2012-03-28  Roland McGrath  <roland@hack.frob.com>
 
        * dwfl_segment_report_module.c

diff --git a/libdwfl/offline.c b/libdwfl/offline.c
index a142acd996d7c45f07fa4c0791b765ad695a5d6d..26a6bd664dd55b1b284018c044ca1dc72f452933 100644 (file)
--- a/libdwfl/offline.c
+++ b/libdwfl/offline.c
@@ -1,5 +1,5 @@
 /* Recover relocatibility for addresses computed from debug information.
-   Copyright (C) 2005, 2006, 2007, 2008, 2009 Red Hat, Inc.
+   Copyright (C) 2005-2009, 2012 Red Hat, Inc.
    This file is part of elfutils.
 
    This file is free software; you can redistribute it and/or modify
@@ -169,7 +169,8 @@ process_archive_member (Dwfl *dwfl, const char *name, const char *file_name,
       return ELF_C_NULL;
     }
 
-  if (!strcmp (h->ar_name, "/") || !strcmp (h->ar_name, "//"))
+  if (!strcmp (h->ar_name, "/") || !strcmp (h->ar_name, "//")
+      || !strcmp (h->ar_name, "/SYM64/"))
     {
     skip:;
       /* Skip this and go to the next.  */

diff --git a/libelf/ChangeLog b/libelf/ChangeLog
index 8c9ff8b65dbc8c90235aea3cf791245539758afe..18ada8554b786739ee3efe0d20ee00d6ca3378aa 100644 (file)
--- a/libelf/ChangeLog
+++ b/libelf/ChangeLog
@@ -1,3 +1,11 @@
+2012-08-01  Petr Machata  <pmachata@redhat.com>
+
+       * elf_getarsym (read_number_entries): New function.
+       (elf_getarsym): Handle 64-bit symbol table, stored in special
+       entry named "/SYM64/".
+       * elf_begin.c (__libelf_next_arhdr_wrlock): Don't reject archive
+       because it contains 64-bit symbol table.
+
 2012-07-19  Mark Wielaard  <mjw@redhat.com>
 
        * elf32_getshdr.c (load_shdr_wrlock): Add elf->flags & ELF_F_MALLOCED

diff --git a/libelf/elf_begin.c b/libelf/elf_begin.c
index 5cd2f074686b21d5f58f42c2c04efcafeb54c557..b9d5cea4eb1f6a5e45de7a01270b8123d1a078ff 100644 (file)
--- a/libelf/elf_begin.c
+++ b/libelf/elf_begin.c
@@ -1,5 +1,5 @@
 /* Create descriptor for processing file.
-   Copyright (C) 1998-2010 Red Hat, Inc.
+   Copyright (C) 1998-2010, 2012 Red Hat, Inc.
    This file is part of elfutils.
    Written by Ulrich Drepper <drepper@redhat.com>, 1998.
 
@@ -787,6 +787,10 @@ __libelf_next_arhdr_wrlock (elf)
          && memcmp (ar_hdr->ar_name, "/               ", 16) == 0)
        /* This is the index.  */
        elf_ar_hdr->ar_name = memcpy (elf->state.ar.ar_name, "/", 2);
+      else if (ar_hdr->ar_name[1] == 'S'
+              && memcmp (ar_hdr->ar_name, "/SYM64/         ", 16) == 0)
+       /* 64-bit index.  */
+       elf_ar_hdr->ar_name = memcpy (elf->state.ar.ar_name, "/SYM64/", 8);
       else if (ar_hdr->ar_name[1] == '/'
               && memcmp (ar_hdr->ar_name, "//              ", 16) == 0)
        /* This is the array with the long names.  */

diff --git a/libelf/elf_getarsym.c b/libelf/elf_getarsym.c
index eafaef5b81a4650aa9d3887234041b40db6eba40..9e0f4c2bbf54f677dfe34ffc00344a1eacf43529 100644 (file)
--- a/libelf/elf_getarsym.c
+++ b/libelf/elf_getarsym.c
@@ -1,5 +1,5 @@
 /* Return symbol table of archive.
-   Copyright (C) 1998, 1999, 2000, 2002, 2005 Red Hat, Inc.
+   Copyright (C) 1998-2000, 2002, 2005, 2012 Red Hat, Inc.
    This file is part of elfutils.
    Written by Ulrich Drepper <drepper@redhat.com>, 1998.
 
@@ -35,6 +35,7 @@
 #include <byteswap.h>
 #include <endian.h>
 #include <errno.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -45,6 +46,31 @@
 #include "libelfP.h"
 
 
+static int
+read_number_entries (uint64_t *nump, Elf *elf, size_t *offp, bool index64_p)
+{
+  union u
+  {
+    uint64_t ret64;
+    uint32_t ret32;
+  } u;
+
+  size_t w = index64_p ? 8 : 4;
+  if (elf->map_address != NULL)
+    u = *(union u *) (elf->map_address + *offp);
+  else if ((size_t) pread_retry (elf->fildes, &u, w, *offp) != w)
+    return -1;
+
+  *offp += w;
+
+  if (__BYTE_ORDER == __LITTLE_ENDIAN)
+    *nump = index64_p ? bswap_64 (u.ret64) : bswap_32 (u.ret32);
+  else
+    *nump = index64_p ? u.ret64 : u.ret32;
+
+  return 0;
+}
+
 Elf_Arsym *
 elf_getarsym (elf, ptr)
      Elf *elf;
@@ -116,11 +142,17 @@ elf_getarsym (elf, ptr)
          goto out;
        }
 
-      /* Now test whether this is the index.  It is denoted by the
-        name being "/ ".
+      bool index64_p;
+      /* Now test whether this is the index.  If the name is "/", this
+        is 32-bit index, if it's "/SYM64/", it's 64-bit index.
+
         XXX This is not entirely true.  There are some more forms.
         Which of them shall we handle?  */
-      if (memcmp (index_hdr->ar_name, "/               ", 16) != 0)
+      if (memcmp (index_hdr->ar_name, "/               ", 16) == 0)
+       index64_p = false;
+      else if (memcmp (index_hdr->ar_name, "/SYM64/         ", 16) == 0)
+       index64_p = true;
+      else
        {
          /* If the index is not the first entry, there is no index.
 
@@ -128,27 +160,18 @@ elf_getarsym (elf, ptr)
          __libelf_seterrno (ELF_E_NO_INDEX);
          goto out;
        }
+      int w = index64_p ? 8 : 4;
 
       /* We have an archive.  The first word in there is the number of
         entries in the table.  */
-      uint32_t n;
-      if (elf->map_address == NULL)
+      uint64_t n;
+      size_t off = elf->start_offset + SARMAG + sizeof (struct ar_hdr);
+      if (read_number_entries (&n, elf, &off, index64_p) < 0)
        {
-         if (pread_retry (elf->fildes, &n, sizeof (n),
-                          elf->start_offset + SARMAG + sizeof (struct ar_hdr))
-             != sizeof (n))
-           {
-             /* Cannot read the number of entries.  */
-             __libelf_seterrno (ELF_E_NO_INDEX);
-             goto out;
-           }
+         /* Cannot read the number of entries.  */
+         __libelf_seterrno (ELF_E_NO_INDEX);
+         goto out;
        }
-      else
-       n = *(uint32_t *) (elf->map_address + elf->start_offset
-                          + SARMAG + sizeof (struct ar_hdr));
-
-      if (__BYTE_ORDER == __LITTLE_ENDIAN)
-       n = bswap_32 (n);
 
       /* Now we can perform some first tests on whether all the data
         needed for the index is available.  */
@@ -158,7 +181,7 @@ elf_getarsym (elf, ptr)
       size_t index_size = atol (tmpbuf);
 
       if (SARMAG + sizeof (struct ar_hdr) + index_size > elf->maximum_size
-         || n * sizeof (uint32_t) > index_size)
+         || n * w > index_size)
        {
          /* This index table cannot be right since it does not fit into
             the file.  */
@@ -171,14 +194,19 @@ elf_getarsym (elf, ptr)
       elf->state.ar.ar_sym = (Elf_Arsym *) malloc (ar_sym_len);
       if (elf->state.ar.ar_sym != NULL)
        {
-         uint32_t *file_data;
+         union
+         {
+           uint32_t u32[n];
+           uint64_t u64[n];
+         } *file_data;
          char *str_data;
+         size_t sz = n * w;
 
          if (elf->map_address == NULL)
            {
-             file_data = (uint32_t *) alloca (n * sizeof (uint32_t));
+             file_data = alloca (sz);
 
-             ar_sym_len += index_size - n * sizeof (uint32_t);
+             ar_sym_len += index_size - n * w;
              Elf_Arsym *newp = (Elf_Arsym *) realloc (elf->state.ar.ar_sym,
                                                       ar_sym_len);
              if (newp == NULL)
@@ -193,18 +221,10 @@ elf_getarsym (elf, ptr)
              char *new_str = (char *) (elf->state.ar.ar_sym + n + 1);
 
              /* Now read the data from the file.  */
-             if ((size_t) pread_retry (elf->fildes, file_data,
-                                       n * sizeof (uint32_t),
-                                       elf->start_offset + SARMAG
-                                       + sizeof (struct ar_hdr)
-                                       + sizeof (uint32_t))
-                 != n * sizeof (uint32_t)
+             if ((size_t) pread_retry (elf->fildes, file_data, sz, off) != sz
                  || ((size_t) pread_retry (elf->fildes, new_str,
-                                           index_size - n * sizeof (uint32_t),
-                                           elf->start_offset
-                                           + SARMAG + sizeof (struct ar_hdr)
-                                           + (n + 1) * sizeof (uint32_t))
-                     != index_size - n * sizeof (uint32_t)))
+                                           index_size - sz, off + sz)
+                     != index_size - sz))
                {
                  /* We were not able to read the data.  */
                  free (elf->state.ar.ar_sym);
@@ -217,10 +237,8 @@ elf_getarsym (elf, ptr)
            }
          else
            {
-             file_data = (uint32_t *) (elf->map_address + elf->start_offset
-                                       + SARMAG + sizeof (struct ar_hdr)
-                                       + sizeof (uint32_t));
-             str_data = (char *) &file_data[n];
+             file_data = (void *) (elf->map_address + off);
+             str_data = (char *) (elf->map_address + off + sz);
            }
 
          /* Now we can build the data structure.  */
@@ -228,13 +246,38 @@ elf_getarsym (elf, ptr)
          for (size_t cnt = 0; cnt < n; ++cnt)
            {
              arsym[cnt].as_name = str_data;
-             if (__BYTE_ORDER == __LITTLE_ENDIAN)
-               arsym[cnt].as_off = bswap_32 (file_data[cnt]);
+             if (index64_p)
+               {
+                 uint64_t tmp = file_data->u64[cnt];
+                 if (__BYTE_ORDER == __LITTLE_ENDIAN)
+                   tmp = bswap_64 (tmp);
+
+                 arsym[cnt].as_off = tmp;
+
+                 /* Check whether 64-bit offset fits into 32-bit
+                    size_t.  */
+                 if (sizeof (arsym[cnt].as_off) < 8
+                     && arsym[cnt].as_off != tmp)
+                   {
+                     if (elf->map_address == NULL)
+                       {
+                         free (elf->state.ar.ar_sym);
+                         elf->state.ar.ar_sym = NULL;
+                       }
+
+                     __libelf_seterrno (ELF_E_RANGE);
+                     goto out;
+                   }
+               }
+             else if (__BYTE_ORDER == __LITTLE_ENDIAN)
+               arsym[cnt].as_off = bswap_32 (file_data->u32[cnt]);
              else
-               arsym[cnt].as_off = file_data[cnt];
+               arsym[cnt].as_off = file_data->u32[cnt];
+
              arsym[cnt].as_hash = _dl_elf_hash (str_data);
              str_data = rawmemchr (str_data, '\0') + 1;
            }
+
          /* At the end a special entry.  */
          arsym[n].as_name = NULL;
          arsym[n].as_off = 0;