[dev.ssa] cmd/compile: fix write barriers for SSA

The old write barriers used _nostore versions, which
don't work for Ian's cgo checker.  Instead, we adopt the
same write barrier pattern as the default compiler.

It's a bit trickier to code up but should be more efficient.

Change-Id: I6696c3656cf179e28f800b0e096b7259bd5f3bb7
Reviewed-on: https://go-review.googlesource.com/18941
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>

misc/cgo/errors/ptr.go

@@ -134,111 +134,109 @@ var ptrTests = []ptrTest{
 		body:    `parg := [1]**C.char{&hello[0]}; C.f(&parg[0])`,
 		fail:    true,
 	},
-	/*
-			{
-				// Storing a Go pointer into C memory should fail.
-				name: "barrier",
-				c: `#include <stdlib.h>
-		                    char **f1() { return malloc(sizeof(char*)); }
-		                    void f2(char **p) {}`,
-				body:      `p := C.f1(); *p = new(C.char); C.f2(p)`,
-				fail:      true,
-				expensive: true,
-			},
-			{
-				// Storing a Go pointer into C memory by assigning a
-				// large value should fail.
-				name: "barrier-struct",
-				c: `#include <stdlib.h>
-		                    struct s { char *a[10]; };
-		                    struct s *f1() { return malloc(sizeof(struct s)); }
-		                    void f2(struct s *p) {}`,
-				body:      `p := C.f1(); p.a = [10]*C.char{new(C.char)}; C.f2(p)`,
-				fail:      true,
-				expensive: true,
-			},
-			{
-				// Storing a Go pointer into C memory using a slice
-				// copy should fail.
-				name: "barrier-slice",
-				c: `#include <stdlib.h>
-		                    struct s { char *a[10]; };
-		                    struct s *f1() { return malloc(sizeof(struct s)); }
-		                    void f2(struct s *p) {}`,
-				body:      `p := C.f1(); copy(p.a[:], []*C.char{new(C.char)}); C.f2(p)`,
-				fail:      true,
-				expensive: true,
-			},
-			{
-				// A very large value uses a GC program, which is a
-				// different code path.
-				name: "barrier-gcprog-array",
-				c: `#include <stdlib.h>
-		                    struct s { char *a[32769]; };
-		                    struct s *f1() { return malloc(sizeof(struct s)); }
-		                    void f2(struct s *p) {}`,
-				body:      `p := C.f1(); p.a = [32769]*C.char{new(C.char)}; C.f2(p)`,
-				fail:      true,
-				expensive: true,
-			},
-			{
-				// Similar case, with a source on the heap.
-				name: "barrier-gcprog-array-heap",
-				c: `#include <stdlib.h>
-		                    struct s { char *a[32769]; };
-		                    struct s *f1() { return malloc(sizeof(struct s)); }
-		                    void f2(struct s *p) {}
-		                    void f3(void *p) {}`,
-				imports:   []string{"unsafe"},
-				body:      `p := C.f1(); n := &[32769]*C.char{new(C.char)}; p.a = *n; C.f2(p); n[0] = nil; C.f3(unsafe.Pointer(n))`,
-				fail:      true,
-				expensive: true,
-			},
-			{
-				// A GC program with a struct.
-				name: "barrier-gcprog-struct",
-				c: `#include <stdlib.h>
-		                    struct s { char *a[32769]; };
-		                    struct s2 { struct s f; };
-		                    struct s2 *f1() { return malloc(sizeof(struct s2)); }
-		                    void f2(struct s2 *p) {}`,
-				body:      `p := C.f1(); p.f = C.struct_s{[32769]*C.char{new(C.char)}}; C.f2(p)`,
-				fail:      true,
-				expensive: true,
-			},
-			{
-				// Similar case, with a source on the heap.
-				name: "barrier-gcprog-struct-heap",
-				c: `#include <stdlib.h>
-		                    struct s { char *a[32769]; };
-		                    struct s2 { struct s f; };
-		                    struct s2 *f1() { return malloc(sizeof(struct s2)); }
-		                    void f2(struct s2 *p) {}
-		                    void f3(void *p) {}`,
-				imports:   []string{"unsafe"},
-				body:      `p := C.f1(); n := &C.struct_s{[32769]*C.char{new(C.char)}}; p.f = *n; C.f2(p); n.a[0] = nil; C.f3(unsafe.Pointer(n))`,
-				fail:      true,
-				expensive: true,
-			},
-			{
-				// Exported functions may not return Go pointers.
-				name: "export1",
-				c:    `extern unsigned char *GoFn();`,
-				support: `//export GoFn
-		                          func GoFn() *byte { return new(byte) }`,
-				body: `C.GoFn()`,
-				fail: true,
-			},
-			{
-				// Returning a C pointer is fine.
-				name: "exportok",
-				c: `#include <stdlib.h>
-		                    extern unsigned char *GoFn();`,
-				support: `//export GoFn
-		                          func GoFn() *byte { return (*byte)(C.malloc(1)) }`,
-				body: `C.GoFn()`,
-			},
-	*/
+	{
+		// Storing a Go pointer into C memory should fail.
+		name: "barrier",
+		c: `#include <stdlib.h>
+                    char **f1() { return malloc(sizeof(char*)); }
+                    void f2(char **p) {}`,
+		body:      `p := C.f1(); *p = new(C.char); C.f2(p)`,
+		fail:      true,
+		expensive: true,
+	},
+	{
+		// Storing a Go pointer into C memory by assigning a
+		// large value should fail.
+		name: "barrier-struct",
+		c: `#include <stdlib.h>
+                    struct s { char *a[10]; };
+                    struct s *f1() { return malloc(sizeof(struct s)); }
+                    void f2(struct s *p) {}`,
+		body:      `p := C.f1(); p.a = [10]*C.char{new(C.char)}; C.f2(p)`,
+		fail:      true,
+		expensive: true,
+	},
+	{
+		// Storing a Go pointer into C memory using a slice
+		// copy should fail.
+		name: "barrier-slice",
+		c: `#include <stdlib.h>
+                    struct s { char *a[10]; };
+                    struct s *f1() { return malloc(sizeof(struct s)); }
+                    void f2(struct s *p) {}`,
+		body:      `p := C.f1(); copy(p.a[:], []*C.char{new(C.char)}); C.f2(p)`,
+		fail:      true,
+		expensive: true,
+	},
+	{
+		// A very large value uses a GC program, which is a
+		// different code path.
+		name: "barrier-gcprog-array",
+		c: `#include <stdlib.h>
+                    struct s { char *a[32769]; };
+                    struct s *f1() { return malloc(sizeof(struct s)); }
+                    void f2(struct s *p) {}`,
+		body:      `p := C.f1(); p.a = [32769]*C.char{new(C.char)}; C.f2(p)`,
+		fail:      true,
+		expensive: true,
+	},
+	{
+		// Similar case, with a source on the heap.
+		name: "barrier-gcprog-array-heap",
+		c: `#include <stdlib.h>
+                    struct s { char *a[32769]; };
+                    struct s *f1() { return malloc(sizeof(struct s)); }
+                    void f2(struct s *p) {}
+                    void f3(void *p) {}`,
+		imports:   []string{"unsafe"},
+		body:      `p := C.f1(); n := &[32769]*C.char{new(C.char)}; p.a = *n; C.f2(p); n[0] = nil; C.f3(unsafe.Pointer(n))`,
+		fail:      true,
+		expensive: true,
+	},
+	{
+		// A GC program with a struct.
+		name: "barrier-gcprog-struct",
+		c: `#include <stdlib.h>
+                    struct s { char *a[32769]; };
+                    struct s2 { struct s f; };
+                    struct s2 *f1() { return malloc(sizeof(struct s2)); }
+                    void f2(struct s2 *p) {}`,
+		body:      `p := C.f1(); p.f = C.struct_s{[32769]*C.char{new(C.char)}}; C.f2(p)`,
+		fail:      true,
+		expensive: true,
+	},
+	{
+		// Similar case, with a source on the heap.
+		name: "barrier-gcprog-struct-heap",
+		c: `#include <stdlib.h>
+                    struct s { char *a[32769]; };
+                    struct s2 { struct s f; };
+                    struct s2 *f1() { return malloc(sizeof(struct s2)); }
+                    void f2(struct s2 *p) {}
+                    void f3(void *p) {}`,
+		imports:   []string{"unsafe"},
+		body:      `p := C.f1(); n := &C.struct_s{[32769]*C.char{new(C.char)}}; p.f = *n; C.f2(p); n.a[0] = nil; C.f3(unsafe.Pointer(n))`,
+		fail:      true,
+		expensive: true,
+	},
+	{
+		// Exported functions may not return Go pointers.
+		name: "export1",
+		c:    `extern unsigned char *GoFn();`,
+		support: `//export GoFn
+                          func GoFn() *byte { return new(byte) }`,
+		body: `C.GoFn()`,
+		fail: true,
+	},
+	{
+		// Returning a C pointer is fine.
+		name: "exportok",
+		c: `#include <stdlib.h>
+                    extern unsigned char *GoFn();`,
+		support: `//export GoFn
+                          func GoFn() *byte { return (*byte)(C.malloc(1)) }`,
+		body: `C.GoFn()`,
+	},
 }
 
 func main() {

src/cmd/compile/internal/gc/builtin.go

@@ -117,7 +117,6 @@ const runtimeimport = "" +
 	"func @\"\".writebarrierfat1110 (@\"\".dst·1 *any, _ uintptr, @\"\".src·3 any)\n" +
 	"func @\"\".writebarrierfat1111 (@\"\".dst·1 *any, _ uintptr, @\"\".src·3 any)\n" +
 	"func @\"\".typedmemmove (@\"\".typ·1 *byte, @\"\".dst·2 *any, @\"\".src·3 *any)\n" +
-	"func @\"\".typedmemmove_nostore (@\"\".typ·1 *byte, @\"\".dst·2 *any)\n" +
 	"func @\"\".typedslicecopy (@\"\".typ·2 *byte, @\"\".dst·3 any, @\"\".src·4 any) (? int)\n" +
 	"func @\"\".selectnbsend (@\"\".chanType·2 *byte, @\"\".hchan·3 chan<- any, @\"\".elem·4 *any) (? bool)\n" +
 	"func @\"\".selectnbrecv (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".hchan·4 <-chan any) (? bool)\n" +

src/cmd/compile/internal/gc/builtin/runtime.go

@@ -151,7 +151,6 @@ func writebarrierfat1111(dst *any, _ uintptr, src any)
 
 // *byte is really *runtime.Type
 func typedmemmove(typ *byte, dst *any, src *any)
-func typedmemmove_nostore(typ *byte, dst *any)
 func typedslicecopy(typ *byte, dst any, src any) int
 
 func selectnbsend(chanType *byte, hchan chan<- any, elem *any) bool

src/cmd/compile/internal/gc/go.go

@@ -868,6 +868,7 @@ var throwreturn *Node
 
 var growslice *Node
 
-var typedmemmove_nostore *Node
+var writebarrierptr *Node
+var typedmemmove *Node
 
 var panicdottype *Node

src/cmd/compile/internal/gc/pgen.go

@@ -353,7 +353,8 @@ func compile(fn *Node) {
 		panicdivide = Sysfunc("panicdivide")
 		throwreturn = Sysfunc("throwreturn")
 		growslice = Sysfunc("growslice")
-		typedmemmove_nostore = Sysfunc("typedmemmove_nostore")
+		writebarrierptr = Sysfunc("writebarrierptr")
+		typedmemmove = Sysfunc("typedmemmove")
 		panicdottype = Sysfunc("panicdottype")
 	}
 

src/runtime/mbarrier.go

@@ -197,14 +197,6 @@ func typedmemmove(typ *_type, dst, src unsafe.Pointer) {
 	heapBitsBulkBarrier(uintptr(dst), typ.size)
 }
 
-//go:nosplit
-func typedmemmove_nostore(typ *_type, dst unsafe.Pointer) {
-	if typ.kind&kindNoPointers != 0 {
-		return
-	}
-	heapBitsBulkBarrier(uintptr(dst), typ.size)
-}
-
 //go:linkname reflect_typedmemmove reflect.typedmemmove
 func reflect_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
 	typedmemmove(typ, dst, src)