Index: llvm/trunk/include/llvm/Analysis/MustExecute.h =================================================================== --- llvm/trunk/include/llvm/Analysis/MustExecute.h +++ llvm/trunk/include/llvm/Analysis/MustExecute.h @@ -36,23 +36,42 @@ /// at runtime. The primary way to consume this infromation is via /// isGuaranteedToExecute below, but some callers bailout or fallback to /// alternate reasoning if a loop contains any implicit control flow. -struct LoopSafetyInfo { +/// NOTE: LoopSafetyInfo contains cached information regarding loops and their +/// particular blocks. This information is only dropped on invocation of +/// computeLoopSafetyInfo. If the loop or any of its block is deleted, or if +/// any thrower instructions have been added or removed from them, or if the +/// control flow has changed, or in case of other meaningful modifications, the +/// LoopSafetyInfo needs to be recomputed. If a meaningful modifications to the +/// loop were made and the info wasn't recomputed properly, the behavior of all +/// methods except for computeLoopSafetyInfo is undefined. +class LoopSafetyInfo { bool MayThrow = false; // The current loop contains an instruction which // may throw. bool HeaderMayThrow = false; // Same as previous, but specific to loop header + +public: // Used to update funclet bundle operands. DenseMap BlockColors; + /// Returns true iff the header block of the loop for which this info is + /// calculated contains an instruction that may throw or otherwise exit + /// abnormally. + bool headerMayThrow() const; + + /// Returns true iff any block of the loop for which this info is contains an + /// instruction that may throw or otherwise exit abnormally. + bool anyBlockMayThrow() const; + + /// Computes safety information for a loop checks loop body & header for + /// the possibility of may throw exception, it takes LoopSafetyInfo and loop + /// as argument. Updates safety information in LoopSafetyInfo argument. + /// Note: This is defined to clear and reinitialize an already initialized + /// LoopSafetyInfo. Some callers rely on this fact. + void computeLoopSafetyInfo(Loop *); + LoopSafetyInfo() = default; }; -/// Computes safety information for a loop checks loop body & header for -/// the possibility of may throw exception, it takes LoopSafetyInfo and loop as -/// argument. Updates safety information in LoopSafetyInfo argument. -/// Note: This is defined to clear and reinitialize an already initialized -/// LoopSafetyInfo. Some callers rely on this fact. -void computeLoopSafetyInfo(LoopSafetyInfo *, Loop *); - /// Returns true if the instruction in a loop is guaranteed to execute at least /// once (under the assumption that the loop is entered). bool isGuaranteedToExecute(const Instruction &Inst, const DominatorTree *DT, Index: llvm/trunk/lib/Analysis/MustExecute.cpp =================================================================== --- llvm/trunk/lib/Analysis/MustExecute.cpp +++ llvm/trunk/lib/Analysis/MustExecute.cpp @@ -22,20 +22,20 @@ #include "llvm/Support/raw_ostream.h" using namespace llvm; -/// Computes loop safety information, checks loop body & header -/// for the possibility of may throw exception. -/// -void llvm::computeLoopSafetyInfo(LoopSafetyInfo *SafetyInfo, Loop *CurLoop) { +bool LoopSafetyInfo::headerMayThrow() const { + return HeaderMayThrow; +} + +bool LoopSafetyInfo::anyBlockMayThrow() const { + return MayThrow; +} + +void LoopSafetyInfo::computeLoopSafetyInfo(Loop *CurLoop) { assert(CurLoop != nullptr && "CurLoop can't be null"); BasicBlock *Header = CurLoop->getHeader(); - // Setting default safety values. - SafetyInfo->MayThrow = false; - SafetyInfo->HeaderMayThrow = false; // Iterate over header and compute safety info. - SafetyInfo->HeaderMayThrow = - !isGuaranteedToTransferExecutionToSuccessor(Header); - - SafetyInfo->MayThrow = SafetyInfo->HeaderMayThrow; + HeaderMayThrow = !isGuaranteedToTransferExecutionToSuccessor(Header); + MayThrow = HeaderMayThrow; // Iterate over loop instructions and compute safety info. // Skip header as it has been computed and stored in HeaderMayThrow. // The first block in loopinfo.Blocks is guaranteed to be the header. @@ -43,9 +43,8 @@ "First block must be header"); for (Loop::block_iterator BB = std::next(CurLoop->block_begin()), BBE = CurLoop->block_end(); - (BB != BBE) && !SafetyInfo->MayThrow; ++BB) - SafetyInfo->MayThrow |= - !isGuaranteedToTransferExecutionToSuccessor(*BB); + (BB != BBE) && !MayThrow; ++BB) + MayThrow |= !isGuaranteedToTransferExecutionToSuccessor(*BB); // Compute funclet colors if we might sink/hoist in a function with a funclet // personality routine. @@ -53,7 +52,7 @@ if (Fn->hasPersonalityFn()) if (Constant *PersonalityFn = Fn->getPersonalityFn()) if (isScopedEHPersonality(classifyEHPersonality(PersonalityFn))) - SafetyInfo->BlockColors = colorEHFunclets(*Fn); + BlockColors = colorEHFunclets(*Fn); } /// Return true if we can prove that the given ExitBlock is not reached on the @@ -116,12 +115,12 @@ // Inst unless we can prove that Inst comes before the potential implicit // exit. At the moment, we use a (cheap) hack for the common case where // the instruction of interest is the first one in the block. - return !SafetyInfo->HeaderMayThrow || + return !SafetyInfo->headerMayThrow() || Inst.getParent()->getFirstNonPHIOrDbg() == &Inst; // Somewhere in this loop there is an instruction which may throw and make us // exit the loop. - if (SafetyInfo->MayThrow) + if (SafetyInfo->anyBlockMayThrow()) return false; // Note: There are two styles of reasoning intermixed below for @@ -196,7 +195,7 @@ // result obtained by *either* implementation. This is a bit unfair since no // caller actually gets the full power at the moment. LoopSafetyInfo LSI; - computeLoopSafetyInfo(&LSI, L); + LSI.computeLoopSafetyInfo(L); return isGuaranteedToExecute(I, DT, L, &LSI) || isGuaranteedToExecuteForEveryIteration(&I, L); } Index: llvm/trunk/lib/Transforms/Scalar/LICM.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/LICM.cpp +++ llvm/trunk/lib/Transforms/Scalar/LICM.cpp @@ -261,7 +261,7 @@ // Compute loop safety information. LoopSafetyInfo SafetyInfo; - computeLoopSafetyInfo(&SafetyInfo, L); + SafetyInfo.computeLoopSafetyInfo(L); // We want to visit all of the instructions in this loop... that are not parts // of our subloops (they have already had their invariants hoisted out of @@ -1310,7 +1310,7 @@ const DataLayout &MDL = Preheader->getModule()->getDataLayout(); bool IsKnownThreadLocalObject = false; - if (SafetyInfo->MayThrow) { + if (SafetyInfo->anyBlockMayThrow()) { // If a loop can throw, we have to insert a store along each unwind edge. // That said, we can't actually make the unwind edge explicit. Therefore, // we have to prove that the store is dead along the unwind edge. We do Index: llvm/trunk/lib/Transforms/Scalar/LoopIdiomRecognize.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/LoopIdiomRecognize.cpp +++ llvm/trunk/lib/Transforms/Scalar/LoopIdiomRecognize.cpp @@ -320,8 +320,8 @@ // The following transforms hoist stores/memsets into the loop pre-header. // Give up if the loop has instructions may throw. LoopSafetyInfo SafetyInfo; - computeLoopSafetyInfo(&SafetyInfo, CurLoop); - if (SafetyInfo.MayThrow) + SafetyInfo.computeLoopSafetyInfo(CurLoop); + if (SafetyInfo.anyBlockMayThrow()) return MadeChange; // Scan all the blocks in the loop that are not in subloops. Index: llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp =================================================================== --- llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp +++ llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp @@ -520,7 +520,7 @@ SanitizeMemory = F->hasFnAttribute(Attribute::SanitizeMemory); if (SanitizeMemory) - computeLoopSafetyInfo(&SafetyInfo, L); + SafetyInfo.computeLoopSafetyInfo(L); bool Changed = false; do { Index: llvm/trunk/lib/Transforms/Utils/LoopUnrollAndJam.cpp =================================================================== --- llvm/trunk/lib/Transforms/Utils/LoopUnrollAndJam.cpp +++ llvm/trunk/lib/Transforms/Utils/LoopUnrollAndJam.cpp @@ -762,8 +762,8 @@ // Check the loop safety info for exceptions. LoopSafetyInfo LSI; - computeLoopSafetyInfo(&LSI, L); - if (LSI.MayThrow) { + LSI.computeLoopSafetyInfo(L); + if (LSI.anyBlockMayThrow()) { LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; Something may throw\n"); return false; }