To make matters worse, this is also causing a *slew* of new warnings:<div><br></div><div><pre class="" style="font-family:'Bitstream Vera Sans Mono',Monaco,Consolas,'Courier New',monospace;font-size:12px;line-height:15.600000381469727px;margin-top:0em;color:rgb(0,0,0)">
<span class="">[28/446] Building CXX object lib/VMCore/CMakeFiles/LLVMCore.dir/Metadata.cpp.o
In file included from ../lib/VMCore/Metadata.cpp:15:
In file included from ../lib/VMCore/LLVMContextImpl.h:19:
In file included from ../lib/VMCore/ConstantsContext.h:21:
In file included from ../include/llvm/Instructions.h:23:
../include/llvm/Support/IntegersSubset.h:214:7: warning: default label in switch which covers all enumeration values [-Wcovered-switch-default]
</span> <span class="">default:
^
</span><span class="">../include/llvm/Support/IntegersSubsetMapping.h:379:12: note: in instantiation of member function 'llvm::IntRange<llvm::IntItem>::isSingleNumber' requested here
</span> <span class="">if (!R.isSingleNumber())
</span> <span class="">^
</span><span class="">../include/llvm/Support/IntegersSubsetMapping.h:374:5: note: in instantiation of member function 'llvm::IntegersSubsetMapping<llvm::BasicBlock, llvm::IntegersSubset, llvm::IntItem>::add' requested here
</span> <span class="">add(REx, S);
^
</span><span class="">../include/llvm/Support/IntegersSubsetMapping.h:364:5: note: in instantiation of member function 'llvm::IntegersSubsetMapping<llvm::BasicBlock, llvm::IntegersSubset, llvm::IntItem>::add' requested here
</span> <span class="">add(R, S);
^
</span><span class="">../include/llvm/Instructions.h:2812:15: note: in instantiation of member function 'llvm::IntegersSubsetMapping<llvm::BasicBlock, llvm::IntegersSubset, llvm::IntItem>::add' requested here
</span> <span class="">Mapping.add(IntItem::fromConstantInt(V));
</span> <span class="">^
</span><span class="">1 warning generated.</span></pre></div><div class="gmail_extra"><br><br><div class="gmail_quote">On Mon, Jul 2, 2012 at 6:19 AM, Chandler Carruth <span dir="ltr"><<a href="mailto:chandlerc@google.com" target="_blank">chandlerc@google.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="gmail_extra">I haven't had time to review this in detail, however, I have a strong meta-level comment: please break these patches up before you submit them!</div>
<div class="gmail_extra"><br></div><div class="gmail_extra">
Submitting lumped together patches like this undermines the development and review process of LLVM:</div><div class="gmail_extra">- It makes it hard for reviewers to understand the motivations for different parts of a patch.</div>
<div class="gmail_extra">- It obscures whether all aspects of the patch are well tested.</div><div class="gmail_extra">- It makes build bot failures harder to understand</div><div class="gmail_extra">- It forces more than is strictly necessary to come out in the event that a revert is needed.</div>
<div class="gmail_extra">- It impedes discussion on any one point because of overlap with discussion on other points.</div><div class="gmail_extra"><br></div><div class="gmail_extra">Also, I'm not really sure these are "obvious" and thus valid for post-commit review.</div>
<div class="gmail_extra"><br><div class="gmail_quote">On Mon, Jul 2, 2012 at 6:02 AM, Stepan Dyatkovskiy <span dir="ltr"><<a href="mailto:stpworld@narod.ru" target="_blank">stpworld@narod.ru</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Author: dyatkovskiy<br>
Date: Mon Jul 2 08:02:18 2012<br>
New Revision: 159527<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=159527&view=rev" target="_blank">http://llvm.org/viewvc/llvm-project?rev=159527&view=rev</a><br>
Log:<br>
IntRange:<br>
- Changed isSingleNumber method behaviour. Now this flag is calculated on demand.<br></blockquote><div><br></div><div>Why?</div><div><br></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
IntegersSubsetMapping<br>
- Optimized diff operation.<br></blockquote><div><br></div><div>Under what cases? How much? Did you check in a test case to catch regressions?</div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
- Replaced type of Items field from std::list with std::map.<br></blockquote><div><br></div><div>Why? This type of datastructure change is fairly surprising. We usually move *away* from std::map, not toward it.</div><div>
</div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
- Added new methods:<br>
bool isOverlapped(self &RHS)<br>
void add(self& RHS, SuccessorClass *S)<br>
void detachCase(self& NewMapping, SuccessorClass *Succ)<br>
void removeCase(SuccessorClass *Succ)<br>
SuccessorClass *findSuccessor(const IntTy& Val)<br>
const IntTy* getCaseSingleNumber(SuccessorClass *Succ)<br></blockquote><div><br></div><div>But you didn't add any new tests for them. That's unacceptable.</div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
IntegersSubsetTest<br>
- DiffTest: Added checks for successors.<br>
SimplifyCFG<br>
Updated SwitchInst usage (now it is case-ragnes compatible) for<br>
- SimplifyEqualityComparisonWithOnlyPredecessor<br>
- FoldValueComparisonIntoPredecessors<br>
<br>
<br>
Modified:<br>
llvm/trunk/include/llvm/Support/IntegersSubset.h<br>
llvm/trunk/include/llvm/Support/IntegersSubsetMapping.h<br>
llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp<br>
llvm/trunk/lib/Transforms/Utils/LowerSwitch.cpp<br>
llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp<br>
llvm/trunk/test/Transforms/SimplifyCFG/switch_create.ll<br>
llvm/trunk/unittests/Support/IntegersSubsetTest.cpp<br>
<br>
Modified: llvm/trunk/include/llvm/Support/IntegersSubset.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/IntegersSubset.h?rev=159527&r1=159526&r2=159527&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/IntegersSubset.h?rev=159527&r1=159526&r2=159527&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/include/llvm/Support/IntegersSubset.h (original)<br>
+++ llvm/trunk/include/llvm/Support/IntegersSubset.h Mon Jul 2 08:02:18 2012<br>
@@ -182,7 +182,12 @@<br>
IntType Low;<br>
IntType High;<br>
bool IsEmpty : 1;<br>
- bool IsSingleNumber : 1;<br>
+ enum Type {<br>
+ SINGLE_NUMBER,<br>
+ RANGE,<br>
+ UNKNOWN<br>
+ };<br>
+ Type RangeType;<br>
<br>
public:<br>
typedef IntRange<IntType> self;<br>
@@ -191,15 +196,30 @@<br>
IntRange() : IsEmpty(true) {}<br>
IntRange(const self &RHS) :<br>
Low(RHS.Low), High(RHS.High),<br>
- IsEmpty(RHS.IsEmpty), IsSingleNumber(RHS.IsSingleNumber) {}<br>
+ IsEmpty(RHS.IsEmpty), RangeType(RHS.RangeType) {}<br>
IntRange(const IntType &C) :<br>
- Low(C), High(C), IsEmpty(false), IsSingleNumber(true) {}<br>
+ Low(C), High(C), IsEmpty(false), RangeType(SINGLE_NUMBER) {}<br>
<br>
IntRange(const IntType &L, const IntType &H) : Low(L), High(H),<br>
- IsEmpty(false), IsSingleNumber(Low == High) {}<br>
+ IsEmpty(false), RangeType(UNKNOWN) {}<br>
<br>
bool isEmpty() const { return IsEmpty; }<br>
- bool isSingleNumber() const { return IsSingleNumber; }<br>
+ bool isSingleNumber() const {<br>
+ switch (RangeType) {<br>
+ case SINGLE_NUMBER:<br>
+ return true;<br>
+ case RANGE:<br>
+ return false;<br>
+ case UNKNOWN:<br>
+ default:<br>
+ if (Low == High) {<br>
+ const_cast<Type&>(RangeType) = SINGLE_NUMBER;<br>
+ return true;<br>
+ }<br>
+ const_cast<Type&>(RangeType) = RANGE;<br>
+ return false;<br>
+ }<br>
+ }<br>
<br>
const IntType& getLow() const {<br>
assert(!IsEmpty && "Range is empty.");<br>
@@ -213,13 +233,13 @@<br>
bool operator<(const self &RHS) const {<br>
assert(!IsEmpty && "Left range is empty.");<br>
assert(!RHS.IsEmpty && "Right range is empty.");<br>
+ if (Low < RHS.Low)<br>
+ return true;<br>
if (Low == RHS.Low) {<br>
if (High > RHS.High)<br>
return true;<br>
return false;<br>
}<br>
- if (Low < RHS.Low)<br>
- return true;<br>
return false;<br>
}<br>
<br>
@@ -512,7 +532,7 @@<br>
e = Src.end(); i != e; ++i) {<br>
const Range &R = *i;<br>
std::vector<Constant*> r;<br>
- if (R.isSingleNumber()) {<br>
+ if (!R.isSingleNumber()) {<br>
r.reserve(2);<br>
// FIXME: Since currently we have ConstantInt based numbers<br>
// use hack-conversion of IntItem to ConstantInt<br>
<br>
Modified: llvm/trunk/include/llvm/Support/IntegersSubsetMapping.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/IntegersSubsetMapping.h?rev=159527&r1=159526&r2=159527&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/IntegersSubsetMapping.h?rev=159527&r1=159526&r2=159527&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/include/llvm/Support/IntegersSubsetMapping.h (original)<br>
+++ llvm/trunk/include/llvm/Support/IntegersSubsetMapping.h Mon Jul 2 08:02:18 2012<br>
@@ -58,22 +58,16 @@<br>
<br>
protected:<br>
<br>
- typedef std::list<Cluster> CaseItems;<br>
+ typedef std::map<RangeEx, SuccessorClass*> CaseItems;<br>
typedef typename CaseItems::iterator CaseItemIt;<br>
typedef typename CaseItems::const_iterator CaseItemConstIt;<br>
<br>
// TODO: Change unclean CRS prefixes to SubsetMap for example.<br>
typedef std::map<SuccessorClass*, RangesCollection > CRSMap;<br>
typedef typename CRSMap::iterator CRSMapIt;<br>
-<br>
- struct ClustersCmp {<br>
- bool operator()(const Cluster &C1, const Cluster &C2) {<br>
- return C1.first < C2.first;<br>
- }<br>
- };<br>
<br>
CaseItems Items;<br>
- bool Sorted;<br>
+ bool SingleNumbersOnly;<br>
<br>
bool isIntersected(CaseItemIt& LItem, CaseItemIt& RItem) {<br>
return LItem->first.getHigh() >= RItem->first.getLow();<br>
@@ -91,18 +85,6 @@<br>
return LItem->first.getHigh() >= RLow;<br>
}<br>
<br>
- void sort() {<br>
- if (!Sorted) {<br>
- std::vector<Cluster> clustersVector;<br>
- clustersVector.reserve(Items.size());<br>
- clustersVector.insert(clustersVector.begin(), Items.begin(), Items.end());<br>
- std::sort(clustersVector.begin(), clustersVector.end(), ClustersCmp());<br>
- Items.clear();<br>
- Items.insert(Items.begin(), clustersVector.begin(), clustersVector.end());<br>
- Sorted = true;<br>
- }<br>
- }<br>
-<br>
enum DiffProcessState {<br>
L_OPENED,<br>
INTERSECT_OPENED,<br>
@@ -213,7 +195,7 @@<br>
}<br>
}<br>
<br>
- void onRLOpen(const IntTy &Pt,<br>
+ void onLROpen(const IntTy &Pt,<br>
SuccessorClass *LS,<br>
SuccessorClass *RS) {<br>
switch (State) {<br>
@@ -229,7 +211,7 @@<br>
OpenPt = Pt;<br>
}<br>
<br>
- void onRLClose(const IntTy &Pt) {<br>
+ void onLRClose(const IntTy &Pt) {<br>
switch (State) {<br>
case INTERSECT_OPENED:<br>
if (IntersectionMapping)<br>
@@ -245,6 +227,48 @@<br>
bool isLOpened() { return State == L_OPENED; }<br>
bool isROpened() { return State == R_OPENED; }<br>
};<br>
+<br>
+ void diff_single_numbers(self *LExclude, self *Intersection, self *RExclude,<br>
+ const self& RHS) {<br>
+<br>
+ CaseItemConstIt L = Items.begin(), R = RHS.Items.begin();<br>
+ CaseItemConstIt el = Items.end(), er = RHS.Items.end();<br>
+ while (L != el && R != er) {<br>
+ const Cluster &LCluster = *L;<br>
+ const RangeEx &LRange = LCluster.first;<br>
+ const Cluster &RCluster = *R;<br>
+ const RangeEx &RRange = RCluster.first;<br>
+<br>
+ if (LRange.getLow() < RRange.getLow()) {<br>
+ if (LExclude)<br>
+ LExclude->add(LRange.getLow(), LCluster.second);<br>
+ ++L;<br>
+ } else if (LRange.getLow() > RRange.getLow()) {<br>
+ if (RExclude)<br>
+ RExclude->add(RRange.getLow(), RCluster.second);<br>
+ ++R;<br>
+ } else {<br>
+ if (Intersection)<br>
+ Intersection->add(LRange.getLow(), LCluster.second);<br>
+ ++L;<br>
+ ++R;<br>
+ }<br>
+ }<br>
+<br>
+ if (L != Items.end()) {<br>
+ if (LExclude)<br>
+ do {<br>
+ LExclude->add(L->first, L->second);<br>
+ ++L;<br>
+ } while (L != Items.end());<br>
+ } else if (R != RHS.Items.end()) {<br>
+ if (RExclude)<br>
+ do {<br>
+ RExclude->add(R->first, R->second);<br>
+ ++R;<br>
+ } while (R != RHS.Items.end());<br>
+ }<br>
+ }<br>
<br>
public:<br>
<br>
@@ -256,15 +280,18 @@<br>
<br>
typedef std::pair<SuccessorClass*, IntegersSubsetTy> Case;<br>
typedef std::list<Case> Cases;<br>
+ typedef typename Cases::iterator CasesIt;<br>
+<br>
+ IntegersSubsetMapping() : SingleNumbersOnly(true) {}<br>
<br>
- IntegersSubsetMapping() {<br>
- Sorted = false;<br>
+ bool verify() {<br>
+ RangeIterator DummyErrItem;<br>
+ return verify(DummyErrItem);<br>
}<br>
<br>
bool verify(RangeIterator& errItem) {<br>
if (Items.empty())<br>
return true;<br>
- sort();<br>
for (CaseItemIt j = Items.begin(), i = j++, e = Items.end();<br>
j != e; i = j++) {<br>
if (isIntersected(i, j) && i->second != j->second) {<br>
@@ -275,10 +302,36 @@<br>
return true;<br>
}<br>
<br>
+ bool isOverlapped(self &RHS) {<br>
+ if (Items.empty() || RHS.empty())<br>
+ return true;<br>
+<br>
+ for (CaseItemIt L = Items.begin(), R = RHS.Items.begin(),<br>
+ el = Items.end(), er = RHS.Items.end(); L != el && R != er;) {<br>
+<br>
+ const RangeTy &LRange = L->first;<br>
+ const RangeTy &RRange = R->first;<br>
+<br>
+ if (LRange.getLow() > RRange.getLow()) {<br>
+ if (RRange.isSingleNumber() || LRange.getLow() > RRange.getHigh())<br>
+ ++R;<br>
+ else<br>
+ return true;<br>
+ } else if (LRange.getLow() < RRange.getLow()) {<br>
+ if (LRange.isSingleNumber() || LRange.getHigh() < RRange.getLow())<br>
+ ++L;<br>
+ else<br>
+ return true;<br>
+ } else // iRange.getLow() == jRange.getLow()<br>
+ return true;<br>
+ }<br>
+ return false;<br>
+ }<br>
+<br>
+<br>
void optimize() {<br>
if (Items.size() < 2)<br>
return;<br>
- sort();<br>
CaseItems OldItems = Items;<br>
Items.clear();<br>
const IntTy *Low = &OldItems.begin()->first.getLow();<br>
@@ -303,8 +356,6 @@<br>
}<br>
RangeEx R(*Low, *High, Weight);<br>
add(R, Successor);<br>
- // We recollected the Items, but we kept it sorted.<br>
- Sorted = true;<br>
}<br>
<br>
/// Adds a constant value.<br>
@@ -323,8 +374,10 @@<br>
add(REx, S);<br>
}<br>
void add(const RangeEx &R, SuccessorClass *S = 0) {<br>
- Items.push_back(std::make_pair(R, S));<br>
- Sorted = false;<br>
+ //Items.push_back(std::make_pair(R, S));<br>
+ Items.insert(std::make_pair(R, S));<br>
+ if (!R.isSingleNumber())<br>
+ SingleNumbersOnly = false;<br>
}<br>
<br>
/// Adds all ranges and values from given ranges set to the current<br>
@@ -337,9 +390,17 @@<br>
}<br>
<br>
void add(self& RHS) {<br>
- Items.insert(Items.end(), RHS.Items.begin(), RHS.Items.end());<br>
+ //Items.insert(Items.begin(), RHS.Items.begin(), RHS.Items.end());<br>
+ Items.insert(RHS.Items.begin(), RHS.Items.end());<br>
+ if (!RHS.SingleNumbersOnly)<br>
+ SingleNumbersOnly = false;<br>
}<br>
<br>
+ void add(self& RHS, SuccessorClass *S) {<br>
+ for (CaseItemIt i = RHS.Items.begin(), e = RHS.Items.end(); i != e; ++i)<br>
+ add(i->first, S);<br>
+ }<br>
+<br>
void add(const RangesCollection& RHS, SuccessorClass *S = 0) {<br>
for (RangesCollectionConstIt i = RHS.begin(), e = RHS.end(); i != e; ++i)<br>
add(*i, S);<br>
@@ -348,6 +409,34 @@<br>
/// Removes items from set.<br>
void removeItem(RangeIterator i) { Items.erase(i); }<br>
<br>
+ /// Moves whole case from current mapping to the NewMapping object.<br>
+ void detachCase(self& NewMapping, SuccessorClass *Succ) {<br>
+ for (CaseItemIt i = Items.begin(); i != Items.end();)<br>
+ if (i->second == Succ) {<br>
+ NewMapping.add(i->first, i->second);<br>
+ Items.erase(i++);<br>
+ } else<br>
+ ++i;<br>
+ }<br>
+<br>
+ /// Removes all clusters for given successor.<br>
+ void removeCase(SuccessorClass *Succ) {<br>
+ for (CaseItemIt i = Items.begin(); i != Items.end();)<br>
+ if (i->second == Succ) {<br>
+ Items.erase(i++);<br>
+ } else<br>
+ ++i;<br>
+ }<br>
+<br>
+ /// Find successor that satisfies given value.<br>
+ SuccessorClass *findSuccessor(const IntTy& Val) {<br>
+ for (CaseItemIt i = Items.begin(); i != Items.end(); ++i) {<br>
+ if (i->first.isInRange(Val))<br>
+ return i->second;<br>
+ }<br>
+ return 0;<br>
+ }<br>
+<br>
/// Calculates the difference between this mapping and RHS.<br>
/// THIS without RHS is placed into LExclude,<br>
/// RHS without THIS is placed into RExclude,<br>
@@ -355,10 +444,16 @@<br>
void diff(self *LExclude, self *Intersection, self *RExclude,<br>
const self& RHS) {<br>
<br>
+ if (SingleNumbersOnly && RHS.SingleNumbersOnly) {<br>
+ diff_single_numbers(LExclude, Intersection, RExclude, RHS);<br>
+ return;<br>
+ }<br>
+<br>
DiffStateMachine Machine(LExclude, Intersection, RExclude);<br>
<br>
CaseItemConstIt L = Items.begin(), R = RHS.Items.begin();<br>
- while (L != Items.end() && R != RHS.Items.end()) {<br>
+ CaseItemConstIt el = Items.end(), er = RHS.Items.end();<br>
+ while (L != el && R != er) {<br>
const Cluster &LCluster = *L;<br>
const RangeEx &LRange = LCluster.first;<br>
const Cluster &RCluster = *R;<br>
@@ -377,7 +472,36 @@<br>
++R;<br>
continue;<br>
}<br>
+<br>
+ if (LRange.isSingleNumber() && RRange.isSingleNumber()) {<br>
+ Machine.onLROpen(LRange.getLow(), LCluster.second, RCluster.second);<br>
+ Machine.onLRClose(LRange.getLow());<br>
+ ++L;<br>
+ ++R;<br>
+ continue;<br>
+ }<br>
<br>
+ if (LRange.isSingleNumber()) {<br>
+ Machine.onLOpen(LRange.getLow(), LCluster.second);<br>
+ Machine.onLClose(LRange.getLow());<br>
+ ++L;<br>
+ while(L != Items.end() && L->first.getHigh() < RRange.getHigh()) {<br>
+ Machine.onLOpen(LRange.getLow(), LCluster.second);<br>
+ Machine.onLClose(LRange.getLow());<br>
+ ++L;<br>
+ }<br>
+ continue;<br>
+ } else if (RRange.isSingleNumber()) {<br>
+ Machine.onROpen(R->first.getLow(), R->second);<br>
+ Machine.onRClose(R->first.getHigh());<br>
+ ++R;<br>
+ while(R != RHS.Items.end() && R->first.getHigh() < LRange.getHigh()) {<br>
+ Machine.onROpen(R->first.getLow(), R->second);<br>
+ Machine.onRClose(R->first.getHigh());<br>
+ ++R;<br>
+ }<br>
+ continue;<br>
+ } else<br>
if (LRange.getLow() < RRange.getLow()) {<br>
// May be opened in previous iteration.<br>
if (!Machine.isLOpened())<br>
@@ -390,7 +514,7 @@<br>
Machine.onLOpen(LRange.getLow(), LCluster.second);<br>
}<br>
else<br>
- Machine.onRLOpen(LRange.getLow(), LCluster.second, RCluster.second);<br>
+ Machine.onLROpen(LRange.getLow(), LCluster.second, RCluster.second);<br>
<br>
if (LRange.getHigh() < RRange.getHigh()) {<br>
Machine.onLClose(LRange.getHigh());<br>
@@ -411,7 +535,7 @@<br>
}<br>
}<br>
else {<br>
- Machine.onRLClose(LRange.getHigh());<br>
+ Machine.onLRClose(LRange.getHigh());<br>
++L;<br>
++R;<br>
}<br>
@@ -441,7 +565,20 @@<br>
}<br>
<br>
/// Builds the finalized case objects.<br>
- void getCases(Cases& TheCases) {<br>
+ void getCases(Cases& TheCases, bool PreventMerging = false) {<br>
+ //FIXME: PreventMerging is a temporary parameter.<br>
+ //Currently a set of passes is still knows nothing about<br>
+ //switches with case ranges, and if these passes meet switch<br>
+ //with complex case that crashs the application.<br>
+ if (PreventMerging) {<br>
+ for (RangeIterator i = this->begin(); i != this->end(); ++i) {<br>
+ RangesCollection SingleRange;<br>
+ SingleRange.push_back(i->first);<br>
+ TheCases.push_back(std::make_pair(i->second,<br>
+ IntegersSubsetTy(SingleRange)));<br>
+ }<br>
+ return;<br>
+ }<br>
CRSMap TheCRSMap;<br>
for (RangeIterator i = this->begin(); i != this->end(); ++i)<br>
TheCRSMap[i->second].push_back(i->first);<br>
@@ -458,6 +595,22 @@<br>
return IntegersSubsetTy(Ranges);<br>
}<br>
<br>
+ /// Returns pointer to value of case if it is single-numbered or 0<br>
+ /// in another case.<br>
+ const IntTy* getCaseSingleNumber(SuccessorClass *Succ) {<br>
+ const IntTy* Res = 0;<br>
+ for (CaseItemIt i = Items.begin(); i != Items.end(); ++i)<br>
+ if (i->second == Succ) {<br>
+ if (!i->first.isSingleNumber())<br>
+ return 0;<br>
+ if (Res)<br>
+ return 0;<br>
+ else<br>
+ Res = &(i->first.getLow());<br>
+ }<br>
+ return Res;<br>
+ }<br>
+<br>
/// Returns true if there is no ranges and values inside.<br>
bool empty() const { return Items.empty(); }<br>
<br>
<br>
Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp?rev=159527&r1=159526&r2=159527&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp?rev=159527&r1=159526&r2=159527&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp (original)<br>
+++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp Mon Jul 2 08:02:18 2012<br>
@@ -2450,22 +2450,23 @@<br>
size_t numCmps = 0;<br>
for (Clusterifier::RangeIterator i = TheClusterifier.begin(),<br>
e = TheClusterifier.end(); i != e; ++i, ++numCmps) {<br>
- Clusterifier::Cluster &C = *i;<br>
+ const Clusterifier::RangeEx &R = i->first;<br>
+ MachineBasicBlock *MBB = i->second;<br>
unsigned W = 0;<br>
if (BPI) {<br>
- W = BPI->getEdgeWeight(SI.getParent(), C.second->getBasicBlock());<br>
+ W = BPI->getEdgeWeight(SI.getParent(), MBB->getBasicBlock());<br>
if (!W)<br>
W = 16;<br>
- W *= C.first.Weight;<br>
- BPI->setEdgeWeight(SI.getParent(), C.second->getBasicBlock(), W);<br>
+ W *= R.Weight;<br>
+ BPI->setEdgeWeight(SI.getParent(), MBB->getBasicBlock(), W);<br>
}<br>
<br>
// FIXME: Currently work with ConstantInt based numbers.<br>
// Changing it to APInt based is a pretty heavy for this commit.<br>
- Cases.push_back(Case(C.first.getLow().toConstantInt(),<br>
- C.first.getHigh().toConstantInt(), C.second, W));<br>
+ Cases.push_back(Case(R.getLow().toConstantInt(),<br>
+ R.getHigh().toConstantInt(), MBB, W));<br>
<br>
- if (C.first.getLow() != C.first.getHigh())<br>
+ if (R.getLow() != R.getHigh())<br>
// A range counts double, since it requires two compares.<br>
++numCmps;<br>
}<br>
<br>
Modified: llvm/trunk/lib/Transforms/Utils/LowerSwitch.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LowerSwitch.cpp?rev=159527&r1=159526&r2=159527&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LowerSwitch.cpp?rev=159527&r1=159526&r2=159527&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/Transforms/Utils/LowerSwitch.cpp (original)<br>
+++ llvm/trunk/lib/Transforms/Utils/LowerSwitch.cpp Mon Jul 2 08:02:18 2012<br>
@@ -238,13 +238,14 @@<br>
size_t numCmps = 0;<br>
for (IntegersSubsetToBB::RangeIterator i = TheClusterifier.begin(),<br>
e = TheClusterifier.end(); i != e; ++i, ++numCmps) {<br>
- IntegersSubsetToBB::Cluster &C = *i;<br>
+ const IntegersSubsetToBB::RangeTy &R = i->first;<br>
+ BasicBlock *S = i->second;<br>
<br>
// FIXME: Currently work with ConstantInt based numbers.<br>
// Changing it to APInt based is a pretty heavy for this commit.<br>
- Cases.push_back(CaseRange(C.first.getLow().toConstantInt(),<br>
- C.first.getHigh().toConstantInt(), C.second));<br>
- if (C.first.isSingleNumber())<br>
+ Cases.push_back(CaseRange(R.getLow().toConstantInt(),<br>
+ R.getHigh().toConstantInt(), S));<br>
+ if (R.isSingleNumber())<br>
// A range counts double, since it requires two compares.<br>
++numCmps;<br>
}<br>
<br>
Modified: llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp?rev=159527&r1=159526&r2=159527&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp?rev=159527&r1=159526&r2=159527&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp (original)<br>
+++ llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp Mon Jul 2 08:02:18 2012<br>
@@ -56,26 +56,12 @@<br>
STATISTIC(NumSpeculations, "Number of speculative executed instructions");<br>
<br>
namespace {<br>
- /// ValueEqualityComparisonCase - Represents a case of a switch.<br>
- struct ValueEqualityComparisonCase {<br>
- ConstantInt *Value;<br>
- BasicBlock *Dest;<br>
-<br>
- ValueEqualityComparisonCase(ConstantInt *Value, BasicBlock *Dest)<br>
- : Value(Value), Dest(Dest) {}<br>
-<br>
- bool operator<(ValueEqualityComparisonCase RHS) const {<br>
- // Comparing pointers is ok as we only rely on the order for uniquing.<br>
- return Value < RHS.Value;<br>
- }<br>
- };<br>
-<br>
class SimplifyCFGOpt {<br>
const TargetData *const TD;<br>
<br>
Value *isValueEqualityComparison(TerminatorInst *TI);<br>
BasicBlock *GetValueEqualityComparisonCases(TerminatorInst *TI,<br>
- std::vector<ValueEqualityComparisonCase> &Cases);<br>
+ IntegersSubsetToBB &Mapping);<br>
bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,<br>
BasicBlock *Pred,<br>
IRBuilder<> &Builder);<br>
@@ -532,72 +518,25 @@<br>
/// decode all of the 'cases' that it represents and return the 'default' block.<br>
BasicBlock *SimplifyCFGOpt::<br>
GetValueEqualityComparisonCases(TerminatorInst *TI,<br>
- std::vector<ValueEqualityComparisonCase><br>
- &Cases) {<br>
+ IntegersSubsetToBB &Mapping) {<br>
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {<br>
- Cases.reserve(SI->getNumCases());<br>
- for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end(); i != e; ++i)<br>
- Cases.push_back(ValueEqualityComparisonCase(i.getCaseValue(),<br>
- i.getCaseSuccessor()));<br>
+ for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end();<br>
+ i != e; ++i)<br>
+ Mapping.add(i.getCaseValueEx(), i.getCaseSuccessor());<br>
return SI->getDefaultDest();<br>
}<br>
-<br>
+<br>
BranchInst *BI = cast<BranchInst>(TI);<br>
ICmpInst *ICI = cast<ICmpInst>(BI->getCondition());<br>
- BasicBlock *Succ = BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_NE);<br>
- Cases.push_back(ValueEqualityComparisonCase(GetConstantInt(ICI->getOperand(1),<br>
- TD),<br>
- Succ));<br>
+ IntegersSubsetToBB Builder;<br>
+<br>
+ Mapping.add(<br>
+ IntItem::fromConstantInt(GetConstantInt(ICI->getOperand(1), TD)),<br>
+ BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_NE));<br>
+<br>
return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ);<br>
}<br>
<br>
-<br>
-/// EliminateBlockCases - Given a vector of bb/value pairs, remove any entries<br>
-/// in the list that match the specified block.<br>
-static void EliminateBlockCases(BasicBlock *BB,<br>
- std::vector<ValueEqualityComparisonCase> &Cases) {<br>
- for (unsigned i = 0, e = Cases.size(); i != e; ++i)<br>
- if (Cases[i].Dest == BB) {<br>
- Cases.erase(Cases.begin()+i);<br>
- --i; --e;<br>
- }<br>
-}<br>
-<br>
-/// ValuesOverlap - Return true if there are any keys in C1 that exist in C2 as<br>
-/// well.<br>
-static bool<br>
-ValuesOverlap(std::vector<ValueEqualityComparisonCase> &C1,<br>
- std::vector<ValueEqualityComparisonCase > &C2) {<br>
- std::vector<ValueEqualityComparisonCase> *V1 = &C1, *V2 = &C2;<br>
-<br>
- // Make V1 be smaller than V2.<br>
- if (V1->size() > V2->size())<br>
- std::swap(V1, V2);<br>
-<br>
- if (V1->size() == 0) return false;<br>
- if (V1->size() == 1) {<br>
- // Just scan V2.<br>
- ConstantInt *TheVal = (*V1)[0].Value;<br>
- for (unsigned i = 0, e = V2->size(); i != e; ++i)<br>
- if (TheVal == (*V2)[i].Value)<br>
- return true;<br>
- }<br>
-<br>
- // Otherwise, just sort both lists and compare element by element.<br>
- array_pod_sort(V1->begin(), V1->end());<br>
- array_pod_sort(V2->begin(), V2->end());<br>
- unsigned i1 = 0, i2 = 0, e1 = V1->size(), e2 = V2->size();<br>
- while (i1 != e1 && i2 != e2) {<br>
- if ((*V1)[i1].Value == (*V2)[i2].Value)<br>
- return true;<br>
- if ((*V1)[i1].Value < (*V2)[i2].Value)<br>
- ++i1;<br>
- else<br>
- ++i2;<br>
- }<br>
- return false;<br>
-}<br>
-<br>
/// SimplifyEqualityComparisonWithOnlyPredecessor - If TI is known to be a<br>
/// terminator instruction and its block is known to only have a single<br>
/// predecessor block, check to see if that predecessor is also a value<br>
@@ -616,23 +555,27 @@<br>
if (ThisVal != PredVal) return false; // Different predicates.<br>
<br>
// Find out information about when control will move from Pred to TI's block.<br>
- std::vector<ValueEqualityComparisonCase> PredCases;<br>
+ IntegersSubsetToBB PredCases;<br>
BasicBlock *PredDef = GetValueEqualityComparisonCases(Pred->getTerminator(),<br>
PredCases);<br>
- EliminateBlockCases(PredDef, PredCases); // Remove default from cases.<br>
<br>
+ // Remove default from cases.<br>
+ PredCases.removeCase(PredDef);<br>
+<br>
// Find information about how control leaves this block.<br>
- std::vector<ValueEqualityComparisonCase> ThisCases;<br>
+ IntegersSubsetToBB ThisCases;<br>
BasicBlock *ThisDef = GetValueEqualityComparisonCases(TI, ThisCases);<br>
- EliminateBlockCases(ThisDef, ThisCases); // Remove default from cases.<br>
<br>
+ // Remove default from cases.<br>
+ ThisCases.removeCase(ThisDef);<br>
+<br>
// If TI's block is the default block from Pred's comparison, potentially<br>
// simplify TI based on this knowledge.<br>
if (PredDef == TI->getParent()) {<br>
// If we are here, we know that the value is none of those cases listed in<br>
// PredCases. If there are any cases in ThisCases that are in PredCases, we<br>
// can simplify TI.<br>
- if (!ValuesOverlap(PredCases, ThisCases))<br>
+ if (!PredCases.isOverlapped(ThisCases))<br>
return false;<br>
<br>
if (isa<BranchInst>(TI)) {<br>
@@ -644,7 +587,7 @@<br>
(void) NI;<br>
<br>
// Remove PHI node entries for the dead edge.<br>
- ThisCases[0].Dest->removePredecessor(TI->getParent());<br>
+ ThisCases.begin()->second->removePredecessor(TI->getParent());<br>
<br>
DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()<br>
<< "Through successor TI: " << *TI << "Leaving: " << *NI << "\n");<br>
@@ -655,45 +598,45 @@<br>
<br>
SwitchInst *SI = cast<SwitchInst>(TI);<br>
// Okay, TI has cases that are statically dead, prune them away.<br>
- SmallPtrSet<Constant*, 16> DeadCases;<br>
- for (unsigned i = 0, e = PredCases.size(); i != e; ++i)<br>
- DeadCases.insert(PredCases[i].Value);<br>
+ IRBuilder<> CodeBuilder(SI);<br>
+ CodeBuilder.SetCurrentDebugLocation(SI->getDebugLoc());<br>
<br>
DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()<br>
<< "Through successor TI: " << *TI);<br>
<br>
- for (SwitchInst::CaseIt i = SI->case_end(), e = SI->case_begin(); i != e;) {<br>
- --i;<br>
- if (DeadCases.count(i.getCaseValue())) {<br>
- i.getCaseSuccessor()->removePredecessor(TI->getParent());<br>
- SI->removeCase(i);<br>
- }<br>
- }<br>
-<br>
- DEBUG(dbgs() << "Leaving: " << *TI << "\n");<br>
+ // Okay, TI has cases that are statically dead, prune them away.<br>
+ IntegersSubsetToBB NewThisCases;<br>
+ IntegersSubsetToBB WastedCases;<br>
+ ThisCases.diff(&NewThisCases, &WastedCases, 0, PredCases);<br>
+<br>
+ IntegersSubsetToBB::Cases Cases;<br>
+ NewThisCases.getCases(Cases, true/*temporary prevent complex cases*/);<br>
+<br>
+ SwitchInst *NewSI =<br>
+ CodeBuilder.CreateSwitch(ThisVal, SI->getDefaultDest(), Cases.size());<br>
+<br>
+ for (IntegersSubsetToBB::RangeIterator i = WastedCases.begin(),<br>
+ e = WastedCases.end(); i != e; ++i)<br>
+ i->second->removePredecessor(TI->getParent());<br>
+<br>
+ for (IntegersSubsetToBB::CasesIt i = Cases.begin(), e = Cases.end();<br>
+ i != e; ++i)<br>
+ NewSI->addCase(i->second, i->first);<br>
+<br>
+ EraseTerminatorInstAndDCECond(SI);<br>
+ DEBUG(dbgs() << "Leaving: " << *NewSI << "\n");<br>
return true;<br>
}<br>
<br>
// Otherwise, TI's block must correspond to some matched value. Find out<br>
// which value (or set of values) this is.<br>
- ConstantInt *TIV = 0;<br>
BasicBlock *TIBB = TI->getParent();<br>
- for (unsigned i = 0, e = PredCases.size(); i != e; ++i)<br>
- if (PredCases[i].Dest == TIBB) {<br>
- if (TIV != 0)<br>
- return false; // Cannot handle multiple values coming to this block.<br>
- TIV = PredCases[i].Value;<br>
- }<br>
- assert(TIV && "No edge from pred to succ?");<br>
+ const IntItem* TIVIntITem = PredCases.getCaseSingleNumber(TIBB);<br>
+ assert(TIVIntITem && "No edge from pred to succ?");<br>
<br>
// Okay, we found the one constant that our value can be if we get into TI's<br>
// BB. Find out which successor will unconditionally be branched to.<br>
- BasicBlock *TheRealDest = 0;<br>
- for (unsigned i = 0, e = ThisCases.size(); i != e; ++i)<br>
- if (ThisCases[i].Value == TIV) {<br>
- TheRealDest = ThisCases[i].Dest;<br>
- break;<br>
- }<br>
+ BasicBlock *TheRealDest = ThisCases.findSuccessor(*TIVIntITem);<br>
<br>
// If not handled by any explicit cases, it is handled by the default case.<br>
if (TheRealDest == 0) TheRealDest = ThisDef;<br>
@@ -759,10 +702,10 @@<br>
<br>
if (PCV == CV && SafeToMergeTerminators(TI, PTI)) {<br>
// Figure out which 'cases' to copy from SI to PSI.<br>
- std::vector<ValueEqualityComparisonCase> BBCases;<br>
+ IntegersSubsetToBB BBCases;<br>
BasicBlock *BBDefault = GetValueEqualityComparisonCases(TI, BBCases);<br>
<br>
- std::vector<ValueEqualityComparisonCase> PredCases;<br>
+ IntegersSubsetToBB PredCases;<br>
BasicBlock *PredDefault = GetValueEqualityComparisonCases(PTI, PredCases);<br>
<br>
// Based on whether the default edge from PTI goes to BB or not, fill in<br>
@@ -773,61 +716,51 @@<br>
if (PredDefault == BB) {<br>
// If this is the default destination from PTI, only the edges in TI<br>
// that don't occur in PTI, or that branch to BB will be activated.<br>
- std::set<ConstantInt*, ConstantIntOrdering> PTIHandled;<br>
- for (unsigned i = 0, e = PredCases.size(); i != e; ++i)<br>
- if (PredCases[i].Dest != BB)<br>
- PTIHandled.insert(PredCases[i].Value);<br>
- else {<br>
- // The default destination is BB, we don't need explicit targets.<br>
- std::swap(PredCases[i], PredCases.back());<br>
- PredCases.pop_back();<br>
- --i; --e;<br>
- }<br>
+<br>
+ PredCases.removeCase(BB);<br>
+ IntegersSubsetToBB NewBBCases;<br>
+ BBCases.diff(&NewBBCases, 0, 0, PredCases);<br>
+ PredCases.add(NewBBCases);<br>
+ for (IntegersSubsetToBB::RangeIterator i = NewBBCases.begin(),<br>
+ e = NewBBCases.end(); i != e; ++i)<br>
+ NewSuccessors.push_back(i->second);<br>
<br>
- // Reconstruct the new switch statement we will be building.<br>
+ // Replace the default if needed.<br>
if (PredDefault != BBDefault) {<br>
PredDefault->removePredecessor(Pred);<br>
PredDefault = BBDefault;<br>
NewSuccessors.push_back(BBDefault);<br>
}<br>
- for (unsigned i = 0, e = BBCases.size(); i != e; ++i)<br>
- if (!PTIHandled.count(BBCases[i].Value) &&<br>
- BBCases[i].Dest != BBDefault) {<br>
- PredCases.push_back(BBCases[i]);<br>
- NewSuccessors.push_back(BBCases[i].Dest);<br>
- }<br>
<br>
} else {<br>
// If this is not the default destination from PSI, only the edges<br>
// in SI that occur in PSI with a destination of BB will be<br>
// activated.<br>
- std::set<ConstantInt*, ConstantIntOrdering> PTIHandled;<br>
- for (unsigned i = 0, e = PredCases.size(); i != e; ++i)<br>
- if (PredCases[i].Dest == BB) {<br>
- PTIHandled.insert(PredCases[i].Value);<br>
- std::swap(PredCases[i], PredCases.back());<br>
- PredCases.pop_back();<br>
- --i; --e;<br>
- }<br>
+ IntegersSubsetToBB BBPredCase;<br>
+ PredCases.detachCase(BBPredCase, BB);<br>
+ IntegersSubsetToBB CasesWithBBDef;<br>
+ IntegersSubsetToBB InharitedCases;<br>
<br>
// Okay, now we know which constants were sent to BB from the<br>
// predecessor. Figure out where they will all go now.<br>
- for (unsigned i = 0, e = BBCases.size(); i != e; ++i)<br>
- if (PTIHandled.count(BBCases[i].Value)) {<br>
- // If this is one we are capable of getting...<br>
- PredCases.push_back(BBCases[i]);<br>
- NewSuccessors.push_back(BBCases[i].Dest);<br>
- PTIHandled.erase(BBCases[i].Value);// This constant is taken care of<br>
- }<br>
-<br>
+ if (!BBPredCase.empty()) {<br>
+ BBCases.diff(<br>
+ 0, // LHS excl RHS<br>
+ &InharitedCases, // intersection<br>
+ &CasesWithBBDef, // RHS excl LHS<br>
+ BBPredCase); // RHS.<br>
+ }<br>
+ PredCases.add(InharitedCases);<br>
+ for (IntegersSubsetToBB::RangeIterator i = InharitedCases.begin(),<br>
+ e = InharitedCases.end();<br>
+ i != e; ++i)<br>
+ NewSuccessors.push_back(i->second);<br>
+<br>
// If there are any constants vectored to BB that TI doesn't handle,<br>
// they must go to the default destination of TI.<br>
- for (std::set<ConstantInt*, ConstantIntOrdering>::iterator I =<br>
- PTIHandled.begin(),<br>
- E = PTIHandled.end(); I != E; ++I) {<br>
- PredCases.push_back(ValueEqualityComparisonCase(*I, BBDefault));<br>
+ PredCases.add(CasesWithBBDef, BBDefault);<br>
+ for (unsigned i = 0, e = CasesWithBBDef.size(); i != e; ++i)<br>
NewSuccessors.push_back(BBDefault);<br>
- }<br>
}<br>
<br>
// Okay, at this point, we know which new successor Pred will get. Make<br>
@@ -848,8 +781,12 @@<br>
SwitchInst *NewSI = Builder.CreateSwitch(CV, PredDefault,<br>
PredCases.size());<br>
NewSI->setDebugLoc(PTI->getDebugLoc());<br>
- for (unsigned i = 0, e = PredCases.size(); i != e; ++i)<br>
- NewSI->addCase(PredCases[i].Value, PredCases[i].Dest);<br>
+ IntegersSubsetToBB::Cases Cases;<br>
+ PredCases.getCases(Cases, true/*temporary prevent complex case*/);<br>
+<br>
+ for (IntegersSubsetToBB::CasesIt i = Cases.begin(), e = Cases.end();<br>
+ i != e; ++i)<br>
+ NewSI->addCase(i->second, i->first);<br>
<br>
EraseTerminatorInstAndDCECond(PTI);<br>
<br>
<br>
Modified: llvm/trunk/test/Transforms/SimplifyCFG/switch_create.ll<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/SimplifyCFG/switch_create.ll?rev=159527&r1=159526&r2=159527&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/SimplifyCFG/switch_create.ll?rev=159527&r1=159526&r2=159527&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/test/Transforms/SimplifyCFG/switch_create.ll (original)<br>
+++ llvm/trunk/test/Transforms/SimplifyCFG/switch_create.ll Mon Jul 2 08:02:18 2012<br>
@@ -82,8 +82,8 @@<br>
<br>
; CHECK: @test4<br>
; CHECK: switch i8 %c, label %lor.rhs [<br>
-; CHECK: i8 62, label %lor.end<br>
; CHECK: i8 34, label %lor.end<br>
+; CHECK: i8 62, label %lor.end<br>
; CHECK: i8 92, label %lor.end<br>
; CHECK: ]<br>
}<br>
<br>
Modified: llvm/trunk/unittests/Support/IntegersSubsetTest.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Support/IntegersSubsetTest.cpp?rev=159527&r1=159526&r2=159527&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Support/IntegersSubsetTest.cpp?rev=159527&r1=159526&r2=159527&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/unittests/Support/IntegersSubsetTest.cpp (original)<br>
+++ llvm/trunk/unittests/Support/IntegersSubsetTest.cpp Mon Jul 2 08:02:18 2012<br>
@@ -193,20 +193,20 @@<br>
const unsigned_ranges IntersectRes,<br>
unsigned IntersectResSize<br>
) {<br>
-<br>
+ unsigned successors[2] = {0, 1};<br>
Mapping::RangesCollection Ranges;<br>
<br>
Mapping LHSMapping;<br>
for (unsigned i = 0; i < LSize; ++i)<br>
Ranges.push_back(Range(Int(LHS[i][0]), Int(LHS[i][1])));<br>
- LHSMapping.add(Ranges);<br>
+ LHSMapping.add(Ranges, &successors[0]);<br>
<br>
Ranges.clear();<br>
<br>
Mapping RHSMapping;<br>
for (unsigned i = 0; i < RSize; ++i)<br>
Ranges.push_back(Range(Int(RHS[i][0]), Int(RHS[i][1])));<br>
- RHSMapping.add(Ranges);<br>
+ RHSMapping.add(Ranges, &successors[1]);<br>
<br>
Mapping LExclude, Intersection;<br>
<br>
@@ -217,8 +217,10 @@<br>
<br>
unsigned i = 0;<br>
for (Mapping::RangeIterator rei = LExclude.begin(),<br>
- e = LExclude.end(); rei != e; ++rei, ++i)<br>
+ e = LExclude.end(); rei != e; ++rei, ++i) {<br>
EXPECT_EQ(rei->first, Range(ExcludeRes[i][0], ExcludeRes[i][1]));<br>
+ EXPECT_EQ(rei->second, &successors[0]);<br>
+ }<br>
} else<br>
EXPECT_TRUE(LExclude.empty());<br>
<br>
@@ -227,8 +229,10 @@<br>
<br>
unsigned i = 0;<br>
for (Mapping::RangeIterator ii = Intersection.begin(),<br>
- e = Intersection.end(); ii != e; ++ii, ++i)<br>
+ e = Intersection.end(); ii != e; ++ii, ++i) {<br>
EXPECT_EQ(ii->first, Range(IntersectRes[i][0], IntersectRes[i][1]));<br>
+ EXPECT_EQ(ii->second, &successors[0]);<br>
+ }<br>
} else<br>
EXPECT_TRUE(Intersection.empty());<br>
<br>
@@ -241,9 +245,11 @@<br>
EXPECT_EQ(LExclude.size(), ExcludeResSize);<br>
<br>
unsigned i = 0;<br>
- for (Mapping::RangeIterator rei = LExclude.begin(),<br>
- e = LExclude.end(); rei != e; ++rei, ++i)<br>
- EXPECT_EQ(rei->first, Range(ExcludeRes[i][0], ExcludeRes[i][1]));<br>
+ for (Mapping::RangeIterator lei = LExclude.begin(),<br>
+ e = LExclude.end(); lei != e; ++lei, ++i) {<br>
+ EXPECT_EQ(lei->first, Range(ExcludeRes[i][0], ExcludeRes[i][1]));<br>
+ EXPECT_EQ(lei->second, &successors[0]);<br>
+ }<br>
} else<br>
EXPECT_TRUE(LExclude.empty());<br>
}<br>
<br>
<br>
_______________________________________________<br>
llvm-commits mailing list<br>
<a href="mailto:llvm-commits@cs.uiuc.edu" target="_blank">llvm-commits@cs.uiuc.edu</a><br>
<a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits" target="_blank">http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits</a><br>
</blockquote></div><br></div>
</blockquote></div><br></div>