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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
#if BIT64
using nuint = System.UInt64;
#else
using nuint = System.UInt32;
#endif
using System.Runtime.CompilerServices;
using System.Runtime;
#if NETCORE
using Internal.Runtime.CompilerServices;
#endif
namespace System
{
partial class Buffer
{
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern unsafe void InternalMemcpy (byte *dest, byte *src, int count);
public static int ByteLength (Array array)
{
// note: the other methods in this class also use ByteLength to test for
// null and non-primitive arguments as a side-effect.
if (array == null)
throw new ArgumentNullException ("array");
int length = _ByteLength (array);
if (length < 0)
throw new ArgumentException ("Object must be an array of primitives.");
return length;
}
public static unsafe byte GetByte (Array array, int index)
{
if (index < 0 || index >= ByteLength (array))
throw new ArgumentOutOfRangeException ("index");
return *(byte*)(Unsafe.AsPointer<byte> (ref Unsafe.Add<byte> (ref array.GetRawSzArrayData (), index)));
}
public static unsafe void SetByte (Array array, int index, byte value)
{
if (index < 0 || index >= ByteLength (array))
throw new ArgumentOutOfRangeException ("index");
*(byte*)(Unsafe.AsPointer<byte> (ref Unsafe.Add<byte> (ref array.GetRawSzArrayData (), index))) = value;
}
public static void BlockCopy (Array src, int srcOffset, Array dst, int dstOffset, int count)
{
if (src == null)
throw new ArgumentNullException ("src");
if (dst == null)
throw new ArgumentNullException ("dst");
if (srcOffset < 0)
throw new ArgumentOutOfRangeException ("srcOffset", "Non-negative number required.");
if (dstOffset < 0)
throw new ArgumentOutOfRangeException ("dstOffset", "Non-negative number required.");
if (count < 0)
throw new ArgumentOutOfRangeException ("count", "Non-negative number required.");
// We do the checks in unmanaged code for performance reasons
bool res = InternalBlockCopy (src, srcOffset, dst, dstOffset, count);
if (!res) {
// watch for integer overflow
if ((srcOffset > ByteLength (src) - count) || (dstOffset > ByteLength (dst) - count))
throw new ArgumentException (
"Offset and length were out of bounds for the array or count is greater than " +
"the number of elements from index to the end of the source collection.");
}
}
[CLSCompliantAttribute (false)]
public static unsafe void MemoryCopy (void* source, void* destination, long destinationSizeInBytes, long sourceBytesToCopy)
{
if (sourceBytesToCopy > destinationSizeInBytes) {
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.sourceBytesToCopy);
}
var src = (byte*)source;
var dst = (byte*)destination;
while (sourceBytesToCopy > int.MaxValue) {
Memcpy (dst, src, int.MaxValue);
sourceBytesToCopy -= int.MaxValue;
src += int.MaxValue;
dst += int.MaxValue;
}
Memcpy (dst, src, (int) sourceBytesToCopy);
}
[CLSCompliantAttribute (false)]
public static unsafe void MemoryCopy (void* source, void* destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy)
{
if (sourceBytesToCopy > destinationSizeInBytes) {
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.sourceBytesToCopy);
}
var src = (byte*)source;
var dst = (byte*)destination;
while (sourceBytesToCopy > int.MaxValue) {
Memcpy (dst, src, int.MaxValue);
sourceBytesToCopy -= int.MaxValue;
src += int.MaxValue;
dst += int.MaxValue;
}
Memcpy (dst, src, (int) sourceBytesToCopy);
}
internal static unsafe void memcpy4 (byte *dest, byte *src, int size) {
/*while (size >= 32) {
// using long is better than int and slower than double
// FIXME: enable this only on correct alignment or on platforms
// that can tolerate unaligned reads/writes of doubles
((double*)dest) [0] = ((double*)src) [0];
((double*)dest) [1] = ((double*)src) [1];
((double*)dest) [2] = ((double*)src) [2];
((double*)dest) [3] = ((double*)src) [3];
dest += 32;
src += 32;
size -= 32;
}*/
while (size >= 16) {
((int*)dest) [0] = ((int*)src) [0];
((int*)dest) [1] = ((int*)src) [1];
((int*)dest) [2] = ((int*)src) [2];
((int*)dest) [3] = ((int*)src) [3];
dest += 16;
src += 16;
size -= 16;
}
while (size >= 4) {
((int*)dest) [0] = ((int*)src) [0];
dest += 4;
src += 4;
size -= 4;
}
while (size > 0) {
((byte*)dest) [0] = ((byte*)src) [0];
dest += 1;
src += 1;
--size;
}
}
internal static unsafe void memcpy2 (byte *dest, byte *src, int size) {
while (size >= 8) {
((short*)dest) [0] = ((short*)src) [0];
((short*)dest) [1] = ((short*)src) [1];
((short*)dest) [2] = ((short*)src) [2];
((short*)dest) [3] = ((short*)src) [3];
dest += 8;
src += 8;
size -= 8;
}
while (size >= 2) {
((short*)dest) [0] = ((short*)src) [0];
dest += 2;
src += 2;
size -= 2;
}
if (size > 0)
((byte*)dest) [0] = ((byte*)src) [0];
}
static unsafe void memcpy1 (byte *dest, byte *src, int size) {
while (size >= 8) {
((byte*)dest) [0] = ((byte*)src) [0];
((byte*)dest) [1] = ((byte*)src) [1];
((byte*)dest) [2] = ((byte*)src) [2];
((byte*)dest) [3] = ((byte*)src) [3];
((byte*)dest) [4] = ((byte*)src) [4];
((byte*)dest) [5] = ((byte*)src) [5];
((byte*)dest) [6] = ((byte*)src) [6];
((byte*)dest) [7] = ((byte*)src) [7];
dest += 8;
src += 8;
size -= 8;
}
while (size >= 2) {
((byte*)dest) [0] = ((byte*)src) [0];
((byte*)dest) [1] = ((byte*)src) [1];
dest += 2;
src += 2;
size -= 2;
}
if (size > 0)
((byte*)dest) [0] = ((byte*)src) [0];
}
internal static unsafe void Memcpy (byte *dest, byte *src, int len) {
// For bigger lengths, we use the heavily optimized native code
if (len > 32) {
InternalMemcpy (dest, src, len);
return;
}
// FIXME: if pointers are not aligned, try to align them
// so a faster routine can be used. Handle the case where
// the pointers can't be reduced to have the same alignment
// (just ignore the issue on x86?)
if ((((int)dest | (int)src) & 3) != 0) {
if (((int)dest & 1) != 0 && ((int)src & 1) != 0 && len >= 1) {
dest [0] = src [0];
++dest;
++src;
--len;
}
if (((int)dest & 2) != 0 && ((int)src & 2) != 0 && len >= 2) {
((short*)dest) [0] = ((short*)src) [0];
dest += 2;
src += 2;
len -= 2;
}
if ((((int)dest | (int)src) & 1) != 0) {
memcpy1 (dest, src, len);
return;
}
if ((((int)dest | (int)src) & 2) != 0) {
memcpy2 (dest, src, len);
return;
}
}
memcpy4 (dest, src, len);
}
internal static unsafe void Memmove (byte *dest, byte *src, uint len)
{
if (((nuint)dest - (nuint)src < len) || ((nuint)src - (nuint)dest < len))
goto PInvoke;
Memcpy (dest, src, (int) len);
return;
PInvoke:
RuntimeImports.Memmove(dest, src, len);
}
internal static void Memmove<T>(ref T destination, ref T source, nuint elementCount)
{
if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>()) {
unsafe {
fixed (byte* pDestination = &Unsafe.As<T, byte>(ref destination), pSource = &Unsafe.As<T, byte>(ref source))
Memmove(pDestination, pSource, (uint)elementCount * (uint)Unsafe.SizeOf<T>());
}
} else {
unsafe {
fixed (byte* pDestination = &Unsafe.As<T, byte>(ref destination), pSource = &Unsafe.As<T, byte>(ref source))
RuntimeImports.Memmove_wbarrier(pDestination, pSource, (uint)elementCount, typeof(T).TypeHandle.Value);
}
}
}
}
}
|
