Source file src/reflect/type.go

     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  // Package reflect implements run-time reflection, allowing a program to
     6  // manipulate objects with arbitrary types. The typical use is to take a value
     7  // with static type interface{} and extract its dynamic type information by
     8  // calling TypeOf, which returns a Type.
     9  //
    10  // A call to ValueOf returns a Value representing the run-time data.
    11  // Zero takes a Type and returns a Value representing a zero value
    12  // for that type.
    13  //
    14  // See "The Laws of Reflection" for an introduction to reflection in Go:
    15  // https://golang.org/doc/articles/laws_of_reflection.html
    16  package reflect
    17  
    18  import (
    19  	"internal/unsafeheader"
    20  	"strconv"
    21  	"sync"
    22  	"unicode"
    23  	"unicode/utf8"
    24  	"unsafe"
    25  )
    26  
    27  // Type is the representation of a Go type.
    28  //
    29  // Not all methods apply to all kinds of types. Restrictions,
    30  // if any, are noted in the documentation for each method.
    31  // Use the Kind method to find out the kind of type before
    32  // calling kind-specific methods. Calling a method
    33  // inappropriate to the kind of type causes a run-time panic.
    34  //
    35  // Type values are comparable, such as with the == operator,
    36  // so they can be used as map keys.
    37  // Two Type values are equal if they represent identical types.
    38  type Type interface {
    39  	// Methods applicable to all types.
    40  
    41  	// Align returns the alignment in bytes of a value of
    42  	// this type when allocated in memory.
    43  	Align() int
    44  
    45  	// FieldAlign returns the alignment in bytes of a value of
    46  	// this type when used as a field in a struct.
    47  	FieldAlign() int
    48  
    49  	// Method returns the i'th method in the type's method set.
    50  	// It panics if i is not in the range [0, NumMethod()).
    51  	//
    52  	// For a non-interface type T or *T, the returned Method's Type and Func
    53  	// fields describe a function whose first argument is the receiver,
    54  	// and only exported methods are accessible.
    55  	//
    56  	// For an interface type, the returned Method's Type field gives the
    57  	// method signature, without a receiver, and the Func field is nil.
    58  	//
    59  	// Methods are sorted in lexicographic order.
    60  	Method(int) Method
    61  
    62  	// MethodByName returns the method with that name in the type's
    63  	// method set and a boolean indicating if the method was found.
    64  	//
    65  	// For a non-interface type T or *T, the returned Method's Type and Func
    66  	// fields describe a function whose first argument is the receiver.
    67  	//
    68  	// For an interface type, the returned Method's Type field gives the
    69  	// method signature, without a receiver, and the Func field is nil.
    70  	MethodByName(string) (Method, bool)
    71  
    72  	// NumMethod returns the number of methods accessible using Method.
    73  	//
    74  	// Note that NumMethod counts unexported methods only for interface types.
    75  	NumMethod() int
    76  
    77  	// Name returns the type's name within its package for a defined type.
    78  	// For other (non-defined) types it returns the empty string.
    79  	Name() string
    80  
    81  	// PkgPath returns a defined type's package path, that is, the import path
    82  	// that uniquely identifies the package, such as "encoding/base64".
    83  	// If the type was predeclared (string, error) or not defined (*T, struct{},
    84  	// []int, or A where A is an alias for a non-defined type), the package path
    85  	// will be the empty string.
    86  	PkgPath() string
    87  
    88  	// Size returns the number of bytes needed to store
    89  	// a value of the given type; it is analogous to unsafe.Sizeof.
    90  	Size() uintptr
    91  
    92  	// String returns a string representation of the type.
    93  	// The string representation may use shortened package names
    94  	// (e.g., base64 instead of "encoding/base64") and is not
    95  	// guaranteed to be unique among types. To test for type identity,
    96  	// compare the Types directly.
    97  	String() string
    98  
    99  	// Kind returns the specific kind of this type.
   100  	Kind() Kind
   101  
   102  	// Implements reports whether the type implements the interface type u.
   103  	Implements(u Type) bool
   104  
   105  	// AssignableTo reports whether a value of the type is assignable to type u.
   106  	AssignableTo(u Type) bool
   107  
   108  	// ConvertibleTo reports whether a value of the type is convertible to type u.
   109  	// Even if ConvertibleTo returns true, the conversion may still panic.
   110  	// For example, a slice of type []T is convertible to *[N]T,
   111  	// but the conversion will panic if its length is less than N.
   112  	ConvertibleTo(u Type) bool
   113  
   114  	// Comparable reports whether values of this type are comparable.
   115  	// Even if Comparable returns true, the comparison may still panic.
   116  	// For example, values of interface type are comparable,
   117  	// but the comparison will panic if their dynamic type is not comparable.
   118  	Comparable() bool
   119  
   120  	// Methods applicable only to some types, depending on Kind.
   121  	// The methods allowed for each kind are:
   122  	//
   123  	//	Int*, Uint*, Float*, Complex*: Bits
   124  	//	Array: Elem, Len
   125  	//	Chan: ChanDir, Elem
   126  	//	Func: In, NumIn, Out, NumOut, IsVariadic.
   127  	//	Map: Key, Elem
   128  	//	Ptr: Elem
   129  	//	Slice: Elem
   130  	//	Struct: Field, FieldByIndex, FieldByName, FieldByNameFunc, NumField
   131  
   132  	// Bits returns the size of the type in bits.
   133  	// It panics if the type's Kind is not one of the
   134  	// sized or unsized Int, Uint, Float, or Complex kinds.
   135  	Bits() int
   136  
   137  	// ChanDir returns a channel type's direction.
   138  	// It panics if the type's Kind is not Chan.
   139  	ChanDir() ChanDir
   140  
   141  	// IsVariadic reports whether a function type's final input parameter
   142  	// is a "..." parameter. If so, t.In(t.NumIn() - 1) returns the parameter's
   143  	// implicit actual type []T.
   144  	//
   145  	// For concreteness, if t represents func(x int, y ... float64), then
   146  	//
   147  	//	t.NumIn() == 2
   148  	//	t.In(0) is the reflect.Type for "int"
   149  	//	t.In(1) is the reflect.Type for "[]float64"
   150  	//	t.IsVariadic() == true
   151  	//
   152  	// IsVariadic panics if the type's Kind is not Func.
   153  	IsVariadic() bool
   154  
   155  	// Elem returns a type's element type.
   156  	// It panics if the type's Kind is not Array, Chan, Map, Ptr, or Slice.
   157  	Elem() Type
   158  
   159  	// Field returns a struct type's i'th field.
   160  	// It panics if the type's Kind is not Struct.
   161  	// It panics if i is not in the range [0, NumField()).
   162  	Field(i int) StructField
   163  
   164  	// FieldByIndex returns the nested field corresponding
   165  	// to the index sequence. It is equivalent to calling Field
   166  	// successively for each index i.
   167  	// It panics if the type's Kind is not Struct.
   168  	FieldByIndex(index []int) StructField
   169  
   170  	// FieldByName returns the struct field with the given name
   171  	// and a boolean indicating if the field was found.
   172  	FieldByName(name string) (StructField, bool)
   173  
   174  	// FieldByNameFunc returns the struct field with a name
   175  	// that satisfies the match function and a boolean indicating if
   176  	// the field was found.
   177  	//
   178  	// FieldByNameFunc considers the fields in the struct itself
   179  	// and then the fields in any embedded structs, in breadth first order,
   180  	// stopping at the shallowest nesting depth containing one or more
   181  	// fields satisfying the match function. If multiple fields at that depth
   182  	// satisfy the match function, they cancel each other
   183  	// and FieldByNameFunc returns no match.
   184  	// This behavior mirrors Go's handling of name lookup in
   185  	// structs containing embedded fields.
   186  	FieldByNameFunc(match func(string) bool) (StructField, bool)
   187  
   188  	// In returns the type of a function type's i'th input parameter.
   189  	// It panics if the type's Kind is not Func.
   190  	// It panics if i is not in the range [0, NumIn()).
   191  	In(i int) Type
   192  
   193  	// Key returns a map type's key type.
   194  	// It panics if the type's Kind is not Map.
   195  	Key() Type
   196  
   197  	// Len returns an array type's length.
   198  	// It panics if the type's Kind is not Array.
   199  	Len() int
   200  
   201  	// NumField returns a struct type's field count.
   202  	// It panics if the type's Kind is not Struct.
   203  	NumField() int
   204  
   205  	// NumIn returns a function type's input parameter count.
   206  	// It panics if the type's Kind is not Func.
   207  	NumIn() int
   208  
   209  	// NumOut returns a function type's output parameter count.
   210  	// It panics if the type's Kind is not Func.
   211  	NumOut() int
   212  
   213  	// Out returns the type of a function type's i'th output parameter.
   214  	// It panics if the type's Kind is not Func.
   215  	// It panics if i is not in the range [0, NumOut()).
   216  	Out(i int) Type
   217  
   218  	common() *rtype
   219  	uncommon() *uncommonType
   220  }
   221  
   222  // BUG(rsc): FieldByName and related functions consider struct field names to be equal
   223  // if the names are equal, even if they are unexported names originating
   224  // in different packages. The practical effect of this is that the result of
   225  // t.FieldByName("x") is not well defined if the struct type t contains
   226  // multiple fields named x (embedded from different packages).
   227  // FieldByName may return one of the fields named x or may report that there are none.
   228  // See https://golang.org/issue/4876 for more details.
   229  
   230  /*
   231   * These data structures are known to the compiler (../../cmd/internal/reflectdata/reflect.go).
   232   * A few are known to ../runtime/type.go to convey to debuggers.
   233   * They are also known to ../runtime/type.go.
   234   */
   235  
   236  // A Kind represents the specific kind of type that a Type represents.
   237  // The zero Kind is not a valid kind.
   238  type Kind uint
   239  
   240  const (
   241  	Invalid Kind = iota
   242  	Bool
   243  	Int
   244  	Int8
   245  	Int16
   246  	Int32
   247  	Int64
   248  	Uint
   249  	Uint8
   250  	Uint16
   251  	Uint32
   252  	Uint64
   253  	Uintptr
   254  	Float32
   255  	Float64
   256  	Complex64
   257  	Complex128
   258  	Array
   259  	Chan
   260  	Func
   261  	Interface
   262  	Map
   263  	Ptr
   264  	Slice
   265  	String
   266  	Struct
   267  	UnsafePointer
   268  )
   269  
   270  // tflag is used by an rtype to signal what extra type information is
   271  // available in the memory directly following the rtype value.
   272  //
   273  // tflag values must be kept in sync with copies in:
   274  //	cmd/compile/internal/reflectdata/reflect.go
   275  //	cmd/link/internal/ld/decodesym.go
   276  //	runtime/type.go
   277  type tflag uint8
   278  
   279  const (
   280  	// tflagUncommon means that there is a pointer, *uncommonType,
   281  	// just beyond the outer type structure.
   282  	//
   283  	// For example, if t.Kind() == Struct and t.tflag&tflagUncommon != 0,
   284  	// then t has uncommonType data and it can be accessed as:
   285  	//
   286  	//	type tUncommon struct {
   287  	//		structType
   288  	//		u uncommonType
   289  	//	}
   290  	//	u := &(*tUncommon)(unsafe.Pointer(t)).u
   291  	tflagUncommon tflag = 1 << 0
   292  
   293  	// tflagExtraStar means the name in the str field has an
   294  	// extraneous '*' prefix. This is because for most types T in
   295  	// a program, the type *T also exists and reusing the str data
   296  	// saves binary size.
   297  	tflagExtraStar tflag = 1 << 1
   298  
   299  	// tflagNamed means the type has a name.
   300  	tflagNamed tflag = 1 << 2
   301  
   302  	// tflagRegularMemory means that equal and hash functions can treat
   303  	// this type as a single region of t.size bytes.
   304  	tflagRegularMemory tflag = 1 << 3
   305  )
   306  
   307  // rtype is the common implementation of most values.
   308  // It is embedded in other struct types.
   309  //
   310  // rtype must be kept in sync with ../runtime/type.go:/^type._type.
   311  type rtype struct {
   312  	size       uintptr
   313  	ptrdata    uintptr // number of bytes in the type that can contain pointers
   314  	hash       uint32  // hash of type; avoids computation in hash tables
   315  	tflag      tflag   // extra type information flags
   316  	align      uint8   // alignment of variable with this type
   317  	fieldAlign uint8   // alignment of struct field with this type
   318  	kind       uint8   // enumeration for C
   319  	// function for comparing objects of this type
   320  	// (ptr to object A, ptr to object B) -> ==?
   321  	equal     func(unsafe.Pointer, unsafe.Pointer) bool
   322  	gcdata    *byte   // garbage collection data
   323  	str       nameOff // string form
   324  	ptrToThis typeOff // type for pointer to this type, may be zero
   325  }
   326  
   327  // Method on non-interface type
   328  type method struct {
   329  	name nameOff // name of method
   330  	mtyp typeOff // method type (without receiver)
   331  	ifn  textOff // fn used in interface call (one-word receiver)
   332  	tfn  textOff // fn used for normal method call
   333  }
   334  
   335  // uncommonType is present only for defined types or types with methods
   336  // (if T is a defined type, the uncommonTypes for T and *T have methods).
   337  // Using a pointer to this struct reduces the overall size required
   338  // to describe a non-defined type with no methods.
   339  type uncommonType struct {
   340  	pkgPath nameOff // import path; empty for built-in types like int, string
   341  	mcount  uint16  // number of methods
   342  	xcount  uint16  // number of exported methods
   343  	moff    uint32  // offset from this uncommontype to [mcount]method
   344  	_       uint32  // unused
   345  }
   346  
   347  // ChanDir represents a channel type's direction.
   348  type ChanDir int
   349  
   350  const (
   351  	RecvDir ChanDir             = 1 << iota // <-chan
   352  	SendDir                                 // chan<-
   353  	BothDir = RecvDir | SendDir             // chan
   354  )
   355  
   356  // arrayType represents a fixed array type.
   357  type arrayType struct {
   358  	rtype
   359  	elem  *rtype // array element type
   360  	slice *rtype // slice type
   361  	len   uintptr
   362  }
   363  
   364  // chanType represents a channel type.
   365  type chanType struct {
   366  	rtype
   367  	elem *rtype  // channel element type
   368  	dir  uintptr // channel direction (ChanDir)
   369  }
   370  
   371  // funcType represents a function type.
   372  //
   373  // A *rtype for each in and out parameter is stored in an array that
   374  // directly follows the funcType (and possibly its uncommonType). So
   375  // a function type with one method, one input, and one output is:
   376  //
   377  //	struct {
   378  //		funcType
   379  //		uncommonType
   380  //		[2]*rtype    // [0] is in, [1] is out
   381  //	}
   382  type funcType struct {
   383  	rtype
   384  	inCount  uint16
   385  	outCount uint16 // top bit is set if last input parameter is ...
   386  }
   387  
   388  // imethod represents a method on an interface type
   389  type imethod struct {
   390  	name nameOff // name of method
   391  	typ  typeOff // .(*FuncType) underneath
   392  }
   393  
   394  // interfaceType represents an interface type.
   395  type interfaceType struct {
   396  	rtype
   397  	pkgPath name      // import path
   398  	methods []imethod // sorted by hash
   399  }
   400  
   401  // mapType represents a map type.
   402  type mapType struct {
   403  	rtype
   404  	key    *rtype // map key type
   405  	elem   *rtype // map element (value) type
   406  	bucket *rtype // internal bucket structure
   407  	// function for hashing keys (ptr to key, seed) -> hash
   408  	hasher     func(unsafe.Pointer, uintptr) uintptr
   409  	keysize    uint8  // size of key slot
   410  	valuesize  uint8  // size of value slot
   411  	bucketsize uint16 // size of bucket
   412  	flags      uint32
   413  }
   414  
   415  // ptrType represents a pointer type.
   416  type ptrType struct {
   417  	rtype
   418  	elem *rtype // pointer element (pointed at) type
   419  }
   420  
   421  // sliceType represents a slice type.
   422  type sliceType struct {
   423  	rtype
   424  	elem *rtype // slice element type
   425  }
   426  
   427  // Struct field
   428  type structField struct {
   429  	name        name    // name is always non-empty
   430  	typ         *rtype  // type of field
   431  	offsetEmbed uintptr // byte offset of field<<1 | isEmbedded
   432  }
   433  
   434  func (f *structField) offset() uintptr {
   435  	return f.offsetEmbed >> 1
   436  }
   437  
   438  func (f *structField) embedded() bool {
   439  	return f.offsetEmbed&1 != 0
   440  }
   441  
   442  // structType represents a struct type.
   443  type structType struct {
   444  	rtype
   445  	pkgPath name
   446  	fields  []structField // sorted by offset
   447  }
   448  
   449  // name is an encoded type name with optional extra data.
   450  //
   451  // The first byte is a bit field containing:
   452  //
   453  //	1<<0 the name is exported
   454  //	1<<1 tag data follows the name
   455  //	1<<2 pkgPath nameOff follows the name and tag
   456  //
   457  // Following that, there is a varint-encoded length of the name,
   458  // followed by the name itself.
   459  //
   460  // If tag data is present, it also has a varint-encoded length
   461  // followed by the tag itself.
   462  //
   463  // If the import path follows, then 4 bytes at the end of
   464  // the data form a nameOff. The import path is only set for concrete
   465  // methods that are defined in a different package than their type.
   466  //
   467  // If a name starts with "*", then the exported bit represents
   468  // whether the pointed to type is exported.
   469  //
   470  // Note: this encoding must match here and in:
   471  //   cmd/compile/internal/reflectdata/reflect.go
   472  //   runtime/type.go
   473  //   internal/reflectlite/type.go
   474  //   cmd/link/internal/ld/decodesym.go
   475  
   476  type name struct {
   477  	bytes *byte
   478  }
   479  
   480  func (n name) data(off int, whySafe string) *byte {
   481  	return (*byte)(add(unsafe.Pointer(n.bytes), uintptr(off), whySafe))
   482  }
   483  
   484  func (n name) isExported() bool {
   485  	return (*n.bytes)&(1<<0) != 0
   486  }
   487  
   488  func (n name) hasTag() bool {
   489  	return (*n.bytes)&(1<<1) != 0
   490  }
   491  
   492  // readVarint parses a varint as encoded by encoding/binary.
   493  // It returns the number of encoded bytes and the encoded value.
   494  func (n name) readVarint(off int) (int, int) {
   495  	v := 0
   496  	for i := 0; ; i++ {
   497  		x := *n.data(off+i, "read varint")
   498  		v += int(x&0x7f) << (7 * i)
   499  		if x&0x80 == 0 {
   500  			return i + 1, v
   501  		}
   502  	}
   503  }
   504  
   505  // writeVarint writes n to buf in varint form. Returns the
   506  // number of bytes written. n must be nonnegative.
   507  // Writes at most 10 bytes.
   508  func writeVarint(buf []byte, n int) int {
   509  	for i := 0; ; i++ {
   510  		b := byte(n & 0x7f)
   511  		n >>= 7
   512  		if n == 0 {
   513  			buf[i] = b
   514  			return i + 1
   515  		}
   516  		buf[i] = b | 0x80
   517  	}
   518  }
   519  
   520  func (n name) name() (s string) {
   521  	if n.bytes == nil {
   522  		return
   523  	}
   524  	i, l := n.readVarint(1)
   525  	hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
   526  	hdr.Data = unsafe.Pointer(n.data(1+i, "non-empty string"))
   527  	hdr.Len = l
   528  	return
   529  }
   530  
   531  func (n name) tag() (s string) {
   532  	if !n.hasTag() {
   533  		return ""
   534  	}
   535  	i, l := n.readVarint(1)
   536  	i2, l2 := n.readVarint(1 + i + l)
   537  	hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
   538  	hdr.Data = unsafe.Pointer(n.data(1+i+l+i2, "non-empty string"))
   539  	hdr.Len = l2
   540  	return
   541  }
   542  
   543  func (n name) pkgPath() string {
   544  	if n.bytes == nil || *n.data(0, "name flag field")&(1<<2) == 0 {
   545  		return ""
   546  	}
   547  	i, l := n.readVarint(1)
   548  	off := 1 + i + l
   549  	if n.hasTag() {
   550  		i2, l2 := n.readVarint(off)
   551  		off += i2 + l2
   552  	}
   553  	var nameOff int32
   554  	// Note that this field may not be aligned in memory,
   555  	// so we cannot use a direct int32 assignment here.
   556  	copy((*[4]byte)(unsafe.Pointer(&nameOff))[:], (*[4]byte)(unsafe.Pointer(n.data(off, "name offset field")))[:])
   557  	pkgPathName := name{(*byte)(resolveTypeOff(unsafe.Pointer(n.bytes), nameOff))}
   558  	return pkgPathName.name()
   559  }
   560  
   561  func newName(n, tag string, exported bool) name {
   562  	if len(n) >= 1<<29 {
   563  		panic("reflect.nameFrom: name too long: " + n[:1024] + "...")
   564  	}
   565  	if len(tag) >= 1<<29 {
   566  		panic("reflect.nameFrom: tag too long: " + tag[:1024] + "...")
   567  	}
   568  	var nameLen [10]byte
   569  	var tagLen [10]byte
   570  	nameLenLen := writeVarint(nameLen[:], len(n))
   571  	tagLenLen := writeVarint(tagLen[:], len(tag))
   572  
   573  	var bits byte
   574  	l := 1 + nameLenLen + len(n)
   575  	if exported {
   576  		bits |= 1 << 0
   577  	}
   578  	if len(tag) > 0 {
   579  		l += tagLenLen + len(tag)
   580  		bits |= 1 << 1
   581  	}
   582  
   583  	b := make([]byte, l)
   584  	b[0] = bits
   585  	copy(b[1:], nameLen[:nameLenLen])
   586  	copy(b[1+nameLenLen:], n)
   587  	if len(tag) > 0 {
   588  		tb := b[1+nameLenLen+len(n):]
   589  		copy(tb, tagLen[:tagLenLen])
   590  		copy(tb[tagLenLen:], tag)
   591  	}
   592  
   593  	return name{bytes: &b[0]}
   594  }
   595  
   596  /*
   597   * The compiler knows the exact layout of all the data structures above.
   598   * The compiler does not know about the data structures and methods below.
   599   */
   600  
   601  // Method represents a single method.
   602  type Method struct {
   603  	// Name is the method name.
   604  	Name string
   605  
   606  	// PkgPath is the package path that qualifies a lower case (unexported)
   607  	// method name. It is empty for upper case (exported) method names.
   608  	// The combination of PkgPath and Name uniquely identifies a method
   609  	// in a method set.
   610  	// See https://golang.org/ref/spec#Uniqueness_of_identifiers
   611  	PkgPath string
   612  
   613  	Type  Type  // method type
   614  	Func  Value // func with receiver as first argument
   615  	Index int   // index for Type.Method
   616  }
   617  
   618  // IsExported reports whether the method is exported.
   619  func (m Method) IsExported() bool {
   620  	return m.PkgPath == ""
   621  }
   622  
   623  const (
   624  	kindDirectIface = 1 << 5
   625  	kindGCProg      = 1 << 6 // Type.gc points to GC program
   626  	kindMask        = (1 << 5) - 1
   627  )
   628  
   629  // String returns the name of k.
   630  func (k Kind) String() string {
   631  	if int(k) < len(kindNames) {
   632  		return kindNames[k]
   633  	}
   634  	return "kind" + strconv.Itoa(int(k))
   635  }
   636  
   637  var kindNames = []string{
   638  	Invalid:       "invalid",
   639  	Bool:          "bool",
   640  	Int:           "int",
   641  	Int8:          "int8",
   642  	Int16:         "int16",
   643  	Int32:         "int32",
   644  	Int64:         "int64",
   645  	Uint:          "uint",
   646  	Uint8:         "uint8",
   647  	Uint16:        "uint16",
   648  	Uint32:        "uint32",
   649  	Uint64:        "uint64",
   650  	Uintptr:       "uintptr",
   651  	Float32:       "float32",
   652  	Float64:       "float64",
   653  	Complex64:     "complex64",
   654  	Complex128:    "complex128",
   655  	Array:         "array",
   656  	Chan:          "chan",
   657  	Func:          "func",
   658  	Interface:     "interface",
   659  	Map:           "map",
   660  	Ptr:           "ptr",
   661  	Slice:         "slice",
   662  	String:        "string",
   663  	Struct:        "struct",
   664  	UnsafePointer: "unsafe.Pointer",
   665  }
   666  
   667  func (t *uncommonType) methods() []method {
   668  	if t.mcount == 0 {
   669  		return nil
   670  	}
   671  	return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.mcount > 0"))[:t.mcount:t.mcount]
   672  }
   673  
   674  func (t *uncommonType) exportedMethods() []method {
   675  	if t.xcount == 0 {
   676  		return nil
   677  	}
   678  	return (*[1 << 16]method)(add(unsafe.Pointer(t), uintptr(t.moff), "t.xcount > 0"))[:t.xcount:t.xcount]
   679  }
   680  
   681  // resolveNameOff resolves a name offset from a base pointer.
   682  // The (*rtype).nameOff method is a convenience wrapper for this function.
   683  // Implemented in the runtime package.
   684  func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer
   685  
   686  // resolveTypeOff resolves an *rtype offset from a base type.
   687  // The (*rtype).typeOff method is a convenience wrapper for this function.
   688  // Implemented in the runtime package.
   689  func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
   690  
   691  // resolveTextOff resolves a function pointer offset from a base type.
   692  // The (*rtype).textOff method is a convenience wrapper for this function.
   693  // Implemented in the runtime package.
   694  func resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
   695  
   696  // addReflectOff adds a pointer to the reflection lookup map in the runtime.
   697  // It returns a new ID that can be used as a typeOff or textOff, and will
   698  // be resolved correctly. Implemented in the runtime package.
   699  func addReflectOff(ptr unsafe.Pointer) int32
   700  
   701  // resolveReflectName adds a name to the reflection lookup map in the runtime.
   702  // It returns a new nameOff that can be used to refer to the pointer.
   703  func resolveReflectName(n name) nameOff {
   704  	return nameOff(addReflectOff(unsafe.Pointer(n.bytes)))
   705  }
   706  
   707  // resolveReflectType adds a *rtype to the reflection lookup map in the runtime.
   708  // It returns a new typeOff that can be used to refer to the pointer.
   709  func resolveReflectType(t *rtype) typeOff {
   710  	return typeOff(addReflectOff(unsafe.Pointer(t)))
   711  }
   712  
   713  // resolveReflectText adds a function pointer to the reflection lookup map in
   714  // the runtime. It returns a new textOff that can be used to refer to the
   715  // pointer.
   716  func resolveReflectText(ptr unsafe.Pointer) textOff {
   717  	return textOff(addReflectOff(ptr))
   718  }
   719  
   720  type nameOff int32 // offset to a name
   721  type typeOff int32 // offset to an *rtype
   722  type textOff int32 // offset from top of text section
   723  
   724  func (t *rtype) nameOff(off nameOff) name {
   725  	return name{(*byte)(resolveNameOff(unsafe.Pointer(t), int32(off)))}
   726  }
   727  
   728  func (t *rtype) typeOff(off typeOff) *rtype {
   729  	return (*rtype)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
   730  }
   731  
   732  func (t *rtype) textOff(off textOff) unsafe.Pointer {
   733  	return resolveTextOff(unsafe.Pointer(t), int32(off))
   734  }
   735  
   736  func (t *rtype) uncommon() *uncommonType {
   737  	if t.tflag&tflagUncommon == 0 {
   738  		return nil
   739  	}
   740  	switch t.Kind() {
   741  	case Struct:
   742  		return &(*structTypeUncommon)(unsafe.Pointer(t)).u
   743  	case Ptr:
   744  		type u struct {
   745  			ptrType
   746  			u uncommonType
   747  		}
   748  		return &(*u)(unsafe.Pointer(t)).u
   749  	case Func:
   750  		type u struct {
   751  			funcType
   752  			u uncommonType
   753  		}
   754  		return &(*u)(unsafe.Pointer(t)).u
   755  	case Slice:
   756  		type u struct {
   757  			sliceType
   758  			u uncommonType
   759  		}
   760  		return &(*u)(unsafe.Pointer(t)).u
   761  	case Array:
   762  		type u struct {
   763  			arrayType
   764  			u uncommonType
   765  		}
   766  		return &(*u)(unsafe.Pointer(t)).u
   767  	case Chan:
   768  		type u struct {
   769  			chanType
   770  			u uncommonType
   771  		}
   772  		return &(*u)(unsafe.Pointer(t)).u
   773  	case Map:
   774  		type u struct {
   775  			mapType
   776  			u uncommonType
   777  		}
   778  		return &(*u)(unsafe.Pointer(t)).u
   779  	case Interface:
   780  		type u struct {
   781  			interfaceType
   782  			u uncommonType
   783  		}
   784  		return &(*u)(unsafe.Pointer(t)).u
   785  	default:
   786  		type u struct {
   787  			rtype
   788  			u uncommonType
   789  		}
   790  		return &(*u)(unsafe.Pointer(t)).u
   791  	}
   792  }
   793  
   794  func (t *rtype) String() string {
   795  	s := t.nameOff(t.str).name()
   796  	if t.tflag&tflagExtraStar != 0 {
   797  		return s[1:]
   798  	}
   799  	return s
   800  }
   801  
   802  func (t *rtype) Size() uintptr { return t.size }
   803  
   804  func (t *rtype) Bits() int {
   805  	if t == nil {
   806  		panic("reflect: Bits of nil Type")
   807  	}
   808  	k := t.Kind()
   809  	if k < Int || k > Complex128 {
   810  		panic("reflect: Bits of non-arithmetic Type " + t.String())
   811  	}
   812  	return int(t.size) * 8
   813  }
   814  
   815  func (t *rtype) Align() int { return int(t.align) }
   816  
   817  func (t *rtype) FieldAlign() int { return int(t.fieldAlign) }
   818  
   819  func (t *rtype) Kind() Kind { return Kind(t.kind & kindMask) }
   820  
   821  func (t *rtype) pointers() bool { return t.ptrdata != 0 }
   822  
   823  func (t *rtype) common() *rtype { return t }
   824  
   825  func (t *rtype) exportedMethods() []method {
   826  	ut := t.uncommon()
   827  	if ut == nil {
   828  		return nil
   829  	}
   830  	return ut.exportedMethods()
   831  }
   832  
   833  func (t *rtype) NumMethod() int {
   834  	if t.Kind() == Interface {
   835  		tt := (*interfaceType)(unsafe.Pointer(t))
   836  		return tt.NumMethod()
   837  	}
   838  	return len(t.exportedMethods())
   839  }
   840  
   841  func (t *rtype) Method(i int) (m Method) {
   842  	if t.Kind() == Interface {
   843  		tt := (*interfaceType)(unsafe.Pointer(t))
   844  		return tt.Method(i)
   845  	}
   846  	methods := t.exportedMethods()
   847  	if i < 0 || i >= len(methods) {
   848  		panic("reflect: Method index out of range")
   849  	}
   850  	p := methods[i]
   851  	pname := t.nameOff(p.name)
   852  	m.Name = pname.name()
   853  	fl := flag(Func)
   854  	mtyp := t.typeOff(p.mtyp)
   855  	ft := (*funcType)(unsafe.Pointer(mtyp))
   856  	in := make([]Type, 0, 1+len(ft.in()))
   857  	in = append(in, t)
   858  	for _, arg := range ft.in() {
   859  		in = append(in, arg)
   860  	}
   861  	out := make([]Type, 0, len(ft.out()))
   862  	for _, ret := range ft.out() {
   863  		out = append(out, ret)
   864  	}
   865  	mt := FuncOf(in, out, ft.IsVariadic())
   866  	m.Type = mt
   867  	tfn := t.textOff(p.tfn)
   868  	fn := unsafe.Pointer(&tfn)
   869  	m.Func = Value{mt.(*rtype), fn, fl}
   870  
   871  	m.Index = i
   872  	return m
   873  }
   874  
   875  func (t *rtype) MethodByName(name string) (m Method, ok bool) {
   876  	if t.Kind() == Interface {
   877  		tt := (*interfaceType)(unsafe.Pointer(t))
   878  		return tt.MethodByName(name)
   879  	}
   880  	ut := t.uncommon()
   881  	if ut == nil {
   882  		return Method{}, false
   883  	}
   884  	// TODO(mdempsky): Binary search.
   885  	for i, p := range ut.exportedMethods() {
   886  		if t.nameOff(p.name).name() == name {
   887  			return t.Method(i), true
   888  		}
   889  	}
   890  	return Method{}, false
   891  }
   892  
   893  func (t *rtype) PkgPath() string {
   894  	if t.tflag&tflagNamed == 0 {
   895  		return ""
   896  	}
   897  	ut := t.uncommon()
   898  	if ut == nil {
   899  		return ""
   900  	}
   901  	return t.nameOff(ut.pkgPath).name()
   902  }
   903  
   904  func (t *rtype) hasName() bool {
   905  	return t.tflag&tflagNamed != 0
   906  }
   907  
   908  func (t *rtype) Name() string {
   909  	if !t.hasName() {
   910  		return ""
   911  	}
   912  	s := t.String()
   913  	i := len(s) - 1
   914  	for i >= 0 && s[i] != '.' {
   915  		i--
   916  	}
   917  	return s[i+1:]
   918  }
   919  
   920  func (t *rtype) ChanDir() ChanDir {
   921  	if t.Kind() != Chan {
   922  		panic("reflect: ChanDir of non-chan type " + t.String())
   923  	}
   924  	tt := (*chanType)(unsafe.Pointer(t))
   925  	return ChanDir(tt.dir)
   926  }
   927  
   928  func (t *rtype) IsVariadic() bool {
   929  	if t.Kind() != Func {
   930  		panic("reflect: IsVariadic of non-func type " + t.String())
   931  	}
   932  	tt := (*funcType)(unsafe.Pointer(t))
   933  	return tt.outCount&(1<<15) != 0
   934  }
   935  
   936  func (t *rtype) Elem() Type {
   937  	switch t.Kind() {
   938  	case Array:
   939  		tt := (*arrayType)(unsafe.Pointer(t))
   940  		return toType(tt.elem)
   941  	case Chan:
   942  		tt := (*chanType)(unsafe.Pointer(t))
   943  		return toType(tt.elem)
   944  	case Map:
   945  		tt := (*mapType)(unsafe.Pointer(t))
   946  		return toType(tt.elem)
   947  	case Ptr:
   948  		tt := (*ptrType)(unsafe.Pointer(t))
   949  		return toType(tt.elem)
   950  	case Slice:
   951  		tt := (*sliceType)(unsafe.Pointer(t))
   952  		return toType(tt.elem)
   953  	}
   954  	panic("reflect: Elem of invalid type " + t.String())
   955  }
   956  
   957  func (t *rtype) Field(i int) StructField {
   958  	if t.Kind() != Struct {
   959  		panic("reflect: Field of non-struct type " + t.String())
   960  	}
   961  	tt := (*structType)(unsafe.Pointer(t))
   962  	return tt.Field(i)
   963  }
   964  
   965  func (t *rtype) FieldByIndex(index []int) StructField {
   966  	if t.Kind() != Struct {
   967  		panic("reflect: FieldByIndex of non-struct type " + t.String())
   968  	}
   969  	tt := (*structType)(unsafe.Pointer(t))
   970  	return tt.FieldByIndex(index)
   971  }
   972  
   973  func (t *rtype) FieldByName(name string) (StructField, bool) {
   974  	if t.Kind() != Struct {
   975  		panic("reflect: FieldByName of non-struct type " + t.String())
   976  	}
   977  	tt := (*structType)(unsafe.Pointer(t))
   978  	return tt.FieldByName(name)
   979  }
   980  
   981  func (t *rtype) FieldByNameFunc(match func(string) bool) (StructField, bool) {
   982  	if t.Kind() != Struct {
   983  		panic("reflect: FieldByNameFunc of non-struct type " + t.String())
   984  	}
   985  	tt := (*structType)(unsafe.Pointer(t))
   986  	return tt.FieldByNameFunc(match)
   987  }
   988  
   989  func (t *rtype) In(i int) Type {
   990  	if t.Kind() != Func {
   991  		panic("reflect: In of non-func type " + t.String())
   992  	}
   993  	tt := (*funcType)(unsafe.Pointer(t))
   994  	return toType(tt.in()[i])
   995  }
   996  
   997  func (t *rtype) Key() Type {
   998  	if t.Kind() != Map {
   999  		panic("reflect: Key of non-map type " + t.String())
  1000  	}
  1001  	tt := (*mapType)(unsafe.Pointer(t))
  1002  	return toType(tt.key)
  1003  }
  1004  
  1005  func (t *rtype) Len() int {
  1006  	if t.Kind() != Array {
  1007  		panic("reflect: Len of non-array type " + t.String())
  1008  	}
  1009  	tt := (*arrayType)(unsafe.Pointer(t))
  1010  	return int(tt.len)
  1011  }
  1012  
  1013  func (t *rtype) NumField() int {
  1014  	if t.Kind() != Struct {
  1015  		panic("reflect: NumField of non-struct type " + t.String())
  1016  	}
  1017  	tt := (*structType)(unsafe.Pointer(t))
  1018  	return len(tt.fields)
  1019  }
  1020  
  1021  func (t *rtype) NumIn() int {
  1022  	if t.Kind() != Func {
  1023  		panic("reflect: NumIn of non-func type " + t.String())
  1024  	}
  1025  	tt := (*funcType)(unsafe.Pointer(t))
  1026  	return int(tt.inCount)
  1027  }
  1028  
  1029  func (t *rtype) NumOut() int {
  1030  	if t.Kind() != Func {
  1031  		panic("reflect: NumOut of non-func type " + t.String())
  1032  	}
  1033  	tt := (*funcType)(unsafe.Pointer(t))
  1034  	return len(tt.out())
  1035  }
  1036  
  1037  func (t *rtype) Out(i int) Type {
  1038  	if t.Kind() != Func {
  1039  		panic("reflect: Out of non-func type " + t.String())
  1040  	}
  1041  	tt := (*funcType)(unsafe.Pointer(t))
  1042  	return toType(tt.out()[i])
  1043  }
  1044  
  1045  func (t *funcType) in() []*rtype {
  1046  	uadd := unsafe.Sizeof(*t)
  1047  	if t.tflag&tflagUncommon != 0 {
  1048  		uadd += unsafe.Sizeof(uncommonType{})
  1049  	}
  1050  	if t.inCount == 0 {
  1051  		return nil
  1052  	}
  1053  	return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.inCount:t.inCount]
  1054  }
  1055  
  1056  func (t *funcType) out() []*rtype {
  1057  	uadd := unsafe.Sizeof(*t)
  1058  	if t.tflag&tflagUncommon != 0 {
  1059  		uadd += unsafe.Sizeof(uncommonType{})
  1060  	}
  1061  	outCount := t.outCount & (1<<15 - 1)
  1062  	if outCount == 0 {
  1063  		return nil
  1064  	}
  1065  	return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "outCount > 0"))[t.inCount : t.inCount+outCount : t.inCount+outCount]
  1066  }
  1067  
  1068  // add returns p+x.
  1069  //
  1070  // The whySafe string is ignored, so that the function still inlines
  1071  // as efficiently as p+x, but all call sites should use the string to
  1072  // record why the addition is safe, which is to say why the addition
  1073  // does not cause x to advance to the very end of p's allocation
  1074  // and therefore point incorrectly at the next block in memory.
  1075  func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
  1076  	return unsafe.Pointer(uintptr(p) + x)
  1077  }
  1078  
  1079  func (d ChanDir) String() string {
  1080  	switch d {
  1081  	case SendDir:
  1082  		return "chan<-"
  1083  	case RecvDir:
  1084  		return "<-chan"
  1085  	case BothDir:
  1086  		return "chan"
  1087  	}
  1088  	return "ChanDir" + strconv.Itoa(int(d))
  1089  }
  1090  
  1091  // Method returns the i'th method in the type's method set.
  1092  func (t *interfaceType) Method(i int) (m Method) {
  1093  	if i < 0 || i >= len(t.methods) {
  1094  		return
  1095  	}
  1096  	p := &t.methods[i]
  1097  	pname := t.nameOff(p.name)
  1098  	m.Name = pname.name()
  1099  	if !pname.isExported() {
  1100  		m.PkgPath = pname.pkgPath()
  1101  		if m.PkgPath == "" {
  1102  			m.PkgPath = t.pkgPath.name()
  1103  		}
  1104  	}
  1105  	m.Type = toType(t.typeOff(p.typ))
  1106  	m.Index = i
  1107  	return
  1108  }
  1109  
  1110  // NumMethod returns the number of interface methods in the type's method set.
  1111  func (t *interfaceType) NumMethod() int { return len(t.methods) }
  1112  
  1113  // MethodByName method with the given name in the type's method set.
  1114  func (t *interfaceType) MethodByName(name string) (m Method, ok bool) {
  1115  	if t == nil {
  1116  		return
  1117  	}
  1118  	var p *imethod
  1119  	for i := range t.methods {
  1120  		p = &t.methods[i]
  1121  		if t.nameOff(p.name).name() == name {
  1122  			return t.Method(i), true
  1123  		}
  1124  	}
  1125  	return
  1126  }
  1127  
  1128  // A StructField describes a single field in a struct.
  1129  type StructField struct {
  1130  	// Name is the field name.
  1131  	Name string
  1132  
  1133  	// PkgPath is the package path that qualifies a lower case (unexported)
  1134  	// field name. It is empty for upper case (exported) field names.
  1135  	// See https://golang.org/ref/spec#Uniqueness_of_identifiers
  1136  	PkgPath string
  1137  
  1138  	Type      Type      // field type
  1139  	Tag       StructTag // field tag string
  1140  	Offset    uintptr   // offset within struct, in bytes
  1141  	Index     []int     // index sequence for Type.FieldByIndex
  1142  	Anonymous bool      // is an embedded field
  1143  }
  1144  
  1145  // IsExported reports whether the field is exported.
  1146  func (f StructField) IsExported() bool {
  1147  	return f.PkgPath == ""
  1148  }
  1149  
  1150  // A StructTag is the tag string in a struct field.
  1151  //
  1152  // By convention, tag strings are a concatenation of
  1153  // optionally space-separated key:"value" pairs.
  1154  // Each key is a non-empty string consisting of non-control
  1155  // characters other than space (U+0020 ' '), quote (U+0022 '"'),
  1156  // and colon (U+003A ':').  Each value is quoted using U+0022 '"'
  1157  // characters and Go string literal syntax.
  1158  type StructTag string
  1159  
  1160  // Get returns the value associated with key in the tag string.
  1161  // If there is no such key in the tag, Get returns the empty string.
  1162  // If the tag does not have the conventional format, the value
  1163  // returned by Get is unspecified. To determine whether a tag is
  1164  // explicitly set to the empty string, use Lookup.
  1165  func (tag StructTag) Get(key string) string {
  1166  	v, _ := tag.Lookup(key)
  1167  	return v
  1168  }
  1169  
  1170  // Lookup returns the value associated with key in the tag string.
  1171  // If the key is present in the tag the value (which may be empty)
  1172  // is returned. Otherwise the returned value will be the empty string.
  1173  // The ok return value reports whether the value was explicitly set in
  1174  // the tag string. If the tag does not have the conventional format,
  1175  // the value returned by Lookup is unspecified.
  1176  func (tag StructTag) Lookup(key string) (value string, ok bool) {
  1177  	// When modifying this code, also update the validateStructTag code
  1178  	// in cmd/vet/structtag.go.
  1179  
  1180  	for tag != "" {
  1181  		// Skip leading space.
  1182  		i := 0
  1183  		for i < len(tag) && tag[i] == ' ' {
  1184  			i++
  1185  		}
  1186  		tag = tag[i:]
  1187  		if tag == "" {
  1188  			break
  1189  		}
  1190  
  1191  		// Scan to colon. A space, a quote or a control character is a syntax error.
  1192  		// Strictly speaking, control chars include the range [0x7f, 0x9f], not just
  1193  		// [0x00, 0x1f], but in practice, we ignore the multi-byte control characters
  1194  		// as it is simpler to inspect the tag's bytes than the tag's runes.
  1195  		i = 0
  1196  		for i < len(tag) && tag[i] > ' ' && tag[i] != ':' && tag[i] != '"' && tag[i] != 0x7f {
  1197  			i++
  1198  		}
  1199  		if i == 0 || i+1 >= len(tag) || tag[i] != ':' || tag[i+1] != '"' {
  1200  			break
  1201  		}
  1202  		name := string(tag[:i])
  1203  		tag = tag[i+1:]
  1204  
  1205  		// Scan quoted string to find value.
  1206  		i = 1
  1207  		for i < len(tag) && tag[i] != '"' {
  1208  			if tag[i] == '\\' {
  1209  				i++
  1210  			}
  1211  			i++
  1212  		}
  1213  		if i >= len(tag) {
  1214  			break
  1215  		}
  1216  		qvalue := string(tag[:i+1])
  1217  		tag = tag[i+1:]
  1218  
  1219  		if key == name {
  1220  			value, err := strconv.Unquote(qvalue)
  1221  			if err != nil {
  1222  				break
  1223  			}
  1224  			return value, true
  1225  		}
  1226  	}
  1227  	return "", false
  1228  }
  1229  
  1230  // Field returns the i'th struct field.
  1231  func (t *structType) Field(i int) (f StructField) {
  1232  	if i < 0 || i >= len(t.fields) {
  1233  		panic("reflect: Field index out of bounds")
  1234  	}
  1235  	p := &t.fields[i]
  1236  	f.Type = toType(p.typ)
  1237  	f.Name = p.name.name()
  1238  	f.Anonymous = p.embedded()
  1239  	if !p.name.isExported() {
  1240  		f.PkgPath = t.pkgPath.name()
  1241  	}
  1242  	if tag := p.name.tag(); tag != "" {
  1243  		f.Tag = StructTag(tag)
  1244  	}
  1245  	f.Offset = p.offset()
  1246  
  1247  	// NOTE(rsc): This is the only allocation in the interface
  1248  	// presented by a reflect.Type. It would be nice to avoid,
  1249  	// at least in the common cases, but we need to make sure
  1250  	// that misbehaving clients of reflect cannot affect other
  1251  	// uses of reflect. One possibility is CL 5371098, but we
  1252  	// postponed that ugliness until there is a demonstrated
  1253  	// need for the performance. This is issue 2320.
  1254  	f.Index = []int{i}
  1255  	return
  1256  }
  1257  
  1258  // TODO(gri): Should there be an error/bool indicator if the index
  1259  //            is wrong for FieldByIndex?
  1260  
  1261  // FieldByIndex returns the nested field corresponding to index.
  1262  func (t *structType) FieldByIndex(index []int) (f StructField) {
  1263  	f.Type = toType(&t.rtype)
  1264  	for i, x := range index {
  1265  		if i > 0 {
  1266  			ft := f.Type
  1267  			if ft.Kind() == Ptr && ft.Elem().Kind() == Struct {
  1268  				ft = ft.Elem()
  1269  			}
  1270  			f.Type = ft
  1271  		}
  1272  		f = f.Type.Field(x)
  1273  	}
  1274  	return
  1275  }
  1276  
  1277  // A fieldScan represents an item on the fieldByNameFunc scan work list.
  1278  type fieldScan struct {
  1279  	typ   *structType
  1280  	index []int
  1281  }
  1282  
  1283  // FieldByNameFunc returns the struct field with a name that satisfies the
  1284  // match function and a boolean to indicate if the field was found.
  1285  func (t *structType) FieldByNameFunc(match func(string) bool) (result StructField, ok bool) {
  1286  	// This uses the same condition that the Go language does: there must be a unique instance
  1287  	// of the match at a given depth level. If there are multiple instances of a match at the
  1288  	// same depth, they annihilate each other and inhibit any possible match at a lower level.
  1289  	// The algorithm is breadth first search, one depth level at a time.
  1290  
  1291  	// The current and next slices are work queues:
  1292  	// current lists the fields to visit on this depth level,
  1293  	// and next lists the fields on the next lower level.
  1294  	current := []fieldScan{}
  1295  	next := []fieldScan{{typ: t}}
  1296  
  1297  	// nextCount records the number of times an embedded type has been
  1298  	// encountered and considered for queueing in the 'next' slice.
  1299  	// We only queue the first one, but we increment the count on each.
  1300  	// If a struct type T can be reached more than once at a given depth level,
  1301  	// then it annihilates itself and need not be considered at all when we
  1302  	// process that next depth level.
  1303  	var nextCount map[*structType]int
  1304  
  1305  	// visited records the structs that have been considered already.
  1306  	// Embedded pointer fields can create cycles in the graph of
  1307  	// reachable embedded types; visited avoids following those cycles.
  1308  	// It also avoids duplicated effort: if we didn't find the field in an
  1309  	// embedded type T at level 2, we won't find it in one at level 4 either.
  1310  	visited := map[*structType]bool{}
  1311  
  1312  	for len(next) > 0 {
  1313  		current, next = next, current[:0]
  1314  		count := nextCount
  1315  		nextCount = nil
  1316  
  1317  		// Process all the fields at this depth, now listed in 'current'.
  1318  		// The loop queues embedded fields found in 'next', for processing during the next
  1319  		// iteration. The multiplicity of the 'current' field counts is recorded
  1320  		// in 'count'; the multiplicity of the 'next' field counts is recorded in 'nextCount'.
  1321  		for _, scan := range current {
  1322  			t := scan.typ
  1323  			if visited[t] {
  1324  				// We've looked through this type before, at a higher level.
  1325  				// That higher level would shadow the lower level we're now at,
  1326  				// so this one can't be useful to us. Ignore it.
  1327  				continue
  1328  			}
  1329  			visited[t] = true
  1330  			for i := range t.fields {
  1331  				f := &t.fields[i]
  1332  				// Find name and (for embedded field) type for field f.
  1333  				fname := f.name.name()
  1334  				var ntyp *rtype
  1335  				if f.embedded() {
  1336  					// Embedded field of type T or *T.
  1337  					ntyp = f.typ
  1338  					if ntyp.Kind() == Ptr {
  1339  						ntyp = ntyp.Elem().common()
  1340  					}
  1341  				}
  1342  
  1343  				// Does it match?
  1344  				if match(fname) {
  1345  					// Potential match
  1346  					if count[t] > 1 || ok {
  1347  						// Name appeared multiple times at this level: annihilate.
  1348  						return StructField{}, false
  1349  					}
  1350  					result = t.Field(i)
  1351  					result.Index = nil
  1352  					result.Index = append(result.Index, scan.index...)
  1353  					result.Index = append(result.Index, i)
  1354  					ok = true
  1355  					continue
  1356  				}
  1357  
  1358  				// Queue embedded struct fields for processing with next level,
  1359  				// but only if we haven't seen a match yet at this level and only
  1360  				// if the embedded types haven't already been queued.
  1361  				if ok || ntyp == nil || ntyp.Kind() != Struct {
  1362  					continue
  1363  				}
  1364  				styp := (*structType)(unsafe.Pointer(ntyp))
  1365  				if nextCount[styp] > 0 {
  1366  					nextCount[styp] = 2 // exact multiple doesn't matter
  1367  					continue
  1368  				}
  1369  				if nextCount == nil {
  1370  					nextCount = map[*structType]int{}
  1371  				}
  1372  				nextCount[styp] = 1
  1373  				if count[t] > 1 {
  1374  					nextCount[styp] = 2 // exact multiple doesn't matter
  1375  				}
  1376  				var index []int
  1377  				index = append(index, scan.index...)
  1378  				index = append(index, i)
  1379  				next = append(next, fieldScan{styp, index})
  1380  			}
  1381  		}
  1382  		if ok {
  1383  			break
  1384  		}
  1385  	}
  1386  	return
  1387  }
  1388  
  1389  // FieldByName returns the struct field with the given name
  1390  // and a boolean to indicate if the field was found.
  1391  func (t *structType) FieldByName(name string) (f StructField, present bool) {
  1392  	// Quick check for top-level name, or struct without embedded fields.
  1393  	hasEmbeds := false
  1394  	if name != "" {
  1395  		for i := range t.fields {
  1396  			tf := &t.fields[i]
  1397  			if tf.name.name() == name {
  1398  				return t.Field(i), true
  1399  			}
  1400  			if tf.embedded() {
  1401  				hasEmbeds = true
  1402  			}
  1403  		}
  1404  	}
  1405  	if !hasEmbeds {
  1406  		return
  1407  	}
  1408  	return t.FieldByNameFunc(func(s string) bool { return s == name })
  1409  }
  1410  
  1411  // TypeOf returns the reflection Type that represents the dynamic type of i.
  1412  // If i is a nil interface value, TypeOf returns nil.
  1413  func TypeOf(i interface{}) Type {
  1414  	eface := *(*emptyInterface)(unsafe.Pointer(&i))
  1415  	return toType(eface.typ)
  1416  }
  1417  
  1418  // ptrMap is the cache for PtrTo.
  1419  var ptrMap sync.Map // map[*rtype]*ptrType
  1420  
  1421  // PtrTo returns the pointer type with element t.
  1422  // For example, if t represents type Foo, PtrTo(t) represents *Foo.
  1423  func PtrTo(t Type) Type {
  1424  	return t.(*rtype).ptrTo()
  1425  }
  1426  
  1427  func (t *rtype) ptrTo() *rtype {
  1428  	if t.ptrToThis != 0 {
  1429  		return t.typeOff(t.ptrToThis)
  1430  	}
  1431  
  1432  	// Check the cache.
  1433  	if pi, ok := ptrMap.Load(t); ok {
  1434  		return &pi.(*ptrType).rtype
  1435  	}
  1436  
  1437  	// Look in known types.
  1438  	s := "*" + t.String()
  1439  	for _, tt := range typesByString(s) {
  1440  		p := (*ptrType)(unsafe.Pointer(tt))
  1441  		if p.elem != t {
  1442  			continue
  1443  		}
  1444  		pi, _ := ptrMap.LoadOrStore(t, p)
  1445  		return &pi.(*ptrType).rtype
  1446  	}
  1447  
  1448  	// Create a new ptrType starting with the description
  1449  	// of an *unsafe.Pointer.
  1450  	var iptr interface{} = (*unsafe.Pointer)(nil)
  1451  	prototype := *(**ptrType)(unsafe.Pointer(&iptr))
  1452  	pp := *prototype
  1453  
  1454  	pp.str = resolveReflectName(newName(s, "", false))
  1455  	pp.ptrToThis = 0
  1456  
  1457  	// For the type structures linked into the binary, the
  1458  	// compiler provides a good hash of the string.
  1459  	// Create a good hash for the new string by using
  1460  	// the FNV-1 hash's mixing function to combine the
  1461  	// old hash and the new "*".
  1462  	pp.hash = fnv1(t.hash, '*')
  1463  
  1464  	pp.elem = t
  1465  
  1466  	pi, _ := ptrMap.LoadOrStore(t, &pp)
  1467  	return &pi.(*ptrType).rtype
  1468  }
  1469  
  1470  // fnv1 incorporates the list of bytes into the hash x using the FNV-1 hash function.
  1471  func fnv1(x uint32, list ...byte) uint32 {
  1472  	for _, b := range list {
  1473  		x = x*16777619 ^ uint32(b)
  1474  	}
  1475  	return x
  1476  }
  1477  
  1478  func (t *rtype) Implements(u Type) bool {
  1479  	if u == nil {
  1480  		panic("reflect: nil type passed to Type.Implements")
  1481  	}
  1482  	if u.Kind() != Interface {
  1483  		panic("reflect: non-interface type passed to Type.Implements")
  1484  	}
  1485  	return implements(u.(*rtype), t)
  1486  }
  1487  
  1488  func (t *rtype) AssignableTo(u Type) bool {
  1489  	if u == nil {
  1490  		panic("reflect: nil type passed to Type.AssignableTo")
  1491  	}
  1492  	uu := u.(*rtype)
  1493  	return directlyAssignable(uu, t) || implements(uu, t)
  1494  }
  1495  
  1496  func (t *rtype) ConvertibleTo(u Type) bool {
  1497  	if u == nil {
  1498  		panic("reflect: nil type passed to Type.ConvertibleTo")
  1499  	}
  1500  	uu := u.(*rtype)
  1501  	return convertOp(uu, t) != nil
  1502  }
  1503  
  1504  func (t *rtype) Comparable() bool {
  1505  	return t.equal != nil
  1506  }
  1507  
  1508  // implements reports whether the type V implements the interface type T.
  1509  func implements(T, V *rtype) bool {
  1510  	if T.Kind() != Interface {
  1511  		return false
  1512  	}
  1513  	t := (*interfaceType)(unsafe.Pointer(T))
  1514  	if len(t.methods) == 0 {
  1515  		return true
  1516  	}
  1517  
  1518  	// The same algorithm applies in both cases, but the
  1519  	// method tables for an interface type and a concrete type
  1520  	// are different, so the code is duplicated.
  1521  	// In both cases the algorithm is a linear scan over the two
  1522  	// lists - T's methods and V's methods - simultaneously.
  1523  	// Since method tables are stored in a unique sorted order
  1524  	// (alphabetical, with no duplicate method names), the scan
  1525  	// through V's methods must hit a match for each of T's
  1526  	// methods along the way, or else V does not implement T.
  1527  	// This lets us run the scan in overall linear time instead of
  1528  	// the quadratic time  a naive search would require.
  1529  	// See also ../runtime/iface.go.
  1530  	if V.Kind() == Interface {
  1531  		v := (*interfaceType)(unsafe.Pointer(V))
  1532  		i := 0
  1533  		for j := 0; j < len(v.methods); j++ {
  1534  			tm := &t.methods[i]
  1535  			tmName := t.nameOff(tm.name)
  1536  			vm := &v.methods[j]
  1537  			vmName := V.nameOff(vm.name)
  1538  			if vmName.name() == tmName.name() && V.typeOff(vm.typ) == t.typeOff(tm.typ) {
  1539  				if !tmName.isExported() {
  1540  					tmPkgPath := tmName.pkgPath()
  1541  					if tmPkgPath == "" {
  1542  						tmPkgPath = t.pkgPath.name()
  1543  					}
  1544  					vmPkgPath := vmName.pkgPath()
  1545  					if vmPkgPath == "" {
  1546  						vmPkgPath = v.pkgPath.name()
  1547  					}
  1548  					if tmPkgPath != vmPkgPath {
  1549  						continue
  1550  					}
  1551  				}
  1552  				if i++; i >= len(t.methods) {
  1553  					return true
  1554  				}
  1555  			}
  1556  		}
  1557  		return false
  1558  	}
  1559  
  1560  	v := V.uncommon()
  1561  	if v == nil {
  1562  		return false
  1563  	}
  1564  	i := 0
  1565  	vmethods := v.methods()
  1566  	for j := 0; j < int(v.mcount); j++ {
  1567  		tm := &t.methods[i]
  1568  		tmName := t.nameOff(tm.name)
  1569  		vm := vmethods[j]
  1570  		vmName := V.nameOff(vm.name)
  1571  		if vmName.name() == tmName.name() && V.typeOff(vm.mtyp) == t.typeOff(tm.typ) {
  1572  			if !tmName.isExported() {
  1573  				tmPkgPath := tmName.pkgPath()
  1574  				if tmPkgPath == "" {
  1575  					tmPkgPath = t.pkgPath.name()
  1576  				}
  1577  				vmPkgPath := vmName.pkgPath()
  1578  				if vmPkgPath == "" {
  1579  					vmPkgPath = V.nameOff(v.pkgPath).name()
  1580  				}
  1581  				if tmPkgPath != vmPkgPath {
  1582  					continue
  1583  				}
  1584  			}
  1585  			if i++; i >= len(t.methods) {
  1586  				return true
  1587  			}
  1588  		}
  1589  	}
  1590  	return false
  1591  }
  1592  
  1593  // specialChannelAssignability reports whether a value x of channel type V
  1594  // can be directly assigned (using memmove) to another channel type T.
  1595  // https://golang.org/doc/go_spec.html#Assignability
  1596  // T and V must be both of Chan kind.
  1597  func specialChannelAssignability(T, V *rtype) bool {
  1598  	// Special case:
  1599  	// x is a bidirectional channel value, T is a channel type,
  1600  	// x's type V and T have identical element types,
  1601  	// and at least one of V or T is not a defined type.
  1602  	return V.ChanDir() == BothDir && (T.Name() == "" || V.Name() == "") && haveIdenticalType(T.Elem(), V.Elem(), true)
  1603  }
  1604  
  1605  // directlyAssignable reports whether a value x of type V can be directly
  1606  // assigned (using memmove) to a value of type T.
  1607  // https://golang.org/doc/go_spec.html#Assignability
  1608  // Ignoring the interface rules (implemented elsewhere)
  1609  // and the ideal constant rules (no ideal constants at run time).
  1610  func directlyAssignable(T, V *rtype) bool {
  1611  	// x's type V is identical to T?
  1612  	if T == V {
  1613  		return true
  1614  	}
  1615  
  1616  	// Otherwise at least one of T and V must not be defined
  1617  	// and they must have the same kind.
  1618  	if T.hasName() && V.hasName() || T.Kind() != V.Kind() {
  1619  		return false
  1620  	}
  1621  
  1622  	if T.Kind() == Chan && specialChannelAssignability(T, V) {
  1623  		return true
  1624  	}
  1625  
  1626  	// x's type T and V must have identical underlying types.
  1627  	return haveIdenticalUnderlyingType(T, V, true)
  1628  }
  1629  
  1630  func haveIdenticalType(T, V Type, cmpTags bool) bool {
  1631  	if cmpTags {
  1632  		return T == V
  1633  	}
  1634  
  1635  	if T.Name() != V.Name() || T.Kind() != V.Kind() || T.PkgPath() != V.PkgPath() {
  1636  		return false
  1637  	}
  1638  
  1639  	return haveIdenticalUnderlyingType(T.common(), V.common(), false)
  1640  }
  1641  
  1642  func haveIdenticalUnderlyingType(T, V *rtype, cmpTags bool) bool {
  1643  	if T == V {
  1644  		return true
  1645  	}
  1646  
  1647  	kind := T.Kind()
  1648  	if kind != V.Kind() {
  1649  		return false
  1650  	}
  1651  
  1652  	// Non-composite types of equal kind have same underlying type
  1653  	// (the predefined instance of the type).
  1654  	if Bool <= kind && kind <= Complex128 || kind == String || kind == UnsafePointer {
  1655  		return true
  1656  	}
  1657  
  1658  	// Composite types.
  1659  	switch kind {
  1660  	case Array:
  1661  		return T.Len() == V.Len() && haveIdenticalType(T.Elem(), V.Elem(), cmpTags)
  1662  
  1663  	case Chan:
  1664  		return V.ChanDir() == T.ChanDir() && haveIdenticalType(T.Elem(), V.Elem(), cmpTags)
  1665  
  1666  	case Func:
  1667  		t := (*funcType)(unsafe.Pointer(T))
  1668  		v := (*funcType)(unsafe.Pointer(V))
  1669  		if t.outCount != v.outCount || t.inCount != v.inCount {
  1670  			return false
  1671  		}
  1672  		for i := 0; i < t.NumIn(); i++ {
  1673  			if !haveIdenticalType(t.In(i), v.In(i), cmpTags) {
  1674  				return false
  1675  			}
  1676  		}
  1677  		for i := 0; i < t.NumOut(); i++ {
  1678  			if !haveIdenticalType(t.Out(i), v.Out(i), cmpTags) {
  1679  				return false
  1680  			}
  1681  		}
  1682  		return true
  1683  
  1684  	case Interface:
  1685  		t := (*interfaceType)(unsafe.Pointer(T))
  1686  		v := (*interfaceType)(unsafe.Pointer(V))
  1687  		if len(t.methods) == 0 && len(v.methods) == 0 {
  1688  			return true
  1689  		}
  1690  		// Might have the same methods but still
  1691  		// need a run time conversion.
  1692  		return false
  1693  
  1694  	case Map:
  1695  		return haveIdenticalType(T.Key(), V.Key(), cmpTags) && haveIdenticalType(T.Elem(), V.Elem(), cmpTags)
  1696  
  1697  	case Ptr, Slice:
  1698  		return haveIdenticalType(T.Elem(), V.Elem(), cmpTags)
  1699  
  1700  	case Struct:
  1701  		t := (*structType)(unsafe.Pointer(T))
  1702  		v := (*structType)(unsafe.Pointer(V))
  1703  		if len(t.fields) != len(v.fields) {
  1704  			return false
  1705  		}
  1706  		if t.pkgPath.name() != v.pkgPath.name() {
  1707  			return false
  1708  		}
  1709  		for i := range t.fields {
  1710  			tf := &t.fields[i]
  1711  			vf := &v.fields[i]
  1712  			if tf.name.name() != vf.name.name() {
  1713  				return false
  1714  			}
  1715  			if !haveIdenticalType(tf.typ, vf.typ, cmpTags) {
  1716  				return false
  1717  			}
  1718  			if cmpTags && tf.name.tag() != vf.name.tag() {
  1719  				return false
  1720  			}
  1721  			if tf.offsetEmbed != vf.offsetEmbed {
  1722  				return false
  1723  			}
  1724  		}
  1725  		return true
  1726  	}
  1727  
  1728  	return false
  1729  }
  1730  
  1731  // typelinks is implemented in package runtime.
  1732  // It returns a slice of the sections in each module,
  1733  // and a slice of *rtype offsets in each module.
  1734  //
  1735  // The types in each module are sorted by string. That is, the first
  1736  // two linked types of the first module are:
  1737  //
  1738  //	d0 := sections[0]
  1739  //	t1 := (*rtype)(add(d0, offset[0][0]))
  1740  //	t2 := (*rtype)(add(d0, offset[0][1]))
  1741  //
  1742  // and
  1743  //
  1744  //	t1.String() < t2.String()
  1745  //
  1746  // Note that strings are not unique identifiers for types:
  1747  // there can be more than one with a given string.
  1748  // Only types we might want to look up are included:
  1749  // pointers, channels, maps, slices, and arrays.
  1750  func typelinks() (sections []unsafe.Pointer, offset [][]int32)
  1751  
  1752  func rtypeOff(section unsafe.Pointer, off int32) *rtype {
  1753  	return (*rtype)(add(section, uintptr(off), "sizeof(rtype) > 0"))
  1754  }
  1755  
  1756  // typesByString returns the subslice of typelinks() whose elements have
  1757  // the given string representation.
  1758  // It may be empty (no known types with that string) or may have
  1759  // multiple elements (multiple types with that string).
  1760  func typesByString(s string) []*rtype {
  1761  	sections, offset := typelinks()
  1762  	var ret []*rtype
  1763  
  1764  	for offsI, offs := range offset {
  1765  		section := sections[offsI]
  1766  
  1767  		// We are looking for the first index i where the string becomes >= s.
  1768  		// This is a copy of sort.Search, with f(h) replaced by (*typ[h].String() >= s).
  1769  		i, j := 0, len(offs)
  1770  		for i < j {
  1771  			h := i + (j-i)>>1 // avoid overflow when computing h
  1772  			// i ≤ h < j
  1773  			if !(rtypeOff(section, offs[h]).String() >= s) {
  1774  				i = h + 1 // preserves f(i-1) == false
  1775  			} else {
  1776  				j = h // preserves f(j) == true
  1777  			}
  1778  		}
  1779  		// i == j, f(i-1) == false, and f(j) (= f(i)) == true  =>  answer is i.
  1780  
  1781  		// Having found the first, linear scan forward to find the last.
  1782  		// We could do a second binary search, but the caller is going
  1783  		// to do a linear scan anyway.
  1784  		for j := i; j < len(offs); j++ {
  1785  			typ := rtypeOff(section, offs[j])
  1786  			if typ.String() != s {
  1787  				break
  1788  			}
  1789  			ret = append(ret, typ)
  1790  		}
  1791  	}
  1792  	return ret
  1793  }
  1794  
  1795  // The lookupCache caches ArrayOf, ChanOf, MapOf and SliceOf lookups.
  1796  var lookupCache sync.Map // map[cacheKey]*rtype
  1797  
  1798  // A cacheKey is the key for use in the lookupCache.
  1799  // Four values describe any of the types we are looking for:
  1800  // type kind, one or two subtypes, and an extra integer.
  1801  type cacheKey struct {
  1802  	kind  Kind
  1803  	t1    *rtype
  1804  	t2    *rtype
  1805  	extra uintptr
  1806  }
  1807  
  1808  // The funcLookupCache caches FuncOf lookups.
  1809  // FuncOf does not share the common lookupCache since cacheKey is not
  1810  // sufficient to represent functions unambiguously.
  1811  var funcLookupCache struct {
  1812  	sync.Mutex // Guards stores (but not loads) on m.
  1813  
  1814  	// m is a map[uint32][]*rtype keyed by the hash calculated in FuncOf.
  1815  	// Elements of m are append-only and thus safe for concurrent reading.
  1816  	m sync.Map
  1817  }
  1818  
  1819  // ChanOf returns the channel type with the given direction and element type.
  1820  // For example, if t represents int, ChanOf(RecvDir, t) represents <-chan int.
  1821  //
  1822  // The gc runtime imposes a limit of 64 kB on channel element types.
  1823  // If t's size is equal to or exceeds this limit, ChanOf panics.
  1824  func ChanOf(dir ChanDir, t Type) Type {
  1825  	typ := t.(*rtype)
  1826  
  1827  	// Look in cache.
  1828  	ckey := cacheKey{Chan, typ, nil, uintptr(dir)}
  1829  	if ch, ok := lookupCache.Load(ckey); ok {
  1830  		return ch.(*rtype)
  1831  	}
  1832  
  1833  	// This restriction is imposed by the gc compiler and the runtime.
  1834  	if typ.size >= 1<<16 {
  1835  		panic("reflect.ChanOf: element size too large")
  1836  	}
  1837  
  1838  	// Look in known types.
  1839  	var s string
  1840  	switch dir {
  1841  	default:
  1842  		panic("reflect.ChanOf: invalid dir")
  1843  	case SendDir:
  1844  		s = "chan<- " + typ.String()
  1845  	case RecvDir:
  1846  		s = "<-chan " + typ.String()
  1847  	case BothDir:
  1848  		typeStr := typ.String()
  1849  		if typeStr[0] == '<' {
  1850  			// typ is recv chan, need parentheses as "<-" associates with leftmost
  1851  			// chan possible, see:
  1852  			// * https://golang.org/ref/spec#Channel_types
  1853  			// * https://github.com/golang/go/issues/39897
  1854  			s = "chan (" + typeStr + ")"
  1855  		} else {
  1856  			s = "chan " + typeStr
  1857  		}
  1858  	}
  1859  	for _, tt := range typesByString(s) {
  1860  		ch := (*chanType)(unsafe.Pointer(tt))
  1861  		if ch.elem == typ && ch.dir == uintptr(dir) {
  1862  			ti, _ := lookupCache.LoadOrStore(ckey, tt)
  1863  			return ti.(Type)
  1864  		}
  1865  	}
  1866  
  1867  	// Make a channel type.
  1868  	var ichan interface{} = (chan unsafe.Pointer)(nil)
  1869  	prototype := *(**chanType)(unsafe.Pointer(&ichan))
  1870  	ch := *prototype
  1871  	ch.tflag = tflagRegularMemory
  1872  	ch.dir = uintptr(dir)
  1873  	ch.str = resolveReflectName(newName(s, "", false))
  1874  	ch.hash = fnv1(typ.hash, 'c', byte(dir))
  1875  	ch.elem = typ
  1876  
  1877  	ti, _ := lookupCache.LoadOrStore(ckey, &ch.rtype)
  1878  	return ti.(Type)
  1879  }
  1880  
  1881  // MapOf returns the map type with the given key and element types.
  1882  // For example, if k represents int and e represents string,
  1883  // MapOf(k, e) represents map[int]string.
  1884  //
  1885  // If the key type is not a valid map key type (that is, if it does
  1886  // not implement Go's == operator), MapOf panics.
  1887  func MapOf(key, elem Type) Type {
  1888  	ktyp := key.(*rtype)
  1889  	etyp := elem.(*rtype)
  1890  
  1891  	if ktyp.equal == nil {
  1892  		panic("reflect.MapOf: invalid key type " + ktyp.String())
  1893  	}
  1894  
  1895  	// Look in cache.
  1896  	ckey := cacheKey{Map, ktyp, etyp, 0}
  1897  	if mt, ok := lookupCache.Load(ckey); ok {
  1898  		return mt.(Type)
  1899  	}
  1900  
  1901  	// Look in known types.
  1902  	s := "map[" + ktyp.String() + "]" + etyp.String()
  1903  	for _, tt := range typesByString(s) {
  1904  		mt := (*mapType)(unsafe.Pointer(tt))
  1905  		if mt.key == ktyp && mt.elem == etyp {
  1906  			ti, _ := lookupCache.LoadOrStore(ckey, tt)
  1907  			return ti.(Type)
  1908  		}
  1909  	}
  1910  
  1911  	// Make a map type.
  1912  	// Note: flag values must match those used in the TMAP case
  1913  	// in ../cmd/compile/internal/reflectdata/reflect.go:writeType.
  1914  	var imap interface{} = (map[unsafe.Pointer]unsafe.Pointer)(nil)
  1915  	mt := **(**mapType)(unsafe.Pointer(&imap))
  1916  	mt.str = resolveReflectName(newName(s, "", false))
  1917  	mt.tflag = 0
  1918  	mt.hash = fnv1(etyp.hash, 'm', byte(ktyp.hash>>24), byte(ktyp.hash>>16), byte(ktyp.hash>>8), byte(ktyp.hash))
  1919  	mt.key = ktyp
  1920  	mt.elem = etyp
  1921  	mt.bucket = bucketOf(ktyp, etyp)
  1922  	mt.hasher = func(p unsafe.Pointer, seed uintptr) uintptr {
  1923  		return typehash(ktyp, p, seed)
  1924  	}
  1925  	mt.flags = 0
  1926  	if ktyp.size > maxKeySize {
  1927  		mt.keysize = uint8(ptrSize)
  1928  		mt.flags |= 1 // indirect key
  1929  	} else {
  1930  		mt.keysize = uint8(ktyp.size)
  1931  	}
  1932  	if etyp.size > maxValSize {
  1933  		mt.valuesize = uint8(ptrSize)
  1934  		mt.flags |= 2 // indirect value
  1935  	} else {
  1936  		mt.valuesize = uint8(etyp.size)
  1937  	}
  1938  	mt.bucketsize = uint16(mt.bucket.size)
  1939  	if isReflexive(ktyp) {
  1940  		mt.flags |= 4
  1941  	}
  1942  	if needKeyUpdate(ktyp) {
  1943  		mt.flags |= 8
  1944  	}
  1945  	if hashMightPanic(ktyp) {
  1946  		mt.flags |= 16
  1947  	}
  1948  	mt.ptrToThis = 0
  1949  
  1950  	ti, _ := lookupCache.LoadOrStore(ckey, &mt.rtype)
  1951  	return ti.(Type)
  1952  }
  1953  
  1954  // TODO(crawshaw): as these funcTypeFixedN structs have no methods,
  1955  // they could be defined at runtime using the StructOf function.
  1956  type funcTypeFixed4 struct {
  1957  	funcType
  1958  	args [4]*rtype
  1959  }
  1960  type funcTypeFixed8 struct {
  1961  	funcType
  1962  	args [8]*rtype
  1963  }
  1964  type funcTypeFixed16 struct {
  1965  	funcType
  1966  	args [16]*rtype
  1967  }
  1968  type funcTypeFixed32 struct {
  1969  	funcType
  1970  	args [32]*rtype
  1971  }
  1972  type funcTypeFixed64 struct {
  1973  	funcType
  1974  	args [64]*rtype
  1975  }
  1976  type funcTypeFixed128 struct {
  1977  	funcType
  1978  	args [128]*rtype
  1979  }
  1980  
  1981  // FuncOf returns the function type with the given argument and result types.
  1982  // For example if k represents int and e represents string,
  1983  // FuncOf([]Type{k}, []Type{e}, false) represents func(int) string.
  1984  //
  1985  // The variadic argument controls whether the function is variadic. FuncOf
  1986  // panics if the in[len(in)-1] does not represent a slice and variadic is
  1987  // true.
  1988  func FuncOf(in, out []Type, variadic bool) Type {
  1989  	if variadic && (len(in) == 0 || in[len(in)-1].Kind() != Slice) {
  1990  		panic("reflect.FuncOf: last arg of variadic func must be slice")
  1991  	}
  1992  
  1993  	// Make a func type.
  1994  	var ifunc interface{} = (func())(nil)
  1995  	prototype := *(**funcType)(unsafe.Pointer(&ifunc))
  1996  	n := len(in) + len(out)
  1997  
  1998  	var ft *funcType
  1999  	var args []*rtype
  2000  	switch {
  2001  	case n <= 4:
  2002  		fixed := new(funcTypeFixed4)
  2003  		args = fixed.args[:0:len(fixed.args)]
  2004  		ft = &fixed.funcType
  2005  	case n <= 8:
  2006  		fixed := new(funcTypeFixed8)
  2007  		args = fixed.args[:0:len(fixed.args)]
  2008  		ft = &fixed.funcType
  2009  	case n <= 16:
  2010  		fixed := new(funcTypeFixed16)
  2011  		args = fixed.args[:0:len(fixed.args)]
  2012  		ft = &fixed.funcType
  2013  	case n <= 32:
  2014  		fixed := new(funcTypeFixed32)
  2015  		args = fixed.args[:0:len(fixed.args)]
  2016  		ft = &fixed.funcType
  2017  	case n <= 64:
  2018  		fixed := new(funcTypeFixed64)
  2019  		args = fixed.args[:0:len(fixed.args)]
  2020  		ft = &fixed.funcType
  2021  	case n <= 128:
  2022  		fixed := new(funcTypeFixed128)
  2023  		args = fixed.args[:0:len(fixed.args)]
  2024  		ft = &fixed.funcType
  2025  	default:
  2026  		panic("reflect.FuncOf: too many arguments")
  2027  	}
  2028  	*ft = *prototype
  2029  
  2030  	// Build a hash and minimally populate ft.
  2031  	var hash uint32
  2032  	for _, in := range in {
  2033  		t := in.(*rtype)
  2034  		args = append(args, t)
  2035  		hash = fnv1(hash, byte(t.hash>>24), byte(t.hash>>16), byte(t.hash>>8), byte(t.hash))
  2036  	}
  2037  	if variadic {
  2038  		hash = fnv1(hash, 'v')
  2039  	}
  2040  	hash = fnv1(hash, '.')
  2041  	for _, out := range out {
  2042  		t := out.(*rtype)
  2043  		args = append(args, t)
  2044  		hash = fnv1(hash, byte(t.hash>>24), byte(t.hash>>16), byte(t.hash>>8), byte(t.hash))
  2045  	}
  2046  	if len(args) > 50 {
  2047  		panic("reflect.FuncOf does not support more than 50 arguments")
  2048  	}
  2049  	ft.tflag = 0
  2050  	ft.hash = hash
  2051  	ft.inCount = uint16(len(in))
  2052  	ft.outCount = uint16(len(out))
  2053  	if variadic {
  2054  		ft.outCount |= 1 << 15
  2055  	}
  2056  
  2057  	// Look in cache.
  2058  	if ts, ok := funcLookupCache.m.Load(hash); ok {
  2059  		for _, t := range ts.([]*rtype) {
  2060  			if haveIdenticalUnderlyingType(&ft.rtype, t, true) {
  2061  				return t
  2062  			}
  2063  		}
  2064  	}
  2065  
  2066  	// Not in cache, lock and retry.
  2067  	funcLookupCache.Lock()
  2068  	defer funcLookupCache.Unlock()
  2069  	if ts, ok := funcLookupCache.m.Load(hash); ok {
  2070  		for _, t := range ts.([]*rtype) {
  2071  			if haveIdenticalUnderlyingType(&ft.rtype, t, true) {
  2072  				return t
  2073  			}
  2074  		}
  2075  	}
  2076  
  2077  	addToCache := func(tt *rtype) Type {
  2078  		var rts []*rtype
  2079  		if rti, ok := funcLookupCache.m.Load(hash); ok {
  2080  			rts = rti.([]*rtype)
  2081  		}
  2082  		funcLookupCache.m.Store(hash, append(rts, tt))
  2083  		return tt
  2084  	}
  2085  
  2086  	// Look in known types for the same string representation.
  2087  	str := funcStr(ft)
  2088  	for _, tt := range typesByString(str) {
  2089  		if haveIdenticalUnderlyingType(&ft.rtype, tt, true) {
  2090  			return addToCache(tt)
  2091  		}
  2092  	}
  2093  
  2094  	// Populate the remaining fields of ft and store in cache.
  2095  	ft.str = resolveReflectName(newName(str, "", false))
  2096  	ft.ptrToThis = 0
  2097  	return addToCache(&ft.rtype)
  2098  }
  2099  
  2100  // funcStr builds a string representation of a funcType.
  2101  func funcStr(ft *funcType) string {
  2102  	repr := make([]byte, 0, 64)
  2103  	repr = append(repr, "func("...)
  2104  	for i, t := range ft.in() {
  2105  		if i > 0 {
  2106  			repr = append(repr, ", "...)
  2107  		}
  2108  		if ft.IsVariadic() && i == int(ft.inCount)-1 {
  2109  			repr = append(repr, "..."...)
  2110  			repr = append(repr, (*sliceType)(unsafe.Pointer(t)).elem.String()...)
  2111  		} else {
  2112  			repr = append(repr, t.String()...)
  2113  		}
  2114  	}
  2115  	repr = append(repr, ')')
  2116  	out := ft.out()
  2117  	if len(out) == 1 {
  2118  		repr = append(repr, ' ')
  2119  	} else if len(out) > 1 {
  2120  		repr = append(repr, " ("...)
  2121  	}
  2122  	for i, t := range out {
  2123  		if i > 0 {
  2124  			repr = append(repr, ", "...)
  2125  		}
  2126  		repr = append(repr, t.String()...)
  2127  	}
  2128  	if len(out) > 1 {
  2129  		repr = append(repr, ')')
  2130  	}
  2131  	return string(repr)
  2132  }
  2133  
  2134  // isReflexive reports whether the == operation on the type is reflexive.
  2135  // That is, x == x for all values x of type t.
  2136  func isReflexive(t *rtype) bool {
  2137  	switch t.Kind() {
  2138  	case Bool, Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr, Chan, Ptr, String, UnsafePointer:
  2139  		return true
  2140  	case Float32, Float64, Complex64, Complex128, Interface:
  2141  		return false
  2142  	case Array:
  2143  		tt := (*arrayType)(unsafe.Pointer(t))
  2144  		return isReflexive(tt.elem)
  2145  	case Struct:
  2146  		tt := (*structType)(unsafe.Pointer(t))
  2147  		for _, f := range tt.fields {
  2148  			if !isReflexive(f.typ) {
  2149  				return false
  2150  			}
  2151  		}
  2152  		return true
  2153  	default:
  2154  		// Func, Map, Slice, Invalid
  2155  		panic("isReflexive called on non-key type " + t.String())
  2156  	}
  2157  }
  2158  
  2159  // needKeyUpdate reports whether map overwrites require the key to be copied.
  2160  func needKeyUpdate(t *rtype) bool {
  2161  	switch t.Kind() {
  2162  	case Bool, Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr, Chan, Ptr, UnsafePointer:
  2163  		return false
  2164  	case Float32, Float64, Complex64, Complex128, Interface, String:
  2165  		// Float keys can be updated from +0 to -0.
  2166  		// String keys can be updated to use a smaller backing store.
  2167  		// Interfaces might have floats of strings in them.
  2168  		return true
  2169  	case Array:
  2170  		tt := (*arrayType)(unsafe.Pointer(t))
  2171  		return needKeyUpdate(tt.elem)
  2172  	case Struct:
  2173  		tt := (*structType)(unsafe.Pointer(t))
  2174  		for _, f := range tt.fields {
  2175  			if needKeyUpdate(f.typ) {
  2176  				return true
  2177  			}
  2178  		}
  2179  		return false
  2180  	default:
  2181  		// Func, Map, Slice, Invalid
  2182  		panic("needKeyUpdate called on non-key type " + t.String())
  2183  	}
  2184  }
  2185  
  2186  // hashMightPanic reports whether the hash of a map key of type t might panic.
  2187  func hashMightPanic(t *rtype) bool {
  2188  	switch t.Kind() {
  2189  	case Interface:
  2190  		return true
  2191  	case Array:
  2192  		tt := (*arrayType)(unsafe.Pointer(t))
  2193  		return hashMightPanic(tt.elem)
  2194  	case Struct:
  2195  		tt := (*structType)(unsafe.Pointer(t))
  2196  		for _, f := range tt.fields {
  2197  			if hashMightPanic(f.typ) {
  2198  				return true
  2199  			}
  2200  		}
  2201  		return false
  2202  	default:
  2203  		return false
  2204  	}
  2205  }
  2206  
  2207  // Make sure these routines stay in sync with ../../runtime/map.go!
  2208  // These types exist only for GC, so we only fill out GC relevant info.
  2209  // Currently, that's just size and the GC program. We also fill in string
  2210  // for possible debugging use.
  2211  const (
  2212  	bucketSize uintptr = 8
  2213  	maxKeySize uintptr = 128
  2214  	maxValSize uintptr = 128
  2215  )
  2216  
  2217  func bucketOf(ktyp, etyp *rtype) *rtype {
  2218  	if ktyp.size > maxKeySize {
  2219  		ktyp = PtrTo(ktyp).(*rtype)
  2220  	}
  2221  	if etyp.size > maxValSize {
  2222  		etyp = PtrTo(etyp).(*rtype)
  2223  	}
  2224  
  2225  	// Prepare GC data if any.
  2226  	// A bucket is at most bucketSize*(1+maxKeySize+maxValSize)+2*ptrSize bytes,
  2227  	// or 2072 bytes, or 259 pointer-size words, or 33 bytes of pointer bitmap.
  2228  	// Note that since the key and value are known to be <= 128 bytes,
  2229  	// they're guaranteed to have bitmaps instead of GC programs.
  2230  	var gcdata *byte
  2231  	var ptrdata uintptr
  2232  	var overflowPad uintptr
  2233  
  2234  	size := bucketSize*(1+ktyp.size+etyp.size) + overflowPad + ptrSize
  2235  	if size&uintptr(ktyp.align-1) != 0 || size&uintptr(etyp.align-1) != 0 {
  2236  		panic("reflect: bad size computation in MapOf")
  2237  	}
  2238  
  2239  	if ktyp.ptrdata != 0 || etyp.ptrdata != 0 {
  2240  		nptr := (bucketSize*(1+ktyp.size+etyp.size) + ptrSize) / ptrSize
  2241  		mask := make([]byte, (nptr+7)/8)
  2242  		base := bucketSize / ptrSize
  2243  
  2244  		if ktyp.ptrdata != 0 {
  2245  			emitGCMask(mask, base, ktyp, bucketSize)
  2246  		}
  2247  		base += bucketSize * ktyp.size / ptrSize
  2248  
  2249  		if etyp.ptrdata != 0 {
  2250  			emitGCMask(mask, base, etyp, bucketSize)
  2251  		}
  2252  		base += bucketSize * etyp.size / ptrSize
  2253  		base += overflowPad / ptrSize
  2254  
  2255  		word := base
  2256  		mask[word/8] |= 1 << (word % 8)
  2257  		gcdata = &mask[0]
  2258  		ptrdata = (word + 1) * ptrSize
  2259  
  2260  		// overflow word must be last
  2261  		if ptrdata != size {
  2262  			panic("reflect: bad layout computation in MapOf")
  2263  		}
  2264  	}
  2265  
  2266  	b := &rtype{
  2267  		align:   ptrSize,
  2268  		size:    size,
  2269  		kind:    uint8(Struct),
  2270  		ptrdata: ptrdata,
  2271  		gcdata:  gcdata,
  2272  	}
  2273  	if overflowPad > 0 {
  2274  		b.align = 8
  2275  	}
  2276  	s := "bucket(" + ktyp.String() + "," + etyp.String() + ")"
  2277  	b.str = resolveReflectName(newName(s, "", false))
  2278  	return b
  2279  }
  2280  
  2281  func (t *rtype) gcSlice(begin, end uintptr) []byte {
  2282  	return (*[1 << 30]byte)(unsafe.Pointer(t.gcdata))[begin:end:end]
  2283  }
  2284  
  2285  // emitGCMask writes the GC mask for [n]typ into out, starting at bit
  2286  // offset base.
  2287  func emitGCMask(out []byte, base uintptr, typ *rtype, n uintptr) {
  2288  	if typ.kind&kindGCProg != 0 {
  2289  		panic("reflect: unexpected GC program")
  2290  	}
  2291  	ptrs := typ.ptrdata / ptrSize
  2292  	words := typ.size / ptrSize
  2293  	mask := typ.gcSlice(0, (ptrs+7)/8)
  2294  	for j := uintptr(0); j < ptrs; j++ {
  2295  		if (mask[j/8]>>(j%8))&1 != 0 {
  2296  			for i := uintptr(0); i < n; i++ {
  2297  				k := base + i*words + j
  2298  				out[k/8] |= 1 << (k % 8)
  2299  			}
  2300  		}
  2301  	}
  2302  }
  2303  
  2304  // appendGCProg appends the GC program for the first ptrdata bytes of
  2305  // typ to dst and returns the extended slice.
  2306  func appendGCProg(dst []byte, typ *rtype) []byte {
  2307  	if typ.kind&kindGCProg != 0 {
  2308  		// Element has GC program; emit one element.
  2309  		n := uintptr(*(*uint32)(unsafe.Pointer(typ.gcdata)))
  2310  		prog := typ.gcSlice(4, 4+n-1)
  2311  		return append(dst, prog...)
  2312  	}
  2313  
  2314  	// Element is small with pointer mask; use as literal bits.
  2315  	ptrs := typ.ptrdata / ptrSize
  2316  	mask := typ.gcSlice(0, (ptrs+7)/8)
  2317  
  2318  	// Emit 120-bit chunks of full bytes (max is 127 but we avoid using partial bytes).
  2319  	for ; ptrs > 120; ptrs -= 120 {
  2320  		dst = append(dst, 120)
  2321  		dst = append(dst, mask[:15]...)
  2322  		mask = mask[15:]
  2323  	}
  2324  
  2325  	dst = append(dst, byte(ptrs))
  2326  	dst = append(dst, mask...)
  2327  	return dst
  2328  }
  2329  
  2330  // SliceOf returns the slice type with element type t.
  2331  // For example, if t represents int, SliceOf(t) represents []int.
  2332  func SliceOf(t Type) Type {
  2333  	typ := t.(*rtype)
  2334  
  2335  	// Look in cache.
  2336  	ckey := cacheKey{Slice, typ, nil, 0}
  2337  	if slice, ok := lookupCache.Load(ckey); ok {
  2338  		return slice.(Type)
  2339  	}
  2340  
  2341  	// Look in known types.
  2342  	s := "[]" + typ.String()
  2343  	for _, tt := range typesByString(s) {
  2344  		slice := (*sliceType)(unsafe.Pointer(tt))
  2345  		if slice.elem == typ {
  2346  			ti, _ := lookupCache.LoadOrStore(ckey, tt)
  2347  			return ti.(Type)
  2348  		}
  2349  	}
  2350  
  2351  	// Make a slice type.
  2352  	var islice interface{} = ([]unsafe.Pointer)(nil)
  2353  	prototype := *(**sliceType)(unsafe.Pointer(&islice))
  2354  	slice := *prototype
  2355  	slice.tflag = 0
  2356  	slice.str = resolveReflectName(newName(s, "", false))
  2357  	slice.hash = fnv1(typ.hash, '[')
  2358  	slice.elem = typ
  2359  	slice.ptrToThis = 0
  2360  
  2361  	ti, _ := lookupCache.LoadOrStore(ckey, &slice.rtype)
  2362  	return ti.(Type)
  2363  }
  2364  
  2365  // The structLookupCache caches StructOf lookups.
  2366  // StructOf does not share the common lookupCache since we need to pin
  2367  // the memory associated with *structTypeFixedN.
  2368  var structLookupCache struct {
  2369  	sync.Mutex // Guards stores (but not loads) on m.
  2370  
  2371  	// m is a map[uint32][]Type keyed by the hash calculated in StructOf.
  2372  	// Elements in m are append-only and thus safe for concurrent reading.
  2373  	m sync.Map
  2374  }
  2375  
  2376  type structTypeUncommon struct {
  2377  	structType
  2378  	u uncommonType
  2379  }
  2380  
  2381  // isLetter reports whether a given 'rune' is classified as a Letter.
  2382  func isLetter(ch rune) bool {
  2383  	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= utf8.RuneSelf && unicode.IsLetter(ch)
  2384  }
  2385  
  2386  // isValidFieldName checks if a string is a valid (struct) field name or not.
  2387  //
  2388  // According to the language spec, a field name should be an identifier.
  2389  //
  2390  // identifier = letter { letter | unicode_digit } .
  2391  // letter = unicode_letter | "_" .
  2392  func isValidFieldName(fieldName string) bool {
  2393  	for i, c := range fieldName {
  2394  		if i == 0 && !isLetter(c) {
  2395  			return false
  2396  		}
  2397  
  2398  		if !(isLetter(c) || unicode.IsDigit(c)) {
  2399  			return false
  2400  		}
  2401  	}
  2402  
  2403  	return len(fieldName) > 0
  2404  }
  2405  
  2406  // StructOf returns the struct type containing fields.
  2407  // The Offset and Index fields are ignored and computed as they would be
  2408  // by the compiler.
  2409  //
  2410  // StructOf currently does not generate wrapper methods for embedded
  2411  // fields and panics if passed unexported StructFields.
  2412  // These limitations may be lifted in a future version.
  2413  func StructOf(fields []StructField) Type {
  2414  	var (
  2415  		hash       = fnv1(0, []byte("struct {")...)
  2416  		size       uintptr
  2417  		typalign   uint8
  2418  		comparable = true
  2419  		methods    []method
  2420  
  2421  		fs   = make([]structField, len(fields))
  2422  		repr = make([]byte, 0, 64)
  2423  		fset = map[string]struct{}{} // fields' names
  2424  
  2425  		hasGCProg = false // records whether a struct-field type has a GCProg
  2426  	)
  2427  
  2428  	lastzero := uintptr(0)
  2429  	repr = append(repr, "struct {"...)
  2430  	pkgpath := ""
  2431  	for i, field := range fields {
  2432  		if field.Name == "" {
  2433  			panic("reflect.StructOf: field " + strconv.Itoa(i) + " has no name")
  2434  		}
  2435  		if !isValidFieldName(field.Name) {
  2436  			panic("reflect.StructOf: field " + strconv.Itoa(i) + " has invalid name")
  2437  		}
  2438  		if field.Type == nil {
  2439  			panic("reflect.StructOf: field " + strconv.Itoa(i) + " has no type")
  2440  		}
  2441  		f, fpkgpath := runtimeStructField(field)
  2442  		ft := f.typ
  2443  		if ft.kind&kindGCProg != 0 {
  2444  			hasGCProg = true
  2445  		}
  2446  		if fpkgpath != "" {
  2447  			if pkgpath == "" {
  2448  				pkgpath = fpkgpath
  2449  			} else if pkgpath != fpkgpath {
  2450  				panic("reflect.Struct: fields with different PkgPath " + pkgpath + " and " + fpkgpath)
  2451  			}
  2452  		}
  2453  
  2454  		// Update string and hash
  2455  		name := f.name.name()
  2456  		hash = fnv1(hash, []byte(name)...)
  2457  		repr = append(repr, (" " + name)...)
  2458  		if f.embedded() {
  2459  			// Embedded field
  2460  			if f.typ.Kind() == Ptr {
  2461  				// Embedded ** and *interface{} are illegal
  2462  				elem := ft.Elem()
  2463  				if k := elem.Kind(); k == Ptr || k == Interface {
  2464  					panic("reflect.StructOf: illegal embedded field type " + ft.String())
  2465  				}
  2466  			}
  2467  
  2468  			switch f.typ.Kind() {
  2469  			case Interface:
  2470  				ift := (*interfaceType)(unsafe.Pointer(ft))
  2471  				for im, m := range ift.methods {
  2472  					if ift.nameOff(m.name).pkgPath() != "" {
  2473  						// TODO(sbinet).  Issue 15924.
  2474  						panic("reflect: embedded interface with unexported method(s) not implemented")
  2475  					}
  2476  
  2477  					var (
  2478  						mtyp    = ift.typeOff(m.typ)
  2479  						ifield  = i
  2480  						imethod = im
  2481  						ifn     Value
  2482  						tfn     Value
  2483  					)
  2484  
  2485  					if ft.kind&kindDirectIface != 0 {
  2486  						tfn = MakeFunc(mtyp, func(in []Value) []Value {
  2487  							var args []Value
  2488  							var recv = in[0]
  2489  							if len(in) > 1 {
  2490  								args = in[1:]
  2491  							}
  2492  							return recv.Field(ifield).Method(imethod).Call(args)
  2493  						})
  2494  						ifn = MakeFunc(mtyp, func(in []Value) []Value {
  2495  							var args []Value
  2496  							var recv = in[0]
  2497  							if len(in) > 1 {
  2498  								args = in[1:]
  2499  							}
  2500  							return recv.Field(ifield).Method(imethod).Call(args)
  2501  						})
  2502  					} else {
  2503  						tfn = MakeFunc(mtyp, func(in []Value) []Value {
  2504  							var args []Value
  2505  							var recv = in[0]
  2506  							if len(in) > 1 {
  2507  								args = in[1:]
  2508  							}
  2509  							return recv.Field(ifield).Method(imethod).Call(args)
  2510  						})
  2511  						ifn = MakeFunc(mtyp, func(in []Value) []Value {
  2512  							var args []Value
  2513  							var recv = Indirect(in[0])
  2514  							if len(in) > 1 {
  2515  								args = in[1:]
  2516  							}
  2517  							return recv.Field(ifield).Method(imethod).Call(args)
  2518  						})
  2519  					}
  2520  
  2521  					methods = append(methods, method{
  2522  						name: resolveReflectName(ift.nameOff(m.name)),
  2523  						mtyp: resolveReflectType(mtyp),
  2524  						ifn:  resolveReflectText(unsafe.Pointer(&ifn)),
  2525  						tfn:  resolveReflectText(unsafe.Pointer(&tfn)),
  2526  					})
  2527  				}
  2528  			case Ptr:
  2529  				ptr := (*ptrType)(unsafe.Pointer(ft))
  2530  				if unt := ptr.uncommon(); unt != nil {
  2531  					if i > 0 && unt.mcount > 0 {
  2532  						// Issue 15924.
  2533  						panic("reflect: embedded type with methods not implemented if type is not first field")
  2534  					}
  2535  					if len(fields) > 1 {
  2536  						panic("reflect: embedded type with methods not implemented if there is more than one field")
  2537  					}
  2538  					for _, m := range unt.methods() {
  2539  						mname := ptr.nameOff(m.name)
  2540  						if mname.pkgPath() != "" {
  2541  							// TODO(sbinet).
  2542  							// Issue 15924.
  2543  							panic("reflect: embedded interface with unexported method(s) not implemented")
  2544  						}
  2545  						methods = append(methods, method{
  2546  							name: resolveReflectName(mname),
  2547  							mtyp: resolveReflectType(ptr.typeOff(m.mtyp)),
  2548  							ifn:  resolveReflectText(ptr.textOff(m.ifn)),
  2549  							tfn:  resolveReflectText(ptr.textOff(m.tfn)),
  2550  						})
  2551  					}
  2552  				}
  2553  				if unt := ptr.elem.uncommon(); unt != nil {
  2554  					for _, m := range unt.methods() {
  2555  						mname := ptr.nameOff(m.name)
  2556  						if mname.pkgPath() != "" {
  2557  							// TODO(sbinet)
  2558  							// Issue 15924.
  2559  							panic("reflect: embedded interface with unexported method(s) not implemented")
  2560  						}
  2561  						methods = append(methods, method{
  2562  							name: resolveReflectName(mname),
  2563  							mtyp: resolveReflectType(ptr.elem.typeOff(m.mtyp)),
  2564  							ifn:  resolveReflectText(ptr.elem.textOff(m.ifn)),
  2565  							tfn:  resolveReflectText(ptr.elem.textOff(m.tfn)),
  2566  						})
  2567  					}
  2568  				}
  2569  			default:
  2570  				if unt := ft.uncommon(); unt != nil {
  2571  					if i > 0 && unt.mcount > 0 {
  2572  						// Issue 15924.
  2573  						panic("reflect: embedded type with methods not implemented if type is not first field")
  2574  					}
  2575  					if len(fields) > 1 && ft.kind&kindDirectIface != 0 {
  2576  						panic("reflect: embedded type with methods not implemented for non-pointer type")
  2577  					}
  2578  					for _, m := range unt.methods() {
  2579  						mname := ft.nameOff(m.name)
  2580  						if mname.pkgPath() != "" {
  2581  							// TODO(sbinet)
  2582  							// Issue 15924.
  2583  							panic("reflect: embedded interface with unexported method(s) not implemented")
  2584  						}
  2585  						methods = append(methods, method{
  2586  							name: resolveReflectName(mname),
  2587  							mtyp: resolveReflectType(ft.typeOff(m.mtyp)),
  2588  							ifn:  resolveReflectText(ft.textOff(m.ifn)),
  2589  							tfn:  resolveReflectText(ft.textOff(m.tfn)),
  2590  						})
  2591  
  2592  					}
  2593  				}
  2594  			}
  2595  		}
  2596  		if _, dup := fset[name]; dup {
  2597  			panic("reflect.StructOf: duplicate field " + name)
  2598  		}
  2599  		fset[name] = struct{}{}
  2600  
  2601  		hash = fnv1(hash, byte(ft.hash>>24), byte(ft.hash>>16), byte(ft.hash>>8), byte(ft.hash))
  2602  
  2603  		repr = append(repr, (" " + ft.String())...)
  2604  		if f.name.hasTag() {
  2605  			hash = fnv1(hash, []byte(f.name.tag())...)
  2606  			repr = append(repr, (" " + strconv.Quote(f.name.tag()))...)
  2607  		}
  2608  		if i < len(fields)-1 {
  2609  			repr = append(repr, ';')
  2610  		}
  2611  
  2612  		comparable = comparable && (ft.equal != nil)
  2613  
  2614  		offset := align(size, uintptr(ft.align))
  2615  		if ft.align > typalign {
  2616  			typalign = ft.align
  2617  		}
  2618  		size = offset + ft.size
  2619  		f.offsetEmbed |= offset << 1
  2620  
  2621  		if ft.size == 0 {
  2622  			lastzero = size
  2623  		}
  2624  
  2625  		fs[i] = f
  2626  	}
  2627  
  2628  	if size > 0 && lastzero == size {
  2629  		// This is a non-zero sized struct that ends in a
  2630  		// zero-sized field. We add an extra byte of padding,
  2631  		// to ensure that taking the address of the final
  2632  		// zero-sized field can't manufacture a pointer to the
  2633  		// next object in the heap. See issue 9401.
  2634  		size++
  2635  	}
  2636  
  2637  	var typ *structType
  2638  	var ut *uncommonType
  2639  
  2640  	if len(methods) == 0 {
  2641  		t := new(structTypeUncommon)
  2642  		typ = &t.structType
  2643  		ut = &t.u
  2644  	} else {
  2645  		// A *rtype representing a struct is followed directly in memory by an
  2646  		// array of method objects representing the methods attached to the
  2647  		// struct. To get the same layout for a run time generated type, we
  2648  		// need an array directly following the uncommonType memory.
  2649  		// A similar strategy is used for funcTypeFixed4, ...funcTypeFixedN.
  2650  		tt := New(StructOf([]StructField{
  2651  			{Name: "S", Type: TypeOf(structType{})},
  2652  			{Name: "U", Type: TypeOf(uncommonType{})},
  2653  			{Name: "M", Type: ArrayOf(len(methods), TypeOf(methods[0]))},
  2654  		}))
  2655  
  2656  		typ = (*structType)(unsafe.Pointer(tt.Elem().Field(0).UnsafeAddr()))
  2657  		ut = (*uncommonType)(unsafe.Pointer(tt.Elem().Field(1).UnsafeAddr()))
  2658  
  2659  		copy(tt.Elem().Field(2).Slice(0, len(methods)).Interface().([]method), methods)
  2660  	}
  2661  	// TODO(sbinet): Once we allow embedding multiple types,
  2662  	// methods will need to be sorted like the compiler does.
  2663  	// TODO(sbinet): Once we allow non-exported methods, we will
  2664  	// need to compute xcount as the number of exported methods.
  2665  	ut.mcount = uint16(len(methods))
  2666  	ut.xcount = ut.mcount
  2667  	ut.moff = uint32(unsafe.Sizeof(uncommonType{}))
  2668  
  2669  	if len(fs) > 0 {
  2670  		repr = append(repr, ' ')
  2671  	}
  2672  	repr = append(repr, '}')
  2673  	hash = fnv1(hash, '}')
  2674  	str := string(repr)
  2675  
  2676  	// Round the size up to be a multiple of the alignment.
  2677  	size = align(size, uintptr(typalign))
  2678  
  2679  	// Make the struct type.
  2680  	var istruct interface{} = struct{}{}
  2681  	prototype := *(**structType)(unsafe.Pointer(&istruct))
  2682  	*typ = *prototype
  2683  	typ.fields = fs
  2684  	if pkgpath != "" {
  2685  		typ.pkgPath = newName(pkgpath, "", false)
  2686  	}
  2687  
  2688  	// Look in cache.
  2689  	if ts, ok := structLookupCache.m.Load(hash); ok {
  2690  		for _, st := range ts.([]Type) {
  2691  			t := st.common()
  2692  			if haveIdenticalUnderlyingType(&typ.rtype, t, true) {
  2693  				return t
  2694  			}
  2695  		}
  2696  	}
  2697  
  2698  	// Not in cache, lock and retry.
  2699  	structLookupCache.Lock()
  2700  	defer structLookupCache.Unlock()
  2701  	if ts, ok := structLookupCache.m.Load(hash); ok {
  2702  		for _, st := range ts.([]Type) {
  2703  			t := st.common()
  2704  			if haveIdenticalUnderlyingType(&typ.rtype, t, true) {
  2705  				return t
  2706  			}
  2707  		}
  2708  	}
  2709  
  2710  	addToCache := func(t Type) Type {
  2711  		var ts []Type
  2712  		if ti, ok := structLookupCache.m.Load(hash); ok {
  2713  			ts = ti.([]Type)
  2714  		}
  2715  		structLookupCache.m.Store(hash, append(ts, t))
  2716  		return t
  2717  	}
  2718  
  2719  	// Look in known types.
  2720  	for _, t := range typesByString(str) {
  2721  		if haveIdenticalUnderlyingType(&typ.rtype, t, true) {
  2722  			// even if 't' wasn't a structType with methods, we should be ok
  2723  			// as the 'u uncommonType' field won't be accessed except when
  2724  			// tflag&tflagUncommon is set.
  2725  			return addToCache(t)
  2726  		}
  2727  	}
  2728  
  2729  	typ.str = resolveReflectName(newName(str, "", false))
  2730  	typ.tflag = 0 // TODO: set tflagRegularMemory
  2731  	typ.hash = hash
  2732  	typ.size = size
  2733  	typ.ptrdata = typeptrdata(typ.common())
  2734  	typ.align = typalign
  2735  	typ.fieldAlign = typalign
  2736  	typ.ptrToThis = 0
  2737  	if len(methods) > 0 {
  2738  		typ.tflag |= tflagUncommon
  2739  	}
  2740  
  2741  	if hasGCProg {
  2742  		lastPtrField := 0
  2743  		for i, ft := range fs {
  2744  			if ft.typ.pointers() {
  2745  				lastPtrField = i
  2746  			}
  2747  		}
  2748  		prog := []byte{0, 0, 0, 0} // will be length of prog
  2749  		var off uintptr
  2750  		for i, ft := range fs {
  2751  			if i > lastPtrField {
  2752  				// gcprog should not include anything for any field after
  2753  				// the last field that contains pointer data
  2754  				break
  2755  			}
  2756  			if !ft.typ.pointers() {
  2757  				// Ignore pointerless fields.
  2758  				continue
  2759  			}
  2760  			// Pad to start of this field with zeros.
  2761  			if ft.offset() > off {
  2762  				n := (ft.offset() - off) / ptrSize
  2763  				prog = append(prog, 0x01, 0x00) // emit a 0 bit
  2764  				if n > 1 {
  2765  					prog = append(prog, 0x81)      // repeat previous bit
  2766  					prog = appendVarint(prog, n-1) // n-1 times
  2767  				}
  2768  				off = ft.offset()
  2769  			}
  2770  
  2771  			prog = appendGCProg(prog, ft.typ)
  2772  			off += ft.typ.ptrdata
  2773  		}
  2774  		prog = append(prog, 0)
  2775  		*(*uint32)(unsafe.Pointer(&prog[0])) = uint32(len(prog) - 4)
  2776  		typ.kind |= kindGCProg
  2777  		typ.gcdata = &prog[0]
  2778  	} else {
  2779  		typ.kind &^= kindGCProg
  2780  		bv := new(bitVector)
  2781  		addTypeBits(bv, 0, typ.common())
  2782  		if len(bv.data) > 0 {
  2783  			typ.gcdata = &bv.data[0]
  2784  		}
  2785  	}
  2786  	typ.equal = nil
  2787  	if comparable {
  2788  		typ.equal = func(p, q unsafe.Pointer) bool {
  2789  			for _, ft := range typ.fields {
  2790  				pi := add(p, ft.offset(), "&x.field safe")
  2791  				qi := add(q, ft.offset(), "&x.field safe")
  2792  				if !ft.typ.equal(pi, qi) {
  2793  					return false
  2794  				}
  2795  			}
  2796  			return true
  2797  		}
  2798  	}
  2799  
  2800  	switch {
  2801  	case len(fs) == 1 && !ifaceIndir(fs[0].typ):
  2802  		// structs of 1 direct iface type can be direct
  2803  		typ.kind |= kindDirectIface
  2804  	default:
  2805  		typ.kind &^= kindDirectIface
  2806  	}
  2807  
  2808  	return addToCache(&typ.rtype)
  2809  }
  2810  
  2811  // runtimeStructField takes a StructField value passed to StructOf and
  2812  // returns both the corresponding internal representation, of type
  2813  // structField, and the pkgpath value to use for this field.
  2814  func runtimeStructField(field StructField) (structField, string) {
  2815  	if field.Anonymous && field.PkgPath != "" {
  2816  		panic("reflect.StructOf: field \"" + field.Name + "\" is anonymous but has PkgPath set")
  2817  	}
  2818  
  2819  	if field.IsExported() {
  2820  		// Best-effort check for misuse.
  2821  		// Since this field will be treated as exported, not much harm done if Unicode lowercase slips through.
  2822  		c := field.Name[0]
  2823  		if 'a' <= c && c <= 'z' || c == '_' {
  2824  			panic("reflect.StructOf: field \"" + field.Name + "\" is unexported but missing PkgPath")
  2825  		}
  2826  	}
  2827  
  2828  	offsetEmbed := uintptr(0)
  2829  	if field.Anonymous {
  2830  		offsetEmbed |= 1
  2831  	}
  2832  
  2833  	resolveReflectType(field.Type.common()) // install in runtime
  2834  	f := structField{
  2835  		name:        newName(field.Name, string(field.Tag), field.IsExported()),
  2836  		typ:         field.Type.common(),
  2837  		offsetEmbed: offsetEmbed,
  2838  	}
  2839  	return f, field.PkgPath
  2840  }
  2841  
  2842  // typeptrdata returns the length in bytes of the prefix of t
  2843  // containing pointer data. Anything after this offset is scalar data.
  2844  // keep in sync with ../cmd/compile/internal/reflectdata/reflect.go
  2845  func typeptrdata(t *rtype) uintptr {
  2846  	switch t.Kind() {
  2847  	case Struct:
  2848  		st := (*structType)(unsafe.Pointer(t))
  2849  		// find the last field that has pointers.
  2850  		field := -1
  2851  		for i := range st.fields {
  2852  			ft := st.fields[i].typ
  2853  			if ft.pointers() {
  2854  				field = i
  2855  			}
  2856  		}
  2857  		if field == -1 {
  2858  			return 0
  2859  		}
  2860  		f := st.fields[field]
  2861  		return f.offset() + f.typ.ptrdata
  2862  
  2863  	default:
  2864  		panic("reflect.typeptrdata: unexpected type, " + t.String())
  2865  	}
  2866  }
  2867  
  2868  // See cmd/compile/internal/reflectdata/reflect.go for derivation of constant.
  2869  const maxPtrmaskBytes = 2048
  2870  
  2871  // ArrayOf returns the array type with the given length and element type.
  2872  // For example, if t represents int, ArrayOf(5, t) represents [5]int.
  2873  //
  2874  // If the resulting type would be larger than the available address space,
  2875  // ArrayOf panics.
  2876  func ArrayOf(length int, elem Type) Type {
  2877  	if length < 0 {
  2878  		panic("reflect: negative length passed to ArrayOf")
  2879  	}
  2880  
  2881  	typ := elem.(*rtype)
  2882  
  2883  	// Look in cache.
  2884  	ckey := cacheKey{Array, typ, nil, uintptr(length)}
  2885  	if array, ok := lookupCache.Load(ckey); ok {
  2886  		return array.(Type)
  2887  	}
  2888  
  2889  	// Look in known types.
  2890  	s := "[" + strconv.Itoa(length) + "]" + typ.String()
  2891  	for _, tt := range typesByString(s) {
  2892  		array := (*arrayType)(unsafe.Pointer(tt))
  2893  		if array.elem == typ {
  2894  			ti, _ := lookupCache.LoadOrStore(ckey, tt)
  2895  			return ti.(Type)
  2896  		}
  2897  	}
  2898  
  2899  	// Make an array type.
  2900  	var iarray interface{} = [1]unsafe.Pointer{}
  2901  	prototype := *(**arrayType)(unsafe.Pointer(&iarray))
  2902  	array := *prototype
  2903  	array.tflag = typ.tflag & tflagRegularMemory
  2904  	array.str = resolveReflectName(newName(s, "", false))
  2905  	array.hash = fnv1(typ.hash, '[')
  2906  	for n := uint32(length); n > 0; n >>= 8 {
  2907  		array.hash = fnv1(array.hash, byte(n))
  2908  	}
  2909  	array.hash = fnv1(array.hash, ']')
  2910  	array.elem = typ
  2911  	array.ptrToThis = 0
  2912  	if typ.size > 0 {
  2913  		max := ^uintptr(0) / typ.size
  2914  		if uintptr(length) > max {
  2915  			panic("reflect.ArrayOf: array size would exceed virtual address space")
  2916  		}
  2917  	}
  2918  	array.size = typ.size * uintptr(length)
  2919  	if length > 0 && typ.ptrdata != 0 {
  2920  		array.ptrdata = typ.size*uintptr(length-1) + typ.ptrdata
  2921  	}
  2922  	array.align = typ.align
  2923  	array.fieldAlign = typ.fieldAlign
  2924  	array.len = uintptr(length)
  2925  	array.slice = SliceOf(elem).(*rtype)
  2926  
  2927  	switch {
  2928  	case typ.ptrdata == 0 || array.size == 0:
  2929  		// No pointers.
  2930  		array.gcdata = nil
  2931  		array.ptrdata = 0
  2932  
  2933  	case length == 1:
  2934  		// In memory, 1-element array looks just like the element.
  2935  		array.kind |= typ.kind & kindGCProg
  2936  		array.gcdata = typ.gcdata
  2937  		array.ptrdata = typ.ptrdata
  2938  
  2939  	case typ.kind&kindGCProg == 0 && array.size <= maxPtrmaskBytes*8*ptrSize:
  2940  		// Element is small with pointer mask; array is still small.
  2941  		// Create direct pointer mask by turning each 1 bit in elem
  2942  		// into length 1 bits in larger mask.
  2943  		mask := make([]byte, (array.ptrdata/ptrSize+7)/8)
  2944  		emitGCMask(mask, 0, typ, array.len)
  2945  		array.gcdata = &mask[0]
  2946  
  2947  	default:
  2948  		// Create program that emits one element
  2949  		// and then repeats to make the array.
  2950  		prog := []byte{0, 0, 0, 0} // will be length of prog
  2951  		prog = appendGCProg(prog, typ)
  2952  		// Pad from ptrdata to size.
  2953  		elemPtrs := typ.ptrdata / ptrSize
  2954  		elemWords := typ.size / ptrSize
  2955  		if elemPtrs < elemWords {
  2956  			// Emit literal 0 bit, then repeat as needed.
  2957  			prog = append(prog, 0x01, 0x00)
  2958  			if elemPtrs+1 < elemWords {
  2959  				prog = append(prog, 0x81)
  2960  				prog = appendVarint(prog, elemWords-elemPtrs-1)
  2961  			}
  2962  		}
  2963  		// Repeat length-1 times.
  2964  		if elemWords < 0x80 {
  2965  			prog = append(prog, byte(elemWords|0x80))
  2966  		} else {
  2967  			prog = append(prog, 0x80)
  2968  			prog = appendVarint(prog, elemWords)
  2969  		}
  2970  		prog = appendVarint(prog, uintptr(length)-1)
  2971  		prog = append(prog, 0)
  2972  		*(*uint32)(unsafe.Pointer(&prog[0])) = uint32(len(prog) - 4)
  2973  		array.kind |= kindGCProg
  2974  		array.gcdata = &prog[0]
  2975  		array.ptrdata = array.size // overestimate but ok; must match program
  2976  	}
  2977  
  2978  	etyp := typ.common()
  2979  	esize := etyp.Size()
  2980  
  2981  	array.equal = nil
  2982  	if eequal := etyp.equal; eequal != nil {
  2983  		array.equal = func(p, q unsafe.Pointer) bool {
  2984  			for i := 0; i < length; i++ {
  2985  				pi := arrayAt(p, i, esize, "i < length")
  2986  				qi := arrayAt(q, i, esize, "i < length")
  2987  				if !eequal(pi, qi) {
  2988  					return false
  2989  				}
  2990  
  2991  			}
  2992  			return true
  2993  		}
  2994  	}
  2995  
  2996  	switch {
  2997  	case length == 1 && !ifaceIndir(typ):
  2998  		// array of 1 direct iface type can be direct
  2999  		array.kind |= kindDirectIface
  3000  	default:
  3001  		array.kind &^= kindDirectIface
  3002  	}
  3003  
  3004  	ti, _ := lookupCache.LoadOrStore(ckey, &array.rtype)
  3005  	return ti.(Type)
  3006  }
  3007  
  3008  func appendVarint(x []byte, v uintptr) []byte {
  3009  	for ; v >= 0x80; v >>= 7 {
  3010  		x = append(x, byte(v|0x80))
  3011  	}
  3012  	x = append(x, byte(v))
  3013  	return x
  3014  }
  3015  
  3016  // toType converts from a *rtype to a Type that can be returned
  3017  // to the client of package reflect. In gc, the only concern is that
  3018  // a nil *rtype must be replaced by a nil Type, but in gccgo this
  3019  // function takes care of ensuring that multiple *rtype for the same
  3020  // type are coalesced into a single Type.
  3021  func toType(t *rtype) Type {
  3022  	if t == nil {
  3023  		return nil
  3024  	}
  3025  	return t
  3026  }
  3027  
  3028  type layoutKey struct {
  3029  	ftyp *funcType // function signature
  3030  	rcvr *rtype    // receiver type, or nil if none
  3031  }
  3032  
  3033  type layoutType struct {
  3034  	t         *rtype
  3035  	framePool *sync.Pool
  3036  	abi       abiDesc
  3037  }
  3038  
  3039  var layoutCache sync.Map // map[layoutKey]layoutType
  3040  
  3041  // funcLayout computes a struct type representing the layout of the
  3042  // stack-assigned function arguments and return values for the function
  3043  // type t.
  3044  // If rcvr != nil, rcvr specifies the type of the receiver.
  3045  // The returned type exists only for GC, so we only fill out GC relevant info.
  3046  // Currently, that's just size and the GC program. We also fill in
  3047  // the name for possible debugging use.
  3048  func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, framePool *sync.Pool, abi abiDesc) {
  3049  	if t.Kind() != Func {
  3050  		panic("reflect: funcLayout of non-func type " + t.String())
  3051  	}
  3052  	if rcvr != nil && rcvr.Kind() == Interface {
  3053  		panic("reflect: funcLayout with interface receiver " + rcvr.String())
  3054  	}
  3055  	k := layoutKey{t, rcvr}
  3056  	if lti, ok := layoutCache.Load(k); ok {
  3057  		lt := lti.(layoutType)
  3058  		return lt.t, lt.framePool, lt.abi
  3059  	}
  3060  
  3061  	// Compute the ABI layout.
  3062  	abi = newAbiDesc(t, rcvr)
  3063  
  3064  	// build dummy rtype holding gc program
  3065  	x := &rtype{
  3066  		align: ptrSize,
  3067  		// Don't add spill space here; it's only necessary in
  3068  		// reflectcall's frame, not in the allocated frame.
  3069  		// TODO(mknyszek): Remove this comment when register
  3070  		// spill space in the frame is no longer required.
  3071  		size:    align(abi.retOffset+abi.ret.stackBytes, ptrSize),
  3072  		ptrdata: uintptr(abi.stackPtrs.n) * ptrSize,
  3073  	}
  3074  	if abi.stackPtrs.n > 0 {
  3075  		x.gcdata = &abi.stackPtrs.data[0]
  3076  	}
  3077  
  3078  	var s string
  3079  	if rcvr != nil {
  3080  		s = "methodargs(" + rcvr.String() + ")(" + t.String() + ")"
  3081  	} else {
  3082  		s = "funcargs(" + t.String() + ")"
  3083  	}
  3084  	x.str = resolveReflectName(newName(s, "", false))
  3085  
  3086  	// cache result for future callers
  3087  	framePool = &sync.Pool{New: func() interface{} {
  3088  		return unsafe_New(x)
  3089  	}}
  3090  	lti, _ := layoutCache.LoadOrStore(k, layoutType{
  3091  		t:         x,
  3092  		framePool: framePool,
  3093  		abi:       abi,
  3094  	})
  3095  	lt := lti.(layoutType)
  3096  	return lt.t, lt.framePool, lt.abi
  3097  }
  3098  
  3099  // ifaceIndir reports whether t is stored indirectly in an interface value.
  3100  func ifaceIndir(t *rtype) bool {
  3101  	return t.kind&kindDirectIface == 0
  3102  }
  3103  
  3104  // Note: this type must agree with runtime.bitvector.
  3105  type bitVector struct {
  3106  	n    uint32 // number of bits
  3107  	data []byte
  3108  }
  3109  
  3110  // append a bit to the bitmap.
  3111  func (bv *bitVector) append(bit uint8) {
  3112  	if bv.n%8 == 0 {
  3113  		bv.data = append(bv.data, 0)
  3114  	}
  3115  	bv.data[bv.n/8] |= bit << (bv.n % 8)
  3116  	bv.n++
  3117  }
  3118  
  3119  func addTypeBits(bv *bitVector, offset uintptr, t *rtype) {
  3120  	if t.ptrdata == 0 {
  3121  		return
  3122  	}
  3123  
  3124  	switch Kind(t.kind & kindMask) {
  3125  	case Chan, Func, Map, Ptr, Slice, String, UnsafePointer:
  3126  		// 1 pointer at start of representation
  3127  		for bv.n < uint32(offset/uintptr(ptrSize)) {
  3128  			bv.append(0)
  3129  		}
  3130  		bv.append(1)
  3131  
  3132  	case Interface:
  3133  		// 2 pointers
  3134  		for bv.n < uint32(offset/uintptr(ptrSize)) {
  3135  			bv.append(0)
  3136  		}
  3137  		bv.append(1)
  3138  		bv.append(1)
  3139  
  3140  	case Array:
  3141  		// repeat inner type
  3142  		tt := (*arrayType)(unsafe.Pointer(t))
  3143  		for i := 0; i < int(tt.len); i++ {
  3144  			addTypeBits(bv, offset+uintptr(i)*tt.elem.size, tt.elem)
  3145  		}
  3146  
  3147  	case Struct:
  3148  		// apply fields
  3149  		tt := (*structType)(unsafe.Pointer(t))
  3150  		for i := range tt.fields {
  3151  			f := &tt.fields[i]
  3152  			addTypeBits(bv, offset+f.offset(), f.typ)
  3153  		}
  3154  	}
  3155  }
  3156  

View as plain text