From d6492e284b61c8be4bfce5ee0ca907f4df5deb72 Mon Sep 17 00:00:00 2001
From: Keith Randall <khr@golang.org>
Date: Fri, 27 Mar 2026 16:20:06 -0700
Subject: test/codegen: get rid of \s

Replace \s with a space in backtick-quoted strings
Replace \\s with a space in double-quoted strings

Change-Id: I0c8b249bb12c2c8ca69e683e4bc6f27544fd6094
Reviewed-on: https://go-review.googlesource.com/c/go/+/760680
Auto-Submit: Keith Randall <khr@google.com>
Reviewed-by: Junyang Shao <shaojunyang@google.com>
Reviewed-by: Paul Murphy <paumurph@redhat.com>
Reviewed-by: Keith Randall <khr@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
---
 test/codegen/arithmetic.go       |  76 +++----
 test/codegen/bits.go             |   6 +-
 test/codegen/bool.go             |  22 +-
 test/codegen/comparisons.go      |   6 +-
 test/codegen/floats.go           |   8 +-
 test/codegen/issue59297.go       |   2 +-
 test/codegen/issue60673.go       |   2 +-
 test/codegen/issue68845.go       |  10 +-
 test/codegen/issue69635.go       |   2 +-
 test/codegen/issue72832.go       |   4 +-
 test/codegen/issue74788.go       |   4 +-
 test/codegen/issue75203.go       |  11 +-
 test/codegen/logic.go            |   2 +-
 test/codegen/memcombine.go       | 428 +++++++++++++++++++--------------------
 test/codegen/memops_bigoffset.go |  64 +++---
 test/codegen/noextend.go         |  60 +++---
 test/codegen/simd.go             |  26 +--
 test/codegen/spills.go           |   2 +-
 test/codegen/switch.go           |  32 +--
 test/codegen/unsafe.go           |   4 +-
 test/codegen/writebarrier.go     |   6 +-
 21 files changed, 388 insertions(+), 389 deletions(-)

(limited to 'test/codegen')

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
 }
-- 
cgit v1.3