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
|
/* go-memmove.c -- memmove
Copyright 2021 The Go Authors. All rights reserved.
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file. */
#include "runtime.h"
void gomemmove(void *, void *, uintptr)
__asm__ (GOSYM_PREFIX "runtime.memmove")
__attribute__ ((no_split_stack));
// This implementation is necessary since
// the __builtin_memmove might use __libc_memmove
// which doesn't require atomicity of 8 byte
// moves.
void
gomemmove (void *dst, void *src, uintptr len)
{
#if !defined(__PPC64__)
__builtin_memmove(dst, src, len);
#else
uint64 offset, tail;
int64 rem;
uint64 dwords;
uint64 i;
char *bdst,*bsrc;
rem = len;
if (len == 0) {
return;
}
// If src and dst don't have the same 8 byte alignment then
// there is no issue with copying pointer atomicity. Use the
// builtin.
if (((uint64)dst % 8) != ((uint64)src % 8) || len < 8) {
__builtin_memmove(dst, src, len);
return;
}
// Length >= 8 && same ptr alignment
offset = (uint64)dst % 8;
// If not 8 byte alignment, move the intial bytes.
if (offset > 0) {
__builtin_memmove(dst, src, 8-offset);
dst += (8-offset);
src += (8-offset);
rem -= (8-offset);
}
// Move the tail bytes to make the backward move
// easier.
tail = rem % 8;
if (tail > 0) {
__builtin_memmove(dst+rem-tail, src+rem-tail, tail);
rem -= tail;
}
if (rem == 0) {
return;
}
// Must now be 8 byte alignment and rem is multiple of 8.
dwords = len>>3;
// Determine if a backwards move is needed
// Forward or backward, move all doublewords
if ((uint64)(dst - src) < (uint64)rem) {
bdst = dst+rem-8;
bsrc = src+rem-8;
for (i = 0; i<dwords; i++) {
*(uint64*)bdst = *(uint64*)bsrc;
bdst -= 8;
bsrc -= 8;
}
} else {
for (i = 0; i<dwords; i++) {
*(uint64*)dst = *(uint64*)src;
dst += 8;
src += 8;
}
}
#endif
}
|
