#undef memchr
/* Search no more than N bytes of S for C. */
-void * memchr (const void * s, int c_in, size_t n)
+void attribute_hidden *__memchr (const void * s, int c_in, size_t n)
{
const unsigned char *char_ptr;
const unsigned long int *longword_ptr;
return 0;
}
+
+strong_alias(__memchr, memchr)
}
int
-memcmp (s1, s2, len)
- const __ptr_t s1;
- const __ptr_t s2;
- size_t len;
+attribute_hidden __memcmp (const __ptr_t s1, const __ptr_t s2, size_t len)
{
op_t a0;
op_t b0;
return 0;
}
-#ifdef weak_alias
-# undef bcmp
-weak_alias (memcmp, bcmp)
-#endif
+
+strong_alias(__memcmp, memcmp)
+
+weak_alias(memcmp, bcmp)
((op_t *) dstp)[0] = MERGE (a2, sh_1, a3, sh_2);
}
-void *memcpy (void *dstpp, const void *srcpp, size_t len)
+void attribute_hidden *__memcpy (void *dstpp, const void *srcpp, size_t len)
{
unsigned long int dstp = (long int) dstpp;
unsigned long int srcp = (long int) srcpp;
return dstpp;
}
+
+strong_alias(__memcpy, memcpy)
#undef memmem
/* Return the first occurrence of NEEDLE in HAYSTACK. */
-void *memmem (const void *haystack, size_t haystack_len,
+void attribute_hidden *__memmem (const void *haystack, size_t haystack_len,
const void *needle, size_t needle_len)
{
const char *begin;
return NULL;
}
+
+strong_alias(__memmem, memmem)
((op_t *) dstp)[3] = MERGE (a0, sh_1, a1, sh_2);
}
-void *memmove (void *dest, const void *src, size_t len)
+#undef memmove
+
+void attribute_hidden *__memmove (void *dest, const void *src, size_t len)
{
unsigned long int dstp = (long int) dest;
unsigned long int srcp = (long int) src;
return (dest);
}
+
+strong_alias(__memmove, memmove)
#include <string.h>
#undef mempcpy
-#undef __mempcpy
-void *__mempcpy (void *dstpp, const void *srcpp, size_t len)
+void attribute_hidden *__mempcpy (void *dstpp, const void *srcpp, size_t len)
{
memcpy(dstpp, srcpp, len);
return (void *)(((char *)dstpp) + len);
}
-weak_alias (__mempcpy, mempcpy)
+
+strong_alias (__mempcpy, mempcpy)
#undef memrchr
/* Search no more than N bytes of S for C. */
-void *memrchr (const void * s, int c_in, size_t n)
+void attribute_hidden *__memrchr (const void * s, int c_in, size_t n)
{
const unsigned char *char_ptr;
const unsigned long int *longword_ptr;
return 0;
}
+
+strong_alias(__memrchr, memrchr)
#undef memset
-void *
-memset (dstpp, c, len)
+void attribute_hidden *__memset (dstpp, c, len)
void *dstpp;
int c;
size_t len;
return dstpp;
}
+
+strong_alias(__memset, memset)
#undef rawmemchr
/* Find the first occurrence of C in S. */
-void *rawmemchr (const void * s, int c_in)
+void attribute_hidden *__rawmemchr (const void * s, int c_in)
{
const unsigned char *char_ptr;
const unsigned long int *longword_ptr;
}
}
}
+
+strong_alias(__rawmemchr, rawmemchr)
#undef strcat
/* Append SRC on the end of DEST. */
-char *
-strcat (dest, src)
+char attribute_hidden *__strcat (dest, src)
char *dest;
const char *src;
{
return dest;
}
+
+strong_alias(__strcat, strcat)
#undef strchr
/* Find the first occurrence of C in S. */
-char *
-strchr (s, c_in)
+char attribute_hidden *__strchr (s, c_in)
const char *s;
int c_in;
{
return NULL;
}
-#ifdef weak_alias
-#undef index
-weak_alias (strchr, index)
-#endif
+strong_alias(__strchr, strchr)
+
+weak_alias(strchr, index)
#include "memcopy.h"
-#undef __strchrnul
#undef strchrnul
/* Find the first occurrence of C in S or the final NUL byte. */
-char *__strchrnul (const char *s, int c_in)
+char attribute_hidden *__strchrnul (const char *s, int c_in)
{
const unsigned char *char_ptr;
const unsigned long int *longword_ptr;
return NULL;
}
-weak_alias (__strchrnul, strchrnul)
+strong_alias(__strchrnul, strchrnul)
/* Compare S1 and S2, returning less than, equal to or
greater than zero if S1 is lexicographically less than,
equal to or greater than S2. */
-int
-strcmp (p1, p2)
+int attribute_hidden __strcmp (p1, p2)
const char *p1;
const char *p2;
{
return c1 - c2;
}
+strong_alias(__strcmp, strcmp)
+
#ifdef __LOCALE_C_ONLY
-weak_alias(strcmp,strcoll);
+weak_alias(__strcmp, __strcoll)
+strong_alias(__strcoll, strcoll)
#endif /* __LOCALE_C_ONLY */
#undef strcpy
/* Copy SRC to DEST. */
-char *
-strcpy (dest, src)
+char attribute_hidden *__strcpy (dest, src)
char *dest;
const char *src;
{
return dest;
}
+
+strong_alias(__strcpy, strcpy)
/* Return the length of the maximum initial segment of S
which contains no characters from REJECT. */
-size_t
-strcspn (s, reject)
- const char *s;
- const char *reject;
+size_t attribute_hidden __strcspn (const char *s, const char *reject)
{
size_t count = 0;
return count;
}
+
+strong_alias(__strcspn, strcspn)
/* Return the length of the null-terminated string STR. Scan for
the null terminator quickly by testing four bytes at a time. */
-size_t
-strlen (str)
+size_t attribute_hidden __strlen (str)
const char *str;
{
const char *char_ptr;
}
}
}
+
+strong_alias(__strlen, strlen)
#undef strncat
-char *
-strncat (s1, s2, n)
+char attribute_hidden *__strncat (s1, s2, n)
char *s1;
const char *s2;
size_t n;
return s;
}
+
+strong_alias(__strncat, strncat)
returning less than, equal to or greater than zero
if S1 is lexicographically less than, equal to or
greater than S2. */
-int
-strncmp (s1, s2, n)
- const char *s1;
- const char *s2;
- size_t n;
+int attribute_hidden __strncmp (const char *s1, const char *s2, size_t n)
{
unsigned reg_char c1 = '\0';
unsigned reg_char c2 = '\0';
return c1 - c2;
}
+
+strong_alias(__strncmp, strncmp)
#undef strncpy
-char *
-strncpy (s1, s2, n)
+char attribute_hidden *__strncpy (s1, s2, n)
char *s1;
const char *s2;
size_t n;
return s;
}
+
+strong_alias(__strncpy, strncpy)
#include <string.h>
#include <stdlib.h>
+#undef strnlen
+
/* Find the length of S, but scan at most MAXLEN characters. If no
'\0' terminator is found in that many characters, return MAXLEN. */
-size_t strnlen (const char *str, size_t maxlen)
+size_t attribute_hidden __strnlen (const char *str, size_t maxlen)
{
const char *char_ptr, *end_ptr = str + maxlen;
const unsigned long int *longword_ptr;
char_ptr = end_ptr;
return char_ptr - str;
}
+
+strong_alias(__strnlen, strnlen)
#undef strrchr
/* Find the last occurrence of C in S. */
-char *
-strrchr (const char *s, int c)
+char attribute_hidden *__strrchr (const char *s, int c)
{
register const char *found, *p;
return (char *) found;
}
-#ifdef weak_alias
-#undef rindex
+strong_alias(__strrchr, strrchr)
+
weak_alias (strrchr, rindex)
-#endif
#undef strsep
-char *strsep (char **stringp, const char *delim)
+char attribute_hidden *__strsep (char **stringp, const char *delim)
{
char *begin, *end;
return begin;
}
+
+strong_alias(__strsep, strsep)
/* Return the length of the maximum initial segment
of S which contains only characters in ACCEPT. */
-size_t
-strspn (s, accept)
- const char *s;
- const char *accept;
+size_t attribute_hidden __strspn (const char *s, const char *accept)
{
const char *p;
const char *a;
return count;
}
+
+strong_alias(__strspn, strspn)
#undef strstr
-char *
-strstr (phaystack, pneedle)
- const char *phaystack;
- const char *pneedle;
+char attribute_hidden *__strstr (const char *phaystack, const char *pneedle)
{
const unsigned char *haystack, *needle;
chartype b;
ret0:
return 0;
}
+
+strong_alias(__strstr, strstr)
#include <string.h>
#undef strtok_r
-#undef __strtok_r
/* Parse S into tokens separated by characters in DELIM.
If S is NULL, the saved pointer in SAVE_PTR is used as
x = strtok_r(NULL, "=", &sp); // x = NULL
// s = "abc\0-def\0"
*/
-char *
-__strtok_r (s, delim, save_ptr)
+char attribute_hidden *__strtok_r (s, delim, save_ptr)
char *s;
const char *delim;
char **save_ptr;
}
return token;
}
-weak_alias (__strtok_r, strtok_r)
+
+strong_alias(__strtok_r, strtok_r)
OSDN Git Service
