From 36e3e668be0c4914660575d7cea800b0d51a4116 Mon Sep 17 00:00:00 2001 From: Bob Wilson Date: Wed, 12 Aug 2009 22:30:59 +0000 Subject: [PATCH] Add a new "SDTCisVec" SDTypeConstraint. This complements the vAny type. There have been a few times where I've wanted this but ended up leaving the operand type unconstrained. It is easy to add this now and should help catch errors in the future. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78849 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Target/TargetSelectionDAG.td | 7 ++++-- utils/TableGen/CodeGenDAGPatterns.cpp | 26 +++++++++++++++++------ utils/TableGen/CodeGenDAGPatterns.h | 15 ++++++++----- 3 files changed, 35 insertions(+), 13 deletions(-) diff --git a/include/llvm/Target/TargetSelectionDAG.td b/include/llvm/Target/TargetSelectionDAG.td index 9a9125e578c..700c64c8ca5 100644 --- a/include/llvm/Target/TargetSelectionDAG.td +++ b/include/llvm/Target/TargetSelectionDAG.td @@ -30,12 +30,15 @@ class SDTCisVT : SDTypeConstraint { class SDTCisPtrTy : SDTypeConstraint; -// SDTCisInt - The specified operand is has integer type. +// SDTCisInt - The specified operand has integer type. class SDTCisInt : SDTypeConstraint; -// SDTCisFP - The specified operand is has floating point type. +// SDTCisFP - The specified operand has floating-point type. class SDTCisFP : SDTypeConstraint; +// SDTCisVec - The specified operand has a vector type. +class SDTCisVec : SDTypeConstraint; + // SDTCisSameAs - The two specified operands have identical types. class SDTCisSameAs : SDTypeConstraint { int OtherOperandNum = OtherOp; diff --git a/utils/TableGen/CodeGenDAGPatterns.cpp b/utils/TableGen/CodeGenDAGPatterns.cpp index 29b41a243bd..efa7fe4ae95 100644 --- a/utils/TableGen/CodeGenDAGPatterns.cpp +++ b/utils/TableGen/CodeGenDAGPatterns.cpp @@ -95,7 +95,7 @@ bool isExtFloatingPointInVTs(const std::vector &EVTs) { /// vector contains a vector value type. bool isExtVectorInVTs(const std::vector &EVTs) { assert(!EVTs.empty() && "Cannot check for vector in empty ExtVT list!"); - return !(FilterEVTs(EVTs, isVector).empty()); + return EVTs[0] == isVec || !(FilterEVTs(EVTs, isVector).empty()); } } // end namespace EEVT. } // end namespace llvm. @@ -190,6 +190,8 @@ SDTypeConstraint::SDTypeConstraint(Record *R) { ConstraintType = SDTCisInt; } else if (R->isSubClassOf("SDTCisFP")) { ConstraintType = SDTCisFP; + } else if (R->isSubClassOf("SDTCisVec")) { + ConstraintType = SDTCisVec; } else if (R->isSubClassOf("SDTCisSameAs")) { ConstraintType = SDTCisSameAs; x.SDTCisSameAs_Info.OtherOperandNum = R->getValueAsInt("OtherOperandNum"); @@ -283,6 +285,16 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N, return NodeToApply->UpdateNodeType(FPVTs[0], TP); return NodeToApply->UpdateNodeType(EEVT::isFP, TP); } + case SDTCisVec: { + // If there is only one vector type supported, this must be it. + std::vector VecVTs = + FilterVTs(CGT.getLegalValueTypes(), isVector); + + // If we found exactly one supported vector type, apply it. + if (VecVTs.size() == 1) + return NodeToApply->UpdateNodeType(VecVTs[0], TP); + return NodeToApply->UpdateNodeType(EEVT::isVec, TP); + } case SDTCisSameAs: { TreePatternNode *OtherNode = getOperandNum(x.SDTCisSameAs_Info.OtherOperandNum, N, NumResults); @@ -502,7 +514,8 @@ bool TreePatternNode::UpdateNodeType(const std::vector &ExtVTs, setTypes(FVTs); return true; } - if (ExtVTs[0] == MVT::vAny && EEVT::isExtVectorInVTs(getExtTypes())) { + if ((ExtVTs[0] == EEVT::isVec || ExtVTs[0] == MVT::vAny) && + EEVT::isExtVectorInVTs(getExtTypes())) { assert(hasTypeSet() && "should be handled above!"); std::vector FVTs = FilterEVTs(getExtTypes(), isVector); if (getExtTypes() == FVTs) @@ -511,16 +524,16 @@ bool TreePatternNode::UpdateNodeType(const std::vector &ExtVTs, return true; } - // If we know this is an int or fp type, and we are told it is a specific one, - // take the advice. + // If we know this is an int, FP, or vector type, and we are told it is a + // specific one, take the advice. // // Similarly, we should probably set the type here to the intersection of - // {isInt|isFP} and ExtVTs + // {isInt|isFP|isVec} and ExtVTs if (((getExtTypeNum(0) == EEVT::isInt || getExtTypeNum(0) == MVT::iAny) && EEVT::isExtIntegerInVTs(ExtVTs)) || ((getExtTypeNum(0) == EEVT::isFP || getExtTypeNum(0) == MVT::fAny) && EEVT::isExtFloatingPointInVTs(ExtVTs)) || - (getExtTypeNum(0) == MVT::vAny && + ((getExtTypeNum(0) == EEVT::isVec || getExtTypeNum(0) == MVT::vAny) && EEVT::isExtVectorInVTs(ExtVTs))) { setTypes(ExtVTs); return true; @@ -556,6 +569,7 @@ void TreePatternNode::print(raw_ostream &OS) const { case MVT::Other: OS << ":Other"; break; case EEVT::isInt: OS << ":isInt"; break; case EEVT::isFP : OS << ":isFP"; break; + case EEVT::isVec: OS << ":isVec"; break; case EEVT::isUnknown: ; /*OS << ":?";*/ break; case MVT::iPTR: OS << ":iPTR"; break; case MVT::iPTRAny: OS << ":iPTRAny"; break; diff --git a/utils/TableGen/CodeGenDAGPatterns.h b/utils/TableGen/CodeGenDAGPatterns.h index 7c2791d4406..56dcfcff910 100644 --- a/utils/TableGen/CodeGenDAGPatterns.h +++ b/utils/TableGen/CodeGenDAGPatterns.h @@ -39,16 +39,21 @@ namespace EEVT { enum DAGISelGenValueType { isFP = MVT::LAST_VALUETYPE, isInt, + isVec, isUnknown }; - /// isExtIntegerVT - Return true if the specified extended value type vector - /// contains isInt or an integer value type. + /// isExtIntegerInVTs - Return true if the specified extended value type + /// vector contains isInt or an integer value type. bool isExtIntegerInVTs(const std::vector &EVTs); - /// isExtFloatingPointVT - Return true if the specified extended value type - /// vector contains isFP or a FP value type. + /// isExtFloatingPointInVTs - Return true if the specified extended value + /// type vector contains isFP or a FP value type. bool isExtFloatingPointInVTs(const std::vector &EVTs); + + /// isExtVectorinVTs - Return true if the specified extended value type + /// vector contains isVec or a vector value type. + bool isExtVectorInVTs(const std::vector &EVTs); } /// Set type used to track multiply used variables in patterns @@ -61,7 +66,7 @@ struct SDTypeConstraint { unsigned OperandNo; // The operand # this constraint applies to. enum { - SDTCisVT, SDTCisPtrTy, SDTCisInt, SDTCisFP, SDTCisSameAs, + SDTCisVT, SDTCisPtrTy, SDTCisInt, SDTCisFP, SDTCisVec, SDTCisSameAs, SDTCisVTSmallerThanOp, SDTCisOpSmallerThanOp, SDTCisEltOfVec } ConstraintType;