[CallSite removal][IPO] Move AbstractCallSite to its own header and change it to use CallBase instead of CallSite. NFCI

[craig.topper]

Summary

CallSite will likely be removed soon, but AbstractCallSite serves a different purpose and won't be going away.

This patch moves it to its own header and switches it to internally store a CallBase* instead of a CallSite. The only interface changes are the removal of the getCallSite function and getCallBackUses now takes a CallBase&. These methods had only a few callers that were easy enough to update without needing a compatibility shim.

[dblaikie]

Looks good - I'd probably have done it differently (waited until all the CallSite uses were eliminated, deleted that code from CallSite.h, then renamed CallSite.h to AbstractCallSite.h) because I /think/ it'd present easier/better revision history, but that's only based on /really/ vague guesses about how smart/not-smart the change tracking stuff is - in any case, dealer's choice :)

[craig.topper]

In D78322#1987472, @dblaikie wrote:

Looks good - I'd probably have done it differently (waited until all the CallSite uses were eliminated, deleted that code from CallSite.h, then renamed CallSite.h to AbstractCallSite.h) because I /think/ it'd present easier/better revision history, but that's only based on /really/ vague guesses about how smart/not-smart the change tracking stuff is - in any case, dealer's choice :)

That's good point. I mainly did it this way so I could remove the include of CallSite.h from Attributor so the compiler could tell me where all the uses of CallSite were.

[dblaikie]

In D78322#1987561, @craig.topper wrote:

In D78322#1987472, @dblaikie wrote:

Looks good - I'd probably have done it differently (waited until all the CallSite uses were eliminated, deleted that code from CallSite.h, then renamed CallSite.h to AbstractCallSite.h) because I /think/ it'd present easier/better revision history, but that's only based on /really/ vague guesses about how smart/not-smart the change tracking stuff is - in any case, dealer's choice :)

That's good point. I mainly did it this way so I could remove the include of CallSite.h from Attributor so the compiler could tell me where all the uses of CallSite were.

Yeah, figured it might be something like that - if you find it a good way to make progress, go for it. Super up to you :)

[craig.topper]

In D78322#1987667, @dblaikie wrote:

In D78322#1987561, @craig.topper wrote:

In D78322#1987472, @dblaikie wrote:

Looks good - I'd probably have done it differently (waited until all the CallSite uses were eliminated, deleted that code from CallSite.h, then renamed CallSite.h to AbstractCallSite.h) because I /think/ it'd present easier/better revision history, but that's only based on /really/ vague guesses about how smart/not-smart the change tracking stuff is - in any case, dealer's choice :)

That's good point. I mainly did it this way so I could remove the include of CallSite.h from Attributor so the compiler could tell me where all the uses of CallSite were.

Yeah, figured it might be something like that - if you find it a good way to make progress, go for it. Super up to you :)

Well removing the include didn't really help. Must be transitively included somewhere. So given that I'm going to just do the change to use CallBase in the implementation and not split the header.

[jdoerfert]

Thanks for updating this!

llvm/include/llvm/IR/CallSite.h

 public:
 
   /// The encoding of a callback with regards to the underlying instruction.
   struct CallbackInfo {
 
     /// For direct/indirect calls the parameter encoding is empty. If it is not,
     /// the abstract call site represents a callback. In that case, the first
     /// element of the encoding vector represents which argument of the call
-    /// site CS is the callback callee. The remaining elements map parameters
+    /// site CB is the callback callee. The remaining elements map parameters
     /// (identified by their position) to the arguments that will be passed
     /// through (also identified by position but in the call site instruction).
     ///
     /// NOTE that we use LLVM argument numbers (starting at 0) and not
     /// clang/source argument numbers (starting at 1). The -1 entries represent
     /// unknown values that are passed to the callee.
     using ParameterEncodingTy = SmallVector<int, 0>;
     ParameterEncodingTy ParameterEncoding;
 
   };
 
 private:
 
   /// The underlying call site:
   ///   caller -> callee,             if this is a direct or indirect call site
   ///   caller -> broker function,    if this is a callback call site
-  CallSite CS;
+  CallBase *CB;
 
   /// The encoding of a callback with regards to the underlying instruction.
   CallbackInfo CI;
 
 public:
   /// Sole constructor for abstract call sites (ACS).
   ///
   /// An abstract call site can only be constructed through a llvm::Use because
public:
   /// callback metadata is used to determine the argument <-> parameter mapping
   /// as well as the callee of the abstract call site.
   AbstractCallSite(const Use *U);
 
   /// Add operand uses of \p ICS that represent callback uses into \p CBUses.
   ///
   /// All uses added to \p CBUses can be used to create abstract call sites for
   /// which AbstractCallSite::isCallbackCall() will return true.
-  static void getCallbackUses(ImmutableCallSite ICS,
-                              SmallVectorImpl<const Use *> &CBUses);
+  static void getCallbackUses(const CallBase &CB,
+                              SmallVectorImpl<const Use *> &CallbackUses);
 
   /// Conversion operator to conveniently check for a valid/initialized ACS.
-  explicit operator bool() const { return (bool)CS; }
+  explicit operator bool() const { return CB != nullptr; }
 
   /// Return the underlying instruction.
-  Instruction *getInstruction() const { return CS.getInstruction(); }
-
-  /// Return the call site abstraction for the underlying instruction.
-  CallSite getCallSite() const { return CS; }
+  CallBase *getInstruction() const { return CB; }
 
   /// Return true if this ACS represents a direct call.
   bool isDirectCall() const {
-    return !isCallbackCall() && !CS.isIndirectCall();
+    return !isCallbackCall() && !CB->isIndirectCall();
   }
 
   /// Return true if this ACS represents an indirect call.
   bool isIndirectCall() const {
-    return !isCallbackCall() && CS.isIndirectCall();
+    return !isCallbackCall() && CB->isIndirectCall();
   }
 
   /// Return true if this ACS represents a callback call.
   bool isCallbackCall() const {
     // For a callback call site the callee is ALWAYS stored first in the
     // transitive values vector. Thus, a non-empty vector indicates a callback.
     return !CI.ParameterEncoding.empty();
   }
 
   /// Return true if @p UI is the use that defines the callee of this ACS.
   bool isCallee(Value::const_user_iterator UI) const {
     return isCallee(&UI.getUse());
   }
 
   /// Return true if @p U is the use that defines the callee of this ACS.
   bool isCallee(const Use *U) const {
     if (isDirectCall())
-      return CS.isCallee(U);
+      return CB->isCallee(U);
 
     assert(!CI.ParameterEncoding.empty() &&
            "Callback without parameter encoding!");
 
-    return (int)CS.getArgumentNo(U) == CI.ParameterEncoding[0];
+    return (int)CB->getArgOperandNo(U) == CI.ParameterEncoding[0];
   }
 
   /// Return the number of parameters of the callee.
   unsigned getNumArgOperands() const {
     if (isDirectCall())
-      return CS.getNumArgOperands();
+      return CB->getNumArgOperands();
     // Subtract 1 for the callee encoding.
     return CI.ParameterEncoding.size() - 1;
   }
 
   /// Return the operand index of the underlying instruction associated with @p
   /// Arg.
   int getCallArgOperandNo(Argument &Arg) const {
     return getCallArgOperandNo(Arg.getArgNo());
public:
   Value *getCallArgOperand(Argument &Arg) const {
     return getCallArgOperand(Arg.getArgNo());
   }
 
   /// Return the operand of the underlying instruction associated with the
   /// function parameter number @p ArgNo or nullptr if there is none.
   Value *getCallArgOperand(unsigned ArgNo) const {
     if (isDirectCall())
-      return CS.getArgOperand(ArgNo);
+      return CB->getArgOperand(ArgNo);
     // Add 1 for the callee encoding.
     return CI.ParameterEncoding[ArgNo + 1] >= 0
-               ? CS.getArgOperand(CI.ParameterEncoding[ArgNo + 1])
+               ? CB->getArgOperand(CI.ParameterEncoding[ArgNo + 1])
                : nullptr;
   }
 
   /// Return the operand index of the underlying instruction associated with the
   /// callee of this ACS. Only valid for callback calls!
   int getCallArgOperandNoForCallee() const {
     assert(isCallbackCall());
     assert(CI.ParameterEncoding.size() && CI.ParameterEncoding[0] >= 0);
     return CI.ParameterEncoding[0];
   }
 
   /// Return the use of the callee value in the underlying instruction. Only
   /// valid for callback calls!
   const Use &getCalleeUseForCallback() const {
     int CalleeArgIdx = getCallArgOperandNoForCallee();
     assert(CalleeArgIdx >= 0 &&
            unsigned(CalleeArgIdx) < getInstruction()->getNumOperands());
     return getInstruction()->getOperandUse(CalleeArgIdx);
   }
 
   /// Return the pointer to function that is being called.
   Value *getCalledValue() const {
     if (isDirectCall())
-      return CS.getCalledValue();
-    return CS.getArgOperand(getCallArgOperandNoForCallee());
+      return CB->getCalledValue();
+    return CB->getArgOperand(getCallArgOperandNoForCallee());
   }
 
   /// Return the function being called if this is a direct call, otherwise
   /// return null (if it's an indirect call).
   Function *getCalledFunction() const {
     Value *V = getCalledValue();
     return V ? dyn_cast<Function>(V->stripPointerCasts()) : nullptr;
   }

llvm/lib/IR/AbstractCallSite.cpp

STATISTIC(NumDirectAbstractCallSites,
           "Number of direct abstract call sites created");
 STATISTIC(NumInvalidAbstractCallSitesUnknownUse,
           "Number of invalid abstract call sites created (unknown use)");
 STATISTIC(NumInvalidAbstractCallSitesUnknownCallee,
           "Number of invalid abstract call sites created (unknown callee)");
 STATISTIC(NumInvalidAbstractCallSitesNoCallback,
           "Number of invalid abstract call sites created (no callback)");
 
-void AbstractCallSite::getCallbackUses(ImmutableCallSite ICS,
-                                       SmallVectorImpl<const Use *> &CBUses) {
-  const Function *Callee = ICS.getCalledFunction();
+void AbstractCallSite::getCallbackUses(const CallBase &CB,
+                                       SmallVectorImpl<const Use *> &CallbackUses) {
+  const Function *Callee = CB.getCalledFunction();
   if (!Callee)
     return;
 
   MDNode *CallbackMD = Callee->getMetadata(LLVMContext::MD_callback);
   if (!CallbackMD)
     return;
 
   for (const MDOperand &Op : CallbackMD->operands()) {
     MDNode *OpMD = cast<MDNode>(Op.get());
     auto *CBCalleeIdxAsCM = cast<ConstantAsMetadata>(OpMD->getOperand(0));
     uint64_t CBCalleeIdx =
         cast<ConstantInt>(CBCalleeIdxAsCM->getValue())->getZExtValue();
-    if (CBCalleeIdx < ICS.arg_size())
-      CBUses.push_back(ICS.arg_begin() + CBCalleeIdx);
+    if (CBCalleeIdx < CB.arg_size())
+      CallbackUses.push_back(CB.arg_begin() + CBCalleeIdx);
   }
 }
 
 /// Create an abstract call site from a use.
-AbstractCallSite::AbstractCallSite(const Use *U) : CS(U->getUser()) {
+AbstractCallSite::AbstractCallSite(const Use *U)
+    : CB(dyn_cast<CallBase>(U->getUser())) {
 
   // First handle unknown users.
-  if (!CS) {
+  if (!CB) {
 
     // If the use is actually in a constant cast expression which itself
     // has only one use, we look through the constant cast expression.
     // This happens by updating the use @p U to the use of the constant
-    // cast expression and afterwards re-initializing CS accordingly.
+    // cast expression and afterwards re-initializing CB accordingly.
     if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U->getUser()))
       if (CE->getNumUses() == 1 && CE->isCast()) {
         U = &*CE->use_begin();
-        CS = CallSite(U->getUser());
+        CB = dyn_cast<CallBase>(U->getUser());
       }
 
-    if (!CS) {
+    if (!CB) {
       NumInvalidAbstractCallSitesUnknownUse++;
       return;
     }
   }
 
   // Then handle direct or indirect calls. Thus, if U is the callee of the
-  // call site CS it is not a callback and we are done.
-  if (CS.isCallee(U)) {
+  // call site CB it is not a callback and we are done.
+  if (CB->isCallee(U)) {
     NumDirectAbstractCallSites++;
     return;
   }
 
   // If we cannot identify the broker function we cannot create a callback and
   // invalidate the abstract call site.
-  Function *Callee = CS.getCalledFunction();
+  Function *Callee = CB->getCalledFunction();
   if (!Callee) {
     NumInvalidAbstractCallSitesUnknownCallee++;
-    CS = CallSite();
+    CB = nullptr;
     return;
   }
 
   MDNode *CallbackMD = Callee->getMetadata(LLVMContext::MD_callback);
   if (!CallbackMD) {
     NumInvalidAbstractCallSitesNoCallback++;
-    CS = CallSite();
+    CB = nullptr;
     return;
   }
 
-  unsigned UseIdx = CS.getArgumentNo(U);
+  unsigned UseIdx = CB->getArgOperandNo(U);
   MDNode *CallbackEncMD = nullptr;
   for (const MDOperand &Op : CallbackMD->operands()) {
     MDNode *OpMD = cast<MDNode>(Op.get());
     auto *CBCalleeIdxAsCM = cast<ConstantAsMetadata>(OpMD->getOperand(0));
     uint64_t CBCalleeIdx =
         cast<ConstantInt>(CBCalleeIdxAsCM->getValue())->getZExtValue();
     if (CBCalleeIdx != UseIdx)
       continue;
     CallbackEncMD = OpMD;
     break;
   }
 
   if (!CallbackEncMD) {
     NumInvalidAbstractCallSitesNoCallback++;
-    CS = CallSite();
+    CB = nullptr;
     return;
   }
 
   NumCallbackCallSites++;
 
   assert(CallbackEncMD->getNumOperands() >= 2 && "Incomplete !callback metadata");
 
-  unsigned NumCallOperands = CS.getNumArgOperands();
+  unsigned NumCallOperands = CB->getNumArgOperands();
   // Skip the var-arg flag at the end when reading the metadata.
   for (unsigned u = 0, e = CallbackEncMD->getNumOperands() - 1; u < e; u++) {
     Metadata *OpAsM = CallbackEncMD->getOperand(u).get();
     auto *OpAsCM = cast<ConstantAsMetadata>(OpAsM);
     assert(OpAsCM->getType()->isIntegerTy(64) &&
            "Malformed !callback metadata");
 
     int64_t Idx = cast<ConstantInt>(OpAsCM->getValue())->getSExtValue();

llvm/lib/Transforms/IPO/Attributor.cpp

Argument *IRPosition::getAssociatedArgument() const {
   if (ArgNo < 0)
     return nullptr;
 
   // Use abstract call sites to make the connection between the call site
   // values and the ones in callbacks. If a callback was found that makes use
   // of the underlying call site operand, we want the corresponding callback
   // callee argument and not the direct callee argument.
   Optional<Argument *> CBCandidateArg;
-  SmallVector<const Use *, 4> CBUses;
-  ImmutableCallSite ICS(&getAnchorValue());
-  AbstractCallSite::getCallbackUses(ICS, CBUses);
-  for (const Use *U : CBUses) {
+  SmallVector<const Use *, 4> CallbackUses;
+  const auto &CB = cast<CallBase>(getAnchorValue());
+  AbstractCallSite::getCallbackUses(CB, CallbackUses);
+  for (const Use *U : CallbackUses) {
     AbstractCallSite ACS(U);
     assert(ACS && ACS.isCallbackCall());
     if (!ACS.getCalledFunction())
       continue;
 
     for (unsigned u = 0, e = ACS.getNumArgOperands(); u < e; u++) {
 
       // Test if the underlying call site operand is argument number u of the
Argument *IRPosition::getAssociatedArgument() const {
   }
 
   // If we found a unique callback candidate argument, return it.
   if (CBCandidateArg.hasValue() && CBCandidateArg.getValue())
     return CBCandidateArg.getValue();
 
   // If no callbacks were found, or none used the underlying call site operand
   // exclusively, use the direct callee argument if available.
-  const Function *Callee = ICS.getCalledFunction();
+  const Function *Callee = CB.getCalledFunction();
   if (Callee && Callee->arg_size() > unsigned(ArgNo))
     return Callee->getArg(ArgNo);
 
   return nullptr;
 }
 
 ChangeStatus AbstractAttribute::update(Attributor &A) {
   ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
static void createShallowWrapper(Function &F) {
   NumFnShallowWrapperCreated++;
 }
 
 bool Attributor::isValidFunctionSignatureRewrite(
     Argument &Arg, ArrayRef<Type *> ReplacementTypes) {
 
   auto CallSiteCanBeChanged = [](AbstractCallSite ACS) {
     // Forbid must-tail calls for now.
-    return !ACS.isCallbackCall() && !ACS.getCallSite().isMustTailCall();
+    return !ACS.isCallbackCall() && !ACS.getInstruction()->isMustTailCall();
   };
 
   Function *Fn = Arg.getParent();
   // Avoid var-arg functions for now.
   if (Fn->isVarArg()) {
     LLVM_DEBUG(dbgs() << "[Attributor] Cannot rewrite var-args functions\n");
     return false;
   }

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

if (!A.isValidFunctionSignatureRewrite(*Arg, ReplacementTypes)) {
       return indicatePessimisticFixpoint();
     }
 
     unsigned ArgNo = Arg->getArgNo();
 
     // Helper to check if for the given call site the associated argument is
     // passed to a callback where the privatization would be different.
     auto IsCompatiblePrivArgOfCallback = [&](CallSite CS) {
-      SmallVector<const Use *, 4> CBUses;
-      AbstractCallSite::getCallbackUses(CS, CBUses);
-      for (const Use *U : CBUses) {
+      SmallVector<const Use *, 4> CallbackUses;
+      AbstractCallSite::getCallbackUses(cast<CallBase>(*CS.getInstruction()),
+                                        CallbackUses);
+      for (const Use *U : CallbackUses) {
         AbstractCallSite CBACS(U);
         assert(CBACS && CBACS.isCallbackCall());
         for (Argument &CBArg : CBACS.getCalledFunction()->args()) {
           int CBArgNo = CBACS.getCallArgOperandNo(CBArg);
 
           LLVM_DEBUG({
             dbgs()
                 << "[AAPrivatizablePtr] Argument " << *Arg
auto IsCompatiblePrivArgOfDirectCS = [&](AbstractCallSite ACS) {
       }
 
       LLVM_DEBUG({
         dbgs() << "[AAPrivatizablePtr] Argument " << *Arg
                << " cannot be privatized in the context of its parent ("
                << Arg->getParent()->getName()
                << ")\n[AAPrivatizablePtr] because it is an argument in a "
                   "direct call of ("
-               << ACS.getCallSite().getCalledFunction()->getName()
+               << ACS.getInstruction()->getCalledFunction()->getName()
                << ").\n[AAPrivatizablePtr] for which the argument "
                   "privatization is not compatible.\n";
       });
       return false;
     };
 
     // Helper to check if the associated argument is used at the given abstract
     // call site in a way that is incompatible with the privatization assumed
     // here.
     auto IsCompatiblePrivArgOfOtherCallSite = [&](AbstractCallSite ACS) {
       if (ACS.isDirectCall())
-        return IsCompatiblePrivArgOfCallback(ACS.getCallSite());
+        return IsCompatiblePrivArgOfCallback(CallSite(ACS.getInstruction()));
       if (ACS.isCallbackCall())
         return IsCompatiblePrivArgOfDirectCS(ACS);
       return false;
     };
 
     bool AllCallSitesKnown;
     if (!A.checkForAllCallSites(IsCompatiblePrivArgOfOtherCallSite, *this, true,
                                 AllCallSitesKnown))