1 files changed, 175 insertions, 102 deletions

diff --git a/elf/cache.c b/elf/cache.c
index cc75704f54..fbbc426268 100644
--- a/elf/cache.c
+++ b/elf/cache.c
@@ -17,9 +17,6 @@
    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-#define _GNU_SOURCE 1
-
-#include <assert.h>
 #include <errno.h>
 #include <error.h>
 #include <dirent.h>
@@ -34,32 +31,18 @@
 #include <sys/types.h>
 
 #include "ldconfig.h"
-
-#define CACHEMAGIC "ld.so-1.7.0"
+#include "dl-cache.h"
 
 struct cache_entry
 {
-  char *lib;
-  char *path;
-  int flags;
-  struct cache_entry *next;
+  char *lib;			/* Library name.  */
+  char *path;			/* Path to find library.  */
+  int flags;			/* Flags to indicate kind of library.  */
+  unsigned long int hwcap;	/* Important hardware capabilities.  */
+  int bits_hwcap;		/* Number of bits set in hwcap.  */
+  struct cache_entry *next;	/* Next entry in list.  */
 };
 
-struct file_entry
-{
-  int flags;		/* This is 1 for an ELF library.  */
-  unsigned int key, value; /* String table indices.  */
-};
-
-
-struct cache_file
-{
-  char magic[sizeof CACHEMAGIC - 1];
-  unsigned int nlibs;
-  struct file_entry libs[0];
-};
-
-
 /* List of all cache entries.  */
 static struct cache_entry *entries;
 
@@ -69,7 +52,7 @@ static const char *flag_descr[] =
 
 /* Print a single entry.  */
 static void
-print_entry (const char *lib, int flag, const char *key)
+print_entry (const char *lib, int flag, unsigned long int hwcap, const char *key)
 {
   printf ("\t%s (", lib);
   switch (flag & FLAG_TYPE_MASK)
@@ -93,14 +76,17 @@ print_entry (const char *lib, int flag, const char *key)
     case 0:
       break;
     default:
-      fprintf (stdout, ",%d", flag & FLAG_REQUIRED_MASK);
+      printf (",%d", flag & FLAG_REQUIRED_MASK);
       break;
     }
+  if (hwcap != 0)
+    printf (", hwcap: 0x%lx", hwcap);
   printf (") => %s\n", key);
 }
 
 
-/* Print the whole cache file.  */
+/* Print the whole cache file, if a file contains the new cache format
+   hidden in the old one, print the contents of the new format.  */
 void
 print_cache (const char *cache_name)
 {
@@ -109,7 +95,9 @@ print_cache (const char *cache_name)
   int fd;
   unsigned int i;
   struct cache_file *cache;
+  struct cache_file_new *cache_new = NULL;
   const char *cache_data;
+  int format = 0;
 
   fd = open (cache_name, O_RDONLY);
   if (fd < 0)
@@ -128,20 +116,63 @@ print_cache (const char *cache_name)
     error (EXIT_FAILURE, errno, _("mmap of cache file failed.\n"));
   cache_size = st.st_size;
 
-  if (cache_size < sizeof (struct cache_file)
-      || memcmp (cache->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1))
-    return;
-  /* This is where the strings start.  */
-  cache_data = (const char *) &cache->libs[cache->nlibs];
+  if (cache_size < sizeof (struct cache_file))
+    error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
+
+  if (memcmp (cache->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1))
+    {
+      /* This can only be the new format without the old one.  */
+      cache_new = (struct cache_file_new *) cache;
+
+      if (memcmp (cache_new->magic, CACHEMAGIC_NEW, sizeof CACHEMAGIC_NEW - 1)
+	  || memcmp (cache_new->version, CACHE_VERSION,
+		      sizeof CACHE_VERSION - 1))
+	error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));
+      format = 1;
+      /* This is where the strings start.  */
+      cache_data = (const char *) cache;
+    }
+  else
+    {
+      /* This is where the strings start.  */
+      cache_data = (const char *) &cache->libs[cache->nlibs];
+
+      /* Check for a new cache embedded in the old format.  */
+      if (cache_size >
+	  (sizeof (struct cache_file)
+	   + cache->nlibs * sizeof (struct file_entry)
+	   + sizeof (struct cache_file_new)))
+	{
+	  cache_new = (struct cache_file_new *) cache_data;
 
-  printf (_("%d libs found in cache `%s'\n"), cache->nlibs, cache_name);
+	  if (!memcmp (cache_new->magic, CACHEMAGIC_NEW, sizeof CACHEMAGIC_NEW - 1)
+	      && !memcmp (cache_new->version, CACHE_VERSION,
+			  sizeof CACHE_VERSION - 1))
+	    format = 1;
+	}
+    }
 
-  /* Print everything.  */
-  for (i = 0; i < cache->nlibs; i++)
-    print_entry (cache_data + cache->libs[i].key,
-		 cache->libs[i].flags,
-		 cache_data + cache->libs[i].value);
+  if (format == 0)
+    {
+      printf (_("%d libs found in cache `%s'\n"), cache->nlibs, cache_name);
 
+      /* Print everything.  */
+      for (i = 0; i < cache->nlibs; i++)
+	print_entry (cache_data + cache->libs[i].key,
+		     cache->libs[i].flags, 0,
+		     cache_data + cache->libs[i].value);
+    }
+  else if (format == 1)
+    {
+      printf (_("%d libs found in cache `%s'\n"), cache_new->nlibs, cache_name);
+
+      /* Print everything.  */
+      for (i = 0; i < cache_new->nlibs; i++)
+	print_entry (cache_data + cache_new->libs[i].key,
+		     cache_new->libs[i].flags,
+		     cache_new->libs[i].hwcap,
+		     cache_data + cache_new->libs[i].value);
+    }
   /* Cleanup.  */
   munmap (cache, cache_size);
   close (fd);
@@ -155,45 +186,6 @@ init_cache (void)
 }
 
 
-/* Helper function which must match the one in the dynamic linker, so that
-   we rely on the same sort order.  */
-int
-cache_libcmp (const char *p1, const char *p2)
-{
-  while (*p1 != '\0')
-    {
-      if (*p1 >= '0' && *p1 <= '9')
-        {
-          if (*p2 >= '0' && *p2 <= '9')
-            {
-	      /* Must compare this numerically.  */
-	      int val1;
-	      int val2;
-
-	      val1 = *p1++ - '0';
-	      val2 = *p2++ - '0';
-	      while (*p1 >= '0' && *p1 <= '9')
-	        val1 = val1 * 10 + *p1++ - '0';
-	      while (*p2 >= '0' && *p2 <= '9')
-	        val2 = val2 * 10 + *p2++ - '0';
-	      if (val1 != val2)
-		return val1 - val2;
-	    }
-	  else
-            return 1;
-        }
-      else if (*p2 >= '0' && *p2 <= '9')
-        return -1;
-      else if (*p1 != *p2)
-        return *p1 - *p2;
-      else
-	{
-	  ++p1;
-	  ++p2;
-	}
-    }
-  return *p1 - *p2;
-}
 
 static
 int compare (const struct cache_entry *e1, const struct cache_entry *e2)
@@ -201,80 +193,142 @@ int compare (const struct cache_entry *e1, const struct cache_entry *e2)
   int res;
 
   /* We need to swap entries here to get the correct sort order.  */
-  res = cache_libcmp (e2->lib, e1->lib);
+  res = _dl_cache_libcmp (e2->lib, e1->lib);
   if (res == 0)
     {
       if (e1->flags < e2->flags)
 	return 1;
       else if (e1->flags > e2->flags)
 	return -1;
+      /* Sort by most specific hwcap.  */
+      else if (e2->bits_hwcap > e1->bits_hwcap)
+	return 1;
+      else if (e2->bits_hwcap < e1->bits_hwcap)
+	return -1;
+      else if (e2->hwcap > e1->hwcap)
+	return 1;
+      else if (e2->hwcap < e1->hwcap)
+	return -1;
     }
   return res;
 }
 
-
 /* Save the contents of the cache.  */
 void
 save_cache (const char *cache_name)
 {
   struct cache_entry *entry;
-  int i, fd;
+  int fd, idx_old, idx_new;
   size_t total_strlen, len;
   char *strings, *str, *temp_name;
-  struct cache_file *file_entries;
-  size_t file_entries_size;
+  struct cache_file *file_entries = NULL;
+  struct cache_file_new *file_entries_new = NULL;
+  size_t file_entries_size = 0;
+  size_t file_entries_new_size = 0;
   unsigned int str_offset;
   /* Number of cache entries.  */
   int cache_entry_count = 0;
+  /* Number of normal cache entries.  */
+  int cache_entry_old_count = 0;
 
   /* The cache entries are sorted already, save them in this order. */
 
   /* Count the length of all strings.  */
+  /* The old format doesn't contain hwcap entries and doesn't contain
+     libraries in subdirectories with hwcaps entries.  Count therefore
+     also all entries with hwcap == 0.  */
   total_strlen = 0;
   for (entry = entries; entry != NULL; entry = entry->next)
     {
       /* Account the final NULs.  */
       total_strlen += strlen (entry->lib) + strlen (entry->path) + 2;
       ++cache_entry_count;
+      if (entry->hwcap == 0)
+	++cache_entry_old_count;
     }
 
   /* Create the on disk cache structure.  */
   /* First an array for all strings.  */
-  strings = (char *)xmalloc (total_strlen + 1);
+  strings = (char *)xmalloc (total_strlen);
 
-  /* And the list of all entries.  */
-  file_entries_size = sizeof (struct cache_file)
-    + cache_entry_count * sizeof (struct file_entry);
-  file_entries = (struct cache_file *) xmalloc (file_entries_size);
+  if (opt_format != 2)
+    {
+      /* And the list of all entries in the old format.  */
+      file_entries_size = sizeof (struct cache_file)
+	+ cache_entry_old_count * sizeof (struct file_entry);
+      file_entries = (struct cache_file *) xmalloc (file_entries_size);
+
+      /* Fill in the header.  */
+      memset (file_entries, 0, sizeof (struct cache_file));
+      memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);
 
-  /* Fill in the header.  */
-  memset (file_entries, 0, sizeof (struct cache_file));
-  memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);
+      file_entries->nlibs = cache_entry_old_count;
+    }
 
-  file_entries->nlibs = cache_entry_count;
+  if (opt_format != 0)
+    {
+      /* And the list of all entries in the new format.  */
+      file_entries_new_size = sizeof (struct cache_file_new)
+	+ cache_entry_count * sizeof (struct file_entry_new);
+      file_entries_new = (struct cache_file_new *) xmalloc (file_entries_new_size);
+
+      /* Fill in the header.  */
+      memset (file_entries_new, 0, sizeof (struct cache_file_new));
+      memcpy (file_entries_new->magic, CACHEMAGIC_NEW, sizeof CACHEMAGIC_NEW - 1);
+      memcpy (file_entries_new->version, CACHE_VERSION, sizeof CACHE_VERSION - 1);
+
+      file_entries_new->nlibs = cache_entry_count;
+      file_entries_new->len_strings = total_strlen;
+    }
+
+  /* If we have both formats, we hide the new format in the strings
+     table, we have to adjust all string indices for this so that
+     old libc5/glibc 2 dynamic linkers just ignore them.  */
+  if (opt_format == 1)
+    str_offset = file_entries_new_size;
+  else
+    str_offset = 0;
 
-  str_offset = 0;
   str = strings;
-  for (i = 0, entry = entries; entry != NULL; entry = entry->next, ++i)
+  for (idx_old = 0, idx_new = 0, entry = entries; entry != NULL;
+       entry = entry->next, ++idx_new)
     {
-      file_entries->libs[i].flags = entry->flags;
       /* First the library.  */
-      /* XXX: Actually we can optimize here and remove duplicates.  */
-      file_entries->libs[i].key = str_offset;
+      if (opt_format != 2)
+	{
+	  file_entries->libs[idx_old].flags = entry->flags;
+	  /* XXX: Actually we can optimize here and remove duplicates.  */
+	  file_entries->libs[idx_old].key = str_offset;
+	}
+      if (opt_format != 0)
+	{
+	  /* We could subtract file_entries_new_size from str_offset -
+	     not doing so makes the code easier, the string table
+	     always begins at the beginning of the the new cache
+	     struct.  */
+	  file_entries_new->libs[idx_new].flags = entry->flags;
+	  file_entries_new->libs[idx_new].hwcap = entry->hwcap;
+	  file_entries_new->libs[idx_new].key = str_offset;
+	}
       len = strlen (entry->lib);
       str = stpcpy (str, entry->lib);
       /* Account the final NUL.  */
       ++str;
       str_offset += len + 1;
       /* Then the path.  */
-      file_entries->libs[i].value = str_offset;
+      if (opt_format != 2)
+	file_entries->libs[idx_old].value = str_offset;
+      if (opt_format != 0)
+	file_entries_new->libs[idx_new].value = str_offset;
       len = strlen (entry->path);
       str = stpcpy (str, entry->path);
       /* Account the final NUL.  */
       ++str;
       str_offset += len + 1;
+      /* Ignore entries with hwcap for old format.  */
+      if (entry->hwcap == 0)
+	++idx_old;
     }
-  assert (str_offset == total_strlen);
 
   /* Write out the cache.  */
 
@@ -293,8 +347,17 @@ save_cache (const char *cache_name)
 	   temp_name);
 
   /* Write contents.  */
-  if (write (fd, file_entries, file_entries_size) != (ssize_t)file_entries_size)
-    error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
+  if (opt_format != 2)
+    {
+      if (write (fd, file_entries, file_entries_size) != (ssize_t)file_entries_size)
+	error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
+    }
+  if (opt_format != 0)
+    {
+      if (write (fd, file_entries_new, file_entries_new_size)
+	  != (ssize_t)file_entries_new_size)
+	error (EXIT_FAILURE, errno, _("Writing of cache data failed"));
+    }
 
   if (write (fd, strings, total_strlen) != (ssize_t)total_strlen)
     error (EXIT_FAILURE, errno, _("Writing of cache data failed."));
@@ -325,13 +388,15 @@ save_cache (const char *cache_name)
     }
 }
 
+
 /* Add one library to the cache.  */
 void
-add_to_cache (const char *path, const char *lib, int flags)
+add_to_cache (const char *path, const char *lib, int flags,
+	      unsigned long int hwcap)
 {
   struct cache_entry *new_entry, *ptr, *prev;
   char *full_path;
-  int len;
+  int len, i;
 
   new_entry = (struct cache_entry *) xmalloc (sizeof (struct cache_entry));
 
@@ -343,6 +408,14 @@ add_to_cache (const char *path, const char *lib, int flags)
   new_entry->lib = xstrdup (lib);
   new_entry->path = full_path;
   new_entry->flags = flags;
+  new_entry->hwcap = hwcap;
+  new_entry->bits_hwcap = 0;
+
+  /* Count the number of bits set in the masked value.  */
+  for (i = 0; (~((1UL << i) - 1) & hwcap) != 0; ++i)
+    if ((hwcap & (1UL << i)) != 0)
+      ++new_entry->bits_hwcap;
+
 
   /* Keep the list sorted - search for right place to insert.  */
   ptr = entries;