1 package reflect2
2 3 import "unsafe"
4 5 //go:linkname unsafe_New reflect.unsafe_New
6 func unsafe_New(rtype unsafe.Pointer) unsafe.Pointer
7 8 //go:linkname typedmemmove reflect.typedmemmove
9 func typedmemmove(rtype unsafe.Pointer, dst, src unsafe.Pointer)
10 11 //go:linkname unsafe_NewArray reflect.unsafe_NewArray
12 func unsafe_NewArray(rtype unsafe.Pointer, length int) unsafe.Pointer
13 14 // typedslicecopy copies a slice of elemType values from src to dst,
15 // returning the number of elements copied.
16 //go:linkname typedslicecopy reflect.typedslicecopy
17 //go:noescape
18 func typedslicecopy(elemType unsafe.Pointer, dst, src sliceHeader) int
19 20 //go:linkname mapassign reflect.mapassign
21 //go:noescape
22 func mapassign(rtype unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer, val unsafe.Pointer)
23 24 //go:linkname mapaccess reflect.mapaccess
25 //go:noescape
26 func mapaccess(rtype unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
27 28 //go:noescape
29 //go:linkname mapiternext reflect.mapiternext
30 func mapiternext(it *hiter)
31 32 //go:linkname ifaceE2I reflect.ifaceE2I
33 func ifaceE2I(rtype unsafe.Pointer, src interface{}, dst unsafe.Pointer)
34 35 // A hash iteration structure.
36 // If you modify hiter, also change cmd/internal/gc/reflect.go to indicate
37 // the layout of this structure.
38 type hiter struct {
39 key unsafe.Pointer
40 value unsafe.Pointer
41 t unsafe.Pointer
42 h unsafe.Pointer
43 buckets unsafe.Pointer
44 bptr unsafe.Pointer
45 overflow *[]unsafe.Pointer
46 oldoverflow *[]unsafe.Pointer
47 startBucket uintptr
48 offset uint8
49 wrapped bool
50 B uint8
51 i uint8
52 bucket uintptr
53 checkBucket uintptr
54 }
55 56 // add returns p+x.
57 //
58 // The whySafe string is ignored, so that the function still inlines
59 // as efficiently as p+x, but all call sites should use the string to
60 // record why the addition is safe, which is to say why the addition
61 // does not cause x to advance to the very end of p's allocation
62 // and therefore point incorrectly at the next block in memory.
63 func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
64 return unsafe.Pointer(uintptr(p) + x)
65 }
66 67 // arrayAt returns the i-th element of p,
68 // an array whose elements are eltSize bytes wide.
69 // The array pointed at by p must have at least i+1 elements:
70 // it is invalid (but impossible to check here) to pass i >= len,
71 // because then the result will point outside the array.
72 // whySafe must explain why i < len. (Passing "i < len" is fine;
73 // the benefit is to surface this assumption at the call site.)
74 func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
75 return add(p, uintptr(i)*eltSize, "i < len")
76 }
77