From 615d3c304077f1f3ca249151fb87d7d7a802cab2 Mon Sep 17 00:00:00 2001 From: Wayne Zuo Date: Mon, 4 Apr 2022 16:32:29 +0800 Subject: [PATCH] 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 Trust: Cherry Mui --- test/codegen/memcombine.go | 92 ++++++++++++++++++-------------------- 1 file changed, 44 insertions(+), 48 deletions(-) diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go index ad42538dcd..0d4e96f862 100644 --- 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) { -- 2.50.0