test: adjust load and store test

In the load tests, we only want to test the assembly produced by
the load operations. If we use the global variable sink, it will produce
one load operation and one store operation(assign to sink).

For example:

func load_be64(b []byte) uint64 {
	sink64 = binary.BigEndian.Uint64(b)
}

If we compile this function with GOAMD64=v3, it may produce MOVBEQload
and MOVQstore or MOVQload and MOVBEQstore, but we only want MOVBEQload.
Discovered when developing CL 395474.

Same for the store tests.

Change-Id: I65c3c742f1eff657c3a0d2dd103f51140ae8079e
Reviewed-on: https://go-review.googlesource.com/c/go/+/397875
Reviewed-by: Keith Randall <khr@golang.org>
Trust: Cherry Mui <cherryyz@google.com>

diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go
index ad42538dcdba878a62373fd2c9f3489a0428cb9f..0d4e96f862ccc35087c6d7f800f0c9e2cb1e5738 100644 (file)
--- a/test/codegen/memcombine.go
+++ b/test/codegen/memcombine.go
@@ -11,98 +11,94 @@ import (
        "runtime"
 )
 
-var sink64 uint64
-var sink32 uint32
-var sink16 uint16
-
 // ------------- //
 //    Loading    //
 // ------------- //
 
-func load_le64(b []byte) {
+func load_le64(b []byte) uint64 {
        // amd64:`MOVQ\s\(.*\),`,-`MOV[BWL]\t[^$]`,-`OR`
        // s390x:`MOVDBR\s\(.*\),`
        // arm64:`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`
        // ppc64le:`MOVD\s`,-`MOV[BHW]Z`
-       sink64 = binary.LittleEndian.Uint64(b)
+       return binary.LittleEndian.Uint64(b)
 }
 
-func load_le64_idx(b []byte, idx int) {
+func load_le64_idx(b []byte, idx int) uint64 {
        // amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL]\t[^$]`,-`OR`
        // s390x:`MOVDBR\s\(.*\)\(.*\*1\),`
        // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]`
        // ppc64le:`MOVD\s`,-`MOV[BHW]Z\s`
-       sink64 = binary.LittleEndian.Uint64(b[idx:])
+       return binary.LittleEndian.Uint64(b[idx:])
 }
 
-func load_le32(b []byte) {
+func load_le32(b []byte) uint32 {
        // amd64:`MOVL\s\(.*\),`,-`MOV[BW]`,-`OR`
        // 386:`MOVL\s\(.*\),`,-`MOV[BW]`,-`OR`
        // s390x:`MOVWBR\s\(.*\),`
        // arm64:`MOVWU\s\(R[0-9]+\),`,-`MOV[BH]`
        // ppc64le:`MOVWZ\s`,-`MOV[BH]Z\s`
-       sink32 = binary.LittleEndian.Uint32(b)
+       return binary.LittleEndian.Uint32(b)
 }
 
-func load_le32_idx(b []byte, idx int) {
+func load_le32_idx(b []byte, idx int) uint32 {
        // amd64:`MOVL\s\(.*\)\(.*\*1\),`,-`MOV[BW]`,-`OR`
        // 386:`MOVL\s\(.*\)\(.*\*1\),`,-`MOV[BW]`,-`OR`
        // s390x:`MOVWBR\s\(.*\)\(.*\*1\),`
        // arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BH]`
        // ppc64le:`MOVWZ\s`,-`MOV[BH]Z\s`
-       sink32 = binary.LittleEndian.Uint32(b[idx:])
+       return binary.LittleEndian.Uint32(b[idx:])
 }
 
-func load_le16(b []byte) {
+func load_le16(b []byte) uint16 {
        // amd64:`MOVWLZX\s\(.*\),`,-`MOVB`,-`OR`
        // ppc64le:`MOVHZ\s`,-`MOVBZ`
        // arm64:`MOVHU\s\(R[0-9]+\),`,-`MOVB`
        // s390x:`MOVHBR\s\(.*\),`
-       sink16 = binary.LittleEndian.Uint16(b)
+       return binary.LittleEndian.Uint16(b)
 }
 
-func load_le16_idx(b []byte, idx int) {
+func load_le16_idx(b []byte, idx int) uint16 {
        // amd64:`MOVWLZX\s\(.*\),`,-`MOVB`,-`OR`
        // ppc64le:`MOVHZ\s`,-`MOVBZ`
        // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOVB`
        // s390x:`MOVHBR\s\(.*\)\(.*\*1\),`
-       sink16 = binary.LittleEndian.Uint16(b[idx:])
+       return binary.LittleEndian.Uint16(b[idx:])
 }
 
-func load_be64(b []byte) {
+func load_be64(b []byte) uint64 {
        // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
        // amd64/v3:`MOVBEQ`
        // s390x:`MOVD\s\(.*\),`
        // arm64:`REV`,`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W`
        // ppc64le:`MOVDBR`,-`MOV[BHW]Z`
-       sink64 = binary.BigEndian.Uint64(b)
+       return binary.BigEndian.Uint64(b)
 }
 
-func load_be64_idx(b []byte, idx int) {
+func load_be64_idx(b []byte, idx int) uint64 {
        // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
        // amd64/v3: `MOVBEQ`
        // s390x:`MOVD\s\(.*\)\(.*\*1\),`
        // arm64:`REV`,`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[WHB]`,-`REVW`,-`REV16W`
        // ppc64le:`MOVDBR`,-`MOV[BHW]Z`
-       sink64 = binary.BigEndian.Uint64(b[idx:])
+       return binary.BigEndian.Uint64(b[idx:])
 }
 
-func load_be32(b []byte) {
+func load_be32(b []byte) uint32 {
        // amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR`
        // amd64/v3: `MOVBEL`
        // s390x:`MOVWZ\s\(.*\),`
        // arm64:`REVW`,`MOVWU\s\(R[0-9]+\),`,-`MOV[BH]`,-`REV16W`
        // ppc64le:`MOVWBR`,-`MOV[BH]Z`
-       sink32 = binary.BigEndian.Uint32(b)
+       return binary.BigEndian.Uint32(b)
 }
 
-func load_be32_idx(b []byte, idx int) {
+func load_be32_idx(b []byte, idx int) uint32 {
        // amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR`
        // amd64/v3: `MOVBEL`
        // s390x:`MOVWZ\s\(.*\)\(.*\*1\),`
        // arm64:`REVW`,`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[HB]`,-`REV16W`
        // ppc64le:`MOVWBR`,-`MOV[BH]Z`
-       sink32 = binary.BigEndian.Uint32(b[idx:])
+       return binary.BigEndian.Uint32(b[idx:])
 }
 
 func load_be16(b []byte) uint16 {
@@ -357,20 +353,20 @@ func safe_point(p, q *[2]*int) {
 //    Storing    //
 // ------------- //
 
-func store_le64(b []byte) {
+func store_le64(b []byte, x uint64) {
        // amd64:`MOVQ\s.*\(.*\)$`,-`SHR.`
        // arm64:`MOVD`,-`MOV[WBH]`
        // ppc64le:`MOVD\s`,-`MOV[BHW]\s`
        // s390x:`MOVDBR\s.*\(.*\)$`
-       binary.LittleEndian.PutUint64(b, sink64)
+       binary.LittleEndian.PutUint64(b, x)
 }
 
-func store_le64_idx(b []byte, idx int) {
+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`
        // s390x:`MOVDBR\s.*\(.*\)\(.*\*1\)$`
-       binary.LittleEndian.PutUint64(b[idx:], sink64)
+       binary.LittleEndian.PutUint64(b[idx:], x)
 }
 
 func store_le64_load(b []byte, x *[8]byte) {
@@ -382,63 +378,63 @@ func store_le64_load(b []byte, x *[8]byte) {
        binary.LittleEndian.PutUint64(b, binary.LittleEndian.Uint64(x[:]))
 }
 
-func store_le32(b []byte) {
+func store_le32(b []byte, x uint32) {
        // amd64:`MOVL\s`
        // arm64:`MOVW`,-`MOV[BH]`
        // ppc64le:`MOVW\s`
        // s390x:`MOVWBR\s.*\(.*\)$`
-       binary.LittleEndian.PutUint32(b, sink32)
+       binary.LittleEndian.PutUint32(b, x)
 }
 
-func store_le32_idx(b []byte, idx int) {
+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`
        // s390x:`MOVWBR\s.*\(.*\)\(.*\*1\)$`
-       binary.LittleEndian.PutUint32(b[idx:], sink32)
+       binary.LittleEndian.PutUint32(b[idx:], x)
 }
 
-func store_le16(b []byte) {
+func store_le16(b []byte, x uint16) {
        // amd64:`MOVW\s`
        // arm64:`MOVH`,-`MOVB`
        // ppc64le:`MOVH\s`
        // s390x:`MOVHBR\s.*\(.*\)$`
-       binary.LittleEndian.PutUint16(b, sink16)
+       binary.LittleEndian.PutUint16(b, x)
 }
 
-func store_le16_idx(b []byte, idx int) {
+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`
        // s390x:`MOVHBR\s.*\(.*\)\(.*\*1\)$`
-       binary.LittleEndian.PutUint16(b[idx:], sink16)
+       binary.LittleEndian.PutUint16(b[idx:], x)
 }
 
-func store_be64(b []byte) {
+func store_be64(b []byte, x uint64) {
        // amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.`
        // amd64/v3: `MOVBEQ`
        // arm64:`MOVD`,`REV`,-`MOV[WBH]`,-`REVW`,-`REV16W`
        // ppc64le:`MOVDBR`
        // s390x:`MOVD\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
-       binary.BigEndian.PutUint64(b, sink64)
+       binary.BigEndian.PutUint64(b, x)
 }
 
-func store_be64_idx(b []byte, idx int) {
+func store_be64_idx(b []byte, x uint64, idx int) {
        // amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.`
        // amd64/v3:`MOVBEQ`
        // arm64:`REV`,`MOVD\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`,-`REV16W`,-`REVW`
        // ppc64le:`MOVDBR`
        // s390x:`MOVD\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
-       binary.BigEndian.PutUint64(b[idx:], sink64)
+       binary.BigEndian.PutUint64(b[idx:], x)
 }
 
-func store_be32(b []byte) {
+func store_be32(b []byte, x uint32) {
        // amd64/v1,amd64/v2:`BSWAPL`,-`SHR.`
        // amd64/v3:`MOVBEL`
        // arm64:`MOVW`,`REVW`,-`MOV[BH]`,-`REV16W`
        // ppc64le:`MOVWBR`
        // s390x:`MOVW\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
-       binary.BigEndian.PutUint32(b, sink32)
+       binary.BigEndian.PutUint32(b, x)
 }
 
 func store_be64_load(b, x *[8]byte) {
@@ -453,31 +449,31 @@ func store_be32_load(b, x *[8]byte) {
        binary.BigEndian.PutUint32(b[:], binary.BigEndian.Uint32(x[:]))
 }
 
-func store_be32_idx(b []byte, idx int) {
+func store_be32_idx(b []byte, x uint32, idx int) {
        // amd64/v1,amd64/v2:`BSWAPL`,-`SHR.`
        // amd64/v3:`MOVBEL`
        // arm64:`REVW`,`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`,-`REV16W`
        // ppc64le:`MOVWBR`
        // s390x:`MOVW\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
-       binary.BigEndian.PutUint32(b[idx:], sink32)
+       binary.BigEndian.PutUint32(b[idx:], x)
 }
 
-func store_be16(b []byte) {
+func store_be16(b []byte, x uint16) {
        // amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.`
        // amd64/v3:`MOVBEW`,-`ROLW`
        // arm64:`MOVH`,`REV16W`,-`MOVB`
        // ppc64le:`MOVHBR`
        // s390x:`MOVH\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
-       binary.BigEndian.PutUint16(b, sink16)
+       binary.BigEndian.PutUint16(b, x)
 }
 
-func store_be16_idx(b []byte, idx int) {
+func store_be16_idx(b []byte, x uint16, idx int) {
        // amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.`
        // amd64/v3: `MOVBEW`
        // arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`MOVB`
        // ppc64le:`MOVHBR`
        // s390x:`MOVH\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
-       binary.BigEndian.PutUint16(b[idx:], sink16)
+       binary.BigEndian.PutUint16(b[idx:], x)
 }
 
 func store_le_byte_2(b []byte, val uint16) {