[Attributor][NFC] Replace call site with call base.

[kuter]

Summary

This patch replaces call site.... with call base to be more consistent with the rest of the LLVM.

[sstefan1]

Personally, callsite still sounds more natural in some places, but LGTM.

Probably wait a little bit for someone else to see as well.

[uenoku]

I think replacing all makes the code hard to understand (because "call base" is just a name of LLVM class)
Personally, I prefer maintaining "call site"

[kuter]

In D82625#2116406, @uenoku wrote:

I think replacing all makes the code hard to understand (because "call base" is just a name of LLVM class)
Personally, I prefer maintaining "call site"

Thanks for the feedback. I think It would make sense to call it "call base" since we are making deductions on the LLVM IR.
I think it doesn't make sense to use IRPosition::callsite... when you want to make deductions about a CallBase.

[jdoerfert]

I'm on the fence on this one. It makes sense when we talk about the instructions, it doesn't really if we talk about the concept, and I don't really want to mix the two wordings.
Let's postpone this for now and you ping it in a week or so, maybe my subconscious mind will have formed a more useful opinion by then.

[xbolva00]

IMHO we should preserve “Call sites” here. (Comments with “call bases” look strange)

llvm/include/llvm/Transforms/IPO/Attributor.h

 // The "mechanics" of adding a new "abstract attribute":
 // - Define a class (transitively) inheriting from AbstractAttribute and one
 //   (which could be the same) that (transitively) inherits from AbstractState.
 //   For the latter, consider the already available BooleanState and
 //   {Inc,Dec,Bit}IntegerState if they fit your needs, e.g., you require only a
 //   number tracking or bit-encoding.
 // - Implement all pure methods. Also use overloading if the attribute is not
 //   conforming with the "default" behavior: A (set of) LLVM-IR attribute(s) for
-//   an argument, call site argument, function return value, or function. See
+//   an argument, call base argument, function return value, or function. See
 //   the class and method descriptions for more information on the two
 //   "Abstract" classes and their respective methods.
 // - Register opportunities for the new abstract attribute in the
 //   `Attributor::identifyDefaultAbstractAttributes` method if it should be
 //   counted as a 'default' attribute.
 // - Add sufficient tests.
 // - Add a Statistics object for bookkeeping. If it is a simple (set of)
 //   attribute(s) manifested through the Attributor manifestation framework, see
enum class DepClassTy {
   REQUIRED,
   OPTIONAL,
 };
 ///}
 
 /// Helper to describe and deal with positions in the LLVM-IR.
 ///
 /// A position in the IR is described by an anchor value and an "offset" that
-/// could be the argument number, for call sites and arguments, or an indicator
+/// could be the argument number, for call bases and arguments, or an indicator
 /// of the "position kind". The kinds, specified in the Kind enum below, include
 /// the locations in the attribute list, i.a., function scope and return value,
-/// as well as a distinction between call sites and functions. Finally, there
+/// as well as a distinction between call bases and functions. Finally, there
 /// are floating values that do not have a corresponding attribute list
 /// position.
 struct IRPosition {
 
   /// The positions we distinguish in the IR.
   enum Kind : char {
     IRP_INVALID,  ///< An invalid position.
     IRP_FLOAT,    ///< A position that is not associated with a spot suitable
                   ///< for attributes. This could be any value or instruction.
     IRP_RETURNED, ///< An attribute for the function return value.
-    IRP_CALL_SITE_RETURNED, ///< An attribute for a call site return value.
+    IRP_CALL_BASE_RETURNED, ///< An attribute for a call base return value.
     IRP_FUNCTION,           ///< An attribute for a function (scope).
-    IRP_CALL_SITE,          ///< An attribute for a call site (function scope).
+    IRP_CALL_BASE,          ///< An attribute for a call base (function scope).
     IRP_ARGUMENT,           ///< An attribute for a function argument.
-    IRP_CALL_SITE_ARGUMENT, ///< An attribute for a call site argument.
+    IRP_CALL_BASE_ARGUMENT, ///< An attribute for a call base argument.
   };
 
   /// Default constructor available to create invalid positions implicitly. All
   /// other positions need to be created explicitly through the appropriate
   /// static member function.
   IRPosition() : Enc(nullptr, ENC_VALUE) { verify(); }
 
   /// Create a position describing the value of \p V.
   static const IRPosition value(const Value &V) {
     if (auto *Arg = dyn_cast<Argument>(&V))
       return IRPosition::argument(*Arg);
     if (auto *CB = dyn_cast<CallBase>(&V))
-      return IRPosition::callsite_returned(*CB);
+      return IRPosition::callbase_returned(*CB);
     return IRPosition(const_cast<Value &>(V), IRP_FLOAT);
   }
 
   /// Create a position describing the function scope of \p F.
   static const IRPosition function(const Function &F) {
     return IRPosition(const_cast<Function &>(F), IRP_FUNCTION);
   }
 
   /// Create a position describing the returned value of \p F.
   static const IRPosition returned(const Function &F) {
     return IRPosition(const_cast<Function &>(F), IRP_RETURNED);
   }
 
   /// Create a position describing the argument \p Arg.
   static const IRPosition argument(const Argument &Arg) {
     return IRPosition(const_cast<Argument &>(Arg), IRP_ARGUMENT);
   }
 
   /// Create a position describing the function scope of \p CB.
-  static const IRPosition callsite_function(const CallBase &CB) {
-    return IRPosition(const_cast<CallBase &>(CB), IRP_CALL_SITE);
+  static const IRPosition callbase_function(const CallBase &CB) {
+    return IRPosition(const_cast<CallBase &>(CB), IRP_CALL_BASE);
   }
 
   /// Create a position describing the returned value of \p CB.
-  static const IRPosition callsite_returned(const CallBase &CB) {
-    return IRPosition(const_cast<CallBase &>(CB), IRP_CALL_SITE_RETURNED);
+  static const IRPosition callbase_returned(const CallBase &CB) {
+    return IRPosition(const_cast<CallBase &>(CB), IRP_CALL_BASE_RETURNED);
   }
 
   /// Create a position describing the argument of \p CB at position \p ArgNo.
-  static const IRPosition callsite_argument(const CallBase &CB,
+  static const IRPosition callbase_argument(const CallBase &CB,
                                             unsigned ArgNo) {
     return IRPosition(const_cast<Use &>(CB.getArgOperandUse(ArgNo)),
-                      IRP_CALL_SITE_ARGUMENT);
+                      IRP_CALL_BASE_ARGUMENT);
   }
 
   /// Create a position describing the argument of \p ACS at position \p ArgNo.
-  static const IRPosition callsite_argument(AbstractCallSite ACS,
+  static const IRPosition callbase_argument(AbstractCallSite ACS,
                                             unsigned ArgNo) {
     if (ACS.getNumArgOperands() <= ArgNo)
       return IRPosition();
     int CSArgNo = ACS.getCallArgOperandNo(ArgNo);
     if (CSArgNo >= 0)
-      return IRPosition::callsite_argument(
+      return IRPosition::callbase_argument(
           cast<CallBase>(*ACS.getInstruction()), CSArgNo);
     return IRPosition();
   }
 
   /// Create a position with function scope matching the "context" of \p IRP.
-  /// If \p IRP is a call site (see isAnyCallSitePosition()) then the result
-  /// will be a call site position, otherwise the function position of the
+  /// If \p IRP is a call base (see isAnyCallBasePosition()) then the result
+  /// will be a call base position, otherwise the function position of the
   /// associated function.
   static const IRPosition function_scope(const IRPosition &IRP) {
-    if (IRP.isAnyCallSitePosition()) {
-      return IRPosition::callsite_function(
+    if (IRP.isAnyCallBasePosition()) {
+      return IRPosition::callbase_function(
           cast<CallBase>(IRP.getAnchorValue()));
     }
     assert(IRP.getAssociatedFunction());
     return IRPosition::function(*IRP.getAssociatedFunction());
   }
 
   bool operator==(const IRPosition &RHS) const { return Enc == RHS.Enc; }
   bool operator!=(const IRPosition &RHS) const { return !(*this == RHS); }
 
   /// Return the value this abstract attribute is anchored with.
   ///
   /// The anchor value might not be the associated value if the latter is not
   /// sufficient to determine where arguments will be manifested. This is, so
-  /// far, only the case for call site arguments as the value is not sufficient
-  /// to pinpoint them. Instead, we can use the call site as an anchor.
+  /// far, only the case for call base arguments as the value is not sufficient
+  /// to pinpoint them. Instead, we can use the call base as an anchor.
   Value &getAnchorValue() const {
     switch (getEncodingBits()) {
     case ENC_VALUE:
     case ENC_RETURNED_VALUE:
     case ENC_FLOATING_FUNCTION:
       return *getAsValuePtr();
-    case ENC_CALL_SITE_ARGUMENT_USE:
+    case ENC_CALL_BASE_ARGUMENT_USE:
       return *(getAsUsePtr()->getUser());
     default:
       llvm_unreachable("Unkown encoding!");
     };
   }
 
   /// Return the associated function, if any.
   Function *getAssociatedFunction() const {
struct IRPosition {
   /// Return the type this abstract attribute is associated with.
   Type *getAssociatedType() const {
     if (getPositionKind() == IRPosition::IRP_RETURNED)
       return getAssociatedFunction()->getReturnType();
     return getAssociatedValue().getType();
   }
 
   /// Return the argument number of the associated value if it is an argument or
-  /// call site argument, otherwise a negative value.
+  /// call base argument, otherwise a negative value.
   int getArgNo() const {
     switch (getPositionKind()) {
     case IRPosition::IRP_ARGUMENT:
       return cast<Argument>(getAsValuePtr())->getArgNo();
-    case IRPosition::IRP_CALL_SITE_ARGUMENT: {
+    case IRPosition::IRP_CALL_BASE_ARGUMENT: {
       Use &U = *getAsUsePtr();
       return cast<CallBase>(U.getUser())->getArgOperandNo(&U);
     }
     default:
       return -1;
     }
   }
 
   /// Return the index in the attribute list for this position.
   unsigned getAttrIdx() const {
     switch (getPositionKind()) {
     case IRPosition::IRP_INVALID:
     case IRPosition::IRP_FLOAT:
       break;
     case IRPosition::IRP_FUNCTION:
-    case IRPosition::IRP_CALL_SITE:
+    case IRPosition::IRP_CALL_BASE:
       return AttributeList::FunctionIndex;
     case IRPosition::IRP_RETURNED:
-    case IRPosition::IRP_CALL_SITE_RETURNED:
+    case IRPosition::IRP_CALL_BASE_RETURNED:
       return AttributeList::ReturnIndex;
     case IRPosition::IRP_ARGUMENT:
-    case IRPosition::IRP_CALL_SITE_ARGUMENT:
+    case IRPosition::IRP_CALL_BASE_ARGUMENT:
       return getArgNo() + AttributeList::FirstArgIndex;
     }
     llvm_unreachable(
         "There is no attribute index for a floating or invalid position!");
   }
 
   /// Return the associated position kind.
   Kind getPositionKind() const {
     char EncodingBits = getEncodingBits();
-    if (EncodingBits == ENC_CALL_SITE_ARGUMENT_USE)
-      return IRP_CALL_SITE_ARGUMENT;
+    if (EncodingBits == ENC_CALL_BASE_ARGUMENT_USE)
+      return IRP_CALL_BASE_ARGUMENT;
     if (EncodingBits == ENC_FLOATING_FUNCTION)
       return IRP_FLOAT;
 
     Value *V = getAsValuePtr();
     if (!V)
       return IRP_INVALID;
     if (isa<Argument>(V))
       return IRP_ARGUMENT;
     if (isa<Function>(V))
       return isReturnPosition(EncodingBits) ? IRP_RETURNED : IRP_FUNCTION;
     if (isa<CallBase>(V))
-      return isReturnPosition(EncodingBits) ? IRP_CALL_SITE_RETURNED
-                                            : IRP_CALL_SITE;
+      return isReturnPosition(EncodingBits) ? IRP_CALL_BASE_RETURNED
+                                            : IRP_CALL_BASE;
     return IRP_FLOAT;
   }
 
   /// TODO: Figure out if the attribute related helper functions should live
   ///       here or somewhere else.
 
   /// Return true if any kind in \p AKs existing in the IR at a position that
   /// will affect this one. See also getAttrs(...).
for (Attribute::AttrKind AK : AKs)
       AttrList = AttrList.removeAttribute(Ctx, getAttrIdx(), AK);
 
     if (CB)
       CB->setAttributes(AttrList);
     else
       getAssociatedFunction()->setAttributes(AttrList);
   }
 
-  bool isAnyCallSitePosition() const {
+  bool isAnyCallBasePosition() const {
     switch (getPositionKind()) {
-    case IRPosition::IRP_CALL_SITE:
-    case IRPosition::IRP_CALL_SITE_RETURNED:
-    case IRPosition::IRP_CALL_SITE_ARGUMENT:
+    case IRPosition::IRP_CALL_BASE:
+    case IRPosition::IRP_CALL_BASE_RETURNED:
+    case IRPosition::IRP_CALL_BASE_ARGUMENT:
       return true;
     default:
       return false;
     }
   }
 
   /// Special DenseMap key values.
   ///
explicit IRPosition(Value &AnchorVal, Kind PK) {
     case IRPosition::IRP_FLOAT:
       // Special case for floating functions.
       if (isa<Function>(AnchorVal))
         Enc = {&AnchorVal, ENC_FLOATING_FUNCTION};
       else
         Enc = {&AnchorVal, ENC_VALUE};
       break;
     case IRPosition::IRP_FUNCTION:
-    case IRPosition::IRP_CALL_SITE:
+    case IRPosition::IRP_CALL_BASE:
       Enc = {&AnchorVal, ENC_VALUE};
       break;
     case IRPosition::IRP_RETURNED:
-    case IRPosition::IRP_CALL_SITE_RETURNED:
+    case IRPosition::IRP_CALL_BASE_RETURNED:
       Enc = {&AnchorVal, ENC_RETURNED_VALUE};
       break;
     case IRPosition::IRP_ARGUMENT:
       Enc = {&AnchorVal, ENC_VALUE};
       break;
-    case IRPosition::IRP_CALL_SITE_ARGUMENT:
+    case IRPosition::IRP_CALL_BASE_ARGUMENT:
       llvm_unreachable(
-          "Cannot create call site argument IRP with an anchor value!");
+          "Cannot create call base argument IRP with an anchor value!");
       break;
     }
     verify();
   }
 
   /// IRPosition for the use \p U. The position kind \p PK needs to be
-  /// IRP_CALL_SITE_ARGUMENT, the anchor value is the user, the associated value
+  /// IRP_CALL_BASE_ARGUMENT, the anchor value is the user, the associated value
   /// the used value.
   explicit IRPosition(Use &U, Kind PK) {
-    assert(PK == IRP_CALL_SITE_ARGUMENT &&
-           "Use constructor is for call site arguments only!");
-    Enc = {&U, ENC_CALL_SITE_ARGUMENT_USE};
+    assert(PK == IRP_CALL_BASE_ARGUMENT &&
+           "Use constructor is for call base arguments only!");
+    Enc = {&U, ENC_CALL_BASE_ARGUMENT_USE};
     verify();
   }
 
   /// Verify internal invariants.
   void verify();
 
   /// Return the attributes of kind \p AK existing in the IR as attribute.
   bool getAttrsFromIRAttr(Attribute::AttrKind AK,
                           SmallVectorImpl<Attribute> &Attrs) const;
 
   /// Return the attributes of kind \p AK existing in the IR as operand bundles
   /// of an llvm.assume.
   bool getAttrsFromAssumes(Attribute::AttrKind AK,
                            SmallVectorImpl<Attribute> &Attrs,
                            Attributor &A) const;
 
   /// Return the underlying pointer as Value *, valid for all positions but
-  /// IRP_CALL_SITE_ARGUMENT.
+  /// IRP_CALL_BASE_ARGUMENT.
   Value *getAsValuePtr() const {
-    assert(getEncodingBits() != ENC_CALL_SITE_ARGUMENT_USE &&
+    assert(getEncodingBits() != ENC_CALL_BASE_ARGUMENT_USE &&
            "Not a value pointer!");
     return reinterpret_cast<Value *>(Enc.getPointer());
   }
 
   /// Return the underlying pointer as Use *, valid only for
-  /// IRP_CALL_SITE_ARGUMENT positions.
+  /// IRP_CALL_BASE_ARGUMENT positions.
   Use *getAsUsePtr() const {
-    assert(getEncodingBits() == ENC_CALL_SITE_ARGUMENT_USE &&
+    assert(getEncodingBits() == ENC_CALL_BASE_ARGUMENT_USE &&
            "Not a value pointer!");
     return reinterpret_cast<Use *>(Enc.getPointer());
   }
 
-  /// Return true if \p EncodingBits describe a returned or call site returned
+  /// Return true if \p EncodingBits describe a returned or call base returned
   /// position.
   static bool isReturnPosition(char EncodingBits) {
     return EncodingBits == ENC_RETURNED_VALUE;
   }
 
-  /// Return true if the encoding bits describe a returned or call site returned
+  /// Return true if the encoding bits describe a returned or call base returned
   /// position.
   bool isReturnPosition() const { return isReturnPosition(getEncodingBits()); }
 
   /// The encoding of the IRPosition is a combination of a pointer and two
   /// encoding bits. The values of the encoding bits are defined in the enum
   /// below. The pointer is either a Value* (for the first three encoding bit
-  /// combinations) or Use* (for ENC_CALL_SITE_ARGUMENT_USE).
+  /// combinations) or Use* (for ENC_CALL_BASE_ARGUMENT_USE).
   ///
   ///{
   enum {
     ENC_VALUE = 0b00,
     ENC_RETURNED_VALUE = 0b01,
     ENC_FLOATING_FUNCTION = 0b10,
-    ENC_CALL_SITE_ARGUMENT_USE = 0b11,
+    ENC_CALL_BASE_ARGUMENT_USE = 0b11,
   };
 
   // Reserve the maximal amount of bits so there is no need to mask out the
   // remaining ones. We will not encode anything else in the pointer anyway.
   static constexpr int NumEncodingBits =
       PointerLikeTypeTraits<void *>::NumLowBitsAvailable;
   static_assert(NumEncodingBits >= 2, "At least two bits are required!");
 

 /// holds for a subsuming position, it also holds for the position P.
 ///
 /// The subsuming positions always include the initial position and then,
 /// depending on the position kind, additionally the following ones:
 /// - for IRP_RETURNED:
 ///   - the function (IRP_FUNCTION)
 /// - for IRP_ARGUMENT:
 ///   - the function (IRP_FUNCTION)
-/// - for IRP_CALL_SITE:
+/// - for IRP_CALL_BASE:
 ///   - the callee (IRP_FUNCTION), if known
-/// - for IRP_CALL_SITE_RETURNED:
+/// - for IRP_CALL_BASE_RETURNED:
 ///   - the callee (IRP_RETURNED), if known
-///   - the call site (IRP_FUNCTION)
+///   - the call base (IRP_FUNCTION)
 ///   - the callee (IRP_FUNCTION), if known
-/// - for IRP_CALL_SITE_ARGUMENT:
+/// - for IRP_CALL_BASE_ARGUMENT:
 ///   - the argument of the callee (IRP_ARGUMENT), if known
 ///   - the callee (IRP_FUNCTION), if known
-///   - the position the call site argument is associated with if it is not
-///     anchored to the call site, e.g., if it is an argument then the argument
+///   - the position the call base argument is associated with if it is not
+///     anchored to the call base, e.g., if it is an argument then the argument
 ///     (IRP_ARGUMENT)
 class SubsumingPositionIterator {
   SmallVector<IRPosition, 4> IRPositions;
   using iterator = decltype(IRPositions)::iterator;
 
 public:
   SubsumingPositionIterator(const IRPosition &IRP);
   iterator begin() { return IRPositions.begin(); }
const AAType &getOrCreateAAFor(const IRPosition &IRP,
     // For now we ignore naked and optnone functions.
     bool Invalidate = Allowed && !Allowed->count(&AAType::ID);
     const Function *FnScope = IRP.getAnchorScope();
     if (FnScope)
       Invalidate |= FnScope->hasFnAttribute(Attribute::Naked) ||
                     FnScope->hasFnAttribute(Attribute::OptimizeNone);
 
     // Bootstrap the new attribute with an initial update to propagate
-    // information, e.g., function -> call site. If it is not on a given
+    // information, e.g., function -> call base. If it is not on a given
     // Allowed we will not perform updates at all.
     if (Invalidate) {
       AA.getState().indicatePessimisticFixpoint();
       return AA;
     }
 
     AA.initialize(*this);
 
struct ArgumentReplacementInfo {
     /// The function repair callback is invoked once to rewire the replacement
     /// arguments in the body of the new function. The argument replacement info
     /// is passed, as build from the registerFunctionSignatureRewrite call, as
     /// well as the replacement function and an iteratore to the first
     /// replacement argument.
     using CalleeRepairCBTy = std::function<void(
         const ArgumentReplacementInfo &, Function &, Function::arg_iterator)>;
 
-    /// Abstract call site (ACS) repair callback type
+    /// Abstract call base (ACS) repair callback type
     ///
-    /// The abstract call site repair callback is invoked once on every abstract
-    /// call site of the replaced function (\see ReplacedFn). The callback needs
+    /// The abstract call base repair callback is invoked once on every abstract
+    /// call base of the replaced function (\see ReplacedFn). The callback needs
     /// to provide the operands for the call to the new replacement function.
     /// The number and type of the operands appended to the provided vector
     /// (second argument) is defined by the number and types determined through
     /// the replacement type vector (\see ReplacementTypes). The first argument
     /// is the ArgumentReplacementInfo object registered with the Attributor
     /// through the registerFunctionSignatureRewrite call.
     using ACSRepairCBTy =
         std::function<void(const ArgumentReplacementInfo &, AbstractCallSite,
struct ArgumentReplacementInfo {
     const SmallVectorImpl<Type *> &getReplacementTypes() const {
       return ReplacementTypes;
     }
 
     ///}
 
   private:
     /// Constructor that takes the argument to be replaced, the types of
-    /// the replacement arguments, as well as callbacks to repair the call sites
+    /// the replacement arguments, as well as callbacks to repair the call bases
     /// and new function after the replacement happened.
     ArgumentReplacementInfo(Attributor &A, Argument &Arg,
                             ArrayRef<Type *> ReplacementTypes,
                             CalleeRepairCBTy &&CalleeRepairCB,
                             ACSRepairCBTy &&ACSRepairCB)
         : A(A), ReplacedFn(*Arg.getParent()), ReplacedArg(Arg),
           ReplacementTypes(ReplacementTypes.begin(), ReplacementTypes.end()),
           CalleeRepairCB(std::move(CalleeRepairCB)),
private:
     const Argument &ReplacedArg;
 
     /// The types of the arguments replacing ReplacedArg.
     const SmallVector<Type *, 8> ReplacementTypes;
 
     /// Callee repair callback, see CalleeRepairCBTy.
     const CalleeRepairCBTy CalleeRepairCB;
 
-    /// Abstract call site (ACS) repair callback, see ACSRepairCBTy.
+    /// Abstract call base (ACS) repair callback, see ACSRepairCBTy.
     const ACSRepairCBTy ACSRepairCB;
 
     /// Allow access to the private members from the Attributor.
     friend struct Attributor;
   };
 
   /// Check if we can rewrite a function signature.
   ///
   /// The argument \p Arg is replaced with new ones defined by the number,
   /// order, and types in \p ReplacementTypes.
   ///
   /// \returns True, if the replacement can be registered, via
   /// registerFunctionSignatureRewrite, false otherwise.
   bool isValidFunctionSignatureRewrite(Argument &Arg,
                                        ArrayRef<Type *> ReplacementTypes);
 
   /// Register a rewrite for a function signature.
   ///
   /// The argument \p Arg is replaced with new ones defined by the number,
-  /// order, and types in \p ReplacementTypes. The rewiring at the call sites is
+  /// order, and types in \p ReplacementTypes. The rewiring at the call bases is
   /// done through \p ACSRepairCB and at the callee site through
   /// \p CalleeRepairCB.
   ///
   /// \returns True, if the replacement was registered, false otherwise.
   bool registerFunctionSignatureRewrite(
       Argument &Arg, ArrayRef<Type *> ReplacementTypes,
       ArgumentReplacementInfo::CalleeRepairCBTy &&CalleeRepairCB,
       ArgumentReplacementInfo::ACSRepairCBTy &&ACSRepairCB);
 
-  /// Check \p Pred on all function call sites.
+  /// Check \p Pred on all function call bases.
   ///
-  /// This method will evaluate \p Pred on call sites and return
-  /// true if \p Pred holds in every call sites. However, this is only possible
-  /// all call sites are known, hence the function has internal linkage.
-  /// If true is returned, \p AllCallSitesKnown is set if all possible call
+  /// This method will evaluate \p Pred on call bases and return
+  /// true if \p Pred holds in every call bases. However, this is only possible
+  /// all call bases are known, hence the function has internal linkage.
+  /// If true is returned, \p AllCallBasesKnown is set if all possible call
   /// sites of the function have been visited.
-  bool checkForAllCallSites(function_ref<bool(AbstractCallSite)> Pred,
+  bool checkForAllCallBases(function_ref<bool(AbstractCallSite)> Pred,
                             const AbstractAttribute &QueryingAA,
-                            bool RequireAllCallSites, bool &AllCallSitesKnown);
+                            bool RequireAllCallBases, bool &AllCallBasesKnown);
 
   /// Check \p Pred on all values potentially returned by \p F.
   ///
   /// This method will evaluate \p Pred on all values potentially returned by
   /// the function associated with \p QueryingAA. The returned values are
   /// matched with their respective return instructions. Returns true if \p Pred
   /// holds on all of them.
   bool checkForAllReturnedValuesAndReturnInsts(
private:
   /// Run `::update` on \p AA and track the dependences queried while doing so.
   /// Also adjust the state if we know further updates are not necessary.
   ChangeStatus updateAA(AbstractAttribute &AA);
 
   /// Remember the dependences on the top of the dependence stack such that they
   /// may trigger further updates. (\see DependenceStack)
   void rememberDependences();
 
-  /// Check \p Pred on all call sites of \p Fn.
+  /// Check \p Pred on all call bases of \p Fn.
   ///
-  /// This method will evaluate \p Pred on call sites and return
-  /// true if \p Pred holds in every call sites. However, this is only possible
-  /// all call sites are known, hence the function has internal linkage.
-  /// If true is returned, \p AllCallSitesKnown is set if all possible call
+  /// This method will evaluate \p Pred on call bases and return
+  /// true if \p Pred holds in every call bases. However, this is only possible
+  /// all call bases are known, hence the function has internal linkage.
+  /// If true is returned, \p AllCallBasesKnown is set if all possible call
   /// sites of the function have been visited.
-  bool checkForAllCallSites(function_ref<bool(AbstractCallSite)> Pred,
-                            const Function &Fn, bool RequireAllCallSites,
+  bool checkForAllCallBases(function_ref<bool(AbstractCallSite)> Pred,
+                            const Function &Fn, bool RequireAllCallBases,
                             const AbstractAttribute *QueryingAA,
-                            bool &AllCallSitesKnown);
+                            bool &AllCallBasesKnown);
 
   /// Apply all requested function signature rewrites
   /// (\see registerFunctionSignatureRewrite) and return Changed if the module
   /// was altered.
   ChangeStatus
   rewriteFunctionSignatures(SmallPtrSetImpl<Function *> &ModifiedFns);
 
   /// The set of all abstract attributes.

 /// exposed. In the most common case, the `updateImpl` will go through a list of
 /// reasons why its optimistic state is valid given the current information. If
 /// any combination of them holds and is sufficient to justify the current
 /// optimistic state, the method shall return UNCHAGED. If not, the optimistic
 /// state is adjusted to the situation and the method shall return CHANGED.
 ///
 /// If the manifestation of the "concrete attribute" deduced by the subclass
 /// differs from the "default" behavior, which is a (set of) LLVM-IR
-/// attribute(s) for an argument, call site argument, function return value, or
+/// attribute(s) for an argument, call base argument, function return value, or
 /// function, the `AbstractAttribute::manifest` method should be overloaded.
 ///
 /// NOTE: If the state obtained via getState() is INVALID, thus if
 ///       AbstractAttribute::getState().isValidState() returns false, no
 ///       information provided by the methods of this class should be used.
 /// NOTE: The Attributor currently has certain limitations to what we can do.
 ///       As a general rule of thumb, "concrete" abstract attributes should *for
 ///       now* only perform "backward" information propagation. That means
 ///       optimistic information obtained through abstract attributes should
 ///       only be used at positions that precede the origin of the information
 ///       with regards to the program flow. More practically, information can
 ///       *now* be propagated from instructions to their enclosing function, but
-///       *not* from call sites to the called function. The mechanisms to allow
+///       *not* from call bases to the called function. The mechanisms to allow
 ///       both directions will be added in the future.
 /// NOTE: The mechanics of adding a new "concrete" abstract attribute are
 ///       described in the file comment.
 struct AbstractAttribute : public IRPosition {
   using StateType = AbstractState;
 
   AbstractAttribute(const IRPosition &IRP) : IRPosition(IRP) {}
 

llvm/lib/Transforms/IPO/Attributor.cpp

static cl::opt<unsigned>
     MaxFixpointIterations("attributor-max-iterations", cl::Hidden,
                           cl::desc("Maximal number of fixpoint iterations."),
                           cl::init(32));
 static cl::opt<bool> VerifyMaxFixpointIterations(
     "attributor-max-iterations-verify", cl::Hidden,
     cl::desc("Verify that max-iterations is a tight bound for a fixpoint"),
     cl::init(false));
 
-static cl::opt<bool> AnnotateDeclarationCallSites(
+static cl::opt<bool> AnnotateDeclarationCallBases(
     "attributor-annotate-decl-cs", cl::Hidden,
-    cl::desc("Annotate call sites of function declarations."), cl::init(false));
+    cl::desc("Annotate call bases of function declarations."), cl::init(false));
 
 static cl::opt<bool> EnableHeapToStack("enable-heap-to-stack-conversion",
                                        cl::init(true), cl::Hidden);
 
 static cl::opt<bool>
     AllowShallowWrappers("attributor-allow-shallow-wrappers", cl::Hidden,
                          cl::desc("Allow the Attributor to create shallow "
                                   "wrappers for non-exact definitions."),
static bool addIfNotExistent(LLVMContext &Ctx, const Attribute &Attr,
 
   llvm_unreachable("Expected enum or string attribute!");
 }
 
 Argument *IRPosition::getAssociatedArgument() const {
   if (getPositionKind() == IRP_ARGUMENT)
     return cast<Argument>(&getAnchorValue());
 
-  // Not an Argument and no argument number means this is not a call site
+  // Not an Argument and no argument number means this is not a call base
   // argument, thus we cannot find a callback argument to return.
   int ArgNo = getArgNo();
   if (ArgNo < 0)
     return nullptr;
 
-  // Use abstract call sites to make the connection between the call site
+  // Use abstract call bases to make the connection between the call base
   // 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
+  // of the underlying call base operand, we want the corresponding callback
   // callee argument and not the direct callee argument.
   Optional<Argument *> CBCandidateArg;
   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
+      // Test if the underlying call base operand is argument number u of the
       // callback callee.
       if (ACS.getCallArgOperandNo(u) != ArgNo)
         continue;
 
       assert(ACS.getCalledFunction()->arg_size() > u &&
              "ACS mapped into var-args arguments!");
       if (CBCandidateArg.hasValue()) {
         CBCandidateArg = nullptr;
         break;
       }
       CBCandidateArg = ACS.getCalledFunction()->getArg(u);
     }
   }
 
   // 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
+  // If no callbacks were found, or none used the underlying call base operand
   // exclusively, use the direct callee argument if available.
   const Function *Callee = CB.getCalledFunction();
   if (Callee && Callee->arg_size() > unsigned(ArgNo))
     return Callee->getArg(ArgNo);
 
   return nullptr;
 }
 
IRAttributeManifest::manifestAttrs(Attributor &A, const IRPosition &IRP,
   case IRPosition::IRP_INVALID:
   case IRPosition::IRP_FLOAT:
     return ChangeStatus::UNCHANGED;
   case IRPosition::IRP_ARGUMENT:
   case IRPosition::IRP_FUNCTION:
   case IRPosition::IRP_RETURNED:
     Attrs = ScopeFn->getAttributes();
     break;
-  case IRPosition::IRP_CALL_SITE:
-  case IRPosition::IRP_CALL_SITE_RETURNED:
-  case IRPosition::IRP_CALL_SITE_ARGUMENT:
+  case IRPosition::IRP_CALL_BASE:
+  case IRPosition::IRP_CALL_BASE_RETURNED:
+  case IRPosition::IRP_CALL_BASE_ARGUMENT:
     Attrs = cast<CallBase>(IRP.getAnchorValue()).getAttributes();
     break;
   }
 
   ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
   LLVMContext &Ctx = IRP.getAnchorValue().getContext();
   for (const Attribute &Attr : DeducedAttrs) {
     if (!addIfNotExistent(Ctx, Attr, Attrs, IRP.getAttrIdx()))
       continue;
 
     HasChanged = ChangeStatus::CHANGED;
   }
 
   if (HasChanged == ChangeStatus::UNCHANGED)
     return HasChanged;
 
   switch (PK) {
   case IRPosition::IRP_ARGUMENT:
   case IRPosition::IRP_FUNCTION:
   case IRPosition::IRP_RETURNED:
     ScopeFn->setAttributes(Attrs);
     break;
-  case IRPosition::IRP_CALL_SITE:
-  case IRPosition::IRP_CALL_SITE_RETURNED:
-  case IRPosition::IRP_CALL_SITE_ARGUMENT:
+  case IRPosition::IRP_CALL_BASE:
+  case IRPosition::IRP_CALL_BASE_RETURNED:
+  case IRPosition::IRP_CALL_BASE_ARGUMENT:
     cast<CallBase>(IRP.getAnchorValue()).setAttributes(Attrs);
     break;
   case IRPosition::IRP_INVALID:
   case IRPosition::IRP_FLOAT:
     break;
   }
 
   return HasChanged;
SubsumingPositionIterator::SubsumingPositionIterator(const IRPosition &IRP) {
   case IRPosition::IRP_INVALID:
   case IRPosition::IRP_FLOAT:
   case IRPosition::IRP_FUNCTION:
     return;
   case IRPosition::IRP_ARGUMENT:
   case IRPosition::IRP_RETURNED:
     IRPositions.emplace_back(IRPosition::function(*IRP.getAnchorScope()));
     return;
-  case IRPosition::IRP_CALL_SITE:
-    assert(CB && "Expected call site!");
+  case IRPosition::IRP_CALL_BASE:
+    assert(CB && "Expected call base!");
     // TODO: We need to look at the operand bundles similar to the redirection
     //       in CallBase.
     if (!CB->hasOperandBundles())
       if (const Function *Callee = CB->getCalledFunction())
         IRPositions.emplace_back(IRPosition::function(*Callee));
     return;
-  case IRPosition::IRP_CALL_SITE_RETURNED:
-    assert(CB && "Expected call site!");
+  case IRPosition::IRP_CALL_BASE_RETURNED:
+    assert(CB && "Expected call base!");
     // TODO: We need to look at the operand bundles similar to the redirection
     //       in CallBase.
     if (!CB->hasOperandBundles()) {
       if (const Function *Callee = CB->getCalledFunction()) {
         IRPositions.emplace_back(IRPosition::returned(*Callee));
         IRPositions.emplace_back(IRPosition::function(*Callee));
         for (const Argument &Arg : Callee->args())
           if (Arg.hasReturnedAttr()) {
             IRPositions.emplace_back(
-                IRPosition::callsite_argument(*CB, Arg.getArgNo()));
+                IRPosition::callbase_argument(*CB, Arg.getArgNo()));
             IRPositions.emplace_back(
                 IRPosition::value(*CB->getArgOperand(Arg.getArgNo())));
             IRPositions.emplace_back(IRPosition::argument(Arg));
           }
       }
     }
-    IRPositions.emplace_back(IRPosition::callsite_function(*CB));
+    IRPositions.emplace_back(IRPosition::callbase_function(*CB));
     return;
-  case IRPosition::IRP_CALL_SITE_ARGUMENT: {
+  case IRPosition::IRP_CALL_BASE_ARGUMENT: {
     int ArgNo = IRP.getArgNo();
-    assert(CB && ArgNo >= 0 && "Expected call site!");
+    assert(CB && ArgNo >= 0 && "Expected call base!");
     // TODO: We need to look at the operand bundles similar to the redirection
     //       in CallBase.
     if (!CB->hasOperandBundles()) {
       const Function *Callee = CB->getCalledFunction();
       if (Callee && Callee->arg_size() > unsigned(ArgNo))
         IRPositions.emplace_back(IRPosition::argument(*Callee->getArg(ArgNo)));
       if (Callee)
         IRPositions.emplace_back(IRPosition::function(*Callee));
assert((!isa<CallBase>(&getAssociatedValue()) &&
            "Expected specialized kind for call base and argument values!");
     return;
   case IRP_RETURNED:
     assert(isa<Function>(getAsValuePtr()) &&
            "Expected function for a 'returned' position!");
     assert(getAsValuePtr() == &getAssociatedValue() &&
            "Associated value mismatch!");
     return;
-  case IRP_CALL_SITE_RETURNED:
+  case IRP_CALL_BASE_RETURNED:
     assert((isa<CallBase>(getAsValuePtr())) &&
-           "Expected call base for 'call site returned' position!");
+           "Expected call base for 'call base returned' position!");
     assert(getAsValuePtr() == &getAssociatedValue() &&
            "Associated value mismatch!");
     return;
-  case IRP_CALL_SITE:
+  case IRP_CALL_BASE:
     assert((isa<CallBase>(getAsValuePtr())) &&
-           "Expected call base for 'call site function' position!");
+           "Expected call base for 'call base function' position!");
     assert(getAsValuePtr() == &getAssociatedValue() &&
            "Associated value mismatch!");
     return;
   case IRP_FUNCTION:
     assert(isa<Function>(getAsValuePtr()) &&
            "Expected function for a 'function' position!");
     assert(getAsValuePtr() == &getAssociatedValue() &&
            "Associated value mismatch!");
     return;
   case IRP_ARGUMENT:
     assert(isa<Argument>(getAsValuePtr()) &&
            "Expected argument for a 'argument' position!");
     assert(getAsValuePtr() == &getAssociatedValue() &&
            "Associated value mismatch!");
     return;
-  case IRP_CALL_SITE_ARGUMENT: {
+  case IRP_CALL_BASE_ARGUMENT: {
     Use *U = getAsUsePtr();
-    assert(U && "Expected use for a 'call site argument' position!");
+    assert(U && "Expected use for a 'call base argument' position!");
     assert(isa<CallBase>(U->getUser()) &&
-           "Expected call base user for a 'call site argument' position!");
+           "Expected call base user for a 'call base argument' position!");
     assert(cast<CallBase>(U->getUser())->isArgOperand(U) &&
-           "Expected call base argument operand for a 'call site argument' "
+           "Expected call base argument operand for a 'call base argument' "
            "position");
     assert(cast<CallBase>(U->getUser())->getArgOperandNo(U) ==
                unsigned(getArgNo()) &&
            "Argument number mismatch!");
     assert(U->get() == &getAssociatedValue() && "Associated value mismatch!");
     return;
   }
   }
bool Attributor::isAssumedDead(const Use &U,
                                const AAIsDead *FnLivenessAA,
                                bool CheckBBLivenessOnly, DepClassTy DepClass) {
   Instruction *UserI = dyn_cast<Instruction>(U.getUser());
   if (!UserI)
     return isAssumedDead(IRPosition::value(*U.get()), QueryingAA, FnLivenessAA,
                          CheckBBLivenessOnly, DepClass);
 
   if (auto *CB = dyn_cast<CallBase>(UserI)) {
-    // For call site argument uses we can check if the argument is
+    // For call base argument uses we can check if the argument is
     // unused/dead.
     if (CB->isArgOperand(&U)) {
       const IRPosition &CSArgPos =
-          IRPosition::callsite_argument(*CB, CB->getArgOperandNo(&U));
+          IRPosition::callbase_argument(*CB, CB->getArgOperandNo(&U));
       return isAssumedDead(CSArgPos, QueryingAA, FnLivenessAA,
                            CheckBBLivenessOnly, DepClass);
     }
   } else if (ReturnInst *RI = dyn_cast<ReturnInst>(UserI)) {
     const IRPosition &RetPos = IRPosition::returned(*RI->getFunction());
     return isAssumedDead(RetPos, QueryingAA, FnLivenessAA, CheckBBLivenessOnly,
                          DepClass);
   } else if (PHINode *PHI = dyn_cast<PHINode>(UserI)) {
if (CtxI &&
                     CheckBBLivenessOnly ? DepClass : DepClassTy::OPTIONAL))
     return true;
 
   if (CheckBBLivenessOnly)
     return false;
 
   // If we haven't succeeded we query the specific liveness info for the IRP.
   const AAIsDead *IsDeadAA;
-  if (IRP.getPositionKind() == IRPosition::IRP_CALL_SITE)
+  if (IRP.getPositionKind() == IRPosition::IRP_CALL_BASE)
     IsDeadAA = &getOrCreateAAFor<AAIsDead>(
-        IRPosition::callsite_returned(cast<CallBase>(IRP.getAssociatedValue())),
+        IRPosition::callbase_returned(cast<CallBase>(IRP.getAssociatedValue())),
         QueryingAA, /* TrackDependence */ false);
   else
     IsDeadAA = &getOrCreateAAFor<AAIsDead>(IRP, QueryingAA,
                                            /* TrackDependence */ false);
   // Don't check liveness for AAIsDead.
   if (QueryingAA == IsDeadAA)
     return false;
 
if (!Follow)
       continue;
     for (const Use &UU : U->getUser()->uses())
       Worklist.push_back(&UU);
   }
 
   return true;
 }
 
-bool Attributor::checkForAllCallSites(function_ref<bool(AbstractCallSite)> Pred,
+bool Attributor::checkForAllCallBases(function_ref<bool(AbstractCallSite)> Pred,
                                       const AbstractAttribute &QueryingAA,
-                                      bool RequireAllCallSites,
-                                      bool &AllCallSitesKnown) {
+                                      bool RequireAllCallBases,
+                                      bool &AllCallBasesKnown) {
   // We can try to determine information from
-  // the call sites. However, this is only possible all call sites are known,
+  // the call bases. However, this is only possible all call bases are known,
   // hence the function has internal linkage.
   const IRPosition &IRP = QueryingAA.getIRPosition();
   const Function *AssociatedFunction = IRP.getAssociatedFunction();
   if (!AssociatedFunction) {
     LLVM_DEBUG(dbgs() << "[Attributor] No function associated with " << IRP
                       << "\n");
-    AllCallSitesKnown = false;
+    AllCallBasesKnown = false;
     return false;
   }
 
-  return checkForAllCallSites(Pred, *AssociatedFunction, RequireAllCallSites,
-                              &QueryingAA, AllCallSitesKnown);
+  return checkForAllCallBases(Pred, *AssociatedFunction, RequireAllCallBases,
+                              &QueryingAA, AllCallBasesKnown);
 }
 
-bool Attributor::checkForAllCallSites(function_ref<bool(AbstractCallSite)> Pred,
+bool Attributor::checkForAllCallBases(function_ref<bool(AbstractCallSite)> Pred,
                                       const Function &Fn,
-                                      bool RequireAllCallSites,
+                                      bool RequireAllCallBases,
                                       const AbstractAttribute *QueryingAA,
-                                      bool &AllCallSitesKnown) {
-  if (RequireAllCallSites && !Fn.hasLocalLinkage()) {
+                                      bool &AllCallBasesKnown) {
+  if (RequireAllCallBases && !Fn.hasLocalLinkage()) {
     LLVM_DEBUG(
         dbgs()
         << "[Attributor] Function " << Fn.getName()
-        << " has no internal linkage, hence not all call sites are known\n");
-    AllCallSitesKnown = false;
+        << " has no internal linkage, hence not all call bases are known\n");
+    AllCallBasesKnown = false;
     return false;
   }
 
-  // If we do not require all call sites we might not see all.
-  AllCallSitesKnown = RequireAllCallSites;
+  // If we do not require all call bases we might not see all.
+  AllCallBasesKnown = RequireAllCallBases;
 
   SmallVector<const Use *, 8> Uses(make_pointer_range(Fn.uses()));
   for (unsigned u = 0; u < Uses.size(); ++u) {
     const Use &U = *Uses[u];
     LLVM_DEBUG(dbgs() << "[Attributor] Check use: " << *U << " in "
                       << *U.getUser() << "\n");
     if (isAssumedDead(U, QueryingAA, nullptr, /* CheckBBLivenessOnly */ true)) {
       LLVM_DEBUG(dbgs() << "[Attributor] Dead use, skip!\n");
       continue;
     }
     if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U.getUser())) {
       if (CE->isCast() && CE->getType()->isPointerTy() &&
           CE->getType()->getPointerElementType()->isFunctionTy()) {
         for (const Use &CEU : CE->uses())
           Uses.push_back(&CEU);
         continue;
       }
     }
 
     AbstractCallSite ACS(&U);
     if (!ACS) {
       LLVM_DEBUG(dbgs() << "[Attributor] Function " << Fn.getName()
-                        << " has non call site use " << *U.get() << " in "
+                        << " has non call base use " << *U.get() << " in "
                         << *U.getUser() << "\n");
       // BlockAddress users are allowed.
       if (isa<BlockAddress>(U.getUser()))
         continue;
       return false;
     }
 
     const Use *EffectiveUse =
         ACS.isCallbackCall() ? &ACS.getCalleeUseForCallback() : &U;
     if (!ACS.isCallee(EffectiveUse)) {
-      if (!RequireAllCallSites)
+      if (!RequireAllCallBases)
         continue;
       LLVM_DEBUG(dbgs() << "[Attributor] User " << EffectiveUse->getUser()
                         << " is an invalid use of " << Fn.getName() << "\n");
       return false;
     }
 
-    // Make sure the arguments that can be matched between the call site and the
+    // Make sure the arguments that can be matched between the call base and the
     // callee argee on their type. It is unlikely they do not and it doesn't
     // make sense for all attributes to know/care about this.
     assert(&Fn == ACS.getCalledFunction() && "Expected known callee");
     unsigned MinArgsParams =
         std::min(size_t(ACS.getNumArgOperands()), Fn.arg_size());
     for (unsigned u = 0; u < MinArgsParams; ++u) {
       Value *CSArgOp = ACS.getCallArgOperand(u);
       if (CSArgOp && Fn.getArg(u)->getType() != CSArgOp->getType()) {
         LLVM_DEBUG(
-            dbgs() << "[Attributor] Call site / callee argument type mismatch ["
+            dbgs() << "[Attributor] Call base / callee argument type mismatch ["
                    << u << "@" << Fn.getName() << ": "
                    << *Fn.getArg(u)->getType() << " vs. "
                    << *ACS.getCallArgOperand(u)->getType() << "\n");
         return false;
       }
     }
 
     if (Pred(ACS))
       continue;
 
-    LLVM_DEBUG(dbgs() << "[Attributor] Call site callback failed for "
+    LLVM_DEBUG(dbgs() << "[Attributor] Call base callback failed for "
                       << *ACS.getInstruction() << "\n");
     return false;
   }
 
   return true;
 }
 
 bool Attributor::checkForAllReturnedValuesAndReturnInsts(
     function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred,
     const AbstractAttribute &QueryingAA) {
 
   const IRPosition &IRP = QueryingAA.getIRPosition();
   // Since we need to provide return instructions we have to have an exact
   // definition.
   const Function *AssociatedFunction = IRP.getAssociatedFunction();
   if (!AssociatedFunction)
     return false;
 
-  // If this is a call site query we use the call site specific return values
+  // If this is a call base query we use the call base specific return values
   // and liveness information.
-  // TODO: use the function scope once we have call site AAReturnedValues.
+  // TODO: use the function scope once we have call base AAReturnedValues.
   const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
   const auto &AARetVal = getAAFor<AAReturnedValues>(QueryingAA, QueryIRP);
   if (!AARetVal.getState().isValidState())
     return false;
 
   return AARetVal.checkForAllReturnedValuesAndReturnInsts(Pred);
 }
 
 bool Attributor::checkForAllReturnedValues(
     function_ref<bool(Value &)> Pred, const AbstractAttribute &QueryingAA) {
 
   const IRPosition &IRP = QueryingAA.getIRPosition();
   const Function *AssociatedFunction = IRP.getAssociatedFunction();
   if (!AssociatedFunction)
     return false;
 
-  // TODO: use the function scope once we have call site AAReturnedValues.
+  // TODO: use the function scope once we have call base AAReturnedValues.
   const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
   const auto &AARetVal = getAAFor<AAReturnedValues>(QueryingAA, QueryIRP);
   if (!AARetVal.getState().isValidState())
     return false;
 
   return AARetVal.checkForAllReturnedValuesAndReturnInsts(
       [&](Value &RV, const SmallSetVector<ReturnInst *, 4> &) {
         return Pred(RV);
bool Attributor::checkForAllInstructions(function_ref<bool(Instruction &)> Pred,
                                          bool CheckBBLivenessOnly) {
 
   const IRPosition &IRP = QueryingAA.getIRPosition();
   // Since we need to provide instructions we have to have an exact definition.
   const Function *AssociatedFunction = IRP.getAssociatedFunction();
   if (!AssociatedFunction)
     return false;
 
-  // TODO: use the function scope once we have call site AAReturnedValues.
+  // TODO: use the function scope once we have call base AAReturnedValues.
   const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
   const auto &LivenessAA =
       getAAFor<AAIsDead>(QueryingAA, QueryIRP, /* TrackDependence */ false);
 
   auto &OpcodeInstMap =
       InfoCache.getOpcodeInstMapForFunction(*AssociatedFunction);
   if (!checkForAllInstructionsImpl(this, OpcodeInstMap, Pred, &QueryingAA,
                                    &LivenessAA, Opcodes, CheckBBLivenessOnly))
     return false;
 
   return true;
 }
 
 bool Attributor::checkForAllReadWriteInstructions(
     function_ref<bool(Instruction &)> Pred, AbstractAttribute &QueryingAA) {
 
   const Function *AssociatedFunction =
       QueryingAA.getIRPosition().getAssociatedFunction();
   if (!AssociatedFunction)
     return false;
 
-  // TODO: use the function scope once we have call site AAReturnedValues.
+  // TODO: use the function scope once we have call base AAReturnedValues.
   const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
   const auto &LivenessAA =
       getAAFor<AAIsDead>(QueryingAA, QueryIRP, /* TrackDependence */ false);
 
   for (Instruction *I :
        InfoCache.getReadOrWriteInstsForFunction(*AssociatedFunction)) {
     // Skip dead instructions.
     if (isAssumedDead(IRPosition::value(*I), &QueryingAA, &LivenessAA))
ChangeStatus Attributor::cleanupIR() {
   bool FoundDeadFn = true;
   while (FoundDeadFn) {
     FoundDeadFn = false;
     for (unsigned u = 0, e = InternalFns.size(); u < e; ++u) {
       Function *F = InternalFns[u];
       if (!F)
         continue;
 
-      bool AllCallSitesKnown;
-      if (!checkForAllCallSites(
+      bool AllCallBasesKnown;
+      if (!checkForAllCallBases(
               [this](AbstractCallSite ACS) {
                 return ToBeDeletedFunctions.count(
                     ACS.getInstruction()->getFunction());
               },
-              *F, true, nullptr, AllCallSitesKnown))
+              *F, true, nullptr, AllCallBasesKnown))
         continue;
 
       ToBeDeletedFunctions.insert(F);
       InternalFns[u] = nullptr;
       FoundDeadFn = true;
     }
   }
 
static void createShallowWrapper(Function &F) {
   ReturnInst::Create(Ctx, CI->getType()->isVoidTy() ? nullptr : CI, EntryBB);
 
   NumFnShallowWrapperCreated++;
 }
 
 bool Attributor::isValidFunctionSignatureRewrite(
     Argument &Arg, ArrayRef<Type *> ReplacementTypes) {
 
-  auto CallSiteCanBeChanged = [](AbstractCallSite ACS) {
-    // Forbid the call site to cast the function return type. If we need to
-    // rewrite these functions we need to re-create a cast for the new call site
+  auto CallBaseCanBeChanged = [](AbstractCallSite ACS) {
+    // Forbid the call base to cast the function return type. If we need to
+    // rewrite these functions we need to re-create a cast for the new call base
     // (if the old had uses).
     if (!ACS.getCalledFunction() ||
         ACS.getInstruction()->getType() !=
             ACS.getCalledFunction()->getReturnType())
       return false;
     // Forbid must-tail calls for now.
     return !ACS.isCallbackCall() && !ACS.getInstruction()->isMustTailCall();
   };
if (FnAttributeList.hasAttrSomewhere(Attribute::Nest) ||
       FnAttributeList.hasAttrSomewhere(Attribute::InAlloca) ||
       FnAttributeList.hasAttrSomewhere(Attribute::Preallocated)) {
     LLVM_DEBUG(
         dbgs() << "[Attributor] Cannot rewrite due to complex attribute\n");
     return false;
   }
 
   // Avoid callbacks for now.
-  bool AllCallSitesKnown;
-  if (!checkForAllCallSites(CallSiteCanBeChanged, *Fn, true, nullptr,
-                            AllCallSitesKnown)) {
-    LLVM_DEBUG(dbgs() << "[Attributor] Cannot rewrite all call sites\n");
+  bool AllCallBasesKnown;
+  if (!checkForAllCallBases(CallBaseCanBeChanged, *Fn, true, nullptr,
+                            AllCallBasesKnown)) {
+    LLVM_DEBUG(dbgs() << "[Attributor] Cannot rewrite all call bases\n");
     return false;
   }
 
   auto InstPred = [](Instruction &I) {
     if (auto *CI = dyn_cast<CallInst>(&I))
       return !CI->isMustTailCall();
     return true;
   };
for (auto &It : ArgumentReplacementMap) {
     for (User *U : OldFn->users())
       if (auto *BA = dyn_cast<BlockAddress>(U))
         BlockAddresses.push_back(BA);
     for (auto *BA : BlockAddresses)
       BA->replaceAllUsesWith(BlockAddress::get(NewFn, BA->getBasicBlock()));
 
     // Set of all "call-like" instructions that invoke the old function mapped
     // to their new replacements.
-    SmallVector<std::pair<CallBase *, CallBase *>, 8> CallSitePairs;
+    SmallVector<std::pair<CallBase *, CallBase *>, 8> CallBasePairs;
 
     // Callback to create a new "call-like" instruction for a given one.
-    auto CallSiteReplacementCreator = [&](AbstractCallSite ACS) {
+    auto CallBaseReplacementCreator = [&](AbstractCallSite ACS) {
       CallBase *OldCB = cast<CallBase>(ACS.getInstruction());
       const AttributeList &OldCallAttributeList = OldCB->getAttributes();
 
-      // Collect the new argument operands for the replacement call site.
+      // Collect the new argument operands for the replacement call base.
       SmallVector<Value *, 16> NewArgOperands;
       SmallVector<AttributeSet, 16> NewArgOperandAttributes;
       for (unsigned OldArgNum = 0; OldArgNum < ARIs.size(); ++OldArgNum) {
         unsigned NewFirstArgNum = NewArgOperands.size();
         (void)NewFirstArgNum; // only used inside assert.
         if (const std::unique_ptr<ArgumentReplacementInfo> &ARI =
                 ARIs[OldArgNum]) {
           if (ARI->ACSRepairCB)
auto CallBaseReplacementCreator = [&](AbstractCallSite ACS) {
       // Copy over various properties and the new attributes.
       NewCB->copyMetadata(*OldCB, {LLVMContext::MD_prof, LLVMContext::MD_dbg});
       NewCB->setCallingConv(OldCB->getCallingConv());
       NewCB->takeName(OldCB);
       NewCB->setAttributes(AttributeList::get(
           Ctx, OldCallAttributeList.getFnAttributes(),
           OldCallAttributeList.getRetAttributes(), NewArgOperandAttributes));
 
-      CallSitePairs.push_back({OldCB, NewCB});
+      CallBasePairs.push_back({OldCB, NewCB});
       return true;
     };
 
-    // Use the CallSiteReplacementCreator to create replacement call sites.
-    bool AllCallSitesKnown;
-    bool Success = checkForAllCallSites(CallSiteReplacementCreator, *OldFn,
-                                        true, nullptr, AllCallSitesKnown);
+    // Use the CallBaseReplacementCreator to create replacement call bases.
+    bool AllCallBasesKnown;
+    bool Success = checkForAllCallBases(CallBaseReplacementCreator, *OldFn,
+                                        true, nullptr, AllCallBasesKnown);
     (void)Success;
-    assert(Success && "Assumed call site replacement to succeed!");
+    assert(Success && "Assumed call base replacement to succeed!");
 
     // Rewire the arguments.
     auto OldFnArgIt = OldFn->arg_begin();
     auto NewFnArgIt = NewFn->arg_begin();
     for (unsigned OldArgNum = 0; OldArgNum < ARIs.size();
          ++OldArgNum, ++OldFnArgIt) {
       if (const std::unique_ptr<ArgumentReplacementInfo> &ARI =
               ARIs[OldArgNum]) {
         if (ARI->CalleeRepairCB)
           ARI->CalleeRepairCB(*ARI, *NewFn, NewFnArgIt);
         NewFnArgIt += ARI->ReplacementTypes.size();
       } else {
         NewFnArgIt->takeName(&*OldFnArgIt);
         OldFnArgIt->replaceAllUsesWith(&*NewFnArgIt);
         ++NewFnArgIt;
       }
     }
 
     // Eliminate the instructions *after* we visited all of them.
-    for (auto &CallSitePair : CallSitePairs) {
-      CallBase &OldCB = *CallSitePair.first;
-      CallBase &NewCB = *CallSitePair.second;
+    for (auto &CallBasePair : CallBasePairs) {
+      CallBase &OldCB = *CallBasePair.first;
+      CallBase &NewCB = *CallBasePair.second;
       assert(OldCB.getType() == NewCB.getType() &&
-             "Cannot handle call sites with different types!");
+             "Cannot handle call bases with different types!");
       ModifiedFns.insert(OldCB.getFunction());
       CGUpdater.replaceCallSite(OldCB, NewCB);
       OldCB.replaceAllUsesWith(&NewCB);
       OldCB.eraseFromParent();
     }
 
     // Replace the function in the call graph (if any).
     CGUpdater.replaceFunctionWith(*OldFn, *NewFn);

 }
 
 void Attributor::identifyDefaultAbstractAttributes(Function &F) {
   if (!VisitedFunctions.insert(&F).second)
     return;
   if (F.isDeclaration())
     return;
 
-  // In non-module runs we need to look at the call sites of a function to
+  // In non-module runs we need to look at the call bases of a function to
   // determine if it is part of a must-tail call edge. This will influence what
   // attributes we can derive.
   InformationCache::FunctionInfo &FI = InfoCache.getFunctionInfo(F);
   if (!isModulePass() && !FI.CalledViaMustTail) {
     for (const Use &U : F.uses())
       if (const auto *CB = dyn_cast<CallBase>(U.getUser()))
         if (CB->isCallee(&U) && CB->isMustTailCall())
           FI.CalledViaMustTail = true;
if (Arg.getType()->isPointerTy()) {
       // Every argument with pointer type might be marked nofree.
       getOrCreateAAFor<AANoFree>(ArgPos);
 
       // Every argument with pointer type might be privatizable (or promotable)
       getOrCreateAAFor<AAPrivatizablePtr>(ArgPos);
     }
   }
 
-  auto CallSitePred = [&](Instruction &I) -> bool {
+  auto CallBasePred = [&](Instruction &I) -> bool {
     auto &CB = cast<CallBase>(I);
-    IRPosition CBRetPos = IRPosition::callsite_returned(CB);
+    IRPosition CBRetPos = IRPosition::callbase_returned(CB);
 
-    // Call sites might be dead if they do not have side effects and no live
+    // Call bases might be dead if they do not have side effects and no live
     // users. The return value might be dead if there are no live users.
     getOrCreateAAFor<AAIsDead>(CBRetPos);
 
     Function *Callee = CB.getCalledFunction();
     // TODO: Even if the callee is not known now we might be able to simplify
     //       the call/callee.
     if (!Callee)
       return true;
 
-    // Skip declarations except if annotations on their call sites were
+    // Skip declarations except if annotations on their call bases were
     // explicitly requested.
-    if (!AnnotateDeclarationCallSites && Callee->isDeclaration() &&
+    if (!AnnotateDeclarationCallBases && Callee->isDeclaration() &&
         !Callee->hasMetadata(LLVMContext::MD_callback))
       return true;
 
     if (!Callee->getReturnType()->isVoidTy() && !CB.use_empty()) {
 
-      IRPosition CBRetPos = IRPosition::callsite_returned(CB);
+      IRPosition CBRetPos = IRPosition::callbase_returned(CB);
 
-      // Call site return integer values might be limited by a constant range.
+      // Call base return integer values might be limited by a constant range.
       if (Callee->getReturnType()->isIntegerTy())
         getOrCreateAAFor<AAValueConstantRange>(CBRetPos);
     }
 
     for (int I = 0, E = CB.getNumArgOperands(); I < E; ++I) {
 
-      IRPosition CBArgPos = IRPosition::callsite_argument(CB, I);
+      IRPosition CBArgPos = IRPosition::callbase_argument(CB, I);
 
-      // Every call site argument might be dead.
+      // Every call base argument might be dead.
       getOrCreateAAFor<AAIsDead>(CBArgPos);
 
-      // Call site argument might be simplified.
+      // Call base argument might be simplified.
       getOrCreateAAFor<AAValueSimplify>(CBArgPos);
 
       if (!CB.getArgOperand(I)->getType()->isPointerTy())
         continue;
 
-      // Call site argument attribute "non-null".
+      // Call base argument attribute "non-null".
       getOrCreateAAFor<AANonNull>(CBArgPos);
 
-      // Call site argument attribute "nocapture".
+      // Call base argument attribute "nocapture".
       getOrCreateAAFor<AANoCapture>(CBArgPos);
 
-      // Call site argument attribute "no-alias".
+      // Call base argument attribute "no-alias".
       getOrCreateAAFor<AANoAlias>(CBArgPos);
 
-      // Call site argument attribute "dereferenceable".
+      // Call base argument attribute "dereferenceable".
       getOrCreateAAFor<AADereferenceable>(CBArgPos);
 
-      // Call site argument attribute "align".
+      // Call base argument attribute "align".
       getOrCreateAAFor<AAAlign>(CBArgPos);
 
-      // Call site argument attribute
+      // Call base argument attribute
       // "readnone/readonly/writeonly/..."
       getOrCreateAAFor<AAMemoryBehavior>(CBArgPos);
 
-      // Call site argument attribute "nofree".
+      // Call base argument attribute "nofree".
       getOrCreateAAFor<AANoFree>(CBArgPos);
     }
     return true;
   };
 
   auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
   bool Success;
   Success = checkForAllInstructionsImpl(
-      nullptr, OpcodeInstMap, CallSitePred, nullptr, nullptr,
+      nullptr, OpcodeInstMap, CallBasePred, nullptr, nullptr,
       {(unsigned)Instruction::Invoke, (unsigned)Instruction::CallBr,
        (unsigned)Instruction::Call});
   (void)Success;
   assert(Success && "Expected the check call to be successful!");
 
   auto LoadStorePred = [&](Instruction &I) -> bool {
     if (isa<LoadInst>(I))
       getOrCreateAAFor<AAAlign>(

 raw_ostream &llvm::operator<<(raw_ostream &OS, IRPosition::Kind AP) {
   switch (AP) {
   case IRPosition::IRP_INVALID:
     return OS << "inv";
   case IRPosition::IRP_FLOAT:
     return OS << "flt";
   case IRPosition::IRP_RETURNED:
     return OS << "fn_ret";
-  case IRPosition::IRP_CALL_SITE_RETURNED:
+  case IRPosition::IRP_CALL_BASE_RETURNED:
     return OS << "cs_ret";
   case IRPosition::IRP_FUNCTION:
     return OS << "fn";
-  case IRPosition::IRP_CALL_SITE:
+  case IRPosition::IRP_CALL_BASE:
     return OS << "cs";
   case IRPosition::IRP_ARGUMENT:
     return OS << "arg";
-  case IRPosition::IRP_CALL_SITE_ARGUMENT:
+  case IRPosition::IRP_CALL_BASE_ARGUMENT:
     return OS << "cs_arg";
   }
   llvm_unreachable("Unknown attribute position!");
 }
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const IRPosition &Pos) {
   const Value &AV = Pos.getAssociatedValue();
   return OS << "{" << Pos.getPositionKind() << ":" << AV.getName() << " ["

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

#define STATS_DECLTRACK(NAME, TYPE, MSG)                                       \
   {                                                                            \
     STATS_DECL(NAME, TYPE, MSG)                                                \
     STATS_TRACK(NAME, TYPE)                                                    \
   }
 #define STATS_DECLTRACK_ARG_ATTR(NAME)                                         \
   STATS_DECLTRACK(NAME, Arguments, BUILD_STAT_MSG_IR_ATTR(arguments, NAME))
 #define STATS_DECLTRACK_CSARG_ATTR(NAME)                                       \
   STATS_DECLTRACK(NAME, CSArguments,                                           \
-                  BUILD_STAT_MSG_IR_ATTR(call site arguments, NAME))
+                  BUILD_STAT_MSG_IR_ATTR(call base arguments, NAME))
 #define STATS_DECLTRACK_FN_ATTR(NAME)                                          \
   STATS_DECLTRACK(NAME, Function, BUILD_STAT_MSG_IR_ATTR(functions, NAME))
 #define STATS_DECLTRACK_CS_ATTR(NAME)                                          \
-  STATS_DECLTRACK(NAME, CS, BUILD_STAT_MSG_IR_ATTR(call site, NAME))
+  STATS_DECLTRACK(NAME, CS, BUILD_STAT_MSG_IR_ATTR(call base, NAME))
 #define STATS_DECLTRACK_FNRET_ATTR(NAME)                                       \
   STATS_DECLTRACK(NAME, FunctionReturn,                                        \
                   BUILD_STAT_MSG_IR_ATTR(function returns, NAME))
 #define STATS_DECLTRACK_CSRET_ATTR(NAME)                                       \
   STATS_DECLTRACK(NAME, CSReturn,                                              \
-                  BUILD_STAT_MSG_IR_ATTR(call site returns, NAME))
+                  BUILD_STAT_MSG_IR_ATTR(call base returns, NAME))
 #define STATS_DECLTRACK_FLOATING_ATTR(NAME)                                    \
   STATS_DECLTRACK(NAME, Floating,                                              \
                   ("Number of floating values known to be '" #NAME "'"))
 
 // Specialization of the operator<< for abstract attributes subclasses. This
 // disambiguates situations where multiple operators are applicable.
 namespace llvm {
 #define PIPE_OPERATOR(CLASS)                                                   \

 static void clampReturnedValueStates(Attributor &A, const AAType &QueryingAA,
                                      StateType &S) {
   LLVM_DEBUG(dbgs() << "[Attributor] Clamp return value states for "
                     << QueryingAA << " into " << S << "\n");
 
   assert((QueryingAA.getIRPosition().getPositionKind() ==
               IRPosition::IRP_RETURNED ||
           QueryingAA.getIRPosition().getPositionKind() ==
-              IRPosition::IRP_CALL_SITE_RETURNED) &&
+              IRPosition::IRP_CALL_BASE_RETURNED) &&
          "Can only clamp returned value states for a function returned or call "
          "site returned position!");
 
   // Use an optional state as there might not be any return values and we want
   // to join (IntegerState::operator&) the state of all there are.
   Optional<StateType> T;
 
   // Callback for each possibly returned value.
ChangeStatus updateImpl(Attributor &A) override {
     StateType S(StateType::getBestState(this->getState()));
     clampReturnedValueStates<AAType, StateType>(A, *this, S);
     // TODO: If we know we visited all returned values, thus no are assumed
     // dead, we can take the known information from the state T.
     return clampStateAndIndicateChange<StateType>(this->getState(), S);
   }
 };
 
-/// Clamp the information known at all call sites for a given argument
+/// Clamp the information known at all call bases for a given argument
 /// (identified by \p QueryingAA) into \p S.
 template <typename AAType, typename StateType = typename AAType::StateType>
-static void clampCallSiteArgumentStates(Attributor &A, const AAType &QueryingAA,
+static void clampCallBaseArgumentStates(Attributor &A, const AAType &QueryingAA,
                                         StateType &S) {
-  LLVM_DEBUG(dbgs() << "[Attributor] Clamp call site argument states for "
+  LLVM_DEBUG(dbgs() << "[Attributor] Clamp call base argument states for "
                     << QueryingAA << " into " << S << "\n");
 
   assert(QueryingAA.getIRPosition().getPositionKind() ==
              IRPosition::IRP_ARGUMENT &&
-         "Can only clamp call site argument states for an argument position!");
+         "Can only clamp call base argument states for an argument position!");
 
   // Use an optional state as there might not be any return values and we want
   // to join (IntegerState::operator&) the state of all there are.
   Optional<StateType> T;
 
-  // The argument number which is also the call site argument number.
+  // The argument number which is also the call base argument number.
   unsigned ArgNo = QueryingAA.getIRPosition().getArgNo();
 
-  auto CallSiteCheck = [&](AbstractCallSite ACS) {
-    const IRPosition &ACSArgPos = IRPosition::callsite_argument(ACS, ArgNo);
+  auto CallBaseCheck = [&](AbstractCallSite ACS) {
+    const IRPosition &ACSArgPos = IRPosition::callbase_argument(ACS, ArgNo);
     // Check if a coresponding argument was found or if it is on not associated
     // (which can happen for callback calls).
     if (ACSArgPos.getPositionKind() == IRPosition::IRP_INVALID)
       return false;
 
     const AAType &AA = A.getAAFor<AAType>(QueryingAA, ACSArgPos);
     LLVM_DEBUG(dbgs() << "[Attributor] ACS: " << *ACS.getInstruction()
                       << " AA: " << AA.getAsStr() << " @" << ACSArgPos << "\n");
     const StateType &AAS = static_cast<const StateType &>(AA.getState());
     if (T.hasValue())
       *T &= AAS;
     else
       T = AAS;
     LLVM_DEBUG(dbgs() << "[Attributor] AA State: " << AAS << " CSA State: " << T
                       << "\n");
     return T->isValidState();
   };
 
-  bool AllCallSitesKnown;
-  if (!A.checkForAllCallSites(CallSiteCheck, QueryingAA, true,
-                              AllCallSitesKnown))
+  bool AllCallBasesKnown;
+  if (!A.checkForAllCallBases(CallBaseCheck, QueryingAA, true,
+                              AllCallBasesKnown))
     S.indicatePessimisticFixpoint();
   else if (T.hasValue())
     S ^= *T;
 }
 
-/// Helper class for generic deduction: call site argument -> argument position.
+/// Helper class for generic deduction: call base argument -> argument position.
 template <typename AAType, typename BaseType,
           typename StateType = typename AAType::StateType>
-struct AAArgumentFromCallSiteArguments : public BaseType {
-  AAArgumentFromCallSiteArguments(const IRPosition &IRP, Attributor &A)
+struct AAArgumentFromCallBaseArguments : public BaseType {
+  AAArgumentFromCallBaseArguments(const IRPosition &IRP, Attributor &A)
       : BaseType(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     StateType S(StateType::getBestState(this->getState()));
-    clampCallSiteArgumentStates<AAType, StateType>(A, *this, S);
+    clampCallBaseArgumentStates<AAType, StateType>(A, *this, S);
     // TODO: If we know we visited all incoming values, thus no are assumed
     // dead, we can take the known information from the state T.
     return clampStateAndIndicateChange<StateType>(this->getState(), S);
   }
 };
 
 /// Helper class for generic replication: function returned -> cs returned.
 template <typename AAType, typename BaseType,
           typename StateType = typename BaseType::StateType>
-struct AACallSiteReturnedFromReturned : public BaseType {
-  AACallSiteReturnedFromReturned(const IRPosition &IRP, Attributor &A)
+struct AACallBaseReturnedFromReturned : public BaseType {
+  AACallBaseReturnedFromReturned(const IRPosition &IRP, Attributor &A)
       : BaseType(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     assert(this->getIRPosition().getPositionKind() ==
-               IRPosition::IRP_CALL_SITE_RETURNED &&
-           "Can only wrap function returned positions for call site returned "
+               IRPosition::IRP_CALL_BASE_RETURNED &&
+           "Can only wrap function returned positions for call base returned "
            "positions!");
     auto &S = this->getState();
 
     const Function *AssociatedFunction =
         this->getIRPosition().getAssociatedFunction();
     if (!AssociatedFunction)
       return S.indicatePessimisticFixpoint();
 
auto Opcodes = {
         (unsigned)Instruction::CatchSwitch, (unsigned)Instruction::Resume};
 
     auto CheckForNoUnwind = [&](Instruction &I) {
       if (!I.mayThrow())
         return true;
 
       if (const auto *CB = dyn_cast<CallBase>(&I)) {
         const auto &NoUnwindAA =
-            A.getAAFor<AANoUnwind>(*this, IRPosition::callsite_function(*CB));
+            A.getAAFor<AANoUnwind>(*this, IRPosition::callbase_function(*CB));
         return NoUnwindAA.isAssumedNoUnwind();
       }
       return false;
     };
 
     if (!A.checkForAllInstructions(CheckForNoUnwind, *this, Opcodes))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 };
 
 struct AANoUnwindFunction final : public AANoUnwindImpl {
   AANoUnwindFunction(const IRPosition &IRP, Attributor &A)
       : AANoUnwindImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nounwind) }
 };
 
-/// NoUnwind attribute deduction for a call sites.
-struct AANoUnwindCallSite final : AANoUnwindImpl {
-  AANoUnwindCallSite(const IRPosition &IRP, Attributor &A)
+/// NoUnwind attribute deduction for a call bases.
+struct AANoUnwindCallBase final : AANoUnwindImpl {
+  AANoUnwindCallBase(const IRPosition &IRP, Attributor &A)
       : AANoUnwindImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AANoUnwindImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F)
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::function(*F);
     auto &FnAA = A.getAAFor<AANoUnwind>(*this, FnPos);
     return clampStateAndIndicateChange(
         getState(),
         static_cast<const AANoUnwind::StateType &>(FnAA.getState()));
   }

 /// If there is a unique returned value R, the manifest method will:
 ///   - mark R with the "returned" attribute, if R is an argument.
 class AAReturnedValuesImpl : public AAReturnedValues, public AbstractState {
 
   /// Mapping of values potentially returned by the associated function to the
   /// return instructions that might return them.
   MapVector<Value *, SmallSetVector<ReturnInst *, 4>> ReturnedValues;
 
-  /// Mapping to remember the number of returned values for a call site such
+  /// Mapping to remember the number of returned values for a call base such
   /// that we can avoid updates if nothing changed.
   DenseMap<const CallBase *, unsigned> NumReturnedValuesPerKnownAA;
 
   /// Set of unresolved calls returned by the associated function.
   SmallSetVector<CallBase *, 4> UnresolvedCalls;
 
   /// State flags
   ///
ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) {
   if (!UniqueRV.hasValue() || !UniqueRV.getValue())
     return Changed;
 
   // Bookkeeping.
   STATS_DECLTRACK(UniqueReturnValue, FunctionReturn,
                   "Number of function with unique return");
 
   // Callback to replace the uses of CB with the constant C.
-  auto ReplaceCallSiteUsersWith = [&A](CallBase &CB, Constant &C) {
+  auto ReplaceCallBaseUsersWith = [&A](CallBase &CB, Constant &C) {
     if (CB.use_empty())
       return ChangeStatus::UNCHANGED;
     if (A.changeValueAfterManifest(CB, C))
       return ChangeStatus::CHANGED;
     return ChangeStatus::UNCHANGED;
   };
 
   // If the assumed unique return value is an argument, annotate it.
if (auto *UniqueRVArg = dyn_cast<Argument>(UniqueRV.getValue())) {
     if (Function *F = dyn_cast<Function>(&AnchorValue)) {
       for (const Use &U : F->uses())
         if (CallBase *CB = dyn_cast<CallBase>(U.getUser()))
           if (CB->isCallee(&U)) {
             Constant *RVCCast =
                 CB->getType() == RVC->getType()
                     ? RVC
                     : ConstantExpr::getTruncOrBitCast(RVC, CB->getType());
-            Changed = ReplaceCallSiteUsersWith(*CB, *RVCCast) | Changed;
+            Changed = ReplaceCallBaseUsersWith(*CB, *RVCCast) | Changed;
           }
     } else {
       assert(isa<CallBase>(AnchorValue) &&
              "Expcected a function or call base anchor!");
       Constant *RVCCast =
           AnchorValue.getType() == RVC->getType()
               ? RVC
               : ConstantExpr::getTruncOrBitCast(RVC, AnchorValue.getType());
-      Changed = ReplaceCallSiteUsersWith(cast<CallBase>(AnchorValue), *RVCCast);
+      Changed = ReplaceCallBaseUsersWith(cast<CallBase>(AnchorValue), *RVCCast);
     }
     if (Changed == ChangeStatus::CHANGED)
       STATS_DECLTRACK(UniqueConstantReturnValue, FunctionReturn,
                       "Number of function returns replaced by constant return");
   }
 
   return Changed;
 }

 }
 
 bool AAReturnedValuesImpl::checkForAllReturnedValuesAndReturnInsts(
     function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred)
     const {
   if (!isValidState())
     return false;
 
-  // Check all returned values but ignore call sites as long as we have not
+  // Check all returned values but ignore call bases as long as we have not
   // encountered an overdefined one during an update.
   for (auto &It : ReturnedValues) {
     Value *RV = It.first;
 
     CallBase *CB = dyn_cast<CallBase>(RV);
     if (CB && !UnresolvedCalls.count(CB))
       continue;
 
auto HandleReturnValue = [&](Value *RV, SmallSetVector<ReturnInst *, 4> &RIs) {
 
     if (!CB->getCalledFunction()) {
       LLVM_DEBUG(dbgs() << "[AAReturnedValues] Unresolved call: " << *CB
                         << "\n");
       UnresolvedCalls.insert(CB);
       return;
     }
 
-    // TODO: use the function scope once we have call site AAReturnedValues.
+    // TODO: use the function scope once we have call base AAReturnedValues.
     const auto &RetValAA = A.getAAFor<AAReturnedValues>(
         *this, IRPosition::function(*CB->getCalledFunction()));
     LLVM_DEBUG(dbgs() << "[AAReturnedValues] Found another AAReturnedValues: "
                       << RetValAA << "\n");
 
     // Skip dead ends, thus if we do not know anything about the returned
     // call we mark it as unresolved and it will stay that way.
     if (!RetValAA.getState().isValidState()) {
if (NumRetAA == RetValAA.getNumReturnValues()) {
                            "changed since it was seen last\n");
       return;
     }
     NumRetAA = RetValAA.getNumReturnValues();
 
     for (auto &RetValAAIt : RetValAA.returned_values()) {
       Value *RetVal = RetValAAIt.first;
       if (Argument *Arg = dyn_cast<Argument>(RetVal)) {
-        // Arguments are mapped to call site operands and we begin the traversal
+        // Arguments are mapped to call base operands and we begin the traversal
         // again.
         bool Unused = false;
         RVState RVS({NewRVsMap, Unused, RetValAAIt.second});
         VisitReturnedValue(*CB->getArgOperand(Arg->getArgNo()), RVS, CB);
         continue;
       } else if (isa<CallBase>(RetVal)) {
-        // Call sites are resolved by the callee attribute over time, no need to
+        // Call bases are resolved by the callee attribute over time, no need to
         // do anything for us.
         continue;
       } else if (isa<Constant>(RetVal)) {
         // Constants are valid everywhere, we can simply take them.
         NewRVsMap[RetVal].insert(RIs.begin(), RIs.end());
         continue;
       }
     }

 struct AAReturnedValuesFunction final : public AAReturnedValuesImpl {
   AAReturnedValuesFunction(const IRPosition &IRP, Attributor &A)
       : AAReturnedValuesImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(returned) }
 };
 
-/// Returned values information for a call sites.
-struct AAReturnedValuesCallSite final : AAReturnedValuesImpl {
-  AAReturnedValuesCallSite(const IRPosition &IRP, Attributor &A)
+/// Returned values information for a call bases.
+struct AAReturnedValuesCallBase final : AAReturnedValuesImpl {
+  AAReturnedValuesCallBase(const IRPosition &IRP, Attributor &A)
       : AAReturnedValuesImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases instead of
     //       redirecting requests to the callee.
     llvm_unreachable("Abstract attributes for returned values are not "
-                     "supported for call sites yet!");
+                     "supported for call bases yet!");
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     return indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::trackStatistics()
auto CheckRWInstForNoSync = [&](Instruction &I) {
     if (isa<IntrinsicInst>(&I) && isNoSyncIntrinsic(&I))
       return true;
 
     if (const auto *CB = dyn_cast<CallBase>(&I)) {
       if (CB->hasFnAttr(Attribute::NoSync))
         return true;
 
       const auto &NoSyncAA =
-          A.getAAFor<AANoSync>(*this, IRPosition::callsite_function(*CB));
+          A.getAAFor<AANoSync>(*this, IRPosition::callbase_function(*CB));
       if (NoSyncAA.isAssumedNoSync())
         return true;
       return false;
     }
 
     if (!isVolatile(&I) && !isNonRelaxedAtomic(&I))
       return true;
 

 struct AANoSyncFunction final : public AANoSyncImpl {
   AANoSyncFunction(const IRPosition &IRP, Attributor &A)
       : AANoSyncImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nosync) }
 };
 
-/// NoSync attribute deduction for a call sites.
-struct AANoSyncCallSite final : AANoSyncImpl {
-  AANoSyncCallSite(const IRPosition &IRP, Attributor &A)
+/// NoSync attribute deduction for a call bases.
+struct AANoSyncCallBase final : AANoSyncImpl {
+  AANoSyncCallBase(const IRPosition &IRP, Attributor &A)
       : AANoSyncImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AANoSyncImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F)
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::function(*F);
     auto &FnAA = A.getAAFor<AANoSync>(*this, FnPos);
     return clampStateAndIndicateChange(
         getState(), static_cast<const AANoSync::StateType &>(FnAA.getState()));
   }
 
struct AANoFreeImpl : public AANoFree {
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     auto CheckForNoFree = [&](Instruction &I) {
       const auto &CB = cast<CallBase>(I);
       if (CB.hasFnAttr(Attribute::NoFree))
         return true;
 
       const auto &NoFreeAA =
-          A.getAAFor<AANoFree>(*this, IRPosition::callsite_function(CB));
+          A.getAAFor<AANoFree>(*this, IRPosition::callbase_function(CB));
       return NoFreeAA.isAssumedNoFree();
     };
 
     if (!A.checkForAllCallLikeInstructions(CheckForNoFree, *this))
       return indicatePessimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractAttribute::getAsStr().
   const std::string getAsStr() const override {
     return getAssumed() ? "nofree" : "may-free";
   }
 };
 
 struct AANoFreeFunction final : public AANoFreeImpl {
   AANoFreeFunction(const IRPosition &IRP, Attributor &A)
       : AANoFreeImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nofree) }
 };
 
-/// NoFree attribute deduction for a call sites.
-struct AANoFreeCallSite final : AANoFreeImpl {
-  AANoFreeCallSite(const IRPosition &IRP, Attributor &A)
+/// NoFree attribute deduction for a call bases.
+struct AANoFreeCallBase final : AANoFreeImpl {
+  AANoFreeCallBase(const IRPosition &IRP, Attributor &A)
       : AANoFreeImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AANoFreeImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F)
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::function(*F);
     auto &FnAA = A.getAAFor<AANoFree>(*this, FnPos);
     return clampStateAndIndicateChange(
         getState(), static_cast<const AANoFree::StateType &>(FnAA.getState()));
   }
 
auto Pred = [&](const Use &U, bool &Follow) -> bool {
       if (auto *CB = dyn_cast<CallBase>(UserI)) {
         if (CB->isBundleOperand(&U))
           return false;
         if (!CB->isArgOperand(&U))
           return true;
         unsigned ArgNo = CB->getArgOperandNo(&U);
 
         const auto &NoFreeArg = A.getAAFor<AANoFree>(
-            *this, IRPosition::callsite_argument(*CB, ArgNo));
+            *this, IRPosition::callbase_argument(*CB, ArgNo));
         return NoFreeArg.isAssumedNoFree();
       }
 
       if (isa<GetElementPtrInst>(UserI) || isa<BitCastInst>(UserI) ||
           isa<PHINode>(UserI) || isa<SelectInst>(UserI)) {
         Follow = true;
         return true;
       }
       if (isa<ReturnInst>(UserI))
         return true;
 
       // Unknown user.
       return false;
     };
     if (!A.checkForAllUses(Pred, *this, AssociatedValue))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 };
 
-/// NoFree attribute for a call site argument.
+/// NoFree attribute for a call base argument.
 struct AANoFreeArgument final : AANoFreeFloating {
   AANoFreeArgument(const IRPosition &IRP, Attributor &A)
       : AANoFreeFloating(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nofree) }
 };
 
-/// NoFree attribute for call site arguments.
-struct AANoFreeCallSiteArgument final : AANoFreeFloating {
-  AANoFreeCallSiteArgument(const IRPosition &IRP, Attributor &A)
+/// NoFree attribute for call base arguments.
+struct AANoFreeCallBaseArgument final : AANoFreeFloating {
+  AANoFreeCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AANoFreeFloating(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Argument *Arg = getAssociatedArgument();
     if (!Arg)
       return indicatePessimisticFixpoint();
     const IRPosition &ArgPos = IRPosition::argument(*Arg);
     auto &ArgAA = A.getAAFor<AANoFree>(*this, ArgPos);
     return clampStateAndIndicateChange(
         getState(), static_cast<const AANoFree::StateType &>(ArgAA.getState()));
struct AANoFreeReturned final : AANoFreeFloating {
   ChangeStatus updateImpl(Attributor &A) override {
     llvm_unreachable("NoFree is not applicable to function returns!");
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {}
 };
 
-/// NoFree attribute deduction for a call site return value.
-struct AANoFreeCallSiteReturned final : AANoFreeFloating {
-  AANoFreeCallSiteReturned(const IRPosition &IRP, Attributor &A)
+/// NoFree attribute deduction for a call base return value.
+struct AANoFreeCallBaseReturned final : AANoFreeFloating {
+  AANoFreeCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : AANoFreeFloating(IRP, A) {}
 
   ChangeStatus manifest(Attributor &A) override {
     return ChangeStatus::UNCHANGED;
   }
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nofree) }
 };
if (const auto *CB = dyn_cast<CallBase>(I)) {
     }
 
     if (CB->isCallee(U)) {
       IsNonNull |= !NullPointerIsDefined;
       return 0;
     }
 
     unsigned ArgNo = CB->getArgOperandNo(U);
-    IRPosition IRP = IRPosition::callsite_argument(*CB, ArgNo);
+    IRPosition IRP = IRPosition::callbase_argument(*CB, ArgNo);
     // As long as we only use known information there is no need to track
     // dependences here.
     auto &DerefAA = A.getAAFor<AADereferenceable>(QueryingAA, IRP,
                                                   /* TrackDependence */ false);
     IsNonNull |= DerefAA.isKnownNonNull();
     return DerefAA.getKnownDereferenceableBytes();
   }
 
AANonNullReturned(const IRPosition &IRP, Attributor &A)
       : AAReturnedFromReturnedValues<AANonNull, AANonNullImpl>(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(nonnull) }
 };
 
 /// NonNull attribute for function argument.
 struct AANonNullArgument final
-    : AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl> {
+    : AAArgumentFromCallBaseArguments<AANonNull, AANonNullImpl> {
   AANonNullArgument(const IRPosition &IRP, Attributor &A)
-      : AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl>(IRP, A) {}
+      : AAArgumentFromCallBaseArguments<AANonNull, AANonNullImpl>(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nonnull) }
 };
 
-struct AANonNullCallSiteArgument final : AANonNullFloating {
-  AANonNullCallSiteArgument(const IRPosition &IRP, Attributor &A)
+struct AANonNullCallBaseArgument final : AANonNullFloating {
+  AANonNullCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AANonNullFloating(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(nonnull) }
 };
 
-/// NonNull attribute for a call site return position.
-struct AANonNullCallSiteReturned final
-    : AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl> {
-  AANonNullCallSiteReturned(const IRPosition &IRP, Attributor &A)
-      : AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl>(IRP, A) {}
+/// NonNull attribute for a call base return position.
+struct AANonNullCallBaseReturned final
+    : AACallBaseReturnedFromReturned<AANonNull, AANonNullImpl> {
+  AANonNullCallBaseReturned(const IRPosition &IRP, Attributor &A)
+      : AACallBaseReturnedFromReturned<AANonNull, AANonNullImpl>(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nonnull) }
 };
 
 /// ------------------------ No-Recurse Attributes ----------------------------
 
 struct AANoRecurseImpl : public AANoRecurse {
void initialize(Attributor &A) override {
     if (const Function *F = getAnchorScope())
       if (A.getInfoCache().getSccSize(*F) != 1)
         indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
 
-    // If all live call sites are known to be no-recurse, we are as well.
-    auto CallSitePred = [&](AbstractCallSite ACS) {
+    // If all live call bases are known to be no-recurse, we are as well.
+    auto CallBasePred = [&](AbstractCallSite ACS) {
       const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(
           *this, IRPosition::function(*ACS.getInstruction()->getFunction()),
           /* TrackDependence */ false, DepClassTy::OPTIONAL);
       return NoRecurseAA.isKnownNoRecurse();
     };
-    bool AllCallSitesKnown;
-    if (A.checkForAllCallSites(CallSitePred, *this, true, AllCallSitesKnown)) {
-      // If we know all call sites and all are known no-recurse, we are done.
-      // If all known call sites, which might not be all that exist, are known
+    bool AllCallBasesKnown;
+    if (A.checkForAllCallBases(CallBasePred, *this, true, AllCallBasesKnown)) {
+      // If we know all call bases and all are known no-recurse, we are done.
+      // If all known call bases, which might not be all that exist, are known
       // to be no-recurse, we are not done but we can continue to assume
-      // no-recurse. If one of the call sites we have not visited will become
+      // no-recurse. If one of the call bases we have not visited will become
       // live, another update is triggered.
-      if (AllCallSitesKnown)
+      if (AllCallBasesKnown)
         indicateOptimisticFixpoint();
       return ChangeStatus::UNCHANGED;
     }
 
     // If the above check does not hold anymore we look at the calls.
     auto CheckForNoRecurse = [&](Instruction &I) {
       const auto &CB = cast<CallBase>(I);
       if (CB.hasFnAttr(Attribute::NoRecurse))
         return true;
 
       const auto &NoRecurseAA =
-          A.getAAFor<AANoRecurse>(*this, IRPosition::callsite_function(CB));
+          A.getAAFor<AANoRecurse>(*this, IRPosition::callbase_function(CB));
       if (!NoRecurseAA.isAssumedNoRecurse())
         return false;
 
       // Recursion to the same function
       if (CB.getCalledFunction() == getAnchorScope())
         return false;
 
       return true;
     };
 
     if (!A.checkForAllCallLikeInstructions(CheckForNoRecurse, *this))
       return indicatePessimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(norecurse) }
 };
 
-/// NoRecurse attribute deduction for a call sites.
-struct AANoRecurseCallSite final : AANoRecurseImpl {
-  AANoRecurseCallSite(const IRPosition &IRP, Attributor &A)
+/// NoRecurse attribute deduction for a call bases.
+struct AANoRecurseCallBase final : AANoRecurseImpl {
+  AANoRecurseCallBase(const IRPosition &IRP, Attributor &A)
       : AANoRecurseImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AANoRecurseImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F)
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::function(*F);
     auto &FnAA = A.getAAFor<AANoRecurse>(*this, FnPos);
     return clampStateAndIndicateChange(
         getState(),
         static_cast<const AANoRecurse::StateType &>(FnAA.getState()));
   }
void initialize(Attributor &A) override {
     Function *F = getAnchorScope();
     if (!F || !A.isFunctionIPOAmendable(*F) || mayContainUnboundedCycle(*F, A))
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     auto CheckForWillReturn = [&](Instruction &I) {
-      IRPosition IPos = IRPosition::callsite_function(cast<CallBase>(I));
+      IRPosition IPos = IRPosition::callbase_function(cast<CallBase>(I));
       const auto &WillReturnAA = A.getAAFor<AAWillReturn>(*this, IPos);
       if (WillReturnAA.isKnownWillReturn())
         return true;
       if (!WillReturnAA.isAssumedWillReturn())
         return false;
       const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(*this, IPos);
       return NoRecurseAA.isAssumedNoRecurse();
     };

 struct AAWillReturnFunction final : AAWillReturnImpl {
   AAWillReturnFunction(const IRPosition &IRP, Attributor &A)
       : AAWillReturnImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(willreturn) }
 };
 
-/// WillReturn attribute deduction for a call sites.
-struct AAWillReturnCallSite final : AAWillReturnImpl {
-  AAWillReturnCallSite(const IRPosition &IRP, Attributor &A)
+/// WillReturn attribute deduction for a call bases.
+struct AAWillReturnCallBase final : AAWillReturnImpl {
+  AAWillReturnCallBase(const IRPosition &IRP, Attributor &A)
       : AAWillReturnImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AAWillReturnImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F)
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::function(*F);
     auto &FnAA = A.getAAFor<AAWillReturn>(*this, FnPos);
     return clampStateAndIndicateChange(
         getState(),
         static_cast<const AAWillReturn::StateType &>(FnAA.getState()));
   }
struct AANoAliasFloating final : AANoAliasImpl {
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_FLOATING_ATTR(noalias)
   }
 };
 
 /// NoAlias attribute for an argument.
 struct AANoAliasArgument final
-    : AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl> {
-  using Base = AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl>;
+    : AAArgumentFromCallBaseArguments<AANoAlias, AANoAliasImpl> {
+  using Base = AAArgumentFromCallBaseArguments<AANoAlias, AANoAliasImpl>;
   AANoAliasArgument(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     Base::initialize(A);
     // See callsite argument attribute and callee argument attribute.
     if (hasAttr({Attribute::ByVal}))
       indicateOptimisticFixpoint();
ChangeStatus updateImpl(Attributor &A) override {
     // If the argument is read-only, no-alias cannot break synchronization.
     const auto &MemBehaviorAA =
         A.getAAFor<AAMemoryBehavior>(*this, getIRPosition());
     if (MemBehaviorAA.isAssumedReadOnly())
       return Base::updateImpl(A);
 
     // If the argument is never passed through callbacks, no-alias cannot break
     // synchronization.
-    bool AllCallSitesKnown;
-    if (A.checkForAllCallSites(
+    bool AllCallBasesKnown;
+    if (A.checkForAllCallBases(
             [](AbstractCallSite ACS) { return !ACS.isCallbackCall(); }, *this,
-            true, AllCallSitesKnown))
+            true, AllCallBasesKnown))
       return Base::updateImpl(A);
 
     // TODO: add no-alias but make sure it doesn't break synchronization by
     // introducing fake uses. See:
     // [1] Compiler Optimizations for OpenMP, J. Doerfert and H. Finkel,
     //     International Workshop on OpenMP 2018,
     //     http://compilers.cs.uni-saarland.de/people/doerfert/par_opt18.pdf
 
     return indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(noalias) }
 };
 
-struct AANoAliasCallSiteArgument final : AANoAliasImpl {
-  AANoAliasCallSiteArgument(const IRPosition &IRP, Attributor &A)
+struct AANoAliasCallBaseArgument final : AANoAliasImpl {
+  AANoAliasCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AANoAliasImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     // See callsite argument attribute and callee argument attribute.
     const auto &CB = cast<CallBase>(getAnchorValue());
     if (CB.paramHasAttr(getArgNo(), Attribute::NoAlias))
       indicateOptimisticFixpoint();
     Value &Val = getAssociatedValue();
     if (isa<ConstantPointerNull>(Val) &&
         !NullPointerIsDefined(getAnchorScope(),
                               Val.getType()->getPointerAddressSpace()))
       indicateOptimisticFixpoint();
   }
 
-  /// Determine if the underlying value may alias with the call site argument
-  /// \p OtherArgNo of \p ICS (= the underlying call site).
+  /// Determine if the underlying value may alias with the call base argument
+  /// \p OtherArgNo of \p ICS (= the underlying call base).
   bool mayAliasWithArgument(Attributor &A, AAResults *&AAR,
                             const AAMemoryBehavior &MemBehaviorAA,
                             const CallBase &CB, unsigned OtherArgNo) {
     // We do not need to worry about aliasing with the underlying IRP.
     if (this->getArgNo() == (int)OtherArgNo)
       return false;
 
     // If it is not a pointer or pointer vector we do not alias.
     const Value *ArgOp = CB.getArgOperand(OtherArgNo);
     if (!ArgOp->getType()->isPtrOrPtrVectorTy())
       return false;
 
     auto &CBArgMemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
-        *this, IRPosition::callsite_argument(CB, OtherArgNo),
+        *this, IRPosition::callbase_argument(CB, OtherArgNo),
         /* TrackDependence */ false);
 
     // If the argument is readnone, there is no read-write aliasing.
     if (CBArgMemBehaviorAA.isAssumedReadNone()) {
       A.recordDependence(CBArgMemBehaviorAA, *this, DepClassTy::OPTIONAL);
       return false;
     }
 
     // If the argument is readonly and the underlying value is readonly, there
     // is no read-write aliasing.
     bool IsReadOnly = MemBehaviorAA.isAssumedReadOnly();
     if (CBArgMemBehaviorAA.isAssumedReadOnly() && IsReadOnly) {
       A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
       A.recordDependence(CBArgMemBehaviorAA, *this, DepClassTy::OPTIONAL);
       return false;
     }
 
     // We have to utilize actual alias analysis queries so we need the object.
     if (!AAR)
       AAR = A.getInfoCache().getAAResultsForFunction(*getAnchorScope());
 
-    // Try to rule it out at the call site.
+    // Try to rule it out at the call base.
     bool IsAliasing = !AAR || !AAR->isNoAlias(&getAssociatedValue(), ArgOp);
     LLVM_DEBUG(dbgs() << "[NoAliasCSArg] Check alias between "
                          "callsite arguments: "
                       << getAssociatedValue() << " " << *ArgOp << " => "
                       << (IsAliasing ? "" : "no-") << "alias \n");
 
     return IsAliasing;
   }
auto UsePred = [&](const Use &U, bool &Follow) -> bool {
           return true;
 
         if (auto *CB = dyn_cast<CallBase>(UserI)) {
           if (CB->isArgOperand(&U)) {
 
             unsigned ArgNo = CB->getArgOperandNo(&U);
 
             const auto &NoCaptureAA = A.getAAFor<AANoCapture>(
-                *this, IRPosition::callsite_argument(*CB, ArgNo));
+                *this, IRPosition::callbase_argument(*CB, ArgNo));
 
             if (NoCaptureAA.isAssumedNoCapture())
               return true;
           }
         }
       }
 
       // For cases which can potentially have more users
if (!NoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
             dbgs() << "[AANoAliasCSArg] " << getAssociatedValue()
                    << " cannot be noalias as it is potentially captured\n");
         return false;
       }
     }
     A.recordDependence(NoCaptureAA, *this, DepClassTy::OPTIONAL);
 
     // Check there is no other pointer argument which could alias with the
-    // value passed at this call site.
+    // value passed at this call base.
     // TODO: AbstractCallSite
     const auto &CB = cast<CallBase>(getAnchorValue());
     for (unsigned OtherArgNo = 0; OtherArgNo < CB.getNumArgOperands();
          OtherArgNo++)
       if (mayAliasWithArgument(A, AAR, MemBehaviorAA, CB, OtherArgNo))
         return false;
 
     return true;
struct AANoAliasReturned final : AANoAliasImpl {
   /// See AbstractAttribute::updateImpl(...).
   virtual ChangeStatus updateImpl(Attributor &A) override {
 
     auto CheckReturnValue = [&](Value &RV) -> bool {
       if (Constant *C = dyn_cast<Constant>(&RV))
         if (C->isNullValue() || isa<UndefValue>(C))
           return true;
 
-      /// For now, we can only deduce noalias if we have call sites.
+      /// For now, we can only deduce noalias if we have call bases.
       /// FIXME: add more support.
       if (!isa<CallBase>(&RV))
         return false;
 
       const IRPosition &RVPos = IRPosition::value(RV);
       const auto &NoAliasAA = A.getAAFor<AANoAlias>(*this, RVPos);
       if (!NoAliasAA.isAssumedNoAlias())
         return false;
 
       const auto &NoCaptureAA = A.getAAFor<AANoCapture>(*this, RVPos);
       return NoCaptureAA.isAssumedNoCaptureMaybeReturned();
     };
 
     if (!A.checkForAllReturnedValues(CheckReturnValue, *this))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(noalias) }
 };
 
-/// NoAlias attribute deduction for a call site return value.
-struct AANoAliasCallSiteReturned final : AANoAliasImpl {
-  AANoAliasCallSiteReturned(const IRPosition &IRP, Attributor &A)
+/// NoAlias attribute deduction for a call base return value.
+struct AANoAliasCallBaseReturned final : AANoAliasImpl {
+  AANoAliasCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : AANoAliasImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AANoAliasImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F)
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::returned(*F);
     auto &FnAA = A.getAAFor<AANoAlias>(*this, FnPos);
     return clampStateAndIndicateChange(
         getState(), static_cast<const AANoAlias::StateType &>(FnAA.getState()));
   }
 
struct AAIsDeadValueImpl : public AAIsDead {
   bool isAssumedSideEffectFree(Attributor &A, Instruction *I) {
     if (!I || wouldInstructionBeTriviallyDead(I))
       return true;
 
     auto *CB = dyn_cast<CallBase>(I);
     if (!CB || isa<IntrinsicInst>(CB))
       return false;
 
-    const IRPosition &CallIRP = IRPosition::callsite_function(*CB);
+    const IRPosition &CallIRP = IRPosition::callbase_function(*CB);
     const auto &NoUnwindAA = A.getAndUpdateAAFor<AANoUnwind>(
         *this, CallIRP, /* TrackDependence */ false);
     if (!NoUnwindAA.isAssumedNoUnwind())
       return false;
     if (!NoUnwindAA.isKnownNoUnwind())
       A.recordDependence(NoUnwindAA, *this, DepClassTy::OPTIONAL);
 
     const auto &MemBehaviorAA = A.getAndUpdateAAFor<AAMemoryBehavior>(
if (A.isValidFunctionSignatureRewrite(Arg, /* ReplacementTypes */ {}))
       }
     return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(IsDead) }
 };
 
-struct AAIsDeadCallSiteArgument : public AAIsDeadValueImpl {
-  AAIsDeadCallSiteArgument(const IRPosition &IRP, Attributor &A)
+struct AAIsDeadCallBaseArgument : public AAIsDeadValueImpl {
+  AAIsDeadCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AAIsDeadValueImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     if (isa<UndefValue>(getAssociatedValue()))
       indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Argument *Arg = getAssociatedArgument();
     if (!Arg)
       return indicatePessimisticFixpoint();
     const IRPosition &ArgPos = IRPosition::argument(*Arg);
     auto &ArgAA = A.getAAFor<AAIsDead>(*this, ArgPos);
     return clampStateAndIndicateChange(
         getState(), static_cast<const AAIsDead::StateType &>(ArgAA.getState()));
if (A.changeUseAfterManifest(U, UV))
       return ChangeStatus::CHANGED;
     return ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(IsDead) }
 };
 
-struct AAIsDeadCallSiteReturned : public AAIsDeadFloating {
-  AAIsDeadCallSiteReturned(const IRPosition &IRP, Attributor &A)
+struct AAIsDeadCallBaseReturned : public AAIsDeadFloating {
+  AAIsDeadCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : AAIsDeadFloating(IRP, A), IsAssumedSideEffectFree(true) {}
 
   /// See AAIsDead::isAssumedDead().
   bool isAssumedDead() const override {
     return AAIsDeadFloating::isAssumedDead() && IsAssumedSideEffectFree;
   }
 
   /// See AbstractAttribute::initialize(...).
AAIsDeadReturned(const IRPosition &IRP, Attributor &A)
       : AAIsDeadValueImpl(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
 
     A.checkForAllInstructions([](Instruction &) { return true; }, *this,
                               {Instruction::Ret});
 
-    auto PredForCallSite = [&](AbstractCallSite ACS) {
+    auto PredForCallBase = [&](AbstractCallSite ACS) {
       if (ACS.isCallbackCall() || !ACS.getInstruction())
         return false;
       return areAllUsesAssumedDead(A, *ACS.getInstruction());
     };
 
-    bool AllCallSitesKnown;
-    if (!A.checkForAllCallSites(PredForCallSite, *this, true,
-                                AllCallSitesKnown))
+    bool AllCallBasesKnown;
+    if (!A.checkForAllCallBases(PredForCallBase, *this, true,
+                                AllCallBasesKnown))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractAttribute::manifest(...).
   ChangeStatus manifest(Attributor &A) override {
     // TODO: Rewrite the signature to return void?
ChangeStatus manifest(Attributor &A) override {
     bool Invoke2CallAllowed = !mayCatchAsynchronousExceptions(F);
 
     KnownDeadEnds.set_union(ToBeExploredFrom);
     for (const Instruction *DeadEndI : KnownDeadEnds) {
       auto *CB = dyn_cast<CallBase>(DeadEndI);
       if (!CB)
         continue;
       const auto &NoReturnAA = A.getAndUpdateAAFor<AANoReturn>(
-          *this, IRPosition::callsite_function(*CB), /* TrackDependence */ true,
+          *this, IRPosition::callbase_function(*CB), /* TrackDependence */ true,
           DepClassTy::OPTIONAL);
       bool MayReturn = !NoReturnAA.isAssumedNoReturn();
       if (MayReturn && (!Invoke2CallAllowed || !isa<InvokeInst>(CB)))
         continue;
 
       if (auto *II = dyn_cast<InvokeInst>(DeadEndI))
         A.registerInvokeWithDeadSuccessor(const_cast<InvokeInst &>(*II));
       else
struct AAIsDeadFunction : public AAIsDead {
   /// Collection of all assumed live BasicBlocks.
   DenseSet<const BasicBlock *> AssumedLiveBlocks;
 };
 
 static bool
 identifyAliveSuccessors(Attributor &A, const CallBase &CB,
                         AbstractAttribute &AA,
                         SmallVectorImpl<const Instruction *> &AliveSuccessors) {
-  const IRPosition &IPos = IRPosition::callsite_function(CB);
+  const IRPosition &IPos = IRPosition::callbase_function(CB);
 
   const auto &NoReturnAA = A.getAndUpdateAAFor<AANoReturn>(
       AA, IPos, /* TrackDependence */ true, DepClassTy::OPTIONAL);
   if (NoReturnAA.isAssumedNoReturn())
     return !NoReturnAA.isKnownNoReturn();
   if (CB.isTerminator())
     AliveSuccessors.push_back(&CB.getSuccessor(0)->front());
   else
bool UsedAssumedInformation =
       identifyAliveSuccessors(A, cast<CallBase>(II), AA, AliveSuccessors);
 
   // First, determine if we can change an invoke to a call assuming the
   // callee is nounwind. This is not possible if the personality of the
   // function allows to catch asynchronous exceptions.
   if (AAIsDeadFunction::mayCatchAsynchronousExceptions(*II.getFunction())) {
     AliveSuccessors.push_back(&II.getUnwindDest()->front());
   } else {
-    const IRPosition &IPos = IRPosition::callsite_function(II);
+    const IRPosition &IPos = IRPosition::callbase_function(II);
     const auto &AANoUnw = A.getAndUpdateAAFor<AANoUnwind>(
         AA, IPos, /* TrackDependence */ true, DepClassTy::OPTIONAL);
     if (AANoUnw.isAssumedNoUnwind()) {
       UsedAssumedInformation |= !AANoUnw.isKnownNoUnwind();
     } else {
       AliveSuccessors.push_back(&II.getUnwindDest()->front());
     }
   }
if (ToBeExploredFrom.empty() &&
       getAnchorScope()->size() == AssumedLiveBlocks.size() &&
       llvm::all_of(KnownDeadEnds, [](const Instruction *DeadEndI) {
         return DeadEndI->isTerminator() && DeadEndI->getNumSuccessors() == 0;
       }))
     return indicatePessimisticFixpoint();
   return Change;
 }
 
-/// Liveness information for a call sites.
-struct AAIsDeadCallSite final : AAIsDeadFunction {
-  AAIsDeadCallSite(const IRPosition &IRP, Attributor &A)
+/// Liveness information for a call bases.
+struct AAIsDeadCallBase final : AAIsDeadFunction {
+  AAIsDeadCallBase(const IRPosition &IRP, Attributor &A)
       : AAIsDeadFunction(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases instead of
     //       redirecting requests to the callee.
     llvm_unreachable("Abstract attributes for liveness are not "
-                     "supported for call sites yet!");
+                     "supported for call bases yet!");
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     return indicatePessimisticFixpoint();
   }
 
   /// See AbstractAttribute::trackStatistics()
struct AADereferenceableReturned final
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_FNRET_ATTR(dereferenceable)
   }
 };
 
 /// Dereferenceable attribute for an argument
 struct AADereferenceableArgument final
-    : AAArgumentFromCallSiteArguments<AADereferenceable,
+    : AAArgumentFromCallBaseArguments<AADereferenceable,
                                       AADereferenceableImpl> {
   using Base =
-      AAArgumentFromCallSiteArguments<AADereferenceable, AADereferenceableImpl>;
+      AAArgumentFromCallBaseArguments<AADereferenceable, AADereferenceableImpl>;
   AADereferenceableArgument(const IRPosition &IRP, Attributor &A)
       : Base(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_ARG_ATTR(dereferenceable)
   }
 };
 
-/// Dereferenceable attribute for a call site argument.
-struct AADereferenceableCallSiteArgument final : AADereferenceableFloating {
-  AADereferenceableCallSiteArgument(const IRPosition &IRP, Attributor &A)
+/// Dereferenceable attribute for a call base argument.
+struct AADereferenceableCallBaseArgument final : AADereferenceableFloating {
+  AADereferenceableCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AADereferenceableFloating(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CSARG_ATTR(dereferenceable)
   }
 };
 
-/// Dereferenceable attribute deduction for a call site return value.
-struct AADereferenceableCallSiteReturned final
-    : AACallSiteReturnedFromReturned<AADereferenceable, AADereferenceableImpl> {
+/// Dereferenceable attribute deduction for a call base return value.
+struct AADereferenceableCallBaseReturned final
+    : AACallBaseReturnedFromReturned<AADereferenceable, AADereferenceableImpl> {
   using Base =
-      AACallSiteReturnedFromReturned<AADereferenceable, AADereferenceableImpl>;
-  AADereferenceableCallSiteReturned(const IRPosition &IRP, Attributor &A)
+      AACallBaseReturnedFromReturned<AADereferenceable, AADereferenceableImpl>;
+  AADereferenceableCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : Base(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CS_ATTR(dereferenceable);
   }
 };
 
static unsigned getKnownAlignForUse(Attributor &A,
   }
 
   MaybeAlign MA;
   if (const auto *CB = dyn_cast<CallBase>(I)) {
     if (CB->isBundleOperand(U) || CB->isCallee(U))
       return 0;
 
     unsigned ArgNo = CB->getArgOperandNo(U);
-    IRPosition IRP = IRPosition::callsite_argument(*CB, ArgNo);
+    IRPosition IRP = IRPosition::callbase_argument(*CB, ArgNo);
     // As long as we only use known information there is no need to track
     // dependences here.
     auto &AlignAA = A.getAAFor<AAAlign>(QueryingAA, IRP,
                                         /* TrackDependence */ false);
     MA = MaybeAlign(AlignAA.getKnownAlign());
   }
 
   const DataLayout &DL = A.getDataLayout();
AAAlignReturned(const IRPosition &IRP, Attributor &A)
       : AAReturnedFromReturnedValues<AAAlign, AAAlignImpl>(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(aligned) }
 };
 
 /// Align attribute for function argument.
 struct AAAlignArgument final
-    : AAArgumentFromCallSiteArguments<AAAlign, AAAlignImpl> {
-  using Base = AAArgumentFromCallSiteArguments<AAAlign, AAAlignImpl>;
+    : AAArgumentFromCallBaseArguments<AAAlign, AAAlignImpl> {
+  using Base = AAArgumentFromCallBaseArguments<AAAlign, AAAlignImpl>;
   AAAlignArgument(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}
 
   /// See AbstractAttribute::manifest(...).
   ChangeStatus manifest(Attributor &A) override {
     // If the associated argument is involved in a must-tail call we give up
     // because we would need to keep the argument alignments of caller and
     // callee in-sync. Just does not seem worth the trouble right now.
     if (A.getInfoCache().isInvolvedInMustTailCall(*getAssociatedArgument()))
       return ChangeStatus::UNCHANGED;
     return Base::manifest(A);
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(aligned) }
 };
 
-struct AAAlignCallSiteArgument final : AAAlignFloating {
-  AAAlignCallSiteArgument(const IRPosition &IRP, Attributor &A)
+struct AAAlignCallBaseArgument final : AAAlignFloating {
+  AAAlignCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AAAlignFloating(IRP, A) {}
 
   /// See AbstractAttribute::manifest(...).
   ChangeStatus manifest(Attributor &A) override {
     // If the associated argument is involved in a must-tail call we give up
     // because we would need to keep the argument alignments of caller and
     // callee in-sync. Just does not seem worth the trouble right now.
     if (Argument *Arg = getAssociatedArgument())
ChangeStatus updateImpl(Attributor &A) override {
     }
     return Changed;
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(aligned) }
 };
 
-/// Align attribute deduction for a call site return value.
-struct AAAlignCallSiteReturned final
-    : AACallSiteReturnedFromReturned<AAAlign, AAAlignImpl> {
-  using Base = AACallSiteReturnedFromReturned<AAAlign, AAAlignImpl>;
-  AAAlignCallSiteReturned(const IRPosition &IRP, Attributor &A)
+/// Align attribute deduction for a call base return value.
+struct AAAlignCallBaseReturned final
+    : AACallBaseReturnedFromReturned<AAAlign, AAAlignImpl> {
+  using Base = AACallBaseReturnedFromReturned<AAAlign, AAAlignImpl>;
+  AAAlignCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : Base(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     Base::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F)
       indicatePessimisticFixpoint();

 struct AANoReturnFunction final : AANoReturnImpl {
   AANoReturnFunction(const IRPosition &IRP, Attributor &A)
       : AANoReturnImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(noreturn) }
 };
 
-/// NoReturn attribute deduction for a call sites.
-struct AANoReturnCallSite final : AANoReturnImpl {
-  AANoReturnCallSite(const IRPosition &IRP, Attributor &A)
+/// NoReturn attribute deduction for a call bases.
+struct AANoReturnCallBase final : AANoReturnImpl {
+  AANoReturnCallBase(const IRPosition &IRP, Attributor &A)
       : AANoReturnImpl(IRP, A) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::function(*F);
     auto &FnAA = A.getAAFor<AANoReturn>(*this, FnPos);
     return clampStateAndIndicateChange(
         getState(),
         static_cast<const AANoReturn::StateType &>(FnAA.getState()));
   }
if (isa<PtrToIntInst>(UInst)) {
       return valueMayBeCaptured(UInst);
     }
 
     // Explicitly catch return instructions.
     if (isa<ReturnInst>(UInst))
       return isCapturedIn(/* Memory */ false, /* Integer */ false,
                           /* Return */ true);
 
-    // For now we only use special logic for call sites. However, the tracker
+    // For now we only use special logic for call bases. However, the tracker
     // itself knows about a lot of other non-capturing cases already.
     auto *CB = dyn_cast<CallBase>(UInst);
     if (!CB || !CB->isArgOperand(U))
       return isCapturedIn(/* Memory */ true, /* Integer */ true,
                           /* Return */ true);
 
     unsigned ArgNo = CB->getArgOperandNo(U);
-    const IRPosition &CSArgPos = IRPosition::callsite_argument(*CB, ArgNo);
+    const IRPosition &CSArgPos = IRPosition::callbase_argument(*CB, ArgNo);
     // If we have a abstract no-capture attribute for the argument we can use
     // it to justify a non-capture attribute here. This allows recursion!
     auto &ArgNoCaptureAA = A.getAAFor<AANoCapture>(NoCaptureAA, CSArgPos);
     if (ArgNoCaptureAA.isAssumedNoCapture())
       return isCapturedIn(/* Memory */ false, /* Integer */ false,
                           /* Return */ false);
     if (ArgNoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
       addPotentialCopy(*CB);

 struct AANoCaptureArgument final : AANoCaptureImpl {
   AANoCaptureArgument(const IRPosition &IRP, Attributor &A)
       : AANoCaptureImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nocapture) }
 };
 
-/// NoCapture attribute for call site arguments.
-struct AANoCaptureCallSiteArgument final : AANoCaptureImpl {
-  AANoCaptureCallSiteArgument(const IRPosition &IRP, Attributor &A)
+/// NoCapture attribute for call base arguments.
+struct AANoCaptureCallBaseArgument final : AANoCaptureImpl {
+  AANoCaptureCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AANoCaptureImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     if (Argument *Arg = getAssociatedArgument())
       if (Arg->hasByValAttr())
         indicateOptimisticFixpoint();
     AANoCaptureImpl::initialize(A);
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Argument *Arg = getAssociatedArgument();
     if (!Arg)
       return indicatePessimisticFixpoint();
     const IRPosition &ArgPos = IRPosition::argument(*Arg);
     auto &ArgAA = A.getAAFor<AANoCapture>(*this, ArgPos);
     return clampStateAndIndicateChange(
         getState(),
struct AANoCaptureReturned final : AANoCaptureImpl {
   ChangeStatus updateImpl(Attributor &A) override {
     llvm_unreachable("NoCapture is not applicable to function returns!");
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {}
 };
 
-/// NoCapture attribute deduction for a call site return value.
-struct AANoCaptureCallSiteReturned final : AANoCaptureImpl {
-  AANoCaptureCallSiteReturned(const IRPosition &IRP, Attributor &A)
+/// NoCapture attribute deduction for a call base return value.
+struct AANoCaptureCallBaseReturned final : AANoCaptureImpl {
+  AANoCaptureCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : AANoCaptureImpl(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CSRET_ATTR(nocapture)
   }
 };
 
if (Arg->hasByValAttr()) {
       //       there is no race by not copying a constant byval.
       const auto &MemAA = A.getAAFor<AAMemoryBehavior>(*this, getIRPosition());
       if (!MemAA.isAssumedReadOnly())
         return indicatePessimisticFixpoint();
     }
 
     bool HasValueBefore = SimplifiedAssociatedValue.hasValue();
 
-    auto PredForCallSite = [&](AbstractCallSite ACS) {
+    auto PredForCallBase = [&](AbstractCallSite ACS) {
       const IRPosition &ACSArgPos =
-          IRPosition::callsite_argument(ACS, getArgNo());
+          IRPosition::callbase_argument(ACS, getArgNo());
       // Check if a coresponding argument was found or if it is on not
       // associated (which can happen for callback calls).
       if (ACSArgPos.getPositionKind() == IRPosition::IRP_INVALID)
         return false;
 
       // We can only propagate thread independent values through callbacks.
-      // This is different to direct/indirect call sites because for them we
+      // This is different to direct/indirect call bases because for them we
       // know the thread executing the caller and callee is the same. For
       // callbacks this is not guaranteed, thus a thread dependent value could
       // be different for the caller and callee, making it invalid to propagate.
       Value &ArgOp = ACSArgPos.getAssociatedValue();
       if (ACS.isCallbackCall())
         if (auto *C = dyn_cast<Constant>(&ArgOp))
           if (C->isThreadDependent())
             return false;
       return checkAndUpdate(A, *this, ArgOp, SimplifiedAssociatedValue);
     };
 
-    bool AllCallSitesKnown;
-    if (!A.checkForAllCallSites(PredForCallSite, *this, true,
-                                AllCallSitesKnown))
+    bool AllCallBasesKnown;
+    if (!A.checkForAllCallBases(PredForCallBase, *this, true,
+                                AllCallBasesKnown))
       if (!askSimplifiedValueForAAValueConstantRange(A))
         return indicatePessimisticFixpoint();
 
     // If a candicate was found in this update, return CHANGED.
     return HasValueBefore == SimplifiedAssociatedValue.hasValue()
                ? ChangeStatus::UNCHANGED
                : ChangeStatus ::CHANGED;
   }
struct AAValueSimplifyFunction : AAValueSimplifyImpl {
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     SimplifiedAssociatedValue = &getAnchorValue();
     indicateOptimisticFixpoint();
   }
   /// See AbstractAttribute::initialize(...).
   ChangeStatus updateImpl(Attributor &A) override {
     llvm_unreachable(
-        "AAValueSimplify(Function|CallSite)::updateImpl will not be called");
+        "AAValueSimplify(Function|CallBase)::updateImpl will not be called");
   }
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_FN_ATTR(value_simplify)
   }
 };
 
-struct AAValueSimplifyCallSite : AAValueSimplifyFunction {
-  AAValueSimplifyCallSite(const IRPosition &IRP, Attributor &A)
+struct AAValueSimplifyCallBase : AAValueSimplifyFunction {
+  AAValueSimplifyCallBase(const IRPosition &IRP, Attributor &A)
       : AAValueSimplifyFunction(IRP, A) {}
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CS_ATTR(value_simplify)
   }
 };
 
-struct AAValueSimplifyCallSiteReturned : AAValueSimplifyReturned {
-  AAValueSimplifyCallSiteReturned(const IRPosition &IRP, Attributor &A)
+struct AAValueSimplifyCallBaseReturned : AAValueSimplifyReturned {
+  AAValueSimplifyCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : AAValueSimplifyReturned(IRP, A) {}
 
   /// See AbstractAttribute::manifest(...).
   ChangeStatus manifest(Attributor &A) override {
     return AAValueSimplifyImpl::manifest(A);
   }
 
   void trackStatistics() const override {
     STATS_DECLTRACK_CSRET_ATTR(value_simplify)
   }
 };
-struct AAValueSimplifyCallSiteArgument : AAValueSimplifyFloating {
-  AAValueSimplifyCallSiteArgument(const IRPosition &IRP, Attributor &A)
+struct AAValueSimplifyCallBaseArgument : AAValueSimplifyFloating {
+  AAValueSimplifyCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AAValueSimplifyFloating(IRP, A) {}
 
   void trackStatistics() const override {
     STATS_DECLTRACK_CSARG_ATTR(value_simplify)
   }
 };
 
 /// ----------------------- Heap-To-Stack Conversion ---------------------------
auto Pred = [&](const Use &U, bool &Follow) -> bool {
             ValidUsesOnly = false;
           }
           return true;
         }
 
         unsigned ArgNo = CB->getArgOperandNo(&U);
 
         const auto &NoCaptureAA = A.getAAFor<AANoCapture>(
-            *this, IRPosition::callsite_argument(*CB, ArgNo));
+            *this, IRPosition::callbase_argument(*CB, ArgNo));
 
         // If a callsite argument use is nofree, we are fine.
         const auto &ArgNoFreeAA = A.getAAFor<AANoFree>(
-            *this, IRPosition::callsite_argument(*CB, ArgNo));
+            *this, IRPosition::callbase_argument(*CB, ArgNo));
 
         if (!NoCaptureAA.isAssumedNoCapture() ||
             !ArgNoFreeAA.isAssumedNoFree()) {
           LLVM_DEBUG(dbgs() << "[H2S] Bad user: " << *UserI << "\n");
           ValidUsesOnly = false;
         }
         return true;
       }
struct AAPrivatizablePtrImpl : public AAPrivatizablePtr {
   const std::string getAsStr() const override {
     return isAssumedPrivatizablePtr() ? "[priv]" : "[no-priv]";
   }
 
 protected:
   Optional<Type *> PrivatizableType;
 };
 
-// TODO: Do this for call site arguments (probably also other values) as well.
+// TODO: Do this for call base arguments (probably also other values) as well.
 
 struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
   AAPrivatizablePtrArgument(const IRPosition &IRP, Attributor &A)
       : AAPrivatizablePtrImpl(IRP, A) {}
 
   /// See AAPrivatizablePtrImpl::identifyPrivatizableType(...)
   Optional<Type *> identifyPrivatizableType(Attributor &A) override {
-    // If this is a byval argument and we know all the call sites (so we can
+    // If this is a byval argument and we know all the call bases (so we can
     // rewrite them), there is no need to check them explicitly.
-    bool AllCallSitesKnown;
+    bool AllCallBasesKnown;
     if (getIRPosition().hasAttr(Attribute::ByVal) &&
-        A.checkForAllCallSites([](AbstractCallSite ACS) { return true; }, *this,
-                               true, AllCallSitesKnown))
+        A.checkForAllCallBases([](AbstractCallSite ACS) { return true; }, *this,
+                               true, AllCallBasesKnown))
       return getAssociatedValue().getType()->getPointerElementType();
 
     Optional<Type *> Ty;
     unsigned ArgNo = getIRPosition().getArgNo();
 
-    // Make sure the associated call site argument has the same type at all call
+    // Make sure the associated call base argument has the same type at all call
     // sites and it is an allocation we know is safe to privatize, for now that
     // means we only allow alloca instructions.
     // TODO: We can additionally analyze the accesses in the callee to  create
     //       the type from that information instead. That is a little more
     //       involved and will be done in a follow up patch.
-    auto CallSiteCheck = [&](AbstractCallSite ACS) {
-      IRPosition ACSArgPos = IRPosition::callsite_argument(ACS, ArgNo);
+    auto CallBaseCheck = [&](AbstractCallSite ACS) {
+      IRPosition ACSArgPos = IRPosition::callbase_argument(ACS, ArgNo);
       // Check if a coresponding argument was found or if it is one not
       // associated (which can happen for callback calls).
       if (ACSArgPos.getPositionKind() == IRPosition::IRP_INVALID)
         return false;
 
-      // Check that all call sites agree on a type.
+      // Check that all call bases agree on a type.
       auto &PrivCSArgAA = A.getAAFor<AAPrivatizablePtr>(*this, ACSArgPos);
       Optional<Type *> CSTy = PrivCSArgAA.getPrivatizableType();
 
       LLVM_DEBUG({
         dbgs() << "[AAPrivatizablePtr] ACSPos: " << ACSArgPos << ", CSTy: ";
         if (CSTy.hasValue() && CSTy.getValue())
           CSTy.getValue()->print(dbgs());
         else if (CSTy.hasValue())
auto CallBaseCheck = [&](AbstractCallSite ACS) {
         else
           dbgs() << "<none>";
         dbgs() << "\n";
       });
 
       return !Ty.hasValue() || Ty.getValue();
     };
 
-    if (!A.checkForAllCallSites(CallSiteCheck, *this, true, AllCallSitesKnown))
+    if (!A.checkForAllCallBases(CallBaseCheck, *this, true, AllCallBasesKnown))
       return nullptr;
     return Ty;
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
     PrivatizableType = identifyPrivatizableType(A);
     if (!PrivatizableType.hasValue())
ChangeStatus updateImpl(Attributor &A) override {
     Argument *Arg = getAssociatedArgument();
     if (!A.isValidFunctionSignatureRewrite(*Arg, ReplacementTypes)) {
       LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] Rewrite not valid\n");
       return indicatePessimisticFixpoint();
     }
 
     unsigned ArgNo = Arg->getArgNo();
 
-    // Helper to check if for the given call site the associated argument is
+    // Helper to check if for the given call base the associated argument is
     // passed to a callback where the privatization would be different.
     auto IsCompatiblePrivArgOfCallback = [&](CallBase &CB) {
       SmallVector<const Use *, 4> CallbackUses;
       AbstractCallSite::getCallbackUses(CB, CallbackUses);
       for (const Use *U : CallbackUses) {
         AbstractCallSite CBACS(U);
         assert(CBACS && CBACS.isCallbackCall());
         for (Argument &CBArg : CBACS.getCalledFunction()->args()) {
auto IsCompatiblePrivArgOfCallback = [&](CallBase &CB) {
                       "privatization is not compatible.\n";
           });
           return false;
         }
       }
       return true;
     };
 
-    // Helper to check if for the given call site the associated argument is
+    // Helper to check if for the given call base the associated argument is
     // passed to a direct call where the privatization would be different.
     auto IsCompatiblePrivArgOfDirectCS = [&](AbstractCallSite ACS) {
       CallBase *DC = cast<CallBase>(ACS.getInstruction());
       int DCArgNo = ACS.getCallArgOperandNo(ArgNo);
       assert(DCArgNo >= 0 && unsigned(DCArgNo) < DC->getNumArgOperands() &&
              "Expected a direct call operand for callback call operand");
 
       LLVM_DEBUG({
auto IsCompatiblePrivArgOfDirectCS = [&](AbstractCallSite ACS) {
                << 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
+    // call base in a way that is incompatible with the privatization assumed
     // here.
-    auto IsCompatiblePrivArgOfOtherCallSite = [&](AbstractCallSite ACS) {
+    auto IsCompatiblePrivArgOfOtherCallBase = [&](AbstractCallSite ACS) {
       if (ACS.isDirectCall())
         return IsCompatiblePrivArgOfCallback(*ACS.getInstruction());
       if (ACS.isCallbackCall())
         return IsCompatiblePrivArgOfDirectCS(ACS);
       return false;
     };
 
-    bool AllCallSitesKnown;
-    if (!A.checkForAllCallSites(IsCompatiblePrivArgOfOtherCallSite, *this, true,
-                                AllCallSitesKnown))
+    bool AllCallBasesKnown;
+    if (!A.checkForAllCallBases(IsCompatiblePrivArgOfOtherCallBase, *this, true,
+                                AllCallBasesKnown))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 
   /// Given a type to private \p PrivType, collect the constituates (which are
   /// used) in \p ReplacementTypes.
   static void
Attributor::ArgumentReplacementInfo::CalleeRepairCBTy FnRepairCB =
           createInitialization(PrivatizableType.getValue(), *AI, ReplacementFn,
                                ArgIt->getArgNo(), *IP);
           Arg->replaceAllUsesWith(AI);
 
           for (CallInst *CI : TailCalls)
             CI->setTailCall(false);
         };
 
-    // Callback to repair a call site of the associated function. The elements
+    // Callback to repair a call base of the associated function. The elements
     // of the privatizable type are loaded prior to the call and passed to the
     // new function version.
     Attributor::ArgumentReplacementInfo::ACSRepairCBTy ACSRepairCB =
         [=, &AlignAA](const Attributor::ArgumentReplacementInfo &ARI,
                       AbstractCallSite ACS,
                       SmallVectorImpl<Value *> &NewArgOperands) {
           // When no alignment is specified for the load instruction,
           // natural alignment is assumed.
struct AAPrivatizablePtrFloating : public AAPrivatizablePtrImpl {
 
   /// See AbstractAttribute::initialize(...).
   virtual void initialize(Attributor &A) override {
     // TODO: We can privatize more than arguments.
     indicatePessimisticFixpoint();
   }
 
   ChangeStatus updateImpl(Attributor &A) override {
-    llvm_unreachable("AAPrivatizablePtr(Floating|Returned|CallSiteReturned)::"
+    llvm_unreachable("AAPrivatizablePtr(Floating|Returned|CallBaseReturned)::"
                      "updateImpl will not be called");
   }
 
   /// See AAPrivatizablePtrImpl::identifyPrivatizableType(...)
   Optional<Type *> identifyPrivatizableType(Attributor &A) override {
     Value *Obj =
         GetUnderlyingObject(&getAssociatedValue(), A.getInfoCache().getDL());
     if (!Obj) {
struct AAPrivatizablePtrFloating : public AAPrivatizablePtrImpl {
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_FLOATING_ATTR(privatizable_ptr);
   }
 };
 
-struct AAPrivatizablePtrCallSiteArgument final
+struct AAPrivatizablePtrCallBaseArgument final
     : public AAPrivatizablePtrFloating {
-  AAPrivatizablePtrCallSiteArgument(const IRPosition &IRP, Attributor &A)
+  AAPrivatizablePtrCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AAPrivatizablePtrFloating(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     if (getIRPosition().hasAttr(Attribute::ByVal))
       indicateOptimisticFixpoint();
   }
 
struct AAPrivatizablePtrCallBaseArgument final
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CSARG_ATTR(privatizable_ptr);
   }
 };
 
-struct AAPrivatizablePtrCallSiteReturned final
+struct AAPrivatizablePtrCallBaseReturned final
     : public AAPrivatizablePtrFloating {
-  AAPrivatizablePtrCallSiteReturned(const IRPosition &IRP, Attributor &A)
+  AAPrivatizablePtrCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : AAPrivatizablePtrFloating(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     // TODO: We can privatize more than arguments.
     indicatePessimisticFixpoint();
   }
 
if (isAssumedReadNone())
       STATS_DECLTRACK_ARG_ATTR(readnone)
     else if (isAssumedReadOnly())
       STATS_DECLTRACK_ARG_ATTR(readonly)
     else if (isAssumedWriteOnly())
       STATS_DECLTRACK_ARG_ATTR(writeonly)
   }
 };
 
-struct AAMemoryBehaviorCallSiteArgument final : AAMemoryBehaviorArgument {
-  AAMemoryBehaviorCallSiteArgument(const IRPosition &IRP, Attributor &A)
+struct AAMemoryBehaviorCallBaseArgument final : AAMemoryBehaviorArgument {
+  AAMemoryBehaviorCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AAMemoryBehaviorArgument(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     if (Argument *Arg = getAssociatedArgument()) {
       if (Arg->hasByValAttr()) {
         addKnownBits(NO_WRITES);
         removeKnownBits(NO_READS);
         removeAssumedBits(NO_READS);
       }
     }
     AAMemoryBehaviorArgument::initialize(A);
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Argument *Arg = getAssociatedArgument();
     const IRPosition &ArgPos = IRPosition::argument(*Arg);
     auto &ArgAA = A.getAAFor<AAMemoryBehavior>(*this, ArgPos);
     return clampStateAndIndicateChange(
         getState(),
         static_cast<const AAMemoryBehavior::StateType &>(ArgAA.getState()));
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     if (isAssumedReadNone())
       STATS_DECLTRACK_CSARG_ATTR(readnone)
     else if (isAssumedReadOnly())
       STATS_DECLTRACK_CSARG_ATTR(readonly)
     else if (isAssumedWriteOnly())
       STATS_DECLTRACK_CSARG_ATTR(writeonly)
   }
 };
 
-/// Memory behavior attribute for a call site return position.
-struct AAMemoryBehaviorCallSiteReturned final : AAMemoryBehaviorFloating {
-  AAMemoryBehaviorCallSiteReturned(const IRPosition &IRP, Attributor &A)
+/// Memory behavior attribute for a call base return position.
+struct AAMemoryBehaviorCallBaseReturned final : AAMemoryBehaviorFloating {
+  AAMemoryBehaviorCallBaseReturned(const IRPosition &IRP, Attributor &A)
       : AAMemoryBehaviorFloating(IRP, A) {}
 
   /// See AbstractAttribute::manifest(...).
   ChangeStatus manifest(Attributor &A) override {
     // We do not annotate returned values.
     return ChangeStatus::UNCHANGED;
   }
 
if (isAssumedReadNone())
       STATS_DECLTRACK_FN_ATTR(readnone)
     else if (isAssumedReadOnly())
       STATS_DECLTRACK_FN_ATTR(readonly)
     else if (isAssumedWriteOnly())
       STATS_DECLTRACK_FN_ATTR(writeonly)
   }
 };
 
-/// AAMemoryBehavior attribute for call sites.
-struct AAMemoryBehaviorCallSite final : AAMemoryBehaviorImpl {
-  AAMemoryBehaviorCallSite(const IRPosition &IRP, Attributor &A)
+/// AAMemoryBehavior attribute for call bases.
+struct AAMemoryBehaviorCallBase final : AAMemoryBehaviorImpl {
+  AAMemoryBehaviorCallBase(const IRPosition &IRP, Attributor &A)
       : AAMemoryBehaviorImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AAMemoryBehaviorImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F || !A.isFunctionIPOAmendable(*F)) {
       indicatePessimisticFixpoint();
       return;
     }
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::function(*F);
     auto &FnAA = A.getAAFor<AAMemoryBehavior>(*this, FnPos);
     return clampStateAndIndicateChange(
         getState(),
         static_cast<const AAMemoryBehavior::StateType &>(FnAA.getState()));
   }
ChangeStatus AAMemoryBehaviorFunction::updateImpl(Attributor &A) {
   auto AssumedState = getAssumed();
 
   auto CheckRWInst = [&](Instruction &I) {
     // If the instruction has an own memory behavior state, use it to restrict
     // the local state. No further analysis is required as the other memory
     // state is as optimistic as it gets.
     if (const auto *CB = dyn_cast<CallBase>(&I)) {
       const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
-          *this, IRPosition::callsite_function(*CB));
+          *this, IRPosition::callbase_function(*CB));
       intersectAssumedBits(MemBehaviorAA.getAssumed());
       return !isAtFixpoint();
     }
 
     // Remove access kind modifiers if necessary.
     if (I.mayReadFromMemory())
       removeAssumedBits(NO_READS);
     if (I.mayWriteToMemory())
if (!ArgNoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
     S.intersectAssumedBits(FnMemAssumedState);
     return ChangeStatus::CHANGED;
   }
 
   // The current assumed state used to determine a change.
   auto AssumedState = S.getAssumed();
 
   // Liveness information to exclude dead users.
-  // TODO: Take the FnPos once we have call site specific liveness information.
+  // TODO: Take the FnPos once we have call base specific liveness information.
   const auto &LivenessAA = A.getAAFor<AAIsDead>(
       *this, IRPosition::function(*IRP.getAssociatedFunction()),
       /* TrackDependence */ false);
 
   // Visit and expand uses until all are analyzed or a fixpoint is reached.
   for (unsigned i = 0; i < Uses.size() && !isAtFixpoint(); i++) {
     const Use *U = Uses[i];
     Instruction *UserI = cast<Instruction>(U->getUser());

 bool AAMemoryBehaviorFloating::followUsersOfUseIn(Attributor &A, const Use *U,
                                                   const Instruction *UserI) {
   // The loaded value is unrelated to the pointer argument, no need to
   // follow the users of the load.
   if (isa<LoadInst>(UserI))
     return false;
 
   // By default we follow all uses assuming UserI might leak information on U,
-  // we have special handling for call sites operands though.
+  // we have special handling for call bases operands though.
   const auto *CB = dyn_cast<CallBase>(UserI);
   if (!CB || !CB->isArgOperand(U))
     return true;
 
   // If the use is a call argument known not to be captured, the users of
   // the call do not need to be visited because they have to be unrelated to
   // the input. Note that this check is not trivial even though we disallow
   // general capturing of the underlying argument. The reason is that the
   // call might the argument "through return", which we allow and for which we
   // need to check call users.
   if (U->get()->getType()->isPointerTy()) {
     unsigned ArgNo = CB->getArgOperandNo(U);
     const auto &ArgNoCaptureAA = A.getAAFor<AANoCapture>(
-        *this, IRPosition::callsite_argument(*CB, ArgNo),
+        *this, IRPosition::callbase_argument(*CB, ArgNo),
         /* TrackDependence */ true, DepClassTy::OPTIONAL);
     return !ArgNoCaptureAA.isAssumedNoCapture();
   }
 
   return true;
 }
 
 void AAMemoryBehaviorFloating::analyzeUseIn(Attributor &A, const Use *U,
case Instruction::Store:
     // somewhere else.
     if (cast<StoreInst>(UserI)->getPointerOperand() == U->get())
       removeAssumedBits(NO_WRITES);
     return;
 
   case Instruction::Call:
   case Instruction::CallBr:
   case Instruction::Invoke: {
-    // For call sites we look at the argument memory behavior attribute (this
+    // For call bases we look at the argument memory behavior attribute (this
     // could be recursive!) in order to restrict our own state.
     const auto *CB = cast<CallBase>(UserI);
 
     // Give up on operand bundles.
     if (CB->isBundleOperand(U)) {
       indicatePessimisticFixpoint();
       return;
     }
 
     // Calling a function does read the function pointer, maybe write it if the
     // function is self-modifying.
     if (CB->isCallee(U)) {
       removeAssumedBits(NO_READS);
       break;
     }
 
     // Adjust the possible access behavior based on the information on the
     // argument.
     IRPosition Pos;
     if (U->get()->getType()->isPointerTy())
-      Pos = IRPosition::callsite_argument(*CB, CB->getArgOperandNo(U));
+      Pos = IRPosition::callbase_argument(*CB, CB->getArgOperandNo(U));
     else
-      Pos = IRPosition::callsite_function(*CB);
+      Pos = IRPosition::callbase_function(*CB);
     const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
         *this, Pos,
         /* TrackDependence */ true, DepClassTy::OPTIONAL);
     // "assumed" has at most the same bits as the MemBehaviorAA assumed
     // and at least "known".
     intersectAssumedBits(MemBehaviorAA.getAssumed());
     return;
   }
auto VisitValueCB = [&](Value &V, const Instruction *,
     } else if (isa<ConstantPointerNull>(V) &&
                !NullPointerIsDefined(getAssociatedFunction(),
                                      V.getType()->getPointerAddressSpace())) {
       return true;
     } else if (isa<AllocaInst>(V)) {
       MLK = NO_LOCAL_MEM;
     } else if (const auto *CB = dyn_cast<CallBase>(&V)) {
       const auto &NoAliasAA =
-          A.getAAFor<AANoAlias>(*this, IRPosition::callsite_returned(*CB));
+          A.getAAFor<AANoAlias>(*this, IRPosition::callbase_returned(*CB));
       if (NoAliasAA.isAssumedNoAlias())
         MLK = NO_MALLOCED_MEM;
       else
         MLK = NO_UNKOWN_MEM;
     } else {
       MLK = NO_UNKOWN_MEM;
     }
 
AAMemoryLocationImpl::categorizeAccessedLocations(Attributor &A, Instruction &I,
 
   AAMemoryLocation::StateType AccessedLocs;
   AccessedLocs.intersectAssumedBits(NO_LOCATIONS);
 
   if (auto *CB = dyn_cast<CallBase>(&I)) {
 
     // First check if we assume any memory is access is visible.
     const auto &CBMemLocationAA =
-        A.getAAFor<AAMemoryLocation>(*this, IRPosition::callsite_function(*CB));
-    LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Categorize call site: " << I
+        A.getAAFor<AAMemoryLocation>(*this, IRPosition::callbase_function(*CB));
+    LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Categorize call base: " << I
                       << " [" << CBMemLocationAA << "]\n");
 
     if (CBMemLocationAA.isAssumedReadNone())
       return NO_LOCATIONS;
 
     if (CBMemLocationAA.isAssumedInaccessibleMemOnly()) {
       updateStateAndAccessesMap(AccessedLocs, NO_INACCESSIBLE_MEM, &I, nullptr,
                                 Changed, getAccessKindFromInst(&I));
if (HasArgAccesses) {
            ++ArgNo) {
 
         // Skip non-pointer arguments.
         const Value *ArgOp = CB->getArgOperand(ArgNo);
         if (!ArgOp->getType()->isPtrOrPtrVectorTy())
           continue;
 
         // Skip readnone arguments.
-        const IRPosition &ArgOpIRP = IRPosition::callsite_argument(*CB, ArgNo);
+        const IRPosition &ArgOpIRP = IRPosition::callbase_argument(*CB, ArgNo);
         const auto &ArgOpMemLocationAA = A.getAAFor<AAMemoryBehavior>(
             *this, ArgOpIRP, /* TrackDependence */ true, DepClassTy::OPTIONAL);
 
         if (ArgOpMemLocationAA.isAssumedReadNone())
           continue;
 
         // Categorize potentially accessed pointer arguments as if there was an
         // access instruction with them as pointer.
else if (isAssumedArgMemOnly())
       STATS_DECLTRACK_FN_ATTR(argmemonly)
     else if (isAssumedInaccessibleMemOnly())
       STATS_DECLTRACK_FN_ATTR(inaccessiblememonly)
     else if (isAssumedInaccessibleOrArgMemOnly())
       STATS_DECLTRACK_FN_ATTR(inaccessiblememorargmemonly)
   }
 };
 
-/// AAMemoryLocation attribute for call sites.
-struct AAMemoryLocationCallSite final : AAMemoryLocationImpl {
-  AAMemoryLocationCallSite(const IRPosition &IRP, Attributor &A)
+/// AAMemoryLocation attribute for call bases.
+struct AAMemoryLocationCallBase final : AAMemoryLocationImpl {
+  AAMemoryLocationCallBase(const IRPosition &IRP, Attributor &A)
       : AAMemoryLocationImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     AAMemoryLocationImpl::initialize(A);
     Function *F = getAssociatedFunction();
     if (!F || !A.isFunctionIPOAmendable(*F)) {
       indicatePessimisticFixpoint();
       return;
     }
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    // TODO: Once we have call site specific value information we can provide
-    //       call site specific liveness liveness information and then it makes
-    //       sense to specialize attributes for call sites arguments instead of
+    // TODO: Once we have call base specific value information we can provide
+    //       call base specific liveness liveness information and then it makes
+    //       sense to specialize attributes for call bases arguments instead of
     //       redirecting requests to the callee argument.
     Function *F = getAssociatedFunction();
     const IRPosition &FnPos = IRPosition::function(*F);
     auto &FnAA = A.getAAFor<AAMemoryLocation>(*this, FnPos);
     bool Changed = false;
     auto AccessPred = [&](const Instruction *I, const Value *Ptr,
                           AccessKind Kind, MemoryLocationsKind MLK) {
       updateStateAndAccessesMap(getState(), MLK, I, Ptr, Changed,
if (!AssumedConstantRange.isEmptySet() &&
             Changed = ChangeStatus::CHANGED;
     }
 
     return Changed;
   }
 };
 
 struct AAValueConstantRangeArgument final
-    : AAArgumentFromCallSiteArguments<
+    : AAArgumentFromCallBaseArguments<
           AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState> {
-  using Base = AAArgumentFromCallSiteArguments<
+  using Base = AAArgumentFromCallBaseArguments<
       AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState>;
   AAValueConstantRangeArgument(const IRPosition &IRP, Attributor &A)
       : Base(IRP, A) {}
 
   /// See AbstractAttribute::initialize(..).
   void initialize(Attributor &A) override {
     if (!getAnchorScope() || getAnchorScope()->isDeclaration()) {
       indicatePessimisticFixpoint();

 };
 
 struct AAValueConstantRangeFunction : AAValueConstantRangeImpl {
   AAValueConstantRangeFunction(const IRPosition &IRP, Attributor &A)
       : AAValueConstantRangeImpl(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   ChangeStatus updateImpl(Attributor &A) override {
-    llvm_unreachable("AAValueConstantRange(Function|CallSite)::updateImpl will "
+    llvm_unreachable("AAValueConstantRange(Function|CallBase)::updateImpl will "
                      "not be called");
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(value_range) }
 };
 
-struct AAValueConstantRangeCallSite : AAValueConstantRangeFunction {
-  AAValueConstantRangeCallSite(const IRPosition &IRP, Attributor &A)
+struct AAValueConstantRangeCallBase : AAValueConstantRangeFunction {
+  AAValueConstantRangeCallBase(const IRPosition &IRP, Attributor &A)
       : AAValueConstantRangeFunction(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(value_range) }
 };
 
-struct AAValueConstantRangeCallSiteReturned
-    : AACallSiteReturnedFromReturned<AAValueConstantRange,
+struct AAValueConstantRangeCallBaseReturned
+    : AACallBaseReturnedFromReturned<AAValueConstantRange,
                                      AAValueConstantRangeImpl> {
-  AAValueConstantRangeCallSiteReturned(const IRPosition &IRP, Attributor &A)
-      : AACallSiteReturnedFromReturned<AAValueConstantRange,
+  AAValueConstantRangeCallBaseReturned(const IRPosition &IRP, Attributor &A)
+      : AACallBaseReturnedFromReturned<AAValueConstantRange,
                                        AAValueConstantRangeImpl>(IRP, A) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     // If it is a load instruction with range metadata, use the metadata.
     if (CallInst *CI = dyn_cast<CallInst>(&getAssociatedValue()))
       if (auto *RangeMD = CI->getMetadata(LLVMContext::MD_range))
         intersectKnown(getConstantRangeFromMetadata(*RangeMD));
 
     AAValueConstantRangeImpl::initialize(A);
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CSRET_ATTR(value_range)
   }
 };
-struct AAValueConstantRangeCallSiteArgument : AAValueConstantRangeFloating {
-  AAValueConstantRangeCallSiteArgument(const IRPosition &IRP, Attributor &A)
+struct AAValueConstantRangeCallBaseArgument : AAValueConstantRangeFloating {
+  AAValueConstantRangeCallBaseArgument(const IRPosition &IRP, Attributor &A)
       : AAValueConstantRangeFloating(IRP, A) {}
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CSARG_ATTR(value_range)
   }
 };
 } // namespace

 #define CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                 \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_INV(CLASS, IRP_FLOAT, "floating")                              \
       SWITCH_PK_INV(CLASS, IRP_ARGUMENT, "argument")                           \
       SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
-      SWITCH_PK_INV(CLASS, IRP_CALL_SITE_RETURNED, "call site returned")       \
-      SWITCH_PK_INV(CLASS, IRP_CALL_SITE_ARGUMENT, "call site argument")       \
+      SWITCH_PK_INV(CLASS, IRP_CALL_BASE_RETURNED, "call base returned")       \
+      SWITCH_PK_INV(CLASS, IRP_CALL_BASE_ARGUMENT, "call base argument")       \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE, CallBase)                    \
     }                                                                          \
     return *AA;                                                                \
   }
 
 #define CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                    \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_INV(CLASS, IRP_FUNCTION, "function")                           \
-      SWITCH_PK_INV(CLASS, IRP_CALL_SITE, "call site")                         \
+      SWITCH_PK_INV(CLASS, IRP_CALL_BASE, "call base")                         \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_RETURNED, Returned)                     \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE_RETURNED, CallBaseReturned)   \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE_ARGUMENT, CallBaseArgument)   \
     }                                                                          \
     return *AA;                                                                \
   }
 
 #define CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                      \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE, CallBase)                    \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_RETURNED, Returned)                     \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE_RETURNED, CallBaseReturned)   \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE_ARGUMENT, CallBaseArgument)   \
     }                                                                          \
     return *AA;                                                                \
   }
 
 #define CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)            \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_INV(CLASS, IRP_ARGUMENT, "argument")                           \
       SWITCH_PK_INV(CLASS, IRP_FLOAT, "floating")                              \
       SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
-      SWITCH_PK_INV(CLASS, IRP_CALL_SITE_RETURNED, "call site returned")       \
-      SWITCH_PK_INV(CLASS, IRP_CALL_SITE_ARGUMENT, "call site argument")       \
-      SWITCH_PK_INV(CLASS, IRP_CALL_SITE, "call site")                         \
+      SWITCH_PK_INV(CLASS, IRP_CALL_BASE_RETURNED, "call base returned")       \
+      SWITCH_PK_INV(CLASS, IRP_CALL_BASE_ARGUMENT, "call base argument")       \
+      SWITCH_PK_INV(CLASS, IRP_CALL_BASE, "call base")                         \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
     }                                                                          \
     return *AA;                                                                \
   }
 
 #define CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                  \
   CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
     CLASS *AA = nullptr;                                                       \
     switch (IRP.getPositionKind()) {                                           \
       SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
       SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE, CallBase)                    \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
       SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
-      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE_RETURNED, CallBaseReturned)   \
+      SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_BASE_ARGUMENT, CallBaseArgument)   \
     }                                                                          \
     return *AA;                                                                \
   }
 
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoUnwind)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoSync)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoRecurse)
 CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAWillReturn)