| // Copyright 2016 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Lowering arithmetic |
| (Add64 x y) -> (ADD x y) |
| (AddPtr x y) -> (ADD x y) |
| (Add32 x y) -> (ADD x y) |
| (Add16 x y) -> (ADD x y) |
| (Add8 x y) -> (ADD x y) |
| (Add64F x y) -> (FADD x y) |
| (Add32F x y) -> (FADDS x y) |
| |
| (Sub64 x y) -> (SUB x y) |
| (SubPtr x y) -> (SUB x y) |
| (Sub32 x y) -> (SUB x y) |
| (Sub16 x y) -> (SUB x y) |
| (Sub8 x y) -> (SUB x y) |
| (Sub32F x y) -> (FSUBS x y) |
| (Sub64F x y) -> (FSUB x y) |
| |
| (Mod16 x y) -> (Mod32 (SignExt16to32 x) (SignExt16to32 y)) |
| (Mod16u x y) -> (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y)) |
| (Mod8 x y) -> (Mod32 (SignExt8to32 x) (SignExt8to32 y)) |
| (Mod8u x y) -> (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y)) |
| (Mod64 x y) -> (SUB x (MULLD y (DIVD x y))) |
| (Mod64u x y) -> (SUB x (MULLD y (DIVDU x y))) |
| (Mod32 x y) -> (SUB x (MULLW y (DIVW x y))) |
| (Mod32u x y) -> (SUB x (MULLW y (DIVWU x y))) |
| |
| (Avg64u <t> x y) -> (ADD (ADD <t> (SRD <t> x (MOVDconst <t> [1])) (SRD <t> y (MOVDconst <t> [1]))) (ANDconst <t> (AND <t> x y) [1])) |
| |
| (Mul64 x y) -> (MULLD x y) |
| (Mul32 x y) -> (MULLW x y) |
| (Mul16 x y) -> (MULLW x y) |
| (Mul8 x y) -> (MULLW x y) |
| |
| (Div64 x y) -> (DIVD x y) |
| (Div64u x y) -> (DIVDU x y) |
| (Div32 x y) -> (DIVW x y) |
| (Div32u x y) -> (DIVWU x y) |
| (Div16 x y) -> (DIVW (SignExt16to32 x) (SignExt16to32 y)) |
| (Div16u x y) -> (DIVWU (ZeroExt16to32 x) (ZeroExt16to32 y)) |
| (Div8 x y) -> (DIVW (SignExt8to32 x) (SignExt8to32 y)) |
| (Div8u x y) -> (DIVWU (ZeroExt8to32 x) (ZeroExt8to32 y)) |
| |
| (Hmul64 x y) -> (MULHD x y) |
| (Hmul64u x y) -> (MULHDU x y) |
| (Hmul32 x y) -> (MULHW x y) |
| (Hmul32u x y) -> (MULHWU x y) |
| (Hmul16 x y) -> (SRAWconst (MULLW <config.fe.TypeInt32()> (SignExt16to32 x) (SignExt16to32 y)) [16]) |
| (Hmul16u x y) -> (SRWconst (MULLW <config.fe.TypeUInt32()> (ZeroExt16to32 x) (ZeroExt16to32 y)) [16]) |
| (Hmul8 x y) -> (SRAWconst (MULLW <config.fe.TypeInt16()> (SignExt8to32 x) (SignExt8to32 y)) [8]) |
| (Hmul8u x y) -> (SRWconst (MULLW <config.fe.TypeUInt16()> (ZeroExt8to32 x) (ZeroExt8to32 y)) [8]) |
| |
| (Mul32F x y) -> (FMULS x y) |
| (Mul64F x y) -> (FMUL x y) |
| |
| (Div32F x y) -> (FDIVS x y) |
| (Div64F x y) -> (FDIV x y) |
| |
| // Lowering float <-> int |
| (Cvt32to32F x) -> (FRSP (FCFID (Xi2f64 (SignExt32to64 x)))) |
| (Cvt32to64F x) -> (FCFID (Xi2f64 (SignExt32to64 x))) |
| (Cvt64to32F x) -> (FRSP (FCFID (Xi2f64 x))) |
| (Cvt64to64F x) -> (FCFID (Xi2f64 x)) |
| |
| (Cvt32Fto32 x) -> (Xf2i64 (FCTIWZ x)) |
| (Cvt32Fto64 x) -> (Xf2i64 (FCTIDZ x)) |
| (Cvt64Fto32 x) -> (Xf2i64 (FCTIWZ x)) |
| (Cvt64Fto64 x) -> (Xf2i64 (FCTIDZ x)) |
| |
| (Cvt32Fto64F x) -> x // Note x will have the wrong type for patterns dependent on Float32/Float64 |
| (Cvt64Fto32F x) -> (FRSP x) |
| |
| (Sqrt x) -> (FSQRT x) |
| |
| (Rsh64x64 x y) -> (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) |
| (Rsh64Ux64 x y) -> (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) |
| (Lsh64x64 x y) -> (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) |
| |
| (Rsh32x64 x y) -> (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) |
| (Rsh32Ux64 x y) -> (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) |
| (Lsh32x64 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) |
| |
| (Rsh16x64 x y) -> (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) |
| (Rsh16Ux64 x y) -> (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) |
| (Lsh16x64 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) |
| |
| (Rsh8x64 x y) -> (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) |
| (Rsh8Ux64 x y) -> (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) |
| (Lsh8x64 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) |
| |
| |
| (Rsh64x32 x y) -> (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) |
| (Rsh64Ux32 x y) -> (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) |
| (Lsh64x32 x y) -> (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) |
| |
| (Rsh32x32 x y) -> (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) |
| (Rsh32Ux32 x y) -> (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) |
| (Lsh32x32 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) |
| |
| (Rsh16x32 x y) -> (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) |
| (Rsh16Ux32 x y) -> (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) |
| (Lsh16x32 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) |
| |
| (Rsh8x32 x y) -> (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) |
| (Rsh8Ux32 x y) -> (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) |
| (Lsh8x32 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) |
| |
| |
| (Rsh64x16 x y) -> (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) |
| (Rsh64Ux16 x y) -> (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) |
| (Lsh64x16 x y) -> (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) |
| |
| (Rsh32x16 x y) -> (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) |
| (Rsh32Ux16 x y) -> (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) |
| (Lsh32x16 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) |
| |
| (Rsh16x16 x y) -> (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) |
| (Rsh16Ux16 x y) -> (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) |
| (Lsh16x16 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) |
| |
| (Rsh8x16 x y) -> (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) |
| (Rsh8Ux16 x y) -> (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) |
| (Lsh8x16 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) |
| |
| |
| (Rsh64x8 x y) -> (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) |
| (Rsh64Ux8 x y) -> (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) |
| (Lsh64x8 x y) -> (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) |
| |
| (Rsh32x8 x y) -> (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) |
| (Rsh32Ux8 x y) -> (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) |
| (Lsh32x8 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) |
| |
| (Rsh16x8 x y) -> (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) |
| (Rsh16Ux8 x y) -> (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) |
| (Lsh16x8 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) |
| |
| (Rsh8x8 x y) -> (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) |
| (Rsh8Ux8 x y) -> (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) |
| (Lsh8x8 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) |
| |
| // Potentially useful optimizing rewrites. |
| // (ADDconstForCarry [k] c), k < 0 && (c < 0 || k+c >= 0) -> CarrySet |
| // (ADDconstForCarry [k] c), K < 0 && (c >= 0 && k+c < 0) -> CarryClear |
| // (MaskIfNotCarry CarrySet) -> 0 |
| // (MaskIfNotCarry CarrySet) -> -1 |
| |
| // Lowering constants |
| (Const8 [val]) -> (MOVWconst [val]) |
| (Const16 [val]) -> (MOVWconst [val]) |
| (Const32 [val]) -> (MOVWconst [val]) |
| (Const64 [val]) -> (MOVDconst [val]) |
| (Const32F [val]) -> (FMOVSconst [val]) |
| (Const64F [val]) -> (FMOVDconst [val]) |
| (ConstNil) -> (MOVDconst [0]) |
| (ConstBool [b]) -> (MOVWconst [b]) |
| |
| (Addr {sym} base) -> (MOVDaddr {sym} base) |
| // (Addr {sym} base) -> (ADDconst {sym} base) |
| (OffPtr [off] ptr) -> (ADD (MOVDconst <config.Frontend().TypeInt64()> [off]) ptr) |
| |
| (And64 x y) -> (AND x y) |
| (And32 x y) -> (AND x y) |
| (And16 x y) -> (AND x y) |
| (And8 x y) -> (AND x y) |
| |
| (Or64 x y) -> (OR x y) |
| (Or32 x y) -> (OR x y) |
| (Or16 x y) -> (OR x y) |
| (Or8 x y) -> (OR x y) |
| |
| (Xor64 x y) -> (XOR x y) |
| (Xor32 x y) -> (XOR x y) |
| (Xor16 x y) -> (XOR x y) |
| (Xor8 x y) -> (XOR x y) |
| |
| (Neg64F x) -> (FNEG x) |
| (Neg32F x) -> (FNEG x) |
| (Neg64 x) -> (NEG x) |
| (Neg32 x) -> (NEG x) |
| (Neg16 x) -> (NEG x) |
| (Neg8 x) -> (NEG x) |
| |
| (Com64 x) -> (XORconst [-1] x) |
| (Com32 x) -> (XORconst [-1] x) |
| (Com16 x) -> (XORconst [-1] x) |
| (Com8 x) -> (XORconst [-1] x) |
| |
| // Lowering boolean ops |
| (AndB x y) -> (AND x y) |
| (OrB x y) -> (OR x y) |
| (Not x) -> (XORconst [1] x) |
| |
| // Lowering comparisons |
| (EqB x y) -> (ANDconst [1] (EQV x y)) |
| (Eq8 x y) -> (Equal (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y))) |
| (Eq16 x y) -> (Equal (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y))) |
| (Eq32 x y) -> (Equal (CMPW x y)) |
| (Eq64 x y) -> (Equal (CMP x y)) |
| (Eq32F x y) -> (Equal (FCMPU x y)) |
| (Eq64F x y) -> (Equal (FCMPU x y)) |
| (EqPtr x y) -> (Equal (CMP x y)) |
| |
| (NeqB x y) -> (XOR x y) |
| (Neq8 x y) -> (NotEqual (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y))) |
| (Neq16 x y) -> (NotEqual (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y))) |
| (Neq32 x y) -> (NotEqual (CMPW x y)) |
| (Neq64 x y) -> (NotEqual (CMP x y)) |
| (Neq32F x y) -> (NotEqual (FCMPU x y)) |
| (Neq64F x y) -> (NotEqual (FCMPU x y)) |
| (NeqPtr x y) -> (NotEqual (CMP x y)) |
| |
| (Less8 x y) -> (LessThan (CMPW (SignExt8to32 x) (SignExt8to32 y))) |
| (Less16 x y) -> (LessThan (CMPW (SignExt16to32 x) (SignExt16to32 y))) |
| (Less32 x y) -> (LessThan (CMPW x y)) |
| (Less64 x y) -> (LessThan (CMP x y)) |
| (Less32F x y) -> (FLessThan (FCMPU x y)) |
| (Less64F x y) -> (FLessThan (FCMPU x y)) |
| |
| (Less8U x y) -> (LessThan (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y))) |
| (Less16U x y) -> (LessThan (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y))) |
| (Less32U x y) -> (LessThan (CMPWU x y)) |
| (Less64U x y) -> (LessThan (CMPU x y)) |
| |
| (Leq8 x y) -> (LessEqual (CMPW (SignExt8to32 x) (SignExt8to32 y))) |
| (Leq16 x y) -> (LessEqual (CMPW (SignExt16to32 x) (SignExt16to32 y))) |
| (Leq32 x y) -> (LessEqual (CMPW x y)) |
| (Leq64 x y) -> (LessEqual (CMP x y)) |
| (Leq32F x y) -> (FLessEqual (FCMPU x y)) |
| (Leq64F x y) -> (FLessEqual (FCMPU x y)) |
| |
| (Leq8U x y) -> (LessEqual (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y))) |
| (Leq16U x y) -> (LessEqual (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y))) |
| (Leq32U x y) -> (LessEqual (CMPWU x y)) |
| (Leq64U x y) -> (LessEqual (CMPU x y)) |
| |
| (Greater8 x y) -> (GreaterThan (CMPW (SignExt8to32 x) (SignExt8to32 y))) |
| (Greater16 x y) -> (GreaterThan (CMPW (SignExt16to32 x) (SignExt16to32 y))) |
| (Greater32 x y) -> (GreaterThan (CMPW x y)) |
| (Greater64 x y) -> (GreaterThan (CMP x y)) |
| (Greater32F x y) -> (FGreaterThan (FCMPU x y)) |
| (Greater64F x y) -> (FGreaterThan (FCMPU x y)) |
| |
| (Greater8U x y) -> (GreaterThan (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y))) |
| (Greater16U x y) -> (GreaterThan (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y))) |
| (Greater32U x y) -> (GreaterThan (CMPWU x y)) |
| (Greater64U x y) -> (GreaterThan (CMPU x y)) |
| |
| (Geq8 x y) -> (GreaterEqual (CMPW (SignExt8to32 x) (SignExt8to32 y))) |
| (Geq16 x y) -> (GreaterEqual (CMPW (SignExt16to32 x) (SignExt16to32 y))) |
| (Geq32 x y) -> (GreaterEqual (CMPW x y)) |
| (Geq64 x y) -> (GreaterEqual (CMP x y)) |
| (Geq32F x y) -> (FGreaterEqual (FCMPU x y)) |
| (Geq64F x y) -> (FGreaterEqual (FCMPU x y)) |
| |
| (Geq8U x y) -> (GreaterEqual (CMPU (ZeroExt8to32 x) (ZeroExt8to32 y))) |
| (Geq16U x y) -> (GreaterEqual (CMPU (ZeroExt16to32 x) (ZeroExt16to32 y))) |
| (Geq32U x y) -> (GreaterEqual (CMPU x y)) |
| (Geq64U x y) -> (GreaterEqual (CMPU 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) |
| (If (LessThan cc) yes no) -> (LT cc yes no) |
| (If (LessEqual cc) yes no) -> (LE cc yes no) |
| (If (GreaterThan cc) yes no) -> (GT cc yes no) |
| (If (GreaterEqual cc) yes no) -> (GE cc yes no) |
| (If (FLessThan cc) yes no) -> (FLT cc yes no) |
| (If (FLessEqual cc) yes no) -> (FLE cc yes no) |
| (If (FGreaterThan cc) yes no) -> (FGT cc yes no) |
| (If (FGreaterEqual cc) yes no) -> (FGE cc yes no) |
| |
| (If cond yes no) -> (NE (CMPWconst [0] cond) yes no) |
| |
| // Absorb boolean tests into block |
| (NE (CMPWconst [0] (Equal cc)) yes no) -> (EQ cc yes no) |
| (NE (CMPWconst [0] (NotEqual cc)) yes no) -> (NE cc yes no) |
| (NE (CMPWconst [0] (LessThan cc)) yes no) -> (LT cc yes no) |
| (NE (CMPWconst [0] (LessEqual cc)) yes no) -> (LE cc yes no) |
| (NE (CMPWconst [0] (GreaterThan cc)) yes no) -> (GT cc yes no) |
| (NE (CMPWconst [0] (GreaterEqual cc)) yes no) -> (GE cc yes no) |
| // (NE (CMPWconst [0] (FLessThan cc)) yes no) -> (FLT cc yes no) |
| // (NE (CMPWconst [0] (FLessEqual cc)) yes no) -> (FLE cc yes no) |
| // (NE (CMPWconst [0] (FGreaterThan cc)) yes no) -> (FGT cc yes no) |
| // (NE (CMPWconst [0] (FGreaterEqual cc)) yes no) -> (FGE cc yes no) |
| |
| // absorb flag constants into branches |
| (EQ (FlagEQ) yes no) -> (First nil yes no) |
| (EQ (FlagLT) yes no) -> (First nil no yes) |
| (EQ (FlagGT) yes no) -> (First nil no yes) |
| |
| (NE (FlagEQ) yes no) -> (First nil no yes) |
| (NE (FlagLT) yes no) -> (First nil yes no) |
| (NE (FlagGT) yes no) -> (First nil yes no) |
| |
| (LT (FlagEQ) yes no) -> (First nil no yes) |
| (LT (FlagLT) yes no) -> (First nil yes no) |
| (LT (FlagGT) yes no) -> (First nil no yes) |
| |
| (LE (FlagEQ) yes no) -> (First nil yes no) |
| (LE (FlagLT) yes no) -> (First nil yes no) |
| (LE (FlagGT) yes no) -> (First nil no yes) |
| |
| (GT (FlagEQ) yes no) -> (First nil no yes) |
| (GT (FlagLT) yes no) -> (First nil no yes) |
| (GT (FlagGT) yes no) -> (First nil yes no) |
| |
| (GE (FlagEQ) yes no) -> (First nil yes no) |
| (GE (FlagLT) yes no) -> (First nil no yes) |
| (GE (FlagGT) yes no) -> (First nil yes no) |
| |
| // absorb InvertFlags into branches |
| (LT (InvertFlags cmp) yes no) -> (GT cmp yes no) |
| (GT (InvertFlags cmp) yes no) -> (LT cmp yes no) |
| (LE (InvertFlags cmp) yes no) -> (GE cmp yes no) |
| (GE (InvertFlags cmp) yes no) -> (LE cmp yes no) |
| (EQ (InvertFlags cmp) yes no) -> (EQ cmp yes no) |
| (NE (InvertFlags cmp) yes no) -> (NE cmp yes no) |
| |
| // (FLT (InvertFlags cmp) yes no) -> (FGT cmp yes no) |
| // (FGT (InvertFlags cmp) yes no) -> (FLT cmp yes no) |
| // (FLE (InvertFlags cmp) yes no) -> (FGE cmp yes no) |
| // (FGE (InvertFlags cmp) yes no) -> (FLE cmp yes no) |
| |
| // constant comparisons |
| (CMPWconst (MOVWconst [x]) [y]) && int32(x)==int32(y) -> (FlagEQ) |
| (CMPWconst (MOVWconst [x]) [y]) && int32(x)<int32(y) -> (FlagLT) |
| (CMPWconst (MOVWconst [x]) [y]) && int32(x)>int32(y) -> (FlagGT) |
| |
| (CMPconst (MOVDconst [x]) [y]) && int64(x)==int64(y) -> (FlagEQ) |
| (CMPconst (MOVDconst [x]) [y]) && int64(x)<int64(y) -> (FlagLT) |
| (CMPconst (MOVDconst [x]) [y]) && int64(x)>int64(y) -> (FlagGT) |
| |
| (CMPWUconst (MOVWconst [x]) [y]) && int32(x)==int32(y) -> (FlagEQ) |
| (CMPWUconst (MOVWconst [x]) [y]) && uint32(x)<uint32(y) -> (FlagLT) |
| (CMPWUconst (MOVWconst [x]) [y]) && uint32(x)>uint32(y) -> (FlagGT) |
| |
| (CMPUconst (MOVDconst [x]) [y]) && int64(x)==int64(y) -> (FlagEQ) |
| (CMPUconst (MOVDconst [x]) [y]) && uint64(x)<uint64(y) -> (FlagLT) |
| (CMPUconst (MOVDconst [x]) [y]) && uint64(x)>uint64(y) -> (FlagGT) |
| |
| // other known comparisons |
| //(CMPconst (MOVBUreg _) [c]) && 0xff < c -> (FlagLT) |
| //(CMPconst (MOVHUreg _) [c]) && 0xffff < c -> (FlagLT) |
| //(CMPconst (ANDconst _ [m]) [n]) && 0 <= int32(m) && int32(m) < int32(n) -> (FlagLT) |
| //(CMPconst (SRLconst _ [c]) [n]) && 0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n) -> (FlagLT) |
| |
| // absorb flag constants into boolean values |
| (Equal (FlagEQ)) -> (MOVWconst [1]) |
| (Equal (FlagLT)) -> (MOVWconst [0]) |
| (Equal (FlagGT)) -> (MOVWconst [0]) |
| |
| (NotEqual (FlagEQ)) -> (MOVWconst [0]) |
| (NotEqual (FlagLT)) -> (MOVWconst [1]) |
| (NotEqual (FlagGT)) -> (MOVWconst [1]) |
| |
| (LessThan (FlagEQ)) -> (MOVWconst [0]) |
| (LessThan (FlagLT)) -> (MOVWconst [1]) |
| (LessThan (FlagGT)) -> (MOVWconst [0]) |
| |
| (LessEqual (FlagEQ)) -> (MOVWconst [1]) |
| (LessEqual (FlagLT)) -> (MOVWconst [1]) |
| (LessEqual (FlagGT)) -> (MOVWconst [0]) |
| |
| (GreaterThan (FlagEQ)) -> (MOVWconst [0]) |
| (GreaterThan (FlagLT)) -> (MOVWconst [0]) |
| (GreaterThan (FlagGT)) -> (MOVWconst [1]) |
| |
| (GreaterEqual (FlagEQ)) -> (MOVWconst [1]) |
| (GreaterEqual (FlagLT)) -> (MOVWconst [0]) |
| (GreaterEqual (FlagGT)) -> (MOVWconst [1]) |
| |
| // absorb InvertFlags into boolean values |
| (Equal (InvertFlags x)) -> (Equal x) |
| (NotEqual (InvertFlags x)) -> (NotEqual x) |
| (LessThan (InvertFlags x)) -> (GreaterThan x) |
| (GreaterThan (InvertFlags x)) -> (LessThan x) |
| (LessEqual (InvertFlags x)) -> (GreaterEqual x) |
| (GreaterEqual (InvertFlags x)) -> (LessEqual x) |
| (FLessThan (InvertFlags x)) -> (FGreaterThan x) |
| (FGreaterThan (InvertFlags x)) -> (FLessThan x) |
| (FLessEqual (InvertFlags x)) -> (FGreaterEqual x) |
| (FGreaterEqual (InvertFlags x)) -> (FLessEqual x) |
| |
| |
| // Lowering loads |
| (Load <t> ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVDload ptr mem) |
| (Load <t> ptr mem) && is32BitInt(t) && isSigned(t) -> (MOVWload ptr mem) |
| (Load <t> ptr mem) && is32BitInt(t) && !isSigned(t) -> (MOVWZload ptr mem) |
| (Load <t> ptr mem) && is16BitInt(t) && isSigned(t) -> (MOVHload ptr mem) |
| (Load <t> ptr mem) && is16BitInt(t) && !isSigned(t) -> (MOVHZload ptr mem) |
| (Load <t> ptr mem) && (t.IsBoolean() || (is8BitInt(t) && isSigned(t))) -> (MOVBload ptr mem) |
| (Load <t> ptr mem) && is8BitInt(t) && !isSigned(t) -> (MOVBZload ptr mem) |
| |
| (Load <t> ptr mem) && is32BitFloat(t) -> (FMOVSload ptr mem) |
| (Load <t> ptr mem) && is64BitFloat(t) -> (FMOVDload ptr mem) |
| |
| (Store [8] ptr val mem) && is64BitFloat(val.Type) -> (FMOVDstore ptr val mem) |
| (Store [8] ptr val mem) && is32BitFloat(val.Type) -> (FMOVDstore ptr val mem) // glitch from (Cvt32Fto64F x) -> x -- type is wrong |
| (Store [4] ptr val mem) && is32BitFloat(val.Type) -> (FMOVSstore ptr val mem) |
| (Store [8] ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVDstore ptr val mem) |
| (Store [4] ptr val mem) && is32BitInt(val.Type) -> (MOVWstore ptr val mem) |
| (Store [2] ptr val mem) -> (MOVHstore ptr val mem) |
| (Store [1] ptr val mem) -> (MOVBstore ptr val mem) |
| |
| (Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstorezero destptr mem) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 -> |
| (MOVHstorezero destptr mem) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 2 -> |
| (MOVBstorezero [1] destptr |
| (MOVBstorezero [0] destptr mem)) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 -> |
| (MOVWstorezero destptr mem) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 -> |
| (MOVHstorezero [2] destptr |
| (MOVHstorezero [0] destptr mem)) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 -> |
| (MOVBstorezero [3] destptr |
| (MOVBstorezero [2] destptr |
| (MOVBstorezero [1] destptr |
| (MOVBstorezero [0] destptr mem)))) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0 -> |
| (MOVDstorezero [0] destptr mem) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0 -> |
| (MOVWstorezero [4] destptr |
| (MOVWstorezero [0] destptr mem)) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0 -> |
| (MOVHstorezero [6] destptr |
| (MOVHstorezero [4] destptr |
| (MOVHstorezero [2] destptr |
| (MOVHstorezero [0] destptr mem)))) |
| |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 3 -> |
| (MOVBstorezero [2] destptr |
| (MOVBstorezero [1] destptr |
| (MOVBstorezero [0] destptr mem))) |
| |
| // Zero small numbers of words directly. |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0 -> |
| (MOVDstorezero [8] destptr |
| (MOVDstorezero [0] destptr mem)) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0 -> |
| (MOVDstorezero [16] destptr |
| (MOVDstorezero [8] destptr |
| (MOVDstorezero [0] destptr mem))) |
| (Zero [s] destptr mem) && SizeAndAlign(s).Size() == 32 && SizeAndAlign(s).Align()%8 == 0 -> |
| (MOVDstorezero [24] destptr |
| (MOVDstorezero [16] destptr |
| (MOVDstorezero [8] destptr |
| (MOVDstorezero [0] destptr mem)))) |
| |
| // Large zeroing uses a loop |
| (Zero [s] ptr mem) |
| && (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0 -> |
| (LoweredZero [SizeAndAlign(s).Align()] |
| ptr |
| (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) |
| mem) |
| |
| // moves |
| (Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBZload src mem) mem) |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 -> |
| (MOVHstore dst (MOVHZload src mem) mem) |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 -> |
| (MOVBstore [1] dst (MOVBZload [1] src mem) |
| (MOVBstore dst (MOVBZload src mem) mem)) |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 -> |
| (MOVWstore dst (MOVWload src mem) mem) |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 -> |
| (MOVHstore [2] dst (MOVHZload [2] src mem) |
| (MOVHstore dst (MOVHZload src mem) mem)) |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 -> |
| (MOVBstore [3] dst (MOVBZload [3] src mem) |
| (MOVBstore [2] dst (MOVBZload [2] src mem) |
| (MOVBstore [1] dst (MOVBZload [1] src mem) |
| (MOVBstore dst (MOVBZload src mem) mem)))) |
| |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0 -> |
| (MOVDstore dst (MOVDload src mem) mem) |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0 -> |
| (MOVWstore [4] dst (MOVWZload [4] src mem) |
| (MOVWstore dst (MOVWZload src mem) mem)) |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0-> |
| (MOVHstore [6] dst (MOVHZload [6] src mem) |
| (MOVHstore [4] dst (MOVHZload [4] src mem) |
| (MOVHstore [2] dst (MOVHZload [2] src mem) |
| (MOVHstore dst (MOVHZload src mem) mem)))) |
| |
| (Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 -> |
| (MOVBstore [2] dst (MOVBZload [2] src mem) |
| (MOVBstore [1] dst (MOVBZload [1] src mem) |
| (MOVBstore dst (MOVBZload src mem) mem))) |
| |
| // Large move uses a loop |
| (Move [s] dst src mem) |
| && (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0 -> |
| (LoweredMove [SizeAndAlign(s).Align()] |
| dst |
| src |
| (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) |
| mem) |
| |
| // Calls |
| // Lowering calls |
| (StaticCall [argwid] {target} mem) -> (CALLstatic [argwid] {target} mem) |
| (ClosureCall [argwid] entry closure mem) -> (CALLclosure [argwid] entry closure mem) |
| (DeferCall [argwid] mem) -> (CALLdefer [argwid] mem) |
| (GoCall [argwid] mem) -> (CALLgo [argwid] mem) |
| (InterCall [argwid] entry mem) -> (CALLinter [argwid] entry mem) |
| |
| // Miscellaneous |
| (Convert <t> x mem) -> (MOVDconvert <t> x mem) |
| (GetClosurePtr) -> (LoweredGetClosurePtr) |
| (IsNonNil ptr) -> (NotEqual (CMPconst [0] ptr)) |
| (IsInBounds idx len) -> (LessThan (CMPU idx len)) |
| (IsSliceInBounds idx len) -> (LessEqual (CMPU idx len)) |
| (NilCheck ptr mem) -> (LoweredNilCheck ptr mem) |
| |
| // Optimizations |
| |
| (ADD (MOVDconst [c]) x) && int64(int32(c)) == c -> (ADDconst [c] x) |
| (ADD x (MOVDconst [c])) && int64(int32(c)) == c -> (ADDconst [c] x) |
| |
| // Fold offsets for stores. |
| (MOVDstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(off1+off2) -> (MOVDstore [off1+off2] {sym} x val mem) |
| (MOVWstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(off1+off2) -> (MOVWstore [off1+off2] {sym} x val mem) |
| (MOVHstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(off1+off2) -> (MOVHstore [off1+off2] {sym} x val mem) |
| (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem) && is16Bit(off1+off2) -> (MOVBstore [off1+off2] {sym} x val mem) |
| |
| // Store of zero -> storezero |
| (MOVDstore [off] {sym} ptr (MOVDconst [c]) mem) && c == 0 -> (MOVDstorezero [off] {sym} ptr mem) |
| (MOVWstore [off] {sym} ptr (MOVDconst [c]) mem) && c == 0 -> (MOVWstorezero [off] {sym} ptr mem) |
| (MOVHstore [off] {sym} ptr (MOVDconst [c]) mem) && c == 0 -> (MOVHstorezero [off] {sym} ptr mem) |
| (MOVBstore [off] {sym} ptr (MOVDconst [c]) mem) && c == 0 -> (MOVBstorezero [off] {sym} ptr mem) |
| |
| // Fold offsets for storezero |
| (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(off1+off2) -> |
| (MOVDstorezero [off1+off2] {sym} x mem) |
| (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(off1+off2) -> |
| (MOVWstorezero [off1+off2] {sym} x mem) |
| (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(off1+off2) -> |
| (MOVHstorezero [off1+off2] {sym} x mem) |
| (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem) && is16Bit(off1+off2) -> |
| (MOVBstorezero [off1+off2] {sym} x mem) |
| |
| // Lowering extension |
| // Note: we always extend to 64 bits even though some ops don't need that many result bits. |
| (SignExt8to16 x) -> (MOVBreg x) |
| (SignExt8to32 x) -> (MOVBreg x) |
| (SignExt8to64 x) -> (MOVBreg x) |
| (SignExt16to32 x) -> (MOVHreg x) |
| (SignExt16to64 x) -> (MOVHreg x) |
| (SignExt32to64 x) -> (MOVWreg x) |
| |
| (ZeroExt8to16 x) -> (MOVBZreg x) |
| (ZeroExt8to32 x) -> (MOVBZreg x) |
| (ZeroExt8to64 x) -> (MOVBZreg x) |
| (ZeroExt16to32 x) -> (MOVHZreg x) |
| (ZeroExt16to64 x) -> (MOVHZreg x) |
| (ZeroExt32to64 x) -> (MOVWZreg x) |
| |
| (Trunc16to8 x) -> (MOVBreg x) |
| (Trunc32to8 x) -> (MOVBreg x) |
| (Trunc32to16 x) -> (MOVHreg x) |
| (Trunc64to8 x) -> (MOVBreg x) |
| (Trunc64to16 x) -> (MOVHreg x) |
| (Trunc64to32 x) -> (MOVWreg x) |
| |