aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/codegen/arithmetic.go76
-rw-r--r--test/codegen/bits.go6
-rw-r--r--test/codegen/bool.go22
-rw-r--r--test/codegen/comparisons.go6
-rw-r--r--test/codegen/floats.go8
-rw-r--r--test/codegen/issue59297.go2
-rw-r--r--test/codegen/issue60673.go2
-rw-r--r--test/codegen/issue68845.go10
-rw-r--r--test/codegen/issue69635.go2
-rw-r--r--test/codegen/issue72832.go4
-rw-r--r--test/codegen/issue74788.go4
-rw-r--r--test/codegen/issue75203.go11
-rw-r--r--test/codegen/logic.go2
-rw-r--r--test/codegen/memcombine.go428
-rw-r--r--test/codegen/memops_bigoffset.go64
-rw-r--r--test/codegen/noextend.go60
-rw-r--r--test/codegen/simd.go26
-rw-r--r--test/codegen/spills.go2
-rw-r--r--test/codegen/switch.go32
-rw-r--r--test/codegen/unsafe.go4
-rw-r--r--test/codegen/writebarrier.go6
21 files changed, 388 insertions, 389 deletions
diff --git a/test/codegen/arithmetic.go b/test/codegen/arithmetic.go
index 867b08a55e..a73ed6ed55 100644
--- a/test/codegen/arithmetic.go
+++ b/test/codegen/arithmetic.go
@@ -59,25 +59,25 @@ func AddLargeConst2(a int, out []int) {
var ef int
func SubMem(arr []int, b, c, d int) int {
- // 386:`SUBL\s[A-Z]+,\s8\([A-Z]+\)`
- // amd64:`SUBQ\s[A-Z]+,\s16\([A-Z]+\)`
+ // 386:`SUBL [A-Z]+, 8\([A-Z]+\)`
+ // amd64:`SUBQ [A-Z]+, 16\([A-Z]+\)`
arr[2] -= b
- // 386:`SUBL\s[A-Z]+,\s12\([A-Z]+\)`
- // amd64:`SUBQ\s[A-Z]+,\s24\([A-Z]+\)`
+ // 386:`SUBL [A-Z]+, 12\([A-Z]+\)`
+ // amd64:`SUBQ [A-Z]+, 24\([A-Z]+\)`
arr[3] -= b
- // 386:`DECL\s16\([A-Z]+\)`
+ // 386:`DECL 16\([A-Z]+\)`
arr[4]--
- // 386:`ADDL\s[$]-20,\s20\([A-Z]+\)`
+ // 386:`ADDL [$]-20, 20\([A-Z]+\)`
arr[5] -= 20
- // 386:`SUBL\s\([A-Z]+\)\([A-Z]+\*4\),\s[A-Z]+`
+ // 386:`SUBL \([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
ef -= arr[b]
- // 386:`SUBL\s[A-Z]+,\s\([A-Z]+\)\([A-Z]+\*4\)`
+ // 386:`SUBL [A-Z]+, \([A-Z]+\)\([A-Z]+\*4\)`
arr[c] -= b
- // 386:`ADDL\s[$]-15,\s\([A-Z]+\)\([A-Z]+\*4\)`
+ // 386:`ADDL [$]-15, \([A-Z]+\)\([A-Z]+\*4\)`
arr[d] -= 15
- // 386:`DECL\s\([A-Z]+\)\([A-Z]+\*4\)`
+ // 386:`DECL \([A-Z]+\)\([A-Z]+\*4\)`
arr[b]--
- // amd64:`DECQ\s64\([A-Z]+\)`
+ // amd64:`DECQ 64\([A-Z]+\)`
arr[8]--
// 386:"SUBL 4"
// amd64:"SUBQ 8"
@@ -85,7 +85,7 @@ func SubMem(arr []int, b, c, d int) int {
}
func SubFromConst(a int) int {
- // ppc64x: `SUBC R[0-9]+,\s[$]40,\sR`
+ // ppc64x: `SUBC R[0-9]+, [$]40, R`
// riscv64: "ADDI [$]-40" "NEG"
b := 40 - a
return b
@@ -96,7 +96,7 @@ func SubFromConstNeg(a int) int {
// loong64: "ADDV[U] [$]40"
// mips: "ADD[U] [$]40"
// mips64: "ADDV[U] [$]40"
- // ppc64x: `ADD [$]40,\sR[0-9]+,\sR`
+ // ppc64x: `ADD [$]40, R[0-9]+, R`
// riscv64: "ADDI [$]40" -"NEG"
c := 40 - (-a)
return c
@@ -107,14 +107,14 @@ func SubSubFromConst(a int) int {
// loong64: "ADDV[U] [$]20"
// mips: "ADD[U] [$]20"
// mips64: "ADDV[U] [$]20"
- // ppc64x: `ADD [$]20,\sR[0-9]+,\sR`
+ // ppc64x: `ADD [$]20, R[0-9]+, R`
// riscv64: "ADDI [$]20" -"NEG"
c := 40 - (20 - a)
return c
}
func AddSubFromConst(a int) int {
- // ppc64x: `SUBC R[0-9]+,\s[$]60,\sR`
+ // ppc64x: `SUBC R[0-9]+, [$]60, R`
// riscv64: "ADDI [$]-60" "NEG"
c := 40 + (20 - a)
return c
@@ -125,7 +125,7 @@ func NegSubFromConst(a int) int {
// loong64: "ADDV[U] [$]-20"
// mips: "ADD[U] [$]-20"
// mips64: "ADDV[U] [$]-20"
- // ppc64x: `ADD [$]-20,\sR[0-9]+,\sR`
+ // ppc64x: `ADD [$]-20, R[0-9]+, R`
// riscv64: "ADDI [$]-20"
c := -(20 - a)
return c
@@ -136,7 +136,7 @@ func NegAddFromConstNeg(a int) int {
// loong64: "ADDV[U] [$]-40" "SUBV"
// mips: "ADD[U] [$]-40" "SUB"
// mips64: "ADDV[U] [$]-40" "SUBV"
- // ppc64x: `SUBC R[0-9]+,\s[$]40,\sR`
+ // ppc64x: `SUBC R[0-9]+, [$]40, R`
// riscv64: "ADDI [$]-40" "NEG"
c := -(-40 + a)
return c
@@ -242,9 +242,9 @@ func Pow2Muls(n1, n2 int) (int, int) {
// amd64:"SHLQ [$]6" -"IMULQ"
// 386:"SHLL [$]6" -"IMULL"
// arm:"SLL [$]6" -"MUL"
- // arm64:`NEG\sR[0-9]+<<6,\sR[0-9]+`,-`LSL`,-`MUL`
+ // arm64:`NEG R[0-9]+<<6, R[0-9]+`,-`LSL`,-`MUL`
// loong64:"SLLV [$]6" -"MULV"
- // ppc64x:"SLD [$]6" "NEG\\sR[0-9]+,\\sR[0-9]+" -"MUL"
+ // ppc64x:"SLD [$]6" "NEG R[0-9]+, R[0-9]+" -"MUL"
b := -64 * n2
return a, b
@@ -262,8 +262,8 @@ func Mul_2(n1 int32, n2 int64) (int32, int64) {
func Mul_96(n int) int {
// amd64:`SHLQ [$]5`,`LEAQ \(.*\)\(.*\*2\),`,-`IMULQ`
// 386:`SHLL [$]5`,`LEAL \(.*\)\(.*\*2\),`,-`IMULL`
- // arm64:`LSL [$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
- // arm:`SLL [$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
+ // arm64:`LSL [$]5`,`ADD R[0-9]+<<1, R[0-9]+`,-`MUL`
+ // arm:`SLL [$]5`,`ADD R[0-9]+<<1, R[0-9]+`,-`MUL`
// loong64:"SLLV [$]5" "ALSLV [$]1,"
// s390x:`SLD [$]5`,`SLD [$]6`,-`MULLD`
return n * 96
@@ -276,10 +276,10 @@ func Mul_n120(n int) int {
}
func MulMemSrc(a []uint32, b []float32) {
- // 386:`IMULL\s4\([A-Z]+\),\s[A-Z]+`
+ // 386:`IMULL 4\([A-Z]+\), [A-Z]+`
a[0] *= a[1]
- // 386/sse2:`MULSS\s4\([A-Z]+\),\sX[0-9]+`
- // amd64:`MULSS\s4\([A-Z]+\),\sX[0-9]+`
+ // 386/sse2:`MULSS 4\([A-Z]+\), X[0-9]+`
+ // amd64:`MULSS 4\([A-Z]+\), X[0-9]+`
b[0] *= b[1]
}
@@ -370,8 +370,8 @@ func SimplifyNegMul(a, b int) int {
// -------------- //
func DivMemSrc(a []float64) {
- // 386/sse2:`DIVSD\s8\([A-Z]+\),\sX[0-9]+`
- // amd64:`DIVSD\s8\([A-Z]+\),\sX[0-9]+`
+ // 386/sse2:`DIVSD 8\([A-Z]+\), X[0-9]+`
+ // amd64:`DIVSD 8\([A-Z]+\), X[0-9]+`
a[0] /= a[1]
}
@@ -411,8 +411,8 @@ func ConstDivs(n1 uint, n2 int) (uint, int) {
}
func FloatDivs(a []float32) float32 {
- // amd64:`DIVSS\s8\([A-Z]+\),\sX[0-9]+`
- // 386/sse2:`DIVSS\s8\([A-Z]+\),\sX[0-9]+`
+ // amd64:`DIVSS 8\([A-Z]+\), X[0-9]+`
+ // 386/sse2:`DIVSS 8\([A-Z]+\), X[0-9]+`
return a[1] / a[2]
}
@@ -669,13 +669,13 @@ func AddShift(a, b int) int {
}
func MULA(a, b, c uint32) (uint32, uint32, uint32) {
- // arm:`MULA`,-`MUL\s`
+ // arm:`MULA`,-`MUL `
// arm64:`MADDW`,-`MULW`
r0 := a*b + c
- // arm:`MULA`,-`MUL\s`
+ // arm:`MULA`,-`MUL `
// arm64:`MADDW`,-`MULW`
r1 := c*79 + a
- // arm:`ADD`,-`MULA`,-`MUL\s`
+ // arm:`ADD`,-`MULA`,-`MUL `
// arm64:`ADD`,-`MADD`,-`MULW`
// ppc64x:`ADD`,-`MULLD`
r2 := b*64 + c
@@ -683,15 +683,15 @@ func MULA(a, b, c uint32) (uint32, uint32, uint32) {
}
func MULS(a, b, c uint32) (uint32, uint32, uint32) {
- // arm/7:`MULS`,-`MUL\s`
- // arm/6:`SUB`,`MUL\s`,-`MULS`
+ // arm/7:`MULS`,-`MUL `
+ // arm/6:`SUB`,`MUL `,-`MULS`
// arm64:`MSUBW`,-`MULW`
r0 := c - a*b
- // arm/7:`MULS`,-`MUL\s`
- // arm/6:`SUB`,`MUL\s`,-`MULS`
+ // arm/7:`MULS`,-`MUL `
+ // arm/6:`SUB`,`MUL `,-`MULS`
// arm64:`MSUBW`,-`MULW`
r1 := a - c*79
- // arm/7:`SUB`,-`MULS`,-`MUL\s`
+ // arm/7:`SUB`,-`MULS`,-`MUL `
// arm64:`SUB`,-`MSUBW`,-`MULW`
// ppc64x:`SUB`,-`MULLD`
r2 := c - b*64
@@ -741,10 +741,10 @@ func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
// "(C - z) - x -> C - (z + x)" can optimize the following cases.
func constantFold2(i0, j0, i1, j1 int) (int, int) {
// arm64:"ADD" "MOVD [$]2" "SUB"
- // ppc64x: `SUBC R[0-9]+,\s[$]2,\sR`
+ // ppc64x: `SUBC R[0-9]+, [$]2, R`
r0 := (3 - i0) - (j0 + 1)
// arm64:"ADD" "MOVD [$]4" "SUB"
- // ppc64x: `SUBC R[0-9]+,\s[$]4,\sR`
+ // ppc64x: `SUBC R[0-9]+, [$]4, R`
r1 := (3 - i1) - (j1 - 1)
return r0, r1
}
diff --git a/test/codegen/bits.go b/test/codegen/bits.go
index c5bce3d318..07e12d3131 100644
--- a/test/codegen/bits.go
+++ b/test/codegen/bits.go
@@ -445,11 +445,11 @@ func bitsFlipU32(a, b uint32) (n uint32) {
func bitsOpOnMem(a []uint32, b, c, d uint32) {
// check direct operation on memory with constant
- // amd64:`ANDL\s[$]200,\s\([A-Z][A-Z0-9]+\)`
+ // amd64:`ANDL [$]200, \([A-Z][A-Z0-9]+\)`
a[0] &= 200
- // amd64:`ORL\s[$]220,\s4\([A-Z][A-Z0-9]+\)`
+ // amd64:`ORL [$]220, 4\([A-Z][A-Z0-9]+\)`
a[1] |= 220
- // amd64:`XORL\s[$]240,\s8\([A-Z][A-Z0-9]+\)`
+ // amd64:`XORL [$]240, 8\([A-Z][A-Z0-9]+\)`
a[2] ^= 240
}
diff --git a/test/codegen/bool.go b/test/codegen/bool.go
index 453b4c6652..e201f0a969 100644
--- a/test/codegen/bool.go
+++ b/test/codegen/bool.go
@@ -242,52 +242,52 @@ func TestSetInvGeFp64(x float64, y float64) bool {
return b
}
func TestLogicalCompareZero(x *[64]uint64) {
- // ppc64x:"ANDCC",-"AND\\s"
+ // ppc64x:"ANDCC",-"AND "
b := x[0] & 3
if b != 0 {
x[0] = b
}
- // ppc64x:"ANDCC",-"AND\\s"
+ // ppc64x:"ANDCC",-"AND "
b = x[1] & x[2]
if b != 0 {
x[1] = b
}
- // ppc64x:"ANDNCC",-"ANDN\\s"
+ // ppc64x:"ANDNCC",-"ANDN "
b = x[1] &^ x[2]
if b != 0 {
x[1] = b
}
- // ppc64x:"ORCC",-"OR\\s"
+ // ppc64x:"ORCC",-"OR "
b = x[3] | x[4]
if b != 0 {
x[3] = b
}
- // ppc64x:"SUBCC",-"SUB\\s"
+ // ppc64x:"SUBCC",-"SUB "
b = x[5] - x[6]
if b != 0 {
x[5] = b
}
- // ppc64x:"NORCC",-"NOR\\s"
+ // ppc64x:"NORCC",-"NOR "
b = ^(x[5] | x[6])
if b != 0 {
x[5] = b
}
- // ppc64x:"XORCC",-"XOR\\s"
+ // ppc64x:"XORCC",-"XOR "
b = x[7] ^ x[8]
if b != 0 {
x[7] = b
}
- // ppc64x:"ADDCC",-"ADD\\s"
+ // ppc64x:"ADDCC",-"ADD "
b = x[9] + x[10]
if b != 0 {
x[9] = b
}
- // ppc64x:"NEGCC",-"NEG\\s"
+ // ppc64x:"NEGCC",-"NEG "
b = -x[11]
if b != 0 {
x[11] = b
}
- // ppc64x:"CNTLZDCC",-"CNTLZD\\s"
+ // ppc64x:"CNTLZDCC",-"CNTLZD "
b = uint64(bits.LeadingZeros64(x[12]))
if b != 0 {
x[12] = b
@@ -299,7 +299,7 @@ func TestLogicalCompareZero(x *[64]uint64) {
x[12] = uint64(c)
}
- // ppc64x:"MULHDUCC",-"MULHDU\\s"
+ // ppc64x:"MULHDUCC",-"MULHDU "
hi, _ := bits.Mul64(x[13], x[14])
if hi != 0 {
x[14] = hi
diff --git a/test/codegen/comparisons.go b/test/codegen/comparisons.go
index e05877ea46..d3cb2c1921 100644
--- a/test/codegen/comparisons.go
+++ b/test/codegen/comparisons.go
@@ -173,8 +173,8 @@ func CmpMem5(p **int) {
}
func CmpMem6(a []int) int {
- // 386:`CMPL\s8\([A-Z]+\),`
- // amd64:`CMPQ\s16\([A-Z]+\),`
+ // 386:`CMPL 8\([A-Z]+\),`
+ // amd64:`CMPQ 16\([A-Z]+\),`
if a[1] > a[2] {
return 1
} else {
@@ -237,7 +237,7 @@ func CmpToZero(a, b, d int32, e, f int64, deOptC0, deOptC1 bool) int32 {
c7 := e&(f<<3) < 0
// For arm64, could be CMN+BPL or ADD+TBZ
c8 := e+(f<<3) < 0
- // arm64:`TST\sR[0-9],\sR[0-9]+`
+ // arm64:`TST R[0-9], R[0-9]+`
c9 := e&(-19) < 0
if c0 {
return 1
diff --git a/test/codegen/floats.go b/test/codegen/floats.go
index ad9713b75f..b93c17af41 100644
--- a/test/codegen/floats.go
+++ b/test/codegen/floats.go
@@ -59,14 +59,14 @@ func DivPow2(f1, f2, f3 float64) (float64, float64, float64) {
}
func indexLoad(b0 []float32, b1 float32, idx int) float32 {
- // arm64:`FMOVS\s\(R[0-9]+\)\(R[0-9]+<<2\),\sF[0-9]+`
- // loong64:`MOVF\s\(R[0-9]+\)\(R[0-9]+\),\sF[0-9]+`
+ // arm64:`FMOVS \(R[0-9]+\)\(R[0-9]+<<2\), F[0-9]+`
+ // loong64:`MOVF \(R[0-9]+\)\(R[0-9]+\), F[0-9]+`
return b0[idx] * b1
}
func indexStore(b0 []float64, b1 float64, idx int) {
- // arm64:`FMOVD\sF[0-9]+,\s\(R[0-9]+\)\(R[0-9]+<<3\)`
- // loong64:`MOVD\sF[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`
+ // arm64:`FMOVD F[0-9]+, \(R[0-9]+\)\(R[0-9]+<<3\)`
+ // loong64:`MOVD F[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`
b0[idx] = b1
}
diff --git a/test/codegen/issue59297.go b/test/codegen/issue59297.go
index 1703a1a863..91ea462791 100644
--- a/test/codegen/issue59297.go
+++ b/test/codegen/issue59297.go
@@ -7,7 +7,7 @@
package codegen
func f(x, y int, p *int) {
- // amd64:`MOVQ\sAX, BX`
+ // amd64:`MOVQ AX, BX`
h(8, x)
*p = y
}
diff --git a/test/codegen/issue60673.go b/test/codegen/issue60673.go
index 2df031a9cf..b57274319a 100644
--- a/test/codegen/issue60673.go
+++ b/test/codegen/issue60673.go
@@ -13,6 +13,6 @@ func f(x int32) {
func g(p *int32) {
// argument marshaling code should live at line 17, not line 15.
x := *p
- // 386: `MOVL\s[A-Z]+,\s\(SP\)`
+ // 386: `MOVL [A-Z]+, \(SP\)`
f(x)
}
diff --git a/test/codegen/issue68845.go b/test/codegen/issue68845.go
index 3b22471d06..b5ab4a0fc8 100644
--- a/test/codegen/issue68845.go
+++ b/test/codegen/issue68845.go
@@ -11,7 +11,7 @@ type T1 struct {
}
func f1() *T1 {
- // amd64:-`MOVQ\s[$]0`,-`MOVUPS\sX15`
+ // amd64:-`MOVQ [$]0`,-`MOVUPS X15`
return &T1{}
}
@@ -20,7 +20,7 @@ type T2 struct {
}
func f2() *T2 {
- // amd64:-`MOVQ\s[$]0`,-`MOVUPS\sX15`
+ // amd64:-`MOVQ [$]0`,-`MOVUPS X15`
return &T2{}
}
@@ -29,7 +29,7 @@ type T3 struct {
}
func f3() *T3 {
- // amd64:-`MOVQ\s[$]0`,-`MOVUPS\sX15`
+ // amd64:-`MOVQ [$]0`,-`MOVUPS X15`
return &T3{}
}
@@ -38,7 +38,7 @@ type T4 struct {
}
func f4() *T4 {
- // amd64:-`MOVQ\s[$]0`,-`MOVUPS\sX15`
+ // amd64:-`MOVQ [$]0`,-`MOVUPS X15`
return &T4{}
}
@@ -47,6 +47,6 @@ type T5 struct {
}
func f5() *T5 {
- // amd64:-`MOVQ\s[$]0`,-`MOVUPS\sX15`
+ // amd64:-`MOVQ [$]0`,-`MOVUPS X15`
return &T5{}
}
diff --git a/test/codegen/issue69635.go b/test/codegen/issue69635.go
index de68bf1287..5fc269b315 100644
--- a/test/codegen/issue69635.go
+++ b/test/codegen/issue69635.go
@@ -8,6 +8,6 @@ package codegen
func calc(a uint64) uint64 {
v := a >> 20 & 0x7f
- // amd64: `SHRQ\s\$17, AX$`, `ANDL\s\$1016, AX$`
+ // amd64: `SHRQ \$17, AX$`, `ANDL \$1016, AX$`
return v << 3
}
diff --git a/test/codegen/issue72832.go b/test/codegen/issue72832.go
index 392b41b173..2af76aa16f 100644
--- a/test/codegen/issue72832.go
+++ b/test/codegen/issue72832.go
@@ -43,8 +43,8 @@ func store_shifted(t *tile3, x uint32) {
func store_const(t *tile3) {
// 0x00030201
- // amd64:`MOVL\s\$197121`
+ // amd64:`MOVL \$197121`
// 0x01020003
- // ppc64:`MOVD\s\$16908291`
+ // ppc64:`MOVD \$16908291`
t.a, t.b, t.c = 1, 2, 3
}
diff --git a/test/codegen/issue74788.go b/test/codegen/issue74788.go
index e102f63827..0e670d17cd 100644
--- a/test/codegen/issue74788.go
+++ b/test/codegen/issue74788.go
@@ -7,11 +7,11 @@
package codegen
func fa(a [2]int) (r [2]int) {
- // amd64:1`MOVUPS[^,]+, X[0-9]+$`,1`MOVUPS\sX[0-9]+,[^\n]+$`
+ // amd64:1`MOVUPS[^,]+, X[0-9]+$`,1`MOVUPS X[0-9]+,[^\n]+$`
return a
}
func fb(a [4]int) (r [4]int) {
- // amd64:2`MOVUPS[^,]+, X[0-9]+$`,2`MOVUPS\sX[0-9]+,[^\n]+$`
+ // amd64:2`MOVUPS[^,]+, X[0-9]+$`,2`MOVUPS X[0-9]+,[^\n]+$`
return a
}
diff --git a/test/codegen/issue75203.go b/test/codegen/issue75203.go
index 68e1794120..6ee29b398d 100644
--- a/test/codegen/issue75203.go
+++ b/test/codegen/issue75203.go
@@ -9,14 +9,13 @@ package codegen
import "reflect"
func f() reflect.Type {
- // amd64:`LEAQ\stype:\*int\(SB\)`
- // arm64:`MOVD\s\$type:\*int\(SB\)`
+ // amd64:`LEAQ type:\*int\(SB\)`
+ // arm64:`MOVD \$type:\*int\(SB\)`
return reflect.TypeFor[*int]()
}
func g() reflect.Type {
- // amd64:`LEAQ\stype:int\(SB\)`
- // arm64:`MOVD\s\$type:int\(SB\)`
- return reflect.TypeFor[int]()
+ // amd64:`LEAQ type:int\(SB\)`
+ // arm64:`MOVD \$type:int\(SB\)`
+ return reflect.TypeFor[int]()
}
-
diff --git a/test/codegen/logic.go b/test/codegen/logic.go
index 1cd389bd2d..0d1beebb67 100644
--- a/test/codegen/logic.go
+++ b/test/codegen/logic.go
@@ -11,7 +11,7 @@ package codegen
// of the args of the ANDQ needs to be saved so it can be used as the arg to TESTQ.
func andWithUse(x, y int) int {
z := x & y
- // amd64:`TESTQ\s(AX, AX|BX, BX|CX, CX|DX, DX|SI, SI|DI, DI|R8, R8|R9, R9|R10, R10|R11, R11|R12, R12|R13, R13|R15, R15)`
+ // amd64:`TESTQ (AX, AX|BX, BX|CX, CX|DX, DX|SI, SI|DI, DI|R8, R8|R9, R9|R10, R10|R11, R11|R12, R12|R13, R13|R15, R15)`
if z == 0 {
return 77
}
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
diff --git a/test/codegen/memops_bigoffset.go b/test/codegen/memops_bigoffset.go
index d34531d76d..4240e7a131 100644
--- a/test/codegen/memops_bigoffset.go
+++ b/test/codegen/memops_bigoffset.go
@@ -15,57 +15,57 @@ type big2 struct {
func loadLargeOffset(sw *big1, sd *big2) (uint32, uint64) {
- // ppc64x:`MOVWZ\s+[0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x:`MOVWZ +[0-9]+\(R[0-9]+\)`,-`ADD`
a3 := sw.w[1<<10]
- // ppc64le/power10:`MOVWZ\s+[0-9]+\(R[0-9]+\),\sR[0-9]+`,-`ADD`
- // ppc64x/power9:`ADD`,`MOVWZ\s+\(R[0-9]+\),\sR[0-9]+`
- // ppc64x/power8:`ADD`,`MOVWZ\s+\(R[0-9]+\),\sR[0-9]+`
+ // ppc64le/power10:`MOVWZ +[0-9]+\(R[0-9]+\), R[0-9]+`,-`ADD`
+ // ppc64x/power9:`ADD`,`MOVWZ +\(R[0-9]+\), R[0-9]+`
+ // ppc64x/power8:`ADD`,`MOVWZ +\(R[0-9]+\), R[0-9]+`
b3 := sw.w[1<<16]
- // ppc64le/power10:`MOVWZ\s+[0-9]+\(R[0-9]+\),\sR[0-9]+`,-`ADD`
- // ppc64x/power9:`ADD`,`MOVWZ\s+\(R[0-9]+\),\sR[0-9]+`
- // ppc64x/power8:`ADD`,`MOVWZ\s+\(R[0-9]+\),\sR[0-9]+`
+ // ppc64le/power10:`MOVWZ +[0-9]+\(R[0-9]+\), R[0-9]+`,-`ADD`
+ // ppc64x/power9:`ADD`,`MOVWZ +\(R[0-9]+\), R[0-9]+`
+ // ppc64x/power8:`ADD`,`MOVWZ +\(R[0-9]+\), R[0-9]+`
c3 := sw.w[1<<28]
- // ppc64x:`MOVWZ\s+\(R[0-9]+\)\(R[0-9]+\),\sR[0-9]+`
+ // ppc64x:`MOVWZ +\(R[0-9]+\)\(R[0-9]+\), R[0-9]+`
d3 := sw.w[1<<29]
- // ppc64x:`MOVD\s+[0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x:`MOVD +[0-9]+\(R[0-9]+\)`,-`ADD`
a4 := sd.d[1<<10]
- // ppc64le/power10:`MOVD\s+[0-9]+\(R[0-9]+\)`,-`ADD`
- // ppc64x/power9:`ADD`,`MOVD\s+\(R[0-9]+\),\sR[0-9]+`
- // ppc64x/power8:`ADD`,`MOVD\s+\(R[0-9]+\),\sR[0-9]+`
+ // ppc64le/power10:`MOVD +[0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x/power9:`ADD`,`MOVD +\(R[0-9]+\), R[0-9]+`
+ // ppc64x/power8:`ADD`,`MOVD +\(R[0-9]+\), R[0-9]+`
b4 := sd.d[1<<16]
- // ppc64le/power10`:`MOVD\s+[0-9]+\(R[0-9]+\)`,-`ADD`
- // ppc64x/power9:`ADD`,`MOVD\s+\(R[0-9]+\),\sR[0-9]+`
- // ppc64x/power8:`ADD`,`MOVD\s+\(R[0-9]+\),\sR[0-9]+`
+ // ppc64le/power10`:`MOVD +[0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x/power9:`ADD`,`MOVD +\(R[0-9]+\), R[0-9]+`
+ // ppc64x/power8:`ADD`,`MOVD +\(R[0-9]+\), R[0-9]+`
c4 := sd.d[1<<27]
- // ppc64x:`MOVD\s+\(R[0-9]+\)\(R[0-9]+\),\sR[0-9]+`
+ // ppc64x:`MOVD +\(R[0-9]+\)\(R[0-9]+\), R[0-9]+`
d4 := sd.d[1<<28]
return a3 + b3 + c3 + d3, a4 + b4 + c4 + d4
}
func storeLargeOffset(sw *big1, sd *big2) {
- // ppc64x:`MOVW\s+R[0-9]+,\s[0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x:`MOVW +R[0-9]+, [0-9]+\(R[0-9]+\)`,-`ADD`
sw.w[1<<10] = uint32(10)
- // ppc64le/power10:`MOVW\s+R[0-9]+,\s[0-9]+\(R[0-9]+\)`,-`ADD`
- // ppc64x/power9:`MOVW\s+R[0-9]+\,\s\(R[0-9]+\)`,`ADD`
- // ppc64x/power8:`MOVW\s+R[0-9]+\,\s\(R[0-9]+\)`,`ADD`
+ // ppc64le/power10:`MOVW +R[0-9]+, [0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x/power9:`MOVW +R[0-9]+\, \(R[0-9]+\)`,`ADD`
+ // ppc64x/power8:`MOVW +R[0-9]+\, \(R[0-9]+\)`,`ADD`
sw.w[1<<16] = uint32(20)
- // ppc64le/power10:`MOVW\s+R[0-9]+,\s[0-9]+\(R[0-9]+\)`,-`ADD`
- // ppc64x/power9:`MOVW\s+R[0-9]+,\s\(R[0-9]+\)`,`ADD`
- // ppc64x/power8:`MOVW\s+R[0-9]+,\s\(R[0-9]+\)`,`ADD`
+ // ppc64le/power10:`MOVW +R[0-9]+, [0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x/power9:`MOVW +R[0-9]+, \(R[0-9]+\)`,`ADD`
+ // ppc64x/power8:`MOVW +R[0-9]+, \(R[0-9]+\)`,`ADD`
sw.w[1<<28] = uint32(30)
- // ppc64x:`MOVW\s+R[0-9]+,\s\(R[0-9]+\)`
+ // ppc64x:`MOVW +R[0-9]+, \(R[0-9]+\)`
sw.w[1<<29] = uint32(40)
- // ppc64x:`MOVD\s+R[0-9]+,\s[0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x:`MOVD +R[0-9]+, [0-9]+\(R[0-9]+\)`,-`ADD`
sd.d[1<<10] = uint64(40)
- // ppc64le/power10:`MOVD\s+R[0-9]+,\s[0-9]+\(R[0-9]+\)`,-`ADD`
- // ppc64x/power9:`MOVD\s+R[0-9]+,\s\(R[0-9]+\)`,`ADD`
- // ppc64x/power8:`MOVD\s+R[0-9]+,\s\(R[0-9]+\)`,`ADD`
+ // ppc64le/power10:`MOVD +R[0-9]+, [0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x/power9:`MOVD +R[0-9]+, \(R[0-9]+\)`,`ADD`
+ // ppc64x/power8:`MOVD +R[0-9]+, \(R[0-9]+\)`,`ADD`
sd.d[1<<16] = uint64(50)
- // ppc64le/power10`:`MOVD\s+R[0-9]+,\s[0-9]+\(R[0-9]+\)`,-`ADD`
- // ppc64x/power9:`MOVD\s+R[0-9]+,\s\(R[0-9]+\)`,`ADD`
- // ppc64x/power8:`MOVD\s+R[0-9]+,\s\(R[0-9]+\)`,`ADD`
+ // ppc64le/power10`:`MOVD +R[0-9]+, [0-9]+\(R[0-9]+\)`,-`ADD`
+ // ppc64x/power9:`MOVD +R[0-9]+, \(R[0-9]+\)`,`ADD`
+ // ppc64x/power8:`MOVD +R[0-9]+, \(R[0-9]+\)`,`ADD`
sd.d[1<<27] = uint64(60)
- // ppc64x:`MOVD\s+R[0-9]+,\s\(R[0-9]+\)`
+ // ppc64x:`MOVD +R[0-9]+, \(R[0-9]+\)`
sd.d[1<<28] = uint64(70)
}
diff --git a/test/codegen/noextend.go b/test/codegen/noextend.go
index d9f1c77289..4aba1c5877 100644
--- a/test/codegen/noextend.go
+++ b/test/codegen/noextend.go
@@ -26,7 +26,7 @@ var val8 [8]uint8
func set16(x8 int8, u8 *uint8, y8 int8, z8 uint8) {
// Truncate not needed, load does sign/zero extend
- // ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVBZ R\\d+, R\\d+"
val16[0] = uint16(*u8)
// AND not needed due to size
@@ -39,20 +39,20 @@ func set16(x8 int8, u8 *uint8, y8 int8, z8 uint8) {
}
func shiftidx(u8 *uint8, x16 *int16, u16 *uint16) {
- // ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVBZ R\\d+, R\\d+"
val16[0] = uint16(sval16[*u8>>2])
- // ppc64x:-"MOVH R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVH R\\d+, R\\d+"
sval16[1] = int16(val16[*x16>>1])
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
val16[1] = uint16(sval16[*u16>>2])
}
func setnox(x8 int8, u8 *uint8, y8 *int8, z8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) {
- // ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVBZ R\\d+, R\\d+"
val16[0] = uint16(*u8)
// AND not needed due to size
@@ -62,65 +62,65 @@ func setnox(x8 int8, u8 *uint8, y8 *int8, z8 *uint8, x16 *int16, u16 *uint16, x3
// ppc64x:-"ANDCC"
val16[1] = 255 & uint16(*u8+*z8)
- // ppc64x:-"MOVH R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVH R\\d+, R\\d+"
sval32[1] = int32(*x16)
- // ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVBZ R\\d+, R\\d+"
val32[0] = uint32(*u8)
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
val32[1] = uint32(*u16)
- // ppc64x:-"MOVH R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVH R\\d+, R\\d+"
sval64[1] = int64(*x16)
- // ppc64x:-"MOVW R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVW R\\d+, R\\d+"
sval64[2] = int64(*x32)
- // ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVBZ R\\d+, R\\d+"
val64[0] = uint64(*u8)
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
val64[1] = uint64(*u16)
- // ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVWZ R\\d+, R\\d+"
val64[2] = uint64(*u32)
}
func cmp16(u8 *uint8, x32 *int32, u32 *uint32, x64 *int64, u64 *uint64) bool {
- // ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVBZ R\\d+, R\\d+"
if uint16(*u8) == val16[0] {
return true
}
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
if uint16(*u32>>16) == val16[0] {
return true
}
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
if uint16(*u64>>48) == val16[0] {
return true
}
// Verify the truncates are using the correct sign.
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
if int16(*x32) == sval16[0] {
return true
}
- // ppc64x:-"MOVH R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVH R\\d+, R\\d+"
if uint16(*u32) == val16[0] {
return true
}
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
if int16(*x64) == sval16[0] {
return true
}
- // ppc64x:-"MOVH R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVH R\\d+, R\\d+"
if uint16(*u64) == val16[0] {
return true
}
@@ -130,28 +130,28 @@ func cmp16(u8 *uint8, x32 *int32, u32 *uint32, x64 *int64, u64 *uint64) bool {
func cmp32(u8 *uint8, x16 *int16, u16 *uint16, x64 *int64, u64 *uint64) bool {
- // ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVBZ R\\d+, R\\d+"
if uint32(*u8) == val32[0] {
return true
}
- // ppc64x:-"MOVH R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVH R\\d+, R\\d+"
if int32(*x16) == sval32[0] {
return true
}
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
if uint32(*u16) == val32[0] {
return true
}
// Verify the truncates are using the correct sign.
- // ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVWZ R\\d+, R\\d+"
if int32(*x64) == sval32[0] {
return true
}
- // ppc64x:-"MOVW R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVW R\\d+, R\\d+"
if uint32(*u64) == val32[0] {
return true
}
@@ -161,27 +161,27 @@ func cmp32(u8 *uint8, x16 *int16, u16 *uint16, x64 *int64, u64 *uint64) bool {
func cmp64(u8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) bool {
- // ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVBZ R\\d+, R\\d+"
if uint64(*u8) == val64[0] {
return true
}
- // ppc64x:-"MOVH R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVH R\\d+, R\\d+"
if int64(*x16) == sval64[0] {
return true
}
- // ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVHZ R\\d+, R\\d+"
if uint64(*u16) == val64[0] {
return true
}
- // ppc64x:-"MOVW R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVW R\\d+, R\\d+"
if int64(*x32) == sval64[0] {
return true
}
- // ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
+ // ppc64x:-"MOVWZ R\\d+, R\\d+"
if uint64(*u32) == val64[0] {
return true
}
diff --git a/test/codegen/simd.go b/test/codegen/simd.go
index acec5421e4..b44d8b5e68 100644
--- a/test/codegen/simd.go
+++ b/test/codegen/simd.go
@@ -18,16 +18,16 @@ import (
func vptest1() bool {
v1 := archsimd.LoadUint64x2Slice([]uint64{0, 1})
v2 := archsimd.LoadUint64x2Slice([]uint64{0, 0})
- // amd64:`VPTEST\s(.*)(.*)$`
- // amd64:`SETCS\s(.*)$`
+ // amd64:`VPTEST (.*)(.*)$`
+ // amd64:`SETCS (.*)$`
return v1.AndNot(v2).IsZero()
}
func vptest2() bool {
v1 := archsimd.LoadUint64x2Slice([]uint64{0, 1})
v2 := archsimd.LoadUint64x2Slice([]uint64{0, 0})
- // amd64:`VPTEST\s(.*)(.*)$`
- // amd64:`SETEQ\s(.*)$`
+ // amd64:`VPTEST (.*)(.*)$`
+ // amd64:`SETEQ (.*)$`
return v1.And(v2).IsZero()
}
@@ -39,24 +39,24 @@ type Args2 struct {
//go:noinline
func simdStructNoSpill(a Args2) archsimd.Uint8x32 {
- // amd64:-`VMOVDQU\s.*$`
+ // amd64:-`VMOVDQU .*$`
return a.V0.Xor(a.V1)
}
func simdStructWrapperNoSpill(a Args2) archsimd.Uint8x32 {
- // amd64:-`VMOVDQU\s.*$`
+ // amd64:-`VMOVDQU .*$`
a.x = "test"
return simdStructNoSpill(a)
}
//go:noinline
func simdArrayNoSpill(a [1]Args2) archsimd.Uint8x32 {
- // amd64:-`VMOVDQU\s.*$`
+ // amd64:-`VMOVDQU .*$`
return a[0].V0.Xor(a[0].V1)
}
func simdArrayWrapperNoSpill(a [1]Args2) archsimd.Uint8x32 {
- // amd64:-`VMOVDQU\s.*$`
+ // amd64:-`VMOVDQU .*$`
a[0].x = "test"
return simdArrayNoSpill(a)
}
@@ -65,20 +65,20 @@ func simdFeatureGuardedMaskOpt() archsimd.Int16x16 {
var x, y archsimd.Int16x16
if archsimd.X86.AVX512() {
mask := archsimd.Mask16x16FromBits(5)
- return x.Add(y).Masked(mask) // amd64:`VPADDW.Z\s.*$`
+ return x.Add(y).Masked(mask) // amd64:`VPADDW.Z .*$`
}
mask := archsimd.Mask16x16FromBits(5)
- return x.Add(y).Masked(mask) // amd64:`VPAND\s.*$`
+ return x.Add(y).Masked(mask) // amd64:`VPAND .*$`
}
func simdMaskedMerge() archsimd.Int16x16 {
var x, y archsimd.Int16x16
if archsimd.X86.AVX512() {
mask := archsimd.Mask16x16FromBits(5)
- return x.Add(y).Merge(x, mask) // amd64:-`VPBLENDVB\s.*$`
+ return x.Add(y).Merge(x, mask) // amd64:-`VPBLENDVB .*$`
}
mask := archsimd.Mask16x16FromBits(5)
- return x.Add(y).Merge(x, mask) // amd64:`VPBLENDVB\s.*$`
+ return x.Add(y).Merge(x, mask) // amd64:`VPBLENDVB .*$`
}
var nan = math.NaN()
@@ -107,6 +107,6 @@ func simdIsNaN512() {
func sftImmVPSRL() archsimd.Uint32x4 {
var x archsimd.Uint32x4
- // amd64:`VPSRLD\s\$1,\s.*$`
+ // amd64:`VPSRLD \$1, .*$`
return x.ShiftAllRight(1)
}
diff --git a/test/codegen/spills.go b/test/codegen/spills.go
index c8ac9859a4..9b04d7d3d0 100644
--- a/test/codegen/spills.go
+++ b/test/codegen/spills.go
@@ -6,7 +6,7 @@
package codegen
-func i64(a, b int64) int64 { // arm64:`STP\s`,`LDP\s`
+func i64(a, b int64) int64 { // arm64:`STP `,`LDP `
g()
return a + b
}
diff --git a/test/codegen/switch.go b/test/codegen/switch.go
index a8860d0cc4..baa8934e06 100644
--- a/test/codegen/switch.go
+++ b/test/codegen/switch.go
@@ -23,8 +23,8 @@ func f(x string) int {
// use jump tables for 8+ int cases
func square(x int) int {
- // amd64:`JMP\s\(.*\)\(.*\)$`
- // arm64:`MOVD\s\(R.*\)\(R.*<<3\)`,`JMP\s\(R.*\)$`
+ // amd64:`JMP \(.*\)\(.*\)$`
+ // arm64:`MOVD \(R.*\)\(R.*<<3\)`,`JMP \(R.*\)$`
// loong64: `ALSLV`,`MOVV`,`JMP`
switch x {
case 1:
@@ -50,8 +50,8 @@ func square(x int) int {
// use jump tables for 8+ string lengths
func length(x string) int {
- // amd64:`JMP\s\(.*\)\(.*\)$`
- // arm64:`MOVD\s\(R.*\)\(R.*<<3\)`,`JMP\s\(R.*\)$`
+ // amd64:`JMP \(.*\)\(.*\)$`
+ // arm64:`MOVD \(R.*\)\(R.*<<3\)`,`JMP \(R.*\)$`
// loong64:`ALSLV`,`MOVV`,`JMP`
switch x {
case "a":
@@ -78,23 +78,23 @@ func length(x string) int {
// Use single-byte ordered comparisons for binary searching strings.
// See issue 53333.
func mimetype(ext string) string {
- // amd64: `CMPB\s1\(.*\), \$104$`,-`cmpstring`
- // arm64: `MOVB\s1\(R.*\), R.*$`, `CMPW\s\$104, R.*$`, -`cmpstring`
+ // amd64: `CMPB 1\(.*\), \$104$`,-`cmpstring`
+ // arm64: `MOVB 1\(R.*\), R.*$`, `CMPW \$104, R.*$`, -`cmpstring`
switch ext {
- // amd64: `CMPL\s\(.*\), \$1836345390$`
- // arm64: `MOVD\s\$1836345390`, `CMPW\sR.*, R.*$`
+ // amd64: `CMPL \(.*\), \$1836345390$`
+ // arm64: `MOVD \$1836345390`, `CMPW R.*, R.*$`
case ".htm":
return "A"
- // amd64: `CMPL\s\(.*\), \$1953457454$`
- // arm64: `MOVD\s\$1953457454`, `CMPW\sR.*, R.*$`
+ // amd64: `CMPL \(.*\), \$1953457454$`
+ // arm64: `MOVD \$1953457454`, `CMPW R.*, R.*$`
case ".eot":
return "B"
- // amd64: `CMPL\s\(.*\), \$1735815982$`
- // arm64: `MOVD\s\$1735815982`, `CMPW\sR.*, R.*$`
+ // amd64: `CMPL \(.*\), \$1735815982$`
+ // arm64: `MOVD \$1735815982`, `CMPW R.*, R.*$`
case ".svg":
return "C"
- // amd64: `CMPL\s\(.*\), \$1718907950$`
- // arm64: `MOVD\s\$1718907950`, `CMPW\sR.*, R.*$`
+ // amd64: `CMPL \(.*\), \$1718907950$`
+ // arm64: `MOVD \$1718907950`, `CMPW R.*, R.*$`
case ".ttf":
return "D"
default:
@@ -104,8 +104,8 @@ func mimetype(ext string) string {
// use jump tables for type switches to concrete types.
func typeSwitch(x any) int {
- // amd64:`JMP\s\(.*\)\(.*\)$`
- // arm64:`MOVD\s\(R.*\)\(R.*<<3\)`,`JMP\s\(R.*\)$`
+ // amd64:`JMP \(.*\)\(.*\)$`
+ // arm64:`MOVD \(R.*\)\(R.*<<3\)`,`JMP \(R.*\)$`
switch x.(type) {
case int:
return 0
diff --git a/test/codegen/unsafe.go b/test/codegen/unsafe.go
index 1f1bdf2a95..30be9f4f34 100644
--- a/test/codegen/unsafe.go
+++ b/test/codegen/unsafe.go
@@ -10,7 +10,7 @@ import "unsafe"
func f(p unsafe.Pointer, x, y uintptr) int64 {
p = unsafe.Pointer(uintptr(p) + x + y)
- // amd64:`MOVQ\s\(.*\)\(.*\*1\), `
- // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\), `
+ // amd64:`MOVQ \(.*\)\(.*\*1\), `
+ // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+\), `
return *(*int64)(p)
}
diff --git a/test/codegen/writebarrier.go b/test/codegen/writebarrier.go
index 271d8d25d3..bb156bb123 100644
--- a/test/codegen/writebarrier.go
+++ b/test/codegen/writebarrier.go
@@ -90,14 +90,14 @@ func issue71228(dst *S, ptr *int) {
}
func writeDouble(p *[2]*int, x, y *int) {
- // arm64: `LDP\s`, `STP\s\(R[0-9]+, R[0-9]+\), \(`
+ // arm64: `LDP `, `STP \(R[0-9]+, R[0-9]+\), \(`
p[0] = x
- // arm64: `STP\s\(R[0-9]+, R[0-9]+\), 16\(`
+ // arm64: `STP \(R[0-9]+, R[0-9]+\), 16\(`
p[1] = y
}
func writeDoubleNil(p *[2]*int) {
- // arm64: `LDP\s`, `STP\s\(R[0-9]+, R[0-9]+\),`, `STP\s\(ZR, ZR\),`
+ // arm64: `LDP `, `STP \(R[0-9]+, R[0-9]+\),`, `STP \(ZR, ZR\),`
p[0] = nil
p[1] = nil
}
generated by cgit v1.3 (git 2.53.0) at 2026-04-15 12:29:56 +0000