[llvm-commits] [llvm] r158997 - in /llvm/trunk: include/llvm/Instructions.h include/llvm/Support/IntegersSubset.h lib/Transforms/Utils/CodeExtractor.cpp lib/VMCore/Instructions.cpp
Stepan Dyatkovskiy
stpworld at narod.ru
Sat Jun 23 03:04:57 PDT 2012
Yup. Looks like you said. But probably David can show stdout, and we can
determine what exactly happens...
-Stepan.
NAKAMURA Takumi wrote:
> It seems msvc mi-infers inappropriate type.
>
> default copy constructor on IntegersSubset is applied to
> explicit IntegersSubsetGeneric(const RangesCollectionTy& Links),
> not to copy constructor.
>
> One of workaround, I suggest to add dummy argument on
> IntegersSubsetGeneric(const RangesCollectionTy& Links, int dummy),
> for msvc to distinguish it.
>
> I don't know what is wrong. :p
>
> ...Takumi
>
> 2012/6/23 Stepan Dyatkovskiy <stpworld at narod.ru>:
>> OK. Thanks. Would you send me more detailed error message? stdout will
>> fine.
>> -Stepan.
>> David Dean wrote:
>>> This appears to have broken windows builds:
>>>
>>> llvm/Support/IntegersSubset.h(306) : error C2039: 'size' : is not a member of 'llvm::IntegersSubset'
>>> llvm/Support/IntegersSubset.h(458) : see declaration of 'llvm::IntegersSubset'
>>>
>>>
>>> On 22 Jun 2012, at 7:53 AM, Stepan Dyatkovskiy wrote:
>>>
>>>> Author: dyatkovskiy
>>>> Date: Fri Jun 22 09:53:30 2012
>>>> New Revision: 158997
>>>>
>>>> URL: http://llvm.org/viewvc/llvm-project?rev=158997&view=rev
>>>> Log:
>>>> Fixed r158979.
>>>> Original message:
>>>> Performance optimizations:
>>>> - SwitchInst: case values stored separately from Operands List. It allows to make faster access to individual case value numbers or ranges.
>>>> - Optimized IntItem, added APInt value caching.
>>>> - Optimized IntegersSubsetGeneric: added optimizations for cases when subset is single number or when subset consists from single numbers only.
>>>>
>>>>
>>>> Modified:
>>>> llvm/trunk/include/llvm/Instructions.h
>>>> llvm/trunk/include/llvm/Support/IntegersSubset.h
>>>> llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp
>>>> llvm/trunk/lib/VMCore/Instructions.cpp
>>>>
>>>> Modified: llvm/trunk/include/llvm/Instructions.h
>>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Instructions.h?rev=158997&r1=158996&r2=158997&view=diff
>>>> ==============================================================================
>>>> --- llvm/trunk/include/llvm/Instructions.h (original)
>>>> +++ llvm/trunk/include/llvm/Instructions.h Fri Jun 22 09:53:30 2012
>>>> @@ -2442,10 +2442,31 @@
>>>> class SwitchInst : public TerminatorInst {
>>>> void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
>>>> unsigned ReservedSpace;
>>>> + // Operands format:
>>>> // Operand[0] = Value to switch on
>>>> // Operand[1] = Default basic block destination
>>>> // Operand[2n ] = Value to match
>>>> // Operand[2n+1] = BasicBlock to go to on match
>>>> +
>>>> + // Store case values separately from operands list. We needn't User-Use
>>>> + // concept here, since it is just a case value, it will always constant,
>>>> + // and case value couldn't reused with another instructions/values.
>>>> + // Additionally:
>>>> + // It allows us to use custom type for case values that is not inherited
>>>> + // from Value. Since case value is a complex type that implements
>>>> + // the subset of integers, we needn't extract sub-constants within
>>>> + // slow getAggregateElement method.
>>>> + // For case values we will use std::list to by two reasons:
>>>> + // 1. It allows to add/remove cases without whole collection reallocation.
>>>> + // 2. In most of cases we needn't random access.
>>>> + // Currently case values are also stored in Operands List, but it will moved
>>>> + // out in future commits.
>>>> + typedef std::list<IntegersSubset> Subsets;
>>>> + typedef Subsets::iterator SubsetsIt;
>>>> + typedef Subsets::const_iterator SubsetsConstIt;
>>>> +
>>>> + Subsets TheSubsets;
>>>> +
>>>> SwitchInst(const SwitchInst &SI);
>>>> void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
>>>> void growOperands();
>>>> @@ -2470,12 +2491,20 @@
>>>> virtual SwitchInst *clone_impl() const;
>>>> public:
>>>>
>>>> - template <class SwitchInstTy, class ConstantIntTy, class BasicBlockTy>
>>>> + // FIXME: Currently there are a lot of unclean template parameters,
>>>> + // we need to make refactoring in future.
>>>> + // All these parameters are used to implement both iterator and const_iterator
>>>> + // without code duplication.
>>>> + // SwitchInstTy may be "const SwitchInst" or "SwitchInst"
>>>> + // ConstantIntTy may be "const ConstantInt" or "ConstantInt"
>>>> + // SubsetsItTy may be SubsetsConstIt or SubsetsIt
>>>> + // BasicBlockTy may be "const BasicBlock" or "BasicBlock"
>>>> + template <class SwitchInstTy, class ConstantIntTy,
>>>> + class SubsetsItTy, class BasicBlockTy>
>>>> class CaseIteratorT;
>>>>
>>>> - typedef CaseIteratorT<const SwitchInst, const ConstantInt, const BasicBlock>
>>>> - ConstCaseIt;
>>>> -
>>>> + typedef CaseIteratorT<const SwitchInst, const ConstantInt,
>>>> + SubsetsConstIt, const BasicBlock> ConstCaseIt;
>>>> class CaseIt;
>>>>
>>>> // -2
>>>> @@ -2516,23 +2545,23 @@
>>>> /// Returns a read/write iterator that points to the first
>>>> /// case in SwitchInst.
>>>> CaseIt case_begin() {
>>>> - return CaseIt(this, 0);
>>>> + return CaseIt(this, 0, TheSubsets.begin());
>>>> }
>>>> /// Returns a read-only iterator that points to the first
>>>> /// case in the SwitchInst.
>>>> ConstCaseIt case_begin() const {
>>>> - return ConstCaseIt(this, 0);
>>>> + return ConstCaseIt(this, 0, TheSubsets.begin());
>>>> }
>>>>
>>>> /// Returns a read/write iterator that points one past the last
>>>> /// in the SwitchInst.
>>>> CaseIt case_end() {
>>>> - return CaseIt(this, getNumCases());
>>>> + return CaseIt(this, getNumCases(), TheSubsets.end());
>>>> }
>>>> /// Returns a read-only iterator that points one past the last
>>>> /// in the SwitchInst.
>>>> ConstCaseIt case_end() const {
>>>> - return ConstCaseIt(this, getNumCases());
>>>> + return ConstCaseIt(this, getNumCases(), TheSubsets.end());
>>>> }
>>>> /// Returns an iterator that points to the default case.
>>>> /// Note: this iterator allows to resolve successor only. Attempt
>>>> @@ -2540,10 +2569,10 @@
>>>> /// Also note, that increment and decrement also causes an assertion and
>>>> /// makes iterator invalid.
>>>> CaseIt case_default() {
>>>> - return CaseIt(this, DefaultPseudoIndex);
>>>> + return CaseIt(this, DefaultPseudoIndex, TheSubsets.end());
>>>> }
>>>> ConstCaseIt case_default() const {
>>>> - return ConstCaseIt(this, DefaultPseudoIndex);
>>>> + return ConstCaseIt(this, DefaultPseudoIndex, TheSubsets.end());
>>>> }
>>>>
>>>> /// findCaseValue - Search all of the case values for the specified constant.
>>>> @@ -2597,7 +2626,7 @@
>>>> /// Note:
>>>> /// This action invalidates iterators for all cases following the one removed,
>>>> /// including the case_end() iterator.
>>>> - void removeCase(CaseIt i);
>>>> + void removeCase(CaseIt& i);
>>>>
>>>> unsigned getNumSuccessors() const { return getNumOperands()/2; }
>>>> BasicBlock *getSuccessor(unsigned idx) const {
>>>> @@ -2622,24 +2651,38 @@
>>>>
>>>> // Case iterators definition.
>>>>
>>>> - template <class SwitchInstTy, class ConstantIntTy, class BasicBlockTy>
>>>> + template <class SwitchInstTy, class ConstantIntTy,
>>>> + class SubsetsItTy, class BasicBlockTy>
>>>> class CaseIteratorT {
>>>> protected:
>>>>
>>>> SwitchInstTy *SI;
>>>> - unsigned Index;
>>>> -
>>>> - public:
>>>> -
>>>> - typedef CaseIteratorT<SwitchInstTy, ConstantIntTy, BasicBlockTy> Self;
>>>> + unsigned long Index;
>>>> + SubsetsItTy SubsetIt;
>>>>
>>>> /// Initializes case iterator for given SwitchInst and for given
>>>> /// case number.
>>>> - CaseIteratorT(SwitchInstTy *SI, unsigned CaseNum) {
>>>> + friend class SwitchInst;
>>>> + CaseIteratorT(SwitchInstTy *SI, unsigned SuccessorIndex,
>>>> + SubsetsItTy CaseValueIt) {
>>>> this->SI = SI;
>>>> - Index = CaseNum;
>>>> + Index = SuccessorIndex;
>>>> + this->SubsetIt = CaseValueIt;
>>>> }
>>>>
>>>> + public:
>>>> + typedef typename SubsetsItTy::reference IntegersSubsetRef;
>>>> + typedef CaseIteratorT<SwitchInstTy, ConstantIntTy,
>>>> + SubsetsItTy, BasicBlockTy> Self;
>>>> +
>>>> + CaseIteratorT(SwitchInstTy *SI, unsigned CaseNum) {
>>>> + this->SI = SI;
>>>> + Index = CaseNum;
>>>> + SubsetIt = SI->TheSubsets.begin();
>>>> + std::advance(SubsetIt, CaseNum);
>>>> + }
>>>> +
>>>> +
>>>> /// Initializes case iterator for given SwitchInst and for given
>>>> /// TerminatorInst's successor index.
>>>> static Self fromSuccessorIndex(SwitchInstTy *SI, unsigned SuccessorIndex) {
>>>> @@ -2654,19 +2697,18 @@
>>>> /// @Deprecated
>>>> ConstantIntTy *getCaseValue() {
>>>> assert(Index < SI->getNumCases() && "Index out the number of cases.");
>>>> - IntegersSubset CaseRanges =
>>>> - reinterpret_cast<Constant*>(SI->getOperand(2 + Index*2));
>>>> - IntegersSubset::Range R = CaseRanges.getItem(0);
>>>> + IntegersSubsetRef CaseRanges = *SubsetIt;
>>>>
>>>> // FIXME: Currently we work with ConstantInt based cases.
>>>> // So return CaseValue as ConstantInt.
>>>> - return R.getLow().toConstantInt();
>>>> + return CaseRanges.getSingleNumber(0).toConstantInt();
>>>> }
>>>>
>>>> /// Resolves case value for current case.
>>>> +// IntegersSubsetRef getCaseValueEx() {
>>>> IntegersSubset getCaseValueEx() {
>>>> assert(Index < SI->getNumCases() && "Index out the number of cases.");
>>>> - return reinterpret_cast<Constant*>(SI->getOperand(2 + Index*2));
>>>> + return *SubsetIt;
>>>> }
>>>>
>>>> /// Resolves successor for current case.
>>>> @@ -2689,9 +2731,14 @@
>>>>
>>>> Self operator++() {
>>>> // Check index correctness after increment.
>>>> - // Note: Index == getNumCases() means end().
>>>> - assert(Index+1 <= SI->getNumCases() && "Index out the number of cases.");
>>>> + // Note: Index == getNumCases() means end().
>>>> + unsigned NumCases = SI->getNumCases();
>>>> + assert(Index+1 <= NumCases && "Index out the number of cases.");
>>>> ++Index;
>>>> + if (Index == 0)
>>>> + SubsetIt = SI->TheSubsets.begin();
>>>> + else
>>>> + ++SubsetIt;
>>>> return *this;
>>>> }
>>>> Self operator++(int) {
>>>> @@ -2703,9 +2750,18 @@
>>>> // Check index correctness after decrement.
>>>> // Note: Index == getNumCases() means end().
>>>> // Also allow "-1" iterator here. That will became valid after ++.
>>>> - assert((Index == 0 || Index-1 <= SI->getNumCases()) &&
>>>> + unsigned NumCases = SI->getNumCases();
>>>> + assert((Index == 0 || Index-1 <= NumCases) &&
>>>> "Index out the number of cases.");
>>>> --Index;
>>>> + if (Index == NumCases) {
>>>> + SubsetIt = SI->TheSubsets.end();
>>>> + return *this;
>>>> + }
>>>> +
>>>> + if (Index != -1UL)
>>>> + --SubsetIt;
>>>> +
>>>> return *this;
>>>> }
>>>> Self operator--(int) {
>>>> @@ -2723,14 +2779,25 @@
>>>> }
>>>> };
>>>>
>>>> - class CaseIt : public CaseIteratorT<SwitchInst, ConstantInt, BasicBlock> {
>>>> + class CaseIt : public CaseIteratorT<SwitchInst, ConstantInt,
>>>> + SubsetsIt, BasicBlock> {
>>>> + typedef CaseIteratorT<SwitchInst, ConstantInt, SubsetsIt, BasicBlock>
>>>> + ParentTy;
>>>> +
>>>> + protected:
>>>> + friend class SwitchInst;
>>>> + CaseIt(SwitchInst *SI, unsigned CaseNum, SubsetsIt SubsetIt) :
>>>> + ParentTy(SI, CaseNum, SubsetIt) {}
>>>>
>>>> - typedef CaseIteratorT<SwitchInst, ConstantInt, BasicBlock> ParentTy;
>>>> + void updateCaseValueOperand(IntegersSubset& V) {
>>>> + SI->setOperand(2 + Index*2, reinterpret_cast<Value*>((Constant*)V));
>>>> + }
>>>>
>>>> public:
>>>> +
>>>> + CaseIt(SwitchInst *SI, unsigned CaseNum) : ParentTy(SI, CaseNum) {}
>>>>
>>>> CaseIt(const ParentTy& Src) : ParentTy(Src) {}
>>>> - CaseIt(SwitchInst *SI, unsigned CaseNum) : ParentTy(SI, CaseNum) {}
>>>>
>>>> /// Sets the new value for current case.
>>>> /// @Deprecated.
>>>> @@ -2740,14 +2807,15 @@
>>>> // FIXME: Currently we work with ConstantInt based cases.
>>>> // So inititalize IntItem container directly from ConstantInt.
>>>> Mapping.add(IntItem::fromConstantInt(V));
>>>> - SI->setOperand(2 + Index*2,
>>>> - reinterpret_cast<Value*>((Constant*)Mapping.getCase()));
>>>> + *SubsetIt = Mapping.getCase();
>>>> + updateCaseValueOperand(*SubsetIt);
>>>> }
>>>>
>>>> /// Sets the new value for current case.
>>>> void setValueEx(IntegersSubset& V) {
>>>> assert(Index < SI->getNumCases() && "Index out the number of cases.");
>>>> - SI->setOperand(2 + Index*2, reinterpret_cast<Value*>((Constant*)V));
>>>> + *SubsetIt = V;
>>>> + updateCaseValueOperand(*SubsetIt);
>>>> }
>>>>
>>>> /// Sets the new successor for current case.
>>>>
>>>> Modified: llvm/trunk/include/llvm/Support/IntegersSubset.h
>>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/IntegersSubset.h?rev=158997&r1=158996&r2=158997&view=diff
>>>> ==============================================================================
>>>> --- llvm/trunk/include/llvm/Support/IntegersSubset.h (original)
>>>> +++ llvm/trunk/include/llvm/Support/IntegersSubset.h Fri Jun 22 09:53:30 2012
>>>> @@ -40,26 +40,26 @@
>>>>
>>>> #define INT_ITEM_DEFINE_COMPARISON(op,func) \
>>>> bool operator op (const APInt& RHS) const { \
>>>> - return ConstantIntVal->getValue().func(RHS); \
>>>> + return getAPIntValue().func(RHS); \
>>>> }
>>>>
>>>> #define INT_ITEM_DEFINE_UNARY_OP(op) \
>>>> IntItem operator op () const { \
>>>> - APInt res = op(ConstantIntVal->getValue()); \
>>>> + APInt res = op(getAPIntValue()); \
>>>> Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
>>>> return IntItem(cast<ConstantInt>(NewVal)); \
>>>> }
>>>>
>>>> #define INT_ITEM_DEFINE_BINARY_OP(op) \
>>>> IntItem operator op (const APInt& RHS) const { \
>>>> - APInt res = ConstantIntVal->getValue() op RHS; \
>>>> + APInt res = getAPIntValue() op RHS; \
>>>> Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
>>>> return IntItem(cast<ConstantInt>(NewVal)); \
>>>> }
>>>>
>>>> #define INT_ITEM_DEFINE_ASSIGNMENT_BY_OP(op) \
>>>> IntItem& operator op (const APInt& RHS) {\
>>>> - APInt res = ConstantIntVal->getValue();\
>>>> + APInt res = getAPIntValue();\
>>>> res op RHS; \
>>>> Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
>>>> ConstantIntVal = cast<ConstantInt>(NewVal); \
>>>> @@ -68,7 +68,7 @@
>>>>
>>>> #define INT_ITEM_DEFINE_PREINCDEC(op) \
>>>> IntItem& operator op () { \
>>>> - APInt res = ConstantIntVal->getValue(); \
>>>> + APInt res = getAPIntValue(); \
>>>> op(res); \
>>>> Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
>>>> ConstantIntVal = cast<ConstantInt>(NewVal); \
>>>> @@ -77,7 +77,7 @@
>>>>
>>>> #define INT_ITEM_DEFINE_POSTINCDEC(op) \
>>>> IntItem& operator op (int) { \
>>>> - APInt res = ConstantIntVal->getValue();\
>>>> + APInt res = getAPIntValue();\
>>>> op(res); \
>>>> Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
>>>> OldConstantIntVal = ConstantIntVal; \
>>>> @@ -87,18 +87,24 @@
>>>>
>>>> #define INT_ITEM_DEFINE_OP_STANDARD_INT(RetTy, op, IntTy) \
>>>> RetTy operator op (IntTy RHS) const { \
>>>> - return (*this) op APInt(ConstantIntVal->getValue().getBitWidth(), RHS); \
>>>> + return (*this) op APInt(getAPIntValue().getBitWidth(), RHS); \
>>>> }
>>>>
>>>> class IntItem {
>>>> ConstantInt *ConstantIntVal;
>>>> - IntItem(const ConstantInt *V) : ConstantIntVal(const_cast<ConstantInt*>(V)) {}
>>>> + const APInt* APIntVal;
>>>> + IntItem(const ConstantInt *V) :
>>>> + ConstantIntVal(const_cast<ConstantInt*>(V)),
>>>> + APIntVal(&ConstantIntVal->getValue()){}
>>>> + const APInt& getAPIntValue() const {
>>>> + return *APIntVal;
>>>> + }
>>>> public:
>>>>
>>>> IntItem() {}
>>>>
>>>> operator const APInt&() const {
>>>> - return (const APInt&)ConstantIntVal->getValue();
>>>> + return getAPIntValue();
>>>> }
>>>>
>>>> // Propagate APInt operators.
>>>> @@ -137,7 +143,7 @@
>>>>
>>>> // Special case for <<=
>>>> IntItem& operator <<= (unsigned RHS) {
>>>> - APInt res = ConstantIntVal->getValue();
>>>> + APInt res = getAPIntValue();
>>>> res <<= RHS;
>>>> Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res);
>>>> ConstantIntVal = cast<ConstantInt>(NewVal);
>>>> @@ -278,9 +284,9 @@
>>>> // In short, for more compact memory consumption we can store flat
>>>> // numbers collection, and define range as pair of indices.
>>>> // In that case we can safe some memory on 32 bit machines.
>>>> - typedef std::list<IntTy> FlatCollectionTy;
>>>> + typedef std::vector<IntTy> FlatCollectionTy;
>>>> typedef std::pair<IntTy*, IntTy*> RangeLinkTy;
>>>> - typedef SmallVector<RangeLinkTy, 64> RangeLinksTy;
>>>> + typedef std::vector<RangeLinkTy> RangeLinksTy;
>>>> typedef typename RangeLinksTy::const_iterator RangeLinksConstIt;
>>>>
>>>> typedef IntegersSubsetGeneric<IntTy> self;
>>>> @@ -290,21 +296,33 @@
>>>> FlatCollectionTy FlatCollection;
>>>> RangeLinksTy RangeLinks;
>>>>
>>>> + bool IsSingleNumber;
>>>> + bool IsSingleNumbersOnly;
>>>> +
>>>> public:
>>>>
>>>> template<class RangesCollectionTy>
>>>> explicit IntegersSubsetGeneric(const RangesCollectionTy& Links) {
>>>> assert(Links.size() && "Empty ranges are not allowed.");
>>>> +
>>>> + // In case of big set of single numbers consumes additional RAM space,
>>>> + // but allows to avoid additional reallocation.
>>>> + FlatCollection.reserve(Links.size() * 2);
>>>> + RangeLinks.reserve(Links.size());
>>>> + IsSingleNumbersOnly = true;
>>>> for (typename RangesCollectionTy::const_iterator i = Links.begin(),
>>>> e = Links.end(); i != e; ++i) {
>>>> RangeLinkTy RangeLink;
>>>> FlatCollection.push_back(i->getLow());
>>>> RangeLink.first = &FlatCollection.back();
>>>> - if (i->getLow() != i->getHigh())
>>>> + if (i->getLow() != i->getHigh()) {
>>>> FlatCollection.push_back(i->getHigh());
>>>> + IsSingleNumbersOnly = false;
>>>> + }
>>>> RangeLink.second = &FlatCollection.back();
>>>> RangeLinks.push_back(RangeLink);
>>>> }
>>>> + IsSingleNumber = IsSingleNumbersOnly && RangeLinks.size() == 1;
>>>> }
>>>>
>>>> IntegersSubsetGeneric(const self& RHS) {
>>>> @@ -314,6 +332,8 @@
>>>> self& operator=(const self& RHS) {
>>>> FlatCollection.clear();
>>>> RangeLinks.clear();
>>>> + FlatCollection.reserve(RHS.RangeLinks.size() * 2);
>>>> + RangeLinks.reserve(RHS.RangeLinks.size());
>>>> for (RangeLinksConstIt i = RHS.RangeLinks.begin(), e = RHS.RangeLinks.end();
>>>> i != e; ++i) {
>>>> RangeLinkTy RangeLink;
>>>> @@ -324,6 +344,8 @@
>>>> RangeLink.second = &FlatCollection.back();
>>>> RangeLinks.push_back(RangeLink);
>>>> }
>>>> + IsSingleNumber = RHS.IsSingleNumber;
>>>> + IsSingleNumbersOnly = RHS.IsSingleNumbersOnly;
>>>> return *this;
>>>> }
>>>>
>>>> @@ -333,6 +355,13 @@
>>>> /// true if it equals to one of contained values or belongs to the one of
>>>> /// contained ranges.
>>>> bool isSatisfies(const IntTy &CheckingVal) const {
>>>> + if (IsSingleNumber)
>>>> + return FlatCollection.front() == CheckingVal;
>>>> + if (IsSingleNumbersOnly)
>>>> + return std::find(FlatCollection.begin(),
>>>> + FlatCollection.end(),
>>>> + CheckingVal) != FlatCollection.end();
>>>> +
>>>> for (unsigned i = 0, e = getNumItems(); i < e; ++i) {
>>>> if (RangeLinks[i].first == RangeLinks[i].second) {
>>>> if (*RangeLinks[i].first == CheckingVal)
>>>> @@ -360,8 +389,12 @@
>>>>
>>>> /// Returns true if whole subset contains single element.
>>>> bool isSingleNumber() const {
>>>> - return RangeLinks.size() == 1 &&
>>>> - RangeLinks[0].first == RangeLinks[0].second;
>>>> + return IsSingleNumber;
>>>> + }
>>>> +
>>>> + /// Returns true if whole subset contains only single numbers, no ranges.
>>>> + bool isSingleNumbersOnly() const {
>>>> + return IsSingleNumbersOnly;
>>>> }
>>>>
>>>> /// Does the same like getItem(idx).isSingleNumber(), but
>>>> @@ -385,7 +418,7 @@
>>>> }
>>>> return sz.getZExtValue();
>>>> }
>>>> -
>>>> +
>>>> /// Allows to access single value even if it belongs to some range.
>>>> /// Ranges set is considered as flat numbers collection.
>>>> /// [<1>, <4,8>] is considered as [1,4,5,6,7,8]
>>>> @@ -409,6 +442,14 @@
>>>> assert(0 && "Index exceeds high border.");
>>>> return sz;
>>>> }
>>>> +
>>>> + /// Does the same as getSingleValue, but works only if subset contains
>>>> + /// single numbers only.
>>>> + const IntTy& getSingleNumber(unsigned idx) const {
>>>> + assert(IsSingleNumbersOnly && "This method works properly if subset "
>>>> + "contains single numbers only.");
>>>> + return FlatCollection[idx];
>>>> + }
>>>> };
>>>>
>>>> //===----------------------------------------------------------------------===//
>>>> @@ -455,9 +496,9 @@
>>>> }
>>>>
>>>> public:
>>>> -
>>>> - IntegersSubset(Constant *C) : ParentTy(rangesFromConstant(C)),
>>>> - Holder(C) {}
>>>> +
>>>> + explicit IntegersSubset(Constant *C) : ParentTy(rangesFromConstant(C)),
>>>> + Holder(C) {}
>>>>
>>>> template<class RangesCollectionTy>
>>>> explicit IntegersSubset(const RangesCollectionTy& Src) : ParentTy(Src) {
>>>>
>>>> Modified: llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp
>>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp?rev=158997&r1=158996&r2=158997&view=diff
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp (original)
>>>> +++ llvm/trunk/lib/Transforms/Utils/CodeExtractor.cpp Fri Jun 22 09:53:30 2012
>>>> @@ -664,7 +664,8 @@
>>>> TheSwitch->setCondition(call);
>>>> TheSwitch->setDefaultDest(TheSwitch->getSuccessor(NumExitBlocks));
>>>> // Remove redundant case
>>>> - TheSwitch->removeCase(SwitchInst::CaseIt(TheSwitch, NumExitBlocks-1));
>>>> + SwitchInst::CaseIt ToBeRemoved(TheSwitch, NumExitBlocks-1);
>>>> + TheSwitch->removeCase(ToBeRemoved);
>>>> break;
>>>> }
>>>> }
>>>>
>>>> Modified: llvm/trunk/lib/VMCore/Instructions.cpp
>>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Instructions.cpp?rev=158997&r1=158996&r2=158997&view=diff
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/VMCore/Instructions.cpp (original)
>>>> +++ llvm/trunk/lib/VMCore/Instructions.cpp Fri Jun 22 09:53:30 2012
>>>> @@ -3158,6 +3158,7 @@
>>>> OL[i] = InOL[i];
>>>> OL[i+1] = InOL[i+1];
>>>> }
>>>> + TheSubsets = SI.TheSubsets;
>>>> SubclassOptionalData = SI.SubclassOptionalData;
>>>> }
>>>>
>>>> @@ -3186,14 +3187,17 @@
>>>> // Initialize some new operands.
>>>> assert(OpNo+1 < ReservedSpace && "Growing didn't work!");
>>>> NumOperands = OpNo+2;
>>>> - CaseIt Case(this, NewCaseIdx);
>>>> - Case.setValueEx(OnVal);
>>>> +
>>>> + SubsetsIt TheSubsetsIt = TheSubsets.insert(TheSubsets.end(), OnVal);
>>>> +
>>>> + CaseIt Case(this, NewCaseIdx, TheSubsetsIt);
>>>> + Case.updateCaseValueOperand(OnVal);
>>>> Case.setSuccessor(Dest);
>>>> }
>>>>
>>>> /// removeCase - This method removes the specified case and its successor
>>>> /// from the switch instruction.
>>>> -void SwitchInst::removeCase(CaseIt i) {
>>>> +void SwitchInst::removeCase(CaseIt& i) {
>>>> unsigned idx = i.getCaseIndex();
>>>>
>>>> assert(2 + idx*2 < getNumOperands() && "Case index out of range!!!");
>>>> @@ -3210,6 +3214,16 @@
>>>> // Nuke the last value.
>>>> OL[NumOps-2].set(0);
>>>> OL[NumOps-2+1].set(0);
>>>> +
>>>> + // Do the same with TheCases collection:
>>>> + if (i.SubsetIt != --TheSubsets.end()) {
>>>> + *i.SubsetIt = TheSubsets.back();
>>>> + TheSubsets.pop_back();
>>>> + } else {
>>>> + TheSubsets.pop_back();
>>>> + i.SubsetIt = TheSubsets.end();
>>>> + }
>>>> +
>>>> NumOperands = NumOps-2;
>>>> }
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> llvm-commits mailing list
>>>> llvm-commits at cs.uiuc.edu
>>>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>>>
>>> -David
>>>
>>>
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list