[llvm][NFC][CallSite] Remove CallSite from ProfileSummary

[mtrofin]

Summary

Depends on D78395.

[dblaikie]

llvm/unittests/Analysis/ProfileSummaryInfoTest.cpp

230

I think I'd tend to deref first, then cast (the earlier the constraint is applied the better/tools can diagnose the problem closer to the source), but don't mind either way.

[mtrofin]

llvm/unittests/Analysis/ProfileSummaryInfoTest.cpp

230

I see what you mean. Here, I wouldn't want to introduce another variable, and I think there's little ambiguity where a failure may happen, since cast would be the one to trigger it.

[craig.topper]

llvm/unittests/Analysis/ProfileSummaryInfoTest.cpp

230

I think the suggestion was to put the * inside the parentheses instead outside the cast.

[dblaikie]

llvm/unittests/Analysis/ProfileSummaryInfoTest.cpp

230

That was the notion, yeah - no big deal though & sorry for the lack of clarity.

[mtrofin]

llvm/unittests/Analysis/ProfileSummaryInfoTest.cpp

230

Oh! I see.

committed https://github.com/llvm/llvm-project/commit/1586d0d38253be72e90b8494a57f546bd4e23b0f

llvm/include/llvm/Analysis/ProfileSummaryInfo.h

 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/Pass.h"
 #include <memory>
 
 namespace llvm {
 class BasicBlock;
 class BlockFrequencyInfo;
-class CallSite;
+class CallBase;
 class Instruction;
 class ProfileSummary;
 /// 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
public:
   /// 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 true if the call site \p CB is considered hot.
+  bool isHotCallSite(const CallBase &CB, BlockFrequencyInfo *BFI);
+  /// Returns true if call site \p CB is considered cold.
+  bool isColdCallSite(const CallBase &CB, 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() {

llvm/lib/Analysis/InlineCost.cpp

bool CallAnalyzer::allowSizeGrowth(CallBase &Call) {
   return true;
 }
 
 bool InlineCostCallAnalyzer::isColdCallSite(CallBase &Call,
                                             BlockFrequencyInfo *CallerBFI) {
   // If global profile summary is available, then callsite's coldness is
   // determined based on that.
   if (PSI && PSI->hasProfileSummary())
-    return PSI->isColdCallSite(CallSite(&Call), CallerBFI);
+    return PSI->isColdCallSite(Call, CallerBFI);
 
   // Otherwise we need BFI to be available.
   if (!CallerBFI)
     return false;
 
   // Determine if the callsite is cold relative to caller's entry. We could
   // potentially cache the computation of scaled entry frequency, but the added
   // complexity is not worth it unless this scaling shows up high in the
   // profiles.
   const BranchProbability ColdProb(ColdCallSiteRelFreq, 100);
   auto CallSiteBB = Call.getParent();
   auto CallSiteFreq = CallerBFI->getBlockFreq(CallSiteBB);
   auto CallerEntryFreq =
       CallerBFI->getBlockFreq(&(Call.getCaller()->getEntryBlock()));
   return CallSiteFreq < CallerEntryFreq * ColdProb;
 }
 
 Optional<int>
 InlineCostCallAnalyzer::getHotCallSiteThreshold(CallBase &Call,
                                                 BlockFrequencyInfo *CallerBFI) {
 
   // If global profile summary is available, then callsite's hotness is
   // determined based on that.
-  if (PSI && PSI->hasProfileSummary() &&
-      PSI->isHotCallSite(CallSite(&Call), CallerBFI))
+  if (PSI && PSI->hasProfileSummary() && PSI->isHotCallSite(Call, CallerBFI))
     return Params.HotCallSiteThreshold;
 
   // Otherwise we need BFI to be available and to have a locally hot callsite
   // threshold.
   if (!CallerBFI || !Params.LocallyHotCallSiteThreshold)
     return None;
 
   // Determine if the callsite is hot relative to caller's entry. We could

llvm/lib/Analysis/ProfileSummaryInfo.cpp

bool ProfileSummaryInfo::computeSummary() {
   // This will actually return PSK_Instr or PSK_Sample summary.
   SummaryMD = M.getProfileSummary(/* IsCS */ false);
   if (!SummaryMD)
     return false;
   Summary.reset(ProfileSummary::getFromMD(SummaryMD));
   return true;
 }
 
+// FIXME(CallSite): the parameter should be a CallBase.
 Optional<uint64_t>
 ProfileSummaryInfo::getProfileCount(const Instruction *Inst,
                                     BlockFrequencyInfo *BFI,
                                     bool AllowSynthetic) {
   if (!Inst)
     return None;
   assert((isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) &&
          "We can only get profile count for call/invoke instruction.");

 }
 
 bool ProfileSummaryInfo::isColdBlockNthPercentile(int PercentileCutoff,
                                                   const BasicBlock *BB,
                                                   BlockFrequencyInfo *BFI) {
   return isHotOrColdBlockNthPercentile<false>(PercentileCutoff, BB, BFI);
 }
 
-bool ProfileSummaryInfo::isHotCallSite(const CallSite &CS,
+bool ProfileSummaryInfo::isHotCallSite(const CallBase &CB,
                                        BlockFrequencyInfo *BFI) {
-  auto C = getProfileCount(CS.getInstruction(), BFI);
+  auto C = getProfileCount(&CB, BFI);
   return C && isHotCount(*C);
 }
 
-bool ProfileSummaryInfo::isColdCallSite(const CallSite &CS,
+bool ProfileSummaryInfo::isColdCallSite(const CallBase &CB,
                                         BlockFrequencyInfo *BFI) {
-  auto C = getProfileCount(CS.getInstruction(), BFI);
+  auto C = getProfileCount(&CB, BFI);
   if (C)
     return isColdCount(*C);
 
   // In SamplePGO, if the caller has been sampled, and there is no profile
   // annotated on the callsite, we consider the callsite as cold.
-  return hasSampleProfile() && CS.getCaller()->hasProfileData();
+  return hasSampleProfile() && CB.getCaller()->hasProfileData();
 }
 
 INITIALIZE_PASS(ProfileSummaryInfoWrapperPass, "profile-summary-info",
                 "Profile summary info", false, true)
 
 ProfileSummaryInfoWrapperPass::ProfileSummaryInfoWrapperPass()
     : ImmutablePass(ID) {
   initializeProfileSummaryInfoWrapperPassPass(*PassRegistry::getPassRegistry());

llvm/unittests/Analysis/ProfileSummaryInfoTest.cpp

 //===- ProfileSummaryInfoTest.cpp - ProfileSummaryInfo unit tests ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/SourceMgr.h"
TEST_F(ProfileSummaryInfoTest, TestNoProfile) {
 
   BasicBlock &BB0 = F->getEntryBlock();
   BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
 
   BlockFrequencyInfo BFI = buildBFI(*F);
   EXPECT_FALSE(PSI.isHotBlock(&BB0, &BFI));
   EXPECT_FALSE(PSI.isColdBlock(&BB0, &BFI));
 
-  CallSite CS1(BB1->getFirstNonPHI());
+  CallBase &CS1 = *cast<CallBase>(BB1->getFirstNonPHI());
   EXPECT_FALSE(PSI.isHotCallSite(CS1, &BFI));
   EXPECT_FALSE(PSI.isColdCallSite(CS1, &BFI));
 }
 TEST_F(ProfileSummaryInfoTest, TestCommon) {
   auto M = makeLLVMModule("InstrProf");
   Function *F = M->getFunction("f");
   Function *G = M->getFunction("g");
   Function *H = M->getFunction("h");
TEST_F(ProfileSummaryInfoTest, InstrProf) {
   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());
+  CallBase &CS1 = *cast<CallBase>(BB1->getFirstNonPHI());
   auto *CI2 = BB2->getFirstNonPHI();
-  CallSite CS2(CI2);
+  CallBase &CS2 = *cast<CallBase>(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}));
TEST_F(ProfileSummaryInfoTest, SampleProf) {
   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());
+  CallBase &CS1 = *cast<CallBase>(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);
+  CallBase &CS2 = *cast<CallBase>(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));