test/writebarrier.go

   1 // errorcheck -0 -l -d=wb
   2
   3 // Copyright 2015 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 // Test where write barriers are and are not emitted.
   8
   9 package p
  10
  11 import "unsafe"
  12
  13 func f(x **byte, y *byte) {
  14         *x = y // ERROR "write barrier"
  15
  16         z := y // no barrier
  17         *x = z // ERROR "write barrier"
  18 }
  19
  20 func f1(x *[]byte, y []byte) {
  21         *x = y // ERROR "write barrier"
  22
  23         z := y // no barrier
  24         *x = z // ERROR "write barrier"
  25 }
  26
  27 func f1a(x *[]byte, y *[]byte) {
  28         *x = *y // ERROR "write barrier"
  29
  30         z := *y // no barrier
  31         *x = z  // ERROR "write barrier"
  32 }
  33
  34 func f2(x *interface{}, y interface{}) {
  35         *x = y // ERROR "write barrier"
  36
  37         z := y // no barrier
  38         *x = z // ERROR "write barrier"
  39 }
  40
  41 func f2a(x *interface{}, y *interface{}) {
  42         *x = *y // ERROR "write barrier"
  43
  44         z := y // no barrier
  45         *x = z // ERROR "write barrier"
  46 }
  47
  48 func f3(x *string, y string) {
  49         *x = y // ERROR "write barrier"
  50
  51         z := y // no barrier
  52         *x = z // ERROR "write barrier"
  53 }
  54
  55 func f3a(x *string, y *string) {
  56         *x = *y // ERROR "write barrier"
  57
  58         z := *y // no barrier
  59         *x = z  // ERROR "write barrier"
  60 }
  61
  62 func f4(x *[2]string, y [2]string) {
  63         *x = y // ERROR "write barrier"
  64
  65         z := y // no barrier
  66         *x = z // ERROR "write barrier"
  67 }
  68
  69 func f4a(x *[2]string, y *[2]string) {
  70         *x = *y // ERROR "write barrier"
  71
  72         z := *y // no barrier
  73         *x = z  // ERROR "write barrier"
  74 }
  75
  76 type T struct {
  77         X *int
  78         Y int
  79         M map[int]int
  80 }
  81
  82 func f5(t, u *T) {
  83         t.X = &u.Y // ERROR "write barrier"
  84 }
  85
  86 func f6(t *T) {
  87         t.M = map[int]int{1: 2} // ERROR "write barrier"
  88 }
  89
  90 func f7(x, y *int) []*int {
  91         var z [3]*int
  92         i := 0
  93         z[i] = x // ERROR "write barrier"
  94         i++
  95         z[i] = y // ERROR "write barrier"
  96         i++
  97         return z[:i]
  98 }
  99
 100 func f9(x *interface{}, v *byte) {
 101         *x = v // ERROR "write barrier"
 102 }
 103
 104 func f10(x *byte, f func(interface{})) {
 105         f(x)
 106 }
 107
 108 func f11(x *unsafe.Pointer, y unsafe.Pointer) {
 109         *x = unsafe.Pointer(uintptr(y) + 1) // ERROR "write barrier"
 110 }
 111
 112 func f12(x []*int, y *int) []*int {
 113         // write barrier for storing y in x's underlying array
 114         x = append(x, y) // ERROR "write barrier"
 115         return x
 116 }
 117
 118 func f12a(x []int, y int) []int {
 119         // y not a pointer, so no write barriers in this function
 120         x = append(x, y)
 121         return x
 122 }
 123
 124 func f13(x []int, y *[]int) {
 125         *y = append(x, 1) // ERROR "write barrier"
 126 }
 127
 128 func f14(y *[]int) {
 129         *y = append(*y, 1) // ERROR "write barrier"
 130 }
 131
 132 type T1 struct {
 133         X *int
 134 }
 135
 136 func f15(x []T1, y T1) []T1 {
 137         return append(x, y) // ERROR "write barrier"
 138 }
 139
 140 type T8 struct {
 141         X [8]*int
 142 }
 143
 144 func f16(x []T8, y T8) []T8 {
 145         return append(x, y) // ERROR "write barrier"
 146 }
 147
 148 func t1(i interface{}) **int {
 149         // From issue 14306, make sure we have write barriers in a type switch
 150         // where the assigned variable escapes.
 151         switch x := i.(type) { // ERROR "write barrier"
 152         case *int:
 153                 return &x
 154         }
 155         switch y := i.(type) { // no write barrier here
 156         case **int:
 157                 return y
 158         }
 159         return nil
 160 }
 161
 162 type T17 struct {
 163         f func(*T17)
 164 }
 165
 166 func f17(x *T17) {
 167         // Originally from golang.org/issue/13901, but the hybrid
 168         // barrier requires both to have barriers.
 169         x.f = f17                      // ERROR "write barrier"
 170         x.f = func(y *T17) { *y = *x } // ERROR "write barrier"
 171 }
 172
 173 type T18 struct {
 174         a []int
 175         s string
 176 }
 177
 178 func f18(p *T18, x *[]int) {
 179         p.a = p.a[:5]    // no barrier
 180         *x = (*x)[0:5]   // no barrier
 181         p.a = p.a[3:5]   // ERROR "write barrier"
 182         p.a = p.a[1:2:3] // ERROR "write barrier"
 183         p.s = p.s[8:9]   // ERROR "write barrier"
 184         *x = (*x)[3:5]   // ERROR "write barrier"
 185 }
 186
 187 func f19(x, y *int, i int) int {
 188         // Constructing a temporary slice on the stack should not
 189         // require any write barriers. See issue 14263.
 190         a := []*int{x, y} // no barrier
 191         return *a[i]
 192 }
 193
 194 func f20(x, y *int, i int) []*int {
 195         // ... but if that temporary slice escapes, then the
 196         // write barriers are necessary.
 197         a := []*int{x, y} // ERROR "write barrier"
 198         return a
 199 }
 200
 201 var x21 *int
 202 var y21 struct {
 203         x *int
 204 }
 205 var z21 int
 206
 207 func f21(x *int) {
 208         // Global -> heap pointer updates must have write barriers.
 209         x21 = x                   // ERROR "write barrier"
 210         y21.x = x                 // ERROR "write barrier"
 211         x21 = &z21                // ERROR "write barrier"
 212         y21.x = &z21              // ERROR "write barrier"
 213         y21 = struct{ x *int }{x} // ERROR "write barrier"
 214 }
 215
 216 func f22(x *int) (y *int) {
 217         // pointer write on stack should have no write barrier.
 218         // this is a case that the frontend failed to eliminate.
 219         p := &y
 220         *p = x // no barrier
 221         return
 222 }
 223
 224 type T23 struct {
 225         p *int
 226         a int
 227 }
 228
 229 var t23 T23
 230 var i23 int
 231
 232 func f23() {
 233         // zeroing global needs write barrier for the hybrid barrier.
 234         t23 = T23{} // ERROR "write barrier"
 235         // also test partial assignments
 236         t23 = T23{a: 1}    // ERROR "write barrier"
 237         t23 = T23{p: &i23} // ERROR "write barrier"
 238 }