runtime._type.size (field)

135 uses

	runtime (current package)
		alg.go#L147: 		switch t.size {
		alg.go#L153: 			return memhash(p, h, t.size)
		alg.go#L176: 			h = typehash(a.elem, add(p, i*a.elem.size), h)
		alg.go#L199: 			memEnd = f.offset() + f.typ.size
		cgocall.go#L454: 			p = add(p, at.elem.size)
		cgocall.go#L503: 			p = add(p, st.elem.size)
		cgocheck.go#L98: 		cgoCheckTypedBlock(typ, p, 0, typ.size)
		cgocheck.go#L99: 		p = add(p, typ.size)
		cgocheck.go#L229: 			if off < at.elem.size {
		cgocheck.go#L232: 			src = add(src, at.elem.size)
		cgocheck.go#L234: 			if skipped > at.elem.size {
		cgocheck.go#L235: 				skipped = at.elem.size
		cgocheck.go#L237: 			checked := at.elem.size - skipped
		cgocheck.go#L247: 			if off < f.typ.size {
		cgocheck.go#L250: 			src = add(src, f.typ.size)
		cgocheck.go#L252: 			if skipped > f.typ.size {
		cgocheck.go#L253: 				skipped = f.typ.size
		cgocheck.go#L255: 			checked := f.typ.size - skipped
		chan.go#L75: 	if elem.size >= 1<<16 {
		chan.go#L82: 	mem, overflow := math.MulUintptr(elem.size, uintptr(size))
		chan.go#L109: 	c.elemsize = uint16(elem.size)
		chan.go#L115: 		print("makechan: chan=", c, "; elemsize=", elem.size, "; dataqsiz=", size, "\n")
		chan.go#L340: 	typeBitsBulkBarrier(t, uintptr(dst), uintptr(src), t.size)
		chan.go#L343: 	memmove(dst, src, t.size)
		chan.go#L351: 	typeBitsBulkBarrier(t, uintptr(dst), uintptr(src), t.size)
		chan.go#L352: 	memmove(dst, src, t.size)
		checkptr.go#L19: 	if size := n * elem.size; size > 1 && checkptrBase(p) != checkptrBase(add(p, size-1)) {
		heapdump.go#L196: 	dumpint(uint64(t.size))
		iface.go#L323: 		msanread(elem, t.size)
		iface.go#L325: 	x := mallocgc(t.size, t, true)
		iface.go#L396: 		msanread(elem, t.size)
		iface.go#L398: 	x := mallocgc(t.size, t, false)
		iface.go#L399: 	memmove(x, elem, t.size)
		iface.go#L411: 		msanread(elem, t.size)
		iface.go#L413: 	x := mallocgc(t.size, t, true)
		iface.go#L426: 		msanread(elem, t.size)
		iface.go#L428: 	x := mallocgc(t.size, t, false)
		iface.go#L429: 	memmove(x, elem, t.size)
		malloc.go#L1097: 		if dataSize > typ.size {
		malloc.go#L1102: 				scanSize = dataSize - typ.size + typ.ptrdata
		malloc.go#L1177: 	return mallocgc(typ.size, typ, true)
		malloc.go#L1182: 	return mallocgc(typ.size, typ, true)
		malloc.go#L1187: 	return mallocgc(typ.size, typ, true)
		malloc.go#L1193: 		return mallocgc(typ.size, typ, true)
		malloc.go#L1195: 	mem, overflow := math.MulUintptr(typ.size, uintptr(n))
		map.go#L304: 	mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
		map.go#L354: 		sz := t.bucket.size * nbuckets
		map.go#L357: 			nbuckets = up / t.bucket.size
		map.go#L368: 		size := t.bucket.size * nbuckets
		map.go#L402: 		msanread(key, t.key.size)
		map.go#L460: 		msanread(key, t.key.size)
		map.go#L582: 		msanread(key, t.key.size)
		map.go#L693: 		msanread(key, t.key.size)
		map.go#L739: 				memclrHasPointers(k, t.key.size)
		map.go#L745: 				memclrHasPointers(e, t.elem.size)
		map.go#L747: 				memclrNoHeapPointers(e, t.elem.size)
		map.go#L1283: 	if t.key.size > maxKeySize && (!t.indirectkey() || t.keysize != uint8(sys.PtrSize)) ||
		map.go#L1284: 		t.key.size <= maxKeySize && (t.indirectkey() || t.keysize != uint8(t.key.size)) {
		map.go#L1287: 	if t.elem.size > maxElemSize && (!t.indirectelem() || t.elemsize != uint8(sys.PtrSize)) ||
		map.go#L1288: 		t.elem.size <= maxElemSize && (t.indirectelem() || t.elemsize != uint8(t.elem.size)) {
		map.go#L1297: 	if t.key.size%uintptr(t.key.align) != 0 {
		map.go#L1300: 	if t.elem.size%uintptr(t.elem.align) != 0 {
		map_fast32.go#L311: 				memclrHasPointers(e, t.elem.size)
		map_fast32.go#L313: 				memclrNoHeapPointers(e, t.elem.size)
		map_fast64.go#L313: 				memclrHasPointers(e, t.elem.size)
		map_fast64.go#L315: 				memclrNoHeapPointers(e, t.elem.size)
		map_faststr.go#L336: 				memclrHasPointers(e, t.elem.size)
		map_faststr.go#L338: 				memclrNoHeapPointers(e, t.elem.size)
		mbarrier.go#L170: 	memmove(dst, src, typ.size)
		mbarrier.go#L172: 		cgoCheckMemmove(typ, dst, src, 0, typ.size)
		mbarrier.go#L183: 		msanwrite(dst, typ.size)
		mbarrier.go#L184: 		msanread(src, typ.size)
		mbarrier.go#L250: 		racewriterangepc(dstPtr, uintptr(n)*typ.size, callerpc, pc)
		mbarrier.go#L251: 		racereadrangepc(srcPtr, uintptr(n)*typ.size, callerpc, pc)
		mbarrier.go#L254: 		msanwrite(dstPtr, uintptr(n)*typ.size)
		mbarrier.go#L255: 		msanread(srcPtr, uintptr(n)*typ.size)
		mbarrier.go#L270: 	size := uintptr(n) * typ.size
		mbarrier.go#L272: 		pwsize := size - typ.size + typ.ptrdata
		mbarrier.go#L284: 		return slicecopy(dst.array, dst.len, src.array, src.len, elemType.size)
		mbarrier.go#L302: 	memclrNoHeapPointers(ptr, typ.size)
		mbitmap.go#L702: 	if typ.size != size {
		mbitmap.go#L703: 		println("runtime: typeBitsBulkBarrier with type ", typ.string(), " of size ", typ.size, " but memory size", size)
		mbitmap.go#L859: 		if typ.size == sys.PtrSize {
		mbitmap.go#L882: 			if typ.size != 2*sys.PtrSize || typ.kind&kindGCProg != 0 {
		mbitmap.go#L883: 				print("runtime: heapBitsSetType size=", size, " but typ.size=", typ.size, " gcprog=", typ.kind&kindGCProg != 0, "\n")
		mbitmap.go#L908: 			if typ.size == 2*sys.PtrSize {
		mbitmap.go#L909: 				print("runtime: heapBitsSetType size=", size, " but typ.size=", typ.size, "\n")
		mbitmap.go#L913: 		if typ.size == sys.PtrSize {
		mbitmap.go#L917: 				print("runtime: heapBitsSetType size=", size, " typ.size=", typ.size, "but *typ.gcdata", *typ.gcdata, "\n")
		mbitmap.go#L1004: 		heapBitsSetTypeGCProg(h, typ.ptrdata, typ.size, dataSize, size, addb(typ.gcdata, 4))
		mbitmap.go#L1055: 	if typ.size < dataSize {
		mbitmap.go#L1076: 			nb = typ.size / sys.PtrSize
		mbitmap.go#L1108: 			endnb = typ.size/sys.PtrSize - n*8
		mbitmap.go#L1117: 	if typ.size == dataSize {
		mbitmap.go#L1124: 		nw = ((dataSize/typ.size-1)*typ.size + typ.ptrdata) / sys.PtrSize
		mbitmap.go#L1401: 			println("ended at wrong bitmap byte for", typ.string(), "x", dataSize/typ.size)
		mbitmap.go#L1402: 			print("typ.size=", typ.size, " typ.ptrdata=", typ.ptrdata, " dataSize=", dataSize, " size=", size, "\n")
		mbitmap.go#L1414: 		ndata := typ.size / sys.PtrSize
		mbitmap.go#L1415: 		count := dataSize / typ.size
		mbitmap.go#L1416: 		totalptr := ((count-1)*typ.size + typ.ptrdata) / sys.PtrSize
		mbitmap.go#L1434: 				println("mismatch writing bits for", typ.string(), "x", dataSize/typ.size)
		mbitmap.go#L1435: 				print("typ.size=", typ.size, " typ.ptrdata=", typ.ptrdata, " dataSize=", dataSize, " size=", size, "\n")
		mbitmap.go#L1960: 			n := (*ptrtype)(unsafe.Pointer(t)).elem.size
		mbitmap.go#L1972: 			n := (*ptrtype)(unsafe.Pointer(t)).elem.size
		mbitmap.go#L2012: 			n := (*ptrtype)(unsafe.Pointer(t)).elem.size
		mfinal.go#L359: 		if ot.elem == nil || ot.elem.ptrdata != 0 || ot.elem.size >= maxTinySize {
		mfinal.go#L410: 		nret = alignUp(nret, uintptr(t.align)) + uintptr(t.size)
		mgcstack.go#L297: 	obj.size = uint32(typ.size)
		select.go#L403: 			msanread(cas.elem, c.elemtype.size)
		select.go#L405: 			msanwrite(cas.elem, c.elemtype.size)
		select.go#L421: 		msanwrite(cas.elem, c.elemtype.size)
		select.go#L444: 		msanread(cas.elem, c.elemtype.size)
		select.go#L482: 		msanread(cas.elem, c.elemtype.size)
		slice.go#L40: 		tomem, overflow = math.MulUintptr(et.size, uintptr(tolen))
		slice.go#L44: 		copymem = et.size * uintptr(fromlen)
		slice.go#L49: 		tomem = et.size * uintptr(tolen)
		slice.go#L84: 	mem, overflow := math.MulUintptr(et.size, uintptr(cap))
		slice.go#L91: 		mem, overflow := math.MulUintptr(et.size, uintptr(len))
		slice.go#L128: 		racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice))
		slice.go#L131: 		msanread(old.array, uintptr(old.len*int(et.size)))
		slice.go#L138: 	if et.size == 0 {
		slice.go#L172: 	case et.size == 1:
		slice.go#L178: 	case et.size == sys.PtrSize:
		slice.go#L184: 	case isPowerOfTwo(et.size):
		slice.go#L188: 			shift = uintptr(sys.Ctz64(uint64(et.size))) & 63
		slice.go#L190: 			shift = uintptr(sys.Ctz32(uint32(et.size))) & 31
		slice.go#L198: 		lenmem = uintptr(old.len) * et.size
		slice.go#L199: 		newlenmem = uintptr(cap) * et.size
		slice.go#L200: 		capmem, overflow = math.MulUintptr(et.size, uintptr(newcap))
		slice.go#L202: 		newcap = int(capmem / et.size)
		slice.go#L234: 			bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(old.array), lenmem-et.size+et.ptrdata)
		type.go#L32: 	size       uintptr