[Attributor] Introduce CallBaseContext to the IRPosition

[kuter]

Summary

This patch introduces call base context information to the IRPosition
This patch is part of the patch set that are going to introduce call base specific analysis.

[kuter]

TODO: comments

[jdoerfert]

We need some way of testing this, so tests that enable this and some way of checking the output. We could look for the debug output or add some other way of checking

[jdoerfert]

In D81929#2096257, @jdoerfert wrote:

We need some way of testing this, so tests that enable this and some way of checking the output. We could look for the debug output or add some other way of checking

Reverse ping. Unit tests might also be an option.

[xbolva00]

llvm/lib/Transforms/IPO/Attributor.cpp

83

typo

[kuter]

In D81929#2128955, @jdoerfert wrote:

In D81929#2096257, @jdoerfert wrote:

We need some way of testing this, so tests that enable this and some way of checking the output. We could look for the debug output or add some other way of checking

Reverse ping. Unit tests might also be an option.

Wouldn't just testing the uses of this path enough.
For example if we have are getting a correct call site constant range would that be enough ?

[jdoerfert]

In D81929#2129334, @kuter wrote:

In D81929#2128955, @jdoerfert wrote:

In D81929#2096257, @jdoerfert wrote:

We need some way of testing this, so tests that enable this and some way of checking the output. We could look for the debug output or add some other way of checking

Reverse ping. Unit tests might also be an option.

Wouldn't just testing the uses of this path enough.
For example if we have are getting a correct call site constant range would that be enough ?

Is the CBContext already used? I might have to take another look at this, sorry.

[kuter]

In D81929#2129517, @jdoerfert wrote:

In D81929#2129334, @kuter wrote:

In D81929#2128955, @jdoerfert wrote:

In D81929#2096257, @jdoerfert wrote:

We need some way of testing this, so tests that enable this and some way of checking the output. We could look for the debug output or add some other way of checking

Reverse ping. Unit tests might also be an option.

Wouldn't just testing the uses of this path enough.
For example if we have are getting a correct call site constant range would that be enough ?

Is the CBContext already used? I might have to take another look at this, sorry.

Not by this patch no. But I have patches that use CBContext(That I am going to send to phabricator soon).

[kuter]

general bug fix.

[kuter]

Btw this patch introduces 8 bytes per attribute because of the CBContext.
I think we would ideally move it to a map inside the attributor.

I can inject the context through the update method or make the attribute ask the Attributor
like A.getCBContext(this); one problem with it is that since the operator<< for IRPosition don't have access
to the attributor we would not be able to print it even though it is useful to have.

One potential solution to this is to use a macro switch to have the CBContext inside the IRPosition only in debug builds.

Any other ideas ?

[kuter]

Fix typo

[jdoerfert]

In D81929#2129807, @kuter wrote:

Btw this patch introduces 8 bytes per attribute because of the CBContext.

[...]

Any other ideas ?

Run heapcheck and if the cgscc memory usage is not impacted much keep it this way ;)

We need a test for this. We can use unit tests or check the printed output (lit test + requires: asserts IIRC). Either works but we should add one.

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

457

I'd prefer to copy the entire thing and then null the context. Will be optimized to the same code but is future proof :)

462

Documentation for all of them please.

591

Nit: I would prefer to move/add the initialization here. Assuming it is all the same to you.

953

Move this into a helper function so we don't have to "make LLVM_DEBUG" work here.

955

& RealIRP or maybe:

if (!should...)
  IRP = IRP.strip...

llvm/lib/Transforms/IPO/Attributor.cpp

91

Nit: attributor-enable-call-site-specific is missing a final word, maybe specialization or deduction or something.

466

Good thinking!

804

Nit, formatting.

[kuter]

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

457

Ugh sorry. I will.

955

I think that was the first way that I tried.
Reassigning a const reference does not work.

[jdoerfert]

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

955

You are right. We can remove the const and reference from IRP actually. Either way is fine with me. If we do it as you have it now, maybe make it a reference. I'm not sold on Real as a name, maybe Effective, but that is not perfect either.

[kuter]

add missing documentation.
improve formating and readability.
fix typos.
rename command line option

[jdoerfert]

All this is missing now is a test :). We can just check for the debug output.

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

937

Nit: newline

Now we are in a hybrid solution, should we do if (should...) IRP = ... ?

[kuter]

In D81929#2160764, @jdoerfert wrote:

All this is missing now is a test :). We can just check for the debug output.

The problem I have is that this patch does not add anything that would trigger any of the code here.
There isn't much logic here either, most of it is in D83744.
I can add a unittest for 'hasCallBaseContext` and stripCallBaseContext

[jdoerfert]

Hmm, I hoped with the flag you would see the context printed somewhere but it is never added I suppose. Do we have a unit test setup for the Attributor? Would be good :D

[kuter]

Memory usage for this patch:
comand: $LLVM_BIN/opt -S -attributor-cgscc test-suit/CTMark/SPASS/clause.ll
before:

calls to allocation functions: 78794 (82506/s)
temporary memory allocations: 3942 (4127/s)
peak heap memory consumption: 2.58MB
peak RSS (including heaptrack overhead): 355.73MB
total memory leaked: 140.33KB

after:

calls to allocation functions: 78802 (86977/s)
temporary memory allocations: 3942 (4350/s)
peak heap memory consumption: 2.59MB
peak RSS (including heaptrack overhead): 356.60MB
total memory leaked: 140.33KB

difference:

calls to allocation functions: 8 (-163/s)
temporary memory allocations: 0 (0/s)
peak heap memory consumption: 8.26KB
peak RSS (including heaptrack overhead): 0B
total memory leaked: 0B

Interesting, there doesn't seem to be much of a difference.

[kuter]

Add unittest.

[kuter]

fix styling.

[jdoerfert]

LGTM with nits.

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

453–467

Nit: If this is not yet upstream, use the proper R from the beginning.

915

Not needed anymore?

937

my bad, if (!should..), right?

997

Not needed anymore.

[kuter]

In D81929#2172319, @jdoerfert wrote:

LGTM with nits.

I made a mistake while creating this revision.
This is incomplete. instead of amending the [Attributor] Introduce CallBaseContext to the IRPosition I created a new commit and when I did arc diff It updated it to the state it is.
I will update this to include all of the patch.

sorry for the mess.

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

937

Yes thank you, I should have ran the tests in D83744 before updating the revision.

[kuter]

add missing code.
remove unneeded definies.
fix bug.

[jdoerfert]

LGTM

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

 /// 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
 /// 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
 /// are floating values that do not have a corresponding attribute list
 /// position.
 struct IRPosition {
+  using CallBaseContext = CallBase;
 
   /// 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_FUNCTION,           ///< An attribute for a function (scope).
     IRP_CALL_SITE,          ///< An attribute for a call site (function scope).
     IRP_ARGUMENT,           ///< An attribute for a function argument.
     IRP_CALL_SITE_ARGUMENT, ///< An attribute for a call site 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) {
+  static const IRPosition value(const Value &V,
+                                const CallBaseContext *CBContext = nullptr) {
     if (auto *Arg = dyn_cast<Argument>(&V))
-      return IRPosition::argument(*Arg);
+      return IRPosition::argument(*Arg, CBContext);
     if (auto *CB = dyn_cast<CallBase>(&V))
       return IRPosition::callsite_returned(*CB);
-    return IRPosition(const_cast<Value &>(V), IRP_FLOAT);
+    return IRPosition(const_cast<Value &>(V), IRP_FLOAT, CBContext);
   }
 
   /// 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);
+  /// \p CBContext is used for call base specific analysis.
+  static const IRPosition function(const Function &F,
+                                   const CallBaseContext *CBContext = nullptr) {
+    return IRPosition(const_cast<Function &>(F), IRP_FUNCTION, CBContext);
   }
 
   /// 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);
+  /// \p CBContext is used for call base specific analysis.
+  static const IRPosition returned(const Function &F,
+                                   const CallBaseContext *CBContext = nullptr) {
+    return IRPosition(const_cast<Function &>(F), IRP_RETURNED, CBContext);
   }
 
   /// Create a position describing the argument \p Arg.
-  static const IRPosition argument(const Argument &Arg) {
-    return IRPosition(const_cast<Argument &>(Arg), IRP_ARGUMENT);
+  /// \p CBContext is used for call base specific analysis.
+  static const IRPosition argument(const Argument &Arg,
+                                   const CallBaseContext *CBContext = nullptr) {
+    return IRPosition(const_cast<Argument &>(Arg), IRP_ARGUMENT, CBContext);
   }
 
   /// 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);
   }
 
   /// Create a position describing the returned value of \p CB.
if (CSArgNo >= 0)
           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
   /// associated function.
-  static const IRPosition function_scope(const IRPosition &IRP) {
+  static const IRPosition
+  function_scope(const IRPosition &IRP,
+                 const CallBaseContext *CBContext = nullptr) {
     if (IRP.isAnyCallSitePosition()) {
       return IRPosition::callsite_function(
           cast<CallBase>(IRP.getAnchorValue()));
     }
     assert(IRP.getAssociatedFunction());
-    return IRPosition::function(*IRP.getAssociatedFunction());
+    return IRPosition::function(*IRP.getAssociatedFunction(), CBContext);
   }
 
-  bool operator==(const IRPosition &RHS) const { return Enc == RHS.Enc; }
+  bool operator==(const IRPosition &RHS) const {
+    return Enc == RHS.Enc && RHS.CBContext == CBContext;
+  }
   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.
bool isAnyCallSitePosition() const {
     case IRPosition::IRP_CALL_SITE:
     case IRPosition::IRP_CALL_SITE_RETURNED:
     case IRPosition::IRP_CALL_SITE_ARGUMENT:
       return true;
     default:
       return false;
     }
   }
 
+  /// Return the same position without the call base context.
+  IRPosition stripCallBaseContext() const {
+    IRPosition Result = *this;
+    Result.CBContext = nullptr;
+    return Result;
+  }
+
+  /// Get the call base context from the position.
+  const CallBaseContext *getCallBaseContext() const { return CBContext; }
+
+  /// Check if the position has any call base context.
+  bool hasCallBaseContext() const { return CBContext != nullptr; }
+
   /// Special DenseMap key values.
   ///
   ///{
   static const IRPosition EmptyKey;
   static const IRPosition TombstoneKey;
   ///}
 
   /// Conversion into a void * to allow reuse of pointer hashing.
   operator void *() const { return Enc.getOpaqueValue(); }
 
 private:
   /// Private constructor for special values only!
-  explicit IRPosition(void *Ptr) { Enc.setFromOpaqueValue(Ptr); }
+  explicit IRPosition(void *Ptr, const CallBaseContext *CBContext = nullptr)
+      : CBContext(CBContext) {
+    Enc.setFromOpaqueValue(Ptr);
+  }
 
   /// IRPosition anchored at \p AnchorVal with kind/argument numbet \p PK.
-  explicit IRPosition(Value &AnchorVal, Kind PK) {
+  explicit IRPosition(Value &AnchorVal, Kind PK,
+                      const CallBaseContext *CBContext = nullptr)
+      : CBContext(CBContext) {
     switch (PK) {
     case IRPosition::IRP_INVALID:
       llvm_unreachable("Cannot create invalid IRP with an anchor value!");
       break;
     case IRPosition::IRP_FLOAT:
       // Special case for floating functions.
       if (isa<Function>(AnchorVal))
         Enc = {&AnchorVal, ENC_FLOATING_FUNCTION};
private:
   static constexpr int NumEncodingBits =
       PointerLikeTypeTraits<void *>::NumLowBitsAvailable;
   static_assert(NumEncodingBits >= 2, "At least two bits are required!");
 
   /// The pointer with the encoding bits.
   PointerIntPair<void *, NumEncodingBits, char> Enc;
   ///}
 
+  /// Call base context. Used for callsite specific analysis.
+  const CallBaseContext *CBContext = nullptr;
+
   /// Return the encoding bits.
   char getEncodingBits() const { return Enc.getInt(); }
 };
 
 /// Helper that allows IRPosition as a key in a DenseMap.
-template <> struct DenseMapInfo<IRPosition> : DenseMapInfo<void *> {
+template <> struct DenseMapInfo<IRPosition> {
   static inline IRPosition getEmptyKey() { return IRPosition::EmptyKey; }
   static inline IRPosition getTombstoneKey() {
     return IRPosition::TombstoneKey;
   }
+  static unsigned getHashValue(const IRPosition &IRP) {
+    return (DenseMapInfo<void *>::getHashValue(IRP) << 4) ^
+           (DenseMapInfo<Value *>::getHashValue(IRP.getCallBaseContext()));
+  }
+
+  static bool isEqual(const IRPosition &a, const IRPosition &b) {
+    return a == b;
+  }
 };
 
 /// A visitor class for IR positions.
 ///
 /// Given a position P, the SubsumingPositionIterator allows to visit "subsuming
 /// positions" wrt. attributes/information. Thus, if a piece of information
 /// holds for a subsuming position, it also holds for the position P.
 ///
struct Attributor {
   template <typename AAType>
   const AAType &getAndUpdateAAFor(const AbstractAttribute &QueryingAA,
                                   const IRPosition &IRP,
                                   bool TrackDependence = true,
                                   DepClassTy DepClass = DepClassTy::REQUIRED) {
     return getOrCreateAAFor<AAType>(IRP, &QueryingAA, TrackDependence, DepClass,
                                     /* ForceUpdate */ true);
   }
 
   /// The version of getAAFor that allows to omit a querying abstract
   /// attribute. Using this after Attributor started running is restricted to
   /// only the Attributor itself. Initial seeding of AAs can be done via this
   /// function.
   template <typename AAType>
-  const AAType &getOrCreateAAFor(const IRPosition &IRP,
+  const AAType &getOrCreateAAFor(IRPosition IRP,
                                  const AbstractAttribute *QueryingAA = nullptr,
                                  bool TrackDependence = false,
                                  DepClassTy DepClass = DepClassTy::OPTIONAL,
                                  bool ForceUpdate = false) {
+#ifdef EXPENSIVE_CHECKS
+    // Don't allow callbase information to leak.
+    if (auto CBContext = IRP.getCallBaseContext()) {
+      assert(
+          ((CBContext->getCalledFunction() == IRP.getAnchorScope() ||
+            QueryingAA ||
+            !QueryingAA.getIRPosition().isAnyCallSitePosition())) &&
+          "non callsite positions are not allowed to propagate CallBaseContext "
+          "across functions");
+    }
+#endif
+    if (!shouldPropagateCallBaseContext(IRP))
+      IRP = IRP.stripCallBaseContext();
+
     if (AAType *AAPtr = lookupAAFor<AAType>(IRP, QueryingAA, TrackDependence)) {
       if (ForceUpdate)
         updateAA(*AAPtr);
       return *AAPtr;
     }
 
     // No matching attribute found, create one.
     // Use the static create method.
     auto &AA = AAType::createForPosition(IRP, *this);
 
     // If we are currenty seeding attributes, enforce seeding rules.
     if (SeedingPeriod && !shouldSeedAttribute(AA)) {
       AA.getState().indicatePessimisticFixpoint();
       return AA;
     }
 
     registerAA(AA);
 
     // 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);
#endif
 
     SeedingPeriod = OldSeedingPeriod;
 
     if (TrackDependence && AA.getState().isValidState())
       recordDependence(AA, const_cast<AbstractAttribute &>(*QueryingAA),
                        DepClass);
     return AA;
   }
 
   /// Return the attribute of \p AAType for \p IRP if existing. This also allows
   /// non-AA users lookup.
   template <typename AAType>
   AAType *lookupAAFor(const IRPosition &IRP,
                       const AbstractAttribute *QueryingAA = nullptr,
                       bool TrackDependence = false,
                       DepClassTy DepClass = DepClassTy::OPTIONAL) {
     static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
private:
   /// all call sites are known, hence the function has internal linkage.
   /// If true is returned, \p AllCallSitesKnown 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,
                             const AbstractAttribute *QueryingAA,
                             bool &AllCallSitesKnown);
 
+  /// Determine if CallBase context in \p IRP should be propagated.
+  bool shouldPropagateCallBaseContext(const IRPosition &IRP);
+
   /// Apply all requested function signature rewrites
   /// (\see registerFunctionSignatureRewrite) and return Changed if the module
   /// was altered.
   ChangeStatus
   rewriteFunctionSignatures(SmallPtrSetImpl<Function *> &ModifiedFns);
 
   /// Check if the Attribute \p AA should be seeded.
   /// See getOrCreateAAFor.

llvm/lib/Transforms/IPO/Attributor.cpp

 
 static cl::opt<bool>
     AllowShallowWrappers("attributor-allow-shallow-wrappers", cl::Hidden,
                          cl::desc("Allow the Attributor to create shallow "
                                   "wrappers for non-exact definitions."),
                          cl::init(false));
 
 static cl::list<std::string>
     SeedAllowList("attributor-seed-allow-list", cl::Hidden,
                   cl::desc("Comma seperated list of attrbute names that are "
                            "allowed to be seeded."),
                   cl::ZeroOrMore, cl::CommaSeparated);
 
+static cl::opt<bool> EnableCallSiteSpecific(
+    "attributor-enable-call-site-specific-deduction", cl::Hidden,
+    cl::desc("Allow the Attributor to do call site specific analysis"),
+    cl::init(false));
+
 /// Logic operators for the change status enum class.
 ///
 ///{
 ChangeStatus llvm::operator|(ChangeStatus l, ChangeStatus r) {
   return l == ChangeStatus::CHANGED ? l : r;
 }
 ChangeStatus llvm::operator&(ChangeStatus l, ChangeStatus r) {
   return l == ChangeStatus::UNCHANGED ? l : r;
if (Explorer.findInContextOf(It.first, EIt, EEnd))
       Attrs.push_back(Attribute::get(Ctx, AK, It.second.Max));
   return AttrsSize != Attrs.size();
 }
 
 void IRPosition::verify() {
 #ifdef EXPENSIVE_CHECKS
   switch (getPositionKind()) {
   case IRP_INVALID:
+    assert((CBContext == nullptr) &&
+           "Invalid position must not have CallBaseContext!");
     assert(!Enc.getOpaqueValue() &&
            "Expected a nullptr for an invalid position!");
     return;
   case IRP_FLOAT:
     assert((!isa<CallBase>(&getAssociatedValue()) &&
             !isa<Argument>(&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:
+    assert((CBContext == nullptr) &&
+           "'call site returned' position must not have CallBaseContext!");
     assert((isa<CallBase>(getAsValuePtr())) &&
            "Expected call base for 'call site returned' position!");
     assert(getAsValuePtr() == &getAssociatedValue() &&
            "Associated value mismatch!");
     return;
   case IRP_CALL_SITE:
+    assert((CBContext == nullptr) &&
+           "'call site function' position must not have CallBaseContext!");
     assert((isa<CallBase>(getAsValuePtr())) &&
            "Expected call base for 'call site 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: {
+    assert((CBContext == nullptr) &&
+           "'call site argument' position must not have CallBaseContext!");
     Use *U = getAsUsePtr();
     assert(U && "Expected use for a 'call site argument' position!");
     assert(isa<CallBase>(U->getUser()) &&
            "Expected call base user for a 'call site argument' position!");
     assert(cast<CallBase>(U->getUser())->isArgOperand(U) &&
            "Expected call base argument operand for a 'call site argument' "
            "position");
     assert(cast<CallBase>(U->getUser())->getArgOperandNo(U) ==
for (unsigned u = 0; u < Uses.size(); ++u) {
     LLVM_DEBUG(dbgs() << "[Attributor] Call site callback failed for "
                       << *ACS.getInstruction() << "\n");
     return false;
   }
 
   return true;
 }
 
+bool Attributor::shouldPropagateCallBaseContext(const IRPosition &IRP) {
+  // TODO: Maintain a cache of Values that are
+  // on the pathway from a Argument to a Instruction that would effect the
+  // liveness/return state etc.
+  return EnableCallSiteSpecific;
+}
+
 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();
for (AbstractAttribute *AA : AllAbstractAttributes) {
 
     // If there is not already a fixpoint reached, we can now take the
     // optimistic state. This is correct because we enforced a pessimistic one
     // on abstract attributes that were transitively dependent on a changed one
     // already above.
     if (!State.isAtFixpoint())
       State.indicateOptimisticFixpoint();
 
+    // We must not manifest Attributes that use Callbase info.
+    if (AA->hasCallBaseContext())
+      continue;
     // If the state is invalid, we do not try to manifest it.
     if (!State.isValidState())
       continue;
 
     // Skip dead code.
     if (isAssumedDead(*AA, nullptr, /* CheckBBLivenessOnly */ true))
       continue;
     // Manifest the state and record if we changed the IR.
raw_ostream &llvm::operator<<(raw_ostream &OS, IRPosition::Kind AP) {
   case IRPosition::IRP_CALL_SITE_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() << " ["
-            << Pos.getAnchorValue().getName() << "@" << Pos.getArgNo() << "]}";
+  OS << "{" << Pos.getPositionKind() << ":" << AV.getName() << " ["
+     << Pos.getAnchorValue().getName() << "@" << Pos.getArgNo() << "]";
+
+  if (Pos.hasCallBaseContext())
+    OS << "[cb_context:" << *Pos.getCallBaseContext() << "]";
+  return OS << "}";
 }
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const IntegerRangeState &S) {
   OS << "range-state(" << S.getBitWidth() << ")<";
   S.getKnown().print(OS);
   OS << " / ";
   S.getAssumed().print(OS);
   OS << ">";

llvm/unittests/Transforms/IPO/AttributorTest.cpp

 #include "llvm/Support/Allocator.h"
 #include "llvm/Testing/Support/Error.h"
 #include "llvm/Transforms/Utils/CallGraphUpdater.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 namespace llvm {
 
+TEST_F(AttributorTestBase, IRPPositionCallBaseContext) {
+  const char *ModuleString = R"(
+    define i32 @foo(i32 %a) {
+    entry:
+      ret i32 %a
+    }
+  )";
+
+  parseModule(ModuleString);
+
+  Function *F = M->getFunction("foo");
+  IRPosition Pos = IRPosition::function(*F, (const llvm::CallBase *)0xDEADBEEF);
+  EXPECT_TRUE(Pos.hasCallBaseContext());
+  EXPECT_FALSE(Pos.stripCallBaseContext().hasCallBaseContext());
+}
+
 TEST_F(AttributorTestBase, TestCast) {
   const char *ModuleString = R"(
     define i32 @foo(i32 %a, i32 %b) {
     entry:
       %c = add i32 %a, %b
       ret i32 %c
     }
   )";
TEST_F(AttributorTestBase, TestCast) {
   const auto *SFail = dyn_cast<AAAlign>(AA);
   const auto *SSucc = dyn_cast<AAIsDead>(AA);
 
   ASSERT_EQ(SFail, nullptr);
   ASSERT_TRUE(SSucc);
 }
 
 } // namespace llvm
 No newline at end of file