cmd/compile: clean up codegen for branch-on-carry on s390x

This CL optimizes code that uses a carry from a function such as
bits.Add64 as the condition in an if statement. For example:

    x, c := bits.Add64(a, b, 0)
    if c != 0 {
        panic("overflow")
    }

Rather than converting the carry into a 0 or a 1 value and using
that as an input to a comparison instruction the carry flag is now
used as the input to a conditional branch directly. This typically
removes an ADD LOGICAL WITH CARRY instruction when user code is
doing overflow detection and is closer to the code that a user
would expect to generate.

Change-Id: I950431270955ab72f1b5c6db873b6abe769be0da
Reviewed-on: https://go-review.googlesource.com/c/go/+/219757
Run-TryBot: Michael Munday <mike.munday@ibm.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

1 files changed, 124 insertions, 0 deletions

diff --git a/src/math/bits/bits_test.go b/src/math/bits/bits_test.go
index c0f43093d9..23b4539fcd 100644
--- a/src/math/bits/bits_test.go
+++ b/src/math/bits/bits_test.go
@@ -806,6 +806,130 @@ func TestAddSubUint64(t *testing.T) {
 	}
 }
 
+func TestAdd64OverflowPanic(t *testing.T) {
+	// Test that 64-bit overflow panics fire correctly.
+	// These are designed to improve coverage of compiler intrinsics.
+	tests := []func(uint64, uint64) uint64{
+		func(a, b uint64) uint64 {
+			x, c := Add64(a, b, 0)
+			if c > 0 {
+				panic("overflow")
+			}
+			return x
+		},
+		func(a, b uint64) uint64 {
+			x, c := Add64(a, b, 0)
+			if c != 0 {
+				panic("overflow")
+			}
+			return x
+		},
+		func(a, b uint64) uint64 {
+			x, c := Add64(a, b, 0)
+			if c == 1 {
+				panic("overflow")
+			}
+			return x
+		},
+		func(a, b uint64) uint64 {
+			x, c := Add64(a, b, 0)
+			if c != 1 {
+				return x
+			}
+			panic("overflow")
+		},
+		func(a, b uint64) uint64 {
+			x, c := Add64(a, b, 0)
+			if c == 0 {
+				return x
+			}
+			panic("overflow")
+		},
+	}
+	for _, test := range tests {
+		shouldPanic := func(f func()) {
+			defer func() {
+				if err := recover(); err == nil {
+					t.Fatalf("expected panic")
+				}
+			}()
+			f()
+		}
+
+		// overflow
+		shouldPanic(func() { test(_M64, 1) })
+		shouldPanic(func() { test(1, _M64) })
+		shouldPanic(func() { test(_M64, _M64) })
+
+		// no overflow
+		test(_M64, 0)
+		test(0, 0)
+		test(1, 1)
+	}
+}
+
+func TestSub64OverflowPanic(t *testing.T) {
+	// Test that 64-bit overflow panics fire correctly.
+	// These are designed to improve coverage of compiler intrinsics.
+	tests := []func(uint64, uint64) uint64{
+		func(a, b uint64) uint64 {
+			x, c := Sub64(a, b, 0)
+			if c > 0 {
+				panic("overflow")
+			}
+			return x
+		},
+		func(a, b uint64) uint64 {
+			x, c := Sub64(a, b, 0)
+			if c != 0 {
+				panic("overflow")
+			}
+			return x
+		},
+		func(a, b uint64) uint64 {
+			x, c := Sub64(a, b, 0)
+			if c == 1 {
+				panic("overflow")
+			}
+			return x
+		},
+		func(a, b uint64) uint64 {
+			x, c := Sub64(a, b, 0)
+			if c != 1 {
+				return x
+			}
+			panic("overflow")
+		},
+		func(a, b uint64) uint64 {
+			x, c := Sub64(a, b, 0)
+			if c == 0 {
+				return x
+			}
+			panic("overflow")
+		},
+	}
+	for _, test := range tests {
+		shouldPanic := func(f func()) {
+			defer func() {
+				if err := recover(); err == nil {
+					t.Fatalf("expected panic")
+				}
+			}()
+			f()
+		}
+
+		// overflow
+		shouldPanic(func() { test(0, 1) })
+		shouldPanic(func() { test(1, _M64) })
+		shouldPanic(func() { test(_M64-1, _M64) })
+
+		// no overflow
+		test(_M64, 0)
+		test(0, 0)
+		test(1, 1)
+	}
+}
+
 func TestMulDiv(t *testing.T) {
 	testMul := func(msg string, f func(x, y uint) (hi, lo uint), x, y, hi, lo uint) {
 		hi1, lo1 := f(x, y)