+/// AttemptRedundancyElimination - If the "fast path" of redundancy elimination
+/// by inheritance from the dominator fails, see if we can perform phi
+/// construction to eliminate the redundancy.
+Value* GVN::AttemptRedundancyElimination(Instruction* orig, unsigned valno) {
+ BasicBlock* BaseBlock = orig->getParent();
+
+ SmallPtrSet<BasicBlock*, 4> Visited;
+ SmallVector<BasicBlock*, 8> Stack;
+ Stack.push_back(BaseBlock);
+
+ DenseMap<BasicBlock*, Value*> Results;
+
+ // Walk backwards through our predecessors, looking for instances of the
+ // value number we're looking for. Instances are recorded in the Results
+ // map, which is then used to perform phi construction.
+ while (!Stack.empty()) {
+ BasicBlock* Current = Stack.back();
+ Stack.pop_back();
+
+ // If we've walked all the way to a proper dominator, then give up. Cases
+ // where the instance is in the dominator will have been caught by the fast
+ // path, and any cases that require phi construction further than this are
+ // probably not worth it anyways. Note that this is a SIGNIFICANT compile
+ // time improvement.
+ if (DT->properlyDominates(Current, orig->getParent())) return 0;
+
+ DenseMap<BasicBlock*, ValueNumberScope*>::iterator LA =
+ localAvail.find(Current);
+ if (LA == localAvail.end()) return 0;
+ DenseMap<uint32_t, Value*>::iterator V = LA->second->table.find(valno);
+
+ if (V != LA->second->table.end()) {
+ // Found an instance, record it.
+ Results.insert(std::make_pair(Current, V->second));
+ continue;
+ }
+
+ // If we reach the beginning of the function, then give up.
+ if (pred_begin(Current) == pred_end(Current))
+ return 0;
+
+ for (pred_iterator PI = pred_begin(Current), PE = pred_end(Current);
+ PI != PE; ++PI)
+ if (Visited.insert(*PI))
+ Stack.push_back(*PI);
+ }
+
+ // If we didn't find instances, give up. Otherwise, perform phi construction.
+ if (Results.size() == 0)
+ return 0;
+ else
+ return GetValueForBlock(BaseBlock, orig, Results, true);
+}
+