From: Archana R <aravind5@in.ibm.com>
Date: Tue, 26 Oct 2021 04:57:46 +0000 (-0500)
Subject: test/codegen: updated arithmetic tests to verify on ppc64,ppc64le
X-Git-Tag: go1.18beta1~648
X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=4056934e483c51fa046f9c2d1ee35f0385b84d91;p=gostls13.git

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 8b8c8ed64b..00841d52ae 100644
--- 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
 }