sysdeps/i386/i486/bits/string.h

   1 /* Optimized, inlined string functions.  i486 version.
   2    Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #ifndef _STRING_H
  21 # error "Never use <bits/string.h> directly; include <string.h> instead."
  22 #endif
  23
  24 /* The ix86 processors can access unaligned multi-byte variables.  */
  25 #define _STRING_ARCH_unaligned  1
  26
  27
  28 /* We only provide optimizations if the user selects them and if
  29    GNU CC is used.  */
  30 #if !defined __NO_STRING_INLINES && defined __USE_STRING_INLINES \
  31     && defined __GNUC__ && __GNUC__ >= 2
  32
  33 #ifdef __cplusplus
  34 # define __STRING_INLINE inline
  35 #else
  36 # define __STRING_INLINE extern __inline
  37 #endif
  38
  39 /* The macros are used in some of the optimized implementations below.  */
  40 #define __STRING_SMALL_GET16(src, idx) \
  41   (((src)[idx + 1] << 8) | (src)[idx])
  42 #define __STRING_SMALL_GET32(src, idx) \
  43   ((((src)[idx + 3] << 8 | (src)[idx + 2]) << 8                               \
  44     | (src)[idx + 1]) << 8 | (src)[idx])
  45
  46
  47 /* Copy N bytes of SRC to DEST.  */
  48 #define _HAVE_STRING_ARCH_memcpy 1
  49 #define memcpy(dest, src, n) \
  50   (__extension__ (__builtin_constant_p (n)                                    \
  51                   ? __memcpy_c (dest, src, n)                                 \
  52                   : __memcpy_g (dest, src, n)))
  53 #define __memcpy_c(dest, src, n) \
  54   ((n) == 0                                                                   \
  55    ? (dest)                                                                   \
  56    : (((n) % 4 == 0)                                                          \
  57       ? __memcpy_by4 (dest, src, n)                                           \
  58       : (((n) % 2 == 0)                                                       \
  59          ? __memcpy_by2 (dest, src, n)                                        \
  60          : __memcpy_g (dest, src, n))))
  61
  62 __STRING_INLINE void *__memcpy_by4 (void *__dest, __const void *__src,
  63                                     size_t __n);
  64
  65 __STRING_INLINE void *
  66 __memcpy_by4 (void *__dest, __const void *__src, size_t __n)
  67 {
  68   register unsigned long int __d0, __d1;
  69   register void *__tmp = __dest;
  70   __asm__ __volatile__
  71     ("1:\n\t"
  72      "movl      (%2),%0\n\t"
  73      "leal      4(%2),%2\n\t"
  74      "movl      %0,(%1)\n\t"
  75      "leal      4(%1),%1\n\t"
  76      "decl      %3\n\t"
  77      "jnz       1b"
  78      : "=&r" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1)
  79      : "1" (__tmp), "2" (__src), "3" (__n / 4)
  80      : "memory", "cc");
  81   return __dest;
  82 }
  83
  84 __STRING_INLINE void *__memcpy_by2 (void *__dest, __const void *__src,
  85                                     size_t __n);
  86
  87 __STRING_INLINE void *
  88 __memcpy_by2 (void *__dest, __const void *__src, size_t __n)
  89 {
  90   register unsigned long int __d0, __d1;
  91   register void *__tmp = __dest;
  92   __asm__ __volatile__
  93     ("shrl      $1,%3\n\t"
  94      "jz        2f\n"                 /* only a word */
  95      "1:\n\t"
  96      "movl      (%2),%0\n\t"
  97      "leal      4(%2),%2\n\t"
  98      "movl      %0,(%1)\n\t"
  99      "leal      4(%1),%1\n\t"
 100      "decl      %3\n\t"
 101      "jnz       1b\n"
 102      "2:\n\t"
 103      "movw      (%2),%w0\n\t"
 104      "movw      %w0,(%1)"
 105      : "=&q" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1)
 106      : "1" (__tmp), "2" (__src), "3" (__n / 2)
 107      : "memory", "cc");
 108   return __dest;
 109 }
 110
 111 __STRING_INLINE void *__memcpy_g (void *__dest, __const void *__src,
 112                                   size_t __n);
 113
 114      __STRING_INLINE void *
 115 __memcpy_g (void *__dest, __const void *__src, size_t __n)
 116 {
 117   register unsigned long int __d0, __d1, __d2;
 118   register void *__tmp = __dest;
 119   __asm__ __volatile__
 120     ("cld\n\t"
 121      "shrl      $1,%%ecx\n\t"
 122      "jnc       1f\n\t"
 123      "movsb\n"
 124      "1:\n\t"
 125      "shrl      $1,%%ecx\n\t"
 126      "jnc       2f\n\t"
 127      "movsw\n"
 128      "2:\n\t"
 129      "rep; movsl"
 130      : "=&c" (__d0), "=&D" (__d1), "=&S" (__d2)
 131      : "0" (__n), "1" (__tmp), "2" (__src)
 132      : "memory", "cc");
 133   return __dest;
 134 }
 135
 136
 137 /* Copy N bytes of SRC to DEST, guaranteeing
 138    correct behavior for overlapping strings.  */
 139 __STRING_INLINE void *
 140 memmove (void *__dest, __const void *__src, size_t __n)
 141 {
 142   register unsigned long int __d0, __d1, __d2;
 143   register void *__tmp = __dest;
 144   if (__dest < __src)
 145     __asm__ __volatile__
 146       ("cld\n\t"
 147        "rep; movsb"
 148        : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
 149        : "0" (__n), "1" (__src), "2" (__tmp)
 150        : "memory");
 151   else
 152     __asm__ __volatile__
 153       ("std\n\t"
 154        "rep; movsb\n\t"
 155        "cld"
 156        : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
 157        : "0" (__n), "1" (__n - 1 + (__const char *) __src),
 158          "2" (__n - 1 + (char *) __tmp)
 159        : "memory");
 160   return __dest;
 161 }
 162
 163
 164 /* Compare N bytes of S1 and S2.  */
 165 #define _HAVE_STRING_ARCH_memcmp 1
 166 #ifndef __PIC__
 167 /* gcc has problems to spill registers when using PIC.  */
 168 __STRING_INLINE int
 169 memcmp (__const void *__s1, __const void *__s2, size_t __n)
 170 {
 171   register unsigned long int __d0, __d1, __d2;
 172   register int __res;
 173   __asm__ __volatile__
 174     ("cld\n\t"
 175      "testl %3,%3\n\t"
 176      "repe; cmpsb\n\t"
 177      "je        1f\n\t"
 178      "sbbl      %0,%0\n\t"
 179      "orl       $1,%0\n"
 180      "1:"
 181      : "=a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2)
 182      : "0" (0), "1" (__s1), "2" (__s2), "3" (__n)
 183      : "cc");
 184   return __res;
 185 }
 186 #endif
 187
 188
 189 /* Set N bytes of S to C.  */
 190 #define _HAVE_STRING_ARCH_memset 1
 191 #define memset(s, c, n) \
 192   (__extension__ (__builtin_constant_p (n) && (n) <= 16                       \
 193                   ? ((n) == 1                                                 \
 194                      ? __memset_c1 (s, c)                                     \
 195                      : __memset_gc (s, c, n))                                 \
 196                   : (__builtin_constant_p (c)                                 \
 197                      ? (__builtin_constant_p (n)                              \
 198                         ? __memset_ccn (s, c, n)                              \
 199                         : memset (s, c, n))                                   \
 200                      : (__builtin_constant_p (n)                              \
 201                         ? __memset_gcn (s, c, n)                              \
 202                         : memset (s, c, n)))))
 203
 204 #define __memset_c1(s, c) ({ void *__s = (s);                                 \
 205                              *((unsigned char *) __s) = (unsigned char) (c);  \
 206                              __s; })
 207
 208 #define __memset_gc(s, c, n) \
 209   ({ void *__s = (s);                                                         \
 210      unsigned int *__ts = (unsigned int *) __s;                               \
 211      unsigned int __c = ((unsigned int) ((unsigned char) (c))) * 0x01010101;  \
 212                                                                               \
 213      /* We apply a trick here.  `gcc' would implement the following           \
 214         assignments using absolute operands.  But this uses to much           \
 215         memory (7, instead of 4 bytes).  */                                   \
 216      if (n == 3 || n >= 5)                                                    \
 217        __asm__ __volatile__ ("" : "=r" (__c) : "0" (__c));                    \
 218                                                                               \
 219      /* This `switch' statement will be removed at compile-time.  */          \
 220      switch (n)                                                               \
 221        {                                                                      \
 222        case 15:                                                               \
 223          *__ts++ = __c;                                                       \
 224        case 11:                                                               \
 225          *__ts++ = __c;                                                       \
 226        case 7:                                                                \
 227          *__ts++ = __c;                                                       \
 228        case 3:                                                                \
 229          *((unsigned short int *) __ts)++ = (unsigned short int) __c;         \
 230          *((unsigned char *) __ts) = (unsigned char) __c;                     \
 231          break;                                                               \
 232                                                                               \
 233        case 14:                                                               \
 234          *__ts++ = __c;                                                       \
 235        case 10:                                                               \
 236          *__ts++ = __c;                                                       \
 237        case 6:                                                                \
 238          *__ts++ = __c;                                                       \
 239        case 2:                                                                \
 240          *((unsigned short int *) __ts) = (unsigned short int) __c;           \
 241          break;                                                               \
 242                                                                               \
 243        case 13:                                                               \
 244          *__ts++ = __c;                                                       \
 245        case 9:                                                                \
 246          *__ts++ = __c;                                                       \
 247        case 5:                                                                \
 248          *__ts++ = __c;                                                       \
 249        case 1:                                                                \
 250          *((unsigned char *) __ts) = (unsigned char) __c;                     \
 251          break;                                                               \
 252                                                                               \
 253        case 16:                                                               \
 254          *__ts++ = __c;                                                       \
 255        case 12:                                                               \
 256          *__ts++ = __c;                                                       \
 257        case 8:                                                                \
 258          *__ts++ = __c;                                                       \
 259        case 4:                                                                \
 260          *__ts = __c;                                                         \
 261        case 0:                                                                \
 262          break;                                                               \
 263        }                                                                      \
 264                                                                               \
 265      __s; })
 266
 267 #define __memset_ccn(s, c, n) \
 268   (((n) % 4 == 0)                                                             \
 269    ? __memset_ccn_by4 (s, ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
 270                        n)                                                     \
 271    : (((n) % 2 == 0)                                                          \
 272       ? __memset_ccn_by2 (s,                                                  \
 273                           ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
 274                            n)                                                 \
 275       : memset (s, c, n)))
 276
 277 __STRING_INLINE void *__memset_ccn_by4 (void *__s, unsigned int __c,
 278                                         size_t __n);
 279
 280 __STRING_INLINE void *
 281 __memset_ccn_by4 (void *__s, unsigned int __c, size_t __n)
 282 {
 283   register void *__tmp = __s;
 284   register unsigned long int __d0;
 285 #ifdef __i686__
 286   __asm__ __volatile__
 287     ("cld\n\t"
 288      "rep; stosl"
 289      : "=&a" (__c), "=&D" (__tmp), "=&c" (__d0)
 290      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
 291      : "memory", "cc");
 292 #else
 293   __asm__ __volatile__
 294     ("1:\n\t"
 295      "movl      %0,(%1)\n\t"
 296      "addl      $4,%1\n\t"
 297      "decl      %2\n\t"
 298      "jnz       1b\n"
 299      : "=&r" (__c), "=&r" (__tmp), "=&r" (__d0)
 300      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
 301      : "memory", "cc");
 302 #endif
 303   return __s;
 304 }
 305
 306 __STRING_INLINE void *__memset_ccn_by2 (void *__s, unsigned int __c,
 307                                         size_t __n);
 308
 309 __STRING_INLINE void *
 310 __memset_ccn_by2 (void *__s, unsigned int __c, size_t __n)
 311 {
 312   register unsigned long int __d0, __d1;
 313   register void *__tmp = __s;
 314 #ifdef __i686__
 315   __asm__ __volatile__
 316     ("cld\n\t"
 317      "rep; stosl\n"
 318      "stosw"
 319     : "=&a" (__d0), "=&D" (__tmp), "=&c" (__d1)
 320      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
 321      : "memory", "cc");
 322 #else
 323   __asm__ __volatile__
 324     ("1:\tmovl  %0,(%1)\n\t"
 325      "leal      4(%1),%1\n\t"
 326      "decl      %2\n\t"
 327      "jnz       1b\n"
 328      "movw      %w0,(%1)"
 329      : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1)
 330      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
 331      : "memory", "cc");
 332 #endif
 333   return __s;
 334 }
 335
 336 #define __memset_gcn(s, c, n) \
 337   (((n) % 4 == 0)                                                             \
 338    ? __memset_gcn_by4 (s, c, n)                                               \
 339    : (((n) % 2 == 0)                                                          \
 340       ? __memset_gcn_by2 (s, c, n)                                            \
 341       : memset (s, c, n)))
 342
 343 __STRING_INLINE void *__memset_gcn_by4 (void *__s, int __c, size_t __n);
 344
 345 __STRING_INLINE void *
 346 __memset_gcn_by4 (void *__s, int __c, size_t __n)
 347 {
 348   register void *__tmp = __s;
 349   register unsigned long int __d0;
 350   __asm__ __volatile__
 351     ("movb      %b0,%h0\n"
 352      "pushw     %w0\n\t"
 353      "shll      $16,%0\n\t"
 354      "popw      %w0\n"
 355      "1:\n\t"
 356      "movl      %0,(%1)\n\t"
 357      "addl      $4,%1\n\t"
 358      "decl      %2\n\t"
 359      "jnz       1b\n"
 360      : "=&q" (__c), "=&r" (__tmp), "=&r" (__d0)
 361      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
 362      : "memory", "cc");
 363   return __s;
 364 }
 365
 366 __STRING_INLINE void *__memset_gcn_by2 (void *__s, int __c, size_t __n);
 367
 368 __STRING_INLINE void *
 369 __memset_gcn_by2 (void *__s, int __c, size_t __n)
 370 {
 371   register unsigned long int __d0, __d1;
 372   register void *__tmp = __s;
 373   __asm__ __volatile__
 374     ("movb      %b0,%h0\n\t"
 375      "pushw     %w0\n\t"
 376      "shll      $16,%0\n\t"
 377      "popw      %w0\n"
 378      "1:\n\t"
 379      "movl      %0,(%1)\n\t"
 380      "leal      4(%1),%1\n\t"
 381      "decl      %2\n\t"
 382      "jnz       1b\n"
 383      "movw      %w0,(%1)"
 384      : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1)
 385      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
 386      : "memory", "cc");
 387   return __s;
 388 }
 389
 390
 391 /* Search N bytes of S for C.  */
 392 #define _HAVE_STRING_ARCH_memchr 1
 393 __STRING_INLINE void *
 394 memchr (__const void *__s, int __c, size_t __n)
 395 {
 396   register unsigned long int __d0;
 397 #ifdef __i686__
 398   register unsigned long int __d1;
 399 #endif
 400   register unsigned char *__res;
 401   if (__n == 0)
 402     return NULL;
 403 #ifdef __i686__
 404   __asm__ __volatile__
 405     ("cld\n\t"
 406      "repne; scasb\n\t"
 407      "cmovne %2,%0"
 408      : "=D" (__res), "=&c" (__d0), "=&r" (__d1)
 409      : "a" (__c), "0" (__s), "1" (__n), "2" (1)
 410      : "cc");
 411 #else
 412   __asm__ __volatile__
 413     ("cld\n\t"
 414      "repne; scasb\n\t"
 415      "je        1f\n\t"
 416      "movl      $1,%0\n"
 417      "1:"
 418      : "=D" (__res), "=&c" (__d0)
 419      : "a" (__c), "0" (__s), "1" (__n)
 420      : "cc");
 421 #endif
 422   return __res - 1;
 423 }
 424
 425
 426 /* Return pointer to C in S.  */
 427 #define _HAVE_STRING_ARCH_rawmemchr 1
 428 __STRING_INLINE void *
 429 __rawmemchr (const void *__s, int __c)
 430 {
 431   register unsigned long int __d0;
 432   register unsigned char *__res;
 433   __asm__ __volatile__
 434     ("cld\n\t"
 435      "repne; scasb\n\t"
 436      : "=D" (__res), "=&c" (__d0)
 437      : "a" (__c), "0" (__s), "1" (0xffffffff)
 438      : "cc");
 439   return __res - 1;
 440 }
 441 #ifdef __USE_GNU
 442 __STRING_INLINE void *
 443 rawmemchr (const void *__s, int __c)
 444 {
 445   return __rawmemchr (__s, __c);
 446 }
 447 #endif  /* use GNU */
 448
 449
 450 /* Return the length of S.  */
 451 #define _HAVE_STRING_ARCH_strlen 1
 452 #define strlen(str) \
 453   (__extension__ (__builtin_constant_p (str)                                  \
 454                   ? __builtin_strlen (str)                                    \
 455                   : __strlen_g (str)))
 456 __STRING_INLINE size_t __strlen_g (__const char *__str);
 457
 458 __STRING_INLINE size_t
 459 __strlen_g (__const char *__str)
 460 {
 461   register char __dummy;
 462   register __const char *__tmp = __str;
 463   __asm__ __volatile__
 464     ("1:\n\t"
 465      "movb      (%0),%b1\n\t"
 466      "leal      1(%0),%0\n\t"
 467      "testb     %b1,%b1\n\t"
 468      "jne       1b"
 469      : "=r" (__tmp), "=&q" (__dummy)
 470      : "0" (__str)
 471      : "memory", "cc" );
 472   return __tmp - __str - 1;
 473 }
 474
 475
 476 /* Copy SRC to DEST.  */
 477 #define _HAVE_STRING_ARCH_strcpy 1
 478 #define strcpy(dest, src) \
 479   (__extension__ (__builtin_constant_p (src)                                  \
 480                   ? (sizeof ((src)[0]) == 1 && strlen (src) + 1 <= 8          \
 481                      ? __strcpy_small (dest, src, strlen (src) + 1)           \
 482                      : (char *) memcpy ((char *) dest,                        \
 483                                         (__const char *) src,                 \
 484                                         strlen (src) + 1))                    \
 485                   : __strcpy_g (dest, src)))
 486
 487 #define __strcpy_small(dest, src, srclen) \
 488   (__extension__ ({ unsigned char *__dest = (unsigned char *) (dest);         \
 489                     switch (srclen)                                           \
 490                       {                                                       \
 491                       case 1:                                                 \
 492                         *__dest = '\0';                                       \
 493                         break;                                                \
 494                       case 2:                                                 \
 495                         *((unsigned short int *) __dest) =                    \
 496                           __STRING_SMALL_GET16 (src, 0);                      \
 497                         break;                                                \
 498                       case 3:                                                 \
 499                         *((unsigned short int *) __dest) =                    \
 500                           __STRING_SMALL_GET16 (src, 0);                      \
 501                         *(__dest + 2) = '\0';                                 \
 502                         break;                                                \
 503                       case 4:                                                 \
 504                         *((unsigned int *) __dest) =                          \
 505                           __STRING_SMALL_GET32 (src, 0);                      \
 506                         break;                                                \
 507                       case 5:                                                 \
 508                         *((unsigned int *) __dest) =                          \
 509                           __STRING_SMALL_GET32 (src, 0);                      \
 510                         *(__dest + 4) = '\0';                                 \
 511                         break;                                                \
 512                       case 6:                                                 \
 513                         *((unsigned int *) __dest) =                          \
 514                           __STRING_SMALL_GET32 (src, 0);                      \
 515                         *((unsigned short int *) (__dest + 4)) =              \
 516                           __STRING_SMALL_GET16 (src, 4);                      \
 517                         break;                                                \
 518                       case 7:                                                 \
 519                         *((unsigned int *) __dest) =                          \
 520                           __STRING_SMALL_GET32 (src, 0);                      \
 521                         *((unsigned short int *) (__dest + 4)) =              \
 522                           __STRING_SMALL_GET16 (src, 4);                      \
 523                         *(__dest + 6) = '\0';                                 \
 524                         break;                                                \
 525                       case 8:                                                 \
 526                         *((unsigned int *) __dest) =                          \
 527                           __STRING_SMALL_GET32 (src, 0);                      \
 528                         *((unsigned int *) (__dest + 4)) =                    \
 529                           __STRING_SMALL_GET32 (src, 4);                      \
 530                         break;                                                \
 531                       }                                                       \
 532                     (char *) __dest; }))
 533
 534 __STRING_INLINE char *__strcpy_g (char *__dest, __const char *__src);
 535
 536 __STRING_INLINE char *
 537 __strcpy_g (char *__dest, __const char *__src)
 538 {
 539   register char *__tmp = __dest;
 540   register char __dummy;
 541   __asm__ __volatile__
 542     (
 543      "1:\n\t"
 544      "movb      (%0),%b2\n\t"
 545      "leal      1(%0),%0\n\t"
 546      "movb      %b2,(%1)\n\t"
 547      "leal      1(%1),%1\n\t"
 548      "testb     %b2,%b2\n\t"
 549      "jne       1b"
 550      : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy)
 551      : "0" (__src), "1" (__tmp)
 552      : "memory", "cc");
 553   return __dest;
 554 }
 555
 556
 557 #ifdef __USE_GNU
 558 # define _HAVE_STRING_ARCH_stpcpy 1
 559 /* Copy SRC to DEST.  */
 560 # define __stpcpy(dest, src) \
 561   (__extension__ (__builtin_constant_p (src)                                  \
 562                   ? (strlen (src) + 1 <= 8                                    \
 563                      ? __stpcpy_small (dest, src, strlen (src) + 1)           \
 564                      : __stpcpy_c (dest, src, strlen (src) + 1))              \
 565                   : __stpcpy_g (dest, src)))
 566 # define __stpcpy_c(dest, src, srclen) \
 567   ((srclen) % 4 == 0                                                          \
 568    ? __mempcpy_by4 (dest, src, srclen) - 1                                    \
 569    : ((srclen) % 2 == 0                                                       \
 570       ? __mempcpy_by2 (dest, src, srclen) - 1                                 \
 571       : __mempcpy_byn (dest, src, srclen) - 1))
 572
 573 /* In glibc itself we use this symbol for namespace reasons.  */
 574 # define stpcpy(dest, src) __stpcpy (dest, src)
 575
 576 # define __stpcpy_small(dest, src, srclen) \
 577   (__extension__ ({ unsigned char *__dest = (unsigned char *) (dest);         \
 578                     switch (srclen)                                           \
 579                       {                                                       \
 580                       case 1:                                                 \
 581                         *__dest = '\0';                                       \
 582                         break;                                                \
 583                       case 2:                                                 \
 584                         *((unsigned short int *) __dest) =                    \
 585                           __STRING_SMALL_GET16 (src, 0);                      \
 586                         ++__dest;                                             \
 587                         break;                                                \
 588                       case 3:                                                 \
 589                         *((unsigned short int *) __dest)++ =                  \
 590                           __STRING_SMALL_GET16 (src, 0);                      \
 591                         *__dest = '\0';                                       \
 592                         break;                                                \
 593                       case 4:                                                 \
 594                         *((unsigned int *) __dest) =                          \
 595                           __STRING_SMALL_GET32 (src, 0);                      \
 596                         __dest += 3;                                          \
 597                         break;                                                \
 598                       case 5:                                                 \
 599                         *((unsigned int *) __dest)++ =                        \
 600                           __STRING_SMALL_GET32 (src, 0);                      \
 601                         *__dest = '\0';                                       \
 602                         break;                                                \
 603                       case 6:                                                 \
 604                         *((unsigned int *) __dest) =                          \
 605                           __STRING_SMALL_GET32 (src, 0);                      \
 606                         *((unsigned short int *) (__dest + 4)) =              \
 607                           __STRING_SMALL_GET16 (src, 4);                      \
 608                         __dest += 5;                                          \
 609                         break;                                                \
 610                       case 7:                                                 \
 611                         *((unsigned int *) __dest) =                          \
 612                           __STRING_SMALL_GET32 (src, 0);                      \
 613                         *((unsigned short int *) (__dest + 4)) =              \
 614                           __STRING_SMALL_GET16 (src, 4);                      \
 615                         __dest += 6;                                          \
 616                         *__dest = '\0';                                       \
 617                         break;                                                \
 618                       case 8:                                                 \
 619                         *((unsigned int *) __dest) =                          \
 620                           __STRING_SMALL_GET32 (src, 0);                      \
 621                         *((unsigned int *) (__dest + 4)) =                    \
 622                           __STRING_SMALL_GET32 (src, 4);                      \
 623                         __dest += 7;                                          \
 624                         break;                                                \
 625                       }                                                       \
 626                     (char *) __dest; }))
 627
 628 __STRING_INLINE char *__mempcpy_by4 (char *__dest, __const char *__src,
 629                                      size_t __srclen);
 630
 631 __STRING_INLINE char *
 632 __mempcpy_by4 (char *__dest, __const char *__src, size_t __srclen)
 633 {
 634   register char *__tmp = __dest;
 635   register unsigned long int __d0, __d1;
 636   __asm__ __volatile__
 637     ("1:\n\t"
 638      "movl      (%2),%0\n\t"
 639      "leal      4(%2),%2\n\t"
 640      "movl      %0,(%1)\n\t"
 641      "leal      4(%1),%1\n\t"
 642      "decl      %3\n\t"
 643      "jnz       1b"
 644      : "=&r" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1)
 645      : "1" (__tmp), "2" (__src), "3" (__srclen / 4)
 646      : "memory", "cc");
 647   return __tmp;
 648 }
 649
 650 __STRING_INLINE char *__mempcpy_by2 (char *__dest, __const char *__src,
 651                                      size_t __srclen);
 652
 653 __STRING_INLINE char *
 654 __mempcpy_by2 (char *__dest, __const char *__src, size_t __srclen)
 655 {
 656   register char *__tmp = __dest;
 657   register unsigned long int __d0, __d1;
 658   __asm__ __volatile__
 659     ("shrl      $1,%3\n\t"
 660      "jz        2f\n"                 /* only a word */
 661      "1:\n\t"
 662      "movl      (%2),%0\n\t"
 663      "leal      4(%2),%2\n\t"
 664      "movl      %0,(%1)\n\t"
 665      "leal      4(%1),%1\n\t"
 666      "decl      %3\n\t"
 667      "jnz       1b\n"
 668      "2:\n\t"
 669      "movw      (%2),%w0\n\t"
 670      "movw      %w0,(%1)"
 671      : "=&q" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1)
 672      : "1" (__tmp), "2" (__src), "3" (__srclen / 2)
 673      : "memory", "cc");
 674   return __tmp + 2;
 675 }
 676
 677 __STRING_INLINE char *__mempcpy_byn (char *__dest, __const char *__src,
 678                                      size_t __srclen);
 679
 680 __STRING_INLINE char *
 681 __mempcpy_byn (char *__dest, __const char *__src, size_t __srclen)
 682 {
 683   register unsigned long __d0, __d1;
 684   register char *__tmp = __dest;
 685   __asm__ __volatile__
 686     ("cld\n\t"
 687      "shrl      $1,%%ecx\n\t"
 688      "jnc       1f\n\t"
 689      "movsb\n"
 690      "1:\n\t"
 691      "shrl      $1,%%ecx\n\t"
 692      "jnc       2f\n\t"
 693      "movsw\n"
 694      "2:\n\t"
 695      "rep; movsl"
 696      : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1)
 697      : "0" (__tmp), "1" (__srclen), "2" (__src)
 698      : "memory", "cc");
 699   return __tmp;
 700 }
 701
 702 __STRING_INLINE char *__stpcpy_g (char *__dest, __const char *__src);
 703
 704 __STRING_INLINE char *
 705 __stpcpy_g (char *__dest, __const char *__src)
 706 {
 707   register char *__tmp = __dest;
 708   register char __dummy;
 709   __asm__ __volatile__
 710     (
 711      "1:\n\t"
 712      "movb      (%0),%b2\n\t"
 713      "leal      1(%0),%0\n\t"
 714      "movb      %b2,(%1)\n\t"
 715      "leal      1(%1),%1\n\t"
 716      "testb     %b2,%b2\n\t"
 717      "jne       1b"
 718      : "=&r" (__src), "=r" (__tmp), "=&q" (__dummy)
 719      : "0" (__src), "1" (__tmp)
 720      : "memory", "cc");
 721   return __tmp - 1;
 722 }
 723 #endif
 724
 725
 726 /* Copy no more than N characters of SRC to DEST.  */
 727 #define _HAVE_STRING_ARCH_strncpy 1
 728 #define strncpy(dest, src, n) \
 729   (__extension__ (__builtin_constant_p (src)                                  \
 730                   ? ((strlen (src) + 1 >= ((size_t) (n))                      \
 731                       ? (char *) memcpy ((char *) dest,                       \
 732                                          (__const char *) src, n)             \
 733                       : __strncpy_cg (dest, src, strlen (src) + 1, n)))       \
 734                   : __strncpy_gg (dest, src, n)))
 735 #define __strncpy_cg(dest, src, srclen, n) \
 736   (((srclen) % 4 == 0)                                                        \
 737    ? __strncpy_by4 (dest, src, srclen, n)                                     \
 738    : (((srclen) % 2 == 0)                                                     \
 739       ? __strncpy_by2 (dest, src, srclen, n)                                  \
 740       : __strncpy_byn (dest, src, srclen, n)))
 741
 742 __STRING_INLINE char *__strncpy_by4 (char *__dest, __const char __src[],
 743                                      size_t __srclen, size_t __n);
 744
 745 __STRING_INLINE char *
 746 __strncpy_by4 (char *__dest, __const char __src[], size_t __srclen, size_t __n)
 747 {
 748   register char *__tmp = __dest;
 749   register int __dummy1, __dummy2;
 750   __asm__ __volatile__
 751     ("1:\n\t"
 752      "movl      (%2),%0\n\t"
 753      "leal      4(%2),%2\n\t"
 754      "movl      %0,(%1)\n\t"
 755      "leal      4(%1),%1\n\t"
 756      "decl      %3\n\t"
 757      "jnz       1b"
 758      : "=&r" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2)
 759      : "1" (__tmp), "2" (__src), "3" (__srclen / 4)
 760      : "memory", "cc");
 761   (void) memset (__tmp, '\0', __n - __srclen);
 762   return __dest;
 763 }
 764
 765 __STRING_INLINE char *__strncpy_by2 (char *__dest, __const char __src[],
 766                                      size_t __srclen, size_t __n);
 767
 768 __STRING_INLINE char *
 769 __strncpy_by2 (char *__dest, __const char __src[], size_t __srclen, size_t __n)
 770 {
 771   register char *__tmp = __dest;
 772   register int __dummy1, __dummy2;
 773   __asm__ __volatile__
 774     ("shrl      $1,%3\n\t"
 775      "jz        2f\n"                 /* only a word */
 776      "1:\n\t"
 777      "movl      (%2),%0\n\t"
 778      "leal      4(%2),%2\n\t"
 779      "movl      %0,(%1)\n\t"
 780      "leal      4(%1),%1\n\t"
 781      "decl      %3\n\t"
 782      "jnz       1b\n"
 783      "2:\n\t"
 784      "movw      (%2),%w0\n\t"
 785      "movw      %w0,(%1)\n\t"
 786      : "=&q" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2)
 787      : "1" (__tmp), "2" (__src), "3" (__srclen / 2)
 788      : "memory", "cc");
 789   (void) memset (__tmp + 2, '\0', __n - __srclen);
 790   return __dest;
 791 }
 792
 793 __STRING_INLINE char *__strncpy_byn (char *__dest, __const char __src[],
 794                                      size_t __srclen, size_t __n);
 795
 796 __STRING_INLINE char *
 797 __strncpy_byn (char *__dest, __const char __src[], size_t __srclen, size_t __n)
 798 {
 799   register unsigned long int __d0, __d1;
 800   register char *__tmp = __dest;
 801   __asm__ __volatile__
 802     ("cld\n\t"
 803      "shrl      $1,%1\n\t"
 804      "jnc       1f\n\t"
 805      "movsb\n"
 806      "1:\n\t"
 807      "shrl      $1,%1\n\t"
 808      "jnc       2f\n\t"
 809      "movsw\n"
 810      "2:\n\t"
 811      "rep; movsl"
 812      : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1)
 813      : "1" (__srclen), "0" (__tmp),"2" (__src)
 814      : "memory", "cc");
 815   (void) memset (__tmp, '\0', __n - __srclen);
 816   return __dest;
 817 }
 818
 819 __STRING_INLINE char *__strncpy_gg (char *__dest, __const char *__src,
 820                                     size_t __n);
 821
 822 __STRING_INLINE char *
 823 __strncpy_gg (char *__dest, __const char *__src, size_t __n)
 824 {
 825   register char *__tmp = __dest;
 826   register char __dummy;
 827   if (__n > 0)
 828     __asm__ __volatile__
 829       ("1:\n\t"
 830        "movb    (%0),%2\n\t"
 831        "incl    %0\n\t"
 832        "movb    %2,(%1)\n\t"
 833        "incl    %1\n\t"
 834        "decl    %3\n\t"
 835        "je      3f\n\t"
 836        "testb   %2,%2\n\t"
 837        "jne     1b\n\t"
 838        "2:\n\t"
 839        "movb    %2,(%1)\n\t"
 840        "incl    %1\n\t"
 841        "decl    %3\n\t"
 842        "jne     2b\n\t"
 843        "3:"
 844        : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy), "=&r" (__n)
 845        : "0" (__src), "1" (__tmp), "3" (__n)
 846        : "memory", "cc");
 847
 848   return __dest;
 849 }
 850
 851
 852 /* Append SRC onto DEST.  */
 853 #define _HAVE_STRING_ARCH_strcat 1
 854 #define strcat(dest, src) \
 855   (__extension__ (__builtin_constant_p (src)                                  \
 856                   ? __strcat_c (dest, src, strlen (src) + 1)                  \
 857                   : __strcat_g (dest, src)))
 858
 859 __STRING_INLINE char *__strcat_c (char *__dest, __const char __src[],
 860                                   size_t __srclen);
 861
 862 __STRING_INLINE char *
 863 __strcat_c (char *__dest, __const char __src[], size_t __srclen)
 864 {
 865 #ifdef __i686__
 866   register unsigned long int __d0;
 867   register char *__tmp;
 868   __asm__ __volatile__
 869     ("repne; scasb"
 870      : "=D" (__tmp), "=&c" (__d0)
 871      : "0" (__dest), "1" (0xffffffff), "a" (0)
 872      : "cc");
 873   --__tmp;
 874 #else
 875   register char *__tmp = __dest - 1;
 876   __asm__ __volatile__
 877     ("1:\n\t"
 878      "incl      %0\n\t"
 879      "cmpb      $0,(%0)\n\t"
 880      "jne       1b\n"
 881      : "=r" (__tmp)
 882      : "0" (__tmp)
 883      : "cc");
 884 #endif
 885   (void) memcpy (__tmp, __src, __srclen);
 886   return __dest;
 887 }
 888
 889 __STRING_INLINE char *__strcat_g (char *__dest, __const char *__src);
 890
 891 __STRING_INLINE char *
 892 __strcat_g (char *__dest, __const char *__src)
 893 {
 894   register char *__tmp = __dest - 1;
 895   register char __dummy;
 896   __asm__ __volatile__
 897     ("1:\n\t"
 898      "incl      %1\n\t"
 899      "cmpb      $0,(%1)\n\t"
 900      "jne       1b\n"
 901      "2:\n\t"
 902      "movb      (%2),%b0\n\t"
 903      "incl      %2\n\t"
 904      "movb      %b0,(%1)\n\t"
 905      "incl      %1\n\t"
 906      "testb     %b0,%b0\n\t"
 907      "jne       2b\n"
 908      : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src)
 909      : "1"  (__tmp), "2"  (__src)
 910      : "memory", "cc");
 911   return __dest;
 912 }
 913
 914
 915 /* Append no more than N characters from SRC onto DEST.  */
 916 #define _HAVE_STRING_ARCH_strncat 1
 917 #define strncat(dest, src, n) \
 918   (__extension__ ({ char *__dest = (dest);                                    \
 919                     __builtin_constant_p (src) && __builtin_constant_p (n)    \
 920                     ? (strlen (src) < ((size_t) (n))                          \
 921                        ? strcat (__dest, src)                                 \
 922                        : (memcpy (strchr (__dest, '\0'),                      \
 923                                   (__const char *) src, n), __dest))          \
 924                     : __strncat_g (__dest, src, n); }))
 925
 926 __STRING_INLINE char *__strncat_g (char *__dest, __const char __src[],
 927                                    size_t __n);
 928
 929 __STRING_INLINE char *
 930 __strncat_g (char *__dest, __const char __src[], size_t __n)
 931 {
 932   register char *__tmp = __dest;
 933   register char __dummy;
 934 #ifdef __i686__
 935   __asm__ __volatile__
 936     ("repne; scasb\n"
 937      "decl %1\n\t"
 938      "1:\n\t"
 939      "decl      %3\n\t"
 940      "js        2f\n\t"
 941      "movb      (%2),%b0\n\t"
 942      "movsb\n\t"
 943      "testb     %b0,%b0\n\t"
 944      "jne       1b\n\t"
 945      "decl      %1\n"
 946      "2:\n\t"
 947      "movb      $0,(%1)"
 948      : "=&a" (__dummy), "=&D" (__tmp), "=&S" (__src), "=&r" (__n)
 949      : "0" (0), "1" (__tmp), "2" (__src), "3" (__n)
 950      : "memory", "cc");
 951 #else
 952   --__tmp;
 953   __asm__ __volatile__
 954     ("1:\n\t"
 955      "cmpb      $0,1(%1)\n\t"
 956      "leal      1(%1),%1\n\t"
 957      "jne       1b\n"
 958      "2:\n\t"
 959      "decl      %3\n\t"
 960      "js        3f\n\t"
 961      "movb      (%2),%b0\n\t"
 962      "leal      1(%2),%2\n\t"
 963      "movb      %b0,(%1)\n\t"
 964      "leal      1(%1),%1\n\t"
 965      "testb     %b0,%b0\n\t"
 966      "jne       2b\n\t"
 967      "decl      %1\n"
 968      "3:\n\t"
 969      "movb      $0,(%1)"
 970      : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src), "=&r" (__n)
 971      : "1" (__tmp), "2" (__src), "3" (__n)
 972      : "memory", "cc");
 973 #endif
 974   return __dest;
 975 }
 976
 977
 978 /* Compare S1 and S2.  */
 979 #define _HAVE_STRING_ARCH_strcmp 1
 980 #define strcmp(s1, s2) \
 981   (__extension__ (__builtin_constant_p (s1) && __builtin_constant_p (s2)      \
 982                   && (sizeof ((s1)[0]) != 1 || strlen (s1) >= 4)              \
 983                   && (sizeof ((s2)[0]) != 1 || strlen (s2) >= 4)              \
 984                   ? memcmp ((__const char *) s1, (__const char *) s2,         \
 985                             (strlen (s1) < strlen (s2)                        \
 986                              ? strlen (s1) : strlen (s2)) + 1)                \
 987                   : (__builtin_constant_p (s1) && sizeof ((s1)[0]) == 1       \
 988                      && sizeof ((s2)[0]) == 1 && strlen (s1) < 4              \
 989                      ? (__builtin_constant_p (s2) && sizeof ((s2)[0]) == 1    \
 990                         ? __strcmp_cc (s1, s2, strlen (s1))                   \
 991                         : __strcmp_cg (s1, s2, strlen (s1)))                  \
 992                      : (__builtin_constant_p (s2) && sizeof ((s1)[0]) == 1    \
 993                         && sizeof ((s2)[0]) == 1 && strlen (s2) < 4           \
 994                         ? (__builtin_constant_p (s1)                          \
 995                            ? __strcmp_cc (s1, s2, strlen (s2))                \
 996                            : __strcmp_gc (s1, s2, strlen (s2)))               \
 997                         : __strcmp_gg (s1, s2)))))
 998
 999 #define __strcmp_cc(s1, s2, l) \
1000   (__extension__ ({ register int __result = ((unsigned char) (s1)[0]          \
1001                                              - (unsigned char) (s2)[0]);      \
1002                     if (l > 0 && __result == 0)                               \
1003                       {                                                       \
1004                         __result = ((unsigned char) (s1)[1]                   \
1005                                     - (unsigned char) (s2)[1]);               \
1006                         if (l > 1 && __result == 0)                           \
1007                           {                                                   \
1008                             __result = ((unsigned char) (s1)[2]               \
1009                                         - (unsigned char) (s2)[2]);           \
1010                             if (l > 2 && __result == 0)                       \
1011                               __result = ((unsigned char) (s1)[3]             \
1012                                           - (unsigned char) (s2)[3]);         \
1013                           }                                                   \
1014                       }                                                       \
1015                     __result; }))
1016
1017 #define __strcmp_cg(s1, s2, l1) \
1018   (__extension__ ({ __const unsigned char *__s2 = (unsigned char *) (s2);     \
1019                     register int __result = (unsigned char) (s1)[0] - __s2[0];\
1020                     if (l1 > 0 && __result == 0)                              \
1021                       {                                                       \
1022                         __result = (unsigned char) (s1)[1] - __s2[1];         \
1023                         if (l1 > 1 && __result == 0)                          \
1024                           {                                                   \
1025                             __result = (unsigned char) (s1)[2] - __s2[2];     \
1026                             if (l1 > 2 && __result == 0)                      \
1027                               __result = (unsigned char) (s1)[3] - __s2[3];   \
1028                           }                                                   \
1029                       }                                                       \
1030                     __result; }))
1031
1032 #define __strcmp_gc(s1, s2, l2) \
1033   (__extension__ ({ __const unsigned char *__s1 = (unsigned char *) (s1);     \
1034                     register int __result = __s1[0] - (unsigned char) (s2)[0];\
1035                     if (l2 > 0 && __result == 0)                              \
1036                       {                                                       \
1037                         __result = __s1[1] - (unsigned char) (s2)[1];         \
1038                         if (l2 > 1 && __result == 0)                          \
1039                           {                                                   \
1040                             __result = __s1[2] - (unsigned char) (s2)[2];     \
1041                             if (l2 > 2 && __result == 0)                      \
1042                               __result = __s1[3] - (unsigned char) (s2)[3];   \
1043                           }                                                   \
1044                       }                                                       \
1045                     __result; }))
1046
1047 __STRING_INLINE int __strcmp_gg (__const char *__s1, __const char *__s2);
1048
1049 __STRING_INLINE int
1050 __strcmp_gg (__const char *__s1, __const char *__s2)
1051 {
1052   register int __res;
1053   __asm__ __volatile__
1054     ("1:\n\t"
1055      "movb      (%1),%b0\n\t"
1056      "leal      1(%1),%1\n\t"
1057      "cmpb      %b0,(%2)\n\t"
1058      "jne       2f\n\t"
1059      "leal      1(%2),%2\n\t"
1060      "testb     %b0,%b0\n\t"
1061      "jne       1b\n\t"
1062      "xorl      %0,%0\n\t"
1063      "jmp       3f\n"
1064      "2:\n\t"
1065      "movl      $1,%0\n\t"
1066      "jb        3f\n\t"
1067      "negl      %0\n"
1068      "3:"
1069      : "=q" (__res), "=&r" (__s1), "=&r" (__s2)
1070      : "1" (__s1), "2" (__s2)
1071      : "cc");
1072   return __res;
1073 }
1074
1075
1076 /* Compare N characters of S1 and S2.  */
1077 #define _HAVE_STRING_ARCH_strncmp 1
1078 #define strncmp(s1, s2, n) \
1079   (__extension__ (__builtin_constant_p (s1) && strlen (s1) < ((size_t) (n))   \
1080                   ? strcmp (s1, s2)                                           \
1081                   : (__builtin_constant_p (s2) && strlen (s2) < ((size_t) (n))\
1082                      ? strcmp (s1, s2)                                        \
1083                      : __strncmp_g (s1, s2, n))))
1084
1085 __STRING_INLINE int __strncmp_g (__const char *__s1, __const char *__s2,
1086                                  size_t __n);
1087
1088 __STRING_INLINE int
1089 __strncmp_g (__const char *__s1, __const char *__s2, size_t __n)
1090 {
1091   register int __res;
1092   __asm__ __volatile__
1093     ("1:\n\t"
1094      "decl      %3\n\t"
1095      "js        2f\n\t"
1096      "movb      (%1),%b0\n\t"
1097      "incl      %1\n\t"
1098      "cmpb      %b0,(%2)\n\t"
1099      "jne       3f\n\t"
1100      "incl      %2\n\t"
1101      "testb     %b0,%b0\n\t"
1102      "jne       1b\n"
1103      "2:\n\t"
1104      "xorl      %0,%0\n\t"
1105      "jmp       4f\n"
1106      "3:\n\t"
1107      "movl      $1,%0\n\t"
1108      "jb        4f\n\t"
1109      "negl      %0\n"
1110      "4:"
1111      : "=q" (__res), "=&r" (__s1), "=&r" (__s2), "=&r" (__n)
1112      : "1"  (__s1), "2"  (__s2),  "3" (__n)
1113      : "cc");
1114   return __res;
1115 }
1116
1117
1118 /* Find the first occurrence of C in S.  */
1119 #define _HAVE_STRING_ARCH_strchr 1
1120 #define strchr(s, c) \
1121   (__extension__ (__builtin_constant_p (c)                                    \
1122                   ? ((c) == '\0'                                              \
1123                      ? (char *) __rawmemchr (s, c)                            \
1124                      : __strchr_c (s, ((c) & 0xff) << 8))                     \
1125                   : __strchr_g (s, c)))
1126
1127 __STRING_INLINE char *__strchr_c (__const char *__s, int __c);
1128
1129 __STRING_INLINE char *
1130 __strchr_c (__const char *__s, int __c)
1131 {
1132   register unsigned long int __d0;
1133   register char *__res;
1134   __asm__ __volatile__
1135     ("1:\n\t"
1136      "movb      (%0),%%al\n\t"
1137      "cmpb      %%ah,%%al\n\t"
1138      "je        2f\n\t"
1139      "leal      1(%0),%0\n\t"
1140      "testb     %%al,%%al\n\t"
1141      "jne       1b\n\t"
1142      "xorl      %0,%0\n"
1143      "2:"
1144      : "=r" (__res), "=&a" (__d0)
1145      : "0" (__s), "1" (__c)
1146      : "cc");
1147   return __res;
1148 }
1149
1150 __STRING_INLINE char *__strchr_g (__const char *__s, int __c);
1151
1152 __STRING_INLINE char *
1153 __strchr_g (__const char *__s, int __c)
1154 {
1155   register unsigned long int __d0;
1156   register char *__res;
1157   __asm__ __volatile__
1158     ("movb      %%al,%%ah\n"
1159      "1:\n\t"
1160      "movb      (%0),%%al\n\t"
1161      "cmpb      %%ah,%%al\n\t"
1162      "je        2f\n\t"
1163      "leal      1(%0),%0\n\t"
1164      "testb     %%al,%%al\n\t"
1165      "jne       1b\n\t"
1166      "xorl      %0,%0\n"
1167      "2:"
1168      : "=r" (__res), "=&a" (__d0)
1169      : "0" (__s), "1" (__c)
1170      : "cc");
1171   return __res;
1172 }
1173
1174
1175 /* Find the first occurrence of C in S or the final NUL byte.  */
1176 #define _HAVE_STRING_ARCH_strchrnul 1
1177 #define __strchrnul(s, c) \
1178   (__extension__ (__builtin_constant_p (c)                                    \
1179                   ? ((c) == '\0'                                              \
1180                      ? (char *) __rawmemchr (s, c)                            \
1181                      : __strchrnul_c (s, ((c) & 0xff) << 8))                  \
1182                   : __strchrnul_g (s, c)))
1183
1184 __STRING_INLINE char *__strchrnul_c (__const char *__s, int __c);
1185
1186 __STRING_INLINE char *
1187 __strchrnul_c (__const char *__s, int __c)
1188 {
1189   register unsigned long int __d0;
1190   register char *__res;
1191   __asm__ __volatile__
1192     ("1:\n\t"
1193      "movb      (%0),%%al\n\t"
1194      "cmpb      %%ah,%%al\n\t"
1195      "je        2f\n\t"
1196      "leal      1(%0),%0\n\t"
1197      "testb     %%al,%%al\n\t"
1198      "jne       1b\n\t"
1199      "decl      %0\n"
1200      "2:"
1201      : "=r" (__res), "=&a" (__d0)
1202      : "0" (__s), "1" (__c)
1203      : "cc");
1204   return __res;
1205 }
1206
1207 __STRING_INLINE char *__strchrnul_g (__const char *__s, int __c);
1208
1209 __STRING_INLINE char *
1210 __strchrnul_g (__const char *__s, int __c)
1211 {
1212   register unsigned long int __d0;
1213   register char *__res;
1214   __asm__ __volatile__
1215     ("movb      %%al,%%ah\n"
1216      "1:\n\t"
1217      "movb      (%0),%%al\n\t"
1218      "cmpb      %%ah,%%al\n\t"
1219      "je        2f\n\t"
1220      "leal      1(%0),%0\n\t"
1221      "testb     %%al,%%al\n\t"
1222      "jne       1b\n\t"
1223      "decl      %0\n"
1224      "2:"
1225      : "=r" (__res), "=&a" (__d0)
1226      : "0" (__s), "1" (__c)
1227      : "cc");
1228   return __res;
1229 }
1230 #ifdef __USE_GNU
1231 # define strchrnul(s, c) __strchrnul (s, c)
1232 #endif
1233
1234
1235 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1236 /* Find the first occurrence of C in S.  This is the BSD name.  */
1237 # define _HAVE_STRING_ARCH_index 1
1238 # define index(s, c) \
1239   (__extension__ (__builtin_constant_p (c)                                    \
1240                   ? __strchr_c (s, ((c) & 0xff) << 8)                         \
1241                   : __strchr_g (s, c)))
1242 #endif
1243
1244
1245 /* Find the last occurrence of C in S.  */
1246 #define _HAVE_STRING_ARCH_strrchr 1
1247 #define strrchr(s, c) \
1248   (__extension__ (__builtin_constant_p (c)                                    \
1249                   ? __strrchr_c (s, ((c) & 0xff) << 8)                        \
1250                   : __strrchr_g (s, c)))
1251
1252 #ifdef __i686__
1253 __STRING_INLINE char *__strrchr_c (__const char *__s, int __c);
1254
1255 __STRING_INLINE char *
1256 __strrchr_c (__const char *__s, int __c)
1257 {
1258   register unsigned long int __d0, __d1;
1259   register char *__res;
1260   __asm__ __volatile__
1261     ("cld\n"
1262      "1:\n\t"
1263      "lodsb\n\t"
1264      "cmpb      %h2,%b2\n\t"
1265      "cmove     %1,%0\n\t"
1266      "testb     %b2,%b2\n\t"
1267      "jne 1b"
1268      : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
1269      : "0" (1), "1" (__s), "2" (__c)
1270      : "cc");
1271   return __res - 1;
1272 }
1273
1274 __STRING_INLINE char *__strrchr_g (__const char *__s, int __c);
1275
1276 __STRING_INLINE char *
1277 __strrchr_g (__const char *__s, int __c)
1278 {
1279   register unsigned long int __d0, __d1;
1280   register char *__res;
1281   __asm__ __volatile__
1282     ("movb      %b2,%h2\n"
1283      "cld\n\t"
1284      "1:\n\t"
1285      "lodsb\n\t"
1286      "cmpb      %h2,%b2\n\t"
1287      "cmove     %1,%0\n\t"
1288      "testb     %b2,%b2\n\t"
1289      "jne 1b"
1290      : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
1291      : "0" (1), "1" (__s), "2" (__c)
1292      : "cc");
1293   return __res - 1;
1294 }
1295 #else
1296 __STRING_INLINE char *__strrchr_c (__const char *__s, int __c);
1297
1298 __STRING_INLINE char *
1299 __strrchr_c (__const char *__s, int __c)
1300 {
1301   register unsigned long int __d0, __d1;
1302   register char *__res;
1303   __asm__ __volatile__
1304     ("cld\n"
1305      "1:\n\t"
1306      "lodsb\n\t"
1307      "cmpb      %%ah,%%al\n\t"
1308      "jne       2f\n\t"
1309      "leal      -1(%%esi),%0\n"
1310      "2:\n\t"
1311      "testb     %%al,%%al\n\t"
1312      "jne 1b"
1313      : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
1314      : "0" (0), "1" (__s), "2" (__c)
1315      : "cc");
1316   return __res;
1317 }
1318
1319 __STRING_INLINE char *__strrchr_g (__const char *__s, int __c);
1320
1321 __STRING_INLINE char *
1322 __strrchr_g (__const char *__s, int __c)
1323 {
1324   register unsigned long int __d0, __d1;
1325   register char *__res;
1326   __asm__ __volatile__
1327     ("movb      %%al,%%ah\n"
1328      "cld\n\t"
1329      "1:\n\t"
1330      "lodsb\n\t"
1331      "cmpb      %%ah,%%al\n\t"
1332      "jne       2f\n\t"
1333      "leal      -1(%%esi),%0\n"
1334      "2:\n\t"
1335      "testb     %%al,%%al\n\t"
1336      "jne 1b"
1337      : "=r" (__res), "=&S" (__d0), "=&a" (__d1)
1338      : "0" (0), "1" (__s), "2" (__c)
1339      : "cc");
1340   return __res;
1341 }
1342 #endif
1343
1344
1345 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1346 /* Find the last occurrence of C in S.  This is the BSD name.  */
1347 # define _HAVE_STRING_ARCH_rindex 1
1348 # define rindex(s, c) \
1349   (__extension__ (__builtin_constant_p (c)                                    \
1350                   ? __strrchr_c (s, ((c) & 0xff) << 8)                        \
1351                   : __strrchr_g (s, c)))
1352 #endif
1353
1354
1355 /* Return the length of the initial segment of S which
1356    consists entirely of characters not in REJECT.  */
1357 #define _HAVE_STRING_ARCH_strcspn 1
1358 #define strcspn(s, reject) \
1359   (__extension__ (__builtin_constant_p (reject) && sizeof ((reject)[0]) == 1  \
1360                   ? ((reject)[0] == '\0'                                      \
1361                      ? strlen (s)                                             \
1362                      : ((reject)[1] == '\0'                                   \
1363                         ? __strcspn_c1 (s, (((reject)[0] << 8) & 0xff00))     \
1364                         : __strcspn_cg (s, reject, strlen (reject))))         \
1365                   : __strcspn_g (s, reject)))
1366
1367 __STRING_INLINE size_t __strcspn_c1 (__const char *__s, int __reject);
1368
1369 __STRING_INLINE size_t
1370 __strcspn_c1 (__const char *__s, int __reject)
1371 {
1372   register unsigned long int __d0;
1373   register char *__res;
1374   __asm__ __volatile__
1375     ("1:\n\t"
1376      "movb      (%0),%%al\n\t"
1377      "leal      1(%0),%0\n\t"
1378      "cmpb      %%ah,%%al\n\t"
1379      "je        2f\n\t"
1380      "testb     %%al,%%al\n\t"
1381      "jne       1b\n"
1382      "2:"
1383      : "=r" (__res), "=&a" (__d0)
1384      : "0" (__s), "1" (__reject)
1385      : "cc");
1386   return (__res - 1) - __s;
1387 }
1388
1389 __STRING_INLINE size_t __strcspn_cg (__const char *__s, __const char __reject[],
1390                                     size_t __reject_len);
1391
1392 __STRING_INLINE size_t
1393 __strcspn_cg (__const char *__s, __const char __reject[], size_t __reject_len)
1394 {
1395   register unsigned long int __d0, __d1, __d2;
1396   register __const char *__res;
1397   __asm__ __volatile__
1398     ("cld\n"
1399      "1:\n\t"
1400      "lodsb\n\t"
1401      "testb     %%al,%%al\n\t"
1402      "je        2f\n\t"
1403      "movl      %5,%%edi\n\t"
1404      "movl      %6,%%ecx\n\t"
1405      "repne; scasb\n\t"
1406      "jne       1b\n"
1407      "2:"
1408      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1409      : "0" (__s), "d" (__reject), "g" (__reject_len)
1410      : "cc");
1411   return (__res - 1) - __s;
1412 }
1413
1414 __STRING_INLINE size_t __strcspn_g (__const char *__s, __const char *__reject);
1415 #ifdef __PIC__
1416
1417 __STRING_INLINE size_t
1418 __strcspn_g (__const char *__s, __const char *__reject)
1419 {
1420   register unsigned long int __d0, __d1, __d2;
1421   register __const char *__res;
1422   __asm__ __volatile__
1423     ("pushl     %%ebx\n\t"
1424      "movl      %4,%%edi\n\t"
1425      "cld\n\t"
1426      "repne; scasb\n\t"
1427      "notl      %%ecx\n\t"
1428      "leal      -1(%%ecx),%%ebx\n"
1429      "1:\n\t"
1430      "lodsb\n\t"
1431      "testb     %%al,%%al\n\t"
1432      "je        2f\n\t"
1433      "movl      %4,%%edi\n\t"
1434      "movl      %%ebx,%%ecx\n\t"
1435      "repne; scasb\n\t"
1436      "jne       1b\n"
1437      "2:\n\t"
1438      "popl      %%ebx"
1439      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1440      : "r" (__reject), "0" (__s), "1" (0), "2" (0xffffffff)
1441      : "cc");
1442   return (__res - 1) - __s;
1443 }
1444 #else
1445 __STRING_INLINE size_t
1446 __strcspn_g (__const char *__s, __const char *__reject)
1447 {
1448   register unsigned long int __d0, __d1, __d2, __d3;
1449   register __const char *__res;
1450   __asm__ __volatile__
1451     ("cld\n\t"
1452      "repne; scasb\n\t"
1453      "notl      %%ecx\n\t"
1454      "leal      -1(%%ecx),%%edx\n"
1455      "1:\n\t"
1456      "lodsb\n\t"
1457      "testb     %%al,%%al\n\t"
1458      "je        2f\n\t"
1459      "movl      %%ebx,%%edi\n\t"
1460      "movl      %%edx,%%ecx\n\t"
1461      "repne; scasb\n\t"
1462      "jne       1b\n"
1463      "2:"
1464      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3)
1465      : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__reject), "b" (__reject)
1466      : "cc");
1467   return (__res - 1) - __s;
1468 }
1469 #endif
1470
1471
1472 /* Return the length of the initial segment of S which
1473    consists entirely of characters in ACCEPT.  */
1474 #define _HAVE_STRING_ARCH_strspn 1
1475 #define strspn(s, accept) \
1476   (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1  \
1477                   ? ((accept)[0] == '\0'                                      \
1478                      ? 0                                                      \
1479                      : ((accept)[1] == '\0'                                   \
1480                         ? __strspn_c1 (s, (((accept)[0] << 8 ) & 0xff00))     \
1481                         : __strspn_cg (s, accept, strlen (accept))))          \
1482                   : __strspn_g (s, accept)))
1483
1484 __STRING_INLINE size_t __strspn_c1 (__const char *__s, int __accept);
1485
1486 __STRING_INLINE size_t
1487 __strspn_c1 (__const char *__s, int __accept)
1488 {
1489   register unsigned long int __d0;
1490   register char *__res;
1491   /* Please note that __accept never can be '\0'.  */
1492   __asm__ __volatile__
1493     ("1:\n\t"
1494      "movb      (%0),%b1\n\t"
1495      "leal      1(%0),%0\n\t"
1496      "cmpb      %h1,%b1\n\t"
1497      "je        1b"
1498      : "=r" (__res), "=&q" (__d0)
1499      : "0" (__s), "1" (__accept)
1500      : "cc");
1501   return (__res - 1) - __s;
1502 }
1503
1504 __STRING_INLINE size_t __strspn_cg (__const char *__s, __const char __accept[],
1505                                     size_t __accept_len);
1506
1507 __STRING_INLINE size_t
1508 __strspn_cg (__const char *__s, __const char __accept[], size_t __accept_len)
1509 {
1510   register unsigned long int __d0, __d1, __d2;
1511   register __const char *__res;
1512   __asm__ __volatile__
1513     ("cld\n"
1514      "1:\n\t"
1515      "lodsb\n\t"
1516      "testb     %%al,%%al\n\t"
1517      "je        2f\n\t"
1518      "movl      %1,%%edi\n\t"
1519      "movl      %6,%%ecx\n\t"
1520      "repne; scasb\n\t"
1521      "je        1b\n"
1522      "2:"
1523      : "=S" (__res), "=&d" (__d0), "=&c" (__d1), "=&D" (__d2)
1524      : "0" (__s), "1" (__accept), "g" (__accept_len)
1525      : "cc");
1526   return (__res - 1) - __s;
1527 }
1528
1529 __STRING_INLINE size_t __strspn_g (__const char *__s, __const char *__accept);
1530 #ifdef __PIC__
1531
1532 __STRING_INLINE size_t
1533 __strspn_g (__const char *__s, __const char *__accept)
1534 {
1535   register unsigned long int __d0, __d1, __d2;
1536   register __const char *__res;
1537   __asm__ __volatile__
1538     ("pushl     %%ebx\n\t"
1539      "cld\n\t"
1540      "repne; scasb\n\t"
1541      "notl      %%ecx\n\t"
1542      "leal      -1(%%ecx),%%ebx\n"
1543      "1:\n\t"
1544      "lodsb\n\t"
1545      "testb     %%al,%%al\n\t"
1546      "je        2f\n\t"
1547      "movl      %%edx,%%edi\n\t"
1548      "movl      %%ebx,%%ecx\n\t"
1549      "repne; scasb\n\t"
1550      "je        1b\n"
1551      "2:\n\t"
1552      "popl      %%ebx"
1553      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1554      : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept)
1555      : "cc");
1556   return (__res - 1) - __s;
1557 }
1558 #else
1559 __STRING_INLINE size_t
1560 __strspn_g (__const char *__s, __const char *__accept)
1561 {
1562   register unsigned long int __d0, __d1, __d2, __d3;
1563   register __const char *__res;
1564   __asm__ __volatile__
1565     ("cld\n\t"
1566      "repne; scasb\n\t"
1567      "notl      %%ecx\n\t"
1568      "leal      -1(%%ecx),%%edx\n"
1569      "1:\n\t"
1570      "lodsb\n\t"
1571      "testb     %%al,%%al\n\t"
1572      "je        2f\n\t"
1573      "movl      %%ebx,%%edi\n\t"
1574      "movl      %%edx,%%ecx\n\t"
1575      "repne; scasb\n\t"
1576      "je        1b\n"
1577      "2:"
1578      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3)
1579      : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept), "b" (__accept)
1580      : "cc");
1581   return (__res - 1) - __s;
1582 }
1583 #endif
1584
1585
1586 /* Find the first occurrence in S of any character in ACCEPT.  */
1587 #define _HAVE_STRING_ARCH_strpbrk 1
1588 #define strpbrk(s, accept) \
1589   (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1  \
1590                   ? ((accept)[0] == '\0'                                      \
1591                      ? NULL                                                   \
1592                      : ((accept)[1] == '\0'                                   \
1593                         ? strchr (s, (accept)[0])                             \
1594                         : __strpbrk_cg (s, accept, strlen (accept))))         \
1595                   : __strpbrk_g (s, accept)))
1596
1597 __STRING_INLINE char *__strpbrk_cg (__const char *__s, __const char __accept[],
1598                                     size_t __accept_len);
1599
1600 __STRING_INLINE char *
1601 __strpbrk_cg (__const char *__s, __const char __accept[], size_t __accept_len)
1602 {
1603   register unsigned long int __d0, __d1, __d2;
1604   register char *__res;
1605   __asm__ __volatile__
1606     ("cld\n"
1607      "1:\n\t"
1608      "lodsb\n\t"
1609      "testb     %%al,%%al\n\t"
1610      "je        2f\n\t"
1611      "movl      %5,%%edi\n\t"
1612      "movl      %6,%%ecx\n\t"
1613      "repne; scasb\n\t"
1614      "jne       1b\n\t"
1615      "decl      %0\n\t"
1616      "jmp       3f\n"
1617      "2:\n\t"
1618      "xorl      %0,%0\n"
1619      "3:"
1620      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1621      : "0" (__s), "d" (__accept), "g" (__accept_len)
1622      : "cc");
1623   return __res;
1624 }
1625
1626 __STRING_INLINE char *__strpbrk_g (__const char *__s, __const char *__accept);
1627 #ifdef __PIC__
1628
1629 __STRING_INLINE char *
1630 __strpbrk_g (__const char *__s, __const char *__accept)
1631 {
1632   register unsigned long int __d0, __d1, __d2;
1633   register char *__res;
1634   __asm__ __volatile__
1635     ("pushl     %%ebx\n\t"
1636      "movl      %%edx,%%edi\n\t"
1637      "cld\n\t"
1638      "repne; scasb\n\t"
1639      "notl      %%ecx\n\t"
1640      "leal      -1(%%ecx),%%ebx\n"
1641      "1:\n\t"
1642      "lodsb\n\t"
1643      "testb     %%al,%%al\n\t"
1644      "je        2f\n\t"
1645      "movl      %%edx,%%edi\n\t"
1646      "movl      %%ebx,%%ecx\n\t"
1647      "repne; scasb\n\t"
1648      "jne       1b\n\t"
1649      "decl      %0\n\t"
1650      "jmp       3f\n"
1651      "2:\n\t"
1652      "xorl      %0,%0\n"
1653      "3:\n\t"
1654      "popl      %%ebx"
1655      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
1656      : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff)
1657      : "cc");
1658   return __res;
1659 }
1660 #else
1661 __STRING_INLINE char *
1662 __strpbrk_g (__const char *__s, __const char *__accept)
1663 {
1664   register unsigned long int __d0, __d1, __d2, __d3;
1665   register char *__res;
1666   __asm__ __volatile__
1667     ("movl      %%ebx,%%edi\n\t"
1668      "cld\n\t"
1669      "repne; scasb\n\t"
1670      "notl      %%ecx\n\t"
1671      "leal      -1(%%ecx),%%edx\n"
1672      "1:\n\t"
1673      "lodsb\n\t"
1674      "testb     %%al,%%al\n\t"
1675      "je        2f\n\t"
1676      "movl      %%ebx,%%edi\n\t"
1677      "movl      %%edx,%%ecx\n\t"
1678      "repne; scasb\n\t"
1679      "jne       1b\n\t"
1680      "decl      %0\n\t"
1681      "jmp       3f\n"
1682      "2:\n\t"
1683      "xorl      %0,%0\n"
1684      "3:"
1685      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&d" (__d2), "=&D" (__d3)
1686      : "0" (__s), "1" (0), "2" (0xffffffff), "b" (__accept)
1687      : "cc");
1688   return __res;
1689 }
1690 #endif
1691
1692
1693 /* Find the first occurrence of NEEDLE in HAYSTACK.  */
1694 #define _HAVE_STRING_ARCH_strstr 1
1695 #define strstr(haystack, needle) \
1696   (__extension__ (__builtin_constant_p (needle) && sizeof ((needle)[0]) == 1  \
1697                   ? ((needle)[0] == '\0'                                      \
1698                      ? haystack                                               \
1699                      : ((needle)[1] == '\0'                                   \
1700                         ? strchr (haystack, (needle)[0])                      \
1701                         : __strstr_cg (haystack, needle, strlen (needle))))   \
1702                   : __strstr_g (haystack, needle)))
1703
1704 /* Please note that this function need not handle NEEDLEs with a
1705    length shorter than two.  */
1706 __STRING_INLINE char *__strstr_cg (__const char *__haystack, __const char __needle[],
1707                                    size_t __needle_len);
1708
1709 __STRING_INLINE char *
1710 __strstr_cg (__const char *__haystack, __const char __needle[],
1711              size_t __needle_len)
1712 {
1713   register unsigned long int __d0, __d1, __d2;
1714   register char *__res;
1715   __asm__ __volatile__
1716     ("cld\n" \
1717      "1:\n\t"
1718      "movl      %6,%%edi\n\t"
1719      "movl      %5,%%eax\n\t"
1720      "movl      %4,%%ecx\n\t"
1721      "repe; cmpsb\n\t"
1722      "je        2f\n\t"
1723      "cmpb      $0,-1(%%esi)\n\t"
1724      "leal      1(%%eax),%5\n\t"
1725      "jne       1b\n\t"
1726      "xorl      %%eax,%%eax\n"
1727      "2:"
1728      : "=a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2)
1729      : "g" (__needle_len), "1" (__haystack), "d" (__needle)
1730      : "cc");
1731   return __res;
1732 }
1733
1734 __STRING_INLINE char *__strstr_g (__const char *__haystack, __const char *__needle);
1735 #ifdef __PIC__
1736
1737 __STRING_INLINE char *
1738 __strstr_g (__const char *__haystack, __const char *__needle)
1739 {
1740   register unsigned long int __d0, __d1, __d2;
1741   register char *__res;
1742   __asm__ __volatile__
1743     ("cld\n\t"
1744      "repne; scasb\n\t"
1745      "notl      %%ecx\n\t"
1746      "pushl     %%ebx\n\t"
1747      "decl      %%ecx\n\t"      /* NOTE! This also sets Z if searchstring='' */
1748      "movl      %%ecx,%%ebx\n"
1749      "1:\n\t"
1750      "movl      %%edx,%%edi\n\t"
1751      "movl      %%esi,%%eax\n\t"
1752      "movl      %%ebx,%%ecx\n\t"
1753      "repe; cmpsb\n\t"
1754      "je        2f\n\t"         /* also works for empty string, see above */
1755      "cmpb      $0,-1(%%esi)\n\t"
1756      "leal      1(%%eax),%%esi\n\t"
1757      "jne       1b\n\t"
1758      "xorl      %%eax,%%eax\n"
1759      "2:\n\t"
1760      "popl      %%ebx"
1761      : "=a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
1762      : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle),
1763        "d" (__needle)
1764      : "cc");
1765   return __res;
1766 }
1767 #else
1768 __STRING_INLINE char *
1769 __strstr_g (__const char *__haystack, __const char *__needle)
1770 {
1771   register unsigned long int __d0, __d1, __d2, __d3;
1772   register char *__res;
1773   __asm__ __volatile__
1774     ("cld\n\t"
1775      "repne; scasb\n\t"
1776      "notl      %%ecx\n\t"
1777      "decl      %%ecx\n\t"      /* NOTE! This also sets Z if searchstring='' */
1778      "movl      %%ecx,%%edx\n"
1779      "1:\n\t"
1780      "movl      %%ebx,%%edi\n\t"
1781      "movl      %%esi,%%eax\n\t"
1782      "movl      %%edx,%%ecx\n\t"
1783      "repe; cmpsb\n\t"
1784      "je        2f\n\t"         /* also works for empty string, see above */
1785      "cmpb      $0,-1(%%esi)\n\t"
1786      "leal      1(%%eax),%%esi\n\t"
1787      "jne       1b\n\t"
1788      "xorl      %%eax,%%eax\n"
1789      "2:"
1790      : "=a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2), "=&d" (__d3)
1791      : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle),
1792        "b" (__needle)
1793      : "cc");
1794   return __res;
1795 }
1796 #endif
1797
1798
1799 /* Bit find functions.  We define only the i686 version since for the other
1800    processors gcc generates good code.  */
1801 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1802 # ifdef __i686__
1803 #  define _HAVE_STRING_ARCH_ffs 1
1804 #  define ffs(word) (__builtin_constant_p (word)                              \
1805                      ? __builtin_ffs (word)                                   \
1806                      : ({ int __cnt, __tmp;                                   \
1807                           __asm__ __volatile__                                \
1808                             ("bsfl %2,%0\n\t"                                 \
1809                              "cmovel %1,%0"                                   \
1810                              : "=&r" (__cnt), "=r" (__tmp)                    \
1811                              : "rm" (word), "1" (-1));                        \
1812                           __cnt + 1; }))
1813
1814 #  ifndef ffsl
1815 #   define ffsl(word) ffs(word)
1816 #  endif
1817 # endif /* i686 */
1818 #endif  /* BSD || X/Open */
1819
1820 #undef __STRING_INLINE
1821
1822 #endif  /* use string inlines && GNU CC */