mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
test/codegen: simplify asmcheck pattern matching
Separate patterns in asmcheck by spaces instead of commas. Many patterns end in comma (like "MOV [$]123,") so separating patterns by comma is not great; they're already quoted, so spaces are fine. Also replace all tabs in the assembly lines with spaces before matching. Finally, replace \$ or \\$ with [$] as the matching idiom. The effect of all these is to make the patterns look like: // amd64:"BSFQ" "ORQ [$]256" instead of the old: // amd64:"BSFQ","ORQ\t\\$256" Update all tests as well. Change-Id: Ia39febe5d7f67ba115846422789e11b185d5c807 Reviewed-on: https://go-review.googlesource.com/c/go/+/716060 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Alan Donovan <adonovan@google.com> Reviewed-by: Jorropo <jorropo.pgm@gmail.com>
This commit is contained in:
Russ Cox
parent
32ee3f3f73
commit
915c1839fe
48 changed files with 2035 additions and 2032 deletions
|
|
@ -1488,7 +1488,7 @@ var (
|
|||
// "\s*,\s*` matches " , "
|
||||
// second reMatchCheck matches "`SUB`"
|
||||
// ")*)" closes started groups; "*" means that there might be other elements in the comma-separated list
|
||||
rxAsmPlatform = regexp.MustCompile(`(\w+)(/[\w.]+)?(/\w*)?\s*:\s*(` + reMatchCheck + `(?:\s*,\s*` + reMatchCheck + `)*)`)
|
||||
rxAsmPlatform = regexp.MustCompile(`(\w+)(/[\w.]+)?(/\w*)?\s*:\s*(` + reMatchCheck + `(?:\s+` + reMatchCheck + `)*)`)
|
||||
|
||||
// Regexp to extract a single opcoded check
|
||||
rxAsmCheck = regexp.MustCompile(reMatchCheck)
|
||||
|
|
@ -1701,6 +1701,9 @@ func (t test) asmCheck(outStr string, fn string, env buildEnv, fullops map[strin
|
|||
}
|
||||
srcFileLine, asm := matches[1], matches[2]
|
||||
|
||||
// Replace tabs with single spaces to make matches easier to write.
|
||||
asm = strings.ReplaceAll(asm, "\t", " ")
|
||||
|
||||
// Associate the original file/line information to the current
|
||||
// function in the output; it will be useful to dump it in case
|
||||
// of error.
|
||||
|
|
@ -1752,11 +1755,11 @@ func (t test) asmCheck(outStr string, fn string, env buildEnv, fullops map[strin
|
|||
}
|
||||
|
||||
if o.negative {
|
||||
fmt.Fprintf(&errbuf, "%s:%d: %s: wrong opcode found: %q\n", t.goFileName(), o.line, env, o.opcode.String())
|
||||
fmt.Fprintf(&errbuf, "%s:%d: %s: wrong opcode found: %#q\n", t.goFileName(), o.line, env, o.opcode.String())
|
||||
} else if o.expected > 0 {
|
||||
fmt.Fprintf(&errbuf, "%s:%d: %s: wrong number of opcodes: %q\n", t.goFileName(), o.line, env, o.opcode.String())
|
||||
fmt.Fprintf(&errbuf, "%s:%d: %s: wrong number of opcodes: %#q\n", t.goFileName(), o.line, env, o.opcode.String())
|
||||
} else {
|
||||
fmt.Fprintf(&errbuf, "%s:%d: %s: opcode not found: %q\n", t.goFileName(), o.line, env, o.opcode.String())
|
||||
fmt.Fprintf(&errbuf, "%s:%d: %s: opcode not found: %#q\n", t.goFileName(), o.line, env, o.opcode.String())
|
||||
}
|
||||
}
|
||||
return errors.New(errbuf.String())
|
||||
|
|
|
|||
|
|
@ -9,6 +9,6 @@ package codegen
|
|||
// Make sure we use ADDQ instead of LEAQ when we can.
|
||||
|
||||
func f(p *[4][2]int, x int) *int {
|
||||
// amd64:"ADDQ",-"LEAQ"
|
||||
// amd64:"ADDQ" -"LEAQ"
|
||||
return &p[x][0]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,28 +10,28 @@
|
|||
package codegen
|
||||
|
||||
func zeroAllocNew1() *struct{} {
|
||||
// 386:-`CALL\truntime\.newobject`, `LEAL\truntime.zerobase`
|
||||
// amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase`
|
||||
// arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase`
|
||||
// arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase`
|
||||
// riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]runtime.zerobase`
|
||||
// 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase`
|
||||
// amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase`
|
||||
// arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase`
|
||||
// arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase`
|
||||
// riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase`
|
||||
return new(struct{})
|
||||
}
|
||||
|
||||
func zeroAllocNew2() *[0]int {
|
||||
// 386:-`CALL\truntime\.newobject`, `LEAL\truntime.zerobase`
|
||||
// amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase`
|
||||
// arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase`
|
||||
// arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase`
|
||||
// riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]runtime.zerobase`
|
||||
// 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase`
|
||||
// amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase`
|
||||
// arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase`
|
||||
// arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase`
|
||||
// riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase`
|
||||
return new([0]int)
|
||||
}
|
||||
|
||||
func zeroAllocSliceLit() []int {
|
||||
// 386:-`CALL\truntime\.newobject`, `LEAL\truntime.zerobase`
|
||||
// amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase`
|
||||
// arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase`
|
||||
// arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase`
|
||||
// riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]runtime.zerobase`
|
||||
// 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase`
|
||||
// amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase`
|
||||
// arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase`
|
||||
// arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase`
|
||||
// riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase`
|
||||
return []int{}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,44 +15,44 @@ package codegen
|
|||
// ----------------- //
|
||||
|
||||
func AddLargeConst(a uint64, out []uint64) {
|
||||
// ppc64x/power10:"ADD\t[$]4294967296,"
|
||||
// ppc64x/power9:"MOVD\t[$]1", "SLD\t[$]32" "ADD\tR[0-9]*"
|
||||
// ppc64x/power8:"MOVD\t[$]1", "SLD\t[$]32" "ADD\tR[0-9]*"
|
||||
// ppc64x/power10:"ADD [$]4294967296,"
|
||||
// ppc64x/power9:"MOVD [$]1", "SLD [$]32" "ADD R[0-9]*"
|
||||
// ppc64x/power8:"MOVD [$]1", "SLD [$]32" "ADD R[0-9]*"
|
||||
out[0] = a + 0x100000000
|
||||
// ppc64x/power10:"ADD\t[$]-8589934592,"
|
||||
// ppc64x/power9:"MOVD\t[$]-1", "SLD\t[$]33" "ADD\tR[0-9]*"
|
||||
// ppc64x/power8:"MOVD\t[$]-1", "SLD\t[$]33" "ADD\tR[0-9]*"
|
||||
// ppc64x/power10:"ADD [$]-8589934592,"
|
||||
// ppc64x/power9:"MOVD [$]-1", "SLD [$]33" "ADD R[0-9]*"
|
||||
// ppc64x/power8:"MOVD [$]-1", "SLD [$]33" "ADD R[0-9]*"
|
||||
out[1] = a + 0xFFFFFFFE00000000
|
||||
// ppc64x/power10:"ADD\t[$]1234567,"
|
||||
// ppc64x/power9:"ADDIS\t[$]19,", "ADD\t[$]-10617,"
|
||||
// ppc64x/power8:"ADDIS\t[$]19,", "ADD\t[$]-10617,"
|
||||
// ppc64x/power10:"ADD [$]1234567,"
|
||||
// ppc64x/power9:"ADDIS [$]19,", "ADD [$]-10617,"
|
||||
// ppc64x/power8:"ADDIS [$]19,", "ADD [$]-10617,"
|
||||
out[2] = a + 1234567
|
||||
// ppc64x/power10:"ADD\t[$]-1234567,"
|
||||
// ppc64x/power9:"ADDIS\t[$]-19,", "ADD\t[$]10617,"
|
||||
// ppc64x/power8:"ADDIS\t[$]-19,", "ADD\t[$]10617,"
|
||||
// ppc64x/power10:"ADD [$]-1234567,"
|
||||
// ppc64x/power9:"ADDIS [$]-19,", "ADD [$]10617,"
|
||||
// ppc64x/power8:"ADDIS [$]-19,", "ADD [$]10617,"
|
||||
out[3] = a - 1234567
|
||||
// ppc64x/power10:"ADD\t[$]2147450879,"
|
||||
// ppc64x/power9:"ADDIS\t[$]32767,", "ADD\t[$]32767,"
|
||||
// ppc64x/power8:"ADDIS\t[$]32767,", "ADD\t[$]32767,"
|
||||
// ppc64x/power10:"ADD [$]2147450879,"
|
||||
// ppc64x/power9:"ADDIS [$]32767,", "ADD [$]32767,"
|
||||
// ppc64x/power8:"ADDIS [$]32767,", "ADD [$]32767,"
|
||||
out[4] = a + 0x7FFF7FFF
|
||||
// ppc64x/power10:"ADD\t[$]-2147483647,"
|
||||
// ppc64x/power9:"ADDIS\t[$]-32768,", "ADD\t[$]1,"
|
||||
// ppc64x/power8:"ADDIS\t[$]-32768,", "ADD\t[$]1,"
|
||||
// ppc64x/power10:"ADD [$]-2147483647,"
|
||||
// ppc64x/power9:"ADDIS [$]-32768,", "ADD [$]1,"
|
||||
// ppc64x/power8:"ADDIS [$]-32768,", "ADD [$]1,"
|
||||
out[5] = a - 2147483647
|
||||
// ppc64x:"ADDIS\t[$]-32768,", ^"ADD\t"
|
||||
// ppc64x:"ADDIS [$]-32768,", ^"ADD "
|
||||
out[6] = a - 2147483648
|
||||
// ppc64x:"ADD\t[$]2147450880,", ^"ADDIS\t"
|
||||
// ppc64x:"ADD [$]2147450880,", ^"ADDIS "
|
||||
out[7] = a + 0x7FFF8000
|
||||
// ppc64x:"ADD\t[$]-32768,", ^"ADDIS\t"
|
||||
// ppc64x:"ADD [$]-32768,", ^"ADDIS "
|
||||
out[8] = a - 32768
|
||||
// ppc64x/power10:"ADD\t[$]-32769,"
|
||||
// ppc64x/power9:"ADDIS\t[$]-1,", "ADD\t[$]32767,"
|
||||
// ppc64x/power8:"ADDIS\t[$]-1,", "ADD\t[$]32767,"
|
||||
// ppc64x/power10:"ADD [$]-32769,"
|
||||
// ppc64x/power9:"ADDIS [$]-1,", "ADD [$]32767,"
|
||||
// ppc64x/power8:"ADDIS [$]-1,", "ADD [$]32767,"
|
||||
out[9] = a - 32769
|
||||
}
|
||||
|
||||
func AddLargeConst2(a int, out []int) {
|
||||
// loong64: -"ADDVU","ADDV16"
|
||||
// loong64: -"ADDVU" "ADDV16"
|
||||
out[0] = a + 0x10000
|
||||
}
|
||||
|
||||
|
|
@ -83,65 +83,65 @@ func SubMem(arr []int, b, c, d int) int {
|
|||
arr[b]--
|
||||
// amd64:`DECQ\s64\([A-Z]+\)`
|
||||
arr[8]--
|
||||
// 386:"SUBL\t4"
|
||||
// amd64:"SUBQ\t8"
|
||||
// 386:"SUBL 4"
|
||||
// amd64:"SUBQ 8"
|
||||
return arr[0] - arr[1]
|
||||
}
|
||||
|
||||
func SubFromConst(a int) int {
|
||||
// ppc64x: `SUBC\tR[0-9]+,\s[$]40,\sR`
|
||||
// riscv64: "ADDI\t\\$-40","NEG"
|
||||
// ppc64x: `SUBC R[0-9]+,\s[$]40,\sR`
|
||||
// riscv64: "ADDI \\$-40" "NEG"
|
||||
b := 40 - a
|
||||
return b
|
||||
}
|
||||
|
||||
func SubFromConstNeg(a int) int {
|
||||
// arm64: "ADD\t\\$40"
|
||||
// loong64: "ADDV[U]\t\\$40"
|
||||
// mips: "ADD[U]\t\\$40"
|
||||
// mips64: "ADDV[U]\t\\$40"
|
||||
// ppc64x: `ADD\t[$]40,\sR[0-9]+,\sR`
|
||||
// riscv64: "ADDI\t\\$40",-"NEG"
|
||||
// arm64: "ADD \\$40"
|
||||
// loong64: "ADDV[U] \\$40"
|
||||
// mips: "ADD[U] \\$40"
|
||||
// mips64: "ADDV[U] \\$40"
|
||||
// ppc64x: `ADD [$]40,\sR[0-9]+,\sR`
|
||||
// riscv64: "ADDI \\$40" -"NEG"
|
||||
c := 40 - (-a)
|
||||
return c
|
||||
}
|
||||
|
||||
func SubSubFromConst(a int) int {
|
||||
// arm64: "ADD\t\\$20"
|
||||
// loong64: "ADDV[U]\t\\$20"
|
||||
// mips: "ADD[U]\t\\$20"
|
||||
// mips64: "ADDV[U]\t\\$20"
|
||||
// ppc64x: `ADD\t[$]20,\sR[0-9]+,\sR`
|
||||
// riscv64: "ADDI\t\\$20",-"NEG"
|
||||
// arm64: "ADD \\$20"
|
||||
// loong64: "ADDV[U] \\$20"
|
||||
// mips: "ADD[U] \\$20"
|
||||
// mips64: "ADDV[U] \\$20"
|
||||
// ppc64x: `ADD [$]20,\sR[0-9]+,\sR`
|
||||
// riscv64: "ADDI \\$20" -"NEG"
|
||||
c := 40 - (20 - a)
|
||||
return c
|
||||
}
|
||||
|
||||
func AddSubFromConst(a int) int {
|
||||
// ppc64x: `SUBC\tR[0-9]+,\s[$]60,\sR`
|
||||
// riscv64: "ADDI\t\\$-60","NEG"
|
||||
// ppc64x: `SUBC R[0-9]+,\s[$]60,\sR`
|
||||
// riscv64: "ADDI \\$-60" "NEG"
|
||||
c := 40 + (20 - a)
|
||||
return c
|
||||
}
|
||||
|
||||
func NegSubFromConst(a int) int {
|
||||
// arm64: "SUB\t\\$20"
|
||||
// loong64: "ADDV[U]\t\\$-20"
|
||||
// mips: "ADD[U]\t\\$-20"
|
||||
// mips64: "ADDV[U]\t\\$-20"
|
||||
// ppc64x: `ADD\t[$]-20,\sR[0-9]+,\sR`
|
||||
// riscv64: "ADDI\t\\$-20"
|
||||
// arm64: "SUB \\$20"
|
||||
// loong64: "ADDV[U] \\$-20"
|
||||
// mips: "ADD[U] \\$-20"
|
||||
// mips64: "ADDV[U] \\$-20"
|
||||
// ppc64x: `ADD [$]-20,\sR[0-9]+,\sR`
|
||||
// riscv64: "ADDI \\$-20"
|
||||
c := -(20 - a)
|
||||
return c
|
||||
}
|
||||
|
||||
func NegAddFromConstNeg(a int) int {
|
||||
// arm64: "SUB\t\\$40","NEG"
|
||||
// loong64: "ADDV[U]\t\\$-40","SUBV"
|
||||
// mips: "ADD[U]\t\\$-40","SUB"
|
||||
// mips64: "ADDV[U]\t\\$-40","SUBV"
|
||||
// ppc64x: `SUBC\tR[0-9]+,\s[$]40,\sR`
|
||||
// riscv64: "ADDI\t\\$-40","NEG"
|
||||
// arm64: "SUB \\$40" "NEG"
|
||||
// loong64: "ADDV[U] \\$-40" "SUBV"
|
||||
// mips: "ADD[U] \\$-40" "SUB"
|
||||
// mips64: "ADDV[U] \\$-40" "SUBV"
|
||||
// ppc64x: `SUBC R[0-9]+,\s[$]40,\sR`
|
||||
// riscv64: "ADDI \\$-40" "NEG"
|
||||
c := -(-40 + a)
|
||||
return c
|
||||
}
|
||||
|
|
@ -153,19 +153,19 @@ func SubSubNegSimplify(a, b int) int {
|
|||
// mips:"SUB"
|
||||
// mips64:"SUBV"
|
||||
// ppc64x:"NEG"
|
||||
// riscv64:"NEG",-"SUB"
|
||||
// riscv64:"NEG" -"SUB"
|
||||
r := (a - b) - a
|
||||
return r
|
||||
}
|
||||
|
||||
func SubAddSimplify(a, b int) int {
|
||||
// amd64:-"SUBQ",-"ADDQ"
|
||||
// arm64:-"SUB",-"ADD"
|
||||
// loong64:-"SUBV",-"ADDV"
|
||||
// mips:-"SUB",-"ADD"
|
||||
// mips64:-"SUBV",-"ADDV"
|
||||
// ppc64x:-"SUB",-"ADD"
|
||||
// riscv64:-"SUB",-"ADD"
|
||||
// amd64:-"SUBQ" -"ADDQ"
|
||||
// arm64:-"SUB" -"ADD"
|
||||
// loong64:-"SUBV" -"ADDV"
|
||||
// mips:-"SUB" -"ADD"
|
||||
// mips64:-"SUBV" -"ADDV"
|
||||
// ppc64x:-"SUB" -"ADD"
|
||||
// riscv64:-"SUB" -"ADD"
|
||||
r := a + (b - a)
|
||||
return r
|
||||
}
|
||||
|
|
@ -173,9 +173,9 @@ func SubAddSimplify(a, b int) int {
|
|||
func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) {
|
||||
// amd64:-"ADDQ"
|
||||
// arm64:-"ADD"
|
||||
// mips:"SUB",-"ADD"
|
||||
// mips64:"SUBV",-"ADDV"
|
||||
// loong64:"SUBV",-"ADDV"
|
||||
// mips:"SUB" -"ADD"
|
||||
// mips64:"SUBV" -"ADDV"
|
||||
// loong64:"SUBV" -"ADDV"
|
||||
r := (a + b) - (a + c)
|
||||
// amd64:-"ADDQ"
|
||||
r1 := (a + b) - (c + a)
|
||||
|
|
@ -185,9 +185,9 @@ func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) {
|
|||
r3 := (b + a) - (c + a)
|
||||
// amd64:-"SUBQ"
|
||||
// arm64:-"SUB"
|
||||
// mips:"ADD",-"SUB"
|
||||
// mips64:"ADDV",-"SUBV"
|
||||
// loong64:"ADDV",-"SUBV"
|
||||
// mips:"ADD" -"SUB"
|
||||
// mips64:"ADDV" -"SUBV"
|
||||
// loong64:"ADDV" -"SUBV"
|
||||
r4 := (a - c) + (c + b)
|
||||
// amd64:-"SUBQ"
|
||||
r5 := (a - c) + (b + c)
|
||||
|
|
@ -195,31 +195,31 @@ func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) {
|
|||
}
|
||||
|
||||
func SubAddNegSimplify(a, b int) int {
|
||||
// amd64:"NEGQ",-"ADDQ",-"SUBQ"
|
||||
// arm64:"NEG",-"ADD",-"SUB"
|
||||
// loong64:"SUBV",-"ADDV"
|
||||
// mips:"SUB",-"ADD"
|
||||
// mips64:"SUBV",-"ADDV"
|
||||
// ppc64x:"NEG",-"ADD",-"SUB"
|
||||
// riscv64:"NEG",-"ADD",-"SUB"
|
||||
// amd64:"NEGQ" -"ADDQ" -"SUBQ"
|
||||
// arm64:"NEG" -"ADD" -"SUB"
|
||||
// loong64:"SUBV" -"ADDV"
|
||||
// mips:"SUB" -"ADD"
|
||||
// mips64:"SUBV" -"ADDV"
|
||||
// ppc64x:"NEG" -"ADD" -"SUB"
|
||||
// riscv64:"NEG" -"ADD" -"SUB"
|
||||
r := a - (b + a)
|
||||
return r
|
||||
}
|
||||
|
||||
func AddAddSubSimplify(a, b, c int) int {
|
||||
// amd64:-"SUBQ"
|
||||
// arm64:"ADD",-"SUB"
|
||||
// loong64:"ADDV",-"SUBV"
|
||||
// mips:"ADD",-"SUB"
|
||||
// mips64:"ADDV",-"SUBV"
|
||||
// arm64:"ADD" -"SUB"
|
||||
// loong64:"ADDV" -"SUBV"
|
||||
// mips:"ADD" -"SUB"
|
||||
// mips64:"ADDV" -"SUBV"
|
||||
// ppc64x:-"SUB"
|
||||
// riscv64:"ADD","ADD",-"SUB"
|
||||
// riscv64:"ADD" "ADD" -"SUB"
|
||||
r := a + (b + (c - a))
|
||||
return r
|
||||
}
|
||||
|
||||
func NegToInt32(a int) int {
|
||||
// riscv64: "NEGW",-"MOVW"
|
||||
// riscv64: "NEGW" -"MOVW"
|
||||
r := int(int32(-a))
|
||||
return r
|
||||
}
|
||||
|
|
@ -229,20 +229,20 @@ func NegToInt32(a int) int {
|
|||
// -------------------- //
|
||||
|
||||
func Pow2Muls(n1, n2 int) (int, int) {
|
||||
// amd64:"SHLQ\t[$]5",-"IMULQ"
|
||||
// 386:"SHLL\t[$]5",-"IMULL"
|
||||
// arm:"SLL\t[$]5",-"MUL"
|
||||
// arm64:"LSL\t[$]5",-"MUL"
|
||||
// loong64:"SLLV\t[$]5",-"MULV"
|
||||
// ppc64x:"SLD\t[$]5",-"MUL"
|
||||
// amd64:"SHLQ [$]5" -"IMULQ"
|
||||
// 386:"SHLL [$]5" -"IMULL"
|
||||
// arm:"SLL [$]5" -"MUL"
|
||||
// arm64:"LSL [$]5" -"MUL"
|
||||
// loong64:"SLLV [$]5" -"MULV"
|
||||
// ppc64x:"SLD [$]5" -"MUL"
|
||||
a := n1 * 32
|
||||
|
||||
// amd64:"SHLQ\t[$]6",-"IMULQ"
|
||||
// 386:"SHLL\t[$]6",-"IMULL"
|
||||
// arm:"SLL\t[$]6",-"MUL"
|
||||
// amd64:"SHLQ [$]6" -"IMULQ"
|
||||
// 386:"SHLL [$]6" -"IMULL"
|
||||
// arm:"SLL [$]6" -"MUL"
|
||||
// arm64:`NEG\sR[0-9]+<<6,\sR[0-9]+`,-`LSL`,-`MUL`
|
||||
// loong64:"SLLV\t[$]6",-"MULV"
|
||||
// ppc64x:"SLD\t[$]6","NEG\\sR[0-9]+,\\sR[0-9]+",-"MUL"
|
||||
// loong64:"SLLV [$]6" -"MULV"
|
||||
// ppc64x:"SLD [$]6" "NEG\\sR[0-9]+,\\sR[0-9]+" -"MUL"
|
||||
b := -64 * n2
|
||||
|
||||
return a, b
|
||||
|
|
@ -258,18 +258,18 @@ func Mul_2(n1 int32, n2 int64) (int32, int64) {
|
|||
}
|
||||
|
||||
func Mul_96(n int) int {
|
||||
// amd64:`SHLQ\t[$]5`,`LEAQ\t\(.*\)\(.*\*2\),`,-`IMULQ`
|
||||
// 386:`SHLL\t[$]5`,`LEAL\t\(.*\)\(.*\*2\),`,-`IMULL`
|
||||
// arm64:`LSL\t[$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
|
||||
// arm:`SLL\t[$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
|
||||
// loong64:"SLLV\t[$]5","ALSLV\t[$]1,"
|
||||
// s390x:`SLD\t[$]5`,`SLD\t[$]6`,-`MULLD`
|
||||
// amd64:`SHLQ [$]5`,`LEAQ \(.*\)\(.*\*2\),`,-`IMULQ`
|
||||
// 386:`SHLL [$]5`,`LEAL \(.*\)\(.*\*2\),`,-`IMULL`
|
||||
// arm64:`LSL [$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
|
||||
// arm:`SLL [$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
|
||||
// loong64:"SLLV [$]5" "ALSLV [$]1,"
|
||||
// s390x:`SLD [$]5`,`SLD [$]6`,-`MULLD`
|
||||
return n * 96
|
||||
}
|
||||
|
||||
func Mul_n120(n int) int {
|
||||
// loong64:"SLLV\t[$]3","SLLV\t[$]7","SUBVU",-"MULV"
|
||||
// s390x:`SLD\t[$]3`,`SLD\t[$]7`,-`MULLD`
|
||||
// loong64:"SLLV [$]3" "SLLV [$]7" "SUBVU" -"MULV"
|
||||
// s390x:`SLD [$]3`,`SLD [$]7`,-`MULLD`
|
||||
return n * -120
|
||||
}
|
||||
|
||||
|
|
@ -284,50 +284,50 @@ func MulMemSrc(a []uint32, b []float32) {
|
|||
// Multiplications merging tests
|
||||
|
||||
func MergeMuls1(n int) int {
|
||||
// amd64:"IMUL3Q\t[$]46"
|
||||
// 386:"IMUL3L\t[$]46"
|
||||
// ppc64x:"MULLD\t[$]46"
|
||||
// amd64:"IMUL3Q [$]46"
|
||||
// 386:"IMUL3L [$]46"
|
||||
// ppc64x:"MULLD [$]46"
|
||||
return 15*n + 31*n // 46n
|
||||
}
|
||||
|
||||
func MergeMuls2(n int) int {
|
||||
// amd64:"IMUL3Q\t[$]23","(ADDQ\t[$]29)|(LEAQ\t29)"
|
||||
// 386:"IMUL3L\t[$]23","ADDL\t[$]29"
|
||||
// ppc64x/power9:"MADDLD",-"MULLD\t[$]23",-"ADD\t[$]29"
|
||||
// ppc64x/power8:"MULLD\t[$]23","ADD\t[$]29"
|
||||
// amd64:"IMUL3Q [$]23" "(ADDQ [$]29)|(LEAQ 29)"
|
||||
// 386:"IMUL3L [$]23" "ADDL [$]29"
|
||||
// ppc64x/power9:"MADDLD" -"MULLD [$]23" -"ADD [$]29"
|
||||
// ppc64x/power8:"MULLD [$]23" "ADD [$]29"
|
||||
return 5*n + 7*(n+1) + 11*(n+2) // 23n + 29
|
||||
}
|
||||
|
||||
func MergeMuls3(a, n int) int {
|
||||
// amd64:"ADDQ\t[$]19",-"IMULQ\t[$]19"
|
||||
// 386:"ADDL\t[$]19",-"IMULL\t[$]19"
|
||||
// ppc64x:"ADD\t[$]19",-"MULLD\t[$]19"
|
||||
// amd64:"ADDQ [$]19" -"IMULQ [$]19"
|
||||
// 386:"ADDL [$]19" -"IMULL [$]19"
|
||||
// ppc64x:"ADD [$]19" -"MULLD [$]19"
|
||||
return a*n + 19*n // (a+19)n
|
||||
}
|
||||
|
||||
func MergeMuls4(n int) int {
|
||||
// amd64:"IMUL3Q\t[$]14"
|
||||
// 386:"IMUL3L\t[$]14"
|
||||
// ppc64x:"MULLD\t[$]14"
|
||||
// amd64:"IMUL3Q [$]14"
|
||||
// 386:"IMUL3L [$]14"
|
||||
// ppc64x:"MULLD [$]14"
|
||||
return 23*n - 9*n // 14n
|
||||
}
|
||||
|
||||
func MergeMuls5(a, n int) int {
|
||||
// amd64:"ADDQ\t[$]-19",-"IMULQ\t[$]19"
|
||||
// 386:"ADDL\t[$]-19",-"IMULL\t[$]19"
|
||||
// ppc64x:"ADD\t[$]-19",-"MULLD\t[$]19"
|
||||
// amd64:"ADDQ [$]-19" -"IMULQ [$]19"
|
||||
// 386:"ADDL [$]-19" -"IMULL [$]19"
|
||||
// ppc64x:"ADD [$]-19" -"MULLD [$]19"
|
||||
return a*n - 19*n // (a-19)n
|
||||
}
|
||||
|
||||
// Multiplications folded negation
|
||||
|
||||
func FoldNegMul(a int) int {
|
||||
// loong64:"SUBVU","ALSLV\t[$]2","ALSLV\t[$]1"
|
||||
// loong64:"SUBVU" "ALSLV [$]2" "ALSLV [$]1"
|
||||
return (-a) * 11
|
||||
}
|
||||
|
||||
func Fold2NegMul(a, b int) int {
|
||||
// loong64:"MULV",-"SUBVU\tR[0-9], R0,"
|
||||
// loong64:"MULV" -"SUBVU R[0-9], R0,"
|
||||
return (-a) * (-b)
|
||||
}
|
||||
|
||||
|
|
@ -342,17 +342,17 @@ func DivMemSrc(a []float64) {
|
|||
}
|
||||
|
||||
func Pow2Divs(n1 uint, n2 int) (uint, int) {
|
||||
// 386:"SHRL\t[$]5",-"DIVL"
|
||||
// amd64:"SHRQ\t[$]5",-"DIVQ"
|
||||
// arm:"SRL\t[$]5",-".*udiv"
|
||||
// arm64:"LSR\t[$]5",-"UDIV"
|
||||
// 386:"SHRL [$]5" -"DIVL"
|
||||
// amd64:"SHRQ [$]5" -"DIVQ"
|
||||
// arm:"SRL [$]5" -".*udiv"
|
||||
// arm64:"LSR [$]5" -"UDIV"
|
||||
// ppc64x:"SRD"
|
||||
a := n1 / 32 // unsigned
|
||||
|
||||
// amd64:"SARQ\t[$]6",-"IDIVQ"
|
||||
// 386:"SARL\t[$]6",-"IDIVL"
|
||||
// arm:"SRA\t[$]6",-".*udiv"
|
||||
// arm64:"ASR\t[$]6",-"SDIV"
|
||||
// amd64:"SARQ [$]6" -"IDIVQ"
|
||||
// 386:"SARL [$]6" -"IDIVL"
|
||||
// arm:"SRA [$]6" -".*udiv"
|
||||
// arm64:"ASR [$]6" -"SDIV"
|
||||
// ppc64x:"SRAD"
|
||||
b := n2 / 64 // signed
|
||||
|
||||
|
|
@ -361,14 +361,14 @@ func Pow2Divs(n1 uint, n2 int) (uint, int) {
|
|||
|
||||
// Check that constant divisions get turned into MULs
|
||||
func ConstDivs(n1 uint, n2 int) (uint, int) {
|
||||
// amd64:"MOVQ\t[$]-1085102592571150095","MULQ",-"DIVQ"
|
||||
// 386:"MOVL\t[$]-252645135","MULL",-"DIVL"
|
||||
// amd64:"MOVQ [$]-1085102592571150095" "MULQ" -"DIVQ"
|
||||
// 386:"MOVL [$]-252645135" "MULL" -"DIVL"
|
||||
// arm64:`MOVD`,`UMULH`,-`DIV`
|
||||
// arm:`MOVW`,`MUL`,-`.*udiv`
|
||||
a := n1 / 17 // unsigned
|
||||
|
||||
// amd64:"MOVQ\t[$]-1085102592571150095","IMULQ",-"IDIVQ"
|
||||
// 386:"MOVL\t[$]-252645135","IMULL",-"IDIVL"
|
||||
// amd64:"MOVQ [$]-1085102592571150095" "IMULQ" -"IDIVQ"
|
||||
// 386:"IMULL" -"IDIVL"
|
||||
// arm64:`SMULH`,-`DIV`
|
||||
// arm:`MOVW`,`MUL`,-`.*udiv`
|
||||
b := n2 / 17 // signed
|
||||
|
|
@ -383,17 +383,17 @@ func FloatDivs(a []float32) float32 {
|
|||
}
|
||||
|
||||
func Pow2Mods(n1 uint, n2 int) (uint, int) {
|
||||
// 386:"ANDL\t[$]31",-"DIVL"
|
||||
// amd64:"ANDL\t[$]31",-"DIVQ"
|
||||
// arm:"AND\t[$]31",-".*udiv"
|
||||
// arm64:"AND\t[$]31",-"UDIV"
|
||||
// 386:"ANDL [$]31" -"DIVL"
|
||||
// amd64:"ANDL [$]31" -"DIVQ"
|
||||
// arm:"AND [$]31" -".*udiv"
|
||||
// arm64:"AND [$]31" -"UDIV"
|
||||
// ppc64x:"RLDICL"
|
||||
a := n1 % 32 // unsigned
|
||||
|
||||
// 386:"SHRL",-"IDIVL"
|
||||
// amd64:"SHRQ",-"IDIVQ"
|
||||
// arm:"SRA",-".*udiv"
|
||||
// arm64:"ASR",-"REM"
|
||||
// 386:"SHRL" -"IDIVL"
|
||||
// amd64:"SHRQ" -"IDIVQ"
|
||||
// arm:"SRA" -".*udiv"
|
||||
// arm64:"ASR" -"REM"
|
||||
// ppc64x:"SRAD"
|
||||
b := n2 % 64 // signed
|
||||
|
||||
|
|
@ -402,18 +402,18 @@ func Pow2Mods(n1 uint, n2 int) (uint, int) {
|
|||
|
||||
// Check that signed divisibility checks get converted to AND on low bits
|
||||
func Pow2DivisibleSigned(n1, n2 int) (bool, bool) {
|
||||
// 386:"TESTL\t[$]63",-"DIVL",-"SHRL"
|
||||
// amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ"
|
||||
// arm:"AND\t[$]63",-".*udiv",-"SRA"
|
||||
// arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND"
|
||||
// ppc64x:"ANDCC",-"RLDICL",-"SRAD",-"CMP"
|
||||
// 386:"TESTL [$]63" -"DIVL" -"SHRL"
|
||||
// amd64:"TESTQ [$]63" -"DIVQ" -"SHRQ"
|
||||
// arm:"AND [$]63" -".*udiv" -"SRA"
|
||||
// arm64:"TST [$]63" -"UDIV" -"ASR" -"AND"
|
||||
// ppc64x:"ANDCC" -"RLDICL" -"SRAD" -"CMP"
|
||||
a := n1%64 == 0 // signed divisible
|
||||
|
||||
// 386:"TESTL\t[$]63",-"DIVL",-"SHRL"
|
||||
// amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ"
|
||||
// arm:"AND\t[$]63",-".*udiv",-"SRA"
|
||||
// arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND"
|
||||
// ppc64x:"ANDCC",-"RLDICL",-"SRAD",-"CMP"
|
||||
// 386:"TESTL [$]63" -"DIVL" -"SHRL"
|
||||
// amd64:"TESTQ [$]63" -"DIVQ" -"SHRQ"
|
||||
// arm:"AND [$]63" -".*udiv" -"SRA"
|
||||
// arm64:"TST [$]63" -"UDIV" -"ASR" -"AND"
|
||||
// ppc64x:"ANDCC" -"RLDICL" -"SRAD" -"CMP"
|
||||
b := n2%64 != 0 // signed indivisible
|
||||
|
||||
return a, b
|
||||
|
|
@ -421,14 +421,14 @@ func Pow2DivisibleSigned(n1, n2 int) (bool, bool) {
|
|||
|
||||
// Check that constant modulo divs get turned into MULs
|
||||
func ConstMods(n1 uint, n2 int) (uint, int) {
|
||||
// amd64:"MOVQ\t[$]-1085102592571150095","MULQ",-"DIVQ"
|
||||
// 386:"MOVL\t[$]-252645135","MULL",-"DIVL"
|
||||
// amd64:"MOVQ [$]-1085102592571150095" "MULQ" -"DIVQ"
|
||||
// 386:"MOVL [$]-252645135" "MULL" -"DIVL"
|
||||
// arm64:`MOVD`,`UMULH`,-`DIV`
|
||||
// arm:`MOVW`,`MUL`,-`.*udiv`
|
||||
a := n1 % 17 // unsigned
|
||||
|
||||
// amd64:"MOVQ\t[$]-1085102592571150095","IMULQ",-"IDIVQ"
|
||||
// 386:"MOVL\t[$]-252645135","IMULL",-"IDIVL"
|
||||
// amd64:"MOVQ [$]-1085102592571150095" "IMULQ" -"IDIVQ"
|
||||
// 386: "IMULL" -"IDIVL"
|
||||
// arm64:`SMULH`,-`DIV`
|
||||
// arm:`MOVW`,`MUL`,-`.*udiv`
|
||||
b := n2 % 17 // signed
|
||||
|
|
@ -438,38 +438,38 @@ func ConstMods(n1 uint, n2 int) (uint, int) {
|
|||
|
||||
// Check that divisibility checks x%c==0 are converted to MULs and rotates
|
||||
func DivisibleU(n uint) (bool, bool) {
|
||||
// amd64:"MOVQ\t[$]-6148914691236517205","IMULQ","ROLQ\t[$]63",-"DIVQ"
|
||||
// 386:"IMUL3L\t[$]-1431655765","ROLL\t[$]31",-"DIVQ"
|
||||
// arm64:"MOVD\t[$]-6148914691236517205","MOVD\t[$]3074457345618258602","MUL","ROR",-"DIV"
|
||||
// arm:"MUL","CMP\t[$]715827882",-".*udiv"
|
||||
// ppc64x:"MULLD","ROTL\t[$]63"
|
||||
// amd64:"MOVQ [$]-6148914691236517205" "IMULQ" "ROLQ [$]63" -"DIVQ"
|
||||
// 386:"IMUL3L [$]-1431655765" "ROLL [$]31" -"DIVQ"
|
||||
// arm64:"MOVD [$]-6148914691236517205" "MOVD [$]3074457345618258602" "MUL" "ROR" -"DIV"
|
||||
// arm:"MUL" "CMP [$]715827882" -".*udiv"
|
||||
// ppc64x:"MULLD" "ROTL [$]63"
|
||||
even := n%6 == 0
|
||||
|
||||
// amd64:"MOVQ\t[$]-8737931403336103397","IMULQ",-"ROLQ",-"DIVQ"
|
||||
// 386:"IMUL3L\t[$]678152731",-"ROLL",-"DIVQ"
|
||||
// arm64:"MOVD\t[$]-8737931403336103397","MUL",-"ROR",-"DIV"
|
||||
// arm:"MUL","CMP\t[$]226050910",-".*udiv"
|
||||
// ppc64x:"MULLD",-"ROTL"
|
||||
// amd64:"MOVQ [$]-8737931403336103397" "IMULQ" -"ROLQ" -"DIVQ"
|
||||
// 386:"IMUL3L [$]678152731" -"ROLL" -"DIVQ"
|
||||
// arm64:"MOVD [$]-8737931403336103397" "MUL" -"ROR" -"DIV"
|
||||
// arm:"MUL" "CMP [$]226050910" -".*udiv"
|
||||
// ppc64x:"MULLD" -"ROTL"
|
||||
odd := n%19 == 0
|
||||
|
||||
return even, odd
|
||||
}
|
||||
|
||||
func Divisible(n int) (bool, bool) {
|
||||
// amd64:"IMULQ","ADD","ROLQ\t[$]63",-"DIVQ"
|
||||
// 386:"IMUL3L\t[$]-1431655765","ADDL\t[$]715827882","ROLL\t[$]31",-"DIVQ"
|
||||
// arm64:"MOVD\t[$]-6148914691236517205","MOVD\t[$]3074457345618258602","MUL","ADD\tR","ROR",-"DIV"
|
||||
// arm:"MUL","ADD\t[$]715827882",-".*udiv"
|
||||
// ppc64x/power8:"MULLD","ADD","ROTL\t[$]63"
|
||||
// ppc64x/power9:"MADDLD","ROTL\t[$]63"
|
||||
// amd64:"IMULQ" "ADD" "ROLQ [$]63" -"DIVQ"
|
||||
// 386:"IMUL3L [$]-1431655765" "ADDL [$]715827882" "ROLL [$]31" -"DIVQ"
|
||||
// arm64:"MOVD [$]-6148914691236517205" "MOVD [$]3074457345618258602" "MUL" "ADD R" "ROR" -"DIV"
|
||||
// arm:"MUL" "ADD [$]715827882" -".*udiv"
|
||||
// ppc64x/power8:"MULLD" "ADD" "ROTL [$]63"
|
||||
// ppc64x/power9:"MADDLD" "ROTL [$]63"
|
||||
even := n%6 == 0
|
||||
|
||||
// amd64:"IMULQ","ADD",-"ROLQ",-"DIVQ"
|
||||
// 386:"IMUL3L\t[$]678152731","ADDL\t[$]113025455",-"ROLL",-"DIVQ"
|
||||
// arm64:"MUL","MOVD\t[$]485440633518672410","ADD",-"ROR",-"DIV"
|
||||
// arm:"MUL","ADD\t[$]113025455",-".*udiv"
|
||||
// ppc64x/power8:"MULLD","ADD",-"ROTL"
|
||||
// ppc64x/power9:"MADDLD",-"ROTL"
|
||||
// amd64:"IMULQ" "ADD" -"ROLQ" -"DIVQ"
|
||||
// 386:"IMUL3L [$]678152731" "ADDL [$]113025455" -"ROLL" -"DIVQ"
|
||||
// arm64:"MUL" "MOVD [$]485440633518672410" "ADD" -"ROR" -"DIV"
|
||||
// arm:"MUL" "ADD [$]113025455" -".*udiv"
|
||||
// ppc64x/power8:"MULLD" "ADD" -"ROTL"
|
||||
// ppc64x/power9:"MADDLD" -"ROTL"
|
||||
odd := n%19 == 0
|
||||
|
||||
return even, odd
|
||||
|
|
@ -568,64 +568,64 @@ func NoFix16B(divd int16) (int16, int16) {
|
|||
// optimized into shifts and ands
|
||||
|
||||
func LenDiv1(a []int) int {
|
||||
// 386:"SHRL\t[$]10"
|
||||
// amd64:"SHRQ\t[$]10"
|
||||
// arm64:"LSR\t[$]10",-"SDIV"
|
||||
// arm:"SRL\t[$]10",-".*udiv"
|
||||
// ppc64x:"SRD"\t[$]10"
|
||||
// 386:"SHRL [$]10"
|
||||
// amd64:"SHRQ [$]10"
|
||||
// arm64:"LSR [$]10" -"SDIV"
|
||||
// arm:"SRL [$]10" -".*udiv"
|
||||
// ppc64x:"SRD" [$]10"
|
||||
return len(a) / 1024
|
||||
}
|
||||
|
||||
func LenDiv2(s string) int {
|
||||
// 386:"SHRL\t[$]11"
|
||||
// amd64:"SHRQ\t[$]11"
|
||||
// arm64:"LSR\t[$]11",-"SDIV"
|
||||
// arm:"SRL\t[$]11",-".*udiv"
|
||||
// ppc64x:"SRD\t[$]11"
|
||||
// 386:"SHRL [$]11"
|
||||
// amd64:"SHRQ [$]11"
|
||||
// arm64:"LSR [$]11" -"SDIV"
|
||||
// arm:"SRL [$]11" -".*udiv"
|
||||
// ppc64x:"SRD [$]11"
|
||||
return len(s) / (4097 >> 1)
|
||||
}
|
||||
|
||||
func LenMod1(a []int) int {
|
||||
// 386:"ANDL\t[$]1023"
|
||||
// amd64:"ANDL\t[$]1023"
|
||||
// arm64:"AND\t[$]1023",-"SDIV"
|
||||
// arm/6:"AND",-".*udiv"
|
||||
// arm/7:"BFC",-".*udiv",-"AND"
|
||||
// 386:"ANDL [$]1023"
|
||||
// amd64:"ANDL [$]1023"
|
||||
// arm64:"AND [$]1023" -"SDIV"
|
||||
// arm/6:"AND" -".*udiv"
|
||||
// arm/7:"BFC" -".*udiv" -"AND"
|
||||
// ppc64x:"RLDICL"
|
||||
return len(a) % 1024
|
||||
}
|
||||
|
||||
func LenMod2(s string) int {
|
||||
// 386:"ANDL\t[$]2047"
|
||||
// amd64:"ANDL\t[$]2047"
|
||||
// arm64:"AND\t[$]2047",-"SDIV"
|
||||
// arm/6:"AND",-".*udiv"
|
||||
// arm/7:"BFC",-".*udiv",-"AND"
|
||||
// 386:"ANDL [$]2047"
|
||||
// amd64:"ANDL [$]2047"
|
||||
// arm64:"AND [$]2047" -"SDIV"
|
||||
// arm/6:"AND" -".*udiv"
|
||||
// arm/7:"BFC" -".*udiv" -"AND"
|
||||
// ppc64x:"RLDICL"
|
||||
return len(s) % (4097 >> 1)
|
||||
}
|
||||
|
||||
func CapDiv(a []int) int {
|
||||
// 386:"SHRL\t[$]12"
|
||||
// amd64:"SHRQ\t[$]12"
|
||||
// arm64:"LSR\t[$]12",-"SDIV"
|
||||
// arm:"SRL\t[$]12",-".*udiv"
|
||||
// ppc64x:"SRD\t[$]12"
|
||||
// 386:"SHRL [$]12"
|
||||
// amd64:"SHRQ [$]12"
|
||||
// arm64:"LSR [$]12" -"SDIV"
|
||||
// arm:"SRL [$]12" -".*udiv"
|
||||
// ppc64x:"SRD [$]12"
|
||||
return cap(a) / ((1 << 11) + 2048)
|
||||
}
|
||||
|
||||
func CapMod(a []int) int {
|
||||
// 386:"ANDL\t[$]4095"
|
||||
// amd64:"ANDL\t[$]4095"
|
||||
// arm64:"AND\t[$]4095",-"SDIV"
|
||||
// arm/6:"AND",-".*udiv"
|
||||
// arm/7:"BFC",-".*udiv",-"AND"
|
||||
// 386:"ANDL [$]4095"
|
||||
// amd64:"ANDL [$]4095"
|
||||
// arm64:"AND [$]4095" -"SDIV"
|
||||
// arm/6:"AND" -".*udiv"
|
||||
// arm/7:"BFC" -".*udiv" -"AND"
|
||||
// ppc64x:"RLDICL"
|
||||
return cap(a) % ((1 << 11) + 2048)
|
||||
}
|
||||
|
||||
func AddMul(x int) int {
|
||||
// amd64:"LEAQ\t1"
|
||||
// amd64:"LEAQ 1"
|
||||
return 2*x + 1
|
||||
}
|
||||
|
||||
|
|
@ -687,17 +687,17 @@ func divInt(v int64) int64 {
|
|||
// The reassociate rules "x - (z + C) -> (x - z) - C" and
|
||||
// "(z + C) -x -> C + (z - x)" can optimize the following cases.
|
||||
func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
|
||||
// arm64:"SUB","ADD\t[$]2"
|
||||
// ppc64x:"SUB","ADD\t[$]2"
|
||||
// arm64:"SUB" "ADD [$]2"
|
||||
// ppc64x:"SUB" "ADD [$]2"
|
||||
r0 := (i0 + 3) - (j0 + 1)
|
||||
// arm64:"SUB","SUB\t[$]4"
|
||||
// ppc64x:"SUB","ADD\t[$]-4"
|
||||
// arm64:"SUB" "SUB [$]4"
|
||||
// ppc64x:"SUB" "ADD [$]-4"
|
||||
r1 := (i1 - 3) - (j1 + 1)
|
||||
// arm64:"SUB","ADD\t[$]4"
|
||||
// ppc64x:"SUB","ADD\t[$]4"
|
||||
// arm64:"SUB" "ADD [$]4"
|
||||
// ppc64x:"SUB" "ADD [$]4"
|
||||
r2 := (i2 + 3) - (j2 - 1)
|
||||
// arm64:"SUB","SUB\t[$]2"
|
||||
// ppc64x:"SUB","ADD\t[$]-2"
|
||||
// arm64:"SUB" "SUB [$]2"
|
||||
// ppc64x:"SUB" "ADD [$]-2"
|
||||
r3 := (i3 - 3) - (j3 - 1)
|
||||
return r0, r1, r2, r3
|
||||
}
|
||||
|
|
@ -705,18 +705,18 @@ func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
|
|||
// The reassociate rules "x - (z + C) -> (x - z) - C" and
|
||||
// "(C - z) - x -> C - (z + x)" can optimize the following cases.
|
||||
func constantFold2(i0, j0, i1, j1 int) (int, int) {
|
||||
// arm64:"ADD","MOVD\t[$]2","SUB"
|
||||
// ppc64x: `SUBC\tR[0-9]+,\s[$]2,\sR`
|
||||
// arm64:"ADD" "MOVD [$]2" "SUB"
|
||||
// ppc64x: `SUBC R[0-9]+,\s[$]2,\sR`
|
||||
r0 := (3 - i0) - (j0 + 1)
|
||||
// arm64:"ADD","MOVD\t[$]4","SUB"
|
||||
// ppc64x: `SUBC\tR[0-9]+,\s[$]4,\sR`
|
||||
// arm64:"ADD" "MOVD [$]4" "SUB"
|
||||
// ppc64x: `SUBC R[0-9]+,\s[$]4,\sR`
|
||||
r1 := (3 - i1) - (j1 - 1)
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
func constantFold3(i, j int) int {
|
||||
// arm64: "LSL\t[$]5,","SUB\tR[0-9]+<<1,",-"ADD"
|
||||
// ppc64x:"MULLD\t[$]30","MULLD"
|
||||
// arm64: "LSL [$]5," "SUB R[0-9]+<<1," -"ADD"
|
||||
// ppc64x:"MULLD [$]30" "MULLD"
|
||||
r := (5 * i) * (6 * j)
|
||||
return r
|
||||
}
|
||||
|
|
@ -726,32 +726,32 @@ func constantFold3(i, j int) int {
|
|||
// ----------------- //
|
||||
|
||||
func Int64Min(a, b int64) int64 {
|
||||
// amd64: "CMPQ","CMOVQLT"
|
||||
// arm64: "CMP","CSEL"
|
||||
// riscv64/rva20u64:"BLT\t"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"MIN\t"
|
||||
// amd64: "CMPQ" "CMOVQLT"
|
||||
// arm64: "CMP" "CSEL"
|
||||
// riscv64/rva20u64:"BLT "
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"MIN "
|
||||
return min(a, b)
|
||||
}
|
||||
|
||||
func Int64Max(a, b int64) int64 {
|
||||
// amd64: "CMPQ","CMOVQGT"
|
||||
// arm64: "CMP","CSEL"
|
||||
// riscv64/rva20u64:"BLT\t"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"MAX\t"
|
||||
// amd64: "CMPQ" "CMOVQGT"
|
||||
// arm64: "CMP" "CSEL"
|
||||
// riscv64/rva20u64:"BLT "
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"MAX "
|
||||
return max(a, b)
|
||||
}
|
||||
|
||||
func Uint64Min(a, b uint64) uint64 {
|
||||
// amd64: "CMPQ","CMOVQCS"
|
||||
// arm64: "CMP","CSEL"
|
||||
// amd64: "CMPQ" "CMOVQCS"
|
||||
// arm64: "CMP" "CSEL"
|
||||
// riscv64/rva20u64:"BLTU"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"MINU"
|
||||
return min(a, b)
|
||||
}
|
||||
|
||||
func Uint64Max(a, b uint64) uint64 {
|
||||
// amd64: "CMPQ","CMOVQHI"
|
||||
// arm64: "CMP","CSEL"
|
||||
// amd64: "CMPQ" "CMOVQHI"
|
||||
// arm64: "CMP" "CSEL"
|
||||
// riscv64/rva20u64:"BLTU"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"MAXU"
|
||||
return max(a, b)
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ func (c *Counter) Increment() {
|
|||
// arm64/v8.1:"LDADDALW"
|
||||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// amd64:"LOCK",-"CMPXCHG"
|
||||
// amd64:"LOCK" -"CMPXCHG"
|
||||
atomic.AddInt32(&c.count, 1)
|
||||
}
|
||||
|
||||
|
|
@ -34,13 +34,13 @@ func atomicLogical64(x *atomic.Uint64) uint64 {
|
|||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// On amd64, make sure we use LOCK+AND instead of CMPXCHG when we don't use the result.
|
||||
// amd64:"LOCK",-"CMPXCHGQ"
|
||||
// amd64:"LOCK" -"CMPXCHGQ"
|
||||
x.And(11)
|
||||
// arm64/v8.0:"LDCLRALD"
|
||||
// arm64/v8.1:"LDCLRALD"
|
||||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// amd64:"LOCK","CMPXCHGQ"
|
||||
// amd64:"LOCK" "CMPXCHGQ"
|
||||
r += x.And(22)
|
||||
|
||||
// arm64/v8.0:"LDORALD"
|
||||
|
|
@ -48,13 +48,13 @@ func atomicLogical64(x *atomic.Uint64) uint64 {
|
|||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// On amd64, make sure we use LOCK+OR instead of CMPXCHG when we don't use the result.
|
||||
// amd64:"LOCK",-"CMPXCHGQ"
|
||||
// amd64:"LOCK" -"CMPXCHGQ"
|
||||
x.Or(33)
|
||||
// arm64/v8.0:"LDORALD"
|
||||
// arm64/v8.1:"LDORALD"
|
||||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// amd64:"LOCK","CMPXCHGQ"
|
||||
// amd64:"LOCK" "CMPXCHGQ"
|
||||
r += x.Or(44)
|
||||
|
||||
return r
|
||||
|
|
@ -68,13 +68,13 @@ func atomicLogical32(x *atomic.Uint32) uint32 {
|
|||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// On amd64, make sure we use LOCK+AND instead of CMPXCHG when we don't use the result.
|
||||
// amd64:"LOCK",-"CMPXCHGL"
|
||||
// amd64:"LOCK" -"CMPXCHGL"
|
||||
x.And(11)
|
||||
// arm64/v8.0:"LDCLRALW"
|
||||
// arm64/v8.1:"LDCLRALW"
|
||||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// amd64:"LOCK","CMPXCHGL"
|
||||
// amd64:"LOCK" "CMPXCHGL"
|
||||
r += x.And(22)
|
||||
|
||||
// arm64/v8.0:"LDORALW"
|
||||
|
|
@ -82,13 +82,13 @@ func atomicLogical32(x *atomic.Uint32) uint32 {
|
|||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// On amd64, make sure we use LOCK+OR instead of CMPXCHG when we don't use the result.
|
||||
// amd64:"LOCK",-"CMPXCHGL"
|
||||
// amd64:"LOCK" -"CMPXCHGL"
|
||||
x.Or(33)
|
||||
// arm64/v8.0:"LDORALW"
|
||||
// arm64/v8.1:"LDORALW"
|
||||
// arm64/v8.0:".*arm64HasATOMICS"
|
||||
// arm64/v8.1:-".*arm64HasATOMICS"
|
||||
// amd64:"LOCK","CMPXCHGL"
|
||||
// amd64:"LOCK" "CMPXCHGL"
|
||||
r += x.Or(44)
|
||||
|
||||
return r
|
||||
|
|
|
|||
|
|
@ -10,304 +10,304 @@ package codegen
|
|||
// insertion/extraction simplifications/optimizations.
|
||||
|
||||
func extr1(x, x2 uint64) uint64 {
|
||||
return x<<7 + x2>>57 // arm64:"EXTR\t[$]57,"
|
||||
return x<<7 + x2>>57 // arm64:"EXTR [$]57,"
|
||||
}
|
||||
|
||||
func extr2(x, x2 uint64) uint64 {
|
||||
return x<<7 | x2>>57 // arm64:"EXTR\t[$]57,"
|
||||
return x<<7 | x2>>57 // arm64:"EXTR [$]57,"
|
||||
}
|
||||
|
||||
func extr3(x, x2 uint64) uint64 {
|
||||
return x<<7 ^ x2>>57 // arm64:"EXTR\t[$]57,"
|
||||
return x<<7 ^ x2>>57 // arm64:"EXTR [$]57,"
|
||||
}
|
||||
|
||||
func extr4(x, x2 uint32) uint32 {
|
||||
return x<<7 + x2>>25 // arm64:"EXTRW\t[$]25,"
|
||||
return x<<7 + x2>>25 // arm64:"EXTRW [$]25,"
|
||||
}
|
||||
|
||||
func extr5(x, x2 uint32) uint32 {
|
||||
return x<<7 | x2>>25 // arm64:"EXTRW\t[$]25,"
|
||||
return x<<7 | x2>>25 // arm64:"EXTRW [$]25,"
|
||||
}
|
||||
|
||||
func extr6(x, x2 uint32) uint32 {
|
||||
return x<<7 ^ x2>>25 // arm64:"EXTRW\t[$]25,"
|
||||
return x<<7 ^ x2>>25 // arm64:"EXTRW [$]25,"
|
||||
}
|
||||
|
||||
// check 32-bit shift masking
|
||||
func mask32(x uint32) uint32 {
|
||||
return (x << 29) >> 29 // arm64:"AND\t[$]7, R[0-9]+",-"LSR",-"LSL"
|
||||
return (x << 29) >> 29 // arm64:"AND [$]7, R[0-9]+" -"LSR" -"LSL"
|
||||
}
|
||||
|
||||
// check 16-bit shift masking
|
||||
func mask16(x uint16) uint16 {
|
||||
return (x << 14) >> 14 // arm64:"AND\t[$]3, R[0-9]+",-"LSR",-"LSL"
|
||||
return (x << 14) >> 14 // arm64:"AND [$]3, R[0-9]+" -"LSR" -"LSL"
|
||||
}
|
||||
|
||||
// check 8-bit shift masking
|
||||
func mask8(x uint8) uint8 {
|
||||
return (x << 7) >> 7 // arm64:"AND\t[$]1, R[0-9]+",-"LSR",-"LSL"
|
||||
return (x << 7) >> 7 // arm64:"AND [$]1, R[0-9]+" -"LSR" -"LSL"
|
||||
}
|
||||
|
||||
func maskshift(x uint64) uint64 {
|
||||
// arm64:"AND\t[$]4095, R[0-9]+",-"LSL",-"LSR",-"UBFIZ",-"UBFX"
|
||||
// arm64:"AND [$]4095, R[0-9]+" -"LSL" -"LSR" -"UBFIZ" -"UBFX"
|
||||
return ((x << 5) & (0xfff << 5)) >> 5
|
||||
}
|
||||
|
||||
// bitfield ops
|
||||
// bfi
|
||||
func bfi1(x, y uint64) uint64 {
|
||||
// arm64:"BFI\t[$]4, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND"
|
||||
// arm64:"BFI [$]4, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND"
|
||||
return ((x & 0xfff) << 4) | (y & 0xffffffffffff000f)
|
||||
}
|
||||
|
||||
func bfi2(x, y uint64) uint64 {
|
||||
// arm64:"BFI\t[$]12, R[0-9]+, [$]40",-"LSL",-"LSR",-"AND"
|
||||
// arm64:"BFI [$]12, R[0-9]+, [$]40" -"LSL" -"LSR" -"AND"
|
||||
return (x << 24 >> 12) | (y & 0xfff0000000000fff)
|
||||
}
|
||||
|
||||
// bfxil
|
||||
func bfxil1(x, y uint64) uint64 {
|
||||
// arm64:"BFXIL\t[$]5, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND"
|
||||
// arm64:"BFXIL [$]5, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND"
|
||||
return ((x >> 5) & 0xfff) | (y & 0xfffffffffffff000)
|
||||
}
|
||||
|
||||
func bfxil2(x, y uint64) uint64 {
|
||||
// arm64:"BFXIL\t[$]12, R[0-9]+, [$]40",-"LSL",-"LSR",-"AND"
|
||||
// arm64:"BFXIL [$]12, R[0-9]+, [$]40" -"LSL" -"LSR" -"AND"
|
||||
return (x << 12 >> 24) | (y & 0xffffff0000000000)
|
||||
}
|
||||
|
||||
// sbfiz
|
||||
// merge shifts into sbfiz: (x << lc) >> rc && lc > rc.
|
||||
func sbfiz1(x int64) int64 {
|
||||
// arm64:"SBFIZ\t[$]1, R[0-9]+, [$]60",-"LSL",-"ASR"
|
||||
// arm64:"SBFIZ [$]1, R[0-9]+, [$]60" -"LSL" -"ASR"
|
||||
return (x << 4) >> 3
|
||||
}
|
||||
|
||||
// merge shift and sign-extension into sbfiz.
|
||||
func sbfiz2(x int32) int64 {
|
||||
return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]29",-"LSL"
|
||||
return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]29" -"LSL"
|
||||
}
|
||||
|
||||
func sbfiz3(x int16) int64 {
|
||||
return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]13",-"LSL"
|
||||
return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]13" -"LSL"
|
||||
}
|
||||
|
||||
func sbfiz4(x int8) int64 {
|
||||
return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]5",-"LSL"
|
||||
return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]5" -"LSL"
|
||||
}
|
||||
|
||||
// sbfiz combinations.
|
||||
// merge shift with sbfiz into sbfiz.
|
||||
func sbfiz5(x int32) int32 {
|
||||
// arm64:"SBFIZ\t[$]1, R[0-9]+, [$]28",-"LSL",-"ASR"
|
||||
// arm64:"SBFIZ [$]1, R[0-9]+, [$]28" -"LSL" -"ASR"
|
||||
return (x << 4) >> 3
|
||||
}
|
||||
|
||||
func sbfiz6(x int16) int64 {
|
||||
return int64(x+1) << 3 // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]16",-"LSL"
|
||||
return int64(x+1) << 3 // arm64:"SBFIZ [$]3, R[0-9]+, [$]16" -"LSL"
|
||||
}
|
||||
|
||||
func sbfiz7(x int8) int64 {
|
||||
return int64(x+1) << 62 // arm64:"SBFIZ\t[$]62, R[0-9]+, [$]2",-"LSL"
|
||||
return int64(x+1) << 62 // arm64:"SBFIZ [$]62, R[0-9]+, [$]2" -"LSL"
|
||||
}
|
||||
|
||||
func sbfiz8(x int32) int64 {
|
||||
return int64(x+1) << 40 // arm64:"SBFIZ\t[$]40, R[0-9]+, [$]24",-"LSL"
|
||||
return int64(x+1) << 40 // arm64:"SBFIZ [$]40, R[0-9]+, [$]24" -"LSL"
|
||||
}
|
||||
|
||||
// sbfx
|
||||
// merge shifts into sbfx: (x << lc) >> rc && lc <= rc.
|
||||
func sbfx1(x int64) int64 {
|
||||
return (x << 3) >> 4 // arm64:"SBFX\t[$]1, R[0-9]+, [$]60",-"LSL",-"ASR"
|
||||
return (x << 3) >> 4 // arm64:"SBFX [$]1, R[0-9]+, [$]60" -"LSL" -"ASR"
|
||||
}
|
||||
|
||||
func sbfx2(x int64) int64 {
|
||||
return (x << 60) >> 60 // arm64:"SBFX\t[$]0, R[0-9]+, [$]4",-"LSL",-"ASR"
|
||||
return (x << 60) >> 60 // arm64:"SBFX [$]0, R[0-9]+, [$]4" -"LSL" -"ASR"
|
||||
}
|
||||
|
||||
// merge shift and sign-extension into sbfx.
|
||||
func sbfx3(x int32) int64 {
|
||||
return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]29",-"ASR"
|
||||
return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]29" -"ASR"
|
||||
}
|
||||
|
||||
func sbfx4(x int16) int64 {
|
||||
return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]13",-"ASR"
|
||||
return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]13" -"ASR"
|
||||
}
|
||||
|
||||
func sbfx5(x int8) int64 {
|
||||
return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]5",-"ASR"
|
||||
return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]5" -"ASR"
|
||||
}
|
||||
|
||||
func sbfx6(x int32) int64 {
|
||||
return int64(x >> 30) // arm64:"SBFX\t[$]30, R[0-9]+, [$]2"
|
||||
return int64(x >> 30) // arm64:"SBFX [$]30, R[0-9]+, [$]2"
|
||||
}
|
||||
|
||||
func sbfx7(x int16) int64 {
|
||||
return int64(x >> 10) // arm64:"SBFX\t[$]10, R[0-9]+, [$]6"
|
||||
return int64(x >> 10) // arm64:"SBFX [$]10, R[0-9]+, [$]6"
|
||||
}
|
||||
|
||||
func sbfx8(x int8) int64 {
|
||||
return int64(x >> 5) // arm64:"SBFX\t[$]5, R[0-9]+, [$]3"
|
||||
return int64(x >> 5) // arm64:"SBFX [$]5, R[0-9]+, [$]3"
|
||||
}
|
||||
|
||||
// sbfx combinations.
|
||||
// merge shifts with sbfiz into sbfx.
|
||||
func sbfx9(x int32) int32 {
|
||||
return (x << 3) >> 4 // arm64:"SBFX\t[$]1, R[0-9]+, [$]28",-"LSL",-"ASR"
|
||||
return (x << 3) >> 4 // arm64:"SBFX [$]1, R[0-9]+, [$]28" -"LSL" -"ASR"
|
||||
}
|
||||
|
||||
// merge sbfx and sign-extension into sbfx.
|
||||
func sbfx10(x int32) int64 {
|
||||
c := x + 5
|
||||
return int64(c >> 20) // arm64"SBFX\t[$]20, R[0-9]+, [$]12",-"MOVW\tR[0-9]+, R[0-9]+"
|
||||
return int64(c >> 20) // arm64"SBFX [$]20, R[0-9]+, [$]12" -"MOVW R[0-9]+, R[0-9]+"
|
||||
}
|
||||
|
||||
// ubfiz
|
||||
// merge shifts into ubfiz: (x<<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
|
||||
}
|
||||
|
||||
|
|
@ -315,7 +315,7 @@ func ubfx14(x uint64) uint64 {
|
|||
func ubfx15(x uint64) bool {
|
||||
midr := x + 10
|
||||
part_num := uint16((midr >> 4) & 0xfff)
|
||||
if part_num == 0xd0c { // arm64:"UBFX\t[$]4, R[0-9]+, [$]12",-"MOVHU\tR[0-9]+, R[0-9]+"
|
||||
if part_num == 0xd0c { // arm64:"UBFX [$]4, R[0-9]+, [$]12" -"MOVHU R[0-9]+, R[0-9]+"
|
||||
return true
|
||||
}
|
||||
return false
|
||||
|
|
@ -323,7 +323,7 @@ func ubfx15(x uint64) bool {
|
|||
|
||||
// merge ANDconst and ubfx into ubfx
|
||||
func ubfx16(x uint64) uint64 {
|
||||
// arm64:"UBFX\t[$]4, R[0-9]+, [$]6",-"AND\t[$]63"
|
||||
// arm64:"UBFX [$]4, R[0-9]+, [$]6" -"AND [$]63"
|
||||
return ((x >> 3) & 0xfff) >> 1 & 0x3f
|
||||
}
|
||||
|
||||
|
|
@ -331,48 +331,48 @@ func ubfx16(x uint64) uint64 {
|
|||
//
|
||||
//go:nosplit
|
||||
func shift_no_cmp(x int) int {
|
||||
// arm64:`LSL\t[$]17`,-`CMP`
|
||||
// mips64:`SLLV\t[$]17`,-`SGT`
|
||||
// arm64:`LSL [$]17`,-`CMP`
|
||||
// mips64:`SLLV [$]17`,-`SGT`
|
||||
return x << 17
|
||||
}
|
||||
|
||||
func rev16(c uint64) (uint64, uint64, uint64) {
|
||||
// arm64:`REV16`,-`AND`,-`LSR`,-`AND`,-`ORR\tR[0-9]+<<8`
|
||||
// arm64:`REV16`,-`AND`,-`LSR`,-`AND`,-`ORR R[0-9]+<<8`
|
||||
// loong64:`REVB4H`,-`MOVV`,-`AND`,-`SRLV`,-`AND`,-`SLLV`,-`OR`
|
||||
b1 := ((c & 0xff00ff00ff00ff00) >> 8) | ((c & 0x00ff00ff00ff00ff) << 8)
|
||||
// arm64:-`ADD\tR[0-9]+<<8`
|
||||
// arm64:-`ADD R[0-9]+<<8`
|
||||
// loong64:-`ADDV`
|
||||
b2 := ((c & 0xff00ff00ff00ff00) >> 8) + ((c & 0x00ff00ff00ff00ff) << 8)
|
||||
// arm64:-`EOR\tR[0-9]+<<8`
|
||||
// arm64:-`EOR R[0-9]+<<8`
|
||||
// loong64:-`XOR`
|
||||
b3 := ((c & 0xff00ff00ff00ff00) >> 8) ^ ((c & 0x00ff00ff00ff00ff) << 8)
|
||||
return b1, b2, b3
|
||||
}
|
||||
|
||||
func rev16w(c uint32) (uint32, uint32, uint32) {
|
||||
// arm64:`REV16W`,-`AND`,-`UBFX`,-`AND`,-`ORR\tR[0-9]+<<8`
|
||||
// arm64:`REV16W`,-`AND`,-`UBFX`,-`AND`,-`ORR R[0-9]+<<8`
|
||||
// loong64:`REVB2H`,-`AND`,-`SRL`,-`AND`,-`SLL`,-`OR`
|
||||
b1 := ((c & 0xff00ff00) >> 8) | ((c & 0x00ff00ff) << 8)
|
||||
// arm64:-`ADD\tR[0-9]+<<8`
|
||||
// arm64:-`ADD R[0-9]+<<8`
|
||||
// loong64:-`ADDV`
|
||||
b2 := ((c & 0xff00ff00) >> 8) + ((c & 0x00ff00ff) << 8)
|
||||
// arm64:-`EOR\tR[0-9]+<<8`
|
||||
// arm64:-`EOR R[0-9]+<<8`
|
||||
// loong64:-`XOR`
|
||||
b3 := ((c & 0xff00ff00) >> 8) ^ ((c & 0x00ff00ff) << 8)
|
||||
return b1, b2, b3
|
||||
}
|
||||
|
||||
func shift(x uint32, y uint16, z uint8) uint64 {
|
||||
// arm64:-`MOVWU`,-`LSR\t[$]32`
|
||||
// loong64:-`MOVWU`,-`SRLV\t[$]32`
|
||||
// arm64:-`MOVWU`,-`LSR [$]32`
|
||||
// loong64:-`MOVWU`,-`SRLV [$]32`
|
||||
a := uint64(x) >> 32
|
||||
// arm64:-`MOVHU
|
||||
// loong64:-`MOVHU`,-`SRLV\t[$]16`
|
||||
// loong64:-`MOVHU`,-`SRLV [$]16`
|
||||
b := uint64(y) >> 16
|
||||
// arm64:-`MOVBU`
|
||||
// loong64:-`MOVBU`,-`SRLV\t[$]8`
|
||||
// loong64:-`MOVBU`,-`SRLV [$]8`
|
||||
c := uint64(z) >> 8
|
||||
// arm64:`MOVD\tZR`,-`ADD\tR[0-9]+>>16`,-`ADD\tR[0-9]+>>8`,
|
||||
// loong64:`MOVV\tR0`,-`ADDVU`
|
||||
// arm64:`MOVD ZR`,-`ADD R[0-9]+>>16`,-`ADD R[0-9]+>>8`,
|
||||
// loong64:`MOVV R0`,-`ADDVU`
|
||||
return a + b + c
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,15 +13,15 @@ import "math/bits"
|
|||
************************************/
|
||||
|
||||
func bitcheck64_constleft(a uint64) (n int) {
|
||||
// amd64:"BTQ\t[$]63"
|
||||
// amd64:"BTQ [$]63"
|
||||
if a&(1<<63) != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTQ\t[$]60"
|
||||
// amd64:"BTQ [$]60"
|
||||
if a&(1<<60) != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]0"
|
||||
// amd64:"BTL [$]0"
|
||||
if a&(1<<0) != 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -29,31 +29,31 @@ func bitcheck64_constleft(a uint64) (n int) {
|
|||
}
|
||||
|
||||
func bitcheck64_constright(a [8]uint64) (n int) {
|
||||
// amd64:"BTQ\t[$]63"
|
||||
// amd64:"BTQ [$]63"
|
||||
if (a[0]>>63)&1 != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTQ\t[$]63"
|
||||
// amd64:"BTQ [$]63"
|
||||
if a[1]>>63 != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTQ\t[$]63"
|
||||
// amd64:"BTQ [$]63"
|
||||
if a[2]>>63 == 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTQ\t[$]60"
|
||||
// amd64:"BTQ [$]60"
|
||||
if (a[3]>>60)&1 == 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]1"
|
||||
// amd64:"BTL [$]1"
|
||||
if (a[4]>>1)&1 == 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]0"
|
||||
// amd64:"BTL [$]0"
|
||||
if (a[5]>>0)&1 == 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]7"
|
||||
// amd64:"BTL [$]7"
|
||||
if (a[6]>>5)&4 == 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -65,7 +65,7 @@ func bitcheck64_var(a, b uint64) (n int) {
|
|||
if a&(1<<(b&63)) != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTQ",-"BT.\t[$]0"
|
||||
// amd64:"BTQ" -"BT. [$]0"
|
||||
if (b>>(a&63))&1 != 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -73,15 +73,15 @@ func bitcheck64_var(a, b uint64) (n int) {
|
|||
}
|
||||
|
||||
func bitcheck64_mask(a uint64) (n int) {
|
||||
// amd64:"BTQ\t[$]63"
|
||||
// amd64:"BTQ [$]63"
|
||||
if a&0x8000000000000000 != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTQ\t[$]59"
|
||||
// amd64:"BTQ [$]59"
|
||||
if a&0x800000000000000 != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]0"
|
||||
// amd64:"BTL [$]0"
|
||||
if a&0x1 != 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -92,13 +92,13 @@ func biton64(a, b uint64) (n uint64) {
|
|||
// amd64:"BTSQ"
|
||||
n += b | (1 << (a & 63))
|
||||
|
||||
// amd64:"BTSQ\t[$]63"
|
||||
// amd64:"BTSQ [$]63"
|
||||
n += a | (1 << 63)
|
||||
|
||||
// amd64:"BTSQ\t[$]60"
|
||||
// amd64:"BTSQ [$]60"
|
||||
n += a | (1 << 60)
|
||||
|
||||
// amd64:"ORQ\t[$]1"
|
||||
// amd64:"ORQ [$]1"
|
||||
n += a | (1 << 0)
|
||||
|
||||
return n
|
||||
|
|
@ -108,23 +108,23 @@ func bitoff64(a, b uint64) (n uint64) {
|
|||
// amd64:"BTRQ"
|
||||
n += b &^ (1 << (a & 63))
|
||||
|
||||
// amd64:"BTRQ\t[$]63"
|
||||
// amd64:"BTRQ [$]63"
|
||||
n += a &^ (1 << 63)
|
||||
|
||||
// amd64:"BTRQ\t[$]60"
|
||||
// amd64:"BTRQ [$]60"
|
||||
n += a &^ (1 << 60)
|
||||
|
||||
// amd64:"ANDQ\t[$]-2"
|
||||
// amd64:"ANDQ [$]-2"
|
||||
n += a &^ (1 << 0)
|
||||
|
||||
return n
|
||||
}
|
||||
|
||||
func clearLastBit(x int64, y int32) (int64, int32) {
|
||||
// amd64:"ANDQ\t[$]-2"
|
||||
// amd64:"ANDQ [$]-2"
|
||||
a := (x >> 1) << 1
|
||||
|
||||
// amd64:"ANDL\t[$]-2"
|
||||
// amd64:"ANDL [$]-2"
|
||||
b := (y >> 1) << 1
|
||||
|
||||
return a, b
|
||||
|
|
@ -134,13 +134,13 @@ func bitcompl64(a, b uint64) (n uint64) {
|
|||
// amd64:"BTCQ"
|
||||
n += b ^ (1 << (a & 63))
|
||||
|
||||
// amd64:"BTCQ\t[$]63"
|
||||
// amd64:"BTCQ [$]63"
|
||||
n += a ^ (1 << 63)
|
||||
|
||||
// amd64:"BTCQ\t[$]60"
|
||||
// amd64:"BTCQ [$]60"
|
||||
n += a ^ (1 << 60)
|
||||
|
||||
// amd64:"XORQ\t[$]1"
|
||||
// amd64:"XORQ [$]1"
|
||||
n += a ^ (1 << 0)
|
||||
|
||||
return n
|
||||
|
|
@ -151,15 +151,15 @@ func bitcompl64(a, b uint64) (n uint64) {
|
|||
************************************/
|
||||
|
||||
func bitcheck32_constleft(a uint32) (n int) {
|
||||
// amd64:"BTL\t[$]31"
|
||||
// amd64:"BTL [$]31"
|
||||
if a&(1<<31) != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]28"
|
||||
// amd64:"BTL [$]28"
|
||||
if a&(1<<28) != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]0"
|
||||
// amd64:"BTL [$]0"
|
||||
if a&(1<<0) != 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -167,31 +167,31 @@ func bitcheck32_constleft(a uint32) (n int) {
|
|||
}
|
||||
|
||||
func bitcheck32_constright(a [8]uint32) (n int) {
|
||||
// amd64:"BTL\t[$]31"
|
||||
// amd64:"BTL [$]31"
|
||||
if (a[0]>>31)&1 != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]31"
|
||||
// amd64:"BTL [$]31"
|
||||
if a[1]>>31 != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]31"
|
||||
// amd64:"BTL [$]31"
|
||||
if a[2]>>31 == 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]28"
|
||||
// amd64:"BTL [$]28"
|
||||
if (a[3]>>28)&1 == 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]1"
|
||||
// amd64:"BTL [$]1"
|
||||
if (a[4]>>1)&1 == 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]0"
|
||||
// amd64:"BTL [$]0"
|
||||
if (a[5]>>0)&1 == 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]7"
|
||||
// amd64:"BTL [$]7"
|
||||
if (a[6]>>5)&4 == 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -203,7 +203,7 @@ func bitcheck32_var(a, b uint32) (n int) {
|
|||
if a&(1<<(b&31)) != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL",-"BT.\t[$]0"
|
||||
// amd64:"BTL" -"BT. [$]0"
|
||||
if (b>>(a&31))&1 != 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -211,15 +211,15 @@ func bitcheck32_var(a, b uint32) (n int) {
|
|||
}
|
||||
|
||||
func bitcheck32_mask(a uint32) (n int) {
|
||||
// amd64:"BTL\t[$]31"
|
||||
// amd64:"BTL [$]31"
|
||||
if a&0x80000000 != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]27"
|
||||
// amd64:"BTL [$]27"
|
||||
if a&0x8000000 != 0 {
|
||||
return 1
|
||||
}
|
||||
// amd64:"BTL\t[$]0"
|
||||
// amd64:"BTL [$]0"
|
||||
if a&0x1 != 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -230,13 +230,13 @@ func biton32(a, b uint32) (n uint32) {
|
|||
// amd64:"BTSL"
|
||||
n += b | (1 << (a & 31))
|
||||
|
||||
// amd64:"ORL\t[$]-2147483648"
|
||||
// amd64:"ORL [$]-2147483648"
|
||||
n += a | (1 << 31)
|
||||
|
||||
// amd64:"ORL\t[$]268435456"
|
||||
// amd64:"ORL [$]268435456"
|
||||
n += a | (1 << 28)
|
||||
|
||||
// amd64:"ORL\t[$]1"
|
||||
// amd64:"ORL [$]1"
|
||||
n += a | (1 << 0)
|
||||
|
||||
return n
|
||||
|
|
@ -246,13 +246,13 @@ func bitoff32(a, b uint32) (n uint32) {
|
|||
// amd64:"BTRL"
|
||||
n += b &^ (1 << (a & 31))
|
||||
|
||||
// amd64:"ANDL\t[$]2147483647"
|
||||
// amd64:"ANDL [$]2147483647"
|
||||
n += a &^ (1 << 31)
|
||||
|
||||
// amd64:"ANDL\t[$]-268435457"
|
||||
// amd64:"ANDL [$]-268435457"
|
||||
n += a &^ (1 << 28)
|
||||
|
||||
// amd64:"ANDL\t[$]-2"
|
||||
// amd64:"ANDL [$]-2"
|
||||
n += a &^ (1 << 0)
|
||||
|
||||
return n
|
||||
|
|
@ -262,13 +262,13 @@ func bitcompl32(a, b uint32) (n uint32) {
|
|||
// amd64:"BTCL"
|
||||
n += b ^ (1 << (a & 31))
|
||||
|
||||
// amd64:"XORL\t[$]-2147483648"
|
||||
// amd64:"XORL [$]-2147483648"
|
||||
n += a ^ (1 << 31)
|
||||
|
||||
// amd64:"XORL\t[$]268435456"
|
||||
// amd64:"XORL [$]268435456"
|
||||
n += a ^ (1 << 28)
|
||||
|
||||
// amd64:"XORL\t[$]1"
|
||||
// amd64:"XORL [$]1"
|
||||
n += a ^ (1 << 0)
|
||||
|
||||
return n
|
||||
|
|
@ -292,12 +292,12 @@ func bitcheckMostNegative(b uint8) bool {
|
|||
// Check AND masking on arm64 (Issue #19857)
|
||||
|
||||
func and_mask_1(a uint64) uint64 {
|
||||
// arm64:`AND\t`
|
||||
// arm64:`AND `
|
||||
return a & ((1 << 63) - 1)
|
||||
}
|
||||
|
||||
func and_mask_2(a uint64) uint64 {
|
||||
// arm64:`AND\t`
|
||||
// arm64:`AND `
|
||||
return a & (1 << 63)
|
||||
}
|
||||
|
||||
|
|
@ -312,65 +312,65 @@ func and_mask_3(a, b uint32) (uint32, uint32) {
|
|||
// Check generation of arm64 BIC/EON/ORN instructions
|
||||
|
||||
func op_bic(x, y uint32) uint32 {
|
||||
// arm64:`BIC\t`,-`AND`
|
||||
// arm64:`BIC `,-`AND`
|
||||
return x &^ y
|
||||
}
|
||||
|
||||
func op_eon(x, y, z uint32, a []uint32, n, m uint64) uint64 {
|
||||
// arm64:`EON\t`,-`EOR`,-`MVN`
|
||||
// arm64:`EON `,-`EOR`,-`MVN`
|
||||
a[0] = x ^ (y ^ 0xffffffff)
|
||||
|
||||
// arm64:`EON\t`,-`EOR`,-`MVN`
|
||||
// arm64:`EON `,-`EOR`,-`MVN`
|
||||
a[1] = ^(y ^ z)
|
||||
|
||||
// arm64:`EON\t`,-`XOR`
|
||||
// arm64:`EON `,-`XOR`
|
||||
a[2] = x ^ ^z
|
||||
|
||||
// arm64:`EON\t`,-`EOR`,-`MVN`
|
||||
// arm64:`EON `,-`EOR`,-`MVN`
|
||||
return n ^ (m ^ 0xffffffffffffffff)
|
||||
}
|
||||
|
||||
func op_orn(x, y uint32) uint32 {
|
||||
// arm64:`ORN\t`,-`ORR`
|
||||
// loong64:"ORN"\t,-"OR\t"
|
||||
// arm64:`ORN `,-`ORR`
|
||||
// loong64:"ORN" ,-"OR "
|
||||
return x | ^y
|
||||
}
|
||||
|
||||
func op_nor(x int64, a []int64) {
|
||||
// loong64: "MOVV\t[$]0","NOR\tR"
|
||||
// loong64: "MOVV [$]0" "NOR R"
|
||||
a[0] = ^(0x1234 | x)
|
||||
// loong64:"NOR",-"XOR"
|
||||
// loong64:"NOR" -"XOR"
|
||||
a[1] = (-1) ^ x
|
||||
// loong64: "MOVV\t[$]-55",-"OR",-"NOR"
|
||||
// loong64: "MOVV [$]-55" -"OR" -"NOR"
|
||||
a[2] = ^(0x12 | 0x34)
|
||||
}
|
||||
|
||||
func op_andn(x, y uint32) uint32 {
|
||||
// loong64:"ANDN\t",-"AND\t"
|
||||
// loong64:"ANDN " -"AND "
|
||||
return x &^ y
|
||||
}
|
||||
|
||||
// check bitsets
|
||||
func bitSetPowerOf2Test(x int) bool {
|
||||
// amd64:"BTL\t[$]3"
|
||||
// amd64:"BTL [$]3"
|
||||
return x&8 == 8
|
||||
}
|
||||
|
||||
func bitSetTest(x int) bool {
|
||||
// amd64:"ANDL\t[$]9, AX"
|
||||
// amd64:"CMPQ\tAX, [$]9"
|
||||
// amd64:"ANDL [$]9, AX"
|
||||
// amd64:"CMPQ AX, [$]9"
|
||||
return x&9 == 9
|
||||
}
|
||||
|
||||
// mask contiguous one bits
|
||||
func cont1Mask64U(x uint64) uint64 {
|
||||
// s390x:"RISBGZ\t[$]16, [$]47, [$]0,"
|
||||
// s390x:"RISBGZ [$]16, [$]47, [$]0,"
|
||||
return x & 0x0000ffffffff0000
|
||||
}
|
||||
|
||||
// mask contiguous zero bits
|
||||
func cont0Mask64U(x uint64) uint64 {
|
||||
// s390x:"RISBGZ\t[$]48, [$]15, [$]0,"
|
||||
// s390x:"RISBGZ [$]48, [$]15, [$]0,"
|
||||
return x & 0xffff00000000ffff
|
||||
}
|
||||
|
||||
|
|
@ -390,60 +390,60 @@ func issue48467(x, y uint64) uint64 {
|
|||
}
|
||||
|
||||
func foldConst(x, y uint64) uint64 {
|
||||
// arm64: "ADDS\t[$]7",-"MOVD\t[$]7"
|
||||
// ppc64x: "ADDC\t[$]7,"
|
||||
// arm64: "ADDS [$]7" -"MOVD [$]7"
|
||||
// ppc64x: "ADDC [$]7,"
|
||||
d, b := bits.Add64(x, 7, 0)
|
||||
return b & d
|
||||
}
|
||||
|
||||
func foldConstOutOfRange(a uint64) uint64 {
|
||||
// arm64: "MOVD\t[$]19088744",-"ADD\t[$]19088744"
|
||||
// arm64: "MOVD [$]19088744" -"ADD [$]19088744"
|
||||
return a + 0x1234568
|
||||
}
|
||||
|
||||
// Verify sign-extended values are not zero-extended under a bit mask (#61297)
|
||||
func signextendAndMask8to64(a int8) (s, z uint64) {
|
||||
// ppc64x: "MOVB", "ANDCC\t[$]1015,"
|
||||
// ppc64x: "MOVB", "ANDCC [$]1015,"
|
||||
s = uint64(a) & 0x3F7
|
||||
// ppc64x: -"MOVB", "ANDCC\t[$]247,"
|
||||
// ppc64x: -"MOVB", "ANDCC [$]247,"
|
||||
z = uint64(uint8(a)) & 0x3F7
|
||||
return
|
||||
}
|
||||
|
||||
// Verify zero-extended values are not sign-extended under a bit mask (#61297)
|
||||
func zeroextendAndMask8to64(a int8, b int16) (x, y uint64) {
|
||||
// ppc64x: -"MOVB\t", -"ANDCC", "MOVBZ"
|
||||
// ppc64x: -"MOVB ", -"ANDCC", "MOVBZ"
|
||||
x = uint64(a) & 0xFF
|
||||
// ppc64x: -"MOVH\t", -"ANDCC", "MOVHZ"
|
||||
// ppc64x: -"MOVH ", -"ANDCC", "MOVHZ"
|
||||
y = uint64(b) & 0xFFFF
|
||||
return
|
||||
}
|
||||
|
||||
// Verify rotate and mask instructions, and further simplified instructions for small types
|
||||
func bitRotateAndMask(io64 [8]uint64, io32 [4]uint32, io16 [4]uint16, io8 [4]uint8) {
|
||||
// ppc64x: "RLDICR\t[$]0, R[0-9]*, [$]47, R"
|
||||
// ppc64x: "RLDICR [$]0, R[0-9]*, [$]47, R"
|
||||
io64[0] = io64[0] & 0xFFFFFFFFFFFF0000
|
||||
// ppc64x: "RLDICL\t[$]0, R[0-9]*, [$]16, R"
|
||||
// ppc64x: "RLDICL [$]0, R[0-9]*, [$]16, R"
|
||||
io64[1] = io64[1] & 0x0000FFFFFFFFFFFF
|
||||
// ppc64x: -"SRD", -"AND", "RLDICL\t[$]60, R[0-9]*, [$]16, R"
|
||||
// ppc64x: -"SRD", -"AND", "RLDICL [$]60, R[0-9]*, [$]16, R"
|
||||
io64[2] = (io64[2] >> 4) & 0x0000FFFFFFFFFFFF
|
||||
// ppc64x: -"SRD", -"AND", "RLDICL\t[$]36, R[0-9]*, [$]28, R"
|
||||
// ppc64x: -"SRD", -"AND", "RLDICL [$]36, R[0-9]*, [$]28, R"
|
||||
io64[3] = (io64[3] >> 28) & 0x0000FFFFFFFFFFFF
|
||||
|
||||
// ppc64x: "MOVWZ", "RLWNM\t[$]1, R[0-9]*, [$]28, [$]3, R"
|
||||
// ppc64x: "MOVWZ", "RLWNM [$]1, R[0-9]*, [$]28, [$]3, R"
|
||||
io64[4] = uint64(bits.RotateLeft32(io32[0], 1) & 0xF000000F)
|
||||
|
||||
// ppc64x: "RLWNM\t[$]0, R[0-9]*, [$]4, [$]19, R"
|
||||
// ppc64x: "RLWNM [$]0, R[0-9]*, [$]4, [$]19, R"
|
||||
io32[0] = io32[0] & 0x0FFFF000
|
||||
// ppc64x: "RLWNM\t[$]0, R[0-9]*, [$]20, [$]3, R"
|
||||
// ppc64x: "RLWNM [$]0, R[0-9]*, [$]20, [$]3, R"
|
||||
io32[1] = io32[1] & 0xF0000FFF
|
||||
// ppc64x: -"RLWNM", MOVD, AND
|
||||
io32[2] = io32[2] & 0xFFFF0002
|
||||
|
||||
var bigc uint32 = 0x12345678
|
||||
// ppc64x: "ANDCC\t[$]22136"
|
||||
// ppc64x: "ANDCC [$]22136"
|
||||
io16[0] = io16[0] & uint16(bigc)
|
||||
|
||||
// ppc64x: "ANDCC\t[$]120"
|
||||
// ppc64x: "ANDCC [$]120"
|
||||
io8[0] = io8[0] & uint8(bigc)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -47,41 +47,41 @@ func blsr32(x int32) int32 {
|
|||
}
|
||||
|
||||
func isPowerOfTwo64(x int64) bool {
|
||||
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
|
||||
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
|
||||
return blsr64(x) == 0
|
||||
}
|
||||
|
||||
func isPowerOfTwo32(x int32) bool {
|
||||
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
|
||||
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
|
||||
return blsr32(x) == 0
|
||||
}
|
||||
|
||||
func isPowerOfTwoSelect64(x, a, b int64) int64 {
|
||||
var r int64
|
||||
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
|
||||
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
|
||||
if isPowerOfTwo64(x) {
|
||||
r = a
|
||||
} else {
|
||||
r = b
|
||||
}
|
||||
// amd64/v3:"CMOVQEQ",-"TESTQ",-"CALL"
|
||||
// amd64/v3:"CMOVQEQ" -"TESTQ" -"CALL"
|
||||
return r * 2 // force return blocks joining
|
||||
}
|
||||
|
||||
func isPowerOfTwoSelect32(x, a, b int32) int32 {
|
||||
var r int32
|
||||
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
|
||||
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
|
||||
if isPowerOfTwo32(x) {
|
||||
r = a
|
||||
} else {
|
||||
r = b
|
||||
}
|
||||
// amd64/v3:"CMOVLEQ",-"TESTL",-"CALL"
|
||||
// amd64/v3:"CMOVLEQ" -"TESTL" -"CALL"
|
||||
return r * 2 // force return blocks joining
|
||||
}
|
||||
|
||||
func isPowerOfTwoBranch64(x int64, a func(bool), b func(string)) {
|
||||
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
|
||||
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
|
||||
if isPowerOfTwo64(x) {
|
||||
a(true)
|
||||
} else {
|
||||
|
|
@ -90,7 +90,7 @@ func isPowerOfTwoBranch64(x int64, a func(bool), b func(string)) {
|
|||
}
|
||||
|
||||
func isPowerOfTwoBranch32(x int32, a func(bool), b func(string)) {
|
||||
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
|
||||
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
|
||||
if isPowerOfTwo32(x) {
|
||||
a(true)
|
||||
} else {
|
||||
|
|
@ -99,41 +99,41 @@ func isPowerOfTwoBranch32(x int32, a func(bool), b func(string)) {
|
|||
}
|
||||
|
||||
func isNotPowerOfTwo64(x int64) bool {
|
||||
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
|
||||
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
|
||||
return blsr64(x) != 0
|
||||
}
|
||||
|
||||
func isNotPowerOfTwo32(x int32) bool {
|
||||
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
|
||||
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
|
||||
return blsr32(x) != 0
|
||||
}
|
||||
|
||||
func isNotPowerOfTwoSelect64(x, a, b int64) int64 {
|
||||
var r int64
|
||||
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
|
||||
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
|
||||
if isNotPowerOfTwo64(x) {
|
||||
r = a
|
||||
} else {
|
||||
r = b
|
||||
}
|
||||
// amd64/v3:"CMOVQNE",-"TESTQ",-"CALL"
|
||||
// amd64/v3:"CMOVQNE" -"TESTQ" -"CALL"
|
||||
return r * 2 // force return blocks joining
|
||||
}
|
||||
|
||||
func isNotPowerOfTwoSelect32(x, a, b int32) int32 {
|
||||
var r int32
|
||||
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
|
||||
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
|
||||
if isNotPowerOfTwo32(x) {
|
||||
r = a
|
||||
} else {
|
||||
r = b
|
||||
}
|
||||
// amd64/v3:"CMOVLNE",-"TESTL",-"CALL"
|
||||
// amd64/v3:"CMOVLNE" -"TESTL" -"CALL"
|
||||
return r * 2 // force return blocks joining
|
||||
}
|
||||
|
||||
func isNotPowerOfTwoBranch64(x int64, a func(bool), b func(string)) {
|
||||
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
|
||||
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
|
||||
if isNotPowerOfTwo64(x) {
|
||||
a(true)
|
||||
} else {
|
||||
|
|
@ -142,7 +142,7 @@ func isNotPowerOfTwoBranch64(x int64, a func(bool), b func(string)) {
|
|||
}
|
||||
|
||||
func isNotPowerOfTwoBranch32(x int32, a func(bool), b func(string)) {
|
||||
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
|
||||
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
|
||||
if isNotPowerOfTwo32(x) {
|
||||
a(true)
|
||||
} else {
|
||||
|
|
@ -161,17 +161,17 @@ func sarx32(x, y int32) int32 {
|
|||
}
|
||||
|
||||
func sarx64_load(x []int64, i int) int64 {
|
||||
// amd64/v3: `SARXQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `SARXQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s := x[i] >> (i & 63)
|
||||
// amd64/v3: `SARXQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `SARXQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s = x[i+1] >> (s & 63)
|
||||
return s
|
||||
}
|
||||
|
||||
func sarx32_load(x []int32, i int) int32 {
|
||||
// amd64/v3: `SARXL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `SARXL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s := x[i] >> (i & 63)
|
||||
// amd64/v3: `SARXL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `SARXL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s = x[i+1] >> (s & 63)
|
||||
return s
|
||||
}
|
||||
|
|
@ -193,17 +193,17 @@ func shlrx32(x, y uint32) uint32 {
|
|||
}
|
||||
|
||||
func shlrx64_load(x []uint64, i int, s uint64) uint64 {
|
||||
// amd64/v3: `SHRXQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `SHRXQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s = x[i] >> i
|
||||
// amd64/v3: `SHLXQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `SHLXQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s = x[i+1] << s
|
||||
return s
|
||||
}
|
||||
|
||||
func shlrx32_load(x []uint32, i int, s uint32) uint32 {
|
||||
// amd64/v3: `SHRXL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `SHRXL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s = x[i] >> i
|
||||
// amd64/v3: `SHLXL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `SHLXL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s = x[i+1] << s
|
||||
return s
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,52 +13,52 @@ import (
|
|||
// This file contains codegen tests related to boolean simplifications/optimizations.
|
||||
|
||||
func convertNeq0B(x uint8, c bool) bool {
|
||||
// amd64:"ANDL\t[$]1",-"SETNE"
|
||||
// ppc64x:"RLDICL",-"CMPW",-"ISEL"
|
||||
// amd64:"ANDL [$]1" -"SETNE"
|
||||
// ppc64x:"RLDICL" -"CMPW" -"ISEL"
|
||||
b := x&1 != 0
|
||||
return c && b
|
||||
}
|
||||
|
||||
func convertNeq0W(x uint16, c bool) bool {
|
||||
// amd64:"ANDL\t[$]1",-"SETNE"
|
||||
// ppc64x:"RLDICL",-"CMPW",-"ISEL"
|
||||
// amd64:"ANDL [$]1" -"SETNE"
|
||||
// ppc64x:"RLDICL" -"CMPW" -"ISEL"
|
||||
b := x&1 != 0
|
||||
return c && b
|
||||
}
|
||||
|
||||
func convertNeq0L(x uint32, c bool) bool {
|
||||
// amd64:"ANDL\t[$]1",-"SETB"
|
||||
// ppc64x:"RLDICL",-"CMPW",-"ISEL"
|
||||
// amd64:"ANDL [$]1" -"SETB"
|
||||
// ppc64x:"RLDICL" -"CMPW" -"ISEL"
|
||||
b := x&1 != 0
|
||||
return c && b
|
||||
}
|
||||
|
||||
func convertNeq0Q(x uint64, c bool) bool {
|
||||
// amd64:"ANDL\t[$]1",-"SETB"
|
||||
// ppc64x:"RLDICL",-"CMP",-"ISEL"
|
||||
// amd64:"ANDL [$]1" -"SETB"
|
||||
// ppc64x:"RLDICL" -"CMP" -"ISEL"
|
||||
b := x&1 != 0
|
||||
return c && b
|
||||
}
|
||||
|
||||
func convertNeqBool32(x uint32) bool {
|
||||
// ppc64x:"RLDICL",-"CMPW",-"ISEL"
|
||||
// ppc64x:"RLDICL" -"CMPW" -"ISEL"
|
||||
return x&1 != 0
|
||||
}
|
||||
|
||||
func convertEqBool32(x uint32) bool {
|
||||
// ppc64x:"RLDICL",-"CMPW","XOR",-"ISEL"
|
||||
// amd64:"ANDL","XORL",-"BTL",-"SETCC"
|
||||
// ppc64x:"RLDICL" -"CMPW" "XOR" -"ISEL"
|
||||
// amd64:"ANDL" "XORL" -"BTL" -"SETCC"
|
||||
return x&1 == 0
|
||||
}
|
||||
|
||||
func convertNeqBool64(x uint64) bool {
|
||||
// ppc64x:"RLDICL",-"CMP",-"ISEL"
|
||||
// ppc64x:"RLDICL" -"CMP" -"ISEL"
|
||||
return x&1 != 0
|
||||
}
|
||||
|
||||
func convertEqBool64(x uint64) bool {
|
||||
// ppc64x:"RLDICL","XOR",-"CMP",-"ISEL"
|
||||
// amd64:"ANDL","XORL",-"BTL",-"SETCC"
|
||||
// ppc64x:"RLDICL" "XOR" -"CMP" -"ISEL"
|
||||
// amd64:"ANDL" "XORL" -"BTL" -"SETCC"
|
||||
return x&1 == 0
|
||||
}
|
||||
|
||||
|
|
@ -87,157 +87,157 @@ func phiOr(a, b bool) bool {
|
|||
}
|
||||
|
||||
func TestSetEq64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0EQ",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0EQ"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0EQ"
|
||||
// ppc64x/power10:"SETBC CR0EQ" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0EQ"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0EQ"
|
||||
b := x == y
|
||||
return b
|
||||
}
|
||||
func TestSetNeq64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0EQ"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0EQ"
|
||||
// ppc64x/power10:"SETBCR CR0EQ" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0EQ"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0EQ"
|
||||
b := x != y
|
||||
return b
|
||||
}
|
||||
func TestSetLt64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0GT",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0GT"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0GT"
|
||||
// ppc64x/power10:"SETBC CR0GT" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0GT"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0GT"
|
||||
b := x < y
|
||||
return b
|
||||
}
|
||||
func TestSetLe64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0LT"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0LT"
|
||||
// ppc64x/power10:"SETBCR CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0LT"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0LT"
|
||||
b := x <= y
|
||||
return b
|
||||
}
|
||||
func TestSetGt64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0LT"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0LT"
|
||||
b := x > y
|
||||
return b
|
||||
}
|
||||
func TestSetGe64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0GT",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0GT"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0GT"
|
||||
// ppc64x/power10:"SETBCR CR0GT" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0GT"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0GT"
|
||||
b := x >= y
|
||||
return b
|
||||
}
|
||||
func TestSetLtFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT"
|
||||
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT"
|
||||
b := x < y
|
||||
return b
|
||||
}
|
||||
func TestSetLeFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0LT","SETBC\tCR0EQ","OR",-"ISEL",-"ISEL"
|
||||
// ppc64x/power9:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR"
|
||||
// ppc64x/power8:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR"
|
||||
// ppc64x/power10:"SETBC CR0LT" "SETBC CR0EQ" "OR" -"ISEL" -"ISEL"
|
||||
// ppc64x/power9:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR"
|
||||
// ppc64x/power8:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR"
|
||||
b := x <= y
|
||||
return b
|
||||
}
|
||||
func TestSetGtFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT"
|
||||
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT"
|
||||
b := x > y
|
||||
return b
|
||||
}
|
||||
func TestSetGeFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0LT","SETBC\tCR0EQ","OR",-"ISEL",-"ISEL"
|
||||
// ppc64x/power9:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR"
|
||||
// ppc64x/power8:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR"
|
||||
// ppc64x/power10:"SETBC CR0LT" "SETBC CR0EQ" "OR" -"ISEL" -"ISEL"
|
||||
// ppc64x/power9:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR"
|
||||
// ppc64x/power8:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR"
|
||||
b := x >= y
|
||||
return b
|
||||
}
|
||||
func TestSetInvEq64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0EQ"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0EQ"
|
||||
// ppc64x/power10:"SETBCR CR0EQ" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0EQ"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0EQ"
|
||||
b := !(x == y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvNeq64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0EQ",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0EQ"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0EQ"
|
||||
// ppc64x/power10:"SETBC CR0EQ" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0EQ"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0EQ"
|
||||
b := !(x != y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvLt64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0GT",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0GT"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0GT"
|
||||
// ppc64x/power10:"SETBCR CR0GT" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0GT"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0GT"
|
||||
b := !(x < y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvLe64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0LT"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0LT"
|
||||
b := !(x <= y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvGt64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0LT"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0LT"
|
||||
// ppc64x/power10:"SETBCR CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0LT"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0LT"
|
||||
b := !(x > y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvGe64(x uint64, y uint64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0GT",-"ISEL"
|
||||
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0GT"
|
||||
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0GT"
|
||||
// ppc64x/power10:"SETBC CR0GT" -"ISEL"
|
||||
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0GT"
|
||||
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0GT"
|
||||
b := !(x >= y)
|
||||
return b
|
||||
}
|
||||
|
||||
func TestSetInvEqFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL"
|
||||
// ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0EQ"
|
||||
// ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0EQ"
|
||||
// ppc64x/power10:"SETBCR CR0EQ" -"ISEL"
|
||||
// ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0EQ"
|
||||
// ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0EQ"
|
||||
b := !(x == y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvNeqFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0EQ",-"ISEL"
|
||||
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0EQ"
|
||||
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0EQ"
|
||||
// ppc64x/power10:"SETBC CR0EQ" -"ISEL"
|
||||
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0EQ"
|
||||
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0EQ"
|
||||
b := !(x != y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvLtFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0LT"
|
||||
// ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0LT"
|
||||
// ppc64x/power10:"SETBCR CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0LT"
|
||||
// ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0LT"
|
||||
b := !(x < y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvLeFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT"
|
||||
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT"
|
||||
b := !(x <= y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvGtFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBCR\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0LT"
|
||||
// ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0LT"
|
||||
// ppc64x/power10:"SETBCR CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0LT"
|
||||
// ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0LT"
|
||||
b := !(x > y)
|
||||
return b
|
||||
}
|
||||
func TestSetInvGeFp64(x float64, y float64) bool {
|
||||
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
|
||||
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT"
|
||||
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
|
||||
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT"
|
||||
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT"
|
||||
b := !(x >= y)
|
||||
return b
|
||||
}
|
||||
|
|
@ -293,7 +293,7 @@ func TestLogicalCompareZero(x *[64]uint64) {
|
|||
x[12] = b
|
||||
}
|
||||
|
||||
// ppc64x:"ADDCCC\t[$]4,"
|
||||
// ppc64x:"ADDCCC [$]4,"
|
||||
c := int64(x[12]) + 4
|
||||
if c <= 0 {
|
||||
x[12] = uint64(c)
|
||||
|
|
@ -309,7 +309,7 @@ func TestLogicalCompareZero(x *[64]uint64) {
|
|||
|
||||
func constantWrite(b bool, p *bool) {
|
||||
if b {
|
||||
// amd64:`MOVB\t[$]1, \(`
|
||||
// amd64:`MOVB [$]1, \(`
|
||||
*p = b
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,16 +15,16 @@ var p1, p2, p3 T
|
|||
func F() {
|
||||
// 3735936685 is 0xdeaddead. On ARM64 R27 is REGTMP.
|
||||
// clobber x, y at entry. not clobber z (stack object).
|
||||
// amd64:`MOVL\t\$3735936685, command-line-arguments\.x`, `MOVL\t\$3735936685, command-line-arguments\.y`, -`MOVL\t\$3735936685, command-line-arguments\.z`
|
||||
// arm64:`MOVW\tR27, command-line-arguments\.x`, `MOVW\tR27, command-line-arguments\.y`, -`MOVW\tR27, command-line-arguments\.z`
|
||||
// amd64:`MOVL \$3735936685, command-line-arguments\.x`, `MOVL \$3735936685, command-line-arguments\.y`, -`MOVL \$3735936685, command-line-arguments\.z`
|
||||
// arm64:`MOVW R27, command-line-arguments\.x`, `MOVW R27, command-line-arguments\.y`, -`MOVW R27, command-line-arguments\.z`
|
||||
x, y, z := p1, p2, p3
|
||||
addrTaken(&z)
|
||||
// x is dead at the call (the value of x is loaded before the CALL), y is not
|
||||
// amd64:`MOVL\t\$3735936685, command-line-arguments\.x`, -`MOVL\t\$3735936685, command-line-arguments\.y`
|
||||
// arm64:`MOVW\tR27, command-line-arguments\.x`, -`MOVW\tR27, command-line-arguments\.y`
|
||||
// amd64:`MOVL \$3735936685, command-line-arguments\.x`, -`MOVL \$3735936685, command-line-arguments\.y`
|
||||
// arm64:`MOVW R27, command-line-arguments\.x`, -`MOVW R27, command-line-arguments\.y`
|
||||
use(x)
|
||||
// amd64:`MOVL\t\$3735936685, command-line-arguments\.x`, `MOVL\t\$3735936685, command-line-arguments\.y`
|
||||
// arm64:`MOVW\tR27, command-line-arguments\.x`, `MOVW\tR27, command-line-arguments\.y`
|
||||
// amd64:`MOVL \$3735936685, command-line-arguments\.x`, `MOVL \$3735936685, command-line-arguments\.y`
|
||||
// arm64:`MOVW R27, command-line-arguments\.x`, `MOVW R27, command-line-arguments\.y`
|
||||
use(y)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -14,14 +14,14 @@ type S struct {
|
|||
|
||||
func F(a, b, c int, d S) {
|
||||
// -2401018187971961171 is 0xdeaddeaddeaddead
|
||||
// amd64:`MOVQ\t\$-2401018187971961171, AX`, `MOVQ\t\$-2401018187971961171, BX`, `MOVQ\t\$-2401018187971961171, CX`
|
||||
// amd64:`MOVQ\t\$-2401018187971961171, DX`, `MOVQ\t\$-2401018187971961171, SI`, `MOVQ\t\$-2401018187971961171, DI`
|
||||
// amd64:`MOVQ\t\$-2401018187971961171, R8`, `MOVQ\t\$-2401018187971961171, R9`, `MOVQ\t\$-2401018187971961171, R10`
|
||||
// amd64:`MOVQ\t\$-2401018187971961171, R11`, `MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`
|
||||
// amd64:-`MOVQ\t\$-2401018187971961171, BP` // frame pointer is not clobbered
|
||||
// amd64:`MOVQ \$-2401018187971961171, AX`, `MOVQ \$-2401018187971961171, BX`, `MOVQ \$-2401018187971961171, CX`
|
||||
// amd64:`MOVQ \$-2401018187971961171, DX`, `MOVQ \$-2401018187971961171, SI`, `MOVQ \$-2401018187971961171, DI`
|
||||
// amd64:`MOVQ \$-2401018187971961171, R8`, `MOVQ \$-2401018187971961171, R9`, `MOVQ \$-2401018187971961171, R10`
|
||||
// amd64:`MOVQ \$-2401018187971961171, R11`, `MOVQ \$-2401018187971961171, R12`, `MOVQ \$-2401018187971961171, R13`
|
||||
// amd64:-`MOVQ \$-2401018187971961171, BP` // frame pointer is not clobbered
|
||||
StackArgsCall([10]int{a, b, c})
|
||||
// amd64:`MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`, `MOVQ\t\$-2401018187971961171, DX`
|
||||
// amd64:-`MOVQ\t\$-2401018187971961171, AX`, -`MOVQ\t\$-2401018187971961171, R11` // register args are not clobbered
|
||||
// amd64:`MOVQ \$-2401018187971961171, R12`, `MOVQ \$-2401018187971961171, R13`, `MOVQ \$-2401018187971961171, DX`
|
||||
// amd64:-`MOVQ \$-2401018187971961171, AX`, -`MOVQ \$-2401018187971961171, R11` // register args are not clobbered
|
||||
RegArgsCall(a, b, c, d)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -11,12 +11,12 @@ func dummy() {}
|
|||
|
||||
// Signed 64-bit compare-and-branch.
|
||||
func si64(x, y chan int64) {
|
||||
// s390x:"CGRJ\t[$](2|4), R[0-9]+, R[0-9]+, "
|
||||
// s390x:"CGRJ [$](2|4), R[0-9]+, R[0-9]+, "
|
||||
for <-x < <-y {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CL?GRJ\t[$]8, R[0-9]+, R[0-9]+, "
|
||||
// s390x:"CL?GRJ [$]8, R[0-9]+, R[0-9]+, "
|
||||
for <-x == <-y {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -25,22 +25,22 @@ func si64(x, y chan int64) {
|
|||
// Signed 64-bit compare-and-branch with 8-bit immediate.
|
||||
func si64x8(doNotOptimize int64) {
|
||||
// take in doNotOptimize as an argument to avoid the loops being rewritten to count down
|
||||
// s390x:"CGIJ\t[$]12, R[0-9]+, [$]127, "
|
||||
// s390x:"CGIJ [$]12, R[0-9]+, [$]127, "
|
||||
for i := doNotOptimize; i < 128; i++ {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CGIJ\t[$]10, R[0-9]+, [$]-128, "
|
||||
// s390x:"CGIJ [$]10, R[0-9]+, [$]-128, "
|
||||
for i := doNotOptimize; i > -129; i-- {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CGIJ\t[$]2, R[0-9]+, [$]127, "
|
||||
// s390x:"CGIJ [$]2, R[0-9]+, [$]127, "
|
||||
for i := doNotOptimize; i >= 128; i++ {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CGIJ\t[$]4, R[0-9]+, [$]-128, "
|
||||
// s390x:"CGIJ [$]4, R[0-9]+, [$]-128, "
|
||||
for i := doNotOptimize; i <= -129; i-- {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -48,12 +48,12 @@ func si64x8(doNotOptimize int64) {
|
|||
|
||||
// Unsigned 64-bit compare-and-branch.
|
||||
func ui64(x, y chan uint64) {
|
||||
// s390x:"CLGRJ\t[$](2|4), R[0-9]+, R[0-9]+, "
|
||||
// s390x:"CLGRJ [$](2|4), R[0-9]+, R[0-9]+, "
|
||||
for <-x > <-y {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CL?GRJ\t[$]6, R[0-9]+, R[0-9]+, "
|
||||
// s390x:"CL?GRJ [$]6, R[0-9]+, R[0-9]+, "
|
||||
for <-x != <-y {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -61,22 +61,22 @@ func ui64(x, y chan uint64) {
|
|||
|
||||
// Unsigned 64-bit comparison with 8-bit immediate.
|
||||
func ui64x8() {
|
||||
// s390x:"CLGIJ\t[$]4, R[0-9]+, [$]128, "
|
||||
// s390x:"CLGIJ [$]4, R[0-9]+, [$]128, "
|
||||
for i := uint64(0); i < 128; i++ {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CLGIJ\t[$]12, R[0-9]+, [$]255, "
|
||||
// s390x:"CLGIJ [$]12, R[0-9]+, [$]255, "
|
||||
for i := uint64(0); i < 256; i++ {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CLGIJ\t[$]2, R[0-9]+, [$]255, "
|
||||
// s390x:"CLGIJ [$]2, R[0-9]+, [$]255, "
|
||||
for i := uint64(257); i >= 256; i-- {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CLGIJ\t[$]2, R[0-9]+, [$]0, "
|
||||
// s390x:"CLGIJ [$]2, R[0-9]+, [$]0, "
|
||||
for i := uint64(1024); i > 0; i-- {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -84,12 +84,12 @@ func ui64x8() {
|
|||
|
||||
// Signed 32-bit compare-and-branch.
|
||||
func si32(x, y chan int32) {
|
||||
// s390x:"CRJ\t[$](2|4), R[0-9]+, R[0-9]+, "
|
||||
// s390x:"CRJ [$](2|4), R[0-9]+, R[0-9]+, "
|
||||
for <-x < <-y {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CL?RJ\t[$]8, R[0-9]+, R[0-9]+, "
|
||||
// s390x:"CL?RJ [$]8, R[0-9]+, R[0-9]+, "
|
||||
for <-x == <-y {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -98,22 +98,22 @@ func si32(x, y chan int32) {
|
|||
// Signed 32-bit compare-and-branch with 8-bit immediate.
|
||||
func si32x8(doNotOptimize int32) {
|
||||
// take in doNotOptimize as an argument to avoid the loops being rewritten to count down
|
||||
// s390x:"CIJ\t[$]12, R[0-9]+, [$]127, "
|
||||
// s390x:"CIJ [$]12, R[0-9]+, [$]127, "
|
||||
for i := doNotOptimize; i < 128; i++ {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CIJ\t[$]10, R[0-9]+, [$]-128, "
|
||||
// s390x:"CIJ [$]10, R[0-9]+, [$]-128, "
|
||||
for i := doNotOptimize; i > -129; i-- {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CIJ\t[$]2, R[0-9]+, [$]127, "
|
||||
// s390x:"CIJ [$]2, R[0-9]+, [$]127, "
|
||||
for i := doNotOptimize; i >= 128; i++ {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CIJ\t[$]4, R[0-9]+, [$]-128, "
|
||||
// s390x:"CIJ [$]4, R[0-9]+, [$]-128, "
|
||||
for i := doNotOptimize; i <= -129; i-- {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -121,12 +121,12 @@ func si32x8(doNotOptimize int32) {
|
|||
|
||||
// Unsigned 32-bit compare-and-branch.
|
||||
func ui32(x, y chan uint32) {
|
||||
// s390x:"CLRJ\t[$](2|4), R[0-9]+, R[0-9]+, "
|
||||
// s390x:"CLRJ [$](2|4), R[0-9]+, R[0-9]+, "
|
||||
for <-x > <-y {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CL?RJ\t[$]6, R[0-9]+, R[0-9]+, "
|
||||
// s390x:"CL?RJ [$]6, R[0-9]+, R[0-9]+, "
|
||||
for <-x != <-y {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -134,22 +134,22 @@ func ui32(x, y chan uint32) {
|
|||
|
||||
// Unsigned 32-bit comparison with 8-bit immediate.
|
||||
func ui32x8() {
|
||||
// s390x:"CLIJ\t[$]4, R[0-9]+, [$]128, "
|
||||
// s390x:"CLIJ [$]4, R[0-9]+, [$]128, "
|
||||
for i := uint32(0); i < 128; i++ {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255, "
|
||||
// s390x:"CLIJ [$]12, R[0-9]+, [$]255, "
|
||||
for i := uint32(0); i < 256; i++ {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]255, "
|
||||
// s390x:"CLIJ [$]2, R[0-9]+, [$]255, "
|
||||
for i := uint32(257); i >= 256; i-- {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]0, "
|
||||
// s390x:"CLIJ [$]2, R[0-9]+, [$]0, "
|
||||
for i := uint32(1024); i > 0; i-- {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -157,12 +157,12 @@ func ui32x8() {
|
|||
|
||||
// Signed 64-bit comparison with unsigned 8-bit immediate.
|
||||
func si64xu8(x chan int64) {
|
||||
// s390x:"CLGIJ\t[$]8, R[0-9]+, [$]128, "
|
||||
// s390x:"CLGIJ [$]8, R[0-9]+, [$]128, "
|
||||
for <-x == 128 {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CLGIJ\t[$]6, R[0-9]+, [$]255, "
|
||||
// s390x:"CLGIJ [$]6, R[0-9]+, [$]255, "
|
||||
for <-x != 255 {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -170,12 +170,12 @@ func si64xu8(x chan int64) {
|
|||
|
||||
// Signed 32-bit comparison with unsigned 8-bit immediate.
|
||||
func si32xu8(x chan int32) {
|
||||
// s390x:"CLIJ\t[$]8, R[0-9]+, [$]255, "
|
||||
// s390x:"CLIJ [$]8, R[0-9]+, [$]255, "
|
||||
for <-x == 255 {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CLIJ\t[$]6, R[0-9]+, [$]128, "
|
||||
// s390x:"CLIJ [$]6, R[0-9]+, [$]128, "
|
||||
for <-x != 128 {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -183,12 +183,12 @@ func si32xu8(x chan int32) {
|
|||
|
||||
// Unsigned 64-bit comparison with signed 8-bit immediate.
|
||||
func ui64xu8(x chan uint64) {
|
||||
// s390x:"CGIJ\t[$]8, R[0-9]+, [$]-1, "
|
||||
// s390x:"CGIJ [$]8, R[0-9]+, [$]-1, "
|
||||
for <-x == ^uint64(0) {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CGIJ\t[$]6, R[0-9]+, [$]-128, "
|
||||
// s390x:"CGIJ [$]6, R[0-9]+, [$]-128, "
|
||||
for <-x != ^uint64(127) {
|
||||
dummy()
|
||||
}
|
||||
|
|
@ -196,12 +196,12 @@ func ui64xu8(x chan uint64) {
|
|||
|
||||
// Unsigned 32-bit comparison with signed 8-bit immediate.
|
||||
func ui32xu8(x chan uint32) {
|
||||
// s390x:"CIJ\t[$]8, R[0-9]+, [$]-128, "
|
||||
// s390x:"CIJ [$]8, R[0-9]+, [$]-128, "
|
||||
for <-x == ^uint32(127) {
|
||||
dummy()
|
||||
}
|
||||
|
||||
// s390x:"CIJ\t[$]6, R[0-9]+, [$]-1, "
|
||||
// s390x:"CIJ [$]6, R[0-9]+, [$]-1, "
|
||||
for <-x != ^uint32(0) {
|
||||
dummy()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,68 +21,68 @@ import (
|
|||
// Check that compare to constant string use 2/4/8 byte compares
|
||||
|
||||
func CompareString1(s string) bool {
|
||||
// amd64:`CMPW\t\(.*\), [$]`
|
||||
// arm64:`MOVHU\t\(.*\), [R]`,`MOVD\t[$]`,`CMPW\tR`
|
||||
// ppc64le:`MOVHZ\t\(.*\), [R]`,`CMPW\t.*, [$]`
|
||||
// s390x:`MOVHBR\t\(.*\), [R]`,`CMPW\t.*, [$]`
|
||||
// amd64:`CMPW \(.*\), [$]`
|
||||
// arm64:`MOVHU \(.*\), [R]`,`MOVD [$]`,`CMPW R`
|
||||
// ppc64le:`MOVHZ \(.*\), [R]`,`CMPW .*, [$]`
|
||||
// s390x:`MOVHBR \(.*\), [R]`,`CMPW .*, [$]`
|
||||
return s == "xx"
|
||||
}
|
||||
|
||||
func CompareString2(s string) bool {
|
||||
// amd64:`CMPL\t\(.*\), [$]`
|
||||
// arm64:`MOVWU\t\(.*\), [R]`,`CMPW\t.*, [R]`
|
||||
// ppc64le:`MOVWZ\t\(.*\), [R]`,`CMPW\t.*, [R]`
|
||||
// s390x:`MOVWBR\t\(.*\), [R]`,`CMPW\t.*, [$]`
|
||||
// amd64:`CMPL \(.*\), [$]`
|
||||
// arm64:`MOVWU \(.*\), [R]`,`CMPW .*, [R]`
|
||||
// ppc64le:`MOVWZ \(.*\), [R]`,`CMPW .*, [R]`
|
||||
// s390x:`MOVWBR \(.*\), [R]`,`CMPW .*, [$]`
|
||||
return s == "xxxx"
|
||||
}
|
||||
|
||||
func CompareString3(s string) bool {
|
||||
// amd64:`CMPQ\t\(.*\), [A-Z]`
|
||||
// arm64:-`CMPW\t`
|
||||
// ppc64x:-`CMPW\t`
|
||||
// s390x:-`CMPW\t`
|
||||
// amd64:`CMPQ \(.*\), [A-Z]`
|
||||
// arm64:-`CMPW `
|
||||
// ppc64x:-`CMPW `
|
||||
// s390x:-`CMPW `
|
||||
return s == "xxxxxxxx"
|
||||
}
|
||||
|
||||
// Check that arrays compare use 2/4/8 byte compares
|
||||
|
||||
func CompareArray1(a, b [2]byte) bool {
|
||||
// amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// arm64:-`MOVBU\t`
|
||||
// ppc64le:-`MOVBZ\t`
|
||||
// s390x:-`MOVBZ\t`
|
||||
// amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// arm64:-`MOVBU `
|
||||
// ppc64le:-`MOVBZ `
|
||||
// s390x:-`MOVBZ `
|
||||
return a == b
|
||||
}
|
||||
|
||||
func CompareArray2(a, b [3]uint16) bool {
|
||||
// amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
return a == b
|
||||
}
|
||||
|
||||
func CompareArray3(a, b [3]int16) bool {
|
||||
// amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
return a == b
|
||||
}
|
||||
|
||||
func CompareArray4(a, b [12]int8) bool {
|
||||
// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
return a == b
|
||||
}
|
||||
|
||||
func CompareArray5(a, b [15]byte) bool {
|
||||
// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
return a == b
|
||||
}
|
||||
|
||||
// This was a TODO in mapaccess1_faststr
|
||||
func CompareArray6(a, b unsafe.Pointer) bool {
|
||||
// amd64:`CMPL\t\(.*\), [A-Z]`
|
||||
// arm64:`MOVWU\t\(.*\), [R]`,`CMPW\t.*, [R]`
|
||||
// ppc64le:`MOVWZ\t\(.*\), [R]`,`CMPW\t.*, [R]`
|
||||
// s390x:`MOVWBR\t\(.*\), [R]`,`CMPW\t.*, [R]`
|
||||
// amd64:`CMPL \(.*\), [A-Z]`
|
||||
// arm64:`MOVWU \(.*\), [R]`,`CMPW .*, [R]`
|
||||
// ppc64le:`MOVWZ \(.*\), [R]`,`CMPW .*, [R]`
|
||||
// s390x:`MOVWBR \(.*\), [R]`,`CMPW .*, [R]`
|
||||
return *((*[4]byte)(a)) != *((*[4]byte)(b))
|
||||
}
|
||||
|
||||
|
|
@ -93,7 +93,7 @@ type T1 struct {
|
|||
}
|
||||
|
||||
func CompareStruct1(s1, s2 T1) bool {
|
||||
// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:-`CALL`
|
||||
return s1 == s2
|
||||
}
|
||||
|
|
@ -103,7 +103,7 @@ type T2 struct {
|
|||
}
|
||||
|
||||
func CompareStruct2(s1, s2 T2) bool {
|
||||
// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:-`CALL`
|
||||
return s1 == s2
|
||||
}
|
||||
|
|
@ -116,7 +116,7 @@ type T3 struct {
|
|||
}
|
||||
|
||||
func CompareStruct3(s1, s2 T3) bool {
|
||||
// amd64:-`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:-`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CALL`
|
||||
return s1 == s2
|
||||
}
|
||||
|
|
@ -126,7 +126,7 @@ type T4 struct {
|
|||
}
|
||||
|
||||
func CompareStruct4(s1, s2 T4) bool {
|
||||
// amd64:-`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:-`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
|
||||
// amd64:`CALL`
|
||||
return s1 == s2
|
||||
}
|
||||
|
|
@ -140,7 +140,7 @@ func CompareStruct4(s1, s2 T4) bool {
|
|||
var r bool
|
||||
|
||||
func CmpFold(x uint32) {
|
||||
// amd64:`SETHI\t.*\(SB\)`
|
||||
// amd64:`SETHI .*\(SB\)`
|
||||
r = x > 4
|
||||
}
|
||||
|
||||
|
|
@ -148,27 +148,27 @@ func CmpFold(x uint32) {
|
|||
// possible
|
||||
|
||||
func CmpMem1(p int, q *int) bool {
|
||||
// amd64:`CMPQ\t\(.*\), [A-Z]`
|
||||
// amd64:`CMPQ \(.*\), [A-Z]`
|
||||
return p < *q
|
||||
}
|
||||
|
||||
func CmpMem2(p *int, q int) bool {
|
||||
// amd64:`CMPQ\t\(.*\), [A-Z]`
|
||||
// amd64:`CMPQ \(.*\), [A-Z]`
|
||||
return *p < q
|
||||
}
|
||||
|
||||
func CmpMem3(p *int) bool {
|
||||
// amd64:`CMPQ\t\(.*\), [$]7`
|
||||
// amd64:`CMPQ \(.*\), [$]7`
|
||||
return *p < 7
|
||||
}
|
||||
|
||||
func CmpMem4(p *int) bool {
|
||||
// amd64:`CMPQ\t\(.*\), [$]7`
|
||||
// amd64:`CMPQ \(.*\), [$]7`
|
||||
return 7 < *p
|
||||
}
|
||||
|
||||
func CmpMem5(p **int) {
|
||||
// amd64:`CMPL\truntime.writeBarrier\(SB\), [$]0`
|
||||
// amd64:`CMPL runtime.writeBarrier\(SB\), [$]0`
|
||||
*p = nil
|
||||
}
|
||||
|
||||
|
|
@ -270,31 +270,31 @@ func CmpToZero(a, b, d int32, e, f int64, deOptC0, deOptC1 bool) int32 {
|
|||
|
||||
func CmpLogicalToZero(a, b, c uint32, d, e, f, g uint64) uint64 {
|
||||
|
||||
// ppc64x:"ANDCC",-"CMPW"
|
||||
// wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
|
||||
// ppc64x:"ANDCC" -"CMPW"
|
||||
// wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
|
||||
if a&63 == 0 {
|
||||
return 1
|
||||
}
|
||||
|
||||
// ppc64x:"ANDCC",-"CMP"
|
||||
// wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
|
||||
// ppc64x:"ANDCC" -"CMP"
|
||||
// wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
|
||||
if d&255 == 0 {
|
||||
return 1
|
||||
}
|
||||
|
||||
// ppc64x:"ANDCC",-"CMP"
|
||||
// wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
|
||||
// ppc64x:"ANDCC" -"CMP"
|
||||
// wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
|
||||
if d&e == 0 {
|
||||
return 1
|
||||
}
|
||||
// ppc64x:"ORCC",-"CMP"
|
||||
// wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
|
||||
// ppc64x:"ORCC" -"CMP"
|
||||
// wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
|
||||
if f|g == 0 {
|
||||
return 1
|
||||
}
|
||||
|
||||
// ppc64x:"XORCC",-"CMP"
|
||||
// wasm:"I64Eqz","I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
|
||||
// ppc64x:"XORCC" -"CMP"
|
||||
// wasm:"I64Eqz" "I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
|
||||
if e^d == 0 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -711,19 +711,19 @@ func cmpToCmn(a, b, c, d int) int {
|
|||
|
||||
func cmpToCmnLessThan(a, b, c, d int) int {
|
||||
var c1, c2, c3, c4 int
|
||||
// arm64:`CMN`,`CSET\tMI`,-`CMP`
|
||||
// arm64:`CMN`,`CSET MI`,-`CMP`
|
||||
if a+1 < 0 {
|
||||
c1 = 1
|
||||
}
|
||||
// arm64:`CMN`,`CSET\tMI`,-`CMP`
|
||||
// arm64:`CMN`,`CSET MI`,-`CMP`
|
||||
if a+b < 0 {
|
||||
c2 = 1
|
||||
}
|
||||
// arm64:`CMN`,`CSET\tMI`,-`CMP`
|
||||
// arm64:`CMN`,`CSET MI`,-`CMP`
|
||||
if a*b+c < 0 {
|
||||
c3 = 1
|
||||
}
|
||||
// arm64:`CMP`,`CSET\tMI`,-`CMN`
|
||||
// arm64:`CMP`,`CSET MI`,-`CMN`
|
||||
if a-b*c < 0 {
|
||||
c4 = 1
|
||||
}
|
||||
|
|
@ -780,19 +780,19 @@ func ge128Signed64(x int64) bool {
|
|||
|
||||
func cmpToCmnGreaterThanEqual(a, b, c, d int) int {
|
||||
var c1, c2, c3, c4 int
|
||||
// arm64:`CMN`,`CSET\tPL`,-`CMP`
|
||||
// arm64:`CMN`,`CSET PL`,-`CMP`
|
||||
if a+1 >= 0 {
|
||||
c1 = 1
|
||||
}
|
||||
// arm64:`CMN`,`CSET\tPL`,-`CMP`
|
||||
// arm64:`CMN`,`CSET PL`,-`CMP`
|
||||
if a+b >= 0 {
|
||||
c2 = 1
|
||||
}
|
||||
// arm64:`CMN`,`CSET\tPL`,-`CMP`
|
||||
// arm64:`CMN`,`CSET PL`,-`CMP`
|
||||
if a*b+c >= 0 {
|
||||
c3 = 1
|
||||
}
|
||||
// arm64:`CMP`,`CSET\tPL`,-`CMN`
|
||||
// arm64:`CMP`,`CSET PL`,-`CMN`
|
||||
if a-b*c >= 0 {
|
||||
c4 = 1
|
||||
}
|
||||
|
|
@ -870,6 +870,6 @@ func cmpstring2(x, y string) int {
|
|||
// like in cmpstring1 will not work. Instead, we
|
||||
// look for spill/restore instructions, which only
|
||||
// need to exist if there are 2 calls.
|
||||
//amd64:-`MOVQ\t.*\(SP\)`
|
||||
//amd64:-`MOVQ .*\(SP\)`
|
||||
return cmp.Compare(x, y)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@ func cmovint(c int) int {
|
|||
x = 182
|
||||
}
|
||||
// amd64:"CMOVQLT"
|
||||
// arm64:"CSEL\tLT"
|
||||
// ppc64x:"ISEL\t[$]0"
|
||||
// arm64:"CSEL LT"
|
||||
// ppc64x:"ISEL [$]0"
|
||||
// wasm:"Select"
|
||||
return x
|
||||
}
|
||||
|
|
@ -23,8 +23,8 @@ func cmovchan(x, y chan int) chan int {
|
|||
x = y
|
||||
}
|
||||
// amd64:"CMOVQNE"
|
||||
// arm64:"CSEL\tNE"
|
||||
// ppc64x:"ISEL\t[$]2"
|
||||
// arm64:"CSEL NE"
|
||||
// ppc64x:"ISEL [$]2"
|
||||
// wasm:"Select"
|
||||
return x
|
||||
}
|
||||
|
|
@ -34,8 +34,8 @@ func cmovuintptr(x, y uintptr) uintptr {
|
|||
x = -y
|
||||
}
|
||||
// amd64:"CMOVQ(HI|CS)"
|
||||
// arm64:"CSNEG\tLS"
|
||||
// ppc64x:"ISEL\t[$]1"
|
||||
// arm64:"CSNEG LS"
|
||||
// ppc64x:"ISEL [$]1"
|
||||
// wasm:"Select"
|
||||
return x
|
||||
}
|
||||
|
|
@ -45,8 +45,8 @@ func cmov32bit(x, y uint32) uint32 {
|
|||
x = -y
|
||||
}
|
||||
// amd64:"CMOVL(HI|CS)"
|
||||
// arm64:"CSNEG\t(LS|HS)"
|
||||
// ppc64x:"ISEL\t[$]1"
|
||||
// arm64:"CSNEG (LS|HS)"
|
||||
// ppc64x:"ISEL [$]1"
|
||||
// wasm:"Select"
|
||||
return x
|
||||
}
|
||||
|
|
@ -56,8 +56,8 @@ func cmov16bit(x, y uint16) uint16 {
|
|||
x = -y
|
||||
}
|
||||
// amd64:"CMOVW(HI|CS)"
|
||||
// arm64:"CSNEG\t(LS|HS)"
|
||||
// ppc64x:"ISEL\t[$][01]"
|
||||
// arm64:"CSNEG (LS|HS)"
|
||||
// ppc64x:"ISEL [$][01]"
|
||||
// wasm:"Select"
|
||||
return x
|
||||
}
|
||||
|
|
@ -69,9 +69,9 @@ func cmovfloateq(x, y float64) int {
|
|||
if x == y {
|
||||
a = 256
|
||||
}
|
||||
// amd64:"CMOVQNE","CMOVQPC"
|
||||
// arm64:"CSEL\tEQ"
|
||||
// ppc64x:"ISEL\t[$]2"
|
||||
// amd64:"CMOVQNE" "CMOVQPC"
|
||||
// arm64:"CSEL EQ"
|
||||
// ppc64x:"ISEL [$]2"
|
||||
// wasm:"Select"
|
||||
return a
|
||||
}
|
||||
|
|
@ -81,9 +81,9 @@ func cmovfloatne(x, y float64) int {
|
|||
if x != y {
|
||||
a = 256
|
||||
}
|
||||
// amd64:"CMOVQNE","CMOVQPS"
|
||||
// arm64:"CSEL\tNE"
|
||||
// ppc64x:"ISEL\t[$]2"
|
||||
// amd64:"CMOVQNE" "CMOVQPS"
|
||||
// arm64:"CSEL NE"
|
||||
// ppc64x:"ISEL [$]2"
|
||||
// wasm:"Select"
|
||||
return a
|
||||
}
|
||||
|
|
@ -109,8 +109,8 @@ func cmovfloatint2(x, y float64) float64 {
|
|||
rexp = rexp - 42
|
||||
}
|
||||
// amd64:"CMOVQHI"
|
||||
// arm64:"CSEL\tMI"
|
||||
// ppc64x:"ISEL\t[$]0"
|
||||
// arm64:"CSEL MI"
|
||||
// ppc64x:"ISEL [$]0"
|
||||
// wasm:"Select"
|
||||
r = r - ldexp(y, rexp-yexp)
|
||||
}
|
||||
|
|
@ -124,8 +124,8 @@ func cmovloaded(x [4]int, y int) int {
|
|||
y = y >> 2
|
||||
}
|
||||
// amd64:"CMOVQNE"
|
||||
// arm64:"CSEL\tNE"
|
||||
// ppc64x:"ISEL\t[$]2"
|
||||
// arm64:"CSEL NE"
|
||||
// ppc64x:"ISEL [$]2"
|
||||
// wasm:"Select"
|
||||
return y
|
||||
}
|
||||
|
|
@ -136,8 +136,8 @@ func cmovuintptr2(x, y uintptr) uintptr {
|
|||
a = 256
|
||||
}
|
||||
// amd64:"CMOVQEQ"
|
||||
// arm64:"CSEL\tEQ"
|
||||
// ppc64x:"ISEL\t[$]2"
|
||||
// arm64:"CSEL EQ"
|
||||
// ppc64x:"ISEL [$]2"
|
||||
// wasm:"Select"
|
||||
return a
|
||||
}
|
||||
|
|
@ -230,7 +230,7 @@ func cmovinc(cond bool, a, b, c int) {
|
|||
} else {
|
||||
x0 = b + 1
|
||||
}
|
||||
// arm64:"CSINC\tNE", -"CSEL"
|
||||
// arm64:"CSINC NE", -"CSEL"
|
||||
r0 = x0
|
||||
|
||||
if cond {
|
||||
|
|
@ -238,13 +238,13 @@ func cmovinc(cond bool, a, b, c int) {
|
|||
} else {
|
||||
x1 = a
|
||||
}
|
||||
// arm64:"CSINC\tEQ", -"CSEL"
|
||||
// arm64:"CSINC EQ", -"CSEL"
|
||||
r1 = x1
|
||||
|
||||
if cond {
|
||||
c++
|
||||
}
|
||||
// arm64:"CSINC\tEQ", -"CSEL"
|
||||
// arm64:"CSINC EQ", -"CSEL"
|
||||
r2 = c
|
||||
}
|
||||
|
||||
|
|
@ -256,7 +256,7 @@ func cmovinv(cond bool, a, b int) {
|
|||
} else {
|
||||
x0 = ^b
|
||||
}
|
||||
// arm64:"CSINV\tNE", -"CSEL"
|
||||
// arm64:"CSINV NE", -"CSEL"
|
||||
r0 = x0
|
||||
|
||||
if cond {
|
||||
|
|
@ -264,7 +264,7 @@ func cmovinv(cond bool, a, b int) {
|
|||
} else {
|
||||
x1 = a
|
||||
}
|
||||
// arm64:"CSINV\tEQ", -"CSEL"
|
||||
// arm64:"CSINV EQ", -"CSEL"
|
||||
r1 = x1
|
||||
}
|
||||
|
||||
|
|
@ -276,7 +276,7 @@ func cmovneg(cond bool, a, b, c int) {
|
|||
} else {
|
||||
x0 = -b
|
||||
}
|
||||
// arm64:"CSNEG\tNE", -"CSEL"
|
||||
// arm64:"CSNEG NE", -"CSEL"
|
||||
r0 = x0
|
||||
|
||||
if cond {
|
||||
|
|
@ -284,7 +284,7 @@ func cmovneg(cond bool, a, b, c int) {
|
|||
} else {
|
||||
x1 = a
|
||||
}
|
||||
// arm64:"CSNEG\tEQ", -"CSEL"
|
||||
// arm64:"CSNEG EQ", -"CSEL"
|
||||
r1 = x1
|
||||
}
|
||||
|
||||
|
|
@ -296,7 +296,7 @@ func cmovsetm(cond bool, x int) {
|
|||
} else {
|
||||
x0 = 0
|
||||
}
|
||||
// arm64:"CSETM\tNE", -"CSEL"
|
||||
// arm64:"CSETM NE", -"CSEL"
|
||||
r0 = x0
|
||||
|
||||
if cond {
|
||||
|
|
@ -304,7 +304,7 @@ func cmovsetm(cond bool, x int) {
|
|||
} else {
|
||||
x1 = -1
|
||||
}
|
||||
// arm64:"CSETM\tEQ", -"CSEL"
|
||||
// arm64:"CSETM EQ", -"CSEL"
|
||||
r1 = x1
|
||||
}
|
||||
|
||||
|
|
@ -316,7 +316,7 @@ func cmovFcmp0(s, t float64, a, b int) {
|
|||
} else {
|
||||
x0 = b + 1
|
||||
}
|
||||
// arm64:"CSINC\tMI", -"CSEL"
|
||||
// arm64:"CSINC MI", -"CSEL"
|
||||
r0 = x0
|
||||
|
||||
if s <= t {
|
||||
|
|
@ -324,7 +324,7 @@ func cmovFcmp0(s, t float64, a, b int) {
|
|||
} else {
|
||||
x1 = ^b
|
||||
}
|
||||
// arm64:"CSINV\tLS", -"CSEL"
|
||||
// arm64:"CSINV LS", -"CSEL"
|
||||
r1 = x1
|
||||
|
||||
if s > t {
|
||||
|
|
@ -332,7 +332,7 @@ func cmovFcmp0(s, t float64, a, b int) {
|
|||
} else {
|
||||
x2 = -b
|
||||
}
|
||||
// arm64:"CSNEG\tMI", -"CSEL"
|
||||
// arm64:"CSNEG MI", -"CSEL"
|
||||
r2 = x2
|
||||
|
||||
if s >= t {
|
||||
|
|
@ -340,7 +340,7 @@ func cmovFcmp0(s, t float64, a, b int) {
|
|||
} else {
|
||||
x3 = 0
|
||||
}
|
||||
// arm64:"CSETM\tLS", -"CSEL"
|
||||
// arm64:"CSETM LS", -"CSEL"
|
||||
r3 = x3
|
||||
|
||||
if s == t {
|
||||
|
|
@ -348,7 +348,7 @@ func cmovFcmp0(s, t float64, a, b int) {
|
|||
} else {
|
||||
x4 = b + 1
|
||||
}
|
||||
// arm64:"CSINC\tEQ", -"CSEL"
|
||||
// arm64:"CSINC EQ", -"CSEL"
|
||||
r4 = x4
|
||||
|
||||
if s != t {
|
||||
|
|
@ -356,7 +356,7 @@ func cmovFcmp0(s, t float64, a, b int) {
|
|||
} else {
|
||||
x5 = b + 1
|
||||
}
|
||||
// arm64:"CSINC\tNE", -"CSEL"
|
||||
// arm64:"CSINC NE", -"CSEL"
|
||||
r5 = x5
|
||||
}
|
||||
|
||||
|
|
@ -368,7 +368,7 @@ func cmovFcmp1(s, t float64, a, b int) {
|
|||
} else {
|
||||
x0 = a
|
||||
}
|
||||
// arm64:"CSINC\tPL", -"CSEL"
|
||||
// arm64:"CSINC PL", -"CSEL"
|
||||
r0 = x0
|
||||
|
||||
if s <= t {
|
||||
|
|
@ -376,7 +376,7 @@ func cmovFcmp1(s, t float64, a, b int) {
|
|||
} else {
|
||||
x1 = a
|
||||
}
|
||||
// arm64:"CSINV\tHI", -"CSEL"
|
||||
// arm64:"CSINV HI", -"CSEL"
|
||||
r1 = x1
|
||||
|
||||
if s > t {
|
||||
|
|
@ -384,7 +384,7 @@ func cmovFcmp1(s, t float64, a, b int) {
|
|||
} else {
|
||||
x2 = a
|
||||
}
|
||||
// arm64:"CSNEG\tPL", -"CSEL"
|
||||
// arm64:"CSNEG PL", -"CSEL"
|
||||
r2 = x2
|
||||
|
||||
if s >= t {
|
||||
|
|
@ -392,7 +392,7 @@ func cmovFcmp1(s, t float64, a, b int) {
|
|||
} else {
|
||||
x3 = -1
|
||||
}
|
||||
// arm64:"CSETM\tHI", -"CSEL"
|
||||
// arm64:"CSETM HI", -"CSEL"
|
||||
r3 = x3
|
||||
|
||||
if s == t {
|
||||
|
|
@ -400,7 +400,7 @@ func cmovFcmp1(s, t float64, a, b int) {
|
|||
} else {
|
||||
x4 = a
|
||||
}
|
||||
// arm64:"CSINC\tNE", -"CSEL"
|
||||
// arm64:"CSINC NE", -"CSEL"
|
||||
r4 = x4
|
||||
|
||||
if s != t {
|
||||
|
|
@ -408,7 +408,7 @@ func cmovFcmp1(s, t float64, a, b int) {
|
|||
} else {
|
||||
x5 = a
|
||||
}
|
||||
// arm64:"CSINC\tEQ", -"CSEL"
|
||||
// arm64:"CSINC EQ", -"CSEL"
|
||||
r5 = x5
|
||||
}
|
||||
|
||||
|
|
@ -439,7 +439,7 @@ func cmovzeroreg0(a, b int) int {
|
|||
if a == b {
|
||||
x = a
|
||||
}
|
||||
// ppc64x:"ISEL\t[$]2, R[0-9]+, R0, R[0-9]+"
|
||||
// ppc64x:"ISEL [$]2, R[0-9]+, R0, R[0-9]+"
|
||||
return x
|
||||
}
|
||||
|
||||
|
|
@ -448,7 +448,7 @@ func cmovzeroreg1(a, b int) int {
|
|||
if a == b {
|
||||
x = 0
|
||||
}
|
||||
// ppc64x:"ISEL\t[$]2, R0, R[0-9]+, R[0-9]+"
|
||||
// ppc64x:"ISEL [$]2, R0, R[0-9]+, R[0-9]+"
|
||||
return x
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,28 +8,28 @@ package codegen
|
|||
|
||||
// A uint16 or sint16 constant shifted left.
|
||||
func shifted16BitConstants() (out [64]uint64) {
|
||||
// ppc64x: "MOVD\t[$]8193,", "SLD\t[$]27,"
|
||||
// ppc64x: "MOVD [$]8193,", "SLD [$]27,"
|
||||
out[0] = 0x0000010008000000
|
||||
// ppc64x: "MOVD\t[$]-32767", "SLD\t[$]26,"
|
||||
// ppc64x: "MOVD [$]-32767", "SLD [$]26,"
|
||||
out[1] = 0xFFFFFE0004000000
|
||||
// ppc64x: "MOVD\t[$]-1", "SLD\t[$]48,"
|
||||
// ppc64x: "MOVD [$]-1", "SLD [$]48,"
|
||||
out[2] = 0xFFFF000000000000
|
||||
// ppc64x: "MOVD\t[$]65535", "SLD\t[$]44,"
|
||||
// ppc64x: "MOVD [$]65535", "SLD [$]44,"
|
||||
out[3] = 0x0FFFF00000000000
|
||||
return
|
||||
}
|
||||
|
||||
// A contiguous set of 1 bits, potentially wrapping.
|
||||
func contiguousMaskConstants() (out [64]uint64) {
|
||||
// ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]44, [$]63,"
|
||||
// ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]44, [$]63,"
|
||||
out[0] = 0xFFFFF00000000001
|
||||
// ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]43, [$]63,"
|
||||
// ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]43, [$]63,"
|
||||
out[1] = 0xFFFFF80000000001
|
||||
// ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]43, [$]4,"
|
||||
// ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]43, [$]4,"
|
||||
out[2] = 0x0FFFF80000000000
|
||||
// ppc64x/power8: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]33, [$]63,"
|
||||
// ppc64x/power9: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]33, [$]63,"
|
||||
// ppc64x/power10: "MOVD\t[$]-8589934591,"
|
||||
// ppc64x/power8: "MOVD [$]-1", "RLDC R[0-9]+, [$]33, [$]63,"
|
||||
// ppc64x/power9: "MOVD [$]-1", "RLDC R[0-9]+, [$]33, [$]63,"
|
||||
// ppc64x/power10: "MOVD [$]-8589934591,"
|
||||
out[3] = 0xFFFFFFFE00000001
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,8 +43,8 @@ var x [256]byte
|
|||
func moveDisjointStack32() {
|
||||
var s [32]byte
|
||||
// ppc64x:-".*memmove"
|
||||
// ppc64x/power8:"LXVD2X",-"ADD",-"BC"
|
||||
// ppc64x/power9:"LXV",-"LXVD2X",-"ADD",-"BC"
|
||||
// ppc64x/power8:"LXVD2X" -"ADD" -"BC"
|
||||
// ppc64x/power9:"LXV" -"LXVD2X" -"ADD" -"BC"
|
||||
copy(s[:], x[:32])
|
||||
runtime.KeepAlive(&s)
|
||||
}
|
||||
|
|
@ -52,8 +52,8 @@ func moveDisjointStack32() {
|
|||
func moveDisjointStack64() {
|
||||
var s [96]byte
|
||||
// ppc64x:-".*memmove"
|
||||
// ppc64x/power8:"LXVD2X","ADD","BC"
|
||||
// ppc64x/power9:"LXV",-"LXVD2X",-"ADD",-"BC"
|
||||
// ppc64x/power8:"LXVD2X" "ADD" "BC"
|
||||
// ppc64x/power9:"LXV" -"LXVD2X" -"ADD" -"BC"
|
||||
copy(s[:], x[:96])
|
||||
runtime.KeepAlive(&s)
|
||||
}
|
||||
|
|
@ -64,7 +64,7 @@ func moveDisjointStack() {
|
|||
// amd64:-".*memmove"
|
||||
// ppc64x:-".*memmove"
|
||||
// ppc64x/power8:"LXVD2X"
|
||||
// ppc64x/power9:"LXV",-"LXVD2X"
|
||||
// ppc64x/power9:"LXV" -"LXVD2X"
|
||||
copy(s[:], x[:])
|
||||
runtime.KeepAlive(&s)
|
||||
}
|
||||
|
|
@ -75,7 +75,7 @@ func moveDisjointArg(b *[256]byte) {
|
|||
// amd64:-".*memmove"
|
||||
// ppc64x:-".*memmove"
|
||||
// ppc64x/power8:"LXVD2X"
|
||||
// ppc64x/power9:"LXV",-"LXVD2X"
|
||||
// ppc64x/power9:"LXV" -"LXVD2X"
|
||||
copy(s[:], b[:])
|
||||
runtime.KeepAlive(&s)
|
||||
}
|
||||
|
|
@ -85,7 +85,7 @@ func moveDisjointNoOverlap(a *[256]byte) {
|
|||
// amd64:-".*memmove"
|
||||
// ppc64x:-".*memmove"
|
||||
// ppc64x/power8:"LXVD2X"
|
||||
// ppc64x/power9:"LXV",-"LXVD2X"
|
||||
// ppc64x/power9:"LXV" -"LXVD2X"
|
||||
copy(a[:], a[128:])
|
||||
}
|
||||
|
||||
|
|
@ -135,28 +135,28 @@ func moveArchLowering16(b []byte, x *[16]byte) {
|
|||
// Check that no branches are generated when the pointers are [not] equal.
|
||||
|
||||
func ptrEqual() {
|
||||
// amd64:-"JEQ",-"JNE"
|
||||
// ppc64x:-"BEQ",-"BNE"
|
||||
// s390x:-"BEQ",-"BNE"
|
||||
// amd64:-"JEQ" -"JNE"
|
||||
// ppc64x:-"BEQ" -"BNE"
|
||||
// s390x:-"BEQ" -"BNE"
|
||||
copy(x[:], x[:])
|
||||
}
|
||||
|
||||
func ptrOneOffset() {
|
||||
// amd64:-"JEQ",-"JNE"
|
||||
// ppc64x:-"BEQ",-"BNE"
|
||||
// s390x:-"BEQ",-"BNE"
|
||||
// amd64:-"JEQ" -"JNE"
|
||||
// ppc64x:-"BEQ" -"BNE"
|
||||
// s390x:-"BEQ" -"BNE"
|
||||
copy(x[1:], x[:])
|
||||
}
|
||||
|
||||
func ptrBothOffset() {
|
||||
// amd64:-"JEQ",-"JNE"
|
||||
// ppc64x:-"BEQ",-"BNE"
|
||||
// s390x:-"BEQ",-"BNE"
|
||||
// amd64:-"JEQ" -"JNE"
|
||||
// ppc64x:-"BEQ" -"BNE"
|
||||
// s390x:-"BEQ" -"BNE"
|
||||
copy(x[1:], x[2:])
|
||||
}
|
||||
|
||||
// Verify #62698 on PPC64.
|
||||
func noMaskOnCopy(a []int, s string, x int) int {
|
||||
// ppc64x:-"MOVD\t$-1", -"AND"
|
||||
// ppc64x:-"MOVD [$]-1", -"AND"
|
||||
return a[x&^copy([]byte{}, s)]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,42 +15,42 @@ package codegen
|
|||
// --------------------- //
|
||||
|
||||
func Mul2(f float64) float64 {
|
||||
// 386/sse2:"ADDSD",-"MULSD"
|
||||
// amd64:"ADDSD",-"MULSD"
|
||||
// arm/7:"ADDD",-"MULD"
|
||||
// arm64:"FADDD",-"FMULD"
|
||||
// loong64:"ADDD",-"MULD"
|
||||
// ppc64x:"FADD",-"FMUL"
|
||||
// riscv64:"FADDD",-"FMULD"
|
||||
// 386/sse2:"ADDSD" -"MULSD"
|
||||
// amd64:"ADDSD" -"MULSD"
|
||||
// arm/7:"ADDD" -"MULD"
|
||||
// arm64:"FADDD" -"FMULD"
|
||||
// loong64:"ADDD" -"MULD"
|
||||
// ppc64x:"FADD" -"FMUL"
|
||||
// riscv64:"FADDD" -"FMULD"
|
||||
return f * 2.0
|
||||
}
|
||||
|
||||
func DivPow2(f1, f2, f3 float64) (float64, float64, float64) {
|
||||
// 386/sse2:"MULSD",-"DIVSD"
|
||||
// amd64:"MULSD",-"DIVSD"
|
||||
// arm/7:"MULD",-"DIVD"
|
||||
// arm64:"FMULD",-"FDIVD"
|
||||
// loong64:"MULD",-"DIVD"
|
||||
// ppc64x:"FMUL",-"FDIV"
|
||||
// riscv64:"FMULD",-"FDIVD"
|
||||
// 386/sse2:"MULSD" -"DIVSD"
|
||||
// amd64:"MULSD" -"DIVSD"
|
||||
// arm/7:"MULD" -"DIVD"
|
||||
// arm64:"FMULD" -"FDIVD"
|
||||
// loong64:"MULD" -"DIVD"
|
||||
// ppc64x:"FMUL" -"FDIV"
|
||||
// riscv64:"FMULD" -"FDIVD"
|
||||
x := f1 / 16.0
|
||||
|
||||
// 386/sse2:"MULSD",-"DIVSD"
|
||||
// amd64:"MULSD",-"DIVSD"
|
||||
// arm/7:"MULD",-"DIVD"
|
||||
// arm64:"FMULD",-"FDIVD"
|
||||
// loong64:"MULD",-"DIVD"
|
||||
// ppc64x:"FMUL",-"FDIVD"
|
||||
// riscv64:"FMULD",-"FDIVD"
|
||||
// 386/sse2:"MULSD" -"DIVSD"
|
||||
// amd64:"MULSD" -"DIVSD"
|
||||
// arm/7:"MULD" -"DIVD"
|
||||
// arm64:"FMULD" -"FDIVD"
|
||||
// loong64:"MULD" -"DIVD"
|
||||
// ppc64x:"FMUL" -"FDIVD"
|
||||
// riscv64:"FMULD" -"FDIVD"
|
||||
y := f2 / 0.125
|
||||
|
||||
// 386/sse2:"ADDSD",-"DIVSD",-"MULSD"
|
||||
// amd64:"ADDSD",-"DIVSD",-"MULSD"
|
||||
// arm/7:"ADDD",-"MULD",-"DIVD"
|
||||
// arm64:"FADDD",-"FMULD",-"FDIVD"
|
||||
// loong64:"ADDD",-"MULD",-"DIVD"
|
||||
// ppc64x:"FADD",-"FMUL",-"FDIV"
|
||||
// riscv64:"FADDD",-"FMULD",-"FDIVD"
|
||||
// 386/sse2:"ADDSD" -"DIVSD" -"MULSD"
|
||||
// amd64:"ADDSD" -"DIVSD" -"MULSD"
|
||||
// arm/7:"ADDD" -"MULD" -"DIVD"
|
||||
// arm64:"FADDD" -"FMULD" -"FDIVD"
|
||||
// loong64:"ADDD" -"MULD" -"DIVD"
|
||||
// ppc64x:"FADD" -"FMUL" -"FDIV"
|
||||
// riscv64:"FADDD" -"FMULD" -"FDIVD"
|
||||
z := f3 / 0.5
|
||||
|
||||
return x, y, z
|
||||
|
|
@ -73,67 +73,67 @@ func indexStore(b0 []float64, b1 float64, idx int) {
|
|||
// ----------- //
|
||||
|
||||
func FusedAdd32(x, y, z float32) float32 {
|
||||
// s390x:"FMADDS\t"
|
||||
// ppc64x:"FMADDS\t"
|
||||
// s390x:"FMADDS "
|
||||
// ppc64x:"FMADDS "
|
||||
// arm64:"FMADDS"
|
||||
// loong64:"FMADDF\t"
|
||||
// riscv64:"FMADDS\t"
|
||||
// amd64/v3:"VFMADD231SS\t"
|
||||
// loong64:"FMADDF "
|
||||
// riscv64:"FMADDS "
|
||||
// amd64/v3:"VFMADD231SS "
|
||||
return x*y + z
|
||||
}
|
||||
|
||||
func FusedSub32_a(x, y, z float32) float32 {
|
||||
// s390x:"FMSUBS\t"
|
||||
// ppc64x:"FMSUBS\t"
|
||||
// riscv64:"FMSUBS\t"
|
||||
// loong64:"FMSUBF\t"
|
||||
// s390x:"FMSUBS "
|
||||
// ppc64x:"FMSUBS "
|
||||
// riscv64:"FMSUBS "
|
||||
// loong64:"FMSUBF "
|
||||
return x*y - z
|
||||
}
|
||||
|
||||
func FusedSub32_b(x, y, z float32) float32 {
|
||||
// arm64:"FMSUBS"
|
||||
// loong64:"FNMSUBF\t"
|
||||
// riscv64:"FNMSUBS\t"
|
||||
// loong64:"FNMSUBF "
|
||||
// riscv64:"FNMSUBS "
|
||||
return z - x*y
|
||||
}
|
||||
|
||||
func FusedAdd64(x, y, z float64) float64 {
|
||||
// s390x:"FMADD\t"
|
||||
// ppc64x:"FMADD\t"
|
||||
// s390x:"FMADD "
|
||||
// ppc64x:"FMADD "
|
||||
// arm64:"FMADDD"
|
||||
// loong64:"FMADDD\t"
|
||||
// riscv64:"FMADDD\t"
|
||||
// amd64/v3:"VFMADD231SD\t"
|
||||
// loong64:"FMADDD "
|
||||
// riscv64:"FMADDD "
|
||||
// amd64/v3:"VFMADD231SD "
|
||||
return x*y + z
|
||||
}
|
||||
|
||||
func FusedSub64_a(x, y, z float64) float64 {
|
||||
// s390x:"FMSUB\t"
|
||||
// ppc64x:"FMSUB\t"
|
||||
// riscv64:"FMSUBD\t"
|
||||
// loong64:"FMSUBD\t"
|
||||
// s390x:"FMSUB "
|
||||
// ppc64x:"FMSUB "
|
||||
// riscv64:"FMSUBD "
|
||||
// loong64:"FMSUBD "
|
||||
return x*y - z
|
||||
}
|
||||
|
||||
func FusedSub64_b(x, y, z float64) float64 {
|
||||
// arm64:"FMSUBD"
|
||||
// loong64:"FNMSUBD\t"
|
||||
// riscv64:"FNMSUBD\t"
|
||||
// loong64:"FNMSUBD "
|
||||
// riscv64:"FNMSUBD "
|
||||
return z - x*y
|
||||
}
|
||||
|
||||
func Cmp(f float64) bool {
|
||||
// arm64:"FCMPD","(BGT|BLE|BMI|BPL)",-"CSET\tGT",-"CBZ"
|
||||
// arm64:"FCMPD" "(BGT|BLE|BMI|BPL)" -"CSET GT" -"CBZ"
|
||||
return f > 4 || f < -4
|
||||
}
|
||||
|
||||
func CmpZero64(f float64) bool {
|
||||
// s390x:"LTDBR",-"FCMPU"
|
||||
// s390x:"LTDBR" -"FCMPU"
|
||||
return f <= 0
|
||||
}
|
||||
|
||||
func CmpZero32(f float32) bool {
|
||||
// s390x:"LTEBR",-"CEBR"
|
||||
// s390x:"LTEBR" -"CEBR"
|
||||
return f <= 0
|
||||
}
|
||||
|
||||
|
|
@ -218,43 +218,43 @@ func Float32Max(a, b float32) float32 {
|
|||
// ------------------------ //
|
||||
|
||||
func Float32ConstantZero() float32 {
|
||||
// arm64:"FMOVS\tZR,"
|
||||
// arm64:"FMOVS ZR,"
|
||||
return 0.0
|
||||
}
|
||||
|
||||
func Float32ConstantChipFloat() float32 {
|
||||
// arm64:"FMOVS\t[$]\\(2\\.25\\),"
|
||||
// arm64:"FMOVS [$]\\(2\\.25\\),"
|
||||
return 2.25
|
||||
}
|
||||
|
||||
func Float32Constant() float32 {
|
||||
// arm64:"FMOVS\t[$]f32\\.42440000\\(SB\\)"
|
||||
// ppc64x/power8:"FMOVS\t[$]f32\\.42440000\\(SB\\)"
|
||||
// ppc64x/power9:"FMOVS\t[$]f32\\.42440000\\(SB\\)"
|
||||
// ppc64x/power10:"XXSPLTIDP\t[$]1111752704,"
|
||||
// arm64:"FMOVS [$]f32\\.42440000\\(SB\\)"
|
||||
// ppc64x/power8:"FMOVS [$]f32\\.42440000\\(SB\\)"
|
||||
// ppc64x/power9:"FMOVS [$]f32\\.42440000\\(SB\\)"
|
||||
// ppc64x/power10:"XXSPLTIDP [$]1111752704,"
|
||||
return 49.0
|
||||
}
|
||||
|
||||
func Float64ConstantZero() float64 {
|
||||
// arm64:"FMOVD\tZR,"
|
||||
// arm64:"FMOVD ZR,"
|
||||
return 0.0
|
||||
}
|
||||
|
||||
func Float64ConstantChipFloat() float64 {
|
||||
// arm64:"FMOVD\t[$]\\(2\\.25\\),"
|
||||
// arm64:"FMOVD [$]\\(2\\.25\\),"
|
||||
return 2.25
|
||||
}
|
||||
|
||||
func Float64Constant() float64 {
|
||||
// arm64:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)"
|
||||
// ppc64x/power8:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)"
|
||||
// ppc64x/power9:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)"
|
||||
// ppc64x/power10:"XXSPLTIDP\t[$]1111752704,"
|
||||
// arm64:"FMOVD [$]f64\\.4048800000000000\\(SB\\)"
|
||||
// ppc64x/power8:"FMOVD [$]f64\\.4048800000000000\\(SB\\)"
|
||||
// ppc64x/power9:"FMOVD [$]f64\\.4048800000000000\\(SB\\)"
|
||||
// ppc64x/power10:"XXSPLTIDP [$]1111752704,"
|
||||
return 49.0
|
||||
}
|
||||
|
||||
func Float32DenormalConstant() float32 {
|
||||
// ppc64x:"FMOVS\t[$]f32\\.00400000\\(SB\\)"
|
||||
// ppc64x:"FMOVS [$]f32\\.00400000\\(SB\\)"
|
||||
return 0x1p-127
|
||||
}
|
||||
|
||||
|
|
@ -262,18 +262,18 @@ func Float32DenormalConstant() float32 {
|
|||
// denormal float32 value. On ppc64x, denormal values cannot
|
||||
// be used with XXSPLTIDP.
|
||||
func Float64DenormalFloat32Constant() float64 {
|
||||
// ppc64x:"FMOVD\t[$]f64\\.3800000000000000\\(SB\\)"
|
||||
// ppc64x:"FMOVD [$]f64\\.3800000000000000\\(SB\\)"
|
||||
return 0x1p-127
|
||||
}
|
||||
|
||||
func Float32ConstantStore(p *float32) {
|
||||
// amd64:"MOVL\t[$]1085133554"
|
||||
// riscv64: "MOVF\t[$]f32.40add2f2"
|
||||
// amd64:"MOVL [$]1085133554"
|
||||
// riscv64: "MOVF [$]f32.40add2f2"
|
||||
*p = 5.432
|
||||
}
|
||||
|
||||
func Float64ConstantStore(p *float64) {
|
||||
// amd64: "MOVQ\t[$]4617801906721357038"
|
||||
// riscv64: "MOVD\t[$]f64.4015ba5e353f7cee"
|
||||
// amd64: "MOVQ [$]4617801906721357038"
|
||||
// riscv64: "MOVD [$]f64.4015ba5e353f7cee"
|
||||
*p = 5.432
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,57 +19,57 @@ import "math"
|
|||
// ---------------------------------- //
|
||||
|
||||
func si1c(c <-chan int64) {
|
||||
// amd64:"CMPQ\t.+, [$]256"
|
||||
// s390x:"CLGIJ\t[$]12, R[0-9]+, [$]255"
|
||||
// amd64:"CMPQ .+, [$]256"
|
||||
// s390x:"CLGIJ [$]12, R[0-9]+, [$]255"
|
||||
for x := <-c; x >= 0 && x < 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si2c(c <-chan int32) {
|
||||
// amd64:"CMPL\t.+, [$]256"
|
||||
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255"
|
||||
// amd64:"CMPL .+, [$]256"
|
||||
// s390x:"CLIJ [$]12, R[0-9]+, [$]255"
|
||||
for x := <-c; x >= 0 && x < 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si3c(c <-chan int16) {
|
||||
// amd64:"CMPW\t.+, [$]256"
|
||||
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255"
|
||||
// amd64:"CMPW .+, [$]256"
|
||||
// s390x:"CLIJ [$]12, R[0-9]+, [$]255"
|
||||
for x := <-c; x >= 0 && x < 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si4c(c <-chan int8) {
|
||||
// amd64:"CMPB\t.+, [$]10"
|
||||
// s390x:"CLIJ\t[$]4, R[0-9]+, [$]10"
|
||||
// amd64:"CMPB .+, [$]10"
|
||||
// s390x:"CLIJ [$]4, R[0-9]+, [$]10"
|
||||
for x := <-c; x >= 0 && x < 10; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si5c(c <-chan int64) {
|
||||
// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"
|
||||
// s390x:"CLGIJ\t[$]4, R[0-9]+, [$]251","ADD\t[$]-5,"
|
||||
// amd64:"CMPQ .+, [$]251" "ADDQ [$]-5,"
|
||||
// s390x:"CLGIJ [$]4, R[0-9]+, [$]251" "ADD [$]-5,"
|
||||
for x := <-c; x < 256 && x > 4; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si6c(c <-chan int32) {
|
||||
// amd64:"CMPL\t.+, [$]255","DECL\t"
|
||||
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255","ADDW\t[$]-1,"
|
||||
// amd64:"CMPL .+, [$]255" "DECL "
|
||||
// s390x:"CLIJ [$]12, R[0-9]+, [$]255" "ADDW [$]-1,"
|
||||
for x := <-c; x > 0 && x <= 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si7c(c <-chan int16) {
|
||||
// amd64:"CMPW\t.+, [$]60","ADDL\t[$]10,"
|
||||
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]60","ADDW\t[$]10,"
|
||||
// amd64:"CMPW .+, [$]60" "ADDL [$]10,"
|
||||
// s390x:"CLIJ [$]12, R[0-9]+, [$]60" "ADDW [$]10,"
|
||||
for x := <-c; x >= -10 && x <= 50; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si8c(c <-chan int8) {
|
||||
// amd64:"CMPB\t.+, [$]126","ADDL\t[$]126,"
|
||||
// s390x:"CLIJ\t[$]4, R[0-9]+, [$]126","ADDW\t[$]126,"
|
||||
// amd64:"CMPB .+, [$]126" "ADDL [$]126,"
|
||||
// s390x:"CLIJ [$]4, R[0-9]+, [$]126" "ADDW [$]126,"
|
||||
for x := <-c; x >= -126 && x < 0; x = <-c {
|
||||
}
|
||||
}
|
||||
|
|
@ -79,57 +79,57 @@ func si8c(c <-chan int8) {
|
|||
// ---------------------------------- //
|
||||
|
||||
func si1d(c <-chan int64) {
|
||||
// amd64:"CMPQ\t.+, [$]256"
|
||||
// s390x:"CLGIJ\t[$]2, R[0-9]+, [$]255"
|
||||
// amd64:"CMPQ .+, [$]256"
|
||||
// s390x:"CLGIJ [$]2, R[0-9]+, [$]255"
|
||||
for x := <-c; x < 0 || x >= 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si2d(c <-chan int32) {
|
||||
// amd64:"CMPL\t.+, [$]256"
|
||||
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]255"
|
||||
// amd64:"CMPL .+, [$]256"
|
||||
// s390x:"CLIJ [$]2, R[0-9]+, [$]255"
|
||||
for x := <-c; x < 0 || x >= 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si3d(c <-chan int16) {
|
||||
// amd64:"CMPW\t.+, [$]256"
|
||||
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]255"
|
||||
// amd64:"CMPW .+, [$]256"
|
||||
// s390x:"CLIJ [$]2, R[0-9]+, [$]255"
|
||||
for x := <-c; x < 0 || x >= 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si4d(c <-chan int8) {
|
||||
// amd64:"CMPB\t.+, [$]10"
|
||||
// s390x:"CLIJ\t[$]10, R[0-9]+, [$]10"
|
||||
// amd64:"CMPB .+, [$]10"
|
||||
// s390x:"CLIJ [$]10, R[0-9]+, [$]10"
|
||||
for x := <-c; x < 0 || x >= 10; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si5d(c <-chan int64) {
|
||||
// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"
|
||||
// s390x:"CLGIJ\t[$]10, R[0-9]+, [$]251","ADD\t[$]-5,"
|
||||
// amd64:"CMPQ .+, [$]251" "ADDQ [$]-5,"
|
||||
// s390x:"CLGIJ [$]10, R[0-9]+, [$]251" "ADD [$]-5,"
|
||||
for x := <-c; x >= 256 || x <= 4; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si6d(c <-chan int32) {
|
||||
// amd64:"CMPL\t.+, [$]255","DECL\t"
|
||||
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]255","ADDW\t[$]-1,"
|
||||
// amd64:"CMPL .+, [$]255" "DECL "
|
||||
// s390x:"CLIJ [$]2, R[0-9]+, [$]255" "ADDW [$]-1,"
|
||||
for x := <-c; x <= 0 || x > 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si7d(c <-chan int16) {
|
||||
// amd64:"CMPW\t.+, [$]60","ADDL\t[$]10,"
|
||||
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]60","ADDW\t[$]10,"
|
||||
// amd64:"CMPW .+, [$]60" "ADDL [$]10,"
|
||||
// s390x:"CLIJ [$]2, R[0-9]+, [$]60" "ADDW [$]10,"
|
||||
for x := <-c; x < -10 || x > 50; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func si8d(c <-chan int8) {
|
||||
// amd64:"CMPB\t.+, [$]126","ADDL\t[$]126,"
|
||||
// s390x:"CLIJ\t[$]10, R[0-9]+, [$]126","ADDW\t[$]126,"
|
||||
// amd64:"CMPB .+, [$]126" "ADDL [$]126,"
|
||||
// s390x:"CLIJ [$]10, R[0-9]+, [$]126" "ADDW [$]126,"
|
||||
for x := <-c; x < -126 || x >= 0; x = <-c {
|
||||
}
|
||||
}
|
||||
|
|
@ -139,29 +139,29 @@ func si8d(c <-chan int8) {
|
|||
// ------------------------------------ //
|
||||
|
||||
func ui1c(c <-chan uint64) {
|
||||
// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"
|
||||
// s390x:"CLGIJ\t[$]4, R[0-9]+, [$]251","ADD\t[$]-5,"
|
||||
// amd64:"CMPQ .+, [$]251" "ADDQ [$]-5,"
|
||||
// s390x:"CLGIJ [$]4, R[0-9]+, [$]251" "ADD [$]-5,"
|
||||
for x := <-c; x < 256 && x > 4; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func ui2c(c <-chan uint32) {
|
||||
// amd64:"CMPL\t.+, [$]255","DECL\t"
|
||||
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255","ADDW\t[$]-1,"
|
||||
// amd64:"CMPL .+, [$]255" "DECL "
|
||||
// s390x:"CLIJ [$]12, R[0-9]+, [$]255" "ADDW [$]-1,"
|
||||
for x := <-c; x > 0 && x <= 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func ui3c(c <-chan uint16) {
|
||||
// amd64:"CMPW\t.+, [$]40","ADDL\t[$]-10,"
|
||||
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]40","ADDW\t[$]-10,"
|
||||
// amd64:"CMPW .+, [$]40" "ADDL [$]-10,"
|
||||
// s390x:"CLIJ [$]12, R[0-9]+, [$]40" "ADDW [$]-10,"
|
||||
for x := <-c; x >= 10 && x <= 50; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func ui4c(c <-chan uint8) {
|
||||
// amd64:"CMPB\t.+, [$]2","ADDL\t[$]-126,"
|
||||
// s390x:"CLIJ\t[$]4, R[0-9]+, [$]2","ADDW\t[$]-126,"
|
||||
// amd64:"CMPB .+, [$]2" "ADDL [$]-126,"
|
||||
// s390x:"CLIJ [$]4, R[0-9]+, [$]2" "ADDW [$]-126,"
|
||||
for x := <-c; x >= 126 && x < 128; x = <-c {
|
||||
}
|
||||
}
|
||||
|
|
@ -171,29 +171,29 @@ func ui4c(c <-chan uint8) {
|
|||
// ------------------------------------ //
|
||||
|
||||
func ui1d(c <-chan uint64) {
|
||||
// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"
|
||||
// s390x:"CLGIJ\t[$]10, R[0-9]+, [$]251","ADD\t[$]-5,"
|
||||
// amd64:"CMPQ .+, [$]251" "ADDQ [$]-5,"
|
||||
// s390x:"CLGIJ [$]10, R[0-9]+, [$]251" "ADD [$]-5,"
|
||||
for x := <-c; x >= 256 || x <= 4; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func ui2d(c <-chan uint32) {
|
||||
// amd64:"CMPL\t.+, [$]254","ADDL\t[$]-2,"
|
||||
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]254","ADDW\t[$]-2,"
|
||||
// amd64:"CMPL .+, [$]254" "ADDL [$]-2,"
|
||||
// s390x:"CLIJ [$]2, R[0-9]+, [$]254" "ADDW [$]-2,"
|
||||
for x := <-c; x <= 1 || x > 256; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func ui3d(c <-chan uint16) {
|
||||
// amd64:"CMPW\t.+, [$]40","ADDL\t[$]-10,"
|
||||
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]40","ADDW\t[$]-10,"
|
||||
// amd64:"CMPW .+, [$]40" "ADDL [$]-10,"
|
||||
// s390x:"CLIJ [$]2, R[0-9]+, [$]40" "ADDW [$]-10,"
|
||||
for x := <-c; x < 10 || x > 50; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func ui4d(c <-chan uint8) {
|
||||
// amd64:"CMPB\t.+, [$]2","ADDL\t[$]-126,"
|
||||
// s390x:"CLIJ\t[$]10, R[0-9]+, [$]2","ADDW\t[$]-126,"
|
||||
// amd64:"CMPB .+, [$]2" "ADDL [$]-126,"
|
||||
// s390x:"CLIJ [$]10, R[0-9]+, [$]2" "ADDW [$]-126,"
|
||||
for x := <-c; x < 126 || x >= 128; x = <-c {
|
||||
}
|
||||
}
|
||||
|
|
@ -205,8 +205,8 @@ func ui4d(c <-chan uint8) {
|
|||
func f64NaNOrPosInf(c <-chan float64) {
|
||||
// This test assumes IsInf(x, 1) is implemented as x > MaxFloat rather than x == Inf(1).
|
||||
|
||||
// amd64:"JCS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FCLASSD",-"FLED",-"FLTD",-"FNED",-"FEQD"
|
||||
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FCLASSD" -"FLED" -"FLTD" -"FNED" -"FEQD"
|
||||
for x := <-c; math.IsNaN(x) || math.IsInf(x, 1); x = <-c {
|
||||
}
|
||||
}
|
||||
|
|
@ -214,64 +214,64 @@ func f64NaNOrPosInf(c <-chan float64) {
|
|||
func f64NaNOrNegInf(c <-chan float64) {
|
||||
// This test assumes IsInf(x, -1) is implemented as x < -MaxFloat rather than x == Inf(-1).
|
||||
|
||||
// amd64:"JCS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FCLASSD",-"FLED",-"FLTD",-"FNED",-"FEQD"
|
||||
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FCLASSD" -"FLED" -"FLTD" -"FNED" -"FEQD"
|
||||
for x := <-c; math.IsNaN(x) || math.IsInf(x, -1); x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func f64NaNOrLtOne(c <-chan float64) {
|
||||
// amd64:"JCS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FLED",-"FLTD",-"FNED",-"FEQD"
|
||||
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FLED" -"FLTD" -"FNED" -"FEQD"
|
||||
for x := <-c; math.IsNaN(x) || x < 1; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func f64NaNOrLteOne(c <-chan float64) {
|
||||
// amd64:"JLS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FLTD",-"FLED",-"FNED",-"FEQD"
|
||||
// amd64:"JLS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FLTD" -"FLED" -"FNED" -"FEQD"
|
||||
for x := <-c; x <= 1 || math.IsNaN(x); x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func f64NaNOrGtOne(c <-chan float64) {
|
||||
// amd64:"JCS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FLED",-"FLTD",-"FNED",-"FEQD"
|
||||
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FLED" -"FLTD" -"FNED" -"FEQD"
|
||||
for x := <-c; math.IsNaN(x) || x > 1; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func f64NaNOrGteOne(c <-chan float64) {
|
||||
// amd64:"JLS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FLTD",-"FLED",-"FNED",-"FEQD"
|
||||
// amd64:"JLS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FLTD" -"FLED" -"FNED" -"FEQD"
|
||||
for x := <-c; x >= 1 || math.IsNaN(x); x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func f32NaNOrLtOne(c <-chan float32) {
|
||||
// amd64:"JCS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FLES",-"FLTS",-"FNES",-"FEQS"
|
||||
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FLES" -"FLTS" -"FNES" -"FEQS"
|
||||
for x := <-c; x < 1 || x != x; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func f32NaNOrLteOne(c <-chan float32) {
|
||||
// amd64:"JLS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FLTS",-"FLES",-"FNES",-"FEQS"
|
||||
// amd64:"JLS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FLTS" -"FLES" -"FNES" -"FEQS"
|
||||
for x := <-c; x != x || x <= 1; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func f32NaNOrGtOne(c <-chan float32) {
|
||||
// amd64:"JCS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FLES",-"FLTS",-"FNES",-"FEQS"
|
||||
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FLES" -"FLTS" -"FNES" -"FEQS"
|
||||
for x := <-c; x > 1 || x != x; x = <-c {
|
||||
}
|
||||
}
|
||||
|
||||
func f32NaNOrGteOne(c <-chan float32) {
|
||||
// amd64:"JLS",-"JNE",-"JPS",-"JPC"
|
||||
// riscv64:"FLTS",-"FLES",-"FNES",-"FEQS"
|
||||
// amd64:"JLS" -"JNE" -"JPS" -"JPC"
|
||||
// riscv64:"FLTS" -"FLES" -"FNES" -"FEQS"
|
||||
for x := <-c; x != x || x >= 1; x = <-c {
|
||||
}
|
||||
}
|
||||
|
|
@ -291,8 +291,8 @@ func lt20(x uint64) bool {
|
|||
func issue74915(c <-chan uint64) {
|
||||
// Check that the optimization is not blocked by function inlining.
|
||||
|
||||
// amd64:"CMPQ\t.+, [$]16","ADDQ\t[$]-4,"
|
||||
// s390x:"CLGIJ\t[$]4, R[0-9]+, [$]16","ADD\t[$]-4,"
|
||||
// amd64:"CMPQ .+, [$]16" "ADDQ [$]-4,"
|
||||
// s390x:"CLGIJ [$]4, R[0-9]+, [$]16" "ADD [$]-4,"
|
||||
for x := <-c; gte4(x) && lt20(x); x = <-c {
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,20 +21,20 @@ func NopConvertGeneric[T any](x T) T {
|
|||
var NopConvertGenericIface = NopConvertGeneric[I]
|
||||
|
||||
func ConvToM(x any) I {
|
||||
// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(.*\)`,`MOVQ\t8\(.*\)(.*\*1)`
|
||||
// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU`,`MOVD\t\(R.*\)\(R.*\)`
|
||||
// amd64:`CALL runtime.typeAssert`,`MOVL 16\(.*\)`,`MOVQ 8\(.*\)(.*\*1)`
|
||||
// arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU`,`MOVD \(R.*\)\(R.*\)`
|
||||
return x.(I)
|
||||
}
|
||||
|
||||
func e1(x any, y *int) bool {
|
||||
// amd64:-`.*faceeq`,`SETEQ`
|
||||
// arm64:-`.*faceeq`,`CSET\tEQ`
|
||||
// arm64:-`.*faceeq`,`CSET EQ`
|
||||
return x == y
|
||||
}
|
||||
|
||||
func e2(x any, y *int) bool {
|
||||
// amd64:-`.*faceeq`,`SETEQ`
|
||||
// arm64:-`.*faceeq`,`CSET\tEQ`
|
||||
// arm64:-`.*faceeq`,`CSET EQ`
|
||||
return y == x
|
||||
}
|
||||
|
||||
|
|
@ -42,7 +42,7 @@ type E *int
|
|||
|
||||
func e3(x any, y E) bool {
|
||||
// amd64:-`.*faceeq`,`SETEQ`
|
||||
// arm64:-`.*faceeq`,`CSET\tEQ`
|
||||
// arm64:-`.*faceeq`,`CSET EQ`
|
||||
return x == y
|
||||
}
|
||||
|
||||
|
|
@ -52,12 +52,12 @@ func (t *T) M() {}
|
|||
|
||||
func i1(x I, y *T) bool {
|
||||
// amd64:-`.*faceeq`,`SETEQ`
|
||||
// arm64:-`.*faceeq`,`CSET\tEQ`
|
||||
// arm64:-`.*faceeq`,`CSET EQ`
|
||||
return x == y
|
||||
}
|
||||
|
||||
func i2(x I, y *T) bool {
|
||||
// amd64:-`.*faceeq`,`SETEQ`
|
||||
// arm64:-`.*faceeq`,`CSET\tEQ`
|
||||
// arm64:-`.*faceeq`,`CSET EQ`
|
||||
return y == x
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,9 +14,9 @@ var wsp = [256]bool{
|
|||
}
|
||||
|
||||
func zeroExtArgByte(ch [2]byte) bool {
|
||||
return wsp[ch[0]] // amd64:-"MOVBLZX\t..,.."
|
||||
return wsp[ch[0]] // amd64:-"MOVBLZX ..,.."
|
||||
}
|
||||
|
||||
func zeroExtArgUint16(ch [2]uint16) bool {
|
||||
return wsp[ch[0]] // amd64:-"MOVWLZX\t..,.."
|
||||
return wsp[ch[0]] // amd64:-"MOVWLZX ..,.."
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,31 +17,31 @@ type T struct {
|
|||
|
||||
func (t *T) f() {
|
||||
// amd64:-".*runtime.memclrNoHeapPointers"
|
||||
// amd64:`MOVUPS\tX15,`
|
||||
// amd64:`MOVUPS X15,`
|
||||
for i := range t.a {
|
||||
t.a[i] = 0
|
||||
}
|
||||
|
||||
// amd64:-".*runtime.memclrNoHeapPointers"
|
||||
// amd64:`MOVUPS\tX15,`
|
||||
// amd64:`MOVUPS X15,`
|
||||
for i := range *t.a {
|
||||
t.a[i] = 0
|
||||
}
|
||||
|
||||
// amd64:-".*runtime.memclrNoHeapPointers"
|
||||
// amd64:`MOVUPS\tX15,`
|
||||
// amd64:`MOVUPS X15,`
|
||||
for i := range t.a {
|
||||
(*t.a)[i] = 0
|
||||
}
|
||||
|
||||
// amd64:-".*runtime.memclrNoHeapPointers"
|
||||
// amd64:`MOVUPS\tX15,`
|
||||
// amd64:`MOVUPS X15,`
|
||||
for i := range *t.a {
|
||||
(*t.a)[i] = 0
|
||||
}
|
||||
|
||||
// amd64:-".*runtime.memclrNoHeapPointers"
|
||||
// amd64:`MOVUPS\tX15,`
|
||||
// amd64:`MOVUPS X15,`
|
||||
for i := range t.b {
|
||||
t.b[i] = 0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ package codegen
|
|||
func f(x []int) int {
|
||||
s := make([]int, 3)
|
||||
s = append(s, 4, 5)
|
||||
// amd64:`MOVQ\t40\(.*\),`
|
||||
// amd64:`MOVQ 40\(.*\),`
|
||||
return x[len(s)]
|
||||
}
|
||||
|
||||
|
|
@ -26,7 +26,7 @@ func g(x []int, p *bool) int {
|
|||
}
|
||||
s = append(s, 4, 5)
|
||||
if *p {
|
||||
// amd64:`MOVQ\t40\(.*\),`
|
||||
// amd64:`MOVQ 40\(.*\),`
|
||||
return x[len(s)]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,30 +7,30 @@
|
|||
package codegen
|
||||
|
||||
func main() {
|
||||
// amd64:"LEAQ\tcommand-line-arguments\\.main\\.f\\.g\\.h\\.func3"
|
||||
// amd64:"LEAQ command-line-arguments\\.main\\.f\\.g\\.h\\.func3"
|
||||
f(1)()
|
||||
|
||||
// amd64:"LEAQ\tcommand-line-arguments\\.main\\.g\\.h\\.func2"
|
||||
// amd64:"LEAQ command-line-arguments\\.main\\.g\\.h\\.func2"
|
||||
g(2)()
|
||||
|
||||
// amd64:"LEAQ\tcommand-line-arguments\\.main\\.h\\.func1"
|
||||
// amd64:"LEAQ command-line-arguments\\.main\\.h\\.func1"
|
||||
h(3)()
|
||||
|
||||
// amd64:"LEAQ\tcommand-line-arguments\\.main\\.f\\.g\\.h\\.func4"
|
||||
// amd64:"LEAQ command-line-arguments\\.main\\.f\\.g\\.h\\.func4"
|
||||
f(4)()
|
||||
}
|
||||
|
||||
func f(x int) func() {
|
||||
// amd64:"LEAQ\tcommand-line-arguments\\.f\\.g\\.h\\.func1"
|
||||
// amd64:"LEAQ command-line-arguments\\.f\\.g\\.h\\.func1"
|
||||
return g(x)
|
||||
}
|
||||
|
||||
func g(x int) func() {
|
||||
// amd64:"LEAQ\tcommand-line-arguments\\.g\\.h\\.func1"
|
||||
// amd64:"LEAQ command-line-arguments\\.g\\.h\\.func1"
|
||||
return h(x)
|
||||
}
|
||||
|
||||
func h(x int) func() {
|
||||
// amd64:"LEAQ\tcommand-line-arguments\\.h\\.func1"
|
||||
// amd64:"LEAQ command-line-arguments\\.h\\.func1"
|
||||
return func() { recover() }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,41 +7,41 @@
|
|||
package codegen
|
||||
|
||||
func divUint64(b uint64) uint64 {
|
||||
// amd64:"SHRQ [$]63, AX"
|
||||
// amd64:"SHRQ [$]63, AX"
|
||||
return b / 9223372036854775808
|
||||
}
|
||||
|
||||
func divUint32(b uint32) uint32 {
|
||||
// amd64:"SHRL [$]31, AX"
|
||||
// amd64:"SHRL [$]31, AX"
|
||||
return b / 2147483648
|
||||
}
|
||||
|
||||
func divUint16(b uint16) uint16 {
|
||||
// amd64:"SHRW [$]15, AX"
|
||||
// amd64:"SHRW [$]15, AX"
|
||||
return b / 32768
|
||||
}
|
||||
|
||||
func divUint8(b uint8) uint8 {
|
||||
// amd64:"SHRB [$]7, AL"
|
||||
// amd64:"SHRB [$]7, AL"
|
||||
return b / 128
|
||||
}
|
||||
|
||||
func modUint64(b uint64) uint64 {
|
||||
// amd64:"BTRQ [$]63, AX"
|
||||
// amd64:"BTRQ [$]63, AX"
|
||||
return b % 9223372036854775808
|
||||
}
|
||||
|
||||
func modUint32(b uint32) uint32 {
|
||||
// amd64:"ANDL [$]2147483647, AX"
|
||||
// amd64:"ANDL [$]2147483647, AX"
|
||||
return b % 2147483648
|
||||
}
|
||||
|
||||
func modUint16(b uint16) uint16 {
|
||||
// amd64:"ANDL [$]32767, AX"
|
||||
// amd64:"ANDL [$]32767, AX"
|
||||
return b % 32768
|
||||
}
|
||||
|
||||
func modUint8(b uint8) uint8 {
|
||||
// amd64:"ANDL [$]127, AX"
|
||||
// amd64:"ANDL [$]127, AX"
|
||||
return b % 128
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,6 +19,6 @@ func (*Impl) A() {}
|
|||
|
||||
func main() {
|
||||
var a M = &Impl{}
|
||||
// amd64:`LEAQ\ttype:.*Impl`
|
||||
// amd64:`LEAQ type:.*Impl`
|
||||
a.(A).A()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,14 +28,14 @@ func ornot(x, y int) int {
|
|||
|
||||
// Verify that (OR (NOT x) (NOT y)) rewrites to (NOT (AND x y))
|
||||
func orDemorgans(x, y int) int {
|
||||
// amd64:"AND",-"OR"
|
||||
// amd64:"AND" -"OR"
|
||||
z := ^x | ^y
|
||||
return z
|
||||
}
|
||||
|
||||
// Verify that (AND (NOT x) (NOT y)) rewrites to (NOT (OR x y))
|
||||
func andDemorgans(x, y int) int {
|
||||
// amd64:"OR",-"AND"
|
||||
// amd64:"OR" -"AND"
|
||||
z := ^x & ^y
|
||||
return z
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,12 +16,12 @@ package codegen
|
|||
// Direct use of constants in fast map access calls (Issue #19015).
|
||||
|
||||
func AccessInt1(m map[int]int) int {
|
||||
// amd64:"MOV[LQ]\t[$]5"
|
||||
// amd64:"MOV[LQ] [$]5"
|
||||
return m[5]
|
||||
}
|
||||
|
||||
func AccessInt2(m map[int]int) bool {
|
||||
// amd64:"MOV[LQ]\t[$]5"
|
||||
// amd64:"MOV[LQ] [$]5"
|
||||
_, ok := m[5]
|
||||
return ok
|
||||
}
|
||||
|
|
@ -147,7 +147,7 @@ func MapClearSideEffect(m map[int]int) int {
|
|||
|
||||
func MapLiteralSizing(x int) (map[int]int, map[int]int) {
|
||||
// This is tested for internal/abi/maps.go:MapBucketCountBits={3,4,5}
|
||||
// amd64:"MOVL\t[$]33,"
|
||||
// amd64:"MOVL [$]33,"
|
||||
m := map[int]int{
|
||||
0: 0,
|
||||
1: 1,
|
||||
|
|
@ -183,7 +183,7 @@ func MapLiteralSizing(x int) (map[int]int, map[int]int) {
|
|||
31: 32,
|
||||
32: 32,
|
||||
}
|
||||
// amd64:"MOVL\t[$]33,"
|
||||
// amd64:"MOVL [$]33,"
|
||||
n := map[int]int{
|
||||
0: 0,
|
||||
1: 1,
|
||||
|
|
|
|||
|
|
@ -12,37 +12,37 @@ var sink64 [8]float64
|
|||
|
||||
func approx(x float64) {
|
||||
// amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41"
|
||||
// amd64:"ROUNDSD\t[$]2"
|
||||
// s390x:"FIDBR\t[$]6"
|
||||
// amd64:"ROUNDSD [$]2"
|
||||
// s390x:"FIDBR [$]6"
|
||||
// arm64:"FRINTPD"
|
||||
// ppc64x:"FRIP"
|
||||
// wasm:"F64Ceil"
|
||||
sink64[0] = math.Ceil(x)
|
||||
|
||||
// amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41"
|
||||
// amd64:"ROUNDSD\t[$]1"
|
||||
// s390x:"FIDBR\t[$]7"
|
||||
// amd64:"ROUNDSD [$]1"
|
||||
// s390x:"FIDBR [$]7"
|
||||
// arm64:"FRINTMD"
|
||||
// ppc64x:"FRIM"
|
||||
// wasm:"F64Floor"
|
||||
sink64[1] = math.Floor(x)
|
||||
|
||||
// s390x:"FIDBR\t[$]1"
|
||||
// s390x:"FIDBR [$]1"
|
||||
// arm64:"FRINTAD"
|
||||
// ppc64x:"FRIN"
|
||||
sink64[2] = math.Round(x)
|
||||
|
||||
// amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41"
|
||||
// amd64:"ROUNDSD\t[$]3"
|
||||
// s390x:"FIDBR\t[$]5"
|
||||
// amd64:"ROUNDSD [$]3"
|
||||
// s390x:"FIDBR [$]5"
|
||||
// arm64:"FRINTZD"
|
||||
// ppc64x:"FRIZ"
|
||||
// wasm:"F64Trunc"
|
||||
sink64[3] = math.Trunc(x)
|
||||
|
||||
// amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41"
|
||||
// amd64:"ROUNDSD\t[$]0"
|
||||
// s390x:"FIDBR\t[$]4"
|
||||
// amd64:"ROUNDSD [$]0"
|
||||
// s390x:"FIDBR [$]4"
|
||||
// arm64:"FRINTND"
|
||||
// wasm:"F64Nearest"
|
||||
sink64[4] = math.RoundToEven(x)
|
||||
|
|
@ -78,43 +78,43 @@ func sqrt32(x float32) float32 {
|
|||
|
||||
// Check that it's using integer registers
|
||||
func abs(x, y float64) {
|
||||
// amd64:"BTRQ\t[$]63"
|
||||
// arm64:"FABSD\t"
|
||||
// loong64:"ABSD\t"
|
||||
// s390x:"LPDFR\t",-"MOVD\t" (no integer load/store)
|
||||
// ppc64x:"FABS\t"
|
||||
// riscv64:"FABSD\t"
|
||||
// amd64:"BTRQ [$]63"
|
||||
// arm64:"FABSD "
|
||||
// loong64:"ABSD "
|
||||
// s390x:"LPDFR " -"MOVD " (no integer load/store)
|
||||
// ppc64x:"FABS "
|
||||
// riscv64:"FABSD "
|
||||
// wasm:"F64Abs"
|
||||
// arm/6:"ABSD\t"
|
||||
// mips64/hardfloat:"ABSD\t"
|
||||
// mips/hardfloat:"ABSD\t"
|
||||
// arm/6:"ABSD "
|
||||
// mips64/hardfloat:"ABSD "
|
||||
// mips/hardfloat:"ABSD "
|
||||
sink64[0] = math.Abs(x)
|
||||
|
||||
// amd64:"BTRQ\t[$]63","PXOR" (TODO: this should be BTSQ)
|
||||
// s390x:"LNDFR\t",-"MOVD\t" (no integer load/store)
|
||||
// ppc64x:"FNABS\t"
|
||||
// amd64:"BTRQ [$]63" "PXOR" (TODO: this should be BTSQ)
|
||||
// s390x:"LNDFR " -"MOVD " (no integer load/store)
|
||||
// ppc64x:"FNABS "
|
||||
sink64[1] = -math.Abs(y)
|
||||
}
|
||||
|
||||
// Check that it's using integer registers
|
||||
func abs32(x float32) float32 {
|
||||
// s390x:"LPDFR",-"LDEBR",-"LEDBR" (no float64 conversion)
|
||||
// s390x:"LPDFR" -"LDEBR" -"LEDBR" (no float64 conversion)
|
||||
return float32(math.Abs(float64(x)))
|
||||
}
|
||||
|
||||
// Check that it's using integer registers
|
||||
func copysign(a, b, c float64) {
|
||||
// amd64:"BTRQ\t[$]63","ANDQ","ORQ"
|
||||
// amd64:"BTRQ [$]63" "ANDQ" "ORQ"
|
||||
// loong64:"FCOPYSGD"
|
||||
// s390x:"CPSDR",-"MOVD" (no integer load/store)
|
||||
// s390x:"CPSDR" -"MOVD" (no integer load/store)
|
||||
// ppc64x:"FCPSGN"
|
||||
// riscv64:"FSGNJD"
|
||||
// wasm:"F64Copysign"
|
||||
sink64[0] = math.Copysign(a, b)
|
||||
|
||||
// amd64:"BTSQ\t[$]63"
|
||||
// amd64:"BTSQ [$]63"
|
||||
// loong64:"FCOPYSGD"
|
||||
// s390x:"LNDFR\t",-"MOVD\t" (no integer load/store)
|
||||
// s390x:"LNDFR " -"MOVD " (no integer load/store)
|
||||
// ppc64x:"FCPSGN"
|
||||
// riscv64:"FSGNJD"
|
||||
// arm64:"ORR", -"AND"
|
||||
|
|
@ -122,12 +122,12 @@ func copysign(a, b, c float64) {
|
|||
|
||||
// Like math.Copysign(c, -1), but with integer operations. Useful
|
||||
// for platforms that have a copysign opcode to see if it's detected.
|
||||
// s390x:"LNDFR\t",-"MOVD\t" (no integer load/store)
|
||||
// s390x:"LNDFR " -"MOVD " (no integer load/store)
|
||||
sink64[2] = math.Float64frombits(math.Float64bits(a) | 1<<63)
|
||||
|
||||
// amd64:"ANDQ","ORQ"
|
||||
// amd64:"ANDQ" "ORQ"
|
||||
// loong64:"FCOPYSGD"
|
||||
// s390x:"CPSDR\t",-"MOVD\t" (no integer load/store)
|
||||
// s390x:"CPSDR " -"MOVD " (no integer load/store)
|
||||
// ppc64x:"FCPSGN"
|
||||
// riscv64:"FSGNJD"
|
||||
sink64[3] = math.Copysign(-1, c)
|
||||
|
|
@ -151,12 +151,12 @@ func fms(x, y, z float64) float64 {
|
|||
}
|
||||
|
||||
func fnms(x, y, z float64) float64 {
|
||||
// riscv64:"FNMSUBD",-"FNMADDD"
|
||||
// riscv64:"FNMSUBD" -"FNMADDD"
|
||||
return math.FMA(-x, y, z)
|
||||
}
|
||||
|
||||
func fnma(x, y, z float64) float64 {
|
||||
// riscv64:"FNMADDD",-"FNMSUBD"
|
||||
// riscv64:"FNMADDD" -"FNMSUBD"
|
||||
return math.FMA(x, -y, -z)
|
||||
}
|
||||
|
||||
|
|
@ -221,39 +221,39 @@ func isNotNegInfCmp(x float64) bool {
|
|||
}
|
||||
|
||||
func fromFloat64(f64 float64) uint64 {
|
||||
// amd64:"MOVQ\tX.*, [^X].*"
|
||||
// arm64:"FMOVD\tF.*, R.*"
|
||||
// loong64:"MOVV\tF.*, R.*"
|
||||
// amd64:"MOVQ X.*, [^X].*"
|
||||
// arm64:"FMOVD F.*, R.*"
|
||||
// loong64:"MOVV F.*, R.*"
|
||||
// ppc64x:"MFVSRD"
|
||||
// mips64/hardfloat:"MOVV\tF.*, R.*"
|
||||
// mips64/hardfloat:"MOVV F.*, R.*"
|
||||
// riscv64:"FMVXD"
|
||||
return math.Float64bits(f64+1) + 1
|
||||
}
|
||||
|
||||
func fromFloat32(f32 float32) uint32 {
|
||||
// amd64:"MOVL\tX.*, [^X].*"
|
||||
// arm64:"FMOVS\tF.*, R.*"
|
||||
// loong64:"MOVW\tF.*, R.*"
|
||||
// mips64/hardfloat:"MOVW\tF.*, R.*"
|
||||
// amd64:"MOVL X.*, [^X].*"
|
||||
// arm64:"FMOVS F.*, R.*"
|
||||
// loong64:"MOVW F.*, R.*"
|
||||
// mips64/hardfloat:"MOVW F.*, R.*"
|
||||
// riscv64:"FMVXW"
|
||||
return math.Float32bits(f32+1) + 1
|
||||
}
|
||||
|
||||
func toFloat64(u64 uint64) float64 {
|
||||
// amd64:"MOVQ\t[^X].*, X.*"
|
||||
// arm64:"FMOVD\tR.*, F.*"
|
||||
// loong64:"MOVV\tR.*, F.*"
|
||||
// amd64:"MOVQ [^X].*, X.*"
|
||||
// arm64:"FMOVD R.*, F.*"
|
||||
// loong64:"MOVV R.*, F.*"
|
||||
// ppc64x:"MTVSRD"
|
||||
// mips64/hardfloat:"MOVV\tR.*, F.*"
|
||||
// mips64/hardfloat:"MOVV R.*, F.*"
|
||||
// riscv64:"FMVDX"
|
||||
return math.Float64frombits(u64+1) + 1
|
||||
}
|
||||
|
||||
func toFloat32(u32 uint32) float32 {
|
||||
// amd64:"MOVL\t[^X].*, X.*"
|
||||
// arm64:"FMOVS\tR.*, F.*"
|
||||
// loong64:"MOVW\tR.*, F.*"
|
||||
// mips64/hardfloat:"MOVW\tR.*, F.*"
|
||||
// amd64:"MOVL [^X].*, X.*"
|
||||
// arm64:"FMOVS R.*, F.*"
|
||||
// loong64:"MOVW R.*, F.*"
|
||||
// mips64/hardfloat:"MOVW R.*, F.*"
|
||||
// riscv64:"FMVWX"
|
||||
return math.Float32frombits(u32+1) + 1
|
||||
}
|
||||
|
|
@ -262,14 +262,14 @@ func toFloat32(u32 uint32) float32 {
|
|||
// are evaluated at compile-time
|
||||
|
||||
func constantCheck64() bool {
|
||||
// amd64:"(MOVB\t[$]0)|(XORL\t[A-Z][A-Z0-9]+, [A-Z][A-Z0-9]+)",-"FCMP",-"MOVB\t[$]1"
|
||||
// s390x:"MOV(B|BZ|D)\t[$]0,",-"FCMPU",-"MOV(B|BZ|D)\t[$]1,"
|
||||
// amd64:"(MOVB [$]0)|(XORL [A-Z][A-Z0-9]+, [A-Z][A-Z0-9]+)" -"FCMP" -"MOVB [$]1"
|
||||
// s390x:"MOV(B|BZ|D) [$]0," -"FCMPU" -"MOV(B|BZ|D) [$]1,"
|
||||
return 0.5 == float64(uint32(1)) || 1.5 > float64(uint64(1<<63))
|
||||
}
|
||||
|
||||
func constantCheck32() bool {
|
||||
// amd64:"MOV(B|L)\t[$]1",-"FCMP",-"MOV(B|L)\t[$]0"
|
||||
// s390x:"MOV(B|BZ|D)\t[$]1,",-"FCMPU",-"MOV(B|BZ|D)\t[$]0,"
|
||||
// amd64:"MOV(B|L) [$]1" -"FCMP" -"MOV(B|L) [$]0"
|
||||
// s390x:"MOV(B|BZ|D) [$]1," -"FCMPU" -"MOV(B|BZ|D) [$]0,"
|
||||
return float32(0.5) <= float32(int64(1)) && float32(1.5) >= float32(int32(-1<<31))
|
||||
}
|
||||
|
||||
|
|
@ -277,12 +277,12 @@ func constantCheck32() bool {
|
|||
// at compile-time
|
||||
|
||||
func constantConvert32(x float32) float32 {
|
||||
// amd64:"MOVSS\t[$]f32.3f800000\\(SB\\)"
|
||||
// s390x:"FMOVS\t[$]f32.3f800000\\(SB\\)"
|
||||
// ppc64x/power8:"FMOVS\t[$]f32.3f800000\\(SB\\)"
|
||||
// ppc64x/power9:"FMOVS\t[$]f32.3f800000\\(SB\\)"
|
||||
// ppc64x/power10:"XXSPLTIDP\t[$]1065353216, VS0"
|
||||
// arm64:"FMOVS\t[$]\\(1.0\\)"
|
||||
// amd64:"MOVSS [$]f32.3f800000\\(SB\\)"
|
||||
// s390x:"FMOVS [$]f32.3f800000\\(SB\\)"
|
||||
// ppc64x/power8:"FMOVS [$]f32.3f800000\\(SB\\)"
|
||||
// ppc64x/power9:"FMOVS [$]f32.3f800000\\(SB\\)"
|
||||
// ppc64x/power10:"XXSPLTIDP [$]1065353216, VS0"
|
||||
// arm64:"FMOVS [$]\\(1.0\\)"
|
||||
if x > math.Float32frombits(0x3f800000) {
|
||||
return -x
|
||||
}
|
||||
|
|
@ -343,7 +343,7 @@ func outOfBoundsConv(i32 *[2]int32, u32 *[2]uint32, i64 *[2]int64, u64 *[2]uint6
|
|||
u32[0] = uint32(two41())
|
||||
// on arm64, this uses an explicit <0 comparison, so it constant folds.
|
||||
// on amd64, this uses an explicit <0 comparison, so it constant folds.
|
||||
// amd64: "MOVL\t[$]0,"
|
||||
// amd64: "MOVL [$]0,"
|
||||
u32[1] = uint32(minus1())
|
||||
// arm64: "FCVTZSD"
|
||||
// amd64: "CVTTSD2SQ"
|
||||
|
|
@ -356,7 +356,7 @@ func outOfBoundsConv(i32 *[2]int32, u32 *[2]uint32, i64 *[2]int64, u64 *[2]uint6
|
|||
u64[0] = uint64(two81())
|
||||
// arm64: "FCVTZUD"
|
||||
// on amd64, this uses an explicit <0 comparison, so it constant folds.
|
||||
// amd64: "MOVQ\t[$]0,"
|
||||
// amd64: "MOVQ [$]0,"
|
||||
u64[1] = uint64(minus1())
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,10 +20,10 @@ func LeadingZeros(n uint) int {
|
|||
// amd64/v3:"LZCNTQ", -"BSRQ"
|
||||
// arm64:"CLZ"
|
||||
// arm:"CLZ"
|
||||
// loong64:"CLZV",-"SUB"
|
||||
// loong64:"CLZV" -"SUB"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"SUB"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"SUB"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.LeadingZeros(n)
|
||||
|
|
@ -34,52 +34,52 @@ func LeadingZeros64(n uint64) int {
|
|||
// amd64/v3:"LZCNTQ", -"BSRQ"
|
||||
// arm:"CLZ"
|
||||
// arm64:"CLZ"
|
||||
// loong64:"CLZV",-"SUB"
|
||||
// loong64:"CLZV" -"SUB"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"ADDI"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"ADDI"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.LeadingZeros64(n)
|
||||
}
|
||||
|
||||
func LeadingZeros32(n uint32) int {
|
||||
// amd64/v1,amd64/v2:"BSRQ","LEAQ",-"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL",- "BSRL"
|
||||
// amd64/v1,amd64/v2:"BSRQ" "LEAQ" -"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL" - "BSRL"
|
||||
// arm:"CLZ"
|
||||
// arm64:"CLZW"
|
||||
// loong64:"CLZW",-"SUB"
|
||||
// loong64:"CLZW" -"SUB"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"CNTLZW"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZW",-"ADDI"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZW" -"ADDI"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.LeadingZeros32(n)
|
||||
}
|
||||
|
||||
func LeadingZeros16(n uint16) int {
|
||||
// amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL",- "BSRL"
|
||||
// amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL" - "BSRL"
|
||||
// arm64:"CLZ"
|
||||
// arm:"CLZ"
|
||||
// loong64:"CLZV"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-48",-"NEG"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-48" -"NEG"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.LeadingZeros16(n)
|
||||
}
|
||||
|
||||
func LeadingZeros8(n uint8) int {
|
||||
// amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL",- "BSRL"
|
||||
// amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL" - "BSRL"
|
||||
// arm64:"CLZ"
|
||||
// arm:"CLZ"
|
||||
// loong64:"CLZV"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-56",-"NEG"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-56" -"NEG"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.LeadingZeros8(n)
|
||||
|
|
@ -96,8 +96,8 @@ func Len(n uint) int {
|
|||
// arm:"CLZ"
|
||||
// loong64:"CLZV"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"SUBC","CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64"
|
||||
// ppc64x:"SUBC" "CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.Len(n)
|
||||
|
|
@ -110,62 +110,62 @@ func Len64(n uint64) int {
|
|||
// arm:"CLZ"
|
||||
// loong64:"CLZV"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"SUBC","CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64"
|
||||
// ppc64x:"SUBC" "CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.Len64(n)
|
||||
}
|
||||
|
||||
func SubFromLen64(n uint64) int {
|
||||
// loong64:"CLZV",-"ADD"
|
||||
// ppc64x:"CNTLZD",-"SUBC"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"ADDI",-"NEG"
|
||||
// loong64:"CLZV" -"ADD"
|
||||
// ppc64x:"CNTLZD" -"SUBC"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"ADDI" -"NEG"
|
||||
return 64 - bits.Len64(n)
|
||||
}
|
||||
|
||||
func CompareWithLen64(n uint64) bool {
|
||||
// loong64:"CLZV",-"ADD",-"[$]64",-"[$]9"
|
||||
// loong64:"CLZV" -"ADD" -"[$]64" -"[$]9"
|
||||
return bits.Len64(n) < 9
|
||||
}
|
||||
|
||||
func Len32(n uint32) int {
|
||||
// amd64/v1,amd64/v2:"BSRQ","LEAQ",-"CMOVQEQ"
|
||||
// amd64/v1,amd64/v2:"BSRQ" "LEAQ" -"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL"
|
||||
// arm64:"CLZ"
|
||||
// arm:"CLZ"
|
||||
// loong64:"CLZW"
|
||||
// mips:"CLZ"
|
||||
// ppc64x: "CNTLZW"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZW","ADDI\t\\$-32"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZW" "ADDI [$]-32"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.Len32(n)
|
||||
}
|
||||
|
||||
func Len16(n uint16) int {
|
||||
// amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ"
|
||||
// amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL"
|
||||
// arm64:"CLZ"
|
||||
// arm:"CLZ"
|
||||
// loong64:"CLZV"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"SUBC","CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64"
|
||||
// ppc64x:"SUBC" "CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.Len16(n)
|
||||
}
|
||||
|
||||
func Len8(n uint8) int {
|
||||
// amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ"
|
||||
// amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ"
|
||||
// amd64/v3: "LZCNTL"
|
||||
// arm64:"CLZ"
|
||||
// arm:"CLZ"
|
||||
// loong64:"CLZV"
|
||||
// mips:"CLZ"
|
||||
// ppc64x:"SUBC","CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64"
|
||||
// ppc64x:"SUBC" "CNTLZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64"
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Clz"
|
||||
return bits.Len8(n)
|
||||
|
|
@ -179,10 +179,10 @@ func Len8(n uint8) int {
|
|||
func OnesCount(n uint) int {
|
||||
// amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT"
|
||||
// amd64:"POPCNTQ"
|
||||
// arm64:"VCNT","VUADDLV"
|
||||
// arm64:"VCNT" "VUADDLV"
|
||||
// loong64:"VPCNTV"
|
||||
// ppc64x:"POPCNTD"
|
||||
// riscv64:"CPOP\t"
|
||||
// riscv64:"CPOP "
|
||||
// s390x:"POPCNT"
|
||||
// wasm:"I64Popcnt"
|
||||
return bits.OnesCount(n)
|
||||
|
|
@ -191,10 +191,10 @@ func OnesCount(n uint) int {
|
|||
func OnesCount64(n uint64) int {
|
||||
// amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT"
|
||||
// amd64:"POPCNTQ"
|
||||
// arm64:"VCNT","VUADDLV"
|
||||
// arm64:"VCNT" "VUADDLV"
|
||||
// loong64:"VPCNTV"
|
||||
// ppc64x:"POPCNTD"
|
||||
// riscv64:"CPOP\t"
|
||||
// riscv64:"CPOP "
|
||||
// s390x:"POPCNT"
|
||||
// wasm:"I64Popcnt"
|
||||
return bits.OnesCount64(n)
|
||||
|
|
@ -203,7 +203,7 @@ func OnesCount64(n uint64) int {
|
|||
func OnesCount32(n uint32) int {
|
||||
// amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT"
|
||||
// amd64:"POPCNTL"
|
||||
// arm64:"VCNT","VUADDLV"
|
||||
// arm64:"VCNT" "VUADDLV"
|
||||
// loong64:"VPCNTW"
|
||||
// ppc64x:"POPCNTW"
|
||||
// riscv64:"CPOPW"
|
||||
|
|
@ -215,10 +215,10 @@ func OnesCount32(n uint32) int {
|
|||
func OnesCount16(n uint16) int {
|
||||
// amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT"
|
||||
// amd64:"POPCNTL"
|
||||
// arm64:"VCNT","VUADDLV"
|
||||
// arm64:"VCNT" "VUADDLV"
|
||||
// loong64:"VPCNTH"
|
||||
// ppc64x:"POPCNTW"
|
||||
// riscv64:"CPOP\t"
|
||||
// riscv64:"CPOP "
|
||||
// s390x:"POPCNT"
|
||||
// wasm:"I64Popcnt"
|
||||
return bits.OnesCount16(n)
|
||||
|
|
@ -226,7 +226,7 @@ func OnesCount16(n uint16) int {
|
|||
|
||||
func OnesCount8(n uint8) int {
|
||||
// ppc64x:"POPCNTB"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CPOP\t"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"CPOP "
|
||||
// s390x:"POPCNT"
|
||||
// wasm:"I64Popcnt"
|
||||
return bits.OnesCount8(n)
|
||||
|
|
@ -252,7 +252,7 @@ func Reverse32(n uint32) uint32 {
|
|||
}
|
||||
|
||||
func Reverse16(n uint16) uint16 {
|
||||
// loong64:"BITREV4B","REVB2H"
|
||||
// loong64:"BITREV4B" "REVB2H"
|
||||
return bits.Reverse16(n)
|
||||
}
|
||||
|
||||
|
|
@ -292,20 +292,20 @@ func ReverseBytes32(n uint32) uint32 {
|
|||
// arm64:"REVW"
|
||||
// loong64:"REVB2W"
|
||||
// ppc64x/power10: "BRW"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"REV8","SRLI\t\\$32"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"REV8" "SRLI [$]32"
|
||||
// s390x:"MOVWBR"
|
||||
return bits.ReverseBytes32(n)
|
||||
}
|
||||
|
||||
func ReverseBytes16(n uint16) uint16 {
|
||||
// amd64:"ROLW"
|
||||
// arm/5:"SLL","SRL","ORR"
|
||||
// arm/5:"SLL" "SRL" "ORR"
|
||||
// arm/6:"REV16"
|
||||
// arm/7:"REV16"
|
||||
// arm64:"REV16W",-"UBFX",-"ORR"
|
||||
// arm64:"REV16W" -"UBFX" -"ORR"
|
||||
// loong64:"REVB2H"
|
||||
// ppc64x/power10: "BRH"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"REV8","SRLI\t\\$48"
|
||||
// riscv64/rva22u64,riscv64/rva23u64:"REV8" "SRLI [$]48"
|
||||
return bits.ReverseBytes16(n)
|
||||
}
|
||||
|
||||
|
|
@ -319,16 +319,16 @@ func RotateLeft64(n uint64) uint64 {
|
|||
// loong64:"ROTRV"
|
||||
// ppc64x:"ROTL"
|
||||
// riscv64:"RORI"
|
||||
// s390x:"RISBGZ\t[$]0, [$]63, [$]37, "
|
||||
// s390x:"RISBGZ [$]0, [$]63, [$]37, "
|
||||
// wasm:"I64Rotl"
|
||||
return bits.RotateLeft64(n, 37)
|
||||
}
|
||||
|
||||
func RotateLeft32(n uint32) uint32 {
|
||||
// amd64:"ROLL" 386:"ROLL"
|
||||
// arm:`MOVW\tR[0-9]+@>23`
|
||||
// arm:`MOVW R[0-9]+@>23`
|
||||
// arm64:"RORW"
|
||||
// loong64:"ROTR\t"
|
||||
// loong64:"ROTR "
|
||||
// ppc64x:"ROTLW"
|
||||
// riscv64:"RORIW"
|
||||
// s390x:"RLL"
|
||||
|
|
@ -338,15 +338,15 @@ func RotateLeft32(n uint32) uint32 {
|
|||
|
||||
func RotateLeft16(n uint16, s int) uint16 {
|
||||
// amd64:"ROLW" 386:"ROLW"
|
||||
// arm64:"RORW",-"CSEL"
|
||||
// loong64:"ROTR\t","SLLV"
|
||||
// arm64:"RORW" -"CSEL"
|
||||
// loong64:"ROTR " "SLLV"
|
||||
return bits.RotateLeft16(n, s)
|
||||
}
|
||||
|
||||
func RotateLeft8(n uint8, s int) uint8 {
|
||||
// amd64:"ROLB" 386:"ROLB"
|
||||
// arm64:"LSL","LSR",-"CSEL"
|
||||
// loong64:"OR","SLLV","SRLV"
|
||||
// arm64:"LSL" "LSR" -"CSEL"
|
||||
// loong64:"OR" "SLLV" "SRLV"
|
||||
return bits.RotateLeft8(n, s)
|
||||
}
|
||||
|
||||
|
|
@ -373,10 +373,10 @@ func RotateLeftVariable64(n uint64, m int) uint64 {
|
|||
}
|
||||
|
||||
func RotateLeftVariable32(n uint32, m int) uint32 {
|
||||
// arm:`MOVW\tR[0-9]+@>R[0-9]+`
|
||||
// arm:`MOVW R[0-9]+@>R[0-9]+`
|
||||
// amd64:"ROLL"
|
||||
// arm64:"RORW"
|
||||
// loong64:"ROTR\t"
|
||||
// loong64:"ROTR "
|
||||
// ppc64x:"ROTLW"
|
||||
// riscv64:"ROLW"
|
||||
// s390x:"RLL"
|
||||
|
|
@ -390,78 +390,78 @@ func RotateLeftVariable32(n uint32, m int) uint32 {
|
|||
|
||||
func TrailingZeros(n uint) int {
|
||||
// 386:"BSFL"
|
||||
// amd64/v1,amd64/v2:"BSFQ","MOVL\t\\$64","CMOVQEQ"
|
||||
// amd64/v1,amd64/v2:"BSFQ" "MOVL [$]64" "CMOVQEQ"
|
||||
// amd64/v3:"TZCNTQ"
|
||||
// arm:"CLZ"
|
||||
// arm64:"RBIT","CLZ"
|
||||
// arm64:"RBIT" "CLZ"
|
||||
// loong64:"CTZV"
|
||||
// ppc64x/power8:"ANDN","POPCNTD"
|
||||
// ppc64x/power8:"ANDN" "POPCNTD"
|
||||
// ppc64x/power9: "CNTTZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ "
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Ctz"
|
||||
return bits.TrailingZeros(n)
|
||||
}
|
||||
|
||||
func TrailingZeros64(n uint64) int {
|
||||
// 386:"BSFL","JNE"
|
||||
// amd64/v1,amd64/v2:"BSFQ","MOVL\t\\$64","CMOVQEQ"
|
||||
// 386:"BSFL" "JNE"
|
||||
// amd64/v1,amd64/v2:"BSFQ" "MOVL [$]64" "CMOVQEQ"
|
||||
// amd64/v3:"TZCNTQ"
|
||||
// arm64:"RBIT","CLZ"
|
||||
// arm64:"RBIT" "CLZ"
|
||||
// loong64:"CTZV"
|
||||
// ppc64x/power8:"ANDN","POPCNTD"
|
||||
// ppc64x/power8:"ANDN" "POPCNTD"
|
||||
// ppc64x/power9: "CNTTZD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ "
|
||||
// s390x:"FLOGR"
|
||||
// wasm:"I64Ctz"
|
||||
return bits.TrailingZeros64(n)
|
||||
}
|
||||
|
||||
func TrailingZeros64Subtract(n uint64) int {
|
||||
// ppc64x/power8:"NEG","SUBC","ANDN","POPCNTD"
|
||||
// ppc64x/power9:"SUBC","CNTTZD"
|
||||
// ppc64x/power8:"NEG" "SUBC" "ANDN" "POPCNTD"
|
||||
// ppc64x/power9:"SUBC" "CNTTZD"
|
||||
return bits.TrailingZeros64(1 - n)
|
||||
}
|
||||
|
||||
func TrailingZeros32(n uint32) int {
|
||||
// 386:"BSFL"
|
||||
// amd64/v1,amd64/v2:"BTSQ\\t\\$32","BSFQ"
|
||||
// amd64/v1,amd64/v2:"BTSQ [$]32" "BSFQ"
|
||||
// amd64/v3:"TZCNTL"
|
||||
// arm:"CLZ"
|
||||
// arm64:"RBITW","CLZW"
|
||||
// arm64:"RBITW" "CLZW"
|
||||
// loong64:"CTZW"
|
||||
// ppc64x/power8:"ANDN","POPCNTW"
|
||||
// ppc64x/power8:"ANDN" "POPCNTW"
|
||||
// ppc64x/power9: "CNTTZW"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZW"
|
||||
// s390x:"FLOGR","MOVWZ"
|
||||
// s390x:"FLOGR" "MOVWZ"
|
||||
// wasm:"I64Ctz"
|
||||
return bits.TrailingZeros32(n)
|
||||
}
|
||||
|
||||
func TrailingZeros16(n uint16) int {
|
||||
// 386:"BSFL\t"
|
||||
// amd64:"BSFL","ORL\\t\\$65536"
|
||||
// arm:"ORR\t\\$65536","CLZ",-"MOVHU\tR"
|
||||
// arm64:"ORR\t\\$65536","RBITW","CLZW",-"MOVHU\tR",-"RBIT\t",-"CLZ\t"
|
||||
// 386:"BSFL "
|
||||
// amd64:"BSFL" "ORL [$]65536"
|
||||
// arm:"ORR [$]65536" "CLZ" -"MOVHU R"
|
||||
// arm64:"ORR [$]65536" "RBITW" "CLZW" -"MOVHU R" -"RBIT " -"CLZ "
|
||||
// loong64:"CTZV"
|
||||
// ppc64x/power8:"POPCNTW","ADD\t\\$-1"
|
||||
// ppc64x/power9:"CNTTZD","ORIS\\t\\$1"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "ORI\t\\$65536","CTZW"
|
||||
// s390x:"FLOGR","OR\t\\$65536"
|
||||
// ppc64x/power8:"POPCNTW" "ADD [$]-1"
|
||||
// ppc64x/power9:"CNTTZD" "ORIS [$]1"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "ORI [$]65536" "CTZW"
|
||||
// s390x:"FLOGR" "OR [$]65536"
|
||||
// wasm:"I64Ctz"
|
||||
return bits.TrailingZeros16(n)
|
||||
}
|
||||
|
||||
func TrailingZeros8(n uint8) int {
|
||||
// 386:"BSFL"
|
||||
// amd64:"BSFL","ORL\\t\\$256"
|
||||
// arm:"ORR\t\\$256","CLZ",-"MOVBU\tR"
|
||||
// arm64:"ORR\t\\$256","RBITW","CLZW",-"MOVBU\tR",-"RBIT\t",-"CLZ\t"
|
||||
// amd64:"BSFL" "ORL [$]256"
|
||||
// arm:"ORR [$]256" "CLZ" -"MOVBU R"
|
||||
// arm64:"ORR [$]256" "RBITW" "CLZW" -"MOVBU R" -"RBIT " -"CLZ "
|
||||
// loong64:"CTZV"
|
||||
// ppc64x/power8:"POPCNTB","ADD\t\\$-1"
|
||||
// ppc64x/power9:"CNTTZD","OR\t\\$256"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "ORI\t\\$256","CTZW"
|
||||
// s390x:"FLOGR","OR\t\\$256"
|
||||
// ppc64x/power8:"POPCNTB" "ADD [$]-1"
|
||||
// ppc64x/power9:"CNTTZD" "OR [$]256"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "ORI [$]256" "CTZW"
|
||||
// s390x:"FLOGR" "OR [$]256"
|
||||
// wasm:"I64Ctz"
|
||||
return bits.TrailingZeros8(n)
|
||||
}
|
||||
|
|
@ -471,7 +471,7 @@ func TrailingZeros8(n uint8) int {
|
|||
func IterateBits(n uint) int {
|
||||
i := 0
|
||||
for n != 0 {
|
||||
// amd64/v1,amd64/v2:"BSFQ",-"CMOVEQ"
|
||||
// amd64/v1,amd64/v2:"BSFQ" -"CMOVEQ"
|
||||
// amd64/v3:"TZCNTQ"
|
||||
i += bits.TrailingZeros(n)
|
||||
n &= n - 1
|
||||
|
|
@ -482,9 +482,9 @@ func IterateBits(n uint) int {
|
|||
func IterateBits64(n uint64) int {
|
||||
i := 0
|
||||
for n != 0 {
|
||||
// amd64/v1,amd64/v2:"BSFQ",-"CMOVEQ"
|
||||
// amd64/v1,amd64/v2:"BSFQ" -"CMOVEQ"
|
||||
// amd64/v3:"TZCNTQ"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ "
|
||||
i += bits.TrailingZeros64(n)
|
||||
n &= n - 1
|
||||
}
|
||||
|
|
@ -494,9 +494,9 @@ func IterateBits64(n uint64) int {
|
|||
func IterateBits32(n uint32) int {
|
||||
i := 0
|
||||
for n != 0 {
|
||||
// amd64/v1,amd64/v2:"BSFL",-"BTSQ"
|
||||
// amd64/v1,amd64/v2:"BSFL" -"BTSQ"
|
||||
// amd64/v3:"TZCNTL"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ "
|
||||
i += bits.TrailingZeros32(n)
|
||||
n &= n - 1
|
||||
}
|
||||
|
|
@ -506,10 +506,10 @@ func IterateBits32(n uint32) int {
|
|||
func IterateBits16(n uint16) int {
|
||||
i := 0
|
||||
for n != 0 {
|
||||
// amd64/v1,amd64/v2:"BSFL",-"BTSL"
|
||||
// amd64/v1,amd64/v2:"BSFL" -"BTSL"
|
||||
// amd64/v3:"TZCNTL"
|
||||
// arm64:"RBITW","CLZW",-"ORR"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t",-"ORR"
|
||||
// arm64:"RBITW" "CLZW" -"ORR"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ " -"ORR"
|
||||
i += bits.TrailingZeros16(n)
|
||||
n &= n - 1
|
||||
}
|
||||
|
|
@ -519,10 +519,10 @@ func IterateBits16(n uint16) int {
|
|||
func IterateBits8(n uint8) int {
|
||||
i := 0
|
||||
for n != 0 {
|
||||
// amd64/v1,amd64/v2:"BSFL",-"BTSL"
|
||||
// amd64/v1,amd64/v2:"BSFL" -"BTSL"
|
||||
// amd64/v3:"TZCNTL"
|
||||
// arm64:"RBITW","CLZW",-"ORR"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t",-"ORR"
|
||||
// arm64:"RBITW" "CLZW" -"ORR"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "CTZ " -"ORR"
|
||||
i += bits.TrailingZeros8(n)
|
||||
n &= n - 1
|
||||
}
|
||||
|
|
@ -534,44 +534,44 @@ func IterateBits8(n uint8) int {
|
|||
// --------------- //
|
||||
|
||||
func Add(x, y, ci uint) (r, co uint) {
|
||||
// arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP"
|
||||
// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
|
||||
// arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP"
|
||||
// amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ"
|
||||
// ppc64x: "ADDC", "ADDE", "ADDZE"
|
||||
// s390x:"ADDE","ADDC\t[$]-1,"
|
||||
// riscv64: "ADD","SLTU"
|
||||
// s390x:"ADDE" "ADDC [$]-1,"
|
||||
// riscv64: "ADD" "SLTU"
|
||||
return bits.Add(x, y, ci)
|
||||
}
|
||||
|
||||
func AddC(x, ci uint) (r, co uint) {
|
||||
// arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP"
|
||||
// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
|
||||
// arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP"
|
||||
// amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ"
|
||||
// loong64: "ADDV", "SGTU"
|
||||
// ppc64x: "ADDC", "ADDE", "ADDZE"
|
||||
// s390x:"ADDE","ADDC\t[$]-1,"
|
||||
// mips64:"ADDV","SGTU"
|
||||
// riscv64: "ADD","SLTU"
|
||||
// s390x:"ADDE" "ADDC [$]-1,"
|
||||
// mips64:"ADDV" "SGTU"
|
||||
// riscv64: "ADD" "SLTU"
|
||||
return bits.Add(x, 7, ci)
|
||||
}
|
||||
|
||||
func AddZ(x, y uint) (r, co uint) {
|
||||
// arm64:"ADDS","ADC",-"ADCS",-"ADD\t",-"CMP"
|
||||
// amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
|
||||
// arm64:"ADDS" "ADC" -"ADCS" -"ADD " -"CMP"
|
||||
// amd64:"ADDQ" "SBBQ" "NEGQ" -"NEGL" -"ADCQ"
|
||||
// loong64: "ADDV", "SGTU"
|
||||
// ppc64x: "ADDC", -"ADDE", "ADDZE"
|
||||
// s390x:"ADDC",-"ADDC\t[$]-1,"
|
||||
// mips64:"ADDV","SGTU"
|
||||
// riscv64: "ADD","SLTU"
|
||||
// s390x:"ADDC" -"ADDC [$]-1,"
|
||||
// mips64:"ADDV" "SGTU"
|
||||
// riscv64: "ADD" "SLTU"
|
||||
return bits.Add(x, y, 0)
|
||||
}
|
||||
|
||||
func AddR(x, y, ci uint) uint {
|
||||
// arm64:"ADDS","ADCS",-"ADD\t",-"CMP"
|
||||
// amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
|
||||
// arm64:"ADDS" "ADCS" -"ADD " -"CMP"
|
||||
// amd64:"NEGL" "ADCQ" -"SBBQ" -"NEGQ"
|
||||
// loong64: "ADDV", -"SGTU"
|
||||
// ppc64x: "ADDC", "ADDE", -"ADDZE"
|
||||
// s390x:"ADDE","ADDC\t[$]-1,"
|
||||
// mips64:"ADDV",-"SGTU"
|
||||
// riscv64: "ADD",-"SLTU"
|
||||
// s390x:"ADDE" "ADDC [$]-1,"
|
||||
// mips64:"ADDV" -"SGTU"
|
||||
// riscv64: "ADD" -"SLTU"
|
||||
r, _ := bits.Add(x, y, ci)
|
||||
return r
|
||||
}
|
||||
|
|
@ -579,54 +579,54 @@ func AddR(x, y, ci uint) uint {
|
|||
func AddM(p, q, r *[3]uint) {
|
||||
var c uint
|
||||
r[0], c = bits.Add(p[0], q[0], c)
|
||||
// arm64:"ADCS",-"ADD\t",-"CMP"
|
||||
// amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
|
||||
// s390x:"ADDE",-"ADDC\t[$]-1,"
|
||||
// arm64:"ADCS" -"ADD " -"CMP"
|
||||
// amd64:"ADCQ" -"NEGL" -"SBBQ" -"NEGQ"
|
||||
// s390x:"ADDE" -"ADDC [$]-1,"
|
||||
r[1], c = bits.Add(p[1], q[1], c)
|
||||
r[2], c = bits.Add(p[2], q[2], c)
|
||||
}
|
||||
|
||||
func Add64(x, y, ci uint64) (r, co uint64) {
|
||||
// arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP"
|
||||
// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
|
||||
// arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP"
|
||||
// amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ"
|
||||
// loong64: "ADDV", "SGTU"
|
||||
// ppc64x: "ADDC", "ADDE", "ADDZE"
|
||||
// s390x:"ADDE","ADDC\t[$]-1,"
|
||||
// mips64:"ADDV","SGTU"
|
||||
// riscv64: "ADD","SLTU"
|
||||
// s390x:"ADDE" "ADDC [$]-1,"
|
||||
// mips64:"ADDV" "SGTU"
|
||||
// riscv64: "ADD" "SLTU"
|
||||
return bits.Add64(x, y, ci)
|
||||
}
|
||||
|
||||
func Add64C(x, ci uint64) (r, co uint64) {
|
||||
// arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP"
|
||||
// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
|
||||
// arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP"
|
||||
// amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ"
|
||||
// loong64: "ADDV", "SGTU"
|
||||
// ppc64x: "ADDC", "ADDE", "ADDZE"
|
||||
// s390x:"ADDE","ADDC\t[$]-1,"
|
||||
// mips64:"ADDV","SGTU"
|
||||
// riscv64: "ADD","SLTU"
|
||||
// s390x:"ADDE" "ADDC [$]-1,"
|
||||
// mips64:"ADDV" "SGTU"
|
||||
// riscv64: "ADD" "SLTU"
|
||||
return bits.Add64(x, 7, ci)
|
||||
}
|
||||
|
||||
func Add64Z(x, y uint64) (r, co uint64) {
|
||||
// arm64:"ADDS","ADC",-"ADCS",-"ADD\t",-"CMP"
|
||||
// amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
|
||||
// arm64:"ADDS" "ADC" -"ADCS" -"ADD " -"CMP"
|
||||
// amd64:"ADDQ" "SBBQ" "NEGQ" -"NEGL" -"ADCQ"
|
||||
// loong64: "ADDV", "SGTU"
|
||||
// ppc64x: "ADDC", -"ADDE", "ADDZE"
|
||||
// s390x:"ADDC",-"ADDC\t[$]-1,"
|
||||
// mips64:"ADDV","SGTU"
|
||||
// riscv64: "ADD","SLTU"
|
||||
// s390x:"ADDC" -"ADDC [$]-1,"
|
||||
// mips64:"ADDV" "SGTU"
|
||||
// riscv64: "ADD" "SLTU"
|
||||
return bits.Add64(x, y, 0)
|
||||
}
|
||||
|
||||
func Add64R(x, y, ci uint64) uint64 {
|
||||
// arm64:"ADDS","ADCS",-"ADD\t",-"CMP"
|
||||
// amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
|
||||
// arm64:"ADDS" "ADCS" -"ADD " -"CMP"
|
||||
// amd64:"NEGL" "ADCQ" -"SBBQ" -"NEGQ"
|
||||
// loong64: "ADDV", -"SGTU"
|
||||
// ppc64x: "ADDC", "ADDE", -"ADDZE"
|
||||
// s390x:"ADDE","ADDC\t[$]-1,"
|
||||
// mips64:"ADDV",-"SGTU"
|
||||
// riscv64: "ADD",-"SLTU"
|
||||
// s390x:"ADDE" "ADDC [$]-1,"
|
||||
// mips64:"ADDV" -"SGTU"
|
||||
// riscv64: "ADD" -"SLTU"
|
||||
r, _ := bits.Add64(x, y, ci)
|
||||
return r
|
||||
}
|
||||
|
|
@ -634,10 +634,10 @@ func Add64R(x, y, ci uint64) uint64 {
|
|||
func Add64M(p, q, r *[3]uint64) {
|
||||
var c uint64
|
||||
r[0], c = bits.Add64(p[0], q[0], c)
|
||||
// arm64:"ADCS",-"ADD\t",-"CMP"
|
||||
// amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
|
||||
// arm64:"ADCS" -"ADD " -"CMP"
|
||||
// amd64:"ADCQ" -"NEGL" -"SBBQ" -"NEGQ"
|
||||
// ppc64x: -"ADDC", "ADDE", -"ADDZE"
|
||||
// s390x:"ADDE",-"ADDC\t[$]-1,"
|
||||
// s390x:"ADDE" -"ADDC [$]-1,"
|
||||
r[1], c = bits.Add64(p[1], q[1], c)
|
||||
r[2], c = bits.Add64(p[2], q[2], c)
|
||||
}
|
||||
|
|
@ -645,22 +645,22 @@ func Add64M(p, q, r *[3]uint64) {
|
|||
func Add64M0(p, q, r *[3]uint64) {
|
||||
var c uint64
|
||||
r[0], c = bits.Add64(p[0], q[0], 0)
|
||||
// ppc64x: -"ADDC", -"ADDE", "ADDZE\tR[1-9]"
|
||||
// ppc64x: -"ADDC", -"ADDE", "ADDZE R[1-9]"
|
||||
r[1], c = bits.Add64(p[1], 0, c)
|
||||
// ppc64x: -"ADDC", "ADDE", -"ADDZE"
|
||||
r[2], c = bits.Add64(p[2], p[2], c)
|
||||
}
|
||||
|
||||
func Add64MSaveC(p, q, r, c *[2]uint64) {
|
||||
// ppc64x: "ADDC\tR", "ADDZE"
|
||||
// ppc64x: "ADDC R", "ADDZE"
|
||||
r[0], c[0] = bits.Add64(p[0], q[0], 0)
|
||||
// ppc64x: "ADDC\t[$]-1", "ADDE", "ADDZE"
|
||||
// ppc64x: "ADDC [$]-1", "ADDE", "ADDZE"
|
||||
r[1], c[1] = bits.Add64(p[1], q[1], c[0])
|
||||
}
|
||||
|
||||
func Add64PanicOnOverflowEQ(a, b uint64) uint64 {
|
||||
r, c := bits.Add64(a, b, 0)
|
||||
// s390x:"BRC\t[$]3,",-"ADDE"
|
||||
// s390x:"BRC [$]3," -"ADDE"
|
||||
if c == 1 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -669,7 +669,7 @@ func Add64PanicOnOverflowEQ(a, b uint64) uint64 {
|
|||
|
||||
func Add64PanicOnOverflowNE(a, b uint64) uint64 {
|
||||
r, c := bits.Add64(a, b, 0)
|
||||
// s390x:"BRC\t[$]3,",-"ADDE"
|
||||
// s390x:"BRC [$]3," -"ADDE"
|
||||
if c != 0 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -678,7 +678,7 @@ func Add64PanicOnOverflowNE(a, b uint64) uint64 {
|
|||
|
||||
func Add64PanicOnOverflowGT(a, b uint64) uint64 {
|
||||
r, c := bits.Add64(a, b, 0)
|
||||
// s390x:"BRC\t[$]3,",-"ADDE"
|
||||
// s390x:"BRC [$]3," -"ADDE"
|
||||
if c > 0 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -690,7 +690,7 @@ func Add64MPanicOnOverflowEQ(a, b [2]uint64) [2]uint64 {
|
|||
var c uint64
|
||||
r[0], c = bits.Add64(a[0], b[0], c)
|
||||
r[1], c = bits.Add64(a[1], b[1], c)
|
||||
// s390x:"BRC\t[$]3,"
|
||||
// s390x:"BRC [$]3,"
|
||||
if c == 1 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -702,7 +702,7 @@ func Add64MPanicOnOverflowNE(a, b [2]uint64) [2]uint64 {
|
|||
var c uint64
|
||||
r[0], c = bits.Add64(a[0], b[0], c)
|
||||
r[1], c = bits.Add64(a[1], b[1], c)
|
||||
// s390x:"BRC\t[$]3,"
|
||||
// s390x:"BRC [$]3,"
|
||||
if c != 0 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -714,7 +714,7 @@ func Add64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 {
|
|||
var c uint64
|
||||
r[0], c = bits.Add64(a[0], b[0], c)
|
||||
r[1], c = bits.Add64(a[1], b[1], c)
|
||||
// s390x:"BRC\t[$]3,"
|
||||
// s390x:"BRC [$]3,"
|
||||
if c > 0 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -737,14 +737,14 @@ func Add64MultipleChains(a, b, c, d [2]uint64) [2]uint64 {
|
|||
b1, b2 := b[0], b[1]
|
||||
c1, c2 := c[0], c[1]
|
||||
|
||||
// ppc64x: "ADDC\tR\\d+,", -"ADDE", -"MOVD\tXER"
|
||||
// ppc64x: "ADDC R\\d+,", -"ADDE", -"MOVD XER"
|
||||
d1, cx = bits.Add64(a1, b1, 0)
|
||||
// ppc64x: "ADDE", -"ADDC", -"MOVD\t.*, XER"
|
||||
// ppc64x: "ADDE", -"ADDC", -"MOVD .*, XER"
|
||||
d2, _ = bits.Add64(a2, b2, cx)
|
||||
|
||||
// ppc64x: "ADDC\tR\\d+,", -"ADDE", -"MOVD\tXER"
|
||||
// ppc64x: "ADDC R\\d+,", -"ADDE", -"MOVD XER"
|
||||
d1, cx = bits.Add64(c1, d1, 0)
|
||||
// ppc64x: "ADDE", -"ADDC", -"MOVD\t.*, XER"
|
||||
// ppc64x: "ADDE", -"ADDC", -"MOVD .*, XER"
|
||||
d2, _ = bits.Add64(c2, d2, cx)
|
||||
d[0] = d1
|
||||
d[1] = d2
|
||||
|
|
@ -756,53 +756,53 @@ func Add64MultipleChains(a, b, c, d [2]uint64) [2]uint64 {
|
|||
// --------------- //
|
||||
|
||||
func Sub(x, y, ci uint) (r, co uint) {
|
||||
// amd64:"NEGL","SBBQ","NEGQ"
|
||||
// arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP"
|
||||
// loong64:"SUBV","SGTU"
|
||||
// amd64:"NEGL" "SBBQ" "NEGQ"
|
||||
// arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP"
|
||||
// loong64:"SUBV" "SGTU"
|
||||
// ppc64x:"SUBC", "SUBE", "SUBZE", "NEG"
|
||||
// s390x:"SUBE"
|
||||
// mips64:"SUBV","SGTU"
|
||||
// riscv64: "SUB","SLTU"
|
||||
// mips64:"SUBV" "SGTU"
|
||||
// riscv64: "SUB" "SLTU"
|
||||
return bits.Sub(x, y, ci)
|
||||
}
|
||||
|
||||
func SubC(x, ci uint) (r, co uint) {
|
||||
// amd64:"NEGL","SBBQ","NEGQ"
|
||||
// arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP"
|
||||
// loong64:"SUBV","SGTU"
|
||||
// amd64:"NEGL" "SBBQ" "NEGQ"
|
||||
// arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP"
|
||||
// loong64:"SUBV" "SGTU"
|
||||
// ppc64x:"SUBC", "SUBE", "SUBZE", "NEG"
|
||||
// s390x:"SUBE"
|
||||
// mips64:"SUBV","SGTU"
|
||||
// riscv64: "SUB","SLTU"
|
||||
// mips64:"SUBV" "SGTU"
|
||||
// riscv64: "SUB" "SLTU"
|
||||
return bits.Sub(x, 7, ci)
|
||||
}
|
||||
|
||||
func SubZ(x, y uint) (r, co uint) {
|
||||
// amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
|
||||
// arm64:"SUBS","NGC","NEG",-"SBCS",-"ADD",-"SUB\t",-"CMP"
|
||||
// loong64:"SUBV","SGTU"
|
||||
// amd64:"SUBQ" "SBBQ" "NEGQ" -"NEGL"
|
||||
// arm64:"SUBS" "NGC" "NEG" -"SBCS" -"ADD" -"SUB " -"CMP"
|
||||
// loong64:"SUBV" "SGTU"
|
||||
// ppc64x:"SUBC", -"SUBE", "SUBZE", "NEG"
|
||||
// s390x:"SUBC"
|
||||
// mips64:"SUBV","SGTU"
|
||||
// riscv64: "SUB","SLTU"
|
||||
// mips64:"SUBV" "SGTU"
|
||||
// riscv64: "SUB" "SLTU"
|
||||
return bits.Sub(x, y, 0)
|
||||
}
|
||||
|
||||
func SubR(x, y, ci uint) uint {
|
||||
// amd64:"NEGL","SBBQ",-"NEGQ"
|
||||
// arm64:"NEGS","SBCS",-"NGC",-"NEG\t",-"ADD",-"SUB",-"CMP"
|
||||
// loong64:"SUBV",-"SGTU"
|
||||
// amd64:"NEGL" "SBBQ" -"NEGQ"
|
||||
// arm64:"NEGS" "SBCS" -"NGC" -"NEG " -"ADD" -"SUB" -"CMP"
|
||||
// loong64:"SUBV" -"SGTU"
|
||||
// ppc64x:"SUBC", "SUBE", -"SUBZE", -"NEG"
|
||||
// s390x:"SUBE"
|
||||
// riscv64: "SUB",-"SLTU"
|
||||
// riscv64: "SUB" -"SLTU"
|
||||
r, _ := bits.Sub(x, y, ci)
|
||||
return r
|
||||
}
|
||||
func SubM(p, q, r *[3]uint) {
|
||||
var c uint
|
||||
r[0], c = bits.Sub(p[0], q[0], c)
|
||||
// amd64:"SBBQ",-"NEGL",-"NEGQ"
|
||||
// arm64:"SBCS",-"NEGS",-"NGC",-"NEG",-"ADD",-"SUB",-"CMP"
|
||||
// amd64:"SBBQ" -"NEGL" -"NEGQ"
|
||||
// arm64:"SBCS" -"NEGS" -"NGC" -"NEG" -"ADD" -"SUB" -"CMP"
|
||||
// ppc64x:-"SUBC", "SUBE", -"SUBZE", -"NEG"
|
||||
// s390x:"SUBE"
|
||||
r[1], c = bits.Sub(p[1], q[1], c)
|
||||
|
|
@ -810,68 +810,68 @@ func SubM(p, q, r *[3]uint) {
|
|||
}
|
||||
|
||||
func Sub64(x, y, ci uint64) (r, co uint64) {
|
||||
// amd64:"NEGL","SBBQ","NEGQ"
|
||||
// arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP"
|
||||
// loong64:"SUBV","SGTU"
|
||||
// amd64:"NEGL" "SBBQ" "NEGQ"
|
||||
// arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP"
|
||||
// loong64:"SUBV" "SGTU"
|
||||
// ppc64x:"SUBC", "SUBE", "SUBZE", "NEG"
|
||||
// s390x:"SUBE"
|
||||
// mips64:"SUBV","SGTU"
|
||||
// riscv64: "SUB","SLTU"
|
||||
// mips64:"SUBV" "SGTU"
|
||||
// riscv64: "SUB" "SLTU"
|
||||
return bits.Sub64(x, y, ci)
|
||||
}
|
||||
|
||||
func Sub64C(x, ci uint64) (r, co uint64) {
|
||||
// amd64:"NEGL","SBBQ","NEGQ"
|
||||
// arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP"
|
||||
// loong64:"SUBV","SGTU"
|
||||
// amd64:"NEGL" "SBBQ" "NEGQ"
|
||||
// arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP"
|
||||
// loong64:"SUBV" "SGTU"
|
||||
// ppc64x:"SUBC", "SUBE", "SUBZE", "NEG"
|
||||
// s390x:"SUBE"
|
||||
// mips64:"SUBV","SGTU"
|
||||
// riscv64: "SUB","SLTU"
|
||||
// mips64:"SUBV" "SGTU"
|
||||
// riscv64: "SUB" "SLTU"
|
||||
return bits.Sub64(x, 7, ci)
|
||||
}
|
||||
|
||||
func Sub64Z(x, y uint64) (r, co uint64) {
|
||||
// amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
|
||||
// arm64:"SUBS","NGC","NEG",-"SBCS",-"ADD",-"SUB\t",-"CMP"
|
||||
// loong64:"SUBV","SGTU"
|
||||
// amd64:"SUBQ" "SBBQ" "NEGQ" -"NEGL"
|
||||
// arm64:"SUBS" "NGC" "NEG" -"SBCS" -"ADD" -"SUB " -"CMP"
|
||||
// loong64:"SUBV" "SGTU"
|
||||
// ppc64x:"SUBC", -"SUBE", "SUBZE", "NEG"
|
||||
// s390x:"SUBC"
|
||||
// mips64:"SUBV","SGTU"
|
||||
// riscv64: "SUB","SLTU"
|
||||
// mips64:"SUBV" "SGTU"
|
||||
// riscv64: "SUB" "SLTU"
|
||||
return bits.Sub64(x, y, 0)
|
||||
}
|
||||
|
||||
func Sub64R(x, y, ci uint64) uint64 {
|
||||
// amd64:"NEGL","SBBQ",-"NEGQ"
|
||||
// arm64:"NEGS","SBCS",-"NGC",-"NEG\t",-"ADD",-"SUB",-"CMP"
|
||||
// loong64:"SUBV",-"SGTU"
|
||||
// amd64:"NEGL" "SBBQ" -"NEGQ"
|
||||
// arm64:"NEGS" "SBCS" -"NGC" -"NEG " -"ADD" -"SUB" -"CMP"
|
||||
// loong64:"SUBV" -"SGTU"
|
||||
// ppc64x:"SUBC", "SUBE", -"SUBZE", -"NEG"
|
||||
// s390x:"SUBE"
|
||||
// riscv64: "SUB",-"SLTU"
|
||||
// riscv64: "SUB" -"SLTU"
|
||||
r, _ := bits.Sub64(x, y, ci)
|
||||
return r
|
||||
}
|
||||
func Sub64M(p, q, r *[3]uint64) {
|
||||
var c uint64
|
||||
r[0], c = bits.Sub64(p[0], q[0], c)
|
||||
// amd64:"SBBQ",-"NEGL",-"NEGQ"
|
||||
// arm64:"SBCS",-"NEGS",-"NGC",-"NEG",-"ADD",-"SUB",-"CMP"
|
||||
// amd64:"SBBQ" -"NEGL" -"NEGQ"
|
||||
// arm64:"SBCS" -"NEGS" -"NGC" -"NEG" -"ADD" -"SUB" -"CMP"
|
||||
// s390x:"SUBE"
|
||||
r[1], c = bits.Sub64(p[1], q[1], c)
|
||||
r[2], c = bits.Sub64(p[2], q[2], c)
|
||||
}
|
||||
|
||||
func Sub64MSaveC(p, q, r, c *[2]uint64) {
|
||||
// ppc64x:"SUBC\tR\\d+, R\\d+,", "SUBZE", "NEG"
|
||||
// ppc64x:"SUBC R\\d+, R\\d+,", "SUBZE", "NEG"
|
||||
r[0], c[0] = bits.Sub64(p[0], q[0], 0)
|
||||
// ppc64x:"SUBC\tR\\d+, [$]0,", "SUBE", "SUBZE", "NEG"
|
||||
// ppc64x:"SUBC R\\d+, [$]0,", "SUBE", "SUBZE", "NEG"
|
||||
r[1], c[1] = bits.Sub64(p[1], q[1], c[0])
|
||||
}
|
||||
|
||||
func Sub64PanicOnOverflowEQ(a, b uint64) uint64 {
|
||||
r, b := bits.Sub64(a, b, 0)
|
||||
// s390x:"BRC\t[$]12,",-"ADDE",-"SUBE"
|
||||
// s390x:"BRC [$]12," -"ADDE" -"SUBE"
|
||||
if b == 1 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -880,7 +880,7 @@ func Sub64PanicOnOverflowEQ(a, b uint64) uint64 {
|
|||
|
||||
func Sub64PanicOnOverflowNE(a, b uint64) uint64 {
|
||||
r, b := bits.Sub64(a, b, 0)
|
||||
// s390x:"BRC\t[$]12,",-"ADDE",-"SUBE"
|
||||
// s390x:"BRC [$]12," -"ADDE" -"SUBE"
|
||||
if b != 0 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -889,7 +889,7 @@ func Sub64PanicOnOverflowNE(a, b uint64) uint64 {
|
|||
|
||||
func Sub64PanicOnOverflowGT(a, b uint64) uint64 {
|
||||
r, b := bits.Sub64(a, b, 0)
|
||||
// s390x:"BRC\t[$]12,",-"ADDE",-"SUBE"
|
||||
// s390x:"BRC [$]12," -"ADDE" -"SUBE"
|
||||
if b > 0 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -901,7 +901,7 @@ func Sub64MPanicOnOverflowEQ(a, b [2]uint64) [2]uint64 {
|
|||
var c uint64
|
||||
r[0], c = bits.Sub64(a[0], b[0], c)
|
||||
r[1], c = bits.Sub64(a[1], b[1], c)
|
||||
// s390x:"BRC\t[$]12,"
|
||||
// s390x:"BRC [$]12,"
|
||||
if c == 1 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -913,7 +913,7 @@ func Sub64MPanicOnOverflowNE(a, b [2]uint64) [2]uint64 {
|
|||
var c uint64
|
||||
r[0], c = bits.Sub64(a[0], b[0], c)
|
||||
r[1], c = bits.Sub64(a[1], b[1], c)
|
||||
// s390x:"BRC\t[$]12,"
|
||||
// s390x:"BRC [$]12,"
|
||||
if c != 0 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -925,7 +925,7 @@ func Sub64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 {
|
|||
var c uint64
|
||||
r[0], c = bits.Sub64(a[0], b[0], c)
|
||||
r[1], c = bits.Sub64(a[1], b[1], c)
|
||||
// s390x:"BRC\t[$]12,"
|
||||
// s390x:"BRC [$]12,"
|
||||
if c > 0 {
|
||||
panic("overflow")
|
||||
}
|
||||
|
|
@ -938,51 +938,51 @@ func Sub64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 {
|
|||
|
||||
func Mul(x, y uint) (hi, lo uint) {
|
||||
// amd64:"MULQ"
|
||||
// arm64:"UMULH","MUL"
|
||||
// loong64:"MULV","MULHVU"
|
||||
// ppc64x:"MULHDU","MULLD"
|
||||
// arm64:"UMULH" "MUL"
|
||||
// loong64:"MULV" "MULHVU"
|
||||
// ppc64x:"MULHDU" "MULLD"
|
||||
// s390x:"MLGR"
|
||||
// mips64: "MULVU"
|
||||
// riscv64:"MULHU","MUL"
|
||||
// riscv64:"MULHU" "MUL"
|
||||
return bits.Mul(x, y)
|
||||
}
|
||||
|
||||
func Mul64(x, y uint64) (hi, lo uint64) {
|
||||
// amd64:"MULQ"
|
||||
// arm64:"UMULH","MUL"
|
||||
// loong64:"MULV","MULHVU"
|
||||
// ppc64x:"MULHDU","MULLD"
|
||||
// arm64:"UMULH" "MUL"
|
||||
// loong64:"MULV" "MULHVU"
|
||||
// ppc64x:"MULHDU" "MULLD"
|
||||
// s390x:"MLGR"
|
||||
// mips64: "MULVU"
|
||||
// riscv64:"MULHU","MUL"
|
||||
// riscv64:"MULHU" "MUL"
|
||||
return bits.Mul64(x, y)
|
||||
}
|
||||
|
||||
func Mul64HiOnly(x, y uint64) uint64 {
|
||||
// arm64:"UMULH",-"MUL"
|
||||
// loong64:"MULHVU",-"MULV"
|
||||
// riscv64:"MULHU",-"MUL\t"
|
||||
// arm64:"UMULH" -"MUL"
|
||||
// loong64:"MULHVU" -"MULV"
|
||||
// riscv64:"MULHU" -"MUL "
|
||||
hi, _ := bits.Mul64(x, y)
|
||||
return hi
|
||||
}
|
||||
|
||||
func Mul64LoOnly(x, y uint64) uint64 {
|
||||
// arm64:"MUL",-"UMULH"
|
||||
// loong64:"MULV",-"MULHVU"
|
||||
// riscv64:"MUL\t",-"MULHU"
|
||||
// arm64:"MUL" -"UMULH"
|
||||
// loong64:"MULV" -"MULHVU"
|
||||
// riscv64:"MUL " -"MULHU"
|
||||
_, lo := bits.Mul64(x, y)
|
||||
return lo
|
||||
}
|
||||
|
||||
func Mul64Const() (uint64, uint64) {
|
||||
// 7133701809754865664 == 99<<56
|
||||
// arm64:"MOVD\t[$]7133701809754865664, R1", "MOVD\t[$]88, R0"
|
||||
// loong64:"MOVV\t[$]88, R4","MOVV\t[$]7133701809754865664, R5",-"MUL"
|
||||
// arm64:"MOVD [$]7133701809754865664, R1", "MOVD [$]88, R0"
|
||||
// loong64:"MOVV [$]88, R4" "MOVV [$]7133701809754865664, R5" -"MUL"
|
||||
return bits.Mul64(99+88<<8, 1<<56)
|
||||
}
|
||||
|
||||
func MulUintOverflow(p *uint64) []uint64 {
|
||||
// arm64:"CMP\t[$]72"
|
||||
// arm64:"CMP [$]72"
|
||||
return unsafe.Slice(p, 9)
|
||||
}
|
||||
|
||||
|
|
@ -996,7 +996,7 @@ func Div(hi, lo, x uint) (q, r uint) {
|
|||
}
|
||||
|
||||
func Div32(hi, lo, x uint32) (q, r uint32) {
|
||||
// arm64:"ORR","UDIV","MSUB",-"UREM"
|
||||
// arm64:"ORR" "UDIV" "MSUB" -"UREM"
|
||||
return bits.Div32(hi, lo, x)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ import (
|
|||
// ------------- //
|
||||
|
||||
func load_le64(b []byte) uint64 {
|
||||
// amd64:`MOVQ\s\(.*\),`,-`MOV[BWL]\t[^$]`,-`OR`
|
||||
// amd64:`MOVQ\s\(.*\),`,-`MOV[BWL] [^$]`,-`OR`
|
||||
// s390x:`MOVDBR\s\(.*\),`
|
||||
// arm64:`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`
|
||||
// loong64:`MOVV\s\(R[0-9]+\),`
|
||||
|
|
@ -26,7 +26,7 @@ func load_le64(b []byte) uint64 {
|
|||
}
|
||||
|
||||
func load_le64_idx(b []byte, idx int) uint64 {
|
||||
// amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL]\t[^$]`,-`OR`
|
||||
// amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL] [^$]`,-`OR`
|
||||
// s390x:`MOVDBR\s\(.*\)\(.*\*1\),`
|
||||
// arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]`
|
||||
// loong64:`MOVV\s\(R[0-9]+\)\(R[0-9]+\),`
|
||||
|
|
@ -78,7 +78,7 @@ func load_le16_idx(b []byte, idx int) uint16 {
|
|||
}
|
||||
|
||||
func load_be64(b []byte) uint64 {
|
||||
// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
|
||||
// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR`
|
||||
// amd64/v3:`MOVBEQ`
|
||||
// s390x:`MOVD\s\(.*\),`
|
||||
// arm64:`REV`,`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W`
|
||||
|
|
@ -88,8 +88,8 @@ func load_be64(b []byte) uint64 {
|
|||
}
|
||||
|
||||
func load_be64_idx(b []byte, idx int) uint64 {
|
||||
// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
|
||||
// amd64/v3: `MOVBEQ\t\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR`
|
||||
// amd64/v3: `MOVBEQ \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// s390x:`MOVD\s\(.*\)\(.*\*1\),`
|
||||
// arm64:`REV`,`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[WHB]`,-`REVW`,-`REV16W`
|
||||
// ppc64le:`MOVDBR`,-`MOV[BHW]Z`
|
||||
|
|
@ -109,7 +109,7 @@ func load_be32(b []byte) uint32 {
|
|||
|
||||
func load_be32_idx(b []byte, idx int) uint32 {
|
||||
// amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR`
|
||||
// amd64/v3: `MOVBEL\t\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// amd64/v3: `MOVBEL \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// s390x:`MOVWZ\s\(.*\)\(.*\*1\),`
|
||||
// arm64:`REVW`,`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[HB]`,-`REV16W`
|
||||
// ppc64le:`MOVWBR`,-`MOV[BH]Z`
|
||||
|
|
@ -136,79 +136,79 @@ func load_be16_idx(b []byte, idx int) uint16 {
|
|||
}
|
||||
|
||||
func load_le_byte2_uint16(s []byte) uint16 {
|
||||
// arm64:`MOVHU\t\(R[0-9]+\)`,-`ORR`,-`MOVB`
|
||||
// arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB`
|
||||
// 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
|
||||
// amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
|
||||
// ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVBZ`
|
||||
// ppc64le:`MOVHZ \(R[0-9]+\)`,-`MOVBZ`
|
||||
// ppc64:`MOVHBR`,-`MOVBZ`
|
||||
return uint16(s[0]) | uint16(s[1])<<8
|
||||
}
|
||||
|
||||
func load_le_byte2_uint16_inv(s []byte) uint16 {
|
||||
// arm64:`MOVHU\t\(R[0-9]+\)`,-`ORR`,-`MOVB`
|
||||
// arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB`
|
||||
// 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
|
||||
// amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
|
||||
// ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVBZ`
|
||||
// ppc64le:`MOVHZ \(R[0-9]+\)`,-`MOVBZ`
|
||||
// ppc64:`MOVHBR`,-`MOVBZ`
|
||||
return uint16(s[1])<<8 | uint16(s[0])
|
||||
}
|
||||
|
||||
func load_le_byte4_uint32(s []byte) uint32 {
|
||||
// arm64:`MOVWU\t\(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
|
||||
// arm64:`MOVWU \(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
|
||||
// 386:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR`
|
||||
// amd64:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR`
|
||||
// ppc64le:`MOVWZ\t\(R[0-9]+\)`,-`MOV[BH]Z`
|
||||
// ppc64le:`MOVWZ \(R[0-9]+\)`,-`MOV[BH]Z`
|
||||
// ppc64:`MOVWBR`,-MOV[BH]Z`
|
||||
return uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 | uint32(s[3])<<24
|
||||
}
|
||||
|
||||
func load_le_byte4_uint32_inv(s []byte) uint32 {
|
||||
// arm64:`MOVWU\t\(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
|
||||
// arm64:`MOVWU \(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
|
||||
// ppc64le:`MOVWZ`,-`MOV[BH]Z`
|
||||
// ppc64:`MOVWBR`,-`MOV[BH]Z`
|
||||
return uint32(s[3])<<24 | uint32(s[2])<<16 | uint32(s[1])<<8 | uint32(s[0])
|
||||
}
|
||||
|
||||
func load_le_byte8_uint64(s []byte) uint64 {
|
||||
// arm64:`MOVD\t\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
|
||||
// amd64:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,-`MOV[BWL]\t[^$]`,-`OR`
|
||||
// ppc64le:`MOVD\t\(R[0-9]+\)`,-`MOV[BHW]Z`
|
||||
// arm64:`MOVD \(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
|
||||
// amd64:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,-`MOV[BWL] [^$]`,-`OR`
|
||||
// ppc64le:`MOVD \(R[0-9]+\)`,-`MOV[BHW]Z`
|
||||
// ppc64:`MOVDBR`,-`MOVW[WHB]Z`
|
||||
return uint64(s[0]) | uint64(s[1])<<8 | uint64(s[2])<<16 | uint64(s[3])<<24 | uint64(s[4])<<32 | uint64(s[5])<<40 | uint64(s[6])<<48 | uint64(s[7])<<56
|
||||
}
|
||||
|
||||
func load_le_byte8_uint64_inv(s []byte) uint64 {
|
||||
// arm64:`MOVD\t\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
|
||||
// arm64:`MOVD \(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
|
||||
// ppc64le:`MOVD`,-`MOV[WHB]Z`
|
||||
// ppc64:`MOVDBR`,-`MOV[WHB]Z`
|
||||
return uint64(s[7])<<56 | uint64(s[6])<<48 | uint64(s[5])<<40 | uint64(s[4])<<32 | uint64(s[3])<<24 | uint64(s[2])<<16 | uint64(s[1])<<8 | uint64(s[0])
|
||||
}
|
||||
|
||||
func load_be_byte2_uint16(s []byte) uint16 {
|
||||
// arm64:`MOVHU\t\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
|
||||
// arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
|
||||
// amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR`
|
||||
// ppc64le:`MOVHBR\t\(R[0-9]+\)`,-`MOVBZ`
|
||||
// ppc64le:`MOVHBR \(R[0-9]+\)`,-`MOVBZ`
|
||||
// ppc64:`MOVHZ`,-`MOVBZ`
|
||||
return uint16(s[0])<<8 | uint16(s[1])
|
||||
}
|
||||
|
||||
func load_be_byte2_uint16_inv(s []byte) uint16 {
|
||||
// arm64:`MOVHU\t\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
|
||||
// arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
|
||||
// amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR`
|
||||
// ppc64le:`MOVHBR\t\(R[0-9]+\)`,-`MOVBZ`
|
||||
// ppc64le:`MOVHBR \(R[0-9]+\)`,-`MOVBZ`
|
||||
// ppc64:`MOVHZ`,-`MOVBZ`
|
||||
return uint16(s[1]) | uint16(s[0])<<8
|
||||
}
|
||||
|
||||
func load_be_byte4_uint32(s []byte) uint32 {
|
||||
// arm64:`MOVWU\t\(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
|
||||
// arm64:`MOVWU \(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
|
||||
// ppc64le:`MOVWBR`,-`MOV[HB]Z`
|
||||
// ppc64:`MOVWZ`,-`MOV[HB]Z`
|
||||
return uint32(s[0])<<24 | uint32(s[1])<<16 | uint32(s[2])<<8 | uint32(s[3])
|
||||
}
|
||||
|
||||
func load_be_byte4_uint32_inv(s []byte) uint32 {
|
||||
// arm64:`MOVWU\t\(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
|
||||
// arm64:`MOVWU \(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
|
||||
// amd64/v1,amd64/v2:`MOVL\s\([A-Z]+\)`,`BSWAPL`,-`MOV[BW]`,-`OR`
|
||||
// amd64/v3: `MOVBEL`
|
||||
// ppc64le:`MOVWBR`,-`MOV[HB]Z`
|
||||
|
|
@ -217,17 +217,17 @@ func load_be_byte4_uint32_inv(s []byte) uint32 {
|
|||
}
|
||||
|
||||
func load_be_byte8_uint64(s []byte) uint64 {
|
||||
// arm64:`MOVD\t\(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
|
||||
// ppc64le:`MOVDBR\t\(R[0-9]+\)`,-`MOV[BHW]Z`
|
||||
// arm64:`MOVD \(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
|
||||
// ppc64le:`MOVDBR \(R[0-9]+\)`,-`MOV[BHW]Z`
|
||||
// ppc64:`MOVD`,-`MOV[WHB]Z`
|
||||
return uint64(s[0])<<56 | uint64(s[1])<<48 | uint64(s[2])<<40 | uint64(s[3])<<32 | uint64(s[4])<<24 | uint64(s[5])<<16 | uint64(s[6])<<8 | uint64(s[7])
|
||||
}
|
||||
|
||||
func load_be_byte8_uint64_inv(s []byte) uint64 {
|
||||
// arm64:`MOVD\t\(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
|
||||
// amd64/v1,amd64/v2:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
|
||||
// arm64:`MOVD \(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
|
||||
// amd64/v1,amd64/v2:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR`
|
||||
// amd64/v3: `MOVBEQ`
|
||||
// ppc64le:`MOVDBR\t\(R[0-9]+\)`,-`MOV[BHW]Z`
|
||||
// ppc64le:`MOVDBR \(R[0-9]+\)`,-`MOV[BHW]Z`
|
||||
// ppc64:`MOVD`,-`MOV[BHW]Z`
|
||||
return uint64(s[7]) | uint64(s[6])<<8 | uint64(s[5])<<16 | uint64(s[4])<<24 | uint64(s[3])<<32 | uint64(s[2])<<40 | uint64(s[1])<<48 | uint64(s[0])<<56
|
||||
}
|
||||
|
|
@ -386,20 +386,20 @@ func fcall_uint32(a [2]uint32) [2]uint32 {
|
|||
// We want to merge load+op in the first function, but not in the
|
||||
// second. See Issue 19595.
|
||||
func load_op_merge(p, q *int) {
|
||||
x := *p // amd64:`ADDQ\t\(`
|
||||
x := *p // amd64:`ADDQ \(`
|
||||
*q += x // The combined nilcheck and load would normally have this line number, but we want that combined operation to have the line number of the nil check instead (see #33724).
|
||||
}
|
||||
func load_op_no_merge(p, q *int) {
|
||||
x := *p
|
||||
for i := 0; i < 10; i++ {
|
||||
*q += x // amd64:`ADDQ\t[A-Z]`
|
||||
*q += x // amd64:`ADDQ [A-Z]`
|
||||
}
|
||||
}
|
||||
|
||||
func load_op_in_loop(a []int) int {
|
||||
r := 0
|
||||
for _, x := range a {
|
||||
// amd64:`ADDQ\t\([A-Z]+\)\([A-Z]+\*8\), [A-Z]+`
|
||||
// amd64:`ADDQ \([A-Z]+\)\([A-Z]+\*8\), [A-Z]+`
|
||||
r += x
|
||||
}
|
||||
return r
|
||||
|
|
@ -407,7 +407,7 @@ func load_op_in_loop(a []int) int {
|
|||
|
||||
// Make sure offsets are folded into loads and stores.
|
||||
func offsets_fold(_, a [20]byte) (b [20]byte) {
|
||||
// arm64:`MOVD\tcommand-line-arguments\.a\+[0-9]+\(FP\), R[0-9]+`,`MOVD\tR[0-9]+, command-line-arguments\.b\+[0-9]+\(FP\)`
|
||||
// arm64:`MOVD command-line-arguments\.a\+[0-9]+\(FP\), R[0-9]+`,`MOVD R[0-9]+, command-line-arguments\.b\+[0-9]+\(FP\)`
|
||||
b = a
|
||||
return
|
||||
}
|
||||
|
|
@ -526,7 +526,7 @@ func store_be64(b []byte, x uint64) {
|
|||
|
||||
func store_be64_idx(b []byte, x uint64, idx int) {
|
||||
// amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.`
|
||||
// amd64/v3:`MOVBEQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// amd64/v3:`MOVBEQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// arm64:`REV`,`MOVD\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`,-`REV16W`,-`REVW`
|
||||
// ppc64le:`MOVDBR`
|
||||
// ppc64:`MOVD\s`
|
||||
|
|
@ -558,7 +558,7 @@ func store_be32_load(b, x *[8]byte) {
|
|||
|
||||
func store_be32_idx(b []byte, x uint32, idx int) {
|
||||
// amd64/v1,amd64/v2:`BSWAPL`,-`SHR.`
|
||||
// amd64/v3:`MOVBEL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// amd64/v3:`MOVBEL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// arm64:`REVW`,`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`,-`REV16W`
|
||||
// ppc64le:`MOVWBR`
|
||||
// ppc64:`MOVW\s`
|
||||
|
|
@ -578,7 +578,7 @@ func store_be16(b []byte, x uint16) {
|
|||
|
||||
func store_be16_idx(b []byte, x uint16, idx int) {
|
||||
// amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.`
|
||||
// amd64/v3:`MOVBEW\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// amd64/v3:`MOVBEW [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`MOVB`
|
||||
// ppc64le:`MOVHBR`
|
||||
// ppc64:`MOVH\s`
|
||||
|
|
@ -736,12 +736,12 @@ func store_le_byte_4_idx4_inv(b []byte, idx int, val uint32) {
|
|||
func zero_byte_2(b1, b2 []byte) {
|
||||
// bounds checks to guarantee safety of writes below
|
||||
_, _ = b1[1], b2[1]
|
||||
// arm64:"MOVH\tZR",-"MOVB"
|
||||
// arm64:"MOVH ZR" -"MOVB"
|
||||
// amd64:`MOVW\s[$]0,\s\([A-Z]+\)`
|
||||
// 386:`MOVW\s[$]0,\s\([A-Z]+\)`
|
||||
// ppc64x:`MOVH\s`
|
||||
b1[0], b1[1] = 0, 0
|
||||
// arm64:"MOVH\tZR",-"MOVB"
|
||||
// arm64:"MOVH ZR" -"MOVB"
|
||||
// 386:`MOVW\s[$]0,\s\([A-Z]+\)`
|
||||
// amd64:`MOVW\s[$]0,\s\([A-Z]+\)`
|
||||
// ppc64x:`MOVH`
|
||||
|
|
@ -750,36 +750,36 @@ func zero_byte_2(b1, b2 []byte) {
|
|||
|
||||
func zero_byte_4(b1, b2 []byte) {
|
||||
_, _ = b1[3], b2[3]
|
||||
// arm64:"MOVW\tZR",-"MOVB",-"MOVH"
|
||||
// arm64:"MOVW ZR" -"MOVB" -"MOVH"
|
||||
// amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
|
||||
// 386:`MOVL\s[$]0,\s\([A-Z]+\)`
|
||||
// ppc64x:`MOVW\s`
|
||||
b1[0], b1[1], b1[2], b1[3] = 0, 0, 0, 0
|
||||
// arm64:"MOVW\tZR",-"MOVB",-"MOVH"
|
||||
// arm64:"MOVW ZR" -"MOVB" -"MOVH"
|
||||
// ppc64x:`MOVW\s`
|
||||
b2[2], b2[3], b2[1], b2[0] = 0, 0, 0, 0
|
||||
}
|
||||
|
||||
func zero_byte_8(b []byte) {
|
||||
_ = b[7]
|
||||
b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
|
||||
b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
|
||||
b[4], b[5], b[6], b[7] = 0, 0, 0, 0
|
||||
}
|
||||
|
||||
func zero_byte_16(b []byte) {
|
||||
_ = b[15]
|
||||
b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH",-"MOVW"
|
||||
b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH" -"MOVW"
|
||||
b[4], b[5], b[6], b[7] = 0, 0, 0, 0
|
||||
b[8], b[9], b[10], b[11] = 0, 0, 0, 0
|
||||
b[12], b[13], b[14], b[15] = 0, 0, 0, 0
|
||||
}
|
||||
|
||||
func zero_byte_30(a *[30]byte) {
|
||||
*a = [30]byte{} // arm64:"STP",-"MOVB",-"MOVH",-"MOVW"
|
||||
*a = [30]byte{} // arm64:"STP" -"MOVB" -"MOVH" -"MOVW"
|
||||
}
|
||||
|
||||
func zero_byte_39(a *[39]byte) {
|
||||
*a = [39]byte{} // arm64:"MOVD",-"MOVB",-"MOVH",-"MOVW"
|
||||
*a = [39]byte{} // arm64:"MOVD" -"MOVB" -"MOVH" -"MOVW"
|
||||
}
|
||||
|
||||
func zero_byte_2_idx(b []byte, idx int) {
|
||||
|
|
@ -798,12 +798,12 @@ func zero_byte_2_idx2(b []byte, idx int) {
|
|||
|
||||
func zero_uint16_2(h1, h2 []uint16) {
|
||||
_, _ = h1[1], h2[1]
|
||||
// arm64:"MOVW\tZR",-"MOVB",-"MOVH"
|
||||
// arm64:"MOVW ZR" -"MOVB" -"MOVH"
|
||||
// amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
|
||||
// 386:`MOVL\s[$]0,\s\([A-Z]+\)`
|
||||
// ppc64x:`MOVW\s`
|
||||
h1[0], h1[1] = 0, 0
|
||||
// arm64:"MOVW\tZR",-"MOVB",-"MOVH"
|
||||
// arm64:"MOVW ZR" -"MOVB" -"MOVH"
|
||||
// amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
|
||||
// 386:`MOVL\s[$]0,\s\([A-Z]+\)`
|
||||
// ppc64x:`MOVW`
|
||||
|
|
@ -812,28 +812,28 @@ func zero_uint16_2(h1, h2 []uint16) {
|
|||
|
||||
func zero_uint16_4(h1, h2 []uint16) {
|
||||
_, _ = h1[3], h2[3]
|
||||
// arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
|
||||
// arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
|
||||
// amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
|
||||
// ppc64x:`MOVD\s`
|
||||
h1[0], h1[1], h1[2], h1[3] = 0, 0, 0, 0
|
||||
// arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
|
||||
// arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
|
||||
// ppc64x:`MOVD\s`
|
||||
h2[2], h2[3], h2[1], h2[0] = 0, 0, 0, 0
|
||||
}
|
||||
|
||||
func zero_uint16_8(h []uint16) {
|
||||
_ = h[7]
|
||||
h[0], h[1], h[2], h[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
|
||||
h[0], h[1], h[2], h[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
|
||||
h[4], h[5], h[6], h[7] = 0, 0, 0, 0
|
||||
}
|
||||
|
||||
func zero_uint32_2(w1, w2 []uint32) {
|
||||
_, _ = w1[1], w2[1]
|
||||
// arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
|
||||
// arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
|
||||
// amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
|
||||
// ppc64x:`MOVD\s`
|
||||
w1[0], w1[1] = 0, 0
|
||||
// arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
|
||||
// arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
|
||||
// amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
|
||||
// ppc64x:`MOVD\s`
|
||||
w2[1], w2[0] = 0, 0
|
||||
|
|
@ -841,22 +841,22 @@ func zero_uint32_2(w1, w2 []uint32) {
|
|||
|
||||
func zero_uint32_4(w1, w2 []uint32) {
|
||||
_, _ = w1[3], w2[3]
|
||||
w1[0], w1[1], w1[2], w1[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
|
||||
w2[2], w2[3], w2[1], w2[0] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
|
||||
w1[0], w1[1], w1[2], w1[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
|
||||
w2[2], w2[3], w2[1], w2[0] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
|
||||
}
|
||||
|
||||
func zero_uint64_2(d1, d2 []uint64) {
|
||||
_, _ = d1[1], d2[1]
|
||||
d1[0], d1[1] = 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
|
||||
d2[1], d2[0] = 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
|
||||
d1[0], d1[1] = 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
|
||||
d2[1], d2[0] = 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
|
||||
}
|
||||
|
||||
func loadstore(p, q *[4]uint8) {
|
||||
// amd64:"MOVL",-"MOVB"
|
||||
// arm64:"MOVWU",-"MOVBU"
|
||||
// amd64:"MOVL" -"MOVB"
|
||||
// arm64:"MOVWU" -"MOVBU"
|
||||
x0, x1, x2, x3 := q[0], q[1], q[2], q[3]
|
||||
// amd64:"MOVL",-"MOVB"
|
||||
// arm64:"MOVW",-"MOVB"
|
||||
// amd64:"MOVL" -"MOVB"
|
||||
// arm64:"MOVW" -"MOVB"
|
||||
p[0], p[1], p[2], p[3] = x0, x1, x2, x3
|
||||
}
|
||||
|
||||
|
|
@ -865,11 +865,11 @@ type S1 struct {
|
|||
}
|
||||
|
||||
func loadstore2(p, q *S1) {
|
||||
// amd64:"MOVL",-"MOVWLZX"
|
||||
// arm64:"MOVWU",-"MOVH"
|
||||
// amd64:"MOVL" -"MOVWLZX"
|
||||
// arm64:"MOVWU" -"MOVH"
|
||||
a, b := p.a, p.b
|
||||
// amd64:"MOVL",-"MOVW"
|
||||
// arm64:"MOVW",-"MOVH"
|
||||
// amd64:"MOVL" -"MOVW"
|
||||
// arm64:"MOVW" -"MOVH"
|
||||
q.a, q.b = a, b
|
||||
}
|
||||
|
||||
|
|
@ -878,11 +878,11 @@ func wideStore(p *[8]uint64) {
|
|||
return
|
||||
}
|
||||
|
||||
// amd64:"MOVUPS",-"MOVQ"
|
||||
// arm64:"STP",-"MOVD"
|
||||
// amd64:"MOVUPS" -"MOVQ"
|
||||
// arm64:"STP" -"MOVD"
|
||||
p[0] = 0
|
||||
// amd64:-"MOVUPS",-"MOVQ"
|
||||
// arm64:-"STP",-"MOVD"
|
||||
// amd64:-"MOVUPS" -"MOVQ"
|
||||
// arm64:-"STP" -"MOVD"
|
||||
p[1] = 0
|
||||
}
|
||||
|
||||
|
|
@ -893,52 +893,52 @@ func wideStore2(p *[8]uint64, x, y uint64) {
|
|||
|
||||
// s390x:"STMG"
|
||||
p[0] = x
|
||||
// s390x:-"STMG",-"MOVD"
|
||||
// s390x:-"STMG" -"MOVD"
|
||||
p[1] = y
|
||||
}
|
||||
|
||||
func store32le(p *struct{ a, b uint32 }, x uint64) {
|
||||
// amd64:"MOVQ",-"MOVL",-"SHRQ"
|
||||
// arm64:"MOVD",-"MOVW",-"LSR"
|
||||
// ppc64le:"MOVD",-"MOVW",-"SRD"
|
||||
// amd64:"MOVQ" -"MOVL" -"SHRQ"
|
||||
// arm64:"MOVD" -"MOVW" -"LSR"
|
||||
// ppc64le:"MOVD" -"MOVW" -"SRD"
|
||||
p.a = uint32(x)
|
||||
// amd64:-"MOVL",-"SHRQ"
|
||||
// arm64:-"MOVW",-"LSR"
|
||||
// ppc64le:-"MOVW",-"SRD"
|
||||
// amd64:-"MOVL" -"SHRQ"
|
||||
// arm64:-"MOVW" -"LSR"
|
||||
// ppc64le:-"MOVW" -"SRD"
|
||||
p.b = uint32(x >> 32)
|
||||
}
|
||||
func store32be(p *struct{ a, b uint32 }, x uint64) {
|
||||
// arm64:"STPW"
|
||||
// ppc64:"MOVD",-"MOVW",-"SRD"
|
||||
// s390x:"MOVD",-"MOVW",-"SRD"
|
||||
// ppc64:"MOVD" -"MOVW" -"SRD"
|
||||
// s390x:"MOVD" -"MOVW" -"SRD"
|
||||
p.a = uint32(x >> 32)
|
||||
// arm64:-"STPW"
|
||||
// ppc64:-"MOVW",-"SRD"
|
||||
// s390x:-"MOVW",-"SRD"
|
||||
// ppc64:-"MOVW" -"SRD"
|
||||
// s390x:-"MOVW" -"SRD"
|
||||
p.b = uint32(x)
|
||||
}
|
||||
func store16le(p *struct{ a, b uint16 }, x uint32) {
|
||||
// amd64:"MOVL",-"MOVW",-"SHRL"
|
||||
// arm64:"MOVW",-"MOVH",-"UBFX"
|
||||
// ppc64le:"MOVW",-"MOVH",-"SRW"
|
||||
// amd64:"MOVL" -"MOVW" -"SHRL"
|
||||
// arm64:"MOVW" -"MOVH" -"UBFX"
|
||||
// ppc64le:"MOVW" -"MOVH" -"SRW"
|
||||
p.a = uint16(x)
|
||||
// amd64:-"MOVW",-"SHRL"
|
||||
// arm64:-"MOVH",-"UBFX"
|
||||
// ppc64le:-"MOVH",-"SRW"
|
||||
// amd64:-"MOVW" -"SHRL"
|
||||
// arm64:-"MOVH" -"UBFX"
|
||||
// ppc64le:-"MOVH" -"SRW"
|
||||
p.b = uint16(x >> 16)
|
||||
}
|
||||
func store16be(p *struct{ a, b uint16 }, x uint32) {
|
||||
// ppc64:"MOVW",-"MOVH",-"SRW"
|
||||
// s390x:"MOVW",-"MOVH",-"SRW"
|
||||
// ppc64:"MOVW" -"MOVH" -"SRW"
|
||||
// s390x:"MOVW" -"MOVH" -"SRW"
|
||||
p.a = uint16(x >> 16)
|
||||
// ppc64:-"MOVH",-"SRW"
|
||||
// s390x:-"MOVH",-"SRW"
|
||||
// ppc64:-"MOVH" -"SRW"
|
||||
// s390x:-"MOVH" -"SRW"
|
||||
p.b = uint16(x)
|
||||
}
|
||||
|
||||
func storeBoolConst(p *struct{ a, b bool }) {
|
||||
// amd64:"MOVW",-"MOVB"
|
||||
// arm64:"MOVH",-"MOVB"
|
||||
// amd64:"MOVW" -"MOVB"
|
||||
// arm64:"MOVH" -"MOVB"
|
||||
p.a = true
|
||||
p.b = true
|
||||
}
|
||||
|
|
@ -948,8 +948,8 @@ func issue66413(p *struct {
|
|||
c bool
|
||||
d int8
|
||||
}) {
|
||||
// amd64:"MOVL",-"MOVB"
|
||||
// arm64:"MOVW",-"MOVB"
|
||||
// amd64:"MOVL" -"MOVB"
|
||||
// arm64:"MOVW" -"MOVB"
|
||||
p.a = 31
|
||||
p.b = false
|
||||
p.c = true
|
||||
|
|
@ -957,7 +957,7 @@ func issue66413(p *struct {
|
|||
}
|
||||
|
||||
func issue70300(v uint64) (b [8]byte) {
|
||||
// amd64:"MOVQ",-"MOVB"
|
||||
// amd64:"MOVQ" -"MOVB"
|
||||
b[0] = byte(v)
|
||||
b[1] = byte(v >> 8)
|
||||
b[2] = byte(v >> 16)
|
||||
|
|
@ -970,7 +970,7 @@ func issue70300(v uint64) (b [8]byte) {
|
|||
}
|
||||
|
||||
func issue70300Reverse(v uint64) (b [8]byte) {
|
||||
// amd64:"MOVQ",-"MOVB"
|
||||
// amd64:"MOVQ" -"MOVB"
|
||||
b[7] = byte(v >> 56)
|
||||
b[6] = byte(v >> 48)
|
||||
b[5] = byte(v >> 40)
|
||||
|
|
@ -987,43 +987,43 @@ func issue70300Reverse(v uint64) (b [8]byte) {
|
|||
// --------------------------------- //
|
||||
|
||||
func dwloadI64(p *struct{ a, b int64 }) int64 {
|
||||
// arm64:"LDP\t"
|
||||
// arm64:"LDP "
|
||||
return p.a + p.b
|
||||
}
|
||||
func dwloadI32(p *struct{ a, b int32 }) int32 {
|
||||
// arm64:"LDPSW\t"
|
||||
// arm64:"LDPSW "
|
||||
return p.a + p.b
|
||||
}
|
||||
func dwloadU32(p *struct{ a, b uint32 }) uint32 {
|
||||
// arm64:"LDPW\t"
|
||||
// arm64:"LDPW "
|
||||
return p.a + p.b
|
||||
}
|
||||
func dwloadF64(p *struct{ a, b float64 }) float64 {
|
||||
// arm64:"FLDPD\t"
|
||||
// arm64:"FLDPD "
|
||||
return p.a + p.b
|
||||
}
|
||||
func dwloadF32(p *struct{ a, b float32 }) float32 {
|
||||
// arm64:"FLDPS\t"
|
||||
// arm64:"FLDPS "
|
||||
return p.a + p.b
|
||||
}
|
||||
|
||||
func dwloadBig(p *struct{ a, b, c, d, e, f int64 }) int64 {
|
||||
// arm64:"LDP\t\\(", "LDP\t16", "LDP\t32"
|
||||
// arm64:"LDP \\(", "LDP 16", "LDP 32"
|
||||
return p.c + p.f + p.a + p.e + p.d + p.b
|
||||
}
|
||||
|
||||
func dwloadArg(a [2]int64) int64 {
|
||||
// arm64:"LDP\t"
|
||||
// arm64:"LDP "
|
||||
return a[0] + a[1]
|
||||
}
|
||||
|
||||
func dwloadResult1(p *string) string {
|
||||
// arm64:"LDP\t\\(R0\\), \\(R0, R1\\)"
|
||||
// arm64:"LDP \\(R0\\), \\(R0, R1\\)"
|
||||
return *p
|
||||
}
|
||||
|
||||
func dwloadResult2(p *[2]int64) (int64, int64) {
|
||||
// arm64:"LDP\t\\(R0\\), \\(R1, R0\\)"
|
||||
// arm64:"LDP \\(R0\\), \\(R1, R0\\)"
|
||||
return p[1], p[0]
|
||||
}
|
||||
|
||||
|
|
@ -1032,22 +1032,22 @@ func dwloadResult2(p *[2]int64) (int64, int64) {
|
|||
// ---------------------------------- //
|
||||
|
||||
func dwstoreI64(p *struct{ a, b int64 }, x, y int64) {
|
||||
// arm64:"STP\t"
|
||||
// arm64:"STP "
|
||||
p.a = x
|
||||
p.b = y
|
||||
}
|
||||
func dwstoreI32(p *struct{ a, b int32 }, x, y int32) {
|
||||
// arm64:"STPW\t"
|
||||
// arm64:"STPW "
|
||||
p.a = x
|
||||
p.b = y
|
||||
}
|
||||
func dwstoreF64(p *struct{ a, b float64 }, x, y float64) {
|
||||
// arm64:"FSTPD\t"
|
||||
// arm64:"FSTPD "
|
||||
p.a = x
|
||||
p.b = y
|
||||
}
|
||||
func dwstoreF32(p *struct{ a, b float32 }, x, y float32) {
|
||||
// arm64:"FSTPS\t"
|
||||
// arm64:"FSTPS "
|
||||
p.a = x
|
||||
p.b = y
|
||||
}
|
||||
|
|
@ -1065,14 +1065,14 @@ func dwstoreBig(p *struct{ a, b, c, d, e, f int64 }, a, b, c, d, e, f int64) {
|
|||
}
|
||||
|
||||
func dwstoreRet() [2]int {
|
||||
// arm64:"STP\t"
|
||||
// arm64:"STP "
|
||||
return [2]int{5, 6}
|
||||
}
|
||||
|
||||
func dwstoreLocal(i int) int64 {
|
||||
var a [2]int64
|
||||
a[0] = 5
|
||||
// arm64:"STP\t"
|
||||
// arm64:"STP "
|
||||
a[1] = 6
|
||||
return a[i]
|
||||
}
|
||||
|
|
@ -1081,7 +1081,7 @@ func dwstoreOrder(p *struct {
|
|||
a, b int64
|
||||
c, d, e, f bool
|
||||
}, a, b int64) {
|
||||
// arm64:"STP\t"
|
||||
// arm64:"STP "
|
||||
p.a = a
|
||||
p.c = true
|
||||
p.e = true
|
||||
|
|
|
|||
|
|
@ -13,23 +13,23 @@ var x32 [2]uint32
|
|||
var x64 [2]uint64
|
||||
|
||||
func compMem1() int {
|
||||
// amd64:`CMPB\tcommand-line-arguments.x\+1\(SB\), [$]0`
|
||||
// amd64:`CMPB command-line-arguments.x\+1\(SB\), [$]0`
|
||||
if x[1] {
|
||||
return 1
|
||||
}
|
||||
// amd64:`CMPB\tcommand-line-arguments.x8\+1\(SB\), [$]7`
|
||||
// amd64:`CMPB command-line-arguments.x8\+1\(SB\), [$]7`
|
||||
if x8[1] == 7 {
|
||||
return 1
|
||||
}
|
||||
// amd64:`CMPW\tcommand-line-arguments.x16\+2\(SB\), [$]7`
|
||||
// amd64:`CMPW command-line-arguments.x16\+2\(SB\), [$]7`
|
||||
if x16[1] == 7 {
|
||||
return 1
|
||||
}
|
||||
// amd64:`CMPL\tcommand-line-arguments.x32\+4\(SB\), [$]7`
|
||||
// amd64:`CMPL command-line-arguments.x32\+4\(SB\), [$]7`
|
||||
if x32[1] == 7 {
|
||||
return 1
|
||||
}
|
||||
// amd64:`CMPQ\tcommand-line-arguments.x64\+8\(SB\), [$]7`
|
||||
// amd64:`CMPQ command-line-arguments.x64\+8\(SB\), [$]7`
|
||||
if x64[1] == 7 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -46,23 +46,23 @@ type T struct {
|
|||
}
|
||||
|
||||
func compMem2(t T) int {
|
||||
// amd64:`CMPB\t.*\(SP\), [$]0`
|
||||
// amd64:`CMPB .*\(SP\), [$]0`
|
||||
if t.x {
|
||||
return 1
|
||||
}
|
||||
// amd64:`CMPB\t.*\(SP\), [$]7`
|
||||
// amd64:`CMPB .*\(SP\), [$]7`
|
||||
if t.x8 == 7 {
|
||||
return 1
|
||||
}
|
||||
// amd64:`CMPW\t.*\(SP\), [$]7`
|
||||
// amd64:`CMPW .*\(SP\), [$]7`
|
||||
if t.x16 == 7 {
|
||||
return 1
|
||||
}
|
||||
// amd64:`CMPL\t.*\(SP\), [$]7`
|
||||
// amd64:`CMPL .*\(SP\), [$]7`
|
||||
if t.x32 == 7 {
|
||||
return 1
|
||||
}
|
||||
// amd64:`CMPQ\t.*\(SP\), [$]7`
|
||||
// amd64:`CMPQ .*\(SP\), [$]7`
|
||||
if t.x64 == 7 {
|
||||
return 1
|
||||
}
|
||||
|
|
@ -73,8 +73,8 @@ func compMem3(x, y *int) (int, bool) {
|
|||
// We can do comparisons of a register with memory even if
|
||||
// the register is used subsequently.
|
||||
r := *x
|
||||
// amd64:`CMPQ\t\(`
|
||||
// 386:`CMPL\t\(`
|
||||
// amd64:`CMPQ \(`
|
||||
// 386:`CMPL \(`
|
||||
return r, r < *y
|
||||
}
|
||||
|
||||
|
|
@ -82,261 +82,261 @@ func compMem3(x, y *int) (int, bool) {
|
|||
|
||||
func idxInt8(x, y []int8, i int) {
|
||||
var t int8
|
||||
// amd64: `MOVBL[SZ]X\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVBL[SZ]X\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVBL[SZ]X 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVBL[SZ]X 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
t = x[i+1]
|
||||
// amd64: `MOVB\t[A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// 386: `MOVB\t[A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// amd64: `MOVB [A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// 386: `MOVB [A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
y[i+1] = t
|
||||
// amd64: `MOVB\t[$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// 386: `MOVB\t[$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// amd64: `MOVB [$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// 386: `MOVB [$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
x[i+1] = 77
|
||||
}
|
||||
|
||||
func idxInt16(x, y []int16, i int) {
|
||||
var t int16
|
||||
// amd64: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
|
||||
t = x[i+1]
|
||||
// amd64: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
|
||||
// 386: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
|
||||
// amd64: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
|
||||
// 386: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
|
||||
y[i+1] = t
|
||||
// amd64: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
|
||||
t = x[16*i+1]
|
||||
// amd64: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
|
||||
// 386: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
|
||||
// amd64: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
|
||||
// 386: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
|
||||
y[16*i+1] = t
|
||||
// amd64: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
|
||||
// 386: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
|
||||
// amd64: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
|
||||
// 386: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
|
||||
x[i+1] = 77
|
||||
// amd64: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
|
||||
// 386: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
|
||||
// amd64: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
|
||||
// 386: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
|
||||
x[16*i+1] = 77
|
||||
}
|
||||
|
||||
func idxInt32(x, y []int32, i int) {
|
||||
var t int32
|
||||
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
t = x[i+1]
|
||||
// amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
y[i+1] = t
|
||||
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
t = x[2*i+1]
|
||||
// amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
y[2*i+1] = t
|
||||
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
|
||||
// 386: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
|
||||
t = x[16*i+1]
|
||||
// amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// 386: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// 386: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
y[16*i+1] = t
|
||||
// amd64: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// amd64: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+1] = 77
|
||||
// amd64: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// 386: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// amd64: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// 386: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
x[16*i+1] = 77
|
||||
}
|
||||
|
||||
func idxInt64(x, y []int64, i int) {
|
||||
var t int64
|
||||
// amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
t = x[i+1]
|
||||
// amd64: `MOVQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `MOVQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
y[i+1] = t
|
||||
// amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
|
||||
t = x[16*i+1]
|
||||
// amd64: `MOVQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
|
||||
// amd64: `MOVQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
|
||||
y[16*i+1] = t
|
||||
// amd64: `MOVQ\t[$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `MOVQ [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+1] = 77
|
||||
// amd64: `MOVQ\t[$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
|
||||
// amd64: `MOVQ [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
|
||||
x[16*i+1] = 77
|
||||
}
|
||||
|
||||
func idxFloat32(x, y []float32, i int) {
|
||||
var t float32
|
||||
// amd64: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
// 386/sse2: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
// arm64: `FMOVS\t\(R[0-9]*\)\(R[0-9]*<<2\), F[0-9]+`
|
||||
// amd64: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
// 386/sse2: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
// arm64: `FMOVS \(R[0-9]*\)\(R[0-9]*<<2\), F[0-9]+`
|
||||
t = x[i+1]
|
||||
// amd64: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386/sse2: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// arm64: `FMOVS\tF[0-9]+, \(R[0-9]*\)\(R[0-9]*<<2\)`
|
||||
// amd64: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386/sse2: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// arm64: `FMOVS F[0-9]+, \(R[0-9]*\)\(R[0-9]*<<2\)`
|
||||
y[i+1] = t
|
||||
// amd64: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
|
||||
// 386/sse2: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
|
||||
// amd64: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
|
||||
// 386/sse2: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
|
||||
t = x[16*i+1]
|
||||
// amd64: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// 386/sse2: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// amd64: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
// 386/sse2: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
|
||||
y[16*i+1] = t
|
||||
}
|
||||
|
||||
func idxFloat64(x, y []float64, i int) {
|
||||
var t float64
|
||||
// amd64: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
// 386/sse2: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
// arm64: `FMOVD\t\(R[0-9]*\)\(R[0-9]*<<3\), F[0-9]+`
|
||||
// amd64: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
// 386/sse2: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
// arm64: `FMOVD \(R[0-9]*\)\(R[0-9]*<<3\), F[0-9]+`
|
||||
t = x[i+1]
|
||||
// amd64: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// 386/sse2: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// arm64: `FMOVD\tF[0-9]+, \(R[0-9]*\)\(R[0-9]*<<3\)`
|
||||
// amd64: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// 386/sse2: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// arm64: `FMOVD F[0-9]+, \(R[0-9]*\)\(R[0-9]*<<3\)`
|
||||
y[i+1] = t
|
||||
// amd64: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
|
||||
// 386/sse2: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
|
||||
// amd64: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
|
||||
// 386/sse2: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
|
||||
t = x[16*i+1]
|
||||
// amd64: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
|
||||
// 386/sse2: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
|
||||
// amd64: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
|
||||
// 386/sse2: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
|
||||
y[16*i+1] = t
|
||||
}
|
||||
|
||||
func idxLoadPlusOp32(x []int32, i int) int32 {
|
||||
s := x[0]
|
||||
// 386: `ADDL\t4\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `ADDL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// 386: `ADDL 4\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `ADDL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s += x[i+1]
|
||||
// 386: `SUBL\t8\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `SUBL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// 386: `SUBL 8\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `SUBL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s -= x[i+2]
|
||||
// 386: `IMULL\t12\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// 386: `IMULL 12\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
s *= x[i+3]
|
||||
// 386: `ANDL\t16\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `ANDL\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// 386: `ANDL 16\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `ANDL 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s &= x[i+4]
|
||||
// 386: `ORL\t20\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `ORL\t20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// 386: `ORL 20\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `ORL 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s |= x[i+5]
|
||||
// 386: `XORL\t24\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `XORL\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// 386: `XORL 24\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
|
||||
// amd64: `XORL 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
s ^= x[i+6]
|
||||
return s
|
||||
}
|
||||
|
||||
func idxLoadPlusOp64(x []int64, i int) int64 {
|
||||
s := x[0]
|
||||
// amd64: `ADDQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `ADDQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s += x[i+1]
|
||||
// amd64: `SUBQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `SUBQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s -= x[i+2]
|
||||
// amd64: `ANDQ\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `ANDQ 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s &= x[i+3]
|
||||
// amd64: `ORQ\t32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `ORQ 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s |= x[i+4]
|
||||
// amd64: `XORQ\t40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `XORQ 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
s ^= x[i+5]
|
||||
return s
|
||||
}
|
||||
|
||||
func idxStorePlusOp32(x []int32, i int, v int32) {
|
||||
// 386: `ADDL\t[A-Z]+, 4\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ADDL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `ADDL [A-Z]+, 4\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ADDL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+1] += v
|
||||
// 386: `SUBL\t[A-Z]+, 8\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `SUBL\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `SUBL [A-Z]+, 8\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `SUBL [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+2] -= v
|
||||
// 386: `ANDL\t[A-Z]+, 12\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ANDL\t[A-Z]+[0-9]*, 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `ANDL [A-Z]+, 12\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ANDL [A-Z]+[0-9]*, 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+3] &= v
|
||||
// 386: `ORL\t[A-Z]+, 16\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ORL\t[A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `ORL [A-Z]+, 16\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ORL [A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+4] |= v
|
||||
// 386: `XORL\t[A-Z]+, 20\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `XORL\t[A-Z]+[0-9]*, 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `XORL [A-Z]+, 20\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `XORL [A-Z]+[0-9]*, 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+5] ^= v
|
||||
|
||||
// 386: `ADDL\t[$]77, 24\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ADDL\t[$]77, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `ADDL [$]77, 24\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ADDL [$]77, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+6] += 77
|
||||
// 386: `ANDL\t[$]77, 28\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ANDL\t[$]77, 28\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `ANDL [$]77, 28\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ANDL [$]77, 28\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+7] &= 77
|
||||
// 386: `ORL\t[$]77, 32\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ORL\t[$]77, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `ORL [$]77, 32\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `ORL [$]77, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+8] |= 77
|
||||
// 386: `XORL\t[$]77, 36\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `XORL\t[$]77, 36\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
// 386: `XORL [$]77, 36\([A-Z]+\)\([A-Z]+\*4\)`
|
||||
// amd64: `XORL [$]77, 36\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
|
||||
x[i+9] ^= 77
|
||||
}
|
||||
|
||||
func idxStorePlusOp64(x []int64, i int, v int64) {
|
||||
// amd64: `ADDQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `ADDQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+1] += v
|
||||
// amd64: `SUBQ\t[A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `SUBQ [A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+2] -= v
|
||||
// amd64: `ANDQ\t[A-Z]+[0-9]*, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `ANDQ [A-Z]+[0-9]*, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+3] &= v
|
||||
// amd64: `ORQ\t[A-Z]+[0-9]*, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `ORQ [A-Z]+[0-9]*, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+4] |= v
|
||||
// amd64: `XORQ\t[A-Z]+[0-9]*, 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `XORQ [A-Z]+[0-9]*, 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+5] ^= v
|
||||
|
||||
// amd64: `ADDQ\t[$]77, 48\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `ADDQ [$]77, 48\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+6] += 77
|
||||
// amd64: `ANDQ\t[$]77, 56\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `ANDQ [$]77, 56\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+7] &= 77
|
||||
// amd64: `ORQ\t[$]77, 64\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `ORQ [$]77, 64\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+8] |= 77
|
||||
// amd64: `XORQ\t[$]77, 72\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
// amd64: `XORQ [$]77, 72\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
|
||||
x[i+9] ^= 77
|
||||
}
|
||||
|
||||
func idxCompare(i int) int {
|
||||
// amd64: `MOVBLZX\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVBLZX 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
if x8[i+1] < x8[0] {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVWLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVWLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
|
||||
if x16[i+1] < x16[0] {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVWLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVWLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
|
||||
if x16[16*i+1] < x16[0] {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
if x32[i+1] < x32[0] {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
|
||||
if x32[16*i+1] < x32[0] {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
if x64[i+1] < x64[0] {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
|
||||
if x64[16*i+1] < x64[0] {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVBLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVBLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
|
||||
if x8[i+2] < 77 {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVWLZX\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVWLZX 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
|
||||
if x16[i+2] < 77 {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVWLZX\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVWLZX 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
|
||||
if x16[16*i+2] < 77 {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
|
||||
if x32[i+2] < 77 {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
|
||||
if x32[16*i+2] < 77 {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
|
||||
if x64[i+2] < 77 {
|
||||
return 0
|
||||
}
|
||||
// amd64: `MOVQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
|
||||
// amd64: `MOVQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
|
||||
if x64[16*i+2] < 77 {
|
||||
return 0
|
||||
}
|
||||
|
|
@ -345,59 +345,59 @@ func idxCompare(i int) int {
|
|||
|
||||
func idxFloatOps(a []float64, b []float32, i int) (float64, float32) {
|
||||
c := float64(7)
|
||||
// amd64: `ADDSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
// amd64: `ADDSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
c += a[i+1]
|
||||
// amd64: `SUBSD\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
// amd64: `SUBSD 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
c -= a[i+2]
|
||||
// amd64: `MULSD\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
// amd64: `MULSD 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
c *= a[i+3]
|
||||
// amd64: `DIVSD\t32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
// amd64: `DIVSD 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
|
||||
c /= a[i+4]
|
||||
|
||||
d := float32(8)
|
||||
// amd64: `ADDSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
// amd64: `ADDSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
d += b[i+1]
|
||||
// amd64: `SUBSS\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
// amd64: `SUBSS 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
d -= b[i+2]
|
||||
// amd64: `MULSS\t12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
// amd64: `MULSS 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
d *= b[i+3]
|
||||
// amd64: `DIVSS\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
// amd64: `DIVSS 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
|
||||
d /= b[i+4]
|
||||
return c, d
|
||||
}
|
||||
|
||||
func storeTest(a []bool, v int, i int) {
|
||||
// amd64: `BTL\t\$0,`,`SETCS\t4\([A-Z]+[0-9]*\)`
|
||||
// amd64: `BTL \$0,`,`SETCS 4\([A-Z]+[0-9]*\)`
|
||||
a[4] = v&1 != 0
|
||||
// amd64: `BTL\t\$1,`,`SETCS\t3\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
// amd64: `BTL \$1,`,`SETCS 3\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
|
||||
a[3+i] = v&2 != 0
|
||||
}
|
||||
|
||||
func bitOps(p *[12]uint64) {
|
||||
// amd64: `ORQ\t\$8, \(AX\)`
|
||||
// amd64: `ORQ \$8, \(AX\)`
|
||||
p[0] |= 8
|
||||
// amd64: `ORQ\t\$1073741824, 8\(AX\)`
|
||||
// amd64: `ORQ \$1073741824, 8\(AX\)`
|
||||
p[1] |= 1 << 30
|
||||
// amd64: `BTSQ\t\$31, 16\(AX\)`
|
||||
// amd64: `BTSQ \$31, 16\(AX\)`
|
||||
p[2] |= 1 << 31
|
||||
// amd64: `BTSQ\t\$63, 24\(AX\)`
|
||||
// amd64: `BTSQ \$63, 24\(AX\)`
|
||||
p[3] |= 1 << 63
|
||||
|
||||
// amd64: `ANDQ\t\$-9, 32\(AX\)`
|
||||
// amd64: `ANDQ \$-9, 32\(AX\)`
|
||||
p[4] &^= 8
|
||||
// amd64: `ANDQ\t\$-1073741825, 40\(AX\)`
|
||||
// amd64: `ANDQ \$-1073741825, 40\(AX\)`
|
||||
p[5] &^= 1 << 30
|
||||
// amd64: `BTRQ\t\$31, 48\(AX\)`
|
||||
// amd64: `BTRQ \$31, 48\(AX\)`
|
||||
p[6] &^= 1 << 31
|
||||
// amd64: `BTRQ\t\$63, 56\(AX\)`
|
||||
// amd64: `BTRQ \$63, 56\(AX\)`
|
||||
p[7] &^= 1 << 63
|
||||
|
||||
// amd64: `XORQ\t\$8, 64\(AX\)`
|
||||
// amd64: `XORQ \$8, 64\(AX\)`
|
||||
p[8] ^= 8
|
||||
// amd64: `XORQ\t\$1073741824, 72\(AX\)`
|
||||
// amd64: `XORQ \$1073741824, 72\(AX\)`
|
||||
p[9] ^= 1 << 30
|
||||
// amd64: `BTCQ\t\$31, 80\(AX\)`
|
||||
// amd64: `BTCQ \$31, 80\(AX\)`
|
||||
p[10] ^= 1 << 31
|
||||
// amd64: `BTCQ\t\$63, 88\(AX\)`
|
||||
// amd64: `BTCQ \$63, 88\(AX\)`
|
||||
p[11] ^= 1 << 63
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,8 +11,8 @@ package codegen
|
|||
|
||||
func m0(x int64) int64 {
|
||||
// amd64: "XORL"
|
||||
// arm64: "MOVD\tZR"
|
||||
// loong64: "MOVV\tR0"
|
||||
// arm64: "MOVD ZR"
|
||||
// loong64: "MOVV R0"
|
||||
return x * 0
|
||||
}
|
||||
func m2(x int64) int64 {
|
||||
|
|
@ -22,351 +22,351 @@ func m2(x int64) int64 {
|
|||
return x * 2
|
||||
}
|
||||
func m3(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]2"
|
||||
// arm64: "ADD\tR[0-9]+<<1,"
|
||||
// loong64: "ALSLV\t[$]1,"
|
||||
// amd64: "LEAQ .*[*]2"
|
||||
// arm64: "ADD R[0-9]+<<1,"
|
||||
// loong64: "ALSLV [$]1,"
|
||||
return x * 3
|
||||
}
|
||||
func m4(x int64) int64 {
|
||||
// amd64: "SHLQ\t[$]2,"
|
||||
// arm64: "LSL\t[$]2,"
|
||||
// loong64: "SLLV\t[$]2,"
|
||||
// amd64: "SHLQ [$]2,"
|
||||
// arm64: "LSL [$]2,"
|
||||
// loong64: "SLLV [$]2,"
|
||||
return x * 4
|
||||
}
|
||||
func m5(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]4"
|
||||
// arm64: "ADD\tR[0-9]+<<2,"
|
||||
// loong64: "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]4"
|
||||
// arm64: "ADD R[0-9]+<<2,"
|
||||
// loong64: "ALSLV [$]2,"
|
||||
return x * 5
|
||||
}
|
||||
func m6(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]2"
|
||||
// arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<1,"
|
||||
// amd64: "LEAQ .*[*]1", "LEAQ .*[*]2"
|
||||
// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<1,"
|
||||
// loong64: "ADDVU", "ADDVU", "ADDVU"
|
||||
return x * 6
|
||||
}
|
||||
func m7(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]2"
|
||||
// arm64: "LSL\t[$]3,", "SUB\tR[0-9]+,"
|
||||
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]1,"
|
||||
// amd64: "LEAQ .*[*]2"
|
||||
// arm64: "LSL [$]3,", "SUB R[0-9]+,"
|
||||
// loong64: "ALSLV [$]1,", "ALSLV [$]1,"
|
||||
return x * 7
|
||||
}
|
||||
func m8(x int64) int64 {
|
||||
// amd64: "SHLQ\t[$]3,"
|
||||
// arm64: "LSL\t[$]3,"
|
||||
// loong64: "SLLV\t[$]3,"
|
||||
// amd64: "SHLQ [$]3,"
|
||||
// arm64: "LSL [$]3,"
|
||||
// loong64: "SLLV [$]3,"
|
||||
return x * 8
|
||||
}
|
||||
func m9(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]8"
|
||||
// arm64: "ADD\tR[0-9]+<<3,"
|
||||
// loong64: "ALSLV\t[$]3,"
|
||||
// amd64: "LEAQ .*[*]8"
|
||||
// arm64: "ADD R[0-9]+<<3,"
|
||||
// loong64: "ALSLV [$]3,"
|
||||
return x * 9
|
||||
}
|
||||
func m10(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]4"
|
||||
// arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<2,"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]1", "LEAQ .*[*]4"
|
||||
// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<2,"
|
||||
// loong64: "ADDVU", "ALSLV [$]2,"
|
||||
return x * 10
|
||||
}
|
||||
func m11(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]4", "LEAQ\t.*[*]2"
|
||||
// arm64: "MOVD\t[$]11,", "MUL"
|
||||
// loong64: "ALSLV\t[$]2,", "ALSLV\t[$]1,"
|
||||
// amd64: "LEAQ .*[*]4", "LEAQ .*[*]2"
|
||||
// arm64: "MOVD [$]11,", "MUL"
|
||||
// loong64: "ALSLV [$]2,", "ALSLV [$]1,"
|
||||
return x * 11
|
||||
}
|
||||
func m12(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]2", "SHLQ\t[$]2,"
|
||||
// arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<1,"
|
||||
// loong64: "SLLV", "ALSLV\t[$]1,"
|
||||
// amd64: "LEAQ .*[*]2", "SHLQ [$]2,"
|
||||
// arm64: "LSL [$]2,", "ADD R[0-9]+<<1,"
|
||||
// loong64: "SLLV", "ALSLV [$]1,"
|
||||
return x * 12
|
||||
}
|
||||
func m13(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]2", "LEAQ\t.*[*]4"
|
||||
// arm64: "MOVD\t[$]13,", "MUL"
|
||||
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]2", "LEAQ .*[*]4"
|
||||
// arm64: "MOVD [$]13,", "MUL"
|
||||
// loong64: "ALSLV [$]1,", "ALSLV [$]2,"
|
||||
return x * 13
|
||||
}
|
||||
func m14(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]14,"
|
||||
// arm64: "LSL\t[$]4,", "SUB\tR[0-9]+<<1,"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]1", "ALSLV\t[$]2"
|
||||
// amd64: "IMUL3Q [$]14,"
|
||||
// arm64: "LSL [$]4,", "SUB R[0-9]+<<1,"
|
||||
// loong64: "ADDVU", "ALSLV [$]1", "ALSLV [$]2"
|
||||
return x * 14
|
||||
}
|
||||
func m15(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]2", "LEAQ\t.*[*]4"
|
||||
// arm64: "LSL\t[$]4,", "SUB\tR[0-9]+,"
|
||||
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]2", "LEAQ .*[*]4"
|
||||
// arm64: "LSL [$]4,", "SUB R[0-9]+,"
|
||||
// loong64: "ALSLV [$]1,", "ALSLV [$]2,"
|
||||
return x * 15
|
||||
}
|
||||
func m16(x int64) int64 {
|
||||
// amd64: "SHLQ\t[$]4,"
|
||||
// arm64: "LSL\t[$]4,"
|
||||
// loong64: "SLLV\t[$]4,"
|
||||
// amd64: "SHLQ [$]4,"
|
||||
// arm64: "LSL [$]4,"
|
||||
// loong64: "SLLV [$]4,"
|
||||
return x * 16
|
||||
}
|
||||
func m17(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]8"
|
||||
// arm64: "ADD\tR[0-9]+<<4,"
|
||||
// loong64: "ALSLV\t[$]"
|
||||
// amd64: "LEAQ .*[*]1", "LEAQ .*[*]8"
|
||||
// arm64: "ADD R[0-9]+<<4,"
|
||||
// loong64: "ALSLV [$]"
|
||||
return x * 17
|
||||
}
|
||||
func m18(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]8"
|
||||
// arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<3,"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]3,"
|
||||
// amd64: "LEAQ .*[*]1", "LEAQ .*[*]8"
|
||||
// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<3,"
|
||||
// loong64: "ADDVU", "ALSLV [$]3,"
|
||||
return x * 18
|
||||
}
|
||||
func m19(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]8", "LEAQ\t.*[*]2"
|
||||
// arm64: "MOVD\t[$]19,", "MUL"
|
||||
// loong64: "ALSLV\t[$]3,", "ALSLV\t[$]1,"
|
||||
// amd64: "LEAQ .*[*]8", "LEAQ .*[*]2"
|
||||
// arm64: "MOVD [$]19,", "MUL"
|
||||
// loong64: "ALSLV [$]3,", "ALSLV [$]1,"
|
||||
return x * 19
|
||||
}
|
||||
func m20(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]4", "SHLQ\t[$]2,"
|
||||
// arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<2,"
|
||||
// loong64: "SLLV\t[$]2,", "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]4", "SHLQ [$]2,"
|
||||
// arm64: "LSL [$]2,", "ADD R[0-9]+<<2,"
|
||||
// loong64: "SLLV [$]2,", "ALSLV [$]2,"
|
||||
return x * 20
|
||||
}
|
||||
func m21(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]4", "LEAQ\t.*[*]4"
|
||||
// arm64: "MOVD\t[$]21,", "MUL"
|
||||
// loong64: "ALSLV\t[$]2,", "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]4", "LEAQ .*[*]4"
|
||||
// arm64: "MOVD [$]21,", "MUL"
|
||||
// loong64: "ALSLV [$]2,", "ALSLV [$]2,"
|
||||
return x * 21
|
||||
}
|
||||
func m22(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]22,"
|
||||
// arm64: "MOVD\t[$]22,", "MUL"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]2,", "ALSLV\t[$]2,"
|
||||
// amd64: "IMUL3Q [$]22,"
|
||||
// arm64: "MOVD [$]22,", "MUL"
|
||||
// loong64: "ADDVU", "ALSLV [$]2,", "ALSLV [$]2,"
|
||||
return x * 22
|
||||
}
|
||||
func m23(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]23,"
|
||||
// arm64: "MOVD\t[$]23,", "MUL"
|
||||
// loong64: "ALSLV\t[$]1,", "SUBVU", "ALSLV\t[$]3,"
|
||||
// amd64: "IMUL3Q [$]23,"
|
||||
// arm64: "MOVD [$]23,", "MUL"
|
||||
// loong64: "ALSLV [$]1,", "SUBVU", "ALSLV [$]3,"
|
||||
return x * 23
|
||||
}
|
||||
func m24(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]2", "SHLQ\t[$]3,"
|
||||
// arm64: "LSL\t[$]3,", "ADD\tR[0-9]+<<1,"
|
||||
// loong64: "SLLV\t[$]3", "ALSLV\t[$]1,"
|
||||
// amd64: "LEAQ .*[*]2", "SHLQ [$]3,"
|
||||
// arm64: "LSL [$]3,", "ADD R[0-9]+<<1,"
|
||||
// loong64: "SLLV [$]3", "ALSLV [$]1,"
|
||||
return x * 24
|
||||
}
|
||||
func m25(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]4", "LEAQ\t.*[*]4"
|
||||
// arm64: "MOVD\t[$]25,", "MUL"
|
||||
// loong64: "ALSLV\t[$]2,", "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]4", "LEAQ .*[*]4"
|
||||
// arm64: "MOVD [$]25,", "MUL"
|
||||
// loong64: "ALSLV [$]2,", "ALSLV [$]2,"
|
||||
return x * 25
|
||||
}
|
||||
func m26(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]26,"
|
||||
// arm64: "MOVD\t[$]26,", "MUL"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]1,", "ALSLV\t[$]3,"
|
||||
// amd64: "IMUL3Q [$]26,"
|
||||
// arm64: "MOVD [$]26,", "MUL"
|
||||
// loong64: "ADDVU", "ALSLV [$]1,", "ALSLV [$]3,"
|
||||
return x * 26
|
||||
}
|
||||
func m27(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]2", "LEAQ\t.*[*]8"
|
||||
// arm64: "MOVD\t[$]27,", "MUL"
|
||||
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]3,"
|
||||
// amd64: "LEAQ .*[*]2", "LEAQ .*[*]8"
|
||||
// arm64: "MOVD [$]27,", "MUL"
|
||||
// loong64: "ALSLV [$]1,", "ALSLV [$]3,"
|
||||
return x * 27
|
||||
}
|
||||
func m28(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]28,"
|
||||
// arm64: "LSL\t[$]5, "SUB\tR[0-9]+<<2,"
|
||||
// loong64: "ALSLV\t[$]1,","SLLV\t[$]2,","ALSLV\t[$]3,"
|
||||
// amd64: "IMUL3Q [$]28,"
|
||||
// arm64: "LSL [$]5, "SUB R[0-9]+<<2,"
|
||||
// loong64: "ALSLV [$]1," "SLLV [$]2," "ALSLV [$]3,"
|
||||
return x * 28
|
||||
}
|
||||
func m29(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]29,"
|
||||
// arm64: "MOVD\t[$]29,", "MUL"
|
||||
// loong64: "ALSLV\t[$]1,","SLLV\t[$]5,","SUBVU"
|
||||
// amd64: "IMUL3Q [$]29,"
|
||||
// arm64: "MOVD [$]29,", "MUL"
|
||||
// loong64: "ALSLV [$]1," "SLLV [$]5," "SUBVU"
|
||||
return x * 29
|
||||
}
|
||||
func m30(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]30,"
|
||||
// arm64: "LSL\t[$]5,", "SUB\tR[0-9]+<<1,"
|
||||
// loong64: "ADDVU","SLLV\t[$]5,","SUBVU"
|
||||
// amd64: "IMUL3Q [$]30,"
|
||||
// arm64: "LSL [$]5,", "SUB R[0-9]+<<1,"
|
||||
// loong64: "ADDVU" "SLLV [$]5," "SUBVU"
|
||||
return x * 30
|
||||
}
|
||||
func m31(x int64) int64 {
|
||||
// amd64: "SHLQ\t[$]5,", "SUBQ"
|
||||
// arm64: "LSL\t[$]5,", "SUB\tR[0-9]+,"
|
||||
// loong64: "SLLV\t[$]5,","SUBVU"
|
||||
// amd64: "SHLQ [$]5,", "SUBQ"
|
||||
// arm64: "LSL [$]5,", "SUB R[0-9]+,"
|
||||
// loong64: "SLLV [$]5," "SUBVU"
|
||||
return x * 31
|
||||
}
|
||||
func m32(x int64) int64 {
|
||||
// amd64: "SHLQ\t[$]5,"
|
||||
// arm64: "LSL\t[$]5,"
|
||||
// loong64: "SLLV\t[$]5,"
|
||||
// amd64: "SHLQ [$]5,"
|
||||
// arm64: "LSL [$]5,"
|
||||
// loong64: "SLLV [$]5,"
|
||||
return x * 32
|
||||
}
|
||||
func m33(x int64) int64 {
|
||||
// amd64: "SHLQ\t[$]2,", "LEAQ\t.*[*]8"
|
||||
// arm64: "ADD\tR[0-9]+<<5,"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]4,"
|
||||
// amd64: "SHLQ [$]2,", "LEAQ .*[*]8"
|
||||
// arm64: "ADD R[0-9]+<<5,"
|
||||
// loong64: "ADDVU", "ALSLV [$]4,"
|
||||
return x * 33
|
||||
}
|
||||
func m34(x int64) int64 {
|
||||
// amd64: "SHLQ\t[$]5,", "LEAQ\t.*[*]2"
|
||||
// arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<4,"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]4,"
|
||||
// amd64: "SHLQ [$]5,", "LEAQ .*[*]2"
|
||||
// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<4,"
|
||||
// loong64: "ADDVU", "ALSLV [$]4,"
|
||||
return x * 34
|
||||
}
|
||||
func m35(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]35,"
|
||||
// arm64: "MOVD\t[$]35,", "MUL"
|
||||
// loong64: "ALSLV\t[$]4,", "ALSLV\t[$]1,"
|
||||
// amd64: "IMUL3Q [$]35,"
|
||||
// arm64: "MOVD [$]35,", "MUL"
|
||||
// loong64: "ALSLV [$]4,", "ALSLV [$]1,"
|
||||
return x * 35
|
||||
}
|
||||
func m36(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]8", "SHLQ\t[$]2,"
|
||||
// arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<3,"
|
||||
// loong64: "SLLV\t[$]2,", "ALSLV\t[$]3,"
|
||||
// amd64: "LEAQ .*[*]8", "SHLQ [$]2,"
|
||||
// arm64: "LSL [$]2,", "ADD R[0-9]+<<3,"
|
||||
// loong64: "SLLV [$]2,", "ALSLV [$]3,"
|
||||
return x * 36
|
||||
}
|
||||
func m37(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]8", "LEAQ\t.*[*]4"
|
||||
// arm64: "MOVD\t[$]37,", "MUL"
|
||||
// loong64: "ALSLV\t[$]3,", "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]8", "LEAQ .*[*]4"
|
||||
// arm64: "MOVD [$]37,", "MUL"
|
||||
// loong64: "ALSLV [$]3,", "ALSLV [$]2,"
|
||||
return x * 37
|
||||
}
|
||||
func m38(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]38,"
|
||||
// arm64: "MOVD\t[$]38,", "MUL"
|
||||
// loong64: "ALSLV\t[$]3,", "ALSLV\t[$]2,"
|
||||
// amd64: "IMUL3Q [$]38,"
|
||||
// arm64: "MOVD [$]38,", "MUL"
|
||||
// loong64: "ALSLV [$]3,", "ALSLV [$]2,"
|
||||
return x * 38
|
||||
}
|
||||
func m39(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]39,"
|
||||
// arm64: "MOVD\t[$]39,", "MUL"
|
||||
// loong64: "ALSLV\t[$]2,", "SUBVU", "ALSLV\t[$]3,"
|
||||
// amd64: "IMUL3Q [$]39,"
|
||||
// arm64: "MOVD [$]39,", "MUL"
|
||||
// loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]3,"
|
||||
return x * 39
|
||||
}
|
||||
func m40(x int64) int64 {
|
||||
// amd64: "LEAQ\t.*[*]4", "SHLQ\t[$]3,"
|
||||
// arm64: "LSL\t[$]3,", "ADD\tR[0-9]+<<2,"
|
||||
// loong64: "SLLV\t[$]3,", "ALSLV\t[$]2,"
|
||||
// amd64: "LEAQ .*[*]4", "SHLQ [$]3,"
|
||||
// arm64: "LSL [$]3,", "ADD R[0-9]+<<2,"
|
||||
// loong64: "SLLV [$]3,", "ALSLV [$]2,"
|
||||
return x * 40
|
||||
}
|
||||
|
||||
func mn1(x int64) int64 {
|
||||
// amd64: "NEGQ\t"
|
||||
// arm64: "NEG\tR[0-9]+,"
|
||||
// loong64: "SUBVU\tR[0-9], R0,"
|
||||
// amd64: "NEGQ "
|
||||
// arm64: "NEG R[0-9]+,"
|
||||
// loong64: "SUBVU R[0-9], R0,"
|
||||
return x * -1
|
||||
}
|
||||
func mn2(x int64) int64 {
|
||||
// amd64: "NEGQ", "ADDQ"
|
||||
// arm64: "NEG\tR[0-9]+<<1,"
|
||||
// loong64: "ADDVU","SUBVU\tR[0-9], R0,"
|
||||
// arm64: "NEG R[0-9]+<<1,"
|
||||
// loong64: "ADDVU" "SUBVU R[0-9], R0,"
|
||||
return x * -2
|
||||
}
|
||||
func mn3(x int64) int64 {
|
||||
// amd64: "NEGQ", "LEAQ\t.*[*]2"
|
||||
// arm64: "SUB\tR[0-9]+<<2,"
|
||||
// loong64: "SUBVU", "ALSLV\t[$]1,"
|
||||
// amd64: "NEGQ", "LEAQ .*[*]2"
|
||||
// arm64: "SUB R[0-9]+<<2,"
|
||||
// loong64: "SUBVU", "ALSLV [$]1,"
|
||||
return x * -3
|
||||
}
|
||||
func mn4(x int64) int64 {
|
||||
// amd64: "NEGQ", "SHLQ\t[$]2,"
|
||||
// arm64: "NEG\tR[0-9]+<<2,"
|
||||
// loong64: "SLLV\t[$]2,","SUBVU\tR[0-9], R0,"
|
||||
// amd64: "NEGQ", "SHLQ [$]2,"
|
||||
// arm64: "NEG R[0-9]+<<2,"
|
||||
// loong64: "SLLV [$]2," "SUBVU R[0-9], R0,"
|
||||
return x * -4
|
||||
}
|
||||
func mn5(x int64) int64 {
|
||||
// amd64: "NEGQ", "LEAQ\t.*[*]4"
|
||||
// arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<2,"
|
||||
// loong64: "SUBVU", "ALSLV\t[$]2,"
|
||||
// amd64: "NEGQ", "LEAQ .*[*]4"
|
||||
// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<2,"
|
||||
// loong64: "SUBVU", "ALSLV [$]2,"
|
||||
return x * -5
|
||||
}
|
||||
func mn6(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-6,"
|
||||
// arm64: "ADD\tR[0-9]+,", "SUB\tR[0-9]+<<2,"
|
||||
// loong64: "ADDVU", "SUBVU", "ALSLV\t[$]3,"
|
||||
// amd64: "IMUL3Q [$]-6,"
|
||||
// arm64: "ADD R[0-9]+,", "SUB R[0-9]+<<2,"
|
||||
// loong64: "ADDVU", "SUBVU", "ALSLV [$]3,"
|
||||
return x * -6
|
||||
}
|
||||
func mn7(x int64) int64 {
|
||||
// amd64: "NEGQ", "LEAQ\t.*[*]8"
|
||||
// arm64: "SUB\tR[0-9]+<<3,"
|
||||
// loong64: "SUBVU", "ALSLV\t[$]3,"
|
||||
// amd64: "NEGQ", "LEAQ .*[*]8"
|
||||
// arm64: "SUB R[0-9]+<<3,"
|
||||
// loong64: "SUBVU", "ALSLV [$]3,"
|
||||
return x * -7
|
||||
}
|
||||
func mn8(x int64) int64 {
|
||||
// amd64: "NEGQ", "SHLQ\t[$]3,"
|
||||
// arm64: "NEG\tR[0-9]+<<3,"
|
||||
// loong64: "SLLV\t[$]3","SUBVU\tR[0-9], R0,"
|
||||
// amd64: "NEGQ", "SHLQ [$]3,"
|
||||
// arm64: "NEG R[0-9]+<<3,"
|
||||
// loong64: "SLLV [$]3" "SUBVU R[0-9], R0,"
|
||||
return x * -8
|
||||
}
|
||||
func mn9(x int64) int64 {
|
||||
// amd64: "NEGQ", "LEAQ\t.*[*]8"
|
||||
// arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<3,"
|
||||
// loong64: "SUBVU", "ALSLV\t[$]3,"
|
||||
// amd64: "NEGQ", "LEAQ .*[*]8"
|
||||
// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<3,"
|
||||
// loong64: "SUBVU", "ALSLV [$]3,"
|
||||
return x * -9
|
||||
}
|
||||
func mn10(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-10,"
|
||||
// arm64: "MOVD\t[$]-10,", "MUL"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]3", "SUBVU"
|
||||
// amd64: "IMUL3Q [$]-10,"
|
||||
// arm64: "MOVD [$]-10,", "MUL"
|
||||
// loong64: "ADDVU", "ALSLV [$]3", "SUBVU"
|
||||
return x * -10
|
||||
}
|
||||
func mn11(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-11,"
|
||||
// arm64: "MOVD\t[$]-11,", "MUL"
|
||||
// loong64: "ALSLV\t[$]2,", "SUBVU", "ALSLV\t[$]4,"
|
||||
// amd64: "IMUL3Q [$]-11,"
|
||||
// arm64: "MOVD [$]-11,", "MUL"
|
||||
// loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]4,"
|
||||
return x * -11
|
||||
}
|
||||
func mn12(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-12,"
|
||||
// arm64: "LSL\t[$]2,", "SUB\tR[0-9]+<<2,"
|
||||
// loong64: "SUBVU", "SLLV\t[$]2,", "ALSLV\t[$]4,"
|
||||
// amd64: "IMUL3Q [$]-12,"
|
||||
// arm64: "LSL [$]2,", "SUB R[0-9]+<<2,"
|
||||
// loong64: "SUBVU", "SLLV [$]2,", "ALSLV [$]4,"
|
||||
return x * -12
|
||||
}
|
||||
func mn13(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-13,"
|
||||
// arm64: "MOVD\t[$]-13,", "MUL"
|
||||
// loong64: "ALSLV\t[$]4,", "SLLV\t[$]2, ", "SUBVU"
|
||||
// amd64: "IMUL3Q [$]-13,"
|
||||
// arm64: "MOVD [$]-13,", "MUL"
|
||||
// loong64: "ALSLV [$]4,", "SLLV [$]2, ", "SUBVU"
|
||||
return x * -13
|
||||
}
|
||||
func mn14(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-14,"
|
||||
// arm64: "ADD\tR[0-9]+,", "SUB\tR[0-9]+<<3,"
|
||||
// loong64: "ADDVU", "SUBVU", "ALSLV\t[$]4,"
|
||||
// amd64: "IMUL3Q [$]-14,"
|
||||
// arm64: "ADD R[0-9]+,", "SUB R[0-9]+<<3,"
|
||||
// loong64: "ADDVU", "SUBVU", "ALSLV [$]4,"
|
||||
return x * -14
|
||||
}
|
||||
func mn15(x int64) int64 {
|
||||
// amd64: "SHLQ\t[$]4,", "SUBQ"
|
||||
// arm64: "SUB\tR[0-9]+<<4,"
|
||||
// loong64: "SUBVU", "ALSLV\t[$]4,"
|
||||
// amd64: "SHLQ [$]4,", "SUBQ"
|
||||
// arm64: "SUB R[0-9]+<<4,"
|
||||
// loong64: "SUBVU", "ALSLV [$]4,"
|
||||
return x * -15
|
||||
}
|
||||
func mn16(x int64) int64 {
|
||||
// amd64: "NEGQ", "SHLQ\t[$]4,"
|
||||
// arm64: "NEG\tR[0-9]+<<4,"
|
||||
// loong64: "SLLV\t[$]4,","SUBVU\tR[0-9], R0,"
|
||||
// amd64: "NEGQ", "SHLQ [$]4,"
|
||||
// arm64: "NEG R[0-9]+<<4,"
|
||||
// loong64: "SLLV [$]4," "SUBVU R[0-9], R0,"
|
||||
return x * -16
|
||||
}
|
||||
func mn17(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-17,"
|
||||
// arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<4,"
|
||||
// loong64: "SUBVU", "ALSLV\t[$]4,"
|
||||
// amd64: "IMUL3Q [$]-17,"
|
||||
// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<4,"
|
||||
// loong64: "SUBVU", "ALSLV [$]4,"
|
||||
return x * -17
|
||||
}
|
||||
func mn18(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-18,"
|
||||
// arm64: "MOVD\t[$]-18,", "MUL"
|
||||
// loong64: "ADDVU", "ALSLV\t[$]4,", "SUBVU"
|
||||
// amd64: "IMUL3Q [$]-18,"
|
||||
// arm64: "MOVD [$]-18,", "MUL"
|
||||
// loong64: "ADDVU", "ALSLV [$]4,", "SUBVU"
|
||||
return x * -18
|
||||
}
|
||||
func mn19(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-19,"
|
||||
// arm64: "MOVD\t[$]-19,", "MUL"
|
||||
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]4,", "SUBVU"
|
||||
// amd64: "IMUL3Q [$]-19,"
|
||||
// arm64: "MOVD [$]-19,", "MUL"
|
||||
// loong64: "ALSLV [$]1,", "ALSLV [$]4,", "SUBVU"
|
||||
return x * -19
|
||||
}
|
||||
func mn20(x int64) int64 {
|
||||
// amd64: "IMUL3Q\t[$]-20,"
|
||||
// arm64: "MOVD\t[$]-20,", "MUL"
|
||||
// loong64: "SLLV\t[$]2,", "ALSLV\t[$]4,", "SUBVU"
|
||||
// amd64: "IMUL3Q [$]-20,"
|
||||
// arm64: "MOVD [$]-20,", "MUL"
|
||||
// loong64: "SLLV [$]2,", "ALSLV [$]4,", "SUBVU"
|
||||
return x * -20
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ var val8 [8]uint8
|
|||
func set16(x8 int8, u8 *uint8, y8 int8, z8 uint8) {
|
||||
// Truncate not needed, load does sign/zero extend
|
||||
|
||||
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
|
||||
val16[0] = uint16(*u8)
|
||||
|
||||
// AND not needed due to size
|
||||
|
|
@ -39,20 +39,20 @@ func set16(x8 int8, u8 *uint8, y8 int8, z8 uint8) {
|
|||
}
|
||||
func shiftidx(u8 *uint8, x16 *int16, u16 *uint16) {
|
||||
|
||||
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
|
||||
val16[0] = uint16(sval16[*u8>>2])
|
||||
|
||||
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
|
||||
sval16[1] = int16(val16[*x16>>1])
|
||||
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
val16[1] = uint16(sval16[*u16>>2])
|
||||
|
||||
}
|
||||
|
||||
func setnox(x8 int8, u8 *uint8, y8 *int8, z8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) {
|
||||
|
||||
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
|
||||
val16[0] = uint16(*u8)
|
||||
|
||||
// AND not needed due to size
|
||||
|
|
@ -62,65 +62,65 @@ func setnox(x8 int8, u8 *uint8, y8 *int8, z8 *uint8, x16 *int16, u16 *uint16, x3
|
|||
// ppc64x:-"ANDCC"
|
||||
val16[1] = 255 & uint16(*u8+*z8)
|
||||
|
||||
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
|
||||
sval32[1] = int32(*x16)
|
||||
|
||||
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
|
||||
val32[0] = uint32(*u8)
|
||||
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
val32[1] = uint32(*u16)
|
||||
|
||||
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
|
||||
sval64[1] = int64(*x16)
|
||||
|
||||
// ppc64x:-"MOVW\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVW R\\d+,\\sR\\d+"
|
||||
sval64[2] = int64(*x32)
|
||||
|
||||
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
|
||||
val64[0] = uint64(*u8)
|
||||
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
val64[1] = uint64(*u16)
|
||||
|
||||
// ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
|
||||
val64[2] = uint64(*u32)
|
||||
}
|
||||
|
||||
func cmp16(u8 *uint8, x32 *int32, u32 *uint32, x64 *int64, u64 *uint64) bool {
|
||||
|
||||
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
|
||||
if uint16(*u8) == val16[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
if uint16(*u32>>16) == val16[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
if uint16(*u64>>48) == val16[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// Verify the truncates are using the correct sign.
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
if int16(*x32) == sval16[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
|
||||
if uint16(*u32) == val16[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
if int16(*x64) == sval16[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
|
||||
if uint16(*u64) == val16[0] {
|
||||
return true
|
||||
}
|
||||
|
|
@ -130,28 +130,28 @@ func cmp16(u8 *uint8, x32 *int32, u32 *uint32, x64 *int64, u64 *uint64) bool {
|
|||
|
||||
func cmp32(u8 *uint8, x16 *int16, u16 *uint16, x64 *int64, u64 *uint64) bool {
|
||||
|
||||
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
|
||||
if uint32(*u8) == val32[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
|
||||
if int32(*x16) == sval32[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
if uint32(*u16) == val32[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// Verify the truncates are using the correct sign.
|
||||
// ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
|
||||
if int32(*x64) == sval32[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVW\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVW R\\d+,\\sR\\d+"
|
||||
if uint32(*u64) == val32[0] {
|
||||
return true
|
||||
}
|
||||
|
|
@ -161,27 +161,27 @@ func cmp32(u8 *uint8, x16 *int16, u16 *uint16, x64 *int64, u64 *uint64) bool {
|
|||
|
||||
func cmp64(u8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) bool {
|
||||
|
||||
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
|
||||
if uint64(*u8) == val64[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
|
||||
if int64(*x16) == sval64[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
|
||||
if uint64(*u16) == val64[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVW\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVW R\\d+,\\sR\\d+"
|
||||
if int64(*x32) == sval64[0] {
|
||||
return true
|
||||
}
|
||||
|
||||
// ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+"
|
||||
// ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
|
||||
if uint64(*u32) == val64[0] {
|
||||
return true
|
||||
}
|
||||
|
|
@ -193,40 +193,40 @@ func cmp64(u8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) bool {
|
|||
func noUnsignEXT(t1, t2, t3, t4 uint32, k int64) uint64 {
|
||||
var ret uint64
|
||||
|
||||
// arm64:"RORW",-"MOVWU"
|
||||
// arm64:"RORW" -"MOVWU"
|
||||
ret += uint64(bits.RotateLeft32(t1, 7))
|
||||
|
||||
// arm64:"MULW",-"MOVWU"
|
||||
// arm64:"MULW" -"MOVWU"
|
||||
ret *= uint64(t1 * t2)
|
||||
|
||||
// arm64:"MNEGW",-"MOVWU"
|
||||
// arm64:"MNEGW" -"MOVWU"
|
||||
ret += uint64(-t1 * t3)
|
||||
|
||||
// arm64:"UDIVW",-"MOVWU"
|
||||
// arm64:"UDIVW" -"MOVWU"
|
||||
ret += uint64(t1 / t4)
|
||||
|
||||
// arm64:-"MOVWU"
|
||||
ret += uint64(t2 % t3)
|
||||
|
||||
// arm64:"MSUBW",-"MOVWU"
|
||||
// arm64:"MSUBW" -"MOVWU"
|
||||
ret += uint64(t1 - t2*t3)
|
||||
|
||||
// arm64:"MADDW",-"MOVWU"
|
||||
// arm64:"MADDW" -"MOVWU"
|
||||
ret += uint64(t3*t4 + t2)
|
||||
|
||||
// arm64:"REVW",-"MOVWU"
|
||||
// arm64:"REVW" -"MOVWU"
|
||||
ret += uint64(bits.ReverseBytes32(t1))
|
||||
|
||||
// arm64:"RBITW",-"MOVWU"
|
||||
// arm64:"RBITW" -"MOVWU"
|
||||
ret += uint64(bits.Reverse32(t1))
|
||||
|
||||
// arm64:"CLZW",-"MOVWU"
|
||||
// arm64:"CLZW" -"MOVWU"
|
||||
ret += uint64(bits.LeadingZeros32(t1))
|
||||
|
||||
// arm64:"REV16W",-"MOVWU"
|
||||
// arm64:"REV16W" -"MOVWU"
|
||||
ret += uint64(((t1 & 0xff00ff00) >> 8) | ((t1 & 0x00ff00ff) << 8))
|
||||
|
||||
// arm64:"EXTRW",-"MOVWU"
|
||||
// arm64:"EXTRW" -"MOVWU"
|
||||
ret += uint64((t1 << 25) | (t2 >> 7))
|
||||
|
||||
return ret
|
||||
|
|
|
|||
|
|
@ -9,13 +9,13 @@ package codegen
|
|||
import "reflect"
|
||||
|
||||
func intPtrTypeSize() uintptr {
|
||||
// amd64:"MOVL\t[$]8,",-"CALL"
|
||||
// arm64:"MOVD\t[$]8,",-"CALL"
|
||||
// amd64:"MOVL [$]8," -"CALL"
|
||||
// arm64:"MOVD [$]8," -"CALL"
|
||||
return reflect.TypeFor[*int]().Size()
|
||||
}
|
||||
|
||||
func intPtrTypeKind() reflect.Kind {
|
||||
// amd64:"MOVL\t[$]22,",-"CALL"
|
||||
// arm64:"MOVD\t[$]22,",-"CALL"
|
||||
// amd64:"MOVL [$]22," -"CALL"
|
||||
// arm64:"MOVD [$]22," -"CALL"
|
||||
return reflect.TypeFor[*int]().Kind()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,13 +8,13 @@ package codegen
|
|||
|
||||
//go:registerparams
|
||||
func f1(a, b int) {
|
||||
// amd64:"MOVQ\tBX, CX", "MOVQ\tAX, BX", "MOVL\t\\$1, AX", -"MOVQ\t.*DX"
|
||||
// amd64:"MOVQ BX, CX", "MOVQ AX, BX", "MOVL [$]1, AX", -"MOVQ .*DX"
|
||||
g(1, a, b)
|
||||
}
|
||||
|
||||
//go:registerparams
|
||||
func f2(a, b int) {
|
||||
// amd64:"MOVQ\tBX, AX", "MOVQ\t[AB]X, CX", -"MOVQ\t.*, BX"
|
||||
// amd64:"MOVQ BX, AX", "MOVQ [AB]X, CX", -"MOVQ .*, BX"
|
||||
g(b, b, b)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -5,12 +5,12 @@
|
|||
package codegen
|
||||
|
||||
func CallFunc(f func()) {
|
||||
// amd64:`CALL\truntime.retpoline`
|
||||
// amd64:`CALL runtime.retpoline`
|
||||
f()
|
||||
}
|
||||
|
||||
func CallInterface(x interface{ M() }) {
|
||||
// amd64:`CALL\truntime.retpoline`
|
||||
// amd64:`CALL runtime.retpoline`
|
||||
x.M()
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -15,36 +15,36 @@ import "math/bits"
|
|||
func rot64(x uint64) uint64 {
|
||||
var a uint64
|
||||
|
||||
// amd64:"ROLQ\t[$]7"
|
||||
// ppc64x:"ROTL\t[$]7"
|
||||
// loong64: "ROTRV\t[$]57"
|
||||
// riscv64: "RORI\t[$]57"
|
||||
// amd64:"ROLQ [$]7"
|
||||
// ppc64x:"ROTL [$]7"
|
||||
// loong64: "ROTRV [$]57"
|
||||
// riscv64: "RORI [$]57"
|
||||
a += x<<7 | x>>57
|
||||
|
||||
// amd64:"ROLQ\t[$]8"
|
||||
// arm64:"ROR\t[$]56"
|
||||
// s390x:"RISBGZ\t[$]0, [$]63, [$]8, "
|
||||
// ppc64x:"ROTL\t[$]8"
|
||||
// loong64: "ROTRV\t[$]56"
|
||||
// riscv64: "RORI\t[$]56"
|
||||
// amd64:"ROLQ [$]8"
|
||||
// arm64:"ROR [$]56"
|
||||
// s390x:"RISBGZ [$]0, [$]63, [$]8, "
|
||||
// ppc64x:"ROTL [$]8"
|
||||
// loong64: "ROTRV [$]56"
|
||||
// riscv64: "RORI [$]56"
|
||||
a += x<<8 + x>>56
|
||||
|
||||
// amd64:"ROLQ\t[$]9"
|
||||
// arm64:"ROR\t[$]55"
|
||||
// s390x:"RISBGZ\t[$]0, [$]63, [$]9, "
|
||||
// ppc64x:"ROTL\t[$]9"
|
||||
// loong64: "ROTRV\t[$]55"
|
||||
// riscv64: "RORI\t[$]55"
|
||||
// amd64:"ROLQ [$]9"
|
||||
// arm64:"ROR [$]55"
|
||||
// s390x:"RISBGZ [$]0, [$]63, [$]9, "
|
||||
// ppc64x:"ROTL [$]9"
|
||||
// loong64: "ROTRV [$]55"
|
||||
// riscv64: "RORI [$]55"
|
||||
a += x<<9 ^ x>>55
|
||||
|
||||
// amd64:"ROLQ\t[$]10"
|
||||
// arm64:"ROR\t[$]54"
|
||||
// s390x:"RISBGZ\t[$]0, [$]63, [$]10, "
|
||||
// ppc64x:"ROTL\t[$]10"
|
||||
// arm64:"ROR\t[$]54"
|
||||
// s390x:"RISBGZ\t[$]0, [$]63, [$]10, "
|
||||
// loong64: "ROTRV\t[$]54"
|
||||
// riscv64: "RORI\t[$]54"
|
||||
// amd64:"ROLQ [$]10"
|
||||
// arm64:"ROR [$]54"
|
||||
// s390x:"RISBGZ [$]0, [$]63, [$]10, "
|
||||
// ppc64x:"ROTL [$]10"
|
||||
// arm64:"ROR [$]54"
|
||||
// s390x:"RISBGZ [$]0, [$]63, [$]10, "
|
||||
// loong64: "ROTRV [$]54"
|
||||
// riscv64: "RORI [$]54"
|
||||
a += bits.RotateLeft64(x, 10)
|
||||
|
||||
return a
|
||||
|
|
@ -53,40 +53,40 @@ func rot64(x uint64) uint64 {
|
|||
func rot32(x uint32) uint32 {
|
||||
var a uint32
|
||||
|
||||
// amd64:"ROLL\t[$]7"
|
||||
// arm:"MOVW\tR\\d+@>25"
|
||||
// ppc64x:"ROTLW\t[$]7"
|
||||
// loong64: "ROTR\t[$]25"
|
||||
// riscv64: "RORIW\t[$]25"
|
||||
// amd64:"ROLL [$]7"
|
||||
// arm:"MOVW R\\d+@>25"
|
||||
// ppc64x:"ROTLW [$]7"
|
||||
// loong64: "ROTR [$]25"
|
||||
// riscv64: "RORIW [$]25"
|
||||
a += x<<7 | x>>25
|
||||
|
||||
// amd64:`ROLL\t[$]8`
|
||||
// arm:"MOVW\tR\\d+@>24"
|
||||
// arm64:"RORW\t[$]24"
|
||||
// s390x:"RLL\t[$]8"
|
||||
// ppc64x:"ROTLW\t[$]8"
|
||||
// loong64: "ROTR\t[$]24"
|
||||
// riscv64: "RORIW\t[$]24"
|
||||
// amd64:`ROLL [$]8`
|
||||
// arm:"MOVW R\\d+@>24"
|
||||
// arm64:"RORW [$]24"
|
||||
// s390x:"RLL [$]8"
|
||||
// ppc64x:"ROTLW [$]8"
|
||||
// loong64: "ROTR [$]24"
|
||||
// riscv64: "RORIW [$]24"
|
||||
a += x<<8 + x>>24
|
||||
|
||||
// amd64:"ROLL\t[$]9"
|
||||
// arm:"MOVW\tR\\d+@>23"
|
||||
// arm64:"RORW\t[$]23"
|
||||
// s390x:"RLL\t[$]9"
|
||||
// ppc64x:"ROTLW\t[$]9"
|
||||
// loong64: "ROTR\t[$]23"
|
||||
// riscv64: "RORIW\t[$]23"
|
||||
// amd64:"ROLL [$]9"
|
||||
// arm:"MOVW R\\d+@>23"
|
||||
// arm64:"RORW [$]23"
|
||||
// s390x:"RLL [$]9"
|
||||
// ppc64x:"ROTLW [$]9"
|
||||
// loong64: "ROTR [$]23"
|
||||
// riscv64: "RORIW [$]23"
|
||||
a += x<<9 ^ x>>23
|
||||
|
||||
// amd64:"ROLL\t[$]10"
|
||||
// arm:"MOVW\tR\\d+@>22"
|
||||
// arm64:"RORW\t[$]22"
|
||||
// s390x:"RLL\t[$]10"
|
||||
// ppc64x:"ROTLW\t[$]10"
|
||||
// arm64:"RORW\t[$]22"
|
||||
// s390x:"RLL\t[$]10"
|
||||
// loong64: "ROTR\t[$]22"
|
||||
// riscv64: "RORIW\t[$]22"
|
||||
// amd64:"ROLL [$]10"
|
||||
// arm:"MOVW R\\d+@>22"
|
||||
// arm64:"RORW [$]22"
|
||||
// s390x:"RLL [$]10"
|
||||
// ppc64x:"ROTLW [$]10"
|
||||
// arm64:"RORW [$]22"
|
||||
// s390x:"RLL [$]10"
|
||||
// loong64: "ROTR [$]22"
|
||||
// riscv64: "RORIW [$]22"
|
||||
a += bits.RotateLeft32(x, 10)
|
||||
|
||||
return a
|
||||
|
|
@ -95,16 +95,16 @@ func rot32(x uint32) uint32 {
|
|||
func rot16(x uint16) uint16 {
|
||||
var a uint16
|
||||
|
||||
// amd64:"ROLW\t[$]7"
|
||||
// riscv64: "OR","SLLI","SRLI",-"AND"
|
||||
// amd64:"ROLW [$]7"
|
||||
// riscv64: "OR" "SLLI" "SRLI" -"AND"
|
||||
a += x<<7 | x>>9
|
||||
|
||||
// amd64:`ROLW\t[$]8`
|
||||
// riscv64: "OR","SLLI","SRLI",-"AND"
|
||||
// amd64:`ROLW [$]8`
|
||||
// riscv64: "OR" "SLLI" "SRLI" -"AND"
|
||||
a += x<<8 + x>>8
|
||||
|
||||
// amd64:"ROLW\t[$]9"
|
||||
// riscv64: "OR","SLLI","SRLI",-"AND"
|
||||
// amd64:"ROLW [$]9"
|
||||
// riscv64: "OR" "SLLI" "SRLI" -"AND"
|
||||
a += x<<9 ^ x>>7
|
||||
|
||||
return a
|
||||
|
|
@ -113,16 +113,16 @@ func rot16(x uint16) uint16 {
|
|||
func rot8(x uint8) uint8 {
|
||||
var a uint8
|
||||
|
||||
// amd64:"ROLB\t[$]5"
|
||||
// riscv64: "OR","SLLI","SRLI",-"AND"
|
||||
// amd64:"ROLB [$]5"
|
||||
// riscv64: "OR" "SLLI" "SRLI" -"AND"
|
||||
a += x<<5 | x>>3
|
||||
|
||||
// amd64:`ROLB\t[$]6`
|
||||
// riscv64: "OR","SLLI","SRLI",-"AND"
|
||||
// amd64:`ROLB [$]6`
|
||||
// riscv64: "OR" "SLLI" "SRLI" -"AND"
|
||||
a += x<<6 + x>>2
|
||||
|
||||
// amd64:"ROLB\t[$]7"
|
||||
// riscv64: "OR","SLLI","SRLI",-"AND"
|
||||
// amd64:"ROLB [$]7"
|
||||
// riscv64: "OR" "SLLI" "SRLI" -"AND"
|
||||
a += x<<7 ^ x>>1
|
||||
|
||||
return a
|
||||
|
|
@ -137,18 +137,18 @@ func rot64nc(x uint64, z uint) uint64 {
|
|||
|
||||
z &= 63
|
||||
|
||||
// amd64:"ROLQ",-"AND"
|
||||
// arm64:"ROR","NEG",-"AND"
|
||||
// ppc64x:"ROTL",-"NEG",-"AND"
|
||||
// amd64:"ROLQ" -"AND"
|
||||
// arm64:"ROR" "NEG" -"AND"
|
||||
// ppc64x:"ROTL" -"NEG" -"AND"
|
||||
// loong64: "ROTRV", -"AND"
|
||||
// riscv64: "ROL",-"AND"
|
||||
// riscv64: "ROL" -"AND"
|
||||
a += x<<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
|
||||
|
|
@ -159,18 +159,18 @@ func rot32nc(x uint32, z uint) uint32 {
|
|||
|
||||
z &= 31
|
||||
|
||||
// amd64:"ROLL",-"AND"
|
||||
// arm64:"ROR","NEG",-"AND"
|
||||
// ppc64x:"ROTLW",-"NEG",-"AND"
|
||||
// amd64:"ROLL" -"AND"
|
||||
// arm64:"ROR" "NEG" -"AND"
|
||||
// ppc64x:"ROTLW" -"NEG" -"AND"
|
||||
// loong64: "ROTR", -"AND"
|
||||
// riscv64: "ROLW",-"AND"
|
||||
// riscv64: "ROLW" -"AND"
|
||||
a += x<<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
|
||||
|
|
@ -181,12 +181,12 @@ func rot16nc(x uint16, z uint) uint16 {
|
|||
|
||||
z &= 15
|
||||
|
||||
// amd64:"ROLW",-"ANDQ"
|
||||
// riscv64: "OR","SLL","SRL",-"AND\t"
|
||||
// amd64:"ROLW" -"ANDQ"
|
||||
// riscv64: "OR" "SLL" "SRL" -"AND "
|
||||
a += x<<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
|
||||
|
|
@ -197,12 +197,12 @@ func rot8nc(x uint8, z uint) uint8 {
|
|||
|
||||
z &= 7
|
||||
|
||||
// amd64:"ROLB",-"ANDQ"
|
||||
// riscv64: "OR","SLL","SRL",-"AND\t"
|
||||
// amd64:"ROLB" -"ANDQ"
|
||||
// riscv64: "OR" "SLL" "SRL" -"AND "
|
||||
a += x<<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
|
||||
|
|
@ -210,14 +210,14 @@ func rot8nc(x uint8, z uint) uint8 {
|
|||
|
||||
// Issue 18254: rotate after inlining
|
||||
func f32(x uint32) uint32 {
|
||||
// amd64:"ROLL\t[$]7"
|
||||
// amd64:"ROLL [$]7"
|
||||
return rot32nc(x, 7)
|
||||
}
|
||||
|
||||
func doubleRotate(x uint64) uint64 {
|
||||
x = (x << 5) | (x >> 59)
|
||||
// amd64:"ROLQ\t[$]15"
|
||||
// arm64:"ROR\t[$]49"
|
||||
// amd64:"ROLQ [$]15"
|
||||
// arm64:"ROR [$]49"
|
||||
x = (x << 10) | (x >> 54)
|
||||
return x
|
||||
}
|
||||
|
|
@ -229,51 +229,51 @@ func doubleRotate(x uint64) uint64 {
|
|||
func checkMaskedRotate32(a []uint32, r int) {
|
||||
i := 0
|
||||
|
||||
// ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
|
||||
a[i] = bits.RotateLeft32(a[i], 16) & 0xFF0000
|
||||
i++
|
||||
// ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
|
||||
a[i] = bits.RotateLeft32(a[i]&0xFF, 16)
|
||||
i++
|
||||
// ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]27, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]4, R[0-9]+, [$]20, [$]27, R[0-9]+"
|
||||
a[i] = bits.RotateLeft32(a[i], 4) & 0xFF0
|
||||
i++
|
||||
// ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]24, [$]31, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]16, R[0-9]+, [$]24, [$]31, R[0-9]+"
|
||||
a[i] = bits.RotateLeft32(a[i]&0xFF0000, 16)
|
||||
i++
|
||||
|
||||
// ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]8, [$]15, R[0-9]+"
|
||||
// ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]8, [$]15, R[0-9]+"
|
||||
a[i] = bits.RotateLeft32(a[i], r) & 0xFF0000
|
||||
i++
|
||||
// ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]16, [$]23, R[0-9]+"
|
||||
// ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]16, [$]23, R[0-9]+"
|
||||
a[i] = bits.RotateLeft32(a[i], r) & 0xFF00
|
||||
i++
|
||||
|
||||
// ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]20, [$]11, R[0-9]+"
|
||||
// ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]20, [$]11, R[0-9]+"
|
||||
a[i] = bits.RotateLeft32(a[i], r) & 0xFFF00FFF
|
||||
i++
|
||||
// ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]11, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]4, R[0-9]+, [$]20, [$]11, R[0-9]+"
|
||||
a[i] = bits.RotateLeft32(a[i], 4) & 0xFFF00FFF
|
||||
i++
|
||||
}
|
||||
|
||||
// combined arithmetic and rotate on arm64
|
||||
func checkArithmeticWithRotate(a *[1000]uint64) {
|
||||
// arm64: "AND\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
// arm64: "AND R[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
a[2] = a[1] & bits.RotateLeft64(a[0], 13)
|
||||
// arm64: "ORR\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
// arm64: "ORR R[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
a[5] = a[4] | bits.RotateLeft64(a[3], 13)
|
||||
// arm64: "EOR\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
// arm64: "EOR R[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
a[8] = a[7] ^ bits.RotateLeft64(a[6], 13)
|
||||
// arm64: "MVN\tR[0-9]+@>51, R[0-9]+"
|
||||
// arm64: "MVN R[0-9]+@>51, R[0-9]+"
|
||||
a[10] = ^bits.RotateLeft64(a[9], 13)
|
||||
// arm64: "BIC\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
// arm64: "BIC R[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
a[13] = a[12] &^ bits.RotateLeft64(a[11], 13)
|
||||
// arm64: "EON\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
// arm64: "EON R[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
a[16] = a[15] ^ ^bits.RotateLeft64(a[14], 13)
|
||||
// arm64: "ORN\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
// arm64: "ORN R[0-9]+@>51, R[0-9]+, R[0-9]+"
|
||||
a[19] = a[18] | ^bits.RotateLeft64(a[17], 13)
|
||||
// arm64: "TST\tR[0-9]+@>51, R[0-9]+"
|
||||
// arm64: "TST R[0-9]+@>51, R[0-9]+"
|
||||
if a[18]&bits.RotateLeft64(a[19], 13) == 0 {
|
||||
a[20] = 1
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@ package codegen
|
|||
|
||||
func f(n int) int {
|
||||
r := 0
|
||||
// arm64:-"MOVD\t R"
|
||||
// amd64:-"LEAQ","INCQ"
|
||||
// arm64:-"MOVD R"
|
||||
// amd64:-"LEAQ" "INCQ"
|
||||
for i := range n {
|
||||
r += i
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ func f() {
|
|||
ch1 := make(chan int)
|
||||
ch2 := make(chan int)
|
||||
for {
|
||||
// amd64:-`MOVQ\t[$]0, command-line-arguments..autotmp_3`
|
||||
// amd64:-`MOVQ [$]0, command-line-arguments..autotmp_3`
|
||||
select {
|
||||
case <-ch1:
|
||||
case <-ch2:
|
||||
|
|
|
|||
|
|
@ -13,57 +13,57 @@ package codegen
|
|||
func lshConst64x64(v int64) int64 {
|
||||
// loong64:"SLLV"
|
||||
// ppc64x:"SLD"
|
||||
// riscv64:"SLLI",-"AND",-"SLTIU"
|
||||
// riscv64:"SLLI" -"AND" -"SLTIU"
|
||||
return v << uint64(33)
|
||||
}
|
||||
|
||||
func rshConst64Ux64(v uint64) uint64 {
|
||||
// loong64:"SRLV"
|
||||
// ppc64x:"SRD"
|
||||
// riscv64:"SRLI\t",-"AND",-"SLTIU"
|
||||
// riscv64:"SRLI " -"AND" -"SLTIU"
|
||||
return v >> uint64(33)
|
||||
}
|
||||
|
||||
func rshConst64Ux64Overflow32(v uint32) uint64 {
|
||||
// loong64:"MOVV\tR0,",-"SRL\t"
|
||||
// riscv64:"MOV\t\\$0,",-"SRL"
|
||||
// loong64:"MOVV R0," -"SRL "
|
||||
// riscv64:"MOV [$]0," -"SRL"
|
||||
return uint64(v) >> 32
|
||||
}
|
||||
|
||||
func rshConst64Ux64Overflow16(v uint16) uint64 {
|
||||
// loong64:"MOVV\tR0,",-"SRLV"
|
||||
// riscv64:"MOV\t\\$0,",-"SRL"
|
||||
// loong64:"MOVV R0," -"SRLV"
|
||||
// riscv64:"MOV [$]0," -"SRL"
|
||||
return uint64(v) >> 16
|
||||
}
|
||||
|
||||
func rshConst64Ux64Overflow8(v uint8) uint64 {
|
||||
// loong64:"MOVV\tR0,",-"SRLV"
|
||||
// riscv64:"MOV\t\\$0,",-"SRL"
|
||||
// loong64:"MOVV R0," -"SRLV"
|
||||
// riscv64:"MOV [$]0," -"SRL"
|
||||
return uint64(v) >> 8
|
||||
}
|
||||
|
||||
func rshConst64x64(v int64) int64 {
|
||||
// loong64:"SRAV"
|
||||
// ppc64x:"SRAD"
|
||||
// riscv64:"SRAI\t",-"OR",-"SLTIU"
|
||||
// riscv64:"SRAI " -"OR" -"SLTIU"
|
||||
return v >> uint64(33)
|
||||
}
|
||||
|
||||
func rshConst64x64Overflow32(v int32) int64 {
|
||||
// loong64:"SRA\t\\$31"
|
||||
// riscv64:"SRAIW",-"SLLI",-"SRAI\t"
|
||||
// loong64:"SRA [$]31"
|
||||
// riscv64:"SRAIW" -"SLLI" -"SRAI "
|
||||
return int64(v) >> 32
|
||||
}
|
||||
|
||||
func rshConst64x64Overflow16(v int16) int64 {
|
||||
// loong64:"SLLV\t\\$48","SRAV\t\\$63"
|
||||
// riscv64:"SLLI","SRAI",-"SRAIW"
|
||||
// loong64:"SLLV [$]48" "SRAV [$]63"
|
||||
// riscv64:"SLLI" "SRAI" -"SRAIW"
|
||||
return int64(v) >> 16
|
||||
}
|
||||
|
||||
func rshConst64x64Overflow8(v int8) int64 {
|
||||
// loong64:"SLLV\t\\$56","SRAV\t\\$63"
|
||||
// riscv64:"SLLI","SRAI",-"SRAIW"
|
||||
// loong64:"SLLV [$]56" "SRAV [$]63"
|
||||
// riscv64:"SLLI" "SRAI" -"SRAIW"
|
||||
return int64(v) >> 8
|
||||
}
|
||||
|
||||
|
|
@ -78,84 +78,84 @@ func lshConst64x1(v int64) int64 {
|
|||
}
|
||||
|
||||
func lshConst32x64(v int32) int32 {
|
||||
// loong64:"SLL\t"
|
||||
// loong64:"SLL "
|
||||
// ppc64x:"SLW"
|
||||
// riscv64:"SLLI",-"AND",-"SLTIU", -"MOVW"
|
||||
// riscv64:"SLLI" -"AND" -"SLTIU", -"MOVW"
|
||||
return v << uint64(29)
|
||||
}
|
||||
|
||||
func rshConst32Ux64(v uint32) uint32 {
|
||||
// loong64:"SRL\t"
|
||||
// loong64:"SRL "
|
||||
// ppc64x:"SRW"
|
||||
// riscv64:"SRLIW",-"AND",-"SLTIU", -"MOVW"
|
||||
// riscv64:"SRLIW" -"AND" -"SLTIU", -"MOVW"
|
||||
return v >> uint64(29)
|
||||
}
|
||||
|
||||
func rshConst32x64(v int32) int32 {
|
||||
// loong64:"SRA\t"
|
||||
// loong64:"SRA "
|
||||
// ppc64x:"SRAW"
|
||||
// riscv64:"SRAIW",-"OR",-"SLTIU", -"MOVW"
|
||||
// riscv64:"SRAIW" -"OR" -"SLTIU", -"MOVW"
|
||||
return v >> uint64(29)
|
||||
}
|
||||
|
||||
func lshConst64x32(v int64) int64 {
|
||||
// loong64:"SLLV"
|
||||
// ppc64x:"SLD"
|
||||
// riscv64:"SLLI",-"AND",-"SLTIU"
|
||||
// riscv64:"SLLI" -"AND" -"SLTIU"
|
||||
return v << uint32(33)
|
||||
}
|
||||
|
||||
func rshConst64Ux32(v uint64) uint64 {
|
||||
// loong64:"SRLV"
|
||||
// ppc64x:"SRD"
|
||||
// riscv64:"SRLI\t",-"AND",-"SLTIU"
|
||||
// riscv64:"SRLI " -"AND" -"SLTIU"
|
||||
return v >> uint32(33)
|
||||
}
|
||||
|
||||
func rshConst64x32(v int64) int64 {
|
||||
// loong64:"SRAV"
|
||||
// ppc64x:"SRAD"
|
||||
// riscv64:"SRAI\t",-"OR",-"SLTIU"
|
||||
// riscv64:"SRAI " -"OR" -"SLTIU"
|
||||
return v >> uint32(33)
|
||||
}
|
||||
|
||||
func lshConst32x1Add(x int32) int32 {
|
||||
// amd64:"SHLL\t[$]2"
|
||||
// loong64:"SLL\t[$]2"
|
||||
// riscv64:"SLLI\t[$]2"
|
||||
// amd64:"SHLL [$]2"
|
||||
// loong64:"SLL [$]2"
|
||||
// riscv64:"SLLI [$]2"
|
||||
return (x + x) << 1
|
||||
}
|
||||
|
||||
func lshConst64x1Add(x int64) int64 {
|
||||
// amd64:"SHLQ\t[$]2"
|
||||
// loong64:"SLLV\t[$]2"
|
||||
// riscv64:"SLLI\t[$]2"
|
||||
// amd64:"SHLQ [$]2"
|
||||
// loong64:"SLLV [$]2"
|
||||
// riscv64:"SLLI [$]2"
|
||||
return (x + x) << 1
|
||||
}
|
||||
|
||||
func lshConst32x2Add(x int32) int32 {
|
||||
// amd64:"SHLL\t[$]3"
|
||||
// loong64:"SLL\t[$]3"
|
||||
// riscv64:"SLLI\t[$]3"
|
||||
// amd64:"SHLL [$]3"
|
||||
// loong64:"SLL [$]3"
|
||||
// riscv64:"SLLI [$]3"
|
||||
return (x + x) << 2
|
||||
}
|
||||
|
||||
func lshConst64x2Add(x int64) int64 {
|
||||
// amd64:"SHLQ\t[$]3"
|
||||
// loong64:"SLLV\t[$]3"
|
||||
// riscv64:"SLLI\t[$]3"
|
||||
// amd64:"SHLQ [$]3"
|
||||
// loong64:"SLLV [$]3"
|
||||
// riscv64:"SLLI [$]3"
|
||||
return (x + x) << 2
|
||||
}
|
||||
|
||||
func lshConst32x31Add(x int32) int32 {
|
||||
// loong64:-"SLL\t","MOVV\tR0"
|
||||
// riscv64:-"SLLI","MOV\t[$]0"
|
||||
// loong64:-"SLL " "MOVV R0"
|
||||
// riscv64:-"SLLI" "MOV [$]0"
|
||||
return (x + x) << 31
|
||||
}
|
||||
|
||||
func lshConst64x63Add(x int64) int64 {
|
||||
// loong64:-"SLLV","MOVV\tR0"
|
||||
// riscv64:-"SLLI","MOV\t[$]0"
|
||||
// loong64:-"SLLV" "MOVV R0"
|
||||
// riscv64:-"SLLI" "MOV [$]0"
|
||||
return (x + x) << 63
|
||||
}
|
||||
|
||||
|
|
@ -164,121 +164,121 @@ func lshConst64x63Add(x int64) int64 {
|
|||
// ------------------ //
|
||||
|
||||
func lshMask64x64(v int64, s uint64) int64 {
|
||||
// arm64:"LSL",-"AND"
|
||||
// loong64:"SLLV",-"AND"
|
||||
// ppc64x:"RLDICL",-"ORN",-"ISEL"
|
||||
// riscv64:"SLL",-"AND\t",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"LSL" -"AND"
|
||||
// loong64:"SLLV" -"AND"
|
||||
// ppc64x:"RLDICL" -"ORN" -"ISEL"
|
||||
// riscv64:"SLL" -"AND " -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v << (s & 63)
|
||||
}
|
||||
|
||||
func rshMask64Ux64(v uint64, s uint64) uint64 {
|
||||
// arm64:"LSR",-"AND",-"CSEL"
|
||||
// loong64:"SRLV",-"AND"
|
||||
// ppc64x:"RLDICL",-"ORN",-"ISEL"
|
||||
// riscv64:"SRL\t",-"AND\t",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"LSR" -"AND" -"CSEL"
|
||||
// loong64:"SRLV" -"AND"
|
||||
// ppc64x:"RLDICL" -"ORN" -"ISEL"
|
||||
// riscv64:"SRL " -"AND " -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v >> (s & 63)
|
||||
}
|
||||
|
||||
func rshMask64x64(v int64, s uint64) int64 {
|
||||
// arm64:"ASR",-"AND",-"CSEL"
|
||||
// loong64:"SRAV",-"AND"
|
||||
// ppc64x:"RLDICL",-"ORN",-"ISEL"
|
||||
// riscv64:"SRA\t",-"OR",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"ASR" -"AND" -"CSEL"
|
||||
// loong64:"SRAV" -"AND"
|
||||
// ppc64x:"RLDICL" -"ORN" -"ISEL"
|
||||
// riscv64:"SRA " -"OR" -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v >> (s & 63)
|
||||
}
|
||||
|
||||
func lshMask32x64(v int32, s uint64) int32 {
|
||||
// arm64:"LSL",-"AND"
|
||||
// loong64:"SLL\t","AND","SGTU","MASKEQZ"
|
||||
// ppc64x:"ISEL",-"ORN"
|
||||
// riscv64:"SLL",-"AND\t",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"LSL" -"AND"
|
||||
// loong64:"SLL " "AND" "SGTU" "MASKEQZ"
|
||||
// ppc64x:"ISEL" -"ORN"
|
||||
// riscv64:"SLL" -"AND " -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v << (s & 63)
|
||||
}
|
||||
|
||||
func lsh5Mask32x64(v int32, s uint64) int32 {
|
||||
// loong64:"SLL\t",-"AND"
|
||||
// loong64:"SLL " -"AND"
|
||||
return v << (s & 31)
|
||||
}
|
||||
|
||||
func rshMask32Ux64(v uint32, s uint64) uint32 {
|
||||
// arm64:"LSR",-"AND"
|
||||
// loong64:"SRL\t","AND","SGTU","MASKEQZ"
|
||||
// ppc64x:"ISEL",-"ORN"
|
||||
// riscv64:"SRLW","SLTIU","NEG","AND\t",-"SRL\t"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"LSR" -"AND"
|
||||
// loong64:"SRL " "AND" "SGTU" "MASKEQZ"
|
||||
// ppc64x:"ISEL" -"ORN"
|
||||
// riscv64:"SRLW" "SLTIU" "NEG" "AND " -"SRL "
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v >> (s & 63)
|
||||
}
|
||||
|
||||
func rsh5Mask32Ux64(v uint32, s uint64) uint32 {
|
||||
// loong64:"SRL\t",-"AND"
|
||||
// riscv64:"SRLW",-"AND\t",-"SLTIU",-"SRL\t"
|
||||
// loong64:"SRL " -"AND"
|
||||
// riscv64:"SRLW" -"AND " -"SLTIU" -"SRL "
|
||||
return v >> (s & 31)
|
||||
}
|
||||
|
||||
func rshMask32x64(v int32, s uint64) int32 {
|
||||
// arm64:"ASR",-"AND"
|
||||
// loong64:"SRA\t","AND","SGTU","SUBVU","OR"
|
||||
// ppc64x:"ISEL",-"ORN"
|
||||
// riscv64:"SRAW","OR","SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"ASR" -"AND"
|
||||
// loong64:"SRA " "AND" "SGTU" "SUBVU" "OR"
|
||||
// ppc64x:"ISEL" -"ORN"
|
||||
// riscv64:"SRAW" "OR" "SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v >> (s & 63)
|
||||
}
|
||||
|
||||
func rsh5Mask32x64(v int32, s uint64) int32 {
|
||||
// loong64:"SRA\t",-"AND"
|
||||
// riscv64:"SRAW",-"OR",-"SLTIU"
|
||||
// loong64:"SRA " -"AND"
|
||||
// riscv64:"SRAW" -"OR" -"SLTIU"
|
||||
return v >> (s & 31)
|
||||
}
|
||||
|
||||
func lshMask64x32(v int64, s uint32) int64 {
|
||||
// arm64:"LSL",-"AND"
|
||||
// loong64:"SLLV",-"AND"
|
||||
// ppc64x:"RLDICL",-"ORN"
|
||||
// riscv64:"SLL",-"AND\t",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"LSL" -"AND"
|
||||
// loong64:"SLLV" -"AND"
|
||||
// ppc64x:"RLDICL" -"ORN"
|
||||
// riscv64:"SLL" -"AND " -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v << (s & 63)
|
||||
}
|
||||
|
||||
func rshMask64Ux32(v uint64, s uint32) uint64 {
|
||||
// arm64:"LSR",-"AND",-"CSEL"
|
||||
// loong64:"SRLV",-"AND"
|
||||
// ppc64x:"RLDICL",-"ORN"
|
||||
// riscv64:"SRL\t",-"AND\t",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"LSR" -"AND" -"CSEL"
|
||||
// loong64:"SRLV" -"AND"
|
||||
// ppc64x:"RLDICL" -"ORN"
|
||||
// riscv64:"SRL " -"AND " -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v >> (s & 63)
|
||||
}
|
||||
|
||||
func rshMask64x32(v int64, s uint32) int64 {
|
||||
// arm64:"ASR",-"AND",-"CSEL"
|
||||
// loong64:"SRAV",-"AND"
|
||||
// ppc64x:"RLDICL",-"ORN",-"ISEL"
|
||||
// riscv64:"SRA\t",-"OR",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// arm64:"ASR" -"AND" -"CSEL"
|
||||
// loong64:"SRAV" -"AND"
|
||||
// ppc64x:"RLDICL" -"ORN" -"ISEL"
|
||||
// riscv64:"SRA " -"OR" -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v >> (s & 63)
|
||||
}
|
||||
|
||||
func lshMask64x32Ext(v int64, s int32) int64 {
|
||||
// ppc64x:"RLDICL",-"ORN",-"ISEL"
|
||||
// riscv64:"SLL",-"AND\t",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// ppc64x:"RLDICL" -"ORN" -"ISEL"
|
||||
// riscv64:"SLL" -"AND " -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v << uint(s&63)
|
||||
}
|
||||
|
||||
func rshMask64Ux32Ext(v uint64, s int32) uint64 {
|
||||
// ppc64x:"RLDICL",-"ORN",-"ISEL"
|
||||
// riscv64:"SRL\t",-"AND\t",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// ppc64x:"RLDICL" -"ORN" -"ISEL"
|
||||
// riscv64:"SRL " -"AND " -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v >> uint(s&63)
|
||||
}
|
||||
|
||||
func rshMask64x32Ext(v int64, s int32) int64 {
|
||||
// ppc64x:"RLDICL",-"ORN",-"ISEL"
|
||||
// riscv64:"SRA\t",-"OR",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// ppc64x:"RLDICL" -"ORN" -"ISEL"
|
||||
// riscv64:"SRA " -"OR" -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
return v >> uint(s&63)
|
||||
}
|
||||
|
||||
|
|
@ -316,10 +316,10 @@ func lshSignedMasked(v8 int8, v16 int16, v32 int32, v64 int64, x int) {
|
|||
|
||||
func lshGuarded64(v int64, s uint) int64 {
|
||||
if s < 64 {
|
||||
// riscv64:"SLL",-"AND",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// wasm:-"Select",-".*LtU"
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// riscv64:"SLL" -"AND" -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
// wasm:-"Select" -".*LtU"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
return v << s
|
||||
}
|
||||
panic("shift too large")
|
||||
|
|
@ -327,10 +327,10 @@ func lshGuarded64(v int64, s uint) int64 {
|
|||
|
||||
func rshGuarded64U(v uint64, s uint) uint64 {
|
||||
if s < 64 {
|
||||
// riscv64:"SRL\t",-"AND",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// wasm:-"Select",-".*LtU"
|
||||
// arm64:"LSR",-"CSEL"
|
||||
// riscv64:"SRL " -"AND" -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
// wasm:-"Select" -".*LtU"
|
||||
// arm64:"LSR" -"CSEL"
|
||||
return v >> s
|
||||
}
|
||||
panic("shift too large")
|
||||
|
|
@ -338,10 +338,10 @@ func rshGuarded64U(v uint64, s uint) uint64 {
|
|||
|
||||
func rshGuarded64(v int64, s uint) int64 {
|
||||
if s < 64 {
|
||||
// riscv64:"SRA\t",-"OR",-"SLTIU"
|
||||
// s390x:-"RISBGZ",-"AND",-"LOCGR"
|
||||
// wasm:-"Select",-".*LtU"
|
||||
// arm64:"ASR",-"CSEL"
|
||||
// riscv64:"SRA " -"OR" -"SLTIU"
|
||||
// s390x:-"RISBGZ" -"AND" -"LOCGR"
|
||||
// wasm:-"Select" -".*LtU"
|
||||
// arm64:"ASR" -"CSEL"
|
||||
return v >> s
|
||||
}
|
||||
panic("shift too large")
|
||||
|
|
@ -349,19 +349,19 @@ func rshGuarded64(v int64, s uint) int64 {
|
|||
|
||||
func provedUnsignedShiftLeft(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) {
|
||||
if shift >= 0 && shift < 64 {
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
r1 = val64 << shift
|
||||
}
|
||||
if shift >= 0 && shift < 32 {
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
r2 = val32 << shift
|
||||
}
|
||||
if shift >= 0 && shift < 16 {
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
r3 = val16 << shift
|
||||
}
|
||||
if shift >= 0 && shift < 8 {
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
r4 = val8 << shift
|
||||
}
|
||||
return r1, r2, r3, r4
|
||||
|
|
@ -369,19 +369,19 @@ func provedUnsignedShiftLeft(val64 uint64, val32 uint32, val16 uint16, val8 uint
|
|||
|
||||
func provedSignedShiftLeft(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) {
|
||||
if shift >= 0 && shift < 64 {
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
r1 = val64 << shift
|
||||
}
|
||||
if shift >= 0 && shift < 32 {
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
r2 = val32 << shift
|
||||
}
|
||||
if shift >= 0 && shift < 16 {
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
r3 = val16 << shift
|
||||
}
|
||||
if shift >= 0 && shift < 8 {
|
||||
// arm64:"LSL",-"CSEL"
|
||||
// arm64:"LSL" -"CSEL"
|
||||
r4 = val8 << shift
|
||||
}
|
||||
return r1, r2, r3, r4
|
||||
|
|
@ -389,19 +389,19 @@ func provedSignedShiftLeft(val64 int64, val32 int32, val16 int16, val8 int8, shi
|
|||
|
||||
func provedUnsignedShiftRight(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) {
|
||||
if shift >= 0 && shift < 64 {
|
||||
// arm64:"LSR",-"CSEL"
|
||||
// arm64:"LSR" -"CSEL"
|
||||
r1 = val64 >> shift
|
||||
}
|
||||
if shift >= 0 && shift < 32 {
|
||||
// arm64:"LSR",-"CSEL"
|
||||
// arm64:"LSR" -"CSEL"
|
||||
r2 = val32 >> shift
|
||||
}
|
||||
if shift >= 0 && shift < 16 {
|
||||
// arm64:"LSR",-"CSEL"
|
||||
// arm64:"LSR" -"CSEL"
|
||||
r3 = val16 >> shift
|
||||
}
|
||||
if shift >= 0 && shift < 8 {
|
||||
// arm64:"LSR",-"CSEL"
|
||||
// arm64:"LSR" -"CSEL"
|
||||
r4 = val8 >> shift
|
||||
}
|
||||
return r1, r2, r3, r4
|
||||
|
|
@ -409,19 +409,19 @@ func provedUnsignedShiftRight(val64 uint64, val32 uint32, val16 uint16, val8 uin
|
|||
|
||||
func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) {
|
||||
if shift >= 0 && shift < 64 {
|
||||
// arm64:"ASR",-"CSEL"
|
||||
// arm64:"ASR" -"CSEL"
|
||||
r1 = val64 >> shift
|
||||
}
|
||||
if shift >= 0 && shift < 32 {
|
||||
// arm64:"ASR",-"CSEL"
|
||||
// arm64:"ASR" -"CSEL"
|
||||
r2 = val32 >> shift
|
||||
}
|
||||
if shift >= 0 && shift < 16 {
|
||||
// arm64:"ASR",-"CSEL"
|
||||
// arm64:"ASR" -"CSEL"
|
||||
r3 = val16 >> shift
|
||||
}
|
||||
if shift >= 0 && shift < 8 {
|
||||
// arm64:"ASR",-"CSEL"
|
||||
// arm64:"ASR" -"CSEL"
|
||||
r4 = val8 >> shift
|
||||
}
|
||||
return r1, r2, r3, r4
|
||||
|
|
@ -429,36 +429,36 @@ func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, sh
|
|||
|
||||
func checkUnneededTrunc(tab *[100000]uint32, d uint64, v uint32, h uint16, b byte) (uint32, uint64) {
|
||||
|
||||
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
|
||||
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
|
||||
f := tab[byte(v)^b]
|
||||
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
|
||||
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
|
||||
f += tab[byte(v)&b]
|
||||
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
|
||||
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
|
||||
f += tab[byte(v)|b]
|
||||
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
|
||||
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
|
||||
f += tab[uint16(v)&h]
|
||||
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
|
||||
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
|
||||
f += tab[uint16(v)^h]
|
||||
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
|
||||
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
|
||||
f += tab[uint16(v)|h]
|
||||
// ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI"
|
||||
// ppc64x:-".*AND" -"RLDICR" ".*CLRLSLDI"
|
||||
f += tab[v&0xff]
|
||||
// ppc64x:-".*AND",".*CLRLSLWI"
|
||||
// ppc64x:-".*AND" ".*CLRLSLWI"
|
||||
f += 2 * uint32(uint16(d))
|
||||
// ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI"
|
||||
// ppc64x:-".*AND" -"RLDICR" ".*CLRLSLDI"
|
||||
g := 2 * uint64(uint32(d))
|
||||
return f, g
|
||||
}
|
||||
|
||||
func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64) (uint8, uint16, uint32, uint64, int64) {
|
||||
|
||||
// ppc64x:-"AND","CLRLSLWI"
|
||||
// ppc64x:-"AND" "CLRLSLWI"
|
||||
f := (v8 & 0xF) << 2
|
||||
// ppc64x:"CLRLSLWI"
|
||||
f += byte(v16) << 3
|
||||
// ppc64x:-"AND","CLRLSLWI"
|
||||
// ppc64x:-"AND" "CLRLSLWI"
|
||||
g := (v16 & 0xFF) << 3
|
||||
// ppc64x:-"AND","CLRLSLWI"
|
||||
// ppc64x:-"AND" "CLRLSLWI"
|
||||
h := (v32 & 0xFFFFF) << 2
|
||||
// ppc64x:"CLRLSLDI"
|
||||
i := (v64 & 0xFFFFFFFF) << 5
|
||||
|
|
@ -466,7 +466,7 @@ func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64
|
|||
i += (v64 & 0xFFFFFFF) << 38
|
||||
// ppc64x/power9:-"CLRLSLDI"
|
||||
i += (v64 & 0xFFFF00) << 10
|
||||
// ppc64x/power9:-"SLD","EXTSWSLI"
|
||||
// ppc64x/power9:-"SLD" "EXTSWSLI"
|
||||
j := int64(x32+32) * 8
|
||||
return f, g, h, i, j
|
||||
}
|
||||
|
|
@ -497,71 +497,71 @@ func checkWidenAfterShift(v int64, u uint64) (int64, uint64) {
|
|||
func checkShiftAndMask32(v []uint32) {
|
||||
i := 0
|
||||
|
||||
// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
|
||||
v[i] = (v[i] & 0xFF00000) >> 8
|
||||
i++
|
||||
// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
|
||||
v[i] = (v[i] & 0xFF00) >> 6
|
||||
i++
|
||||
// ppc64x: "MOVW\tR0"
|
||||
// ppc64x: "MOVW R0"
|
||||
v[i] = (v[i] & 0xFF) >> 8
|
||||
i++
|
||||
// ppc64x: "MOVW\tR0"
|
||||
// ppc64x: "MOVW R0"
|
||||
v[i] = (v[i] & 0xF000000) >> 28
|
||||
i++
|
||||
// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
|
||||
v[i] = (v[i] >> 6) & 0xFF
|
||||
i++
|
||||
// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
|
||||
v[i] = (v[i] >> 6) & 0xFF000
|
||||
i++
|
||||
// ppc64x: "MOVW\tR0"
|
||||
// ppc64x: "MOVW R0"
|
||||
v[i] = (v[i] >> 20) & 0xFF000
|
||||
i++
|
||||
// ppc64x: "MOVW\tR0"
|
||||
// ppc64x: "MOVW R0"
|
||||
v[i] = (v[i] >> 24) & 0xFF00
|
||||
i++
|
||||
}
|
||||
|
||||
func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) {
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM [$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
|
||||
a[0] = a[uint8(v>>24)]
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM [$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
|
||||
b[0] = b[uint8(v>>24)]
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM [$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
|
||||
b[1] = b[(v>>20)&0xFF]
|
||||
// ppc64x: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
|
||||
// ppc64x: -"SLD", "RLWNM [$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
|
||||
b[2] = b[v>>25]
|
||||
}
|
||||
|
||||
func checkMergedShifts64(a [256]uint32, b [256]uint64, c [256]byte, v uint64) {
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM [$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
|
||||
a[0] = a[uint8(v>>24)]
|
||||
// ppc64x: "SRD", "CLRLSLDI", -"RLWNM"
|
||||
a[1] = a[uint8(v>>25)]
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]9, R[0-9]+, [$]23, [$]29, R[0-9]+"
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM [$]9, R[0-9]+, [$]23, [$]29, R[0-9]+"
|
||||
a[2] = a[v>>25&0x7F]
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]3, R[0-9]+, [$]29, [$]29, R[0-9]+"
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM [$]3, R[0-9]+, [$]29, [$]29, R[0-9]+"
|
||||
a[3] = a[(v>>31)&0x01]
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]12, R[0-9]+, [$]21, [$]28, R[0-9]+"
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM [$]12, R[0-9]+, [$]21, [$]28, R[0-9]+"
|
||||
b[0] = b[uint8(v>>23)]
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
|
||||
// ppc64x: -"CLRLSLDI", "RLWNM [$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
|
||||
b[1] = b[(v>>20)&0xFF]
|
||||
// ppc64x: "RLWNM", -"SLD"
|
||||
b[2] = b[((uint64((uint32(v) >> 21)) & 0x3f) << 4)]
|
||||
// ppc64x: -"RLWNM"
|
||||
b[3] = (b[3] << 24) & 0xFFFFFF000000
|
||||
// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]0, [$]7,"
|
||||
// ppc64x: "RLWNM [$]24, R[0-9]+, [$]0, [$]7,"
|
||||
b[4] = (b[4] << 24) & 0xFF000000
|
||||
// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]0, [$]7,"
|
||||
// ppc64x: "RLWNM [$]24, R[0-9]+, [$]0, [$]7,"
|
||||
b[5] = (b[5] << 24) & 0xFF00000F
|
||||
// ppc64x: -"RLWNM"
|
||||
b[6] = (b[6] << 0) & 0xFF00000F
|
||||
// ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]28, [$]31,"
|
||||
// ppc64x: "RLWNM [$]4, R[0-9]+, [$]28, [$]31,"
|
||||
b[7] = (b[7] >> 28) & 0xF
|
||||
// ppc64x: "RLWNM\t[$]11, R[0-9]+, [$]10, [$]15"
|
||||
// ppc64x: "RLWNM [$]11, R[0-9]+, [$]10, [$]15"
|
||||
c[0] = c[((v>>5)&0x3F)<<16]
|
||||
// ppc64x: "ANDCC\t[$]8064,"
|
||||
// ppc64x: "ANDCC [$]8064,"
|
||||
c[1] = c[((v>>7)&0x3F)<<7]
|
||||
}
|
||||
|
||||
|
|
@ -572,7 +572,7 @@ func checkShiftMask(a uint32, b uint64, z []uint32, y []uint64) {
|
|||
z[0] = uint32(uint8(a >> 5))
|
||||
// ppc64x: -"MOVBZ", -"SRW", "RLWNM"
|
||||
z[1] = uint32(uint8((a >> 4) & 0x7e))
|
||||
// ppc64x: "RLWNM\t[$]25, R[0-9]+, [$]27, [$]29, R[0-9]+"
|
||||
// ppc64x: "RLWNM [$]25, R[0-9]+, [$]27, [$]29, R[0-9]+"
|
||||
z[2] = uint32(uint8(a>>7)) & 0x1c
|
||||
// ppc64x: -"MOVWZ"
|
||||
y[0] = uint64((a >> 6) & 0x1c)
|
||||
|
|
@ -598,11 +598,11 @@ func check128bitShifts(x, y uint64, bits uint) (uint64, uint64) {
|
|||
}
|
||||
|
||||
func checkShiftToMask(u []uint64, s []int64) {
|
||||
// amd64:-"SHR",-"SHL","ANDQ"
|
||||
// amd64:-"SHR" -"SHL" "ANDQ"
|
||||
u[0] = u[0] >> 5 << 5
|
||||
// amd64:-"SAR",-"SHL","ANDQ"
|
||||
// amd64:-"SAR" -"SHL" "ANDQ"
|
||||
s[0] = s[0] >> 5 << 5
|
||||
// amd64:-"SHR",-"SHL","ANDQ"
|
||||
// amd64:-"SHR" -"SHL" "ANDQ"
|
||||
u[1] = u[1] << 5 >> 5
|
||||
}
|
||||
|
||||
|
|
@ -611,13 +611,13 @@ func checkShiftToMask(u []uint64, s []int64) {
|
|||
//
|
||||
|
||||
func checkLeftShiftWithAddition(a int64, b int64) int64 {
|
||||
// riscv64/rva20u64: "SLLI","ADD"
|
||||
// riscv64/rva20u64: "SLLI" "ADD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "SH1ADD"
|
||||
a = a + b<<1
|
||||
// riscv64/rva20u64: "SLLI","ADD"
|
||||
// riscv64/rva20u64: "SLLI" "ADD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "SH2ADD"
|
||||
a = a + b<<2
|
||||
// riscv64/rva20u64: "SLLI","ADD"
|
||||
// riscv64/rva20u64: "SLLI" "ADD"
|
||||
// riscv64/rva22u64,riscv64/rva23u64: "SH3ADD"
|
||||
a = a + b<<3
|
||||
return a
|
||||
|
|
@ -631,7 +631,7 @@ func rsh64Uto32U(v uint64) uint32 {
|
|||
x := uint32(v)
|
||||
// riscv64:"MOVWU"
|
||||
if x > 8 {
|
||||
// riscv64:"SRLIW",-"MOVWU",-"SLLI"
|
||||
// riscv64:"SRLIW" -"MOVWU" -"SLLI"
|
||||
x >>= 2
|
||||
}
|
||||
return x
|
||||
|
|
@ -641,7 +641,7 @@ func rsh64Uto16U(v uint64) uint16 {
|
|||
x := uint16(v)
|
||||
// riscv64:"MOVHU"
|
||||
if x > 8 {
|
||||
// riscv64:"SLLI","SRLI"
|
||||
// riscv64:"SLLI" "SRLI"
|
||||
x >>= 2
|
||||
}
|
||||
return x
|
||||
|
|
@ -651,7 +651,7 @@ func rsh64Uto8U(v uint64) uint8 {
|
|||
x := uint8(v)
|
||||
// riscv64:"MOVBU"
|
||||
if x > 8 {
|
||||
// riscv64:"SLLI","SRLI"
|
||||
// riscv64:"SLLI" "SRLI"
|
||||
x >>= 2
|
||||
}
|
||||
return x
|
||||
|
|
@ -661,7 +661,7 @@ func rsh64to32(v int64) int32 {
|
|||
x := int32(v)
|
||||
// riscv64:"MOVW"
|
||||
if x > 8 {
|
||||
// riscv64:"SRAIW",-"MOVW",-"SLLI"
|
||||
// riscv64:"SRAIW" -"MOVW" -"SLLI"
|
||||
x >>= 2
|
||||
}
|
||||
return x
|
||||
|
|
@ -671,7 +671,7 @@ func rsh64to16(v int64) int16 {
|
|||
x := int16(v)
|
||||
// riscv64:"MOVH"
|
||||
if x > 8 {
|
||||
// riscv64:"SLLI","SRAI"
|
||||
// riscv64:"SLLI" "SRAI"
|
||||
x >>= 2
|
||||
}
|
||||
return x
|
||||
|
|
@ -681,7 +681,7 @@ func rsh64to8(v int64) int8 {
|
|||
x := int8(v)
|
||||
// riscv64:"MOVB"
|
||||
if x > 8 {
|
||||
// riscv64:"SLLI","SRAI"
|
||||
// riscv64:"SLLI" "SRAI"
|
||||
x >>= 2
|
||||
}
|
||||
return x
|
||||
|
|
@ -692,6 +692,6 @@ func rsh64to8(v int64) int8 {
|
|||
// (There is still a negative shift test, but
|
||||
// no shift-too-big test.)
|
||||
func signedModShift(i int) int64 {
|
||||
// arm64:-"CMP",-"CSEL"
|
||||
// arm64:-"CMP" -"CSEL"
|
||||
return 1 << (i % 64)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ func SliceExtensionConst(s []int) []int {
|
|||
// amd64:-`.*runtime\.memclrNoHeapPointers`
|
||||
// amd64:-`.*runtime\.makeslice`
|
||||
// amd64:-`.*runtime\.panicmakeslicelen`
|
||||
// amd64:"MOVUPS\tX15"
|
||||
// amd64:"MOVUPS X15"
|
||||
// loong64:-`.*runtime\.memclrNoHeapPointers`
|
||||
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
|
||||
// ppc64x:-`.*runtime\.makeslice`
|
||||
|
|
@ -58,7 +58,7 @@ func SliceExtensionConstInt64(s []int) []int {
|
|||
// amd64:-`.*runtime\.memclrNoHeapPointers`
|
||||
// amd64:-`.*runtime\.makeslice`
|
||||
// amd64:-`.*runtime\.panicmakeslicelen`
|
||||
// amd64:"MOVUPS\tX15"
|
||||
// amd64:"MOVUPS X15"
|
||||
// loong64:-`.*runtime\.memclrNoHeapPointers`
|
||||
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
|
||||
// ppc64x:-`.*runtime\.makeslice`
|
||||
|
|
@ -70,7 +70,7 @@ func SliceExtensionConstUint64(s []int) []int {
|
|||
// amd64:-`.*runtime\.memclrNoHeapPointers`
|
||||
// amd64:-`.*runtime\.makeslice`
|
||||
// amd64:-`.*runtime\.panicmakeslicelen`
|
||||
// amd64:"MOVUPS\tX15"
|
||||
// amd64:"MOVUPS X15"
|
||||
// loong64:-`.*runtime\.memclrNoHeapPointers`
|
||||
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
|
||||
// ppc64x:-`.*runtime\.makeslice`
|
||||
|
|
@ -82,7 +82,7 @@ func SliceExtensionConstUint(s []int) []int {
|
|||
// amd64:-`.*runtime\.memclrNoHeapPointers`
|
||||
// amd64:-`.*runtime\.makeslice`
|
||||
// amd64:-`.*runtime\.panicmakeslicelen`
|
||||
// amd64:"MOVUPS\tX15"
|
||||
// amd64:"MOVUPS X15"
|
||||
// loong64:-`.*runtime\.memclrNoHeapPointers`
|
||||
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
|
||||
// ppc64x:-`.*runtime\.makeslice`
|
||||
|
|
@ -352,12 +352,12 @@ func SliceNilCheck(s []int) {
|
|||
// ---------------------- //
|
||||
// See issue 21561
|
||||
func InitSmallSliceLiteral() []int {
|
||||
// amd64:`MOVQ\t[$]42`
|
||||
// amd64:`MOVQ [$]42`
|
||||
return []int{42}
|
||||
}
|
||||
|
||||
func InitNotSmallSliceLiteral() []int {
|
||||
// amd64:`LEAQ\t.*stmp_`
|
||||
// amd64:`LEAQ .*stmp_`
|
||||
return []int{
|
||||
42,
|
||||
42,
|
||||
|
|
@ -413,7 +413,7 @@ func SliceWithConstCompare(a []int, b int) []int {
|
|||
}
|
||||
|
||||
func SliceWithSubtractBound(a []int, b int) []int {
|
||||
// ppc64x:"SUBC",-"NEG"
|
||||
// ppc64x:"SUBC" -"NEG"
|
||||
return a[(3 - b):]
|
||||
}
|
||||
|
||||
|
|
@ -422,7 +422,7 @@ func SliceWithSubtractBound(a []int, b int) []int {
|
|||
// --------------------------------------- //
|
||||
|
||||
func SliceAndIndex(a []int, b int) int {
|
||||
// arm64:"AND\tR[0-9]+->63","ADD\tR[0-9]+<<3"
|
||||
// arm64:"AND R[0-9]+->63" "ADD R[0-9]+<<3"
|
||||
return a[b:][b]
|
||||
}
|
||||
|
||||
|
|
@ -445,12 +445,12 @@ func Slice0(p *struct{}, i int) []struct{} {
|
|||
// --------------------------------------- //
|
||||
|
||||
func SlicePut(a []byte, c uint8) []byte {
|
||||
// arm64:`CBZ\tR1`
|
||||
// arm64:`CBZ R1`
|
||||
a[0] = c
|
||||
// arm64:`CMP\t\$1, R1`
|
||||
// arm64:`CMP \$1, R1`
|
||||
a = a[1:]
|
||||
a[0] = c
|
||||
// arm64:`CMP\t\$2, R1`
|
||||
// arm64:`CMP \$2, R1`
|
||||
a = a[1:]
|
||||
a[0] = c
|
||||
a = a[1:]
|
||||
|
|
|
|||
|
|
@ -7,16 +7,16 @@ package codegen
|
|||
// license that can be found in the LICENSE file.
|
||||
|
||||
func booliface() interface{} {
|
||||
// amd64:`LEAQ\truntime.staticuint64s\+8\(SB\)`
|
||||
// amd64:`LEAQ runtime.staticuint64s\+8\(SB\)`
|
||||
return true
|
||||
}
|
||||
|
||||
func smallint8iface() interface{} {
|
||||
// amd64:`LEAQ\truntime.staticuint64s\+2024\(SB\)`
|
||||
// amd64:`LEAQ runtime.staticuint64s\+2024\(SB\)`
|
||||
return int8(-3)
|
||||
}
|
||||
|
||||
func smalluint8iface() interface{} {
|
||||
// amd64:`LEAQ\truntime.staticuint64s\+24\(SB\)`
|
||||
// amd64:`LEAQ runtime.staticuint64s\+24\(SB\)`
|
||||
return uint8(3)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,13 +16,13 @@ import (
|
|||
|
||||
// Check that stack stores are optimized away.
|
||||
|
||||
// 386:"TEXT\t.*, [$]0-"
|
||||
// amd64:"TEXT\t.*, [$]0-"
|
||||
// arm:"TEXT\t.*, [$]-4-"
|
||||
// arm64:"TEXT\t.*, [$]0-"
|
||||
// mips:"TEXT\t.*, [$]-4-"
|
||||
// ppc64x:"TEXT\t.*, [$]0-"
|
||||
// s390x:"TEXT\t.*, [$]0-"
|
||||
// 386:"TEXT .*, [$]0-"
|
||||
// amd64:"TEXT .*, [$]0-"
|
||||
// arm:"TEXT .*, [$]-4-"
|
||||
// arm64:"TEXT .*, [$]0-"
|
||||
// mips:"TEXT .*, [$]-4-"
|
||||
// ppc64x:"TEXT .*, [$]0-"
|
||||
// s390x:"TEXT .*, [$]0-"
|
||||
func StackStore() int {
|
||||
var x int
|
||||
return *(&x)
|
||||
|
|
@ -35,13 +35,13 @@ type T struct {
|
|||
|
||||
// Check that large structs are cleared directly (issue #24416).
|
||||
|
||||
// 386:"TEXT\t.*, [$]0-"
|
||||
// amd64:"TEXT\t.*, [$]0-"
|
||||
// arm:"TEXT\t.*, [$]0-" (spills return address)
|
||||
// arm64:"TEXT\t.*, [$]0-"
|
||||
// mips:"TEXT\t.*, [$]-4-"
|
||||
// ppc64x:"TEXT\t.*, [$]0-"
|
||||
// s390x:"TEXT\t.*, [$]0-"
|
||||
// 386:"TEXT .*, [$]0-"
|
||||
// amd64:"TEXT .*, [$]0-"
|
||||
// arm:"TEXT .*, [$]0-" (spills return address)
|
||||
// arm64:"TEXT .*, [$]0-"
|
||||
// mips:"TEXT .*, [$]-4-"
|
||||
// ppc64x:"TEXT .*, [$]0-"
|
||||
// s390x:"TEXT .*, [$]0-"
|
||||
func ZeroLargeStruct(x *T) {
|
||||
t := T{}
|
||||
*x = t
|
||||
|
|
@ -51,11 +51,11 @@ func ZeroLargeStruct(x *T) {
|
|||
|
||||
// Notes:
|
||||
// - 386 fails due to spilling a register
|
||||
// amd64:"TEXT\t.*, [$]0-"
|
||||
// arm:"TEXT\t.*, [$]0-" (spills return address)
|
||||
// arm64:"TEXT\t.*, [$]0-"
|
||||
// ppc64x:"TEXT\t.*, [$]0-"
|
||||
// s390x:"TEXT\t.*, [$]0-"
|
||||
// amd64:"TEXT .*, [$]0-"
|
||||
// arm:"TEXT .*, [$]0-" (spills return address)
|
||||
// arm64:"TEXT .*, [$]0-"
|
||||
// ppc64x:"TEXT .*, [$]0-"
|
||||
// s390x:"TEXT .*, [$]0-"
|
||||
// Note: that 386 currently has to spill a register.
|
||||
func KeepWanted(t *T) {
|
||||
*t = T{A: t.A, B: t.B, C: t.C, D: t.D}
|
||||
|
|
@ -66,23 +66,23 @@ func KeepWanted(t *T) {
|
|||
// Notes:
|
||||
// - 386 fails due to spilling a register
|
||||
// - arm & mips fail due to softfloat calls
|
||||
// amd64:"TEXT\t.*, [$]0-"
|
||||
// arm64:"TEXT\t.*, [$]0-"
|
||||
// ppc64x:"TEXT\t.*, [$]0-"
|
||||
// s390x:"TEXT\t.*, [$]0-"
|
||||
// amd64:"TEXT .*, [$]0-"
|
||||
// arm64:"TEXT .*, [$]0-"
|
||||
// ppc64x:"TEXT .*, [$]0-"
|
||||
// s390x:"TEXT .*, [$]0-"
|
||||
func ArrayAdd64(a, b [4]float64) [4]float64 {
|
||||
return [4]float64{a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]}
|
||||
}
|
||||
|
||||
// Check that small array initialization avoids using the stack.
|
||||
|
||||
// 386:"TEXT\t.*, [$]0-"
|
||||
// amd64:"TEXT\t.*, [$]0-"
|
||||
// arm:"TEXT\t.*, [$]0-" (spills return address)
|
||||
// arm64:"TEXT\t.*, [$]0-"
|
||||
// mips:"TEXT\t.*, [$]-4-"
|
||||
// ppc64x:"TEXT\t.*, [$]0-"
|
||||
// s390x:"TEXT\t.*, [$]0-"
|
||||
// 386:"TEXT .*, [$]0-"
|
||||
// amd64:"TEXT .*, [$]0-"
|
||||
// arm:"TEXT .*, [$]0-" (spills return address)
|
||||
// arm64:"TEXT .*, [$]0-"
|
||||
// mips:"TEXT .*, [$]-4-"
|
||||
// ppc64x:"TEXT .*, [$]0-"
|
||||
// s390x:"TEXT .*, [$]0-"
|
||||
func ArrayInit(i, j int) [4]int {
|
||||
return [4]int{i, 0, j, 0}
|
||||
}
|
||||
|
|
@ -99,7 +99,7 @@ func check_asmout(b [2]int) int {
|
|||
|
||||
// Check that simple functions get promoted to nosplit, even when
|
||||
// they might panic in various ways. See issue 31219.
|
||||
// amd64:"TEXT\t.*NOSPLIT.*"
|
||||
// amd64:"TEXT .*NOSPLIT.*"
|
||||
func MightPanic(a []int, i, j, k, s int) {
|
||||
_ = a[i] // panicIndex
|
||||
_ = a[i:j] // panicSlice
|
||||
|
|
@ -113,7 +113,7 @@ func Defer() {
|
|||
for i := 0; i < 2; i++ {
|
||||
defer func() {}()
|
||||
}
|
||||
// amd64:`CALL\truntime\.deferprocStack`
|
||||
// amd64:`CALL runtime\.deferprocStack`
|
||||
defer func() {}()
|
||||
}
|
||||
|
||||
|
|
@ -138,7 +138,7 @@ type mySlice struct {
|
|||
cap int
|
||||
}
|
||||
|
||||
// amd64:"TEXT\t.*, [$]0-"
|
||||
// amd64:"TEXT .*, [$]0-"
|
||||
func sliceInit(base uintptr) []uintptr {
|
||||
const ptrSize = 8
|
||||
size := uintptr(4096)
|
||||
|
|
@ -150,7 +150,7 @@ func sliceInit(base uintptr) []uintptr {
|
|||
elements,
|
||||
elements,
|
||||
}
|
||||
// amd64:-"POPQ",-"SP"
|
||||
// amd64:-"POPQ" -"SP"
|
||||
return *(*[]uintptr)(unsafe.Pointer(&sl))
|
||||
}
|
||||
|
||||
|
|
@ -171,6 +171,6 @@ func getp2() *[4]int {
|
|||
|
||||
// Store to an argument without read can be removed.
|
||||
func storeArg(a [2]int) {
|
||||
// amd64:-`MOVQ\t\$123,.*\.a\+\d+\(SP\)`
|
||||
// amd64:-`MOVQ \$123,.*\.a\+\d+\(SP\)`
|
||||
a[1] = 123
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,8 +22,8 @@ func CountBytes(s []byte) int {
|
|||
}
|
||||
|
||||
func ToByteSlice() []byte { // Issue #24698
|
||||
// amd64:`LEAQ\ttype:\[3\]uint8`
|
||||
// amd64:`CALL\truntime\.mallocTiny3`
|
||||
// amd64:`LEAQ type:\[3\]uint8`
|
||||
// amd64:`CALL runtime\.mallocTiny3`
|
||||
// amd64:-`.*runtime.stringtoslicebyte`
|
||||
return []byte("foo")
|
||||
}
|
||||
|
|
@ -37,56 +37,56 @@ func ConvertToByteSlice(a, b, c string) []byte {
|
|||
func ConstantLoad() {
|
||||
// 12592 = 0x3130
|
||||
// 50 = 0x32
|
||||
// amd64:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(`
|
||||
// 386:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(`
|
||||
// arm:`MOVW\t\$48`,`MOVW\t\$49`,`MOVW\t\$50`
|
||||
// arm64:`MOVD\t\$12592`,`MOVD\t\$50`
|
||||
// loong64:`MOVV\t\$12592`,`MOVV\t\$50`
|
||||
// wasm:`I64Const\t\$12592`,`I64Store16\t\$0`,`I64Const\t\$50`,`I64Store8\t\$2`
|
||||
// mips64:`MOVV\t\$48`,`MOVV\t\$49`,`MOVV\t\$50`
|
||||
// amd64:`MOVW \$12592, \(`,`MOVB \$50, 2\(`
|
||||
// 386:`MOVW \$12592, \(`,`MOVB \$50, 2\(`
|
||||
// arm:`MOVW \$48`,`MOVW \$49`,`MOVW \$50`
|
||||
// arm64:`MOVD \$12592`,`MOVD \$50`
|
||||
// loong64:`MOVV \$12592`,`MOVV \$50`
|
||||
// wasm:`I64Const \$12592`,`I64Store16 \$0`,`I64Const \$50`,`I64Store8 \$2`
|
||||
// mips64:`MOVV \$48`,`MOVV \$49`,`MOVV \$50`
|
||||
bsink = []byte("012")
|
||||
|
||||
// 858927408 = 0x33323130
|
||||
// 13620 = 0x3534
|
||||
// amd64:`MOVL\t\$858927408`,`MOVW\t\$13620, 4\(`
|
||||
// 386:`MOVL\t\$858927408`,`MOVW\t\$13620, 4\(`
|
||||
// arm64:`MOVD\t\$858927408`,`MOVD\t\$13620`
|
||||
// loong64:`MOVV\t\$858927408`,`MOVV\t\$13620`
|
||||
// wasm:`I64Const\t\$858927408`,`I64Store32\t\$0`,`I64Const\t\$13620`,`I64Store16\t\$4`
|
||||
// amd64:`MOVL \$858927408`,`MOVW \$13620, 4\(`
|
||||
// 386:`MOVL \$858927408`,`MOVW \$13620, 4\(`
|
||||
// arm64:`MOVD \$858927408`,`MOVD \$13620`
|
||||
// loong64:`MOVV \$858927408`,`MOVV \$13620`
|
||||
// wasm:`I64Const \$858927408`,`I64Store32 \$0`,`I64Const \$13620`,`I64Store16 \$4`
|
||||
bsink = []byte("012345")
|
||||
|
||||
// 3978425819141910832 = 0x3736353433323130
|
||||
// 7306073769690871863 = 0x6564636261393837
|
||||
// amd64:`MOVQ\t\$3978425819141910832`,`MOVQ\t\$7306073769690871863`
|
||||
// 386:`MOVL\t\$858927408, \(`,`DUFFCOPY`
|
||||
// arm64:`MOVD\t\$3978425819141910832`,`MOVD\t\$7306073769690871863`,`MOVD\t\$15`
|
||||
// loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$7306073769690871863`,`MOVV\t\$15`
|
||||
// wasm:`I64Const\t\$3978425819141910832`,`I64Store\t\$0`,`I64Const\t\$7306073769690871863`,`I64Store\t\$7`
|
||||
// amd64:`MOVQ \$3978425819141910832`,`MOVQ \$7306073769690871863`
|
||||
// 386:`MOVL \$858927408, \(`,`DUFFCOPY`
|
||||
// arm64:`MOVD \$3978425819141910832`,`MOVD \$7306073769690871863`,`MOVD \$15`
|
||||
// loong64:`MOVV \$3978425819141910832`,`MOVV \$7306073769690871863`,`MOVV \$15`
|
||||
// wasm:`I64Const \$3978425819141910832`,`I64Store \$0`,`I64Const \$7306073769690871863`,`I64Store \$7`
|
||||
bsink = []byte("0123456789abcde")
|
||||
|
||||
// 56 = 0x38
|
||||
// amd64:`MOVQ\t\$3978425819141910832`,`MOVB\t\$56`
|
||||
// loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$56`
|
||||
// amd64:`MOVQ \$3978425819141910832`,`MOVB \$56`
|
||||
// loong64:`MOVV \$3978425819141910832`,`MOVV \$56`
|
||||
bsink = []byte("012345678")
|
||||
|
||||
// 14648 = 0x3938
|
||||
// amd64:`MOVQ\t\$3978425819141910832`,`MOVW\t\$14648`
|
||||
// loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$14648`
|
||||
// amd64:`MOVQ \$3978425819141910832`,`MOVW \$14648`
|
||||
// loong64:`MOVV \$3978425819141910832`,`MOVV \$14648`
|
||||
bsink = []byte("0123456789")
|
||||
|
||||
// 1650538808 = 0x62613938
|
||||
// amd64:`MOVQ\t\$3978425819141910832`,`MOVL\t\$1650538808`
|
||||
// loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$1650538808`
|
||||
// amd64:`MOVQ \$3978425819141910832`,`MOVL \$1650538808`
|
||||
// loong64:`MOVV \$3978425819141910832`,`MOVV \$1650538808`
|
||||
bsink = []byte("0123456789ab")
|
||||
}
|
||||
|
||||
// self-equality is always true. See issue 60777.
|
||||
func EqualSelf(s string) bool {
|
||||
// amd64:`MOVL\t\$1, AX`,-`.*memequal.*`
|
||||
// amd64:`MOVL \$1, AX`,-`.*memequal.*`
|
||||
return s == s
|
||||
}
|
||||
func NotEqualSelf(s string) bool {
|
||||
// amd64:`XORL\tAX, AX`,-`.*memequal.*`
|
||||
// amd64:`XORL AX, AX`,-`.*memequal.*`
|
||||
return s != s
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ type Z1 struct {
|
|||
}
|
||||
|
||||
func Zero1(t *Z1) { // Issue #18370
|
||||
// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
|
||||
// amd64:`MOVUPS X[0-9]+, \(.*\)`,`MOVQ \$0, 16\(.*\)`
|
||||
*t = Z1{}
|
||||
}
|
||||
|
||||
|
|
@ -29,7 +29,7 @@ type Z2 struct {
|
|||
}
|
||||
|
||||
func Zero2(t *Z2) {
|
||||
// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
|
||||
// amd64:`MOVUPS X[0-9]+, \(.*\)`,`MOVQ \$0, 16\(.*\)`
|
||||
// amd64:`.*runtime[.]gcWriteBarrier.*\(SB\)`
|
||||
*t = Z2{}
|
||||
}
|
||||
|
|
@ -43,6 +43,6 @@ type I1 struct {
|
|||
}
|
||||
|
||||
func Init1(p *I1) { // Issue #18872
|
||||
// amd64:`MOVQ\t[$]1`,`MOVQ\t[$]2`,`MOVQ\t[$]3`,`MOVQ\t[$]4`
|
||||
// amd64:`MOVQ [$]1`,`MOVQ [$]2`,`MOVQ [$]3`,`MOVQ [$]4`
|
||||
*p = I1{1, 2, 3, 4}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -137,8 +137,8 @@ type K interface {
|
|||
|
||||
// use a runtime call for type switches to interface types.
|
||||
func interfaceSwitch(x any) int {
|
||||
// amd64:`CALL\truntime.interfaceSwitch`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*8)`
|
||||
// arm64:`CALL\truntime.interfaceSwitch`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
|
||||
// amd64:`CALL runtime.interfaceSwitch`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*8)`
|
||||
// arm64:`CALL runtime.interfaceSwitch`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
|
||||
switch x.(type) {
|
||||
case I:
|
||||
return 1
|
||||
|
|
@ -150,8 +150,8 @@ func interfaceSwitch(x any) int {
|
|||
}
|
||||
|
||||
func interfaceSwitch2(x K) int {
|
||||
// amd64:`CALL\truntime.interfaceSwitch`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*8)`
|
||||
// arm64:`CALL\truntime.interfaceSwitch`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
|
||||
// amd64:`CALL runtime.interfaceSwitch`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*8)`
|
||||
// arm64:`CALL runtime.interfaceSwitch`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
|
||||
switch x.(type) {
|
||||
case I:
|
||||
return 1
|
||||
|
|
@ -163,8 +163,8 @@ func interfaceSwitch2(x K) int {
|
|||
}
|
||||
|
||||
func interfaceCast(x any) int {
|
||||
// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)`
|
||||
// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
|
||||
// amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)`
|
||||
// arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
|
||||
if _, ok := x.(I); ok {
|
||||
return 3
|
||||
}
|
||||
|
|
@ -172,8 +172,8 @@ func interfaceCast(x any) int {
|
|||
}
|
||||
|
||||
func interfaceCast2(x K) int {
|
||||
// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)`
|
||||
// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
|
||||
// amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)`
|
||||
// arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
|
||||
if _, ok := x.(I); ok {
|
||||
return 3
|
||||
}
|
||||
|
|
@ -181,8 +181,8 @@ func interfaceCast2(x K) int {
|
|||
}
|
||||
|
||||
func interfaceConv(x IJ) I {
|
||||
// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)`
|
||||
// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
|
||||
// amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)`
|
||||
// arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
|
||||
return x
|
||||
}
|
||||
|
||||
|
|
@ -195,7 +195,7 @@ func stringSwitchInlineable(s string) {
|
|||
}
|
||||
}
|
||||
func stringSwitch() {
|
||||
// amd64:-"CMP",-"CALL"
|
||||
// arm64:-"CMP",-"CALL"
|
||||
// amd64:-"CMP" -"CALL"
|
||||
// arm64:-"CMP" -"CALL"
|
||||
stringSwitchInlineable("foo")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ func swGYZ[T any](a Ig[T]) {
|
|||
t.Y()
|
||||
case Iz: // amd64:-".*typeAssert"
|
||||
t.Z()
|
||||
case interface{ G() T }: // amd64:-".*typeAssert",-".*assertE2I\\(",".*assertE2I2"
|
||||
case interface{ G() T }: // amd64:-".*typeAssert" -".*assertE2I\\(" ".*assertE2I2"
|
||||
t.G()
|
||||
}
|
||||
}
|
||||
|
|
@ -46,7 +46,7 @@ func swE2G[T any](a any) {
|
|||
switch t := a.(type) {
|
||||
case Iy:
|
||||
t.Y()
|
||||
case Ig[T]: // amd64:-".*assertE2I\\(",".*assertE2I2"
|
||||
case Ig[T]: // amd64:-".*assertE2I\\(" ".*assertE2I2"
|
||||
t.G()
|
||||
}
|
||||
}
|
||||
|
|
@ -55,7 +55,7 @@ func swI2G[T any](a Ix) {
|
|||
switch t := a.(type) {
|
||||
case Iy:
|
||||
t.Y()
|
||||
case Ig[T]: // amd64:-".*assertE2I\\(",".*assertE2I2"
|
||||
case Ig[T]: // amd64:-".*assertE2I\\(" ".*assertE2I2"
|
||||
t.G()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,24 +12,24 @@ package codegen
|
|||
|
||||
func zeroSize() {
|
||||
c := make(chan struct{})
|
||||
// amd64:`MOVQ\t\$0, command-line-arguments\.s\+56\(SP\)`
|
||||
// amd64:`MOVQ \$0, command-line-arguments\.s\+56\(SP\)`
|
||||
var s *int
|
||||
// force s to be a stack object, also use some (fixed) stack space
|
||||
g(&s, 1, 2, 3, 4, 5)
|
||||
|
||||
// amd64:`LEAQ\tcommand-line-arguments\..*\+55\(SP\)`
|
||||
// amd64:`LEAQ command-line-arguments\..*\+55\(SP\)`
|
||||
c <- noliteral(struct{}{})
|
||||
}
|
||||
|
||||
// Like zeroSize, but without hiding the zero-sized struct.
|
||||
func zeroSize2() {
|
||||
c := make(chan struct{})
|
||||
// amd64:`MOVQ\t\$0, command-line-arguments\.s\+48\(SP\)`
|
||||
// amd64:`MOVQ \$0, command-line-arguments\.s\+48\(SP\)`
|
||||
var s *int
|
||||
// force s to be a stack object, also use some (fixed) stack space
|
||||
g(&s, 1, 2, 3, 4, 5)
|
||||
|
||||
// amd64:`LEAQ\tcommand-line-arguments\..*stmp_\d+\(SB\)`
|
||||
// amd64:`LEAQ command-line-arguments\..*stmp_\d+\(SB\)`
|
||||
c <- struct{}{}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue