diff options
| -rw-r--r-- | libc/string/i386/Makefile.arch | 23 | ||||
| -rw-r--r-- | libc/string/i386/memchr.c | 52 | ||||
| -rw-r--r-- | libc/string/i386/memcpy.c | 54 | ||||
| -rw-r--r-- | libc/string/i386/memmove.c | 60 | ||||
| -rw-r--r-- | libc/string/i386/memset.c | 48 | ||||
| -rw-r--r-- | libc/string/i386/strcat.c | 52 | ||||
| -rw-r--r-- | libc/string/i386/strchr.c | 56 | ||||
| -rw-r--r-- | libc/string/i386/strcmp.c | 61 | ||||
| -rw-r--r-- | libc/string/i386/strcpy.c | 49 | ||||
| -rw-r--r-- | libc/string/i386/string.c | 328 | ||||
| -rw-r--r-- | libc/string/i386/strlen.c | 49 | ||||
| -rw-r--r-- | libc/string/i386/strncat.c | 62 | ||||
| -rw-r--r-- | libc/string/i386/strncmp.c | 59 | ||||
| -rw-r--r-- | libc/string/i386/strncpy.c | 57 | ||||
| -rw-r--r-- | libc/string/i386/strnlen.c | 55 | ||||
| -rw-r--r-- | libc/string/i386/strrchr.c | 54 |
16 files changed, 772 insertions, 347 deletions
diff --git a/libc/string/i386/Makefile.arch b/libc/string/i386/Makefile.arch index e12eb8170..27a29dd16 100644 --- a/libc/string/i386/Makefile.arch +++ b/libc/string/i386/Makefile.arch @@ -5,33 +5,18 @@ # Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. # -MSRC:=string.c -MOBJ:= strcpy.o strncpy.o strcat.o strncat.o strcmp.o \ - strncmp.o strchr.o strrchr.o strlen.o strnlen.o \ - memcpy.o memmove.o memchr.o memset.o - STRING_ARCH_DIR:=$(top_srcdir)libc/string/i386 STRING_ARCH_OUT:=$(top_builddir)libc/string/i386 -STRING_ARCH_MSRC:=$(patsubst %.c,$(STRING_ARCH_DIR)/%.c,$(MSRC)) -STRING_ARCH_MOBJ:=$(patsubst %.o,$(STRING_ARCH_OUT)/%.o,$(MOBJ)) - -STRING_ARCH_OBJS:=$(STRING_ARCH_MOBJ) - -#STRING_ARCH_DEF:=$(patsubst %,-DL_%,$(subst .o,,$(notdir $(STRING_ARCH_OBJS)))) - -$(STRING_ARCH_MOBJ): $(STRING_ARCH_MSRC) - $(compile.m) +STRING_ARCH_CSRC:=$(wildcard $(STRING_ARCH_DIR)/*.c) +STRING_ARCH_COBJ:=$(patsubst $(STRING_ARCH_DIR)/%.c,$(STRING_ARCH_OUT)/%.o,$(STRING_ARCH_CSRC)) -$(STRING_ARCH_MOBJ:.o=.os): $(STRING_ARCH_MSRC) - $(compile.m) +STRING_ARCH_OBJS:=$(STRING_ARCH_COBJ) libc-a-$(UCLIBC_HAS_STRING_ARCH_OPT)+=$(STRING_ARCH_OBJS) libc-so-$(UCLIBC_HAS_STRING_ARCH_OPT)+=$(STRING_ARCH_OBJS:.o=.os) -#CFLAGS-multi-$(UCLIBC_HAS_STRING_ARCH_OPT)+=$(STRING_ARCH_DEF) -#libc-multi-$(UCLIBC_HAS_STRING_ARCH_OPT)+=$(STRING_ARCH_MSRC) -libc-nomulti-$(UCLIBC_HAS_STRING_ARCH_OPT)+=$(STRING_ARCH_OBJS) +libc-multi-$(UCLIBC_HAS_STRING_ARCH_OPT)+=$(STRING_ARCH_CSRC) objclean-y+=string_arch_objclean diff --git a/libc/string/i386/memchr.c b/libc/string/i386/memchr.c new file mode 100644 index 000000000..53a2af2bb --- /dev/null +++ b/libc/string/i386/memchr.c @@ -0,0 +1,52 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +void attribute_hidden *__memchr(const void *cs, int c, size_t count) +{ + int d0; + register void * __res; + if (!count) + return NULL; + __asm__ __volatile__( + "repne\n\t" + "scasb\n\t" + "je 1f\n\t" + "movl $1,%0\n" + "1:\tdecl %0" + :"=D" (__res), "=&c" (d0) : "a" (c),"0" (cs),"1" (count)); + return __res; +} + +strong_alias(__memchr, memchr) diff --git a/libc/string/i386/memcpy.c b/libc/string/i386/memcpy.c new file mode 100644 index 000000000..b2e0236f5 --- /dev/null +++ b/libc/string/i386/memcpy.c @@ -0,0 +1,54 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +void attribute_hidden *__memcpy(void * to, const void * from, size_t n) +{ + int d0, d1, d2; + __asm__ __volatile__( + "rep ; movsl\n\t" + "testb $2,%b4\n\t" + "je 1f\n\t" + "movsw\n" + "1:\ttestb $1,%b4\n\t" + "je 2f\n\t" + "movsb\n" + "2:" + : "=&c" (d0), "=&D" (d1), "=&S" (d2) + :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from) + : "memory"); + return (to); +} + +strong_alias(__memcpy, memcpy) diff --git a/libc/string/i386/memmove.c b/libc/string/i386/memmove.c new file mode 100644 index 000000000..27f6cf264 --- /dev/null +++ b/libc/string/i386/memmove.c @@ -0,0 +1,60 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +void attribute_hidden *__memmove(void *dest, const void *src, size_t n) +{ + int d0, d1, d2; + if (dest<src) + __asm__ __volatile__( + "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; +} + +strong_alias(__memmove, memmove) diff --git a/libc/string/i386/memset.c b/libc/string/i386/memset.c new file mode 100644 index 000000000..a35279643 --- /dev/null +++ b/libc/string/i386/memset.c @@ -0,0 +1,48 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +void attribute_hidden *__memset(void *s, int c, size_t count) +{ + int d0, d1; + __asm__ __volatile__( + "rep\n\t" + "stosb" + : "=&c" (d0), "=&D" (d1) + :"a" (c),"1" (s),"0" (count) + :"memory"); + return s; +} + +strong_alias(__memset, memset) diff --git a/libc/string/i386/strcat.c b/libc/string/i386/strcat.c new file mode 100644 index 000000000..8e4447ee0 --- /dev/null +++ b/libc/string/i386/strcat.c @@ -0,0 +1,52 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +char attribute_hidden *__strcat(char * dest, const char * src) +{ + int d0, d1, d2, d3; + __asm__ __volatile__( + "repne\n\t" + "scasb\n\t" + "decl %1\n" + "1:\tlodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b" + : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3) + : "0" (src), "1" (dest), "2" (0), "3" (0xffffffff):"memory"); + return dest; +} + +strong_alias(__strcat, strcat) diff --git a/libc/string/i386/strchr.c b/libc/string/i386/strchr.c new file mode 100644 index 000000000..075c65c39 --- /dev/null +++ b/libc/string/i386/strchr.c @@ -0,0 +1,56 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +char attribute_hidden *__strchr(const char *s, int c) +{ + int d0; + register char * __res; + __asm__ __volatile__( + "movb %%al,%%ah\n" + "1:\tlodsb\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:\tmovl %1,%0\n\t" + "decl %0" + :"=a" (__res), "=&S" (d0) : "1" (s),"0" (c)); + return __res; +} + +strong_alias(__strchr, strchr) + +weak_alias(strchr, index) diff --git a/libc/string/i386/strcmp.c b/libc/string/i386/strcmp.c new file mode 100644 index 000000000..4744fdf4e --- /dev/null +++ b/libc/string/i386/strcmp.c @@ -0,0 +1,61 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> +#include <locale.h> /* for __LOCALE_C_ONLY */ + +int attribute_hidden __strcmp(const char *cs, const char *ct) +{ + int d0, d1; + register int __res; + __asm__ __volatile__( + "1:\tlodsb\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:\tsbbl %%eax,%%eax\n\t" + "orb $1,%%al\n" + "3:" + :"=a" (__res), "=&S" (d0), "=&D" (d1) + :"1" (cs),"2" (ct)); + return __res; +} + +strong_alias(__strcmp, strcmp) + +#ifdef __LOCALE_C_ONLY +weak_alias(strcmp, strcoll) +#endif /* __LOCALE_C_ONLY */ diff --git a/libc/string/i386/strcpy.c b/libc/string/i386/strcpy.c new file mode 100644 index 000000000..cb923aaba --- /dev/null +++ b/libc/string/i386/strcpy.c @@ -0,0 +1,49 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +char attribute_hidden *__strcpy(char * dest, const char * src) +{ + int d0, d1, d2; + __asm__ __volatile__( + "1:\tlodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b" + : "=&S" (d0), "=&D" (d1), "=&a" (d2) + :"0" (src),"1" (dest) : "memory"); + return dest; +} + +strong_alias(__strcpy, strcpy) diff --git a/libc/string/i386/string.c b/libc/string/i386/string.c deleted file mode 100644 index f827445fe..000000000 --- a/libc/string/i386/string.c +++ /dev/null @@ -1,328 +0,0 @@ -/* - * This string-include defines all string functions as inline - * functions. Use gcc. It also assumes ds=es=data space, this should be - * normal. Most of the string-functions are rather heavily hand-optimized, - * see especially strtok,strstr,str[c]spn. They should work, but are not - * very easy to understand. Everything is done entirely within the register - * set, making the functions fast and clean. String instructions have been - * used through-out, making for "slightly" unclear code :-) - * - * NO Copyright (C) 1991, 1992 Linus Torvalds, - * consider these trivial functions to be PD. - * - * Modified for uClibc by Erik Andersen <andersen@codepoet.org> - * These make no attempt to use nifty things like mmx/3dnow/etc. - * These are not inline, and will therefore not be as fast as - * modifying the headers to use inlines (and cannot therefore - * do tricky things when dealing with const memory). But they - * should (I hope!) be faster than their generic equivalents.... - * - * More importantly, these should provide a good example for - * others to follow when adding arch specific optimizations. - * -Erik - */ - -#define _GNU_SOURCE -#include <string.h> -#include <locale.h> /* for __LOCALE_C_ONLY */ - -#ifdef L_strcpy -char * strcpy(char * dest, const char * src) -{ - int d0, d1, d2; - __asm__ __volatile__( - "1:\tlodsb\n\t" - "stosb\n\t" - "testb %%al,%%al\n\t" - "jne 1b" - : "=&S" (d0), "=&D" (d1), "=&a" (d2) - :"0" (src),"1" (dest) : "memory"); - return dest; -} -#endif - - -#ifdef L_strncpy -char * strncpy(char * dest, const char * src, size_t count) -{ - int d0, d1, d2, d3; - __asm__ __volatile__( - "incl %2\n" - "1:\n" - "decl %2\n" - "jz 2f\n" - "lodsb\n\t" - "stosb\n\t" - "testb %%al,%%al\n\t" - "jne 1b\n\t" - "decl %2\n" - "rep\n\t" - "stosb\n" - "2:" - : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3) - :"0" (src),"1" (dest),"2" (count) : "memory"); - return dest; -} -#endif - - -#ifdef L_strcat -char *strcat(char * dest, const char * src) -{ - int d0, d1, d2, d3; - __asm__ __volatile__( - "repne\n\t" - "scasb\n\t" - "decl %1\n" - "1:\tlodsb\n\t" - "stosb\n\t" - "testb %%al,%%al\n\t" - "jne 1b" - : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3) - : "0" (src), "1" (dest), "2" (0), "3" (0xffffffff):"memory"); - return dest; -} -#endif - - -#ifdef L_strncat -char *strncat(char * dest, - const char * src, size_t count) -{ - int d0, d1, d2, d3; - __asm__ __volatile__( - "repne\n\t" - "scasb\n\t" - "decl %1\n\t" - "movl %8,%3\n" - "incl %3\n" - "1:\tdecl %3\n\t" - "jz 2f\n" - "lodsb\n\t" - "stosb\n\t" - "testb %%al,%%al\n\t" - "jne 1b\n" - "jmp 3f\n" - "2:\txorl %2,%2\n\t" - "stosb\n" - "3:" - : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3) - : "0" (src),"1" (dest),"2" (0),"3" (0xffffffff), "g" (count) - : "memory"); - return dest; -} -#endif - - -#ifdef L_strcmp -int strcmp(const char *cs, const char *ct) -{ - int d0, d1; - register int __res; - __asm__ __volatile__( - "1:\tlodsb\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:\tsbbl %%eax,%%eax\n\t" - "orb $1,%%al\n" - "3:" - :"=a" (__res), "=&S" (d0), "=&D" (d1) - :"1" (cs),"2" (ct)); - return __res; -} -#ifdef __LOCALE_C_ONLY -weak_alias(strcmp,strcoll); -#endif /* __LOCALE_C_ONLY */ -#endif - - -#ifdef L_strncmp -int strncmp(const char *cs, const char *ct, size_t count) -{ - register int __res; - int d0, d1, d2; - __asm__ __volatile__( - "incl %3\n" - "1:\tdecl %3\n\t" - "jz 2f\n" - "lodsb\n\t" - "scasb\n\t" - "jne 3f\n\t" - "testb %%al,%%al\n\t" - "jne 1b\n" - "2:\txorl %%eax,%%eax\n\t" - "jmp 4f\n" - "3:\tsbbl %%eax,%%eax\n\t" - "orb $1,%%al\n" - "4:" - :"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2) - :"1" (cs),"2" (ct),"3" (count)); - return __res; -} -#endif - - -#ifdef L_strchr -char * strchr(const char *s, int c) -{ - int d0; - register char * __res; - __asm__ __volatile__( - "movb %%al,%%ah\n" - "1:\tlodsb\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:\tmovl %1,%0\n\t" - "decl %0" - :"=a" (__res), "=&S" (d0) : "1" (s),"0" (c)); - return __res; -} -weak_alias(strchr,index); -#endif - - -#ifdef L_strrchr -char *strrchr(const char *s, int c) -{ - int d0, d1; - register char * __res; - __asm__ __volatile__( - "movb %%al,%%ah\n" - "1:\tlodsb\n\t" - "cmpb %%ah,%%al\n\t" - "jne 2f\n\t" - "leal -1(%%esi),%0\n" - "2:\ttestb %%al,%%al\n\t" - "jne 1b" - :"=g" (__res), "=&S" (d0), "=&a" (d1) :"0" (0),"1" (s),"2" (c)); - return __res; -} -weak_alias(strrchr,rindex); -#endif - - - -#ifdef L_strlen -size_t strlen(const char *s) -{ - int d0; - register int __res; - __asm__ __volatile__( - "repne\n\t" - "scasb\n\t" - "notl %0\n\t" - "decl %0" - :"=c" (__res), "=&D" (d0) :"1" (s),"a" (0), "0" (0xffffffff)); - return __res; -} -#endif - - -#ifdef L_strnlen -size_t strnlen(const char *s, size_t count) -{ - int d0; - register int __res; - __asm__ __volatile__( - "movl %2,%0\n\t" - "incl %1\n" - "jmp 2f\n" - "1:\tcmpb $0,(%0)\n\t" - "je 3f\n\t" - "incl %0\n" - "2:\tdecl %1\n\t" - "jne 1b\n" - "3:\tsubl %2,%0" - :"=a" (__res), "=&d" (d0) - :"c" (s),"1" (count)); - return __res; -} -#endif - - -#ifdef L_memcpy -void *memcpy(void * to, const void * from, size_t n) -{ - int d0, d1, d2; - __asm__ __volatile__( - "rep ; movsl\n\t" - "testb $2,%b4\n\t" - "je 1f\n\t" - "movsw\n" - "1:\ttestb $1,%b4\n\t" - "je 2f\n\t" - "movsb\n" - "2:" - : "=&c" (d0), "=&D" (d1), "=&S" (d2) - :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from) - : "memory"); - return (to); -} -#endif - - -#ifdef L_memmove -void *memmove(void *dest, const void *src, size_t n) -{ - int d0, d1, d2; - if (dest<src) - __asm__ __volatile__( - "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 - -#ifdef L_memchr -void *memchr(const void *cs, int c, size_t count) -{ - int d0; - register void * __res; - if (!count) - return NULL; - __asm__ __volatile__( - "repne\n\t" - "scasb\n\t" - "je 1f\n\t" - "movl $1,%0\n" - "1:\tdecl %0" - :"=D" (__res), "=&c" (d0) : "a" (c),"0" (cs),"1" (count)); - return __res; -} -#endif - -#ifdef L_memset -void *memset(void *s, int c, size_t count) -{ - int d0, d1; - __asm__ __volatile__( - "rep\n\t" - "stosb" - : "=&c" (d0), "=&D" (d1) - :"a" (c),"1" (s),"0" (count) - :"memory"); - return s; -} -#endif - diff --git a/libc/string/i386/strlen.c b/libc/string/i386/strlen.c new file mode 100644 index 000000000..1371acbeb --- /dev/null +++ b/libc/string/i386/strlen.c @@ -0,0 +1,49 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +size_t attribute_hidden __strlen(const char *s) +{ + int d0; + register int __res; + __asm__ __volatile__( + "repne\n\t" + "scasb\n\t" + "notl %0\n\t" + "decl %0" + :"=c" (__res), "=&D" (d0) :"1" (s),"a" (0), "0" (0xffffffff)); + return __res; +} + +strong_alias(__strlen, strlen) diff --git a/libc/string/i386/strncat.c b/libc/string/i386/strncat.c new file mode 100644 index 000000000..39a22766d --- /dev/null +++ b/libc/string/i386/strncat.c @@ -0,0 +1,62 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +char attribute_hidden *__strncat(char * dest, + const char * src, size_t count) +{ + int d0, d1, d2, d3; + __asm__ __volatile__( + "repne\n\t" + "scasb\n\t" + "decl %1\n\t" + "movl %8,%3\n" + "incl %3\n" + "1:\tdecl %3\n\t" + "jz 2f\n" + "lodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n" + "jmp 3f\n" + "2:\txorl %2,%2\n\t" + "stosb\n" + "3:" + : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3) + : "0" (src),"1" (dest),"2" (0),"3" (0xffffffff), "g" (count) + : "memory"); + return dest; +} + +strong_alias(__strncat, strncat) diff --git a/libc/string/i386/strncmp.c b/libc/string/i386/strncmp.c new file mode 100644 index 000000000..86b317fb8 --- /dev/null +++ b/libc/string/i386/strncmp.c @@ -0,0 +1,59 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +int attribute_hidden __strncmp(const char *cs, const char *ct, size_t count) +{ + register int __res; + int d0, d1, d2; + __asm__ __volatile__( + "incl %3\n" + "1:\tdecl %3\n\t" + "jz 2f\n" + "lodsb\n\t" + "scasb\n\t" + "jne 3f\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n" + "2:\txorl %%eax,%%eax\n\t" + "jmp 4f\n" + "3:\tsbbl %%eax,%%eax\n\t" + "orb $1,%%al\n" + "4:" + :"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2) + :"1" (cs),"2" (ct),"3" (count)); + return __res; +} + +strong_alias(__strncmp, strncmp) diff --git a/libc/string/i386/strncpy.c b/libc/string/i386/strncpy.c new file mode 100644 index 000000000..1e7257e95 --- /dev/null +++ b/libc/string/i386/strncpy.c @@ -0,0 +1,57 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +char attribute_hidden *__strncpy(char * dest, const char * src, size_t count) +{ + int d0, d1, d2, d3; + __asm__ __volatile__( + "incl %2\n" + "1:\n" + "decl %2\n" + "jz 2f\n" + "lodsb\n\t" + "stosb\n\t" + "testb %%al,%%al\n\t" + "jne 1b\n\t" + "decl %2\n" + "rep\n\t" + "stosb\n" + "2:" + : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3) + :"0" (src),"1" (dest),"2" (count) : "memory"); + return dest; +} + +strong_alias(__strncpy, strncpy) diff --git a/libc/string/i386/strnlen.c b/libc/string/i386/strnlen.c new file mode 100644 index 000000000..be7ace51d --- /dev/null +++ b/libc/string/i386/strnlen.c @@ -0,0 +1,55 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +size_t attribute_hidden __strnlen(const char *s, size_t count) +{ + int d0; + register int __res; + __asm__ __volatile__( + "movl %2,%0\n\t" + "incl %1\n" + "jmp 2f\n" + "1:\tcmpb $0,(%0)\n\t" + "je 3f\n\t" + "incl %0\n" + "2:\tdecl %1\n\t" + "jne 1b\n" + "3:\tsubl %2,%0" + :"=a" (__res), "=&d" (d0) + :"c" (s),"1" (count)); + return __res; +} + +strong_alias(__strnlen, strnlen) diff --git a/libc/string/i386/strrchr.c b/libc/string/i386/strrchr.c new file mode 100644 index 000000000..626a12777 --- /dev/null +++ b/libc/string/i386/strrchr.c @@ -0,0 +1,54 @@ +/* + * This string-include defines all string functions as inline + * functions. Use gcc. It also assumes ds=es=data space, this should be + * normal. Most of the string-functions are rather heavily hand-optimized, + * see especially strtok,strstr,str[c]spn. They should work, but are not + * very easy to understand. Everything is done entirely within the register + * set, making the functions fast and clean. String instructions have been + * used through-out, making for "slightly" unclear code :-) + * + * NO Copyright (C) 1991, 1992 Linus Torvalds, + * consider these trivial functions to be PD. + */ + +/* + * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + */ + +/* + * Modified for uClibc by Erik Andersen <andersen@codepoet.org> + * These make no attempt to use nifty things like mmx/3dnow/etc. + * These are not inline, and will therefore not be as fast as + * modifying the headers to use inlines (and cannot therefore + * do tricky things when dealing with const memory). But they + * should (I hope!) be faster than their generic equivalents.... + * + * More importantly, these should provide a good example for + * others to follow when adding arch specific optimizations. + * -Erik + */ + +#define _GNU_SOURCE +#include <string.h> + +char attribute_hidden *__strrchr(const char *s, int c) +{ + int d0, d1; + register char * __res; + __asm__ __volatile__( + "movb %%al,%%ah\n" + "1:\tlodsb\n\t" + "cmpb %%ah,%%al\n\t" + "jne 2f\n\t" + "leal -1(%%esi),%0\n" + "2:\ttestb %%al,%%al\n\t" + "jne 1b" + :"=g" (__res), "=&S" (d0), "=&a" (d1) :"0" (0),"1" (s),"2" (c)); + return __res; +} + +strong_alias(__strrchr, strrchr) + +weak_alias(__strrchr, rindex) |