opAndType{OLT, TFLOAT64}: ssa.OpLess64F,
opAndType{OLT, TFLOAT32}: ssa.OpLess32F,
- opAndType{OGT, TFLOAT64}: ssa.OpGreater64F,
- opAndType{OGT, TFLOAT32}: ssa.OpGreater32F,
-
opAndType{OLE, TINT8}: ssa.OpLeq8,
opAndType{OLE, TUINT8}: ssa.OpLeq8U,
opAndType{OLE, TINT16}: ssa.OpLeq16,
opAndType{OLE, TUINT64}: ssa.OpLeq64U,
opAndType{OLE, TFLOAT64}: ssa.OpLeq64F,
opAndType{OLE, TFLOAT32}: ssa.OpLeq32F,
-
- opAndType{OGE, TFLOAT64}: ssa.OpGeq64F,
- opAndType{OGE, TFLOAT32}: ssa.OpGeq32F,
}
func (s *state) concreteEtype(t *types.Type) types.EType {
s.Fatalf("ordered complex compare %v", n.Op)
}
}
- if n.Left.Type.IsFloat() {
- return s.newValueOrSfCall2(s.ssaOp(n.Op, n.Left.Type), types.Types[TBOOL], a, b)
- }
- // Integer: convert OGE and OGT into OLE and OLT.
+ // Convert OGE and OGT into OLE and OLT.
op := n.Op
switch op {
case OGE:
case OGT:
op, a, b = OLT, b, a
}
+ if n.Left.Type.IsFloat() {
+ // float comparison
+ return s.newValueOrSfCall2(s.ssaOp(op, n.Left.Type), types.Types[TBOOL], a, b)
+ }
+ // integer comparison
return s.newValue2(s.ssaOp(op, n.Left.Type), types.Types[TBOOL], a, b)
case OMUL:
a := s.expr(n.Left)
ssa.OpDiv32F: sfRtCallDef{sysfunc("fdiv32"), TFLOAT32},
ssa.OpDiv64F: sfRtCallDef{sysfunc("fdiv64"), TFLOAT64},
- ssa.OpEq64F: sfRtCallDef{sysfunc("feq64"), TBOOL},
- ssa.OpEq32F: sfRtCallDef{sysfunc("feq32"), TBOOL},
- ssa.OpNeq64F: sfRtCallDef{sysfunc("feq64"), TBOOL},
- ssa.OpNeq32F: sfRtCallDef{sysfunc("feq32"), TBOOL},
- ssa.OpLess64F: sfRtCallDef{sysfunc("fgt64"), TBOOL},
- ssa.OpLess32F: sfRtCallDef{sysfunc("fgt32"), TBOOL},
- ssa.OpGreater64F: sfRtCallDef{sysfunc("fgt64"), TBOOL},
- ssa.OpGreater32F: sfRtCallDef{sysfunc("fgt32"), TBOOL},
- ssa.OpLeq64F: sfRtCallDef{sysfunc("fge64"), TBOOL},
- ssa.OpLeq32F: sfRtCallDef{sysfunc("fge32"), TBOOL},
- ssa.OpGeq64F: sfRtCallDef{sysfunc("fge64"), TBOOL},
- ssa.OpGeq32F: sfRtCallDef{sysfunc("fge32"), TBOOL},
+ ssa.OpEq64F: sfRtCallDef{sysfunc("feq64"), TBOOL},
+ ssa.OpEq32F: sfRtCallDef{sysfunc("feq32"), TBOOL},
+ ssa.OpNeq64F: sfRtCallDef{sysfunc("feq64"), TBOOL},
+ ssa.OpNeq32F: sfRtCallDef{sysfunc("feq32"), TBOOL},
+ ssa.OpLess64F: sfRtCallDef{sysfunc("fgt64"), TBOOL},
+ ssa.OpLess32F: sfRtCallDef{sysfunc("fgt32"), TBOOL},
+ ssa.OpLeq64F: sfRtCallDef{sysfunc("fge64"), TBOOL},
+ ssa.OpLeq32F: sfRtCallDef{sysfunc("fge32"), TBOOL},
ssa.OpCvt32to32F: sfRtCallDef{sysfunc("fint32to32"), TFLOAT32},
ssa.OpCvt32Fto32: sfRtCallDef{sysfunc("f32toint32"), TINT32},
(Leq64F x y) -> (SETGEF (UCOMISD y x))
(Leq32F x y) -> (SETGEF (UCOMISS y x))
-// Note Go assembler gets UCOMISx operand order wrong, but it is right here
-// Bug is accommodated at generation of assembly language.
-(Greater64F x y) -> (SETGF (UCOMISD x y))
-(Greater32F x y) -> (SETGF (UCOMISS x y))
-
-// Note Go assembler gets UCOMISx operand order wrong, but it is right here
-// Bug is accommodated at generation of assembly language.
-(Geq64F x y) -> (SETGEF (UCOMISD x y))
-(Geq32F x y) -> (SETGEF (UCOMISS x y))
-
(Eq32 x y) -> (SETEQ (CMPL x y))
(Eq16 x y) -> (SETEQ (CMPW x y))
(Eq8 x y) -> (SETEQ (CMPB x y))
(Rsh16x(64|32|16|8) x y) && shiftIsBounded(v) -> (SARW x y)
(Rsh8x(64|32|16|8) x y) && shiftIsBounded(v) -> (SARB x y)
-// Lowering comparisons
-(Less(64|32|16|8) x y) -> (SETL (CMP(Q|L|W|B) x y))
-(Less(64|32|16|8)U x y) -> (SETB (CMP(Q|L|W|B) x y))
-// Use SETGF with reversed operands to dodge NaN case
-(Less(32|64)F x y) -> (SETGF (UCOMIS(S|D) y x))
-
-(Leq(64|32|16|8) x y) -> (SETLE (CMP(Q|L|W|B) x y))
-(Leq(64|32|16|8)U x y) -> (SETBE (CMP(Q|L|W|B) x y))
-// Use SETGEF with reversed operands to dodge NaN case
-(Leq(32|64)F x y) -> (SETGEF (UCOMIS(S|D) y x))
-
-// Note Go assembler gets UCOMISx operand order wrong, but it is right here
-// Bug is accommodated at generation of assembly language.
-(Greater(32|64)F x y) -> (SETGF (UCOMIS(S|D) x y))
-
+// Lowering integer comparisons
+(Less(64|32|16|8) x y) -> (SETL (CMP(Q|L|W|B) x y))
+(Less(64|32|16|8)U x y) -> (SETB (CMP(Q|L|W|B) x y))
+(Leq(64|32|16|8) x y) -> (SETLE (CMP(Q|L|W|B) x y))
+(Leq(64|32|16|8)U x y) -> (SETBE (CMP(Q|L|W|B) x y))
+(Eq(Ptr|64|32|16|8|B) x y) -> (SETEQ (CMP(Q|Q|L|W|B|B) x y))
+(Neq(Ptr|64|32|16|8|B) x y) -> (SETNE (CMP(Q|Q|L|W|B|B) x y))
+
+// Lowering floating point comparisons
// Note Go assembler gets UCOMISx operand order wrong, but it is right here
-// Bug is accommodated at generation of assembly language.
-(Geq(32|64)F x y) -> (SETGEF (UCOMIS(S|D) x y))
-
-(Eq(64|32|16|8|B) x y) -> (SETEQ (CMP(Q|L|W|B|B) x y))
-(EqPtr x y) -> (SETEQ (CMPQ x y))
-(Eq(32|64)F x y) -> (SETEQF (UCOMIS(S|D) x y))
-
-(Neq(64|32|16|8|B) x y) -> (SETNE (CMP(Q|L|W|B|B) x y))
-(NeqPtr x y) -> (SETNE (CMPQ x y))
-(Neq(32|64)F x y) -> (SETNEF (UCOMIS(S|D) x y))
+// and the operands are reversed when generating assembly language.
+(Eq(32|64)F x y) -> (SETEQF (UCOMIS(S|D) x y))
+(Neq(32|64)F x y) -> (SETNEF (UCOMIS(S|D) x y))
+// Use SETGF/SETGEF with reversed operands to dodge NaN case.
+(Less(32|64)F x y) -> (SETGF (UCOMIS(S|D) y x))
+(Leq(32|64)F x y) -> (SETGEF (UCOMIS(S|D) y x))
// Lowering loads
(Load <t> ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem)
(Leq16U x y) -> (LessEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
(Leq32U x y) -> (LessEqualU (CMP x y))
-(Greater(32|64)F x y) -> (GreaterThan (CMP(F|D) x y))
-
-(Geq(32|64)F x y) -> (GreaterEqual (CMP(F|D) x y))
-
(OffPtr [off] ptr:(SP)) -> (MOVWaddr [off] ptr)
(OffPtr [off] ptr) -> (ADDconst [off] ptr)
(Leq32U x y) -> (LessEqualU (CMPW x y))
(Leq64U x y) -> (LessEqualU (CMP x y))
-(Greater32F x y) -> (GreaterThanF (FCMPS x y))
-(Greater64F x y) -> (GreaterThanF (FCMPD x y))
-
-(Geq32F x y) -> (GreaterEqualF (FCMPS x y))
-(Geq64F x y) -> (GreaterEqualF (FCMPD x y))
-
// Optimize comparison between a floating-point value and 0.0 with "FCMP $(0.0), Fn"
(FCMPS x (FMOVSconst [0])) -> (FCMPS0 x)
(FCMPS (FMOVSconst [0]) x) -> (InvertFlags (FCMPS0 x))
(Leq16U x y) -> (XORconst [1] (SGTU (ZeroExt16to32 x) (ZeroExt16to32 y)))
(Leq32U x y) -> (XORconst [1] (SGTU x y))
-(Greater(32|64)F x y) -> (FPFlagTrue (CMPGT(F|D) x y))
-(Geq(32|64)F x y) -> (FPFlagTrue (CMPGE(F|D) x y))
-
(OffPtr [off] ptr:(SP)) -> (MOVWaddr [off] ptr)
(OffPtr [off] ptr) -> (ADDconst [off] ptr)
(Leq32U x y) -> (XOR (MOVVconst [1]) (SGTU (ZeroExt32to64 x) (ZeroExt32to64 y)))
(Leq64U x y) -> (XOR (MOVVconst [1]) (SGTU x y))
-(Greater(32|64)F x y) -> (FPFlagTrue (CMPGT(F|D) x y))
-(Geq(32|64)F x y) -> (FPFlagTrue (CMPGE(F|D) x y))
-
(OffPtr [off] ptr:(SP)) -> (MOVVaddr [off] ptr)
(OffPtr [off] ptr) -> (ADDVconst [off] ptr)
(Leq32U x y) -> (LessEqual (CMPWU x y))
(Leq64U x y) -> (LessEqual (CMPU x y))
-(Greater(32|64)F x y) -> (FGreaterThan (FCMPU x y))
-
-(Geq(32|64)F x y) -> (FGreaterEqual (FCMPU x y))
-
// Absorb pseudo-ops into blocks.
(If (Equal cc) yes no) -> (EQ cc yes no)
(If (NotEqual cc) yes no) -> (NE cc yes no)
(Leq64F ...) -> (FLED ...)
(Leq32F ...) -> (FLES ...)
-// Convert x > y to y < x.
-(Greater64F x y) -> (FLTD y x)
-(Greater32F x y) -> (FLTS y x)
-
-// Convert x >= y to !(x < y)
-(Geq64F x y) -> (FLED y x)
-(Geq32F x y) -> (FLES y x)
-
(EqPtr x y) -> (SEQZ (SUB <x.Type> x y))
(Eq64 x y) -> (SEQZ (SUB <x.Type> x y))
(Eq32 x y) -> (SEQZ (SUBW <x.Type> x y))
(Leq64F x y) -> (LOCGR {s390x.LessOrEqual} (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
(Leq32F x y) -> (LOCGR {s390x.LessOrEqual} (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
-(Greater64F x y) -> (LOCGR {s390x.Greater} (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
-(Greater32F x y) -> (LOCGR {s390x.Greater} (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
-
-(Geq64F x y) -> (LOCGR {s390x.GreaterOrEqual} (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
-(Geq32F x y) -> (LOCGR {s390x.GreaterOrEqual} (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
-
(Eq(64|Ptr) x y) -> (LOCGR {s390x.Equal} (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
(Eq32 x y) -> (LOCGR {s390x.Equal} (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
(Eq(16|8|B) x y) -> (LOCGR {s390x.Equal} (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOV(H|B|B)reg x) (MOV(H|B|B)reg y)))
(Leq8U x y) -> (I64LeU (ZeroExt8to64 x) (ZeroExt8to64 y))
(Leq(64|32)F ...) -> (F(64|32)Le ...)
-(Greater(64|32)F ...) -> (F(64|32)Gt ...)
-(Geq(64|32)F ...) -> (F(64|32)Ge ...)
-
(Eq64 ...) -> (I64Eq ...)
(Eq32 x y) -> (I64Eq (ZeroExt32to64 x) (ZeroExt32to64 y))
(Eq16 x y) -> (I64Eq (ZeroExt16to64 x) (ZeroExt16to64 y))
(Eq64F (Const64F [c]) (Const64F [d])) -> (ConstBool [b2i(auxTo64F(c) == auxTo64F(d))])
(Neq32F (Const32F [c]) (Const32F [d])) -> (ConstBool [b2i(auxTo32F(c) != auxTo32F(d))])
(Neq64F (Const64F [c]) (Const64F [d])) -> (ConstBool [b2i(auxTo64F(c) != auxTo64F(d))])
-(Greater32F (Const32F [c]) (Const32F [d])) -> (ConstBool [b2i(auxTo32F(c) > auxTo32F(d))])
-(Greater64F (Const64F [c]) (Const64F [d])) -> (ConstBool [b2i(auxTo64F(c) > auxTo64F(d))])
-(Geq32F (Const32F [c]) (Const32F [d])) -> (ConstBool [b2i(auxTo32F(c) >= auxTo32F(d))])
-(Geq64F (Const64F [c]) (Const64F [d])) -> (ConstBool [b2i(auxTo64F(c) >= auxTo64F(d))])
(Less32F (Const32F [c]) (Const32F [d])) -> (ConstBool [b2i(auxTo32F(c) < auxTo32F(d))])
(Less64F (Const64F [c]) (Const64F [d])) -> (ConstBool [b2i(auxTo64F(c) < auxTo64F(d))])
(Leq32F (Const32F [c]) (Const32F [d])) -> (ConstBool [b2i(auxTo32F(c) <= auxTo32F(d))])
{name: "Leq32F", argLength: 2, typ: "Bool"},
{name: "Leq64F", argLength: 2, typ: "Bool"},
- {name: "Greater32F", argLength: 2, typ: "Bool"},
- {name: "Greater64F", argLength: 2, typ: "Bool"},
-
- {name: "Geq32F", argLength: 2, typ: "Bool"},
- {name: "Geq64F", argLength: 2, typ: "Bool"},
-
// the type of a CondSelect is the same as the type of its first
// two arguments, which should be register-width scalars; the third
// argument should be a boolean
OpLeq64U
OpLeq32F
OpLeq64F
- OpGreater32F
- OpGreater64F
- OpGeq32F
- OpGeq64F
OpCondSelect
OpAndB
OpOrB
argLen: 2,
generic: true,
},
- {
- name: "Greater32F",
- argLen: 2,
- generic: true,
- },
- {
- name: "Greater64F",
- argLen: 2,
- generic: true,
- },
- {
- name: "Geq32F",
- argLen: 2,
- generic: true,
- },
- {
- name: "Geq64F",
- argLen: 2,
- generic: true,
- },
{
name: "CondSelect",
argLen: 3,
return rewriteValue386_OpEqB(v)
case OpEqPtr:
return rewriteValue386_OpEqPtr(v)
- case OpGeq32F:
- return rewriteValue386_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValue386_OpGeq64F(v)
case OpGetCallerPC:
v.Op = Op386LoweredGetCallerPC
return true
case OpGetG:
v.Op = Op386LoweredGetG
return true
- case OpGreater32F:
- return rewriteValue386_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValue386_OpGreater64F(v)
case OpHmul32:
v.Op = Op386HMULL
return true
return true
}
}
-func rewriteValue386_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq32F x y)
- // result: (SETGEF (UCOMISS x y))
- for {
- x := v_0
- y := v_1
- v.reset(Op386SETGEF)
- v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValue386_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq64F x y)
- // result: (SETGEF (UCOMISD x y))
- for {
- x := v_0
- y := v_1
- v.reset(Op386SETGEF)
- v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValue386_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater32F x y)
- // result: (SETGF (UCOMISS x y))
- for {
- x := v_0
- y := v_1
- v.reset(Op386SETGF)
- v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValue386_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater64F x y)
- // result: (SETGF (UCOMISD x y))
- for {
- x := v_0
- y := v_1
- v.reset(Op386SETGF)
- v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
func rewriteValue386_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return rewriteValueAMD64_OpFMA(v)
case OpFloor:
return rewriteValueAMD64_OpFloor(v)
- case OpGeq32F:
- return rewriteValueAMD64_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValueAMD64_OpGeq64F(v)
case OpGetCallerPC:
v.Op = OpAMD64LoweredGetCallerPC
return true
case OpGetG:
v.Op = OpAMD64LoweredGetG
return true
- case OpGreater32F:
- return rewriteValueAMD64_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValueAMD64_OpGreater64F(v)
case OpHasCPUFeature:
return rewriteValueAMD64_OpHasCPUFeature(v)
case OpHmul32:
return true
}
}
-func rewriteValueAMD64_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq32F x y)
- // result: (SETGEF (UCOMISS x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpAMD64SETGEF)
- v0 := b.NewValue0(v.Pos, OpAMD64UCOMISS, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueAMD64_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq64F x y)
- // result: (SETGEF (UCOMISD x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpAMD64SETGEF)
- v0 := b.NewValue0(v.Pos, OpAMD64UCOMISD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueAMD64_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater32F x y)
- // result: (SETGF (UCOMISS x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpAMD64SETGF)
- v0 := b.NewValue0(v.Pos, OpAMD64UCOMISS, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueAMD64_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater64F x y)
- // result: (SETGF (UCOMISD x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpAMD64SETGF)
- v0 := b.NewValue0(v.Pos, OpAMD64UCOMISD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
func rewriteValueAMD64_OpHasCPUFeature(v *Value) bool {
b := v.Block
typ := &b.Func.Config.Types
return rewriteValueARM_OpEqPtr(v)
case OpFMA:
return rewriteValueARM_OpFMA(v)
- case OpGeq32F:
- return rewriteValueARM_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValueARM_OpGeq64F(v)
case OpGetCallerPC:
v.Op = OpARMLoweredGetCallerPC
return true
case OpGetClosurePtr:
v.Op = OpARMLoweredGetClosurePtr
return true
- case OpGreater32F:
- return rewriteValueARM_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValueARM_OpGreater64F(v)
case OpHmul32:
v.Op = OpARMHMUL
return true
return true
}
}
-func rewriteValueARM_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq32F x y)
- // result: (GreaterEqual (CMPF x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpARMGreaterEqual)
- v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueARM_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq64F x y)
- // result: (GreaterEqual (CMPD x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpARMGreaterEqual)
- v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueARM_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater32F x y)
- // result: (GreaterThan (CMPF x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpARMGreaterThan)
- v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueARM_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater64F x y)
- // result: (GreaterThan (CMPD x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpARMGreaterThan)
- v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
func rewriteValueARM_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
case OpFloor:
v.Op = OpARM64FRINTMD
return true
- case OpGeq32F:
- return rewriteValueARM64_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValueARM64_OpGeq64F(v)
case OpGetCallerPC:
v.Op = OpARM64LoweredGetCallerPC
return true
case OpGetClosurePtr:
v.Op = OpARM64LoweredGetClosurePtr
return true
- case OpGreater32F:
- return rewriteValueARM64_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValueARM64_OpGreater64F(v)
case OpHmul32:
return rewriteValueARM64_OpHmul32(v)
case OpHmul32u:
return true
}
}
-func rewriteValueARM64_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq32F x y)
- // result: (GreaterEqualF (FCMPS x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpARM64GreaterEqualF)
- v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueARM64_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq64F x y)
- // result: (GreaterEqualF (FCMPD x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpARM64GreaterEqualF)
- v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueARM64_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater32F x y)
- // result: (GreaterThanF (FCMPS x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpARM64GreaterThanF)
- v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueARM64_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater64F x y)
- // result: (GreaterThanF (FCMPD x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpARM64GreaterThanF)
- v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
func rewriteValueARM64_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return rewriteValueMIPS_OpEqB(v)
case OpEqPtr:
return rewriteValueMIPS_OpEqPtr(v)
- case OpGeq32F:
- return rewriteValueMIPS_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValueMIPS_OpGeq64F(v)
case OpGetCallerPC:
v.Op = OpMIPSLoweredGetCallerPC
return true
case OpGetClosurePtr:
v.Op = OpMIPSLoweredGetClosurePtr
return true
- case OpGreater32F:
- return rewriteValueMIPS_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValueMIPS_OpGreater64F(v)
case OpHmul32:
return rewriteValueMIPS_OpHmul32(v)
case OpHmul32u:
return true
}
}
-func rewriteValueMIPS_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq32F x y)
- // result: (FPFlagTrue (CMPGEF x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSFPFlagTrue)
- v0 := b.NewValue0(v.Pos, OpMIPSCMPGEF, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueMIPS_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq64F x y)
- // result: (FPFlagTrue (CMPGED x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSFPFlagTrue)
- v0 := b.NewValue0(v.Pos, OpMIPSCMPGED, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueMIPS_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater32F x y)
- // result: (FPFlagTrue (CMPGTF x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSFPFlagTrue)
- v0 := b.NewValue0(v.Pos, OpMIPSCMPGTF, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueMIPS_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater64F x y)
- // result: (FPFlagTrue (CMPGTD x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSFPFlagTrue)
- v0 := b.NewValue0(v.Pos, OpMIPSCMPGTD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
func rewriteValueMIPS_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return rewriteValueMIPS64_OpEqB(v)
case OpEqPtr:
return rewriteValueMIPS64_OpEqPtr(v)
- case OpGeq32F:
- return rewriteValueMIPS64_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValueMIPS64_OpGeq64F(v)
case OpGetCallerPC:
v.Op = OpMIPS64LoweredGetCallerPC
return true
case OpGetClosurePtr:
v.Op = OpMIPS64LoweredGetClosurePtr
return true
- case OpGreater32F:
- return rewriteValueMIPS64_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValueMIPS64_OpGreater64F(v)
case OpHmul32:
return rewriteValueMIPS64_OpHmul32(v)
case OpHmul32u:
return true
}
}
-func rewriteValueMIPS64_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq32F x y)
- // result: (FPFlagTrue (CMPGEF x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPS64FPFlagTrue)
- v0 := b.NewValue0(v.Pos, OpMIPS64CMPGEF, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueMIPS64_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq64F x y)
- // result: (FPFlagTrue (CMPGED x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPS64FPFlagTrue)
- v0 := b.NewValue0(v.Pos, OpMIPS64CMPGED, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueMIPS64_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater32F x y)
- // result: (FPFlagTrue (CMPGTF x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPS64FPFlagTrue)
- v0 := b.NewValue0(v.Pos, OpMIPS64CMPGTF, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueMIPS64_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater64F x y)
- // result: (FPFlagTrue (CMPGTD x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPS64FPFlagTrue)
- v0 := b.NewValue0(v.Pos, OpMIPS64CMPGTD, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
func rewriteValueMIPS64_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
case OpFloor:
v.Op = OpPPC64FFLOOR
return true
- case OpGeq32F:
- return rewriteValuePPC64_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValuePPC64_OpGeq64F(v)
case OpGetCallerPC:
v.Op = OpPPC64LoweredGetCallerPC
return true
case OpGetClosurePtr:
v.Op = OpPPC64LoweredGetClosurePtr
return true
- case OpGreater32F:
- return rewriteValuePPC64_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValuePPC64_OpGreater64F(v)
case OpHmul32:
v.Op = OpPPC64MULHW
return true
return true
}
}
-func rewriteValuePPC64_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq32F x y)
- // result: (FGreaterEqual (FCMPU x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpPPC64FGreaterEqual)
- v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValuePPC64_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Geq64F x y)
- // result: (FGreaterEqual (FCMPU x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpPPC64FGreaterEqual)
- v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValuePPC64_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater32F x y)
- // result: (FGreaterThan (FCMPU x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpPPC64FGreaterThan)
- v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValuePPC64_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- // match: (Greater64F x y)
- // result: (FGreaterThan (FCMPU x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpPPC64FGreaterThan)
- v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, types.TypeFlags)
- v0.AddArg2(x, y)
- v.AddArg(v0)
- return true
- }
-}
func rewriteValuePPC64_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return rewriteValueRISCV64_OpEqB(v)
case OpEqPtr:
return rewriteValueRISCV64_OpEqPtr(v)
- case OpGeq32F:
- return rewriteValueRISCV64_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValueRISCV64_OpGeq64F(v)
case OpGetCallerPC:
v.Op = OpRISCV64LoweredGetCallerPC
return true
case OpGetClosurePtr:
v.Op = OpRISCV64LoweredGetClosurePtr
return true
- case OpGreater32F:
- return rewriteValueRISCV64_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValueRISCV64_OpGreater64F(v)
case OpHmul32:
return rewriteValueRISCV64_OpHmul32(v)
case OpHmul32u:
return true
}
}
-func rewriteValueRISCV64_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Geq32F x y)
- // result: (FLES y x)
- for {
- x := v_0
- y := v_1
- v.reset(OpRISCV64FLES)
- v.AddArg2(y, x)
- return true
- }
-}
-func rewriteValueRISCV64_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Geq64F x y)
- // result: (FLED y x)
- for {
- x := v_0
- y := v_1
- v.reset(OpRISCV64FLED)
- v.AddArg2(y, x)
- return true
- }
-}
-func rewriteValueRISCV64_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater32F x y)
- // result: (FLTS y x)
- for {
- x := v_0
- y := v_1
- v.reset(OpRISCV64FLTS)
- v.AddArg2(y, x)
- return true
- }
-}
-func rewriteValueRISCV64_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater64F x y)
- // result: (FLTD y x)
- for {
- x := v_0
- y := v_1
- v.reset(OpRISCV64FLTD)
- v.AddArg2(y, x)
- return true
- }
-}
func rewriteValueRISCV64_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return rewriteValueS390X_OpFMA(v)
case OpFloor:
return rewriteValueS390X_OpFloor(v)
- case OpGeq32F:
- return rewriteValueS390X_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValueS390X_OpGeq64F(v)
case OpGetCallerPC:
v.Op = OpS390XLoweredGetCallerPC
return true
case OpGetG:
v.Op = OpS390XLoweredGetG
return true
- case OpGreater32F:
- return rewriteValueS390X_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValueS390X_OpGreater64F(v)
case OpHmul32:
return rewriteValueS390X_OpHmul32(v)
case OpHmul32u:
return true
}
}
-func rewriteValueS390X_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Geq32F x y)
- // result: (LOCGR {s390x.GreaterOrEqual} (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpS390XLOCGR)
- v.Aux = s390x.GreaterOrEqual
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
- v0.AuxInt = 0
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
- v1.AuxInt = 1
- v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
- v2.AddArg2(x, y)
- v.AddArg3(v0, v1, v2)
- return true
- }
-}
-func rewriteValueS390X_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Geq64F x y)
- // result: (LOCGR {s390x.GreaterOrEqual} (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpS390XLOCGR)
- v.Aux = s390x.GreaterOrEqual
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
- v0.AuxInt = 0
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
- v1.AuxInt = 1
- v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
- v2.AddArg2(x, y)
- v.AddArg3(v0, v1, v2)
- return true
- }
-}
-func rewriteValueS390X_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Greater32F x y)
- // result: (LOCGR {s390x.Greater} (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpS390XLOCGR)
- v.Aux = s390x.Greater
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
- v0.AuxInt = 0
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
- v1.AuxInt = 1
- v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
- v2.AddArg2(x, y)
- v.AddArg3(v0, v1, v2)
- return true
- }
-}
-func rewriteValueS390X_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Greater64F x y)
- // result: (LOCGR {s390x.Greater} (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
- for {
- x := v_0
- y := v_1
- v.reset(OpS390XLOCGR)
- v.Aux = s390x.Greater
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
- v0.AuxInt = 0
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
- v1.AuxInt = 1
- v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
- v2.AddArg2(x, y)
- v.AddArg3(v0, v1, v2)
- return true
- }
-}
func rewriteValueS390X_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
case OpFloor:
v.Op = OpWasmF64Floor
return true
- case OpGeq32F:
- v.Op = OpWasmF32Ge
- return true
- case OpGeq64F:
- v.Op = OpWasmF64Ge
- return true
case OpGetCallerPC:
v.Op = OpWasmLoweredGetCallerPC
return true
case OpGetClosurePtr:
v.Op = OpWasmLoweredGetClosurePtr
return true
- case OpGreater32F:
- v.Op = OpWasmF32Gt
- return true
- case OpGreater64F:
- v.Op = OpWasmF64Gt
- return true
case OpInterCall:
v.Op = OpWasmLoweredInterCall
return true
return rewriteValuegeneric_OpEqPtr(v)
case OpEqSlice:
return rewriteValuegeneric_OpEqSlice(v)
- case OpGeq32F:
- return rewriteValuegeneric_OpGeq32F(v)
- case OpGeq64F:
- return rewriteValuegeneric_OpGeq64F(v)
- case OpGreater32F:
- return rewriteValuegeneric_OpGreater32F(v)
- case OpGreater64F:
- return rewriteValuegeneric_OpGreater64F(v)
case OpIMake:
return rewriteValuegeneric_OpIMake(v)
case OpInterCall:
return true
}
}
-func rewriteValuegeneric_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Geq32F (Const32F [c]) (Const32F [d]))
- // result: (ConstBool [b2i(auxTo32F(c) >= auxTo32F(d))])
- for {
- if v_0.Op != OpConst32F {
- break
- }
- c := v_0.AuxInt
- if v_1.Op != OpConst32F {
- break
- }
- d := v_1.AuxInt
- v.reset(OpConstBool)
- v.AuxInt = b2i(auxTo32F(c) >= auxTo32F(d))
- return true
- }
- return false
-}
-func rewriteValuegeneric_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Geq64F (Const64F [c]) (Const64F [d]))
- // result: (ConstBool [b2i(auxTo64F(c) >= auxTo64F(d))])
- for {
- if v_0.Op != OpConst64F {
- break
- }
- c := v_0.AuxInt
- if v_1.Op != OpConst64F {
- break
- }
- d := v_1.AuxInt
- v.reset(OpConstBool)
- v.AuxInt = b2i(auxTo64F(c) >= auxTo64F(d))
- return true
- }
- return false
-}
-func rewriteValuegeneric_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater32F (Const32F [c]) (Const32F [d]))
- // result: (ConstBool [b2i(auxTo32F(c) > auxTo32F(d))])
- for {
- if v_0.Op != OpConst32F {
- break
- }
- c := v_0.AuxInt
- if v_1.Op != OpConst32F {
- break
- }
- d := v_1.AuxInt
- v.reset(OpConstBool)
- v.AuxInt = b2i(auxTo32F(c) > auxTo32F(d))
- return true
- }
- return false
-}
-func rewriteValuegeneric_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater64F (Const64F [c]) (Const64F [d]))
- // result: (ConstBool [b2i(auxTo64F(c) > auxTo64F(d))])
- for {
- if v_0.Op != OpConst64F {
- break
- }
- c := v_0.AuxInt
- if v_1.Op != OpConst64F {
- break
- }
- d := v_1.AuxInt
- v.reset(OpConstBool)
- v.AuxInt = b2i(auxTo64F(c) > auxTo64F(d))
- return true
- }
- return false
-}
func rewriteValuegeneric_OpIMake(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
}
func Cmp(f float64) bool {
- // arm64:"FCMPD","BLE",-"CSET\tGT",-"CBZ"
+ // arm64:"FCMPD","(BGT|BLE|BMI|BPL)",-"CSET\tGT",-"CBZ"
return f > 4 || f < -4
}