Changes in kernel/generic/src/lib/memstr.c [cb4f078:96b02eb9] in mainline

File:

• kernel/generic/src/lib/memstr.c (modified) (4 diffs)

kernel/generic/src/lib/memstr.c

@@ -28 +28 @@
  */
 
-/** @addtogroup generic
+/** @addtogroup generic 
  * @{
  */
@@ -34 +34 @@
 /**
  * @file
- * @brief Memory string operations.
+ * @brief       Memory string operations.
  *
- * This file provides architecture independent functions to manipulate blocks
- * of memory. These functions are optimized as much as generic functions of
- * this type can be.
+ * This file provides architecture independent functions to manipulate blocks of
+ * memory. These functions are optimized as much as generic functions of this
+ * type can be. However, architectures are free to provide even more optimized
+ * versions of these functions.
  */
 
@@ -45 +46 @@
 #include <align.h>
 
-/** Fill block of memory.
+/** Copy block of memory.
  *
- * Fill cnt bytes at dst address with the value val.
+ * Copy cnt bytes from src address to dst address.  The copying is done
+ * word-by-word and then byte-by-byte.  The source and destination memory areas
+ * cannot overlap.
  *
- * @param dst Destination address to fill.
- * @param cnt Number of bytes to fill.
- * @param val Value to fill.
+ * @param src           Source address to copy from.
+ * @param dst           Destination address to copy to.
+ * @param cnt           Number of bytes to copy.
  *
+ * @return              Destination address.
  */
-void memsetb(void *dst, size_t cnt, uint8_t val)
+void *_memcpy(void *dst, const void *src, size_t cnt)
 {
-        __builtin_memset(dst, val, cnt);
-}
-
-/** Fill block of memory.
- *
- * Fill cnt words at dst address with the value val. The filling
- * is done word-by-word.
- *
- * @param dst Destination address to fill.
- * @param cnt Number of words to fill.
- * @param val Value to fill.
- *
- */
-void memsetw(void *dst, size_t cnt, uint16_t val)
-{
-        size_t i;
-        uint16_t *ptr = (uint16_t *) dst;
+        unsigned int i, j;
         
-        for (i = 0; i < cnt; i++)
-                ptr[i] = val;
-}
-
-/** Fill block of memory.
- *
- * Fill cnt bytes at dst address with the value val.
- *
- * @param dst Destination address to fill.
- * @param val Value to fill.
- * @param cnt Number of bytes to fill.
- *
- * @return Destination address.
- *
- */
-void *memset(void *dst, int val, size_t cnt)
-{
-        return __builtin_memset(dst, val, cnt);
-}
-
-/** Move memory block without overlapping.
- *
- * Copy cnt bytes from src address to dst address. The source
- * and destination memory areas cannot overlap.
- *
- * @param dst Destination address to copy to.
- * @param src Source address to copy from.
- * @param cnt Number of bytes to copy.
- *
- * @return Destination address.
- *
- */
-void *memcpy(void *dst, const void *src, size_t cnt)
-{
-        return __builtin_memcpy(dst, src, cnt);
+        if (ALIGN_UP((uintptr_t) src, sizeof(sysarg_t)) != (uintptr_t) src ||
+            ALIGN_UP((uintptr_t) dst, sizeof(sysarg_t)) != (uintptr_t) dst) {
+                for (i = 0; i < cnt; i++)
+                        ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
+        } else { 
+                for (i = 0; i < cnt / sizeof(sysarg_t); i++)
+                        ((sysarg_t *) dst)[i] = ((sysarg_t *) src)[i];
+                
+                for (j = 0; j < cnt % sizeof(sysarg_t); j++)
+                        ((uint8_t *)(((sysarg_t *) dst) + i))[j] =
+                            ((uint8_t *)(((sysarg_t *) src) + i))[j];
+        }
+                
+        return (char *) dst;
 }
 
 /** Move memory block with possible overlapping.
  *
- * Copy cnt bytes from src address to dst address. The source
- * and destination memory areas may overlap.
+ * Copy cnt bytes from src address to dst address. The source and destination
+ * memory areas may overlap.
  *
- * @param dst Destination address to copy to.
- * @param src Source address to copy from.
- * @param cnt Number of bytes to copy.
+ * @param src           Source address to copy from.
+ * @param dst           Destination address to copy to.
+ * @param cnt           Number of bytes to copy.
  *
- * @return Destination address.
- *
+ * @return              Destination address.
  */
-void *memmove(void *dst, const void *src, size_t cnt)
+void *memmove(void *dst, const void *src, size_t n)
 {
+        const uint8_t *sp;
+        uint8_t *dp;
+
         /* Nothing to do? */
         if (src == dst)
                 return dst;
-        
+
         /* Non-overlapping? */
-        if ((dst >= src + cnt) || (src >= dst + cnt))
-                return memcpy(dst, src, cnt);
-        
-        const uint8_t *sp;
-        uint8_t *dp;
-        
+        if (dst >= src + n || src >= dst + n) { 
+                return memcpy(dst, src, n);
+        }
+
         /* Which direction? */
         if (src > dst) {
@@ -141 +108 @@
                 sp = src;
                 dp = dst;
-                
-                while (cnt-- != 0)
+
+                while (n-- != 0)
                         *dp++ = *sp++;
         } else {
                 /* Backwards. */
-                sp = src + (cnt - 1);
-                dp = dst + (cnt - 1);
-                
-                while (cnt-- != 0)
+                sp = src + (n - 1);
+                dp = dst + (n - 1);
+
+                while (n-- != 0)
                         *dp-- = *sp--;
         }
+
+        return dst;
+}
+
+/** Fill block of memory
+ *
+ * Fill cnt bytes at dst address with the value x.  The filling is done
+ * byte-by-byte.
+ *
+ * @param dst           Destination address to fill.
+ * @param cnt           Number of bytes to fill.
+ * @param x             Value to fill.
+ *
+ */
+void _memsetb(void *dst, size_t cnt, uint8_t x)
+{
+        unsigned int i;
+        uint8_t *p = (uint8_t *) dst;
         
-        return dst;
+        for (i = 0; i < cnt; i++)
+                p[i] = x;
+}
+
+/** Fill block of memory.
+ *
+ * Fill cnt words at dst address with the value x.  The filling is done
+ * word-by-word.
+ *
+ * @param dst           Destination address to fill.
+ * @param cnt           Number of words to fill.
+ * @param x             Value to fill.
+ *
+ */
+void _memsetw(void *dst, size_t cnt, uint16_t x)
+{
+        unsigned int i;
+        uint16_t *p = (uint16_t *) dst;
+        
+        for (i = 0; i < cnt; i++)
+                p[i] = x;       
 }