diff options
Diffstat (limited to 'sysdeps/i386/bits/string.h')
| -rw-r--r-- | sysdeps/i386/bits/string.h | 922 |
1 files changed, 922 insertions, 0 deletions
diff --git a/sysdeps/i386/bits/string.h b/sysdeps/i386/bits/string.h new file mode 100644 index 0000000000..d181afd48b --- /dev/null +++ b/sysdeps/i386/bits/string.h @@ -0,0 +1,922 @@ +/* Optimized, inlined string functions. i386 version. + Copyright (C) 1997,1998,1999,2000,2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#ifndef _STRING_H +# error "Never use <bits/string.h> directly; include <string.h> instead." +#endif + +/* The ix86 processors can access unaligned multi-byte variables. */ +#define _STRING_ARCH_unaligned 1 + + +/* We only provide optimizations if the user selects them and if + GNU CC is used. */ +#if !defined __NO_STRING_INLINES && defined __USE_STRING_INLINES \ + && defined __GNUC__ && __GNUC__ >= 2 && !__BOUNDED_POINTERS__ + +#ifndef __STRING_INLINE +# ifdef __cplusplus +# define __STRING_INLINE inline +# else +# define __STRING_INLINE extern __inline +# endif +#endif + + +/* Copy N bytes of SRC to DEST. */ +#define _HAVE_STRING_ARCH_memcpy 1 +#define memcpy(dest, src, n) \ + (__extension__ (__builtin_constant_p (n) \ + ? __memcpy_c ((dest), (src), (n)) \ + : memcpy ((dest), (src), (n)))) +/* This looks horribly ugly, but the compiler can optimize it totally, + as the count is constant. */ +__STRING_INLINE void *__memcpy_c (void *__dest, __const void *__src, + size_t __n); + +__STRING_INLINE void * +__memcpy_c (void *__dest, __const void *__src, size_t __n) +{ + register unsigned long int __d0, __d1, __d2; + union { + unsigned int __ui; + unsigned short int __usi; + unsigned char __uc; + } *__u = __dest; + switch (__n) + { + case 0: + return __dest; + case 1: + __u->__uc = *(const unsigned char *) __src; + return __dest; + case 2: + __u->__usi = *(const unsigned short int *) __src; + return __dest; + case 3: + __u->__usi = *(const unsigned short int *) __src; + __u = (void *) __u + 2; + __u->__uc = *(2 + (const unsigned char *) __src); + return __dest; + case 4: + __u->__ui = *(const unsigned int *) __src; + return __dest; + case 6: + __u->__ui = *(const unsigned int *) __src; + __u = (void *) __u + 4; + __u->__usi = *(2 + (const unsigned short int *) __src); + return __dest; + case 8: + __u->__ui = *(const unsigned int *) __src; + __u = (void *) __u + 4; + __u->__ui = *(1 + (const unsigned int *) __src); + return __dest; + case 12: + __u->__ui = *(const unsigned int *) __src; + __u = (void *) __u + 4; + __u->__ui = *(1 + (const unsigned int *) __src); + __u = (void *) __u + 4; + __u->__ui = *(2 + (const unsigned int *) __src); + return __dest; + case 16: + __u->__ui = *(const unsigned int *) __src; + __u = (void *) __u + 4; + __u->__ui = *(1 + (const unsigned int *) __src); + __u = (void *) __u + 4; + __u->__ui = *(2 + (const unsigned int *) __src); + __u = (void *) __u + 4; + __u->__ui = *(3 + (const unsigned int *) __src); + return __dest; + case 20: + __u->__ui = *(const unsigned int *) __src; + __u = (void *) __u + 4; + __u->__ui = *(1 + (const unsigned int *) __src); + __u = (void *) __u + 4; + __u->__ui = *(2 + (const unsigned int *) __src); + __u = (void *) __u + 4; + __u->__ui = *(3 + (const unsigned int *) __src); + __u = (void *) __u + 4; + __u->__ui = *(4 + (const unsigned int *) __src); + return __dest; + } +#define __COMMON_CODE(x) \ + __asm__ __volatile__ \ + ("cld\n\t" \ + "rep; movsl" \ + x \ + : "=&c" (__d0), "=&D" (__d1), "=&S" (__d2) \ + : "0" (__n / 4), "1" (&__u->__uc), "2" (__src) \ + : "memory"); + + switch (__n % 4) + { + case 0: + __COMMON_CODE (""); + break; + case 1: + __COMMON_CODE ("\n\tmovsb"); + break; + case 2: + __COMMON_CODE ("\n\tmovsw"); + break; + case 3: + __COMMON_CODE ("\n\tmovsw\n\tmovsb"); + break; + } + return __dest; +#undef __COMMON_CODE +} + + +/* Copy N bytes of SRC to DEST, guaranteeing + correct behavior for overlapping strings. */ +#define _HAVE_STRING_ARCH_memmove 1 +#ifndef _FORCE_INLINES +__STRING_INLINE void * +memmove (void *__dest, __const void *__src, size_t __n) +{ + register unsigned long int __d0, __d1, __d2; + if (__dest < __src) + __asm__ __volatile__ + ("cld\n\t" + "rep\n\t" + "movsb" + : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2) + : "0" (__n), "1" (__src), "2" (__dest) + : "memory"); + else + __asm__ __volatile__ + ("std\n\t" + "rep\n\t" + "movsb\n\t" + "cld" + : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2) + : "0" (__n), "1" (__n - 1 + (const char *) __src), + "2" (__n - 1 + (char *) __dest) + : "memory"); + return __dest; +} +#endif + +/* Set N bytes of S to C. */ +#define _HAVE_STRING_ARCH_memset 1 +#define _USE_STRING_ARCH_memset 1 +#define memset(s, c, n) \ + (__extension__ (__builtin_constant_p (c) \ + ? (__builtin_constant_p (n) \ + ? __memset_cc (s, 0x01010101UL * (unsigned char) (c), n) \ + : __memset_cg (s, 0x01010101UL * (unsigned char) (c), n))\ + : __memset_gg (s, c, n))) + +__STRING_INLINE void *__memset_cc (void *__s, unsigned long int __pattern, + size_t __n); + +__STRING_INLINE void * +__memset_cc (void *__s, unsigned long int __pattern, size_t __n) +{ + register unsigned long int __d0, __d1; + union { + unsigned int __ui; + unsigned short int __usi; + unsigned char __uc; + } *__u = __s; + switch (__n) + { + case 0: + return __s; + case 1: + __u->__uc = __pattern; + return __s; + case 2: + __u->__usi = __pattern; + return __s; + case 3: + __u->__usi = __pattern; + __u = __extension__ ((void *) __u + 2); + __u->__uc = __pattern; + return __s; + case 4: + __u->__ui = __pattern; + return __s; + } +#define __COMMON_CODE(x) \ + __asm__ __volatile__ \ + ("cld\n\t" \ + "rep; stosl" \ + x \ + : "=&c" (__d0), "=&D" (__d1) \ + : "a" (__pattern), "0" (__n / 4), "1" (&__u->__uc) \ + : "memory") + + switch (__n % 4) + { + case 0: + __COMMON_CODE (""); + break; + case 1: + __COMMON_CODE ("\n\tstosb"); + break; + case 2: + __COMMON_CODE ("\n\tstosw"); + break; + case 3: + __COMMON_CODE ("\n\tstosw\n\tstosb"); + break; + } + return __s; +#undef __COMMON_CODE +} + +__STRING_INLINE void *__memset_cg (void *__s, unsigned long __c, size_t __n); + +__STRING_INLINE void * +__memset_cg (void *__s, unsigned long __c, size_t __n) +{ + register unsigned long int __d0, __d1; + __asm__ __volatile__ + ("cld\n\t" + "rep; stosl\n\t" + "testb $2,%b3\n\t" + "je 1f\n\t" + "stosw\n" + "1:\n\t" + "testb $1,%b3\n\t" + "je 2f\n\t" + "stosb\n" + "2:" + : "=&c" (__d0), "=&D" (__d1) + : "a" (__c), "q" (__n), "0" (__n / 4), "1" (__s) + : "memory"); + return __s; +} + +__STRING_INLINE void *__memset_gg (void *__s, char __c, size_t __n); + +__STRING_INLINE void * +__memset_gg (void *__s, char __c, size_t __n) +{ + register unsigned long int __d0, __d1; + __asm__ __volatile__ + ("cld\n\t" + "rep; stosb" + : "=&D" (__d0), "=&c" (__d1) + : "a" (__c), "0" (__s), "1" (__n) + : "memory"); + return __s; +} + + + + +/* Search N bytes of S for C. */ +#define _HAVE_STRING_ARCH_memchr 1 +#ifndef _FORCE_INLINES +__STRING_INLINE void * +memchr (__const void *__s, int __c, size_t __n) +{ + register unsigned long int __d0; + register void *__res; + if (__n == 0) + return NULL; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "je 1f\n\t" + "movl $1,%0\n" + "1:" + : "=D" (__res), "=&c" (__d0) + : "a" (__c), "0" (__s), "1" (__n), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "cc"); + return __res - 1; +} +#endif + +#define _HAVE_STRING_ARCH_memrchr 1 +#ifndef _FORCE_INLINES +__STRING_INLINE void * +__memrchr (__const void *__s, int __c, size_t __n) +{ + register unsigned long int __d0; + register void *__res; + if (__n == 0) + return NULL; + __asm__ __volatile__ + ("std\n\t" + "repne; scasb\n\t" + "je 1f\n\t" + "orl $-1,%0\n" + "1:\tcld\n\t" + "incl %0" + : "=D" (__res), "=&c" (__d0) + : "a" (__c), "0" (__s + __n - 1), "1" (__n), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s) + : "cc"); + return __res; +} +# ifdef __USE_GNU +# define memrchr(s, c, n) __memrchr (s, c, n) +# endif +#endif + +/* Return the length of S. */ +#define _HAVE_STRING_ARCH_strlen 1 +#ifndef _FORCE_INLINES +__STRING_INLINE size_t +strlen (__const char *__str) +{ + register unsigned long int __d0; + register size_t __res; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "notl %0" + : "=c" (__res), "=&D" (__d0) + : "1" (__str), "a" (0), "0" (0xffffffff), + "m" ( *(struct { char __x[0xfffffff]; } *)__str) + : "cc"); + return __res - 1; +} +#endif + +/* Copy SRC to DEST. */ +#define _HAVE_STRING_ARCH_strcpy 1 +#ifndef _FORCE_INLINES +__STRING_INLINE char * +strcpy (char *__dest, __const char *__src) +{ + register unsigned long int __d0, __d1; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "lodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b" + : "=&S" (__d0), "=&D" (__d1) + : "0" (__src), "1" (__dest) + : "ax", "memory", "cc"); + return __dest; +} +#endif + +/* Copy no more than N characters of SRC to DEST. */ +#define _HAVE_STRING_ARCH_strncpy 1 +#ifndef _FORCE_INLINES +__STRING_INLINE char * +strncpy (char *__dest, __const char *__src, size_t __n) +{ + register unsigned long int __d0, __d1, __d2; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "decl %2\n\t" + "js 2f\n\t" + "lodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "rep; stosb\n" + "2:" + : "=&S" (__d0), "=&D" (__d1), "=&c" (__d2) + : "0" (__src), "1" (__dest), "2" (__n) + : "ax", "memory", "cc"); + return __dest; +} +#endif + +/* Append SRC onto DEST. */ +#define _HAVE_STRING_ARCH_strcat 1 +#ifndef _FORCE_INLINES +__STRING_INLINE char * +strcat (char *__dest, __const char *__src) +{ + register unsigned long int __d0, __d1, __d2, __d3; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "decl %1\n" + "1:\n\t" + "lodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b" + : "=&S" (__d0), "=&D" (__d1), "=&c" (__d2), "=&a" (__d3) + : "0" (__src), "1" (__dest), "2" (0xffffffff), "3" (0) + : "memory", "cc"); + return __dest; +} +#endif + +/* Append no more than N characters from SRC onto DEST. */ +#define _HAVE_STRING_ARCH_strncat 1 +#ifndef _FORCE_INLINES +__STRING_INLINE char * +strncat (char *__dest, __const char *__src, size_t __n) +{ + register unsigned long int __d0, __d1, __d2, __d3; + __asm__ __volatile__ + ("cld\n\t" + "repne; scasb\n\t" + "decl %1\n\t" + "movl %4,%2\n" + "1:\n\t" + "decl %2\n\t" + "js 2f\n\t" + "lodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "jmp 3f\n" + "2:\n\t" + "xorl %3,%3\n\t" + "stosb\n" + "3:" + : "=&S" (__d0), "=&D" (__d1), "=&c" (__d2), "=&a" (__d3) + : "g" (__n), "0" (__src), "1" (__dest), "2" (0xffffffff), "3" (0) + : "memory", "cc"); + return __dest; +} +#endif + +/* Compare S1 and S2. */ +#define _HAVE_STRING_ARCH_strcmp 1 +#ifndef _FORCE_INLINES +__STRING_INLINE int +strcmp (__const char *__s1, __const char *__s2) +{ + register unsigned long int __d0, __d1; + register int __res; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "lodsb\n\t" + "scasb\n\t" + "jne 2f\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "xorl %%eax,%%eax\n\t" + "jmp 3f\n" + "2:\n\t" + "sbbl %%eax,%%eax\n\t" + "orb $1,%%al\n" + "3:" + : "=a" (__res), "=&S" (__d0), "=&D" (__d1) + : "1" (__s1), "2" (__s2), + "m" ( *(struct { char __x[0xfffffff]; } *)__s1), + "m" ( *(struct { char __x[0xfffffff]; } *)__s2) + : "cc"); + return __res; +} +#endif + +/* Compare N characters of S1 and S2. */ +#define _HAVE_STRING_ARCH_strncmp 1 +#ifndef _FORCE_INLINES +__STRING_INLINE int +strncmp (__const char *__s1, __const char *__s2, size_t __n) +{ + register unsigned long int __d0, __d1, __d2; + register int __res; + __asm__ __volatile__ + ("cld\n" + "1:\n\t" + "decl %3\n\t" + "js 2f\n\t" + "lodsb\n\t" + "scasb\n\t" + "jne 3f\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n" + "2:\n\t" + "xorl %%eax,%%eax\n\t" + "jmp 4f\n" + "3:\n\t" + "sbbl %%eax,%%eax\n\t" + "orb $1,%%al\n" + "4:" + : "=a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2) + : "1" (__s1), "2" (__s2), "3" (__n), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s1), + "m" ( *(struct { __extension__ char __x[__n]; } *)__s2) + : "cc"); + return __res; +} +#endif + +/* Find the first occurrence of C in S. */ +#define _HAVE_STRING_ARCH_strchr 1 +#define _USE_STRING_ARCH_strchr 1 +#define strchr(s, c) \ + (__extension__ (__builtin_constant_p (c) \ + ? __strchr_c (s, ((c) & 0xff) << 8) \ + : __strchr_g (s, c))) + +__STRING_INLINE char *__strchr_g (__const char *__s, int __c); + +__STRING_INLINE char * +__strchr_g (__const char *__s, int __c) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "movb %%al,%%ah\n" + "1:\n\t" + "lodsb\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "movl $1,%1\n" + "2:\n\t" + "movl %1,%0" + : "=a" (__res), "=&S" (__d0) + : "0" (__c), "1" (__s), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res - 1; +} + +__STRING_INLINE char *__strchr_c (__const char *__s, int __c); + +__STRING_INLINE char * +__strchr_c (__const char *__s, int __c) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "1:\n\t" + "lodsb\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "movl $1,%1\n" + "2:\n\t" + "movl %1,%0" + : "=a" (__res), "=&S" (__d0) + : "0" (__c), "1" (__s), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res - 1; +} + + +/* Find the first occurrence of C in S or the final NUL byte. */ +#define _HAVE_STRING_ARCH_strchrnul 1 +#define __strchrnul(s, c) \ + (__extension__ (__builtin_constant_p (c) \ + ? ((c) == '\0' \ + ? (char *) __rawmemchr (s, c) \ + : __strchrnul_c (s, ((c) & 0xff) << 8)) \ + : __strchrnul_g (s, c))) + +__STRING_INLINE char *__strchrnul_g (__const char *__s, int __c); + +__STRING_INLINE char * +__strchrnul_g (__const char *__s, int __c) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "movb %%al,%%ah\n" + "1:\n\t" + "lodsb\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "2:\n\t" + "movl %1,%0" + : "=a" (__res), "=&S" (__d0) + : "0" (__c), "1" (__s), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res - 1; +} + +__STRING_INLINE char *__strchrnul_c (__const char *__s, int __c); + +__STRING_INLINE char * +__strchrnul_c (__const char *__s, int __c) +{ + register unsigned long int __d0; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "1:\n\t" + "lodsb\n\t" + "cmpb %%ah,%%al\n\t" + "je 2f\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "2:\n\t" + "movl %1,%0" + : "=a" (__res), "=&S" (__d0) + : "0" (__c), "1" (__s), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res - 1; +} +#ifdef __USE_GNU +# define strchrnul(s, c) __strchrnul (s, c) +#endif + + +/* Return the length of the initial segment of S which + consists entirely of characters not in REJECT. */ +#define _HAVE_STRING_ARCH_strcspn 1 +#ifndef _FORCE_INLINES +# ifdef __PIC__ +__STRING_INLINE size_t +strcspn (__const char *__s, __const char *__reject) +{ + register unsigned long int __d0, __d1, __d2; + register char *__res; + __asm__ __volatile__ + ("pushl %%ebx\n\t" + "cld\n\t" + "movl %4,%%edi\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" + "movl %%ecx,%%ebx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %4,%%edi\n\t" + "movl %%ebx,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n" + "2:\n\t" + "popl %%ebx" + : "=&S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "d" (__reject), "0" (__s), "1" (0), "2" (0xffffffff), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return (__res - 1) - __s; +} +# else +__STRING_INLINE size_t +strcspn (__const char *__s, __const char *__reject) +{ + register unsigned long int __d0, __d1, __d2, __d3; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "movl %5,%%edi\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" + "movl %%ecx,%%edx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %5,%%edi\n\t" + "movl %%edx,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n" + "2:" + : "=&S" (__res), "=&a" (__d0), "=&c" (__d1), "=&d" (__d2), "=&D" (__d3) + : "g" (__reject), "0" (__s), "1" (0), "2" (0xffffffff), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return (__res - 1) - __s; +} +# endif +#endif + + +/* Return the length of the initial segment of S which + consists entirely of characters in ACCEPT. */ +#define _HAVE_STRING_ARCH_strspn 1 +#ifndef _FORCE_INLINES +# ifdef __PIC__ +__STRING_INLINE size_t +strspn (__const char *__s, __const char *__accept) +{ + register unsigned long int __d0, __d1, __d2; + register char *__res; + __asm__ __volatile__ + ("pushl %%ebx\n\t" + "cld\n\t" + "movl %4,%%edi\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" + "movl %%ecx,%%ebx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %4,%%edi\n\t" + "movl %%ebx,%%ecx\n\t" + "repne; scasb\n\t" + "je 1b\n" + "2:\n\t" + "popl %%ebx" + : "=&S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "r" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return (__res - 1) - __s; +} +# else +__STRING_INLINE size_t +strspn (__const char *__s, __const char *__accept) +{ + register unsigned long int __d0, __d1, __d2, __d3; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "movl %5,%%edi\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" + "movl %%ecx,%%edx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %5,%%edi\n\t" + "movl %%edx,%%ecx\n\t" + "repne; scasb\n\t" + "je 1b\n" + "2:" + : "=&S" (__res), "=&a" (__d0), "=&c" (__d1), "=&d" (__d2), "=&D" (__d3) + : "g" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return (__res - 1) - __s; +} +# endif +#endif + + +/* Find the first occurrence in S of any character in ACCEPT. */ +#define _HAVE_STRING_ARCH_strpbrk 1 +#ifndef _FORCE_INLINES +# ifdef __PIC__ +__STRING_INLINE char * +strpbrk (__const char *__s, __const char *__accept) +{ + unsigned long int __d0, __d1, __d2; + register char *__res; + __asm__ __volatile__ + ("pushl %%ebx\n\t" + "cld\n\t" + "movl %4,%%edi\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" + "movl %%ecx,%%ebx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %4,%%edi\n\t" + "movl %%ebx,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n\t" + "decl %0\n\t" + "jmp 3f\n" + "2:\n\t" + "xorl %0,%0\n" + "3:\n\t" + "popl %%ebx" + : "=&S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2) + : "r" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res; +} +# else +__STRING_INLINE char * +strpbrk (__const char *__s, __const char *__accept) +{ + register unsigned long int __d0, __d1, __d2, __d3; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" + "movl %5,%%edi\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" + "movl %%ecx,%%edx\n" + "1:\n\t" + "lodsb\n\t" + "testb %%al,%%al\n\t" + "je 2f\n\t" + "movl %5,%%edi\n\t" + "movl %%edx,%%ecx\n\t" + "repne; scasb\n\t" + "jne 1b\n\t" + "decl %0\n\t" + "jmp 3f\n" + "2:\n\t" + "xorl %0,%0\n" + "3:" + : "=&S" (__res), "=&a" (__d0), "=&c" (__d1), "=&d" (__d2), "=&D" (__d3) + : "g" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), + "m" ( *(struct { char __x[0xfffffff]; } *)__s) + : "cc"); + return __res; +} +# endif +#endif + + +/* Find the first occurrence of NEEDLE in HAYSTACK. */ +#define _HAVE_STRING_ARCH_strstr 1 +#ifndef _FORCE_INLINES +# ifdef __PIC__ +__STRING_INLINE char * +strstr (__const char *__haystack, __const char *__needle) +{ + register unsigned long int __d0, __d1, __d2; + register char *__res; + __asm__ __volatile__ + ("pushl %%ebx\n\t" + "cld\n\t" \ + "movl %4,%%edi\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */ + "movl %%ecx,%%ebx\n" + "1:\n\t" + "movl %4,%%edi\n\t" + "movl %%esi,%%eax\n\t" + "movl %%ebx,%%ecx\n\t" + "repe; cmpsb\n\t" + "je 2f\n\t" /* also works for empty string, see above */ + "xchgl %%eax,%%esi\n\t" + "incl %%esi\n\t" + "cmpb $0,-1(%%eax)\n\t" + "jne 1b\n\t" + "xorl %%eax,%%eax\n\t" + "2:\n\t" + "popl %%ebx" + : "=&a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2) + : "r" (__needle), "0" (0), "1" (0xffffffff), "2" (__haystack) + : "memory", "cc"); + return __res; +} +# else +__STRING_INLINE char * +strstr (__const char *__haystack, __const char *__needle) +{ + register unsigned long int __d0, __d1, __d2, __d3; + register char *__res; + __asm__ __volatile__ + ("cld\n\t" \ + "movl %5,%%edi\n\t" + "repne; scasb\n\t" + "notl %%ecx\n\t" + "decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */ + "movl %%ecx,%%edx\n" + "1:\n\t" + "movl %5,%%edi\n\t" + "movl %%esi,%%eax\n\t" + "movl %%edx,%%ecx\n\t" + "repe; cmpsb\n\t" + "je 2f\n\t" /* also works for empty string, see above */ + "xchgl %%eax,%%esi\n\t" + "incl %%esi\n\t" + "cmpb $0,-1(%%eax)\n\t" + "jne 1b\n\t" + "xorl %%eax,%%eax\n\t" + "2:" + : "=&a" (__res), "=&c" (__d0), "=&S" (__d1), "=&d" (__d2), "=&D" (__d3) + : "g" (__needle), "0" (0), "1" (0xffffffff), "2" (__haystack) + : "memory", "cc"); + return __res; +} +# endif +#endif + +#ifndef _FORCE_INLINES +# undef __STRING_INLINE +#endif + +#endif /* use string inlines && GNU CC */ |