Source file src/cmd/compile/internal/types/type.go

     1  // Copyright 2017 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 types
     6  
     7  import (
     8  	"cmd/compile/internal/base"
     9  	"cmd/internal/objabi"
    10  	"cmd/internal/src"
    11  	"fmt"
    12  	"go/constant"
    13  	"internal/types/errors"
    14  	"sync"
    15  )
    16  
    17  // Object represents an ir.Node, but without needing to import cmd/compile/internal/ir,
    18  // which would cause an import cycle. The uses in other packages must type assert
    19  // values of type Object to ir.Node or a more specific type.
    20  type Object interface {
    21  	Pos() src.XPos
    22  	Sym() *Sym
    23  	Type() *Type
    24  }
    25  
    26  //go:generate stringer -type Kind -trimprefix T type.go
    27  
    28  // Kind describes a kind of type.
    29  type Kind uint8
    30  
    31  const (
    32  	Txxx Kind = iota
    33  
    34  	TINT8
    35  	TUINT8
    36  	TINT16
    37  	TUINT16
    38  	TINT32
    39  	TUINT32
    40  	TINT64
    41  	TUINT64
    42  	TINT
    43  	TUINT
    44  	TUINTPTR
    45  
    46  	TCOMPLEX64
    47  	TCOMPLEX128
    48  
    49  	TFLOAT32
    50  	TFLOAT64
    51  
    52  	TBOOL
    53  
    54  	TPTR
    55  	TFUNC
    56  	TSLICE
    57  	TARRAY
    58  	TSTRUCT
    59  	TCHAN
    60  	TMAP
    61  	TINTER
    62  	TFORW
    63  	TANY
    64  	TSTRING
    65  	TUNSAFEPTR
    66  
    67  	// pseudo-types for literals
    68  	TIDEAL // untyped numeric constants
    69  	TNIL
    70  	TBLANK
    71  
    72  	// pseudo-types used temporarily only during frame layout (CalcSize())
    73  	TFUNCARGS
    74  	TCHANARGS
    75  
    76  	// SSA backend types
    77  	TSSA     // internal types used by SSA backend (flags, memory, etc.)
    78  	TTUPLE   // a pair of types, used by SSA backend
    79  	TRESULTS // multiple types; the result of calling a function or method, with a memory at the end.
    80  
    81  	NTYPE
    82  )
    83  
    84  // ChanDir is whether a channel can send, receive, or both.
    85  type ChanDir uint8
    86  
    87  func (c ChanDir) CanRecv() bool { return c&Crecv != 0 }
    88  func (c ChanDir) CanSend() bool { return c&Csend != 0 }
    89  
    90  const (
    91  	// types of channel
    92  	// must match ../../../../reflect/type.go:/ChanDir
    93  	Crecv ChanDir = 1 << 0
    94  	Csend ChanDir = 1 << 1
    95  	Cboth ChanDir = Crecv | Csend
    96  )
    97  
    98  // Types stores pointers to predeclared named types.
    99  //
   100  // It also stores pointers to several special types:
   101  //   - Types[TANY] is the placeholder "any" type recognized by SubstArgTypes.
   102  //   - Types[TBLANK] represents the blank variable's type.
   103  //   - Types[TINTER] is the canonical "interface{}" type.
   104  //   - Types[TNIL] represents the predeclared "nil" value's type.
   105  //   - Types[TUNSAFEPTR] is package unsafe's Pointer type.
   106  var Types [NTYPE]*Type
   107  
   108  var (
   109  	// Predeclared alias types. These are actually created as distinct
   110  	// defined types for better error messages, but are then specially
   111  	// treated as identical to their respective underlying types.
   112  	AnyType  *Type
   113  	ByteType *Type
   114  	RuneType *Type
   115  
   116  	// Predeclared error interface type.
   117  	ErrorType *Type
   118  	// Predeclared comparable interface type.
   119  	ComparableType *Type
   120  
   121  	// Types to represent untyped string and boolean constants.
   122  	UntypedString = newType(TSTRING)
   123  	UntypedBool   = newType(TBOOL)
   124  
   125  	// Types to represent untyped numeric constants.
   126  	UntypedInt     = newType(TIDEAL)
   127  	UntypedRune    = newType(TIDEAL)
   128  	UntypedFloat   = newType(TIDEAL)
   129  	UntypedComplex = newType(TIDEAL)
   130  )
   131  
   132  // UntypedTypes maps from a constant.Kind to its untyped Type
   133  // representation.
   134  var UntypedTypes = [...]*Type{
   135  	constant.Bool:    UntypedBool,
   136  	constant.String:  UntypedString,
   137  	constant.Int:     UntypedInt,
   138  	constant.Float:   UntypedFloat,
   139  	constant.Complex: UntypedComplex,
   140  }
   141  
   142  // DefaultKinds maps from a constant.Kind to its default Kind.
   143  var DefaultKinds = [...]Kind{
   144  	constant.Bool:    TBOOL,
   145  	constant.String:  TSTRING,
   146  	constant.Int:     TINT,
   147  	constant.Float:   TFLOAT64,
   148  	constant.Complex: TCOMPLEX128,
   149  }
   150  
   151  // A Type represents a Go type.
   152  //
   153  // There may be multiple unnamed types with identical structure. However, there must
   154  // be a unique Type object for each unique named (defined) type. After noding, a
   155  // package-level type can be looked up by building its unique symbol sym (sym =
   156  // package.Lookup(name)) and checking sym.Def. If sym.Def is non-nil, the type
   157  // already exists at package scope and is available at sym.Def.(*ir.Name).Type().
   158  // Local types (which may have the same name as a package-level type) are
   159  // distinguished by their vargen, which is embedded in their symbol name.
   160  type Type struct {
   161  	// extra contains extra etype-specific fields.
   162  	// As an optimization, those etype-specific structs which contain exactly
   163  	// one pointer-shaped field are stored as values rather than pointers when possible.
   164  	//
   165  	// TMAP: *Map
   166  	// TFORW: *Forward
   167  	// TFUNC: *Func
   168  	// TSTRUCT: *Struct
   169  	// TINTER: *Interface
   170  	// TFUNCARGS: FuncArgs
   171  	// TCHANARGS: ChanArgs
   172  	// TCHAN: *Chan
   173  	// TPTR: Ptr
   174  	// TARRAY: *Array
   175  	// TSLICE: Slice
   176  	// TSSA: string
   177  	extra any
   178  
   179  	// width is the width of this Type in bytes.
   180  	width int64 // valid if Align > 0
   181  
   182  	// list of base methods (excluding embedding)
   183  	methods fields
   184  	// list of all methods (including embedding)
   185  	allMethods fields
   186  
   187  	// canonical OTYPE node for a named type (should be an ir.Name node with same sym)
   188  	obj Object
   189  	// the underlying type (type literal or predeclared type) for a defined type
   190  	underlying *Type
   191  
   192  	// Cache of composite types, with this type being the element type.
   193  	cache struct {
   194  		ptr   *Type // *T, or nil
   195  		slice *Type // []T, or nil
   196  	}
   197  
   198  	kind  Kind  // kind of type
   199  	align uint8 // the required alignment of this type, in bytes (0 means Width and Align have not yet been computed)
   200  
   201  	intRegs, floatRegs uint8 // registers needed for ABIInternal
   202  
   203  	flags             bitset8
   204  	alg               AlgKind // valid if Align > 0
   205  	isSIMDTag, isSIMD bool    // tag is the marker type, isSIMD means has marker type
   206  
   207  	// size of prefix of object that contains all pointers. valid if Align > 0.
   208  	// Note that for pointers, this is always PtrSize even if the element type
   209  	// is NotInHeap. See size.go:PtrDataSize for details.
   210  	ptrBytes int64
   211  }
   212  
   213  // Registers returns the number of integer and floating-point
   214  // registers required to represent a parameter of this type under the
   215  // ABIInternal calling conventions.
   216  //
   217  // If t must be passed by memory, Registers returns (math.MaxUint8,
   218  // math.MaxUint8).
   219  func (t *Type) Registers() (uint8, uint8) {
   220  	CalcSize(t)
   221  	return t.intRegs, t.floatRegs
   222  }
   223  
   224  func (*Type) CanBeAnSSAAux() {}
   225  
   226  const (
   227  	typeNotInHeap  = 1 << iota // type cannot be heap allocated
   228  	typeNoalg                  // suppress hash and eq algorithm generation
   229  	typeDeferwidth             // width computation has been deferred and type is on deferredTypeStack
   230  	typeRecur
   231  	typeIsShape  // represents a set of closely related types, for generics
   232  	typeHasShape // there is a shape somewhere in the type
   233  	// typeIsFullyInstantiated reports whether a type is fully instantiated generic type; i.e.
   234  	// an instantiated generic type where all type arguments are non-generic or fully instantiated generic types.
   235  	typeIsFullyInstantiated
   236  )
   237  
   238  func (t *Type) NotInHeap() bool           { return t.flags&typeNotInHeap != 0 }
   239  func (t *Type) Noalg() bool               { return t.flags&typeNoalg != 0 }
   240  func (t *Type) Deferwidth() bool          { return t.flags&typeDeferwidth != 0 }
   241  func (t *Type) Recur() bool               { return t.flags&typeRecur != 0 }
   242  func (t *Type) IsShape() bool             { return t.flags&typeIsShape != 0 }
   243  func (t *Type) HasShape() bool            { return t.flags&typeHasShape != 0 }
   244  func (t *Type) IsFullyInstantiated() bool { return t.flags&typeIsFullyInstantiated != 0 }
   245  
   246  func (t *Type) SetNotInHeap(b bool)           { t.flags.set(typeNotInHeap, b) }
   247  func (t *Type) SetNoalg(b bool)               { t.flags.set(typeNoalg, b) }
   248  func (t *Type) SetDeferwidth(b bool)          { t.flags.set(typeDeferwidth, b) }
   249  func (t *Type) SetRecur(b bool)               { t.flags.set(typeRecur, b) }
   250  func (t *Type) SetIsFullyInstantiated(b bool) { t.flags.set(typeIsFullyInstantiated, b) }
   251  
   252  // Should always do SetHasShape(true) when doing SetIsShape(true).
   253  func (t *Type) SetIsShape(b bool)  { t.flags.set(typeIsShape, b) }
   254  func (t *Type) SetHasShape(b bool) { t.flags.set(typeHasShape, b) }
   255  
   256  // Kind returns the kind of type t.
   257  func (t *Type) Kind() Kind { return t.kind }
   258  
   259  // Sym returns the name of type t.
   260  func (t *Type) Sym() *Sym {
   261  	if t.obj != nil {
   262  		return t.obj.Sym()
   263  	}
   264  	return nil
   265  }
   266  
   267  // Underlying returns the underlying type of type t.
   268  func (t *Type) Underlying() *Type { return t.underlying }
   269  
   270  // Pos returns a position associated with t, if any.
   271  // This should only be used for diagnostics.
   272  func (t *Type) Pos() src.XPos {
   273  	if t.obj != nil {
   274  		return t.obj.Pos()
   275  	}
   276  	return src.NoXPos
   277  }
   278  
   279  // Map contains Type fields specific to maps.
   280  type Map struct {
   281  	Key  *Type // Key type
   282  	Elem *Type // Val (elem) type
   283  
   284  	Group *Type // internal struct type representing a slot group
   285  }
   286  
   287  // MapType returns t's extra map-specific fields.
   288  func (t *Type) MapType() *Map {
   289  	t.wantEtype(TMAP)
   290  	return t.extra.(*Map)
   291  }
   292  
   293  // Forward contains Type fields specific to forward types.
   294  type Forward struct {
   295  	Copyto      []*Type  // where to copy the eventual value to
   296  	Embedlineno src.XPos // first use of this type as an embedded type
   297  }
   298  
   299  // forwardType returns t's extra forward-type-specific fields.
   300  func (t *Type) forwardType() *Forward {
   301  	t.wantEtype(TFORW)
   302  	return t.extra.(*Forward)
   303  }
   304  
   305  // Func contains Type fields specific to func types.
   306  type Func struct {
   307  	allParams []*Field // slice of all parameters, in receiver/params/results order
   308  
   309  	startParams  int // index of the start of the (regular) parameters section
   310  	startResults int // index of the start of the results section
   311  
   312  	resultsTuple *Type // struct-like type representing multi-value results
   313  
   314  	// Argwid is the total width of the function receiver, params, and results.
   315  	// It gets calculated via a temporary TFUNCARGS type.
   316  	// Note that TFUNC's Width is Widthptr.
   317  	Argwid int64
   318  }
   319  
   320  func (ft *Func) recvs() []*Field         { return ft.allParams[:ft.startParams] }
   321  func (ft *Func) params() []*Field        { return ft.allParams[ft.startParams:ft.startResults] }
   322  func (ft *Func) results() []*Field       { return ft.allParams[ft.startResults:] }
   323  func (ft *Func) recvParams() []*Field    { return ft.allParams[:ft.startResults] }
   324  func (ft *Func) paramsResults() []*Field { return ft.allParams[ft.startParams:] }
   325  
   326  // funcType returns t's extra func-specific fields.
   327  func (t *Type) funcType() *Func {
   328  	t.wantEtype(TFUNC)
   329  	return t.extra.(*Func)
   330  }
   331  
   332  // Struct contains Type fields specific to struct types.
   333  type Struct struct {
   334  	fields fields
   335  
   336  	// Maps have three associated internal structs (see struct MapType).
   337  	// Map links such structs back to their map type.
   338  	Map *Type
   339  
   340  	ParamTuple bool // whether this struct is actually a tuple of signature parameters
   341  }
   342  
   343  // StructType returns t's extra struct-specific fields.
   344  func (t *Type) StructType() *Struct {
   345  	t.wantEtype(TSTRUCT)
   346  	return t.extra.(*Struct)
   347  }
   348  
   349  // Interface contains Type fields specific to interface types.
   350  type Interface struct {
   351  }
   352  
   353  // Ptr contains Type fields specific to pointer types.
   354  type Ptr struct {
   355  	Elem *Type // element type
   356  }
   357  
   358  // ChanArgs contains Type fields specific to TCHANARGS types.
   359  type ChanArgs struct {
   360  	T *Type // reference to a chan type whose elements need a width check
   361  }
   362  
   363  // FuncArgs contains Type fields specific to TFUNCARGS types.
   364  type FuncArgs struct {
   365  	T *Type // reference to a func type whose elements need a width check
   366  }
   367  
   368  // Chan contains Type fields specific to channel types.
   369  type Chan struct {
   370  	Elem *Type   // element type
   371  	Dir  ChanDir // channel direction
   372  }
   373  
   374  // chanType returns t's extra channel-specific fields.
   375  func (t *Type) chanType() *Chan {
   376  	t.wantEtype(TCHAN)
   377  	return t.extra.(*Chan)
   378  }
   379  
   380  type Tuple struct {
   381  	first  *Type
   382  	second *Type
   383  	// Any tuple with a memory type must put that memory type second.
   384  }
   385  
   386  // Results are the output from calls that will be late-expanded.
   387  type Results struct {
   388  	Types []*Type // Last element is memory output from call.
   389  }
   390  
   391  // Array contains Type fields specific to array types.
   392  type Array struct {
   393  	Elem  *Type // element type
   394  	Bound int64 // number of elements; <0 if unknown yet
   395  }
   396  
   397  // Slice contains Type fields specific to slice types.
   398  type Slice struct {
   399  	Elem *Type // element type
   400  }
   401  
   402  // A Field is a (Sym, Type) pairing along with some other information, and,
   403  // depending on the context, is used to represent:
   404  //   - a field in a struct
   405  //   - a method in an interface or associated with a named type
   406  //   - a function parameter
   407  type Field struct {
   408  	flags bitset8
   409  
   410  	Embedded uint8 // embedded field
   411  
   412  	Pos src.XPos
   413  
   414  	// Name of field/method/parameter. Can be nil for interface fields embedded
   415  	// in interfaces and unnamed parameters.
   416  	Sym  *Sym
   417  	Type *Type  // field type
   418  	Note string // literal string annotation
   419  
   420  	// For fields that represent function parameters, Nname points to the
   421  	// associated ONAME Node. For fields that represent methods, Nname points to
   422  	// the function name node.
   423  	Nname Object
   424  
   425  	// Offset in bytes of this field or method within its enclosing struct
   426  	// or interface Type. For parameters, this is BADWIDTH.
   427  	Offset int64
   428  }
   429  
   430  const (
   431  	fieldIsDDD = 1 << iota // field is ... argument
   432  	fieldNointerface
   433  )
   434  
   435  func (f *Field) IsDDD() bool       { return f.flags&fieldIsDDD != 0 }
   436  func (f *Field) Nointerface() bool { return f.flags&fieldNointerface != 0 }
   437  
   438  func (f *Field) SetIsDDD(b bool)       { f.flags.set(fieldIsDDD, b) }
   439  func (f *Field) SetNointerface(b bool) { f.flags.set(fieldNointerface, b) }
   440  
   441  // End returns the offset of the first byte immediately after this field.
   442  func (f *Field) End() int64 {
   443  	return f.Offset + f.Type.width
   444  }
   445  
   446  // IsMethod reports whether f represents a method rather than a struct field.
   447  func (f *Field) IsMethod() bool {
   448  	return f.Type.kind == TFUNC && f.Type.Recv() != nil
   449  }
   450  
   451  // CompareFields compares two Field values by name.
   452  func CompareFields(a, b *Field) int {
   453  	return CompareSyms(a.Sym, b.Sym)
   454  }
   455  
   456  // fields is a pointer to a slice of *Field.
   457  // This saves space in Types that do not have fields or methods
   458  // compared to a simple slice of *Field.
   459  type fields struct {
   460  	s *[]*Field
   461  }
   462  
   463  // Slice returns the entries in f as a slice.
   464  // Changes to the slice entries will be reflected in f.
   465  func (f *fields) Slice() []*Field {
   466  	if f.s == nil {
   467  		return nil
   468  	}
   469  	return *f.s
   470  }
   471  
   472  // Set sets f to a slice.
   473  // This takes ownership of the slice.
   474  func (f *fields) Set(s []*Field) {
   475  	if len(s) == 0 {
   476  		f.s = nil
   477  	} else {
   478  		// Copy s and take address of t rather than s to avoid
   479  		// allocation in the case where len(s) == 0.
   480  		t := s
   481  		f.s = &t
   482  	}
   483  }
   484  
   485  // newType returns a new Type of the specified kind.
   486  func newType(et Kind) *Type {
   487  	t := &Type{
   488  		kind:  et,
   489  		width: BADWIDTH,
   490  	}
   491  	t.underlying = t
   492  	// TODO(josharian): lazily initialize some of these?
   493  	switch t.kind {
   494  	case TMAP:
   495  		t.extra = new(Map)
   496  	case TFORW:
   497  		t.extra = new(Forward)
   498  	case TFUNC:
   499  		t.extra = new(Func)
   500  	case TSTRUCT:
   501  		t.extra = new(Struct)
   502  	case TINTER:
   503  		t.extra = new(Interface)
   504  	case TPTR:
   505  		t.extra = Ptr{}
   506  	case TCHANARGS:
   507  		t.extra = ChanArgs{}
   508  	case TFUNCARGS:
   509  		t.extra = FuncArgs{}
   510  	case TCHAN:
   511  		t.extra = new(Chan)
   512  	case TTUPLE:
   513  		t.extra = new(Tuple)
   514  	case TRESULTS:
   515  		t.extra = new(Results)
   516  	}
   517  	return t
   518  }
   519  
   520  // NewArray returns a new fixed-length array Type.
   521  func NewArray(elem *Type, bound int64) *Type {
   522  	if bound < 0 {
   523  		base.Fatalf("NewArray: invalid bound %v", bound)
   524  	}
   525  	t := newType(TARRAY)
   526  	t.extra = &Array{Elem: elem, Bound: bound}
   527  	if elem.HasShape() {
   528  		t.SetHasShape(true)
   529  	}
   530  	if elem.NotInHeap() {
   531  		t.SetNotInHeap(true)
   532  	}
   533  	return t
   534  }
   535  
   536  // NewSlice returns the slice Type with element type elem.
   537  func NewSlice(elem *Type) *Type {
   538  	if t := elem.cache.slice; t != nil {
   539  		if t.Elem() != elem {
   540  			base.Fatalf("elem mismatch")
   541  		}
   542  		if elem.HasShape() != t.HasShape() {
   543  			base.Fatalf("Incorrect HasShape flag for cached slice type")
   544  		}
   545  		return t
   546  	}
   547  
   548  	t := newType(TSLICE)
   549  	t.extra = Slice{Elem: elem}
   550  	elem.cache.slice = t
   551  	if elem.HasShape() {
   552  		t.SetHasShape(true)
   553  	}
   554  	return t
   555  }
   556  
   557  // NewChan returns a new chan Type with direction dir.
   558  func NewChan(elem *Type, dir ChanDir) *Type {
   559  	t := newType(TCHAN)
   560  	ct := t.chanType()
   561  	ct.Elem = elem
   562  	ct.Dir = dir
   563  	if elem.HasShape() {
   564  		t.SetHasShape(true)
   565  	}
   566  	return t
   567  }
   568  
   569  func NewTuple(t1, t2 *Type) *Type {
   570  	t := newType(TTUPLE)
   571  	t.extra.(*Tuple).first = t1
   572  	t.extra.(*Tuple).second = t2
   573  	if t1.HasShape() || t2.HasShape() {
   574  		t.SetHasShape(true)
   575  	}
   576  	return t
   577  }
   578  
   579  func newResults(types []*Type) *Type {
   580  	t := newType(TRESULTS)
   581  	t.extra.(*Results).Types = types
   582  	return t
   583  }
   584  
   585  func NewResults(types []*Type) *Type {
   586  	if len(types) == 1 && types[0] == TypeMem {
   587  		return TypeResultMem
   588  	}
   589  	return newResults(types)
   590  }
   591  
   592  func newSSA(name string) *Type {
   593  	t := newType(TSSA)
   594  	t.extra = name
   595  	return t
   596  }
   597  
   598  func newSIMD(name string) *Type {
   599  	t := newSSA(name)
   600  	t.isSIMD = true
   601  	return t
   602  }
   603  
   604  // NewMap returns a new map Type with key type k and element (aka value) type v.
   605  func NewMap(k, v *Type) *Type {
   606  	t := newType(TMAP)
   607  	mt := t.MapType()
   608  	mt.Key = k
   609  	mt.Elem = v
   610  	if k.HasShape() || v.HasShape() {
   611  		t.SetHasShape(true)
   612  	}
   613  	return t
   614  }
   615  
   616  // NewPtrCacheEnabled controls whether *T Types are cached in T.
   617  // Caching is disabled just before starting the backend.
   618  // This allows the backend to run concurrently.
   619  var NewPtrCacheEnabled = true
   620  
   621  // NewPtr returns the pointer type pointing to t.
   622  func NewPtr(elem *Type) *Type {
   623  	if elem == nil {
   624  		base.Fatalf("NewPtr: pointer to elem Type is nil")
   625  	}
   626  
   627  	if t := elem.cache.ptr; t != nil {
   628  		if t.Elem() != elem {
   629  			base.Fatalf("NewPtr: elem mismatch")
   630  		}
   631  		if elem.HasShape() != t.HasShape() {
   632  			base.Fatalf("Incorrect HasShape flag for cached pointer type")
   633  		}
   634  		return t
   635  	}
   636  
   637  	t := newType(TPTR)
   638  	t.extra = Ptr{Elem: elem}
   639  	t.width = int64(PtrSize)
   640  	t.align = uint8(PtrSize)
   641  	t.intRegs = 1
   642  	if NewPtrCacheEnabled {
   643  		elem.cache.ptr = t
   644  	}
   645  	if elem.HasShape() {
   646  		t.SetHasShape(true)
   647  	}
   648  	t.alg = AMEM
   649  	if elem.Noalg() {
   650  		t.SetNoalg(true)
   651  		t.alg = ANOALG
   652  	}
   653  	// Note: we can't check elem.NotInHeap here because it might
   654  	// not be set yet. See size.go:PtrDataSize.
   655  	t.ptrBytes = int64(PtrSize)
   656  	return t
   657  }
   658  
   659  // NewChanArgs returns a new TCHANARGS type for channel type c.
   660  func NewChanArgs(c *Type) *Type {
   661  	t := newType(TCHANARGS)
   662  	t.extra = ChanArgs{T: c}
   663  	return t
   664  }
   665  
   666  // NewFuncArgs returns a new TFUNCARGS type for func type f.
   667  func NewFuncArgs(f *Type) *Type {
   668  	t := newType(TFUNCARGS)
   669  	t.extra = FuncArgs{T: f}
   670  	return t
   671  }
   672  
   673  func NewField(pos src.XPos, sym *Sym, typ *Type) *Field {
   674  	f := &Field{
   675  		Pos:    pos,
   676  		Sym:    sym,
   677  		Type:   typ,
   678  		Offset: BADWIDTH,
   679  	}
   680  	if typ == nil {
   681  		base.Fatalf("typ is nil")
   682  	}
   683  	return f
   684  }
   685  
   686  // SubstAny walks t, replacing instances of "any" with successive
   687  // elements removed from types.  It returns the substituted type.
   688  func SubstAny(t *Type, types *[]*Type) *Type {
   689  	if t == nil {
   690  		return nil
   691  	}
   692  
   693  	switch t.kind {
   694  	default:
   695  		// Leave the type unchanged.
   696  
   697  	case TANY:
   698  		if len(*types) == 0 {
   699  			base.Fatalf("SubstArgTypes: not enough argument types")
   700  		}
   701  		t = (*types)[0]
   702  		*types = (*types)[1:]
   703  
   704  	case TPTR:
   705  		elem := SubstAny(t.Elem(), types)
   706  		if elem != t.Elem() {
   707  			t = t.copy()
   708  			t.extra = Ptr{Elem: elem}
   709  		}
   710  
   711  	case TARRAY:
   712  		elem := SubstAny(t.Elem(), types)
   713  		if elem != t.Elem() {
   714  			t = t.copy()
   715  			t.extra.(*Array).Elem = elem
   716  		}
   717  
   718  	case TSLICE:
   719  		elem := SubstAny(t.Elem(), types)
   720  		if elem != t.Elem() {
   721  			t = t.copy()
   722  			t.extra = Slice{Elem: elem}
   723  		}
   724  
   725  	case TCHAN:
   726  		elem := SubstAny(t.Elem(), types)
   727  		if elem != t.Elem() {
   728  			t = t.copy()
   729  			t.extra.(*Chan).Elem = elem
   730  		}
   731  
   732  	case TMAP:
   733  		key := SubstAny(t.Key(), types)
   734  		elem := SubstAny(t.Elem(), types)
   735  		if key != t.Key() || elem != t.Elem() {
   736  			t = t.copy()
   737  			t.extra.(*Map).Key = key
   738  			t.extra.(*Map).Elem = elem
   739  		}
   740  
   741  	case TFUNC:
   742  		ft := t.funcType()
   743  		allParams := substFields(ft.allParams, types)
   744  
   745  		t = t.copy()
   746  		ft = t.funcType()
   747  		ft.allParams = allParams
   748  
   749  		rt := ft.resultsTuple
   750  		rt = rt.copy()
   751  		ft.resultsTuple = rt
   752  		rt.setFields(t.Results())
   753  
   754  	case TSTRUCT:
   755  		// Make a copy of all fields, including ones whose type does not change.
   756  		// This prevents aliasing across functions, which can lead to later
   757  		// fields getting their Offset incorrectly overwritten.
   758  		nfs := substFields(t.Fields(), types)
   759  		t = t.copy()
   760  		t.setFields(nfs)
   761  	}
   762  
   763  	return t
   764  }
   765  
   766  func substFields(fields []*Field, types *[]*Type) []*Field {
   767  	nfs := make([]*Field, len(fields))
   768  	for i, f := range fields {
   769  		nft := SubstAny(f.Type, types)
   770  		nfs[i] = f.Copy()
   771  		nfs[i].Type = nft
   772  	}
   773  	return nfs
   774  }
   775  
   776  // copy returns a shallow copy of the Type.
   777  func (t *Type) copy() *Type {
   778  	if t == nil {
   779  		return nil
   780  	}
   781  	nt := *t
   782  	// copy any *T Extra fields, to avoid aliasing
   783  	switch t.kind {
   784  	case TMAP:
   785  		x := *t.extra.(*Map)
   786  		nt.extra = &x
   787  	case TFORW:
   788  		x := *t.extra.(*Forward)
   789  		nt.extra = &x
   790  	case TFUNC:
   791  		x := *t.extra.(*Func)
   792  		nt.extra = &x
   793  	case TSTRUCT:
   794  		x := *t.extra.(*Struct)
   795  		nt.extra = &x
   796  	case TINTER:
   797  		x := *t.extra.(*Interface)
   798  		nt.extra = &x
   799  	case TCHAN:
   800  		x := *t.extra.(*Chan)
   801  		nt.extra = &x
   802  	case TARRAY:
   803  		x := *t.extra.(*Array)
   804  		nt.extra = &x
   805  	case TTUPLE, TSSA, TRESULTS:
   806  		base.Fatalf("ssa types cannot be copied")
   807  	}
   808  	// TODO(mdempsky): Find out why this is necessary and explain.
   809  	if t.underlying == t {
   810  		nt.underlying = &nt
   811  	}
   812  	return &nt
   813  }
   814  
   815  func (f *Field) Copy() *Field {
   816  	nf := *f
   817  	return &nf
   818  }
   819  
   820  func (t *Type) wantEtype(et Kind) {
   821  	if t.kind != et {
   822  		base.Fatalf("want %v, but have %v", et, t)
   823  	}
   824  }
   825  
   826  // ResultsTuple returns the result type of signature type t as a tuple.
   827  // This can be used as the type of multi-valued call expressions.
   828  func (t *Type) ResultsTuple() *Type { return t.funcType().resultsTuple }
   829  
   830  // Recvs returns a slice of receiver parameters of signature type t.
   831  // The returned slice always has length 0 or 1.
   832  func (t *Type) Recvs() []*Field { return t.funcType().recvs() }
   833  
   834  // Params returns a slice of regular parameters of signature type t.
   835  func (t *Type) Params() []*Field { return t.funcType().params() }
   836  
   837  // Results returns a slice of result parameters of signature type t.
   838  func (t *Type) Results() []*Field { return t.funcType().results() }
   839  
   840  // RecvParamsResults returns a slice containing all of the
   841  // signature's parameters in receiver (if any), (normal) parameters,
   842  // and then results.
   843  func (t *Type) RecvParamsResults() []*Field { return t.funcType().allParams }
   844  
   845  // RecvParams returns a slice containing the signature's receiver (if
   846  // any) followed by its (normal) parameters.
   847  func (t *Type) RecvParams() []*Field { return t.funcType().recvParams() }
   848  
   849  // ParamsResults returns a slice containing the signature's (normal)
   850  // parameters followed by its results.
   851  func (t *Type) ParamsResults() []*Field { return t.funcType().paramsResults() }
   852  
   853  func (t *Type) NumRecvs() int   { return len(t.Recvs()) }
   854  func (t *Type) NumParams() int  { return len(t.Params()) }
   855  func (t *Type) NumResults() int { return len(t.Results()) }
   856  
   857  // IsVariadic reports whether function type t is variadic.
   858  func (t *Type) IsVariadic() bool {
   859  	n := t.NumParams()
   860  	return n > 0 && t.Param(n-1).IsDDD()
   861  }
   862  
   863  // Recv returns the receiver of function type t, if any.
   864  func (t *Type) Recv() *Field {
   865  	if s := t.Recvs(); len(s) == 1 {
   866  		return s[0]
   867  	}
   868  	return nil
   869  }
   870  
   871  // Param returns the i'th parameter of signature type t.
   872  func (t *Type) Param(i int) *Field { return t.Params()[i] }
   873  
   874  // Result returns the i'th result of signature type t.
   875  func (t *Type) Result(i int) *Field { return t.Results()[i] }
   876  
   877  // Key returns the key type of map type t.
   878  func (t *Type) Key() *Type {
   879  	t.wantEtype(TMAP)
   880  	return t.extra.(*Map).Key
   881  }
   882  
   883  // Elem returns the type of elements of t.
   884  // Usable with pointers, channels, arrays, slices, and maps.
   885  func (t *Type) Elem() *Type {
   886  	switch t.kind {
   887  	case TPTR:
   888  		return t.extra.(Ptr).Elem
   889  	case TARRAY:
   890  		return t.extra.(*Array).Elem
   891  	case TSLICE:
   892  		return t.extra.(Slice).Elem
   893  	case TCHAN:
   894  		return t.extra.(*Chan).Elem
   895  	case TMAP:
   896  		return t.extra.(*Map).Elem
   897  	}
   898  	base.Fatalf("Type.Elem %s", t.kind)
   899  	return nil
   900  }
   901  
   902  // ChanArgs returns the channel type for TCHANARGS type t.
   903  func (t *Type) ChanArgs() *Type {
   904  	t.wantEtype(TCHANARGS)
   905  	return t.extra.(ChanArgs).T
   906  }
   907  
   908  // FuncArgs returns the func type for TFUNCARGS type t.
   909  func (t *Type) FuncArgs() *Type {
   910  	t.wantEtype(TFUNCARGS)
   911  	return t.extra.(FuncArgs).T
   912  }
   913  
   914  // IsFuncArgStruct reports whether t is a struct representing function parameters or results.
   915  func (t *Type) IsFuncArgStruct() bool {
   916  	return t.kind == TSTRUCT && t.extra.(*Struct).ParamTuple
   917  }
   918  
   919  // Methods returns a pointer to the base methods (excluding embedding) for type t.
   920  // These can either be concrete methods (for non-interface types) or interface
   921  // methods (for interface types).
   922  func (t *Type) Methods() []*Field {
   923  	return t.methods.Slice()
   924  }
   925  
   926  // AllMethods returns a pointer to all the methods (including embedding) for type t.
   927  // For an interface type, this is the set of methods that are typically iterated
   928  // over. For non-interface types, AllMethods() only returns a valid result after
   929  // CalcMethods() has been called at least once.
   930  func (t *Type) AllMethods() []*Field {
   931  	if t.kind == TINTER {
   932  		// Calculate the full method set of an interface type on the fly
   933  		// now, if not done yet.
   934  		CalcSize(t)
   935  	}
   936  	return t.allMethods.Slice()
   937  }
   938  
   939  // SetMethods sets the direct method set for type t (i.e., *not*
   940  // including promoted methods from embedded types).
   941  func (t *Type) SetMethods(fs []*Field) {
   942  	t.methods.Set(fs)
   943  }
   944  
   945  // SetAllMethods sets the set of all methods for type t (i.e.,
   946  // including promoted methods from embedded types).
   947  func (t *Type) SetAllMethods(fs []*Field) {
   948  	t.allMethods.Set(fs)
   949  }
   950  
   951  // fields returns the fields of struct type t.
   952  func (t *Type) fields() *fields {
   953  	t.wantEtype(TSTRUCT)
   954  	return &t.extra.(*Struct).fields
   955  }
   956  
   957  // Field returns the i'th field of struct type t.
   958  func (t *Type) Field(i int) *Field { return t.Fields()[i] }
   959  
   960  // Fields returns a slice of containing all fields of
   961  // a struct type t.
   962  func (t *Type) Fields() []*Field { return t.fields().Slice() }
   963  
   964  // setFields sets struct type t's fields to fields.
   965  func (t *Type) setFields(fields []*Field) {
   966  	// If we've calculated the width of t before,
   967  	// then some other type such as a function signature
   968  	// might now have the wrong type.
   969  	// Rather than try to track and invalidate those,
   970  	// enforce that SetFields cannot be called once
   971  	// t's width has been calculated.
   972  	if t.widthCalculated() {
   973  		base.Fatalf("SetFields of %v: width previously calculated", t)
   974  	}
   975  	t.wantEtype(TSTRUCT)
   976  	t.fields().Set(fields)
   977  }
   978  
   979  // SetInterface sets the base methods of an interface type t.
   980  func (t *Type) SetInterface(methods []*Field) {
   981  	t.wantEtype(TINTER)
   982  	t.methods.Set(methods)
   983  }
   984  
   985  // ArgWidth returns the total aligned argument size for a function.
   986  // It includes the receiver, parameters, and results.
   987  func (t *Type) ArgWidth() int64 {
   988  	t.wantEtype(TFUNC)
   989  	return t.extra.(*Func).Argwid
   990  }
   991  
   992  // Size returns the width of t in bytes.
   993  func (t *Type) Size() int64 {
   994  	if t.kind == TSSA {
   995  		return t.width
   996  	}
   997  	CalcSize(t)
   998  	return t.width
   999  }
  1000  
  1001  // Alignment returns the alignment of t in bytes.
  1002  func (t *Type) Alignment() int64 {
  1003  	CalcSize(t)
  1004  	return int64(t.align)
  1005  }
  1006  
  1007  func (t *Type) SimpleString() string {
  1008  	return t.kind.String()
  1009  }
  1010  
  1011  // Cmp is a comparison between values a and b.
  1012  //
  1013  //	-1 if a < b
  1014  //	 0 if a == b
  1015  //	 1 if a > b
  1016  type Cmp int8
  1017  
  1018  const (
  1019  	CMPlt = Cmp(-1)
  1020  	CMPeq = Cmp(0)
  1021  	CMPgt = Cmp(1)
  1022  )
  1023  
  1024  // Compare compares types for purposes of the SSA back
  1025  // end, returning a Cmp (one of CMPlt, CMPeq, CMPgt).
  1026  // The answers are correct for an optimizer
  1027  // or code generator, but not necessarily typechecking.
  1028  // The order chosen is arbitrary, only consistency and division
  1029  // into equivalence classes (Types that compare CMPeq) matters.
  1030  func (t *Type) Compare(x *Type) Cmp {
  1031  	if x == t {
  1032  		return CMPeq
  1033  	}
  1034  	return t.cmp(x)
  1035  }
  1036  
  1037  func cmpForNe(x bool) Cmp {
  1038  	if x {
  1039  		return CMPlt
  1040  	}
  1041  	return CMPgt
  1042  }
  1043  
  1044  func (r *Sym) cmpsym(s *Sym) Cmp {
  1045  	if r == s {
  1046  		return CMPeq
  1047  	}
  1048  	if r == nil {
  1049  		return CMPlt
  1050  	}
  1051  	if s == nil {
  1052  		return CMPgt
  1053  	}
  1054  	// Fast sort, not pretty sort
  1055  	if len(r.Name) != len(s.Name) {
  1056  		return cmpForNe(len(r.Name) < len(s.Name))
  1057  	}
  1058  	if r.Pkg != s.Pkg {
  1059  		if len(r.Pkg.Prefix) != len(s.Pkg.Prefix) {
  1060  			return cmpForNe(len(r.Pkg.Prefix) < len(s.Pkg.Prefix))
  1061  		}
  1062  		if r.Pkg.Prefix != s.Pkg.Prefix {
  1063  			return cmpForNe(r.Pkg.Prefix < s.Pkg.Prefix)
  1064  		}
  1065  	}
  1066  	if r.Name != s.Name {
  1067  		return cmpForNe(r.Name < s.Name)
  1068  	}
  1069  	return CMPeq
  1070  }
  1071  
  1072  // cmp compares two *Types t and x, returning CMPlt,
  1073  // CMPeq, CMPgt as t<x, t==x, t>x, for an arbitrary
  1074  // and optimizer-centric notion of comparison.
  1075  // TODO(josharian): make this safe for recursive interface types
  1076  // and use in signatlist sorting. See issue 19869.
  1077  func (t *Type) cmp(x *Type) Cmp {
  1078  	// This follows the structure of function identical in identity.go
  1079  	// with two exceptions.
  1080  	// 1. Symbols are compared more carefully because a <,=,> result is desired.
  1081  	// 2. Maps are treated specially to avoid endless recursion -- maps
  1082  	//    contain an internal data type not expressible in Go source code.
  1083  	if t == x {
  1084  		return CMPeq
  1085  	}
  1086  	if t == nil {
  1087  		return CMPlt
  1088  	}
  1089  	if x == nil {
  1090  		return CMPgt
  1091  	}
  1092  
  1093  	if t.kind != x.kind {
  1094  		return cmpForNe(t.kind < x.kind)
  1095  	}
  1096  
  1097  	if t.obj != nil || x.obj != nil {
  1098  		// Special case: we keep byte and uint8 separate
  1099  		// for error messages. Treat them as equal.
  1100  		switch t.kind {
  1101  		case TUINT8:
  1102  			if (t == Types[TUINT8] || t == ByteType) && (x == Types[TUINT8] || x == ByteType) {
  1103  				return CMPeq
  1104  			}
  1105  
  1106  		case TINT32:
  1107  			if (t == Types[RuneType.kind] || t == RuneType) && (x == Types[RuneType.kind] || x == RuneType) {
  1108  				return CMPeq
  1109  			}
  1110  
  1111  		case TINTER:
  1112  			// Make sure named any type matches any empty interface.
  1113  			if t == AnyType && x.IsEmptyInterface() || x == AnyType && t.IsEmptyInterface() {
  1114  				return CMPeq
  1115  			}
  1116  		}
  1117  	}
  1118  
  1119  	if c := t.Sym().cmpsym(x.Sym()); c != CMPeq {
  1120  		return c
  1121  	}
  1122  
  1123  	if x.obj != nil {
  1124  		return CMPeq
  1125  	}
  1126  	// both syms nil, look at structure below.
  1127  
  1128  	switch t.kind {
  1129  	case TBOOL, TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, TUNSAFEPTR, TUINTPTR,
  1130  		TINT8, TINT16, TINT32, TINT64, TINT, TUINT8, TUINT16, TUINT32, TUINT64, TUINT:
  1131  		return CMPeq
  1132  
  1133  	case TSSA:
  1134  		tname := t.extra.(string)
  1135  		xname := x.extra.(string)
  1136  		// desire fast sorting, not pretty sorting.
  1137  		if len(tname) == len(xname) {
  1138  			if tname == xname {
  1139  				return CMPeq
  1140  			}
  1141  			if tname < xname {
  1142  				return CMPlt
  1143  			}
  1144  			return CMPgt
  1145  		}
  1146  		if len(tname) > len(xname) {
  1147  			return CMPgt
  1148  		}
  1149  		return CMPlt
  1150  
  1151  	case TTUPLE:
  1152  		xtup := x.extra.(*Tuple)
  1153  		ttup := t.extra.(*Tuple)
  1154  		if c := ttup.first.Compare(xtup.first); c != CMPeq {
  1155  			return c
  1156  		}
  1157  		return ttup.second.Compare(xtup.second)
  1158  
  1159  	case TRESULTS:
  1160  		xResults := x.extra.(*Results)
  1161  		tResults := t.extra.(*Results)
  1162  		xl, tl := len(xResults.Types), len(tResults.Types)
  1163  		if tl != xl {
  1164  			if tl < xl {
  1165  				return CMPlt
  1166  			}
  1167  			return CMPgt
  1168  		}
  1169  		for i := 0; i < tl; i++ {
  1170  			if c := tResults.Types[i].Compare(xResults.Types[i]); c != CMPeq {
  1171  				return c
  1172  			}
  1173  		}
  1174  		return CMPeq
  1175  
  1176  	case TMAP:
  1177  		if c := t.Key().cmp(x.Key()); c != CMPeq {
  1178  			return c
  1179  		}
  1180  		return t.Elem().cmp(x.Elem())
  1181  
  1182  	case TPTR, TSLICE:
  1183  		// No special cases for these, they are handled
  1184  		// by the general code after the switch.
  1185  
  1186  	case TSTRUCT:
  1187  		// Is this a map group type?
  1188  		if t.StructType().Map == nil {
  1189  			if x.StructType().Map != nil {
  1190  				return CMPlt // nil < non-nil
  1191  			}
  1192  			// to the general case
  1193  		} else if x.StructType().Map == nil {
  1194  			return CMPgt // nil > non-nil
  1195  		}
  1196  		// Both have non-nil Map, fallthrough to the general
  1197  		// case. Note that the map type does not directly refer
  1198  		// to the group type (it uses unsafe.Pointer). If it
  1199  		// did, this would need special handling to avoid
  1200  		// infinite recursion.
  1201  
  1202  		tfs := t.Fields()
  1203  		xfs := x.Fields()
  1204  		for i := 0; i < len(tfs) && i < len(xfs); i++ {
  1205  			t1, x1 := tfs[i], xfs[i]
  1206  			if t1.Embedded != x1.Embedded {
  1207  				return cmpForNe(t1.Embedded < x1.Embedded)
  1208  			}
  1209  			if t1.Note != x1.Note {
  1210  				return cmpForNe(t1.Note < x1.Note)
  1211  			}
  1212  			if c := t1.Sym.cmpsym(x1.Sym); c != CMPeq {
  1213  				return c
  1214  			}
  1215  			if c := t1.Type.cmp(x1.Type); c != CMPeq {
  1216  				return c
  1217  			}
  1218  		}
  1219  		if len(tfs) != len(xfs) {
  1220  			return cmpForNe(len(tfs) < len(xfs))
  1221  		}
  1222  		return CMPeq
  1223  
  1224  	case TINTER:
  1225  		tfs := t.AllMethods()
  1226  		xfs := x.AllMethods()
  1227  		for i := 0; i < len(tfs) && i < len(xfs); i++ {
  1228  			t1, x1 := tfs[i], xfs[i]
  1229  			if c := t1.Sym.cmpsym(x1.Sym); c != CMPeq {
  1230  				return c
  1231  			}
  1232  			if c := t1.Type.cmp(x1.Type); c != CMPeq {
  1233  				return c
  1234  			}
  1235  		}
  1236  		if len(tfs) != len(xfs) {
  1237  			return cmpForNe(len(tfs) < len(xfs))
  1238  		}
  1239  		return CMPeq
  1240  
  1241  	case TFUNC:
  1242  		if tn, xn := t.NumRecvs(), x.NumRecvs(); tn != xn {
  1243  			return cmpForNe(tn < xn)
  1244  		}
  1245  		if tn, xn := t.NumParams(), x.NumParams(); tn != xn {
  1246  			return cmpForNe(tn < xn)
  1247  		}
  1248  		if tn, xn := t.NumResults(), x.NumResults(); tn != xn {
  1249  			return cmpForNe(tn < xn)
  1250  		}
  1251  		if tv, xv := t.IsVariadic(), x.IsVariadic(); tv != xv {
  1252  			return cmpForNe(!tv)
  1253  		}
  1254  
  1255  		tfs := t.RecvParamsResults()
  1256  		xfs := x.RecvParamsResults()
  1257  		for i, tf := range tfs {
  1258  			if c := tf.Type.cmp(xfs[i].Type); c != CMPeq {
  1259  				return c
  1260  			}
  1261  		}
  1262  		return CMPeq
  1263  
  1264  	case TARRAY:
  1265  		if t.NumElem() != x.NumElem() {
  1266  			return cmpForNe(t.NumElem() < x.NumElem())
  1267  		}
  1268  
  1269  	case TCHAN:
  1270  		if t.ChanDir() != x.ChanDir() {
  1271  			return cmpForNe(t.ChanDir() < x.ChanDir())
  1272  		}
  1273  
  1274  	default:
  1275  		e := fmt.Sprintf("Do not know how to compare %v with %v", t, x)
  1276  		panic(e)
  1277  	}
  1278  
  1279  	// Common element type comparison for TARRAY, TCHAN, TPTR, and TSLICE.
  1280  	return t.Elem().cmp(x.Elem())
  1281  }
  1282  
  1283  // IsKind reports whether t is a Type of the specified kind.
  1284  func (t *Type) IsKind(et Kind) bool {
  1285  	return t != nil && t.kind == et
  1286  }
  1287  
  1288  func (t *Type) IsBoolean() bool {
  1289  	return t.kind == TBOOL
  1290  }
  1291  
  1292  var unsignedEType = [...]Kind{
  1293  	TINT8:    TUINT8,
  1294  	TUINT8:   TUINT8,
  1295  	TINT16:   TUINT16,
  1296  	TUINT16:  TUINT16,
  1297  	TINT32:   TUINT32,
  1298  	TUINT32:  TUINT32,
  1299  	TINT64:   TUINT64,
  1300  	TUINT64:  TUINT64,
  1301  	TINT:     TUINT,
  1302  	TUINT:    TUINT,
  1303  	TUINTPTR: TUINTPTR,
  1304  }
  1305  
  1306  // ToUnsigned returns the unsigned equivalent of integer type t.
  1307  func (t *Type) ToUnsigned() *Type {
  1308  	if !t.IsInteger() {
  1309  		base.Fatalf("unsignedType(%v)", t)
  1310  	}
  1311  	return Types[unsignedEType[t.kind]]
  1312  }
  1313  
  1314  func (t *Type) IsInteger() bool {
  1315  	switch t.kind {
  1316  	case TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64, TUINT64, TINT, TUINT, TUINTPTR:
  1317  		return true
  1318  	}
  1319  	return t == UntypedInt || t == UntypedRune
  1320  }
  1321  
  1322  func (t *Type) IsSigned() bool {
  1323  	switch t.kind {
  1324  	case TINT8, TINT16, TINT32, TINT64, TINT:
  1325  		return true
  1326  	}
  1327  	return false
  1328  }
  1329  
  1330  func (t *Type) IsUnsigned() bool {
  1331  	switch t.kind {
  1332  	case TUINT8, TUINT16, TUINT32, TUINT64, TUINT, TUINTPTR:
  1333  		return true
  1334  	}
  1335  	return false
  1336  }
  1337  
  1338  func (t *Type) IsFloat() bool {
  1339  	return t.kind == TFLOAT32 || t.kind == TFLOAT64 || t == UntypedFloat
  1340  }
  1341  
  1342  func (t *Type) IsComplex() bool {
  1343  	return t.kind == TCOMPLEX64 || t.kind == TCOMPLEX128 || t == UntypedComplex
  1344  }
  1345  
  1346  // IsPtr reports whether t is a regular Go pointer type.
  1347  // This does not include unsafe.Pointer.
  1348  func (t *Type) IsPtr() bool {
  1349  	return t.kind == TPTR
  1350  }
  1351  
  1352  // IsPtrElem reports whether t is the element of a pointer (to t).
  1353  func (t *Type) IsPtrElem() bool {
  1354  	return t.cache.ptr != nil
  1355  }
  1356  
  1357  // IsUnsafePtr reports whether t is an unsafe pointer.
  1358  func (t *Type) IsUnsafePtr() bool {
  1359  	return t.kind == TUNSAFEPTR
  1360  }
  1361  
  1362  // IsUintptr reports whether t is a uintptr.
  1363  func (t *Type) IsUintptr() bool {
  1364  	return t.kind == TUINTPTR
  1365  }
  1366  
  1367  // IsPtrShaped reports whether t is represented by a single machine pointer.
  1368  // In addition to regular Go pointer types, this includes map, channel, and
  1369  // function types and unsafe.Pointer. It does not include array or struct types
  1370  // that consist of a single pointer shaped type.
  1371  // TODO(mdempsky): Should it? See golang.org/issue/15028.
  1372  func (t *Type) IsPtrShaped() bool {
  1373  	return t.kind == TPTR || t.kind == TUNSAFEPTR ||
  1374  		t.kind == TMAP || t.kind == TCHAN || t.kind == TFUNC
  1375  }
  1376  
  1377  // HasNil reports whether the set of values determined by t includes nil.
  1378  func (t *Type) HasNil() bool {
  1379  	switch t.kind {
  1380  	case TCHAN, TFUNC, TINTER, TMAP, TNIL, TPTR, TSLICE, TUNSAFEPTR:
  1381  		return true
  1382  	}
  1383  	return false
  1384  }
  1385  
  1386  func (t *Type) IsString() bool {
  1387  	return t.kind == TSTRING
  1388  }
  1389  
  1390  func (t *Type) IsMap() bool {
  1391  	return t.kind == TMAP
  1392  }
  1393  
  1394  func (t *Type) IsChan() bool {
  1395  	return t.kind == TCHAN
  1396  }
  1397  
  1398  func (t *Type) IsSlice() bool {
  1399  	return t.kind == TSLICE
  1400  }
  1401  
  1402  func (t *Type) IsArray() bool {
  1403  	return t.kind == TARRAY
  1404  }
  1405  
  1406  func (t *Type) IsStruct() bool {
  1407  	return t.kind == TSTRUCT
  1408  }
  1409  
  1410  func (t *Type) IsInterface() bool {
  1411  	return t.kind == TINTER
  1412  }
  1413  
  1414  // IsEmptyInterface reports whether t is an empty interface type.
  1415  func (t *Type) IsEmptyInterface() bool {
  1416  	return t.IsInterface() && len(t.AllMethods()) == 0
  1417  }
  1418  
  1419  // IsScalar reports whether 't' is a scalar Go type, e.g.
  1420  // bool/int/float/complex. Note that struct and array types consisting
  1421  // of a single scalar element are not considered scalar, likewise
  1422  // pointer types are also not considered scalar.
  1423  func (t *Type) IsScalar() bool {
  1424  	switch t.kind {
  1425  	case TBOOL, TINT8, TUINT8, TINT16, TUINT16, TINT32,
  1426  		TUINT32, TINT64, TUINT64, TINT, TUINT,
  1427  		TUINTPTR, TCOMPLEX64, TCOMPLEX128, TFLOAT32, TFLOAT64:
  1428  		return true
  1429  	}
  1430  	return false
  1431  }
  1432  
  1433  func (t *Type) PtrTo() *Type {
  1434  	return NewPtr(t)
  1435  }
  1436  
  1437  func (t *Type) NumFields() int {
  1438  	if t.kind == TRESULTS {
  1439  		return len(t.extra.(*Results).Types)
  1440  	}
  1441  	return len(t.Fields())
  1442  }
  1443  func (t *Type) FieldType(i int) *Type {
  1444  	if t.kind == TTUPLE {
  1445  		switch i {
  1446  		case 0:
  1447  			return t.extra.(*Tuple).first
  1448  		case 1:
  1449  			return t.extra.(*Tuple).second
  1450  		default:
  1451  			panic("bad tuple index")
  1452  		}
  1453  	}
  1454  	if t.kind == TRESULTS {
  1455  		return t.extra.(*Results).Types[i]
  1456  	}
  1457  	return t.Field(i).Type
  1458  }
  1459  func (t *Type) FieldOff(i int) int64 {
  1460  	return t.Field(i).Offset
  1461  }
  1462  func (t *Type) FieldName(i int) string {
  1463  	return t.Field(i).Sym.Name
  1464  }
  1465  
  1466  // OffsetOf reports the offset of the field of a struct.
  1467  // The field is looked up by name.
  1468  func (t *Type) OffsetOf(name string) int64 {
  1469  	if t.kind != TSTRUCT {
  1470  		base.Fatalf("can't call OffsetOf on non-struct %v", t)
  1471  	}
  1472  	for _, f := range t.Fields() {
  1473  		if f.Sym.Name == name {
  1474  			return f.Offset
  1475  		}
  1476  	}
  1477  	base.Fatalf("couldn't find field %s in %v", name, t)
  1478  	return -1
  1479  }
  1480  
  1481  func (t *Type) NumElem() int64 {
  1482  	t.wantEtype(TARRAY)
  1483  	return t.extra.(*Array).Bound
  1484  }
  1485  
  1486  type componentsIncludeBlankFields bool
  1487  
  1488  const (
  1489  	IgnoreBlankFields componentsIncludeBlankFields = false
  1490  	CountBlankFields  componentsIncludeBlankFields = true
  1491  )
  1492  
  1493  // NumComponents returns the number of primitive elements that compose t.
  1494  // Struct and array types are flattened for the purpose of counting.
  1495  // All other types (including string, slice, and interface types) count as one element.
  1496  // If countBlank is IgnoreBlankFields, then blank struct fields
  1497  // (and their comprised elements) are excluded from the count.
  1498  // struct { x, y [3]int } has six components; [10]struct{ x, y string } has twenty.
  1499  func (t *Type) NumComponents(countBlank componentsIncludeBlankFields) int64 {
  1500  	switch t.kind {
  1501  	case TSTRUCT:
  1502  		if t.IsFuncArgStruct() {
  1503  			base.Fatalf("NumComponents func arg struct")
  1504  		}
  1505  		var n int64
  1506  		for _, f := range t.Fields() {
  1507  			if countBlank == IgnoreBlankFields && f.Sym.IsBlank() {
  1508  				continue
  1509  			}
  1510  			n += f.Type.NumComponents(countBlank)
  1511  		}
  1512  		return n
  1513  	case TARRAY:
  1514  		return t.NumElem() * t.Elem().NumComponents(countBlank)
  1515  	}
  1516  	return 1
  1517  }
  1518  
  1519  // SoleComponent returns the only primitive component in t,
  1520  // if there is exactly one. Otherwise, it returns nil.
  1521  // Components are counted as in NumComponents, including blank fields.
  1522  // Keep in sync with cmd/compile/internal/walk/convert.go:soleComponent.
  1523  func (t *Type) SoleComponent() *Type {
  1524  	switch t.kind {
  1525  	case TSTRUCT:
  1526  		if t.IsFuncArgStruct() {
  1527  			base.Fatalf("SoleComponent func arg struct")
  1528  		}
  1529  		if t.NumFields() != 1 {
  1530  			return nil
  1531  		}
  1532  		return t.Field(0).Type.SoleComponent()
  1533  	case TARRAY:
  1534  		if t.NumElem() != 1 {
  1535  			return nil
  1536  		}
  1537  		return t.Elem().SoleComponent()
  1538  	}
  1539  	return t
  1540  }
  1541  
  1542  // ChanDir returns the direction of a channel type t.
  1543  // The direction will be one of Crecv, Csend, or Cboth.
  1544  func (t *Type) ChanDir() ChanDir {
  1545  	t.wantEtype(TCHAN)
  1546  	return t.extra.(*Chan).Dir
  1547  }
  1548  
  1549  func (t *Type) IsMemory() bool {
  1550  	if t == TypeMem || t.kind == TTUPLE && t.extra.(*Tuple).second == TypeMem {
  1551  		return true
  1552  	}
  1553  	if t.kind == TRESULTS {
  1554  		if types := t.extra.(*Results).Types; len(types) > 0 && types[len(types)-1] == TypeMem {
  1555  			return true
  1556  		}
  1557  	}
  1558  	return false
  1559  }
  1560  func (t *Type) IsFlags() bool   { return t == TypeFlags }
  1561  func (t *Type) IsVoid() bool    { return t == TypeVoid }
  1562  func (t *Type) IsTuple() bool   { return t.kind == TTUPLE }
  1563  func (t *Type) IsResults() bool { return t.kind == TRESULTS }
  1564  
  1565  // IsUntyped reports whether t is an untyped type.
  1566  func (t *Type) IsUntyped() bool {
  1567  	if t == nil {
  1568  		return false
  1569  	}
  1570  	if t == UntypedString || t == UntypedBool {
  1571  		return true
  1572  	}
  1573  	switch t.kind {
  1574  	case TNIL, TIDEAL:
  1575  		return true
  1576  	}
  1577  	return false
  1578  }
  1579  
  1580  // HasPointers reports whether t contains a heap pointer.
  1581  // Note that this function ignores pointers to not-in-heap types.
  1582  func (t *Type) HasPointers() bool {
  1583  	return PtrDataSize(t) > 0
  1584  }
  1585  
  1586  var recvType *Type
  1587  
  1588  // FakeRecvType returns the singleton type used for interface method receivers.
  1589  func FakeRecvType() *Type {
  1590  	if recvType == nil {
  1591  		recvType = NewPtr(newType(TSTRUCT))
  1592  	}
  1593  	return recvType
  1594  }
  1595  
  1596  func FakeRecv() *Field {
  1597  	return NewField(base.AutogeneratedPos, nil, FakeRecvType())
  1598  }
  1599  
  1600  var (
  1601  	// TSSA types. HasPointers assumes these are pointer-free.
  1602  	TypeInvalid   = newSSA("invalid")
  1603  	TypeMem       = newSSA("mem")
  1604  	TypeFlags     = newSSA("flags")
  1605  	TypeVoid      = newSSA("void")
  1606  	TypeInt128    = newSSA("int128")
  1607  	TypeVec128    = newSIMD("vec128")
  1608  	TypeVec256    = newSIMD("vec256")
  1609  	TypeVec512    = newSIMD("vec512")
  1610  	TypeMask      = newSIMD("mask") // not a vector, not 100% sure what this should be.
  1611  	TypeResultMem = newResults([]*Type{TypeMem})
  1612  )
  1613  
  1614  func init() {
  1615  	TypeInt128.width = 16
  1616  	TypeInt128.align = 8
  1617  
  1618  	TypeVec128.width = 16
  1619  	TypeVec128.align = 8
  1620  	TypeVec256.width = 32
  1621  	TypeVec256.align = 8
  1622  	TypeVec512.width = 64
  1623  	TypeVec512.align = 8
  1624  
  1625  	TypeMask.width = 8 // This will depend on the architecture; spilling will be "interesting".
  1626  	TypeMask.align = 8
  1627  }
  1628  
  1629  // NewNamed returns a new named type for the given type name. obj should be an
  1630  // ir.Name. The new type is incomplete (marked as TFORW kind), and the underlying
  1631  // type should be set later via SetUnderlying(). References to the type are
  1632  // maintained until the type is filled in, so those references can be updated when
  1633  // the type is complete.
  1634  func NewNamed(obj Object) *Type {
  1635  	t := newType(TFORW)
  1636  	t.obj = obj
  1637  	sym := obj.Sym()
  1638  	if sym.Pkg == ShapePkg {
  1639  		t.SetIsShape(true)
  1640  		t.SetHasShape(true)
  1641  	}
  1642  	if sym.Pkg.Path == "internal/runtime/sys" && sym.Name == "nih" {
  1643  		// Recognize the special not-in-heap type. Any type including
  1644  		// this type will also be not-in-heap.
  1645  		// This logic is duplicated in go/types and
  1646  		// cmd/compile/internal/types2.
  1647  		t.SetNotInHeap(true)
  1648  	}
  1649  	return t
  1650  }
  1651  
  1652  // Obj returns the canonical type name node for a named type t, nil for an unnamed type.
  1653  func (t *Type) Obj() Object {
  1654  	return t.obj
  1655  }
  1656  
  1657  // SetUnderlying sets the underlying type of an incomplete type (i.e. type whose kind
  1658  // is currently TFORW). SetUnderlying automatically updates any types that were waiting
  1659  // for this type to be completed.
  1660  func (t *Type) SetUnderlying(underlying *Type) {
  1661  	if underlying.kind == TFORW {
  1662  		// This type isn't computed yet; when it is, update n.
  1663  		underlying.forwardType().Copyto = append(underlying.forwardType().Copyto, t)
  1664  		return
  1665  	}
  1666  
  1667  	ft := t.forwardType()
  1668  
  1669  	// TODO(mdempsky): Fix Type rekinding.
  1670  	t.kind = underlying.kind
  1671  	t.extra = underlying.extra
  1672  	t.width = underlying.width
  1673  	t.align = underlying.align
  1674  	t.alg = underlying.alg
  1675  	t.ptrBytes = underlying.ptrBytes
  1676  	t.intRegs = underlying.intRegs
  1677  	t.floatRegs = underlying.floatRegs
  1678  	t.underlying = underlying.underlying
  1679  
  1680  	if underlying.NotInHeap() {
  1681  		t.SetNotInHeap(true)
  1682  	}
  1683  	if underlying.HasShape() {
  1684  		t.SetHasShape(true)
  1685  	}
  1686  	if underlying.isSIMD {
  1687  		simdify(t, underlying.isSIMDTag)
  1688  	}
  1689  
  1690  	// spec: "The declared type does not inherit any methods bound
  1691  	// to the existing type, but the method set of an interface
  1692  	// type [...] remains unchanged."
  1693  	if t.IsInterface() {
  1694  		t.methods = underlying.methods
  1695  		t.allMethods = underlying.allMethods
  1696  	}
  1697  
  1698  	// Update types waiting on this type.
  1699  	for _, w := range ft.Copyto {
  1700  		w.SetUnderlying(t)
  1701  	}
  1702  
  1703  	// Double-check use of type as embedded type.
  1704  	if ft.Embedlineno.IsKnown() {
  1705  		if t.IsPtr() || t.IsUnsafePtr() {
  1706  			base.ErrorfAt(ft.Embedlineno, errors.InvalidPtrEmbed, "embedded type cannot be a pointer")
  1707  		}
  1708  	}
  1709  }
  1710  
  1711  func fieldsHasShape(fields []*Field) bool {
  1712  	for _, f := range fields {
  1713  		if f.Type != nil && f.Type.HasShape() {
  1714  			return true
  1715  		}
  1716  	}
  1717  	return false
  1718  }
  1719  
  1720  // NewInterface returns a new interface for the given methods and
  1721  // embedded types. Embedded types are specified as fields with no Sym.
  1722  func NewInterface(methods []*Field) *Type {
  1723  	t := newType(TINTER)
  1724  	t.SetInterface(methods)
  1725  	for _, f := range methods {
  1726  		// f.Type could be nil for a broken interface declaration
  1727  		if f.Type != nil && f.Type.HasShape() {
  1728  			t.SetHasShape(true)
  1729  			break
  1730  		}
  1731  	}
  1732  	return t
  1733  }
  1734  
  1735  // NewSignature returns a new function type for the given receiver,
  1736  // parameters, and results, any of which may be nil.
  1737  func NewSignature(recv *Field, params, results []*Field) *Type {
  1738  	startParams := 0
  1739  	if recv != nil {
  1740  		startParams = 1
  1741  	}
  1742  	startResults := startParams + len(params)
  1743  
  1744  	allParams := make([]*Field, startResults+len(results))
  1745  	if recv != nil {
  1746  		allParams[0] = recv
  1747  	}
  1748  	copy(allParams[startParams:], params)
  1749  	copy(allParams[startResults:], results)
  1750  
  1751  	t := newType(TFUNC)
  1752  	ft := t.funcType()
  1753  
  1754  	funargs := func(fields []*Field) *Type {
  1755  		s := NewStruct(fields)
  1756  		s.StructType().ParamTuple = true
  1757  		return s
  1758  	}
  1759  
  1760  	ft.allParams = allParams
  1761  	ft.startParams = startParams
  1762  	ft.startResults = startResults
  1763  
  1764  	ft.resultsTuple = funargs(allParams[startResults:])
  1765  
  1766  	if fieldsHasShape(allParams) {
  1767  		t.SetHasShape(true)
  1768  	}
  1769  
  1770  	return t
  1771  }
  1772  
  1773  // NewStruct returns a new struct with the given fields.
  1774  func NewStruct(fields []*Field) *Type {
  1775  	t := newType(TSTRUCT)
  1776  	t.setFields(fields)
  1777  	if fieldsHasShape(fields) {
  1778  		t.SetHasShape(true)
  1779  	}
  1780  	for _, f := range fields {
  1781  		if f.Type.NotInHeap() {
  1782  			t.SetNotInHeap(true)
  1783  			break
  1784  		}
  1785  	}
  1786  
  1787  	return t
  1788  }
  1789  
  1790  var (
  1791  	IsInt     [NTYPE]bool
  1792  	IsFloat   [NTYPE]bool
  1793  	IsComplex [NTYPE]bool
  1794  	IsSimple  [NTYPE]bool
  1795  )
  1796  
  1797  var IsOrdered [NTYPE]bool
  1798  
  1799  // IsReflexive reports whether t has a reflexive equality operator.
  1800  // That is, if x==x for all x of type t.
  1801  func IsReflexive(t *Type) bool {
  1802  	switch t.Kind() {
  1803  	case TBOOL,
  1804  		TINT,
  1805  		TUINT,
  1806  		TINT8,
  1807  		TUINT8,
  1808  		TINT16,
  1809  		TUINT16,
  1810  		TINT32,
  1811  		TUINT32,
  1812  		TINT64,
  1813  		TUINT64,
  1814  		TUINTPTR,
  1815  		TPTR,
  1816  		TUNSAFEPTR,
  1817  		TSTRING,
  1818  		TCHAN:
  1819  		return true
  1820  
  1821  	case TFLOAT32,
  1822  		TFLOAT64,
  1823  		TCOMPLEX64,
  1824  		TCOMPLEX128,
  1825  		TINTER:
  1826  		return false
  1827  
  1828  	case TARRAY:
  1829  		return IsReflexive(t.Elem())
  1830  
  1831  	case TSTRUCT:
  1832  		for _, t1 := range t.Fields() {
  1833  			if !IsReflexive(t1.Type) {
  1834  				return false
  1835  			}
  1836  		}
  1837  		return true
  1838  
  1839  	default:
  1840  		base.Fatalf("bad type for map key: %v", t)
  1841  		return false
  1842  	}
  1843  }
  1844  
  1845  // Can this type be stored directly in an interface word?
  1846  // Yes, if the representation is a single pointer.
  1847  func IsDirectIface(t *Type) bool {
  1848  	return t.Size() == int64(PtrSize) && PtrDataSize(t) == int64(PtrSize)
  1849  }
  1850  
  1851  // IsInterfaceMethod reports whether (field) m is
  1852  // an interface method. Such methods have the
  1853  // special receiver type types.FakeRecvType().
  1854  func IsInterfaceMethod(f *Type) bool {
  1855  	return f.Recv().Type == FakeRecvType()
  1856  }
  1857  
  1858  // IsMethodApplicable reports whether method m can be called on a
  1859  // value of type t. This is necessary because we compute a single
  1860  // method set for both T and *T, but some *T methods are not
  1861  // applicable to T receivers.
  1862  func IsMethodApplicable(t *Type, m *Field) bool {
  1863  	return t.IsPtr() || !m.Type.Recv().Type.IsPtr() || IsInterfaceMethod(m.Type) || m.Embedded == 2
  1864  }
  1865  
  1866  // RuntimeSymName returns the name of s if it's in package "runtime"; otherwise
  1867  // it returns "".
  1868  func RuntimeSymName(s *Sym) string {
  1869  	if s.Pkg.Path == "runtime" {
  1870  		return s.Name
  1871  	}
  1872  	return ""
  1873  }
  1874  
  1875  // ReflectSymName returns the name of s if it's in package "reflect"; otherwise
  1876  // it returns "".
  1877  func ReflectSymName(s *Sym) string {
  1878  	if s.Pkg.Path == "reflect" {
  1879  		return s.Name
  1880  	}
  1881  	return ""
  1882  }
  1883  
  1884  // IsNoInstrumentPkg reports whether p is a package that
  1885  // should not be instrumented.
  1886  func IsNoInstrumentPkg(p *Pkg) bool {
  1887  	return objabi.LookupPkgSpecial(p.Path).NoInstrument
  1888  }
  1889  
  1890  // IsNoRacePkg reports whether p is a package that
  1891  // should not be race instrumented.
  1892  func IsNoRacePkg(p *Pkg) bool {
  1893  	return objabi.LookupPkgSpecial(p.Path).NoRaceFunc
  1894  }
  1895  
  1896  // IsRuntimePkg reports whether p is a runtime package.
  1897  func IsRuntimePkg(p *Pkg) bool {
  1898  	return objabi.LookupPkgSpecial(p.Path).Runtime
  1899  }
  1900  
  1901  // ReceiverBaseType returns the underlying type, if any,
  1902  // that owns methods with receiver parameter t.
  1903  // The result is either a named type or an anonymous struct.
  1904  func ReceiverBaseType(t *Type) *Type {
  1905  	if t == nil {
  1906  		return nil
  1907  	}
  1908  
  1909  	// Strip away pointer if it's there.
  1910  	if t.IsPtr() {
  1911  		if t.Sym() != nil {
  1912  			return nil
  1913  		}
  1914  		t = t.Elem()
  1915  		if t == nil {
  1916  			return nil
  1917  		}
  1918  	}
  1919  
  1920  	// Must be a named type or anonymous struct.
  1921  	if t.Sym() == nil && !t.IsStruct() {
  1922  		return nil
  1923  	}
  1924  
  1925  	// Check types.
  1926  	if IsSimple[t.Kind()] {
  1927  		return t
  1928  	}
  1929  	switch t.Kind() {
  1930  	case TARRAY, TCHAN, TFUNC, TMAP, TSLICE, TSTRING, TSTRUCT:
  1931  		return t
  1932  	}
  1933  	return nil
  1934  }
  1935  
  1936  func FloatForComplex(t *Type) *Type {
  1937  	switch t.Kind() {
  1938  	case TCOMPLEX64:
  1939  		return Types[TFLOAT32]
  1940  	case TCOMPLEX128:
  1941  		return Types[TFLOAT64]
  1942  	}
  1943  	base.Fatalf("unexpected type: %v", t)
  1944  	return nil
  1945  }
  1946  
  1947  func ComplexForFloat(t *Type) *Type {
  1948  	switch t.Kind() {
  1949  	case TFLOAT32:
  1950  		return Types[TCOMPLEX64]
  1951  	case TFLOAT64:
  1952  		return Types[TCOMPLEX128]
  1953  	}
  1954  	base.Fatalf("unexpected type: %v", t)
  1955  	return nil
  1956  }
  1957  
  1958  func TypeSym(t *Type) *Sym {
  1959  	return TypeSymLookup(TypeSymName(t))
  1960  }
  1961  
  1962  func TypeSymLookup(name string) *Sym {
  1963  	typepkgmu.Lock()
  1964  	s := typepkg.Lookup(name)
  1965  	typepkgmu.Unlock()
  1966  	return s
  1967  }
  1968  
  1969  func TypeSymName(t *Type) string {
  1970  	name := t.LinkString()
  1971  	// Use a separate symbol name for Noalg types for #17752.
  1972  	if TypeHasNoAlg(t) {
  1973  		name = "noalg." + name
  1974  	}
  1975  	return name
  1976  }
  1977  
  1978  // Fake package for runtime type info (headers)
  1979  // Don't access directly, use typeLookup below.
  1980  var (
  1981  	typepkgmu sync.Mutex // protects typepkg lookups
  1982  	typepkg   = NewPkg("type", "type")
  1983  )
  1984  
  1985  var SimType [NTYPE]Kind
  1986  
  1987  // Fake package for shape types (see typecheck.Shapify()).
  1988  var ShapePkg = NewPkg("go.shape", "go.shape")
  1989  
  1990  func (t *Type) IsSIMD() bool {
  1991  	return t.isSIMD
  1992  }
  1993  

View as plain text