From 0aa32d5d0ff6cd65b6cff957858a79e2d2a614bd Mon Sep 17 00:00:00 2001 From: Stepan Dyatkovskiy Date: Tue, 29 May 2012 12:26:47 +0000 Subject: [PATCH] ConstantRangesSet renamed to IntegersSubset. CRSBuilder renamed to IntegersSubsetMapping. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@157612 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Instructions.h | 20 ++-- .../{ConstantRangesSet.h => IntegersSubset.h} | 4 +- .../{CRSBuilder.h => IntegersSubsetMapping.h} | 112 ++++++++---------- lib/Bitcode/Reader/BitcodeReader.cpp | 4 +- lib/Bitcode/Writer/BitcodeWriter.cpp | 10 +- .../SelectionDAG/SelectionDAGBuilder.cpp | 4 +- lib/ExecutionEngine/Interpreter/Execution.cpp | 4 +- lib/Target/CppBackend/CPPBackend.cpp | 2 +- lib/Transforms/Utils/Local.cpp | 6 +- lib/Transforms/Utils/LowerSwitch.cpp | 10 +- lib/VMCore/Instructions.cpp | 10 +- lib/VMCore/Verifier.cpp | 16 +-- tools/llvm-diff/DifferenceEngine.cpp | 2 +- 13 files changed, 95 insertions(+), 109 deletions(-) rename include/llvm/Support/{ConstantRangesSet.h => IntegersSubset.h} (99%) rename include/llvm/Support/{CRSBuilder.h => IntegersSubsetMapping.h} (88%) diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index 3f67e26f73a..89a5a307f22 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -20,8 +20,8 @@ #include "llvm/DerivedTypes.h" #include "llvm/Attributes.h" #include "llvm/CallingConv.h" -#include "llvm/Support/ConstantRangesSet.h" -#include "llvm/Support/CRSBuilder.h" +#include "llvm/Support/IntegersSubset.h" +#include "llvm/Support/IntegersSubsetMapping.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/ErrorHandling.h" @@ -2589,7 +2589,7 @@ public: /// Note: /// This action invalidates case_end(). Old case_end() iterator will /// point to the added case. - void addCase(ConstantRangesSet& OnVal, BasicBlock *Dest); + void addCase(IntegersSubset& OnVal, BasicBlock *Dest); /// removeCase - This method removes the specified case and its successor /// from the switch instruction. Note that this operation may reorder the @@ -2654,9 +2654,9 @@ public: /// @Deprecated ConstantIntTy *getCaseValue() { assert(Index < SI->getNumCases() && "Index out the number of cases."); - ConstantRangesSet CRS = + IntegersSubset CaseRanges = reinterpret_cast(SI->getOperand(2 + Index*2)); - ConstantRangesSet::Range R = CRS.getItem(0); + IntegersSubset::Range R = CaseRanges.getItem(0); // FIXME: Currently we work with ConstantInt based cases. // So return CaseValue as ConstantInt. @@ -2664,7 +2664,7 @@ public: } /// Resolves case value for current case. - ConstantRangesSet getCaseValueEx() { + IntegersSubset getCaseValueEx() { assert(Index < SI->getNumCases() && "Index out the number of cases."); return reinterpret_cast(SI->getOperand(2 + Index*2)); } @@ -2736,16 +2736,16 @@ public: /// @Deprecated. void setValue(ConstantInt *V) { assert(Index < SI->getNumCases() && "Index out the number of cases."); - CRSBuilder CB; + IntegersSubsetToBB Mapping; // FIXME: Currently we work with ConstantInt based cases. // So inititalize IntItem container directly from ConstantInt. - CB.add(IntItem::fromConstantInt(V)); + Mapping.add(IntItem::fromConstantInt(V)); SI->setOperand(2 + Index*2, - reinterpret_cast((Constant*)CB.getCase())); + reinterpret_cast((Constant*)Mapping.getCase())); } /// Sets the new value for current case. - void setValueEx(ConstantRangesSet& V) { + void setValueEx(IntegersSubset& V) { assert(Index < SI->getNumCases() && "Index out the number of cases."); SI->setOperand(2 + Index*2, reinterpret_cast((Constant*)V)); } diff --git a/include/llvm/Support/ConstantRangesSet.h b/include/llvm/Support/IntegersSubset.h similarity index 99% rename from include/llvm/Support/ConstantRangesSet.h rename to include/llvm/Support/IntegersSubset.h index 109bd5b26e9..894b104da96 100644 --- a/include/llvm/Support/ConstantRangesSet.h +++ b/include/llvm/Support/IntegersSubset.h @@ -223,14 +223,14 @@ struct IntRange { /// Note: It is assumed that "holder" is inherited from Constant object. /// ConstantRangesSet may be converted to and from Constant* pointer. /// -class ConstantRangesSet { +class IntegersSubset { Constant *Array; public: bool IsWide; // implicit - ConstantRangesSet(Constant *V) : Array(V) { + IntegersSubset(Constant *V) : Array(V) { ArrayType *ArrTy = cast(Array->getType()); VectorType *VecTy = cast(ArrTy->getElementType()); IntegerType *IntTy = cast(VecTy->getElementType()); diff --git a/include/llvm/Support/CRSBuilder.h b/include/llvm/Support/IntegersSubsetMapping.h similarity index 88% rename from include/llvm/Support/CRSBuilder.h rename to include/llvm/Support/IntegersSubsetMapping.h index c5dfa9f3f11..eaa2f5be2f1 100644 --- a/include/llvm/Support/CRSBuilder.h +++ b/include/llvm/Support/IntegersSubsetMapping.h @@ -19,7 +19,7 @@ #ifndef CRSBUILDER_H_ #define CRSBUILDER_H_ -#include "llvm/Support/ConstantRangesSet.h" +#include "llvm/Support/IntegersSubset.h" #include #include #include @@ -27,13 +27,13 @@ namespace llvm { template -class CRSBuilderBase { +class IntegersSubsetMapping { public: - typedef ConstantRangesSet::Range RangeTy; + typedef IntegersSubset::Range RangeTy; struct RangeEx : public RangeTy { - typedef ConstantRangesSet::Range RangeTy; + typedef IntegersSubset::Range RangeTy; RangeEx() : Weight(1) {} RangeEx(const RangeTy &R) : RangeTy(R.Low, R.High), Weight(1) {} RangeEx(const IntItem &C) : RangeTy(C), Weight(1) {} @@ -50,6 +50,12 @@ protected: typedef std::vector CaseItems; typedef typename CaseItems::iterator CaseItemIt; typedef typename CaseItems::const_iterator CaseItemConstIt; + + typedef std::list RangesCollection; + typedef typename RangesCollection::iterator RangesCollectionIt; + + typedef std::map CRSMap; + typedef typename CRSMap::iterator CRSMapIt; struct ClustersCmp { bool operator()(const Cluster &C1, const Cluster &C2) { @@ -82,6 +88,31 @@ protected: Sorted = true; } } + + IntegersSubset getCase(RangesCollection& Src) { + std::vector Elts; + Elts.reserve(Src.size()); + for (RangesCollectionIt i = Src.begin(), e = Src.end(); i != e; ++i) { + RangeTy &R = *i; + std::vector r; + if (R.isSingleNumber()) { + r.reserve(2); + // FIXME: Since currently we have ConstantInt based numbers + // use hack-conversion of IntItem to ConstantInt + r.push_back(R.Low.toConstantInt()); + r.push_back(R.High.toConstantInt()); + } else { + r.reserve(1); + r.push_back(R.Low.toConstantInt()); + } + Constant *CV = ConstantVector::get(r); + Elts.push_back(CV); + } + ArrayType *ArrTy = + ArrayType::get(Elts.front()->getType(), (uint64_t)Elts.size()); + Constant *Array = ConstantArray::get(ArrTy, Elts); + return IntegersSubset(Array); + } public: @@ -91,7 +122,10 @@ public: // factory. typedef CaseItemIt RangeIterator; - CRSBuilderBase() { + typedef std::pair Case; + typedef std::list Cases; + + IntegersSubsetMapping() { Items.reserve(32); Sorted = false; } @@ -164,7 +198,7 @@ public: /// Adds all ranges and values from given ranges set to the current /// CRSBuilder object. - void add(const ConstantRangesSet &CRS, SuccessorClass *S = 0) { + void add(const IntegersSubset &CRS, SuccessorClass *S = 0) { for (unsigned i = 0, e = CRS.getNumItems(); i < e; ++i) { RangeTy R = CRS.getItem(i); add(R, S); @@ -174,59 +208,6 @@ public: /// Removes items from set. void removeItem(RangeIterator i) { Items.erase(i); } - /// Returns true if there is no ranges and values inside. - bool empty() const { return Items.empty(); } - - RangeIterator begin() { return Items.begin(); } - RangeIterator end() { return Items.end(); } -}; - -template -class CRSBuilderT : public CRSBuilderBase { -public: - - typedef typename CRSBuilderBase::RangeTy RangeTy; - typedef typename CRSBuilderBase::RangeIterator - RangeIterator; - -private: - - typedef std::list RangesCollection; - typedef typename RangesCollection::iterator RangesCollectionIt; - - typedef std::map CRSMap; - typedef typename CRSMap::iterator CRSMapIt; - - ConstantRangesSet getCase(RangesCollection& Src) { - std::vector Elts; - Elts.reserve(Src.size()); - for (RangesCollectionIt i = Src.begin(), e = Src.end(); i != e; ++i) { - RangeTy &R = *i; - std::vector r; - if (R.isSingleNumber()) { - r.reserve(2); - // FIXME: Since currently we have ConstantInt based numbers - // use hack-conversion of IntItem to ConstantInt - r.push_back(R.Low.toConstantInt()); - r.push_back(R.High.toConstantInt()); - } else { - r.reserve(1); - r.push_back(R.Low.toConstantInt()); - } - Constant *CV = ConstantVector::get(r); - Elts.push_back(CV); - } - ArrayType *ArrTy = - ArrayType::get(Elts.front()->getType(), (uint64_t)Elts.size()); - Constant *Array = ConstantArray::get(ArrTy, Elts); - return ConstantRangesSet(Array); - } - -public: - - typedef std::pair Case; - typedef std::list Cases; - /// Builds the finalized case objects. void getCases(Cases& TheCases) { CRSMap TheCRSMap; @@ -238,17 +219,22 @@ public: /// Builds the finalized case objects ignoring successor values, as though /// all ranges belongs to the same successor. - ConstantRangesSet getCase() { + IntegersSubset getCase() { RangesCollection Ranges; for (RangeIterator i = this->begin(); i != this->end(); ++i) Ranges.push_back(i->first); return getCase(Ranges); - } + } + + /// Returns true if there is no ranges and values inside. + bool empty() const { return Items.empty(); } + + RangeIterator begin() { return Items.begin(); } + RangeIterator end() { return Items.end(); } }; class BasicBlock; -typedef CRSBuilderT CRSBuilder; -typedef CRSBuilderBase CRSBuilderConst; +typedef IntegersSubsetMapping IntegersSubsetToBB; } diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index e58af0eae21..83756daa7ae 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -2234,7 +2234,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { unsigned CurIdx = 5; for (unsigned i = 0; i != NumCases; ++i) { - CRSBuilder CaseBuilder; + IntegersSubsetToBB CaseBuilder; unsigned NumItems = Record[CurIdx++]; for (unsigned ci = 0; ci != NumItems; ++ci) { bool isSingleNumber = Record[CurIdx++]; @@ -2262,7 +2262,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { CaseBuilder.add(IntItem::fromType(OpTy, Low)); } BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]); - ConstantRangesSet Case = CaseBuilder.getCase(); + IntegersSubset Case = CaseBuilder.getCase(); SI->addCase(Case, DestBB); } uint16_t Hash = SI->hash(); diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index d4549642909..7dd18c87ffe 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -1157,12 +1157,12 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, Vals64.push_back(SI.getNumCases()); for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); i != e; ++i) { - ConstantRangesSet CRS = i.getCaseValueEx(); - Vals64.push_back(CRS.getNumItems()); - for (unsigned ri = 0, rn = CRS.getNumItems(); ri != rn; ++ri) { - ConstantRangesSet::Range r = CRS.getItem(ri); + IntegersSubset CaseRanges = i.getCaseValueEx(); + Vals64.push_back(CaseRanges.getNumItems()); + for (unsigned ri = 0, rn = CaseRanges.getNumItems(); ri != rn; ++ri) { + IntegersSubset::Range r = CaseRanges.getItem(ri); - Vals64.push_back(CRS.isSingleNumber(ri)); + Vals64.push_back(CaseRanges.isSingleNumber(ri)); const APInt &Low = r.Low; const APInt &High = r.High; diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index b7a6ec23d6e..15c4258ddb8 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -51,7 +51,7 @@ #include "llvm/Target/TargetLowering.h" #include "llvm/Target/TargetOptions.h" #include "llvm/Support/CommandLine.h" -#include "llvm/Support/CRSBuilder.h" +#include "llvm/Support/IntegersSubsetMapping.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MathExtras.h" @@ -2427,7 +2427,7 @@ size_t SelectionDAGBuilder::Clusterify(CaseVector& Cases, /// Use a shorter form of declaration, and also /// show the we want to use CRSBuilder as Clusterifier. - typedef CRSBuilderBase Clusterifier; + typedef IntegersSubsetMapping Clusterifier; Clusterifier TheClusterifier; diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp index 46ed6fdfbf5..d54010195d0 100644 --- a/lib/ExecutionEngine/Interpreter/Execution.cpp +++ b/lib/ExecutionEngine/Interpreter/Execution.cpp @@ -651,9 +651,9 @@ void Interpreter::visitSwitchInst(SwitchInst &I) { // Check to see if any of the cases match... BasicBlock *Dest = 0; for (SwitchInst::CaseIt i = I.case_begin(), e = I.case_end(); i != e; ++i) { - ConstantRangesSet Case = i.getCaseValueEx(); + IntegersSubset Case = i.getCaseValueEx(); for (unsigned n = 0, en = Case.getNumItems(); n != en; ++n) { - ConstantRangesSet::Range r = Case.getItem(n); + IntegersSubset::Range r = Case.getItem(n); // FIXME: Currently work with ConstantInt based numbers. const ConstantInt *LowCI = r.Low.getImplementation(); const ConstantInt *HighCI = r.High.getImplementation(); diff --git a/lib/Target/CppBackend/CPPBackend.cpp b/lib/Target/CppBackend/CPPBackend.cpp index 9f9545559c9..2ac9fe71fb4 100644 --- a/lib/Target/CppBackend/CPPBackend.cpp +++ b/lib/Target/CppBackend/CPPBackend.cpp @@ -1105,7 +1105,7 @@ void CppWriter::printInstruction(const Instruction *I, nl(Out); for (SwitchInst::ConstCaseIt i = SI->case_begin(), e = SI->case_end(); i != e; ++i) { - const ConstantRangesSet CaseVal = i.getCaseValueEx(); + const IntegersSubset CaseVal = i.getCaseValueEx(); const BasicBlock *BB = i.getCaseSuccessor(); Out << iName << "->addCase(" << getOpName(CaseVal) << ", " diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp index 130b876ee96..a4ddfa5de3c 100644 --- a/lib/Transforms/Utils/Local.cpp +++ b/lib/Transforms/Utils/Local.cpp @@ -169,11 +169,11 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions) { // Otherwise, we can fold this switch into a conditional branch // instruction if it has only one non-default destination. SwitchInst::CaseIt FirstCase = SI->case_begin(); - ConstantRangesSet CRS = FirstCase.getCaseValueEx(); - if (CRS.getNumItems() == 1 && CRS.isSingleNumber(0)) { + IntegersSubset CaseRanges = FirstCase.getCaseValueEx(); + if (CaseRanges.getNumItems() == 1 && CaseRanges.isSingleNumber(0)) { // FIXME: Currently work with ConstantInt based numbers. Value *Cond = Builder.CreateICmpEQ(SI->getCondition(), - CRS.getItem(0).Low.toConstantInt(), + CaseRanges.getItem(0).Low.toConstantInt(), "cond"); // Insert the new branch. diff --git a/lib/Transforms/Utils/LowerSwitch.cpp b/lib/Transforms/Utils/LowerSwitch.cpp index 23620373a06..a4cf7732928 100644 --- a/lib/Transforms/Utils/LowerSwitch.cpp +++ b/lib/Transforms/Utils/LowerSwitch.cpp @@ -223,22 +223,22 @@ BasicBlock* LowerSwitch::newLeafBlock(CaseRange& Leaf, Value* Val, // Clusterify - Transform simple list of Cases into list of CaseRange's unsigned LowerSwitch::Clusterify(CaseVector& Cases, SwitchInst *SI) { - CRSBuilder TheClusterifier; + IntegersSubsetToBB TheClusterifier; // Start with "simple" cases for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e; ++i) { BasicBlock *SuccBB = i.getCaseSuccessor(); - ConstantRangesSet CRS = i.getCaseValueEx(); - TheClusterifier.add(CRS, SuccBB); + IntegersSubset CaseRanges = i.getCaseValueEx(); + TheClusterifier.add(CaseRanges, SuccBB); } TheClusterifier.optimize(); size_t numCmps = 0; - for (CRSBuilder::RangeIterator i = TheClusterifier.begin(), + for (IntegersSubsetToBB::RangeIterator i = TheClusterifier.begin(), e = TheClusterifier.end(); i != e; ++i, ++numCmps) { - CRSBuilder::Cluster &C = *i; + IntegersSubsetToBB::Cluster &C = *i; // FIXME: Currently work with ConstantInt based numbers. // Changing it to APInt based is a pretty heavy for this commit. diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 42a92d955c1..26cc6322da7 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -3169,16 +3169,16 @@ SwitchInst::~SwitchInst() { /// addCase - Add an entry to the switch instruction... /// void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) { - CRSBuilder CB; + IntegersSubsetToBB Mapping; // FIXME: Currently we work with ConstantInt based cases. // So inititalize IntItem container directly from ConstantInt. - CB.add(IntItem::fromConstantInt(OnVal)); - ConstantRangesSet CRS = CB.getCase(); - addCase(CRS, Dest); + Mapping.add(IntItem::fromConstantInt(OnVal)); + IntegersSubset CaseRanges = Mapping.getCase(); + addCase(CaseRanges, Dest); } -void SwitchInst::addCase(ConstantRangesSet& OnVal, BasicBlock *Dest) { +void SwitchInst::addCase(IntegersSubset& OnVal, BasicBlock *Dest) { unsigned NewCaseIdx = getNumCases(); unsigned OpNo = NumOperands; if (OpNo+2 > ReservedSpace) diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index c546e416f45..cae3bc8855e 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -806,23 +806,23 @@ void Verifier::visitSwitchInst(SwitchInst &SI) { // have the same type as the switched-on value. Type *SwitchTy = SI.getCondition()->getType(); IntegerType *IntTy = cast(SwitchTy); - CRSBuilder Builder; - std::map RangeSetMap; + IntegersSubsetToBB Mapping; + std::map RangeSetMap; for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); i != e; ++i) { - ConstantRangesSet RS = i.getCaseValueEx(); - for (unsigned ri = 0, rie = RS.getNumItems(); ri < rie; ++ri) { - ConstantRangesSet::Range r = RS.getItem(ri); + IntegersSubset CaseRanges = i.getCaseValueEx(); + for (unsigned ri = 0, rie = CaseRanges.getNumItems(); ri < rie; ++ri) { + IntegersSubset::Range r = CaseRanges.getItem(ri); Assert1(r.Low->getBitWidth() == IntTy->getBitWidth(), "Switch constants must all be same type as switch value!", &SI); Assert1(r.High->getBitWidth() == IntTy->getBitWidth(), "Switch constants must all be same type as switch value!", &SI); - Builder.add(r); + Mapping.add(r); RangeSetMap[r] = i.getCaseIndex(); } } - CRSBuilder::RangeIterator errItem; - if (!Builder.verify(errItem)) { + IntegersSubsetToBB::RangeIterator errItem; + if (!Mapping.verify(errItem)) { unsigned CaseIndex = RangeSetMap[errItem->first]; SwitchInst::CaseIt i(&SI, CaseIndex); Assert2(false, "Duplicate integer as switch case", &SI, i.getCaseValueEx()); diff --git a/tools/llvm-diff/DifferenceEngine.cpp b/tools/llvm-diff/DifferenceEngine.cpp index 0e7815b26ba..0c1e30c987e 100644 --- a/tools/llvm-diff/DifferenceEngine.cpp +++ b/tools/llvm-diff/DifferenceEngine.cpp @@ -326,7 +326,7 @@ class FunctionDifferenceEngine { for (SwitchInst::CaseIt I = RI->case_begin(), E = RI->case_end(); I != E; ++I) { - ConstantRangesSet CaseValue = I.getCaseValueEx(); + IntegersSubset CaseValue = I.getCaseValueEx(); BasicBlock *LCase = LCases[CaseValue]; if (LCase) { if (TryUnify) tryUnify(LCase, I.getCaseSuccessor());