diff options
Diffstat (limited to 'llvm/lib/Target/RISCV/RISCVInstrInfoVSDPatterns.td')
-rw-r--r-- | llvm/lib/Target/RISCV/RISCVInstrInfoVSDPatterns.td | 854 |
1 files changed, 468 insertions, 386 deletions
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoVSDPatterns.td b/llvm/lib/Target/RISCV/RISCVInstrInfoVSDPatterns.td index 970c021297a2..374cffc01dfe 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoVSDPatterns.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoVSDPatterns.td @@ -144,28 +144,33 @@ class VPatBinarySDNode_XI_E<SDPatternOperator vop, xop_kind:$rs2, avl, log2sew)>; -multiclass VPatBinarySDNode_VV_VX<SDPatternOperator vop, string instruction_name> { - foreach vti = AllIntegerVectors in { - def : VPatBinarySDNode_VV<vop, instruction_name, - vti.Vector, vti.Vector, vti.Log2SEW, - vti.LMul, vti.AVL, vti.RegClass>; - def : VPatBinarySDNode_XI<vop, instruction_name, "VX", - vti.Vector, vti.Vector, vti.Log2SEW, - vti.LMul, vti.AVL, vti.RegClass, - SplatPat, GPR>; +multiclass VPatBinarySDNode_VV_VX<SDPatternOperator vop, string instruction_name, + list<VTypeInfo> vtilist = AllIntegerVectors> { + foreach vti = vtilist in { + let Predicates = GetVTypePredicates<vti>.Predicates in { + def : VPatBinarySDNode_VV<vop, instruction_name, + vti.Vector, vti.Vector, vti.Log2SEW, + vti.LMul, vti.AVL, vti.RegClass>; + def : VPatBinarySDNode_XI<vop, instruction_name, "VX", + vti.Vector, vti.Vector, vti.Log2SEW, + vti.LMul, vti.AVL, vti.RegClass, + SplatPat, GPR>; + } } } multiclass VPatBinarySDNode_VV_VX_E<SDPatternOperator vop, string instruction_name> { foreach vti = AllIntegerVectors in { - def : VPatBinarySDNode_VV_E<vop, instruction_name, - vti.Vector, vti.Vector, vti.Log2SEW, - vti.LMul, vti.SEW, vti.AVL, vti.RegClass>; - def : VPatBinarySDNode_XI_E<vop, instruction_name, "VX", - vti.Vector, vti.Vector, vti.Log2SEW, - vti.LMul, vti.SEW, vti.AVL, vti.RegClass, - SplatPat, GPR>; + let Predicates = GetVTypePredicates<vti>.Predicates in { + def : VPatBinarySDNode_VV_E<vop, instruction_name, + vti.Vector, vti.Vector, vti.Log2SEW, + vti.LMul, vti.SEW, vti.AVL, vti.RegClass>; + def : VPatBinarySDNode_XI_E<vop, instruction_name, "VX", + vti.Vector, vti.Vector, vti.Log2SEW, + vti.LMul, vti.SEW, vti.AVL, vti.RegClass, + SplatPat, GPR>; + } } } @@ -173,6 +178,7 @@ multiclass VPatBinarySDNode_VV_VX_VI<SDPatternOperator vop, string instruction_n Operand ImmType = simm5> : VPatBinarySDNode_VV_VX<vop, instruction_name> { foreach vti = AllIntegerVectors in { + let Predicates = GetVTypePredicates<vti>.Predicates in def : VPatBinarySDNode_XI<vop, instruction_name, "VI", vti.Vector, vti.Vector, vti.Log2SEW, vti.LMul, vti.AVL, vti.RegClass, @@ -218,31 +224,36 @@ class VPatBinarySDNode_VF_E<SDPatternOperator vop, multiclass VPatBinaryFPSDNode_VV_VF<SDPatternOperator vop, string instruction_name> { foreach vti = AllFloatVectors in { - def : VPatBinarySDNode_VV<vop, instruction_name, - vti.Vector, vti.Vector, vti.Log2SEW, - vti.LMul, vti.AVL, vti.RegClass>; - def : VPatBinarySDNode_VF<vop, instruction_name#"_V"#vti.ScalarSuffix, - vti.Vector, vti.Vector, vti.Scalar, - vti.Log2SEW, vti.LMul, vti.AVL, vti.RegClass, - vti.ScalarRegClass>; + let Predicates = GetVTypePredicates<vti>.Predicates in { + def : VPatBinarySDNode_VV<vop, instruction_name, + vti.Vector, vti.Vector, vti.Log2SEW, + vti.LMul, vti.AVL, vti.RegClass>; + def : VPatBinarySDNode_VF<vop, instruction_name#"_V"#vti.ScalarSuffix, + vti.Vector, vti.Vector, vti.Scalar, + vti.Log2SEW, vti.LMul, vti.AVL, vti.RegClass, + vti.ScalarRegClass>; + } } } multiclass VPatBinaryFPSDNode_VV_VF_E<SDPatternOperator vop, string instruction_name> { foreach vti = AllFloatVectors in { - def : VPatBinarySDNode_VV_E<vop, instruction_name, - vti.Vector, vti.Vector, vti.Log2SEW, - vti.LMul, vti.SEW, vti.AVL, vti.RegClass>; - def : VPatBinarySDNode_VF_E<vop, instruction_name#"_V"#vti.ScalarSuffix, - vti.Vector, vti.Vector, vti.Scalar, - vti.Log2SEW, vti.LMul, vti.SEW, vti.AVL, - vti.RegClass, vti.ScalarRegClass>; + let Predicates = GetVTypePredicates<vti>.Predicates in { + def : VPatBinarySDNode_VV_E<vop, instruction_name, + vti.Vector, vti.Vector, vti.Log2SEW, + vti.LMul, vti.SEW, vti.AVL, vti.RegClass>; + def : VPatBinarySDNode_VF_E<vop, instruction_name#"_V"#vti.ScalarSuffix, + vti.Vector, vti.Vector, vti.Scalar, + vti.Log2SEW, vti.LMul, vti.SEW, vti.AVL, + vti.RegClass, vti.ScalarRegClass>; + } } } multiclass VPatBinaryFPSDNode_R_VF<SDPatternOperator vop, string instruction_name> { foreach fvti = AllFloatVectors in + let Predicates = GetVTypePredicates<fvti>.Predicates in def : Pat<(fvti.Vector (vop (fvti.Vector (SplatFPOp fvti.Scalar:$rs2)), (fvti.Vector fvti.RegClass:$rs1))), (!cast<Instruction>(instruction_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX) @@ -254,6 +265,7 @@ multiclass VPatBinaryFPSDNode_R_VF<SDPatternOperator vop, string instruction_nam multiclass VPatBinaryFPSDNode_R_VF_E<SDPatternOperator vop, string instruction_name> { foreach fvti = AllFloatVectors in + let Predicates = GetVTypePredicates<fvti>.Predicates in def : Pat<(fvti.Vector (vop (fvti.Vector (SplatFPOp fvti.Scalar:$rs2)), (fvti.Vector fvti.RegClass:$rs1))), (!cast<Instruction>(instruction_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX#"_E"#fvti.SEW) @@ -266,6 +278,7 @@ multiclass VPatIntegerSetCCSDNode_VV<string instruction_name, CondCode cc> { foreach vti = AllIntegerVectors in { defvar instruction = !cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX); + let Predicates = GetVTypePredicates<vti>.Predicates in def : Pat<(vti.Mask (setcc (vti.Vector vti.RegClass:$rs1), (vti.Vector vti.RegClass:$rs2), cc)), (instruction vti.RegClass:$rs1, vti.RegClass:$rs2, vti.AVL, @@ -278,6 +291,7 @@ multiclass VPatIntegerSetCCSDNode_VV_Swappable<string instruction_name, : VPatIntegerSetCCSDNode_VV<instruction_name, cc> { foreach vti = AllIntegerVectors in { defvar instruction = !cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX); + let Predicates = GetVTypePredicates<vti>.Predicates in def : Pat<(vti.Mask (setcc (vti.Vector vti.RegClass:$rs2), (vti.Vector vti.RegClass:$rs1), invcc)), (instruction vti.RegClass:$rs1, vti.RegClass:$rs2, vti.AVL, @@ -293,6 +307,7 @@ multiclass VPatIntegerSetCCSDNode_XI< DAGOperand xop_kind> { foreach vti = AllIntegerVectors in { defvar instruction = !cast<Instruction>(instruction_name#_#kind#_#vti.LMul.MX); + let Predicates = GetVTypePredicates<vti>.Predicates in def : Pat<(vti.Mask (setcc (vti.Vector vti.RegClass:$rs1), (vti.Vector (SplatPatKind xop_kind:$rs2)), cc)), (instruction vti.RegClass:$rs1, xop_kind:$rs2, vti.AVL, vti.Log2SEW)>; @@ -308,12 +323,14 @@ multiclass VPatIntegerSetCCSDNode_XI_Swappable<string instruction_name, xop_kind> { foreach vti = AllIntegerVectors in { defvar instruction = !cast<Instruction>(instruction_name#_#kind#_#vti.LMul.MX); - def : Pat<(vti.Mask (setcc (vti.Vector vti.RegClass:$rs1), - (vti.Vector (SplatPatKind xop_kind:$rs2)), cc)), - (instruction vti.RegClass:$rs1, xop_kind:$rs2, vti.AVL, vti.Log2SEW)>; - def : Pat<(vti.Mask (setcc (vti.Vector (SplatPatKind xop_kind:$rs2)), - (vti.Vector vti.RegClass:$rs1), invcc)), - (instruction vti.RegClass:$rs1, xop_kind:$rs2, vti.AVL, vti.Log2SEW)>; + let Predicates = GetVTypePredicates<vti>.Predicates in { + def : Pat<(vti.Mask (setcc (vti.Vector vti.RegClass:$rs1), + (vti.Vector (SplatPatKind xop_kind:$rs2)), cc)), + (instruction vti.RegClass:$rs1, xop_kind:$rs2, vti.AVL, vti.Log2SEW)>; + def : Pat<(vti.Mask (setcc (vti.Vector (SplatPatKind xop_kind:$rs2)), + (vti.Vector vti.RegClass:$rs1), invcc)), + (instruction vti.RegClass:$rs1, xop_kind:$rs2, vti.AVL, vti.Log2SEW)>; + } } } @@ -329,6 +346,7 @@ multiclass VPatIntegerSetCCSDNode_VIPlus1<string instruction_name, CondCode cc, ComplexPattern splatpat_kind> { foreach vti = AllIntegerVectors in { defvar instruction = !cast<Instruction>(instruction_name#"_VI_"#vti.LMul.MX); + let Predicates = GetVTypePredicates<vti>.Predicates in def : Pat<(vti.Mask (setcc (vti.Vector vti.RegClass:$rs1), (vti.Vector (splatpat_kind simm5:$rs2)), cc)), @@ -341,23 +359,25 @@ multiclass VPatFPSetCCSDNode_VV_VF_FV<CondCode cc, string inst_name, string swapped_op_inst_name> { foreach fvti = AllFloatVectors in { - def : Pat<(fvti.Mask (setcc (fvti.Vector fvti.RegClass:$rs1), - (fvti.Vector fvti.RegClass:$rs2), - cc)), - (!cast<Instruction>(inst_name#"_VV_"#fvti.LMul.MX) - fvti.RegClass:$rs1, fvti.RegClass:$rs2, fvti.AVL, fvti.Log2SEW)>; - def : Pat<(fvti.Mask (setcc (fvti.Vector fvti.RegClass:$rs1), - (SplatFPOp fvti.ScalarRegClass:$rs2), - cc)), - (!cast<Instruction>(inst_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX) - fvti.RegClass:$rs1, fvti.ScalarRegClass:$rs2, - fvti.AVL, fvti.Log2SEW)>; - def : Pat<(fvti.Mask (setcc (SplatFPOp fvti.ScalarRegClass:$rs2), - (fvti.Vector fvti.RegClass:$rs1), - cc)), - (!cast<Instruction>(swapped_op_inst_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX) - fvti.RegClass:$rs1, fvti.ScalarRegClass:$rs2, - fvti.AVL, fvti.Log2SEW)>; + let Predicates = GetVTypePredicates<fvti>.Predicates in { + def : Pat<(fvti.Mask (setcc (fvti.Vector fvti.RegClass:$rs1), + (fvti.Vector fvti.RegClass:$rs2), + cc)), + (!cast<Instruction>(inst_name#"_VV_"#fvti.LMul.MX) + fvti.RegClass:$rs1, fvti.RegClass:$rs2, fvti.AVL, fvti.Log2SEW)>; + def : Pat<(fvti.Mask (setcc (fvti.Vector fvti.RegClass:$rs1), + (SplatFPOp fvti.ScalarRegClass:$rs2), + cc)), + (!cast<Instruction>(inst_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX) + fvti.RegClass:$rs1, fvti.ScalarRegClass:$rs2, + fvti.AVL, fvti.Log2SEW)>; + def : Pat<(fvti.Mask (setcc (SplatFPOp fvti.ScalarRegClass:$rs2), + (fvti.Vector fvti.RegClass:$rs1), + cc)), + (!cast<Instruction>(swapped_op_inst_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX) + fvti.RegClass:$rs1, fvti.ScalarRegClass:$rs2, + fvti.AVL, fvti.Log2SEW)>; + } } } @@ -367,6 +387,8 @@ multiclass VPatExtendSDNode_V<list<SDNode> ops, string inst_name, string suffix, defvar vti = vtiTofti.Vti; defvar fti = vtiTofti.Fti; foreach op = ops in + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<fti>.Predicates) in def : Pat<(vti.Vector (op (fti.Vector fti.RegClass:$rs2))), (!cast<Instruction>(inst_name#"_"#suffix#"_"#vti.LMul.MX) fti.RegClass:$rs2, fti.AVL, vti.Log2SEW)>; @@ -377,6 +399,8 @@ multiclass VPatConvertI2FPSDNode_V<SDPatternOperator vop, string instruction_name> { foreach fvti = AllFloatVectors in { defvar ivti = GetIntVTypeInfo<fvti>.Vti; + let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, + GetVTypePredicates<ivti>.Predicates) in def : Pat<(fvti.Vector (vop (ivti.Vector ivti.RegClass:$rs1))), (!cast<Instruction>(instruction_name#"_"#fvti.LMul.MX) ivti.RegClass:$rs1, fvti.AVL, fvti.Log2SEW)>; @@ -387,6 +411,8 @@ multiclass VPatConvertFP2ISDNode_V<SDPatternOperator vop, string instruction_name> { foreach fvti = AllFloatVectors in { defvar ivti = GetIntVTypeInfo<fvti>.Vti; + let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, + GetVTypePredicates<ivti>.Predicates) in def : Pat<(ivti.Vector (vop (fvti.Vector fvti.RegClass:$rs1))), (!cast<Instruction>(instruction_name#"_"#ivti.LMul.MX) fvti.RegClass:$rs1, ivti.AVL, ivti.Log2SEW)>; @@ -398,6 +424,8 @@ multiclass VPatWConvertI2FPSDNode_V<SDPatternOperator vop, foreach vtiToWti = AllWidenableIntToFloatVectors in { defvar ivti = vtiToWti.Vti; defvar fwti = vtiToWti.Wti; + let Predicates = !listconcat(GetVTypePredicates<ivti>.Predicates, + GetVTypePredicates<fwti>.Predicates) in def : Pat<(fwti.Vector (vop (ivti.Vector ivti.RegClass:$rs1))), (!cast<Instruction>(instruction_name#"_"#ivti.LMul.MX) ivti.RegClass:$rs1, ivti.AVL, ivti.Log2SEW)>; @@ -409,6 +437,8 @@ multiclass VPatWConvertFP2ISDNode_V<SDPatternOperator vop, foreach fvtiToFWti = AllWidenableFloatVectors in { defvar fvti = fvtiToFWti.Vti; defvar iwti = GetIntVTypeInfo<fvtiToFWti.Wti>.Vti; + let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, + GetVTypePredicates<iwti>.Predicates) in def : Pat<(iwti.Vector (vop (fvti.Vector fvti.RegClass:$rs1))), (!cast<Instruction>(instruction_name#"_"#fvti.LMul.MX) fvti.RegClass:$rs1, fvti.AVL, fvti.Log2SEW)>; @@ -420,6 +450,8 @@ multiclass VPatNConvertI2FPSDNode_W<SDPatternOperator vop, foreach fvtiToFWti = AllWidenableFloatVectors in { defvar fvti = fvtiToFWti.Vti; defvar iwti = GetIntVTypeInfo<fvtiToFWti.Wti>.Vti; + let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, + GetVTypePredicates<iwti>.Predicates) in def : Pat<(fvti.Vector (vop (iwti.Vector iwti.RegClass:$rs1))), (!cast<Instruction>(instruction_name#"_"#fvti.LMul.MX) iwti.RegClass:$rs1, fvti.AVL, fvti.Log2SEW)>; @@ -431,6 +463,8 @@ multiclass VPatNConvertFP2ISDNode_W<SDPatternOperator vop, foreach vtiToWti = AllWidenableIntToFloatVectors in { defvar vti = vtiToWti.Vti; defvar fwti = vtiToWti.Wti; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<fwti>.Predicates) in def : Pat<(vti.Vector (vop (fwti.Vector fwti.RegClass:$rs1))), (!cast<Instruction>(instruction_name#"_"#vti.LMul.MX) fwti.RegClass:$rs1, vti.AVL, vti.Log2SEW)>; @@ -442,14 +476,17 @@ multiclass VPatWidenBinarySDNode_VV_VX<SDNode op, PatFrags extop1, PatFrags exto foreach vtiToWti = AllWidenableIntVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; - def : Pat<(op (wti.Vector (extop1 (vti.Vector vti.RegClass:$rs2))), - (wti.Vector (extop2 (vti.Vector vti.RegClass:$rs1)))), - (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) - vti.RegClass:$rs2, vti.RegClass:$rs1, vti.AVL, vti.Log2SEW)>; - def : Pat<(op (wti.Vector (extop1 (vti.Vector vti.RegClass:$rs2))), - (wti.Vector (extop2 (vti.Vector (SplatPat GPR:$rs1))))), - (!cast<Instruction>(instruction_name#"_VX_"#vti.LMul.MX) - vti.RegClass:$rs2, GPR:$rs1, vti.AVL, vti.Log2SEW)>; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in { + def : Pat<(op (wti.Vector (extop1 (vti.Vector vti.RegClass:$rs2))), + (wti.Vector (extop2 (vti.Vector vti.RegClass:$rs1)))), + (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) + vti.RegClass:$rs2, vti.RegClass:$rs1, vti.AVL, vti.Log2SEW)>; + def : Pat<(op (wti.Vector (extop1 (vti.Vector vti.RegClass:$rs2))), + (wti.Vector (extop2 (vti.Vector (SplatPat GPR:$rs1))))), + (!cast<Instruction>(instruction_name#"_VX_"#vti.LMul.MX) + vti.RegClass:$rs2, GPR:$rs1, vti.AVL, vti.Log2SEW)>; + } } } @@ -458,15 +495,18 @@ multiclass VPatWidenBinarySDNode_WV_WX<SDNode op, PatFrags extop, foreach vtiToWti = AllWidenableIntVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; - def : Pat<(op (wti.Vector wti.RegClass:$rs2), - (wti.Vector (extop (vti.Vector vti.RegClass:$rs1)))), - (!cast<Instruction>(instruction_name#"_WV_"#vti.LMul.MX#"_TIED") - wti.RegClass:$rs2, vti.RegClass:$rs1, vti.AVL, vti.Log2SEW, - TAIL_AGNOSTIC)>; - def : Pat<(op (wti.Vector wti.RegClass:$rs2), - (wti.Vector (extop (vti.Vector (SplatPat GPR:$rs1))))), - (!cast<Instruction>(instruction_name#"_WX_"#vti.LMul.MX) - wti.RegClass:$rs2, GPR:$rs1, vti.AVL, vti.Log2SEW)>; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in { + def : Pat<(op (wti.Vector wti.RegClass:$rs2), + (wti.Vector (extop (vti.Vector vti.RegClass:$rs1)))), + (!cast<Instruction>(instruction_name#"_WV_"#vti.LMul.MX#"_TIED") + wti.RegClass:$rs2, vti.RegClass:$rs1, vti.AVL, vti.Log2SEW, + TAIL_AGNOSTIC)>; + def : Pat<(op (wti.Vector wti.RegClass:$rs2), + (wti.Vector (extop (vti.Vector (SplatPat GPR:$rs1))))), + (!cast<Instruction>(instruction_name#"_WX_"#vti.LMul.MX) + wti.RegClass:$rs2, GPR:$rs1, vti.AVL, vti.Log2SEW)>; + } } } @@ -479,6 +519,8 @@ multiclass VPatWidenMulAddSDNode_VV<PatFrags extop1, PatFrags extop2, string ins foreach vtiToWti = AllWidenableIntVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in def : Pat< (add (wti.Vector wti.RegClass:$rd), (mul_oneuse (wti.Vector (extop1 (vti.Vector vti.RegClass:$rs1))), @@ -493,6 +535,8 @@ multiclass VPatWidenMulAddSDNode_VX<PatFrags extop1, PatFrags extop2, string ins foreach vtiToWti = AllWidenableIntVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in def : Pat< (add (wti.Vector wti.RegClass:$rd), (mul_oneuse (wti.Vector (extop1 (vti.Vector (SplatPat GPR:$rs1)))), @@ -508,28 +552,31 @@ multiclass VPatWidenBinaryFPSDNode_VV_VF<SDNode op, string instruction_name> { foreach vtiToWti = AllWidenableFloatVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; - def : Pat<(op (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue))), - (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs1), - (vti.Mask true_mask), (XLenVT srcvalue)))), - (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) - vti.RegClass:$rs2, vti.RegClass:$rs1, vti.AVL, vti.Log2SEW)>; - def : Pat<(op (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue))), - (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1)), - (vti.Mask true_mask), (XLenVT srcvalue)))), - (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - vti.RegClass:$rs2, vti.ScalarRegClass:$rs1, vti.AVL, vti.Log2SEW)>; - def : Pat<(op (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue))), - (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)))), - (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - vti.RegClass:$rs2, vti.ScalarRegClass:$rs1, vti.AVL, vti.Log2SEW)>; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in { + def : Pat<(op (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue))), + (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs1), + (vti.Mask true_mask), (XLenVT srcvalue)))), + (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) + vti.RegClass:$rs2, vti.RegClass:$rs1, vti.AVL, vti.Log2SEW)>; + def : Pat<(op (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue))), + (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1)), + (vti.Mask true_mask), (XLenVT srcvalue)))), + (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + vti.RegClass:$rs2, vti.ScalarRegClass:$rs1, vti.AVL, vti.Log2SEW)>; + def : Pat<(op (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue))), + (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)))), + (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + vti.RegClass:$rs2, vti.ScalarRegClass:$rs1, vti.AVL, vti.Log2SEW)>; + } } } @@ -537,23 +584,26 @@ multiclass VPatWidenBinaryFPSDNode_WV_WF<SDNode op, string instruction_name> { foreach vtiToWti = AllWidenableFloatVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; - def : Pat<(op (wti.Vector wti.RegClass:$rs2), - (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs1), - (vti.Mask true_mask), (XLenVT srcvalue)))), - (!cast<Instruction>(instruction_name#"_WV_"#vti.LMul.MX#"_TIED") - wti.RegClass:$rs2, vti.RegClass:$rs1, vti.AVL, vti.Log2SEW, - TAIL_AGNOSTIC)>; - def : Pat<(op (wti.Vector wti.RegClass:$rs2), - (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1)), - (vti.Mask true_mask), (XLenVT srcvalue)))), - (!cast<Instruction>(instruction_name#"_W"#vti.ScalarSuffix#"_"#vti.LMul.MX) - wti.RegClass:$rs2, vti.ScalarRegClass:$rs1, vti.AVL, vti.Log2SEW)>; - def : Pat<(op (wti.Vector wti.RegClass:$rs2), - (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)))), - (!cast<Instruction>(instruction_name#"_W"#vti.ScalarSuffix#"_"#vti.LMul.MX) - wti.RegClass:$rs2, vti.ScalarRegClass:$rs1, vti.AVL, vti.Log2SEW)>; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in { + def : Pat<(op (wti.Vector wti.RegClass:$rs2), + (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs1), + (vti.Mask true_mask), (XLenVT srcvalue)))), + (!cast<Instruction>(instruction_name#"_WV_"#vti.LMul.MX#"_TIED") + wti.RegClass:$rs2, vti.RegClass:$rs1, vti.AVL, vti.Log2SEW, + TAIL_AGNOSTIC)>; + def : Pat<(op (wti.Vector wti.RegClass:$rs2), + (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1)), + (vti.Mask true_mask), (XLenVT srcvalue)))), + (!cast<Instruction>(instruction_name#"_W"#vti.ScalarSuffix#"_"#vti.LMul.MX) + wti.RegClass:$rs2, vti.ScalarRegClass:$rs1, vti.AVL, vti.Log2SEW)>; + def : Pat<(op (wti.Vector wti.RegClass:$rs2), + (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)))), + (!cast<Instruction>(instruction_name#"_W"#vti.ScalarSuffix#"_"#vti.LMul.MX) + wti.RegClass:$rs2, vti.ScalarRegClass:$rs1, vti.AVL, vti.Log2SEW)>; + } } } @@ -566,25 +616,28 @@ multiclass VPatWidenFPMulAccSDNode_VV_VF<string instruction_name> { foreach vtiToWti = AllWidenableFloatVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; - def : Pat<(fma (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs1), - (vti.Mask true_mask), (XLenVT srcvalue))), - (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue))), - (wti.Vector wti.RegClass:$rd)), - (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) - wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fma (wti.Vector (SplatFPOp - (fpext_oneuse vti.ScalarRegClass:$rs1))), - (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue))), - (wti.Vector wti.RegClass:$rd)), - (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in { + def : Pat<(fma (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs1), + (vti.Mask true_mask), (XLenVT srcvalue))), + (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue))), + (wti.Vector wti.RegClass:$rd)), + (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) + wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fma (wti.Vector (SplatFPOp + (fpext_oneuse vti.ScalarRegClass:$rs1))), + (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue))), + (wti.Vector wti.RegClass:$rd)), + (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + } } } @@ -592,30 +645,33 @@ multiclass VPatWidenFPNegMulAccSDNode_VV_VF<string instruction_name> { foreach vtiToWti = AllWidenableFloatVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; - def : Pat<(fma (fneg (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs1), - (vti.Mask true_mask), (XLenVT srcvalue)))), - (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue)), - (fneg wti.RegClass:$rd)), - (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) - wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fma (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)), - (fneg (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue)))), - (fneg wti.RegClass:$rd)), - (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fma (fneg (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)))), - (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue)), - (fneg wti.RegClass:$rd)), - (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in { + def : Pat<(fma (fneg (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs1), + (vti.Mask true_mask), (XLenVT srcvalue)))), + (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue)), + (fneg wti.RegClass:$rd)), + (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) + wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fma (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)), + (fneg (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue)))), + (fneg wti.RegClass:$rd)), + (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fma (fneg (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)))), + (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue)), + (fneg wti.RegClass:$rd)), + (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + } } } @@ -623,22 +679,25 @@ multiclass VPatWidenFPMulSacSDNode_VV_VF<string instruction_name> { foreach vtiToWti = AllWidenableFloatVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; - def : Pat<(fma (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs1), - (vti.Mask true_mask), (XLenVT srcvalue))), - (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue)), - (fneg wti.RegClass:$rd)), - (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) - wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fma (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1))), - (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue)), - (fneg wti.RegClass:$rd)), - (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in { + def : Pat<(fma (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs1), + (vti.Mask true_mask), (XLenVT srcvalue))), + (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue)), + (fneg wti.RegClass:$rd)), + (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) + wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fma (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1))), + (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue)), + (fneg wti.RegClass:$rd)), + (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + } } } @@ -646,50 +705,55 @@ multiclass VPatWidenFPNegMulSacSDNode_VV_VF<string instruction_name> { foreach vtiToWti = AllWidenableFloatVectors in { defvar vti = vtiToWti.Vti; defvar wti = vtiToWti.Wti; - def : Pat<(fma (fneg (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs1), - (vti.Mask true_mask), (XLenVT srcvalue)))), - (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue)), - wti.RegClass:$rd), - (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) - wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fma (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1))), - (fneg (wti.Vector (riscv_fpextend_vl_oneuse - (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue)))), - wti.RegClass:$rd), - (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fma (fneg (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)))), - (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), - (vti.Mask true_mask), (XLenVT srcvalue)), - wti.RegClass:$rd), - (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, + GetVTypePredicates<wti>.Predicates) in { + def : Pat<(fma (fneg (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs1), + (vti.Mask true_mask), (XLenVT srcvalue)))), + (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue)), + wti.RegClass:$rd), + (!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX) + wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fma (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1))), + (fneg (wti.Vector (riscv_fpextend_vl_oneuse + (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue)))), + wti.RegClass:$rd), + (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fma (fneg (wti.Vector (SplatFPOp (fpext_oneuse vti.ScalarRegClass:$rs1)))), + (riscv_fpextend_vl_oneuse (vti.Vector vti.RegClass:$rs2), + (vti.Mask true_mask), (XLenVT srcvalue)), + wti.RegClass:$rd), + (!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + } } } multiclass VPatMultiplyAddSDNode_VV_VX<SDNode op, string instruction_name> { foreach vti = AllIntegerVectors in { defvar suffix = vti.LMul.MX; - // NOTE: We choose VMADD because it has the most commuting freedom. So it - // works best with how TwoAddressInstructionPass tries commuting. - def : Pat<(vti.Vector (op vti.RegClass:$rs2, - (mul_oneuse vti.RegClass:$rs1, vti.RegClass:$rd))), - (!cast<Instruction>(instruction_name#"_VV_"# suffix) - vti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; - // The choice of VMADD here is arbitrary, vmadd.vx and vmacc.vx are equally - // commutable. - def : Pat<(vti.Vector (op vti.RegClass:$rs2, - (mul_oneuse (SplatPat XLenVT:$rs1), vti.RegClass:$rd))), - (!cast<Instruction>(instruction_name#"_VX_" # suffix) - vti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, - vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + let Predicates = GetVTypePredicates<vti>.Predicates in { + // NOTE: We choose VMADD because it has the most commuting freedom. So it + // works best with how TwoAddressInstructionPass tries commuting. + def : Pat<(vti.Vector (op vti.RegClass:$rs2, + (mul_oneuse vti.RegClass:$rs1, vti.RegClass:$rd))), + (!cast<Instruction>(instruction_name#"_VV_"# suffix) + vti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + // The choice of VMADD here is arbitrary, vmadd.vx and vmacc.vx are equally + // commutable. + def : Pat<(vti.Vector (op vti.RegClass:$rs2, + (mul_oneuse (SplatPat XLenVT:$rs1), vti.RegClass:$rd))), + (!cast<Instruction>(instruction_name#"_VX_" # suffix) + vti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2, + vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>; + } } } @@ -697,20 +761,22 @@ multiclass VPatMultiplyAddSDNode_VV_VX<SDNode op, string instruction_name> { // Patterns. //===----------------------------------------------------------------------===// -let Predicates = [HasVInstructions] in { - // 7.4. Vector Unit-Stride Instructions foreach vti = !listconcat(FractionalGroupIntegerVectors, FractionalGroupFloatVectors) in + let Predicates = GetVTypePredicates<vti>.Predicates in defm : VPatUSLoadStoreSDNode<vti.Vector, vti.Log2SEW, vti.LMul, vti.AVL, vti.RegClass>; foreach vti = [VI8M1, VI16M1, VI32M1, VI64M1, VF16M1, VF32M1, VF64M1] in + let Predicates = GetVTypePredicates<vti>.Predicates in defm : VPatUSLoadStoreWholeVRSDNode<vti.Vector, vti.Log2SEW, vti.LMul, vti.RegClass>; foreach vti = !listconcat(GroupIntegerVectors, GroupFloatVectors) in + let Predicates = GetVTypePredicates<vti>.Predicates in defm : VPatUSLoadStoreWholeVRSDNode<vti.Vector, vti.Log2SEW, vti.LMul, vti.RegClass>; foreach mti = AllMasks in + let Predicates = [HasVInstructions] in defm : VPatUSLoadStoreMaskSDNode<mti>; // 11. Vector Integer Arithmetic Instructions @@ -721,14 +787,16 @@ defm : VPatBinarySDNode_VV_VX<sub, "PseudoVSUB">; // Handle VRSUB specially since it's the only integer binary op with reversed // pattern operands foreach vti = AllIntegerVectors in { - def : Pat<(sub (vti.Vector (SplatPat GPR:$rs2)), - (vti.Vector vti.RegClass:$rs1)), - (!cast<Instruction>("PseudoVRSUB_VX_"# vti.LMul.MX) - vti.RegClass:$rs1, GPR:$rs2, vti.AVL, vti.Log2SEW)>; - def : Pat<(sub (vti.Vector (SplatPat_simm5 simm5:$rs2)), - (vti.Vector vti.RegClass:$rs1)), - (!cast<Instruction>("PseudoVRSUB_VI_"# vti.LMul.MX) - vti.RegClass:$rs1, simm5:$rs2, vti.AVL, vti.Log2SEW)>; + let Predicates = GetVTypePredicates<vti>.Predicates in { + def : Pat<(sub (vti.Vector (SplatPat GPR:$rs2)), + (vti.Vector vti.RegClass:$rs1)), + (!cast<Instruction>("PseudoVRSUB_VX_"# vti.LMul.MX) + vti.RegClass:$rs1, GPR:$rs2, vti.AVL, vti.Log2SEW)>; + def : Pat<(sub (vti.Vector (SplatPat_simm5 simm5:$rs2)), + (vti.Vector vti.RegClass:$rs1)), + (!cast<Instruction>("PseudoVRSUB_VI_"# vti.LMul.MX) + vti.RegClass:$rs1, simm5:$rs2, vti.AVL, vti.Log2SEW)>; + } } // 11.2. Vector Widening Integer Add and Subtract @@ -766,6 +834,7 @@ defm : VPatBinarySDNode_VV_VX_VI<sra, "PseudoVSRA", uimm5>; foreach vti = AllIntegerVectors in { // Emit shift by 1 as an add since it might be faster. + let Predicates = GetVTypePredicates<vti>.Predicates in def : Pat<(shl (vti.Vector vti.RegClass:$rs1), (vti.Vector (riscv_vmv_v_x_vl (vti.Vector undef), 1, (XLenVT srcvalue)))), (!cast<Instruction>("PseudoVADD_VV_"# vti.LMul.MX) @@ -816,8 +885,14 @@ defm : VPatBinarySDNode_VV_VX<smax, "PseudoVMAX">; // 11.10. Vector Single-Width Integer Multiply Instructions defm : VPatBinarySDNode_VV_VX<mul, "PseudoVMUL">; -defm : VPatBinarySDNode_VV_VX<mulhs, "PseudoVMULH">; -defm : VPatBinarySDNode_VV_VX<mulhu, "PseudoVMULHU">; + +defm : VPatBinarySDNode_VV_VX<mulhs, "PseudoVMULH", IntegerVectorsExceptI64>; +defm : VPatBinarySDNode_VV_VX<mulhu, "PseudoVMULHU", IntegerVectorsExceptI64>; + +let Predicates = [HasVInstructionsFullMultiply] in { + defm : VPatBinarySDNode_VV_VX<mulhs, "PseudoVMULH", I64IntegerVectors>; + defm : VPatBinarySDNode_VV_VX<mulhu, "PseudoVMULHU", I64IntegerVectors>; +} // 11.11. Vector Integer Divide Instructions defm : VPatBinarySDNode_VV_VX_E<udiv, "PseudoVDIVU">; @@ -854,21 +929,23 @@ defm : VPatWidenMulAddSDNode_VX<zext_oneuse, sext_oneuse, "PseudoVWMACCUS">; // 11.15. Vector Integer Merge Instructions foreach vti = AllIntegerVectors in { - def : Pat<(vti.Vector (vselect (vti.Mask V0), vti.RegClass:$rs1, - vti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVMERGE_VVM_"#vti.LMul.MX) - vti.RegClass:$rs2, vti.RegClass:$rs1, (vti.Mask V0), - vti.AVL, vti.Log2SEW)>; - - def : Pat<(vti.Vector (vselect (vti.Mask V0), (SplatPat XLenVT:$rs1), - vti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVMERGE_VXM_"#vti.LMul.MX) - vti.RegClass:$rs2, GPR:$rs1, (vti.Mask V0), vti.AVL, vti.Log2SEW)>; - - def : Pat<(vti.Vector (vselect (vti.Mask V0), (SplatPat_simm5 simm5:$rs1), - vti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVMERGE_VIM_"#vti.LMul.MX) - vti.RegClass:$rs2, simm5:$rs1, (vti.Mask V0), vti.AVL, vti.Log2SEW)>; + let Predicates = GetVTypePredicates<vti>.Predicates in { + def : Pat<(vti.Vector (vselect (vti.Mask V0), vti.RegClass:$rs1, + vti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVMERGE_VVM_"#vti.LMul.MX) + vti.RegClass:$rs2, vti.RegClass:$rs1, (vti.Mask V0), + vti.AVL, vti.Log2SEW)>; + + def : Pat<(vti.Vector (vselect (vti.Mask V0), (SplatPat XLenVT:$rs1), + vti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVMERGE_VXM_"#vti.LMul.MX) + vti.RegClass:$rs2, GPR:$rs1, (vti.Mask V0), vti.AVL, vti.Log2SEW)>; + + def : Pat<(vti.Vector (vselect (vti.Mask V0), (SplatPat_simm5 simm5:$rs1), + vti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVMERGE_VIM_"#vti.LMul.MX) + vti.RegClass:$rs2, simm5:$rs1, (vti.Mask V0), vti.AVL, vti.Log2SEW)>; + } } // 12. Vector Fixed-Point Arithmetic Instructions @@ -883,45 +960,43 @@ defm : VPatBinarySDNode_VV_VX<usubsat, "PseudoVSSUBU">; // 15.1. Vector Mask-Register Logical Instructions foreach mti = AllMasks in { - def : Pat<(mti.Mask (and VR:$rs1, VR:$rs2)), - (!cast<Instruction>("PseudoVMAND_MM_"#mti.LMul.MX) - VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; - def : Pat<(mti.Mask (or VR:$rs1, VR:$rs2)), - (!cast<Instruction>("PseudoVMOR_MM_"#mti.LMul.MX) - VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; - def : Pat<(mti.Mask (xor VR:$rs1, VR:$rs2)), - (!cast<Instruction>("PseudoVMXOR_MM_"#mti.LMul.MX) - VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; - - def : Pat<(mti.Mask (rvv_vnot (and VR:$rs1, VR:$rs2))), - (!cast<Instruction>("PseudoVMNAND_MM_"#mti.LMul.MX) - VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; - def : Pat<(mti.Mask (rvv_vnot (or VR:$rs1, VR:$rs2))), - (!cast<Instruction>("PseudoVMNOR_MM_"#mti.LMul.MX) - VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; - def : Pat<(mti.Mask (rvv_vnot (xor VR:$rs1, VR:$rs2))), - (!cast<Instruction>("PseudoVMXNOR_MM_"#mti.LMul.MX) - VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; - - def : Pat<(mti.Mask (and VR:$rs1, (rvv_vnot VR:$rs2))), - (!cast<Instruction>("PseudoVMANDN_MM_"#mti.LMul.MX) - VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; - def : Pat<(mti.Mask (or VR:$rs1, (rvv_vnot VR:$rs2))), - (!cast<Instruction>("PseudoVMORN_MM_"#mti.LMul.MX) - VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; - - // Handle rvv_vnot the same as the vmnot.m pseudoinstruction. - def : Pat<(mti.Mask (rvv_vnot VR:$rs)), - (!cast<Instruction>("PseudoVMNAND_MM_"#mti.LMul.MX) - VR:$rs, VR:$rs, mti.AVL, mti.Log2SEW)>; + let Predicates = [HasVInstructions] in { + def : Pat<(mti.Mask (and VR:$rs1, VR:$rs2)), + (!cast<Instruction>("PseudoVMAND_MM_"#mti.LMul.MX) + VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; + def : Pat<(mti.Mask (or VR:$rs1, VR:$rs2)), + (!cast<Instruction>("PseudoVMOR_MM_"#mti.LMul.MX) + VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; + def : Pat<(mti.Mask (xor VR:$rs1, VR:$rs2)), + (!cast<Instruction>("PseudoVMXOR_MM_"#mti.LMul.MX) + VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; + + def : Pat<(mti.Mask (rvv_vnot (and VR:$rs1, VR:$rs2))), + (!cast<Instruction>("PseudoVMNAND_MM_"#mti.LMul.MX) + VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; + def : Pat<(mti.Mask (rvv_vnot (or VR:$rs1, VR:$rs2))), + (!cast<Instruction>("PseudoVMNOR_MM_"#mti.LMul.MX) + VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; + def : Pat<(mti.Mask (rvv_vnot (xor VR:$rs1, VR:$rs2))), + (!cast<Instruction>("PseudoVMXNOR_MM_"#mti.LMul.MX) + VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; + + def : Pat<(mti.Mask (and VR:$rs1, (rvv_vnot VR:$rs2))), + (!cast<Instruction>("PseudoVMANDN_MM_"#mti.LMul.MX) + VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; + def : Pat<(mti.Mask (or VR:$rs1, (rvv_vnot VR:$rs2))), + (!cast<Instruction>("PseudoVMORN_MM_"#mti.LMul.MX) + VR:$rs1, VR:$rs2, mti.AVL, mti.Log2SEW)>; + + // Handle rvv_vnot the same as the vmnot.m pseudoinstruction. + def : Pat<(mti.Mask (rvv_vnot VR:$rs)), + (!cast<Instruction>("PseudoVMNAND_MM_"#mti.LMul.MX) + VR:$rs, VR:$rs, mti.AVL, mti.Log2SEW)>; + } } -} // Predicates = [HasVInstructions] - // 13. Vector Floating-Point Instructions -let Predicates = [HasVInstructionsAnyF] in { - // 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions defm : VPatBinaryFPSDNode_VV_VF<any_fadd, "PseudoVFADD">; defm : VPatBinaryFPSDNode_VV_VF<any_fsub, "PseudoVFSUB">; @@ -944,62 +1019,64 @@ foreach fvti = AllFloatVectors in { // NOTE: We choose VFMADD because it has the most commuting freedom. So it // works best with how TwoAddressInstructionPass tries commuting. defvar suffix = fvti.LMul.MX; - def : Pat<(fvti.Vector (any_fma fvti.RegClass:$rs1, fvti.RegClass:$rd, - fvti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVFMADD_VV_"# suffix) - fvti.RegClass:$rd, fvti.RegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fvti.Vector (any_fma fvti.RegClass:$rs1, fvti.RegClass:$rd, - (fneg fvti.RegClass:$rs2))), - (!cast<Instruction>("PseudoVFMSUB_VV_"# suffix) - fvti.RegClass:$rd, fvti.RegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fvti.Vector (any_fma (fneg fvti.RegClass:$rs1), fvti.RegClass:$rd, - (fneg fvti.RegClass:$rs2))), - (!cast<Instruction>("PseudoVFNMADD_VV_"# suffix) - fvti.RegClass:$rd, fvti.RegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fvti.Vector (any_fma (fneg fvti.RegClass:$rs1), fvti.RegClass:$rd, - fvti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVFNMSUB_VV_"# suffix) - fvti.RegClass:$rd, fvti.RegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - - // The choice of VFMADD here is arbitrary, vfmadd.vf and vfmacc.vf are equally - // commutable. - def : Pat<(fvti.Vector (any_fma (SplatFPOp fvti.ScalarRegClass:$rs1), - fvti.RegClass:$rd, fvti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVFMADD_V" # fvti.ScalarSuffix # "_" # suffix) - fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fvti.Vector (any_fma (SplatFPOp fvti.ScalarRegClass:$rs1), - fvti.RegClass:$rd, (fneg fvti.RegClass:$rs2))), - (!cast<Instruction>("PseudoVFMSUB_V" # fvti.ScalarSuffix # "_" # suffix) - fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - - def : Pat<(fvti.Vector (any_fma (SplatFPOp fvti.ScalarRegClass:$rs1), - (fneg fvti.RegClass:$rd), (fneg fvti.RegClass:$rs2))), - (!cast<Instruction>("PseudoVFNMADD_V" # fvti.ScalarSuffix # "_" # suffix) - fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fvti.Vector (any_fma (SplatFPOp fvti.ScalarRegClass:$rs1), - (fneg fvti.RegClass:$rd), fvti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVFNMSUB_V" # fvti.ScalarSuffix # "_" # suffix) - fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - - // The splat might be negated. - def : Pat<(fvti.Vector (any_fma (fneg (SplatFPOp fvti.ScalarRegClass:$rs1)), - fvti.RegClass:$rd, (fneg fvti.RegClass:$rs2))), - (!cast<Instruction>("PseudoVFNMADD_V" # fvti.ScalarSuffix # "_" # suffix) - fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; - def : Pat<(fvti.Vector (any_fma (fneg (SplatFPOp fvti.ScalarRegClass:$rs1)), - fvti.RegClass:$rd, fvti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVFNMSUB_V" # fvti.ScalarSuffix # "_" # suffix) - fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, - fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + let Predicates = GetVTypePredicates<fvti>.Predicates in { + def : Pat<(fvti.Vector (any_fma fvti.RegClass:$rs1, fvti.RegClass:$rd, + fvti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVFMADD_VV_"# suffix) + fvti.RegClass:$rd, fvti.RegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fvti.Vector (any_fma fvti.RegClass:$rs1, fvti.RegClass:$rd, + (fneg fvti.RegClass:$rs2))), + (!cast<Instruction>("PseudoVFMSUB_VV_"# suffix) + fvti.RegClass:$rd, fvti.RegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fvti.Vector (any_fma (fneg fvti.RegClass:$rs1), fvti.RegClass:$rd, + (fneg fvti.RegClass:$rs2))), + (!cast<Instruction>("PseudoVFNMADD_VV_"# suffix) + fvti.RegClass:$rd, fvti.RegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fvti.Vector (any_fma (fneg fvti.RegClass:$rs1), fvti.RegClass:$rd, + fvti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVFNMSUB_VV_"# suffix) + fvti.RegClass:$rd, fvti.RegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + + // The choice of VFMADD here is arbitrary, vfmadd.vf and vfmacc.vf are equally + // commutable. + def : Pat<(fvti.Vector (any_fma (SplatFPOp fvti.ScalarRegClass:$rs1), + fvti.RegClass:$rd, fvti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVFMADD_V" # fvti.ScalarSuffix # "_" # suffix) + fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fvti.Vector (any_fma (SplatFPOp fvti.ScalarRegClass:$rs1), + fvti.RegClass:$rd, (fneg fvti.RegClass:$rs2))), + (!cast<Instruction>("PseudoVFMSUB_V" # fvti.ScalarSuffix # "_" # suffix) + fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + + def : Pat<(fvti.Vector (any_fma (SplatFPOp fvti.ScalarRegClass:$rs1), + (fneg fvti.RegClass:$rd), (fneg fvti.RegClass:$rs2))), + (!cast<Instruction>("PseudoVFNMADD_V" # fvti.ScalarSuffix # "_" # suffix) + fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fvti.Vector (any_fma (SplatFPOp fvti.ScalarRegClass:$rs1), + (fneg fvti.RegClass:$rd), fvti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVFNMSUB_V" # fvti.ScalarSuffix # "_" # suffix) + fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + + // The splat might be negated. + def : Pat<(fvti.Vector (any_fma (fneg (SplatFPOp fvti.ScalarRegClass:$rs1)), + fvti.RegClass:$rd, (fneg fvti.RegClass:$rs2))), + (!cast<Instruction>("PseudoVFNMADD_V" # fvti.ScalarSuffix # "_" # suffix) + fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + def : Pat<(fvti.Vector (any_fma (fneg (SplatFPOp fvti.ScalarRegClass:$rs1)), + fvti.RegClass:$rd, fvti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVFNMSUB_V" # fvti.ScalarSuffix # "_" # suffix) + fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2, + fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>; + } } // 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions @@ -1009,37 +1086,39 @@ defm : VPatWidenFPMulSacSDNode_VV_VF<"PseudoVFWMSAC">; defm : VPatWidenFPNegMulSacSDNode_VV_VF<"PseudoVFWNMSAC">; foreach vti = AllFloatVectors in { - // 13.8. Vector Floating-Point Square-Root Instruction - def : Pat<(any_fsqrt (vti.Vector vti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVFSQRT_V_"# vti.LMul.MX#"_E"#vti.SEW) - vti.RegClass:$rs2, vti.AVL, vti.Log2SEW)>; - - // 13.12. Vector Floating-Point Sign-Injection Instructions - def : Pat<(fabs (vti.Vector vti.RegClass:$rs)), - (!cast<Instruction>("PseudoVFSGNJX_VV_"# vti.LMul.MX) - vti.RegClass:$rs, vti.RegClass:$rs, vti.AVL, vti.Log2SEW)>; - // Handle fneg with VFSGNJN using the same input for both operands. - def : Pat<(fneg (vti.Vector vti.RegClass:$rs)), - (!cast<Instruction>("PseudoVFSGNJN_VV_"# vti.LMul.MX) - vti.RegClass:$rs, vti.RegClass:$rs, vti.AVL, vti.Log2SEW)>; - - def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1), - (vti.Vector vti.RegClass:$rs2))), - (!cast<Instruction>("PseudoVFSGNJ_VV_"# vti.LMul.MX) - vti.RegClass:$rs1, vti.RegClass:$rs2, vti.AVL, vti.Log2SEW)>; - def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1), - (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs2)))), - (!cast<Instruction>("PseudoVFSGNJ_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - vti.RegClass:$rs1, vti.ScalarRegClass:$rs2, vti.AVL, vti.Log2SEW)>; - - def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1), - (vti.Vector (fneg vti.RegClass:$rs2)))), - (!cast<Instruction>("PseudoVFSGNJN_VV_"# vti.LMul.MX) - vti.RegClass:$rs1, vti.RegClass:$rs2, vti.AVL, vti.Log2SEW)>; - def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1), - (vti.Vector (fneg (SplatFPOp vti.ScalarRegClass:$rs2))))), - (!cast<Instruction>("PseudoVFSGNJN_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) - vti.RegClass:$rs1, vti.ScalarRegClass:$rs2, vti.AVL, vti.Log2SEW)>; + let Predicates = GetVTypePredicates<vti>.Predicates in { + // 13.8. Vector Floating-Point Square-Root Instruction + def : Pat<(any_fsqrt (vti.Vector vti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVFSQRT_V_"# vti.LMul.MX#"_E"#vti.SEW) + vti.RegClass:$rs2, vti.AVL, vti.Log2SEW)>; + + // 13.12. Vector Floating-Point Sign-Injection Instructions + def : Pat<(fabs (vti.Vector vti.RegClass:$rs)), + (!cast<Instruction>("PseudoVFSGNJX_VV_"# vti.LMul.MX) + vti.RegClass:$rs, vti.RegClass:$rs, vti.AVL, vti.Log2SEW)>; + // Handle fneg with VFSGNJN using the same input for both operands. + def : Pat<(fneg (vti.Vector vti.RegClass:$rs)), + (!cast<Instruction>("PseudoVFSGNJN_VV_"# vti.LMul.MX) + vti.RegClass:$rs, vti.RegClass:$rs, vti.AVL, vti.Log2SEW)>; + + def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1), + (vti.Vector vti.RegClass:$rs2))), + (!cast<Instruction>("PseudoVFSGNJ_VV_"# vti.LMul.MX) + vti.RegClass:$rs1, vti.RegClass:$rs2, vti.AVL, vti.Log2SEW)>; + def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1), + (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs2)))), + (!cast<Instruction>("PseudoVFSGNJ_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + vti.RegClass:$rs1, vti.ScalarRegClass:$rs2, vti.AVL, vti.Log2SEW)>; + + def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1), + (vti.Vector (fneg vti.RegClass:$rs2)))), + (!cast<Instruction>("PseudoVFSGNJN_VV_"# vti.LMul.MX) + vti.RegClass:$rs1, vti.RegClass:$rs2, vti.AVL, vti.Log2SEW)>; + def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1), + (vti.Vector (fneg (SplatFPOp vti.ScalarRegClass:$rs2))))), + (!cast<Instruction>("PseudoVFSGNJN_V"#vti.ScalarSuffix#"_"#vti.LMul.MX) + vti.RegClass:$rs1, vti.ScalarRegClass:$rs2, vti.AVL, vti.Log2SEW)>; + } } // 13.11. Vector Floating-Point MIN/MAX Instructions @@ -1063,25 +1142,27 @@ defm : VPatFPSetCCSDNode_VV_VF_FV<SETOLE, "PseudoVMFLE", "PseudoVMFGE">; // 11.15. Vector Integer Merge Instructions // 13.15. Vector Floating-Point Merge Instruction foreach fvti = AllFloatVectors in { - def : Pat<(fvti.Vector (vselect (fvti.Mask V0), fvti.RegClass:$rs1, - fvti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVMERGE_VVM_"#fvti.LMul.MX) - fvti.RegClass:$rs2, fvti.RegClass:$rs1, (fvti.Mask V0), - fvti.AVL, fvti.Log2SEW)>; - - def : Pat<(fvti.Vector (vselect (fvti.Mask V0), - (SplatFPOp fvti.ScalarRegClass:$rs1), - fvti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVFMERGE_V"#fvti.ScalarSuffix#"M_"#fvti.LMul.MX) - fvti.RegClass:$rs2, - (fvti.Scalar fvti.ScalarRegClass:$rs1), - (fvti.Mask V0), fvti.AVL, fvti.Log2SEW)>; - - def : Pat<(fvti.Vector (vselect (fvti.Mask V0), - (SplatFPOp (fvti.Scalar fpimm0)), - fvti.RegClass:$rs2)), - (!cast<Instruction>("PseudoVMERGE_VIM_"#fvti.LMul.MX) - fvti.RegClass:$rs2, 0, (fvti.Mask V0), fvti.AVL, fvti.Log2SEW)>; + let Predicates = GetVTypePredicates<fvti>.Predicates in { + def : Pat<(fvti.Vector (vselect (fvti.Mask V0), fvti.RegClass:$rs1, + fvti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVMERGE_VVM_"#fvti.LMul.MX) + fvti.RegClass:$rs2, fvti.RegClass:$rs1, (fvti.Mask V0), + fvti.AVL, fvti.Log2SEW)>; + + def : Pat<(fvti.Vector (vselect (fvti.Mask V0), + (SplatFPOp fvti.ScalarRegClass:$rs1), + fvti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVFMERGE_V"#fvti.ScalarSuffix#"M_"#fvti.LMul.MX) + fvti.RegClass:$rs2, + (fvti.Scalar fvti.ScalarRegClass:$rs1), + (fvti.Mask V0), fvti.AVL, fvti.Log2SEW)>; + + def : Pat<(fvti.Vector (vselect (fvti.Mask V0), + (SplatFPOp (fvti.Scalar fpimm0)), + fvti.RegClass:$rs2)), + (!cast<Instruction>("PseudoVMERGE_VIM_"#fvti.LMul.MX) + fvti.RegClass:$rs2, 0, (fvti.Mask V0), fvti.AVL, fvti.Log2SEW)>; + } } // 13.17. Vector Single-Width Floating-Point/Integer Type-Convert Instructions @@ -1104,33 +1185,33 @@ defm : VPatNConvertI2FPSDNode_W<any_uint_to_fp, "PseudoVFNCVT_F_XU_W">; foreach fvtiToFWti = AllWidenableFloatVectors in { defvar fvti = fvtiToFWti.Vti; defvar fwti = fvtiToFWti.Wti; + let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, + GetVTypePredicates<fwti>.Predicates) in def : Pat<(fvti.Vector (fpround (fwti.Vector fwti.RegClass:$rs1))), (!cast<Instruction>("PseudoVFNCVT_F_F_W_"#fvti.LMul.MX) fwti.RegClass:$rs1, fvti.AVL, fvti.Log2SEW)>; } -} // Predicates = [HasVInstructionsAnyF] //===----------------------------------------------------------------------===// // Vector Splats //===----------------------------------------------------------------------===// -let Predicates = [HasVInstructionsAnyF] in { foreach fvti = AllFloatVectors in { - def : Pat<(fvti.Vector (SplatFPOp fvti.ScalarRegClass:$rs1)), - (!cast<Instruction>("PseudoVFMV_V_"#fvti.ScalarSuffix#"_"#fvti.LMul.MX) - (fvti.Scalar fvti.ScalarRegClass:$rs1), - fvti.AVL, fvti.Log2SEW)>; - - def : Pat<(fvti.Vector (SplatFPOp (fvti.Scalar fpimm0))), - (!cast<Instruction>("PseudoVMV_V_I_"#fvti.LMul.MX) - 0, fvti.AVL, fvti.Log2SEW)>; + let Predicates = GetVTypePredicates<fvti>.Predicates in { + def : Pat<(fvti.Vector (SplatFPOp fvti.ScalarRegClass:$rs1)), + (!cast<Instruction>("PseudoVFMV_V_"#fvti.ScalarSuffix#"_"#fvti.LMul.MX) + (fvti.Scalar fvti.ScalarRegClass:$rs1), + fvti.AVL, fvti.Log2SEW)>; + + def : Pat<(fvti.Vector (SplatFPOp (fvti.Scalar fpimm0))), + (!cast<Instruction>("PseudoVMV_V_I_"#fvti.LMul.MX) + 0, fvti.AVL, fvti.Log2SEW)>; + } } -} // Predicates = [HasVInstructionsAnyF] //===----------------------------------------------------------------------===// // Vector Element Extracts //===----------------------------------------------------------------------===// -let Predicates = [HasVInstructionsAnyF] in foreach vti = AllFloatVectors in { defvar vmv_f_s_inst = !cast<Instruction>(!strconcat("PseudoVFMV_", vti.ScalarSuffix, @@ -1138,6 +1219,7 @@ foreach vti = AllFloatVectors in { // Only pattern-match extract-element operations where the index is 0. Any // other index will have been custom-lowered to slide the vector correctly // into place. + let Predicates = GetVTypePredicates<vti>.Predicates in def : Pat<(vti.Scalar (extractelt (vti.Vector vti.RegClass:$rs2), 0)), (vmv_f_s_inst vti.RegClass:$rs2, vti.Log2SEW)>; } |