/*
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}