>From 37118707e4974c6bc95d2e3d7fbf59ac1e1912c3 Mon Sep 17 00:00:00 2001
From: Petr Machata <pmachata@redhat.com>
Date: Wed, 1 Aug 2012 21:37:52 +0200
Subject: [PATCH 1/2] Implement support for archives with 64-bit symbol table

Signed-off-by: Petr Machata <pmachata@redhat.com>
---
 libdwfl/ChangeLog     |    4 ++
 libdwfl/offline.c     |    5 +-
 libelf/ChangeLog      |    8 +++
 libelf/elf_begin.c    |    6 ++-
 libelf/elf_getarsym.c |  127 +++++++++++++++++++++++++++++++++----------------
 5 files changed, 105 insertions(+), 45 deletions(-)

diff --git a/libdwfl/ChangeLog b/libdwfl/ChangeLog
index 86f6fba..36db7a3 100644
--- 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 a142acd..da13595 100644
--- 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-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 8c9ff8b..18ada85 100644
--- 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 5cd2f07..9f4c2d8 100644
--- 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-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 eafaef5..09b0d6c 100644
--- 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-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;
-- 
1.7.6.5

