type runtime._type

122 uses

	runtime (current package)
		alg.go#L144: func typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L213: func reflect_typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L260: func efaceeq(t *_type, x, y unsafe.Pointer) bool {
		cgocall.go#L434: func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
		cgocall.go#L470: 		it := *(**_type)(p)
		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#L206: func cgoCheckUsingType(typ *_type, src unsafe.Pointer, off, size uintptr) {
		chan.go#L38: 	elemtype *_type // element type
		chan.go#L333: func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
		chan.go#L346: func recvDirect(t *_type, sg *sudog, dst unsafe.Pointer) {
		checkptr.go#L9: func checkptrAlignment(p unsafe.Pointer, elem *_type, n uintptr) {
		error.go#L22: 	_interface    *_type
		error.go#L23: 	concrete      *_type
		error.go#L24: 	asserted      *_type
		heapdump.go#L118: 	t [typeCacheAssoc]*_type
		heapdump.go#L164: func dumptype(t *_type) {
		heapdump.go#L226: func dumpfinalizer(obj unsafe.Pointer, fn *funcval, fint *_type, ot *ptrtype) {
		heapdump.go#L424: func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype) {
		iface.go#L28: func itabHashFunc(inter *interfacetype, typ *_type) uintptr {
		iface.go#L33: func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
		iface.go#L96: func (t *itabTableType) find(inter *interfacetype, typ *_type) *itab {
		iface.go#L260: func panicdottypeE(have, want, iface *_type) {
		iface.go#L266: func panicdottypeI(have *itab, want, iface *_type) {
		iface.go#L267: 	var t *_type
		iface.go#L276: func panicnildottype(want *_type) {
		iface.go#L304: 	uint16Type *_type = efaceOf(&uint16Eface)._type
		iface.go#L305: 	uint32Type *_type = efaceOf(&uint32Eface)._type
		iface.go#L306: 	uint64Type *_type = efaceOf(&uint64Eface)._type
		iface.go#L307: 	stringType *_type = efaceOf(&stringEface)._type
		iface.go#L308: 	sliceType  *_type = efaceOf(&sliceEface)._type
		iface.go#L318: func convT2E(t *_type, elem unsafe.Pointer) (e eface) {
		iface.go#L391: func convT2Enoptr(t *_type, elem unsafe.Pointer) (e eface) {
		malloc.go#L905: func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
		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 {
		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#L282: func reflect_typedslicecopy(elemType *_type, dst, src slice) 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) {
		mbitmap.go#L698: func typeBitsBulkBarrier(typ *_type, dst, src, size uintptr) {
		mbitmap.go#L815: func heapBitsSetType(x, size, dataSize uintptr, typ *_type) {
		mfinal.go#L45: 	fint *_type         // type of first argument of fn
		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)) {
		mgcstack.go#L155: 	typ   *_type       // type info (for ptr/nonptr bits). nil if object has been scanned.
		mgcstack.go#L162: func (obj *stackObject) setType(typ *_type) {
		mgcstack.go#L274: func (s *stackScanState) addObject(addr uintptr, typ *_type) {
		mheap.go#L1776: 	fint    *_type   // May be a heap pointer, but always live.
		mheap.go#L1781: func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool {
		mprof.go#L841: func tracealloc(p unsafe.Pointer, size uintptr, typ *_type) {
		netpoll.go#L567: 	pdType  *_type      = efaceOf(&pdEface)._type
		panic.go#L376: var deferType *_type // type of _defer struct
		plugin.go#L82: 		t := (*_type)(unsafe.Pointer(md.types)).typeOff(ptab.typ)
		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") }
		runtime1.go#L504: 	return unsafe.Pointer((*_type)(rtype).typeOff(typeOff(off)))
		runtime1.go#L510: 	return (*_type)(rtype).textOff(textOff(off))
		runtime1.go#L523: 	return unsafe.Pointer((*_type)(rtype).typeOff(typeOff(off)))
		runtime2.go#L209: 	_type *_type
		runtime2.go#L859: 	_type *_type
		slice.go#L36: func makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) 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#L125: func growslice(et *_type, old slice, cap int) slice {
		stack.go#L1326: 	typ *_type
		stubs.go#L190: func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)
		symtab.go#L392: 	typemap map[typeOff]*_type // offset to *_rtype in previous module
		symtab.go#L424: var pinnedTypemaps []map[typeOff]*_type
		type.go#L31: type _type struct {
		type.go#L50: func (t *_type) string() string {
		type.go#L58: func (t *_type) uncommon() *uncommontype {
		type.go#L113: 			_type
		type.go#L120: func (t *_type) name() string {
		type.go#L136: func (t *_type) pkgpath() string {
		type.go#L215: func (t *_type) nameOff(off nameOff) name {
		type.go#L219: func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {
		type.go#L244: 		return (*_type)(res)
		type.go#L254: 	return (*_type)(unsafe.Pointer(res))
		type.go#L257: func (t *_type) typeOff(off typeOff) *_type {
		type.go#L261: func (t *_type) textOff(off textOff) unsafe.Pointer {
		type.go#L319: func (t *functype) in() []*_type {
		type.go#L325: 	return (*[1 << 20]*_type)(add(unsafe.Pointer(t), uadd))[:t.inCount]
		type.go#L328: func (t *functype) out() []*_type {
		type.go#L335: 	return (*[1 << 20]*_type)(add(unsafe.Pointer(t), uadd))[t.inCount : t.inCount+outCount]
		type.go#L367: 	typ     _type
		type.go#L373: 	typ    _type
		type.go#L374: 	key    *_type
		type.go#L375: 	elem   *_type
		type.go#L376: 	bucket *_type // internal type representing a hash bucket
		type.go#L404: 	typ   _type
		type.go#L405: 	elem  *_type
		type.go#L406: 	slice *_type
		type.go#L411: 	typ  _type
		type.go#L412: 	elem *_type
		type.go#L417: 	typ  _type
		type.go#L418: 	elem *_type
		type.go#L422: 	typ      _type
		type.go#L428: 	typ  _type
		type.go#L429: 	elem *_type
		type.go#L434: 	typ        *_type
		type.go#L443: 	typ     _type
		type.go#L530: 	typehash := make(map[uint32][]*_type, len(firstmoduledata.typelinks))
		type.go#L538: 			var t *_type
		type.go#L540: 				t = (*_type)(unsafe.Pointer(prev.types + uintptr(tl)))
		type.go#L558: 			tm := make(map[typeOff]*_type, len(md.typelinks))
		type.go#L562: 				t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
		type.go#L579: 	t1 *_type
		type.go#L580: 	t2 *_type
		type.go#L595: func typesEqual(t, v *_type, seen map[_typePair]struct{}) bool {
		typekind.go#L41: func isDirectIface(t *_type) bool {