Merge branch 'next' of https://source.denx.de/u-boot/custodians/u-boot-marvell into...

[platform/kernel/u-boot.git] / lib / string.c

diff --git a/lib/string.c b/lib/string.c
index 9b779dd..78bd65c 100644 (file)
--- a/lib/string.c
+++ b/lib/string.c
@@ -16,6 +16,7 @@
  */
 
 #include <config.h>
+#include <linux/compiler.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
@@ -114,17 +115,21 @@ char * strncpy(char * dest,const char *src,size_t count)
  * NUL-terminated string that fits in the buffer (unless,
  * of course, the buffer size is zero). It does not pad
  * out the result like strncpy() does.
+ *
+ * Return: the number of bytes copied
  */
 size_t strlcpy(char *dest, const char *src, size_t size)
 {
-       size_t ret = strlen(src);
-
        if (size) {
-               size_t len = (ret >= size) ? size - 1 : ret;
+               size_t srclen = strlen(src);
+               size_t len = (srclen >= size) ? size - 1 : srclen;
+
                memcpy(dest, src, len);
                dest[len] = '\0';
+               return len + 1;
        }
-       return ret;
+
+       return 0;
 }
 #endif
 
@@ -176,6 +181,25 @@ char * strncat(char *dest, const char *src, size_t count)
 }
 #endif
 
+#ifndef __HAVE_ARCH_STRLCAT
+/**
+ * strlcat - Append a length-limited, %NUL-terminated string to another
+ * @dest: The string to be appended to
+ * @src: The string to append to it
+ * @size: The size of @dest
+ *
+ * Compatible with *BSD: the result is always a valid NUL-terminated string that
+ * fits in the buffer (unless, of course, the buffer size is zero). It does not
+ * write past @size like strncat() does.
+ */
+size_t strlcat(char *dest, const char *src, size_t size)
+{
+       size_t len = strnlen(dest, size);
+
+       return len + strlcpy(dest + len, src, size - len);
+}
+#endif
+
 #ifndef __HAVE_ARCH_STRCMP
 /**
  * strcmp - Compare two strings
@@ -324,7 +348,6 @@ char * strdup(const char *s)
        strcpy (new, s);
        return new;
 }
-#endif
 
 char * strndup(const char *s, size_t n)
 {
@@ -348,6 +371,7 @@ char * strndup(const char *s, size_t n)
 
        return new;
 }
+#endif
 
 #ifndef __HAVE_ARCH_STRSPN
 /**
@@ -490,7 +514,7 @@ char *strswab(const char *s)
  *
  * Do not use memset() to access IO space, use memset_io() instead.
  */
-void * memset(void * s,int c,size_t count)
+__used void * memset(void * s,int c,size_t count)
 {
        unsigned long *sl = (unsigned long *) s;
        char *s8;
@@ -529,7 +553,7 @@ void * memset(void * s,int c,size_t count)
  * You should not use this function to access IO space, use memcpy_toio()
  * or memcpy_fromio() instead.
  */
-void * memcpy(void *dest, const void *src, size_t count)
+__used void * memcpy(void *dest, const void *src, size_t count)
 {
        unsigned long *dl = (unsigned long *)dest, *sl = (unsigned long *)src;
        char *d8, *s8;
@@ -563,11 +587,23 @@ void * memcpy(void *dest, const void *src, size_t count)
  *
  * Unlike memcpy(), memmove() copes with overlapping areas.
  */
-void * memmove(void * dest,const void *src,size_t count)
+__used void * memmove(void * dest,const void *src,size_t count)
 {
        char *tmp, *s;
 
-       if (dest <= src) {
+       if (dest <= src || (src + count) <= dest) {
+       /*
+        * Use the fast memcpy implementation (ARCH optimized or lib/string.c) when it is possible:
+        * - when dest is before src (assuming that memcpy is doing forward-copying)
+        * - when destination don't overlap the source buffer (src + count <= dest)
+        *
+        * WARNING: the first optimisation cause an issue, when __HAVE_ARCH_MEMCPY is defined,
+        *          __HAVE_ARCH_MEMMOVE is not defined and if the memcpy ARCH-specific
+        *          implementation is not doing a forward-copying.
+        *
+        * No issue today because memcpy is doing a forward-copying in lib/string.c and for ARM32
+        * architecture; no other arches use __HAVE_ARCH_MEMCPY without __HAVE_ARCH_MEMMOVE.
+        */
                memcpy(dest, src, count);
        } else {
                tmp = (char *) dest + count;
@@ -587,7 +623,7 @@ void * memmove(void * dest,const void *src,size_t count)
  * @ct: Another area of memory
  * @count: The size of the area.
  */
-int memcmp(const void * cs,const void * ct,size_t count)
+__used int memcmp(const void * cs,const void * ct,size_t count)
 {
        const unsigned char *su1, *su2;
        int res = 0;
@@ -623,6 +659,19 @@ void * memscan(void * addr, int c, size_t size)
 }
 #endif
 
+char *memdup(const void *src, size_t len)
+{
+       char *p;
+
+       p = malloc(len);
+       if (!p)
+               return NULL;
+
+       memcpy(p, src, len);
+
+       return p;
+}
+
 #ifndef __HAVE_ARCH_STRSTR
 /**
  * strstr - Find the first substring in a %NUL terminated string