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
|
// Copyright 2016 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.
// +build !go1.8
// +build !ppc64,!ppc64le,!arm64,!mips,!mipsle,!mips64,!mips64le
// +build !js,!appengine,!safe
package reflectutil
import (
"reflect"
"unsafe"
)
const ptrSize = 4 << (^uintptr(0) >> 63) // unsafe.Sizeof(uintptr(0)) but an ideal const
// arrayAt returns the i-th element of p, a C-array whose elements are
// eltSize wide (in bytes).
func arrayAt(p unsafe.Pointer, i int, eltSize uintptr) unsafe.Pointer {
return unsafe.Pointer(uintptr(p) + uintptr(i)*eltSize)
}
type sliceHeader struct {
Data unsafe.Pointer
Len int
Cap int
}
func swapper(v reflect.Value) func(i, j int) {
maxLen := uint(v.Len())
s := sliceHeader{unsafe.Pointer(v.Pointer()), int(maxLen), int(maxLen)}
tt := v.Type()
elemt := tt.Elem()
typ := unsafe.Pointer(reflect.ValueOf(elemt).Pointer())
size := elemt.Size()
hasPtr := hasPointers(elemt)
// Some common & small cases, without using memmove:
if hasPtr {
if size == ptrSize {
var ps []unsafe.Pointer
*(*sliceHeader)(unsafe.Pointer(&ps)) = s
return func(i, j int) { ps[i], ps[j] = ps[j], ps[i] }
}
if elemt.Kind() == reflect.String {
var ss []string
*(*sliceHeader)(unsafe.Pointer(&ss)) = s
return func(i, j int) { ss[i], ss[j] = ss[j], ss[i] }
}
} else {
switch size {
case 8:
var is []int64
*(*sliceHeader)(unsafe.Pointer(&is)) = s
return func(i, j int) { is[i], is[j] = is[j], is[i] }
case 4:
var is []int32
*(*sliceHeader)(unsafe.Pointer(&is)) = s
return func(i, j int) { is[i], is[j] = is[j], is[i] }
case 2:
var is []int16
*(*sliceHeader)(unsafe.Pointer(&is)) = s
return func(i, j int) { is[i], is[j] = is[j], is[i] }
case 1:
var is []int8
*(*sliceHeader)(unsafe.Pointer(&is)) = s
return func(i, j int) { is[i], is[j] = is[j], is[i] }
}
}
// Allocate scratch space for swaps:
tmpVal := reflect.New(elemt)
tmp := unsafe.Pointer(tmpVal.Pointer())
// If no pointers (or Go 1.4 or below), we don't require typedmemmove:
if !haveTypedMemmove || !hasPtr {
return func(i, j int) {
if uint(i) >= maxLen || uint(j) >= maxLen {
panic("reflect: slice index out of range")
}
val1 := arrayAt(s.Data, i, size)
val2 := arrayAt(s.Data, j, size)
memmove(tmp, val1, size)
memmove(val1, val2, size)
memmove(val2, tmp, size)
}
}
return func(i, j int) {
if uint(i) >= maxLen || uint(j) >= maxLen {
panic("reflect: slice index out of range")
}
val1 := arrayAt(s.Data, i, size)
val2 := arrayAt(s.Data, j, size)
typedmemmove(typ, tmp, val1)
typedmemmove(typ, val1, val2)
typedmemmove(typ, val2, tmp)
}
}
// memmove copies size bytes from src to dst.
// The memory must not contain any pointers.
//go:noescape
func memmove(dst, src unsafe.Pointer, size uintptr)
|
