diff options
| author | Keith Randall <khr@golang.org> | 2026-03-27 16:42:41 -0700 |
|---|---|---|
| committer | Gopher Robot <gobot@golang.org> | 2026-03-31 11:01:16 -0700 |
| commit | d5b6d583c16f60e4a2f80f8b0fe78abab503f84c (patch) | |
| tree | b2000af6a1ba82ea647f23d22812d9c329b61fb5 /test/codegen | |
| parent | d6492e284b61c8be4bfce5ee0ca907f4df5deb72 (diff) | |
| download | go-d5b6d583c16f60e4a2f80f8b0fe78abab503f84c.tar.xz | |
test/codegen: replace commas with spaces between regexps
Change-Id: Ia7a955833d761e08c1b8081fb29a2e6317de004c
Reviewed-on: https://go-review.googlesource.com/c/go/+/760681
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>
Diffstat (limited to 'test/codegen')
31 files changed, 750 insertions, 750 deletions
diff --git a/test/codegen/alloc.go b/test/codegen/alloc.go index 20ccc853c6..f755bb54a2 100644 --- a/test/codegen/alloc.go +++ b/test/codegen/alloc.go @@ -10,28 +10,28 @@ package codegen func zeroAllocNew1() *struct{} { - // 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase` - // amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase` - // arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase` - // arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase` - // riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase` + // 386:-`CALL runtime\.newobject` `LEAL runtime.zerobase` + // amd64:-`CALL runtime\.newobject` `LEAQ runtime.zerobase` + // arm:-`CALL runtime\.newobject` `MOVW [$]runtime.zerobase` + // arm64:-`CALL runtime\.newobject` `MOVD [$]runtime.zerobase` + // riscv64:-`CALL runtime\.newobject` `MOV [$]runtime.zerobase` return new(struct{}) } func zeroAllocNew2() *[0]int { - // 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase` - // amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase` - // arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase` - // arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase` - // riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase` + // 386:-`CALL runtime\.newobject` `LEAL runtime.zerobase` + // amd64:-`CALL runtime\.newobject` `LEAQ runtime.zerobase` + // arm:-`CALL runtime\.newobject` `MOVW [$]runtime.zerobase` + // arm64:-`CALL runtime\.newobject` `MOVD [$]runtime.zerobase` + // riscv64:-`CALL runtime\.newobject` `MOV [$]runtime.zerobase` return new([0]int) } func zeroAllocSliceLit() []int { - // 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase` - // amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase` - // arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase` - // arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase` - // riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase` + // 386:-`CALL runtime\.newobject` `LEAL runtime.zerobase` + // amd64:-`CALL runtime\.newobject` `LEAQ runtime.zerobase` + // arm:-`CALL runtime\.newobject` `MOVW [$]runtime.zerobase` + // arm64:-`CALL runtime\.newobject` `MOVD [$]runtime.zerobase` + // riscv64:-`CALL runtime\.newobject` `MOV [$]runtime.zerobase` return []int{} } diff --git a/test/codegen/arithmetic.go b/test/codegen/arithmetic.go index a73ed6ed55..b48975cc13 100644 --- a/test/codegen/arithmetic.go +++ b/test/codegen/arithmetic.go @@ -14,38 +14,38 @@ package codegen func AddLargeConst(a uint64, out []uint64) { // ppc64x/power10:"ADD [$]4294967296," - // ppc64x/power9:"MOVD [$]1", "SLD [$]32" "ADD R[0-9]*" - // ppc64x/power8:"MOVD [$]1", "SLD [$]32" "ADD R[0-9]*" + // ppc64x/power9:"MOVD [$]1" "SLD [$]32" "ADD R[0-9]*" + // ppc64x/power8:"MOVD [$]1" "SLD [$]32" "ADD R[0-9]*" out[0] = a + 0x100000000 // ppc64x/power10:"ADD [$]-8589934592," - // ppc64x/power9:"MOVD [$]-1", "SLD [$]33" "ADD R[0-9]*" - // ppc64x/power8:"MOVD [$]-1", "SLD [$]33" "ADD R[0-9]*" + // ppc64x/power9:"MOVD [$]-1" "SLD [$]33" "ADD R[0-9]*" + // ppc64x/power8:"MOVD [$]-1" "SLD [$]33" "ADD R[0-9]*" out[1] = a + 0xFFFFFFFE00000000 // ppc64x/power10:"ADD [$]1234567," - // ppc64x/power9:"ADDIS [$]19,", "ADD [$]-10617," - // ppc64x/power8:"ADDIS [$]19,", "ADD [$]-10617," + // ppc64x/power9:"ADDIS [$]19," "ADD [$]-10617," + // ppc64x/power8:"ADDIS [$]19," "ADD [$]-10617," out[2] = a + 1234567 // ppc64x/power10:"ADD [$]-1234567," - // ppc64x/power9:"ADDIS [$]-19,", "ADD [$]10617," - // ppc64x/power8:"ADDIS [$]-19,", "ADD [$]10617," + // ppc64x/power9:"ADDIS [$]-19," "ADD [$]10617," + // ppc64x/power8:"ADDIS [$]-19," "ADD [$]10617," out[3] = a - 1234567 // ppc64x/power10:"ADD [$]2147450879," - // ppc64x/power9:"ADDIS [$]32767,", "ADD [$]32767," - // ppc64x/power8:"ADDIS [$]32767,", "ADD [$]32767," + // ppc64x/power9:"ADDIS [$]32767," "ADD [$]32767," + // ppc64x/power8:"ADDIS [$]32767," "ADD [$]32767," out[4] = a + 0x7FFF7FFF // ppc64x/power10:"ADD [$]-2147483647," - // ppc64x/power9:"ADDIS [$]-32768,", "ADD [$]1," - // ppc64x/power8:"ADDIS [$]-32768,", "ADD [$]1," + // ppc64x/power9:"ADDIS [$]-32768," "ADD [$]1," + // ppc64x/power8:"ADDIS [$]-32768," "ADD [$]1," out[5] = a - 2147483647 - // ppc64x:"ADDIS [$]-32768,", -"ADD " + // ppc64x:"ADDIS [$]-32768," -"ADD " out[6] = a - 2147483648 - // ppc64x:"ADD [$]2147450880,", -"ADDIS " + // ppc64x:"ADD [$]2147450880," -"ADDIS " out[7] = a + 0x7FFF8000 - // ppc64x:"ADD [$]-32768,", -"ADDIS " + // ppc64x:"ADD [$]-32768," -"ADDIS " out[8] = a - 32768 // ppc64x/power10:"ADD [$]-32769," - // ppc64x/power9:"ADDIS [$]-1,", "ADD [$]32767," - // ppc64x/power8:"ADDIS [$]-1,", "ADD [$]32767," + // ppc64x/power9:"ADDIS [$]-1," "ADD [$]32767," + // ppc64x/power8:"ADDIS [$]-1," "ADD [$]32767," out[9] = a - 32769 } @@ -242,7 +242,7 @@ func Pow2Muls(n1, n2 int) (int, int) { // amd64:"SHLQ [$]6" -"IMULQ" // 386:"SHLL [$]6" -"IMULL" // arm:"SLL [$]6" -"MUL" - // arm64:`NEG R[0-9]+<<6, R[0-9]+`,-`LSL`,-`MUL` + // arm64:`NEG R[0-9]+<<6, R[0-9]+` -`LSL` -`MUL` // loong64:"SLLV [$]6" -"MULV" // ppc64x:"SLD [$]6" "NEG R[0-9]+, R[0-9]+" -"MUL" b := -64 * n2 @@ -251,27 +251,27 @@ func Pow2Muls(n1, n2 int) (int, int) { } func Mul_2(n1 int32, n2 int64) (int32, int64) { - // amd64:"ADDL", -"SHLL" + // amd64:"ADDL" -"SHLL" a := n1 * 2 - // amd64:"ADDQ", -"SHLQ" + // amd64:"ADDQ" -"SHLQ" b := n2 * 2 return a, b } func Mul_96(n int) int { - // amd64:`SHLQ [$]5`,`LEAQ \(.*\)\(.*\*2\),`,-`IMULQ` - // 386:`SHLL [$]5`,`LEAL \(.*\)\(.*\*2\),`,-`IMULL` - // arm64:`LSL [$]5`,`ADD R[0-9]+<<1, R[0-9]+`,-`MUL` - // arm:`SLL [$]5`,`ADD R[0-9]+<<1, R[0-9]+`,-`MUL` + // amd64:`SHLQ [$]5` `LEAQ \(.*\)\(.*\*2\),` -`IMULQ` + // 386:`SHLL [$]5` `LEAL \(.*\)\(.*\*2\),` -`IMULL` + // 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` + // s390x:`SLD [$]5` `SLD [$]6` -`MULLD` return n * 96 } func Mul_n120(n int) int { // loong64:"SLLV [$]3" "SLLV [$]7" "SUBVU" -"MULV" - // s390x:`SLD [$]3`,`SLD [$]7`,-`MULLD` + // s390x:`SLD [$]3` `SLD [$]7` -`MULLD` return n * -120 } @@ -397,8 +397,8 @@ func Pow2Divs(n1 uint, n2 int) (uint, int) { func ConstDivs(n1 uint, n2 int) (uint, int) { // amd64: "MOVQ [$]-1085102592571150095" "MULQ" -"DIVQ" // 386: "MOVL [$]-252645135" "MULL" -"DIVL" - // arm64: `MOVD`,`UMULH`,-`DIV` - // arm: `MOVW`,`MUL`,-`.*udiv` + // arm64: `MOVD` `UMULH` -`DIV` + // arm: `MOVW` `MUL` -`.*udiv` a := n1 / 17 // unsigned // amd64: "MOVQ [$]-1085102592571150095" "IMULQ" -"IDIVQ" @@ -669,31 +669,31 @@ func AddShift(a, b int) int { } func MULA(a, b, c uint32) (uint32, uint32, uint32) { - // arm:`MULA`,-`MUL ` - // arm64:`MADDW`,-`MULW` + // arm:`MULA` -`MUL ` + // arm64:`MADDW` -`MULW` r0 := a*b + c - // arm:`MULA`,-`MUL ` - // arm64:`MADDW`,-`MULW` + // arm:`MULA` -`MUL ` + // arm64:`MADDW` -`MULW` r1 := c*79 + a - // arm:`ADD`,-`MULA`,-`MUL ` - // arm64:`ADD`,-`MADD`,-`MULW` - // ppc64x:`ADD`,-`MULLD` + // arm:`ADD` -`MULA` -`MUL ` + // arm64:`ADD` -`MADD` -`MULW` + // ppc64x:`ADD` -`MULLD` r2 := b*64 + c return r0, r1, r2 } func MULS(a, b, c uint32) (uint32, uint32, uint32) { - // arm/7:`MULS`,-`MUL ` - // arm/6:`SUB`,`MUL `,-`MULS` - // arm64:`MSUBW`,-`MULW` + // arm/7:`MULS` -`MUL ` + // arm/6:`SUB` `MUL ` -`MULS` + // arm64:`MSUBW` -`MULW` r0 := c - a*b - // arm/7:`MULS`,-`MUL ` - // arm/6:`SUB`,`MUL `,-`MULS` - // arm64:`MSUBW`,-`MULW` + // arm/7:`MULS` -`MUL ` + // arm/6:`SUB` `MUL ` -`MULS` + // arm64:`MSUBW` -`MULW` r1 := a - c*79 - // arm/7:`SUB`,-`MULS`,-`MUL ` - // arm64:`SUB`,-`MSUBW`,-`MULW` - // ppc64x:`SUB`,-`MULLD` + // arm/7:`SUB` -`MULS` -`MUL ` + // arm64:`SUB` -`MSUBW` -`MULW` + // ppc64x:`SUB` -`MULLD` r2 := c - b*64 return r0, r1, r2 } @@ -712,10 +712,10 @@ func addSpecial(a, b, c uint32) (uint32, uint32, uint32) { // If the input is non-negative, make sure the unsigned form is generated. func divInt(v int64) int64 { if v < 0 { - // amd64:`SARQ.*63,`, `SHRQ.*56,`, `SARQ.*8,` + // amd64:`SARQ.*63,` `SHRQ.*56,` `SARQ.*8,` return v / 256 } - // amd64:-`.*SARQ`, `SHRQ.*9,` + // amd64:-`.*SARQ` `SHRQ.*9,` return v / 512 } diff --git a/test/codegen/bitfield.go b/test/codegen/bitfield.go index a26a21c18d..c377fb3c28 100644 --- a/test/codegen/bitfield.go +++ b/test/codegen/bitfield.go @@ -331,14 +331,14 @@ func ubfx16(x uint64) uint64 { // //go:nosplit func shift_no_cmp(x int) int { - // arm64:`LSL [$]17`,-`CMP` - // mips64:`SLLV [$]17`,-`SGT` + // arm64:`LSL [$]17` -`CMP` + // mips64:`SLLV [$]17` -`SGT` return x << 17 } func rev16(c uint64) (uint64, uint64, uint64) { - // arm64:`REV16`,-`AND`,-`LSR`,-`AND`,-`ORR R[0-9]+<<8` - // loong64:`REVB4H`,-`MOVV`,-`AND`,-`SRLV`,-`AND`,-`SLLV`,-`OR` + // arm64:`REV16` -`AND` -`LSR` -`AND` -`ORR R[0-9]+<<8` + // loong64:`REVB4H` -`MOVV` -`AND` -`SRLV` -`AND` -`SLLV` -`OR` b1 := ((c & 0xff00ff00ff00ff00) >> 8) | ((c & 0x00ff00ff00ff00ff) << 8) // arm64:-`ADD R[0-9]+<<8` // loong64:-`ADDV` @@ -350,8 +350,8 @@ func rev16(c uint64) (uint64, uint64, uint64) { } func rev16w(c uint32) (uint32, uint32, uint32) { - // arm64:`REV16W`,-`AND`,-`UBFX`,-`AND`,-`ORR R[0-9]+<<8` - // loong64:`REVB2H`,-`AND`,-`SRL`,-`AND`,-`SLL`,-`OR` + // arm64:`REV16W` -`AND` -`UBFX` -`AND` -`ORR R[0-9]+<<8` + // loong64:`REVB2H` -`AND` -`SRL` -`AND` -`SLL` -`OR` b1 := ((c & 0xff00ff00) >> 8) | ((c & 0x00ff00ff) << 8) // arm64:-`ADD R[0-9]+<<8` // loong64:-`ADDV` @@ -363,16 +363,16 @@ func rev16w(c uint32) (uint32, uint32, uint32) { } func shift(x uint32, y uint16, z uint8) uint64 { - // arm64:-`MOVWU`,-`LSR [$]32` - // loong64:-`MOVWU`,-`SRLV [$]32` + // arm64:-`MOVWU` -`LSR [$]32` + // loong64:-`MOVWU` -`SRLV [$]32` a := uint64(x) >> 32 // arm64:-`MOVHU` - // loong64:-`MOVHU`,-`SRLV [$]16` + // loong64:-`MOVHU` -`SRLV [$]16` b := uint64(y) >> 16 // arm64:-`MOVBU` - // loong64:-`MOVBU`,-`SRLV [$]8` + // loong64:-`MOVBU` -`SRLV [$]8` c := uint64(z) >> 8 - // arm64:`MOVD ZR`,-`ADD R[0-9]+>>16`,-`ADD R[0-9]+>>8`, - // loong64:`MOVV R0`,-`ADDVU` + // arm64:`MOVD ZR` -`ADD R[0-9]+>>16` -`ADD R[0-9]+>>8` + // loong64:`MOVV R0` -`ADDVU` return a + b + c } diff --git a/test/codegen/bits.go b/test/codegen/bits.go index 07e12d3131..15447801ec 100644 --- a/test/codegen/bits.go +++ b/test/codegen/bits.go @@ -62,7 +62,7 @@ func bitsCheckConstRightShiftU64(a [8]uint64) (n int) { // amd64:"BTQ [$]60," // arm64:"TBZ [$]60," -"LSR" // loong64:"SRLV [$]60," "AND [$]1," "BEQ" - // riscv64:"SRLI [$]60,", "ANDI [$]1," "BEQZ" + // riscv64:"SRLI [$]60," "ANDI [$]1," "BEQZ" if (a[3]>>60)&1 == 0 { return 1 } @@ -472,37 +472,37 @@ func bitsIssue19857b(a uint64) uint64 { } func bitsIssue19857c(a, b uint32) (uint32, uint32) { - // arm/7:`BIC`,-`AND` + // arm/7:`BIC` -`AND` a &= 0xffffaaaa - // arm/7:`BFC`,-`AND`,-`BIC` + // arm/7:`BFC` -`AND` -`BIC` b &= 0xffc003ff return a, b } func bitsAndNot(x, y uint32) uint32 { - // arm64:`BIC `,-`AND` + // arm64:`BIC ` -`AND` // loong64:"ANDN " -"AND " // riscv64:"ANDN" -"AND " return x &^ y } func bitsXorNot(x, y, z uint32, a []uint32, n, m uint64) uint64 { - // arm64:`EON `,-`EOR`,-`MVN` + // arm64:`EON ` -`EOR` -`MVN` // loong64:"NOR" "XOR" // riscv64:"XNOR " -"MOV [$]" -"XOR " a[0] = x ^ (y ^ 0xffffffff) - // arm64:`EON `,-`EOR`,-`MVN` + // arm64:`EON ` -`EOR` -`MVN` // loong64:"XOR" "NOR" // riscv64:"XNOR" -"XOR " a[1] = ^(y ^ z) - // arm64:`EON `,-`XOR` + // arm64:`EON ` -`XOR` // loong64:"NOR" "XOR" // riscv64:"XNOR" -"XOR " -"NOT" a[2] = x ^ ^z - // arm64:`EON `,-`EOR`,-`MVN` + // arm64:`EON ` -`EOR` -`MVN` // loong64:"NOR" "XOR" // riscv64:"XNOR" -"MOV [$]" -"XOR " return n ^ (m ^ 0xffffffffffffffff) @@ -550,12 +550,12 @@ func bitsMaskContiguousZeroes64U(x uint64) uint64 { } func bitsIssue44228a(a []int64, i int) bool { - // amd64: "BTQ", -"SHL" + // amd64: "BTQ" -"SHL" return a[i>>6]&(1<<(i&63)) != 0 } func bitsIssue44228b(a []int32, i int) bool { - // amd64: "BTL", -"SHL" + // amd64: "BTL" -"SHL" return a[i>>5]&(1<<(i&31)) != 0 } @@ -580,9 +580,9 @@ func bitsFoldConstOutOfRange(a uint64) uint64 { func bitsSignExtendAndMask8to64U(a int8) (s, z uint64) { // Verify sign-extended values are not zero-extended under a bit mask (#61297) - // ppc64x: "MOVB", "ANDCC [$]1015," + // ppc64x: "MOVB" "ANDCC [$]1015," s = uint64(a) & 0x3F7 - // ppc64x: -"MOVB", "ANDCC [$]247," + // ppc64x: -"MOVB" "ANDCC [$]247," z = uint64(uint8(a)) & 0x3F7 return } @@ -590,9 +590,9 @@ func bitsSignExtendAndMask8to64U(a int8) (s, z uint64) { func bitsZeroExtendAndMask8toU64(a int8, b int16) (x, y uint64) { // Verify zero-extended values are not sign-extended under a bit mask (#61297) - // ppc64x: -"MOVB ", -"ANDCC", "MOVBZ" + // ppc64x: -"MOVB " -"ANDCC" "MOVBZ" x = uint64(a) & 0xFF - // ppc64x: -"MOVH ", -"ANDCC", "MOVHZ" + // ppc64x: -"MOVH " -"ANDCC" "MOVHZ" y = uint64(b) & 0xFFFF return } @@ -604,19 +604,19 @@ func bitsRotateAndMask(io64 [8]uint64, io32 [4]uint32, io16 [4]uint16, io8 [4]ui io64[0] = io64[0] & 0xFFFFFFFFFFFF0000 // ppc64x: "RLDICL [$]0, R[0-9]*, [$]16, R" io64[1] = io64[1] & 0x0000FFFFFFFFFFFF - // ppc64x: -"SRD", -"AND", "RLDICL [$]60, R[0-9]*, [$]16, R" + // ppc64x: -"SRD" -"AND" "RLDICL [$]60, R[0-9]*, [$]16, R" io64[2] = (io64[2] >> 4) & 0x0000FFFFFFFFFFFF // ppc64x: -"SRD" -"AND" "RLDICL [$]36, R[0-9]*, [$]29, R" io64[3] = (io64[3] >> 28) & 0x00000007FFFFFFFF - // ppc64x: "MOVWZ", "RLWNM [$]1, R[0-9]*, [$]28, [$]3, R" + // ppc64x: "MOVWZ" "RLWNM [$]1, R[0-9]*, [$]28, [$]3, R" io64[4] = uint64(bits.RotateLeft32(io32[0], 1) & 0xF000000F) // ppc64x: "RLWNM [$]0, R[0-9]*, [$]4, [$]19, R" io32[0] = io32[0] & 0x0FFFF000 // ppc64x: "RLWNM [$]0, R[0-9]*, [$]20, [$]3, R" io32[1] = io32[1] & 0xF0000FFF - // ppc64x: -"RLWNM", "MOVD", "AND" + // ppc64x: -"RLWNM" "MOVD" "AND" io32[2] = io32[2] & 0xFFFF0002 var bigc uint32 = 0x12345678 diff --git a/test/codegen/bool.go b/test/codegen/bool.go index e201f0a969..22c86ba779 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 " + // ppc64x:"ANDCC" -"AND " b := x[0] & 3 if b != 0 { x[0] = b } - // ppc64x:"ANDCC",-"AND " + // ppc64x:"ANDCC" -"AND " b = x[1] & x[2] if b != 0 { x[1] = b } - // ppc64x:"ANDNCC",-"ANDN " + // ppc64x:"ANDNCC" -"ANDN " b = x[1] &^ x[2] if b != 0 { x[1] = b } - // ppc64x:"ORCC",-"OR " + // ppc64x:"ORCC" -"OR " b = x[3] | x[4] if b != 0 { x[3] = b } - // ppc64x:"SUBCC",-"SUB " + // ppc64x:"SUBCC" -"SUB " b = x[5] - x[6] if b != 0 { x[5] = b } - // ppc64x:"NORCC",-"NOR " + // ppc64x:"NORCC" -"NOR " b = ^(x[5] | x[6]) if b != 0 { x[5] = b } - // ppc64x:"XORCC",-"XOR " + // ppc64x:"XORCC" -"XOR " b = x[7] ^ x[8] if b != 0 { x[7] = b } - // ppc64x:"ADDCC",-"ADD " + // ppc64x:"ADDCC" -"ADD " b = x[9] + x[10] if b != 0 { x[9] = b } - // ppc64x:"NEGCC",-"NEG " + // ppc64x:"NEGCC" -"NEG " b = -x[11] if b != 0 { x[11] = b } - // ppc64x:"CNTLZDCC",-"CNTLZD " + // 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 " + // ppc64x:"MULHDUCC" -"MULHDU " hi, _ := bits.Mul64(x[13], x[14]) if hi != 0 { x[14] = hi diff --git a/test/codegen/clobberdead.go b/test/codegen/clobberdead.go index df44705cfc..80ac4bb6d7 100644 --- a/test/codegen/clobberdead.go +++ b/test/codegen/clobberdead.go @@ -15,16 +15,16 @@ var p1, p2, p3 T func F() { // 3735936685 is 0xdeaddead. On ARM64 R27 is REGTMP. // clobber x, y at entry. not clobber z (stack object). - // amd64:`MOVL \$3735936685, command-line-arguments\.x`, `MOVL \$3735936685, command-line-arguments\.y`, -`MOVL \$3735936685, command-line-arguments\.z` - // arm64:`MOVW R27, command-line-arguments\.x`, `MOVW R27, command-line-arguments\.y`, -`MOVW R27, command-line-arguments\.z` + // amd64:`MOVL \$3735936685, command-line-arguments\.x` `MOVL \$3735936685, command-line-arguments\.y` -`MOVL \$3735936685, command-line-arguments\.z` + // arm64:`MOVW R27, command-line-arguments\.x` `MOVW R27, command-line-arguments\.y` -`MOVW R27, command-line-arguments\.z` x, y, z := p1, p2, p3 addrTaken(&z) // x is dead at the call (the value of x is loaded before the CALL), y is not - // amd64:`MOVL \$3735936685, command-line-arguments\.x`, -`MOVL \$3735936685, command-line-arguments\.y` - // arm64:`MOVW R27, command-line-arguments\.x`, -`MOVW R27, command-line-arguments\.y` + // amd64:`MOVL \$3735936685, command-line-arguments\.x` -`MOVL \$3735936685, command-line-arguments\.y` + // arm64:`MOVW R27, command-line-arguments\.x` -`MOVW R27, command-line-arguments\.y` use(x) - // amd64:`MOVL \$3735936685, command-line-arguments\.x`, `MOVL \$3735936685, command-line-arguments\.y` - // arm64:`MOVW R27, command-line-arguments\.x`, `MOVW R27, command-line-arguments\.y` + // amd64:`MOVL \$3735936685, command-line-arguments\.x` `MOVL \$3735936685, command-line-arguments\.y` + // arm64:`MOVW R27, command-line-arguments\.x` `MOVW R27, command-line-arguments\.y` use(y) } diff --git a/test/codegen/clobberdeadreg.go b/test/codegen/clobberdeadreg.go index 24043438b2..a7488feff0 100644 --- a/test/codegen/clobberdeadreg.go +++ b/test/codegen/clobberdeadreg.go @@ -14,14 +14,14 @@ type S struct { func F(a, b, c int, d S) { // -2401018187971961171 is 0xdeaddeaddeaddead - // amd64:`MOVQ \$-2401018187971961171, AX`, `MOVQ \$-2401018187971961171, BX`, `MOVQ \$-2401018187971961171, CX` - // amd64:`MOVQ \$-2401018187971961171, DX`, `MOVQ \$-2401018187971961171, SI`, `MOVQ \$-2401018187971961171, DI` - // amd64:`MOVQ \$-2401018187971961171, R8`, `MOVQ \$-2401018187971961171, R9`, `MOVQ \$-2401018187971961171, R10` - // amd64:`MOVQ \$-2401018187971961171, R11`, `MOVQ \$-2401018187971961171, R12`, `MOVQ \$-2401018187971961171, R13` + // amd64:`MOVQ \$-2401018187971961171, AX` `MOVQ \$-2401018187971961171, BX` `MOVQ \$-2401018187971961171, CX` + // amd64:`MOVQ \$-2401018187971961171, DX` `MOVQ \$-2401018187971961171, SI` `MOVQ \$-2401018187971961171, DI` + // amd64:`MOVQ \$-2401018187971961171, R8` `MOVQ \$-2401018187971961171, R9` `MOVQ \$-2401018187971961171, R10` + // amd64:`MOVQ \$-2401018187971961171, R11` `MOVQ \$-2401018187971961171, R12` `MOVQ \$-2401018187971961171, R13` // amd64:-`MOVQ \$-2401018187971961171, BP` // frame pointer is not clobbered StackArgsCall([10]int{a, b, c}) - // amd64:`MOVQ \$-2401018187971961171, R12`, `MOVQ \$-2401018187971961171, R13`, `MOVQ \$-2401018187971961171, DX` - // amd64:-`MOVQ \$-2401018187971961171, AX`, -`MOVQ \$-2401018187971961171, R11` // register args are not clobbered + // amd64:`MOVQ \$-2401018187971961171, R12` `MOVQ \$-2401018187971961171, R13` `MOVQ \$-2401018187971961171, DX` + // amd64:-`MOVQ \$-2401018187971961171, AX` -`MOVQ \$-2401018187971961171, R11` // register args are not clobbered RegArgsCall(a, b, c, d) } diff --git a/test/codegen/comparisons.go b/test/codegen/comparisons.go index d3cb2c1921..ce08158d81 100644 --- a/test/codegen/comparisons.go +++ b/test/codegen/comparisons.go @@ -22,17 +22,17 @@ import ( func CompareString1(s string) bool { // amd64:`CMPW \(.*\), [$]` - // arm64:`MOVHU \(.*\), [R]`,`MOVD [$]`,`CMPW R` - // ppc64le:`MOVHZ \(.*\), [R]`,`CMPW .*, [$]` - // s390x:`MOVHBR \(.*\), [R]`,`CMPW .*, [$]` + // arm64:`MOVHU \(.*\), [R]` `MOVD [$]` `CMPW R` + // ppc64le:`MOVHZ \(.*\), [R]` `CMPW .*, [$]` + // s390x:`MOVHBR \(.*\), [R]` `CMPW .*, [$]` return s == "xx" } func CompareString2(s string) bool { // amd64:`CMPL \(.*\), [$]` - // arm64:`MOVWU \(.*\), [R]`,`CMPW .*, [R]` - // ppc64le:`MOVWZ \(.*\), [R]`,`CMPW .*, [R]` - // s390x:`MOVWBR \(.*\), [R]`,`CMPW .*, [$]` + // arm64:`MOVWU \(.*\), [R]` `CMPW .*, [R]` + // ppc64le:`MOVWZ \(.*\), [R]` `CMPW .*, [R]` + // s390x:`MOVWBR \(.*\), [R]` `CMPW .*, [$]` return s == "xxxx" } @@ -80,9 +80,9 @@ func CompareArray5(a, b [15]byte) bool { // This was a TODO in mapaccess1_faststr func CompareArray6(a, b unsafe.Pointer) bool { // amd64:`CMPL \(.*\), [A-Z]` - // arm64:`MOVWU \(.*\), [R]`,`CMPW .*, [R]` - // ppc64le:`MOVWZ \(.*\), [R]`,`CMPW .*, [R]` - // s390x:`MOVWBR \(.*\), [R]`,`CMPW .*, [R]` + // arm64:`MOVWU \(.*\), [R]` `CMPW .*, [R]` + // ppc64le:`MOVWZ \(.*\), [R]` `CMPW .*, [R]` + // s390x:`MOVWBR \(.*\), [R]` `CMPW .*, [R]` return *((*[4]byte)(a)) != *((*[4]byte)(b)) } @@ -209,28 +209,28 @@ func CmpZero4(a int64, ptr *int) { } func CmpToZero(a, b, d int32, e, f int64, deOptC0, deOptC1 bool) int32 { - // arm:`TST`,-`AND` - // arm64:`TSTW`,-`AND` - // 386:`TESTL`,-`ANDL` - // amd64:`TESTL`,-`ANDL` + // arm:`TST` -`AND` + // arm64:`TSTW` -`AND` + // 386:`TESTL` -`ANDL` + // amd64:`TESTL` -`ANDL` c0 := a&b < 0 - // arm:`CMN`,-`ADD` - // arm64:`CMNW`,-`ADD` + // arm:`CMN` -`ADD` + // arm64:`CMNW` -`ADD` c1 := a+b < 0 - // arm:`TEQ`,-`XOR` + // arm:`TEQ` -`XOR` c2 := a^b < 0 - // arm64:`TST`,-`AND` - // amd64:`TESTQ`,-`ANDQ` + // arm64:`TST` -`AND` + // amd64:`TESTQ` -`ANDQ` c3 := e&f < 0 - // arm64:`CMN`,-`ADD` + // arm64:`CMN` -`ADD` c4 := e+f < 0 // not optimized to single CMNW/CMN due to further use of b+d - // arm64:`ADD`,-`CMNW` - // arm:`ADD`,-`CMN` + // arm64:`ADD` -`CMNW` + // arm:`ADD` -`CMN` c5 := b+d == 0 // not optimized to single TSTW/TST due to further use of a&d - // arm64:`AND`,-`TSTW` - // arm:`AND`,-`TST` + // arm64:`AND` -`TSTW` + // arm:`AND` -`TST` // 386:`ANDL` c6 := a&d >= 0 // For arm64, could be TST+BGE or AND+TBZ @@ -308,56 +308,56 @@ func CmpLogicalToZero(a, b, c uint32, d, e, f, g uint64) uint64 { // 'x-const' might be canonicalized to 'x+(-const)', so we check both // CMN and CMP for subtraction expressions to make the pattern robust. func CmpToZero_ex1(a int64, e int32) int { - // arm64:`CMN`,-`ADD`,`(BMI|BPL)` + // arm64:`CMN` -`ADD` `(BMI|BPL)` if a+3 < 0 { return 1 } - // arm64:`CMN`,-`ADD`,`BEQ`,`(BMI|BPL)` + // arm64:`CMN` -`ADD` `BEQ` `(BMI|BPL)` if a+5 <= 0 { return 1 } - // arm64:`CMN`,-`ADD`,`(BMI|BPL)` + // arm64:`CMN` -`ADD` `(BMI|BPL)` if a+13 >= 0 { return 2 } - // arm64:`CMP|CMN`,-`(ADD|SUB)`,`(BMI|BPL)` + // arm64:`CMP|CMN` -`(ADD|SUB)` `(BMI|BPL)` if a-7 < 0 { return 3 } - // arm64:`SUB`,`TBZ` + // arm64:`SUB` `TBZ` if a-11 >= 0 { return 4 } - // arm64:`SUB`,`CMP`,`BGT` + // arm64:`SUB` `CMP` `BGT` if a-19 > 0 { return 4 } - // arm64:`CMNW`,-`ADDW`,`(BMI|BPL)` - // arm:`CMN`,-`ADD`,`(BMI|BPL)` + // arm64:`CMNW` -`ADDW` `(BMI|BPL)` + // arm:`CMN` -`ADD` `(BMI|BPL)` if e+3 < 0 { return 5 } - // arm64:`CMNW`,-`ADDW`,`(BMI|BPL)` - // arm:`CMN`,-`ADD`,`(BMI|BPL)` + // arm64:`CMNW` -`ADDW` `(BMI|BPL)` + // arm:`CMN` -`ADD` `(BMI|BPL)` if e+13 >= 0 { return 6 } - // arm64:`CMPW|CMNW`,`(BMI|BPL)` - // arm:`CMP|CMN`, -`(ADD|SUB)`, `(BMI|BPL)` + // arm64:`CMPW|CMNW` `(BMI|BPL)` + // arm:`CMP|CMN` -`(ADD|SUB)` `(BMI|BPL)` if e-7 < 0 { return 7 } - // arm64:`SUB`,`TBNZ` - // arm:`CMP|CMN`, -`(ADD|SUB)`, `(BMI|BPL)` + // arm64:`SUB` `TBNZ` + // arm:`CMP|CMN` -`(ADD|SUB)` `(BMI|BPL)` if e-11 >= 0 { return 8 } @@ -368,29 +368,29 @@ func CmpToZero_ex1(a int64, e int32) int { // var + var // TODO: optimize 'var - var' func CmpToZero_ex2(a, b, c int64, e, f, g int32) int { - // arm64:`CMN`,-`ADD`,`(BMI|BPL)` + // arm64:`CMN` -`ADD` `(BMI|BPL)` if a+b < 0 { return 1 } - // arm64:`CMN`,-`ADD`,`BEQ`,`(BMI|BPL)` + // arm64:`CMN` -`ADD` `BEQ` `(BMI|BPL)` if a+c <= 0 { return 1 } - // arm64:`CMN`,-`ADD`,`(BMI|BPL)` + // arm64:`CMN` -`ADD` `(BMI|BPL)` if b+c >= 0 { return 2 } - // arm64:`CMNW`,-`ADDW`,`(BMI|BPL)` - // arm:`CMN`,-`ADD`,`(BMI|BPL)` + // arm64:`CMNW` -`ADDW` `(BMI|BPL)` + // arm:`CMN` -`ADD` `(BMI|BPL)` if e+f < 0 { return 5 } - // arm64:`CMNW`,-`ADDW`,`(BMI|BPL)` - // arm:`CMN`,-`ADD`,`(BMI|BPL)` + // arm64:`CMNW` -`ADDW` `(BMI|BPL)` + // arm:`CMN` -`ADD` `(BMI|BPL)` if f+g >= 0 { return 6 } @@ -399,24 +399,24 @@ func CmpToZero_ex2(a, b, c int64, e, f, g int32) int { // var + var*var func CmpToZero_ex3(a, b, c, d int64, e, f, g, h int32) int { - // arm64:`CMN`,-`MADD`,`MUL`,`(BMI|BPL)` + // arm64:`CMN` -`MADD` `MUL` `(BMI|BPL)` if a+b*c < 0 { return 1 } - // arm64:`CMN`,-`MADD`,`MUL`,`(BMI|BPL)` + // arm64:`CMN` -`MADD` `MUL` `(BMI|BPL)` if b+c*d >= 0 { return 2 } - // arm64:`CMNW`,-`MADDW`,`MULW`,`BEQ`,`(BMI|BPL)` - // arm:`CMN`,-`MULA`,`MUL`,`BEQ`,`(BMI|BPL)` + // arm64:`CMNW` -`MADDW` `MULW` `BEQ` `(BMI|BPL)` + // arm:`CMN` -`MULA` `MUL` `BEQ` `(BMI|BPL)` if e+f*g > 0 { return 5 } - // arm64:`CMNW`,-`MADDW`,`MULW`,`BEQ`,`(BMI|BPL)` - // arm:`CMN`,-`MULA`,`MUL`,`BEQ`,`(BMI|BPL)` + // arm64:`CMNW` -`MADDW` `MULW` `BEQ` `(BMI|BPL)` + // arm:`CMN` -`MULA` `MUL` `BEQ` `(BMI|BPL)` if f+g*h <= 0 { return 6 } @@ -425,22 +425,22 @@ func CmpToZero_ex3(a, b, c, d int64, e, f, g, h int32) int { // var - var*var func CmpToZero_ex4(a, b, c, d int64, e, f, g, h int32) int { - // arm64:`CMP`,-`MSUB`,`MUL`,`BEQ`,`(BMI|BPL)` + // arm64:`CMP` -`MSUB` `MUL` `BEQ` `(BMI|BPL)` if a-b*c > 0 { return 1 } - // arm64:`CMP`,-`MSUB`,`MUL`,`(BMI|BPL)` + // arm64:`CMP` -`MSUB` `MUL` `(BMI|BPL)` if b-c*d >= 0 { return 2 } - // arm64:`CMPW`,-`MSUBW`,`MULW`,`(BMI|BPL)` + // arm64:`CMPW` -`MSUBW` `MULW` `(BMI|BPL)` if e-f*g < 0 { return 5 } - // arm64:`CMPW`,-`MSUBW`,`MULW`,`(BMI|BPL)` + // arm64:`CMPW` -`MSUBW` `MULW` `(BMI|BPL)` if f-g*h >= 0 { return 6 } @@ -448,12 +448,12 @@ func CmpToZero_ex4(a, b, c, d int64, e, f, g, h int32) int { } func CmpToZero_ex5(e, f int32, u uint32) int { - // arm:`CMN`,-`ADD`,`BEQ`,`(BMI|BPL)` + // arm:`CMN` -`ADD` `BEQ` `(BMI|BPL)` if e+f<<1 > 0 { return 1 } - // arm:`CMP`,-`SUB`,`(BMI|BPL)` + // arm:`CMP` -`SUB` `(BMI|BPL)` if f-int32(u>>2) >= 0 { return 2 } @@ -719,47 +719,47 @@ func equalVarString17(a string) bool { func cmpToCmn(a, b, c, d int) int { var c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11 int - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if a < -8 { c1 = 1 } - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if a+1 == 0 { c2 = 1 } - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if a+3 != 0 { c3 = 1 } - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if a+b == 0 { c4 = 1 } - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if b+c != 0 { c5 = 1 } - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if a == -c { c6 = 1 } - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if b != -d { c7 = 1 } - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if a*b+c == 0 { c8 = 1 } - // arm64:`CMN`,-`CMP` + // arm64:`CMN` -`CMP` if a*c+b != 0 { c9 = 1 } - // arm64:`CMP`,-`CMN` + // arm64:`CMP` -`CMN` if b*c-a == 0 { c10 = 1 } - // arm64:`CMP`,-`CMN` + // arm64:`CMP` -`CMN` if a*d-b != 0 { c11 = 1 } @@ -768,19 +768,19 @@ func cmpToCmn(a, b, c, d int) int { func cmpToCmnLessThan(a, b, c, d int) int { var c1, c2, c3, c4 int - // arm64:`CMN`,`CSET MI`,-`CMP` + // arm64:`CMN` `CSET MI` -`CMP` if a+1 < 0 { c1 = 1 } - // arm64:`CMN`,`CSET MI`,-`CMP` + // arm64:`CMN` `CSET MI` -`CMP` if a+b < 0 { c2 = 1 } - // arm64:`CMN`,`CSET MI`,-`CMP` + // arm64:`CMN` `CSET MI` -`CMP` if a*b+c < 0 { c3 = 1 } - // arm64:`CMP`,`CSET MI`,-`CMN` + // arm64:`CMP` `CSET MI` -`CMN` if a-b*c < 0 { c4 = 1 } @@ -837,19 +837,19 @@ func ge128Signed64(x int64) bool { func cmpToCmnGreaterThanEqual(a, b, c, d int) int { var c1, c2, c3, c4 int - // arm64:`CMN`,`CSET PL`,-`CMP` + // arm64:`CMN` `CSET PL` -`CMP` if a+1 >= 0 { c1 = 1 } - // arm64:`CMN`,`CSET PL`,-`CMP` + // arm64:`CMN` `CSET PL` -`CMP` if a+b >= 0 { c2 = 1 } - // arm64:`CMN`,`CSET PL`,-`CMP` + // arm64:`CMN` `CSET PL` -`CMP` if a*b+c >= 0 { c3 = 1 } - // arm64:`CMP`,`CSET PL`,-`CMN` + // arm64:`CMP` `CSET PL` -`CMN` if a-b*c >= 0 { c4 = 1 } @@ -906,7 +906,7 @@ type Point struct { // certain conditions, see canonLessThan, so if the code below does not // generate an InvertFlags OP, this check may fail. func invertLessThanNoov(p1, p2, p3 Point) bool { - // arm64:`CMP`,`CSET`,`CSEL` + // arm64:`CMP` `CSET` `CSEL` return (p1.X-p3.X)*(p2.Y-p3.Y)-(p2.X-p3.X)*(p1.Y-p3.Y) < 0 } diff --git a/test/codegen/condmove.go b/test/codegen/condmove.go index 5633da10fe..61f47b4d8f 100644 --- a/test/codegen/condmove.go +++ b/test/codegen/condmove.go @@ -232,7 +232,7 @@ func cmovinc(cond bool, a, b, c int) { } else { x0 = b + 1 } - // arm64:"CSINC NE", -"CSEL" + // arm64:"CSINC NE" -"CSEL" r0 = x0 if cond { @@ -240,13 +240,13 @@ func cmovinc(cond bool, a, b, c int) { } else { x1 = a } - // arm64:"CSINC EQ", -"CSEL" + // arm64:"CSINC EQ" -"CSEL" r1 = x1 if cond { c++ } - // arm64:"CSINC EQ", -"CSEL" + // arm64:"CSINC EQ" -"CSEL" r2 = c } @@ -258,7 +258,7 @@ func cmovinv(cond bool, a, b int) { } else { x0 = ^b } - // arm64:"CSINV NE", -"CSEL" + // arm64:"CSINV NE" -"CSEL" r0 = x0 if cond { @@ -266,7 +266,7 @@ func cmovinv(cond bool, a, b int) { } else { x1 = a } - // arm64:"CSINV EQ", -"CSEL" + // arm64:"CSINV EQ" -"CSEL" r1 = x1 } @@ -278,7 +278,7 @@ func cmovneg(cond bool, a, b, c int) { } else { x0 = -b } - // arm64:"CSNEG NE", -"CSEL" + // arm64:"CSNEG NE" -"CSEL" r0 = x0 if cond { @@ -286,7 +286,7 @@ func cmovneg(cond bool, a, b, c int) { } else { x1 = a } - // arm64:"CSNEG EQ", -"CSEL" + // arm64:"CSNEG EQ" -"CSEL" r1 = x1 } @@ -298,7 +298,7 @@ func cmovsetm(cond bool, x int) { } else { x0 = 0 } - // arm64:"CSETM NE", -"CSEL" + // arm64:"CSETM NE" -"CSEL" r0 = x0 if cond { @@ -306,7 +306,7 @@ func cmovsetm(cond bool, x int) { } else { x1 = -1 } - // arm64:"CSETM EQ", -"CSEL" + // arm64:"CSETM EQ" -"CSEL" r1 = x1 } @@ -318,7 +318,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x0 = b + 1 } - // arm64:"CSINC MI", -"CSEL" + // arm64:"CSINC MI" -"CSEL" r0 = x0 if s <= t { @@ -326,7 +326,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x1 = ^b } - // arm64:"CSINV LS", -"CSEL" + // arm64:"CSINV LS" -"CSEL" r1 = x1 if s > t { @@ -334,7 +334,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x2 = -b } - // arm64:"CSNEG MI", -"CSEL" + // arm64:"CSNEG MI" -"CSEL" r2 = x2 if s >= t { @@ -342,7 +342,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x3 = 0 } - // arm64:"CSETM LS", -"CSEL" + // arm64:"CSETM LS" -"CSEL" r3 = x3 if s == t { @@ -350,7 +350,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x4 = b + 1 } - // arm64:"CSINC EQ", -"CSEL" + // arm64:"CSINC EQ" -"CSEL" r4 = x4 if s != t { @@ -358,7 +358,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x5 = b + 1 } - // arm64:"CSINC NE", -"CSEL" + // arm64:"CSINC NE" -"CSEL" r5 = x5 } @@ -370,7 +370,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x0 = a } - // arm64:"CSINC PL", -"CSEL" + // arm64:"CSINC PL" -"CSEL" r0 = x0 if s <= t { @@ -378,7 +378,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x1 = a } - // arm64:"CSINV HI", -"CSEL" + // arm64:"CSINV HI" -"CSEL" r1 = x1 if s > t { @@ -386,7 +386,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x2 = a } - // arm64:"CSNEG PL", -"CSEL" + // arm64:"CSNEG PL" -"CSEL" r2 = x2 if s >= t { @@ -394,7 +394,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x3 = -1 } - // arm64:"CSETM HI", -"CSEL" + // arm64:"CSETM HI" -"CSEL" r3 = x3 if s == t { @@ -402,7 +402,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x4 = a } - // arm64:"CSINC NE", -"CSEL" + // arm64:"CSINC NE" -"CSEL" r4 = x4 if s != t { @@ -410,7 +410,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x5 = a } - // arm64:"CSINC EQ", -"CSEL" + // arm64:"CSINC EQ" -"CSEL" r5 = x5 } @@ -419,7 +419,7 @@ func cmovzero1(c bool) int { if c { x = 182 } - // loong64:"MASKEQZ", -"MASKNEZ" + // loong64:"MASKEQZ" -"MASKNEZ" return x } @@ -428,7 +428,7 @@ func cmovzero2(c bool) int { if !c { x = 182 } - // loong64:"MASKNEZ", -"MASKEQZ" + // loong64:"MASKNEZ" -"MASKEQZ" return x } @@ -458,10 +458,10 @@ func cmovmathadd(a uint, b bool) uint { if b { a++ } - // amd64:"ADDQ", -"CMOV" - // arm64:"CSINC", -"CSEL" - // ppc64x:"ADD", -"ISEL" - // wasm:"I64Add", -"Select" + // amd64:"ADDQ" -"CMOV" + // arm64:"CSINC" -"CSEL" + // ppc64x:"ADD" -"ISEL" + // wasm:"I64Add" -"Select" return a } @@ -469,10 +469,10 @@ func cmovmathsub(a uint, b bool) uint { if b { a-- } - // amd64:"SUBQ", -"CMOV" - // arm64:"SUB", -"CSEL" - // ppc64x:"SUB", -"ISEL" - // wasm:"I64Sub", -"Select" + // amd64:"SUBQ" -"CMOV" + // arm64:"SUB" -"CSEL" + // ppc64x:"SUB" -"ISEL" + // wasm:"I64Sub" -"Select" return a } @@ -480,18 +480,18 @@ func cmovmathdouble(a uint, b bool) uint { if b { a *= 2 } - // amd64:"SHL", -"CMOV" - // amd64/v3:"SHL", -"CMOV", -"MOV" - // arm64:"LSL", -"CSEL" - // wasm:"I64Shl", -"Select" + // amd64:"SHL" -"CMOV" + // amd64/v3:"SHL" -"CMOV" -"MOV" + // arm64:"LSL" -"CSEL" + // wasm:"I64Shl" -"Select" return a } func cmovmathhalvei(a int, b bool) int { if b { // For some reason the compiler attributes the shift to inside this block rather than where the Phi node is. - // arm64:"ASR", -"CSEL" - // wasm:"I64ShrS", -"Select" + // arm64:"ASR" -"CSEL" + // wasm:"I64ShrS" -"Select" a /= 2 } // arm64:-"CSEL" @@ -503,10 +503,10 @@ func cmovmathhalveu(a uint, b bool) uint { if b { a /= 2 } - // amd64:"SHR", -"CMOV" - // amd64/v3:"SHR", -"CMOV", -"MOV" - // arm64:"LSR", -"CSEL" - // wasm:"I64ShrU", -"Select" + // amd64:"SHR" -"CMOV" + // amd64/v3:"SHR" -"CMOV" -"MOV" + // arm64:"LSR" -"CSEL" + // wasm:"I64ShrU" -"Select" return a } @@ -542,13 +542,13 @@ func branchlessBoolToUint8(b bool) (r uint8) { func cmovFromMulFromFlags64(x uint64, b bool) uint64 { // amd64:-"MOVB.ZX" r := uint64(branchlessBoolToUint8(b)) - // amd64:"CMOV",-"MOVB.ZX",-"MUL" + // amd64:"CMOV" -"MOVB.ZX" -"MUL" return x * r } func cmovFromMulFromFlags64sext(x int64, b bool) int64 { // amd64:-"MOVB.ZX" r := int64(int8(branchlessBoolToUint8(b))) - // amd64:"CMOV",-"MOVB.ZX",-"MUL" + // amd64:"CMOV" -"MOVB.ZX" -"MUL" return x * r } diff --git a/test/codegen/constants.go b/test/codegen/constants.go index 9b014b54b1..00c0f4e3d0 100644 --- a/test/codegen/constants.go +++ b/test/codegen/constants.go @@ -8,27 +8,27 @@ package codegen // A uint16 or sint16 constant shifted left. func shifted16BitConstants() (out [64]uint64) { - // ppc64x: "MOVD [$]8193,", "SLD [$]27," + // ppc64x: "MOVD [$]8193," "SLD [$]27," out[0] = 0x0000010008000000 - // ppc64x: "MOVD [$]-32767", "SLD [$]26," + // ppc64x: "MOVD [$]-32767" "SLD [$]26," out[1] = 0xFFFFFE0004000000 - // ppc64x: "MOVD [$]-1", "SLD [$]48," + // ppc64x: "MOVD [$]-1" "SLD [$]48," out[2] = 0xFFFF000000000000 - // ppc64x: "MOVD [$]65535", "SLD [$]44," + // ppc64x: "MOVD [$]65535" "SLD [$]44," out[3] = 0x0FFFF00000000000 return } // A contiguous set of 1 bits, potentially wrapping. func contiguousMaskConstants() (out [64]uint64) { - // ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]44, [$]63," + // ppc64x: "MOVD [$]-1" "RLDC R[0-9]+, [$]44, [$]63," out[0] = 0xFFFFF00000000001 - // ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]43, [$]63," + // ppc64x: "MOVD [$]-1" "RLDC R[0-9]+, [$]43, [$]63," out[1] = 0xFFFFF80000000001 - // ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]43, [$]4," + // ppc64x: "MOVD [$]-1" "RLDC R[0-9]+, [$]43, [$]4," out[2] = 0x0FFFF80000000000 - // ppc64x/power8: "MOVD [$]-1", "RLDC R[0-9]+, [$]33, [$]63," - // ppc64x/power9: "MOVD [$]-1", "RLDC R[0-9]+, [$]33, [$]63," + // ppc64x/power8: "MOVD [$]-1" "RLDC R[0-9]+, [$]33, [$]63," + // ppc64x/power9: "MOVD [$]-1" "RLDC R[0-9]+, [$]33, [$]63," // ppc64x/power10: "MOVD [$]-8589934591," out[3] = 0xFFFFFFFE00000001 return diff --git a/test/codegen/copy.go b/test/codegen/copy.go index a4b9bedbe8..72db2756f5 100644 --- a/test/codegen/copy.go +++ b/test/codegen/copy.go @@ -157,6 +157,6 @@ func ptrBothOffset() { // Verify #62698 on PPC64. func noMaskOnCopy(a []int, s string, x int) int { - // ppc64x:-"MOVD [$]-1", -"AND" + // ppc64x:-"MOVD [$]-1" -"AND" return a[x&^copy([]byte{}, s)] } diff --git a/test/codegen/divmod.go b/test/codegen/divmod.go index a8f8227364..adcba5dd73 100644 --- a/test/codegen/divmod.go +++ b/test/codegen/divmod.go @@ -290,7 +290,7 @@ func div3_uint16(i uint16) uint16 { } func div3_uint32(i uint32) uint32 { - // 386: "MOVL [$]-1431655765," "MULL", "SHRL [$]1," + // 386: "MOVL [$]-1431655765," "MULL" "SHRL [$]1," // arm64: "MOVD [$]2863311531," // arm64: "MUL" // arm64: "LSR [$]33," @@ -381,7 +381,7 @@ func div7_uint64(i uint64) uint64 { // 386: -".*CALL" // arm64: "MOVD [$]2635249153387078803," // arm64: "UMULH" - // arm64: "SUB", + // arm64: "SUB" // arm64: "ADD R[0-9]+>>1," // arm64: "LSR [$]2," // wasm: "I64Const [$]613566756" @@ -505,7 +505,7 @@ func ndivis32_int64(i int64) bool { func div_divis32_uint8(i uint8) (uint8, bool) { // 386: "SHRB [$]5," - // 386: "TESTB [$]31,", + // 386: "TESTB [$]31," // 386: "SETEQ" // arm64: "UBFX [$]5, R[0-9]+, [$]3" // arm64: "TSTW [$]31," @@ -515,7 +515,7 @@ func div_divis32_uint8(i uint8) (uint8, bool) { func div_ndivis32_uint8(i uint8) (uint8, bool) { // 386: "SHRB [$]5," - // 386: "TESTB [$]31,", + // 386: "TESTB [$]31," // 386: "SETNE" // arm64: "UBFX [$]5, R[0-9]+, [$]3" // arm64: "TSTW [$]31," @@ -525,7 +525,7 @@ func div_ndivis32_uint8(i uint8) (uint8, bool) { func div_divis32_uint16(i uint16) (uint16, bool) { // 386: "SHRW [$]5," - // 386: "TESTW [$]31,", + // 386: "TESTW [$]31," // 386: "SETEQ" // arm64: "UBFX [$]5, R[0-9]+, [$]11" // arm64: "TSTW [$]31," @@ -535,7 +535,7 @@ func div_divis32_uint16(i uint16) (uint16, bool) { func div_ndivis32_uint16(i uint16) (uint16, bool) { // 386: "SHRW [$]5," - // 386: "TESTW [$]31,", + // 386: "TESTW [$]31," // 386: "SETNE" // arm64: "UBFX [$]5, R[0-9]+, [$]11," // arm64: "TSTW [$]31," @@ -545,7 +545,7 @@ func div_ndivis32_uint16(i uint16) (uint16, bool) { func div_divis32_uint32(i uint32) (uint32, bool) { // 386: "SHRL [$]5," - // 386: "TESTL [$]31,", + // 386: "TESTL [$]31," // 386: "SETEQ" // arm64: "UBFX [$]5, R[0-9]+, [$]27," // arm64: "TSTW [$]31," @@ -555,7 +555,7 @@ func div_divis32_uint32(i uint32) (uint32, bool) { func div_ndivis32_uint32(i uint32) (uint32, bool) { // 386: "SHRL [$]5," - // 386: "TESTL [$]31,", + // 386: "TESTL [$]31," // 386: "SETNE" // arm64: "UBFX [$]5, R[0-9]+, [$]27," // arm64: "TSTW [$]31," @@ -566,7 +566,7 @@ func div_ndivis32_uint32(i uint32) (uint32, bool) { func div_divis32_uint64(i uint64) (uint64, bool) { // 386: "SHRL [$]5," // 386: "SHLL [$]27," - // 386: "TESTL [$]31,", + // 386: "TESTL [$]31," // 386: "SETEQ" // arm64: "LSR [$]5," // arm64: "TST [$]31," @@ -577,7 +577,7 @@ func div_divis32_uint64(i uint64) (uint64, bool) { func div_ndivis32_uint64(i uint64) (uint64, bool) { // 386: "SHRL [$]5," // 386: "SHLL [$]27," - // 386: "TESTL [$]31,", + // 386: "TESTL [$]31," // 386: "SETNE" // arm64: "LSR [$]5," // arm64: "TST [$]31," @@ -589,7 +589,7 @@ func div_divis32_int8(i int8) (int8, bool) { // 386: "SARB [$]7," // 386: "SHRB [$]3," // 386: "SARB [$]5," - // 386: "TESTB [$]31,", + // 386: "TESTB [$]31," // 386: "SETEQ" // arm64: "SBFX [$]7, R[0-9]+, [$]1," // arm64: "ADD R[0-9]+>>3," @@ -603,7 +603,7 @@ func div_ndivis32_int8(i int8) (int8, bool) { // 386: "SARB [$]7," // 386: "SHRB [$]3," // 386: "SARB [$]5," - // 386: "TESTB [$]31,", + // 386: "TESTB [$]31," // 386: "SETNE" // arm64: "SBFX [$]7, R[0-9]+, [$]1," // arm64: "ADD R[0-9]+>>3," @@ -617,7 +617,7 @@ func div_divis32_int16(i int16) (int16, bool) { // 386: "SARW [$]15," // 386: "SHRW [$]11," // 386: "SARW [$]5," - // 386: "TESTW [$]31,", + // 386: "TESTW [$]31," // 386: "SETEQ" // arm64: "SBFX [$]15, R[0-9]+, [$]1," // arm64: "ADD R[0-9]+>>11," @@ -631,7 +631,7 @@ func div_ndivis32_int16(i int16) (int16, bool) { // 386: "SARW [$]15," // 386: "SHRW [$]11," // 386: "SARW [$]5," - // 386: "TESTW [$]31,", + // 386: "TESTW [$]31," // 386: "SETNE" // arm64: "SBFX [$]15, R[0-9]+, [$]1," // arm64: "ADD R[0-9]+>>11," @@ -645,7 +645,7 @@ func div_divis32_int32(i int32) (int32, bool) { // 386: "SARL [$]31," // 386: "SHRL [$]27," // 386: "SARL [$]5," - // 386: "TESTL [$]31,", + // 386: "TESTL [$]31," // 386: "SETEQ" // arm64: "SBFX [$]31, R[0-9]+, [$]1," // arm64: "ADD R[0-9]+>>27," @@ -659,7 +659,7 @@ func div_ndivis32_int32(i int32) (int32, bool) { // 386: "SARL [$]31," // 386: "SHRL [$]27," // 386: "SARL [$]5," - // 386: "TESTL [$]31,", + // 386: "TESTL [$]31," // 386: "SETNE" // arm64: "SBFX [$]31, R[0-9]+, [$]1," // arm64: "ADD R[0-9]+>>27," @@ -674,7 +674,7 @@ func div_divis32_int64(i int64) (int64, bool) { // 386: "SHRL [$]27," // 386: "SARL [$]5," // 386: "SHLL [$]27," - // 386: "TESTL [$]31,", + // 386: "TESTL [$]31," // 386: "SETEQ" // arm64: "ASR [$]63," // arm64: "ADD R[0-9]+>>59," @@ -689,7 +689,7 @@ func div_ndivis32_int64(i int64) (int64, bool) { // 386: "SHRL [$]27," // 386: "SARL [$]5," // 386: "SHLL [$]27," - // 386: "TESTL [$]31,", + // 386: "TESTL [$]31," // 386: "SETNE" // arm64: "ASR [$]63," // arm64: "ADD R[0-9]+>>59," diff --git a/test/codegen/ifaces.go b/test/codegen/ifaces.go index 59139ceab3..a6d89f26a5 100644 --- a/test/codegen/ifaces.go +++ b/test/codegen/ifaces.go @@ -21,28 +21,28 @@ func NopConvertGeneric[T any](x T) T { var NopConvertGenericIface = NopConvertGeneric[I] func ConvToM(x any) I { - // amd64:`CALL runtime.typeAssert`,`MOVL 16\(.*\)`,`MOVQ 8\(.*\)(.*\*1)` - // arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU`,`MOVD \(R.*\)\(R.*\)` + // amd64:`CALL runtime.typeAssert` `MOVL 16\(.*\)` `MOVQ 8\(.*\)(.*\*1)` + // arm64:`CALL runtime.typeAssert` `LDAR` `MOVWU` `MOVD \(R.*\)\(R.*\)` return x.(I) } func e1(x any, y *int) bool { - // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET EQ` + // amd64:-`.*faceeq` `SETEQ` + // arm64:-`.*faceeq` `CSET EQ` return x == y } func e2(x any, y *int) bool { - // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET EQ` + // amd64:-`.*faceeq` `SETEQ` + // arm64:-`.*faceeq` `CSET EQ` return y == x } type E *int func e3(x any, y E) bool { - // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET EQ` + // amd64:-`.*faceeq` `SETEQ` + // arm64:-`.*faceeq` `CSET EQ` return x == y } @@ -51,13 +51,13 @@ type T int func (t *T) M() {} func i1(x I, y *T) bool { - // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET EQ` + // amd64:-`.*faceeq` `SETEQ` + // arm64:-`.*faceeq` `CSET EQ` return x == y } func i2(x I, y *T) bool { - // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET EQ` + // amd64:-`.*faceeq` `SETEQ` + // arm64:-`.*faceeq` `CSET EQ` return y == x } diff --git a/test/codegen/issue68845.go b/test/codegen/issue68845.go index b5ab4a0fc8..e61437878e 100644 --- a/test/codegen/issue68845.go +++ b/test/codegen/issue68845.go @@ -11,7 +11,7 @@ type T1 struct { } func f1() *T1 { - // amd64:-`MOVQ [$]0`,-`MOVUPS X15` + // amd64:-`MOVQ [$]0` -`MOVUPS X15` return &T1{} } @@ -20,7 +20,7 @@ type T2 struct { } func f2() *T2 { - // amd64:-`MOVQ [$]0`,-`MOVUPS X15` + // amd64:-`MOVQ [$]0` -`MOVUPS X15` return &T2{} } @@ -29,7 +29,7 @@ type T3 struct { } func f3() *T3 { - // amd64:-`MOVQ [$]0`,-`MOVUPS X15` + // amd64:-`MOVQ [$]0` -`MOVUPS X15` return &T3{} } @@ -38,7 +38,7 @@ type T4 struct { } func f4() *T4 { - // amd64:-`MOVQ [$]0`,-`MOVUPS X15` + // amd64:-`MOVQ [$]0` -`MOVUPS X15` return &T4{} } @@ -47,6 +47,6 @@ type T5 struct { } func f5() *T5 { - // amd64:-`MOVQ [$]0`,-`MOVUPS X15` + // amd64:-`MOVQ [$]0` -`MOVUPS X15` return &T5{} } diff --git a/test/codegen/issue69635.go b/test/codegen/issue69635.go index 5fc269b315..7617a27740 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 \$17, AX$`, `ANDL \$1016, AX$` + // amd64: `SHRQ \$17, AX$` `ANDL \$1016, AX$` return v << 3 } diff --git a/test/codegen/issue74788.go b/test/codegen/issue74788.go index 0e670d17cd..e632a33bba 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 X[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 X[0-9]+,[^\n]+$` + // amd64:2`MOVUPS[^,]+, X[0-9]+$` 2`MOVUPS X[0-9]+,[^\n]+$` return a } diff --git a/test/codegen/maps.go b/test/codegen/maps.go index 48438eb90c..c7593e00a5 100644 --- a/test/codegen/maps.go +++ b/test/codegen/maps.go @@ -54,7 +54,7 @@ func AccessStringStruct2(m map[string]Struct, k string) bool { } func AccessIntArrayLarge2(m map[int][512]int, k int) bool { - // amd64:-"REP",-"MOVSQ" + // amd64:-"REP" -"MOVSQ" _, ok := m[k] return ok } diff --git a/test/codegen/math.go b/test/codegen/math.go index ef8c51e658..4eaf811b5d 100644 --- a/test/codegen/math.go +++ b/test/codegen/math.go @@ -117,7 +117,7 @@ func copysign(a, b, c float64) { // s390x:"LNDFR " -"MOVD " (no integer load/store) // ppc64x:"FCPSGN" // riscv64:"FSGNJD" - // arm64:"ORR", -"AND" + // arm64:"ORR" -"AND" sink64[1] = math.Copysign(c, -1) // Like math.Copysign(c, -1), but with integer operations. Useful @@ -333,13 +333,13 @@ func nanGenerate32() float32 { func outOfBoundsConv(i32 *[2]int32, u32 *[2]uint32, i64 *[2]int64, u64 *[2]uint64) { // arm64: "FCVTZSDW" - // amd64: "CVTTSD2SL", "CVTSD2SS" + // amd64: "CVTTSD2SL" "CVTSD2SS" i32[0] = int32(two40()) // arm64: "FCVTZSDW" - // amd64: "CVTTSD2SL", "CVTSD2SS" + // amd64: "CVTTSD2SL" "CVTSD2SS" i32[1] = int32(-two40()) // arm64: "FCVTZSDW" - // amd64: "CVTTSD2SL", "CVTSD2SS" + // amd64: "CVTTSD2SL" "CVTSD2SS" u32[0] = uint32(two41()) // on arm64, this uses an explicit <0 comparison, so it constant folds. // on amd64, this uses an explicit <0 comparison, so it constant folds. diff --git a/test/codegen/mathbits.go b/test/codegen/mathbits.go index 6f7014688a..57ef2cc494 100644 --- a/test/codegen/mathbits.go +++ b/test/codegen/mathbits.go @@ -17,7 +17,7 @@ import ( func LeadingZeros(n uint) int { // amd64/v1,amd64/v2:"BSRQ" - // amd64/v3:"LZCNTQ", -"BSRQ" + // amd64/v3:"LZCNTQ" -"BSRQ" // arm64:"CLZ" // arm:"CLZ" // loong64:"CLZV" -"SUB" @@ -31,7 +31,7 @@ func LeadingZeros(n uint) int { func LeadingZeros64(n uint64) int { // amd64/v1,amd64/v2:"BSRQ" - // amd64/v3:"LZCNTQ", -"BSRQ" + // amd64/v3:"LZCNTQ" -"BSRQ" // arm:"CLZ" // arm64:"CLZ" // loong64:"CLZV" -"SUB" @@ -536,7 +536,7 @@ func IterateBits8(n uint8) int { func Add(x, y, ci uint) (r, co uint) { // arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP" // amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ" - // ppc64x: "ADDC", "ADDE", "ADDZE" + // ppc64x: "ADDC" "ADDE" "ADDZE" // s390x:"ADDE" "ADDC [$]-1," // riscv64: "ADD" "SLTU" return bits.Add(x, y, ci) @@ -545,8 +545,8 @@ func Add(x, y, ci uint) (r, co uint) { func AddC(x, ci uint) (r, co uint) { // arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP" // amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ" - // loong64: "ADDV", "SGTU" - // ppc64x: "ADDC", "ADDE", "ADDZE" + // loong64: "ADDV" "SGTU" + // ppc64x: "ADDC" "ADDE" "ADDZE" // s390x:"ADDE" "ADDC [$]-1," // mips64:"ADDV" "SGTU" // riscv64: "ADD" "SLTU" @@ -556,8 +556,8 @@ func AddC(x, ci uint) (r, co uint) { func AddZ(x, y uint) (r, co uint) { // arm64:"ADDS" "ADC" -"ADCS" -"ADD " -"CMP" // amd64:"ADDQ" "SBBQ" "NEGQ" -"NEGL" -"ADCQ" - // loong64: "ADDV", "SGTU" - // ppc64x: "ADDC", -"ADDE", "ADDZE" + // loong64: "ADDV" "SGTU" + // ppc64x: "ADDC" -"ADDE" "ADDZE" // s390x:"ADDC" -"ADDC [$]-1," // mips64:"ADDV" "SGTU" // riscv64: "ADD" "SLTU" @@ -567,8 +567,8 @@ func AddZ(x, y uint) (r, co uint) { func AddR(x, y, ci uint) uint { // arm64:"ADDS" "ADCS" -"ADD " -"CMP" // amd64:"NEGL" "ADCQ" -"SBBQ" -"NEGQ" - // loong64: "ADDV", -"SGTU" - // ppc64x: "ADDC", "ADDE", -"ADDZE" + // loong64: "ADDV" -"SGTU" + // ppc64x: "ADDC" "ADDE" -"ADDZE" // s390x:"ADDE" "ADDC [$]-1," // mips64:"ADDV" -"SGTU" // riscv64: "ADD" -"SLTU" @@ -589,8 +589,8 @@ func AddM(p, q, r *[3]uint) { func Add64(x, y, ci uint64) (r, co uint64) { // arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP" // amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ" - // loong64: "ADDV", "SGTU" - // ppc64x: "ADDC", "ADDE", "ADDZE" + // loong64: "ADDV" "SGTU" + // ppc64x: "ADDC" "ADDE" "ADDZE" // s390x:"ADDE" "ADDC [$]-1," // mips64:"ADDV" "SGTU" // riscv64: "ADD" "SLTU" @@ -600,8 +600,8 @@ func Add64(x, y, ci uint64) (r, co uint64) { func Add64C(x, ci uint64) (r, co uint64) { // arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP" // amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ" - // loong64: "ADDV", "SGTU" - // ppc64x: "ADDC", "ADDE", "ADDZE" + // loong64: "ADDV" "SGTU" + // ppc64x: "ADDC" "ADDE" "ADDZE" // s390x:"ADDE" "ADDC [$]-1," // mips64:"ADDV" "SGTU" // riscv64: "ADD" "SLTU" @@ -611,8 +611,8 @@ func Add64C(x, ci uint64) (r, co uint64) { func Add64Z(x, y uint64) (r, co uint64) { // arm64:"ADDS" "ADC" -"ADCS" -"ADD " -"CMP" // amd64:"ADDQ" "SBBQ" "NEGQ" -"NEGL" -"ADCQ" - // loong64: "ADDV", "SGTU" - // ppc64x: "ADDC", -"ADDE", "ADDZE" + // loong64: "ADDV" "SGTU" + // ppc64x: "ADDC" -"ADDE" "ADDZE" // s390x:"ADDC" -"ADDC [$]-1," // mips64:"ADDV" "SGTU" // riscv64: "ADD" "SLTU" @@ -622,8 +622,8 @@ func Add64Z(x, y uint64) (r, co uint64) { func Add64R(x, y, ci uint64) uint64 { // arm64:"ADDS" "ADCS" -"ADD " -"CMP" // amd64:"NEGL" "ADCQ" -"SBBQ" -"NEGQ" - // loong64: "ADDV", -"SGTU" - // ppc64x: "ADDC", "ADDE", -"ADDZE" + // loong64: "ADDV" -"SGTU" + // ppc64x: "ADDC" "ADDE" -"ADDZE" // s390x:"ADDE" "ADDC [$]-1," // mips64:"ADDV" -"SGTU" // riscv64: "ADD" -"SLTU" @@ -636,7 +636,7 @@ func Add64M(p, q, r *[3]uint64) { r[0], c = bits.Add64(p[0], q[0], c) // arm64:"ADCS" -"ADD " -"CMP" // amd64:"ADCQ" -"NEGL" -"SBBQ" -"NEGQ" - // ppc64x: -"ADDC", "ADDE", -"ADDZE" + // ppc64x: -"ADDC" "ADDE" -"ADDZE" // s390x:"ADDE" -"ADDC [$]-1," r[1], c = bits.Add64(p[1], q[1], c) r[2], c = bits.Add64(p[2], q[2], c) @@ -645,16 +645,16 @@ func Add64M(p, q, r *[3]uint64) { func Add64M0(p, q, r *[3]uint64) { var c uint64 r[0], c = bits.Add64(p[0], q[0], 0) - // ppc64x: -"ADDC", -"ADDE", "ADDZE R[1-9]" + // ppc64x: -"ADDC" -"ADDE" "ADDZE R[1-9]" r[1], c = bits.Add64(p[1], 0, c) - // ppc64x: -"ADDC", "ADDE", -"ADDZE" + // ppc64x: -"ADDC" "ADDE" -"ADDZE" r[2], c = bits.Add64(p[2], p[2], c) } func Add64MSaveC(p, q, r, c *[2]uint64) { - // ppc64x: "ADDC R", "ADDZE" + // ppc64x: "ADDC R" "ADDZE" r[0], c[0] = bits.Add64(p[0], q[0], 0) - // ppc64x: "ADDC [$]-1", "ADDE", "ADDZE" + // ppc64x: "ADDC [$]-1" "ADDE" "ADDZE" r[1], c[1] = bits.Add64(p[1], q[1], c[0]) } @@ -737,14 +737,14 @@ func Add64MultipleChains(a, b, c, d [2]uint64) [2]uint64 { b1, b2 := b[0], b[1] c1, c2 := c[0], c[1] - // ppc64x: "ADDC R\\d+,", -"ADDE", -"MOVD XER" + // ppc64x: "ADDC R\\d+," -"ADDE" -"MOVD XER" d1, cx = bits.Add64(a1, b1, 0) - // ppc64x: "ADDE", -"ADDC", -"MOVD .*, XER" + // ppc64x: "ADDE" -"ADDC" -"MOVD .*, XER" d2, _ = bits.Add64(a2, b2, cx) - // ppc64x: "ADDC R\\d+,", -"ADDE", -"MOVD XER" + // ppc64x: "ADDC R\\d+," -"ADDE" -"MOVD XER" d1, cx = bits.Add64(c1, d1, 0) - // ppc64x: "ADDE", -"ADDC", -"MOVD .*, XER" + // ppc64x: "ADDE" -"ADDC" -"MOVD .*, XER" d2, _ = bits.Add64(c2, d2, cx) d[0] = d1 d[1] = d2 @@ -759,7 +759,7 @@ func Sub(x, y, ci uint) (r, co uint) { // amd64:"NEGL" "SBBQ" "NEGQ" // arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP" // loong64:"SUBV" "SGTU" - // ppc64x:"SUBC", "SUBE", "SUBZE", "NEG" + // ppc64x:"SUBC" "SUBE" "SUBZE" "NEG" // s390x:"SUBE" // mips64:"SUBV" "SGTU" // riscv64: "SUB" "SLTU" @@ -770,7 +770,7 @@ func SubC(x, ci uint) (r, co uint) { // amd64:"NEGL" "SBBQ" "NEGQ" // arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP" // loong64:"SUBV" "SGTU" - // ppc64x:"SUBC", "SUBE", "SUBZE", "NEG" + // ppc64x:"SUBC" "SUBE" "SUBZE" "NEG" // s390x:"SUBE" // mips64:"SUBV" "SGTU" // riscv64: "SUB" "SLTU" @@ -781,7 +781,7 @@ func SubZ(x, y uint) (r, co uint) { // amd64:"SUBQ" "SBBQ" "NEGQ" -"NEGL" // arm64:"SUBS" "NGC" "NEG" -"SBCS" -"ADD" -"SUB " -"CMP" // loong64:"SUBV" "SGTU" - // ppc64x:"SUBC", -"SUBE", "SUBZE", "NEG" + // ppc64x:"SUBC" -"SUBE" "SUBZE" "NEG" // s390x:"SUBC" // mips64:"SUBV" "SGTU" // riscv64: "SUB" "SLTU" @@ -792,7 +792,7 @@ func SubR(x, y, ci uint) uint { // amd64:"NEGL" "SBBQ" -"NEGQ" // arm64:"NEGS" "SBCS" -"NGC" -"NEG " -"ADD" -"SUB" -"CMP" // loong64:"SUBV" -"SGTU" - // ppc64x:"SUBC", "SUBE", -"SUBZE", -"NEG" + // ppc64x:"SUBC" "SUBE" -"SUBZE" -"NEG" // s390x:"SUBE" // riscv64: "SUB" -"SLTU" r, _ := bits.Sub(x, y, ci) @@ -803,7 +803,7 @@ func SubM(p, q, r *[3]uint) { r[0], c = bits.Sub(p[0], q[0], c) // amd64:"SBBQ" -"NEGL" -"NEGQ" // arm64:"SBCS" -"NEGS" -"NGC" -"NEG" -"ADD" -"SUB" -"CMP" - // ppc64x:-"SUBC", "SUBE", -"SUBZE", -"NEG" + // ppc64x:-"SUBC" "SUBE" -"SUBZE" -"NEG" // s390x:"SUBE" r[1], c = bits.Sub(p[1], q[1], c) r[2], c = bits.Sub(p[2], q[2], c) @@ -813,7 +813,7 @@ func Sub64(x, y, ci uint64) (r, co uint64) { // amd64:"NEGL" "SBBQ" "NEGQ" // arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP" // loong64:"SUBV" "SGTU" - // ppc64x:"SUBC", "SUBE", "SUBZE", "NEG" + // ppc64x:"SUBC" "SUBE" "SUBZE" "NEG" // s390x:"SUBE" // mips64:"SUBV" "SGTU" // riscv64: "SUB" "SLTU" @@ -824,7 +824,7 @@ func Sub64C(x, ci uint64) (r, co uint64) { // amd64:"NEGL" "SBBQ" "NEGQ" // arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP" // loong64:"SUBV" "SGTU" - // ppc64x:"SUBC", "SUBE", "SUBZE", "NEG" + // ppc64x:"SUBC" "SUBE" "SUBZE" "NEG" // s390x:"SUBE" // mips64:"SUBV" "SGTU" // riscv64: "SUB" "SLTU" @@ -835,7 +835,7 @@ func Sub64Z(x, y uint64) (r, co uint64) { // amd64:"SUBQ" "SBBQ" "NEGQ" -"NEGL" // arm64:"SUBS" "NGC" "NEG" -"SBCS" -"ADD" -"SUB " -"CMP" // loong64:"SUBV" "SGTU" - // ppc64x:"SUBC", -"SUBE", "SUBZE", "NEG" + // ppc64x:"SUBC" -"SUBE" "SUBZE" "NEG" // s390x:"SUBC" // mips64:"SUBV" "SGTU" // riscv64: "SUB" "SLTU" @@ -846,7 +846,7 @@ func Sub64R(x, y, ci uint64) uint64 { // amd64:"NEGL" "SBBQ" -"NEGQ" // arm64:"NEGS" "SBCS" -"NGC" -"NEG " -"ADD" -"SUB" -"CMP" // loong64:"SUBV" -"SGTU" - // ppc64x:"SUBC", "SUBE", -"SUBZE", -"NEG" + // ppc64x:"SUBC" "SUBE" -"SUBZE" -"NEG" // s390x:"SUBE" // riscv64: "SUB" -"SLTU" r, _ := bits.Sub64(x, y, ci) @@ -863,9 +863,9 @@ func Sub64M(p, q, r *[3]uint64) { } func Sub64MSaveC(p, q, r, c *[2]uint64) { - // ppc64x:"SUBC R\\d+, R\\d+,", "SUBZE", "NEG" + // ppc64x:"SUBC R\\d+, R\\d+," "SUBZE" "NEG" r[0], c[0] = bits.Sub64(p[0], q[0], 0) - // ppc64x:"SUBC R\\d+, [$]0,", "SUBE", "SUBZE", "NEG" + // ppc64x:"SUBC R\\d+, [$]0," "SUBE" "SUBZE" "NEG" r[1], c[1] = bits.Sub64(p[1], q[1], c[0]) } @@ -976,7 +976,7 @@ func Mul64LoOnly(x, y uint64) uint64 { func Mul64Const() (uint64, uint64) { // 7133701809754865664 == 99<<56 - // arm64:"MOVD [$]7133701809754865664, R1", "MOVD [$]88, R0" + // arm64:"MOVD [$]7133701809754865664, R1" "MOVD [$]88, R0" // loong64:"MOVV [$]88, R4" "MOVV [$]7133701809754865664, R5" -"MUL" return bits.Mul64(99+88<<8, 1<<56) } diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go index 9e24185a22..9df22c1109 100644 --- a/test/codegen/memcombine.go +++ b/test/codegen/memcombine.go @@ -16,353 +16,353 @@ import ( // ------------- // func load_le64(b []byte) uint64 { - // amd64:`MOVQ \(.*\),`,-`MOV[BWL] [^$]`,-`OR` + // amd64:`MOVQ \(.*\),` -`MOV[BWL] [^$]` -`OR` // s390x:`MOVDBR \(.*\),` - // arm64:`MOVD \(R[0-9]+\),`,-`MOV[BHW]` + // arm64:`MOVD \(R[0-9]+\),` -`MOV[BHW]` // loong64:`MOVV \(R[0-9]+\),` - // ppc64le:`MOVD `,-`MOV[BHW]Z` - // ppc64:`MOVDBR `,-`MOV[BHW]Z` + // 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 \(.*\)\(.*\*1\),`,-`MOV[BWL] [^$]`,-`OR` + // amd64:`MOVQ \(.*\)\(.*\*1\),` -`MOV[BWL] [^$]` -`OR` // s390x:`MOVDBR \(.*\)\(.*\*1\),` - // arm64:`MOVD \(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]` + // 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 ` + // ppc64le:`MOVD ` -`MOV[BHW]Z ` + // ppc64:`MOVDBR ` -`MOV[BHW]Z ` return binary.LittleEndian.Uint64(b[idx:]) } func load_le32(b []byte) uint32 { - // amd64:`MOVL \(.*\),`,-`MOV[BW]`,-`OR` - // 386:`MOVL \(.*\),`,-`MOV[BW]`,-`OR` + // amd64:`MOVL \(.*\),` -`MOV[BW]` -`OR` + // 386:`MOVL \(.*\),` -`MOV[BW]` -`OR` // s390x:`MOVWBR \(.*\),` - // arm64:`MOVWU \(R[0-9]+\),`,-`MOV[BH]` + // arm64:`MOVWU \(R[0-9]+\),` -`MOV[BH]` // loong64:`MOVWU \(R[0-9]+\),` - // ppc64le:`MOVWZ `,-`MOV[BH]Z ` - // ppc64:`MOVWBR `,-`MOV[BH]Z ` + // 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 \(.*\)\(.*\*1\),`,-`MOV[BW]`,-`OR` - // 386:`MOVL \(.*\)\(.*\*1\),`,-`MOV[BW]`,-`OR` + // 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]` + // 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 ` + // ppc64le:`MOVWZ ` -`MOV[BH]Z ` + // ppc64:`MOVWBR ` -`MOV[BH]Z ` return binary.LittleEndian.Uint32(b[idx:]) } func load_le16(b []byte) uint16 { - // amd64:`MOVWLZX \(.*\),`,-`MOVB`,-`OR` - // ppc64le:`MOVHZ `,-`MOVBZ` - // arm64:`MOVHU \(R[0-9]+\),`,-`MOVB` + // amd64:`MOVWLZX \(.*\),` -`MOVB` -`OR` + // ppc64le:`MOVHZ ` -`MOVBZ` + // arm64:`MOVHU \(R[0-9]+\),` -`MOVB` // loong64:`MOVHU \(R[0-9]+\),` // s390x:`MOVHBR \(.*\),` - // ppc64:`MOVHBR `,-`MOVBZ` + // ppc64:`MOVHBR ` -`MOVBZ` return binary.LittleEndian.Uint16(b) } func load_le16_idx(b []byte, idx int) uint16 { - // amd64:`MOVWLZX \(.*\),`,-`MOVB`,-`OR` - // ppc64le:`MOVHZ `,-`MOVBZ` - // ppc64:`MOVHBR `,-`MOVBZ` - // arm64:`MOVHU \(R[0-9]+\)\(R[0-9]+\),`,-`MOVB` + // 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/v1,amd64/v2:`BSWAPQ` -`MOV[BWL] [^$]` -`OR` // amd64/v3:`MOVBEQ` // s390x:`MOVD \(.*\),` - // arm64:`REV`,`MOVD \(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W` - // ppc64le:`MOVDBR`,-`MOV[BHW]Z` - // ppc64:`MOVD`,-`MOV[BHW]Z` + // 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) } func load_be64_idx(b []byte, idx int) uint64 { - // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` + // 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 \(.*\)\(.*\*1\),` - // arm64:`REV`,`MOVD \(R[0-9]+\)\(R[0-9]+\),`,-`MOV[WHB]`,-`REVW`,-`REV16W` - // ppc64le:`MOVDBR`,-`MOV[BHW]Z` - // ppc64:`MOVD`,-`MOV[BHW]Z` + // 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:]) } func load_be32(b []byte) uint32 { - // amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR` + // amd64/v1,amd64/v2:`BSWAPL` -`MOV[BW]` -`OR` // amd64/v3: `MOVBEL` // s390x:`MOVWZ \(.*\),` - // arm64:`REVW`,`MOVWU \(R[0-9]+\),`,-`MOV[BH]`,-`REV16W` - // ppc64le:`MOVWBR`,-`MOV[BH]Z` - // ppc64:`MOVWZ`,-`MOV[BH]Z` + // arm64:`REVW` `MOVWU \(R[0-9]+\),` -`MOV[BH]` -`REV16W` + // ppc64le:`MOVWBR` -`MOV[BH]Z` + // ppc64:`MOVWZ` -`MOV[BH]Z` return binary.BigEndian.Uint32(b) } func load_be32_idx(b []byte, idx int) uint32 { - // amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR` + // 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 \(.*\)\(.*\*1\),` - // arm64:`REVW`,`MOVWU \(R[0-9]+\)\(R[0-9]+\),`,-`MOV[HB]`,-`REV16W` - // ppc64le:`MOVWBR`,-`MOV[BH]Z` - // ppc64:`MOVWZ`,-`MOV[BH]Z` + // 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 \$8`,-`MOVB`,-`OR` - // arm64:`REV16W`,`MOVHU \(R[0-9]+\),`,-`MOVB` - // ppc64le:`MOVHBR`,-`MOVBZ` - // ppc64:`MOVHZ`,-`MOVBZ` - // s390x:`MOVHZ \(.*\),`,-`OR`,-`ORW`,-`SLD`,-`SLW` + // amd64:`ROLW \$8` -`MOVB` -`OR` + // arm64:`REV16W` `MOVHU \(R[0-9]+\),` -`MOVB` + // ppc64le:`MOVHBR` -`MOVBZ` + // ppc64:`MOVHZ` -`MOVBZ` + // s390x:`MOVHZ \(.*\),` -`OR` -`ORW` -`SLD` -`SLW` return binary.BigEndian.Uint16(b) } func load_be16_idx(b []byte, idx int) uint16 { - // amd64:`ROLW \$8`,-`MOVB`,-`OR` - // arm64:`REV16W`,`MOVHU \(R[0-9]+\)\(R[0-9]+\),`,-`MOVB` - // ppc64le:`MOVHBR`,-`MOVBZ` - // ppc64:`MOVHZ`,-`MOVBZ` - // s390x:`MOVHZ \(.*\)\(.*\*1\),`,-`OR`,-`ORW`,-`SLD`,-`SLW` + // amd64:`ROLW \$8` -`MOVB` -`OR` + // arm64:`REV16W` `MOVHU \(R[0-9]+\)\(R[0-9]+\),` -`MOVB` + // ppc64le:`MOVHBR` -`MOVBZ` + // ppc64:`MOVHZ` -`MOVBZ` + // 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 \([A-Z]+\)`,-`MOVB`,-`OR` - // amd64:`MOVWLZX \([A-Z]+\)`,-`MOVB`,-`OR` - // ppc64le:`MOVHZ \(R[0-9]+\)`,-`MOVBZ` - // ppc64:`MOVHBR`,-`MOVBZ` + // arm64:`MOVHU \(R[0-9]+\)` -`ORR` -`MOVB` + // 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 } func load_le_byte2_uint16_inv(s []byte) uint16 { - // arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB` - // 386:`MOVWLZX \([A-Z]+\)`,-`MOVB`,-`OR` - // amd64:`MOVWLZX \([A-Z]+\)`,-`MOVB`,-`OR` - // ppc64le:`MOVHZ \(R[0-9]+\)`,-`MOVBZ` - // ppc64:`MOVHBR`,-`MOVBZ` + // arm64:`MOVHU \(R[0-9]+\)` -`ORR` -`MOVB` + // 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]) } func load_le_byte4_uint32(s []byte) uint32 { - // arm64:`MOVWU \(R[0-9]+\)`,-`ORR`,-`MOV[BH]` - // 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` + // arm64:`MOVWU \(R[0-9]+\)` -`ORR` -`MOV[BH]` + // 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 } func load_le_byte4_uint32_inv(s []byte) uint32 { - // arm64:`MOVWU \(R[0-9]+\)`,-`ORR`,-`MOV[BH]` - // ppc64le:`MOVWZ`,-`MOV[BH]Z` - // ppc64:`MOVWBR`,-`MOV[BH]Z` + // arm64:`MOVWU \(R[0-9]+\)` -`ORR` -`MOV[BH]` + // ppc64le:`MOVWZ` -`MOV[BH]Z` + // ppc64:`MOVWBR` -`MOV[BH]Z` return uint32(s[3])<<24 | uint32(s[2])<<16 | uint32(s[1])<<8 | uint32(s[0]) } func load_le_byte8_uint64(s []byte) uint64 { - // arm64:`MOVD \(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` - // amd64:`MOVQ \([A-Z]+\), [A-Z]+`,-`MOV[BWL] [^$]`,-`OR` - // ppc64le:`MOVD \(R[0-9]+\)`,-`MOV[BHW]Z` - // ppc64:`MOVDBR`,-`MOVW[WHB]Z` + // arm64:`MOVD \(R[0-9]+\)` -`ORR` -`MOV[BHW]` + // 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 } func load_le_byte8_uint64_inv(s []byte) uint64 { - // arm64:`MOVD \(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` - // ppc64le:`MOVD`,-`MOV[WHB]Z` - // ppc64:`MOVDBR`,-`MOV[WHB]Z` + // arm64:`MOVD \(R[0-9]+\)` -`ORR` -`MOV[BHW]` + // ppc64le:`MOVD` -`MOV[WHB]Z` + // ppc64:`MOVDBR` -`MOV[WHB]Z` return uint64(s[7])<<56 | uint64(s[6])<<48 | uint64(s[5])<<40 | uint64(s[4])<<32 | uint64(s[3])<<24 | uint64(s[2])<<16 | uint64(s[1])<<8 | uint64(s[0]) } func load_be_byte2_uint16(s []byte) uint16 { - // arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` - // amd64:`MOVWLZX \([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR` - // ppc64le:`MOVHBR \(R[0-9]+\)`,-`MOVBZ` - // ppc64:`MOVHZ`,-`MOVBZ` + // arm64:`MOVHU \(R[0-9]+\)` `REV16W` -`ORR` -`MOVB` + // amd64:`MOVWLZX \([A-Z]+\)` `ROLW` -`MOVB` -`OR` + // ppc64le:`MOVHBR \(R[0-9]+\)` -`MOVBZ` + // ppc64:`MOVHZ` -`MOVBZ` return uint16(s[0])<<8 | uint16(s[1]) } func load_be_byte2_uint16_inv(s []byte) uint16 { - // arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` - // amd64:`MOVWLZX \([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR` - // ppc64le:`MOVHBR \(R[0-9]+\)`,-`MOVBZ` - // ppc64:`MOVHZ`,-`MOVBZ` + // arm64:`MOVHU \(R[0-9]+\)` `REV16W` -`ORR` -`MOVB` + // amd64:`MOVWLZX \([A-Z]+\)` `ROLW` -`MOVB` -`OR` + // ppc64le:`MOVHBR \(R[0-9]+\)` -`MOVBZ` + // ppc64:`MOVHZ` -`MOVBZ` return uint16(s[1]) | uint16(s[0])<<8 } func load_be_byte4_uint32(s []byte) uint32 { - // arm64:`MOVWU \(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]` - // ppc64le:`MOVWBR`,-`MOV[HB]Z` - // ppc64:`MOVWZ`,-`MOV[HB]Z` + // arm64:`MOVWU \(R[0-9]+\)` `REVW` -`ORR` -`REV16W` -`MOV[BH]` + // ppc64le:`MOVWBR` -`MOV[HB]Z` + // ppc64:`MOVWZ` -`MOV[HB]Z` return uint32(s[0])<<24 | uint32(s[1])<<16 | uint32(s[2])<<8 | uint32(s[3]) } func load_be_byte4_uint32_inv(s []byte) uint32 { - // arm64:`MOVWU \(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]` - // amd64/v1,amd64/v2:`MOVL \([A-Z]+\)`,`BSWAPL`,-`MOV[BW]`,-`OR` + // arm64:`MOVWU \(R[0-9]+\)` `REVW` -`ORR` -`REV16W` -`MOV[BH]` + // amd64/v1,amd64/v2:`MOVL \([A-Z]+\)` `BSWAPL` -`MOV[BW]` -`OR` // amd64/v3: `MOVBEL` - // ppc64le:`MOVWBR`,-`MOV[HB]Z` - // ppc64:`MOVWZ`,-`MOV[HB]Z` + // ppc64le:`MOVWBR` -`MOV[HB]Z` + // ppc64:`MOVWZ` -`MOV[HB]Z` return uint32(s[3]) | uint32(s[2])<<8 | uint32(s[1])<<16 | uint32(s[0])<<24 } func load_be_byte8_uint64(s []byte) uint64 { - // arm64:`MOVD \(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]` - // ppc64le:`MOVDBR \(R[0-9]+\)`,-`MOV[BHW]Z` - // ppc64:`MOVD`,-`MOV[WHB]Z` + // arm64:`MOVD \(R[0-9]+\)` `REV` -`ORR` -`REVW` -`REV16W` -`MOV[BHW]` + // ppc64le:`MOVDBR \(R[0-9]+\)` -`MOV[BHW]Z` + // ppc64:`MOVD` -`MOV[WHB]Z` return uint64(s[0])<<56 | uint64(s[1])<<48 | uint64(s[2])<<40 | uint64(s[3])<<32 | uint64(s[4])<<24 | uint64(s[5])<<16 | uint64(s[6])<<8 | uint64(s[7]) } 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 \([A-Z]+\), [A-Z]+`,`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` + // arm64:`MOVD \(R[0-9]+\)` `REV` -`ORR` -`REVW` -`REV16W` -`MOV[BHW]` + // 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` + // ppc64le:`MOVDBR \(R[0-9]+\)` -`MOV[BHW]Z` + // ppc64:`MOVD` -`MOV[BHW]Z` return uint64(s[7]) | uint64(s[6])<<8 | uint64(s[5])<<16 | uint64(s[4])<<24 | uint64(s[3])<<32 | uint64(s[2])<<40 | uint64(s[1])<<48 | uint64(s[0])<<56 } func load_le_byte2_uint16_idx(s []byte, idx int) uint16 { - // 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` + // 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 \(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` + // 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 \(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BH]` - // amd64:`MOVL \([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 \(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 \(R[0-9]+\)\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` - // amd64:`MOVQ \([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 \(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 \(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` - // amd64:`MOVWLZX \([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 \(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` - // amd64:`MOVWLZX \([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 \(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 \(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 \(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 \(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 \(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 \(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 \(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 \(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 \(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 \(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 \(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 \(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 \([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 \([A-Z]+\)`,`SHLL [$]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 \([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 \([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 @@ -407,7 +407,7 @@ func load_op_in_loop(a []int) int { // Make sure offsets are folded into loads and stores. func offsets_fold(_, a [20]byte) (b [20]byte) { - // arm64:`MOVD command-line-arguments\.a\+[0-9]+\(FP\), R[0-9]+`,`MOVD R[0-9]+, command-line-arguments\.b\+[0-9]+\(FP\)` + // arm64:`MOVD command-line-arguments\.a\+[0-9]+\(FP\), R[0-9]+` `MOVD R[0-9]+, command-line-arguments\.b\+[0-9]+\(FP\)` b = a return } @@ -426,19 +426,19 @@ func safe_point(p, q *[2]*int) { // ------------- // func store_le64(b []byte, x uint64) { - // amd64:`MOVQ .*\(.*\)$`,-`SHR.` - // arm64:`MOVD`,-`MOV[WBH]` - // ppc64le:`MOVD `,-`MOV[BHW] ` - // ppc64:`MOVDBR`,-MOVB ` + // amd64:`MOVQ .*\(.*\)$` -`SHR.` + // arm64:`MOVD` -`MOV[WBH]` + // 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 .*\(.*\)\(.*\*1\)$`,-`SHR.` - // arm64:`MOVD R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]` - // ppc64le:`MOVD `,-`MOV[BHW] ` - // ppc64:`MOVDBR`,-`MOVBZ` + // 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 .*\(.*\)\(.*\*1\)$` binary.LittleEndian.PutUint64(b[idx:], x) } @@ -446,7 +446,7 @@ func store_le64_idx(b []byte, x uint64, idx int) { func store_le64_idx2(dst []byte, d, length, offset int) []byte { a := dst[d : d+length] b := dst[d-offset:] - // amd64:`MOVQ .*\(.*\)\(.*\*1\)$`,-`SHR.` + // amd64:`MOVQ .*\(.*\)\(.*\*1\)$` -`SHR.` binary.LittleEndian.PutUint64(a, binary.LittleEndian.Uint64(b)) return dst } @@ -460,15 +460,15 @@ func store_le64_load(b []byte, x *[8]byte) { _ = b[8] // amd64:-`MOV[BWL]` // arm64:-`MOV[BWH]` - // ppc64le:`MOVD `,-`MOV[BWH]Z` + // ppc64le:`MOVD ` -`MOV[BWH]Z` // ppc64:`MOVDBR` - // s390x:-`MOVB`,-`MOV[WH]BR` + // s390x:-`MOVB` -`MOV[WH]BR` binary.LittleEndian.PutUint64(b, binary.LittleEndian.Uint64(x[:])) } func store_le32(b []byte, x uint32) { // amd64:`MOVL ` - // arm64:`MOVW`,-`MOV[BH]` + // arm64:`MOVW` -`MOV[BH]` // ppc64le:`MOVW ` // ppc64:`MOVWBR` // s390x:`MOVWBR .*\(.*\)$` @@ -477,7 +477,7 @@ func store_le32(b []byte, x uint32) { func store_le32_idx(b []byte, x uint32, idx int) { // amd64:`MOVL ` - // arm64:`MOVW R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]` + // arm64:`MOVW R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)` -`MOV[BH]` // ppc64le:`MOVW ` // ppc64:`MOVWBR` // s390x:`MOVWBR .*\(.*\)\(.*\*1\)$` @@ -486,13 +486,13 @@ func store_le32_idx(b []byte, x uint32, idx int) { func store_le32_idx_const(b []byte, idx int) { // amd64:`MOVL \$123, \(.*\)\(.*\*1\)$` - // ppc64x:`MOVW `,-`MOV[HB]` + // ppc64x:`MOVW ` -`MOV[HB]` binary.LittleEndian.PutUint32(b[idx:], 123) } func store_le16(b []byte, x uint16) { // amd64:`MOVW ` - // arm64:`MOVH`,-`MOVB` + // arm64:`MOVH` -`MOVB` // ppc64le:`MOVH ` // ppc64:`MOVHBR` // s390x:`MOVHBR .*\(.*\)$` @@ -501,7 +501,7 @@ func store_le16(b []byte, x uint16) { func store_le16_idx(b []byte, x uint16, idx int) { // amd64:`MOVW ` - // arm64:`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB` + // arm64:`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)` -`MOVB` // ppc64le:`MOVH ` // ppc64:`MOVHBR ` // s390x:`MOVHBR .*\(.*\)\(.*\*1\)$` @@ -515,32 +515,32 @@ func store_le16_idx_const(b []byte, idx int) { } func store_be64(b []byte, x uint64) { - // amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.` + // amd64/v1,amd64/v2:`BSWAPQ` -`SHR.` // amd64/v3: `MOVBEQ` - // arm64:`MOVD`,`REV`,-`MOV[WBH]`,-`REVW`,-`REV16W` + // arm64:`MOVD` `REV` -`MOV[WBH]` -`REVW` -`REV16W` // ppc64le:`MOVDBR` // ppc64:`MOVD ` - // s390x:`MOVD .*\(.*\)$`,-`SRW `,-`SRD ` + // 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/v1,amd64/v2:`BSWAPQ` -`SHR.` // amd64/v3:`MOVBEQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` - // arm64:`REV`,`MOVD R[0-9]+, \(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 ` - // s390x:`MOVD .*\(.*\)\(.*\*1\)$`,-`SRW `,-`SRD ` + // s390x:`MOVD .*\(.*\)\(.*\*1\)$` -`SRW ` -`SRD ` binary.BigEndian.PutUint64(b[idx:], x) } func store_be32(b []byte, x uint32) { - // amd64/v1,amd64/v2:`BSWAPL`,-`SHR.` + // amd64/v1,amd64/v2:`BSWAPL` -`SHR.` // amd64/v3:`MOVBEL` - // arm64:`MOVW`,`REVW`,-`MOV[BH]`,-`REV16W` + // arm64:`MOVW` `REVW` -`MOV[BH]` -`REV16W` // ppc64le:`MOVWBR` // ppc64:`MOVW ` - // s390x:`MOVW .*\(.*\)$`,-`SRW `,-`SRD ` + // s390x:`MOVW .*\(.*\)$` -`SRW ` -`SRD ` binary.BigEndian.PutUint32(b, x) } @@ -557,59 +557,59 @@ 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/v1,amd64/v2:`BSWAPL` -`SHR.` // amd64/v3:`MOVBEL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` - // arm64:`REVW`,`MOVW R[0-9]+, \(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 ` - // s390x:`MOVW .*\(.*\)\(.*\*1\)$`,-`SRW `,-`SRD ` + // s390x:`MOVW .*\(.*\)\(.*\*1\)$` -`SRW ` -`SRD ` binary.BigEndian.PutUint32(b[idx:], x) } func store_be16(b []byte, x uint16) { - // amd64/v1,amd64/v2:`ROLW \$8`,-`SHR.` - // amd64/v3:`MOVBEW`,-`ROLW` - // arm64:`MOVH`,`REV16W`,-`MOVB` + // amd64/v1,amd64/v2:`ROLW \$8` -`SHR.` + // amd64/v3:`MOVBEW` -`ROLW` + // arm64:`MOVH` `REV16W` -`MOVB` // ppc64le:`MOVHBR` // ppc64:`MOVH ` - // s390x:`MOVH .*\(.*\)$`,-`SRW `,-`SRD ` + // s390x:`MOVH .*\(.*\)$` -`SRW ` -`SRD ` binary.BigEndian.PutUint16(b, x) } func store_be16_idx(b []byte, x uint16, idx int) { - // amd64/v1,amd64/v2:`ROLW \$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 R[0-9]+, \(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 ` - // s390x:`MOVH .*\(.*\)\(.*\*1\)$`,-`SRW `,-`SRD ` + // s390x:`MOVH .*\(.*\)\(.*\*1\)$` -`SRW ` -`SRD ` binary.BigEndian.PutUint16(b[idx:], x) } func store_le_byte_2(b []byte, val uint16) { _ = b[2] - // 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` + // 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 [A-Z]+, 1\([A-Z]+\)`,-`MOVB` - // amd64:`MOVW [A-Z]+, 1\([A-Z]+\)`,-`MOVB` - // ppc64le:`MOVH `,-`MOVB` - // ppc64:`MOVHBR`,-`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 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` + // 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) @@ -617,17 +617,17 @@ func store_le_byte_4(b []byte, val uint32) { func store_le_byte_8(b []byte, val uint64) { _ = b[8] - // 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` + // 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 R[0-9]+, 1\(R[0-9]+\)`,-`MOVB` - // amd64/v1,amd64/v2:`MOVW [A-Z]+, 1\([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 ` @@ -636,8 +636,8 @@ func store_be_byte_2(b []byte, val uint16) { func store_be_byte_4(b []byte, val uint32) { _ = b[4] - // 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` + // 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 ` @@ -646,9 +646,9 @@ func store_be_byte_4(b []byte, val uint32) { func store_be_byte_8(b []byte, val uint64) { _ = b[8] - // 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` + // 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,8 +656,8 @@ 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 R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB` - // 386:`MOVW [A-Z]+, \([A-Z]+\)\([A-Z]+`,-`MOVB` + // 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) @@ -665,7 +665,7 @@ func store_le_byte_2_idx(b []byte, idx int, val uint16) { func store_le_byte_2_idx_inv(b []byte, idx int, val uint16) { _, _ = b[idx+0], b[idx+1] - // 386:`MOVW [A-Z]+, \([A-Z]+\)\([A-Z]+`,-`MOVB` + // 386:`MOVW [A-Z]+, \([A-Z]+\)\([A-Z]+` -`MOVB` // ppc64le:`MOVH ` // ppc64:`MOVHBR` b[idx+0], b[idx+1] = byte(val), byte(val>>8) @@ -673,7 +673,7 @@ func store_le_byte_2_idx_inv(b []byte, idx int, val uint16) { 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 R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`,-`MOVH` + // 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) @@ -681,7 +681,7 @@ func store_le_byte_4_idx(b []byte, idx int, val uint32) { func store_be_byte_2_idx(b []byte, idx int, val uint16) { _, _ = b[idx+0], b[idx+1] - // arm64:`REV16W`,`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB` + // arm64:`REV16W` `MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+\)` -`MOVB` // ppc64le:`MOVHBR` // ppc64:`MOVH ` b[idx+0], b[idx+1] = byte(val>>8), byte(val) @@ -689,7 +689,7 @@ func store_be_byte_2_idx(b []byte, idx int, val uint16) { 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 R[0-9]+, \(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 ` b[idx+0], b[idx+1], b[idx+2], b[idx+3] = byte(val>>24), byte(val>>16), byte(val>>8), byte(val) @@ -697,7 +697,7 @@ func store_be_byte_4_idx(b []byte, idx int, val uint32) { func store_be_byte_2_idx2(b []byte, idx int, val uint16) { _, _ = b[(idx<<1)+0], b[(idx<<1)+1] - // arm64:`REV16W`,`MOVH R[0-9]+, \(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 ` b[(idx<<1)+0], b[(idx<<1)+1] = byte(val>>8), byte(val) @@ -705,7 +705,7 @@ func store_be_byte_2_idx2(b []byte, idx int, val uint16) { func store_le_byte_2_idx2(b []byte, idx int, val uint16) { _, _ = b[(idx<<1)+0], b[(idx<<1)+1] - // arm64:`MOVH R[0-9]+, \(R[0-9]+\)\(R[0-9]+<<1\)`,-`MOVB` + // 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) @@ -713,7 +713,7 @@ func store_le_byte_2_idx2(b []byte, idx int, val uint16) { 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 R[0-9]+, \(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 ` 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) @@ -721,7 +721,7 @@ func store_be_byte_4_idx4(b []byte, idx int, val uint32) { 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 R[0-9]+, \(R[0-9]+\)\(R[0-9]+<<2\)`,-`MOVB`,-`MOVH` + // 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) @@ -784,14 +784,14 @@ func zero_byte_39(a *[39]byte) { func zero_byte_2_idx(b []byte, idx int) { _, _ = b[idx+0], b[idx+1] - // arm64:`MOVH ZR, \(R[0-9]+\)\(R[0-9]+\)`,-`MOVB` + // 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 ZR, \(R[0-9]+\)\(R[0-9]+<<1\)`,-`MOVB` + // arm64:`MOVH ZR, \(R[0-9]+\)\(R[0-9]+<<1\)` -`MOVB` // ppc64x:`MOVH ` b[(idx<<1)+0], b[(idx<<1)+1] = 0, 0 } @@ -1008,7 +1008,7 @@ func dwloadF32(p *struct{ a, b float32 }) float32 { } func dwloadBig(p *struct{ a, b, c, d, e, f int64 }) int64 { - // arm64:"LDP \\(", "LDP 16", "LDP 32" + // arm64:"LDP \\(" "LDP 16" "LDP 32" return p.c + p.f + p.a + p.e + p.d + p.b } diff --git a/test/codegen/memops.go b/test/codegen/memops.go index 4d7bdfb685..378521c5f7 100644 --- a/test/codegen/memops.go +++ b/test/codegen/memops.go @@ -367,9 +367,9 @@ func idxFloatOps(a []float64, b []float32, i int) (float64, float32) { } func storeTest(a []bool, v int, i int) { - // amd64: `BTL \$0,`,`SETCS 4\([A-Z]+[0-9]*\)` + // amd64: `BTL \$0,` `SETCS 4\([A-Z]+[0-9]*\)` a[4] = v&1 != 0 - // amd64: `BTL \$1,`,`SETCS 3\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` + // amd64: `BTL \$1,` `SETCS 3\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` a[3+i] = v&2 != 0 } diff --git a/test/codegen/memops_bigoffset.go b/test/codegen/memops_bigoffset.go index 4240e7a131..74dd198890 100644 --- a/test/codegen/memops_bigoffset.go +++ b/test/codegen/memops_bigoffset.go @@ -15,27 +15,27 @@ type big2 struct { func loadLargeOffset(sw *big1, sd *big2) (uint32, uint64) { - // ppc64x:`MOVWZ +[0-9]+\(R[0-9]+\)`,-`ADD` + // ppc64x:`MOVWZ +[0-9]+\(R[0-9]+\)` -`ADD` a3 := sw.w[1<<10] - // 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]+` + // 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 +[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]+` + // 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 +\(R[0-9]+\)\(R[0-9]+\), R[0-9]+` d3 := sw.w[1<<29] - // ppc64x:`MOVD +[0-9]+\(R[0-9]+\)`,-`ADD` + // ppc64x:`MOVD +[0-9]+\(R[0-9]+\)` -`ADD` a4 := sd.d[1<<10] - // 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]+` + // 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 +[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]+` + // 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 +\(R[0-9]+\)\(R[0-9]+\), R[0-9]+` d4 := sd.d[1<<28] @@ -44,27 +44,27 @@ func loadLargeOffset(sw *big1, sd *big2) (uint32, uint64) { } func storeLargeOffset(sw *big1, sd *big2) { - // ppc64x:`MOVW +R[0-9]+, [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 +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` + // 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 +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` + // 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 +R[0-9]+, \(R[0-9]+\)` sw.w[1<<29] = uint32(40) - // ppc64x:`MOVD +R[0-9]+, [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 +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` + // 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 +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` + // 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 +R[0-9]+, \(R[0-9]+\)` sd.d[1<<28] = uint64(70) diff --git a/test/codegen/multiply.go b/test/codegen/multiply.go index 166bc104d0..3b88a1179f 100644 --- a/test/codegen/multiply.go +++ b/test/codegen/multiply.go @@ -40,15 +40,15 @@ func m5(x int64) int64 { return x * 5 } func m6(x int64) int64 { - // amd64: "LEAQ .*[*]1", "LEAQ .*[*]2" - // arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<1," - // loong64: "ADDVU", "ADDVU", "ADDVU" + // amd64: "LEAQ .*[*]1" "LEAQ .*[*]2" + // arm64: "ADD R[0-9]+," "ADD R[0-9]+<<1," + // loong64: "ADDVU" "ADDVU" "ADDVU" return x * 6 } func m7(x int64) int64 { // amd64: "LEAQ .*[*]2" - // arm64: "LSL [$]3,", "SUB R[0-9]+," - // loong64: "ALSLV [$]1,", "ALSLV [$]1," + // arm64: "LSL [$]3," "SUB R[0-9]+," + // loong64: "ALSLV [$]1," "ALSLV [$]1," return x * 7 } func m8(x int64) int64 { @@ -64,39 +64,39 @@ func m9(x int64) int64 { return x * 9 } func m10(x int64) int64 { - // amd64: "LEAQ .*[*]1", "LEAQ .*[*]4" - // arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<2," - // loong64: "ADDVU", "ALSLV [$]2," + // amd64: "LEAQ .*[*]1" "LEAQ .*[*]4" + // arm64: "ADD R[0-9]+," "ADD R[0-9]+<<2," + // loong64: "ADDVU" "ALSLV [$]2," return x * 10 } func m11(x int64) int64 { - // amd64: "LEAQ .*[*]4", "LEAQ .*[*]2" - // arm64: "MOVD [$]11,", "MUL" - // loong64: "ALSLV [$]2,", "ALSLV [$]1," + // amd64: "LEAQ .*[*]4" "LEAQ .*[*]2" + // arm64: "MOVD [$]11," "MUL" + // loong64: "ALSLV [$]2," "ALSLV [$]1," return x * 11 } func m12(x int64) int64 { - // amd64: "LEAQ .*[*]2", "SHLQ [$]2," - // arm64: "LSL [$]2,", "ADD R[0-9]+<<1," - // loong64: "SLLV", "ALSLV [$]1," + // amd64: "LEAQ .*[*]2" "SHLQ [$]2," + // arm64: "LSL [$]2," "ADD R[0-9]+<<1," + // loong64: "SLLV" "ALSLV [$]1," return x * 12 } func m13(x int64) int64 { - // amd64: "LEAQ .*[*]2", "LEAQ .*[*]4" - // arm64: "MOVD [$]13,", "MUL" - // loong64: "ALSLV [$]1,", "ALSLV [$]2," + // amd64: "LEAQ .*[*]2" "LEAQ .*[*]4" + // arm64: "MOVD [$]13," "MUL" + // loong64: "ALSLV [$]1," "ALSLV [$]2," return x * 13 } func m14(x int64) int64 { // amd64: "IMUL3Q [$]14," - // arm64: "LSL [$]4,", "SUB R[0-9]+<<1," - // loong64: "ADDVU", "ALSLV [$]1", "ALSLV [$]2" + // arm64: "LSL [$]4," "SUB R[0-9]+<<1," + // loong64: "ADDVU" "ALSLV [$]1" "ALSLV [$]2" return x * 14 } func m15(x int64) int64 { - // amd64: "LEAQ .*[*]2", "LEAQ .*[*]4" - // arm64: "LSL [$]4,", "SUB R[0-9]+," - // loong64: "ALSLV [$]1,", "ALSLV [$]2," + // amd64: "LEAQ .*[*]2" "LEAQ .*[*]4" + // arm64: "LSL [$]4," "SUB R[0-9]+," + // loong64: "ALSLV [$]1," "ALSLV [$]2," return x * 15 } func m16(x int64) int64 { @@ -106,69 +106,69 @@ func m16(x int64) int64 { return x * 16 } func m17(x int64) int64 { - // amd64: "LEAQ .*[*]1", "LEAQ .*[*]8" + // amd64: "LEAQ .*[*]1" "LEAQ .*[*]8" // arm64: "ADD R[0-9]+<<4," // loong64: "ALSLV [$]" return x * 17 } func m18(x int64) int64 { - // amd64: "LEAQ .*[*]1", "LEAQ .*[*]8" - // arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<3," - // loong64: "ADDVU", "ALSLV [$]3," + // amd64: "LEAQ .*[*]1" "LEAQ .*[*]8" + // arm64: "ADD R[0-9]+," "ADD R[0-9]+<<3," + // loong64: "ADDVU" "ALSLV [$]3," return x * 18 } func m19(x int64) int64 { - // amd64: "LEAQ .*[*]8", "LEAQ .*[*]2" - // arm64: "MOVD [$]19,", "MUL" - // loong64: "ALSLV [$]3,", "ALSLV [$]1," + // amd64: "LEAQ .*[*]8" "LEAQ .*[*]2" + // arm64: "MOVD [$]19," "MUL" + // loong64: "ALSLV [$]3," "ALSLV [$]1," return x * 19 } func m20(x int64) int64 { - // amd64: "LEAQ .*[*]4", "SHLQ [$]2," - // arm64: "LSL [$]2,", "ADD R[0-9]+<<2," - // loong64: "SLLV [$]2,", "ALSLV [$]2," + // amd64: "LEAQ .*[*]4" "SHLQ [$]2," + // arm64: "LSL [$]2," "ADD R[0-9]+<<2," + // loong64: "SLLV [$]2," "ALSLV [$]2," return x * 20 } func m21(x int64) int64 { - // amd64: "LEAQ .*[*]4", "LEAQ .*[*]4" - // arm64: "MOVD [$]21,", "MUL" - // loong64: "ALSLV [$]2,", "ALSLV [$]2," + // amd64: "LEAQ .*[*]4" "LEAQ .*[*]4" + // arm64: "MOVD [$]21," "MUL" + // loong64: "ALSLV [$]2," "ALSLV [$]2," return x * 21 } func m22(x int64) int64 { // amd64: "IMUL3Q [$]22," - // arm64: "MOVD [$]22,", "MUL" - // loong64: "ADDVU", "ALSLV [$]2,", "ALSLV [$]2," + // arm64: "MOVD [$]22," "MUL" + // loong64: "ADDVU" "ALSLV [$]2," "ALSLV [$]2," return x * 22 } func m23(x int64) int64 { // amd64: "IMUL3Q [$]23," - // arm64: "MOVD [$]23,", "MUL" - // loong64: "ALSLV [$]1,", "SUBVU", "ALSLV [$]3," + // arm64: "MOVD [$]23," "MUL" + // loong64: "ALSLV [$]1," "SUBVU" "ALSLV [$]3," return x * 23 } func m24(x int64) int64 { - // amd64: "LEAQ .*[*]2", "SHLQ [$]3," - // arm64: "LSL [$]3,", "ADD R[0-9]+<<1," - // loong64: "SLLV [$]3", "ALSLV [$]1," + // amd64: "LEAQ .*[*]2" "SHLQ [$]3," + // arm64: "LSL [$]3," "ADD R[0-9]+<<1," + // loong64: "SLLV [$]3" "ALSLV [$]1," return x * 24 } func m25(x int64) int64 { - // amd64: "LEAQ .*[*]4", "LEAQ .*[*]4" - // arm64: "MOVD [$]25,", "MUL" - // loong64: "ALSLV [$]2,", "ALSLV [$]2," + // amd64: "LEAQ .*[*]4" "LEAQ .*[*]4" + // arm64: "MOVD [$]25," "MUL" + // loong64: "ALSLV [$]2," "ALSLV [$]2," return x * 25 } func m26(x int64) int64 { // amd64: "IMUL3Q [$]26," - // arm64: "MOVD [$]26,", "MUL" - // loong64: "ADDVU", "ALSLV [$]1,", "ALSLV [$]3," + // arm64: "MOVD [$]26," "MUL" + // loong64: "ADDVU" "ALSLV [$]1," "ALSLV [$]3," return x * 26 } func m27(x int64) int64 { - // amd64: "LEAQ .*[*]2", "LEAQ .*[*]8" - // arm64: "MOVD [$]27,", "MUL" - // loong64: "ALSLV [$]1,", "ALSLV [$]3," + // amd64: "LEAQ .*[*]2" "LEAQ .*[*]8" + // arm64: "MOVD [$]27," "MUL" + // loong64: "ALSLV [$]1," "ALSLV [$]3," return x * 27 } func m28(x int64) int64 { @@ -179,19 +179,19 @@ func m28(x int64) int64 { } func m29(x int64) int64 { // amd64: "IMUL3Q [$]29," - // arm64: "MOVD [$]29,", "MUL" + // arm64: "MOVD [$]29," "MUL" // loong64: "ALSLV [$]1," "SLLV [$]5," "SUBVU" return x * 29 } func m30(x int64) int64 { // amd64: "IMUL3Q [$]30," - // arm64: "LSL [$]5,", "SUB R[0-9]+<<1," + // arm64: "LSL [$]5," "SUB R[0-9]+<<1," // loong64: "ADDVU" "SLLV [$]5," "SUBVU" return x * 30 } func m31(x int64) int64 { - // amd64: "SHLQ [$]5,", "SUBQ" - // arm64: "LSL [$]5,", "SUB R[0-9]+," + // amd64: "SHLQ [$]5," "SUBQ" + // arm64: "LSL [$]5," "SUB R[0-9]+," // loong64: "SLLV [$]5," "SUBVU" return x * 31 } @@ -202,51 +202,51 @@ func m32(x int64) int64 { return x * 32 } func m33(x int64) int64 { - // amd64: "SHLQ [$]2,", "LEAQ .*[*]8" + // amd64: "SHLQ [$]2," "LEAQ .*[*]8" // arm64: "ADD R[0-9]+<<5," - // loong64: "ADDVU", "ALSLV [$]4," + // loong64: "ADDVU" "ALSLV [$]4," return x * 33 } func m34(x int64) int64 { - // amd64: "SHLQ [$]5,", "LEAQ .*[*]2" - // arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<4," - // loong64: "ADDVU", "ALSLV [$]4," + // amd64: "SHLQ [$]5," "LEAQ .*[*]2" + // arm64: "ADD R[0-9]+," "ADD R[0-9]+<<4," + // loong64: "ADDVU" "ALSLV [$]4," return x * 34 } func m35(x int64) int64 { // amd64: "IMUL3Q [$]35," - // arm64: "MOVD [$]35,", "MUL" - // loong64: "ALSLV [$]4,", "ALSLV [$]1," + // arm64: "MOVD [$]35," "MUL" + // loong64: "ALSLV [$]4," "ALSLV [$]1," return x * 35 } func m36(x int64) int64 { - // amd64: "LEAQ .*[*]8", "SHLQ [$]2," - // arm64: "LSL [$]2,", "ADD R[0-9]+<<3," - // loong64: "SLLV [$]2,", "ALSLV [$]3," + // amd64: "LEAQ .*[*]8" "SHLQ [$]2," + // arm64: "LSL [$]2," "ADD R[0-9]+<<3," + // loong64: "SLLV [$]2," "ALSLV [$]3," return x * 36 } func m37(x int64) int64 { - // amd64: "LEAQ .*[*]8", "LEAQ .*[*]4" - // arm64: "MOVD [$]37,", "MUL" - // loong64: "ALSLV [$]3,", "ALSLV [$]2," + // amd64: "LEAQ .*[*]8" "LEAQ .*[*]4" + // arm64: "MOVD [$]37," "MUL" + // loong64: "ALSLV [$]3," "ALSLV [$]2," return x * 37 } func m38(x int64) int64 { // amd64: "IMUL3Q [$]38," - // arm64: "MOVD [$]38,", "MUL" - // loong64: "ALSLV [$]3,", "ALSLV [$]2," + // arm64: "MOVD [$]38," "MUL" + // loong64: "ALSLV [$]3," "ALSLV [$]2," return x * 38 } func m39(x int64) int64 { // amd64: "IMUL3Q [$]39," - // arm64: "MOVD [$]39,", "MUL" - // loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]3," + // arm64: "MOVD [$]39," "MUL" + // loong64: "ALSLV [$]2," "SUBVU" "ALSLV [$]3," return x * 39 } func m40(x int64) int64 { - // amd64: "LEAQ .*[*]4", "SHLQ [$]3," - // arm64: "LSL [$]3,", "ADD R[0-9]+<<2," - // loong64: "SLLV [$]3,", "ALSLV [$]2," + // amd64: "LEAQ .*[*]4" "SHLQ [$]3," + // arm64: "LSL [$]3," "ADD R[0-9]+<<2," + // loong64: "SLLV [$]3," "ALSLV [$]2," return x * 40 } @@ -257,116 +257,116 @@ func mn1(x int64) int64 { return x * -1 } func mn2(x int64) int64 { - // amd64: "NEGQ", "ADDQ" + // amd64: "NEGQ" "ADDQ" // arm64: "NEG R[0-9]+<<1," // loong64: "ADDVU" "SUBVU R[0-9], R0," return x * -2 } func mn3(x int64) int64 { - // amd64: "NEGQ", "LEAQ .*[*]2" + // amd64: "NEGQ" "LEAQ .*[*]2" // arm64: "SUB R[0-9]+<<2," - // loong64: "SUBVU", "ALSLV [$]1," + // loong64: "SUBVU" "ALSLV [$]1," return x * -3 } func mn4(x int64) int64 { - // amd64: "NEGQ", "SHLQ [$]2," + // amd64: "NEGQ" "SHLQ [$]2," // arm64: "NEG R[0-9]+<<2," // loong64: "SLLV [$]2," "SUBVU R[0-9], R0," return x * -4 } func mn5(x int64) int64 { - // amd64: "NEGQ", "LEAQ .*[*]4" - // arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<2," - // loong64: "SUBVU", "ALSLV [$]2," + // amd64: "NEGQ" "LEAQ .*[*]4" + // arm64: "NEG R[0-9]+," "ADD R[0-9]+<<2," + // loong64: "SUBVU" "ALSLV [$]2," return x * -5 } func mn6(x int64) int64 { // amd64: "IMUL3Q [$]-6," - // arm64: "ADD R[0-9]+,", "SUB R[0-9]+<<2," - // loong64: "ADDVU", "SUBVU", "ALSLV [$]3," + // arm64: "ADD R[0-9]+," "SUB R[0-9]+<<2," + // loong64: "ADDVU" "SUBVU" "ALSLV [$]3," return x * -6 } func mn7(x int64) int64 { - // amd64: "NEGQ", "LEAQ .*[*]8" + // amd64: "NEGQ" "LEAQ .*[*]8" // arm64: "SUB R[0-9]+<<3," - // loong64: "SUBVU", "ALSLV [$]3," + // loong64: "SUBVU" "ALSLV [$]3," return x * -7 } func mn8(x int64) int64 { - // amd64: "NEGQ", "SHLQ [$]3," + // amd64: "NEGQ" "SHLQ [$]3," // arm64: "NEG R[0-9]+<<3," // loong64: "SLLV [$]3" "SUBVU R[0-9], R0," return x * -8 } func mn9(x int64) int64 { - // amd64: "NEGQ", "LEAQ .*[*]8" - // arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<3," - // loong64: "SUBVU", "ALSLV [$]3," + // amd64: "NEGQ" "LEAQ .*[*]8" + // arm64: "NEG R[0-9]+," "ADD R[0-9]+<<3," + // loong64: "SUBVU" "ALSLV [$]3," return x * -9 } func mn10(x int64) int64 { // amd64: "IMUL3Q [$]-10," - // arm64: "MOVD [$]-10,", "MUL" - // loong64: "ADDVU", "ALSLV [$]3", "SUBVU" + // arm64: "MOVD [$]-10," "MUL" + // loong64: "ADDVU" "ALSLV [$]3" "SUBVU" return x * -10 } func mn11(x int64) int64 { // amd64: "IMUL3Q [$]-11," - // arm64: "MOVD [$]-11,", "MUL" - // loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]4," + // arm64: "MOVD [$]-11," "MUL" + // loong64: "ALSLV [$]2," "SUBVU" "ALSLV [$]4," return x * -11 } func mn12(x int64) int64 { // amd64: "IMUL3Q [$]-12," - // arm64: "LSL [$]2,", "SUB R[0-9]+<<2," - // loong64: "SUBVU", "SLLV [$]2,", "ALSLV [$]4," + // arm64: "LSL [$]2," "SUB R[0-9]+<<2," + // loong64: "SUBVU" "SLLV [$]2," "ALSLV [$]4," return x * -12 } func mn13(x int64) int64 { // amd64: "IMUL3Q [$]-13," - // arm64: "MOVD [$]-13,", "MUL" - // loong64: "ALSLV [$]4,", "SLLV [$]2, ", "SUBVU" + // arm64: "MOVD [$]-13," "MUL" + // loong64: "ALSLV [$]4," "SLLV [$]2, " "SUBVU" return x * -13 } func mn14(x int64) int64 { // amd64: "IMUL3Q [$]-14," - // arm64: "ADD R[0-9]+,", "SUB R[0-9]+<<3," - // loong64: "ADDVU", "SUBVU", "ALSLV [$]4," + // arm64: "ADD R[0-9]+," "SUB R[0-9]+<<3," + // loong64: "ADDVU" "SUBVU" "ALSLV [$]4," return x * -14 } func mn15(x int64) int64 { - // amd64: "SHLQ [$]4,", "SUBQ" + // amd64: "SHLQ [$]4," "SUBQ" // arm64: "SUB R[0-9]+<<4," - // loong64: "SUBVU", "ALSLV [$]4," + // loong64: "SUBVU" "ALSLV [$]4," return x * -15 } func mn16(x int64) int64 { - // amd64: "NEGQ", "SHLQ [$]4," + // amd64: "NEGQ" "SHLQ [$]4," // arm64: "NEG R[0-9]+<<4," // loong64: "SLLV [$]4," "SUBVU R[0-9], R0," return x * -16 } func mn17(x int64) int64 { // amd64: "IMUL3Q [$]-17," - // arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<4," - // loong64: "SUBVU", "ALSLV [$]4," + // arm64: "NEG R[0-9]+," "ADD R[0-9]+<<4," + // loong64: "SUBVU" "ALSLV [$]4," return x * -17 } func mn18(x int64) int64 { // amd64: "IMUL3Q [$]-18," - // arm64: "MOVD [$]-18,", "MUL" - // loong64: "ADDVU", "ALSLV [$]4,", "SUBVU" + // arm64: "MOVD [$]-18," "MUL" + // loong64: "ADDVU" "ALSLV [$]4," "SUBVU" return x * -18 } func mn19(x int64) int64 { // amd64: "IMUL3Q [$]-19," - // arm64: "MOVD [$]-19,", "MUL" - // loong64: "ALSLV [$]1,", "ALSLV [$]4,", "SUBVU" + // arm64: "MOVD [$]-19," "MUL" + // loong64: "ALSLV [$]1," "ALSLV [$]4," "SUBVU" return x * -19 } func mn20(x int64) int64 { // amd64: "IMUL3Q [$]-20," - // arm64: "MOVD [$]-20,", "MUL" - // loong64: "SLLV [$]2,", "ALSLV [$]4,", "SUBVU" + // arm64: "MOVD [$]-20," "MUL" + // loong64: "SLLV [$]2," "ALSLV [$]4," "SUBVU" return x * -20 } diff --git a/test/codegen/regabi_regalloc.go b/test/codegen/regabi_regalloc.go index 8ac6a3da9c..2dfbfc356b 100644 --- a/test/codegen/regabi_regalloc.go +++ b/test/codegen/regabi_regalloc.go @@ -8,13 +8,13 @@ package codegen //go:registerparams func f1(a, b int) { - // amd64:"MOVQ BX, CX", "MOVQ AX, BX", "MOVL [$]1, AX", -"MOVQ .*DX" + // amd64:"MOVQ BX, CX" "MOVQ AX, BX" "MOVL [$]1, AX" -"MOVQ .*DX" g(1, a, b) } //go:registerparams func f2(a, b int) { - // amd64:"MOVQ BX, AX", "MOVQ [AB]X, CX", -"MOVQ .*, BX" + // amd64:"MOVQ BX, AX" "MOVQ [AB]X, CX" -"MOVQ .*, BX" g(b, b, b) } diff --git a/test/codegen/rotate.go b/test/codegen/rotate.go index 17bd27a4d0..b72dcada2d 100644 --- a/test/codegen/rotate.go +++ b/test/codegen/rotate.go @@ -140,14 +140,14 @@ func rot64nc(x uint64, z uint) uint64 { // amd64:"ROLQ" -"AND" // arm64:"ROR" "NEG" -"AND" // ppc64x:"ROTL" -"NEG" -"AND" - // loong64: "ROTRV", -"AND" + // loong64: "ROTRV" -"AND" // riscv64: "ROL" -"AND" a += x<<z | x>>(64-z) // amd64:"RORQ" -"AND" // arm64:"ROR" -"NEG" -"AND" // ppc64x:"ROTL" "NEG" -"AND" - // loong64: "ROTRV", -"AND" + // loong64: "ROTRV" -"AND" // riscv64: "ROR" -"AND" a += x>>z | x<<(64-z) @@ -162,14 +162,14 @@ func rot32nc(x uint32, z uint) uint32 { // amd64:"ROLL" -"AND" // arm64:"ROR" "NEG" -"AND" // ppc64x:"ROTLW" -"NEG" -"AND" - // loong64: "ROTR", -"AND" + // loong64: "ROTR" -"AND" // riscv64: "ROLW" -"AND" a += x<<z | x>>(32-z) // amd64:"RORL" -"AND" // arm64:"ROR" -"NEG" -"AND" // ppc64x:"ROTLW" "NEG" -"AND" - // loong64: "ROTR", -"AND" + // loong64: "ROTR" -"AND" // riscv64: "RORW" -"AND" a += x>>z | x<<(32-z) diff --git a/test/codegen/shift.go b/test/codegen/shift.go index 9ae113d9d7..a073944187 100644 --- a/test/codegen/shift.go +++ b/test/codegen/shift.go @@ -68,33 +68,33 @@ func rshConst64x64Overflow8(v int8) int64 { } func lshConst32x1(v int32) int32 { - // amd64:"ADDL", -"SHLL" + // amd64:"ADDL" -"SHLL" return v << 1 } func lshConst64x1(v int64) int64 { - // amd64:"ADDQ", -"SHLQ" + // amd64:"ADDQ" -"SHLQ" return v << 1 } func lshConst32x64(v int32) int32 { // loong64:"SLL " // ppc64x:"SLW" - // riscv64:"SLLI" -"AND" -"SLTIU", -"MOVW" + // riscv64:"SLLI" -"AND" -"SLTIU" -"MOVW" return v << uint64(29) } func rshConst32Ux64(v uint32) uint32 { // loong64:"SRL " // ppc64x:"SRW" - // riscv64:"SRLIW" -"AND" -"SLTIU", -"MOVW" + // riscv64:"SRLIW" -"AND" -"SLTIU" -"MOVW" return v >> uint64(29) } func rshConst32x64(v int32) int32 { // loong64:"SRA " // ppc64x:"SRAW" - // riscv64:"SRAIW" -"OR" -"SLTIU", -"MOVW" + // riscv64:"SRAIW" -"OR" -"SLTIU" -"MOVW" return v >> uint64(29) } @@ -529,30 +529,30 @@ func checkShiftAndMask32(v []uint32) { } func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) { - // ppc64x: -"CLRLSLDI", "RLWNM [$]10, R[0-9]+, [$]22, [$]29, R[0-9]+" + // ppc64x: -"CLRLSLDI" "RLWNM [$]10, R[0-9]+, [$]22, [$]29, R[0-9]+" a[0] = a[uint8(v>>24)] - // ppc64x: -"CLRLSLDI", "RLWNM [$]11, R[0-9]+, [$]21, [$]28, R[0-9]+" + // ppc64x: -"CLRLSLDI" "RLWNM [$]11, R[0-9]+, [$]21, [$]28, R[0-9]+" b[0] = b[uint8(v>>24)] - // ppc64x: -"CLRLSLDI", "RLWNM [$]15, R[0-9]+, [$]21, [$]28, R[0-9]+" + // ppc64x: -"CLRLSLDI" "RLWNM [$]15, R[0-9]+, [$]21, [$]28, R[0-9]+" b[1] = b[(v>>20)&0xFF] - // ppc64x: -"SLD", "RLWNM [$]10, R[0-9]+, [$]22, [$]28, R[0-9]+" + // ppc64x: -"SLD" "RLWNM [$]10, R[0-9]+, [$]22, [$]28, R[0-9]+" b[2] = b[v>>25] } func checkMergedShifts64(a [256]uint32, b [256]uint64, c [256]byte, v uint64) { - // ppc64x: -"CLRLSLDI", "RLWNM [$]10, R[0-9]+, [$]22, [$]29, R[0-9]+" + // ppc64x: -"CLRLSLDI" "RLWNM [$]10, R[0-9]+, [$]22, [$]29, R[0-9]+" a[0] = a[uint8(v>>24)] - // ppc64x: "SRD", "CLRLSLDI", -"RLWNM" + // ppc64x: "SRD" "CLRLSLDI" -"RLWNM" a[1] = a[uint8(v>>25)] - // ppc64x: -"CLRLSLDI", "RLWNM [$]9, R[0-9]+, [$]23, [$]29, R[0-9]+" + // ppc64x: -"CLRLSLDI" "RLWNM [$]9, R[0-9]+, [$]23, [$]29, R[0-9]+" a[2] = a[v>>25&0x7F] - // ppc64x: -"CLRLSLDI", "RLWNM [$]3, R[0-9]+, [$]29, [$]29, R[0-9]+" + // ppc64x: -"CLRLSLDI" "RLWNM [$]3, R[0-9]+, [$]29, [$]29, R[0-9]+" a[3] = a[(v>>31)&0x01] - // ppc64x: -"CLRLSLDI", "RLWNM [$]12, R[0-9]+, [$]21, [$]28, R[0-9]+" + // ppc64x: -"CLRLSLDI" "RLWNM [$]12, R[0-9]+, [$]21, [$]28, R[0-9]+" b[0] = b[uint8(v>>23)] - // ppc64x: -"CLRLSLDI", "RLWNM [$]15, R[0-9]+, [$]21, [$]28, R[0-9]+" + // ppc64x: -"CLRLSLDI" "RLWNM [$]15, R[0-9]+, [$]21, [$]28, R[0-9]+" b[1] = b[(v>>20)&0xFF] - // ppc64x: "RLWNM", -"SLD" + // ppc64x: "RLWNM" -"SLD" b[2] = b[((uint64((uint32(v) >> 21)) & 0x3f) << 4)] // ppc64x: -"RLWNM" b[3] = (b[3] << 24) & 0xFFFFFF000000 @@ -573,9 +573,9 @@ func checkMergedShifts64(a [256]uint32, b [256]uint64, c [256]byte, v uint64) { func checkShiftMask(a uint32, b uint64, z []uint32, y []uint64) { _ = y[128] _ = z[128] - // ppc64x: -"MOVBZ", -"SRW", "RLWNM" + // ppc64x: -"MOVBZ" -"SRW" "RLWNM" z[0] = uint32(uint8(a >> 5)) - // ppc64x: -"MOVBZ", -"SRW", "RLWNM" + // ppc64x: -"MOVBZ" -"SRW" "RLWNM" z[1] = uint32(uint8((a >> 4) & 0x7e)) // ppc64x: "RLWNM [$]25, R[0-9]+, [$]27, [$]29, R[0-9]+" z[2] = uint32(uint8(a>>7)) & 0x1c @@ -583,9 +583,9 @@ func checkShiftMask(a uint32, b uint64, z []uint32, y []uint64) { y[0] = uint64((a >> 6) & 0x1c) // ppc64x: -"MOVWZ" y[1] = uint64(uint32(b)<<6) + 1 - // ppc64x: -"MOVHZ", -"MOVWZ" + // ppc64x: -"MOVHZ" -"MOVWZ" y[2] = uint64((uint16(a) >> 9) & 0x1F) - // ppc64x: -"MOVHZ", -"MOVWZ", -"ANDCC" + // ppc64x: -"MOVHZ" -"MOVWZ" -"ANDCC" y[3] = uint64(((uint16(a) & 0xFF0) >> 9) & 0x1F) } diff --git a/test/codegen/spills.go b/test/codegen/spills.go index 9b04d7d3d0..bef3cbbbb2 100644 --- a/test/codegen/spills.go +++ b/test/codegen/spills.go @@ -6,22 +6,22 @@ package codegen -func i64(a, b int64) int64 { // arm64:`STP `,`LDP ` +func i64(a, b int64) int64 { // arm64:`STP ` `LDP ` g() return a + b } -func i32(a, b int32) int32 { // arm64:`STPW`,`LDPW` +func i32(a, b int32) int32 { // arm64:`STPW` `LDPW` g() return a + b } -func f64(a, b float64) float64 { // arm64:`FSTPD`,`FLDPD` +func f64(a, b float64) float64 { // arm64:`FSTPD` `FLDPD` g() return a + b } -func f32(a, b float32) float32 { // arm64:`FSTPS`,`FLDPS` +func f32(a, b float32) float32 { // arm64:`FSTPS` `FLDPS` g() return a + b } diff --git a/test/codegen/strings.go b/test/codegen/strings.go index 1c14021150..1202d608ac 100644 --- a/test/codegen/strings.go +++ b/test/codegen/strings.go @@ -37,56 +37,56 @@ func ConvertToByteSlice(a, b, c string) []byte { func ConstantLoad() { // 12592 = 0x3130 // 50 = 0x32 - // amd64:`MOVW \$12592, \(`,`MOVB \$50, 2\(` - // 386:`MOVW \$12592, \(`,`MOVB \$50, 2\(` - // arm:`MOVW \$48`,`MOVW \$49`,`MOVW \$50` - // arm64:`MOVD \$12592`,`MOVD \$50` - // loong64:`MOVV \$12592`,`MOVV \$50` - // wasm:`I64Const \$12592`,`I64Store16 \$0`,`I64Const \$50`,`I64Store8 \$2` - // mips64:`MOVV \$48`,`MOVV \$49`,`MOVV \$50` + // amd64:`MOVW \$12592, \(` `MOVB \$50, 2\(` + // 386:`MOVW \$12592, \(` `MOVB \$50, 2\(` + // arm:`MOVW \$48` `MOVW \$49` `MOVW \$50` + // arm64:`MOVD \$12592` `MOVD \$50` + // loong64:`MOVV \$12592` `MOVV \$50` + // wasm:`I64Const \$12592` `I64Store16 \$0` `I64Const \$50` `I64Store8 \$2` + // mips64:`MOVV \$48` `MOVV \$49` `MOVV \$50` bsink = []byte("012") // 858927408 = 0x33323130 // 13620 = 0x3534 - // amd64:`MOVL \$858927408`,`MOVW \$13620, 4\(` - // 386:`MOVL \$858927408`,`MOVW \$13620, 4\(` - // arm64:`MOVD \$858927408`,`MOVD \$13620` - // loong64:`MOVV \$858927408`,`MOVV \$13620` - // wasm:`I64Const \$858927408`,`I64Store32 \$0`,`I64Const \$13620`,`I64Store16 \$4` + // amd64:`MOVL \$858927408` `MOVW \$13620, 4\(` + // 386:`MOVL \$858927408` `MOVW \$13620, 4\(` + // arm64:`MOVD \$858927408` `MOVD \$13620` + // loong64:`MOVV \$858927408` `MOVV \$13620` + // wasm:`I64Const \$858927408` `I64Store32 \$0` `I64Const \$13620` `I64Store16 \$4` bsink = []byte("012345") // 3978425819141910832 = 0x3736353433323130 // 7306073769690871863 = 0x6564636261393837 - // amd64:`MOVQ \$3978425819141910832`,`MOVQ \$7306073769690871863` - // 386:`MOVL \$858927408, \(`,`DUFFCOPY` - // arm64:`MOVD \$3978425819141910832`,`MOVD \$7306073769690871863`,`MOVD \$15` - // loong64:`MOVV \$3978425819141910832`,`MOVV \$7306073769690871863`,`MOVV \$15` - // wasm:`I64Const \$3978425819141910832`,`I64Store \$0`,`I64Const \$7306073769690871863`,`I64Store \$7` + // amd64:`MOVQ \$3978425819141910832` `MOVQ \$7306073769690871863` + // 386:`MOVL \$858927408, \(` `DUFFCOPY` + // arm64:`MOVD \$3978425819141910832` `MOVD \$7306073769690871863` `MOVD \$15` + // loong64:`MOVV \$3978425819141910832` `MOVV \$7306073769690871863` `MOVV \$15` + // wasm:`I64Const \$3978425819141910832` `I64Store \$0` `I64Const \$7306073769690871863` `I64Store \$7` bsink = []byte("0123456789abcde") // 56 = 0x38 - // amd64:`MOVQ \$3978425819141910832`,`MOVB \$56` - // loong64:`MOVV \$3978425819141910832`,`MOVV \$56` + // amd64:`MOVQ \$3978425819141910832` `MOVB \$56` + // loong64:`MOVV \$3978425819141910832` `MOVV \$56` bsink = []byte("012345678") // 14648 = 0x3938 - // amd64:`MOVQ \$3978425819141910832`,`MOVW \$14648` - // loong64:`MOVV \$3978425819141910832`,`MOVV \$14648` + // amd64:`MOVQ \$3978425819141910832` `MOVW \$14648` + // loong64:`MOVV \$3978425819141910832` `MOVV \$14648` bsink = []byte("0123456789") // 1650538808 = 0x62613938 - // amd64:`MOVQ \$3978425819141910832`,`MOVL \$1650538808` - // loong64:`MOVV \$3978425819141910832`,`MOVV \$1650538808` + // amd64:`MOVQ \$3978425819141910832` `MOVL \$1650538808` + // loong64:`MOVV \$3978425819141910832` `MOVV \$1650538808` bsink = []byte("0123456789ab") } // self-equality is always true. See issue 60777. func EqualSelf(s string) bool { - // amd64:`MOVL \$1, AX`,-`.*memequal.*` + // amd64:`MOVL \$1, AX` -`.*memequal.*` return s == s } func NotEqualSelf(s string) bool { - // amd64:`XORL AX, AX`,-`.*memequal.*` + // amd64:`XORL AX, AX` -`.*memequal.*` return s != s } diff --git a/test/codegen/structs.go b/test/codegen/structs.go index 1c8cb5d62d..f789249ee3 100644 --- a/test/codegen/structs.go +++ b/test/codegen/structs.go @@ -20,7 +20,7 @@ type Z1 struct { } func Zero1(t *Z1) { // Issue #18370 - // amd64:`MOVUPS X[0-9]+, \(.*\)`,`MOVQ \$0, 16\(.*\)` + // amd64:`MOVUPS X[0-9]+, \(.*\)` `MOVQ \$0, 16\(.*\)` *t = Z1{} } @@ -29,7 +29,7 @@ type Z2 struct { } func Zero2(t *Z2) { - // amd64:`MOVUPS X[0-9]+, \(.*\)`,`MOVQ \$0, 16\(.*\)` + // amd64:`MOVUPS X[0-9]+, \(.*\)` `MOVQ \$0, 16\(.*\)` // amd64:`.*runtime[.]gcWriteBarrier.*\(SB\)` *t = Z2{} } @@ -43,6 +43,6 @@ type I1 struct { } func Init1(p *I1) { // Issue #18872 - // amd64:`MOVQ [$]1`,`MOVQ [$]2`,`MOVQ [$]3`,`MOVQ [$]4` + // amd64:`MOVQ [$]1` `MOVQ [$]2` `MOVQ [$]3` `MOVQ [$]4` *p = I1{1, 2, 3, 4} } diff --git a/test/codegen/switch.go b/test/codegen/switch.go index baa8934e06..d59ef4f2eb 100644 --- a/test/codegen/switch.go +++ b/test/codegen/switch.go @@ -24,8 +24,8 @@ func f(x string) int { // use jump tables for 8+ int cases func square(x int) int { // amd64:`JMP \(.*\)\(.*\)$` - // arm64:`MOVD \(R.*\)\(R.*<<3\)`,`JMP \(R.*\)$` - // loong64: `ALSLV`,`MOVV`,`JMP` + // arm64:`MOVD \(R.*\)\(R.*<<3\)` `JMP \(R.*\)$` + // loong64: `ALSLV` `MOVV` `JMP` switch x { case 1: return 1 @@ -51,8 +51,8 @@ func square(x int) int { // use jump tables for 8+ string lengths func length(x string) int { // amd64:`JMP \(.*\)\(.*\)$` - // arm64:`MOVD \(R.*\)\(R.*<<3\)`,`JMP \(R.*\)$` - // loong64:`ALSLV`,`MOVV`,`JMP` + // arm64:`MOVD \(R.*\)\(R.*<<3\)` `JMP \(R.*\)$` + // loong64:`ALSLV` `MOVV` `JMP` switch x { case "a": return 1 @@ -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 1\(.*\), \$104$`,-`cmpstring` - // arm64: `MOVB 1\(R.*\), R.*$`, `CMPW \$104, R.*$`, -`cmpstring` + // amd64: `CMPB 1\(.*\), \$104$` -`cmpstring` + // arm64: `MOVB 1\(R.*\), R.*$` `CMPW \$104, R.*$` -`cmpstring` switch ext { // amd64: `CMPL \(.*\), \$1836345390$` - // arm64: `MOVD \$1836345390`, `CMPW R.*, R.*$` + // arm64: `MOVD \$1836345390` `CMPW R.*, R.*$` case ".htm": return "A" // amd64: `CMPL \(.*\), \$1953457454$` - // arm64: `MOVD \$1953457454`, `CMPW R.*, R.*$` + // arm64: `MOVD \$1953457454` `CMPW R.*, R.*$` case ".eot": return "B" // amd64: `CMPL \(.*\), \$1735815982$` - // arm64: `MOVD \$1735815982`, `CMPW R.*, R.*$` + // arm64: `MOVD \$1735815982` `CMPW R.*, R.*$` case ".svg": return "C" // amd64: `CMPL \(.*\), \$1718907950$` - // arm64: `MOVD \$1718907950`, `CMPW R.*, R.*$` + // arm64: `MOVD \$1718907950` `CMPW R.*, R.*$` case ".ttf": return "D" default: @@ -105,7 +105,7 @@ func mimetype(ext string) string { // use jump tables for type switches to concrete types. func typeSwitch(x any) int { // amd64:`JMP \(.*\)\(.*\)$` - // arm64:`MOVD \(R.*\)\(R.*<<3\)`,`JMP \(R.*\)$` + // arm64:`MOVD \(R.*\)\(R.*<<3\)` `JMP \(R.*\)$` switch x.(type) { case int: return 0 @@ -137,8 +137,8 @@ type K interface { // use a runtime call for type switches to interface types. func interfaceSwitch(x any) int { - // amd64:`CALL runtime.interfaceSwitch`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*8)` - // arm64:`CALL runtime.interfaceSwitch`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)` + // amd64:`CALL runtime.interfaceSwitch` `MOVL 16\(AX\)` `MOVQ 8\(.*\)(.*\*8)` + // arm64:`CALL runtime.interfaceSwitch` `LDAR` `MOVWU 16\(R0\)` `MOVD \(R.*\)\(R.*\)` switch x.(type) { case I: return 1 @@ -150,8 +150,8 @@ func interfaceSwitch(x any) int { } func interfaceSwitch2(x K) int { - // amd64:`CALL runtime.interfaceSwitch`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*8)` - // arm64:`CALL runtime.interfaceSwitch`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)` + // amd64:`CALL runtime.interfaceSwitch` `MOVL 16\(AX\)` `MOVQ 8\(.*\)(.*\*8)` + // arm64:`CALL runtime.interfaceSwitch` `LDAR` `MOVWU 16\(R0\)` `MOVD \(R.*\)\(R.*\)` switch x.(type) { case I: return 1 @@ -163,8 +163,8 @@ func interfaceSwitch2(x K) int { } func interfaceCast(x any) int { - // amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)` - // arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)` + // amd64:`CALL runtime.typeAssert` `MOVL 16\(AX\)` `MOVQ 8\(.*\)(.*\*1)` + // arm64:`CALL runtime.typeAssert` `LDAR` `MOVWU 16\(R0\)` `MOVD \(R.*\)\(R.*\)` if _, ok := x.(I); ok { return 3 } @@ -172,8 +172,8 @@ func interfaceCast(x any) int { } func interfaceCast2(x K) int { - // amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)` - // arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)` + // amd64:`CALL runtime.typeAssert` `MOVL 16\(AX\)` `MOVQ 8\(.*\)(.*\*1)` + // arm64:`CALL runtime.typeAssert` `LDAR` `MOVWU 16\(R0\)` `MOVD \(R.*\)\(R.*\)` if _, ok := x.(I); ok { return 3 } @@ -181,8 +181,8 @@ func interfaceCast2(x K) int { } func interfaceConv(x IJ) I { - // amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)` - // arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)` + // amd64:`CALL runtime.typeAssert` `MOVL 16\(AX\)` `MOVQ 8\(.*\)(.*\*1)` + // arm64:`CALL runtime.typeAssert` `LDAR` `MOVWU 16\(R0\)` `MOVD \(R.*\)\(R.*\)` return x } diff --git a/test/codegen/writebarrier.go b/test/codegen/writebarrier.go index bb156bb123..93fab68f63 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 `, `STP \(R[0-9]+, R[0-9]+\), \(` + // arm64: `LDP ` `STP \(R[0-9]+, R[0-9]+\), \(` p[0] = x // arm64: `STP \(R[0-9]+, R[0-9]+\), 16\(` p[1] = y } func writeDoubleNil(p *[2]*int) { - // arm64: `LDP `, `STP \(R[0-9]+, R[0-9]+\),`, `STP \(ZR, ZR\),` + // arm64: `LDP ` `STP \(R[0-9]+, R[0-9]+\),` `STP \(ZR, ZR\),` p[0] = nil p[1] = nil } |