clang-r510928/include/llvm/Analysis/ProfileSummaryInfo.h - platform/prebuilts/clang/host/windows-x86 - Git at Google

 //===- llvm/Analysis/ProfileSummaryInfo.h - profile summary ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a pass that provides access to profile summary
 // information.
 //
 //===----------------------------------------------------------------------===//

 #ifndef LLVM_ANALYSIS_PROFILESUMMARYINFO_H
 #define LLVM_ANALYSIS_PROFILESUMMARYINFO_H

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/Pass.h"
 #include <memory>
 #include <optional>

 namespace llvm {
 class BasicBlock;
 class CallBase;
 class MachineFunction;

 /// 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:
   const Module *M;
   std::unique_ptr<ProfileSummary> Summary;
   void computeThresholds();
   // Count thresholds to answer isHotCount and isColdCount queries.
   std::optional<uint64_t> HotCountThreshold, ColdCountThreshold;
   // True if the working set size of the code is considered huge,
   // because the number of profile counts required to reach the hot
   // percentile is above a huge threshold.
   std::optional<bool> HasHugeWorkingSetSize;
   // True if the working set size of the code is considered large,
   // because the number of profile counts required to reach the hot
   // percentile is above a large threshold.
   std::optional<bool> HasLargeWorkingSetSize;
   // Compute the threshold for a given cutoff.
   std::optional<uint64_t> computeThreshold(int PercentileCutoff) const;
   // The map that caches the threshold values. The keys are the percentile
   // cutoff values and the values are the corresponding threshold values.
   mutable DenseMap<int, uint64_t> ThresholdCache;

 public:
   ProfileSummaryInfo(const Module &M) : M(&M) { refresh(); }
   ProfileSummaryInfo(ProfileSummaryInfo &&Arg) = default;

   /// If no summary is present, attempt to refresh.
   void refresh();

   /// Returns true if profile summary is available.
   bool hasProfileSummary() const { return Summary != nullptr; }

   /// Returns true if module \c M has sample profile.
   bool hasSampleProfile() const {
     return hasProfileSummary() &&
            Summary->getKind() == ProfileSummary::PSK_Sample;
   }

   /// Returns true if module \c M has instrumentation profile.
   bool hasInstrumentationProfile() const {
     return hasProfileSummary() &&
            Summary->getKind() == ProfileSummary::PSK_Instr;
   }

   /// Returns true if module \c M has context sensitive instrumentation profile.
   bool hasCSInstrumentationProfile() const {
     return hasProfileSummary() &&
            Summary->getKind() == ProfileSummary::PSK_CSInstr;
   }

   /// Handle the invalidation of this information.
   ///
   /// When used as a result of \c ProfileSummaryAnalysis this method will be
   /// called when the module this was computed for changes. Since profile
   /// summary is immutable after it is annotated on the module, we return false
   /// here.
   bool invalidate(Module &, const PreservedAnalyses &,
                   ModuleAnalysisManager::Invalidator &) {
     return false;
   }

   /// Returns the profile count for \p CallInst.
   std::optional<uint64_t> getProfileCount(const CallBase &CallInst,
                                           BlockFrequencyInfo *BFI,
                                           bool AllowSynthetic = false) const;
   /// Returns true if module \c M has partial-profile sample profile.
   bool hasPartialSampleProfile() const;
   /// Returns true if the working set size of the code is considered huge.
   bool hasHugeWorkingSetSize() const;
   /// Returns true if the working set size of the code is considered large.
   bool hasLargeWorkingSetSize() const;
   /// Returns true if \p F has hot function entry. If it returns false, it
   /// either means it is not hot or it is unknown whether it is hot or not (for
   /// example, no profile data is available).
   template <typename FuncT> bool isFunctionEntryHot(const FuncT *F) const {
     if (!F || !hasProfileSummary())
       return false;
     std::optional<Function::ProfileCount> FunctionCount = getEntryCount(F);
     // 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 && isHotCount(FunctionCount->getCount());
   }

   /// Returns true if \p F contains hot code.
   template <typename FuncT, typename BFIT>
   bool isFunctionHotInCallGraph(const FuncT *F, BFIT &BFI) const {
     if (!F || !hasProfileSummary())
       return false;
     if (auto FunctionCount = getEntryCount(F))
       if (isHotCount(FunctionCount->getCount()))
         return true;

     if (auto TotalCallCount = getTotalCallCount(F))
       if (isHotCount(*TotalCallCount))
         return true;

     for (const auto &BB : *F)
       if (isHotBlock(&BB, &BFI))
         return true;
     return false;
   }
   /// Returns true if \p F has cold function entry.
   bool isFunctionEntryCold(const Function *F) const;
   /// Returns true if \p F contains only cold code.
   template <typename FuncT, typename BFIT>
   bool isFunctionColdInCallGraph(const FuncT *F, BFIT &BFI) const {
     if (!F || !hasProfileSummary())
       return false;
     if (auto FunctionCount = getEntryCount(F))
       if (!isColdCount(FunctionCount->getCount()))
         return false;

     if (auto TotalCallCount = getTotalCallCount(F))
       if (!isColdCount(*TotalCallCount))
         return false;

     for (const auto &BB : *F)
       if (!isColdBlock(&BB, &BFI))
         return false;
     return true;
   }
   /// Returns true if the hotness of \p F is unknown.
   bool isFunctionHotnessUnknown(const Function &F) const;
   /// Returns true if \p F contains hot code with regard to a given hot
   /// percentile cutoff value.
   template <typename FuncT, typename BFIT>
   bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff,
                                              const FuncT *F, BFIT &BFI) const {
     return isFunctionHotOrColdInCallGraphNthPercentile<true, FuncT, BFIT>(
         PercentileCutoff, F, BFI);
   }
   /// Returns true if \p F contains cold code with regard to a given cold
   /// percentile cutoff value.
   template <typename FuncT, typename BFIT>
   bool isFunctionColdInCallGraphNthPercentile(int PercentileCutoff,
                                               const FuncT *F, BFIT &BFI) const {
     return isFunctionHotOrColdInCallGraphNthPercentile<false, FuncT, BFIT>(
         PercentileCutoff, F, BFI);
   }
   /// Returns true if count \p C is considered hot.
   bool isHotCount(uint64_t C) const;
   /// Returns true if count \p C is considered cold.
   bool isColdCount(uint64_t C) const;
   /// Returns true if count \p C is considered hot with regard to a given
   /// hot percentile cutoff value.
   /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
   /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
   bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C) const;
   /// Returns true if count \p C is considered cold with regard to a given
   /// cold percentile cutoff value.
   /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
   /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
   bool isColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;

   /// Returns true if BasicBlock \p BB is considered hot.
   template <typename BBType, typename BFIT>
   bool isHotBlock(const BBType *BB, BFIT *BFI) const {
     auto Count = BFI->getBlockProfileCount(BB);
     return Count && isHotCount(*Count);
   }

   /// Returns true if BasicBlock \p BB is considered cold.
   template <typename BBType, typename BFIT>
   bool isColdBlock(const BBType *BB, BFIT *BFI) const {
     auto Count = BFI->getBlockProfileCount(BB);
     return Count && isColdCount(*Count);
   }

   template <typename BFIT>
   bool isColdBlock(BlockFrequency BlockFreq, const BFIT *BFI) const {
     auto Count = BFI->getProfileCountFromFreq(BlockFreq.getFrequency());
     return Count && isColdCount(*Count);
   }

   template <typename BBType, typename BFIT>
   bool isHotBlockNthPercentile(int PercentileCutoff, const BBType *BB,
                                BFIT *BFI) const {
     return isHotOrColdBlockNthPercentile<true, BBType, BFIT>(PercentileCutoff,
                                                              BB, BFI);
   }

   template <typename BFIT>
   bool isHotBlockNthPercentile(int PercentileCutoff, BlockFrequency BlockFreq,
                                BFIT *BFI) const {
     return isHotOrColdBlockNthPercentile<true, BFIT>(PercentileCutoff,
                                                      BlockFreq, BFI);
   }

   /// Returns true if BasicBlock \p BB is considered cold with regard to a given
   /// cold percentile cutoff value.
   /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
   /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
   template <typename BBType, typename BFIT>
   bool isColdBlockNthPercentile(int PercentileCutoff, const BBType *BB,
                                 BFIT *BFI) const {
     return isHotOrColdBlockNthPercentile<false, BBType, BFIT>(PercentileCutoff,
                                                               BB, BFI);
   }
   template <typename BFIT>
   bool isColdBlockNthPercentile(int PercentileCutoff, BlockFrequency BlockFreq,
                                 BFIT *BFI) const {
     return isHotOrColdBlockNthPercentile<false, BFIT>(PercentileCutoff,
                                                       BlockFreq, BFI);
   }
   /// Returns true if the call site \p CB is considered hot.
   bool isHotCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
   /// Returns true if call site \p CB is considered cold.
   bool isColdCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
   /// Returns HotCountThreshold if set. Recompute HotCountThreshold
   /// if not set.
   uint64_t getOrCompHotCountThreshold() const;
   /// Returns ColdCountThreshold if set. Recompute HotCountThreshold
   /// if not set.
   uint64_t getOrCompColdCountThreshold() const;
   /// Returns HotCountThreshold if set.
   uint64_t getHotCountThreshold() const {
     return HotCountThreshold.value_or(0);
   }
   /// Returns ColdCountThreshold if set.
   uint64_t getColdCountThreshold() const {
     return ColdCountThreshold.value_or(0);
   }

 private:
   template <typename FuncT>
   std::optional<uint64_t> getTotalCallCount(const FuncT *F) const {
     return std::nullopt;
   }

   template <bool isHot, typename FuncT, typename BFIT>
   bool isFunctionHotOrColdInCallGraphNthPercentile(int PercentileCutoff,
                                                    const FuncT *F,
                                                    BFIT &FI) const {
     if (!F || !hasProfileSummary())
       return false;
     if (auto FunctionCount = getEntryCount(F)) {
       if (isHot &&
           isHotCountNthPercentile(PercentileCutoff, FunctionCount->getCount()))
         return true;
       if (!isHot && !isColdCountNthPercentile(PercentileCutoff,
                                               FunctionCount->getCount()))
         return false;
     }
     if (auto TotalCallCount = getTotalCallCount(F)) {
       if (isHot && isHotCountNthPercentile(PercentileCutoff, *TotalCallCount))
         return true;
       if (!isHot &&
           !isColdCountNthPercentile(PercentileCutoff, *TotalCallCount))
         return false;
     }
     for (const auto &BB : *F) {
       if (isHot && isHotBlockNthPercentile(PercentileCutoff, &BB, &FI))
         return true;
       if (!isHot && !isColdBlockNthPercentile(PercentileCutoff, &BB, &FI))
         return false;
     }
     return !isHot;
   }

   template <bool isHot>
   bool isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;

   template <bool isHot, typename BBType, typename BFIT>
   bool isHotOrColdBlockNthPercentile(int PercentileCutoff, const BBType *BB,
                                      BFIT *BFI) const {
     auto Count = BFI->getBlockProfileCount(BB);
     if (isHot)
       return Count && isHotCountNthPercentile(PercentileCutoff, *Count);
     else
       return Count && isColdCountNthPercentile(PercentileCutoff, *Count);
   }

   template <bool isHot, typename BFIT>
   bool isHotOrColdBlockNthPercentile(int PercentileCutoff,
                                      BlockFrequency BlockFreq,
                                      BFIT *BFI) const {
     auto Count = BFI->getProfileCountFromFreq(BlockFreq.getFrequency());
     if (isHot)
       return Count && isHotCountNthPercentile(PercentileCutoff, *Count);
     else
       return Count && isColdCountNthPercentile(PercentileCutoff, *Count);
   }

   template <typename FuncT>
   std::optional<Function::ProfileCount> getEntryCount(const FuncT *F) const {
     return F->getEntryCount();
   }
 };

 template <>
 inline std::optional<uint64_t>
 ProfileSummaryInfo::getTotalCallCount<Function>(const Function *F) const {
   if (!hasSampleProfile())
     return std::nullopt;
   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(cast<CallBase>(I), nullptr))
           TotalCallCount += *CallCount;
   return TotalCallCount;
 }

 // Declare template specialization for llvm::MachineFunction. Do not implement
 // here, because we cannot include MachineFunction header here, that would break
 // dependency rules.
 template <>
 std::optional<Function::ProfileCount>
 ProfileSummaryInfo::getEntryCount<MachineFunction>(
     const MachineFunction *F) const;

 /// 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() { return *PSI; }
   const ProfileSummaryInfo &getPSI() const { return *PSI; }

   bool doInitialization(Module &M) override;
   bool doFinalization(Module &M) override;
   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;

   Result run(Module &M, ModuleAnalysisManager &);

 private:
   friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
   static AnalysisKey Key;
 };

 /// 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, ModuleAnalysisManager &AM);
 };

 } // end namespace llvm

 #endif
	//===- llvm/Analysis/ProfileSummaryInfo.h - profile summary ---- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file contains a pass that provides access to profile summary
	// information.
	//
	//===----------------------------------------------------------------------===//

	#ifndef LLVM_ANALYSIS_PROFILESUMMARYINFO_H
	#define LLVM_ANALYSIS_PROFILESUMMARYINFO_H

	#include "llvm/ADT/DenseMap.h"
	#include "llvm/Analysis/BlockFrequencyInfo.h"
	#include "llvm/IR/Function.h"
	#include "llvm/IR/Instructions.h"
	#include "llvm/IR/PassManager.h"
	#include "llvm/IR/ProfileSummary.h"
	#include "llvm/Pass.h"
	#include <memory>
	#include <optional>

	namespace llvm {
	class BasicBlock;
	class CallBase;
	class MachineFunction;

	/// 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:
	const Module *M;
	std::unique_ptr<ProfileSummary> Summary;
	void computeThresholds();
	// Count thresholds to answer isHotCount and isColdCount queries.
	std::optional<uint64_t> HotCountThreshold, ColdCountThreshold;
	// True if the working set size of the code is considered huge,
	// because the number of profile counts required to reach the hot
	// percentile is above a huge threshold.
	std::optional<bool> HasHugeWorkingSetSize;
	// True if the working set size of the code is considered large,
	// because the number of profile counts required to reach the hot
	// percentile is above a large threshold.
	std::optional<bool> HasLargeWorkingSetSize;
	// Compute the threshold for a given cutoff.
	std::optional<uint64_t> computeThreshold(int PercentileCutoff) const;
	// The map that caches the threshold values. The keys are the percentile
	// cutoff values and the values are the corresponding threshold values.
	mutable DenseMap<int, uint64_t> ThresholdCache;

	public:
	ProfileSummaryInfo(const Module &M) : M(&M) { refresh(); }
	ProfileSummaryInfo(ProfileSummaryInfo &&Arg) = default;

	/// If no summary is present, attempt to refresh.
	void refresh();

	/// Returns true if profile summary is available.
	bool hasProfileSummary() const { return Summary != nullptr; }

	/// Returns true if module \c M has sample profile.
	bool hasSampleProfile() const {
	return hasProfileSummary() &&
	Summary->getKind() == ProfileSummary::PSK_Sample;
	}

	/// Returns true if module \c M has instrumentation profile.
	bool hasInstrumentationProfile() const {
	return hasProfileSummary() &&
	Summary->getKind() == ProfileSummary::PSK_Instr;
	}

	/// Returns true if module \c M has context sensitive instrumentation profile.
	bool hasCSInstrumentationProfile() const {
	return hasProfileSummary() &&
	Summary->getKind() == ProfileSummary::PSK_CSInstr;
	}

	/// Handle the invalidation of this information.
	///
	/// When used as a result of \c ProfileSummaryAnalysis this method will be
	/// called when the module this was computed for changes. Since profile
	/// summary is immutable after it is annotated on the module, we return false
	/// here.
	bool invalidate(Module &, const PreservedAnalyses &,
	ModuleAnalysisManager::Invalidator &) {
	return false;
	}

	/// Returns the profile count for \p CallInst.
	std::optional<uint64_t> getProfileCount(const CallBase &CallInst,
	BlockFrequencyInfo *BFI,
	bool AllowSynthetic = false) const;
	/// Returns true if module \c M has partial-profile sample profile.
	bool hasPartialSampleProfile() const;
	/// Returns true if the working set size of the code is considered huge.
	bool hasHugeWorkingSetSize() const;
	/// Returns true if the working set size of the code is considered large.
	bool hasLargeWorkingSetSize() const;
	/// Returns true if \p F has hot function entry. If it returns false, it
	/// either means it is not hot or it is unknown whether it is hot or not (for
	/// example, no profile data is available).
	template <typename FuncT> bool isFunctionEntryHot(const FuncT *F) const {
	if (!F \|\| !hasProfileSummary())
	return false;
	std::optional<Function::ProfileCount> FunctionCount = getEntryCount(F);
	// 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 && isHotCount(FunctionCount->getCount());
	}

	/// Returns true if \p F contains hot code.
	template <typename FuncT, typename BFIT>
	bool isFunctionHotInCallGraph(const FuncT *F, BFIT &BFI) const {
	if (!F \|\| !hasProfileSummary())
	return false;
	if (auto FunctionCount = getEntryCount(F))
	if (isHotCount(FunctionCount->getCount()))
	return true;

	if (auto TotalCallCount = getTotalCallCount(F))
	if (isHotCount(*TotalCallCount))
	return true;

	for (const auto &BB : *F)
	if (isHotBlock(&BB, &BFI))
	return true;
	return false;
	}
	/// Returns true if \p F has cold function entry.
	bool isFunctionEntryCold(const Function *F) const;
	/// Returns true if \p F contains only cold code.
	template <typename FuncT, typename BFIT>
	bool isFunctionColdInCallGraph(const FuncT *F, BFIT &BFI) const {
	if (!F \|\| !hasProfileSummary())
	return false;
	if (auto FunctionCount = getEntryCount(F))
	if (!isColdCount(FunctionCount->getCount()))
	return false;

	if (auto TotalCallCount = getTotalCallCount(F))
	if (!isColdCount(*TotalCallCount))
	return false;

	for (const auto &BB : *F)
	if (!isColdBlock(&BB, &BFI))
	return false;
	return true;
	}
	/// Returns true if the hotness of \p F is unknown.
	bool isFunctionHotnessUnknown(const Function &F) const;
	/// Returns true if \p F contains hot code with regard to a given hot
	/// percentile cutoff value.
	template <typename FuncT, typename BFIT>
	bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff,
	const FuncT *F, BFIT &BFI) const {
	return isFunctionHotOrColdInCallGraphNthPercentile<true, FuncT, BFIT>(
	PercentileCutoff, F, BFI);
	}
	/// Returns true if \p F contains cold code with regard to a given cold
	/// percentile cutoff value.
	template <typename FuncT, typename BFIT>
	bool isFunctionColdInCallGraphNthPercentile(int PercentileCutoff,
	const FuncT *F, BFIT &BFI) const {
	return isFunctionHotOrColdInCallGraphNthPercentile<false, FuncT, BFIT>(
	PercentileCutoff, F, BFI);
	}
	/// Returns true if count \p C is considered hot.
	bool isHotCount(uint64_t C) const;
	/// Returns true if count \p C is considered cold.
	bool isColdCount(uint64_t C) const;
	/// Returns true if count \p C is considered hot with regard to a given
	/// hot percentile cutoff value.
	/// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
	/// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
	bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C) const;
	/// Returns true if count \p C is considered cold with regard to a given
	/// cold percentile cutoff value.
	/// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
	/// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
	bool isColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;

	/// Returns true if BasicBlock \p BB is considered hot.
	template <typename BBType, typename BFIT>
	bool isHotBlock(const BBType BB, BFIT BFI) const {
	auto Count = BFI->getBlockProfileCount(BB);
	return Count && isHotCount(*Count);
	}

	/// Returns true if BasicBlock \p BB is considered cold.
	template <typename BBType, typename BFIT>
	bool isColdBlock(const BBType BB, BFIT BFI) const {
	auto Count = BFI->getBlockProfileCount(BB);
	return Count && isColdCount(*Count);
	}

	template <typename BFIT>
	bool isColdBlock(BlockFrequency BlockFreq, const BFIT *BFI) const {
	auto Count = BFI->getProfileCountFromFreq(BlockFreq.getFrequency());
	return Count && isColdCount(*Count);
	}

	template <typename BBType, typename BFIT>
	bool isHotBlockNthPercentile(int PercentileCutoff, const BBType *BB,
	BFIT *BFI) const {
	return isHotOrColdBlockNthPercentile<true, BBType, BFIT>(PercentileCutoff,
	BB, BFI);
	}

	template <typename BFIT>
	bool isHotBlockNthPercentile(int PercentileCutoff, BlockFrequency BlockFreq,
	BFIT *BFI) const {
	return isHotOrColdBlockNthPercentile<true, BFIT>(PercentileCutoff,
	BlockFreq, BFI);
	}

	/// Returns true if BasicBlock \p BB is considered cold with regard to a given
	/// cold percentile cutoff value.
	/// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
	/// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
	template <typename BBType, typename BFIT>
	bool isColdBlockNthPercentile(int PercentileCutoff, const BBType *BB,
	BFIT *BFI) const {
	return isHotOrColdBlockNthPercentile<false, BBType, BFIT>(PercentileCutoff,
	BB, BFI);
	}
	template <typename BFIT>
	bool isColdBlockNthPercentile(int PercentileCutoff, BlockFrequency BlockFreq,
	BFIT *BFI) const {
	return isHotOrColdBlockNthPercentile<false, BFIT>(PercentileCutoff,
	BlockFreq, BFI);
	}
	/// Returns true if the call site \p CB is considered hot.
	bool isHotCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
	/// Returns true if call site \p CB is considered cold.
	bool isColdCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
	/// Returns HotCountThreshold if set. Recompute HotCountThreshold
	/// if not set.
	uint64_t getOrCompHotCountThreshold() const;
	/// Returns ColdCountThreshold if set. Recompute HotCountThreshold
	/// if not set.
	uint64_t getOrCompColdCountThreshold() const;
	/// Returns HotCountThreshold if set.
	uint64_t getHotCountThreshold() const {
	return HotCountThreshold.value_or(0);
	}
	/// Returns ColdCountThreshold if set.
	uint64_t getColdCountThreshold() const {
	return ColdCountThreshold.value_or(0);
	}

	private:
	template <typename FuncT>
	std::optional<uint64_t> getTotalCallCount(const FuncT *F) const {
	return std::nullopt;
	}

	template <bool isHot, typename FuncT, typename BFIT>
	bool isFunctionHotOrColdInCallGraphNthPercentile(int PercentileCutoff,
	const FuncT *F,
	BFIT &FI) const {
	if (!F \|\| !hasProfileSummary())
	return false;
	if (auto FunctionCount = getEntryCount(F)) {
	if (isHot &&
	isHotCountNthPercentile(PercentileCutoff, FunctionCount->getCount()))
	return true;
	if (!isHot && !isColdCountNthPercentile(PercentileCutoff,
	FunctionCount->getCount()))
	return false;
	}
	if (auto TotalCallCount = getTotalCallCount(F)) {
	if (isHot && isHotCountNthPercentile(PercentileCutoff, *TotalCallCount))
	return true;
	if (!isHot &&
	!isColdCountNthPercentile(PercentileCutoff, *TotalCallCount))
	return false;
	}
	for (const auto &BB : *F) {
	if (isHot && isHotBlockNthPercentile(PercentileCutoff, &BB, &FI))
	return true;
	if (!isHot && !isColdBlockNthPercentile(PercentileCutoff, &BB, &FI))
	return false;
	}
	return !isHot;
	}

	template <bool isHot>
	bool isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;

	template <bool isHot, typename BBType, typename BFIT>
	bool isHotOrColdBlockNthPercentile(int PercentileCutoff, const BBType *BB,
	BFIT *BFI) const {
	auto Count = BFI->getBlockProfileCount(BB);
	if (isHot)
	return Count && isHotCountNthPercentile(PercentileCutoff, *Count);
	else
	return Count && isColdCountNthPercentile(PercentileCutoff, *Count);
	}

	template <bool isHot, typename BFIT>
	bool isHotOrColdBlockNthPercentile(int PercentileCutoff,
	BlockFrequency BlockFreq,
	BFIT *BFI) const {
	auto Count = BFI->getProfileCountFromFreq(BlockFreq.getFrequency());
	if (isHot)
	return Count && isHotCountNthPercentile(PercentileCutoff, *Count);
	else
	return Count && isColdCountNthPercentile(PercentileCutoff, *Count);
	}

	template <typename FuncT>
	std::optional<Function::ProfileCount> getEntryCount(const FuncT *F) const {
	return F->getEntryCount();
	}
	};

	template <>
	inline std::optional<uint64_t>
	ProfileSummaryInfo::getTotalCallCount<Function>(const Function *F) const {
	if (!hasSampleProfile())
	return std::nullopt;
	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(cast<CallBase>(I), nullptr))
	TotalCallCount += *CallCount;
	return TotalCallCount;
	}

	// Declare template specialization for llvm::MachineFunction. Do not implement
	// here, because we cannot include MachineFunction header here, that would break
	// dependency rules.
	template <>
	std::optional<Function::ProfileCount>
	ProfileSummaryInfo::getEntryCount<MachineFunction>(
	const MachineFunction *F) const;

	/// 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() { return *PSI; }
	const ProfileSummaryInfo &getPSI() const { return *PSI; }

	bool doInitialization(Module &M) override;
	bool doFinalization(Module &M) override;
	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;

	Result run(Module &M, ModuleAnalysisManager &);

	private:
	friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
	static AnalysisKey Key;
	};

	/// 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, ModuleAnalysisManager &AM);
	};

	} // end namespace llvm

	#endif