cmd/compile: optimize make+copy pattern to avoid memclr

match:
 m = make([]T, x); copy(m, s)
for pointer free T and x==len(s) rewrite to:
 m = mallocgc(x*elemsize(T), nil, false); memmove(&m, &s, x*elemsize(T))
otherwise rewrite to:
 m = makeslicecopy([]T, x, s)

This avoids memclear and shading of pointers in the newly created slice
before the copy.

With this CL "s" is only be allowed to bev a variable and not a more
complex expression. This restriction could be lifted in future versions
of this optimization when it can be proven that "s" is not referencing "m".

Triggers 450 times during make.bash..
Reduces go binary size by ~8 kbyte.

name                           old time/op  new time/op  delta
MakeSliceCopy/mallocmove/Byte  71.1ns ± 1%  65.8ns ± 0%  -7.49%  (p=0.000 n=10+9)
MakeSliceCopy/mallocmove/Int   71.2ns ± 1%  66.0ns ± 0%  -7.27%  (p=0.000 n=10+8)
MakeSliceCopy/mallocmove/Ptr    104ns ± 4%    99ns ± 1%  -5.13%  (p=0.000 n=10+10)
MakeSliceCopy/makecopy/Byte    70.3ns ± 0%  68.0ns ± 0%  -3.22%  (p=0.000 n=10+9)
MakeSliceCopy/makecopy/Int     70.3ns ± 0%  68.5ns ± 1%  -2.59%  (p=0.000 n=9+10)
MakeSliceCopy/makecopy/Ptr      102ns ± 0%    99ns ± 1%  -2.97%  (p=0.000 n=9+9)
MakeSliceCopy/nilappend/Byte   75.4ns ± 0%  74.9ns ± 2%  -0.63%  (p=0.015 n=9+9)
MakeSliceCopy/nilappend/Int    75.6ns ± 0%  76.4ns ± 3%    ~     (p=0.245 n=9+10)
MakeSliceCopy/nilappend/Ptr     107ns ± 0%   108ns ± 1%  +0.93%  (p=0.005 n=9+10)

Fixes #26252

Change-Id: Iec553dd1fef6ded16197216a472351c8799a8e71
Reviewed-on: https://go-review.googlesource.com/c/go/+/146719
Reviewed-by: Keith Randall <khr@golang.org>
Run-TryBot: Martin Möhrmann <moehrmann@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

2 files changed, 332 insertions, 0 deletions

diff --git a/test/codegen/slices.go b/test/codegen/slices.go
index cf569e27fb..40e857f9f6 100644
--- a/test/codegen/slices.go
+++ b/test/codegen/slices.go
@@ -104,6 +104,189 @@ func SliceExtensionInt64(s []int, l64 int64) []int {
 	return append(s, make([]int, l64)...)
 }
 
+// ------------------ //
+//      Make+Copy     //
+// ------------------ //
+
+// Issue #26252 - avoid memclr for make+copy
+
+func SliceMakeCopyLen(s []int) []int {
+	// amd64:`.*runtime\.mallocgc`
+	// amd64:`.*runtime\.memmove`
+	// amd64:-`.*runtime\.makeslice`
+	a := make([]int, len(s))
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyLenPtr(s []*int) []*int {
+	// amd64:`.*runtime\.makeslicecopy`
+	// amd64:-`.*runtime\.makeslice\(`
+	// amd64:-`.*runtime\.typedslicecopy
+	a := make([]*int, len(s))
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyConst(s []int) []int {
+	// amd64:`.*runtime\.makeslicecopy`
+	// amd64:-`.*runtime\.makeslice\(`
+	// amd64:-`.*runtime\.memmove`
+	a := make([]int, 4)
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyConstPtr(s []*int) []*int {
+	// amd64:`.*runtime\.makeslicecopy`
+	// amd64:-`.*runtime\.makeslice\(`
+	// amd64:-`.*runtime\.typedslicecopy
+	a := make([]*int, 4)
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyNoOptNoDeref(s []*int) []*int {
+	a := new([]*int)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	*a = make([]*int, 4)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.typedslicecopy`
+	copy(*a, s)
+	return *a
+}
+
+func SliceMakeCopyNoOptNoVar(s []*int) []*int {
+	a := make([][]*int, 1)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	a[0] = make([]*int, 4)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.typedslicecopy`
+	copy(a[0], s)
+	return a[0]
+}
+
+func SliceMakeCopyNoOptBlank(s []*int) []*int {
+	var a []*int
+	// amd64:-`.*runtime\.makeslicecopy`
+	_ = make([]*int, 4)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.typedslicecopy`
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyNoOptNoMake(s []*int) []*int {
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:-`.*runtime\.objectnew`
+	a := *new([]*int)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.typedslicecopy`
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyNoOptNoHeapAlloc(s []*int) int {
+	// amd64:-`.*runtime\.makeslicecopy`
+	a := make([]*int, 4)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.typedslicecopy`
+	copy(a, s)
+	return cap(a)
+}
+
+func SliceMakeCopyNoOptNoCap(s []*int) []*int {
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	a := make([]*int, 0, 4)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.typedslicecopy`
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyNoOptNoCopy(s []*int) []*int {
+	copy := func(x, y []*int) {}
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	a := make([]*int, 4)
+	// amd64:-`.*runtime\.makeslicecopy`
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyNoOptWrongOrder(s []*int) []*int {
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	a := make([]*int, 4)
+	// amd64:`.*runtime\.typedslicecopy`
+	// amd64:-`.*runtime\.makeslicecopy`
+	copy(s, a)
+	return a
+}
+
+func SliceMakeCopyNoOptWrongAssign(s []*int) []*int {
+	var a []*int
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	s = make([]*int, 4)
+	// amd64:`.*runtime\.typedslicecopy`
+	// amd64:-`.*runtime\.makeslicecopy`
+	copy(a, s)
+	return s
+}
+
+func SliceMakeCopyNoOptCopyLength(s []*int) (int, []*int) {
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	a := make([]*int, 4)
+	// amd64:`.*runtime\.typedslicecopy`
+	// amd64:-`.*runtime\.makeslicecopy`
+	n := copy(a, s)
+	return n, a
+}
+
+func SliceMakeCopyNoOptSelfCopy(s []*int) []*int {
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	a := make([]*int, 4)
+	// amd64:`.*runtime\.typedslicecopy`
+	// amd64:-`.*runtime\.makeslicecopy`
+	copy(a, a)
+	return a
+}
+
+func SliceMakeCopyNoOptTargetReference(s []*int) []*int {
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	a := make([]*int, 4)
+	// amd64:`.*runtime\.typedslicecopy`
+	// amd64:-`.*runtime\.makeslicecopy`
+	copy(a, s[:len(a)])
+	return a
+}
+
+func SliceMakeCopyNoOptCap(s []int) []int {
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.makeslice\(`
+	a := make([]int, len(s), 9)
+	// amd64:-`.*runtime\.makeslicecopy`
+	// amd64:`.*runtime\.memmove`
+	copy(a, s)
+	return a
+}
+
+func SliceMakeCopyNoMemmoveDifferentLen(s []int) []int {
+	// amd64:`.*runtime\.makeslicecopy`
+	// amd64:-`.*runtime\.memmove`
+	a := make([]int, len(s)-1)
+	// amd64:-`.*runtime\.memmove`
+	copy(a, s)
+	return a
+}
+
 // ---------------------- //
 //   Nil check of &s[0]   //
 // ---------------------- //
diff --git a/test/makeslice.go b/test/makeslice.go
new file mode 100644
index 0000000000..0ffecd7c43
--- /dev/null
+++ b/test/makeslice.go
@@ -0,0 +1,149 @@
+// run
+
+// Copyright 2013 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.
+
+package main
+
+import (
+	"strings"
+	"unsafe"
+)
+
+func main() {
+	n := -1
+	testInts(uint64(n))
+	testBytes(uint64(n))
+
+	var t *byte
+	if unsafe.Sizeof(t) == 8 {
+		// Test mem > maxAlloc
+		testInts(1 << 59)
+
+		// Test elem.size*cap overflow
+		testInts(1<<63 - 1)
+
+		testInts(1<<64 - 1)
+		testBytes(1<<64 - 1)
+	} else {
+		testInts(1<<31 - 1)
+
+		// Test elem.size*cap overflow
+		testInts(1<<32 - 1)
+		testBytes(1<<32 - 1)
+	}
+}
+
+func shouldPanic(str string, f func()) {
+	defer func() {
+		err := recover()
+		if err == nil {
+			panic("did not panic")
+		}
+		s := err.(error).Error()
+		if !strings.Contains(s, str) {
+			panic("got panic " + s + ", want " + str)
+		}
+	}()
+
+	f()
+}
+
+func testInts(n uint64) {
+	testMakeInts(n)
+	testMakeCopyInts(n)
+	testMakeInAppendInts(n)
+}
+
+func testBytes(n uint64) {
+	testMakeBytes(n)
+	testMakeCopyBytes(n)
+	testMakeInAppendBytes(n)
+}
+
+// Test make panics for given length or capacity n.
+func testMakeInts(n uint64) {
+	type T []int
+	shouldPanic("len out of range", func() { _ = make(T, int(n)) })
+	shouldPanic("cap out of range", func() { _ = make(T, 0, int(n)) })
+	shouldPanic("len out of range", func() { _ = make(T, uint(n)) })
+	shouldPanic("cap out of range", func() { _ = make(T, 0, uint(n)) })
+	shouldPanic("len out of range", func() { _ = make(T, int64(n)) })
+	shouldPanic("cap out of range", func() { _ = make(T, 0, int64(n)) })
+	shouldPanic("len out of range", func() { _ = make(T, uint64(n)) })
+	shouldPanic("cap out of range", func() { _ = make(T, 0, uint64(n)) })
+}
+
+func testMakeBytes(n uint64) {
+	type T []byte
+	shouldPanic("len out of range", func() { _ = make(T, int(n)) })
+	shouldPanic("cap out of range", func() { _ = make(T, 0, int(n)) })
+	shouldPanic("len out of range", func() { _ = make(T, uint(n)) })
+	shouldPanic("cap out of range", func() { _ = make(T, 0, uint(n)) })
+	shouldPanic("len out of range", func() { _ = make(T, int64(n)) })
+	shouldPanic("cap out of range", func() { _ = make(T, 0, int64(n)) })
+	shouldPanic("len out of range", func() { _ = make(T, uint64(n)) })
+	shouldPanic("cap out of range", func() { _ = make(T, 0, uint64(n)) })
+}
+
+// Test make+copy panics since the gc compiler optimizes these
+// to runtime.makeslicecopy calls.
+func testMakeCopyInts(n uint64) {
+	type T []int
+	var c = make(T, 8)
+	shouldPanic("len out of range", func() { x := make(T, int(n)); copy(x, c) })
+	shouldPanic("cap out of range", func() { x := make(T, 0, int(n)); copy(x, c) })
+	shouldPanic("len out of range", func() { x := make(T, uint(n)); copy(x, c) })
+	shouldPanic("cap out of range", func() { x := make(T, 0, uint(n)); copy(x, c) })
+	shouldPanic("len out of range", func() { x := make(T, int64(n)); copy(x, c) })
+	shouldPanic("cap out of range", func() { x := make(T, 0, int64(n)); copy(x, c) })
+	shouldPanic("len out of range", func() { x := make(T, uint64(n)); copy(x, c) })
+	shouldPanic("cap out of range", func() { x := make(T, 0, uint64(n)); copy(x, c) })
+}
+
+func testMakeCopyBytes(n uint64) {
+	type T []byte
+	var c = make(T, 8)
+	shouldPanic("len out of range", func() { x := make(T, int(n)); copy(x, c) })
+	shouldPanic("cap out of range", func() { x := make(T, 0, int(n)); copy(x, c) })
+	shouldPanic("len out of range", func() { x := make(T, uint(n)); copy(x, c) })
+	shouldPanic("cap out of range", func() { x := make(T, 0, uint(n)); copy(x, c) })
+	shouldPanic("len out of range", func() { x := make(T, int64(n)); copy(x, c) })
+	shouldPanic("cap out of range", func() { x := make(T, 0, int64(n)); copy(x, c) })
+	shouldPanic("len out of range", func() { x := make(T, uint64(n)); copy(x, c) })
+	shouldPanic("cap out of range", func() { x := make(T, 0, uint64(n)); copy(x, c) })
+}
+
+// Test make in append panics for int slices since the gc compiler optimizes makes in appends.
+func testMakeInAppendInts(n uint64) {
+	type T []int
+	for _, length := range []int{0, 1} {
+		t := make(T, length)
+		shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) })
+		shouldPanic("len out of range", func() { _ = append(t, make(T, int64(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int64(n))...) })
+		shouldPanic("len out of range", func() { _ = append(t, make(T, uint64(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint64(n))...) })
+		shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) })
+		shouldPanic("len out of range", func() { _ = append(t, make(T, uint(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint(n))...) })
+	}
+}
+
+func testMakeInAppendBytes(n uint64) {
+	type T []byte
+	for _, length := range []int{0, 1} {
+		t := make(T, length)
+		shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) })
+		shouldPanic("len out of range", func() { _ = append(t, make(T, uint(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint(n))...) })
+		shouldPanic("len out of range", func() { _ = append(t, make(T, int64(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int64(n))...) })
+		shouldPanic("len out of range", func() { _ = append(t, make(T, uint64(n))...) })
+		shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint64(n))...) })
+	}
+}