test/codegen: updated arithmetic tests to verify on ppc64,ppc64le

Updated multiple tests in test/codegen/arithmetic.go to verify
on ppc64/ppc64le as well

Change-Id: I79ca9f87017ea31147a4ba16f5d42ba0fcae64e1
Reviewed-on: https://go-review.googlesource.com/c/go/+/358546
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>

diff --git a/test/codegen/arithmetic.go b/test/codegen/arithmetic.go
index 8b8c8ed64b0c813e6515ecc141a350855fdeaa65..00841d52ae27db5c9be6f59fefd9512103c26e8e 100644 (file)
--- a/test/codegen/arithmetic.go
+++ b/test/codegen/arithmetic.go
@@ -86,24 +86,32 @@ func NegAddFromConstNeg(a int) int {
 
 func SubSubNegSimplify(a, b int) int {
        // amd64:"NEGQ"
+       // ppc64:"NEG"
+       // ppc64le:"NEG"
        r := (a - b) - a
        return r
 }
 
 func SubAddSimplify(a, b int) int {
        // amd64:-"SUBQ",-"ADDQ"
+       // ppc64:-"SUB",-"ADD"
+       // ppc64le:-"SUB",-"ADD"
        r := a + (b - a)
        return r
 }
 
 func SubAddNegSimplify(a, b int) int {
        // amd64:"NEGQ",-"ADDQ",-"SUBQ"
+       // ppc64:"NEG",-"ADD",-"SUB"
+       // ppc64le:"NEG",-"ADD",-"SUB"
        r := a - (b + a)
        return r
 }
 
 func AddAddSubSimplify(a, b, c int) int {
        // amd64:-"SUBQ"
+       // ppc64:-"SUB"
+       // ppc64le:-"SUB"
        r := a + (b + (c - a))
        return r
 }
@@ -159,30 +167,40 @@ func MulMemSrc(a []uint32, b []float32) {
 func MergeMuls1(n int) int {
        // amd64:"IMUL3Q\t[$]46"
        // 386:"IMUL3L\t[$]46"
+       // ppc64le:"MULLD\t[$]46"
+       // ppc64:"MULLD\t[$]46"
        return 15*n + 31*n // 46n
 }
 
 func MergeMuls2(n int) int {
        // amd64:"IMUL3Q\t[$]23","(ADDQ\t[$]29)|(LEAQ\t29)"
        // 386:"IMUL3L\t[$]23","ADDL\t[$]29"
+       // ppc64le/power9:"MADDLD",-"MULLD\t[$]23",-"ADD\t[$]29"
+        // ppc64le/power8:"MULLD\t[$]23","ADD\t[$]29"
        return 5*n + 7*(n+1) + 11*(n+2) // 23n + 29
 }
 
 func MergeMuls3(a, n int) int {
        // amd64:"ADDQ\t[$]19",-"IMULQ\t[$]19"
        // 386:"ADDL\t[$]19",-"IMULL\t[$]19"
+       // ppc64:"ADD\t[$]19",-"MULLD\t[$]19"
+       // ppc64le:"ADD\t[$]19",-"MULLD\t[$]19"
        return a*n + 19*n // (a+19)n
 }
 
 func MergeMuls4(n int) int {
        // amd64:"IMUL3Q\t[$]14"
        // 386:"IMUL3L\t[$]14"
+       // ppc64:"MULLD\t[$]14"
+       // ppc64le:"MULLD\t[$]14"
        return 23*n - 9*n // 14n
 }
 
 func MergeMuls5(a, n int) int {
        // amd64:"ADDQ\t[$]-19",-"IMULQ\t[$]19"
        // 386:"ADDL\t[$]-19",-"IMULL\t[$]19"
+       // ppc64:"ADD\t[$]-19",-"MULLD\t[$]19"
+       // ppc64le:"ADD\t[$]-19",-"MULLD\t[$]19"
        return a*n - 19*n // (a-19)n
 }
 
@@ -507,6 +525,8 @@ func MULA(a, b, c uint32) (uint32, uint32, uint32) {
        r1 := c*79 + a
        // arm:`ADD`,-`MULA`,-`MUL\s`
        // arm64:`ADD`,-`MADD`,-`MULW`
+       // ppc64:`ADD`,-`MULLD`
+       // ppc64le:`ADD`,-`MULLD`
        r2 := b*64 + c
        return r0, r1, r2
 }
@@ -522,6 +542,8 @@ func MULS(a, b, c uint32) (uint32, uint32, uint32) {
        r1 := a - c*79
        // arm/7:`SUB`,-`MULS`,-`MUL\s`
        // arm64:`SUB`,-`MSUBW`,-`MULW`
+       // ppc64:`SUB`,-`MULLD`
+       // ppc64le:`SUB`,-`MULLD`
        r2 := c - b*64
        return r0, r1, r2
 }
@@ -550,12 +572,20 @@ func divInt(v int64) int64 {
 // "(z + C) -x -> C + (z - x)" can optimize the following cases.
 func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
        // arm64:"SUB","ADD\t[$]2"
+        // ppc64:"SUB","ADD\t[$]2"
+        // ppc64le:"SUB","ADD\t[$]2"
        r0 := (i0 + 3) - (j0 + 1)
        // arm64:"SUB","SUB\t[$]4"
+        // ppc64:"SUB","ADD\t[$]-4"
+        // ppc64le:"SUB","ADD\t[$]-4"
        r1 := (i1 - 3) - (j1 + 1)
        // arm64:"SUB","ADD\t[$]4"
+        // ppc64:"SUB","ADD\t[$]4"
+        // ppc64le:"SUB","ADD\t[$]4"
        r2 := (i2 + 3) - (j2 - 1)
        // arm64:"SUB","SUB\t[$]2"
+       // ppc64:"SUB","ADD\t[$]-2"
+       // ppc64le:"SUB","ADD\t[$]-2"
        r3 := (i3 - 3) - (j3 - 1)
        return r0, r1, r2, r3
 }
@@ -564,14 +594,20 @@ func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
 // "(C - z) - x -> C - (z + x)" can optimize the following cases.
 func constantFold2(i0, j0, i1, j1 int) (int, int) {
        // arm64:"ADD","MOVD\t[$]2","SUB"
+       // ppc64le: `SUBC\tR[0-9]+,\s[$]2,\sR`
+       // ppc64: `SUBC\tR[0-9]+,\s[$]2,\sR`
        r0 := (3 - i0) - (j0 + 1)
        // arm64:"ADD","MOVD\t[$]4","SUB"
+       // ppc64le: `SUBC\tR[0-9]+,\s[$]4,\sR`
+       // ppc64: `SUBC\tR[0-9]+,\s[$]4,\sR`
        r1 := (3 - i1) - (j1 - 1)
        return r0, r1
 }
 
 func constantFold3(i, j int) int {
        // arm64: "MOVD\t[$]30","MUL",-"ADD",-"LSL"
+        // ppc64:"MULLD\t[$]30","MULLD"
+        // ppc64le:"MULLD\t[$]30","MULLD"
        r := (5 * i) * (6 * j)
        return r
 }