[llvm][NFC] Refactor uses of CallSite to CallBase - call promotion

[mtrofin]

Summary

Updated CallPromotionUtils and impacted sites. Parameters that are
expected to be non-null, and return values that are guranteed non-null,
were replaced with CallBase references rather than pointers.

Left FIXME in places where more changes are facilitated by CallBase, but
aren't CallSites: Instruction* parameters or return values, for example,
where the contract that they are actually CallBase values.

[dblaikie]

llvm/lib/Target/AMDGPU/AMDGPUFixFunctionBitcasts.cpp

39

Hmm, might be worth adding an implicit conversion from CallSite to CallBase* to make code like this easier? (alternatively/at least CallSite::getInstruction() should return CallBase*, I think?)

llvm/unittests/Transforms/Utils/CallPromotionUtilsTest.cpp

94–96

Can probably drop the intermediate CB variable now (& just write CI->getCalledFunction() and tryPromoteCall(*CI))

(similarly below)

[mtrofin]

simplified CallPromotionUtilsTest.cpp

[mtrofin]

llvm/lib/Target/AMDGPU/AMDGPUFixFunctionBitcasts.cpp

39

I'd keep it ugly and hard to use, since we want to deprecate CallSite, and encourage more refactoring.

(I'm hoping to actually complete it, I think it's very tractable)

llvm/unittests/Transforms/Utils/CallPromotionUtilsTest.cpp

94–96

Done.

Also, seems like this file would benefit from ASSERT_TRUE(pointer) -> ASSERT_NE(pointer, nullptr) (same for EXPECT_) - or is this not particularly followed?

[dblaikie]

llvm/unittests/Transforms/Utils/CallPromotionUtilsTest.cpp

94–96

When writing non-gtest boolean tests, I favor "if (X)" or "if (!X)" but I'm not sure what's most common across LLVM.

For gtests - yeah, I think using the most descriptive test is good from a gtest error message perspective - I don't know of any particular convention there, but I wouldn't object to/would encourage changes to go in that direction (of using the most descriptive tests).

llvm/include/llvm/Transforms/Utils/CallPromotionUtils.h

 //===- CallPromotionUtils.h - Utilities for call promotion ------*- 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 declares utilities useful for promoting indirect call sites to
 // direct call sites.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_CALLPROMOTIONUTILS_H
 #define LLVM_TRANSFORMS_UTILS_CALLPROMOTIONUTILS_H
 
-#include "llvm/IR/CallSite.h"
-
 namespace llvm {
+class CallBase;
+class CastInst;
+class Function;
+class MDNode;
 
 /// Return true if the given indirect call site can be made to call \p Callee.
 ///
 /// This function ensures that the number and type of the call site's arguments
 /// and return value match those of the given function. If the types do not
 /// match exactly, they must at least be bitcast compatible. If \p FailureReason
 /// is non-null and the indirect call cannot be promoted, the failure reason
 /// will be stored in it.
-bool isLegalToPromote(CallSite CS, Function *Callee,
+bool isLegalToPromote(CallBase &CB, Function *Callee,
                       const char **FailureReason = nullptr);
 
 /// Promote the given indirect call site to unconditionally call \p Callee.
 ///
 /// This function promotes the given call site, returning the direct call or
 /// invoke instruction. If the function type of the call site doesn't match that
 /// of the callee, bitcast instructions are inserted where appropriate. If \p
 /// RetBitCast is non-null, it will be used to store the return value bitcast,
 /// if created.
-Instruction *promoteCall(CallSite CS, Function *Callee,
-                         CastInst **RetBitCast = nullptr);
+CallBase &promoteCall(CallBase &CB, Function *Callee,
 
 /// Promote the given indirect call site to conditionally call \p Callee.
 ///
 /// This function creates an if-then-else structure at the location of the call
 /// site. The original call site is moved into the "else" block. A clone of the
 /// indirect call site is promoted, placed in the "then" block, and returned. If
 /// \p BranchWeights is non-null, it will be used to set !prof metadata on the
 /// new conditional branch.
-Instruction *promoteCallWithIfThenElse(CallSite CS, Function *Callee,
-                                       MDNode *BranchWeights = nullptr);
+CallBase &promoteCallWithIfThenElse(CallBase &CB, Function *Callee,
 
 /// Try to promote (devirtualize) a virtual call on an Alloca. Return true on
 /// success.
 ///
 /// Look for a pattern like:
 ///
 ///  %o = alloca %class.Impl
 ///  %1 = getelementptr %class.Impl, %class.Impl* %o, i64 0, i32 0, i32 0
 ///  store i32 (...)** bitcast (i8** getelementptr inbounds
 ///      ({ [3 x i8*] }, { [3 x i8*] }* @_ZTV4Impl, i64 0, inrange i32 0, i64 2)
 ///      to i32 (...)**), i32 (...)*** %1
 ///  %2 = getelementptr inbounds %class.Impl, %class.Impl* %o, i64 0, i32 0
 ///  %3 = bitcast %class.Interface* %2 to void (%class.Interface*)***
 ///  %vtable.i = load void (%class.Interface*)**, void (%class.Interface*)*** %3
 ///  %4 = load void (%class.Interface*)*, void (%class.Interface*)** %vtable.i
 ///  call void %4(%class.Interface* nonnull %2)
 ///
 /// @_ZTV4Impl = linkonce_odr dso_local unnamed_addr constant { [3 x i8*] }
 ///     { [3 x i8*]
 ///     [i8* null, i8* bitcast ({ i8*, i8*, i8* }* @_ZTI4Impl to i8*),
 ///     i8* bitcast (void (%class.Impl*)* @_ZN4Impl3RunEv to i8*)] }
 ///
-bool tryPromoteCall(CallSite &CS);
+bool tryPromoteCall(CallBase &CB);
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_CALLPROMOTIONUTILS_H

llvm/include/llvm/Transforms/Utils/Cloning.h

 #ifndef LLVM_TRANSFORMS_UTILS_CLONING_H
 #define LLVM_TRANSFORMS_UTILS_CLONING_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/InlineCost.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 #include <functional>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
public:
   /// callee. This is only filled in if CG is non-null.
   SmallVector<WeakTrackingVH, 8> InlinedCalls;
 
   /// All of the new call sites inlined into the caller.
   ///
   /// 'InlineFunction' fills this in by scanning the inlined instructions, and
   /// only if CG is null. If CG is non-null, instead the value handle
   /// `InlinedCalls` above is used.
-  SmallVector<CallSite, 8> InlinedCallSites;
+  SmallVector<CallBase *, 8> InlinedCallSites;
 
   void reset() {
     StaticAllocas.clear();
     InlinedCalls.clear();
     InlinedCallSites.clear();
   }
 };
 

llvm/lib/Target/AMDGPU/AMDGPUFixFunctionBitcasts.cpp

class AMDGPUFixFunctionBitcasts final
 
   bool Modified;
 
 public:
   void visitCallSite(CallSite CS) {
     if (CS.getCalledFunction())
       return;
     auto Callee = dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts());
-    if (Callee && isLegalToPromote(CS, Callee)) {
-      promoteCall(CS, Callee);
+    if (Callee &&
+        isLegalToPromote(*cast<CallBase>(CS.getInstruction()), Callee)) {
+      promoteCall(*cast<CallBase>(CS.getInstruction()), Callee);
       Modified = true;
     }
   }
 
   static char ID;
   AMDGPUFixFunctionBitcasts() : ModulePass(ID) {}
 };
 } // End anonymous namespace

llvm/lib/Transforms/IPO/Inliner.cpp

 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/CallPromotionUtils.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
for (; I < (int)Calls.size() && Calls[I].first->getCaller() == &F; ++I) {
       emitInlinedInto(ORE, DLoc, Block, Callee, F, *OIC);
 
       // Add any new callsites to defined functions to the worklist.
       if (!IFI.InlinedCallSites.empty()) {
         int NewHistoryID = InlineHistory.size();
         InlineHistory.push_back({&Callee, InlineHistoryID});
 
         // FIXME(mtrofin): refactor IFI.InlinedCallSites to be CallBase-based
-        for (CallSite &CS : reverse(IFI.InlinedCallSites)) {
-          Function *NewCallee = CS.getCalledFunction();
+        for (CallBase *CS : reverse(IFI.InlinedCallSites)) {
+          Function *NewCallee = CS->getCalledFunction();
           if (!NewCallee) {
             // Try to promote an indirect (virtual) call without waiting for the
             // post-inline cleanup and the next DevirtSCCRepeatedPass iteration
             // because the next iteration may not happen and we may miss
             // inlining it.
-            if (tryPromoteCall(CS))
-              NewCallee = CS.getCalledFunction();
+            if (tryPromoteCall(*CS))
+              NewCallee = CS->getCalledFunction();
           }
           if (NewCallee)
             if (!NewCallee->isDeclaration())
-              Calls.push_back(
-                  {cast<CallBase>(CS.getInstruction()), NewHistoryID});
+              Calls.push_back({CS, NewHistoryID});
         }
       }
 
       if (InlinerFunctionImportStats != InlinerFunctionImportStatsOpts::No)
         ImportedFunctionsStats->recordInline(F, Callee);
 
       // Merge the attributes based on the inlining.
       AttributeFuncs::mergeAttributesForInlining(F, Callee);

llvm/lib/Transforms/IPO/SampleProfile.cpp

 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/PostDominators.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
bool SampleProfileLoader::inlineHotFunctions(
   // ProfAccForSymsInList is used in callsiteIsHot. The assertion makes sure
   // Profile symbol list is ignored when profile-sample-accurate is on.
   assert((!ProfAccForSymsInList ||
           (!ProfileSampleAccurate &&
            !F.hasFnAttribute("profile-sample-accurate"))) &&
          "ProfAccForSymsInList should be false when profile-sample-accurate "
          "is enabled");
 
+  // FIXME(CallSite): refactor the vectors here, as they operate with CallBase
+  // values
   DenseMap<Instruction *, const FunctionSamples *> localNotInlinedCallSites;
   bool Changed = false;
   while (true) {
     bool LocalChanged = false;
     SmallVector<Instruction *, 10> CIS;
     for (auto &BB : F) {
       bool Hot = false;
       SmallVector<Instruction *, 10> AllCandidates;
for (auto I : CIS) {
           if (!callsiteIsHot(FS, PSI))
             continue;
 
           const char *Reason = "Callee function not available";
           auto R = SymbolMap.find(CalleeFunctionName);
           if (R != SymbolMap.end() && R->getValue() &&
               !R->getValue()->isDeclaration() &&
               R->getValue()->getSubprogram() &&
-              isLegalToPromote(CallSite(I), R->getValue(), &Reason)) {
+              isLegalToPromote(*cast<CallBase>(I), R->getValue(), &Reason)) {
             uint64_t C = FS->getEntrySamples();
             Instruction *DI =
                 pgo::promoteIndirectCall(I, R->getValue(), C, Sum, false, ORE);
             Sum -= C;
             PromotedInsns.insert(I);
             // If profile mismatches, we should not attempt to inline DI.
             if ((isa<CallInst>(DI) || isa<InvokeInst>(DI)) &&
                 inlineCallInstruction(DI)) {

llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/IndirectCallPromotionAnalysis.h"
 #include "llvm/Analysis/IndirectCallVisitor.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
public:
 
   bool processFunction(ProfileSummaryInfo *PSI);
 };
 
 } // end anonymous namespace
 
 // Indirect-call promotion heuristic. The direct targets are sorted based on
 // the count. Stop at the first target that is not promoted.
+// FIXME(callsite): the Instruction* parameter can be changed to CallBase
 std::vector<ICallPromotionFunc::PromotionCandidate>
 ICallPromotionFunc::getPromotionCandidatesForCallSite(
     Instruction *Inst, const ArrayRef<InstrProfValueData> &ValueDataRef,
     uint64_t TotalCount, uint32_t NumCandidates) {
   std::vector<PromotionCandidate> Ret;
 
   LLVM_DEBUG(dbgs() << " \nWork on callsite #" << NumOfPGOICallsites << *Inst
                     << " Num_targets: " << ValueDataRef.size()
if (TargetFunction == nullptr) {
         return OptimizationRemarkMissed(DEBUG_TYPE, "UnableToFindTarget", Inst)
                << "Cannot promote indirect call: target with md5sum "
                << ore::NV("target md5sum", Target) << " not found";
       });
       break;
     }
 
     const char *Reason = nullptr;
-    if (!isLegalToPromote(CallSite(Inst), TargetFunction, &Reason)) {
+    if (!isLegalToPromote(*cast<CallBase>(Inst), TargetFunction, &Reason)) {
       using namespace ore;
 
       ORE.emit([&]() {
         return OptimizationRemarkMissed(DEBUG_TYPE, "UnableToPromote", Inst)
                << "Cannot promote indirect call to "
                << NV("TargetFunction", TargetFunction) << " with count of "
                << NV("Count", Count) << ": " << Reason;
       });
       break;
     }
 
     Ret.push_back(PromotionCandidate(TargetFunction, Count));
     TotalCount -= Count;
   }
   return Ret;
 }
 
+// FIXME(callsite): the Instruction* parameter and return can be changed to
+// CallBase
 Instruction *llvm::pgo::promoteIndirectCall(Instruction *Inst,
                                             Function *DirectCallee,
                                             uint64_t Count, uint64_t TotalCount,
                                             bool AttachProfToDirectCall,
                                             OptimizationRemarkEmitter *ORE) {
 
   uint64_t ElseCount = TotalCount - Count;
   uint64_t MaxCount = (Count >= ElseCount ? Count : ElseCount);
   uint64_t Scale = calculateCountScale(MaxCount);
   MDBuilder MDB(Inst->getContext());
   MDNode *BranchWeights = MDB.createBranchWeights(
       scaleBranchCount(Count, Scale), scaleBranchCount(ElseCount, Scale));
 
-  Instruction *NewInst =
-      promoteCallWithIfThenElse(CallSite(Inst), DirectCallee, BranchWeights);
+  CallBase &NewInst = promoteCallWithIfThenElse(*cast<CallBase>(Inst),
+                                                DirectCallee, BranchWeights);
 
   if (AttachProfToDirectCall) {
-    MDBuilder MDB(NewInst->getContext());
-    NewInst->setMetadata(
+    MDBuilder MDB(NewInst.getContext());
+    NewInst.setMetadata(
         LLVMContext::MD_prof,
         MDB.createBranchWeights({static_cast<uint32_t>(Count)}));
   }
 
   using namespace ore;
 
   if (ORE)
     ORE->emit([&]() {
       return OptimizationRemark(DEBUG_TYPE, "Promoted", Inst)
              << "Promote indirect call to " << NV("DirectCallee", DirectCallee)
              << " with count " << NV("Count", Count) << " out of "
              << NV("TotalCount", TotalCount);
     });
-  return NewInst;
+  return &NewInst;
 }
 
 // Promote indirect-call to conditional direct-call for one callsite.
 uint32_t ICallPromotionFunc::tryToPromote(
     Instruction *Inst, const std::vector<PromotionCandidate> &Candidates,
     uint64_t &TotalCount) {
   uint32_t NumPromoted = 0;
 

llvm/lib/Transforms/Utils/CallPromotionUtils.cpp

 // direct call sites.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/CallPromotionUtils.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/TypeMetadataUtils.h"
 #include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "call-promotion-utils"
 
 /// Fix-up phi nodes in an invoke instruction's normal destination.
 ///

 ///   orig_bb:
 ///     %t0 = invoke i32 @func() to label %split_bb unwind label %unwind_dst
 ///
 ///   split_bb:
 ///     ; Uses of the original return value are replaced by uses of the bitcast.
 ///     %t1 = bitcast i32 %t0 to ...
 ///     br label %normal_dst
 ///
-static void createRetBitCast(CallSite CS, Type *RetTy, CastInst **RetBitCast) {
+static void createRetBitCast(CallBase &CB, Type *RetTy, CastInst **RetBitCast) {
 
   // Save the users of the calling instruction. These uses will be changed to
   // use the bitcast after we create it.
   SmallVector<User *, 16> UsersToUpdate;
-  for (User *U : CS.getInstruction()->users())
+  for (User *U : CB.users())
     UsersToUpdate.push_back(U);
 
   // Determine an appropriate location to create the bitcast for the return
   // value. The location depends on if we have a call or invoke instruction.
   Instruction *InsertBefore = nullptr;
-  if (auto *Invoke = dyn_cast<InvokeInst>(CS.getInstruction()))
+  if (auto *Invoke = dyn_cast<InvokeInst>(&CB))
     InsertBefore =
         &SplitEdge(Invoke->getParent(), Invoke->getNormalDest())->front();
   else
-    InsertBefore = &*std::next(CS.getInstruction()->getIterator());
+    InsertBefore = &*std::next(CB.getIterator());
 
   // Bitcast the return value to the correct type.
-  auto *Cast = CastInst::CreateBitOrPointerCast(CS.getInstruction(), RetTy, "",
-                                                InsertBefore);
+  auto *Cast = CastInst::CreateBitOrPointerCast(&CB, RetTy, "", InsertBefore);
   if (RetBitCast)
     *RetBitCast = Cast;
 
   // Replace all the original uses of the calling instruction with the bitcast.
   for (User *U : UsersToUpdate)
-    U->replaceUsesOfWith(CS.getInstruction(), Cast);
+    U->replaceUsesOfWith(&CB, Cast);
 }
 
 /// Predicate and clone the given call site.
 ///
 /// This function creates an if-then-else structure at the location of the call
 /// site. The "if" condition compares the call site's called value to the given
 /// callee. The original call site is moved into the "else" block, and a clone
 /// of the call site is placed in the "then" block. The cloned instruction is

 ///     %t0 = invoke i32 %ptr() to label %merge_bb unwind label %unwind_dst
 ///
 ///   merge_bb:
 ///     ; Uses of the original invoke instruction are replaced by uses of the
 ///     ; phi node, and the merge block branches to the normal destination.
 ///     %t2 = phi i32 [ %t0, %else_bb ], [ %t1, %then_bb ]
 ///     br %normal_dst
 ///
-static Instruction *versionCallSite(CallSite CS, Value *Callee,
-                                    MDNode *BranchWeights) {
+static CallBase &versionCallSite(CallBase &CB, Value *Callee,
 
-  IRBuilder<> Builder(CS.getInstruction());
-  Instruction *OrigInst = CS.getInstruction();
+  IRBuilder<> Builder(&CB);
+  CallBase *OrigInst = &CB;
   BasicBlock *OrigBlock = OrigInst->getParent();
 
   // Create the compare. The called value and callee must have the same type to
   // be compared.
-  if (CS.getCalledValue()->getType() != Callee->getType())
-    Callee = Builder.CreateBitCast(Callee, CS.getCalledValue()->getType());
-  auto *Cond = Builder.CreateICmpEQ(CS.getCalledValue(), Callee);
+  if (CB.getCalledValue()->getType() != Callee->getType())
+    Callee = Builder.CreateBitCast(Callee, CB.getCalledValue()->getType());
+  auto *Cond = Builder.CreateICmpEQ(CB.getCalledValue(), Callee);
 
   // Create an if-then-else structure. The original instruction is moved into
   // the "else" block, and a clone of the original instruction is placed in the
   // "then" block.
   Instruction *ThenTerm = nullptr;
   Instruction *ElseTerm = nullptr;
-  SplitBlockAndInsertIfThenElse(Cond, CS.getInstruction(), &ThenTerm, &ElseTerm,
-                                BranchWeights);
+  SplitBlockAndInsertIfThenElse(Cond, &CB, &ThenTerm, &ElseTerm, BranchWeights);
   BasicBlock *ThenBlock = ThenTerm->getParent();
   BasicBlock *ElseBlock = ElseTerm->getParent();
   BasicBlock *MergeBlock = OrigInst->getParent();
 
   ThenBlock->setName("if.true.direct_targ");
   ElseBlock->setName("if.false.orig_indirect");
   MergeBlock->setName("if.end.icp");
 
-  Instruction *NewInst = OrigInst->clone();
+  CallBase *NewInst = cast<CallBase>(OrigInst->clone());
   OrigInst->moveBefore(ElseTerm);
   NewInst->insertBefore(ThenTerm);
 
   // If the original call site is an invoke instruction, we have extra work to
   // do since invoke instructions are terminating. We have to fix-up phi nodes
   // in the invoke's normal and unwind destinations.
   if (auto *OrigInvoke = dyn_cast<InvokeInst>(OrigInst)) {
     auto *NewInvoke = cast<InvokeInst>(NewInst);
if (auto *OrigInvoke = dyn_cast<InvokeInst>(OrigInst)) {
     // "merge" block.
     OrigInvoke->setNormalDest(MergeBlock);
     NewInvoke->setNormalDest(MergeBlock);
   }
 
   // Create a phi node for the returned value of the call site.
   createRetPHINode(OrigInst, NewInst, MergeBlock, Builder);
 
-  return NewInst;
+  return *NewInst;
 }
 
-bool llvm::isLegalToPromote(CallSite CS, Function *Callee,
+bool llvm::isLegalToPromote(CallBase &CB, Function *Callee,
                             const char **FailureReason) {
-  assert(!CS.getCalledFunction() && "Only indirect call sites can be promoted");
+  assert(!CB.getCalledFunction() && "Only indirect call sites can be promoted");
 
   auto &DL = Callee->getParent()->getDataLayout();
 
   // Check the return type. The callee's return value type must be bitcast
   // compatible with the call site's type.
-  Type *CallRetTy = CS.getInstruction()->getType();
+  Type *CallRetTy = CB.getType();
   Type *FuncRetTy = Callee->getReturnType();
   if (CallRetTy != FuncRetTy)
     if (!CastInst::isBitOrNoopPointerCastable(FuncRetTy, CallRetTy, DL)) {
       if (FailureReason)
         *FailureReason = "Return type mismatch";
       return false;
     }
 
   // The number of formal arguments of the callee.
   unsigned NumParams = Callee->getFunctionType()->getNumParams();
 
   // Check the number of arguments. The callee and call site must agree on the
   // number of arguments.
-  if (CS.arg_size() != NumParams && !Callee->isVarArg()) {
+  if (CB.arg_size() != NumParams && !Callee->isVarArg()) {
     if (FailureReason)
       *FailureReason = "The number of arguments mismatch";
     return false;
   }
 
   // Check the argument types. The callee's formal argument types must be
   // bitcast compatible with the corresponding actual argument types of the call
   // site.
   for (unsigned I = 0; I < NumParams; ++I) {
     Type *FormalTy = Callee->getFunctionType()->getFunctionParamType(I);
-    Type *ActualTy = CS.getArgument(I)->getType();
+    Type *ActualTy = CB.getArgOperand(I)->getType();
     if (FormalTy == ActualTy)
       continue;
     if (!CastInst::isBitOrNoopPointerCastable(ActualTy, FormalTy, DL)) {
       if (FailureReason)
         *FailureReason = "Argument type mismatch";
       return false;
     }
   }
 
   return true;
 }
 
-Instruction *llvm::promoteCall(CallSite CS, Function *Callee,
-                               CastInst **RetBitCast) {
-  assert(!CS.getCalledFunction() && "Only indirect call sites can be promoted");
+CallBase &llvm::promoteCall(CallBase &CB, Function *Callee,
+  assert(!CB.getCalledFunction() && "Only indirect call sites can be promoted");
 
   // Set the called function of the call site to be the given callee (but don't
   // change the type).
-  cast<CallBase>(CS.getInstruction())->setCalledOperand(Callee);
+  CB.setCalledOperand(Callee);
 
   // Since the call site will no longer be direct, we must clear metadata that
   // is only appropriate for indirect calls. This includes !prof and !callees
   // metadata.
-  CS.getInstruction()->setMetadata(LLVMContext::MD_prof, nullptr);
-  CS.getInstruction()->setMetadata(LLVMContext::MD_callees, nullptr);
+  CB.setMetadata(LLVMContext::MD_prof, nullptr);
+  CB.setMetadata(LLVMContext::MD_callees, nullptr);
 
   // If the function type of the call site matches that of the callee, no
   // additional work is required.
-  if (CS.getFunctionType() == Callee->getFunctionType())
-    return CS.getInstruction();
+  if (CB.getFunctionType() == Callee->getFunctionType())
+    return CB;
 
   // Save the return types of the call site and callee.
-  Type *CallSiteRetTy = CS.getInstruction()->getType();
+  Type *CallSiteRetTy = CB.getType();
   Type *CalleeRetTy = Callee->getReturnType();
 
   // Change the function type of the call site the match that of the callee.
-  CS.mutateFunctionType(Callee->getFunctionType());
+  CB.mutateFunctionType(Callee->getFunctionType());
 
   // Inspect the arguments of the call site. If an argument's type doesn't
   // match the corresponding formal argument's type in the callee, bitcast it
   // to the correct type.
   auto CalleeType = Callee->getFunctionType();
   auto CalleeParamNum = CalleeType->getNumParams();
 
   LLVMContext &Ctx = Callee->getContext();
-  const AttributeList &CallerPAL = CS.getAttributes();
+  const AttributeList &CallerPAL = CB.getAttributes();
   // The new list of argument attributes.
   SmallVector<AttributeSet, 4> NewArgAttrs;
   bool AttributeChanged = false;
 
   for (unsigned ArgNo = 0; ArgNo < CalleeParamNum; ++ArgNo) {
-    auto *Arg = CS.getArgument(ArgNo);
+    auto *Arg = CB.getArgOperand(ArgNo);
     Type *FormalTy = CalleeType->getParamType(ArgNo);
     Type *ActualTy = Arg->getType();
     if (FormalTy != ActualTy) {
-      auto *Cast = CastInst::CreateBitOrPointerCast(Arg, FormalTy, "",
-                                                    CS.getInstruction());
-      CS.setArgument(ArgNo, Cast);
+      auto *Cast = CastInst::CreateBitOrPointerCast(Arg, FormalTy, "", &CB);
+      CB.setArgOperand(ArgNo, Cast);
 
       // Remove any incompatible attributes for the argument.
       AttrBuilder ArgAttrs(CallerPAL.getParamAttributes(ArgNo));
       ArgAttrs.remove(AttributeFuncs::typeIncompatible(FormalTy));
 
       // If byval is used, this must be a pointer type, and the byval type must
       // match the element type. Update it if present.
       if (ArgAttrs.getByValType()) {
         Type *NewTy = Callee->getParamByValType(ArgNo);
         ArgAttrs.addByValAttr(
             NewTy ? NewTy : cast<PointerType>(FormalTy)->getElementType());
       }
 
       NewArgAttrs.push_back(AttributeSet::get(Ctx, ArgAttrs));
       AttributeChanged = true;
     } else
       NewArgAttrs.push_back(CallerPAL.getParamAttributes(ArgNo));
   }
 
   // If the return type of the call site doesn't match that of the callee, cast
   // the returned value to the appropriate type.
   // Remove any incompatible return value attribute.
   AttrBuilder RAttrs(CallerPAL, AttributeList::ReturnIndex);
   if (!CallSiteRetTy->isVoidTy() && CallSiteRetTy != CalleeRetTy) {
-    createRetBitCast(CS, CallSiteRetTy, RetBitCast);
+    createRetBitCast(CB, CallSiteRetTy, RetBitCast);
     RAttrs.remove(AttributeFuncs::typeIncompatible(CalleeRetTy));
     AttributeChanged = true;
   }
 
   // Set the new callsite attribute.
   if (AttributeChanged)
-    CS.setAttributes(AttributeList::get(Ctx, CallerPAL.getFnAttributes(),
+    CB.setAttributes(AttributeList::get(Ctx, CallerPAL.getFnAttributes(),
                                         AttributeSet::get(Ctx, RAttrs),
                                         NewArgAttrs));
 
-  return CS.getInstruction();
+  return CB;
 }
 
-Instruction *llvm::promoteCallWithIfThenElse(CallSite CS, Function *Callee,
-                                             MDNode *BranchWeights) {
+CallBase &llvm::promoteCallWithIfThenElse(CallBase &CB, Function *Callee,
 
   // Version the indirect call site. If the called value is equal to the given
   // callee, 'NewInst' will be executed, otherwise the original call site will
   // be executed.
-  Instruction *NewInst = versionCallSite(CS, Callee, BranchWeights);
+  CallBase &NewInst = versionCallSite(CB, Callee, BranchWeights);
 
   // Promote 'NewInst' so that it directly calls the desired function.
-  return promoteCall(CallSite(NewInst), Callee);
+  return promoteCall(NewInst, Callee);
 }
 
-bool llvm::tryPromoteCall(CallSite &CS) {
-  assert(!CS.getCalledFunction());
-  Module *M = CS.getCaller()->getParent();
+bool llvm::tryPromoteCall(CallBase &CB) {
+  assert(!CB.getCalledFunction());
+  Module *M = CB.getCaller()->getParent();
   const DataLayout &DL = M->getDataLayout();
-  Value *Callee = CS.getCalledValue();
+  Value *Callee = CB.getCalledValue();
 
   LoadInst *VTableEntryLoad = dyn_cast<LoadInst>(Callee);
   if (!VTableEntryLoad)
     return false; // Not a vtable entry load.
   Value *VTableEntryPtr = VTableEntryLoad->getPointerOperand();
   APInt VTableOffset(DL.getTypeSizeInBits(VTableEntryPtr->getType()), 0);
   Value *VTableBasePtr = VTableEntryPtr->stripAndAccumulateConstantOffsets(
       DL, VTableOffset, /* AllowNonInbounds */ true);
Constant *Ptr = getPointerAtOffset(VTableGVInitializer,
                                      VTableGVOffset.getZExtValue(),
                                      *M);
   if (!Ptr)
     return false; // No constant (function) pointer found.
   Function *DirectCallee = dyn_cast<Function>(Ptr->stripPointerCasts());
   if (!DirectCallee)
     return false; // No function pointer found.
 
-  if (!isLegalToPromote(CS, DirectCallee))
+  if (!isLegalToPromote(CB, DirectCallee))
     return false;
 
   // Success.
-  promoteCall(CS, DirectCallee);
+  promoteCall(CB, DirectCallee);
   return true;
 }
 
 #undef DEBUG_TYPE

llvm/lib/Transforms/Utils/InlineFunction.cpp

 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Dominators.h"
llvm::InlineResult llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
   // blocks were actually inlined, collect the call sites. We only do this if
   // call graph updates weren't requested, as those provide value handle based
   // tracking of inlined call sites instead.
   if (InlinedFunctionInfo.ContainsCalls && !IFI.CG) {
     // Otherwise just collect the raw call sites that were inlined.
     for (BasicBlock &NewBB :
          make_range(FirstNewBlock->getIterator(), Caller->end()))
       for (Instruction &I : NewBB)
-        if (auto CS = CallSite(&I))
-          IFI.InlinedCallSites.push_back(CS);
+        if (auto *CB = dyn_cast<CallBase>(&I))
+          IFI.InlinedCallSites.push_back(CB);
   }
 
   // If we cloned in _exactly one_ basic block, and if that block ends in a
   // return instruction, we splice the body of the inlined callee directly into
   // the calling basic block.
   if (Returns.size() == 1 && std::distance(FirstNewBlock, Caller->end()) == 1) {
     // Move all of the instructions right before the call.
     OrigBB->getInstList().splice(TheCall->getIterator(),

llvm/unittests/Transforms/Utils/CallPromotionUtilsTest.cpp

)IR");
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS(CI);
-  ASSERT_FALSE(CS.getCalledFunction());
-  bool IsPromoted = tryPromoteCall(CS);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted = tryPromoteCall(*CI);
   EXPECT_TRUE(IsPromoted);
   GV = M->getNamedValue("_ZN4Impl3RunEv");
   ASSERT_TRUE(GV);
   auto *F1 = dyn_cast<Function>(GV);
-  EXPECT_EQ(F1, CS.getCalledFunction());
+  EXPECT_EQ(F1, CI->getCalledFunction());
 }
 
 TEST(CallPromotionUtilsTest, TryPromoteCall_NoFPLoad) {
   LLVMContext C;
   std::unique_ptr<Module> M = parseIR(C,
                                       R"IR(
 %class.Impl = type <{ %class.Interface, i32, [4 x i8] }>
 %class.Interface = type { i32 (...)** }
 
 define void @f(void (%class.Interface*)* %fp, %class.Interface* nonnull %base.i) {
 entry:
   call void %fp(%class.Interface* nonnull %base.i)
   ret void
 }
 )IR");
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS(CI);
-  ASSERT_FALSE(CS.getCalledFunction());
-  bool IsPromoted = tryPromoteCall(CS);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted = tryPromoteCall(*CI);
   EXPECT_FALSE(IsPromoted);
 }
 
 TEST(CallPromotionUtilsTest, TryPromoteCall_NoVTablePtrLoad) {
   LLVMContext C;
   std::unique_ptr<Module> M = parseIR(C,
                                       R"IR(
 %class.Impl = type <{ %class.Interface, i32, [4 x i8] }>
 %class.Interface = type { i32 (...)** }
 
 define void @f(void (%class.Interface*)** %vtable.i, %class.Interface* nonnull %base.i) {
 entry:
   %fp = load void (%class.Interface*)*, void (%class.Interface*)** %vtable.i
   call void %fp(%class.Interface* nonnull %base.i)
   ret void
 }
 )IR");
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS(CI);
-  ASSERT_FALSE(CS.getCalledFunction());
-  bool IsPromoted = tryPromoteCall(CS);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted = tryPromoteCall(*CI);
   EXPECT_FALSE(IsPromoted);
 }
 
 TEST(CallPromotionUtilsTest, TryPromoteCall_NoVTableInitFound) {
   LLVMContext C;
   std::unique_ptr<Module> M = parseIR(C,
                                       R"IR(
 %class.Impl = type <{ %class.Interface, i32, [4 x i8] }>
)IR");
 
   auto *GV = M->getNamedValue("f");
   ASSERT_TRUE(GV);
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS(CI);
-  ASSERT_FALSE(CS.getCalledFunction());
-  bool IsPromoted = tryPromoteCall(CS);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted = tryPromoteCall(*CI);
   EXPECT_FALSE(IsPromoted);
 }
 
 TEST(CallPromotionUtilsTest, TryPromoteCall_EmptyVTable) {
   LLVMContext C;
   std::unique_ptr<Module> M = parseIR(C,
                                       R"IR(
 %class.Impl = type <{ %class.Interface, i32, [4 x i8] }>
)IR");
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS(CI);
-  ASSERT_FALSE(CS.getCalledFunction());
-  bool IsPromoted = tryPromoteCall(CS);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted = tryPromoteCall(*CI);
   EXPECT_FALSE(IsPromoted);
 }
 
 TEST(CallPromotionUtilsTest, TryPromoteCall_NullFP) {
   LLVMContext C;
   std::unique_ptr<Module> M = parseIR(C,
                                       R"IR(
 %class.Impl = type <{ %class.Interface, i32, [4 x i8] }>
)IR");
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS(CI);
-  ASSERT_FALSE(CS.getCalledFunction());
-  bool IsPromoted = tryPromoteCall(CS);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted = tryPromoteCall(*CI);
   EXPECT_FALSE(IsPromoted);
 }
 
 // Based on clang/test/CodeGenCXX/member-function-pointer-calls.cpp
 TEST(CallPromotionUtilsTest, TryPromoteCall_MemberFunctionCalls) {
   LLVMContext C;
   std::unique_ptr<Module> M = parseIR(C,
                                       R"IR(
)IR");
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS1(CI);
-  ASSERT_FALSE(CS1.getCalledFunction());
-  bool IsPromoted1 = tryPromoteCall(CS1);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted1 = tryPromoteCall(*CI);
   EXPECT_TRUE(IsPromoted1);
   GV = M->getNamedValue("_ZN1A3vf1Ev");
   ASSERT_TRUE(GV);
   F = dyn_cast<Function>(GV);
-  EXPECT_EQ(F, CS1.getCalledFunction());
+  EXPECT_EQ(F, CI->getCalledFunction());
 
   GV = M->getNamedValue("_Z2g2v");
   ASSERT_TRUE(GV);
   F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Inst = &F->front().front();
   AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = &*++F->front().rbegin();
   CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS2(CI);
-  ASSERT_FALSE(CS2.getCalledFunction());
-  bool IsPromoted2 = tryPromoteCall(CS2);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted2 = tryPromoteCall(*CI);
   EXPECT_TRUE(IsPromoted2);
   GV = M->getNamedValue("_ZN1A3vf2Ev");
   ASSERT_TRUE(GV);
   F = dyn_cast<Function>(GV);
-  EXPECT_EQ(F, CS2.getCalledFunction());
+  EXPECT_EQ(F, CI->getCalledFunction());
 }
 
 // Check that it isn't crashing due to missing promotion legality.
 TEST(CallPromotionUtilsTest, TryPromoteCall_Legality) {
   LLVMContext C;
   std::unique_ptr<Module> M = parseIR(C,
                                       R"IR(
 %struct1 = type <{ i32, i64 }>
)IR");
   auto *F = dyn_cast<Function>(GV);
   ASSERT_TRUE(F);
   Instruction *Inst = &F->front().front();
   auto *AI = dyn_cast<AllocaInst>(Inst);
   ASSERT_TRUE(AI);
   Inst = &*++F->front().rbegin();
   auto *CI = dyn_cast<CallInst>(Inst);
   ASSERT_TRUE(CI);
-  CallSite CS(CI);
-  ASSERT_FALSE(CS.getCalledFunction());
-  bool IsPromoted = tryPromoteCall(CS);
+  ASSERT_FALSE(CI->getCalledFunction());
+  bool IsPromoted = tryPromoteCall(*CI);
   EXPECT_FALSE(IsPromoted);
 }