test/codegen: combine trivial PPC64 tests into ppc64x

Use a small python script to consolidate duplicate
ppc64/ppc64le tests into a single ppc64x codegen test.

This makes small assumption that anytime two tests with
for different arch/variant combos exists, those tests
can be combined into a single ppc64x test.

E.x:

  // ppc64le: foo
  // ppc64le/power9: foo
into
  // ppc64x: foo

or

  // ppc64: foo
  // ppc64le: foo
into
  // ppc64x: foo

import glob
import re
files = glob.glob("codegen/*.go")
for file in files:
    with open(file) as f:
        text = [l for l in f]
    i = 0
    while i < len(text):
        first = re.match("\s*// ?ppc64(le)?(/power[89])?:(.*)", text[i])
        if first:
            j = i+1
            while j < len(text):
                second = re.match("\s*// ?ppc64(le)?(/power[89])?:(.*)", text[j])
                if not second:
                    break
                if (not first.group(2) or first.group(2) == second.group(2)) and first.group(3) == second.group(3):
                    text[i] = re.sub(" ?ppc64(le|x)?"," ppc64x",text[i])
                    text=text[:j] + (text[j+1:])
                else:
                    j += 1
        i+=1
    with open(file, 'w') as f:
        f.write("".join(text))

Change-Id: Ic6b009b54eacaadc5a23db9c5a3bf7331b595821
Reviewed-on: https://go-review.googlesource.com/c/go/+/463220
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Bryan Mills <bcmills@google.com>
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Gopher Robot <gobot@golang.org>

1 files changed, 49 insertions, 98 deletions

diff --git a/test/codegen/shift.go b/test/codegen/shift.go
index 4a9f5d4356..2b136361d5 100644
--- a/test/codegen/shift.go
+++ b/test/codegen/shift.go
@@ -11,64 +11,55 @@ package codegen
 // ------------------ //
 
 func lshConst64x64(v int64) int64 {
-	// ppc64:"SLD"
-	// ppc64le:"SLD"
+	// ppc64x:"SLD"
 	// riscv64:"SLLI",-"AND",-"SLTIU"
 	return v << uint64(33)
 }
 
 func rshConst64Ux64(v uint64) uint64 {
-	// ppc64:"SRD"
-	// ppc64le:"SRD"
+	// ppc64x:"SRD"
 	// riscv64:"SRLI",-"AND",-"SLTIU"
 	return v >> uint64(33)
 }
 
 func rshConst64x64(v int64) int64 {
-	// ppc64:"SRAD"
-	// ppc64le:"SRAD"
+	// ppc64x:"SRAD"
 	// riscv64:"SRAI",-"OR",-"SLTIU"
 	return v >> uint64(33)
 }
 
 func lshConst32x64(v int32) int32 {
-	// ppc64:"SLW"
-	// ppc64le:"SLW"
+	// ppc64x:"SLW"
 	// riscv64:"SLLI",-"AND",-"SLTIU", -"MOVW"
 	return v << uint64(29)
 }
 
 func rshConst32Ux64(v uint32) uint32 {
-	// ppc64:"SRW"
-	// ppc64le:"SRW"
+	// ppc64x:"SRW"
 	// riscv64:"SRLI",-"AND",-"SLTIU", -"MOVW"
 	return v >> uint64(29)
 }
 
 func rshConst32x64(v int32) int32 {
-	// ppc64:"SRAW"
-	// ppc64le:"SRAW"
+	// ppc64x:"SRAW"
 	// riscv64:"SRAI",-"OR",-"SLTIU", -"MOVW"
 	return v >> uint64(29)
 }
 
 func lshConst64x32(v int64) int64 {
-	// ppc64:"SLD"
-	// ppc64le:"SLD"
+	// ppc64x:"SLD"
 	// riscv64:"SLLI",-"AND",-"SLTIU"
 	return v << uint32(33)
 }
 
 func rshConst64Ux32(v uint64) uint64 {
-	// ppc64:"SRD"
-	// ppc64le:"SRD"
+	// ppc64x:"SRD"
 	// riscv64:"SRLI",-"AND",-"SLTIU"
 	return v >> uint32(33)
 }
 
 func rshConst64x32(v int64) int64 {
-	// ppc64:"SRAD"
-	// ppc64le:"SRAD"
+	// ppc64x:"SRAD"
 	// riscv64:"SRAI",-"OR",-"SLTIU"
 	return v >> uint32(33)
 }
@@ -79,8 +70,7 @@ func rshConst64x32(v int64) int64 {
 
 func lshMask64x64(v int64, s uint64) int64 {
 	// arm64:"LSL",-"AND"
-	// ppc64:"ANDCC",-"ORN",-"ISEL"
-	// ppc64le:"ANDCC",-"ORN",-"ISEL"
+	// ppc64x:"ANDCC",-"ORN",-"ISEL"
 	// riscv64:"SLL",-"AND\t",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v << (s & 63)
@@ -88,8 +78,7 @@ func lshMask64x64(v int64, s uint64) int64 {
 
 func rshMask64Ux64(v uint64, s uint64) uint64 {
 	// arm64:"LSR",-"AND",-"CSEL"
-	// ppc64:"ANDCC",-"ORN",-"ISEL"
-	// ppc64le:"ANDCC",-"ORN",-"ISEL"
+	// ppc64x:"ANDCC",-"ORN",-"ISEL"
 	// riscv64:"SRL",-"AND\t",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v >> (s & 63)
@@ -106,8 +95,7 @@ func rshMask64x64(v int64, s uint64) int64 {
 
 func lshMask32x64(v int32, s uint64) int32 {
 	// arm64:"LSL",-"AND"
-	// ppc64:"ISEL",-"ORN"
-	// ppc64le:"ISEL",-"ORN"
+	// ppc64x:"ISEL",-"ORN"
 	// riscv64:"SLL",-"AND\t",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v << (s & 63)
@@ -115,8 +103,7 @@ func lshMask32x64(v int32, s uint64) int32 {
 
 func rshMask32Ux64(v uint32, s uint64) uint32 {
 	// arm64:"LSR",-"AND"
-	// ppc64:"ISEL",-"ORN"
-	// ppc64le:"ISEL",-"ORN"
+	// ppc64x:"ISEL",-"ORN"
 	// riscv64:"SRL",-"AND\t",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v >> (s & 63)
@@ -124,8 +111,7 @@ func rshMask32Ux64(v uint32, s uint64) uint32 {
 
 func rshMask32x64(v int32, s uint64) int32 {
 	// arm64:"ASR",-"AND"
-	// ppc64:"ISEL",-"ORN"
-	// ppc64le:"ISEL",-"ORN"
+	// ppc64x:"ISEL",-"ORN"
 	// riscv64:"SRA",-"OR",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v >> (s & 63)
@@ -133,8 +119,7 @@ func rshMask32x64(v int32, s uint64) int32 {
 
 func lshMask64x32(v int64, s uint32) int64 {
 	// arm64:"LSL",-"AND"
-	// ppc64:"ANDCC",-"ORN"
-	// ppc64le:"ANDCC",-"ORN"
+	// ppc64x:"ANDCC",-"ORN"
 	// riscv64:"SLL",-"AND\t",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v << (s & 63)
@@ -142,8 +127,7 @@ func lshMask64x32(v int64, s uint32) int64 {
 
 func rshMask64Ux32(v uint64, s uint32) uint64 {
 	// arm64:"LSR",-"AND",-"CSEL"
-	// ppc64:"ANDCC",-"ORN"
-	// ppc64le:"ANDCC",-"ORN"
+	// ppc64x:"ANDCC",-"ORN"
 	// riscv64:"SRL",-"AND\t",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v >> (s & 63)
@@ -151,32 +135,28 @@ func rshMask64Ux32(v uint64, s uint32) uint64 {
 
 func rshMask64x32(v int64, s uint32) int64 {
 	// arm64:"ASR",-"AND",-"CSEL"
-	// ppc64:"ANDCC",-"ORN",-"ISEL"
-	// ppc64le:"ANDCC",-"ORN",-"ISEL"
+	// ppc64x:"ANDCC",-"ORN",-"ISEL"
 	// riscv64:"SRA",-"OR",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v >> (s & 63)
 }
 
 func lshMask64x32Ext(v int64, s int32) int64 {
-	// ppc64:"ANDCC",-"ORN",-"ISEL"
-	// ppc64le:"ANDCC",-"ORN",-"ISEL"
+	// ppc64x:"ANDCC",-"ORN",-"ISEL"
 	// riscv64:"SLL",-"AND\t",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v << uint(s&63)
 }
 
 func rshMask64Ux32Ext(v uint64, s int32) uint64 {
-	// ppc64:"ANDCC",-"ORN",-"ISEL"
-	// ppc64le:"ANDCC",-"ORN",-"ISEL"
+	// ppc64x:"ANDCC",-"ORN",-"ISEL"
 	// riscv64:"SRL",-"AND\t",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v >> uint(s&63)
 }
 
 func rshMask64x32Ext(v int64, s int32) int64 {
-	// ppc64:"ANDCC",-"ORN",-"ISEL"
-	// ppc64le:"ANDCC",-"ORN",-"ISEL"
+	// ppc64x:"ANDCC",-"ORN",-"ISEL"
 	// riscv64:"SRA",-"OR",-"SLTIU"
 	// s390x:-"RISBGZ",-"AND",-"LOCGR"
 	return v >> uint(s&63)
@@ -329,61 +309,44 @@ func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, sh
 
 func checkUnneededTrunc(tab *[100000]uint32, d uint64, v uint32, h uint16, b byte) (uint32, uint64) {
 
-	// ppc64le:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
-	// ppc64:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
+	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
 	f := tab[byte(v)^b]
-	// ppc64le:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
-	// ppc64:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
+	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
 	f += tab[byte(v)&b]
-	// ppc64le:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
-	// ppc64:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
+	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
 	f += tab[byte(v)|b]
-	// ppc64le:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
-	// ppc64:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
+	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
 	f += tab[uint16(v)&h]
-	// ppc64le:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
-	// ppc64:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
+	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
 	f += tab[uint16(v)^h]
-	// ppc64le:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
-	// ppc64:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
+	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
 	f += tab[uint16(v)|h]
-	// ppc64le:-".*AND",-"RLDICR",".*CLRLSLDI"
-	// ppc64:-".*AND",-"RLDICR",".*CLRLSLDI"
+	// ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI"
 	f += tab[v&0xff]
-	// ppc64le:-".*AND",".*CLRLSLWI"
-	// ppc64:-".*AND",".*CLRLSLWI"
+	// ppc64x:-".*AND",".*CLRLSLWI"
 	f += 2 * uint32(uint16(d))
-	// ppc64le:-".*AND",-"RLDICR",".*CLRLSLDI"
-	// ppc64:-".*AND",-"RLDICR",".*CLRLSLDI"
+	// ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI"
 	g := 2 * uint64(uint32(d))
 	return f, g
 }
 
 func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64) (uint8, uint16, uint32, uint64, int64) {
 
-	// ppc64le:-"AND","CLRLSLWI"
-	// ppc64:-"AND","CLRLSLWI"
+	// ppc64x:-"AND","CLRLSLWI"
 	f := (v8 & 0xF) << 2
-	// ppc64le:"CLRLSLWI"
-	// ppc64:"CLRLSLWI"
+	// ppc64x:"CLRLSLWI"
 	f += byte(v16) << 3
-	// ppc64le:-"AND","CLRLSLWI"
-	// ppc64:-"AND","CLRLSLWI"
+	// ppc64x:-"AND","CLRLSLWI"
 	g := (v16 & 0xFF) << 3
-	// ppc64le:-"AND","CLRLSLWI"
-	// ppc64:-"AND","CLRLSLWI"
+	// ppc64x:-"AND","CLRLSLWI"
 	h := (v32 & 0xFFFFF) << 2
-	// ppc64le:"CLRLSLDI"
-	// ppc64:"CLRLSLDI"
+	// ppc64x:"CLRLSLDI"
 	i := (v64 & 0xFFFFFFFF) << 5
-	// ppc64le:-"CLRLSLDI"
-	// ppc64:-"CLRLSLDI"
+	// ppc64x:-"CLRLSLDI"
 	i += (v64 & 0xFFFFFFF) << 38
-	// ppc64le/power9:-"CLRLSLDI"
-	// ppc64/power9:-"CLRLSLDI"
+	// ppc64x/power9:-"CLRLSLDI"
 	i += (v64 & 0xFFFF00) << 10
-	// ppc64le/power9:-"SLD","EXTSWSLI"
-	// ppc64/power9:-"SLD","EXTSWSLI"
+	// ppc64x/power9:-"SLD","EXTSWSLI"
 	j := int64(x32+32) * 8
 	return f, g, h, i, j
 }
@@ -414,52 +377,40 @@ func checkWidenAfterShift(v int64, u uint64) (int64, uint64) {
 func checkShiftAndMask32(v []uint32) {
 	i := 0
 
-	// ppc64le: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
-	// ppc64: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
+	// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
 	v[i] = (v[i] & 0xFF00000) >> 8
 	i++
-	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
-	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
+	// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
 	v[i] = (v[i] & 0xFF00) >> 6
 	i++
-	// ppc64le: "MOVW\tR0"
-	// ppc64: "MOVW\tR0"
+	// ppc64x: "MOVW\tR0"
 	v[i] = (v[i] & 0xFF) >> 8
 	i++
-	// ppc64le: "MOVW\tR0"
-	// ppc64: "MOVW\tR0"
+	// ppc64x: "MOVW\tR0"
 	v[i] = (v[i] & 0xF000000) >> 28
 	i++
-	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
-	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
+	// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
 	v[i] = (v[i] >> 6) & 0xFF
 	i++
-	// ppc64le: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
-	// ppc64: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
+	// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
 	v[i] = (v[i] >> 6) & 0xFF000
 	i++
-	// ppc64le: "MOVW\tR0"
-	// ppc64: "MOVW\tR0"
+	// ppc64x: "MOVW\tR0"
 	v[i] = (v[i] >> 20) & 0xFF000
 	i++
-	// ppc64le: "MOVW\tR0"
-	// ppc64: "MOVW\tR0"
+	// ppc64x: "MOVW\tR0"
 	v[i] = (v[i] >> 24) & 0xFF00
 	i++
 }
 
 func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) {
-	// ppc64le: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
-	// ppc64: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
+	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
 	a[0] = a[uint8(v>>24)]
-	// ppc64le: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
-	// ppc64: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
+	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
 	b[0] = b[uint8(v>>24)]
-	// ppc64le: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
-	// ppc64: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
+	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
 	b[1] = b[(v>>20)&0xFF]
-	// ppc64le: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
-	// ppc64: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
+	// ppc64x: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
 	b[2] = b[v>>25]
 }