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