mirror of https://github.com/EasyDarwin/EasyDarwin
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
70 lines
2.7 KiB
70 lines
2.7 KiB
package reflect2 |
|
|
|
import "unsafe" |
|
|
|
//go:linkname unsafe_New reflect.unsafe_New |
|
func unsafe_New(rtype unsafe.Pointer) unsafe.Pointer |
|
|
|
//go:linkname typedmemmove reflect.typedmemmove |
|
func typedmemmove(rtype unsafe.Pointer, dst, src unsafe.Pointer) |
|
|
|
//go:linkname unsafe_NewArray reflect.unsafe_NewArray |
|
func unsafe_NewArray(rtype unsafe.Pointer, length int) unsafe.Pointer |
|
|
|
// typedslicecopy copies a slice of elemType values from src to dst, |
|
// returning the number of elements copied. |
|
//go:linkname typedslicecopy reflect.typedslicecopy |
|
//go:noescape |
|
func typedslicecopy(elemType unsafe.Pointer, dst, src sliceHeader) int |
|
|
|
//go:linkname mapassign reflect.mapassign |
|
//go:noescape |
|
func mapassign(rtype unsafe.Pointer, m unsafe.Pointer, key, val unsafe.Pointer) |
|
|
|
//go:linkname mapaccess reflect.mapaccess |
|
//go:noescape |
|
func mapaccess(rtype unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer) |
|
|
|
// m escapes into the return value, but the caller of mapiterinit |
|
// doesn't let the return value escape. |
|
//go:noescape |
|
//go:linkname mapiterinit reflect.mapiterinit |
|
func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer) *hiter |
|
|
|
//go:noescape |
|
//go:linkname mapiternext reflect.mapiternext |
|
func mapiternext(it *hiter) |
|
|
|
//go:linkname ifaceE2I reflect.ifaceE2I |
|
func ifaceE2I(rtype unsafe.Pointer, src interface{}, dst unsafe.Pointer) |
|
|
|
// A hash iteration structure. |
|
// If you modify hiter, also change cmd/internal/gc/reflect.go to indicate |
|
// the layout of this structure. |
|
type hiter struct { |
|
key unsafe.Pointer // Must be in first position. Write nil to indicate iteration end (see cmd/internal/gc/range.go). |
|
value unsafe.Pointer // Must be in second position (see cmd/internal/gc/range.go). |
|
// rest fields are ignored |
|
} |
|
|
|
// add returns p+x. |
|
// |
|
// The whySafe string is ignored, so that the function still inlines |
|
// as efficiently as p+x, but all call sites should use the string to |
|
// record why the addition is safe, which is to say why the addition |
|
// does not cause x to advance to the very end of p's allocation |
|
// and therefore point incorrectly at the next block in memory. |
|
func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer { |
|
return unsafe.Pointer(uintptr(p) + x) |
|
} |
|
|
|
// arrayAt returns the i-th element of p, |
|
// an array whose elements are eltSize bytes wide. |
|
// The array pointed at by p must have at least i+1 elements: |
|
// it is invalid (but impossible to check here) to pass i >= len, |
|
// because then the result will point outside the array. |
|
// whySafe must explain why i < len. (Passing "i < len" is fine; |
|
// the benefit is to surface this assumption at the call site.) |
|
func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer { |
|
return add(p, uintptr(i)*eltSize, "i < len") |
|
}
|
|
|