/// though division by zero might cause undefined behavior.
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I);
+ /// Returns true if this block does not contain a potential implicit exit.
+ /// This is equivelent to saying that all instructions within the basic block
+ /// are guaranteed to transfer execution to their successor within the basic
+ /// block. This has the same assumptions w.r.t. undefined behavior as the
+ /// instruction variant of this function.
+ bool isGuaranteedToTransferExecutionToSuccessor(const BasicBlock *BB);
+
/// Return true if this function can prove that the instruction I
/// is executed for every iteration of the loop L.
///
return true;
}
+bool llvm::isGuaranteedToTransferExecutionToSuccessor(const BasicBlock *BB) {
+ // TODO: This is slightly consdervative for invoke instruction since exiting
+ // via an exception *is* normal control for them.
+ for (auto I = BB->begin(), E = BB->end(); I != E; ++I)
+ if (!isGuaranteedToTransferExecutionToSuccessor(&*I))
+ return false;
+ return true;
+}
+
bool llvm::isGuaranteedToExecuteForEveryIteration(const Instruction *I,
const Loop *L) {
// The loop header is guaranteed to be executed for every iteration.
// Invalidate LVI information for BB if the LVI is not provably true for
// all of BB.
- if (any_of(*BB, [](Instruction &I) {
- return !isGuaranteedToTransferExecutionToSuccessor(&I);
- }))
+ if (!isGuaranteedToTransferExecutionToSuccessor(BB))
LVI->eraseBlock(BB);
return true;
}
SafetyInfo->MayThrow = false;
SafetyInfo->HeaderMayThrow = false;
// Iterate over header and compute safety info.
- for (BasicBlock::iterator I = Header->begin(), E = Header->end();
- (I != E) && !SafetyInfo->HeaderMayThrow; ++I)
- SafetyInfo->HeaderMayThrow |=
- !isGuaranteedToTransferExecutionToSuccessor(&*I);
+ SafetyInfo->HeaderMayThrow =
+ !isGuaranteedToTransferExecutionToSuccessor(Header);
SafetyInfo->MayThrow = SafetyInfo->HeaderMayThrow;
// Iterate over loop instructions and compute safety info.
for (Loop::block_iterator BB = std::next(CurLoop->block_begin()),
BBE = CurLoop->block_end();
(BB != BBE) && !SafetyInfo->MayThrow; ++BB)
- for (BasicBlock::iterator I = (*BB)->begin(), E = (*BB)->end();
- (I != E) && !SafetyInfo->MayThrow; ++I)
- SafetyInfo->MayThrow |= !isGuaranteedToTransferExecutionToSuccessor(&*I);
+ SafetyInfo->MayThrow |=
+ !isGuaranteedToTransferExecutionToSuccessor(*BB);
// Compute funclet colors if we might sink/hoist in a function with a funclet
// personality routine.