Fix crashes with -fprofile-use + new pass manager in queens.c from the testsuite (bugzilla bug 33776)

[jtony]

Summary

(1) The problem was originally reported on bugzilla, for more context please see: https://bugs.llvm.org/show_bug.cgi?id=33776

(2) Steps to reproduce the bug :
the test case queens.c is under directory: test-suite/SingleSource/Benchmarks/McGill

With the old pass manager, it is OK:
clang -fprofile-use -fsave-optimization-record -foptimization-record-file=pgo.yaml -O2 queens.c

But with the new pass manager, it emits fatal error:

clang -fprofile-use -fsave-optimization-record -foptimization-record-file=pgo.yaml -fexperimental-new-pass-manager -O2 queens.c
fatal error: error in backend: LICM: OptimizationRemarkEmitterAnalysis not cached at a higher level

(3) What have been done in this patch:
The other places which use getCachedResult(), they check the pointer is not NULL. So probably we just need to check the ORE pointer is not NULL as well (the crash happens at line 203 in lib/Transforms/Scalar/LICM.cpp). Especially there is a comment in the source code which says the fatal error emitting when ORE pointer is NULL should probably be optional rather than required.

With the proper checks in this patch, the crash goes away. However, this may not be the eventual solution, if people have other better solutions for this issue, we are very interested to hear them.

[davide]

Thanks for your contribution.
Some notes:

1. Can you please update the patch to include context (see the doc) ?
2. Can you please add a test? I attached one to the PR.
3. Can you please explain the rationale behind this fix? I'm afraid it's just papering over the problem rather than solving it.

[nemanjai]

3. Can you please explain the rationale behind this fix? I'm afraid it's just papering over the problem rather than solving it.

I am not at all sure how this is supposed to work, but it certainly seems messy to always do a NULL check before using ORE. Perhaps someone that really knows how this is supposed to work can comment on why there's a requirement that the ORE object be available in the cache (i.e. why we need to acquire it through getCachedResult() rather than getResult() and add it to the cache if it isn't already cached).

[jtony]

In D38099#876879, @davide wrote:

Thanks for your contribution.
Some notes:

1. Can you please update the patch to include context (see the doc) ?
2. Can you please add a test? I attached one to the PR.
3. Can you please explain the rationale behind this fix? I'm afraid it's just papering over the problem rather than solving it.

lib/Transforms/IPO/SampleProfile.cpp

     bool FirstMark =
         CoverageTracker.markSamplesUsed(FS, LineOffset, Discriminator, R.get());
     if (FirstMark) {
-      if (Discriminator)
-        ORE->emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AppliedSamples", &Inst)
-                  << "Applied " << ore::NV("NumSamples", *R)
-                  << " samples from profile (offset: "
-                  << ore::NV("LineOffset", LineOffset) << "."
-                  << ore::NV("Discriminator", Discriminator) << ")");
-      else
-        ORE->emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AppliedSamples", &Inst)
-                  << "Applied " << ore::NV("NumSamples", *R)
-                  << " samples from profile (offset: "
-                  << ore::NV("LineOffset", LineOffset) << ")");
+      if (Discriminator) {
+        if (ORE)
+          ORE->emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AppliedSamples", &Inst)
+                    << "Applied " << ore::NV("NumSamples", *R)
+                    << " samples from profile (offset: "
+                    << ore::NV("LineOffset", LineOffset) << "."
+                    << ore::NV("Discriminator", Discriminator) << ")");
+      } else {
+        if (ORE)
+          ORE->emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AppliedSamples", &Inst)
+                    << "Applied " << ore::NV("NumSamples", *R)
+                    << " samples from profile (offset: "
+                    << ore::NV("LineOffset", LineOffset) << ")");
+      }
     }
     DEBUG(dbgs() << "    " << DLoc.getLine() << "."
                  << DIL->getBaseDiscriminator() << ":" << Inst

       if (InlineFunction(CallSite(DI), IFI)) {
         LocalChanged = true;
         // The call to InlineFunction erases DI, so we can't pass it here.
-        ORE->emit(OptimizationRemark(DEBUG_TYPE, "HotInline", DLoc, BB)
-                  << "inlined hot callee '"
-                  << ore::NV("Callee", CalledFunction) << "' into '"
-                  << ore::NV("Caller", &F) << "'");
+        if (ORE)
+          ORE->emit(OptimizationRemark(DEBUG_TYPE, "HotInline", DLoc, BB)
+                    << "inlined hot callee '"
+                    << ore::NV("Callee", CalledFunction) << "' into '"
+                    << ore::NV("Caller", &F) << "'");
       }
     }
     if (LocalChanged) {

       DEBUG(dbgs() << "SUCCESS. Found non-zero weights.\n");
       TI->setMetadata(llvm::LLVMContext::MD_prof,
                       MDB.createBranchWeights(Weights));
-      ORE->emit(OptimizationRemark(DEBUG_TYPE, "PopularDest", MaxDestInst)
-                << "most popular destination for conditional branches at "
-                << ore::NV("CondBranchesLoc", BranchLoc));
+      if (ORE)
+        ORE->emit(OptimizationRemark(DEBUG_TYPE, "PopularDest", MaxDestInst)
+                  << "most popular destination for conditional branches at "
+                  << ore::NV("CondBranchesLoc", BranchLoc));
     } else {
       DEBUG(dbgs() << "SKIPPED. All branch weights are zero.\n");
     }

lib/Transforms/IPO/WholeProgramDevirt.cpp

     }
 
     using namespace ore;
-    ORE->emit(OptimizationRemark(DEBUG_TYPE, OptName, DLoc, Block)
-              << NV("Optimization", OptName) << ": devirtualized a call to "
-              << NV("FunctionName", TargetName));
+    if (ORE)
+      ORE->emit(OptimizationRemark(DEBUG_TYPE, OptName, DLoc, Block)
+                << NV("Optimization", OptName) << ": devirtualized a call to "
+                << NV("FunctionName", TargetName));
   }
 
   void replaceAndErase(

       }
 
       using namespace ore;
-      ORE->emit(OptimizationRemark(DEBUG_TYPE, "Devirtualized", F)
-                << "devirtualized " << NV("FunctionName", F->getName()));
+      if (ORE)
+        ORE->emit(OptimizationRemark(DEBUG_TYPE, "Devirtualized", F)
+                  << "devirtualized " << NV("FunctionName", F->getName()));
     }
   }
 

lib/Transforms/Scalar/GVN.cpp

 
   R << " because it is clobbered by " << NV("ClobberedBy", DepInfo.getInst());
 
-  ORE->emit(R);
+  if (ORE)
+    ORE->emit(R);
 }
 
 bool GVN::AnalyzeLoadAvailability(LoadInst *LI, MemDepResult DepInfo,

       dbgs() << " is clobbered by " << *I << '\n';
     );
 
-    if (ORE->allowExtraAnalysis())
+    if (ORE && ORE->allowExtraAnalysis())
       reportMayClobberedLoad(LI, DepInfo, DT, ORE);
 
     return false;

   if (V->getType()->isPtrOrPtrVectorTy())
     MD->invalidateCachedPointerInfo(V);
   markInstructionForDeletion(LI);
-  ORE->emit(OptimizationRemark(DEBUG_TYPE, "LoadPRE", LI)
-            << "load eliminated by PRE");
+  if (ORE)
+    ORE->emit(OptimizationRemark(DEBUG_TYPE, "LoadPRE", LI)
+              << "load eliminated by PRE");
   ++NumPRELoad;
   return true;
 }

 static void reportLoadElim(LoadInst *LI, Value *AvailableValue,
                            OptimizationRemarkEmitter *ORE) {
   using namespace ore;
-  ORE->emit(OptimizationRemark(DEBUG_TYPE, "LoadElim", LI)
-            << "load of type " << NV("Type", LI->getType()) << " eliminated"
-            << setExtraArgs() << " in favor of "
-            << NV("InfavorOfValue", AvailableValue));
+  if (ORE)
+    ORE->emit(OptimizationRemark(DEBUG_TYPE, "LoadElim", LI)
+              << "load of type " << NV("Type", LI->getType()) << " eliminated"
+              << setExtraArgs() << " in favor of "
+              << NV("InfavorOfValue", AvailableValue));
 }
 
 /// Attempt to eliminate a load whose dependencies are

lib/Transforms/Scalar/LICM.cpp

 
   auto *ORE = FAM.getCachedResult<OptimizationRemarkEmitterAnalysis>(*F);
   // FIXME: This should probably be optional rather than required.
-  if (!ORE)
-    report_fatal_error("LICM: OptimizationRemarkEmitterAnalysis not "
-                       "cached at a higher level");
+  //if (!ORE)
+  //  report_fatal_error("LICM: OptimizationRemarkEmitterAnalysis not "
+  //                     "cached at a higher level");
 
   LoopInvariantCodeMotion LICM;
   if (!LICM.runOnLoop(&L, &AR.AA, &AR.LI, &AR.DT, &AR.TLI, &AR.SE, ORE, true))

                  const LoopSafetyInfo *SafetyInfo,
                  OptimizationRemarkEmitter *ORE) {
   DEBUG(dbgs() << "LICM sinking instruction: " << I << "\n");
-  ORE->emit(OptimizationRemark(DEBUG_TYPE, "InstSunk", &I)
-            << "sinking " << ore::NV("Inst", &I));
+  if (ORE)
+    ORE->emit(OptimizationRemark(DEBUG_TYPE, "InstSunk", &I)
+              << "sinking " << ore::NV("Inst", &I));
   bool Changed = false;
   if (isa<LoadInst>(I))
     ++NumMovedLoads;

   auto *Preheader = CurLoop->getLoopPreheader();
   DEBUG(dbgs() << "LICM hoisting to " << Preheader->getName() << ": " << I
                << "\n");
-  ORE->emit(OptimizationRemark(DEBUG_TYPE, "Hoisted", &I)
+  if (ORE)
+    ORE->emit(OptimizationRemark(DEBUG_TYPE, "Hoisted", &I)
             << "hoisting " << ore::NV("Inst", &I));
 
   // Metadata can be dependent on conditions we are hoisting above.

 
   if (!GuaranteedToExecute) {
     auto *LI = dyn_cast<LoadInst>(&Inst);
-    if (LI && CurLoop->isLoopInvariant(LI->getPointerOperand()))
+    if (ORE && LI && CurLoop->isLoopInvariant(LI->getPointerOperand()))
       ORE->emit(OptimizationRemarkMissed(
                     DEBUG_TYPE, "LoadWithLoopInvariantAddressCondExecuted", LI)
                 << "failed to hoist load with loop-invariant address "

   // Otherwise, this is safe to promote, lets do it!
   DEBUG(dbgs() << "LICM: Promoting value stored to in loop: " << *SomePtr
                << '\n');
-  ORE->emit(
-      OptimizationRemark(DEBUG_TYPE, "PromoteLoopAccessesToScalar", LoopUses[0])
-      << "Moving accesses to memory location out of the loop");
+  if (ORE)
+    ORE->emit(
+        OptimizationRemark(DEBUG_TYPE, "PromoteLoopAccessesToScalar", LoopUses[0])
+        << "Moving accesses to memory location out of the loop");
   ++NumPromoted;
 
   // Grab a debug location for the inserted loads/stores; given that the

lib/Transforms/Scalar/LoopDataPrefetch.cpp

       ++NumPrefetches;
       DEBUG(dbgs() << "  Access: " << *PtrValue << ", SCEV: " << *LSCEV
                    << "\n");
-      ORE->emit(OptimizationRemark(DEBUG_TYPE, "Prefetched", MemI)
-                << "prefetched memory access");
+      if (ORE)
+        ORE->emit(OptimizationRemark(DEBUG_TYPE, "Prefetched", MemI)
+                  << "prefetched memory access");
 
       MadeChange = true;
     }

lib/Transforms/Scalar/LoopDistribute.cpp

 
     ++NumLoopsDistributed;
     // Report the success.
-    ORE->emit(OptimizationRemark(LDIST_NAME, "Distribute", L->getStartLoc(),
-                                 L->getHeader())
-              << "distributed loop");
+    if (ORE)
+      ORE->emit(OptimizationRemark(LDIST_NAME, "Distribute", L->getStartLoc(),
+                                   L->getHeader())
+                << "distributed loop");
     return true;
   }
 

     DEBUG(dbgs() << "Skipping; " << Message << "\n");
 
     // With Rpass-missed report that distribution failed.
-    ORE->emit(
-        OptimizationRemarkMissed(LDIST_NAME, "NotDistributed", L->getStartLoc(),
-                                 L->getHeader())
-        << "loop not distributed: use -Rpass-analysis=loop-distribute for more "
-           "info");
+    if (ORE)
+      ORE->emit(
+          OptimizationRemarkMissed(LDIST_NAME, "NotDistributed", L->getStartLoc(),
+                                   L->getHeader())
+          << "loop not distributed: use -Rpass-analysis=loop-distribute for more "
+             "info");
 
     // With Rpass-analysis report why.  This is on by default if distribution
     // was requested explicitly.
-    ORE->emit(OptimizationRemarkAnalysis(
-                  Forced ? OptimizationRemarkAnalysis::AlwaysPrint : LDIST_NAME,
-                  RemarkName, L->getStartLoc(), L->getHeader())
-              << "loop not distributed: " << Message);
+    if (ORE)
+      ORE->emit(OptimizationRemarkAnalysis(
+                    Forced ? OptimizationRemarkAnalysis::AlwaysPrint : LDIST_NAME,
+                    RemarkName, L->getStartLoc(), L->getHeader())
+                << "loop not distributed: " << Message);
 
     // Also issue a warning if distribution was requested explicitly but it
     // failed.

lib/Transforms/Scalar/LoopInterchange.cpp

       return false;
     }
 
-    ORE->emit(OptimizationRemark(DEBUG_TYPE, "Interchanged",
-                                 InnerLoop->getStartLoc(),
-                                 InnerLoop->getHeader())
-              << "Loop interchanged with enclosing loop.");
+    if (ORE)
+      ORE->emit(OptimizationRemark(DEBUG_TYPE, "Interchanged",
+                                   InnerLoop->getStartLoc(),
+                                   InnerLoop->getHeader())
+                << "Loop interchanged with enclosing loop.");
 
     LoopInterchangeTransform LIT(OuterLoop, InnerLoop, SE, LI, DT,
                                  LoopNestExit, LIL.hasInnerLoopReduction());

   if (!findInductionAndReductions(InnerLoop, Inductions, Reductions)) {
     DEBUG(dbgs() << "Only inner loops with induction or reduction PHI nodes "
                  << "are supported currently.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "UnsupportedPHIInner",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "Only inner loops with induction or reduction PHI nodes can be"
-                 " interchange currently.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "UnsupportedPHIInner",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "Only inner loops with induction or reduction PHI nodes can be"
+                   " interchange currently.");
     return true;
   }
 

   if (Inductions.size() != 1) {
     DEBUG(dbgs() << "We currently only support loops with 1 induction variable."
                  << "Failed to interchange due to current limitation\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "MultiInductionInner",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "Only inner loops with 1 induction variable can be "
-                 "interchanged currently.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "MultiInductionInner",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "Only inner loops with 1 induction variable can be "
+                   "interchanged currently.");
     return true;
   }
   if (Reductions.size() > 0)

   if (!findInductionAndReductions(OuterLoop, Inductions, Reductions)) {
     DEBUG(dbgs() << "Only outer loops with induction or reduction PHI nodes "
                  << "are supported currently.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "UnsupportedPHIOuter",
-                                       OuterLoop->getStartLoc(),
-                                       OuterLoop->getHeader())
-              << "Only outer loops with induction or reduction PHI nodes can be"
-                 " interchanged currently.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "UnsupportedPHIOuter",
+                                         OuterLoop->getStartLoc(),
+                                         OuterLoop->getHeader())
+                << "Only outer loops with induction or reduction PHI nodes can be"
+                   " interchanged currently.");
     return true;
   }
 

   if (!Reductions.empty()) {
     DEBUG(dbgs() << "Outer loops with reductions are not supported "
                  << "currently.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "ReductionsOuter",
-                                       OuterLoop->getStartLoc(),
-                                       OuterLoop->getHeader())
-              << "Outer loops with reductions cannot be interchangeed "
-                 "currently.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "ReductionsOuter",
+                                         OuterLoop->getStartLoc(),
+                                         OuterLoop->getHeader())
+                << "Outer loops with reductions cannot be interchangeed "
+                   "currently.");
     return true;
   }
   // TODO: Currently we handle only loops with 1 induction variable.
   if (Inductions.size() != 1) {
     DEBUG(dbgs() << "Loops with more than 1 induction variables are not "
                  << "supported currently.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "MultiIndutionOuter",
-                                       OuterLoop->getStartLoc(),
-                                       OuterLoop->getHeader())
-              << "Only outer loops with 1 induction variable can be "
-                 "interchanged currently.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "MultiIndutionOuter",
+                                         OuterLoop->getStartLoc(),
+                                         OuterLoop->getHeader())
+                << "Only outer loops with 1 induction variable can be "
+                   "interchanged currently.");
     return true;
   }
 
   // TODO: Triangular loops are not handled for now.
   if (!isLoopStructureUnderstood(InnerInductionVar)) {
     DEBUG(dbgs() << "Loop structure not understood by pass\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "UnsupportedStructureInner",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "Inner loop structure not understood currently.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "UnsupportedStructureInner",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "Inner loop structure not understood currently.");
     return true;
   }
 

       getLoopLatchExitBlock(OuterLoopLatch, OuterLoopHeader);
   if (!LoopExitBlock || !containsSafePHI(LoopExitBlock, true)) {
     DEBUG(dbgs() << "Can only handle LCSSA PHIs in outer loops currently.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "NoLCSSAPHIOuter",
-                                       OuterLoop->getStartLoc(),
-                                       OuterLoop->getHeader())
-              << "Only outer loops with LCSSA PHIs can be interchange "
-                 "currently.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "NoLCSSAPHIOuter",
+                                         OuterLoop->getStartLoc(),
+                                         OuterLoop->getHeader())
+                << "Only outer loops with LCSSA PHIs can be interchange "
+                   "currently.");
     return true;
   }
 
   LoopExitBlock = getLoopLatchExitBlock(InnerLoopLatch, InnerLoopHeader);
   if (!LoopExitBlock || !containsSafePHI(LoopExitBlock, false)) {
     DEBUG(dbgs() << "Can only handle LCSSA PHIs in inner loops currently.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "NoLCSSAPHIOuterInner",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "Only inner loops with LCSSA PHIs can be interchange "
-                 "currently.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "NoLCSSAPHIOuterInner",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "Only inner loops with LCSSA PHIs can be interchange "
+                   "currently.");
     return true;
   }
 

   if (!InnerIndexVarInc) {
     DEBUG(dbgs() << "Did not find an instruction to increment the induction "
                  << "variable.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "NoIncrementInInner",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "The inner loop does not increment the induction variable.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "NoIncrementInInner",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "The inner loop does not increment the induction variable.");
     return true;
   }
 

     if (!I.isIdenticalTo(InnerIndexVarInc)) {
       DEBUG(dbgs() << "Found unsupported instructions between induction "
                    << "variable increment and branch.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "UnsupportedInsBetweenInduction",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "Found unsupported instruction between induction variable "
-                 "increment and branch.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "UnsupportedInsBetweenInduction",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "Found unsupported instruction between induction variable "
+                   "increment and branch.");
       return true;
     }
 

   // current limitation.
   if (!FoundInduction) {
     DEBUG(dbgs() << "Did not find the induction variable.\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "NoIndutionVariable",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "Did not find the induction variable.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "NoIndutionVariable",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "Did not find the induction variable.");
     return true;
   }
   return false;

     DEBUG(dbgs() << "Failed interchange InnerLoopId = " << InnerLoopId
                  << " and OuterLoopId = " << OuterLoopId
                  << " due to dependence\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "Dependence",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "Cannot interchange loops due to dependences.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "Dependence",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "Cannot interchange loops due to dependences.");
     return false;
   }
 

   // Check if the loops are tightly nested.
   if (!tightlyNested(OuterLoop, InnerLoop)) {
     DEBUG(dbgs() << "Loops not tightly nested\n");
-    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                       "NotTightlyNested",
-                                       InnerLoop->getStartLoc(),
-                                       InnerLoop->getHeader())
-              << "Cannot interchange loops because they are not tightly "
-                 "nested.");
+    if (ORE)
+      ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                         "NotTightlyNested",
+                                         InnerLoop->getStartLoc(),
+                                         InnerLoop->getHeader())
+                << "Cannot interchange loops because they are not tightly "
+                   "nested.");
     return false;
   }
 

   if (isProfitableForVectorization(InnerLoopId, OuterLoopId, DepMatrix))
     return true;
 
-  ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
-                                     "InterchangeNotProfitable",
-                                     InnerLoop->getStartLoc(),
-                                     InnerLoop->getHeader())
-            << "Interchanging loops is too costly (cost="
-            << ore::NV("Cost", Cost) << ", threshold="
-            << ore::NV("Threshold", LoopInterchangeCostThreshold) <<
-            ") and it does not improve parallelism.");
+  if (ORE)
+    ORE->emit(OptimizationRemarkMissed(DEBUG_TYPE,
+                                       "InterchangeNotProfitable",
+                                       InnerLoop->getStartLoc(),
+                                       InnerLoop->getHeader())
+              << "Interchanging loops is too costly (cost="
+              << ore::NV("Cost", Cost) << ", threshold="
+              << ore::NV("Threshold", LoopInterchangeCostThreshold) <<
+              ") and it does not improve parallelism.");
   return false;
 }
 

lib/Transforms/Scalar/LoopUnrollPass.cpp

           UP.Count >>= 1;
       }
       if (UP.Count < 2) {
-        if (PragmaEnableUnroll)
+        if (ORE && PragmaEnableUnroll)
           ORE->emit(
               OptimizationRemarkMissed(DEBUG_TYPE, "UnrollAsDirectedTooLarge",
                                        L->getStartLoc(), L->getHeader())

     }
     if (UP.Count > UP.MaxCount)
       UP.Count = UP.MaxCount;
-    if ((PragmaFullUnroll || PragmaEnableUnroll) && TripCount &&
+    if (ORE && (PragmaFullUnroll || PragmaEnableUnroll) && TripCount &&
         UP.Count != TripCount)
       ORE->emit(
           OptimizationRemarkMissed(DEBUG_TYPE, "FullUnrollAsDirectedTooLarge",

   }
   assert(TripCount == 0 &&
          "All cases when TripCount is constant should be covered here.");
-  if (PragmaFullUnroll)
+  if (ORE && PragmaFullUnroll)
     ORE->emit(
         OptimizationRemarkMissed(DEBUG_TYPE,
                                  "CantFullUnrollAsDirectedRuntimeTripCount",

                  << TripMultiple << ".  Reducing unroll count from "
                  << OrigCount << " to " << UP.Count << ".\n");
     using namespace ore;
-    if (PragmaCount > 0 && !UP.AllowRemainder)
+    if (ORE && PragmaCount > 0 && !UP.AllowRemainder)
       ORE->emit(
           OptimizationRemarkMissed(DEBUG_TYPE,
                                    "DifferentUnrollCountFromDirected",

 
   auto *ORE = FAM.getCachedResult<OptimizationRemarkEmitterAnalysis>(*F);
   // FIXME: This should probably be optional rather than required.
-  if (!ORE)
-    report_fatal_error(
-        "LoopFullUnrollPass: OptimizationRemarkEmitterAnalysis not "
-        "cached at a higher level");
+  //if (!ORE)
+  //  report_fatal_error(
+  //      "LoopFullUnrollPass: OptimizationRemarkEmitterAnalysis not "
+  //      "cached at a higher level");
 
   // Keep track of the previous loop structure so we can identify new loops
   // created by unrolling.

lib/Transforms/Scalar/TailRecursionElimination.cpp

         }
         if (SafeToTail) {
           using namespace ore;
-          ORE->emit(OptimizationRemark(DEBUG_TYPE, "tailcall-readnone", CI)
-                    << "marked as tail call candidate (readnone)");
+          if (ORE)
+            ORE->emit(OptimizationRemark(DEBUG_TYPE, "tailcall-readnone", CI)
+                      << "marked as tail call candidate (readnone)");
           CI->setTailCall();
           Modified = true;
           continue;

     if (Visited[CI->getParent()] != ESCAPED) {
       // If the escape point was part way through the block, calls after the
       // escape point wouldn't have been put into DeferredTails.
-      ORE->emit(OptimizationRemark(DEBUG_TYPE, "tailcall", CI)
-                << "marked as tail call candidate");
+      if (ORE)
+        ORE->emit(OptimizationRemark(DEBUG_TYPE, "tailcall", CI)
+                  << "marked as tail call candidate");
       CI->setTailCall();
       Modified = true;
     } else {

   Function *F = BB->getParent();
 
   using namespace ore;
-  ORE->emit(OptimizationRemark(DEBUG_TYPE, "tailcall-recursion", CI)
-            << "transforming tail recursion into loop");
+  if (ORE)
+    ORE->emit(OptimizationRemark(DEBUG_TYPE, "tailcall-recursion", CI)
+              << "transforming tail recursion into loop");
 
   // OK! We can transform this tail call.  If this is the first one found,
   // create the new entry block, allowing us to branch back to the old entry.

lib/Transforms/Utils/LoopUnroll.cpp

   if (CompletelyUnroll) {
     DEBUG(dbgs() << "COMPLETELY UNROLLING loop %" << Header->getName()
           << " with trip count " << TripCount << "!\n");
-    ORE->emit(OptimizationRemark(DEBUG_TYPE, "FullyUnrolled", L->getStartLoc(),
-                                 L->getHeader())
-              << "completely unrolled loop with "
-              << NV("UnrollCount", TripCount) << " iterations");
+    if (ORE)
+      ORE->emit(OptimizationRemark(DEBUG_TYPE, "FullyUnrolled", L->getStartLoc(),
+                                   L->getHeader())
+                << "completely unrolled loop with "
+                << NV("UnrollCount", TripCount) << " iterations");
   } else if (PeelCount) {
     DEBUG(dbgs() << "PEELING loop %" << Header->getName()
                  << " with iteration count " << PeelCount << "!\n");
-    ORE->emit(OptimizationRemark(DEBUG_TYPE, "Peeled", L->getStartLoc(),
-                                 L->getHeader())
-              << " peeled loop by " << NV("PeelCount", PeelCount)
-              << " iterations");
+    if (ORE)
+      ORE->emit(OptimizationRemark(DEBUG_TYPE, "Peeled", L->getStartLoc(),
+                                   L->getHeader())
+                << " peeled loop by " << NV("PeelCount", PeelCount)
+                << " iterations");
   } else {
     OptimizationRemark Diag(DEBUG_TYPE, "PartialUnrolled", L->getStartLoc(),
                             L->getHeader());

           << " by " << Count);
     if (TripMultiple == 0 || BreakoutTrip != TripMultiple) {
       DEBUG(dbgs() << " with a breakout at trip " << BreakoutTrip);
-      ORE->emit(Diag << " with a breakout at trip "
-                     << NV("BreakoutTrip", BreakoutTrip));
+      if (ORE)
+        ORE->emit(Diag << " with a breakout at trip "
+                       << NV("BreakoutTrip", BreakoutTrip));
     } else if (TripMultiple != 1) {
       DEBUG(dbgs() << " with " << TripMultiple << " trips per branch");
-      ORE->emit(Diag << " with " << NV("TripMultiple", TripMultiple)
-                     << " trips per branch");
+      if (ORE)
+        ORE->emit(Diag << " with " << NV("TripMultiple", TripMultiple)
+                       << " trips per branch");
     } else if (RuntimeTripCount) {
       DEBUG(dbgs() << " with run-time trip count");
-      ORE->emit(Diag << " with run-time trip count");
+      if (ORE)
+        ORE->emit(Diag << " with run-time trip count");
     }
     DEBUG(dbgs() << "!\n");
   }

lib/Transforms/Vectorize/LoopVectorize.cpp

       // FIXME: Add interleave.disable metadata. This will allow
       // vectorize.disable to be used without disabling the pass and errors
       // to differentiate between disabled vectorization and a width of 1.
         ORE.emit(OptimizationRemarkAnalysis(vectorizeAnalysisPassName(),
                                             "AllDisabled", L->getStartLoc(),
                                             L->getHeader())
                  << "loop not vectorized: vectorization and interleaving are "
                     "explicitly disabled, or the loop has already been "
                     "vectorized");
       return false;
     }
 

   LH.emitRemarkWithHints();
 
   if (LH.getForce() == LoopVectorizeHints::FK_Enabled) {
-    if (LH.getWidth() != 1)
-      ORE->emit(DiagnosticInfoOptimizationFailure(
-                    DEBUG_TYPE, "FailedRequestedVectorization",
-                    L->getStartLoc(), L->getHeader())
-                << "loop not vectorized: "
-                << "failed explicitly specified loop vectorization");
-    else if (LH.getInterleave() != 1)
-      ORE->emit(DiagnosticInfoOptimizationFailure(
-                    DEBUG_TYPE, "FailedRequestedInterleaving", L->getStartLoc(),
-                    L->getHeader())
-                << "loop not interleaved: "
-                << "failed explicitly specified loop interleaving");
+    if (LH.getWidth() != 1) {
+      if (ORE)
+        ORE->emit(DiagnosticInfoOptimizationFailure(
+                      DEBUG_TYPE, "FailedRequestedVectorization",
+                      L->getStartLoc(), L->getHeader())
+                  << "loop not vectorized: "
+                  << "failed explicitly specified loop vectorization");
+    } else if (LH.getInterleave() != 1) {
+      if (ORE)
+        ORE->emit(DiagnosticInfoOptimizationFailure(
+                      DEBUG_TYPE, "FailedRequestedInterleaving", L->getStartLoc(),
+                      L->getHeader())
+                  << "loop not interleaved: "
+                  << "failed explicitly specified loop interleaving");
+    }
   }
 }
 

     const char *PassName = Hints.vectorizeAnalysisPassName();
     bool Failed = false;
     if (UnsafeAlgebraInst && !Hints.allowReordering()) {
         ORE.emit(
             OptimizationRemarkAnalysisFPCommute(PassName, "CantReorderFPOps",
                                                 UnsafeAlgebraInst->getDebugLoc(),
                                                 UnsafeAlgebraInst->getParent())
             << "loop not vectorized: cannot prove it is safe to reorder "
                "floating-point operations");
       Failed = true;
     }
 

 
 bool LoopVectorizationLegality::canVectorizeWithIfConvert() {
   if (!EnableIfConversion) {
-    ORE->emit(createMissedAnalysis("IfConversionDisabled")
-              << "if-conversion is disabled");
+    if (ORE)
+      ORE->emit(createMissedAnalysis("IfConversionDisabled")
+                << "if-conversion is disabled");
     return false;
   }
 

   for (BasicBlock *BB : TheLoop->blocks()) {
     // We don't support switch statements inside loops.
     if (!isa<BranchInst>(BB->getTerminator())) {
-      ORE->emit(createMissedAnalysis("LoopContainsSwitch", BB->getTerminator())
-                << "loop contains a switch statement");
+      if (ORE)
+        ORE->emit(createMissedAnalysis("LoopContainsSwitch", BB->getTerminator())
+                  << "loop contains a switch statement");
       return false;
     }
 
     // We must be able to predicate all blocks that need to be predicated.
     if (blockNeedsPredication(BB)) {
       if (!blockCanBePredicated(BB, SafePointes)) {
-        ORE->emit(createMissedAnalysis("NoCFGForSelect", BB->getTerminator())
-                  << "control flow cannot be substituted for a select");
+        if (ORE)
+          ORE->emit(createMissedAnalysis("NoCFGForSelect", BB->getTerminator())
+                    << "control flow cannot be substituted for a select");
         return false;
       }
     } else if (BB != Header && !canIfConvertPHINodes(BB)) {
-      ORE->emit(createMissedAnalysis("NoCFGForSelect", BB->getTerminator())
-                << "control flow cannot be substituted for a select");
+        if (ORE)
+          ORE->emit(createMissedAnalysis("NoCFGForSelect", BB->getTerminator())
+                    << "control flow cannot be substituted for a select");
       return false;
     }
   }

   // We must have a loop in canonical form. Loops with indirectbr in them cannot
   // be canonicalized.
   if (!TheLoop->getLoopPreheader()) {
-    ORE->emit(createMissedAnalysis("CFGNotUnderstood")
-              << "loop control flow is not understood by vectorizer");
-    if (ORE->allowExtraAnalysis())
+    if (ORE)
+      ORE->emit(createMissedAnalysis("CFGNotUnderstood")
+                << "loop control flow is not understood by vectorizer");
+    if (ORE && ORE->allowExtraAnalysis())
       Result = false;
     else
       return false;

   //
   // We can only vectorize innermost loops.
   if (!TheLoop->empty()) {
-    ORE->emit(createMissedAnalysis("NotInnermostLoop")
-              << "loop is not the innermost loop");
-    if (ORE->allowExtraAnalysis())
+    if (ORE)
+      ORE->emit(createMissedAnalysis("NotInnermostLoop")
+                << "loop is not the innermost loop");
+    if (ORE && ORE->allowExtraAnalysis())
       Result = false;
     else
       return false;

 
   // We must have a single backedge.
   if (TheLoop->getNumBackEdges() != 1) {
-    ORE->emit(createMissedAnalysis("CFGNotUnderstood")
-              << "loop control flow is not understood by vectorizer");
-    if (ORE->allowExtraAnalysis())
+    if (ORE)
+      ORE->emit(createMissedAnalysis("CFGNotUnderstood")
+                << "loop control flow is not understood by vectorizer");
+    if (ORE && ORE->allowExtraAnalysis())
       Result = false;
     else
       return false;

 
   // We must have a single exiting block.
   if (!TheLoop->getExitingBlock()) {
-    ORE->emit(createMissedAnalysis("CFGNotUnderstood")
-              << "loop control flow is not understood by vectorizer");
-    if (ORE->allowExtraAnalysis())
+    if (ORE)
+      ORE->emit(createMissedAnalysis("CFGNotUnderstood")
+                << "loop control flow is not understood by vectorizer");
+    if (ORE && ORE->allowExtraAnalysis())
       Result = false;
     else
       return false;

   unsigned NumBlocks = TheLoop->getNumBlocks();
   if (NumBlocks != 1 && !canVectorizeWithIfConvert()) {
     DEBUG(dbgs() << "LV: Can't if-convert the loop.\n");
-    if (ORE->allowExtraAnalysis())
+    if (ORE && ORE->allowExtraAnalysis())
       Result = false;
     else
       return false;

   // Check if we can vectorize the instructions and CFG in this loop.
   if (!canVectorizeInstrs()) {
     DEBUG(dbgs() << "LV: Can't vectorize the instructions or CFG\n");
-    if (ORE->allowExtraAnalysis())
+    if (ORE && ORE->allowExtraAnalysis())
       Result = false;
     else
       return false;

   // Go over each instruction and look at memory deps.
   if (!canVectorizeMemory()) {
     DEBUG(dbgs() << "LV: Can't vectorize due to memory conflicts\n");
-    if (ORE->allowExtraAnalysis())
+    if (ORE && ORE->allowExtraAnalysis())
       Result = false;
     else
       return false;

     SCEVThreshold = PragmaVectorizeSCEVCheckThreshold;
 
   if (PSE.getUnionPredicate().getComplexity() > SCEVThreshold) {
-    ORE->emit(createMissedAnalysis("TooManySCEVRunTimeChecks")
-              << "Too many SCEV assumptions need to be made and checked "
-              << "at runtime");
+    if (ORE)
+      ORE->emit(createMissedAnalysis("TooManySCEVRunTimeChecks")
+                << "Too many SCEV assumptions need to be made and checked "
+                << "at runtime");
     DEBUG(dbgs() << "LV: Too many SCEV checks needed.\n");
-    if (ORE->allowExtraAnalysis())
+    if (ORE && ORE->allowExtraAnalysis())
       Result = false;
     else
       return false;

         // Check that this PHI type is allowed.
         if (!PhiTy->isIntegerTy() && !PhiTy->isFloatingPointTy() &&
             !PhiTy->isPointerTy()) {
-          ORE->emit(createMissedAnalysis("CFGNotUnderstood", Phi)
-                    << "loop control flow is not understood by vectorizer");
+          if (ORE)
+            ORE->emit(createMissedAnalysis("CFGNotUnderstood", Phi)
+                      << "loop control flow is not understood by vectorizer");
           DEBUG(dbgs() << "LV: Found an non-int non-pointer PHI.\n");
           return false;
         }

           // identified reduction value with an outside user.
           if (!hasOutsideLoopUser(TheLoop, Phi, AllowedExit))
             continue;
-          ORE->emit(createMissedAnalysis("NeitherInductionNorReduction", Phi)
-                    << "value could not be identified as "
-                       "an induction or reduction variable");
+          if (ORE)
+            ORE->emit(createMissedAnalysis("NeitherInductionNorReduction", Phi)
+                      << "value could not be identified as "
+                         "an induction or reduction variable");
           return false;
         }
 
         // We only allow if-converted PHIs with exactly two incoming values.
         if (Phi->getNumIncomingValues() != 2) {
-          ORE->emit(createMissedAnalysis("CFGNotUnderstood", Phi)
-                    << "control flow not understood by vectorizer");
+          if (ORE)
+            ORE->emit(createMissedAnalysis("CFGNotUnderstood", Phi)
+                      << "control flow not understood by vectorizer");
           DEBUG(dbgs() << "LV: Found an invalid PHI.\n");
           return false;
         }

           addInductionPhi(Phi, ID, AllowedExit);
           continue;
         }
-
+        if (ORE)
           ORE->emit(createMissedAnalysis("NonReductionValueUsedOutsideLoop", Phi)
                     << "value that could not be identified as "
                        "reduction is used outside the loop");
         DEBUG(dbgs() << "LV: Found an unidentified PHI." << *Phi << "\n");
         return false;
       } // end of PHI handling

           !isa<DbgInfoIntrinsic>(CI) &&
           !(CI->getCalledFunction() && TLI &&
             TLI->isFunctionVectorizable(CI->getCalledFunction()->getName()))) {
-        ORE->emit(createMissedAnalysis("CantVectorizeCall", CI)
-                  << "call instruction cannot be vectorized");
+        if (ORE)
+          ORE->emit(createMissedAnalysis("CantVectorizeCall", CI)
+                    << "call instruction cannot be vectorized");
         DEBUG(dbgs() << "LV: Found a non-intrinsic, non-libfunc callsite.\n");
         return false;
       }

                     getVectorIntrinsicIDForCall(CI, TLI), 1)) {
         auto *SE = PSE.getSE();
         if (!SE->isLoopInvariant(PSE.getSCEV(CI->getOperand(1)), TheLoop)) {
-          ORE->emit(createMissedAnalysis("CantVectorizeIntrinsic", CI)
-                    << "intrinsic instruction cannot be vectorized");
+          if (ORE)
+            ORE->emit(createMissedAnalysis("CantVectorizeIntrinsic", CI)
+                      << "intrinsic instruction cannot be vectorized");
           DEBUG(dbgs() << "LV: Found unvectorizable intrinsic " << *CI << "\n");
           return false;
         }

       if ((!VectorType::isValidElementType(I.getType()) &&
            !I.getType()->isVoidTy()) ||
           isa<ExtractElementInst>(I)) {
-        ORE->emit(createMissedAnalysis("CantVectorizeInstructionReturnType", &I)
-                  << "instruction return type cannot be vectorized");
+        if (ORE)
+          ORE->emit(createMissedAnalysis("CantVectorizeInstructionReturnType", &I)
+                    << "instruction return type cannot be vectorized");
         DEBUG(dbgs() << "LV: Found unvectorizable type.\n");
         return false;
       }

       if (auto *ST = dyn_cast<StoreInst>(&I)) {
         Type *T = ST->getValueOperand()->getType();
         if (!VectorType::isValidElementType(T)) {
-          ORE->emit(createMissedAnalysis("CantVectorizeStore", ST)
-                    << "store instruction cannot be vectorized");
+          if (ORE)
+            ORE->emit(createMissedAnalysis("CantVectorizeStore", ST)
+                      << "store instruction cannot be vectorized");
           return false;
         }
 

       // Reduction instructions are allowed to have exit users.
       // All other instructions must not have external users.
       if (hasOutsideLoopUser(TheLoop, &I, AllowedExit)) {
-        ORE->emit(createMissedAnalysis("ValueUsedOutsideLoop", &I)
-                  << "value cannot be used outside the loop");
+        if (ORE)
+          ORE->emit(createMissedAnalysis("ValueUsedOutsideLoop", &I)
+                    << "value cannot be used outside the loop");
         return false;
       }
 

   if (!PrimaryInduction) {
     DEBUG(dbgs() << "LV: Did not find one integer induction var.\n");
     if (Inductions.empty()) {
-      ORE->emit(createMissedAnalysis("NoInductionVariable")
-                << "loop induction variable could not be identified");
+      if (ORE)
+        ORE->emit(createMissedAnalysis("NoInductionVariable")
+                  << "loop induction variable could not be identified");
       return false;
     }
   }

   if (LAR) {
     OptimizationRemarkAnalysis VR(Hints->vectorizeAnalysisPassName(),
                                   "loop not vectorized: ", *LAR);
-    ORE->emit(VR);
+   if (ORE)
+     ORE->emit(VR);
   }
   if (!LAI->canVectorizeMemory())
     return false;
 
   if (LAI->hasStoreToLoopInvariantAddress()) {
-    ORE->emit(createMissedAnalysis("CantVectorizeStoreToLoopInvariantAddress")
-              << "write to a loop invariant address could not be vectorized");
+    if (ORE)
+      ORE->emit(createMissedAnalysis("CantVectorizeStoreToLoopInvariantAddress")
+                << "write to a loop invariant address could not be vectorized");
     DEBUG(dbgs() << "LV: We don't allow storing to uniform addresses\n");
     return false;
   }

 
 Optional<unsigned> LoopVectorizationCostModel::computeMaxVF(bool OptForSize) {
   if (!EnableCondStoresVectorization && Legal->getNumPredStores()) {
-    ORE->emit(createMissedAnalysis("ConditionalStore")
-              << "store that is conditionally executed prevents vectorization");
+    if (ORE)
+      ORE->emit(createMissedAnalysis("ConditionalStore")
+                << "store that is conditionally executed prevents vectorization");
     DEBUG(dbgs() << "LV: No vectorization. There are conditional stores.\n");
     return None;
   }

     // uniform if the target can skip.
     DEBUG(dbgs() << "LV: Not inserting runtime ptr check for divergent target");
 
-    ORE->emit(
-      createMissedAnalysis("CantVersionLoopWithDivergentTarget")
-      << "runtime pointer checks needed. Not enabled for divergent target");
+    if (ORE)
+      ORE->emit(
+        createMissedAnalysis("CantVersionLoopWithDivergentTarget")
+        << "runtime pointer checks needed. Not enabled for divergent target");
 
     return None;
   }

     return computeFeasibleMaxVF(OptForSize);
 
   if (Legal->getRuntimePointerChecking()->Need) {
-    ORE->emit(createMissedAnalysis("CantVersionLoopWithOptForSize")
-              << "runtime pointer checks needed. Enable vectorization of this "
-                 "loop with '#pragma clang loop vectorize(enable)' when "
-                 "compiling with -Os/-Oz");
+    if (ORE)
+      ORE->emit(createMissedAnalysis("CantVersionLoopWithOptForSize")
+                << "runtime pointer checks needed. Enable vectorization of this "
+                   "loop with '#pragma clang loop vectorize(enable)' when "
+                   "compiling with -Os/-Oz");
     DEBUG(dbgs()
           << "LV: Aborting. Runtime ptr check is required with -Os/-Oz.\n");
     return None;

 
   // If we don't know the precise trip count, don't try to vectorize.
   if (TC < 2) {
-    ORE->emit(
-        createMissedAnalysis("UnknownLoopCountComplexCFG")
-        << "unable to calculate the loop count due to complex control flow");
+    if (ORE)
+      ORE->emit(
+          createMissedAnalysis("UnknownLoopCountComplexCFG")
+          << "unable to calculate the loop count due to complex control flow");
     DEBUG(dbgs() << "LV: Aborting. A tail loop is required with -Os/-Oz.\n");
     return None;
   }

     // FIXME: return None if loop requiresScalarEpilog(<MaxVF>), or look for a
     //        smaller MaxVF that does not require a scalar epilog.
 
-    ORE->emit(createMissedAnalysis("NoTailLoopWithOptForSize")
-              << "cannot optimize for size and vectorize at the "
-                 "same time. Enable vectorization of this loop "
-                 "with '#pragma clang loop vectorize(enable)' "
-                 "when compiling with -Os/-Oz");
+    if (ORE)
+      ORE->emit(createMissedAnalysis("NoTailLoopWithOptForSize")
+                << "cannot optimize for size and vectorize at the "
+                   "same time. Enable vectorization of this loop "
+                   "with '#pragma clang loop vectorize(enable)' "
+                   "when compiling with -Os/-Oz");
     DEBUG(dbgs() << "LV: Aborting. A tail loop is required with -Os/-Oz.\n");
     return None;
   }

   if (F->hasFnAttribute(Attribute::NoImplicitFloat)) {
     DEBUG(dbgs() << "LV: Can't vectorize when the NoImplicitFloat"
                     "attribute is used.\n");
-    ORE->emit(createMissedAnalysis(Hints.vectorizeAnalysisPassName(),
-                                   "NoImplicitFloat", L)
+    if (ORE)
+      ORE->emit(createMissedAnalysis(Hints.vectorizeAnalysisPassName(),
+                                     "NoImplicitFloat", L)
               << "loop not vectorized due to NoImplicitFloat attribute");
     emitMissedWarning(F, L, Hints, ORE);
     return false;

   if (Hints.isPotentiallyUnsafe() &&
       TTI->isFPVectorizationPotentiallyUnsafe()) {
     DEBUG(dbgs() << "LV: Potentially unsafe FP op prevents vectorization.\n");
-    ORE->emit(
-        createMissedAnalysis(Hints.vectorizeAnalysisPassName(), "UnsafeFP", L)
-        << "loop not vectorized due to unsafe FP support.");
+    if (ORE)
+      ORE->emit(
+          createMissedAnalysis(Hints.vectorizeAnalysisPassName(), "UnsafeFP", L)
+          << "loop not vectorized due to unsafe FP support.");
     emitMissedWarning(F, L, Hints, ORE);
     return false;
   }

   const char *VAPassName = Hints.vectorizeAnalysisPassName();
   if (!VectorizeLoop && !InterleaveLoop) {
     // Do not vectorize or interleaving the loop.
-    ORE->emit(OptimizationRemarkMissed(VAPassName, VecDiagMsg.first,
-                                         L->getStartLoc(), L->getHeader())
-              << VecDiagMsg.second);
-    ORE->emit(OptimizationRemarkMissed(LV_NAME, IntDiagMsg.first,
-                                         L->getStartLoc(), L->getHeader())
-              << IntDiagMsg.second);
+    if (ORE) {
+      ORE->emit(OptimizationRemarkMissed(VAPassName, VecDiagMsg.first,
+                                           L->getStartLoc(), L->getHeader())
+                << VecDiagMsg.second);
+      ORE->emit(OptimizationRemarkMissed(LV_NAME, IntDiagMsg.first,
+                                           L->getStartLoc(), L->getHeader())
+                << IntDiagMsg.second);
+    }
     return false;
   } else if (!VectorizeLoop && InterleaveLoop) {
     DEBUG(dbgs() << "LV: Interleave Count is " << IC << '\n');
-    ORE->emit(OptimizationRemarkAnalysis(VAPassName, VecDiagMsg.first,
-                                         L->getStartLoc(), L->getHeader())
-              << VecDiagMsg.second);
+    if (ORE)
+      ORE->emit(OptimizationRemarkAnalysis(VAPassName, VecDiagMsg.first,
+                                           L->getStartLoc(), L->getHeader())
+                << VecDiagMsg.second);
   } else if (VectorizeLoop && !InterleaveLoop) {
     DEBUG(dbgs() << "LV: Found a vectorizable loop (" << VF.Width << ") in "
                  << DebugLocStr << '\n');
-    ORE->emit(OptimizationRemarkAnalysis(LV_NAME, IntDiagMsg.first,
-                                         L->getStartLoc(), L->getHeader())
-              << IntDiagMsg.second);
+    if (ORE)
+      ORE->emit(OptimizationRemarkAnalysis(LV_NAME, IntDiagMsg.first,
+                                           L->getStartLoc(), L->getHeader())
+                << IntDiagMsg.second);
   } else if (VectorizeLoop && InterleaveLoop) {
     DEBUG(dbgs() << "LV: Found a vectorizable loop (" << VF.Width << ") in "
                  << DebugLocStr << '\n');

                                &CM);
     LVP.executePlan(Unroller, DT);
 
-    ORE->emit(OptimizationRemark(LV_NAME, "Interleaved", L->getStartLoc(),
-                                 L->getHeader())
-              << "interleaved loop (interleaved count: "
-              << NV("InterleaveCount", IC) << ")");
+    if (ORE)
+      ORE->emit(OptimizationRemark(LV_NAME, "Interleaved", L->getStartLoc(),
+                                   L->getHeader())
+                << "interleaved loop (interleaved count: "
+                << NV("InterleaveCount", IC) << ")");
   } else {
     // If we decided that it is *legal* to vectorize the loop, then do it.
     InnerLoopVectorizer LB(L, PSE, LI, DT, TLI, TTI, AC, ORE, VF.Width, IC,

       AddRuntimeUnrollDisableMetaData(L);
 
     // Report the vectorization decision.
-    ORE->emit(OptimizationRemark(LV_NAME, "Vectorized", L->getStartLoc(),
-                                 L->getHeader())
-              << "vectorized loop (vectorization width: "
-              << NV("VectorizationFactor", VF.Width)
-              << ", interleaved count: " << NV("InterleaveCount", IC) << ")");
+    if (ORE)
+      ORE->emit(OptimizationRemark(LV_NAME, "Vectorized", L->getStartLoc(),
+                                   L->getHeader())
+                << "vectorized loop (vectorization width: "
+                << NV("VectorizationFactor", VF.Width)
+                << ", interleaved count: " << NV("InterleaveCount", IC) << ")");
   }
 
   // Mark the loop as already vectorized to avoid vectorizing again.