1 /* Optimized, inlined string functions. i486 version.
2 Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2004,2007
3 Free Software Foundation, Inc.
4 This file is part of the GNU C Library.
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.
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.
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
22 # error "Never use <bits/string.h> directly; include <string.h> instead."
25 /* The ix86 processors can access unaligned multi-byte variables. */
26 #define _STRING_ARCH_unaligned 1
29 /* We only provide optimizations if the user selects them and if
31 #if !defined __NO_STRING_INLINES && defined __USE_STRING_INLINES \
32 && defined __GNUC__ && __GNUC__ >= 2 && !__BOUNDED_POINTERS__
34 #ifndef __STRING_INLINE
35 # ifndef __extern_inline
36 # define __STRING_INLINE inline
38 # define __STRING_INLINE __extern_inline
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])
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) \
63 ? __memcpy_by4 (dest, src, n) \
65 ? __memcpy_by2 (dest, src, n) \
66 : __memcpy_g (dest, src, n))))
68 __STRING_INLINE
void *__memcpy_by4 (void *__dest
, __const
void *__src
,
71 __STRING_INLINE
void *
72 __memcpy_by4 (void *__dest
, __const
void *__src
, size_t __n
)
74 register unsigned long int __d0
, __d1
;
75 register void *__tmp
= __dest
;
84 : "=&r" (__d0
), "=&r" (__tmp
), "=&r" (__src
), "=&r" (__d1
)
85 : "1" (__tmp
), "2" (__src
), "3" (__n
/ 4)
90 __STRING_INLINE
void *__memcpy_by2 (void *__dest
, __const
void *__src
,
93 __STRING_INLINE
void *
94 __memcpy_by2 (void *__dest
, __const
void *__src
, size_t __n
)
96 register unsigned long int __d0
, __d1
;
97 register void *__tmp
= __dest
;
100 "jz 2f\n" /* only a word */
111 : "=&q" (__d0
), "=&r" (__tmp
), "=&r" (__src
), "=&r" (__d1
)
112 : "1" (__tmp
), "2" (__src
), "3" (__n
/ 2)
117 __STRING_INLINE
void *__memcpy_g (void *__dest
, __const
void *__src
,
120 __STRING_INLINE
void *
121 __memcpy_g (void *__dest
, __const
void *__src
, size_t __n
)
123 register unsigned long int __d0
, __d1
, __d2
;
124 register void *__tmp
= __dest
;
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
)
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 #define memmove(dest, src, n) __memmove_g (dest, src, n)
150 __STRING_INLINE
void *__memmove_g (void *, __const
void *, size_t)
153 __STRING_INLINE
void *
154 __memmove_g (void *__dest
, __const
void *__src
, size_t __n
)
156 register unsigned long int __d0
, __d1
, __d2
;
157 register void *__tmp
= __dest
;
162 : "=&c" (__d0
), "=&S" (__d1
), "=&D" (__d2
),
163 "=m" ( *(struct { __extension__
char __x
[__n
]; } *)__dest
)
164 : "0" (__n
), "1" (__src
), "2" (__tmp
),
165 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__src
));
171 : "=&c" (__d0
), "=&S" (__d1
), "=&D" (__d2
),
172 "=m" ( *(struct { __extension__
char __x
[__n
]; } *)__dest
)
173 : "0" (__n
), "1" (__n
- 1 + (__const
char *) __src
),
174 "2" (__n
- 1 + (char *) __tmp
),
175 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__src
));
180 /* Compare N bytes of S1 and S2. */
181 #define _HAVE_STRING_ARCH_memcmp 1
182 #ifndef _FORCE_INLINES
184 /* gcc has problems to spill registers when using PIC. */
186 memcmp (__const
void *__s1
, __const
void *__s2
, size_t __n
)
188 register unsigned long int __d0
, __d1
, __d2
;
198 : "=&a" (__res
), "=&S" (__d0
), "=&D" (__d1
), "=&c" (__d2
)
199 : "0" (0), "1" (__s1
), "2" (__s2
), "3" (__n
),
200 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__s1
),
201 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__s2
)
208 /* Set N bytes of S to C. */
209 #define _HAVE_STRING_ARCH_memset 1
210 #define _USE_STRING_ARCH_memset 1
211 #define memset(s, c, n) \
212 (__extension__ (__builtin_constant_p (n) && (n) <= 16 \
214 ? __memset_c1 ((s), (c)) \
215 : __memset_gc ((s), (c), (n))) \
216 : (__builtin_constant_p (c) \
217 ? (__builtin_constant_p (n) \
218 ? __memset_ccn ((s), (c), (n)) \
219 : memset ((s), (c), (n))) \
220 : (__builtin_constant_p (n) \
221 ? __memset_gcn ((s), (c), (n)) \
222 : memset ((s), (c), (n))))))
224 #define __memset_c1(s, c) ({ void *__s = (s); \
225 *((unsigned char *) __s) = (unsigned char) (c); \
228 #define __memset_gc(s, c, n) \
229 ({ void *__s = (s); \
232 unsigned short int __usi; \
233 unsigned char __uc; \
235 unsigned int __c = ((unsigned int) ((unsigned char) (c))) * 0x01010101; \
237 /* We apply a trick here. `gcc' would implement the following \
238 assignments using immediate operands. But this uses to much \
239 memory (7, instead of 4 bytes). So we force the value in a \
241 if ((n) == 3 || (n) >= 5) \
242 __asm__ __volatile__ ("" : "=r" (__c) : "0" (__c)); \
244 /* This `switch' statement will be removed at compile-time. */ \
249 __u = __extension__ ((void *) __u + 4); \
252 __u = __extension__ ((void *) __u + 4); \
255 __u = __extension__ ((void *) __u + 4); \
257 __u->__usi = (unsigned short int) __c; \
258 __u = __extension__ ((void *) __u + 2); \
259 __u->__uc = (unsigned char) __c; \
264 __u = __extension__ ((void *) __u + 4); \
267 __u = __extension__ ((void *) __u + 4); \
270 __u = __extension__ ((void *) __u + 4); \
272 __u->__usi = (unsigned short int) __c; \
277 __u = __extension__ ((void *) __u + 4); \
280 __u = __extension__ ((void *) __u + 4); \
283 __u = __extension__ ((void *) __u + 4); \
285 __u->__uc = (unsigned char) __c; \
290 __u = __extension__ ((void *) __u + 4); \
293 __u = __extension__ ((void *) __u + 4); \
296 __u = __extension__ ((void *) __u + 4); \
305 #define __memset_ccn(s, c, n) \
307 ? __memset_ccn_by4 (s, ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
310 ? __memset_ccn_by2 (s, \
311 ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
315 __STRING_INLINE
void *__memset_ccn_by4 (void *__s
, unsigned int __c
,
318 __STRING_INLINE
void *
319 __memset_ccn_by4 (void *__s
, unsigned int __c
, size_t __n
)
321 register void *__tmp
= __s
;
322 register unsigned long int __d0
;
327 : "=&a" (__c
), "=&D" (__tmp
), "=&c" (__d0
),
328 "=m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
329 : "0" ((unsigned int) __c
), "1" (__tmp
), "2" (__n
/ 4)
338 : "=&r" (__c
), "=&r" (__tmp
), "=&r" (__d0
),
339 "=m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
340 : "0" ((unsigned int) __c
), "1" (__tmp
), "2" (__n
/ 4)
346 __STRING_INLINE
void *__memset_ccn_by2 (void *__s
, unsigned int __c
,
349 __STRING_INLINE
void *
350 __memset_ccn_by2 (void *__s
, unsigned int __c
, size_t __n
)
352 register unsigned long int __d0
, __d1
;
353 register void *__tmp
= __s
;
359 : "=&a" (__d0
), "=&D" (__tmp
), "=&c" (__d1
),
360 "=m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
361 : "0" ((unsigned int) __c
), "1" (__tmp
), "2" (__n
/ 4)
365 ("1:\tmovl %0,(%1)\n\t"
370 : "=&q" (__d0
), "=&r" (__tmp
), "=&r" (__d1
),
371 "=m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
372 : "0" ((unsigned int) __c
), "1" (__tmp
), "2" (__n
/ 4)
378 #define __memset_gcn(s, c, n) \
380 ? __memset_gcn_by4 (s, c, n) \
382 ? __memset_gcn_by2 (s, c, n) \
385 __STRING_INLINE
void *__memset_gcn_by4 (void *__s
, int __c
, size_t __n
);
387 __STRING_INLINE
void *
388 __memset_gcn_by4 (void *__s
, int __c
, size_t __n
)
390 register void *__tmp
= __s
;
391 register unsigned long int __d0
;
402 : "=&q" (__c
), "=&r" (__tmp
), "=&r" (__d0
),
403 "=m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
404 : "0" ((unsigned int) __c
), "1" (__tmp
), "2" (__n
/ 4)
409 __STRING_INLINE
void *__memset_gcn_by2 (void *__s
, int __c
, size_t __n
);
411 __STRING_INLINE
void *
412 __memset_gcn_by2 (void *__s
, int __c
, size_t __n
)
414 register unsigned long int __d0
, __d1
;
415 register void *__tmp
= __s
;
427 : "=&q" (__d0
), "=&r" (__tmp
), "=&r" (__d1
),
428 "=m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
429 : "0" ((unsigned int) __c
), "1" (__tmp
), "2" (__n
/ 4)
435 /* Search N bytes of S for C. */
436 #define _HAVE_STRING_ARCH_memchr 1
437 #ifndef _FORCE_INLINES
438 __STRING_INLINE
void *
439 memchr (__const
void *__s
, int __c
, size_t __n
)
441 register unsigned long int __d0
;
443 register unsigned long int __d1
;
445 register unsigned char *__res
;
453 : "=D" (__res
), "=&c" (__d0
), "=&r" (__d1
)
454 : "a" (__c
), "0" (__s
), "1" (__n
), "2" (1),
455 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
464 : "=D" (__res
), "=&c" (__d0
)
465 : "a" (__c
), "0" (__s
), "1" (__n
),
466 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
473 #define _HAVE_STRING_ARCH_memrchr 1
474 #ifndef _FORCE_INLINES
475 __STRING_INLINE
void *__memrchr (__const
void *__s
, int __c
, size_t __n
);
477 __STRING_INLINE
void *
478 __memrchr (__const
void *__s
, int __c
, size_t __n
)
480 register unsigned long int __d0
;
482 register unsigned long int __d1
;
484 register void *__res
;
494 : "=D" (__res
), "=&c" (__d0
), "=&r" (__d1
)
495 : "a" (__c
), "0" (__s
+ __n
- 1), "1" (__n
), "2" (-1),
496 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
506 : "=D" (__res
), "=&c" (__d0
)
507 : "a" (__c
), "0" (__s
+ __n
- 1), "1" (__n
),
508 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__s
)
514 # define memrchr(s, c, n) __memrchr ((s), (c), (n))
518 /* Return pointer to C in S. */
519 #define _HAVE_STRING_ARCH_rawmemchr 1
520 __STRING_INLINE
void *__rawmemchr (const void *__s
, int __c
);
522 #ifndef _FORCE_INLINES
523 __STRING_INLINE
void *
524 __rawmemchr (const void *__s
, int __c
)
526 register unsigned long int __d0
;
527 register unsigned char *__res
;
531 : "=D" (__res
), "=&c" (__d0
)
532 : "a" (__c
), "0" (__s
), "1" (0xffffffff),
533 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
538 __STRING_INLINE
void *
539 rawmemchr (const void *__s
, int __c
)
541 return __rawmemchr (__s
, __c
);
543 # endif /* use GNU */
547 /* Return the length of S. */
548 #define _HAVE_STRING_ARCH_strlen 1
549 #define strlen(str) \
550 (__extension__ (__builtin_constant_p (str) \
551 ? __builtin_strlen (str) \
553 __STRING_INLINE
size_t __strlen_g (__const
char *__str
);
555 __STRING_INLINE
size_t
556 __strlen_g (__const
char *__str
)
558 register char __dummy
;
559 register __const
char *__tmp
= __str
;
566 : "=r" (__tmp
), "=&q" (__dummy
)
568 "m" ( *(struct { char __x
[0xfffffff]; } *)__str
)
570 return __tmp
- __str
- 1;
574 /* Copy SRC to DEST. */
575 #define _HAVE_STRING_ARCH_strcpy 1
576 #define strcpy(dest, src) \
577 (__extension__ (__builtin_constant_p (src) \
578 ? (sizeof ((src)[0]) == 1 && strlen (src) + 1 <= 8 \
579 ? __strcpy_a_small ((dest), (src), strlen (src) + 1) \
580 : (char *) memcpy ((char *) (dest), \
581 (__const char *) (src), \
583 : __strcpy_g ((dest), (src))))
585 #define __strcpy_a_small(dest, src, srclen) \
586 (__extension__ ({ char *__dest = (dest); \
589 unsigned short int __usi; \
590 unsigned char __uc; \
592 } *__u = (void *) __dest; \
599 __u->__usi = __STRING_SMALL_GET16 (src, 0); \
602 __u->__usi = __STRING_SMALL_GET16 (src, 0); \
603 __u = __extension__ ((void *) __u + 2); \
607 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
610 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
611 __u = __extension__ ((void *) __u + 4); \
615 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
616 __u = __extension__ ((void *) __u + 4); \
617 __u->__usi = __STRING_SMALL_GET16 (src, 4); \
620 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
621 __u = __extension__ ((void *) __u + 4); \
622 __u->__usi = __STRING_SMALL_GET16 (src, 4); \
623 __u = __extension__ ((void *) __u + 2); \
627 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
628 __u = __extension__ ((void *) __u + 4); \
629 __u->__ui = __STRING_SMALL_GET32 (src, 4); \
634 __STRING_INLINE
char *__strcpy_g (char *__dest
, __const
char *__src
);
636 __STRING_INLINE
char *
637 __strcpy_g (char *__dest
, __const
char *__src
)
639 register char *__tmp
= __dest
;
640 register char __dummy
;
650 : "=&r" (__src
), "=&r" (__tmp
), "=&q" (__dummy
),
651 "=m" ( *(struct { char __x
[0xfffffff]; } *)__dest
)
652 : "0" (__src
), "1" (__tmp
),
653 "m" ( *(struct { char __x
[0xfffffff]; } *)__src
)
660 # define _HAVE_STRING_ARCH_stpcpy 1
661 /* Copy SRC to DEST. */
662 # define __stpcpy(dest, src) \
663 (__extension__ (__builtin_constant_p (src) \
664 ? (strlen (src) + 1 <= 8 \
665 ? __stpcpy_a_small ((dest), (src), strlen (src) + 1) \
666 : __stpcpy_c ((dest), (src), strlen (src) + 1)) \
667 : __stpcpy_g ((dest), (src))))
668 # define __stpcpy_c(dest, src, srclen) \
670 ? __mempcpy_by4 (dest, src, srclen) - 1 \
671 : ((srclen) % 2 == 0 \
672 ? __mempcpy_by2 (dest, src, srclen) - 1 \
673 : __mempcpy_byn (dest, src, srclen) - 1))
675 /* In glibc itself we use this symbol for namespace reasons. */
676 # define stpcpy(dest, src) __stpcpy ((dest), (src))
678 # define __stpcpy_a_small(dest, src, srclen) \
679 (__extension__ ({ union { \
681 unsigned short int __usi; \
682 unsigned char __uc; \
684 } *__u = (void *) (dest); \
691 __u->__usi = __STRING_SMALL_GET16 (src, 0); \
692 __u = __extension__ ((void *) __u + 1); \
695 __u->__usi = __STRING_SMALL_GET16 (src, 0); \
696 __u = __extension__ ((void *) __u + 2); \
700 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
701 __u = __extension__ ((void *) __u + 3); \
704 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
705 __u = __extension__ ((void *) __u + 4); \
709 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
710 __u = __extension__ ((void *) __u + 4); \
711 __u->__usi = __STRING_SMALL_GET16 (src, 4); \
712 __u = __extension__ ((void *) __u + 1); \
715 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
716 __u = __extension__ ((void *) __u + 4); \
717 __u->__usi = __STRING_SMALL_GET16 (src, 4); \
718 __u = __extension__ ((void *) __u + 2); \
722 __u->__ui = __STRING_SMALL_GET32 (src, 0); \
723 __u = __extension__ ((void *) __u + 4); \
724 __u->__ui = __STRING_SMALL_GET32 (src, 4); \
725 __u = __extension__ ((void *) __u + 3); \
730 __STRING_INLINE
char *__mempcpy_by4 (char *__dest
, __const
char *__src
,
733 __STRING_INLINE
char *
734 __mempcpy_by4 (char *__dest
, __const
char *__src
, size_t __srclen
)
736 register char *__tmp
= __dest
;
737 register unsigned long int __d0
, __d1
;
746 : "=&r" (__d0
), "=r" (__tmp
), "=&r" (__src
), "=&r" (__d1
)
747 : "1" (__tmp
), "2" (__src
), "3" (__srclen
/ 4)
752 __STRING_INLINE
char *__mempcpy_by2 (char *__dest
, __const
char *__src
,
755 __STRING_INLINE
char *
756 __mempcpy_by2 (char *__dest
, __const
char *__src
, size_t __srclen
)
758 register char *__tmp
= __dest
;
759 register unsigned long int __d0
, __d1
;
762 "jz 2f\n" /* only a word */
773 : "=&q" (__d0
), "=r" (__tmp
), "=&r" (__src
), "=&r" (__d1
),
774 "=m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__dest
)
775 : "1" (__tmp
), "2" (__src
), "3" (__srclen
/ 2),
776 "m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__src
)
781 __STRING_INLINE
char *__mempcpy_byn (char *__dest
, __const
char *__src
,
784 __STRING_INLINE
char *
785 __mempcpy_byn (char *__dest
, __const
char *__src
, size_t __srclen
)
787 register unsigned long __d0
, __d1
;
788 register char *__tmp
= __dest
;
800 : "=D" (__tmp
), "=&c" (__d0
), "=&S" (__d1
),
801 "=m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__dest
)
802 : "0" (__tmp
), "1" (__srclen
), "2" (__src
),
803 "m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__src
)
808 __STRING_INLINE
char *__stpcpy_g (char *__dest
, __const
char *__src
);
810 __STRING_INLINE
char *
811 __stpcpy_g (char *__dest
, __const
char *__src
)
813 register char *__tmp
= __dest
;
814 register char __dummy
;
824 : "=&r" (__src
), "=r" (__tmp
), "=&q" (__dummy
),
825 "=m" ( *(struct { char __x
[0xfffffff]; } *)__dest
)
826 : "0" (__src
), "1" (__tmp
),
827 "m" ( *(struct { char __x
[0xfffffff]; } *)__src
)
834 /* Copy no more than N characters of SRC to DEST. */
835 #define _HAVE_STRING_ARCH_strncpy 1
836 #define strncpy(dest, src, n) \
837 (__extension__ (__builtin_constant_p (src) \
838 ? ((strlen (src) + 1 >= ((size_t) (n)) \
839 ? (char *) memcpy ((char *) (dest), \
840 (__const char *) (src), n) \
841 : __strncpy_cg ((dest), (src), strlen (src) + 1, n))) \
842 : __strncpy_gg ((dest), (src), n)))
843 #define __strncpy_cg(dest, src, srclen, n) \
844 (((srclen) % 4 == 0) \
845 ? __strncpy_by4 (dest, src, srclen, n) \
846 : (((srclen) % 2 == 0) \
847 ? __strncpy_by2 (dest, src, srclen, n) \
848 : __strncpy_byn (dest, src, srclen, n)))
850 __STRING_INLINE
char *__strncpy_by4 (char *__dest
, __const
char __src
[],
851 size_t __srclen
, size_t __n
);
853 __STRING_INLINE
char *
854 __strncpy_by4 (char *__dest
, __const
char __src
[], size_t __srclen
, size_t __n
)
856 register char *__tmp
= __dest
;
857 register int __dummy1
, __dummy2
;
866 : "=&r" (__dummy1
), "=r" (__tmp
), "=&r" (__src
), "=&r" (__dummy2
),
867 "=m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__dest
)
868 : "1" (__tmp
), "2" (__src
), "3" (__srclen
/ 4),
869 "m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__src
)
871 (void) memset (__tmp
, '\0', __n
- __srclen
);
875 __STRING_INLINE
char *__strncpy_by2 (char *__dest
, __const
char __src
[],
876 size_t __srclen
, size_t __n
);
878 __STRING_INLINE
char *
879 __strncpy_by2 (char *__dest
, __const
char __src
[], size_t __srclen
, size_t __n
)
881 register char *__tmp
= __dest
;
882 register int __dummy1
, __dummy2
;
885 "jz 2f\n" /* only a word */
896 : "=&q" (__dummy1
), "=r" (__tmp
), "=&r" (__src
), "=&r" (__dummy2
),
897 "=m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__dest
)
898 : "1" (__tmp
), "2" (__src
), "3" (__srclen
/ 2),
899 "m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__src
)
901 (void) memset (__tmp
+ 2, '\0', __n
- __srclen
);
905 __STRING_INLINE
char *__strncpy_byn (char *__dest
, __const
char __src
[],
906 size_t __srclen
, size_t __n
);
908 __STRING_INLINE
char *
909 __strncpy_byn (char *__dest
, __const
char __src
[], size_t __srclen
, size_t __n
)
911 register unsigned long int __d0
, __d1
;
912 register char *__tmp
= __dest
;
924 : "=D" (__tmp
), "=&c" (__d0
), "=&S" (__d1
),
925 "=m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__dest
)
926 : "1" (__srclen
), "0" (__tmp
),"2" (__src
),
927 "m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__src
)
929 (void) memset (__tmp
, '\0', __n
- __srclen
);
933 __STRING_INLINE
char *__strncpy_gg (char *__dest
, __const
char *__src
,
936 __STRING_INLINE
char *
937 __strncpy_gg (char *__dest
, __const
char *__src
, size_t __n
)
939 register char *__tmp
= __dest
;
940 register char __dummy
;
958 : "=&r" (__src
), "=&r" (__tmp
), "=&q" (__dummy
), "=&r" (__n
)
959 : "0" (__src
), "1" (__tmp
), "3" (__n
)
966 /* Append SRC onto DEST. */
967 #define _HAVE_STRING_ARCH_strcat 1
968 #define strcat(dest, src) \
969 (__extension__ (__builtin_constant_p (src) \
970 ? __strcat_c ((dest), (src), strlen (src) + 1) \
971 : __strcat_g ((dest), (src))))
973 __STRING_INLINE
char *__strcat_c (char *__dest
, __const
char __src
[],
976 __STRING_INLINE
char *
977 __strcat_c (char *__dest
, __const
char __src
[], size_t __srclen
)
980 register unsigned long int __d0
;
981 register char *__tmp
;
984 : "=D" (__tmp
), "=&c" (__d0
),
985 "=m" ( *(struct { char __x
[0xfffffff]; } *)__dest
)
986 : "0" (__dest
), "1" (0xffffffff), "a" (0),
987 "m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__src
)
991 register char *__tmp
= __dest
- 1;
998 "=m" ( *(struct { char __x
[0xfffffff]; } *)__dest
)
1000 "m" ( *(struct { __extension__
char __x
[__srclen
]; } *)__src
)
1003 (void) memcpy (__tmp
, __src
, __srclen
);
1007 __STRING_INLINE
char *__strcat_g (char *__dest
, __const
char *__src
);
1009 __STRING_INLINE
char *
1010 __strcat_g (char *__dest
, __const
char *__src
)
1012 register char *__tmp
= __dest
- 1;
1013 register char __dummy
;
1014 __asm__ __volatile__
1026 : "=&q" (__dummy
), "=&r" (__tmp
), "=&r" (__src
),
1027 "=m" ( *(struct { char __x
[0xfffffff]; } *)__dest
)
1028 : "1" (__tmp
), "2" (__src
),
1029 "m" ( *(struct { char __x
[0xfffffff]; } *)__src
)
1035 /* Append no more than N characters from SRC onto DEST. */
1036 #define _HAVE_STRING_ARCH_strncat 1
1037 #define strncat(dest, src, n) \
1038 (__extension__ ({ char *__dest = (dest); \
1039 __builtin_constant_p (src) && __builtin_constant_p (n) \
1040 ? (strlen (src) < ((size_t) (n)) \
1041 ? strcat (__dest, (src)) \
1042 : (*(char *)__mempcpy (strchr (__dest, '\0'), \
1043 (__const char *) (src), \
1044 (n)) = 0, __dest)) \
1045 : __strncat_g (__dest, (src), (n)); }))
1047 __STRING_INLINE
char *__strncat_g (char *__dest
, __const
char __src
[],
1050 __STRING_INLINE
char *
1051 __strncat_g (char *__dest
, __const
char __src
[], size_t __n
)
1053 register char *__tmp
= __dest
;
1054 register char __dummy
;
1056 __asm__ __volatile__
1070 : "=&a" (__dummy
), "=&D" (__tmp
), "=&S" (__src
), "=&c" (__n
)
1071 : "g" (__n
), "0" (0), "1" (__tmp
), "2" (__src
), "3" (0xffffffff)
1075 __asm__ __volatile__
1092 : "=&q" (__dummy
), "=&r" (__tmp
), "=&r" (__src
), "=&r" (__n
)
1093 : "1" (__tmp
), "2" (__src
), "3" (__n
)
1100 /* Compare S1 and S2. */
1101 #define _HAVE_STRING_ARCH_strcmp 1
1102 #define strcmp(s1, s2) \
1103 (__extension__ (__builtin_constant_p (s1) && __builtin_constant_p (s2) \
1104 && (sizeof ((s1)[0]) != 1 || strlen (s1) >= 4) \
1105 && (sizeof ((s2)[0]) != 1 || strlen (s2) >= 4) \
1106 ? memcmp ((__const char *) (s1), (__const char *) (s2), \
1107 (strlen (s1) < strlen (s2) \
1108 ? strlen (s1) : strlen (s2)) + 1) \
1109 : (__builtin_constant_p (s1) && sizeof ((s1)[0]) == 1 \
1110 && sizeof ((s2)[0]) == 1 && strlen (s1) < 4 \
1111 ? (__builtin_constant_p (s2) && sizeof ((s2)[0]) == 1 \
1112 ? __strcmp_cc ((__const unsigned char *) (s1), \
1113 (__const unsigned char *) (s2), \
1115 : __strcmp_cg ((__const unsigned char *) (s1), \
1116 (__const unsigned char *) (s2), \
1118 : (__builtin_constant_p (s2) && sizeof ((s1)[0]) == 1 \
1119 && sizeof ((s2)[0]) == 1 && strlen (s2) < 4 \
1120 ? (__builtin_constant_p (s1) \
1121 ? __strcmp_cc ((__const unsigned char *) (s1), \
1122 (__const unsigned char *) (s2), \
1124 : __strcmp_gc ((__const unsigned char *) (s1), \
1125 (__const unsigned char *) (s2), \
1127 : __strcmp_gg ((s1), (s2))))))
1129 #define __strcmp_cc(s1, s2, l) \
1130 (__extension__ ({ register int __result = (s1)[0] - (s2)[0]; \
1131 if (l > 0 && __result == 0) \
1133 __result = (s1)[1] - (s2)[1]; \
1134 if (l > 1 && __result == 0) \
1136 __result = (s1)[2] - (s2)[2]; \
1137 if (l > 2 && __result == 0) \
1138 __result = (s1)[3] - (s2)[3]; \
1143 #define __strcmp_cg(s1, s2, l1) \
1144 (__extension__ ({ __const unsigned char *__s2 = (s2); \
1145 register int __result = (s1)[0] - __s2[0]; \
1146 if (l1 > 0 && __result == 0) \
1148 __result = (s1)[1] - __s2[1]; \
1149 if (l1 > 1 && __result == 0) \
1151 __result = (s1)[2] - __s2[2]; \
1152 if (l1 > 2 && __result == 0) \
1153 __result = (s1)[3] - __s2[3]; \
1158 #define __strcmp_gc(s1, s2, l2) \
1159 (__extension__ ({ __const unsigned char *__s1 = (s1); \
1160 register int __result = __s1[0] - (s2)[0]; \
1161 if (l2 > 0 && __result == 0) \
1163 __result = __s1[1] - (s2)[1]; \
1164 if (l2 > 1 && __result == 0) \
1166 __result = __s1[2] - (s2)[2]; \
1167 if (l2 > 2 && __result == 0) \
1168 __result = __s1[3] - (s2)[3]; \
1173 __STRING_INLINE
int __strcmp_gg (__const
char *__s1
, __const
char *__s2
);
1176 __strcmp_gg (__const
char *__s1
, __const
char *__s2
)
1179 __asm__ __volatile__
1195 : "=q" (__res
), "=&r" (__s1
), "=&r" (__s2
)
1196 : "1" (__s1
), "2" (__s2
),
1197 "m" ( *(struct { char __x
[0xfffffff]; } *)__s1
),
1198 "m" ( *(struct { char __x
[0xfffffff]; } *)__s2
)
1204 /* Compare N characters of S1 and S2. */
1205 #define _HAVE_STRING_ARCH_strncmp 1
1206 #define strncmp(s1, s2, n) \
1207 (__extension__ (__builtin_constant_p (s1) && strlen (s1) < ((size_t) (n)) \
1208 ? strcmp ((s1), (s2)) \
1209 : (__builtin_constant_p (s2) && strlen (s2) < ((size_t) (n))\
1210 ? strcmp ((s1), (s2)) \
1211 : __strncmp_g ((s1), (s2), (n)))))
1213 __STRING_INLINE
int __strncmp_g (__const
char *__s1
, __const
char *__s2
,
1217 __strncmp_g (__const
char *__s1
, __const
char *__s2
, size_t __n
)
1220 __asm__ __volatile__
1239 : "=q" (__res
), "=&r" (__s1
), "=&r" (__s2
), "=&r" (__n
)
1240 : "1" (__s1
), "2" (__s2
), "3" (__n
),
1241 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__s1
),
1242 "m" ( *(struct { __extension__
char __x
[__n
]; } *)__s2
)
1248 /* Find the first occurrence of C in S. */
1249 #define _HAVE_STRING_ARCH_strchr 1
1250 #define _USE_STRING_ARCH_strchr 1
1251 #define strchr(s, c) \
1252 (__extension__ (__builtin_constant_p (c) \
1254 ? (char *) __rawmemchr ((s), (c)) \
1255 : __strchr_c ((s), ((c) & 0xff) << 8)) \
1256 : __strchr_g ((s), (c))))
1258 __STRING_INLINE
char *__strchr_c (__const
char *__s
, int __c
);
1260 __STRING_INLINE
char *
1261 __strchr_c (__const
char *__s
, int __c
)
1263 register unsigned long int __d0
;
1264 register char *__res
;
1265 __asm__ __volatile__
1267 "movb (%0),%%al\n\t"
1268 "cmpb %%ah,%%al\n\t"
1271 "testb %%al,%%al\n\t"
1275 : "=r" (__res
), "=&a" (__d0
)
1276 : "0" (__s
), "1" (__c
),
1277 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1282 __STRING_INLINE
char *__strchr_g (__const
char *__s
, int __c
);
1284 __STRING_INLINE
char *
1285 __strchr_g (__const
char *__s
, int __c
)
1287 register unsigned long int __d0
;
1288 register char *__res
;
1289 __asm__ __volatile__
1292 "movb (%0),%%al\n\t"
1293 "cmpb %%ah,%%al\n\t"
1296 "testb %%al,%%al\n\t"
1300 : "=r" (__res
), "=&a" (__d0
)
1301 : "0" (__s
), "1" (__c
),
1302 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1308 /* Find the first occurrence of C in S or the final NUL byte. */
1309 #define _HAVE_STRING_ARCH_strchrnul 1
1310 #define __strchrnul(s, c) \
1311 (__extension__ (__builtin_constant_p (c) \
1313 ? (char *) __rawmemchr ((s), c) \
1314 : __strchrnul_c ((s), ((c) & 0xff) << 8)) \
1315 : __strchrnul_g ((s), c)))
1317 __STRING_INLINE
char *__strchrnul_c (__const
char *__s
, int __c
);
1319 __STRING_INLINE
char *
1320 __strchrnul_c (__const
char *__s
, int __c
)
1322 register unsigned long int __d0
;
1323 register char *__res
;
1324 __asm__ __volatile__
1326 "movb (%0),%%al\n\t"
1327 "cmpb %%ah,%%al\n\t"
1330 "testb %%al,%%al\n\t"
1334 : "=r" (__res
), "=&a" (__d0
)
1335 : "0" (__s
), "1" (__c
),
1336 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1341 __STRING_INLINE
char *__strchrnul_g (__const
char *__s
, int __c
);
1343 __STRING_INLINE
char *
1344 __strchrnul_g (__const
char *__s
, int __c
)
1346 register unsigned long int __d0
;
1347 register char *__res
;
1348 __asm__ __volatile__
1351 "movb (%0),%%al\n\t"
1352 "cmpb %%ah,%%al\n\t"
1355 "testb %%al,%%al\n\t"
1359 : "=r" (__res
), "=&a" (__d0
)
1360 : "0" (__s
), "1" (__c
),
1361 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1366 # define strchrnul(s, c) __strchrnul ((s), (c))
1370 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1371 /* Find the first occurrence of C in S. This is the BSD name. */
1372 # define _HAVE_STRING_ARCH_index 1
1373 # define index(s, c) \
1374 (__extension__ (__builtin_constant_p (c) \
1375 ? __strchr_c ((s), ((c) & 0xff) << 8) \
1376 : __strchr_g ((s), (c))))
1380 /* Find the last occurrence of C in S. */
1381 #define _HAVE_STRING_ARCH_strrchr 1
1382 #define strrchr(s, c) \
1383 (__extension__ (__builtin_constant_p (c) \
1384 ? __strrchr_c ((s), ((c) & 0xff) << 8) \
1385 : __strrchr_g ((s), (c))))
1388 __STRING_INLINE
char *__strrchr_c (__const
char *__s
, int __c
);
1390 __STRING_INLINE
char *
1391 __strrchr_c (__const
char *__s
, int __c
)
1393 register unsigned long int __d0
, __d1
;
1394 register char *__res
;
1395 __asm__ __volatile__
1403 : "=d" (__res
), "=&S" (__d0
), "=&a" (__d1
)
1404 : "0" (1), "1" (__s
), "2" (__c
),
1405 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1410 __STRING_INLINE
char *__strrchr_g (__const
char *__s
, int __c
);
1412 __STRING_INLINE
char *
1413 __strrchr_g (__const
char *__s
, int __c
)
1415 register unsigned long int __d0
, __d1
;
1416 register char *__res
;
1417 __asm__ __volatile__
1426 : "=d" (__res
), "=&S" (__d0
), "=&a" (__d1
)
1427 : "0" (1), "1" (__s
), "2" (__c
),
1428 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1433 __STRING_INLINE
char *__strrchr_c (__const
char *__s
, int __c
);
1435 __STRING_INLINE
char *
1436 __strrchr_c (__const
char *__s
, int __c
)
1438 register unsigned long int __d0
, __d1
;
1439 register char *__res
;
1440 __asm__ __volatile__
1444 "cmpb %%ah,%%al\n\t"
1446 "leal -1(%%esi),%0\n"
1448 "testb %%al,%%al\n\t"
1450 : "=d" (__res
), "=&S" (__d0
), "=&a" (__d1
)
1451 : "0" (0), "1" (__s
), "2" (__c
),
1452 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1457 __STRING_INLINE
char *__strrchr_g (__const
char *__s
, int __c
);
1459 __STRING_INLINE
char *
1460 __strrchr_g (__const
char *__s
, int __c
)
1462 register unsigned long int __d0
, __d1
;
1463 register char *__res
;
1464 __asm__ __volatile__
1469 "cmpb %%ah,%%al\n\t"
1471 "leal -1(%%esi),%0\n"
1473 "testb %%al,%%al\n\t"
1475 : "=r" (__res
), "=&S" (__d0
), "=&a" (__d1
)
1476 : "0" (0), "1" (__s
), "2" (__c
),
1477 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1484 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1485 /* Find the last occurrence of C in S. This is the BSD name. */
1486 # define _HAVE_STRING_ARCH_rindex 1
1487 # define rindex(s, c) \
1488 (__extension__ (__builtin_constant_p (c) \
1489 ? __strrchr_c ((s), ((c) & 0xff) << 8) \
1490 : __strrchr_g ((s), (c))))
1494 /* Return the length of the initial segment of S which
1495 consists entirely of characters not in REJECT. */
1496 #define _HAVE_STRING_ARCH_strcspn 1
1497 #define strcspn(s, reject) \
1498 (__extension__ (__builtin_constant_p (reject) && sizeof ((reject)[0]) == 1 \
1499 ? ((reject)[0] == '\0' \
1501 : ((reject)[1] == '\0' \
1502 ? __strcspn_c1 ((s), (((reject)[0] << 8) & 0xff00)) \
1503 : __strcspn_cg ((s), (reject), strlen (reject)))) \
1504 : __strcspn_g ((s), (reject))))
1506 __STRING_INLINE
size_t __strcspn_c1 (__const
char *__s
, int __reject
);
1508 #ifndef _FORCE_INLINES
1509 __STRING_INLINE
size_t
1510 __strcspn_c1 (__const
char *__s
, int __reject
)
1512 register unsigned long int __d0
;
1513 register char *__res
;
1514 __asm__ __volatile__
1516 "movb (%0),%%al\n\t"
1518 "cmpb %%ah,%%al\n\t"
1520 "testb %%al,%%al\n\t"
1523 : "=r" (__res
), "=&a" (__d0
)
1524 : "0" (__s
), "1" (__reject
),
1525 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1527 return (__res
- 1) - __s
;
1531 __STRING_INLINE
size_t __strcspn_cg (__const
char *__s
, __const
char __reject
[],
1532 size_t __reject_len
);
1534 __STRING_INLINE
size_t
1535 __strcspn_cg (__const
char *__s
, __const
char __reject
[], size_t __reject_len
)
1537 register unsigned long int __d0
, __d1
, __d2
;
1538 register __const
char *__res
;
1539 __asm__ __volatile__
1543 "testb %%al,%%al\n\t"
1550 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&D" (__d2
)
1551 : "0" (__s
), "d" (__reject
), "g" (__reject_len
)
1553 return (__res
- 1) - __s
;
1556 __STRING_INLINE
size_t __strcspn_g (__const
char *__s
, __const
char *__reject
);
1559 __STRING_INLINE
size_t
1560 __strcspn_g (__const
char *__s
, __const
char *__reject
)
1562 register unsigned long int __d0
, __d1
, __d2
;
1563 register __const
char *__res
;
1564 __asm__ __volatile__
1570 "leal -1(%%ecx),%%ebx\n"
1573 "testb %%al,%%al\n\t"
1576 "movl %%ebx,%%ecx\n\t"
1581 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&D" (__d2
)
1582 : "r" (__reject
), "0" (__s
), "1" (0), "2" (0xffffffff)
1584 return (__res
- 1) - __s
;
1587 __STRING_INLINE
size_t
1588 __strcspn_g (__const
char *__s
, __const
char *__reject
)
1590 register unsigned long int __d0
, __d1
, __d2
, __d3
;
1591 register __const
char *__res
;
1592 __asm__ __volatile__
1596 "leal -1(%%ecx),%%edx\n"
1599 "testb %%al,%%al\n\t"
1601 "movl %%ebx,%%edi\n\t"
1602 "movl %%edx,%%ecx\n\t"
1606 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&D" (__d2
), "=&d" (__d3
)
1607 : "0" (__s
), "1" (0), "2" (0xffffffff), "3" (__reject
), "b" (__reject
)
1608 /* Clobber memory, otherwise GCC cannot handle this. */
1610 return (__res
- 1) - __s
;
1615 /* Return the length of the initial segment of S which
1616 consists entirely of characters in ACCEPT. */
1617 #define _HAVE_STRING_ARCH_strspn 1
1618 #define strspn(s, accept) \
1619 (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1 \
1620 ? ((accept)[0] == '\0' \
1622 : ((accept)[1] == '\0' \
1623 ? __strspn_c1 ((s), (((accept)[0] << 8 ) & 0xff00)) \
1624 : __strspn_cg ((s), (accept), strlen (accept)))) \
1625 : __strspn_g ((s), (accept))))
1627 #ifndef _FORCE_INLINES
1628 __STRING_INLINE
size_t __strspn_c1 (__const
char *__s
, int __accept
);
1630 __STRING_INLINE
size_t
1631 __strspn_c1 (__const
char *__s
, int __accept
)
1633 register unsigned long int __d0
;
1634 register char *__res
;
1635 /* Please note that __accept never can be '\0'. */
1636 __asm__ __volatile__
1642 : "=r" (__res
), "=&q" (__d0
)
1643 : "0" (__s
), "1" (__accept
),
1644 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
)
1646 return (__res
- 1) - __s
;
1650 __STRING_INLINE
size_t __strspn_cg (__const
char *__s
, __const
char __accept
[],
1651 size_t __accept_len
);
1653 __STRING_INLINE
size_t
1654 __strspn_cg (__const
char *__s
, __const
char __accept
[], size_t __accept_len
)
1656 register unsigned long int __d0
, __d1
, __d2
;
1657 register __const
char *__res
;
1658 __asm__ __volatile__
1662 "testb %%al,%%al\n\t"
1669 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&D" (__d2
)
1670 : "0" (__s
), "g" (__accept
), "g" (__accept_len
),
1671 /* Since we do not know how large the memory we access it, use a
1672 really large amount. */
1673 "m" ( *(struct { char __x
[0xfffffff]; } *)__s
),
1674 "m" ( *(struct { __extension__
char __x
[__accept_len
]; } *)__accept
)
1676 return (__res
- 1) - __s
;
1679 __STRING_INLINE
size_t __strspn_g (__const
char *__s
, __const
char *__accept
);
1682 __STRING_INLINE
size_t
1683 __strspn_g (__const
char *__s
, __const
char *__accept
)
1685 register unsigned long int __d0
, __d1
, __d2
;
1686 register __const
char *__res
;
1687 __asm__ __volatile__
1692 "leal -1(%%ecx),%%ebx\n"
1695 "testb %%al,%%al\n\t"
1697 "movl %%edx,%%edi\n\t"
1698 "movl %%ebx,%%ecx\n\t"
1703 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&D" (__d2
)
1704 : "d" (__accept
), "0" (__s
), "1" (0), "2" (0xffffffff), "3" (__accept
)
1706 return (__res
- 1) - __s
;
1709 __STRING_INLINE
size_t
1710 __strspn_g (__const
char *__s
, __const
char *__accept
)
1712 register unsigned long int __d0
, __d1
, __d2
, __d3
;
1713 register __const
char *__res
;
1714 __asm__ __volatile__
1718 "leal -1(%%ecx),%%edx\n"
1721 "testb %%al,%%al\n\t"
1723 "movl %%ebx,%%edi\n\t"
1724 "movl %%edx,%%ecx\n\t"
1728 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&D" (__d2
), "=&d" (__d3
)
1729 : "0" (__s
), "1" (0), "2" (0xffffffff), "3" (__accept
), "b" (__accept
)
1731 return (__res
- 1) - __s
;
1736 /* Find the first occurrence in S of any character in ACCEPT. */
1737 #define _HAVE_STRING_ARCH_strpbrk 1
1738 #define strpbrk(s, accept) \
1739 (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1 \
1740 ? ((accept)[0] == '\0' \
1741 ? ((void) (s), (char *) 0) \
1742 : ((accept)[1] == '\0' \
1743 ? strchr ((s), (accept)[0]) \
1744 : __strpbrk_cg ((s), (accept), strlen (accept)))) \
1745 : __strpbrk_g ((s), (accept))))
1747 __STRING_INLINE
char *__strpbrk_cg (__const
char *__s
, __const
char __accept
[],
1748 size_t __accept_len
);
1750 __STRING_INLINE
char *
1751 __strpbrk_cg (__const
char *__s
, __const
char __accept
[], size_t __accept_len
)
1753 register unsigned long int __d0
, __d1
, __d2
;
1754 register char *__res
;
1755 __asm__ __volatile__
1759 "testb %%al,%%al\n\t"
1770 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&D" (__d2
)
1771 : "0" (__s
), "d" (__accept
), "g" (__accept_len
)
1776 __STRING_INLINE
char *__strpbrk_g (__const
char *__s
, __const
char *__accept
);
1779 __STRING_INLINE
char *
1780 __strpbrk_g (__const
char *__s
, __const
char *__accept
)
1782 register unsigned long int __d0
, __d1
, __d2
;
1783 register char *__res
;
1784 __asm__ __volatile__
1786 "movl %%edx,%%edi\n\t"
1790 "leal -1(%%ecx),%%ebx\n"
1793 "testb %%al,%%al\n\t"
1795 "movl %%edx,%%edi\n\t"
1796 "movl %%ebx,%%ecx\n\t"
1805 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&D" (__d2
)
1806 : "d" (__accept
), "0" (__s
), "1" (0), "2" (0xffffffff)
1811 __STRING_INLINE
char *
1812 __strpbrk_g (__const
char *__s
, __const
char *__accept
)
1814 register unsigned long int __d0
, __d1
, __d2
, __d3
;
1815 register char *__res
;
1816 __asm__ __volatile__
1817 ("movl %%ebx,%%edi\n\t"
1821 "leal -1(%%ecx),%%edx\n"
1824 "testb %%al,%%al\n\t"
1826 "movl %%ebx,%%edi\n\t"
1827 "movl %%edx,%%ecx\n\t"
1835 : "=S" (__res
), "=&a" (__d0
), "=&c" (__d1
), "=&d" (__d2
), "=&D" (__d3
)
1836 : "0" (__s
), "1" (0), "2" (0xffffffff), "b" (__accept
)
1843 /* Find the first occurrence of NEEDLE in HAYSTACK. */
1844 #define _HAVE_STRING_ARCH_strstr 1
1845 #define strstr(haystack, needle) \
1846 (__extension__ (__builtin_constant_p (needle) && sizeof ((needle)[0]) == 1 \
1847 ? ((needle)[0] == '\0' \
1849 : ((needle)[1] == '\0' \
1850 ? strchr ((haystack), (needle)[0]) \
1851 : __strstr_cg ((haystack), (needle), \
1852 strlen (needle)))) \
1853 : __strstr_g ((haystack), (needle))))
1855 /* Please note that this function need not handle NEEDLEs with a
1856 length shorter than two. */
1857 __STRING_INLINE
char *__strstr_cg (__const
char *__haystack
, __const
char __needle
[],
1858 size_t __needle_len
);
1860 __STRING_INLINE
char *
1861 __strstr_cg (__const
char *__haystack
, __const
char __needle
[],
1862 size_t __needle_len
)
1864 register unsigned long int __d0
, __d1
, __d2
;
1865 register char *__res
;
1866 __asm__ __volatile__
1874 "cmpb $0,-1(%%esi)\n\t"
1875 "leal 1(%%eax),%5\n\t"
1877 "xorl %%eax,%%eax\n"
1879 : "=&a" (__res
), "=&S" (__d0
), "=&D" (__d1
), "=&c" (__d2
)
1880 : "g" (__needle_len
), "1" (__haystack
), "d" (__needle
)
1885 __STRING_INLINE
char *__strstr_g (__const
char *__haystack
, __const
char *__needle
);
1888 __STRING_INLINE
char *
1889 __strstr_g (__const
char *__haystack
, __const
char *__needle
)
1891 register unsigned long int __d0
, __d1
, __d2
;
1892 register char *__res
;
1893 __asm__ __volatile__
1898 "decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */
1899 "movl %%ecx,%%ebx\n"
1901 "movl %%edx,%%edi\n\t"
1902 "movl %%esi,%%eax\n\t"
1903 "movl %%ebx,%%ecx\n\t"
1905 "je 2f\n\t" /* also works for empty string, see above */
1906 "cmpb $0,-1(%%esi)\n\t"
1907 "leal 1(%%eax),%%esi\n\t"
1909 "xorl %%eax,%%eax\n"
1912 : "=&a" (__res
), "=&c" (__d0
), "=&S" (__d1
), "=&D" (__d2
)
1913 : "0" (0), "1" (0xffffffff), "2" (__haystack
), "3" (__needle
),
1919 __STRING_INLINE
char *
1920 __strstr_g (__const
char *__haystack
, __const
char *__needle
)
1922 register unsigned long int __d0
, __d1
, __d2
, __d3
;
1923 register char *__res
;
1924 __asm__ __volatile__
1928 "decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */
1929 "movl %%ecx,%%edx\n"
1931 "movl %%ebx,%%edi\n\t"
1932 "movl %%esi,%%eax\n\t"
1933 "movl %%edx,%%ecx\n\t"
1935 "je 2f\n\t" /* also works for empty string, see above */
1936 "cmpb $0,-1(%%esi)\n\t"
1937 "leal 1(%%eax),%%esi\n\t"
1939 "xorl %%eax,%%eax\n"
1941 : "=&a" (__res
), "=&c" (__d0
), "=&S" (__d1
), "=&D" (__d2
), "=&d" (__d3
)
1942 : "0" (0), "1" (0xffffffff), "2" (__haystack
), "3" (__needle
),
1950 /* Bit find functions. We define only the i686 version since for the other
1951 processors gcc generates good code. */
1952 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1954 # define _HAVE_STRING_ARCH_ffs 1
1955 # define ffs(word) (__builtin_constant_p (word) \
1956 ? __builtin_ffs (word) \
1957 : ({ int __cnt, __tmp; \
1958 __asm__ __volatile__ \
1961 : "=&r" (__cnt), "=r" (__tmp) \
1962 : "rm" (word), "1" (-1)); \
1966 # define ffsl(word) ffs(word)
1969 #endif /* BSD || X/Open */
1971 #ifndef _FORCE_INLINES
1972 # undef __STRING_INLINE
1975 #endif /* use string inlines && GNU CC */