/// on branchy code but not loops, and LI is most useful on code with loops but
/// does not help on branchy code outside loops.
bool isPotentiallyReachable(const Instruction *From, const Instruction *To,
- DominatorTree *DT = 0, LoopInfo *LI = 0);
+ const DominatorTree *DT = 0,
+ const LoopInfo *LI = 0);
/// \brief Determine whether block 'To' is reachable from 'From', returning
/// true if uncertain.
/// Returns false only if we can prove that once 'From' has been reached then
/// 'To' can not be executed. Conservatively returns true.
bool isPotentiallyReachable(const BasicBlock *From, const BasicBlock *To,
- DominatorTree *DT = 0, LoopInfo *LI = 0);
+ const DominatorTree *DT = 0,
+ const LoopInfo *LI = 0);
} // End llvm namespace
// LoopInfo contains a mapping from basic block to the innermost loop. Find
// the outermost loop in the loop nest that contains BB.
-static const Loop *getOutermostLoop(LoopInfo *LI, const BasicBlock *BB) {
+static const Loop *getOutermostLoop(const LoopInfo *LI, const BasicBlock *BB) {
const Loop *L = LI->getLoopFor(BB);
if (L) {
while (const Loop *Parent = L->getParentLoop())
}
// True if there is a loop which contains both BB1 and BB2.
-static bool loopContainsBoth(LoopInfo *LI,
+static bool loopContainsBoth(const LoopInfo *LI,
const BasicBlock *BB1, const BasicBlock *BB2) {
const Loop *L1 = getOutermostLoop(LI, BB1);
const Loop *L2 = getOutermostLoop(LI, BB2);
static bool isPotentiallyReachableInner(SmallVectorImpl<BasicBlock *> &Worklist,
BasicBlock *StopBB,
- DominatorTree *DT, LoopInfo *LI) {
+ const DominatorTree *DT,
+ const LoopInfo *LI) {
// When the stop block is unreachable, it's dominated from everywhere,
// regardless of whether there's a path between the two blocks.
if (DT && !DT->isReachableFromEntry(StopBB))
}
bool llvm::isPotentiallyReachable(const BasicBlock *A, const BasicBlock *B,
- DominatorTree *DT, LoopInfo *LI) {
+ const DominatorTree *DT, const LoopInfo *LI) {
assert(A->getParent() == B->getParent() &&
"This analysis is function-local!");
}
bool llvm::isPotentiallyReachable(const Instruction *A, const Instruction *B,
- DominatorTree *DT, LoopInfo *LI) {
+ const DominatorTree *DT, const LoopInfo *LI) {
assert(A->getParent()->getParent() == B->getParent()->getParent() &&
"This analysis is function-local!");