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
|
|
@ -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)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue