[OptDiag] Updating Remarks in SampleProfile

[efriedma]

Summary

Updating remark API to newer OptimizationDiagnosticInfo API. This allows remarks to show up in diagnostic yaml file, and enables use of opt-viewer tool.

Hotness information for remarks (L505 and L751) do not display hotness information, most likely due to profile information not being propagated yet. Unsure if this is the desired outcome.

[anemet]

Thanks very much for working on this! Please assign https://bugs.llvm.org/show_bug.cgi?id=33794 to you. Also check out my note in the bug.

Hotness information for remarks (L505 and L751) do not display hotness information, most likely due to profile information not being propagated yet. Unsure if this is the desired outcome.

You need to use -pass-remarks-with-hotness for that.

lib/Transforms/IPO/SampleProfile.cpp

163–183

Rather than passing and ORE reference around like this, can't we make it a member to this class?

505

Should these be OptimizationRemarkAnalysis instead? These aren't really optimization performed (or missed) i.e. either negative or positive.

506

You probably want to stream this out as named-value argument. Looks for NV in Inliner.cpp for an example.

507–508

I don't know much about the internals of sample-based profiling but is LineOffset or Discriminator actionable to the user? I.e. isn't this just a debugging aid if something goes wrong?

679–682

Formatting only?

751–753

Again see Inliner.cpp how to stream these out as named-value arguments.

1259–1265

You can stream out the instruction like we stream them out I think in LICM as a named-value argument. This may include the LLVM IR name of the instruction which may or may not work in this case, so you may need to tweak DiagnosticInfoOptimizationBase::Argument to do the right thing here.

1492

For the new pass manager path (when you enter via SampleProfileLoaderPass::run we shouldn't create ORE on the file but rather get it from FunctionAnalysisManagerModuleProxy. See IndirectCallPromotion.cpp for an example.

1503–1504

Commit formatting change in otherwise unmodified code separately.

test/Transforms/SampleProfile/remarks.ll

30–40

Please check the full records with YAML-NEXT.

[tarunr]

Thanks for reviewing and for pointing me to examples.

-pass-remarks-with-hotness doesn't seem to be helping me in getting hotness information in these remarks.

lib/Transforms/IPO/SampleProfile.cpp

505

Yes, I think that this makes sense

507–508

The LineOffset and Discriminator may be useful for the user to better determine how the compiler applied the profile to the source. Though, I agree it doesn't seem very actionable to the user

1259–1265

Currently it looks like the opcode of the instruction gets streamed out in DiagnosticInfoOptimizationBase::Argument. Do you mean that the original source code of the instruction or location of the instruction should be streamed out instead?

[tarunr]

This update makes OptimizationRemarkEmitter part of the class, adds ORE to the promoteIndirectCall, and streams out remark messages as name-valued arguments.

[anemet]

In D36127#837482, @tarunr wrote:

-pass-remarks-with-hotness doesn't seem to be helping me in getting hotness information in these remarks.

It does something (after applying your patch):

./bin/opt -sample-profile -sample-profile-file=../test/Transforms/SampleProfile/Inputs/remarks.prof -S -pass-remarks-output=- -pass-remarks-with-hotness ../test/Transforms/SampleProfile/remarks.ll -o /dev/null | grep Hotness
Hotness: 0
Hotness: 0

but the 0 values are probably wrong. You probably need to study/debug this. The hotness should come from BFI which sample profiler should be updating.

lib/Transforms/IPO/SampleProfile.cpp

256

Comments end in period.

731

I think that this last use of the function that didn't use to pass ORE. Please remove the default argument from the declaration.

751–753

You didn't address this. See the Inliner or the Argument ctors; you can just stream out the Function itself.

751–753

We can't pass I here because it's remove by the time we get here? If yes, please comment.

1263–1265

I think that the way we should handle this is like: << NV("CondBranchesLoc", BranchLoc)

And then add a new ctor Arguments(StringRef Key, DebugLoc DL) where you set Val to DL.getFileName() + DL.getLine() + DL.getCol() and also Loc to DL. I think this will appear correctly both on the compiler output and in YAML/HTML.

If you want to make that this works correctly in YAML/HTML, you can run opt-viewer on the YAML file. You will have to split out the original C source from the comment into a source file specified in the debug info.

1270

Just stream out a DebugLoc() in you can't find. Don't the change the name of the field.

1446

Default argument on the definition? Please remove.

[anemet]

In D36127#837621, @anemet wrote:

In D36127#837482, @tarunr wrote:

-pass-remarks-with-hotness doesn't seem to be helping me in getting hotness information in these remarks.

It does something (after applying your patch):

./bin/opt -sample-profile -sample-profile-file=../test/Transforms/SampleProfile/Inputs/remarks.prof -S -pass-remarks-output=- -pass-remarks-with-hotness ../test/Transforms/SampleProfile/remarks.ll -o /dev/null | grep Hotness
Hotness: 0
Hotness: 0

but the 0 values are probably wrong. You probably need to study/debug this. The hotness should come from BFI which sample profiler should be updating.

Actually thinking a bit more about this, I don't think we can expect correct profile counts in BFI at this point. This pass adds the necessary metadata to get profile count on a subsequent run of BFI. @davidxl, am I right about this?

So I think for now we should just add a comment about this.

[efriedma]

(Tarun won't have time to finish this, so I'm taking it over.)

[efriedma]

Address review comments.

[anemet]

lib/Transforms/IPO/SampleProfile.cpp

1260

Why do you output the instruction? Its location should already be carried by remark location. It's also weird to see the instruction name in the remark:

CHECK: remark: nolocinfo.c:3:5: ret is the most popular destination for conditional branches at <UNKNOWN LOCATION>

[efriedma]

Don't emit instruction names for "most popular destination" remarks.

[anemet]

LGTM, thanks!

lib/Transforms/IPO/SampleProfile.cpp

 
 #include "llvm/Transforms/SampleProfile.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/OptimizationDiagnosticInfo.h"
 #include "llvm/Analysis/PostDominators.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/InstIterator.h"
public:
   bool runOnModule(Module &M);
   void setACT(AssumptionCacheTracker *A) { ACT = A; }
 
   void dump() { Reader->dump(); }
 
 protected:
   bool runOnFunction(Function &F);
   unsigned getFunctionLoc(Function &F);
-  bool emitAnnotations(Function &F);
-  ErrorOr<uint64_t> getInstWeight(const Instruction &I);
-  ErrorOr<uint64_t> getBlockWeight(const BasicBlock *BB);
+  bool emitAnnotations(Function &F, OptimizationRemarkEmitter &ORE);
+  ErrorOr<uint64_t> getInstWeight(const Instruction &I,
+                                  OptimizationRemarkEmitter &ORE);
+  ErrorOr<uint64_t> getBlockWeight(const BasicBlock *BB,
+                                   OptimizationRemarkEmitter &ORE);
   const FunctionSamples *findCalleeFunctionSamples(const Instruction &I) const;
   std::vector<const FunctionSamples *>
   findIndirectCallFunctionSamples(const Instruction &I) const;
   const FunctionSamples *findFunctionSamples(const Instruction &I) const;
-  bool inlineHotFunctions(Function &F,
-                          DenseSet<GlobalValue::GUID> &ImportGUIDs);
+  bool inlineHotFunctions(Function &F, DenseSet<GlobalValue::GUID> &ImportGUIDs,
+                          OptimizationRemarkEmitter &ORE);
   void printEdgeWeight(raw_ostream &OS, Edge E);
   void printBlockWeight(raw_ostream &OS, const BasicBlock *BB) const;
   void printBlockEquivalence(raw_ostream &OS, const BasicBlock *BB);
-  bool computeBlockWeights(Function &F);
+  bool computeBlockWeights(Function &F, OptimizationRemarkEmitter &ORE);
   void findEquivalenceClasses(Function &F);
   template <bool IsPostDom>
   void findEquivalencesFor(BasicBlock *BB1, ArrayRef<BasicBlock *> Descendants,
                            DominatorTreeBase<BasicBlock, IsPostDom> *DomTree);
 
-  void propagateWeights(Function &F);
+  void propagateWeights(Function &F, OptimizationRemarkEmitter &ORE);
   uint64_t visitEdge(Edge E, unsigned *NumUnknownEdges, Edge *UnknownEdge);
   void buildEdges(Function &F);
   bool propagateThroughEdges(Function &F, bool UpdateBlockCount);
   void computeDominanceAndLoopInfo(Function &F);
   unsigned getOffset(const DILocation *DIL) const;
   void clearFunctionData();
 
   /// \brief Map basic blocks to their computed weights.
protected:
   bool ProfileIsValid;
 
   /// \brief Total number of samples collected in this profile.
   ///
   /// This is the sum of all the samples collected in all the functions executed
   /// at runtime.
   uint64_t TotalCollectedSamples;
 };
 
 class SampleProfileLoaderLegacyPass : public ModulePass {
 public:
   // Class identification, replacement for typeinfo
   static char ID;
 
   SampleProfileLoaderLegacyPass(StringRef Name = SampleProfileFile)
       : ModulePass(ID), SampleLoader(Name) {
     initializeSampleProfileLoaderLegacyPassPass(

 /// collected on that instruction at runtime. To retrieve it, we
 /// need to compute the line number of \p Inst relative to the start of its
 /// function. We use HeaderLineno to compute the offset. We then
 /// look up the samples collected for \p Inst using BodySamples.
 ///
 /// \param Inst Instruction to query.
 ///
 /// \returns the weight of \p Inst.
-ErrorOr<uint64_t> SampleProfileLoader::getInstWeight(const Instruction &Inst) {
+ErrorOr<uint64_t>
+SampleProfileLoader::getInstWeight(const Instruction &Inst,
+                                   OptimizationRemarkEmitter &ORE) {
   const DebugLoc &DLoc = Inst.getDebugLoc();
   if (!DLoc)
     return std::error_code();
 
   const FunctionSamples *FS = findFunctionSamples(Inst);
   if (!FS)
     return std::error_code();
 
SampleProfileLoader::getInstWeight(const Instruction &Inst,
   const DILocation *DIL = DLoc;
   uint32_t LineOffset = getOffset(DIL);
   uint32_t Discriminator = DIL->getBaseDiscriminator();
   ErrorOr<uint64_t> R = FS->findSamplesAt(LineOffset, Discriminator);
   if (R) {
     bool FirstMark =
         CoverageTracker.markSamplesUsed(FS, LineOffset, Discriminator, R.get());
     if (FirstMark) {
-      const Function *F = Inst.getParent()->getParent();
-      LLVMContext &Ctx = F->getContext();
-      emitOptimizationRemark(
-          Ctx, DEBUG_TYPE, *F, DLoc,
-          Twine("Applied ") + Twine(*R) +
-              " samples from profile (offset: " + Twine(LineOffset) +
-              ((Discriminator) ? Twine(".") + Twine(Discriminator) : "") + ")");
+      ORE.emit(OptimizationRemark(DEBUG_TYPE, "AppliedSamples", &Inst)
+               << "Applied " << Twine(*R).str()
+               << " samples from profile (offset: " << Twine(LineOffset).str()
+               << ((Discriminator) ? "." + Twine(Discriminator).str() : "") +
+                      ")");
     }
     DEBUG(dbgs() << "    " << DLoc.getLine() << "."
                  << DIL->getBaseDiscriminator() << ":" << Inst
                  << " (line offset: " << LineOffset << "."
                  << DIL->getBaseDiscriminator() << " - weight: " << R.get()
                  << ")\n");
   }
   return R;
 }
 
 /// \brief Compute the weight of a basic block.
 ///
 /// The weight of basic block \p BB is the maximum weight of all the
 /// instructions in BB.
 ///
 /// \param BB The basic block to query.
 ///
 /// \returns the weight for \p BB.
-ErrorOr<uint64_t> SampleProfileLoader::getBlockWeight(const BasicBlock *BB) {
+ErrorOr<uint64_t>
+SampleProfileLoader::getBlockWeight(const BasicBlock *BB,
+                                    OptimizationRemarkEmitter &ORE) {
   uint64_t Max = 0;
   bool HasWeight = false;
   for (auto &I : BB->getInstList()) {
-    const ErrorOr<uint64_t> &R = getInstWeight(I);
+    const ErrorOr<uint64_t> &R = getInstWeight(I, ORE);
     if (R) {
       Max = std::max(Max, R.get());
       HasWeight = true;
     }
   }
   return HasWeight ? ErrorOr<uint64_t>(Max) : std::error_code();
 }
 
 /// \brief Compute and store the weights of every basic block.
 ///
 /// This populates the BlockWeights map by computing
 /// the weights of every basic block in the CFG.
 ///
 /// \param F The function to query.
-bool SampleProfileLoader::computeBlockWeights(Function &F) {
+bool SampleProfileLoader::computeBlockWeights(Function &F,
+                                              OptimizationRemarkEmitter &ORE) {
   bool Changed = false;
   DEBUG(dbgs() << "Block weights\n");
   for (const auto &BB : F) {
-    ErrorOr<uint64_t> Weight = getBlockWeight(&BB);
+    ErrorOr<uint64_t> Weight = getBlockWeight(&BB, ORE);
     if (Weight) {
       BlockWeights[&BB] = Weight.get();
       VisitedBlocks.insert(&BB);
       Changed = true;
     }
     DEBUG(printBlockWeight(dbgs(), &BB));
   }
 

 /// it to direct call. Each indirect call is limited with a single target.
 ///
 /// \param F function to perform iterative inlining.
 /// \param ImportGUIDs a set to be updated to include all GUIDs that come
 ///     from a different module but inlined in the profiled binary.
 ///
 /// \returns True if there is any inline happened.
 bool SampleProfileLoader::inlineHotFunctions(
-    Function &F, DenseSet<GlobalValue::GUID> &ImportGUIDs) {
+    Function &F, DenseSet<GlobalValue::GUID> &ImportGUIDs,
+    OptimizationRemarkEmitter &ORE) {
   DenseSet<Instruction *> PromotedInsns;
   bool Changed = false;
-  LLVMContext &Ctx = F.getContext();
-  std::function<AssumptionCache &(Function &)> GetAssumptionCache = [&](
-      Function &F) -> AssumptionCache & { return ACT->getAssumptionCache(F); };
+  std::function<AssumptionCache &(Function &)> GetAssumptionCache =
+      [&](Function &F) -> AssumptionCache & {
+    return ACT->getAssumptionCache(F);
+  };
   while (true) {
     bool LocalChanged = false;
     SmallVector<Instruction *, 10> CIS;
     for (auto &BB : F) {
       bool Hot = false;
       SmallVector<Instruction *, 10> Candidates;
       for (auto &I : BB.getInstList()) {
         const FunctionSamples *FS = nullptr;
for (auto I : CIS) {
             continue;
           CalledFunction = R->getValue();
           if (CalledFunction && isLegalToPromote(I, CalledFunction, &Reason)) {
             // The indirect target was promoted and inlined in the profile, as a
             // result, we do not have profile info for the branch probability.
             // We set the probability to 80% taken to indicate that the static
             // call is likely taken.
             DI = dyn_cast<Instruction>(
                 promoteIndirectCall(I, CalledFunction, 80, 100, false)
                     ->stripPointerCasts());
             PromotedInsns.insert(I);
           } else {
             DEBUG(dbgs() << "\nFailed to promote indirect call to "
                          << CalleeFunctionName << " because " << Reason
                          << "\n");
             continue;
           }
         }
       if (!CalledFunction || !CalledFunction->getSubprogram()) {
         findCalleeFunctionSamples(*I)->findImportedFunctions(
             ImportGUIDs, F.getParent(),
             Samples->getTotalSamples() * SampleProfileHotThreshold / 100);
         continue;
       }
       DebugLoc DLoc = I->getDebugLoc();
+      BasicBlock *BB = I->getParent();
       if (InlineFunction(CallSite(DI), IFI)) {
         LocalChanged = true;
-        emitOptimizationRemark(Ctx, DEBUG_TYPE, F, DLoc,
-                               Twine("inlined hot callee '") +
-                                   CalledFunction->getName() + "' into '" +
-                                   F.getName() + "'");
+        ORE.emit(OptimizationRemark(DEBUG_TYPE, "HotInline", DLoc, BB)
+                 << "inlined hot callee '" << CalledFunction->getName().str()
+                 << "' into '" << F.getName() << "'");
       }
     }
     if (LocalChanged) {
       Changed = true;
     } else {
       break;
     }
   }

 ///   edge will be the weight of the block minus the sum of all the known
 ///   edges. If the sum of all the known edges is larger than BB's weight,
 ///   we set the unknown edge weight to zero.
 ///
 /// - If there is a self-referential edge, and the weight of the block is
 ///   known, the weight for that edge is set to the weight of the block
 ///   minus the weight of the other incoming edges to that block (if
 ///   known).
-void SampleProfileLoader::propagateWeights(Function &F) {
+void SampleProfileLoader::propagateWeights(Function &F,
+                                           OptimizationRemarkEmitter &ORE) {
   bool Changed = true;
   unsigned I = 0;
 
   // If BB weight is larger than its corresponding loop's header BB weight,
   // use the BB weight to replace the loop header BB weight.
   for (auto &BI : F) {
     BasicBlock *BB = &BI;
     Loop *L = LI->getLoopFor(BB);
for (auto &BI : F) {
 
     DebugLoc BranchLoc = TI->getDebugLoc();
     DEBUG(dbgs() << "\nGetting weights for branch at line "
                  << ((BranchLoc) ? Twine(BranchLoc.getLine())
                                  : Twine("<UNKNOWN LOCATION>"))
                  << ".\n");
     SmallVector<uint32_t, 4> Weights;
     uint32_t MaxWeight = 0;
-    DebugLoc MaxDestLoc;
+    Instruction *MaxDestInstr;
     for (unsigned I = 0; I < TI->getNumSuccessors(); ++I) {
       BasicBlock *Succ = TI->getSuccessor(I);
       Edge E = std::make_pair(BB, Succ);
       uint64_t Weight = EdgeWeights[E];
       DEBUG(dbgs() << "\t"; printEdgeWeight(dbgs(), E));
       // Use uint32_t saturated arithmetic to adjust the incoming weights,
       // if needed. Sample counts in profiles are 64-bit unsigned values,
       // but internally branch weights are expressed as 32-bit values.
       if (Weight > std::numeric_limits<uint32_t>::max()) {
         DEBUG(dbgs() << " (saturated due to uint32_t overflow)");
         Weight = std::numeric_limits<uint32_t>::max();
       }
       // Weight is added by one to avoid propagation errors introduced by
       // 0 weights.
       Weights.push_back(static_cast<uint32_t>(Weight + 1));
       if (Weight != 0) {
         if (Weight > MaxWeight) {
           MaxWeight = Weight;
-          MaxDestLoc = Succ->getFirstNonPHIOrDbgOrLifetime()->getDebugLoc();
+          MaxDestInstr = Succ->getFirstNonPHIOrDbgOrLifetime();
         }
       }
     }
 
     uint64_t TempWeight;
     // Only set weights if there is at least one non-zero weight.
     // In any other case, let the analyzer set weights.
     // Do not set weights if the weights are present. In ThinLTO, the profile
     // annotation is done twice. If the first annotation already set the
     // weights, the second pass does not need to set it.
     if (MaxWeight > 0 && !TI->extractProfTotalWeight(TempWeight)) {
       DEBUG(dbgs() << "SUCCESS. Found non-zero weights.\n");
       TI->setMetadata(llvm::LLVMContext::MD_prof,
                       MDB.createBranchWeights(Weights));
-      emitOptimizationRemark(
-          Ctx, DEBUG_TYPE, F, MaxDestLoc,
-          Twine("most popular destination for conditional branches at ") +
-              ((BranchLoc) ? Twine(BranchLoc->getFilename() + ":" +
+      ORE.emit(OptimizationRemark(DEBUG_TYPE, "PopularDest", MaxDestInstr)
+               << "most popular destination for conditional branches at "
+               << ((BranchLoc) ? Twine(BranchLoc->getFilename() + ":" +
                                        Twine(BranchLoc.getLine()) + ":" +
                                        Twine(BranchLoc.getCol()))
-                           : Twine("<UNKNOWN LOCATION>")));
+                                     .str()
+                               : Twine("<UNKNOWN LOCATION>").str()));
     } else {
       DEBUG(dbgs() << "SKIPPED. All branch weights are zero.\n");
     }
   }
 }
 
 /// \brief Get the line number for the function header.
 ///
 /// This looks up function \p F in the current compilation unit and
 /// retrieves the line number where the function is defined. This is
 /// line 0 for all the samples read from the profile file. Every line
 /// number is relative to this line.
 ///

 /// work here.
 ///
 /// Once all the branch weights are computed, we emit the MD_prof
 /// metadata on BB using the computed values for each of its branches.
 ///
 /// \param F The function to query.
 ///
 /// \returns true if \p F was modified. Returns false, otherwise.
-bool SampleProfileLoader::emitAnnotations(Function &F) {
+bool SampleProfileLoader::emitAnnotations(Function &F,
+                                          OptimizationRemarkEmitter &ORE) {
   bool Changed = false;
 
   if (getFunctionLoc(F) == 0)
     return false;
 
   DEBUG(dbgs() << "Line number for the first instruction in " << F.getName()
                << ": " << getFunctionLoc(F) << "\n");
 
   DenseSet<GlobalValue::GUID> ImportGUIDs;
-  Changed |= inlineHotFunctions(F, ImportGUIDs);
+  Changed |= inlineHotFunctions(F, ImportGUIDs, ORE);
 
   // Compute basic block weights.
-  Changed |= computeBlockWeights(F);
+  Changed |= computeBlockWeights(F, ORE);
 
   if (Changed) {
     // Add an entry count to the function using the samples gathered at the
     // function entry. Also sets the GUIDs that comes from a different
     // module but inlined in the profiled binary. This is aiming at making
     // the IR match the profiled binary before annotation.
     F.setEntryCount(Samples->getHeadSamples() + 1, &ImportGUIDs);
 
     // Compute dominance and loop info needed for propagation.
     computeDominanceAndLoopInfo(F);
 
     // Find equivalence classes.
     findEquivalenceClasses(F);
 
     // Propagate weights to all edges.
-    propagateWeights(F);
+    propagateWeights(F, ORE);
   }
 
   // If coverage checking was requested, compute it now.
   if (SampleProfileRecordCoverage) {
     unsigned Used = CoverageTracker.countUsedRecords(Samples);
     unsigned Total = CoverageTracker.countBodyRecords(Samples);
     unsigned Coverage = CoverageTracker.computeCoverage(Used, Total);
     if (Coverage < SampleProfileRecordCoverage) {

 ModulePass *llvm::createSampleProfileLoaderPass() {
   return new SampleProfileLoaderLegacyPass(SampleProfileFile);
 }
 
 ModulePass *llvm::createSampleProfileLoaderPass(StringRef Name) {
   return new SampleProfileLoaderLegacyPass(Name);
 }
 
 bool SampleProfileLoader::runOnModule(Module &M) {
   if (!ProfileIsValid)
     return false;
 
   // Compute the total number of samples collected in this profile.
   for (const auto &I : Reader->getProfiles())
     TotalCollectedSamples += I.second.getTotalSamples();
 
   // Populate the symbol map.

 
 bool SampleProfileLoaderLegacyPass::runOnModule(Module &M) {
   // FIXME: pass in AssumptionCache correctly for the new pass manager.
   SampleLoader.setACT(&getAnalysis<AssumptionCacheTracker>());
   return SampleLoader.runOnModule(M);
 }
 
 bool SampleProfileLoader::runOnFunction(Function &F) {
+  OptimizationRemarkEmitter ORE(&F);
   F.setEntryCount(0);
   Samples = Reader->getSamplesFor(F);
   if (Samples && !Samples->empty())
-    return emitAnnotations(F);
+    return emitAnnotations(F, ORE);
   return false;
 }
 
 PreservedAnalyses SampleProfileLoaderPass::run(Module &M,
                                                ModuleAnalysisManager &AM) {
 
-  SampleProfileLoader SampleLoader(
-      ProfileFileName.empty() ? SampleProfileFile : ProfileFileName);
+  SampleProfileLoader SampleLoader(ProfileFileName.empty() ? SampleProfileFile
+                                                           : ProfileFileName);
 
   SampleLoader.doInitialization(M);
 
   if (!SampleLoader.runOnModule(M))
     return PreservedAnalyses::all();
 
   return PreservedAnalyses::none();
 }

test/Transforms/SampleProfile/remarks.ll

-; RUN: opt < %s -sample-profile -sample-profile-file=%S/Inputs/remarks.prof -S -pass-remarks=sample-profile 2>&1 | FileCheck %s
+; RUN: opt < %s -sample-profile -sample-profile-file=%S/Inputs/remarks.prof -S -pass-remarks=sample-profile -pass-remarks-output=%t.opt.yaml 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/remarks.prof -S -pass-remarks=sample-profile 2>&1 | FileCheck %s
-;
+; RUN: cat %t.opt.yaml | FileCheck %s -check-prefix=YAML
 ; Original test case.
 ;
 ;     1    #include <stdlib.h>
 ;     2
 ;     3    long long foo() {
 ;     4      long long int sum = 0;
 ;     5      for (int i = 0; i < 500000000; i++)
 ;     6        if (i < 1000)

 ; CHECK: remark: remarks.cc:13:21: inlined hot callee '_Z3foov' into 'main'
 
 ; The back edge for the loop is the hottest edge in the loop subgraph.
 ; CHECK: remark: remarks.cc:6:9: most popular destination for conditional branches at remarks.cc:5:3
 
 ; The predicate almost always chooses the 'else' branch.
 ; CHECK: remark: remarks.cc:9:15: most popular destination for conditional branches at remarks.cc:6:9
 
+; Checking to see if YAML file is generated and contains remarks
+; YAML:  --- !Passed
+; YAML:  Pass:            sample-profile
+; YAML:  Name:            HotInline
+; YAML:  --- !Passed
+; YAML:  Pass:            sample-profile
+; YAML:  Name:            AppliedSamples
+; YAML:  --- !Passed
+; YAML:  Pass:            sample-profile
+; YAML:  Name:            PopularDest
+
 ; Function Attrs: nounwind uwtable
 define i64 @_Z3foov() #0 !dbg !4 {
 entry:
   %sum = alloca i64, align 8
   %i = alloca i32, align 4
   %0 = bitcast i64* %sum to i8*, !dbg !19
   call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #4, !dbg !19
   call void @llvm.dbg.declare(metadata i64* %sum, metadata !9, metadata !20), !dbg !21