size.go

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package types
     6  
     7  import (
     8  	"math"
     9  	"slices"
    10  
    11  	"cmd/compile/internal/base"
    12  	"cmd/internal/src"
    13  	"internal/buildcfg"
    14  	"internal/types/errors"
    15  )
    16  
    17  var PtrSize int
    18  
    19  var RegSize int
    20  
    21  // Slices in the runtime are represented by three components:
    22  //
    23  //	type slice struct {
    24  //		ptr unsafe.Pointer
    25  //		len int
    26  //		cap int
    27  //	}
    28  //
    29  // Strings in the runtime are represented by two components:
    30  //
    31  //	type string struct {
    32  //		ptr unsafe.Pointer
    33  //		len int
    34  //	}
    35  //
    36  // These variables are the offsets of fields and sizes of these structs.
    37  var (
    38  	SlicePtrOffset int64
    39  	SliceLenOffset int64
    40  	SliceCapOffset int64
    41  
    42  	SliceSize  int64
    43  	StringSize int64
    44  )
    45  
    46  var SkipSizeForTracing bool
    47  
    48  // typePos returns the position associated with t.
    49  // This is where t was declared or where it appeared as a type expression.
    50  func typePos(t *Type) src.XPos {
    51  	if pos := t.Pos(); pos.IsKnown() {
    52  		return pos
    53  	}
    54  	base.Fatalf("bad type: %v", t)
    55  	panic("unreachable")
    56  }
    57  
    58  // MaxWidth is the maximum size of a value on the target architecture.
    59  var MaxWidth int64
    60  
    61  // CalcSizeDisabled indicates whether it is safe
    62  // to calculate Types' widths and alignments. See CalcSize.
    63  var CalcSizeDisabled bool
    64  
    65  // machine size and rounding alignment is dictated around
    66  // the size of a pointer, set in gc.Main (see ../gc/main.go).
    67  var defercalc int
    68  
    69  // RoundUp rounds o to a multiple of r, r is a power of 2.
    70  func RoundUp(o int64, r int64) int64 {
    71  	if r < 1 || r > 16 || r&(r-1) != 0 {
    72  		base.Fatalf("Round %d", r)
    73  	}
    74  	return (o + r - 1) &^ (r - 1)
    75  }
    76  
    77  // expandiface computes the method set for interface type t by
    78  // expanding embedded interfaces.
    79  func expandiface(t *Type) {
    80  	seen := make(map[*Sym]*Field)
    81  	var methods []*Field
    82  
    83  	addMethod := func(m *Field, explicit bool) {
    84  		switch prev := seen[m.Sym]; {
    85  		case prev == nil:
    86  			seen[m.Sym] = m
    87  		case !explicit && Identical(m.Type, prev.Type):
    88  			return
    89  		default:
    90  			base.ErrorfAt(m.Pos, errors.DuplicateDecl, "duplicate method %s", m.Sym.Name)
    91  		}
    92  		methods = append(methods, m)
    93  	}
    94  
    95  	{
    96  		methods := t.Methods()
    97  		slices.SortStableFunc(methods, func(a, b *Field) int {
    98  			// Sort embedded types by type name (if any).
    99  			if a.Sym == nil && b.Sym == nil {
   100  				return CompareSyms(a.Type.Sym(), b.Type.Sym())
   101  			}
   102  
   103  			// Sort methods before embedded types.
   104  			if a.Sym == nil {
   105  				return -1
   106  			} else if b.Sym == nil {
   107  				return +1
   108  			}
   109  
   110  			// Sort methods by symbol name.
   111  			return CompareSyms(a.Sym, b.Sym)
   112  		})
   113  	}
   114  
   115  	for _, m := range t.Methods() {
   116  		if m.Sym == nil {
   117  			continue
   118  		}
   119  
   120  		CheckSize(m.Type)
   121  		addMethod(m, true)
   122  	}
   123  
   124  	for _, m := range t.Methods() {
   125  		if m.Sym != nil || m.Type == nil {
   126  			continue
   127  		}
   128  
   129  		// In 1.18, embedded types can be anything. In Go 1.17, we disallow
   130  		// embedding anything other than interfaces. This requirement was caught
   131  		// by types2 already, so allow non-interface here.
   132  		if !m.Type.IsInterface() {
   133  			continue
   134  		}
   135  
   136  		// Embedded interface: duplicate all methods
   137  		// and add to t's method set.
   138  		for _, t1 := range m.Type.AllMethods() {
   139  			f := NewField(m.Pos, t1.Sym, t1.Type)
   140  			addMethod(f, false)
   141  
   142  			// Clear position after typechecking, for consistency with types2.
   143  			f.Pos = src.NoXPos
   144  		}
   145  
   146  		// Clear position after typechecking, for consistency with types2.
   147  		m.Pos = src.NoXPos
   148  	}
   149  
   150  	slices.SortFunc(methods, CompareFields)
   151  
   152  	if int64(len(methods)) >= MaxWidth/int64(PtrSize) {
   153  		base.ErrorfAt(typePos(t), 0, "interface too large")
   154  	}
   155  	for i, m := range methods {
   156  		m.Offset = int64(i) * int64(PtrSize)
   157  	}
   158  
   159  	t.SetAllMethods(methods)
   160  }
   161  
   162  // calcStructOffset computes the offsets of a sequence of fields,
   163  // starting at the given offset. It returns the resulting offset and
   164  // maximum field alignment.
   165  func calcStructOffset(t *Type, fields []*Field, offset int64) int64 {
   166  	for _, f := range fields {
   167  		CalcSize(f.Type)
   168  		offset = RoundUp(offset, int64(f.Type.align))
   169  
   170  		if t.IsStruct() { // param offsets depend on ABI
   171  			f.Offset = offset
   172  
   173  			// If type T contains a field F marked as not-in-heap,
   174  			// then T must also be a not-in-heap type. Otherwise,
   175  			// you could heap allocate T and then get a pointer F,
   176  			// which would be a heap pointer to a not-in-heap type.
   177  			if f.Type.NotInHeap() {
   178  				t.SetNotInHeap(true)
   179  			}
   180  		}
   181  
   182  		offset += f.Type.width
   183  
   184  		maxwidth := MaxWidth
   185  		// On 32-bit systems, reflect tables impose an additional constraint
   186  		// that each field start offset must fit in 31 bits.
   187  		if maxwidth < 1<<32 {
   188  			maxwidth = 1<<31 - 1
   189  		}
   190  		if offset >= maxwidth {
   191  			base.ErrorfAt(typePos(t), 0, "type %L too large", t)
   192  			offset = 8 // small but nonzero
   193  		}
   194  	}
   195  
   196  	return offset
   197  }
   198  
   199  func isAtomicStdPkg(p *Pkg) bool {
   200  	if p.Prefix == `""` {
   201  		panic("bad package prefix")
   202  	}
   203  	return p.Prefix == "sync/atomic" || p.Prefix == "internal/runtime/atomic"
   204  }
   205  
   206  // CalcSize calculates and stores the size, alignment, eq/hash algorithm,
   207  // and ptrBytes for t.
   208  // If CalcSizeDisabled is set, and the size/alignment
   209  // have not already been calculated, it calls Fatal.
   210  // This is used to prevent data races in the back end.
   211  func CalcSize(t *Type) {
   212  	// Calling CalcSize when typecheck tracing enabled is not safe.
   213  	// See issue #33658.
   214  	if base.EnableTrace && SkipSizeForTracing {
   215  		return
   216  	}
   217  	if PtrSize == 0 {
   218  		// Assume this is a test.
   219  		return
   220  	}
   221  
   222  	if t == nil {
   223  		return
   224  	}
   225  
   226  	if t.width == -2 {
   227  		t.width = 0
   228  		t.align = 1
   229  		base.Fatalf("invalid recursive type %v", t)
   230  		return
   231  	}
   232  
   233  	if t.widthCalculated() {
   234  		return
   235  	}
   236  
   237  	if CalcSizeDisabled {
   238  		base.Fatalf("width not calculated: %v", t)
   239  	}
   240  
   241  	// defer CheckSize calls until after we're done
   242  	DeferCheckSize()
   243  
   244  	lno := base.Pos
   245  	if pos := t.Pos(); pos.IsKnown() {
   246  		base.Pos = pos
   247  	}
   248  
   249  	t.width = -2
   250  	t.align = 0  // 0 means use t.Width, below
   251  	t.alg = AMEM // default
   252  	// default t.ptrBytes is 0.
   253  	if t.Noalg() {
   254  		t.setAlg(ANOALG)
   255  	}
   256  
   257  	et := t.Kind()
   258  	switch et {
   259  	case TFUNC, TCHAN, TMAP, TSTRING:
   260  		break
   261  
   262  	// SimType == 0 during bootstrap
   263  	default:
   264  		if SimType[t.Kind()] != 0 {
   265  			et = SimType[t.Kind()]
   266  		}
   267  	}
   268  
   269  	var w int64
   270  	switch et {
   271  	default:
   272  		base.Fatalf("CalcSize: unknown type: %v", t)
   273  
   274  	// compiler-specific stuff
   275  	case TINT8, TUINT8, TBOOL:
   276  		// bool is int8
   277  		w = 1
   278  		t.intRegs = 1
   279  
   280  	case TINT16, TUINT16:
   281  		w = 2
   282  		t.intRegs = 1
   283  
   284  	case TINT32, TUINT32:
   285  		w = 4
   286  		t.intRegs = 1
   287  
   288  	case TINT64, TUINT64:
   289  		w = 8
   290  		t.align = uint8(RegSize)
   291  		t.intRegs = uint8(8 / RegSize)
   292  
   293  	case TFLOAT32:
   294  		w = 4
   295  		t.floatRegs = 1
   296  		t.setAlg(AFLOAT32)
   297  
   298  	case TFLOAT64:
   299  		w = 8
   300  		t.align = uint8(RegSize)
   301  		t.floatRegs = 1
   302  		t.setAlg(AFLOAT64)
   303  
   304  	case TCOMPLEX64:
   305  		w = 8
   306  		t.align = 4
   307  		t.floatRegs = 2
   308  		t.setAlg(ACPLX64)
   309  
   310  	case TCOMPLEX128:
   311  		w = 16
   312  		t.align = uint8(RegSize)
   313  		t.floatRegs = 2
   314  		t.setAlg(ACPLX128)
   315  
   316  	case TPTR:
   317  		w = int64(PtrSize)
   318  		t.intRegs = 1
   319  		CheckSize(t.Elem())
   320  		t.ptrBytes = int64(PtrSize) // See PtrDataSize
   321  
   322  	case TUNSAFEPTR:
   323  		w = int64(PtrSize)
   324  		t.intRegs = 1
   325  		t.ptrBytes = int64(PtrSize)
   326  
   327  	case TINTER: // implemented as 2 pointers
   328  		w = 2 * int64(PtrSize)
   329  		t.align = uint8(PtrSize)
   330  		t.intRegs = 2
   331  		expandiface(t)
   332  		if len(t.allMethods.Slice()) == 0 {
   333  			t.setAlg(ANILINTER)
   334  		} else {
   335  			t.setAlg(AINTER)
   336  		}
   337  		t.ptrBytes = int64(2 * PtrSize)
   338  
   339  	case TCHAN: // implemented as pointer
   340  		w = int64(PtrSize)
   341  		t.intRegs = 1
   342  		t.ptrBytes = int64(PtrSize)
   343  
   344  		CheckSize(t.Elem())
   345  
   346  		// Make fake type to trigger channel element size check after
   347  		// any top-level recursive type has been completed.
   348  		t1 := NewChanArgs(t)
   349  		CheckSize(t1)
   350  
   351  	case TCHANARGS:
   352  		t1 := t.ChanArgs()
   353  		CalcSize(t1) // just in case
   354  		// Make sure size of t1.Elem() is calculated at this point. We can
   355  		// use CalcSize() here rather than CheckSize(), because the top-level
   356  		// (possibly recursive) type will have been calculated before the fake
   357  		// chanargs is handled.
   358  		CalcSize(t1.Elem())
   359  		if t1.Elem().width >= 1<<16 {
   360  			base.Errorf("channel element type too large (>64kB)")
   361  		}
   362  		w = 1 // anything will do
   363  
   364  	case TMAP: // implemented as pointer
   365  		w = int64(PtrSize)
   366  		t.intRegs = 1
   367  		CheckSize(t.Elem())
   368  		CheckSize(t.Key())
   369  		if t.Elem().width >= 1<<31 {
   370  			base.Errorf("map element type too large")
   371  		}
   372  		if t.Key().width >= 1<<31 {
   373  			base.Errorf("map key type too large")
   374  		}
   375  		t.setAlg(ANOEQ)
   376  		t.ptrBytes = int64(PtrSize)
   377  
   378  	case TFORW: // should have been filled in
   379  		base.Fatalf("invalid recursive type %v", t)
   380  
   381  	case TANY: // not a real type; should be replaced before use.
   382  		base.Fatalf("CalcSize any")
   383  
   384  	case TSTRING:
   385  		if StringSize == 0 {
   386  			base.Fatalf("early CalcSize string")
   387  		}
   388  		w = StringSize
   389  		t.align = uint8(PtrSize)
   390  		t.intRegs = 2
   391  		t.setAlg(ASTRING)
   392  		t.ptrBytes = int64(PtrSize)
   393  
   394  	case TARRAY:
   395  		if t.Elem() == nil {
   396  			break
   397  		}
   398  		CalcArraySize(t)
   399  		w = t.width
   400  
   401  	case TSLICE:
   402  		if t.Elem() == nil {
   403  			break
   404  		}
   405  		w = SliceSize
   406  		CheckSize(t.Elem())
   407  		t.align = uint8(PtrSize)
   408  		t.intRegs = 3
   409  		t.setAlg(ANOEQ)
   410  		if !t.Elem().NotInHeap() {
   411  			t.ptrBytes = int64(PtrSize)
   412  		}
   413  
   414  	case TSTRUCT:
   415  		if t.IsFuncArgStruct() {
   416  			base.Fatalf("CalcSize fn struct %v", t)
   417  		}
   418  		CalcStructSize(t)
   419  		w = t.width
   420  
   421  	// make fake type to check later to
   422  	// trigger function argument computation.
   423  	case TFUNC:
   424  		t1 := NewFuncArgs(t)
   425  		CheckSize(t1)
   426  		w = int64(PtrSize) // width of func type is pointer
   427  		t.intRegs = 1
   428  		t.setAlg(ANOEQ)
   429  		t.ptrBytes = int64(PtrSize)
   430  
   431  	// function is 3 cated structures;
   432  	// compute their widths as side-effect.
   433  	case TFUNCARGS:
   434  		t1 := t.FuncArgs()
   435  		// TODO(mdempsky): Should package abi be responsible for computing argwid?
   436  		w = calcStructOffset(t1, t1.Recvs(), 0)
   437  		w = calcStructOffset(t1, t1.Params(), w)
   438  		w = RoundUp(w, int64(RegSize))
   439  		w = calcStructOffset(t1, t1.Results(), w)
   440  		w = RoundUp(w, int64(RegSize))
   441  		t1.extra.(*Func).Argwid = w
   442  		t.align = 1
   443  	}
   444  
   445  	if PtrSize == 4 && w != int64(int32(w)) {
   446  		base.Errorf("type %v too large", t)
   447  	}
   448  
   449  	t.width = w
   450  	if t.align == 0 {
   451  		if w == 0 || w > 8 || w&(w-1) != 0 {
   452  			base.Fatalf("invalid alignment for %v", t)
   453  		}
   454  		t.align = uint8(w)
   455  	}
   456  
   457  	base.Pos = lno
   458  
   459  	ResumeCheckSize()
   460  }
   461  
   462  // simdify marks as type as "SIMD", either as a tag field,
   463  // or having the SIMD attribute.  The tag field is a marker
   464  // type used to identify a struct that is not really a struct.
   465  // A SIMD type is allocated to a vector register (on amd64,
   466  // xmm, ymm, or zmm).  The fields of a SIMD type are ignored
   467  // by the compiler except for the space that they reserve.
   468  func simdify(st *Type, isTag bool) {
   469  	st.align = 8
   470  	st.alg = ANOALG // not comparable with ==
   471  	st.intRegs = 0
   472  	st.flags |= typeIsSIMD
   473  	if isTag {
   474  		st.width = 0
   475  		st.flags |= typeIsSIMDTag
   476  		st.floatRegs = 0
   477  	} else {
   478  		st.floatRegs = 1
   479  	}
   480  }
   481  
   482  // CalcStructSize calculates the size of t,
   483  // filling in t.width, t.align, t.intRegs, and t.floatRegs,
   484  // even if size calculation is otherwise disabled.
   485  func CalcStructSize(t *Type) {
   486  	var maxAlign uint8 = 1
   487  
   488  	// Recognize special types. This logic is duplicated in go/types and
   489  	// cmd/compile/internal/types2.
   490  	if sym := t.Sym(); sym != nil {
   491  		switch {
   492  		case sym.Name == "align64" && isAtomicStdPkg(sym.Pkg):
   493  			maxAlign = 8
   494  
   495  		case sym.Name == "align128" && isAtomicStdPkg(sym.Pkg):
   496  			maxAlign = 16
   497  
   498  		case buildcfg.Experiment.SIMD && (sym.Pkg.Path == "simd/archsimd") && len(t.Fields()) >= 1:
   499  			// This gates the experiment -- without it, no user-visible types can be "simd".
   500  			// The SSA-visible SIMD types remain.
   501  			switch sym.Name {
   502  			case "v128":
   503  				simdify(t, true)
   504  				return
   505  			case "v256":
   506  				simdify(t, true)
   507  				return
   508  			case "v512":
   509  				simdify(t, true)
   510  				return
   511  			case "vsve":
   512  				simdify(t, true)
   513  				return
   514  			case "psve":
   515  				simdify(t, true)
   516  				return
   517  			}
   518  		}
   519  	}
   520  
   521  	fields := t.Fields()
   522  
   523  	size := calcStructOffset(t, fields, 0)
   524  
   525  	// For non-zero-sized structs which end in a zero-sized field, we
   526  	// add an extra byte of padding to the type. This padding ensures
   527  	// that taking the address of a zero-sized field can't manufacture a
   528  	// pointer to the next object in the heap. See issue 9401.
   529  	if size > 0 && fields[len(fields)-1].Type.width == 0 {
   530  		size++
   531  	}
   532  
   533  	var intRegs, floatRegs uint64
   534  	for _, field := range fields {
   535  		typ := field.Type
   536  
   537  		// The alignment of a struct type is the maximum alignment of its
   538  		// field types.
   539  		if align := typ.align; align > maxAlign {
   540  			maxAlign = align
   541  		}
   542  
   543  		// Each field needs its own registers.
   544  		// We sum in uint64 to avoid possible overflows.
   545  		intRegs += uint64(typ.intRegs)
   546  		floatRegs += uint64(typ.floatRegs)
   547  	}
   548  
   549  	// Final size includes trailing padding.
   550  	size = RoundUp(size, int64(maxAlign))
   551  
   552  	if intRegs > math.MaxUint8 || floatRegs > math.MaxUint8 {
   553  		intRegs = math.MaxUint8
   554  		floatRegs = math.MaxUint8
   555  	}
   556  
   557  	t.width = size
   558  	t.align = maxAlign
   559  	t.intRegs = uint8(intRegs)
   560  	t.floatRegs = uint8(floatRegs)
   561  
   562  	// Compute eq/hash algorithm type.
   563  	t.alg = AMEM // default
   564  	if t.Noalg() {
   565  		t.setAlg(ANOALG)
   566  	}
   567  	if len(fields) == 1 && !fields[0].Sym.IsBlank() {
   568  		// One-field struct is same as that one field alone.
   569  		t.setAlg(fields[0].Type.alg)
   570  	} else {
   571  		for i, f := range fields {
   572  			a := f.Type.alg
   573  			switch a {
   574  			case ANOEQ, ANOALG:
   575  			case AMEM:
   576  				// Blank fields and padded fields need a special compare.
   577  				if f.Sym.IsBlank() || IsPaddedField(t, i) {
   578  					a = ASPECIAL
   579  				}
   580  			default:
   581  				// Fields with non-memory equality need a special compare.
   582  				a = ASPECIAL
   583  			}
   584  			t.setAlg(a)
   585  		}
   586  	}
   587  	// Compute ptrBytes.
   588  	for i := len(fields) - 1; i >= 0; i-- {
   589  		f := fields[i]
   590  		if size := PtrDataSize(f.Type); size > 0 {
   591  			t.ptrBytes = f.Offset + size
   592  			break
   593  		}
   594  	}
   595  
   596  	if len(t.Fields()) >= 1 && t.Fields()[0].Type.flags&typeIsSIMDTag != 0 {
   597  		// this catches `type Foo simd.Whatever` -- Foo is also SIMD.
   598  		if t.Fields()[0].Type.Sym().Name == "psve" {
   599  			simdify(t, false)
   600  			// Force it to be passed via memory for now.
   601  			// TODO: support p registers in the ABI.
   602  			t.intRegs = math.MaxUint8
   603  			t.floatRegs = math.MaxUint8
   604  		} else {
   605  			simdify(t, false)
   606  		}
   607  	}
   608  }
   609  
   610  // CalcArraySize calculates the size of t,
   611  // filling in t.width, t.align, t.alg, and t.ptrBytes,
   612  // even if size calculation is otherwise disabled.
   613  func CalcArraySize(t *Type) {
   614  	elem := t.Elem()
   615  	n := t.NumElem()
   616  	CalcSize(elem)
   617  	t.SetNotInHeap(elem.NotInHeap())
   618  	if elem.width != 0 {
   619  		cap := (uint64(MaxWidth) - 1) / uint64(elem.width)
   620  		if uint64(n) > cap {
   621  			base.Errorf("type %L larger than address space", t)
   622  		}
   623  	}
   624  
   625  	t.width = elem.width * n
   626  	t.align = elem.align
   627  	// ABIInternal only allows "trivial" arrays (i.e., length 0 or 1)
   628  	// to be passed by register.
   629  	switch n {
   630  	case 0:
   631  		t.intRegs = 0
   632  		t.floatRegs = 0
   633  	case 1:
   634  		t.intRegs = elem.intRegs
   635  		t.floatRegs = elem.floatRegs
   636  	default:
   637  		t.intRegs = math.MaxUint8
   638  		t.floatRegs = math.MaxUint8
   639  	}
   640  	t.alg = AMEM // default
   641  	if t.Noalg() {
   642  		t.setAlg(ANOALG)
   643  	}
   644  	switch a := elem.alg; a {
   645  	case AMEM, ANOEQ, ANOALG:
   646  		t.setAlg(a)
   647  	default:
   648  		switch n {
   649  		case 0:
   650  			// We checked above that the element type is comparable.
   651  			t.setAlg(AMEM)
   652  		case 1:
   653  			// Single-element array is same as its lone element.
   654  			t.setAlg(a)
   655  		default:
   656  			t.setAlg(ASPECIAL)
   657  		}
   658  	}
   659  	if n > 0 {
   660  		x := PtrDataSize(elem)
   661  		if x > 0 {
   662  			t.ptrBytes = elem.width*(n-1) + x
   663  		}
   664  	}
   665  }
   666  
   667  func (t *Type) widthCalculated() bool {
   668  	return t.align > 0
   669  }
   670  
   671  // when a type's width should be known, we call CheckSize
   672  // to compute it.  during a declaration like
   673  //
   674  //	type T *struct { next T }
   675  //
   676  // it is necessary to defer the calculation of the struct width
   677  // until after T has been initialized to be a pointer to that struct.
   678  // similarly, during import processing structs may be used
   679  // before their definition.  in those situations, calling
   680  // DeferCheckSize() stops width calculations until
   681  // ResumeCheckSize() is called, at which point all the
   682  // CalcSizes that were deferred are executed.
   683  // CalcSize should only be called when the type's size
   684  // is needed immediately.  CheckSize makes sure the
   685  // size is evaluated eventually.
   686  
   687  var deferredTypeStack []*Type
   688  
   689  func CheckSize(t *Type) {
   690  	if t == nil {
   691  		return
   692  	}
   693  
   694  	// function arg structs should not be checked
   695  	// outside of the enclosing function.
   696  	if t.IsFuncArgStruct() {
   697  		base.Fatalf("CheckSize %v", t)
   698  	}
   699  
   700  	if defercalc == 0 {
   701  		CalcSize(t)
   702  		return
   703  	}
   704  
   705  	// if type has not yet been pushed on deferredTypeStack yet, do it now
   706  	if !t.Deferwidth() {
   707  		t.SetDeferwidth(true)
   708  		deferredTypeStack = append(deferredTypeStack, t)
   709  	}
   710  }
   711  
   712  func DeferCheckSize() {
   713  	defercalc++
   714  }
   715  
   716  func ResumeCheckSize() {
   717  	if defercalc == 1 {
   718  		for len(deferredTypeStack) > 0 {
   719  			t := deferredTypeStack[len(deferredTypeStack)-1]
   720  			deferredTypeStack = deferredTypeStack[:len(deferredTypeStack)-1]
   721  			t.SetDeferwidth(false)
   722  			CalcSize(t)
   723  		}
   724  	}
   725  
   726  	defercalc--
   727  }
   728  
   729  // PtrDataSize returns the length in bytes of the prefix of t
   730  // containing pointer data. Anything after this offset is scalar data.
   731  //
   732  // PtrDataSize is only defined for actual Go types. It's an error to
   733  // use it on compiler-internal types (e.g., TSSA, TRESULTS).
   734  func PtrDataSize(t *Type) int64 {
   735  	CalcSize(t)
   736  	x := t.ptrBytes
   737  	if t.Kind() == TPTR && t.Elem().NotInHeap() {
   738  		// Note: this is done here instead of when we're setting
   739  		// the ptrBytes field, because at that time (in NewPtr, usually)
   740  		// the NotInHeap bit of the element type might not be set yet.
   741  		x = 0
   742  	}
   743  	return x
   744  }
   745
View as plain text