maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

3 Changes: 

1. Better document what is going on here.
2. Only hack on one branch per iteration, making the results less conservative.
3. Handle the problematic case by marking edges executable instead of by
   playing with value lattice states.  This is far less pessimistic, and fixes
   SCCP/ipsccp-gvar.ll.

llvm-svn: 31106
This commit is contained in:
Chris Lattner 2006-10-22 05:59:17 +00:00
parent 097971202e
commit af17096dcf
1 changed files with 35 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
llvm/lib/Transforms/Scalar/SCCP.cpp
View File

@ -1023,33 +1023,44 @@ void SCCPSolver::Solve() {
/// However, this is not a safe assumption. After we solve dataflow, this /// However, this is not a safe assumption. After we solve dataflow, this
/// method should be use to handle this. If this returns true, the solver /// method should be use to handle this. If this returns true, the solver
/// should be rerun. /// should be rerun.
///
/// This method handles this by finding an unresolved branch and marking it one
/// of the edges from the block as being feasible, even though the condition
/// doesn't say it would otherwise be. This allows SCCP to find the rest of the
/// CFG and only slightly pessimizes the analysis results (by marking one,
/// potentially unfeasible, edge feasible). This cannot usefully modify the
/// constraints on the condition of the branch, as that would impact other users
/// of the value.
bool SCCPSolver::ResolveBranchesIn(Function &F) { bool SCCPSolver::ResolveBranchesIn(Function &F) {
bool BranchesResolved = false; for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) if (!BBExecutable.count(BB))
if (BBExecutable.count(BB)) { continue;
TerminatorInst *TI = BB->getTerminator();
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { TerminatorInst *TI = BB->getTerminator();
if (BI->isConditional()) { if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
LatticeVal &BCValue = getValueState(BI->getCondition()); if (!BI->isConditional()) continue;
if (BCValue.isUndefined()) { if (!getValueState(BI->getCondition()).isUndefined())
BCValue.markOverdefined(); continue;
BranchesResolved = true; } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
visit(BI); if (!getValueState(SI->getCondition()).isUndefined())
} continue;
} } else {
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { continue;
LatticeVal &SCValue = getValueState(SI->getCondition());
if (SCValue.isUndefined()) {
const Type *CondTy = SI->getCondition()->getType();
// Pick and arbitrary direction for the switch to go.
SCValue.markOverdefined();
BranchesResolved = true;
visit(SI);
}
}
} }
// If the edge to the first successor isn't thought to be feasible yet, mark
// it so now.
if (KnownFeasibleEdges.count(Edge(BB, TI->getSuccessor(0))))
continue;
// Otherwise, it isn't already thought to be feasible. Mark it as such now
// and return. This will make other blocks reachable, which will allow new
// values to be discovered and existing ones to be moved in the lattice.
markEdgeExecutable(BB, TI->getSuccessor(0));
return true;
}
return BranchesResolved; return false;
} }