gen.subproj/i386.subproj/bcopy.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /*
  23  * Copyright (c) 1990, 1993
  24  *      The Regents of the University of California.  All rights reserved.
  25  *
  26  * This code is derived from software contributed to Berkeley by
  27  * Chris Torek.
  28  *
  29  * Redistribution and use in source and binary forms, with or without
  30  * modification, are permitted provided that the following conditions
  31  * are met:
  32  * 1. Redistributions of source code must retain the above copyright
  33  *    notice, this list of conditions and the following disclaimer.
  34  * 2. Redistributions in binary form must reproduce the above copyright
  35  *    notice, this list of conditions and the following disclaimer in the
  36  *    documentation and/or other materials provided with the distribution.
  37  * 3. All advertising materials mentioning features or use of this software
  38  *    must display the following acknowledgement:
  39  *      This product includes software developed by the University of
  40  *      California, Berkeley and its contributors.
  41  * 4. Neither the name of the University nor the names of its contributors
  42  *    may be used to endorse or promote products derived from this software
  43  *    without specific prior written permission.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  48  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  55  * SUCH DAMAGE.
  56  */
  57
  58 #if defined(LIBC_SCCS) && !defined(lint)
  59 static char sccsid[] = "@(#)bcopy.c     8.1 (Berkeley) 6/4/93";
  60 #endif /* LIBC_SCCS and not lint */
  61
  62 #include <sys/cdefs.h>
  63 #include <string.h>
  64
  65 /*
  66  * sizeof(word) MUST BE A POWER OF TWO
  67  * SO THAT wmask BELOW IS ALL ONES
  68  */
  69 typedef int word;               /* "word" used for optimal copy speed */
  70
  71 #define wsize   sizeof(word)
  72 #define wmask   (wsize - 1)
  73
  74 /*
  75  * Copy a block of memory, handling overlap.
  76  * This is the routine that actually implements
  77  * (the portable versions of) bcopy, memcpy, and memmove.
  78  */
  79 #ifdef MEMCOPY
  80 void *
  81 memcpy(dst0, src0, length)
  82 #else
  83 #ifdef MEMMOVE
  84 void *
  85 memmove(dst0, src0, length)
  86 #else
  87 void
  88 bcopy(src0, dst0, length)
  89 #endif
  90 #endif
  91         void *dst0;
  92         const void *src0;
  93         register size_t length;
  94 {
  95         register char *dst = dst0;
  96         register const char *src = src0;
  97         register size_t t;
  98
  99         if (length == 0 || dst == src)          /* nothing to do */
 100                 goto done;
 101
 102         /*
 103          * Macros: loop-t-times; and loop-t-times, t>0
 104          */
 105 #define TLOOP(s) if (t) TLOOP1(s)
 106 #define TLOOP1(s) do { s; } while (--t)
 107
 108         if (((unsigned long)dst < (unsigned long)src) || ((unsigned long)dst >= ((unsigned long)src + length))) {
 109                 /*
 110                  * Copy forward.
 111                  */
 112                 t = (int)src;   /* only need low bits */
 113                 if ((t | (int)dst) & wmask) {
 114                         /*
 115                          * Try to align operands.  This cannot be done
 116                          * unless the low bits match.
 117                          */
 118                         if ((t ^ (int)dst) & wmask || length < wsize)
 119                                 t = length;
 120                         else
 121                                 t = wsize - (t & wmask);
 122                         length -= t;
 123                         TLOOP1(*dst++ = *src++);
 124                 }
 125                 /*
 126                  * Copy whole words, then mop up any trailing bytes.
 127                  */
 128                 t = length / wsize;
 129                 TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);
 130                 t = length & wmask;
 131                 TLOOP(*dst++ = *src++);
 132         } else {
 133                 /*
 134                  * Copy backwards.  Otherwise essentially the same.
 135                  * Alignment works as before, except that it takes
 136                  * (t&wmask) bytes to align, not wsize-(t&wmask).
 137                  */
 138                 src += length;
 139                 dst += length;
 140                 t = (int)src;
 141                 if ((t | (int)dst) & wmask) {
 142                         if ((t ^ (int)dst) & wmask || length <= wsize)
 143                                 t = length;
 144                         else
 145                                 t &= wmask;
 146                         length -= t;
 147                         TLOOP1(*--dst = *--src);
 148                 }
 149                 t = length / wsize;
 150                 TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);
 151                 t = length & wmask;
 152                 TLOOP(*--dst = *--src);
 153         }
 154 done:
 155 #if defined(MEMCOPY) || defined(MEMMOVE)
 156         return (dst0);
 157 #else
 158         return;
 159 #endif
 160 }
 161