mirror of https://github.com/golang/go.git
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>
This commit is contained in:
Wayne Zuo
Keith Randall
parent
a6f6932b3e
commit
615d3c3040
|
|
@ -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) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue