Analysis pass to access profile summary info

[eraman]

Summary

This analysis provides access to the profile summary information. This is a WIP and the interface will change as we have more clients using it. The immediate task is to get the inline cost analysis to use the isHotFunction/isColdFunction interfaces here and remove the MaxFunctionCount annotation at the module.

[davidxl]

include/llvm/Analysis/ProfileSummaryInfo.h

85 ↗

(On Diff #58527)

Are those ctors/ assignment operators needed? The result type needs the rvalue ctors for data moving.

92 ↗

(On Diff #58527)

Return 'Result'

100 ↗

(On Diff #58527)

Nit : ProfileSummaryPrinterPass?

lib/Analysis/ProfileSummaryInfo.cpp

45 ↗

(On Diff #58527)

typo.

65 ↗

(On Diff #58527)

Should define a enum : SUMMARY_hot, _cold, _unknown (or noprofile)

We probably also need another interface in the future to check body hotness.

79 ↗

(On Diff #58527)

Merge with above and make it 'getFunctionHotness' ?

106 ↗

(On Diff #58527)

Document with FIXME that the hotness determination here is different from function hotness logic above.

[eraman]

include/llvm/Analysis/ProfileSummaryInfo.h

85 ↗

(On Diff #58527)

This boilerplate code is found in many places. For example, see AssumptionAnalysis which also doesn't have any data members has this. From comments elsewhere, not specifying these breaks in MSVC (search for MSVC under include/llvm/Analysis)

100 ↗

(On Diff #58527)

I thought FunctionHotnessPrinterPass accurately reflects what this is doing. I have no strong opinion - will change it to ProfileSummaryPrinterPass if you prefer.

lib/Analysis/ProfileSummaryInfo.cpp

65 ↗

(On Diff #58527)

I feel separate isHotX and isColdX is better. You anyway have to check the return value of the enum and the implementation has the combined code of isHotX and isColdX. But if you insist on unifying them, do you have any suggestion for "neither hot nor cold"? Unknown is not the right value.

106 ↗

(On Diff #58527)

The fixme is in the is{Hot|Cold}Function since that is the one that needs to be fixed.

[davidxl]

include/llvm/Analysis/ProfileSummaryInfo.h

85 ↗

(On Diff #58527)

ok.

lib/Analysis/ProfileSummaryInfo.cpp

65 ↗

(On Diff #58527)

Ok -- document that when returns false, it either means it is not hot or we don't have info to tell.

106 ↗

(On Diff #58527)

ok

[eraman]

Address David's comments

[davidxl]

lgtm

[vsk]

Sorry for the delay. I have some preliminary comments, I'll take a closer look in a second.

lib/Analysis/ProfileSummaryInfo.cpp

34 ↗

(On Diff #58829)

I'm a bit confused as to why this is higher than the percentile for hot functions. Sorry if this is a basic question! Could you explain this a bit?

44 ↗

(On Diff #58829)

Why not a lower_bound? That should be faster, and it adds a bit of flexibility, I think.

47 ↗

(On Diff #58829)

Could you add an error string to this assert?

[davidxl]

lib/Analysis/ProfileSummaryInfo.cpp

34 ↗

(On Diff #58829)

Higher percentile means that more (colder) blocks are covered in the accumulative sum -- the higher the percentile, the colder the threshold.

[vsk]

Ah ok, I think I understand the *CountPercentiles now. Just two more nits.

lib/Passes/PassBuilder.cpp

71 ↗

(On Diff #58829)

This change should be left out of this patch.

test/Analysis/ProfileSummary/basic.ll

5 ↗

(On Diff #58829)

It doesn't seem like the contents of these function bodies affect the test. Could you minimize them?

[eraman]

I'll address the rest of your comments and update the patch

lib/Analysis/ProfileSummaryInfo.cpp

44 ↗

(On Diff #58829)

If we want the flexibility of not specifying an exact percentile, won't nearest entry (minimum difference) be better than lower_bound?

[vsk]

lib/Analysis/ProfileSummaryInfo.cpp

44 ↗

(On Diff #58829)

ISTM that breaks the function's contract. It would no longer always return the minimum execution count for a given percentile: it could return something greater.

[silvas]

This LGTM with some nits.

include/llvm/Analysis/ProfileSummaryInfo.h

100 ↗

(On Diff #58527)

I think if we change ProfileSummaryAnalysis to have more predicates, we would want to extend this pass (e.g. we use it for testing), so ProfileSummaryPrinterPass seems a bit better (but it is just a nit).

lib/Analysis/ProfileSummaryInfo.cpp

29 ↗

(On Diff #58527)

If the name is "percentile", I would expect it to be out of 100, but instead it is out of 1,000,000 which is confusing.
Since we require it to be one of the cutoffs in the profile summary, I would call it "profile-summary-cutoff" or similar.

34 ↗

(On Diff #58527)

Sorry if I'm missing something obvious, but why is the cold percentile nearly 1,000,000? Wouldn't that mark almost everything as cold?
I.e. I would expect that ColdCountPercentile must be less than HotCountPercentile.

47 ↗

(On Diff #58527)

This assertion can be triggered from the command line and is therefore not a correct assertion. Since this is not an option meant to be exposed directly to users (-mllvm is technical an "internal compiler flag"), I think that using report_fatal_error here is appropriate.

138 ↗

(On Diff #58527)

You may want to mention that this isn't really a big deal since we are setting the function count directly in the test.

[eraman]

lib/Analysis/ProfileSummaryInfo.cpp

44 ↗

(On Diff #58829)

You're right. I've changed the code to use lower_bound

47 ↗

(On Diff #58829)

I've changed to report_fatal_error as suggested by Sean

139 ↗

(On Diff #58829)

Sorry, I don't understand this comment. Irrespective of how we set the function entry count, the issue is we are not testing the isHotCount and isColdCount code.

[eraman]

Address comments and rebase

llvm/trunk/include/llvm/Analysis/ProfileSummaryInfo.h

+//===- llvm/Analysis/ProfileSummaryInfo.h - profile summary ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains a pass that provides access to profile summary
+// information.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
+#define LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/ProfileSummary.h"
+#include "llvm/IR/ValueHandle.h"
+#include "llvm/Pass.h"
+#include <memory>
+
+namespace llvm {
+class ProfileSummary;
+/// \brief Analysis providing profile information.
+///
+/// This is an immutable analysis pass that provides ability to query global
+/// (program-level) profile information. The main APIs are isHotCount and
+/// isColdCount that tells whether a given profile count is considered hot/cold
+/// based on the profile summary. This also provides convenience methods to
+/// check whether a function is hot or cold.
+
+// FIXME: Provide convenience methods to determine hotness/coldness of other IR
+// units. This would require making this depend on BFI.
+class ProfileSummaryInfo {
+private:
+  Module &M;
+  std::unique_ptr<ProfileSummary> Summary;
+  void computeSummary();
+  void computeThresholds();
+  // Count thresholds to answer isHotCount and isColdCount queries.
+  Optional<uint64_t> HotCountThreshold, ColdCountThreshold;
+
+public:
+  ProfileSummaryInfo(Module &M) : M(M) {}
+  /// \brief Returns true if \p F is a hot function.
+  bool isHotFunction(const Function *F);
+  /// \brief Returns true if \p F is a cold function.
+  bool isColdFunction(const Function *F);
+  /// \brief Returns true if count \p C is considered hot.
+  bool isHotCount(uint64_t C);
+  /// \brief Returns true if count \p C is considered cold.
+  bool isColdCount(uint64_t C);
+};
+
+/// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
+class ProfileSummaryInfoWrapperPass : public ImmutablePass {
+  std::unique_ptr<ProfileSummaryInfo> PSI;
+
+public:
+  static char ID;
+  ProfileSummaryInfoWrapperPass();
+
+  ProfileSummaryInfo *getPSI(Module &M);
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+};
+
+/// An analysis pass based on the new PM to deliver ProfileSummaryInfo.
+class ProfileSummaryAnalysis
+    : public AnalysisInfoMixin<ProfileSummaryAnalysis> {
+public:
+  typedef ProfileSummaryInfo Result;
+
+  ProfileSummaryAnalysis() {}
+  ProfileSummaryAnalysis(const ProfileSummaryAnalysis &Arg) {}
+  ProfileSummaryAnalysis(ProfileSummaryAnalysis &&Arg) {}
+  ProfileSummaryAnalysis &operator=(const ProfileSummaryAnalysis &RHS) {
+    return *this;
+  }
+  ProfileSummaryAnalysis &operator=(ProfileSummaryAnalysis &&RHS) {
+    return *this;
+  }
+
+  Result run(Module &M);
+
+private:
+  friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
+  static char PassID;
+};
+
+/// \brief Printer pass that uses \c ProfileSummaryAnalysis.
+class ProfileSummaryPrinterPass
+    : public PassInfoMixin<ProfileSummaryPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM);
+};
+
+} // end namespace llvm
+
+#endif

llvm/trunk/include/llvm/InitializePasses.h

 void initializePostOrderFunctionAttrsLegacyPassPass(PassRegistry&);
 void initializePostRAHazardRecognizerPass(PassRegistry&);
 void initializePostRASchedulerPass(PassRegistry&);
 void initializePostMachineSchedulerPass(PassRegistry&);
 void initializePreISelIntrinsicLoweringPass(PassRegistry&);
 void initializePrintFunctionPassWrapperPass(PassRegistry&);
 void initializePrintModulePassWrapperPass(PassRegistry&);
 void initializePrintBasicBlockPassPass(PassRegistry&);
+void initializeProfileSummaryInfoWrapperPassPass(PassRegistry &);
 void initializeProcessImplicitDefsPass(PassRegistry&);
 void initializePromotePassPass(PassRegistry&);
 void initializePruneEHPass(PassRegistry&);
 void initializeReassociateLegacyPassPass(PassRegistry&);
 void initializeRegBankSelectPass(PassRegistry &);
 void initializeRegToMemPass(PassRegistry&);
 void initializeRegionInfoPassPass(PassRegistry&);
 void initializeRegionOnlyPrinterPass(PassRegistry&);

llvm/trunk/lib/Analysis/CMakeLists.txt

add_llvm_library(LLVMAnalysis
   ModuleDebugInfoPrinter.cpp
   ModuleSummaryAnalysis.cpp
   ObjCARCAliasAnalysis.cpp
   ObjCARCAnalysisUtils.cpp
   ObjCARCInstKind.cpp
   OrderedBasicBlock.cpp
   PHITransAddr.cpp
   PostDominators.cpp
+  ProfileSummaryInfo.cpp
   PtrUseVisitor.cpp
   RegionInfo.cpp
   RegionPass.cpp
   RegionPrinter.cpp
   ScalarEvolution.cpp
   ScalarEvolutionAliasAnalysis.cpp
   ScalarEvolutionExpander.cpp
   ScalarEvolutionNormalization.cpp

llvm/trunk/lib/Analysis/ProfileSummaryInfo.cpp

+//===- ProfileSummaryInfo.cpp - Global profile summary information --------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains a pass that provides access to the global profile summary
+// information.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/IR/Metadata.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/ProfileSummary.h"
+using namespace llvm;
+
+// The following two parameters determine the threshold for a count to be
+// considered hot/cold. These two parameters are percentile values (multiplied
+// by 10000). If the counts are sorted in descending order, the minimum count to
+// reach ProfileSummaryCutoffHot gives the threshold to determine a hot count.
+// Similarly, the minimum count to reach ProfileSummaryCutoffCold gives the
+// threshold for determining cold count (everything <= this threshold is
+// considered cold).
+
+static cl::opt<int> ProfileSummaryCutoffHot(
+    "profile-summary-cutoff-hot", cl::Hidden, cl::init(999000), cl::ZeroOrMore,
+    cl::desc("A count is hot if it exceeds the minimum count to"
+             " reach this percentile of total counts."));
+
+static cl::opt<int> ProfileSummaryCutoffCold(
+    "profile-summary-cutoff-cold", cl::Hidden, cl::init(999999), cl::ZeroOrMore,
+    cl::desc("A count is cold if it is below the minimum count"
+             " to reach this percentile of total counts."));
+
+// Find the minimum count to reach a desired percentile of counts.
+static uint64_t getMinCountForPercentile(SummaryEntryVector &DS,
+                                         uint64_t Percentile) {
+  auto Compare = [](const ProfileSummaryEntry &Entry, uint64_t Percentile) {
+    return Entry.Cutoff < Percentile;
+  };
+  auto It = std::lower_bound(DS.begin(), DS.end(), Percentile, Compare);
+  // The required percentile has to be <= one of the percentiles in the
+  // detailed summary.
+  if (It == DS.end())
+    report_fatal_error("Desired percentile exceeds the maximum cutoff");
+  return It->MinCount;
+}
+
+// The profile summary metadata may be attached either by the frontend or by
+// any backend passes (IR level instrumentation, for example). This method
+// checks if the Summary is null and if so checks if the summary metadata is now
+// available in the module and parses it to get the Summary object.
+void ProfileSummaryInfo::computeSummary() {
+  if (Summary)
+    return;
+  auto *SummaryMD = M.getProfileSummary();
+  if (!SummaryMD)
+    return;
+  Summary.reset(ProfileSummary::getFromMD(SummaryMD));
+}
+
+// Returns true if the function is a hot function. If it returns false, it
+// either means it is not hot or it is unknown whether F is hot or not (for
+// example, no profile data is available).
+bool ProfileSummaryInfo::isHotFunction(const Function *F) {
+  computeSummary();
+  if (!F || !Summary)
+    return false;
+  auto FunctionCount = F->getEntryCount();
+  // FIXME: The heuristic used below for determining hotness is based on
+  // preliminary SPEC tuning for inliner. This will eventually be a
+  // convenience method that calls isHotCount.
+  return (FunctionCount &&
+          FunctionCount.getValue() >=
+              (uint64_t)(0.3 * (double)Summary->getMaxFunctionCount()));
+}
+
+// Returns true if the function is a cold function. If it returns false, it
+// either means it is not cold or it is unknown whether F is cold or not (for
+// example, no profile data is available).
+bool ProfileSummaryInfo::isColdFunction(const Function *F) {
+  computeSummary();
+  if (F->hasFnAttribute(Attribute::Cold)) {
+    return true;
+  }
+  auto FunctionCount = F->getEntryCount();
+  // FIXME: The heuristic used below for determining coldness is based on
+  // preliminary SPEC tuning for inliner. This will eventually be a
+  // convenience method that calls isHotCount.
+  return (FunctionCount &&
+          FunctionCount.getValue() <=
+              (uint64_t)(0.01 * (double)Summary->getMaxFunctionCount()));
+}
+
+// Compute the hot and cold thresholds.
+void ProfileSummaryInfo::computeThresholds() {
+  if (!Summary)
+    computeSummary();
+  if (!Summary)
+    return;
+  auto &DetailedSummary = Summary->getDetailedSummary();
+  HotCountThreshold =
+      getMinCountForPercentile(DetailedSummary, ProfileSummaryCutoffHot);
+  ColdCountThreshold =
+      getMinCountForPercentile(DetailedSummary, ProfileSummaryCutoffCold);
+}
+
+bool ProfileSummaryInfo::isHotCount(uint64_t C) {
+  if (!HotCountThreshold)
+    computeThresholds();
+  return HotCountThreshold && C >= HotCountThreshold.getValue();
+}
+
+bool ProfileSummaryInfo::isColdCount(uint64_t C) {
+  if (!ColdCountThreshold)
+    computeThresholds();
+  return ColdCountThreshold && C <= ColdCountThreshold.getValue();
+}
+
+ProfileSummaryInfo *ProfileSummaryInfoWrapperPass::getPSI(Module &M) {
+  if (!PSI)
+    PSI.reset(new ProfileSummaryInfo(M));
+  return PSI.get();
+}
+
+INITIALIZE_PASS(ProfileSummaryInfoWrapperPass, "profile-summary-info",
+                "Profile summary info", false, true)
+
+ProfileSummaryInfoWrapperPass::ProfileSummaryInfoWrapperPass()
+    : ImmutablePass(ID) {
+  initializeProfileSummaryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
+}
+
+char ProfileSummaryAnalysis::PassID;
+ProfileSummaryInfo ProfileSummaryAnalysis::run(Module &M) {
+  return ProfileSummaryInfo(M);
+}
+
+// FIXME: This only tests isHotFunction and isColdFunction and not the
+// isHotCount and isColdCount calls.
+PreservedAnalyses ProfileSummaryPrinterPass::run(Module &M,
+                                                 AnalysisManager<Module> &AM) {
+  ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M);
+
+  OS << "Functions in " << M.getName() << " with hot/cold annotations: \n";
+  for (auto &F : M) {
+    OS << F.getName();
+    if (PSI.isHotFunction(&F))
+      OS << " :hot ";
+    else if (PSI.isColdFunction(&F))
+      OS << " :cold ";
+    OS << "\n";
+  }
+  return PreservedAnalyses::all();
+}
+
+char ProfileSummaryInfoWrapperPass::ID = 0;

llvm/trunk/lib/IR/ProfileSummary.cpp

for (auto &&MDOp : EntriesMD->operands()) {
     Summary.emplace_back(cast<ConstantInt>(Op0->getValue())->getZExtValue(),
                          cast<ConstantInt>(Op1->getValue())->getZExtValue(),
                          cast<ConstantInt>(Op2->getValue())->getZExtValue());
   }
   return true;
 }
 
 ProfileSummary *ProfileSummary::getFromMD(Metadata *MD) {
+  if (!MD)
+    return nullptr;
   if (!isa<MDTuple>(MD))
     return nullptr;
   MDTuple *Tuple = cast<MDTuple>(MD);
   if (Tuple->getNumOperands() != 8)
     return nullptr;
 
   auto &FormatMD = Tuple->getOperand(0);
   ProfileSummary::Kind SummaryKind;

llvm/trunk/lib/Passes/PassBuilder.cpp

 #include "llvm/Analysis/DemandedBits.h"
 #include "llvm/Analysis/DependenceAnalysis.h"
 #include "llvm/Analysis/DominanceFrontier.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/MemoryDependenceAnalysis.h"
 #include "llvm/Analysis/PostDominators.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
 #include "llvm/Analysis/ScopedNoAliasAA.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/IR/Dominators.h"

 #include "llvm/Transforms/InstrProfiling.h"
 #include "llvm/Transforms/PGOInstrumentation.h"
 #include "llvm/Transforms/SampleProfile.h"
 #include "llvm/Transforms/Scalar/ADCE.h"
 #include "llvm/Transforms/Scalar/BDCE.h"
 #include "llvm/Transforms/Scalar/DCE.h"
 #include "llvm/Transforms/Scalar/DeadStoreElimination.h"
 #include "llvm/Transforms/Scalar/EarlyCSE.h"
-#include "llvm/Transforms/Scalar/GVN.h"
 #include "llvm/Transforms/Scalar/GuardWidening.h"
+#include "llvm/Transforms/Scalar/GVN.h"
 #include "llvm/Transforms/Scalar/LoopRotation.h"
 #include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
 #include "llvm/Transforms/Scalar/LowerAtomic.h"
 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
 #include "llvm/Transforms/Scalar/Reassociate.h"
 #include "llvm/Transforms/Scalar/SCCP.h"
 #include "llvm/Transforms/Scalar/SROA.h"

llvm/trunk/lib/Passes/PassRegistry.def

 // NOTE: NO INCLUDE GUARD DESIRED!
 
 #ifndef MODULE_ANALYSIS
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)
 #endif
 MODULE_ANALYSIS("callgraph", CallGraphAnalysis())
 MODULE_ANALYSIS("lcg", LazyCallGraphAnalysis())
 MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis())
+MODULE_ANALYSIS("profile-summary", ProfileSummaryAnalysis())
 MODULE_ANALYSIS("targetlibinfo", TargetLibraryAnalysis())
 MODULE_ANALYSIS("verify", VerifierAnalysis())
 
 #ifndef MODULE_ALIAS_ANALYSIS
 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)                             \
   MODULE_ANALYSIS(NAME, CREATE_PASS)
 #endif
 MODULE_ALIAS_ANALYSIS("globals-aa", GlobalsAA())

 MODULE_PASS("internalize", InternalizePass())
 MODULE_PASS("instrprof", InstrProfiling())
 MODULE_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 MODULE_PASS("ipsccp", IPSCCPPass())
 MODULE_PASS("no-op-module", NoOpModulePass())
 MODULE_PASS("pgo-icall-prom", PGOIndirectCallPromotion())
 MODULE_PASS("pgo-instr-gen", PGOInstrumentationGen())
 MODULE_PASS("pgo-instr-use", PGOInstrumentationUse())
-MODULE_PASS("print", PrintModulePass(dbgs()))
+MODULE_PASS("print-profile-summary", ProfileSummaryPrinterPass(dbgs()))
 MODULE_PASS("print-callgraph", CallGraphPrinterPass(dbgs()))
+MODULE_PASS("print", PrintModulePass(dbgs()))
 MODULE_PASS("print-lcg", LazyCallGraphPrinterPass(dbgs()))
 MODULE_PASS("sample-profile", SampleProfileLoaderPass())
 MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass())
 MODULE_PASS("verify", VerifierPass())
 #undef MODULE_PASS
 
 #ifndef CGSCC_ANALYSIS
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)

llvm/trunk/test/Analysis/ProfileSummary/basic.ll

+; RUN: opt < %s -disable-output -passes=print-profile-summary -S 2>&1 | FileCheck %s
+
+define void @f1() !prof !20 {
+; CHECK-LABEL: f1 :hot
+
+  ret void
+}
+
+define void @f2() !prof !21 {
+; CHECK-LABEL: f2 :cold
+
+  ret void
+}
+
+define void @f3() !prof !22 {
+; CHECK-LABEL: f3
+
+  ret void
+}
+
+!llvm.module.flags = !{!1}
+!20 = !{!"function_entry_count", i64 400}
+!21 = !{!"function_entry_count", i64 1}
+!22 = !{!"function_entry_count", i64 100}
+
+!1 = !{i32 1, !"ProfileSummary", !2}
+!2 = !{!3, !4, !5, !6, !7, !8, !9, !10}
+!3 = !{!"ProfileFormat", !"InstrProf"}
+!4 = !{!"TotalCount", i64 10000}
+!5 = !{!"MaxCount", i64 10}
+!6 = !{!"MaxInternalCount", i64 1}
+!7 = !{!"MaxFunctionCount", i64 1000}
+!8 = !{!"NumCounts", i64 3}
+!9 = !{!"NumFunctions", i64 3}
+!10 = !{!"DetailedSummary", !11}
+!11 = !{!12, !13, !14}
+!12 = !{i32 10000, i64 100, i32 1}
+!13 = !{i32 999000, i64 100, i32 1}
+!14 = !{i32 999999, i64 1, i32 2}