mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
cmd/compile: fuse NaN checks with other comparisons
NaN checks can often be merged into other comparisons by inverting them.
For example, `math.IsNaN(x) || x > 0` is equivalent to `!(x <= 0)`.
goos: linux
goarch: amd64
pkg: math
cpu: 12th Gen Intel(R) Core(TM) i7-12700T
│ sec/op │ sec/op vs base │
Acos 4.315n ± 0% 4.314n ± 0% ~ (p=0.642 n=10)
Acosh 8.398n ± 0% 7.779n ± 0% -7.37% (p=0.000 n=10)
Asin 4.203n ± 0% 4.211n ± 0% +0.20% (p=0.001 n=10)
Asinh 10.150n ± 0% 9.562n ± 0% -5.79% (p=0.000 n=10)
Atan 2.363n ± 0% 2.363n ± 0% ~ (p=0.801 n=10)
Atanh 8.192n ± 2% 7.685n ± 0% -6.20% (p=0.000 n=10)
Atan2 4.013n ± 0% 4.010n ± 0% ~ (p=0.073 n=10)
Cbrt 4.858n ± 0% 4.755n ± 0% -2.12% (p=0.000 n=10)
Cos 4.596n ± 0% 4.357n ± 0% -5.20% (p=0.000 n=10)
Cosh 5.071n ± 0% 5.071n ± 0% ~ (p=0.585 n=10)
Erf 2.802n ± 1% 2.788n ± 0% -0.54% (p=0.002 n=10)
Erfc 3.087n ± 1% 3.071n ± 0% ~ (p=0.320 n=10)
Erfinv 3.981n ± 0% 3.965n ± 0% -0.41% (p=0.000 n=10)
Erfcinv 3.985n ± 0% 3.977n ± 0% -0.20% (p=0.000 n=10)
ExpGo 8.721n ± 2% 8.252n ± 0% -5.38% (p=0.000 n=10)
Expm1 4.378n ± 0% 4.228n ± 0% -3.43% (p=0.000 n=10)
Exp2 8.313n ± 0% 7.855n ± 0% -5.52% (p=0.000 n=10)
Exp2Go 8.498n ± 2% 7.921n ± 0% -6.79% (p=0.000 n=10)
Mod 15.16n ± 4% 12.20n ± 1% -19.58% (p=0.000 n=10)
Frexp 1.780n ± 2% 1.496n ± 0% -15.96% (p=0.000 n=10)
Gamma 4.378n ± 1% 4.013n ± 0% -8.35% (p=0.000 n=10)
HypotGo 2.655n ± 5% 2.427n ± 1% -8.57% (p=0.000 n=10)
Ilogb 1.912n ± 5% 1.749n ± 0% -8.53% (p=0.000 n=10)
J0 22.43n ± 9% 20.46n ± 0% -8.76% (p=0.000 n=10)
J1 21.03n ± 4% 19.96n ± 0% -5.09% (p=0.000 n=10)
Jn 45.40n ± 1% 42.59n ± 0% -6.20% (p=0.000 n=10)
Ldexp 2.312n ± 1% 1.944n ± 0% -15.94% (p=0.000 n=10)
Lgamma 4.617n ± 1% 4.584n ± 0% -0.73% (p=0.000 n=10)
Log 4.226n ± 0% 4.213n ± 0% -0.31% (p=0.001 n=10)
Logb 1.771n ± 0% 1.775n ± 0% ~ (p=0.097 n=10)
Log1p 5.102n ± 2% 5.001n ± 0% -1.97% (p=0.000 n=10)
Log10 4.407n ± 0% 4.408n ± 0% ~ (p=1.000 n=10)
Log2 2.416n ± 1% 2.138n ± 0% -11.51% (p=0.000 n=10)
Modf 1.669n ± 2% 1.611n ± 0% -3.50% (p=0.000 n=10)
Nextafter32 2.186n ± 0% 2.185n ± 0% ~ (p=0.051 n=10)
Nextafter64 2.182n ± 0% 2.184n ± 0% +0.09% (p=0.016 n=10)
PowInt 11.39n ± 6% 10.68n ± 2% -6.24% (p=0.000 n=10)
PowFrac 26.60n ± 2% 26.12n ± 0% -1.80% (p=0.000 n=10)
Pow10Pos 0.5067n ± 4% 0.5003n ± 1% -1.27% (p=0.001 n=10)
Pow10Neg 0.8552n ± 0% 0.8552n ± 0% ~ (p=0.928 n=10)
Round 1.181n ± 0% 1.182n ± 0% +0.08% (p=0.001 n=10)
RoundToEven 1.709n ± 0% 1.710n ± 0% ~ (p=0.053 n=10)
Remainder 12.54n ± 5% 11.99n ± 2% -4.46% (p=0.000 n=10)
Sin 3.933n ± 5% 3.926n ± 0% -0.17% (p=0.000 n=10)
Sincos 5.672n ± 0% 5.522n ± 0% -2.65% (p=0.000 n=10)
Sinh 5.447n ± 1% 5.444n ± 0% -0.06% (p=0.029 n=10)
Tan 4.061n ± 0% 4.058n ± 0% -0.07% (p=0.005 n=10)
Tanh 5.599n ± 0% 5.595n ± 0% -0.06% (p=0.042 n=10)
Y0 20.75n ± 5% 19.73n ± 1% -4.92% (p=0.000 n=10)
Y1 20.87n ± 2% 19.78n ± 1% -5.20% (p=0.000 n=10)
Yn 44.50n ± 2% 42.04n ± 2% -5.53% (p=0.000 n=10)
geomean 4.989n 4.791n -3.96%
goos: linux
goarch: riscv64
pkg: math
cpu: Spacemit(R) X60
│ sec/op │ sec/op vs base │
Acos 159.9n ± 0% 159.9n ± 0% ~ (p=0.269 n=10)
Acosh 244.7n ± 0% 235.0n ± 0% -3.98% (p=0.000 n=10)
Asin 159.9n ± 0% 159.9n ± 0% ~ (p=0.154 n=10)
Asinh 270.8n ± 0% 261.1n ± 0% -3.60% (p=0.000 n=10)
Atan 119.1n ± 0% 119.1n ± 0% ~ (p=0.347 n=10)
Atanh 260.2n ± 0% 261.8n ± 4% ~ (p=0.459 n=10)
Atan2 186.8n ± 0% 186.8n ± 0% ~ (p=0.487 n=10)
Cbrt 203.5n ± 0% 198.2n ± 0% -2.60% (p=0.000 n=10)
Ceil 31.82n ± 0% 31.81n ± 0% ~ (p=0.714 n=10)
Copysign 4.894n ± 0% 4.893n ± 0% ~ (p=0.161 n=10)
Cos 107.6n ± 0% 103.6n ± 0% -3.76% (p=0.000 n=10)
Cosh 259.0n ± 0% 252.8n ± 0% -2.39% (p=0.000 n=10)
Erf 133.7n ± 0% 133.7n ± 0% ~ (p=0.720 n=10)
Erfc 137.9n ± 0% 137.8n ± 0% -0.04% (p=0.033 n=10)
Erfinv 173.7n ± 0% 168.8n ± 0% -2.82% (p=0.000 n=10)
Erfcinv 173.7n ± 0% 168.8n ± 0% -2.82% (p=0.000 n=10)
Exp 215.3n ± 0% 208.1n ± 0% -3.34% (p=0.000 n=10)
ExpGo 226.7n ± 0% 220.6n ± 0% -2.69% (p=0.000 n=10)
Expm1 164.8n ± 0% 159.0n ± 0% -3.52% (p=0.000 n=10)
Exp2 185.0n ± 0% 182.7n ± 0% -1.22% (p=0.000 n=10)
Exp2Go 198.9n ± 0% 196.5n ± 0% -1.21% (p=0.000 n=10)
Abs 4.894n ± 0% 4.893n ± 0% ~ (p=0.262 n=10)
Dim 16.31n ± 0% 16.31n ± 0% ~ (p=1.000 n=10)
Floor 31.81n ± 0% 31.81n ± 0% ~ (p=0.067 n=10)
Max 26.11n ± 0% 26.10n ± 0% ~ (p=0.080 n=10)
Min 26.10n ± 0% 26.10n ± 0% ~ (p=0.095 n=10)
Mod 337.7n ± 0% 291.9n ± 0% -13.56% (p=0.000 n=10)
Frexp 50.57n ± 0% 42.41n ± 0% -16.13% (p=0.000 n=10)
Gamma 206.3n ± 0% 198.1n ± 0% -4.00% (p=0.000 n=10)
Hypot 94.62n ± 0% 94.61n ± 0% ~ (p=0.437 n=10)
HypotGo 109.3n ± 0% 109.3n ± 0% ~ (p=1.000 n=10)
Ilogb 44.05n ± 0% 44.04n ± 0% -0.02% (p=0.025 n=10)
J0 663.1n ± 0% 663.9n ± 0% +0.13% (p=0.002 n=10)
J1 663.9n ± 0% 666.4n ± 0% +0.38% (p=0.000 n=10)
Jn 1.404µ ± 0% 1.407µ ± 0% +0.21% (p=0.000 n=10)
Ldexp 57.10n ± 0% 48.93n ± 0% -14.30% (p=0.000 n=10)
Lgamma 185.1n ± 0% 187.6n ± 0% +1.32% (p=0.000 n=10)
Log 182.7n ± 0% 170.1n ± 0% -6.87% (p=0.000 n=10)
Logb 46.49n ± 0% 46.49n ± 0% ~ (p=0.675 n=10)
Log1p 184.3n ± 0% 179.4n ± 0% -2.63% (p=0.000 n=10)
Log10 184.3n ± 0% 171.2n ± 0% -7.08% (p=0.000 n=10)
Log2 66.05n ± 0% 57.90n ± 0% -12.34% (p=0.000 n=10)
Modf 34.25n ± 0% 34.24n ± 0% ~ (p=0.163 n=10)
Nextafter32 49.33n ± 1% 48.93n ± 0% -0.81% (p=0.002 n=10)
Nextafter64 43.64n ± 0% 43.23n ± 0% -0.93% (p=0.000 n=10)
PowInt 267.6n ± 0% 251.2n ± 0% -6.11% (p=0.000 n=10)
PowFrac 672.9n ± 0% 637.9n ± 0% -5.19% (p=0.000 n=10)
Pow10Pos 13.87n ± 0% 13.87n ± 0% ~ (p=1.000 n=10)
Pow10Neg 19.58n ± 62% 19.59n ± 62% ~ (p=0.355 n=10)
Round 23.65n ± 0% 23.65n ± 0% ~ (p=1.000 n=10)
RoundToEven 27.73n ± 0% 27.73n ± 0% ~ (p=0.635 n=10)
Remainder 309.9n ± 0% 280.5n ± 0% -9.49% (p=0.000 n=10)
Signbit 13.05n ± 0% 13.05n ± 0% ~ (p=1.000 n=10) ¹
Sin 120.7n ± 0% 120.7n ± 0% ~ (p=1.000 n=10) ¹
Sincos 148.4n ± 0% 143.5n ± 0% -3.30% (p=0.000 n=10)
Sinh 275.6n ± 0% 267.5n ± 0% -2.94% (p=0.000 n=10)
SqrtIndirect 3.262n ± 0% 3.262n ± 0% ~ (p=0.263 n=10)
SqrtLatency 19.57n ± 0% 19.57n ± 0% ~ (p=0.582 n=10)
SqrtIndirectLatency 19.57n ± 0% 19.57n ± 0% ~ (p=1.000 n=10)
SqrtGoLatency 203.2n ± 0% 197.6n ± 0% -2.78% (p=0.000 n=10)
SqrtPrime 4.952µ ± 0% 4.952µ ± 0% -0.01% (p=0.025 n=10)
Tan 153.3n ± 0% 153.3n ± 0% ~ (p=1.000 n=10)
Tanh 280.5n ± 0% 272.4n ± 0% -2.91% (p=0.000 n=10)
Trunc 31.81n ± 0% 31.81n ± 0% ~ (p=1.000 n=10)
Y0 680.1n ± 0% 664.8n ± 0% -2.25% (p=0.000 n=10)
Y1 684.2n ± 0% 669.6n ± 0% -2.14% (p=0.000 n=10)
Yn 1.444µ ± 0% 1.410µ ± 0% -2.35% (p=0.000 n=10)
Float64bits 5.709n ± 0% 5.708n ± 0% ~ (p=0.573 n=10)
Float64frombits 4.893n ± 0% 4.893n ± 0% ~ (p=0.734 n=10)
Float32bits 12.23n ± 0% 12.23n ± 0% ~ (p=0.628 n=10)
Float32frombits 4.893n ± 0% 4.893n ± 0% ~ (p=0.971 n=10)
FMA 4.893n ± 0% 4.893n ± 0% ~ (p=0.736 n=10)
geomean 88.96n 87.05n -2.15%
¹ all samples are equal
Change-Id: I8db8ac7b7b3430b946b89e88dd6c1546804125c3
Reviewed-on: https://go-review.googlesource.com/c/go/+/697360
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Keith Randall <khr@google.com>
Auto-Submit: Michael Munday <mikemndy@gmail.com>
This commit is contained in:
Michael Munday
Gopher Robot
parent
78b43037dc
commit
97fd6bdecc
6 changed files with 855 additions and 24 deletions
|
|
@ -23957,6 +23957,7 @@ func rewriteValuegeneric_OpOrB(v *Value) bool {
|
|||
v_1 := v.Args[1]
|
||||
v_0 := v.Args[0]
|
||||
b := v.Block
|
||||
typ := &b.Func.Config.Types
|
||||
// match: (OrB (Less64 (Const64 [c]) x) (Less64 x (Const64 [d])))
|
||||
// cond: c >= d
|
||||
// result: (Less64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d])))
|
||||
|
|
@ -25269,6 +25270,558 @@ func rewriteValuegeneric_OpOrB(v *Value) bool {
|
|||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Less64F x y:(Const64F [c])))
|
||||
// result: (Not (Leq64F y x))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
if x != v_1.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq64F, typ.Bool)
|
||||
v0.AddArg2(y, x)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Leq64F x y:(Const64F [c])))
|
||||
// result: (Not (Less64F y x))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
if x != v_1.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess64F, typ.Bool)
|
||||
v0.AddArg2(y, x)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) x))
|
||||
// result: (Not (Leq64F x y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
if x != v_1.Args[1] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq64F, typ.Bool)
|
||||
v0.AddArg2(x, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) x))
|
||||
// result: (Not (Less64F x y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
if x != v_1.Args[1] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess64F, typ.Bool)
|
||||
v0.AddArg2(x, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq32F x x) (Less32F x y:(Const32F [c])))
|
||||
// result: (Not (Leq32F y x))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq32F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess32F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
if x != v_1.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst32F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq32F, typ.Bool)
|
||||
v0.AddArg2(y, x)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq32F x x) (Leq32F x y:(Const32F [c])))
|
||||
// result: (Not (Less32F y x))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq32F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq32F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
if x != v_1.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst32F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess32F, typ.Bool)
|
||||
v0.AddArg2(y, x)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq32F x x) (Less32F y:(Const32F [c]) x))
|
||||
// result: (Not (Leq32F x y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq32F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess32F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst32F {
|
||||
continue
|
||||
}
|
||||
if x != v_1.Args[1] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq32F, typ.Bool)
|
||||
v0.AddArg2(x, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq32F x x) (Leq32F y:(Const32F [c]) x))
|
||||
// result: (Not (Less32F x y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq32F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq32F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst32F {
|
||||
continue
|
||||
}
|
||||
if x != v_1.Args[1] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess32F, typ.Bool)
|
||||
v0.AddArg2(x, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Less64F abs:(Abs x) y:(Const64F [c])))
|
||||
// result: (Not (Leq64F y abs))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
abs := v_1.Args[0]
|
||||
if abs.Op != OpAbs || x != abs.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq64F, typ.Bool)
|
||||
v0.AddArg2(y, abs)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Leq64F abs:(Abs x) y:(Const64F [c])))
|
||||
// result: (Not (Less64F y abs))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
abs := v_1.Args[0]
|
||||
if abs.Op != OpAbs || x != abs.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess64F, typ.Bool)
|
||||
v0.AddArg2(y, abs)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) abs:(Abs x)))
|
||||
// result: (Not (Leq64F abs y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
abs := v_1.Args[1]
|
||||
if abs.Op != OpAbs || x != abs.Args[0] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq64F, typ.Bool)
|
||||
v0.AddArg2(abs, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) abs:(Abs x)))
|
||||
// result: (Not (Less64F abs y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
abs := v_1.Args[1]
|
||||
if abs.Op != OpAbs || x != abs.Args[0] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess64F, typ.Bool)
|
||||
v0.AddArg2(abs, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Less64F neg:(Neg64F x) y:(Const64F [c])))
|
||||
// result: (Not (Leq64F y neg))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
neg := v_1.Args[0]
|
||||
if neg.Op != OpNeg64F || x != neg.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq64F, typ.Bool)
|
||||
v0.AddArg2(y, neg)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Leq64F neg:(Neg64F x) y:(Const64F [c])))
|
||||
// result: (Not (Less64F y neg))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
neg := v_1.Args[0]
|
||||
if neg.Op != OpNeg64F || x != neg.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess64F, typ.Bool)
|
||||
v0.AddArg2(y, neg)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) neg:(Neg64F x)))
|
||||
// result: (Not (Leq64F neg y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
neg := v_1.Args[1]
|
||||
if neg.Op != OpNeg64F || x != neg.Args[0] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq64F, typ.Bool)
|
||||
v0.AddArg2(neg, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) neg:(Neg64F x)))
|
||||
// result: (Not (Less64F neg y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq64F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq64F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst64F {
|
||||
continue
|
||||
}
|
||||
neg := v_1.Args[1]
|
||||
if neg.Op != OpNeg64F || x != neg.Args[0] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess64F, typ.Bool)
|
||||
v0.AddArg2(neg, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq32F x x) (Less32F neg:(Neg32F x) y:(Const32F [c])))
|
||||
// result: (Not (Leq32F y neg))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq32F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess32F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
neg := v_1.Args[0]
|
||||
if neg.Op != OpNeg32F || x != neg.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst32F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq32F, typ.Bool)
|
||||
v0.AddArg2(y, neg)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq32F x x) (Leq32F neg:(Neg32F x) y:(Const32F [c])))
|
||||
// result: (Not (Less32F y neg))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq32F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq32F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
neg := v_1.Args[0]
|
||||
if neg.Op != OpNeg32F || x != neg.Args[0] {
|
||||
continue
|
||||
}
|
||||
y := v_1.Args[1]
|
||||
if y.Op != OpConst32F {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess32F, typ.Bool)
|
||||
v0.AddArg2(y, neg)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq32F x x) (Less32F y:(Const32F [c]) neg:(Neg32F x)))
|
||||
// result: (Not (Leq32F neg y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq32F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLess32F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst32F {
|
||||
continue
|
||||
}
|
||||
neg := v_1.Args[1]
|
||||
if neg.Op != OpNeg32F || x != neg.Args[0] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLeq32F, typ.Bool)
|
||||
v0.AddArg2(neg, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
// match: (OrB (Neq32F x x) (Leq32F y:(Const32F [c]) neg:(Neg32F x)))
|
||||
// result: (Not (Less32F neg y))
|
||||
for {
|
||||
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
|
||||
if v_0.Op != OpNeq32F {
|
||||
continue
|
||||
}
|
||||
x := v_0.Args[1]
|
||||
if x != v_0.Args[0] || v_1.Op != OpLeq32F {
|
||||
continue
|
||||
}
|
||||
_ = v_1.Args[1]
|
||||
y := v_1.Args[0]
|
||||
if y.Op != OpConst32F {
|
||||
continue
|
||||
}
|
||||
neg := v_1.Args[1]
|
||||
if neg.Op != OpNeg32F || x != neg.Args[0] {
|
||||
continue
|
||||
}
|
||||
v.reset(OpNot)
|
||||
v0 := b.NewValue0(v.Pos, OpLess32F, typ.Bool)
|
||||
v0.AddArg2(neg, y)
|
||||
v.AddArg(v0)
|
||||
return true
|
||||
}
|
||||
break
|
||||
}
|
||||
return false
|
||||
}
|
||||
func rewriteValuegeneric_OpPhi(v *Value) bool {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue