[Attributor][NFCI] Avoid duplication of the InformationCache reference

[jdoerfert]

Summary

Instead of storing the reference to the InformationCache we now pass it
whenever it might be needed.

[uenoku]

LGTM

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

struct Attributor {
   ~Attributor() { DeleteContainerPointers(AllAbstractAttributes); }
 
   /// Run the analyses until a fixpoint is reached or enforced (timeout).
   ///
   /// The attributes registered with this Attributor can be used after as long
   /// as the Attributor is not destroyed (it owns the attributes now).
   ///
   /// \Returns CHANGED if the IR was changed, otherwise UNCHANGED.
-  ChangeStatus run();
+  ChangeStatus run(InformationCache &InfoCache);
 
   /// Lookup an abstract attribute of type \p AAType anchored at value \p V and
   /// argument number \p ArgNo. If no attribute is found and \p V is a call base
   /// instruction, the called function is tried as a value next. Thus, the
   /// returned abstract attribute might be anchored at the callee of \p V.
   ///
   /// This method is the only (supported) way an abstract attribute can retrieve
   /// information from another abstract attribute. As an example, take an
enum ManifestPosition {
     MP_RETURNED,           ///< An attribute for the function return value.
   };
 
   /// An abstract attribute associated with \p AssociatedVal and anchored at
   /// \p AnchoredVal.
   ///
   /// \param AssociatedVal The value this abstract attribute is associated with.
   /// \param AnchoredVal The value this abstract attributes is anchored at.
-  /// \param InfoCache Cached information accessible to the abstract attribute.
-  AbstractAttribute(Value *AssociatedVal, Value &AnchoredVal,
-                    InformationCache &InfoCache)
-      : AssociatedVal(AssociatedVal), AnchoredVal(AnchoredVal),
-        InfoCache(InfoCache) {}
+  AbstractAttribute(Value *AssociatedVal, Value &AnchoredVal)
+      : AssociatedVal(AssociatedVal), AnchoredVal(AnchoredVal) {}
 
   /// An abstract attribute associated with and anchored at \p V.
-  AbstractAttribute(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(&V, V, InfoCache) {}
+  AbstractAttribute(Value &V) : AbstractAttribute(&V, V) {}
 
   /// Virtual destructor.
   virtual ~AbstractAttribute() {}
 
   /// Initialize the state with the information in the Attributor \p A.
   ///
   /// This function is called by the Attributor once all abstract attributes
   /// have been identified. It can and shall be used for task like:
   ///  - identify existing knowledge in the IR and use it for the "known state"
   ///  - perform any work that is not going to change over time, e.g., determine
   ///    a subset of the IR, or attributes in-flight, that have to be looked at
   ///    in the `updateImpl` method.
-  virtual void initialize(Attributor &A) {}
+  virtual void initialize(Attributor &A, InformationCache &InfoCache) {}
 
   /// Return the internal abstract state for inspection.
   virtual const AbstractState &getState() const = 0;
 
   /// Return the value this abstract attribute is anchored with.
   ///
   /// The anchored value might not be the associated value if the latter is not
   /// sufficient to determine where arguments will be manifested. This is mostly

 
 protected:
   /// Hook for the Attributor to trigger an update of the internal state.
   ///
   /// If this attribute is already fixed, this method will return UNCHANGED,
   /// otherwise it delegates to `AbstractAttribute::updateImpl`.
   ///
   /// \Return CHANGED if the internal state changed, otherwise UNCHANGED.
-  ChangeStatus update(Attributor &A);
+  ChangeStatus update(Attributor &A, InformationCache &InfoCache);
 
   /// Hook for the Attributor to trigger the manifestation of the information
   /// represented by the abstract attribute in the LLVM-IR.
   ///
   /// \Return CHANGED if the IR was altered, otherwise UNCHANGED.
   virtual ChangeStatus manifest(Attributor &A);
 
   /// Return the internal abstract state for careful modification.
   virtual AbstractState &getState() = 0;
 
   /// The actual update/transfer function which has to be implemented by the
   /// derived classes.
   ///
   /// If it is called, the environment has changed and we have to determine if
   /// the current information is still valid or adjust it otherwise.
   ///
   /// \Return CHANGED if the internal state changed, otherwise UNCHANGED.
-  virtual ChangeStatus updateImpl(Attributor &A) = 0;
+  virtual ChangeStatus updateImpl(Attributor &A,
+                                  InformationCache &InfoCache) = 0;
 
   /// The value this abstract attribute is associated with.
   Value *AssociatedVal;
 
   /// The value this abstract attribute is anchored at.
   Value &AnchoredVal;
-
-  /// The information cache accessible to this abstract attribute.
-  InformationCache &InfoCache;
 };
 
 /// Forward declarations of output streams for debug purposes.
 ///
 ///{
 raw_ostream &operator<<(raw_ostream &OS, const AbstractAttribute &AA);
 raw_ostream &operator<<(raw_ostream &OS, ChangeStatus S);
 raw_ostream &operator<<(raw_ostream &OS, AbstractAttribute::ManifestPosition);
 raw_ostream &operator<<(raw_ostream &OS, const AbstractState &State);
 ///}
 
 struct AttributorPass : public PassInfoMixin<AttributorPass> {
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 
 Pass *createAttributorLegacyPass();
 
 /// ----------------------------------------------------------------------------
 ///                       Abstract Attribute Classes
 /// ----------------------------------------------------------------------------
 
 /// An abstract attribute for the returned values of a function.
 struct AAReturnedValues : public AbstractAttribute {
   /// See AbstractAttribute::AbstractAttribute(...).
-  AAReturnedValues(Function &F, InformationCache &InfoCache)
-      : AbstractAttribute(F, InfoCache) {}
+  AAReturnedValues(Function &F) : AbstractAttribute(F) {}
 
   /// Check \p Pred on all returned values.
   ///
   /// This method will evaluate \p Pred on returned values and return
   /// true if (1) all returned values are known, and (2) \p Pred returned true
   /// for all returned values.
   virtual bool checkForallReturnedValues(
       std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> &Pred)
       const = 0;
 
   /// See AbstractAttribute::getAttrKind()
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::Returned;
 };
 
 struct AANoUnwind : public AbstractAttribute {
   /// An abstract interface for all nosync attributes.
-  AANoUnwind(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AANoUnwind(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::getAttrKind()/
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   static constexpr Attribute::AttrKind ID = Attribute::NoUnwind;
 
   /// Returns true if nounwind is assumed.
   virtual bool isAssumedNoUnwind() const = 0;
 
   /// Returns true if nounwind is known.
   virtual bool isKnownNoUnwind() const = 0;
 };
 
 struct AANoSync : public AbstractAttribute {
   /// An abstract interface for all nosync attributes.
-  AANoSync(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AANoSync(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::getAttrKind().
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   static constexpr Attribute::AttrKind ID =
       Attribute::AttrKind(Attribute::NoSync);
 
   /// Returns true if "nosync" is assumed.
   virtual bool isAssumedNoSync() const = 0;
 
   /// Returns true if "nosync" is known.
   virtual bool isKnownNoSync() const = 0;
 };
 
 /// An abstract interface for all nonnull attributes.
 struct AANonNull : public AbstractAttribute {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AANonNull(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AANonNull(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AANonNull(Value *AssociatedVal, Value &AnchoredValue,
-            InformationCache &InfoCache)
-      : AbstractAttribute(AssociatedVal, AnchoredValue, InfoCache) {}
+  AANonNull(Value *AssociatedVal, Value &AnchoredValue)
+      : AbstractAttribute(AssociatedVal, AnchoredValue) {}
 
   /// Return true if we assume that the underlying value is nonnull.
   virtual bool isAssumedNonNull() const = 0;
 
   /// Return true if we know that underlying value is nonnull.
   virtual bool isKnownNonNull() const = 0;
 
   /// See AbastractState::getAttrKind().
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::NonNull;
 };
 
 /// An abstract attribute for norecurse.
 struct AANoRecurse : public AbstractAttribute {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AANoRecurse(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AANoRecurse(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::getAttrKind()
   virtual Attribute::AttrKind getAttrKind() const override {
     return Attribute::NoRecurse;
   }
 
   /// Return true if "norecurse" is known.
   virtual bool isKnownNoRecurse() const = 0;
 
   /// Return true if "norecurse" is assumed.
   virtual bool isAssumedNoRecurse() const = 0;
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::NoRecurse;
 };
 
 /// An abstract attribute for willreturn.
 struct AAWillReturn : public AbstractAttribute {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AAWillReturn(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AAWillReturn(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::getAttrKind()
   virtual Attribute::AttrKind getAttrKind() const override {
     return Attribute::WillReturn;
   }
 
   /// Return true if "willreturn" is known.
   virtual bool isKnownWillReturn() const = 0;
 
   /// Return true if "willreturn" is assumed.
   virtual bool isAssumedWillReturn() const = 0;
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::WillReturn;
 };
 
 /// An abstract interface for all noalias attributes.
 struct AANoAlias : public AbstractAttribute {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AANoAlias(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AANoAlias(Value &V) : AbstractAttribute(V) {}
 
   /// Return true if we assume that the underlying value is alias.
   virtual bool isAssumedNoAlias() const = 0;
 
   /// Return true if we know that underlying value is noalias.
   virtual bool isKnownNoAlias() const = 0;
 
   /// See AbastractState::getAttrKind().
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::NoAlias;
 };
 
 /// An AbstractAttribute for noreturn.
 struct AANoReturn : public AbstractAttribute {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AANoReturn(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AANoReturn(Value &V) : AbstractAttribute(V) {}
 
   /// Return true if the underlying object is known to never return.
   virtual bool isKnownNoReturn() const = 0;
 
   /// Return true if the underlying object is assumed to never return.
   virtual bool isAssumedNoReturn() const = 0;
 
   /// See AbstractAttribute::getAttrKind()
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::NoReturn;
 };
 
 /// An abstract interface for liveness abstract attribute.
 struct AAIsDead : public AbstractAttribute {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AAIsDead(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AAIsDead(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::getAttrKind()
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   static constexpr Attribute::AttrKind ID =
       Attribute::AttrKind(Attribute::EndAttrKinds + 1);
 
   /// Returns true if \p BB is assumed dead.
template <typename T> bool isLiveInstSet(T begin, T end) const {
     return false;
   }
 };
 
 /// An abstract interface for all dereferenceable attribute.
 struct AADereferenceable : public AbstractAttribute {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AADereferenceable(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AADereferenceable(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AADereferenceable(Value *AssociatedVal, Value &AnchoredValue,
-                    InformationCache &InfoCache)
-      : AbstractAttribute(AssociatedVal, AnchoredValue, InfoCache) {}
+  AADereferenceable(Value *AssociatedVal, Value &AnchoredValue)
+      : AbstractAttribute(AssociatedVal, AnchoredValue) {}
 
   /// Return true if we assume that the underlying value is nonnull.
   virtual bool isAssumedNonNull() const = 0;
 
   /// Return true if we know that underlying value is nonnull.
   virtual bool isKnownNonNull() const = 0;
 
   /// Return true if we assume that underlying value is
struct AADereferenceable : public AbstractAttribute {
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::Dereferenceable;
 };
 
 /// An abstract interface for all align attributes.
 struct AAAlign : public AbstractAttribute {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AAAlign(Value &V, InformationCache &InfoCache)
-      : AbstractAttribute(V, InfoCache) {}
+  AAAlign(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AAAlign(Value *AssociatedVal, Value &AnchoredValue,
-          InformationCache &InfoCache)
-      : AbstractAttribute(AssociatedVal, AnchoredValue, InfoCache) {}
+  AAAlign(Value *AssociatedVal, Value &AnchoredValue)
+      : AbstractAttribute(AssociatedVal, AnchoredValue) {}
 
   /// See AbastractState::getAttrKind().
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   /// Return assumed alignment.
   virtual unsigned getAssumedAlign() const = 0;
 
   /// Return known alignemnt.

llvm/trunk/lib/Transforms/IPO/Attributor.cpp

if (Attr.isIntAttribute()) {
     Attrs = Attrs.removeAttribute(Ctx, AttrIdx, Kind);
     Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
     return true;
   }
 
   llvm_unreachable("Expected enum or string attribute!");
 }
 
-ChangeStatus AbstractAttribute::update(Attributor &A) {
+ChangeStatus AbstractAttribute::update(Attributor &A,
+                                       InformationCache &InfoCache) {
   ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
   if (getState().isAtFixpoint())
     return HasChanged;
 
   LLVM_DEBUG(dbgs() << "[Attributor] Update: " << *this << "\n");
 
-  HasChanged = updateImpl(A);
+  HasChanged = updateImpl(A, InfoCache);
 
   LLVM_DEBUG(dbgs() << "[Attributor] Update " << HasChanged << " " << *this
                     << "\n");
 
   return HasChanged;
 }
 
 ChangeStatus AbstractAttribute::manifest(Attributor &A) {
if (auto *Arg = dyn_cast<Argument>(&V))
     return Arg->getArgNo();
   return -1;
 }
 
 /// -----------------------NoUnwind Function Attribute--------------------------
 
 struct AANoUnwindFunction : AANoUnwind, BooleanState {
 
-  AANoUnwindFunction(Function &F, InformationCache &InfoCache)
-      : AANoUnwind(F, InfoCache) {}
+  AANoUnwindFunction(Function &F) : AANoUnwind(F) {}
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_FUNCTION; }
 
   const std::string getAsStr() const override {
     return getAssumed() ? "nounwind" : "may-unwind";
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AANoUnwind::isAssumedNoUnwind().
   bool isAssumedNoUnwind() const override { return getAssumed(); }
 
   /// See AANoUnwind::isKnownNoUnwind().
   bool isKnownNoUnwind() const override { return getKnown(); }
 };
 
-ChangeStatus AANoUnwindFunction::updateImpl(Attributor &A) {
+ChangeStatus AANoUnwindFunction::updateImpl(Attributor &A,
+                                            InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
   // The map from instruction opcodes to those instructions in the function.
   auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
   auto Opcodes = {
       (unsigned)Instruction::Invoke,      (unsigned)Instruction::CallBr,
       (unsigned)Instruction::Call,        (unsigned)Instruction::CleanupRet,
       (unsigned)Instruction::CatchSwitch, (unsigned)Instruction::Resume};
void collectValuesRecursively(
     // Consequently, we cannot know if the information we would derive is
     // accurate so we give up early.
     if (!Success)
       indicatePessimisticFixpoint();
   }
 
 public:
   /// See AbstractAttribute::AbstractAttribute(...).
-  AAReturnedValuesImpl(Function &F, InformationCache &InfoCache)
-      : AAReturnedValues(F, InfoCache) {
+  AAReturnedValuesImpl(Function &F) : AAReturnedValues(F) {
     // We do not have an associated argument yet.
     AssociatedVal = nullptr;
   }
 
   /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     // Reset the state.
     AssociatedVal = nullptr;
     IsFixed = false;
     IsValidState = true;
     HasOverdefinedReturnedCalls = false;
     ReturnedValues.clear();
 
     Function &F = cast<Function>(getAnchoredValue());
public:
 
   /// See AbstractAttribute::getState(...).
   const AbstractState &getState() const override { return *this; }
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_ARGUMENT; }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 
   /// Return the number of potential return values, -1 if unknown.
   size_t getNumReturnValues() const {
     return isValidState() ? ReturnedValues.size() : -1;
   }
 
   /// Return an assumed unique return value if a single candidate is found. If
   /// there cannot be one, return a nullptr. If it is not clear yet, return the
for (auto &It : ReturnedValues) {
 
     if (!Pred(*RV, RetInsts))
       return false;
   }
 
   return true;
 }
 
-ChangeStatus AAReturnedValuesImpl::updateImpl(Attributor &A) {
+ChangeStatus AAReturnedValuesImpl::updateImpl(Attributor &A,
+                                              InformationCache &InfoCache) {
 
   // Check if we know of any values returned by the associated function,
   // if not, we are done.
   if (getNumReturnValues() == 0) {
     indicateOptimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
ChangeStatus AAReturnedValuesImpl::updateImpl(Attributor &A,
 
   return Changed;
 }
 
 /// ------------------------ NoSync Function Attribute -------------------------
 
 struct AANoSyncFunction : AANoSync, BooleanState {
 
-  AANoSyncFunction(Function &F, InformationCache &InfoCache)
-      : AANoSync(F, InfoCache) {}
+  AANoSyncFunction(Function &F) : AANoSync(F) {}
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_FUNCTION; }
 
   const std::string getAsStr() const override {
     return getAssumed() ? "nosync" : "may-sync";
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AANoSync::isAssumedNoSync()
   bool isAssumedNoSync() const override { return getAssumed(); }
 
   /// See AANoSync::isKnownNoSync()
   bool isKnownNoSync() const override { return getKnown(); }
 
   /// Helper function used to determine whether an instruction is non-relaxed
case Instruction::Load:
     return cast<LoadInst>(I)->isVolatile();
   case Instruction::AtomicCmpXchg:
     return cast<AtomicCmpXchgInst>(I)->isVolatile();
   default:
     return false;
   }
 }
 
-ChangeStatus AANoSyncFunction::updateImpl(Attributor &A) {
+ChangeStatus AANoSyncFunction::updateImpl(Attributor &A,
+                                          InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
   auto *LivenessAA = A.getAAFor<AAIsDead>(*this, F);
 
   /// We are looking for volatile instructions or Non-Relaxed atomics.
   /// FIXME: We should ipmrove the handling of intrinsics.
   for (Instruction *I : InfoCache.getReadOrWriteInstsForFunction(F)) {
     // Skip assumed dead instructions.
ChangeStatus AANoSyncFunction::updateImpl(Attributor &A,
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ No-Free Attributes ----------------------------
 
 struct AANoFreeFunction : AbstractAttribute, BooleanState {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AANoFreeFunction(Function &F, InformationCache &InfoCache)
-      : AbstractAttribute(F, InfoCache) {}
+  AANoFreeFunction(Function &F) : AbstractAttribute(F) {}
 
   /// See AbstractAttribute::getState()
   ///{
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   ///}
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_FUNCTION; }
 
   /// See AbstractAttribute::getAsStr().
   const std::string getAsStr() const override {
     return getAssumed() ? "nofree" : "may-free";
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AbstractAttribute::getAttrKind().
   Attribute::AttrKind getAttrKind() const override { return ID; }
 
   /// Return true if "nofree" is assumed.
   bool isAssumedNoFree() const { return getAssumed(); }
 
   /// Return true if "nofree" is known.
   bool isKnownNoFree() const { return getKnown(); }
 
   /// The identifier used by the Attributor for this class of attributes.
   static constexpr Attribute::AttrKind ID = Attribute::NoFree;
 };
 
-ChangeStatus AANoFreeFunction::updateImpl(Attributor &A) {
+ChangeStatus AANoFreeFunction::updateImpl(Attributor &A,
+                                          InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
   auto *LivenessAA = A.getAAFor<AAIsDead>(*this, F);
 
   // The map from instruction opcodes to those instructions in the function.
   auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
 
   for (unsigned Opcode :
for (unsigned Opcode :
     }
   }
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ NonNull Argument Attribute ------------------------
 struct AANonNullImpl : AANonNull, BooleanState {
 
-  AANonNullImpl(Value &V, InformationCache &InfoCache)
-      : AANonNull(V, InfoCache) {}
+  AANonNullImpl(Value &V) : AANonNull(V) {}
 
-  AANonNullImpl(Value *AssociatedVal, Value &AnchoredValue,
-                InformationCache &InfoCache)
-      : AANonNull(AssociatedVal, AnchoredValue, InfoCache) {}
+  AANonNullImpl(Value *AssociatedVal, Value &AnchoredValue)
+      : AANonNull(AssociatedVal, AnchoredValue) {}
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AbstractAttribute::getAsStr().
AANonNullImpl::generatePredicate(Attributor &A) {
   };
 
   return Pred;
 }
 
 /// NonNull attribute for function return value.
 struct AANonNullReturned : AANonNullImpl {
 
-  AANonNullReturned(Function &F, InformationCache &InfoCache)
-      : AANonNullImpl(F, InfoCache) {}
+  AANonNullReturned(Function &F) : AANonNullImpl(F) {}
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_RETURNED; }
 
   /// See AbstractAttriubute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
 
     // Already nonnull.
     if (F.getAttributes().hasAttribute(AttributeList::ReturnIndex,
                                        Attribute::NonNull) ||
         F.getAttributes().hasAttribute(AttributeList::ReturnIndex,
                                        Attribute::Dereferenceable))
       indicateOptimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
-ChangeStatus AANonNullReturned::updateImpl(Attributor &A) {
+ChangeStatus AANonNullReturned::updateImpl(Attributor &A,
+                                           InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
   auto *AARetVal = A.getAAFor<AAReturnedValues>(*this, F);
   if (!AARetVal)
     return indicatePessimisticFixpoint();
 
   std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> Pred =
       this->generatePredicate(A);
 
   if (!AARetVal->checkForallReturnedValues(Pred))
     return indicatePessimisticFixpoint();
   return ChangeStatus::UNCHANGED;
 }
 
 /// NonNull attribute for function argument.
 struct AANonNullArgument : AANonNullImpl {
 
-  AANonNullArgument(Argument &A, InformationCache &InfoCache)
-      : AANonNullImpl(A, InfoCache) {}
+  AANonNullArgument(Argument &A) : AANonNullImpl(A) {}
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_ARGUMENT; }
 
   /// See AbstractAttriubute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     Argument *Arg = cast<Argument>(getAssociatedValue());
     if (Arg->hasNonNullAttr())
       indicateOptimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
 /// NonNull attribute for a call site argument.
 struct AANonNullCallSiteArgument : AANonNullImpl {
 
   /// See AANonNullImpl::AANonNullImpl(...).
-  AANonNullCallSiteArgument(CallSite CS, unsigned ArgNo,
-                            InformationCache &InfoCache)
-      : AANonNullImpl(CS.getArgOperand(ArgNo), *CS.getInstruction(), InfoCache),
+  AANonNullCallSiteArgument(CallSite CS, unsigned ArgNo)
+      : AANonNullImpl(CS.getArgOperand(ArgNo), *CS.getInstruction()),
         ArgNo(ArgNo) {}
 
   /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     CallSite CS(&getAnchoredValue());
     if (CS.paramHasAttr(ArgNo, getAttrKind()) ||
         CS.paramHasAttr(ArgNo, Attribute::Dereferenceable) ||
         isKnownNonZero(getAssociatedValue(),
                        getAnchorScope().getParent()->getDataLayout()))
       indicateOptimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override {
     return MP_CALL_SITE_ARGUMENT;
   };
 
   // Return argument index of associated value.
   int getArgNo() const { return ArgNo; }
 
 private:
   unsigned ArgNo;
 };
-ChangeStatus AANonNullArgument::updateImpl(Attributor &A) {
+
+ChangeStatus AANonNullArgument::updateImpl(Attributor &A,
+                                           InformationCache &InfoCache) {
   Function &F = getAnchorScope();
   Argument &Arg = cast<Argument>(getAnchoredValue());
 
   unsigned ArgNo = Arg.getArgNo();
 
   // Callback function
   std::function<bool(CallSite)> CallSiteCheck = [&](CallSite CS) {
     assert(CS && "Sanity check: Call site was not initialized properly!");
std::function<bool(CallSite)> CallSiteCheck = [&](CallSite CS) {
 
     return false;
   };
   if (!A.checkForAllCallSites(F, CallSiteCheck, true, *this))
     return indicatePessimisticFixpoint();
   return ChangeStatus::UNCHANGED;
 }
 
-ChangeStatus AANonNullCallSiteArgument::updateImpl(Attributor &A) {
+ChangeStatus
+AANonNullCallSiteArgument::updateImpl(Attributor &A,
+                                      InformationCache &InfoCache) {
   // NOTE: Never look at the argument of the callee in this method.
   //       If we do this, "nonnull" is always deduced because of the assumption.
 
   Value &V = *getAssociatedValue();
 
   auto *NonNullAA = A.getAAFor<AANonNull>(*this, V);
 
   if (!NonNullAA || !NonNullAA->isAssumedNonNull())
     return indicatePessimisticFixpoint();
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ Will-Return Attributes ----------------------------
 
 struct AAWillReturnImpl : public AAWillReturn, BooleanState {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AAWillReturnImpl(Function &F, InformationCache &InfoCache)
-      : AAWillReturn(F, InfoCache) {}
+  AAWillReturnImpl(Function &F) : AAWillReturn(F) {}
 
   /// See AAWillReturn::isKnownWillReturn().
   bool isKnownWillReturn() const override { return getKnown(); }
 
   /// See AAWillReturn::isAssumedWillReturn().
   bool isAssumedWillReturn() const override { return getAssumed(); }
 
   /// See AbstractAttribute::getState(...).
   AbstractState &getState() override { return *this; }
 
   /// See AbstractAttribute::getState(...).
   const AbstractState &getState() const override { return *this; }
 
   /// See AbstractAttribute::getAsStr()
   const std::string getAsStr() const override {
     return getAssumed() ? "willreturn" : "may-noreturn";
   }
 };
 
 struct AAWillReturnFunction final : AAWillReturnImpl {
 
   /// See AbstractAttribute::AbstractAttribute(...).
-  AAWillReturnFunction(Function &F, InformationCache &InfoCache)
-      : AAWillReturnImpl(F, InfoCache) {}
+  AAWillReturnFunction(Function &F) : AAWillReturnImpl(F) {}
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_FUNCTION; }
 
   /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override;
+  void initialize(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
 // Helper function that checks whether a function has any cycle.
 // TODO: Replace with more efficent code
 bool containsCycle(Function &F) {
   SmallPtrSet<BasicBlock *, 32> Visited;
 
   // Traverse BB by dfs and check whether successor is already visited.
   for (BasicBlock *BB : depth_first(&F)) {
     Visited.insert(BB);
     for (auto *SuccBB : successors(BB)) {
       if (Visited.count(SuccBB))
         return true;
     }
   }
   return false;
 }
 
 // Helper function that checks the function have a loop which might become an
 // endless loop
 // FIXME: Any cycle is regarded as endless loop for now.
 //        We have to allow some patterns.
 bool containsPossiblyEndlessLoop(Function &F) { return containsCycle(F); }
 
-void AAWillReturnFunction::initialize(Attributor &A) {
+void AAWillReturnFunction::initialize(Attributor &A,
+                                      InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
   if (containsPossiblyEndlessLoop(F))
     indicatePessimisticFixpoint();
 }
 
-ChangeStatus AAWillReturnFunction::updateImpl(Attributor &A) {
+ChangeStatus AAWillReturnFunction::updateImpl(Attributor &A,
+                                              InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
   // The map from instruction opcodes to those instructions in the function.
   auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
 
   auto *LivenessAA = A.getAAFor<AAIsDead>(*this, F);
 
   for (unsigned Opcode :
ChangeStatus AAWillReturnFunction::updateImpl(Attributor &A,
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ NoAlias Argument Attribute ------------------------
 
 struct AANoAliasImpl : AANoAlias, BooleanState {
 
-  AANoAliasImpl(Value &V, InformationCache &InfoCache)
-      : AANoAlias(V, InfoCache) {}
+  AANoAliasImpl(Value &V) : AANoAlias(V) {}
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   const std::string getAsStr() const override {
     return getAssumed() ? "noalias" : "may-alias";
   }
 
   /// See AANoAlias::isAssumedNoAlias().
   bool isAssumedNoAlias() const override { return getAssumed(); }
 
   /// See AANoAlias::isKnowndNoAlias().
   bool isKnownNoAlias() const override { return getKnown(); }
 };
 
 /// NoAlias attribute for function return value.
 struct AANoAliasReturned : AANoAliasImpl {
 
-  AANoAliasReturned(Function &F, InformationCache &InfoCache)
-      : AANoAliasImpl(F, InfoCache) {}
+  AANoAliasReturned(Function &F) : AANoAliasImpl(F) {}
 
   /// See AbstractAttribute::getManifestPosition().
   virtual ManifestPosition getManifestPosition() const override {
     return MP_RETURNED;
   }
 
   /// See AbstractAttriubute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
 
     // Already noalias.
     if (F.returnDoesNotAlias()) {
       indicateOptimisticFixpoint();
       return;
     }
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  virtual ChangeStatus updateImpl(Attributor &A) override;
+  virtual ChangeStatus updateImpl(Attributor &A,
+                                  InformationCache &InfoCache) override;
 };
 
-ChangeStatus AANoAliasReturned::updateImpl(Attributor &A) {
+ChangeStatus AANoAliasReturned::updateImpl(Attributor &A,
+                                           InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
   auto *AARetValImpl = A.getAAFor<AAReturnedValuesImpl>(*this, F);
   if (!AARetValImpl)
     return indicatePessimisticFixpoint();
 
   std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> Pred =
       [&](Value &RV, const SmallPtrSetImpl<ReturnInst *> &RetInsts) -> bool {
ChangeStatus AANoAliasReturned::updateImpl(Attributor &A,
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// -------------------AAIsDead Function Attribute-----------------------
 
 struct AAIsDeadFunction : AAIsDead, BooleanState {
 
-  AAIsDeadFunction(Function &F, InformationCache &InfoCache)
-      : AAIsDead(F, InfoCache) {}
+  AAIsDeadFunction(Function &F) : AAIsDead(F) {}
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_FUNCTION; }
 
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
 
     ToBeExploredPaths.insert(&(F.getEntryBlock().front()));
     AssumedLiveBlocks.insert(&(F.getEntryBlock()));
     for (size_t i = 0; i < ToBeExploredPaths.size(); ++i)
       if (const Instruction *NextNoReturnI =
               findNextNoReturn(A, ToBeExploredPaths[i]))
         NoReturnCalls.insert(NextNoReturnI);
for (const Instruction *NRC : NoReturnCalls) {
       changeToUnreachable(BB->getTerminator(), /* UseLLVMTrap */ false);
       HasChanged = ChangeStatus::CHANGED;
     }
 
     return HasChanged;
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AAIsDead::isAssumedDead(BasicBlock *).
   bool isAssumedDead(const BasicBlock *BB) const override {
     assert(BB->getParent() == &getAnchorScope() &&
            "BB must be in the same anchor scope function.");
 
     if (!getAssumed())
       return false;
for (const BasicBlock *SuccBB : successors(BB)) {
     AssumedLiveBlocks.insert(SuccBB);
     ToBeExploredPaths.insert(&SuccBB->front());
   }
 
   // No noreturn instruction found.
   return nullptr;
 }
 
-ChangeStatus AAIsDeadFunction::updateImpl(Attributor &A) {
+ChangeStatus AAIsDeadFunction::updateImpl(Attributor &A,
+                                          InformationCache &InfoCache) {
   // Temporary collection to iterate over existing noreturn instructions. This
   // will alow easier modification of NoReturnCalls collection
   SmallVector<const Instruction *, 8> NoReturnChanged;
   ChangeStatus Status = ChangeStatus::UNCHANGED;
 
   for (const Instruction *I : NoReturnCalls)
     NoReturnChanged.push_back(I);
 
struct DerefState : AbstractState {
   /// Equality for DerefState.
   bool operator==(const DerefState &R) {
     return this->DerefBytesState == R.DerefBytesState &&
            this->NonNullGlobalState == R.NonNullGlobalState;
   }
 };
 struct AADereferenceableImpl : AADereferenceable, DerefState {
 
-  AADereferenceableImpl(Value &V, InformationCache &InfoCache)
-      : AADereferenceable(V, InfoCache) {}
+  AADereferenceableImpl(Value &V) : AADereferenceable(V) {}
 
-  AADereferenceableImpl(Value *AssociatedVal, Value &AnchoredValue,
-                        InformationCache &InfoCache)
-      : AADereferenceable(AssociatedVal, AnchoredValue, InfoCache) {}
+  AADereferenceableImpl(Value *AssociatedVal, Value &AnchoredValue)
+      : AADereferenceable(AssociatedVal, AnchoredValue) {}
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AADereferenceable::getAssumedDereferenceableBytes().
if (isAssumedNonNull())
           Ctx, getAssumedDereferenceableBytes()));
     else
       Attrs.emplace_back(Attribute::getWithDereferenceableOrNullBytes(
           Ctx, getAssumedDereferenceableBytes()));
   }
   uint64_t computeAssumedDerefenceableBytes(Attributor &A, Value &V,
                                             bool &IsNonNull, bool &IsGlobal);
 
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
     unsigned AttrIdx =
         getAttrIndex(getManifestPosition(), getArgNo(getAnchoredValue()));
 
     for (Attribute::AttrKind AK :
          {Attribute::Dereferenceable, Attribute::DereferenceableOrNull})
       if (F.getAttributes().hasAttribute(AttrIdx, AK))
         takeKnownDerefBytesMaximum(F.getAttribute(AttrIdx, AK).getValueAsInt());
   }
 
   /// See AbstractAttribute::getAsStr().
   const std::string getAsStr() const override {
     if (!getAssumedDereferenceableBytes())
       return "unknown-dereferenceable";
     return std::string("dereferenceable") +
            (isAssumedNonNull() ? "" : "_or_null") +
            (isAssumedGlobal() ? "_globally" : "") + "<" +
            std::to_string(getKnownDereferenceableBytes()) + "-" +
            std::to_string(getAssumedDereferenceableBytes()) + ">";
   }
 };
 
 struct AADereferenceableReturned : AADereferenceableImpl {
-  AADereferenceableReturned(Function &F, InformationCache &InfoCache)
-      : AADereferenceableImpl(F, InfoCache) {}
+  AADereferenceableReturned(Function &F) : AADereferenceableImpl(F) {}
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_RETURNED; }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
 // Helper function that returns dereferenceable bytes.
 static uint64_t calcDifferenceIfBaseIsNonNull(int64_t DerefBytes,
                                               int64_t Offset, bool IsNonNull) {
   if (!IsNonNull)
     return 0;
   return std::max((int64_t)0, DerefBytes - Offset);
return calcDifferenceIfBaseIsNonNull(
         DL.getTypeStoreSize(Base->getType()->getPointerElementType()),
         Offset.getSExtValue(),
         !NullPointerIsDefined(&getAnchorScope(),
                               V.getType()->getPointerAddressSpace()));
 
   IsNonNull = false;
   return 0;
 }
-ChangeStatus AADereferenceableReturned::updateImpl(Attributor &A) {
+
+ChangeStatus
+AADereferenceableReturned::updateImpl(Attributor &A,
+                                      InformationCache &InfoCache) {
   Function &F = getAnchorScope();
   auto BeforeState = static_cast<DerefState>(*this);
 
   syncNonNull(A.getAAFor<AANonNull>(*this, F));
 
   auto *AARetVal = A.getAAFor<AAReturnedValues>(*this, F);
   if (!AARetVal)
     return indicatePessimisticFixpoint();
if (AARetVal->checkForallReturnedValues(Pred)) {
     return BeforeState == static_cast<DerefState>(*this)
                ? ChangeStatus::UNCHANGED
                : ChangeStatus::CHANGED;
   }
   return indicatePessimisticFixpoint();
 }
 
 struct AADereferenceableArgument : AADereferenceableImpl {
-  AADereferenceableArgument(Argument &A, InformationCache &InfoCache)
-      : AADereferenceableImpl(A, InfoCache) {}
+  AADereferenceableArgument(Argument &A) : AADereferenceableImpl(A) {}
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_ARGUMENT; }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
-ChangeStatus AADereferenceableArgument::updateImpl(Attributor &A) {
+ChangeStatus
+AADereferenceableArgument::updateImpl(Attributor &A,
+                                      InformationCache &InfoCache) {
   Function &F = getAnchorScope();
   Argument &Arg = cast<Argument>(getAnchoredValue());
 
   auto BeforeState = static_cast<DerefState>(*this);
 
   unsigned ArgNo = Arg.getArgNo();
 
   syncNonNull(A.getAAFor<AANonNull>(*this, F, ArgNo));
AADereferenceableArgument::updateImpl(Attributor &A,
   return BeforeState == static_cast<DerefState>(*this) ? ChangeStatus::UNCHANGED
                                                        : ChangeStatus::CHANGED;
 }
 
 /// Dereferenceable attribute for a call site argument.
 struct AADereferenceableCallSiteArgument : AADereferenceableImpl {
 
   /// See AADereferenceableImpl::AADereferenceableImpl(...).
-  AADereferenceableCallSiteArgument(CallSite CS, unsigned ArgNo,
-                                    InformationCache &InfoCache)
-      : AADereferenceableImpl(CS.getArgOperand(ArgNo), *CS.getInstruction(),
-                              InfoCache),
+  AADereferenceableCallSiteArgument(CallSite CS, unsigned ArgNo)
+      : AADereferenceableImpl(CS.getArgOperand(ArgNo), *CS.getInstruction()),
         ArgNo(ArgNo) {}
 
   /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     CallSite CS(&getAnchoredValue());
     if (CS.paramHasAttr(ArgNo, Attribute::Dereferenceable))
       takeKnownDerefBytesMaximum(
           CS.getDereferenceableBytes(ArgNo + AttributeList::FirstArgIndex));
 
     if (CS.paramHasAttr(ArgNo, Attribute::DereferenceableOrNull))
       takeKnownDerefBytesMaximum(CS.getDereferenceableOrNullBytes(
           ArgNo + AttributeList::FirstArgIndex));
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override {
     return MP_CALL_SITE_ARGUMENT;
   };
 
   // Return argument index of associated value.
   int getArgNo() const { return ArgNo; }
 
 private:
   unsigned ArgNo;
 };
 
-ChangeStatus AADereferenceableCallSiteArgument::updateImpl(Attributor &A) {
+ChangeStatus
+AADereferenceableCallSiteArgument::updateImpl(Attributor &A,
+                                              InformationCache &InfoCache) {
   // NOTE: Never look at the argument of the callee in this method.
   //       If we do this, "dereferenceable" is always deduced because of the
   //       assumption.
 
   Value &V = *getAssociatedValue();
 
   auto BeforeState = static_cast<DerefState>(*this);
 

 
 // ------------------------ Align Argument Attribute ------------------------
 
 struct AAAlignImpl : AAAlign, IntegerState {
 
   // Max alignemnt value allowed in IR
   static const unsigned MAX_ALIGN = 1U << 29;
 
-  AAAlignImpl(Value *AssociatedVal, Value &AnchoredValue,
-              InformationCache &InfoCache)
-      : AAAlign(AssociatedVal, AnchoredValue, InfoCache),
-        IntegerState(MAX_ALIGN) {}
+  AAAlignImpl(Value *AssociatedVal, Value &AnchoredValue)
+      : AAAlign(AssociatedVal, AnchoredValue), IntegerState(MAX_ALIGN) {}
 
-  AAAlignImpl(Value &V, InformationCache &InfoCache)
-      : AAAlignImpl(&V, V, InfoCache) {}
+  AAAlignImpl(Value &V) : AAAlignImpl(&V, V) {}
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   virtual const std::string getAsStr() const override {
     return getAssumedAlign() ? ("align<" + std::to_string(getKnownAlign()) +
                                 "-" + std::to_string(getAssumedAlign()) + ">")
                              : "unknown-align";
   }
 
   /// See AAAlign::getAssumedAlign().
   unsigned getAssumedAlign() const override { return getAssumed(); }
 
   /// See AAAlign::getKnownAlign().
   unsigned getKnownAlign() const override { return getKnown(); }
 
   /// See AbstractAttriubute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
 
     unsigned AttrIdx =
         getAttrIndex(getManifestPosition(), getArgNo(getAnchoredValue()));
 
     // Already the function has align attribute on return value or argument.
     if (F.getAttributes().hasAttribute(AttrIdx, ID))
       addKnownBits(F.getAttribute(AttrIdx, ID).getAlignment());
   }
 
   /// See AbstractAttribute::getDeducedAttributes
   virtual void
   getDeducedAttributes(SmallVectorImpl<Attribute> &Attrs) const override {
     LLVMContext &Ctx = AnchoredVal.getContext();
 
     Attrs.emplace_back(Attribute::getWithAlignment(Ctx, getAssumedAlign()));
   }
 };
 
 /// Align attribute for function return value.
 struct AAAlignReturned : AAAlignImpl {
 
-  AAAlignReturned(Function &F, InformationCache &InfoCache)
-      : AAAlignImpl(F, InfoCache) {}
+  AAAlignReturned(Function &F) : AAAlignImpl(F) {}
 
   /// See AbstractAttribute::getManifestPosition().
   virtual ManifestPosition getManifestPosition() const override {
     return MP_RETURNED;
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  virtual ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
-ChangeStatus AAAlignReturned::updateImpl(Attributor &A) {
+ChangeStatus AAAlignReturned::updateImpl(Attributor &A,
+                                         InformationCache &InfoCache) {
   Function &F = getAnchorScope();
   auto *AARetValImpl = A.getAAFor<AAReturnedValuesImpl>(*this, F);
   if (!AARetValImpl)
     return indicatePessimisticFixpoint();
 
   // Currently, align<n> is deduced if alignments in return values are assumed
   // as greater than n. We reach pessimistic fixpoint if any of the return value
   // wouldn't have align. If no assumed state was used for reasoning, an
ChangeStatus AAAlignReturned::updateImpl(Attributor &A,
 
   return (getAssumed() != BeforeState) ? ChangeStatus::CHANGED
                                        : ChangeStatus::UNCHANGED;
 }
 
 /// Align attribute for function argument.
 struct AAAlignArgument : AAAlignImpl {
 
-  AAAlignArgument(Argument &A, InformationCache &InfoCache)
-      : AAAlignImpl(A, InfoCache) {}
+  AAAlignArgument(Argument &A) : AAAlignImpl(A) {}
 
   /// See AbstractAttribute::getManifestPosition().
   virtual ManifestPosition getManifestPosition() const override {
     return MP_ARGUMENT;
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  virtual ChangeStatus updateImpl(Attributor &A) override;
+  virtual ChangeStatus updateImpl(Attributor &A,
+                                  InformationCache &InfoCache) override;
 };
 
-ChangeStatus AAAlignArgument::updateImpl(Attributor &A) {
+ChangeStatus AAAlignArgument::updateImpl(Attributor &A,
+                                         InformationCache &InfoCache) {
 
   Function &F = getAnchorScope();
   Argument &Arg = cast<Argument>(getAnchoredValue());
 
   unsigned ArgNo = Arg.getArgNo();
   const DataLayout &DL = F.getParent()->getDataLayout();
 
   auto BeforeState = getAssumed();
ChangeStatus AAAlignArgument::updateImpl(Attributor &A,
 
   return BeforeState == getAssumed() ? ChangeStatus::UNCHANGED
                                      : ChangeStatus ::CHANGED;
 }
 
 struct AAAlignCallSiteArgument : AAAlignImpl {
 
   /// See AANonNullImpl::AANonNullImpl(...).
-  AAAlignCallSiteArgument(CallSite CS, unsigned ArgNo,
-                          InformationCache &InfoCache)
-      : AAAlignImpl(CS.getArgOperand(ArgNo), *CS.getInstruction(), InfoCache),
+  AAAlignCallSiteArgument(CallSite CS, unsigned ArgNo)
+      : AAAlignImpl(CS.getArgOperand(ArgNo), *CS.getInstruction()),
         ArgNo(ArgNo) {}
 
   /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     CallSite CS(&getAnchoredValue());
     takeKnownMaximum(getAssociatedValue()->getPointerAlignment(
         getAnchorScope().getParent()->getDataLayout()));
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
-  ChangeStatus updateImpl(Attributor &A) override;
+  ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override {
     return MP_CALL_SITE_ARGUMENT;
   };
 
   // Return argument index of associated value.
   int getArgNo() const { return ArgNo; }
 
 private:
   unsigned ArgNo;
 };
 
-ChangeStatus AAAlignCallSiteArgument::updateImpl(Attributor &A) {
+ChangeStatus AAAlignCallSiteArgument::updateImpl(Attributor &A,
+                                                 InformationCache &InfoCache) {
   // NOTE: Never look at the argument of the callee in this method.
   //       If we do this, "align" is always deduced because of the assumption.
 
   auto BeforeState = getAssumed();
 
   Value &V = *getAssociatedValue();
 
   auto *AlignAA = A.getAAFor<AAAlign>(*this, V);
 
   if (AlignAA)
     takeAssumedMinimum(AlignAA->getAssumedAlign());
   else
     indicatePessimisticFixpoint();
 
   return BeforeState == getAssumed() ? ChangeStatus::UNCHANGED
                                      : ChangeStatus::CHANGED;
 }
 
 /// ------------------ Function No-Return Attribute ----------------------------
 struct AANoReturnFunction final : public AANoReturn, BooleanState {
 
-  AANoReturnFunction(Function &F, InformationCache &InfoCache)
-      : AANoReturn(F, InfoCache) {}
+  AANoReturnFunction(Function &F) : AANoReturn(F) {}
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// Return true if the underlying object is known to never return.
   bool isKnownNoReturn() const override { return getKnown(); }
 
   /// Return true if the underlying object is assumed to never return.
   bool isAssumedNoReturn() const override { return getAssumed(); }
 
   /// See AbstractAttribute::getManifestPosition().
   ManifestPosition getManifestPosition() const override { return MP_FUNCTION; }
 
   /// See AbstractAttribute::getAsStr().
   const std::string getAsStr() const override {
     return getAssumed() ? "noreturn" : "may-return";
   }
 
   /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {
+  void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
     if (F.hasFnAttribute(getAttrKind()))
       indicateOptimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
-  virtual ChangeStatus updateImpl(Attributor &A) override {
+  virtual ChangeStatus updateImpl(Attributor &A,
+                                  InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
 
     // The map from instruction opcodes to those instructions in the function.
     auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
 
     // Look at all return instructions.
     auto &ReturnInsts = OpcodeInstMap[Instruction::Ret];
     if (ReturnInsts.empty())
for (const Use &U : F.uses()) {
     LLVM_DEBUG(dbgs() << "Attributor: Call site callback failed for "
                       << *CS.getInstruction() << "\n");
     return false;
   }
 
   return true;
 }
 
-ChangeStatus Attributor::run() {
+ChangeStatus Attributor::run(InformationCache &InfoCache) {
   // Initialize all abstract attributes.
   for (AbstractAttribute *AA : AllAbstractAttributes)
-    AA->initialize(*this);
+    AA->initialize(*this, InfoCache);
 
   LLVM_DEBUG(dbgs() << "[Attributor] Identified and initialized "
                     << AllAbstractAttributes.size()
                     << " abstract attributes.\n");
 
   // Now that all abstract attributes are collected and initialized we start
   // the abstract analysis.
 
do {
     }
 
     // Reset the changed set.
     ChangedAAs.clear();
 
     // Update all abstract attribute in the work list and record the ones that
     // changed.
     for (AbstractAttribute *AA : Worklist)
-      if (AA->update(*this) == ChangeStatus::CHANGED)
+      if (AA->update(*this, InfoCache) == ChangeStatus::CHANGED)
         ChangedAAs.push_back(AA);
 
     // Reset the work list and repopulate with the changed abstract attributes.
     // Note that dependent ones are added above.
     Worklist.clear();
     Worklist.insert(ChangedAAs.begin(), ChangedAAs.end());
 
   } while (!Worklist.empty() && ++IterationCounter < MaxFixpointIterations);
ChangeStatus Attributor::run(InformationCache &InfoCache) {
   // IR was changed, we re-run the whole fixpoint analysis, starting at
   // re-initialization of the arguments. This re-run should not result in an IR
   // change. Though, the (virtual) state of attributes at the end of the re-run
   // might be more optimistic than the known state or the IR state if the better
   // state cannot be manifested.
   if (VerifyAttributor && FinishedAtFixpoint &&
       ManifestChange == ChangeStatus::CHANGED) {
     VerifyAttributor = false;
-    ChangeStatus VerifyStatus = run();
+    ChangeStatus VerifyStatus = run(InfoCache);
     if (VerifyStatus != ChangeStatus::UNCHANGED)
       llvm_unreachable(
           "Attributor verification failed, re-run did result in an IR change "
           "even after a fixpoint was reached in the original run. (False "
           "positives possible!)");
     VerifyAttributor = true;
   }
 
   NumAttributesManifested += NumManifested;
   NumAttributesValidFixpoint += NumAtFixpoint;
 
   return ManifestChange;
 }
 
 void Attributor::identifyDefaultAbstractAttributes(
     Function &F, InformationCache &InfoCache,
     DenseSet</* Attribute::AttrKind */ unsigned> *Whitelist) {
 
   // Check for dead BasicBlocks in every function.
-  registerAA(*new AAIsDeadFunction(F, InfoCache));
+  registerAA(*new AAIsDeadFunction(F));
 
   // Every function might be "will-return".
-  registerAA(*new AAWillReturnFunction(F, InfoCache));
+  registerAA(*new AAWillReturnFunction(F));
 
   // Every function can be nounwind.
-  registerAA(*new AANoUnwindFunction(F, InfoCache));
+  registerAA(*new AANoUnwindFunction(F));
 
   // Every function might be marked "nosync"
-  registerAA(*new AANoSyncFunction(F, InfoCache));
+  registerAA(*new AANoSyncFunction(F));
 
   // Every function might be "no-free".
-  registerAA(*new AANoFreeFunction(F, InfoCache));
+  registerAA(*new AANoFreeFunction(F));
 
   // Every function might be "no-return".
-  registerAA(*new AANoReturnFunction(F, InfoCache));
+  registerAA(*new AANoReturnFunction(F));
 
   // Return attributes are only appropriate if the return type is non void.
   Type *ReturnType = F.getReturnType();
   if (!ReturnType->isVoidTy()) {
     // Argument attribute "returned" --- Create only one per function even
     // though it is an argument attribute.
     if (!Whitelist || Whitelist->count(AAReturnedValues::ID))
-      registerAA(*new AAReturnedValuesImpl(F, InfoCache));
+      registerAA(*new AAReturnedValuesImpl(F));
 
     if (ReturnType->isPointerTy()) {
       // Every function with pointer return type might be marked align.
       if (!Whitelist || Whitelist->count(AAAlignReturned::ID))
-        registerAA(*new AAAlignReturned(F, InfoCache));
+        registerAA(*new AAAlignReturned(F));
 
       // Every function with pointer return type might be marked nonnull.
       if (!Whitelist || Whitelist->count(AANonNullReturned::ID))
-        registerAA(*new AANonNullReturned(F, InfoCache));
+        registerAA(*new AANonNullReturned(F));
 
       // Every function with pointer return type might be marked noalias.
       if (!Whitelist || Whitelist->count(AANoAliasReturned::ID))
-        registerAA(*new AANoAliasReturned(F, InfoCache));
+        registerAA(*new AANoAliasReturned(F));
 
       // Every function with pointer return type might be marked
       // dereferenceable.
       if (ReturnType->isPointerTy() &&
           (!Whitelist || Whitelist->count(AADereferenceableReturned::ID)))
-        registerAA(*new AADereferenceableReturned(F, InfoCache));
+        registerAA(*new AADereferenceableReturned(F));
     }
   }
 
   for (Argument &Arg : F.args()) {
     if (Arg.getType()->isPointerTy()) {
       // Every argument with pointer type might be marked nonnull.
       if (!Whitelist || Whitelist->count(AANonNullArgument::ID))
-        registerAA(*new AANonNullArgument(Arg, InfoCache));
+        registerAA(*new AANonNullArgument(Arg));
 
       // Every argument with pointer type might be marked dereferenceable.
       if (!Whitelist || Whitelist->count(AADereferenceableArgument::ID))
-        registerAA(*new AADereferenceableArgument(Arg, InfoCache));
+        registerAA(*new AADereferenceableArgument(Arg));
 
       // Every argument with pointer type might be marked align.
       if (!Whitelist || Whitelist->count(AAAlignArgument::ID))
-        registerAA(*new AAAlignArgument(Arg, InfoCache));
+        registerAA(*new AAAlignArgument(Arg));
     }
   }
 
   // Walk all instructions to find more attribute opportunities and also
   // interesting instructions that might be queried by abstract attributes
   // during their initialization or update.
   auto &ReadOrWriteInsts = InfoCache.FuncRWInstsMap[&F];
   auto &InstOpcodeMap = InfoCache.FuncInstOpcodeMap[&F];
for (Instruction &I : instructions(&F)) {
     CallSite CS(&I);
     if (CS && CS.getCalledFunction()) {
       for (int i = 0, e = CS.getCalledFunction()->arg_size(); i < e; i++) {
         if (!CS.getArgument(i)->getType()->isPointerTy())
           continue;
 
         // Call site argument attribute "non-null".
         if (!Whitelist || Whitelist->count(AANonNullCallSiteArgument::ID))
-          registerAA(*new AANonNullCallSiteArgument(CS, i, InfoCache), i);
+          registerAA(*new AANonNullCallSiteArgument(CS, i), i);
 
         // Call site argument attribute "dereferenceable".
         if (!Whitelist ||
             Whitelist->count(AADereferenceableCallSiteArgument::ID))
-          registerAA(*new AADereferenceableCallSiteArgument(CS, i, InfoCache),
-                     i);
+          registerAA(*new AADereferenceableCallSiteArgument(CS, i), i);
 
         // Call site argument attribute "align".
         if (!Whitelist || Whitelist->count(AAAlignCallSiteArgument::ID))
-          registerAA(*new AAAlignCallSiteArgument(CS, i, InfoCache), i);
+          registerAA(*new AAAlignCallSiteArgument(CS, i), i);
       }
     }
   }
 }
 
 /// Helpers to ease debugging through output streams and print calls.
 ///
 ///{
for (Function &F : M) {
 
     NumFnWithExactDefinition++;
 
     // Populate the Attributor with abstract attribute opportunities in the
     // function and the information cache with IR information.
     A.identifyDefaultAbstractAttributes(F, InfoCache);
   }
 
-  return A.run() == ChangeStatus::CHANGED;
+  return A.run(InfoCache) == ChangeStatus::CHANGED;
 }
 
 PreservedAnalyses AttributorPass::run(Module &M, ModuleAnalysisManager &AM) {
   if (runAttributorOnModule(M)) {
     // FIXME: Think about passes we will preserve and add them here.
     return PreservedAnalyses::none();
   }
   return PreservedAnalyses::all();