github.com/mymmsc/gox@v1.3.33/util/reflect2/unsafe_link.go (about)

     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  }