gcinfo_test.go

     1  // Copyright 2014 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 runtime_test
     6  
     7  import (
     8  	"bytes"
     9  	"runtime"
    10  	"testing"
    11  )
    12  
    13  const (
    14  	typeScalar  = 0
    15  	typePointer = 1
    16  )
    17  
    18  // TestGCInfo tests that various objects in heap, data and bss receive correct GC pointer type info.
    19  func TestGCInfo(t *testing.T) {
    20  	verifyGCInfo(t, "bss Ptr", &bssPtr, infoPtr)
    21  	verifyGCInfo(t, "bss ScalarPtr", &bssScalarPtr, infoScalarPtr)
    22  	verifyGCInfo(t, "bss PtrScalar", &bssPtrScalar, infoPtrScalar)
    23  	verifyGCInfo(t, "bss BigStruct", &bssBigStruct, infoBigStruct())
    24  	verifyGCInfo(t, "bss string", &bssString, infoString)
    25  	verifyGCInfo(t, "bss slice", &bssSlice, infoSlice)
    26  	verifyGCInfo(t, "bss eface", &bssEface, infoEface)
    27  	verifyGCInfo(t, "bss iface", &bssIface, infoIface)
    28  
    29  	verifyGCInfo(t, "data Ptr", &dataPtr, infoPtr)
    30  	verifyGCInfo(t, "data ScalarPtr", &dataScalarPtr, infoScalarPtr)
    31  	verifyGCInfo(t, "data PtrScalar", &dataPtrScalar, infoPtrScalar)
    32  	verifyGCInfo(t, "data BigStruct", &dataBigStruct, infoBigStruct())
    33  	verifyGCInfo(t, "data string", &dataString, infoString)
    34  	verifyGCInfo(t, "data slice", &dataSlice, infoSlice)
    35  	verifyGCInfo(t, "data eface", &dataEface, infoEface)
    36  	verifyGCInfo(t, "data iface", &dataIface, infoIface)
    37  
    38  	{
    39  		var x Ptr
    40  		verifyGCInfo(t, "stack Ptr", &x, infoPtr)
    41  		runtime.KeepAlive(x)
    42  	}
    43  	{
    44  		var x ScalarPtr
    45  		verifyGCInfo(t, "stack ScalarPtr", &x, infoScalarPtr)
    46  		runtime.KeepAlive(x)
    47  	}
    48  	{
    49  		var x PtrScalar
    50  		verifyGCInfo(t, "stack PtrScalar", &x, infoPtrScalar)
    51  		runtime.KeepAlive(x)
    52  	}
    53  	{
    54  		var x BigStruct
    55  		verifyGCInfo(t, "stack BigStruct", &x, infoBigStruct())
    56  		runtime.KeepAlive(x)
    57  	}
    58  	{
    59  		var x string
    60  		verifyGCInfo(t, "stack string", &x, infoString)
    61  		runtime.KeepAlive(x)
    62  	}
    63  	{
    64  		var x []string
    65  		verifyGCInfo(t, "stack slice", &x, infoSlice)
    66  		runtime.KeepAlive(x)
    67  	}
    68  	{
    69  		var x any
    70  		verifyGCInfo(t, "stack eface", &x, infoEface)
    71  		runtime.KeepAlive(x)
    72  	}
    73  	{
    74  		var x Iface
    75  		verifyGCInfo(t, "stack iface", &x, infoIface)
    76  		runtime.KeepAlive(x)
    77  	}
    78  
    79  	for i := 0; i < 10; i++ {
    80  		verifyGCInfo(t, "heap Ptr", runtime.Escape(new(Ptr)), trimDead(infoPtr))
    81  		verifyGCInfo(t, "heap PtrSlice", runtime.Escape(&make([]*byte, 10)[0]), trimDead(infoPtr10))
    82  		verifyGCInfo(t, "heap ScalarPtr", runtime.Escape(new(ScalarPtr)), trimDead(infoScalarPtr))
    83  		verifyGCInfo(t, "heap ScalarPtrSlice", runtime.Escape(&make([]ScalarPtr, 4)[0]), trimDead(infoScalarPtr4))
    84  		verifyGCInfo(t, "heap PtrScalar", runtime.Escape(new(PtrScalar)), trimDead(infoPtrScalar))
    85  		verifyGCInfo(t, "heap BigStruct", runtime.Escape(new(BigStruct)), trimDead(infoBigStruct()))
    86  		verifyGCInfo(t, "heap string", runtime.Escape(new(string)), trimDead(infoString))
    87  		verifyGCInfo(t, "heap eface", runtime.Escape(new(any)), trimDead(infoEface))
    88  		verifyGCInfo(t, "heap iface", runtime.Escape(new(Iface)), trimDead(infoIface))
    89  	}
    90  }
    91  
    92  func verifyGCInfo(t *testing.T, name string, p any, mask0 []byte) {
    93  	mask := runtime.GCMask(p)
    94  	if bytes.HasPrefix(mask, mask0) {
    95  		// Just the prefix matching is OK.
    96  		//
    97  		// The Go runtime's pointer/scalar iterator generates pointers beyond
    98  		// the size of the type, up to the size of the size class. This space
    99  		// is safe for the GC to scan since it's zero, and GCBits checks to
   100  		// make sure that's true. But we need to handle the fact that the bitmap
   101  		// may be larger than we expect.
   102  		return
   103  	}
   104  	t.Errorf("bad GC program for %v:\nwant %+v\ngot  %+v", name, mask0, mask)
   105  }
   106  
   107  func trimDead(mask []byte) []byte {
   108  	for len(mask) > 0 && mask[len(mask)-1] == typeScalar {
   109  		mask = mask[:len(mask)-1]
   110  	}
   111  	return mask
   112  }
   113  
   114  var infoPtr = []byte{typePointer}
   115  
   116  type Ptr struct {
   117  	*byte
   118  }
   119  
   120  var infoPtr10 = []byte{typePointer, typePointer, typePointer, typePointer, typePointer, typePointer, typePointer, typePointer, typePointer, typePointer}
   121  
   122  type ScalarPtr struct {
   123  	q int
   124  	w *int
   125  	e int
   126  	r *int
   127  	t int
   128  	y *int
   129  }
   130  
   131  var infoScalarPtr = []byte{typeScalar, typePointer, typeScalar, typePointer, typeScalar, typePointer}
   132  
   133  var infoScalarPtr4 = append(append(append(append([]byte(nil), infoScalarPtr...), infoScalarPtr...), infoScalarPtr...), infoScalarPtr...)
   134  
   135  type PtrScalar struct {
   136  	q *int
   137  	w int
   138  	e *int
   139  	r int
   140  	t *int
   141  	y int
   142  }
   143  
   144  var infoPtrScalar = []byte{typePointer, typeScalar, typePointer, typeScalar, typePointer, typeScalar}
   145  
   146  type BigStruct struct {
   147  	q *int
   148  	w byte
   149  	e [17]byte
   150  	r []byte
   151  	t int
   152  	y uint16
   153  	u uint64
   154  	i string
   155  }
   156  
   157  func infoBigStruct() []byte {
   158  	switch runtime.GOARCH {
   159  	case "386", "arm", "mips", "mipsle":
   160  		return []byte{
   161  			typePointer,                                                // q *int
   162  			typeScalar, typeScalar, typeScalar, typeScalar, typeScalar, // w byte; e [17]byte
   163  			typePointer, typeScalar, typeScalar, // r []byte
   164  			typeScalar, typeScalar, typeScalar, typeScalar, // t int; y uint16; u uint64
   165  			typePointer, typeScalar, // i string
   166  		}
   167  	case "arm64", "amd64", "loong64", "mips64", "mips64le", "ppc64", "ppc64le", "riscv64", "s390x", "wasm":
   168  		return []byte{
   169  			typePointer,                        // q *int
   170  			typeScalar, typeScalar, typeScalar, // w byte; e [17]byte
   171  			typePointer, typeScalar, typeScalar, // r []byte
   172  			typeScalar, typeScalar, typeScalar, // t int; y uint16; u uint64
   173  			typePointer, typeScalar, // i string
   174  		}
   175  	default:
   176  		panic("unknown arch")
   177  	}
   178  }
   179  
   180  type Iface interface {
   181  	f()
   182  }
   183  
   184  type IfaceImpl int
   185  
   186  func (IfaceImpl) f() {
   187  }
   188  
   189  var (
   190  	// BSS
   191  	bssPtr       Ptr
   192  	bssScalarPtr ScalarPtr
   193  	bssPtrScalar PtrScalar
   194  	bssBigStruct BigStruct
   195  	bssString    string
   196  	bssSlice     []string
   197  	bssEface     any
   198  	bssIface     Iface
   199  
   200  	// DATA
   201  	dataPtr             = Ptr{new(byte)}
   202  	dataScalarPtr       = ScalarPtr{q: 1}
   203  	dataPtrScalar       = PtrScalar{w: 1}
   204  	dataBigStruct       = BigStruct{w: 1}
   205  	dataString          = "foo"
   206  	dataSlice           = []string{"foo"}
   207  	dataEface     any   = 42
   208  	dataIface     Iface = IfaceImpl(42)
   209  
   210  	infoString = []byte{typePointer, typeScalar}
   211  	infoSlice  = []byte{typePointer, typeScalar, typeScalar}
   212  	infoEface  = []byte{typeScalar, typePointer}
   213  	infoIface  = []byte{typeScalar, typePointer}
   214  )
   215
View as plain text