From 28a8dbc35fe6da6b7d2633529b73453aca254207 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 20 May 2008 03:39:39 +0000
Subject: [PATCH] Add a bool to isEdgeFeasible that tells it whether to treat
 unknown value as undef or untracked.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51295 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Analysis/SparsePropagation.h | 11 +++++++---
 lib/Analysis/SparsePropagation.cpp        | 26 +++++++++++++++++------
 2 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/include/llvm/Analysis/SparsePropagation.h b/include/llvm/Analysis/SparsePropagation.h
index dea81b1e887..c4722138728 100644
--- a/include/llvm/Analysis/SparsePropagation.h
+++ b/include/llvm/Analysis/SparsePropagation.h
@@ -147,8 +147,12 @@ public:
   LatticeVal getOrInitValueState(Value *V);
   
   /// isEdgeFeasible - Return true if the control flow edge from the 'From'
-  /// basic block to the 'To' basic block is currently feasible...
-  bool isEdgeFeasible(BasicBlock *From, BasicBlock *To);
+  /// basic block to the 'To' basic block is currently feasible.  If
+  /// AggressiveUndef is true, then this treats values with unknown lattice
+  /// values as undefined.  This is generally only useful when solving the
+  /// lattice, not when querying it.
+  bool isEdgeFeasible(BasicBlock *From, BasicBlock *To,
+                      bool AggressiveUndef = false);
   
 private:
   /// UpdateState - When the state for some instruction is potentially updated,
@@ -165,7 +169,8 @@ private:
   
   /// getFeasibleSuccessors - Return a vector of booleans to indicate which
   /// successors are reachable from a given terminator instruction.
-  void getFeasibleSuccessors(TerminatorInst &TI, SmallVectorImpl<bool> &Succs);
+  void getFeasibleSuccessors(TerminatorInst &TI, SmallVectorImpl<bool> &Succs,
+                             bool AggressiveUndef);
   
   void visitInst(Instruction &I);
   void visitPHINode(PHINode &I);
diff --git a/lib/Analysis/SparsePropagation.cpp b/lib/Analysis/SparsePropagation.cpp
index c5d99d49e13..e2c739d5418 100644
--- a/lib/Analysis/SparsePropagation.cpp
+++ b/lib/Analysis/SparsePropagation.cpp
@@ -115,7 +115,8 @@ void SparseSolver::markEdgeExecutable(BasicBlock *Source, BasicBlock *Dest) {
 /// getFeasibleSuccessors - Return a vector of booleans to indicate which
 /// successors are reachable from a given terminator instruction.
 void SparseSolver::getFeasibleSuccessors(TerminatorInst &TI,
-                                         SmallVectorImpl<bool> &Succs) {
+                                         SmallVectorImpl<bool> &Succs,
+                                         bool AggressiveUndef) {
   Succs.resize(TI.getNumSuccessors());
   if (TI.getNumSuccessors() == 0) return;
   
@@ -125,7 +126,12 @@ void SparseSolver::getFeasibleSuccessors(TerminatorInst &TI,
       return;
     }
     
-    LatticeVal BCValue = getOrInitValueState(BI->getCondition());
+    LatticeVal BCValue;
+    if (AggressiveUndef)
+      BCValue = getOrInitValueState(BI->getCondition());
+    else
+      BCValue = getLatticeState(BI->getCondition());
+    
     if (BCValue == LatticeFunc->getOverdefinedVal() ||
         BCValue == LatticeFunc->getUntrackedVal()) {
       // Overdefined condition variables can branch either way.
@@ -157,7 +163,12 @@ void SparseSolver::getFeasibleSuccessors(TerminatorInst &TI,
   }
   
   SwitchInst &SI = cast<SwitchInst>(TI);
-  LatticeVal SCValue = getOrInitValueState(SI.getCondition());
+  LatticeVal SCValue;
+  if (AggressiveUndef)
+    SCValue = getOrInitValueState(SI.getCondition());
+  else
+    SCValue = getLatticeState(SI.getCondition());
+  
   if (SCValue == LatticeFunc->getOverdefinedVal() ||
       SCValue == LatticeFunc->getUntrackedVal()) {
     // All destinations are executable!
@@ -182,10 +193,11 @@ void SparseSolver::getFeasibleSuccessors(TerminatorInst &TI,
 
 /// isEdgeFeasible - Return true if the control flow edge from the 'From'
 /// basic block to the 'To' basic block is currently feasible...
-bool SparseSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) {
+bool SparseSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To,
+                                  bool AggressiveUndef) {
   SmallVector<bool, 16> SuccFeasible;
   TerminatorInst *TI = From->getTerminator();
-  getFeasibleSuccessors(*TI, SuccFeasible);
+  getFeasibleSuccessors(*TI, SuccFeasible, AggressiveUndef);
   
   for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
     if (TI->getSuccessor(i) == To && SuccFeasible[i])
@@ -196,7 +208,7 @@ bool SparseSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) {
 
 void SparseSolver::visitTerminatorInst(TerminatorInst &TI) {
   SmallVector<bool, 16> SuccFeasible;
-  getFeasibleSuccessors(TI, SuccFeasible);
+  getFeasibleSuccessors(TI, SuccFeasible, true);
   
   BasicBlock *BB = TI.getParent();
   
@@ -226,7 +238,7 @@ void SparseSolver::visitPHINode(PHINode &PN) {
   // transfer function to give us the merge of the incoming values.
   for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
     // If the edge is not yet known to be feasible, it doesn't impact the PHI.
-    if (!isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent()))
+    if (!isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent(), true))
       continue;
     
     // Merge in this value.