type unsafe.Pointer
3014 uses
unsafe (current package)
unsafe.go#L184: type Pointer *ArbitraryType
crypto/internal/entropy/v1.0.0
entropy.go#L117: u32 := (*uint32)(unsafe.Pointer(&memory[idx]))
crypto/internal/fips140/alias
alias.go#L15: uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
alias.go#L16: uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))
crypto/internal/fips140/check
check.go#L42: Start unsafe.Pointer
check.go#L43: End unsafe.Pointer
crypto/internal/fips140/nistec
p256_asm.go#L332: p256PrecomputedPtr := unsafe.Pointer(&p256PrecomputedEmbed)
p256_asm.go#L338: p256PrecomputedPtr = unsafe.Pointer(&newTable)
crypto/internal/fips140/sha3
keccakf.go#L56: a = (*[25]uint64)(unsafe.Pointer(da))
github.com/cespare/xxhash/v2
xxhash_unsafe.go#L39: b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)}))
xxhash_unsafe.go#L46: d.Write(*(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)})))
github.com/klauspost/compress/internal/le
unsafe_enabled.go#L15: return *(*byte)(unsafe.Add(unsafe.Pointer(unsafe.SliceData(b)), i))
unsafe_enabled.go#L22: return *(*uint16)(unsafe.Add(unsafe.Pointer(unsafe.SliceData(b)), i))
unsafe_enabled.go#L29: return *(*uint32)(unsafe.Add(unsafe.Pointer(unsafe.SliceData(b)), i))
unsafe_enabled.go#L36: return *(*uint64)(unsafe.Add(unsafe.Pointer(unsafe.SliceData(b)), i))
unsafe_enabled.go#L41: *(*uint16)(unsafe.Pointer(unsafe.SliceData(b))) = v
unsafe_enabled.go#L46: *(*uint32)(unsafe.Pointer(unsafe.SliceData(b))) = v
unsafe_enabled.go#L51: *(*uint64)(unsafe.Add(unsafe.Pointer(unsafe.SliceData(b)), i)) = v
github.com/segmentio/asm/internal/unsafebytes
unsafebytes.go#L6: return *(**byte)(unsafe.Pointer(&b))
unsafebytes.go#L10: return *(*string)(unsafe.Pointer(&b))
unsafebytes.go#L14: return *(*[]byte)(unsafe.Pointer(&sliceHeader{str: s, cap: len(s)}))
go.uber.org/atomic
unsafe_pointer.go#L32: v unsafe.Pointer
unsafe_pointer.go#L36: func NewUnsafePointer(val unsafe.Pointer) *UnsafePointer {
unsafe_pointer.go#L41: func (p *UnsafePointer) Load() unsafe.Pointer {
unsafe_pointer.go#L46: func (p *UnsafePointer) Store(val unsafe.Pointer) {
unsafe_pointer.go#L51: func (p *UnsafePointer) Swap(val unsafe.Pointer) (old unsafe.Pointer) {
unsafe_pointer.go#L58: func (p *UnsafePointer) CAS(old, new unsafe.Pointer) (swapped bool) {
unsafe_pointer.go#L63: func (p *UnsafePointer) CompareAndSwap(old, new unsafe.Pointer) (swapped bool) {
golang.org/x/crypto/internal/alias
alias.go#L16: uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
alias.go#L17: uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))
golang.org/x/crypto/sha3
legacy_hash.go#L114: a = (*[25]uint64)(unsafe.Pointer(&d.a))
hash/crc32
crc32_amd64.go#L158: delta := int(uintptr(unsafe.Pointer(&p[0])) & 7)
internal/abi
abi.go#L38: Ptrs [IntArgRegs]unsafe.Pointer
abi.go#L74: func (r *RegArgs) IntRegArgAddr(reg int, argSize uintptr) unsafe.Pointer {
abi.go#L82: return unsafe.Pointer(uintptr(unsafe.Pointer(&r.Ints[reg])) + offset)
abi.go#L102: p := (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(b)) + uintptr(i/8)))
escape.go#L19: func NoEscape(p unsafe.Pointer) unsafe.Pointer {
escape.go#L21: return unsafe.Pointer(x ^ 0)
escape.go#L64: return *(*T)(NoEscape(unsafe.Pointer(&v)))
iface.go#L26: Data unsafe.Pointer
iface.go#L32: Data unsafe.Pointer
iface.go#L38: _ unsafe.Pointer
iface.go#L40: Data unsafe.Pointer
map.go#L38: Hasher func(unsafe.Pointer, uintptr) uintptr
type.go#L30: Equal func(unsafe.Pointer, unsafe.Pointer) bool
type.go#L182: eface := *(*EmptyInterface)(unsafe.Pointer(&a))
type.go#L188: return (*Type)(NoEscape(unsafe.Pointer(eface.Type)))
type.go#L193: return (*PtrType)(unsafe.Pointer(TypeOf((*T)(nil)))).Elem
type.go#L241: return (*[1 << 16]Method)(addChecked(unsafe.Pointer(t), uintptr(t.Moff), "t.mcount > 0"))[:t.Mcount:t.Mcount]
type.go#L248: return (*[1 << 16]Method)(addChecked(unsafe.Pointer(t), uintptr(t.Moff), "t.xcount > 0"))[:t.Xcount:t.Xcount]
type.go#L258: func addChecked(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
type.go#L259: return unsafe.Pointer(uintptr(p) + x)
type.go#L279: return int((*ArrayType)(unsafe.Pointer(t)).Len)
type.go#L312: ch := (*ChanType)(unsafe.Pointer(t))
type.go#L325: return &(*structTypeUncommon)(unsafe.Pointer(t)).u
type.go#L331: return &(*u)(unsafe.Pointer(t)).u
type.go#L337: return &(*u)(unsafe.Pointer(t)).u
type.go#L343: return &(*u)(unsafe.Pointer(t)).u
type.go#L349: return &(*u)(unsafe.Pointer(t)).u
type.go#L355: return &(*u)(unsafe.Pointer(t)).u
type.go#L361: return &(*u)(unsafe.Pointer(t)).u
type.go#L367: return &(*u)(unsafe.Pointer(t)).u
type.go#L373: return &(*u)(unsafe.Pointer(t)).u
type.go#L381: tt := (*ArrayType)(unsafe.Pointer(t))
type.go#L384: tt := (*ChanType)(unsafe.Pointer(t))
type.go#L387: tt := (*MapType)(unsafe.Pointer(t))
type.go#L390: tt := (*PtrType)(unsafe.Pointer(t))
type.go#L393: tt := (*SliceType)(unsafe.Pointer(t))
type.go#L404: return (*StructType)(unsafe.Pointer(t))
type.go#L412: return (*MapType)(unsafe.Pointer(t))
type.go#L420: return (*ArrayType)(unsafe.Pointer(t))
type.go#L428: return (*FuncType)(unsafe.Pointer(t))
type.go#L436: return (*InterfaceType)(unsafe.Pointer(t))
type.go#L463: tt := (*InterfaceType)(unsafe.Pointer(t))
type.go#L474: return (*MapType)(unsafe.Pointer(t)).Key
type.go#L525: return (*[1 << 16]*Type)(addChecked(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.InCount:t.InCount]
type.go#L536: return (*[1 << 17]*Type)(addChecked(unsafe.Pointer(t), uadd, "outCount > 0"))[t.InCount : t.InCount+outCount : t.InCount+outCount]
type.go#L597: return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), whySafe))
type.go#L603: return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), "the runtime doesn't need to give you a reason"))
internal/asan
noasan.go#L15: func Read(addr unsafe.Pointer, len uintptr) {}
noasan.go#L17: func Write(addr unsafe.Pointer, len uintptr) {}
internal/bytealg
equal_native.go#L18: func abigen_runtime_memequal(a, b unsafe.Pointer, size uintptr) bool
equal_native.go#L21: func abigen_runtime_memequal_varlen(a, b unsafe.Pointer) bool
internal/chacha8rand
chacha8_generic.go#L61: b := (*[16][2]uint64)(unsafe.Pointer(b32))
chacha8_generic.go#L151: b := (*[16][4]uint32)(unsafe.Pointer(buf))
internal/coverage/rtcov
rtcov.go#L63: func AddMeta(p unsafe.Pointer, dlen uint32, hash [16]byte, pkgpath string, pkgid int, cmode uint8, cgran uint8) uint32 {
internal/godebug
godebug.go#L307: write(2, unsafe.Pointer(&b[0]), int32(len(b)))
godebug.go#L316: func write(fd uintptr, p unsafe.Pointer, n int32) int32
internal/msan
nomsan.go#L15: func Read(addr unsafe.Pointer, sz uintptr) {
nomsan.go#L18: func Write(addr unsafe.Pointer, sz uintptr) {
nomsan.go#L21: func Malloc(addr unsafe.Pointer, sz uintptr) {
nomsan.go#L24: func Free(addr unsafe.Pointer, sz uintptr) {
nomsan.go#L27: func Move(dst, src unsafe.Pointer, sz uintptr) {
internal/poll
fd_writev_unix.go#L20: r, _, e = syscall.Syscall(syscall.SYS_WRITEV, uintptr(fd), uintptr(unsafe.Pointer(&iovecs[0])), uintptr(len(iovecs)))
internal/race
norace.go#L16: func Acquire(addr unsafe.Pointer) {
norace.go#L19: func Release(addr unsafe.Pointer) {
norace.go#L22: func ReleaseMerge(addr unsafe.Pointer) {
norace.go#L31: func Read(addr unsafe.Pointer) {
norace.go#L34: func ReadPC(addr unsafe.Pointer, callerpc, pc uintptr) {
norace.go#L37: func ReadObjectPC(t *abi.Type, addr unsafe.Pointer, callerpc, pc uintptr) {
norace.go#L40: func Write(addr unsafe.Pointer) {
norace.go#L43: func WritePC(addr unsafe.Pointer, callerpc, pc uintptr) {
norace.go#L46: func WriteObjectPC(t *abi.Type, addr unsafe.Pointer, callerpc, pc uintptr) {
norace.go#L49: func ReadRange(addr unsafe.Pointer, len int) {
norace.go#L52: func WriteRange(addr unsafe.Pointer, len int) {
internal/reflectlite
swapper.go#L41: ps := *(*[]unsafe.Pointer)(v.ptr)
type.go#L151: return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off), whySafe))
type.go#L209: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.DataChecked(off, "name offset field")))[:])
type.go#L210: pkgPathName := name{(*byte)(resolveTypeOff(unsafe.Pointer(n.Bytes), nameOff))}
type.go#L224: func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
type.go#L231: func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L234: return abi.Name{Bytes: (*byte)(resolveNameOff(unsafe.Pointer(t.Type), int32(off)))}
type.go#L238: return (*abi.Type)(resolveTypeOff(unsafe.Pointer(t.Type), int32(off)))
type.go#L380: func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
type.go#L381: return unsafe.Pointer(uintptr(p) + x)
type.go#L438: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L566: t := (*funcType)(unsafe.Pointer(T))
type.go#L567: v := (*funcType)(unsafe.Pointer(V))
type.go#L584: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L585: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L600: t := (*structType)(unsafe.Pointer(T))
type.go#L601: v := (*structType)(unsafe.Pointer(V))
value.go#L43: ptr unsafe.Pointer
value.go#L99: return (*abi.Type)(abi.NoEscape(unsafe.Pointer(v.typ_)))
value.go#L104: func (v Value) pointer() unsafe.Pointer {
value.go#L109: return *(*unsafe.Pointer)(v.ptr)
value.go#L118: e := (*abi.EmptyInterface)(unsafe.Pointer(&i))
value.go#L136: e.Data = *(*unsafe.Pointer)(v.ptr)
value.go#L151: e := (*abi.EmptyInterface)(unsafe.Pointer(&i))
value.go#L250: ptr = *(*unsafe.Pointer)(ptr)
value.go#L256: tt := (*ptrType)(unsafe.Pointer(v.typ()))
value.go#L301: ptr = *(*unsafe.Pointer)(ptr)
value.go#L307: return *(*unsafe.Pointer)(v.ptr) == nil
value.go#L330: func chanlen(unsafe.Pointer) int
value.go#L333: func maplen(unsafe.Pointer) int
value.go#L341: tt := (*arrayType)(unsafe.Pointer(v.typ()))
value.go#L371: var target unsafe.Pointer
value.go#L379: *(*unsafe.Pointer)(v.ptr) = x.ptr
value.go#L400: func unsafe_New(*abi.Type) unsafe.Pointer
value.go#L414: func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
value.go#L457: func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
value.go#L461: func ifaceE2I(t *abi.Type, src any, dst unsafe.Pointer)
value.go#L466: func typedmemmove(t *abi.Type, dst, src unsafe.Pointer)
internal/runtime/atomic
atomic_amd64.go#L23: func Loadp(ptr unsafe.Pointer) unsafe.Pointer {
atomic_amd64.go#L24: return *(*unsafe.Pointer)(ptr)
atomic_amd64.go#L138: func StorepNoWB(ptr unsafe.Pointer, val unsafe.Pointer)
stubs.go#L15: func Casp1(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
types.go#L438: return *(*float64)(unsafe.Pointer(&r))
types.go#L445: f.u.Store(*(*uint64)(unsafe.Pointer(&value)))
types.go#L459: value unsafe.Pointer
types.go#L465: func (u *UnsafePointer) Load() unsafe.Pointer {
types.go#L466: return Loadp(unsafe.Pointer(&u.value))
types.go#L478: func (u *UnsafePointer) StoreNoWB(value unsafe.Pointer) {
types.go#L479: StorepNoWB(unsafe.Pointer(&u.value), value)
types.go#L483: func (u *UnsafePointer) Store(value unsafe.Pointer) {
types.go#L490: func storePointer(ptr *unsafe.Pointer, new unsafe.Pointer)
types.go#L504: func (u *UnsafePointer) CompareAndSwapNoWB(old, new unsafe.Pointer) bool {
types.go#L511: func (u *UnsafePointer) CompareAndSwap(old, new unsafe.Pointer) bool {
types.go#L515: func casPointer(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
types.go#L539: p.u.StoreNoWB(unsafe.Pointer(value))
types.go#L546: p.u.Store(unsafe.Pointer(value))
types.go#L562: return p.u.CompareAndSwapNoWB(unsafe.Pointer(old), unsafe.Pointer(new))
types.go#L570: return p.u.CompareAndSwap(unsafe.Pointer(old), unsafe.Pointer(new))
xchg8.go#L15: addr32 := (*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(addr)) &^ 3))
xchg8.go#L16: shift := (uintptr(unsafe.Pointer(addr)) & 3)
internal/runtime/gc/scan
scan_amd64.go#L13: func ScanSpanPacked(mem unsafe.Pointer, bufp *uintptr, objMarks *gc.ObjMask, sizeClass uintptr, ptrMask *gc.PtrMask) (count int32) {
scan_amd64.go#L30: func ScanSpanPackedAVX512(mem unsafe.Pointer, bufp *uintptr, objMarks *gc.ObjMask, sizeClass uintptr, ptrMask *gc.PtrMask) (count int32) {
scan_amd64.go#L35: func scanSpanPackedAVX512(mem unsafe.Pointer, bufp *uintptr, objMarks *gc.ObjMask, sizeClass uintptr, ptrMask *gc.PtrMask) (count int32)
scan_go.go#L15: func ScanSpanPackedGo(mem unsafe.Pointer, bufp *uintptr, objMarks *gc.ObjMask, sizeClass uintptr, ptrMask *gc.PtrMask) (count int32) {
scan_go.go#L81: *(*T)(unsafe.Add(unsafe.Pointer(b.base), b.n*int(unsafe.Sizeof(val)))) = val
scan_reference.go#L21: func ScanSpanPackedReference(mem unsafe.Pointer, bufp *uintptr, objMarks *gc.ObjMask, sizeClass uintptr, ptrMask *gc.PtrMask) (count int32) {
internal/runtime/maps
group.go#L131: return *(*ctrl)(unsafe.Add(unsafe.Pointer(g), 7-i))
group.go#L133: return *(*ctrl)(unsafe.Add(unsafe.Pointer(g), i))
group.go#L139: *(*ctrl)(unsafe.Add(unsafe.Pointer(g), 7-i)) = c
group.go#L142: *(*ctrl)(unsafe.Add(unsafe.Pointer(g), i)) = c
group.go#L256: data unsafe.Pointer // data *typ.Group
group.go#L289: func (g *groupReference) key(typ *abi.MapType, i uintptr) unsafe.Pointer {
group.go#L292: return unsafe.Pointer(uintptr(g.data) + offset)
group.go#L296: func (g *groupReference) elem(typ *abi.MapType, i uintptr) unsafe.Pointer {
group.go#L299: return unsafe.Pointer(uintptr(g.data) + offset)
group.go#L307: data unsafe.Pointer // data *[length]typ.Group
group.go#L333: data: unsafe.Pointer(uintptr(g.data) + offset),
group.go#L342: oldKey := *(*unsafe.Pointer)(oldGroup.key(typ, i))
group.go#L348: *(*unsafe.Pointer)(newGroup.key(typ, i)) = newKey
group.go#L354: oldElem := *(*unsafe.Pointer)(oldGroup.elem(typ, i))
group.go#L360: *(*unsafe.Pointer)(newGroup.elem(typ, i)) = newElem
map.go#L223: dirPtr unsafe.Pointer
map.go#L325: m.dirPtr = unsafe.Pointer(&directory[0])
map.go#L346: return *(**table)(unsafe.Pointer(uintptr(m.dirPtr) + goarch.PtrSize*i))
map.go#L350: *(**table)(unsafe.Pointer(uintptr(m.dirPtr) + goarch.PtrSize*i)) = nt
map.go#L383: m.dirPtr = unsafe.Pointer(&newDir[0])
map.go#L403: func (m *Map) Get(typ *abi.MapType, key unsafe.Pointer) (unsafe.Pointer, bool) {
map.go#L407: func (m *Map) getWithKey(typ *abi.MapType, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer, bool) {
map.go#L426: func (m *Map) getWithoutKey(typ *abi.MapType, key unsafe.Pointer) (unsafe.Pointer, bool) {
map.go#L446: func (m *Map) getWithKeySmall(typ *abi.MapType, hash uintptr, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer, bool) {
map.go#L458: slotKey = *((*unsafe.Pointer)(slotKey))
map.go#L464: slotElem = *((*unsafe.Pointer)(slotElem))
map.go#L477: func (m *Map) Put(typ *abi.MapType, key, elem unsafe.Pointer) {
map.go#L486: func (m *Map) PutSlot(typ *abi.MapType, key unsafe.Pointer) unsafe.Pointer {
map.go#L536: func (m *Map) putSlotSmall(typ *abi.MapType, hash uintptr, key unsafe.Pointer) unsafe.Pointer {
map.go#L549: slotKey = *((*unsafe.Pointer)(slotKey))
map.go#L558: slotElem = *((*unsafe.Pointer)(slotElem))
map.go#L580: *(*unsafe.Pointer)(slotKey) = kmem
map.go#L588: *(*unsafe.Pointer)(slotElem) = emem
map.go#L623: key = *((*unsafe.Pointer)(key))
map.go#L628: elem = *((*unsafe.Pointer)(elem))
map.go#L640: m.dirPtr = unsafe.Pointer(&directory[0])
map.go#L647: func (m *Map) Delete(typ *abi.MapType, key unsafe.Pointer) {
map.go#L687: func (m *Map) deleteSmall(typ *abi.MapType, hash uintptr, key unsafe.Pointer) {
map.go#L699: slotKey = *((*unsafe.Pointer)(slotKey))
map.go#L706: *(*unsafe.Pointer)(origSlotKey) = nil
map.go#L715: *(*unsafe.Pointer)(slotElem) = nil
map.go#L815: m.dirPtr = unsafe.Pointer(&newDir[0])
map.go#L821: func mapKeyError(t *abi.MapType, p unsafe.Pointer) error {
map.go#L828: func mapKeyError2(t *abi.Type, p unsafe.Pointer) error {
map.go#L836: i := (*abi.InterfaceType)(unsafe.Pointer(t))
map.go#L838: var pdata *unsafe.Pointer
map.go#L860: return mapKeyError2(t, unsafe.Pointer(pdata))
map.go#L865: a := (*abi.ArrayType)(unsafe.Pointer(t))
map.go#L867: if err := mapKeyError2(a.Elem, unsafe.Pointer(uintptr(p)+i*a.Elem.Size_)); err != nil {
map.go#L873: s := (*abi.StructType)(unsafe.Pointer(t))
map.go#L878: if err := mapKeyError2(f.Typ, unsafe.Pointer(uintptr(p)+f.Offset)); err != nil {
runtime.go#L25: func typedmemmove(typ *abi.Type, dst, src unsafe.Pointer)
runtime.go#L28: func typedmemclr(typ *abi.Type, ptr unsafe.Pointer)
runtime.go#L31: func newarray(typ *abi.Type, n int) unsafe.Pointer
runtime.go#L34: func newobject(typ *abi.Type) unsafe.Pointer
runtime.go#L56: func runtime_mapaccess1(typ *abi.MapType, m *Map, key unsafe.Pointer) unsafe.Pointer {
runtime.go#L60: race.ReadPC(unsafe.Pointer(m), callerpc, pc)
runtime.go#L74: return unsafe.Pointer(&zeroVal[0])
runtime.go#L86: return unsafe.Pointer(&zeroVal[0])
runtime.go#L109: slotKey = *((*unsafe.Pointer)(slotKey))
runtime.go#L112: slotElem := unsafe.Pointer(uintptr(slotKeyOrig) + typ.ElemOff)
runtime.go#L114: slotElem = *((*unsafe.Pointer)(slotElem))
runtime.go#L125: return unsafe.Pointer(&zeroVal[0])
runtime.go#L131: func runtime_mapaccess2(typ *abi.MapType, m *Map, key unsafe.Pointer) (unsafe.Pointer, bool) {
runtime.go#L135: race.ReadPC(unsafe.Pointer(m), callerpc, pc)
runtime.go#L149: return unsafe.Pointer(&zeroVal[0]), false
runtime.go#L161: return unsafe.Pointer(&zeroVal[0]), false
runtime.go#L184: slotKey = *((*unsafe.Pointer)(slotKey))
runtime.go#L187: slotElem := unsafe.Pointer(uintptr(slotKeyOrig) + typ.ElemOff)
runtime.go#L189: slotElem = *((*unsafe.Pointer)(slotElem))
runtime.go#L200: return unsafe.Pointer(&zeroVal[0]), false
runtime.go#L206: func runtime_mapassign(typ *abi.MapType, m *Map, key unsafe.Pointer) unsafe.Pointer {
runtime.go#L213: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime.go#L252: var slotElem unsafe.Pointer
runtime.go#L279: slotKey = *((*unsafe.Pointer)(slotKey))
runtime.go#L286: slotElem = unsafe.Pointer(uintptr(slotKeyOrig) + typ.ElemOff)
runtime.go#L288: slotElem = *((*unsafe.Pointer)(slotElem))
runtime.go#L323: *(*unsafe.Pointer)(slotKey) = kmem
runtime.go#L328: slotElem = unsafe.Pointer(uintptr(slotKeyOrig) + typ.ElemOff)
runtime.go#L331: *(*unsafe.Pointer)(slotElem) = emem
runtime_fast32.go#L15: func runtime_mapaccess1_fast32(typ *abi.MapType, m *Map, key uint32) unsafe.Pointer {
runtime_fast32.go#L19: race.ReadPC(unsafe.Pointer(m), callerpc, pc)
runtime_fast32.go#L23: return unsafe.Pointer(&zeroVal[0])
runtime_fast32.go#L40: slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
runtime_fast32.go#L43: slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
runtime_fast32.go#L46: return unsafe.Pointer(&zeroVal[0])
runtime_fast32.go#L50: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_fast32.go#L69: slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
runtime_fast32.go#L79: return unsafe.Pointer(&zeroVal[0])
runtime_fast32.go#L85: func runtime_mapaccess2_fast32(typ *abi.MapType, m *Map, key uint32) (unsafe.Pointer, bool) {
runtime_fast32.go#L89: race.ReadPC(unsafe.Pointer(m), callerpc, pc)
runtime_fast32.go#L93: return unsafe.Pointer(&zeroVal[0]), false
runtime_fast32.go#L110: slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
runtime_fast32.go#L113: slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
runtime_fast32.go#L116: return unsafe.Pointer(&zeroVal[0]), false
runtime_fast32.go#L120: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_fast32.go#L139: slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
runtime_fast32.go#L149: return unsafe.Pointer(&zeroVal[0]), false
runtime_fast32.go#L154: func (m *Map) putSlotSmallFast32(typ *abi.MapType, hash uintptr, key uint32) unsafe.Pointer {
runtime_fast32.go#L195: func runtime_mapassign_fast32(typ *abi.MapType, m *Map, key uint32) unsafe.Pointer {
runtime_fast32.go#L202: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime_fast32.go#L209: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_fast32.go#L235: var slotElem unsafe.Pointer
runtime_fast32.go#L335: func runtime_mapassign_fast32ptr(typ *abi.MapType, m *Map, key unsafe.Pointer) unsafe.Pointer {
runtime_fast32.go#L342: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime_fast32.go#L349: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_fast32.go#L375: var slotElem unsafe.Pointer
runtime_fast32.go#L399: if key == *(*unsafe.Pointer)(slotKey) {
runtime_fast32.go#L438: *(*unsafe.Pointer)(slotKey) = key
runtime_fast32.go#L469: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime_fast32.go#L476: m.Delete(typ, abi.NoEscape(unsafe.Pointer(&key)))
runtime_fast64.go#L15: func runtime_mapaccess1_fast64(typ *abi.MapType, m *Map, key uint64) unsafe.Pointer {
runtime_fast64.go#L19: race.ReadPC(unsafe.Pointer(m), callerpc, pc)
runtime_fast64.go#L23: return unsafe.Pointer(&zeroVal[0])
runtime_fast64.go#L40: slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
runtime_fast64.go#L43: slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
runtime_fast64.go#L46: return unsafe.Pointer(&zeroVal[0])
runtime_fast64.go#L50: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_fast64.go#L69: slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
runtime_fast64.go#L79: return unsafe.Pointer(&zeroVal[0])
runtime_fast64.go#L85: func runtime_mapaccess2_fast64(typ *abi.MapType, m *Map, key uint64) (unsafe.Pointer, bool) {
runtime_fast64.go#L89: race.ReadPC(unsafe.Pointer(m), callerpc, pc)
runtime_fast64.go#L93: return unsafe.Pointer(&zeroVal[0]), false
runtime_fast64.go#L110: slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
runtime_fast64.go#L113: slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
runtime_fast64.go#L116: return unsafe.Pointer(&zeroVal[0]), false
runtime_fast64.go#L120: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_fast64.go#L140: slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
runtime_fast64.go#L150: return unsafe.Pointer(&zeroVal[0]), false
runtime_fast64.go#L155: func (m *Map) putSlotSmallFast64(typ *abi.MapType, hash uintptr, key uint64) unsafe.Pointer {
runtime_fast64.go#L196: func runtime_mapassign_fast64(typ *abi.MapType, m *Map, key uint64) unsafe.Pointer {
runtime_fast64.go#L203: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime_fast64.go#L210: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_fast64.go#L236: var slotElem unsafe.Pointer
runtime_fast64.go#L331: func (m *Map) putSlotSmallFastPtr(typ *abi.MapType, hash uintptr, key unsafe.Pointer) unsafe.Pointer {
runtime_fast64.go#L343: if key == *(*unsafe.Pointer)(slotKey) {
runtime_fast64.go#L361: *(*unsafe.Pointer)(slotKey) = key
runtime_fast64.go#L374: func runtime_mapassign_fast64ptr(typ *abi.MapType, m *Map, key unsafe.Pointer) unsafe.Pointer {
runtime_fast64.go#L381: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime_fast64.go#L388: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_fast64.go#L414: var slotElem unsafe.Pointer
runtime_fast64.go#L439: if key == *(*unsafe.Pointer)(slotKey) {
runtime_fast64.go#L478: *(*unsafe.Pointer)(slotKey) = key
runtime_fast64.go#L509: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime_fast64.go#L516: m.Delete(typ, abi.NoEscape(unsafe.Pointer(&key)))
runtime_faststr.go#L15: func (m *Map) getWithoutKeySmallFastStr(typ *abi.MapType, key string) unsafe.Pointer {
runtime_faststr.go#L40: slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
runtime_faststr.go#L50: return unsafe.Pointer(uintptr(slotKey) + 2*goarch.PtrSize)
runtime_faststr.go#L57: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&key)), m.seed)
runtime_faststr.go#L64: return unsafe.Pointer(uintptr(slotKey) + 2*goarch.PtrSize)
runtime_faststr.go#L66: slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
runtime_faststr.go#L85: x = unsafe.Pointer(uintptr(x) + uintptr(len(a)) - 8)
runtime_faststr.go#L86: y = unsafe.Pointer(uintptr(y) + uintptr(len(a)) - 8)
runtime_faststr.go#L92: func stringPtr(s string) unsafe.Pointer {
runtime_faststr.go#L94: ptr unsafe.Pointer
runtime_faststr.go#L97: return (*stringStruct)(unsafe.Pointer(&s)).ptr
runtime_faststr.go#L101: func runtime_mapaccess1_faststr(typ *abi.MapType, m *Map, key string) unsafe.Pointer {
runtime_faststr.go#L105: race.ReadPC(unsafe.Pointer(m), callerpc, pc)
runtime_faststr.go#L109: return unsafe.Pointer(&zeroVal[0])
runtime_faststr.go#L120: return unsafe.Pointer(&zeroVal[0])
runtime_faststr.go#L126: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_faststr.go#L145: slotElem := unsafe.Pointer(uintptr(slotKey) + 2*goarch.PtrSize)
runtime_faststr.go#L155: return unsafe.Pointer(&zeroVal[0])
runtime_faststr.go#L161: func runtime_mapaccess2_faststr(typ *abi.MapType, m *Map, key string) (unsafe.Pointer, bool) {
runtime_faststr.go#L165: race.ReadPC(unsafe.Pointer(m), callerpc, pc)
runtime_faststr.go#L169: return unsafe.Pointer(&zeroVal[0]), false
runtime_faststr.go#L180: return unsafe.Pointer(&zeroVal[0]), false
runtime_faststr.go#L186: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_faststr.go#L205: slotElem := unsafe.Pointer(uintptr(slotKey) + 2*goarch.PtrSize)
runtime_faststr.go#L215: return unsafe.Pointer(&zeroVal[0]), false
runtime_faststr.go#L220: func (m *Map) putSlotSmallFastStr(typ *abi.MapType, hash uintptr, key string) unsafe.Pointer {
runtime_faststr.go#L263: func runtime_mapassign_faststr(typ *abi.MapType, m *Map, key string) unsafe.Pointer {
runtime_faststr.go#L270: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime_faststr.go#L277: hash := typ.Hasher(abi.NoEscape(unsafe.Pointer(&k)), m.seed)
runtime_faststr.go#L303: var slotElem unsafe.Pointer
runtime_faststr.go#L406: race.WritePC(unsafe.Pointer(m), callerpc, pc)
runtime_faststr.go#L413: m.Delete(typ, abi.NoEscape(unsafe.Pointer(&key)))
table.go#L143: func (t *table) Get(typ *abi.MapType, m *Map, key unsafe.Pointer) (unsafe.Pointer, bool) {
table.go#L164: func (t *table) getWithKey(typ *abi.MapType, hash uintptr, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer, bool) {
table.go#L204: slotKey = *((*unsafe.Pointer)(slotKey))
table.go#L209: slotElem = *((*unsafe.Pointer)(slotElem))
table.go#L225: func (t *table) getWithoutKey(typ *abi.MapType, hash uintptr, key unsafe.Pointer) (unsafe.Pointer, bool) {
table.go#L238: slotKey = *((*unsafe.Pointer)(slotKey))
table.go#L243: slotElem = *((*unsafe.Pointer)(slotElem))
table.go#L266: func (t *table) PutSlot(typ *abi.MapType, m *Map, hash uintptr, key unsafe.Pointer) (unsafe.Pointer, bool) {
table.go#L285: slotKey = *((*unsafe.Pointer)(slotKey))
table.go#L294: slotElem = *((*unsafe.Pointer)(slotElem))
table.go#L340: *(*unsafe.Pointer)(slotKey) = kmem
table.go#L348: *(*unsafe.Pointer)(slotElem) = emem
table.go#L382: func (t *table) uncheckedPutSlot(typ *abi.MapType, hash uintptr, key, elem unsafe.Pointer) {
table.go#L401: *(*unsafe.Pointer)(slotKey) = key
table.go#L408: *(*unsafe.Pointer)(slotElem) = elem
table.go#L422: func (t *table) Delete(typ *abi.MapType, m *Map, hash uintptr, key unsafe.Pointer) bool {
table.go#L435: slotKey = *((*unsafe.Pointer)(slotKey))
table.go#L444: *(*unsafe.Pointer)(origSlotKey) = nil
table.go#L454: *(*unsafe.Pointer)(slotElem) = nil
table.go#L528: key = *((*unsafe.Pointer)(key))
table.go#L642: key unsafe.Pointer // Must be in first position. Write nil to indicate iteration end (see cmd/compile/internal/walk/range.go).
table.go#L643: elem unsafe.Pointer // Must be in second position (see cmd/compile/internal/walk/range.go).
table.go#L714: func (it *Iter) Key() unsafe.Pointer {
table.go#L722: func (it *Iter) Elem() unsafe.Pointer {
table.go#L762: func (it *Iter) grownKeyElem(key unsafe.Pointer, slotIdx uintptr) (unsafe.Pointer, unsafe.Pointer, bool) {
table.go#L791: elem = *((*unsafe.Pointer)(elem))
table.go#L835: key = *((*unsafe.Pointer)(key))
table.go#L843: var elem unsafe.Pointer
table.go#L852: elem = *((*unsafe.Pointer)(elem))
table.go#L864: elem = *((*unsafe.Pointer)(elem))
table.go#L978: key = *((*unsafe.Pointer)(key))
table.go#L982: var elem unsafe.Pointer
table.go#L997: elem = *((*unsafe.Pointer)(elem))
table.go#L1071: key = *((*unsafe.Pointer)(key))
table.go#L1086: var elem unsafe.Pointer
table.go#L1112: elem = *((*unsafe.Pointer)(elem))
table.go#L1200: key = *((*unsafe.Pointer)(key))
table.go#L1205: elem = *((*unsafe.Pointer)(elem))
table.go#L1241: key = *((*unsafe.Pointer)(key))
table.go#L1246: elem = *((*unsafe.Pointer)(elem))
table_debug.go#L38: key = *((*unsafe.Pointer)(key))
table_debug.go#L124: func dump(ptr unsafe.Pointer, size uintptr) {
table_debug.go#L127: ptr = unsafe.Pointer(uintptr(ptr) + 1)
internal/runtime/syscall/linux
syscall_linux.go#L26: var ev unsafe.Pointer
syscall_linux.go#L28: ev = unsafe.Pointer(&events[0])
syscall_linux.go#L30: ev = unsafe.Pointer(&_zero)
syscall_linux.go#L37: _, _, e := Syscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
syscall_linux.go#L49: r1, _, e := Syscall6(SYS_OPENAT, uintptr(dfd), uintptr(unsafe.Pointer(path)), uintptr(mode|O_LARGEFILE), uintptr(perm), 0, 0)
syscall_linux.go#L59: var p0 unsafe.Pointer
syscall_linux.go#L61: p0 = unsafe.Pointer(&p[0])
syscall_linux.go#L63: p0 = unsafe.Pointer(&_zero)
syscall_linux.go#L70: var p0 unsafe.Pointer
syscall_linux.go#L72: p0 = unsafe.Pointer(&p[0])
syscall_linux.go#L74: p0 = unsafe.Pointer(&_zero)
syscall_linux.go#L100: _, _, e := Syscall6(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0, 0, 0, 0)
internal/strconv
deps.go#L13: func float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
deps.go#L14: func float32frombits(b uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
deps.go#L15: func float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
deps.go#L16: func float32bits(f float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
internal/sync
hashtriemap.go#L58: type hashFunc func(unsafe.Pointer, uintptr) uintptr
hashtriemap.go#L59: type equalFunc func(unsafe.Pointer, unsafe.Pointer) bool
hashtriemap.go#L66: hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
hashtriemap.go#L90: hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
hashtriemap.go#L169: oldHash := ht.keyHash(unsafe.Pointer(&oldEntry.key), ht.seed)
hashtriemap.go#L207: hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
hashtriemap.go#L285: hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
hashtriemap.go#L311: hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
hashtriemap.go#L373: hash := ht.keyHash(abi.NoEscape(unsafe.Pointer(&key)), ht.seed)
hashtriemap.go#L591: if e.key == key && (valEqual == nil || valEqual(unsafe.Pointer(&e.value), abi.NoEscape(unsafe.Pointer(&value)))) {
hashtriemap.go#L633: if head.key == key && valEqual(unsafe.Pointer(&head.value), abi.NoEscape(unsafe.Pointer(&old))) {
hashtriemap.go#L644: if e.key == key && valEqual(unsafe.Pointer(&e.value), abi.NoEscape(unsafe.Pointer(&old))) {
hashtriemap.go#L683: if head.key == key && valEqual(unsafe.Pointer(&head.value), abi.NoEscape(unsafe.Pointer(&value))) {
hashtriemap.go#L690: if e.key == key && valEqual(unsafe.Pointer(&e.value), abi.NoEscape(unsafe.Pointer(&value))) {
hashtriemap.go#L710: return (*entry[K, V])(unsafe.Pointer(n))
hashtriemap.go#L717: return (*indirect[K, V])(unsafe.Pointer(n))
mutex.go#L65: race.Acquire(unsafe.Pointer(m))
mutex.go#L90: race.Acquire(unsafe.Pointer(m))
mutex.go#L180: race.Acquire(unsafe.Pointer(m))
mutex.go#L190: race.Release(unsafe.Pointer(m))
internal/synctest
synctest.go#L40: return Association(associate(unsafe.Pointer(escapedP)))
synctest.go#L44: func associate(p unsafe.Pointer) int
synctest.go#L48: disassociate(unsafe.Pointer(p))
synctest.go#L52: func disassociate(b unsafe.Pointer)
synctest.go#L56: return isAssociated(unsafe.Pointer(p))
synctest.go#L60: func isAssociated(p unsafe.Pointer) bool
internal/syscall/unix
at.go#L20: _, _, errno := syscall.Syscall(unlinkatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags))
at.go#L34: fd, _, errno := syscall.Syscall6(openatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags), uintptr(perm), 0, 0)
at.go#L47: var p1 unsafe.Pointer
at.go#L49: p1 = unsafe.Pointer(&buf[0])
at.go#L51: p1 = unsafe.Pointer(&_zero)
at.go#L55: uintptr(unsafe.Pointer(p0)),
at.go#L74: uintptr(unsafe.Pointer(p)),
at.go#L90: uintptr(unsafe.Pointer(p)),
at.go#L112: uintptr(unsafe.Pointer(oldp)),
at.go#L114: uintptr(unsafe.Pointer(newp)),
at.go#L134: uintptr(unsafe.Pointer(oldp)),
at.go#L136: uintptr(unsafe.Pointer(newp)),
at.go#L155: uintptr(unsafe.Pointer(oldp)),
at.go#L157: uintptr(unsafe.Pointer(newp)))
at_fstatat.go#L21: _, _, errno := syscall.Syscall6(fstatatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
copy_file_range_unix.go#L17: uintptr(unsafe.Pointer(roff)),
copy_file_range_unix.go#L19: uintptr(unsafe.Pointer(woff)),
getrandom.go#L37: uintptr(unsafe.Pointer(unsafe.SliceData(p))),
tcsetpgrp_linux.go#L16: _, _, errno := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(syscall.TIOCSPGRP), uintptr(unsafe.Pointer(&pgid)), 0, 0, 0)
waitid_linux.go#L18: _, _, errno := syscall.Syscall6(syscall.SYS_WAITID, uintptr(idType), uintptr(id), uintptr(unsafe.Pointer(info)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0)
internal/unsafeheader
unsafeheader.go#L23: Data unsafe.Pointer
unsafeheader.go#L35: Data unsafe.Pointer
iter
iter.go#L272: race.Acquire(unsafe.Pointer(&pull.racer))
iter.go#L274: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L286: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L288: race.Acquire(unsafe.Pointer(&pull.racer))
iter.go#L299: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L307: race.Write(unsafe.Pointer(&pull.racer)) // detect races
iter.go#L316: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L318: race.Acquire(unsafe.Pointer(&pull.racer))
iter.go#L332: race.Write(unsafe.Pointer(&pull.racer)) // detect races
iter.go#L336: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L338: race.Acquire(unsafe.Pointer(&pull.racer))
iter.go#L388: race.Acquire(unsafe.Pointer(&pull.racer))
iter.go#L390: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L402: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L404: race.Acquire(unsafe.Pointer(&pull.racer))
iter.go#L415: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L424: race.Write(unsafe.Pointer(&pull.racer)) // detect races
iter.go#L433: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L435: race.Acquire(unsafe.Pointer(&pull.racer))
iter.go#L449: race.Write(unsafe.Pointer(&pull.racer)) // detect races
iter.go#L453: race.Release(unsafe.Pointer(&pull.racer))
iter.go#L455: race.Acquire(unsafe.Pointer(&pull.racer))
math
unsafe.go#L24: func Float32bits(f float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
unsafe.go#L30: func Float32frombits(b uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
unsafe.go#L35: func Float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
unsafe.go#L41: func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
net
cgo_unix.go#L126: gerrno, err := _C_getaddrinfo(nil, (*_C_char)(unsafe.Pointer(&cservice[0])), hints, &res)
cgo_unix.go#L145: sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(*_C_ai_addr(r)))
cgo_unix.go#L146: p := (*[2]byte)(unsafe.Pointer(&sa.Port))
cgo_unix.go#L149: sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(*_C_ai_addr(r)))
cgo_unix.go#L150: p := (*[2]byte)(unsafe.Pointer(&sa.Port))
cgo_unix.go#L174: gerrno, err := _C_getaddrinfo((*_C_char)(unsafe.Pointer(h)), nil, &hints, &res)
cgo_unix.go#L215: sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(*_C_ai_addr(r)))
cgo_unix.go#L219: sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(*_C_ai_addr(r)))
cgo_unix.go#L328: state = (*_C_struct___res_state)(unsafe.Pointer(&memSlice[0]))
cgo_unix.go#L347: _C_free(unsafe.Pointer(buf))
cgo_unix.go#L357: size = _C_res_nsearch(state, (*_C_char)(unsafe.Pointer(s)), class, rtype, buf, bufSize)
cgo_unix.go#L366: _C_free(unsafe.Pointer(buf))
cgo_unix.go#L372: if _, err := p.Start(unsafe.Slice((*byte)(unsafe.Pointer(buf)), size)); err != nil {
interface_linux.go#L32: ifim := (*syscall.IfInfomsg)(unsafe.Pointer(&m.Data[0]))
interface_linux.go#L91: ifi.MTU = int(*(*uint32)(unsafe.Pointer(&a.Value[:4][0])))
interface_linux.go#L147: ifam := (*syscall.IfAddrmsg)(unsafe.Pointer(&m.Data[0]))
interface_linux.go#L226: i := *(*uint32)(unsafe.Pointer(&b[:4][0]))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L16: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L74: func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L105: var _cgo_77133bf98b3a_C2func_getaddrinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_C2func_getaddrinfo)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L109: errno := _cgo_runtime_cgocall(_cgo_77133bf98b3a_C2func_getaddrinfo, uintptr(unsafe.Pointer(&p0)))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L122: var _cgo_77133bf98b3a_C2func_getnameinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_C2func_getnameinfo)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L126: errno := _cgo_runtime_cgocall(_cgo_77133bf98b3a_C2func_getnameinfo, uintptr(unsafe.Pointer(&p0)))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L148: func _Cfunc__CMalloc(n _Ctype_size_t) unsafe.Pointer {
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L154: var _cgo_77133bf98b3a_Cfunc_free = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_free)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L157: func _Cfunc_free(p0 unsafe.Pointer) (r1 _Ctype_void) {
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L158: _cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_free, uintptr(unsafe.Pointer(&p0)))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L167: var _cgo_77133bf98b3a_Cfunc_freeaddrinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_freeaddrinfo)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L171: _cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_freeaddrinfo, uintptr(unsafe.Pointer(&p0)))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L180: var _cgo_77133bf98b3a_Cfunc_gai_strerror = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_gai_strerror)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L184: _cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_gai_strerror, uintptr(unsafe.Pointer(&p0)))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L193: var _cgo_77133bf98b3a_Cfunc_getaddrinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_getaddrinfo)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L197: _cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_getaddrinfo, uintptr(unsafe.Pointer(&p0)))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L209: var _cgo_77133bf98b3a_Cfunc_getnameinfo = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_getnameinfo)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L213: _cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_getnameinfo, uintptr(unsafe.Pointer(&p0)))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L228: var _cgo_77133bf98b3a_Cfunc_res_search = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc_res_search)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L232: _cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc_res_search, uintptr(unsafe.Pointer(&p0)))
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L246: var _cgo_77133bf98b3a_Cfunc__Cmalloc = unsafe.Pointer(&__cgofn__cgo_77133bf98b3a_Cfunc__Cmalloc)
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L252: func _cgo_cmalloc(p0 uint64) (r1 unsafe.Pointer) {
1c315fb54dd1fee3cd91300cf670884ee961786c4b5d9162483397e875c9d355-d#L253: _cgo_runtime_cgocall(_cgo_77133bf98b3a_Cfunc__Cmalloc, uintptr(unsafe.Pointer(&p0)))
cgo_resnew.go#L23: gerrno, err := ( /*line :20:17*/_C2func_getnameinfo /*line :20:29*/)(sa, salen, (* /*line :20:44*/_Ctype_char /*line :20:50*/)(unsafe.Pointer(&b[0])), /*line :20:76*/_Ctype_socklen_t /*line :20:87*/(len(b)), nil, 0, ( /*line :20:105*/_Ciconst_NI_NAMEREQD /*line :20:117*/))
cgo_socknew.go#L28: return (* /*line :25:11*/_Ctype_struct_sockaddr /*line :25:28*/)(unsafe.Pointer(&sa))
cgo_socknew.go#L34: return (* /*line :31:11*/_Ctype_struct_sockaddr /*line :31:28*/)(unsafe.Pointer(&sa))
cgo_unix_cgo.go#L68: func _C_malloc(n uintptr) unsafe.Pointer { return ( /*line :65:51*/_Cfunc__CMalloc /*line :65:58*/)( /*line :65:60*/_Ctype_size_t /*line :65:68*/(n)) }
cgo_unix_cgo.go#L69: func _C_free(p unsafe.Pointer) { func() { _cgo0 := /*line :66:51*/p; _cgoCheckPointer(_cgo0, nil); /*line :66:53*/_Cfunc_free(_cgo0); }() }
reflect
abi.go#L224: tt := (*arrayType)(unsafe.Pointer(t))
abi.go#L237: st := (*structType)(unsafe.Pointer(t))
abi.go#L473: func intFromReg(r *abi.RegArgs, reg int, argSize uintptr, to unsafe.Pointer) {
abi.go#L480: func intToReg(r *abi.RegArgs, reg int, argSize uintptr, from unsafe.Pointer) {
abi.go#L487: func floatFromReg(r *abi.RegArgs, reg int, argSize uintptr, to unsafe.Pointer) {
abi.go#L492: *(*float64)(to) = *(*float64)(unsafe.Pointer(&r.Floats[reg]))
abi.go#L501: func floatToReg(r *abi.RegArgs, reg int, argSize uintptr, from unsafe.Pointer) {
badlinkname.go#L130: func badlinkname_Value_pointer(Value) unsafe.Pointer
deepequal.go#L19: a1 unsafe.Pointer
deepequal.go#L20: a2 unsafe.Pointer
deepequal.go#L63: ptrval := func(v Value) unsafe.Pointer {
float32reg_generic.go#L18: return *(*float32)(unsafe.Pointer(&i))
float32reg_generic.go#L22: return uint64(*(*uint32)(unsafe.Pointer(&val)))
makefunc.go#L53: ftyp := (*funcType)(unsafe.Pointer(t))
makefunc.go#L71: return Value{t, unsafe.Pointer(impl), flag(Func)}
makefunc.go#L108: ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))
makefunc.go#L130: return Value{ftyp.Common(), unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
makefunc.go#L172: ptr := (*uintptr)(add(unsafe.Pointer(unsafe.SliceData(args.Ptrs[:])), uintptr(i)*goarch.PtrSize, "always in [0:IntArgRegs]"))
map.go#L19: tt := (*abi.MapType)(unsafe.Pointer(t))
map.go#L46: mt := (*abi.MapType)(unsafe.Pointer(tt))
map.go#L58: var imap any = (map[unsafe.Pointer]unsafe.Pointer)(nil)
map.go#L59: mt := **(**abi.MapType)(unsafe.Pointer(&imap))
map.go#L66: mt.Hasher = func(p unsafe.Pointer, seed uintptr) uintptr {
map.go#L141: tt := (*abi.MapType)(unsafe.Pointer(v.typ()))
map.go#L151: var e unsafe.Pointer
map.go#L157: var k unsafe.Pointer
map.go#L161: k = unsafe.Pointer(&key.ptr)
map.go#L180: race.ReadPC(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(mapIterStart))
map.go#L193: race.ReadPC(unsafe.Pointer(it.Map()), callerpc, abi.FuncPCABIInternal(mapIterNext))
map.go#L205: tt := (*abi.MapType)(unsafe.Pointer(v.typ()))
map.go#L254: t := (*abi.MapType)(unsafe.Pointer(iter.m.typ()))
map.go#L274: var target unsafe.Pointer
map.go#L279: t := (*abi.MapType)(unsafe.Pointer(iter.m.typ()))
map.go#L298: t := (*abi.MapType)(unsafe.Pointer(iter.m.typ()))
map.go#L318: var target unsafe.Pointer
map.go#L323: t := (*abi.MapType)(unsafe.Pointer(iter.m.typ()))
map.go#L340: t := (*abi.MapType)(unsafe.Pointer(iter.m.typ()))
map.go#L400: tt := (*abi.MapType)(unsafe.Pointer(v.typ()))
map.go#L410: var e unsafe.Pointer
map.go#L414: e = unsafe.Pointer(&elem.ptr)
map.go#L421: var k unsafe.Pointer
map.go#L425: k = unsafe.Pointer(&key.ptr)
map.go#L433: var e unsafe.Pointer
map.go#L437: e = unsafe.Pointer(&elem.ptr)
swapper.go#L42: ps := *(*[]unsafe.Pointer)(v.ptr)
type.go#L455: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.DataChecked(off, "name offset field")))[:])
type.go#L456: pkgPathName := abi.Name{Bytes: (*byte)(resolveTypeOff(unsafe.Pointer(n.Bytes), nameOff))}
type.go#L534: func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
type.go#L541: func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L548: func resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L564: func addReflectOff(ptr unsafe.Pointer) int32
type.go#L569: return aNameOff(addReflectOff(unsafe.Pointer(n.Bytes)))
type.go#L575: return aTypeOff(addReflectOff(unsafe.Pointer(t)))
type.go#L581: func resolveReflectText(ptr unsafe.Pointer) aTextOff {
type.go#L586: return abi.Name{Bytes: (*byte)(resolveNameOff(unsafe.Pointer(t), int32(off)))}
type.go#L590: return (*abi.Type)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
type.go#L593: func (t *rtype) textOff(off aTextOff) unsafe.Pointer {
type.go#L594: return resolveTextOff(unsafe.Pointer(t), int32(off))
type.go#L597: func textOffFor(t *abi.Type, off aTextOff) unsafe.Pointer {
type.go#L638: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L646: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L658: ft := (*funcType)(unsafe.Pointer(mtyp))
type.go#L671: fn := unsafe.Pointer(&tfn)
type.go#L680: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L752: tt := (*abi.ChanType)(unsafe.Pointer(t))
type.go#L757: return (*rtype)(unsafe.Pointer(t))
type.go#L776: tt := (*structType)(unsafe.Pointer(t))
type.go#L784: tt := (*structType)(unsafe.Pointer(t))
type.go#L792: tt := (*structType)(unsafe.Pointer(t))
type.go#L800: tt := (*structType)(unsafe.Pointer(t))
type.go#L808: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L816: tt := (*structType)(unsafe.Pointer(t))
type.go#L824: tt := (*abi.FuncType)(unsafe.Pointer(t))
type.go#L832: tt := (*abi.FuncType)(unsafe.Pointer(t))
type.go#L840: tt := (*abi.FuncType)(unsafe.Pointer(t))
type.go#L848: tt := (*abi.FuncType)(unsafe.Pointer(t))
type.go#L856: tt := (*abi.FuncType)(unsafe.Pointer(t))
type.go#L1027: func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
type.go#L1028: return unsafe.Pointer(uintptr(p) + x)
type.go#L1203: p := unsafe.Pointer(&(*staticuint64s)[i])
type.go#L1334: styp := (*structType)(unsafe.Pointer(ntyp))
type.go#L1432: p := (*ptrType)(unsafe.Pointer(tt))
type.go#L1442: var iptr any = (*unsafe.Pointer)(nil)
type.go#L1443: prototype := *(**ptrType)(unsafe.Pointer(&iptr))
type.go#L1508: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L1526: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L1662: t := (*funcType)(unsafe.Pointer(T))
type.go#L1663: v := (*funcType)(unsafe.Pointer(V))
type.go#L1680: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L1681: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L1696: t := (*structType)(unsafe.Pointer(T))
type.go#L1697: v := (*structType)(unsafe.Pointer(V))
type.go#L1748: func typelinks() (sections []unsafe.Pointer, offset [][]int32)
type.go#L1759: func rtypeOff(section unsafe.Pointer, off int32) *abi.Type {
type.go#L1878: ch := (*chanType)(unsafe.Pointer(tt))
type.go#L1886: var ichan any = (chan unsafe.Pointer)(nil)
type.go#L1887: prototype := *(**chanType)(unsafe.Pointer(&ichan))
type.go#L1941: prototype := *(**funcType)(unsafe.Pointer(&ifunc))
type.go#L1949: ft := (*funcType)(unsafe.Pointer(o.Field(0).Addr().Pointer()))
type.go#L1950: args := unsafe.Slice((**rtype)(unsafe.Pointer(o.Field(1).Addr().Pointer())), n)[0:0:n]
type.go#L2034: repr = append(repr, stringFor((*sliceType)(unsafe.Pointer(t)).Elem)...)
type.go#L2067: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2070: tt := (*structType)(unsafe.Pointer(t))
type.go#L2094: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2097: tt := (*structType)(unsafe.Pointer(t))
type.go#L2116: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2119: tt := (*structType)(unsafe.Pointer(t))
type.go#L2161: slice := (*sliceType)(unsafe.Pointer(tt))
type.go#L2169: var islice any = ([]unsafe.Pointer)(nil)
type.go#L2170: prototype := *(**sliceType)(unsafe.Pointer(&islice))
type.go#L2327: ift := (*interfaceType)(unsafe.Pointer(ft))
type.go#L2334: fnStub := resolveReflectText(unsafe.Pointer(abi.FuncPCABIInternal(embeddedIfaceMethStub)))
type.go#L2343: ptr := (*ptrType)(unsafe.Pointer(ft))
type.go#L2508: prototype := *(**structType)(unsafe.Pointer(&istruct))
type.go#L2582: typ.GCData = (*byte)(unsafe.Pointer(new(uintptr)))
type.go#L2587: typ.Equal = func(p, q unsafe.Pointer) bool {
type.go#L2645: st := (*structType)(unsafe.Pointer(t))
type.go#L2686: array := (*arrayType)(unsafe.Pointer(tt))
type.go#L2694: var iarray any = [1]unsafe.Pointer{}
type.go#L2695: prototype := *(**arrayType)(unsafe.Pointer(&iarray))
type.go#L2747: array.GCData = (*byte)(unsafe.Pointer(new(uintptr)))
type.go#L2755: array.Equal = func(p, q unsafe.Pointer) bool {
type.go#L2926: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2933: tt := (*structType)(unsafe.Pointer(t))
value.go#L47: ptr unsafe.Pointer
value.go#L106: return (*abi.Type)(abi.NoEscape(unsafe.Pointer(v.typ_)))
value.go#L112: func (v Value) pointer() unsafe.Pointer {
value.go#L117: return *(*unsafe.Pointer)(v.ptr)
value.go#L124: return *(*any)(unsafe.Pointer(&abi.EmptyInterface{
value.go#L132: func packEfaceData(v Value) unsafe.Pointer {
value.go#L150: return *(*unsafe.Pointer)(v.ptr)
value.go#L159: e := (*abi.EmptyInterface)(unsafe.Pointer(&i))
value.go#L209: word unsafe.Pointer
value.go#L322: n := int((*arrayType)(unsafe.Pointer(v.typ())).Len)
value.go#L392: t := (*funcType)(unsafe.Pointer(v.typ()))
value.go#L394: fn unsafe.Pointer
value.go#L402: fn = *(*unsafe.Pointer)(v.ptr)
value.go#L476: var stackArgs unsafe.Pointer
value.go#L479: stackArgs = framePool.Get().(unsafe.Pointer)
value.go#L505: storeRcvr(rcvr, unsafe.Pointer(®Args.Ptrs[st.ireg]))
value.go#L508: storeRcvr(rcvr, unsafe.Pointer(®Args.Ints[st.ireg]))
value.go#L510: storeRcvr(rcvr, unsafe.Pointer(®Args.Floats[st.freg]))
value.go#L534: *(*unsafe.Pointer)(addr) = v.ptr
value.go#L546: regArgs.Ptrs[st.ireg] = *(*unsafe.Pointer)(offset)
value.go#L660: *((*unsafe.Pointer)(s)) = regArgs.Ptrs[st.ireg]
value.go#L697: func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool, regs *abi.RegArgs) {
value.go#L733: v.ptr = *(*unsafe.Pointer)(add(ptr, st.stkOff, "1-ptr"))
value.go#L748: *((*unsafe.Pointer)(s)) = regs.Ptrs[st.ireg]
value.go#L877: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *abi.Type, t *funcType, fn unsafe.Pointer) {
value.go#L880: tt := (*interfaceType)(unsafe.Pointer(v.typ()))
value.go#L893: fn = unsafe.Pointer(&unsafe.Slice(&iface.itab.Fun[0], i+1)[i])
value.go#L894: t = (*funcType)(unsafe.Pointer(tt.typeOff(m.Typ)))
value.go#L906: fn = unsafe.Pointer(&ifn)
value.go#L907: t = (*funcType)(unsafe.Pointer(typeOffFor(v.typ(), m.Mtyp)))
value.go#L916: func storeRcvr(v Value, p unsafe.Pointer) {
value.go#L921: *(*unsafe.Pointer)(p) = iface.word
value.go#L923: *(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(v.ptr)
value.go#L925: *(*unsafe.Pointer)(p) = v.ptr
value.go#L954: func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool, regs *abi.RegArgs) {
value.go#L972: methodFrame := methodFramePool.Get().(unsafe.Pointer)
value.go#L983: storeRcvr(rcvr, unsafe.Pointer(&methodRegs.Ptrs[st.ireg]))
value.go#L986: storeRcvr(rcvr, unsafe.Pointer(&methodRegs.Ints[st.ireg]))
value.go#L988: storeRcvr(rcvr, unsafe.Pointer(&methodRegs.Floats[st.freg]))
value.go#L1034: methodRegs.Ptrs[mStep.ireg] = *(*unsafe.Pointer)(from)
value.go#L1053: *(*unsafe.Pointer)(to) = valueRegs.Ptrs[vStep.ireg]
value.go#L1145: pc := *(*uintptr)(unsafe.Pointer(&f))
value.go#L1185: tt := (*chanType)(unsafe.Pointer(v.typ()))
value.go#L1247: ptr = *(*unsafe.Pointer)(ptr)
value.go#L1253: tt := (*ptrType)(unsafe.Pointer(v.typ()))
value.go#L1268: tt := (*structType)(unsafe.Pointer(v.typ()))
value.go#L1294: return Value{typ, unsafe.Pointer(&zeroVal[0]), fl | flagIndir}
value.go#L1403: tt := (*arrayType)(unsafe.Pointer(v.typ()))
value.go#L1426: tt := (*sliceType)(unsafe.Pointer(v.typ()))
value.go#L1566: iface := *(*any)(unsafe.Pointer(&abi.EmptyInterface{Type: v.typ(), Data: nil}))
value.go#L1571: (*abi.CommonInterface)(unsafe.Pointer(&out)).Data = packEfaceData(v)
value.go#L1585: return *(*T)(unsafe.Pointer(&v.ptr)), true
value.go#L1641: ptr = *(*unsafe.Pointer)(ptr)
value.go#L1647: return *(*unsafe.Pointer)(v.ptr) == nil
value.go#L1679: if v.ptr == unsafe.Pointer(&zeroVal[0]) {
value.go#L1682: typ := (*abi.ArrayType)(unsafe.Pointer(v.typ()))
value.go#L1688: return typ.Equal(abi.NoEscape(v.ptr), unsafe.Pointer(&zeroVal[0]))
value.go#L1710: if v.ptr == unsafe.Pointer(&zeroVal[0]) {
value.go#L1713: typ := (*abi.StructType)(unsafe.Pointer(v.typ()))
value.go#L1717: return typ.Equal(abi.NoEscape(v.ptr), unsafe.Pointer(&zeroVal[0]))
value.go#L1747: for uintptr(unsafe.Pointer(&b[0]))%8 != 0 {
value.go#L1765: w := unsafe.Slice((*uint64)(unsafe.Pointer(&b[0])), len(b)/8)
value.go#L1832: *(*unsafe.Pointer)(v.ptr) = nil
value.go#L1861: tt := (*arrayType)(unsafe.Pointer(v.typ()))
value.go#L1881: func copyVal(typ *abi.Type, fl flag, ptr unsafe.Pointer) Value {
value.go#L1889: return Value{typ, *(*unsafe.Pointer)(ptr), fl}
value.go#L1957: tt := (*structType)(unsafe.Pointer(v.typ()))
value.go#L2074: p = *(*unsafe.Pointer)(p)
value.go#L2099: tt := (*chanType)(unsafe.Pointer(v.typ()))
value.go#L2105: var p unsafe.Pointer
value.go#L2111: p = unsafe.Pointer(&val.ptr)
value.go#L2132: tt := (*chanType)(unsafe.Pointer(v.typ()))
value.go#L2138: var p unsafe.Pointer
value.go#L2142: p = unsafe.Pointer(&x.ptr)
value.go#L2154: var target unsafe.Pointer
value.go#L2160: if x.ptr == unsafe.Pointer(&zeroVal[0]) {
value.go#L2166: *(*unsafe.Pointer)(v.ptr) = x.ptr
value.go#L2307: func (v Value) SetPointer(x unsafe.Pointer) {
value.go#L2310: *(*unsafe.Pointer)(v.ptr) = x
value.go#L2328: base unsafe.Pointer
value.go#L2338: tt := (*arrayType)(unsafe.Pointer(v.typ()))
value.go#L2340: typ = (*sliceType)(unsafe.Pointer(tt.Slice))
value.go#L2344: typ = (*sliceType)(unsafe.Pointer(v.typ()))
value.go#L2358: return Value{v.typ(), unsafe.Pointer(&t), v.flag}
value.go#L2366: var x []unsafe.Pointer
value.go#L2369: s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
value.go#L2380: return Value{typ.Common(), unsafe.Pointer(&x), fl}
value.go#L2390: base unsafe.Pointer
value.go#L2400: tt := (*arrayType)(unsafe.Pointer(v.typ()))
value.go#L2402: typ = (*sliceType)(unsafe.Pointer(tt.Slice))
value.go#L2406: typ = (*sliceType)(unsafe.Pointer(v.typ()))
value.go#L2418: var x []unsafe.Pointer
value.go#L2421: s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
value.go#L2432: return Value{typ.Common(), unsafe.Pointer(&x), fl}
value.go#L2482: return (*rtype)(abi.NoEscape(unsafe.Pointer(v.typ_))) // inline of toRType(v.typ()), for own inlining in inline test
value.go#L2514: tt := (*interfaceType)(unsafe.Pointer(typ))
value.go#L2597: func (v Value) UnsafePointer() unsafe.Pointer {
value.go#L2607: return *(*unsafe.Pointer)(v.ptr)
value.go#L2621: return *(*unsafe.Pointer)(unsafe.Pointer(&code))
value.go#L2627: p = *(*unsafe.Pointer)(p)
value.go#L2720: func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
value.go#L2763: v.ptr = unsafe.Pointer(s)
value.go#L2778: st := (*sliceType)(unsafe.Pointer(v.typ()))
value.go#L2875: ch unsafe.Pointer // channel
value.go#L2876: val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
value.go#L2977: tt := (*chanType)(unsafe.Pointer(ch.typ()))
value.go#L2992: rc.val = unsafe.Pointer(&v.ptr)
value.go#L3008: tt := (*chanType)(unsafe.Pointer(ch.typ()))
value.go#L3020: tt := (*chanType)(unsafe.Pointer(runcases[chosen].typ))
value.go#L3027: recv = Value{t, *(*unsafe.Pointer)(p), fl}
value.go#L3040: func unsafe_New(*abi.Type) unsafe.Pointer
value.go#L3043: func unsafe_NewArray(*abi.Type, int) unsafe.Pointer
value.go#L3062: return Value{&typ.(*rtype).t, unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L3069: func SliceAt(typ Type, p unsafe.Pointer, n int) Value {
value.go#L3072: return Value{SliceOf(typ).common(), unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L3138: var p unsafe.Pointer
value.go#L3140: p = unsafe.Pointer(&zeroVal[0])
value.go#L3171: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L3182: func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
value.go#L3695: func chancap(ch unsafe.Pointer) int
value.go#L3698: func chanclose(ch unsafe.Pointer)
value.go#L3701: func chanlen(ch unsafe.Pointer) int
value.go#L3711: func chanrecv(ch unsafe.Pointer, nb bool, val unsafe.Pointer) (selected, received bool)
value.go#L3714: func chansend0(ch unsafe.Pointer, val unsafe.Pointer, nb bool) bool
value.go#L3716: func chansend(ch unsafe.Pointer, val unsafe.Pointer, nb bool) bool {
value.go#L3721: func makechan(typ *abi.Type, size int) (ch unsafe.Pointer)
value.go#L3722: func makemap(t *abi.Type, cap int) (m unsafe.Pointer)
value.go#L3725: func mapaccess(t *abi.Type, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
value.go#L3728: func mapaccess_faststr(t *abi.Type, m unsafe.Pointer, key string) (val unsafe.Pointer)
value.go#L3731: func mapassign0(t *abi.Type, m unsafe.Pointer, key, val unsafe.Pointer)
value.go#L3743: func mapassign(t *abi.Type, m unsafe.Pointer, key, val unsafe.Pointer) {
value.go#L3750: func mapassign_faststr0(t *abi.Type, m unsafe.Pointer, key string, val unsafe.Pointer)
value.go#L3752: func mapassign_faststr(t *abi.Type, m unsafe.Pointer, key string, val unsafe.Pointer) {
value.go#L3753: contentEscapes((*unsafeheader.String)(unsafe.Pointer(&key)).Data)
value.go#L3759: func mapdelete(t *abi.Type, m unsafe.Pointer, key unsafe.Pointer)
value.go#L3762: func mapdelete_faststr(t *abi.Type, m unsafe.Pointer, key string)
value.go#L3765: func maplen(m unsafe.Pointer) int
value.go#L3767: func mapclear(t *abi.Type, m unsafe.Pointer)
value.go#L3795: func call(stackArgsType *abi.Type, f, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
value.go#L3797: func ifaceE2I(t *abi.Type, src any, dst unsafe.Pointer)
value.go#L3802: func memmove(dst, src unsafe.Pointer, size uintptr)
value.go#L3807: func typedmemmove(t *abi.Type, dst, src unsafe.Pointer)
value.go#L3812: func typedmemclr(t *abi.Type, ptr unsafe.Pointer)
value.go#L3818: func typedmemclrpartial(t *abi.Type, ptr unsafe.Pointer, off, size uintptr)
value.go#L3830: func typedarrayclear(elemType *abi.Type, ptr unsafe.Pointer, len int)
value.go#L3833: func typehash(t *abi.Type, p unsafe.Pointer, h uintptr) uintptr
value.go#L3841: func unsafeslice(t *abi.Type, ptr unsafe.Pointer, len int)
value.go#L3861: func contentEscapes(x unsafe.Pointer) {
runtime
alg.go#L34: func memhash0(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L38: func memhash8(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L42: func memhash16(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L46: func memhash128(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L51: func memhash_varlen(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L53: size := *(*uintptr)(unsafe.Pointer(ptr + unsafe.Sizeof(h)))
alg.go#L81: func memhash(p unsafe.Pointer, h, s uintptr) uintptr
alg.go#L83: func memhash32(p unsafe.Pointer, h uintptr) uintptr
alg.go#L85: func memhash64(p unsafe.Pointer, h uintptr) uintptr
alg.go#L100: func strhash(p unsafe.Pointer, h uintptr) uintptr
alg.go#L102: func strhashFallback(a unsafe.Pointer, h uintptr) uintptr {
alg.go#L112: func f32hash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L124: func f64hash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L136: func c64hash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L138: return f32hash(unsafe.Pointer(&x[1]), f32hash(unsafe.Pointer(&x[0]), h))
alg.go#L141: func c128hash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L143: return f64hash(unsafe.Pointer(&x[1]), f64hash(unsafe.Pointer(&x[0]), h))
alg.go#L146: func interhash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L161: return trimHash(c1 * typehash(t, unsafe.Pointer(&a.data), h^c0))
alg.go#L177: func nilinterhash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L188: return trimHash(c1 * typehash(t, unsafe.Pointer(&a.data), h^c0))
alg.go#L215: func typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
alg.go#L239: i := (*interfacetype)(unsafe.Pointer(t))
alg.go#L245: a := (*arraytype)(unsafe.Pointer(t))
alg.go#L251: s := (*structtype)(unsafe.Pointer(t))
alg.go#L267: func reflect_typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
alg.go#L271: func memequal0(p, q unsafe.Pointer) bool {
alg.go#L274: func memequal8(p, q unsafe.Pointer) bool {
alg.go#L277: func memequal16(p, q unsafe.Pointer) bool {
alg.go#L280: func memequal32(p, q unsafe.Pointer) bool {
alg.go#L283: func memequal64(p, q unsafe.Pointer) bool {
alg.go#L286: func memequal128(p, q unsafe.Pointer) bool {
alg.go#L289: func f32equal(p, q unsafe.Pointer) bool {
alg.go#L292: func f64equal(p, q unsafe.Pointer) bool {
alg.go#L295: func c64equal(p, q unsafe.Pointer) bool {
alg.go#L298: func c128equal(p, q unsafe.Pointer) bool {
alg.go#L301: func strequal(p, q unsafe.Pointer) bool {
alg.go#L304: func interequal(p, q unsafe.Pointer) bool {
alg.go#L309: func nilinterequal(p, q unsafe.Pointer) bool {
alg.go#L314: func efaceeq(t *_type, x, y unsafe.Pointer) bool {
alg.go#L330: func ifaceeq(tab *itab, x, y unsafe.Pointer) bool {
alg.go#L358: return strhash(noescape(unsafe.Pointer(&s)), seed)
alg.go#L362: s := (*slice)(unsafe.Pointer(&b))
alg.go#L367: return memhash32(noescape(unsafe.Pointer(&i)), seed)
alg.go#L371: return memhash64(noescape(unsafe.Pointer(&i)), seed)
alg.go#L375: return nilinterhash(noescape(unsafe.Pointer(&i)), seed)
alg.go#L381: return interhash(noescape(unsafe.Pointer(&i)), seed)
alg.go#L413: key := (*[hashRandomBytes / 8]uint64)(unsafe.Pointer(&aeskeysched))
alg.go#L420: func readUnaligned32(p unsafe.Pointer) uint32 {
alg.go#L428: func readUnaligned64(p unsafe.Pointer) uint64 {
arena.go#L102: func arena_newArena() unsafe.Pointer {
arena.go#L103: return unsafe.Pointer(newUserArena())
arena.go#L112: func arena_arena_New(arena unsafe.Pointer, typ any) any {
arena.go#L117: te := (*ptrtype)(unsafe.Pointer(t)).Elem
arena.go#L129: func arena_arena_Slice(arena unsafe.Pointer, slice any, cap int) {
arena.go#L136: func arena_arena_Free(arena unsafe.Pointer) {
arena.go#L145: var v unsafe.Pointer
arena.go#L173: et := (*slicetype)(unsafe.Pointer(t)).Elem
arena.go#L178: xe.data = unsafe.Pointer(sl)
arena.go#L180: et := (*ptrtype)(unsafe.Pointer(t)).Elem
arena.go#L252: refs []unsafe.Pointer
arena.go#L279: func (a *userArena) new(typ *_type) unsafe.Pointer {
arena.go#L299: typ = (*ptrtype)(unsafe.Pointer(typ)).Elem
arena.go#L303: typ = (*slicetype)(unsafe.Pointer(typ)).Elem
arena.go#L367: func (a *userArena) alloc(typ *_type, cap int) unsafe.Pointer {
arena.go#L369: var x unsafe.Pointer
arena.go#L398: var x unsafe.Pointer
arena.go#L428: x unsafe.Pointer
arena.go#L449: func (s *mspan) userArenaNextFree(typ *_type, cap int) unsafe.Pointer {
arena.go#L459: return unsafe.Pointer(&zerobase)
arena.go#L482: var ptr unsafe.Pointer
arena.go#L487: ptr = unsafe.Pointer(v)
arena.go#L492: ptr = unsafe.Pointer(v)
arena.go#L539: func userArenaHeapBitsSetSliceType(typ *_type, n int, ptr unsafe.Pointer, s *mspan) {
arena.go#L553: func userArenaHeapBitsSetType(typ *_type, ptr unsafe.Pointer, s *mspan) {
arena.go#L737: func newUserArenaChunk() (unsafe.Pointer, *mspan) {
arena.go#L770: x := unsafe.Pointer(span.base())
arena.go#L782: racemalloc(unsafe.Pointer(span.base()), span.elemsize)
arena.go#L787: msanmalloc(unsafe.Pointer(span.base()), span.elemsize)
arena.go#L794: asanpoison(unsafe.Pointer(rzStart), span.limit-rzStart)
arena.go#L795: asanunpoison(unsafe.Pointer(span.base()), span.elemsize)
arena.go#L807: profilealloc(mp, unsafe.Pointer(span.base()), userArenaChunkBytes)
arena.go#L880: sysFault(unsafe.Pointer(s.base()), s.npages*pageSize)
arena.go#L909: racefree(unsafe.Pointer(s.base()), s.elemsize)
arena.go#L936: func freeUserArenaChunk(s *mspan, x unsafe.Pointer) {
arena.go#L947: racefree(unsafe.Pointer(s.base()), s.elemsize)
arena.go#L950: msanfree(unsafe.Pointer(s.base()), s.elemsize)
arena.go#L953: asanpoison(unsafe.Pointer(s.base()), s.elemsize)
arena.go#L956: valgrindFree(unsafe.Pointer(s.base()))
arena.go#L1049: sysMap(unsafe.Pointer(base), userArenaChunkBytes, &gcController.heapReleased, "user arena chunk")
arena.go#L1050: sysUsed(unsafe.Pointer(base), userArenaChunkBytes, userArenaChunkBytes)
arena.go#L1110: memclrNoHeapPointers(unsafe.Pointer(s.base()), s.elemsize)
arena.go#L1124: *(*uintptr)(unsafe.Pointer(&s.largeType)) = uintptr(unsafe.Pointer(s.limit))
arena.go#L1125: *(*uintptr)(unsafe.Pointer(&s.largeType.GCData)) = s.limit + unsafe.Sizeof(_type{})
asan0.go#L20: func asanread(addr unsafe.Pointer, sz uintptr) { throw("asan") }
asan0.go#L21: func asanwrite(addr unsafe.Pointer, sz uintptr) { throw("asan") }
asan0.go#L22: func asanunpoison(addr unsafe.Pointer, sz uintptr) { throw("asan") }
asan0.go#L23: func asanpoison(addr unsafe.Pointer, sz uintptr) { throw("asan") }
asan0.go#L24: func asanregisterglobals(addr unsafe.Pointer, sz uintptr) { throw("asan") }
asan0.go#L25: func lsanregisterrootregion(unsafe.Pointer, uintptr) { throw("asan") }
asan0.go#L26: func lsanunregisterrootregion(unsafe.Pointer, uintptr) { throw("asan") }
atomic_pointer.go#L32: func atomicwb(ptr *unsafe.Pointer, new unsafe.Pointer) {
atomic_pointer.go#L33: slot := (*uintptr)(unsafe.Pointer(ptr))
atomic_pointer.go#L42: func atomicstorep(ptr unsafe.Pointer, new unsafe.Pointer) {
atomic_pointer.go#L44: atomicwb((*unsafe.Pointer)(ptr), new)
atomic_pointer.go#L47: cgoCheckPtrWrite((*unsafe.Pointer)(ptr), new)
atomic_pointer.go#L57: func atomic_storePointer(ptr *unsafe.Pointer, new unsafe.Pointer) {
atomic_pointer.go#L58: atomicstorep(unsafe.Pointer(ptr), new)
atomic_pointer.go#L66: func atomic_casPointer(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool {
atomic_pointer.go#L85: func sync_atomic_StorePointer(ptr *unsafe.Pointer, new unsafe.Pointer) {
atomic_pointer.go#L92: sync_atomic_StoreUintptr((*uintptr)(unsafe.Pointer(ptr)), uintptr(new))
atomic_pointer.go#L100: func sync_atomic_SwapPointer(ptr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer {
atomic_pointer.go#L107: old := unsafe.Pointer(sync_atomic_SwapUintptr((*uintptr)(noescape(unsafe.Pointer(ptr))), uintptr(new)))
atomic_pointer.go#L116: func sync_atomic_CompareAndSwapPointer(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool {
atomic_pointer.go#L123: return sync_atomic_CompareAndSwapUintptr((*uintptr)(noescape(unsafe.Pointer(ptr))), uintptr(old), uintptr(new))
cgo.go#L27: _cgo_init unsafe.Pointer
cgo.go#L28: _cgo_thread_start unsafe.Pointer
cgo.go#L29: _cgo_sys_thread_create unsafe.Pointer
cgo.go#L30: _cgo_notify_runtime_init_done unsafe.Pointer
cgo.go#L31: _cgo_callers unsafe.Pointer
cgo.go#L32: _cgo_set_traceback_functions unsafe.Pointer
cgo.go#L33: _cgo_call_traceback_function unsafe.Pointer
cgo.go#L34: _cgo_call_symbolizer_function unsafe.Pointer
cgo.go#L35: _cgo_yield unsafe.Pointer
cgo.go#L36: _cgo_pthread_key_created unsafe.Pointer
cgo.go#L37: _cgo_bindm unsafe.Pointer
cgo.go#L38: _cgo_getstackbound unsafe.Pointer
cgo_mmap.go#L17: var _cgo_mmap unsafe.Pointer
cgo_mmap.go#L23: var _cgo_munmap unsafe.Pointer
cgo_mmap.go#L31: func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) {
cgo_mmap.go#L45: return unsafe.Pointer(ret), 0
cgo_mmap.go#L50: func munmap(addr unsafe.Pointer, n uintptr) {
cgo_mmap.go#L59: func sysMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int)
cgo_mmap.go#L63: func callCgoMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) uintptr
cgo_mmap.go#L66: func sysMunmap(addr unsafe.Pointer, n uintptr)
cgo_mmap.go#L70: func callCgoMunmap(addr unsafe.Pointer, n uintptr)
cgo_sigaction.go#L19: var _cgo_sigaction unsafe.Pointer
cgo_sigaction.go#L31: msanwrite(unsafe.Pointer(new), unsafe.Sizeof(*new))
cgo_sigaction.go#L34: asanwrite(unsafe.Pointer(new), unsafe.Sizeof(*new))
cgo_sigaction.go#L53: sp := uintptr(unsafe.Pointer(&sig))
cgo_sigaction.go#L87: msanread(unsafe.Pointer(old), unsafe.Sizeof(*old))
cgo_sigaction.go#L90: asanread(unsafe.Pointer(old), unsafe.Sizeof(*old))
cgocall.go#L101: args unsafe.Pointer
cgocall.go#L110: func syscall_cgocaller(fn unsafe.Pointer, args ...uintptr) uintptr {
cgocall.go#L111: as := argset{args: unsafe.Pointer(&args[0])}
cgocall.go#L112: cgocall(fn, unsafe.Pointer(&as))
cgocall.go#L134: func cgocall(fn, arg unsafe.Pointer) int32 {
cgocall.go#L144: racereleasemerge(unsafe.Pointer(&racecgosync))
cgocall.go#L205: raceacquire(unsafe.Pointer(&racecgosync))
cgocall.go#L291: asmcgocall(_cgo_getstackbound, unsafe.Pointer(&bounds))
cgocall.go#L313: func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
cgocall.go#L347: savedsp := unsafe.Pointer(gp.syscallsp)
cgocall.go#L349: savedbp := unsafe.Pointer(gp.syscallbp)
cgocall.go#L394: func cgocallbackg1(fn, frame unsafe.Pointer, ctxt uintptr) {
cgocall.go#L411: p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
cgocall.go#L412: atomicstorep(unsafe.Pointer(&p.array), unsafe.Pointer(&s[0]))
cgocall.go#L418: p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
cgocall.go#L458: raceacquire(unsafe.Pointer(&racecgosync))
cgocall.go#L463: var cb func(frame unsafe.Pointer)
cgocall.go#L465: *(*unsafe.Pointer)(unsafe.Pointer(&cb)) = noescape(unsafe.Pointer(&cbFV))
cgocall.go#L469: racereleasemerge(unsafe.Pointer(&racecgosync))
cgocall.go#L495: sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + alignUp(sys.MinFrameSize, sys.StackAlign)))
cgocall.go#L576: p = *(*unsafe.Pointer)(p)
cgocall.go#L588: pt := (*ptrtype)(unsafe.Pointer(t))
cgocall.go#L606: pt := (*abi.PtrType)(unsafe.Pointer(aep._type))
cgocall.go#L633: func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg cgoErrorMsg) {
cgocall.go#L643: at := (*arraytype)(unsafe.Pointer(t))
cgocall.go#L662: p = *(*unsafe.Pointer)(p)
cgocall.go#L676: if inheap(uintptr(unsafe.Pointer(it))) {
cgocall.go#L679: p = *(*unsafe.Pointer)(add(p, goarch.PtrSize))
cgocall.go#L688: st := (*slicetype)(unsafe.Pointer(t))
cgocall.go#L713: st := (*structtype)(unsafe.Pointer(t))
cgocall.go#L729: p = *(*unsafe.Pointer)(p)
cgocall.go#L750: func cgoCheckUnknownPointer(p unsafe.Pointer, msg cgoErrorMsg) (base, i uintptr) {
cgocall.go#L763: pp := *(*unsafe.Pointer)(unsafe.Pointer(addr))
cgocall.go#L790: func cgoIsGoPointer(p unsafe.Pointer) bool {
cgocall.go#L812: func cgoInRange(p unsafe.Pointer, start, end uintptr) bool {
cgocheck.go#L25: func cgoCheckPtrWrite(dst *unsafe.Pointer, src unsafe.Pointer) {
cgocheck.go#L35: if cgoIsGoPointer(unsafe.Pointer(dst)) {
cgocheck.go#L61: if inPersistentAlloc(uintptr(unsafe.Pointer(dst))) {
cgocheck.go#L66: println("write of unpinned Go pointer", hex(uintptr(src)), "to non-Go memory", hex(uintptr(unsafe.Pointer(dst))))
cgocheck.go#L79: func cgoCheckMemmove(typ *_type, dst, src unsafe.Pointer) {
cgocheck.go#L91: func cgoCheckMemmove2(typ *_type, dst, src unsafe.Pointer, off, size uintptr) {
cgocheck.go#L112: func cgoCheckSliceCopy(typ *_type, dst, src unsafe.Pointer, n int) {
cgocheck.go#L135: func cgoCheckTypedBlock(typ *_type, src unsafe.Pointer, off, size uintptr) {
cgocheck.go#L153: func cgoCheckBits(src unsafe.Pointer, gcbits *byte, off, size uintptr) {
cgocheck.go#L172: v := *(*unsafe.Pointer)(add(src, i))
chan.go#L37: buf unsafe.Pointer // points to an array of dataqsiz elements
chan.go#L106: c.buf = add(unsafe.Pointer(c), hchanSize)
chan.go#L138: func chanbuf(c *hchan, i uint) unsafe.Pointer {
chan.go#L160: func chansend1(c *hchan, elem unsafe.Pointer) {
chan.go#L176: func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
chan.go#L283: gopark(chanparkcommit, unsafe.Pointer(&c.lock), reason, traceBlockChanSend, 2)
chan.go#L318: func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
chan.go#L345: gp.param = unsafe.Pointer(sg)
chan.go#L392: func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
chan.go#L405: func recvDirect(t *_type, sg *sudog, dst unsafe.Pointer) {
chan.go#L452: gp.param = unsafe.Pointer(sg)
chan.go#L471: gp.param = unsafe.Pointer(sg)
chan.go#L495: return atomic.Loadp(unsafe.Pointer(&c.sendq.first)) == nil
chan.go#L508: func chanrecv1(c *hchan, elem unsafe.Pointer) {
chan.go#L513: func chanrecv2(c *hchan, elem unsafe.Pointer) (received bool) {
chan.go#L524: func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
chan.go#L667: gopark(chanparkcommit, unsafe.Pointer(&c.lock), reason, traceBlockChanRecv, 2)
chan.go#L702: func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
chan.go#L740: gp.param = unsafe.Pointer(sg)
chan.go#L748: func chanparkcommit(gp *g, chanLock unsafe.Pointer) bool {
chan.go#L784: func selectnbsend(c *hchan, elem unsafe.Pointer) (selected bool) {
chan.go#L804: func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected, received bool) {
chan.go#L809: func reflect_chansend(c *hchan, elem unsafe.Pointer, nb bool) (selected bool) {
chan.go#L814: func reflect_chanrecv(c *hchan, nb bool, elem unsafe.Pointer) (selected bool, received bool) {
chan.go#L921: func (c *hchan) raceaddr() unsafe.Pointer {
chan.go#L927: return unsafe.Pointer(&c.buf)
checkptr.go#L9: func checkptrAlignment(p unsafe.Pointer, elem *_type, n uintptr) {
checkptr.go#L32: func checkptrStraddles(ptr unsafe.Pointer, size uintptr) bool {
checkptr.go#L50: func checkptrArithmetic(p unsafe.Pointer, originals []unsafe.Pointer) {
checkptr.go#L89: func checkptrBase(p unsafe.Pointer) uintptr {
coro.go#L50: startfv := *(**funcval)(unsafe.Pointer(&start))
coro.go#L125: print("coro: got thread ", unsafe.Pointer(mp), ", want ", unsafe.Pointer(c.mp), "\n")
covercounter.go#L21: Counters: (*uint32)(unsafe.Pointer(datap.covctrs)),
covermeta.go#L14: func addCovMeta(p unsafe.Pointer, dlen uint32, hash [16]byte, pkgpath string, pkgid int, cmode uint8, cgran uint8) uint32 {
cpuprof.go#L106: func (p *cpuProfile) add(tagPtr *unsafe.Pointer, stk []uintptr) {
cpuprof.go#L243: func runtime_pprof_readProfile() ([]uint64, []unsafe.Pointer, bool) {
debug.go#L161: for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
debug.go#L171: for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
debug.go#L251: p.Pin(unsafe.Pointer(p))
debugcall.go#L128: newg := newproc1(*(**funcval)(unsafe.Pointer(&fn)), gp, callerpc, false, waitReasonZero)
debugcall.go#L133: newg.param = unsafe.Pointer(args)
debugcall.go#L266: *(*unsafe.Pointer)(unsafe.Pointer(&dispatchF)) = noescape(unsafe.Pointer(&dispatchFV))
debuglog.go#L85: allp := (*uintptr)(unsafe.Pointer(&allDloggers))
debuglog.go#L86: all := (*dloggerImpl)(unsafe.Pointer(atomic.Loaduintptr(allp)))
debuglog.go#L107: headp := (*uintptr)(unsafe.Pointer(&allDloggers))
debuglog.go#L110: l.allLink = (*dloggerImpl)(unsafe.Pointer(head))
debuglog.go#L111: if atomic.Casuintptr(headp, head, uintptr(unsafe.Pointer(l))) {
debuglog.go#L348: if len(x) > 4 && datap.etext <= uintptr(unsafe.Pointer(strData)) && uintptr(unsafe.Pointer(strData)) < datap.end {
debuglog.go#L354: l.w.uvarint(uint64(uintptr(unsafe.Pointer(strData)) - datap.etext))
debuglog.go#L360: bb := (*slice)(unsafe.Pointer(&b))
debuglog.go#L361: bb.array = unsafe.Pointer(strData)
debuglog.go#L377: func (l dloggerFake) hexdump(p unsafe.Pointer, bytes uintptr) dloggerFake { return l }
debuglog.go#L380: func (l *dloggerImpl) hexdump(p unsafe.Pointer, bytes uintptr) *dloggerImpl {
debuglog.go#L382: bb := (*slice)(unsafe.Pointer(&b))
debuglog.go#L383: bb.array = unsafe.Pointer(p)
debuglog.go#L732: str: unsafe.Pointer(ptr),
debuglog.go#L735: s := *(*string)(unsafe.Pointer(&str))
debuglog.go#L794: allp := (*uintptr)(unsafe.Pointer(&allDloggers))
debuglog.go#L795: all := (*dloggerImpl)(unsafe.Pointer(atomic.Loaduintptr(allp)))
debuglog.go#L876: print(slicebytetostringtmp((*byte)(noescape(unsafe.Pointer(&pnanoBytes[0]))), len(pnanoBytes)))
env_posix.go#L54: var _cgo_setenv unsafe.Pointer // pointer to C function
env_posix.go#L65: var _cgo_unsetenv unsafe.Pointer // pointer to C function
env_posix.go#L72: arg := [2]unsafe.Pointer{cstring(k), cstring(v)}
env_posix.go#L73: asmcgocall(_cgo_setenv, unsafe.Pointer(&arg))
env_posix.go#L81: arg := [1]unsafe.Pointer{cstring(k)}
env_posix.go#L82: asmcgocall(_cgo_unsetenv, unsafe.Pointer(&arg))
env_posix.go#L85: func cstring(s string) unsafe.Pointer {
env_posix.go#L88: return unsafe.Pointer(&p[0])
float.go#L53: return *(*uint64)(unsafe.Pointer(&f))
float.go#L59: return *(*float64)(unsafe.Pointer(&b))
hash64.go#L21: func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
hash64.go#L67: func memhash32Fallback(p unsafe.Pointer, seed uintptr) uintptr {
hash64.go#L72: func memhash64Fallback(p unsafe.Pointer, seed uintptr) uintptr {
hash64.go#L82: func r4(p unsafe.Pointer) uintptr {
hash64.go#L86: func r8(p unsafe.Pointer) uintptr {
heapdump.go#L79: func dwrite(data unsafe.Pointer, len uintptr) {
heapdump.go#L89: write(dumpfd, unsafe.Pointer(&buf), int32(nbuf))
heapdump.go#L100: dwrite(unsafe.Pointer(&b), 1)
heapdump.go#L104: write(dumpfd, unsafe.Pointer(&buf), int32(nbuf))
heapdump.go#L136: dwrite(unsafe.Pointer(&buf), uintptr(n))
heapdump.go#L148: func dumpmemrange(data unsafe.Pointer, len uintptr) {
heapdump.go#L156: dwrite(unsafe.Pointer(&b[0]), uintptr(len(b)))
heapdump.go#L161: dumpmemrange(unsafe.Pointer(unsafe.StringData(s)), uintptr(len(s)))
heapdump.go#L196: dumpint(uint64(uintptr(unsafe.Pointer(t))))
heapdump.go#L205: dwrite(unsafe.Pointer(unsafe.StringData(pkgpath)), uintptr(len(pkgpath)))
heapdump.go#L207: dwrite(unsafe.Pointer(unsafe.StringData(name)), uintptr(len(name)))
heapdump.go#L213: func dumpobj(obj unsafe.Pointer, size uintptr, bv bitvector) {
heapdump.go#L220: func dumpotherroot(description string, to unsafe.Pointer) {
heapdump.go#L226: func dumpfinalizer(obj unsafe.Pointer, fn *funcval, fint *_type, ot *ptrtype) {
heapdump.go#L229: dumpint(uint64(uintptr(unsafe.Pointer(fn))))
heapdump.go#L230: dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
heapdump.go#L231: dumpint(uint64(uintptr(unsafe.Pointer(fint))))
heapdump.go#L232: dumpint(uint64(uintptr(unsafe.Pointer(ot))))
heapdump.go#L284: dumpint(uint64(uintptr(unsafe.Pointer(child.sp)))) // sp of child, or 0 if bottom of stack
heapdump.go#L285: dumpmemrange(unsafe.Pointer(s.sp), s.fp-s.sp) // frame contents
heapdump.go#L330: child.sp = (*uint8)(unsafe.Pointer(s.sp))
heapdump.go#L354: dumpint(uint64(uintptr(unsafe.Pointer(gp))))
heapdump.go#L364: dumpint(uint64(uintptr(unsafe.Pointer(gp.m))))
heapdump.go#L365: dumpint(uint64(uintptr(unsafe.Pointer(gp._defer))))
heapdump.go#L366: dumpint(uint64(uintptr(unsafe.Pointer(gp._panic))))
heapdump.go#L382: dumpint(uint64(uintptr(unsafe.Pointer(d))))
heapdump.go#L383: dumpint(uint64(uintptr(unsafe.Pointer(gp))))
heapdump.go#L386: fn := *(**funcval)(unsafe.Pointer(&d.fn))
heapdump.go#L387: dumpint(uint64(uintptr(unsafe.Pointer(fn))))
heapdump.go#L392: dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
heapdump.go#L394: dumpint(uint64(uintptr(unsafe.Pointer(d.link))))
heapdump.go#L398: dumpint(uint64(uintptr(unsafe.Pointer(p))))
heapdump.go#L399: dumpint(uint64(uintptr(unsafe.Pointer(gp))))
heapdump.go#L401: dumpint(uint64(uintptr(unsafe.Pointer(eface._type))))
heapdump.go#L404: dumpint(uint64(uintptr(unsafe.Pointer(p.link))))
heapdump.go#L436: func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype) {
heapdump.go#L439: dumpint(uint64(uintptr(unsafe.Pointer(fn))))
heapdump.go#L440: dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
heapdump.go#L441: dumpint(uint64(uintptr(unsafe.Pointer(fint))))
heapdump.go#L442: dumpint(uint64(uintptr(unsafe.Pointer(ot))))
heapdump.go#L453: dumpmemrange(unsafe.Pointer(firstmoduledata.data), firstmoduledata.edata-firstmoduledata.data)
heapdump.go#L459: dumpmemrange(unsafe.Pointer(firstmoduledata.bss), firstmoduledata.ebss-firstmoduledata.bss)
heapdump.go#L470: spf := (*specialfinalizer)(unsafe.Pointer(sp))
heapdump.go#L471: p := unsafe.Pointer(s.base() + spf.special.offset)
heapdump.go#L511: dumpobj(unsafe.Pointer(p), size, makeheapobjbv(p, size))
heapdump.go#L519: if *(*byte)(unsafe.Pointer(&x)) == 1 {
heapdump.go#L554: dumpint(uint64(uintptr(unsafe.Pointer(tab))))
heapdump.go#L555: dumpint(uint64(uintptr(unsafe.Pointer(t))))
heapdump.go#L565: dumpint(uint64(uintptr(unsafe.Pointer(mp))))
heapdump.go#L610: stk := (*[100000]uintptr)(unsafe.Pointer(pstk))
heapdump.go#L612: dumpint(uint64(uintptr(unsafe.Pointer(b))))
heapdump.go#L669: spp := (*specialprofile)(unsafe.Pointer(sp))
heapdump.go#L673: dumpint(uint64(uintptr(unsafe.Pointer(spp.b))))
heapdump.go#L689: memclrNoHeapPointers(unsafe.Pointer(&typecache), unsafe.Sizeof(typecache))
heapdump.go#L690: dwrite(unsafe.Pointer(&dumphdr[0]), uintptr(len(dumphdr)))
heapdump.go#L718: sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
heapdump.go#L736: sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
hexdump.go#L25: val := *(*uintptr)(unsafe.Pointer(u))
hexdump.go#L34: h.write(unsafe.Slice((*byte)(unsafe.Pointer(p)), len))
histogram.go#L157: return *(*float64)(unsafe.Pointer(&inf))
histogram.go#L162: return *(*float64)(unsafe.Pointer(&inf))
iface.go#L64: t := (*itabTableType)(atomic.Loadp(unsafe.Pointer(&itabTable)))
iface.go#L114: p := (**itab)(add(unsafe.Pointer(&t.entries), h*goarch.PtrSize))
iface.go#L118: m := (*itab)(atomic.Loadp(unsafe.Pointer(p)))
iface.go#L159: atomicstorep(unsafe.Pointer(&itabTable), unsafe.Pointer(t2))
iface.go#L175: p := (**itab)(add(unsafe.Pointer(&t.entries), h*goarch.PtrSize))
iface.go#L189: atomic.StorepNoWB(unsafe.Pointer(p), unsafe.Pointer(m))
iface.go#L215: xmhdr := (*[1 << 16]abi.Method)(add(unsafe.Pointer(x), uintptr(x.Moff)))[:nt:nt]
iface.go#L217: methods := (*[1 << 16]unsafe.Pointer)(unsafe.Pointer(&m.Fun[0]))[:ni:ni]
iface.go#L218: var fun0 unsafe.Pointer
iface.go#L334: func convT(t *_type, v unsafe.Pointer) unsafe.Pointer {
iface.go#L348: func convTnoptr(t *_type, v unsafe.Pointer) unsafe.Pointer {
iface.go#L365: func convT16(val uint16) (x unsafe.Pointer) {
iface.go#L367: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L378: func convT32(val uint32) (x unsafe.Pointer) {
iface.go#L380: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L400: func convT64(val uint64) (x unsafe.Pointer) {
iface.go#L402: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L419: func convTstring(val string) (x unsafe.Pointer) {
iface.go#L421: x = unsafe.Pointer(&zeroVal[0])
iface.go#L438: func convTslice(val []byte) (x unsafe.Pointer) {
iface.go#L440: if (*slice)(unsafe.Pointer(&val)).array == nil {
iface.go#L441: x = unsafe.Pointer(&zeroVal[0])
iface.go#L488: oldC := (*abi.TypeAssertCache)(atomic.Loadp(unsafe.Pointer(&s.Cache)))
iface.go#L502: atomic_casPointer((*unsafe.Pointer)(unsafe.Pointer(&s.Cache)), unsafe.Pointer(oldC), unsafe.Pointer(newC))
iface.go#L535: newEntries[h].Typ = uintptr(unsafe.Pointer(typ))
iface.go#L536: newEntries[h].Itab = uintptr(unsafe.Pointer(tab))
iface.go#L544: addEntry((*_type)(unsafe.Pointer(e.Typ)), (*itab)(unsafe.Pointer(e.Itab)))
iface.go#L590: oldC := (*abi.InterfaceSwitchCache)(atomic.Loadp(unsafe.Pointer(&s.Cache)))
iface.go#L605: atomic_casPointer((*unsafe.Pointer)(unsafe.Pointer(&s.Cache)), unsafe.Pointer(oldC), unsafe.Pointer(newC))
iface.go#L641: newEntries[h].Typ = uintptr(unsafe.Pointer(typ))
iface.go#L643: newEntries[h].Itab = uintptr(unsafe.Pointer(tab))
iface.go#L651: addEntry((*_type)(unsafe.Pointer(e.Typ)), e.Case, (*itab)(unsafe.Pointer(e.Itab)))
iface.go#L687: m := *(**itab)(add(unsafe.Pointer(&t.entries), i*goarch.PtrSize))
lfstack.go#L36: func (head *lfstack) pop() unsafe.Pointer {
lfstack.go#L50: return unsafe.Pointer(node)
lfstack.go#L72: if base, _, _ := findObject(uintptr(unsafe.Pointer(node)), 0, 0); base != 0 {
lfstack.go#L79: return uint64(taggedPointerPack(unsafe.Pointer(node), cnt&(1<<tagBits-1)))
linkname_shim.go#L62: key unsafe.Pointer
linkname_shim.go#L63: elem unsafe.Pointer
linkname_shim.go#L91: racereadpc(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(mapiterinit))
linkname_shim.go#L144: racereadpc(unsafe.Pointer(it.it.Map()), callerpc, abi.FuncPCABIInternal(mapiternext))
linkname_shim.go#L188: func reflect_mapiterkey(it *linknameIter) unsafe.Pointer {
linkname_shim.go#L206: func reflect_mapiterelem(it *linknameIter) unsafe.Pointer {
list.go#L17: obj unsafe.Pointer
list.go#L46: prev unsafe.Pointer
list.go#L47: next unsafe.Pointer
list.go#L50: func (head *listHead) getNode(p unsafe.Pointer) *listNode {
list.go#L67: func (head *listHead) head() unsafe.Pointer {
list.go#L72: func (head *listHead) push(p unsafe.Pointer) {
list.go#L89: func (head *listHead) pop() unsafe.Pointer {
list.go#L114: func (head *listHead) remove(p unsafe.Pointer) {
list_manual.go#L57: func (head *listHeadManual) getNode(p unsafe.Pointer) *listNodeManual {
list_manual.go#L74: func (head *listHeadManual) head() unsafe.Pointer {
list_manual.go#L75: return unsafe.Pointer(head.obj)
list_manual.go#L79: func (head *listHeadManual) push(p unsafe.Pointer) {
list_manual.go#L88: headNode := head.getNode(unsafe.Pointer(head.obj))
list_manual.go#L96: func (head *listHeadManual) pop() unsafe.Pointer {
list_manual.go#L102: p := unsafe.Pointer(head.obj)
list_manual.go#L113: headNode := head.getNode(unsafe.Pointer(head.obj))
list_manual.go#L121: func (head *listHeadManual) remove(p unsafe.Pointer) {
list_manual.go#L122: if unsafe.Pointer(head.obj) == p {
list_manual.go#L129: prevNode := head.getNode(unsafe.Pointer(pNode.prev))
list_manual.go#L130: nextNode := head.getNode(unsafe.Pointer(pNode.next))
lock_futex.go#L18: return (*uint32)(unsafe.Pointer(p))
lock_spinbit.go#L76: return &(*[8]uint8)(unsafe.Pointer(p))[goarch.PtrSize/1-1]
lock_spinbit.go#L78: return &(*[8]uint8)(unsafe.Pointer(p))[0]
lock_spinbit.go#L114: } else if m0bits := muintptr(unsafe.Pointer(&m0)); highBits == uintptr(m0bits)&^mutexMMask {
lock_spinbit.go#L242: next := (uintptr(unsafe.Pointer(gp.m)) &^ mutexMMask) | v&mutexMMask | mutexSleeping
malloc.go#L702: a, size := sysReserveAligned(unsafe.Pointer(p), arenaSize, heapArenaBytes, "heap reservation")
malloc.go#L741: func (h *mheap) sysAlloc(n uintptr, hintList **arenaHint, arenaList *[]arenaIdx) (v unsafe.Pointer, size uintptr) {
malloc.go#L773: v = sysReserve(unsafe.Pointer(p), n, "heap reservation")
malloc.go#L794: h.arenaHintAlloc.free(unsafe.Pointer(hint))
malloc.go#L869: sysHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
malloc.go#L871: sysNoHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
malloc.go#L873: atomic.StorepNoWB(unsafe.Pointer(&h.arenas[ri.l1()]), unsafe.Pointer(l2))
malloc.go#L899: *(*notInHeapSlice)(unsafe.Pointer(&(*arenaList))) = notInHeapSlice{newArray, len((*arenaList)), int(size / goarch.PtrSize)}
malloc.go#L913: atomic.StorepNoWB(unsafe.Pointer(&l2[ri.l2()]), unsafe.Pointer(r))
malloc.go#L956: l2 := (*[1 << arenaL2Bits]*heapArena)(atomic.Loadp(unsafe.Pointer(&h.arenas[i])))
malloc.go#L960: sysHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
malloc.go#L1067: func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc.go#L1076: return unsafe.Pointer(&zerobase)
malloc.go#L1117: var x unsafe.Pointer
malloc.go#L1202: func mallocgcTiny(size uintptr, typ *_type) (unsafe.Pointer, uintptr) {
malloc.go#L1267: x := unsafe.Pointer(c.tiny + off)
malloc.go#L1281: x := unsafe.Pointer(v)
malloc.go#L1358: func mallocgcSmallNoscan(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
malloc.go#L1399: x := unsafe.Pointer(v)
malloc.go#L1456: func mallocgcSmallNoscanReuse(c *mcache, span *mspan, spc spanClass, size uintptr, needzero bool) unsafe.Pointer {
malloc.go#L1460: x := unsafe.Pointer(v)
malloc.go#L1503: func mallocgcSmallScanNoHeader(size uintptr, typ *_type) (unsafe.Pointer, uintptr) {
malloc.go#L1531: x := unsafe.Pointer(v)
malloc.go#L1594: func mallocgcSmallScanHeader(size uintptr, typ *_type) (unsafe.Pointer, uintptr) {
malloc.go#L1629: x := unsafe.Pointer(v)
malloc.go#L1687: func mallocgcLarge(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
malloc.go#L1708: x := unsafe.Pointer(span.base())
malloc.go#L1789: func preMallocgcDebug(size uintptr, typ *_type) unsafe.Pointer {
malloc.go#L1819: func postMallocgcDebug(x unsafe.Pointer, elemsize uintptr, typ *_type) {
malloc.go#L1839: setTinyBlockContext(unsafe.Pointer(alignDown(uintptr(x), maxTinySize)))
malloc.go#L1929: func freegc(ptr unsafe.Pointer, size uintptr, noscan bool) bool {
malloc.go#L2134: func memclrNoHeapPointersChunked(size uintptr, x unsafe.Pointer) {
malloc.go#L2149: memclrNoHeapPointers(unsafe.Pointer(voff), n)
malloc.go#L2156: func newobject(typ *_type) unsafe.Pointer {
malloc.go#L2161: func maps_newobject(typ *_type) unsafe.Pointer {
malloc.go#L2177: func reflect_unsafe_New(typ *_type) unsafe.Pointer {
malloc.go#L2182: func reflectlite_unsafe_New(typ *_type) unsafe.Pointer {
malloc.go#L2199: func newarray(typ *_type, n int) unsafe.Pointer {
malloc.go#L2225: func reflect_unsafe_NewArray(typ *_type, n int) unsafe.Pointer {
malloc.go#L2230: func maps_newarray(typ *_type, n int) unsafe.Pointer {
malloc.go#L2238: func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
malloc.go#L2329: func persistentalloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer {
malloc.go#L2334: return unsafe.Pointer(p)
malloc.go#L2384: chunks := uintptr(unsafe.Pointer(persistentChunks))
malloc.go#L2385: *(*uintptr)(unsafe.Pointer(persistent.base)) = chunks
malloc.go#L2386: if atomic.Casuintptr((*uintptr)(unsafe.Pointer(&persistentChunks)), chunks, uintptr(unsafe.Pointer(persistent.base))) {
malloc.go#L2412: chunk := atomic.Loaduintptr((*uintptr)(unsafe.Pointer(&persistentChunks)))
malloc.go#L2417: chunk = *(*uintptr)(unsafe.Pointer(chunk))
malloc.go#L2448: func (l *linearAlloc) alloc(size, align uintptr, sysStat *sysMemStat, vmaName string) unsafe.Pointer {
malloc.go#L2458: sysMap(unsafe.Pointer(l.mapped), n, sysStat, vmaName)
malloc.go#L2459: sysUsed(unsafe.Pointer(l.mapped), n, n)
malloc.go#L2463: return unsafe.Pointer(p)
malloc.go#L2477: return (*notInHeap)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + bytes))
malloc_generated.go#L13: func mallocgcSmallScanNoHeaderSC1(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L68: x := unsafe.Pointer(v)
malloc_generated.go#L103: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L178: func mallocgcSmallScanNoHeaderSC2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L233: x := unsafe.Pointer(v)
malloc_generated.go#L268: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L343: func mallocgcSmallScanNoHeaderSC3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L398: x := unsafe.Pointer(v)
malloc_generated.go#L433: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L508: func mallocgcSmallScanNoHeaderSC4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L563: x := unsafe.Pointer(v)
malloc_generated.go#L598: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L673: func mallocgcSmallScanNoHeaderSC5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L728: x := unsafe.Pointer(v)
malloc_generated.go#L763: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L838: func mallocgcSmallScanNoHeaderSC6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L893: x := unsafe.Pointer(v)
malloc_generated.go#L928: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L1003: func mallocgcSmallScanNoHeaderSC7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L1058: x := unsafe.Pointer(v)
malloc_generated.go#L1093: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L1168: func mallocgcSmallScanNoHeaderSC8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L1223: x := unsafe.Pointer(v)
malloc_generated.go#L1258: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L1333: func mallocgcSmallScanNoHeaderSC9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L1388: x := unsafe.Pointer(v)
malloc_generated.go#L1423: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L1498: func mallocgcSmallScanNoHeaderSC10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L1553: x := unsafe.Pointer(v)
malloc_generated.go#L1588: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L1663: func mallocgcSmallScanNoHeaderSC11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L1718: x := unsafe.Pointer(v)
malloc_generated.go#L1753: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L1828: func mallocgcSmallScanNoHeaderSC12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L1883: x := unsafe.Pointer(v)
malloc_generated.go#L1918: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L1993: func mallocgcSmallScanNoHeaderSC13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L2048: x := unsafe.Pointer(v)
malloc_generated.go#L2083: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L2158: func mallocgcSmallScanNoHeaderSC14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L2213: x := unsafe.Pointer(v)
malloc_generated.go#L2248: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L2323: func mallocgcSmallScanNoHeaderSC15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L2378: x := unsafe.Pointer(v)
malloc_generated.go#L2413: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L2488: func mallocgcSmallScanNoHeaderSC16(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L2543: x := unsafe.Pointer(v)
malloc_generated.go#L2578: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L2653: func mallocgcSmallScanNoHeaderSC17(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L2708: x := unsafe.Pointer(v)
malloc_generated.go#L2743: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L2818: func mallocgcSmallScanNoHeaderSC18(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L2873: x := unsafe.Pointer(v)
malloc_generated.go#L2908: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L2983: func mallocgcSmallScanNoHeaderSC19(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L3038: x := unsafe.Pointer(v)
malloc_generated.go#L3073: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L3148: func mallocgcSmallScanNoHeaderSC20(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L3203: x := unsafe.Pointer(v)
malloc_generated.go#L3238: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L3313: func mallocgcSmallScanNoHeaderSC21(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L3368: x := unsafe.Pointer(v)
malloc_generated.go#L3403: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L3478: func mallocgcSmallScanNoHeaderSC22(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L3533: x := unsafe.Pointer(v)
malloc_generated.go#L3568: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L3643: func mallocgcSmallScanNoHeaderSC23(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L3698: x := unsafe.Pointer(v)
malloc_generated.go#L3733: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L3808: func mallocgcSmallScanNoHeaderSC24(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L3863: x := unsafe.Pointer(v)
malloc_generated.go#L3898: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L3973: func mallocgcSmallScanNoHeaderSC25(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L4028: x := unsafe.Pointer(v)
malloc_generated.go#L4063: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L4138: func mallocgcSmallScanNoHeaderSC26(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L4193: x := unsafe.Pointer(v)
malloc_generated.go#L4228: dst := unsafe.Pointer(dstBase)
malloc_generated.go#L4303: func mallocgcTinySize1(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L4353: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L4406: x := unsafe.Pointer(v)
malloc_generated.go#L4459: func mallocgcTinySize2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L4509: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L4562: x := unsafe.Pointer(v)
malloc_generated.go#L4615: func mallocgcTinySize3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L4665: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L4718: x := unsafe.Pointer(v)
malloc_generated.go#L4771: func mallocgcTinySize4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L4821: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L4874: x := unsafe.Pointer(v)
malloc_generated.go#L4927: func mallocgcTinySize5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L4977: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L5030: x := unsafe.Pointer(v)
malloc_generated.go#L5083: func mallocgcTinySize6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L5133: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L5186: x := unsafe.Pointer(v)
malloc_generated.go#L5239: func mallocgcTinySize7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L5289: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L5342: x := unsafe.Pointer(v)
malloc_generated.go#L5395: func mallocgcTinySize8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L5445: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L5498: x := unsafe.Pointer(v)
malloc_generated.go#L5551: func mallocgcTinySize9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L5601: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L5654: x := unsafe.Pointer(v)
malloc_generated.go#L5707: func mallocgcTinySize10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L5757: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L5810: x := unsafe.Pointer(v)
malloc_generated.go#L5863: func mallocgcTinySize11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L5913: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L5966: x := unsafe.Pointer(v)
malloc_generated.go#L6019: func mallocgcTinySize12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L6069: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L6122: x := unsafe.Pointer(v)
malloc_generated.go#L6175: func mallocgcTinySize13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L6225: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L6278: x := unsafe.Pointer(v)
malloc_generated.go#L6331: func mallocgcTinySize14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L6381: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L6434: x := unsafe.Pointer(v)
malloc_generated.go#L6487: func mallocgcTinySize15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L6537: x := unsafe.Pointer(c.tiny + off)
malloc_generated.go#L6590: x := unsafe.Pointer(v)
malloc_generated.go#L6643: func mallocgcSmallNoScanSC2(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L6730: x := unsafe.Pointer(v)
malloc_generated.go#L6779: func mallocgcSmallNoScanSC3(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L6866: x := unsafe.Pointer(v)
malloc_generated.go#L6915: func mallocgcSmallNoScanSC4(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L7002: x := unsafe.Pointer(v)
malloc_generated.go#L7051: func mallocgcSmallNoScanSC5(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L7138: x := unsafe.Pointer(v)
malloc_generated.go#L7187: func mallocgcSmallNoScanSC6(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L7274: x := unsafe.Pointer(v)
malloc_generated.go#L7323: func mallocgcSmallNoScanSC7(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L7410: x := unsafe.Pointer(v)
malloc_generated.go#L7459: func mallocgcSmallNoScanSC8(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L7546: x := unsafe.Pointer(v)
malloc_generated.go#L7595: func mallocgcSmallNoScanSC9(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L7682: x := unsafe.Pointer(v)
malloc_generated.go#L7731: func mallocgcSmallNoScanSC10(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L7818: x := unsafe.Pointer(v)
malloc_generated.go#L7867: func mallocgcSmallNoScanSC11(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L7954: x := unsafe.Pointer(v)
malloc_generated.go#L8003: func mallocgcSmallNoScanSC12(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L8090: x := unsafe.Pointer(v)
malloc_generated.go#L8139: func mallocgcSmallNoScanSC13(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L8226: x := unsafe.Pointer(v)
malloc_generated.go#L8275: func mallocgcSmallNoScanSC14(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L8362: x := unsafe.Pointer(v)
malloc_generated.go#L8411: func mallocgcSmallNoScanSC15(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L8498: x := unsafe.Pointer(v)
malloc_generated.go#L8547: func mallocgcSmallNoScanSC16(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L8634: x := unsafe.Pointer(v)
malloc_generated.go#L8683: func mallocgcSmallNoScanSC17(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L8770: x := unsafe.Pointer(v)
malloc_generated.go#L8819: func mallocgcSmallNoScanSC18(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L8906: x := unsafe.Pointer(v)
malloc_generated.go#L8955: func mallocgcSmallNoScanSC19(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L9042: x := unsafe.Pointer(v)
malloc_generated.go#L9091: func mallocgcSmallNoScanSC20(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L9178: x := unsafe.Pointer(v)
malloc_generated.go#L9227: func mallocgcSmallNoScanSC21(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L9314: x := unsafe.Pointer(v)
malloc_generated.go#L9363: func mallocgcSmallNoScanSC22(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L9450: x := unsafe.Pointer(v)
malloc_generated.go#L9499: func mallocgcSmallNoScanSC23(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L9586: x := unsafe.Pointer(v)
malloc_generated.go#L9635: func mallocgcSmallNoScanSC24(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L9722: x := unsafe.Pointer(v)
malloc_generated.go#L9771: func mallocgcSmallNoScanSC25(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L9858: x := unsafe.Pointer(v)
malloc_generated.go#L9907: func mallocgcSmallNoScanSC26(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_generated.go#L9994: x := unsafe.Pointer(v)
malloc_stubs.go#L42: func malloc0(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_stubs.go#L50: return unsafe.Pointer(&zerobase)
malloc_stubs.go#L53: func mallocPanic(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_stubs.go#L59: func mallocStub(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc_stubs.go#L135: func inlinedMalloc(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
malloc_stubs.go#L136: return unsafe.Pointer(uintptr(0)), 0
malloc_stubs.go#L154: func smallScanNoHeaderStub(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
malloc_stubs.go#L173: x := unsafe.Pointer(v)
malloc_stubs.go#L251: func smallNoScanStub(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
malloc_stubs.go#L292: x := unsafe.Pointer(v)
malloc_stubs.go#L359: func tinyStub(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
malloc_stubs.go#L419: x := unsafe.Pointer(c.tiny + off)
malloc_stubs.go#L433: x := unsafe.Pointer(v)
malloc_stubs.go#L595: dst := unsafe.Pointer(dstBase)
malloc_tables_generated.go#L8: var mallocScanTable = [513]func(size uintptr, typ *_type, needzero bool) unsafe.Pointer{
malloc_tables_generated.go#L524: var mallocNoScanTable = [513]func(size uintptr, typ *_type, needzero bool) unsafe.Pointer{
map.go#L80: func mapaccess1(t *abi.MapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
map.go#L91: func mapaccess2(t *abi.MapType, m *maps.Map, key unsafe.Pointer) (unsafe.Pointer, bool)
map.go#L93: func mapaccess1_fat(t *abi.MapType, m *maps.Map, key, zero unsafe.Pointer) unsafe.Pointer {
map.go#L95: if e == unsafe.Pointer(&zeroVal[0]) {
map.go#L101: func mapaccess2_fat(t *abi.MapType, m *maps.Map, key, zero unsafe.Pointer) (unsafe.Pointer, bool) {
map.go#L103: if e == unsafe.Pointer(&zeroVal[0]) {
map.go#L124: func mapassign(t *abi.MapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
map.go#L135: func mapdelete(t *abi.MapType, m *maps.Map, key unsafe.Pointer) {
map.go#L139: racewritepc(unsafe.Pointer(m), callerpc, pc)
map.go#L159: racereadpc(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(mapIterStart))
map.go#L171: racereadpc(unsafe.Pointer(it.Map()), callerpc, abi.FuncPCABIInternal(mapIterNext))
map.go#L182: racewritepc(unsafe.Pointer(m), callerpc, pc)
map.go#L225: func reflect_mapaccess(t *abi.MapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer {
map.go#L235: func reflect_mapaccess_faststr(t *abi.MapType, m *maps.Map, key string) unsafe.Pointer {
map.go#L253: func reflect_mapassign(t *abi.MapType, m *maps.Map, key unsafe.Pointer, elem unsafe.Pointer) {
map.go#L259: func reflect_mapassign_faststr(t *abi.MapType, m *maps.Map, key string, elem unsafe.Pointer) {
map.go#L265: func reflect_mapdelete(t *abi.MapType, m *maps.Map, key unsafe.Pointer) {
map.go#L290: racereadpc(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(reflect_maplen))
map.go#L307: racereadpc(unsafe.Pointer(m), callerpc, abi.FuncPCABIInternal(reflect_maplen))
map.go#L324: typ := (*abi.MapType)(unsafe.Pointer(e._type))
map.go#L327: e.data = (unsafe.Pointer)(map_)
map_fast32.go#L16: func mapaccess1_fast32(t *abi.MapType, m *maps.Map, key uint32) unsafe.Pointer
map_fast32.go#L27: func mapaccess2_fast32(t *abi.MapType, m *maps.Map, key uint32) (unsafe.Pointer, bool)
map_fast32.go#L39: func mapassign_fast32(t *abi.MapType, m *maps.Map, key uint32) unsafe.Pointer
map_fast32.go#L50: func mapassign_fast32ptr(t *abi.MapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
map_fast64.go#L16: func mapaccess1_fast64(t *abi.MapType, m *maps.Map, key uint64) unsafe.Pointer
map_fast64.go#L27: func mapaccess2_fast64(t *abi.MapType, m *maps.Map, key uint64) (unsafe.Pointer, bool)
map_fast64.go#L39: func mapassign_fast64(t *abi.MapType, m *maps.Map, key uint64) unsafe.Pointer
map_fast64.go#L51: func mapassign_fast64ptr(t *abi.MapType, m *maps.Map, key unsafe.Pointer) unsafe.Pointer
map_faststr.go#L16: func mapaccess1_faststr(t *abi.MapType, m *maps.Map, ky string) unsafe.Pointer
map_faststr.go#L27: func mapaccess2_faststr(t *abi.MapType, m *maps.Map, ky string) (unsafe.Pointer, bool)
map_faststr.go#L39: func mapassign_faststr(t *abi.MapType, m *maps.Map, s string) unsafe.Pointer
mbarrier.go#L150: func typedmemmove(typ *abi.Type, dst, src unsafe.Pointer) {
mbarrier.go#L179: func wbZero(typ *_type, dst unsafe.Pointer) {
mbarrier.go#L192: func wbMove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L213: func reflect_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L230: func reflectlite_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L235: func maps_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L249: func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr, regs *abi.RegArgs) {
mbarrier.go#L261: regs.Ptrs[i] = unsafe.Pointer(regs.Ints[i])
mbarrier.go#L276: func typedslicecopy(typ *_type, dstPtr unsafe.Pointer, dstLen int, srcPtr unsafe.Pointer, srcLen int) int {
mbarrier.go#L361: func typedmemclr(typ *_type, ptr unsafe.Pointer) {
mbarrier.go#L380: func reflect_typedmemclr(typ *_type, ptr unsafe.Pointer) {
mbarrier.go#L385: func maps_typedmemclr(typ *_type, ptr unsafe.Pointer) {
mbarrier.go#L390: func reflect_typedmemclrpartial(typ *_type, ptr unsafe.Pointer, off, size uintptr) {
mbarrier.go#L402: func reflect_typedarrayclear(typ *_type, ptr unsafe.Pointer, len int) {
mbarrier.go#L427: func memclrHasPointers(ptr unsafe.Pointer, n uintptr) {
mbitmap.go#L155: typ = *(**_type)(unsafe.Pointer(addr))
mbitmap.go#L160: typ = (*_type)(atomic.Loadp(unsafe.Pointer(&span.largeType)))
mbitmap.go#L441: dstx := (*uintptr)(unsafe.Pointer(addr))
mbitmap.go#L451: dstx := (*uintptr)(unsafe.Pointer(addr))
mbitmap.go#L452: srcx := (*uintptr)(unsafe.Pointer(src + (addr - dst)))
mbitmap.go#L501: srcx := (*uintptr)(unsafe.Pointer(addr - dst + src))
mbitmap.go#L565: sl = notInHeapSlice{(*notInHeap)(unsafe.Pointer(base)), elems, elems}
mbitmap.go#L566: return *(*[]uintptr)(unsafe.Pointer(&sl))
mbitmap.go#L587: hbits := (*byte)(unsafe.Pointer(hbitsBase))
mbitmap.go#L600: word0 := (*uintptr)(unsafe.Pointer(addb(hbits, goarch.PtrSize*(i+0))))
mbitmap.go#L601: word1 := (*uintptr)(unsafe.Pointer(addb(hbits, goarch.PtrSize*(i+1))))
mbitmap.go#L654: dst := unsafe.Pointer(dstBase)
mbitmap.go#L795: atomic.StorepNoWB(unsafe.Pointer(&span.largeType), unsafe.Pointer(gctyp))
mbitmap.go#L871: print("runtime: typ=", unsafe.Pointer(typ), " typ.PtrBytes=", typ.PtrBytes, "\n")
mbitmap.go#L1012: print("runtime: tp.elem=", hex(tp.elem), " tp.typ=", unsafe.Pointer(tp.typ), "\n")
mbitmap.go#L1032: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + n))
mbitmap.go#L1043: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) - n))
mbitmap.go#L1054: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + 1))
mbitmap.go#L1067: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) - 1))
mbitmap.go#L1096: bytes := (*[8]uint8)(unsafe.Pointer(s.allocBits.bytep(uintptr(whichByte))))
mbitmap.go#L1273: func isMarkedOrNotInHeap(p unsafe.Pointer) bool {
mbitmap.go#L1295: m.bytep = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(m.bytep)) + 1))
mbitmap.go#L1433: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L1438: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L1484: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L1485: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L1507: mrkBits := *(*uint64)(unsafe.Pointer(s.gcmarkBits.bytep(i)))
mbitmap.go#L1516: x := *(*uintptr)(unsafe.Pointer(p))
mbitmap.go#L1747: totalBits := (uintptr(unsafe.Pointer(dst))-uintptr(unsafe.Pointer(dstStart)))*8 + nbits
mbitmap.go#L1824: et = (*ptrtype)(unsafe.Pointer(t)).Elem
mbitmap.go#L1880: if *(*byte)(unsafe.Pointer(i)) != 0 {
mbitmap.go#L1961: n := (*ptrtype)(unsafe.Pointer(t)).Elem.Size_
mcache.go#L86: return (*gclink)(unsafe.Pointer(p))
mcache.go#L130: mheap_.cachealloc.free(unsafe.Pointer(c))
mcheckmark.go#L186: gcScanFinalizer((*specialfinalizer)(unsafe.Pointer(sp)), s, gcw)
mcheckmark.go#L188: gcScanCleanup((*specialCleanup)(unsafe.Pointer(sp)), gcw)
mcheckmark.go#L233: ctx = getCleanupContext(r.ptr, ((*specialCleanup)(unsafe.Pointer(r.sp))).id)
mcheckmark.go#L263: println("Has", kind, "at", hex(uintptr(unsafe.Pointer(r.sp))))
mcleanup.go#L90: usptr := uintptr(unsafe.Pointer(ptr))
mcleanup.go#L96: if unsafe.Pointer(ptr) == *((*unsafe.Pointer)(unsafe.Pointer(&arg))) {
mcleanup.go#L123: argv = (*S)(unsafe.Pointer(box))
mcleanup.go#L132: if isGoPointerWithoutSpan(unsafe.Pointer(ptr)) {
mcleanup.go#L141: argPtr := uintptr(*(*unsafe.Pointer)(unsafe.Pointer(&arg)))
mcleanup.go#L156: cleanupFV := unsafe.Pointer(*(**funcval)(unsafe.Pointer(&cleanup)))
mcleanup.go#L165: ptr := *(*uintptr)(unsafe.Pointer(addr))
mcleanup.go#L177: id := addCleanup(unsafe.Pointer(ptr), cleanupFn{
mcleanup.go#L184: fn: *(**funcval)(unsafe.Pointer(&cleanup)),
mcleanup.go#L185: arg: unsafe.Pointer(argv),
mcleanup.go#L188: cleanupFn := *(**funcval)(unsafe.Pointer(&cleanup))
mcleanup.go#L189: setCleanupContext(unsafe.Pointer(ptr), abi.TypeFor[T](), sys.GetCallerPC(), cleanupFn.fn, id)
mcleanup.go#L202: func callCleanup[T any](fn *funcval, arg unsafe.Pointer) {
mcleanup.go#L203: cleanup := *(*func(T))(unsafe.Pointer(&fn))
mcleanup.go#L250: (*specialCleanup)(unsafe.Pointer(s)).id == c.id {
mcleanup.go#L275: mheap_.specialCleanupAlloc.free(unsafe.Pointer(found))
mcleanup.go#L300: call func(*funcval, unsafe.Pointer)
mcleanup.go#L302: arg unsafe.Pointer // pointer to argument to pass to cleanup function.
mcleanup.go#L475: if q.all.CompareAndSwap(unsafe.Pointer(next), unsafe.Pointer(b)) {
mcleanup.go#L739: racerelease(unsafe.Pointer(c.arg))
mcleanup.go#L741: raceacquire(unsafe.Pointer(c.arg))
mcleanup.go#L816: racefree(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
mcleanup.go#L818: racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
mcleanup.go#L833: racefree(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
mcleanup.go#L835: racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
mem.go#L49: func sysAlloc(n uintptr, sysStat *sysMemStat, vmaName string) unsafe.Pointer {
mem.go#L68: func sysUnused(v unsafe.Pointer, n uintptr) {
mem.go#L89: func sysUsed(v unsafe.Pointer, n, prepared uintptr) {
mem.go#L97: func sysHugePage(v unsafe.Pointer, n uintptr) {
mem.go#L104: func sysNoHugePage(v unsafe.Pointer, n uintptr) {
mem.go#L110: func sysHugePageCollapse(v unsafe.Pointer, n uintptr) {
mem.go#L131: func sysFree(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) {
mem.go#L156: func sysFault(v unsafe.Pointer, n uintptr) {
mem.go#L172: func sysReserve(v unsafe.Pointer, n uintptr, vmaName string) unsafe.Pointer {
mem.go#L189: func sysReserveAligned(v unsafe.Pointer, size, align uintptr, vmaName string) (unsafe.Pointer, uintptr) {
mem.go#L206: return unsafe.Pointer(p), size + align
mem.go#L212: sysUnreserve(unsafe.Pointer(p), size+align)
mem.go#L214: p2 := sysReserve(unsafe.Pointer(p), size, vmaName)
mem.go#L238: lsanunregisterrootregion(unsafe.Pointer(p), size+align)
mem.go#L239: lsanregisterrootregion(unsafe.Pointer(pAligned), size)
mem.go#L241: sysFreeOS(unsafe.Pointer(p), pAligned-p)
mem.go#L243: sysFreeOS(unsafe.Pointer(end), endLen)
mem.go#L245: return unsafe.Pointer(pAligned), size
mem.go#L259: func sysUnreserve(v unsafe.Pointer, n uintptr) {
mem.go#L277: func sysMap(v unsafe.Pointer, n uintptr, sysStat *sysMemStat, vmaName string) {
mem_linux.go#L21: func sysAllocOS(n uintptr, vmaName string) unsafe.Pointer {
mem_linux.go#L42: func sysUnusedOS(v unsafe.Pointer, n uintptr) {
mem_linux.go#L89: func sysUsedOS(v unsafe.Pointer, n uintptr) {
mem_linux.go#L103: func sysHugePageOS(v unsafe.Pointer, n uintptr) {
mem_linux.go#L111: madvise(unsafe.Pointer(beg), end-beg, _MADV_HUGEPAGE)
mem_linux.go#L116: func sysNoHugePageOS(v unsafe.Pointer, n uintptr) {
mem_linux.go#L125: func sysHugePageCollapseOS(v unsafe.Pointer, n uintptr) {
mem_linux.go#L154: func sysFreeOS(v unsafe.Pointer, n uintptr) {
mem_linux.go#L158: func sysFaultOS(v unsafe.Pointer, n uintptr) {
mem_linux.go#L163: func sysReserveOS(v unsafe.Pointer, n uintptr, vmaName string) unsafe.Pointer {
mem_linux.go#L172: func sysMapOS(v unsafe.Pointer, n uintptr, vmaName string) {
mem_nonsbrk.go#L13: func sysReserveAlignedSbrk(size, align uintptr) (unsafe.Pointer, uintptr) {
metrics.go#L48: raceacquire(unsafe.Pointer(&metricsSema))
metrics.go#L54: racerelease(unsafe.Pointer(&metricsSema))
metrics.go#L948: pointer unsafe.Pointer // contains non-scalar values.
metrics.go#L961: v.pointer = unsafe.Pointer(hist)
metrics.go#L1013: func readMetrics(samplesp unsafe.Pointer, len int, cap int) {
metrics.go#L1028: func readMetricsLocked(samplesp unsafe.Pointer, len int, cap int) {
metrics.go#L1031: samples := *(*[]metricSample)(unsafe.Pointer(&sl))
mfinal.go#L61: arg unsafe.Pointer // ptr to object (may be a heap pointer)
mfinal.go#L101: func queuefinalizer(p unsafe.Pointer, fn *funcval, nret uintptr, fint *_type, ot *ptrtype) {
mfinal.go#L153: func iterate_finq(callback func(*funcval, unsafe.Pointer, uintptr, *_type, *ptrtype)) {
mfinal.go#L176: func finalizercommit(gp *g, lock unsafe.Pointer) bool {
mfinal.go#L195: frame unsafe.Pointer
mfinal.go#L210: gopark(finalizercommit, unsafe.Pointer(&finlock), waitReasonFinalizerWait, traceBlockSystemGoroutine, 1)
mfinal.go#L246: r = unsafe.Pointer(®s.Ints)
mfinal.go#L257: *(*unsafe.Pointer)(r) = f.arg
mfinal.go#L259: ityp := (*interfacetype)(unsafe.Pointer(f.fint))
mfinal.go#L272: reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), uint32(framesz), ®s)
mfinal.go#L295: func isGoPointerWithoutSpan(p unsafe.Pointer) bool {
mfinal.go#L297: if p == unsafe.Pointer(&zerobase) {
mfinal.go#L441: ot := (*ptrtype)(unsafe.Pointer(etyp))
mfinal.go#L496: ft := (*functype)(unsafe.Pointer(ftyp))
mfinal.go#L509: if (fint.Uncommon() == nil || etyp.Uncommon() == nil) && (*ptrtype)(unsafe.Pointer(fint)).Elem == ot.Elem {
mfinal.go#L515: ityp := (*interfacetype)(unsafe.Pointer(fint))
mfixalloc.go#L33: first func(arg, p unsafe.Pointer) // called first time p is returned
mfixalloc.go#L34: arg unsafe.Pointer
mfixalloc.go#L56: func (f *fixalloc) init(size uintptr, first func(arg, p unsafe.Pointer), arg unsafe.Pointer, stat *sysMemStat) {
mfixalloc.go#L74: func (f *fixalloc) alloc() unsafe.Pointer {
mfixalloc.go#L81: v := unsafe.Pointer(f.list)
mfixalloc.go#L94: v := unsafe.Pointer(f.chunk)
mfixalloc.go#L104: func (f *fixalloc) free(p unsafe.Pointer) {
mgc.go#L1200: if isMarkedOrNotInHeap(unsafe.Pointer(sg.c.get())) {
mgc.go#L1791: gopark(func(g *g, nodep unsafe.Pointer) bool {
mgc.go#L1818: }, unsafe.Pointer(node), waitReasonGCWorkerIdle, traceBlockSystemGoroutine, 0)
mgc.go#L2138: var boringCaches []unsafe.Pointer // for crypto/internal/boring
mgc.go#L2155: func boring_registerCache(p unsafe.Pointer) {
mgc.go#L2253: func gcTestIsReachable(ptrs ...unsafe.Pointer) (mask uint64) {
mgc.go#L2299: mheap_.specialReachableAlloc.free(unsafe.Pointer(s))
mgc.go#L2314: func gcTestPointerClass(p unsafe.Pointer) string {
mgcmark.go#L241: scanblock(uintptr(unsafe.Pointer(&fb.fin[0])), cnt*unsafe.Sizeof(fb.fin[0]), &finptrmask[0], gcw, nil)
mgcmark.go#L254: scanblock(uintptr(unsafe.Pointer(&cb.cleanups[0])), n*unsafe.Sizeof(cleanupFn{}), &cleanupBlockPtrMask[0], gcw, nil)
mgcmark.go#L344: ptrmask := (*uint8)(add(unsafe.Pointer(ptrmask0), uintptr(shard)*(rootBlockBytes/(8*goarch.PtrSize))))
mgcmark.go#L457: gcScanFinalizer((*specialfinalizer)(unsafe.Pointer(sp)), s, gcw)
mgcmark.go#L460: spw := (*specialWeakHandle)(unsafe.Pointer(sp))
mgcmark.go#L461: scanblock(uintptr(unsafe.Pointer(&spw.handle)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
mgcmark.go#L463: gcScanCleanup((*specialCleanup)(unsafe.Pointer(sp)), gcw)
mgcmark.go#L486: scanblock(uintptr(unsafe.Pointer(&spf.fn)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
mgcmark.go#L492: scanblock(uintptr(unsafe.Pointer(&spc.cleanup)), unsafe.Sizeof(cleanupFn{}), &cleanupFnPtrMask[0], gcw, nil)
mgcmark.go#L765: gp.param = unsafe.Pointer(gp)
mgcmark.go#L967: scanblock(uintptr(unsafe.Pointer(&gp.sched.ctxt)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L984: scanblock(uintptr(unsafe.Pointer(&d.fn)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L989: scanblock(uintptr(unsafe.Pointer(&d.link)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L995: scanblock(uintptr(unsafe.Pointer(&d)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L1000: state.putPtr(uintptr(unsafe.Pointer(gp._panic)), false)
mgcmark.go#L1058: putempty((*workbuf)(unsafe.Pointer(x)))
mgcmark.go#L1496: p := *(*uintptr)(unsafe.Pointer(b + i))
mgcmark.go#L1536: val := *(*uintptr)(unsafe.Pointer(p))
mgcmark.go#L1579: val := *(*uintptr)(unsafe.Pointer(b + i))
mgcmark.go#L1730: print(" *(", label, "+", i, ") = ", hex(*(*uintptr)(unsafe.Pointer(obj + i))))
mgcmark_greenteagc.go#L92: return spanScanOwnership(atomic.Load8((*uint8)(unsafe.Pointer(o))))
mgcmark_greenteagc.go#L105: o32 := (*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(o)) &^ 0b11))
mgcmark_greenteagc.go#L106: off := (uintptr(unsafe.Pointer(o)) & 0b11) * 8
mgcmark_greenteagc.go#L139: memclrNoHeapPointers(unsafe.Pointer(imb), unsafe.Sizeof(spanInlineMarkBits{}))
mgcmark_greenteagc.go#L174: return spanScanOwnership(atomic.Xchg8((*uint8)(unsafe.Pointer(&imb.owned)), uint8(spanScanUnowned)))
mgcmark_greenteagc.go#L181: return (*spanInlineMarkBits)(unsafe.Pointer(base + gc.PageSize - unsafe.Sizeof(spanInlineMarkBits{})))
mgcmark_greenteagc.go#L202: imbMarks := (*gc.ObjMask)(unsafe.Pointer(&imb.marks))
mgcmark_greenteagc.go#L208: *(*uintptr)(unsafe.Pointer(dst.bytep(i))) |= bswapIfBigEndian(marks)
mgcmark_greenteagc.go#L469: q.chain.tail.StoreNoWB(unsafe.Pointer(r))
mgcmark_greenteagc.go#L504: q.chain.head.prev.StoreNoWB(unsafe.Pointer(newHead))
mgcmark_greenteagc.go#L572: if q2.chain.tail.CompareAndSwapNoWB(unsafe.Pointer(r), unsafe.Pointer(r2)) {
mgcmark_greenteagc.go#L640: work.spanSPMCs.list.remove(unsafe.Pointer(r))
mgcmark_greenteagc.go#L642: mheap_.spanSPMCAlloc.free(unsafe.Pointer(r))
mgcmark_greenteagc.go#L711: work.spanSPMCs.list.push(unsafe.Pointer(r))
mgcmark_greenteagc.go#L725: atomic.StorepNoWB(unsafe.Pointer(&r.ring), ring)
mgcmark_greenteagc.go#L740: sysFree(unsafe.Pointer(r.ring), uintptr(r.cap)*unsafe.Sizeof(objptr(0)), &memstats.gcMiscSys)
mgcmark_greenteagc.go#L753: return (*objptr)(unsafe.Add(unsafe.Pointer(r.ring), idx*unsafe.Sizeof(objptr(0))))
mgcmark_greenteagc.go#L782: next := (*spanSPMC)(unsafe.Pointer(r.allnode.next))
mgcmark_greenteagc.go#L785: work.spanSPMCs.list.remove(unsafe.Pointer(r))
mgcmark_greenteagc.go#L787: mheap_.spanSPMCAlloc.free(unsafe.Pointer(r))
mgcmark_greenteagc.go#L907: unsafe.Pointer(spanBase),
mgcmark_greenteagc.go#L948: imbMarks := (*gc.ObjMask)(unsafe.Pointer(&imb.marks))
mgcmark_greenteagc.go#L949: imbScans := (*gc.ObjMask)(unsafe.Pointer(&imb.scans))
mgcmark_greenteagc.go#L970: atomic.Or32((*uint32)(unsafe.Pointer(&imbScans[i/goarch.PtrSize])), uint32(toGrey))
mgcmark_greenteagc.go#L972: atomic.Or64((*uint64)(unsafe.Pointer(&imbScans[i/goarch.PtrSize])), uint64(toGrey))
mgcmark_greenteagc.go#L982: hbits := (*byte)(unsafe.Pointer(hbitsBase))
mgcmark_greenteagc.go#L1003: p = *(*uintptr)(unsafe.Pointer(p))
mgcmark_greenteagc.go#L1023: hbits := (*byte)(unsafe.Pointer(hbitsBase))
mgcmark_greenteagc.go#L1051: p = *(*uintptr)(unsafe.Pointer(p))
mgcmark_greenteagc.go#L1075: word0 := (*uintptr)(unsafe.Pointer(addb(hbits, goarch.PtrSize*(i+0))))
mgcmark_greenteagc.go#L1076: word1 := (*uintptr)(unsafe.Pointer(addb(hbits, goarch.PtrSize*(i+1))))
mgcmark_greenteagc.go#L1100: return (*gc.PtrMask)(unsafe.Pointer(base))
mgcmark_greenteagc.go#L1254: obj := *(*uintptr)(unsafe.Pointer(addr))
mgcscavenge.go#L778: sysUnused(unsafe.Pointer(addr), uintptr(npages)*pageSize)
mgcstack.go#L163: *(*uintptr)(unsafe.Pointer(&obj.r)) = uintptr(unsafe.Pointer(r))
mgcstack.go#L213: buf = (*stackWorkBuf)(unsafe.Pointer(getempty()))
mgcstack.go#L222: buf = (*stackWorkBuf)(unsafe.Pointer(getempty()))
mgcstack.go#L247: putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
mgcstack.go#L263: putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
mgcstack.go#L274: x = (*stackObjectBuf)(unsafe.Pointer(getempty()))
mgcstack.go#L284: y := (*stackObjectBuf)(unsafe.Pointer(getempty()))
mgcsweep.go#L584: freeSpecial(special, unsafe.Pointer(p), size)
mgcsweep.go#L599: freeSpecial(special, unsafe.Pointer(p), size)
mgcsweep.go#L606: (*specialReachable)(unsafe.Pointer(special)).reachable = true
mgcsweep.go#L607: freeSpecial(special, unsafe.Pointer(p), size)
mgcsweep.go#L633: clobberfree(unsafe.Pointer(x), size)
mgcsweep.go#L637: racefree(unsafe.Pointer(x), size)
mgcsweep.go#L640: msanfree(unsafe.Pointer(x), size)
mgcsweep.go#L643: asanpoison(unsafe.Pointer(x), size)
mgcsweep.go#L646: valgrindFree(unsafe.Pointer(x))
mgcsweep.go#L832: sysFault(unsafe.Pointer(s.base()), size)
mgcsweep.go#L970: func clobberfree(x unsafe.Pointer, size uintptr) {
mgcwork.go#L463: newb := (*workbuf)(unsafe.Pointer(s.base() + i))
mgcwork.go#L515: memmove(unsafe.Pointer(&b1.obj[0]), unsafe.Pointer(&b.obj[b.nobj]), uintptr(n)*unsafe.Sizeof(b1.obj[0]))
mheap.go#L544: func recordspan(vh unsafe.Pointer, p unsafe.Pointer) {
mheap.go#L556: sp := (*slice)(unsafe.Pointer(&new))
mheap.go#L567: *(*notInHeapSlice)(unsafe.Pointer(&h.allspans)) = *(*notInHeapSlice)(unsafe.Pointer(&new))
mheap.go#L569: sysFree(unsafe.Pointer(&oldAllspans[0]), uintptr(cap(oldAllspans))*unsafe.Sizeof(oldAllspans[0]), &memstats.other_sys)
mheap.go#L791: h.spanalloc.init(unsafe.Sizeof(mspan{}), recordspan, unsafe.Pointer(h), &memstats.mspan_sys)
mheap.go#L1204: h.spanalloc.free(unsafe.Pointer(s))
mheap.go#L1396: valgrindMempoolMalloc(unsafe.Pointer(arenaBase(arenaIndex(base))), unsafe.Pointer(base), npages*pageSize)
mheap.go#L1404: sysUsed(unsafe.Pointer(base), nbytes, scav)
mheap.go#L1593: sysMap(unsafe.Pointer(h.curArena.base), size, &gcController.heapReleased, "heap")
mheap.go#L1634: sysMap(unsafe.Pointer(v), nBase-v, &gcController.heapReleased, "heap")
mheap.go#L1680: base := unsafe.Pointer(s.base())
mheap.go#L1686: base := unsafe.Pointer(s.base())
mheap.go#L1692: valgrindMempoolFree(unsafe.Pointer(arenaBase(arenaIndex(base))), unsafe.Pointer(base))
mheap.go#L1724: valgrindMempoolFree(unsafe.Pointer(arenaBase(arenaIndex(base))), unsafe.Pointer(base))
mheap.go#L2003: func addspecial(p unsafe.Pointer, s *special, force bool) bool {
mheap.go#L2041: func removespecial(p unsafe.Pointer, kind uint8) *special {
mheap.go#L2110: func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool {
mheap.go#L2135: scanblock(uintptr(unsafe.Pointer(&s.fn)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
mheap.go#L2143: mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
mheap.go#L2149: func removefinalizer(p unsafe.Pointer) {
mheap.go#L2150: s := (*specialfinalizer)(unsafe.Pointer(removespecial(p, _KindSpecialFinalizer)))
mheap.go#L2155: mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
mheap.go#L2172: func addCleanup(p unsafe.Pointer, c cleanupFn) uint64 {
mheap.go#L2218: func setFinalizerContext(ptr unsafe.Pointer, ptrType *_type, createPC, funcPC uintptr) {
mheap.go#L2225: func setCleanupContext(ptr unsafe.Pointer, ptrType *_type, createPC, funcPC uintptr, cleanupID uint64) {
mheap.go#L2259: (*specialCheckFinalizer)(unsafe.Pointer(s)).cleanupID == cleanupID {
mheap.go#L2262: found = (*specialCheckFinalizer)(unsafe.Pointer(s))
mheap.go#L2309: (*specialCheckFinalizer)(unsafe.Pointer(s)).cleanupID == cleanupID {
mheap.go#L2334: mheap_.specialCheckFinalizerAlloc.free(unsafe.Pointer(found))
mheap.go#L2350: func setTinyBlockContext(ptr unsafe.Pointer) {
mheap.go#L2410: func internal_weak_runtime_registerWeakPointer(p unsafe.Pointer) unsafe.Pointer {
mheap.go#L2411: return unsafe.Pointer(getOrAddWeakHandle(p))
mheap.go#L2415: func internal_weak_runtime_makeStrongFromWeak(u unsafe.Pointer) unsafe.Pointer {
mheap.go#L2445: if isGoPointerWithoutSpan(unsafe.Pointer(p)) {
mheap.go#L2447: return unsafe.Pointer(p)
mheap.go#L2460: ptr := unsafe.Pointer(handle.Load())
mheap.go#L2516: func getOrAddWeakHandle(p unsafe.Pointer) *atomic.Uintptr {
mheap.go#L2561: scanblock(uintptr(unsafe.Pointer(&s.handle)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
mheap.go#L2584: mheap_.specialWeakHandleAlloc.free(unsafe.Pointer(s))
mheap.go#L2601: func getWeakHandle(p unsafe.Pointer) *atomic.Uintptr {
mheap.go#L2624: handle = ((*specialWeakHandle)(unsafe.Pointer(*iter))).handle
mheap.go#L2661: return (*atomic.Uintptr)(unsafe.Pointer(&h.ptr))
mheap.go#L2669: hash := memhash(abi.NoEscape(unsafe.Pointer(&p)), 0, goarch.PtrSize)
mheap.go#L2693: if m.CompareAndSwapNoWB(nil, unsafe.Pointer(newNode)) {
mheap.go#L2717: func setprofilebucket(p unsafe.Pointer, b *bucket) {
mheap.go#L2786: func freeSpecial(s *special, p unsafe.Pointer, size uintptr) {
mheap.go#L2789: sf := (*specialfinalizer)(unsafe.Pointer(s))
mheap.go#L2792: mheap_.specialfinalizeralloc.free(unsafe.Pointer(sf))
mheap.go#L2795: sw := (*specialWeakHandle)(unsafe.Pointer(s))
mheap.go#L2798: mheap_.specialWeakHandleAlloc.free(unsafe.Pointer(s))
mheap.go#L2801: sp := (*specialprofile)(unsafe.Pointer(s))
mheap.go#L2804: mheap_.specialprofilealloc.free(unsafe.Pointer(sp))
mheap.go#L2807: sp := (*specialReachable)(unsafe.Pointer(s))
mheap.go#L2812: mheap_.specialPinCounterAlloc.free(unsafe.Pointer(s))
mheap.go#L2815: sc := (*specialCleanup)(unsafe.Pointer(s))
mheap.go#L2821: mheap_.specialCleanupAlloc.free(unsafe.Pointer(sc))
mheap.go#L2824: sc := (*specialCheckFinalizer)(unsafe.Pointer(s))
mheap.go#L2826: mheap_.specialCheckFinalizerAlloc.free(unsafe.Pointer(sc))
mheap.go#L2829: st := (*specialTinyBlock)(unsafe.Pointer(s))
mheap.go#L2831: mheap_.specialTinyBlockAlloc.free(unsafe.Pointer(st))
mheap.go#L2834: st := (*specialBubble)(unsafe.Pointer(s))
mheap.go#L2836: mheap_.specialBubbleAlloc.free(unsafe.Pointer(st))
mheap.go#L2839: ss := (*specialSecret)(unsafe.Pointer(s))
mheap.go#L2853: mheap_.specialSecretAlloc.free(unsafe.Pointer(s))
mheap.go#L2925: head := (*gcBitsArena)(atomic.Loadp(unsafe.Pointer(&gcBitsArenas.next)))
mheap.go#L2964: atomic.StorepNoWB(unsafe.Pointer(&gcBitsArenas.next), unsafe.Pointer(fresh))
mheap.go#L3010: atomic.StorepNoWB(unsafe.Pointer(&gcBitsArenas.next), nil) // newMarkBits calls newArena when needed
mheap.go#L3028: memclrNoHeapPointers(unsafe.Pointer(result), gcBitsChunkBytes)
mheap.go#L3036: result.free = 8 - (uintptr(unsafe.Pointer(&result.bits[0])) & 7)
minmax.go#L57: *(*uint32)(unsafe.Pointer(&x)) |= *(*uint32)(unsafe.Pointer(&y))
minmax.go#L59: *(*uint64)(unsafe.Pointer(&x)) |= *(*uint64)(unsafe.Pointer(&y))
minmax.go#L67: *(*uint32)(unsafe.Pointer(&x)) &= *(*uint32)(unsafe.Pointer(&y))
minmax.go#L69: *(*uint64)(unsafe.Pointer(&x)) &= *(*uint64)(unsafe.Pointer(&y))
mpagealloc.go#L427: *(*uintptr)(unsafe.Pointer(&p.chunks[c.l1()])) = uintptr(r)
mpagealloc.go#L479: sysHugePage(unsafe.Pointer(p.chunks[i]), unsafe.Sizeof(*p.chunks[0]))
mpagealloc_64bit.go#L86: p.summary[l] = *(*[]pallocSum)(unsafe.Pointer(&sl))
mpagealloc_64bit.go#L120: base := unsafe.Pointer(&p.summary[level][0])
mpagealloc_64bit.go#L179: sysMap(unsafe.Pointer(need.base.addr()), need.size(), p.sysStat, "page alloc")
mpagealloc_64bit.go#L180: sysUsed(unsafe.Pointer(need.base.addr()), need.size(), need.size())
mpagealloc_64bit.go#L219: chunksBase := uintptr(unsafe.Pointer(&s.chunks[0]))
mpagealloc_64bit.go#L229: sysMap(unsafe.Pointer(need.base.addr()), need.size(), sysStat, "scavenge index")
mpagealloc_64bit.go#L230: sysUsed(unsafe.Pointer(need.base.addr()), need.size(), need.size())
mpagealloc_64bit.go#L250: s.chunks = *(*[]atomicScavChunkData)(unsafe.Pointer(&sl))
mprof.go#L248: stk := (*[maxProfStackDepth]uintptr)(add(unsafe.Pointer(b), unsafe.Sizeof(*b)))
mprof.go#L261: data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
mprof.go#L270: data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
mprof.go#L286: buckhash.StoreNoWB(unsafe.Pointer(bh))
mprof.go#L345: bh[i].StoreNoWB(unsafe.Pointer(b))
mprof.go#L346: allnext.StoreNoWB(unsafe.Pointer(b))
mprof.go#L437: func mProf_Malloc(mp *m, p unsafe.Pointer, size uintptr) {
mprof.go#L563: nstk = fpTracebackPartialExpand(skip, unsafe.Pointer(getfp()), mp.profStack)
mprof.go#L566: nstk = 1 + fpTracebackPartialExpand(skip, unsafe.Pointer(gp.m.curg.sched.bp), mp.profStack[1:])
mprof.go#L578: func fpTracebackPartialExpand(skip int, fp unsafe.Pointer, pcBuf []uintptr) int {
mprof.go#L592: pc := *(*uintptr)(unsafe.Pointer(uintptr(fp) + goarch.PtrSize))
mprof.go#L615: fp = unsafe.Pointer(*(*uintptr)(fp))
mprof.go#L1019: racewriterangepc(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0), sys.GetCallerPC(), abi.FuncPCABIInternal(MemProfile))
mprof.go#L1022: msanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
mprof.go#L1025: asanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
mprof.go#L1133: racewriterangepc(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0), sys.GetCallerPC(), abi.FuncPCABIInternal(BlockProfile))
mprof.go#L1136: msanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
mprof.go#L1139: asanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
mprof.go#L1226: first := (*m)(atomic.Loadp(unsafe.Pointer(&allm)))
mprof.go#L1249: func pprof_goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L1254: func goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L1263: func pprof_goroutineLeakProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L1268: func goroutineLeakProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L1281: labels []unsafe.Pointer
mprof.go#L1319: func goroutineLeakProfileWithLabelsConcurrent(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L1350: raceacquire(unsafe.Pointer(&labelSync))
mprof.go#L1356: func goroutineProfileWithLabelsConcurrent(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L1444: raceacquire(unsafe.Pointer(&labelSync))
mprof.go#L1573: func goroutineProfileWithLabelsSync(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L1645: raceacquire(unsafe.Pointer(&labelSync))
mranges.go#L255: ranges := (*notInHeapSlice)(unsafe.Pointer(&a.ranges))
mranges.go#L382: ranges := (*notInHeapSlice)(unsafe.Pointer(&a.ranges))
mranges.go#L452: ranges := (*notInHeapSlice)(unsafe.Pointer(&b.ranges))
msan0.go#L19: func msanread(addr unsafe.Pointer, sz uintptr) { throw("msan") }
msan0.go#L20: func msanwrite(addr unsafe.Pointer, sz uintptr) { throw("msan") }
msan0.go#L21: func msanmalloc(addr unsafe.Pointer, sz uintptr) { throw("msan") }
msan0.go#L22: func msanfree(addr unsafe.Pointer, sz uintptr) { throw("msan") }
msan0.go#L23: func msanmove(dst, src unsafe.Pointer, sz uintptr) { throw("msan") }
mspanset.go#L316: p unsafe.Pointer
mspanset.go#L425: p.p.StoreNoWB(unsafe.Pointer(s))
mwbbuf.go#L79: start := uintptr(unsafe.Pointer(&b.buf[0]))
mwbbuf.go#L85: b.end = uintptr(unsafe.Pointer(&b.buf[wbMaxEntriesPerCall+1]))
mwbbuf.go#L101: b.next = uintptr(unsafe.Pointer(&b.buf[0]))
mwbbuf.go#L106: return b.next == uintptr(unsafe.Pointer(&b.buf[0]))
mwbbuf.go#L135: p := (*[1]uintptr)(unsafe.Pointer(b.next))
mwbbuf.go#L146: p := (*[2]uintptr)(unsafe.Pointer(b.next))
mwbbuf.go#L197: start := uintptr(unsafe.Pointer(&pp.wbBuf.buf[0]))
netpoll.go#L529: func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
netpoll.go#L530: r := atomic.Casuintptr((*uintptr)(gpp), pdWait, uintptr(unsafe.Pointer(gp)))
netpoll.go#L575: gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceBlockNet, 5)
netpoll.go#L617: return (*g)(unsafe.Pointer(old))
netpoll.go#L724: x := (*eface)(unsafe.Pointer(&i))
netpoll.go#L726: x.data = unsafe.Pointer(&pd.self)
netpoll_epoll.go#L36: *(**uintptr)(unsafe.Pointer(&ev.Data)) = &netpollEventFd
netpoll_epoll.go#L52: tp := taggedPointerPack(unsafe.Pointer(pd), pd.fdseq.Load())
netpoll_epoll.go#L53: *(*taggedPointer)(unsafe.Pointer(&ev.Data)) = tp
netpoll_epoll.go#L76: n := write(netpollEventFd, noescape(unsafe.Pointer(&one)), oneSize)
netpoll_epoll.go#L140: if *(**uintptr)(unsafe.Pointer(&ev.Data)) == &netpollEventFd {
netpoll_epoll.go#L152: read(int32(netpollEventFd), noescape(unsafe.Pointer(&one)), int32(unsafe.Sizeof(one)))
netpoll_epoll.go#L166: tp := *(*taggedPointer)(unsafe.Pointer(&ev.Data))
os_linux.go#L73: futex(unsafe.Pointer(addr), _FUTEX_WAIT_PRIVATE, val, nil, nil, 0)
os_linux.go#L79: futex(unsafe.Pointer(addr), _FUTEX_WAIT_PRIVATE, val, &ts, nil, 0)
os_linux.go#L86: ret := futex(unsafe.Pointer(addr), _FUTEX_WAKE_PRIVATE, cnt, nil, nil, 0)
os_linux.go#L98: *(*int32)(unsafe.Pointer(uintptr(0x1006))) = 0x1006
os_linux.go#L165: func clone(flags int32, stk, mp, gp, fn unsafe.Pointer) int32
os_linux.go#L171: stk := unsafe.Pointer(mp.g0.stack.hi)
os_linux.go#L184: r := clone(cloneFlags, stk, unsafe.Pointer(mp), unsafe.Pointer(mp.g0), unsafe.Pointer(abi.FuncPCABI0(mstart)))
os_linux.go#L206: func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
os_linux.go#L212: ret := clone(cloneFlags, unsafe.Pointer(uintptr(stack)+stacksize), nil, nil, fn)
os_linux.go#L233: func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
os_linux.go#L249: auxvp := (*[1 << 28]uintptr)(add(unsafe.Pointer(argv), uintptr(n)*goarch.PtrSize))
os_linux.go#L270: err := mincore(unsafe.Pointer(uintptr(p)+n), 1, &addrspace_vec[0])
os_linux.go#L283: n = read(fd, noescape(unsafe.Pointer(&auxvreadbuf[0])), int32(unsafe.Sizeof(auxvreadbuf)))
os_linux.go#L312: startupRand = (*[16]byte)(unsafe.Pointer(val))[:]
os_linux.go#L335: ptr := noescape(unsafe.Pointer(&numbuf[0]))
os_linux.go#L366: n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
os_linux.go#L524: *(*uintptr)(unsafe.Pointer(&s.ss_sp)) = sp
os_linux.go#L935: func mprotect(addr unsafe.Pointer, n uintptr, prot int32) (ret int32, errno int32) {
os_linux64.go#L16: func futex(addr unsafe.Pointer, op int32, val uint32, ts *timespec, addr2 unsafe.Pointer, val3 uint32) int32
panic.go#L482: return (*_defer)(unsafe.Pointer(uintptr(1)))
panic.go#L490: racewritepc(unsafe.Pointer(head), sys.GetCallerPC(), abi.FuncPCABIInternal(deferprocat))
panic.go#L511: racereadpc(unsafe.Pointer(head), sys.GetCallerPC(), abi.FuncPCABIInternal(deferconvert))
panic.go#L568: *(*uintptr)(unsafe.Pointer(&d.link)) = uintptr(unsafe.Pointer(gp._defer))
panic.go#L569: *(*uintptr)(unsafe.Pointer(&d.head)) = 0
panic.go#L570: *(*uintptr)(unsafe.Pointer(&gp._defer)) = uintptr(unsafe.Pointer(d))
panic.go#L662: p.start(sys.GetCallerPC(), unsafe.Pointer(sys.GetCallerSP()))
panic.go#L688: p.start(sys.GetCallerPC(), unsafe.Pointer(sys.GetCallerSP()))
panic.go#L762: func readvarintUnsafe(fd unsafe.Pointer) (uint32, unsafe.Pointer) {
panic.go#L850: p.gopanicFP = unsafe.Pointer(sys.GetCallerSP())
panic.go#L854: p.start(sys.GetCallerPC(), unsafe.Pointer(sys.GetCallerSP()))
panic.go#L886: func (p *_panic) start(pc uintptr, sp unsafe.Pointer) {
panic.go#L894: p.startSP = unsafe.Pointer(sys.GetCallerSP())
panic.go#L914: gp._panic = (*_panic)(noescape(unsafe.Pointer(p)))
panic.go#L1026: if p.initOpenCodedDefers(u.frame.fn, unsafe.Pointer(u.frame.varp)) {
panic.go#L1034: p.sp = unsafe.Pointer(u.frame.sp)
panic.go#L1035: p.fp = unsafe.Pointer(u.frame.fp)
panic.go#L1043: func (p *_panic) initOpenCodedDefers(fn funcInfo, varp unsafe.Pointer) bool {
panic.go#L1352: gp.param = unsafe.Pointer(&savedOpenDeferState{
panic.go#L1358: deferBitsOffset: uintptr(unsafe.Pointer(p0.deferBitsPtr)) - uintptr(p0.sp),
pinner.go#L103: pinnerRefStoreSize = (pinnerSize - unsafe.Sizeof([]unsafe.Pointer{})) / unsafe.Sizeof(unsafe.Pointer(nil))
pinner.go#L107: refs []unsafe.Pointer
pinner.go#L108: refStore [pinnerRefStoreSize]unsafe.Pointer
pinner.go#L121: p.refStore = [pinnerRefStoreSize]unsafe.Pointer{}
pinner.go#L125: func pinnerGetPtr(i *any) unsafe.Pointer {
pinner.go#L145: func isPinned(ptr unsafe.Pointer) bool {
pinner.go#L169: func setPinned(ptr unsafe.Pointer, pin bool) bool {
pinner.go#L305: return (*pinnerBits)(atomic.Loadp(unsafe.Pointer(&s.pinnerBits)))
pinner.go#L309: atomicstorep(unsafe.Pointer(&s.pinnerBits), unsafe.Pointer(p))
pinner.go#L328: for _, x := range unsafe.Slice((*uint64)(unsafe.Pointer(&p.x)), bytes/8) {
pinner.go#L337: memmove(unsafe.Pointer(&newPinnerBits.x), unsafe.Pointer(&p.x), bytes)
pinner.go#L357: *ref = (*special)(unsafe.Pointer(rec))
pinner.go#L360: rec = (*specialPinCounter)(unsafe.Pointer(*ref))
pinner.go#L372: counter := (*specialPinCounter)(unsafe.Pointer(*ref))
pinner.go#L380: mheap_.specialPinCounterAlloc.free(unsafe.Pointer(counter))
pinner.go#L388: func pinnerGetPinCounter(addr unsafe.Pointer) *uintptr {
pinner.go#L395: counter := (*specialPinCounter)(unsafe.Pointer(*t))
plugin.go#L84: symName := resolveNameOff(unsafe.Pointer(md.types), ptab.name)
plugin.go#L85: t := toRType((*_type)(unsafe.Pointer(md.types))).typeOff(ptab.typ) // TODO can this stack of conversions be simpler?
plugin.go#L87: valp := (*[2]unsafe.Pointer)(unsafe.Pointer(&val))
plugin.go#L88: (*valp)[0] = unsafe.Pointer(t)
plugin.go#L107: f := funcInfo{(*_func)(unsafe.Pointer(&md.pclntable[md.ftab[i].funcoff])), md}
preempt_xreg.go#L133: xRegAlloc.alloc.free(unsafe.Pointer(xRegs.cache))
print.go#L21: rp := (*slice)(unsafe.Pointer(&ret))
print.go#L249: func printpointer(p unsafe.Pointer) {
print.go#L261: sp := (*slice)(unsafe.Pointer(&s))
proc.go#L445: func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceReason traceBlockReason, traceskip int) {
proc.go#L468: gopark(parkunlock_c, unsafe.Pointer(lock), reason, traceReason, traceskip)
proc.go#L696: atomicstorep(unsafe.Pointer(&allgptr), unsafe.Pointer(&allgs[0]))
proc.go#L719: ptr := (**g)(atomic.Loadp(unsafe.Pointer(&allgptr)))
proc.go#L725: return *(**g)(add(unsafe.Pointer(ptr), i*goarch.PtrSize))
proc.go#L1029: atomicstorep(unsafe.Pointer(&allm), unsafe.Pointer(mp))
proc.go#L1879: gp.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))
proc.go#L1917: gp.sched.g = guintptr(unsafe.Pointer(gp))
proc.go#L2252: var cgoThreadStart unsafe.Pointer
proc.go#L2257: fn unsafe.Pointer
proc.go#L2517: gp.sched.g = guintptr(unsafe.Pointer(gp))
proc.go#L2700: asmcgocall(_cgo_bindm, unsafe.Pointer(g))
proc.go#L2716: return uintptr(unsafe.Pointer(getg().m))
proc.go#L2765: return (*m)(unsafe.Pointer(old))
proc.go#L2775: extraM.Store(uintptr(unsafe.Pointer(mp)))
proc.go#L2913: ts.tls = (*uint64)(unsafe.Pointer(&mp.tls[0]))
proc.go#L2914: ts.fn = unsafe.Pointer(abi.FuncPCABI0(mstart))
proc.go#L2916: msanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
proc.go#L2919: asanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
proc.go#L2922: asmcgocall(_cgo_thread_start, unsafe.Pointer(&ts))
proc.go#L4247: func parkunlock_c(gp *g, lock unsafe.Pointer) bool {
proc.go#L4495: memclrNoHeapPointers(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L5280: newg.valgrindStackID = valgrindRegisterStack(unsafe.Pointer(newg.stack.lo), unsafe.Pointer(newg.stack.hi))
proc.go#L5287: *(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0
proc.go#L5339: *(*uintptr)(unsafe.Pointer(sp)) = 0
proc.go#L5344: *(*uintptr)(unsafe.Pointer(sp - goarch.PtrSize)) = 0
proc.go#L5347: memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
proc.go#L5351: newg.sched.g = guintptr(unsafe.Pointer(newg))
proc.go#L5420: racereleasemergeg(newg, unsafe.Pointer(&labelSync))
proc.go#L5550: gp.valgrindStackID = valgrindRegisterStack(unsafe.Pointer(gp.stack.lo), unsafe.Pointer(gp.stack.hi))
proc.go#L5556: racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L5559: msanmalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L5562: asanunpoison(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L5845: var tagPtr *unsafe.Pointer
proc.go#L5984: mheap_.spanalloc.free(unsafe.Pointer(pp.mspancache.buf[i]))
proc.go#L6079: atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
proc.go#L6245: atomic.Store((*uint32)(unsafe.Pointer(int32p)), uint32(nprocs))
proc.go#L7203: sched.midle.push(unsafe.Pointer(mp))
proc.go#L7238: sched.midle.remove(unsafe.Pointer(mp))
proc.go#L7455: runnext := atomic.Loaduintptr((*uintptr)(unsafe.Pointer(&pp.runnext)))
proc.go#L7497: if !pp.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
proc.go#L8099: firstFunc := add(unsafe.Pointer(t), 8)
proc.go#L8102: f := *(*func())(unsafe.Pointer(&p))
proc.go#L8111: f := *(*func())(unsafe.Pointer(&firstFunc))
profbuf.go#L101: tags []unsafe.Pointer
profbuf.go#L234: b.tags = make([]unsafe.Pointer, tags)
profbuf.go#L307: func (b *profBuf) write(tagPtr *unsafe.Pointer, now int64, hdr []uint64, stk []uintptr) {
profbuf.go#L355: *(*uintptr)(unsafe.Pointer(&b.tags[wt])) = uintptr(*tagPtr)
profbuf.go#L453: var overflowTag [1]unsafe.Pointer // always nil
profbuf.go#L455: func (b *profBuf) read(mode profBufReadMode) (data []uint64, tags []unsafe.Pointer, eof bool) {
profbuf.go#L579: raceacquire(unsafe.Pointer(&labelSync))
proflabel.go#L20: func runtime_setProfLabel(labels unsafe.Pointer) {
proflabel.go#L40: racereleasemerge(unsafe.Pointer(&labelSync))
proflabel.go#L54: func runtime_getProfLabel() unsafe.Pointer {
race0.go#L19: func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) { throw("race") }
race0.go#L20: func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) { throw("race") }
race0.go#L25: func racemapshadow(addr unsafe.Pointer, size uintptr) { throw("race") }
race0.go#L26: func racewritepc(addr unsafe.Pointer, callerpc, pc uintptr) { throw("race") }
race0.go#L27: func racereadpc(addr unsafe.Pointer, callerpc, pc uintptr) { throw("race") }
race0.go#L28: func racereadrangepc(addr unsafe.Pointer, sz, callerpc, pc uintptr) { throw("race") }
race0.go#L29: func racewriterangepc(addr unsafe.Pointer, sz, callerpc, pc uintptr) { throw("race") }
race0.go#L30: func raceacquire(addr unsafe.Pointer) { throw("race") }
race0.go#L31: func raceacquireg(gp *g, addr unsafe.Pointer) { throw("race") }
race0.go#L32: func raceacquirectx(racectx uintptr, addr unsafe.Pointer) { throw("race") }
race0.go#L33: func racerelease(addr unsafe.Pointer) { throw("race") }
race0.go#L34: func racereleaseg(gp *g, addr unsafe.Pointer) { throw("race") }
race0.go#L35: func racereleaseacquire(addr unsafe.Pointer) { throw("race") }
race0.go#L36: func racereleaseacquireg(gp *g, addr unsafe.Pointer) { throw("race") }
race0.go#L37: func racereleasemerge(addr unsafe.Pointer) { throw("race") }
race0.go#L38: func racereleasemergeg(gp *g, addr unsafe.Pointer) { throw("race") }
race0.go#L40: func racemalloc(p unsafe.Pointer, sz uintptr) { throw("race") }
race0.go#L41: func racefree(p unsafe.Pointer, sz uintptr) { throw("race") }
rand.go#L245: t := (*[2]uint32)(unsafe.Pointer(&mp.cheaprand))
runtime.go#L175: racereleasemerge(unsafe.Pointer(&g.inc))
runtime.go#L182: raceacquire(unsafe.Pointer(&g.inc))
runtime.go#L233: write(2, unsafe.Pointer(data), n)
runtime.go#L240: write(fd, unsafe.Pointer(data), n)
runtime1.go#L64: return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*goarch.PtrSize))
runtime1.go#L155: k unsafe.Pointer
runtime1.go#L252: *(*uint64)(unsafe.Pointer(&j)) = ^uint64(0)
runtime1.go#L260: *(*uint64)(unsafe.Pointer(&j1)) = ^uint64(1)
runtime1.go#L268: *(*uint32)(unsafe.Pointer(&i)) = ^uint32(0)
runtime1.go#L276: *(*uint32)(unsafe.Pointer(&i1)) = ^uint32(1)
runtime1.go#L631: func reflect_typelinks() ([]unsafe.Pointer, [][]int32) {
runtime1.go#L633: sections := []unsafe.Pointer{unsafe.Pointer(modules[0].types)}
runtime1.go#L636: sections = append(sections, unsafe.Pointer(md.types))
runtime1.go#L653: func reflect_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L654: return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).Bytes)
runtime1.go#L671: func reflect_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L672: return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
runtime1.go#L686: func reflect_resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L693: func reflectlite_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L694: return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).Bytes)
runtime1.go#L700: func reflectlite_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L701: return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
runtime1.go#L707: func reflect_addReflectOff(ptr unsafe.Pointer) int32 {
runtime1.go#L710: reflectOffs.m = make(map[int32]unsafe.Pointer)
runtime1.go#L711: reflectOffs.minv = make(map[unsafe.Pointer]int32)
runtime2.go#L186: data unsafe.Pointer
runtime2.go#L191: data unsafe.Pointer
runtime2.go#L195: return (*eface)(unsafe.Pointer(ep))
runtime2.go#L245: func (gp guintptr) ptr() *g { return (*g)(unsafe.Pointer(gp)) }
runtime2.go#L248: func (gp *guintptr) set(g *g) { *gp = guintptr(unsafe.Pointer(g)) }
runtime2.go#L252: return atomic.Casuintptr((*uintptr)(unsafe.Pointer(gp)), uintptr(old), uintptr(new))
runtime2.go#L257: return guintptr(unsafe.Pointer(gp))
runtime2.go#L266: (*guintptr)(unsafe.Pointer(gp)).set(new)
runtime2.go#L272: func (pp puintptr) ptr() *p { return (*p)(unsafe.Pointer(pp)) }
runtime2.go#L275: func (pp *puintptr) set(p *p) { *pp = puintptr(unsafe.Pointer(p)) }
runtime2.go#L289: func (mp muintptr) ptr() *m { return (*m)(unsafe.Pointer(mp)) }
runtime2.go#L292: func (mp *muintptr) set(m *m) { *mp = muintptr(unsafe.Pointer(m)) }
runtime2.go#L300: (*muintptr)(unsafe.Pointer(mp)).set(new)
runtime2.go#L319: ctxt unsafe.Pointer
runtime2.go#L336: vp unsafe.Pointer // For liveness only.
runtime2.go#L353: p.vp = unsafe.Pointer(p.vu)
runtime2.go#L359: func (p *maybeTraceablePtr) set(v unsafe.Pointer) {
runtime2.go#L367: func (p *maybeTraceablePtr) get() unsafe.Pointer {
runtime2.go#L368: return unsafe.Pointer(p.vu)
runtime2.go#L388: p.maybeTraceablePtr.set(unsafe.Pointer(c))
runtime2.go#L506: param unsafe.Pointer
runtime2.go#L565: labels unsafe.Pointer // profiler labels
runtime2.go#L685: waitunlockf func(*g, unsafe.Pointer) bool
runtime2.go#L686: waitlock unsafe.Pointer
runtime2.go#L1179: startSP unsafe.Pointer
runtime2.go#L1182: sp unsafe.Pointer
runtime2.go#L1184: fp unsafe.Pointer
runtime2.go#L1192: slotsPtr unsafe.Pointer
runtime2.go#L1199: gopanicFP unsafe.Pointer // frame pointer of the gopanic frame
runtime2.go#L1515: fp = *(*uintptr)(unsafe.Pointer(fp)) // The caller's FP.
runtime2.go#L1516: fp = *(*uintptr)(unsafe.Pointer(fp)) // The caller's caller's FP.
runtime_clearenv.go#L11: var _cgo_clearenv unsafe.Pointer // pointer to C function
secret.go#L52: memclrNoHeapPointers(unsafe.Pointer(lo), sp-lo)
secret.go#L60: func addSecret(p unsafe.Pointer, size uintptr) {
select.go#L22: elem unsafe.Pointer // data element
select.go#L63: func selparkcommit(gp *g, _ unsafe.Pointer) bool {
select.go#L130: cas1 := (*[1 << 16]scase)(unsafe.Pointer(cas0))
select.go#L131: order1 := (*[1 << 17]uint16)(unsafe.Pointer(order0))
select.go#L144: pc1 := (*[1 << 16]uintptr)(unsafe.Pointer(pc0))
select.go#L260: qp unsafe.Pointer
select.go#L546: return uintptr(unsafe.Pointer(c))
select.go#L553: typ unsafe.Pointer // channel type (not used here)
select.go#L555: val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
sema.go#L57: return &t[(uintptr(unsafe.Pointer(addr))>>3)%semTabSize].root
sema.go#L306: s.elem.set(unsafe.Pointer(addr))
sema.go#L317: if uintptr(unsafe.Pointer(addr)) == t.elem.uintptr() {
sema.go#L363: if uintptr(unsafe.Pointer(addr)) < t.elem.uintptr() {
sema.go#L410: if uintptr(unsafe.Pointer(addr)) == s.elem.uintptr() {
sema.go#L414: if uintptr(unsafe.Pointer(addr)) < s.elem.uintptr() {
sema.go#L602: s.elem.set(unsafe.Pointer(l))
set_vma_name_linux.go#L22: func setVMAName(start unsafe.Pointer, length uintptr, name string) {
set_vma_name_linux.go#L31: _, _, err := linux.Syscall6(linux.SYS_PRCTL, linux.PR_SET_VMA, linux.PR_SET_VMA_ANON_NAME, uintptr(start), length, uintptr(unsafe.Pointer(&sysName[0])), 0)
signal_amd64.go#L54: pc := (*[4]byte)(unsafe.Pointer(gp.sigpc))
signal_amd64.go#L72: if shouldPushSigpanic(gp, pc, *(*uintptr)(unsafe.Pointer(sp))) {
signal_amd64.go#L84: *(*uintptr)(unsafe.Pointer(sp)) = resumePC
signal_linux_amd64.go#L14: ctxt unsafe.Pointer
signal_linux_amd64.go#L20: return (*sigcontext)(unsafe.Pointer(&(*ucontext)(c.ctxt).uc_mcontext))
signal_linux_amd64.go#L55: *(*uintptr)(add(unsafe.Pointer(c.info), 2*goarch.PtrSize)) = uintptr(x)
signal_linux_amd64.go#L66: fpbegin := uintptr(unsafe.Pointer((&sigctxt{nil, unsafe.Pointer(ctx)}).regs().fpstate))
signal_unix.go#L412: gp := *(**g)(unsafe.Pointer(s.base()))
signal_unix.go#L432: func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
signal_unix.go#L521: func sigprofNonGo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
signal_unix.go#L562: sp := uintptr(unsafe.Pointer(&sig))
signal_unix.go#L569: stsp := uintptr(unsafe.Pointer(st.ss_sp))
signal_unix.go#L646: func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
signal_unix.go#L674: if sig == _SIGTRAP && testSigtrap != nil && testSigtrap(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp) {
signal_unix.go#L885: b := (*[maxN]byte)(unsafe.Pointer(pc))
signal_unix.go#L1147: *(*uintptr)(unsafe.Pointer(uintptr(123))) = 2
signal_unix.go#L1159: func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)
signal_unix.go#L1168: func sigfwdgo(sig uint32, info *siginfo, ctx unsafe.Pointer) bool {
signal_unix.go#L1431: stsp := uintptr(unsafe.Pointer(st.ss_sp))
slice.go#L17: array unsafe.Pointer
slice.go#L39: func makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer {
slice.go#L56: var to unsafe.Pointer
slice.go#L102: func makeslice(et *_type, len, cap int) unsafe.Pointer {
slice.go#L120: func makeslice64(et *_type, len64, cap64 int64) unsafe.Pointer {
slice.go#L178: func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {
slice.go#L198: return slice{unsafe.Pointer(&zerobase), newLen, newLen}
slice.go#L263: var p unsafe.Pointer
slice.go#L303: func growsliceNoAlias(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {
slice.go#L392: func slicecopy(toPtr unsafe.Pointer, toLen int, fromPtr unsafe.Pointer, fromLen int, width uintptr) int {
slice.go#L442: func moveSlice(et *_type, old unsafe.Pointer, len, cap int) (unsafe.Pointer, int, int) {
slice.go#L445: old = unsafe.Pointer(&zerobase)
slice.go#L458: func moveSliceNoScan(elemSize uintptr, old unsafe.Pointer, len, cap int) (unsafe.Pointer, int, int) {
slice.go#L461: old = unsafe.Pointer(&zerobase)
slice.go#L474: func moveSliceNoCap(et *_type, old unsafe.Pointer, len int) (unsafe.Pointer, int, int) {
slice.go#L477: old = unsafe.Pointer(&zerobase)
slice.go#L490: func moveSliceNoCapNoScan(elemSize uintptr, old unsafe.Pointer, len int) (unsafe.Pointer, int, int) {
slice.go#L493: old = unsafe.Pointer(&zerobase)
slice.go#L509: func growsliceBuf(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type, bufPtr unsafe.Pointer, bufLen int) slice {
slice.go#L546: func growsliceBufNoAlias(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type, bufPtr unsafe.Pointer, bufLen int) slice {
stack.go#L219: valgrindMalloc(unsafe.Pointer(x.ptr()), unsafe.Sizeof(x.ptr()))
stack.go#L371: var v unsafe.Pointer
stack.go#L402: valgrindFree(unsafe.Pointer(x.ptr()))
stack.go#L404: v = unsafe.Pointer(x)
stack.go#L429: v = unsafe.Pointer(s.base())
stack.go#L465: v := unsafe.Pointer(stk.lo)
stack.go#L514: valgrindMalloc(unsafe.Pointer(x.ptr()), unsafe.Sizeof(x.ptr()))
stack.go#L527: valgrindMalloc(unsafe.Pointer(x.ptr()), unsafe.Sizeof(x.ptr()))
stack.go#L610: func adjustpointer(adjinfo *adjustinfo, vpp unsafe.Pointer) {
stack.go#L624: valgrindMakeMemDefined(unsafe.Pointer(&p), unsafe.Sizeof(&p))
stack.go#L652: func adjustpointers(scanp unsafe.Pointer, bv *bitvector, adjinfo *adjustinfo, f funcInfo) {
stack.go#L688: ppu := (*unsafe.Pointer)(unsafe.Pointer(pp))
stack.go#L689: if !atomic.Casp1(ppu, unsafe.Pointer(p), unsafe.Pointer(p+delta)) {
stack.go#L719: bp := *(*uintptr)(unsafe.Pointer(frame.varp))
stack.go#L730: adjustpointer(adjinfo, unsafe.Pointer(frame.varp))
stack.go#L738: adjustpointers(unsafe.Pointer(frame.varp-size), &locals, adjinfo, f)
stack.go#L746: adjustpointers(unsafe.Pointer(frame.argp), &args, adjinfo, funcInfo{})
stack.go#L769: adjustpointer(adjinfo, unsafe.Pointer(p+i))
stack.go#L777: adjustpointer(adjinfo, unsafe.Pointer(&gp.sched.ctxt))
stack.go#L790: adjustpointer(adjinfo, unsafe.Pointer(&gp.sched.bp))
stack.go#L796: memmove(unsafe.Pointer(gp.sched.bp), unsafe.Pointer(oldfp), goarch.PtrSize)
stack.go#L797: adjustpointer(adjinfo, unsafe.Pointer(gp.sched.bp))
stack.go#L806: adjustpointer(adjinfo, unsafe.Pointer(&gp._defer))
stack.go#L808: adjustpointer(adjinfo, unsafe.Pointer(&d.fn))
stack.go#L809: adjustpointer(adjinfo, unsafe.Pointer(&d.sp))
stack.go#L810: adjustpointer(adjinfo, unsafe.Pointer(&d.link))
stack.go#L817: adjustpointer(adjinfo, unsafe.Pointer(&gp._panic))
stack.go#L824: adjustpointer(adjinfo, unsafe.Pointer(&s.elem.vu))
stack.go#L825: adjustpointer(adjinfo, unsafe.Pointer(&s.elem.vp))
stack.go#L831: *(*byte)(unsafe.Pointer(p)) = b
stack.go#L883: memmove(unsafe.Pointer(newBot), unsafe.Pointer(oldBot), sgsize)
stack.go#L956: memmove(unsafe.Pointer(new.hi-ncopy), unsafe.Pointer(old.hi-ncopy), ncopy)
stack.go#L982: gp.valgrindStackID = valgrindRegisterStack(unsafe.Pointer(new.lo), unsafe.Pointer(new.hi))
stack.go#L984: valgrindChangeStack(gp.valgrindStackID, unsafe.Pointer(new.lo), unsafe.Pointer(new.hi))
stack.go#L995: memclrNoHeapPointers(unsafe.Pointer(old.lo), old.hi-old.lo)
stack.go#L1203: var fn unsafe.Pointer
stack.go#L1205: fn = unsafe.Pointer(fv.fn)
stack.go#L1207: fn = unsafe.Pointer(abi.FuncPCABIInternal(nilfunc))
stack.go#L1209: gostartcall(gobuf, fn, unsafe.Pointer(fv))
stack.go#L1357: ptr := uintptr(unsafe.Pointer(r))
stack.go#L1375: return uintptr(r.ptrBytes), (*byte)(unsafe.Pointer(res))
stkframe.go#L133: mv := *(**reflectMethodValue)(unsafe.Pointer(arg0))
stkframe.go#L137: retValid := *(*bool)(unsafe.Pointer(arg0 + 4*goarch.PtrSize))
stkframe.go#L269: ptr := uintptr(unsafe.Pointer(&methodValueCallFrameObjs[0]))
stkframe.go#L284: gcdataoff: uint32(uintptr(unsafe.Pointer(getGCMask(abiRegArgsType))) - mod.rodata),
string.go#L147: racereadrangepc(unsafe.Pointer(ptr),
string.go#L153: msanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L156: asanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L159: p := unsafe.Pointer(&staticuint64s[*ptr])
string.go#L166: var p unsafe.Pointer
string.go#L168: p = unsafe.Pointer(buf)
string.go#L172: memmove(p, unsafe.Pointer(ptr), uintptr(n))
string.go#L179: ptr := uintptr(unsafe.Pointer(unsafe.StringData(s)))
string.go#L210: racereadrangepc(unsafe.Pointer(ptr),
string.go#L216: msanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L219: asanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L262: racereadrangepc(unsafe.Pointer(&a[0]),
string.go#L268: msanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
string.go#L271: asanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
string.go#L291: str unsafe.Pointer
string.go#L302: return (*stringStruct)(unsafe.Pointer(sp))
string.go#L337: *(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(cap)}
string.go#L352: *(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(mem / 4)}
string.go#L367: memmove(bp, unsafe.Pointer(p), uintptr(n))
string.go#L369: *(*slice)(unsafe.Pointer(&b)) = slice{bp, n, n}
string.go#L382: memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l))
string.go#L398: memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l))
string.go#L496: p := (*[maxAlloc/2 - 1]byte)(unsafe.Pointer(s))
string.go#L511: ptr := unsafe.Pointer(s)
string.go#L518: t := *(*string)(unsafe.Pointer(&stringStruct{ptr, safeLen}))
string.go#L524: ptr = unsafe.Pointer(uintptr(ptr) + uintptr(safeLen))
string.go#L534: p := (*[maxAlloc/2/2 - 1]uint16)(unsafe.Pointer(s))
string.go#L544: ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
string.go#L545: s := *(*string)(unsafe.Pointer(&ss))
string.go#L551: str := (*[maxAlloc/2/2 - 1]uint16)(unsafe.Pointer(strw))
stubs.go#L24: func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
stubs.go#L25: return unsafe.Pointer(uintptr(p) + x)
stubs.go#L108: func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
stubs.go#L111: func reflect_memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr) {
stubs.go#L145: func memmove(to, from unsafe.Pointer, n uintptr)
stubs.go#L148: func reflect_memmove(to, from unsafe.Pointer, n uintptr) {
stubs.go#L167: func memequal(a, b unsafe.Pointer, size uintptr) bool
stubs.go#L189: func noescape(p unsafe.Pointer) unsafe.Pointer {
stubs.go#L191: return unsafe.Pointer(x ^ 0)
stubs.go#L199: x := uintptr(unsafe.Pointer(p))
stubs.go#L200: return (*T)(unsafe.Pointer(x ^ 0))
stubs.go#L264: func reflectcall(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L320: func asmcgocall(fn, arg unsafe.Pointer) int32
stubs.go#L341: func call16(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L342: func call32(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L343: func call64(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L344: func call128(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L345: func call256(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L346: func call512(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L347: func call1024(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L348: func call2048(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L349: func call4096(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L350: func call8192(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L351: func call16384(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L352: func call32768(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L353: func call65536(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L354: func call131072(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L355: func call262144(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L356: func call524288(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L357: func call1048576(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L358: func call2097152(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L359: func call4194304(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L360: func call8388608(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L361: func call16777216(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L362: func call33554432(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L363: func call67108864(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L364: func call134217728(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L365: func call268435456(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L366: func call536870912(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L367: func call1073741824(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L397: func memequal_varlen(a, b unsafe.Pointer) bool
stubs.go#L403: return int(*(*uint8)(unsafe.Pointer(&x)))
stubs2.go#L16: func read(fd int32, p unsafe.Pointer, n int32) int32
stubs2.go#L32: func write1(fd uintptr, p unsafe.Pointer, n int32) int32
stubs2.go#L38: func madvise(addr unsafe.Pointer, n uintptr, flags int32) int32
stubs_amd64.go#L42: func asmcgocall_no_g(fn, arg unsafe.Pointer)
stubs_linux.go#L19: func connect(fd int32, addr unsafe.Pointer, len int32) int32
symtab.go#L349: return (*_func)(unsafe.Pointer(f))
symtab.go#L360: ptr := uintptr(unsafe.Pointer(f))
symtab.go#L366: base := uintptr(unsafe.Pointer(&datap.pclntable[0]))
symtab.go#L519: p := (*[]*moduledata)(atomic.Loadp(unsafe.Pointer(&modulesSlice)))
symtab.go#L553: md.gcdatamask = progToPointerMask((*byte)(unsafe.Pointer(md.gcdata)), scanDataSize)
symtab.go#L555: md.gcbssmask = progToPointerMask((*byte)(unsafe.Pointer(md.gcbss)), scanBSSSize)
symtab.go#L577: atomicstorep(unsafe.Pointer(&modulesSlice), unsafe.Pointer(modules))
symtab.go#L639: f1 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i].funcoff])), datap}
symtab.go#L640: f2 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i+1].funcoff])), datap}
symtab.go#L647: println("\t", hex(datap.ftab[j].entryoff), funcname(funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[j].funcoff])), datap}))
symtab.go#L806: return (*Func)(unsafe.Pointer(fi))
symtab.go#L816: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L826: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L839: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L853: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L884: return (*Func)(unsafe.Pointer(f._func))
symtab.go#L944: ffb := (*findfuncbucket)(add(unsafe.Pointer(datap.findfunctab), b*unsafe.Sizeof(findfuncbucket{})))
symtab.go#L953: return funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[funcoff])), datap}
symtab.go#L1237: return *(*uint32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4))
symtab.go#L1266: func funcdata(f funcInfo, i uint8) unsafe.Pointer {
symtab.go#L1271: p := uintptr(unsafe.Pointer(&f.nfuncdata)) + unsafe.Sizeof(f.nfuncdata) + uintptr(f.npcdata)*4 + uintptr(i)*4
symtab.go#L1272: off := *(*uint32)(unsafe.Pointer(p))
symtab.go#L1281: return unsafe.Pointer(raw & mask)
synctest.go#L160: func (bubble *synctestBubble) raceaddr() unsafe.Pointer {
synctest.go#L165: return unsafe.Pointer(bubble)
synctest.go#L199: fv := *(**funcval)(unsafe.Pointer(&f))
synctest.go#L269: func synctestidle_c(gp *g, _ unsafe.Pointer) bool {
synctest.go#L316: func synctestwait_c(gp *g, _ unsafe.Pointer) bool {
synctest.go#L381: func getOrSetBubbleSpecial(p unsafe.Pointer, bubbleid uint64, add bool) (assoc int) {
synctest.go#L404: s := (*specialBubble)((unsafe.Pointer)(*iter))
synctest.go#L420: *iter = (*special)(unsafe.Pointer(s))
synctest.go#L438: func synctest_associate(p unsafe.Pointer) int {
synctest.go#L445: func synctest_disassociate(p unsafe.Pointer) {
synctest.go#L452: func synctest_isAssociated(p unsafe.Pointer) bool {
sys_x86.go#L16: func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
sys_x86.go#L19: *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
tagptr_64bit.go#L63: func taggedPointerPack(ptr unsafe.Pointer, tag uintptr) taggedPointer {
tagptr_64bit.go#L73: func (tp taggedPointer) pointer() unsafe.Pointer {
tagptr_64bit.go#L77: return unsafe.Pointer(uintptr(int64(tp) >> tagBits << tagAlignBits))
tagptr_64bit.go#L80: return unsafe.Pointer(uintptr((tp >> tagBits << tagAlignBits) | 0xa<<56))
tagptr_64bit.go#L82: return unsafe.Pointer(uintptr(tp >> tagBits << tagAlignBits))
time.go#L371: func resetForSleep(gp *g, _ unsafe.Pointer) bool {
time.go#L380: c unsafe.Pointer // <-chan time.Time
time.go#L394: racerelease(unsafe.Pointer(&t.timer))
time.go#L430: racerelease(unsafe.Pointer(&t.timer))
time.go#L1139: raceacquirectx(tsLocal.raceCtx, unsafe.Pointer(t))
time_nofake.go#L48: var overrideWrite func(fd uintptr, p unsafe.Pointer, n int32) int32
time_nofake.go#L53: func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
trace.go#L788: raceacquire(unsafe.Pointer(&trace.doneSema[gen%2]))
trace.go#L809: sysFree(unsafe.Pointer(buf), unsafe.Sizeof(*buf), &memstats.other_sys)
trace.go#L893: gopark(func(gp *g, _ unsafe.Pointer) bool {
trace.go#L1003: racerelease(unsafe.Pointer(&trace.doneSema[gen%2]))
trace.go#L1025: racerelease(unsafe.Pointer(&trace.doneSema[gen%2]))
trace.go#L1161: raceacquire(unsafe.Pointer(&s.lock))
trace.go#L1165: racerelease(unsafe.Pointer(&s.lock))
trace.go#L1180: raceacquire(unsafe.Pointer(&s.lock))
trace.go#L1194: racerelease(unsafe.Pointer(&s.lock))
trace.go#L1210: raceacquire(unsafe.Pointer(&s.lock))
trace.go#L1219: racerelease(unsafe.Pointer(&s.lock))
traceback.go#L179: frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
traceback.go#L182: frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
traceback.go#L374: frame.lr = *(*uintptr)(unsafe.Pointer(lrPtr))
traceback.go#L379: frame.lr = *(*uintptr)(unsafe.Pointer(lrPtr))
traceback.go#L503: x := *(*uintptr)(unsafe.Pointer(frame.sp))
traceback.go#L657: func printArgs(f funcInfo, argp unsafe.Pointer, pc uintptr) {
traceback.go#L996: argp := unsafe.Pointer(u.frame.argp)
traceback.go#L1601: func SetCgoTraceback(version int, traceback, context, symbolizer unsafe.Pointer) {
traceback.go#L1618: traceback unsafe.Pointer
traceback.go#L1619: context unsafe.Pointer
traceback.go#L1620: symbolizer unsafe.Pointer
traceback.go#L1627: cgocall(_cgo_set_traceback_functions, noescape(unsafe.Pointer(&arg)))
traceback.go#L1631: var cgoTraceback unsafe.Pointer
traceback.go#L1632: var cgoContext unsafe.Pointer
traceback.go#L1633: var cgoSymbolizer unsafe.Pointer
traceback.go#L1740: msanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
traceback.go#L1743: asanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
traceback.go#L1745: call(_cgo_call_symbolizer_function, noescape(unsafe.Pointer(arg)))
traceback.go#L1760: buf: (*uintptr)(noescape(unsafe.Pointer(&buf[0]))),
traceback.go#L1764: msanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
traceback.go#L1767: asanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
traceback.go#L1769: call(_cgo_call_traceback_function, noescape(unsafe.Pointer(&arg)))
tracemap.go#L74: func (tab *traceMap) put(data unsafe.Pointer, size uintptr) (uint64, bool) {
tracemap.go#L104: if m.CompareAndSwapNoWB(nil, unsafe.Pointer(newNode)) {
tracemap.go#L113: if memequal(unsafe.Pointer(&n.data[0]), data, size) {
tracemap.go#L122: func (tab *traceMap) newTraceMapNode(data unsafe.Pointer, size, hash uintptr, id uint64) *traceMapNode {
tracemap.go#L129: memmove(unsafe.Pointer(sl.array), data, size)
tracemap.go#L132: meta := (*traceMapNode)(unsafe.Pointer(tab.mem.alloc(unsafe.Sizeof(traceMapNode{}))))
tracemap.go#L133: *(*notInHeapSlice)(unsafe.Pointer(&meta.data)) = sl
traceregion.go#L57: return (*notInHeap)(unsafe.Pointer(&block.data[r-n]))
traceregion.go#L75: x = (*notInHeap)(unsafe.Pointer(&block.data[r-n]))
traceregion.go#L93: x = (*notInHeap)(unsafe.Pointer(&block.data[0]))
traceregion.go#L96: a.current.Store(unsafe.Pointer(block))
traceregion.go#L111: sysFree(unsafe.Pointer(block), unsafe.Sizeof(traceRegionAllocBlock{}), &memstats.other_sys)
tracestack.go#L58: print("runtime: gp=", unsafe.Pointer(gp), " gp.goid=", gp.goid, " status=", gStatusStrings[status], "\n")
tracestack.go#L87: nstk += fpTracebackPCs(unsafe.Pointer(getfp()), pcBuf[1:])
tracestack.go#L107: nstk += 1 + fpTracebackPCs(unsafe.Pointer(gp.syscallbp), pcBuf[2:])
tracestack.go#L120: pcBuf[2] = *(*uintptr)(unsafe.Pointer(gp.sched.sp))
tracestack.go#L122: nstk += 2 + fpTracebackPCs(unsafe.Pointer(gp.sched.bp), pcBuf[3:])
tracestack.go#L124: nstk += 1 + fpTracebackPCs(unsafe.Pointer(gp.sched.bp), pcBuf[2:])
tracestack.go#L154: id, _ := t.tab.put(noescape(unsafe.Pointer(&pcs[0])), uintptr(len(pcs))*unsafe.Sizeof(uintptr(0)))
tracestack.go#L172: stack := unsafe.Slice((*uintptr)(unsafe.Pointer(&node.data[0])), uintptr(len(node.data))/unsafe.Sizeof(uintptr(0)))
tracestack.go#L267: func fpTracebackPCs(fp unsafe.Pointer, pcBuf []uintptr) (i int) {
tracestack.go#L270: pcBuf[i] = *(*uintptr)(unsafe.Pointer(uintptr(fp) + goarch.PtrSize))
tracestack.go#L272: fp = unsafe.Pointer(*(*uintptr)(fp))
tracetype.go#L31: id, _ := t.tab.put(noescape(unsafe.Pointer(&typ)), goarch.PtrSize)
tracetype.go#L48: typ := (*abi.Type)(*(*unsafe.Pointer)(unsafe.Pointer(&node.data[0])))
tracetype.go#L68: w.varint(uint64(uintptr(unsafe.Pointer(typ))))
type.go#L73: st := (*structtype)(unsafe.Pointer(t.Type))
type.go#L76: it := (*interfacetype)(unsafe.Pointer(t.Type))
type.go#L109: addr := unsafe.Pointer(t.GCData)
type.go#L128: if !atomic.Casp1((*unsafe.Pointer)(addr), nil, unsafe.Pointer(&inProgress)) {
type.go#L140: atomic.StorepNoWB(addr, unsafe.Pointer(p))
type.go#L276: m map[int32]unsafe.Pointer
type.go#L277: minv map[unsafe.Pointer]int32
type.go#L283: raceacquire(unsafe.Pointer(&reflectOffs.lock))
type.go#L289: racerelease(unsafe.Pointer(&reflectOffs.lock))
type.go#L294: func resolveNameOff(ptrInModule unsafe.Pointer, off nameOff) name {
type.go#L306: return name{Bytes: (*byte)(unsafe.Pointer(res))}
type.go#L325: return resolveNameOff(unsafe.Pointer(t.Type), off)
type.go#L328: func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {
type.go#L363: return (*_type)(unsafe.Pointer(res))
type.go#L367: return resolveTypeOff(unsafe.Pointer(t.Type), off)
type.go#L370: func (t rtype) textOff(off textOff) unsafe.Pointer {
type.go#L374: return unsafe.Pointer(abi.FuncPCABIInternal(unreachableMethod))
type.go#L376: base := uintptr(unsafe.Pointer(t.Type))
type.go#L398: return unsafe.Pointer(res)
type.go#L430: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.Data(off)))[:])
type.go#L431: pkgPathName := resolveNameOff(unsafe.Pointer(n.Bytes), nameOff)
type.go#L451: t = (*_type)(unsafe.Pointer(prev.types + uintptr(tl)))
type.go#L473: t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
type.go#L551: at := (*arraytype)(unsafe.Pointer(t))
type.go#L552: av := (*arraytype)(unsafe.Pointer(v))
type.go#L555: ct := (*chantype)(unsafe.Pointer(t))
type.go#L556: cv := (*chantype)(unsafe.Pointer(v))
type.go#L559: ft := (*functype)(unsafe.Pointer(t))
type.go#L560: fv := (*functype)(unsafe.Pointer(v))
type.go#L578: it := (*interfacetype)(unsafe.Pointer(t))
type.go#L579: iv := (*interfacetype)(unsafe.Pointer(v))
type.go#L591: tname := resolveNameOff(unsafe.Pointer(tm), tm.Name)
type.go#L592: vname := resolveNameOff(unsafe.Pointer(vm), vm.Name)
type.go#L599: tityp := resolveTypeOff(unsafe.Pointer(tm), tm.Typ)
type.go#L600: vityp := resolveTypeOff(unsafe.Pointer(vm), vm.Typ)
type.go#L607: mt := (*abi.MapType)(unsafe.Pointer(t))
type.go#L608: mv := (*abi.MapType)(unsafe.Pointer(v))
type.go#L611: pt := (*ptrtype)(unsafe.Pointer(t))
type.go#L612: pv := (*ptrtype)(unsafe.Pointer(v))
type.go#L615: st := (*slicetype)(unsafe.Pointer(t))
type.go#L616: sv := (*slicetype)(unsafe.Pointer(v))
type.go#L619: st := (*structtype)(unsafe.Pointer(t))
type.go#L620: sv := (*structtype)(unsafe.Pointer(v))
unsafe.go#L13: func unsafestring(ptr unsafe.Pointer, len int) {
unsafe.go#L27: func unsafestring64(ptr unsafe.Pointer, len64 int64) {
unsafe.go#L35: func unsafestringcheckptr(ptr unsafe.Pointer, len64 int64) {
unsafe.go#L54: func unsafeslice(et *_type, ptr unsafe.Pointer, len int) {
unsafe.go#L75: func unsafeslice64(et *_type, ptr unsafe.Pointer, len64 int64) {
unsafe.go#L83: func unsafeslicecheckptr(et *_type, ptr unsafe.Pointer, len64 int64) {
unsafe.go#L118: func reflect_unsafeslice(et *_type, ptr unsafe.Pointer, len int) {
valgrind0.go#L15: func valgrindRegisterStack(start, end unsafe.Pointer) uintptr { return 0 }
valgrind0.go#L17: func valgrindChangeStack(id uintptr, start, end unsafe.Pointer) {}
valgrind0.go#L18: func valgrindMalloc(addr unsafe.Pointer, size uintptr) {}
valgrind0.go#L19: func valgrindFree(addr unsafe.Pointer) {}
valgrind0.go#L20: func valgrindCreateMempool(addr unsafe.Pointer) {}
valgrind0.go#L21: func valgrindMempoolMalloc(pool, addr unsafe.Pointer, size uintptr) {}
valgrind0.go#L22: func valgrindMempoolFree(pool, addr unsafe.Pointer) {}
valgrind0.go#L23: func valgrindMakeMemUndefined(addr unsafe.Pointer, size uintptr) {}
valgrind0.go#L24: func valgrindMakeMemDefined(addr unsafe.Pointer, size uintptr) {}
valgrind0.go#L25: func valgrindMakeMemNoAccess(addr unsafe.Pointer, size uintptr) {}
vdso_linux.go#L106: info.loadAddr = uintptr(unsafe.Pointer(hdr))
vdso_linux.go#L108: pt := unsafe.Pointer(info.loadAddr + uintptr(hdr.e_phoff))
vdso_linux.go#L126: dyn = (*[vdsoDynSize]elfDyn)(unsafe.Pointer(info.loadAddr + uintptr(pt.p_offset)))
vdso_linux.go#L146: info.symstrings = (*[vdsoSymStringsSize]byte)(unsafe.Pointer(p))
vdso_linux.go#L148: info.symtab = (*[vdsoSymTabSize]elfSym)(unsafe.Pointer(p))
vdso_linux.go#L150: hash = (*[vdsoHashSize]uint32)(unsafe.Pointer(p))
vdso_linux.go#L152: gnuhash = (*[vdsoHashSize]uint32)(unsafe.Pointer(p))
vdso_linux.go#L154: info.versym = (*[vdsoVerSymSize]uint16)(unsafe.Pointer(p))
vdso_linux.go#L156: info.verdef = (*elfVerdef)(unsafe.Pointer(p))
vdso_linux.go#L196: aux := (*elfVerdaux)(add(unsafe.Pointer(def), uintptr(def.vd_aux)))
vdso_linux.go#L205: def = (*elfVerdef)(add(unsafe.Pointer(def), uintptr(def.vd_next)))
vdso_linux.go#L282: info1 := (*vdsoInfo)(noescape(unsafe.Pointer(&info)))
vdso_linux.go#L283: vdsoInitFromSysinfoEhdr(info1, (*elfEhdr)(unsafe.Pointer(val)))
vgetrandom_linux.go#L37: if vgetrandom1(nil, 0, 0, uintptr(unsafe.Pointer(¶ms)), ^uintptr(0)) != 0 {
runtime/cgo
callbacks.go#L157: var _cgo_yield unsafe.Pointer
linux.go#L26: var cgo_libc_setegid = unsafe.Pointer(&_cgo_libc_setegid)
linux.go#L32: var cgo_libc_seteuid = unsafe.Pointer(&_cgo_libc_seteuid)
linux.go#L38: var cgo_libc_setregid = unsafe.Pointer(&_cgo_libc_setregid)
linux.go#L44: var cgo_libc_setresgid = unsafe.Pointer(&_cgo_libc_setresgid)
linux.go#L50: var cgo_libc_setresuid = unsafe.Pointer(&_cgo_libc_setresuid)
linux.go#L56: var cgo_libc_setreuid = unsafe.Pointer(&_cgo_libc_setreuid)
linux.go#L62: var cgo_libc_setgroups = unsafe.Pointer(&_cgo_libc_setgroups)
linux.go#L68: var cgo_libc_setgid = unsafe.Pointer(&_cgo_libc_setgid)
linux.go#L74: var cgo_libc_setuid = unsafe.Pointer(&_cgo_libc_setuid)
35ecbc01c116bd35989833b4c19548bb631e16537a61f6cf6fc2841cdb0db557-d#L10: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
35ecbc01c116bd35989833b4c19548bb631e16537a61f6cf6fc2841cdb0db557-d#L24: func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
slices
slices.go#L463: return uintptr(unsafe.Pointer(&a[0])) <= uintptr(unsafe.Pointer(&b[len(b)-1]))+(elemSize-1) &&
slices.go#L464: uintptr(unsafe.Pointer(&b[0])) <= uintptr(unsafe.Pointer(&a[len(a)-1]))+(elemSize-1)
strings
builder.go#L39: b.addr = (*Builder)(abi.NoEscape(unsafe.Pointer(b)))
sync
cond.go#L104: if uintptr(*c) != uintptr(unsafe.Pointer(c)) &&
cond.go#L105: !atomic.CompareAndSwapUintptr((*uintptr)(c), 0, uintptr(unsafe.Pointer(c))) &&
cond.go#L106: uintptr(*c) != uintptr(unsafe.Pointer(c)) {
pool.go#L54: local unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
pool.go#L57: victim unsafe.Pointer // local from previous cycle
pool.go#L92: func poolRaceAddr(x any) unsafe.Pointer {
pool.go#L93: ptr := uintptr((*[2]unsafe.Pointer)(unsafe.Pointer(&x))[1])
pool.go#L95: return unsafe.Pointer(&poolRaceHash[h%uint32(len(poolRaceHash))])
pool.go#L242: atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
pool.go#L300: func indexLocal(l unsafe.Pointer, i int) *poolLocal {
pool.go#L301: lp := unsafe.Pointer(uintptr(l) + uintptr(i)*unsafe.Sizeof(poolLocal{}))
poolqueue.go#L48: typ, val unsafe.Pointer
poolqueue.go#L101: *(*any)(unsafe.Pointer(slot)) = val
poolqueue.go#L134: val := *(*any)(unsafe.Pointer(slot))
poolqueue.go#L169: val := *(*any)(unsafe.Pointer(slot))
runtime2.go#L17: head unsafe.Pointer
runtime2.go#L18: tail unsafe.Pointer
rwmutex.go#L69: race.Read(unsafe.Pointer(&rw.w))
rwmutex.go#L78: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L89: race.Read(unsafe.Pointer(&rw.w))
rwmutex.go#L103: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L116: race.Read(unsafe.Pointer(&rw.w))
rwmutex.go#L117: race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))
rwmutex.go#L146: race.Read(unsafe.Pointer(&rw.w))
rwmutex.go#L159: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L160: race.Acquire(unsafe.Pointer(&rw.writerSem))
rwmutex.go#L171: race.Read(unsafe.Pointer(&rw.w))
rwmutex.go#L189: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L190: race.Acquire(unsafe.Pointer(&rw.writerSem))
rwmutex.go#L203: race.Read(unsafe.Pointer(&rw.w))
rwmutex.go#L204: race.Release(unsafe.Pointer(&rw.readerSem))
waitgroup.go#L81: race.ReleaseMerge(unsafe.Pointer(wg))
waitgroup.go#L115: race.Read(unsafe.Pointer(&wg.sema))
waitgroup.go#L172: race.Acquire(unsafe.Pointer(wg))
waitgroup.go#L190: race.Write(unsafe.Pointer(&wg.sema))
waitgroup.go#L210: race.Acquire(unsafe.Pointer(wg))
sync/atomic
doc.go#L87: func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)
doc.go#L109: func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)
doc.go#L193: func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)
doc.go#L215: func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)
type.go#L54: v unsafe.Pointer
type.go#L61: func (x *Pointer[T]) Store(val *T) { StorePointer(&x.v, unsafe.Pointer(val)) }
type.go#L64: func (x *Pointer[T]) Swap(new *T) (old *T) { return (*T)(SwapPointer(&x.v, unsafe.Pointer(new))) }
type.go#L68: return CompareAndSwapPointer(&x.v, unsafe.Pointer(old), unsafe.Pointer(new))
value.go#L22: typ unsafe.Pointer
value.go#L23: data unsafe.Pointer
value.go#L29: vp := (*efaceWords)(unsafe.Pointer(v))
value.go#L31: if typ == nil || typ == unsafe.Pointer(&firstStoreInProgress) {
value.go#L36: vlp := (*efaceWords)(unsafe.Pointer(&val))
value.go#L51: vp := (*efaceWords)(unsafe.Pointer(v))
value.go#L52: vlp := (*efaceWords)(unsafe.Pointer(&val))
value.go#L60: if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
value.go#L70: if typ == unsafe.Pointer(&firstStoreInProgress) {
value.go#L94: vp := (*efaceWords)(unsafe.Pointer(v))
value.go#L95: np := (*efaceWords)(unsafe.Pointer(&new))
value.go#L103: if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
value.go#L113: if typ == unsafe.Pointer(&firstStoreInProgress) {
value.go#L123: op := (*efaceWords)(unsafe.Pointer(&old))
value.go#L138: vp := (*efaceWords)(unsafe.Pointer(v))
value.go#L139: np := (*efaceWords)(unsafe.Pointer(&new))
value.go#L140: op := (*efaceWords)(unsafe.Pointer(&old))
value.go#L154: if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
value.go#L164: if typ == unsafe.Pointer(&firstStoreInProgress) {
value.go#L181: (*efaceWords)(unsafe.Pointer(&i)).typ = typ
value.go#L182: (*efaceWords)(unsafe.Pointer(&i)).data = data
syscall
exec_linux.go#L165: RawSyscall(SYS_WRITE, uintptr(mapPipe[1]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
exec_linux.go#L325: clone3.pidFD = uint64(uintptr(unsafe.Pointer(&pidfd)))
exec_linux.go#L334: pid, err1 = rawVforkSyscall(_SYS_clone3, uintptr(unsafe.Pointer(clone3)), unsafe.Sizeof(*clone3), 0)
exec_linux.go#L340: pid, err1 = rawVforkSyscall(SYS_CLONE, 0, flags, uintptr(unsafe.Pointer(&pidfd)))
exec_linux.go#L342: pid, err1 = rawVforkSyscall(SYS_CLONE, flags, 0, uintptr(unsafe.Pointer(&pidfd)))
exec_linux.go#L370: c, _, err1 = RawSyscall(SYS_READ, uintptr(mapPipe[0]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
exec_linux.go#L410: _, _, err1 = RawSyscall(SYS_IOCTL, uintptr(sys.Ctty), uintptr(TIOCSPGRP), uintptr(unsafe.Pointer(&pgrp)))
exec_linux.go#L429: if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&psetgroups[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
exec_linux.go#L432: _, _, err1 = RawSyscall(SYS_WRITE, fd1, uintptr(unsafe.Pointer(&setgroups[0])), uintptr(len(setgroups)))
exec_linux.go#L440: if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&pgid[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
exec_linux.go#L443: _, _, err1 = RawSyscall(SYS_WRITE, fd1, uintptr(unsafe.Pointer(&gidmap[0])), uintptr(len(gidmap)))
exec_linux.go#L454: if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&puid[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
exec_linux.go#L457: _, _, err1 = RawSyscall(SYS_WRITE, fd1, uintptr(unsafe.Pointer(&uidmap[0])), uintptr(len(uidmap)))
exec_linux.go#L474: _, _, err1 = RawSyscall6(SYS_MOUNT, uintptr(unsafe.Pointer(&none[0])), uintptr(unsafe.Pointer(&slash[0])), 0, MS_REC|MS_PRIVATE, 0, 0)
exec_linux.go#L483: _, _, err1 = RawSyscall(SYS_CHROOT, uintptr(unsafe.Pointer(chroot)), 0, 0)
exec_linux.go#L494: groups = uintptr(unsafe.Pointer(&cred.Groups[0]))
exec_linux.go#L517: if _, _, err1 = RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(&caps.hdr)), uintptr(unsafe.Pointer(&caps.data[0])), 0); err1 != 0 {
exec_linux.go#L528: if _, _, err1 = RawSyscall(SYS_CAPSET, uintptr(unsafe.Pointer(&caps.hdr)), uintptr(unsafe.Pointer(&caps.data[0])), 0); err1 != 0 {
exec_linux.go#L542: _, _, err1 = RawSyscall(SYS_CHDIR, uintptr(unsafe.Pointer(dir)), 0, 0)
exec_linux.go#L651: _, _, err1 = RawSyscall6(SYS_PRLIMIT64, 0, RLIMIT_NOFILE, 0, uintptr(unsafe.Pointer(&lim)), 0, 0)
exec_linux.go#L653: RawSyscall6(SYS_PRLIMIT64, 0, RLIMIT_NOFILE, uintptr(unsafe.Pointer(rlim)), 0, 0, 0)
exec_linux.go#L669: uintptr(unsafe.Pointer(argv0)),
exec_linux.go#L670: uintptr(unsafe.Pointer(&argv[0])),
exec_linux.go#L671: uintptr(unsafe.Pointer(&envv[0])))
exec_linux.go#L675: RawSyscall(SYS_WRITE, uintptr(pipe), uintptr(unsafe.Pointer(&err1)), unsafe.Sizeof(err1))
exec_linux.go#L832: _, _, errno = Syscall6(SYS_WAITID, _P_PIDFD, uintptr(pidfd), uintptr(unsafe.Pointer(&info)), WEXITED|WCLONE, 0, 0)
exec_linux.go#L856: pid, errno = rawVforkSyscall(SYS_CLONE, 0, flags, uintptr(unsafe.Pointer(pidfd)))
exec_linux.go#L858: pid, errno = rawVforkSyscall(SYS_CLONE, flags, 0, uintptr(unsafe.Pointer(pidfd)))
exec_unix.go#L220: n, err = readlen(p[0], (*byte)(unsafe.Pointer(&err1)), int(unsafe.Sizeof(err1)))
exec_unix.go#L299: uintptr(unsafe.Pointer(argv0p)),
exec_unix.go#L300: uintptr(unsafe.Pointer(&argvp[0])),
exec_unix.go#L301: uintptr(unsafe.Pointer(&envvp[0])))
flock_linux.go#L15: _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))
lsf_linux.go#L32: p := (*[2]byte)(unsafe.Pointer(&lsall.Protocol))
lsf_linux.go#L58: _, _, ep := Syscall(SYS_IOCTL, uintptr(s), SIOCGIFFLAGS, uintptr(unsafe.Pointer(&ifl)))
lsf_linux.go#L67: _, _, ep = Syscall(SYS_IOCTL, uintptr(s), SIOCSIFFLAGS, uintptr(unsafe.Pointer(&ifl)))
lsf_linux.go#L78: p.Filter = (*SockFilter)(unsafe.Pointer(&i[0]))
lsf_linux.go#L79: return setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, unsafe.Pointer(&p), unsafe.Sizeof(p))
lsf_linux.go#L85: return setsockopt(fd, SOL_SOCKET, SO_DETACH_FILTER, unsafe.Pointer(&dummy), unsafe.Sizeof(dummy))
netlink_linux.go#L34: *(*uint32)(unsafe.Pointer(&b[0:4][0])) = rr.Header.Len
netlink_linux.go#L35: *(*uint16)(unsafe.Pointer(&b[4:6][0])) = rr.Header.Type
netlink_linux.go#L36: *(*uint16)(unsafe.Pointer(&b[6:8][0])) = rr.Header.Flags
netlink_linux.go#L37: *(*uint32)(unsafe.Pointer(&b[8:12][0])) = rr.Header.Seq
netlink_linux.go#L38: *(*uint32)(unsafe.Pointer(&b[12:16][0])) = rr.Header.Pid
netlink_linux.go#L140: h := (*NlMsghdr)(unsafe.Pointer(&b[0]))
netlink_linux.go#L183: a := (*RtAttr)(unsafe.Pointer(&b[0]))
sockcmsg_linux.go#L16: h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
sockcmsg_linux.go#L37: ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0]))
sockcmsg_unix.go#L27: func (h *Cmsghdr) data(offset uintptr) unsafe.Pointer {
sockcmsg_unix.go#L28: return unsafe.Pointer(uintptr(unsafe.Pointer(h)) + uintptr(cmsgAlignOf(SizeofCmsghdr)) + offset)
sockcmsg_unix.go#L55: h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
sockcmsg_unix.go#L67: h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
sockcmsg_unix.go#L88: fds[j] = int(*(*int32)(unsafe.Pointer(&m.Data[i])))
syscall_linux.go#L146: _, _, err := RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(&c.hdr)), uintptr(unsafe.Pointer(&c.data[0])), 0)
syscall_linux.go#L342: return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_linux.go#L351: return utimensat(_AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
syscall_linux.go#L358: return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_linux.go#L417: var cgo_libc_setgroups unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L439: if _, _, e1 := AllThreadsSyscall(_SYS_setgroups, n, uintptr(unsafe.Pointer(&a[0])), 0); e1 != 0 {
syscall_linux.go#L444: if ret := cgocaller(cgo_libc_setgroups, n, uintptr(unsafe.Pointer(&a[0]))); ret != 0 {
syscall_linux.go#L522: func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L527: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_linux.go#L531: return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
syscall_linux.go#L534: func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L539: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_linux.go#L544: return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
syscall_linux.go#L547: func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L578: return unsafe.Pointer(&sa.raw), sl, nil
syscall_linux.go#L591: func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L602: return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
syscall_linux.go#L613: func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L618: return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
syscall_linux.go#L624: pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
syscall_linux.go#L633: pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
syscall_linux.go#L644: pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
syscall_linux.go#L664: sa.Name = string(unsafe.Slice((*byte)(unsafe.Pointer(&pp.Path[0])), n))
syscall_linux.go#L668: pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
syscall_linux.go#L670: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_linux.go#L676: pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
syscall_linux.go#L678: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_linux.go#L720: err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
syscall_linux.go#L727: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L734: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L741: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L748: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L755: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L762: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L767: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
syscall_linux.go#L772: msg.Name = (*byte)(unsafe.Pointer(rsa))
syscall_linux.go#L806: func sendmsgN(fd int, p, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
syscall_linux.go#L867: err = ptracePtr(req, pid, addr-addr%sizeofPtr, unsafe.Pointer(&buf[0]))
syscall_linux.go#L879: err = ptracePtr(req, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
syscall_linux.go#L907: err = ptracePtr(peekReq, pid, addr-addr%sizeofPtr, unsafe.Pointer(&buf[0]))
syscall_linux.go#L912: word := *((*uintptr)(unsafe.Pointer(&buf[0])))
syscall_linux.go#L922: word := *((*uintptr)(unsafe.Pointer(&data[0])))
syscall_linux.go#L934: err = ptracePtr(peekReq, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
syscall_linux.go#L939: word := *((*uintptr)(unsafe.Pointer(&buf[0])))
syscall_linux.go#L964: iov.Base = (*byte)(unsafe.Pointer(regsout))
syscall_linux.go#L966: return ptracePtr(PTRACE_GETREGSET, pid, uintptr(_NT_PRSTATUS), unsafe.Pointer(&iov))
syscall_linux.go#L971: iov.Base = (*byte)(unsafe.Pointer(regs))
syscall_linux.go#L973: return ptracePtr(PTRACE_SETREGSET, pid, uintptr(_NT_PRSTATUS), unsafe.Pointer(&iov))
syscall_linux.go#L982: err = ptracePtr(PTRACE_GETEVENTMSG, pid, 0, unsafe.Pointer(&data))
syscall_linux.go#L1146: func cgocaller(unsafe.Pointer, ...uintptr) uintptr
syscall_linux.go#L1148: var cgo_libc_setegid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1163: var cgo_libc_seteuid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1176: var cgo_libc_setgid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1189: var cgo_libc_setregid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1202: var cgo_libc_setresgid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1215: var cgo_libc_setresuid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1228: var cgo_libc_setreuid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1241: var cgo_libc_setuid unsafe.Pointer // non-nil if cgo linked.
syscall_unix.go#L62: b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), length)
syscall_unix.go#L87: if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
syscall_unix.go#L186: race.WriteRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L189: race.Acquire(unsafe.Pointer(&ioSync))
syscall_unix.go#L193: msan.Write(unsafe.Pointer(&p[0]), uintptr(n))
syscall_unix.go#L196: asan.Write(unsafe.Pointer(&p[0]), uintptr(n))
syscall_unix.go#L203: race.ReleaseMerge(unsafe.Pointer(&ioSync))
syscall_unix.go#L214: race.ReadRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L217: msan.Read(unsafe.Pointer(&p[0]), uintptr(n))
syscall_unix.go#L220: asan.Read(unsafe.Pointer(&p[0]), uintptr(n))
syscall_unix.go#L229: race.WriteRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L232: race.Acquire(unsafe.Pointer(&ioSync))
syscall_unix.go#L236: msan.Write(unsafe.Pointer(&p[0]), uintptr(n))
syscall_unix.go#L239: asan.Write(unsafe.Pointer(&p[0]), uintptr(n))
syscall_unix.go#L246: race.ReleaseMerge(unsafe.Pointer(&ioSync))
syscall_unix.go#L250: race.ReadRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L253: msan.Read(unsafe.Pointer(&p[0]), uintptr(n))
syscall_unix.go#L256: asan.Read(unsafe.Pointer(&p[0]), uintptr(n))
syscall_unix.go#L266: sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
syscall_unix.go#L315: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L337: pp := (*RawSockaddrInet4)(unsafe.Pointer(&rsa))
syscall_unix.go#L338: port := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_unix.go#L350: pp := (*RawSockaddrInet6)(unsafe.Pointer(&rsa))
syscall_unix.go#L351: port := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_unix.go#L364: pp := (*RawSockaddrInet4)(unsafe.Pointer(&rsa))
syscall_unix.go#L365: port := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_unix.go#L377: pp := (*RawSockaddrInet6)(unsafe.Pointer(&rsa))
syscall_unix.go#L378: port := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_unix.go#L401: var ptr unsafe.Pointer
syscall_unix.go#L413: var ptr unsafe.Pointer
syscall_unix.go#L425: var ptr unsafe.Pointer
syscall_unix.go#L454: ptr unsafe.Pointer
syscall_unix.go#L467: return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
syscall_unix.go#L472: return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
syscall_unix.go#L476: return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
syscall_unix.go#L480: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
syscall_unix.go#L484: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
syscall_unix.go#L488: return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
syscall_unix.go#L492: return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
syscall_unix.go#L496: var p unsafe.Pointer
syscall_unix.go#L498: p = unsafe.Pointer(&[]byte(s)[0])
syscall_unix.go#L504: return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
syscall_unix.go#L527: race.ReleaseMerge(unsafe.Pointer(&ioSync))
zsyscall_linux_amd64.go#L18: _, _, e1 := Syscall(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_linux_amd64.go#L33: _, _, e1 := Syscall6(_SYS_faccessat2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
zsyscall_linux_amd64.go#L48: _, _, e1 := Syscall(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_linux_amd64.go#L63: _, _, e1 := Syscall6(_SYS_fchmodat2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
zsyscall_linux_amd64.go#L83: _, _, e1 := Syscall6(SYS_LINKAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
zsyscall_linux_amd64.go#L98: r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
zsyscall_linux_amd64.go#L109: _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
zsyscall_linux_amd64.go#L124: var _p1 unsafe.Pointer
zsyscall_linux_amd64.go#L126: _p1 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L128: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L130: r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
zsyscall_linux_amd64.go#L151: _, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
zsyscall_linux_amd64.go#L166: _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
zsyscall_linux_amd64.go#L181: _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
zsyscall_linux_amd64.go#L191: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L193: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L195: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L208: r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
zsyscall_linux_amd64.go#L228: func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) {
zsyscall_linux_amd64.go#L244: _, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux_amd64.go#L269: _, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0)
zsyscall_linux_amd64.go#L284: _, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux_amd64.go#L294: r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0)
zsyscall_linux_amd64.go#L310: _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux_amd64.go#L325: _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux_amd64.go#L377: _, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
zsyscall_linux_amd64.go#L422: _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
zsyscall_linux_amd64.go#L473: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L475: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L477: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L528: _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
zsyscall_linux_amd64.go#L556: var _p2 unsafe.Pointer
zsyscall_linux_amd64.go#L558: _p2 = unsafe.Pointer(&dest[0])
zsyscall_linux_amd64.go#L560: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L562: r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
zsyscall_linux_amd64.go#L578: r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
zsyscall_linux_amd64.go#L621: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L623: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L625: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L643: var _p1 unsafe.Pointer
zsyscall_linux_amd64.go#L645: _p1 = unsafe.Pointer(&dest[0])
zsyscall_linux_amd64.go#L647: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L649: r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
zsyscall_linux_amd64.go#L665: _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_linux_amd64.go#L680: _, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
zsyscall_linux_amd64.go#L690: _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
zsyscall_linux_amd64.go#L710: _, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_linux_amd64.go#L720: _, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old)), 0, 0)
zsyscall_linux_amd64.go#L730: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L732: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L734: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L757: _, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_linux_amd64.go#L767: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L769: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L771: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L783: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L785: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L787: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L820: _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
zsyscall_linux_amd64.go#L850: var _p2 unsafe.Pointer
zsyscall_linux_amd64.go#L852: _p2 = unsafe.Pointer(&data[0])
zsyscall_linux_amd64.go#L854: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L856: _, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
zsyscall_linux_amd64.go#L873: _, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0)
zsyscall_linux_amd64.go#L904: r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
zsyscall_linux_amd64.go#L923: _, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0)
zsyscall_linux_amd64.go#L938: _, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_linux_amd64.go#L958: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L960: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L962: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L985: r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
zsyscall_linux_amd64.go#L1006: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1008: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux_amd64.go#L1010: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1022: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1024: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux_amd64.go#L1026: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1038: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1040: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux_amd64.go#L1042: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1054: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1056: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux_amd64.go#L1058: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1110: _, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_linux_amd64.go#L1120: _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L1223: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1225: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L1227: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1240: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1242: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L1244: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1267: _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
zsyscall_linux_amd64.go#L1288: r0, _, e1 := Syscall6(SYS_SELECT, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
zsyscall_linux_amd64.go#L1299: r0, _, e1 := Syscall6(SYS_SENDFILE, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
zsyscall_linux_amd64.go#L1340: r0, _, e1 := Syscall6(SYS_SPLICE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
zsyscall_linux_amd64.go#L1356: _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L1381: _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
zsyscall_linux_amd64.go#L1391: _, _, e1 := Syscall(SYS_USTAT, uintptr(dev), uintptr(unsafe.Pointer(ubuf)), 0)
zsyscall_linux_amd64.go#L1401: r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
zsyscall_linux_amd64.go#L1411: func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L1421: func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L1437: _, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
zsyscall_linux_amd64.go#L1447: r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
zsyscall_linux_amd64.go#L1457: func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
zsyscall_linux_amd64.go#L1458: _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
zsyscall_linux_amd64.go#L1467: func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
zsyscall_linux_amd64.go#L1489: _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
zsyscall_linux_amd64.go#L1499: _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_linux_amd64.go#L1509: _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_linux_amd64.go#L1519: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1521: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L1523: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1525: r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
zsyscall_linux_amd64.go#L1535: func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L1536: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1538: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L1540: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1552: r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_linux_amd64.go#L1563: r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_linux_amd64.go#L1585: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1587: _p0 = unsafe.Pointer(&events[0])
zsyscall_linux_amd64.go#L1589: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1607: _, _, e1 := Syscall(SYS_FUTIMESAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)))
zsyscall_linux_amd64.go#L1622: _, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L1637: _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0)
time
sleep.go#L22: func syncTimer(c chan Time) unsafe.Pointer {
sleep.go#L45: return *(*unsafe.Pointer)(unsafe.Pointer(&c))
sleep.go#L72: func newTimer(when, period int64, f func(any, uintptr, int64), arg any, cp unsafe.Pointer) *Timer
tick.go#L44: t := (*Ticker)(unsafe.Pointer(newTimer(when(d), int64(d), sendTime, c, syncTimer(c))))
tick.go#L59: stopTimer((*Timer)(unsafe.Pointer(t)))
tick.go#L72: resetTimer((*Timer)(unsafe.Pointer(t)), when(d), int64(d))
unique
canonmap.go#L22: hash func(unsafe.Pointer, uintptr) uintptr
canonmap.go#L38: hash := m.hash(abi.NoEscape(unsafe.Pointer(&key)), m.seed)
canonmap.go#L59: hash := m.hash(abi.NoEscape(unsafe.Pointer(&key)), m.seed)
canonmap.go#L265: return (*entry[T])(unsafe.Pointer(n))
canonmap.go#L272: return (*indirect[T])(unsafe.Pointer(n))
clone.go#L23: ps := (*string)(unsafe.Pointer(uintptr(unsafe.Pointer(&value)) + offset))
handle.go#L37: return Handle[T]{(*T)(unsafe.Pointer(&zero))}
vendor/golang.org/x/crypto/internal/alias
alias.go#L16: uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
alias.go#L17: uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))
weak
pointer.go#L64: u unsafe.Pointer
pointer.go#L72: var u unsafe.Pointer
pointer.go#L74: u = runtime_registerWeakPointer(unsafe.Pointer(ptr))
pointer.go#L95: func runtime_registerWeakPointer(unsafe.Pointer) unsafe.Pointer
pointer.go#L98: func runtime_makeStrongFromWeak(unsafe.Pointer) unsafe.Pointer
 |
The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |