[llvm-commits] [llvm] r158979 - in /llvm/trunk: include/llvm/Instructions.h include/llvm/Support/IntegersSubset.h lib/VMCore/Instructions.cpp

Duncan Sands baldrick at free.fr
Fri Jun 22 02:35:23 PDT 2012


Hi Stepan, this is breaking buildbots, for example

 
http://lab.llvm.org:8011/builders/dragonegg-x86_64-linux-gcc-4.6-self-host-checks/builds/1142

Looks like an invalid iterator problem based on the messages:


/home/baldrick/osuosl/slave/dragonegg-x86_64-linux-gcc-4.6-self-host-checks/gcc.install/lib/gcc/x86_64-unknown-linux-gnu/4.6.4/291:
     error: attempt to decrement a dereferenceable (start-of-sequence)
     iterator.

Objects involved in the operation:
iterator "this" @ 0x0x7fffffffa760 {
type = 
N11__gnu_debug14_Safe_iteratorINSt9__cxx199814_List_iteratorIN4llvm14IntegersSubsetEEENSt7__debug4listIS4_SaIS4_EEEEE 
(mutable iterator);
   state = dereferenceable (start-of-sequence);
   references sequence with type 
`NSt7__debug4listIN4llvm14IntegersSubsetESaIS2_EEE' @ 0x0x7fffffffa760
}
Stack dump:
0.	Running pass 'CallGraph Pass Manager' on module 
'/home/baldrick/osuosl/slave/dragonegg-x86_64-linux-gcc-4.6-self-host-checks/dragonegg.src/src/Cache.cpp'.
1.	Running pass 'Value Propagation' on function '@_ZN4llvm6WeakVHaSEPNS_5ValueE'
g++: internal compiler error: Aborted (program cc1plus)
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://gcc.gnu.org/bugs.html> for instructions.


Ciao, Duncan.

On 22/06/12 09:35, Stepan Dyatkovskiy wrote:
> Author: dyatkovskiy
> Date: Fri Jun 22 02:35:13 2012
> New Revision: 158979
>
> URL: http://llvm.org/viewvc/llvm-project?rev=158979&view=rev
> Log:
> 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.
>
> On my machine these optimizations gave about 4-6% of compile-time improvement.
>
>
> Modified:
>      llvm/trunk/include/llvm/Instructions.h
>      llvm/trunk/include/llvm/Support/IntegersSubset.h
>      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=158979&r1=158978&r2=158979&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Instructions.h (original)
> +++ llvm/trunk/include/llvm/Instructions.h Fri Jun 22 02:35:13 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.
> @@ -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;
> +    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=158979&r1=158978&r2=158979&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Support/IntegersSubset.h (original)
> +++ llvm/trunk/include/llvm/Support/IntegersSubset.h Fri Jun 22 02:35:13 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/VMCore/Instructions.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Instructions.cpp?rev=158979&r1=158978&r2=158979&view=diff
> ==============================================================================
> --- llvm/trunk/lib/VMCore/Instructions.cpp (original)
> +++ llvm/trunk/lib/VMCore/Instructions.cpp Fri Jun 22 02:35:13 2012
> @@ -3158,6 +3158,7 @@
>       OL[i] = InOL[i];
>       OL[i+1] = InOL[i+1];
>     }
> +  TheSubsets = SI.TheSubsets;
>     SubclassOptionalData = SI.SubclassOptionalData;
>   }
>
> @@ -3186,8 +3187,11 @@
>     // 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);
>   }
>
> @@ -3210,6 +3214,11 @@
>     // Nuke the last value.
>     OL[NumOps-2].set(0);
>     OL[NumOps-2+1].set(0);
> +
> +  // Do the same with TheCases collection:
> +  *i.SubsetIt = TheSubsets.back();
> +  TheSubsets.pop_back();
> +
>     NumOperands = NumOps-2;
>   }
>
>
>
> _______________________________________________
> 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