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