[PSI] Add the isCold query support with a given percentile value.

[hjyamauchi]

Summary

This follows up D67377 that added the isHot side.

[hjyamauchi]

This is split from an upcoming PGSO patch that uses this.

[davidxl]

I think it is possible to templatize the implementation to share implementation with isHot... interfaces.

[hjyamauchi]

Which functions are you referring to to be templatized?

[davidxl]

For each isColdNthPercentil, there is a counter part in Hot -- the pair share mostly the same code and can be templatized.

[hjyamauchi]

Done. PTAL.

[davidxl]

lgtm

[thakis]

This broke check-lld on my linux bot: http://45.33.8.238/linux/11645/step_11.txt

Does that error make sense to you? Or do you think it's more likely that it's a bot problem?

[thakis]

The error went away after a clean build, so I think it's unrelated to this change. Sorry for the noise!

llvm/include/llvm/Analysis/ProfileSummaryInfo.h

public:
   bool isFunctionEntryCold(const Function *F);
   /// Returns true if \p F contains only cold code.
   bool isFunctionColdInCallGraph(const Function *F, BlockFrequencyInfo &BFI);
   /// Returns true if \p F contains hot code with regard to a given hot
   /// percentile cutoff value.
   bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff,
                                              const Function *F,
                                              BlockFrequencyInfo &BFI);
+  /// Returns true if \p F contains cold code with regard to a given cold
+  /// percentile cutoff value.
+  bool isFunctionColdInCallGraphNthPercentile(int PercentileCutoff,
+                                              const Function *F,
+                                              BlockFrequencyInfo &BFI);
   /// Returns true if count \p C is considered hot.
   bool isHotCount(uint64_t C);
   /// Returns true if count \p C is considered cold.
   bool isColdCount(uint64_t C);
   /// Returns true if count \p C is considered hot with regard to a given
   /// hot percentile cutoff value.
   bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C);
+  /// Returns true if count \p C is considered cold with regard to a given
+  /// cold percentile cutoff value.
+  bool isColdCountNthPercentile(int PercentileCutoff, uint64_t C);
   /// Returns true if BasicBlock \p BB is considered hot.
   bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI);
   /// Returns true if BasicBlock \p BB is considered cold.
   bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI);
   /// Returns true if BasicBlock \p BB is considered hot with regard to a given
   /// hot percentile cutoff value.
   bool isHotBlockNthPercentile(int PercentileCutoff,
                                const BasicBlock *BB, BlockFrequencyInfo *BFI);
+  /// Returns true if BasicBlock \p BB is considered cold with regard to a given
+  /// cold percentile cutoff value.
+  bool isColdBlockNthPercentile(int PercentileCutoff,
+                                const BasicBlock *BB, BlockFrequencyInfo *BFI);
   /// Returns true if CallSite \p CS is considered hot.
   bool isHotCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
   /// Returns true if Callsite \p CS is considered cold.
   bool isColdCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
   /// Returns HotCountThreshold if set. Recompute HotCountThreshold
   /// if not set.
   uint64_t getOrCompHotCountThreshold();
   /// Returns ColdCountThreshold if set. Recompute HotCountThreshold
   /// if not set.
   uint64_t getOrCompColdCountThreshold();
   /// Returns HotCountThreshold if set.
   uint64_t getHotCountThreshold() {
     return HotCountThreshold ? HotCountThreshold.getValue() : 0;
   }
   /// Returns ColdCountThreshold if set.
   uint64_t getColdCountThreshold() {
     return ColdCountThreshold ? ColdCountThreshold.getValue() : 0;
   }
+
+ private:
+  template<bool isHot>
+  bool isFunctionHotOrColdInCallGraphNthPercentile(int PercentileCutoff,
+                                                   const Function *F,
+                                                   BlockFrequencyInfo &BFI);
+  template<bool isHot>
+  bool isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C);
+  template<bool isHot>
+  bool isHotOrColdBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB,
+                                     BlockFrequencyInfo *BFI);
 };
 
 /// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
 class ProfileSummaryInfoWrapperPass : public ImmutablePass {
   std::unique_ptr<ProfileSummaryInfo> PSI;
 
 public:
   static char ID;

llvm/lib/Analysis/ProfileSummaryInfo.cpp

if (!isColdCount(TotalCallCount))
       return false;
   }
   for (const auto &BB : *F)
     if (!isColdBlock(&BB, &BFI))
       return false;
   return true;
 }
 
-// Like isFunctionHotInCallGraph but for a given cutoff.
-bool ProfileSummaryInfo::isFunctionHotInCallGraphNthPercentile(
+template<bool isHot>
+bool ProfileSummaryInfo::isFunctionHotOrColdInCallGraphNthPercentile(
     int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) {
   if (!F || !computeSummary())
     return false;
-  if (auto FunctionCount = F->getEntryCount())
-    if (isHotCountNthPercentile(PercentileCutoff, FunctionCount.getCount()))
+  if (auto FunctionCount = F->getEntryCount()) {
+    if (isHot &&
+        isHotCountNthPercentile(PercentileCutoff, FunctionCount.getCount()))
       return true;
-
+    if (!isHot &&
+        !isColdCountNthPercentile(PercentileCutoff, FunctionCount.getCount()))
+      return false;
+  }
   if (hasSampleProfile()) {
     uint64_t TotalCallCount = 0;
     for (const auto &BB : *F)
       for (const auto &I : BB)
         if (isa<CallInst>(I) || isa<InvokeInst>(I))
           if (auto CallCount = getProfileCount(&I, nullptr))
             TotalCallCount += CallCount.getValue();
-    if (isHotCountNthPercentile(PercentileCutoff, TotalCallCount))
+    if (isHot && isHotCountNthPercentile(PercentileCutoff, TotalCallCount))
       return true;
+    if (!isHot && !isColdCountNthPercentile(PercentileCutoff, TotalCallCount))
+      return false;
   }
-  for (const auto &BB : *F)
-    if (isHotBlockNthPercentile(PercentileCutoff, &BB, &BFI))
+  for (const auto &BB : *F) {
+    if (isHot && isHotBlockNthPercentile(PercentileCutoff, &BB, &BFI))
       return true;
+    if (!isHot && !isColdBlockNthPercentile(PercentileCutoff, &BB, &BFI))
       return false;
   }
+  return !isHot;
+}
+
+// Like isFunctionHotInCallGraph but for a given cutoff.
+bool ProfileSummaryInfo::isFunctionHotInCallGraphNthPercentile(
+    int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) {
+  return isFunctionHotOrColdInCallGraphNthPercentile<true>(
+      PercentileCutoff, F, BFI);
+}
+
+bool ProfileSummaryInfo::isFunctionColdInCallGraphNthPercentile(
+    int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) {
+  return isFunctionHotOrColdInCallGraphNthPercentile<false>(
+      PercentileCutoff, F, BFI);
+}
 
 /// Returns true if the function's entry is a cold. If it returns false, it
 /// either means it is not cold or it is unknown whether it is cold or not (for
 /// example, no profile data is available).
 bool ProfileSummaryInfo::isFunctionEntryCold(const Function *F) {
   if (!F)
     return false;
   if (F->hasFnAttribute(Attribute::Cold))

 }
 
 bool ProfileSummaryInfo::isColdCount(uint64_t C) {
   if (!ColdCountThreshold)
     computeThresholds();
   return ColdCountThreshold && C <= ColdCountThreshold.getValue();
 }
 
-bool ProfileSummaryInfo::isHotCountNthPercentile(int PercentileCutoff, uint64_t C) {
+template<bool isHot>
+bool ProfileSummaryInfo::isHotOrColdCountNthPercentile(int PercentileCutoff,
+                                                       uint64_t C) {
   auto CountThreshold = computeThreshold(PercentileCutoff);
+  if (isHot)
     return CountThreshold && C >= CountThreshold.getValue();
+  else
+    return CountThreshold && C <= CountThreshold.getValue();
+}
+
+bool ProfileSummaryInfo::isHotCountNthPercentile(int PercentileCutoff, uint64_t C) {
+  return isHotOrColdCountNthPercentile<true>(PercentileCutoff, C);
+}
+
+bool ProfileSummaryInfo::isColdCountNthPercentile(int PercentileCutoff, uint64_t C) {
+  return isHotOrColdCountNthPercentile<false>(PercentileCutoff, C);
 }
 
 uint64_t ProfileSummaryInfo::getOrCompHotCountThreshold() {
   if (!HotCountThreshold)
     computeThresholds();
   return HotCountThreshold ? HotCountThreshold.getValue() : UINT64_MAX;
 }
 

 }
 
 bool ProfileSummaryInfo::isColdBlock(const BasicBlock *BB,
                                   BlockFrequencyInfo *BFI) {
   auto Count = BFI->getBlockProfileCount(BB);
   return Count && isColdCount(*Count);
 }
 
-bool ProfileSummaryInfo::isHotBlockNthPercentile(int PercentileCutoff,
+template<bool isHot>
+bool ProfileSummaryInfo::isHotOrColdBlockNthPercentile(int PercentileCutoff,
                                                        const BasicBlock *BB,
                                                        BlockFrequencyInfo *BFI) {
   auto Count = BFI->getBlockProfileCount(BB);
+  if (isHot)
     return Count && isHotCountNthPercentile(PercentileCutoff, *Count);
+  else
+    return Count && isColdCountNthPercentile(PercentileCutoff, *Count);
+}
+
+bool ProfileSummaryInfo::isHotBlockNthPercentile(int PercentileCutoff,
+                                                 const BasicBlock *BB,
+                                                 BlockFrequencyInfo *BFI) {
+  return isHotOrColdBlockNthPercentile<true>(PercentileCutoff, BB, BFI);
+}
+
+bool ProfileSummaryInfo::isColdBlockNthPercentile(int PercentileCutoff,
+                                                  const BasicBlock *BB,
+                                                  BlockFrequencyInfo *BFI) {
+  return isHotOrColdBlockNthPercentile<false>(PercentileCutoff, BB, BFI);
 }
 
 bool ProfileSummaryInfo::isHotCallSite(const CallSite &CS,
                                        BlockFrequencyInfo *BFI) {
   auto C = getProfileCount(CS.getInstruction(), BFI);
   return C && isHotCount(*C);
 }
 

llvm/unittests/Analysis/ProfileSummaryInfoTest.cpp

const char *ModuleString =
         "  br label %bb3\n"
         "bb2:\n"
         "  %z2 = call i32 @h(i32 %x)\n"
         "  br label %bb3\n"
         "bb3:\n"
         "  %y2 = phi i32 [0, %bb1], [1, %bb2] \n"
         "  ret i32 %y2\n"
         "}\n"
+        "define i32 @l(i32 %x) {{\n"
+        "bb0:\n"
+        "  %y1 = icmp eq i32 %x, 0 \n"
+        "  br i1 %y1, label %bb1, label %bb2, !prof !23 \n"
+        "bb1:\n"
+        "  %z1 = call i32 @g(i32 %x)\n"
+        "  br label %bb3\n"
+        "bb2:\n"
+        "  %z2 = call i32 @h(i32 %x)\n"
+        "  br label %bb3\n"
+        "bb3:\n"
+        "  %y2 = phi i32 [0, %bb1], [1, %bb2] \n"
+        "  ret i32 %y2\n"
+        "}\n"
         "!20 = !{{!\"function_entry_count\", i64 400}\n"
         "!21 = !{{!\"function_entry_count\", i64 1}\n"
         "!22 = !{{!\"function_entry_count\", i64 100}\n"
         "!23 = !{{!\"branch_weights\", i32 64, i32 4}\n"
         "{0}";
     const char *SummaryString = "!llvm.module.flags = !{{!1}"
                                 "!1 = !{{i32 1, !\"ProfileSummary\", !2}"
                                 "!2 = !{{!3, !4, !5, !6, !7, !8, !9, !10}"
TEST_F(ProfileSummaryInfoTest, TestCommon) {
   EXPECT_TRUE(PSI.isColdCount(2));
   EXPECT_FALSE(PSI.isColdCount(100));
   EXPECT_FALSE(PSI.isHotCount(100));
 
   EXPECT_TRUE(PSI.isHotCountNthPercentile(990000, 400));
   EXPECT_FALSE(PSI.isHotCountNthPercentile(990000, 100));
   EXPECT_FALSE(PSI.isHotCountNthPercentile(990000, 2));
 
+  EXPECT_FALSE(PSI.isColdCountNthPercentile(990000, 400));
+  EXPECT_TRUE(PSI.isColdCountNthPercentile(990000, 100));
+  EXPECT_TRUE(PSI.isColdCountNthPercentile(990000, 2));
+
   EXPECT_TRUE(PSI.isHotCountNthPercentile(999999, 400));
   EXPECT_TRUE(PSI.isHotCountNthPercentile(999999, 100));
   EXPECT_FALSE(PSI.isHotCountNthPercentile(999999, 2));
 
+  EXPECT_FALSE(PSI.isColdCountNthPercentile(999999, 400));
+  EXPECT_FALSE(PSI.isColdCountNthPercentile(999999, 100));
+  EXPECT_TRUE(PSI.isColdCountNthPercentile(999999, 2));
+
   EXPECT_FALSE(PSI.isHotCountNthPercentile(10000, 400));
   EXPECT_FALSE(PSI.isHotCountNthPercentile(10000, 100));
   EXPECT_FALSE(PSI.isHotCountNthPercentile(10000, 2));
 
+  EXPECT_TRUE(PSI.isColdCountNthPercentile(10000, 400));
+  EXPECT_TRUE(PSI.isColdCountNthPercentile(10000, 100));
+  EXPECT_TRUE(PSI.isColdCountNthPercentile(10000, 2));
+
   EXPECT_TRUE(PSI.isFunctionEntryHot(F));
   EXPECT_FALSE(PSI.isFunctionEntryHot(G));
   EXPECT_FALSE(PSI.isFunctionEntryHot(H));
 }
 
 TEST_F(ProfileSummaryInfoTest, InstrProf) {
   auto M = makeLLVMModule("InstrProf");
   Function *F = M->getFunction("f");
TEST_F(ProfileSummaryInfoTest, InstrProf) {
   EXPECT_FALSE(PSI.isHotBlock(BB2, &BFI));
   EXPECT_TRUE(PSI.isHotBlock(BB3, &BFI));
 
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
 
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
+
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, &BB0, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB1, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB2, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB3, &BFI));
 
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, &BB0, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB1, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB2, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB3, &BFI));
+
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, &BB0, &BFI));
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB1, &BFI));
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB2, &BFI));
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB3, &BFI));
 
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, &BB0, &BFI));
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB1, &BFI));
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB2, &BFI));
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB3, &BFI));
+
   CallSite CS1(BB1->getFirstNonPHI());
   auto *CI2 = BB2->getFirstNonPHI();
   CallSite CS2(CI2);
 
   EXPECT_TRUE(PSI.isHotCallSite(CS1, &BFI));
   EXPECT_FALSE(PSI.isHotCallSite(CS2, &BFI));
 
   // Test that adding an MD_prof metadata with a hot count on CS2 does not
   // change its hotness as it has no effect in instrumented profiling.
   MDBuilder MDB(M->getContext());
   CI2->setMetadata(llvm::LLVMContext::MD_prof, MDB.createBranchWeights({400}));
   EXPECT_FALSE(PSI.isHotCallSite(CS2, &BFI));
 }
 
+TEST_F(ProfileSummaryInfoTest, InstrProfNoFuncEntryCount) {
+  auto M = makeLLVMModule("InstrProf");
+  Function *F = M->getFunction("l");
+  ProfileSummaryInfo PSI = buildPSI(M.get());
+  EXPECT_TRUE(PSI.hasProfileSummary());
+  EXPECT_TRUE(PSI.hasInstrumentationProfile());
+
+  BasicBlock &BB0 = F->getEntryBlock();
+  BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
+  BasicBlock *BB2 = BB0.getTerminator()->getSuccessor(1);
+  BasicBlock *BB3 = BB1->getSingleSuccessor();
+
+  BlockFrequencyInfo BFI = buildBFI(*F);
+
+  // Without the entry count, all should return false.
+  EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
+  EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
+  EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
+  EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
+}
+
 TEST_F(ProfileSummaryInfoTest, SampleProf) {
   auto M = makeLLVMModule("SampleProfile");
   Function *F = M->getFunction("f");
   ProfileSummaryInfo PSI = buildPSI(M.get());
   EXPECT_TRUE(PSI.hasProfileSummary());
   EXPECT_TRUE(PSI.hasSampleProfile());
 
   BasicBlock &BB0 = F->getEntryBlock();
   BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
   BasicBlock *BB2 = BB0.getTerminator()->getSuccessor(1);
   BasicBlock *BB3 = BB1->getSingleSuccessor();
 
   BlockFrequencyInfo BFI = buildBFI(*F);
   EXPECT_TRUE(PSI.isHotBlock(&BB0, &BFI));
   EXPECT_TRUE(PSI.isHotBlock(BB1, &BFI));
   EXPECT_FALSE(PSI.isHotBlock(BB2, &BFI));
   EXPECT_TRUE(PSI.isHotBlock(BB3, &BFI));
 
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
 
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
+
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, &BB0, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB1, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB2, &BFI));
   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB3, &BFI));
 
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, &BB0, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB1, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB2, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB3, &BFI));
+
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, &BB0, &BFI));
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB1, &BFI));
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB2, &BFI));
   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB3, &BFI));
 
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, &BB0, &BFI));
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB1, &BFI));
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB2, &BFI));
+  EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB3, &BFI));
+
   CallSite CS1(BB1->getFirstNonPHI());
   auto *CI2 = BB2->getFirstNonPHI();
   // Manually attach branch weights metadata to the call instruction.
   SmallVector<uint32_t, 1> Weights;
   Weights.push_back(1000);
   MDBuilder MDB(M->getContext());
   CI2->setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
   CallSite CS2(CI2);
 
   EXPECT_FALSE(PSI.isHotCallSite(CS1, &BFI));
   EXPECT_TRUE(PSI.isHotCallSite(CS2, &BFI));
 
   // Test that CS2 is considered hot when it gets an MD_prof metadata with
   // weights that exceed the hot count threshold.
   CI2->setMetadata(llvm::LLVMContext::MD_prof, MDB.createBranchWeights({400}));
   EXPECT_TRUE(PSI.isHotCallSite(CS2, &BFI));
+
+  {
+    Function *F = M->getFunction("l");
+    BlockFrequencyInfo BFI = buildBFI(*F);
+    BasicBlock &BB0 = F->getEntryBlock();
+    BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
+    BasicBlock *BB2 = BB0.getTerminator()->getSuccessor(1);
+    BasicBlock *BB3 = BB1->getSingleSuccessor();
+
+    // Without the entry count, all should return false.
+    EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
+    EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
+    EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
+    EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
+
+    EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
+    EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
+    EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
+    EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
+  }
+}
+
+TEST_F(ProfileSummaryInfoTest, SampleProfNoFuncEntryCount) {
+  auto M = makeLLVMModule("SampleProfile");
+  Function *F = M->getFunction("l");
+  ProfileSummaryInfo PSI = buildPSI(M.get());
+  EXPECT_TRUE(PSI.hasProfileSummary());
+  EXPECT_TRUE(PSI.hasSampleProfile());
+
+  BasicBlock &BB0 = F->getEntryBlock();
+  BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
+  BasicBlock *BB2 = BB0.getTerminator()->getSuccessor(1);
+  BasicBlock *BB3 = BB1->getSingleSuccessor();
+
+  BlockFrequencyInfo BFI = buildBFI(*F);
+
+  // Without the entry count, all should return false.
+  EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
+  EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
+  EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
+  EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
+  EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
 }
 
 } // end anonymous namespace
 } // end namespace llvm