func unsafe.Sizeof
230 uses
unsafe (current package)
unsafe.go#L198: func Sizeof(x ArbitraryType) uintptr
internal/abi
type.go#L518: uadd := unsafe.Sizeof(*t)
type.go#L520: uadd += unsafe.Sizeof(UncommonType{})
type.go#L532: uadd := unsafe.Sizeof(*t)
type.go#L534: uadd += unsafe.Sizeof(UncommonType{})
internal/runtime/gc/scan
scan_go.go#L81: *(*T)(unsafe.Add(unsafe.Pointer(b.base), b.n*int(unsafe.Sizeof(val)))) = val
internal/runtime/maps
group.go#L260: ctrlGroupsSize = unsafe.Sizeof(ctrlGroup(0))
internal/saferio
io.go#L130: size := uint64(unsafe.Sizeof(v))
net
cgo_unix.go#L321: resStateSize := unsafe.Sizeof(_C_struct___res_state{})
os
dirent_linux.go#L13: return readInt(buf, unsafe.Offsetof(syscall.Dirent{}.Ino), unsafe.Sizeof(syscall.Dirent{}.Ino))
dirent_linux.go#L17: return readInt(buf, unsafe.Offsetof(syscall.Dirent{}.Reclen), unsafe.Sizeof(syscall.Dirent{}.Reclen))
reflect
type.go#L1204: if unsafe.Sizeof(int(0)) == 4 && goarch.BigEndian {
type.go#L2490: ut.Moff = uint32(unsafe.Sizeof(uncommonType{}))
runtime
alg.go#L53: size := *(*uintptr)(unsafe.Pointer(ptr + unsafe.Sizeof(h)))
arena.go#L231: return userArenaChunkBytes/goarch.PtrSize/8 + unsafe.Sizeof(_type{})
arena.go#L1125: *(*uintptr)(unsafe.Pointer(&s.largeType.GCData)) = s.limit + unsafe.Sizeof(_type{})
cgo_sigaction.go#L31: msanwrite(unsafe.Pointer(new), unsafe.Sizeof(*new))
cgo_sigaction.go#L34: asanwrite(unsafe.Pointer(new), unsafe.Sizeof(*new))
cgo_sigaction.go#L87: msanread(unsafe.Pointer(old), unsafe.Sizeof(*old))
cgo_sigaction.go#L90: asanread(unsafe.Pointer(old), unsafe.Sizeof(*old))
chan.go#L30: hchanSize = unsafe.Sizeof(hchan{}) + uintptr(-int(unsafe.Sizeof(hchan{}))&(maxAlign-1))
covercounter.go#L15: u32sz := unsafe.Sizeof(uint32(0))
debuglog.go#L99: l = (*dloggerImpl)(sysAllocOS(unsafe.Sizeof(dloggerImpl{}), "debug log"))
debuglog.go#L816: state1 := sysAllocOS(unsafe.Sizeof(readState{})*uintptr(n), "debug log")
defs_linux_amd64.go#L137: _ [_si_max_size - unsafe.Sizeof(siginfoFields{})]byte
defs_linux_amd64.go#L162: _ [_sigev_max_size - unsafe.Sizeof(sigeventFields{})]byte
heapdump.go#L689: memclrNoHeapPointers(unsafe.Pointer(&typecache), unsafe.Sizeof(typecache))
iface.go#L77: m = (*itab)(persistentalloc(unsafe.Sizeof(itab{})+uintptr(len(inter.Methods)-1)*goarch.PtrSize, 0, &memstats.other_sys))
iface.go#L423: x = mallocgc(unsafe.Sizeof(val), stringType, true)
iface.go#L443: x = mallocgc(unsafe.Sizeof(val), sliceType, true)
iface.go#L525: newSize := unsafe.Sizeof(abi.TypeAssertCache{}) + uintptr(newN-1)*unsafe.Sizeof(abi.TypeAssertCacheEntry{})
iface.go#L631: newSize := unsafe.Sizeof(abi.InterfaceSwitchCache{}) + uintptr(newN-1)*unsafe.Sizeof(abi.InterfaceSwitchCacheEntry{})
lock_spinbit.go#L95: size := roundupsize(unsafe.Sizeof(mPadded{}), false) + gc.MallocHeaderSize
malloc.go#L664: const arenaMetaSize = (1 << arenaBits) * unsafe.Sizeof(heapArena{})
malloc.go#L864: l2 = (*[1 << arenaL2Bits]*heapArena)(sysAllocOS(unsafe.Sizeof(*l2), "heap index"))
malloc.go#L869: sysHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
malloc.go#L871: sysNoHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
malloc.go#L880: r = (*heapArena)(h.heapArenaAlloc.alloc(unsafe.Sizeof(*r), goarch.PtrSize, &memstats.gcMiscSys, "heap metadata"))
malloc.go#L882: r = (*heapArena)(persistentalloc(unsafe.Sizeof(*r), goarch.PtrSize, &memstats.gcMiscSys))
malloc.go#L960: sysHugePage(unsafe.Pointer(l2), unsafe.Sizeof(*l2))
malloc_generated.go#L4383: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L4539: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L4695: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L4851: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L5007: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L5163: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L5319: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L5475: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L5631: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L5787: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L5943: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L6099: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L6255: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L6411: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_generated.go#L6567: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) /
malloc_stubs.go#L514: const nelems = uint16((nbytes - unsafe.Sizeof(spanInlineMarkBits{})) / elemsize_)
mbitmap.go#L574: base -= unsafe.Sizeof(spanInlineMarkBits{})
mcheckmark.go#L48: bitmap = (*checkmarksMap)(persistentalloc(unsafe.Sizeof(*bitmap), 0, &memstats.gcMiscSys))
mcleanup.go#L113: if size := unsafe.Sizeof(arg); size < maxTinySize && argType.PtrBytes == 0 {
mcleanup.go#L292: cleanups [(cleanupBlockSize - unsafe.Sizeof(cleanupBlockHeader{})) / unsafe.Sizeof(cleanupFn{})]cleanupFn
mcleanup.go#L369: _ [cpu.CacheLinePadSize - unsafe.Sizeof(lfstack(0)) - unsafe.Sizeof(atomic.Uint64{})]byte
mcleanup.go#L380: _ [cpu.CacheLinePadSize - unsafe.Sizeof(lfstack(0)) - 1]byte
mcleanup.go#L384: _ [cpu.CacheLinePadSize - unsafe.Sizeof(atomic.UnsafePointer{})]byte
mfinal.go#L32: fin [(finBlockSize - 2*goarch.PtrSize - 2*4) / unsafe.Sizeof(finalizer{})]finalizer
mfinal.go#L122: if (unsafe.Sizeof(finalizer{}) != 5*goarch.PtrSize ||
mfinal.go#L232: framesz := unsafe.Sizeof((any)(nil)) + f.nret
mfixalloc.go#L60: size = max(size, unsafe.Sizeof(mlink{}))
mgc.go#L180: if unsafe.Sizeof(workbuf{}) != _WorkbufSize {
mgc.go#L1745: pad [tagAlign - unsafe.Sizeof(gcBgMarkWorkerNode{}) - gcBgMarkWorkerNodeRedZoneSize]byte
mgcmark.go#L241: scanblock(uintptr(unsafe.Pointer(&fb.fin[0])), cnt*unsafe.Sizeof(fb.fin[0]), &finptrmask[0], gcw, nil)
mgcmark.go#L254: scanblock(uintptr(unsafe.Pointer(&cb.cleanups[0])), n*unsafe.Sizeof(cleanupFn{}), &cleanupBlockPtrMask[0], gcw, nil)
mgcmark.go#L492: scanblock(uintptr(unsafe.Pointer(&spc.cleanup)), unsafe.Sizeof(cleanupFn{}), &cleanupFnPtrMask[0], gcw, nil)
mgcmark_greenteagc.go#L139: memclrNoHeapPointers(unsafe.Pointer(imb), unsafe.Sizeof(spanInlineMarkBits{}))
mgcmark_greenteagc.go#L181: return (*spanInlineMarkBits)(unsafe.Pointer(base + gc.PageSize - unsafe.Sizeof(spanInlineMarkBits{})))
mgcmark_greenteagc.go#L724: ring := sysAlloc(uintptr(cap)*unsafe.Sizeof(objptr(0)), &memstats.gcMiscSys, "GC span queue")
mgcmark_greenteagc.go#L740: sysFree(unsafe.Pointer(r.ring), uintptr(r.cap)*unsafe.Sizeof(objptr(0)), &memstats.gcMiscSys)
mgcmark_greenteagc.go#L753: return (*objptr)(unsafe.Add(unsafe.Pointer(r.ring), idx*unsafe.Sizeof(objptr(0))))
mgcmark_greenteagc.go#L875: usableSpanSize := uint64(gc.PageSize - unsafe.Sizeof(spanInlineMarkBits{}))
mgcmark_greenteagc.go#L1099: base := spanBase + gc.PageSize - unsafe.Sizeof(gc.PtrMask{}) - unsafe.Sizeof(spanInlineMarkBits{})
mgcstack.go#L110: obj [(_WorkbufSize - unsafe.Sizeof(stackWorkBufHdr{})) / goarch.PtrSize]uintptr
mgcstack.go#L128: obj [(_WorkbufSize - unsafe.Sizeof(stackObjectBufHdr{})) / unsafe.Sizeof(stackObject{})]stackObject
mgcstack.go#L138: if unsafe.Sizeof(stackWorkBuf{}) > unsafe.Sizeof(workbuf{}) {
mgcstack.go#L141: if unsafe.Sizeof(stackObjectBuf{}) > unsafe.Sizeof(workbuf{}) {
mgcwork.go#L400: obj [(_WorkbufSize - unsafe.Sizeof(workbufhdr{})) / goarch.PtrSize]uintptr
mgcwork.go#L515: memmove(unsafe.Pointer(&b1.obj[0]), unsafe.Pointer(&b.obj[b.nobj]), uintptr(n)*unsafe.Sizeof(b1.obj[0]))
mheap.go#L213: pad [(cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize) % cpu.CacheLinePadSize]byte
mheap.go#L569: sysFree(unsafe.Pointer(&oldAllspans[0]), uintptr(cap(oldAllspans))*unsafe.Sizeof(oldAllspans[0]), &memstats.other_sys)
mheap.go#L791: h.spanalloc.init(unsafe.Sizeof(mspan{}), recordspan, unsafe.Pointer(h), &memstats.mspan_sys)
mheap.go#L792: h.spanSPMCAlloc.init(unsafe.Sizeof(spanSPMC{}), nil, nil, &memstats.gcMiscSys)
mheap.go#L793: h.cachealloc.init(unsafe.Sizeof(mcache{}), nil, nil, &memstats.mcache_sys)
mheap.go#L794: h.specialfinalizeralloc.init(unsafe.Sizeof(specialfinalizer{}), nil, nil, &memstats.other_sys)
mheap.go#L795: h.specialCleanupAlloc.init(unsafe.Sizeof(specialCleanup{}), nil, nil, &memstats.other_sys)
mheap.go#L796: h.specialCheckFinalizerAlloc.init(unsafe.Sizeof(specialCheckFinalizer{}), nil, nil, &memstats.other_sys)
mheap.go#L797: h.specialTinyBlockAlloc.init(unsafe.Sizeof(specialTinyBlock{}), nil, nil, &memstats.other_sys)
mheap.go#L798: h.specialprofilealloc.init(unsafe.Sizeof(specialprofile{}), nil, nil, &memstats.other_sys)
mheap.go#L799: h.specialReachableAlloc.init(unsafe.Sizeof(specialReachable{}), nil, nil, &memstats.other_sys)
mheap.go#L800: h.specialPinCounterAlloc.init(unsafe.Sizeof(specialPinCounter{}), nil, nil, &memstats.other_sys)
mheap.go#L801: h.specialSecretAlloc.init(unsafe.Sizeof(specialSecret{}), nil, nil, &memstats.other_sys)
mheap.go#L802: h.specialWeakHandleAlloc.init(unsafe.Sizeof(specialWeakHandle{}), nil, nil, &memstats.gcMiscSys)
mheap.go#L803: h.specialBubbleAlloc.init(unsafe.Sizeof(specialBubble{}), nil, nil, &memstats.other_sys)
mheap.go#L804: h.arenaHintAlloc.init(unsafe.Sizeof(arenaHint{}), nil, nil, &memstats.other_sys)
mheap.go#L1471: reserve += unsafe.Sizeof(spanInlineMarkBits{})
mheap.go#L2545: _ [maxTinySize - unsafe.Sizeof(atomic.Uintptr{})]byte
mheap.go#L2690: newNode = (*immortalWeakHandle)(persistentalloc(unsafe.Sizeof(immortalWeakHandle{}), goarch.PtrSize, &memstats.gcMiscSys))
mheap.go#L2879: const gcBitsHeaderBytes = unsafe.Sizeof(gcBitsHeader{})
minmax.go#L55: switch unsafe.Sizeof(x) {
minmax.go#L65: switch unsafe.Sizeof(x) {
mpagealloc.go#L410: const l2Size = unsafe.Sizeof(*p.chunks[0])
mpagealloc.go#L479: sysHugePage(unsafe.Pointer(p.chunks[i]), unsafe.Sizeof(*p.chunks[0]))
mpagealloc.go#L1019: pallocSumBytes = unsafe.Sizeof(pallocSum(0))
mpagealloc_64bit.go#L193: scSize := unsafe.Sizeof(atomicScavChunkData{})
mpagealloc_64bit.go#L247: nbytes := n * unsafe.Sizeof(atomicScavChunkData{})
mpagecache.go#L12: const pageCachePages = 8 * unsafe.Sizeof(pageCache{}.cache)
mprof.go#L229: size := unsafe.Sizeof(bucket{}) + uintptr(nstk)*unsafe.Sizeof(uintptr(0))
mprof.go#L234: size += unsafe.Sizeof(memRecord{})
mprof.go#L236: size += unsafe.Sizeof(blockRecord{})
mprof.go#L248: stk := (*[maxProfStackDepth]uintptr)(add(unsafe.Pointer(b), unsafe.Sizeof(*b)))
mprof.go#L261: data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
mprof.go#L270: data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
mprof.go#L282: bh = (*buckhashArray)(sysAlloc(unsafe.Sizeof(buckhashArray{}), &memstats.buckhash_sys, "profiler hash buckets"))
mprof.go#L1019: racewriterangepc(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0), sys.GetCallerPC(), abi.FuncPCABIInternal(MemProfile))
mprof.go#L1022: msanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
mprof.go#L1025: asanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
mprof.go#L1133: racewriterangepc(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0), sys.GetCallerPC(), abi.FuncPCABIInternal(BlockProfile))
mprof.go#L1136: msanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
mprof.go#L1139: asanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
mranges.go#L258: ranges.array = (*notInHeap)(persistentalloc(unsafe.Sizeof(addrRange{})*uintptr(ranges.cap), goarch.PtrSize, sysStat))
mranges.go#L385: ranges.array = (*notInHeap)(persistentalloc(unsafe.Sizeof(addrRange{})*uintptr(ranges.cap), goarch.PtrSize, a.sysStat))
mranges.go#L455: ranges.array = (*notInHeap)(persistentalloc(unsafe.Sizeof(addrRange{})*uintptr(ranges.cap), goarch.PtrSize, b.sysStat))
mspanset.go#L71: pad [tagAlign - unsafe.Sizeof(spanSetBlockHeader{})]byte
mspanset.go#L338: return (*spanSetBlock)(persistentalloc(unsafe.Sizeof(spanSetBlock{}), max(cpu.CacheLineSize, tagAlign), &memstats.gcMiscSys))
mstats.go#L344: if size := unsafe.Sizeof(heapStatsDelta{}); size%8 != 0 {
mwbbuf.go#L87: b.end = start + uintptr(len(b.buf))*unsafe.Sizeof(b.buf[0])
mwbbuf.go#L90: if (b.end-b.next)%unsafe.Sizeof(b.buf[0]) != 0 {
mwbbuf.go#L198: n := (pp.wbBuf.next - start) / unsafe.Sizeof(pp.wbBuf.buf[0])
netpoll.go#L693: pad [tagAlign - unsafe.Sizeof(pollDesc{})]byte
netpoll.go#L695: const pdSize = unsafe.Sizeof(pollDescPadded{})
netpoll_epoll.go#L74: oneSize := int32(unsafe.Sizeof(one))
netpoll_epoll.go#L152: read(int32(netpollEventFd), noescape(unsafe.Pointer(&one)), int32(unsafe.Sizeof(one)))
os_linux.go#L111: r := sched_getaffinity(0, unsafe.Sizeof(buf), &buf[0])
os_linux.go#L283: n = read(fd, noescape(unsafe.Pointer(&auxvreadbuf[0])), int32(unsafe.Sizeof(auxvreadbuf)))
os_linux.go#L448: rtsigprocmask(how, new, old, int32(unsafe.Sizeof(*new)))
os_linux.go#L535: if rt_sigaction(uintptr(sig), new, old, unsafe.Sizeof(sigactiont{}.sa_mask)) != 0 {
panic.go#L767: fd = add(fd, unsafe.Sizeof(b))
pinner.go#L103: pinnerRefStoreSize = (pinnerSize - unsafe.Sizeof([]unsafe.Pointer{})) / unsafe.Sizeof(unsafe.Pointer(nil))
preempt_xreg.go#L64: xRegAlloc.alloc.init(unsafe.Sizeof(xRegState{}), nil, nil, &memstats.other_sys)
proc.go#L2916: msanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
proc.go#L2919: asanwrite(unsafe.Pointer(&ts), unsafe.Sizeof(ts))
proc.go#L5347: memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
runtime1.go#L169: if unsafe.Sizeof(a) != 1 {
runtime1.go#L172: if unsafe.Sizeof(b) != 1 {
runtime1.go#L175: if unsafe.Sizeof(c) != 2 {
runtime1.go#L178: if unsafe.Sizeof(d) != 2 {
runtime1.go#L181: if unsafe.Sizeof(e) != 4 {
runtime1.go#L184: if unsafe.Sizeof(f) != 4 {
runtime1.go#L187: if unsafe.Sizeof(g) != 8 {
runtime1.go#L190: if unsafe.Sizeof(h) != 8 {
runtime1.go#L193: if unsafe.Sizeof(i) != 4 {
runtime1.go#L196: if unsafe.Sizeof(j) != 8 {
runtime1.go#L199: if unsafe.Sizeof(k) != goarch.PtrSize {
runtime1.go#L202: if unsafe.Sizeof(l) != goarch.PtrSize {
runtime1.go#L205: if unsafe.Sizeof(x1) != 1 {
runtime1.go#L211: if unsafe.Sizeof(y1) != 2 {
runtime2.go#L738: _ [(1 - goarch.IsWasm) * (2048 - mallocHeaderSize - mRedZoneSize - unsafe.Sizeof(m{}))]byte
sema.go#L53: pad [cpu.CacheLinePadSize - unsafe.Sizeof(semaRoot{})]byte
sema.go#L726: if sz != unsafe.Sizeof(notifyList{}) {
sema.go#L727: print("runtime: bad notifyList size - sync=", sz, " runtime=", unsafe.Sizeof(notifyList{}), "\n")
stack.go#L155: _ [(cpu.CacheLinePadSize - unsafe.Sizeof(stackpoolItem{})%cpu.CacheLinePadSize) % cpu.CacheLinePadSize]byte
stack.go#L219: valgrindMalloc(unsafe.Pointer(x.ptr()), unsafe.Sizeof(x.ptr()))
stack.go#L514: valgrindMalloc(unsafe.Pointer(x.ptr()), unsafe.Sizeof(x.ptr()))
stack.go#L527: valgrindMalloc(unsafe.Pointer(x.ptr()), unsafe.Sizeof(x.ptr()))
stack.go#L624: valgrindMakeMemDefined(unsafe.Pointer(&p), unsafe.Sizeof(&p))
stkframe.go#L238: unsafe.Sizeof(abi.RegArgs{}) > 0 && isReflect {
string.go#L263: uintptr(len(a))*unsafe.Sizeof(a[0]),
string.go#L268: msanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
string.go#L271: asanread(unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(a[0]))
symtab.go#L944: ffb := (*findfuncbucket)(add(unsafe.Pointer(datap.findfunctab), b*unsafe.Sizeof(findfuncbucket{})))
symtab.go#L1237: return *(*uint32)(add(unsafe.Pointer(&f.nfuncdata), unsafe.Sizeof(f.nfuncdata)+uintptr(table)*4))
symtab.go#L1271: p := uintptr(unsafe.Pointer(&f.nfuncdata)) + unsafe.Sizeof(f.nfuncdata) + uintptr(f.npcdata)*4 + uintptr(i)*4
trace.go#L809: sysFree(unsafe.Pointer(buf), unsafe.Sizeof(*buf), &memstats.other_sys)
traceback.go#L1740: msanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
traceback.go#L1743: asanwrite(unsafe.Pointer(arg), unsafe.Sizeof(cgoSymbolizerArg{}))
traceback.go#L1764: msanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
traceback.go#L1767: asanwrite(unsafe.Pointer(&arg), unsafe.Sizeof(arg))
tracebuf.go#L168: w.traceBuf = (*traceBuf)(sysAlloc(unsafe.Sizeof(traceBuf{}), &memstats.other_sys, "trace buffer"))
tracebuf.go#L272: arr [tracev2.MaxBatchSize - unsafe.Sizeof(traceBufHeader{})]byte // underlying buffer for traceBufHeader.buf
tracemap.go#L132: meta := (*traceMapNode)(unsafe.Pointer(tab.mem.alloc(unsafe.Sizeof(traceMapNode{}))))
traceregion.go#L40: const traceRegionAllocBlockData = 64<<10 - unsafe.Sizeof(traceRegionAllocBlockHeader{})
traceregion.go#L85: block = (*traceRegionAllocBlock)(sysAlloc(unsafe.Sizeof(traceRegionAllocBlock{}), &memstats.other_sys, "trace arena alloc"))
traceregion.go#L111: sysFree(unsafe.Pointer(block), unsafe.Sizeof(traceRegionAllocBlock{}), &memstats.other_sys)
traceregion.go#L114: sysFree(current, unsafe.Sizeof(traceRegionAllocBlock{}), &memstats.other_sys)
tracestack.go#L154: id, _ := t.tab.put(noescape(unsafe.Pointer(&pcs[0])), uintptr(len(pcs))*unsafe.Sizeof(uintptr(0)))
tracestack.go#L172: stack := unsafe.Slice((*uintptr)(unsafe.Pointer(&node.data[0])), uintptr(len(node.data))/unsafe.Sizeof(uintptr(0)))
vdso_linux.go#L53: vdsoSymTabSize = vdsoArrayMax / unsafe.Sizeof(elfSym{})
vdso_linux.go#L54: vdsoDynSize = vdsoArrayMax / unsafe.Sizeof(elfDyn{})
vdso_linux.go#L61: vdsoBloomSizeScale = unsafe.Sizeof(uintptr(0)) / 4 // uint32
vdso_linux.go#L115: pt := (*elfPhdr)(add(pt, uintptr(i)*unsafe.Sizeof(elfPhdr{})))
slices
slices.go#L457: elemSize := unsafe.Sizeof(a[0])
sync
pool.go#L77: pad [128 - unsafe.Sizeof(poolLocalInternal{})%128]byte
pool.go#L301: lp := unsafe.Pointer(uintptr(l) + uintptr(i)*unsafe.Sizeof(poolLocal{}))
runtime.go#L55: runtime_notifyListCheck(unsafe.Sizeof(n))
syscall
exec_linux.go#L165: RawSyscall(SYS_WRITE, uintptr(mapPipe[1]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
exec_linux.go#L334: pid, err1 = rawVforkSyscall(_SYS_clone3, uintptr(unsafe.Pointer(clone3)), unsafe.Sizeof(*clone3), 0)
exec_linux.go#L370: c, _, err1 = RawSyscall(SYS_READ, uintptr(mapPipe[0]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
exec_linux.go#L374: if c != unsafe.Sizeof(err2) {
exec_linux.go#L675: RawSyscall(SYS_WRITE, uintptr(pipe), uintptr(unsafe.Pointer(&err1)), unsafe.Sizeof(err1))
exec_unix.go#L220: n, err = readlen(p[0], (*byte)(unsafe.Pointer(&err1)), int(unsafe.Sizeof(err1)))
exec_unix.go#L227: if n == int(unsafe.Sizeof(err1)) {
lsf_linux.go#L79: return setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, unsafe.Pointer(&p), unsafe.Sizeof(p))
lsf_linux.go#L85: return setsockopt(fd, SOL_SOCKET, SO_DETACH_FILTER, unsafe.Pointer(&dummy), unsafe.Sizeof(dummy))
sockcmsg_linux.go#L34: if uintptr(len(m.Data)) < unsafe.Sizeof(Ucred{}) {
syscall_linux.go#L767: return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
syscall_linux.go#L965: iov.SetLen(int(unsafe.Sizeof(*regsout)))
syscall_linux.go#L972: iov.SetLen(int(unsafe.Sizeof(*regs)))
syscall_linux.go#L1012: return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
syscall_linux.go#L1016: return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
syscall_unix.go#L504: return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv))
 |
The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |