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 // no barrier (dead store) 15 16 z := y // no barrier 17 *x = z // ERROR "write barrier" 18 } 19 20 func f1(x *[]byte, y []byte) { 21 *x = y // no barrier (dead store) 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 // no barrier (dead store) 36 37 z := y // no barrier 38 *x = z // ERROR "write barrier" 39 } 40 41 func f2a(x *interface{}, y *interface{}) { 42 *x = *y // no barrier (dead store) 43 44 z := y // no barrier 45 *x = z // ERROR "write barrier" 46 } 47 48 func f3(x *string, y string) { 49 *x = y // no barrier (dead store) 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 // f21x: Global -> heap pointer updates must have write barriers. 208 func f21a(x *int) { 209 x21 = x // ERROR "write barrier" 210 y21.x = x // ERROR "write barrier" 211 } 212 213 func f21b(x *int) { 214 x21 = &z21 // ERROR "write barrier" 215 y21.x = &z21 // ERROR "write barrier" 216 } 217 218 func f21c(x *int) { 219 y21 = struct{ x *int }{x} // ERROR "write barrier" 220 } 221 222 func f22(x *int) (y *int) { 223 // pointer write on stack should have no write barrier. 224 // this is a case that the frontend failed to eliminate. 225 p := &y 226 *p = x // no barrier 227 return 228 } 229 230 type T23 struct { 231 p *int 232 a int 233 } 234 235 var t23 T23 236 var i23 int 237 238 // f23x: zeroing global needs write barrier for the hybrid barrier. 239 func f23a() { 240 t23 = T23{} // ERROR "write barrier" 241 } 242 243 func f23b() { 244 // also test partial assignments 245 t23 = T23{a: 1} // ERROR "write barrier" 246 } 247 248 func f23c() { 249 t23 = T23{} // no barrier (dead store) 250 // also test partial assignments 251 t23 = T23{p: &i23} // ERROR "write barrier" 252 } 253
