OpenCores
URL https://opencores.org/ocsvn/amber/amber/trunk

Subversion Repositories amber

[/] [amber/] [trunk/] [sw/] [mini-libc/] [memcpy.c] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 csantifort
/********************************************************************
2
 ** File:     memcpy.c
3
 **
4
 ** Copyright (C) 1999-2010 Daniel Vik
5
 **
6
 ** This software is provided 'as-is', without any express or implied
7
 ** warranty. In no event will the authors be held liable for any
8
 ** damages arising from the use of this software.
9
 ** Permission is granted to anyone to use this software for any
10
 ** purpose, including commercial applications, and to alter it and
11
 ** redistribute it freely, subject to the following restrictions:
12
 **
13
 ** 1. The origin of this software must not be misrepresented; you
14
 **    must not claim that you wrote the original software. If you
15
 **    use this software in a product, an acknowledgment in the
16
 **    use this software in a product, an acknowledgment in the
17
 **    product documentation would be appreciated but is not
18
 **    required.
19
 **
20
 ** 2. Altered source versions must be plainly marked as such, and
21
 **    must not be misrepresented as being the original software.
22
 **
23
 ** 3. This notice may not be removed or altered from any source
24
 **    distribution.
25
 **
26
 **
27
 ** Description: Implementation of the standard library function memcpy.
28
 **             This implementation of memcpy() is ANSI-C89 compatible.
29
 **
30
 **             The following configuration options can be set:
31
 **
32
 **           LITTLE_ENDIAN   - Uses processor with little endian
33
 **                             addressing. Default is big endian.
34
 **
35
 **           PRE_INC_PTRS    - Use pre increment of pointers.
36
 **                             Default is post increment of
37
 **                             pointers.
38
 **
39
 **           INDEXED_COPY    - Copying data using array indexing.
40
 **                             Using this option, disables the
41
 **                             PRE_INC_PTRS option.
42
 **
43
 **           MEMCPY_64BIT    - Compiles memcpy for 64 bit
44
 **                             architectures
45
 **
46
 **
47
 ** Best Settings:
48
 **
49
 ** Intel x86:  LITTLE_ENDIAN and INDEXED_COPY
50
 **
51
 *******************************************************************/
52
 
53
 
54
 
55
/********************************************************************
56
 ** Configuration definitions.
57
 *******************************************************************/
58
 
59
#define LITTLE_ENDIAN
60
#define INDEXED_COPY
61
 
62
 
63
/********************************************************************
64
 ** Includes for size_t definition
65
 *******************************************************************/
66
 
67
#include "stdio.h"
68
 
69
 
70
/********************************************************************
71
 ** Typedefs
72
 *******************************************************************/
73
 
74
typedef unsigned char       UInt8;
75
typedef unsigned short      UInt16;
76
typedef unsigned int        UInt32;
77
#ifdef _WIN32
78
typedef unsigned __int64    UInt64;
79
#else
80
typedef unsigned long long  UInt64;
81
#endif
82
 
83
#ifdef MEMCPY_64BIT
84
typedef UInt64              UIntN;
85
#define TYPE_WIDTH          8
86
#else
87
typedef UInt32              UIntN;
88
#define TYPE_WIDTH          4
89
#endif
90
 
91
 
92
/********************************************************************
93
 ** Remove definitions when INDEXED_COPY is defined.
94
 *******************************************************************/
95
 
96
#if defined (INDEXED_COPY)
97
#if defined (PRE_INC_PTRS)
98
#undef PRE_INC_PTRS
99
#endif /*PRE_INC_PTRS*/
100
#endif /*INDEXED_COPY*/
101
 
102
 
103
 
104
/********************************************************************
105
 ** Definitions for pre and post increment of pointers.
106
 *******************************************************************/
107
 
108
#if defined (PRE_INC_PTRS)
109
 
110
#define START_VAL(x)            (x)--
111
#define INC_VAL(x)              *++(x)
112
#define CAST_TO_U8(p, o)        ((UInt8*)p + o + TYPE_WIDTH)
113
#define WHILE_DEST_BREAK        (TYPE_WIDTH - 1)
114
#define PRE_LOOP_ADJUST         - (TYPE_WIDTH - 1)
115
#define PRE_SWITCH_ADJUST       + 1
116
 
117
#else /*PRE_INC_PTRS*/
118
 
119
#define START_VAL(x)
120
#define INC_VAL(x)              *(x)++
121
#define CAST_TO_U8(p, o)        ((UInt8*)p + o)
122
#define WHILE_DEST_BREAK        0
123
#define PRE_LOOP_ADJUST
124
#define PRE_SWITCH_ADJUST
125
 
126
#endif /*PRE_INC_PTRS*/
127
 
128
 
129
 
130
/********************************************************************
131
 ** Definitions for endians
132
 *******************************************************************/
133
 
134
#if defined (LITTLE_ENDIAN)
135
 
136
#define SHL >>
137
#define SHR <<
138
 
139
#else /* LITTLE_ENDIAN */
140
 
141
#define SHL <<
142
#define SHR >>
143
 
144
#endif /* LITTLE_ENDIAN */
145
 
146
 
147
 
148
/********************************************************************
149
 ** Macros for copying words of  different alignment.
150
 ** Uses incremening pointers.
151
 *******************************************************************/
152
 
153
#define CP_INCR() {                         \
154
    INC_VAL(dstN) = INC_VAL(srcN);          \
155
}
156
 
157
#define CP_INCR_SH(shl, shr) {              \
158
    dstWord   = srcWord SHL shl;            \
159
    srcWord   = INC_VAL(srcN);              \
160
    dstWord  |= srcWord SHR shr;            \
161
    INC_VAL(dstN) = dstWord;                \
162
}
163
 
164
 
165
 
166
/********************************************************************
167
 ** Macros for copying words of  different alignment.
168
 ** Uses array indexes.
169
 *******************************************************************/
170
 
171
#define CP_INDEX(idx) {                     \
172
    dstN[idx] = srcN[idx];                  \
173
}
174
 
175
#define CP_INDEX_SH(x, shl, shr) {          \
176
    dstWord   = srcWord SHL shl;            \
177
    srcWord   = srcN[x];                    \
178
    dstWord  |= srcWord SHR shr;            \
179
    dstN[x]  = dstWord;                     \
180
}
181
 
182
 
183
 
184
/********************************************************************
185
 ** Macros for copying words of different alignment.
186
 ** Uses incremening pointers or array indexes depending on
187
 ** configuration.
188
 *******************************************************************/
189
 
190
#if defined (INDEXED_COPY)
191
 
192
#define CP(idx)               CP_INDEX(idx)
193
#define CP_SH(idx, shl, shr)  CP_INDEX_SH(idx, shl, shr)
194
 
195
#define INC_INDEX(p, o)       ((p) += (o))
196
 
197
#else /* INDEXED_COPY */
198
 
199
#define CP(idx)               CP_INCR()
200
#define CP_SH(idx, shl, shr)  CP_INCR_SH(shl, shr)
201
 
202
#define INC_INDEX(p, o)
203
 
204
#endif /* INDEXED_COPY */
205
 
206
 
207
#define COPY_REMAINING(count) {                                     \
208
    START_VAL(dst8);                                                \
209
    START_VAL(src8);                                                \
210
                                                                    \
211
    switch (count) {                                                \
212
    case 7: INC_VAL(dst8) = INC_VAL(src8);                          \
213
    case 6: INC_VAL(dst8) = INC_VAL(src8);                          \
214
    case 5: INC_VAL(dst8) = INC_VAL(src8);                          \
215
    case 4: INC_VAL(dst8) = INC_VAL(src8);                          \
216
    case 3: INC_VAL(dst8) = INC_VAL(src8);                          \
217
    case 2: INC_VAL(dst8) = INC_VAL(src8);                          \
218
    case 1: INC_VAL(dst8) = INC_VAL(src8);                          \
219
    case 0:                                                         \
220
    default: break;                                                 \
221
    }                                                               \
222
}
223
 
224
#define COPY_NO_SHIFT() {                                           \
225
    UIntN* dstN = (UIntN*)(dst8 PRE_LOOP_ADJUST);                   \
226
    UIntN* srcN = (UIntN*)(src8 PRE_LOOP_ADJUST);                   \
227
    size_t length = count / TYPE_WIDTH;                             \
228
                                                                    \
229
    while (length & 7) {                                            \
230
        CP_INCR();                                                  \
231
        length--;                                                   \
232
    }                                                               \
233
                                                                    \
234
    length /= 8;                                                    \
235
                                                                    \
236
    while (length--) {                                              \
237
        CP(0);                                                      \
238
        CP(1);                                                      \
239
        CP(2);                                                      \
240
        CP(3);                                                      \
241
        CP(4);                                                      \
242
        CP(5);                                                      \
243
        CP(6);                                                      \
244
        CP(7);                                                      \
245
                                                                    \
246
        INC_INDEX(dstN, 8);                                         \
247
        INC_INDEX(srcN, 8);                                         \
248
    }                                                               \
249
                                                                    \
250
    src8 = CAST_TO_U8(srcN, 0);                                     \
251
    dst8 = CAST_TO_U8(dstN, 0);                                     \
252
                                                                    \
253
    COPY_REMAINING(count & (TYPE_WIDTH - 1));                       \
254
                                                                    \
255
    return dest;                                                    \
256
}
257
 
258
 
259
 
260
#define COPY_SHIFT(shift) {                                         \
261
    UIntN* dstN  = (UIntN*)((((UIntN)dst8) PRE_LOOP_ADJUST) &       \
262
                             ~(TYPE_WIDTH - 1));                    \
263
    UIntN* srcN  = (UIntN*)((((UIntN)src8) PRE_LOOP_ADJUST) &       \
264
                             ~(TYPE_WIDTH - 1));                    \
265
    size_t length  = count / TYPE_WIDTH;                            \
266
    UIntN srcWord = INC_VAL(srcN);                                  \
267
    UIntN dstWord;                                                  \
268
                                                                    \
269
    while (length & 7) {                                            \
270
        CP_INCR_SH(8 * shift, 8 * (TYPE_WIDTH - shift));            \
271
        length--;                                                   \
272
    }                                                               \
273
                                                                    \
274
    length /= 8;                                                    \
275
                                                                    \
276
    while (length--) {                                              \
277
        CP_SH(0, 8 * shift, 8 * (TYPE_WIDTH - shift));              \
278
        CP_SH(1, 8 * shift, 8 * (TYPE_WIDTH - shift));              \
279
        CP_SH(2, 8 * shift, 8 * (TYPE_WIDTH - shift));              \
280
        CP_SH(3, 8 * shift, 8 * (TYPE_WIDTH - shift));              \
281
        CP_SH(4, 8 * shift, 8 * (TYPE_WIDTH - shift));              \
282
        CP_SH(5, 8 * shift, 8 * (TYPE_WIDTH - shift));              \
283
        CP_SH(6, 8 * shift, 8 * (TYPE_WIDTH - shift));              \
284
        CP_SH(7, 8 * shift, 8 * (TYPE_WIDTH - shift));              \
285
                                                                    \
286
        INC_INDEX(dstN, 8);                                         \
287
        INC_INDEX(srcN, 8);                                         \
288
    }                                                               \
289
                                                                    \
290
    src8 = CAST_TO_U8(srcN, (shift - TYPE_WIDTH));                  \
291
    dst8 = CAST_TO_U8(dstN, 0);                                     \
292
                                                                    \
293
    COPY_REMAINING(count & (TYPE_WIDTH - 1));                       \
294
                                                                    \
295
    return dest;                                                    \
296
}
297
 
298
 
299
/********************************************************************
300
 **
301
 ** void *memcpy(void *dest, const void *src, size_t count)
302
 **
303
 ** Args:     dest        - pointer to destination buffer
304
 **           src         - pointer to source buffer
305
 **           count       - number of bytes to copy
306
 **
307
 ** Return:   A pointer to destination buffer
308
 **
309
 ** Purpose:  Copies count bytes from src to dest.
310
 **           No overlap check is performed.
311
 **
312
 *******************************************************************/
313
 
314
void *memcpy(void *dest, const void *src, size_t count)
315
{
316
    UInt8* dst8 = (UInt8*)dest;
317
    UInt8* src8 = (UInt8*)src;
318
 
319
    if (count < 8) {
320
        COPY_REMAINING(count);
321
        return dest;
322
    }
323
 
324
    START_VAL(dst8);
325
    START_VAL(src8);
326
 
327
    while (((UIntN)dst8 & (TYPE_WIDTH - 1)) != WHILE_DEST_BREAK) {
328
        INC_VAL(dst8) = INC_VAL(src8);
329
        count--;
330
    }
331
 
332
    switch ((((UIntN)src8) PRE_SWITCH_ADJUST) & (TYPE_WIDTH - 1)) {
333
    case 0: COPY_NO_SHIFT(); break;
334
    case 1: COPY_SHIFT(1);   break;
335
    case 2: COPY_SHIFT(2);   break;
336
    case 3: COPY_SHIFT(3);   break;
337
    }
338
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.