diff options
Diffstat (limited to 'vendor/github.com/ugorji/go/codec/helper_unsafe.go')
| -rw-r--r-- | vendor/github.com/ugorji/go/codec/helper_unsafe.go | 1350 |
1 files changed, 0 insertions, 1350 deletions
diff --git a/vendor/github.com/ugorji/go/codec/helper_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_unsafe.go deleted file mode 100644 index 4e29b030b..000000000 --- a/vendor/github.com/ugorji/go/codec/helper_unsafe.go +++ /dev/null @@ -1,1350 +0,0 @@ -// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved. -// Use of this source code is governed by a MIT license found in the LICENSE file. - -//go:build !safe && !codec.safe && !appengine && go1.9 -// +build !safe,!codec.safe,!appengine,go1.9 - -// minimum of go 1.9 is needed, as that is the minimum for all features and linked functions we need -// - typedmemclr was introduced in go 1.8 -// - mapassign_fastXXX was introduced in go 1.9 -// etc - -package codec - -import ( - "reflect" - _ "runtime" // needed for go linkname(s) - "sync/atomic" - "time" - "unsafe" -) - -// This file has unsafe variants of some helper functions. -// MARKER: See helper_unsafe.go for the usage documentation. - -// There are a number of helper_*unsafe*.go files. -// -// - helper_unsafe -// unsafe variants of dependent functions -// - helper_unsafe_compiler_gc (gc) -// unsafe variants of dependent functions which cannot be shared with gollvm or gccgo -// - helper_not_unsafe_not_gc (gccgo/gollvm or safe) -// safe variants of functions in helper_unsafe_compiler_gc -// - helper_not_unsafe (safe) -// safe variants of functions in helper_unsafe -// - helper_unsafe_compiler_not_gc (gccgo, gollvm) -// unsafe variants of functions/variables which non-standard compilers need -// -// This way, we can judiciously use build tags to include the right set of files -// for any compiler, and make it run optimally in unsafe mode. -// -// As of March 2021, we cannot differentiate whether running with gccgo or gollvm -// using a build constraint, as both satisfy 'gccgo' build tag. -// Consequently, we must use the lowest common denominator to support both. - -// For reflect.Value code, we decided to do the following: -// - if we know the kind, we can elide conditional checks for -// - SetXXX (Int, Uint, String, Bool, etc) -// - SetLen -// -// We can also optimize -// - IsNil - -// MARKER: Some functions here will not be hit during code coverage runs due to optimizations, e.g. -// - rvCopySlice: called by decode if rvGrowSlice did not set new slice into pointer to orig slice. -// however, helper_unsafe sets it, so no need to call rvCopySlice later -// - rvSlice: same as above - -const safeMode = false - -// helperUnsafeDirectAssignMapEntry says that we should not copy the pointer in the map -// to another value during mapRange/iteration and mapGet calls, but directly assign it. -// -// The only callers of mapRange/iteration is encode. -// Here, we just walk through the values and encode them -// -// The only caller of mapGet is decode. -// Here, it does a Get if the underlying value is a pointer, and decodes into that. -// -// For both users, we are very careful NOT to modify or keep the pointers around. -// Consequently, it is ok for take advantage of the performance that the map is not modified -// during an iteration and we can just "peek" at the internal value" in the map and use it. -const helperUnsafeDirectAssignMapEntry = true - -// MARKER: keep in sync with GO_ROOT/src/reflect/value.go -const ( - unsafeFlagStickyRO = 1 << 5 - unsafeFlagEmbedRO = 1 << 6 - unsafeFlagIndir = 1 << 7 - unsafeFlagAddr = 1 << 8 - unsafeFlagRO = unsafeFlagStickyRO | unsafeFlagEmbedRO - // unsafeFlagKindMask = (1 << 5) - 1 // 5 bits for 27 kinds (up to 31) - // unsafeTypeKindDirectIface = 1 << 5 -) - -// transientSizeMax below is used in TransientAddr as the backing storage. -// -// Must be >= 16 as the maximum size is a complex128 (or string on 64-bit machines). -const transientSizeMax = 64 - -// should struct/array support internal strings and slices? -const transientValueHasStringSlice = false - -type unsafeString struct { - Data unsafe.Pointer - Len int -} - -type unsafeSlice struct { - Data unsafe.Pointer - Len int - Cap int -} - -type unsafeIntf struct { - typ unsafe.Pointer - ptr unsafe.Pointer -} - -type unsafeReflectValue struct { - unsafeIntf - flag uintptr -} - -// keep in sync with stdlib runtime/type.go -type unsafeRuntimeType struct { - size uintptr - // ... many other fields here -} - -// unsafeZeroAddr and unsafeZeroSlice points to a read-only block of memory -// used for setting a zero value for most types or creating a read-only -// zero value for a given type. -var ( - unsafeZeroAddr = unsafe.Pointer(&unsafeZeroArr[0]) - unsafeZeroSlice = unsafeSlice{unsafeZeroAddr, 0, 0} -) - -// We use a scratch memory and an unsafeSlice for transient values: -// -// unsafeSlice is used for standalone strings and slices (outside an array or struct). -// scratch memory is used for other kinds, based on contract below: -// - numbers, bool are always transient -// - structs and arrays are transient iff they have no pointers i.e. -// no string, slice, chan, func, interface, map, etc only numbers and bools. -// - slices and strings are transient (using the unsafeSlice) - -type unsafePerTypeElem struct { - arr [transientSizeMax]byte // for bool, number, struct, array kinds - slice unsafeSlice // for string and slice kinds -} - -func (x *unsafePerTypeElem) addrFor(k reflect.Kind) unsafe.Pointer { - if k == reflect.String || k == reflect.Slice { - x.slice = unsafeSlice{} // memclr - return unsafe.Pointer(&x.slice) - } - x.arr = [transientSizeMax]byte{} // memclr - return unsafe.Pointer(&x.arr) -} - -type perType struct { - elems [2]unsafePerTypeElem -} - -type decPerType struct { - perType -} - -type encPerType struct{} - -// TransientAddrK is used for getting a *transient* value to be decoded into, -// which will right away be used for something else. -// -// See notes in helper.go about "Transient values during decoding" - -func (x *perType) TransientAddrK(t reflect.Type, k reflect.Kind) reflect.Value { - return rvZeroAddrTransientAnyK(t, k, x.elems[0].addrFor(k)) -} - -func (x *perType) TransientAddr2K(t reflect.Type, k reflect.Kind) reflect.Value { - return rvZeroAddrTransientAnyK(t, k, x.elems[1].addrFor(k)) -} - -func (encPerType) AddressableRO(v reflect.Value) reflect.Value { - return rvAddressableReadonly(v) -} - -// byteAt returns the byte given an index which is guaranteed -// to be within the bounds of the slice i.e. we defensively -// already verified that the index is less than the length of the slice. -func byteAt(b []byte, index uint) byte { - // return b[index] - return *(*byte)(unsafe.Pointer(uintptr((*unsafeSlice)(unsafe.Pointer(&b)).Data) + uintptr(index))) -} - -func byteSliceOf(b []byte, start, end uint) []byte { - s := (*unsafeSlice)(unsafe.Pointer(&b)) - s.Data = unsafe.Pointer(uintptr(s.Data) + uintptr(start)) - s.Len = int(end - start) - s.Cap -= int(start) - return b -} - -// func byteSliceWithLen(b []byte, length uint) []byte { -// (*unsafeSlice)(unsafe.Pointer(&b)).Len = int(length) -// return b -// } - -func setByteAt(b []byte, index uint, val byte) { - // b[index] = val - *(*byte)(unsafe.Pointer(uintptr((*unsafeSlice)(unsafe.Pointer(&b)).Data) + uintptr(index))) = val -} - -// stringView returns a view of the []byte as a string. -// In unsafe mode, it doesn't incur allocation and copying caused by conversion. -// In regular safe mode, it is an allocation and copy. -func stringView(v []byte) string { - return *(*string)(unsafe.Pointer(&v)) -} - -// bytesView returns a view of the string as a []byte. -// In unsafe mode, it doesn't incur allocation and copying caused by conversion. -// In regular safe mode, it is an allocation and copy. -func bytesView(v string) (b []byte) { - sx := (*unsafeString)(unsafe.Pointer(&v)) - bx := (*unsafeSlice)(unsafe.Pointer(&b)) - bx.Data, bx.Len, bx.Cap = sx.Data, sx.Len, sx.Len - return -} - -func byteSliceSameData(v1 []byte, v2 []byte) bool { - return (*unsafeSlice)(unsafe.Pointer(&v1)).Data == (*unsafeSlice)(unsafe.Pointer(&v2)).Data -} - -// MARKER: okBytesN functions will copy N bytes into the top slots of the return array. -// These functions expect that the bound check already occured and are are valid. -// copy(...) does a number of checks which are unnecessary in this situation when in bounds. - -func okBytes2(b []byte) [2]byte { - return *((*[2]byte)(((*unsafeSlice)(unsafe.Pointer(&b))).Data)) -} - -func okBytes3(b []byte) [3]byte { - return *((*[3]byte)(((*unsafeSlice)(unsafe.Pointer(&b))).Data)) -} - -func okBytes4(b []byte) [4]byte { - return *((*[4]byte)(((*unsafeSlice)(unsafe.Pointer(&b))).Data)) -} - -func okBytes8(b []byte) [8]byte { - return *((*[8]byte)(((*unsafeSlice)(unsafe.Pointer(&b))).Data)) -} - -// isNil says whether the value v is nil. -// This applies to references like map/ptr/unsafepointer/chan/func, -// and non-reference values like interface/slice. -func isNil(v interface{}) (rv reflect.Value, isnil bool) { - var ui = (*unsafeIntf)(unsafe.Pointer(&v)) - isnil = ui.ptr == nil - if !isnil { - rv, isnil = unsafeIsNilIntfOrSlice(ui, v) - } - return -} - -func unsafeIsNilIntfOrSlice(ui *unsafeIntf, v interface{}) (rv reflect.Value, isnil bool) { - rv = reflect.ValueOf(v) // reflect.ValueOf is currently not inline'able - so call it directly - tk := rv.Kind() - isnil = (tk == reflect.Interface || tk == reflect.Slice) && *(*unsafe.Pointer)(ui.ptr) == nil - return -} - -// return the pointer for a reference (map/chan/func/pointer/unsafe.Pointer). -// true references (map, func, chan, ptr - NOT slice) may be double-referenced? as flagIndir -// -// Assumes that v is a reference (map/func/chan/ptr/func) -func rvRefPtr(v *unsafeReflectValue) unsafe.Pointer { - if v.flag&unsafeFlagIndir != 0 { - return *(*unsafe.Pointer)(v.ptr) - } - return v.ptr -} - -func eq4i(i0, i1 interface{}) bool { - v0 := (*unsafeIntf)(unsafe.Pointer(&i0)) - v1 := (*unsafeIntf)(unsafe.Pointer(&i1)) - return v0.typ == v1.typ && v0.ptr == v1.ptr -} - -func rv4iptr(i interface{}) (v reflect.Value) { - // Main advantage here is that it is inlined, nothing escapes to heap, i is never nil - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - uv.unsafeIntf = *(*unsafeIntf)(unsafe.Pointer(&i)) - uv.flag = uintptr(rkindPtr) - return -} - -func rv4istr(i interface{}) (v reflect.Value) { - // Main advantage here is that it is inlined, nothing escapes to heap, i is never nil - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - uv.unsafeIntf = *(*unsafeIntf)(unsafe.Pointer(&i)) - uv.flag = uintptr(rkindString) | unsafeFlagIndir - return -} - -func rv2i(rv reflect.Value) (i interface{}) { - // We tap into implememtation details from - // the source go stdlib reflect/value.go, and trims the implementation. - // - // e.g. - // - a map/ptr is a reference, thus flagIndir is not set on it - // - an int/slice is not a reference, thus flagIndir is set on it - - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - if refBitset.isset(byte(rv.Kind())) && urv.flag&unsafeFlagIndir != 0 { - urv.ptr = *(*unsafe.Pointer)(urv.ptr) - } - return *(*interface{})(unsafe.Pointer(&urv.unsafeIntf)) -} - -func rvAddr(rv reflect.Value, ptrType reflect.Type) reflect.Value { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - urv.flag = (urv.flag & unsafeFlagRO) | uintptr(reflect.Ptr) - urv.typ = ((*unsafeIntf)(unsafe.Pointer(&ptrType))).ptr - return rv -} - -func rvIsNil(rv reflect.Value) bool { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - if urv.flag&unsafeFlagIndir != 0 { - return *(*unsafe.Pointer)(urv.ptr) == nil - } - return urv.ptr == nil -} - -func rvSetSliceLen(rv reflect.Value, length int) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - (*unsafeString)(urv.ptr).Len = length -} - -func rvZeroAddrK(t reflect.Type, k reflect.Kind) (rv reflect.Value) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - urv.typ = ((*unsafeIntf)(unsafe.Pointer(&t))).ptr - urv.flag = uintptr(k) | unsafeFlagIndir | unsafeFlagAddr - urv.ptr = unsafeNew(urv.typ) - return -} - -func rvZeroAddrTransientAnyK(t reflect.Type, k reflect.Kind, addr unsafe.Pointer) (rv reflect.Value) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - urv.typ = ((*unsafeIntf)(unsafe.Pointer(&t))).ptr - urv.flag = uintptr(k) | unsafeFlagIndir | unsafeFlagAddr - urv.ptr = addr - return -} - -func rvZeroK(t reflect.Type, k reflect.Kind) (rv reflect.Value) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - urv.typ = ((*unsafeIntf)(unsafe.Pointer(&t))).ptr - if refBitset.isset(byte(k)) { - urv.flag = uintptr(k) - } else if rtsize2(urv.typ) <= uintptr(len(unsafeZeroArr)) { - urv.flag = uintptr(k) | unsafeFlagIndir - urv.ptr = unsafeZeroAddr - } else { // meaning struct or array - urv.flag = uintptr(k) | unsafeFlagIndir | unsafeFlagAddr - urv.ptr = unsafeNew(urv.typ) - } - return -} - -// rvConvert will convert a value to a different type directly, -// ensuring that they still point to the same underlying value. -func rvConvert(v reflect.Value, t reflect.Type) reflect.Value { - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - uv.typ = ((*unsafeIntf)(unsafe.Pointer(&t))).ptr - return v -} - -// rvAddressableReadonly returns an addressable reflect.Value. -// -// Use it within encode calls, when you just want to "read" the underlying ptr -// without modifying the value. -// -// Note that it cannot be used for r/w use, as those non-addressable values -// may have been stored in read-only memory, and trying to write the pointer -// may cause a segfault. -func rvAddressableReadonly(v reflect.Value) reflect.Value { - // hack to make an addressable value out of a non-addressable one. - // Assume folks calling it are passing a value that can be addressable, but isn't. - // This assumes that the flagIndir is already set on it. - // so we just set the flagAddr bit on the flag (and do not set the flagIndir). - - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - uv.flag = uv.flag | unsafeFlagAddr // | unsafeFlagIndir - - return v -} - -func rtsize2(rt unsafe.Pointer) uintptr { - return ((*unsafeRuntimeType)(rt)).size -} - -func rt2id(rt reflect.Type) uintptr { - return uintptr(((*unsafeIntf)(unsafe.Pointer(&rt))).ptr) -} - -func i2rtid(i interface{}) uintptr { - return uintptr(((*unsafeIntf)(unsafe.Pointer(&i))).typ) -} - -// -------------------------- - -func unsafeCmpZero(ptr unsafe.Pointer, size int) bool { - // verified that size is always within right range, so no chance of OOM - var s1 = unsafeString{ptr, size} - var s2 = unsafeString{unsafeZeroAddr, size} - if size > len(unsafeZeroArr) { - arr := make([]byte, size) - s2.Data = unsafe.Pointer(&arr[0]) - } - return *(*string)(unsafe.Pointer(&s1)) == *(*string)(unsafe.Pointer(&s2)) // memcmp -} - -func isEmptyValue(v reflect.Value, tinfos *TypeInfos, recursive bool) bool { - urv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - if urv.flag == 0 { - return true - } - if recursive { - return isEmptyValueFallbackRecur(urv, v, tinfos) - } - return unsafeCmpZero(urv.ptr, int(rtsize2(urv.typ))) -} - -func isEmptyValueFallbackRecur(urv *unsafeReflectValue, v reflect.Value, tinfos *TypeInfos) bool { - const recursive = true - - switch v.Kind() { - case reflect.Invalid: - return true - case reflect.String: - return (*unsafeString)(urv.ptr).Len == 0 - case reflect.Slice: - return (*unsafeSlice)(urv.ptr).Len == 0 - case reflect.Bool: - return !*(*bool)(urv.ptr) - case reflect.Int: - return *(*int)(urv.ptr) == 0 - case reflect.Int8: - return *(*int8)(urv.ptr) == 0 - case reflect.Int16: - return *(*int16)(urv.ptr) == 0 - case reflect.Int32: - return *(*int32)(urv.ptr) == 0 - case reflect.Int64: - return *(*int64)(urv.ptr) == 0 - case reflect.Uint: - return *(*uint)(urv.ptr) == 0 - case reflect.Uint8: - return *(*uint8)(urv.ptr) == 0 - case reflect.Uint16: - return *(*uint16)(urv.ptr) == 0 - case reflect.Uint32: - return *(*uint32)(urv.ptr) == 0 - case reflect.Uint64: - return *(*uint64)(urv.ptr) == 0 - case reflect.Uintptr: - return *(*uintptr)(urv.ptr) == 0 - case reflect.Float32: - return *(*float32)(urv.ptr) == 0 - case reflect.Float64: - return *(*float64)(urv.ptr) == 0 - case reflect.Complex64: - return unsafeCmpZero(urv.ptr, 8) - case reflect.Complex128: - return unsafeCmpZero(urv.ptr, 16) - case reflect.Struct: - // return isEmptyStruct(v, tinfos, recursive) - if tinfos == nil { - tinfos = defTypeInfos - } - ti := tinfos.find(uintptr(urv.typ)) - if ti == nil { - ti = tinfos.load(v.Type()) - } - return unsafeCmpZero(urv.ptr, int(ti.size)) - case reflect.Interface, reflect.Ptr: - // isnil := urv.ptr == nil // (not sufficient, as a pointer value encodes the type) - isnil := urv.ptr == nil || *(*unsafe.Pointer)(urv.ptr) == nil - if recursive && !isnil { - return isEmptyValue(v.Elem(), tinfos, recursive) - } - return isnil - case reflect.UnsafePointer: - return urv.ptr == nil || *(*unsafe.Pointer)(urv.ptr) == nil - case reflect.Chan: - return urv.ptr == nil || len_chan(rvRefPtr(urv)) == 0 - case reflect.Map: - return urv.ptr == nil || len_map(rvRefPtr(urv)) == 0 - case reflect.Array: - return v.Len() == 0 || - urv.ptr == nil || - urv.typ == nil || - rtsize2(urv.typ) == 0 || - unsafeCmpZero(urv.ptr, int(rtsize2(urv.typ))) - } - return false -} - -// -------------------------- - -type structFieldInfos struct { - c unsafe.Pointer // source - s unsafe.Pointer // sorted - length int -} - -func (x *structFieldInfos) load(source, sorted []*structFieldInfo) { - s := (*unsafeSlice)(unsafe.Pointer(&sorted)) - x.s = s.Data - x.length = s.Len - s = (*unsafeSlice)(unsafe.Pointer(&source)) - x.c = s.Data -} - -func (x *structFieldInfos) sorted() (v []*structFieldInfo) { - *(*unsafeSlice)(unsafe.Pointer(&v)) = unsafeSlice{x.s, x.length, x.length} - // s := (*unsafeSlice)(unsafe.Pointer(&v)) - // s.Data = x.sorted0 - // s.Len = x.length - // s.Cap = s.Len - return -} - -func (x *structFieldInfos) source() (v []*structFieldInfo) { - *(*unsafeSlice)(unsafe.Pointer(&v)) = unsafeSlice{x.c, x.length, x.length} - return -} - -// atomicXXX is expected to be 2 words (for symmetry with atomic.Value) -// -// Note that we do not atomically load/store length and data pointer separately, -// as this could lead to some races. Instead, we atomically load/store cappedSlice. -// -// Note: with atomic.(Load|Store)Pointer, we MUST work with an unsafe.Pointer directly. - -// ---------------------- -type atomicTypeInfoSlice struct { - v unsafe.Pointer // *[]rtid2ti -} - -func (x *atomicTypeInfoSlice) load() (s []rtid2ti) { - x2 := atomic.LoadPointer(&x.v) - if x2 != nil { - s = *(*[]rtid2ti)(x2) - } - return -} - -func (x *atomicTypeInfoSlice) store(p []rtid2ti) { - atomic.StorePointer(&x.v, unsafe.Pointer(&p)) -} - -// MARKER: in safe mode, atomicXXX are atomic.Value, which contains an interface{}. -// This is 2 words. -// consider padding atomicXXX here with a uintptr, so they fit into 2 words also. - -// -------------------------- -type atomicRtidFnSlice struct { - v unsafe.Pointer // *[]codecRtidFn -} - -func (x *atomicRtidFnSlice) load() (s []codecRtidFn) { - x2 := atomic.LoadPointer(&x.v) - if x2 != nil { - s = *(*[]codecRtidFn)(x2) - } - return -} - -func (x *atomicRtidFnSlice) store(p []codecRtidFn) { - atomic.StorePointer(&x.v, unsafe.Pointer(&p)) -} - -// -------------------------- -type atomicClsErr struct { - v unsafe.Pointer // *clsErr -} - -func (x *atomicClsErr) load() (e clsErr) { - x2 := (*clsErr)(atomic.LoadPointer(&x.v)) - if x2 != nil { - e = *x2 - } - return -} - -func (x *atomicClsErr) store(p clsErr) { - atomic.StorePointer(&x.v, unsafe.Pointer(&p)) -} - -// -------------------------- - -// to create a reflect.Value for each member field of fauxUnion, -// we first create a global fauxUnion, and create reflect.Value -// for them all. -// This way, we have the flags and type in the reflect.Value. -// Then, when a reflect.Value is called, we just copy it, -// update the ptr to the fauxUnion's, and return it. - -type unsafeDecNakedWrapper struct { - fauxUnion - ru, ri, rf, rl, rs, rb, rt reflect.Value // mapping to the primitives above -} - -func (n *unsafeDecNakedWrapper) init() { - n.ru = rv4iptr(&n.u).Elem() - n.ri = rv4iptr(&n.i).Elem() - n.rf = rv4iptr(&n.f).Elem() - n.rl = rv4iptr(&n.l).Elem() - n.rs = rv4iptr(&n.s).Elem() - n.rt = rv4iptr(&n.t).Elem() - n.rb = rv4iptr(&n.b).Elem() - // n.rr[] = reflect.ValueOf(&n.) -} - -var defUnsafeDecNakedWrapper unsafeDecNakedWrapper - -func init() { - defUnsafeDecNakedWrapper.init() -} - -func (n *fauxUnion) ru() (v reflect.Value) { - v = defUnsafeDecNakedWrapper.ru - ((*unsafeReflectValue)(unsafe.Pointer(&v))).ptr = unsafe.Pointer(&n.u) - return -} -func (n *fauxUnion) ri() (v reflect.Value) { - v = defUnsafeDecNakedWrapper.ri - ((*unsafeReflectValue)(unsafe.Pointer(&v))).ptr = unsafe.Pointer(&n.i) - return -} -func (n *fauxUnion) rf() (v reflect.Value) { - v = defUnsafeDecNakedWrapper.rf - ((*unsafeReflectValue)(unsafe.Pointer(&v))).ptr = unsafe.Pointer(&n.f) - return -} -func (n *fauxUnion) rl() (v reflect.Value) { - v = defUnsafeDecNakedWrapper.rl - ((*unsafeReflectValue)(unsafe.Pointer(&v))).ptr = unsafe.Pointer(&n.l) - return -} -func (n *fauxUnion) rs() (v reflect.Value) { - v = defUnsafeDecNakedWrapper.rs - ((*unsafeReflectValue)(unsafe.Pointer(&v))).ptr = unsafe.Pointer(&n.s) - return -} -func (n *fauxUnion) rt() (v reflect.Value) { - v = defUnsafeDecNakedWrapper.rt - ((*unsafeReflectValue)(unsafe.Pointer(&v))).ptr = unsafe.Pointer(&n.t) - return -} -func (n *fauxUnion) rb() (v reflect.Value) { - v = defUnsafeDecNakedWrapper.rb - ((*unsafeReflectValue)(unsafe.Pointer(&v))).ptr = unsafe.Pointer(&n.b) - return -} - -// -------------------------- -func rvSetBytes(rv reflect.Value, v []byte) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*[]byte)(urv.ptr) = v -} - -func rvSetString(rv reflect.Value, v string) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*string)(urv.ptr) = v -} - -func rvSetBool(rv reflect.Value, v bool) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*bool)(urv.ptr) = v -} - -func rvSetTime(rv reflect.Value, v time.Time) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*time.Time)(urv.ptr) = v -} - -func rvSetFloat32(rv reflect.Value, v float32) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*float32)(urv.ptr) = v -} - -func rvSetFloat64(rv reflect.Value, v float64) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*float64)(urv.ptr) = v -} - -func rvSetComplex64(rv reflect.Value, v complex64) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*complex64)(urv.ptr) = v -} - -func rvSetComplex128(rv reflect.Value, v complex128) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*complex128)(urv.ptr) = v -} - -func rvSetInt(rv reflect.Value, v int) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*int)(urv.ptr) = v -} - -func rvSetInt8(rv reflect.Value, v int8) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*int8)(urv.ptr) = v -} - -func rvSetInt16(rv reflect.Value, v int16) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*int16)(urv.ptr) = v -} - -func rvSetInt32(rv reflect.Value, v int32) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*int32)(urv.ptr) = v -} - -func rvSetInt64(rv reflect.Value, v int64) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*int64)(urv.ptr) = v -} - -func rvSetUint(rv reflect.Value, v uint) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*uint)(urv.ptr) = v -} - -func rvSetUintptr(rv reflect.Value, v uintptr) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*uintptr)(urv.ptr) = v -} - -func rvSetUint8(rv reflect.Value, v uint8) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*uint8)(urv.ptr) = v -} - -func rvSetUint16(rv reflect.Value, v uint16) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*uint16)(urv.ptr) = v -} - -func rvSetUint32(rv reflect.Value, v uint32) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*uint32)(urv.ptr) = v -} - -func rvSetUint64(rv reflect.Value, v uint64) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - *(*uint64)(urv.ptr) = v -} - -// ---------------- - -// rvSetZero is rv.Set(reflect.Zero(rv.Type()) for all kinds (including reflect.Interface). -func rvSetZero(rv reflect.Value) { - rvSetDirectZero(rv) -} - -func rvSetIntf(rv reflect.Value, v reflect.Value) { - rv.Set(v) -} - -// rvSetDirect is rv.Set for all kinds except reflect.Interface. -// -// Callers MUST not pass a value of kind reflect.Interface, as it may cause unexpected segfaults. -func rvSetDirect(rv reflect.Value, v reflect.Value) { - // MARKER: rv.Set for kind reflect.Interface may do a separate allocation if a scalar value. - // The book-keeping is onerous, so we just do the simple ones where a memmove is sufficient. - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - if uv.flag&unsafeFlagIndir == 0 { - *(*unsafe.Pointer)(urv.ptr) = uv.ptr - } else if uv.ptr == unsafeZeroAddr { - if urv.ptr != unsafeZeroAddr { - typedmemclr(urv.typ, urv.ptr) - } - } else { - typedmemmove(urv.typ, urv.ptr, uv.ptr) - } -} - -// rvSetDirectZero is rv.Set(reflect.Zero(rv.Type()) for all kinds except reflect.Interface. -func rvSetDirectZero(rv reflect.Value) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - if urv.ptr != unsafeZeroAddr { - typedmemclr(urv.typ, urv.ptr) - } -} - -// rvMakeSlice updates the slice to point to a new array. -// It copies data from old slice to new slice. -// It returns set=true iff it updates it, else it just returns a new slice pointing to a newly made array. -func rvMakeSlice(rv reflect.Value, ti *typeInfo, xlen, xcap int) (_ reflect.Value, set bool) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - ux := (*unsafeSlice)(urv.ptr) - t := ((*unsafeIntf)(unsafe.Pointer(&ti.elem))).ptr - s := unsafeSlice{newarray(t, xcap), xlen, xcap} - if ux.Len > 0 { - typedslicecopy(t, s, *ux) - } - *ux = s - return rv, true -} - -// rvSlice returns a sub-slice of the slice given new lenth, -// without modifying passed in value. -// It is typically called when we know that SetLen(...) cannot be done. -func rvSlice(rv reflect.Value, length int) reflect.Value { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - var x []struct{} - ux := (*unsafeSlice)(unsafe.Pointer(&x)) - *ux = *(*unsafeSlice)(urv.ptr) - ux.Len = length - urv.ptr = unsafe.Pointer(ux) - return rv -} - -// rcGrowSlice updates the slice to point to a new array with the cap incremented, and len set to the new cap value. -// It copies data from old slice to new slice. -// It returns set=true iff it updates it, else it just returns a new slice pointing to a newly made array. -func rvGrowSlice(rv reflect.Value, ti *typeInfo, cap, incr int) (v reflect.Value, newcap int, set bool) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - ux := (*unsafeSlice)(urv.ptr) - t := ((*unsafeIntf)(unsafe.Pointer(&ti.elem))).ptr - *ux = unsafeGrowslice(t, *ux, cap, incr) - ux.Len = ux.Cap - return rv, ux.Cap, true -} - -// ------------ - -func rvSliceIndex(rv reflect.Value, i int, ti *typeInfo) (v reflect.Value) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - uv.ptr = unsafe.Pointer(uintptr(((*unsafeSlice)(urv.ptr)).Data) + uintptr(int(ti.elemsize)*i)) - uv.typ = ((*unsafeIntf)(unsafe.Pointer(&ti.elem))).ptr - uv.flag = uintptr(ti.elemkind) | unsafeFlagIndir | unsafeFlagAddr - return -} - -func rvSliceZeroCap(t reflect.Type) (v reflect.Value) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - urv.typ = ((*unsafeIntf)(unsafe.Pointer(&t))).ptr - urv.flag = uintptr(reflect.Slice) | unsafeFlagIndir - urv.ptr = unsafe.Pointer(&unsafeZeroSlice) - return -} - -func rvLenSlice(rv reflect.Value) int { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return (*unsafeSlice)(urv.ptr).Len -} - -func rvCapSlice(rv reflect.Value) int { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return (*unsafeSlice)(urv.ptr).Cap -} - -func rvArrayIndex(rv reflect.Value, i int, ti *typeInfo) (v reflect.Value) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - uv.ptr = unsafe.Pointer(uintptr(urv.ptr) + uintptr(int(ti.elemsize)*i)) - uv.typ = ((*unsafeIntf)(unsafe.Pointer(&ti.elem))).ptr - uv.flag = uintptr(ti.elemkind) | unsafeFlagIndir | unsafeFlagAddr - return -} - -// if scratch is nil, then return a writable view (assuming canAddr=true) -func rvGetArrayBytes(rv reflect.Value, scratch []byte) (bs []byte) { - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - bx := (*unsafeSlice)(unsafe.Pointer(&bs)) - bx.Data = urv.ptr - bx.Len = rv.Len() - bx.Cap = bx.Len - return -} - -func rvGetArray4Slice(rv reflect.Value) (v reflect.Value) { - // It is possible that this slice is based off an array with a larger - // len that we want (where array len == slice cap). - // However, it is ok to create an array type that is a subset of the full - // e.g. full slice is based off a *[16]byte, but we can create a *[4]byte - // off of it. That is ok. - // - // Consequently, we use rvLenSlice, not rvCapSlice. - - t := reflectArrayOf(rvLenSlice(rv), rv.Type().Elem()) - // v = rvZeroAddrK(t, reflect.Array) - - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - uv.flag = uintptr(reflect.Array) | unsafeFlagIndir | unsafeFlagAddr - uv.typ = ((*unsafeIntf)(unsafe.Pointer(&t))).ptr - - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - uv.ptr = *(*unsafe.Pointer)(urv.ptr) // slice rv has a ptr to the slice. - - return -} - -func rvGetSlice4Array(rv reflect.Value, v interface{}) { - // v is a pointer to a slice to be populated - uv := (*unsafeIntf)(unsafe.Pointer(&v)) - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - - s := (*unsafeSlice)(uv.ptr) - s.Data = urv.ptr - s.Len = rv.Len() - s.Cap = s.Len -} - -func rvCopySlice(dest, src reflect.Value, elemType reflect.Type) { - typedslicecopy((*unsafeIntf)(unsafe.Pointer(&elemType)).ptr, - *(*unsafeSlice)((*unsafeReflectValue)(unsafe.Pointer(&dest)).ptr), - *(*unsafeSlice)((*unsafeReflectValue)(unsafe.Pointer(&src)).ptr)) -} - -// ------------ - -func rvGetBool(rv reflect.Value) bool { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*bool)(v.ptr) -} - -func rvGetBytes(rv reflect.Value) []byte { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*[]byte)(v.ptr) -} - -func rvGetTime(rv reflect.Value) time.Time { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*time.Time)(v.ptr) -} - -func rvGetString(rv reflect.Value) string { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*string)(v.ptr) -} - -func rvGetFloat64(rv reflect.Value) float64 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*float64)(v.ptr) -} - -func rvGetFloat32(rv reflect.Value) float32 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*float32)(v.ptr) -} - -func rvGetComplex64(rv reflect.Value) complex64 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*complex64)(v.ptr) -} - -func rvGetComplex128(rv reflect.Value) complex128 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*complex128)(v.ptr) -} - -func rvGetInt(rv reflect.Value) int { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*int)(v.ptr) -} - -func rvGetInt8(rv reflect.Value) int8 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*int8)(v.ptr) -} - -func rvGetInt16(rv reflect.Value) int16 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*int16)(v.ptr) -} - -func rvGetInt32(rv reflect.Value) int32 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*int32)(v.ptr) -} - -func rvGetInt64(rv reflect.Value) int64 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*int64)(v.ptr) -} - -func rvGetUint(rv reflect.Value) uint { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*uint)(v.ptr) -} - -func rvGetUint8(rv reflect.Value) uint8 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*uint8)(v.ptr) -} - -func rvGetUint16(rv reflect.Value) uint16 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*uint16)(v.ptr) -} - -func rvGetUint32(rv reflect.Value) uint32 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*uint32)(v.ptr) -} - -func rvGetUint64(rv reflect.Value) uint64 { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*uint64)(v.ptr) -} - -func rvGetUintptr(rv reflect.Value) uintptr { - v := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - return *(*uintptr)(v.ptr) -} - -func rvLenMap(rv reflect.Value) int { - // maplen is not inlined, because as of go1.16beta, go:linkname's are not inlined. - // thus, faster to call rv.Len() directly. - // - // MARKER: review after https://github.com/golang/go/issues/20019 fixed. - - // return rv.Len() - - return len_map(rvRefPtr((*unsafeReflectValue)(unsafe.Pointer(&rv)))) -} - -// copy is an intrinsic, which may use asm if length is small, -// or make a runtime call to runtime.memmove if length is large. -// Performance suffers when you always call runtime.memmove function. -// -// Consequently, there's no value in a copybytes call - just call copy() directly - -// func copybytes(to, from []byte) (n int) { -// n = (*unsafeSlice)(unsafe.Pointer(&from)).Len -// memmove( -// (*unsafeSlice)(unsafe.Pointer(&to)).Data, -// (*unsafeSlice)(unsafe.Pointer(&from)).Data, -// uintptr(n), -// ) -// return -// } - -// func copybytestr(to []byte, from string) (n int) { -// n = (*unsafeSlice)(unsafe.Pointer(&from)).Len -// memmove( -// (*unsafeSlice)(unsafe.Pointer(&to)).Data, -// (*unsafeSlice)(unsafe.Pointer(&from)).Data, -// uintptr(n), -// ) -// return -// } - -// Note: it is hard to find len(...) of an array type, -// as that is a field in the arrayType representing the array, and hard to introspect. -// -// func rvLenArray(rv reflect.Value) int { return rv.Len() } - -// ------------ map range and map indexing ---------- - -// regular calls to map via reflection: MapKeys, MapIndex, MapRange/MapIter etc -// will always allocate for each map key or value. -// -// It is more performant to provide a value that the map entry is set into, -// and that elides the allocation. - -// go 1.4+ has runtime/hashmap.go or runtime/map.go which has a -// hIter struct with the first 2 values being key and value -// of the current iteration. -// -// This *hIter is passed to mapiterinit, mapiternext, mapiterkey, mapiterelem. -// We bypass the reflect wrapper functions and just use the *hIter directly. -// -// Though *hIter has many fields, we only care about the first 2. -// -// We directly embed this in unsafeMapIter below -// -// hiter is typically about 12 words, but we just fill up unsafeMapIter to 32 words, -// so it fills multiple cache lines and can give some extra space to accomodate small growth. - -type unsafeMapIter struct { - mtyp, mptr unsafe.Pointer - k, v reflect.Value - kisref bool - visref bool - mapvalues bool - done bool - started bool - _ [3]byte // padding - it struct { - key unsafe.Pointer - value unsafe.Pointer - _ [20]uintptr // padding for other fields (to make up 32 words for enclosing struct) - } -} - -func (t *unsafeMapIter) Next() (r bool) { - if t == nil || t.done { - return - } - if t.started { - mapiternext((unsafe.Pointer)(&t.it)) - } else { - t.started = true - } - - t.done = t.it.key == nil - if t.done { - return - } - - if helperUnsafeDirectAssignMapEntry || t.kisref { - (*unsafeReflectValue)(unsafe.Pointer(&t.k)).ptr = t.it.key - } else { - k := (*unsafeReflectValue)(unsafe.Pointer(&t.k)) - typedmemmove(k.typ, k.ptr, t.it.key) - } - - if t.mapvalues { - if helperUnsafeDirectAssignMapEntry || t.visref { - (*unsafeReflectValue)(unsafe.Pointer(&t.v)).ptr = t.it.value - } else { - v := (*unsafeReflectValue)(unsafe.Pointer(&t.v)) - typedmemmove(v.typ, v.ptr, t.it.value) - } - } - - return true -} - -func (t *unsafeMapIter) Key() (r reflect.Value) { - return t.k -} - -func (t *unsafeMapIter) Value() (r reflect.Value) { - return t.v -} - -func (t *unsafeMapIter) Done() {} - -type mapIter struct { - unsafeMapIter -} - -func mapRange(t *mapIter, m, k, v reflect.Value, mapvalues bool) { - if rvIsNil(m) { - t.done = true - return - } - t.done = false - t.started = false - t.mapvalues = mapvalues - - // var urv *unsafeReflectValue - - urv := (*unsafeReflectValue)(unsafe.Pointer(&m)) - t.mtyp = urv.typ - t.mptr = rvRefPtr(urv) - - // t.it = (*unsafeMapHashIter)(reflect_mapiterinit(t.mtyp, t.mptr)) - mapiterinit(t.mtyp, t.mptr, unsafe.Pointer(&t.it)) - - t.k = k - t.kisref = refBitset.isset(byte(k.Kind())) - - if mapvalues { - t.v = v - t.visref = refBitset.isset(byte(v.Kind())) - } else { - t.v = reflect.Value{} - } -} - -// unsafeMapKVPtr returns the pointer if flagIndir, else it returns a pointer to the pointer. -// It is needed as maps always keep a reference to the underlying value. -func unsafeMapKVPtr(urv *unsafeReflectValue) unsafe.Pointer { - if urv.flag&unsafeFlagIndir == 0 { - return unsafe.Pointer(&urv.ptr) - } - return urv.ptr -} - -// func mapDelete(m, k reflect.Value) { -// var urv = (*unsafeReflectValue)(unsafe.Pointer(&k)) -// var kptr = unsafeMapKVPtr(urv) -// urv = (*unsafeReflectValue)(unsafe.Pointer(&m)) -// mapdelete(urv.typ, rv2ptr(urv), kptr) -// } - -// return an addressable reflect value that can be used in mapRange and mapGet operations. -// -// all calls to mapGet or mapRange will call here to get an addressable reflect.Value. -func mapAddrLoopvarRV(t reflect.Type, k reflect.Kind) (rv reflect.Value) { - // return rvZeroAddrK(t, k) - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - urv.flag = uintptr(k) | unsafeFlagIndir | unsafeFlagAddr - urv.typ = ((*unsafeIntf)(unsafe.Pointer(&t))).ptr - // since we always set the ptr when helperUnsafeDirectAssignMapEntry=true, - // we should only allocate if it is not true - if !helperUnsafeDirectAssignMapEntry { - urv.ptr = unsafeNew(urv.typ) - } - return -} - -// ---------- ENCODER optimized --------------- - -func (e *Encoder) jsondriver() *jsonEncDriver { - return (*jsonEncDriver)((*unsafeIntf)(unsafe.Pointer(&e.e)).ptr) -} - -func (d *Decoder) zerocopystate() bool { - return d.decByteState == decByteStateZerocopy && d.h.ZeroCopy -} - -func (d *Decoder) stringZC(v []byte) (s string) { - // MARKER: inline zerocopystate directly so genHelper forwarding function fits within inlining cost - - // if d.zerocopystate() { - if d.decByteState == decByteStateZerocopy && d.h.ZeroCopy { - return stringView(v) - } - return d.string(v) -} - -func (d *Decoder) mapKeyString(callFnRvk *bool, kstrbs, kstr2bs *[]byte) string { - if !d.zerocopystate() { - *callFnRvk = true - if d.decByteState == decByteStateReuseBuf { - *kstrbs = append((*kstrbs)[:0], (*kstr2bs)...) - *kstr2bs = *kstrbs - } - } - return stringView(*kstr2bs) -} - -// ---------- DECODER optimized --------------- - -func (d *Decoder) jsondriver() *jsonDecDriver { - return (*jsonDecDriver)((*unsafeIntf)(unsafe.Pointer(&d.d)).ptr) -} - -// ---------- structFieldInfo optimized --------------- - -func (n *structFieldInfoPathNode) rvField(v reflect.Value) (rv reflect.Value) { - // we already know this is exported, and maybe embedded (based on what si says) - uv := (*unsafeReflectValue)(unsafe.Pointer(&v)) - urv := (*unsafeReflectValue)(unsafe.Pointer(&rv)) - // clear flagEmbedRO if necessary, and inherit permission bits from v - urv.flag = uv.flag&(unsafeFlagStickyRO|unsafeFlagIndir|unsafeFlagAddr) | uintptr(n.kind) - urv.typ = ((*unsafeIntf)(unsafe.Pointer(&n.typ))).ptr - urv.ptr = unsafe.Pointer(uintptr(uv.ptr) + uintptr(n.offset)) - return -} - -// runtime chan and map are designed such that the first field is the count. -// len builtin uses this to get the length of a chan/map easily. -// leverage this knowledge, since maplen and chanlen functions from runtime package -// are go:linkname'd here, and thus not inlined as of go1.16beta - -func len_map_chan(m unsafe.Pointer) int { - if m == nil { - return 0 - } - return *((*int)(m)) -} - -func len_map(m unsafe.Pointer) int { - // return maplen(m) - return len_map_chan(m) -} -func len_chan(m unsafe.Pointer) int { - // return chanlen(m) - return len_map_chan(m) -} - -func unsafeNew(typ unsafe.Pointer) unsafe.Pointer { - return mallocgc(rtsize2(typ), typ, true) -} - -// ---------- go linknames (LINKED to runtime/reflect) --------------- - -// MARKER: always check that these linknames match subsequent versions of go -// -// Note that as of Jan 2021 (go 1.16 release), go:linkname(s) are not inlined -// outside of the standard library use (e.g. within sync, reflect, etc). -// If these link'ed functions were normally inlined, calling them here would -// not necessarily give a performance boost, due to function overhead. -// -// However, it seems most of these functions are not inlined anyway, -// as only maplen, chanlen and mapaccess are small enough to get inlined. -// -// We checked this by going into $GOROOT/src/runtime and running: -// $ go build -tags codec.notfastpath -gcflags "-m=2" - -// reflect.{unsafe_New, unsafe_NewArray} are not supported in gollvm, -// failing with "error: undefined reference" error. -// however, runtime.{mallocgc, newarray} are supported, so use that instead. - -//go:linkname memmove runtime.memmove -//go:noescape -func memmove(to, from unsafe.Pointer, n uintptr) - -//go:linkname mallocgc runtime.mallocgc -//go:noescape -func mallocgc(size uintptr, typ unsafe.Pointer, needzero bool) unsafe.Pointer - -//go:linkname newarray runtime.newarray -//go:noescape -func newarray(typ unsafe.Pointer, n int) unsafe.Pointer - -//go:linkname mapiterinit runtime.mapiterinit -//go:noescape -func mapiterinit(typ unsafe.Pointer, m unsafe.Pointer, it unsafe.Pointer) - -//go:linkname mapiternext runtime.mapiternext -//go:noescape -func mapiternext(it unsafe.Pointer) (key unsafe.Pointer) - -//go:linkname mapdelete runtime.mapdelete -//go:noescape -func mapdelete(typ unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) - -//go:linkname mapassign runtime.mapassign -//go:noescape -func mapassign(typ unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer - -//go:linkname mapaccess2 runtime.mapaccess2 -//go:noescape -func mapaccess2(typ unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer, ok bool) - -// reflect.typed{memmove, memclr, slicecopy} will handle checking if the type has pointers or not, -// and if a writeBarrier is needed, before delegating to the right method in the runtime. -// -// This is why we use the functions in reflect, and not the ones in runtime directly. -// Calling runtime.XXX here will lead to memory issues. - -//go:linkname typedslicecopy reflect.typedslicecopy -//go:noescape -func typedslicecopy(elemType unsafe.Pointer, dst, src unsafeSlice) int - -//go:linkname typedmemmove reflect.typedmemmove -//go:noescape -func typedmemmove(typ unsafe.Pointer, dst, src unsafe.Pointer) - -//go:linkname typedmemclr reflect.typedmemclr -//go:noescape -func typedmemclr(typ unsafe.Pointer, dst unsafe.Pointer) |