1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
/*
FUNCTION
<<memcpy>>---copy memory regions, optimized for the mips processors
ANSI_SYNOPSIS
#include <string.h>
void* memcpy(void *<[out]>, const void *<[in]>, size_t <[n]>);
TRAD_SYNOPSIS
void *memcpy(<[out]>, <[in]>, <[n]>
void *<[out]>;
void *<[in]>;
size_t <[n]>;
DESCRIPTION
This function copies <[n]> bytes from the memory region
pointed to by <[in]> to the memory region pointed to by
<[out]>.
If the regions overlap, the behavior is undefined.
RETURNS
<<memcpy>> returns a pointer to the first byte of the <[out]>
region.
PORTABILITY
<<memcpy>> is ANSI C.
<<memcpy>> requires no supporting OS subroutines.
QUICKREF
memcpy ansi pure
*/
#include <_ansi.h>
#include <stddef.h>
#include <limits.h>
#ifdef __mips64
#define wordtype long long
#else
#define wordtype long
#endif
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (wordtype) - 1)) | ((long)Y & (sizeof (wordtype) - 1)))
/* How many bytes are copied each iteration of the 4X unrolled loop. */
#define BIGBLOCKSIZE (sizeof (wordtype) << 2)
/* How many bytes are copied each iteration of the word copy loop. */
#define LITTLEBLOCKSIZE (sizeof (wordtype))
/* Threshhold for punting to the byte copier. */
#define TOO_SMALL(LEN) ((LEN) < BIGBLOCKSIZE)
_PTR
_DEFUN (memcpy, (dst0, src0, len0),
_PTR dst0 _AND
_CONST _PTR src0 _AND
size_t len0)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) || defined(__mips16)
char *dst = (char *) dst0;
char *src = (char *) src0;
_PTR save = dst0;
while (len0--)
{
*dst++ = *src++;
}
return save;
#else
char *dst = dst0;
_CONST char *src = src0;
wordtype *aligned_dst;
_CONST wordtype *aligned_src;
int len = len0;
size_t iter;
/* Handle aligned moves here. */
if (!UNALIGNED (src, dst))
{
iter = len / BIGBLOCKSIZE;
len = len % BIGBLOCKSIZE;
aligned_dst = (wordtype *)dst;
aligned_src = (wordtype *)src;
/* Copy 4X long or long long words at a time if possible. */
while (iter > 0)
{
wordtype tmp0 = aligned_src[0];
wordtype tmp1 = aligned_src[1];
wordtype tmp2 = aligned_src[2];
wordtype tmp3 = aligned_src[3];
aligned_dst[0] = tmp0;
aligned_dst[1] = tmp1;
aligned_dst[2] = tmp2;
aligned_dst[3] = tmp3;
aligned_src += 4;
aligned_dst += 4;
iter--;
}
/* Copy one long or long long word at a time if possible. */
iter = len / LITTLEBLOCKSIZE;
len = len % LITTLEBLOCKSIZE;
while (iter > 0)
{
*aligned_dst++ = *aligned_src++;
iter--;
}
/* Pick up any residual with a byte copier. */
dst = (char*)aligned_dst;
src = (char*)aligned_src;
while (len > 0)
{
*dst++ = *src++;
len--;
}
return dst0;
}
/* Handle unaligned moves here, using lwr/lwl and swr/swl where possible */
else
{
#ifndef NO_UNALIGNED_LOADSTORE
int tmp;
int *int_src = (int *)src;
int *int_dst = (int *)dst;
iter = len / 4;
len = len % 4;
while (iter > 0)
{
__asm__ ("ulw %0,%1" : "=r" (tmp) : "m" (*int_src));
iter--;
int_src++;
__asm__ ("usw %1,%0" : "=m" (*int_dst) : "r" (tmp));
int_dst++;
}
/* Pick up any residual with a byte copier. */
dst = (char*)int_dst;
src = (char*)int_src;
#endif
while (len > 0)
{
*dst++ = *src++;
len--;
}
return dst0;
}
#endif /* not PREFER_SIZE_OVER_SPEED */
}
|
