[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 yandex.ru
Sun Jun 24 03:54:21 PDT 2012


Ok. Thanks!
-Stepan.

> Tweaked in r159101. I don't like this, ugly workaround, sorry. :(
> 
> ...Takumi
> 
> 2012/6/23 David Dean <david_dean at apple.com>:
> 
>> 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:
>>
Sass>>> 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


 -- 
Truly yours,
Stepan Dyatkovskiy



More information about the llvm-commits mailing list