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