type unsafe.Pointer
2786 uses
unsafe (current package)
unsafe.go#L184: type Pointer *ArbitraryType
crypto/internal/subtle
aliasing.go#L19: uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
aliasing.go#L20: uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))
github.com/go-pg/pg/v10/internal
unsafe.go#L12: return *(*string)(unsafe.Pointer(&b))
unsafe.go#L17: return *(*[]byte)(unsafe.Pointer(
github.com/google/go-cmp/cmp
export_unsafe.go#L24: ve := reflect.NewAt(f.Type, unsafe.Pointer(uintptr(unsafe.Pointer(v.UnsafeAddr()))+f.Offset)).Elem()
github.com/google/go-cmp/cmp/internal/value
pointer_unsafe.go#L17: p unsafe.Pointer
pointer_unsafe.go#L26: return Pointer{unsafe.Pointer(v.Pointer()), v.Type()}
github.com/valyala/fastjson
util.go#L9: return *(*string)(unsafe.Pointer(&b))
util.go#L13: strh := (*reflect.StringHeader)(unsafe.Pointer(&s))
util.go#L14: sh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
github.com/vmihailenco/msgpack/v5
unsafe.go#L11: return *(*string)(unsafe.Pointer(&b))
unsafe.go#L16: return *(*[]byte)(unsafe.Pointer(
github.com/vmihailenco/tagparser/internal
unsafe.go#L11: return *(*string)(unsafe.Pointer(&b))
unsafe.go#L16: return *(*[]byte)(unsafe.Pointer(
github.com/vmihailenco/tagparser/v2/internal
unsafe.go#L11: return *(*string)(unsafe.Pointer(&b))
unsafe.go#L16: return *(*[]byte)(unsafe.Pointer(
go.uber.org/atomic
pointer_go118.go#L37: p.p.Store(unsafe.Pointer(v))
pointer_go118.go#L49: p.p.Store(unsafe.Pointer(val))
pointer_go118.go#L54: return (*T)(p.p.Swap(unsafe.Pointer(val)))
pointer_go118.go#L59: return p.p.CompareAndSwap(unsafe.Pointer(old), unsafe.Pointer(new))
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/sha3
xor_unaligned.go#L17: return (*[maxRate]byte)(unsafe.Pointer(b))
xor_unaligned.go#L24: bw := (*[maxRate / 8]uint64)(unsafe.Pointer(&buf[0]))[: n/8 : n/8]
xor_unaligned.go#L59: ab := (*[maxRate]uint8)(unsafe.Pointer(&d.a[0]))
golang.org/x/sys/execabs
execabs.go#L71: lookPathErr := (*error)(unsafe.Pointer(reflect.ValueOf(cmd).Elem().FieldByName("lookPathErr").Addr().Pointer()))
golang.org/x/sys/unix
affinity_linux.go#L20: _, _, e := RawSyscall(trap, uintptr(pid), uintptr(unsafe.Sizeof(*set)), uintptr(unsafe.Pointer(set)))
fcntl.go#L32: _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))
ifreq_linux.go#L58: raw := *(*RawSockaddrInet4)(unsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]))
ifreq_linux.go#L80: unsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]),
ifreq_linux.go#L92: return *(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0]))
ifreq_linux.go#L98: *(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0])) = v
ifreq_linux.go#L103: return *(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0]))
ifreq_linux.go#L109: *(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0])) = v
ifreq_linux.go#L130: data unsafe.Pointer
ifreq_linux.go#L137: func (ifr Ifreq) withData(p unsafe.Pointer) ifreqData {
ioctl.go#L30: return ioctl(fd, req, uintptr(unsafe.Pointer(&v)))
ioctl.go#L39: err := ioctl(fd, req, uintptr(unsafe.Pointer(value)))
ioctl.go#L49: err := ioctl(fd, req, uintptr(unsafe.Pointer(value)))
ioctl.go#L61: err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
ioctl.go#L67: err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
ioctl.go#L73: err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
ioctl_linux.go#L22: err := ioctlPtr(fd, req, unsafe.Pointer(&value))
ioctl_linux.go#L28: err := ioctlPtr(fd, RTC_RD_TIME, unsafe.Pointer(&value))
ioctl_linux.go#L33: return ioctlPtr(fd, RTC_SET_TIME, unsafe.Pointer(value))
ioctl_linux.go#L38: err := ioctlPtr(fd, RTC_WKALM_RD, unsafe.Pointer(&value))
ioctl_linux.go#L43: return ioctlPtr(fd, RTC_WKALM_SET, unsafe.Pointer(value))
ioctl_linux.go#L55: ifrd := ifr.withData(unsafe.Pointer(&value))
ioctl_linux.go#L66: err := ioctlPtr(fd, WDIOC_GETSUPPORT, unsafe.Pointer(&value))
ioctl_linux.go#L82: return ioctlPtr(destFd, FICLONERANGE, unsafe.Pointer(value))
ioctl_linux.go#L115: rawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))
ioctl_linux.go#L123: rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
ioctl_linux.go#L124: uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
ioctl_linux.go#L133: err := ioctlPtr(srcFd, FIDEDUPERANGE, unsafe.Pointer(&buf[0]))
ioctl_linux.go#L137: rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
ioctl_linux.go#L138: uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
ioctl_linux.go#L151: return ioctlPtr(fd, HIDIOCGRDESC, unsafe.Pointer(value))
ioctl_linux.go#L156: err := ioctlPtr(fd, HIDIOCGRAWINFO, unsafe.Pointer(&value))
ioctl_linux.go#L162: err := ioctlPtr(fd, _HIDIOCGRAWNAME, unsafe.Pointer(&value[0]))
ioctl_linux.go#L168: err := ioctlPtr(fd, _HIDIOCGRAWPHYS, unsafe.Pointer(&value[0]))
ioctl_linux.go#L174: err := ioctlPtr(fd, _HIDIOCGRAWUNIQ, unsafe.Pointer(&value[0]))
ioctl_linux.go#L183: return ioctlPtr(fd, req, unsafe.Pointer(&value.raw))
ioctl_linux.go#L193: return ioctlPtr(fd, req, unsafe.Pointer(value))
ioctl_linux.go#L201: if err := ioctlPtr(fd, SIOCKCMCLONE, unsafe.Pointer(&info)); err != nil {
ioctl_linux.go#L211: return ioctlPtr(fd, SIOCKCMATTACH, unsafe.Pointer(&info))
ioctl_linux.go#L216: return ioctlPtr(fd, SIOCKCMUNATTACH, unsafe.Pointer(&info))
ioctl_linux.go#L223: if err := ioctlPtr(fd, LOOP_GET_STATUS64, unsafe.Pointer(&value)); err != nil {
ioctl_linux.go#L232: return ioctlPtr(fd, LOOP_SET_STATUS64, unsafe.Pointer(value))
race0.go#L16: func raceAcquire(addr unsafe.Pointer) {
race0.go#L19: func raceReleaseMerge(addr unsafe.Pointer) {
race0.go#L22: func raceReadRange(addr unsafe.Pointer, len int) {
race0.go#L25: func raceWriteRange(addr unsafe.Pointer, len int) {
sockcmsg_linux.go#L16: h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
sockcmsg_linux.go#L34: ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0]))
sockcmsg_linux.go#L41: h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
sockcmsg_linux.go#L52: h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
sockcmsg_linux.go#L66: pp := (*RawSockaddrInet4)(unsafe.Pointer(&m.Data[0]))
sockcmsg_linux.go#L68: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
sockcmsg_linux.go#L74: pp := (*RawSockaddrInet6)(unsafe.Pointer(&m.Data[0]))
sockcmsg_linux.go#L76: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
sockcmsg_unix.go#L28: func (h *Cmsghdr) data(offset uintptr) unsafe.Pointer {
sockcmsg_unix.go#L29: return unsafe.Pointer(uintptr(unsafe.Pointer(h)) + uintptr(cmsgAlignOf(SizeofCmsghdr)) + offset)
sockcmsg_unix.go#L70: h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
sockcmsg_unix.go#L82: h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
sockcmsg_unix.go#L103: fds[j] = int(*(*int32)(unsafe.Pointer(&m.Data[i])))
syscall.go#L79: for ptr := unsafe.Pointer(p); *(*byte)(ptr) != 0; n++ {
syscall.go#L80: ptr = unsafe.Pointer(uintptr(ptr) + 1)
syscall_linux.go#L201: err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
syscall_linux.go#L205: return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_linux.go#L221: return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
syscall_linux.go#L231: return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_linux.go#L380: func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L385: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_linux.go#L389: return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
syscall_linux.go#L392: func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L397: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_linux.go#L402: return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
syscall_linux.go#L405: func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L426: return unsafe.Pointer(&sa.raw), sl, nil
syscall_linux.go#L440: func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L451: return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
syscall_linux.go#L463: func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L468: return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
syscall_linux.go#L479: func (sa *SockaddrHCI) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L483: return unsafe.Pointer(&sa.raw), SizeofSockaddrHCI, nil
syscall_linux.go#L496: func (sa *SockaddrL2) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L498: psm := (*[2]byte)(unsafe.Pointer(&sa.raw.Psm))
syscall_linux.go#L504: cid := (*[2]byte)(unsafe.Pointer(&sa.raw.Cid))
syscall_linux.go#L508: return unsafe.Pointer(&sa.raw), SizeofSockaddrL2, nil
syscall_linux.go#L545: func (sa *SockaddrRFCOMM) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L549: return unsafe.Pointer(&sa.raw), SizeofSockaddrRFCOMM, nil
syscall_linux.go#L576: func (sa *SockaddrCAN) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L582: rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
syscall_linux.go#L586: tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
syscall_linux.go#L590: return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
syscall_linux.go#L605: func (sa *SockaddrCANJ1939) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L611: n := (*[8]byte)(unsafe.Pointer(&sa.Name))
syscall_linux.go#L615: p := (*[4]byte)(unsafe.Pointer(&sa.PGN))
syscall_linux.go#L620: return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
syscall_linux.go#L694: func (sa *SockaddrALG) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L719: return unsafe.Pointer(&sa.raw), SizeofSockaddrALG, nil
syscall_linux.go#L738: func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L744: return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
syscall_linux.go#L755: func (sa *SockaddrXDP) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L762: return unsafe.Pointer(&sa.raw), SizeofSockaddrXDP, nil
syscall_linux.go#L781: func (sa *SockaddrPPPoE) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L789: *(*uint16)(unsafe.Pointer(&sa.raw[0])) = AF_PPPOX
syscall_linux.go#L807: return unsafe.Pointer(&sa.raw), SizeofSockaddrPPPoX, nil
syscall_linux.go#L839: copy(out[:], (*(*[unsafe.Sizeof(TIPCSocketAddr{})]byte)(unsafe.Pointer(sa)))[:])
syscall_linux.go#L847: copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceRange{})]byte)(unsafe.Pointer(sa)))[:])
syscall_linux.go#L855: copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceName{})]byte)(unsafe.Pointer(sa)))[:])
syscall_linux.go#L861: func (sa *SockaddrTIPC) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L869: return unsafe.Pointer(&sa.raw), SizeofSockaddrTIPC, nil
syscall_linux.go#L879: func (sa *SockaddrL2TPIP) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L883: return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP, nil
syscall_linux.go#L894: func (sa *SockaddrL2TPIP6) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L899: return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP6, nil
syscall_linux.go#L909: func (sa *SockaddrIUCV) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L928: return unsafe.Pointer(&sa.raw), SizeofSockaddrIUCV, nil
syscall_linux.go#L938: func (sa *SockaddrNFC) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L943: return unsafe.Pointer(&sa.raw), SizeofSockaddrNFC, nil
syscall_linux.go#L956: func (sa *SockaddrNFCLLCP) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L968: return unsafe.Pointer(&sa.raw), SizeofSockaddrNFCLLCP, nil
syscall_linux.go#L978: pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
syscall_linux.go#L987: pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
syscall_linux.go#L998: pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
syscall_linux.go#L1018: bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
syscall_linux.go#L1030: pp := (*RawSockaddrL2TPIP)(unsafe.Pointer(rsa))
syscall_linux.go#L1036: pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
syscall_linux.go#L1038: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_linux.go#L1052: pp := (*RawSockaddrL2TPIP6)(unsafe.Pointer(rsa))
syscall_linux.go#L1059: pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
syscall_linux.go#L1061: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_linux.go#L1069: pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
syscall_linux.go#L1084: pp := (*RawSockaddrL2)(unsafe.Pointer(rsa))
syscall_linux.go#L1093: pp := (*RawSockaddrRFCOMM)(unsafe.Pointer(rsa))
syscall_linux.go#L1101: pp := (*RawSockaddrXDP)(unsafe.Pointer(rsa))
syscall_linux.go#L1110: pp := (*RawSockaddrPPPoX)(unsafe.Pointer(rsa))
syscall_linux.go#L1126: pp := (*RawSockaddrTIPC)(unsafe.Pointer(rsa))
syscall_linux.go#L1136: sa.Addr = (*TIPCServiceRange)(unsafe.Pointer(&pp.Addr))
syscall_linux.go#L1138: sa.Addr = (*TIPCServiceName)(unsafe.Pointer(&pp.Addr))
syscall_linux.go#L1140: sa.Addr = (*TIPCSocketAddr)(unsafe.Pointer(&pp.Addr))
syscall_linux.go#L1147: pp := (*RawSockaddrIUCV)(unsafe.Pointer(rsa))
syscall_linux.go#L1169: pp := (*RawSockaddrCAN)(unsafe.Pointer(rsa))
syscall_linux.go#L1176: name := (*[8]byte)(unsafe.Pointer(&sa.Name))
syscall_linux.go#L1180: pgn := (*[4]byte)(unsafe.Pointer(&sa.PGN))
syscall_linux.go#L1184: addr := (*[1]byte)(unsafe.Pointer(&sa.Addr))
syscall_linux.go#L1191: rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
syscall_linux.go#L1195: tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
syscall_linux.go#L1208: pp := (*RawSockaddrNFC)(unsafe.Pointer(rsa))
syscall_linux.go#L1216: pp := (*RawSockaddrNFCLLCP)(unsafe.Pointer(rsa))
syscall_linux.go#L1281: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L1288: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L1295: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L1304: err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
syscall_linux.go#L1308: err = getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
syscall_linux.go#L1320: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L1327: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L1332: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
syscall_linux.go#L1336: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
syscall_linux.go#L1342: return setsockopt(fd, level, opt, unsafe.Pointer(fprog), unsafe.Sizeof(*fprog))
syscall_linux.go#L1346: var p unsafe.Pointer
syscall_linux.go#L1348: p = unsafe.Pointer(&filter[0])
syscall_linux.go#L1354: return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
syscall_linux.go#L1358: return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
syscall_linux.go#L1365: return setsockopt(fd, level, opt, unsafe.Pointer(&o[0]), uintptr(SizeofTCPRepairOpt*len(o)))
syscall_linux.go#L1505: msg.Name = (*byte)(unsafe.Pointer(rsa))
syscall_linux.go#L1538: func sendmsgN(fd int, iov []Iovec, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
syscall_linux.go#L1599: err = ptrace(req, pid, addr-addr%SizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
syscall_linux.go#L1611: err = ptrace(req, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
syscall_linux.go#L1643: err = ptrace(peekReq, pid, addr-addr%SizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
syscall_linux.go#L1648: word := *((*uintptr)(unsafe.Pointer(&buf[0])))
syscall_linux.go#L1658: word := *((*uintptr)(unsafe.Pointer(&data[0])))
syscall_linux.go#L1670: err = ptrace(peekReq, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
syscall_linux.go#L1675: word := *((*uintptr)(unsafe.Pointer(&buf[0])))
syscall_linux.go#L1699: return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
syscall_linux.go#L1703: return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
syscall_linux.go#L1712: err = ptrace(PTRACE_GETEVENTMSG, pid, 0, uintptr(unsafe.Pointer(&data)))
syscall_linux.go#L1784: raceReleaseMerge(unsafe.Pointer(&ioSync))
syscall_linux.go#L1993: v.Base = (*byte)(unsafe.Pointer(&_zero))
syscall_linux.go#L2043: raceWriteRange(unsafe.Pointer(iovecs[i].Base), m)
syscall_linux.go#L2047: raceAcquire(unsafe.Pointer(&ioSync))
syscall_linux.go#L2055: raceReleaseMerge(unsafe.Pointer(&ioSync))
syscall_linux.go#L2066: raceReleaseMerge(unsafe.Pointer(&ioSync))
syscall_linux.go#L2078: raceReleaseMerge(unsafe.Pointer(&ioSync))
syscall_linux.go#L2097: raceReadRange(unsafe.Pointer(iovecs[i].Base), m)
syscall_linux.go#L2130: var p unsafe.Pointer
syscall_linux.go#L2132: p = unsafe.Pointer(&iovs[0])
syscall_linux.go#L2258: fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
syscall_linux.go#L2271: return unsafe.Slice((*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(&fh.fileHandle.Type))+4)), n)
syscall_linux.go#L2284: fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
syscall_linux.go#L2312: var p unsafe.Pointer
syscall_unix.go#L118: b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), length)
syscall_unix.go#L143: if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
syscall_unix.go#L154: raceWriteRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L157: raceAcquire(unsafe.Pointer(&ioSync))
syscall_unix.go#L165: raceReleaseMerge(unsafe.Pointer(&ioSync))
syscall_unix.go#L169: raceReadRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L178: raceWriteRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L181: raceAcquire(unsafe.Pointer(&ioSync))
syscall_unix.go#L189: raceReleaseMerge(unsafe.Pointer(&ioSync))
syscall_unix.go#L193: raceReadRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L204: sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
syscall_unix.go#L256: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L263: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L269: err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
syscall_unix.go#L276: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_unix.go#L283: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_unix.go#L290: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_unix.go#L297: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_unix.go#L304: err := getsockopt(fd, level, opt, unsafe.Pointer(&linger), &vallen)
syscall_unix.go#L311: err := getsockopt(fd, level, opt, unsafe.Pointer(&tv), &vallen)
syscall_unix.go#L318: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L372: iov[i].Base = (*byte)(unsafe.Pointer(&_zero))
syscall_unix.go#L421: var ptr unsafe.Pointer
syscall_unix.go#L442: iov[i].Base = (*byte)(unsafe.Pointer(&_zero))
syscall_unix.go#L445: var ptr unsafe.Pointer
syscall_unix.go#L461: var ptr unsafe.Pointer
syscall_unix.go#L473: return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
syscall_unix.go#L478: return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
syscall_unix.go#L482: return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
syscall_unix.go#L486: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
syscall_unix.go#L490: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
syscall_unix.go#L494: return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
syscall_unix.go#L498: return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
syscall_unix.go#L502: var p unsafe.Pointer
syscall_unix.go#L504: p = unsafe.Pointer(&[]byte(s)[0])
syscall_unix.go#L510: return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
syscall_unix.go#L514: return setsockopt(fd, level, opt, unsafe.Pointer(&value), 8)
sysvshm_unix.go#L33: b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), int(info.Segsz))
sysvshm_unix.go#L45: return shmdt(uintptr(unsafe.Pointer(&data[0])))
zptrace_x86_linux.go#L34: return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
zptrace_x86_linux.go#L39: return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
zptrace_x86_linux.go#L75: return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
zptrace_x86_linux.go#L80: return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
zsyscall_linux.go#L32: _, _, e1 := Syscall(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_linux.go#L51: func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
zsyscall_linux.go#L72: _, _, e1 := Syscall6(SYS_LINKAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
zsyscall_linux.go#L87: r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
zsyscall_linux.go#L103: r0, _, e1 := Syscall6(SYS_OPENAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(open_how)), uintptr(size), 0, 0)
zsyscall_linux.go#L114: _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
zsyscall_linux.go#L124: r0, _, e1 := Syscall6(SYS_PPOLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)), 0, 0)
zsyscall_linux.go#L140: var _p1 unsafe.Pointer
zsyscall_linux.go#L142: _p1 = unsafe.Pointer(&buf[0])
zsyscall_linux.go#L144: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L146: r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
zsyscall_linux.go#L167: _, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
zsyscall_linux.go#L182: _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
zsyscall_linux.go#L197: _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flags), 0, 0)
zsyscall_linux.go#L207: var _p0 unsafe.Pointer
zsyscall_linux.go#L209: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux.go#L211: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L224: r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
zsyscall_linux.go#L235: _, _, e1 := Syscall6(SYS_WAITID, uintptr(idType), uintptr(id), uintptr(unsafe.Pointer(info)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0)
zsyscall_linux.go#L256: var _p0 unsafe.Pointer
zsyscall_linux.go#L258: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux.go#L260: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L278: r0, _, e1 := Syscall(SYS_KEYCTL, uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0)
zsyscall_linux.go#L299: r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(arg5), 0)
zsyscall_linux.go#L310: var _p0 unsafe.Pointer
zsyscall_linux.go#L312: _p0 = unsafe.Pointer(&payload[0])
zsyscall_linux.go#L314: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L326: var _p0 unsafe.Pointer
zsyscall_linux.go#L328: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux.go#L330: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L332: r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(unsafe.Pointer(arg2)), uintptr(_p0), uintptr(len(buf)), 0, 0)
zsyscall_linux.go#L353: _, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0)
zsyscall_linux.go#L388: _, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux.go#L413: _, _, 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.go#L428: _, _, e1 := Syscall6(SYS_MOUNT_SETATTR, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(unsafe.Pointer(attr)), uintptr(size), 0)
zsyscall_linux.go#L443: _, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux.go#L463: var _p2 unsafe.Pointer
zsyscall_linux.go#L465: _p2 = unsafe.Pointer(&payload[0])
zsyscall_linux.go#L467: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L469: r0, _, e1 := Syscall6(SYS_ADD_KEY, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(payload)), uintptr(ringid), 0)
zsyscall_linux.go#L480: r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0)
zsyscall_linux.go#L491: _, _, e1 := RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(hdr)), uintptr(unsafe.Pointer(data)), 0)
zsyscall_linux.go#L501: _, _, e1 := RawSyscall(SYS_CAPSET, uintptr(unsafe.Pointer(hdr)), uintptr(unsafe.Pointer(data)), 0)
zsyscall_linux.go#L516: _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux.go#L531: _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux.go#L541: r0, _, e1 := Syscall(SYS_CLOCK_ADJTIME, uintptr(clockid), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux.go#L552: _, _, e1 := Syscall(SYS_CLOCK_GETRES, uintptr(clockid), uintptr(unsafe.Pointer(res)), 0)
zsyscall_linux.go#L562: _, _, e1 := Syscall(SYS_CLOCK_GETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
zsyscall_linux.go#L572: _, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0)
zsyscall_linux.go#L602: r0, _, e1 := Syscall6(SYS_COPY_FILE_RANGE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
zsyscall_linux.go#L618: _, _, e1 := Syscall(SYS_DELETE_MODULE, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_linux.go#L660: _, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
zsyscall_linux.go#L713: _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
zsyscall_linux.go#L738: var _p1 unsafe.Pointer
zsyscall_linux.go#L740: _p1 = unsafe.Pointer(&dest[0])
zsyscall_linux.go#L742: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L744: r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)), 0, 0)
zsyscall_linux.go#L760: _, _, e1 := Syscall(SYS_FINIT_MODULE, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
zsyscall_linux.go#L770: var _p0 unsafe.Pointer
zsyscall_linux.go#L772: _p0 = unsafe.Pointer(&dest[0])
zsyscall_linux.go#L774: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L802: _, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), 0)
zsyscall_linux.go#L817: var _p1 unsafe.Pointer
zsyscall_linux.go#L819: _p1 = unsafe.Pointer(&dest[0])
zsyscall_linux.go#L821: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L823: _, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)), uintptr(flags), 0)
zsyscall_linux.go#L859: r0, _, e1 := Syscall(SYS_FSOPEN, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_linux.go#L875: r0, _, e1 := Syscall(SYS_FSPICK, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
zsyscall_linux.go#L886: var _p0 unsafe.Pointer
zsyscall_linux.go#L888: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux.go#L890: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L941: var _p0 unsafe.Pointer
zsyscall_linux.go#L943: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux.go#L945: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L958: _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
zsyscall_linux.go#L997: var _p2 unsafe.Pointer
zsyscall_linux.go#L999: _p2 = unsafe.Pointer(&dest[0])
zsyscall_linux.go#L1001: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1003: r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
zsyscall_linux.go#L1014: var _p0 unsafe.Pointer
zsyscall_linux.go#L1016: _p0 = unsafe.Pointer(&moduleImage[0])
zsyscall_linux.go#L1018: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1025: _, _, e1 := Syscall(SYS_INIT_MODULE, uintptr(_p0), uintptr(len(moduleImage)), uintptr(unsafe.Pointer(_p1)))
zsyscall_linux.go#L1040: r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
zsyscall_linux.go#L1083: var _p0 unsafe.Pointer
zsyscall_linux.go#L1085: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux.go#L1087: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1110: var _p2 unsafe.Pointer
zsyscall_linux.go#L1112: _p2 = unsafe.Pointer(&dest[0])
zsyscall_linux.go#L1114: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1116: r0, _, e1 := Syscall6(SYS_LGETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
zsyscall_linux.go#L1132: var _p1 unsafe.Pointer
zsyscall_linux.go#L1134: _p1 = unsafe.Pointer(&dest[0])
zsyscall_linux.go#L1136: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1138: r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
zsyscall_linux.go#L1154: var _p1 unsafe.Pointer
zsyscall_linux.go#L1156: _p1 = unsafe.Pointer(&dest[0])
zsyscall_linux.go#L1158: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1160: r0, _, e1 := Syscall(SYS_LLISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
zsyscall_linux.go#L1181: _, _, e1 := Syscall(SYS_LREMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_linux.go#L1201: var _p2 unsafe.Pointer
zsyscall_linux.go#L1203: _p2 = unsafe.Pointer(&data[0])
zsyscall_linux.go#L1205: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1207: _, _, e1 := Syscall6(SYS_LSETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
zsyscall_linux.go#L1222: r0, _, e1 := Syscall(SYS_MEMFD_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_linux.go#L1238: _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_linux.go#L1253: _, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
zsyscall_linux.go#L1273: _, _, e1 := Syscall6(SYS_MOVE_MOUNT, uintptr(fromDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(toDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
zsyscall_linux.go#L1283: _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
zsyscall_linux.go#L1298: r0, _, e1 := Syscall(SYS_OPEN_TREE, uintptr(dfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
zsyscall_linux.go#L1309: r0, _, e1 := Syscall6(SYS_PERF_EVENT_OPEN, uintptr(unsafe.Pointer(attr)), uintptr(pid), uintptr(cpu), uintptr(groupFd), uintptr(flags), 0)
zsyscall_linux.go#L1330: _, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_linux.go#L1340: _, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old)), 0, 0)
zsyscall_linux.go#L1360: r0, _, e1 := Syscall6(SYS_PSELECT6, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)))
zsyscall_linux.go#L1371: var _p0 unsafe.Pointer
zsyscall_linux.go#L1373: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux.go#L1375: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1398: _, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_linux.go#L1418: _, _, e1 := Syscall6(SYS_RENAMEAT2, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
zsyscall_linux.go#L1443: r0, _, e1 := Syscall6(SYS_REQUEST_KEY, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(destRingid), 0, 0)
zsyscall_linux.go#L1454: var _p0 unsafe.Pointer
zsyscall_linux.go#L1456: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux.go#L1458: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1470: var _p0 unsafe.Pointer
zsyscall_linux.go#L1472: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux.go#L1474: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1507: _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
zsyscall_linux.go#L1547: var _p2 unsafe.Pointer
zsyscall_linux.go#L1549: _p2 = unsafe.Pointer(&data[0])
zsyscall_linux.go#L1551: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1553: _, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
zsyscall_linux.go#L1563: r0, _, e1 := Syscall6(SYS_SIGNALFD4, uintptr(fd), uintptr(unsafe.Pointer(sigmask)), uintptr(maskSize), uintptr(flags), 0, 0)
zsyscall_linux.go#L1579: _, _, e1 := Syscall6(SYS_STATX, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mask), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_linux.go#L1606: _, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0)
zsyscall_linux.go#L1627: _, _, e1 := RawSyscall(SYS_TIMERFD_GETTIME, uintptr(fd), uintptr(unsafe.Pointer(currValue)), 0)
zsyscall_linux.go#L1637: _, _, e1 := RawSyscall6(SYS_TIMERFD_SETTIME, uintptr(fd), uintptr(flags), uintptr(unsafe.Pointer(newValue)), uintptr(unsafe.Pointer(oldValue)), 0, 0)
zsyscall_linux.go#L1657: r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
zsyscall_linux.go#L1676: _, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0)
zsyscall_linux.go#L1691: _, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_linux.go#L1711: var _p0 unsafe.Pointer
zsyscall_linux.go#L1713: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux.go#L1715: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1738: r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
zsyscall_linux.go#L1749: r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
zsyscall_linux.go#L1760: var _p0 unsafe.Pointer
zsyscall_linux.go#L1762: _p0 = unsafe.Pointer(&iovs[0])
zsyscall_linux.go#L1764: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1777: var _p0 unsafe.Pointer
zsyscall_linux.go#L1779: _p0 = unsafe.Pointer(&iovs[0])
zsyscall_linux.go#L1781: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1794: var _p0 unsafe.Pointer
zsyscall_linux.go#L1796: _p0 = unsafe.Pointer(&iovs[0])
zsyscall_linux.go#L1798: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1811: var _p0 unsafe.Pointer
zsyscall_linux.go#L1813: _p0 = unsafe.Pointer(&iovs[0])
zsyscall_linux.go#L1815: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1828: var _p0 unsafe.Pointer
zsyscall_linux.go#L1830: _p0 = unsafe.Pointer(&iovs[0])
zsyscall_linux.go#L1832: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1845: var _p0 unsafe.Pointer
zsyscall_linux.go#L1847: _p0 = unsafe.Pointer(&iovs[0])
zsyscall_linux.go#L1849: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1872: var _p0 unsafe.Pointer
zsyscall_linux.go#L1874: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux.go#L1876: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1888: var _p0 unsafe.Pointer
zsyscall_linux.go#L1890: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux.go#L1892: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1904: var _p0 unsafe.Pointer
zsyscall_linux.go#L1906: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux.go#L1908: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1930: var _p0 unsafe.Pointer
zsyscall_linux.go#L1932: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux.go#L1934: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1946: var _p0 unsafe.Pointer
zsyscall_linux.go#L1948: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux.go#L1950: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L1977: _, _, e1 := Syscall(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_linux.go#L1992: _, _, e1 := Syscall6(SYS_FACCESSAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
zsyscall_linux.go#L2007: _, _, e1 := Syscall6(SYS_NAME_TO_HANDLE_AT, uintptr(dirFD), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(fh)), uintptr(unsafe.Pointer(mountID)), uintptr(flags), 0)
zsyscall_linux.go#L2017: r0, _, e1 := Syscall(SYS_OPEN_BY_HANDLE_AT, uintptr(mountFD), uintptr(unsafe.Pointer(fh)), uintptr(flags))
zsyscall_linux.go#L2028: var _p0 unsafe.Pointer
zsyscall_linux.go#L2030: _p0 = unsafe.Pointer(&localIov[0])
zsyscall_linux.go#L2032: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L2034: var _p1 unsafe.Pointer
zsyscall_linux.go#L2036: _p1 = unsafe.Pointer(&remoteIov[0])
zsyscall_linux.go#L2038: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L2051: var _p0 unsafe.Pointer
zsyscall_linux.go#L2053: _p0 = unsafe.Pointer(&localIov[0])
zsyscall_linux.go#L2055: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L2057: var _p1 unsafe.Pointer
zsyscall_linux.go#L2059: _p1 = unsafe.Pointer(&remoteIov[0])
zsyscall_linux.go#L2061: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux.go#L2096: _, _, e1 := Syscall6(SYS_PIDFD_SEND_SIGNAL, uintptr(pidfd), uintptr(sig), uintptr(unsafe.Pointer(info)), uintptr(flags), 0, 0)
zsyscall_linux.go#L2117: r0, _, e1 := Syscall(SYS_SHMCTL, uintptr(id), uintptr(cmd), uintptr(unsafe.Pointer(buf)))
zsyscall_linux.go#L2149: _, _, e1 := Syscall(SYS_GETITIMER, uintptr(which), uintptr(unsafe.Pointer(currValue)), 0)
zsyscall_linux.go#L2159: _, _, e1 := Syscall(SYS_SETITIMER, uintptr(which), uintptr(unsafe.Pointer(newValue)), uintptr(unsafe.Pointer(oldValue)))
zsyscall_linux.go#L2169: _, _, e1 := RawSyscall6(SYS_RT_SIGPROCMASK, uintptr(how), uintptr(unsafe.Pointer(set)), uintptr(unsafe.Pointer(oldset)), uintptr(sigsetsize), 0, 0)
zsyscall_linux_amd64.go#L19: _, _, e1 := Syscall6(SYS_FANOTIFY_MARK, uintptr(fd), uintptr(flags), uintptr(mask), uintptr(dirFd), uintptr(unsafe.Pointer(pathname)), 0)
zsyscall_linux_amd64.go#L50: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L52: _p0 = unsafe.Pointer(&events[0])
zsyscall_linux_amd64.go#L54: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L87: _, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_linux_amd64.go#L102: _, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
zsyscall_linux_amd64.go#L112: _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L156: _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
zsyscall_linux_amd64.go#L199: _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
zsyscall_linux_amd64.go#L240: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L242: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L244: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L257: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L259: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L261: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L284: _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
zsyscall_linux_amd64.go#L305: r0, _, e1 := Syscall6(SYS_SENDFILE, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
zsyscall_linux_amd64.go#L338: _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
zsyscall_linux_amd64.go#L358: 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#L374: _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L399: _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
zsyscall_linux_amd64.go#L409: _, _, e1 := Syscall(SYS_USTAT, uintptr(dev), uintptr(unsafe.Pointer(ubuf)), 0)
zsyscall_linux_amd64.go#L419: r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
zsyscall_linux_amd64.go#L429: func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L439: func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L450: r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
zsyscall_linux_amd64.go#L461: _, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
zsyscall_linux_amd64.go#L470: func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
zsyscall_linux_amd64.go#L471: _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
zsyscall_linux_amd64.go#L480: func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
zsyscall_linux_amd64.go#L502: _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
zsyscall_linux_amd64.go#L512: _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_linux_amd64.go#L522: _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_linux_amd64.go#L532: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L534: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L536: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L538: 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#L548: func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L549: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L551: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L553: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L565: r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_linux_amd64.go#L576: r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_linux_amd64.go#L603: _, _, e1 := Syscall(SYS_FUTIMESAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)))
zsyscall_linux_amd64.go#L618: _, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L633: _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0)
zsyscall_linux_amd64.go#L648: _, _, e1 := Syscall6(SYS_KEXEC_FILE_LOAD, uintptr(kernelFd), uintptr(initrdFd), uintptr(cmdlineLen), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
golang.org/x/tools/internal/event/core
export.go#L21: exporter unsafe.Pointer
export.go#L28: p := unsafe.Pointer(&e)
golang.org/x/tools/internal/event/label
label.go#L99: type stringptr unsafe.Pointer
label.go#L105: hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))
label.go#L119: hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))
golang.org/x/tools/internal/tokeninternal
tokeninternal.go#L40: type uP = unsafe.Pointer
golang.org/x/tools/internal/typesinternal
types.go#L27: addr := unsafe.Pointer(f.UnsafeAddr())
google.golang.org/protobuf/internal/impl
pointer_unsafe.go#L19: type Pointer unsafe.Pointer
pointer_unsafe.go#L40: type pointer struct{ p unsafe.Pointer }
pointer_unsafe.go#L44: return pointer{p: unsafe.Pointer(p)}
pointer_unsafe.go#L49: return pointer{p: unsafe.Pointer(v.Pointer())}
pointer_unsafe.go#L55: Type unsafe.Pointer
pointer_unsafe.go#L56: Data unsafe.Pointer
pointer_unsafe.go#L58: return pointer{p: (*ifaceHeader)(unsafe.Pointer(&v)).Data}
pointer_unsafe.go#L72: return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
pointer_unsafe.go#L119: return pointer{p: *(*unsafe.Pointer)(p.p)}
pointer_unsafe.go#L138: *(*unsafe.Pointer)(p.p) = (unsafe.Pointer)(v.p)
pointer_unsafe.go#L142: const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{}))
pointer_unsafe.go#L146: return (*messageState)(unsafe.Pointer(p))
pointer_unsafe.go#L150: return pointer{p: unsafe.Pointer(ms)}
pointer_unsafe.go#L160: return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo))))
pointer_unsafe.go#L163: atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi))
pointer_unsafe.go#L166: type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper
pointer_unsafe.go#L173: atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w))
google.golang.org/protobuf/internal/strs
strings_unsafe.go#L18: Data unsafe.Pointer
strings_unsafe.go#L22: Data unsafe.Pointer
strings_unsafe.go#L34: src := (*sliceHeader)(unsafe.Pointer(&b))
strings_unsafe.go#L35: dst := (*stringHeader)(unsafe.Pointer(&s))
strings_unsafe.go#L46: src := (*stringHeader)(unsafe.Pointer(&s))
strings_unsafe.go#L47: dst := (*sliceHeader)(unsafe.Pointer(&b))
google.golang.org/protobuf/reflect/protoreflect
value_unsafe.go#L18: Data unsafe.Pointer
value_unsafe.go#L22: Data unsafe.Pointer
value_unsafe.go#L27: Type unsafe.Pointer
value_unsafe.go#L28: Data unsafe.Pointer
value_unsafe.go#L48: func typeOf(t interface{}) unsafe.Pointer {
value_unsafe.go#L49: return (*ifaceHeader)(unsafe.Pointer(&t)).Type
value_unsafe.go#L62: typ unsafe.Pointer // 8B
value_unsafe.go#L65: ptr unsafe.Pointer // 8B
value_unsafe.go#L76: p := (*stringHeader)(unsafe.Pointer(&v))
value_unsafe.go#L80: p := (*sliceHeader)(unsafe.Pointer(&v))
value_unsafe.go#L84: p := (*ifaceHeader)(unsafe.Pointer(&v))
value_unsafe.go#L89: *(*stringHeader)(unsafe.Pointer(&x)) = stringHeader{Data: v.ptr, Len: int(v.num)}
value_unsafe.go#L93: *(*sliceHeader)(unsafe.Pointer(&x)) = sliceHeader{Data: v.ptr, Len: int(v.num), Cap: int(v.num)}
value_unsafe.go#L97: *(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr}
hash/crc32
crc32_amd64.go#L150: 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)
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/execabs
execabs.go#L51: lookPathErr := (*error)(unsafe.Pointer(reflect.ValueOf(cmd).Elem().FieldByName("lookPathErr").Addr().Pointer()))
internal/intern
intern.go#L105: v = (*Value)(unsafe.Pointer(addr))
intern.go#L118: valMap[k] = uintptr(unsafe.Pointer(v))
internal/poll
fd_writev_unix.go#L20: r, _, e = syscall.Syscall(syscall.SYS_WRITEV, uintptr(fd), uintptr(unsafe.Pointer(&iovecs[0])), uintptr(len(iovecs)))
splice_linux.go#L210: var disableSplice unsafe.Pointer
splice_linux.go#L233: defer atomic.StorePointer(&disableSplice, unsafe.Pointer(p))
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 Write(addr unsafe.Pointer) {
norace.go#L37: func ReadRange(addr unsafe.Pointer, len int) {
norace.go#L40: func WriteRange(addr unsafe.Pointer, len int) {
internal/reflectlite
swapper.go#L41: ps := *(*[]unsafe.Pointer)(v.ptr)
type.go#L163: equal func(unsafe.Pointer, unsafe.Pointer) bool
type.go#L250: hasher func(unsafe.Pointer, uintptr) uintptr
type.go#L319: return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off), whySafe))
type.go#L348: hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
type.go#L349: hdr.Data = unsafe.Pointer(n.data(1+i, "non-empty string"))
type.go#L360: hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
type.go#L361: hdr.Data = unsafe.Pointer(n.data(1+i+l+i2, "non-empty string"))
type.go#L379: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off, "name offset field")))[:])
type.go#L380: pkgPathName := name{(*byte)(resolveTypeOff(unsafe.Pointer(n.bytes), nameOff))}
type.go#L437: return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.mcount > 0"))[:t.mcount:t.mcount]
type.go#L444: return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.xcount > 0"))[:t.xcount:t.xcount]
type.go#L450: func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
type.go#L455: func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L462: return name{(*byte)(resolveNameOff(unsafe.Pointer(t), int32(off)))}
type.go#L466: return (*rtype)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
type.go#L475: return &(*structTypeUncommon)(unsafe.Pointer(t)).u
type.go#L481: return &(*u)(unsafe.Pointer(t)).u
type.go#L487: return &(*u)(unsafe.Pointer(t)).u
type.go#L493: return &(*u)(unsafe.Pointer(t)).u
type.go#L499: return &(*u)(unsafe.Pointer(t)).u
type.go#L505: return &(*u)(unsafe.Pointer(t)).u
type.go#L511: return &(*u)(unsafe.Pointer(t)).u
type.go#L517: return &(*u)(unsafe.Pointer(t)).u
type.go#L523: return &(*u)(unsafe.Pointer(t)).u
type.go#L553: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L590: tt := (*chanType)(unsafe.Pointer(t))
type.go#L597: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L600: tt := (*chanType)(unsafe.Pointer(t))
type.go#L603: tt := (*mapType)(unsafe.Pointer(t))
type.go#L606: tt := (*ptrType)(unsafe.Pointer(t))
type.go#L609: tt := (*sliceType)(unsafe.Pointer(t))
type.go#L619: tt := (*funcType)(unsafe.Pointer(t))
type.go#L627: tt := (*mapType)(unsafe.Pointer(t))
type.go#L635: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L643: tt := (*structType)(unsafe.Pointer(t))
type.go#L651: tt := (*funcType)(unsafe.Pointer(t))
type.go#L659: tt := (*funcType)(unsafe.Pointer(t))
type.go#L667: tt := (*funcType)(unsafe.Pointer(t))
type.go#L679: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.inCount:t.inCount]
type.go#L691: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "outCount > 0"))[t.inCount : t.inCount+outCount : t.inCount+outCount]
type.go#L701: func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
type.go#L702: return unsafe.Pointer(uintptr(p) + x)
type.go#L711: eface := *(*emptyInterface)(unsafe.Pointer(&i))
type.go#L742: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L760: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L888: t := (*funcType)(unsafe.Pointer(T))
type.go#L889: v := (*funcType)(unsafe.Pointer(V))
type.go#L906: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L907: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L922: t := (*structType)(unsafe.Pointer(T))
type.go#L923: v := (*structType)(unsafe.Pointer(V))
value.go#L41: ptr unsafe.Pointer
value.go#L91: func (v Value) pointer() unsafe.Pointer {
value.go#L96: return *(*unsafe.Pointer)(v.ptr)
value.go#L105: e := (*emptyInterface)(unsafe.Pointer(&i))
value.go#L125: e.word = *(*unsafe.Pointer)(v.ptr)
value.go#L140: e := (*emptyInterface)(unsafe.Pointer(&i))
value.go#L182: word unsafe.Pointer
value.go#L245: ptr = *(*unsafe.Pointer)(ptr)
value.go#L251: tt := (*ptrType)(unsafe.Pointer(v.typ))
value.go#L297: ptr = *(*unsafe.Pointer)(ptr)
value.go#L303: return *(*unsafe.Pointer)(v.ptr) == nil
value.go#L324: func chanlen(unsafe.Pointer) int
value.go#L325: func maplen(unsafe.Pointer) int
value.go#L333: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L363: var target unsafe.Pointer
value.go#L371: *(*unsafe.Pointer)(v.ptr) = x.ptr
value.go#L390: func unsafe_New(*rtype) unsafe.Pointer
value.go#L411: func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
value.go#L454: func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
value.go#L458: func ifaceE2I(t *rtype, src any, dst unsafe.Pointer)
value.go#L462: func typedmemmove(t *rtype, dst, src unsafe.Pointer)
internal/syscall/unix
at.go#L21: _, _, errno := syscall.Syscall(unlinkatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags))
at.go#L36: fd, _, errno := syscall.Syscall6(openatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags), uintptr(perm), 0, 0)
at.go#L51: _, _, errno := syscall.Syscall6(fstatatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
copy_file_range_linux.go#L15: uintptr(unsafe.Pointer(roff)),
copy_file_range_linux.go#L17: uintptr(unsafe.Pointer(woff)),
getrandom.go#L29: uintptr(unsafe.Pointer(&p[0])),
internal/unsafeheader
unsafeheader.go#L23: Data unsafe.Pointer
unsafeheader.go#L35: Data unsafe.Pointer
math
unsafe.go#L12: func Float32bits(f float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
unsafe.go#L18: func Float32frombits(b uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
unsafe.go#L23: func Float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
unsafe.go#L29: func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
net
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#L152: ifam := (*syscall.IfAddrmsg)(unsafe.Pointer(&m.Data[0]))
interface_linux.go#L238: i := *(*uint32)(unsafe.Pointer(&b[:4][0]))
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L14: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L64: func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L90: var _cgo_6cc2654a8ed3_C2func_getaddrinfo = unsafe.Pointer(&__cgofn__cgo_6cc2654a8ed3_C2func_getaddrinfo)
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L94: errno := _cgo_runtime_cgocall(_cgo_6cc2654a8ed3_C2func_getaddrinfo, uintptr(unsafe.Pointer(&p0)))
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L107: var _cgo_6cc2654a8ed3_C2func_getnameinfo = unsafe.Pointer(&__cgofn__cgo_6cc2654a8ed3_C2func_getnameinfo)
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L111: errno := _cgo_runtime_cgocall(_cgo_6cc2654a8ed3_C2func_getnameinfo, uintptr(unsafe.Pointer(&p0)))
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L134: var _cgo_6cc2654a8ed3_Cfunc_freeaddrinfo = unsafe.Pointer(&__cgofn__cgo_6cc2654a8ed3_Cfunc_freeaddrinfo)
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L138: _cgo_runtime_cgocall(_cgo_6cc2654a8ed3_Cfunc_freeaddrinfo, uintptr(unsafe.Pointer(&p0)))
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L147: var _cgo_6cc2654a8ed3_Cfunc_gai_strerror = unsafe.Pointer(&__cgofn__cgo_6cc2654a8ed3_Cfunc_gai_strerror)
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L151: _cgo_runtime_cgocall(_cgo_6cc2654a8ed3_Cfunc_gai_strerror, uintptr(unsafe.Pointer(&p0)))
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L160: var _cgo_6cc2654a8ed3_Cfunc_getaddrinfo = unsafe.Pointer(&__cgofn__cgo_6cc2654a8ed3_Cfunc_getaddrinfo)
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L164: _cgo_runtime_cgocall(_cgo_6cc2654a8ed3_Cfunc_getaddrinfo, uintptr(unsafe.Pointer(&p0)))
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L176: var _cgo_6cc2654a8ed3_Cfunc_getnameinfo = unsafe.Pointer(&__cgofn__cgo_6cc2654a8ed3_Cfunc_getnameinfo)
9f1d3a93b89b11393a57bf07a90273582641ac744d673b213b5b5bb7036be168-d#L180: _cgo_runtime_cgocall(_cgo_6cc2654a8ed3_Cfunc_getnameinfo, 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.go#L109: gerrno, err := func() (_Ctype_int, error){ var _cgo0 *_Ctype_char = /*line :106:31*/nil; var _cgo1 *_Ctype_char = /*line :106:36*/(*_Ctype_char /*line :106:44*/)(unsafe.Pointer(&cservice[0])); _cgo2 := /*line :106:77*/hints; _cgoBase3 := /*line :106:84*/&res; _cgo3 := _cgoBase3; _cgoCheckPointer(_cgo2, nil); _cgoCheckPointer(_cgoBase3, 0 == 0); return _C2func_getaddrinfo(_cgo0, _cgo1, _cgo2, _cgo3); }()
cgo_unix.go#L128: sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.ai_addr))
cgo_unix.go#L129: p := (*[2]byte)(unsafe.Pointer(&sa.Port))
cgo_unix.go#L132: sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.ai_addr))
cgo_unix.go#L133: p := (*[2]byte)(unsafe.Pointer(&sa.Port))
cgo_unix.go#L163: gerrno, err := func() (_Ctype_int, error){ var _cgo0 *_Ctype_char = /*line :160:31*/(*_Ctype_char /*line :160:39*/)(unsafe.Pointer(&h[0])); var _cgo1 *_Ctype_char = /*line :160:65*/nil; _cgoBase2 := /*line :160:70*/&hints; _cgo2 := _cgoBase2; _cgoBase3 := /*line :160:78*/&res; _cgo3 := _cgoBase3; _cgoCheckPointer(_cgoBase2, 0 == 0); _cgoCheckPointer(_cgoBase3, 0 == 0); return _C2func_getaddrinfo(_cgo0, _cgo1, _cgo2, _cgo3); }()
cgo_unix.go#L207: sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.ai_addr))
cgo_unix.go#L211: sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.ai_addr))
os
file.go#L252: hdr := (*unsafeheader.Slice)(unsafe.Pointer(&b))
file.go#L253: hdr.Data = (*unsafeheader.String)(unsafe.Pointer(&s)).Data
wait_waitid.go#L32: _, _, e = syscall.Syscall6(syscall.SYS_WAITID, _P_PID, uintptr(p.Pid), uintptr(unsafe.Pointer(psig)), syscall.WEXITED|syscall.WNOWAIT, 0, 0)
reflect
abi.go#L225: tt := (*arrayType)(unsafe.Pointer(t))
abi.go#L238: st := (*structType)(unsafe.Pointer(t))
abi.go#L474: func intFromReg(r *abi.RegArgs, reg int, argSize uintptr, to unsafe.Pointer) {
abi.go#L481: func intToReg(r *abi.RegArgs, reg int, argSize uintptr, from unsafe.Pointer) {
abi.go#L488: func floatFromReg(r *abi.RegArgs, reg int, argSize uintptr, to unsafe.Pointer) {
abi.go#L493: *(*float64)(to) = *(*float64)(unsafe.Pointer(&r.Floats[reg]))
abi.go#L502: func floatToReg(r *abi.RegArgs, reg int, argSize uintptr, from 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.rtype, unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
makefunc.go#L168: *(*uintptr)(unsafe.Pointer(&args.Ptrs[i])) = arg
makefunc.go#L173: *(*uintptr)(unsafe.Pointer(&args.Ptrs[i])) = 0
swapper.go#L41: ps := *(*[]unsafe.Pointer)(v.ptr)
type.go#L325: equal func(unsafe.Pointer, unsafe.Pointer) bool
type.go#L412: hasher func(unsafe.Pointer, uintptr) uintptr
type.go#L485: return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off), whySafe))
type.go#L529: hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
type.go#L530: hdr.Data = unsafe.Pointer(n.data(1+i, "non-empty string"))
type.go#L541: hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
type.go#L542: hdr.Data = unsafe.Pointer(n.data(1+i+l+i2, "non-empty string"))
type.go#L560: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off, "name offset field")))[:])
type.go#L561: pkgPathName := name{(*byte)(resolveTypeOff(unsafe.Pointer(n.bytes), nameOff))}
type.go#L675: return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.mcount > 0"))[:t.mcount:t.mcount]
type.go#L682: return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.xcount > 0"))[:t.xcount:t.xcount]
type.go#L688: func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
type.go#L693: func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L698: func resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L703: func addReflectOff(ptr unsafe.Pointer) int32
type.go#L708: return nameOff(addReflectOff(unsafe.Pointer(n.bytes)))
type.go#L714: return typeOff(addReflectOff(unsafe.Pointer(t)))
type.go#L720: func resolveReflectText(ptr unsafe.Pointer) textOff {
type.go#L729: return name{(*byte)(resolveNameOff(unsafe.Pointer(t), int32(off)))}
type.go#L733: return (*rtype)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
type.go#L736: func (t *rtype) textOff(off textOff) unsafe.Pointer {
type.go#L737: return resolveTextOff(unsafe.Pointer(t), int32(off))
type.go#L746: return &(*structTypeUncommon)(unsafe.Pointer(t)).u
type.go#L752: return &(*u)(unsafe.Pointer(t)).u
type.go#L758: return &(*u)(unsafe.Pointer(t)).u
type.go#L764: return &(*u)(unsafe.Pointer(t)).u
type.go#L770: return &(*u)(unsafe.Pointer(t)).u
type.go#L776: return &(*u)(unsafe.Pointer(t)).u
type.go#L782: return &(*u)(unsafe.Pointer(t)).u
type.go#L788: return &(*u)(unsafe.Pointer(t)).u
type.go#L794: return &(*u)(unsafe.Pointer(t)).u
type.go#L839: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L847: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L859: ft := (*funcType)(unsafe.Pointer(mtyp))
type.go#L872: fn := unsafe.Pointer(&tfn)
type.go#L881: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L935: tt := (*chanType)(unsafe.Pointer(t))
type.go#L943: tt := (*funcType)(unsafe.Pointer(t))
type.go#L950: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L953: tt := (*chanType)(unsafe.Pointer(t))
type.go#L956: tt := (*mapType)(unsafe.Pointer(t))
type.go#L959: tt := (*ptrType)(unsafe.Pointer(t))
type.go#L962: tt := (*sliceType)(unsafe.Pointer(t))
type.go#L972: tt := (*structType)(unsafe.Pointer(t))
type.go#L980: tt := (*structType)(unsafe.Pointer(t))
type.go#L988: tt := (*structType)(unsafe.Pointer(t))
type.go#L996: tt := (*structType)(unsafe.Pointer(t))
type.go#L1004: tt := (*funcType)(unsafe.Pointer(t))
type.go#L1012: tt := (*mapType)(unsafe.Pointer(t))
type.go#L1020: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L1028: tt := (*structType)(unsafe.Pointer(t))
type.go#L1036: tt := (*funcType)(unsafe.Pointer(t))
type.go#L1044: tt := (*funcType)(unsafe.Pointer(t))
type.go#L1052: tt := (*funcType)(unsafe.Pointer(t))
type.go#L1064: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.inCount:t.inCount]
type.go#L1076: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "outCount > 0"))[t.inCount : t.inCount+outCount : t.inCount+outCount]
type.go#L1086: func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
type.go#L1087: return unsafe.Pointer(uintptr(p) + x)
type.go#L1375: styp := (*structType)(unsafe.Pointer(ntyp))
type.go#L1425: eface := *(*emptyInterface)(unsafe.Pointer(&i))
type.go#L1458: p := (*ptrType)(unsafe.Pointer(tt))
type.go#L1468: var iptr any = (*unsafe.Pointer)(nil)
type.go#L1469: prototype := *(**ptrType)(unsafe.Pointer(&iptr))
type.go#L1531: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L1549: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L1685: t := (*funcType)(unsafe.Pointer(T))
type.go#L1686: v := (*funcType)(unsafe.Pointer(V))
type.go#L1703: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L1704: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L1719: t := (*structType)(unsafe.Pointer(T))
type.go#L1720: v := (*structType)(unsafe.Pointer(V))
type.go#L1768: func typelinks() (sections []unsafe.Pointer, offset [][]int32)
type.go#L1770: func rtypeOff(section unsafe.Pointer, off int32) *rtype {
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#L1922: mt := (*mapType)(unsafe.Pointer(tt))
type.go#L1932: var imap any = (map[unsafe.Pointer]unsafe.Pointer)(nil)
type.go#L1933: mt := **(**mapType)(unsafe.Pointer(&imap))
type.go#L1940: mt.hasher = func(p unsafe.Pointer, seed uintptr) uintptr {
type.go#L2013: prototype := *(**funcType)(unsafe.Pointer(&ifunc))
type.go#L2128: repr = append(repr, (*sliceType)(unsafe.Pointer(t)).elem.String()...)
type.go#L2161: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2164: tt := (*structType)(unsafe.Pointer(t))
type.go#L2188: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2191: tt := (*structType)(unsafe.Pointer(t))
type.go#L2210: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2213: tt := (*structType)(unsafe.Pointer(t))
type.go#L2300: return (*[1 << 30]byte)(unsafe.Pointer(t.gcdata))[begin:end:end]
type.go#L2327: n := uintptr(*(*uint32)(unsafe.Pointer(typ.gcdata)))
type.go#L2362: slice := (*sliceType)(unsafe.Pointer(tt))
type.go#L2370: var islice any = ([]unsafe.Pointer)(nil)
type.go#L2371: prototype := *(**sliceType)(unsafe.Pointer(&islice))
type.go#L2488: ift := (*interfaceType)(unsafe.Pointer(ft))
type.go#L2542: ifn: resolveReflectText(unsafe.Pointer(&ifn)),
type.go#L2543: tfn: resolveReflectText(unsafe.Pointer(&tfn)),
type.go#L2547: ptr := (*ptrType)(unsafe.Pointer(ft))
type.go#L2699: prototype := *(**structType)(unsafe.Pointer(&istruct))
type.go#L2793: *(*uint32)(unsafe.Pointer(&prog[0])) = uint32(len(prog) - 4)
type.go#L2806: typ.equal = func(p, q unsafe.Pointer) bool {
type.go#L2866: st := (*structType)(unsafe.Pointer(t))
type.go#L2910: array := (*arrayType)(unsafe.Pointer(tt))
type.go#L2918: var iarray any = [1]unsafe.Pointer{}
type.go#L2919: prototype := *(**arrayType)(unsafe.Pointer(&iarray))
type.go#L2990: *(*uint32)(unsafe.Pointer(&prog[0])) = uint32(len(prog) - 4)
type.go#L3001: array.equal = func(p, q unsafe.Pointer) bool {
type.go#L3160: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L3167: tt := (*structType)(unsafe.Pointer(t))
value.go#L45: ptr unsafe.Pointer
value.go#L96: func (v Value) pointer() unsafe.Pointer {
value.go#L101: return *(*unsafe.Pointer)(v.ptr)
value.go#L110: e := (*emptyInterface)(unsafe.Pointer(&i))
value.go#L130: e.word = *(*unsafe.Pointer)(v.ptr)
value.go#L145: e := (*emptyInterface)(unsafe.Pointer(&i))
value.go#L198: word unsafe.Pointer
value.go#L209: fun [100000]unsafe.Pointer // method table
value.go#L211: word unsafe.Pointer
value.go#L361: t := (*funcType)(unsafe.Pointer(v.typ))
value.go#L363: fn unsafe.Pointer
value.go#L371: fn = *(*unsafe.Pointer)(v.ptr)
value.go#L445: var stackArgs unsafe.Pointer
value.go#L448: stackArgs = framePool.Get().(unsafe.Pointer)
value.go#L478: storeRcvr(rcvr, unsafe.Pointer(®Args.Ints[st.ireg]))
value.go#L480: storeRcvr(rcvr, unsafe.Pointer(®Args.Floats[st.freg]))
value.go#L504: *(*unsafe.Pointer)(addr) = v.ptr
value.go#L516: regArgs.Ptrs[st.ireg] = *(*unsafe.Pointer)(offset)
value.go#L630: *((*unsafe.Pointer)(s)) = regArgs.Ptrs[st.ireg]
value.go#L667: func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool, regs *abi.RegArgs) {
value.go#L703: v.ptr = *(*unsafe.Pointer)(add(ptr, st.stkOff, "1-ptr"))
value.go#L718: *((*unsafe.Pointer)(s)) = regs.Ptrs[st.ireg]
value.go#L847: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *rtype, t *funcType, fn unsafe.Pointer) {
value.go#L850: tt := (*interfaceType)(unsafe.Pointer(v.typ))
value.go#L863: fn = unsafe.Pointer(&iface.itab.fun[i])
value.go#L864: t = (*funcType)(unsafe.Pointer(tt.typeOff(m.typ)))
value.go#L876: fn = unsafe.Pointer(&ifn)
value.go#L877: t = (*funcType)(unsafe.Pointer(v.typ.typeOff(m.mtyp)))
value.go#L886: func storeRcvr(v Value, p unsafe.Pointer) {
value.go#L891: *(*unsafe.Pointer)(p) = iface.word
value.go#L893: *(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(v.ptr)
value.go#L895: *(*unsafe.Pointer)(p) = v.ptr
value.go#L924: func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool, regs *abi.RegArgs) {
value.go#L942: methodFrame := methodFramePool.Get().(unsafe.Pointer)
value.go#L952: storeRcvr(rcvr, unsafe.Pointer(&methodRegs.Ints))
value.go#L996: methodRegs.Ptrs[mStep.ireg] = *(*unsafe.Pointer)(from)
value.go#L1015: *(*unsafe.Pointer)(to) = valueRegs.Ptrs[vStep.ireg]
value.go#L1107: pc := *(*uintptr)(unsafe.Pointer(&f))
value.go#L1201: ptr = *(*unsafe.Pointer)(ptr)
value.go#L1207: tt := (*ptrType)(unsafe.Pointer(v.typ))
value.go#L1222: tt := (*structType)(unsafe.Pointer(v.typ))
value.go#L1345: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L1368: tt := (*sliceType)(unsafe.Pointer(v.typ))
value.go#L1498: ptr = *(*unsafe.Pointer)(ptr)
value.go#L1504: return *(*unsafe.Pointer)(v.ptr) == nil
value.go#L1570: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L1594: tt := (*mapType)(unsafe.Pointer(v.typ))
value.go#L1604: var e unsafe.Pointer
value.go#L1610: var k unsafe.Pointer
value.go#L1614: k = unsafe.Pointer(&key.ptr)
value.go#L1633: tt := (*mapType)(unsafe.Pointer(v.typ))
value.go#L1666: key unsafe.Pointer
value.go#L1667: elem unsafe.Pointer
value.go#L1668: t unsafe.Pointer
value.go#L1669: h unsafe.Pointer
value.go#L1670: buckets unsafe.Pointer
value.go#L1671: bptr unsafe.Pointer
value.go#L1672: overflow *[]unsafe.Pointer
value.go#L1673: oldoverflow *[]unsafe.Pointer
value.go#L1704: t := (*mapType)(unsafe.Pointer(iter.m.typ))
value.go#L1722: var target unsafe.Pointer
value.go#L1727: t := (*mapType)(unsafe.Pointer(iter.m.typ))
value.go#L1745: t := (*mapType)(unsafe.Pointer(iter.m.typ))
value.go#L1763: var target unsafe.Pointer
value.go#L1768: t := (*mapType)(unsafe.Pointer(iter.m.typ))
value.go#L1829: func copyVal(typ *rtype, fl flag, ptr unsafe.Pointer) Value {
value.go#L1837: return Value{typ, *(*unsafe.Pointer)(ptr), fl}
value.go#L1894: tt := (*structType)(unsafe.Pointer(v.typ))
value.go#L2008: p = *(*unsafe.Pointer)(p)
value.go#L2032: tt := (*chanType)(unsafe.Pointer(v.typ))
value.go#L2038: var p unsafe.Pointer
value.go#L2044: p = unsafe.Pointer(&val.ptr)
value.go#L2065: tt := (*chanType)(unsafe.Pointer(v.typ))
value.go#L2071: var p unsafe.Pointer
value.go#L2075: p = unsafe.Pointer(&x.ptr)
value.go#L2086: var target unsafe.Pointer
value.go#L2092: if x.ptr == unsafe.Pointer(&zeroVal[0]) {
value.go#L2098: *(*unsafe.Pointer)(v.ptr) = x.ptr
value.go#L2216: tt := (*mapType)(unsafe.Pointer(v.typ))
value.go#L2226: var e unsafe.Pointer
value.go#L2230: e = unsafe.Pointer(&elem.ptr)
value.go#L2237: var k unsafe.Pointer
value.go#L2241: k = unsafe.Pointer(&key.ptr)
value.go#L2249: var e unsafe.Pointer
value.go#L2253: e = unsafe.Pointer(&elem.ptr)
value.go#L2282: func (v Value) SetPointer(x unsafe.Pointer) {
value.go#L2285: *(*unsafe.Pointer)(v.ptr) = x
value.go#L2303: base unsafe.Pointer
value.go#L2313: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L2315: typ = (*sliceType)(unsafe.Pointer(tt.slice))
value.go#L2319: typ = (*sliceType)(unsafe.Pointer(v.typ))
value.go#L2333: return Value{v.typ, unsafe.Pointer(&t), v.flag}
value.go#L2341: var x []unsafe.Pointer
value.go#L2344: s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
value.go#L2355: return Value{typ.common(), unsafe.Pointer(&x), fl}
value.go#L2365: base unsafe.Pointer
value.go#L2375: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L2377: typ = (*sliceType)(unsafe.Pointer(tt.slice))
value.go#L2381: typ = (*sliceType)(unsafe.Pointer(v.typ))
value.go#L2393: var x []unsafe.Pointer
value.go#L2396: s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
value.go#L2407: return Value{typ.common(), unsafe.Pointer(&x), fl}
value.go#L2465: tt := (*interfaceType)(unsafe.Pointer(v.typ))
value.go#L2544: func (v Value) UnsafePointer() unsafe.Pointer {
value.go#L2554: return *(*unsafe.Pointer)(v.ptr)
value.go#L2568: return *(*unsafe.Pointer)(unsafe.Pointer(&code))
value.go#L2574: p = *(*unsafe.Pointer)(p)
value.go#L2620: func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
value.go#L2737: ch unsafe.Pointer // channel
value.go#L2738: val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
value.go#L2834: tt := (*chanType)(unsafe.Pointer(ch.typ))
value.go#L2849: rc.val = unsafe.Pointer(&v.ptr)
value.go#L2862: tt := (*chanType)(unsafe.Pointer(ch.typ))
value.go#L2874: tt := (*chanType)(unsafe.Pointer(runcases[chosen].typ))
value.go#L2881: recv = Value{t, *(*unsafe.Pointer)(p), fl}
value.go#L2892: func unsafe_New(*rtype) unsafe.Pointer
value.go#L2893: func unsafe_NewArray(*rtype, int) unsafe.Pointer
value.go#L2912: return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L2985: var p unsafe.Pointer
value.go#L2987: p = unsafe.Pointer(&zeroVal[0])
value.go#L3021: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L3031: func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
value.go#L3405: func chancap(ch unsafe.Pointer) int
value.go#L3406: func chanclose(ch unsafe.Pointer)
value.go#L3407: func chanlen(ch unsafe.Pointer) int
value.go#L3418: func chanrecv(ch unsafe.Pointer, nb bool, val unsafe.Pointer) (selected, received bool)
value.go#L3421: func chansend(ch unsafe.Pointer, val unsafe.Pointer, nb bool) bool
value.go#L3423: func makechan(typ *rtype, size int) (ch unsafe.Pointer)
value.go#L3424: func makemap(t *rtype, cap int) (m unsafe.Pointer)
value.go#L3427: func mapaccess(t *rtype, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
value.go#L3430: func mapaccess_faststr(t *rtype, m unsafe.Pointer, key string) (val unsafe.Pointer)
value.go#L3433: func mapassign(t *rtype, m unsafe.Pointer, key, val unsafe.Pointer)
value.go#L3436: func mapassign_faststr(t *rtype, m unsafe.Pointer, key string, val unsafe.Pointer)
value.go#L3439: func mapdelete(t *rtype, m unsafe.Pointer, key unsafe.Pointer)
value.go#L3442: func mapdelete_faststr(t *rtype, m unsafe.Pointer, key string)
value.go#L3445: func mapiterinit(t *rtype, m unsafe.Pointer, it *hiter)
value.go#L3448: func mapiterkey(it *hiter) (key unsafe.Pointer)
value.go#L3451: func mapiterelem(it *hiter) (elem unsafe.Pointer)
value.go#L3457: func maplen(m unsafe.Pointer) int
value.go#L3484: func call(stackArgsType *rtype, f, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
value.go#L3486: func ifaceE2I(t *rtype, src any, dst unsafe.Pointer)
value.go#L3490: func memmove(dst, src unsafe.Pointer, size uintptr)
value.go#L3494: func typedmemmove(t *rtype, dst, src unsafe.Pointer)
value.go#L3499: func typedmemmovepartial(t *rtype, dst, src unsafe.Pointer, off, size uintptr)
value.go#L3503: func typedmemclr(t *rtype, ptr unsafe.Pointer)
value.go#L3508: func typedmemclrpartial(t *rtype, ptr unsafe.Pointer, off, size uintptr)
value.go#L3516: func typehash(t *rtype, p unsafe.Pointer, h uintptr) uintptr
runtime
alg.go#L18: func memhash0(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L22: func memhash8(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L26: func memhash16(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L30: func memhash128(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L35: func memhash_varlen(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L37: size := *(*uintptr)(unsafe.Pointer(ptr + unsafe.Sizeof(h)))
alg.go#L47: func memhash(p unsafe.Pointer, h, s uintptr) uintptr
alg.go#L48: func memhash32(p unsafe.Pointer, h uintptr) uintptr
alg.go#L49: func memhash64(p unsafe.Pointer, h uintptr) uintptr
alg.go#L50: func strhash(p unsafe.Pointer, h uintptr) uintptr
alg.go#L52: func strhashFallback(a unsafe.Pointer, h uintptr) uintptr {
alg.go#L62: func f32hash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L74: func f64hash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L86: func c64hash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L88: return f32hash(unsafe.Pointer(&x[1]), f32hash(unsafe.Pointer(&x[0]), h))
alg.go#L91: func c128hash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L93: return f64hash(unsafe.Pointer(&x[1]), f64hash(unsafe.Pointer(&x[0]), h))
alg.go#L96: func interhash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L111: return c1 * typehash(t, unsafe.Pointer(&a.data), h^c0)
alg.go#L117: func nilinterhash(p unsafe.Pointer, h uintptr) uintptr {
alg.go#L128: return c1 * typehash(t, unsafe.Pointer(&a.data), h^c0)
alg.go#L144: func typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
alg.go#L168: i := (*interfacetype)(unsafe.Pointer(t))
alg.go#L174: a := (*arraytype)(unsafe.Pointer(t))
alg.go#L180: s := (*structtype)(unsafe.Pointer(t))
alg.go#L196: func reflect_typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
alg.go#L200: func memequal0(p, q unsafe.Pointer) bool {
alg.go#L203: func memequal8(p, q unsafe.Pointer) bool {
alg.go#L206: func memequal16(p, q unsafe.Pointer) bool {
alg.go#L209: func memequal32(p, q unsafe.Pointer) bool {
alg.go#L212: func memequal64(p, q unsafe.Pointer) bool {
alg.go#L215: func memequal128(p, q unsafe.Pointer) bool {
alg.go#L218: func f32equal(p, q unsafe.Pointer) bool {
alg.go#L221: func f64equal(p, q unsafe.Pointer) bool {
alg.go#L224: func c64equal(p, q unsafe.Pointer) bool {
alg.go#L227: func c128equal(p, q unsafe.Pointer) bool {
alg.go#L230: func strequal(p, q unsafe.Pointer) bool {
alg.go#L233: func interequal(p, q unsafe.Pointer) bool {
alg.go#L238: func nilinterequal(p, q unsafe.Pointer) bool {
alg.go#L243: func efaceeq(t *_type, x, y unsafe.Pointer) bool {
alg.go#L259: func ifaceeq(tab *itab, x, y unsafe.Pointer) bool {
alg.go#L277: return strhash(noescape(unsafe.Pointer(&s)), seed)
alg.go#L281: s := (*slice)(unsafe.Pointer(&b))
alg.go#L286: return memhash32(noescape(unsafe.Pointer(&i)), seed)
alg.go#L290: return memhash64(noescape(unsafe.Pointer(&i)), seed)
alg.go#L294: return nilinterhash(noescape(unsafe.Pointer(&i)), seed)
alg.go#L300: return interhash(noescape(unsafe.Pointer(&i)), seed)
alg.go#L324: getRandomData((*[len(hashkey) * goarch.PtrSize]byte)(unsafe.Pointer(&hashkey))[:])
alg.go#L338: func readUnaligned32(p unsafe.Pointer) uint32 {
alg.go#L346: func readUnaligned64(p unsafe.Pointer) uint64 {
asan0.go#L19: func asanread(addr unsafe.Pointer, sz uintptr) { throw("asan") }
asan0.go#L20: func asanwrite(addr unsafe.Pointer, sz uintptr) { throw("asan") }
asan0.go#L21: func asanunpoison(addr unsafe.Pointer, sz uintptr) { throw("asan") }
asan0.go#L22: func asanpoison(addr unsafe.Pointer, sz uintptr) { throw("asan") }
atomic_pointer.go#L21: func atomicwb(ptr *unsafe.Pointer, new unsafe.Pointer) {
atomic_pointer.go#L22: slot := (*uintptr)(unsafe.Pointer(ptr))
atomic_pointer.go#L31: func atomicstorep(ptr unsafe.Pointer, new unsafe.Pointer) {
atomic_pointer.go#L33: atomicwb((*unsafe.Pointer)(ptr), new)
atomic_pointer.go#L47: func sync_atomic_StorePointer(ptr *unsafe.Pointer, new unsafe.Pointer) {
atomic_pointer.go#L51: sync_atomic_StoreUintptr((*uintptr)(unsafe.Pointer(ptr)), uintptr(new))
atomic_pointer.go#L59: func sync_atomic_SwapPointer(ptr *unsafe.Pointer, new unsafe.Pointer) unsafe.Pointer {
atomic_pointer.go#L63: old := unsafe.Pointer(sync_atomic_SwapUintptr((*uintptr)(noescape(unsafe.Pointer(ptr))), uintptr(new)))
atomic_pointer.go#L72: func sync_atomic_CompareAndSwapPointer(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool {
atomic_pointer.go#L76: return sync_atomic_CompareAndSwapUintptr((*uintptr)(noescape(unsafe.Pointer(ptr))), uintptr(old), uintptr(new))
cgo.go#L22: _cgo_init unsafe.Pointer
cgo.go#L23: _cgo_thread_start unsafe.Pointer
cgo.go#L24: _cgo_sys_thread_create unsafe.Pointer
cgo.go#L25: _cgo_notify_runtime_init_done unsafe.Pointer
cgo.go#L26: _cgo_callers unsafe.Pointer
cgo.go#L27: _cgo_set_context_function unsafe.Pointer
cgo.go#L28: _cgo_yield unsafe.Pointer
cgo_mmap.go#L16: var _cgo_mmap unsafe.Pointer
cgo_mmap.go#L21: var _cgo_munmap unsafe.Pointer
cgo_mmap.go#L28: func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) {
cgo_mmap.go#L42: return unsafe.Pointer(ret), 0
cgo_mmap.go#L47: func munmap(addr unsafe.Pointer, n uintptr) {
cgo_mmap.go#L56: func sysMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int)
cgo_mmap.go#L60: func callCgoMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) uintptr
cgo_mmap.go#L63: func sysMunmap(addr unsafe.Pointer, n uintptr)
cgo_mmap.go#L67: func callCgoMunmap(addr unsafe.Pointer, n uintptr)
cgo_sigaction.go#L16: var _cgo_sigaction unsafe.Pointer
cgo_sigaction.go#L28: msanwrite(unsafe.Pointer(new), unsafe.Sizeof(*new))
cgo_sigaction.go#L31: asanwrite(unsafe.Pointer(new), unsafe.Sizeof(*new))
cgo_sigaction.go#L48: sp := uintptr(unsafe.Pointer(&sig))
cgo_sigaction.go#L82: msanread(unsafe.Pointer(old), unsafe.Sizeof(*old))
cgo_sigaction.go#L85: asanread(unsafe.Pointer(old), unsafe.Sizeof(*old))
cgocall.go#L100: args unsafe.Pointer
cgocall.go#L108: func syscall_cgocaller(fn unsafe.Pointer, args ...uintptr) uintptr {
cgocall.go#L109: as := argset{args: unsafe.Pointer(&args[0])}
cgocall.go#L110: cgocall(fn, unsafe.Pointer(&as))
cgocall.go#L123: func cgocall(fn, arg unsafe.Pointer) int32 {
cgocall.go#L133: racereleasemerge(unsafe.Pointer(&racecgosync))
cgocall.go#L181: raceacquire(unsafe.Pointer(&racecgosync))
cgocall.go#L203: func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
cgocall.go#L226: savedsp := unsafe.Pointer(gp.syscallsp)
cgocall.go#L253: func cgocallbackg1(fn, frame unsafe.Pointer, ctxt uintptr) {
cgocall.go#L274: p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
cgocall.go#L275: atomicstorep(unsafe.Pointer(&p.array), unsafe.Pointer(&s[0]))
cgocall.go#L281: p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
cgocall.go#L306: raceacquire(unsafe.Pointer(&racecgosync))
cgocall.go#L311: var cb func(frame unsafe.Pointer)
cgocall.go#L313: *(*unsafe.Pointer)(unsafe.Pointer(&cb)) = noescape(unsafe.Pointer(&cbFV))
cgocall.go#L317: racereleasemerge(unsafe.Pointer(&racecgosync))
cgocall.go#L331: sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + alignUp(sys.MinFrameSize, sys.StackAlign)))
cgocall.go#L404: p = *(*unsafe.Pointer)(p)
cgocall.go#L416: pt := (*ptrtype)(unsafe.Pointer(t))
cgocall.go#L445: func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
cgocall.go#L455: at := (*arraytype)(unsafe.Pointer(t))
cgocall.go#L474: p = *(*unsafe.Pointer)(p)
cgocall.go#L488: if inheap(uintptr(unsafe.Pointer(it))) {
cgocall.go#L491: p = *(*unsafe.Pointer)(add(p, goarch.PtrSize))
cgocall.go#L500: st := (*slicetype)(unsafe.Pointer(t))
cgocall.go#L525: st := (*structtype)(unsafe.Pointer(t))
cgocall.go#L541: p = *(*unsafe.Pointer)(p)
cgocall.go#L562: func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
cgocall.go#L576: if hbits.isPointer() && cgoIsGoPointer(*(*unsafe.Pointer)(unsafe.Pointer(base + i))) {
cgocall.go#L603: func cgoIsGoPointer(p unsafe.Pointer) bool {
cgocall.go#L624: func cgoInRange(p unsafe.Pointer, start, end uintptr) bool {
cgocheck.go#L26: if !cgoIsGoPointer(unsafe.Pointer(src)) {
cgocheck.go#L29: if cgoIsGoPointer(unsafe.Pointer(dst)) {
cgocheck.go#L49: if inPersistentAlloc(uintptr(unsafe.Pointer(dst))) {
cgocheck.go#L54: println("write of Go pointer", hex(src), "to non-Go memory", hex(uintptr(unsafe.Pointer(dst))))
cgocheck.go#L66: func cgoCheckMemmove(typ *_type, dst, src unsafe.Pointer, off, size uintptr) {
cgocheck.go#L86: func cgoCheckSliceCopy(typ *_type, dst, src unsafe.Pointer, n int) {
cgocheck.go#L108: func cgoCheckTypedBlock(typ *_type, src unsafe.Pointer, off, size uintptr) {
cgocheck.go#L157: v := *(*unsafe.Pointer)(add(src, i))
cgocheck.go#L171: func cgoCheckBits(src unsafe.Pointer, gcbits *byte, off, size uintptr) {
cgocheck.go#L190: v := *(*unsafe.Pointer)(add(src, i))
cgocheck.go#L206: func cgoCheckUsingType(typ *_type, src unsafe.Pointer, off, size uintptr) {
cgocheck.go#L227: at := (*arraytype)(unsafe.Pointer(typ))
cgocheck.go#L245: st := (*structtype)(unsafe.Pointer(typ))
chan.go#L36: buf unsafe.Pointer // points to an array of dataqsiz elements
chan.go#L103: c.buf = add(unsafe.Pointer(c), hchanSize)
chan.go#L122: func chanbuf(c *hchan, i uint) unsafe.Pointer {
chan.go#L143: func chansend1(c *hchan, elem unsafe.Pointer) {
chan.go#L159: func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
chan.go#L258: gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
chan.go#L293: func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
chan.go#L316: gp.param = unsafe.Pointer(sg)
chan.go#L334: func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
chan.go#L347: func recvDirect(t *_type, sg *sudog, dst unsafe.Pointer) {
chan.go#L391: gp.param = unsafe.Pointer(sg)
chan.go#L410: gp.param = unsafe.Pointer(sg)
chan.go#L432: return atomic.Loadp(unsafe.Pointer(&c.sendq.first)) == nil
chan.go#L439: func chanrecv1(c *hchan, elem unsafe.Pointer) {
chan.go#L444: func chanrecv2(c *hchan, elem unsafe.Pointer) (received bool) {
chan.go#L455: func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
chan.go#L577: gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)
chan.go#L608: func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
chan.go#L642: gp.param = unsafe.Pointer(sg)
chan.go#L650: func chanparkcommit(gp *g, chanLock unsafe.Pointer) bool {
chan.go#L687: func selectnbsend(c *hchan, elem unsafe.Pointer) (selected bool) {
chan.go#L708: func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected, received bool) {
chan.go#L713: func reflect_chansend(c *hchan, elem unsafe.Pointer, nb bool) (selected bool) {
chan.go#L718: func reflect_chanrecv(c *hchan, nb bool, elem unsafe.Pointer) (selected bool, received bool) {
chan.go#L797: func (c *hchan) raceaddr() unsafe.Pointer {
chan.go#L803: 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#L79: func checkptrBase(p unsafe.Pointer) uintptr {
cpuprof.go#L92: func (p *cpuProfile) add(tagPtr *unsafe.Pointer, stk []uintptr) {
cpuprof.go#L207: func runtime_pprof_readProfile() ([]uint64, []unsafe.Pointer, bool) {
debug.go#L49: for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
debugcall.go#L114: newg := newproc1(*(**funcval)(unsafe.Pointer(&fn)), gp, callerpc)
debugcall.go#L119: newg.param = unsafe.Pointer(args)
debugcall.go#L242: *(*unsafe.Pointer)(unsafe.Pointer(&dispatchF)) = noescape(unsafe.Pointer(&dispatchFV))
debuglog.go#L63: allp := (*uintptr)(unsafe.Pointer(&allDloggers))
debuglog.go#L64: all := (*dlogger)(unsafe.Pointer(atomic.Loaduintptr(allp)))
debuglog.go#L83: headp := (*uintptr)(unsafe.Pointer(&allDloggers))
debuglog.go#L86: l.allLink = (*dlogger)(unsafe.Pointer(head))
debuglog.go#L87: if atomic.Casuintptr(headp, head, uintptr(unsafe.Pointer(l))) {
debuglog.go#L305: bb := (*slice)(unsafe.Pointer(&b))
debuglog.go#L658: str: unsafe.Pointer(ptr),
debuglog.go#L661: s := *(*string)(unsafe.Pointer(&str))
debuglog.go#L697: allp := (*uintptr)(unsafe.Pointer(&allDloggers))
debuglog.go#L698: all := (*dlogger)(unsafe.Pointer(atomic.Loaduintptr(allp)))
env_posix.go#L47: var _cgo_setenv unsafe.Pointer // pointer to C function
env_posix.go#L48: var _cgo_unsetenv unsafe.Pointer // pointer to C function
env_posix.go#L57: arg := [2]unsafe.Pointer{cstring(k), cstring(v)}
env_posix.go#L58: asmcgocall(_cgo_setenv, unsafe.Pointer(&arg))
env_posix.go#L68: arg := [1]unsafe.Pointer{cstring(k)}
env_posix.go#L69: asmcgocall(_cgo_unsetenv, unsafe.Pointer(&arg))
env_posix.go#L72: func cstring(s string) unsafe.Pointer {
env_posix.go#L75: return unsafe.Pointer(&p[0])
float.go#L46: return *(*uint64)(unsafe.Pointer(&f))
float.go#L52: return *(*float64)(unsafe.Pointer(&b))
hash64.go#L25: func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
hash64.go#L71: func memhash32Fallback(p unsafe.Pointer, seed uintptr) uintptr {
hash64.go#L76: func memhash64Fallback(p unsafe.Pointer, seed uintptr) uintptr {
hash64.go#L86: func r4(p unsafe.Pointer) uintptr {
hash64.go#L90: func r8(p unsafe.Pointer) uintptr {
heapdump.go#L77: func dwrite(data unsafe.Pointer, len uintptr) {
heapdump.go#L87: write(dumpfd, unsafe.Pointer(&buf), int32(nbuf))
heapdump.go#L98: dwrite(unsafe.Pointer(&b), 1)
heapdump.go#L102: write(dumpfd, unsafe.Pointer(&buf), int32(nbuf))
heapdump.go#L134: dwrite(unsafe.Pointer(&buf), uintptr(n))
heapdump.go#L146: func dumpmemrange(data unsafe.Pointer, len uintptr) {
heapdump.go#L154: dwrite(unsafe.Pointer(&b[0]), uintptr(len(b)))
heapdump.go#L195: dumpint(uint64(uintptr(unsafe.Pointer(t))))
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#L255: func dumpframe(s *stkframe, arg unsafe.Pointer) bool {
heapdump.go#L285: dumpint(uint64(uintptr(unsafe.Pointer(child.sp)))) // sp of child, or 0 if bottom of stack
heapdump.go#L286: dumpmemrange(unsafe.Pointer(s.sp), s.fp-s.sp) // frame contents
heapdump.go#L331: child.sp = (*uint8)(unsafe.Pointer(s.sp))
heapdump.go#L355: dumpint(uint64(uintptr(unsafe.Pointer(gp))))
heapdump.go#L365: dumpint(uint64(uintptr(unsafe.Pointer(gp.m))))
heapdump.go#L366: dumpint(uint64(uintptr(unsafe.Pointer(gp._defer))))
heapdump.go#L367: dumpint(uint64(uintptr(unsafe.Pointer(gp._panic))))
heapdump.go#L375: gentraceback(pc, sp, lr, gp, 0, nil, 0x7fffffff, dumpframe, noescape(unsafe.Pointer(&child)), 0)
heapdump.go#L380: dumpint(uint64(uintptr(unsafe.Pointer(d))))
heapdump.go#L381: dumpint(uint64(uintptr(unsafe.Pointer(gp))))
heapdump.go#L384: fn := *(**funcval)(unsafe.Pointer(&d.fn))
heapdump.go#L385: dumpint(uint64(uintptr(unsafe.Pointer(fn))))
heapdump.go#L390: dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
heapdump.go#L392: dumpint(uint64(uintptr(unsafe.Pointer(d.link))))
heapdump.go#L396: dumpint(uint64(uintptr(unsafe.Pointer(p))))
heapdump.go#L397: dumpint(uint64(uintptr(unsafe.Pointer(gp))))
heapdump.go#L399: dumpint(uint64(uintptr(unsafe.Pointer(eface._type))))
heapdump.go#L400: dumpint(uint64(uintptr(unsafe.Pointer(eface.data))))
heapdump.go#L402: dumpint(uint64(uintptr(unsafe.Pointer(p.link))))
heapdump.go#L426: func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype) {
heapdump.go#L429: dumpint(uint64(uintptr(unsafe.Pointer(fn))))
heapdump.go#L430: dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
heapdump.go#L431: dumpint(uint64(uintptr(unsafe.Pointer(fint))))
heapdump.go#L432: dumpint(uint64(uintptr(unsafe.Pointer(ot))))
heapdump.go#L443: dumpmemrange(unsafe.Pointer(firstmoduledata.data), firstmoduledata.edata-firstmoduledata.data)
heapdump.go#L449: dumpmemrange(unsafe.Pointer(firstmoduledata.bss), firstmoduledata.ebss-firstmoduledata.bss)
heapdump.go#L460: spf := (*specialfinalizer)(unsafe.Pointer(sp))
heapdump.go#L461: p := unsafe.Pointer(s.base() + uintptr(spf.special.offset))
heapdump.go#L501: dumpobj(unsafe.Pointer(p), size, makeheapobjbv(p, size))
heapdump.go#L509: if *(*byte)(unsafe.Pointer(&x)) == 1 {
heapdump.go#L544: dumpint(uint64(uintptr(unsafe.Pointer(tab))))
heapdump.go#L545: dumpint(uint64(uintptr(unsafe.Pointer(t))))
heapdump.go#L555: dumpint(uint64(uintptr(unsafe.Pointer(mp))))
heapdump.go#L600: stk := (*[100000]uintptr)(unsafe.Pointer(pstk))
heapdump.go#L602: dumpint(uint64(uintptr(unsafe.Pointer(b))))
heapdump.go#L659: spp := (*specialprofile)(unsafe.Pointer(sp))
heapdump.go#L663: dumpint(uint64(uintptr(unsafe.Pointer(spp.b))))
heapdump.go#L679: memclrNoHeapPointers(unsafe.Pointer(&typecache), unsafe.Sizeof(typecache))
heapdump.go#L680: dwrite(unsafe.Pointer(&dumphdr[0]), uintptr(len(dumphdr)))
heapdump.go#L714: sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
heapdump.go#L732: sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
histogram.go#L128: return *(*float64)(unsafe.Pointer(&inf))
histogram.go#L133: return *(*float64)(unsafe.Pointer(&inf))
iface.go#L54: t := (*itabTableType)(atomic.Loadp(unsafe.Pointer(&itabTable)))
iface.go#L104: p := (**itab)(add(unsafe.Pointer(&t.entries), h*goarch.PtrSize))
iface.go#L108: m := (*itab)(atomic.Loadp(unsafe.Pointer(p)))
iface.go#L149: atomicstorep(unsafe.Pointer(&itabTable), unsafe.Pointer(t2))
iface.go#L165: p := (**itab)(add(unsafe.Pointer(&t.entries), h*goarch.PtrSize))
iface.go#L179: atomic.StorepNoWB(unsafe.Pointer(p), unsafe.Pointer(m))
iface.go#L203: xmhdr := (*[1 << 16]method)(add(unsafe.Pointer(x), uintptr(x.moff)))[:nt:nt]
iface.go#L205: methods := (*[1 << 16]unsafe.Pointer)(unsafe.Pointer(&m.fun[0]))[:ni:ni]
iface.go#L206: var fun0 unsafe.Pointer
iface.go#L321: func convT(t *_type, v unsafe.Pointer) unsafe.Pointer {
iface.go#L335: func convTnoptr(t *_type, v unsafe.Pointer) unsafe.Pointer {
iface.go#L352: func convT16(val uint16) (x unsafe.Pointer) {
iface.go#L354: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L365: func convT32(val uint32) (x unsafe.Pointer) {
iface.go#L367: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L378: func convT64(val uint64) (x unsafe.Pointer) {
iface.go#L380: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L388: func convTstring(val string) (x unsafe.Pointer) {
iface.go#L390: x = unsafe.Pointer(&zeroVal[0])
iface.go#L398: func convTslice(val []byte) (x unsafe.Pointer) {
iface.go#L400: if (*slice)(unsafe.Pointer(&val)).array == nil {
iface.go#L401: x = unsafe.Pointer(&zeroVal[0])
iface.go#L485: m := *(**itab)(add(unsafe.Pointer(&t.entries), i*goarch.PtrSize))
lfstack.go#L41: func (head *lfstack) pop() unsafe.Pointer {
lfstack.go#L50: return unsafe.Pointer(node)
lfstack.go#L64: println("runtime: bad lfnode address", hex(uintptr(unsafe.Pointer(node))))
lfstack_64bit.go#L43: return uint64(uintptr(unsafe.Pointer(node)))<<(64-aixAddrBits) | uint64(cnt&(1<<aixCntBits-1))
lfstack_64bit.go#L45: return uint64(uintptr(unsafe.Pointer(node)))<<(64-addrBits) | uint64(cnt&(1<<cntBits-1))
lfstack_64bit.go#L52: return (*lfnode)(unsafe.Pointer(uintptr(int64(val) >> cntBits << 3)))
lfstack_64bit.go#L55: return (*lfnode)(unsafe.Pointer(uintptr((val >> aixCntBits << 3) | 0xa<<56)))
lfstack_64bit.go#L57: return (*lfnode)(unsafe.Pointer(uintptr(val >> cntBits << 3)))
lock_futex.go#L43: return (*uint32)(unsafe.Pointer(p))
malloc.go#L613: a, size := sysReserveAligned(unsafe.Pointer(p), arenaSize, heapArenaBytes)
malloc.go#L636: func (h *mheap) sysAlloc(n uintptr) (v unsafe.Pointer, size uintptr) {
malloc.go#L662: v = sysReserve(unsafe.Pointer(p), n)
malloc.go#L683: h.arenaHintAlloc.free(unsafe.Pointer(hint))
malloc.go#L745: atomic.StorepNoWB(unsafe.Pointer(&h.arenas[ri.l1()]), unsafe.Pointer(l2))
malloc.go#L771: *(*notInHeapSlice)(unsafe.Pointer(&h.allArenas)) = notInHeapSlice{newArray, len(h.allArenas), int(size / goarch.PtrSize)}
malloc.go#L785: atomic.StorepNoWB(unsafe.Pointer(&l2[ri.l2()]), unsafe.Pointer(r))
malloc.go#L799: func sysReserveAligned(v unsafe.Pointer, size, align uintptr) (unsafe.Pointer, uintptr) {
malloc.go#L812: return unsafe.Pointer(p), size + align
malloc.go#L818: sysFree(unsafe.Pointer(p), size+align, nil)
malloc.go#L820: p2 := sysReserve(unsafe.Pointer(p), size)
malloc.go#L834: sysFree(unsafe.Pointer(p), pAligned-p, nil)
malloc.go#L838: sysFree(unsafe.Pointer(end), endLen, nil)
malloc.go#L840: return unsafe.Pointer(pAligned), size
malloc.go#L909: func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc.go#L915: return unsafe.Pointer(&zerobase)
malloc.go#L994: var x unsafe.Pointer
malloc.go#L1049: x = unsafe.Pointer(c.tiny + off)
malloc.go#L1062: x = unsafe.Pointer(v)
malloc.go#L1087: x = unsafe.Pointer(v)
malloc.go#L1089: memclrNoHeapPointers(unsafe.Pointer(v), size)
malloc.go#L1100: x = unsafe.Pointer(span.base())
malloc.go#L1236: func memclrNoHeapPointersChunked(size uintptr, x unsafe.Pointer) {
malloc.go#L1251: memclrNoHeapPointers(unsafe.Pointer(voff), n)
malloc.go#L1258: func newobject(typ *_type) unsafe.Pointer {
malloc.go#L1263: func reflect_unsafe_New(typ *_type) unsafe.Pointer {
malloc.go#L1268: func reflectlite_unsafe_New(typ *_type) unsafe.Pointer {
malloc.go#L1273: func newarray(typ *_type, n int) unsafe.Pointer {
malloc.go#L1285: func reflect_unsafe_NewArray(typ *_type, n int) unsafe.Pointer {
malloc.go#L1289: func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
malloc.go#L1393: func persistentalloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer {
malloc.go#L1398: return unsafe.Pointer(p)
malloc.go#L1447: chunks := uintptr(unsafe.Pointer(persistentChunks))
malloc.go#L1448: *(*uintptr)(unsafe.Pointer(persistent.base)) = chunks
malloc.go#L1449: if atomic.Casuintptr((*uintptr)(unsafe.Pointer(&persistentChunks)), chunks, uintptr(unsafe.Pointer(persistent.base))) {
malloc.go#L1474: chunk := atomic.Loaduintptr((*uintptr)(unsafe.Pointer(&persistentChunks)))
malloc.go#L1479: chunk = *(*uintptr)(unsafe.Pointer(chunk))
malloc.go#L1510: func (l *linearAlloc) alloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer {
malloc.go#L1519: sysMap(unsafe.Pointer(l.mapped), pEnd-l.mapped, sysStat)
malloc.go#L1520: sysUsed(unsafe.Pointer(l.mapped), pEnd-l.mapped)
malloc.go#L1524: return unsafe.Pointer(p)
malloc.go#L1540: return (*notInHeap)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + bytes))
map.go#L125: buckets unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
map.go#L126: oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
map.go#L166: key unsafe.Pointer // Must be in first position. Write nil to indicate iteration end (see cmd/compile/internal/walk/range.go).
map.go#L167: elem unsafe.Pointer // Must be in second position (see cmd/compile/internal/walk/range.go).
map.go#L170: buckets unsafe.Pointer // bucket ptr at hash_iter initialization time
map.go#L209: return *(**bmap)(add(unsafe.Pointer(b), uintptr(t.bucketsize)-goarch.PtrSize))
map.go#L213: *(**bmap)(add(unsafe.Pointer(b), uintptr(t.bucketsize)-goarch.PtrSize)) = ovf
map.go#L216: func (b *bmap) keys() unsafe.Pointer {
map.go#L217: return add(unsafe.Pointer(b), dataOffset)
map.go#L254: h.extra.nextOverflow = (*bmap)(add(unsafe.Pointer(ovf), uintptr(t.bucketsize)))
map.go#L345: func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) {
map.go#L395: func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map.go#L399: racereadpc(unsafe.Pointer(h), callerpc, pc)
map.go#L412: return unsafe.Pointer(&zeroVal[0])
map.go#L440: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L442: k = *((*unsafe.Pointer)(k))
map.go#L445: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L447: e = *((*unsafe.Pointer)(e))
map.go#L453: return unsafe.Pointer(&zeroVal[0])
map.go#L456: func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool) {
map.go#L460: racereadpc(unsafe.Pointer(h), callerpc, pc)
map.go#L473: return unsafe.Pointer(&zeroVal[0]), false
map.go#L501: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L503: k = *((*unsafe.Pointer)(k))
map.go#L506: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L508: e = *((*unsafe.Pointer)(e))
map.go#L514: return unsafe.Pointer(&zeroVal[0]), false
map.go#L518: func mapaccessK(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer) {
map.go#L545: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L547: k = *((*unsafe.Pointer)(k))
map.go#L550: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L552: e = *((*unsafe.Pointer)(e))
map.go#L561: func mapaccess1_fat(t *maptype, h *hmap, key, zero unsafe.Pointer) unsafe.Pointer {
map.go#L563: if e == unsafe.Pointer(&zeroVal[0]) {
map.go#L569: func mapaccess2_fat(t *maptype, h *hmap, key, zero unsafe.Pointer) (unsafe.Pointer, bool) {
map.go#L571: if e == unsafe.Pointer(&zeroVal[0]) {
map.go#L578: func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map.go#L585: racewritepc(unsafe.Pointer(h), callerpc, pc)
map.go#L616: var insertk unsafe.Pointer
map.go#L617: var elem unsafe.Pointer
map.go#L624: insertk = add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L625: elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L632: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L634: k = *((*unsafe.Pointer)(k))
map.go#L643: elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L666: insertk = add(unsafe.Pointer(newb), dataOffset)
map.go#L673: *(*unsafe.Pointer)(insertk) = kmem
map.go#L678: *(*unsafe.Pointer)(elem) = vmem
map.go#L690: elem = *((*unsafe.Pointer)(elem))
map.go#L695: func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
map.go#L699: racewritepc(unsafe.Pointer(h), callerpc, pc)
map.go#L740: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L743: k2 = *((*unsafe.Pointer)(k2))
map.go#L750: *(*unsafe.Pointer)(k) = nil
map.go#L754: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L756: *(*unsafe.Pointer)(e) = nil
map.go#L818: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapiterinit))
map.go#L868: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapiternext))
map.go#L918: k := add(unsafe.Pointer(b), dataOffset+uintptr(offi)*uintptr(t.keysize))
map.go#L920: k = *((*unsafe.Pointer)(k))
map.go#L922: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+uintptr(offi)*uintptr(t.elemsize))
map.go#L959: e = *((*unsafe.Pointer)(e))
map.go#L995: racewritepc(unsafe.Pointer(h), callerpc, pc)
map.go#L1146: k unsafe.Pointer // pointer to current key storage
map.go#L1147: e unsafe.Pointer // pointer to current elem storage
map.go#L1161: x.k = add(unsafe.Pointer(x.b), dataOffset)
map.go#L1169: y.k = add(unsafe.Pointer(y.b), dataOffset)
map.go#L1174: k := add(unsafe.Pointer(b), dataOffset)
map.go#L1187: k2 = *((*unsafe.Pointer)(k2))
map.go#L1225: dst.k = add(unsafe.Pointer(dst.b), dataOffset)
map.go#L1230: *(*unsafe.Pointer)(dst.k) = k2 // copy pointer
map.go#L1235: *(*unsafe.Pointer)(dst.e) = *(*unsafe.Pointer)(e)
map.go#L1330: func reflect_mapaccess(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map.go#L1340: func reflect_mapaccess_faststr(t *maptype, h *hmap, key string) unsafe.Pointer {
map.go#L1350: func reflect_mapassign(t *maptype, h *hmap, key unsafe.Pointer, elem unsafe.Pointer) {
map.go#L1356: func reflect_mapassign_faststr(t *maptype, h *hmap, key string, elem unsafe.Pointer) {
map.go#L1362: func reflect_mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
map.go#L1382: func reflect_mapiterkey(it *hiter) unsafe.Pointer {
map.go#L1387: func reflect_mapiterelem(it *hiter) unsafe.Pointer {
map.go#L1398: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(reflect_maplen))
map.go#L1410: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(reflect_maplen))
map_fast32.go#L13: func mapaccess1_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
map_fast32.go#L16: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapaccess1_fast32))
map_fast32.go#L19: return unsafe.Pointer(&zeroVal[0])
map_fast32.go#L29: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L46: return add(unsafe.Pointer(b), dataOffset+bucketCnt*4+i*uintptr(t.elemsize))
map_fast32.go#L50: return unsafe.Pointer(&zeroVal[0])
map_fast32.go#L53: func mapaccess2_fast32(t *maptype, h *hmap, key uint32) (unsafe.Pointer, bool) {
map_fast32.go#L56: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapaccess2_fast32))
map_fast32.go#L59: return unsafe.Pointer(&zeroVal[0]), false
map_fast32.go#L69: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L86: return add(unsafe.Pointer(b), dataOffset+bucketCnt*4+i*uintptr(t.elemsize)), true
map_fast32.go#L90: return unsafe.Pointer(&zeroVal[0]), false
map_fast32.go#L93: func mapassign_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
map_fast32.go#L99: racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapassign_fast32))
map_fast32.go#L104: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L122: var insertk unsafe.Pointer
map_fast32.go#L137: k := *((*uint32)(add(unsafe.Pointer(b), dataOffset+i*4)))
map_fast32.go#L168: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*4)
map_fast32.go#L175: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*4+inserti*uintptr(t.elemsize))
map_fast32.go#L183: func mapassign_fast32ptr(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map_fast32.go#L189: racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapassign_fast32))
map_fast32.go#L194: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L212: var insertk unsafe.Pointer
map_fast32.go#L227: k := *((*unsafe.Pointer)(add(unsafe.Pointer(b), dataOffset+i*4)))
map_fast32.go#L258: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*4)
map_fast32.go#L260: *(*unsafe.Pointer)(insertk) = key
map_fast32.go#L265: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*4+inserti*uintptr(t.elemsize))
map_fast32.go#L276: racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapdelete_fast32))
map_fast32.go#L285: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L308: *(*unsafe.Pointer)(k) = nil
map_fast32.go#L310: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*4+i*uintptr(t.elemsize))
map_fast32.go#L385: x.k = add(unsafe.Pointer(x.b), dataOffset)
map_fast32.go#L393: y.k = add(unsafe.Pointer(y.b), dataOffset)
map_fast32.go#L398: k := add(unsafe.Pointer(b), dataOffset)
map_fast32.go#L425: dst.k = add(unsafe.Pointer(dst.b), dataOffset)
map_fast32.go#L433: *(*unsafe.Pointer)(dst.k) = *(*unsafe.Pointer)(k)
map_fast64.go#L13: func mapaccess1_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
map_fast64.go#L16: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapaccess1_fast64))
map_fast64.go#L19: return unsafe.Pointer(&zeroVal[0])
map_fast64.go#L29: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L46: return add(unsafe.Pointer(b), dataOffset+bucketCnt*8+i*uintptr(t.elemsize))
map_fast64.go#L50: return unsafe.Pointer(&zeroVal[0])
map_fast64.go#L53: func mapaccess2_fast64(t *maptype, h *hmap, key uint64) (unsafe.Pointer, bool) {
map_fast64.go#L56: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapaccess2_fast64))
map_fast64.go#L59: return unsafe.Pointer(&zeroVal[0]), false
map_fast64.go#L69: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L86: return add(unsafe.Pointer(b), dataOffset+bucketCnt*8+i*uintptr(t.elemsize)), true
map_fast64.go#L90: return unsafe.Pointer(&zeroVal[0]), false
map_fast64.go#L93: func mapassign_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
map_fast64.go#L99: racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapassign_fast64))
map_fast64.go#L104: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L122: var insertk unsafe.Pointer
map_fast64.go#L137: k := *((*uint64)(add(unsafe.Pointer(b), dataOffset+i*8)))
map_fast64.go#L168: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*8)
map_fast64.go#L175: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*8+inserti*uintptr(t.elemsize))
map_fast64.go#L183: func mapassign_fast64ptr(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map_fast64.go#L189: racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapassign_fast64))
map_fast64.go#L194: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L212: var insertk unsafe.Pointer
map_fast64.go#L227: k := *((*unsafe.Pointer)(add(unsafe.Pointer(b), dataOffset+i*8)))
map_fast64.go#L258: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*8)
map_fast64.go#L260: *(*unsafe.Pointer)(insertk) = key
map_fast64.go#L265: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*8+inserti*uintptr(t.elemsize))
map_fast64.go#L276: racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapdelete_fast64))
map_fast64.go#L285: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L305: *(*unsafe.Pointer)(k) = nil
map_fast64.go#L312: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*8+i*uintptr(t.elemsize))
map_fast64.go#L387: x.k = add(unsafe.Pointer(x.b), dataOffset)
map_fast64.go#L395: y.k = add(unsafe.Pointer(y.b), dataOffset)
map_fast64.go#L400: k := add(unsafe.Pointer(b), dataOffset)
map_fast64.go#L427: dst.k = add(unsafe.Pointer(dst.b), dataOffset)
map_fast64.go#L436: *(*unsafe.Pointer)(dst.k) = *(*unsafe.Pointer)(k)
map_faststr.go#L13: func mapaccess1_faststr(t *maptype, h *hmap, ky string) unsafe.Pointer {
map_faststr.go#L16: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapaccess1_faststr))
map_faststr.go#L19: return unsafe.Pointer(&zeroVal[0])
map_faststr.go#L39: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+i*uintptr(t.elemsize))
map_faststr.go#L42: return unsafe.Pointer(&zeroVal[0])
map_faststr.go#L55: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+i*uintptr(t.elemsize))
map_faststr.go#L72: k := (*stringStruct)(add(unsafe.Pointer(b), dataOffset+keymaybe*2*goarch.PtrSize))
map_faststr.go#L74: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+keymaybe*uintptr(t.elemsize))
map_faststr.go#L77: return unsafe.Pointer(&zeroVal[0])
map_faststr.go#L80: hash := t.hasher(noescape(unsafe.Pointer(&ky)), uintptr(h.hash0))
map_faststr.go#L101: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+i*uintptr(t.elemsize))
map_faststr.go#L105: return unsafe.Pointer(&zeroVal[0])
map_faststr.go#L108: func mapaccess2_faststr(t *maptype, h *hmap, ky string) (unsafe.Pointer, bool) {
map_faststr.go#L111: racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapaccess2_faststr))
map_faststr.go#L114: return unsafe.Pointer(&zeroVal[0]), false
map_faststr.go#L134: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+i*uintptr(t.elemsize)), true
map_faststr.go#L137: return unsafe.Pointer(&zeroVal[0]), false
map_faststr.go#L150: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+i*uintptr(t.elemsize)), true
map_faststr.go#L167: k := (*stringStruct)(add(unsafe.Pointer(b), dataOffset+keymaybe*2*goarch.PtrSize))
map_faststr.go#L169: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+keymaybe*uintptr(t.elemsize)), true
map_faststr.go#L172: return unsafe.Pointer(&zeroVal[0]), false
map_faststr.go#L175: hash := t.hasher(noescape(unsafe.Pointer(&ky)), uintptr(h.hash0))
map_faststr.go#L196: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+i*uintptr(t.elemsize)), true
map_faststr.go#L200: return unsafe.Pointer(&zeroVal[0]), false
map_faststr.go#L203: func mapassign_faststr(t *maptype, h *hmap, s string) unsafe.Pointer {
map_faststr.go#L209: racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapassign_faststr))
map_faststr.go#L215: hash := t.hasher(noescape(unsafe.Pointer(&s)), uintptr(h.hash0))
map_faststr.go#L234: var insertk unsafe.Pointer
map_faststr.go#L249: k := (*stringStruct)(add(unsafe.Pointer(b), dataOffset+i*2*goarch.PtrSize))
map_faststr.go#L287: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*2*goarch.PtrSize)
map_faststr.go#L293: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*2*goarch.PtrSize+inserti*uintptr(t.elemsize))
map_faststr.go#L304: racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapdelete_faststr))
map_faststr.go#L314: hash := t.hasher(noescape(unsafe.Pointer(&ky)), uintptr(h.hash0))
map_faststr.go#L338: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*2*goarch.PtrSize+i*uintptr(t.elemsize))
map_faststr.go#L413: x.k = add(unsafe.Pointer(x.b), dataOffset)
map_faststr.go#L421: y.k = add(unsafe.Pointer(y.b), dataOffset)
map_faststr.go#L426: k := add(unsafe.Pointer(b), dataOffset)
map_faststr.go#L453: dst.k = add(unsafe.Pointer(dst.b), dataOffset)
mbarrier.go#L157: func typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L178: func reflect_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L195: func reflectlite_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L203: func reflect_typedmemmovepartial(typ *_type, dst, src unsafe.Pointer, off, size uintptr) {
mbarrier.go#L231: func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr, regs *abi.RegArgs) {
mbarrier.go#L240: regs.Ptrs[i] = unsafe.Pointer(regs.Ints[i])
mbarrier.go#L246: func typedslicecopy(typ *_type, dstPtr unsafe.Pointer, dstLen int, srcPtr unsafe.Pointer, srcLen int) int {
mbarrier.go#L314: func typedmemclr(typ *_type, ptr unsafe.Pointer) {
mbarrier.go#L322: func reflect_typedmemclr(typ *_type, ptr unsafe.Pointer) {
mbarrier.go#L327: func reflect_typedmemclrpartial(typ *_type, ptr unsafe.Pointer, off, size uintptr) {
mbarrier.go#L340: func memclrHasPointers(ptr unsafe.Pointer, n uintptr) {
mbitmap.go#L74: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + n))
mbitmap.go#L84: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) - n))
mbitmap.go#L94: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + 1))
mbitmap.go#L106: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) - 1))
mbitmap.go#L150: bytes := (*[8]uint8)(unsafe.Pointer(s.allocBits.bytep(whichByte)))
mbitmap.go#L304: m.bytep = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(m.bytep)) + 1))
mbitmap.go#L483: nbitp := uintptr(unsafe.Pointer(h.bitp)) + n/4
mbitmap.go#L485: if nbitp <= uintptr(unsafe.Pointer(h.last)) {
mbitmap.go#L486: h.bitp = (*uint8)(unsafe.Pointer(nbitp))
mbitmap.go#L491: past := nbitp - (uintptr(unsafe.Pointer(h.last)) + 1)
mbitmap.go#L508: maxn := 4 * ((uintptr(unsafe.Pointer(h.last)) + 1) - uintptr(unsafe.Pointer(h.bitp)))
mbitmap.go#L607: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L617: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L618: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L648: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L682: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L688: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L741: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L742: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L782: memclrNoHeapPointers(unsafe.Pointer(h.bitp), nbyte)
mbitmap.go#L803: mrkBits := *(*uint64)(unsafe.Pointer(s.gcmarkBits.bytep(i)))
mbitmap.go#L994: h.bitp = (*uint8)(unsafe.Pointer(x))
mbitmap.go#L1339: src := (*uint8)(unsafe.Pointer(x))
mbitmap.go#L1369: memmove(unsafe.Pointer(h.bitp), unsafe.Pointer(src), n)
mbitmap.go#L1385: if uintptr(unsafe.Pointer(src)) > x+size {
mbitmap.go#L1396: memclrNoHeapPointers(unsafe.Pointer(x), uintptr(unsafe.Pointer(src))-x)
mbitmap.go#L1560: endProg := unsafe.Pointer(addb(h.bitp, (totalBits+3)/4))
mbitmap.go#L1561: endAlloc := unsafe.Pointer(addb(h.bitp, allocSize/goarch.PtrSize/wordsPerBitmapByte))
mbitmap.go#L1858: totalBits = (uintptr(unsafe.Pointer(dst))-uintptr(unsafe.Pointer(dstStart)))*8 + nbits
mbitmap.go#L1866: totalBits = (uintptr(unsafe.Pointer(dst))-uintptr(unsafe.Pointer(dstStart)))*4 + nbits
mbitmap.go#L1889: runGCProg(addb(prog, 4), nil, (*byte)(unsafe.Pointer(s.startAddr)), 1)
mbitmap.go#L1943: func getgcmaskcb(frame *stkframe, ctxt unsafe.Pointer) bool {
mbitmap.go#L1957: typ := (*ptrtype)(unsafe.Pointer(efaceOf(&x)._type)).elem
mbitmap.go#L1977: n := (*ptrtype)(unsafe.Pointer(t)).elem.size
mbitmap.go#L1989: n := (*ptrtype)(unsafe.Pointer(t)).elem.size
mbitmap.go#L2022: gentraceback(_g_.m.curg.sched.pc, _g_.m.curg.sched.sp, 0, _g_.m.curg, 0, nil, 1000, getgcmaskcb, noescape(unsafe.Pointer(&frame)), 0)
mbitmap.go#L2029: n := (*ptrtype)(unsafe.Pointer(t)).elem.size
mcache.go#L73: return (*gclink)(unsafe.Pointer(p))
mcache.go#L116: mheap_.cachealloc.free(unsafe.Pointer(c))
mem_linux.go#L20: func sysAlloc(n uintptr, sysStat *sysMemStat) unsafe.Pointer {
mem_linux.go#L39: func sysUnused(v unsafe.Pointer, n uintptr) {
mem_linux.go#L86: madvise(unsafe.Pointer(head), 2*physHugePageSize, _MADV_NOHUGEPAGE)
mem_linux.go#L90: madvise(unsafe.Pointer(head), physHugePageSize, _MADV_NOHUGEPAGE)
mem_linux.go#L93: madvise(unsafe.Pointer(tail), physHugePageSize, _MADV_NOHUGEPAGE)
mem_linux.go#L126: func sysUsed(v unsafe.Pointer, n uintptr) {
mem_linux.go#L151: func sysHugePage(v unsafe.Pointer, n uintptr) {
mem_linux.go#L159: madvise(unsafe.Pointer(beg), end-beg, _MADV_HUGEPAGE)
mem_linux.go#L167: func sysFree(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) {
mem_linux.go#L172: func sysFault(v unsafe.Pointer, n uintptr) {
mem_linux.go#L176: func sysReserve(v unsafe.Pointer, n uintptr) unsafe.Pointer {
mem_linux.go#L184: func sysMap(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) {
metrics.go#L505: pointer unsafe.Pointer // contains non-scalar values.
metrics.go#L518: v.pointer = unsafe.Pointer(hist)
metrics.go#L544: func readMetrics(samplesp unsafe.Pointer, len int, cap int) {
metrics.go#L547: samples := *(*[]metricSample)(unsafe.Pointer(&sl))
mfinal.go#L44: arg unsafe.Pointer // ptr to object (may be a heap pointer)
mfinal.go#L78: func queuefinalizer(p unsafe.Pointer, fn *funcval, nret uintptr, fint *_type, ot *ptrtype) {
mfinal.go#L128: func iterate_finq(callback func(*funcval, unsafe.Pointer, uintptr, *_type, *ptrtype)) {
mfinal.go#L164: frame unsafe.Pointer
mfinal.go#L213: r = unsafe.Pointer(®s.Ints)
mfinal.go#L224: *(*unsafe.Pointer)(r) = f.arg
mfinal.go#L226: ityp := (*interfacetype)(unsafe.Pointer(f.fint))
mfinal.go#L239: reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz), uint32(framesz), ®s)
mfinal.go#L340: ot := (*ptrtype)(unsafe.Pointer(etyp))
mfinal.go#L350: if e.data == unsafe.Pointer(&zerobase) {
mfinal.go#L394: ft := (*functype)(unsafe.Pointer(ftyp))
mfinal.go#L407: if (fint.uncommon() == nil || etyp.uncommon() == nil) && (*ptrtype)(unsafe.Pointer(fint)).elem == ot.elem {
mfinal.go#L413: ityp := (*interfacetype)(unsafe.Pointer(fint))
mfixalloc.go#L29: first func(arg, p unsafe.Pointer) // called first time p is returned
mfixalloc.go#L30: arg unsafe.Pointer
mfixalloc.go#L53: func (f *fixalloc) init(size uintptr, first func(arg, p unsafe.Pointer), arg unsafe.Pointer, stat *sysMemStat) {
mfixalloc.go#L73: func (f *fixalloc) alloc() unsafe.Pointer {
mfixalloc.go#L80: v := unsafe.Pointer(f.list)
mfixalloc.go#L93: v := unsafe.Pointer(f.chunk)
mfixalloc.go#L103: func (f *fixalloc) free(p unsafe.Pointer) {
mgc.go#L1207: gopark(func(g *g, nodep unsafe.Pointer) bool {
mgc.go#L1234: }, unsafe.Pointer(node), waitReasonGCWorkerIdle, traceEvGoBlock, 0)
mgc.go#L1634: func gcTestIsReachable(ptrs ...unsafe.Pointer) (mask uint64) {
mgc.go#L1680: mheap_.specialReachableAlloc.free(unsafe.Pointer(s))
mgc.go#L1695: func gcTestPointerClass(p unsafe.Pointer) string {
mgcmark.go#L183: scanblock(uintptr(unsafe.Pointer(&fb.fin[0])), cnt*unsafe.Sizeof(fb.fin[0]), &finptrmask[0], gcw, nil)
mgcmark.go#L281: ptrmask := (*uint8)(add(unsafe.Pointer(ptrmask0), uintptr(shard)*(rootBlockBytes/(8*goarch.PtrSize))))
mgcmark.go#L386: spf := (*specialfinalizer)(unsafe.Pointer(sp))
mgcmark.go#L396: scanblock(uintptr(unsafe.Pointer(&spf.fn)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
mgcmark.go#L585: gp.param = unsafe.Pointer(gp)
mgcmark.go#L775: scanblock(uintptr(unsafe.Pointer(&gp.sched.ctxt)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L779: scanframe := func(frame *stkframe, unused unsafe.Pointer) bool {
mgcmark.go#L793: scanblock(uintptr(unsafe.Pointer(&d.fn)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L798: scanblock(uintptr(unsafe.Pointer(&d.link)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L804: scanblock(uintptr(unsafe.Pointer(&d)), goarch.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L809: state.putPtr(uintptr(unsafe.Pointer(gp._panic)), false)
mgcmark.go#L855: gcdata = (*byte)(unsafe.Pointer(s.startAddr))
mgcmark.go#L886: putempty((*workbuf)(unsafe.Pointer(x)))
mgcmark.go#L1213: p := *(*uintptr)(unsafe.Pointer(b + i))
mgcmark.go#L1302: obj := *(*uintptr)(unsafe.Pointer(b + i))
mgcmark.go#L1346: val := *(*uintptr)(unsafe.Pointer(p))
mgcmark.go#L1386: val := *(*uintptr)(unsafe.Pointer(b + i))
mgcmark.go#L1526: print(" *(", label, "+", i, ") = ", hex(*(*uintptr)(unsafe.Pointer(obj + i))))
mgcscavenge.go#L668: l2 := (*[1 << pallocChunksL2Bits]pallocData)(atomic.Loadp(unsafe.Pointer(&p.chunks[i.l1()])))
mgcscavenge.go#L775: sysUnused(unsafe.Pointer(addr), uintptr(npages)*pageSize)
mgcstack.go#L165: *(*uintptr)(unsafe.Pointer(&obj.r)) = uintptr(unsafe.Pointer(r))
mgcstack.go#L217: buf = (*stackWorkBuf)(unsafe.Pointer(getempty()))
mgcstack.go#L226: buf = (*stackWorkBuf)(unsafe.Pointer(getempty()))
mgcstack.go#L251: putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
mgcstack.go#L267: putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
mgcstack.go#L278: x = (*stackObjectBuf)(unsafe.Pointer(getempty()))
mgcstack.go#L288: y := (*stackObjectBuf)(unsafe.Pointer(getempty()))
mgcsweep.go#L542: freeSpecial(special, unsafe.Pointer(p), size)
mgcsweep.go#L554: (*specialReachable)(unsafe.Pointer(special)).reachable = true
mgcsweep.go#L555: freeSpecial(special, unsafe.Pointer(p), size)
mgcsweep.go#L575: tracefree(unsafe.Pointer(x), size)
mgcsweep.go#L578: clobberfree(unsafe.Pointer(x), size)
mgcsweep.go#L581: racefree(unsafe.Pointer(x), size)
mgcsweep.go#L584: msanfree(unsafe.Pointer(x), size)
mgcsweep.go#L587: asanpoison(unsafe.Pointer(x), size)
mgcsweep.go#L711: sysFault(unsafe.Pointer(s.base()), size)
mgcsweep.go#L830: func clobberfree(x unsafe.Pointer, size uintptr) {
mgcwork.go#L388: newb := (*workbuf)(unsafe.Pointer(s.base() + i))
mgcwork.go#L437: memmove(unsafe.Pointer(&b1.obj[0]), unsafe.Pointer(&b.obj[b.nobj]), uintptr(n)*unsafe.Sizeof(b1.obj[0]))
mheap.go#L490: func recordspan(vh unsafe.Pointer, p unsafe.Pointer) {
mheap.go#L502: sp := (*slice)(unsafe.Pointer(&new))
mheap.go#L513: *(*notInHeapSlice)(unsafe.Pointer(&h.allspans)) = *(*notInHeapSlice)(unsafe.Pointer(&new))
mheap.go#L515: sysFree(unsafe.Pointer(&oldAllspans[0]), uintptr(cap(oldAllspans))*unsafe.Sizeof(oldAllspans[0]), &memstats.other_sys)
mheap.go#L701: h.spanalloc.init(unsafe.Sizeof(mspan{}), recordspan, unsafe.Pointer(h), &memstats.mspan_sys)
mheap.go#L1099: h.spanalloc.free(unsafe.Pointer(s))
mheap.go#L1279: sysUsed(unsafe.Pointer(base), nbytes)
mheap.go#L1376: sysMap(unsafe.Pointer(h.curArena.base), size, &memstats.heap_sys)
mheap.go#L1404: sysMap(unsafe.Pointer(v), nBase-v, &memstats.heap_sys)
mheap.go#L1430: base := unsafe.Pointer(s.base())
mheap.go#L1436: base := unsafe.Pointer(s.base())
mheap.go#L1710: func addspecial(p unsafe.Pointer, s *special) bool {
mheap.go#L1759: func removespecial(p unsafe.Pointer, kind uint8) *special {
mheap.go#L1813: func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool {
mheap.go#L1836: scanblock(uintptr(unsafe.Pointer(&s.fn)), goarch.PtrSize, &oneptrmask[0], gcw, nil)
mheap.go#L1844: mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
mheap.go#L1850: func removefinalizer(p unsafe.Pointer) {
mheap.go#L1851: s := (*specialfinalizer)(unsafe.Pointer(removespecial(p, _KindSpecialFinalizer)))
mheap.go#L1856: mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
mheap.go#L1869: func setprofilebucket(p unsafe.Pointer, b *bucket) {
mheap.go#L1918: func freeSpecial(s *special, p unsafe.Pointer, size uintptr) {
mheap.go#L1921: sf := (*specialfinalizer)(unsafe.Pointer(s))
mheap.go#L1924: mheap_.specialfinalizeralloc.free(unsafe.Pointer(sf))
mheap.go#L1927: sp := (*specialprofile)(unsafe.Pointer(s))
mheap.go#L1930: mheap_.specialprofilealloc.free(unsafe.Pointer(sp))
mheap.go#L1933: sp := (*specialReachable)(unsafe.Pointer(s))
mheap.go#L2005: head := (*gcBitsArena)(atomic.Loadp(unsafe.Pointer(&gcBitsArenas.next)))
mheap.go#L2044: atomic.StorepNoWB(unsafe.Pointer(&gcBitsArenas.next), unsafe.Pointer(fresh))
mheap.go#L2090: atomic.StorepNoWB(unsafe.Pointer(&gcBitsArenas.next), nil) // newMarkBits calls newArena when needed
mheap.go#L2108: memclrNoHeapPointers(unsafe.Pointer(result), gcBitsChunkBytes)
mheap.go#L2116: result.free = 8 - (uintptr(unsafe.Pointer(&result.bits[0])) & 7)
mpagealloc.go#L415: atomic.StorepNoWB(unsafe.Pointer(&p.chunks[c.l1()]), r)
mpagealloc_64bit.go#L83: p.summary[l] = *(*[]pallocSum)(unsafe.Pointer(&sl))
mpagealloc_64bit.go#L117: base := unsafe.Pointer(&p.summary[level][0])
mpagealloc_64bit.go#L175: sysMap(unsafe.Pointer(need.base.addr()), need.size(), p.sysStat)
mpagealloc_64bit.go#L176: sysUsed(unsafe.Pointer(need.base.addr()), need.size())
mprof.go#L183: stk := (*[maxStack]uintptr)(add(unsafe.Pointer(b), unsafe.Sizeof(*b)))
mprof.go#L192: data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
mprof.go#L201: data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
mprof.go#L341: func mProf_Malloc(p unsafe.Pointer, size uintptr) {
mprof.go#L625: racewriterangepc(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0), getcallerpc(), abi.FuncPCABIInternal(MemProfile))
mprof.go#L628: msanwrite(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0))
mprof.go#L631: asanwrite(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0))
mprof.go#L681: racewriterangepc(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0), getcallerpc(), abi.FuncPCABIInternal(BlockProfile))
mprof.go#L684: msanwrite(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0))
mprof.go#L687: asanwrite(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0))
mprof.go#L736: first := (*m)(atomic.Loadp(unsafe.Pointer(&allm)))
mprof.go#L752: func runtime_goroutineProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L757: func goroutineProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L885: func tracealloc(p unsafe.Pointer, size uintptr, typ *_type) {
mprof.go#L910: func tracefree(p unsafe.Pointer, size uintptr) {
mranges.go#L167: ranges := (*notInHeapSlice)(unsafe.Pointer(&a.ranges))
mranges.go#L294: ranges := (*notInHeapSlice)(unsafe.Pointer(&a.ranges))
mranges.go#L364: 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#L36: spine unsafe.Pointer // *[N]*spanSetBlock, accessed atomically
mspanset.go#L84: spine := atomic.Loadp(unsafe.Pointer(&b.spine))
mspanset.go#L112: atomic.StorepNoWB(unsafe.Pointer(&b.spine), newSpine)
mspanset.go#L129: atomic.StorepNoWB(blockp, unsafe.Pointer(block))
mspanset.go#L136: atomic.StorepNoWB(unsafe.Pointer(&block.spans[bottom]), unsafe.Pointer(s))
mspanset.go#L183: spine := atomic.Loadp(unsafe.Pointer(&b.spine))
mspanset.go#L190: s := (*mspan)(atomic.Loadp(unsafe.Pointer(&block.spans[bottom])))
mspanset.go#L195: s = (*mspan)(atomic.Loadp(unsafe.Pointer(&block.spans[bottom])))
mspanset.go#L200: atomic.StorepNoWB(unsafe.Pointer(&block.spans[bottom]), nil)
mspanset.go#L262: atomic.StorepNoWB(unsafe.Pointer(blockp), nil)
mwbbuf.go#L81: start := uintptr(unsafe.Pointer(&b.buf[0]))
mwbbuf.go#L86: b.end = uintptr(unsafe.Pointer(&b.buf[wbBufEntryPointers]))
mwbbuf.go#L92: b.end = uintptr(unsafe.Pointer(&b.buf[2*wbBufEntryPointers]))
mwbbuf.go#L108: b.next = uintptr(unsafe.Pointer(&b.buf[0]))
mwbbuf.go#L113: return b.next == uintptr(unsafe.Pointer(&b.buf[0]))
mwbbuf.go#L145: p := (*[2]uintptr)(unsafe.Pointer(b.next))
mwbbuf.go#L217: start := uintptr(unsafe.Pointer(&_p_.wbBuf.buf[0]))
netpoll.go#L475: func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
netpoll.go#L476: r := atomic.Casuintptr((*uintptr)(gpp), pdWait, uintptr(unsafe.Pointer(gp)))
netpoll.go#L522: gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceEvGoBlockNet, 5)
netpoll.go#L556: return (*g)(unsafe.Pointer(old))
netpoll.go#L643: x := (*eface)(unsafe.Pointer(&i))
netpoll.go#L645: x.data = unsafe.Pointer(&pd.self)
netpoll_epoll.go#L50: *(**uintptr)(unsafe.Pointer(&ev.data)) = &netpollBreakRd
netpoll_epoll.go#L67: *(**pollDesc)(unsafe.Pointer(&ev.data)) = pd
netpoll_epoll.go#L85: n := write(netpollBreakWr, unsafe.Pointer(&b), 1)
netpoll_epoll.go#L146: if *(**uintptr)(unsafe.Pointer(&ev.data)) == &netpollBreakRd {
netpoll_epoll.go#L156: read(int32(netpollBreakRd), noescape(unsafe.Pointer(&tmp[0])), int32(len(tmp)))
netpoll_epoll.go#L170: pd := *(**pollDesc)(unsafe.Pointer(&ev.data))
os_linux.go#L37: func futex(addr unsafe.Pointer, op int32, val uint32, ts, addr2 unsafe.Pointer, val3 uint32) int32
os_linux.go#L66: futex(unsafe.Pointer(addr), _FUTEX_WAIT_PRIVATE, val, nil, nil, 0)
os_linux.go#L72: futex(unsafe.Pointer(addr), _FUTEX_WAIT_PRIVATE, val, unsafe.Pointer(&ts), nil, 0)
os_linux.go#L78: ret := futex(unsafe.Pointer(addr), _FUTEX_WAKE_PRIVATE, cnt, nil, nil, 0)
os_linux.go#L90: *(*int32)(unsafe.Pointer(uintptr(0x1006))) = 0x1006
os_linux.go#L157: func clone(flags int32, stk, mp, gp, fn unsafe.Pointer) int32
os_linux.go#L162: stk := unsafe.Pointer(mp.g0.stack.hi)
os_linux.go#L174: ret := clone(cloneFlags, stk, unsafe.Pointer(mp), unsafe.Pointer(mp.g0), unsafe.Pointer(abi.FuncPCABI0(mstart)))
os_linux.go#L188: func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
os_linux.go#L191: write(2, unsafe.Pointer(&failallocatestack[0]), int32(len(failallocatestack)))
os_linux.go#L194: ret := clone(cloneFlags, unsafe.Pointer(uintptr(stack)+stacksize), nil, nil, fn)
os_linux.go#L196: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_linux.go#L216: func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
os_linux.go#L230: auxv := (*[1 << 28]uintptr)(add(unsafe.Pointer(argv), uintptr(n)*goarch.PtrSize))
os_linux.go#L249: err := mincore(unsafe.Pointer(uintptr(p)+n), 1, &addrspace_vec[0])
os_linux.go#L262: n = read(fd, noescape(unsafe.Pointer(&buf[0])), int32(unsafe.Sizeof(buf)))
os_linux.go#L285: startupRandomData = (*[16]byte)(unsafe.Pointer(val))[:]
os_linux.go#L305: ptr := noescape(unsafe.Pointer(&numbuf[0]))
os_linux.go#L356: n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
os_linux.go#L504: *(*uintptr)(unsafe.Pointer(&s.ss_sp)) = sp
panic.go#L294: *(*uintptr)(unsafe.Pointer(&d._panic)) = 0
panic.go#L295: *(*uintptr)(unsafe.Pointer(&d.fd)) = 0
panic.go#L296: *(*uintptr)(unsafe.Pointer(&d.link)) = uintptr(unsafe.Pointer(gp._defer))
panic.go#L297: *(*uintptr)(unsafe.Pointer(&gp._defer)) = uintptr(unsafe.Pointer(d))
panic.go#L459: gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
panic.go#L461: addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))
panic.go#L480: d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
panic.go#L493: addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))
panic.go#L591: func addOneOpenDeferFrame(gp *g, pc uintptr, sp unsafe.Pointer) {
panic.go#L596: sp = unsafe.Pointer(prevDefer.sp)
panic.go#L600: func(frame *stkframe, unused unsafe.Pointer) bool {
panic.go#L680: func readvarintUnsafe(fd unsafe.Pointer) (uint32, unsafe.Pointer) {
panic.go#L684: b := *(*uint8)((unsafe.Pointer(fd)))
panic.go#L707: deferBits := *(*uint8)(unsafe.Pointer(d.varp - uintptr(deferBitsOffset)))
panic.go#L716: closure := *(*func())(unsafe.Pointer(d.varp - uintptr(closureOffset)))
panic.go#L719: *(*uint8)(unsafe.Pointer(d.varp - uintptr(deferBitsOffset))) = deferBits
panic.go#L746: p.argp = unsafe.Pointer(getargp())
panic.go#L748: p.sp = unsafe.Pointer(getcallersp())
panic.go#L753: p.sp = unsafe.Pointer(nil)
panic.go#L792: gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
panic.go#L798: addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))
panic.go#L834: d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
panic.go#L843: p.argp = unsafe.Pointer(getargp())
panic.go#L858: sp := unsafe.Pointer(d.sp) // must be pointer so it gets adjusted during stack copy
plugin.go#L81: symName := resolveNameOff(unsafe.Pointer(md.types), ptab.name)
plugin.go#L82: t := (*_type)(unsafe.Pointer(md.types)).typeOff(ptab.typ)
plugin.go#L84: valp := (*[2]unsafe.Pointer)(unsafe.Pointer(&val))
plugin.go#L85: (*valp)[0] = unsafe.Pointer(t)
plugin.go#L104: f := funcInfo{(*_func)(unsafe.Pointer(&md.pclntable[md.ftab[i].funcoff])), md}
print.go#L18: rp := (*slice)(unsafe.Pointer(&ret))
print.go#L239: func printpointer(p unsafe.Pointer) {
print.go#L251: sp := (*slice)(unsafe.Pointer(&s))
print.go#L289: val := *(*uintptr)(unsafe.Pointer(p + i))
proc.go#L344: func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceEv byte, traceskip int) {
proc.go#L367: gopark(parkunlock_c, unsafe.Pointer(lock), reason, traceEv, traceskip)
proc.go#L539: atomicstorep(unsafe.Pointer(&allgptr), unsafe.Pointer(&allgs[0]))
proc.go#L562: ptr := (**g)(atomic.Loadp(unsafe.Pointer(&allgptr)))
proc.go#L568: return *(**g)(add(unsafe.Pointer(ptr), i*goarch.PtrSize))
proc.go#L621: s := *(*string)(unsafe.Pointer(&stringStruct{unsafe.Pointer(p), findnull(p)}))
proc.go#L824: atomicstorep(unsafe.Pointer(&allm), unsafe.Pointer(mp))
proc.go#L836: s := (*[unsafe.Sizeof(fastrandseed)]byte)(unsafe.Pointer(&fastrandseed))[:]
proc.go#L1367: _g_.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))
proc.go#L1404: _g_.sched.g = guintptr(unsafe.Pointer(_g_))
proc.go#L1688: var cgoThreadStart unsafe.Pointer
proc.go#L1693: fn unsafe.Pointer
proc.go#L1807: write(2, unsafe.Pointer(&earlycgocallback[0]), int32(len(earlycgocallback)))
proc.go#L1901: gp.sched.g = guintptr(unsafe.Pointer(gp))
proc.go#L1991: return uintptr(unsafe.Pointer(getg().m))
proc.go#L2026: return (*m)(unsafe.Pointer(old))
proc.go#L2035: atomic.Storeuintptr(&extram, uintptr(unsafe.Pointer(mp)))
proc.go#L2133: ts.tls = (*uint64)(unsafe.Pointer(&mp.tls[0]))
proc.go#L2134: ts.fn = unsafe.Pointer(abi.FuncPCABI0(mstart))
proc.go#L2136: msanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
proc.go#L2139: asanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
proc.go#L2142: asmcgocall(_cgo_thread_start, unsafe.Pointer(&ts))
proc.go#L3308: func parkunlock_c(gp *g, lock unsafe.Pointer) bool {
proc.go#L4044: *(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0
proc.go#L4100: *(*uintptr)(unsafe.Pointer(sp)) = 0
proc.go#L4105: memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
proc.go#L4109: newg.sched.g = guintptr(unsafe.Pointer(newg))
proc.go#L4264: racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L4267: msanmalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L4270: asanunpoison(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L4544: var tagPtr *unsafe.Pointer
proc.go#L4681: mheap_.spanalloc.free(unsafe.Pointer(pp.mspancache.buf[i]))
proc.go#L4782: atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
proc.go#L4852: atomic.Store((*uint32)(unsafe.Pointer(int32p)), uint32(nprocs))
proc.go#L5656: runnext := atomic.Loaduintptr((*uintptr)(unsafe.Pointer(&_p_.runnext)))
proc.go#L5687: if !_p_.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
proc.go#L6197: p := add(unsafe.Pointer(t), (3+i)*goarch.PtrSize)
proc.go#L6218: firstFunc := add(unsafe.Pointer(t), (3+t.ndeps)*goarch.PtrSize)
proc.go#L6221: f := *(*func())(unsafe.Pointer(&p))
proc.go#L6230: f := *(*func())(unsafe.Pointer(&firstFunc))
profbuf.go#L98: tags []unsafe.Pointer
profbuf.go#L231: b.tags = make([]unsafe.Pointer, tags)
profbuf.go#L304: func (b *profBuf) write(tagPtr *unsafe.Pointer, now int64, hdr []uint64, stk []uintptr) {
profbuf.go#L352: *(*uintptr)(unsafe.Pointer(&b.tags[wt])) = uintptr(unsafe.Pointer(*tagPtr))
profbuf.go#L430: var overflowTag [1]unsafe.Pointer // always nil
profbuf.go#L432: func (b *profBuf) read(mode profBufReadMode) (data []uint64, tags []unsafe.Pointer, eof bool) {
profbuf.go#L557: raceacquire(unsafe.Pointer(&labelSync))
proflabel.go#L12: func runtime_setProfLabel(labels unsafe.Pointer) {
proflabel.go#L32: racereleasemerge(unsafe.Pointer(&labelSync))
proflabel.go#L38: 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") }
runtime1.go#L58: return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*goarch.PtrSize))
runtime1.go#L149: k unsafe.Pointer
runtime1.go#L250: *(*uint64)(unsafe.Pointer(&j)) = ^uint64(0)
runtime1.go#L258: *(*uint64)(unsafe.Pointer(&j1)) = ^uint64(1)
runtime1.go#L266: *(*uint32)(unsafe.Pointer(&i)) = ^uint32(0)
runtime1.go#L274: *(*uint32)(unsafe.Pointer(&i1)) = ^uint32(1)
runtime1.go#L484: func reflect_typelinks() ([]unsafe.Pointer, [][]int32) {
runtime1.go#L486: sections := []unsafe.Pointer{unsafe.Pointer(modules[0].types)}
runtime1.go#L489: sections = append(sections, unsafe.Pointer(md.types))
runtime1.go#L497: func reflect_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L498: return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).bytes)
runtime1.go#L503: func reflect_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L504: return unsafe.Pointer((*_type)(rtype).typeOff(typeOff(off)))
runtime1.go#L509: func reflect_resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L516: func reflectlite_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L517: return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).bytes)
runtime1.go#L522: func reflectlite_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
runtime1.go#L523: return unsafe.Pointer((*_type)(rtype).typeOff(typeOff(off)))
runtime1.go#L528: func reflect_addReflectOff(ptr unsafe.Pointer) int32 {
runtime1.go#L531: reflectOffs.m = make(map[int32]unsafe.Pointer)
runtime1.go#L532: reflectOffs.minv = make(map[unsafe.Pointer]int32)
runtime2.go#L204: data unsafe.Pointer
runtime2.go#L209: data unsafe.Pointer
runtime2.go#L213: return (*eface)(unsafe.Pointer(ep))
runtime2.go#L263: func (gp guintptr) ptr() *g { return (*g)(unsafe.Pointer(gp)) }
runtime2.go#L266: func (gp *guintptr) set(g *g) { *gp = guintptr(unsafe.Pointer(g)) }
runtime2.go#L270: return atomic.Casuintptr((*uintptr)(unsafe.Pointer(gp)), uintptr(old), uintptr(new))
runtime2.go#L278: (*guintptr)(unsafe.Pointer(gp)).set(new)
runtime2.go#L284: func (pp puintptr) ptr() *p { return (*p)(unsafe.Pointer(pp)) }
runtime2.go#L287: func (pp *puintptr) set(p *p) { *pp = puintptr(unsafe.Pointer(p)) }
runtime2.go#L301: func (mp muintptr) ptr() *m { return (*m)(unsafe.Pointer(mp)) }
runtime2.go#L304: func (mp *muintptr) set(m *m) { *mp = muintptr(unsafe.Pointer(m)) }
runtime2.go#L311: (*muintptr)(unsafe.Pointer(mp)).set(new)
runtime2.go#L330: ctxt unsafe.Pointer
runtime2.go#L355: elem unsafe.Pointer // data element (may point to stack)
runtime2.go#L435: param unsafe.Pointer
runtime2.go#L486: labels unsafe.Pointer // profiler labels
runtime2.go#L559: waitunlockf func(*g, unsafe.Pointer) bool
runtime2.go#L560: waitlock unsafe.Pointer
runtime2.go#L918: h := memhash(unsafe.Pointer(&r[n-w]), uintptr(nanotime()), uintptr(w))
runtime2.go#L952: fd unsafe.Pointer // funcdata for the function associated with the frame
runtime2.go#L970: argp unsafe.Pointer // pointer to arguments of deferred call run during panic; cannot move - known to liblink
runtime2.go#L974: sp unsafe.Pointer // where to return to in runtime if this panic is bypassed
select.go#L22: elem unsafe.Pointer // data element
select.go#L63: func selparkcommit(gp *g, _ unsafe.Pointer) bool {
select.go#L129: cas1 := (*[1 << 16]scase)(unsafe.Pointer(cas0))
select.go#L130: order1 := (*[1 << 17]uint16)(unsafe.Pointer(order0))
select.go#L143: pc1 := (*[1 << 16]uintptr)(unsafe.Pointer(pc0))
select.go#L240: qp unsafe.Pointer
select.go#L520: return uintptr(unsafe.Pointer(c))
select.go#L527: typ unsafe.Pointer // channel type (not used here)
select.go#L529: val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
sema.go#L218: return &semtable[(uintptr(unsafe.Pointer(addr))>>3)%semTabSize].root
sema.go#L236: s.elem = unsafe.Pointer(addr)
sema.go#L243: if t.elem == unsafe.Pointer(addr) {
sema.go#L282: if uintptr(unsafe.Pointer(addr)) < uintptr(t.elem) {
sema.go#L325: if s.elem == unsafe.Pointer(addr) {
sema.go#L328: if uintptr(unsafe.Pointer(addr)) < uintptr(s.elem) {
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_unix.go#L409: gp := *(**g)(unsafe.Pointer(s.base()))
signal_unix.go#L429: func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
signal_unix.go#L502: func sigprofNonGo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
signal_unix.go#L541: sp := uintptr(unsafe.Pointer(&sig))
signal_unix.go#L548: stsp := uintptr(unsafe.Pointer(st.ss_sp))
signal_unix.go#L604: func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
signal_unix.go#L618: if sig == _SIGTRAP && testSigtrap != nil && testSigtrap(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp) {
signal_unix.go#L735: b := (*[maxN]byte)(unsafe.Pointer(pc))
signal_unix.go#L1029: *(*uintptr)(unsafe.Pointer(uintptr(123))) = 2
signal_unix.go#L1041: func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)
signal_unix.go#L1049: func sigfwdgo(sig uint32, info *siginfo, ctx unsafe.Pointer) bool {
signal_unix.go#L1281: stsp := uintptr(unsafe.Pointer(st.ss_sp))
slice.go#L16: array unsafe.Pointer
slice.go#L38: func makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer {
slice.go#L55: var to unsafe.Pointer
slice.go#L88: func makeslice(et *_type, len, cap int) unsafe.Pointer {
slice.go#L106: func makeslice64(et *_type, len64, cap64 int64) unsafe.Pointer {
slice.go#L120: func unsafeslice(et *_type, ptr unsafe.Pointer, len int) {
slice.go#L134: func unsafeslice64(et *_type, ptr unsafe.Pointer, len64 int64) {
slice.go#L142: func unsafeslicecheckptr(et *_type, ptr unsafe.Pointer, len64 int64) {
slice.go#L185: return slice{unsafe.Pointer(&zerobase), old.len, cap}
slice.go#L270: var p unsafe.Pointer
slice.go#L295: func slicecopy(toPtr unsafe.Pointer, toLen int, fromPtr unsafe.Pointer, fromLen int, width uintptr) int {
stack.go#L369: var v unsafe.Pointer
stack.go#L396: v = unsafe.Pointer(x)
stack.go#L421: v = unsafe.Pointer(s.base())
stack.go#L447: v := unsafe.Pointer(stk.lo)
stack.go#L567: func adjustpointer(adjinfo *adjustinfo, vpp unsafe.Pointer) {
stack.go#L599: func adjustpointers(scanp unsafe.Pointer, bv *bitvector, adjinfo *adjustinfo, f funcInfo) {
stack.go#L635: ppu := (*unsafe.Pointer)(unsafe.Pointer(pp))
stack.go#L636: if !atomic.Casp1(ppu, unsafe.Pointer(p), unsafe.Pointer(p+delta)) {
stack.go#L648: func adjustframe(frame *stkframe, arg unsafe.Pointer) bool {
stack.go#L670: adjustpointers(unsafe.Pointer(frame.varp-size), &locals, adjinfo, f)
stack.go#L682: bp := *(*uintptr)(unsafe.Pointer(frame.varp))
stack.go#L689: adjustpointer(adjinfo, unsafe.Pointer(frame.varp))
stack.go#L697: adjustpointers(unsafe.Pointer(frame.argp), &args, adjinfo, funcInfo{})
stack.go#L723: gcdata = (*byte)(unsafe.Pointer(s.startAddr))
stack.go#L727: adjustpointer(adjinfo, unsafe.Pointer(p+i))
stack.go#L740: adjustpointer(adjinfo, unsafe.Pointer(&gp.sched.ctxt))
stack.go#L752: adjustpointer(adjinfo, unsafe.Pointer(&gp.sched.bp))
stack.go#L759: adjustpointer(adjinfo, unsafe.Pointer(&gp._defer))
stack.go#L761: adjustpointer(adjinfo, unsafe.Pointer(&d.fn))
stack.go#L762: adjustpointer(adjinfo, unsafe.Pointer(&d.sp))
stack.go#L763: adjustpointer(adjinfo, unsafe.Pointer(&d._panic))
stack.go#L764: adjustpointer(adjinfo, unsafe.Pointer(&d.link))
stack.go#L765: adjustpointer(adjinfo, unsafe.Pointer(&d.varp))
stack.go#L766: adjustpointer(adjinfo, unsafe.Pointer(&d.fd))
stack.go#L773: adjustpointer(adjinfo, unsafe.Pointer(&gp._panic))
stack.go#L780: adjustpointer(adjinfo, unsafe.Pointer(&s.elem))
stack.go#L786: *(*byte)(unsafe.Pointer(p)) = b
stack.go#L838: memmove(unsafe.Pointer(newBot), unsafe.Pointer(oldBot), sgsize)
stack.go#L911: memmove(unsafe.Pointer(new.hi-ncopy), unsafe.Pointer(old.hi-ncopy), ncopy)
stack.go#L930: gentraceback(^uintptr(0), ^uintptr(0), 0, gp, 0, nil, 0x7fffffff, adjustframe, noescape(unsafe.Pointer(&adjinfo)), 0)
stack.go#L1126: var fn unsafe.Pointer
stack.go#L1128: fn = unsafe.Pointer(fv.fn)
stack.go#L1130: fn = unsafe.Pointer(abi.FuncPCABIInternal(nilfunc))
stack.go#L1132: gostartcall(gobuf, fn, unsafe.Pointer(fv))
stack.go#L1346: *(*slice)(unsafe.Pointer(&objs)) = slice{array: noescape(p), len: int(n), cap: int(n)}
stack.go#L1368: ptr := uintptr(unsafe.Pointer(&methodValueCallFrameObjs[0]))
stack.go#L1383: gcdataoff: uint32(uintptr(unsafe.Pointer(abiRegArgsType.gcdata)) - mod.rodata),
stack.go#L1413: ptr := uintptr(unsafe.Pointer(r))
stack.go#L1425: return (*byte)(unsafe.Pointer(res))
string.go#L89: racereadrangepc(unsafe.Pointer(ptr),
string.go#L95: msanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L98: asanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L101: p := unsafe.Pointer(&staticuint64s[*ptr])
string.go#L110: var p unsafe.Pointer
string.go#L112: p = unsafe.Pointer(buf)
string.go#L118: memmove(p, unsafe.Pointer(ptr), uintptr(n))
string.go#L156: racereadrangepc(unsafe.Pointer(ptr),
string.go#L162: msanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L165: asanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L167: stringStructOf(&str).str = unsafe.Pointer(ptr)
string.go#L210: racereadrangepc(unsafe.Pointer(&a[0]),
string.go#L216: msanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
string.go#L219: asanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
string.go#L239: str unsafe.Pointer
string.go#L250: return (*stringStruct)(unsafe.Pointer(sp))
string.go#L278: *(*slice)(unsafe.Pointer(&b)) = slice{p, size, size}
string.go#L291: *(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(cap)}
string.go#L306: *(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(mem / 4)}
string.go#L321: memmove(bp, unsafe.Pointer(p), uintptr(n))
string.go#L323: *(*slice)(unsafe.Pointer(&b)) = slice{bp, n, n}
string.go#L335: memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l))
string.go#L344: memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l))
string.go#L424: p := (*[maxAlloc/2 - 1]byte)(unsafe.Pointer(s))
string.go#L439: ptr := unsafe.Pointer(s)
string.go#L446: t := *(*string)(unsafe.Pointer(&stringStruct{ptr, safeLen}))
string.go#L452: ptr = unsafe.Pointer(uintptr(ptr) + uintptr(safeLen))
string.go#L462: p := (*[maxAlloc/2/2 - 1]uint16)(unsafe.Pointer(s))
string.go#L472: ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
string.go#L473: s := *(*string)(unsafe.Pointer(&ss))
string.go#L479: str := (*[maxAlloc/2/2 - 1]uint16)(unsafe.Pointer(strw))
stubs.go#L17: func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
stubs.go#L18: return unsafe.Pointer(uintptr(p) + x)
stubs.go#L92: func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
stubs.go#L95: func reflect_memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr) {
stubs.go#L112: func memmove(to, from unsafe.Pointer, n uintptr)
stubs.go#L118: func reflect_memmove(to, from unsafe.Pointer, n uintptr) {
stubs.go#L144: t := (*[2]uint32)(unsafe.Pointer(&mp.fastrand))
stubs.go#L170: func memequal(a, b unsafe.Pointer, size uintptr) bool
stubs.go#L178: func noescape(p unsafe.Pointer) unsafe.Pointer {
stubs.go#L180: return unsafe.Pointer(x ^ 0)
stubs.go#L240: func reflectcall(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L322: func asmcgocall(fn, arg unsafe.Pointer) int32
stubs.go#L338: func call16(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L339: func call32(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L340: func call64(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L341: func call128(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L342: func call256(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L343: func call512(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L344: func call1024(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L345: func call2048(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L346: func call4096(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L347: func call8192(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L348: func call16384(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L349: func call32768(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L350: func call65536(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L351: func call131072(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L352: func call262144(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L353: func call524288(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L354: func call1048576(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L355: func call2097152(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L356: func call4194304(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L357: func call8388608(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L358: func call16777216(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L359: func call33554432(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L360: func call67108864(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L361: func call134217728(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L362: func call268435456(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L363: func call536870912(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L364: func call1073741824(typ, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
stubs.go#L388: func memequal_varlen(a, b unsafe.Pointer) bool
stubs.go#L394: return int(uint8(*(*uint8)(unsafe.Pointer(&x))))
stubs2.go#L13: func read(fd int32, p unsafe.Pointer, n int32) int32
stubs2.go#L28: func write1(fd uintptr, p unsafe.Pointer, n int32) int32
stubs2.go#L34: 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#L18: func connect(fd int32, addr unsafe.Pointer, len int32) int32
symtab.go#L271: return (*_func)(unsafe.Pointer(f))
symtab.go#L282: ptr := uintptr(unsafe.Pointer(f))
symtab.go#L288: base := uintptr(unsafe.Pointer(&datap.pclntable[0]))
symtab.go#L500: p := (*[]*moduledata)(atomic.Loadp(unsafe.Pointer(&modulesSlice)))
symtab.go#L534: md.gcdatamask = progToPointerMask((*byte)(unsafe.Pointer(md.gcdata)), scanDataSize)
symtab.go#L536: md.gcbssmask = progToPointerMask((*byte)(unsafe.Pointer(md.gcbss)), scanBSSSize)
symtab.go#L558: atomicstorep(unsafe.Pointer(&modulesSlice), unsafe.Pointer(modules))
symtab.go#L614: f1 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i].funcoff])), datap}
symtab.go#L615: f2 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i+1].funcoff])), datap}
symtab.go#L622: println("\t", hex(datap.ftab[j].entryoff), funcname(funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[j].funcoff])), datap}))
symtab.go#L736: return (*Func)(unsafe.Pointer(fi))
symtab.go#L749: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L759: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L772: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L806: return (*Func)(unsafe.Pointer(f._func))
symtab.go#L841: ffb := (*findfuncbucket)(add(unsafe.Pointer(datap.findfunctab), b*unsafe.Sizeof(findfuncbucket{})))
symtab.go#L850: return funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[funcoff])), datap}
symtab.go#L1066: return *(*uint32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4))
symtab.go#L1096: func funcdata(f funcInfo, i uint8) unsafe.Pointer {
symtab.go#L1101: p := uintptr(unsafe.Pointer(&f.nfuncdata)) + unsafe.Sizeof(f.nfuncdata) + uintptr(f.npcdata)*4 + uintptr(i)*4
symtab.go#L1102: off := *(*uint32)(unsafe.Pointer(p))
symtab.go#L1111: return unsafe.Pointer(raw & mask)
sys_x86.go#L16: func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
sys_x86.go#L19: *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
time.go#L194: gopark(resetForSleep, unsafe.Pointer(t), waitReasonSleep, traceEvGoSleep, 1)
time.go#L201: func resetForSleep(gp *g, ut unsafe.Pointer) bool {
time.go#L211: racerelease(unsafe.Pointer(t))
time.go#L228: racerelease(unsafe.Pointer(t))
time.go#L829: raceacquirectx(ppcur.timerRaceCtx, unsafe.Pointer(t))
time_nofake.go#L22: var overrideWrite func(fd uintptr, p unsafe.Pointer, n int32) int32
time_nofake.go#L27: func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
trace.go#L173: func (tp traceBufPtr) ptr() *traceBuf { return (*traceBuf)(unsafe.Pointer(tp)) }
trace.go#L174: func (tp *traceBufPtr) set(b *traceBuf) { *tp = traceBufPtr(unsafe.Pointer(b)) }
trace.go#L176: return traceBufPtr(unsafe.Pointer(b))
trace.go#L344: raceacquire(unsafe.Pointer(&trace.shutdownSema))
trace.go#L366: sysFree(unsafe.Pointer(buf), unsafe.Sizeof(*buf.ptr()), &memstats.other_sys)
trace.go#L450: racerelease(unsafe.Pointer(&trace.shutdownSema))
trace.go#L690: raceacquire(unsafe.Pointer(&trace.stringsLock))
trace.go#L695: racerelease(unsafe.Pointer(&trace.stringsLock))
trace.go#L707: racerelease(unsafe.Pointer(&trace.stringsLock))
trace.go#L786: func (tp traceStackPtr) ptr() *traceStack { return (*traceStack)(unsafe.Pointer(tp)) }
trace.go#L790: return (*[traceStackSize]uintptr)(unsafe.Pointer(&ts.stk))[:ts.n]
trace.go#L799: hash := memhash(unsafe.Pointer(&pcs[0]), 0, uintptr(len(pcs))*unsafe.Sizeof(pcs[0]))
trace.go#L822: atomicstorep(unsafe.Pointer(&tab.tab[part]), unsafe.Pointer(stk))
trace.go#L952: func (p traceAllocBlockPtr) ptr() *traceAllocBlock { return (*traceAllocBlock)(unsafe.Pointer(p)) }
trace.go#L953: func (p *traceAllocBlockPtr) set(x *traceAllocBlock) { *p = traceAllocBlockPtr(unsafe.Pointer(x)) }
trace.go#L956: func (a *traceAlloc) alloc(n uintptr) unsafe.Pointer {
trace.go#L972: return unsafe.Pointer(p)
trace.go#L980: sysFree(unsafe.Pointer(block), unsafe.Sizeof(traceAllocBlock{}), &memstats.other_sys)
traceback.go#L33: func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max int, callback func(*stkframe, unsafe.Pointer) bool, v unsafe.Pointer, flags uint) int {
traceback.go#L91: frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
traceback.go#L94: frame.pc = uintptr(*(*uintptr)(unsafe.Pointer(frame.sp)))
traceback.go#L227: frame.lr = *(*uintptr)(unsafe.Pointer(lrPtr))
traceback.go#L232: frame.lr = uintptr(*(*uintptr)(unsafe.Pointer(lrPtr)))
traceback.go#L330: if !callback((*stkframe)(noescape(unsafe.Pointer(&frame))), v) {
traceback.go#L369: (*[1 << 20]uintptr)(unsafe.Pointer(pcbuf))[n] = pc
traceback.go#L384: (*[1 << 20]uintptr)(unsafe.Pointer(pcbuf))[n] = pc
traceback.go#L443: argp := unsafe.Pointer(frame.argp)
traceback.go#L491: x := *(*uintptr)(unsafe.Pointer(frame.sp))
traceback.go#L557: func printArgs(f funcInfo, argp unsafe.Pointer, pc uintptr) {
traceback.go#L696: mv = (*reflectMethodValue)(unsafe.Pointer(ctxt))
traceback.go#L704: mv = *(**reflectMethodValue)(unsafe.Pointer(arg0))
traceback.go#L708: retValid = *(*bool)(unsafe.Pointer(arg0 + 4*goarch.PtrSize))
traceback.go#L738: (*[1 << 20]uintptr)(unsafe.Pointer(pcbuf))[n] = pc
traceback.go#L1294: func SetCgoTraceback(version int, traceback, context, symbolizer unsafe.Pointer) {
traceback.go#L1316: var cgoTraceback unsafe.Pointer
traceback.go#L1317: var cgoContext unsafe.Pointer
traceback.go#L1318: var cgoSymbolizer unsafe.Pointer
traceback.go#L1405: msanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
traceback.go#L1408: asanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
traceback.go#L1410: call(cgoSymbolizer, noescape(unsafe.Pointer(arg)))
traceback.go#L1426: buf: (*uintptr)(noescape(unsafe.Pointer(&buf[0]))),
traceback.go#L1430: msanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
traceback.go#L1433: asanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
traceback.go#L1435: call(cgoTraceback, noescape(unsafe.Pointer(&arg)))
type.go#L44: equal func(unsafe.Pointer, unsafe.Pointer) bool
type.go#L71: return &(*u)(unsafe.Pointer(t)).u
type.go#L77: return &(*u)(unsafe.Pointer(t)).u
type.go#L83: return &(*u)(unsafe.Pointer(t)).u
type.go#L89: return &(*u)(unsafe.Pointer(t)).u
type.go#L95: return &(*u)(unsafe.Pointer(t)).u
type.go#L101: return &(*u)(unsafe.Pointer(t)).u
type.go#L107: return &(*u)(unsafe.Pointer(t)).u
type.go#L113: return &(*u)(unsafe.Pointer(t)).u
type.go#L119: return &(*u)(unsafe.Pointer(t)).u
type.go#L145: st := (*structtype)(unsafe.Pointer(t))
type.go#L148: it := (*interfacetype)(unsafe.Pointer(t))
type.go#L170: m map[int32]unsafe.Pointer
type.go#L171: minv map[unsafe.Pointer]int32
type.go#L177: raceacquire(unsafe.Pointer(&reflectOffs.lock))
type.go#L183: racerelease(unsafe.Pointer(&reflectOffs.lock))
type.go#L188: func resolveNameOff(ptrInModule unsafe.Pointer, off nameOff) name {
type.go#L200: return name{(*byte)(unsafe.Pointer(res))}
type.go#L219: return resolveNameOff(unsafe.Pointer(t), off)
type.go#L222: func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {
type.go#L257: return (*_type)(unsafe.Pointer(res))
type.go#L261: return resolveTypeOff(unsafe.Pointer(t), off)
type.go#L264: func (t *_type) textOff(off textOff) unsafe.Pointer {
type.go#L268: return unsafe.Pointer(abi.FuncPCABIInternal(unreachableMethod))
type.go#L270: base := uintptr(unsafe.Pointer(t))
type.go#L292: return unsafe.Pointer(res)
type.go#L301: return (*[1 << 20]*_type)(add(unsafe.Pointer(t), uadd))[:t.inCount]
type.go#L311: return (*[1 << 20]*_type)(add(unsafe.Pointer(t), uadd))[t.inCount : t.inCount+outCount]
type.go#L354: hasher func(unsafe.Pointer, uintptr) uintptr
type.go#L431: return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off)))
type.go#L457: hdr := (*stringStruct)(unsafe.Pointer(&s))
type.go#L458: hdr.str = unsafe.Pointer(n.data(1 + i))
type.go#L469: hdr := (*stringStruct)(unsafe.Pointer(&s))
type.go#L470: hdr.str = unsafe.Pointer(n.data(1 + i + l + i2))
type.go#L486: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off)))[:])
type.go#L487: pkgPathName := resolveNameOff(unsafe.Pointer(n.bytes), nameOff)
type.go#L515: t = (*_type)(unsafe.Pointer(prev.types + uintptr(tl)))
type.go#L537: t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
type.go#L610: at := (*arraytype)(unsafe.Pointer(t))
type.go#L611: av := (*arraytype)(unsafe.Pointer(v))
type.go#L614: ct := (*chantype)(unsafe.Pointer(t))
type.go#L615: cv := (*chantype)(unsafe.Pointer(v))
type.go#L618: ft := (*functype)(unsafe.Pointer(t))
type.go#L619: fv := (*functype)(unsafe.Pointer(v))
type.go#L637: it := (*interfacetype)(unsafe.Pointer(t))
type.go#L638: iv := (*interfacetype)(unsafe.Pointer(v))
type.go#L650: tname := resolveNameOff(unsafe.Pointer(tm), tm.name)
type.go#L651: vname := resolveNameOff(unsafe.Pointer(vm), vm.name)
type.go#L658: tityp := resolveTypeOff(unsafe.Pointer(tm), tm.ityp)
type.go#L659: vityp := resolveTypeOff(unsafe.Pointer(vm), vm.ityp)
type.go#L666: mt := (*maptype)(unsafe.Pointer(t))
type.go#L667: mv := (*maptype)(unsafe.Pointer(v))
type.go#L670: pt := (*ptrtype)(unsafe.Pointer(t))
type.go#L671: pv := (*ptrtype)(unsafe.Pointer(v))
type.go#L674: st := (*slicetype)(unsafe.Pointer(t))
type.go#L675: sv := (*slicetype)(unsafe.Pointer(v))
type.go#L678: st := (*structtype)(unsafe.Pointer(t))
type.go#L679: sv := (*structtype)(unsafe.Pointer(v))
vdso_linux.go#L104: info.loadAddr = uintptr(unsafe.Pointer(hdr))
vdso_linux.go#L106: pt := unsafe.Pointer(info.loadAddr + uintptr(hdr.e_phoff))
vdso_linux.go#L122: dyn = (*[vdsoDynSize]elfDyn)(unsafe.Pointer(info.loadAddr + uintptr(pt.p_offset)))
vdso_linux.go#L142: info.symstrings = (*[vdsoSymStringsSize]byte)(unsafe.Pointer(p))
vdso_linux.go#L144: info.symtab = (*[vdsoSymTabSize]elfSym)(unsafe.Pointer(p))
vdso_linux.go#L146: hash = (*[vdsoHashSize]uint32)(unsafe.Pointer(p))
vdso_linux.go#L148: gnuhash = (*[vdsoHashSize]uint32)(unsafe.Pointer(p))
vdso_linux.go#L150: info.versym = (*[vdsoVerSymSize]uint16)(unsafe.Pointer(p))
vdso_linux.go#L152: info.verdef = (*elfVerdef)(unsafe.Pointer(p))
vdso_linux.go#L192: aux := (*elfVerdaux)(add(unsafe.Pointer(def), uintptr(def.vd_aux)))
vdso_linux.go#L201: def = (*elfVerdef)(add(unsafe.Pointer(def), uintptr(def.vd_next)))
vdso_linux.go#L276: info1 := (*vdsoInfo)(noescape(unsafe.Pointer(&info)))
vdso_linux.go#L277: vdsoInitFromSysinfoEhdr(info1, (*elfEhdr)(unsafe.Pointer(val)))
write_err.go#L12: write(2, unsafe.Pointer(&b[0]), int32(len(b)))
runtime/cgo
callbacks.go#L103: 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)
6c043be568fc81bc9d80c45e9f371fbcaf924357b5c9b4b4fa0af948dcf7d65d-d#L10: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
6c043be568fc81bc9d80c45e9f371fbcaf924357b5c9b4b4fa0af948dcf7d65d-d#L22: func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
runtime/internal/atomic
atomic_amd64.go#L22: func Loadp(ptr unsafe.Pointer) unsafe.Pointer {
atomic_amd64.go#L23: return *(*unsafe.Pointer)(ptr)
atomic_amd64.go#L116: func StorepNoWB(ptr unsafe.Pointer, val unsafe.Pointer)
stubs.go#L15: func Casp1(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
types.go#L335: return *(*float64)(unsafe.Pointer(&r))
types.go#L340: f.u.Store(*(*uint64)(unsafe.Pointer(&value)))
types.go#L354: value unsafe.Pointer
types.go#L358: func (u *UnsafePointer) Load() unsafe.Pointer {
types.go#L359: return Loadp(unsafe.Pointer(&u.value))
types.go#L368: func (u *UnsafePointer) StoreNoWB(value unsafe.Pointer) {
types.go#L369: StorepNoWB(unsafe.Pointer(&u.value), value)
types.go#L382: func (u *UnsafePointer) CompareAndSwapNoWB(old, new unsafe.Pointer) bool {
runtime/pprof
map.go#L24: tag unsafe.Pointer
map.go#L28: func (m *profMap) lookup(stk []uint64, tag unsafe.Pointer) *profMapEntry {
pprof.go#L667: return writeRuntimeProfile(w, debug, "threadcreate", func(p []runtime.StackRecord, _ []unsafe.Pointer) (n int, ok bool) {
pprof.go#L678: func runtime_goroutineProfileWithLabels(p []runtime.StackRecord, labels []unsafe.Pointer) (n int, ok bool)
pprof.go#L709: func writeRuntimeProfile(w io.Writer, debug int, name string, fetch func([]runtime.StackRecord, []unsafe.Pointer) (int, bool)) error {
pprof.go#L717: var labels []unsafe.Pointer
pprof.go#L724: labels = make([]unsafe.Pointer, n+10)
pprof.go#L738: labels []unsafe.Pointer
pprof.go#L794: func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool)
proto.go#L272: func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error {
runtime.go#L16: func runtime_setProfLabel(labels unsafe.Pointer)
runtime.go#L19: func runtime_getProfLabel() unsafe.Pointer
runtime.go#L26: runtime_setProfLabel(unsafe.Pointer(ctxLabels))
strings
builder.go#L27: func noescape(p unsafe.Pointer) unsafe.Pointer {
builder.go#L29: return unsafe.Pointer(x ^ 0)
builder.go#L39: b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
builder.go#L47: return *(*string)(unsafe.Pointer(&b.buf))
clone.go#L27: return *(*string)(unsafe.Pointer(&b))
sync
cond.go#L82: if uintptr(*c) != uintptr(unsafe.Pointer(c)) &&
cond.go#L83: !atomic.CompareAndSwapUintptr((*uintptr)(c), 0, uintptr(unsafe.Pointer(c))) &&
cond.go#L84: uintptr(*c) != uintptr(unsafe.Pointer(c)) {
map.go#L70: var expunged = unsafe.Pointer(new(any))
map.go#L93: p unsafe.Pointer // *interface{}
map.go#L97: return &entry{p: unsafe.Pointer(&i)}
map.go#L176: if atomic.CompareAndSwapPointer(&e.p, p, unsafe.Pointer(i)) {
map.go#L194: atomic.StorePointer(&e.p, unsafe.Pointer(i))
map.go#L254: if atomic.CompareAndSwapPointer(&e.p, nil, unsafe.Pointer(&ic)) {
mutex.go#L76: race.Acquire(unsafe.Pointer(m))
mutex.go#L103: race.Acquire(unsafe.Pointer(m))
mutex.go#L193: race.Acquire(unsafe.Pointer(m))
mutex.go#L206: race.Release(unsafe.Pointer(m))
pool.go#L47: local unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
pool.go#L50: victim unsafe.Pointer // local from previous cycle
pool.go#L83: func poolRaceAddr(x any) unsafe.Pointer {
pool.go#L84: ptr := uintptr((*[2]unsafe.Pointer)(unsafe.Pointer(&x))[1])
pool.go#L86: return unsafe.Pointer(&poolRaceHash[h%uint32(len(poolRaceHash))])
pool.go#L228: atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
pool.go#L276: func indexLocal(l unsafe.Pointer, i int) *poolLocal {
pool.go#L277: 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))
poolqueue.go#L221: atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(pp)), unsafe.Pointer(v))
poolqueue.go#L225: return (*poolChainElt)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(pp))))
poolqueue.go#L300: if atomic.CompareAndSwapPointer((*unsafe.Pointer)(unsafe.Pointer(&c.tail)), unsafe.Pointer(d), unsafe.Pointer(d2)) {
runtime2.go#L17: head unsafe.Pointer
runtime2.go#L18: tail unsafe.Pointer
rwmutex.go#L67: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L92: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L106: race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))
rwmutex.go#L148: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L149: race.Acquire(unsafe.Pointer(&rw.writerSem))
rwmutex.go#L178: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L179: race.Acquire(unsafe.Pointer(&rw.writerSem))
rwmutex.go#L193: race.Release(unsafe.Pointer(&rw.readerSem))
waitgroup.go#L35: if unsafe.Alignof(wg.state1) == 8 || uintptr(unsafe.Pointer(&wg.state1))%8 == 0 {
waitgroup.go#L41: state := (*[3]uint32)(unsafe.Pointer(&wg.state1))
waitgroup.go#L42: return (*uint64)(unsafe.Pointer(&state[1])), &state[0]
waitgroup.go#L65: race.ReleaseMerge(unsafe.Pointer(wg))
waitgroup.go#L77: race.Read(unsafe.Pointer(semap))
waitgroup.go#L123: race.Acquire(unsafe.Pointer(wg))
waitgroup.go#L134: race.Write(unsafe.Pointer(semap))
waitgroup.go#L142: race.Acquire(unsafe.Pointer(wg))
sync/atomic
doc.go#L71: func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)
doc.go#L89: func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer) (swapped bool)
doc.go#L126: func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)
doc.go#L144: func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)
value.go#L22: typ unsafe.Pointer
value.go#L23: data unsafe.Pointer
value.go#L29: vp := (*ifaceWords)(unsafe.Pointer(v))
value.go#L31: if typ == nil || typ == unsafe.Pointer(&firstStoreInProgress) {
value.go#L36: vlp := (*ifaceWords)(unsafe.Pointer(&val))
value.go#L51: vp := (*ifaceWords)(unsafe.Pointer(v))
value.go#L52: vlp := (*ifaceWords)(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 := (*ifaceWords)(unsafe.Pointer(v))
value.go#L95: np := (*ifaceWords)(unsafe.Pointer(&new))
value.go#L104: if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
value.go#L114: if typ == unsafe.Pointer(&firstStoreInProgress) {
value.go#L124: op := (*ifaceWords)(unsafe.Pointer(&old))
value.go#L139: vp := (*ifaceWords)(unsafe.Pointer(v))
value.go#L140: np := (*ifaceWords)(unsafe.Pointer(&new))
value.go#L141: op := (*ifaceWords)(unsafe.Pointer(&old))
value.go#L156: if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(&firstStoreInProgress)) {
value.go#L166: if typ == unsafe.Pointer(&firstStoreInProgress) {
value.go#L183: (*ifaceWords)(unsafe.Pointer(&i)).typ = typ
value.go#L184: (*ifaceWords)(unsafe.Pointer(&i)).data = data
syscall
asan0.go#L15: func asanRead(addr unsafe.Pointer, len int) {
asan0.go#L18: func asanWrite(addr unsafe.Pointer, len int) {
exec_linux.go#L105: RawSyscall(SYS_WRITE, uintptr(p[1]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
exec_linux.go#L248: r1, _, err1 = RawSyscall(SYS_READ, uintptr(p[0]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
exec_linux.go#L288: _, _, err1 = RawSyscall(SYS_IOCTL, uintptr(sys.Ctty), uintptr(TIOCSPGRP), uintptr(unsafe.Pointer(&pgrp)))
exec_linux.go#L307: if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&psetgroups[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
exec_linux.go#L310: r1, _, err1 = RawSyscall(SYS_WRITE, uintptr(fd1), uintptr(unsafe.Pointer(&setgroups[0])), uintptr(len(setgroups)))
exec_linux.go#L318: if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&pgid[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
exec_linux.go#L321: r1, _, err1 = RawSyscall(SYS_WRITE, uintptr(fd1), uintptr(unsafe.Pointer(&gidmap[0])), uintptr(len(gidmap)))
exec_linux.go#L332: if fd1, _, err1 = RawSyscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(&puid[0])), uintptr(O_WRONLY), 0, 0, 0); err1 != 0 {
exec_linux.go#L335: r1, _, err1 = RawSyscall(SYS_WRITE, uintptr(fd1), uintptr(unsafe.Pointer(&uidmap[0])), uintptr(len(uidmap)))
exec_linux.go#L352: _, _, err1 = RawSyscall6(SYS_MOUNT, uintptr(unsafe.Pointer(&none[0])), uintptr(unsafe.Pointer(&slash[0])), 0, MS_REC|MS_PRIVATE, 0, 0)
exec_linux.go#L361: _, _, err1 = RawSyscall(SYS_CHROOT, uintptr(unsafe.Pointer(chroot)), 0, 0)
exec_linux.go#L372: groups = uintptr(unsafe.Pointer(&cred.Groups[0]))
exec_linux.go#L395: if _, _, err1 := RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(&caps.hdr)), uintptr(unsafe.Pointer(&caps.data[0])), 0); err1 != 0 {
exec_linux.go#L406: if _, _, err1 := RawSyscall(SYS_CAPSET, uintptr(unsafe.Pointer(&caps.hdr)), uintptr(unsafe.Pointer(&caps.data[0])), 0); err1 != 0 {
exec_linux.go#L420: _, _, err1 = RawSyscall(SYS_CHDIR, uintptr(unsafe.Pointer(dir)), 0, 0)
exec_linux.go#L529: uintptr(unsafe.Pointer(argv0)),
exec_linux.go#L530: uintptr(unsafe.Pointer(&argv[0])),
exec_linux.go#L531: uintptr(unsafe.Pointer(&envv[0])))
exec_linux.go#L535: RawSyscall(SYS_WRITE, uintptr(pipe), uintptr(unsafe.Pointer(&err1)), unsafe.Sizeof(err1))
exec_unix.go#L221: n, err = readlen(p[0], (*byte)(unsafe.Pointer(&err1)), int(unsafe.Sizeof(err1)))
exec_unix.go#L289: uintptr(unsafe.Pointer(argv0p)),
exec_unix.go#L290: uintptr(unsafe.Pointer(&argvp[0])),
exec_unix.go#L291: uintptr(unsafe.Pointer(&envvp[0])))
exec_unix.go#L300: uintptr(unsafe.Pointer(argv0p)),
exec_unix.go#L301: uintptr(unsafe.Pointer(&argvp[0])),
exec_unix.go#L302: uintptr(unsafe.Pointer(&envvp[0])))
flock.go#L17: _, _, 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))
msan0.go#L15: func msanRead(addr unsafe.Pointer, len int) {
msan0.go#L18: func msanWrite(addr unsafe.Pointer, len int) {
netlink_linux.go#L31: *(*uint32)(unsafe.Pointer(&b[0:4][0])) = rr.Header.Len
netlink_linux.go#L32: *(*uint16)(unsafe.Pointer(&b[4:6][0])) = rr.Header.Type
netlink_linux.go#L33: *(*uint16)(unsafe.Pointer(&b[6:8][0])) = rr.Header.Flags
netlink_linux.go#L34: *(*uint32)(unsafe.Pointer(&b[8:12][0])) = rr.Header.Seq
netlink_linux.go#L35: *(*uint32)(unsafe.Pointer(&b[12:16][0])) = rr.Header.Pid
netlink_linux.go#L130: h := (*NlMsghdr)(unsafe.Pointer(&b[0]))
netlink_linux.go#L173: 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#L217: return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_linux.go#L226: return utimensat(_AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
syscall_linux.go#L233: return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_linux.go#L285: var cgo_libc_setgroups unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L307: if _, _, e1 := AllThreadsSyscall(_SYS_setgroups, n, uintptr(unsafe.Pointer(&a[0])), 0); e1 != 0 {
syscall_linux.go#L312: if ret := cgocaller(cgo_libc_setgroups, n, uintptr(unsafe.Pointer(&a[0]))); ret != 0 {
syscall_linux.go#L390: func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L395: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_linux.go#L399: return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
syscall_linux.go#L402: func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L407: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_linux.go#L412: return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
syscall_linux.go#L415: func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L439: return unsafe.Pointer(&sa.raw), sl, nil
syscall_linux.go#L452: func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L463: return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
syscall_linux.go#L474: func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_linux.go#L479: return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
syscall_linux.go#L485: pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
syscall_linux.go#L494: pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
syscall_linux.go#L505: pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
syscall_linux.go#L525: bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
syscall_linux.go#L530: pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
syscall_linux.go#L532: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_linux.go#L538: pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
syscall_linux.go#L540: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_linux.go#L593: err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
syscall_linux.go#L600: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L607: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L614: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L621: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L628: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L635: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_linux.go#L640: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
syscall_linux.go#L645: msg.Name = (*byte)(unsafe.Pointer(rsa))
syscall_linux.go#L679: func sendmsgN(fd int, p, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
syscall_linux.go#L739: err = ptrace(req, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
syscall_linux.go#L751: err = ptrace(req, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
syscall_linux.go#L779: err = ptrace(peekReq, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
syscall_linux.go#L784: word := *((*uintptr)(unsafe.Pointer(&buf[0])))
syscall_linux.go#L794: word := *((*uintptr)(unsafe.Pointer(&data[0])))
syscall_linux.go#L806: err = ptrace(peekReq, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
syscall_linux.go#L811: word := *((*uintptr)(unsafe.Pointer(&buf[0])))
syscall_linux.go#L831: return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
syscall_linux.go#L835: return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
syscall_linux.go#L844: err = ptrace(PTRACE_GETEVENTMSG, pid, 0, uintptr(unsafe.Pointer(&data)))
syscall_linux.go#L1004: func cgocaller(unsafe.Pointer, ...uintptr) uintptr
syscall_linux.go#L1006: var cgo_libc_setegid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1021: var cgo_libc_seteuid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1034: var cgo_libc_setgid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1047: var cgo_libc_setregid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1060: var cgo_libc_setresgid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1073: var cgo_libc_setresuid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1086: var cgo_libc_setreuid unsafe.Pointer // non-nil if cgo linked.
syscall_linux.go#L1099: var cgo_libc_setuid unsafe.Pointer // non-nil if cgo linked.
syscall_unix.go#L67: hdr := (*unsafeheader.Slice)(unsafe.Pointer(&b))
syscall_unix.go#L68: hdr.Data = unsafe.Pointer(addr)
syscall_unix.go#L95: if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
syscall_unix.go#L191: race.WriteRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L194: race.Acquire(unsafe.Pointer(&ioSync))
syscall_unix.go#L198: msanWrite(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L201: asanWrite(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L208: race.ReleaseMerge(unsafe.Pointer(&ioSync))
syscall_unix.go#L219: race.ReadRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L222: msanRead(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L225: asanRead(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L235: sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
syscall_unix.go#L284: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L306: pp := (*RawSockaddrInet4)(unsafe.Pointer(&rsa))
syscall_unix.go#L307: port := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_unix.go#L319: pp := (*RawSockaddrInet6)(unsafe.Pointer(&rsa))
syscall_unix.go#L320: port := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_unix.go#L333: pp := (*RawSockaddrInet4)(unsafe.Pointer(&rsa))
syscall_unix.go#L334: port := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_unix.go#L346: pp := (*RawSockaddrInet6)(unsafe.Pointer(&rsa))
syscall_unix.go#L347: port := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_unix.go#L370: var ptr unsafe.Pointer
syscall_unix.go#L422: return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
syscall_unix.go#L427: return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
syscall_unix.go#L431: return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
syscall_unix.go#L435: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
syscall_unix.go#L439: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
syscall_unix.go#L443: return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
syscall_unix.go#L447: return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
syscall_unix.go#L451: var p unsafe.Pointer
syscall_unix.go#L453: p = unsafe.Pointer(&[]byte(s)[0])
syscall_unix.go#L459: return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
syscall_unix.go#L482: 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 := Syscall(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_linux_amd64.go#L53: _, _, e1 := Syscall6(SYS_LINKAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
zsyscall_linux_amd64.go#L68: r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
zsyscall_linux_amd64.go#L79: _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
zsyscall_linux_amd64.go#L94: var _p1 unsafe.Pointer
zsyscall_linux_amd64.go#L96: _p1 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L98: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L100: r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
zsyscall_linux_amd64.go#L121: _, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
zsyscall_linux_amd64.go#L136: _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
zsyscall_linux_amd64.go#L151: _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0)
zsyscall_linux_amd64.go#L161: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L163: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L165: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L178: r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
zsyscall_linux_amd64.go#L204: _, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux_amd64.go#L229: _, _, 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#L244: _, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux_amd64.go#L254: r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0)
zsyscall_linux_amd64.go#L270: _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux_amd64.go#L285: _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_linux_amd64.go#L337: _, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
zsyscall_linux_amd64.go#L382: _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
zsyscall_linux_amd64.go#L433: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L435: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L437: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L488: _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
zsyscall_linux_amd64.go#L516: var _p2 unsafe.Pointer
zsyscall_linux_amd64.go#L518: _p2 = unsafe.Pointer(&dest[0])
zsyscall_linux_amd64.go#L520: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L522: r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
zsyscall_linux_amd64.go#L538: r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
zsyscall_linux_amd64.go#L581: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L583: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L585: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L603: var _p1 unsafe.Pointer
zsyscall_linux_amd64.go#L605: _p1 = unsafe.Pointer(&dest[0])
zsyscall_linux_amd64.go#L607: _p1 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L609: r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
zsyscall_linux_amd64.go#L625: _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_linux_amd64.go#L640: _, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
zsyscall_linux_amd64.go#L650: _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
zsyscall_linux_amd64.go#L670: _, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_linux_amd64.go#L680: _, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old)), 0, 0)
zsyscall_linux_amd64.go#L690: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L692: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L694: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L717: _, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_linux_amd64.go#L727: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L729: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L731: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L743: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L745: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L747: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L780: _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
zsyscall_linux_amd64.go#L810: var _p2 unsafe.Pointer
zsyscall_linux_amd64.go#L812: _p2 = unsafe.Pointer(&data[0])
zsyscall_linux_amd64.go#L814: _p2 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L816: _, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
zsyscall_linux_amd64.go#L833: _, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0)
zsyscall_linux_amd64.go#L864: r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
zsyscall_linux_amd64.go#L883: _, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0)
zsyscall_linux_amd64.go#L898: _, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_linux_amd64.go#L918: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L920: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L922: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L945: r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
zsyscall_linux_amd64.go#L956: r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
zsyscall_linux_amd64.go#L977: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L979: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux_amd64.go#L981: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L993: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L995: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux_amd64.go#L997: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1009: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1011: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux_amd64.go#L1013: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1025: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1027: _p0 = unsafe.Pointer(&b[0])
zsyscall_linux_amd64.go#L1029: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1092: _, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_linux_amd64.go#L1102: _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L1146: _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
zsyscall_linux_amd64.go#L1215: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1217: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L1219: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1232: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1234: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L1236: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1259: _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
zsyscall_linux_amd64.go#L1280: 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#L1291: r0, _, e1 := Syscall6(SYS_SENDFILE, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
zsyscall_linux_amd64.go#L1322: _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
zsyscall_linux_amd64.go#L1342: 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#L1358: _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L1383: _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
zsyscall_linux_amd64.go#L1393: _, _, e1 := Syscall(SYS_USTAT, uintptr(dev), uintptr(unsafe.Pointer(ubuf)), 0)
zsyscall_linux_amd64.go#L1403: r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_linux_amd64.go#L1414: r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)
zsyscall_linux_amd64.go#L1424: func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L1434: func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L1450: _, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
zsyscall_linux_amd64.go#L1460: r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
zsyscall_linux_amd64.go#L1470: func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
zsyscall_linux_amd64.go#L1471: _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
zsyscall_linux_amd64.go#L1480: func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
zsyscall_linux_amd64.go#L1502: _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
zsyscall_linux_amd64.go#L1512: _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_linux_amd64.go#L1522: _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_linux_amd64.go#L1532: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1534: _p0 = unsafe.Pointer(&p[0])
zsyscall_linux_amd64.go#L1536: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1538: 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#L1548: func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_linux_amd64.go#L1549: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1551: _p0 = unsafe.Pointer(&buf[0])
zsyscall_linux_amd64.go#L1553: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1565: r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_linux_amd64.go#L1576: r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_linux_amd64.go#L1598: var _p0 unsafe.Pointer
zsyscall_linux_amd64.go#L1600: _p0 = unsafe.Pointer(&events[0])
zsyscall_linux_amd64.go#L1602: _p0 = unsafe.Pointer(&_zero)
zsyscall_linux_amd64.go#L1620: _, _, e1 := Syscall(SYS_FUTIMESAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)))
zsyscall_linux_amd64.go#L1635: _, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
zsyscall_linux_amd64.go#L1650: _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0)
vendor/golang.org/x/crypto/internal/subtle
aliasing.go#L18: uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
aliasing.go#L19: uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))