[NFC] Remove function isGuaranteedToExecute

[mkazantsev]

Summary

It is now obsolete because the method mustExecuteInLoop does exactly the same thing in a cleaner OOP style.

[fedor.sergeev]

LGTM

[reames]

Hold this one please. I have some concerns about the naming, but have lost track of the dependent patches and can't fully review. Once dependent changes have landed, let's revisit.

[mkazantsev]

Abandoned per https://reviews.llvm.org/rL344587.

include/llvm/Analysis/MustExecute.h

 
 class Instruction;
 class DominatorTree;
 class Loop;
 
 /// Captures loop safety information.
 /// It keep information for loop blocks may throw exception or otherwise
 /// exit abnormaly on any iteration of the loop which might actually execute
-/// 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.
+/// at runtime.
 /// 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.
public:
   /// 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(DominatorTree *DT): ICF(DT) {}
 };
-
-/// Returns true if the instruction in a loop is guaranteed to execute at least
-/// once (under the assumption that the loop is entered).
-/// TODO: Remove the function, call SafetyInfi->mustExecuteInLoop instead.
-bool isGuaranteedToExecute(const Instruction &Inst, const DominatorTree *DT,
-                           const Loop *CurLoop,
-                           const LoopSafetyInfo *SafetyInfo);
-
 }
 
 #endif

lib/Analysis/MustExecute.cpp

bool LoopSafetyInfo::mustExecuteInLoop(const Loop *CurLoop,
   return !ICF.isDominatedByICFIFromSameBlock(I) &&
          allLoopPathsLeadToBlock(CurLoop, I->getParent(), DT);
 }
 
 void LoopSafetyInfo::dropCachedInfo(const BasicBlock *BB) {
   ICF.invalidateBlock(BB);
 }
 
-/// Returns true if the instruction in a loop is guaranteed to execute at least
-/// once.
-bool llvm::isGuaranteedToExecute(const Instruction &Inst,
-                                 const DominatorTree *DT, const Loop *CurLoop,
-                                 const LoopSafetyInfo *SafetyInfo) {
-  return SafetyInfo->mustExecuteInLoop(CurLoop, &Inst, DT);
-}
-
-
 namespace {
   struct MustExecutePrinter : public FunctionPass {
 
     static char ID; // Pass identification, replacement for typeid
     MustExecutePrinter() : FunctionPass(ID) {
       initializeMustExecutePrinterPass(*PassRegistry::getPassRegistry());
     }
     void getAnalysisUsage(AnalysisUsage &AU) const override {

 }
 
 static bool isMustExecuteIn(const Instruction &I, Loop *L, DominatorTree *DT) {
   // TODO: merge these two routines.  For the moment, we display the best
   // result obtained by *either* implementation.  This is a bit unfair since no
   // caller actually gets the full power at the moment.
   LoopSafetyInfo LSI(DT);
   LSI.computeLoopSafetyInfo(L);
-  return isGuaranteedToExecute(I, DT, L, &LSI) ||
+  return LSI.mustExecuteInLoop(L, &I, DT) ||
     isGuaranteedToExecuteForEveryIteration(&I, L);
 }
 
 namespace {
 /// An assembly annotator class to print must execute information in
 /// comments.
 class MustExecuteAnnotatedWriter : public AssemblyAnnotationWriter {
   DenseMap<const Value*, SmallVector<Loop*, 4> > MustExec;

lib/Transforms/Scalar/LICM.cpp

static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
   });
 
   // Metadata can be dependent on conditions we are hoisting above.
   // Conservatively strip all metadata on the instruction unless we were
   // guaranteed to execute I if we entered the loop, in which case the metadata
   // is valid in the loop preheader.
   if (I.hasMetadataOtherThanDebugLoc() &&
       // The check on hasMetadataOtherThanDebugLoc is to prevent us from burning
-      // time in isGuaranteedToExecute if we don't actually have anything to
+      // time in mustExecuteInLoop if we don't actually have anything to
       // drop.  It is a compile time optimization, not required for correctness.
-      !isGuaranteedToExecute(I, DT, CurLoop, SafetyInfo))
+      !SafetyInfo->mustExecuteInLoop(CurLoop, &I, DT))
     I.dropUnknownNonDebugMetadata();
 
   // Contents of a block has changed, we need to mark it in safety info.
   SafetyInfo->dropCachedInfo(I.getParent());
   // Move the new node to the Preheader, before its terminator.
   I.moveBefore(Preheader->getTerminator());
 
   // Do not retain debug locations when we are moving instructions to different
static bool isSafeToExecuteUnconditionally(Instruction &Inst,
                                            const DominatorTree *DT,
                                            const Loop *CurLoop,
                                            const LoopSafetyInfo *SafetyInfo,
                                            OptimizationRemarkEmitter *ORE,
                                            const Instruction *CtxI) {
   if (isSafeToSpeculativelyExecute(&Inst, CtxI, DT))
     return true;
 
-  bool GuaranteedToExecute =
-      isGuaranteedToExecute(Inst, DT, CurLoop, SafetyInfo);
+  bool GuaranteedToExecute = SafetyInfo->mustExecuteInLoop(CurLoop, &Inst, DT);
 
   if (!GuaranteedToExecute) {
     auto *LI = dyn_cast<LoadInst>(&Inst);
     if (LI && CurLoop->isLoopInvariant(LI->getPointerOperand()))
       ORE->emit([&]() {
         return OptimizationRemarkMissed(
                    DEBUG_TYPE, "LoadWithLoopInvariantAddressCondExecuted", LI)
                << "failed to hoist load with loop-invariant address "
for (User *U : ASIV->users()) {
         // raise the alignment on the promoted store.
         unsigned InstAlignment = Store->getAlignment();
         if (!InstAlignment)
           InstAlignment =
               MDL.getABITypeAlignment(Store->getValueOperand()->getType());
 
         if (!DereferenceableInPH || !SafeToInsertStore ||
             (InstAlignment > Alignment)) {
-          if (isGuaranteedToExecute(*UI, DT, CurLoop, SafetyInfo)) {
+          if (SafetyInfo->mustExecuteInLoop(CurLoop, UI, DT)) {
             DereferenceableInPH = true;
             SafeToInsertStore = true;
             Alignment = std::max(Alignment, InstAlignment);
           }
         }
 
         // If a store dominates all exit blocks, it is safe to sink.
         // As explained above, if an exit block was executed, a dominating

lib/Transforms/Scalar/LoopUnswitch.cpp

for (Loop::block_iterator I = currentLoop->block_begin(),
     TerminatorInst *TI = (*I)->getTerminator();
 
     // Unswitching on a potentially uninitialized predicate is not
     // MSan-friendly. Limit this to the cases when the original predicate is
     // guaranteed to execute, to avoid creating a use-of-uninitialized-value
     // in the code that did not have one.
     // This is a workaround for the discrepancy between LLVM IR and MSan
     // semantics. See PR28054 for more details.
-    if (SanitizeMemory &&
-        !isGuaranteedToExecute(*TI, DT, currentLoop, SafetyInfo))
+    if (SanitizeMemory && !SafetyInfo->mustExecuteInLoop(currentLoop, TI, DT))
       continue;
 
     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
       // Some branches may be rendered unreachable because of previous
       // unswitching.
       // Unswitch only those branches that are reachable.
       if (isUnreachableDueToPreviousUnswitching(*I))
         continue;