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