type.go

Documentation: runtime

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Runtime type representation.
     6  
     7  package runtime
     8  
     9  import "unsafe"
    10  
    11  // tflag is documented in reflect/type.go.
    12  //
    13  // tflag values must be kept in sync with copies in:
    14  //	cmd/compile/internal/reflectdata/reflect.go
    15  //	cmd/link/internal/ld/decodesym.go
    16  //	reflect/type.go
    17  //      internal/reflectlite/type.go
    18  type tflag uint8
    19  
    20  const (
    21  	tflagUncommon      tflag = 1 << 0
    22  	tflagExtraStar     tflag = 1 << 1
    23  	tflagNamed         tflag = 1 << 2
    24  	tflagRegularMemory tflag = 1 << 3 // equal and hash can treat values of this type as a single region of t.size bytes
    25  )
    26  
    27  // Needs to be in sync with ../cmd/link/internal/ld/decodesym.go:/^func.commonsize,
    28  // ../cmd/compile/internal/reflectdata/reflect.go:/^func.dcommontype and
    29  // ../reflect/type.go:/^type.rtype.
    30  // ../internal/reflectlite/type.go:/^type.rtype.
    31  type _type struct {
    32  	size       uintptr
    33  	ptrdata    uintptr // size of memory prefix holding all pointers
    34  	hash       uint32
    35  	tflag      tflag
    36  	align      uint8
    37  	fieldAlign uint8
    38  	kind       uint8
    39  	// function for comparing objects of this type
    40  	// (ptr to object A, ptr to object B) -> ==?
    41  	equal func(unsafe.Pointer, unsafe.Pointer) bool
    42  	// gcdata stores the GC type data for the garbage collector.
    43  	// If the KindGCProg bit is set in kind, gcdata is a GC program.
    44  	// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
    45  	gcdata    *byte
    46  	str       nameOff
    47  	ptrToThis typeOff
    48  }
    49  
    50  func (t *_type) string() string {
    51  	s := t.nameOff(t.str).name()
    52  	if t.tflag&tflagExtraStar != 0 {
    53  		return s[1:]
    54  	}
    55  	return s
    56  }
    57  
    58  func (t *_type) uncommon() *uncommontype {
    59  	if t.tflag&tflagUncommon == 0 {
    60  		return nil
    61  	}
    62  	switch t.kind & kindMask {
    63  	case kindStruct:
    64  		type u struct {
    65  			structtype
    66  			u uncommontype
    67  		}
    68  		return &(*u)(unsafe.Pointer(t)).u
    69  	case kindPtr:
    70  		type u struct {
    71  			ptrtype
    72  			u uncommontype
    73  		}
    74  		return &(*u)(unsafe.Pointer(t)).u
    75  	case kindFunc:
    76  		type u struct {
    77  			functype
    78  			u uncommontype
    79  		}
    80  		return &(*u)(unsafe.Pointer(t)).u
    81  	case kindSlice:
    82  		type u struct {
    83  			slicetype
    84  			u uncommontype
    85  		}
    86  		return &(*u)(unsafe.Pointer(t)).u
    87  	case kindArray:
    88  		type u struct {
    89  			arraytype
    90  			u uncommontype
    91  		}
    92  		return &(*u)(unsafe.Pointer(t)).u
    93  	case kindChan:
    94  		type u struct {
    95  			chantype
    96  			u uncommontype
    97  		}
    98  		return &(*u)(unsafe.Pointer(t)).u
    99  	case kindMap:
   100  		type u struct {
   101  			maptype
   102  			u uncommontype
   103  		}
   104  		return &(*u)(unsafe.Pointer(t)).u
   105  	case kindInterface:
   106  		type u struct {
   107  			interfacetype
   108  			u uncommontype
   109  		}
   110  		return &(*u)(unsafe.Pointer(t)).u
   111  	default:
   112  		type u struct {
   113  			_type
   114  			u uncommontype
   115  		}
   116  		return &(*u)(unsafe.Pointer(t)).u
   117  	}
   118  }
   119  
   120  func (t *_type) name() string {
   121  	if t.tflag&tflagNamed == 0 {
   122  		return ""
   123  	}
   124  	s := t.string()
   125  	i := len(s) - 1
   126  	for i >= 0 && s[i] != '.' {
   127  		i--
   128  	}
   129  	return s[i+1:]
   130  }
   131  
   132  // pkgpath returns the path of the package where t was defined, if
   133  // available. This is not the same as the reflect package's PkgPath
   134  // method, in that it returns the package path for struct and interface
   135  // types, not just named types.
   136  func (t *_type) pkgpath() string {
   137  	if u := t.uncommon(); u != nil {
   138  		return t.nameOff(u.pkgpath).name()
   139  	}
   140  	switch t.kind & kindMask {
   141  	case kindStruct:
   142  		st := (*structtype)(unsafe.Pointer(t))
   143  		return st.pkgPath.name()
   144  	case kindInterface:
   145  		it := (*interfacetype)(unsafe.Pointer(t))
   146  		return it.pkgpath.name()
   147  	}
   148  	return ""
   149  }
   150  
   151  // reflectOffs holds type offsets defined at run time by the reflect package.
   152  //
   153  // When a type is defined at run time, its *rtype data lives on the heap.
   154  // There are a wide range of possible addresses the heap may use, that
   155  // may not be representable as a 32-bit offset. Moreover the GC may
   156  // one day start moving heap memory, in which case there is no stable
   157  // offset that can be defined.
   158  //
   159  // To provide stable offsets, we add pin *rtype objects in a global map
   160  // and treat the offset as an identifier. We use negative offsets that
   161  // do not overlap with any compile-time module offsets.
   162  //
   163  // Entries are created by reflect.addReflectOff.
   164  var reflectOffs struct {
   165  	lock mutex
   166  	next int32
   167  	m    map[int32]unsafe.Pointer
   168  	minv map[unsafe.Pointer]int32
   169  }
   170  
   171  func reflectOffsLock() {
   172  	lock(&reflectOffs.lock)
   173  	if raceenabled {
   174  		raceacquire(unsafe.Pointer(&reflectOffs.lock))
   175  	}
   176  }
   177  
   178  func reflectOffsUnlock() {
   179  	if raceenabled {
   180  		racerelease(unsafe.Pointer(&reflectOffs.lock))
   181  	}
   182  	unlock(&reflectOffs.lock)
   183  }
   184  
   185  func resolveNameOff(ptrInModule unsafe.Pointer, off nameOff) name {
   186  	if off == 0 {
   187  		return name{}
   188  	}
   189  	base := uintptr(ptrInModule)
   190  	for md := &firstmoduledata; md != nil; md = md.next {
   191  		if base >= md.types && base < md.etypes {
   192  			res := md.types + uintptr(off)
   193  			if res > md.etypes {
   194  				println("runtime: nameOff", hex(off), "out of range", hex(md.types), "-", hex(md.etypes))
   195  				throw("runtime: name offset out of range")
   196  			}
   197  			return name{(*byte)(unsafe.Pointer(res))}
   198  		}
   199  	}
   200  
   201  	// No module found. see if it is a run time name.
   202  	reflectOffsLock()
   203  	res, found := reflectOffs.m[int32(off)]
   204  	reflectOffsUnlock()
   205  	if !found {
   206  		println("runtime: nameOff", hex(off), "base", hex(base), "not in ranges:")
   207  		for next := &firstmoduledata; next != nil; next = next.next {
   208  			println("\ttypes", hex(next.types), "etypes", hex(next.etypes))
   209  		}
   210  		throw("runtime: name offset base pointer out of range")
   211  	}
   212  	return name{(*byte)(res)}
   213  }
   214  
   215  func (t *_type) nameOff(off nameOff) name {
   216  	return resolveNameOff(unsafe.Pointer(t), off)
   217  }
   218  
   219  func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {
   220  	if off == 0 || off == -1 {
   221  		// -1 is the sentinel value for unreachable code.
   222  		// See cmd/link/internal/ld/data.go:relocsym.
   223  		return nil
   224  	}
   225  	base := uintptr(ptrInModule)
   226  	var md *moduledata
   227  	for next := &firstmoduledata; next != nil; next = next.next {
   228  		if base >= next.types && base < next.etypes {
   229  			md = next
   230  			break
   231  		}
   232  	}
   233  	if md == nil {
   234  		reflectOffsLock()
   235  		res := reflectOffs.m[int32(off)]
   236  		reflectOffsUnlock()
   237  		if res == nil {
   238  			println("runtime: typeOff", hex(off), "base", hex(base), "not in ranges:")
   239  			for next := &firstmoduledata; next != nil; next = next.next {
   240  				println("\ttypes", hex(next.types), "etypes", hex(next.etypes))
   241  			}
   242  			throw("runtime: type offset base pointer out of range")
   243  		}
   244  		return (*_type)(res)
   245  	}
   246  	if t := md.typemap[off]; t != nil {
   247  		return t
   248  	}
   249  	res := md.types + uintptr(off)
   250  	if res > md.etypes {
   251  		println("runtime: typeOff", hex(off), "out of range", hex(md.types), "-", hex(md.etypes))
   252  		throw("runtime: type offset out of range")
   253  	}
   254  	return (*_type)(unsafe.Pointer(res))
   255  }
   256  
   257  func (t *_type) typeOff(off typeOff) *_type {
   258  	return resolveTypeOff(unsafe.Pointer(t), off)
   259  }
   260  
   261  func (t *_type) textOff(off textOff) unsafe.Pointer {
   262  	if off == -1 {
   263  		// -1 is the sentinel value for unreachable code.
   264  		// See cmd/link/internal/ld/data.go:relocsym.
   265  		return unsafe.Pointer(funcPC(unreachableMethod))
   266  	}
   267  	base := uintptr(unsafe.Pointer(t))
   268  	var md *moduledata
   269  	for next := &firstmoduledata; next != nil; next = next.next {
   270  		if base >= next.types && base < next.etypes {
   271  			md = next
   272  			break
   273  		}
   274  	}
   275  	if md == nil {
   276  		reflectOffsLock()
   277  		res := reflectOffs.m[int32(off)]
   278  		reflectOffsUnlock()
   279  		if res == nil {
   280  			println("runtime: textOff", hex(off), "base", hex(base), "not in ranges:")
   281  			for next := &firstmoduledata; next != nil; next = next.next {
   282  				println("\ttypes", hex(next.types), "etypes", hex(next.etypes))
   283  			}
   284  			throw("runtime: text offset base pointer out of range")
   285  		}
   286  		return res
   287  	}
   288  	res := uintptr(0)
   289  
   290  	// The text, or instruction stream is generated as one large buffer.  The off (offset) for a method is
   291  	// its offset within this buffer.  If the total text size gets too large, there can be issues on platforms like ppc64 if
   292  	// the target of calls are too far for the call instruction.  To resolve the large text issue, the text is split
   293  	// into multiple text sections to allow the linker to generate long calls when necessary.  When this happens, the vaddr
   294  	// for each text section is set to its offset within the text.  Each method's offset is compared against the section
   295  	// vaddrs and sizes to determine the containing section.  Then the section relative offset is added to the section's
   296  	// relocated baseaddr to compute the method addess.
   297  
   298  	if len(md.textsectmap) > 1 {
   299  		for i := range md.textsectmap {
   300  			sectaddr := md.textsectmap[i].vaddr
   301  			sectlen := md.textsectmap[i].length
   302  			if uintptr(off) >= sectaddr && uintptr(off) < sectaddr+sectlen {
   303  				res = md.textsectmap[i].baseaddr + uintptr(off) - uintptr(md.textsectmap[i].vaddr)
   304  				break
   305  			}
   306  		}
   307  	} else {
   308  		// single text section
   309  		res = md.text + uintptr(off)
   310  	}
   311  
   312  	if res > md.etext && GOARCH != "wasm" { // on wasm, functions do not live in the same address space as the linear memory
   313  		println("runtime: textOff", hex(off), "out of range", hex(md.text), "-", hex(md.etext))
   314  		throw("runtime: text offset out of range")
   315  	}
   316  	return unsafe.Pointer(res)
   317  }
   318  
   319  func (t *functype) in() []*_type {
   320  	// See funcType in reflect/type.go for details on data layout.
   321  	uadd := uintptr(unsafe.Sizeof(functype{}))
   322  	if t.typ.tflag&tflagUncommon != 0 {
   323  		uadd += unsafe.Sizeof(uncommontype{})
   324  	}
   325  	return (*[1 << 20]*_type)(add(unsafe.Pointer(t), uadd))[:t.inCount]
   326  }
   327  
   328  func (t *functype) out() []*_type {
   329  	// See funcType in reflect/type.go for details on data layout.
   330  	uadd := uintptr(unsafe.Sizeof(functype{}))
   331  	if t.typ.tflag&tflagUncommon != 0 {
   332  		uadd += unsafe.Sizeof(uncommontype{})
   333  	}
   334  	outCount := t.outCount & (1<<15 - 1)
   335  	return (*[1 << 20]*_type)(add(unsafe.Pointer(t), uadd))[t.inCount : t.inCount+outCount]
   336  }
   337  
   338  func (t *functype) dotdotdot() bool {
   339  	return t.outCount&(1<<15) != 0
   340  }
   341  
   342  type nameOff int32
   343  type typeOff int32
   344  type textOff int32
   345  
   346  type method struct {
   347  	name nameOff
   348  	mtyp typeOff
   349  	ifn  textOff
   350  	tfn  textOff
   351  }
   352  
   353  type uncommontype struct {
   354  	pkgpath nameOff
   355  	mcount  uint16 // number of methods
   356  	xcount  uint16 // number of exported methods
   357  	moff    uint32 // offset from this uncommontype to [mcount]method
   358  	_       uint32 // unused
   359  }
   360  
   361  type imethod struct {
   362  	name nameOff
   363  	ityp typeOff
   364  }
   365  
   366  type interfacetype struct {
   367  	typ     _type
   368  	pkgpath name
   369  	mhdr    []imethod
   370  }
   371  
   372  type maptype struct {
   373  	typ    _type
   374  	key    *_type
   375  	elem   *_type
   376  	bucket *_type // internal type representing a hash bucket
   377  	// function for hashing keys (ptr to key, seed) -> hash
   378  	hasher     func(unsafe.Pointer, uintptr) uintptr
   379  	keysize    uint8  // size of key slot
   380  	elemsize   uint8  // size of elem slot
   381  	bucketsize uint16 // size of bucket
   382  	flags      uint32
   383  }
   384  
   385  // Note: flag values must match those used in the TMAP case
   386  // in ../cmd/compile/internal/reflectdata/reflect.go:writeType.
   387  func (mt *maptype) indirectkey() bool { // store ptr to key instead of key itself
   388  	return mt.flags&1 != 0
   389  }
   390  func (mt *maptype) indirectelem() bool { // store ptr to elem instead of elem itself
   391  	return mt.flags&2 != 0
   392  }
   393  func (mt *maptype) reflexivekey() bool { // true if k==k for all keys
   394  	return mt.flags&4 != 0
   395  }
   396  func (mt *maptype) needkeyupdate() bool { // true if we need to update key on an overwrite
   397  	return mt.flags&8 != 0
   398  }
   399  func (mt *maptype) hashMightPanic() bool { // true if hash function might panic
   400  	return mt.flags&16 != 0
   401  }
   402  
   403  type arraytype struct {
   404  	typ   _type
   405  	elem  *_type
   406  	slice *_type
   407  	len   uintptr
   408  }
   409  
   410  type chantype struct {
   411  	typ  _type
   412  	elem *_type
   413  	dir  uintptr
   414  }
   415  
   416  type slicetype struct {
   417  	typ  _type
   418  	elem *_type
   419  }
   420  
   421  type functype struct {
   422  	typ      _type
   423  	inCount  uint16
   424  	outCount uint16
   425  }
   426  
   427  type ptrtype struct {
   428  	typ  _type
   429  	elem *_type
   430  }
   431  
   432  type structfield struct {
   433  	name       name
   434  	typ        *_type
   435  	offsetAnon uintptr
   436  }
   437  
   438  func (f *structfield) offset() uintptr {
   439  	return f.offsetAnon >> 1
   440  }
   441  
   442  type structtype struct {
   443  	typ     _type
   444  	pkgPath name
   445  	fields  []structfield
   446  }
   447  
   448  // name is an encoded type name with optional extra data.
   449  // See reflect/type.go for details.
   450  type name struct {
   451  	bytes *byte
   452  }
   453  
   454  func (n name) data(off int) *byte {
   455  	return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off)))
   456  }
   457  
   458  func (n name) isExported() bool {
   459  	return (*n.bytes)&(1<<0) != 0
   460  }
   461  
   462  func (n name) readvarint(off int) (int, int) {
   463  	v := 0
   464  	for i := 0; ; i++ {
   465  		x := *n.data(off + i)
   466  		v += int(x&0x7f) << (7 * i)
   467  		if x&0x80 == 0 {
   468  			return i + 1, v
   469  		}
   470  	}
   471  }
   472  
   473  func (n name) name() (s string) {
   474  	if n.bytes == nil {
   475  		return ""
   476  	}
   477  	i, l := n.readvarint(1)
   478  	if l == 0 {
   479  		return ""
   480  	}
   481  	hdr := (*stringStruct)(unsafe.Pointer(&s))
   482  	hdr.str = unsafe.Pointer(n.data(1 + i))
   483  	hdr.len = l
   484  	return
   485  }
   486  
   487  func (n name) tag() (s string) {
   488  	if *n.data(0)&(1<<1) == 0 {
   489  		return ""
   490  	}
   491  	i, l := n.readvarint(1)
   492  	i2, l2 := n.readvarint(1 + i + l)
   493  	hdr := (*stringStruct)(unsafe.Pointer(&s))
   494  	hdr.str = unsafe.Pointer(n.data(1 + i + l + i2))
   495  	hdr.len = l2
   496  	return
   497  }
   498  
   499  func (n name) pkgPath() string {
   500  	if n.bytes == nil || *n.data(0)&(1<<2) == 0 {
   501  		return ""
   502  	}
   503  	i, l := n.readvarint(1)
   504  	off := 1 + i + l
   505  	if *n.data(0)&(1<<1) != 0 {
   506  		i2, l2 := n.readvarint(off)
   507  		off += i2 + l2
   508  	}
   509  	var nameOff nameOff
   510  	copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off)))[:])
   511  	pkgPathName := resolveNameOff(unsafe.Pointer(n.bytes), nameOff)
   512  	return pkgPathName.name()
   513  }
   514  
   515  func (n name) isBlank() bool {
   516  	if n.bytes == nil {
   517  		return false
   518  	}
   519  	_, l := n.readvarint(1)
   520  	return l == 1 && *n.data(2) == '_'
   521  }
   522  
   523  // typelinksinit scans the types from extra modules and builds the
   524  // moduledata typemap used to de-duplicate type pointers.
   525  func typelinksinit() {
   526  	if firstmoduledata.next == nil {
   527  		return
   528  	}
   529  	typehash := make(map[uint32][]*_type, len(firstmoduledata.typelinks))
   530  
   531  	modules := activeModules()
   532  	prev := modules[0]
   533  	for _, md := range modules[1:] {
   534  		// Collect types from the previous module into typehash.
   535  	collect:
   536  		for _, tl := range prev.typelinks {
   537  			var t *_type
   538  			if prev.typemap == nil {
   539  				t = (*_type)(unsafe.Pointer(prev.types + uintptr(tl)))
   540  			} else {
   541  				t = prev.typemap[typeOff(tl)]
   542  			}
   543  			// Add to typehash if not seen before.
   544  			tlist := typehash[t.hash]
   545  			for _, tcur := range tlist {
   546  				if tcur == t {
   547  					continue collect
   548  				}
   549  			}
   550  			typehash[t.hash] = append(tlist, t)
   551  		}
   552  
   553  		if md.typemap == nil {
   554  			// If any of this module's typelinks match a type from a
   555  			// prior module, prefer that prior type by adding the offset
   556  			// to this module's typemap.
   557  			tm := make(map[typeOff]*_type, len(md.typelinks))
   558  			pinnedTypemaps = append(pinnedTypemaps, tm)
   559  			md.typemap = tm
   560  			for _, tl := range md.typelinks {
   561  				t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
   562  				for _, candidate := range typehash[t.hash] {
   563  					seen := map[_typePair]struct{}{}
   564  					if typesEqual(t, candidate, seen) {
   565  						t = candidate
   566  						break
   567  					}
   568  				}
   569  				md.typemap[typeOff(tl)] = t
   570  			}
   571  		}
   572  
   573  		prev = md
   574  	}
   575  }
   576  
   577  type _typePair struct {
   578  	t1 *_type
   579  	t2 *_type
   580  }
   581  
   582  // typesEqual reports whether two types are equal.
   583  //
   584  // Everywhere in the runtime and reflect packages, it is assumed that
   585  // there is exactly one *_type per Go type, so that pointer equality
   586  // can be used to test if types are equal. There is one place that
   587  // breaks this assumption: buildmode=shared. In this case a type can
   588  // appear as two different pieces of memory. This is hidden from the
   589  // runtime and reflect package by the per-module typemap built in
   590  // typelinksinit. It uses typesEqual to map types from later modules
   591  // back into earlier ones.
   592  //
   593  // Only typelinksinit needs this function.
   594  func typesEqual(t, v *_type, seen map[_typePair]struct{}) bool {
   595  	tp := _typePair{t, v}
   596  	if _, ok := seen[tp]; ok {
   597  		return true
   598  	}
   599  
   600  	// mark these types as seen, and thus equivalent which prevents an infinite loop if
   601  	// the two types are identical, but recursively defined and loaded from
   602  	// different modules
   603  	seen[tp] = struct{}{}
   604  
   605  	if t == v {
   606  		return true
   607  	}
   608  	kind := t.kind & kindMask
   609  	if kind != v.kind&kindMask {
   610  		return false
   611  	}
   612  	if t.string() != v.string() {
   613  		return false
   614  	}
   615  	ut := t.uncommon()
   616  	uv := v.uncommon()
   617  	if ut != nil || uv != nil {
   618  		if ut == nil || uv == nil {
   619  			return false
   620  		}
   621  		pkgpatht := t.nameOff(ut.pkgpath).name()
   622  		pkgpathv := v.nameOff(uv.pkgpath).name()
   623  		if pkgpatht != pkgpathv {
   624  			return false
   625  		}
   626  	}
   627  	if kindBool <= kind && kind <= kindComplex128 {
   628  		return true
   629  	}
   630  	switch kind {
   631  	case kindString, kindUnsafePointer:
   632  		return true
   633  	case kindArray:
   634  		at := (*arraytype)(unsafe.Pointer(t))
   635  		av := (*arraytype)(unsafe.Pointer(v))
   636  		return typesEqual(at.elem, av.elem, seen) && at.len == av.len
   637  	case kindChan:
   638  		ct := (*chantype)(unsafe.Pointer(t))
   639  		cv := (*chantype)(unsafe.Pointer(v))
   640  		return ct.dir == cv.dir && typesEqual(ct.elem, cv.elem, seen)
   641  	case kindFunc:
   642  		ft := (*functype)(unsafe.Pointer(t))
   643  		fv := (*functype)(unsafe.Pointer(v))
   644  		if ft.outCount != fv.outCount || ft.inCount != fv.inCount {
   645  			return false
   646  		}
   647  		tin, vin := ft.in(), fv.in()
   648  		for i := 0; i < len(tin); i++ {
   649  			if !typesEqual(tin[i], vin[i], seen) {
   650  				return false
   651  			}
   652  		}
   653  		tout, vout := ft.out(), fv.out()
   654  		for i := 0; i < len(tout); i++ {
   655  			if !typesEqual(tout[i], vout[i], seen) {
   656  				return false
   657  			}
   658  		}
   659  		return true
   660  	case kindInterface:
   661  		it := (*interfacetype)(unsafe.Pointer(t))
   662  		iv := (*interfacetype)(unsafe.Pointer(v))
   663  		if it.pkgpath.name() != iv.pkgpath.name() {
   664  			return false
   665  		}
   666  		if len(it.mhdr) != len(iv.mhdr) {
   667  			return false
   668  		}
   669  		for i := range it.mhdr {
   670  			tm := &it.mhdr[i]
   671  			vm := &iv.mhdr[i]
   672  			// Note the mhdr array can be relocated from
   673  			// another module. See #17724.
   674  			tname := resolveNameOff(unsafe.Pointer(tm), tm.name)
   675  			vname := resolveNameOff(unsafe.Pointer(vm), vm.name)
   676  			if tname.name() != vname.name() {
   677  				return false
   678  			}
   679  			if tname.pkgPath() != vname.pkgPath() {
   680  				return false
   681  			}
   682  			tityp := resolveTypeOff(unsafe.Pointer(tm), tm.ityp)
   683  			vityp := resolveTypeOff(unsafe.Pointer(vm), vm.ityp)
   684  			if !typesEqual(tityp, vityp, seen) {
   685  				return false
   686  			}
   687  		}
   688  		return true
   689  	case kindMap:
   690  		mt := (*maptype)(unsafe.Pointer(t))
   691  		mv := (*maptype)(unsafe.Pointer(v))
   692  		return typesEqual(mt.key, mv.key, seen) && typesEqual(mt.elem, mv.elem, seen)
   693  	case kindPtr:
   694  		pt := (*ptrtype)(unsafe.Pointer(t))
   695  		pv := (*ptrtype)(unsafe.Pointer(v))
   696  		return typesEqual(pt.elem, pv.elem, seen)
   697  	case kindSlice:
   698  		st := (*slicetype)(unsafe.Pointer(t))
   699  		sv := (*slicetype)(unsafe.Pointer(v))
   700  		return typesEqual(st.elem, sv.elem, seen)
   701  	case kindStruct:
   702  		st := (*structtype)(unsafe.Pointer(t))
   703  		sv := (*structtype)(unsafe.Pointer(v))
   704  		if len(st.fields) != len(sv.fields) {
   705  			return false
   706  		}
   707  		if st.pkgPath.name() != sv.pkgPath.name() {
   708  			return false
   709  		}
   710  		for i := range st.fields {
   711  			tf := &st.fields[i]
   712  			vf := &sv.fields[i]
   713  			if tf.name.name() != vf.name.name() {
   714  				return false
   715  			}
   716  			if !typesEqual(tf.typ, vf.typ, seen) {
   717  				return false
   718  			}
   719  			if tf.name.tag() != vf.name.tag() {
   720  				return false
   721  			}
   722  			if tf.offsetAnon != vf.offsetAnon {
   723  				return false
   724  			}
   725  		}
   726  		return true
   727  	default:
   728  		println("runtime: impossible type kind", kind)
   729  		throw("runtime: impossible type kind")
   730  		return false
   731  	}
   732  }
   733
View as plain text