memcpy and memmove
from waterloo university
/* 00002 * This file is shared between libc and the kernel,
so don't put anything 00003 * in here that won't work in both contexts. 00004 */ 00005 00006 #ifdef _KERNEL 00007 #include <types.h> 00008 #include <lib.h> 00009 #else 00010 #include <string.h> 00011 #endif 00012 00013 /* 00014 * C standard function - copy a block of memory. 00015 */ 00016 00017 void * 00018 memcpy(void *dst, const void *src, size_t len) 00019 { 00020 size_t i; 00021 00022 /* 00023 * memcpy does not support overlapping buffers,
00024 * so always do it forwards.
00025 * (Don't change this without adjusting memmove.) 00026 * For speedy copying, optimize the common case
00027 * where both pointers and the length are word-aligned, 00028 * and copy word-at-a-time insteadof byte-at-a-time.
00029 *Otherwise, copy by bytes. 00030 * The alignment logic below should be portable. 00031 * We rely onthe compiler to be reasonably intelligent 00032 * about optimizing the divides and modulos out.
00033 * Fortunately, it is.*/ 00034 00035 if ((uintptr_t)dst % sizeof(long) == 0 && 00036 (uintptr_t)src % sizeof(long) == 0 && 00037 len % sizeof(long) == 0) { 00038 00039 long *d = dst; 00040 const long *s = src; 00041 00042 for (i=0; i<len/sizeof(long); i++) { 00043 d[i] = s[i]; 00044 } 00045 } 00046 else { 00047 char *d = dst; 00048 const char *s = src; 00049 00050 for (i=0; i<len; i++) { 00051 d[i] = s[i]; 00052 } 00053 } 00054 00055 return dst; 00056 }
/* 00014 * C standard function - copy a block of memory,
00015 * handling overlapping * regions correctly. 00016 */ 00017 00018 void * 00019 memmove(void *dst, const void *src, size_t len) 00020 { 00021 size_t i; 00022 00023 /* 00024 * If the buffers don't overlap, it doesn't matter 00025 * what direction we copy in. If they do, it does,
00026 * so just assume they always do.We don't concern
00027 * ourselves with the possibility that the region
00028 * to copy might roll over across the top of memory,
00029 * because it's not going to happen. 00030 * If the destination is above the source, we have 00031 * to copy back to front to avoid overwriting the
00032 * data we want to copy. 00033 * 00034 * dest: dddddddd 00035 * src: ssssssss ^ 00036 * | ^ |___| 00037 * |___| 00038 * 00039 * If the destination is below the source, we have to 00040 * copy front to back. 00041 * 00042 * dest: dddddddd 00043 * src: ^ ssssssss 00044 * |___| ^ | 00045 * |___| 00046 */ 00047 00048 if ((uintptr_t)dst < (uintptr_t)src) { 00049 /* 00050 * As author/maintainer of libc, take advantage of the 00051 * fact that we know memcpy copies forwards. 00052 */ 00053 return memcpy(dst, src, len); 00054 } 00055 00056 /* 00057 * Copy by words in the common case. Look in 00058 * memcpy.c for more information. 00059 */ 00060 00061 if ((uintptr_t)dst % sizeof(long) == 0 && 00062 (uintptr_t)src % sizeof(long) == 0 && 00063 len % sizeof(long) == 0) { 00064 00065 long *d = dst; 00066 const long *s = src; 00067 00068 /* 00069 * The reason we copy index i-1 and test i>0 is that 00070 * i is unsigned - so testing i>=0 doesn't work. 00071 */ 00072 00073 for (i=len/sizeof(long); i>0; i--) { 00074 d[i-1] = s[i-1]; 00075 } 00076 } 00077 else { 00078 char *d = dst; 00079 const char *s = src; 00080 00081 for (i=len; i>0; i--) { 00082 d[i-1] = s[i-1]; 00083 } 00084 } 00085 00086 return dst; 00087}