[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
David Dean
david_dean at apple.com
Fri Jun 22 13:18:44 PDT 2012
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
More information about the llvm-commits
mailing list