// errorcheck -0 -l -d=wb
-// Copyright 2015 The Go Authors. All rights reserved.
+// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
import "unsafe"
func f(x **byte, y *byte) {
- *x = y // ERROR "write barrier"
+ *x = y // no barrier (dead store)
z := y // no barrier
*x = z // ERROR "write barrier"
}
func f1(x *[]byte, y []byte) {
- *x = y // ERROR "write barrier"
+ *x = y // no barrier (dead store)
z := y // no barrier
*x = z // ERROR "write barrier"
*x = *y // ERROR "write barrier"
z := *y // no barrier
- *x = z // ERROR "write barrier"
+ *x = z // ERROR "write barrier"
}
func f2(x *interface{}, y interface{}) {
- *x = y // ERROR "write barrier"
+ *x = y // no barrier (dead store)
z := y // no barrier
*x = z // ERROR "write barrier"
}
func f2a(x *interface{}, y *interface{}) {
- *x = *y // ERROR "write barrier"
+ *x = *y // no barrier (dead store)
z := y // no barrier
*x = z // ERROR "write barrier"
}
func f3(x *string, y string) {
- *x = y // ERROR "write barrier"
+ *x = y // no barrier (dead store)
z := y // no barrier
*x = z // ERROR "write barrier"
*x = *y // ERROR "write barrier"
z := *y // no barrier
- *x = z // ERROR "write barrier"
+ *x = z // ERROR "write barrier"
}
func f4(x *[2]string, y [2]string) {
*x = *y // ERROR "write barrier"
z := *y // no barrier
- *x = z // ERROR "write barrier"
+ *x = z // ERROR "write barrier"
}
type T struct {
func f11(x *unsafe.Pointer, y unsafe.Pointer) {
*x = unsafe.Pointer(uintptr(y) + 1) // ERROR "write barrier"
}
+
+func f12(x []*int, y *int) []*int {
+ // write barrier for storing y in x's underlying array
+ x = append(x, y) // ERROR "write barrier"
+ return x
+}
+
+func f12a(x []int, y int) []int {
+ // y not a pointer, so no write barriers in this function
+ x = append(x, y)
+ return x
+}
+
+func f13(x []int, y *[]int) {
+ *y = append(x, 1) // ERROR "write barrier"
+}
+
+func f14(y *[]int) {
+ *y = append(*y, 1) // ERROR "write barrier"
+}
+
+type T1 struct {
+ X *int
+}
+
+func f15(x []T1, y T1) []T1 {
+ return append(x, y) // ERROR "write barrier"
+}
+
+type T8 struct {
+ X [8]*int
+}
+
+func f16(x []T8, y T8) []T8 {
+ return append(x, y) // ERROR "write barrier"
+}
+
+func t1(i interface{}) **int {
+ // From issue 14306, make sure we have write barriers in a type switch
+ // where the assigned variable escapes.
+ switch x := i.(type) {
+ case *int: // ERROR "write barrier"
+ return &x
+ }
+ switch y := i.(type) {
+ case **int: // no write barrier here
+ return y
+ }
+ return nil
+}
+
+type T17 struct {
+ f func(*T17)
+}
+
+func f17(x *T17) {
+ // Originally from golang.org/issue/13901, but the hybrid
+ // barrier requires both to have barriers.
+ x.f = f17 // ERROR "write barrier"
+ x.f = func(y *T17) { *y = *x } // ERROR "write barrier"
+}
+
+type T18 struct {
+ a []int
+ s string
+}
+
+func f18(p *T18, x *[]int) {
+ p.a = p.a[:5] // no barrier
+ *x = (*x)[0:5] // no barrier
+ p.a = p.a[3:5] // ERROR "write barrier"
+ p.a = p.a[1:2:3] // ERROR "write barrier"
+ p.s = p.s[8:9] // ERROR "write barrier"
+ *x = (*x)[3:5] // ERROR "write barrier"
+}
+
+func f19(x, y *int, i int) int {
+ // Constructing a temporary slice on the stack should not
+ // require any write barriers. See issue 14263.
+ a := []*int{x, y} // no barrier
+ return *a[i]
+}
+
+func f20(x, y *int, i int) []*int {
+ // ... but if that temporary slice escapes, then the
+ // write barriers are necessary.
+ a := []*int{x, y} // ERROR "write barrier"
+ return a
+}
+
+var x21 *int
+var y21 struct {
+ x *int
+}
+var z21 int
+
+// f21x: Global -> heap pointer updates must have write barriers.
+func f21a(x *int) {
+ x21 = x // ERROR "write barrier"
+ y21.x = x // ERROR "write barrier"
+}
+
+func f21b(x *int) {
+ x21 = &z21 // ERROR "write barrier"
+ y21.x = &z21 // ERROR "write barrier"
+}
+
+func f21c(x *int) {
+ y21 = struct{ x *int }{x} // ERROR "write barrier"
+}
+
+func f22(x *int) (y *int) {
+ // pointer write on stack should have no write barrier.
+ // this is a case that the frontend failed to eliminate.
+ p := &y
+ *p = x // no barrier
+ return
+}
+
+type T23 struct {
+ p *int
+ a int
+}
+
+var t23 T23
+var i23 int
+
+// f23x: zeroing global needs write barrier for the hybrid barrier.
+func f23a() {
+ t23 = T23{} // ERROR "write barrier"
+}
+
+func f23b() {
+ // also test partial assignments
+ t23 = T23{a: 1} // ERROR "write barrier"
+}
+
+func f23c() {
+ t23 = T23{} // no barrier (dead store)
+ // also test partial assignments
+ t23 = T23{p: &i23} // ERROR "write barrier"
+}
+
+var g int
+
+func f24() **int {
+ p := new(*int)
+ *p = &g // no write barrier here
+ return p
+}
+func f25() []string {
+ return []string{"abc", "def", "ghi"} // no write barrier here
+}
+
+type T26 struct {
+ a, b, c int
+ d, e, f *int
+}
+
+var g26 int
+
+func f26(p *int) *T26 { // see issue 29573
+ return &T26{
+ a: 5,
+ b: 6,
+ c: 7,
+ d: &g26, // no write barrier: global ptr
+ e: nil, // no write barrier: nil ptr
+ f: p, // ERROR "write barrier"
+ }
+}
+
+func f27(p *int) []interface{} {
+ return []interface{}{
+ nil, // no write barrier: zeroed memory, nil ptr
+ (*T26)(nil), // no write barrier: zeroed memory, type ptr & nil ptr
+ &g26, // no write barrier: zeroed memory, type ptr & global ptr
+ 7, // no write barrier: zeroed memory, type ptr & global ptr
+ p, // ERROR "write barrier"
+ }
+}
+
+var g28 [256]uint64
+
+func f28() []interface{} {
+ return []interface{}{
+ false, // no write barrier
+ true, // no write barrier
+ 0, // no write barrier
+ 1, // no write barrier
+ uint8(127), // no write barrier
+ int8(-4), // no write barrier
+ &g28[5], // no write barrier
+ }
+}