From 915c1839fe76aef4bea6191282be1e48ef1c64e2 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sun, 26 Oct 2025 22:51:14 -0400 Subject: [PATCH] test/codegen: simplify asmcheck pattern matching Separate patterns in asmcheck by spaces instead of commas. Many patterns end in comma (like "MOV [$]123,") so separating patterns by comma is not great; they're already quoted, so spaces are fine. Also replace all tabs in the assembly lines with spaces before matching. Finally, replace \$ or \\$ with [$] as the matching idiom. The effect of all these is to make the patterns look like: // amd64:"BSFQ" "ORQ [$]256" instead of the old: // amd64:"BSFQ","ORQ\t\\$256" Update all tests as well. Change-Id: Ia39febe5d7f67ba115846422789e11b185d5c807 Reviewed-on: https://go-review.googlesource.com/c/go/+/716060 LUCI-TryBot-Result: Go LUCI Reviewed-by: Alan Donovan Reviewed-by: Jorropo --- src/cmd/internal/testdir/testdir_test.go | 11 +- test/codegen/addrcalc.go | 2 +- test/codegen/alloc.go | 30 +- test/codegen/arithmetic.go | 464 +++++++++++------------ test/codegen/atomics.go | 18 +- test/codegen/bitfield.go | 176 ++++----- test/codegen/bits.go | 164 ++++---- test/codegen/bmi.go | 48 +-- test/codegen/bool.go | 164 ++++---- test/codegen/clobberdead.go | 12 +- test/codegen/clobberdeadreg.go | 14 +- test/codegen/compare_and_branch.go | 64 ++-- test/codegen/comparisons.go | 112 +++--- test/codegen/condmove.go | 90 ++--- test/codegen/constants.go | 20 +- test/codegen/copy.go | 34 +- test/codegen/floats.go | 142 +++---- test/codegen/fuse.go | 140 +++---- test/codegen/ifaces.go | 14 +- test/codegen/issue25378.go | 4 +- test/codegen/issue52635.go | 10 +- test/codegen/issue56440.go | 4 +- test/codegen/issue60324.go | 14 +- test/codegen/issue74485.go | 16 +- test/codegen/load_type_from_itab.go | 2 +- test/codegen/logic.go | 4 +- test/codegen/maps.go | 8 +- test/codegen/math.go | 118 +++--- test/codegen/mathbits.go | 438 ++++++++++----------- test/codegen/memcombine.go | 218 +++++------ test/codegen/memops.go | 298 +++++++-------- test/codegen/multiply.go | 348 ++++++++--------- test/codegen/noextend.go | 82 ++-- test/codegen/reflect_type.go | 8 +- test/codegen/regabi_regalloc.go | 4 +- test/codegen/retpoline.go | 4 +- test/codegen/rotate.go | 214 +++++------ test/codegen/schedule.go | 4 +- test/codegen/select.go | 2 +- test/codegen/shift.go | 352 ++++++++--------- test/codegen/slices.go | 22 +- test/codegen/smallintiface.go | 6 +- test/codegen/stack.go | 70 ++-- test/codegen/strings.go | 54 +-- test/codegen/structs.go | 6 +- test/codegen/switch.go | 24 +- test/codegen/typeswitch.go | 6 +- test/codegen/zerosize.go | 8 +- 48 files changed, 2035 insertions(+), 2032 deletions(-) diff --git a/src/cmd/internal/testdir/testdir_test.go b/src/cmd/internal/testdir/testdir_test.go index c5aa91ba47..30e66c428d 100644 --- a/src/cmd/internal/testdir/testdir_test.go +++ b/src/cmd/internal/testdir/testdir_test.go @@ -1488,7 +1488,7 @@ var ( // "\s*,\s*` matches " , " // second reMatchCheck matches "`SUB`" // ")*)" closes started groups; "*" means that there might be other elements in the comma-separated list - rxAsmPlatform = regexp.MustCompile(`(\w+)(/[\w.]+)?(/\w*)?\s*:\s*(` + reMatchCheck + `(?:\s*,\s*` + reMatchCheck + `)*)`) + rxAsmPlatform = regexp.MustCompile(`(\w+)(/[\w.]+)?(/\w*)?\s*:\s*(` + reMatchCheck + `(?:\s+` + reMatchCheck + `)*)`) // Regexp to extract a single opcoded check rxAsmCheck = regexp.MustCompile(reMatchCheck) @@ -1701,6 +1701,9 @@ func (t test) asmCheck(outStr string, fn string, env buildEnv, fullops map[strin } srcFileLine, asm := matches[1], matches[2] + // Replace tabs with single spaces to make matches easier to write. + asm = strings.ReplaceAll(asm, "\t", " ") + // Associate the original file/line information to the current // function in the output; it will be useful to dump it in case // of error. @@ -1752,11 +1755,11 @@ func (t test) asmCheck(outStr string, fn string, env buildEnv, fullops map[strin } if o.negative { - fmt.Fprintf(&errbuf, "%s:%d: %s: wrong opcode found: %q\n", t.goFileName(), o.line, env, o.opcode.String()) + fmt.Fprintf(&errbuf, "%s:%d: %s: wrong opcode found: %#q\n", t.goFileName(), o.line, env, o.opcode.String()) } else if o.expected > 0 { - fmt.Fprintf(&errbuf, "%s:%d: %s: wrong number of opcodes: %q\n", t.goFileName(), o.line, env, o.opcode.String()) + fmt.Fprintf(&errbuf, "%s:%d: %s: wrong number of opcodes: %#q\n", t.goFileName(), o.line, env, o.opcode.String()) } else { - fmt.Fprintf(&errbuf, "%s:%d: %s: opcode not found: %q\n", t.goFileName(), o.line, env, o.opcode.String()) + fmt.Fprintf(&errbuf, "%s:%d: %s: opcode not found: %#q\n", t.goFileName(), o.line, env, o.opcode.String()) } } return errors.New(errbuf.String()) diff --git a/test/codegen/addrcalc.go b/test/codegen/addrcalc.go index 45552d278c..9dddb1ba94 100644 --- a/test/codegen/addrcalc.go +++ b/test/codegen/addrcalc.go @@ -9,6 +9,6 @@ package codegen // Make sure we use ADDQ instead of LEAQ when we can. func f(p *[4][2]int, x int) *int { - // amd64:"ADDQ",-"LEAQ" + // amd64:"ADDQ" -"LEAQ" return &p[x][0] } diff --git a/test/codegen/alloc.go b/test/codegen/alloc.go index c6ff004eed..20ccc853c6 100644 --- a/test/codegen/alloc.go +++ b/test/codegen/alloc.go @@ -10,28 +10,28 @@ package codegen func zeroAllocNew1() *struct{} { - // 386:-`CALL\truntime\.newobject`, `LEAL\truntime.zerobase` - // amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase` - // arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase` - // arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase` - // riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]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\truntime\.newobject`, `LEAL\truntime.zerobase` - // amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase` - // arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase` - // arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase` - // riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]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\truntime\.newobject`, `LEAL\truntime.zerobase` - // amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase` - // arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase` - // arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase` - // riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]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 7055db3dc9..ef7c5d92aa 100644 --- a/test/codegen/arithmetic.go +++ b/test/codegen/arithmetic.go @@ -15,44 +15,44 @@ package codegen // ----------------- // func AddLargeConst(a uint64, out []uint64) { - // ppc64x/power10:"ADD\t[$]4294967296," - // ppc64x/power9:"MOVD\t[$]1", "SLD\t[$]32" "ADD\tR[0-9]*" - // ppc64x/power8:"MOVD\t[$]1", "SLD\t[$]32" "ADD\tR[0-9]*" + // ppc64x/power10:"ADD [$]4294967296," + // 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\t[$]-8589934592," - // ppc64x/power9:"MOVD\t[$]-1", "SLD\t[$]33" "ADD\tR[0-9]*" - // ppc64x/power8:"MOVD\t[$]-1", "SLD\t[$]33" "ADD\tR[0-9]*" + // ppc64x/power10:"ADD [$]-8589934592," + // 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\t[$]1234567," - // ppc64x/power9:"ADDIS\t[$]19,", "ADD\t[$]-10617," - // ppc64x/power8:"ADDIS\t[$]19,", "ADD\t[$]-10617," + // ppc64x/power10:"ADD [$]1234567," + // ppc64x/power9:"ADDIS [$]19,", "ADD [$]-10617," + // ppc64x/power8:"ADDIS [$]19,", "ADD [$]-10617," out[2] = a + 1234567 - // ppc64x/power10:"ADD\t[$]-1234567," - // ppc64x/power9:"ADDIS\t[$]-19,", "ADD\t[$]10617," - // ppc64x/power8:"ADDIS\t[$]-19,", "ADD\t[$]10617," + // ppc64x/power10:"ADD [$]-1234567," + // ppc64x/power9:"ADDIS [$]-19,", "ADD [$]10617," + // ppc64x/power8:"ADDIS [$]-19,", "ADD [$]10617," out[3] = a - 1234567 - // ppc64x/power10:"ADD\t[$]2147450879," - // ppc64x/power9:"ADDIS\t[$]32767,", "ADD\t[$]32767," - // ppc64x/power8:"ADDIS\t[$]32767,", "ADD\t[$]32767," + // ppc64x/power10:"ADD [$]2147450879," + // ppc64x/power9:"ADDIS [$]32767,", "ADD [$]32767," + // ppc64x/power8:"ADDIS [$]32767,", "ADD [$]32767," out[4] = a + 0x7FFF7FFF - // ppc64x/power10:"ADD\t[$]-2147483647," - // ppc64x/power9:"ADDIS\t[$]-32768,", "ADD\t[$]1," - // ppc64x/power8:"ADDIS\t[$]-32768,", "ADD\t[$]1," + // ppc64x/power10:"ADD [$]-2147483647," + // ppc64x/power9:"ADDIS [$]-32768,", "ADD [$]1," + // ppc64x/power8:"ADDIS [$]-32768,", "ADD [$]1," out[5] = a - 2147483647 - // ppc64x:"ADDIS\t[$]-32768,", ^"ADD\t" + // ppc64x:"ADDIS [$]-32768,", ^"ADD " out[6] = a - 2147483648 - // ppc64x:"ADD\t[$]2147450880,", ^"ADDIS\t" + // ppc64x:"ADD [$]2147450880,", ^"ADDIS " out[7] = a + 0x7FFF8000 - // ppc64x:"ADD\t[$]-32768,", ^"ADDIS\t" + // ppc64x:"ADD [$]-32768,", ^"ADDIS " out[8] = a - 32768 - // ppc64x/power10:"ADD\t[$]-32769," - // ppc64x/power9:"ADDIS\t[$]-1,", "ADD\t[$]32767," - // ppc64x/power8:"ADDIS\t[$]-1,", "ADD\t[$]32767," + // ppc64x/power10:"ADD [$]-32769," + // ppc64x/power9:"ADDIS [$]-1,", "ADD [$]32767," + // ppc64x/power8:"ADDIS [$]-1,", "ADD [$]32767," out[9] = a - 32769 } func AddLargeConst2(a int, out []int) { - // loong64: -"ADDVU","ADDV16" + // loong64: -"ADDVU" "ADDV16" out[0] = a + 0x10000 } @@ -83,65 +83,65 @@ func SubMem(arr []int, b, c, d int) int { arr[b]-- // amd64:`DECQ\s64\([A-Z]+\)` arr[8]-- - // 386:"SUBL\t4" - // amd64:"SUBQ\t8" + // 386:"SUBL 4" + // amd64:"SUBQ 8" return arr[0] - arr[1] } func SubFromConst(a int) int { - // ppc64x: `SUBC\tR[0-9]+,\s[$]40,\sR` - // riscv64: "ADDI\t\\$-40","NEG" + // ppc64x: `SUBC R[0-9]+,\s[$]40,\sR` + // riscv64: "ADDI \\$-40" "NEG" b := 40 - a return b } func SubFromConstNeg(a int) int { - // arm64: "ADD\t\\$40" - // loong64: "ADDV[U]\t\\$40" - // mips: "ADD[U]\t\\$40" - // mips64: "ADDV[U]\t\\$40" - // ppc64x: `ADD\t[$]40,\sR[0-9]+,\sR` - // riscv64: "ADDI\t\\$40",-"NEG" + // arm64: "ADD \\$40" + // loong64: "ADDV[U] \\$40" + // mips: "ADD[U] \\$40" + // mips64: "ADDV[U] \\$40" + // ppc64x: `ADD [$]40,\sR[0-9]+,\sR` + // riscv64: "ADDI \\$40" -"NEG" c := 40 - (-a) return c } func SubSubFromConst(a int) int { - // arm64: "ADD\t\\$20" - // loong64: "ADDV[U]\t\\$20" - // mips: "ADD[U]\t\\$20" - // mips64: "ADDV[U]\t\\$20" - // ppc64x: `ADD\t[$]20,\sR[0-9]+,\sR` - // riscv64: "ADDI\t\\$20",-"NEG" + // arm64: "ADD \\$20" + // loong64: "ADDV[U] \\$20" + // mips: "ADD[U] \\$20" + // mips64: "ADDV[U] \\$20" + // ppc64x: `ADD [$]20,\sR[0-9]+,\sR` + // riscv64: "ADDI \\$20" -"NEG" c := 40 - (20 - a) return c } func AddSubFromConst(a int) int { - // ppc64x: `SUBC\tR[0-9]+,\s[$]60,\sR` - // riscv64: "ADDI\t\\$-60","NEG" + // ppc64x: `SUBC R[0-9]+,\s[$]60,\sR` + // riscv64: "ADDI \\$-60" "NEG" c := 40 + (20 - a) return c } func NegSubFromConst(a int) int { - // arm64: "SUB\t\\$20" - // loong64: "ADDV[U]\t\\$-20" - // mips: "ADD[U]\t\\$-20" - // mips64: "ADDV[U]\t\\$-20" - // ppc64x: `ADD\t[$]-20,\sR[0-9]+,\sR` - // riscv64: "ADDI\t\\$-20" + // arm64: "SUB \\$20" + // loong64: "ADDV[U] \\$-20" + // mips: "ADD[U] \\$-20" + // mips64: "ADDV[U] \\$-20" + // ppc64x: `ADD [$]-20,\sR[0-9]+,\sR` + // riscv64: "ADDI \\$-20" c := -(20 - a) return c } func NegAddFromConstNeg(a int) int { - // arm64: "SUB\t\\$40","NEG" - // loong64: "ADDV[U]\t\\$-40","SUBV" - // mips: "ADD[U]\t\\$-40","SUB" - // mips64: "ADDV[U]\t\\$-40","SUBV" - // ppc64x: `SUBC\tR[0-9]+,\s[$]40,\sR` - // riscv64: "ADDI\t\\$-40","NEG" + // arm64: "SUB \\$40" "NEG" + // loong64: "ADDV[U] \\$-40" "SUBV" + // mips: "ADD[U] \\$-40" "SUB" + // mips64: "ADDV[U] \\$-40" "SUBV" + // ppc64x: `SUBC R[0-9]+,\s[$]40,\sR` + // riscv64: "ADDI \\$-40" "NEG" c := -(-40 + a) return c } @@ -153,19 +153,19 @@ func SubSubNegSimplify(a, b int) int { // mips:"SUB" // mips64:"SUBV" // ppc64x:"NEG" - // riscv64:"NEG",-"SUB" + // riscv64:"NEG" -"SUB" r := (a - b) - a return r } func SubAddSimplify(a, b int) int { - // amd64:-"SUBQ",-"ADDQ" - // arm64:-"SUB",-"ADD" - // loong64:-"SUBV",-"ADDV" - // mips:-"SUB",-"ADD" - // mips64:-"SUBV",-"ADDV" - // ppc64x:-"SUB",-"ADD" - // riscv64:-"SUB",-"ADD" + // amd64:-"SUBQ" -"ADDQ" + // arm64:-"SUB" -"ADD" + // loong64:-"SUBV" -"ADDV" + // mips:-"SUB" -"ADD" + // mips64:-"SUBV" -"ADDV" + // ppc64x:-"SUB" -"ADD" + // riscv64:-"SUB" -"ADD" r := a + (b - a) return r } @@ -173,9 +173,9 @@ func SubAddSimplify(a, b int) int { func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) { // amd64:-"ADDQ" // arm64:-"ADD" - // mips:"SUB",-"ADD" - // mips64:"SUBV",-"ADDV" - // loong64:"SUBV",-"ADDV" + // mips:"SUB" -"ADD" + // mips64:"SUBV" -"ADDV" + // loong64:"SUBV" -"ADDV" r := (a + b) - (a + c) // amd64:-"ADDQ" r1 := (a + b) - (c + a) @@ -185,9 +185,9 @@ func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) { r3 := (b + a) - (c + a) // amd64:-"SUBQ" // arm64:-"SUB" - // mips:"ADD",-"SUB" - // mips64:"ADDV",-"SUBV" - // loong64:"ADDV",-"SUBV" + // mips:"ADD" -"SUB" + // mips64:"ADDV" -"SUBV" + // loong64:"ADDV" -"SUBV" r4 := (a - c) + (c + b) // amd64:-"SUBQ" r5 := (a - c) + (b + c) @@ -195,31 +195,31 @@ func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) { } func SubAddNegSimplify(a, b int) int { - // amd64:"NEGQ",-"ADDQ",-"SUBQ" - // arm64:"NEG",-"ADD",-"SUB" - // loong64:"SUBV",-"ADDV" - // mips:"SUB",-"ADD" - // mips64:"SUBV",-"ADDV" - // ppc64x:"NEG",-"ADD",-"SUB" - // riscv64:"NEG",-"ADD",-"SUB" + // amd64:"NEGQ" -"ADDQ" -"SUBQ" + // arm64:"NEG" -"ADD" -"SUB" + // loong64:"SUBV" -"ADDV" + // mips:"SUB" -"ADD" + // mips64:"SUBV" -"ADDV" + // ppc64x:"NEG" -"ADD" -"SUB" + // riscv64:"NEG" -"ADD" -"SUB" r := a - (b + a) return r } func AddAddSubSimplify(a, b, c int) int { // amd64:-"SUBQ" - // arm64:"ADD",-"SUB" - // loong64:"ADDV",-"SUBV" - // mips:"ADD",-"SUB" - // mips64:"ADDV",-"SUBV" + // arm64:"ADD" -"SUB" + // loong64:"ADDV" -"SUBV" + // mips:"ADD" -"SUB" + // mips64:"ADDV" -"SUBV" // ppc64x:-"SUB" - // riscv64:"ADD","ADD",-"SUB" + // riscv64:"ADD" "ADD" -"SUB" r := a + (b + (c - a)) return r } func NegToInt32(a int) int { - // riscv64: "NEGW",-"MOVW" + // riscv64: "NEGW" -"MOVW" r := int(int32(-a)) return r } @@ -229,20 +229,20 @@ func NegToInt32(a int) int { // -------------------- // func Pow2Muls(n1, n2 int) (int, int) { - // amd64:"SHLQ\t[$]5",-"IMULQ" - // 386:"SHLL\t[$]5",-"IMULL" - // arm:"SLL\t[$]5",-"MUL" - // arm64:"LSL\t[$]5",-"MUL" - // loong64:"SLLV\t[$]5",-"MULV" - // ppc64x:"SLD\t[$]5",-"MUL" + // amd64:"SHLQ [$]5" -"IMULQ" + // 386:"SHLL [$]5" -"IMULL" + // arm:"SLL [$]5" -"MUL" + // arm64:"LSL [$]5" -"MUL" + // loong64:"SLLV [$]5" -"MULV" + // ppc64x:"SLD [$]5" -"MUL" a := n1 * 32 - // amd64:"SHLQ\t[$]6",-"IMULQ" - // 386:"SHLL\t[$]6",-"IMULL" - // arm:"SLL\t[$]6",-"MUL" + // amd64:"SHLQ [$]6" -"IMULQ" + // 386:"SHLL [$]6" -"IMULL" + // arm:"SLL [$]6" -"MUL" // arm64:`NEG\sR[0-9]+<<6,\sR[0-9]+`,-`LSL`,-`MUL` - // loong64:"SLLV\t[$]6",-"MULV" - // ppc64x:"SLD\t[$]6","NEG\\sR[0-9]+,\\sR[0-9]+",-"MUL" + // loong64:"SLLV [$]6" -"MULV" + // ppc64x:"SLD [$]6" "NEG\\sR[0-9]+,\\sR[0-9]+" -"MUL" b := -64 * n2 return a, b @@ -258,18 +258,18 @@ func Mul_2(n1 int32, n2 int64) (int32, int64) { } func Mul_96(n int) int { - // amd64:`SHLQ\t[$]5`,`LEAQ\t\(.*\)\(.*\*2\),`,-`IMULQ` - // 386:`SHLL\t[$]5`,`LEAL\t\(.*\)\(.*\*2\),`,-`IMULL` - // arm64:`LSL\t[$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL` - // arm:`SLL\t[$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL` - // loong64:"SLLV\t[$]5","ALSLV\t[$]1," - // s390x:`SLD\t[$]5`,`SLD\t[$]6`,-`MULLD` + // amd64:`SHLQ [$]5`,`LEAQ \(.*\)\(.*\*2\),`,-`IMULQ` + // 386:`SHLL [$]5`,`LEAL \(.*\)\(.*\*2\),`,-`IMULL` + // arm64:`LSL [$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL` + // arm:`SLL [$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL` + // loong64:"SLLV [$]5" "ALSLV [$]1," + // s390x:`SLD [$]5`,`SLD [$]6`,-`MULLD` return n * 96 } func Mul_n120(n int) int { - // loong64:"SLLV\t[$]3","SLLV\t[$]7","SUBVU",-"MULV" - // s390x:`SLD\t[$]3`,`SLD\t[$]7`,-`MULLD` + // loong64:"SLLV [$]3" "SLLV [$]7" "SUBVU" -"MULV" + // s390x:`SLD [$]3`,`SLD [$]7`,-`MULLD` return n * -120 } @@ -284,50 +284,50 @@ func MulMemSrc(a []uint32, b []float32) { // Multiplications merging tests func MergeMuls1(n int) int { - // amd64:"IMUL3Q\t[$]46" - // 386:"IMUL3L\t[$]46" - // ppc64x:"MULLD\t[$]46" + // amd64:"IMUL3Q [$]46" + // 386:"IMUL3L [$]46" + // ppc64x:"MULLD [$]46" return 15*n + 31*n // 46n } func MergeMuls2(n int) int { - // amd64:"IMUL3Q\t[$]23","(ADDQ\t[$]29)|(LEAQ\t29)" - // 386:"IMUL3L\t[$]23","ADDL\t[$]29" - // ppc64x/power9:"MADDLD",-"MULLD\t[$]23",-"ADD\t[$]29" - // ppc64x/power8:"MULLD\t[$]23","ADD\t[$]29" + // amd64:"IMUL3Q [$]23" "(ADDQ [$]29)|(LEAQ 29)" + // 386:"IMUL3L [$]23" "ADDL [$]29" + // ppc64x/power9:"MADDLD" -"MULLD [$]23" -"ADD [$]29" + // ppc64x/power8:"MULLD [$]23" "ADD [$]29" return 5*n + 7*(n+1) + 11*(n+2) // 23n + 29 } func MergeMuls3(a, n int) int { - // amd64:"ADDQ\t[$]19",-"IMULQ\t[$]19" - // 386:"ADDL\t[$]19",-"IMULL\t[$]19" - // ppc64x:"ADD\t[$]19",-"MULLD\t[$]19" + // amd64:"ADDQ [$]19" -"IMULQ [$]19" + // 386:"ADDL [$]19" -"IMULL [$]19" + // ppc64x:"ADD [$]19" -"MULLD [$]19" return a*n + 19*n // (a+19)n } func MergeMuls4(n int) int { - // amd64:"IMUL3Q\t[$]14" - // 386:"IMUL3L\t[$]14" - // ppc64x:"MULLD\t[$]14" + // amd64:"IMUL3Q [$]14" + // 386:"IMUL3L [$]14" + // ppc64x:"MULLD [$]14" return 23*n - 9*n // 14n } func MergeMuls5(a, n int) int { - // amd64:"ADDQ\t[$]-19",-"IMULQ\t[$]19" - // 386:"ADDL\t[$]-19",-"IMULL\t[$]19" - // ppc64x:"ADD\t[$]-19",-"MULLD\t[$]19" + // amd64:"ADDQ [$]-19" -"IMULQ [$]19" + // 386:"ADDL [$]-19" -"IMULL [$]19" + // ppc64x:"ADD [$]-19" -"MULLD [$]19" return a*n - 19*n // (a-19)n } // Multiplications folded negation func FoldNegMul(a int) int { - // loong64:"SUBVU","ALSLV\t[$]2","ALSLV\t[$]1" + // loong64:"SUBVU" "ALSLV [$]2" "ALSLV [$]1" return (-a) * 11 } func Fold2NegMul(a, b int) int { - // loong64:"MULV",-"SUBVU\tR[0-9], R0," + // loong64:"MULV" -"SUBVU R[0-9], R0," return (-a) * (-b) } @@ -342,17 +342,17 @@ func DivMemSrc(a []float64) { } func Pow2Divs(n1 uint, n2 int) (uint, int) { - // 386:"SHRL\t[$]5",-"DIVL" - // amd64:"SHRQ\t[$]5",-"DIVQ" - // arm:"SRL\t[$]5",-".*udiv" - // arm64:"LSR\t[$]5",-"UDIV" + // 386:"SHRL [$]5" -"DIVL" + // amd64:"SHRQ [$]5" -"DIVQ" + // arm:"SRL [$]5" -".*udiv" + // arm64:"LSR [$]5" -"UDIV" // ppc64x:"SRD" a := n1 / 32 // unsigned - // amd64:"SARQ\t[$]6",-"IDIVQ" - // 386:"SARL\t[$]6",-"IDIVL" - // arm:"SRA\t[$]6",-".*udiv" - // arm64:"ASR\t[$]6",-"SDIV" + // amd64:"SARQ [$]6" -"IDIVQ" + // 386:"SARL [$]6" -"IDIVL" + // arm:"SRA [$]6" -".*udiv" + // arm64:"ASR [$]6" -"SDIV" // ppc64x:"SRAD" b := n2 / 64 // signed @@ -361,14 +361,14 @@ func Pow2Divs(n1 uint, n2 int) (uint, int) { // Check that constant divisions get turned into MULs func ConstDivs(n1 uint, n2 int) (uint, int) { - // amd64:"MOVQ\t[$]-1085102592571150095","MULQ",-"DIVQ" - // 386:"MOVL\t[$]-252645135","MULL",-"DIVL" + // amd64:"MOVQ [$]-1085102592571150095" "MULQ" -"DIVQ" + // 386:"MOVL [$]-252645135" "MULL" -"DIVL" // arm64:`MOVD`,`UMULH`,-`DIV` // arm:`MOVW`,`MUL`,-`.*udiv` a := n1 / 17 // unsigned - // amd64:"MOVQ\t[$]-1085102592571150095","IMULQ",-"IDIVQ" - // 386:"MOVL\t[$]-252645135","IMULL",-"IDIVL" + // amd64:"MOVQ [$]-1085102592571150095" "IMULQ" -"IDIVQ" + // 386:"IMULL" -"IDIVL" // arm64:`SMULH`,-`DIV` // arm:`MOVW`,`MUL`,-`.*udiv` b := n2 / 17 // signed @@ -383,17 +383,17 @@ func FloatDivs(a []float32) float32 { } func Pow2Mods(n1 uint, n2 int) (uint, int) { - // 386:"ANDL\t[$]31",-"DIVL" - // amd64:"ANDL\t[$]31",-"DIVQ" - // arm:"AND\t[$]31",-".*udiv" - // arm64:"AND\t[$]31",-"UDIV" + // 386:"ANDL [$]31" -"DIVL" + // amd64:"ANDL [$]31" -"DIVQ" + // arm:"AND [$]31" -".*udiv" + // arm64:"AND [$]31" -"UDIV" // ppc64x:"RLDICL" a := n1 % 32 // unsigned - // 386:"SHRL",-"IDIVL" - // amd64:"SHRQ",-"IDIVQ" - // arm:"SRA",-".*udiv" - // arm64:"ASR",-"REM" + // 386:"SHRL" -"IDIVL" + // amd64:"SHRQ" -"IDIVQ" + // arm:"SRA" -".*udiv" + // arm64:"ASR" -"REM" // ppc64x:"SRAD" b := n2 % 64 // signed @@ -402,18 +402,18 @@ func Pow2Mods(n1 uint, n2 int) (uint, int) { // Check that signed divisibility checks get converted to AND on low bits func Pow2DivisibleSigned(n1, n2 int) (bool, bool) { - // 386:"TESTL\t[$]63",-"DIVL",-"SHRL" - // amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ" - // arm:"AND\t[$]63",-".*udiv",-"SRA" - // arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND" - // ppc64x:"ANDCC",-"RLDICL",-"SRAD",-"CMP" + // 386:"TESTL [$]63" -"DIVL" -"SHRL" + // amd64:"TESTQ [$]63" -"DIVQ" -"SHRQ" + // arm:"AND [$]63" -".*udiv" -"SRA" + // arm64:"TST [$]63" -"UDIV" -"ASR" -"AND" + // ppc64x:"ANDCC" -"RLDICL" -"SRAD" -"CMP" a := n1%64 == 0 // signed divisible - // 386:"TESTL\t[$]63",-"DIVL",-"SHRL" - // amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ" - // arm:"AND\t[$]63",-".*udiv",-"SRA" - // arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND" - // ppc64x:"ANDCC",-"RLDICL",-"SRAD",-"CMP" + // 386:"TESTL [$]63" -"DIVL" -"SHRL" + // amd64:"TESTQ [$]63" -"DIVQ" -"SHRQ" + // arm:"AND [$]63" -".*udiv" -"SRA" + // arm64:"TST [$]63" -"UDIV" -"ASR" -"AND" + // ppc64x:"ANDCC" -"RLDICL" -"SRAD" -"CMP" b := n2%64 != 0 // signed indivisible return a, b @@ -421,14 +421,14 @@ func Pow2DivisibleSigned(n1, n2 int) (bool, bool) { // Check that constant modulo divs get turned into MULs func ConstMods(n1 uint, n2 int) (uint, int) { - // amd64:"MOVQ\t[$]-1085102592571150095","MULQ",-"DIVQ" - // 386:"MOVL\t[$]-252645135","MULL",-"DIVL" + // amd64:"MOVQ [$]-1085102592571150095" "MULQ" -"DIVQ" + // 386:"MOVL [$]-252645135" "MULL" -"DIVL" // arm64:`MOVD`,`UMULH`,-`DIV` // arm:`MOVW`,`MUL`,-`.*udiv` a := n1 % 17 // unsigned - // amd64:"MOVQ\t[$]-1085102592571150095","IMULQ",-"IDIVQ" - // 386:"MOVL\t[$]-252645135","IMULL",-"IDIVL" + // amd64:"MOVQ [$]-1085102592571150095" "IMULQ" -"IDIVQ" + // 386: "IMULL" -"IDIVL" // arm64:`SMULH`,-`DIV` // arm:`MOVW`,`MUL`,-`.*udiv` b := n2 % 17 // signed @@ -438,38 +438,38 @@ func ConstMods(n1 uint, n2 int) (uint, int) { // Check that divisibility checks x%c==0 are converted to MULs and rotates func DivisibleU(n uint) (bool, bool) { - // amd64:"MOVQ\t[$]-6148914691236517205","IMULQ","ROLQ\t[$]63",-"DIVQ" - // 386:"IMUL3L\t[$]-1431655765","ROLL\t[$]31",-"DIVQ" - // arm64:"MOVD\t[$]-6148914691236517205","MOVD\t[$]3074457345618258602","MUL","ROR",-"DIV" - // arm:"MUL","CMP\t[$]715827882",-".*udiv" - // ppc64x:"MULLD","ROTL\t[$]63" + // amd64:"MOVQ [$]-6148914691236517205" "IMULQ" "ROLQ [$]63" -"DIVQ" + // 386:"IMUL3L [$]-1431655765" "ROLL [$]31" -"DIVQ" + // arm64:"MOVD [$]-6148914691236517205" "MOVD [$]3074457345618258602" "MUL" "ROR" -"DIV" + // arm:"MUL" "CMP [$]715827882" -".*udiv" + // ppc64x:"MULLD" "ROTL [$]63" even := n%6 == 0 - // amd64:"MOVQ\t[$]-8737931403336103397","IMULQ",-"ROLQ",-"DIVQ" - // 386:"IMUL3L\t[$]678152731",-"ROLL",-"DIVQ" - // arm64:"MOVD\t[$]-8737931403336103397","MUL",-"ROR",-"DIV" - // arm:"MUL","CMP\t[$]226050910",-".*udiv" - // ppc64x:"MULLD",-"ROTL" + // amd64:"MOVQ [$]-8737931403336103397" "IMULQ" -"ROLQ" -"DIVQ" + // 386:"IMUL3L [$]678152731" -"ROLL" -"DIVQ" + // arm64:"MOVD [$]-8737931403336103397" "MUL" -"ROR" -"DIV" + // arm:"MUL" "CMP [$]226050910" -".*udiv" + // ppc64x:"MULLD" -"ROTL" odd := n%19 == 0 return even, odd } func Divisible(n int) (bool, bool) { - // amd64:"IMULQ","ADD","ROLQ\t[$]63",-"DIVQ" - // 386:"IMUL3L\t[$]-1431655765","ADDL\t[$]715827882","ROLL\t[$]31",-"DIVQ" - // arm64:"MOVD\t[$]-6148914691236517205","MOVD\t[$]3074457345618258602","MUL","ADD\tR","ROR",-"DIV" - // arm:"MUL","ADD\t[$]715827882",-".*udiv" - // ppc64x/power8:"MULLD","ADD","ROTL\t[$]63" - // ppc64x/power9:"MADDLD","ROTL\t[$]63" + // amd64:"IMULQ" "ADD" "ROLQ [$]63" -"DIVQ" + // 386:"IMUL3L [$]-1431655765" "ADDL [$]715827882" "ROLL [$]31" -"DIVQ" + // arm64:"MOVD [$]-6148914691236517205" "MOVD [$]3074457345618258602" "MUL" "ADD R" "ROR" -"DIV" + // arm:"MUL" "ADD [$]715827882" -".*udiv" + // ppc64x/power8:"MULLD" "ADD" "ROTL [$]63" + // ppc64x/power9:"MADDLD" "ROTL [$]63" even := n%6 == 0 - // amd64:"IMULQ","ADD",-"ROLQ",-"DIVQ" - // 386:"IMUL3L\t[$]678152731","ADDL\t[$]113025455",-"ROLL",-"DIVQ" - // arm64:"MUL","MOVD\t[$]485440633518672410","ADD",-"ROR",-"DIV" - // arm:"MUL","ADD\t[$]113025455",-".*udiv" - // ppc64x/power8:"MULLD","ADD",-"ROTL" - // ppc64x/power9:"MADDLD",-"ROTL" + // amd64:"IMULQ" "ADD" -"ROLQ" -"DIVQ" + // 386:"IMUL3L [$]678152731" "ADDL [$]113025455" -"ROLL" -"DIVQ" + // arm64:"MUL" "MOVD [$]485440633518672410" "ADD" -"ROR" -"DIV" + // arm:"MUL" "ADD [$]113025455" -".*udiv" + // ppc64x/power8:"MULLD" "ADD" -"ROTL" + // ppc64x/power9:"MADDLD" -"ROTL" odd := n%19 == 0 return even, odd @@ -568,64 +568,64 @@ func NoFix16B(divd int16) (int16, int16) { // optimized into shifts and ands func LenDiv1(a []int) int { - // 386:"SHRL\t[$]10" - // amd64:"SHRQ\t[$]10" - // arm64:"LSR\t[$]10",-"SDIV" - // arm:"SRL\t[$]10",-".*udiv" - // ppc64x:"SRD"\t[$]10" + // 386:"SHRL [$]10" + // amd64:"SHRQ [$]10" + // arm64:"LSR [$]10" -"SDIV" + // arm:"SRL [$]10" -".*udiv" + // ppc64x:"SRD" [$]10" return len(a) / 1024 } func LenDiv2(s string) int { - // 386:"SHRL\t[$]11" - // amd64:"SHRQ\t[$]11" - // arm64:"LSR\t[$]11",-"SDIV" - // arm:"SRL\t[$]11",-".*udiv" - // ppc64x:"SRD\t[$]11" + // 386:"SHRL [$]11" + // amd64:"SHRQ [$]11" + // arm64:"LSR [$]11" -"SDIV" + // arm:"SRL [$]11" -".*udiv" + // ppc64x:"SRD [$]11" return len(s) / (4097 >> 1) } func LenMod1(a []int) int { - // 386:"ANDL\t[$]1023" - // amd64:"ANDL\t[$]1023" - // arm64:"AND\t[$]1023",-"SDIV" - // arm/6:"AND",-".*udiv" - // arm/7:"BFC",-".*udiv",-"AND" + // 386:"ANDL [$]1023" + // amd64:"ANDL [$]1023" + // arm64:"AND [$]1023" -"SDIV" + // arm/6:"AND" -".*udiv" + // arm/7:"BFC" -".*udiv" -"AND" // ppc64x:"RLDICL" return len(a) % 1024 } func LenMod2(s string) int { - // 386:"ANDL\t[$]2047" - // amd64:"ANDL\t[$]2047" - // arm64:"AND\t[$]2047",-"SDIV" - // arm/6:"AND",-".*udiv" - // arm/7:"BFC",-".*udiv",-"AND" + // 386:"ANDL [$]2047" + // amd64:"ANDL [$]2047" + // arm64:"AND [$]2047" -"SDIV" + // arm/6:"AND" -".*udiv" + // arm/7:"BFC" -".*udiv" -"AND" // ppc64x:"RLDICL" return len(s) % (4097 >> 1) } func CapDiv(a []int) int { - // 386:"SHRL\t[$]12" - // amd64:"SHRQ\t[$]12" - // arm64:"LSR\t[$]12",-"SDIV" - // arm:"SRL\t[$]12",-".*udiv" - // ppc64x:"SRD\t[$]12" + // 386:"SHRL [$]12" + // amd64:"SHRQ [$]12" + // arm64:"LSR [$]12" -"SDIV" + // arm:"SRL [$]12" -".*udiv" + // ppc64x:"SRD [$]12" return cap(a) / ((1 << 11) + 2048) } func CapMod(a []int) int { - // 386:"ANDL\t[$]4095" - // amd64:"ANDL\t[$]4095" - // arm64:"AND\t[$]4095",-"SDIV" - // arm/6:"AND",-".*udiv" - // arm/7:"BFC",-".*udiv",-"AND" + // 386:"ANDL [$]4095" + // amd64:"ANDL [$]4095" + // arm64:"AND [$]4095" -"SDIV" + // arm/6:"AND" -".*udiv" + // arm/7:"BFC" -".*udiv" -"AND" // ppc64x:"RLDICL" return cap(a) % ((1 << 11) + 2048) } func AddMul(x int) int { - // amd64:"LEAQ\t1" + // amd64:"LEAQ 1" return 2*x + 1 } @@ -687,17 +687,17 @@ func divInt(v int64) int64 { // The reassociate rules "x - (z + C) -> (x - z) - C" and // "(z + C) -x -> C + (z - x)" can optimize the following cases. func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) { - // arm64:"SUB","ADD\t[$]2" - // ppc64x:"SUB","ADD\t[$]2" + // arm64:"SUB" "ADD [$]2" + // ppc64x:"SUB" "ADD [$]2" r0 := (i0 + 3) - (j0 + 1) - // arm64:"SUB","SUB\t[$]4" - // ppc64x:"SUB","ADD\t[$]-4" + // arm64:"SUB" "SUB [$]4" + // ppc64x:"SUB" "ADD [$]-4" r1 := (i1 - 3) - (j1 + 1) - // arm64:"SUB","ADD\t[$]4" - // ppc64x:"SUB","ADD\t[$]4" + // arm64:"SUB" "ADD [$]4" + // ppc64x:"SUB" "ADD [$]4" r2 := (i2 + 3) - (j2 - 1) - // arm64:"SUB","SUB\t[$]2" - // ppc64x:"SUB","ADD\t[$]-2" + // arm64:"SUB" "SUB [$]2" + // ppc64x:"SUB" "ADD [$]-2" r3 := (i3 - 3) - (j3 - 1) return r0, r1, r2, r3 } @@ -705,18 +705,18 @@ func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) { // The reassociate rules "x - (z + C) -> (x - z) - C" and // "(C - z) - x -> C - (z + x)" can optimize the following cases. func constantFold2(i0, j0, i1, j1 int) (int, int) { - // arm64:"ADD","MOVD\t[$]2","SUB" - // ppc64x: `SUBC\tR[0-9]+,\s[$]2,\sR` + // arm64:"ADD" "MOVD [$]2" "SUB" + // ppc64x: `SUBC R[0-9]+,\s[$]2,\sR` r0 := (3 - i0) - (j0 + 1) - // arm64:"ADD","MOVD\t[$]4","SUB" - // ppc64x: `SUBC\tR[0-9]+,\s[$]4,\sR` + // arm64:"ADD" "MOVD [$]4" "SUB" + // ppc64x: `SUBC R[0-9]+,\s[$]4,\sR` r1 := (3 - i1) - (j1 - 1) return r0, r1 } func constantFold3(i, j int) int { - // arm64: "LSL\t[$]5,","SUB\tR[0-9]+<<1,",-"ADD" - // ppc64x:"MULLD\t[$]30","MULLD" + // arm64: "LSL [$]5," "SUB R[0-9]+<<1," -"ADD" + // ppc64x:"MULLD [$]30" "MULLD" r := (5 * i) * (6 * j) return r } @@ -726,32 +726,32 @@ func constantFold3(i, j int) int { // ----------------- // func Int64Min(a, b int64) int64 { - // amd64: "CMPQ","CMOVQLT" - // arm64: "CMP","CSEL" - // riscv64/rva20u64:"BLT\t" - // riscv64/rva22u64,riscv64/rva23u64:"MIN\t" + // amd64: "CMPQ" "CMOVQLT" + // arm64: "CMP" "CSEL" + // riscv64/rva20u64:"BLT " + // riscv64/rva22u64,riscv64/rva23u64:"MIN " return min(a, b) } func Int64Max(a, b int64) int64 { - // amd64: "CMPQ","CMOVQGT" - // arm64: "CMP","CSEL" - // riscv64/rva20u64:"BLT\t" - // riscv64/rva22u64,riscv64/rva23u64:"MAX\t" + // amd64: "CMPQ" "CMOVQGT" + // arm64: "CMP" "CSEL" + // riscv64/rva20u64:"BLT " + // riscv64/rva22u64,riscv64/rva23u64:"MAX " return max(a, b) } func Uint64Min(a, b uint64) uint64 { - // amd64: "CMPQ","CMOVQCS" - // arm64: "CMP","CSEL" + // amd64: "CMPQ" "CMOVQCS" + // arm64: "CMP" "CSEL" // riscv64/rva20u64:"BLTU" // riscv64/rva22u64,riscv64/rva23u64:"MINU" return min(a, b) } func Uint64Max(a, b uint64) uint64 { - // amd64: "CMPQ","CMOVQHI" - // arm64: "CMP","CSEL" + // amd64: "CMPQ" "CMOVQHI" + // arm64: "CMP" "CSEL" // riscv64/rva20u64:"BLTU" // riscv64/rva22u64,riscv64/rva23u64:"MAXU" return max(a, b) diff --git a/test/codegen/atomics.go b/test/codegen/atomics.go index 14024dcd83..7ae5a9aff7 100644 --- a/test/codegen/atomics.go +++ b/test/codegen/atomics.go @@ -22,7 +22,7 @@ func (c *Counter) Increment() { // arm64/v8.1:"LDADDALW" // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" - // amd64:"LOCK",-"CMPXCHG" + // amd64:"LOCK" -"CMPXCHG" atomic.AddInt32(&c.count, 1) } @@ -34,13 +34,13 @@ func atomicLogical64(x *atomic.Uint64) uint64 { // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" // On amd64, make sure we use LOCK+AND instead of CMPXCHG when we don't use the result. - // amd64:"LOCK",-"CMPXCHGQ" + // amd64:"LOCK" -"CMPXCHGQ" x.And(11) // arm64/v8.0:"LDCLRALD" // arm64/v8.1:"LDCLRALD" // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" - // amd64:"LOCK","CMPXCHGQ" + // amd64:"LOCK" "CMPXCHGQ" r += x.And(22) // arm64/v8.0:"LDORALD" @@ -48,13 +48,13 @@ func atomicLogical64(x *atomic.Uint64) uint64 { // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" // On amd64, make sure we use LOCK+OR instead of CMPXCHG when we don't use the result. - // amd64:"LOCK",-"CMPXCHGQ" + // amd64:"LOCK" -"CMPXCHGQ" x.Or(33) // arm64/v8.0:"LDORALD" // arm64/v8.1:"LDORALD" // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" - // amd64:"LOCK","CMPXCHGQ" + // amd64:"LOCK" "CMPXCHGQ" r += x.Or(44) return r @@ -68,13 +68,13 @@ func atomicLogical32(x *atomic.Uint32) uint32 { // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" // On amd64, make sure we use LOCK+AND instead of CMPXCHG when we don't use the result. - // amd64:"LOCK",-"CMPXCHGL" + // amd64:"LOCK" -"CMPXCHGL" x.And(11) // arm64/v8.0:"LDCLRALW" // arm64/v8.1:"LDCLRALW" // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" - // amd64:"LOCK","CMPXCHGL" + // amd64:"LOCK" "CMPXCHGL" r += x.And(22) // arm64/v8.0:"LDORALW" @@ -82,13 +82,13 @@ func atomicLogical32(x *atomic.Uint32) uint32 { // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" // On amd64, make sure we use LOCK+OR instead of CMPXCHG when we don't use the result. - // amd64:"LOCK",-"CMPXCHGL" + // amd64:"LOCK" -"CMPXCHGL" x.Or(33) // arm64/v8.0:"LDORALW" // arm64/v8.1:"LDORALW" // arm64/v8.0:".*arm64HasATOMICS" // arm64/v8.1:-".*arm64HasATOMICS" - // amd64:"LOCK","CMPXCHGL" + // amd64:"LOCK" "CMPXCHGL" r += x.Or(44) return r diff --git a/test/codegen/bitfield.go b/test/codegen/bitfield.go index 51221266e1..2539362750 100644 --- a/test/codegen/bitfield.go +++ b/test/codegen/bitfield.go @@ -10,304 +10,304 @@ package codegen // insertion/extraction simplifications/optimizations. func extr1(x, x2 uint64) uint64 { - return x<<7 + x2>>57 // arm64:"EXTR\t[$]57," + return x<<7 + x2>>57 // arm64:"EXTR [$]57," } func extr2(x, x2 uint64) uint64 { - return x<<7 | x2>>57 // arm64:"EXTR\t[$]57," + return x<<7 | x2>>57 // arm64:"EXTR [$]57," } func extr3(x, x2 uint64) uint64 { - return x<<7 ^ x2>>57 // arm64:"EXTR\t[$]57," + return x<<7 ^ x2>>57 // arm64:"EXTR [$]57," } func extr4(x, x2 uint32) uint32 { - return x<<7 + x2>>25 // arm64:"EXTRW\t[$]25," + return x<<7 + x2>>25 // arm64:"EXTRW [$]25," } func extr5(x, x2 uint32) uint32 { - return x<<7 | x2>>25 // arm64:"EXTRW\t[$]25," + return x<<7 | x2>>25 // arm64:"EXTRW [$]25," } func extr6(x, x2 uint32) uint32 { - return x<<7 ^ x2>>25 // arm64:"EXTRW\t[$]25," + return x<<7 ^ x2>>25 // arm64:"EXTRW [$]25," } // check 32-bit shift masking func mask32(x uint32) uint32 { - return (x << 29) >> 29 // arm64:"AND\t[$]7, R[0-9]+",-"LSR",-"LSL" + return (x << 29) >> 29 // arm64:"AND [$]7, R[0-9]+" -"LSR" -"LSL" } // check 16-bit shift masking func mask16(x uint16) uint16 { - return (x << 14) >> 14 // arm64:"AND\t[$]3, R[0-9]+",-"LSR",-"LSL" + return (x << 14) >> 14 // arm64:"AND [$]3, R[0-9]+" -"LSR" -"LSL" } // check 8-bit shift masking func mask8(x uint8) uint8 { - return (x << 7) >> 7 // arm64:"AND\t[$]1, R[0-9]+",-"LSR",-"LSL" + return (x << 7) >> 7 // arm64:"AND [$]1, R[0-9]+" -"LSR" -"LSL" } func maskshift(x uint64) uint64 { - // arm64:"AND\t[$]4095, R[0-9]+",-"LSL",-"LSR",-"UBFIZ",-"UBFX" + // arm64:"AND [$]4095, R[0-9]+" -"LSL" -"LSR" -"UBFIZ" -"UBFX" return ((x << 5) & (0xfff << 5)) >> 5 } // bitfield ops // bfi func bfi1(x, y uint64) uint64 { - // arm64:"BFI\t[$]4, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND" + // arm64:"BFI [$]4, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND" return ((x & 0xfff) << 4) | (y & 0xffffffffffff000f) } func bfi2(x, y uint64) uint64 { - // arm64:"BFI\t[$]12, R[0-9]+, [$]40",-"LSL",-"LSR",-"AND" + // arm64:"BFI [$]12, R[0-9]+, [$]40" -"LSL" -"LSR" -"AND" return (x << 24 >> 12) | (y & 0xfff0000000000fff) } // bfxil func bfxil1(x, y uint64) uint64 { - // arm64:"BFXIL\t[$]5, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND" + // arm64:"BFXIL [$]5, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND" return ((x >> 5) & 0xfff) | (y & 0xfffffffffffff000) } func bfxil2(x, y uint64) uint64 { - // arm64:"BFXIL\t[$]12, R[0-9]+, [$]40",-"LSL",-"LSR",-"AND" + // arm64:"BFXIL [$]12, R[0-9]+, [$]40" -"LSL" -"LSR" -"AND" return (x << 12 >> 24) | (y & 0xffffff0000000000) } // sbfiz // merge shifts into sbfiz: (x << lc) >> rc && lc > rc. func sbfiz1(x int64) int64 { - // arm64:"SBFIZ\t[$]1, R[0-9]+, [$]60",-"LSL",-"ASR" + // arm64:"SBFIZ [$]1, R[0-9]+, [$]60" -"LSL" -"ASR" return (x << 4) >> 3 } // merge shift and sign-extension into sbfiz. func sbfiz2(x int32) int64 { - return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]29",-"LSL" + return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]29" -"LSL" } func sbfiz3(x int16) int64 { - return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]13",-"LSL" + return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]13" -"LSL" } func sbfiz4(x int8) int64 { - return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]5",-"LSL" + return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]5" -"LSL" } // sbfiz combinations. // merge shift with sbfiz into sbfiz. func sbfiz5(x int32) int32 { - // arm64:"SBFIZ\t[$]1, R[0-9]+, [$]28",-"LSL",-"ASR" + // arm64:"SBFIZ [$]1, R[0-9]+, [$]28" -"LSL" -"ASR" return (x << 4) >> 3 } func sbfiz6(x int16) int64 { - return int64(x+1) << 3 // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]16",-"LSL" + return int64(x+1) << 3 // arm64:"SBFIZ [$]3, R[0-9]+, [$]16" -"LSL" } func sbfiz7(x int8) int64 { - return int64(x+1) << 62 // arm64:"SBFIZ\t[$]62, R[0-9]+, [$]2",-"LSL" + return int64(x+1) << 62 // arm64:"SBFIZ [$]62, R[0-9]+, [$]2" -"LSL" } func sbfiz8(x int32) int64 { - return int64(x+1) << 40 // arm64:"SBFIZ\t[$]40, R[0-9]+, [$]24",-"LSL" + return int64(x+1) << 40 // arm64:"SBFIZ [$]40, R[0-9]+, [$]24" -"LSL" } // sbfx // merge shifts into sbfx: (x << lc) >> rc && lc <= rc. func sbfx1(x int64) int64 { - return (x << 3) >> 4 // arm64:"SBFX\t[$]1, R[0-9]+, [$]60",-"LSL",-"ASR" + return (x << 3) >> 4 // arm64:"SBFX [$]1, R[0-9]+, [$]60" -"LSL" -"ASR" } func sbfx2(x int64) int64 { - return (x << 60) >> 60 // arm64:"SBFX\t[$]0, R[0-9]+, [$]4",-"LSL",-"ASR" + return (x << 60) >> 60 // arm64:"SBFX [$]0, R[0-9]+, [$]4" -"LSL" -"ASR" } // merge shift and sign-extension into sbfx. func sbfx3(x int32) int64 { - return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]29",-"ASR" + return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]29" -"ASR" } func sbfx4(x int16) int64 { - return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]13",-"ASR" + return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]13" -"ASR" } func sbfx5(x int8) int64 { - return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]5",-"ASR" + return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]5" -"ASR" } func sbfx6(x int32) int64 { - return int64(x >> 30) // arm64:"SBFX\t[$]30, R[0-9]+, [$]2" + return int64(x >> 30) // arm64:"SBFX [$]30, R[0-9]+, [$]2" } func sbfx7(x int16) int64 { - return int64(x >> 10) // arm64:"SBFX\t[$]10, R[0-9]+, [$]6" + return int64(x >> 10) // arm64:"SBFX [$]10, R[0-9]+, [$]6" } func sbfx8(x int8) int64 { - return int64(x >> 5) // arm64:"SBFX\t[$]5, R[0-9]+, [$]3" + return int64(x >> 5) // arm64:"SBFX [$]5, R[0-9]+, [$]3" } // sbfx combinations. // merge shifts with sbfiz into sbfx. func sbfx9(x int32) int32 { - return (x << 3) >> 4 // arm64:"SBFX\t[$]1, R[0-9]+, [$]28",-"LSL",-"ASR" + return (x << 3) >> 4 // arm64:"SBFX [$]1, R[0-9]+, [$]28" -"LSL" -"ASR" } // merge sbfx and sign-extension into sbfx. func sbfx10(x int32) int64 { c := x + 5 - return int64(c >> 20) // arm64"SBFX\t[$]20, R[0-9]+, [$]12",-"MOVW\tR[0-9]+, R[0-9]+" + return int64(c >> 20) // arm64"SBFX [$]20, R[0-9]+, [$]12" -"MOVW R[0-9]+, R[0-9]+" } // ubfiz // merge shifts into ubfiz: (x<>rc && lc>rc func ubfiz1(x uint64) uint64 { - // arm64:"UBFIZ\t[$]1, R[0-9]+, [$]60",-"LSL",-"LSR" - // s390x:"RISBGZ\t[$]3, [$]62, [$]1, ",-"SLD",-"SRD" + // arm64:"UBFIZ [$]1, R[0-9]+, [$]60" -"LSL" -"LSR" + // s390x:"RISBGZ [$]3, [$]62, [$]1, " -"SLD" -"SRD" return (x << 4) >> 3 } // merge shift and zero-extension into ubfiz. func ubfiz2(x uint32) uint64 { - return uint64(x+1) << 3 // arm64:"UBFIZ\t[$]3, R[0-9]+, [$]32",-"LSL" + return uint64(x+1) << 3 // arm64:"UBFIZ [$]3, R[0-9]+, [$]32" -"LSL" } func ubfiz3(x uint16) uint64 { - return uint64(x+1) << 3 // arm64:"UBFIZ\t[$]3, R[0-9]+, [$]16",-"LSL" + return uint64(x+1) << 3 // arm64:"UBFIZ [$]3, R[0-9]+, [$]16" -"LSL" } func ubfiz4(x uint8) uint64 { - return uint64(x+1) << 3 // arm64:"UBFIZ\t[$]3, R[0-9]+, [$]8",-"LSL" + return uint64(x+1) << 3 // arm64:"UBFIZ [$]3, R[0-9]+, [$]8" -"LSL" } func ubfiz5(x uint8) uint64 { - return uint64(x) << 60 // arm64:"UBFIZ\t[$]60, R[0-9]+, [$]4",-"LSL" + return uint64(x) << 60 // arm64:"UBFIZ [$]60, R[0-9]+, [$]4" -"LSL" } func ubfiz6(x uint32) uint64 { - return uint64(x << 30) // arm64:"UBFIZ\t[$]30, R[0-9]+, [$]2", + return uint64(x << 30) // arm64:"UBFIZ [$]30, R[0-9]+, [$]2", } func ubfiz7(x uint16) uint64 { - return uint64(x << 10) // arm64:"UBFIZ\t[$]10, R[0-9]+, [$]6", + return uint64(x << 10) // arm64:"UBFIZ [$]10, R[0-9]+, [$]6", } func ubfiz8(x uint8) uint64 { - return uint64(x << 7) // arm64:"UBFIZ\t[$]7, R[0-9]+, [$]1", + return uint64(x << 7) // arm64:"UBFIZ [$]7, R[0-9]+, [$]1", } // merge ANDconst into ubfiz. func ubfiz9(x uint64) uint64 { - // arm64:"UBFIZ\t[$]3, R[0-9]+, [$]12",-"LSL",-"AND" - // s390x:"RISBGZ\t[$]49, [$]60, [$]3,",-"SLD",-"AND" + // arm64:"UBFIZ [$]3, R[0-9]+, [$]12" -"LSL" -"AND" + // s390x:"RISBGZ [$]49, [$]60, [$]3," -"SLD" -"AND" return (x & 0xfff) << 3 } func ubfiz10(x uint64) uint64 { - // arm64:"UBFIZ\t[$]4, R[0-9]+, [$]12",-"LSL",-"AND" - // s390x:"RISBGZ\t[$]48, [$]59, [$]4,",-"SLD",-"AND" + // arm64:"UBFIZ [$]4, R[0-9]+, [$]12" -"LSL" -"AND" + // s390x:"RISBGZ [$]48, [$]59, [$]4," -"SLD" -"AND" return (x << 4) & 0xfff0 } // ubfiz combinations func ubfiz11(x uint32) uint32 { - // arm64:"UBFIZ\t[$]1, R[0-9]+, [$]28",-"LSL",-"LSR" + // arm64:"UBFIZ [$]1, R[0-9]+, [$]28" -"LSL" -"LSR" return (x << 4) >> 3 } func ubfiz12(x uint64) uint64 { - // arm64:"UBFIZ\t[$]1, R[0-9]+, [$]20",-"LSL",-"LSR" - // s390x:"RISBGZ\t[$]43, [$]62, [$]1, ",-"SLD",-"SRD",-"AND" + // arm64:"UBFIZ [$]1, R[0-9]+, [$]20" -"LSL" -"LSR" + // s390x:"RISBGZ [$]43, [$]62, [$]1, " -"SLD" -"SRD" -"AND" return ((x & 0xfffff) << 4) >> 3 } func ubfiz13(x uint64) uint64 { - // arm64:"UBFIZ\t[$]5, R[0-9]+, [$]13",-"LSL",-"LSR",-"AND" + // arm64:"UBFIZ [$]5, R[0-9]+, [$]13" -"LSL" -"LSR" -"AND" return ((x << 3) & 0xffff) << 2 } func ubfiz14(x uint64) uint64 { - // arm64:"UBFIZ\t[$]7, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND" - // s390x:"RISBGZ\t[$]45, [$]56, [$]7, ",-"SLD",-"SRD",-"AND" + // arm64:"UBFIZ [$]7, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND" + // s390x:"RISBGZ [$]45, [$]56, [$]7, " -"SLD" -"SRD" -"AND" return ((x << 5) & (0xfff << 5)) << 2 } // ubfx // merge shifts into ubfx: (x<>rc && lc> 2 } // merge shift and zero-extension into ubfx. func ubfx2(x uint32) uint64 { - return uint64(x >> 15) // arm64:"UBFX\t[$]15, R[0-9]+, [$]17",-"LSR" + return uint64(x >> 15) // arm64:"UBFX [$]15, R[0-9]+, [$]17" -"LSR" } func ubfx3(x uint16) uint64 { - return uint64(x >> 9) // arm64:"UBFX\t[$]9, R[0-9]+, [$]7",-"LSR" + return uint64(x >> 9) // arm64:"UBFX [$]9, R[0-9]+, [$]7" -"LSR" } func ubfx4(x uint8) uint64 { - return uint64(x >> 3) // arm64:"UBFX\t[$]3, R[0-9]+, [$]5",-"LSR" + return uint64(x >> 3) // arm64:"UBFX [$]3, R[0-9]+, [$]5" -"LSR" } func ubfx5(x uint32) uint64 { - return uint64(x) >> 30 // arm64:"UBFX\t[$]30, R[0-9]+, [$]2" + return uint64(x) >> 30 // arm64:"UBFX [$]30, R[0-9]+, [$]2" } func ubfx6(x uint16) uint64 { - return uint64(x) >> 10 // arm64:"UBFX\t[$]10, R[0-9]+, [$]6" + return uint64(x) >> 10 // arm64:"UBFX [$]10, R[0-9]+, [$]6" } func ubfx7(x uint8) uint64 { - return uint64(x) >> 3 // arm64:"UBFX\t[$]3, R[0-9]+, [$]5" + return uint64(x) >> 3 // arm64:"UBFX [$]3, R[0-9]+, [$]5" } // merge ANDconst into ubfx. func ubfx8(x uint64) uint64 { - // arm64:"UBFX\t[$]25, R[0-9]+, [$]10",-"LSR",-"AND" - // s390x:"RISBGZ\t[$]54, [$]63, [$]39, ",-"SRD",-"AND" + // arm64:"UBFX [$]25, R[0-9]+, [$]10" -"LSR" -"AND" + // s390x:"RISBGZ [$]54, [$]63, [$]39, " -"SRD" -"AND" return (x >> 25) & 1023 } func ubfx9(x uint64) uint64 { - // arm64:"UBFX\t[$]4, R[0-9]+, [$]8",-"LSR",-"AND" - // s390x:"RISBGZ\t[$]56, [$]63, [$]60, ",-"SRD",-"AND" + // arm64:"UBFX [$]4, R[0-9]+, [$]8" -"LSR" -"AND" + // s390x:"RISBGZ [$]56, [$]63, [$]60, " -"SRD" -"AND" return (x & 0x0ff0) >> 4 } // ubfx combinations. func ubfx10(x uint32) uint32 { - // arm64:"UBFX\t[$]1, R[0-9]+, [$]30",-"LSL",-"LSR" + // arm64:"UBFX [$]1, R[0-9]+, [$]30" -"LSL" -"LSR" return (x << 1) >> 2 } func ubfx11(x uint64) uint64 { - // arm64:"UBFX\t[$]1, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND" - // s390x:"RISBGZ\t[$]52, [$]63, [$]63,",-"SLD",-"SRD",-"AND" + // arm64:"UBFX [$]1, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND" + // s390x:"RISBGZ [$]52, [$]63, [$]63," -"SLD" -"SRD" -"AND" return ((x << 1) >> 2) & 0xfff } func ubfx12(x uint64) uint64 { - // arm64:"UBFX\t[$]4, R[0-9]+, [$]11",-"LSL",-"LSR",-"AND" - // s390x:"RISBGZ\t[$]53, [$]63, [$]60, ",-"SLD",-"SRD",-"AND" + // arm64:"UBFX [$]4, R[0-9]+, [$]11" -"LSL" -"LSR" -"AND" + // s390x:"RISBGZ [$]53, [$]63, [$]60, " -"SLD" -"SRD" -"AND" return ((x >> 3) & 0xfff) >> 1 } func ubfx13(x uint64) uint64 { - // arm64:"UBFX\t[$]5, R[0-9]+, [$]56",-"LSL",-"LSR" - // s390x:"RISBGZ\t[$]8, [$]63, [$]59, ",-"SLD",-"SRD" + // arm64:"UBFX [$]5, R[0-9]+, [$]56" -"LSL" -"LSR" + // s390x:"RISBGZ [$]8, [$]63, [$]59, " -"SLD" -"SRD" return ((x >> 2) << 5) >> 8 } func ubfx14(x uint64) uint64 { - // arm64:"UBFX\t[$]1, R[0-9]+, [$]19",-"LSL",-"LSR" - // s390x:"RISBGZ\t[$]45, [$]63, [$]63, ",-"SLD",-"SRD",-"AND" + // arm64:"UBFX [$]1, R[0-9]+, [$]19" -"LSL" -"LSR" + // s390x:"RISBGZ [$]45, [$]63, [$]63, " -"SLD" -"SRD" -"AND" return ((x & 0xfffff) << 3) >> 4 } @@ -315,7 +315,7 @@ func ubfx14(x uint64) uint64 { func ubfx15(x uint64) bool { midr := x + 10 part_num := uint16((midr >> 4) & 0xfff) - if part_num == 0xd0c { // arm64:"UBFX\t[$]4, R[0-9]+, [$]12",-"MOVHU\tR[0-9]+, R[0-9]+" + if part_num == 0xd0c { // arm64:"UBFX [$]4, R[0-9]+, [$]12" -"MOVHU R[0-9]+, R[0-9]+" return true } return false @@ -323,7 +323,7 @@ func ubfx15(x uint64) bool { // merge ANDconst and ubfx into ubfx func ubfx16(x uint64) uint64 { - // arm64:"UBFX\t[$]4, R[0-9]+, [$]6",-"AND\t[$]63" + // arm64:"UBFX [$]4, R[0-9]+, [$]6" -"AND [$]63" return ((x >> 3) & 0xfff) >> 1 & 0x3f } @@ -331,48 +331,48 @@ func ubfx16(x uint64) uint64 { // //go:nosplit func shift_no_cmp(x int) int { - // arm64:`LSL\t[$]17`,-`CMP` - // mips64:`SLLV\t[$]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\tR[0-9]+<<8` + // 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\tR[0-9]+<<8` + // arm64:-`ADD R[0-9]+<<8` // loong64:-`ADDV` b2 := ((c & 0xff00ff00ff00ff00) >> 8) + ((c & 0x00ff00ff00ff00ff) << 8) - // arm64:-`EOR\tR[0-9]+<<8` + // arm64:-`EOR R[0-9]+<<8` // loong64:-`XOR` b3 := ((c & 0xff00ff00ff00ff00) >> 8) ^ ((c & 0x00ff00ff00ff00ff) << 8) return b1, b2, b3 } func rev16w(c uint32) (uint32, uint32, uint32) { - // arm64:`REV16W`,-`AND`,-`UBFX`,-`AND`,-`ORR\tR[0-9]+<<8` + // 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\tR[0-9]+<<8` + // arm64:-`ADD R[0-9]+<<8` // loong64:-`ADDV` b2 := ((c & 0xff00ff00) >> 8) + ((c & 0x00ff00ff) << 8) - // arm64:-`EOR\tR[0-9]+<<8` + // arm64:-`EOR R[0-9]+<<8` // loong64:-`XOR` b3 := ((c & 0xff00ff00) >> 8) ^ ((c & 0x00ff00ff) << 8) return b1, b2, b3 } func shift(x uint32, y uint16, z uint8) uint64 { - // arm64:-`MOVWU`,-`LSR\t[$]32` - // loong64:-`MOVWU`,-`SRLV\t[$]32` + // arm64:-`MOVWU`,-`LSR [$]32` + // loong64:-`MOVWU`,-`SRLV [$]32` a := uint64(x) >> 32 // arm64:-`MOVHU - // loong64:-`MOVHU`,-`SRLV\t[$]16` + // loong64:-`MOVHU`,-`SRLV [$]16` b := uint64(y) >> 16 // arm64:-`MOVBU` - // loong64:-`MOVBU`,-`SRLV\t[$]8` + // loong64:-`MOVBU`,-`SRLV [$]8` c := uint64(z) >> 8 - // arm64:`MOVD\tZR`,-`ADD\tR[0-9]+>>16`,-`ADD\tR[0-9]+>>8`, - // loong64:`MOVV\tR0`,-`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 7974f471fc..39969dcdb2 100644 --- a/test/codegen/bits.go +++ b/test/codegen/bits.go @@ -13,15 +13,15 @@ import "math/bits" ************************************/ func bitcheck64_constleft(a uint64) (n int) { - // amd64:"BTQ\t[$]63" + // amd64:"BTQ [$]63" if a&(1<<63) != 0 { return 1 } - // amd64:"BTQ\t[$]60" + // amd64:"BTQ [$]60" if a&(1<<60) != 0 { return 1 } - // amd64:"BTL\t[$]0" + // amd64:"BTL [$]0" if a&(1<<0) != 0 { return 1 } @@ -29,31 +29,31 @@ func bitcheck64_constleft(a uint64) (n int) { } func bitcheck64_constright(a [8]uint64) (n int) { - // amd64:"BTQ\t[$]63" + // amd64:"BTQ [$]63" if (a[0]>>63)&1 != 0 { return 1 } - // amd64:"BTQ\t[$]63" + // amd64:"BTQ [$]63" if a[1]>>63 != 0 { return 1 } - // amd64:"BTQ\t[$]63" + // amd64:"BTQ [$]63" if a[2]>>63 == 0 { return 1 } - // amd64:"BTQ\t[$]60" + // amd64:"BTQ [$]60" if (a[3]>>60)&1 == 0 { return 1 } - // amd64:"BTL\t[$]1" + // amd64:"BTL [$]1" if (a[4]>>1)&1 == 0 { return 1 } - // amd64:"BTL\t[$]0" + // amd64:"BTL [$]0" if (a[5]>>0)&1 == 0 { return 1 } - // amd64:"BTL\t[$]7" + // amd64:"BTL [$]7" if (a[6]>>5)&4 == 0 { return 1 } @@ -65,7 +65,7 @@ func bitcheck64_var(a, b uint64) (n int) { if a&(1<<(b&63)) != 0 { return 1 } - // amd64:"BTQ",-"BT.\t[$]0" + // amd64:"BTQ" -"BT. [$]0" if (b>>(a&63))&1 != 0 { return 1 } @@ -73,15 +73,15 @@ func bitcheck64_var(a, b uint64) (n int) { } func bitcheck64_mask(a uint64) (n int) { - // amd64:"BTQ\t[$]63" + // amd64:"BTQ [$]63" if a&0x8000000000000000 != 0 { return 1 } - // amd64:"BTQ\t[$]59" + // amd64:"BTQ [$]59" if a&0x800000000000000 != 0 { return 1 } - // amd64:"BTL\t[$]0" + // amd64:"BTL [$]0" if a&0x1 != 0 { return 1 } @@ -92,13 +92,13 @@ func biton64(a, b uint64) (n uint64) { // amd64:"BTSQ" n += b | (1 << (a & 63)) - // amd64:"BTSQ\t[$]63" + // amd64:"BTSQ [$]63" n += a | (1 << 63) - // amd64:"BTSQ\t[$]60" + // amd64:"BTSQ [$]60" n += a | (1 << 60) - // amd64:"ORQ\t[$]1" + // amd64:"ORQ [$]1" n += a | (1 << 0) return n @@ -108,23 +108,23 @@ func bitoff64(a, b uint64) (n uint64) { // amd64:"BTRQ" n += b &^ (1 << (a & 63)) - // amd64:"BTRQ\t[$]63" + // amd64:"BTRQ [$]63" n += a &^ (1 << 63) - // amd64:"BTRQ\t[$]60" + // amd64:"BTRQ [$]60" n += a &^ (1 << 60) - // amd64:"ANDQ\t[$]-2" + // amd64:"ANDQ [$]-2" n += a &^ (1 << 0) return n } func clearLastBit(x int64, y int32) (int64, int32) { - // amd64:"ANDQ\t[$]-2" + // amd64:"ANDQ [$]-2" a := (x >> 1) << 1 - // amd64:"ANDL\t[$]-2" + // amd64:"ANDL [$]-2" b := (y >> 1) << 1 return a, b @@ -134,13 +134,13 @@ func bitcompl64(a, b uint64) (n uint64) { // amd64:"BTCQ" n += b ^ (1 << (a & 63)) - // amd64:"BTCQ\t[$]63" + // amd64:"BTCQ [$]63" n += a ^ (1 << 63) - // amd64:"BTCQ\t[$]60" + // amd64:"BTCQ [$]60" n += a ^ (1 << 60) - // amd64:"XORQ\t[$]1" + // amd64:"XORQ [$]1" n += a ^ (1 << 0) return n @@ -151,15 +151,15 @@ func bitcompl64(a, b uint64) (n uint64) { ************************************/ func bitcheck32_constleft(a uint32) (n int) { - // amd64:"BTL\t[$]31" + // amd64:"BTL [$]31" if a&(1<<31) != 0 { return 1 } - // amd64:"BTL\t[$]28" + // amd64:"BTL [$]28" if a&(1<<28) != 0 { return 1 } - // amd64:"BTL\t[$]0" + // amd64:"BTL [$]0" if a&(1<<0) != 0 { return 1 } @@ -167,31 +167,31 @@ func bitcheck32_constleft(a uint32) (n int) { } func bitcheck32_constright(a [8]uint32) (n int) { - // amd64:"BTL\t[$]31" + // amd64:"BTL [$]31" if (a[0]>>31)&1 != 0 { return 1 } - // amd64:"BTL\t[$]31" + // amd64:"BTL [$]31" if a[1]>>31 != 0 { return 1 } - // amd64:"BTL\t[$]31" + // amd64:"BTL [$]31" if a[2]>>31 == 0 { return 1 } - // amd64:"BTL\t[$]28" + // amd64:"BTL [$]28" if (a[3]>>28)&1 == 0 { return 1 } - // amd64:"BTL\t[$]1" + // amd64:"BTL [$]1" if (a[4]>>1)&1 == 0 { return 1 } - // amd64:"BTL\t[$]0" + // amd64:"BTL [$]0" if (a[5]>>0)&1 == 0 { return 1 } - // amd64:"BTL\t[$]7" + // amd64:"BTL [$]7" if (a[6]>>5)&4 == 0 { return 1 } @@ -203,7 +203,7 @@ func bitcheck32_var(a, b uint32) (n int) { if a&(1<<(b&31)) != 0 { return 1 } - // amd64:"BTL",-"BT.\t[$]0" + // amd64:"BTL" -"BT. [$]0" if (b>>(a&31))&1 != 0 { return 1 } @@ -211,15 +211,15 @@ func bitcheck32_var(a, b uint32) (n int) { } func bitcheck32_mask(a uint32) (n int) { - // amd64:"BTL\t[$]31" + // amd64:"BTL [$]31" if a&0x80000000 != 0 { return 1 } - // amd64:"BTL\t[$]27" + // amd64:"BTL [$]27" if a&0x8000000 != 0 { return 1 } - // amd64:"BTL\t[$]0" + // amd64:"BTL [$]0" if a&0x1 != 0 { return 1 } @@ -230,13 +230,13 @@ func biton32(a, b uint32) (n uint32) { // amd64:"BTSL" n += b | (1 << (a & 31)) - // amd64:"ORL\t[$]-2147483648" + // amd64:"ORL [$]-2147483648" n += a | (1 << 31) - // amd64:"ORL\t[$]268435456" + // amd64:"ORL [$]268435456" n += a | (1 << 28) - // amd64:"ORL\t[$]1" + // amd64:"ORL [$]1" n += a | (1 << 0) return n @@ -246,13 +246,13 @@ func bitoff32(a, b uint32) (n uint32) { // amd64:"BTRL" n += b &^ (1 << (a & 31)) - // amd64:"ANDL\t[$]2147483647" + // amd64:"ANDL [$]2147483647" n += a &^ (1 << 31) - // amd64:"ANDL\t[$]-268435457" + // amd64:"ANDL [$]-268435457" n += a &^ (1 << 28) - // amd64:"ANDL\t[$]-2" + // amd64:"ANDL [$]-2" n += a &^ (1 << 0) return n @@ -262,13 +262,13 @@ func bitcompl32(a, b uint32) (n uint32) { // amd64:"BTCL" n += b ^ (1 << (a & 31)) - // amd64:"XORL\t[$]-2147483648" + // amd64:"XORL [$]-2147483648" n += a ^ (1 << 31) - // amd64:"XORL\t[$]268435456" + // amd64:"XORL [$]268435456" n += a ^ (1 << 28) - // amd64:"XORL\t[$]1" + // amd64:"XORL [$]1" n += a ^ (1 << 0) return n @@ -292,12 +292,12 @@ func bitcheckMostNegative(b uint8) bool { // Check AND masking on arm64 (Issue #19857) func and_mask_1(a uint64) uint64 { - // arm64:`AND\t` + // arm64:`AND ` return a & ((1 << 63) - 1) } func and_mask_2(a uint64) uint64 { - // arm64:`AND\t` + // arm64:`AND ` return a & (1 << 63) } @@ -312,65 +312,65 @@ func and_mask_3(a, b uint32) (uint32, uint32) { // Check generation of arm64 BIC/EON/ORN instructions func op_bic(x, y uint32) uint32 { - // arm64:`BIC\t`,-`AND` + // arm64:`BIC `,-`AND` return x &^ y } func op_eon(x, y, z uint32, a []uint32, n, m uint64) uint64 { - // arm64:`EON\t`,-`EOR`,-`MVN` + // arm64:`EON `,-`EOR`,-`MVN` a[0] = x ^ (y ^ 0xffffffff) - // arm64:`EON\t`,-`EOR`,-`MVN` + // arm64:`EON `,-`EOR`,-`MVN` a[1] = ^(y ^ z) - // arm64:`EON\t`,-`XOR` + // arm64:`EON `,-`XOR` a[2] = x ^ ^z - // arm64:`EON\t`,-`EOR`,-`MVN` + // arm64:`EON `,-`EOR`,-`MVN` return n ^ (m ^ 0xffffffffffffffff) } func op_orn(x, y uint32) uint32 { - // arm64:`ORN\t`,-`ORR` - // loong64:"ORN"\t,-"OR\t" + // arm64:`ORN `,-`ORR` + // loong64:"ORN" ,-"OR " return x | ^y } func op_nor(x int64, a []int64) { - // loong64: "MOVV\t[$]0","NOR\tR" + // loong64: "MOVV [$]0" "NOR R" a[0] = ^(0x1234 | x) - // loong64:"NOR",-"XOR" + // loong64:"NOR" -"XOR" a[1] = (-1) ^ x - // loong64: "MOVV\t[$]-55",-"OR",-"NOR" + // loong64: "MOVV [$]-55" -"OR" -"NOR" a[2] = ^(0x12 | 0x34) } func op_andn(x, y uint32) uint32 { - // loong64:"ANDN\t",-"AND\t" + // loong64:"ANDN " -"AND " return x &^ y } // check bitsets func bitSetPowerOf2Test(x int) bool { - // amd64:"BTL\t[$]3" + // amd64:"BTL [$]3" return x&8 == 8 } func bitSetTest(x int) bool { - // amd64:"ANDL\t[$]9, AX" - // amd64:"CMPQ\tAX, [$]9" + // amd64:"ANDL [$]9, AX" + // amd64:"CMPQ AX, [$]9" return x&9 == 9 } // mask contiguous one bits func cont1Mask64U(x uint64) uint64 { - // s390x:"RISBGZ\t[$]16, [$]47, [$]0," + // s390x:"RISBGZ [$]16, [$]47, [$]0," return x & 0x0000ffffffff0000 } // mask contiguous zero bits func cont0Mask64U(x uint64) uint64 { - // s390x:"RISBGZ\t[$]48, [$]15, [$]0," + // s390x:"RISBGZ [$]48, [$]15, [$]0," return x & 0xffff00000000ffff } @@ -390,60 +390,60 @@ func issue48467(x, y uint64) uint64 { } func foldConst(x, y uint64) uint64 { - // arm64: "ADDS\t[$]7",-"MOVD\t[$]7" - // ppc64x: "ADDC\t[$]7," + // arm64: "ADDS [$]7" -"MOVD [$]7" + // ppc64x: "ADDC [$]7," d, b := bits.Add64(x, 7, 0) return b & d } func foldConstOutOfRange(a uint64) uint64 { - // arm64: "MOVD\t[$]19088744",-"ADD\t[$]19088744" + // arm64: "MOVD [$]19088744" -"ADD [$]19088744" return a + 0x1234568 } // Verify sign-extended values are not zero-extended under a bit mask (#61297) func signextendAndMask8to64(a int8) (s, z uint64) { - // ppc64x: "MOVB", "ANDCC\t[$]1015," + // ppc64x: "MOVB", "ANDCC [$]1015," s = uint64(a) & 0x3F7 - // ppc64x: -"MOVB", "ANDCC\t[$]247," + // ppc64x: -"MOVB", "ANDCC [$]247," z = uint64(uint8(a)) & 0x3F7 return } // Verify zero-extended values are not sign-extended under a bit mask (#61297) func zeroextendAndMask8to64(a int8, b int16) (x, y uint64) { - // ppc64x: -"MOVB\t", -"ANDCC", "MOVBZ" + // ppc64x: -"MOVB ", -"ANDCC", "MOVBZ" x = uint64(a) & 0xFF - // ppc64x: -"MOVH\t", -"ANDCC", "MOVHZ" + // ppc64x: -"MOVH ", -"ANDCC", "MOVHZ" y = uint64(b) & 0xFFFF return } // Verify rotate and mask instructions, and further simplified instructions for small types func bitRotateAndMask(io64 [8]uint64, io32 [4]uint32, io16 [4]uint16, io8 [4]uint8) { - // ppc64x: "RLDICR\t[$]0, R[0-9]*, [$]47, R" + // ppc64x: "RLDICR [$]0, R[0-9]*, [$]47, R" io64[0] = io64[0] & 0xFFFFFFFFFFFF0000 - // ppc64x: "RLDICL\t[$]0, R[0-9]*, [$]16, R" + // ppc64x: "RLDICL [$]0, R[0-9]*, [$]16, R" io64[1] = io64[1] & 0x0000FFFFFFFFFFFF - // ppc64x: -"SRD", -"AND", "RLDICL\t[$]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\t[$]36, R[0-9]*, [$]28, R" + // ppc64x: -"SRD", -"AND", "RLDICL [$]36, R[0-9]*, [$]28, R" io64[3] = (io64[3] >> 28) & 0x0000FFFFFFFFFFFF - // ppc64x: "MOVWZ", "RLWNM\t[$]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\t[$]0, R[0-9]*, [$]4, [$]19, R" + // ppc64x: "RLWNM [$]0, R[0-9]*, [$]4, [$]19, R" io32[0] = io32[0] & 0x0FFFF000 - // ppc64x: "RLWNM\t[$]0, R[0-9]*, [$]20, [$]3, R" + // ppc64x: "RLWNM [$]0, R[0-9]*, [$]20, [$]3, R" io32[1] = io32[1] & 0xF0000FFF // ppc64x: -"RLWNM", MOVD, AND io32[2] = io32[2] & 0xFFFF0002 var bigc uint32 = 0x12345678 - // ppc64x: "ANDCC\t[$]22136" + // ppc64x: "ANDCC [$]22136" io16[0] = io16[0] & uint16(bigc) - // ppc64x: "ANDCC\t[$]120" + // ppc64x: "ANDCC [$]120" io8[0] = io8[0] & uint8(bigc) } diff --git a/test/codegen/bmi.go b/test/codegen/bmi.go index aa61b03928..c50f15a7e0 100644 --- a/test/codegen/bmi.go +++ b/test/codegen/bmi.go @@ -47,41 +47,41 @@ func blsr32(x int32) int32 { } func isPowerOfTwo64(x int64) bool { - // amd64/v3:"BLSRQ",-"TESTQ",-"CALL" + // amd64/v3:"BLSRQ" -"TESTQ" -"CALL" return blsr64(x) == 0 } func isPowerOfTwo32(x int32) bool { - // amd64/v3:"BLSRL",-"TESTL",-"CALL" + // amd64/v3:"BLSRL" -"TESTL" -"CALL" return blsr32(x) == 0 } func isPowerOfTwoSelect64(x, a, b int64) int64 { var r int64 - // amd64/v3:"BLSRQ",-"TESTQ",-"CALL" + // amd64/v3:"BLSRQ" -"TESTQ" -"CALL" if isPowerOfTwo64(x) { r = a } else { r = b } - // amd64/v3:"CMOVQEQ",-"TESTQ",-"CALL" + // amd64/v3:"CMOVQEQ" -"TESTQ" -"CALL" return r * 2 // force return blocks joining } func isPowerOfTwoSelect32(x, a, b int32) int32 { var r int32 - // amd64/v3:"BLSRL",-"TESTL",-"CALL" + // amd64/v3:"BLSRL" -"TESTL" -"CALL" if isPowerOfTwo32(x) { r = a } else { r = b } - // amd64/v3:"CMOVLEQ",-"TESTL",-"CALL" + // amd64/v3:"CMOVLEQ" -"TESTL" -"CALL" return r * 2 // force return blocks joining } func isPowerOfTwoBranch64(x int64, a func(bool), b func(string)) { - // amd64/v3:"BLSRQ",-"TESTQ",-"CALL" + // amd64/v3:"BLSRQ" -"TESTQ" -"CALL" if isPowerOfTwo64(x) { a(true) } else { @@ -90,7 +90,7 @@ func isPowerOfTwoBranch64(x int64, a func(bool), b func(string)) { } func isPowerOfTwoBranch32(x int32, a func(bool), b func(string)) { - // amd64/v3:"BLSRL",-"TESTL",-"CALL" + // amd64/v3:"BLSRL" -"TESTL" -"CALL" if isPowerOfTwo32(x) { a(true) } else { @@ -99,41 +99,41 @@ func isPowerOfTwoBranch32(x int32, a func(bool), b func(string)) { } func isNotPowerOfTwo64(x int64) bool { - // amd64/v3:"BLSRQ",-"TESTQ",-"CALL" + // amd64/v3:"BLSRQ" -"TESTQ" -"CALL" return blsr64(x) != 0 } func isNotPowerOfTwo32(x int32) bool { - // amd64/v3:"BLSRL",-"TESTL",-"CALL" + // amd64/v3:"BLSRL" -"TESTL" -"CALL" return blsr32(x) != 0 } func isNotPowerOfTwoSelect64(x, a, b int64) int64 { var r int64 - // amd64/v3:"BLSRQ",-"TESTQ",-"CALL" + // amd64/v3:"BLSRQ" -"TESTQ" -"CALL" if isNotPowerOfTwo64(x) { r = a } else { r = b } - // amd64/v3:"CMOVQNE",-"TESTQ",-"CALL" + // amd64/v3:"CMOVQNE" -"TESTQ" -"CALL" return r * 2 // force return blocks joining } func isNotPowerOfTwoSelect32(x, a, b int32) int32 { var r int32 - // amd64/v3:"BLSRL",-"TESTL",-"CALL" + // amd64/v3:"BLSRL" -"TESTL" -"CALL" if isNotPowerOfTwo32(x) { r = a } else { r = b } - // amd64/v3:"CMOVLNE",-"TESTL",-"CALL" + // amd64/v3:"CMOVLNE" -"TESTL" -"CALL" return r * 2 // force return blocks joining } func isNotPowerOfTwoBranch64(x int64, a func(bool), b func(string)) { - // amd64/v3:"BLSRQ",-"TESTQ",-"CALL" + // amd64/v3:"BLSRQ" -"TESTQ" -"CALL" if isNotPowerOfTwo64(x) { a(true) } else { @@ -142,7 +142,7 @@ func isNotPowerOfTwoBranch64(x int64, a func(bool), b func(string)) { } func isNotPowerOfTwoBranch32(x int32, a func(bool), b func(string)) { - // amd64/v3:"BLSRL",-"TESTL",-"CALL" + // amd64/v3:"BLSRL" -"TESTL" -"CALL" if isNotPowerOfTwo32(x) { a(true) } else { @@ -161,17 +161,17 @@ func sarx32(x, y int32) int32 { } func sarx64_load(x []int64, i int) int64 { - // amd64/v3: `SARXQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64/v3: `SARXQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s := x[i] >> (i & 63) - // amd64/v3: `SARXQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64/v3: `SARXQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s = x[i+1] >> (s & 63) return s } func sarx32_load(x []int32, i int) int32 { - // amd64/v3: `SARXL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // amd64/v3: `SARXL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s := x[i] >> (i & 63) - // amd64/v3: `SARXL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // amd64/v3: `SARXL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s = x[i+1] >> (s & 63) return s } @@ -193,17 +193,17 @@ func shlrx32(x, y uint32) uint32 { } func shlrx64_load(x []uint64, i int, s uint64) uint64 { - // amd64/v3: `SHRXQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64/v3: `SHRXQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s = x[i] >> i - // amd64/v3: `SHLXQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64/v3: `SHLXQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s = x[i+1] << s return s } func shlrx32_load(x []uint32, i int, s uint32) uint32 { - // amd64/v3: `SHRXL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // amd64/v3: `SHRXL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s = x[i] >> i - // amd64/v3: `SHLXL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // amd64/v3: `SHLXL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s = x[i+1] << s return s } diff --git a/test/codegen/bool.go b/test/codegen/bool.go index 760dbbcf7b..37f85a45b7 100644 --- a/test/codegen/bool.go +++ b/test/codegen/bool.go @@ -13,52 +13,52 @@ import ( // This file contains codegen tests related to boolean simplifications/optimizations. func convertNeq0B(x uint8, c bool) bool { - // amd64:"ANDL\t[$]1",-"SETNE" - // ppc64x:"RLDICL",-"CMPW",-"ISEL" + // amd64:"ANDL [$]1" -"SETNE" + // ppc64x:"RLDICL" -"CMPW" -"ISEL" b := x&1 != 0 return c && b } func convertNeq0W(x uint16, c bool) bool { - // amd64:"ANDL\t[$]1",-"SETNE" - // ppc64x:"RLDICL",-"CMPW",-"ISEL" + // amd64:"ANDL [$]1" -"SETNE" + // ppc64x:"RLDICL" -"CMPW" -"ISEL" b := x&1 != 0 return c && b } func convertNeq0L(x uint32, c bool) bool { - // amd64:"ANDL\t[$]1",-"SETB" - // ppc64x:"RLDICL",-"CMPW",-"ISEL" + // amd64:"ANDL [$]1" -"SETB" + // ppc64x:"RLDICL" -"CMPW" -"ISEL" b := x&1 != 0 return c && b } func convertNeq0Q(x uint64, c bool) bool { - // amd64:"ANDL\t[$]1",-"SETB" - // ppc64x:"RLDICL",-"CMP",-"ISEL" + // amd64:"ANDL [$]1" -"SETB" + // ppc64x:"RLDICL" -"CMP" -"ISEL" b := x&1 != 0 return c && b } func convertNeqBool32(x uint32) bool { - // ppc64x:"RLDICL",-"CMPW",-"ISEL" + // ppc64x:"RLDICL" -"CMPW" -"ISEL" return x&1 != 0 } func convertEqBool32(x uint32) bool { - // ppc64x:"RLDICL",-"CMPW","XOR",-"ISEL" - // amd64:"ANDL","XORL",-"BTL",-"SETCC" + // ppc64x:"RLDICL" -"CMPW" "XOR" -"ISEL" + // amd64:"ANDL" "XORL" -"BTL" -"SETCC" return x&1 == 0 } func convertNeqBool64(x uint64) bool { - // ppc64x:"RLDICL",-"CMP",-"ISEL" + // ppc64x:"RLDICL" -"CMP" -"ISEL" return x&1 != 0 } func convertEqBool64(x uint64) bool { - // ppc64x:"RLDICL","XOR",-"CMP",-"ISEL" - // amd64:"ANDL","XORL",-"BTL",-"SETCC" + // ppc64x:"RLDICL" "XOR" -"CMP" -"ISEL" + // amd64:"ANDL" "XORL" -"BTL" -"SETCC" return x&1 == 0 } @@ -87,157 +87,157 @@ func phiOr(a, b bool) bool { } func TestSetEq64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBC\tCR0EQ",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0EQ" - // ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0EQ" + // ppc64x/power10:"SETBC CR0EQ" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBC CR0EQ" + // ppc64x/power8:"CMP" "ISEL" -"SETBC CR0EQ" b := x == y return b } func TestSetNeq64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0EQ" - // ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0EQ" + // ppc64x/power10:"SETBCR CR0EQ" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0EQ" + // ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0EQ" b := x != y return b } func TestSetLt64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBC\tCR0GT",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0GT" - // ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0GT" + // ppc64x/power10:"SETBC CR0GT" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBC CR0GT" + // ppc64x/power8:"CMP" "ISEL" -"SETBC CR0GT" b := x < y return b } func TestSetLe64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBCR\tCR0LT",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0LT" - // ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0LT" + // ppc64x/power10:"SETBCR CR0LT" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0LT" + // ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0LT" b := x <= y return b } func TestSetGt64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBC\tCR0LT",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0LT" - // ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0LT" + // ppc64x/power10:"SETBC CR0LT" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBC CR0LT" + // ppc64x/power8:"CMP" "ISEL" -"SETBC CR0LT" b := x > y return b } func TestSetGe64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBCR\tCR0GT",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0GT" - // ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0GT" + // ppc64x/power10:"SETBCR CR0GT" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0GT" + // ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0GT" b := x >= y return b } func TestSetLtFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBC\tCR0LT",-"ISEL" - // ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT" - // ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT" + // ppc64x/power10:"SETBC CR0LT" -"ISEL" + // ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT" + // ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT" b := x < y return b } func TestSetLeFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBC\tCR0LT","SETBC\tCR0EQ","OR",-"ISEL",-"ISEL" - // ppc64x/power9:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR" - // ppc64x/power8:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR" + // ppc64x/power10:"SETBC CR0LT" "SETBC CR0EQ" "OR" -"ISEL" -"ISEL" + // ppc64x/power9:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR" + // ppc64x/power8:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR" b := x <= y return b } func TestSetGtFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBC\tCR0LT",-"ISEL" - // ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT" - // ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT" + // ppc64x/power10:"SETBC CR0LT" -"ISEL" + // ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT" + // ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT" b := x > y return b } func TestSetGeFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBC\tCR0LT","SETBC\tCR0EQ","OR",-"ISEL",-"ISEL" - // ppc64x/power9:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR" - // ppc64x/power8:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR" + // ppc64x/power10:"SETBC CR0LT" "SETBC CR0EQ" "OR" -"ISEL" -"ISEL" + // ppc64x/power9:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR" + // ppc64x/power8:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR" b := x >= y return b } func TestSetInvEq64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0EQ" - // ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0EQ" + // ppc64x/power10:"SETBCR CR0EQ" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0EQ" + // ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0EQ" b := !(x == y) return b } func TestSetInvNeq64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBC\tCR0EQ",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0EQ" - // ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0EQ" + // ppc64x/power10:"SETBC CR0EQ" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBC CR0EQ" + // ppc64x/power8:"CMP" "ISEL" -"SETBC CR0EQ" b := !(x != y) return b } func TestSetInvLt64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBCR\tCR0GT",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0GT" - // ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0GT" + // ppc64x/power10:"SETBCR CR0GT" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0GT" + // ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0GT" b := !(x < y) return b } func TestSetInvLe64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBC\tCR0LT",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0LT" - // ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0LT" + // ppc64x/power10:"SETBC CR0LT" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBC CR0LT" + // ppc64x/power8:"CMP" "ISEL" -"SETBC CR0LT" b := !(x <= y) return b } func TestSetInvGt64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBCR\tCR0LT",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0LT" - // ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0LT" + // ppc64x/power10:"SETBCR CR0LT" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0LT" + // ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0LT" b := !(x > y) return b } func TestSetInvGe64(x uint64, y uint64) bool { - // ppc64x/power10:"SETBC\tCR0GT",-"ISEL" - // ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0GT" - // ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0GT" + // ppc64x/power10:"SETBC CR0GT" -"ISEL" + // ppc64x/power9:"CMP" "ISEL" -"SETBC CR0GT" + // ppc64x/power8:"CMP" "ISEL" -"SETBC CR0GT" b := !(x >= y) return b } func TestSetInvEqFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL" - // ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0EQ" - // ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0EQ" + // ppc64x/power10:"SETBCR CR0EQ" -"ISEL" + // ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0EQ" + // ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0EQ" b := !(x == y) return b } func TestSetInvNeqFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBC\tCR0EQ",-"ISEL" - // ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0EQ" - // ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0EQ" + // ppc64x/power10:"SETBC CR0EQ" -"ISEL" + // ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0EQ" + // ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0EQ" b := !(x != y) return b } func TestSetInvLtFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBCR\tCR0LT",-"ISEL" - // ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0LT" - // ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0LT" + // ppc64x/power10:"SETBCR CR0LT" -"ISEL" + // ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0LT" + // ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0LT" b := !(x < y) return b } func TestSetInvLeFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBC\tCR0LT",-"ISEL" - // ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT" - // ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT" + // ppc64x/power10:"SETBC CR0LT" -"ISEL" + // ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT" + // ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT" b := !(x <= y) return b } func TestSetInvGtFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBCR\tCR0LT",-"ISEL" - // ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0LT" - // ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0LT" + // ppc64x/power10:"SETBCR CR0LT" -"ISEL" + // ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0LT" + // ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0LT" b := !(x > y) return b } func TestSetInvGeFp64(x float64, y float64) bool { - // ppc64x/power10:"SETBC\tCR0LT",-"ISEL" - // ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT" - // ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT" + // ppc64x/power10:"SETBC CR0LT" -"ISEL" + // ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT" + // ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT" b := !(x >= y) return b } @@ -293,7 +293,7 @@ func TestLogicalCompareZero(x *[64]uint64) { x[12] = b } - // ppc64x:"ADDCCC\t[$]4," + // ppc64x:"ADDCCC [$]4," c := int64(x[12]) + 4 if c <= 0 { x[12] = uint64(c) @@ -309,7 +309,7 @@ func TestLogicalCompareZero(x *[64]uint64) { func constantWrite(b bool, p *bool) { if b { - // amd64:`MOVB\t[$]1, \(` + // amd64:`MOVB [$]1, \(` *p = b } } diff --git a/test/codegen/clobberdead.go b/test/codegen/clobberdead.go index 13d2efbbe5..df44705cfc 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\t\$3735936685, command-line-arguments\.x`, `MOVL\t\$3735936685, command-line-arguments\.y`, -`MOVL\t\$3735936685, command-line-arguments\.z` - // arm64:`MOVW\tR27, command-line-arguments\.x`, `MOVW\tR27, command-line-arguments\.y`, -`MOVW\tR27, 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\t\$3735936685, command-line-arguments\.x`, -`MOVL\t\$3735936685, command-line-arguments\.y` - // arm64:`MOVW\tR27, command-line-arguments\.x`, -`MOVW\tR27, 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\t\$3735936685, command-line-arguments\.x`, `MOVL\t\$3735936685, command-line-arguments\.y` - // arm64:`MOVW\tR27, command-line-arguments\.x`, `MOVW\tR27, 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 39c4a743cb..24043438b2 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\t\$-2401018187971961171, AX`, `MOVQ\t\$-2401018187971961171, BX`, `MOVQ\t\$-2401018187971961171, CX` - // amd64:`MOVQ\t\$-2401018187971961171, DX`, `MOVQ\t\$-2401018187971961171, SI`, `MOVQ\t\$-2401018187971961171, DI` - // amd64:`MOVQ\t\$-2401018187971961171, R8`, `MOVQ\t\$-2401018187971961171, R9`, `MOVQ\t\$-2401018187971961171, R10` - // amd64:`MOVQ\t\$-2401018187971961171, R11`, `MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13` - // amd64:-`MOVQ\t\$-2401018187971961171, BP` // frame pointer is not clobbered + // 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\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`, `MOVQ\t\$-2401018187971961171, DX` - // amd64:-`MOVQ\t\$-2401018187971961171, AX`, -`MOVQ\t\$-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/compare_and_branch.go b/test/codegen/compare_and_branch.go index 759dd26358..7ffd25ced8 100644 --- a/test/codegen/compare_and_branch.go +++ b/test/codegen/compare_and_branch.go @@ -11,12 +11,12 @@ func dummy() {} // Signed 64-bit compare-and-branch. func si64(x, y chan int64) { - // s390x:"CGRJ\t[$](2|4), R[0-9]+, R[0-9]+, " + // s390x:"CGRJ [$](2|4), R[0-9]+, R[0-9]+, " for <-x < <-y { dummy() } - // s390x:"CL?GRJ\t[$]8, R[0-9]+, R[0-9]+, " + // s390x:"CL?GRJ [$]8, R[0-9]+, R[0-9]+, " for <-x == <-y { dummy() } @@ -25,22 +25,22 @@ func si64(x, y chan int64) { // Signed 64-bit compare-and-branch with 8-bit immediate. func si64x8(doNotOptimize int64) { // take in doNotOptimize as an argument to avoid the loops being rewritten to count down - // s390x:"CGIJ\t[$]12, R[0-9]+, [$]127, " + // s390x:"CGIJ [$]12, R[0-9]+, [$]127, " for i := doNotOptimize; i < 128; i++ { dummy() } - // s390x:"CGIJ\t[$]10, R[0-9]+, [$]-128, " + // s390x:"CGIJ [$]10, R[0-9]+, [$]-128, " for i := doNotOptimize; i > -129; i-- { dummy() } - // s390x:"CGIJ\t[$]2, R[0-9]+, [$]127, " + // s390x:"CGIJ [$]2, R[0-9]+, [$]127, " for i := doNotOptimize; i >= 128; i++ { dummy() } - // s390x:"CGIJ\t[$]4, R[0-9]+, [$]-128, " + // s390x:"CGIJ [$]4, R[0-9]+, [$]-128, " for i := doNotOptimize; i <= -129; i-- { dummy() } @@ -48,12 +48,12 @@ func si64x8(doNotOptimize int64) { // Unsigned 64-bit compare-and-branch. func ui64(x, y chan uint64) { - // s390x:"CLGRJ\t[$](2|4), R[0-9]+, R[0-9]+, " + // s390x:"CLGRJ [$](2|4), R[0-9]+, R[0-9]+, " for <-x > <-y { dummy() } - // s390x:"CL?GRJ\t[$]6, R[0-9]+, R[0-9]+, " + // s390x:"CL?GRJ [$]6, R[0-9]+, R[0-9]+, " for <-x != <-y { dummy() } @@ -61,22 +61,22 @@ func ui64(x, y chan uint64) { // Unsigned 64-bit comparison with 8-bit immediate. func ui64x8() { - // s390x:"CLGIJ\t[$]4, R[0-9]+, [$]128, " + // s390x:"CLGIJ [$]4, R[0-9]+, [$]128, " for i := uint64(0); i < 128; i++ { dummy() } - // s390x:"CLGIJ\t[$]12, R[0-9]+, [$]255, " + // s390x:"CLGIJ [$]12, R[0-9]+, [$]255, " for i := uint64(0); i < 256; i++ { dummy() } - // s390x:"CLGIJ\t[$]2, R[0-9]+, [$]255, " + // s390x:"CLGIJ [$]2, R[0-9]+, [$]255, " for i := uint64(257); i >= 256; i-- { dummy() } - // s390x:"CLGIJ\t[$]2, R[0-9]+, [$]0, " + // s390x:"CLGIJ [$]2, R[0-9]+, [$]0, " for i := uint64(1024); i > 0; i-- { dummy() } @@ -84,12 +84,12 @@ func ui64x8() { // Signed 32-bit compare-and-branch. func si32(x, y chan int32) { - // s390x:"CRJ\t[$](2|4), R[0-9]+, R[0-9]+, " + // s390x:"CRJ [$](2|4), R[0-9]+, R[0-9]+, " for <-x < <-y { dummy() } - // s390x:"CL?RJ\t[$]8, R[0-9]+, R[0-9]+, " + // s390x:"CL?RJ [$]8, R[0-9]+, R[0-9]+, " for <-x == <-y { dummy() } @@ -98,22 +98,22 @@ func si32(x, y chan int32) { // Signed 32-bit compare-and-branch with 8-bit immediate. func si32x8(doNotOptimize int32) { // take in doNotOptimize as an argument to avoid the loops being rewritten to count down - // s390x:"CIJ\t[$]12, R[0-9]+, [$]127, " + // s390x:"CIJ [$]12, R[0-9]+, [$]127, " for i := doNotOptimize; i < 128; i++ { dummy() } - // s390x:"CIJ\t[$]10, R[0-9]+, [$]-128, " + // s390x:"CIJ [$]10, R[0-9]+, [$]-128, " for i := doNotOptimize; i > -129; i-- { dummy() } - // s390x:"CIJ\t[$]2, R[0-9]+, [$]127, " + // s390x:"CIJ [$]2, R[0-9]+, [$]127, " for i := doNotOptimize; i >= 128; i++ { dummy() } - // s390x:"CIJ\t[$]4, R[0-9]+, [$]-128, " + // s390x:"CIJ [$]4, R[0-9]+, [$]-128, " for i := doNotOptimize; i <= -129; i-- { dummy() } @@ -121,12 +121,12 @@ func si32x8(doNotOptimize int32) { // Unsigned 32-bit compare-and-branch. func ui32(x, y chan uint32) { - // s390x:"CLRJ\t[$](2|4), R[0-9]+, R[0-9]+, " + // s390x:"CLRJ [$](2|4), R[0-9]+, R[0-9]+, " for <-x > <-y { dummy() } - // s390x:"CL?RJ\t[$]6, R[0-9]+, R[0-9]+, " + // s390x:"CL?RJ [$]6, R[0-9]+, R[0-9]+, " for <-x != <-y { dummy() } @@ -134,22 +134,22 @@ func ui32(x, y chan uint32) { // Unsigned 32-bit comparison with 8-bit immediate. func ui32x8() { - // s390x:"CLIJ\t[$]4, R[0-9]+, [$]128, " + // s390x:"CLIJ [$]4, R[0-9]+, [$]128, " for i := uint32(0); i < 128; i++ { dummy() } - // s390x:"CLIJ\t[$]12, R[0-9]+, [$]255, " + // s390x:"CLIJ [$]12, R[0-9]+, [$]255, " for i := uint32(0); i < 256; i++ { dummy() } - // s390x:"CLIJ\t[$]2, R[0-9]+, [$]255, " + // s390x:"CLIJ [$]2, R[0-9]+, [$]255, " for i := uint32(257); i >= 256; i-- { dummy() } - // s390x:"CLIJ\t[$]2, R[0-9]+, [$]0, " + // s390x:"CLIJ [$]2, R[0-9]+, [$]0, " for i := uint32(1024); i > 0; i-- { dummy() } @@ -157,12 +157,12 @@ func ui32x8() { // Signed 64-bit comparison with unsigned 8-bit immediate. func si64xu8(x chan int64) { - // s390x:"CLGIJ\t[$]8, R[0-9]+, [$]128, " + // s390x:"CLGIJ [$]8, R[0-9]+, [$]128, " for <-x == 128 { dummy() } - // s390x:"CLGIJ\t[$]6, R[0-9]+, [$]255, " + // s390x:"CLGIJ [$]6, R[0-9]+, [$]255, " for <-x != 255 { dummy() } @@ -170,12 +170,12 @@ func si64xu8(x chan int64) { // Signed 32-bit comparison with unsigned 8-bit immediate. func si32xu8(x chan int32) { - // s390x:"CLIJ\t[$]8, R[0-9]+, [$]255, " + // s390x:"CLIJ [$]8, R[0-9]+, [$]255, " for <-x == 255 { dummy() } - // s390x:"CLIJ\t[$]6, R[0-9]+, [$]128, " + // s390x:"CLIJ [$]6, R[0-9]+, [$]128, " for <-x != 128 { dummy() } @@ -183,12 +183,12 @@ func si32xu8(x chan int32) { // Unsigned 64-bit comparison with signed 8-bit immediate. func ui64xu8(x chan uint64) { - // s390x:"CGIJ\t[$]8, R[0-9]+, [$]-1, " + // s390x:"CGIJ [$]8, R[0-9]+, [$]-1, " for <-x == ^uint64(0) { dummy() } - // s390x:"CGIJ\t[$]6, R[0-9]+, [$]-128, " + // s390x:"CGIJ [$]6, R[0-9]+, [$]-128, " for <-x != ^uint64(127) { dummy() } @@ -196,12 +196,12 @@ func ui64xu8(x chan uint64) { // Unsigned 32-bit comparison with signed 8-bit immediate. func ui32xu8(x chan uint32) { - // s390x:"CIJ\t[$]8, R[0-9]+, [$]-128, " + // s390x:"CIJ [$]8, R[0-9]+, [$]-128, " for <-x == ^uint32(127) { dummy() } - // s390x:"CIJ\t[$]6, R[0-9]+, [$]-1, " + // s390x:"CIJ [$]6, R[0-9]+, [$]-1, " for <-x != ^uint32(0) { dummy() } diff --git a/test/codegen/comparisons.go b/test/codegen/comparisons.go index 702ea275cc..74a7d689da 100644 --- a/test/codegen/comparisons.go +++ b/test/codegen/comparisons.go @@ -21,68 +21,68 @@ import ( // Check that compare to constant string use 2/4/8 byte compares func CompareString1(s string) bool { - // amd64:`CMPW\t\(.*\), [$]` - // arm64:`MOVHU\t\(.*\), [R]`,`MOVD\t[$]`,`CMPW\tR` - // ppc64le:`MOVHZ\t\(.*\), [R]`,`CMPW\t.*, [$]` - // s390x:`MOVHBR\t\(.*\), [R]`,`CMPW\t.*, [$]` + // amd64:`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\t\(.*\), [$]` - // arm64:`MOVWU\t\(.*\), [R]`,`CMPW\t.*, [R]` - // ppc64le:`MOVWZ\t\(.*\), [R]`,`CMPW\t.*, [R]` - // s390x:`MOVWBR\t\(.*\), [R]`,`CMPW\t.*, [$]` + // amd64:`CMPL \(.*\), [$]` + // arm64:`MOVWU \(.*\), [R]`,`CMPW .*, [R]` + // ppc64le:`MOVWZ \(.*\), [R]`,`CMPW .*, [R]` + // s390x:`MOVWBR \(.*\), [R]`,`CMPW .*, [$]` return s == "xxxx" } func CompareString3(s string) bool { - // amd64:`CMPQ\t\(.*\), [A-Z]` - // arm64:-`CMPW\t` - // ppc64x:-`CMPW\t` - // s390x:-`CMPW\t` + // amd64:`CMPQ \(.*\), [A-Z]` + // arm64:-`CMPW ` + // ppc64x:-`CMPW ` + // s390x:-`CMPW ` return s == "xxxxxxxx" } // Check that arrays compare use 2/4/8 byte compares func CompareArray1(a, b [2]byte) bool { - // amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` - // arm64:-`MOVBU\t` - // ppc64le:-`MOVBZ\t` - // s390x:-`MOVBZ\t` + // amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // arm64:-`MOVBU ` + // ppc64le:-`MOVBZ ` + // s390x:-`MOVBZ ` return a == b } func CompareArray2(a, b [3]uint16) bool { - // amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` - // amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` return a == b } func CompareArray3(a, b [3]int16) bool { - // amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` - // amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` return a == b } func CompareArray4(a, b [12]int8) bool { - // amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` - // amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` return a == b } func CompareArray5(a, b [15]byte) bool { - // amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` return a == b } // This was a TODO in mapaccess1_faststr func CompareArray6(a, b unsafe.Pointer) bool { - // amd64:`CMPL\t\(.*\), [A-Z]` - // arm64:`MOVWU\t\(.*\), [R]`,`CMPW\t.*, [R]` - // ppc64le:`MOVWZ\t\(.*\), [R]`,`CMPW\t.*, [R]` - // s390x:`MOVWBR\t\(.*\), [R]`,`CMPW\t.*, [R]` + // amd64:`CMPL \(.*\), [A-Z]` + // arm64:`MOVWU \(.*\), [R]`,`CMPW .*, [R]` + // ppc64le:`MOVWZ \(.*\), [R]`,`CMPW .*, [R]` + // s390x:`MOVWBR \(.*\), [R]`,`CMPW .*, [R]` return *((*[4]byte)(a)) != *((*[4]byte)(b)) } @@ -93,7 +93,7 @@ type T1 struct { } func CompareStruct1(s1, s2 T1) bool { - // amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` // amd64:-`CALL` return s1 == s2 } @@ -103,7 +103,7 @@ type T2 struct { } func CompareStruct2(s1, s2 T2) bool { - // amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` // amd64:-`CALL` return s1 == s2 } @@ -116,7 +116,7 @@ type T3 struct { } func CompareStruct3(s1, s2 T3) bool { - // amd64:-`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:-`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` // amd64:`CALL` return s1 == s2 } @@ -126,7 +126,7 @@ type T4 struct { } func CompareStruct4(s1, s2 T4) bool { - // amd64:-`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` + // amd64:-`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]` // amd64:`CALL` return s1 == s2 } @@ -140,7 +140,7 @@ func CompareStruct4(s1, s2 T4) bool { var r bool func CmpFold(x uint32) { - // amd64:`SETHI\t.*\(SB\)` + // amd64:`SETHI .*\(SB\)` r = x > 4 } @@ -148,27 +148,27 @@ func CmpFold(x uint32) { // possible func CmpMem1(p int, q *int) bool { - // amd64:`CMPQ\t\(.*\), [A-Z]` + // amd64:`CMPQ \(.*\), [A-Z]` return p < *q } func CmpMem2(p *int, q int) bool { - // amd64:`CMPQ\t\(.*\), [A-Z]` + // amd64:`CMPQ \(.*\), [A-Z]` return *p < q } func CmpMem3(p *int) bool { - // amd64:`CMPQ\t\(.*\), [$]7` + // amd64:`CMPQ \(.*\), [$]7` return *p < 7 } func CmpMem4(p *int) bool { - // amd64:`CMPQ\t\(.*\), [$]7` + // amd64:`CMPQ \(.*\), [$]7` return 7 < *p } func CmpMem5(p **int) { - // amd64:`CMPL\truntime.writeBarrier\(SB\), [$]0` + // amd64:`CMPL runtime.writeBarrier\(SB\), [$]0` *p = nil } @@ -270,31 +270,31 @@ func CmpToZero(a, b, d int32, e, f int64, deOptC0, deOptC1 bool) int32 { func CmpLogicalToZero(a, b, c uint32, d, e, f, g uint64) uint64 { - // ppc64x:"ANDCC",-"CMPW" - // wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64" + // ppc64x:"ANDCC" -"CMPW" + // wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64" if a&63 == 0 { return 1 } - // ppc64x:"ANDCC",-"CMP" - // wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64" + // ppc64x:"ANDCC" -"CMP" + // wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64" if d&255 == 0 { return 1 } - // ppc64x:"ANDCC",-"CMP" - // wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64" + // ppc64x:"ANDCC" -"CMP" + // wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64" if d&e == 0 { return 1 } - // ppc64x:"ORCC",-"CMP" - // wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64" + // ppc64x:"ORCC" -"CMP" + // wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64" if f|g == 0 { return 1 } - // ppc64x:"XORCC",-"CMP" - // wasm:"I64Eqz","I32Eqz",-"I64ExtendI32U",-"I32WrapI64" + // ppc64x:"XORCC" -"CMP" + // wasm:"I64Eqz" "I32Eqz" -"I64ExtendI32U" -"I32WrapI64" if e^d == 0 { return 1 } @@ -711,19 +711,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\tMI`,-`CMP` + // arm64:`CMN`,`CSET MI`,-`CMP` if a+1 < 0 { c1 = 1 } - // arm64:`CMN`,`CSET\tMI`,-`CMP` + // arm64:`CMN`,`CSET MI`,-`CMP` if a+b < 0 { c2 = 1 } - // arm64:`CMN`,`CSET\tMI`,-`CMP` + // arm64:`CMN`,`CSET MI`,-`CMP` if a*b+c < 0 { c3 = 1 } - // arm64:`CMP`,`CSET\tMI`,-`CMN` + // arm64:`CMP`,`CSET MI`,-`CMN` if a-b*c < 0 { c4 = 1 } @@ -780,19 +780,19 @@ func ge128Signed64(x int64) bool { func cmpToCmnGreaterThanEqual(a, b, c, d int) int { var c1, c2, c3, c4 int - // arm64:`CMN`,`CSET\tPL`,-`CMP` + // arm64:`CMN`,`CSET PL`,-`CMP` if a+1 >= 0 { c1 = 1 } - // arm64:`CMN`,`CSET\tPL`,-`CMP` + // arm64:`CMN`,`CSET PL`,-`CMP` if a+b >= 0 { c2 = 1 } - // arm64:`CMN`,`CSET\tPL`,-`CMP` + // arm64:`CMN`,`CSET PL`,-`CMP` if a*b+c >= 0 { c3 = 1 } - // arm64:`CMP`,`CSET\tPL`,-`CMN` + // arm64:`CMP`,`CSET PL`,-`CMN` if a-b*c >= 0 { c4 = 1 } @@ -870,6 +870,6 @@ func cmpstring2(x, y string) int { // like in cmpstring1 will not work. Instead, we // look for spill/restore instructions, which only // need to exist if there are 2 calls. - //amd64:-`MOVQ\t.*\(SP\)` + //amd64:-`MOVQ .*\(SP\)` return cmp.Compare(x, y) } diff --git a/test/codegen/condmove.go b/test/codegen/condmove.go index 6d3a46b03c..54e5f361fe 100644 --- a/test/codegen/condmove.go +++ b/test/codegen/condmove.go @@ -12,8 +12,8 @@ func cmovint(c int) int { x = 182 } // amd64:"CMOVQLT" - // arm64:"CSEL\tLT" - // ppc64x:"ISEL\t[$]0" + // arm64:"CSEL LT" + // ppc64x:"ISEL [$]0" // wasm:"Select" return x } @@ -23,8 +23,8 @@ func cmovchan(x, y chan int) chan int { x = y } // amd64:"CMOVQNE" - // arm64:"CSEL\tNE" - // ppc64x:"ISEL\t[$]2" + // arm64:"CSEL NE" + // ppc64x:"ISEL [$]2" // wasm:"Select" return x } @@ -34,8 +34,8 @@ func cmovuintptr(x, y uintptr) uintptr { x = -y } // amd64:"CMOVQ(HI|CS)" - // arm64:"CSNEG\tLS" - // ppc64x:"ISEL\t[$]1" + // arm64:"CSNEG LS" + // ppc64x:"ISEL [$]1" // wasm:"Select" return x } @@ -45,8 +45,8 @@ func cmov32bit(x, y uint32) uint32 { x = -y } // amd64:"CMOVL(HI|CS)" - // arm64:"CSNEG\t(LS|HS)" - // ppc64x:"ISEL\t[$]1" + // arm64:"CSNEG (LS|HS)" + // ppc64x:"ISEL [$]1" // wasm:"Select" return x } @@ -56,8 +56,8 @@ func cmov16bit(x, y uint16) uint16 { x = -y } // amd64:"CMOVW(HI|CS)" - // arm64:"CSNEG\t(LS|HS)" - // ppc64x:"ISEL\t[$][01]" + // arm64:"CSNEG (LS|HS)" + // ppc64x:"ISEL [$][01]" // wasm:"Select" return x } @@ -69,9 +69,9 @@ func cmovfloateq(x, y float64) int { if x == y { a = 256 } - // amd64:"CMOVQNE","CMOVQPC" - // arm64:"CSEL\tEQ" - // ppc64x:"ISEL\t[$]2" + // amd64:"CMOVQNE" "CMOVQPC" + // arm64:"CSEL EQ" + // ppc64x:"ISEL [$]2" // wasm:"Select" return a } @@ -81,9 +81,9 @@ func cmovfloatne(x, y float64) int { if x != y { a = 256 } - // amd64:"CMOVQNE","CMOVQPS" - // arm64:"CSEL\tNE" - // ppc64x:"ISEL\t[$]2" + // amd64:"CMOVQNE" "CMOVQPS" + // arm64:"CSEL NE" + // ppc64x:"ISEL [$]2" // wasm:"Select" return a } @@ -109,8 +109,8 @@ func cmovfloatint2(x, y float64) float64 { rexp = rexp - 42 } // amd64:"CMOVQHI" - // arm64:"CSEL\tMI" - // ppc64x:"ISEL\t[$]0" + // arm64:"CSEL MI" + // ppc64x:"ISEL [$]0" // wasm:"Select" r = r - ldexp(y, rexp-yexp) } @@ -124,8 +124,8 @@ func cmovloaded(x [4]int, y int) int { y = y >> 2 } // amd64:"CMOVQNE" - // arm64:"CSEL\tNE" - // ppc64x:"ISEL\t[$]2" + // arm64:"CSEL NE" + // ppc64x:"ISEL [$]2" // wasm:"Select" return y } @@ -136,8 +136,8 @@ func cmovuintptr2(x, y uintptr) uintptr { a = 256 } // amd64:"CMOVQEQ" - // arm64:"CSEL\tEQ" - // ppc64x:"ISEL\t[$]2" + // arm64:"CSEL EQ" + // ppc64x:"ISEL [$]2" // wasm:"Select" return a } @@ -230,7 +230,7 @@ func cmovinc(cond bool, a, b, c int) { } else { x0 = b + 1 } - // arm64:"CSINC\tNE", -"CSEL" + // arm64:"CSINC NE", -"CSEL" r0 = x0 if cond { @@ -238,13 +238,13 @@ func cmovinc(cond bool, a, b, c int) { } else { x1 = a } - // arm64:"CSINC\tEQ", -"CSEL" + // arm64:"CSINC EQ", -"CSEL" r1 = x1 if cond { c++ } - // arm64:"CSINC\tEQ", -"CSEL" + // arm64:"CSINC EQ", -"CSEL" r2 = c } @@ -256,7 +256,7 @@ func cmovinv(cond bool, a, b int) { } else { x0 = ^b } - // arm64:"CSINV\tNE", -"CSEL" + // arm64:"CSINV NE", -"CSEL" r0 = x0 if cond { @@ -264,7 +264,7 @@ func cmovinv(cond bool, a, b int) { } else { x1 = a } - // arm64:"CSINV\tEQ", -"CSEL" + // arm64:"CSINV EQ", -"CSEL" r1 = x1 } @@ -276,7 +276,7 @@ func cmovneg(cond bool, a, b, c int) { } else { x0 = -b } - // arm64:"CSNEG\tNE", -"CSEL" + // arm64:"CSNEG NE", -"CSEL" r0 = x0 if cond { @@ -284,7 +284,7 @@ func cmovneg(cond bool, a, b, c int) { } else { x1 = a } - // arm64:"CSNEG\tEQ", -"CSEL" + // arm64:"CSNEG EQ", -"CSEL" r1 = x1 } @@ -296,7 +296,7 @@ func cmovsetm(cond bool, x int) { } else { x0 = 0 } - // arm64:"CSETM\tNE", -"CSEL" + // arm64:"CSETM NE", -"CSEL" r0 = x0 if cond { @@ -304,7 +304,7 @@ func cmovsetm(cond bool, x int) { } else { x1 = -1 } - // arm64:"CSETM\tEQ", -"CSEL" + // arm64:"CSETM EQ", -"CSEL" r1 = x1 } @@ -316,7 +316,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x0 = b + 1 } - // arm64:"CSINC\tMI", -"CSEL" + // arm64:"CSINC MI", -"CSEL" r0 = x0 if s <= t { @@ -324,7 +324,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x1 = ^b } - // arm64:"CSINV\tLS", -"CSEL" + // arm64:"CSINV LS", -"CSEL" r1 = x1 if s > t { @@ -332,7 +332,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x2 = -b } - // arm64:"CSNEG\tMI", -"CSEL" + // arm64:"CSNEG MI", -"CSEL" r2 = x2 if s >= t { @@ -340,7 +340,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x3 = 0 } - // arm64:"CSETM\tLS", -"CSEL" + // arm64:"CSETM LS", -"CSEL" r3 = x3 if s == t { @@ -348,7 +348,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x4 = b + 1 } - // arm64:"CSINC\tEQ", -"CSEL" + // arm64:"CSINC EQ", -"CSEL" r4 = x4 if s != t { @@ -356,7 +356,7 @@ func cmovFcmp0(s, t float64, a, b int) { } else { x5 = b + 1 } - // arm64:"CSINC\tNE", -"CSEL" + // arm64:"CSINC NE", -"CSEL" r5 = x5 } @@ -368,7 +368,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x0 = a } - // arm64:"CSINC\tPL", -"CSEL" + // arm64:"CSINC PL", -"CSEL" r0 = x0 if s <= t { @@ -376,7 +376,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x1 = a } - // arm64:"CSINV\tHI", -"CSEL" + // arm64:"CSINV HI", -"CSEL" r1 = x1 if s > t { @@ -384,7 +384,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x2 = a } - // arm64:"CSNEG\tPL", -"CSEL" + // arm64:"CSNEG PL", -"CSEL" r2 = x2 if s >= t { @@ -392,7 +392,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x3 = -1 } - // arm64:"CSETM\tHI", -"CSEL" + // arm64:"CSETM HI", -"CSEL" r3 = x3 if s == t { @@ -400,7 +400,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x4 = a } - // arm64:"CSINC\tNE", -"CSEL" + // arm64:"CSINC NE", -"CSEL" r4 = x4 if s != t { @@ -408,7 +408,7 @@ func cmovFcmp1(s, t float64, a, b int) { } else { x5 = a } - // arm64:"CSINC\tEQ", -"CSEL" + // arm64:"CSINC EQ", -"CSEL" r5 = x5 } @@ -439,7 +439,7 @@ func cmovzeroreg0(a, b int) int { if a == b { x = a } - // ppc64x:"ISEL\t[$]2, R[0-9]+, R0, R[0-9]+" + // ppc64x:"ISEL [$]2, R[0-9]+, R0, R[0-9]+" return x } @@ -448,7 +448,7 @@ func cmovzeroreg1(a, b int) int { if a == b { x = 0 } - // ppc64x:"ISEL\t[$]2, R0, R[0-9]+, R[0-9]+" + // ppc64x:"ISEL [$]2, R0, R[0-9]+, R[0-9]+" return x } diff --git a/test/codegen/constants.go b/test/codegen/constants.go index 0935a9e53a..178a106552 100644 --- a/test/codegen/constants.go +++ b/test/codegen/constants.go @@ -8,28 +8,28 @@ package codegen // A uint16 or sint16 constant shifted left. func shifted16BitConstants() (out [64]uint64) { - // ppc64x: "MOVD\t[$]8193,", "SLD\t[$]27," + // ppc64x: "MOVD [$]8193,", "SLD [$]27," out[0] = 0x0000010008000000 - // ppc64x: "MOVD\t[$]-32767", "SLD\t[$]26," + // ppc64x: "MOVD [$]-32767", "SLD [$]26," out[1] = 0xFFFFFE0004000000 - // ppc64x: "MOVD\t[$]-1", "SLD\t[$]48," + // ppc64x: "MOVD [$]-1", "SLD [$]48," out[2] = 0xFFFF000000000000 - // ppc64x: "MOVD\t[$]65535", "SLD\t[$]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\t[$]-1", "RLDC\tR[0-9]+, [$]44, [$]63," + // ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]44, [$]63," out[0] = 0xFFFFF00000000001 - // ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]43, [$]63," + // ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]43, [$]63," out[1] = 0xFFFFF80000000001 - // ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]43, [$]4," + // ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]43, [$]4," out[2] = 0x0FFFF80000000000 - // ppc64x/power8: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]33, [$]63," - // ppc64x/power9: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]33, [$]63," - // ppc64x/power10: "MOVD\t[$]-8589934591," + // 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 4329c6d78f..a4b9bedbe8 100644 --- a/test/codegen/copy.go +++ b/test/codegen/copy.go @@ -43,8 +43,8 @@ var x [256]byte func moveDisjointStack32() { var s [32]byte // ppc64x:-".*memmove" - // ppc64x/power8:"LXVD2X",-"ADD",-"BC" - // ppc64x/power9:"LXV",-"LXVD2X",-"ADD",-"BC" + // ppc64x/power8:"LXVD2X" -"ADD" -"BC" + // ppc64x/power9:"LXV" -"LXVD2X" -"ADD" -"BC" copy(s[:], x[:32]) runtime.KeepAlive(&s) } @@ -52,8 +52,8 @@ func moveDisjointStack32() { func moveDisjointStack64() { var s [96]byte // ppc64x:-".*memmove" - // ppc64x/power8:"LXVD2X","ADD","BC" - // ppc64x/power9:"LXV",-"LXVD2X",-"ADD",-"BC" + // ppc64x/power8:"LXVD2X" "ADD" "BC" + // ppc64x/power9:"LXV" -"LXVD2X" -"ADD" -"BC" copy(s[:], x[:96]) runtime.KeepAlive(&s) } @@ -64,7 +64,7 @@ func moveDisjointStack() { // amd64:-".*memmove" // ppc64x:-".*memmove" // ppc64x/power8:"LXVD2X" - // ppc64x/power9:"LXV",-"LXVD2X" + // ppc64x/power9:"LXV" -"LXVD2X" copy(s[:], x[:]) runtime.KeepAlive(&s) } @@ -75,7 +75,7 @@ func moveDisjointArg(b *[256]byte) { // amd64:-".*memmove" // ppc64x:-".*memmove" // ppc64x/power8:"LXVD2X" - // ppc64x/power9:"LXV",-"LXVD2X" + // ppc64x/power9:"LXV" -"LXVD2X" copy(s[:], b[:]) runtime.KeepAlive(&s) } @@ -85,7 +85,7 @@ func moveDisjointNoOverlap(a *[256]byte) { // amd64:-".*memmove" // ppc64x:-".*memmove" // ppc64x/power8:"LXVD2X" - // ppc64x/power9:"LXV",-"LXVD2X" + // ppc64x/power9:"LXV" -"LXVD2X" copy(a[:], a[128:]) } @@ -135,28 +135,28 @@ func moveArchLowering16(b []byte, x *[16]byte) { // Check that no branches are generated when the pointers are [not] equal. func ptrEqual() { - // amd64:-"JEQ",-"JNE" - // ppc64x:-"BEQ",-"BNE" - // s390x:-"BEQ",-"BNE" + // amd64:-"JEQ" -"JNE" + // ppc64x:-"BEQ" -"BNE" + // s390x:-"BEQ" -"BNE" copy(x[:], x[:]) } func ptrOneOffset() { - // amd64:-"JEQ",-"JNE" - // ppc64x:-"BEQ",-"BNE" - // s390x:-"BEQ",-"BNE" + // amd64:-"JEQ" -"JNE" + // ppc64x:-"BEQ" -"BNE" + // s390x:-"BEQ" -"BNE" copy(x[1:], x[:]) } func ptrBothOffset() { - // amd64:-"JEQ",-"JNE" - // ppc64x:-"BEQ",-"BNE" - // s390x:-"BEQ",-"BNE" + // amd64:-"JEQ" -"JNE" + // ppc64x:-"BEQ" -"BNE" + // s390x:-"BEQ" -"BNE" copy(x[1:], x[2:]) } // Verify #62698 on PPC64. func noMaskOnCopy(a []int, s string, x int) int { - // ppc64x:-"MOVD\t$-1", -"AND" + // ppc64x:-"MOVD [$]-1", -"AND" return a[x&^copy([]byte{}, s)] } diff --git a/test/codegen/floats.go b/test/codegen/floats.go index b453cabf3b..3942cb5862 100644 --- a/test/codegen/floats.go +++ b/test/codegen/floats.go @@ -15,42 +15,42 @@ package codegen // --------------------- // func Mul2(f float64) float64 { - // 386/sse2:"ADDSD",-"MULSD" - // amd64:"ADDSD",-"MULSD" - // arm/7:"ADDD",-"MULD" - // arm64:"FADDD",-"FMULD" - // loong64:"ADDD",-"MULD" - // ppc64x:"FADD",-"FMUL" - // riscv64:"FADDD",-"FMULD" + // 386/sse2:"ADDSD" -"MULSD" + // amd64:"ADDSD" -"MULSD" + // arm/7:"ADDD" -"MULD" + // arm64:"FADDD" -"FMULD" + // loong64:"ADDD" -"MULD" + // ppc64x:"FADD" -"FMUL" + // riscv64:"FADDD" -"FMULD" return f * 2.0 } func DivPow2(f1, f2, f3 float64) (float64, float64, float64) { - // 386/sse2:"MULSD",-"DIVSD" - // amd64:"MULSD",-"DIVSD" - // arm/7:"MULD",-"DIVD" - // arm64:"FMULD",-"FDIVD" - // loong64:"MULD",-"DIVD" - // ppc64x:"FMUL",-"FDIV" - // riscv64:"FMULD",-"FDIVD" + // 386/sse2:"MULSD" -"DIVSD" + // amd64:"MULSD" -"DIVSD" + // arm/7:"MULD" -"DIVD" + // arm64:"FMULD" -"FDIVD" + // loong64:"MULD" -"DIVD" + // ppc64x:"FMUL" -"FDIV" + // riscv64:"FMULD" -"FDIVD" x := f1 / 16.0 - // 386/sse2:"MULSD",-"DIVSD" - // amd64:"MULSD",-"DIVSD" - // arm/7:"MULD",-"DIVD" - // arm64:"FMULD",-"FDIVD" - // loong64:"MULD",-"DIVD" - // ppc64x:"FMUL",-"FDIVD" - // riscv64:"FMULD",-"FDIVD" + // 386/sse2:"MULSD" -"DIVSD" + // amd64:"MULSD" -"DIVSD" + // arm/7:"MULD" -"DIVD" + // arm64:"FMULD" -"FDIVD" + // loong64:"MULD" -"DIVD" + // ppc64x:"FMUL" -"FDIVD" + // riscv64:"FMULD" -"FDIVD" y := f2 / 0.125 - // 386/sse2:"ADDSD",-"DIVSD",-"MULSD" - // amd64:"ADDSD",-"DIVSD",-"MULSD" - // arm/7:"ADDD",-"MULD",-"DIVD" - // arm64:"FADDD",-"FMULD",-"FDIVD" - // loong64:"ADDD",-"MULD",-"DIVD" - // ppc64x:"FADD",-"FMUL",-"FDIV" - // riscv64:"FADDD",-"FMULD",-"FDIVD" + // 386/sse2:"ADDSD" -"DIVSD" -"MULSD" + // amd64:"ADDSD" -"DIVSD" -"MULSD" + // arm/7:"ADDD" -"MULD" -"DIVD" + // arm64:"FADDD" -"FMULD" -"FDIVD" + // loong64:"ADDD" -"MULD" -"DIVD" + // ppc64x:"FADD" -"FMUL" -"FDIV" + // riscv64:"FADDD" -"FMULD" -"FDIVD" z := f3 / 0.5 return x, y, z @@ -73,67 +73,67 @@ func indexStore(b0 []float64, b1 float64, idx int) { // ----------- // func FusedAdd32(x, y, z float32) float32 { - // s390x:"FMADDS\t" - // ppc64x:"FMADDS\t" + // s390x:"FMADDS " + // ppc64x:"FMADDS " // arm64:"FMADDS" - // loong64:"FMADDF\t" - // riscv64:"FMADDS\t" - // amd64/v3:"VFMADD231SS\t" + // loong64:"FMADDF " + // riscv64:"FMADDS " + // amd64/v3:"VFMADD231SS " return x*y + z } func FusedSub32_a(x, y, z float32) float32 { - // s390x:"FMSUBS\t" - // ppc64x:"FMSUBS\t" - // riscv64:"FMSUBS\t" - // loong64:"FMSUBF\t" + // s390x:"FMSUBS " + // ppc64x:"FMSUBS " + // riscv64:"FMSUBS " + // loong64:"FMSUBF " return x*y - z } func FusedSub32_b(x, y, z float32) float32 { // arm64:"FMSUBS" - // loong64:"FNMSUBF\t" - // riscv64:"FNMSUBS\t" + // loong64:"FNMSUBF " + // riscv64:"FNMSUBS " return z - x*y } func FusedAdd64(x, y, z float64) float64 { - // s390x:"FMADD\t" - // ppc64x:"FMADD\t" + // s390x:"FMADD " + // ppc64x:"FMADD " // arm64:"FMADDD" - // loong64:"FMADDD\t" - // riscv64:"FMADDD\t" - // amd64/v3:"VFMADD231SD\t" + // loong64:"FMADDD " + // riscv64:"FMADDD " + // amd64/v3:"VFMADD231SD " return x*y + z } func FusedSub64_a(x, y, z float64) float64 { - // s390x:"FMSUB\t" - // ppc64x:"FMSUB\t" - // riscv64:"FMSUBD\t" - // loong64:"FMSUBD\t" + // s390x:"FMSUB " + // ppc64x:"FMSUB " + // riscv64:"FMSUBD " + // loong64:"FMSUBD " return x*y - z } func FusedSub64_b(x, y, z float64) float64 { // arm64:"FMSUBD" - // loong64:"FNMSUBD\t" - // riscv64:"FNMSUBD\t" + // loong64:"FNMSUBD " + // riscv64:"FNMSUBD " return z - x*y } func Cmp(f float64) bool { - // arm64:"FCMPD","(BGT|BLE|BMI|BPL)",-"CSET\tGT",-"CBZ" + // arm64:"FCMPD" "(BGT|BLE|BMI|BPL)" -"CSET GT" -"CBZ" return f > 4 || f < -4 } func CmpZero64(f float64) bool { - // s390x:"LTDBR",-"FCMPU" + // s390x:"LTDBR" -"FCMPU" return f <= 0 } func CmpZero32(f float32) bool { - // s390x:"LTEBR",-"CEBR" + // s390x:"LTEBR" -"CEBR" return f <= 0 } @@ -218,43 +218,43 @@ func Float32Max(a, b float32) float32 { // ------------------------ // func Float32ConstantZero() float32 { - // arm64:"FMOVS\tZR," + // arm64:"FMOVS ZR," return 0.0 } func Float32ConstantChipFloat() float32 { - // arm64:"FMOVS\t[$]\\(2\\.25\\)," + // arm64:"FMOVS [$]\\(2\\.25\\)," return 2.25 } func Float32Constant() float32 { - // arm64:"FMOVS\t[$]f32\\.42440000\\(SB\\)" - // ppc64x/power8:"FMOVS\t[$]f32\\.42440000\\(SB\\)" - // ppc64x/power9:"FMOVS\t[$]f32\\.42440000\\(SB\\)" - // ppc64x/power10:"XXSPLTIDP\t[$]1111752704," + // arm64:"FMOVS [$]f32\\.42440000\\(SB\\)" + // ppc64x/power8:"FMOVS [$]f32\\.42440000\\(SB\\)" + // ppc64x/power9:"FMOVS [$]f32\\.42440000\\(SB\\)" + // ppc64x/power10:"XXSPLTIDP [$]1111752704," return 49.0 } func Float64ConstantZero() float64 { - // arm64:"FMOVD\tZR," + // arm64:"FMOVD ZR," return 0.0 } func Float64ConstantChipFloat() float64 { - // arm64:"FMOVD\t[$]\\(2\\.25\\)," + // arm64:"FMOVD [$]\\(2\\.25\\)," return 2.25 } func Float64Constant() float64 { - // arm64:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)" - // ppc64x/power8:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)" - // ppc64x/power9:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)" - // ppc64x/power10:"XXSPLTIDP\t[$]1111752704," + // arm64:"FMOVD [$]f64\\.4048800000000000\\(SB\\)" + // ppc64x/power8:"FMOVD [$]f64\\.4048800000000000\\(SB\\)" + // ppc64x/power9:"FMOVD [$]f64\\.4048800000000000\\(SB\\)" + // ppc64x/power10:"XXSPLTIDP [$]1111752704," return 49.0 } func Float32DenormalConstant() float32 { - // ppc64x:"FMOVS\t[$]f32\\.00400000\\(SB\\)" + // ppc64x:"FMOVS [$]f32\\.00400000\\(SB\\)" return 0x1p-127 } @@ -262,18 +262,18 @@ func Float32DenormalConstant() float32 { // denormal float32 value. On ppc64x, denormal values cannot // be used with XXSPLTIDP. func Float64DenormalFloat32Constant() float64 { - // ppc64x:"FMOVD\t[$]f64\\.3800000000000000\\(SB\\)" + // ppc64x:"FMOVD [$]f64\\.3800000000000000\\(SB\\)" return 0x1p-127 } func Float32ConstantStore(p *float32) { - // amd64:"MOVL\t[$]1085133554" - // riscv64: "MOVF\t[$]f32.40add2f2" + // amd64:"MOVL [$]1085133554" + // riscv64: "MOVF [$]f32.40add2f2" *p = 5.432 } func Float64ConstantStore(p *float64) { - // amd64: "MOVQ\t[$]4617801906721357038" - // riscv64: "MOVD\t[$]f64.4015ba5e353f7cee" + // amd64: "MOVQ [$]4617801906721357038" + // riscv64: "MOVD [$]f64.4015ba5e353f7cee" *p = 5.432 } diff --git a/test/codegen/fuse.go b/test/codegen/fuse.go index 561bac7224..4fbb03bef8 100644 --- a/test/codegen/fuse.go +++ b/test/codegen/fuse.go @@ -19,57 +19,57 @@ import "math" // ---------------------------------- // func si1c(c <-chan int64) { - // amd64:"CMPQ\t.+, [$]256" - // s390x:"CLGIJ\t[$]12, R[0-9]+, [$]255" + // amd64:"CMPQ .+, [$]256" + // s390x:"CLGIJ [$]12, R[0-9]+, [$]255" for x := <-c; x >= 0 && x < 256; x = <-c { } } func si2c(c <-chan int32) { - // amd64:"CMPL\t.+, [$]256" - // s390x:"CLIJ\t[$]12, R[0-9]+, [$]255" + // amd64:"CMPL .+, [$]256" + // s390x:"CLIJ [$]12, R[0-9]+, [$]255" for x := <-c; x >= 0 && x < 256; x = <-c { } } func si3c(c <-chan int16) { - // amd64:"CMPW\t.+, [$]256" - // s390x:"CLIJ\t[$]12, R[0-9]+, [$]255" + // amd64:"CMPW .+, [$]256" + // s390x:"CLIJ [$]12, R[0-9]+, [$]255" for x := <-c; x >= 0 && x < 256; x = <-c { } } func si4c(c <-chan int8) { - // amd64:"CMPB\t.+, [$]10" - // s390x:"CLIJ\t[$]4, R[0-9]+, [$]10" + // amd64:"CMPB .+, [$]10" + // s390x:"CLIJ [$]4, R[0-9]+, [$]10" for x := <-c; x >= 0 && x < 10; x = <-c { } } func si5c(c <-chan int64) { - // amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5," - // s390x:"CLGIJ\t[$]4, R[0-9]+, [$]251","ADD\t[$]-5," + // amd64:"CMPQ .+, [$]251" "ADDQ [$]-5," + // s390x:"CLGIJ [$]4, R[0-9]+, [$]251" "ADD [$]-5," for x := <-c; x < 256 && x > 4; x = <-c { } } func si6c(c <-chan int32) { - // amd64:"CMPL\t.+, [$]255","DECL\t" - // s390x:"CLIJ\t[$]12, R[0-9]+, [$]255","ADDW\t[$]-1," + // amd64:"CMPL .+, [$]255" "DECL " + // s390x:"CLIJ [$]12, R[0-9]+, [$]255" "ADDW [$]-1," for x := <-c; x > 0 && x <= 256; x = <-c { } } func si7c(c <-chan int16) { - // amd64:"CMPW\t.+, [$]60","ADDL\t[$]10," - // s390x:"CLIJ\t[$]12, R[0-9]+, [$]60","ADDW\t[$]10," + // amd64:"CMPW .+, [$]60" "ADDL [$]10," + // s390x:"CLIJ [$]12, R[0-9]+, [$]60" "ADDW [$]10," for x := <-c; x >= -10 && x <= 50; x = <-c { } } func si8c(c <-chan int8) { - // amd64:"CMPB\t.+, [$]126","ADDL\t[$]126," - // s390x:"CLIJ\t[$]4, R[0-9]+, [$]126","ADDW\t[$]126," + // amd64:"CMPB .+, [$]126" "ADDL [$]126," + // s390x:"CLIJ [$]4, R[0-9]+, [$]126" "ADDW [$]126," for x := <-c; x >= -126 && x < 0; x = <-c { } } @@ -79,57 +79,57 @@ func si8c(c <-chan int8) { // ---------------------------------- // func si1d(c <-chan int64) { - // amd64:"CMPQ\t.+, [$]256" - // s390x:"CLGIJ\t[$]2, R[0-9]+, [$]255" + // amd64:"CMPQ .+, [$]256" + // s390x:"CLGIJ [$]2, R[0-9]+, [$]255" for x := <-c; x < 0 || x >= 256; x = <-c { } } func si2d(c <-chan int32) { - // amd64:"CMPL\t.+, [$]256" - // s390x:"CLIJ\t[$]2, R[0-9]+, [$]255" + // amd64:"CMPL .+, [$]256" + // s390x:"CLIJ [$]2, R[0-9]+, [$]255" for x := <-c; x < 0 || x >= 256; x = <-c { } } func si3d(c <-chan int16) { - // amd64:"CMPW\t.+, [$]256" - // s390x:"CLIJ\t[$]2, R[0-9]+, [$]255" + // amd64:"CMPW .+, [$]256" + // s390x:"CLIJ [$]2, R[0-9]+, [$]255" for x := <-c; x < 0 || x >= 256; x = <-c { } } func si4d(c <-chan int8) { - // amd64:"CMPB\t.+, [$]10" - // s390x:"CLIJ\t[$]10, R[0-9]+, [$]10" + // amd64:"CMPB .+, [$]10" + // s390x:"CLIJ [$]10, R[0-9]+, [$]10" for x := <-c; x < 0 || x >= 10; x = <-c { } } func si5d(c <-chan int64) { - // amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5," - // s390x:"CLGIJ\t[$]10, R[0-9]+, [$]251","ADD\t[$]-5," + // amd64:"CMPQ .+, [$]251" "ADDQ [$]-5," + // s390x:"CLGIJ [$]10, R[0-9]+, [$]251" "ADD [$]-5," for x := <-c; x >= 256 || x <= 4; x = <-c { } } func si6d(c <-chan int32) { - // amd64:"CMPL\t.+, [$]255","DECL\t" - // s390x:"CLIJ\t[$]2, R[0-9]+, [$]255","ADDW\t[$]-1," + // amd64:"CMPL .+, [$]255" "DECL " + // s390x:"CLIJ [$]2, R[0-9]+, [$]255" "ADDW [$]-1," for x := <-c; x <= 0 || x > 256; x = <-c { } } func si7d(c <-chan int16) { - // amd64:"CMPW\t.+, [$]60","ADDL\t[$]10," - // s390x:"CLIJ\t[$]2, R[0-9]+, [$]60","ADDW\t[$]10," + // amd64:"CMPW .+, [$]60" "ADDL [$]10," + // s390x:"CLIJ [$]2, R[0-9]+, [$]60" "ADDW [$]10," for x := <-c; x < -10 || x > 50; x = <-c { } } func si8d(c <-chan int8) { - // amd64:"CMPB\t.+, [$]126","ADDL\t[$]126," - // s390x:"CLIJ\t[$]10, R[0-9]+, [$]126","ADDW\t[$]126," + // amd64:"CMPB .+, [$]126" "ADDL [$]126," + // s390x:"CLIJ [$]10, R[0-9]+, [$]126" "ADDW [$]126," for x := <-c; x < -126 || x >= 0; x = <-c { } } @@ -139,29 +139,29 @@ func si8d(c <-chan int8) { // ------------------------------------ // func ui1c(c <-chan uint64) { - // amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5," - // s390x:"CLGIJ\t[$]4, R[0-9]+, [$]251","ADD\t[$]-5," + // amd64:"CMPQ .+, [$]251" "ADDQ [$]-5," + // s390x:"CLGIJ [$]4, R[0-9]+, [$]251" "ADD [$]-5," for x := <-c; x < 256 && x > 4; x = <-c { } } func ui2c(c <-chan uint32) { - // amd64:"CMPL\t.+, [$]255","DECL\t" - // s390x:"CLIJ\t[$]12, R[0-9]+, [$]255","ADDW\t[$]-1," + // amd64:"CMPL .+, [$]255" "DECL " + // s390x:"CLIJ [$]12, R[0-9]+, [$]255" "ADDW [$]-1," for x := <-c; x > 0 && x <= 256; x = <-c { } } func ui3c(c <-chan uint16) { - // amd64:"CMPW\t.+, [$]40","ADDL\t[$]-10," - // s390x:"CLIJ\t[$]12, R[0-9]+, [$]40","ADDW\t[$]-10," + // amd64:"CMPW .+, [$]40" "ADDL [$]-10," + // s390x:"CLIJ [$]12, R[0-9]+, [$]40" "ADDW [$]-10," for x := <-c; x >= 10 && x <= 50; x = <-c { } } func ui4c(c <-chan uint8) { - // amd64:"CMPB\t.+, [$]2","ADDL\t[$]-126," - // s390x:"CLIJ\t[$]4, R[0-9]+, [$]2","ADDW\t[$]-126," + // amd64:"CMPB .+, [$]2" "ADDL [$]-126," + // s390x:"CLIJ [$]4, R[0-9]+, [$]2" "ADDW [$]-126," for x := <-c; x >= 126 && x < 128; x = <-c { } } @@ -171,29 +171,29 @@ func ui4c(c <-chan uint8) { // ------------------------------------ // func ui1d(c <-chan uint64) { - // amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5," - // s390x:"CLGIJ\t[$]10, R[0-9]+, [$]251","ADD\t[$]-5," + // amd64:"CMPQ .+, [$]251" "ADDQ [$]-5," + // s390x:"CLGIJ [$]10, R[0-9]+, [$]251" "ADD [$]-5," for x := <-c; x >= 256 || x <= 4; x = <-c { } } func ui2d(c <-chan uint32) { - // amd64:"CMPL\t.+, [$]254","ADDL\t[$]-2," - // s390x:"CLIJ\t[$]2, R[0-9]+, [$]254","ADDW\t[$]-2," + // amd64:"CMPL .+, [$]254" "ADDL [$]-2," + // s390x:"CLIJ [$]2, R[0-9]+, [$]254" "ADDW [$]-2," for x := <-c; x <= 1 || x > 256; x = <-c { } } func ui3d(c <-chan uint16) { - // amd64:"CMPW\t.+, [$]40","ADDL\t[$]-10," - // s390x:"CLIJ\t[$]2, R[0-9]+, [$]40","ADDW\t[$]-10," + // amd64:"CMPW .+, [$]40" "ADDL [$]-10," + // s390x:"CLIJ [$]2, R[0-9]+, [$]40" "ADDW [$]-10," for x := <-c; x < 10 || x > 50; x = <-c { } } func ui4d(c <-chan uint8) { - // amd64:"CMPB\t.+, [$]2","ADDL\t[$]-126," - // s390x:"CLIJ\t[$]10, R[0-9]+, [$]2","ADDW\t[$]-126," + // amd64:"CMPB .+, [$]2" "ADDL [$]-126," + // s390x:"CLIJ [$]10, R[0-9]+, [$]2" "ADDW [$]-126," for x := <-c; x < 126 || x >= 128; x = <-c { } } @@ -205,8 +205,8 @@ func ui4d(c <-chan uint8) { func f64NaNOrPosInf(c <-chan float64) { // This test assumes IsInf(x, 1) is implemented as x > MaxFloat rather than x == Inf(1). - // amd64:"JCS",-"JNE",-"JPS",-"JPC" - // riscv64:"FCLASSD",-"FLED",-"FLTD",-"FNED",-"FEQD" + // amd64:"JCS" -"JNE" -"JPS" -"JPC" + // riscv64:"FCLASSD" -"FLED" -"FLTD" -"FNED" -"FEQD" for x := <-c; math.IsNaN(x) || math.IsInf(x, 1); x = <-c { } } @@ -214,64 +214,64 @@ func f64NaNOrPosInf(c <-chan float64) { func f64NaNOrNegInf(c <-chan float64) { // This test assumes IsInf(x, -1) is implemented as x < -MaxFloat rather than x == Inf(-1). - // amd64:"JCS",-"JNE",-"JPS",-"JPC" - // riscv64:"FCLASSD",-"FLED",-"FLTD",-"FNED",-"FEQD" + // amd64:"JCS" -"JNE" -"JPS" -"JPC" + // riscv64:"FCLASSD" -"FLED" -"FLTD" -"FNED" -"FEQD" for x := <-c; math.IsNaN(x) || math.IsInf(x, -1); x = <-c { } } func f64NaNOrLtOne(c <-chan float64) { - // amd64:"JCS",-"JNE",-"JPS",-"JPC" - // riscv64:"FLED",-"FLTD",-"FNED",-"FEQD" + // amd64:"JCS" -"JNE" -"JPS" -"JPC" + // riscv64:"FLED" -"FLTD" -"FNED" -"FEQD" for x := <-c; math.IsNaN(x) || x < 1; x = <-c { } } func f64NaNOrLteOne(c <-chan float64) { - // amd64:"JLS",-"JNE",-"JPS",-"JPC" - // riscv64:"FLTD",-"FLED",-"FNED",-"FEQD" + // amd64:"JLS" -"JNE" -"JPS" -"JPC" + // riscv64:"FLTD" -"FLED" -"FNED" -"FEQD" for x := <-c; x <= 1 || math.IsNaN(x); x = <-c { } } func f64NaNOrGtOne(c <-chan float64) { - // amd64:"JCS",-"JNE",-"JPS",-"JPC" - // riscv64:"FLED",-"FLTD",-"FNED",-"FEQD" + // amd64:"JCS" -"JNE" -"JPS" -"JPC" + // riscv64:"FLED" -"FLTD" -"FNED" -"FEQD" for x := <-c; math.IsNaN(x) || x > 1; x = <-c { } } func f64NaNOrGteOne(c <-chan float64) { - // amd64:"JLS",-"JNE",-"JPS",-"JPC" - // riscv64:"FLTD",-"FLED",-"FNED",-"FEQD" + // amd64:"JLS" -"JNE" -"JPS" -"JPC" + // riscv64:"FLTD" -"FLED" -"FNED" -"FEQD" for x := <-c; x >= 1 || math.IsNaN(x); x = <-c { } } func f32NaNOrLtOne(c <-chan float32) { - // amd64:"JCS",-"JNE",-"JPS",-"JPC" - // riscv64:"FLES",-"FLTS",-"FNES",-"FEQS" + // amd64:"JCS" -"JNE" -"JPS" -"JPC" + // riscv64:"FLES" -"FLTS" -"FNES" -"FEQS" for x := <-c; x < 1 || x != x; x = <-c { } } func f32NaNOrLteOne(c <-chan float32) { - // amd64:"JLS",-"JNE",-"JPS",-"JPC" - // riscv64:"FLTS",-"FLES",-"FNES",-"FEQS" + // amd64:"JLS" -"JNE" -"JPS" -"JPC" + // riscv64:"FLTS" -"FLES" -"FNES" -"FEQS" for x := <-c; x != x || x <= 1; x = <-c { } } func f32NaNOrGtOne(c <-chan float32) { - // amd64:"JCS",-"JNE",-"JPS",-"JPC" - // riscv64:"FLES",-"FLTS",-"FNES",-"FEQS" + // amd64:"JCS" -"JNE" -"JPS" -"JPC" + // riscv64:"FLES" -"FLTS" -"FNES" -"FEQS" for x := <-c; x > 1 || x != x; x = <-c { } } func f32NaNOrGteOne(c <-chan float32) { - // amd64:"JLS",-"JNE",-"JPS",-"JPC" - // riscv64:"FLTS",-"FLES",-"FNES",-"FEQS" + // amd64:"JLS" -"JNE" -"JPS" -"JPC" + // riscv64:"FLTS" -"FLES" -"FNES" -"FEQS" for x := <-c; x != x || x >= 1; x = <-c { } } @@ -291,8 +291,8 @@ func lt20(x uint64) bool { func issue74915(c <-chan uint64) { // Check that the optimization is not blocked by function inlining. - // amd64:"CMPQ\t.+, [$]16","ADDQ\t[$]-4," - // s390x:"CLGIJ\t[$]4, R[0-9]+, [$]16","ADD\t[$]-4," + // amd64:"CMPQ .+, [$]16" "ADDQ [$]-4," + // s390x:"CLGIJ [$]4, R[0-9]+, [$]16" "ADD [$]-4," for x := <-c; gte4(x) && lt20(x); x = <-c { } } diff --git a/test/codegen/ifaces.go b/test/codegen/ifaces.go index cc67a04740..59139ceab3 100644 --- a/test/codegen/ifaces.go +++ b/test/codegen/ifaces.go @@ -21,20 +21,20 @@ func NopConvertGeneric[T any](x T) T { var NopConvertGenericIface = NopConvertGeneric[I] func ConvToM(x any) I { - // amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(.*\)`,`MOVQ\t8\(.*\)(.*\*1)` - // arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU`,`MOVD\t\(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\tEQ` + // arm64:-`.*faceeq`,`CSET EQ` return x == y } func e2(x any, y *int) bool { // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET\tEQ` + // arm64:-`.*faceeq`,`CSET EQ` return y == x } @@ -42,7 +42,7 @@ type E *int func e3(x any, y E) bool { // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET\tEQ` + // arm64:-`.*faceeq`,`CSET EQ` return x == y } @@ -52,12 +52,12 @@ func (t *T) M() {} func i1(x I, y *T) bool { // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET\tEQ` + // arm64:-`.*faceeq`,`CSET EQ` return x == y } func i2(x I, y *T) bool { // amd64:-`.*faceeq`,`SETEQ` - // arm64:-`.*faceeq`,`CSET\tEQ` + // arm64:-`.*faceeq`,`CSET EQ` return y == x } diff --git a/test/codegen/issue25378.go b/test/codegen/issue25378.go index 810a022722..ddb5cecc40 100644 --- a/test/codegen/issue25378.go +++ b/test/codegen/issue25378.go @@ -14,9 +14,9 @@ var wsp = [256]bool{ } func zeroExtArgByte(ch [2]byte) bool { - return wsp[ch[0]] // amd64:-"MOVBLZX\t..,.." + return wsp[ch[0]] // amd64:-"MOVBLZX ..,.." } func zeroExtArgUint16(ch [2]uint16) bool { - return wsp[ch[0]] // amd64:-"MOVWLZX\t..,.." + return wsp[ch[0]] // amd64:-"MOVWLZX ..,.." } diff --git a/test/codegen/issue52635.go b/test/codegen/issue52635.go index 65f2a021d6..965b073210 100644 --- a/test/codegen/issue52635.go +++ b/test/codegen/issue52635.go @@ -17,31 +17,31 @@ type T struct { func (t *T) f() { // amd64:-".*runtime.memclrNoHeapPointers" - // amd64:`MOVUPS\tX15,` + // amd64:`MOVUPS X15,` for i := range t.a { t.a[i] = 0 } // amd64:-".*runtime.memclrNoHeapPointers" - // amd64:`MOVUPS\tX15,` + // amd64:`MOVUPS X15,` for i := range *t.a { t.a[i] = 0 } // amd64:-".*runtime.memclrNoHeapPointers" - // amd64:`MOVUPS\tX15,` + // amd64:`MOVUPS X15,` for i := range t.a { (*t.a)[i] = 0 } // amd64:-".*runtime.memclrNoHeapPointers" - // amd64:`MOVUPS\tX15,` + // amd64:`MOVUPS X15,` for i := range *t.a { (*t.a)[i] = 0 } // amd64:-".*runtime.memclrNoHeapPointers" - // amd64:`MOVUPS\tX15,` + // amd64:`MOVUPS X15,` for i := range t.b { t.b[i] = 0 } diff --git a/test/codegen/issue56440.go b/test/codegen/issue56440.go index 826dea8586..3d09688811 100644 --- a/test/codegen/issue56440.go +++ b/test/codegen/issue56440.go @@ -13,7 +13,7 @@ package codegen func f(x []int) int { s := make([]int, 3) s = append(s, 4, 5) - // amd64:`MOVQ\t40\(.*\),` + // amd64:`MOVQ 40\(.*\),` return x[len(s)] } @@ -26,7 +26,7 @@ func g(x []int, p *bool) int { } s = append(s, 4, 5) if *p { - // amd64:`MOVQ\t40\(.*\),` + // amd64:`MOVQ 40\(.*\),` return x[len(s)] } } diff --git a/test/codegen/issue60324.go b/test/codegen/issue60324.go index d106e7ecf8..ca62291015 100644 --- a/test/codegen/issue60324.go +++ b/test/codegen/issue60324.go @@ -7,30 +7,30 @@ package codegen func main() { - // amd64:"LEAQ\tcommand-line-arguments\\.main\\.f\\.g\\.h\\.func3" + // amd64:"LEAQ command-line-arguments\\.main\\.f\\.g\\.h\\.func3" f(1)() - // amd64:"LEAQ\tcommand-line-arguments\\.main\\.g\\.h\\.func2" + // amd64:"LEAQ command-line-arguments\\.main\\.g\\.h\\.func2" g(2)() - // amd64:"LEAQ\tcommand-line-arguments\\.main\\.h\\.func1" + // amd64:"LEAQ command-line-arguments\\.main\\.h\\.func1" h(3)() - // amd64:"LEAQ\tcommand-line-arguments\\.main\\.f\\.g\\.h\\.func4" + // amd64:"LEAQ command-line-arguments\\.main\\.f\\.g\\.h\\.func4" f(4)() } func f(x int) func() { - // amd64:"LEAQ\tcommand-line-arguments\\.f\\.g\\.h\\.func1" + // amd64:"LEAQ command-line-arguments\\.f\\.g\\.h\\.func1" return g(x) } func g(x int) func() { - // amd64:"LEAQ\tcommand-line-arguments\\.g\\.h\\.func1" + // amd64:"LEAQ command-line-arguments\\.g\\.h\\.func1" return h(x) } func h(x int) func() { - // amd64:"LEAQ\tcommand-line-arguments\\.h\\.func1" + // amd64:"LEAQ command-line-arguments\\.h\\.func1" return func() { recover() } } diff --git a/test/codegen/issue74485.go b/test/codegen/issue74485.go index b5aba9568c..b2877c822b 100644 --- a/test/codegen/issue74485.go +++ b/test/codegen/issue74485.go @@ -7,41 +7,41 @@ package codegen func divUint64(b uint64) uint64 { - // amd64:"SHRQ [$]63, AX" + // amd64:"SHRQ [$]63, AX" return b / 9223372036854775808 } func divUint32(b uint32) uint32 { - // amd64:"SHRL [$]31, AX" + // amd64:"SHRL [$]31, AX" return b / 2147483648 } func divUint16(b uint16) uint16 { - // amd64:"SHRW [$]15, AX" + // amd64:"SHRW [$]15, AX" return b / 32768 } func divUint8(b uint8) uint8 { - // amd64:"SHRB [$]7, AL" + // amd64:"SHRB [$]7, AL" return b / 128 } func modUint64(b uint64) uint64 { - // amd64:"BTRQ [$]63, AX" + // amd64:"BTRQ [$]63, AX" return b % 9223372036854775808 } func modUint32(b uint32) uint32 { - // amd64:"ANDL [$]2147483647, AX" + // amd64:"ANDL [$]2147483647, AX" return b % 2147483648 } func modUint16(b uint16) uint16 { - // amd64:"ANDL [$]32767, AX" + // amd64:"ANDL [$]32767, AX" return b % 32768 } func modUint8(b uint8) uint8 { - // amd64:"ANDL [$]127, AX" + // amd64:"ANDL [$]127, AX" return b % 128 } diff --git a/test/codegen/load_type_from_itab.go b/test/codegen/load_type_from_itab.go index b47044fcbd..4d56122c05 100644 --- a/test/codegen/load_type_from_itab.go +++ b/test/codegen/load_type_from_itab.go @@ -19,6 +19,6 @@ func (*Impl) A() {} func main() { var a M = &Impl{} - // amd64:`LEAQ\ttype:.*Impl` + // amd64:`LEAQ type:.*Impl` a.(A).A() } diff --git a/test/codegen/logic.go b/test/codegen/logic.go index ac33f91dad..1cd389bd2d 100644 --- a/test/codegen/logic.go +++ b/test/codegen/logic.go @@ -28,14 +28,14 @@ func ornot(x, y int) int { // Verify that (OR (NOT x) (NOT y)) rewrites to (NOT (AND x y)) func orDemorgans(x, y int) int { - // amd64:"AND",-"OR" + // amd64:"AND" -"OR" z := ^x | ^y return z } // Verify that (AND (NOT x) (NOT y)) rewrites to (NOT (OR x y)) func andDemorgans(x, y int) int { - // amd64:"OR",-"AND" + // amd64:"OR" -"AND" z := ^x & ^y return z } diff --git a/test/codegen/maps.go b/test/codegen/maps.go index 860b2c2cbd..fe38c99cb8 100644 --- a/test/codegen/maps.go +++ b/test/codegen/maps.go @@ -16,12 +16,12 @@ package codegen // Direct use of constants in fast map access calls (Issue #19015). func AccessInt1(m map[int]int) int { - // amd64:"MOV[LQ]\t[$]5" + // amd64:"MOV[LQ] [$]5" return m[5] } func AccessInt2(m map[int]int) bool { - // amd64:"MOV[LQ]\t[$]5" + // amd64:"MOV[LQ] [$]5" _, ok := m[5] return ok } @@ -147,7 +147,7 @@ func MapClearSideEffect(m map[int]int) int { func MapLiteralSizing(x int) (map[int]int, map[int]int) { // This is tested for internal/abi/maps.go:MapBucketCountBits={3,4,5} - // amd64:"MOVL\t[$]33," + // amd64:"MOVL [$]33," m := map[int]int{ 0: 0, 1: 1, @@ -183,7 +183,7 @@ func MapLiteralSizing(x int) (map[int]int, map[int]int) { 31: 32, 32: 32, } - // amd64:"MOVL\t[$]33," + // amd64:"MOVL [$]33," n := map[int]int{ 0: 0, 1: 1, diff --git a/test/codegen/math.go b/test/codegen/math.go index 9ef881a9af..ef8c51e658 100644 --- a/test/codegen/math.go +++ b/test/codegen/math.go @@ -12,37 +12,37 @@ var sink64 [8]float64 func approx(x float64) { // amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41" - // amd64:"ROUNDSD\t[$]2" - // s390x:"FIDBR\t[$]6" + // amd64:"ROUNDSD [$]2" + // s390x:"FIDBR [$]6" // arm64:"FRINTPD" // ppc64x:"FRIP" // wasm:"F64Ceil" sink64[0] = math.Ceil(x) // amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41" - // amd64:"ROUNDSD\t[$]1" - // s390x:"FIDBR\t[$]7" + // amd64:"ROUNDSD [$]1" + // s390x:"FIDBR [$]7" // arm64:"FRINTMD" // ppc64x:"FRIM" // wasm:"F64Floor" sink64[1] = math.Floor(x) - // s390x:"FIDBR\t[$]1" + // s390x:"FIDBR [$]1" // arm64:"FRINTAD" // ppc64x:"FRIN" sink64[2] = math.Round(x) // amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41" - // amd64:"ROUNDSD\t[$]3" - // s390x:"FIDBR\t[$]5" + // amd64:"ROUNDSD [$]3" + // s390x:"FIDBR [$]5" // arm64:"FRINTZD" // ppc64x:"FRIZ" // wasm:"F64Trunc" sink64[3] = math.Trunc(x) // amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41" - // amd64:"ROUNDSD\t[$]0" - // s390x:"FIDBR\t[$]4" + // amd64:"ROUNDSD [$]0" + // s390x:"FIDBR [$]4" // arm64:"FRINTND" // wasm:"F64Nearest" sink64[4] = math.RoundToEven(x) @@ -78,43 +78,43 @@ func sqrt32(x float32) float32 { // Check that it's using integer registers func abs(x, y float64) { - // amd64:"BTRQ\t[$]63" - // arm64:"FABSD\t" - // loong64:"ABSD\t" - // s390x:"LPDFR\t",-"MOVD\t" (no integer load/store) - // ppc64x:"FABS\t" - // riscv64:"FABSD\t" + // amd64:"BTRQ [$]63" + // arm64:"FABSD " + // loong64:"ABSD " + // s390x:"LPDFR " -"MOVD " (no integer load/store) + // ppc64x:"FABS " + // riscv64:"FABSD " // wasm:"F64Abs" - // arm/6:"ABSD\t" - // mips64/hardfloat:"ABSD\t" - // mips/hardfloat:"ABSD\t" + // arm/6:"ABSD " + // mips64/hardfloat:"ABSD " + // mips/hardfloat:"ABSD " sink64[0] = math.Abs(x) - // amd64:"BTRQ\t[$]63","PXOR" (TODO: this should be BTSQ) - // s390x:"LNDFR\t",-"MOVD\t" (no integer load/store) - // ppc64x:"FNABS\t" + // amd64:"BTRQ [$]63" "PXOR" (TODO: this should be BTSQ) + // s390x:"LNDFR " -"MOVD " (no integer load/store) + // ppc64x:"FNABS " sink64[1] = -math.Abs(y) } // Check that it's using integer registers func abs32(x float32) float32 { - // s390x:"LPDFR",-"LDEBR",-"LEDBR" (no float64 conversion) + // s390x:"LPDFR" -"LDEBR" -"LEDBR" (no float64 conversion) return float32(math.Abs(float64(x))) } // Check that it's using integer registers func copysign(a, b, c float64) { - // amd64:"BTRQ\t[$]63","ANDQ","ORQ" + // amd64:"BTRQ [$]63" "ANDQ" "ORQ" // loong64:"FCOPYSGD" - // s390x:"CPSDR",-"MOVD" (no integer load/store) + // s390x:"CPSDR" -"MOVD" (no integer load/store) // ppc64x:"FCPSGN" // riscv64:"FSGNJD" // wasm:"F64Copysign" sink64[0] = math.Copysign(a, b) - // amd64:"BTSQ\t[$]63" + // amd64:"BTSQ [$]63" // loong64:"FCOPYSGD" - // s390x:"LNDFR\t",-"MOVD\t" (no integer load/store) + // s390x:"LNDFR " -"MOVD " (no integer load/store) // ppc64x:"FCPSGN" // riscv64:"FSGNJD" // arm64:"ORR", -"AND" @@ -122,12 +122,12 @@ func copysign(a, b, c float64) { // Like math.Copysign(c, -1), but with integer operations. Useful // for platforms that have a copysign opcode to see if it's detected. - // s390x:"LNDFR\t",-"MOVD\t" (no integer load/store) + // s390x:"LNDFR " -"MOVD " (no integer load/store) sink64[2] = math.Float64frombits(math.Float64bits(a) | 1<<63) - // amd64:"ANDQ","ORQ" + // amd64:"ANDQ" "ORQ" // loong64:"FCOPYSGD" - // s390x:"CPSDR\t",-"MOVD\t" (no integer load/store) + // s390x:"CPSDR " -"MOVD " (no integer load/store) // ppc64x:"FCPSGN" // riscv64:"FSGNJD" sink64[3] = math.Copysign(-1, c) @@ -151,12 +151,12 @@ func fms(x, y, z float64) float64 { } func fnms(x, y, z float64) float64 { - // riscv64:"FNMSUBD",-"FNMADDD" + // riscv64:"FNMSUBD" -"FNMADDD" return math.FMA(-x, y, z) } func fnma(x, y, z float64) float64 { - // riscv64:"FNMADDD",-"FNMSUBD" + // riscv64:"FNMADDD" -"FNMSUBD" return math.FMA(x, -y, -z) } @@ -221,39 +221,39 @@ func isNotNegInfCmp(x float64) bool { } func fromFloat64(f64 float64) uint64 { - // amd64:"MOVQ\tX.*, [^X].*" - // arm64:"FMOVD\tF.*, R.*" - // loong64:"MOVV\tF.*, R.*" + // amd64:"MOVQ X.*, [^X].*" + // arm64:"FMOVD F.*, R.*" + // loong64:"MOVV F.*, R.*" // ppc64x:"MFVSRD" - // mips64/hardfloat:"MOVV\tF.*, R.*" + // mips64/hardfloat:"MOVV F.*, R.*" // riscv64:"FMVXD" return math.Float64bits(f64+1) + 1 } func fromFloat32(f32 float32) uint32 { - // amd64:"MOVL\tX.*, [^X].*" - // arm64:"FMOVS\tF.*, R.*" - // loong64:"MOVW\tF.*, R.*" - // mips64/hardfloat:"MOVW\tF.*, R.*" + // amd64:"MOVL X.*, [^X].*" + // arm64:"FMOVS F.*, R.*" + // loong64:"MOVW F.*, R.*" + // mips64/hardfloat:"MOVW F.*, R.*" // riscv64:"FMVXW" return math.Float32bits(f32+1) + 1 } func toFloat64(u64 uint64) float64 { - // amd64:"MOVQ\t[^X].*, X.*" - // arm64:"FMOVD\tR.*, F.*" - // loong64:"MOVV\tR.*, F.*" + // amd64:"MOVQ [^X].*, X.*" + // arm64:"FMOVD R.*, F.*" + // loong64:"MOVV R.*, F.*" // ppc64x:"MTVSRD" - // mips64/hardfloat:"MOVV\tR.*, F.*" + // mips64/hardfloat:"MOVV R.*, F.*" // riscv64:"FMVDX" return math.Float64frombits(u64+1) + 1 } func toFloat32(u32 uint32) float32 { - // amd64:"MOVL\t[^X].*, X.*" - // arm64:"FMOVS\tR.*, F.*" - // loong64:"MOVW\tR.*, F.*" - // mips64/hardfloat:"MOVW\tR.*, F.*" + // amd64:"MOVL [^X].*, X.*" + // arm64:"FMOVS R.*, F.*" + // loong64:"MOVW R.*, F.*" + // mips64/hardfloat:"MOVW R.*, F.*" // riscv64:"FMVWX" return math.Float32frombits(u32+1) + 1 } @@ -262,14 +262,14 @@ func toFloat32(u32 uint32) float32 { // are evaluated at compile-time func constantCheck64() bool { - // amd64:"(MOVB\t[$]0)|(XORL\t[A-Z][A-Z0-9]+, [A-Z][A-Z0-9]+)",-"FCMP",-"MOVB\t[$]1" - // s390x:"MOV(B|BZ|D)\t[$]0,",-"FCMPU",-"MOV(B|BZ|D)\t[$]1," + // amd64:"(MOVB [$]0)|(XORL [A-Z][A-Z0-9]+, [A-Z][A-Z0-9]+)" -"FCMP" -"MOVB [$]1" + // s390x:"MOV(B|BZ|D) [$]0," -"FCMPU" -"MOV(B|BZ|D) [$]1," return 0.5 == float64(uint32(1)) || 1.5 > float64(uint64(1<<63)) } func constantCheck32() bool { - // amd64:"MOV(B|L)\t[$]1",-"FCMP",-"MOV(B|L)\t[$]0" - // s390x:"MOV(B|BZ|D)\t[$]1,",-"FCMPU",-"MOV(B|BZ|D)\t[$]0," + // amd64:"MOV(B|L) [$]1" -"FCMP" -"MOV(B|L) [$]0" + // s390x:"MOV(B|BZ|D) [$]1," -"FCMPU" -"MOV(B|BZ|D) [$]0," return float32(0.5) <= float32(int64(1)) && float32(1.5) >= float32(int32(-1<<31)) } @@ -277,12 +277,12 @@ func constantCheck32() bool { // at compile-time func constantConvert32(x float32) float32 { - // amd64:"MOVSS\t[$]f32.3f800000\\(SB\\)" - // s390x:"FMOVS\t[$]f32.3f800000\\(SB\\)" - // ppc64x/power8:"FMOVS\t[$]f32.3f800000\\(SB\\)" - // ppc64x/power9:"FMOVS\t[$]f32.3f800000\\(SB\\)" - // ppc64x/power10:"XXSPLTIDP\t[$]1065353216, VS0" - // arm64:"FMOVS\t[$]\\(1.0\\)" + // amd64:"MOVSS [$]f32.3f800000\\(SB\\)" + // s390x:"FMOVS [$]f32.3f800000\\(SB\\)" + // ppc64x/power8:"FMOVS [$]f32.3f800000\\(SB\\)" + // ppc64x/power9:"FMOVS [$]f32.3f800000\\(SB\\)" + // ppc64x/power10:"XXSPLTIDP [$]1065353216, VS0" + // arm64:"FMOVS [$]\\(1.0\\)" if x > math.Float32frombits(0x3f800000) { return -x } @@ -343,7 +343,7 @@ func outOfBoundsConv(i32 *[2]int32, u32 *[2]uint32, i64 *[2]int64, u64 *[2]uint6 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. - // amd64: "MOVL\t[$]0," + // amd64: "MOVL [$]0," u32[1] = uint32(minus1()) // arm64: "FCVTZSD" // amd64: "CVTTSD2SQ" @@ -356,7 +356,7 @@ func outOfBoundsConv(i32 *[2]int32, u32 *[2]uint32, i64 *[2]int64, u64 *[2]uint6 u64[0] = uint64(two81()) // arm64: "FCVTZUD" // on amd64, this uses an explicit <0 comparison, so it constant folds. - // amd64: "MOVQ\t[$]0," + // amd64: "MOVQ [$]0," u64[1] = uint64(minus1()) } diff --git a/test/codegen/mathbits.go b/test/codegen/mathbits.go index f8fa374c0a..6f7014688a 100644 --- a/test/codegen/mathbits.go +++ b/test/codegen/mathbits.go @@ -20,10 +20,10 @@ func LeadingZeros(n uint) int { // amd64/v3:"LZCNTQ", -"BSRQ" // arm64:"CLZ" // arm:"CLZ" - // loong64:"CLZV",-"SUB" + // loong64:"CLZV" -"SUB" // mips:"CLZ" // ppc64x:"CNTLZD" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"SUB" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"SUB" // s390x:"FLOGR" // wasm:"I64Clz" return bits.LeadingZeros(n) @@ -34,52 +34,52 @@ func LeadingZeros64(n uint64) int { // amd64/v3:"LZCNTQ", -"BSRQ" // arm:"CLZ" // arm64:"CLZ" - // loong64:"CLZV",-"SUB" + // loong64:"CLZV" -"SUB" // mips:"CLZ" // ppc64x:"CNTLZD" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"ADDI" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"ADDI" // s390x:"FLOGR" // wasm:"I64Clz" return bits.LeadingZeros64(n) } func LeadingZeros32(n uint32) int { - // amd64/v1,amd64/v2:"BSRQ","LEAQ",-"CMOVQEQ" - // amd64/v3: "LZCNTL",- "BSRL" + // amd64/v1,amd64/v2:"BSRQ" "LEAQ" -"CMOVQEQ" + // amd64/v3: "LZCNTL" - "BSRL" // arm:"CLZ" // arm64:"CLZW" - // loong64:"CLZW",-"SUB" + // loong64:"CLZW" -"SUB" // mips:"CLZ" // ppc64x:"CNTLZW" - // riscv64/rva22u64,riscv64/rva23u64:"CLZW",-"ADDI" + // riscv64/rva22u64,riscv64/rva23u64:"CLZW" -"ADDI" // s390x:"FLOGR" // wasm:"I64Clz" return bits.LeadingZeros32(n) } func LeadingZeros16(n uint16) int { - // amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ" - // amd64/v3: "LZCNTL",- "BSRL" + // amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ" + // amd64/v3: "LZCNTL" - "BSRL" // arm64:"CLZ" // arm:"CLZ" // loong64:"CLZV" // mips:"CLZ" // ppc64x:"CNTLZD" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-48",-"NEG" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-48" -"NEG" // s390x:"FLOGR" // wasm:"I64Clz" return bits.LeadingZeros16(n) } func LeadingZeros8(n uint8) int { - // amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ" - // amd64/v3: "LZCNTL",- "BSRL" + // amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ" + // amd64/v3: "LZCNTL" - "BSRL" // arm64:"CLZ" // arm:"CLZ" // loong64:"CLZV" // mips:"CLZ" // ppc64x:"CNTLZD" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-56",-"NEG" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-56" -"NEG" // s390x:"FLOGR" // wasm:"I64Clz" return bits.LeadingZeros8(n) @@ -96,8 +96,8 @@ func Len(n uint) int { // arm:"CLZ" // loong64:"CLZV" // mips:"CLZ" - // ppc64x:"SUBC","CNTLZD" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64" + // ppc64x:"SUBC" "CNTLZD" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64" // s390x:"FLOGR" // wasm:"I64Clz" return bits.Len(n) @@ -110,62 +110,62 @@ func Len64(n uint64) int { // arm:"CLZ" // loong64:"CLZV" // mips:"CLZ" - // ppc64x:"SUBC","CNTLZD" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64" + // ppc64x:"SUBC" "CNTLZD" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64" // s390x:"FLOGR" // wasm:"I64Clz" return bits.Len64(n) } func SubFromLen64(n uint64) int { - // loong64:"CLZV",-"ADD" - // ppc64x:"CNTLZD",-"SUBC" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"ADDI",-"NEG" + // loong64:"CLZV" -"ADD" + // ppc64x:"CNTLZD" -"SUBC" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"ADDI" -"NEG" return 64 - bits.Len64(n) } func CompareWithLen64(n uint64) bool { - // loong64:"CLZV",-"ADD",-"[$]64",-"[$]9" + // loong64:"CLZV" -"ADD" -"[$]64" -"[$]9" return bits.Len64(n) < 9 } func Len32(n uint32) int { - // amd64/v1,amd64/v2:"BSRQ","LEAQ",-"CMOVQEQ" + // amd64/v1,amd64/v2:"BSRQ" "LEAQ" -"CMOVQEQ" // amd64/v3: "LZCNTL" // arm64:"CLZ" // arm:"CLZ" // loong64:"CLZW" // mips:"CLZ" // ppc64x: "CNTLZW" - // riscv64/rva22u64,riscv64/rva23u64:"CLZW","ADDI\t\\$-32" + // riscv64/rva22u64,riscv64/rva23u64:"CLZW" "ADDI [$]-32" // s390x:"FLOGR" // wasm:"I64Clz" return bits.Len32(n) } func Len16(n uint16) int { - // amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ" + // amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ" // amd64/v3: "LZCNTL" // arm64:"CLZ" // arm:"CLZ" // loong64:"CLZV" // mips:"CLZ" - // ppc64x:"SUBC","CNTLZD" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64" + // ppc64x:"SUBC" "CNTLZD" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64" // s390x:"FLOGR" // wasm:"I64Clz" return bits.Len16(n) } func Len8(n uint8) int { - // amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ" + // amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ" // amd64/v3: "LZCNTL" // arm64:"CLZ" // arm:"CLZ" // loong64:"CLZV" // mips:"CLZ" - // ppc64x:"SUBC","CNTLZD" - // riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64" + // ppc64x:"SUBC" "CNTLZD" + // riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64" // s390x:"FLOGR" // wasm:"I64Clz" return bits.Len8(n) @@ -179,10 +179,10 @@ func Len8(n uint8) int { func OnesCount(n uint) int { // amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT" // amd64:"POPCNTQ" - // arm64:"VCNT","VUADDLV" + // arm64:"VCNT" "VUADDLV" // loong64:"VPCNTV" // ppc64x:"POPCNTD" - // riscv64:"CPOP\t" + // riscv64:"CPOP " // s390x:"POPCNT" // wasm:"I64Popcnt" return bits.OnesCount(n) @@ -191,10 +191,10 @@ func OnesCount(n uint) int { func OnesCount64(n uint64) int { // amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT" // amd64:"POPCNTQ" - // arm64:"VCNT","VUADDLV" + // arm64:"VCNT" "VUADDLV" // loong64:"VPCNTV" // ppc64x:"POPCNTD" - // riscv64:"CPOP\t" + // riscv64:"CPOP " // s390x:"POPCNT" // wasm:"I64Popcnt" return bits.OnesCount64(n) @@ -203,7 +203,7 @@ func OnesCount64(n uint64) int { func OnesCount32(n uint32) int { // amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT" // amd64:"POPCNTL" - // arm64:"VCNT","VUADDLV" + // arm64:"VCNT" "VUADDLV" // loong64:"VPCNTW" // ppc64x:"POPCNTW" // riscv64:"CPOPW" @@ -215,10 +215,10 @@ func OnesCount32(n uint32) int { func OnesCount16(n uint16) int { // amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT" // amd64:"POPCNTL" - // arm64:"VCNT","VUADDLV" + // arm64:"VCNT" "VUADDLV" // loong64:"VPCNTH" // ppc64x:"POPCNTW" - // riscv64:"CPOP\t" + // riscv64:"CPOP " // s390x:"POPCNT" // wasm:"I64Popcnt" return bits.OnesCount16(n) @@ -226,7 +226,7 @@ func OnesCount16(n uint16) int { func OnesCount8(n uint8) int { // ppc64x:"POPCNTB" - // riscv64/rva22u64,riscv64/rva23u64:"CPOP\t" + // riscv64/rva22u64,riscv64/rva23u64:"CPOP " // s390x:"POPCNT" // wasm:"I64Popcnt" return bits.OnesCount8(n) @@ -252,7 +252,7 @@ func Reverse32(n uint32) uint32 { } func Reverse16(n uint16) uint16 { - // loong64:"BITREV4B","REVB2H" + // loong64:"BITREV4B" "REVB2H" return bits.Reverse16(n) } @@ -292,20 +292,20 @@ func ReverseBytes32(n uint32) uint32 { // arm64:"REVW" // loong64:"REVB2W" // ppc64x/power10: "BRW" - // riscv64/rva22u64,riscv64/rva23u64:"REV8","SRLI\t\\$32" + // riscv64/rva22u64,riscv64/rva23u64:"REV8" "SRLI [$]32" // s390x:"MOVWBR" return bits.ReverseBytes32(n) } func ReverseBytes16(n uint16) uint16 { // amd64:"ROLW" - // arm/5:"SLL","SRL","ORR" + // arm/5:"SLL" "SRL" "ORR" // arm/6:"REV16" // arm/7:"REV16" - // arm64:"REV16W",-"UBFX",-"ORR" + // arm64:"REV16W" -"UBFX" -"ORR" // loong64:"REVB2H" // ppc64x/power10: "BRH" - // riscv64/rva22u64,riscv64/rva23u64:"REV8","SRLI\t\\$48" + // riscv64/rva22u64,riscv64/rva23u64:"REV8" "SRLI [$]48" return bits.ReverseBytes16(n) } @@ -319,16 +319,16 @@ func RotateLeft64(n uint64) uint64 { // loong64:"ROTRV" // ppc64x:"ROTL" // riscv64:"RORI" - // s390x:"RISBGZ\t[$]0, [$]63, [$]37, " + // s390x:"RISBGZ [$]0, [$]63, [$]37, " // wasm:"I64Rotl" return bits.RotateLeft64(n, 37) } func RotateLeft32(n uint32) uint32 { // amd64:"ROLL" 386:"ROLL" - // arm:`MOVW\tR[0-9]+@>23` + // arm:`MOVW R[0-9]+@>23` // arm64:"RORW" - // loong64:"ROTR\t" + // loong64:"ROTR " // ppc64x:"ROTLW" // riscv64:"RORIW" // s390x:"RLL" @@ -338,15 +338,15 @@ func RotateLeft32(n uint32) uint32 { func RotateLeft16(n uint16, s int) uint16 { // amd64:"ROLW" 386:"ROLW" - // arm64:"RORW",-"CSEL" - // loong64:"ROTR\t","SLLV" + // arm64:"RORW" -"CSEL" + // loong64:"ROTR " "SLLV" return bits.RotateLeft16(n, s) } func RotateLeft8(n uint8, s int) uint8 { // amd64:"ROLB" 386:"ROLB" - // arm64:"LSL","LSR",-"CSEL" - // loong64:"OR","SLLV","SRLV" + // arm64:"LSL" "LSR" -"CSEL" + // loong64:"OR" "SLLV" "SRLV" return bits.RotateLeft8(n, s) } @@ -373,10 +373,10 @@ func RotateLeftVariable64(n uint64, m int) uint64 { } func RotateLeftVariable32(n uint32, m int) uint32 { - // arm:`MOVW\tR[0-9]+@>R[0-9]+` + // arm:`MOVW R[0-9]+@>R[0-9]+` // amd64:"ROLL" // arm64:"RORW" - // loong64:"ROTR\t" + // loong64:"ROTR " // ppc64x:"ROTLW" // riscv64:"ROLW" // s390x:"RLL" @@ -390,78 +390,78 @@ func RotateLeftVariable32(n uint32, m int) uint32 { func TrailingZeros(n uint) int { // 386:"BSFL" - // amd64/v1,amd64/v2:"BSFQ","MOVL\t\\$64","CMOVQEQ" + // amd64/v1,amd64/v2:"BSFQ" "MOVL [$]64" "CMOVQEQ" // amd64/v3:"TZCNTQ" // arm:"CLZ" - // arm64:"RBIT","CLZ" + // arm64:"RBIT" "CLZ" // loong64:"CTZV" - // ppc64x/power8:"ANDN","POPCNTD" + // ppc64x/power8:"ANDN" "POPCNTD" // ppc64x/power9: "CNTTZD" - // riscv64/rva22u64,riscv64/rva23u64: "CTZ\t" + // riscv64/rva22u64,riscv64/rva23u64: "CTZ " // s390x:"FLOGR" // wasm:"I64Ctz" return bits.TrailingZeros(n) } func TrailingZeros64(n uint64) int { - // 386:"BSFL","JNE" - // amd64/v1,amd64/v2:"BSFQ","MOVL\t\\$64","CMOVQEQ" + // 386:"BSFL" "JNE" + // amd64/v1,amd64/v2:"BSFQ" "MOVL [$]64" "CMOVQEQ" // amd64/v3:"TZCNTQ" - // arm64:"RBIT","CLZ" + // arm64:"RBIT" "CLZ" // loong64:"CTZV" - // ppc64x/power8:"ANDN","POPCNTD" + // ppc64x/power8:"ANDN" "POPCNTD" // ppc64x/power9: "CNTTZD" - // riscv64/rva22u64,riscv64/rva23u64: "CTZ\t" + // riscv64/rva22u64,riscv64/rva23u64: "CTZ " // s390x:"FLOGR" // wasm:"I64Ctz" return bits.TrailingZeros64(n) } func TrailingZeros64Subtract(n uint64) int { - // ppc64x/power8:"NEG","SUBC","ANDN","POPCNTD" - // ppc64x/power9:"SUBC","CNTTZD" + // ppc64x/power8:"NEG" "SUBC" "ANDN" "POPCNTD" + // ppc64x/power9:"SUBC" "CNTTZD" return bits.TrailingZeros64(1 - n) } func TrailingZeros32(n uint32) int { // 386:"BSFL" - // amd64/v1,amd64/v2:"BTSQ\\t\\$32","BSFQ" + // amd64/v1,amd64/v2:"BTSQ [$]32" "BSFQ" // amd64/v3:"TZCNTL" // arm:"CLZ" - // arm64:"RBITW","CLZW" + // arm64:"RBITW" "CLZW" // loong64:"CTZW" - // ppc64x/power8:"ANDN","POPCNTW" + // ppc64x/power8:"ANDN" "POPCNTW" // ppc64x/power9: "CNTTZW" // riscv64/rva22u64,riscv64/rva23u64: "CTZW" - // s390x:"FLOGR","MOVWZ" + // s390x:"FLOGR" "MOVWZ" // wasm:"I64Ctz" return bits.TrailingZeros32(n) } func TrailingZeros16(n uint16) int { - // 386:"BSFL\t" - // amd64:"BSFL","ORL\\t\\$65536" - // arm:"ORR\t\\$65536","CLZ",-"MOVHU\tR" - // arm64:"ORR\t\\$65536","RBITW","CLZW",-"MOVHU\tR",-"RBIT\t",-"CLZ\t" + // 386:"BSFL " + // amd64:"BSFL" "ORL [$]65536" + // arm:"ORR [$]65536" "CLZ" -"MOVHU R" + // arm64:"ORR [$]65536" "RBITW" "CLZW" -"MOVHU R" -"RBIT " -"CLZ " // loong64:"CTZV" - // ppc64x/power8:"POPCNTW","ADD\t\\$-1" - // ppc64x/power9:"CNTTZD","ORIS\\t\\$1" - // riscv64/rva22u64,riscv64/rva23u64: "ORI\t\\$65536","CTZW" - // s390x:"FLOGR","OR\t\\$65536" + // ppc64x/power8:"POPCNTW" "ADD [$]-1" + // ppc64x/power9:"CNTTZD" "ORIS [$]1" + // riscv64/rva22u64,riscv64/rva23u64: "ORI [$]65536" "CTZW" + // s390x:"FLOGR" "OR [$]65536" // wasm:"I64Ctz" return bits.TrailingZeros16(n) } func TrailingZeros8(n uint8) int { // 386:"BSFL" - // amd64:"BSFL","ORL\\t\\$256" - // arm:"ORR\t\\$256","CLZ",-"MOVBU\tR" - // arm64:"ORR\t\\$256","RBITW","CLZW",-"MOVBU\tR",-"RBIT\t",-"CLZ\t" + // amd64:"BSFL" "ORL [$]256" + // arm:"ORR [$]256" "CLZ" -"MOVBU R" + // arm64:"ORR [$]256" "RBITW" "CLZW" -"MOVBU R" -"RBIT " -"CLZ " // loong64:"CTZV" - // ppc64x/power8:"POPCNTB","ADD\t\\$-1" - // ppc64x/power9:"CNTTZD","OR\t\\$256" - // riscv64/rva22u64,riscv64/rva23u64: "ORI\t\\$256","CTZW" - // s390x:"FLOGR","OR\t\\$256" + // ppc64x/power8:"POPCNTB" "ADD [$]-1" + // ppc64x/power9:"CNTTZD" "OR [$]256" + // riscv64/rva22u64,riscv64/rva23u64: "ORI [$]256" "CTZW" + // s390x:"FLOGR" "OR [$]256" // wasm:"I64Ctz" return bits.TrailingZeros8(n) } @@ -471,7 +471,7 @@ func TrailingZeros8(n uint8) int { func IterateBits(n uint) int { i := 0 for n != 0 { - // amd64/v1,amd64/v2:"BSFQ",-"CMOVEQ" + // amd64/v1,amd64/v2:"BSFQ" -"CMOVEQ" // amd64/v3:"TZCNTQ" i += bits.TrailingZeros(n) n &= n - 1 @@ -482,9 +482,9 @@ func IterateBits(n uint) int { func IterateBits64(n uint64) int { i := 0 for n != 0 { - // amd64/v1,amd64/v2:"BSFQ",-"CMOVEQ" + // amd64/v1,amd64/v2:"BSFQ" -"CMOVEQ" // amd64/v3:"TZCNTQ" - // riscv64/rva22u64,riscv64/rva23u64: "CTZ\t" + // riscv64/rva22u64,riscv64/rva23u64: "CTZ " i += bits.TrailingZeros64(n) n &= n - 1 } @@ -494,9 +494,9 @@ func IterateBits64(n uint64) int { func IterateBits32(n uint32) int { i := 0 for n != 0 { - // amd64/v1,amd64/v2:"BSFL",-"BTSQ" + // amd64/v1,amd64/v2:"BSFL" -"BTSQ" // amd64/v3:"TZCNTL" - // riscv64/rva22u64,riscv64/rva23u64: "CTZ\t" + // riscv64/rva22u64,riscv64/rva23u64: "CTZ " i += bits.TrailingZeros32(n) n &= n - 1 } @@ -506,10 +506,10 @@ func IterateBits32(n uint32) int { func IterateBits16(n uint16) int { i := 0 for n != 0 { - // amd64/v1,amd64/v2:"BSFL",-"BTSL" + // amd64/v1,amd64/v2:"BSFL" -"BTSL" // amd64/v3:"TZCNTL" - // arm64:"RBITW","CLZW",-"ORR" - // riscv64/rva22u64,riscv64/rva23u64: "CTZ\t",-"ORR" + // arm64:"RBITW" "CLZW" -"ORR" + // riscv64/rva22u64,riscv64/rva23u64: "CTZ " -"ORR" i += bits.TrailingZeros16(n) n &= n - 1 } @@ -519,10 +519,10 @@ func IterateBits16(n uint16) int { func IterateBits8(n uint8) int { i := 0 for n != 0 { - // amd64/v1,amd64/v2:"BSFL",-"BTSL" + // amd64/v1,amd64/v2:"BSFL" -"BTSL" // amd64/v3:"TZCNTL" - // arm64:"RBITW","CLZW",-"ORR" - // riscv64/rva22u64,riscv64/rva23u64: "CTZ\t",-"ORR" + // arm64:"RBITW" "CLZW" -"ORR" + // riscv64/rva22u64,riscv64/rva23u64: "CTZ " -"ORR" i += bits.TrailingZeros8(n) n &= n - 1 } @@ -534,44 +534,44 @@ func IterateBits8(n uint8) int { // --------------- // func Add(x, y, ci uint) (r, co uint) { - // arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP" - // amd64:"NEGL","ADCQ","SBBQ","NEGQ" + // arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP" + // amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ" // ppc64x: "ADDC", "ADDE", "ADDZE" - // s390x:"ADDE","ADDC\t[$]-1," - // riscv64: "ADD","SLTU" + // s390x:"ADDE" "ADDC [$]-1," + // riscv64: "ADD" "SLTU" return bits.Add(x, y, ci) } func AddC(x, ci uint) (r, co uint) { - // arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP" - // amd64:"NEGL","ADCQ","SBBQ","NEGQ" + // arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP" + // amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ" // loong64: "ADDV", "SGTU" // ppc64x: "ADDC", "ADDE", "ADDZE" - // s390x:"ADDE","ADDC\t[$]-1," - // mips64:"ADDV","SGTU" - // riscv64: "ADD","SLTU" + // s390x:"ADDE" "ADDC [$]-1," + // mips64:"ADDV" "SGTU" + // riscv64: "ADD" "SLTU" return bits.Add(x, 7, ci) } func AddZ(x, y uint) (r, co uint) { - // arm64:"ADDS","ADC",-"ADCS",-"ADD\t",-"CMP" - // amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ" + // arm64:"ADDS" "ADC" -"ADCS" -"ADD " -"CMP" + // amd64:"ADDQ" "SBBQ" "NEGQ" -"NEGL" -"ADCQ" // loong64: "ADDV", "SGTU" // ppc64x: "ADDC", -"ADDE", "ADDZE" - // s390x:"ADDC",-"ADDC\t[$]-1," - // mips64:"ADDV","SGTU" - // riscv64: "ADD","SLTU" + // s390x:"ADDC" -"ADDC [$]-1," + // mips64:"ADDV" "SGTU" + // riscv64: "ADD" "SLTU" return bits.Add(x, y, 0) } func AddR(x, y, ci uint) uint { - // arm64:"ADDS","ADCS",-"ADD\t",-"CMP" - // amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ" + // arm64:"ADDS" "ADCS" -"ADD " -"CMP" + // amd64:"NEGL" "ADCQ" -"SBBQ" -"NEGQ" // loong64: "ADDV", -"SGTU" // ppc64x: "ADDC", "ADDE", -"ADDZE" - // s390x:"ADDE","ADDC\t[$]-1," - // mips64:"ADDV",-"SGTU" - // riscv64: "ADD",-"SLTU" + // s390x:"ADDE" "ADDC [$]-1," + // mips64:"ADDV" -"SGTU" + // riscv64: "ADD" -"SLTU" r, _ := bits.Add(x, y, ci) return r } @@ -579,54 +579,54 @@ func AddR(x, y, ci uint) uint { func AddM(p, q, r *[3]uint) { var c uint r[0], c = bits.Add(p[0], q[0], c) - // arm64:"ADCS",-"ADD\t",-"CMP" - // amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ" - // s390x:"ADDE",-"ADDC\t[$]-1," + // arm64:"ADCS" -"ADD " -"CMP" + // amd64:"ADCQ" -"NEGL" -"SBBQ" -"NEGQ" + // s390x:"ADDE" -"ADDC [$]-1," r[1], c = bits.Add(p[1], q[1], c) r[2], c = bits.Add(p[2], q[2], c) } func Add64(x, y, ci uint64) (r, co uint64) { - // arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP" - // amd64:"NEGL","ADCQ","SBBQ","NEGQ" + // arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP" + // amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ" // loong64: "ADDV", "SGTU" // ppc64x: "ADDC", "ADDE", "ADDZE" - // s390x:"ADDE","ADDC\t[$]-1," - // mips64:"ADDV","SGTU" - // riscv64: "ADD","SLTU" + // s390x:"ADDE" "ADDC [$]-1," + // mips64:"ADDV" "SGTU" + // riscv64: "ADD" "SLTU" return bits.Add64(x, y, ci) } func Add64C(x, ci uint64) (r, co uint64) { - // arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP" - // amd64:"NEGL","ADCQ","SBBQ","NEGQ" + // arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP" + // amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ" // loong64: "ADDV", "SGTU" // ppc64x: "ADDC", "ADDE", "ADDZE" - // s390x:"ADDE","ADDC\t[$]-1," - // mips64:"ADDV","SGTU" - // riscv64: "ADD","SLTU" + // s390x:"ADDE" "ADDC [$]-1," + // mips64:"ADDV" "SGTU" + // riscv64: "ADD" "SLTU" return bits.Add64(x, 7, ci) } func Add64Z(x, y uint64) (r, co uint64) { - // arm64:"ADDS","ADC",-"ADCS",-"ADD\t",-"CMP" - // amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ" + // arm64:"ADDS" "ADC" -"ADCS" -"ADD " -"CMP" + // amd64:"ADDQ" "SBBQ" "NEGQ" -"NEGL" -"ADCQ" // loong64: "ADDV", "SGTU" // ppc64x: "ADDC", -"ADDE", "ADDZE" - // s390x:"ADDC",-"ADDC\t[$]-1," - // mips64:"ADDV","SGTU" - // riscv64: "ADD","SLTU" + // s390x:"ADDC" -"ADDC [$]-1," + // mips64:"ADDV" "SGTU" + // riscv64: "ADD" "SLTU" return bits.Add64(x, y, 0) } func Add64R(x, y, ci uint64) uint64 { - // arm64:"ADDS","ADCS",-"ADD\t",-"CMP" - // amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ" + // arm64:"ADDS" "ADCS" -"ADD " -"CMP" + // amd64:"NEGL" "ADCQ" -"SBBQ" -"NEGQ" // loong64: "ADDV", -"SGTU" // ppc64x: "ADDC", "ADDE", -"ADDZE" - // s390x:"ADDE","ADDC\t[$]-1," - // mips64:"ADDV",-"SGTU" - // riscv64: "ADD",-"SLTU" + // s390x:"ADDE" "ADDC [$]-1," + // mips64:"ADDV" -"SGTU" + // riscv64: "ADD" -"SLTU" r, _ := bits.Add64(x, y, ci) return r } @@ -634,10 +634,10 @@ func Add64R(x, y, ci uint64) uint64 { func Add64M(p, q, r *[3]uint64) { var c uint64 r[0], c = bits.Add64(p[0], q[0], c) - // arm64:"ADCS",-"ADD\t",-"CMP" - // amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ" + // arm64:"ADCS" -"ADD " -"CMP" + // amd64:"ADCQ" -"NEGL" -"SBBQ" -"NEGQ" // ppc64x: -"ADDC", "ADDE", -"ADDZE" - // s390x:"ADDE",-"ADDC\t[$]-1," + // 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,22 +645,22 @@ 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\tR[1-9]" + // ppc64x: -"ADDC", -"ADDE", "ADDZE R[1-9]" r[1], c = bits.Add64(p[1], 0, c) // ppc64x: -"ADDC", "ADDE", -"ADDZE" r[2], c = bits.Add64(p[2], p[2], c) } func Add64MSaveC(p, q, r, c *[2]uint64) { - // ppc64x: "ADDC\tR", "ADDZE" + // ppc64x: "ADDC R", "ADDZE" r[0], c[0] = bits.Add64(p[0], q[0], 0) - // ppc64x: "ADDC\t[$]-1", "ADDE", "ADDZE" + // ppc64x: "ADDC [$]-1", "ADDE", "ADDZE" r[1], c[1] = bits.Add64(p[1], q[1], c[0]) } func Add64PanicOnOverflowEQ(a, b uint64) uint64 { r, c := bits.Add64(a, b, 0) - // s390x:"BRC\t[$]3,",-"ADDE" + // s390x:"BRC [$]3," -"ADDE" if c == 1 { panic("overflow") } @@ -669,7 +669,7 @@ func Add64PanicOnOverflowEQ(a, b uint64) uint64 { func Add64PanicOnOverflowNE(a, b uint64) uint64 { r, c := bits.Add64(a, b, 0) - // s390x:"BRC\t[$]3,",-"ADDE" + // s390x:"BRC [$]3," -"ADDE" if c != 0 { panic("overflow") } @@ -678,7 +678,7 @@ func Add64PanicOnOverflowNE(a, b uint64) uint64 { func Add64PanicOnOverflowGT(a, b uint64) uint64 { r, c := bits.Add64(a, b, 0) - // s390x:"BRC\t[$]3,",-"ADDE" + // s390x:"BRC [$]3," -"ADDE" if c > 0 { panic("overflow") } @@ -690,7 +690,7 @@ func Add64MPanicOnOverflowEQ(a, b [2]uint64) [2]uint64 { var c uint64 r[0], c = bits.Add64(a[0], b[0], c) r[1], c = bits.Add64(a[1], b[1], c) - // s390x:"BRC\t[$]3," + // s390x:"BRC [$]3," if c == 1 { panic("overflow") } @@ -702,7 +702,7 @@ func Add64MPanicOnOverflowNE(a, b [2]uint64) [2]uint64 { var c uint64 r[0], c = bits.Add64(a[0], b[0], c) r[1], c = bits.Add64(a[1], b[1], c) - // s390x:"BRC\t[$]3," + // s390x:"BRC [$]3," if c != 0 { panic("overflow") } @@ -714,7 +714,7 @@ func Add64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 { var c uint64 r[0], c = bits.Add64(a[0], b[0], c) r[1], c = bits.Add64(a[1], b[1], c) - // s390x:"BRC\t[$]3," + // s390x:"BRC [$]3," if c > 0 { panic("overflow") } @@ -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\tR\\d+,", -"ADDE", -"MOVD\tXER" + // ppc64x: "ADDC R\\d+,", -"ADDE", -"MOVD XER" d1, cx = bits.Add64(a1, b1, 0) - // ppc64x: "ADDE", -"ADDC", -"MOVD\t.*, XER" + // ppc64x: "ADDE", -"ADDC", -"MOVD .*, XER" d2, _ = bits.Add64(a2, b2, cx) - // ppc64x: "ADDC\tR\\d+,", -"ADDE", -"MOVD\tXER" + // ppc64x: "ADDC R\\d+,", -"ADDE", -"MOVD XER" d1, cx = bits.Add64(c1, d1, 0) - // ppc64x: "ADDE", -"ADDC", -"MOVD\t.*, XER" + // ppc64x: "ADDE", -"ADDC", -"MOVD .*, XER" d2, _ = bits.Add64(c2, d2, cx) d[0] = d1 d[1] = d2 @@ -756,53 +756,53 @@ func Add64MultipleChains(a, b, c, d [2]uint64) [2]uint64 { // --------------- // func Sub(x, y, ci uint) (r, co uint) { - // amd64:"NEGL","SBBQ","NEGQ" - // arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP" - // loong64:"SUBV","SGTU" + // amd64:"NEGL" "SBBQ" "NEGQ" + // arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP" + // loong64:"SUBV" "SGTU" // ppc64x:"SUBC", "SUBE", "SUBZE", "NEG" // s390x:"SUBE" - // mips64:"SUBV","SGTU" - // riscv64: "SUB","SLTU" + // mips64:"SUBV" "SGTU" + // riscv64: "SUB" "SLTU" return bits.Sub(x, y, ci) } func SubC(x, ci uint) (r, co uint) { - // amd64:"NEGL","SBBQ","NEGQ" - // arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP" - // loong64:"SUBV","SGTU" + // amd64:"NEGL" "SBBQ" "NEGQ" + // arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP" + // loong64:"SUBV" "SGTU" // ppc64x:"SUBC", "SUBE", "SUBZE", "NEG" // s390x:"SUBE" - // mips64:"SUBV","SGTU" - // riscv64: "SUB","SLTU" + // mips64:"SUBV" "SGTU" + // riscv64: "SUB" "SLTU" return bits.Sub(x, 7, ci) } func SubZ(x, y uint) (r, co uint) { - // amd64:"SUBQ","SBBQ","NEGQ",-"NEGL" - // arm64:"SUBS","NGC","NEG",-"SBCS",-"ADD",-"SUB\t",-"CMP" - // loong64:"SUBV","SGTU" + // amd64:"SUBQ" "SBBQ" "NEGQ" -"NEGL" + // arm64:"SUBS" "NGC" "NEG" -"SBCS" -"ADD" -"SUB " -"CMP" + // loong64:"SUBV" "SGTU" // ppc64x:"SUBC", -"SUBE", "SUBZE", "NEG" // s390x:"SUBC" - // mips64:"SUBV","SGTU" - // riscv64: "SUB","SLTU" + // mips64:"SUBV" "SGTU" + // riscv64: "SUB" "SLTU" return bits.Sub(x, y, 0) } func SubR(x, y, ci uint) uint { - // amd64:"NEGL","SBBQ",-"NEGQ" - // arm64:"NEGS","SBCS",-"NGC",-"NEG\t",-"ADD",-"SUB",-"CMP" - // loong64:"SUBV",-"SGTU" + // amd64:"NEGL" "SBBQ" -"NEGQ" + // arm64:"NEGS" "SBCS" -"NGC" -"NEG " -"ADD" -"SUB" -"CMP" + // loong64:"SUBV" -"SGTU" // ppc64x:"SUBC", "SUBE", -"SUBZE", -"NEG" // s390x:"SUBE" - // riscv64: "SUB",-"SLTU" + // riscv64: "SUB" -"SLTU" r, _ := bits.Sub(x, y, ci) return r } func SubM(p, q, r *[3]uint) { var c uint r[0], c = bits.Sub(p[0], q[0], c) - // amd64:"SBBQ",-"NEGL",-"NEGQ" - // arm64:"SBCS",-"NEGS",-"NGC",-"NEG",-"ADD",-"SUB",-"CMP" + // amd64:"SBBQ" -"NEGL" -"NEGQ" + // arm64:"SBCS" -"NEGS" -"NGC" -"NEG" -"ADD" -"SUB" -"CMP" // ppc64x:-"SUBC", "SUBE", -"SUBZE", -"NEG" // s390x:"SUBE" r[1], c = bits.Sub(p[1], q[1], c) @@ -810,68 +810,68 @@ func SubM(p, q, r *[3]uint) { } func Sub64(x, y, ci uint64) (r, co uint64) { - // amd64:"NEGL","SBBQ","NEGQ" - // arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP" - // loong64:"SUBV","SGTU" + // amd64:"NEGL" "SBBQ" "NEGQ" + // arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP" + // loong64:"SUBV" "SGTU" // ppc64x:"SUBC", "SUBE", "SUBZE", "NEG" // s390x:"SUBE" - // mips64:"SUBV","SGTU" - // riscv64: "SUB","SLTU" + // mips64:"SUBV" "SGTU" + // riscv64: "SUB" "SLTU" return bits.Sub64(x, y, ci) } func Sub64C(x, ci uint64) (r, co uint64) { - // amd64:"NEGL","SBBQ","NEGQ" - // arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP" - // loong64:"SUBV","SGTU" + // amd64:"NEGL" "SBBQ" "NEGQ" + // arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP" + // loong64:"SUBV" "SGTU" // ppc64x:"SUBC", "SUBE", "SUBZE", "NEG" // s390x:"SUBE" - // mips64:"SUBV","SGTU" - // riscv64: "SUB","SLTU" + // mips64:"SUBV" "SGTU" + // riscv64: "SUB" "SLTU" return bits.Sub64(x, 7, ci) } func Sub64Z(x, y uint64) (r, co uint64) { - // amd64:"SUBQ","SBBQ","NEGQ",-"NEGL" - // arm64:"SUBS","NGC","NEG",-"SBCS",-"ADD",-"SUB\t",-"CMP" - // loong64:"SUBV","SGTU" + // amd64:"SUBQ" "SBBQ" "NEGQ" -"NEGL" + // arm64:"SUBS" "NGC" "NEG" -"SBCS" -"ADD" -"SUB " -"CMP" + // loong64:"SUBV" "SGTU" // ppc64x:"SUBC", -"SUBE", "SUBZE", "NEG" // s390x:"SUBC" - // mips64:"SUBV","SGTU" - // riscv64: "SUB","SLTU" + // mips64:"SUBV" "SGTU" + // riscv64: "SUB" "SLTU" return bits.Sub64(x, y, 0) } func Sub64R(x, y, ci uint64) uint64 { - // amd64:"NEGL","SBBQ",-"NEGQ" - // arm64:"NEGS","SBCS",-"NGC",-"NEG\t",-"ADD",-"SUB",-"CMP" - // loong64:"SUBV",-"SGTU" + // amd64:"NEGL" "SBBQ" -"NEGQ" + // arm64:"NEGS" "SBCS" -"NGC" -"NEG " -"ADD" -"SUB" -"CMP" + // loong64:"SUBV" -"SGTU" // ppc64x:"SUBC", "SUBE", -"SUBZE", -"NEG" // s390x:"SUBE" - // riscv64: "SUB",-"SLTU" + // riscv64: "SUB" -"SLTU" r, _ := bits.Sub64(x, y, ci) return r } func Sub64M(p, q, r *[3]uint64) { var c uint64 r[0], c = bits.Sub64(p[0], q[0], c) - // amd64:"SBBQ",-"NEGL",-"NEGQ" - // arm64:"SBCS",-"NEGS",-"NGC",-"NEG",-"ADD",-"SUB",-"CMP" + // amd64:"SBBQ" -"NEGL" -"NEGQ" + // arm64:"SBCS" -"NEGS" -"NGC" -"NEG" -"ADD" -"SUB" -"CMP" // s390x:"SUBE" r[1], c = bits.Sub64(p[1], q[1], c) r[2], c = bits.Sub64(p[2], q[2], c) } func Sub64MSaveC(p, q, r, c *[2]uint64) { - // ppc64x:"SUBC\tR\\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\tR\\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]) } func Sub64PanicOnOverflowEQ(a, b uint64) uint64 { r, b := bits.Sub64(a, b, 0) - // s390x:"BRC\t[$]12,",-"ADDE",-"SUBE" + // s390x:"BRC [$]12," -"ADDE" -"SUBE" if b == 1 { panic("overflow") } @@ -880,7 +880,7 @@ func Sub64PanicOnOverflowEQ(a, b uint64) uint64 { func Sub64PanicOnOverflowNE(a, b uint64) uint64 { r, b := bits.Sub64(a, b, 0) - // s390x:"BRC\t[$]12,",-"ADDE",-"SUBE" + // s390x:"BRC [$]12," -"ADDE" -"SUBE" if b != 0 { panic("overflow") } @@ -889,7 +889,7 @@ func Sub64PanicOnOverflowNE(a, b uint64) uint64 { func Sub64PanicOnOverflowGT(a, b uint64) uint64 { r, b := bits.Sub64(a, b, 0) - // s390x:"BRC\t[$]12,",-"ADDE",-"SUBE" + // s390x:"BRC [$]12," -"ADDE" -"SUBE" if b > 0 { panic("overflow") } @@ -901,7 +901,7 @@ func Sub64MPanicOnOverflowEQ(a, b [2]uint64) [2]uint64 { var c uint64 r[0], c = bits.Sub64(a[0], b[0], c) r[1], c = bits.Sub64(a[1], b[1], c) - // s390x:"BRC\t[$]12," + // s390x:"BRC [$]12," if c == 1 { panic("overflow") } @@ -913,7 +913,7 @@ func Sub64MPanicOnOverflowNE(a, b [2]uint64) [2]uint64 { var c uint64 r[0], c = bits.Sub64(a[0], b[0], c) r[1], c = bits.Sub64(a[1], b[1], c) - // s390x:"BRC\t[$]12," + // s390x:"BRC [$]12," if c != 0 { panic("overflow") } @@ -925,7 +925,7 @@ func Sub64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 { var c uint64 r[0], c = bits.Sub64(a[0], b[0], c) r[1], c = bits.Sub64(a[1], b[1], c) - // s390x:"BRC\t[$]12," + // s390x:"BRC [$]12," if c > 0 { panic("overflow") } @@ -938,51 +938,51 @@ func Sub64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 { func Mul(x, y uint) (hi, lo uint) { // amd64:"MULQ" - // arm64:"UMULH","MUL" - // loong64:"MULV","MULHVU" - // ppc64x:"MULHDU","MULLD" + // arm64:"UMULH" "MUL" + // loong64:"MULV" "MULHVU" + // ppc64x:"MULHDU" "MULLD" // s390x:"MLGR" // mips64: "MULVU" - // riscv64:"MULHU","MUL" + // riscv64:"MULHU" "MUL" return bits.Mul(x, y) } func Mul64(x, y uint64) (hi, lo uint64) { // amd64:"MULQ" - // arm64:"UMULH","MUL" - // loong64:"MULV","MULHVU" - // ppc64x:"MULHDU","MULLD" + // arm64:"UMULH" "MUL" + // loong64:"MULV" "MULHVU" + // ppc64x:"MULHDU" "MULLD" // s390x:"MLGR" // mips64: "MULVU" - // riscv64:"MULHU","MUL" + // riscv64:"MULHU" "MUL" return bits.Mul64(x, y) } func Mul64HiOnly(x, y uint64) uint64 { - // arm64:"UMULH",-"MUL" - // loong64:"MULHVU",-"MULV" - // riscv64:"MULHU",-"MUL\t" + // arm64:"UMULH" -"MUL" + // loong64:"MULHVU" -"MULV" + // riscv64:"MULHU" -"MUL " hi, _ := bits.Mul64(x, y) return hi } func Mul64LoOnly(x, y uint64) uint64 { - // arm64:"MUL",-"UMULH" - // loong64:"MULV",-"MULHVU" - // riscv64:"MUL\t",-"MULHU" + // arm64:"MUL" -"UMULH" + // loong64:"MULV" -"MULHVU" + // riscv64:"MUL " -"MULHU" _, lo := bits.Mul64(x, y) return lo } func Mul64Const() (uint64, uint64) { // 7133701809754865664 == 99<<56 - // arm64:"MOVD\t[$]7133701809754865664, R1", "MOVD\t[$]88, R0" - // loong64:"MOVV\t[$]88, R4","MOVV\t[$]7133701809754865664, R5",-"MUL" + // arm64:"MOVD [$]7133701809754865664, R1", "MOVD [$]88, R0" + // loong64:"MOVV [$]88, R4" "MOVV [$]7133701809754865664, R5" -"MUL" return bits.Mul64(99+88<<8, 1<<56) } func MulUintOverflow(p *uint64) []uint64 { - // arm64:"CMP\t[$]72" + // arm64:"CMP [$]72" return unsafe.Slice(p, 9) } @@ -996,7 +996,7 @@ func Div(hi, lo, x uint) (q, r uint) { } func Div32(hi, lo, x uint32) (q, r uint32) { - // arm64:"ORR","UDIV","MSUB",-"UREM" + // arm64:"ORR" "UDIV" "MSUB" -"UREM" return bits.Div32(hi, lo, x) } diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go index fa0e902ac2..deac9e2091 100644 --- a/test/codegen/memcombine.go +++ b/test/codegen/memcombine.go @@ -16,7 +16,7 @@ import ( // ------------- // func load_le64(b []byte) uint64 { - // amd64:`MOVQ\s\(.*\),`,-`MOV[BWL]\t[^$]`,-`OR` + // amd64:`MOVQ\s\(.*\),`,-`MOV[BWL] [^$]`,-`OR` // s390x:`MOVDBR\s\(.*\),` // arm64:`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]` // loong64:`MOVV\s\(R[0-9]+\),` @@ -26,7 +26,7 @@ func load_le64(b []byte) uint64 { } func load_le64_idx(b []byte, idx int) uint64 { - // amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL]\t[^$]`,-`OR` + // amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL] [^$]`,-`OR` // s390x:`MOVDBR\s\(.*\)\(.*\*1\),` // arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]` // loong64:`MOVV\s\(R[0-9]+\)\(R[0-9]+\),` @@ -78,7 +78,7 @@ func load_le16_idx(b []byte, idx int) uint16 { } func load_be64(b []byte) uint64 { - // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR` + // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` // amd64/v3:`MOVBEQ` // s390x:`MOVD\s\(.*\),` // arm64:`REV`,`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W` @@ -88,8 +88,8 @@ func load_be64(b []byte) uint64 { } func load_be64_idx(b []byte, idx int) uint64 { - // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR` - // amd64/v3: `MOVBEQ\t\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` + // amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` + // amd64/v3: `MOVBEQ \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` // s390x:`MOVD\s\(.*\)\(.*\*1\),` // arm64:`REV`,`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[WHB]`,-`REVW`,-`REV16W` // ppc64le:`MOVDBR`,-`MOV[BHW]Z` @@ -109,7 +109,7 @@ func load_be32(b []byte) uint32 { func load_be32_idx(b []byte, idx int) uint32 { // amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR` - // amd64/v3: `MOVBEL\t\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` + // amd64/v3: `MOVBEL \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` // s390x:`MOVWZ\s\(.*\)\(.*\*1\),` // arm64:`REVW`,`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[HB]`,-`REV16W` // ppc64le:`MOVWBR`,-`MOV[BH]Z` @@ -136,79 +136,79 @@ func load_be16_idx(b []byte, idx int) uint16 { } func load_le_byte2_uint16(s []byte) uint16 { - // arm64:`MOVHU\t\(R[0-9]+\)`,-`ORR`,-`MOVB` + // arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB` // 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR` // amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR` - // ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVBZ` + // 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\t\(R[0-9]+\)`,-`ORR`,-`MOVB` + // arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB` // 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR` // amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR` - // ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVBZ` + // 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\t\(R[0-9]+\)`,-`ORR`,-`MOV[BH]` + // arm64:`MOVWU \(R[0-9]+\)`,-`ORR`,-`MOV[BH]` // 386:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR` // amd64:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR` - // ppc64le:`MOVWZ\t\(R[0-9]+\)`,-`MOV[BH]Z` + // 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\t\(R[0-9]+\)`,-`ORR`,-`MOV[BH]` + // 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\t\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` - // amd64:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,-`MOV[BWL]\t[^$]`,-`OR` - // ppc64le:`MOVD\t\(R[0-9]+\)`,-`MOV[BHW]Z` + // arm64:`MOVD \(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` + // amd64:`MOVQ\s\([A-Z]+\),\s[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\t\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]` + // 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\t\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` + // arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` // amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR` - // ppc64le:`MOVHBR\t\(R[0-9]+\)`,-`MOVBZ` + // 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\t\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` + // arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB` // amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR` - // ppc64le:`MOVHBR\t\(R[0-9]+\)`,-`MOVBZ` + // 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\t\(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]` + // 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\t\(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]` + // arm64:`MOVWU \(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]` // amd64/v1,amd64/v2:`MOVL\s\([A-Z]+\)`,`BSWAPL`,-`MOV[BW]`,-`OR` // amd64/v3: `MOVBEL` // ppc64le:`MOVWBR`,-`MOV[HB]Z` @@ -217,17 +217,17 @@ func load_be_byte4_uint32_inv(s []byte) uint32 { } func load_be_byte8_uint64(s []byte) uint64 { - // arm64:`MOVD\t\(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]` - // ppc64le:`MOVDBR\t\(R[0-9]+\)`,-`MOV[BHW]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\t\(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]` - // amd64/v1,amd64/v2:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR` + // arm64:`MOVD \(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]` + // amd64/v1,amd64/v2:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR` // amd64/v3: `MOVBEQ` - // ppc64le:`MOVDBR\t\(R[0-9]+\)`,-`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 } @@ -386,20 +386,20 @@ func fcall_uint32(a [2]uint32) [2]uint32 { // We want to merge load+op in the first function, but not in the // second. See Issue 19595. func load_op_merge(p, q *int) { - x := *p // amd64:`ADDQ\t\(` + x := *p // amd64:`ADDQ \(` *q += x // The combined nilcheck and load would normally have this line number, but we want that combined operation to have the line number of the nil check instead (see #33724). } func load_op_no_merge(p, q *int) { x := *p for i := 0; i < 10; i++ { - *q += x // amd64:`ADDQ\t[A-Z]` + *q += x // amd64:`ADDQ [A-Z]` } } func load_op_in_loop(a []int) int { r := 0 for _, x := range a { - // amd64:`ADDQ\t\([A-Z]+\)\([A-Z]+\*8\), [A-Z]+` + // amd64:`ADDQ \([A-Z]+\)\([A-Z]+\*8\), [A-Z]+` r += x } return r @@ -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\tcommand-line-arguments\.a\+[0-9]+\(FP\), R[0-9]+`,`MOVD\tR[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 } @@ -526,7 +526,7 @@ func store_be64(b []byte, x uint64) { func store_be64_idx(b []byte, x uint64, idx int) { // amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.` - // amd64/v3:`MOVBEQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` + // amd64/v3:`MOVBEQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` // arm64:`REV`,`MOVD\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`,-`REV16W`,-`REVW` // ppc64le:`MOVDBR` // ppc64:`MOVD\s` @@ -558,7 +558,7 @@ func store_be32_load(b, x *[8]byte) { func store_be32_idx(b []byte, x uint32, idx int) { // amd64/v1,amd64/v2:`BSWAPL`,-`SHR.` - // amd64/v3:`MOVBEL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` + // amd64/v3:`MOVBEL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` // arm64:`REVW`,`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`,-`REV16W` // ppc64le:`MOVWBR` // ppc64:`MOVW\s` @@ -578,7 +578,7 @@ func store_be16(b []byte, x uint16) { func store_be16_idx(b []byte, x uint16, idx int) { // amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.` - // amd64/v3:`MOVBEW\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` + // amd64/v3:`MOVBEW [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` // arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`MOVB` // ppc64le:`MOVHBR` // ppc64:`MOVH\s` @@ -736,12 +736,12 @@ func store_le_byte_4_idx4_inv(b []byte, idx int, val uint32) { func zero_byte_2(b1, b2 []byte) { // bounds checks to guarantee safety of writes below _, _ = b1[1], b2[1] - // arm64:"MOVH\tZR",-"MOVB" + // arm64:"MOVH ZR" -"MOVB" // amd64:`MOVW\s[$]0,\s\([A-Z]+\)` // 386:`MOVW\s[$]0,\s\([A-Z]+\)` // ppc64x:`MOVH\s` b1[0], b1[1] = 0, 0 - // arm64:"MOVH\tZR",-"MOVB" + // arm64:"MOVH ZR" -"MOVB" // 386:`MOVW\s[$]0,\s\([A-Z]+\)` // amd64:`MOVW\s[$]0,\s\([A-Z]+\)` // ppc64x:`MOVH` @@ -750,36 +750,36 @@ func zero_byte_2(b1, b2 []byte) { func zero_byte_4(b1, b2 []byte) { _, _ = b1[3], b2[3] - // arm64:"MOVW\tZR",-"MOVB",-"MOVH" + // arm64:"MOVW ZR" -"MOVB" -"MOVH" // amd64:`MOVL\s[$]0,\s\([A-Z]+\)` // 386:`MOVL\s[$]0,\s\([A-Z]+\)` // ppc64x:`MOVW\s` b1[0], b1[1], b1[2], b1[3] = 0, 0, 0, 0 - // arm64:"MOVW\tZR",-"MOVB",-"MOVH" + // arm64:"MOVW ZR" -"MOVB" -"MOVH" // ppc64x:`MOVW\s` b2[2], b2[3], b2[1], b2[0] = 0, 0, 0, 0 } func zero_byte_8(b []byte) { _ = b[7] - b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW" + b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" b[4], b[5], b[6], b[7] = 0, 0, 0, 0 } func zero_byte_16(b []byte) { _ = b[15] - b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH",-"MOVW" + b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH" -"MOVW" b[4], b[5], b[6], b[7] = 0, 0, 0, 0 b[8], b[9], b[10], b[11] = 0, 0, 0, 0 b[12], b[13], b[14], b[15] = 0, 0, 0, 0 } func zero_byte_30(a *[30]byte) { - *a = [30]byte{} // arm64:"STP",-"MOVB",-"MOVH",-"MOVW" + *a = [30]byte{} // arm64:"STP" -"MOVB" -"MOVH" -"MOVW" } func zero_byte_39(a *[39]byte) { - *a = [39]byte{} // arm64:"MOVD",-"MOVB",-"MOVH",-"MOVW" + *a = [39]byte{} // arm64:"MOVD" -"MOVB" -"MOVH" -"MOVW" } func zero_byte_2_idx(b []byte, idx int) { @@ -798,12 +798,12 @@ func zero_byte_2_idx2(b []byte, idx int) { func zero_uint16_2(h1, h2 []uint16) { _, _ = h1[1], h2[1] - // arm64:"MOVW\tZR",-"MOVB",-"MOVH" + // arm64:"MOVW ZR" -"MOVB" -"MOVH" // amd64:`MOVL\s[$]0,\s\([A-Z]+\)` // 386:`MOVL\s[$]0,\s\([A-Z]+\)` // ppc64x:`MOVW\s` h1[0], h1[1] = 0, 0 - // arm64:"MOVW\tZR",-"MOVB",-"MOVH" + // arm64:"MOVW ZR" -"MOVB" -"MOVH" // amd64:`MOVL\s[$]0,\s\([A-Z]+\)` // 386:`MOVL\s[$]0,\s\([A-Z]+\)` // ppc64x:`MOVW` @@ -812,28 +812,28 @@ func zero_uint16_2(h1, h2 []uint16) { func zero_uint16_4(h1, h2 []uint16) { _, _ = h1[3], h2[3] - // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW" + // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)` // ppc64x:`MOVD\s` h1[0], h1[1], h1[2], h1[3] = 0, 0, 0, 0 - // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW" + // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" // ppc64x:`MOVD\s` h2[2], h2[3], h2[1], h2[0] = 0, 0, 0, 0 } func zero_uint16_8(h []uint16) { _ = h[7] - h[0], h[1], h[2], h[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH" + h[0], h[1], h[2], h[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH" h[4], h[5], h[6], h[7] = 0, 0, 0, 0 } func zero_uint32_2(w1, w2 []uint32) { _, _ = w1[1], w2[1] - // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW" + // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)` // ppc64x:`MOVD\s` w1[0], w1[1] = 0, 0 - // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW" + // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW" // amd64:`MOVQ\s[$]0,\s\([A-Z]+\)` // ppc64x:`MOVD\s` w2[1], w2[0] = 0, 0 @@ -841,22 +841,22 @@ func zero_uint32_2(w1, w2 []uint32) { func zero_uint32_4(w1, w2 []uint32) { _, _ = w1[3], w2[3] - w1[0], w1[1], w1[2], w1[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH" - w2[2], w2[3], w2[1], w2[0] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH" + w1[0], w1[1], w1[2], w1[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH" + w2[2], w2[3], w2[1], w2[0] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH" } func zero_uint64_2(d1, d2 []uint64) { _, _ = d1[1], d2[1] - d1[0], d1[1] = 0, 0 // arm64:"STP",-"MOVB",-"MOVH" - d2[1], d2[0] = 0, 0 // arm64:"STP",-"MOVB",-"MOVH" + d1[0], d1[1] = 0, 0 // arm64:"STP" -"MOVB" -"MOVH" + d2[1], d2[0] = 0, 0 // arm64:"STP" -"MOVB" -"MOVH" } func loadstore(p, q *[4]uint8) { - // amd64:"MOVL",-"MOVB" - // arm64:"MOVWU",-"MOVBU" + // amd64:"MOVL" -"MOVB" + // arm64:"MOVWU" -"MOVBU" x0, x1, x2, x3 := q[0], q[1], q[2], q[3] - // amd64:"MOVL",-"MOVB" - // arm64:"MOVW",-"MOVB" + // amd64:"MOVL" -"MOVB" + // arm64:"MOVW" -"MOVB" p[0], p[1], p[2], p[3] = x0, x1, x2, x3 } @@ -865,11 +865,11 @@ type S1 struct { } func loadstore2(p, q *S1) { - // amd64:"MOVL",-"MOVWLZX" - // arm64:"MOVWU",-"MOVH" + // amd64:"MOVL" -"MOVWLZX" + // arm64:"MOVWU" -"MOVH" a, b := p.a, p.b - // amd64:"MOVL",-"MOVW" - // arm64:"MOVW",-"MOVH" + // amd64:"MOVL" -"MOVW" + // arm64:"MOVW" -"MOVH" q.a, q.b = a, b } @@ -878,11 +878,11 @@ func wideStore(p *[8]uint64) { return } - // amd64:"MOVUPS",-"MOVQ" - // arm64:"STP",-"MOVD" + // amd64:"MOVUPS" -"MOVQ" + // arm64:"STP" -"MOVD" p[0] = 0 - // amd64:-"MOVUPS",-"MOVQ" - // arm64:-"STP",-"MOVD" + // amd64:-"MOVUPS" -"MOVQ" + // arm64:-"STP" -"MOVD" p[1] = 0 } @@ -893,52 +893,52 @@ func wideStore2(p *[8]uint64, x, y uint64) { // s390x:"STMG" p[0] = x - // s390x:-"STMG",-"MOVD" + // s390x:-"STMG" -"MOVD" p[1] = y } func store32le(p *struct{ a, b uint32 }, x uint64) { - // amd64:"MOVQ",-"MOVL",-"SHRQ" - // arm64:"MOVD",-"MOVW",-"LSR" - // ppc64le:"MOVD",-"MOVW",-"SRD" + // amd64:"MOVQ" -"MOVL" -"SHRQ" + // arm64:"MOVD" -"MOVW" -"LSR" + // ppc64le:"MOVD" -"MOVW" -"SRD" p.a = uint32(x) - // amd64:-"MOVL",-"SHRQ" - // arm64:-"MOVW",-"LSR" - // ppc64le:-"MOVW",-"SRD" + // amd64:-"MOVL" -"SHRQ" + // arm64:-"MOVW" -"LSR" + // ppc64le:-"MOVW" -"SRD" p.b = uint32(x >> 32) } func store32be(p *struct{ a, b uint32 }, x uint64) { // arm64:"STPW" - // ppc64:"MOVD",-"MOVW",-"SRD" - // s390x:"MOVD",-"MOVW",-"SRD" + // ppc64:"MOVD" -"MOVW" -"SRD" + // s390x:"MOVD" -"MOVW" -"SRD" p.a = uint32(x >> 32) // arm64:-"STPW" - // ppc64:-"MOVW",-"SRD" - // s390x:-"MOVW",-"SRD" + // ppc64:-"MOVW" -"SRD" + // s390x:-"MOVW" -"SRD" p.b = uint32(x) } func store16le(p *struct{ a, b uint16 }, x uint32) { - // amd64:"MOVL",-"MOVW",-"SHRL" - // arm64:"MOVW",-"MOVH",-"UBFX" - // ppc64le:"MOVW",-"MOVH",-"SRW" + // amd64:"MOVL" -"MOVW" -"SHRL" + // arm64:"MOVW" -"MOVH" -"UBFX" + // ppc64le:"MOVW" -"MOVH" -"SRW" p.a = uint16(x) - // amd64:-"MOVW",-"SHRL" - // arm64:-"MOVH",-"UBFX" - // ppc64le:-"MOVH",-"SRW" + // amd64:-"MOVW" -"SHRL" + // arm64:-"MOVH" -"UBFX" + // ppc64le:-"MOVH" -"SRW" p.b = uint16(x >> 16) } func store16be(p *struct{ a, b uint16 }, x uint32) { - // ppc64:"MOVW",-"MOVH",-"SRW" - // s390x:"MOVW",-"MOVH",-"SRW" + // ppc64:"MOVW" -"MOVH" -"SRW" + // s390x:"MOVW" -"MOVH" -"SRW" p.a = uint16(x >> 16) - // ppc64:-"MOVH",-"SRW" - // s390x:-"MOVH",-"SRW" + // ppc64:-"MOVH" -"SRW" + // s390x:-"MOVH" -"SRW" p.b = uint16(x) } func storeBoolConst(p *struct{ a, b bool }) { - // amd64:"MOVW",-"MOVB" - // arm64:"MOVH",-"MOVB" + // amd64:"MOVW" -"MOVB" + // arm64:"MOVH" -"MOVB" p.a = true p.b = true } @@ -948,8 +948,8 @@ func issue66413(p *struct { c bool d int8 }) { - // amd64:"MOVL",-"MOVB" - // arm64:"MOVW",-"MOVB" + // amd64:"MOVL" -"MOVB" + // arm64:"MOVW" -"MOVB" p.a = 31 p.b = false p.c = true @@ -957,7 +957,7 @@ func issue66413(p *struct { } func issue70300(v uint64) (b [8]byte) { - // amd64:"MOVQ",-"MOVB" + // amd64:"MOVQ" -"MOVB" b[0] = byte(v) b[1] = byte(v >> 8) b[2] = byte(v >> 16) @@ -970,7 +970,7 @@ func issue70300(v uint64) (b [8]byte) { } func issue70300Reverse(v uint64) (b [8]byte) { - // amd64:"MOVQ",-"MOVB" + // amd64:"MOVQ" -"MOVB" b[7] = byte(v >> 56) b[6] = byte(v >> 48) b[5] = byte(v >> 40) @@ -987,43 +987,43 @@ func issue70300Reverse(v uint64) (b [8]byte) { // --------------------------------- // func dwloadI64(p *struct{ a, b int64 }) int64 { - // arm64:"LDP\t" + // arm64:"LDP " return p.a + p.b } func dwloadI32(p *struct{ a, b int32 }) int32 { - // arm64:"LDPSW\t" + // arm64:"LDPSW " return p.a + p.b } func dwloadU32(p *struct{ a, b uint32 }) uint32 { - // arm64:"LDPW\t" + // arm64:"LDPW " return p.a + p.b } func dwloadF64(p *struct{ a, b float64 }) float64 { - // arm64:"FLDPD\t" + // arm64:"FLDPD " return p.a + p.b } func dwloadF32(p *struct{ a, b float32 }) float32 { - // arm64:"FLDPS\t" + // arm64:"FLDPS " return p.a + p.b } func dwloadBig(p *struct{ a, b, c, d, e, f int64 }) int64 { - // arm64:"LDP\t\\(", "LDP\t16", "LDP\t32" + // arm64:"LDP \\(", "LDP 16", "LDP 32" return p.c + p.f + p.a + p.e + p.d + p.b } func dwloadArg(a [2]int64) int64 { - // arm64:"LDP\t" + // arm64:"LDP " return a[0] + a[1] } func dwloadResult1(p *string) string { - // arm64:"LDP\t\\(R0\\), \\(R0, R1\\)" + // arm64:"LDP \\(R0\\), \\(R0, R1\\)" return *p } func dwloadResult2(p *[2]int64) (int64, int64) { - // arm64:"LDP\t\\(R0\\), \\(R1, R0\\)" + // arm64:"LDP \\(R0\\), \\(R1, R0\\)" return p[1], p[0] } @@ -1032,22 +1032,22 @@ func dwloadResult2(p *[2]int64) (int64, int64) { // ---------------------------------- // func dwstoreI64(p *struct{ a, b int64 }, x, y int64) { - // arm64:"STP\t" + // arm64:"STP " p.a = x p.b = y } func dwstoreI32(p *struct{ a, b int32 }, x, y int32) { - // arm64:"STPW\t" + // arm64:"STPW " p.a = x p.b = y } func dwstoreF64(p *struct{ a, b float64 }, x, y float64) { - // arm64:"FSTPD\t" + // arm64:"FSTPD " p.a = x p.b = y } func dwstoreF32(p *struct{ a, b float32 }, x, y float32) { - // arm64:"FSTPS\t" + // arm64:"FSTPS " p.a = x p.b = y } @@ -1065,14 +1065,14 @@ func dwstoreBig(p *struct{ a, b, c, d, e, f int64 }, a, b, c, d, e, f int64) { } func dwstoreRet() [2]int { - // arm64:"STP\t" + // arm64:"STP " return [2]int{5, 6} } func dwstoreLocal(i int) int64 { var a [2]int64 a[0] = 5 - // arm64:"STP\t" + // arm64:"STP " a[1] = 6 return a[i] } @@ -1081,7 +1081,7 @@ func dwstoreOrder(p *struct { a, b int64 c, d, e, f bool }, a, b int64) { - // arm64:"STP\t" + // arm64:"STP " p.a = a p.c = true p.e = true diff --git a/test/codegen/memops.go b/test/codegen/memops.go index e5e89c2acc..4d7bdfb685 100644 --- a/test/codegen/memops.go +++ b/test/codegen/memops.go @@ -13,23 +13,23 @@ var x32 [2]uint32 var x64 [2]uint64 func compMem1() int { - // amd64:`CMPB\tcommand-line-arguments.x\+1\(SB\), [$]0` + // amd64:`CMPB command-line-arguments.x\+1\(SB\), [$]0` if x[1] { return 1 } - // amd64:`CMPB\tcommand-line-arguments.x8\+1\(SB\), [$]7` + // amd64:`CMPB command-line-arguments.x8\+1\(SB\), [$]7` if x8[1] == 7 { return 1 } - // amd64:`CMPW\tcommand-line-arguments.x16\+2\(SB\), [$]7` + // amd64:`CMPW command-line-arguments.x16\+2\(SB\), [$]7` if x16[1] == 7 { return 1 } - // amd64:`CMPL\tcommand-line-arguments.x32\+4\(SB\), [$]7` + // amd64:`CMPL command-line-arguments.x32\+4\(SB\), [$]7` if x32[1] == 7 { return 1 } - // amd64:`CMPQ\tcommand-line-arguments.x64\+8\(SB\), [$]7` + // amd64:`CMPQ command-line-arguments.x64\+8\(SB\), [$]7` if x64[1] == 7 { return 1 } @@ -46,23 +46,23 @@ type T struct { } func compMem2(t T) int { - // amd64:`CMPB\t.*\(SP\), [$]0` + // amd64:`CMPB .*\(SP\), [$]0` if t.x { return 1 } - // amd64:`CMPB\t.*\(SP\), [$]7` + // amd64:`CMPB .*\(SP\), [$]7` if t.x8 == 7 { return 1 } - // amd64:`CMPW\t.*\(SP\), [$]7` + // amd64:`CMPW .*\(SP\), [$]7` if t.x16 == 7 { return 1 } - // amd64:`CMPL\t.*\(SP\), [$]7` + // amd64:`CMPL .*\(SP\), [$]7` if t.x32 == 7 { return 1 } - // amd64:`CMPQ\t.*\(SP\), [$]7` + // amd64:`CMPQ .*\(SP\), [$]7` if t.x64 == 7 { return 1 } @@ -73,8 +73,8 @@ func compMem3(x, y *int) (int, bool) { // We can do comparisons of a register with memory even if // the register is used subsequently. r := *x - // amd64:`CMPQ\t\(` - // 386:`CMPL\t\(` + // amd64:`CMPQ \(` + // 386:`CMPL \(` return r, r < *y } @@ -82,261 +82,261 @@ func compMem3(x, y *int) (int, bool) { func idxInt8(x, y []int8, i int) { var t int8 - // amd64: `MOVBL[SZ]X\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` - // 386: `MOVBL[SZ]X\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` + // amd64: `MOVBL[SZ]X 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` + // 386: `MOVBL[SZ]X 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` t = x[i+1] - // amd64: `MOVB\t[A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` - // 386: `MOVB\t[A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` + // amd64: `MOVB [A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` + // 386: `MOVB [A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` y[i+1] = t - // amd64: `MOVB\t[$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` - // 386: `MOVB\t[$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` + // amd64: `MOVB [$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` + // 386: `MOVB [$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` x[i+1] = 77 } func idxInt16(x, y []int16, i int) { var t int16 - // amd64: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*` - // 386: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*` + // amd64: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*` + // 386: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*` t = x[i+1] - // amd64: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` - // 386: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` + // amd64: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` + // 386: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` y[i+1] = t - // amd64: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*` - // 386: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*` + // amd64: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*` + // 386: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*` t = x[16*i+1] - // amd64: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)` - // 386: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)` + // amd64: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)` + // 386: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)` y[16*i+1] = t - // amd64: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` - // 386: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` + // amd64: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` + // 386: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` x[i+1] = 77 - // amd64: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)` - // 386: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)` + // amd64: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)` + // 386: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)` x[16*i+1] = 77 } func idxInt32(x, y []int32, i int) { var t int32 - // amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` - // 386: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // 386: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` t = x[i+1] - // amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` - // 386: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` y[i+1] = t - // amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` t = x[2*i+1] - // amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` y[2*i+1] = t - // amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*` - // 386: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*` + // amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*` + // 386: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*` t = x[16*i+1] - // amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` - // 386: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` + // amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` + // 386: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` y[16*i+1] = t - // amd64: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` - // 386: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // amd64: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+1] = 77 - // amd64: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` - // 386: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` + // amd64: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` + // 386: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` x[16*i+1] = 77 } func idxInt64(x, y []int64, i int) { var t int64 - // amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` t = x[i+1] - // amd64: `MOVQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `MOVQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` y[i+1] = t - // amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*` + // amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*` t = x[16*i+1] - // amd64: `MOVQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)` + // amd64: `MOVQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)` y[16*i+1] = t - // amd64: `MOVQ\t[$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `MOVQ [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+1] = 77 - // amd64: `MOVQ\t[$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)` + // amd64: `MOVQ [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)` x[16*i+1] = 77 } func idxFloat32(x, y []float32, i int) { var t float32 - // amd64: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` - // 386/sse2: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` - // arm64: `FMOVS\t\(R[0-9]*\)\(R[0-9]*<<2\), F[0-9]+` + // amd64: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` + // 386/sse2: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` + // arm64: `FMOVS \(R[0-9]*\)\(R[0-9]*<<2\), F[0-9]+` t = x[i+1] - // amd64: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` - // 386/sse2: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` - // arm64: `FMOVS\tF[0-9]+, \(R[0-9]*\)\(R[0-9]*<<2\)` + // amd64: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386/sse2: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // arm64: `FMOVS F[0-9]+, \(R[0-9]*\)\(R[0-9]*<<2\)` y[i+1] = t - // amd64: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+` - // 386/sse2: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+` + // amd64: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+` + // 386/sse2: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+` t = x[16*i+1] - // amd64: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` - // 386/sse2: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` + // amd64: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` + // 386/sse2: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)` y[16*i+1] = t } func idxFloat64(x, y []float64, i int) { var t float64 - // amd64: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` - // 386/sse2: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` - // arm64: `FMOVD\t\(R[0-9]*\)\(R[0-9]*<<3\), F[0-9]+` + // amd64: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` + // 386/sse2: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` + // arm64: `FMOVD \(R[0-9]*\)\(R[0-9]*<<3\), F[0-9]+` t = x[i+1] - // amd64: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` - // 386/sse2: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` - // arm64: `FMOVD\tF[0-9]+, \(R[0-9]*\)\(R[0-9]*<<3\)` + // amd64: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // 386/sse2: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // arm64: `FMOVD F[0-9]+, \(R[0-9]*\)\(R[0-9]*<<3\)` y[i+1] = t - // amd64: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+` - // 386/sse2: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+` + // amd64: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+` + // 386/sse2: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+` t = x[16*i+1] - // amd64: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)` - // 386/sse2: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)` + // amd64: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)` + // 386/sse2: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)` y[16*i+1] = t } func idxLoadPlusOp32(x []int32, i int) int32 { s := x[0] - // 386: `ADDL\t4\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` - // amd64: `ADDL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // 386: `ADDL 4\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` + // amd64: `ADDL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s += x[i+1] - // 386: `SUBL\t8\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` - // amd64: `SUBL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // 386: `SUBL 8\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` + // amd64: `SUBL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s -= x[i+2] - // 386: `IMULL\t12\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` + // 386: `IMULL 12\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` s *= x[i+3] - // 386: `ANDL\t16\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` - // amd64: `ANDL\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // 386: `ANDL 16\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` + // amd64: `ANDL 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s &= x[i+4] - // 386: `ORL\t20\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` - // amd64: `ORL\t20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // 386: `ORL 20\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` + // amd64: `ORL 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s |= x[i+5] - // 386: `XORL\t24\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` - // amd64: `XORL\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // 386: `XORL 24\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+` + // amd64: `XORL 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` s ^= x[i+6] return s } func idxLoadPlusOp64(x []int64, i int) int64 { s := x[0] - // amd64: `ADDQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `ADDQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s += x[i+1] - // amd64: `SUBQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `SUBQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s -= x[i+2] - // amd64: `ANDQ\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `ANDQ 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s &= x[i+3] - // amd64: `ORQ\t32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `ORQ 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s |= x[i+4] - // amd64: `XORQ\t40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `XORQ 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` s ^= x[i+5] return s } func idxStorePlusOp32(x []int32, i int, v int32) { - // 386: `ADDL\t[A-Z]+, 4\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `ADDL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `ADDL [A-Z]+, 4\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `ADDL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+1] += v - // 386: `SUBL\t[A-Z]+, 8\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `SUBL\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `SUBL [A-Z]+, 8\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `SUBL [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+2] -= v - // 386: `ANDL\t[A-Z]+, 12\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `ANDL\t[A-Z]+[0-9]*, 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `ANDL [A-Z]+, 12\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `ANDL [A-Z]+[0-9]*, 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+3] &= v - // 386: `ORL\t[A-Z]+, 16\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `ORL\t[A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `ORL [A-Z]+, 16\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `ORL [A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+4] |= v - // 386: `XORL\t[A-Z]+, 20\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `XORL\t[A-Z]+[0-9]*, 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `XORL [A-Z]+, 20\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `XORL [A-Z]+[0-9]*, 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+5] ^= v - // 386: `ADDL\t[$]77, 24\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `ADDL\t[$]77, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `ADDL [$]77, 24\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `ADDL [$]77, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+6] += 77 - // 386: `ANDL\t[$]77, 28\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `ANDL\t[$]77, 28\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `ANDL [$]77, 28\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `ANDL [$]77, 28\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+7] &= 77 - // 386: `ORL\t[$]77, 32\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `ORL\t[$]77, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `ORL [$]77, 32\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `ORL [$]77, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+8] |= 77 - // 386: `XORL\t[$]77, 36\([A-Z]+\)\([A-Z]+\*4\)` - // amd64: `XORL\t[$]77, 36\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` + // 386: `XORL [$]77, 36\([A-Z]+\)\([A-Z]+\*4\)` + // amd64: `XORL [$]77, 36\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)` x[i+9] ^= 77 } func idxStorePlusOp64(x []int64, i int, v int64) { - // amd64: `ADDQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `ADDQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+1] += v - // amd64: `SUBQ\t[A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `SUBQ [A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+2] -= v - // amd64: `ANDQ\t[A-Z]+[0-9]*, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `ANDQ [A-Z]+[0-9]*, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+3] &= v - // amd64: `ORQ\t[A-Z]+[0-9]*, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `ORQ [A-Z]+[0-9]*, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+4] |= v - // amd64: `XORQ\t[A-Z]+[0-9]*, 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `XORQ [A-Z]+[0-9]*, 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+5] ^= v - // amd64: `ADDQ\t[$]77, 48\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `ADDQ [$]77, 48\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+6] += 77 - // amd64: `ANDQ\t[$]77, 56\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `ANDQ [$]77, 56\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+7] &= 77 - // amd64: `ORQ\t[$]77, 64\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `ORQ [$]77, 64\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+8] |= 77 - // amd64: `XORQ\t[$]77, 72\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` + // amd64: `XORQ [$]77, 72\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)` x[i+9] ^= 77 } func idxCompare(i int) int { - // amd64: `MOVBLZX\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` + // amd64: `MOVBLZX 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` if x8[i+1] < x8[0] { return 0 } - // amd64: `MOVWLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*` + // amd64: `MOVWLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*` if x16[i+1] < x16[0] { return 0 } - // amd64: `MOVWLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*` + // amd64: `MOVWLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*` if x16[16*i+1] < x16[0] { return 0 } - // amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` if x32[i+1] < x32[0] { return 0 } - // amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*` + // amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*` if x32[16*i+1] < x32[0] { return 0 } - // amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` if x64[i+1] < x64[0] { return 0 } - // amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*` + // amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*` if x64[16*i+1] < x64[0] { return 0 } - // amd64: `MOVBLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` + // amd64: `MOVBLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*` if x8[i+2] < 77 { return 0 } - // amd64: `MOVWLZX\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*` + // amd64: `MOVWLZX 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*` if x16[i+2] < 77 { return 0 } - // amd64: `MOVWLZX\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*` + // amd64: `MOVWLZX 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*` if x16[16*i+2] < 77 { return 0 } - // amd64: `MOVL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` + // amd64: `MOVL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*` if x32[i+2] < 77 { return 0 } - // amd64: `MOVL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*` + // amd64: `MOVL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*` if x32[16*i+2] < 77 { return 0 } - // amd64: `MOVQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` + // amd64: `MOVQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*` if x64[i+2] < 77 { return 0 } - // amd64: `MOVQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*` + // amd64: `MOVQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*` if x64[16*i+2] < 77 { return 0 } @@ -345,59 +345,59 @@ func idxCompare(i int) int { func idxFloatOps(a []float64, b []float32, i int) (float64, float32) { c := float64(7) - // amd64: `ADDSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` + // amd64: `ADDSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` c += a[i+1] - // amd64: `SUBSD\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` + // amd64: `SUBSD 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` c -= a[i+2] - // amd64: `MULSD\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` + // amd64: `MULSD 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` c *= a[i+3] - // amd64: `DIVSD\t32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` + // amd64: `DIVSD 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+` c /= a[i+4] d := float32(8) - // amd64: `ADDSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` + // amd64: `ADDSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` d += b[i+1] - // amd64: `SUBSS\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` + // amd64: `SUBSS 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` d -= b[i+2] - // amd64: `MULSS\t12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` + // amd64: `MULSS 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` d *= b[i+3] - // amd64: `DIVSS\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` + // amd64: `DIVSS 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+` d /= b[i+4] return c, d } func storeTest(a []bool, v int, i int) { - // amd64: `BTL\t\$0,`,`SETCS\t4\([A-Z]+[0-9]*\)` + // amd64: `BTL \$0,`,`SETCS 4\([A-Z]+[0-9]*\)` a[4] = v&1 != 0 - // amd64: `BTL\t\$1,`,`SETCS\t3\([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 } func bitOps(p *[12]uint64) { - // amd64: `ORQ\t\$8, \(AX\)` + // amd64: `ORQ \$8, \(AX\)` p[0] |= 8 - // amd64: `ORQ\t\$1073741824, 8\(AX\)` + // amd64: `ORQ \$1073741824, 8\(AX\)` p[1] |= 1 << 30 - // amd64: `BTSQ\t\$31, 16\(AX\)` + // amd64: `BTSQ \$31, 16\(AX\)` p[2] |= 1 << 31 - // amd64: `BTSQ\t\$63, 24\(AX\)` + // amd64: `BTSQ \$63, 24\(AX\)` p[3] |= 1 << 63 - // amd64: `ANDQ\t\$-9, 32\(AX\)` + // amd64: `ANDQ \$-9, 32\(AX\)` p[4] &^= 8 - // amd64: `ANDQ\t\$-1073741825, 40\(AX\)` + // amd64: `ANDQ \$-1073741825, 40\(AX\)` p[5] &^= 1 << 30 - // amd64: `BTRQ\t\$31, 48\(AX\)` + // amd64: `BTRQ \$31, 48\(AX\)` p[6] &^= 1 << 31 - // amd64: `BTRQ\t\$63, 56\(AX\)` + // amd64: `BTRQ \$63, 56\(AX\)` p[7] &^= 1 << 63 - // amd64: `XORQ\t\$8, 64\(AX\)` + // amd64: `XORQ \$8, 64\(AX\)` p[8] ^= 8 - // amd64: `XORQ\t\$1073741824, 72\(AX\)` + // amd64: `XORQ \$1073741824, 72\(AX\)` p[9] ^= 1 << 30 - // amd64: `BTCQ\t\$31, 80\(AX\)` + // amd64: `BTCQ \$31, 80\(AX\)` p[10] ^= 1 << 31 - // amd64: `BTCQ\t\$63, 88\(AX\)` + // amd64: `BTCQ \$63, 88\(AX\)` p[11] ^= 1 << 63 } diff --git a/test/codegen/multiply.go b/test/codegen/multiply.go index 8c408cbfba..166bc104d0 100644 --- a/test/codegen/multiply.go +++ b/test/codegen/multiply.go @@ -11,8 +11,8 @@ package codegen func m0(x int64) int64 { // amd64: "XORL" - // arm64: "MOVD\tZR" - // loong64: "MOVV\tR0" + // arm64: "MOVD ZR" + // loong64: "MOVV R0" return x * 0 } func m2(x int64) int64 { @@ -22,351 +22,351 @@ func m2(x int64) int64 { return x * 2 } func m3(x int64) int64 { - // amd64: "LEAQ\t.*[*]2" - // arm64: "ADD\tR[0-9]+<<1," - // loong64: "ALSLV\t[$]1," + // amd64: "LEAQ .*[*]2" + // arm64: "ADD R[0-9]+<<1," + // loong64: "ALSLV [$]1," return x * 3 } func m4(x int64) int64 { - // amd64: "SHLQ\t[$]2," - // arm64: "LSL\t[$]2," - // loong64: "SLLV\t[$]2," + // amd64: "SHLQ [$]2," + // arm64: "LSL [$]2," + // loong64: "SLLV [$]2," return x * 4 } func m5(x int64) int64 { - // amd64: "LEAQ\t.*[*]4" - // arm64: "ADD\tR[0-9]+<<2," - // loong64: "ALSLV\t[$]2," + // amd64: "LEAQ .*[*]4" + // arm64: "ADD R[0-9]+<<2," + // loong64: "ALSLV [$]2," return x * 5 } func m6(x int64) int64 { - // amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]2" - // arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<1," + // 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\t.*[*]2" - // arm64: "LSL\t[$]3,", "SUB\tR[0-9]+," - // loong64: "ALSLV\t[$]1,", "ALSLV\t[$]1," + // amd64: "LEAQ .*[*]2" + // arm64: "LSL [$]3,", "SUB R[0-9]+," + // loong64: "ALSLV [$]1,", "ALSLV [$]1," return x * 7 } func m8(x int64) int64 { - // amd64: "SHLQ\t[$]3," - // arm64: "LSL\t[$]3," - // loong64: "SLLV\t[$]3," + // amd64: "SHLQ [$]3," + // arm64: "LSL [$]3," + // loong64: "SLLV [$]3," return x * 8 } func m9(x int64) int64 { - // amd64: "LEAQ\t.*[*]8" - // arm64: "ADD\tR[0-9]+<<3," - // loong64: "ALSLV\t[$]3," + // amd64: "LEAQ .*[*]8" + // arm64: "ADD R[0-9]+<<3," + // loong64: "ALSLV [$]3," return x * 9 } func m10(x int64) int64 { - // amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]4" - // arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<2," - // loong64: "ADDVU", "ALSLV\t[$]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\t.*[*]4", "LEAQ\t.*[*]2" - // arm64: "MOVD\t[$]11,", "MUL" - // loong64: "ALSLV\t[$]2,", "ALSLV\t[$]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\t.*[*]2", "SHLQ\t[$]2," - // arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<1," - // loong64: "SLLV", "ALSLV\t[$]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\t.*[*]2", "LEAQ\t.*[*]4" - // arm64: "MOVD\t[$]13,", "MUL" - // loong64: "ALSLV\t[$]1,", "ALSLV\t[$]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\t[$]14," - // arm64: "LSL\t[$]4,", "SUB\tR[0-9]+<<1," - // loong64: "ADDVU", "ALSLV\t[$]1", "ALSLV\t[$]2" + // amd64: "IMUL3Q [$]14," + // arm64: "LSL [$]4,", "SUB R[0-9]+<<1," + // loong64: "ADDVU", "ALSLV [$]1", "ALSLV [$]2" return x * 14 } func m15(x int64) int64 { - // amd64: "LEAQ\t.*[*]2", "LEAQ\t.*[*]4" - // arm64: "LSL\t[$]4,", "SUB\tR[0-9]+," - // loong64: "ALSLV\t[$]1,", "ALSLV\t[$]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 { - // amd64: "SHLQ\t[$]4," - // arm64: "LSL\t[$]4," - // loong64: "SLLV\t[$]4," + // amd64: "SHLQ [$]4," + // arm64: "LSL [$]4," + // loong64: "SLLV [$]4," return x * 16 } func m17(x int64) int64 { - // amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]8" - // arm64: "ADD\tR[0-9]+<<4," - // loong64: "ALSLV\t[$]" + // amd64: "LEAQ .*[*]1", "LEAQ .*[*]8" + // arm64: "ADD R[0-9]+<<4," + // loong64: "ALSLV [$]" return x * 17 } func m18(x int64) int64 { - // amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]8" - // arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<3," - // loong64: "ADDVU", "ALSLV\t[$]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\t.*[*]8", "LEAQ\t.*[*]2" - // arm64: "MOVD\t[$]19,", "MUL" - // loong64: "ALSLV\t[$]3,", "ALSLV\t[$]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\t.*[*]4", "SHLQ\t[$]2," - // arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<2," - // loong64: "SLLV\t[$]2,", "ALSLV\t[$]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\t.*[*]4", "LEAQ\t.*[*]4" - // arm64: "MOVD\t[$]21,", "MUL" - // loong64: "ALSLV\t[$]2,", "ALSLV\t[$]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\t[$]22," - // arm64: "MOVD\t[$]22,", "MUL" - // loong64: "ADDVU", "ALSLV\t[$]2,", "ALSLV\t[$]2," + // amd64: "IMUL3Q [$]22," + // arm64: "MOVD [$]22,", "MUL" + // loong64: "ADDVU", "ALSLV [$]2,", "ALSLV [$]2," return x * 22 } func m23(x int64) int64 { - // amd64: "IMUL3Q\t[$]23," - // arm64: "MOVD\t[$]23,", "MUL" - // loong64: "ALSLV\t[$]1,", "SUBVU", "ALSLV\t[$]3," + // amd64: "IMUL3Q [$]23," + // arm64: "MOVD [$]23,", "MUL" + // loong64: "ALSLV [$]1,", "SUBVU", "ALSLV [$]3," return x * 23 } func m24(x int64) int64 { - // amd64: "LEAQ\t.*[*]2", "SHLQ\t[$]3," - // arm64: "LSL\t[$]3,", "ADD\tR[0-9]+<<1," - // loong64: "SLLV\t[$]3", "ALSLV\t[$]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\t.*[*]4", "LEAQ\t.*[*]4" - // arm64: "MOVD\t[$]25,", "MUL" - // loong64: "ALSLV\t[$]2,", "ALSLV\t[$]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\t[$]26," - // arm64: "MOVD\t[$]26,", "MUL" - // loong64: "ADDVU", "ALSLV\t[$]1,", "ALSLV\t[$]3," + // amd64: "IMUL3Q [$]26," + // arm64: "MOVD [$]26,", "MUL" + // loong64: "ADDVU", "ALSLV [$]1,", "ALSLV [$]3," return x * 26 } func m27(x int64) int64 { - // amd64: "LEAQ\t.*[*]2", "LEAQ\t.*[*]8" - // arm64: "MOVD\t[$]27,", "MUL" - // loong64: "ALSLV\t[$]1,", "ALSLV\t[$]3," + // amd64: "LEAQ .*[*]2", "LEAQ .*[*]8" + // arm64: "MOVD [$]27,", "MUL" + // loong64: "ALSLV [$]1,", "ALSLV [$]3," return x * 27 } func m28(x int64) int64 { - // amd64: "IMUL3Q\t[$]28," - // arm64: "LSL\t[$]5, "SUB\tR[0-9]+<<2," - // loong64: "ALSLV\t[$]1,","SLLV\t[$]2,","ALSLV\t[$]3," + // amd64: "IMUL3Q [$]28," + // arm64: "LSL [$]5, "SUB R[0-9]+<<2," + // loong64: "ALSLV [$]1," "SLLV [$]2," "ALSLV [$]3," return x * 28 } func m29(x int64) int64 { - // amd64: "IMUL3Q\t[$]29," - // arm64: "MOVD\t[$]29,", "MUL" - // loong64: "ALSLV\t[$]1,","SLLV\t[$]5,","SUBVU" + // amd64: "IMUL3Q [$]29," + // arm64: "MOVD [$]29,", "MUL" + // loong64: "ALSLV [$]1," "SLLV [$]5," "SUBVU" return x * 29 } func m30(x int64) int64 { - // amd64: "IMUL3Q\t[$]30," - // arm64: "LSL\t[$]5,", "SUB\tR[0-9]+<<1," - // loong64: "ADDVU","SLLV\t[$]5,","SUBVU" + // amd64: "IMUL3Q [$]30," + // arm64: "LSL [$]5,", "SUB R[0-9]+<<1," + // loong64: "ADDVU" "SLLV [$]5," "SUBVU" return x * 30 } func m31(x int64) int64 { - // amd64: "SHLQ\t[$]5,", "SUBQ" - // arm64: "LSL\t[$]5,", "SUB\tR[0-9]+," - // loong64: "SLLV\t[$]5,","SUBVU" + // amd64: "SHLQ [$]5,", "SUBQ" + // arm64: "LSL [$]5,", "SUB R[0-9]+," + // loong64: "SLLV [$]5," "SUBVU" return x * 31 } func m32(x int64) int64 { - // amd64: "SHLQ\t[$]5," - // arm64: "LSL\t[$]5," - // loong64: "SLLV\t[$]5," + // amd64: "SHLQ [$]5," + // arm64: "LSL [$]5," + // loong64: "SLLV [$]5," return x * 32 } func m33(x int64) int64 { - // amd64: "SHLQ\t[$]2,", "LEAQ\t.*[*]8" - // arm64: "ADD\tR[0-9]+<<5," - // loong64: "ADDVU", "ALSLV\t[$]4," + // amd64: "SHLQ [$]2,", "LEAQ .*[*]8" + // arm64: "ADD R[0-9]+<<5," + // loong64: "ADDVU", "ALSLV [$]4," return x * 33 } func m34(x int64) int64 { - // amd64: "SHLQ\t[$]5,", "LEAQ\t.*[*]2" - // arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<4," - // loong64: "ADDVU", "ALSLV\t[$]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\t[$]35," - // arm64: "MOVD\t[$]35,", "MUL" - // loong64: "ALSLV\t[$]4,", "ALSLV\t[$]1," + // amd64: "IMUL3Q [$]35," + // arm64: "MOVD [$]35,", "MUL" + // loong64: "ALSLV [$]4,", "ALSLV [$]1," return x * 35 } func m36(x int64) int64 { - // amd64: "LEAQ\t.*[*]8", "SHLQ\t[$]2," - // arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<3," - // loong64: "SLLV\t[$]2,", "ALSLV\t[$]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\t.*[*]8", "LEAQ\t.*[*]4" - // arm64: "MOVD\t[$]37,", "MUL" - // loong64: "ALSLV\t[$]3,", "ALSLV\t[$]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\t[$]38," - // arm64: "MOVD\t[$]38,", "MUL" - // loong64: "ALSLV\t[$]3,", "ALSLV\t[$]2," + // amd64: "IMUL3Q [$]38," + // arm64: "MOVD [$]38,", "MUL" + // loong64: "ALSLV [$]3,", "ALSLV [$]2," return x * 38 } func m39(x int64) int64 { - // amd64: "IMUL3Q\t[$]39," - // arm64: "MOVD\t[$]39,", "MUL" - // loong64: "ALSLV\t[$]2,", "SUBVU", "ALSLV\t[$]3," + // amd64: "IMUL3Q [$]39," + // arm64: "MOVD [$]39,", "MUL" + // loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]3," return x * 39 } func m40(x int64) int64 { - // amd64: "LEAQ\t.*[*]4", "SHLQ\t[$]3," - // arm64: "LSL\t[$]3,", "ADD\tR[0-9]+<<2," - // loong64: "SLLV\t[$]3,", "ALSLV\t[$]2," + // amd64: "LEAQ .*[*]4", "SHLQ [$]3," + // arm64: "LSL [$]3,", "ADD R[0-9]+<<2," + // loong64: "SLLV [$]3,", "ALSLV [$]2," return x * 40 } func mn1(x int64) int64 { - // amd64: "NEGQ\t" - // arm64: "NEG\tR[0-9]+," - // loong64: "SUBVU\tR[0-9], R0," + // amd64: "NEGQ " + // arm64: "NEG R[0-9]+," + // loong64: "SUBVU R[0-9], R0," return x * -1 } func mn2(x int64) int64 { // amd64: "NEGQ", "ADDQ" - // arm64: "NEG\tR[0-9]+<<1," - // loong64: "ADDVU","SUBVU\tR[0-9], R0," + // arm64: "NEG R[0-9]+<<1," + // loong64: "ADDVU" "SUBVU R[0-9], R0," return x * -2 } func mn3(x int64) int64 { - // amd64: "NEGQ", "LEAQ\t.*[*]2" - // arm64: "SUB\tR[0-9]+<<2," - // loong64: "SUBVU", "ALSLV\t[$]1," + // amd64: "NEGQ", "LEAQ .*[*]2" + // arm64: "SUB R[0-9]+<<2," + // loong64: "SUBVU", "ALSLV [$]1," return x * -3 } func mn4(x int64) int64 { - // amd64: "NEGQ", "SHLQ\t[$]2," - // arm64: "NEG\tR[0-9]+<<2," - // loong64: "SLLV\t[$]2,","SUBVU\tR[0-9], R0," + // 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\t.*[*]4" - // arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<2," - // loong64: "SUBVU", "ALSLV\t[$]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\t[$]-6," - // arm64: "ADD\tR[0-9]+,", "SUB\tR[0-9]+<<2," - // loong64: "ADDVU", "SUBVU", "ALSLV\t[$]3," + // amd64: "IMUL3Q [$]-6," + // 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\t.*[*]8" - // arm64: "SUB\tR[0-9]+<<3," - // loong64: "SUBVU", "ALSLV\t[$]3," + // amd64: "NEGQ", "LEAQ .*[*]8" + // arm64: "SUB R[0-9]+<<3," + // loong64: "SUBVU", "ALSLV [$]3," return x * -7 } func mn8(x int64) int64 { - // amd64: "NEGQ", "SHLQ\t[$]3," - // arm64: "NEG\tR[0-9]+<<3," - // loong64: "SLLV\t[$]3","SUBVU\tR[0-9], R0," + // 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\t.*[*]8" - // arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<3," - // loong64: "SUBVU", "ALSLV\t[$]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\t[$]-10," - // arm64: "MOVD\t[$]-10,", "MUL" - // loong64: "ADDVU", "ALSLV\t[$]3", "SUBVU" + // amd64: "IMUL3Q [$]-10," + // arm64: "MOVD [$]-10,", "MUL" + // loong64: "ADDVU", "ALSLV [$]3", "SUBVU" return x * -10 } func mn11(x int64) int64 { - // amd64: "IMUL3Q\t[$]-11," - // arm64: "MOVD\t[$]-11,", "MUL" - // loong64: "ALSLV\t[$]2,", "SUBVU", "ALSLV\t[$]4," + // amd64: "IMUL3Q [$]-11," + // arm64: "MOVD [$]-11,", "MUL" + // loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]4," return x * -11 } func mn12(x int64) int64 { - // amd64: "IMUL3Q\t[$]-12," - // arm64: "LSL\t[$]2,", "SUB\tR[0-9]+<<2," - // loong64: "SUBVU", "SLLV\t[$]2,", "ALSLV\t[$]4," + // amd64: "IMUL3Q [$]-12," + // arm64: "LSL [$]2,", "SUB R[0-9]+<<2," + // loong64: "SUBVU", "SLLV [$]2,", "ALSLV [$]4," return x * -12 } func mn13(x int64) int64 { - // amd64: "IMUL3Q\t[$]-13," - // arm64: "MOVD\t[$]-13,", "MUL" - // loong64: "ALSLV\t[$]4,", "SLLV\t[$]2, ", "SUBVU" + // amd64: "IMUL3Q [$]-13," + // arm64: "MOVD [$]-13,", "MUL" + // loong64: "ALSLV [$]4,", "SLLV [$]2, ", "SUBVU" return x * -13 } func mn14(x int64) int64 { - // amd64: "IMUL3Q\t[$]-14," - // arm64: "ADD\tR[0-9]+,", "SUB\tR[0-9]+<<3," - // loong64: "ADDVU", "SUBVU", "ALSLV\t[$]4," + // amd64: "IMUL3Q [$]-14," + // 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\t[$]4,", "SUBQ" - // arm64: "SUB\tR[0-9]+<<4," - // loong64: "SUBVU", "ALSLV\t[$]4," + // amd64: "SHLQ [$]4,", "SUBQ" + // arm64: "SUB R[0-9]+<<4," + // loong64: "SUBVU", "ALSLV [$]4," return x * -15 } func mn16(x int64) int64 { - // amd64: "NEGQ", "SHLQ\t[$]4," - // arm64: "NEG\tR[0-9]+<<4," - // loong64: "SLLV\t[$]4,","SUBVU\tR[0-9], R0," + // 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\t[$]-17," - // arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<4," - // loong64: "SUBVU", "ALSLV\t[$]4," + // amd64: "IMUL3Q [$]-17," + // arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<4," + // loong64: "SUBVU", "ALSLV [$]4," return x * -17 } func mn18(x int64) int64 { - // amd64: "IMUL3Q\t[$]-18," - // arm64: "MOVD\t[$]-18,", "MUL" - // loong64: "ADDVU", "ALSLV\t[$]4,", "SUBVU" + // amd64: "IMUL3Q [$]-18," + // arm64: "MOVD [$]-18,", "MUL" + // loong64: "ADDVU", "ALSLV [$]4,", "SUBVU" return x * -18 } func mn19(x int64) int64 { - // amd64: "IMUL3Q\t[$]-19," - // arm64: "MOVD\t[$]-19,", "MUL" - // loong64: "ALSLV\t[$]1,", "ALSLV\t[$]4,", "SUBVU" + // amd64: "IMUL3Q [$]-19," + // arm64: "MOVD [$]-19,", "MUL" + // loong64: "ALSLV [$]1,", "ALSLV [$]4,", "SUBVU" return x * -19 } func mn20(x int64) int64 { - // amd64: "IMUL3Q\t[$]-20," - // arm64: "MOVD\t[$]-20,", "MUL" - // loong64: "SLLV\t[$]2,", "ALSLV\t[$]4,", "SUBVU" + // amd64: "IMUL3Q [$]-20," + // arm64: "MOVD [$]-20,", "MUL" + // loong64: "SLLV [$]2,", "ALSLV [$]4,", "SUBVU" return x * -20 } diff --git a/test/codegen/noextend.go b/test/codegen/noextend.go index 193f75b092..d9f1c77289 100644 --- a/test/codegen/noextend.go +++ b/test/codegen/noextend.go @@ -26,7 +26,7 @@ var val8 [8]uint8 func set16(x8 int8, u8 *uint8, y8 int8, z8 uint8) { // Truncate not needed, load does sign/zero extend - // ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVBZ R\\d+,\\sR\\d+" val16[0] = uint16(*u8) // AND not needed due to size @@ -39,20 +39,20 @@ func set16(x8 int8, u8 *uint8, y8 int8, z8 uint8) { } func shiftidx(u8 *uint8, x16 *int16, u16 *uint16) { - // ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVBZ R\\d+,\\sR\\d+" val16[0] = uint16(sval16[*u8>>2]) - // ppc64x:-"MOVH\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVH R\\d+,\\sR\\d+" sval16[1] = int16(val16[*x16>>1]) - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" val16[1] = uint16(sval16[*u16>>2]) } func setnox(x8 int8, u8 *uint8, y8 *int8, z8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) { - // ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVBZ R\\d+,\\sR\\d+" val16[0] = uint16(*u8) // AND not needed due to size @@ -62,65 +62,65 @@ func setnox(x8 int8, u8 *uint8, y8 *int8, z8 *uint8, x16 *int16, u16 *uint16, x3 // ppc64x:-"ANDCC" val16[1] = 255 & uint16(*u8+*z8) - // ppc64x:-"MOVH\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVH R\\d+,\\sR\\d+" sval32[1] = int32(*x16) - // ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVBZ R\\d+,\\sR\\d+" val32[0] = uint32(*u8) - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" val32[1] = uint32(*u16) - // ppc64x:-"MOVH\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVH R\\d+,\\sR\\d+" sval64[1] = int64(*x16) - // ppc64x:-"MOVW\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVW R\\d+,\\sR\\d+" sval64[2] = int64(*x32) - // ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVBZ R\\d+,\\sR\\d+" val64[0] = uint64(*u8) - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" val64[1] = uint64(*u16) - // ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVWZ R\\d+,\\sR\\d+" val64[2] = uint64(*u32) } func cmp16(u8 *uint8, x32 *int32, u32 *uint32, x64 *int64, u64 *uint64) bool { - // ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVBZ R\\d+,\\sR\\d+" if uint16(*u8) == val16[0] { return true } - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" if uint16(*u32>>16) == val16[0] { return true } - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" if uint16(*u64>>48) == val16[0] { return true } // Verify the truncates are using the correct sign. - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" if int16(*x32) == sval16[0] { return true } - // ppc64x:-"MOVH\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVH R\\d+,\\sR\\d+" if uint16(*u32) == val16[0] { return true } - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" if int16(*x64) == sval16[0] { return true } - // ppc64x:-"MOVH\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVH R\\d+,\\sR\\d+" if uint16(*u64) == val16[0] { return true } @@ -130,28 +130,28 @@ func cmp16(u8 *uint8, x32 *int32, u32 *uint32, x64 *int64, u64 *uint64) bool { func cmp32(u8 *uint8, x16 *int16, u16 *uint16, x64 *int64, u64 *uint64) bool { - // ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVBZ R\\d+,\\sR\\d+" if uint32(*u8) == val32[0] { return true } - // ppc64x:-"MOVH\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVH R\\d+,\\sR\\d+" if int32(*x16) == sval32[0] { return true } - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" if uint32(*u16) == val32[0] { return true } // Verify the truncates are using the correct sign. - // ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVWZ R\\d+,\\sR\\d+" if int32(*x64) == sval32[0] { return true } - // ppc64x:-"MOVW\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVW R\\d+,\\sR\\d+" if uint32(*u64) == val32[0] { return true } @@ -161,27 +161,27 @@ func cmp32(u8 *uint8, x16 *int16, u16 *uint16, x64 *int64, u64 *uint64) bool { func cmp64(u8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) bool { - // ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVBZ R\\d+,\\sR\\d+" if uint64(*u8) == val64[0] { return true } - // ppc64x:-"MOVH\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVH R\\d+,\\sR\\d+" if int64(*x16) == sval64[0] { return true } - // ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVHZ R\\d+,\\sR\\d+" if uint64(*u16) == val64[0] { return true } - // ppc64x:-"MOVW\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVW R\\d+,\\sR\\d+" if int64(*x32) == sval64[0] { return true } - // ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+" + // ppc64x:-"MOVWZ R\\d+,\\sR\\d+" if uint64(*u32) == val64[0] { return true } @@ -193,40 +193,40 @@ func cmp64(u8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) bool { func noUnsignEXT(t1, t2, t3, t4 uint32, k int64) uint64 { var ret uint64 - // arm64:"RORW",-"MOVWU" + // arm64:"RORW" -"MOVWU" ret += uint64(bits.RotateLeft32(t1, 7)) - // arm64:"MULW",-"MOVWU" + // arm64:"MULW" -"MOVWU" ret *= uint64(t1 * t2) - // arm64:"MNEGW",-"MOVWU" + // arm64:"MNEGW" -"MOVWU" ret += uint64(-t1 * t3) - // arm64:"UDIVW",-"MOVWU" + // arm64:"UDIVW" -"MOVWU" ret += uint64(t1 / t4) // arm64:-"MOVWU" ret += uint64(t2 % t3) - // arm64:"MSUBW",-"MOVWU" + // arm64:"MSUBW" -"MOVWU" ret += uint64(t1 - t2*t3) - // arm64:"MADDW",-"MOVWU" + // arm64:"MADDW" -"MOVWU" ret += uint64(t3*t4 + t2) - // arm64:"REVW",-"MOVWU" + // arm64:"REVW" -"MOVWU" ret += uint64(bits.ReverseBytes32(t1)) - // arm64:"RBITW",-"MOVWU" + // arm64:"RBITW" -"MOVWU" ret += uint64(bits.Reverse32(t1)) - // arm64:"CLZW",-"MOVWU" + // arm64:"CLZW" -"MOVWU" ret += uint64(bits.LeadingZeros32(t1)) - // arm64:"REV16W",-"MOVWU" + // arm64:"REV16W" -"MOVWU" ret += uint64(((t1 & 0xff00ff00) >> 8) | ((t1 & 0x00ff00ff) << 8)) - // arm64:"EXTRW",-"MOVWU" + // arm64:"EXTRW" -"MOVWU" ret += uint64((t1 << 25) | (t2 >> 7)) return ret diff --git a/test/codegen/reflect_type.go b/test/codegen/reflect_type.go index b92a9567f1..6b3eae96f5 100644 --- a/test/codegen/reflect_type.go +++ b/test/codegen/reflect_type.go @@ -9,13 +9,13 @@ package codegen import "reflect" func intPtrTypeSize() uintptr { - // amd64:"MOVL\t[$]8,",-"CALL" - // arm64:"MOVD\t[$]8,",-"CALL" + // amd64:"MOVL [$]8," -"CALL" + // arm64:"MOVD [$]8," -"CALL" return reflect.TypeFor[*int]().Size() } func intPtrTypeKind() reflect.Kind { - // amd64:"MOVL\t[$]22,",-"CALL" - // arm64:"MOVD\t[$]22,",-"CALL" + // amd64:"MOVL [$]22," -"CALL" + // arm64:"MOVD [$]22," -"CALL" return reflect.TypeFor[*int]().Kind() } diff --git a/test/codegen/regabi_regalloc.go b/test/codegen/regabi_regalloc.go index a7b7bd52bc..8ac6a3da9c 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\tBX, CX", "MOVQ\tAX, BX", "MOVL\t\\$1, AX", -"MOVQ\t.*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\tBX, AX", "MOVQ\t[AB]X, CX", -"MOVQ\t.*, BX" + // amd64:"MOVQ BX, AX", "MOVQ [AB]X, CX", -"MOVQ .*, BX" g(b, b, b) } diff --git a/test/codegen/retpoline.go b/test/codegen/retpoline.go index 0e8f661ec9..e733a49d8a 100644 --- a/test/codegen/retpoline.go +++ b/test/codegen/retpoline.go @@ -5,12 +5,12 @@ package codegen func CallFunc(f func()) { - // amd64:`CALL\truntime.retpoline` + // amd64:`CALL runtime.retpoline` f() } func CallInterface(x interface{ M() }) { - // amd64:`CALL\truntime.retpoline` + // amd64:`CALL runtime.retpoline` x.M() } diff --git a/test/codegen/rotate.go b/test/codegen/rotate.go index 121ce4cc0a..17bd27a4d0 100644 --- a/test/codegen/rotate.go +++ b/test/codegen/rotate.go @@ -15,36 +15,36 @@ import "math/bits" func rot64(x uint64) uint64 { var a uint64 - // amd64:"ROLQ\t[$]7" - // ppc64x:"ROTL\t[$]7" - // loong64: "ROTRV\t[$]57" - // riscv64: "RORI\t[$]57" + // amd64:"ROLQ [$]7" + // ppc64x:"ROTL [$]7" + // loong64: "ROTRV [$]57" + // riscv64: "RORI [$]57" a += x<<7 | x>>57 - // amd64:"ROLQ\t[$]8" - // arm64:"ROR\t[$]56" - // s390x:"RISBGZ\t[$]0, [$]63, [$]8, " - // ppc64x:"ROTL\t[$]8" - // loong64: "ROTRV\t[$]56" - // riscv64: "RORI\t[$]56" + // amd64:"ROLQ [$]8" + // arm64:"ROR [$]56" + // s390x:"RISBGZ [$]0, [$]63, [$]8, " + // ppc64x:"ROTL [$]8" + // loong64: "ROTRV [$]56" + // riscv64: "RORI [$]56" a += x<<8 + x>>56 - // amd64:"ROLQ\t[$]9" - // arm64:"ROR\t[$]55" - // s390x:"RISBGZ\t[$]0, [$]63, [$]9, " - // ppc64x:"ROTL\t[$]9" - // loong64: "ROTRV\t[$]55" - // riscv64: "RORI\t[$]55" + // amd64:"ROLQ [$]9" + // arm64:"ROR [$]55" + // s390x:"RISBGZ [$]0, [$]63, [$]9, " + // ppc64x:"ROTL [$]9" + // loong64: "ROTRV [$]55" + // riscv64: "RORI [$]55" a += x<<9 ^ x>>55 - // amd64:"ROLQ\t[$]10" - // arm64:"ROR\t[$]54" - // s390x:"RISBGZ\t[$]0, [$]63, [$]10, " - // ppc64x:"ROTL\t[$]10" - // arm64:"ROR\t[$]54" - // s390x:"RISBGZ\t[$]0, [$]63, [$]10, " - // loong64: "ROTRV\t[$]54" - // riscv64: "RORI\t[$]54" + // amd64:"ROLQ [$]10" + // arm64:"ROR [$]54" + // s390x:"RISBGZ [$]0, [$]63, [$]10, " + // ppc64x:"ROTL [$]10" + // arm64:"ROR [$]54" + // s390x:"RISBGZ [$]0, [$]63, [$]10, " + // loong64: "ROTRV [$]54" + // riscv64: "RORI [$]54" a += bits.RotateLeft64(x, 10) return a @@ -53,40 +53,40 @@ func rot64(x uint64) uint64 { func rot32(x uint32) uint32 { var a uint32 - // amd64:"ROLL\t[$]7" - // arm:"MOVW\tR\\d+@>25" - // ppc64x:"ROTLW\t[$]7" - // loong64: "ROTR\t[$]25" - // riscv64: "RORIW\t[$]25" + // amd64:"ROLL [$]7" + // arm:"MOVW R\\d+@>25" + // ppc64x:"ROTLW [$]7" + // loong64: "ROTR [$]25" + // riscv64: "RORIW [$]25" a += x<<7 | x>>25 - // amd64:`ROLL\t[$]8` - // arm:"MOVW\tR\\d+@>24" - // arm64:"RORW\t[$]24" - // s390x:"RLL\t[$]8" - // ppc64x:"ROTLW\t[$]8" - // loong64: "ROTR\t[$]24" - // riscv64: "RORIW\t[$]24" + // amd64:`ROLL [$]8` + // arm:"MOVW R\\d+@>24" + // arm64:"RORW [$]24" + // s390x:"RLL [$]8" + // ppc64x:"ROTLW [$]8" + // loong64: "ROTR [$]24" + // riscv64: "RORIW [$]24" a += x<<8 + x>>24 - // amd64:"ROLL\t[$]9" - // arm:"MOVW\tR\\d+@>23" - // arm64:"RORW\t[$]23" - // s390x:"RLL\t[$]9" - // ppc64x:"ROTLW\t[$]9" - // loong64: "ROTR\t[$]23" - // riscv64: "RORIW\t[$]23" + // amd64:"ROLL [$]9" + // arm:"MOVW R\\d+@>23" + // arm64:"RORW [$]23" + // s390x:"RLL [$]9" + // ppc64x:"ROTLW [$]9" + // loong64: "ROTR [$]23" + // riscv64: "RORIW [$]23" a += x<<9 ^ x>>23 - // amd64:"ROLL\t[$]10" - // arm:"MOVW\tR\\d+@>22" - // arm64:"RORW\t[$]22" - // s390x:"RLL\t[$]10" - // ppc64x:"ROTLW\t[$]10" - // arm64:"RORW\t[$]22" - // s390x:"RLL\t[$]10" - // loong64: "ROTR\t[$]22" - // riscv64: "RORIW\t[$]22" + // amd64:"ROLL [$]10" + // arm:"MOVW R\\d+@>22" + // arm64:"RORW [$]22" + // s390x:"RLL [$]10" + // ppc64x:"ROTLW [$]10" + // arm64:"RORW [$]22" + // s390x:"RLL [$]10" + // loong64: "ROTR [$]22" + // riscv64: "RORIW [$]22" a += bits.RotateLeft32(x, 10) return a @@ -95,16 +95,16 @@ func rot32(x uint32) uint32 { func rot16(x uint16) uint16 { var a uint16 - // amd64:"ROLW\t[$]7" - // riscv64: "OR","SLLI","SRLI",-"AND" + // amd64:"ROLW [$]7" + // riscv64: "OR" "SLLI" "SRLI" -"AND" a += x<<7 | x>>9 - // amd64:`ROLW\t[$]8` - // riscv64: "OR","SLLI","SRLI",-"AND" + // amd64:`ROLW [$]8` + // riscv64: "OR" "SLLI" "SRLI" -"AND" a += x<<8 + x>>8 - // amd64:"ROLW\t[$]9" - // riscv64: "OR","SLLI","SRLI",-"AND" + // amd64:"ROLW [$]9" + // riscv64: "OR" "SLLI" "SRLI" -"AND" a += x<<9 ^ x>>7 return a @@ -113,16 +113,16 @@ func rot16(x uint16) uint16 { func rot8(x uint8) uint8 { var a uint8 - // amd64:"ROLB\t[$]5" - // riscv64: "OR","SLLI","SRLI",-"AND" + // amd64:"ROLB [$]5" + // riscv64: "OR" "SLLI" "SRLI" -"AND" a += x<<5 | x>>3 - // amd64:`ROLB\t[$]6` - // riscv64: "OR","SLLI","SRLI",-"AND" + // amd64:`ROLB [$]6` + // riscv64: "OR" "SLLI" "SRLI" -"AND" a += x<<6 + x>>2 - // amd64:"ROLB\t[$]7" - // riscv64: "OR","SLLI","SRLI",-"AND" + // amd64:"ROLB [$]7" + // riscv64: "OR" "SLLI" "SRLI" -"AND" a += x<<7 ^ x>>1 return a @@ -137,18 +137,18 @@ func rot64nc(x uint64, z uint) uint64 { z &= 63 - // amd64:"ROLQ",-"AND" - // arm64:"ROR","NEG",-"AND" - // ppc64x:"ROTL",-"NEG",-"AND" + // amd64:"ROLQ" -"AND" + // arm64:"ROR" "NEG" -"AND" + // ppc64x:"ROTL" -"NEG" -"AND" // loong64: "ROTRV", -"AND" - // riscv64: "ROL",-"AND" + // riscv64: "ROL" -"AND" a += x<>(64-z) - // amd64:"RORQ",-"AND" - // arm64:"ROR",-"NEG",-"AND" - // ppc64x:"ROTL","NEG",-"AND" + // amd64:"RORQ" -"AND" + // arm64:"ROR" -"NEG" -"AND" + // ppc64x:"ROTL" "NEG" -"AND" // loong64: "ROTRV", -"AND" - // riscv64: "ROR",-"AND" + // riscv64: "ROR" -"AND" a += x>>z | x<<(64-z) return a @@ -159,18 +159,18 @@ func rot32nc(x uint32, z uint) uint32 { z &= 31 - // amd64:"ROLL",-"AND" - // arm64:"ROR","NEG",-"AND" - // ppc64x:"ROTLW",-"NEG",-"AND" + // amd64:"ROLL" -"AND" + // arm64:"ROR" "NEG" -"AND" + // ppc64x:"ROTLW" -"NEG" -"AND" // loong64: "ROTR", -"AND" - // riscv64: "ROLW",-"AND" + // riscv64: "ROLW" -"AND" a += x<>(32-z) - // amd64:"RORL",-"AND" - // arm64:"ROR",-"NEG",-"AND" - // ppc64x:"ROTLW","NEG",-"AND" + // amd64:"RORL" -"AND" + // arm64:"ROR" -"NEG" -"AND" + // ppc64x:"ROTLW" "NEG" -"AND" // loong64: "ROTR", -"AND" - // riscv64: "RORW",-"AND" + // riscv64: "RORW" -"AND" a += x>>z | x<<(32-z) return a @@ -181,12 +181,12 @@ func rot16nc(x uint16, z uint) uint16 { z &= 15 - // amd64:"ROLW",-"ANDQ" - // riscv64: "OR","SLL","SRL",-"AND\t" + // amd64:"ROLW" -"ANDQ" + // riscv64: "OR" "SLL" "SRL" -"AND " a += x<>(16-z) - // amd64:"RORW",-"ANDQ" - // riscv64: "OR","SLL","SRL",-"AND\t" + // amd64:"RORW" -"ANDQ" + // riscv64: "OR" "SLL" "SRL" -"AND " a += x>>z | x<<(16-z) return a @@ -197,12 +197,12 @@ func rot8nc(x uint8, z uint) uint8 { z &= 7 - // amd64:"ROLB",-"ANDQ" - // riscv64: "OR","SLL","SRL",-"AND\t" + // amd64:"ROLB" -"ANDQ" + // riscv64: "OR" "SLL" "SRL" -"AND " a += x<>(8-z) - // amd64:"RORB",-"ANDQ" - // riscv64: "OR","SLL","SRL",-"AND\t" + // amd64:"RORB" -"ANDQ" + // riscv64: "OR" "SLL" "SRL" -"AND " a += x>>z | x<<(8-z) return a @@ -210,14 +210,14 @@ func rot8nc(x uint8, z uint) uint8 { // Issue 18254: rotate after inlining func f32(x uint32) uint32 { - // amd64:"ROLL\t[$]7" + // amd64:"ROLL [$]7" return rot32nc(x, 7) } func doubleRotate(x uint64) uint64 { x = (x << 5) | (x >> 59) - // amd64:"ROLQ\t[$]15" - // arm64:"ROR\t[$]49" + // amd64:"ROLQ [$]15" + // arm64:"ROR [$]49" x = (x << 10) | (x >> 54) return x } @@ -229,51 +229,51 @@ func doubleRotate(x uint64) uint64 { func checkMaskedRotate32(a []uint32, r int) { i := 0 - // ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+" + // ppc64x: "RLWNM [$]16, R[0-9]+, [$]8, [$]15, R[0-9]+" a[i] = bits.RotateLeft32(a[i], 16) & 0xFF0000 i++ - // ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+" + // ppc64x: "RLWNM [$]16, R[0-9]+, [$]8, [$]15, R[0-9]+" a[i] = bits.RotateLeft32(a[i]&0xFF, 16) i++ - // ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]27, R[0-9]+" + // ppc64x: "RLWNM [$]4, R[0-9]+, [$]20, [$]27, R[0-9]+" a[i] = bits.RotateLeft32(a[i], 4) & 0xFF0 i++ - // ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]24, [$]31, R[0-9]+" + // ppc64x: "RLWNM [$]16, R[0-9]+, [$]24, [$]31, R[0-9]+" a[i] = bits.RotateLeft32(a[i]&0xFF0000, 16) i++ - // ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]8, [$]15, R[0-9]+" + // ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]8, [$]15, R[0-9]+" a[i] = bits.RotateLeft32(a[i], r) & 0xFF0000 i++ - // ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]16, [$]23, R[0-9]+" + // ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]16, [$]23, R[0-9]+" a[i] = bits.RotateLeft32(a[i], r) & 0xFF00 i++ - // ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]20, [$]11, R[0-9]+" + // ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]20, [$]11, R[0-9]+" a[i] = bits.RotateLeft32(a[i], r) & 0xFFF00FFF i++ - // ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]11, R[0-9]+" + // ppc64x: "RLWNM [$]4, R[0-9]+, [$]20, [$]11, R[0-9]+" a[i] = bits.RotateLeft32(a[i], 4) & 0xFFF00FFF i++ } // combined arithmetic and rotate on arm64 func checkArithmeticWithRotate(a *[1000]uint64) { - // arm64: "AND\tR[0-9]+@>51, R[0-9]+, R[0-9]+" + // arm64: "AND R[0-9]+@>51, R[0-9]+, R[0-9]+" a[2] = a[1] & bits.RotateLeft64(a[0], 13) - // arm64: "ORR\tR[0-9]+@>51, R[0-9]+, R[0-9]+" + // arm64: "ORR R[0-9]+@>51, R[0-9]+, R[0-9]+" a[5] = a[4] | bits.RotateLeft64(a[3], 13) - // arm64: "EOR\tR[0-9]+@>51, R[0-9]+, R[0-9]+" + // arm64: "EOR R[0-9]+@>51, R[0-9]+, R[0-9]+" a[8] = a[7] ^ bits.RotateLeft64(a[6], 13) - // arm64: "MVN\tR[0-9]+@>51, R[0-9]+" + // arm64: "MVN R[0-9]+@>51, R[0-9]+" a[10] = ^bits.RotateLeft64(a[9], 13) - // arm64: "BIC\tR[0-9]+@>51, R[0-9]+, R[0-9]+" + // arm64: "BIC R[0-9]+@>51, R[0-9]+, R[0-9]+" a[13] = a[12] &^ bits.RotateLeft64(a[11], 13) - // arm64: "EON\tR[0-9]+@>51, R[0-9]+, R[0-9]+" + // arm64: "EON R[0-9]+@>51, R[0-9]+, R[0-9]+" a[16] = a[15] ^ ^bits.RotateLeft64(a[14], 13) - // arm64: "ORN\tR[0-9]+@>51, R[0-9]+, R[0-9]+" + // arm64: "ORN R[0-9]+@>51, R[0-9]+, R[0-9]+" a[19] = a[18] | ^bits.RotateLeft64(a[17], 13) - // arm64: "TST\tR[0-9]+@>51, R[0-9]+" + // arm64: "TST R[0-9]+@>51, R[0-9]+" if a[18]&bits.RotateLeft64(a[19], 13) == 0 { a[20] = 1 } diff --git a/test/codegen/schedule.go b/test/codegen/schedule.go index aafffd817b..bb8a81af78 100644 --- a/test/codegen/schedule.go +++ b/test/codegen/schedule.go @@ -8,8 +8,8 @@ package codegen func f(n int) int { r := 0 - // arm64:-"MOVD\t R" - // amd64:-"LEAQ","INCQ" + // arm64:-"MOVD R" + // amd64:-"LEAQ" "INCQ" for i := range n { r += i } diff --git a/test/codegen/select.go b/test/codegen/select.go index 82f6d1c7ef..46532d4012 100644 --- a/test/codegen/select.go +++ b/test/codegen/select.go @@ -10,7 +10,7 @@ func f() { ch1 := make(chan int) ch2 := make(chan int) for { - // amd64:-`MOVQ\t[$]0, command-line-arguments..autotmp_3` + // amd64:-`MOVQ [$]0, command-line-arguments..autotmp_3` select { case <-ch1: case <-ch2: diff --git a/test/codegen/shift.go b/test/codegen/shift.go index 4b0885a4dd..1877247af4 100644 --- a/test/codegen/shift.go +++ b/test/codegen/shift.go @@ -13,57 +13,57 @@ package codegen func lshConst64x64(v int64) int64 { // loong64:"SLLV" // ppc64x:"SLD" - // riscv64:"SLLI",-"AND",-"SLTIU" + // riscv64:"SLLI" -"AND" -"SLTIU" return v << uint64(33) } func rshConst64Ux64(v uint64) uint64 { // loong64:"SRLV" // ppc64x:"SRD" - // riscv64:"SRLI\t",-"AND",-"SLTIU" + // riscv64:"SRLI " -"AND" -"SLTIU" return v >> uint64(33) } func rshConst64Ux64Overflow32(v uint32) uint64 { - // loong64:"MOVV\tR0,",-"SRL\t" - // riscv64:"MOV\t\\$0,",-"SRL" + // loong64:"MOVV R0," -"SRL " + // riscv64:"MOV [$]0," -"SRL" return uint64(v) >> 32 } func rshConst64Ux64Overflow16(v uint16) uint64 { - // loong64:"MOVV\tR0,",-"SRLV" - // riscv64:"MOV\t\\$0,",-"SRL" + // loong64:"MOVV R0," -"SRLV" + // riscv64:"MOV [$]0," -"SRL" return uint64(v) >> 16 } func rshConst64Ux64Overflow8(v uint8) uint64 { - // loong64:"MOVV\tR0,",-"SRLV" - // riscv64:"MOV\t\\$0,",-"SRL" + // loong64:"MOVV R0," -"SRLV" + // riscv64:"MOV [$]0," -"SRL" return uint64(v) >> 8 } func rshConst64x64(v int64) int64 { // loong64:"SRAV" // ppc64x:"SRAD" - // riscv64:"SRAI\t",-"OR",-"SLTIU" + // riscv64:"SRAI " -"OR" -"SLTIU" return v >> uint64(33) } func rshConst64x64Overflow32(v int32) int64 { - // loong64:"SRA\t\\$31" - // riscv64:"SRAIW",-"SLLI",-"SRAI\t" + // loong64:"SRA [$]31" + // riscv64:"SRAIW" -"SLLI" -"SRAI " return int64(v) >> 32 } func rshConst64x64Overflow16(v int16) int64 { - // loong64:"SLLV\t\\$48","SRAV\t\\$63" - // riscv64:"SLLI","SRAI",-"SRAIW" + // loong64:"SLLV [$]48" "SRAV [$]63" + // riscv64:"SLLI" "SRAI" -"SRAIW" return int64(v) >> 16 } func rshConst64x64Overflow8(v int8) int64 { - // loong64:"SLLV\t\\$56","SRAV\t\\$63" - // riscv64:"SLLI","SRAI",-"SRAIW" + // loong64:"SLLV [$]56" "SRAV [$]63" + // riscv64:"SLLI" "SRAI" -"SRAIW" return int64(v) >> 8 } @@ -78,84 +78,84 @@ func lshConst64x1(v int64) int64 { } func lshConst32x64(v int32) int32 { - // loong64:"SLL\t" + // 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\t" + // 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\t" + // loong64:"SRA " // ppc64x:"SRAW" - // riscv64:"SRAIW",-"OR",-"SLTIU", -"MOVW" + // riscv64:"SRAIW" -"OR" -"SLTIU", -"MOVW" return v >> uint64(29) } func lshConst64x32(v int64) int64 { // loong64:"SLLV" // ppc64x:"SLD" - // riscv64:"SLLI",-"AND",-"SLTIU" + // riscv64:"SLLI" -"AND" -"SLTIU" return v << uint32(33) } func rshConst64Ux32(v uint64) uint64 { // loong64:"SRLV" // ppc64x:"SRD" - // riscv64:"SRLI\t",-"AND",-"SLTIU" + // riscv64:"SRLI " -"AND" -"SLTIU" return v >> uint32(33) } func rshConst64x32(v int64) int64 { // loong64:"SRAV" // ppc64x:"SRAD" - // riscv64:"SRAI\t",-"OR",-"SLTIU" + // riscv64:"SRAI " -"OR" -"SLTIU" return v >> uint32(33) } func lshConst32x1Add(x int32) int32 { - // amd64:"SHLL\t[$]2" - // loong64:"SLL\t[$]2" - // riscv64:"SLLI\t[$]2" + // amd64:"SHLL [$]2" + // loong64:"SLL [$]2" + // riscv64:"SLLI [$]2" return (x + x) << 1 } func lshConst64x1Add(x int64) int64 { - // amd64:"SHLQ\t[$]2" - // loong64:"SLLV\t[$]2" - // riscv64:"SLLI\t[$]2" + // amd64:"SHLQ [$]2" + // loong64:"SLLV [$]2" + // riscv64:"SLLI [$]2" return (x + x) << 1 } func lshConst32x2Add(x int32) int32 { - // amd64:"SHLL\t[$]3" - // loong64:"SLL\t[$]3" - // riscv64:"SLLI\t[$]3" + // amd64:"SHLL [$]3" + // loong64:"SLL [$]3" + // riscv64:"SLLI [$]3" return (x + x) << 2 } func lshConst64x2Add(x int64) int64 { - // amd64:"SHLQ\t[$]3" - // loong64:"SLLV\t[$]3" - // riscv64:"SLLI\t[$]3" + // amd64:"SHLQ [$]3" + // loong64:"SLLV [$]3" + // riscv64:"SLLI [$]3" return (x + x) << 2 } func lshConst32x31Add(x int32) int32 { - // loong64:-"SLL\t","MOVV\tR0" - // riscv64:-"SLLI","MOV\t[$]0" + // loong64:-"SLL " "MOVV R0" + // riscv64:-"SLLI" "MOV [$]0" return (x + x) << 31 } func lshConst64x63Add(x int64) int64 { - // loong64:-"SLLV","MOVV\tR0" - // riscv64:-"SLLI","MOV\t[$]0" + // loong64:-"SLLV" "MOVV R0" + // riscv64:-"SLLI" "MOV [$]0" return (x + x) << 63 } @@ -164,121 +164,121 @@ func lshConst64x63Add(x int64) int64 { // ------------------ // func lshMask64x64(v int64, s uint64) int64 { - // arm64:"LSL",-"AND" - // loong64:"SLLV",-"AND" - // ppc64x:"RLDICL",-"ORN",-"ISEL" - // riscv64:"SLL",-"AND\t",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"LSL" -"AND" + // loong64:"SLLV" -"AND" + // ppc64x:"RLDICL" -"ORN" -"ISEL" + // riscv64:"SLL" -"AND " -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v << (s & 63) } func rshMask64Ux64(v uint64, s uint64) uint64 { - // arm64:"LSR",-"AND",-"CSEL" - // loong64:"SRLV",-"AND" - // ppc64x:"RLDICL",-"ORN",-"ISEL" - // riscv64:"SRL\t",-"AND\t",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"LSR" -"AND" -"CSEL" + // loong64:"SRLV" -"AND" + // ppc64x:"RLDICL" -"ORN" -"ISEL" + // riscv64:"SRL " -"AND " -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v >> (s & 63) } func rshMask64x64(v int64, s uint64) int64 { - // arm64:"ASR",-"AND",-"CSEL" - // loong64:"SRAV",-"AND" - // ppc64x:"RLDICL",-"ORN",-"ISEL" - // riscv64:"SRA\t",-"OR",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"ASR" -"AND" -"CSEL" + // loong64:"SRAV" -"AND" + // ppc64x:"RLDICL" -"ORN" -"ISEL" + // riscv64:"SRA " -"OR" -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v >> (s & 63) } func lshMask32x64(v int32, s uint64) int32 { - // arm64:"LSL",-"AND" - // loong64:"SLL\t","AND","SGTU","MASKEQZ" - // ppc64x:"ISEL",-"ORN" - // riscv64:"SLL",-"AND\t",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"LSL" -"AND" + // loong64:"SLL " "AND" "SGTU" "MASKEQZ" + // ppc64x:"ISEL" -"ORN" + // riscv64:"SLL" -"AND " -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v << (s & 63) } func lsh5Mask32x64(v int32, s uint64) int32 { - // loong64:"SLL\t",-"AND" + // loong64:"SLL " -"AND" return v << (s & 31) } func rshMask32Ux64(v uint32, s uint64) uint32 { - // arm64:"LSR",-"AND" - // loong64:"SRL\t","AND","SGTU","MASKEQZ" - // ppc64x:"ISEL",-"ORN" - // riscv64:"SRLW","SLTIU","NEG","AND\t",-"SRL\t" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"LSR" -"AND" + // loong64:"SRL " "AND" "SGTU" "MASKEQZ" + // ppc64x:"ISEL" -"ORN" + // riscv64:"SRLW" "SLTIU" "NEG" "AND " -"SRL " + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v >> (s & 63) } func rsh5Mask32Ux64(v uint32, s uint64) uint32 { - // loong64:"SRL\t",-"AND" - // riscv64:"SRLW",-"AND\t",-"SLTIU",-"SRL\t" + // loong64:"SRL " -"AND" + // riscv64:"SRLW" -"AND " -"SLTIU" -"SRL " return v >> (s & 31) } func rshMask32x64(v int32, s uint64) int32 { - // arm64:"ASR",-"AND" - // loong64:"SRA\t","AND","SGTU","SUBVU","OR" - // ppc64x:"ISEL",-"ORN" - // riscv64:"SRAW","OR","SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"ASR" -"AND" + // loong64:"SRA " "AND" "SGTU" "SUBVU" "OR" + // ppc64x:"ISEL" -"ORN" + // riscv64:"SRAW" "OR" "SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v >> (s & 63) } func rsh5Mask32x64(v int32, s uint64) int32 { - // loong64:"SRA\t",-"AND" - // riscv64:"SRAW",-"OR",-"SLTIU" + // loong64:"SRA " -"AND" + // riscv64:"SRAW" -"OR" -"SLTIU" return v >> (s & 31) } func lshMask64x32(v int64, s uint32) int64 { - // arm64:"LSL",-"AND" - // loong64:"SLLV",-"AND" - // ppc64x:"RLDICL",-"ORN" - // riscv64:"SLL",-"AND\t",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"LSL" -"AND" + // loong64:"SLLV" -"AND" + // ppc64x:"RLDICL" -"ORN" + // riscv64:"SLL" -"AND " -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v << (s & 63) } func rshMask64Ux32(v uint64, s uint32) uint64 { - // arm64:"LSR",-"AND",-"CSEL" - // loong64:"SRLV",-"AND" - // ppc64x:"RLDICL",-"ORN" - // riscv64:"SRL\t",-"AND\t",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"LSR" -"AND" -"CSEL" + // loong64:"SRLV" -"AND" + // ppc64x:"RLDICL" -"ORN" + // riscv64:"SRL " -"AND " -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v >> (s & 63) } func rshMask64x32(v int64, s uint32) int64 { - // arm64:"ASR",-"AND",-"CSEL" - // loong64:"SRAV",-"AND" - // ppc64x:"RLDICL",-"ORN",-"ISEL" - // riscv64:"SRA\t",-"OR",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // arm64:"ASR" -"AND" -"CSEL" + // loong64:"SRAV" -"AND" + // ppc64x:"RLDICL" -"ORN" -"ISEL" + // riscv64:"SRA " -"OR" -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v >> (s & 63) } func lshMask64x32Ext(v int64, s int32) int64 { - // ppc64x:"RLDICL",-"ORN",-"ISEL" - // riscv64:"SLL",-"AND\t",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // ppc64x:"RLDICL" -"ORN" -"ISEL" + // riscv64:"SLL" -"AND " -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v << uint(s&63) } func rshMask64Ux32Ext(v uint64, s int32) uint64 { - // ppc64x:"RLDICL",-"ORN",-"ISEL" - // riscv64:"SRL\t",-"AND\t",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // ppc64x:"RLDICL" -"ORN" -"ISEL" + // riscv64:"SRL " -"AND " -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v >> uint(s&63) } func rshMask64x32Ext(v int64, s int32) int64 { - // ppc64x:"RLDICL",-"ORN",-"ISEL" - // riscv64:"SRA\t",-"OR",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" + // ppc64x:"RLDICL" -"ORN" -"ISEL" + // riscv64:"SRA " -"OR" -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" return v >> uint(s&63) } @@ -316,10 +316,10 @@ func lshSignedMasked(v8 int8, v16 int16, v32 int32, v64 int64, x int) { func lshGuarded64(v int64, s uint) int64 { if s < 64 { - // riscv64:"SLL",-"AND",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" - // wasm:-"Select",-".*LtU" - // arm64:"LSL",-"CSEL" + // riscv64:"SLL" -"AND" -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" + // wasm:-"Select" -".*LtU" + // arm64:"LSL" -"CSEL" return v << s } panic("shift too large") @@ -327,10 +327,10 @@ func lshGuarded64(v int64, s uint) int64 { func rshGuarded64U(v uint64, s uint) uint64 { if s < 64 { - // riscv64:"SRL\t",-"AND",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" - // wasm:-"Select",-".*LtU" - // arm64:"LSR",-"CSEL" + // riscv64:"SRL " -"AND" -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" + // wasm:-"Select" -".*LtU" + // arm64:"LSR" -"CSEL" return v >> s } panic("shift too large") @@ -338,10 +338,10 @@ func rshGuarded64U(v uint64, s uint) uint64 { func rshGuarded64(v int64, s uint) int64 { if s < 64 { - // riscv64:"SRA\t",-"OR",-"SLTIU" - // s390x:-"RISBGZ",-"AND",-"LOCGR" - // wasm:-"Select",-".*LtU" - // arm64:"ASR",-"CSEL" + // riscv64:"SRA " -"OR" -"SLTIU" + // s390x:-"RISBGZ" -"AND" -"LOCGR" + // wasm:-"Select" -".*LtU" + // arm64:"ASR" -"CSEL" return v >> s } panic("shift too large") @@ -349,19 +349,19 @@ func rshGuarded64(v int64, s uint) int64 { func provedUnsignedShiftLeft(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) { if shift >= 0 && shift < 64 { - // arm64:"LSL",-"CSEL" + // arm64:"LSL" -"CSEL" r1 = val64 << shift } if shift >= 0 && shift < 32 { - // arm64:"LSL",-"CSEL" + // arm64:"LSL" -"CSEL" r2 = val32 << shift } if shift >= 0 && shift < 16 { - // arm64:"LSL",-"CSEL" + // arm64:"LSL" -"CSEL" r3 = val16 << shift } if shift >= 0 && shift < 8 { - // arm64:"LSL",-"CSEL" + // arm64:"LSL" -"CSEL" r4 = val8 << shift } return r1, r2, r3, r4 @@ -369,19 +369,19 @@ func provedUnsignedShiftLeft(val64 uint64, val32 uint32, val16 uint16, val8 uint func provedSignedShiftLeft(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) { if shift >= 0 && shift < 64 { - // arm64:"LSL",-"CSEL" + // arm64:"LSL" -"CSEL" r1 = val64 << shift } if shift >= 0 && shift < 32 { - // arm64:"LSL",-"CSEL" + // arm64:"LSL" -"CSEL" r2 = val32 << shift } if shift >= 0 && shift < 16 { - // arm64:"LSL",-"CSEL" + // arm64:"LSL" -"CSEL" r3 = val16 << shift } if shift >= 0 && shift < 8 { - // arm64:"LSL",-"CSEL" + // arm64:"LSL" -"CSEL" r4 = val8 << shift } return r1, r2, r3, r4 @@ -389,19 +389,19 @@ func provedSignedShiftLeft(val64 int64, val32 int32, val16 int16, val8 int8, shi func provedUnsignedShiftRight(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) { if shift >= 0 && shift < 64 { - // arm64:"LSR",-"CSEL" + // arm64:"LSR" -"CSEL" r1 = val64 >> shift } if shift >= 0 && shift < 32 { - // arm64:"LSR",-"CSEL" + // arm64:"LSR" -"CSEL" r2 = val32 >> shift } if shift >= 0 && shift < 16 { - // arm64:"LSR",-"CSEL" + // arm64:"LSR" -"CSEL" r3 = val16 >> shift } if shift >= 0 && shift < 8 { - // arm64:"LSR",-"CSEL" + // arm64:"LSR" -"CSEL" r4 = val8 >> shift } return r1, r2, r3, r4 @@ -409,19 +409,19 @@ func provedUnsignedShiftRight(val64 uint64, val32 uint32, val16 uint16, val8 uin func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) { if shift >= 0 && shift < 64 { - // arm64:"ASR",-"CSEL" + // arm64:"ASR" -"CSEL" r1 = val64 >> shift } if shift >= 0 && shift < 32 { - // arm64:"ASR",-"CSEL" + // arm64:"ASR" -"CSEL" r2 = val32 >> shift } if shift >= 0 && shift < 16 { - // arm64:"ASR",-"CSEL" + // arm64:"ASR" -"CSEL" r3 = val16 >> shift } if shift >= 0 && shift < 8 { - // arm64:"ASR",-"CSEL" + // arm64:"ASR" -"CSEL" r4 = val8 >> shift } return r1, r2, r3, r4 @@ -429,36 +429,36 @@ func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, sh func checkUnneededTrunc(tab *[100000]uint32, d uint64, v uint32, h uint16, b byte) (uint32, uint64) { - // ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI" + // ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI" f := tab[byte(v)^b] - // ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI" + // ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI" f += tab[byte(v)&b] - // ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI" + // ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI" f += tab[byte(v)|b] - // ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI" + // ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI" f += tab[uint16(v)&h] - // ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI" + // ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI" f += tab[uint16(v)^h] - // ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI" + // ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI" f += tab[uint16(v)|h] - // ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI" + // ppc64x:-".*AND" -"RLDICR" ".*CLRLSLDI" f += tab[v&0xff] - // ppc64x:-".*AND",".*CLRLSLWI" + // ppc64x:-".*AND" ".*CLRLSLWI" f += 2 * uint32(uint16(d)) - // ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI" + // ppc64x:-".*AND" -"RLDICR" ".*CLRLSLDI" g := 2 * uint64(uint32(d)) return f, g } func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64) (uint8, uint16, uint32, uint64, int64) { - // ppc64x:-"AND","CLRLSLWI" + // ppc64x:-"AND" "CLRLSLWI" f := (v8 & 0xF) << 2 // ppc64x:"CLRLSLWI" f += byte(v16) << 3 - // ppc64x:-"AND","CLRLSLWI" + // ppc64x:-"AND" "CLRLSLWI" g := (v16 & 0xFF) << 3 - // ppc64x:-"AND","CLRLSLWI" + // ppc64x:-"AND" "CLRLSLWI" h := (v32 & 0xFFFFF) << 2 // ppc64x:"CLRLSLDI" i := (v64 & 0xFFFFFFFF) << 5 @@ -466,7 +466,7 @@ func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64 i += (v64 & 0xFFFFFFF) << 38 // ppc64x/power9:-"CLRLSLDI" i += (v64 & 0xFFFF00) << 10 - // ppc64x/power9:-"SLD","EXTSWSLI" + // ppc64x/power9:-"SLD" "EXTSWSLI" j := int64(x32+32) * 8 return f, g, h, i, j } @@ -497,71 +497,71 @@ func checkWidenAfterShift(v int64, u uint64) (int64, uint64) { func checkShiftAndMask32(v []uint32) { i := 0 - // ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+" + // ppc64x: "RLWNM [$]24, R[0-9]+, [$]12, [$]19, R[0-9]+" v[i] = (v[i] & 0xFF00000) >> 8 i++ - // ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+" + // ppc64x: "RLWNM [$]26, R[0-9]+, [$]22, [$]29, R[0-9]+" v[i] = (v[i] & 0xFF00) >> 6 i++ - // ppc64x: "MOVW\tR0" + // ppc64x: "MOVW R0" v[i] = (v[i] & 0xFF) >> 8 i++ - // ppc64x: "MOVW\tR0" + // ppc64x: "MOVW R0" v[i] = (v[i] & 0xF000000) >> 28 i++ - // ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+" + // ppc64x: "RLWNM [$]26, R[0-9]+, [$]24, [$]31, R[0-9]+" v[i] = (v[i] >> 6) & 0xFF i++ - // ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+" + // ppc64x: "RLWNM [$]26, R[0-9]+, [$]12, [$]19, R[0-9]+" v[i] = (v[i] >> 6) & 0xFF000 i++ - // ppc64x: "MOVW\tR0" + // ppc64x: "MOVW R0" v[i] = (v[i] >> 20) & 0xFF000 i++ - // ppc64x: "MOVW\tR0" + // ppc64x: "MOVW R0" v[i] = (v[i] >> 24) & 0xFF00 i++ } func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) { - // ppc64x: -"CLRLSLDI", "RLWNM\t[$]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\t[$]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\t[$]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\t[$]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\t[$]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" a[1] = a[uint8(v>>25)] - // ppc64x: -"CLRLSLDI", "RLWNM\t[$]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\t[$]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\t[$]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\t[$]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" b[2] = b[((uint64((uint32(v) >> 21)) & 0x3f) << 4)] // ppc64x: -"RLWNM" b[3] = (b[3] << 24) & 0xFFFFFF000000 - // ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]0, [$]7," + // ppc64x: "RLWNM [$]24, R[0-9]+, [$]0, [$]7," b[4] = (b[4] << 24) & 0xFF000000 - // ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]0, [$]7," + // ppc64x: "RLWNM [$]24, R[0-9]+, [$]0, [$]7," b[5] = (b[5] << 24) & 0xFF00000F // ppc64x: -"RLWNM" b[6] = (b[6] << 0) & 0xFF00000F - // ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]28, [$]31," + // ppc64x: "RLWNM [$]4, R[0-9]+, [$]28, [$]31," b[7] = (b[7] >> 28) & 0xF - // ppc64x: "RLWNM\t[$]11, R[0-9]+, [$]10, [$]15" + // ppc64x: "RLWNM [$]11, R[0-9]+, [$]10, [$]15" c[0] = c[((v>>5)&0x3F)<<16] - // ppc64x: "ANDCC\t[$]8064," + // ppc64x: "ANDCC [$]8064," c[1] = c[((v>>7)&0x3F)<<7] } @@ -572,7 +572,7 @@ func checkShiftMask(a uint32, b uint64, z []uint32, y []uint64) { z[0] = uint32(uint8(a >> 5)) // ppc64x: -"MOVBZ", -"SRW", "RLWNM" z[1] = uint32(uint8((a >> 4) & 0x7e)) - // ppc64x: "RLWNM\t[$]25, R[0-9]+, [$]27, [$]29, R[0-9]+" + // ppc64x: "RLWNM [$]25, R[0-9]+, [$]27, [$]29, R[0-9]+" z[2] = uint32(uint8(a>>7)) & 0x1c // ppc64x: -"MOVWZ" y[0] = uint64((a >> 6) & 0x1c) @@ -598,11 +598,11 @@ func check128bitShifts(x, y uint64, bits uint) (uint64, uint64) { } func checkShiftToMask(u []uint64, s []int64) { - // amd64:-"SHR",-"SHL","ANDQ" + // amd64:-"SHR" -"SHL" "ANDQ" u[0] = u[0] >> 5 << 5 - // amd64:-"SAR",-"SHL","ANDQ" + // amd64:-"SAR" -"SHL" "ANDQ" s[0] = s[0] >> 5 << 5 - // amd64:-"SHR",-"SHL","ANDQ" + // amd64:-"SHR" -"SHL" "ANDQ" u[1] = u[1] << 5 >> 5 } @@ -611,13 +611,13 @@ func checkShiftToMask(u []uint64, s []int64) { // func checkLeftShiftWithAddition(a int64, b int64) int64 { - // riscv64/rva20u64: "SLLI","ADD" + // riscv64/rva20u64: "SLLI" "ADD" // riscv64/rva22u64,riscv64/rva23u64: "SH1ADD" a = a + b<<1 - // riscv64/rva20u64: "SLLI","ADD" + // riscv64/rva20u64: "SLLI" "ADD" // riscv64/rva22u64,riscv64/rva23u64: "SH2ADD" a = a + b<<2 - // riscv64/rva20u64: "SLLI","ADD" + // riscv64/rva20u64: "SLLI" "ADD" // riscv64/rva22u64,riscv64/rva23u64: "SH3ADD" a = a + b<<3 return a @@ -631,7 +631,7 @@ func rsh64Uto32U(v uint64) uint32 { x := uint32(v) // riscv64:"MOVWU" if x > 8 { - // riscv64:"SRLIW",-"MOVWU",-"SLLI" + // riscv64:"SRLIW" -"MOVWU" -"SLLI" x >>= 2 } return x @@ -641,7 +641,7 @@ func rsh64Uto16U(v uint64) uint16 { x := uint16(v) // riscv64:"MOVHU" if x > 8 { - // riscv64:"SLLI","SRLI" + // riscv64:"SLLI" "SRLI" x >>= 2 } return x @@ -651,7 +651,7 @@ func rsh64Uto8U(v uint64) uint8 { x := uint8(v) // riscv64:"MOVBU" if x > 8 { - // riscv64:"SLLI","SRLI" + // riscv64:"SLLI" "SRLI" x >>= 2 } return x @@ -661,7 +661,7 @@ func rsh64to32(v int64) int32 { x := int32(v) // riscv64:"MOVW" if x > 8 { - // riscv64:"SRAIW",-"MOVW",-"SLLI" + // riscv64:"SRAIW" -"MOVW" -"SLLI" x >>= 2 } return x @@ -671,7 +671,7 @@ func rsh64to16(v int64) int16 { x := int16(v) // riscv64:"MOVH" if x > 8 { - // riscv64:"SLLI","SRAI" + // riscv64:"SLLI" "SRAI" x >>= 2 } return x @@ -681,7 +681,7 @@ func rsh64to8(v int64) int8 { x := int8(v) // riscv64:"MOVB" if x > 8 { - // riscv64:"SLLI","SRAI" + // riscv64:"SLLI" "SRAI" x >>= 2 } return x @@ -692,6 +692,6 @@ func rsh64to8(v int64) int8 { // (There is still a negative shift test, but // no shift-too-big test.) func signedModShift(i int) int64 { - // arm64:-"CMP",-"CSEL" + // arm64:-"CMP" -"CSEL" return 1 << (i % 64) } diff --git a/test/codegen/slices.go b/test/codegen/slices.go index 1d918a3a0a..1c48b38047 100644 --- a/test/codegen/slices.go +++ b/test/codegen/slices.go @@ -46,7 +46,7 @@ func SliceExtensionConst(s []int) []int { // amd64:-`.*runtime\.memclrNoHeapPointers` // amd64:-`.*runtime\.makeslice` // amd64:-`.*runtime\.panicmakeslicelen` - // amd64:"MOVUPS\tX15" + // amd64:"MOVUPS X15" // loong64:-`.*runtime\.memclrNoHeapPointers` // ppc64x:-`.*runtime\.memclrNoHeapPointers` // ppc64x:-`.*runtime\.makeslice` @@ -58,7 +58,7 @@ func SliceExtensionConstInt64(s []int) []int { // amd64:-`.*runtime\.memclrNoHeapPointers` // amd64:-`.*runtime\.makeslice` // amd64:-`.*runtime\.panicmakeslicelen` - // amd64:"MOVUPS\tX15" + // amd64:"MOVUPS X15" // loong64:-`.*runtime\.memclrNoHeapPointers` // ppc64x:-`.*runtime\.memclrNoHeapPointers` // ppc64x:-`.*runtime\.makeslice` @@ -70,7 +70,7 @@ func SliceExtensionConstUint64(s []int) []int { // amd64:-`.*runtime\.memclrNoHeapPointers` // amd64:-`.*runtime\.makeslice` // amd64:-`.*runtime\.panicmakeslicelen` - // amd64:"MOVUPS\tX15" + // amd64:"MOVUPS X15" // loong64:-`.*runtime\.memclrNoHeapPointers` // ppc64x:-`.*runtime\.memclrNoHeapPointers` // ppc64x:-`.*runtime\.makeslice` @@ -82,7 +82,7 @@ func SliceExtensionConstUint(s []int) []int { // amd64:-`.*runtime\.memclrNoHeapPointers` // amd64:-`.*runtime\.makeslice` // amd64:-`.*runtime\.panicmakeslicelen` - // amd64:"MOVUPS\tX15" + // amd64:"MOVUPS X15" // loong64:-`.*runtime\.memclrNoHeapPointers` // ppc64x:-`.*runtime\.memclrNoHeapPointers` // ppc64x:-`.*runtime\.makeslice` @@ -352,12 +352,12 @@ func SliceNilCheck(s []int) { // ---------------------- // // See issue 21561 func InitSmallSliceLiteral() []int { - // amd64:`MOVQ\t[$]42` + // amd64:`MOVQ [$]42` return []int{42} } func InitNotSmallSliceLiteral() []int { - // amd64:`LEAQ\t.*stmp_` + // amd64:`LEAQ .*stmp_` return []int{ 42, 42, @@ -413,7 +413,7 @@ func SliceWithConstCompare(a []int, b int) []int { } func SliceWithSubtractBound(a []int, b int) []int { - // ppc64x:"SUBC",-"NEG" + // ppc64x:"SUBC" -"NEG" return a[(3 - b):] } @@ -422,7 +422,7 @@ func SliceWithSubtractBound(a []int, b int) []int { // --------------------------------------- // func SliceAndIndex(a []int, b int) int { - // arm64:"AND\tR[0-9]+->63","ADD\tR[0-9]+<<3" + // arm64:"AND R[0-9]+->63" "ADD R[0-9]+<<3" return a[b:][b] } @@ -445,12 +445,12 @@ func Slice0(p *struct{}, i int) []struct{} { // --------------------------------------- // func SlicePut(a []byte, c uint8) []byte { - // arm64:`CBZ\tR1` + // arm64:`CBZ R1` a[0] = c - // arm64:`CMP\t\$1, R1` + // arm64:`CMP \$1, R1` a = a[1:] a[0] = c - // arm64:`CMP\t\$2, R1` + // arm64:`CMP \$2, R1` a = a[1:] a[0] = c a = a[1:] diff --git a/test/codegen/smallintiface.go b/test/codegen/smallintiface.go index 0207a0af79..e1dbae5f9a 100644 --- a/test/codegen/smallintiface.go +++ b/test/codegen/smallintiface.go @@ -7,16 +7,16 @@ package codegen // license that can be found in the LICENSE file. func booliface() interface{} { - // amd64:`LEAQ\truntime.staticuint64s\+8\(SB\)` + // amd64:`LEAQ runtime.staticuint64s\+8\(SB\)` return true } func smallint8iface() interface{} { - // amd64:`LEAQ\truntime.staticuint64s\+2024\(SB\)` + // amd64:`LEAQ runtime.staticuint64s\+2024\(SB\)` return int8(-3) } func smalluint8iface() interface{} { - // amd64:`LEAQ\truntime.staticuint64s\+24\(SB\)` + // amd64:`LEAQ runtime.staticuint64s\+24\(SB\)` return uint8(3) } diff --git a/test/codegen/stack.go b/test/codegen/stack.go index 59284ae888..4ce56eb1d9 100644 --- a/test/codegen/stack.go +++ b/test/codegen/stack.go @@ -16,13 +16,13 @@ import ( // Check that stack stores are optimized away. -// 386:"TEXT\t.*, [$]0-" -// amd64:"TEXT\t.*, [$]0-" -// arm:"TEXT\t.*, [$]-4-" -// arm64:"TEXT\t.*, [$]0-" -// mips:"TEXT\t.*, [$]-4-" -// ppc64x:"TEXT\t.*, [$]0-" -// s390x:"TEXT\t.*, [$]0-" +// 386:"TEXT .*, [$]0-" +// amd64:"TEXT .*, [$]0-" +// arm:"TEXT .*, [$]-4-" +// arm64:"TEXT .*, [$]0-" +// mips:"TEXT .*, [$]-4-" +// ppc64x:"TEXT .*, [$]0-" +// s390x:"TEXT .*, [$]0-" func StackStore() int { var x int return *(&x) @@ -35,13 +35,13 @@ type T struct { // Check that large structs are cleared directly (issue #24416). -// 386:"TEXT\t.*, [$]0-" -// amd64:"TEXT\t.*, [$]0-" -// arm:"TEXT\t.*, [$]0-" (spills return address) -// arm64:"TEXT\t.*, [$]0-" -// mips:"TEXT\t.*, [$]-4-" -// ppc64x:"TEXT\t.*, [$]0-" -// s390x:"TEXT\t.*, [$]0-" +// 386:"TEXT .*, [$]0-" +// amd64:"TEXT .*, [$]0-" +// arm:"TEXT .*, [$]0-" (spills return address) +// arm64:"TEXT .*, [$]0-" +// mips:"TEXT .*, [$]-4-" +// ppc64x:"TEXT .*, [$]0-" +// s390x:"TEXT .*, [$]0-" func ZeroLargeStruct(x *T) { t := T{} *x = t @@ -51,11 +51,11 @@ func ZeroLargeStruct(x *T) { // Notes: // - 386 fails due to spilling a register -// amd64:"TEXT\t.*, [$]0-" -// arm:"TEXT\t.*, [$]0-" (spills return address) -// arm64:"TEXT\t.*, [$]0-" -// ppc64x:"TEXT\t.*, [$]0-" -// s390x:"TEXT\t.*, [$]0-" +// amd64:"TEXT .*, [$]0-" +// arm:"TEXT .*, [$]0-" (spills return address) +// arm64:"TEXT .*, [$]0-" +// ppc64x:"TEXT .*, [$]0-" +// s390x:"TEXT .*, [$]0-" // Note: that 386 currently has to spill a register. func KeepWanted(t *T) { *t = T{A: t.A, B: t.B, C: t.C, D: t.D} @@ -66,23 +66,23 @@ func KeepWanted(t *T) { // Notes: // - 386 fails due to spilling a register // - arm & mips fail due to softfloat calls -// amd64:"TEXT\t.*, [$]0-" -// arm64:"TEXT\t.*, [$]0-" -// ppc64x:"TEXT\t.*, [$]0-" -// s390x:"TEXT\t.*, [$]0-" +// amd64:"TEXT .*, [$]0-" +// arm64:"TEXT .*, [$]0-" +// ppc64x:"TEXT .*, [$]0-" +// s390x:"TEXT .*, [$]0-" func ArrayAdd64(a, b [4]float64) [4]float64 { return [4]float64{a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]} } // Check that small array initialization avoids using the stack. -// 386:"TEXT\t.*, [$]0-" -// amd64:"TEXT\t.*, [$]0-" -// arm:"TEXT\t.*, [$]0-" (spills return address) -// arm64:"TEXT\t.*, [$]0-" -// mips:"TEXT\t.*, [$]-4-" -// ppc64x:"TEXT\t.*, [$]0-" -// s390x:"TEXT\t.*, [$]0-" +// 386:"TEXT .*, [$]0-" +// amd64:"TEXT .*, [$]0-" +// arm:"TEXT .*, [$]0-" (spills return address) +// arm64:"TEXT .*, [$]0-" +// mips:"TEXT .*, [$]-4-" +// ppc64x:"TEXT .*, [$]0-" +// s390x:"TEXT .*, [$]0-" func ArrayInit(i, j int) [4]int { return [4]int{i, 0, j, 0} } @@ -99,7 +99,7 @@ func check_asmout(b [2]int) int { // Check that simple functions get promoted to nosplit, even when // they might panic in various ways. See issue 31219. -// amd64:"TEXT\t.*NOSPLIT.*" +// amd64:"TEXT .*NOSPLIT.*" func MightPanic(a []int, i, j, k, s int) { _ = a[i] // panicIndex _ = a[i:j] // panicSlice @@ -113,7 +113,7 @@ func Defer() { for i := 0; i < 2; i++ { defer func() {}() } - // amd64:`CALL\truntime\.deferprocStack` + // amd64:`CALL runtime\.deferprocStack` defer func() {}() } @@ -138,7 +138,7 @@ type mySlice struct { cap int } -// amd64:"TEXT\t.*, [$]0-" +// amd64:"TEXT .*, [$]0-" func sliceInit(base uintptr) []uintptr { const ptrSize = 8 size := uintptr(4096) @@ -150,7 +150,7 @@ func sliceInit(base uintptr) []uintptr { elements, elements, } - // amd64:-"POPQ",-"SP" + // amd64:-"POPQ" -"SP" return *(*[]uintptr)(unsafe.Pointer(&sl)) } @@ -171,6 +171,6 @@ func getp2() *[4]int { // Store to an argument without read can be removed. func storeArg(a [2]int) { - // amd64:-`MOVQ\t\$123,.*\.a\+\d+\(SP\)` + // amd64:-`MOVQ \$123,.*\.a\+\d+\(SP\)` a[1] = 123 } diff --git a/test/codegen/strings.go b/test/codegen/strings.go index 0b3ca7016f..9d85604395 100644 --- a/test/codegen/strings.go +++ b/test/codegen/strings.go @@ -22,8 +22,8 @@ func CountBytes(s []byte) int { } func ToByteSlice() []byte { // Issue #24698 - // amd64:`LEAQ\ttype:\[3\]uint8` - // amd64:`CALL\truntime\.mallocTiny3` + // amd64:`LEAQ type:\[3\]uint8` + // amd64:`CALL runtime\.mallocTiny3` // amd64:-`.*runtime.stringtoslicebyte` return []byte("foo") } @@ -37,56 +37,56 @@ func ConvertToByteSlice(a, b, c string) []byte { func ConstantLoad() { // 12592 = 0x3130 // 50 = 0x32 - // amd64:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(` - // 386:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(` - // arm:`MOVW\t\$48`,`MOVW\t\$49`,`MOVW\t\$50` - // arm64:`MOVD\t\$12592`,`MOVD\t\$50` - // loong64:`MOVV\t\$12592`,`MOVV\t\$50` - // wasm:`I64Const\t\$12592`,`I64Store16\t\$0`,`I64Const\t\$50`,`I64Store8\t\$2` - // mips64:`MOVV\t\$48`,`MOVV\t\$49`,`MOVV\t\$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\t\$858927408`,`MOVW\t\$13620, 4\(` - // 386:`MOVL\t\$858927408`,`MOVW\t\$13620, 4\(` - // arm64:`MOVD\t\$858927408`,`MOVD\t\$13620` - // loong64:`MOVV\t\$858927408`,`MOVV\t\$13620` - // wasm:`I64Const\t\$858927408`,`I64Store32\t\$0`,`I64Const\t\$13620`,`I64Store16\t\$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\t\$3978425819141910832`,`MOVQ\t\$7306073769690871863` - // 386:`MOVL\t\$858927408, \(`,`DUFFCOPY` - // arm64:`MOVD\t\$3978425819141910832`,`MOVD\t\$7306073769690871863`,`MOVD\t\$15` - // loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$7306073769690871863`,`MOVV\t\$15` - // wasm:`I64Const\t\$3978425819141910832`,`I64Store\t\$0`,`I64Const\t\$7306073769690871863`,`I64Store\t\$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\t\$3978425819141910832`,`MOVB\t\$56` - // loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$56` + // amd64:`MOVQ \$3978425819141910832`,`MOVB \$56` + // loong64:`MOVV \$3978425819141910832`,`MOVV \$56` bsink = []byte("012345678") // 14648 = 0x3938 - // amd64:`MOVQ\t\$3978425819141910832`,`MOVW\t\$14648` - // loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$14648` + // amd64:`MOVQ \$3978425819141910832`,`MOVW \$14648` + // loong64:`MOVV \$3978425819141910832`,`MOVV \$14648` bsink = []byte("0123456789") // 1650538808 = 0x62613938 - // amd64:`MOVQ\t\$3978425819141910832`,`MOVL\t\$1650538808` - // loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$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\t\$1, AX`,-`.*memequal.*` + // amd64:`MOVL \$1, AX`,-`.*memequal.*` return s == s } func NotEqualSelf(s string) bool { - // amd64:`XORL\tAX, AX`,-`.*memequal.*` + // amd64:`XORL AX, AX`,-`.*memequal.*` return s != s } diff --git a/test/codegen/structs.go b/test/codegen/structs.go index 49a201f743..1c8cb5d62d 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\tX[0-9]+, \(.*\)`,`MOVQ\t\$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\tX[0-9]+, \(.*\)`,`MOVQ\t\$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\t[$]1`,`MOVQ\t[$]2`,`MOVQ\t[$]3`,`MOVQ\t[$]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 1a66a5ddf8..a8860d0cc4 100644 --- a/test/codegen/switch.go +++ b/test/codegen/switch.go @@ -137,8 +137,8 @@ type K interface { // use a runtime call for type switches to interface types. func interfaceSwitch(x any) int { - // amd64:`CALL\truntime.interfaceSwitch`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*8)` - // arm64:`CALL\truntime.interfaceSwitch`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(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\truntime.interfaceSwitch`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*8)` - // arm64:`CALL\truntime.interfaceSwitch`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(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\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)` - // arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(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\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)` - // arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(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\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)` - // arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(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 } @@ -195,7 +195,7 @@ func stringSwitchInlineable(s string) { } } func stringSwitch() { - // amd64:-"CMP",-"CALL" - // arm64:-"CMP",-"CALL" + // amd64:-"CMP" -"CALL" + // arm64:-"CMP" -"CALL" stringSwitchInlineable("foo") } diff --git a/test/codegen/typeswitch.go b/test/codegen/typeswitch.go index 93f8e84269..db78a6e5ab 100644 --- a/test/codegen/typeswitch.go +++ b/test/codegen/typeswitch.go @@ -37,7 +37,7 @@ func swGYZ[T any](a Ig[T]) { t.Y() case Iz: // amd64:-".*typeAssert" t.Z() - case interface{ G() T }: // amd64:-".*typeAssert",-".*assertE2I\\(",".*assertE2I2" + case interface{ G() T }: // amd64:-".*typeAssert" -".*assertE2I\\(" ".*assertE2I2" t.G() } } @@ -46,7 +46,7 @@ func swE2G[T any](a any) { switch t := a.(type) { case Iy: t.Y() - case Ig[T]: // amd64:-".*assertE2I\\(",".*assertE2I2" + case Ig[T]: // amd64:-".*assertE2I\\(" ".*assertE2I2" t.G() } } @@ -55,7 +55,7 @@ func swI2G[T any](a Ix) { switch t := a.(type) { case Iy: t.Y() - case Ig[T]: // amd64:-".*assertE2I\\(",".*assertE2I2" + case Ig[T]: // amd64:-".*assertE2I\\(" ".*assertE2I2" t.G() } } diff --git a/test/codegen/zerosize.go b/test/codegen/zerosize.go index 86c4819400..1e93260ef5 100644 --- a/test/codegen/zerosize.go +++ b/test/codegen/zerosize.go @@ -12,24 +12,24 @@ package codegen func zeroSize() { c := make(chan struct{}) - // amd64:`MOVQ\t\$0, command-line-arguments\.s\+56\(SP\)` + // amd64:`MOVQ \$0, command-line-arguments\.s\+56\(SP\)` var s *int // force s to be a stack object, also use some (fixed) stack space g(&s, 1, 2, 3, 4, 5) - // amd64:`LEAQ\tcommand-line-arguments\..*\+55\(SP\)` + // amd64:`LEAQ command-line-arguments\..*\+55\(SP\)` c <- noliteral(struct{}{}) } // Like zeroSize, but without hiding the zero-sized struct. func zeroSize2() { c := make(chan struct{}) - // amd64:`MOVQ\t\$0, command-line-arguments\.s\+48\(SP\)` + // amd64:`MOVQ \$0, command-line-arguments\.s\+48\(SP\)` var s *int // force s to be a stack object, also use some (fixed) stack space g(&s, 1, 2, 3, 4, 5) - // amd64:`LEAQ\tcommand-line-arguments\..*stmp_\d+\(SB\)` + // amd64:`LEAQ command-line-arguments\..*stmp_\d+\(SB\)` c <- struct{}{} } -- 2.52.0