diff options
Diffstat (limited to 'test/codegen/memcombine.go')
| -rw-r--r-- | test/codegen/memcombine.go | 428 |
1 files changed, 214 insertions, 214 deletions
diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go index 48ecd4fd01..9e24185a22 100644 --- a/test/codegen/memcombine.go +++ b/test/codegen/memcombine.go @@ -16,72 +16,72 @@ import ( // ------------- // func load_le64(b []byte) uint64 { - // amd64:`MOVQ\s\(.*\),`,-`MOV[BWL] [^$]`,-`OR` - // s390x:`MOVDBR\s\(.*\),` - // arm64:`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]` - // loong64:`MOVV\s\(R[0-9]+\),` - // ppc64le:`MOVD\s`,-`MOV[BHW]Z` - // ppc64:`MOVDBR\s`,-`MOV[BHW]Z` + // amd64:`MOVQ \(.*\),`,-`MOV[BWL] [^$]`,-`OR` + // s390x:`MOVDBR \(.*\),` + // arm64:`MOVD \(R[0-9]+\),`,-`MOV[BHW]` + // loong64:`MOVV \(R[0-9]+\),` + // ppc64le:`MOVD `,-`MOV[BHW]Z` + // ppc64:`MOVDBR `,-`MOV[BHW]Z` return binary.LittleEndian.Uint64(b) } func load_le64_idx(b []byte, idx int) uint64 { - // amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL] [^$]`,-`OR` - // s390x:`MOVDBR\s\(.*\)\(.*\*1\),` - // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]` - // loong64:`MOVV\s\(R[0-9]+\)\(R[0-9]+\),` - // ppc64le:`MOVD\s`,-`MOV[BHW]Z\s` - // ppc64:`MOVDBR\s`,-`MOV[BHW]Z\s` + // amd64:`MOVQ \(.*\)\(.*\*1\),`,-`MOV[BWL] [^$]`,-`OR` + // s390x:`MOVDBR \(.*\)\(.*\*1\),` + // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]` + // loong64:`MOVV \(R[0-9]+\)\(R[0-9]+\),` + // ppc64le:`MOVD `,-`MOV[BHW]Z ` + // ppc64:`MOVDBR `,-`MOV[BHW]Z ` return binary.LittleEndian.Uint64(b[idx:]) } 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]` - // loong64:`MOVWU\s\(R[0-9]+\),` - // ppc64le:`MOVWZ\s`,-`MOV[BH]Z\s` - // ppc64:`MOVWBR\s`,-`MOV[BH]Z\s` + // amd64:`MOVL \(.*\),`,-`MOV[BW]`,-`OR` + // 386:`MOVL \(.*\),`,-`MOV[BW]`,-`OR` + // s390x:`MOVWBR \(.*\),` + // arm64:`MOVWU \(R[0-9]+\),`,-`MOV[BH]` + // loong64:`MOVWU \(R[0-9]+\),` + // ppc64le:`MOVWZ `,-`MOV[BH]Z ` + // ppc64:`MOVWBR `,-`MOV[BH]Z ` return binary.LittleEndian.Uint32(b) } 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]` - // loong64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),` - // ppc64le:`MOVWZ\s`,-`MOV[BH]Z\s` - // ppc64:`MOVWBR\s`,-`MOV[BH]Z\s` + // amd64:`MOVL \(.*\)\(.*\*1\),`,-`MOV[BW]`,-`OR` + // 386:`MOVL \(.*\)\(.*\*1\),`,-`MOV[BW]`,-`OR` + // s390x:`MOVWBR \(.*\)\(.*\*1\),` + // arm64:`MOVWU \(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BH]` + // loong64:`MOVWU \(R[0-9]+\)\(R[0-9]+\),` + // ppc64le:`MOVWZ `,-`MOV[BH]Z ` + // ppc64:`MOVWBR `,-`MOV[BH]Z ` return binary.LittleEndian.Uint32(b[idx:]) } func load_le16(b []byte) uint16 { - // amd64:`MOVWLZX\s\(.*\),`,-`MOVB`,-`OR` - // ppc64le:`MOVHZ\s`,-`MOVBZ` - // arm64:`MOVHU\s\(R[0-9]+\),`,-`MOVB` - // loong64:`MOVHU\s\(R[0-9]+\),` - // s390x:`MOVHBR\s\(.*\),` - // ppc64:`MOVHBR\s`,-`MOVBZ` + // amd64:`MOVWLZX \(.*\),`,-`MOVB`,-`OR` + // ppc64le:`MOVHZ `,-`MOVBZ` + // arm64:`MOVHU \(R[0-9]+\),`,-`MOVB` + // loong64:`MOVHU \(R[0-9]+\),` + // s390x:`MOVHBR \(.*\),` + // ppc64:`MOVHBR `,-`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` - // loong64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+\),` - // s390x:`MOVHBR\s\(.*\)\(.*\*1\),` + // amd64:`MOVWLZX \(.*\),`,-`MOVB`,-`OR` + // ppc64le:`MOVHZ `,-`MOVBZ` + // ppc64:`MOVHBR `,-`MOVBZ` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+\),`,-`MOVB` + // loong64:`MOVHU \(R[0-9]+\)\(R[0-9]+\),` + // s390x:`MOVHBR \(.*\)\(.*\*1\),` return binary.LittleEndian.Uint16(b[idx:]) } func load_be64(b []byte) uint64 { // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` // amd64/v3:`MOVBEQ` - // s390x:`MOVD\s\(.*\),` - // arm64:`REV`,`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W` + // s390x:`MOVD \(.*\),` + // arm64:`REV`,`MOVD \(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W` // ppc64le:`MOVDBR`,-`MOV[BHW]Z` // ppc64:`MOVD`,-`MOV[BHW]Z` return binary.BigEndian.Uint64(b) @@ -90,8 +90,8 @@ func load_be64(b []byte) uint64 { func load_be64_idx(b []byte, idx int) uint64 { // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` // amd64/v3: `MOVBEQ \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` - // s390x:`MOVD\s\(.*\)\(.*\*1\),` - // arm64:`REV`,`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[WHB]`,-`REVW`,-`REV16W` + // s390x:`MOVD \(.*\)\(.*\*1\),` + // arm64:`REV`,`MOVD \(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:]) @@ -100,8 +100,8 @@ func load_be64_idx(b []byte, idx int) uint64 { 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` + // s390x:`MOVWZ \(.*\),` + // arm64:`REVW`,`MOVWU \(R[0-9]+\),`,-`MOV[BH]`,-`REV16W` // ppc64le:`MOVWBR`,-`MOV[BH]Z` // ppc64:`MOVWZ`,-`MOV[BH]Z` return binary.BigEndian.Uint32(b) @@ -110,35 +110,35 @@ func load_be32(b []byte) uint32 { func load_be32_idx(b []byte, idx int) uint32 { // amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR` // amd64/v3: `MOVBEL \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` - // s390x:`MOVWZ\s\(.*\)\(.*\*1\),` - // arm64:`REVW`,`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[HB]`,-`REV16W` + // s390x:`MOVWZ \(.*\)\(.*\*1\),` + // arm64:`REVW`,`MOVWU \(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` + // amd64:`ROLW \$8`,-`MOVB`,-`OR` + // arm64:`REV16W`,`MOVHU \(R[0-9]+\),`,-`MOVB` // ppc64le:`MOVHBR`,-`MOVBZ` // ppc64:`MOVHZ`,-`MOVBZ` - // s390x:`MOVHZ\s\(.*\),`,-`OR`,-`ORW`,-`SLD`,-`SLW` + // s390x:`MOVHZ \(.*\),`,-`OR`,-`ORW`,-`SLD`,-`SLW` return binary.BigEndian.Uint16(b) } 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` + // amd64:`ROLW \$8`,-`MOVB`,-`OR` + // arm64:`REV16W`,`MOVHU \(R[0-9]+\)\(R[0-9]+\),`,-`MOVB` // ppc64le:`MOVHBR`,-`MOVBZ` // ppc64:`MOVHZ`,-`MOVBZ` - // s390x:`MOVHZ\s\(.*\)\(.*\*1\),`,-`OR`,-`ORW`,-`SLD`,-`SLW` + // s390x:`MOVHZ \(.*\)\(.*\*1\),`,-`OR`,-`ORW`,-`SLD`,-`SLW` return binary.BigEndian.Uint16(b[idx:]) } func load_le_byte2_uint16(s []byte) uint16 { // arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB` - // 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR` - // amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR` + // 386:`MOVWLZX \([A-Z]+\)`,-`MOVB`,-`OR` + // amd64:`MOVWLZX \([A-Z]+\)`,-`MOVB`,-`OR` // ppc64le:`MOVHZ \(R[0-9]+\)`,-`MOVBZ` // ppc64:`MOVHBR`,-`MOVBZ` return uint16(s[0]) | uint16(s[1])<<8 @@ -146,8 +146,8 @@ func load_le_byte2_uint16(s []byte) uint16 { func load_le_byte2_uint16_inv(s []byte) uint16 { // arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB` - // 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR` - // amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR` + // 386:`MOVWLZX \([A-Z]+\)`,-`MOVB`,-`OR` + // amd64:`MOVWLZX \([A-Z]+\)`,-`MOVB`,-`OR` // ppc64le:`MOVHZ \(R[0-9]+\)`,-`MOVBZ` // ppc64:`MOVHBR`,-`MOVBZ` return uint16(s[1])<<8 | uint16(s[0]) @@ -155,8 +155,8 @@ func load_le_byte2_uint16_inv(s []byte) uint16 { func load_le_byte4_uint32(s []byte) uint32 { // arm64:`MOVWU \(R[0-9]+\)`,-`ORR`,-`MOV[BH]` - // 386:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR` - // amd64:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR` + // 386:`MOVL \([A-Z]+\)`,-`MOV[BW]`,-`OR` + // amd64:`MOVL \([A-Z]+\)`,-`MOV[BW]`,-`OR` // ppc64le:`MOVWZ \(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 @@ -171,7 +171,7 @@ func load_le_byte4_uint32_inv(s []byte) uint32 { func load_le_byte8_uint64(s []byte) uint64 { // arm64:`MOVD \(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` - // amd64:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,-`MOV[BWL] [^$]`,-`OR` + // amd64:`MOVQ \([A-Z]+\), [A-Z]+`,-`MOV[BWL] [^$]`,-`OR` // ppc64le:`MOVD \(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 @@ -186,7 +186,7 @@ func load_le_byte8_uint64_inv(s []byte) uint64 { func load_be_byte2_uint16(s []byte) uint16 { // arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` - // amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR` + // amd64:`MOVWLZX \([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR` // ppc64le:`MOVHBR \(R[0-9]+\)`,-`MOVBZ` // ppc64:`MOVHZ`,-`MOVBZ` return uint16(s[0])<<8 | uint16(s[1]) @@ -194,7 +194,7 @@ func load_be_byte2_uint16(s []byte) uint16 { func load_be_byte2_uint16_inv(s []byte) uint16 { // arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` - // amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR` + // amd64:`MOVWLZX \([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR` // ppc64le:`MOVHBR \(R[0-9]+\)`,-`MOVBZ` // ppc64:`MOVHZ`,-`MOVBZ` return uint16(s[1]) | uint16(s[0])<<8 @@ -209,7 +209,7 @@ func load_be_byte4_uint32(s []byte) uint32 { func load_be_byte4_uint32_inv(s []byte) uint32 { // arm64:`MOVWU \(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]` - // amd64/v1,amd64/v2:`MOVL\s\([A-Z]+\)`,`BSWAPL`,-`MOV[BW]`,-`OR` + // amd64/v1,amd64/v2:`MOVL \([A-Z]+\)`,`BSWAPL`,-`MOV[BW]`,-`OR` // amd64/v3: `MOVBEL` // ppc64le:`MOVWBR`,-`MOV[HB]Z` // ppc64:`MOVWZ`,-`MOV[HB]Z` @@ -225,7 +225,7 @@ func load_be_byte8_uint64(s []byte) uint64 { func load_be_byte8_uint64_inv(s []byte) uint64 { // arm64:`MOVD \(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]` - // amd64/v1,amd64/v2:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` + // amd64/v1,amd64/v2:`MOVQ \([A-Z]+\), [A-Z]+`,`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` // amd64/v3: `MOVBEQ` // ppc64le:`MOVDBR \(R[0-9]+\)`,-`MOV[BHW]Z` // ppc64:`MOVD`,-`MOV[BHW]Z` @@ -233,136 +233,136 @@ func load_be_byte8_uint64_inv(s []byte) uint64 { } 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` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOVB` + // 386:`MOVWLZX \([A-Z]+\)\([A-Z]+`,-`ORL`,-`MOVB` + // amd64:`MOVWLZX \([A-Z]+\)\([A-Z]+`,-`MOVB`,-`OR` // ppc64le:`MOVHZ`,-`MOVBZ` // ppc64:`MOVHBR`,-`MOVBZ` return uint16(s[idx]) | uint16(s[idx+1])<<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` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOVB` + // 386:`MOVWLZX \([A-Z]+\)\([A-Z]+`,-`ORL`,-`MOVB` + // amd64:`MOVWLZX \([A-Z]+\)\([A-Z]+`,-`MOVB`,-`OR` // ppc64le:`MOVHZ`,-`MOVBZ` // ppc64:`MOVHBR`,-`MOVBZ` return uint16(s[idx+1])<<8 | uint16(s[idx]) } func load_le_byte4_uint32_idx(s []byte, idx int) uint32 { - // arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BH]` - // amd64:`MOVL\s\([A-Z]+\)\([A-Z]+`,-`MOV[BW]`,-`OR` + // arm64:`MOVWU \(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BH]` + // amd64:`MOVL \([A-Z]+\)\([A-Z]+`,-`MOV[BW]`,-`OR` return uint32(s[idx]) | uint32(s[idx+1])<<8 | uint32(s[idx+2])<<16 | uint32(s[idx+3])<<24 } func load_le_byte4_uint32_idx_inv(s []byte, idx int) uint32 { - // arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BH]` + // arm64:`MOVWU \(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BH]` return uint32(s[idx+3])<<24 | uint32(s[idx+2])<<16 | uint32(s[idx+1])<<8 | uint32(s[idx]) } func load_le_byte8_uint64_idx(s []byte, idx int) uint64 { - // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` - // amd64:`MOVQ\s\([A-Z]+\)\([A-Z]+`,-`MOV[BWL]`,-`OR` + // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` + // amd64:`MOVQ \([A-Z]+\)\([A-Z]+`,-`MOV[BWL]`,-`OR` return uint64(s[idx]) | uint64(s[idx+1])<<8 | uint64(s[idx+2])<<16 | uint64(s[idx+3])<<24 | uint64(s[idx+4])<<32 | uint64(s[idx+5])<<40 | uint64(s[idx+6])<<48 | uint64(s[idx+7])<<56 } func load_le_byte8_uint64_idx_inv(s []byte, idx int) uint64 { - // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` + // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` return uint64(s[idx+7])<<56 | uint64(s[idx+6])<<48 | uint64(s[idx+5])<<40 | uint64(s[idx+4])<<32 | uint64(s[idx+3])<<24 | uint64(s[idx+2])<<16 | uint64(s[idx+1])<<8 | uint64(s[idx]) } func load_be_byte2_uint16_idx(s []byte, idx int) uint16 { - // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` - // amd64:`MOVWLZX\s\([A-Z]+\)\([A-Z]+`,-`MOVB`,-`OR` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` + // amd64:`MOVWLZX \([A-Z]+\)\([A-Z]+`,-`MOVB`,-`OR` return uint16(s[idx])<<8 | uint16(s[idx+1]) } func load_be_byte2_uint16_idx_inv(s []byte, idx int) uint16 { - // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` - // amd64:`MOVWLZX\s\([A-Z]+\)\([A-Z]+`,-`MOVB`,-`OR` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` + // amd64:`MOVWLZX \([A-Z]+\)\([A-Z]+`,-`MOVB`,-`OR` return uint16(s[idx+1]) | uint16(s[idx])<<8 } func load_be_byte4_uint32_idx(s []byte, idx int) uint32 { - // arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+\)`,`REVW`,-`ORR`,-`MOV[BH]`,-`REV16W` + // arm64:`MOVWU \(R[0-9]+\)\(R[0-9]+\)`,`REVW`,-`ORR`,-`MOV[BH]`,-`REV16W` return uint32(s[idx])<<24 | uint32(s[idx+1])<<16 | uint32(s[idx+2])<<8 | uint32(s[idx+3]) } func load_be_byte8_uint64_idx(s []byte, idx int) uint64 { - // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\)`,`REV`,-`ORR`,-`MOV[BHW]`,-`REVW`,-`REV16W` + // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+\)`,`REV`,-`ORR`,-`MOV[BHW]`,-`REVW`,-`REV16W` return uint64(s[idx])<<56 | uint64(s[idx+1])<<48 | uint64(s[idx+2])<<40 | uint64(s[idx+3])<<32 | uint64(s[idx+4])<<24 | uint64(s[idx+5])<<16 | uint64(s[idx+6])<<8 | uint64(s[idx+7]) } func load_le_byte2_uint16_idx2(s []byte, idx int) uint16 { - // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+<<1\)`,-`ORR`,-`MOVB` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+<<1\)`,-`ORR`,-`MOVB` return uint16(s[idx<<1]) | uint16(s[(idx<<1)+1])<<8 } func load_le_byte2_uint16_idx2_inv(s []byte, idx int) uint16 { - // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+<<1\)`,-`ORR`,-`MOVB` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+<<1\)`,-`ORR`,-`MOVB` return uint16(s[(idx<<1)+1])<<8 | uint16(s[idx<<1]) } func load_le_byte4_uint32_idx4(s []byte, idx int) uint32 { - // arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+<<2\)`,-`ORR`,-`MOV[BH]` + // arm64:`MOVWU \(R[0-9]+\)\(R[0-9]+<<2\)`,-`ORR`,-`MOV[BH]` return uint32(s[idx<<2]) | uint32(s[(idx<<2)+1])<<8 | uint32(s[(idx<<2)+2])<<16 | uint32(s[(idx<<2)+3])<<24 } func load_le_byte4_uint32_idx4_inv(s []byte, idx int) uint32 { - // arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+<<2\)`,-`ORR`,-`MOV[BH]` + // arm64:`MOVWU \(R[0-9]+\)\(R[0-9]+<<2\)`,-`ORR`,-`MOV[BH]` return uint32(s[(idx<<2)+3])<<24 | uint32(s[(idx<<2)+2])<<16 | uint32(s[(idx<<2)+1])<<8 | uint32(s[idx<<2]) } func load_le_byte8_uint64_idx8(s []byte, idx int) uint64 { - // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+<<3\)`,-`ORR`,-`MOV[BHW]` + // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+<<3\)`,-`ORR`,-`MOV[BHW]` return uint64(s[idx<<3]) | uint64(s[(idx<<3)+1])<<8 | uint64(s[(idx<<3)+2])<<16 | uint64(s[(idx<<3)+3])<<24 | uint64(s[(idx<<3)+4])<<32 | uint64(s[(idx<<3)+5])<<40 | uint64(s[(idx<<3)+6])<<48 | uint64(s[(idx<<3)+7])<<56 } func load_le_byte8_uint64_idx8_inv(s []byte, idx int) uint64 { - // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+<<3\)`,-`ORR`,-`MOV[BHW]` + // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+<<3\)`,-`ORR`,-`MOV[BHW]` return uint64(s[(idx<<3)+7])<<56 | uint64(s[(idx<<3)+6])<<48 | uint64(s[(idx<<3)+5])<<40 | uint64(s[(idx<<3)+4])<<32 | uint64(s[(idx<<3)+3])<<24 | uint64(s[(idx<<3)+2])<<16 | uint64(s[(idx<<3)+1])<<8 | uint64(s[idx<<3]) } func load_be_byte2_uint16_idx2(s []byte, idx int) uint16 { - // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+<<1\)`,`REV16W`,-`ORR`,-`MOVB` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+<<1\)`,`REV16W`,-`ORR`,-`MOVB` return uint16(s[idx<<1])<<8 | uint16(s[(idx<<1)+1]) } func load_be_byte2_uint16_idx2_inv(s []byte, idx int) uint16 { - // arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+<<1\)`,`REV16W`,-`ORR`,-`MOVB` + // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+<<1\)`,`REV16W`,-`ORR`,-`MOVB` return uint16(s[(idx<<1)+1]) | uint16(s[idx<<1])<<8 } func load_be_byte4_uint32_idx4(s []byte, idx int) uint32 { - // arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+<<2\)`,`REVW`,-`ORR`,-`MOV[BH]`,-`REV16W` + // arm64:`MOVWU \(R[0-9]+\)\(R[0-9]+<<2\)`,`REVW`,-`ORR`,-`MOV[BH]`,-`REV16W` return uint32(s[idx<<2])<<24 | uint32(s[(idx<<2)+1])<<16 | uint32(s[(idx<<2)+2])<<8 | uint32(s[(idx<<2)+3]) } func load_be_byte8_uint64_idx8(s []byte, idx int) uint64 { - // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+<<3\)`,`REV`,-`ORR`,-`MOV[BHW]`,-`REVW`,-`REV16W` + // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+<<3\)`,`REV`,-`ORR`,-`MOV[BHW]`,-`REVW`,-`REV16W` return uint64(s[idx<<3])<<56 | uint64(s[(idx<<3)+1])<<48 | uint64(s[(idx<<3)+2])<<40 | uint64(s[(idx<<3)+3])<<32 | uint64(s[(idx<<3)+4])<<24 | uint64(s[(idx<<3)+5])<<16 | uint64(s[(idx<<3)+6])<<8 | uint64(s[(idx<<3)+7]) } // Some tougher cases for the memcombine pass. func reassoc_load_uint32(b []byte) uint32 { - // amd64:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR` + // amd64:`MOVL \([A-Z]+\)`,-`MOV[BW]`,-`OR` return (uint32(b[0]) | uint32(b[1])<<8) | (uint32(b[2])<<16 | uint32(b[3])<<24) } func extrashift_load_uint32(b []byte) uint32 { - // amd64:`MOVL\s\([A-Z]+\)`,`SHLL\s[$]2`,-`MOV[BW]`,-`OR` + // amd64:`MOVL \([A-Z]+\)`,`SHLL [$]2`,-`MOV[BW]`,-`OR` return uint32(b[0])<<2 | uint32(b[1])<<10 | uint32(b[2])<<18 | uint32(b[3])<<26 } func outoforder_load_uint32(b []byte) uint32 { - // amd64:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR` + // amd64:`MOVL \([A-Z]+\)`,-`MOV[BW]`,-`OR` return uint32(b[0]) | uint32(b[2])<<16 | uint32(b[1])<<8 | uint32(b[3])<<24 } func extraOr_load_uint32(b []byte, x, y uint32) uint32 { - // amd64:`ORL\s\([A-Z]+\)`,-`MOV[BW]` + // amd64:`ORL \([A-Z]+\)`,-`MOV[BW]` return x | binary.LittleEndian.Uint32(b) | y // TODO: Note that // x | uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 | y @@ -426,33 +426,33 @@ func safe_point(p, q *[2]*int) { // ------------- // func store_le64(b []byte, x uint64) { - // amd64:`MOVQ\s.*\(.*\)$`,-`SHR.` + // amd64:`MOVQ .*\(.*\)$`,-`SHR.` // arm64:`MOVD`,-`MOV[WBH]` - // ppc64le:`MOVD\s`,-`MOV[BHW]\s` - // ppc64:`MOVDBR`,-MOVB\s` - // s390x:`MOVDBR\s.*\(.*\)$` + // ppc64le:`MOVD `,-`MOV[BHW] ` + // ppc64:`MOVDBR`,-MOVB ` + // s390x:`MOVDBR .*\(.*\)$` binary.LittleEndian.PutUint64(b, x) } 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` + // amd64:`MOVQ .*\(.*\)\(.*\*1\)$`,-`SHR.` + // arm64:`MOVD R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]` + // ppc64le:`MOVD `,-`MOV[BHW] ` // ppc64:`MOVDBR`,-`MOVBZ` - // s390x:`MOVDBR\s.*\(.*\)\(.*\*1\)$` + // s390x:`MOVDBR .*\(.*\)\(.*\*1\)$` binary.LittleEndian.PutUint64(b[idx:], x) } func store_le64_idx2(dst []byte, d, length, offset int) []byte { a := dst[d : d+length] b := dst[d-offset:] - // amd64:`MOVQ\s.*\(.*\)\(.*\*1\)$`,-`SHR.` + // amd64:`MOVQ .*\(.*\)\(.*\*1\)$`,-`SHR.` binary.LittleEndian.PutUint64(a, binary.LittleEndian.Uint64(b)) return dst } func store_le64_idx_const(b []byte, idx int) { - // amd64:`MOVQ\s\$123, \(.*\)\(.*\*1\)$` + // amd64:`MOVQ \$123, \(.*\)\(.*\*1\)$` binary.LittleEndian.PutUint64(b[idx:], 123) } @@ -460,57 +460,57 @@ func store_le64_load(b []byte, x *[8]byte) { _ = b[8] // amd64:-`MOV[BWL]` // arm64:-`MOV[BWH]` - // ppc64le:`MOVD\s`,-`MOV[BWH]Z` + // ppc64le:`MOVD `,-`MOV[BWH]Z` // ppc64:`MOVDBR` // s390x:-`MOVB`,-`MOV[WH]BR` binary.LittleEndian.PutUint64(b, binary.LittleEndian.Uint64(x[:])) } func store_le32(b []byte, x uint32) { - // amd64:`MOVL\s` + // amd64:`MOVL ` // arm64:`MOVW`,-`MOV[BH]` - // ppc64le:`MOVW\s` + // ppc64le:`MOVW ` // ppc64:`MOVWBR` - // s390x:`MOVWBR\s.*\(.*\)$` + // s390x:`MOVWBR .*\(.*\)$` binary.LittleEndian.PutUint32(b, x) } 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` + // amd64:`MOVL ` + // arm64:`MOVW R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]` + // ppc64le:`MOVW ` // ppc64:`MOVWBR` - // s390x:`MOVWBR\s.*\(.*\)\(.*\*1\)$` + // s390x:`MOVWBR .*\(.*\)\(.*\*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]` + // amd64:`MOVL \$123, \(.*\)\(.*\*1\)$` + // ppc64x:`MOVW `,-`MOV[HB]` binary.LittleEndian.PutUint32(b[idx:], 123) } func store_le16(b []byte, x uint16) { - // amd64:`MOVW\s` + // amd64:`MOVW ` // arm64:`MOVH`,-`MOVB` - // ppc64le:`MOVH\s` + // ppc64le:`MOVH ` // ppc64:`MOVHBR` - // s390x:`MOVHBR\s.*\(.*\)$` + // s390x:`MOVHBR .*\(.*\)$` binary.LittleEndian.PutUint16(b, x) } 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\)$` + // amd64:`MOVW ` + // arm64:`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB` + // ppc64le:`MOVH ` + // ppc64:`MOVHBR ` + // s390x:`MOVHBR .*\(.*\)\(.*\*1\)$` binary.LittleEndian.PutUint16(b[idx:], x) } func store_le16_idx_const(b []byte, idx int) { - // amd64:`MOVW\s\$123, \(.*\)\(.*\*1\)$` - // ppc64x:`MOVH\s` + // amd64:`MOVW \$123, \(.*\)\(.*\*1\)$` + // ppc64x:`MOVH ` binary.LittleEndian.PutUint16(b[idx:], 123) } @@ -519,18 +519,18 @@ 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` + // ppc64:`MOVD ` + // s390x:`MOVD .*\(.*\)$`,-`SRW `,-`SRD ` binary.BigEndian.PutUint64(b, x) } func store_be64_idx(b []byte, x uint64, idx int) { // amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.` // amd64/v3:`MOVBEQ [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` + // arm64:`REV`,`MOVD R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`,-`REV16W`,-`REVW` // ppc64le:`MOVDBR` - // ppc64:`MOVD\s` - // s390x:`MOVD\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s` + // ppc64:`MOVD ` + // s390x:`MOVD .*\(.*\)\(.*\*1\)$`,-`SRW `,-`SRD ` binary.BigEndian.PutUint64(b[idx:], x) } @@ -539,8 +539,8 @@ 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` + // ppc64:`MOVW ` + // s390x:`MOVW .*\(.*\)$`,-`SRW `,-`SRD ` binary.BigEndian.PutUint32(b, x) } @@ -559,96 +559,96 @@ func store_be32_load(b, x *[8]byte) { func store_be32_idx(b []byte, x uint32, idx int) { // amd64/v1,amd64/v2:`BSWAPL`,-`SHR.` // amd64/v3:`MOVBEL [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` + // arm64:`REVW`,`MOVW R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`,-`REV16W` // ppc64le:`MOVWBR` - // ppc64:`MOVW\s` - // s390x:`MOVW\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s` + // ppc64:`MOVW ` + // s390x:`MOVW .*\(.*\)\(.*\*1\)$`,-`SRW `,-`SRD ` binary.BigEndian.PutUint32(b[idx:], x) } func store_be16(b []byte, x uint16) { - // amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.` + // amd64/v1,amd64/v2:`ROLW \$8`,-`SHR.` // amd64/v3:`MOVBEW`,-`ROLW` // arm64:`MOVH`,`REV16W`,-`MOVB` // ppc64le:`MOVHBR` - // ppc64:`MOVH\s` - // s390x:`MOVH\s.*\(.*\)$`,-`SRW\s`,-`SRD\s` + // ppc64:`MOVH ` + // s390x:`MOVH .*\(.*\)$`,-`SRW `,-`SRD ` binary.BigEndian.PutUint16(b, x) } func store_be16_idx(b []byte, x uint16, idx int) { - // amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.` + // amd64/v1,amd64/v2:`ROLW \$8`,-`SHR.` // amd64/v3:`MOVBEW [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` + // arm64:`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`MOVB` // ppc64le:`MOVHBR` - // ppc64:`MOVH\s` - // s390x:`MOVH\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s` + // ppc64:`MOVH ` + // s390x:`MOVH .*\(.*\)\(.*\*1\)$`,-`SRW `,-`SRD ` binary.BigEndian.PutUint16(b[idx:], x) } func store_le_byte_2(b []byte, val uint16) { _ = b[2] - // 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` + // arm64:`MOVH R[0-9]+, 1\(R[0-9]+\)`,-`MOVB` + // 386:`MOVW [A-Z]+, 1\([A-Z]+\)`,-`MOVB` + // amd64:`MOVW [A-Z]+, 1\([A-Z]+\)`,-`MOVB` + // ppc64le:`MOVH `,-`MOVB` // ppc64:`MOVHBR`,-`MOVB` b[1], b[2] = byte(val), byte(val>>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` + // 386:`MOVW [A-Z]+, 1\([A-Z]+\)`,-`MOVB` + // amd64:`MOVW [A-Z]+, 1\([A-Z]+\)`,-`MOVB` + // ppc64le:`MOVH `,-`MOVB` // ppc64:`MOVHBR`,-`MOVB` b[2], b[1] = byte(val>>8), byte(val) } func store_le_byte_4(b []byte, val uint32) { _ = b[4] - // 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` + // arm64:`MOVW R[0-9]+, 1\(R[0-9]+\)`,-`MOVB`,-`MOVH` + // 386:`MOVL [A-Z]+, 1\([A-Z]+\)`,-`MOVB`,-`MOVW` + // amd64:`MOVL [A-Z]+, 1\([A-Z]+\)`,-`MOVB`,-`MOVW` + // ppc64le:`MOVW ` + // ppc64:`MOVWBR ` b[1], b[2], b[3], b[4] = byte(val), byte(val>>8), byte(val>>16), byte(val>>24) } 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` + // arm64:`MOVD R[0-9]+, 1\(R[0-9]+\)`,-`MOVB`,-`MOVH`,-`MOVW` + // amd64:`MOVQ [A-Z]+, 1\([A-Z]+\)`,-`MOVB`,-`MOVW`,-`MOVL` + // ppc64le:`MOVD `,-`MOVW` + // ppc64:`MOVDBR ` 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) } func store_be_byte_2(b []byte, val uint16) { _ = b[2] - // arm64:`REV16W`,`MOVH\sR[0-9]+,\s1\(R[0-9]+\)`,-`MOVB` - // amd64/v1,amd64/v2:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB` + // arm64:`REV16W`,`MOVH R[0-9]+, 1\(R[0-9]+\)`,-`MOVB` + // amd64/v1,amd64/v2:`MOVW [A-Z]+, 1\([A-Z]+\)`,-`MOVB` // amd64/v3: `MOVBEW` // ppc64le:`MOVHBR` - // ppc64:`MOVH\s` + // ppc64:`MOVH ` b[1], b[2] = byte(val>>8), byte(val) } func store_be_byte_4(b []byte, val uint32) { _ = b[4] - // 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]+\)` + // arm64:`REVW`,`MOVW R[0-9]+, 1\(R[0-9]+\)`,-`MOVB`,-`MOVH`,-`REV16W` + // amd64/v1,amd64/v2:`MOVL [A-Z]+, 1\([A-Z]+\)`,-`MOVB`,-`MOVW` + // amd64/v3:`MOVBEL [A-Z]+, 1\([A-Z]+\)` // ppc64le:`MOVWBR` - // ppc64:`MOVW\s` + // ppc64:`MOVW ` b[1], b[2], b[3], b[4] = byte(val>>24), byte(val>>16), byte(val>>8), byte(val) } func store_be_byte_8(b []byte, val uint64) { _ = b[8] - // 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` + // arm64:`REV`,`MOVD R[0-9]+, 1\(R[0-9]+\)`,-`MOVB`,-`MOVH`,-`MOVW`,-`REV16W`,-`REVW` + // amd64/v1,amd64/v2:`MOVQ [A-Z]+, 1\([A-Z]+\)`,-`MOVB`,-`MOVW`,-`MOVL` + // amd64/v3:`MOVBEQ [A-Z]+, 1\([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) @@ -656,73 +656,73 @@ func store_be_byte_8(b []byte, val uint64) { 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` + // arm64:`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB` + // 386:`MOVW [A-Z]+, \([A-Z]+\)\([A-Z]+`,-`MOVB` + // ppc64le:`MOVH ` // 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` + // 386:`MOVW [A-Z]+, \([A-Z]+\)\([A-Z]+`,-`MOVB` + // ppc64le:`MOVH ` // 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` + // arm64:`MOVW R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`,-`MOVH` + // ppc64le:`MOVW ` // 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` + // arm64:`REV16W`,`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB` // ppc64le:`MOVHBR` - // ppc64:`MOVH\s` + // ppc64:`MOVH ` 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` + // arm64:`REVW`,`MOVW R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`,-`MOVH`,-`REV16W` // ppc64le:`MOVWBR` - // ppc64:`MOVW\s` + // ppc64:`MOVW ` 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` + // arm64:`REV16W`,`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+<<1\)`,-`MOVB` // ppc64le:`MOVHBR` - // ppc64:`MOVH\s` + // ppc64:`MOVH ` 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` + // arm64:`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+<<1\)`,-`MOVB` + // ppc64le:`MOVH ` // 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` + // arm64:`REVW`,`MOVW R[0-9]+, \(R[0-9]+\)\(R[0-9]+<<2\)`,-`MOVB`,-`MOVH`,-`REV16W` // ppc64le:`MOVWBR` - // ppc64:`MOVW\s` + // ppc64:`MOVW ` 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` + // arm64:`MOVW R[0-9]+, \(R[0-9]+\)\(R[0-9]+<<2\)`,-`MOVB`,-`MOVH` + // ppc64le:`MOVW ` // 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) } @@ -737,13 +737,13 @@ func zero_byte_2(b1, b2 []byte) { // bounds checks to guarantee safety of writes below _, _ = b1[1], b2[1] // arm64:"MOVH ZR" -"MOVB" - // amd64:`MOVW\s[$]0,\s\([A-Z]+\)` - // 386:`MOVW\s[$]0,\s\([A-Z]+\)` - // ppc64x:`MOVH\s` + // amd64:`MOVW [$]0, \([A-Z]+\)` + // 386:`MOVW [$]0, \([A-Z]+\)` + // ppc64x:`MOVH ` b1[0], b1[1] = 0, 0 // arm64:"MOVH ZR" -"MOVB" - // 386:`MOVW\s[$]0,\s\([A-Z]+\)` - // amd64:`MOVW\s[$]0,\s\([A-Z]+\)` + // 386:`MOVW [$]0, \([A-Z]+\)` + // amd64:`MOVW [$]0, \([A-Z]+\)` // ppc64x:`MOVH` b2[1], b2[0] = 0, 0 } @@ -751,12 +751,12 @@ func zero_byte_2(b1, b2 []byte) { func zero_byte_4(b1, b2 []byte) { _, _ = b1[3], b2[3] // arm64:"MOVW ZR" -"MOVB" -"MOVH" - // amd64:`MOVL\s[$]0,\s\([A-Z]+\)` - // 386:`MOVL\s[$]0,\s\([A-Z]+\)` - // ppc64x:`MOVW\s` + // amd64:`MOVL [$]0, \([A-Z]+\)` + // 386:`MOVL [$]0, \([A-Z]+\)` + // ppc64x:`MOVW ` b1[0], b1[1], b1[2], b1[3] = 0, 0, 0, 0 // arm64:"MOVW ZR" -"MOVB" -"MOVH" - // ppc64x:`MOVW\s` + // ppc64x:`MOVW ` b2[2], b2[3], b2[1], b2[0] = 0, 0, 0, 0 } @@ -784,28 +784,28 @@ 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` + // arm64:`MOVH ZR, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB` + // ppc64x:`MOVH ` 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` + // arm64:`MOVH ZR, \(R[0-9]+\)\(R[0-9]+<<1\)`,-`MOVB` + // ppc64x:`MOVH ` b[(idx<<1)+0], b[(idx<<1)+1] = 0, 0 } func zero_uint16_2(h1, h2 []uint16) { _, _ = h1[1], h2[1] // arm64:"MOVW ZR" -"MOVB" -"MOVH" - // amd64:`MOVL\s[$]0,\s\([A-Z]+\)` - // 386:`MOVL\s[$]0,\s\([A-Z]+\)` - // ppc64x:`MOVW\s` + // amd64:`MOVL [$]0, \([A-Z]+\)` + // 386:`MOVL [$]0, \([A-Z]+\)` + // ppc64x:`MOVW ` h1[0], h1[1] = 0, 0 // arm64:"MOVW ZR" -"MOVB" -"MOVH" - // amd64:`MOVL\s[$]0,\s\([A-Z]+\)` - // 386:`MOVL\s[$]0,\s\([A-Z]+\)` + // amd64:`MOVL [$]0, \([A-Z]+\)` + // 386:`MOVL [$]0, \([A-Z]+\)` // ppc64x:`MOVW` h2[1], h2[0] = 0, 0 } @@ -813,11 +813,11 @@ func zero_uint16_2(h1, h2 []uint16) { func zero_uint16_4(h1, h2 []uint16) { _, _ = h1[3], h2[3] // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" - // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)` - // ppc64x:`MOVD\s` + // amd64:`MOVQ [$]0, \([A-Z]+\)` + // ppc64x:`MOVD ` h1[0], h1[1], h1[2], h1[3] = 0, 0, 0, 0 // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" - // ppc64x:`MOVD\s` + // ppc64x:`MOVD ` h2[2], h2[3], h2[1], h2[0] = 0, 0, 0, 0 } @@ -830,12 +830,12 @@ func zero_uint16_8(h []uint16) { func zero_uint32_2(w1, w2 []uint32) { _, _ = w1[1], w2[1] // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" - // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)` - // ppc64x:`MOVD\s` + // amd64:`MOVQ [$]0, \([A-Z]+\)` + // ppc64x:`MOVD ` w1[0], w1[1] = 0, 0 // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" - // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)` - // ppc64x:`MOVD\s` + // amd64:`MOVQ [$]0, \([A-Z]+\)` + // ppc64x:`MOVD ` w2[1], w2[0] = 0, 0 } @@ -1065,9 +1065,9 @@ func dwstoreBig(p *struct{ a, b, c, d, e, f int64 }, a, b, c, d, e, f int64) { // This is not perfect. We merge b+a, then d+e, then c and f have no pair. p.c = c p.f = f - // arm64:`STP\s\(R[0-9]+, R[0-9]+\), \(R[0-9]+\)` + // arm64:`STP \(R[0-9]+, R[0-9]+\), \(R[0-9]+\)` p.a = a - // arm64:`STP\s\(R[0-9]+, R[0-9]+\), 24\(R[0-9]+\)` + // arm64:`STP \(R[0-9]+, R[0-9]+\), 24\(R[0-9]+\)` p.e = e p.d = d p.b = b |