test: add memcombine testcases for ppc64

Thanks to the recent addition of the memcombine pass, the
ppc64 ports now have the memcombine optimizations. Previously
in PPC64.rules, the memcombine rules were only added for
ppc64le targets due to the significant increase in size of
the rewritePPC64.go file when those rules were added. The
ppc64 and ppc64le rules had to be different because of the
byte order due to endianness differences.

This enables the memcombine tests to be run on ppc64 as well
as ppc64le.

Change-Id: I4081e2d94617a1b66541d536c0c2662e266c9c1e
Reviewed-on: https://go-review.googlesource.com/c/go/+/492615
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@google.com>
Auto-Submit: Lynn Boger <laboger@linux.vnet.ibm.com>

diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go
index 8143b6bed5beac7d2bfc2431fd14754625b8975d..c7a2c7e5ace04ea22f976195e22793a85752a3c1 100644 (file)
--- a/test/codegen/memcombine.go
+++ b/test/codegen/memcombine.go
@@ -20,6 +20,7 @@ func load_le64(b []byte) uint64 {
        // s390x:`MOVDBR\s\(.*\),`
        // arm64:`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`
        // ppc64le:`MOVD\s`,-`MOV[BHW]Z`
+       // ppc64:`MOVDBR\s`,-`MOV[BHW]Z`
        return binary.LittleEndian.Uint64(b)
 }
 
@@ -28,6 +29,7 @@ func load_le64_idx(b []byte, idx int) uint64 {
        // s390x:`MOVDBR\s\(.*\)\(.*\*1\),`
        // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]`
        // ppc64le:`MOVD\s`,-`MOV[BHW]Z\s`
+       // ppc64:`MOVDBR\s`,-`MOV[BHW]Z\s`
        return binary.LittleEndian.Uint64(b[idx:])
 }
 
@@ -37,6 +39,7 @@ func load_le32(b []byte) uint32 {
        // s390x:`MOVWBR\s\(.*\),`
        // arm64:`MOVWU\s\(R[0-9]+\),`,-`MOV[BH]`
        // ppc64le:`MOVWZ\s`,-`MOV[BH]Z\s`
+       // ppc64:`MOVWBR\s`,-`MOV[BH]Z\s`
        return binary.LittleEndian.Uint32(b)
 }
 
@@ -46,6 +49,7 @@ func load_le32_idx(b []byte, idx int) uint32 {
        // s390x:`MOVWBR\s\(.*\)\(.*\*1\),`
        // arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BH]`
        // ppc64le:`MOVWZ\s`,-`MOV[BH]Z\s`
+       // ppc64:`MOVWBR\s`,-`MOV[BH]Z\s'
        return binary.LittleEndian.Uint32(b[idx:])
 }
 
@@ -54,12 +58,14 @@ func load_le16(b []byte) uint16 {
        // ppc64le:`MOVHZ\s`,-`MOVBZ`
        // arm64:`MOVHU\s\(R[0-9]+\),`,-`MOVB`
        // s390x:`MOVHBR\s\(.*\),`
+       // ppc64:`MOVHBR\s`,-`MOVBZ`
        return binary.LittleEndian.Uint16(b)
 }
 
 func load_le16_idx(b []byte, idx int) uint16 {
        // amd64:`MOVWLZX\s\(.*\),`,-`MOVB`,-`OR`
        // ppc64le:`MOVHZ\s`,-`MOVBZ`
+       // ppc64:`MOVHBR\s`,-`MOVBZ`
        // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOVB`
        // s390x:`MOVHBR\s\(.*\)\(.*\*1\),`
        return binary.LittleEndian.Uint16(b[idx:])
@@ -71,6 +77,7 @@ func load_be64(b []byte) uint64 {
        // s390x:`MOVD\s\(.*\),`
        // arm64:`REV`,`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W`
        // ppc64le:`MOVDBR`,-`MOV[BHW]Z`
+       // ppc64:`MOVD`,-`MOV[BHW]Z`
        return binary.BigEndian.Uint64(b)
 }
 
@@ -80,6 +87,7 @@ func load_be64_idx(b []byte, idx int) uint64 {
        // s390x:`MOVD\s\(.*\)\(.*\*1\),`
        // arm64:`REV`,`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[WHB]`,-`REVW`,-`REV16W`
        // ppc64le:`MOVDBR`,-`MOV[BHW]Z`
+       // ppc64:`MOVD`,-`MOV[BHW]Z`
        return binary.BigEndian.Uint64(b[idx:])
 }
 
@@ -89,6 +97,7 @@ func load_be32(b []byte) uint32 {
        // s390x:`MOVWZ\s\(.*\),`
        // arm64:`REVW`,`MOVWU\s\(R[0-9]+\),`,-`MOV[BH]`,-`REV16W`
        // ppc64le:`MOVWBR`,-`MOV[BH]Z`
+       // ppc64:`MOVWZ`,-MOV[BH]Z`
        return binary.BigEndian.Uint32(b)
 }
 
@@ -98,13 +107,15 @@ func load_be32_idx(b []byte, idx int) uint32 {
        // s390x:`MOVWZ\s\(.*\)\(.*\*1\),`
        // arm64:`REVW`,`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[HB]`,-`REV16W`
        // ppc64le:`MOVWBR`,-`MOV[BH]Z`
+       // ppc64:`MOVWZ`,-MOV[BH]Z`
        return binary.BigEndian.Uint32(b[idx:])
 }
 
 func load_be16(b []byte) uint16 {
        // amd64:`ROLW\s\$8`,-`MOVB`,-`OR`
        // arm64:`REV16W`,`MOVHU\s\(R[0-9]+\),`,-`MOVB`
-       // ppc64le:`MOVHBR`
+       // ppc64le:`MOVHBR`,-`MOVBZ`
+       // ppc64:`MOVHZ`,-`MOVBZ`
        // s390x:`MOVHZ\s\(.*\),`,-`OR`,-`ORW`,-`SLD`,-`SLW`
        return binary.BigEndian.Uint16(b)
 }
@@ -112,7 +123,8 @@ func load_be16(b []byte) uint16 {
 func load_be16_idx(b []byte, idx int) uint16 {
        // amd64:`ROLW\s\$8`,-`MOVB`,-`OR`
        // arm64:`REV16W`,`MOVHU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOVB`
-       // ppc64le:`MOVHBR`
+       // ppc64le:`MOVHBR`,-`MOVBZ`
+       // ppc64:`MOVHZ`,-`MOVBZ`
        // s390x:`MOVHZ\s\(.*\)\(.*\*1\),`,-`OR`,-`ORW`,-`SLD`,-`SLW`
        return binary.BigEndian.Uint16(b[idx:])
 }
@@ -122,6 +134,7 @@ func load_le_byte2_uint16(s []byte) uint16 {
        // 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
        // amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
        // ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVBZ`
+       // ppc64:`MOVHBR`,-`MOVBZ`
        return uint16(s[0]) | uint16(s[1])<<8
 }
 
@@ -129,7 +142,8 @@ func load_le_byte2_uint16_inv(s []byte) uint16 {
        // arm64:`MOVHU\t\(R[0-9]+\)`,-`ORR`,-`MOVB`
        // 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
        // amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
-       // ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVDZ`
+       // ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVBZ`
+       // ppc64:`MOVHBR`,-`MOVBZ`
        return uint16(s[1])<<8 | uint16(s[0])
 }
 
@@ -138,11 +152,14 @@ func load_le_byte4_uint32(s []byte) uint32 {
        // 386:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR`
        // amd64:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR`
        // ppc64le:`MOVWZ\t\(R[0-9]+\)`,-`MOV[BH]Z`
+       // ppc64:`MOVWBR`,-MOV[BH]Z`
        return uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 | uint32(s[3])<<24
 }
 
 func load_le_byte4_uint32_inv(s []byte) uint32 {
        // arm64:`MOVWU\t\(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
+       // ppc64le:`MOVWZ`,-`MOV[BH]Z`
+       // ppc64:`MOVWBR`,-`MOV[BH]Z`
        return uint32(s[3])<<24 | uint32(s[2])<<16 | uint32(s[1])<<8 | uint32(s[0])
 }
 
@@ -150,11 +167,14 @@ func load_le_byte8_uint64(s []byte) uint64 {
        // arm64:`MOVD\t\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
        // amd64:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,-`MOV[BWL]\t[^$]`,-`OR`
        // ppc64le:`MOVD\t\(R[0-9]+\)`,-`MOV[BHW]Z`
+       // ppc64:`MOVDBR`,-`MOVW[WHB]Z`
        return uint64(s[0]) | uint64(s[1])<<8 | uint64(s[2])<<16 | uint64(s[3])<<24 | uint64(s[4])<<32 | uint64(s[5])<<40 | uint64(s[6])<<48 | uint64(s[7])<<56
 }
 
 func load_le_byte8_uint64_inv(s []byte) uint64 {
        // arm64:`MOVD\t\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
+       // ppc64le:`MOVD`,-`MOV[WHB]Z`
+       // ppc64:`MOVDBR`,-`MOV[WHB]Z`
        return uint64(s[7])<<56 | uint64(s[6])<<48 | uint64(s[5])<<40 | uint64(s[4])<<32 | uint64(s[3])<<24 | uint64(s[2])<<16 | uint64(s[1])<<8 | uint64(s[0])
 }
 
@@ -162,6 +182,7 @@ func load_be_byte2_uint16(s []byte) uint16 {
        // arm64:`MOVHU\t\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
        // amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR`
        // ppc64le:`MOVHBR\t\(R[0-9]+\)`,-`MOVBZ`
+       // ppc64:`MOVHZ`,-`MOVBZ`
        return uint16(s[0])<<8 | uint16(s[1])
 }
 
@@ -169,11 +190,14 @@ func load_be_byte2_uint16_inv(s []byte) uint16 {
        // arm64:`MOVHU\t\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
        // amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR`
        // ppc64le:`MOVHBR\t\(R[0-9]+\)`,-`MOVBZ`
+       // ppc64:`MOVHZ`,-`MOVBZ`
        return uint16(s[1]) | uint16(s[0])<<8
 }
 
 func load_be_byte4_uint32(s []byte) uint32 {
        // arm64:`MOVWU\t\(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
+       // ppc64le:`MOVWBR`,-`MOV[HB]Z`
+       // ppc64:`MOVWZ`,-`MOV[HB]Z`
        return uint32(s[0])<<24 | uint32(s[1])<<16 | uint32(s[2])<<8 | uint32(s[3])
 }
 
@@ -181,12 +205,15 @@ func load_be_byte4_uint32_inv(s []byte) uint32 {
        // arm64:`MOVWU\t\(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
        // amd64/v1,amd64/v2:`MOVL\s\([A-Z]+\)`,`BSWAPL`,-`MOV[BW]`,-`OR`
        // amd64/v3: `MOVBEL`
+       // ppc64le:`MOVWBR`,-`MOV[HB]Z`
+       // ppc64:`MOVWZ`,-`MOV[HB]Z`
        return uint32(s[3]) | uint32(s[2])<<8 | uint32(s[1])<<16 | uint32(s[0])<<24
 }
 
 func load_be_byte8_uint64(s []byte) uint64 {
        // arm64:`MOVD\t\(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
        // ppc64le:`MOVDBR\t\(R[0-9]+\)`,-`MOV[BHW]Z`
+       // ppc64:`MOVD`,-`MOV[WHB]Z`
        return uint64(s[0])<<56 | uint64(s[1])<<48 | uint64(s[2])<<40 | uint64(s[3])<<32 | uint64(s[4])<<24 | uint64(s[5])<<16 | uint64(s[6])<<8 | uint64(s[7])
 }
 
@@ -195,6 +222,7 @@ func load_be_byte8_uint64_inv(s []byte) uint64 {
        // amd64/v1,amd64/v2:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
        // amd64/v3: `MOVBEQ`
        // ppc64le:`MOVDBR\t\(R[0-9]+\)`,-`MOV[BHW]Z`
+       // ppc64:`MOVD`,-`MOV[BHW]Z`
        return uint64(s[7]) | uint64(s[6])<<8 | uint64(s[5])<<16 | uint64(s[4])<<24 | uint64(s[3])<<32 | uint64(s[2])<<40 | uint64(s[1])<<48 | uint64(s[0])<<56
 }
 
@@ -202,6 +230,8 @@ func load_le_byte2_uint16_idx(s []byte, idx int) uint16 {
        // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOVB`
        // 386:`MOVWLZX\s\([A-Z]+\)\([A-Z]+`,-`ORL`,-`MOVB`
        // amd64:`MOVWLZX\s\([A-Z]+\)\([A-Z]+`,-`MOVB`,-`OR`
+       // ppc64le:`MOVHZ`,-`MOVBZ`
+       // ppc64:`MOVHBR`,-`MOVBZ`
        return uint16(s[idx]) | uint16(s[idx+1])<<8
 }
 
@@ -209,6 +239,8 @@ func load_le_byte2_uint16_idx_inv(s []byte, idx int) uint16 {
        // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOVB`
        // 386:`MOVWLZX\s\([A-Z]+\)\([A-Z]+`,-`ORL`,-`MOVB`
        // amd64:`MOVWLZX\s\([A-Z]+\)\([A-Z]+`,-`MOVB`,-`OR`
+       // ppc64le:`MOVHZ`,-`MOVBZ`
+       // ppc64:`MOVHBR`,-`MOVBZ`
        return uint16(s[idx+1])<<8 | uint16(s[idx])
 }
 
@@ -357,6 +389,7 @@ func store_le64(b []byte, x uint64) {
        // amd64:`MOVQ\s.*\(.*\)$`,-`SHR.`
        // arm64:`MOVD`,-`MOV[WBH]`
        // ppc64le:`MOVD\s`,-`MOV[BHW]\s`
+       // ppc64:`MOVDBR`,-MOVB\s`
        // s390x:`MOVDBR\s.*\(.*\)$`
        binary.LittleEndian.PutUint64(b, x)
 }
@@ -365,6 +398,7 @@ func store_le64_idx(b []byte, x uint64, idx int) {
        // amd64:`MOVQ\s.*\(.*\)\(.*\*1\)$`,-`SHR.`
        // arm64:`MOVD\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`
        // ppc64le:`MOVD\s`,-`MOV[BHW]\s`
+       // ppc64:`MOVDBR`,-`MOVBZ`
        // s390x:`MOVDBR\s.*\(.*\)\(.*\*1\)$`
        binary.LittleEndian.PutUint64(b[idx:], x)
 }
@@ -386,7 +420,8 @@ func store_le64_load(b []byte, x *[8]byte) {
        _ = b[8]
        // amd64:-`MOV[BWL]`
        // arm64:-`MOV[BWH]`
-       // ppc64le:-`MOV[BWH]`
+       // ppc64le:`MOVD\s`,-`MOV[BWH]Z`
+       // ppc64:`MOVDBR`
        // s390x:-`MOVB`,-`MOV[WH]BR`
        binary.LittleEndian.PutUint64(b, binary.LittleEndian.Uint64(x[:]))
 }
@@ -395,6 +430,7 @@ func store_le32(b []byte, x uint32) {
        // amd64:`MOVL\s`
        // arm64:`MOVW`,-`MOV[BH]`
        // ppc64le:`MOVW\s`
+       // ppc64:`MOVWBR`
        // s390x:`MOVWBR\s.*\(.*\)$`
        binary.LittleEndian.PutUint32(b, x)
 }
@@ -403,12 +439,14 @@ func store_le32_idx(b []byte, x uint32, idx int) {
        // amd64:`MOVL\s`
        // arm64:`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`
        // ppc64le:`MOVW\s`
+       // ppc64:`MOVWBR`
        // s390x:`MOVWBR\s.*\(.*\)\(.*\*1\)$`
        binary.LittleEndian.PutUint32(b[idx:], x)
 }
 
 func store_le32_idx_const(b []byte, idx int) {
        // amd64:`MOVL\s\$123, \(.*\)\(.*\*1\)$`
+       // ppc64x:`MOVW\s`,-MOV[HB]`
        binary.LittleEndian.PutUint32(b[idx:], 123)
 }
 
@@ -416,6 +454,7 @@ func store_le16(b []byte, x uint16) {
        // amd64:`MOVW\s`
        // arm64:`MOVH`,-`MOVB`
        // ppc64le:`MOVH\s`
+       // ppc64:`MOVHBR`
        // s390x:`MOVHBR\s.*\(.*\)$`
        binary.LittleEndian.PutUint16(b, x)
 }
@@ -424,12 +463,14 @@ func store_le16_idx(b []byte, x uint16, idx int) {
        // amd64:`MOVW\s`
        // arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`
        // ppc64le:`MOVH\s`
+       // ppc64:`MOVHBR\s`
        // s390x:`MOVHBR\s.*\(.*\)\(.*\*1\)$`
        binary.LittleEndian.PutUint16(b[idx:], x)
 }
 
 func store_le16_idx_const(b []byte, idx int) {
        // amd64:`MOVW\s\$123, \(.*\)\(.*\*1\)$`
+       // ppc64x:`MOVH\s`
        binary.LittleEndian.PutUint16(b[idx:], 123)
 }
 
@@ -438,6 +479,7 @@ func store_be64(b []byte, x uint64) {
        // amd64/v3: `MOVBEQ`
        // arm64:`MOVD`,`REV`,-`MOV[WBH]`,-`REVW`,-`REV16W`
        // ppc64le:`MOVDBR`
+       // ppc64:`MOVD\s`
        // s390x:`MOVD\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
        binary.BigEndian.PutUint64(b, x)
 }
@@ -447,6 +489,7 @@ func store_be64_idx(b []byte, x uint64, idx int) {
        // amd64/v3:`MOVBEQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
        // arm64:`REV`,`MOVD\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`,-`REV16W`,-`REVW`
        // ppc64le:`MOVDBR`
+       // ppc64:`MOVD\s`
        // s390x:`MOVD\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
        binary.BigEndian.PutUint64(b[idx:], x)
 }
@@ -456,6 +499,7 @@ func store_be32(b []byte, x uint32) {
        // amd64/v3:`MOVBEL`
        // arm64:`MOVW`,`REVW`,-`MOV[BH]`,-`REV16W`
        // ppc64le:`MOVWBR`
+       // ppc64:`MOVW\s`
        // s390x:`MOVW\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
        binary.BigEndian.PutUint32(b, x)
 }
@@ -477,6 +521,7 @@ func store_be32_idx(b []byte, x uint32, idx int) {
        // amd64/v3:`MOVBEL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
        // arm64:`REVW`,`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`,-`REV16W`
        // ppc64le:`MOVWBR`
+       // ppc64:`MOVW\s`
        // s390x:`MOVW\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
        binary.BigEndian.PutUint32(b[idx:], x)
 }
@@ -486,6 +531,7 @@ func store_be16(b []byte, x uint16) {
        // amd64/v3:`MOVBEW`,-`ROLW`
        // arm64:`MOVH`,`REV16W`,-`MOVB`
        // ppc64le:`MOVHBR`
+       // ppc64:`MOVH\s`
        // s390x:`MOVH\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
        binary.BigEndian.PutUint16(b, x)
 }
@@ -495,6 +541,7 @@ func store_be16_idx(b []byte, x uint16, idx int) {
        // amd64/v3:`MOVBEW\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
        // arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`MOVB`
        // ppc64le:`MOVHBR`
+       // ppc64:`MOVH\s`
        // s390x:`MOVH\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
        binary.BigEndian.PutUint16(b[idx:], x)
 }
@@ -504,6 +551,8 @@ func store_le_byte_2(b []byte, val uint16) {
        // arm64:`MOVH\sR[0-9]+,\s1\(R[0-9]+\)`,-`MOVB`
        // 386:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`
        // amd64:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`
+       // ppc64le:`MOVH\s`,-`MOVB`
+       // ppc64:`MOVHBR`,-`MOVB`
        b[1], b[2] = byte(val), byte(val>>8)
 }
 
@@ -511,6 +560,8 @@ func store_le_byte_2_inv(b []byte, val uint16) {
        _ = b[2]
        // 386:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`
        // amd64:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`
+       // ppc64le:`MOVH\s`,-`MOVB`
+       // ppc64:`MOVHBR`,-`MOVB`
        b[2], b[1] = byte(val>>8), byte(val)
 }
 
@@ -519,6 +570,8 @@ func store_le_byte_4(b []byte, val uint32) {
        // arm64:`MOVW\sR[0-9]+,\s1\(R[0-9]+\)`,-`MOVB`,-`MOVH`
        // 386:`MOVL\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`,-`MOVW`
        // amd64:`MOVL\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`,-`MOVW`
+       // ppc64le:`MOVW\s`
+       // ppc64:`MOVWBR\s`
        b[1], b[2], b[3], b[4] = byte(val), byte(val>>8), byte(val>>16), byte(val>>24)
 }
 
@@ -526,6 +579,8 @@ func store_le_byte_8(b []byte, val uint64) {
        _ = b[8]
        // arm64:`MOVD\sR[0-9]+,\s1\(R[0-9]+\)`,-`MOVB`,-`MOVH`,-`MOVW`
        // amd64:`MOVQ\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`,-`MOVW`,-`MOVL`
+       // ppc64le:`MOVD\s`,-`MOVW`
+       // ppc64:`MOVDBR\s`
        b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8] = byte(val), byte(val>>8), byte(val>>16), byte(val>>24), byte(val>>32), byte(val>>40), byte(val>>48), byte(val>>56)
 }
 
@@ -534,6 +589,8 @@ func store_be_byte_2(b []byte, val uint16) {
        // arm64:`REV16W`,`MOVH\sR[0-9]+,\s1\(R[0-9]+\)`,-`MOVB`
        // amd64/v1,amd64/v2:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`
        // amd64/v3: `MOVBEW`
+       // ppc64le:`MOVHBR`
+       // ppc64:`MOVH\s`
        b[1], b[2] = byte(val>>8), byte(val)
 }
 
@@ -542,6 +599,8 @@ func store_be_byte_4(b []byte, val uint32) {
        // arm64:`REVW`,`MOVW\sR[0-9]+,\s1\(R[0-9]+\)`,-`MOVB`,-`MOVH`,-`REV16W`
        // amd64/v1,amd64/v2:`MOVL\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`,-`MOVW`
        // amd64/v3:`MOVBEL\s[A-Z]+,\s1\([A-Z]+\)`
+       // ppc64le:`MOVWBR`
+       // ppc64:`MOVW\s`
        b[1], b[2], b[3], b[4] = byte(val>>24), byte(val>>16), byte(val>>8), byte(val)
 }
 
@@ -550,6 +609,8 @@ func store_be_byte_8(b []byte, val uint64) {
        // arm64:`REV`,`MOVD\sR[0-9]+,\s1\(R[0-9]+\)`,-`MOVB`,-`MOVH`,-`MOVW`,-`REV16W`,-`REVW`
        // amd64/v1,amd64/v2:`MOVQ\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`,-`MOVW`,-`MOVL`
        // amd64/v3:`MOVBEQ\s[A-Z]+,\s1\([A-Z]+\)`, -`MOVBEL`
+       // ppc64le:`MOVDBR`
+       // ppc64:`MOVD`
        b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8] = byte(val>>56), byte(val>>48), byte(val>>40), byte(val>>32), byte(val>>24), byte(val>>16), byte(val>>8), byte(val)
 }
 
@@ -557,54 +618,72 @@ func store_le_byte_2_idx(b []byte, idx int, val uint16) {
        _, _ = b[idx+0], b[idx+1]
        // arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`
        // 386:`MOVW\s[A-Z]+,\s\([A-Z]+\)\([A-Z]+`,-`MOVB`
+       // ppc64le:`MOVH\s`
+       // ppc64:`MOVHBR`
        b[idx+1], b[idx+0] = byte(val>>8), byte(val)
 }
 
 func store_le_byte_2_idx_inv(b []byte, idx int, val uint16) {
        _, _ = b[idx+0], b[idx+1]
        // 386:`MOVW\s[A-Z]+,\s\([A-Z]+\)\([A-Z]+`,-`MOVB`
+       // ppc64le:`MOVH\s`
+       // ppc64:`MOVHBR`
        b[idx+0], b[idx+1] = byte(val), byte(val>>8)
 }
 
 func store_le_byte_4_idx(b []byte, idx int, val uint32) {
        _, _, _, _ = b[idx+0], b[idx+1], b[idx+2], b[idx+3]
        // arm64:`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`,-`MOVH`
+       // ppc64le:`MOVW\s`
+       // ppc64:`MOVWBR`
        b[idx+3], b[idx+2], b[idx+1], b[idx+0] = byte(val>>24), byte(val>>16), byte(val>>8), byte(val)
 }
 
 func store_be_byte_2_idx(b []byte, idx int, val uint16) {
        _, _ = b[idx+0], b[idx+1]
        // arm64:`REV16W`,`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`
+       // ppc64le:`MOVHBR`
+       // ppc64:`MOVH\s`
        b[idx+0], b[idx+1] = byte(val>>8), byte(val)
 }
 
 func store_be_byte_4_idx(b []byte, idx int, val uint32) {
        _, _, _, _ = b[idx+0], b[idx+1], b[idx+2], b[idx+3]
        // arm64:`REVW`,`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`,-`MOVH`,-`REV16W`
+       // ppc64le:`MOVWBR`
+       // ppc64:`MOVW\s`
        b[idx+0], b[idx+1], b[idx+2], b[idx+3] = byte(val>>24), byte(val>>16), byte(val>>8), byte(val)
 }
 
 func store_be_byte_2_idx2(b []byte, idx int, val uint16) {
        _, _ = b[(idx<<1)+0], b[(idx<<1)+1]
        // arm64:`REV16W`,`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+<<1\)`,-`MOVB`
+       // ppc64le:`MOVHBR`
+       // ppc64:`MOVH\s`
        b[(idx<<1)+0], b[(idx<<1)+1] = byte(val>>8), byte(val)
 }
 
 func store_le_byte_2_idx2(b []byte, idx int, val uint16) {
        _, _ = b[(idx<<1)+0], b[(idx<<1)+1]
        // arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+<<1\)`,-`MOVB`
+       // ppc64le:`MOVH\s`
+       // ppc64:`MOVHBR`
        b[(idx<<1)+1], b[(idx<<1)+0] = byte(val>>8), byte(val)
 }
 
 func store_be_byte_4_idx4(b []byte, idx int, val uint32) {
        _, _, _, _ = b[(idx<<2)+0], b[(idx<<2)+1], b[(idx<<2)+2], b[(idx<<2)+3]
        // arm64:`REVW`,`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+<<2\)`,-`MOVB`,-`MOVH`,-`REV16W`
+       // ppc64le:`MOVWBR`
+       // ppc64:`MOVW\s`
        b[(idx<<2)+0], b[(idx<<2)+1], b[(idx<<2)+2], b[(idx<<2)+3] = byte(val>>24), byte(val>>16), byte(val>>8), byte(val)
 }
 
 func store_le_byte_4_idx4_inv(b []byte, idx int, val uint32) {
        _, _, _, _ = b[(idx<<2)+0], b[(idx<<2)+1], b[(idx<<2)+2], b[(idx<<2)+3]
        // arm64:`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+<<2\)`,-`MOVB`,-`MOVH`
+       // ppc64le:`MOVW\s`
+       // ppc64:`MOVWBR`
        b[(idx<<2)+3], b[(idx<<2)+2], b[(idx<<2)+1], b[(idx<<2)+0] = byte(val>>24), byte(val>>16), byte(val>>8), byte(val)
 }
 
@@ -620,10 +699,12 @@ func zero_byte_2(b1, b2 []byte) {
        // arm64:"MOVH\tZR",-"MOVB"
        // amd64:`MOVW\s[$]0,\s\([A-Z]+\)`
        // 386:`MOVW\s[$]0,\s\([A-Z]+\)`
+       // ppc64x:`MOVH\s`
        b1[0], b1[1] = 0, 0
        // arm64:"MOVH\tZR",-"MOVB"
        // 386:`MOVW\s[$]0,\s\([A-Z]+\)`
        // amd64:`MOVW\s[$]0,\s\([A-Z]+\)`
+       // ppc64x:`MOVH`
        b2[1], b2[0] = 0, 0
 }
 
@@ -632,8 +713,10 @@ func zero_byte_4(b1, b2 []byte) {
        // arm64:"MOVW\tZR",-"MOVB",-"MOVH"
        // amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
        // 386:`MOVL\s[$]0,\s\([A-Z]+\)`
+       // ppc64x:`MOVW\s`
        b1[0], b1[1], b1[2], b1[3] = 0, 0, 0, 0
        // arm64:"MOVW\tZR",-"MOVB",-"MOVH"
+       // ppc64x:`MOVW\s`
        b2[2], b2[3], b2[1], b2[0] = 0, 0, 0, 0
 }
 
@@ -662,12 +745,14 @@ func zero_byte_39(a *[39]byte) {
 func zero_byte_2_idx(b []byte, idx int) {
        _, _ = b[idx+0], b[idx+1]
        // arm64:`MOVH\sZR,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`
+       // ppc64x:`MOVH\s`
        b[idx+0], b[idx+1] = 0, 0
 }
 
 func zero_byte_2_idx2(b []byte, idx int) {
        _, _ = b[(idx<<1)+0], b[(idx<<1)+1]
        // arm64:`MOVH\sZR,\s\(R[0-9]+\)\(R[0-9]+<<1\)`,-`MOVB`
+       // ppc64x:`MOVH\s`
        b[(idx<<1)+0], b[(idx<<1)+1] = 0, 0
 }
 
@@ -676,10 +761,12 @@ func zero_uint16_2(h1, h2 []uint16) {
        // arm64:"MOVW\tZR",-"MOVB",-"MOVH"
        // amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
        // 386:`MOVL\s[$]0,\s\([A-Z]+\)`
+       // ppc64x:`MOVW\s`
        h1[0], h1[1] = 0, 0
        // arm64:"MOVW\tZR",-"MOVB",-"MOVH"
        // amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
        // 386:`MOVL\s[$]0,\s\([A-Z]+\)`
+       // ppc64x:`MOVW`
        h2[1], h2[0] = 0, 0
 }
 
@@ -687,8 +774,10 @@ func zero_uint16_4(h1, h2 []uint16) {
        _, _ = h1[3], h2[3]
        // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
        // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
+       // ppc64x:`MOVD\s`
        h1[0], h1[1], h1[2], h1[3] = 0, 0, 0, 0
        // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
+       // ppc64x:`MOVD\s`
        h2[2], h2[3], h2[1], h2[0] = 0, 0, 0, 0
 }
 
@@ -702,9 +791,11 @@ func zero_uint32_2(w1, w2 []uint32) {
        _, _ = w1[1], w2[1]
        // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
        // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
+       // ppc64x:`MOVD\s`
        w1[0], w1[1] = 0, 0
        // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
        // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
+       // ppc64x:`MOVD\s`
        w2[1], w2[0] = 0, 0
 }