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