[Attributor]Introduce call base context argument pathway.

[kuter]

Summary

This patch puts a constraint on the attributes that will receive call base context.

[jdoerfert]

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

1416

Nit: For better or worse we use F and Fn as a variable name for functions usually.

I read the comment and do not know what happens. We need to improve the wording, maybe elaborate.

llvm/lib/Transforms/IPO/Attributor.cpp

96

I'm confused by the description. Is the analysis invaliding values?

807

Nit: Assertions always with messages.

---

Can we have a explanation here or in the header what is happening here. The commit message should also contain more details.

815

Style: No braces. Use a range loop or part of the constructor (or use append).

[kuter]

fix wording. use pointer_iterator instead of for loop.
fix naming.

[kuter]

llvm/lib/Transforms/IPO/Attributor.cpp

815

That was my initial idea but since arg_begin() is a pointer the SmallVector was trying to converyt Argument to Value*. After investigating I found that there is something called pointer_iterator that would fix this issue.

[kuter]

add unit test.
fix bug (😄)
fix typo.

[kuter]

remove unused header.

[kuter]

llvm/unittests/Transforms/IPO/AttributorTestBase.h

53 ↗

(On Diff #281191)

contents BumpPtrAllocator will be freed after this block is dead.
This causes a use after free.

[jdoerfert]

llvm/unittests/Transforms/IPO/AttributorTestBase.h

53 ↗

(On Diff #281191)

Put the allocator in the same scope as the Attributor?

[kuter]

llvm/unittests/Transforms/IPO/AttributorTestBase.h

53 ↗

(On Diff #281191)

That's what I am planing to do. I just wanted to add a inline commend so I don't forget about this issue.

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

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);
 
+  /// Efficiently compute the intersections between Values that can be
+  /// reached forwards from the arguments and the Values that can be
+  /// reached backwards from the instructions that would benefit.
+  /// from call site specific information.
+  void populateArgumentPathwayForFunction(Function *Funct);
+
   /// 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);
private:
 
   /// Functions, blocks, and instructions we delete after manifest is done.
   ///
   ///{
   SmallPtrSet<Function *, 8> ToBeDeletedFunctions;
   SmallPtrSet<BasicBlock *, 8> ToBeDeletedBlocks;
   SmallDenseSet<WeakVH, 8> ToBeDeletedInsts;
   ///}
+
+  /// Values per function that are relevant to the call base context.
+  DenseMap<Function *, SmallPtrSet<Value *, 32>> ArgumentPathway;
 };
 
 /// An interface to query the internal state of an abstract attribute.
 ///
 /// The abstract state is a minimal interface that allows the Attributor to
 /// communicate with the abstract attributes about their internal state without
 /// enforcing or exposing implementation details, e.g., the (existence of an)
 /// underlying lattice.

llvm/lib/Transforms/IPO/Attributor.cpp

SeedAllowList("attributor-seed-allow-list", cl::Hidden,
                            "allowed to be seeded."),
                   cl::ZeroOrMore, cl::CommaSeparated);
 
 static cl::opt<bool> EnableCallSiteSpecific(
     "attributor-enable-call-site-specific", cl::Hidden,
     cl::desc("Allow the Attributor to do call site specific analysis"),
     cl::init(false));
 
+static cl::opt<unsigned>
+    CallSiteSpecificDepth("attributor-call-site-depth", cl::Hidden,
+                          cl::desc("Maximum depth of values that call site "
+                                   "specific analysis will invalidate."),
+                          cl::init(6));
+
 /// 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;
for (unsigned u = 0; u < Uses.size(); ++u) {
     LLVM_DEBUG(dbgs() << "[Attributor] Call site callback failed for "
                       << *ACS.getInstruction() << "\n");
     return false;
   }
 
   return true;
 }
 
+void Attributor::populateArgumentPathwayForFunction(Function *Funct) {
+  assert(Funct != nullptr);
+
+  SmallVector<Value *, 32> SuccsessfullValues;
+  SmallVector<Value *, 32> Worklist;
+  SmallPtrSet<Value *, 32> ForwardsVisited;
+
+  for (Argument *V = Funct->arg_begin(); V != Funct->arg_end(); V++) {
+    Worklist.push_back(V);
+  }
+
+  for (unsigned I = 0; I < CallSiteSpecificDepth && !Worklist.empty(); I++) {
+    Value *Val = Worklist.pop_back_val();
+
+    // Avoid infinite loops.
+    if (!ForwardsVisited.insert(Val).second)
+      continue;
+
+    if (auto *Instr = dyn_cast<Instruction>(Val)) {
+      // Keep track of important instructions.
+      if (Instr->isTerminator())
+        SuccsessfullValues.push_back(Instr);
+    }
+
+    for (User *U : Val->users())
+      Worklist.push_back(U);
+  }
+
+  Worklist.assign(SuccsessfullValues.begin(), SuccsessfullValues.end());
+
+  SmallSet<Value *, 32> BackwardsVisited;
+  for (unsigned I = 0; I < CallSiteSpecificDepth && !Worklist.empty(); I++) {
+    Value *Val = Worklist.pop_back_val();
+
+    // Avoid infinite loops.
+    if (!BackwardsVisited.insert(Val).second)
+      continue;
+
+    for (Use &U : Val->uses()) {
+      // Avoid visiting nodes that can not be reached by the arguments.
+      // this creates the intersection.
+      if (ForwardsVisited.count((Value *)U))
+        continue;
+      Worklist.push_back((Value *)U);
+    }
+  }
+
+  LLVM_DEBUG(dbgs() << "[Attributor] Argument pathway for function: " << *Funct
+                    << "\n");
+  for (SmallPtrSet<Value *, 32>::iterator it = ForwardsVisited.begin();
+       it != ForwardsVisited.end(); it++) {
+    LLVM_DEBUG(dbgs() << "[Attributor]" << **it << " is in Argument Pathway."
+                      << "\n");
+  }
+  ArgumentPathway[Funct] = std::move(ForwardsVisited);
+}
+
 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;
+  if (!EnableCallSiteSpecific)
+    return false;
+
+  // Certain positions must always propogate call base context.
+  switch (IRP.getPositionKind()) {
+  case IRPosition::IRP_RETURNED:
+  case IRPosition::IRP_ARGUMENT:
+  case IRPosition::IRP_FUNCTION:
+    return true;
+  case IRPosition::IRP_FLOAT:
+    break;
+  default:
+    return false;
+  }
+  Function *Func = IRP.getAssociatedFunction();
+  if (!Func)
+    return false;
+
+  auto ArgPathwayIt = ArgumentPathway.find(Func);
+  if (ArgPathwayIt == ArgumentPathway.end()) {
+    populateArgumentPathwayForFunction(Func);
+    ArgPathwayIt = ArgumentPathway.find(Func);
+  }
+
+  return ((*ArgPathwayIt).second).count(&IRP.getAnchorValue());
 }
 
 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