type unsafe.Pointer
2491 uses
unsafe (current package)
unsafe.go#L180: 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]))
crypto/x509/internal/macos
corefoundation.go#L31: src := (*[1 << 20]byte)(unsafe.Pointer(ptr))[:length:length]
corefoundation.go#L47: p := unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&s)).Data)
corefoundation.go#L60: uintptr(unsafe.Pointer(&value)), 0, 0, 0)
corefoundation.go#L76: uintptr(unsafe.Pointer(&value)), 0, 0, 0)
corefoundation.go#L144: return **(**uintptr)(unsafe.Pointer(&f))
security.go#L71: uintptr(unsafe.Pointer(&certArray)), 0, 0, 0, 0)
security.go#L88: 0 /* flags */, 0 /* keyParams */, uintptr(unsafe.Pointer(&data)), 0)
security.go#L103: uintptr(unsafe.Pointer(&trustSettings)), 0, 0, 0)
github.com/cespare/xxhash/v2
xxhash_unsafe.go#L30: bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
xxhash_unsafe.go#L31: bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
xxhash_unsafe.go#L41: bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
xxhash_unsafe.go#L42: bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
github.com/evanw/esbuild/internal/js_parser
js_parser.go#L1557: c := (*reflect.StringHeader)(unsafe.Pointer(&p.source.Contents))
js_parser.go#L1558: n := (*reflect.StringHeader)(unsafe.Pointer(&name))
github.com/go-redis/redis/v8/internal
unsafe.go#L9: return *(*string)(unsafe.Pointer(&b))
unsafe.go#L14: return *(*[]byte)(unsafe.Pointer(
github.com/go-redis/redis/v8/internal/util
unsafe.go#L11: return *(*string)(unsafe.Pointer(&b))
unsafe.go#L16: return *(*[]byte)(unsafe.Pointer(
github.com/google/go-cmp/cmp
export_unsafe.go#L23: 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#L16: p unsafe.Pointer
pointer_unsafe.go#L25: return Pointer{unsafe.Pointer(v.Pointer()), v.Type()}
github.com/imdario/mergo
merge.go#L103: rf = reflect.NewAt(rf.Type(), unsafe.Pointer(rf.UnsafeAddr())).Elem() //nolint:gosec
merge.go#L109: dstRF = reflect.NewAt(dstRF.Type(), unsafe.Pointer(dstRF.UnsafeAddr())).Elem() //nolint:gosec
github.com/yuin/goldmark/util
util_unsafe.go#L12: return *(*string)(unsafe.Pointer(&b))
util_unsafe.go#L17: sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
util_unsafe.go#L18: bh := (*reflect.SliceHeader)(unsafe.Pointer(&bs))
go.opentelemetry.io/otel/api/global/internal
meter.go#L65: delegate unsafe.Pointer // (*metric.MeterImpl)
meter.go#L82: delegate unsafe.Pointer // (*metric.SyncImpl)
meter.go#L88: delegate unsafe.Pointer // (*metric.AsyncImpl)
meter.go#L108: delegate unsafe.Pointer // (*metric.HandleImpl)
meter.go#L175: m.delegate = unsafe.Pointer(d)
meter.go#L220: atomic.StorePointer(&inst.delegate, unsafe.Pointer(implPtr))
meter.go#L297: atomic.StorePointer(&obs.delegate, unsafe.Pointer(implPtr))
meter.go#L325: atomic.StorePointer(&bound.delegate, unsafe.Pointer(implPtr))
go.opentelemetry.io/otel/internal
rawhelpers.go#L82: return (*float64)(unsafe.Pointer(r))
rawhelpers.go#L86: return (*int64)(unsafe.Pointer(r))
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]))
golang.org/x/sys/internal/unsafeheader
unsafeheader.go#L20: Data unsafe.Pointer
unsafeheader.go#L28: Data unsafe.Pointer
golang.org/x/sys/unix
fcntl_darwin.go#L16: _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk))))
fcntl_darwin.go#L22: _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore))))
ioctl.go#L29: return ioctl(fd, req, uintptr(unsafe.Pointer(&v)))
ioctl.go#L38: err := ioctl(fd, req, uintptr(unsafe.Pointer(value)))
ioctl.go#L48: err := ioctl(fd, req, uintptr(unsafe.Pointer(value)))
ioctl.go#L60: err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
ioctl.go#L66: err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
ioctl.go#L72: err := ioctl(fd, req, uintptr(unsafe.Pointer(&value)))
race0.go#L15: func raceAcquire(addr unsafe.Pointer) {
race0.go#L18: func raceReleaseMerge(addr unsafe.Pointer) {
race0.go#L21: func raceReadRange(addr unsafe.Pointer, len int) {
race0.go#L24: func raceWriteRange(addr unsafe.Pointer, len int) {
readdirent_getdirentries.go#L17: var base = (*uintptr)(unsafe.Pointer(new(uint64)))
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.go#L80: for ptr := unsafe.Pointer(p); *(*byte)(ptr) != 0; n++ {
syscall.go#L81: ptr = unsafe.Pointer(uintptr(ptr) + 1)
syscall.go#L85: h := (*unsafeheader.Slice)(unsafe.Pointer(&s))
syscall.go#L86: h.Data = unsafe.Pointer(p)
syscall_bsd.go#L156: func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_bsd.go#L162: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_bsd.go#L168: return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
syscall_bsd.go#L171: func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_bsd.go#L177: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_bsd.go#L184: return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
syscall_bsd.go#L187: func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_bsd.go#L198: return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
syscall_bsd.go#L201: func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_bsd.go#L215: return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil
syscall_bsd.go#L221: pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa))
syscall_bsd.go#L236: pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
syscall_bsd.go#L255: bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
syscall_bsd.go#L260: pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
syscall_bsd.go#L262: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_bsd.go#L270: pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
syscall_bsd.go#L272: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_bsd.go#L328: err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
syscall_bsd.go#L342: msg.Name = (*byte)(unsafe.Pointer(&rsa))
syscall_bsd.go#L346: iov.Base = (*byte)(unsafe.Pointer(&p[0]))
syscall_bsd.go#L356: msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
syscall_bsd.go#L381: var ptr unsafe.Pointer
syscall_bsd.go#L390: msg.Name = (*byte)(unsafe.Pointer(ptr))
syscall_bsd.go#L394: iov.Base = (*byte)(unsafe.Pointer(&p[0]))
syscall_bsd.go#L404: msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
syscall_bsd.go#L421: var change, event unsafe.Pointer
syscall_bsd.go#L423: change = unsafe.Pointer(&changes[0])
syscall_bsd.go#L426: event = unsafe.Pointer(&events[0])
syscall_bsd.go#L482: return *(*uint32)(unsafe.Pointer(&buf[0])), nil
syscall_bsd.go#L499: return *(*uint64)(unsafe.Pointer(&buf[0])), nil
syscall_bsd.go#L536: if err := sysctl(mib, (*byte)(unsafe.Pointer(&ci)), &n, nil, 0); err != nil {
syscall_bsd.go#L553: if err := sysctl(mib, (*byte)(unsafe.Pointer(&tv)), &n, nil, 0); err != nil {
syscall_bsd.go#L571: return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_bsd.go#L590: err = utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
syscall_bsd.go#L600: return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_bsd.go#L614: return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
syscall_bsd.go#L626: return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_darwin.1_13.go#L90: hdr := (*unsafeheader.Slice)(unsafe.Pointer(&s))
syscall_darwin.1_13.go#L91: hdr.Data = unsafe.Pointer(&entry)
syscall_darwin.go#L41: func (sa *SockaddrCtl) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_darwin.go#L47: return unsafe.Pointer(&sa.raw), SizeofSockaddrCtl, nil
syscall_darwin.go#L53: pp := (*RawSockaddrCtl)(unsafe.Pointer(rsa))
syscall_darwin.go#L83: p := (*byte)(unsafe.Pointer(&buf[0]))
syscall_darwin.go#L133: var _p0 unsafe.Pointer
syscall_darwin.go#L136: _p0 = unsafe.Pointer(&buf[0])
syscall_darwin.go#L266: unsafe.Pointer(&attrList),
syscall_darwin.go#L267: unsafe.Pointer(&attributes),
syscall_darwin.go#L292: err := ioctl(fd, CTLIOCGINFO, uintptr(unsafe.Pointer(ctlInfo)))
syscall_darwin.go#L308: err := ioctl(fd, SIOCGIFMTU, uintptr(unsafe.Pointer(&ifreq)))
syscall_darwin.go#L315: err := ioctl(fd, SIOCSIFMTU, uintptr(unsafe.Pointer(ifreq)))
syscall_darwin.go#L370: raceReleaseMerge(unsafe.Pointer(&ioSync))
syscall_darwin_libSystem.go#L32: return **(**uintptr)(unsafe.Pointer(&f))
syscall_unix.go#L120: hdr := (*unsafeheader.Slice)(unsafe.Pointer(&b))
syscall_unix.go#L121: hdr.Data = unsafe.Pointer(addr)
syscall_unix.go#L148: if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
syscall_unix.go#L159: raceWriteRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L162: raceAcquire(unsafe.Pointer(&ioSync))
syscall_unix.go#L170: raceReleaseMerge(unsafe.Pointer(&ioSync))
syscall_unix.go#L174: raceReadRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L185: sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
syscall_unix.go#L237: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L244: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L250: err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
syscall_unix.go#L257: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_unix.go#L264: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_unix.go#L271: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_unix.go#L278: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_unix.go#L285: err := getsockopt(fd, level, opt, unsafe.Pointer(&linger), &vallen)
syscall_unix.go#L292: err := getsockopt(fd, level, opt, unsafe.Pointer(&tv), &vallen)
syscall_unix.go#L299: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L324: return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
syscall_unix.go#L329: return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
syscall_unix.go#L333: return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
syscall_unix.go#L337: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
syscall_unix.go#L341: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
syscall_unix.go#L345: return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
syscall_unix.go#L349: return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
syscall_unix.go#L353: var p unsafe.Pointer
syscall_unix.go#L355: p = unsafe.Pointer(&[]byte(s)[0])
syscall_unix.go#L361: return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
syscall_unix.go#L365: return setsockopt(fd, level, opt, unsafe.Pointer(&value), 8)
zsyscall_darwin_amd64.1_13.go#L33: r0, _, _ := syscall_syscall(funcPC(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
zsyscall_darwin_amd64.go#L18: r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
zsyscall_darwin_amd64.go#L34: _, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
zsyscall_darwin_amd64.go#L49: r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
zsyscall_darwin_amd64.go#L65: r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_darwin_amd64.go#L80: func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_darwin_amd64.go#L95: func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_darwin_amd64.go#L126: func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
zsyscall_darwin_amd64.go#L127: _, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
zsyscall_darwin_amd64.go#L141: func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
zsyscall_darwin_amd64.go#L157: _, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_darwin_amd64.go#L172: _, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_darwin_amd64.go#L202: _, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
zsyscall_darwin_amd64.go#L217: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L219: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L221: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L223: r0, _, e1 := syscall_syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
zsyscall_darwin_amd64.go#L238: func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_darwin_amd64.go#L239: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L241: _p0 = unsafe.Pointer(&buf[0])
zsyscall_darwin_amd64.go#L243: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L260: r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_darwin_amd64.go#L276: r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_darwin_amd64.go#L291: func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
zsyscall_darwin_amd64.go#L292: r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
zsyscall_darwin_amd64.go#L313: _, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
zsyscall_darwin_amd64.go#L328: _, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
zsyscall_darwin_amd64.go#L343: r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
zsyscall_darwin_amd64.go#L359: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L361: _p0 = unsafe.Pointer(&b[0])
zsyscall_darwin_amd64.go#L363: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L380: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L382: _p0 = unsafe.Pointer(&b[0])
zsyscall_darwin_amd64.go#L384: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L416: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L418: _p0 = unsafe.Pointer(&b[0])
zsyscall_darwin_amd64.go#L420: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L437: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L439: _p0 = unsafe.Pointer(&b[0])
zsyscall_darwin_amd64.go#L441: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L458: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L460: _p0 = unsafe.Pointer(&b[0])
zsyscall_darwin_amd64.go#L462: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L521: r0, _, e1 := syscall_syscall6(funcPC(libc_getxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
zsyscall_darwin_amd64.go#L542: r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
zsyscall_darwin_amd64.go#L568: _, _, e1 := syscall_syscall6(funcPC(libc_setxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
zsyscall_darwin_amd64.go#L588: _, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
zsyscall_darwin_amd64.go#L613: _, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
zsyscall_darwin_amd64.go#L633: _, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
zsyscall_darwin_amd64.go#L653: r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
zsyscall_darwin_amd64.go#L669: r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
zsyscall_darwin_amd64.go#L684: func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
zsyscall_darwin_amd64.go#L685: _, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
zsyscall_darwin_amd64.go#L746: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L748: _p0 = unsafe.Pointer(&mib[0])
zsyscall_darwin_amd64.go#L750: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L752: _, _, e1 := syscall_syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
zsyscall_darwin_amd64.go#L766: func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
zsyscall_darwin_amd64.go#L767: _, _, e1 := syscall_syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
zsyscall_darwin_amd64.go#L787: _, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
zsyscall_darwin_amd64.go#L802: _, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
zsyscall_darwin_amd64.go#L822: _, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L842: _, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_darwin_amd64.go#L862: _, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
zsyscall_darwin_amd64.go#L882: _, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
zsyscall_darwin_amd64.go#L902: _, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L917: _, _, e1 := syscall_syscall(funcPC(libc_clock_gettime_trampoline), uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
zsyscall_darwin_amd64.go#L957: _, _, e1 := syscall_syscall(funcPC(libc_clonefile_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flags))
zsyscall_darwin_amd64.go#L982: _, _, e1 := syscall_syscall6(funcPC(libc_clonefileat_trampoline), uintptr(srcDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
zsyscall_darwin_amd64.go#L1038: _, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
zsyscall_darwin_amd64.go#L1070: _, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
zsyscall_darwin_amd64.go#L1135: _, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
zsyscall_darwin_amd64.go#L1170: _, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
zsyscall_darwin_amd64.go#L1190: _, _, e1 := syscall_syscall6(funcPC(libc_fclonefileat_trampoline), uintptr(srcDirfd), uintptr(dstDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0, 0)
zsyscall_darwin_amd64.go#L1266: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1268: _p0 = unsafe.Pointer(&buf[0])
zsyscall_darwin_amd64.go#L1270: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1411: _, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
zsyscall_darwin_amd64.go#L1426: _, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
zsyscall_darwin_amd64.go#L1457: _, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
zsyscall_darwin_amd64.go#L1519: _, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
zsyscall_darwin_amd64.go#L1544: _, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_darwin_amd64.go#L1569: _, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
zsyscall_darwin_amd64.go#L1604: _, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
zsyscall_darwin_amd64.go#L1624: _, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
zsyscall_darwin_amd64.go#L1644: _, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
zsyscall_darwin_amd64.go#L1664: _, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
zsyscall_darwin_amd64.go#L1684: r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
zsyscall_darwin_amd64.go#L1705: r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
zsyscall_darwin_amd64.go#L1726: r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
zsyscall_darwin_amd64.go#L1742: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1744: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L1746: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1764: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1766: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L1768: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1786: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1788: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L1790: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1813: var _p1 unsafe.Pointer
zsyscall_darwin_amd64.go#L1815: _p1 = unsafe.Pointer(&buf[0])
zsyscall_darwin_amd64.go#L1817: _p1 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1819: r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
zsyscall_darwin_amd64.go#L1840: var _p1 unsafe.Pointer
zsyscall_darwin_amd64.go#L1842: _p1 = unsafe.Pointer(&buf[0])
zsyscall_darwin_amd64.go#L1844: _p1 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1846: r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
zsyscall_darwin_amd64.go#L1872: _, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_darwin_amd64.go#L1897: _, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
zsyscall_darwin_amd64.go#L1917: _, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L1937: _, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L1968: r0, _, e1 := syscall_syscall6(funcPC(libc_select_trampoline), uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
zsyscall_darwin_amd64.go#L2034: _, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L2124: _, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
zsyscall_darwin_amd64.go#L2155: _, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
zsyscall_darwin_amd64.go#L2195: _, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_darwin_amd64.go#L2220: _, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
zsyscall_darwin_amd64.go#L2255: _, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
zsyscall_darwin_amd64.go#L2288: _, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L2308: _, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L2328: _, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
zsyscall_darwin_amd64.go#L2348: _, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_darwin_amd64.go#L2363: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L2365: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L2367: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L2416: r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
zsyscall_darwin_amd64.go#L2427: r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
zsyscall_darwin_amd64.go#L2438: _, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L2458: _, _, e1 := syscall_syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
zsyscall_darwin_amd64.go#L2473: _, _, e1 := syscall_syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L2487: func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
zsyscall_darwin_amd64.go#L2509: _, _, e1 := syscall_syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L2544: _, _, e1 := syscall_syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L2564: _, _, e1 := syscall_syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
google.golang.org/protobuf/internal/impl
pointer_unsafe.go#L18: type Pointer unsafe.Pointer
pointer_unsafe.go#L39: type pointer struct{ p unsafe.Pointer }
pointer_unsafe.go#L43: return pointer{p: unsafe.Pointer(p)}
pointer_unsafe.go#L48: return pointer{p: unsafe.Pointer(v.Pointer())}
pointer_unsafe.go#L54: Type unsafe.Pointer
pointer_unsafe.go#L55: Data unsafe.Pointer
pointer_unsafe.go#L57: return pointer{p: (*ifaceHeader)(unsafe.Pointer(&v)).Data}
pointer_unsafe.go#L71: return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
pointer_unsafe.go#L117: return pointer{p: *(*unsafe.Pointer)(p.p)}
pointer_unsafe.go#L136: *(*unsafe.Pointer)(p.p) = (unsafe.Pointer)(v.p)
pointer_unsafe.go#L140: const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{}))
pointer_unsafe.go#L144: return (*messageState)(unsafe.Pointer(p))
pointer_unsafe.go#L148: return pointer{p: unsafe.Pointer(ms)}
pointer_unsafe.go#L158: return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo))))
pointer_unsafe.go#L161: atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi))
pointer_unsafe.go#L164: type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper
pointer_unsafe.go#L171: atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w))
google.golang.org/protobuf/internal/strs
strings_unsafe.go#L17: Data unsafe.Pointer
strings_unsafe.go#L21: Data unsafe.Pointer
strings_unsafe.go#L33: src := (*sliceHeader)(unsafe.Pointer(&b))
strings_unsafe.go#L34: dst := (*stringHeader)(unsafe.Pointer(&s))
strings_unsafe.go#L45: src := (*stringHeader)(unsafe.Pointer(&s))
strings_unsafe.go#L46: dst := (*sliceHeader)(unsafe.Pointer(&b))
google.golang.org/protobuf/reflect/protoreflect
value_unsafe.go#L17: Data unsafe.Pointer
value_unsafe.go#L21: Data unsafe.Pointer
value_unsafe.go#L26: Type unsafe.Pointer
value_unsafe.go#L27: Data unsafe.Pointer
value_unsafe.go#L47: func typeOf(t interface{}) unsafe.Pointer {
value_unsafe.go#L48: return (*ifaceHeader)(unsafe.Pointer(&t)).Type
value_unsafe.go#L61: typ unsafe.Pointer // 8B
value_unsafe.go#L64: ptr unsafe.Pointer // 8B
value_unsafe.go#L75: p := (*stringHeader)(unsafe.Pointer(&v))
value_unsafe.go#L79: p := (*sliceHeader)(unsafe.Pointer(&v))
value_unsafe.go#L83: p := (*ifaceHeader)(unsafe.Pointer(&v))
value_unsafe.go#L88: *(*stringHeader)(unsafe.Pointer(&x)) = stringHeader{Data: v.ptr, Len: int(v.num)}
value_unsafe.go#L92: *(*sliceHeader)(unsafe.Pointer(&x)) = sliceHeader{Data: v.ptr, Len: int(v.num), Cap: int(v.num)}
value_unsafe.go#L96: *(*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/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/race
norace.go#L15: func Acquire(addr unsafe.Pointer) {
norace.go#L18: func Release(addr unsafe.Pointer) {
norace.go#L21: func ReleaseMerge(addr unsafe.Pointer) {
norace.go#L30: func Read(addr unsafe.Pointer) {
norace.go#L33: func Write(addr unsafe.Pointer) {
norace.go#L36: func ReadRange(addr unsafe.Pointer, len int) {
norace.go#L39: func WriteRange(addr unsafe.Pointer, len int) {
internal/reflectlite
swapper.go#L40: ps := *(*[]unsafe.Pointer)(v.ptr)
type.go#L161: equal func(unsafe.Pointer, unsafe.Pointer) bool
type.go#L248: hasher func(unsafe.Pointer, uintptr) uintptr
type.go#L317: return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off), whySafe))
type.go#L340: b := (*[4]byte)(unsafe.Pointer(n.bytes))
type.go#L342: hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
type.go#L343: hdr.Data = unsafe.Pointer(&b[3])
type.go#L354: hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
type.go#L355: hdr.Data = unsafe.Pointer(n.data(3+nl+2, "non-empty string"))
type.go#L371: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off, "name offset field")))[:])
type.go#L372: pkgPathName := name{(*byte)(resolveTypeOff(unsafe.Pointer(n.bytes), nameOff))}
type.go#L429: return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.mcount > 0"))[:t.mcount:t.mcount]
type.go#L436: return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.xcount > 0"))[:t.xcount:t.xcount]
type.go#L442: func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
type.go#L447: func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L454: return name{(*byte)(resolveNameOff(unsafe.Pointer(t), int32(off)))}
type.go#L458: return (*rtype)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
type.go#L467: return &(*structTypeUncommon)(unsafe.Pointer(t)).u
type.go#L473: return &(*u)(unsafe.Pointer(t)).u
type.go#L479: return &(*u)(unsafe.Pointer(t)).u
type.go#L485: return &(*u)(unsafe.Pointer(t)).u
type.go#L491: return &(*u)(unsafe.Pointer(t)).u
type.go#L497: return &(*u)(unsafe.Pointer(t)).u
type.go#L503: return &(*u)(unsafe.Pointer(t)).u
type.go#L509: return &(*u)(unsafe.Pointer(t)).u
type.go#L515: return &(*u)(unsafe.Pointer(t)).u
type.go#L545: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L582: tt := (*chanType)(unsafe.Pointer(t))
type.go#L589: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L592: tt := (*chanType)(unsafe.Pointer(t))
type.go#L595: tt := (*mapType)(unsafe.Pointer(t))
type.go#L598: tt := (*ptrType)(unsafe.Pointer(t))
type.go#L601: tt := (*sliceType)(unsafe.Pointer(t))
type.go#L611: tt := (*funcType)(unsafe.Pointer(t))
type.go#L619: tt := (*mapType)(unsafe.Pointer(t))
type.go#L627: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L635: tt := (*structType)(unsafe.Pointer(t))
type.go#L643: tt := (*funcType)(unsafe.Pointer(t))
type.go#L651: tt := (*funcType)(unsafe.Pointer(t))
type.go#L659: tt := (*funcType)(unsafe.Pointer(t))
type.go#L671: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.inCount:t.inCount]
type.go#L683: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "outCount > 0"))[t.inCount : t.inCount+outCount : t.inCount+outCount]
type.go#L693: func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
type.go#L694: return unsafe.Pointer(uintptr(p) + x)
type.go#L703: eface := *(*emptyInterface)(unsafe.Pointer(&i))
type.go#L734: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L752: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L880: t := (*funcType)(unsafe.Pointer(T))
type.go#L881: v := (*funcType)(unsafe.Pointer(V))
type.go#L898: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L899: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L914: t := (*structType)(unsafe.Pointer(T))
type.go#L915: v := (*structType)(unsafe.Pointer(V))
value.go#L42: ptr unsafe.Pointer
value.go#L92: func (v Value) pointer() unsafe.Pointer {
value.go#L97: return *(*unsafe.Pointer)(v.ptr)
value.go#L106: e := (*emptyInterface)(unsafe.Pointer(&i))
value.go#L126: e.word = *(*unsafe.Pointer)(v.ptr)
value.go#L141: e := (*emptyInterface)(unsafe.Pointer(&i))
value.go#L183: word unsafe.Pointer
value.go#L246: ptr = *(*unsafe.Pointer)(ptr)
value.go#L252: tt := (*ptrType)(unsafe.Pointer(v.typ))
value.go#L298: ptr = *(*unsafe.Pointer)(ptr)
value.go#L304: return *(*unsafe.Pointer)(v.ptr) == nil
value.go#L325: func chanlen(unsafe.Pointer) int
value.go#L326: func maplen(unsafe.Pointer) int
value.go#L334: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L364: var target unsafe.Pointer
value.go#L372: *(*unsafe.Pointer)(v.ptr) = x.ptr
value.go#L391: func unsafe_New(*rtype) unsafe.Pointer
value.go#L412: func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
value.go#L455: func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
value.go#L459: func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer)
value.go#L463: func typedmemmove(t *rtype, dst, src unsafe.Pointer)
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
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L14: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L66: func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L93: var _cgo_daa8182be981_C2func_getaddrinfo = unsafe.Pointer(&__cgofn__cgo_daa8182be981_C2func_getaddrinfo)
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L97: errno := _cgo_runtime_cgocall(_cgo_daa8182be981_C2func_getaddrinfo, uintptr(unsafe.Pointer(&p0)))
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L110: var _cgo_daa8182be981_C2func_getnameinfo = unsafe.Pointer(&__cgofn__cgo_daa8182be981_C2func_getnameinfo)
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L114: errno := _cgo_runtime_cgocall(_cgo_daa8182be981_C2func_getnameinfo, uintptr(unsafe.Pointer(&p0)))
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L137: var _cgo_daa8182be981_Cfunc_freeaddrinfo = unsafe.Pointer(&__cgofn__cgo_daa8182be981_Cfunc_freeaddrinfo)
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L141: _cgo_runtime_cgocall(_cgo_daa8182be981_Cfunc_freeaddrinfo, uintptr(unsafe.Pointer(&p0)))
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L150: var _cgo_daa8182be981_Cfunc_gai_strerror = unsafe.Pointer(&__cgofn__cgo_daa8182be981_Cfunc_gai_strerror)
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L154: _cgo_runtime_cgocall(_cgo_daa8182be981_Cfunc_gai_strerror, uintptr(unsafe.Pointer(&p0)))
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L163: var _cgo_daa8182be981_Cfunc_getaddrinfo = unsafe.Pointer(&__cgofn__cgo_daa8182be981_Cfunc_getaddrinfo)
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L167: _cgo_runtime_cgocall(_cgo_daa8182be981_Cfunc_getaddrinfo, uintptr(unsafe.Pointer(&p0)))
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L179: var _cgo_daa8182be981_Cfunc_getnameinfo = unsafe.Pointer(&__cgofn__cgo_daa8182be981_Cfunc_getnameinfo)
d2bd86cebde3e0fc58c0894535c79a607aa00c5e131cf2d9a8cd9652c62ae01e-d#L183: _cgo_runtime_cgocall(_cgo_daa8182be981_Cfunc_getnameinfo, uintptr(unsafe.Pointer(&p0)))
cgo_resnew.go#L24: gerrno, err := ( /*line :21:17*/_C2func_getnameinfo /*line :21:29*/)(sa, salen, (* /*line :21:44*/_Ctype_char /*line :21:50*/)(unsafe.Pointer(&b[0])), /*line :21:76*/_Ctype_socklen_t /*line :21:87*/(len(b)), nil, 0, ( /*line :21:105*/_Ciconst_NI_NAMEREQD /*line :21:117*/))
cgo_sockold.go#L29: return (* /*line :26:11*/_Ctype_struct_sockaddr /*line :26:28*/)(unsafe.Pointer(&sa))
cgo_sockold.go#L35: return (* /*line :32:11*/_Ctype_struct_sockaddr /*line :32:28*/)(unsafe.Pointer(&sa))
cgo_unix.go#L110: gerrno, err := func() (_Ctype_int, error){ var _cgo0 *_Ctype_char = /*line :107:31*/nil; var _cgo1 *_Ctype_char = /*line :107:36*/(*_Ctype_char)(unsafe.Pointer(&cservice[0])); _cgo2 := /*line :107:77*/hints; _cgoBase3 := /*line :107:84*/&res; _cgo3 := _cgoBase3; _cgoCheckPointer(_cgo2, nil); _cgoCheckPointer(_cgoBase3, 0 == 0); return _C2func_getaddrinfo(_cgo0, _cgo1, _cgo2, _cgo3); }()
cgo_unix.go#L129: sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.ai_addr))
cgo_unix.go#L130: p := (*[2]byte)(unsafe.Pointer(&sa.Port))
cgo_unix.go#L133: sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.ai_addr))
cgo_unix.go#L134: p := (*[2]byte)(unsafe.Pointer(&sa.Port))
cgo_unix.go#L164: gerrno, err := func() (_Ctype_int, error){ var _cgo0 *_Ctype_char = /*line :161:31*/(*_Ctype_char)(unsafe.Pointer(&h[0])); var _cgo1 *_Ctype_char = /*line :161:65*/nil; _cgoBase2 := /*line :161:70*/&hints; _cgo2 := _cgoBase2; _cgoBase3 := /*line :161:78*/&res; _cgo3 := _cgoBase3; _cgoCheckPointer(_cgoBase2, 0 == 0); _cgoCheckPointer(_cgoBase3, 0 == 0); return _C2func_getaddrinfo(_cgo0, _cgo1, _cgo2, _cgo3); }()
cgo_unix.go#L208: sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.ai_addr))
cgo_unix.go#L212: sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.ai_addr))
os
dir_darwin.go#L60: name := (*[len(syscall.Dirent{}.Name)]byte)(unsafe.Pointer(&dirent.Name))[:]
os/user
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L14: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L73: func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L91: func _Cfunc__CMalloc(n _Ctype_size_t) unsafe.Pointer {
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L97: var _cgo_a722341dd114_Cfunc_free = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc_free)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L100: func _Cfunc_free(p0 unsafe.Pointer) (r1 _Ctype_void) {
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L101: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc_free, uintptr(unsafe.Pointer(&p0)))
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L110: var _cgo_a722341dd114_Cfunc_mygetgrgid_r = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc_mygetgrgid_r)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L114: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc_mygetgrgid_r, uintptr(unsafe.Pointer(&p0)))
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L127: var _cgo_a722341dd114_Cfunc_mygetgrnam_r = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc_mygetgrnam_r)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L131: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc_mygetgrnam_r, uintptr(unsafe.Pointer(&p0)))
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L144: var _cgo_a722341dd114_Cfunc_mygetgrouplist = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc_mygetgrouplist)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L148: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc_mygetgrouplist, uintptr(unsafe.Pointer(&p0)))
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L160: var _cgo_a722341dd114_Cfunc_mygetpwnam_r = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc_mygetpwnam_r)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L164: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc_mygetpwnam_r, uintptr(unsafe.Pointer(&p0)))
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L177: var _cgo_a722341dd114_Cfunc_mygetpwuid_r = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc_mygetpwuid_r)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L181: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc_mygetpwuid_r, uintptr(unsafe.Pointer(&p0)))
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L194: var _cgo_a722341dd114_Cfunc_realloc = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc_realloc)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L197: func _Cfunc_realloc(p0 unsafe.Pointer, p1 _Ctype_size_t) (r1 unsafe.Pointer) {
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L198: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc_realloc, uintptr(unsafe.Pointer(&p0)))
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L208: var _cgo_a722341dd114_Cfunc_sysconf = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc_sysconf)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L212: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc_sysconf, uintptr(unsafe.Pointer(&p0)))
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L222: var _cgo_a722341dd114_Cfunc__Cmalloc = unsafe.Pointer(&__cgofn__cgo_a722341dd114_Cfunc__Cmalloc)
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L228: func _cgo_cmalloc(p0 uint64) (r1 unsafe.Pointer) {
f944835971175ae02f5a15dd71fd940ec4b08d0430844caacc17edcfd010b48b-d#L229: _cgo_runtime_cgocall(_cgo_a722341dd114_Cfunc__Cmalloc, uintptr(unsafe.Pointer(&p0)))
cgo_lookup_unix.go#L69: return syscall.Errno(func() _Ctype_int{ var _cgo0 *_Ctype_char = /*line :66:39*/(*_Ctype_char)(unsafe.Pointer(&nameC[0])); _cgoBase1 := /*line :67:4*/&pwd; _cgo1 := _cgoBase1; var _cgo2 *_Ctype_char = /*line :68:4*/(*_Ctype_char)(buf.ptr); var _cgo3 _Ctype_size_t = _Ctype_size_t(buf.size); _cgoBase4 := /*line :70:4*/&result; _cgo4 := _cgoBase4; _cgoCheckPointer(_cgoBase1, 0 == 0); _cgoCheckPointer(_cgoBase4, 0 == 0); return _Cfunc_mygetpwnam_r(_cgo0, _cgo1, _cgo2, _cgo3, _cgo4); }())
cgo_lookup_unix.go#L137: return syscall.Errno(func() _Ctype_int{ var _cgo0 *_Ctype_char = /*line :142:39*/(*_Ctype_char)(unsafe.Pointer(&cname[0])); _cgoBase1 := /*line :143:4*/&grp; _cgo1 := _cgoBase1; var _cgo2 *_Ctype_char = /*line :144:4*/(*_Ctype_char)(buf.ptr); var _cgo3 _Ctype_size_t = _Ctype_size_t(buf.size); _cgoBase4 := /*line :146:4*/&result; _cgo4 := _cgoBase4; _cgoCheckPointer(_cgoBase1, 0 == 0); _cgoCheckPointer(_cgoBase4, 0 == 0); return _Cfunc_mygetgrnam_r(_cgo0, _cgo1, _cgo2, _cgo3, _cgo4); }())
cgo_lookup_unix.go#L208: ptr unsafe.Pointer
cgo_lookup_unix.go#L221: mb.ptr = func() _cgo_unsafe.Pointer{ _cgo0 := /*line :234:21*/mb.ptr; var _cgo1 _Ctype_size_t = /*line :234:29*/newSize; _cgoCheckPointer(_cgo0, nil); return _Cfunc_realloc(_cgo0, _cgo1); }()
getgrouplist_darwin.go#L46: rv := getGroupList((* /*line :43:24*/_Ctype_char /*line :43:30*/)(unsafe.Pointer(&name[0])), userGID, &(*gids)[0], n)
listgroups_unix.go#L38: rv := getGroupList((* /*line :35:23*/_Ctype_char /*line :35:29*/)(unsafe.Pointer(&nameC[0])), userGID, &gidsC[0], &n)
reflect
deepequal.go#L16: a1 unsafe.Pointer
deepequal.go#L17: a2 unsafe.Pointer
deepequal.go#L60: ptrval := func(v Value) unsafe.Pointer {
makefunc.go#L54: ftyp := (*funcType)(unsafe.Pointer(t))
makefunc.go#L60: code := **(**uintptr)(unsafe.Pointer(&dummy))
makefunc.go#L67: return Value{t, unsafe.Pointer(impl), flag(Func)}
makefunc.go#L106: ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))
makefunc.go#L112: code := **(**uintptr)(unsafe.Pointer(&dummy))
makefunc.go#L130: return Value{&ftyp.rtype, unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
swapper.go#L40: ps := *(*[]unsafe.Pointer)(v.ptr)
type.go#L315: equal func(unsafe.Pointer, unsafe.Pointer) bool
type.go#L402: hasher func(unsafe.Pointer, uintptr) uintptr
type.go#L471: return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off), whySafe))
type.go#L494: b := (*[4]byte)(unsafe.Pointer(n.bytes))
type.go#L496: hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
type.go#L497: hdr.Data = unsafe.Pointer(&b[3])
type.go#L508: hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
type.go#L509: hdr.Data = unsafe.Pointer(n.data(3+nl+2, "non-empty string"))
type.go#L525: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off, "name offset field")))[:])
type.go#L526: pkgPathName := name{(*byte)(resolveTypeOff(unsafe.Pointer(n.bytes), nameOff))}
type.go#L632: return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.mcount > 0"))[:t.mcount:t.mcount]
type.go#L639: return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.xcount > 0"))[:t.xcount:t.xcount]
type.go#L645: func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
type.go#L650: func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L655: func resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
type.go#L660: func addReflectOff(ptr unsafe.Pointer) int32
type.go#L665: return nameOff(addReflectOff(unsafe.Pointer(n.bytes)))
type.go#L671: return typeOff(addReflectOff(unsafe.Pointer(t)))
type.go#L677: func resolveReflectText(ptr unsafe.Pointer) textOff {
type.go#L686: return name{(*byte)(resolveNameOff(unsafe.Pointer(t), int32(off)))}
type.go#L690: return (*rtype)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
type.go#L693: func (t *rtype) textOff(off textOff) unsafe.Pointer {
type.go#L694: return resolveTextOff(unsafe.Pointer(t), int32(off))
type.go#L703: return &(*structTypeUncommon)(unsafe.Pointer(t)).u
type.go#L709: return &(*u)(unsafe.Pointer(t)).u
type.go#L715: return &(*u)(unsafe.Pointer(t)).u
type.go#L721: return &(*u)(unsafe.Pointer(t)).u
type.go#L727: return &(*u)(unsafe.Pointer(t)).u
type.go#L733: return &(*u)(unsafe.Pointer(t)).u
type.go#L739: return &(*u)(unsafe.Pointer(t)).u
type.go#L745: return &(*u)(unsafe.Pointer(t)).u
type.go#L751: return &(*u)(unsafe.Pointer(t)).u
type.go#L796: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L804: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L816: ft := (*funcType)(unsafe.Pointer(mtyp))
type.go#L829: fn := unsafe.Pointer(&tfn)
type.go#L838: tt := (*interfaceType)(unsafe.Pointer(t))
type.go#L885: tt := (*chanType)(unsafe.Pointer(t))
type.go#L893: tt := (*funcType)(unsafe.Pointer(t))
type.go#L900: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L903: tt := (*chanType)(unsafe.Pointer(t))
type.go#L906: tt := (*mapType)(unsafe.Pointer(t))
type.go#L909: tt := (*ptrType)(unsafe.Pointer(t))
type.go#L912: tt := (*sliceType)(unsafe.Pointer(t))
type.go#L922: tt := (*structType)(unsafe.Pointer(t))
type.go#L930: tt := (*structType)(unsafe.Pointer(t))
type.go#L938: tt := (*structType)(unsafe.Pointer(t))
type.go#L946: tt := (*structType)(unsafe.Pointer(t))
type.go#L954: tt := (*funcType)(unsafe.Pointer(t))
type.go#L962: tt := (*mapType)(unsafe.Pointer(t))
type.go#L970: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L978: tt := (*structType)(unsafe.Pointer(t))
type.go#L986: tt := (*funcType)(unsafe.Pointer(t))
type.go#L994: tt := (*funcType)(unsafe.Pointer(t))
type.go#L1002: tt := (*funcType)(unsafe.Pointer(t))
type.go#L1014: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.inCount:t.inCount]
type.go#L1026: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "outCount > 0"))[t.inCount : t.inCount+outCount : t.inCount+outCount]
type.go#L1036: func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
type.go#L1037: return unsafe.Pointer(uintptr(p) + x)
type.go#L1319: styp := (*structType)(unsafe.Pointer(ntyp))
type.go#L1369: eface := *(*emptyInterface)(unsafe.Pointer(&i))
type.go#L1395: p := (*ptrType)(unsafe.Pointer(tt))
type.go#L1405: var iptr interface{} = (*unsafe.Pointer)(nil)
type.go#L1406: prototype := *(**ptrType)(unsafe.Pointer(&iptr))
type.go#L1468: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L1486: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L1622: t := (*funcType)(unsafe.Pointer(T))
type.go#L1623: v := (*funcType)(unsafe.Pointer(V))
type.go#L1640: t := (*interfaceType)(unsafe.Pointer(T))
type.go#L1641: v := (*interfaceType)(unsafe.Pointer(V))
type.go#L1656: t := (*structType)(unsafe.Pointer(T))
type.go#L1657: v := (*structType)(unsafe.Pointer(V))
type.go#L1705: func typelinks() (sections []unsafe.Pointer, offset [][]int32)
type.go#L1707: func rtypeOff(section unsafe.Pointer, off int32) *rtype {
type.go#L1815: ch := (*chanType)(unsafe.Pointer(tt))
type.go#L1823: var ichan interface{} = (chan unsafe.Pointer)(nil)
type.go#L1824: prototype := *(**chanType)(unsafe.Pointer(&ichan))
type.go#L1859: mt := (*mapType)(unsafe.Pointer(tt))
type.go#L1869: var imap interface{} = (map[unsafe.Pointer]unsafe.Pointer)(nil)
type.go#L1870: mt := **(**mapType)(unsafe.Pointer(&imap))
type.go#L1877: mt.hasher = func(p unsafe.Pointer, seed uintptr) uintptr {
type.go#L1950: prototype := *(**funcType)(unsafe.Pointer(&ifunc))
type.go#L2065: repr = append(repr, (*sliceType)(unsafe.Pointer(t)).elem.String()...)
type.go#L2098: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2101: tt := (*structType)(unsafe.Pointer(t))
type.go#L2125: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2128: tt := (*structType)(unsafe.Pointer(t))
type.go#L2147: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L2150: tt := (*structType)(unsafe.Pointer(t))
type.go#L2237: return (*[1 << 30]byte)(unsafe.Pointer(t.gcdata))[begin:end:end]
type.go#L2264: n := uintptr(*(*uint32)(unsafe.Pointer(typ.gcdata)))
type.go#L2299: slice := (*sliceType)(unsafe.Pointer(tt))
type.go#L2307: var islice interface{} = ([]unsafe.Pointer)(nil)
type.go#L2308: prototype := *(**sliceType)(unsafe.Pointer(&islice))
type.go#L2425: ift := (*interfaceType)(unsafe.Pointer(ft))
type.go#L2479: ifn: resolveReflectText(unsafe.Pointer(&ifn)),
type.go#L2480: tfn: resolveReflectText(unsafe.Pointer(&tfn)),
type.go#L2484: ptr := (*ptrType)(unsafe.Pointer(ft))
type.go#L2611: typ = (*structType)(unsafe.Pointer(tt.Elem().Field(0).UnsafeAddr()))
type.go#L2612: ut = (*uncommonType)(unsafe.Pointer(tt.Elem().Field(1).UnsafeAddr()))
type.go#L2636: prototype := *(**structType)(unsafe.Pointer(&istruct))
type.go#L2730: *(*uint32)(unsafe.Pointer(&prog[0])) = uint32(len(prog) - 4)
type.go#L2743: typ.equal = func(p, q unsafe.Pointer) bool {
type.go#L2804: st := (*structType)(unsafe.Pointer(t))
type.go#L2844: array := (*arrayType)(unsafe.Pointer(tt))
type.go#L2852: var iarray interface{} = [1]unsafe.Pointer{}
type.go#L2853: prototype := *(**arrayType)(unsafe.Pointer(&iarray))
type.go#L2924: *(*uint32)(unsafe.Pointer(&prog[0])) = uint32(len(prog) - 4)
type.go#L2935: array.equal = func(p, q unsafe.Pointer) bool {
type.go#L3119: tt := (*arrayType)(unsafe.Pointer(t))
type.go#L3126: tt := (*structType)(unsafe.Pointer(t))
value.go#L43: ptr unsafe.Pointer
value.go#L94: func (v Value) pointer() unsafe.Pointer {
value.go#L99: return *(*unsafe.Pointer)(v.ptr)
value.go#L108: e := (*emptyInterface)(unsafe.Pointer(&i))
value.go#L128: e.word = *(*unsafe.Pointer)(v.ptr)
value.go#L143: e := (*emptyInterface)(unsafe.Pointer(&i))
value.go#L196: word unsafe.Pointer
value.go#L207: fun [100000]unsafe.Pointer // method table
value.go#L209: word unsafe.Pointer
value.go#L357: t := (*funcType)(unsafe.Pointer(v.typ))
value.go#L359: fn unsafe.Pointer
value.go#L367: fn = *(*unsafe.Pointer)(v.ptr)
value.go#L437: var args unsafe.Pointer
value.go#L439: args = framePool.Get().(unsafe.Pointer)
value.go#L470: *(*unsafe.Pointer)(addr) = v.ptr
value.go#L536: func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool) {
value.go#L558: v.ptr = *(*unsafe.Pointer)(add(ptr, off, "1-ptr"))
value.go#L635: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *rtype, t *funcType, fn unsafe.Pointer) {
value.go#L638: tt := (*interfaceType)(unsafe.Pointer(v.typ))
value.go#L651: fn = unsafe.Pointer(&iface.itab.fun[i])
value.go#L652: t = (*funcType)(unsafe.Pointer(tt.typeOff(m.typ)))
value.go#L664: fn = unsafe.Pointer(&ifn)
value.go#L665: t = (*funcType)(unsafe.Pointer(v.typ.typeOff(m.mtyp)))
value.go#L674: func storeRcvr(v Value, p unsafe.Pointer) {
value.go#L679: *(*unsafe.Pointer)(p) = iface.word
value.go#L681: *(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(v.ptr)
value.go#L683: *(*unsafe.Pointer)(p) = v.ptr
value.go#L709: func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool) {
value.go#L716: scratch := framePool.Get().(unsafe.Pointer)
value.go#L762: pc := *(*uintptr)(unsafe.Pointer(&f))
value.go#L831: ptr = *(*unsafe.Pointer)(ptr)
value.go#L837: tt := (*ptrType)(unsafe.Pointer(v.typ))
value.go#L852: tt := (*structType)(unsafe.Pointer(v.typ))
value.go#L941: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L964: tt := (*sliceType)(unsafe.Pointer(v.typ))
value.go#L1078: ptr = *(*unsafe.Pointer)(ptr)
value.go#L1084: return *(*unsafe.Pointer)(v.ptr) == nil
value.go#L1150: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L1172: tt := (*mapType)(unsafe.Pointer(v.typ))
value.go#L1183: var k unsafe.Pointer
value.go#L1187: k = unsafe.Pointer(&key.ptr)
value.go#L1205: tt := (*mapType)(unsafe.Pointer(v.typ))
value.go#L1236: it unsafe.Pointer
value.go#L1248: t := (*mapType)(unsafe.Pointer(it.m.typ))
value.go#L1262: t := (*mapType)(unsafe.Pointer(it.m.typ))
value.go#L1305: func copyVal(typ *rtype, fl flag, ptr unsafe.Pointer) Value {
value.go#L1313: return Value{typ, *(*unsafe.Pointer)(ptr), fl}
value.go#L1370: tt := (*structType)(unsafe.Pointer(v.typ))
value.go#L1476: return **(**uintptr)(unsafe.Pointer(&f))
value.go#L1482: p = *(*unsafe.Pointer)(p)
value.go#L1506: tt := (*chanType)(unsafe.Pointer(v.typ))
value.go#L1512: var p unsafe.Pointer
value.go#L1518: p = unsafe.Pointer(&val.ptr)
value.go#L1539: tt := (*chanType)(unsafe.Pointer(v.typ))
value.go#L1545: var p unsafe.Pointer
value.go#L1549: p = unsafe.Pointer(&x.ptr)
value.go#L1560: var target unsafe.Pointer
value.go#L1566: if x.ptr == unsafe.Pointer(&zeroVal[0]) {
value.go#L1572: *(*unsafe.Pointer)(v.ptr) = x.ptr
value.go#L1690: tt := (*mapType)(unsafe.Pointer(v.typ))
value.go#L1692: var k unsafe.Pointer
value.go#L1696: k = unsafe.Pointer(&key.ptr)
value.go#L1704: var e unsafe.Pointer
value.go#L1708: e = unsafe.Pointer(&elem.ptr)
value.go#L1737: func (v Value) SetPointer(x unsafe.Pointer) {
value.go#L1740: *(*unsafe.Pointer)(v.ptr) = x
value.go#L1758: base unsafe.Pointer
value.go#L1768: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L1770: typ = (*sliceType)(unsafe.Pointer(tt.slice))
value.go#L1774: typ = (*sliceType)(unsafe.Pointer(v.typ))
value.go#L1788: return Value{v.typ, unsafe.Pointer(&t), v.flag}
value.go#L1796: var x []unsafe.Pointer
value.go#L1799: s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
value.go#L1810: return Value{typ.common(), unsafe.Pointer(&x), fl}
value.go#L1820: base unsafe.Pointer
value.go#L1830: tt := (*arrayType)(unsafe.Pointer(v.typ))
value.go#L1832: typ = (*sliceType)(unsafe.Pointer(tt.slice))
value.go#L1836: typ = (*sliceType)(unsafe.Pointer(v.typ))
value.go#L1848: var x []unsafe.Pointer
value.go#L1851: s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
value.go#L1862: return Value{typ.common(), unsafe.Pointer(&x), fl}
value.go#L1920: tt := (*interfaceType)(unsafe.Pointer(v.typ))
value.go#L2013: func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
value.go#L2129: ch unsafe.Pointer // channel
value.go#L2130: val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir)
value.go#L2226: tt := (*chanType)(unsafe.Pointer(ch.typ))
value.go#L2241: rc.val = unsafe.Pointer(&v.ptr)
value.go#L2254: tt := (*chanType)(unsafe.Pointer(ch.typ))
value.go#L2266: tt := (*chanType)(unsafe.Pointer(runcases[chosen].typ))
value.go#L2273: recv = Value{t, *(*unsafe.Pointer)(p), fl}
value.go#L2284: func unsafe_New(*rtype) unsafe.Pointer
value.go#L2285: func unsafe_NewArray(*rtype, int) unsafe.Pointer
value.go#L2304: return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L2377: var p unsafe.Pointer
value.go#L2379: p = unsafe.Pointer(&zeroVal[0])
value.go#L2408: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L2418: func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
value.go#L2758: func chancap(ch unsafe.Pointer) int
value.go#L2759: func chanclose(ch unsafe.Pointer)
value.go#L2760: func chanlen(ch unsafe.Pointer) int
value.go#L2771: func chanrecv(ch unsafe.Pointer, nb bool, val unsafe.Pointer) (selected, received bool)
value.go#L2774: func chansend(ch unsafe.Pointer, val unsafe.Pointer, nb bool) bool
value.go#L2776: func makechan(typ *rtype, size int) (ch unsafe.Pointer)
value.go#L2777: func makemap(t *rtype, cap int) (m unsafe.Pointer)
value.go#L2780: func mapaccess(t *rtype, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
value.go#L2783: func mapassign(t *rtype, m unsafe.Pointer, key, val unsafe.Pointer)
value.go#L2786: func mapdelete(t *rtype, m unsafe.Pointer, key unsafe.Pointer)
value.go#L2791: func mapiterinit(t *rtype, m unsafe.Pointer) unsafe.Pointer
value.go#L2794: func mapiterkey(it unsafe.Pointer) (key unsafe.Pointer)
value.go#L2797: func mapiterelem(it unsafe.Pointer) (elem unsafe.Pointer)
value.go#L2800: func mapiternext(it unsafe.Pointer)
value.go#L2803: func maplen(m unsafe.Pointer) int
value.go#L2812: func call(argtype *rtype, fn, arg unsafe.Pointer, n uint32, retoffset uint32)
value.go#L2814: func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer)
value.go#L2818: func memmove(dst, src unsafe.Pointer, size uintptr)
value.go#L2822: func typedmemmove(t *rtype, dst, src unsafe.Pointer)
value.go#L2827: func typedmemmovepartial(t *rtype, dst, src unsafe.Pointer, off, size uintptr)
value.go#L2831: func typedmemclr(t *rtype, ptr unsafe.Pointer)
value.go#L2836: func typedmemclrpartial(t *rtype, ptr unsafe.Pointer, off, size uintptr)
value.go#L2844: 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#L213: func reflect_typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
alg.go#L217: func memequal0(p, q unsafe.Pointer) bool {
alg.go#L220: func memequal8(p, q unsafe.Pointer) bool {
alg.go#L223: func memequal16(p, q unsafe.Pointer) bool {
alg.go#L226: func memequal32(p, q unsafe.Pointer) bool {
alg.go#L229: func memequal64(p, q unsafe.Pointer) bool {
alg.go#L232: func memequal128(p, q unsafe.Pointer) bool {
alg.go#L235: func f32equal(p, q unsafe.Pointer) bool {
alg.go#L238: func f64equal(p, q unsafe.Pointer) bool {
alg.go#L241: func c64equal(p, q unsafe.Pointer) bool {
alg.go#L244: func c128equal(p, q unsafe.Pointer) bool {
alg.go#L247: func strequal(p, q unsafe.Pointer) bool {
alg.go#L250: func interequal(p, q unsafe.Pointer) bool {
alg.go#L255: func nilinterequal(p, q unsafe.Pointer) bool {
alg.go#L260: func efaceeq(t *_type, x, y unsafe.Pointer) bool {
alg.go#L276: func ifaceeq(tab *itab, x, y unsafe.Pointer) bool {
alg.go#L294: return strhash(noescape(unsafe.Pointer(&s)), seed)
alg.go#L298: s := (*slice)(unsafe.Pointer(&b))
alg.go#L303: return memhash32(noescape(unsafe.Pointer(&i)), seed)
alg.go#L307: return memhash64(noescape(unsafe.Pointer(&i)), seed)
alg.go#L311: return nilinterhash(noescape(unsafe.Pointer(&i)), seed)
alg.go#L317: return interhash(noescape(unsafe.Pointer(&i)), seed)
alg.go#L341: getRandomData((*[len(hashkey) * sys.PtrSize]byte)(unsafe.Pointer(&hashkey))[:])
alg.go#L355: func readUnaligned32(p unsafe.Pointer) uint32 {
alg.go#L363: func readUnaligned64(p unsafe.Pointer) uint64 {
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
cgocall.go#L99: args unsafe.Pointer
cgocall.go#L107: func syscall_cgocaller(fn unsafe.Pointer, args ...uintptr) uintptr {
cgocall.go#L108: as := argset{args: unsafe.Pointer(&args[0])}
cgocall.go#L109: cgocall(fn, unsafe.Pointer(&as))
cgocall.go#L120: func cgocall(fn, arg unsafe.Pointer) int32 {
cgocall.go#L130: racereleasemerge(unsafe.Pointer(&racecgosync))
cgocall.go#L178: raceacquire(unsafe.Pointer(&racecgosync))
cgocall.go#L200: func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
cgocall.go#L221: savedsp := unsafe.Pointer(gp.syscallsp)
cgocall.go#L243: func cgocallbackg1(fn, frame unsafe.Pointer, ctxt uintptr) {
cgocall.go#L259: p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
cgocall.go#L260: atomicstorep(unsafe.Pointer(&p.array), unsafe.Pointer(&s[0]))
cgocall.go#L266: p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
cgocall.go#L284: raceacquire(unsafe.Pointer(&racecgosync))
cgocall.go#L289: var cb func(frame unsafe.Pointer)
cgocall.go#L291: *(*unsafe.Pointer)(unsafe.Pointer(&cb)) = noescape(unsafe.Pointer(&cbFV))
cgocall.go#L295: racereleasemerge(unsafe.Pointer(&racecgosync))
cgocall.go#L313: sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + sys.MinFrameSize))
cgocall.go#L315: sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + 16))
cgocall.go#L393: p = *(*unsafe.Pointer)(p)
cgocall.go#L405: pt := (*ptrtype)(unsafe.Pointer(t))
cgocall.go#L434: func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
cgocall.go#L444: at := (*arraytype)(unsafe.Pointer(t))
cgocall.go#L463: p = *(*unsafe.Pointer)(p)
cgocall.go#L477: if inheap(uintptr(unsafe.Pointer(it))) {
cgocall.go#L480: p = *(*unsafe.Pointer)(add(p, sys.PtrSize))
cgocall.go#L489: st := (*slicetype)(unsafe.Pointer(t))
cgocall.go#L514: st := (*structtype)(unsafe.Pointer(t))
cgocall.go#L530: p = *(*unsafe.Pointer)(p)
cgocall.go#L551: func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
cgocall.go#L565: if hbits.isPointer() && cgoIsGoPointer(*(*unsafe.Pointer)(unsafe.Pointer(base + i))) {
cgocall.go#L592: func cgoIsGoPointer(p unsafe.Pointer) bool {
cgocall.go#L613: 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#L35: buf unsafe.Pointer // points to an array of dataqsiz elements
chan.go#L102: c.buf = add(unsafe.Pointer(c), hchanSize)
chan.go#L121: func chanbuf(c *hchan, i uint) unsafe.Pointer {
chan.go#L142: func chansend1(c *hchan, elem unsafe.Pointer) {
chan.go#L158: func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
chan.go#L257: gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2)
chan.go#L292: func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
chan.go#L315: gp.param = unsafe.Pointer(sg)
chan.go#L333: func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
chan.go#L346: func recvDirect(t *_type, sg *sudog, dst unsafe.Pointer) {
chan.go#L390: gp.param = unsafe.Pointer(sg)
chan.go#L409: gp.param = unsafe.Pointer(sg)
chan.go#L431: return atomic.Loadp(unsafe.Pointer(&c.sendq.first)) == nil
chan.go#L438: func chanrecv1(c *hchan, elem unsafe.Pointer) {
chan.go#L443: func chanrecv2(c *hchan, elem unsafe.Pointer) (received bool) {
chan.go#L454: func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
chan.go#L576: gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanReceive, traceEvGoBlockRecv, 2)
chan.go#L607: func recv(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {
chan.go#L641: gp.param = unsafe.Pointer(sg)
chan.go#L649: func chanparkcommit(gp *g, chanLock unsafe.Pointer) bool {
chan.go#L686: func selectnbsend(c *hchan, elem unsafe.Pointer) (selected bool) {
chan.go#L707: func selectnbrecv(elem unsafe.Pointer, c *hchan) (selected bool) {
chan.go#L729: func selectnbrecv2(elem unsafe.Pointer, received *bool, c *hchan) (selected bool) {
chan.go#L736: func reflect_chansend(c *hchan, elem unsafe.Pointer, nb bool) (selected bool) {
chan.go#L741: func reflect_chanrecv(c *hchan, nb bool, elem unsafe.Pointer) (selected bool, received bool) {
chan.go#L820: func (c *hchan) raceaddr() unsafe.Pointer {
chan.go#L826: return unsafe.Pointer(&c.buf)
checkptr.go#L9: func checkptrAlignment(p unsafe.Pointer, elem *_type, n uintptr) {
checkptr.go#L24: func checkptrArithmetic(p unsafe.Pointer, originals []unsafe.Pointer) {
checkptr.go#L53: func checkptrBase(p unsafe.Pointer) uintptr {
cpuprof.go#L204: 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#L117: newg := newproc1(*(**funcval)(unsafe.Pointer(&fn)), unsafe.Pointer(&args), int32(unsafe.Sizeof(args)), gp, callerpc)
debugcall.go#L230: *(*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)))
defs_darwin_amd64.go#L114: sa_tramp unsafe.Pointer
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#L23: func memhashFallback(p unsafe.Pointer, seed, s uintptr) uintptr {
hash64.go#L81: func memhash32Fallback(p unsafe.Pointer, seed uintptr) uintptr {
hash64.go#L93: func memhash64Fallback(p unsafe.Pointer, seed uintptr) 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: dumpint(uint64(uintptr(unsafe.Pointer(d.fn))))
heapdump.go#L389: dumpint(uint64(uintptr(unsafe.Pointer(d.fn.fn))))
heapdump.go#L391: dumpint(uint64(uintptr(unsafe.Pointer(d.link))))
heapdump.go#L395: dumpint(uint64(uintptr(unsafe.Pointer(p))))
heapdump.go#L396: dumpint(uint64(uintptr(unsafe.Pointer(gp))))
heapdump.go#L398: dumpint(uint64(uintptr(unsafe.Pointer(eface._type))))
heapdump.go#L399: dumpint(uint64(uintptr(unsafe.Pointer(eface.data))))
heapdump.go#L401: dumpint(uint64(uintptr(unsafe.Pointer(p.link))))
heapdump.go#L424: func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype) {
heapdump.go#L427: dumpint(uint64(uintptr(unsafe.Pointer(fn))))
heapdump.go#L428: dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
heapdump.go#L429: dumpint(uint64(uintptr(unsafe.Pointer(fint))))
heapdump.go#L430: dumpint(uint64(uintptr(unsafe.Pointer(ot))))
heapdump.go#L441: dumpmemrange(unsafe.Pointer(firstmoduledata.data), firstmoduledata.edata-firstmoduledata.data)
heapdump.go#L447: dumpmemrange(unsafe.Pointer(firstmoduledata.bss), firstmoduledata.ebss-firstmoduledata.bss)
heapdump.go#L458: spf := (*specialfinalizer)(unsafe.Pointer(sp))
heapdump.go#L459: p := unsafe.Pointer(s.base() + uintptr(spf.special.offset))
heapdump.go#L499: dumpobj(unsafe.Pointer(p), size, makeheapobjbv(p, size))
heapdump.go#L507: if *(*byte)(unsafe.Pointer(&x)) == 1 {
heapdump.go#L542: dumpint(uint64(uintptr(unsafe.Pointer(tab))))
heapdump.go#L543: dumpint(uint64(uintptr(unsafe.Pointer(t))))
heapdump.go#L553: dumpint(uint64(uintptr(unsafe.Pointer(mp))))
heapdump.go#L598: stk := (*[100000]uintptr)(unsafe.Pointer(pstk))
heapdump.go#L600: dumpint(uint64(uintptr(unsafe.Pointer(b))))
heapdump.go#L657: spp := (*specialprofile)(unsafe.Pointer(sp))
heapdump.go#L661: dumpint(uint64(uintptr(unsafe.Pointer(spp.b))))
heapdump.go#L677: memclrNoHeapPointers(unsafe.Pointer(&typecache), unsafe.Sizeof(typecache))
heapdump.go#L678: dwrite(unsafe.Pointer(&dumphdr[0]), uintptr(len(dumphdr)))
heapdump.go#L712: sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
heapdump.go#L730: sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
histogram.go#L124: return *(*float64)(unsafe.Pointer(&inf))
histogram.go#L129: return *(*float64)(unsafe.Pointer(&inf))
iface.go#L53: t := (*itabTableType)(atomic.Loadp(unsafe.Pointer(&itabTable)))
iface.go#L103: p := (**itab)(add(unsafe.Pointer(&t.entries), h*sys.PtrSize))
iface.go#L107: m := (*itab)(atomic.Loadp(unsafe.Pointer(p)))
iface.go#L148: atomicstorep(unsafe.Pointer(&itabTable), unsafe.Pointer(t2))
iface.go#L164: p := (**itab)(add(unsafe.Pointer(&t.entries), h*sys.PtrSize))
iface.go#L178: atomic.StorepNoWB(unsafe.Pointer(p), unsafe.Pointer(m))
iface.go#L202: xmhdr := (*[1 << 16]method)(add(unsafe.Pointer(x), uintptr(x.moff)))[:nt:nt]
iface.go#L204: methods := (*[1 << 16]unsafe.Pointer)(unsafe.Pointer(&m.fun[0]))[:ni:ni]
iface.go#L205: var fun0 unsafe.Pointer
iface.go#L318: func convT2E(t *_type, elem unsafe.Pointer) (e eface) {
iface.go#L334: func convT16(val uint16) (x unsafe.Pointer) {
iface.go#L336: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L347: func convT32(val uint32) (x unsafe.Pointer) {
iface.go#L349: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L360: func convT64(val uint64) (x unsafe.Pointer) {
iface.go#L362: x = unsafe.Pointer(&staticuint64s[val])
iface.go#L370: func convTstring(val string) (x unsafe.Pointer) {
iface.go#L372: x = unsafe.Pointer(&zeroVal[0])
iface.go#L380: func convTslice(val []byte) (x unsafe.Pointer) {
iface.go#L382: if (*slice)(unsafe.Pointer(&val)).array == nil {
iface.go#L383: x = unsafe.Pointer(&zeroVal[0])
iface.go#L391: func convT2Enoptr(t *_type, elem unsafe.Pointer) (e eface) {
iface.go#L405: func convT2I(tab *itab, elem unsafe.Pointer) (i iface) {
iface.go#L420: func convT2Inoptr(tab *itab, elem unsafe.Pointer) (i iface) {
iface.go#L524: m := *(**itab)(add(unsafe.Pointer(&t.entries), i*sys.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<lfstack_64bit.go#L45: return uint64(uintptr(unsafe.Pointer(node)))<<(64-addrBits) | uint64(cnt&(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_sema.go#L79: if atomic.Casuintptr(&l.key, v, uintptr(unsafe.Pointer(gp.m))|locked) {
lock_sema.go#L161: semawakeup((*m)(unsafe.Pointer(v)))
lock_sema.go#L171: if !atomic.Casuintptr(&n.key, 0, uintptr(unsafe.Pointer(gp.m))) {
lock_sema.go#L202: if !atomic.Casuintptr(&n.key, 0, uintptr(unsafe.Pointer(gp.m))) {
lock_sema.go#L257: case uintptr(unsafe.Pointer(gp.m)):
malloc.go#L606: a, size := sysReserveAligned(unsafe.Pointer(p), arenaSize, heapArenaBytes)
malloc.go#L629: func (h *mheap) sysAlloc(n uintptr) (v unsafe.Pointer, size uintptr) {
malloc.go#L655: v = sysReserve(unsafe.Pointer(p), n)
malloc.go#L676: h.arenaHintAlloc.free(unsafe.Pointer(hint))
malloc.go#L741: atomic.StorepNoWB(unsafe.Pointer(&h.arenas[ri.l1()]), unsafe.Pointer(l2))
malloc.go#L767: *(*notInHeapSlice)(unsafe.Pointer(&h.allArenas)) = notInHeapSlice{newArray, len(h.allArenas), int(size / sys.PtrSize)}
malloc.go#L781: atomic.StorepNoWB(unsafe.Pointer(&l2[ri.l2()]), unsafe.Pointer(r))
malloc.go#L795: func sysReserveAligned(v unsafe.Pointer, size, align uintptr) (unsafe.Pointer, uintptr) {
malloc.go#L808: return unsafe.Pointer(p), size + align
malloc.go#L814: sysFree(unsafe.Pointer(p), size+align, nil)
malloc.go#L816: p2 := sysReserve(unsafe.Pointer(p), size)
malloc.go#L830: sysFree(unsafe.Pointer(p), pAligned-p, nil)
malloc.go#L834: sysFree(unsafe.Pointer(end), endLen, nil)
malloc.go#L836: return unsafe.Pointer(pAligned), size
malloc.go#L905: func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
malloc.go#L911: return unsafe.Pointer(&zerobase)
malloc.go#L982: var x unsafe.Pointer
malloc.go#L1034: x = unsafe.Pointer(c.tiny + off)
malloc.go#L1047: x = unsafe.Pointer(v)
malloc.go#L1071: x = unsafe.Pointer(v)
malloc.go#L1073: memclrNoHeapPointers(unsafe.Pointer(v), size)
malloc.go#L1081: x = unsafe.Pointer(span.base())
malloc.go#L1176: func newobject(typ *_type) unsafe.Pointer {
malloc.go#L1181: func reflect_unsafe_New(typ *_type) unsafe.Pointer {
malloc.go#L1186: func reflectlite_unsafe_New(typ *_type) unsafe.Pointer {
malloc.go#L1191: func newarray(typ *_type, n int) unsafe.Pointer {
malloc.go#L1203: func reflect_unsafe_NewArray(typ *_type, n int) unsafe.Pointer {
malloc.go#L1207: func profilealloc(mp *m, x unsafe.Pointer, size uintptr) {
malloc.go#L1311: func persistentalloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer {
malloc.go#L1316: return unsafe.Pointer(p)
malloc.go#L1365: chunks := uintptr(unsafe.Pointer(persistentChunks))
malloc.go#L1366: *(*uintptr)(unsafe.Pointer(persistent.base)) = chunks
malloc.go#L1367: if atomic.Casuintptr((*uintptr)(unsafe.Pointer(&persistentChunks)), chunks, uintptr(unsafe.Pointer(persistent.base))) {
malloc.go#L1392: chunk := atomic.Loaduintptr((*uintptr)(unsafe.Pointer(&persistentChunks)))
malloc.go#L1397: chunk = *(*uintptr)(unsafe.Pointer(chunk))
malloc.go#L1423: func (l *linearAlloc) alloc(size, align uintptr, sysStat *sysMemStat) unsafe.Pointer {
malloc.go#L1431: sysMap(unsafe.Pointer(l.mapped), pEnd-l.mapped, sysStat)
malloc.go#L1432: sysUsed(unsafe.Pointer(l.mapped), pEnd-l.mapped)
malloc.go#L1435: return unsafe.Pointer(p)
malloc.go#L1451: return (*notInHeap)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + bytes))
map.go#L124: buckets unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
map.go#L125: oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
map.go#L165: key unsafe.Pointer // Must be in first position. Write nil to indicate iteration end (see cmd/compile/internal/gc/range.go).
map.go#L166: elem unsafe.Pointer // Must be in second position (see cmd/compile/internal/gc/range.go).
map.go#L169: buckets unsafe.Pointer // bucket ptr at hash_iter initialization time
map.go#L208: return *(**bmap)(add(unsafe.Pointer(b), uintptr(t.bucketsize)-sys.PtrSize))
map.go#L212: *(**bmap)(add(unsafe.Pointer(b), uintptr(t.bucketsize)-sys.PtrSize)) = ovf
map.go#L215: func (b *bmap) keys() unsafe.Pointer {
map.go#L216: return add(unsafe.Pointer(b), dataOffset)
map.go#L253: h.extra.nextOverflow = (*bmap)(add(unsafe.Pointer(ovf), uintptr(t.bucketsize)))
map.go#L344: func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) {
map.go#L394: func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map.go#L398: racereadpc(unsafe.Pointer(h), callerpc, pc)
map.go#L408: return unsafe.Pointer(&zeroVal[0])
map.go#L436: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L438: k = *((*unsafe.Pointer)(k))
map.go#L441: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L443: e = *((*unsafe.Pointer)(e))
map.go#L449: return unsafe.Pointer(&zeroVal[0])
map.go#L452: func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool) {
map.go#L456: racereadpc(unsafe.Pointer(h), callerpc, pc)
map.go#L466: return unsafe.Pointer(&zeroVal[0]), false
map.go#L473: b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + (hash&m)*uintptr(t.bucketsize)))
map.go#L479: oldb := (*bmap)(unsafe.Pointer(uintptr(c) + (hash&m)*uintptr(t.bucketsize)))
map.go#L494: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L496: k = *((*unsafe.Pointer)(k))
map.go#L499: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L501: e = *((*unsafe.Pointer)(e))
map.go#L507: return unsafe.Pointer(&zeroVal[0]), false
map.go#L511: func mapaccessK(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer) {
map.go#L517: b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + (hash&m)*uintptr(t.bucketsize)))
map.go#L523: oldb := (*bmap)(unsafe.Pointer(uintptr(c) + (hash&m)*uintptr(t.bucketsize)))
map.go#L538: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L540: k = *((*unsafe.Pointer)(k))
map.go#L543: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L545: e = *((*unsafe.Pointer)(e))
map.go#L554: func mapaccess1_fat(t *maptype, h *hmap, key, zero unsafe.Pointer) unsafe.Pointer {
map.go#L556: if e == unsafe.Pointer(&zeroVal[0]) {
map.go#L562: func mapaccess2_fat(t *maptype, h *hmap, key, zero unsafe.Pointer) (unsafe.Pointer, bool) {
map.go#L564: if e == unsafe.Pointer(&zeroVal[0]) {
map.go#L571: func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map.go#L578: racewritepc(unsafe.Pointer(h), callerpc, pc)
map.go#L606: var insertk unsafe.Pointer
map.go#L607: var elem unsafe.Pointer
map.go#L614: insertk = add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L615: elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L622: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L624: k = *((*unsafe.Pointer)(k))
map.go#L633: elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L656: insertk = add(unsafe.Pointer(newb), dataOffset)
map.go#L663: *(*unsafe.Pointer)(insertk) = kmem
map.go#L668: *(*unsafe.Pointer)(elem) = vmem
map.go#L680: elem = *((*unsafe.Pointer)(elem))
map.go#L685: func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
map.go#L689: racewritepc(unsafe.Pointer(h), callerpc, pc)
map.go#L727: k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
map.go#L730: k2 = *((*unsafe.Pointer)(k2))
map.go#L737: *(*unsafe.Pointer)(k) = nil
map.go#L741: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
map.go#L743: *(*unsafe.Pointer)(e) = nil
map.go#L805: racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapiterinit))
map.go#L855: racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapiternext))
map.go#L905: k := add(unsafe.Pointer(b), dataOffset+uintptr(offi)*uintptr(t.keysize))
map.go#L907: k = *((*unsafe.Pointer)(k))
map.go#L909: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+uintptr(offi)*uintptr(t.elemsize))
map.go#L946: e = *((*unsafe.Pointer)(e))
map.go#L982: racewritepc(unsafe.Pointer(h), callerpc, pc)
map.go#L1133: k unsafe.Pointer // pointer to current key storage
map.go#L1134: e unsafe.Pointer // pointer to current elem storage
map.go#L1148: x.k = add(unsafe.Pointer(x.b), dataOffset)
map.go#L1156: y.k = add(unsafe.Pointer(y.b), dataOffset)
map.go#L1161: k := add(unsafe.Pointer(b), dataOffset)
map.go#L1174: k2 = *((*unsafe.Pointer)(k2))
map.go#L1212: dst.k = add(unsafe.Pointer(dst.b), dataOffset)
map.go#L1217: *(*unsafe.Pointer)(dst.k) = k2 // copy pointer
map.go#L1222: *(*unsafe.Pointer)(dst.e) = *(*unsafe.Pointer)(e)
map.go#L1317: func reflect_mapaccess(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map.go#L1327: func reflect_mapassign(t *maptype, h *hmap, key unsafe.Pointer, elem unsafe.Pointer) {
map.go#L1333: func reflect_mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
map.go#L1350: func reflect_mapiterkey(it *hiter) unsafe.Pointer {
map.go#L1355: func reflect_mapiterelem(it *hiter) unsafe.Pointer {
map.go#L1366: racereadpc(unsafe.Pointer(h), callerpc, funcPC(reflect_maplen))
map.go#L1378: racereadpc(unsafe.Pointer(h), callerpc, funcPC(reflect_maplen))
map_fast32.go#L12: func mapaccess1_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
map_fast32.go#L15: racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess1_fast32))
map_fast32.go#L18: return unsafe.Pointer(&zeroVal[0])
map_fast32.go#L28: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L45: return add(unsafe.Pointer(b), dataOffset+bucketCnt*4+i*uintptr(t.elemsize))
map_fast32.go#L49: return unsafe.Pointer(&zeroVal[0])
map_fast32.go#L52: func mapaccess2_fast32(t *maptype, h *hmap, key uint32) (unsafe.Pointer, bool) {
map_fast32.go#L55: racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess2_fast32))
map_fast32.go#L58: return unsafe.Pointer(&zeroVal[0]), false
map_fast32.go#L68: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L85: return add(unsafe.Pointer(b), dataOffset+bucketCnt*4+i*uintptr(t.elemsize)), true
map_fast32.go#L89: return unsafe.Pointer(&zeroVal[0]), false
map_fast32.go#L92: func mapassign_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
map_fast32.go#L98: racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapassign_fast32))
map_fast32.go#L103: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L121: var insertk unsafe.Pointer
map_fast32.go#L136: k := *((*uint32)(add(unsafe.Pointer(b), dataOffset+i*4)))
map_fast32.go#L167: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*4)
map_fast32.go#L174: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*4+inserti*uintptr(t.elemsize))
map_fast32.go#L182: func mapassign_fast32ptr(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map_fast32.go#L188: racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapassign_fast32))
map_fast32.go#L193: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L211: var insertk unsafe.Pointer
map_fast32.go#L226: k := *((*unsafe.Pointer)(add(unsafe.Pointer(b), dataOffset+i*4)))
map_fast32.go#L257: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*4)
map_fast32.go#L259: *(*unsafe.Pointer)(insertk) = key
map_fast32.go#L264: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*4+inserti*uintptr(t.elemsize))
map_fast32.go#L275: racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapdelete_fast32))
map_fast32.go#L284: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast32.go#L307: *(*unsafe.Pointer)(k) = nil
map_fast32.go#L309: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*4+i*uintptr(t.elemsize))
map_fast32.go#L384: x.k = add(unsafe.Pointer(x.b), dataOffset)
map_fast32.go#L392: y.k = add(unsafe.Pointer(y.b), dataOffset)
map_fast32.go#L397: k := add(unsafe.Pointer(b), dataOffset)
map_fast32.go#L424: dst.k = add(unsafe.Pointer(dst.b), dataOffset)
map_fast32.go#L432: *(*unsafe.Pointer)(dst.k) = *(*unsafe.Pointer)(k)
map_fast64.go#L12: func mapaccess1_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
map_fast64.go#L15: racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess1_fast64))
map_fast64.go#L18: return unsafe.Pointer(&zeroVal[0])
map_fast64.go#L28: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L45: return add(unsafe.Pointer(b), dataOffset+bucketCnt*8+i*uintptr(t.elemsize))
map_fast64.go#L49: return unsafe.Pointer(&zeroVal[0])
map_fast64.go#L52: func mapaccess2_fast64(t *maptype, h *hmap, key uint64) (unsafe.Pointer, bool) {
map_fast64.go#L55: racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess2_fast64))
map_fast64.go#L58: return unsafe.Pointer(&zeroVal[0]), false
map_fast64.go#L68: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L85: return add(unsafe.Pointer(b), dataOffset+bucketCnt*8+i*uintptr(t.elemsize)), true
map_fast64.go#L89: return unsafe.Pointer(&zeroVal[0]), false
map_fast64.go#L92: func mapassign_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
map_fast64.go#L98: racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapassign_fast64))
map_fast64.go#L103: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L121: var insertk unsafe.Pointer
map_fast64.go#L136: k := *((*uint64)(add(unsafe.Pointer(b), dataOffset+i*8)))
map_fast64.go#L167: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*8)
map_fast64.go#L174: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*8+inserti*uintptr(t.elemsize))
map_fast64.go#L182: func mapassign_fast64ptr(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
map_fast64.go#L188: racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapassign_fast64))
map_fast64.go#L193: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L211: var insertk unsafe.Pointer
map_fast64.go#L226: k := *((*unsafe.Pointer)(add(unsafe.Pointer(b), dataOffset+i*8)))
map_fast64.go#L257: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*8)
map_fast64.go#L259: *(*unsafe.Pointer)(insertk) = key
map_fast64.go#L264: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*8+inserti*uintptr(t.elemsize))
map_fast64.go#L275: racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapdelete_fast64))
map_fast64.go#L284: hash := t.hasher(noescape(unsafe.Pointer(&key)), uintptr(h.hash0))
map_fast64.go#L304: *(*unsafe.Pointer)(k) = nil
map_fast64.go#L311: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*8+i*uintptr(t.elemsize))
map_fast64.go#L386: x.k = add(unsafe.Pointer(x.b), dataOffset)
map_fast64.go#L394: y.k = add(unsafe.Pointer(y.b), dataOffset)
map_fast64.go#L399: k := add(unsafe.Pointer(b), dataOffset)
map_fast64.go#L426: dst.k = add(unsafe.Pointer(dst.b), dataOffset)
map_fast64.go#L435: *(*unsafe.Pointer)(dst.k) = *(*unsafe.Pointer)(k)
map_faststr.go#L12: func mapaccess1_faststr(t *maptype, h *hmap, ky string) unsafe.Pointer {
map_faststr.go#L15: racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess1_faststr))
map_faststr.go#L18: return unsafe.Pointer(&zeroVal[0])
map_faststr.go#L38: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+i*uintptr(t.elemsize))
map_faststr.go#L41: return unsafe.Pointer(&zeroVal[0])
map_faststr.go#L54: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+i*uintptr(t.elemsize))
map_faststr.go#L71: k := (*stringStruct)(add(unsafe.Pointer(b), dataOffset+keymaybe*2*sys.PtrSize))
map_faststr.go#L73: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+keymaybe*uintptr(t.elemsize))
map_faststr.go#L76: return unsafe.Pointer(&zeroVal[0])
map_faststr.go#L79: hash := t.hasher(noescape(unsafe.Pointer(&ky)), uintptr(h.hash0))
map_faststr.go#L100: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+i*uintptr(t.elemsize))
map_faststr.go#L104: return unsafe.Pointer(&zeroVal[0])
map_faststr.go#L107: func mapaccess2_faststr(t *maptype, h *hmap, ky string) (unsafe.Pointer, bool) {
map_faststr.go#L110: racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapaccess2_faststr))
map_faststr.go#L113: return unsafe.Pointer(&zeroVal[0]), false
map_faststr.go#L133: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+i*uintptr(t.elemsize)), true
map_faststr.go#L136: return unsafe.Pointer(&zeroVal[0]), false
map_faststr.go#L149: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+i*uintptr(t.elemsize)), true
map_faststr.go#L166: k := (*stringStruct)(add(unsafe.Pointer(b), dataOffset+keymaybe*2*sys.PtrSize))
map_faststr.go#L168: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+keymaybe*uintptr(t.elemsize)), true
map_faststr.go#L171: return unsafe.Pointer(&zeroVal[0]), false
map_faststr.go#L174: hash := t.hasher(noescape(unsafe.Pointer(&ky)), uintptr(h.hash0))
map_faststr.go#L195: return add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+i*uintptr(t.elemsize)), true
map_faststr.go#L199: return unsafe.Pointer(&zeroVal[0]), false
map_faststr.go#L202: func mapassign_faststr(t *maptype, h *hmap, s string) unsafe.Pointer {
map_faststr.go#L208: racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapassign_faststr))
map_faststr.go#L214: hash := t.hasher(noescape(unsafe.Pointer(&s)), uintptr(h.hash0))
map_faststr.go#L233: var insertk unsafe.Pointer
map_faststr.go#L248: k := (*stringStruct)(add(unsafe.Pointer(b), dataOffset+i*2*sys.PtrSize))
map_faststr.go#L283: insertk = add(unsafe.Pointer(insertb), dataOffset+inserti*2*sys.PtrSize)
map_faststr.go#L289: elem := add(unsafe.Pointer(insertb), dataOffset+bucketCnt*2*sys.PtrSize+inserti*uintptr(t.elemsize))
map_faststr.go#L300: racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapdelete_faststr))
map_faststr.go#L310: hash := t.hasher(noescape(unsafe.Pointer(&ky)), uintptr(h.hash0))
map_faststr.go#L334: e := add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+i*uintptr(t.elemsize))
map_faststr.go#L409: x.k = add(unsafe.Pointer(x.b), dataOffset)
map_faststr.go#L417: y.k = add(unsafe.Pointer(y.b), dataOffset)
map_faststr.go#L422: k := add(unsafe.Pointer(b), dataOffset)
map_faststr.go#L449: dst.k = add(unsafe.Pointer(dst.b), dataOffset)
mbarrier.go#L156: func typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L177: func reflect_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L190: func reflectlite_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
mbarrier.go#L198: func reflect_typedmemmovepartial(typ *_type, dst, src unsafe.Pointer, off, size uintptr) {
mbarrier.go#L226: func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr) {
mbarrier.go#L234: func typedslicecopy(typ *_type, dstPtr unsafe.Pointer, dstLen int, srcPtr unsafe.Pointer, srcLen int) int {
mbarrier.go#L298: func typedmemclr(typ *_type, ptr unsafe.Pointer) {
mbarrier.go#L306: func reflect_typedmemclr(typ *_type, ptr unsafe.Pointer) {
mbarrier.go#L311: func reflect_typedmemclrpartial(typ *_type, ptr unsafe.Pointer, off, size uintptr) {
mbarrier.go#L324: func memclrHasPointers(ptr unsafe.Pointer, n uintptr) {
mbitmap.go#L73: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + n))
mbitmap.go#L83: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) - n))
mbitmap.go#L93: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + 1))
mbitmap.go#L105: return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) - 1))
mbitmap.go#L149: bytes := (*[8]uint8)(unsafe.Pointer(s.allocBits.bytep(whichByte)))
mbitmap.go#L294: m.bytep = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(m.bytep)) + 1))
mbitmap.go#L466: nbitp := uintptr(unsafe.Pointer(h.bitp)) + n/4
mbitmap.go#L468: if nbitp <= uintptr(unsafe.Pointer(h.last)) {
mbitmap.go#L469: h.bitp = (*uint8)(unsafe.Pointer(nbitp))
mbitmap.go#L474: past := nbitp - (uintptr(unsafe.Pointer(h.last)) + 1)
mbitmap.go#L491: maxn := 4 * ((uintptr(unsafe.Pointer(h.last)) + 1) - uintptr(unsafe.Pointer(h.bitp)))
mbitmap.go#L590: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L600: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L601: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L631: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L665: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L671: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L724: dstx := (*uintptr)(unsafe.Pointer(dst + i))
mbitmap.go#L725: srcx := (*uintptr)(unsafe.Pointer(src + i))
mbitmap.go#L765: memclrNoHeapPointers(unsafe.Pointer(h.bitp), nbyte)
mbitmap.go#L786: mrkBits := *(*uint64)(unsafe.Pointer(s.gcmarkBits.bytep(i)))
mbitmap.go#L977: h.bitp = (*uint8)(unsafe.Pointer(x))
mbitmap.go#L1322: src := (*uint8)(unsafe.Pointer(x))
mbitmap.go#L1352: memmove(unsafe.Pointer(h.bitp), unsafe.Pointer(src), n)
mbitmap.go#L1368: if uintptr(unsafe.Pointer(src)) > x+size {
mbitmap.go#L1379: memclrNoHeapPointers(unsafe.Pointer(x), uintptr(unsafe.Pointer(src))-x)
mbitmap.go#L1543: endProg := unsafe.Pointer(addb(h.bitp, (totalBits+3)/4))
mbitmap.go#L1544: endAlloc := unsafe.Pointer(addb(h.bitp, allocSize/sys.PtrSize/wordsPerBitmapByte))
mbitmap.go#L1841: totalBits = (uintptr(unsafe.Pointer(dst))-uintptr(unsafe.Pointer(dstStart)))*8 + nbits
mbitmap.go#L1849: totalBits = (uintptr(unsafe.Pointer(dst))-uintptr(unsafe.Pointer(dstStart)))*4 + nbits
mbitmap.go#L1872: runGCProg(addb(prog, 4), nil, (*byte)(unsafe.Pointer(s.startAddr)), 1)
mbitmap.go#L1926: func getgcmaskcb(frame *stkframe, ctxt unsafe.Pointer) bool {
mbitmap.go#L1940: typ := (*ptrtype)(unsafe.Pointer(efaceOf(&x)._type)).elem
mbitmap.go#L1960: n := (*ptrtype)(unsafe.Pointer(t)).elem.size
mbitmap.go#L1972: n := (*ptrtype)(unsafe.Pointer(t)).elem.size
mbitmap.go#L2005: 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#L2012: 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_darwin.go#L14: func sysAlloc(n uintptr, sysStat *sysMemStat) unsafe.Pointer {
mem_darwin.go#L23: func sysUnused(v unsafe.Pointer, n uintptr) {
mem_darwin.go#L29: func sysUsed(v unsafe.Pointer, n uintptr) {
mem_darwin.go#L36: func sysHugePage(v unsafe.Pointer, n uintptr) {
mem_darwin.go#L42: func sysFree(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) {
mem_darwin.go#L47: func sysFault(v unsafe.Pointer, n uintptr) {
mem_darwin.go#L51: func sysReserve(v unsafe.Pointer, n uintptr) unsafe.Pointer {
mem_darwin.go#L61: func sysMap(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) {
metrics.go#L438: pointer unsafe.Pointer // contains non-scalar values.
metrics.go#L451: v.pointer = unsafe.Pointer(hist)
metrics.go#L477: func readMetrics(samplesp unsafe.Pointer, len int, cap int) {
metrics.go#L480: samples := *(*[]metricSample)(unsafe.Pointer(&sl))
mfinal.go#L43: arg unsafe.Pointer // ptr to object (may be a heap pointer)
mfinal.go#L77: func queuefinalizer(p unsafe.Pointer, fn *funcval, nret uintptr, fint *_type, ot *ptrtype) {
mfinal.go#L127: func iterate_finq(callback func(*funcval, unsafe.Pointer, uintptr, *_type, *ptrtype)) {
mfinal.go#L163: frame unsafe.Pointer
mfinal.go#L207: *(*unsafe.Pointer)(frame) = f.arg
mfinal.go#L209: ityp := (*interfacetype)(unsafe.Pointer(f.fint))
mfinal.go#L222: reflectcall(nil, unsafe.Pointer(f.fn), frame, uint32(framesz), uint32(framesz))
mfinal.go#L323: ot := (*ptrtype)(unsafe.Pointer(etyp))
mfinal.go#L333: if e.data == unsafe.Pointer(&zerobase) {
mfinal.go#L377: ft := (*functype)(unsafe.Pointer(ftyp))
mfinal.go#L390: if (fint.uncommon() == nil || etyp.uncommon() == nil) && (*ptrtype)(unsafe.Pointer(fint)).elem == ot.elem {
mfinal.go#L396: 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#L52: func (f *fixalloc) init(size uintptr, first func(arg, p unsafe.Pointer), arg unsafe.Pointer, stat *sysMemStat) {
mfixalloc.go#L64: func (f *fixalloc) alloc() unsafe.Pointer {
mfixalloc.go#L71: v := unsafe.Pointer(f.list)
mfixalloc.go#L84: v := unsafe.Pointer(f.chunk)
mfixalloc.go#L94: func (f *fixalloc) free(p unsafe.Pointer) {
mgc.go#L756: if atomic.Cas64((*uint64)(unsafe.Pointer(ptr)), uint64(v), uint64(v-1)) {
mgc.go#L1911: gopark(func(g *g, nodep unsafe.Pointer) bool {
mgc.go#L1938: }, unsafe.Pointer(node), waitReasonGCWorkerIdle, traceEvGoBlock, 0)
mgcmark.go#L176: scanblock(uintptr(unsafe.Pointer(&fb.fin[0])), cnt*unsafe.Sizeof(fb.fin[0]), &finptrmask[0], gcw, nil)
mgcmark.go#L262: ptrmask := (*uint8)(add(unsafe.Pointer(ptrmask0), uintptr(shard)*(rootBlockBytes/(8*sys.PtrSize))))
mgcmark.go#L366: spf := (*specialfinalizer)(unsafe.Pointer(sp))
mgcmark.go#L376: scanblock(uintptr(unsafe.Pointer(&spf.fn)), sys.PtrSize, &oneptrmask[0], gcw, nil)
mgcmark.go#L565: gp.param = unsafe.Pointer(gp)
mgcmark.go#L741: scanblock(uintptr(unsafe.Pointer(&gp.sched.ctxt)), sys.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L745: scanframe := func(frame *stkframe, unused unsafe.Pointer) bool {
mgcmark.go#L762: scanblock(uintptr(unsafe.Pointer(&d.fn)), sys.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L767: scanblock(uintptr(unsafe.Pointer(&d.link)), sys.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L773: scanblock(uintptr(unsafe.Pointer(&d)), sys.PtrSize, &oneptrmask[0], gcw, &state)
mgcmark.go#L778: state.putPtr(uintptr(unsafe.Pointer(gp._panic)), false)
mgcmark.go#L824: gcdata = (*byte)(unsafe.Pointer(s.startAddr))
mgcmark.go#L855: putempty((*workbuf)(unsafe.Pointer(x)))
mgcmark.go#L1184: p := *(*uintptr)(unsafe.Pointer(b + i))
mgcmark.go#L1272: obj := *(*uintptr)(unsafe.Pointer(b + i))
mgcmark.go#L1316: val := *(*uintptr)(unsafe.Pointer(p))
mgcmark.go#L1356: val := *(*uintptr)(unsafe.Pointer(b + i))
mgcmark.go#L1496: print(" *(", label, "+", i, ") = ", hex(*(*uintptr)(unsafe.Pointer(obj + i))))
mgcscavenge.go#L656: l2 := (*[1 << pallocChunksL2Bits]pallocData)(atomic.Loadp(unsafe.Pointer(&p.chunks[i.l1()])))
mgcscavenge.go#L728: sysUnused(unsafe.Pointer(addr), uintptr(npages)*pageSize)
mgcstack.go#L165: *(*uintptr)(unsafe.Pointer(&obj.typ)) = uintptr(unsafe.Pointer(typ))
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#L389: freespecial(y, unsafe.Pointer(p), size)
mgcsweep.go#L416: tracefree(unsafe.Pointer(x), size)
mgcsweep.go#L419: clobberfree(unsafe.Pointer(x), size)
mgcsweep.go#L422: racefree(unsafe.Pointer(x), size)
mgcsweep.go#L425: msanfree(unsafe.Pointer(x), size)
mgcsweep.go#L549: sysFault(unsafe.Pointer(s.base()), size)
mgcsweep.go#L668: func clobberfree(x unsafe.Pointer, size uintptr) {
mgcwork.go#L387: newb := (*workbuf)(unsafe.Pointer(s.base() + i))
mgcwork.go#L436: memmove(unsafe.Pointer(&b1.obj[0]), unsafe.Pointer(&b.obj[b.nobj]), uintptr(n)*unsafe.Sizeof(b1.obj[0]))
mheap.go#L494: func recordspan(vh unsafe.Pointer, p unsafe.Pointer) {
mheap.go#L506: sp := (*slice)(unsafe.Pointer(&new))
mheap.go#L517: *(*notInHeapSlice)(unsafe.Pointer(&h.allspans)) = *(*notInHeapSlice)(unsafe.Pointer(&new))
mheap.go#L519: sysFree(unsafe.Pointer(&oldAllspans[0]), uintptr(cap(oldAllspans))*unsafe.Sizeof(oldAllspans[0]), &memstats.other_sys)
mheap.go#L705: h.spanalloc.init(unsafe.Sizeof(mspan{}), recordspan, unsafe.Pointer(h), &memstats.mspan_sys)
mheap.go#L915: memclrNoHeapPointers(unsafe.Pointer(s.base()), s.npages<<_PageShift)
mheap.go#L1104: h.spanalloc.free(unsafe.Pointer(s))
mheap.go#L1271: sysUsed(unsafe.Pointer(base), nbytes)
mheap.go#L1413: base := unsafe.Pointer(s.base())
mheap.go#L1678: func addspecial(p unsafe.Pointer, s *special) bool {
mheap.go#L1727: func removespecial(p unsafe.Pointer, kind uint8) *special {
mheap.go#L1781: func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool {
mheap.go#L1804: scanblock(uintptr(unsafe.Pointer(&s.fn)), sys.PtrSize, &oneptrmask[0], gcw, nil)
mheap.go#L1812: mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
mheap.go#L1818: func removefinalizer(p unsafe.Pointer) {
mheap.go#L1819: s := (*specialfinalizer)(unsafe.Pointer(removespecial(p, _KindSpecialFinalizer)))
mheap.go#L1824: mheap_.specialfinalizeralloc.free(unsafe.Pointer(s))
mheap.go#L1837: func setprofilebucket(p unsafe.Pointer, b *bucket) {
mheap.go#L1850: func freespecial(s *special, p unsafe.Pointer, size uintptr) {
mheap.go#L1853: sf := (*specialfinalizer)(unsafe.Pointer(s))
mheap.go#L1856: mheap_.specialfinalizeralloc.free(unsafe.Pointer(sf))
mheap.go#L1859: sp := (*specialprofile)(unsafe.Pointer(s))
mheap.go#L1862: mheap_.specialprofilealloc.free(unsafe.Pointer(sp))
mheap.go#L1933: head := (*gcBitsArena)(atomic.Loadp(unsafe.Pointer(&gcBitsArenas.next)))
mheap.go#L1972: atomic.StorepNoWB(unsafe.Pointer(&gcBitsArenas.next), unsafe.Pointer(fresh))
mheap.go#L2018: atomic.StorepNoWB(unsafe.Pointer(&gcBitsArenas.next), nil) // newMarkBits calls newArena when needed
mheap.go#L2036: memclrNoHeapPointers(unsafe.Pointer(result), gcBitsChunkBytes)
mheap.go#L2044: result.free = 8 - (uintptr(unsafe.Pointer(&result.bits[0])) & 7)
mpagealloc.go#L398: atomic.StorepNoWB(unsafe.Pointer(&p.chunks[c.l1()]), r)
mpagealloc_64bit.go#L85: p.summary[l] = *(*[]pallocSum)(unsafe.Pointer(&sl))
mpagealloc_64bit.go#L119: base := unsafe.Pointer(&p.summary[level][0])
mpagealloc_64bit.go#L177: sysMap(unsafe.Pointer(need.base.addr()), need.size(), p.sysStat)
mpagealloc_64bit.go#L178: sysUsed(unsafe.Pointer(need.base.addr()), need.size())
mprof.go#L182: stk := (*[maxStack]uintptr)(add(unsafe.Pointer(b), unsafe.Sizeof(*b)))
mprof.go#L191: data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
mprof.go#L200: data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
mprof.go#L340: func mProf_Malloc(p unsafe.Pointer, size uintptr) {
mprof.go#L599: racewriterangepc(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0), getcallerpc(), funcPC(MemProfile))
mprof.go#L602: msanwrite(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0))
mprof.go#L647: racewriterangepc(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0), getcallerpc(), funcPC(BlockProfile))
mprof.go#L650: msanwrite(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0))
mprof.go#L699: first := (*m)(atomic.Loadp(unsafe.Pointer(&allm)))
mprof.go#L715: func runtime_goroutineProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L720: func goroutineProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
mprof.go#L841: func tracealloc(p unsafe.Pointer, size uintptr, typ *_type) {
mprof.go#L866: 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#L308: atomic.StorepNoWB(noescape(unsafe.Pointer(&wg)), nil) // full memory barrier between stores to rd/wd and load of rg/wg in netpollunblock
netpoll.go#L335: atomic.StorepNoWB(noescape(unsafe.Pointer(&rg)), nil) // full memory barrier between store to closing and read of rg/wg in netpollunblock
netpoll.go#L395: func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
netpoll.go#L396: r := atomic.Casuintptr((*uintptr)(gpp), pdWait, uintptr(unsafe.Pointer(gp)))
netpoll.go#L438: gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceEvGoBlockNet, 5)
netpoll.go#L472: return (*g)(unsafe.Pointer(old))
netpoll.go#L496: atomic.StorepNoWB(unsafe.Pointer(&pd.rt.f), nil) // full memory barrier between store to rd and load of rg in netpollunblock
netpoll.go#L505: atomic.StorepNoWB(unsafe.Pointer(&pd.wt.f), nil) // full memory barrier between store to wd and load of wg in netpollunblock
netpoll.go#L559: x := (*eface)(unsafe.Pointer(&i))
netpoll.go#L561: x.data = unsafe.Pointer(&pd.self)
netpoll_kqueue.go#L40: *(*uintptr)(unsafe.Pointer(&ev.ident)) = uintptr(r)
netpoll_kqueue.go#L59: *(*uintptr)(unsafe.Pointer(&ev[0].ident)) = fd
netpoll_kqueue.go#L64: ev[0].udata = (*byte)(unsafe.Pointer(pd))
netpoll_kqueue.go#L89: n := write(netpollBreakWr, unsafe.Pointer(&b), 1)
netpoll_kqueue.go#L154: read(int32(netpollBreakRd), noescape(unsafe.Pointer(&tmp[0])), int32(len(tmp)))
netpoll_kqueue.go#L181: pd := (*pollDesc)(unsafe.Pointer(ev.udata))
os_darwin.go#L18: *(*int)(unsafe.Pointer(uintptr(1231))) = 1231
os_darwin.go#L113: write(uintptr(sigNoteWrite), unsafe.Pointer(&b), 1)
os_darwin.go#L120: read(sigNoteRead, unsafe.Pointer(&b), 1)
os_darwin.go#L136: ret := sysctlbyname(&name[0], (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
os_darwin.go#L156: ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
os_darwin.go#L168: ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
os_darwin.go#L180: n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
os_darwin.go#L192: stk := unsafe.Pointer(mp.g0.stack.hi)
os_darwin.go#L202: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_darwin.go#L209: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_darwin.go#L216: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_darwin.go#L224: err = pthread_create(&attr, funcPC(mstart_stub), unsafe.Pointer(mp))
os_darwin.go#L227: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_darwin.go#L247: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_darwin.go#L257: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_darwin.go#L265: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_darwin.go#L276: write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
os_darwin.go#L302: mlock(unsafe.Pointer(mp.gsignal.stack.hi-physPageSize), physPageSize)
os_darwin.go#L366: *(*uintptr)(unsafe.Pointer(&sa.__sigaction_u)) = fn
os_darwin.go#L380: handler := *(*uintptr)(unsafe.Pointer(&osa.__sigaction_u))
os_darwin.go#L385: *(*uintptr)(unsafe.Pointer(&sa.__sigaction_u)) = handler
os_darwin.go#L396: return *(*uintptr)(unsafe.Pointer(&sa.__sigaction_u))
os_darwin.go#L402: *(*uintptr)(unsafe.Pointer(&s.ss_sp)) = sp
panic.go#L236: argp := uintptr(unsafe.Pointer(&fn)) + unsafe.Sizeof(fn)
panic.go#L252: *(*uintptr)(deferArgs(d)) = *(*uintptr)(unsafe.Pointer(argp))
panic.go#L254: memmove(deferArgs(d), unsafe.Pointer(argp), uintptr(siz))
panic.go#L303: *(*uintptr)(unsafe.Pointer(&d._panic)) = 0
panic.go#L304: *(*uintptr)(unsafe.Pointer(&d.fd)) = 0
panic.go#L305: *(*uintptr)(unsafe.Pointer(&d.link)) = uintptr(unsafe.Pointer(gp._defer))
panic.go#L306: *(*uintptr)(unsafe.Pointer(&gp._defer)) = uintptr(unsafe.Pointer(d))
panic.go#L368: func deferArgs(d *_defer) unsafe.Pointer {
panic.go#L373: return add(unsafe.Pointer(d), unsafe.Sizeof(*d))
panic.go#L381: deferType = (*(**ptrtype)(unsafe.Pointer(&x))).elem
panic.go#L554: *(*uintptr)(unsafe.Pointer(&arg0)) = *(*uintptr)(deferArgs(d))
panic.go#L556: memmove(unsafe.Pointer(&arg0), deferArgs(d), uintptr(d.siz))
panic.go#L568: jmpdefer(fn, uintptr(unsafe.Pointer(&arg0)))
panic.go#L590: gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
panic.go#L592: addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))
panic.go#L611: d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
panic.go#L624: addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))
panic.go#L632: reflectcallSave(&p, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz))
panic.go#L709: func addOneOpenDeferFrame(gp *g, pc uintptr, sp unsafe.Pointer) {
panic.go#L714: sp = unsafe.Pointer(prevDefer.sp)
panic.go#L718: func(frame *stkframe, unused unsafe.Pointer) bool {
panic.go#L789: func readvarintUnsafe(fd unsafe.Pointer) (uint32, unsafe.Pointer) {
panic.go#L793: b := *(*uint8)((unsafe.Pointer(fd)))
panic.go#L818: deferBits := *(*uint8)(unsafe.Pointer(d.varp - uintptr(deferBitsOffset)))
panic.go#L834: closure := *(**funcval)(unsafe.Pointer(d.varp - uintptr(closureOffset)))
panic.go#L844: memmove(unsafe.Pointer(uintptr(deferArgs)+uintptr(argCallOffset)),
panic.go#L845: unsafe.Pointer(d.varp-uintptr(argOffset)),
panic.go#L849: *(*uint8)(unsafe.Pointer(d.varp - uintptr(deferBitsOffset))) = deferBits
panic.go#L851: reflectcallSave(p, unsafe.Pointer(closure), deferArgs, argWidth)
panic.go#L871: func reflectcallSave(p *_panic, fn, arg unsafe.Pointer, argsize uint32) {
panic.go#L873: p.argp = unsafe.Pointer(getargp(0))
panic.go#L875: p.sp = unsafe.Pointer(getcallersp())
panic.go#L880: p.sp = unsafe.Pointer(nil)
panic.go#L919: gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
panic.go#L925: addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))
panic.go#L961: d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
panic.go#L970: p.argp = unsafe.Pointer(getargp(0))
panic.go#L971: reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
panic.go#L985: sp := unsafe.Pointer(d.sp) // must be pointer so it gets adjusted during stack copy
panic.go#L1075: return uintptr(noescape(unsafe.Pointer(&x)))
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}
preempt.go#L407: if fd := funcdata(f, _FUNCDATA_LocalsPointerMaps); fd == nil || fd == unsafe.Pointer(&no_pointers_stackmap) {
print.go#L18: rp := (*slice)(unsafe.Pointer(&ret))
print.go#L237: func printpointer(p unsafe.Pointer) {
print.go#L249: sp := (*slice)(unsafe.Pointer(&s))
print.go#L300: val := *(*uintptr)(unsafe.Pointer(p + i))
proc.go#L319: func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceEv byte, traceskip int) {
proc.go#L342: gopark(parkunlock_c, unsafe.Pointer(lock), reason, traceEv, traceskip)
proc.go#L526: atomicstorep(unsafe.Pointer(&allgptr), unsafe.Pointer(&allgs[0]))
proc.go#L535: ptr := (**g)(atomic.Loadp(unsafe.Pointer(&allgptr)))
proc.go#L541: return *(**g)(add(unsafe.Pointer(ptr), i*sys.PtrSize))
proc.go#L570: s := *(*string)(unsafe.Pointer(&stringStruct{unsafe.Pointer(p), findnull(p)}))
proc.go#L755: atomicstorep(unsafe.Pointer(&allm), unsafe.Pointer(mp))
proc.go#L767: s := (*[unsafe.Sizeof(fastrandseed)]byte)(unsafe.Pointer(&fastrandseed))[:]
proc.go#L1263: _g_.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))
proc.go#L1703: var cgoThreadStart unsafe.Pointer
proc.go#L1708: fn unsafe.Pointer
proc.go#L1815: write(2, unsafe.Pointer(&earlycgocallback[0]), int32(len(earlycgocallback)))
proc.go#L1905: gp.sched.g = guintptr(unsafe.Pointer(gp))
proc.go#L1995: return uintptr(unsafe.Pointer(getg().m))
proc.go#L2030: return (*m)(unsafe.Pointer(old))
proc.go#L2039: atomic.Storeuintptr(&extram, uintptr(unsafe.Pointer(mp)))
proc.go#L2113: ts.tls = (*uint64)(unsafe.Pointer(&mp.tls[0]))
proc.go#L2114: ts.fn = unsafe.Pointer(funcPC(mstart))
proc.go#L2116: msanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
proc.go#L2119: asmcgocall(_cgo_thread_start, unsafe.Pointer(&ts))
proc.go#L2179: *(*uintptr)(unsafe.Pointer(&_g_.m.mFixup.fn)) = 0
proc.go#L3246: func parkunlock_c(gp *g, lock unsafe.Pointer) bool {
proc.go#L3452: _g_.sched.g = guintptr(unsafe.Pointer(_g_))
proc.go#L3954: *(*uintptr)(unsafe.Pointer(newg.stack.lo)) = 0
proc.go#L3975: argp := add(unsafe.Pointer(&fn), sys.PtrSize)
proc.go#L3999: func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {
proc.go#L4039: *(*uintptr)(unsafe.Pointer(sp)) = 0
proc.go#L4044: memmove(unsafe.Pointer(spArg), argp, uintptr(narg))
proc.go#L4062: memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
proc.go#L4066: newg.sched.g = guintptr(unsafe.Pointer(newg))
proc.go#L4205: racemalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L4208: msanmalloc(unsafe.Pointer(gp.stack.lo), gp.stack.hi-gp.stack.lo)
proc.go#L4734: mheap_.spanalloc.free(unsafe.Pointer(pp.mspancache.buf[i]))
proc.go#L4835: atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
proc.go#L4905: atomic.Store((*uint32)(unsafe.Pointer(int32p)), uint32(nprocs))
proc.go#L5716: runnext := atomic.Loaduintptr((*uintptr)(unsafe.Pointer(&_p_.runnext)))
proc.go#L5747: if !_p_.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
proc.go#L6240: p := add(unsafe.Pointer(t), (3+i)*sys.PtrSize)
proc.go#L6261: firstFunc := add(unsafe.Pointer(t), (3+t.ndeps)*sys.PtrSize)
proc.go#L6264: f := *(*func())(unsafe.Pointer(&p))
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)*sys.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#L205: data unsafe.Pointer
runtime2.go#L210: data unsafe.Pointer
runtime2.go#L214: return (*eface)(unsafe.Pointer(ep))
runtime2.go#L262: func (gp guintptr) ptr() *g { return (*g)(unsafe.Pointer(gp)) }
runtime2.go#L265: func (gp *guintptr) set(g *g) { *gp = guintptr(unsafe.Pointer(g)) }
runtime2.go#L269: return atomic.Casuintptr((*uintptr)(unsafe.Pointer(gp)), uintptr(old), uintptr(new))
runtime2.go#L277: (*guintptr)(unsafe.Pointer(gp)).set(new)
runtime2.go#L283: func (pp puintptr) ptr() *p { return (*p)(unsafe.Pointer(pp)) }
runtime2.go#L286: func (pp *puintptr) set(p *p) { *pp = puintptr(unsafe.Pointer(p)) }
runtime2.go#L300: func (mp muintptr) ptr() *m { return (*m)(unsafe.Pointer(mp)) }
runtime2.go#L303: func (mp *muintptr) set(m *m) { *mp = muintptr(unsafe.Pointer(m)) }
runtime2.go#L310: (*muintptr)(unsafe.Pointer(mp)).set(new)
runtime2.go#L329: ctxt unsafe.Pointer
runtime2.go#L354: elem unsafe.Pointer // data element (may point to stack)
runtime2.go#L423: param unsafe.Pointer // passed parameter on wakeup
runtime2.go#L470: labels unsafe.Pointer // profiler labels
runtime2.go#L532: waitunlockf func(*g, unsafe.Pointer) bool
runtime2.go#L533: waitlock unsafe.Pointer
runtime2.go#L890: h := memhash(unsafe.Pointer(&r[n-w]), uintptr(nanotime()), uintptr(w))
runtime2.go#L925: fd unsafe.Pointer // funcdata for the function associated with the frame
runtime2.go#L943: argp unsafe.Pointer // pointer to arguments of deferred call run during panic; cannot move - known to liblink
runtime2.go#L947: sp unsafe.Pointer // where to return to in runtime if this panic is bypassed
select.go#L21: elem unsafe.Pointer // data element
select.go#L62: func selparkcommit(gp *g, _ unsafe.Pointer) bool {
select.go#L128: cas1 := (*[1 << 16]scase)(unsafe.Pointer(cas0))
select.go#L129: order1 := (*[1 << 17]uint16)(unsafe.Pointer(order0))
select.go#L142: pc1 := (*[1 << 16]uintptr)(unsafe.Pointer(pc0))
select.go#L239: qp unsafe.Pointer
select.go#L503: return uintptr(unsafe.Pointer(c))
select.go#L510: typ unsafe.Pointer // channel type (not used here)
select.go#L512: 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#L53: pc := (*[4]byte)(unsafe.Pointer(gp.sigpc))
signal_amd64.go#L68: if shouldPushSigpanic(gp, pc, *(*uintptr)(unsafe.Pointer(sp))) {
signal_amd64.go#L80: *(*uintptr)(unsafe.Pointer(sp)) = resumePC
signal_darwin_amd64.go#L11: ctxt unsafe.Pointer
signal_darwin_amd64.go#L66: code := (*[2]byte)(unsafe.Pointer(pc - 2))
signal_unix.go#L395: gp := *(**g)(unsafe.Pointer(s.base()))
signal_unix.go#L415: func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
signal_unix.go#L473: sp := uintptr(unsafe.Pointer(&sig))
signal_unix.go#L480: stsp := uintptr(unsafe.Pointer(st.ss_sp))
signal_unix.go#L536: func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
signal_unix.go#L545: if sig == _SIGTRAP && testSigtrap != nil && testSigtrap(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp) {
signal_unix.go#L651: b := (*[maxN]byte)(unsafe.Pointer(pc))
signal_unix.go#L945: *(*uintptr)(unsafe.Pointer(uintptr(123))) = 2
signal_unix.go#L957: func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)
signal_unix.go#L965: func sigfwdgo(sig uint32, info *siginfo, ctx unsafe.Pointer) bool {
signal_unix.go#L1193: stsp := uintptr(unsafe.Pointer(st.ss_sp))
slice.go#L14: array unsafe.Pointer
slice.go#L36: func makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer {
slice.go#L53: var to unsafe.Pointer
slice.go#L83: func makeslice(et *_type, len, cap int) unsafe.Pointer {
slice.go#L101: func makeslice64(et *_type, len64, cap64 int64) unsafe.Pointer {
slice.go#L141: return slice{unsafe.Pointer(&zerobase), old.len, cap}
slice.go#L222: var p unsafe.Pointer
slice.go#L247: func slicecopy(toPtr unsafe.Pointer, toLen int, fromPtr unsafe.Pointer, fromLen int, width uintptr) int {
stack.go#L354: var v unsafe.Pointer
stack.go#L381: v = unsafe.Pointer(x)
stack.go#L406: v = unsafe.Pointer(s.base())
stack.go#L429: v := unsafe.Pointer(stk.lo)
stack.go#L546: func adjustpointer(adjinfo *adjustinfo, vpp unsafe.Pointer) {
stack.go#L578: func adjustpointers(scanp unsafe.Pointer, bv *bitvector, adjinfo *adjustinfo, f funcInfo) {
stack.go#L614: ppu := (*unsafe.Pointer)(unsafe.Pointer(pp))
stack.go#L615: if !atomic.Casp1(ppu, unsafe.Pointer(p), unsafe.Pointer(p+delta)) {
stack.go#L627: func adjustframe(frame *stkframe, arg unsafe.Pointer) bool {
stack.go#L649: adjustpointers(unsafe.Pointer(frame.varp-size), &locals, adjinfo, f)
stack.go#L661: bp := *(*uintptr)(unsafe.Pointer(frame.varp))
stack.go#L668: adjustpointer(adjinfo, unsafe.Pointer(frame.varp))
stack.go#L676: adjustpointers(unsafe.Pointer(frame.argp), &args, adjinfo, funcInfo{})
stack.go#L701: gcdata = (*byte)(unsafe.Pointer(s.startAddr))
stack.go#L705: adjustpointer(adjinfo, unsafe.Pointer(p+i))
stack.go#L718: adjustpointer(adjinfo, unsafe.Pointer(&gp.sched.ctxt))
stack.go#L730: adjustpointer(adjinfo, unsafe.Pointer(&gp.sched.bp))
stack.go#L737: adjustpointer(adjinfo, unsafe.Pointer(&gp._defer))
stack.go#L739: adjustpointer(adjinfo, unsafe.Pointer(&d.fn))
stack.go#L740: adjustpointer(adjinfo, unsafe.Pointer(&d.sp))
stack.go#L741: adjustpointer(adjinfo, unsafe.Pointer(&d._panic))
stack.go#L742: adjustpointer(adjinfo, unsafe.Pointer(&d.link))
stack.go#L743: adjustpointer(adjinfo, unsafe.Pointer(&d.varp))
stack.go#L744: adjustpointer(adjinfo, unsafe.Pointer(&d.fd))
stack.go#L750: tracebackdefers(gp, adjustframe, noescape(unsafe.Pointer(adjinfo)))
stack.go#L756: adjustpointer(adjinfo, unsafe.Pointer(&gp._panic))
stack.go#L763: adjustpointer(adjinfo, unsafe.Pointer(&s.elem))
stack.go#L769: *(*byte)(unsafe.Pointer(p)) = b
stack.go#L821: memmove(unsafe.Pointer(newBot), unsafe.Pointer(oldBot), sgsize)
stack.go#L889: memmove(unsafe.Pointer(new.hi-ncopy), unsafe.Pointer(old.hi-ncopy), ncopy)
stack.go#L908: gentraceback(^uintptr(0), ^uintptr(0), 0, gp, 0, nil, 0x7fffffff, adjustframe, noescape(unsafe.Pointer(&adjinfo)), 0)
stack.go#L1094: var fn unsafe.Pointer
stack.go#L1096: fn = unsafe.Pointer(fv.fn)
stack.go#L1098: fn = unsafe.Pointer(funcPC(nilfunc))
stack.go#L1100: gostartcall(gobuf, fn, unsafe.Pointer(fv))
stack.go#L1308: *(*slice)(unsafe.Pointer(&objs)) = slice{array: noescape(p), len: int(n), cap: int(n)}
string.go#L88: racereadrangepc(unsafe.Pointer(ptr),
string.go#L94: msanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L97: p := unsafe.Pointer(&staticuint64s[*ptr])
string.go#L106: var p unsafe.Pointer
string.go#L108: p = unsafe.Pointer(buf)
string.go#L114: memmove(p, unsafe.Pointer(ptr), uintptr(n))
string.go#L152: racereadrangepc(unsafe.Pointer(ptr),
string.go#L158: msanread(unsafe.Pointer(ptr), uintptr(n))
string.go#L160: stringStructOf(&str).str = unsafe.Pointer(ptr)
string.go#L203: racereadrangepc(unsafe.Pointer(&a[0]),
string.go#L209: msanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
string.go#L229: str unsafe.Pointer
string.go#L240: return (*stringStruct)(unsafe.Pointer(sp))
string.go#L268: *(*slice)(unsafe.Pointer(&b)) = slice{p, size, size}
string.go#L281: *(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(cap)}
string.go#L296: *(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(mem / 4)}
string.go#L311: memmove(bp, unsafe.Pointer(p), uintptr(n))
string.go#L313: *(*slice)(unsafe.Pointer(&b)) = slice{bp, n, n}
string.go#L325: memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l))
string.go#L334: memmove(unsafe.Pointer(&b[0]), unsafe.Pointer(p), uintptr(l))
string.go#L414: p := (*[maxAlloc/2 - 1]byte)(unsafe.Pointer(s))
string.go#L429: ptr := unsafe.Pointer(s)
string.go#L436: t := *(*string)(unsafe.Pointer(&stringStruct{ptr, safeLen}))
string.go#L442: ptr = unsafe.Pointer(uintptr(ptr) + uintptr(safeLen))
string.go#L452: p := (*[maxAlloc/2/2 - 1]uint16)(unsafe.Pointer(s))
string.go#L462: ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
string.go#L463: s := *(*string)(unsafe.Pointer(&ss))
string.go#L469: str := (*[maxAlloc/2/2 - 1]uint16)(unsafe.Pointer(strw))
stubs.go#L11: func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
stubs.go#L12: return unsafe.Pointer(uintptr(p) + x)
stubs.go#L86: func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
stubs.go#L89: func reflect_memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr) {
stubs.go#L106: func memmove(to, from unsafe.Pointer, n uintptr)
stubs.go#L109: func reflect_memmove(to, from unsafe.Pointer, n uintptr) {
stubs.go#L149: func memequal(a, b unsafe.Pointer, size uintptr) bool
stubs.go#L157: func noescape(p unsafe.Pointer) unsafe.Pointer {
stubs.go#L159: return unsafe.Pointer(x ^ 0)
stubs.go#L190: func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)
stubs.go#L272: func asmcgocall(fn, arg unsafe.Pointer) int32
stubs.go#L287: func call16(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L288: func call32(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L289: func call64(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L290: func call128(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L291: func call256(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L292: func call512(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L293: func call1024(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L294: func call2048(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L295: func call4096(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L296: func call8192(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L297: func call16384(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L298: func call32768(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L299: func call65536(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L300: func call131072(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L301: func call262144(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L302: func call524288(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L303: func call1048576(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L304: func call2097152(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L305: func call4194304(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L306: func call8388608(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L307: func call16777216(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L308: func call33554432(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L309: func call67108864(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L310: func call134217728(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L311: func call268435456(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L312: func call536870912(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L313: func call1073741824(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
stubs.go#L337: func memequal_varlen(a, b unsafe.Pointer) bool
stubs.go#L343: return int(uint8(*(*uint8)(unsafe.Pointer(&x))))
symtab.go#L261: return (*_func)(unsafe.Pointer(f))
symtab.go#L440: p := (*[]*moduledata)(atomic.Loadp(unsafe.Pointer(&modulesSlice)))
symtab.go#L473: md.gcdatamask = progToPointerMask((*byte)(unsafe.Pointer(md.gcdata)), md.edata-md.data)
symtab.go#L474: md.gcbssmask = progToPointerMask((*byte)(unsafe.Pointer(md.gcbss)), md.ebss-md.bss)
symtab.go#L495: atomicstorep(unsafe.Pointer(&modulesSlice), unsafe.Pointer(modules))
symtab.go#L548: f1 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i].funcoff])), datap}
symtab.go#L549: f2 := funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[i+1].funcoff])), datap}
symtab.go#L556: print("\t", hex(datap.ftab[j].entry), " ", funcname(funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[datap.ftab[j].funcoff])), datap}), "\n")
symtab.go#L604: return (*Func)(unsafe.Pointer(fi))
symtab.go#L617: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L627: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L640: fi := (*funcinl)(unsafe.Pointer(fn))
symtab.go#L668: return (*Func)(unsafe.Pointer(f._func))
symtab.go#L682: ffb := (*findfuncbucket)(add(unsafe.Pointer(datap.findfunctab), b*unsafe.Sizeof(findfuncbucket{})))
symtab.go#L716: return funcInfo{(*_func)(unsafe.Pointer(&datap.pclntable[funcoff])), datap}
symtab.go#L931: return *(*uint32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4))
symtab.go#L959: func funcdata(f funcInfo, i uint8) unsafe.Pointer {
symtab.go#L963: p := add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(f.npcdata)*4)
symtab.go#L965: if uintptr(unsafe.Pointer(f._func))&4 != 0 {
symtab.go#L970: return *(*unsafe.Pointer)(add(p, uintptr(i)*sys.PtrSize))
sys_darwin.go#L20: libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn))
sys_darwin.go#L31: libcCall(unsafe.Pointer(funcPC(syscallX)), unsafe.Pointer(&fn))
sys_darwin.go#L42: libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn))
sys_darwin.go#L53: libcCall(unsafe.Pointer(funcPC(syscall6X)), unsafe.Pointer(&fn))
sys_darwin.go#L64: libcCall(unsafe.Pointer(funcPC(syscallPtr)), unsafe.Pointer(&fn))
sys_darwin.go#L74: libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn))
sys_darwin.go#L82: libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn))
sys_darwin.go#L93: libcCall(unsafe.Pointer(funcPC(syscallNoErr)), unsafe.Pointer(&fn))
sys_darwin.go#L105: return libcCall(unsafe.Pointer(funcPC(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
sys_darwin.go#L112: return libcCall(unsafe.Pointer(funcPC(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
sys_darwin.go#L119: return libcCall(unsafe.Pointer(funcPC(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
sys_darwin.go#L125: func pthread_create(attr *pthreadattr, start uintptr, arg unsafe.Pointer) int32 {
sys_darwin.go#L126: return libcCall(unsafe.Pointer(funcPC(pthread_create_trampoline)), unsafe.Pointer(&attr))
sys_darwin.go#L133: libcCall(unsafe.Pointer(funcPC(raise_trampoline)), unsafe.Pointer(&sig))
sys_darwin.go#L140: libcCall(unsafe.Pointer(funcPC(pthread_self_trampoline)), unsafe.Pointer(&t))
sys_darwin.go#L148: libcCall(unsafe.Pointer(funcPC(pthread_kill_trampoline)), unsafe.Pointer(&t))
sys_darwin.go#L157: func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) {
sys_darwin.go#L159: addr unsafe.Pointer
sys_darwin.go#L163: ret1 unsafe.Pointer
sys_darwin.go#L166: libcCall(unsafe.Pointer(funcPC(mmap_trampoline)), unsafe.Pointer(&args))
sys_darwin.go#L173: func munmap(addr unsafe.Pointer, n uintptr) {
sys_darwin.go#L174: libcCall(unsafe.Pointer(funcPC(munmap_trampoline)), unsafe.Pointer(&addr))
sys_darwin.go#L180: func madvise(addr unsafe.Pointer, n uintptr, flags int32) {
sys_darwin.go#L181: libcCall(unsafe.Pointer(funcPC(madvise_trampoline)), unsafe.Pointer(&addr))
sys_darwin.go#L187: func mlock(addr unsafe.Pointer, n uintptr) {
sys_darwin.go#L188: libcCall(unsafe.Pointer(funcPC(mlock_trampoline)), unsafe.Pointer(&addr))
sys_darwin.go#L194: func read(fd int32, p unsafe.Pointer, n int32) int32 {
sys_darwin.go#L195: return libcCall(unsafe.Pointer(funcPC(read_trampoline)), unsafe.Pointer(&fd))
sys_darwin.go#L201: errno = libcCall(unsafe.Pointer(funcPC(pipe_trampoline)), noescape(unsafe.Pointer(&p)))
sys_darwin.go#L209: return libcCall(unsafe.Pointer(funcPC(close_trampoline)), unsafe.Pointer(&fd))
sys_darwin.go#L219: libcCall(unsafe.Pointer(funcPC(exit_trampoline)), unsafe.Pointer(&code))
sys_darwin.go#L226: libcCall(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
sys_darwin.go#L232: func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
sys_darwin.go#L233: return libcCall(unsafe.Pointer(funcPC(write_trampoline)), unsafe.Pointer(&fd))
sys_darwin.go#L240: return libcCall(unsafe.Pointer(funcPC(open_trampoline)), unsafe.Pointer(&name))
sys_darwin.go#L251: libcCall(unsafe.Pointer(funcPC(nanotime_trampoline)), unsafe.Pointer(&r))
sys_darwin.go#L270: libcCall(unsafe.Pointer(funcPC(walltime_trampoline)), unsafe.Pointer(&t))
sys_darwin.go#L278: libcCall(unsafe.Pointer(funcPC(sigaction_trampoline)), unsafe.Pointer(&sig))
sys_darwin.go#L285: libcCall(unsafe.Pointer(funcPC(sigprocmask_trampoline)), unsafe.Pointer(&how))
sys_darwin.go#L299: libcCall(unsafe.Pointer(funcPC(sigaltstack_trampoline)), unsafe.Pointer(&new))
sys_darwin.go#L306: libcCall(unsafe.Pointer(funcPC(raiseproc_trampoline)), unsafe.Pointer(&sig))
sys_darwin.go#L313: libcCall(unsafe.Pointer(funcPC(setitimer_trampoline)), unsafe.Pointer(&mode))
sys_darwin.go#L320: return libcCall(unsafe.Pointer(funcPC(sysctl_trampoline)), unsafe.Pointer(&mib))
sys_darwin.go#L327: return libcCall(unsafe.Pointer(funcPC(sysctlbyname_trampoline)), unsafe.Pointer(&name))
sys_darwin.go#L334: return libcCall(unsafe.Pointer(funcPC(fcntl_trampoline)), unsafe.Pointer(&fd))
sys_darwin.go#L341: v := libcCall(unsafe.Pointer(funcPC(kqueue_trampoline)), nil)
sys_darwin.go#L349: return libcCall(unsafe.Pointer(funcPC(kevent_trampoline)), unsafe.Pointer(&kq))
sys_darwin.go#L356: return libcCall(unsafe.Pointer(funcPC(pthread_mutex_init_trampoline)), unsafe.Pointer(&m))
sys_darwin.go#L363: return libcCall(unsafe.Pointer(funcPC(pthread_mutex_lock_trampoline)), unsafe.Pointer(&m))
sys_darwin.go#L370: return libcCall(unsafe.Pointer(funcPC(pthread_mutex_unlock_trampoline)), unsafe.Pointer(&m))
sys_darwin.go#L377: return libcCall(unsafe.Pointer(funcPC(pthread_cond_init_trampoline)), unsafe.Pointer(&c))
sys_darwin.go#L384: return libcCall(unsafe.Pointer(funcPC(pthread_cond_wait_trampoline)), unsafe.Pointer(&c))
sys_darwin.go#L391: return libcCall(unsafe.Pointer(funcPC(pthread_cond_timedwait_relative_np_trampoline)), unsafe.Pointer(&c))
sys_darwin.go#L398: return libcCall(unsafe.Pointer(funcPC(pthread_cond_signal_trampoline)), unsafe.Pointer(&c))
sys_libc.go#L16: func libcCall(fn, arg unsafe.Pointer) int32 {
sys_x86.go#L16: func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
sys_x86.go#L20: *(*uintptr)(unsafe.Pointer(sp)) = 0
sys_x86.go#L23: *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
time.go#L193: gopark(resetForSleep, unsafe.Pointer(t), waitReasonSleep, traceEvGoSleep, 1)
time.go#L200: func resetForSleep(gp *g, ut unsafe.Pointer) bool {
time.go#L210: racerelease(unsafe.Pointer(t))
time.go#L227: racerelease(unsafe.Pointer(t))
time.go#L861: raceacquirectx(ppcur.timerRaceCtx, unsafe.Pointer(t))
time_nofake.go#L29: func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
trace.go#L172: func (tp traceBufPtr) ptr() *traceBuf { return (*traceBuf)(unsafe.Pointer(tp)) }
trace.go#L173: func (tp *traceBufPtr) set(b *traceBuf) { *tp = traceBufPtr(unsafe.Pointer(b)) }
trace.go#L175: return traceBufPtr(unsafe.Pointer(b))
trace.go#L342: raceacquire(unsafe.Pointer(&trace.shutdownSema))
trace.go#L364: sysFree(unsafe.Pointer(buf), unsafe.Sizeof(*buf.ptr()), &memstats.other_sys)
trace.go#L445: racerelease(unsafe.Pointer(&trace.shutdownSema))
trace.go#L675: raceacquire(unsafe.Pointer(&trace.stringsLock))
trace.go#L680: racerelease(unsafe.Pointer(&trace.stringsLock))
trace.go#L692: racerelease(unsafe.Pointer(&trace.stringsLock))
trace.go#L771: func (tp traceStackPtr) ptr() *traceStack { return (*traceStack)(unsafe.Pointer(tp)) }
trace.go#L775: return (*[traceStackSize]uintptr)(unsafe.Pointer(&ts.stk))[:ts.n]
trace.go#L784: hash := memhash(unsafe.Pointer(&pcs[0]), 0, uintptr(len(pcs))*unsafe.Sizeof(pcs[0]))
trace.go#L807: atomicstorep(unsafe.Pointer(&tab.tab[part]), unsafe.Pointer(stk))
trace.go#L937: func (p traceAllocBlockPtr) ptr() *traceAllocBlock { return (*traceAllocBlock)(unsafe.Pointer(p)) }
trace.go#L938: func (p *traceAllocBlockPtr) set(x *traceAllocBlock) { *p = traceAllocBlockPtr(unsafe.Pointer(x)) }
trace.go#L941: func (a *traceAlloc) alloc(n uintptr) unsafe.Pointer {
trace.go#L957: return unsafe.Pointer(p)
trace.go#L965: sysFree(unsafe.Pointer(block), unsafe.Sizeof(traceAllocBlock{}), &memstats.other_sys)
traceback.go#L41: func tracebackdefers(gp *g, callback func(*stkframe, unsafe.Pointer) bool, v unsafe.Pointer) {
traceback.go#L68: if !callback((*stkframe)(noescape(unsafe.Pointer(&frame))), v) {
traceback.go#L86: 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#L144: frame.pc = *(*uintptr)(unsafe.Pointer(frame.sp))
traceback.go#L147: frame.pc = uintptr(*(*sys.Uintreg)(unsafe.Pointer(frame.sp)))
traceback.go#L234: frame.lr = *(*uintptr)(unsafe.Pointer(lrPtr))
traceback.go#L239: frame.lr = uintptr(*(*sys.Uintreg)(unsafe.Pointer(lrPtr)))
traceback.go#L322: if !callback((*stkframe)(noescape(unsafe.Pointer(&frame))), v) {
traceback.go#L361: (*[1 << 20]uintptr)(unsafe.Pointer(pcbuf))[n] = pc
traceback.go#L376: (*[1 << 20]uintptr)(unsafe.Pointer(pcbuf))[n] = pc
traceback.go#L435: argp := (*[100]uintptr)(unsafe.Pointer(frame.argp))
traceback.go#L492: x := *(*uintptr)(unsafe.Pointer(frame.sp))
traceback.go#L600: mv = (*reflectMethodValue)(unsafe.Pointer(ctxt))
traceback.go#L608: mv = *(**reflectMethodValue)(unsafe.Pointer(arg0))
traceback.go#L612: retValid = *(*bool)(unsafe.Pointer(arg0 + 3*sys.PtrSize))
traceback.go#L642: (*[1 << 20]uintptr)(unsafe.Pointer(pcbuf))[n] = pc
traceback.go#L1210: func SetCgoTraceback(version int, traceback, context, symbolizer unsafe.Pointer) {
traceback.go#L1232: var cgoTraceback unsafe.Pointer
traceback.go#L1233: var cgoContext unsafe.Pointer
traceback.go#L1234: var cgoSymbolizer unsafe.Pointer
traceback.go#L1321: msanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
traceback.go#L1323: call(cgoSymbolizer, noescape(unsafe.Pointer(arg)))
traceback.go#L1339: buf: (*uintptr)(noescape(unsafe.Pointer(&buf[0]))),
traceback.go#L1343: msanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
traceback.go#L1345: call(cgoTraceback, noescape(unsafe.Pointer(&arg)))
type.go#L41: equal func(unsafe.Pointer, unsafe.Pointer) bool
type.go#L68: return &(*u)(unsafe.Pointer(t)).u
type.go#L74: return &(*u)(unsafe.Pointer(t)).u
type.go#L80: return &(*u)(unsafe.Pointer(t)).u
type.go#L86: return &(*u)(unsafe.Pointer(t)).u
type.go#L92: return &(*u)(unsafe.Pointer(t)).u
type.go#L98: return &(*u)(unsafe.Pointer(t)).u
type.go#L104: return &(*u)(unsafe.Pointer(t)).u
type.go#L110: return &(*u)(unsafe.Pointer(t)).u
type.go#L116: return &(*u)(unsafe.Pointer(t)).u
type.go#L142: st := (*structtype)(unsafe.Pointer(t))
type.go#L145: it := (*interfacetype)(unsafe.Pointer(t))
type.go#L167: m map[int32]unsafe.Pointer
type.go#L168: minv map[unsafe.Pointer]int32
type.go#L174: raceacquire(unsafe.Pointer(&reflectOffs.lock))
type.go#L180: racerelease(unsafe.Pointer(&reflectOffs.lock))
type.go#L185: func resolveNameOff(ptrInModule unsafe.Pointer, off nameOff) name {
type.go#L197: return name{(*byte)(unsafe.Pointer(res))}
type.go#L216: return resolveNameOff(unsafe.Pointer(t), off)
type.go#L219: func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {
type.go#L254: return (*_type)(unsafe.Pointer(res))
type.go#L258: return resolveTypeOff(unsafe.Pointer(t), off)
type.go#L261: func (t *_type) textOff(off textOff) unsafe.Pointer {
type.go#L265: return unsafe.Pointer(^uintptr(0))
type.go#L267: base := uintptr(unsafe.Pointer(t))
type.go#L316: return unsafe.Pointer(res)
type.go#L325: return (*[1 << 20]*_type)(add(unsafe.Pointer(t), uadd))[:t.inCount]
type.go#L335: return (*[1 << 20]*_type)(add(unsafe.Pointer(t), uadd))[t.inCount : t.inCount+outCount]
type.go#L378: hasher func(unsafe.Pointer, uintptr) uintptr
type.go#L455: return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off)))
type.go#L482: hdr := (*stringStruct)(unsafe.Pointer(&s))
type.go#L483: hdr.str = unsafe.Pointer(n.data(3))
type.go#L494: hdr := (*stringStruct)(unsafe.Pointer(&s))
type.go#L495: hdr.str = unsafe.Pointer(n.data(3 + nl + 2))
type.go#L509: copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off)))[:])
type.go#L510: pkgPathName := resolveNameOff(unsafe.Pointer(n.bytes), nameOff)
type.go#L540: t = (*_type)(unsafe.Pointer(prev.types + uintptr(tl)))
type.go#L562: t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
type.go#L635: at := (*arraytype)(unsafe.Pointer(t))
type.go#L636: av := (*arraytype)(unsafe.Pointer(v))
type.go#L639: ct := (*chantype)(unsafe.Pointer(t))
type.go#L640: cv := (*chantype)(unsafe.Pointer(v))
type.go#L643: ft := (*functype)(unsafe.Pointer(t))
type.go#L644: fv := (*functype)(unsafe.Pointer(v))
type.go#L662: it := (*interfacetype)(unsafe.Pointer(t))
type.go#L663: iv := (*interfacetype)(unsafe.Pointer(v))
type.go#L675: tname := resolveNameOff(unsafe.Pointer(tm), tm.name)
type.go#L676: vname := resolveNameOff(unsafe.Pointer(vm), vm.name)
type.go#L683: tityp := resolveTypeOff(unsafe.Pointer(tm), tm.ityp)
type.go#L684: vityp := resolveTypeOff(unsafe.Pointer(vm), vm.ityp)
type.go#L691: mt := (*maptype)(unsafe.Pointer(t))
type.go#L692: mv := (*maptype)(unsafe.Pointer(v))
type.go#L695: pt := (*ptrtype)(unsafe.Pointer(t))
type.go#L696: pv := (*ptrtype)(unsafe.Pointer(v))
type.go#L699: st := (*slicetype)(unsafe.Pointer(t))
type.go#L700: sv := (*slicetype)(unsafe.Pointer(v))
type.go#L703: st := (*structtype)(unsafe.Pointer(t))
type.go#L704: sv := (*structtype)(unsafe.Pointer(v))
write_err.go#L12: write(2, unsafe.Pointer(&b[0]), int32(len(b)))
runtime/cgo
callbacks.go#L103: var _cgo_yield unsafe.Pointer
641f2e0211133494cd768b7d19f12c66f4866c112d709f9f6b5ae3aaa00e6c8e-d#L10: func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }
641f2e0211133494cd768b7d19f12c66f4866c112d709f9f6b5ae3aaa00e6c8e-d#L19: 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
runtime/pprof
map.go#L24: tag unsafe.Pointer
map.go#L28: func (m *profMap) lookup(stk []uint64, tag unsafe.Pointer) *profMapEntry {
pprof.go#L666: return writeRuntimeProfile(w, debug, "threadcreate", func(p []runtime.StackRecord, _ []unsafe.Pointer) (n int, ok bool) {
pprof.go#L677: func runtime_goroutineProfileWithLabels(p []runtime.StackRecord, labels []unsafe.Pointer) (n int, ok bool)
pprof.go#L708: func writeRuntimeProfile(w io.Writer, debug int, name string, fetch func([]runtime.StackRecord, []unsafe.Pointer) (int, bool)) error {
pprof.go#L716: var labels []unsafe.Pointer
pprof.go#L723: labels = make([]unsafe.Pointer, n+10)
pprof.go#L737: labels []unsafe.Pointer
pprof.go#L793: func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool)
proto.go#L26: return *(*[2]*uintptr)(unsafe.Pointer(&f))[1]
proto.go#L274: func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error {
proto.go#L315: var tag unsafe.Pointer
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#L28: func noescape(p unsafe.Pointer) unsafe.Pointer {
builder.go#L30: return unsafe.Pointer(x ^ 0)
builder.go#L40: b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
builder.go#L48: return *(*string)(unsafe.Pointer(&b.buf))
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(interface{}))
map.go#L92: p unsafe.Pointer // *interface{}
map.go#L96: return &entry{p: unsafe.Pointer(&i)}
map.go#L175: if atomic.CompareAndSwapPointer(&e.p, p, unsafe.Pointer(i)) {
map.go#L193: atomic.StorePointer(&e.p, unsafe.Pointer(i))
map.go#L253: if atomic.CompareAndSwapPointer(&e.p, nil, unsafe.Pointer(&ic)) {
mutex.go#L76: race.Acquire(unsafe.Pointer(m))
mutex.go#L169: race.Acquire(unsafe.Pointer(m))
mutex.go#L182: 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 interface{}) 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: *(*interface{})(unsafe.Pointer(slot)) = val
poolqueue.go#L134: val := *(*interface{})(unsafe.Pointer(slot))
poolqueue.go#L169: val := *(*interface{})(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#L78: race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))
rwmutex.go#L120: race.Acquire(unsafe.Pointer(&rw.readerSem))
rwmutex.go#L121: race.Acquire(unsafe.Pointer(&rw.writerSem))
rwmutex.go#L134: race.Release(unsafe.Pointer(&rw.readerSem))
waitgroup.go#L33: if uintptr(unsafe.Pointer(&wg.state1))%8 == 0 {
waitgroup.go#L34: return (*uint64)(unsafe.Pointer(&wg.state1)), &wg.state1[2]
waitgroup.go#L36: return (*uint64)(unsafe.Pointer(&wg.state1[1])), &wg.state1[0]
waitgroup.go#L59: race.ReleaseMerge(unsafe.Pointer(wg))
waitgroup.go#L71: race.Read(unsafe.Pointer(semap))
waitgroup.go#L117: race.Acquire(unsafe.Pointer(wg))
waitgroup.go#L128: race.Write(unsafe.Pointer(semap))
waitgroup.go#L136: 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#L36: xp := (*ifaceWords)(unsafe.Pointer(&x))
value.go#L49: vp := (*ifaceWords)(unsafe.Pointer(v))
value.go#L50: xp := (*ifaceWords)(unsafe.Pointer(&x))
value.go#L59: if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(^uintptr(0))) {
syscall
bpf_darwin.go#L26: err := ioctlPtr(fd, BIOCGBLEN, unsafe.Pointer(&l))
bpf_darwin.go#L35: err := ioctlPtr(fd, BIOCSBLEN, unsafe.Pointer(&l))
bpf_darwin.go#L45: err := ioctlPtr(fd, BIOCGDLT, unsafe.Pointer(&t))
bpf_darwin.go#L54: err := ioctlPtr(fd, BIOCSDLT, unsafe.Pointer(&t))
bpf_darwin.go#L63: err := ioctlPtr(fd, BIOCPROMISC, unsafe.Pointer(&m))
bpf_darwin.go#L87: err := ioctlPtr(fd, BIOCGETIF, unsafe.Pointer(&iv))
bpf_darwin.go#L98: err := ioctlPtr(fd, BIOCSETIF, unsafe.Pointer(&iv))
bpf_darwin.go#L108: err := ioctlPtr(fd, BIOCGRTIMEOUT, unsafe.Pointer(&tv))
bpf_darwin.go#L117: err := ioctlPtr(fd, BIOCSRTIMEOUT, unsafe.Pointer(tv))
bpf_darwin.go#L127: err := ioctlPtr(fd, BIOCGSTATS, unsafe.Pointer(&s))
bpf_darwin.go#L136: err := ioctlPtr(fd, BIOCIMMEDIATE, unsafe.Pointer(&m))
bpf_darwin.go#L147: p.Insns = (*BpfInsn)(unsafe.Pointer(&i[0]))
bpf_darwin.go#L148: err := ioctlPtr(fd, BIOCSETF, unsafe.Pointer(&p))
bpf_darwin.go#L158: err := ioctlPtr(fd, BIOCVERSION, unsafe.Pointer(&v))
bpf_darwin.go#L171: err := ioctlPtr(fd, BIOCGHDRCMPLT, unsafe.Pointer(&f))
bpf_darwin.go#L180: err := ioctlPtr(fd, BIOCSHDRCMPLT, unsafe.Pointer(&f))
exec_libc2.go#L131: _, _, err1 = rawSyscall(funcPC(libc_ioctl_trampoline), uintptr(sys.Ctty), uintptr(TIOCSPGRP), uintptr(unsafe.Pointer(&pgrp)))
exec_libc2.go#L139: _, _, err1 = rawSyscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(chroot)), 0, 0)
exec_libc2.go#L150: groups = uintptr(unsafe.Pointer(&cred.Groups[0]))
exec_libc2.go#L170: _, _, err1 = rawSyscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(dir)), 0, 0)
exec_libc2.go#L251: uintptr(unsafe.Pointer(argv0)),
exec_libc2.go#L252: uintptr(unsafe.Pointer(&argv[0])),
exec_libc2.go#L253: uintptr(unsafe.Pointer(&envv[0])))
exec_libc2.go#L257: rawSyscall(funcPC(libc_write_trampoline), 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#L297: uintptr(unsafe.Pointer(argv0p)),
exec_unix.go#L298: uintptr(unsafe.Pointer(&argvp[0])),
exec_unix.go#L299: uintptr(unsafe.Pointer(&envvp[0])))
exec_unix.go#L308: uintptr(unsafe.Pointer(argv0p)),
exec_unix.go#L309: uintptr(unsafe.Pointer(&argvp[0])),
exec_unix.go#L310: uintptr(unsafe.Pointer(&envvp[0])))
flock_darwin.go#L11: _, err := fcntlPtr(int(fd), cmd, unsafe.Pointer(lk))
msan0.go#L15: func msanRead(addr unsafe.Pointer, len int) {
msan0.go#L18: func msanWrite(addr unsafe.Pointer, len int) {
route_bsd.go#L54: rsa := (*RawSockaddrDatalink)(unsafe.Pointer(&b[0]))
route_bsd.go#L82: lla := (*linkLayerAddr)(unsafe.Pointer(&b[0]))
route_bsd.go#L102: rsa := (*RawSockaddrAny)(unsafe.Pointer(&b[0]))
route_bsd.go#L108: rsa := (*RawSockaddrAny)(unsafe.Pointer(&b[0]))
route_bsd.go#L230: rsa := (*RawSockaddr)(unsafe.Pointer(&b[0]))
route_bsd.go#L298: rsa := (*RawSockaddr)(unsafe.Pointer(&b[0]))
route_bsd.go#L335: any := (*anyMessage)(unsafe.Pointer(&b[0]))
route_darwin.go#L12: p := (*RouteMessage)(unsafe.Pointer(any))
route_darwin.go#L15: p := (*InterfaceMessage)(unsafe.Pointer(any))
route_darwin.go#L18: p := (*InterfaceAddrMessage)(unsafe.Pointer(any))
route_darwin.go#L21: p := (*InterfaceMulticastAddrMessage)(unsafe.Pointer(any))
route_darwin.go#L43: rsa := (*RawSockaddr)(unsafe.Pointer(&b[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_bsd.go#L85: var base = (*uintptr)(unsafe.Pointer(new(uint64)))
syscall_bsd.go#L161: func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_bsd.go#L167: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_bsd.go#L173: return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
syscall_bsd.go#L176: func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_bsd.go#L182: p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
syscall_bsd.go#L189: return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
syscall_bsd.go#L192: func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_bsd.go#L203: return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil
syscall_bsd.go#L206: func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) {
syscall_bsd.go#L220: return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil
syscall_bsd.go#L226: pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa))
syscall_bsd.go#L241: pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
syscall_bsd.go#L260: bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
syscall_bsd.go#L265: pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
syscall_bsd.go#L267: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_bsd.go#L275: pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
syscall_bsd.go#L277: p := (*[2]byte)(unsafe.Pointer(&pp.Port))
syscall_bsd.go#L331: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_bsd.go#L337: err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen)
syscall_bsd.go#L344: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_bsd.go#L351: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_bsd.go#L358: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_bsd.go#L365: err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
syscall_bsd.go#L376: msg.Name = (*byte)(unsafe.Pointer(&rsa))
syscall_bsd.go#L380: iov.Base = (*byte)(unsafe.Pointer(&p[0]))
syscall_bsd.go#L390: msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
syscall_bsd.go#L415: var ptr unsafe.Pointer
syscall_bsd.go#L424: msg.Name = (*byte)(unsafe.Pointer(ptr))
syscall_bsd.go#L428: iov.Base = (*byte)(unsafe.Pointer(&p[0]))
syscall_bsd.go#L438: msg.Control = (*byte)(unsafe.Pointer(&oob[0]))
syscall_bsd.go#L455: var change, event unsafe.Pointer
syscall_bsd.go#L457: change = unsafe.Pointer(&changes[0])
syscall_bsd.go#L460: event = unsafe.Pointer(&events[0])
syscall_bsd.go#L510: return *(*uint32)(unsafe.Pointer(&buf[0])), nil
syscall_bsd.go#L519: return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_bsd.go#L531: err = utimensat(_AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
syscall_bsd.go#L541: return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_bsd.go#L550: return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
syscall_darwin.go#L43: p := (*byte)(unsafe.Pointer(&buf[0]))
syscall_darwin.go#L102: var _p0 unsafe.Pointer
syscall_darwin.go#L105: _p0 = unsafe.Pointer(&buf[0])
syscall_darwin.go#L136: uintptr(unsafe.Pointer(_p0)),
syscall_darwin.go#L137: uintptr(unsafe.Pointer(&attrList)),
syscall_darwin.go#L138: uintptr(unsafe.Pointer(&attributes)),
syscall_darwin.go#L283: r0, _, e1 := syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
syscall_darwin.go#L292: r0, _, e1 := syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
syscall_darwin.go#L356: ptr unsafe.Pointer
syscall_darwin.go#L359: }{ptr: unsafe.Pointer(&entry), siz: reclen, cap: reclen}
syscall_darwin.go#L360: copy(buf, *(*[]byte)(unsafe.Pointer(&s)))
syscall_darwin.go#L387: return **(**uintptr)(unsafe.Pointer(&f))
syscall_darwin_amd64.go#L47: _, _, e1 := syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
syscall_unix.go#L66: hdr := (*unsafeheader.Slice)(unsafe.Pointer(&b))
syscall_unix.go#L67: hdr.Data = unsafe.Pointer(addr)
syscall_unix.go#L94: if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil {
syscall_unix.go#L190: race.WriteRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L193: race.Acquire(unsafe.Pointer(&ioSync))
syscall_unix.go#L197: msanWrite(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L204: race.ReleaseMerge(unsafe.Pointer(&ioSync))
syscall_unix.go#L215: race.ReadRange(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L218: msanRead(unsafe.Pointer(&p[0]), n)
syscall_unix.go#L228: sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
syscall_unix.go#L277: err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen)
syscall_unix.go#L302: return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1)
syscall_unix.go#L307: return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4)
syscall_unix.go#L311: return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4)
syscall_unix.go#L315: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq)
syscall_unix.go#L319: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq)
syscall_unix.go#L323: return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter)
syscall_unix.go#L327: return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger)
syscall_unix.go#L331: var p unsafe.Pointer
syscall_unix.go#L333: p = unsafe.Pointer(&[]byte(s)[0])
syscall_unix.go#L339: return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
syscall_unix.go#L362: race.ReleaseMerge(unsafe.Pointer(&ioSync))
zsyscall_darwin_amd64.go#L13: r0, _, e1 := rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
zsyscall_darwin_amd64.go#L29: _, _, e1 := rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
zsyscall_darwin_amd64.go#L44: r0, _, e1 := syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
zsyscall_darwin_amd64.go#L60: r0, _, e1 := syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_darwin_amd64.go#L75: func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_darwin_amd64.go#L90: func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_darwin_amd64.go#L121: func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
zsyscall_darwin_amd64.go#L122: _, _, e1 := syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
zsyscall_darwin_amd64.go#L136: func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
zsyscall_darwin_amd64.go#L152: _, _, e1 := rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_darwin_amd64.go#L167: _, _, e1 := rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
zsyscall_darwin_amd64.go#L197: _, _, e1 := rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
zsyscall_darwin_amd64.go#L212: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L214: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L216: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L218: r0, _, e1 := syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
zsyscall_darwin_amd64.go#L233: func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
zsyscall_darwin_amd64.go#L234: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L236: _p0 = unsafe.Pointer(&buf[0])
zsyscall_darwin_amd64.go#L238: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L255: r0, _, e1 := syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_darwin_amd64.go#L271: r0, _, e1 := syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
zsyscall_darwin_amd64.go#L286: func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
zsyscall_darwin_amd64.go#L287: r0, _, e1 := syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
zsyscall_darwin_amd64.go#L308: _, _, e1 := syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
zsyscall_darwin_amd64.go#L323: _, _, e1 := syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
zsyscall_darwin_amd64.go#L354: _, _, e1 := rawSyscall(funcPC(libc_pipe_trampoline), uintptr(unsafe.Pointer(p)), 0, 0)
zsyscall_darwin_amd64.go#L389: _, _, e1 := syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
zsyscall_darwin_amd64.go#L404: _, _, e1 := syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
zsyscall_darwin_amd64.go#L424: _, _, e1 := syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L444: _, _, e1 := syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_darwin_amd64.go#L464: _, _, e1 := syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
zsyscall_darwin_amd64.go#L484: _, _, e1 := syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
zsyscall_darwin_amd64.go#L504: _, _, e1 := syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L590: _, _, e1 := syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
zsyscall_darwin_amd64.go#L849: _, _, e1 := rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
zsyscall_darwin_amd64.go#L864: _, _, e1 := rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
zsyscall_darwin_amd64.go#L942: _, _, e1 := syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
zsyscall_darwin_amd64.go#L967: _, _, e1 := syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_darwin_amd64.go#L1002: _, _, e1 := syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
zsyscall_darwin_amd64.go#L1022: _, _, e1 := syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
zsyscall_darwin_amd64.go#L1042: _, _, e1 := syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
zsyscall_darwin_amd64.go#L1057: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1059: _p0 = unsafe.Pointer(&b[0])
zsyscall_darwin_amd64.go#L1061: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1093: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1095: _p0 = unsafe.Pointer(&b[0])
zsyscall_darwin_amd64.go#L1097: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1114: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1116: _p0 = unsafe.Pointer(&b[0])
zsyscall_darwin_amd64.go#L1118: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1155: r0, _, e1 := syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
zsyscall_darwin_amd64.go#L1176: r0, _, e1 := syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
zsyscall_darwin_amd64.go#L1192: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1194: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L1196: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1214: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1216: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L1218: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1236: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1238: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L1240: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1258: r0, _, _ := syscall(funcPC(libc_readdir_r_trampoline), uintptr(dir), uintptr(unsafe.Pointer(entry)), uintptr(unsafe.Pointer(result)))
zsyscall_darwin_amd64.go#L1276: var _p1 unsafe.Pointer
zsyscall_darwin_amd64.go#L1278: _p1 = unsafe.Pointer(&buf[0])
zsyscall_darwin_amd64.go#L1280: _p1 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1282: r0, _, e1 := syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
zsyscall_darwin_amd64.go#L1308: _, _, e1 := syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_darwin_amd64.go#L1328: _, _, e1 := syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L1348: _, _, e1 := syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L1379: _, _, e1 := syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
zsyscall_darwin_amd64.go#L1444: _, _, e1 := syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L1534: _, _, e1 := rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
zsyscall_darwin_amd64.go#L1565: _, _, e1 := rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
zsyscall_darwin_amd64.go#L1605: _, _, e1 := syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
zsyscall_darwin_amd64.go#L1640: _, _, e1 := syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
zsyscall_darwin_amd64.go#L1673: _, _, e1 := syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L1693: _, _, e1 := syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
zsyscall_darwin_amd64.go#L1713: _, _, e1 := syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
zsyscall_darwin_amd64.go#L1728: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1730: _p0 = unsafe.Pointer(&p[0])
zsyscall_darwin_amd64.go#L1732: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1750: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1752: _p0 = unsafe.Pointer(&iovecs[0])
zsyscall_darwin_amd64.go#L1754: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1833: func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) {
zsyscall_darwin_amd64.go#L1844: _, _, e1 := rawSyscall(funcPC(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp)))
zsyscall_darwin_amd64.go#L1874: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1876: _p0 = unsafe.Pointer(&mib[0])
zsyscall_darwin_amd64.go#L1878: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1880: _, _, e1 := syscall6(funcPC(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
zsyscall_darwin_amd64.go#L1894: func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
zsyscall_darwin_amd64.go#L1911: _, _, e1 := syscall(funcPC(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
zsyscall_darwin_amd64.go#L1931: r0, _, e1 := syscall6(funcPC(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0)
zsyscall_darwin_amd64.go#L1947: var _p0 unsafe.Pointer
zsyscall_darwin_amd64.go#L1949: _p0 = unsafe.Pointer(&buf[0])
zsyscall_darwin_amd64.go#L1951: _p0 = unsafe.Pointer(&_zero)
zsyscall_darwin_amd64.go#L1969: _, _, e1 := syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L1984: _, _, e1 := syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L1999: _, _, e1 := rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
zsyscall_darwin_amd64.go#L2019: _, _, e1 := syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L2039: _, _, e1 := syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L2059: _, _, e1 := syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
zsyscall_darwin_amd64.go#L2079: _, _, e1 := syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
vendor/golang.org/x/crypto/internal/subtle
aliasing.go#L17: uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
aliasing.go#L18: uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))
vendor/golang.org/x/net/route
sys.go#L20: b := (*[4]byte)(unsafe.Pointer(&i))
 |
The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |