← Back to branch summary

~linaro-toolchain-dev/cortex-strings/trunk

« back to all changes in this revision

Viewing changes to reference/bionic-c/bcopy.c

  • Committer: Michael Hope
  • Date: 2012-06-12 03:19:14 UTC
  • Revision ID: michael.hope@linaro.org-20120612031914-aymo3gdouh7ueo9c
Added the C only routines from Bionic 4.04r2+20120606~gita985076b

Show diffs side-by-side

added added

removed removed

Lines of Context:
reference/bionic-c/bcopy.c
 
1
/*      $OpenBSD: bcopy.c,v 1.5 2005/08/08 08:05:37 espie Exp $ */
 
2
/*-
 
3
 * Copyright (c) 1990 The Regents of the University of California.
 
4
 * All rights reserved.
 
5
 *
 
6
 * This code is derived from software contributed to Berkeley by
 
7
 * Chris Torek.
 
8
 *
 
9
 * Redistribution and use in source and binary forms, with or without
 
10
 * modification, are permitted provided that the following conditions
 
11
 * are met:
 
12
 * 1. Redistributions of source code must retain the above copyright
 
13
 *    notice, this list of conditions and the following disclaimer.
 
14
 * 2. Redistributions in binary form must reproduce the above copyright
 
15
 *    notice, this list of conditions and the following disclaimer in the
 
16
 *    documentation and/or other materials provided with the distribution.
 
17
 * 3. Neither the name of the University nor the names of its contributors
 
18
 *    may be used to endorse or promote products derived from this software
 
19
 *    without specific prior written permission.
 
20
 *
 
21
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 
22
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
23
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
24
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 
25
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
26
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
27
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
28
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
29
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 
30
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 
31
 * SUCH DAMAGE.
 
32
 */
 
33
 
 
34
#include <string.h>
 
35
 
 
36
/*
 
37
 * sizeof(word) MUST BE A POWER OF TWO
 
38
 * SO THAT wmask BELOW IS ALL ONES
 
39
 */
 
40
typedef long word;              /* "word" used for optimal copy speed */
 
41
 
 
42
#define wsize   sizeof(word)
 
43
#define wmask   (wsize - 1)
 
44
 
 
45
/*
 
46
 * Copy a block of memory, handling overlap.
 
47
 * This is the routine that actually implements
 
48
 * (the portable versions of) bcopy, memcpy, and memmove.
 
49
 */
 
50
#ifdef MEMCOPY
 
51
void *
 
52
memcpy(void *dst0, const void *src0, size_t length)
 
53
#else
 
54
#ifdef MEMMOVE
 
55
void *
 
56
memmove(void *dst0, const void *src0, size_t length)
 
57
#else
 
58
void
 
59
bcopy(const void *src0, void *dst0, size_t length)
 
60
#endif
 
61
#endif
 
62
{
 
63
        char *dst = dst0;
 
64
        const char *src = src0;
 
65
        size_t t;
 
66
 
 
67
        if (length == 0 || dst == src)          /* nothing to do */
 
68
                goto done;
 
69
 
 
70
        /*
 
71
         * Macros: loop-t-times; and loop-t-times, t>0
 
72
         */
 
73
#define TLOOP(s) if (t) TLOOP1(s)
 
74
#define TLOOP1(s) do { s; } while (--t)
 
75
 
 
76
        if ((unsigned long)dst < (unsigned long)src) {
 
77
                /*
 
78
                 * Copy forward.
 
79
                 */
 
80
                t = (long)src;  /* only need low bits */
 
81
                if ((t | (long)dst) & wmask) {
 
82
                        /*
 
83
                         * Try to align operands.  This cannot be done
 
84
                         * unless the low bits match.
 
85
                         */
 
86
                        if ((t ^ (long)dst) & wmask || length < wsize)
 
87
                                t = length;
 
88
                        else
 
89
                                t = wsize - (t & wmask);
 
90
                        length -= t;
 
91
                        TLOOP1(*dst++ = *src++);
 
92
                }
 
93
                /*
 
94
                 * Copy whole words, then mop up any trailing bytes.
 
95
                 */
 
96
                t = length / wsize;
 
97
                TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);
 
98
                t = length & wmask;
 
99
                TLOOP(*dst++ = *src++);
 
100
        } else {
 
101
                /*
 
102
                 * Copy backwards.  Otherwise essentially the same.
 
103
                 * Alignment works as before, except that it takes
 
104
                 * (t&wmask) bytes to align, not wsize-(t&wmask).
 
105
                 */
 
106
                src += length;
 
107
                dst += length;
 
108
                t = (long)src;
 
109
                if ((t | (long)dst) & wmask) {
 
110
                        if ((t ^ (long)dst) & wmask || length <= wsize)
 
111
                                t = length;
 
112
                        else
 
113
                                t &= wmask;
 
114
                        length -= t;
 
115
                        TLOOP1(*--dst = *--src);
 
116
                }
 
117
                t = length / wsize;
 
118
                TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);
 
119
                t = length & wmask;
 
120
                TLOOP(*--dst = *--src);
 
121
        }
 
122
done:
 
123
#if defined(MEMCOPY) || defined(MEMMOVE)
 
124
        return (dst0);
 
125
#else
 
126
        return;
 
127
#endif
 
128
}