void bcopy(const void *src0, void *dst0, size_t length) #endif #endif { char *dst = dst0; const char *src = src0; size_t t; if (length == 0 || dst == src) /* nothing to do */ goto done; /* * Macros: loop-t-times; and loop-t-times, t>0 */ #define TLOOP(s) if (t) TLOOP1(s) #define TLOOP1(s) do { s; } while (--t) if ((unsigned long)dst < (unsigned long)src) { /* * Copy forward. */ t = (long)src; /* only need low bits */ if ((t | (long)dst) & wmask) { /* * Try to align operands. This cannot be done * unless the low bits match. */ if (length < wsize) { t = length; TLOOP1(*dst++ = *src++); goto done; } /* * Src and dst not at same byte offset */ if ((t ^ (long)dst) & wmask) { t = length; #if !defined (MEMCOPY) #if defined(__ARM_NEON__) memcpy(dst0, src0, length); goto done; #else /* BCOPY without NEON */ memcpy(dst0, src0, length); goto done; #endif /* __ARM_NEON__ */ #endif /* !MEMCOPY */ } else t = wsize - (t & wmask); length -= t; TLOOP1(*dst++ = *src++); } /* * Copy whole words, then mop up any trailing bytes. */ t = length / wsize; TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize); t = length & wmask; TLOOP(*dst++ = *src++); } else {
/* * Copy a block of memory, handling overlap. * This is the routine that actually implements * (the portable versions of) bcopy, memcpy, and memmove. */ void * memcpy(void *dst0, const void *src0, size_t length) { char *dst; const char *src; size_t t; dst = dst0; src = src0; if (length == 0 || dst == src) { /* nothing to do */ goto done; } /* * Macros: loop-t-times; and loop-t-times, t>0 */ #define TLOOP(s) if (t) TLOOP1(s) #define TLOOP1(s) do { s; } while (--t) if ((unsigned long)dst < (unsigned long)src) { /* * Copy forward. */ t = (size_t)src; /* only need low bits */ if ((t | (uintptr_t)dst) & wmask) { /* * Try to align operands. This cannot be done * unless the low bits match. */ if ((t ^ (uintptr_t)dst) & wmask || length < wsize) { t = length; } else { t = wsize - (t & wmask); } length -= t; TLOOP1(*dst++ = *src++); } /* * Copy whole words, then mop up any trailing bytes. */ t = length / wsize; TLOOP(*(word *)dst = *(const word *)src; src += wsize; dst += wsize); t = length & wmask; TLOOP(*dst++ = *src++); } else {
void bcopy(const void *src0, void *dst0, size_t length) #endif { char *dst = dst0; const char *src = src0; size_t t; unsigned long u; #if !defined(_KERNEL) _DIAGASSERT(dst0 != 0); _DIAGASSERT(src0 != 0); #endif if (length == 0 || dst == src) /* nothing to do */ goto done; /* * Macros: loop-t-times; and loop-t-times, t>0 */ #define TLOOP(s) if (t) TLOOP1(s) #define TLOOP1(s) do { s; } while (--t) if ((unsigned long)dst < (unsigned long)src) { /* * Copy forward. */ u = (unsigned long)src; /* only need low bits */ if ((u | (unsigned long)dst) & wmask) { /* * Try to align operands. This cannot be done * unless the low bits match. */ if ((u ^ (unsigned long)dst) & wmask || length < wsize) t = length; else t = wsize - (size_t)(u & wmask); length -= t; TLOOP1(*dst++ = *src++); } /* * Copy whole words, then mop up any trailing bytes. */ t = length / wsize; TLOOP(*(word *)(void *)dst = *(const word *)(const void *)src; src += wsize; dst += wsize); t = length & wmask; TLOOP(*dst++ = *src++); } else {
void bcopy(const char *src0, char *dst0, size_t length) #endif #endif { register char *dst = dst0; register const char *src = src0; register size_t t; if (length == 0 || dst == src) /* nothing to do */ goto retval; /* * Macros: loop-t-times; and loop-t-times, t>0 */ #define TLOOP(s) if (t) TLOOP1(s) #define TLOOP1(s) do { s; } while (--t) if ((char *)dst < (char *)src) { /* * Copy forward. */ t = (int)src; /* only need low bits */ if ((t | (int)dst) & wmask) { /* * Try to align operands. This cannot be done * unless the low bits match. */ if ((t ^ (int)dst) & wmask || length < wsize) t = length; else t = wsize - (t & wmask); length -= t; TLOOP1(*dst++ = *src++); } /* * Copy whole words, then mop up any trailing bytes. */ t = length / wsize; TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize); t = length & wmask; TLOOP(*dst++ = *src++); } else {