cmd/bpa-operator/vendor/github.com/modern-go/reflect2/unsafe_link.go

   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, 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 // m escapes into the return value, but the caller of mapiterinit
  29 // doesn't let the return value escape.
  30 //go:noescape
  31 //go:linkname mapiterinit reflect.mapiterinit
  32 func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer) *hiter
  33
  34 //go:noescape
  35 //go:linkname mapiternext reflect.mapiternext
  36 func mapiternext(it *hiter)
  37
  38 //go:linkname ifaceE2I reflect.ifaceE2I
  39 func ifaceE2I(rtype unsafe.Pointer, src interface{}, dst unsafe.Pointer)
  40
  41 // A hash iteration structure.
  42 // If you modify hiter, also change cmd/internal/gc/reflect.go to indicate
  43 // the layout of this structure.
  44 type hiter struct {
  45         key   unsafe.Pointer // Must be in first position.  Write nil to indicate iteration end (see cmd/internal/gc/range.go).
  46         value unsafe.Pointer // Must be in second position (see cmd/internal/gc/range.go).
  47         // rest fields are ignored
  48 }
  49
  50 // add returns p+x.
  51 //
  52 // The whySafe string is ignored, so that the function still inlines
  53 // as efficiently as p+x, but all call sites should use the string to
  54 // record why the addition is safe, which is to say why the addition
  55 // does not cause x to advance to the very end of p's allocation
  56 // and therefore point incorrectly at the next block in memory.
  57 func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
  58         return unsafe.Pointer(uintptr(p) + x)
  59 }
  60
  61 // arrayAt returns the i-th element of p,
  62 // an array whose elements are eltSize bytes wide.
  63 // The array pointed at by p must have at least i+1 elements:
  64 // it is invalid (but impossible to check here) to pass i >= len,
  65 // because then the result will point outside the array.
  66 // whySafe must explain why i < len. (Passing "i < len" is fine;
  67 // the benefit is to surface this assumption at the call site.)
  68 func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
  69         return add(p, uintptr(i)*eltSize, "i < len")
  70 }