type.go

     1  // Copyright 2023 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 abi
     6  
     7  import (
     8  	"unsafe"
     9  )
    10  
    11  // Type is the runtime representation of a Go type.
    12  //
    13  // Be careful about accessing this type at build time, as the version
    14  // of this type in the compiler/linker may not have the same layout
    15  // as the version in the target binary, due to pointer width
    16  // differences and any experiments. Use cmd/compile/internal/rttype
    17  // or the functions in compiletype.go to access this type instead.
    18  // (TODO: this admonition applies to every type in this package.
    19  // Put it in some shared location?)
    20  type Type struct {
    21  	Size_       uintptr
    22  	PtrBytes    uintptr // number of (prefix) bytes in the type that can contain pointers
    23  	Hash        uint32  // hash of type; avoids computation in hash tables
    24  	TFlag       TFlag   // extra type information flags
    25  	Align_      uint8   // alignment of variable with this type
    26  	FieldAlign_ uint8   // alignment of struct field with this type
    27  	Kind_       Kind    // enumeration for C
    28  	// function for comparing objects of this type
    29  	// (ptr to object A, ptr to object B) -> ==?
    30  	Equal func(unsafe.Pointer, unsafe.Pointer) bool
    31  	// GCData stores the GC type data for the garbage collector.
    32  	// Normally, GCData points to a bitmask that describes the
    33  	// ptr/nonptr fields of the type. The bitmask will have at
    34  	// least PtrBytes/ptrSize bits.
    35  	// If the TFlagGCMaskOnDemand bit is set, GCData is instead a
    36  	// **byte and the pointer to the bitmask is one dereference away.
    37  	// The runtime will build the bitmask if needed.
    38  	// (See runtime/type.go:getGCMask.)
    39  	// Note: multiple types may have the same value of GCData,
    40  	// including when TFlagGCMaskOnDemand is set. The types will, of course,
    41  	// have the same pointer layout (but not necessarily the same size).
    42  	GCData    *byte
    43  	Str       NameOff // string form
    44  	PtrToThis TypeOff // type for pointer to this type, may be zero
    45  }
    46  
    47  // A Kind represents the specific kind of type that a Type represents.
    48  // The zero Kind is not a valid kind.
    49  type Kind uint8
    50  
    51  const (
    52  	Invalid Kind = iota
    53  	Bool
    54  	Int
    55  	Int8
    56  	Int16
    57  	Int32
    58  	Int64
    59  	Uint
    60  	Uint8
    61  	Uint16
    62  	Uint32
    63  	Uint64
    64  	Uintptr
    65  	Float32
    66  	Float64
    67  	Complex64
    68  	Complex128
    69  	Array
    70  	Chan
    71  	Func
    72  	Interface
    73  	Map
    74  	Pointer
    75  	Slice
    76  	String
    77  	Struct
    78  	UnsafePointer
    79  )
    80  
    81  const (
    82  	// TODO (khr, drchase) why aren't these in TFlag?  Investigate, fix if possible.
    83  	KindDirectIface Kind = 1 << 5
    84  	KindMask        Kind = (1 << 5) - 1
    85  )
    86  
    87  // TFlag is used by a Type to signal what extra type information is
    88  // available in the memory directly following the Type value.
    89  type TFlag uint8
    90  
    91  const (
    92  	// TFlagUncommon means that there is a data with a type, UncommonType,
    93  	// just beyond the shared-per-type common data.  That is, the data
    94  	// for struct types will store their UncommonType at one offset, the
    95  	// data for interface types will store their UncommonType at a different
    96  	// offset.  UncommonType is always accessed via a pointer that is computed
    97  	// using trust-us-we-are-the-implementors pointer arithmetic.
    98  	//
    99  	// For example, if t.Kind() == Struct and t.tflag&TFlagUncommon != 0,
   100  	// then t has UncommonType data and it can be accessed as:
   101  	//
   102  	//	type structTypeUncommon struct {
   103  	//		structType
   104  	//		u UncommonType
   105  	//	}
   106  	//	u := &(*structTypeUncommon)(unsafe.Pointer(t)).u
   107  	TFlagUncommon TFlag = 1 << 0
   108  
   109  	// TFlagExtraStar means the name in the str field has an
   110  	// extraneous '*' prefix. This is because for most types T in
   111  	// a program, the type *T also exists and reusing the str data
   112  	// saves binary size.
   113  	TFlagExtraStar TFlag = 1 << 1
   114  
   115  	// TFlagNamed means the type has a name.
   116  	TFlagNamed TFlag = 1 << 2
   117  
   118  	// TFlagRegularMemory means that equal and hash functions can treat
   119  	// this type as a single region of t.size bytes.
   120  	TFlagRegularMemory TFlag = 1 << 3
   121  
   122  	// TFlagGCMaskOnDemand means that the GC pointer bitmask will be
   123  	// computed on demand at runtime instead of being precomputed at
   124  	// compile time. If this flag is set, the GCData field effectively
   125  	// has type **byte instead of *byte. The runtime will store a
   126  	// pointer to the GC pointer bitmask in *GCData.
   127  	TFlagGCMaskOnDemand TFlag = 1 << 4
   128  )
   129  
   130  // NameOff is the offset to a name from moduledata.types.  See resolveNameOff in runtime.
   131  type NameOff int32
   132  
   133  // TypeOff is the offset to a type from moduledata.types.  See resolveTypeOff in runtime.
   134  type TypeOff int32
   135  
   136  // TextOff is an offset from the top of a text section.  See (rtype).textOff in runtime.
   137  type TextOff int32
   138  
   139  // String returns the name of k.
   140  func (k Kind) String() string {
   141  	if int(k) < len(kindNames) {
   142  		return kindNames[k]
   143  	}
   144  	return kindNames[0]
   145  }
   146  
   147  var kindNames = []string{
   148  	Invalid:       "invalid",
   149  	Bool:          "bool",
   150  	Int:           "int",
   151  	Int8:          "int8",
   152  	Int16:         "int16",
   153  	Int32:         "int32",
   154  	Int64:         "int64",
   155  	Uint:          "uint",
   156  	Uint8:         "uint8",
   157  	Uint16:        "uint16",
   158  	Uint32:        "uint32",
   159  	Uint64:        "uint64",
   160  	Uintptr:       "uintptr",
   161  	Float32:       "float32",
   162  	Float64:       "float64",
   163  	Complex64:     "complex64",
   164  	Complex128:    "complex128",
   165  	Array:         "array",
   166  	Chan:          "chan",
   167  	Func:          "func",
   168  	Interface:     "interface",
   169  	Map:           "map",
   170  	Pointer:       "ptr",
   171  	Slice:         "slice",
   172  	String:        "string",
   173  	Struct:        "struct",
   174  	UnsafePointer: "unsafe.Pointer",
   175  }
   176  
   177  // TypeOf returns the abi.Type of some value.
   178  func TypeOf(a any) *Type {
   179  	eface := *(*EmptyInterface)(unsafe.Pointer(&a))
   180  	// Types are either static (for compiler-created types) or
   181  	// heap-allocated but always reachable (for reflection-created
   182  	// types, held in the central map). So there is no need to
   183  	// escape types. noescape here help avoid unnecessary escape
   184  	// of v.
   185  	return (*Type)(NoEscape(unsafe.Pointer(eface.Type)))
   186  }
   187  
   188  // TypeFor returns the abi.Type for a type parameter.
   189  func TypeFor[T any]() *Type {
   190  	var v T
   191  	if t := TypeOf(v); t != nil {
   192  		return t // optimize for T being a non-interface kind
   193  	}
   194  	return TypeOf((*T)(nil)).Elem() // only for an interface kind
   195  }
   196  
   197  func (t *Type) Kind() Kind { return t.Kind_ & KindMask }
   198  
   199  func (t *Type) HasName() bool {
   200  	return t.TFlag&TFlagNamed != 0
   201  }
   202  
   203  // Pointers reports whether t contains pointers.
   204  func (t *Type) Pointers() bool { return t.PtrBytes != 0 }
   205  
   206  // IfaceIndir reports whether t is stored indirectly in an interface value.
   207  func (t *Type) IfaceIndir() bool {
   208  	return t.Kind_&KindDirectIface == 0
   209  }
   210  
   211  // isDirectIface reports whether t is stored directly in an interface value.
   212  func (t *Type) IsDirectIface() bool {
   213  	return t.Kind_&KindDirectIface != 0
   214  }
   215  
   216  func (t *Type) GcSlice(begin, end uintptr) []byte {
   217  	if t.TFlag&TFlagGCMaskOnDemand != 0 {
   218  		panic("GcSlice can't handle on-demand gcdata types")
   219  	}
   220  	return unsafe.Slice(t.GCData, int(end))[begin:]
   221  }
   222  
   223  // Method on non-interface type
   224  type Method struct {
   225  	Name NameOff // name of method
   226  	Mtyp TypeOff // method type (without receiver)
   227  	Ifn  TextOff // fn used in interface call (one-word receiver)
   228  	Tfn  TextOff // fn used for normal method call
   229  }
   230  
   231  // UncommonType is present only for defined types or types with methods
   232  // (if T is a defined type, the uncommonTypes for T and *T have methods).
   233  // Using a pointer to this struct reduces the overall size required
   234  // to describe a non-defined type with no methods.
   235  type UncommonType struct {
   236  	PkgPath NameOff // import path; empty for built-in types like int, string
   237  	Mcount  uint16  // number of methods
   238  	Xcount  uint16  // number of exported methods
   239  	Moff    uint32  // offset from this uncommontype to [mcount]Method
   240  	_       uint32  // unused
   241  }
   242  
   243  func (t *UncommonType) Methods() []Method {
   244  	if t.Mcount == 0 {
   245  		return nil
   246  	}
   247  	return (*[1 << 16]Method)(addChecked(unsafe.Pointer(t), uintptr(t.Moff), "t.mcount > 0"))[:t.Mcount:t.Mcount]
   248  }
   249  
   250  func (t *UncommonType) ExportedMethods() []Method {
   251  	if t.Xcount == 0 {
   252  		return nil
   253  	}
   254  	return (*[1 << 16]Method)(addChecked(unsafe.Pointer(t), uintptr(t.Moff), "t.xcount > 0"))[:t.Xcount:t.Xcount]
   255  }
   256  
   257  // addChecked returns p+x.
   258  //
   259  // The whySafe string is ignored, so that the function still inlines
   260  // as efficiently as p+x, but all call sites should use the string to
   261  // record why the addition is safe, which is to say why the addition
   262  // does not cause x to advance to the very end of p's allocation
   263  // and therefore point incorrectly at the next block in memory.
   264  func addChecked(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
   265  	return unsafe.Pointer(uintptr(p) + x)
   266  }
   267  
   268  // Imethod represents a method on an interface type
   269  type Imethod struct {
   270  	Name NameOff // name of method
   271  	Typ  TypeOff // .(*FuncType) underneath
   272  }
   273  
   274  // ArrayType represents a fixed array type.
   275  type ArrayType struct {
   276  	Type
   277  	Elem  *Type // array element type
   278  	Slice *Type // slice type
   279  	Len   uintptr
   280  }
   281  
   282  // Len returns the length of t if t is an array type, otherwise 0
   283  func (t *Type) Len() int {
   284  	if t.Kind() == Array {
   285  		return int((*ArrayType)(unsafe.Pointer(t)).Len)
   286  	}
   287  	return 0
   288  }
   289  
   290  func (t *Type) Common() *Type {
   291  	return t
   292  }
   293  
   294  type ChanDir int
   295  
   296  const (
   297  	RecvDir    ChanDir = 1 << iota         // <-chan
   298  	SendDir                                // chan<-
   299  	BothDir            = RecvDir | SendDir // chan
   300  	InvalidDir ChanDir = 0
   301  )
   302  
   303  // ChanType represents a channel type
   304  type ChanType struct {
   305  	Type
   306  	Elem *Type
   307  	Dir  ChanDir
   308  }
   309  
   310  type structTypeUncommon struct {
   311  	StructType
   312  	u UncommonType
   313  }
   314  
   315  // ChanDir returns the direction of t if t is a channel type, otherwise InvalidDir (0).
   316  func (t *Type) ChanDir() ChanDir {
   317  	if t.Kind() == Chan {
   318  		ch := (*ChanType)(unsafe.Pointer(t))
   319  		return ch.Dir
   320  	}
   321  	return InvalidDir
   322  }
   323  
   324  // Uncommon returns a pointer to T's "uncommon" data if there is any, otherwise nil
   325  func (t *Type) Uncommon() *UncommonType {
   326  	if t.TFlag&TFlagUncommon == 0 {
   327  		return nil
   328  	}
   329  	switch t.Kind() {
   330  	case Struct:
   331  		return &(*structTypeUncommon)(unsafe.Pointer(t)).u
   332  	case Pointer:
   333  		type u struct {
   334  			PtrType
   335  			u UncommonType
   336  		}
   337  		return &(*u)(unsafe.Pointer(t)).u
   338  	case Func:
   339  		type u struct {
   340  			FuncType
   341  			u UncommonType
   342  		}
   343  		return &(*u)(unsafe.Pointer(t)).u
   344  	case Slice:
   345  		type u struct {
   346  			SliceType
   347  			u UncommonType
   348  		}
   349  		return &(*u)(unsafe.Pointer(t)).u
   350  	case Array:
   351  		type u struct {
   352  			ArrayType
   353  			u UncommonType
   354  		}
   355  		return &(*u)(unsafe.Pointer(t)).u
   356  	case Chan:
   357  		type u struct {
   358  			ChanType
   359  			u UncommonType
   360  		}
   361  		return &(*u)(unsafe.Pointer(t)).u
   362  	case Map:
   363  		type u struct {
   364  			mapType
   365  			u UncommonType
   366  		}
   367  		return &(*u)(unsafe.Pointer(t)).u
   368  	case Interface:
   369  		type u struct {
   370  			InterfaceType
   371  			u UncommonType
   372  		}
   373  		return &(*u)(unsafe.Pointer(t)).u
   374  	default:
   375  		type u struct {
   376  			Type
   377  			u UncommonType
   378  		}
   379  		return &(*u)(unsafe.Pointer(t)).u
   380  	}
   381  }
   382  
   383  // Elem returns the element type for t if t is an array, channel, map, pointer, or slice, otherwise nil.
   384  func (t *Type) Elem() *Type {
   385  	switch t.Kind() {
   386  	case Array:
   387  		tt := (*ArrayType)(unsafe.Pointer(t))
   388  		return tt.Elem
   389  	case Chan:
   390  		tt := (*ChanType)(unsafe.Pointer(t))
   391  		return tt.Elem
   392  	case Map:
   393  		tt := (*mapType)(unsafe.Pointer(t))
   394  		return tt.Elem
   395  	case Pointer:
   396  		tt := (*PtrType)(unsafe.Pointer(t))
   397  		return tt.Elem
   398  	case Slice:
   399  		tt := (*SliceType)(unsafe.Pointer(t))
   400  		return tt.Elem
   401  	}
   402  	return nil
   403  }
   404  
   405  // StructType returns t cast to a *StructType, or nil if its tag does not match.
   406  func (t *Type) StructType() *StructType {
   407  	if t.Kind() != Struct {
   408  		return nil
   409  	}
   410  	return (*StructType)(unsafe.Pointer(t))
   411  }
   412  
   413  // MapType returns t cast to a *OldMapType or *SwissMapType, or nil if its tag does not match.
   414  func (t *Type) MapType() *mapType {
   415  	if t.Kind() != Map {
   416  		return nil
   417  	}
   418  	return (*mapType)(unsafe.Pointer(t))
   419  }
   420  
   421  // ArrayType returns t cast to a *ArrayType, or nil if its tag does not match.
   422  func (t *Type) ArrayType() *ArrayType {
   423  	if t.Kind() != Array {
   424  		return nil
   425  	}
   426  	return (*ArrayType)(unsafe.Pointer(t))
   427  }
   428  
   429  // FuncType returns t cast to a *FuncType, or nil if its tag does not match.
   430  func (t *Type) FuncType() *FuncType {
   431  	if t.Kind() != Func {
   432  		return nil
   433  	}
   434  	return (*FuncType)(unsafe.Pointer(t))
   435  }
   436  
   437  // InterfaceType returns t cast to a *InterfaceType, or nil if its tag does not match.
   438  func (t *Type) InterfaceType() *InterfaceType {
   439  	if t.Kind() != Interface {
   440  		return nil
   441  	}
   442  	return (*InterfaceType)(unsafe.Pointer(t))
   443  }
   444  
   445  // Size returns the size of data with type t.
   446  func (t *Type) Size() uintptr { return t.Size_ }
   447  
   448  // Align returns the alignment of data with type t.
   449  func (t *Type) Align() int { return int(t.Align_) }
   450  
   451  func (t *Type) FieldAlign() int { return int(t.FieldAlign_) }
   452  
   453  type InterfaceType struct {
   454  	Type
   455  	PkgPath Name      // import path
   456  	Methods []Imethod // sorted by hash
   457  }
   458  
   459  func (t *Type) ExportedMethods() []Method {
   460  	ut := t.Uncommon()
   461  	if ut == nil {
   462  		return nil
   463  	}
   464  	return ut.ExportedMethods()
   465  }
   466  
   467  func (t *Type) NumMethod() int {
   468  	if t.Kind() == Interface {
   469  		tt := (*InterfaceType)(unsafe.Pointer(t))
   470  		return tt.NumMethod()
   471  	}
   472  	return len(t.ExportedMethods())
   473  }
   474  
   475  // NumMethod returns the number of interface methods in the type's method set.
   476  func (t *InterfaceType) NumMethod() int { return len(t.Methods) }
   477  
   478  func (t *Type) Key() *Type {
   479  	if t.Kind() == Map {
   480  		return (*mapType)(unsafe.Pointer(t)).Key
   481  	}
   482  	return nil
   483  }
   484  
   485  type SliceType struct {
   486  	Type
   487  	Elem *Type // slice element type
   488  }
   489  
   490  // funcType represents a function type.
   491  //
   492  // A *Type for each in and out parameter is stored in an array that
   493  // directly follows the funcType (and possibly its uncommonType). So
   494  // a function type with one method, one input, and one output is:
   495  //
   496  //	struct {
   497  //		funcType
   498  //		uncommonType
   499  //		[2]*rtype    // [0] is in, [1] is out
   500  //	}
   501  type FuncType struct {
   502  	Type
   503  	InCount  uint16
   504  	OutCount uint16 // top bit is set if last input parameter is ...
   505  }
   506  
   507  func (t *FuncType) In(i int) *Type {
   508  	return t.InSlice()[i]
   509  }
   510  
   511  func (t *FuncType) NumIn() int {
   512  	return int(t.InCount)
   513  }
   514  
   515  func (t *FuncType) NumOut() int {
   516  	return int(t.OutCount & (1<<15 - 1))
   517  }
   518  
   519  func (t *FuncType) Out(i int) *Type {
   520  	return (t.OutSlice()[i])
   521  }
   522  
   523  func (t *FuncType) InSlice() []*Type {
   524  	uadd := unsafe.Sizeof(*t)
   525  	if t.TFlag&TFlagUncommon != 0 {
   526  		uadd += unsafe.Sizeof(UncommonType{})
   527  	}
   528  	if t.InCount == 0 {
   529  		return nil
   530  	}
   531  	return (*[1 << 16]*Type)(addChecked(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.InCount:t.InCount]
   532  }
   533  func (t *FuncType) OutSlice() []*Type {
   534  	outCount := uint16(t.NumOut())
   535  	if outCount == 0 {
   536  		return nil
   537  	}
   538  	uadd := unsafe.Sizeof(*t)
   539  	if t.TFlag&TFlagUncommon != 0 {
   540  		uadd += unsafe.Sizeof(UncommonType{})
   541  	}
   542  	return (*[1 << 17]*Type)(addChecked(unsafe.Pointer(t), uadd, "outCount > 0"))[t.InCount : t.InCount+outCount : t.InCount+outCount]
   543  }
   544  
   545  func (t *FuncType) IsVariadic() bool {
   546  	return t.OutCount&(1<<15) != 0
   547  }
   548  
   549  type PtrType struct {
   550  	Type
   551  	Elem *Type // pointer element (pointed at) type
   552  }
   553  
   554  type StructField struct {
   555  	Name   Name    // name is always non-empty
   556  	Typ    *Type   // type of field
   557  	Offset uintptr // byte offset of field
   558  }
   559  
   560  func (f *StructField) Embedded() bool {
   561  	return f.Name.IsEmbedded()
   562  }
   563  
   564  type StructType struct {
   565  	Type
   566  	PkgPath Name
   567  	Fields  []StructField
   568  }
   569  
   570  // Name is an encoded type Name with optional extra data.
   571  //
   572  // The first byte is a bit field containing:
   573  //
   574  //	1<<0 the name is exported
   575  //	1<<1 tag data follows the name
   576  //	1<<2 pkgPath nameOff follows the name and tag
   577  //	1<<3 the name is of an embedded (a.k.a. anonymous) field
   578  //
   579  // Following that, there is a varint-encoded length of the name,
   580  // followed by the name itself.
   581  //
   582  // If tag data is present, it also has a varint-encoded length
   583  // followed by the tag itself.
   584  //
   585  // If the import path follows, then 4 bytes at the end of
   586  // the data form a nameOff. The import path is only set for concrete
   587  // methods that are defined in a different package than their type.
   588  //
   589  // If a name starts with "*", then the exported bit represents
   590  // whether the pointed to type is exported.
   591  //
   592  // Note: this encoding must match here and in:
   593  //   cmd/compile/internal/reflectdata/reflect.go
   594  //   cmd/link/internal/ld/decodesym.go
   595  
   596  type Name struct {
   597  	Bytes *byte
   598  }
   599  
   600  // DataChecked does pointer arithmetic on n's Bytes, and that arithmetic is asserted to
   601  // be safe for the reason in whySafe (which can appear in a backtrace, etc.)
   602  func (n Name) DataChecked(off int, whySafe string) *byte {
   603  	return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), whySafe))
   604  }
   605  
   606  // Data does pointer arithmetic on n's Bytes, and that arithmetic is asserted to
   607  // be safe because the runtime made the call (other packages use DataChecked)
   608  func (n Name) Data(off int) *byte {
   609  	return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), "the runtime doesn't need to give you a reason"))
   610  }
   611  
   612  // IsExported returns "is n exported?"
   613  func (n Name) IsExported() bool {
   614  	return (*n.Bytes)&(1<<0) != 0
   615  }
   616  
   617  // HasTag returns true iff there is tag data following this name
   618  func (n Name) HasTag() bool {
   619  	return (*n.Bytes)&(1<<1) != 0
   620  }
   621  
   622  // IsEmbedded returns true iff n is embedded (an anonymous field).
   623  func (n Name) IsEmbedded() bool {
   624  	return (*n.Bytes)&(1<<3) != 0
   625  }
   626  
   627  // ReadVarint parses a varint as encoded by encoding/binary.
   628  // It returns the number of encoded bytes and the encoded value.
   629  func (n Name) ReadVarint(off int) (int, int) {
   630  	v := 0
   631  	for i := 0; ; i++ {
   632  		x := *n.DataChecked(off+i, "read varint")
   633  		v += int(x&0x7f) << (7 * i)
   634  		if x&0x80 == 0 {
   635  			return i + 1, v
   636  		}
   637  	}
   638  }
   639  
   640  // IsBlank indicates whether n is "_".
   641  func (n Name) IsBlank() bool {
   642  	if n.Bytes == nil {
   643  		return false
   644  	}
   645  	_, l := n.ReadVarint(1)
   646  	return l == 1 && *n.Data(2) == '_'
   647  }
   648  
   649  // writeVarint writes n to buf in varint form. Returns the
   650  // number of bytes written. n must be nonnegative.
   651  // Writes at most 10 bytes.
   652  func writeVarint(buf []byte, n int) int {
   653  	for i := 0; ; i++ {
   654  		b := byte(n & 0x7f)
   655  		n >>= 7
   656  		if n == 0 {
   657  			buf[i] = b
   658  			return i + 1
   659  		}
   660  		buf[i] = b | 0x80
   661  	}
   662  }
   663  
   664  // Name returns the tag string for n, or empty if there is none.
   665  func (n Name) Name() string {
   666  	if n.Bytes == nil {
   667  		return ""
   668  	}
   669  	i, l := n.ReadVarint(1)
   670  	return unsafe.String(n.DataChecked(1+i, "non-empty string"), l)
   671  }
   672  
   673  // Tag returns the tag string for n, or empty if there is none.
   674  func (n Name) Tag() string {
   675  	if !n.HasTag() {
   676  		return ""
   677  	}
   678  	i, l := n.ReadVarint(1)
   679  	i2, l2 := n.ReadVarint(1 + i + l)
   680  	return unsafe.String(n.DataChecked(1+i+l+i2, "non-empty string"), l2)
   681  }
   682  
   683  func NewName(n, tag string, exported, embedded bool) Name {
   684  	if len(n) >= 1<<29 {
   685  		panic("abi.NewName: name too long: " + n[:1024] + "...")
   686  	}
   687  	if len(tag) >= 1<<29 {
   688  		panic("abi.NewName: tag too long: " + tag[:1024] + "...")
   689  	}
   690  	var nameLen [10]byte
   691  	var tagLen [10]byte
   692  	nameLenLen := writeVarint(nameLen[:], len(n))
   693  	tagLenLen := writeVarint(tagLen[:], len(tag))
   694  
   695  	var bits byte
   696  	l := 1 + nameLenLen + len(n)
   697  	if exported {
   698  		bits |= 1 << 0
   699  	}
   700  	if len(tag) > 0 {
   701  		l += tagLenLen + len(tag)
   702  		bits |= 1 << 1
   703  	}
   704  	if embedded {
   705  		bits |= 1 << 3
   706  	}
   707  
   708  	b := make([]byte, l)
   709  	b[0] = bits
   710  	copy(b[1:], nameLen[:nameLenLen])
   711  	copy(b[1+nameLenLen:], n)
   712  	if len(tag) > 0 {
   713  		tb := b[1+nameLenLen+len(n):]
   714  		copy(tb, tagLen[:tagLenLen])
   715  		copy(tb[tagLenLen:], tag)
   716  	}
   717  
   718  	return Name{Bytes: &b[0]}
   719  }
   720  
   721  const (
   722  	TraceArgsLimit    = 10 // print no more than 10 args/components
   723  	TraceArgsMaxDepth = 5  // no more than 5 layers of nesting
   724  
   725  	// maxLen is a (conservative) upper bound of the byte stream length. For
   726  	// each arg/component, it has no more than 2 bytes of data (size, offset),
   727  	// and no more than one {, }, ... at each level (it cannot have both the
   728  	// data and ... unless it is the last one, just be conservative). Plus 1
   729  	// for _endSeq.
   730  	TraceArgsMaxLen = (TraceArgsMaxDepth*3+2)*TraceArgsLimit + 1
   731  )
   732  
   733  // Populate the data.
   734  // The data is a stream of bytes, which contains the offsets and sizes of the
   735  // non-aggregate arguments or non-aggregate fields/elements of aggregate-typed
   736  // arguments, along with special "operators". Specifically,
   737  //   - for each non-aggregate arg/field/element, its offset from FP (1 byte) and
   738  //     size (1 byte)
   739  //   - special operators:
   740  //   - 0xff - end of sequence
   741  //   - 0xfe - print { (at the start of an aggregate-typed argument)
   742  //   - 0xfd - print } (at the end of an aggregate-typed argument)
   743  //   - 0xfc - print ... (more args/fields/elements)
   744  //   - 0xfb - print _ (offset too large)
   745  const (
   746  	TraceArgsEndSeq         = 0xff
   747  	TraceArgsStartAgg       = 0xfe
   748  	TraceArgsEndAgg         = 0xfd
   749  	TraceArgsDotdotdot      = 0xfc
   750  	TraceArgsOffsetTooLarge = 0xfb
   751  	TraceArgsSpecial        = 0xf0 // above this are operators, below this are ordinary offsets
   752  )
   753  
   754  // MaxPtrmaskBytes is the maximum length of a GC ptrmask bitmap,
   755  // which holds 1-bit entries describing where pointers are in a given type.
   756  // Above this length, the GC information is recorded as a GC program,
   757  // which can express repetition compactly. In either form, the
   758  // information is used by the runtime to initialize the heap bitmap,
   759  // and for large types (like 128 or more words), they are roughly the
   760  // same speed. GC programs are never much larger and often more
   761  // compact. (If large arrays are involved, they can be arbitrarily
   762  // more compact.)
   763  //
   764  // The cutoff must be large enough that any allocation large enough to
   765  // use a GC program is large enough that it does not share heap bitmap
   766  // bytes with any other objects, allowing the GC program execution to
   767  // assume an aligned start and not use atomic operations. In the current
   768  // runtime, this means all malloc size classes larger than the cutoff must
   769  // be multiples of four words. On 32-bit systems that's 16 bytes, and
   770  // all size classes >= 16 bytes are 16-byte aligned, so no real constraint.
   771  // On 64-bit systems, that's 32 bytes, and 32-byte alignment is guaranteed
   772  // for size classes >= 256 bytes. On a 64-bit system, 256 bytes allocated
   773  // is 32 pointers, the bits for which fit in 4 bytes. So MaxPtrmaskBytes
   774  // must be >= 4.
   775  //
   776  // We used to use 16 because the GC programs do have some constant overhead
   777  // to get started, and processing 128 pointers seems to be enough to
   778  // amortize that overhead well.
   779  //
   780  // To make sure that the runtime's chansend can call typeBitsBulkBarrier,
   781  // we raised the limit to 2048, so that even 32-bit systems are guaranteed to
   782  // use bitmaps for objects up to 64 kB in size.
   783  const MaxPtrmaskBytes = 2048
   784
View as plain text