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 <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
Reviewed-by: Jorropo <jorropo.pgm@gmail.com>
// "\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)
}
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.
}
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())
// 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]
}
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{}
}
// ----------------- //
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
}
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
}
// 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
}
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)
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)
}
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
}
// -------------------- //
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
}
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
}
// 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)
}
}
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
// 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
}
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
// 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
// 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
// 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
// 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
}
// 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
}
// 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
}
// ----------------- //
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)
// arm64/v8.1:"LDADDALW"
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
- // amd64:"LOCK",-"CMPXCHG"
+ // amd64:"LOCK" -"CMPXCHG"
atomic.AddInt32(&c.count, 1)
}
// 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"
// 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
// 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"
// 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
// 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<<lc)>>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<<lc)>>rc && lc<rc
func ubfx1(x uint64) uint64 {
- // arm64:"UBFX\t[$]1, R[0-9]+, [$]62",-"LSL",-"LSR"
- // s390x:"RISBGZ\t[$]2, [$]63, [$]63,",-"SLD",-"SRD"
+ // arm64:"UBFX [$]1, R[0-9]+, [$]62" -"LSL" -"LSR"
+ // s390x:"RISBGZ [$]2, [$]63, [$]63," -"SLD" -"SRD"
return (x << 1) >> 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
}
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
// 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
}
//
//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
}
************************************/
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
}
}
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
}
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
}
}
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
}
// 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
// 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
// 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
************************************/
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
}
}
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
}
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
}
}
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
}
// 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
// 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
// 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
// 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)
}
// 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
}
}
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)
}
}
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 {
}
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 {
}
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 {
}
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 {
}
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
}
}
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
}
// 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
}
}
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
}
x[12] = b
}
- // ppc64x:"ADDCCC\t[$]4,"
+ // ppc64x:"ADDCCC [$]4,"
c := int64(x[12]) + 4
if c <= 0 {
x[12] = uint64(c)
func constantWrite(b bool, p *bool) {
if b {
- // amd64:`MOVB\t[$]1, \(`
+ // amd64:`MOVB [$]1, \(`
*p = b
}
}
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)
}
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)
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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()
}
// 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))
}
}
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
}
}
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
}
}
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
}
}
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
}
var r bool
func CmpFold(x uint32) {
- // amd64:`SETHI\t.*\(SB\)`
+ // amd64:`SETHI .*\(SB\)`
r = x > 4
}
// 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
}
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
}
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
}
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
}
// 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)
}
x = 182
}
// amd64:"CMOVQLT"
- // arm64:"CSEL\tLT"
- // ppc64x:"ISEL\t[$]0"
+ // arm64:"CSEL LT"
+ // ppc64x:"ISEL [$]0"
// wasm:"Select"
return x
}
x = y
}
// amd64:"CMOVQNE"
- // arm64:"CSEL\tNE"
- // ppc64x:"ISEL\t[$]2"
+ // arm64:"CSEL NE"
+ // ppc64x:"ISEL [$]2"
// wasm:"Select"
return x
}
x = -y
}
// amd64:"CMOVQ(HI|CS)"
- // arm64:"CSNEG\tLS"
- // ppc64x:"ISEL\t[$]1"
+ // arm64:"CSNEG LS"
+ // ppc64x:"ISEL [$]1"
// wasm:"Select"
return x
}
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
}
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
}
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
}
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
}
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)
}
y = y >> 2
}
// amd64:"CMOVQNE"
- // arm64:"CSEL\tNE"
- // ppc64x:"ISEL\t[$]2"
+ // arm64:"CSEL NE"
+ // ppc64x:"ISEL [$]2"
// wasm:"Select"
return y
}
a = 256
}
// amd64:"CMOVQEQ"
- // arm64:"CSEL\tEQ"
- // ppc64x:"ISEL\t[$]2"
+ // arm64:"CSEL EQ"
+ // ppc64x:"ISEL [$]2"
// wasm:"Select"
return a
}
} else {
x0 = b + 1
}
- // arm64:"CSINC\tNE", -"CSEL"
+ // arm64:"CSINC NE", -"CSEL"
r0 = x0
if cond {
} 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
}
} else {
x0 = ^b
}
- // arm64:"CSINV\tNE", -"CSEL"
+ // arm64:"CSINV NE", -"CSEL"
r0 = x0
if cond {
} else {
x1 = a
}
- // arm64:"CSINV\tEQ", -"CSEL"
+ // arm64:"CSINV EQ", -"CSEL"
r1 = x1
}
} else {
x0 = -b
}
- // arm64:"CSNEG\tNE", -"CSEL"
+ // arm64:"CSNEG NE", -"CSEL"
r0 = x0
if cond {
} else {
x1 = a
}
- // arm64:"CSNEG\tEQ", -"CSEL"
+ // arm64:"CSNEG EQ", -"CSEL"
r1 = x1
}
} else {
x0 = 0
}
- // arm64:"CSETM\tNE", -"CSEL"
+ // arm64:"CSETM NE", -"CSEL"
r0 = x0
if cond {
} else {
x1 = -1
}
- // arm64:"CSETM\tEQ", -"CSEL"
+ // arm64:"CSETM EQ", -"CSEL"
r1 = x1
}
} else {
x0 = b + 1
}
- // arm64:"CSINC\tMI", -"CSEL"
+ // arm64:"CSINC MI", -"CSEL"
r0 = x0
if s <= t {
} else {
x1 = ^b
}
- // arm64:"CSINV\tLS", -"CSEL"
+ // arm64:"CSINV LS", -"CSEL"
r1 = x1
if s > t {
} else {
x2 = -b
}
- // arm64:"CSNEG\tMI", -"CSEL"
+ // arm64:"CSNEG MI", -"CSEL"
r2 = x2
if s >= t {
} else {
x3 = 0
}
- // arm64:"CSETM\tLS", -"CSEL"
+ // arm64:"CSETM LS", -"CSEL"
r3 = x3
if s == t {
} else {
x4 = b + 1
}
- // arm64:"CSINC\tEQ", -"CSEL"
+ // arm64:"CSINC EQ", -"CSEL"
r4 = x4
if s != t {
} else {
x5 = b + 1
}
- // arm64:"CSINC\tNE", -"CSEL"
+ // arm64:"CSINC NE", -"CSEL"
r5 = x5
}
} else {
x0 = a
}
- // arm64:"CSINC\tPL", -"CSEL"
+ // arm64:"CSINC PL", -"CSEL"
r0 = x0
if s <= t {
} else {
x1 = a
}
- // arm64:"CSINV\tHI", -"CSEL"
+ // arm64:"CSINV HI", -"CSEL"
r1 = x1
if s > t {
} else {
x2 = a
}
- // arm64:"CSNEG\tPL", -"CSEL"
+ // arm64:"CSNEG PL", -"CSEL"
r2 = x2
if s >= t {
} else {
x3 = -1
}
- // arm64:"CSETM\tHI", -"CSEL"
+ // arm64:"CSETM HI", -"CSEL"
r3 = x3
if s == t {
} else {
x4 = a
}
- // arm64:"CSINC\tNE", -"CSEL"
+ // arm64:"CSINC NE", -"CSEL"
r4 = x4
if s != t {
} else {
x5 = a
}
- // arm64:"CSINC\tEQ", -"CSEL"
+ // arm64:"CSINC EQ", -"CSEL"
r5 = x5
}
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
}
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
}
// 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
}
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)
}
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)
}
// amd64:-".*memmove"
// ppc64x:-".*memmove"
// ppc64x/power8:"LXVD2X"
- // ppc64x/power9:"LXV",-"LXVD2X"
+ // ppc64x/power9:"LXV" -"LXVD2X"
copy(s[:], x[:])
runtime.KeepAlive(&s)
}
// amd64:-".*memmove"
// ppc64x:-".*memmove"
// ppc64x/power8:"LXVD2X"
- // ppc64x/power9:"LXV",-"LXVD2X"
+ // ppc64x/power9:"LXV" -"LXVD2X"
copy(s[:], b[:])
runtime.KeepAlive(&s)
}
// amd64:-".*memmove"
// ppc64x:-".*memmove"
// ppc64x/power8:"LXVD2X"
- // ppc64x/power9:"LXV",-"LXVD2X"
+ // ppc64x/power9:"LXV" -"LXVD2X"
copy(a[:], a[128:])
}
// 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)]
}
// --------------------- //
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
// ----------- //
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
}
// ------------------------ //
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
}
// 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
}
// ---------------------------------- //
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 {
}
}
// ---------------------------------- //
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 {
}
}
// ------------------------------------ //
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 {
}
}
// ------------------------------------ //
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 {
}
}
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 {
}
}
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 {
}
}
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 {
}
}
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
}
func e3(x any, y E) bool {
// amd64:-`.*faceeq`,`SETEQ`
- // arm64:-`.*faceeq`,`CSET\tEQ`
+ // arm64:-`.*faceeq`,`CSET EQ`
return x == y
}
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
}
}
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 ..,.."
}
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
}
func f(x []int) int {
s := make([]int, 3)
s = append(s, 4, 5)
- // amd64:`MOVQ\t40\(.*\),`
+ // amd64:`MOVQ 40\(.*\),`
return x[len(s)]
}
}
s = append(s, 4, 5)
if *p {
- // amd64:`MOVQ\t40\(.*\),`
+ // amd64:`MOVQ 40\(.*\),`
return x[len(s)]
}
}
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() }
}
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
}
func main() {
var a M = &Impl{}
- // amd64:`LEAQ\ttype:.*Impl`
+ // amd64:`LEAQ type:.*Impl`
a.(A).A()
}
// 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
}
// 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
}
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,
31: 32,
32: 32,
}
- // amd64:"MOVL\t[$]33,"
+ // amd64:"MOVL [$]33,"
n := map[int]int{
0: 0,
1: 1,
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)
// 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"
// 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)
}
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)
}
}
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
}
// 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))
}
// 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
}
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"
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())
}
// 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)
// 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)
// 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)
// 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)
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)
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)
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"
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)
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)
}
func Reverse16(n uint16) uint16 {
- // loong64:"BITREV4B","REVB2H"
+ // loong64:"BITREV4B" "REVB2H"
return bits.Reverse16(n)
}
// 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)
}
// 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"
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)
}
}
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"
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)
}
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
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
}
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
}
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
}
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
}
// --------------- //
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
}
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
}
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)
}
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")
}
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")
}
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")
}
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")
}
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")
}
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")
}
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
// --------------- //
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)
}
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")
}
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")
}
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")
}
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")
}
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")
}
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")
}
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)
}
}
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)
}
// ------------- //
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]+\),`
}
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]+\),`
}
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`
}
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`
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`
}
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`
}
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
}
// 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
// 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
}
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`
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`
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`
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`
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) {
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`
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
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
}
}
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
}
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
}
// 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
}
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
}
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)
}
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)
// --------------------------------- //
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]
}
// ---------------------------------- //
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
}
}
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]
}
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
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
}
}
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
}
// 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
}
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
}
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
}
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 {
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
}
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
}
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
// 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
}
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
}
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
}
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
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()
}
//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)
}
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()
}
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
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
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
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
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<<z | 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
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<<z | 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
z &= 15
- // amd64:"ROLW",-"ANDQ"
- // riscv64: "OR","SLL","SRL",-"AND\t"
+ // amd64:"ROLW" -"ANDQ"
+ // riscv64: "OR" "SLL" "SRL" -"AND "
a += x<<z | 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
z &= 7
- // amd64:"ROLB",-"ANDQ"
- // riscv64: "OR","SLL","SRL",-"AND\t"
+ // amd64:"ROLB" -"ANDQ"
+ // riscv64: "OR" "SLL" "SRL" -"AND "
a += x<<z | 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
// 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
}
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
}
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
}
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:
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
}
}
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
}
// ------------------ //
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)
}
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")
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")
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")
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
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
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
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
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
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
}
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]
}
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)
}
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
}
//
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
x := uint32(v)
// riscv64:"MOVWU"
if x > 8 {
- // riscv64:"SRLIW",-"MOVWU",-"SLLI"
+ // riscv64:"SRLIW" -"MOVWU" -"SLLI"
x >>= 2
}
return x
x := uint16(v)
// riscv64:"MOVHU"
if x > 8 {
- // riscv64:"SLLI","SRLI"
+ // riscv64:"SLLI" "SRLI"
x >>= 2
}
return x
x := uint8(v)
// riscv64:"MOVBU"
if x > 8 {
- // riscv64:"SLLI","SRLI"
+ // riscv64:"SLLI" "SRLI"
x >>= 2
}
return x
x := int32(v)
// riscv64:"MOVW"
if x > 8 {
- // riscv64:"SRAIW",-"MOVW",-"SLLI"
+ // riscv64:"SRAIW" -"MOVW" -"SLLI"
x >>= 2
}
return x
x := int16(v)
// riscv64:"MOVH"
if x > 8 {
- // riscv64:"SLLI","SRAI"
+ // riscv64:"SLLI" "SRAI"
x >>= 2
}
return x
x := int8(v)
// riscv64:"MOVB"
if x > 8 {
- // riscv64:"SLLI","SRAI"
+ // riscv64:"SLLI" "SRAI"
x >>= 2
}
return x
// (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)
}
// amd64:-`.*runtime\.memclrNoHeapPointers`
// amd64:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.panicmakeslicelen`
- // amd64:"MOVUPS\tX15"
+ // amd64:"MOVUPS X15"
// loong64:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.memclrNoHeapPointers`
// amd64:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.panicmakeslicelen`
- // amd64:"MOVUPS\tX15"
+ // amd64:"MOVUPS X15"
// loong64:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.memclrNoHeapPointers`
// amd64:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.panicmakeslicelen`
- // amd64:"MOVUPS\tX15"
+ // amd64:"MOVUPS X15"
// loong64:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.memclrNoHeapPointers`
// amd64:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.panicmakeslicelen`
- // amd64:"MOVUPS\tX15"
+ // amd64:"MOVUPS X15"
// loong64:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.makeslice`
// ---------------------- //
// 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,
}
func SliceWithSubtractBound(a []int, b int) []int {
- // ppc64x:"SUBC",-"NEG"
+ // ppc64x:"SUBC" -"NEG"
return a[(3 - b):]
}
// --------------------------------------- //
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]
}
// --------------------------------------- //
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:]
// 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)
}
// 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)
// 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
// 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}
// 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}
}
// 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
for i := 0; i < 2; i++ {
defer func() {}()
}
- // amd64:`CALL\truntime\.deferprocStack`
+ // amd64:`CALL runtime\.deferprocStack`
defer func() {}()
}
cap int
}
-// amd64:"TEXT\t.*, [$]0-"
+// amd64:"TEXT .*, [$]0-"
func sliceInit(base uintptr) []uintptr {
const ptrSize = 8
size := uintptr(4096)
elements,
elements,
}
- // amd64:-"POPQ",-"SP"
+ // amd64:-"POPQ" -"SP"
return *(*[]uintptr)(unsafe.Pointer(&sl))
}
// 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
}
}
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")
}
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
}
}
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{}
}
}
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{}
}
}
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}
}
// 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
}
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
}
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
}
}
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
}
}
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
}
}
}
func stringSwitch() {
- // amd64:-"CMP",-"CALL"
- // arm64:-"CMP",-"CALL"
+ // amd64:-"CMP" -"CALL"
+ // arm64:-"CMP" -"CALL"
stringSwitchInlineable("foo")
}
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()
}
}
switch t := a.(type) {
case Iy:
t.Y()
- case Ig[T]: // amd64:-".*assertE2I\\(",".*assertE2I2"
+ case Ig[T]: // amd64:-".*assertE2I\\(" ".*assertE2I2"
t.G()
}
}
switch t := a.(type) {
case Iy:
t.Y()
- case Ig[T]: // amd64:-".*assertE2I\\(",".*assertE2I2"
+ case Ig[T]: // amd64:-".*assertE2I\\(" ".*assertE2I2"
t.G()
}
}
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{}{}
}