Remove bits/string.h.

These machine-dependent inline string functions have never been on by
default, and even if they were a good idea at the time they were
introduced, they haven't really been touched in ten to fifteen years
and probably aren't a good idea on current-gen processors.  Current
thinking is that this class of optimization is best left to the
compiler.

	* bits/string.h, string/bits/string.h
	* sysdeps/aarch64/bits/string.h
	* sysdeps/m68k/m680x0/m68020/bits/string.h
	* sysdeps/s390/bits/string.h, sysdeps/sparc/bits/string.h
	* sysdeps/x86/bits/string.h: Delete file.

	* string/string.h: Don't include bits/string.h.
	* string/bits/string3.h: Rename to bits/string_fortified.h.
	No need to undef various symbols that the removed headers
	might have defined as macros.
	* string/Makefile (headers): Remove bits/string.h, change
	bits/string3.h to bits/string_fortified.h.
	* string/string-inlines.c: Update commentary.  Remove definitions
	of various macros that nothing looks at anymore.  Don't directly
	include bits/string.h. Set _STRING_INLINE_unaligned here, based on
	compiler-predefined macros.
	* string/strncat.c: If STRNCAT is not defined, or STRNCAT_PRIMARY
	_is_ defined, provide internal hidden alias __strncat.
	* include/string.h: Declare internal hidden alias __strncat.
	Only forward __stpcpy to __builtin_stpcpy if __NO_STRING_INLINES is
	not defined.
	* include/bits/string3.h: Rename to bits/string_fortified.h,
	update to match above.

	* sysdeps/i386/string-inlines.c: Define compat symbols for
	everything formerly defined by sysdeps/x86/bits/string.h.
	Make existing definitions into compat symbols as well.
	Remove some no-longer-necessary messing around with macros.

	* sysdeps/powerpc/powerpc32/power4/multiarch/mempcpy.c
	* sysdeps/powerpc/powerpc64/multiarch/mempcpy.c
	* sysdeps/powerpc/powerpc64/multiarch/stpcpy.c
	* sysdeps/s390/multiarch/mempcpy.c
	No need to define _HAVE_STRING_ARCH_mempcpy.
	Do define __NO_STRING_INLINES and NO_MEMPCPY_STPCPY_REDIRECT.

	* sysdeps/i386/i686/multiarch/strncat-c.c
	* sysdeps/s390/multiarch/strncat-c.c
	* sysdeps/x86_64/multiarch/strncat-c.c
	Define STRNCAT_PRIMARY.  Don't change definition of libc_hidden_def.

23 files changed, 264 insertions, 2452 deletions

diff --git a/ChangeLog b/ChangeLog
index 10e921b056..cae2982dbe 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,46 @@
+2017-06-20  Zack Weinberg  <zackw@panix.com>
+
+	* bits/string.h, string/bits/string.h
+	* sysdeps/aarch64/bits/string.h
+	* sysdeps/m68k/m680x0/m68020/bits/string.h
+	* sysdeps/s390/bits/string.h, sysdeps/sparc/bits/string.h
+	* sysdeps/x86/bits/string.h: Delete file.
+
+	* string/string.h: Don't include bits/string.h.
+	* string/bits/string3.h: Rename to bits/string_fortified.h.
+	No need to undef various symbols that the removed headers
+	might have defined as macros.
+	* string/Makefile (headers): Remove bits/string.h, change
+	bits/string3.h to bits/string_fortified.h.
+	* string/string-inlines.c: Update commentary.  Remove definitions
+	of various macros that nothing looks at anymore.  Don't directly
+	include bits/string.h. Set _STRING_INLINE_unaligned here, based on
+	compiler-predefined macros.
+	* string/strncat.c: If STRNCAT is not defined, or STRNCAT_PRIMARY
+	_is_ defined, provide internal hidden alias __strncat.
+	* include/string.h: Declare internal hidden alias __strncat.
+	Only forward __stpcpy to __builtin_stpcpy if __NO_STRING_INLINES is
+	not defined.
+	* include/bits/string3.h: Rename to bits/string_fortified.h,
+	update to match above.
+
+	* sysdeps/i386/string-inlines.c: Define compat symbols for
+	everything formerly defined by sysdeps/x86/bits/string.h.
+	Make existing definitions into compat symbols as well.
+	Remove some no-longer-necessary messing around with macros.
+
+	* sysdeps/powerpc/powerpc32/power4/multiarch/mempcpy.c
+	* sysdeps/powerpc/powerpc64/multiarch/mempcpy.c
+	* sysdeps/powerpc/powerpc64/multiarch/stpcpy.c
+	* sysdeps/s390/multiarch/mempcpy.c
+	No need to define _HAVE_STRING_ARCH_mempcpy.
+	Do define __NO_STRING_INLINES and NO_MEMPCPY_STPCPY_REDIRECT.
+
+	* sysdeps/i386/i686/multiarch/strncat-c.c
+	* sysdeps/s390/multiarch/strncat-c.c
+	* sysdeps/x86_64/multiarch/strncat-c.c
+	Define STRNCAT_PRIMARY.  Don't change definition of libc_hidden_def.
+
 2017-06-20  Rical Jasan  <ricaljasan@pacific.net>
 
 	* manual/lang.texi (LDBL_MANT_DIG): Add annotation.
diff --git a/bits/string.h b/bits/string.h
deleted file mode 100644
index 89c627c182..0000000000
--- a/bits/string.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/* This file should provide inline versions of string functions.
-
-   Surround GCC-specific parts with #ifdef __GNUC__, and use `__extern_inline'.
-
-   This file should define __STRING_INLINES if functions are actually defined
-   as inlines.  */
-
-#ifndef _BITS_STRING_H
-#define _BITS_STRING_H	1
-
-/* Define whether to use the unaligned string inline ABI.
-   The string inline functions are an external ABI, thus cannot be changed
-   after the first release of a new target (unlike _STRING_ARCH_unaligned
-   which may be changed from release to release).  Targets must support
-   unaligned accesses in hardware if either define is set to true.  */
-#define _STRING_INLINE_unaligned   0
-
-#endif /* bits/string.h */
diff --git a/include/bits/string3.h b/include/bits/string3.h
deleted file mode 100644
index 1ddd981a90..0000000000
--- a/include/bits/string3.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <string/bits/string3.h>
diff --git a/include/bits/string_fortified.h b/include/bits/string_fortified.h
new file mode 100644
index 0000000000..88bf073c9c
--- /dev/null
+++ b/include/bits/string_fortified.h
@@ -0,0 +1 @@
+#include <string/bits/string_fortified.h>
diff --git a/include/string.h b/include/string.h
index 2bf29445df..069efd0b87 100644
--- a/include/string.h
+++ b/include/string.h
@@ -76,12 +76,20 @@ extern __typeof (strncasecmp_l) __strncasecmp_l;
 #endif
 
 libc_hidden_proto (__mempcpy)
+#ifndef __NO_STRING_INLINES
+# define __mempcpy(dest, src, n) __builtin_mempcpy (dest, src, n)
+#endif
 libc_hidden_proto (__stpcpy)
+#ifndef __NO_STRING_INLINES
+# define __stpcpy(dest, src) __builtin_stpcpy (dest, src)
+#endif
 libc_hidden_proto (__stpncpy)
 libc_hidden_proto (__rawmemchr)
 libc_hidden_proto (__strcasecmp)
 libc_hidden_proto (__strcasecmp_l)
 libc_hidden_proto (__strncasecmp_l)
+extern __typeof (strncat) __strncat;
+libc_hidden_proto (__strncat)
 libc_hidden_proto (__strdup)
 libc_hidden_proto (__strndup)
 libc_hidden_proto (__strerror_r)
@@ -162,11 +170,6 @@ extern __typeof (mempcpy) mempcpy __asm__ ("__mempcpy");
 extern __typeof (stpcpy) stpcpy __asm__ ("__stpcpy");
 #endif
 
-/* Redirect internal calls to builtins.  */
-#ifndef __stpcpy
-# define __stpcpy(dest, src) __builtin_stpcpy (dest, src)
-#endif
-
 extern void *__memcpy_chk (void *__restrict __dest,
 			   const void *__restrict __src, size_t __len,
 			   size_t __destlen) __THROW;
diff --git a/string/Makefile b/string/Makefile
index 8d0d6b0873..d7e90a38a5 100644
--- a/string/Makefile
+++ b/string/Makefile
@@ -22,10 +22,11 @@ subdir	:= string
 
 include ../Makeconfig
 
-headers	:= string.h strings.h memory.h endian.h bits/endian.h \
-	   argz.h envz.h byteswap.h bits/byteswap.h bits/byteswap-16.h \
-	   bits/string.h bits/string3.h bits/strings_fortified.h \
-	   bits/uintn-identity.h
+headers		:= string.h bits/string_fortified.h			\
+		   strings.h bits/strings_fortified.h			\
+		   byteswap.h bits/byteswap.h bits/byteswap-16.h	\
+		   endian.h bits/endian.h bits/uintn-identity.h		\
+		   memory.h argz.h envz.h
 
 routines	:= strcat strchr strcmp strcoll strcpy strcspn		\
 		   strverscmp strdup strndup				\
diff --git a/string/bits/string3.h b/string/bits/string_fortified.h
index 738226d49b..a89e757c9d 100644
--- a/string/bits/string3.h
+++ b/string/bits/string_fortified.h
@@ -15,8 +15,11 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#ifndef _BITS_STRING_FORTIFIED_H
+#define _BITS_STRING_FORTIFIED_H 1
+
 #ifndef _STRING_H
-# error "Never use <bits/string3.h> directly; include <string.h> instead."
+# error "Never use <bits/string_fortified.h> directly; include <string.h> instead."
 #endif
 
 #if !__GNUC_PREREQ (5,0)
@@ -24,28 +27,6 @@ __warndecl (__warn_memset_zero_len,
 	    "memset used with constant zero length parameter; this could be due to transposed parameters");
 #endif
 
-#ifndef __cplusplus
-/* XXX This is temporarily.  We should not redefine any of the symbols
-   and instead integrate the error checking into the original
-   definitions.  */
-# undef memcpy
-# undef memmove
-# undef memset
-# undef strcat
-# undef strcpy
-# undef strncat
-# undef strncpy
-# ifdef __USE_GNU
-#  undef mempcpy
-#  undef stpcpy
-# endif
-# ifdef __USE_MISC
-#  undef bcopy
-#  undef bzero
-# endif
-#endif
-
-
 __fortify_function void *
 __NTH (memcpy (void *__restrict __dest, const void *__restrict __src,
 	       size_t __len))
@@ -154,3 +135,5 @@ __NTH (strncat (char *__restrict __dest, const char *__restrict __src,
 {
   return __builtin___strncat_chk (__dest, __src, __len, __bos (__dest));
 }
+
+#endif /* bits/string_fortified.h */
diff --git a/string/string-inlines.c b/string/string-inlines.c
index 9f145366b6..d5243e1161 100644
--- a/string/string-inlines.c
+++ b/string/string-inlines.c
@@ -15,28 +15,17 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
-/*  <bits/string.h> may declare some extern inline functions.
-    These functions are defined here if inlining is not possible.  */
-
-#undef __USE_STRING_INLINES
-#define __USE_STRING_INLINES
-#define _FORCE_INLINES
-#define __STRING_INLINE /* empty */
-#define __NO_INLINE__
+/* This file contains compatibility definitions of functions that were
+   formerly defined as "extern inline" in string.h; it's conceivable
+   that old binaries contain references to them.  */
 
+#define __NO_STRING_INLINES
 #include <string.h>
-#undef index
-#undef rindex
-#undef __stpcpy
 
-#undef __NO_INLINE__
-#include <bits/string.h>
 #include "shlib-compat.h"
 
 #if SHLIB_COMPAT (libc, GLIBC_2_1_1, GLIBC_2_25)
-/* The inline functions are not used from GLIBC 2.25 and forward, however
-   they are required to provide the symbols through string-inlines.c
-   (if inlining is not possible for compatibility reasons).  */
+/* These functions were removed from string.h in glibc 2.25.  */
 
 char *
 __old_strtok_r_1c (char *__s, char __sep, char **__nextp)
@@ -128,9 +117,8 @@ compat_symbol (libc, __old_strsep_3c, __strsep_3c, GLIBC_2_1_1);
 #endif
 
 #if SHLIB_COMPAT (libc, GLIBC_2_1_1, GLIBC_2_24)
-/* The inline functions are not used from GLIBC 2.24 and forward, however
-   they are required to provide the symbols through string-inlines.c
-   (if inlining is not possible for compatibility reasons).  */
+/* These functions were removed from string.h in glibc 2.24.  */
+
 size_t
 __old_strcspn_c1 (const char *__s, int __reject)
 {
@@ -220,9 +208,13 @@ __old_strpbrk_c3 (const char *__s, int __accept1, int __accept2, int __accept3)
 }
 compat_symbol (libc, __old_strpbrk_c3, __strpbrk_c3, GLIBC_2_1_1);
 
+# if defined __mc68020__ || defined __s390__ || defined __i386__
+#  define _STRING_INLINE_unaligned 1
+# else
+#  define _STRING_INLINE_unaligned 0
 /* These are a few types we need for the optimizations if we cannot
    use unaligned memory accesses.  */
-# define __STRING2_COPY_TYPE(N) \
+#  define __STRING2_COPY_TYPE(N) \
   typedef struct { unsigned char __arr[N]; }				      \
     __attribute__ ((__packed__)) __STRING2_COPY_ARR##N
 __STRING2_COPY_TYPE (2);
@@ -232,8 +224,8 @@ __STRING2_COPY_TYPE (5);
 __STRING2_COPY_TYPE (6);
 __STRING2_COPY_TYPE (7);
 __STRING2_COPY_TYPE (8);
-# undef __STRING2_COPY_TYPE
-
+#  undef __STRING2_COPY_TYPE
+# endif
 
 # if _STRING_INLINE_unaligned
 void *
diff --git a/string/string.h b/string/string.h
index d1a274628f..3b68579c2e 100644
--- a/string/string.h
+++ b/string/string.h
@@ -487,30 +487,10 @@ extern char *basename (const char *__filename) __THROW __nonnull ((1));
 # endif
 #endif
 
-
 #if __GNUC_PREREQ (3,4)
-# if defined __OPTIMIZE__ && !defined __OPTIMIZE_SIZE__ \
-     && !defined __NO_INLINE__ && !defined __cplusplus
-/* When using GNU CC we provide some optimized versions of selected
-   functions from this header.  There are two kinds of optimizations:
-
-   - machine-dependent optimizations, most probably using inline
-     assembler code; these might be quite expensive since the code
-     size can increase significantly.
-     These optimizations are not used unless the symbol
-	__USE_STRING_INLINES
-     is defined before including this header.
-
-   One can inhibit all optimizations by defining __NO_STRING_INLINES.  */
-
-/* Get the machine-dependent optimizations (if any).  */
-#  include <bits/string.h>
-
-# endif
-
 # if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function
 /* Functions with security checks.  */
-#  include <bits/string3.h>
+#  include <bits/string_fortified.h>
 # endif
 #endif
 
diff --git a/string/strncat.c b/string/strncat.c
index 71a13eec0b..1904811709 100644
--- a/string/strncat.c
+++ b/string/strncat.c
@@ -20,6 +20,7 @@
 #ifndef STRNCAT
 # undef strncat
 # define STRNCAT  strncat
+# define STRNCAT_PRIMARY
 #endif
 
 char *
@@ -37,3 +38,7 @@ STRNCAT (char *s1, const char *s2, size_t n)
 
   return s;
 }
+#ifdef STRNCAT_PRIMARY
+strong_alias (STRNCAT, __strncat)
+libc_hidden_def (__strncat)
+#endif
diff --git a/sysdeps/aarch64/bits/string.h b/sysdeps/aarch64/bits/string.h
deleted file mode 100644
index 295eeb7be9..0000000000
--- a/sysdeps/aarch64/bits/string.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/* Optimized, inlined string functions.  AArch64 version.
-   Copyright (C) 2015-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, see
-   <http://www.gnu.org/licenses/>.  */
-
-#ifndef _STRING_H
-# error "Never use <bits/string.h> directly; include <string.h> instead."
-#endif
-
-/* AArch64 uses the aligned string inline ABI.  */
-#define _STRING_INLINE_unaligned 0
diff --git a/sysdeps/i386/i686/multiarch/strncat-c.c b/sysdeps/i386/i686/multiarch/strncat-c.c
index 132a000545..aa58a61846 100644
--- a/sysdeps/i386/i686/multiarch/strncat-c.c
+++ b/sysdeps/i386/i686/multiarch/strncat-c.c
@@ -1,8 +1,3 @@
 #define STRNCAT __strncat_ia32
-#ifdef SHARED
-#undef libc_hidden_def
-#define libc_hidden_def(name) \
-  __hidden_ver1 (__strncat_ia32, __GI___strncat, __strncat_ia32);
-#endif
-
+#define STRNCAT_PRIMARY
 #include "string/strncat.c"
diff --git a/sysdeps/i386/string-inlines.c b/sysdeps/i386/string-inlines.c
index d023bc3aa3..1a3cc84f2a 100644
--- a/sysdeps/i386/string-inlines.c
+++ b/sysdeps/i386/string-inlines.c
@@ -15,33 +15,194 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
-/* This is to avoid PLT entries for the x86 version.  */
-#define __memcpy_g __memcpy_g_internal
-#define __strchr_g __strchr_g_internal
 #include <string/string-inlines.c>
 
+#if SHLIB_COMPAT (libc, GLIBC_2_1_1, GLIBC_2_26)
+/* Additional compatibility shims for the former
+   sysdeps/x86/bits/string.h.  */
 void *
-(__memcpy_c) (void *d, const void *s, size_t n)
+__old_memcpy_c (void *d, const void *s, size_t n)
 {
   return memcpy (d, s, n);
 }
+strong_alias (__old_memcpy_c, __old_memcpy_g);
+strong_alias (__old_memcpy_c, __old_memcpy_by4);
+strong_alias (__old_memcpy_c, __old_memcpy_by2);
+compat_symbol (libc, __old_memcpy_c, __memcpy_c, GLIBC_2_1_1);
+compat_symbol (libc, __old_memcpy_g, __memcpy_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_memcpy_by4, __memcpy_by4, GLIBC_2_1_1);
+compat_symbol (libc, __old_memcpy_by2, __memcpy_by2, GLIBC_2_1_1);
 
 void *
-__memset_cc (void *s, unsigned long int pattern, size_t n)
+__old_memset_cc (void *s, unsigned long int pattern, size_t n)
 {
   return memset (s, pattern & 0xff, n);
 }
-strong_alias (__memset_cc, __memset_cg)
+strong_alias (__old_memset_cc, __old_memset_cg);
+strong_alias (__old_memset_cc, __old_memset_ccn_by2);
+strong_alias (__old_memset_cc, __old_memset_ccn_by4);
+compat_symbol (libc, __old_memset_cc, __memset_cc, GLIBC_2_1_1);
+compat_symbol (libc, __old_memset_cg, __memset_cg, GLIBC_2_1_1);
+compat_symbol (libc, __old_memset_ccn_by4, __memset_ccn_by4, GLIBC_2_1_1);
+compat_symbol (libc, __old_memset_ccn_by2, __memset_ccn_by2, GLIBC_2_1_1);
 
 void *
-__memset_gg (void *s, char c, size_t n)
+__old_memset_gg (void *s, char c, size_t n)
 {
   return memset (s, c, n);
 }
+strong_alias (__old_memset_gg, __old_memset_gcn_by4);
+strong_alias (__old_memset_gg, __old_memset_gcn_by2);
+compat_symbol (libc, __old_memset_gg, __memset_gg, GLIBC_2_1_1);
+compat_symbol (libc, __old_memset_gcn_by4, __memset_gcn_by4, GLIBC_2_1_1);
+compat_symbol (libc, __old_memset_gcn_by2, __memset_gcn_by2, GLIBC_2_1_1);
+
+size_t
+__old_strlen_g (const char *str)
+{
+  return strlen (str);
+}
+compat_symbol (libc, __old_strlen_g, __strlen_g, GLIBC_2_1_1);
+
+char *
+__old_strcpy_g (char *dest, const char *src)
+{
+  return strcpy (dest, src);
+}
+compat_symbol (libc, __old_strcpy_g, __strcpy_g, GLIBC_2_1_1);
+
+void *
+__old_mempcpy_byn (void *dest, const void *src, size_t len)
+{
+  return __mempcpy (dest, src, len);
+}
+strong_alias (__old_mempcpy_byn, __old_mempcpy_by4);
+strong_alias (__old_mempcpy_byn, __old_mempcpy_by2);
+compat_symbol (libc, __old_mempcpy_byn, __mempcpy_byn, GLIBC_2_1_1);
+compat_symbol (libc, __old_mempcpy_by4, __mempcpy_by4, GLIBC_2_1_1);
+compat_symbol (libc, __old_mempcpy_by2, __mempcpy_by2, GLIBC_2_1_1);
+
+char *
+__old_stpcpy_g (char *dest, const char *src)
+{
+  return __stpcpy (dest, src);
+}
+compat_symbol (libc, __old_stpcpy_g, __stpcpy_g, GLIBC_2_1_1);
+
+char *
+__old_strncpy_byn (char *dest, const char *src, size_t srclen, size_t n)
+{
+  return strncpy (dest, src, n);
+}
+strong_alias (__old_strncpy_byn, __old_strncpy_by4);
+strong_alias (__old_strncpy_byn, __old_strncpy_by2);
+compat_symbol (libc, __old_strncpy_byn, __strncpy_byn, GLIBC_2_1_1);
+compat_symbol (libc, __old_strncpy_by4, __strncpy_by4, GLIBC_2_1_1);
+compat_symbol (libc, __old_strncpy_by2, __strncpy_by2, GLIBC_2_1_1);
+
+char *
+__old_strncpy_gg (char *dest, const char *src, size_t n)
+{
+  return strncpy (dest, src, n);
+}
+compat_symbol (libc, __old_strncpy_gg, __strncpy_gg, GLIBC_2_1_1);
+
+/* __strcat_c took a third argument, which we ignore.  */
+char *
+__old_strcat_g (char *dest, const char *src)
+{
+  return strcat (dest, src);
+}
+strong_alias (__old_strcat_g, __old_strcat_c);
+compat_symbol (libc, __old_strcat_g, __strcat_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_strcat_c, __strcat_c, GLIBC_2_1_1);
+
+char *
+__old_strncat_g (char *dest, const char *src, size_t n)
+{
+  return __strncat (dest, src, n);
+}
+compat_symbol (libc, __old_strncat_g, __strncat_g, GLIBC_2_1_1);
+
+int
+__old_strcmp_gg (const char *s1, const char *s2)
+{
+  return strcmp (s1, s2);
+}
+compat_symbol (libc, __old_strcmp_gg, __strcmp_gg, GLIBC_2_1_1);
+
+int
+__old_strncmp_g (const char *s1, const char *s2, size_t n)
+{
+  return strncmp (s1, s2, n);
+}
+compat_symbol (libc, __old_strncmp_g, __strncmp_g, GLIBC_2_1_1);
+
+char *
+__old_strchr_g (const char *s, int c)
+{
+  return strchr (s, c);
+}
+strong_alias (__old_strchr_g, __old_strchr_c);
+compat_symbol (libc, __old_strchr_g, __strchr_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_strchr_c, __strchr_c, GLIBC_2_1_1);
+
+char *
+__old_strchrnul_g (const char *s, int c)
+{
+  return __strchrnul (s, c);
+}
+strong_alias (__old_strchrnul_g, __old_strchrnul_c);
+compat_symbol (libc, __old_strchrnul_g, __strchrnul_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_strchrnul_c, __strchrnul_c, GLIBC_2_1_1);
+
+char *
+__old_strrchr_g (const char *s, int c)
+{
+  return strrchr (s, c);
+}
+strong_alias (__old_strrchr_g, __old_strrchr_c);
+compat_symbol (libc, __old_strrchr_g, __strrchr_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_strrchr_c, __strrchr_c, GLIBC_2_1_1);
+
+/* __strcspn_cg took a third argument, which we ignore.  */
+size_t
+__old_strcspn_g (const char *s, const char *reject)
+{
+  return strcspn (s, reject);
+}
+strong_alias (__old_strcspn_g, __old_strcspn_cg);
+compat_symbol (libc, __old_strcspn_g, __strcspn_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_strcspn_cg, __strcspn_cg, GLIBC_2_1_1);
+
+/* __strspn_cg took a third argument, which we ignore.  */
+size_t
+__old_strspn_g (const char *s, const char *accept)
+{
+  return strspn (s, accept);
+}
+strong_alias (__old_strspn_g, __old_strspn_cg);
+compat_symbol (libc, __old_strspn_g, __strspn_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_strspn_cg, __strspn_cg, GLIBC_2_1_1);
+
+/* __strpbrk_cg took a third argument, which we ignore.  */
+const char *
+__old_strpbrk_g (const char *s, const char *accept)
+{
+  return strpbrk (s, accept);
+}
+strong_alias (__old_strpbrk_g, __old_strpbrk_cg);
+compat_symbol (libc, __old_strpbrk_g, __strpbrk_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_strpbrk_cg, __strpbrk_cg, GLIBC_2_1_1);
+
+/* __strstr_cg took a third argument, which we ignore.  */
+const char *
+__old_strstr_g (const char *s, const char *accept)
+{
+  return strstr (s, accept);
+}
+strong_alias (__old_strstr_g, __old_strstr_cg);
+compat_symbol (libc, __old_strstr_g, __strstr_g, GLIBC_2_1_1);
+compat_symbol (libc, __old_strstr_cg, __strstr_cg, GLIBC_2_1_1);
 
-#ifdef __memcpy_c
-# undef __memcpy_g
-strong_alias (__memcpy_g_internal, __memcpy_g)
-# undef __strchr_g
-strong_alias (__strchr_g_internal, __strchr_g)
 #endif
diff --git a/sysdeps/m68k/m680x0/m68020/bits/string.h b/sysdeps/m68k/m680x0/m68020/bits/string.h
deleted file mode 100644
index 120afc0d79..0000000000
--- a/sysdeps/m68k/m680x0/m68020/bits/string.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/* Optimized, inlined string functions.  m680x0 version, x >= 2.
-   Copyright (C) 1997-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library.  If not, see
-   <http://www.gnu.org/licenses/>.  */
-
-#ifndef _STRING_H
-# error "Never use <bits/string.h> directly; include <string.h> instead."
-#endif
-
-/* Use the unaligned string inline ABI.  */
-#define _STRING_INLINE_unaligned 1
diff --git a/sysdeps/powerpc/powerpc32/power4/multiarch/mempcpy.c b/sysdeps/powerpc/powerpc32/power4/multiarch/mempcpy.c
index 0c7250a4bf..21014b8e3d 100644
--- a/sysdeps/powerpc/powerpc32/power4/multiarch/mempcpy.c
+++ b/sysdeps/powerpc/powerpc32/power4/multiarch/mempcpy.c
@@ -20,8 +20,7 @@
 # define mempcpy __redirect_mempcpy
 # define __mempcpy __redirect___mempcpy
 # define NO_MEMPCPY_STPCPY_REDIRECT
-/* Omit the mempcpy inline definitions because it would redefine mempcpy.  */
-# define _HAVE_STRING_ARCH_mempcpy 1
+# define __NO_STRING_INLINES
 # include <string.h>
 # include <shlib-compat.h>
 # include "init-arch.h"
diff --git a/sysdeps/powerpc/powerpc64/multiarch/mempcpy.c b/sysdeps/powerpc/powerpc64/multiarch/mempcpy.c
index 430557ee0a..92391d3333 100644
--- a/sysdeps/powerpc/powerpc64/multiarch/mempcpy.c
+++ b/sysdeps/powerpc/powerpc64/multiarch/mempcpy.c
@@ -20,8 +20,7 @@
 # define mempcpy __redirect_mempcpy
 # define __mempcpy __redirect___mempcpy
 # define NO_MEMPCPY_STPCPY_REDIRECT
-/* Omit the mempcpy inline definitions because it would redefine mempcpy.  */
-# define _HAVE_STRING_ARCH_mempcpy 1
+# define __NO_STRING_INLINES
 # include <string.h>
 # include <shlib-compat.h>
 # include "init-arch.h"
diff --git a/sysdeps/powerpc/powerpc64/multiarch/stpcpy.c b/sysdeps/powerpc/powerpc64/multiarch/stpcpy.c
index 3e34e3cafe..aa01adba7b 100644
--- a/sysdeps/powerpc/powerpc64/multiarch/stpcpy.c
+++ b/sysdeps/powerpc/powerpc64/multiarch/stpcpy.c
@@ -17,6 +17,7 @@
    <http://www.gnu.org/licenses/>.  */
 
 #if defined SHARED && IS_IN (libc)
+# define __NO_STRING_INLINES
 # define NO_MEMPCPY_STPCPY_REDIRECT
 # include <string.h>
 # include <shlib-compat.h>
diff --git a/sysdeps/s390/bits/string.h b/sysdeps/s390/bits/string.h
deleted file mode 100644
index 1e794f925d..0000000000
--- a/sysdeps/s390/bits/string.h
+++ /dev/null
@@ -1,252 +0,0 @@
-/* Optimized, inlined string functions.  S/390 version.
-   Copyright (C) 2000-2017 Free Software Foundation, Inc.
-   Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
-   This file is part of the GNU C Library.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, see
-   <http://www.gnu.org/licenses/>.  */
-
-#ifndef _STRING_H
-# error "Never use <bits/string.h> directly; include <string.h> instead."
-#endif
-
-/* Use the unaligned string inline ABI.  */
-#define _STRING_INLINE_unaligned 1
-
-/* We only provide optimizations if the user selects them and if
-   GNU CC is used.  */
-#if !defined __NO_STRING_INLINES && defined __USE_STRING_INLINES \
-    && defined __GNUC__ && __GNUC__ >= 2
-
-#ifndef __STRING_INLINE
-# ifndef __extern_inline
-#  define __STRING_INLINE inline
-# else
-#  define __STRING_INLINE __extern_inline
-# endif
-#endif
-
-#define _HAVE_STRING_ARCH_strlen 1
-#ifndef _FORCE_INLINES
-#define strlen(str) __strlen_g ((str))
-
-__STRING_INLINE size_t __strlen_g (const char *) __asm__ ("strlen");
-
-__STRING_INLINE size_t
-__strlen_g (const char *__str)
-{
-    char *__ptr, *__tmp;
-
-    __ptr = (char *) 0;
-    __tmp = (char *) __str;
-    __asm__ __volatile__ ("   la    0,0\n"
-			  "0: srst  %0,%1\n"
-			  "   jo    0b\n"
-			  : "+&a" (__ptr), "+&a" (__tmp) :
-			  : "cc", "memory", "0" );
-    return (size_t) (__ptr - __str);
-}
-#endif
-
-/* Copy SRC to DEST.  */
-#define _HAVE_STRING_ARCH_strcpy 1
-#ifndef _FORCE_INLINES
-#define strcpy(dest, src) __strcpy_g ((dest), (src))
-
-__STRING_INLINE char *__strcpy_g (char *, const char *) __asm__ ("strcpy");
-
-__STRING_INLINE char *
-__strcpy_g (char *__dest, const char *__src)
-{
-    char *tmp = __dest;
-
-    __asm__ __volatile__ ("   la    0,0\n"
-			  "0: mvst  %0,%1\n"
-			  "   jo    0b"
-			  : "+&a" (__dest), "+&a" (__src) :
-			  : "cc", "memory", "0" );
-    return tmp;
-}
-#endif
-
-#define _HAVE_STRING_ARCH_strncpy 1
-#ifndef _FORCE_INLINES
-#define strncpy(dest, src, n) __strncpy_g ((dest), (src), (n))
-
-__STRING_INLINE char *__strncpy_g (char *, const char *, size_t)
-     __asm__ ("strncpy");
-
-__STRING_INLINE char *
-__strncpy_g (char *__dest, const char *__src, size_t __n)
-{
-    char *__ret = __dest;
-    char *__ptr;
-    size_t __diff;
-
-    if (__n > 0) {
-      __diff = (size_t) (__dest - __src);
-      __ptr = (char *) __src;
-      __asm__ __volatile__ ("   j     1f\n"
-			    "0: la    %0,1(%0)\n"
-			    "1: icm   0,1,0(%0)\n"
-			    "   stc   0,0(%2,%0)\n"
-			    "   jz    3f\n"
-#if defined(__s390x__)
-			    "   brctg %1,0b\n"
-#else
-			    "   brct  %1,0b\n"
-#endif
-			    "   j     4f\n"
-			    "2: la    %0,1(%0)\n"
-			    "   stc   0,0(%2,%0)\n"
-#if defined(__s390x__)
-			    "3: brctg %1,2b\n"
-#else
-			    "3: brct  %1,2b\n"
-#endif
-			    "4:"
-			    : "+&a" (__ptr), "+&a" (__n) : "a" (__diff)
-			    : "cc", "memory", "0" );
-    }
-    return __ret;
-}
-#endif
-
-/* Append SRC onto DEST.  */
-#define _HAVE_STRING_ARCH_strcat 1
-#ifndef _FORCE_INLINES
-#define strcat(dest, src) __strcat_g ((dest), (src))
-
-__STRING_INLINE char *__strcat_g (char *, const char *) __asm__ ("strcat");
-
-__STRING_INLINE char *
-__strcat_g (char *__dest, const char *__src)
-{
-    char *__ret = __dest;
-    char *__ptr, *__tmp;
-
-    /* Move __ptr to the end of __dest.  */
-    __ptr = (char *) 0;
-    __tmp = __dest;
-    __asm__ __volatile__ ("   la    0,0\n"
-			  "0: srst  %0,%1\n"
-			  "   jo    0b\n"
-			  : "+&a" (__ptr), "+&a" (__tmp) :
-			  : "cc", "0" );
-
-    /* Now do the copy.  */
-    __asm__ __volatile__ ("   la    0,0\n"
-			  "0: mvst  %0,%1\n"
-			  "   jo    0b"
-			  : "+&a" (__ptr), "+&a" (__src) :
-			  : "cc", "memory", "0" );
-    return __ret;
-}
-#endif
-
-/* Append no more than N characters from SRC onto DEST.  */
-#define _HAVE_STRING_ARCH_strncat 1
-#ifndef _FORCE_INLINES
-#define strncat(dest, src, n) __strncat_g ((dest), (src), (n))
-
-__STRING_INLINE char *__strncat_g (char *, const char *, size_t)
-     __asm__ ("strncat");
-
-__STRING_INLINE char *
-__strncat_g (char *__dest, const char *__src, size_t __n)
-{
-    char *__ret = __dest;
-    char *__ptr, *__tmp;
-    size_t __diff;
-
-    if (__n > 0) {
-      /* Move __ptr to the end of __dest.  */
-      __ptr = (char *) 0;
-      __tmp = __dest;
-      __asm__ __volatile__ ("   la    0,0\n"
-			    "0: srst  %0,%1\n"
-			  "   jo    0b\n"
-			    : "+&a" (__ptr), "+&a" (__tmp) :
-			    : "cc", "memory", "0" );
-
-      __diff = (size_t) (__ptr - __src);
-      __tmp = (char *) __src;
-      __asm__ __volatile__ ("   j     1f\n"
-			    "0: la    %0,1(%0)\n"
-			    "1: icm   0,1,0(%0)\n"
-			    "   stc   0,0(%2,%0)\n"
-			    "   jz    2f\n"
-#if defined(__s390x__)
-			    "   brctg %1,0b\n"
-#else
-			    "   brct  %1,0b\n"
-#endif
-			    "   slr   0,0\n"
-			    "   stc   0,1(%2,%0)\n"
-			    "2:"
-			    : "+&a" (__tmp), "+&a" (__n) : "a" (__diff)
-			    : "cc", "memory", "0" );
-
-    }
-    return __ret;
-}
-#endif
-
-/* Search N bytes of S for C.  */
-#define _HAVE_STRING_ARCH_memchr 1
-#ifndef _FORCE_INLINES
-__STRING_INLINE void *
-memchr (const void *__str, int __c, size_t __n)
-{
-    char *__ptr, *__tmp;
-
-    __tmp = (char *) __str;
-    __ptr = (char *) __tmp + __n;
-    __asm__ __volatile__ ("   lhi   0,0xff\n"
-			  "   nr    0,%2\n"
-			  "0: srst  %0,%1\n"
-			  "   jo    0b\n"
-			  "   brc   13,1f\n"
-			  "   la    %0,0\n"
-			  "1:"
-			  : "+&a" (__ptr), "+&a" (__tmp) : "d" (__c)
-			  : "cc", "memory", "0" );
-    return __ptr;
-}
-#endif
-
-/* Compare S1 and S2.  */
-#define _HAVE_STRING_ARCH_strcmp 1
-#ifndef _FORCE_INLINES
-__STRING_INLINE int
-strcmp (const char *__s1, const char *__s2)
-{
-    char *__p1, *__p2;
-    int __ret;
-
-    __p1 = (char *) __s1;
-    __p2 = (char *) __s2;
-    __asm__ __volatile__ ("   slr   0,0\n"
-			  "0: clst  %1,%2\n"
-			  "   jo    0b\n"
-			  "   ipm   %0\n"
-			  "   srl   %0,28"
-			  : "=d" (__ret), "+&a" (__p1), "+&a" (__p2) :
-			  : "cc", "memory", "0" );
-    __ret = (__ret == 0) ? 0 : (__ret == 1) ? -1 : 1;
-    return __ret;
-}
-#endif
-
-#endif	/* Use string inlines && GNU CC.  */
diff --git a/sysdeps/s390/multiarch/mempcpy.c b/sysdeps/s390/multiarch/mempcpy.c
index bf111a3aea..ba59062956 100644
--- a/sysdeps/s390/multiarch/mempcpy.c
+++ b/sysdeps/s390/multiarch/mempcpy.c
@@ -20,8 +20,8 @@
 #if defined SHARED && IS_IN (libc)
 # define mempcpy __redirect_mempcpy
 # define __mempcpy __redirect___mempcpy
-/* Omit the mempcpy inline definitions because it would redefine mempcpy.  */
-# define _HAVE_STRING_ARCH_mempcpy 1
+# define __NO_STRING_INLINES
+# define NO_MEMPCPY_STPCPY_REDIRECT
 # include <string.h>
 # undef mempcpy
 # undef __mempcpy
diff --git a/sysdeps/s390/multiarch/strncat-c.c b/sysdeps/s390/multiarch/strncat-c.c
index e72d778fb4..d894811e83 100644
--- a/sysdeps/s390/multiarch/strncat-c.c
+++ b/sysdeps/s390/multiarch/strncat-c.c
@@ -18,6 +18,6 @@
 
 #if defined HAVE_S390_VX_ASM_SUPPORT && IS_IN (libc)
 # define STRNCAT  __strncat_c
-
+# define STRNCAT_PRIMARY
 # include <string/strncat.c>
 #endif
diff --git a/sysdeps/sparc/bits/string.h b/sysdeps/sparc/bits/string.h
deleted file mode 100644
index 4fd4e8d1de..0000000000
--- a/sysdeps/sparc/bits/string.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* Optimized, inlined string functions.  SPARC version.
-   Copyright (C) 2000-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, see
-   <http://www.gnu.org/licenses/>.  */
-
-#ifndef _STRING_H
-# error "Never use <bits/string.h> directly; include <string.h> instead."
-#endif
-
-/* sparc uses the aligned string inline ABI.  */
-#define _STRING_INLINE_unaligned 0
-
-/* sparc32 and sparc64 strchr(x, '\0') perform better than
-   __rawmemchr(x, '\0').  */
-#define _HAVE_STRING_ARCH_strchr 1
-
-/* Don't inline mempcpy into memcpy as sparc has an optimized mempcpy.  */
-#define _HAVE_STRING_ARCH_mempcpy 1
diff --git a/sysdeps/x86/bits/string.h b/sysdeps/x86/bits/string.h
deleted file mode 100644
index 94cba8e76f..0000000000
--- a/sysdeps/x86/bits/string.h
+++ /dev/null
@@ -1,1996 +0,0 @@
-/* Optimized, inlined string functions.  i486/x86-64 version.
-   Copyright (C) 2001-2017 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   The GNU C Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, see
-   <http://www.gnu.org/licenses/>.  */
-
-#ifndef _STRING_H
-# error "Never use <bits/string.h> directly; include <string.h> instead."
-#endif
-
-/* Use the unaligned string inline ABI.  */
-#define _STRING_INLINE_unaligned 1
-
-/* Don't inline mempcpy into memcpy as x86 has an optimized mempcpy.  */
-#define _HAVE_STRING_ARCH_mempcpy 1
-
-/* Enable inline functions only for i486 or better when compiling for
-   ia32.  */
-#if !defined __x86_64__ && (defined __i486__ || defined __pentium__	      \
-			    || defined __pentiumpro__ || defined __pentium4__ \
-			    || defined __nocona__ || defined __atom__ 	      \
-			    || defined __core2__ || defined __corei7__	      \
-			    || defined __sandybridge__ || defined __haswell__ \
-			    || defined __bonnell__ || defined __silvermont__  \
-			    || defined __k6__ || defined __geode__	      \
-			    || defined __k8__ || defined __athlon__	      \
-			    || defined __amdfam10__ || defined __bdver1__     \
-			    || defined __bdver2__ || defined __bdver3__	      \
-			    || defined __bdver4__ || defined __btver1__	      \
-			    || defined __btver2__)
-
-/* We only provide optimizations if the user selects them and if
-   GNU CC is used.  */
-# if !defined __NO_STRING_INLINES && defined __USE_STRING_INLINES \
-    && defined __GNUC__ && __GNUC__ >= 2
-
-# ifndef __STRING_INLINE
-#  ifndef __extern_inline
-#   define __STRING_INLINE inline
-#  else
-#   define __STRING_INLINE __extern_inline
-#  endif
-# endif
-
-/* The macros are used in some of the optimized implementations below.  */
-# define __STRING_SMALL_GET16(src, idx) \
-  ((((const unsigned char *) (src))[idx + 1] << 8)			      \
-   | ((const unsigned char *) (src))[idx])
-# define __STRING_SMALL_GET32(src, idx) \
-  (((((const unsigned char *) (src))[idx + 3] << 8			      \
-     | ((const unsigned char *) (src))[idx + 2]) << 8			      \
-    | ((const unsigned char *) (src))[idx + 1]) << 8			      \
-   | ((const unsigned char *) (src))[idx])
-
-
-/* Copy N bytes of SRC to DEST.  */
-# define _HAVE_STRING_ARCH_memcpy 1
-# define memcpy(dest, src, n) \
-  (__extension__ (__builtin_constant_p (n)				      \
-		  ? __memcpy_c ((dest), (src), (n))			      \
-		  : __memcpy_g ((dest), (src), (n))))
-# define __memcpy_c(dest, src, n) \
-  ((n) == 0								      \
-   ? (dest)								      \
-   : (((n) % 4 == 0)							      \
-      ? __memcpy_by4 (dest, src, n)					      \
-      : (((n) % 2 == 0)							      \
-	 ? __memcpy_by2 (dest, src, n)					      \
-	 : __memcpy_g (dest, src, n))))
-
-__STRING_INLINE void *__memcpy_by4 (void *__dest, const void *__src,
-				    size_t __n);
-
-__STRING_INLINE void *
-__memcpy_by4 (void *__dest, const void *__src, size_t __n)
-{
-  register unsigned long int __d0, __d1;
-  register void *__tmp = __dest;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movl	(%2),%0\n\t"
-     "leal	4(%2),%2\n\t"
-     "movl	%0,(%1)\n\t"
-     "leal	4(%1),%1\n\t"
-     "decl	%3\n\t"
-     "jnz	1b"
-     : "=&r" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1)
-     : "1" (__tmp), "2" (__src), "3" (__n / 4)
-     : "memory", "cc");
-  return __dest;
-}
-
-__STRING_INLINE void *__memcpy_by2 (void *__dest, const void *__src,
-				    size_t __n);
-
-__STRING_INLINE void *
-__memcpy_by2 (void *__dest, const void *__src, size_t __n)
-{
-  register unsigned long int __d0, __d1;
-  register void *__tmp = __dest;
-  __asm__ __volatile__
-    ("shrl	$1,%3\n\t"
-     "jz	2f\n"                 /* only a word */
-     "1:\n\t"
-     "movl	(%2),%0\n\t"
-     "leal	4(%2),%2\n\t"
-     "movl	%0,(%1)\n\t"
-     "leal	4(%1),%1\n\t"
-     "decl	%3\n\t"
-     "jnz	1b\n"
-     "2:\n\t"
-     "movw	(%2),%w0\n\t"
-     "movw	%w0,(%1)"
-     : "=&q" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1)
-     : "1" (__tmp), "2" (__src), "3" (__n / 2)
-     : "memory", "cc");
-  return __dest;
-}
-
-__STRING_INLINE void *__memcpy_g (void *__dest, const void *__src, size_t __n);
-
-__STRING_INLINE void *
-__memcpy_g (void *__dest, const void *__src, size_t __n)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register void *__tmp = __dest;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "shrl	$1,%%ecx\n\t"
-     "jnc	1f\n\t"
-     "movsb\n"
-     "1:\n\t"
-     "shrl	$1,%%ecx\n\t"
-     "jnc	2f\n\t"
-     "movsw\n"
-     "2:\n\t"
-     "rep; movsl"
-     : "=&c" (__d0), "=&D" (__d1), "=&S" (__d2),
-       "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest)
-     : "0" (__n), "1" (__tmp), "2" (__src),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__src)
-     : "cc");
-  return __dest;
-}
-
-# define _HAVE_STRING_ARCH_memmove 1
-# ifndef _FORCE_INLINES
-/* Copy N bytes of SRC to DEST, guaranteeing
-   correct behavior for overlapping strings.  */
-#  define memmove(dest, src, n) __memmove_g (dest, src, n)
-
-__STRING_INLINE void *__memmove_g (void *, const void *, size_t)
-     __asm__ ("memmove");
-
-__STRING_INLINE void *
-__memmove_g (void *__dest, const void *__src, size_t __n)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register void *__tmp = __dest;
-  if (__dest < __src)
-    __asm__ __volatile__
-      ("cld\n\t"
-       "rep; movsb"
-       : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2),
-	 "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest)
-       : "0" (__n), "1" (__src), "2" (__tmp),
-	 "m" ( *(struct { __extension__ char __x[__n]; } *)__src));
-  else
-    __asm__ __volatile__
-      ("decl %1\n\t"
-       "decl %2\n\t"
-       "std\n\t"
-       "rep; movsb\n\t"
-       "cld"
-       : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2),
-	 "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest)
-       : "0" (__n), "1" (__n + (const char *) __src),
-	 "2" (__n + (char *) __tmp),
-	 "m" ( *(struct { __extension__ char __x[__n]; } *)__src));
-  return __dest;
-}
-# endif
-
-/* Compare N bytes of S1 and S2.  */
-# define _HAVE_STRING_ARCH_memcmp 1
-# ifndef _FORCE_INLINES
-#  ifndef __PIC__
-/* gcc has problems to spill registers when using PIC.  */
-__STRING_INLINE int
-memcmp (const void *__s1, const void *__s2, size_t __n)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register int __res;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "testl %3,%3\n\t"
-     "repe; cmpsb\n\t"
-     "je	1f\n\t"
-     "sbbl	%0,%0\n\t"
-     "orl	$1,%0\n"
-     "1:"
-     : "=&a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2)
-     : "0" (0), "1" (__s1), "2" (__s2), "3" (__n),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__s1),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__s2)
-     : "cc");
-  return __res;
-}
-#  endif
-# endif
-
-/* Set N bytes of S to C.  */
-# define _HAVE_STRING_ARCH_memset 1
-# define _USE_STRING_ARCH_memset 1
-# define memset(s, c, n) \
-  (__extension__ (__builtin_constant_p (n) && (n) <= 16			      \
-		  ? ((n) == 1						      \
-		     ? __memset_c1 ((s), (c))				      \
-		     : __memset_gc ((s), (c), (n)))			      \
-		  : (__builtin_constant_p (c)				      \
-		     ? (__builtin_constant_p (n)			      \
-			? __memset_ccn ((s), (c), (n))			      \
-			: memset ((s), (c), (n)))			      \
-		     : (__builtin_constant_p (n)			      \
-			? __memset_gcn ((s), (c), (n))			      \
-			: memset ((s), (c), (n))))))
-
-# define __memset_c1(s, c) ({ void *__s = (s);				      \
-			      *((unsigned char *) __s) = (unsigned char) (c); \
-			      __s; })
-
-# define __memset_gc(s, c, n) \
-  ({ void *__s = (s);							      \
-     union {								      \
-       unsigned int __ui;						      \
-       unsigned short int __usi;					      \
-       unsigned char __uc;						      \
-     } *__u = __s;							      \
-     unsigned int __c = ((unsigned int) ((unsigned char) (c))) * 0x01010101;  \
-									      \
-     /* We apply a trick here.  `gcc' would implement the following	      \
-	assignments using immediate operands.  But this uses to much	      \
-	memory (7, instead of 4 bytes).  So we force the value in a	      \
-	registers.  */							      \
-     if ((n) == 3 || (n) >= 5)						      \
-       __asm__ __volatile__ ("" : "=r" (__c) : "0" (__c));		      \
-									      \
-     /* This `switch' statement will be removed at compile-time.  */	      \
-     switch (n)								      \
-       {								      \
-       case 15:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 11:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 7:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 3:								      \
-	 __u->__usi = (unsigned short int) __c;				      \
-	 __u = __extension__ ((void *) __u + 2);			      \
-	 __u->__uc = (unsigned char) __c;				      \
-	 break;								      \
-									      \
-       case 14:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 10:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 6:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 2:								      \
-	 __u->__usi = (unsigned short int) __c;				      \
-	 break;								      \
-									      \
-       case 13:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 9:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 5:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 1:								      \
-	 __u->__uc = (unsigned char) __c;				      \
-	 break;								      \
-									      \
-       case 16:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 12:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 8:								      \
-	 __u->__ui = __c;						      \
-	 __u = __extension__ ((void *) __u + 4);			      \
-       case 4:								      \
-	 __u->__ui = __c;						      \
-       case 0:								      \
-	 break;								      \
-       }								      \
-									      \
-     __s; })
-
-# define __memset_ccn(s, c, n) \
-  (((n) % 4 == 0)							      \
-   ? __memset_ccn_by4 (s, ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
-		       n)						      \
-   : (((n) % 2 == 0)							      \
-      ? __memset_ccn_by2 (s,						      \
-			  ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
-			   n)						      \
-      : memset (s, c, n)))
-
-__STRING_INLINE void *__memset_ccn_by4 (void *__s, unsigned int __c,
-					size_t __n);
-
-__STRING_INLINE void *
-__memset_ccn_by4 (void *__s, unsigned int __c, size_t __n)
-{
-  register void *__tmp = __s;
-  register unsigned long int __d0;
-# ifdef __i686__
-  __asm__ __volatile__
-    ("cld\n\t"
-     "rep; stosl"
-     : "=&a" (__c), "=&D" (__tmp), "=&c" (__d0),
-       "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
-     : "cc");
-# else
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movl	%0,(%1)\n\t"
-     "addl	$4,%1\n\t"
-     "decl	%2\n\t"
-     "jnz	1b\n"
-     : "=&r" (__c), "=&r" (__tmp), "=&r" (__d0),
-       "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
-     : "cc");
-# endif
-  return __s;
-}
-
-__STRING_INLINE void *__memset_ccn_by2 (void *__s, unsigned int __c,
-					size_t __n);
-
-__STRING_INLINE void *
-__memset_ccn_by2 (void *__s, unsigned int __c, size_t __n)
-{
-  register unsigned long int __d0, __d1;
-  register void *__tmp = __s;
-# ifdef __i686__
-  __asm__ __volatile__
-    ("cld\n\t"
-     "rep; stosl\n"
-     "stosw"
-     : "=&a" (__d0), "=&D" (__tmp), "=&c" (__d1),
-       "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
-     : "cc");
-# else
-  __asm__ __volatile__
-    ("1:\tmovl	%0,(%1)\n\t"
-     "leal	4(%1),%1\n\t"
-     "decl	%2\n\t"
-     "jnz	1b\n"
-     "movw	%w0,(%1)"
-     : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1),
-       "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
-     : "cc");
-#endif
-  return __s;
-}
-
-# define __memset_gcn(s, c, n) \
-  (((n) % 4 == 0)							      \
-   ? __memset_gcn_by4 (s, c, n)						      \
-   : (((n) % 2 == 0)							      \
-      ? __memset_gcn_by2 (s, c, n)					      \
-      : memset (s, c, n)))
-
-__STRING_INLINE void *__memset_gcn_by4 (void *__s, int __c, size_t __n);
-
-__STRING_INLINE void *
-__memset_gcn_by4 (void *__s, int __c, size_t __n)
-{
-  register void *__tmp = __s;
-  register unsigned long int __d0;
-  __asm__ __volatile__
-    ("movb	%b0,%h0\n"
-     "pushw	%w0\n\t"
-     "shll	$16,%0\n\t"
-     "popw	%w0\n"
-     "1:\n\t"
-     "movl	%0,(%1)\n\t"
-     "addl	$4,%1\n\t"
-     "decl	%2\n\t"
-     "jnz	1b\n"
-     : "=&q" (__c), "=&r" (__tmp), "=&r" (__d0),
-       "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
-     : "cc");
-  return __s;
-}
-
-__STRING_INLINE void *__memset_gcn_by2 (void *__s, int __c, size_t __n);
-
-__STRING_INLINE void *
-__memset_gcn_by2 (void *__s, int __c, size_t __n)
-{
-  register unsigned long int __d0, __d1;
-  register void *__tmp = __s;
-  __asm__ __volatile__
-    ("movb	%b0,%h0\n\t"
-     "pushw	%w0\n\t"
-     "shll	$16,%0\n\t"
-     "popw	%w0\n"
-     "1:\n\t"
-     "movl	%0,(%1)\n\t"
-     "leal	4(%1),%1\n\t"
-     "decl	%2\n\t"
-     "jnz	1b\n"
-     "movw	%w0,(%1)"
-     : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1),
-       "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
-     : "cc");
-  return __s;
-}
-
-
-/* Search N bytes of S for C.  */
-# define _HAVE_STRING_ARCH_memchr 1
-# ifndef _FORCE_INLINES
-__STRING_INLINE void *
-memchr (const void *__s, int __c, size_t __n)
-{
-  register unsigned long int __d0;
-#  ifdef __i686__
-  register unsigned long int __d1;
-#  endif
-  register unsigned char *__res;
-  if (__n == 0)
-    return NULL;
-#  ifdef __i686__
-  __asm__ __volatile__
-    ("cld\n\t"
-     "repne; scasb\n\t"
-     "cmovne %2,%0"
-     : "=D" (__res), "=&c" (__d0), "=&r" (__d1)
-     : "a" (__c), "0" (__s), "1" (__n), "2" (1),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "cc");
-#  else
-  __asm__ __volatile__
-    ("cld\n\t"
-     "repne; scasb\n\t"
-     "je	1f\n\t"
-     "movl	$1,%0\n"
-     "1:"
-     : "=D" (__res), "=&c" (__d0)
-     : "a" (__c), "0" (__s), "1" (__n),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "cc");
-#  endif
-  return __res - 1;
-}
-# endif
-
-# define _HAVE_STRING_ARCH_memrchr 1
-# ifndef _FORCE_INLINES
-__STRING_INLINE void *__memrchr (const void *__s, int __c, size_t __n);
-
-__STRING_INLINE void *
-__memrchr (const void *__s, int __c, size_t __n)
-{
-  register unsigned long int __d0;
-#  ifdef __i686__
-  register unsigned long int __d1;
-#  endif
-  register void *__res;
-  if (__n == 0)
-    return NULL;
-#  ifdef __i686__
-  __asm__ __volatile__
-    ("std\n\t"
-     "repne; scasb\n\t"
-     "cmovne %2,%0\n\t"
-     "cld\n\t"
-     "incl %0"
-     : "=D" (__res), "=&c" (__d0), "=&r" (__d1)
-     : "a" (__c), "0" (__s + __n - 1), "1" (__n), "2" (-1),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "cc");
-#  else
-  __asm__ __volatile__
-    ("std\n\t"
-     "repne; scasb\n\t"
-     "je 1f\n\t"
-     "orl $-1,%0\n"
-     "1:\tcld\n\t"
-     "incl %0"
-     : "=D" (__res), "=&c" (__d0)
-     : "a" (__c), "0" (__s + __n - 1), "1" (__n),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__s)
-     : "cc");
-#  endif
-  return __res;
-}
-#  ifdef __USE_GNU
-#   define memrchr(s, c, n) __memrchr ((s), (c), (n))
-#  endif
-# endif
-
-/* Return pointer to C in S.  */
-# define _HAVE_STRING_ARCH_rawmemchr 1
-__STRING_INLINE void *__rawmemchr (const void *__s, int __c);
-
-# ifndef _FORCE_INLINES
-__STRING_INLINE void *
-__rawmemchr (const void *__s, int __c)
-{
-  register unsigned long int __d0;
-  register unsigned char *__res;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "repne; scasb\n\t"
-     : "=D" (__res), "=&c" (__d0)
-     : "a" (__c), "0" (__s), "1" (0xffffffff),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res - 1;
-}
-#  ifdef __USE_GNU
-__STRING_INLINE void *
-rawmemchr (const void *__s, int __c)
-{
-  return __rawmemchr (__s, __c);
-}
-#  endif /* use GNU */
-# endif
-
-
-/* Return the length of S.  */
-# define _HAVE_STRING_ARCH_strlen 1
-# define strlen(str) \
-  (__extension__ (__builtin_constant_p (str)				      \
-		  ? __builtin_strlen (str)				      \
-		  : __strlen_g (str)))
-__STRING_INLINE size_t __strlen_g (const char *__str);
-
-__STRING_INLINE size_t
-__strlen_g (const char *__str)
-{
-  register char __dummy;
-  register const char *__tmp = __str;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movb	(%0),%b1\n\t"
-     "leal	1(%0),%0\n\t"
-     "testb	%b1,%b1\n\t"
-     "jne	1b"
-     : "=r" (__tmp), "=&q" (__dummy)
-     : "0" (__str),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__str)
-     : "cc" );
-  return __tmp - __str - 1;
-}
-
-
-/* Copy SRC to DEST.  */
-# define _HAVE_STRING_ARCH_strcpy 1
-# define strcpy(dest, src) \
-  (__extension__ (__builtin_constant_p (src)				      \
-		  ? (sizeof ((src)[0]) == 1 && strlen (src) + 1 <= 8	      \
-		     ? __strcpy_a_small ((dest), (src), strlen (src) + 1)     \
-		     : (char *) memcpy ((char *) (dest),		      \
-					(const char *) (src),		      \
-					strlen (src) + 1))		      \
-		  : __strcpy_g ((dest), (src))))
-
-# define __strcpy_a_small(dest, src, srclen) \
-  (__extension__ ({ char *__dest = (dest);				      \
-		    union {						      \
-		      unsigned int __ui;				      \
-		      unsigned short int __usi;				      \
-		      unsigned char __uc;				      \
-		      char __c;						      \
-		    } *__u = (void *) __dest;				      \
-		    switch (srclen)					      \
-		      {							      \
-		      case 1:						      \
-			__u->__uc = '\0';				      \
-			break;						      \
-		      case 2:						      \
-			__u->__usi = __STRING_SMALL_GET16 (src, 0);	      \
-			break;						      \
-		      case 3:						      \
-			__u->__usi = __STRING_SMALL_GET16 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 2);		      \
-			__u->__uc = '\0';				      \
-			break;						      \
-		      case 4:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			break;						      \
-		      case 5:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 4);		      \
-			__u->__uc = '\0';				      \
-			break;						      \
-		      case 6:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 4);		      \
-			__u->__usi = __STRING_SMALL_GET16 (src, 4);	      \
-			break;						      \
-		      case 7:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 4);		      \
-			__u->__usi = __STRING_SMALL_GET16 (src, 4);	      \
-			__u = __extension__ ((void *) __u + 2);		      \
-			__u->__uc = '\0';				      \
-			break;						      \
-		      case 8:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 4);		      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 4);	      \
-			break;						      \
-		      }							      \
-		    (char *) __dest; }))
-
-__STRING_INLINE char *__strcpy_g (char *__dest, const char *__src);
-
-__STRING_INLINE char *
-__strcpy_g (char *__dest, const char *__src)
-{
-  register char *__tmp = __dest;
-  register char __dummy;
-  __asm__ __volatile__
-    (
-     "1:\n\t"
-     "movb	(%0),%b2\n\t"
-     "leal	1(%0),%0\n\t"
-     "movb	%b2,(%1)\n\t"
-     "leal	1(%1),%1\n\t"
-     "testb	%b2,%b2\n\t"
-     "jne	1b"
-     : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy),
-       "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
-     : "0" (__src), "1" (__tmp),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__src)
-     : "cc");
-  return __dest;
-}
-
-
-# ifdef __USE_GNU
-#  define _HAVE_STRING_ARCH_stpcpy 1
-/* Copy SRC to DEST.  */
-#  define __stpcpy(dest, src) \
-  (__extension__ (__builtin_constant_p (src)				      \
-		  ? (strlen (src) + 1 <= 8				      \
-		     ? __stpcpy_a_small ((dest), (src), strlen (src) + 1)     \
-		     : __stpcpy_c ((dest), (src), strlen (src) + 1))	      \
-		  : __stpcpy_g ((dest), (src))))
-#  define __stpcpy_c(dest, src, srclen) \
-  ((srclen) % 4 == 0							      \
-   ? __mempcpy_by4 (dest, src, srclen) - 1				      \
-   : ((srclen) % 2 == 0							      \
-      ? __mempcpy_by2 (dest, src, srclen) - 1				      \
-      : __mempcpy_byn (dest, src, srclen) - 1))
-
-/* In glibc itself we use this symbol for namespace reasons.  */
-#  define stpcpy(dest, src) __stpcpy ((dest), (src))
-
-#  define __stpcpy_a_small(dest, src, srclen) \
-  (__extension__ ({ union {						      \
-		      unsigned int __ui;				      \
-		      unsigned short int __usi;				      \
-		      unsigned char __uc;				      \
-		      char __c;						      \
-		    } *__u = (void *) (dest);				      \
-		    switch (srclen)					      \
-		      {							      \
-		      case 1:						      \
-			__u->__uc = '\0';				      \
-			break;						      \
-		      case 2:						      \
-			__u->__usi = __STRING_SMALL_GET16 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 1);		      \
-			break;						      \
-		      case 3:						      \
-			__u->__usi = __STRING_SMALL_GET16 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 2);		      \
-			__u->__uc = '\0';				      \
-			break;						      \
-		      case 4:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 3);		      \
-			break;						      \
-		      case 5:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 4);		      \
-			__u->__uc = '\0';				      \
-			break;						      \
-		      case 6:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 4);		      \
-			__u->__usi = __STRING_SMALL_GET16 (src, 4);	      \
-			__u = __extension__ ((void *) __u + 1);		      \
-			break;						      \
-		      case 7:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 4);		      \
-			__u->__usi = __STRING_SMALL_GET16 (src, 4);	      \
-			__u = __extension__ ((void *) __u + 2);		      \
-			__u->__uc = '\0';				      \
-			break;						      \
-		      case 8:						      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 0);	      \
-			__u = __extension__ ((void *) __u + 4);		      \
-			__u->__ui = __STRING_SMALL_GET32 (src, 4);	      \
-			__u = __extension__ ((void *) __u + 3);		      \
-			break;						      \
-		      }							      \
-		    (char *) __u; }))
-
-__STRING_INLINE char *__mempcpy_by4 (char *__dest, const char *__src,
-				     size_t __srclen);
-
-__STRING_INLINE char *
-__mempcpy_by4 (char *__dest, const char *__src, size_t __srclen)
-{
-  register char *__tmp = __dest;
-  register unsigned long int __d0, __d1;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movl	(%2),%0\n\t"
-     "leal	4(%2),%2\n\t"
-     "movl	%0,(%1)\n\t"
-     "leal	4(%1),%1\n\t"
-     "decl	%3\n\t"
-     "jnz	1b"
-     : "=&r" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1)
-     : "1" (__tmp), "2" (__src), "3" (__srclen / 4)
-     : "memory", "cc");
-  return __tmp;
-}
-
-__STRING_INLINE char *__mempcpy_by2 (char *__dest, const char *__src,
-				     size_t __srclen);
-
-__STRING_INLINE char *
-__mempcpy_by2 (char *__dest, const char *__src, size_t __srclen)
-{
-  register char *__tmp = __dest;
-  register unsigned long int __d0, __d1;
-  __asm__ __volatile__
-    ("shrl	$1,%3\n\t"
-     "jz	2f\n"                 /* only a word */
-     "1:\n\t"
-     "movl	(%2),%0\n\t"
-     "leal	4(%2),%2\n\t"
-     "movl	%0,(%1)\n\t"
-     "leal	4(%1),%1\n\t"
-     "decl	%3\n\t"
-     "jnz	1b\n"
-     "2:\n\t"
-     "movw	(%2),%w0\n\t"
-     "movw	%w0,(%1)"
-     : "=&q" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1),
-       "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
-     : "1" (__tmp), "2" (__src), "3" (__srclen / 2),
-       "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
-     : "cc");
-  return __tmp + 2;
-}
-
-__STRING_INLINE char *__mempcpy_byn (char *__dest, const char *__src,
-				     size_t __srclen);
-
-__STRING_INLINE char *
-__mempcpy_byn (char *__dest, const char *__src, size_t __srclen)
-{
-  register unsigned long __d0, __d1;
-  register char *__tmp = __dest;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "shrl	$1,%%ecx\n\t"
-     "jnc	1f\n\t"
-     "movsb\n"
-     "1:\n\t"
-     "shrl	$1,%%ecx\n\t"
-     "jnc	2f\n\t"
-     "movsw\n"
-     "2:\n\t"
-     "rep; movsl"
-     : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1),
-       "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
-     : "0" (__tmp), "1" (__srclen), "2" (__src),
-       "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
-     : "cc");
-  return __tmp;
-}
-
-__STRING_INLINE char *__stpcpy_g (char *__dest, const char *__src);
-
-__STRING_INLINE char *
-__stpcpy_g (char *__dest, const char *__src)
-{
-  register char *__tmp = __dest;
-  register char __dummy;
-  __asm__ __volatile__
-    (
-     "1:\n\t"
-     "movb	(%0),%b2\n\t"
-     "leal	1(%0),%0\n\t"
-     "movb	%b2,(%1)\n\t"
-     "leal	1(%1),%1\n\t"
-     "testb	%b2,%b2\n\t"
-     "jne	1b"
-     : "=&r" (__src), "=r" (__tmp), "=&q" (__dummy),
-       "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
-     : "0" (__src), "1" (__tmp),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__src)
-     : "cc");
-  return __tmp - 1;
-}
-# endif
-
-
-/* Copy no more than N characters of SRC to DEST.  */
-# define _HAVE_STRING_ARCH_strncpy 1
-# define strncpy(dest, src, n) \
-  (__extension__ (__builtin_constant_p (src)				      \
-		  ? ((strlen (src) + 1 >= ((size_t) (n))		      \
-		      ? (char *) memcpy ((char *) (dest),		      \
-					 (const char *) (src), n)	      \
-		      : __strncpy_cg ((dest), (src), strlen (src) + 1, n)))   \
-		  : __strncpy_gg ((dest), (src), n)))
-# define __strncpy_cg(dest, src, srclen, n) \
-  (((srclen) % 4 == 0)							      \
-   ? __strncpy_by4 (dest, src, srclen, n)				      \
-   : (((srclen) % 2 == 0)						      \
-      ? __strncpy_by2 (dest, src, srclen, n)				      \
-      : __strncpy_byn (dest, src, srclen, n)))
-
-__STRING_INLINE char *__strncpy_by4 (char *__dest, const char __src[],
-				     size_t __srclen, size_t __n);
-
-__STRING_INLINE char *
-__strncpy_by4 (char *__dest, const char __src[], size_t __srclen, size_t __n)
-{
-  register char *__tmp = __dest;
-  register int __dummy1, __dummy2;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movl	(%2),%0\n\t"
-     "leal	4(%2),%2\n\t"
-     "movl	%0,(%1)\n\t"
-     "leal	4(%1),%1\n\t"
-     "decl	%3\n\t"
-     "jnz	1b"
-     : "=&r" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2),
-       "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
-     : "1" (__tmp), "2" (__src), "3" (__srclen / 4),
-       "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
-     : "cc");
-  (void) memset (__tmp, '\0', __n - __srclen);
-  return __dest;
-}
-
-__STRING_INLINE char *__strncpy_by2 (char *__dest, const char __src[],
-				     size_t __srclen, size_t __n);
-
-__STRING_INLINE char *
-__strncpy_by2 (char *__dest, const char __src[], size_t __srclen, size_t __n)
-{
-  register char *__tmp = __dest;
-  register int __dummy1, __dummy2;
-  __asm__ __volatile__
-    ("shrl	$1,%3\n\t"
-     "jz	2f\n"                 /* only a word */
-     "1:\n\t"
-     "movl	(%2),%0\n\t"
-     "leal	4(%2),%2\n\t"
-     "movl	%0,(%1)\n\t"
-     "leal	4(%1),%1\n\t"
-     "decl	%3\n\t"
-     "jnz	1b\n"
-     "2:\n\t"
-     "movw	(%2),%w0\n\t"
-     "movw	%w0,(%1)\n\t"
-     : "=&q" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2),
-       "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
-     : "1" (__tmp), "2" (__src), "3" (__srclen / 2),
-       "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
-     : "cc");
-  (void) memset (__tmp + 2, '\0', __n - __srclen);
-  return __dest;
-}
-
-__STRING_INLINE char *__strncpy_byn (char *__dest, const char __src[],
-				     size_t __srclen, size_t __n);
-
-__STRING_INLINE char *
-__strncpy_byn (char *__dest, const char __src[], size_t __srclen, size_t __n)
-{
-  register unsigned long int __d0, __d1;
-  register char *__tmp = __dest;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "shrl	$1,%1\n\t"
-     "jnc	1f\n\t"
-     "movsb\n"
-     "1:\n\t"
-     "shrl	$1,%1\n\t"
-     "jnc	2f\n\t"
-     "movsw\n"
-     "2:\n\t"
-     "rep; movsl"
-     : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1),
-       "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
-     : "1" (__srclen), "0" (__tmp),"2" (__src),
-       "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
-     : "cc");
-  (void) memset (__tmp, '\0', __n - __srclen);
-  return __dest;
-}
-
-__STRING_INLINE char *__strncpy_gg (char *__dest, const char *__src,
-				    size_t __n);
-
-__STRING_INLINE char *
-__strncpy_gg (char *__dest, const char *__src, size_t __n)
-{
-  register char *__tmp = __dest;
-  register char __dummy;
-  if (__n > 0)
-    __asm__ __volatile__
-      ("1:\n\t"
-       "movb	(%0),%2\n\t"
-       "incl	%0\n\t"
-       "movb	%2,(%1)\n\t"
-       "incl	%1\n\t"
-       "decl	%3\n\t"
-       "je	3f\n\t"
-       "testb	%2,%2\n\t"
-       "jne	1b\n\t"
-       "2:\n\t"
-       "movb	%2,(%1)\n\t"
-       "incl	%1\n\t"
-       "decl	%3\n\t"
-       "jne	2b\n\t"
-       "3:"
-       : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy), "=&r" (__n)
-       : "0" (__src), "1" (__tmp), "3" (__n)
-       : "memory", "cc");
-
-  return __dest;
-}
-
-
-/* Append SRC onto DEST.  */
-# define _HAVE_STRING_ARCH_strcat 1
-# define strcat(dest, src) \
-  (__extension__ (__builtin_constant_p (src)				      \
-		  ? __strcat_c ((dest), (src), strlen (src) + 1)	      \
-		  : __strcat_g ((dest), (src))))
-
-__STRING_INLINE char *__strcat_c (char *__dest, const char __src[],
-				  size_t __srclen);
-
-__STRING_INLINE char *
-__strcat_c (char *__dest, const char __src[], size_t __srclen)
-{
-# ifdef __i686__
-  register unsigned long int __d0;
-  register char *__tmp;
-  __asm__ __volatile__
-    ("repne; scasb"
-     : "=D" (__tmp), "=&c" (__d0),
-       "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
-     : "0" (__dest), "1" (0xffffffff), "a" (0),
-       "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
-     : "cc");
-  --__tmp;
-# else
-  register char *__tmp = __dest;
-  __asm__ __volatile__
-    ("decl	%0\n\t"
-     "1:\n\t"
-     "incl	%0\n\t"
-     "cmpb	$0,(%0)\n\t"
-     "jne	1b\n"
-     : "=r" (__tmp),
-       "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
-     : "0" (__tmp),
-       "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
-     : "cc");
-# endif
-  (void) memcpy (__tmp, __src, __srclen);
-  return __dest;
-}
-
-__STRING_INLINE char *__strcat_g (char *__dest, const char *__src);
-
-__STRING_INLINE char *
-__strcat_g (char *__dest, const char *__src)
-{
-  register char *__tmp = __dest;
-  register char __dummy;
-  __asm__ __volatile__
-    ("decl	%1\n\t"
-     "1:\n\t"
-     "incl	%1\n\t"
-     "cmpb	$0,(%1)\n\t"
-     "jne	1b\n"
-     "2:\n\t"
-     "movb	(%2),%b0\n\t"
-     "incl	%2\n\t"
-     "movb	%b0,(%1)\n\t"
-     "incl	%1\n\t"
-     "testb	%b0,%b0\n\t"
-     "jne	2b\n"
-     : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src),
-       "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
-     : "1"  (__tmp), "2"  (__src),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__src)
-     : "memory", "cc");
-  return __dest;
-}
-
-
-/* Append no more than N characters from SRC onto DEST.  */
-# define _HAVE_STRING_ARCH_strncat 1
-# define strncat(dest, src, n) \
-  (__extension__ ({ char *__dest = (dest);				      \
-		    __builtin_constant_p (src) && __builtin_constant_p (n)    \
-		    ? (strlen (src) < ((size_t) (n))			      \
-		       ? strcat (__dest, (src))				      \
-		       : (*(char *)__mempcpy (strchr (__dest, '\0'),	      \
-					       (const char *) (src),	      \
-					      (n)) = 0, __dest))	      \
-		    : __strncat_g (__dest, (src), (n)); }))
-
-__STRING_INLINE char *__strncat_g (char *__dest, const char __src[],
-				   size_t __n);
-
-__STRING_INLINE char *
-__strncat_g (char *__dest, const char __src[], size_t __n)
-{
-  register char *__tmp = __dest;
-  register char __dummy;
-# ifdef __i686__
-  __asm__ __volatile__
-    ("repne; scasb\n"
-     "movl %4, %3\n\t"
-     "decl %1\n\t"
-     "1:\n\t"
-     "subl	$1,%3\n\t"
-     "jc	2f\n\t"
-     "movb	(%2),%b0\n\t"
-     "movsb\n\t"
-     "testb	%b0,%b0\n\t"
-     "jne	1b\n\t"
-     "decl	%1\n"
-     "2:\n\t"
-     "movb	$0,(%1)"
-     : "=&a" (__dummy), "=&D" (__tmp), "=&S" (__src), "=&c" (__n)
-     :  "g" (__n), "0" (0), "1" (__tmp), "2" (__src), "3" (0xffffffff)
-     : "memory", "cc");
-# else
-  __asm__ __volatile__
-    ("1:\n\t"
-     "cmpb	$0,1(%1)\n\t"
-     "leal	1(%1),%1\n\t"
-     "jne	1b\n"
-     "2:\n\t"
-     "subl	$1,%3\n\t"
-     "jc	3f\n\t"
-     "movb	(%2),%b0\n\t"
-     "leal	1(%2),%2\n\t"
-     "movb	%b0,(%1)\n\t"
-     "leal	1(%1),%1\n\t"
-     "testb	%b0,%b0\n\t"
-     "jne	2b\n\t"
-     "decl	%1\n"
-     "3:\n\t"
-     "movb	$0,(%1)"
-     : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src), "=&r" (__n)
-     : "1" ((unsigned long) __tmp - 1), "2" (__src), "3" (__n)
-     : "memory", "cc");
-#endif
-  return __dest;
-}
-
-
-/* Compare S1 and S2.  */
-# define _HAVE_STRING_ARCH_strcmp 1
-# define strcmp(s1, s2) \
-  (__extension__ (__builtin_constant_p (s1) && __builtin_constant_p (s2)      \
-		  && (sizeof ((s1)[0]) != 1 || strlen (s1) >= 4)	      \
-		  && (sizeof ((s2)[0]) != 1 || strlen (s2) >= 4)	      \
-		  ? memcmp ((const char *) (s1), (const char *) (s2),	      \
-			    (strlen (s1) < strlen (s2)			      \
-			     ? strlen (s1) : strlen (s2)) + 1)		      \
-		  : (__builtin_constant_p (s1) && sizeof ((s1)[0]) == 1	      \
-		     && sizeof ((s2)[0]) == 1 && strlen (s1) < 4	      \
-		     ? (__builtin_constant_p (s2) && sizeof ((s2)[0]) == 1    \
-			? __strcmp_cc ((const unsigned char *) (s1),	      \
-				       (const unsigned char *) (s2),	      \
-				       strlen (s1))			      \
-			: __strcmp_cg ((const unsigned char *) (s1),	      \
-				       (const unsigned char *) (s2),	      \
-				       strlen (s1)))			      \
-		     : (__builtin_constant_p (s2) && sizeof ((s1)[0]) == 1    \
-			&& sizeof ((s2)[0]) == 1 && strlen (s2) < 4	      \
-			? (__builtin_constant_p (s1)			      \
-			   ? __strcmp_cc ((const unsigned char *) (s1),	      \
-					  (const unsigned char *) (s2),	      \
-					  strlen (s2))			      \
-			   : __strcmp_gc ((const unsigned char *) (s1),	      \
-					  (const unsigned char *) (s2),	      \
-					  strlen (s2)))			      \
-			: __strcmp_gg ((s1), (s2))))))
-
-# define __strcmp_cc(s1, s2, l) \
-  (__extension__ ({ register int __result = (s1)[0] - (s2)[0];		      \
-		    if (l > 0 && __result == 0)				      \
-		      {							      \
-			__result = (s1)[1] - (s2)[1];			      \
-			if (l > 1 && __result == 0)			      \
-			  {						      \
-			    __result = (s1)[2] - (s2)[2];		      \
-			    if (l > 2 && __result == 0)			      \
-			      __result = (s1)[3] - (s2)[3];		      \
-			  }						      \
-		      }							      \
-		    __result; }))
-
-# define __strcmp_cg(s1, s2, l1) \
-  (__extension__ ({ const unsigned char *__s2 = (s2);			      \
-		    register int __result = (s1)[0] - __s2[0];		      \
-		    if (l1 > 0 && __result == 0)			      \
-		      {							      \
-			__result = (s1)[1] - __s2[1];			      \
-			if (l1 > 1 && __result == 0)			      \
-			  {						      \
-			    __result = (s1)[2] - __s2[2];		      \
-			    if (l1 > 2 && __result == 0)		      \
-			      __result = (s1)[3] - __s2[3];		      \
-			  }						      \
-		      }							      \
-		    __result; }))
-
-# define __strcmp_gc(s1, s2, l2) \
-  (__extension__ ({ const unsigned char *__s1 = (s1);			      \
-		    register int __result = __s1[0] - (s2)[0];		      \
-		    if (l2 > 0 && __result == 0)			      \
-		      {							      \
-			__result = __s1[1] - (s2)[1];			      \
-			if (l2 > 1 && __result == 0)			      \
-			  {						      \
-			    __result = __s1[2] - (s2)[2];		      \
-			    if (l2 > 2 && __result == 0)		      \
-			      __result = __s1[3] - (s2)[3];		      \
-			  }						      \
-		      }							      \
-		    __result; }))
-
-__STRING_INLINE int __strcmp_gg (const char *__s1, const char *__s2);
-
-__STRING_INLINE int
-__strcmp_gg (const char *__s1, const char *__s2)
-{
-  register int __res;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movb	(%1),%b0\n\t"
-     "leal	1(%1),%1\n\t"
-     "cmpb	%b0,(%2)\n\t"
-     "jne	2f\n\t"
-     "leal	1(%2),%2\n\t"
-     "testb	%b0,%b0\n\t"
-     "jne	1b\n\t"
-     "xorl	%0,%0\n\t"
-     "jmp	3f\n"
-     "2:\n\t"
-     "movl	$1,%0\n\t"
-     "jb	3f\n\t"
-     "negl	%0\n"
-     "3:"
-     : "=q" (__res), "=&r" (__s1), "=&r" (__s2)
-     : "1" (__s1), "2" (__s2),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s1),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s2)
-     : "cc");
-  return __res;
-}
-
-
-/* Compare N characters of S1 and S2.  */
-# define _HAVE_STRING_ARCH_strncmp 1
-# define strncmp(s1, s2, n) \
-  (__extension__ (__builtin_constant_p (s1) && strlen (s1) < ((size_t) (n))   \
-		  ? strcmp ((s1), (s2))					      \
-		  : (__builtin_constant_p (s2) && strlen (s2) < ((size_t) (n))\
-		     ? strcmp ((s1), (s2))				      \
-		     : __strncmp_g ((s1), (s2), (n)))))
-
-__STRING_INLINE int __strncmp_g (const char *__s1, const char *__s2,
-				 size_t __n);
-
-__STRING_INLINE int
-__strncmp_g (const char *__s1, const char *__s2, size_t __n)
-{
-  register int __res;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "subl	$1,%3\n\t"
-     "jc	2f\n\t"
-     "movb	(%1),%b0\n\t"
-     "incl	%1\n\t"
-     "cmpb	%b0,(%2)\n\t"
-     "jne	3f\n\t"
-     "incl	%2\n\t"
-     "testb	%b0,%b0\n\t"
-     "jne	1b\n"
-     "2:\n\t"
-     "xorl	%0,%0\n\t"
-     "jmp	4f\n"
-     "3:\n\t"
-     "movl	$1,%0\n\t"
-     "jb	4f\n\t"
-     "negl	%0\n"
-     "4:"
-     : "=q" (__res), "=&r" (__s1), "=&r" (__s2), "=&r" (__n)
-     : "1"  (__s1), "2"  (__s2),  "3" (__n),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__s1),
-       "m" ( *(struct { __extension__ char __x[__n]; } *)__s2)
-     : "cc");
-  return __res;
-}
-
-
-/* Find the first occurrence of C in S.  */
-# define _HAVE_STRING_ARCH_strchr 1
-# define _USE_STRING_ARCH_strchr 1
-# define strchr(s, c) \
-  (__extension__ (__builtin_constant_p (c)				      \
-		  ? ((c) == '\0'					      \
-		     ? (char *) __rawmemchr ((s), (c))			      \
-		     : __strchr_c ((s), ((c) & 0xff) << 8))		      \
-		  : __strchr_g ((s), (c))))
-
-__STRING_INLINE char *__strchr_c (const char *__s, int __c);
-
-__STRING_INLINE char *
-__strchr_c (const char *__s, int __c)
-{
-  register unsigned long int __d0;
-  register char *__res;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movb	(%0),%%al\n\t"
-     "cmpb	%%ah,%%al\n\t"
-     "je	2f\n\t"
-     "leal	1(%0),%0\n\t"
-     "testb	%%al,%%al\n\t"
-     "jne	1b\n\t"
-     "xorl	%0,%0\n"
-     "2:"
-     : "=r" (__res), "=&a" (__d0)
-     : "0" (__s), "1" (__c),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res;
-}
-
-__STRING_INLINE char *__strchr_g (const char *__s, int __c);
-
-__STRING_INLINE char *
-__strchr_g (const char *__s, int __c)
-{
-  register unsigned long int __d0;
-  register char *__res;
-  __asm__ __volatile__
-    ("movb	%%al,%%ah\n"
-     "1:\n\t"
-     "movb	(%0),%%al\n\t"
-     "cmpb	%%ah,%%al\n\t"
-     "je	2f\n\t"
-     "leal	1(%0),%0\n\t"
-     "testb	%%al,%%al\n\t"
-     "jne	1b\n\t"
-     "xorl	%0,%0\n"
-     "2:"
-     : "=r" (__res), "=&a" (__d0)
-     : "0" (__s), "1" (__c),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res;
-}
-
-
-/* Find the first occurrence of C in S or the final NUL byte.  */
-# define _HAVE_STRING_ARCH_strchrnul 1
-# define __strchrnul(s, c) \
-  (__extension__ (__builtin_constant_p (c)				      \
-		  ? ((c) == '\0'					      \
-		     ? (char *) __rawmemchr ((s), c)			      \
-		     : __strchrnul_c ((s), ((c) & 0xff) << 8))		      \
-		  : __strchrnul_g ((s), c)))
-
-__STRING_INLINE char *__strchrnul_c (const char *__s, int __c);
-
-__STRING_INLINE char *
-__strchrnul_c (const char *__s, int __c)
-{
-  register unsigned long int __d0;
-  register char *__res;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movb	(%0),%%al\n\t"
-     "cmpb	%%ah,%%al\n\t"
-     "je	2f\n\t"
-     "leal	1(%0),%0\n\t"
-     "testb	%%al,%%al\n\t"
-     "jne	1b\n\t"
-     "decl	%0\n"
-     "2:"
-     : "=r" (__res), "=&a" (__d0)
-     : "0" (__s), "1" (__c),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res;
-}
-
-__STRING_INLINE char *__strchrnul_g (const char *__s, int __c);
-
-__STRING_INLINE char *
-__strchrnul_g (const char *__s, int __c)
-{
-  register unsigned long int __d0;
-  register char *__res;
-  __asm__ __volatile__
-    ("movb	%%al,%%ah\n"
-     "1:\n\t"
-     "movb	(%0),%%al\n\t"
-     "cmpb	%%ah,%%al\n\t"
-     "je	2f\n\t"
-     "leal	1(%0),%0\n\t"
-     "testb	%%al,%%al\n\t"
-     "jne	1b\n\t"
-     "decl	%0\n"
-     "2:"
-     : "=r" (__res), "=&a" (__d0)
-     : "0" (__s), "1" (__c),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res;
-}
-# ifdef __USE_GNU
-#  define strchrnul(s, c) __strchrnul ((s), (c))
-# endif
-
-
-# if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
-/* Find the first occurrence of C in S.  This is the BSD name.  */
-#  define _HAVE_STRING_ARCH_index 1
-#  define index(s, c) \
-  (__extension__ (__builtin_constant_p (c)				      \
-		  ? __strchr_c ((s), ((c) & 0xff) << 8)			      \
-		  : __strchr_g ((s), (c))))
-# endif
-
-
-/* Find the last occurrence of C in S.  */
-# define _HAVE_STRING_ARCH_strrchr 1
-# define strrchr(s, c) \
-  (__extension__ (__builtin_constant_p (c)				      \
-		  ? __strrchr_c ((s), ((c) & 0xff) << 8)		      \
-		  : __strrchr_g ((s), (c))))
-
-# ifdef __i686__
-__STRING_INLINE char *__strrchr_c (const char *__s, int __c);
-
-__STRING_INLINE char *
-__strrchr_c (const char *__s, int __c)
-{
-  register unsigned long int __d0, __d1;
-  register char *__res;
-  __asm__ __volatile__
-    ("cld\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "cmpb	%h2,%b2\n\t"
-     "cmove	%1,%0\n\t"
-     "testb	%b2,%b2\n\t"
-     "jne 1b"
-     : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
-     : "0" (1), "1" (__s), "2" (__c),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res - 1;
-}
-
-__STRING_INLINE char *__strrchr_g (const char *__s, int __c);
-
-__STRING_INLINE char *
-__strrchr_g (const char *__s, int __c)
-{
-  register unsigned long int __d0, __d1;
-  register char *__res;
-  __asm__ __volatile__
-    ("movb	%b2,%h2\n"
-     "cld\n\t"
-     "1:\n\t"
-     "lodsb\n\t"
-     "cmpb	%h2,%b2\n\t"
-     "cmove	%1,%0\n\t"
-     "testb	%b2,%b2\n\t"
-     "jne 1b"
-     : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
-     : "0" (1), "1" (__s), "2" (__c),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res - 1;
-}
-# else
-__STRING_INLINE char *__strrchr_c (const char *__s, int __c);
-
-__STRING_INLINE char *
-__strrchr_c (const char *__s, int __c)
-{
-  register unsigned long int __d0, __d1;
-  register char *__res;
-  __asm__ __volatile__
-    ("cld\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "cmpb	%%ah,%%al\n\t"
-     "jne	2f\n\t"
-     "leal	-1(%%esi),%0\n"
-     "2:\n\t"
-     "testb	%%al,%%al\n\t"
-     "jne 1b"
-     : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
-     : "0" (0), "1" (__s), "2" (__c),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res;
-}
-
-__STRING_INLINE char *__strrchr_g (const char *__s, int __c);
-
-__STRING_INLINE char *
-__strrchr_g (const char *__s, int __c)
-{
-  register unsigned long int __d0, __d1;
-  register char *__res;
-  __asm__ __volatile__
-    ("movb	%%al,%%ah\n"
-     "cld\n\t"
-     "1:\n\t"
-     "lodsb\n\t"
-     "cmpb	%%ah,%%al\n\t"
-     "jne	2f\n\t"
-     "leal	-1(%%esi),%0\n"
-     "2:\n\t"
-     "testb	%%al,%%al\n\t"
-     "jne 1b"
-     : "=r" (__res), "=&S" (__d0), "=&a" (__d1)
-     : "0" (0), "1" (__s), "2" (__c),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return __res;
-}
-# endif
-
-
-# if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
-/* Find the last occurrence of C in S.  This is the BSD name.  */
-#  define _HAVE_STRING_ARCH_rindex 1
-#  define rindex(s, c) \
-  (__extension__ (__builtin_constant_p (c)				      \
-		  ? __strrchr_c ((s), ((c) & 0xff) << 8)		      \
-		  : __strrchr_g ((s), (c))))
-# endif
-
-
-/* Return the length of the initial segment of S which
-   consists entirely of characters not in REJECT.  */
-# define _HAVE_STRING_ARCH_strcspn 1
-# define strcspn(s, reject) \
-  (__extension__ (__builtin_constant_p (reject) && sizeof ((reject)[0]) == 1  \
-		  ? ((reject)[0] == '\0'				      \
-		     ? strlen (s)					      \
-		     : ((reject)[1] == '\0'				      \
-			? __strcspn_c1 ((s), (((reject)[0] << 8) & 0xff00))   \
-			: __strcspn_cg ((s), (reject), strlen (reject))))     \
-		  : __strcspn_g ((s), (reject))))
-
-__STRING_INLINE size_t __strcspn_c1 (const char *__s, int __reject);
-
-# ifndef _FORCE_INLINES
-__STRING_INLINE size_t
-__strcspn_c1 (const char *__s, int __reject)
-{
-  register unsigned long int __d0;
-  register char *__res;
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movb	(%0),%%al\n\t"
-     "leal	1(%0),%0\n\t"
-     "cmpb	%%ah,%%al\n\t"
-     "je	2f\n\t"
-     "testb	%%al,%%al\n\t"
-     "jne	1b\n"
-     "2:"
-     : "=r" (__res), "=&a" (__d0)
-     : "0" (__s), "1" (__reject),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return (__res - 1) - __s;
-}
-# endif
-
-__STRING_INLINE size_t __strcspn_cg (const char *__s, const char __reject[],
-				     size_t __reject_len);
-
-__STRING_INLINE size_t
-__strcspn_cg (const char *__s, const char __reject[], size_t __reject_len)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register const char *__res;
-  __asm__ __volatile__
-    ("cld\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%5,%%edi\n\t"
-     "movl	%6,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "jne	1b\n"
-     "2:"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
-     : "0" (__s), "d" (__reject), "g" (__reject_len)
-     : "memory", "cc");
-  return (__res - 1) - __s;
-}
-
-__STRING_INLINE size_t __strcspn_g (const char *__s, const char *__reject);
-# ifdef __PIC__
-
-__STRING_INLINE size_t
-__strcspn_g (const char *__s, const char *__reject)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register const char *__res;
-  __asm__ __volatile__
-    ("pushl	%%ebx\n\t"
-     "movl	%4,%%edi\n\t"
-     "cld\n\t"
-     "repne; scasb\n\t"
-     "notl	%%ecx\n\t"
-     "leal	-1(%%ecx),%%ebx\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%4,%%edi\n\t"
-     "movl	%%ebx,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "jne	1b\n"
-     "2:\n\t"
-     "popl	%%ebx"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
-     : "r" (__reject), "0" (__s), "1" (0), "2" (0xffffffff)
-     : "memory", "cc");
-  return (__res - 1) - __s;
-}
-# else
-__STRING_INLINE size_t
-__strcspn_g (const char *__s, const char *__reject)
-{
-  register unsigned long int __d0, __d1, __d2, __d3;
-  register const char *__res;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "repne; scasb\n\t"
-     "notl	%%ecx\n\t"
-     "leal	-1(%%ecx),%%edx\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%%ebx,%%edi\n\t"
-     "movl	%%edx,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "jne	1b\n"
-     "2:"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3)
-     : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__reject), "b" (__reject)
-     /* Clobber memory, otherwise GCC cannot handle this.  */
-     : "memory", "cc");
-  return (__res - 1) - __s;
-}
-# endif
-
-
-/* Return the length of the initial segment of S which
-   consists entirely of characters in ACCEPT.  */
-# define _HAVE_STRING_ARCH_strspn 1
-# define strspn(s, accept) \
-  (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1  \
-		  ? ((accept)[0] == '\0'				      \
-		     ? ((void) (s), 0)					      \
-		     : ((accept)[1] == '\0'				      \
-			? __strspn_c1 ((s), (((accept)[0] << 8 ) & 0xff00))   \
-			: __strspn_cg ((s), (accept), strlen (accept))))      \
-		  : __strspn_g ((s), (accept))))
-
-# ifndef _FORCE_INLINES
-__STRING_INLINE size_t __strspn_c1 (const char *__s, int __accept);
-
-__STRING_INLINE size_t
-__strspn_c1 (const char *__s, int __accept)
-{
-  register unsigned long int __d0;
-  register char *__res;
-  /* Please note that __accept never can be '\0'.  */
-  __asm__ __volatile__
-    ("1:\n\t"
-     "movb	(%0),%b1\n\t"
-     "leal	1(%0),%0\n\t"
-     "cmpb	%h1,%b1\n\t"
-     "je	1b"
-     : "=r" (__res), "=&q" (__d0)
-     : "0" (__s), "1" (__accept),
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s)
-     : "cc");
-  return (__res - 1) - __s;
-}
-# endif
-
-__STRING_INLINE size_t __strspn_cg (const char *__s, const char __accept[],
-				    size_t __accept_len);
-
-__STRING_INLINE size_t
-__strspn_cg (const char *__s, const char __accept[], size_t __accept_len)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register const char *__res;
-  __asm__ __volatile__
-    ("cld\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%5,%%edi\n\t"
-     "movl	%6,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "je	1b\n"
-     "2:"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
-     : "0" (__s), "g" (__accept), "g" (__accept_len),
-       /* Since we do not know how large the memory we access it, use a
-	  really large amount.  */
-       "m" ( *(struct { char __x[0xfffffff]; } *)__s),
-       "m" ( *(struct { __extension__ char __x[__accept_len]; } *)__accept)
-     : "cc");
-  return (__res - 1) - __s;
-}
-
-__STRING_INLINE size_t __strspn_g (const char *__s, const char *__accept);
-# ifdef __PIC__
-
-__STRING_INLINE size_t
-__strspn_g (const char *__s, const char *__accept)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register const char *__res;
-  __asm__ __volatile__
-    ("pushl	%%ebx\n\t"
-     "cld\n\t"
-     "repne; scasb\n\t"
-     "notl	%%ecx\n\t"
-     "leal	-1(%%ecx),%%ebx\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%%edx,%%edi\n\t"
-     "movl	%%ebx,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "je	1b\n"
-     "2:\n\t"
-     "popl	%%ebx"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
-     : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept)
-     : "memory", "cc");
-  return (__res - 1) - __s;
-}
-# else
-__STRING_INLINE size_t
-__strspn_g (const char *__s, const char *__accept)
-{
-  register unsigned long int __d0, __d1, __d2, __d3;
-  register const char *__res;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "repne; scasb\n\t"
-     "notl	%%ecx\n\t"
-     "leal	-1(%%ecx),%%edx\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%%ebx,%%edi\n\t"
-     "movl	%%edx,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "je	1b\n"
-     "2:"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3)
-     : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept), "b" (__accept)
-     : "memory", "cc");
-  return (__res - 1) - __s;
-}
-# endif
-
-
-/* Find the first occurrence in S of any character in ACCEPT.  */
-# define _HAVE_STRING_ARCH_strpbrk 1
-# define strpbrk(s, accept) \
-  (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1  \
-		  ? ((accept)[0] == '\0'				      \
-		     ? ((void) (s), (char *) 0)				      \
-		     : ((accept)[1] == '\0'				      \
-			? strchr ((s), (accept)[0])			      \
-			: __strpbrk_cg ((s), (accept), strlen (accept))))     \
-		  : __strpbrk_g ((s), (accept))))
-
-__STRING_INLINE char *__strpbrk_cg (const char *__s, const char __accept[],
-				    size_t __accept_len);
-
-__STRING_INLINE char *
-__strpbrk_cg (const char *__s, const char __accept[], size_t __accept_len)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register char *__res;
-  __asm__ __volatile__
-    ("cld\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%5,%%edi\n\t"
-     "movl	%6,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "jne	1b\n\t"
-     "decl	%0\n\t"
-     "jmp	3f\n"
-     "2:\n\t"
-     "xorl	%0,%0\n"
-     "3:"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
-     : "0" (__s), "d" (__accept), "g" (__accept_len)
-     : "memory", "cc");
-  return __res;
-}
-
-__STRING_INLINE char *__strpbrk_g (const char *__s, const char *__accept);
-# ifdef __PIC__
-
-__STRING_INLINE char *
-__strpbrk_g (const char *__s, const char *__accept)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register char *__res;
-  __asm__ __volatile__
-    ("pushl	%%ebx\n\t"
-     "movl	%%edx,%%edi\n\t"
-     "cld\n\t"
-     "repne; scasb\n\t"
-     "notl	%%ecx\n\t"
-     "leal	-1(%%ecx),%%ebx\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%%edx,%%edi\n\t"
-     "movl	%%ebx,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "jne	1b\n\t"
-     "decl	%0\n\t"
-     "jmp	3f\n"
-     "2:\n\t"
-     "xorl	%0,%0\n"
-     "3:\n\t"
-     "popl	%%ebx"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
-     : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff)
-     : "memory", "cc");
-  return __res;
-}
-# else
-__STRING_INLINE char *
-__strpbrk_g (const char *__s, const char *__accept)
-{
-  register unsigned long int __d0, __d1, __d2, __d3;
-  register char *__res;
-  __asm__ __volatile__
-    ("movl	%%ebx,%%edi\n\t"
-     "cld\n\t"
-     "repne; scasb\n\t"
-     "notl	%%ecx\n\t"
-     "leal	-1(%%ecx),%%edx\n"
-     "1:\n\t"
-     "lodsb\n\t"
-     "testb	%%al,%%al\n\t"
-     "je	2f\n\t"
-     "movl	%%ebx,%%edi\n\t"
-     "movl	%%edx,%%ecx\n\t"
-     "repne; scasb\n\t"
-     "jne	1b\n\t"
-     "decl	%0\n\t"
-     "jmp	3f\n"
-     "2:\n\t"
-     "xorl	%0,%0\n"
-     "3:"
-     : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&d" (__d2), "=&D" (__d3)
-     : "0" (__s), "1" (0), "2" (0xffffffff), "b" (__accept)
-     : "memory", "cc");
-  return __res;
-}
-# endif
-
-
-/* Find the first occurrence of NEEDLE in HAYSTACK.  */
-# define _HAVE_STRING_ARCH_strstr 1
-# define strstr(haystack, needle) \
-  (__extension__ (__builtin_constant_p (needle) && sizeof ((needle)[0]) == 1  \
-		  ? ((needle)[0] == '\0'				      \
-		     ? (haystack)					      \
-		     : ((needle)[1] == '\0'				      \
-			? strchr ((haystack), (needle)[0])		      \
-			: __strstr_cg ((haystack), (needle),		      \
-				       strlen (needle))))		      \
-		  : __strstr_g ((haystack), (needle))))
-
-/* Please note that this function need not handle NEEDLEs with a
-   length shorter than two.  */
-__STRING_INLINE char *__strstr_cg (const char *__haystack,
-				   const char __needle[],
-				   size_t __needle_len);
-
-__STRING_INLINE char *
-__strstr_cg (const char *__haystack, const char __needle[],
-	     size_t __needle_len)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register char *__res;
-  __asm__ __volatile__
-    ("cld\n" \
-     "1:\n\t"
-     "movl	%6,%%edi\n\t"
-     "movl	%5,%%eax\n\t"
-     "movl	%4,%%ecx\n\t"
-     "repe; cmpsb\n\t"
-     "je	2f\n\t"
-     "cmpb	$0,-1(%%esi)\n\t"
-     "leal	1(%%eax),%5\n\t"
-     "jne	1b\n\t"
-     "xorl	%%eax,%%eax\n"
-     "2:"
-     : "=&a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2)
-     : "g" (__needle_len), "1" (__haystack), "d" (__needle)
-     : "memory", "cc");
-  return __res;
-}
-
-__STRING_INLINE char *__strstr_g (const char *__haystack,
-				  const char *__needle);
-# ifdef __PIC__
-
-__STRING_INLINE char *
-__strstr_g (const char *__haystack, const char *__needle)
-{
-  register unsigned long int __d0, __d1, __d2;
-  register char *__res;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "repne; scasb\n\t"
-     "notl	%%ecx\n\t"
-     "pushl	%%ebx\n\t"
-     "decl	%%ecx\n\t"	/* NOTE! This also sets Z if searchstring='' */
-     "movl	%%ecx,%%ebx\n"
-     "1:\n\t"
-     "movl	%%edx,%%edi\n\t"
-     "movl	%%esi,%%eax\n\t"
-     "movl	%%ebx,%%ecx\n\t"
-     "repe; cmpsb\n\t"
-     "je	2f\n\t"		/* also works for empty string, see above */
-     "cmpb	$0,-1(%%esi)\n\t"
-     "leal	1(%%eax),%%esi\n\t"
-     "jne	1b\n\t"
-     "xorl	%%eax,%%eax\n"
-     "2:\n\t"
-     "popl	%%ebx"
-     : "=&a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
-     : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle),
-       "d" (__needle)
-     : "memory", "cc");
-  return __res;
-}
-# else
-__STRING_INLINE char *
-__strstr_g (const char *__haystack, const char *__needle)
-{
-  register unsigned long int __d0, __d1, __d2, __d3;
-  register char *__res;
-  __asm__ __volatile__
-    ("cld\n\t"
-     "repne; scasb\n\t"
-     "notl	%%ecx\n\t"
-     "decl	%%ecx\n\t"	/* NOTE! This also sets Z if searchstring='' */
-     "movl	%%ecx,%%edx\n"
-     "1:\n\t"
-     "movl	%%ebx,%%edi\n\t"
-     "movl	%%esi,%%eax\n\t"
-     "movl	%%edx,%%ecx\n\t"
-     "repe; cmpsb\n\t"
-     "je	2f\n\t"		/* also works for empty string, see above */
-     "cmpb	$0,-1(%%esi)\n\t"
-     "leal	1(%%eax),%%esi\n\t"
-     "jne	1b\n\t"
-     "xorl	%%eax,%%eax\n"
-     "2:"
-     : "=&a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2), "=&d" (__d3)
-     : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle),
-       "b" (__needle)
-     : "memory", "cc");
-  return __res;
-}
-# endif
-
-
-/* Bit find functions.  We define only the i686 version since for the other
-   processors gcc generates good code.  */
-# if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
-#  ifdef __i686__
-#   define _HAVE_STRING_ARCH_ffs 1
-#   define ffs(word) (__builtin_constant_p (word)			      \
-		      ? __builtin_ffs (word)				      \
-		      : ({ int __cnt, __tmp;				      \
-			   __asm__ __volatile__				      \
-			     ("bsfl %2,%0\n\t"				      \
-			      "cmovel %1,%0"				      \
-			      : "=&r" (__cnt), "=r" (__tmp)		      \
-			      : "rm" (word), "1" (-1));			      \
-			   __cnt + 1; }))
-
-#   ifndef ffsl
-#    define ffsl(word) ffs(word)
-#   endif
-#  endif /* i686 */
-# endif	/* Misc || X/Open */
-
-# ifndef _FORCE_INLINES
-#  undef __STRING_INLINE
-# endif
-
-# endif	/* use string inlines && GNU CC */
-
-#endif
diff --git a/sysdeps/x86_64/multiarch/strncat-c.c b/sysdeps/x86_64/multiarch/strncat-c.c
index a3cdbff689..db8ad9917c 100644
--- a/sysdeps/x86_64/multiarch/strncat-c.c
+++ b/sysdeps/x86_64/multiarch/strncat-c.c
@@ -1,8 +1,3 @@
 #define STRNCAT __strncat_sse2
-#ifdef SHARED
-#undef libc_hidden_def
-#define libc_hidden_def(name) \
-  __hidden_ver1 (__strncat_sse2, __GI___strncat, __strncat_sse2);
-#endif
-
+#define STRNCAT_PRIMARY
 #include "string/strncat.c"