2007-08-01  Andreas Jaeger  <aj@suse.de>

	    Jakub Jelinek  <jakub@redhat.com>

	* elf/ldconfig.c (opt_ignore_aux_cache): Add new option.

	(options): Add option.

	(parse_opt): Handle option.

	(manual_link): Adjust process_file caller.  Call implicit_soname.

	(search_dir): Formatting.  Use and populate auxiliary cache.

	(main): Load and save auxiliary cache.

	* elf/readlib.c (process_file): Add stat_buf argument.  Pass struct

	stat64 from fstat64 to caller.

	(implicit_soname): New function.

	* elf/readelflib.c (process_elf_file): If DT_SONAME is not present,

	leave *soname as NULL.

	* elf/cache.c: Include libgen.h.

	(print_entry, print_cache, compare, save_cache, add_to_cache):

	Formatting and cleanups.

	(aux_cache_entry_id, aux_cache_entry, aux_cache_file_entry,

	aux_cache_file): New structures.

	(AUX_CACHEMAGIC): Define.

	(primes): New array.

	(aux_hash_size, aux_hash): New variables.

	(aux_cache_entry_id_hash, nextprime, init_aux_cache,

	search_aux_cache, insert_to_aux_cache, add_to_aux_cache,

	load_aux_cache, save_aux_cache): New functions.

	* sysdeps/generic/ldconfig.h (_PATH_LDCONFIG_AUX_CACHE): Define.

	(init_aux_cache, search_aux_cache, add_to_aux_cache,

	load_aux_cache, save_aux_cache, implicit_soname): New prototypes.

	(process_file): Adjust prototype.

--- libc/elf/ldconfig.c.jj	2007-07-16 09:58:46.000000000 +0200

+++ libc/elf/ldconfig.c	2007-08-01 18:54:26.000000000 +0200

@@ -112,6 +112,9 @@ static char *opt_chroot;

 /* Manually link given shared libraries.  */

 static int opt_manual_link;

+/* Should we ignore an old auxiliary cache file?  */

+static int opt_ignore_aux_cache;

+

 /* Cache file to use.  */

 static char *cache_file;

@@ -142,6 +145,7 @@ static const struct argp_option options[

   { NULL, 'n', NULL, 0, N_("Only process directories specified on the command line.  Don't build cache."), 0},

   { NULL, 'l', NULL, 0, N_("Manually link individual libraries."), 0},

   { "format", 'c', N_("FORMAT"), 0, N_("Format to use: new, old or compat (default)"), 0},

+  { "ignore-aux-cache", 'i', NULL, 0, N_("Ignore auxiliary cache file"), 0},

   { NULL, 0, NULL, 0, NULL, 0 }

 };

@@ -238,10 +242,15 @@ parse_opt (int key, char *arg, struct ar

     {

     case 'C':

       cache_file = arg;

+      /* Ignore auxiliary cache since we use non-standard cache.  */

+      opt_ignore_aux_cache = 1;

       break;

     case 'f':

       config_file = arg;

       break;

+    case 'i':

+      opt_ignore_aux_cache = 1;

+      break;

     case 'l':

       opt_manual_link = 1;

       break;

@@ -518,7 +527,7 @@ manual_link (char *library)

   if (libname)

     {

       /* Successfully split names.  Check if path is just "/" to avoid

-         an empty path.  */

+	 an empty path.  */

       if (libname == path)

 	{

 	  libname = library + 1;

@@ -572,14 +581,17 @@ manual_link (char *library)

       free (path);

       return;

     }

+

   if (process_file (real_library, library, libname, &flag, &osversion,

-		    &soname, 0))

+		    &soname, 0, &stat_buf))

     {

       error (0, 0, _("No link created since soname could not be found for %s"),

 	     library);

       free (path);

       return;

     }

+  if (soname == NULL)

+    soname = implicit_soname (libname, flag);

   create_links (real_path, path, libname, soname);

   free (soname);

   free (path);

@@ -625,23 +637,7 @@ struct dlib_entry

 static void

 search_dir (const struct dir_entry *entry)

 {

-  DIR *dir;

-  struct dirent64 *direntry;

-  char *file_name, *dir_name, *real_file_name, *real_name;

-  int file_name_len, real_file_name_len, len;

-  char *soname;

-  struct dlib_entry *dlibs;

-  struct dlib_entry *dlib_ptr;

-  struct stat64 lstat_buf, stat_buf;

-  int is_link, is_dir;

   uint64_t hwcap = path_hwcap (entry->path);

-  unsigned int osversion;

-

-  file_name_len = PATH_MAX;

-  file_name = alloca (file_name_len);

-

-  dlibs = NULL;

-

   if (opt_verbose)

     {

       if (hwcap != 0)

@@ -650,6 +646,11 @@ search_dir (const struct dir_entry *entr

 	printf ("%s:\n", entry->path);

     }

+  char *dir_name;

+  char *real_file_name;

+  size_t real_file_name_len;

+  size_t file_name_len = PATH_MAX;

+  char *file_name = alloca (file_name_len);

   if (opt_chroot)

     {

       dir_name = chroot_canon (opt_chroot, entry->path);

@@ -663,6 +664,7 @@ search_dir (const struct dir_entry *entr

       real_file_name = file_name;

     }

+  DIR *dir;

   if (dir_name == NULL || (dir = opendir (dir_name)) == NULL)

     {

       if (opt_verbose)

@@ -672,6 +674,8 @@ search_dir (const struct dir_entry *entr

       return;

     }

+  struct dirent64 *direntry;

+  struct dlib_entry *dlibs = NULL;

   while ((direntry = readdir64 (dir)) != NULL)

     {

       int flag;

@@ -695,7 +699,8 @@ search_dir (const struct dir_entry *entr

 #endif

 	      !is_hwcap_platform (direntry->d_name)))

 	continue;

-      len = strlen (direntry->d_name);

+

+      size_t len = strlen (direntry->d_name);

       /* Skip temporary files created by the prelink program.  Files with

 	 names like these are never really DSOs we want to look at.  */

       if (len >= sizeof (".#prelink#") - 1)

@@ -727,7 +732,10 @@ search_dir (const struct dir_entry *entr

 	    }

 	  sprintf (real_file_name, "%s/%s", dir_name, direntry->d_name);

 	}

+

+      struct stat64 lstat_buf;

 #ifdef _DIRENT_HAVE_D_TYPE

+      /* We optimize and try to do the lstat call only if needed.  */

       if (direntry->d_type != DT_UNKNOWN)

 	lstat_buf.st_mode = DTTOIF (direntry->d_type);

       else

@@ -738,9 +746,11 @@ search_dir (const struct dir_entry *entr

 	    continue;

 	  }

-      is_link = S_ISLNK (lstat_buf.st_mode);

+      struct stat64 stat_buf;

+      int is_dir;

+      int is_link = S_ISLNK (lstat_buf.st_mode);

       if (is_link)

-        {

+	{

 	  /* In case of symlink, we check if the symlink refers to

 	     a directory. */

 	  if (__builtin_expect (stat64 (real_file_name, &stat_buf), 0))

@@ -754,6 +764,12 @@ search_dir (const struct dir_entry *entr

 	      continue;

 	    }

 	  is_dir = S_ISDIR (stat_buf.st_mode);

+

+	  /* lstat_buf is later stored, update contents.  */

+	  lstat_buf.st_dev = stat_buf.st_dev;

+	  lstat_buf.st_ino = stat_buf.st_ino;

+	  lstat_buf.st_size = stat_buf.st_size;

+	  lstat_buf.st_ctime = stat_buf.st_ctime;

 	}

       else

 	is_dir = S_ISDIR (lstat_buf.st_mode);

@@ -767,36 +783,28 @@ search_dir (const struct dir_entry *entr

 	  new_entry->path = xstrdup (file_name);

 	  new_entry->flag = entry->flag;

 	  new_entry->next = NULL;

-	  if (is_link)

+#ifdef _DIRENT_HAVE_D_TYPE

+	  /* We have filled in lstat only #ifndef

+	     _DIRENT_HAVE_D_TYPE.  Fill it in if needed.  */

+	  if (!is_link

+	      && direntry->d_type != DT_UNKNOWN

+	      && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))

 	    {

-	      new_entry->ino = stat_buf.st_ino;

-	      new_entry->dev = stat_buf.st_dev;

+	      error (0, errno, _("Cannot lstat %s"), file_name);

+	      free (new_entry->path);

+	      free (new_entry);

+	      continue;

 	    }

-	  else

-	    {

-#ifdef _DIRENT_HAVE_D_TYPE

-	      /* We have filled in lstat only #ifndef

-		 _DIRENT_HAVE_D_TYPE.  Fill it in if needed.  */

-	      if (direntry->d_type != DT_UNKNOWN

-		  && __builtin_expect (lstat64 (real_file_name, &lstat_buf),

-				       0))

-		{

-		  error (0, errno, _("Cannot lstat %s"), file_name);

-		  free (new_entry->path);

-		  free (new_entry);

-		  continue;

-		}

 #endif

-

-	      new_entry->ino = lstat_buf.st_ino;

-	      new_entry->dev = lstat_buf.st_dev;

-	    }

+	  new_entry->ino = lstat_buf.st_ino;

+	  new_entry->dev = lstat_buf.st_dev;

 	  add_single_dir (new_entry, 0);

 	  continue;

 	}

       else if (!S_ISREG (lstat_buf.st_mode) && !is_link)

 	continue;

+      char *real_name;

       if (opt_chroot && is_link)

 	{

 	  real_name = chroot_canon (opt_chroot, file_name);

@@ -810,14 +818,36 @@ search_dir (const struct dir_entry *entr

       else

 	real_name = real_file_name;

-      if (process_file (real_name, file_name, direntry->d_name, &flag,

-			&osversion, &soname, is_link))

+#ifdef _DIRENT_HAVE_D_TYPE

+      /* Call lstat64 if not done yet.  */

+      if (!is_link

+	  && direntry->d_type != DT_UNKNOWN

+	  && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))

 	{

-	  if (real_name != real_file_name)

-	    free (real_name);

+	  error (0, errno, _("Cannot lstat %s"), file_name);

 	  continue;

 	}

+#endif

+

+      /* First search whether the auxiliary cache contains this

+	 library already and it's not changed.  */

+      char *soname;

+      unsigned int osversion;

+      if (!search_aux_cache (&lstat_buf, &flag, &osversion, &soname))

+	{

+	  if (process_file (real_name, file_name, direntry->d_name, &flag,

+			    &osversion, &soname, is_link, &lstat_buf))

+	    {

+	      if (real_name != real_file_name)

+		free (real_name);

+	      continue;

+	    }

+	  else if (opt_build_cache)

+	    add_to_aux_cache (&lstat_buf, flag, osversion, soname);

+	}

+      if (soname == NULL)

+	soname = implicit_soname (direntry->d_name, flag);

       /* A link may just point to itself.  */

       if (is_link)

@@ -834,7 +864,7 @@ search_dir (const struct dir_entry *entr

 		  || strncmp (real_base_name, soname, len) != 0)

 		is_link = 0;

 	    }

-        }

+	}

       if (real_name != real_file_name)

 	free (real_name);

@@ -849,6 +879,7 @@ search_dir (const struct dir_entry *entr

 	  && (entry->flag == FLAG_ELF_LIBC5

 	      || entry->flag == FLAG_ELF_LIBC6))

 	flag = entry->flag;

+

       /* Some sanity checks to print warnings.  */

       if (opt_verbose)

 	{

@@ -864,6 +895,7 @@ search_dir (const struct dir_entry *entr

 	}

       /* Add library to list.  */

+      struct dlib_entry *dlib_ptr;

       for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)

 	{

 	  /* Is soname already in list?  */

@@ -888,12 +920,13 @@ search_dir (const struct dir_entry *entr

 			dlib_ptr->flag = flag;

 		      else

 			error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),

-			       dlib_ptr->name, direntry->d_name, entry->path);

+			       dlib_ptr->name, direntry->d_name,

+			       entry->path);

 		    }

 		  free (dlib_ptr->name);

-		  dlib_ptr->osversion = osversion;

 		  dlib_ptr->name = xstrdup (direntry->d_name);

 		  dlib_ptr->is_link = is_link;

+		  dlib_ptr->osversion = osversion;

 		}

 	      /* Don't add this library, abort loop.  */

 	      /* Also free soname, since it's dynamically allocated.  */

@@ -906,10 +939,10 @@ search_dir (const struct dir_entry *entr

 	{

 	  dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));

 	  dlib_ptr->name = xstrdup (direntry->d_name);

-	  dlib_ptr->flag = flag;

-	  dlib_ptr->osversion = osversion;

 	  dlib_ptr->soname = soname;

+	  dlib_ptr->flag = flag;

 	  dlib_ptr->is_link = is_link;

+	  dlib_ptr->osversion = osversion;

 	  /* Add at head of list.  */

 	  dlib_ptr->next = dlibs;

 	  dlibs = dlib_ptr;

@@ -920,6 +953,7 @@ search_dir (const struct dir_entry *entr

   /* Now dlibs contains a list of all libs - add those to the cache

      and created all symbolic links.  */

+  struct dlib_entry *dlib_ptr;

   for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)

     {

       /* Don't create links to links.  */

@@ -1246,7 +1280,7 @@ main (int argc, char **argv)

   if (opt_chroot)

     {

       /* Canonicalize the directory name of cache_file, not cache_file,

-         because we'll rename a temporary cache file to it.  */

+	 because we'll rename a temporary cache file to it.  */

       char *p = strrchr (cache_file, '/');

       char *canon = chroot_canon (opt_chroot,

 				  p ? (*p = '\0', cache_file) : "/");

@@ -1293,10 +1327,18 @@ main (int argc, char **argv)

 	add_system_dir (LIBDIR);

     }

+  if (! opt_ignore_aux_cache)

+    load_aux_cache (_PATH_LDCONFIG_AUX_CACHE);

+  else

+    init_aux_cache ();

+

   search_dirs ();

   if (opt_build_cache)

-    save_cache (cache_file);

+    {

+      save_cache (cache_file);

+      save_aux_cache (_PATH_LDCONFIG_AUX_CACHE);

+    }

   return 0;

 }

--- libc/elf/readlib.c.jj	2007-07-16 09:58:46.000000000 +0200

+++ libc/elf/readlib.c	2007-08-01 18:54:26.000000000 +0200

@@ -1,4 +1,4 @@

-/* Copyright (C) 1999-2003, 2005 Free Software Foundation, Inc.

+/* Copyright (C) 1999-2003, 2005, 2007 Free Software Foundation, Inc.

    This file is part of the GNU C Library.

    Contributed by Andreas Jaeger <aj@suse.de>, 1999 and

 		  Jakub Jelinek <jakub@redhat.com>, 1999.

@@ -69,7 +69,7 @@ static struct known_names known_libs[] =

 int

 process_file (const char *real_file_name, const char *file_name,

 	      const char *lib, int *flag, unsigned int *osversion,

-	      char **soname, int is_link)

+	      char **soname, int is_link, struct stat64 *stat_buf)

 {

   FILE *file;

   struct stat64 statbuf;

@@ -135,7 +135,7 @@ process_file (const char *real_file_name

       )

     {

       /* Aout files don't have a soname, just return the name

-         including the major number.  */

+	 including the major number.  */

       char *copy, *major, *dot;

       copy = xstrdup (lib);

       major = strstr (copy, ".so.");

@@ -175,8 +175,31 @@ process_file (const char *real_file_name

   munmap (file_contents, statbuf.st_size);

   fclose (file);

+  *stat_buf = statbuf;

   return ret;

 }

+/* Returns made up soname if lib doesn't have explicit DT_SONAME.  */

+

+char *

+implicit_soname (const char *lib, int flag)

+{

+  char *soname = xstrdup (lib);

+

+  if ((flag & FLAG_TYPE_MASK) != FLAG_LIBC4)

+    return soname;

+

+  /* Aout files don't have a soname, just return the name

+     including the major number.  */

+  char *major = strstr (soname, ".so.");

+  if (major)

+    {

+      char *dot = strstr (major + 4, ".");

+      if (dot)

+	*dot = '\0';

+    }

+  return soname;

+}

+

 /* Get architecture specific version of process_elf_file.  */

 #include <readelflib.c>

--- libc/elf/readelflib.c.jj	2007-07-03 12:36:59.000000000 +0200

+++ libc/elf/readelflib.c	2007-08-01 18:54:26.000000000 +0200

@@ -231,11 +231,5 @@ process_elf_file (const char *file_name,

 	}

     }

-  /* We reach this point only if the file doesn't contain a DT_SONAME

-     or if we can't classify the library.  If it doesn't have a

-     soname, return the name of the library.  */

-  if (*soname == NULL)

-    *soname = xstrdup (lib);

-

   return 0;

 }

--- libc/elf/cache.c.jj	2007-07-16 09:58:46.000000000 +0200

+++ libc/elf/cache.c	2007-08-01 19:00:30.000000000 +0200

@@ -1,4 +1,4 @@

-/* Copyright (C) 1999-2003,2005,2006 Free Software Foundation, Inc.

+/* Copyright (C) 1999-2003,2005,2006,2007 Free Software Foundation, Inc.

    This file is part of the GNU C Library.

    Contributed by Andreas Jaeger <aj@suse.de>, 1999.

@@ -20,6 +20,7 @@

 #include <error.h>

 #include <dirent.h>

 #include <inttypes.h>

+#include <libgen.h>

 #include <libintl.h>

 #include <stdio.h>

 #include <stdlib.h>

@@ -80,16 +81,16 @@ print_entry (const char *lib, int flag, 

       fputs (",x86-64", stdout);

       break;

     case FLAG_S390_LIB64:

-      fputs(",64bit", stdout);

+      fputs (",64bit", stdout);

       break;

     case FLAG_POWERPC_LIB64:

-      fputs(",64bit", stdout);

+      fputs (",64bit", stdout);

       break;

     case FLAG_MIPS64_LIBN32:

-      fputs(",N32", stdout);

+      fputs (",N32", stdout);

       break;

     case FLAG_MIPS64_LIBN64:

-      fputs(",64bit", stdout);

+      fputs (",64bit", stdout);

     case 0:

       break;

     default:

@@ -128,19 +129,11 @@ print_entry (const char *lib, int flag, 

 void

 print_cache (const char *cache_name)

 {

-  size_t cache_size;

-  struct stat64 st;

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

+  int fd = open (cache_name, O_RDONLY);

   if (fd < 0)

     error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"), cache_name);

+  struct stat64 st;

   if (fstat64 (fd, &st) < 0

       /* No need to map the file if it is empty.  */

       || st.st_size == 0)

@@ -149,14 +142,19 @@ print_cache (const char *cache_name)

       return;

     }

-  cache = mmap (0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);

+  struct cache_file *cache

+    = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);

   if (cache == MAP_FAILED)

     error (EXIT_FAILURE, errno, _("mmap of cache file failed.\n"));

-  cache_size = st.st_size;

+  size_t cache_size = st.st_size;

   if (cache_size < sizeof (struct cache_file))

     error (EXIT_FAILURE, 0, _("File is not a cache file.\n"));

+  struct cache_file_new *cache_new = NULL;

+  const char *cache_data;

+  int format = 0;

+

   if (memcmp (cache->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1))

     {

       /* This can only be the new format without the old one.  */

@@ -201,7 +199,7 @@ print_cache (const char *cache_name)

       printf (_("%d libs found in cache `%s'\n"), cache->nlibs, cache_name);

       /* Print everything.  */

-      for (i = 0; i < cache->nlibs; i++)

+      for (unsigned int i = 0; i < cache->nlibs; i++)

 	print_entry (cache_data + cache->libs[i].key,

 		     cache->libs[i].flags, 0, 0,

 		     cache_data + cache->libs[i].value);

@@ -212,7 +210,7 @@ print_cache (const char *cache_name)

 	      cache_new->nlibs, cache_name);

       /* Print everything.  */

-      for (i = 0; i < cache_new->nlibs; i++)

+      for (unsigned int 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].osversion,

@@ -231,15 +229,11 @@ init_cache (void)

   entries = NULL;

 }

-

-

-static

-int compare (const struct cache_entry *e1, const struct cache_entry *e2)

+static 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 = _dl_cache_libcmp (e2->lib, e1->lib);

+  int res = _dl_cache_libcmp (e2->lib, e1->lib);

   if (res == 0)

     {

       if (e1->flags < e2->flags)

@@ -267,29 +261,19 @@ int compare (const struct cache_entry *e

 void

 save_cache (const char *cache_name)

 {

-  struct cache_entry *entry;

-  int fd, idx_old, idx_new;

-  size_t total_strlen, len;

-  char *strings, *str, *temp_name;

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

-  /* Pad for alignment of cache_file_new.  */

-  size_t pad;

-

   /* 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;

+  size_t total_strlen = 0;

+  struct cache_entry *entry;

+  /* Number of cache entries.  */

+  int cache_entry_count = 0;

+  /* Number of normal cache entries.  */

+  int cache_entry_old_count = 0;

+

   for (entry = entries; entry != NULL; entry = entry->next)

     {

       /* Account the final NULs.  */

@@ -300,8 +284,8 @@ save_cache (const char *cache_name)

     }

   /* Create the on disk cache structure.  */

-  /* First an array for all strings.  */

-  strings = (char *)xmalloc (total_strlen);

+  struct cache_file *file_entries = NULL;

+  size_t file_entries_size = 0;

   if (opt_format != 2)

     {

@@ -315,25 +299,27 @@ save_cache (const char *cache_name)

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

+      file_entries = xmalloc (file_entries_size);

       /* Fill in the header.  */

-      memset (file_entries, 0, sizeof (struct cache_file));

+      memset (file_entries, '\0', sizeof (struct cache_file));

       memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);

       file_entries->nlibs = cache_entry_old_count;

     }

+  struct cache_file_new *file_entries_new = NULL;

+  size_t file_entries_new_size = 0;

+

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

+      file_entries_new = xmalloc (file_entries_new_size);

       /* Fill in the header.  */

-      memset (file_entries_new, 0, sizeof (struct cache_file_new));

+      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,

@@ -343,17 +329,24 @@ save_cache (const char *cache_name)

       file_entries_new->len_strings = total_strlen;

     }

-  pad = ALIGN_CACHE (file_entries_size) - file_entries_size;

+  /* Pad for alignment of cache_file_new.  */

+  size_t pad = ALIGN_CACHE (file_entries_size) - file_entries_size;

   /* 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.  */

+  unsigned int str_offset;

   if (opt_format != 0)

     str_offset = file_entries_new_size;

   else

     str_offset = 0;

-  str = strings;

+  /* An array for all strings.  */

+  char *strings = xmalloc (total_strlen);

+  char *str = strings;

+  int idx_old;

+  int idx_new;

+

   for (idx_old = 0, idx_new = 0, entry = entries; entry != NULL;

        entry = entry->next, ++idx_new)

     {

@@ -375,21 +368,18 @@ save_cache (const char *cache_name)

 	  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;

+

+      size_t len = strlen (entry->lib) + 1;

+      str = mempcpy (str, entry->lib, len);

+      str_offset += len;

       /* Then the path.  */

       if (opt_format != 2 && entry->hwcap == 0)

 	file_entries->libs[idx_old].value = str_offset + pad;

       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;

+      len = strlen (entry->path) + 1;

+      str = mempcpy (str, entry->path, len);

+      str_offset += len;

       /* Ignore entries with hwcap for old format.  */

       if (entry->hwcap == 0)

 	++idx_old;

@@ -403,16 +393,12 @@ save_cache (const char *cache_name)

   /* Write out the cache.  */

   /* Write cache first to a temporary file and rename it later.  */

-  temp_name = xmalloc (strlen (cache_name) + 2);

+  char *temp_name = xmalloc (strlen (cache_name) + 2);

   sprintf (temp_name, "%s~", cache_name);

-  /* First remove an old copy if it exists.  */

-  if (unlink (temp_name) && errno != ENOENT)

-    error (EXIT_FAILURE, errno, _("Can't remove old temporary cache file %s"),

-	   temp_name);