(__memset_ccn_by4): Loosen restrictions on first parameter of non-i686 version.
[kopensolaris-gnu/glibc.git] / 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 */