diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h
--- a/llvm/include/llvm/Transforms/IPO/Attributor.h
+++ b/llvm/include/llvm/Transforms/IPO/Attributor.h
@@ -1408,6 +1408,10 @@
                             const AbstractAttribute *QueryingAA,
                             bool &AllCallSitesKnown);
 
+  /// for function \p Fn Populate the cache for values that the call base
+  /// context is going to get propagated to.
+  void populateArgumentPathwayForFunction(Function *Fn);
+
   /// Determine if CallBase context in \p IRP should be propagated.
   bool shouldPropagateCallBaseContext(const IRPosition &IRP);
 
@@ -1497,6 +1501,9 @@
   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.
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -90,6 +90,13 @@
     cl::desc("Allow the Attributor to do call site specific analysis"),
     cl::init(false));
 
+static cl::opt<unsigned>
+    CallSiteSpecificDepth("attributor-call-site-specifc-deduction-depth",
+                          cl::Hidden,
+                          cl::desc("Maximum depth of values that call site "
+                                   "specific analysis context will reach."),
+                          cl::init(6));
+
 /// Logic operators for the change status enum class.
 ///
 ///{
@@ -798,11 +805,94 @@
   return true;
 }
 
+void Attributor::populateArgumentPathwayForFunction(Function *Fn) {
+  /// 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.
+  assert(Fn != nullptr && "There must be a function!");
+
+  SmallVector<Value *, 32> SuccsessfullValues;
+  SmallVector<Value *, 32> Worklist(
+      pointer_iterator<Argument *>(Fn->arg_begin()),
+      pointer_iterator<Argument *>(Fn->arg_end()));
+  SmallPtrSet<Value *, 32> ForwardsVisited;
+
+  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: " << *Fn
+                    << "\n");
+  for (SmallPtrSet<Value *, 32>::iterator it = ForwardsVisited.begin();
+       it != ForwardsVisited.end(); it++) {
+    LLVM_DEBUG(dbgs() << "[Attributor]" << **it << " is in Argument Pathway."
+                      << "\n");
+  }
+  ArgumentPathway[Fn] = 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 *Fn = IRP.getAssociatedFunction();
+  if (!Fn)
+    return false;
+
+  // Look up the value to see if it is one of the values that will recieve
+  // call base context.
+  auto ArgPathwayIt = ArgumentPathway.find(Fn);
+  if (ArgPathwayIt == ArgumentPathway.end()) {
+    // No cached information, create the `patway`.
+    populateArgumentPathwayForFunction(Fn);
+    ArgPathwayIt = ArgumentPathway.find(Fn);
+  }
+
+  return ((*ArgPathwayIt).second).count(&IRP.getAnchorValue());
 }
 
 bool Attributor::checkForAllReturnedValuesAndReturnInsts(