[Attributor][NFCI] Make abstract attributes stateless

[jdoerfert]

Summary

To remove boilerplate, mostly passing through values to the
AbstractAttriubute base class, we extract the state into an IRPosition
helper. There is no function change intended.

[sstefan1]

I really like both this and D65712. This makes things much cleaner imo. One more question, since D65712 also simplifies some things from this patch, wouldn't it be easier to just make it in one review?

llvm/lib/Transforms/IPO/Attributor.cpp

407 ↗

(On Diff #213226)

Can these getState() overrides be also put in the above macro? As far as I can see they are also always same.
This would also apply to D65712, for IRAttribute.

[sstefan1]

Comment discussed on irc and agreed to be done in another patch.

LGTM.

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

 // height lattice and the update function to be monotone. However, these
 // conditions are not enforced because the iteration limit will guarantee
 // termination. If an optimistic fixpoint is reached, or a pessimistic fix
 // point is enforced after a timeout, the abstract attributes are tasked to
 // manifest their result in the IR for passes to come.
 //
 // Attribute manifestation is not mandatory. If desired, there is support to
 // generate a single LLVM-IR attribute already in the AbstractAttribute base
-// class. In the simplest case, a subclass overloads
-// `AbstractAttribute::getManifestPosition()` and
-// `AbstractAttribute::getAttrKind()` to return the appropriate values. The
-// Attributor manifestation framework will then create and place a new attribute
-// if it is allowed to do so (based on the abstract state). Other use cases can
-// be achieved by overloading other abstract attribute methods.
+// class. In the simplest case, a subclass initializes the IRPosition properly
+// and overloads `AbstractAttribute::getAttrKind()` to return the appropriate
+// value. The Attributor manifestation framework will then create and place a
+// new attribute if it is allowed to do so (based on the abstract state). Other
+// use cases can be achieved by overloading other abstract attribute methods.
 //
 //
 // The "mechanics" of adding a new "abstract attribute":
 // - Define a class (transitively) inheriting from AbstractAttribute and one
 //   (which could be the same) that (transitively) inherits from AbstractState.
 //   For the latter, consider the already available BooleanState and
 //   IntegerState if they fit your needs, e.g., you require only a bit-encoding.
 // - Implement all pure methods. Also use overloading if the attribute is not
template <typename AAType> AAType &registerAA(AAType &AA, int ArgNo = -1) {
     static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
                   "Cannot register an attribute with a type not derived from "
                   "'AbstractAttribute'!");
 
     // Determine the anchor value and the argument number which are used to
     // lookup the attribute together with AAType::ID. If passed an argument,
     // use its argument number but do not override a given one as it could be a
     // use of the argument at a call site.
-    Value &AnchoredVal = AA.getAnchoredValue();
+    Value &AnchorVal = AA.getIRPosition().getAnchorValue();
     if (ArgNo == -1)
-      if (auto *Arg = dyn_cast<Argument>(&AnchoredVal))
+      if (auto *Arg = dyn_cast<Argument>(&AnchorVal))
         ArgNo = Arg->getArgNo();
 
     // Put the attribute in the lookup map structure and the container we use to
     // keep track of all attributes.
-    AAMap[{&AnchoredVal, ArgNo}][&AAType::ID] = &AA;
+    AAMap[{&AnchorVal, ArgNo}][&AAType::ID] = &AA;
     AllAbstractAttributes.push_back(&AA);
     return AA;
   }
 
   /// Determine opportunities to derive 'default' attributes in \p F and create
   /// abstract attribute objects for them.
   ///
   /// \param F The function that is checked for attribute opportunities.
private:
   base_t Assumed;
 };
 
 /// Simple wrapper for a single bit (boolean) state.
 struct BooleanState : public IntegerState {
   BooleanState() : IntegerState(1){};
 };
 
+/// Struct to encode the position in the LLVM-IR with regards to the associated
+/// value but also the attribute lists.
+struct IRPosition {
+
+  /// The positions attributes can be manifested in.
+  enum Kind {
+    IRP_FUNCTION = AttributeList::FunctionIndex, ///< An attribute for a
+                                                 ///< function as a whole.
+    IRP_RETURNED = AttributeList::ReturnIndex,   ///< An attribute for the
+                                                 ///< function return value.
+    IRP_ARGUMENT,           ///< An attribute for a function argument.
+    IRP_CALL_SITE_ARGUMENT, ///< An attribute for a call site argument.
+  };
+
+  /// Create an IRPosition for an argument.
+  explicit IRPosition(Argument &Arg) : IRPosition(&Arg, Arg, Arg.getArgNo()) {}
+
+  /// Create an IRPosition for a function return or function body position.
+  ///
+  /// \param Fn The value this abstract attributes is anchored at and
+  ///            associated with.
+  /// \param PK  The kind of attribute position, can not be a (call site)
+  ///            argument.
+  explicit IRPosition(Function &Fn, Kind PK)
+      : AssociatedVal(&Fn), AnchorVal(Fn), AttributeIdx(PK) {
+    assert((PK == IRP_RETURNED || PK == IRP_FUNCTION) &&
+           "Expected non-argument position!");
+  }
+
+  /// An abstract attribute associated with \p AssociatedVal and anchored at
+  /// \p AnchorVal.
+  ///
+  /// \param AssociatedVal The value this abstract attribute is associated with.
+  /// \param AnchorVal The value this abstract attributes is anchored at.
+  /// \param ArgumentNo The index in the attribute list, encodes also the
+  ///                     argument number if this is one.
+  explicit IRPosition(Value *AssociatedVal, Value &AnchorVal,
+                      unsigned ArgumentNo)
+      : AssociatedVal(AssociatedVal), AnchorVal(AnchorVal),
+        AttributeIdx(ArgumentNo + AttributeList::FirstArgIndex) {
+    assert(((isa<CallBase>(&AnchorVal) &&
+             cast<CallBase>(&AnchorVal)->arg_size() > ArgumentNo) ||
+            (isa<Argument>(AnchorVal) &&
+             cast<Argument>(AnchorVal).getArgNo() == ArgumentNo)) &&
+           "Expected a valid argument index!");
+  }
+
+  IRPosition(const IRPosition &AAP)
+      : IRPosition(AAP.AssociatedVal, AAP.AnchorVal, AAP.AttributeIdx) {}
+
+  /// Virtual destructor.
+  virtual ~IRPosition() {}
+
+  /// 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
+  /// 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.
+  ///
+  ///{
+  Value &getAnchorValue() { return AnchorVal; }
+  const Value &getAnchorValue() const { return AnchorVal; }
+  ///}
+
+  /// Return the llvm::Function surrounding the anchored value.
+  ///
+  ///{
+  Function &getAnchorScope() {
+    Value &V = getAnchorValue();
+    if (isa<Function>(V))
+      return cast<Function>(V);
+    if (isa<Argument>(V))
+      return *cast<Argument>(V).getParent();
+    if (isa<Instruction>(V))
+      return *cast<Instruction>(V).getFunction();
+    llvm_unreachable("No scope for anchored value found!");
+  }
+  const Function &getAnchorScope() const {
+    return const_cast<IRPosition *>(this)->getAnchorScope();
+  }
+  ///}
+
+  /// Return the value this abstract attribute is associated with.
+  ///
+  /// The abstract state usually represents this value.
+  ///
+  ///{
+  Value *getAssociatedValue() { return AssociatedVal; }
+  const Value *getAssociatedValue() const { return AssociatedVal; }
+  ///}
+
+  /// Return the argument number of the associated value if it is an argument or
+  /// call site argument, otherwise a negative value.
+  int getArgNo() const { return AttributeIdx - AttributeList::FirstArgIndex; }
+
+  /// Return the position this abstract state is manifested in.
+  Kind getPositionKind() const {
+    if (getArgNo() >= 0) {
+      if (isa<CallBase>(getAnchorValue()))
+        return IRP_CALL_SITE_ARGUMENT;
+      assert((isa<Argument>(getAnchorValue()) ||
+              isa_and_nonnull<Argument>(getAssociatedValue()) ||
+              (!getAssociatedValue() && isa<Function>(getAnchorValue()))) &&
+             "Expected argument or call base due to argument number!");
+      return IRP_ARGUMENT;
+    }
+    return (Kind)AttributeIdx;
+  }
+
+  /// Return the index in the attribute list for this position.
+  int getAttrIdx() const { return AttributeIdx; }
+
+  /// Change the associated value.
+  void setAssociatedValue(Value *V) { AssociatedVal = V; }
+
+  /// Change the associated attribue list position.
+  void setAttributeIdx(int AttrIdx) { AttributeIdx = AttrIdx; }
+
+protected:
+  /// The value this abstract attribute is associated with.
+  Value *AssociatedVal;
+
+  /// The value this abstract attribute is anchored at.
+  Value &AnchorVal;
+
+  /// The index in the attribute list.
+  int AttributeIdx;
+};
+
 /// Base struct for all "concrete attribute" deductions.
 ///
 /// The abstract attribute is a minimal interface that allows the Attributor to
 /// orchestrate the abstract/fixpoint analysis. The design allows to hide away
 /// implementation choices made for the subclasses but also to structure their
 /// implementation and simplify the use of other abstract attributes in-flight.
 ///
 /// To allow easy creation of new attributes, most methods have default

 ///       with regards to the program flow. More practically, information can
 ///       *now* be propagated from instructions to their enclosing function, but
 ///       *not* from call sites to the called function. The mechanisms to allow
 ///       both directions will be added in the future.
 /// NOTE: The mechanics of adding a new "concrete" abstract attribute are
 ///       described in the file comment.
 struct AbstractAttribute {
 
-  /// The positions attributes can be manifested in.
-  enum ManifestPosition {
-    MP_ARGUMENT,           ///< An attribute for a function argument.
-    MP_CALL_SITE_ARGUMENT, ///< An attribute for a call site argument.
-    MP_FUNCTION,           ///< An attribute for a function as a whole.
-    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.
-  AbstractAttribute(Value *AssociatedVal, Value &AnchoredVal)
-      : AssociatedVal(AssociatedVal), AnchoredVal(AnchoredVal) {}
-
-  /// An abstract attribute associated with and anchored at \p V.
-  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, 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
-  /// 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.
-  ///
-  ///{
-  Value &getAnchoredValue() { return AnchoredVal; }
-  const Value &getAnchoredValue() const { return AnchoredVal; }
-  ///}
-
-  /// Return the llvm::Function surrounding the anchored value.
-  ///
-  ///{
-  Function &getAnchorScope();
-  const Function &getAnchorScope() const;
-  ///}
-
-  /// Return the value this abstract attribute is associated with.
-  ///
-  /// The abstract state usually represents this value.
-  ///
-  ///{
-  virtual Value *getAssociatedValue() { return AssociatedVal; }
-  virtual const Value *getAssociatedValue() const { return AssociatedVal; }
-  ///}
-
-  /// Return the position this abstract state is manifested in.
-  virtual ManifestPosition getManifestPosition() const = 0;
+  /// Return an IR position, see struct IRPosition.
+  virtual const IRPosition &getIRPosition() const = 0;
 
   /// Return the kind that identifies the abstract attribute implementation.
   virtual Attribute::AttrKind getAttrKind() const = 0;
 
   /// Return the deduced attributes in \p Attrs.
   virtual void getDeducedAttributes(SmallVectorImpl<Attribute> &Attrs) const {
-    LLVMContext &Ctx = AnchoredVal.getContext();
+    LLVMContext &Ctx = getIRPosition().getAnchorScope().getContext();
     Attrs.emplace_back(Attribute::get(Ctx, getAttrKind()));
   }
 
   /// Helper functions, for debug purposes only.
   ///{
   virtual void print(raw_ostream &OS) const;
   void dump() const { print(dbgs()); }
 
protected:
   /// \Return CHANGED if the internal state changed, otherwise UNCHANGED.
   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 an IR position, see struct IRPosition.
+  virtual IRPosition &getIRPosition() = 0;
 
   /// 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,
                                   InformationCache &InfoCache) = 0;
-
-  /// The value this abstract attribute is associated with.
-  Value *AssociatedVal;
-
-  /// The value this abstract attribute is anchored at.
-  Value &AnchoredVal;
 };
 
 /// 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, IRPosition::Kind);
+raw_ostream &operator<<(raw_ostream &OS, const IRPosition &);
 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) : 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 Attribute::Returned;
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 struct AANoUnwind : public AbstractAttribute {
-  /// An abstract interface for all nosync attributes.
-  AANoUnwind(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::getAttrKind()/
   Attribute::AttrKind getAttrKind() const override {
     return Attribute::NoUnwind;
   }
 
   /// Returns true if nounwind is assumed.
   virtual bool isAssumedNoUnwind() const = 0;
 
   /// Returns true if nounwind is known.
   virtual bool isKnownNoUnwind() const = 0;
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 struct AANoSync : public AbstractAttribute {
-  /// An abstract interface for all nosync attributes.
-  AANoSync(Value &V) : AbstractAttribute(V) {}
 
   /// See AbstractAttribute::getAttrKind().
   Attribute::AttrKind getAttrKind() const override { return Attribute::NoSync; }
 
   /// Returns true if "nosync" is assumed.
   virtual bool isAssumedNoSync() const = 0;
 
   /// Returns true if "nosync" is known.
   virtual bool isKnownNoSync() const = 0;
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract interface for all nonnull attributes.
 struct AANonNull : public AbstractAttribute {
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  AANonNull(Value &V) : AbstractAttribute(V) {}
-
-  /// See AbstractAttribute::AbstractAttribute(...).
-  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 Attribute::NonNull;
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract attribute for norecurse.
 struct AANoRecurse : public AbstractAttribute {
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  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;
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract attribute for willreturn.
 struct AAWillReturn : public AbstractAttribute {
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  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;
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract interface for all noalias attributes.
 struct AANoAlias : public AbstractAttribute {
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  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 Attribute::NoAlias;
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An AbstractAttribute for noreturn.
 struct AANoReturn : public AbstractAttribute {
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  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 Attribute::NoReturn;
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract interface for liveness abstract attribute.
 struct AAIsDead : public AbstractAttribute {
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  AAIsDead(Value &V) : AbstractAttribute(V) {}
-
   /// See AbstractAttribute::getAttrKind()
   Attribute::AttrKind getAttrKind() const override { return Attribute::None; }
 
   /// Returns true if \p BB is assumed dead.
   virtual bool isAssumedDead(const BasicBlock *BB) const = 0;
 
   /// Returns true if \p BB is known dead.
   virtual bool isKnownDead(const BasicBlock *BB) const = 0;
 
   /// Returns true if \p I is assumed dead.
   virtual bool isAssumedDead(const Instruction *I) const = 0;
 
   /// Returns true if \p I is known dead.
   virtual bool isKnownDead(const Instruction *I) const = 0;
 
   /// This method is used to check if at least one instruction in a collection
   /// of instructions is live.
   template <typename T> bool isLiveInstSet(T begin, T end) const {
     for (const auto &I : llvm::make_range(begin, end)) {
-      assert(I->getFunction() == &getAnchorScope() &&
+      assert(I->getFunction() == &getIRPosition().getAnchorScope() &&
              "Instruction must be in the same anchor scope function.");
 
       if (!isAssumedDead(I))
         return true;
     }
 
     return false;
   }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract interface for all dereferenceable attribute.
 struct AADereferenceable : public AbstractAttribute {
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  AADereferenceable(Value &V) : AbstractAttribute(V) {}
-
-  /// See AbstractAttribute::AbstractAttribute(...).
-  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
   /// dereferenceable(_or_null) globally.
struct AADereferenceable : public AbstractAttribute {
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract interface for all align attributes.
 struct AAAlign : public AbstractAttribute {
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  AAAlign(Value &V) : AbstractAttribute(V) {}
+  /// Return assumed alignment.
+  virtual unsigned getAssumedAlign() const = 0;
 
-  /// See AbstractAttribute::AbstractAttribute(...).
-  AAAlign(Value *AssociatedVal, Value &AnchoredValue)
-      : AbstractAttribute(AssociatedVal, AnchoredValue) {}
+  /// Return known alignemnt.
+  virtual unsigned getKnownAlign() const = 0;
 
   /// See AbastractState::getAttrKind().
   Attribute::AttrKind getAttrKind() const override {
     return Attribute::Alignment;
   }
 
-  /// Return assumed alignment.
-  virtual unsigned getAssumedAlign() const = 0;
-
-  /// Return known alignemnt.
-  virtual unsigned getKnownAlign() const = 0;
-
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H

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

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;
 }
 ///}
 
 /// Helper to adjust the statistics.
-static void bookkeeping(AbstractAttribute::ManifestPosition MP,
-                        const Attribute &Attr) {
+static void bookkeeping(IRPosition::Kind PK, const Attribute &Attr) {
   if (!AreStatisticsEnabled())
     return;
 
   switch (Attr.getKindAsEnum()) {
   case Attribute::Alignment:
-    switch (MP) {
-    case AbstractAttribute::MP_RETURNED:
+    switch (PK) {
+    case IRPosition::IRP_RETURNED:
       NumFnReturnedAlign++;
       break;
-    case AbstractAttribute::MP_ARGUMENT:
+    case IRPosition::IRP_ARGUMENT:
       NumFnArgumentAlign++;
       break;
-    case AbstractAttribute::MP_CALL_SITE_ARGUMENT:
+    case IRPosition::IRP_CALL_SITE_ARGUMENT:
       NumCSArgumentAlign++;
       break;
     default:
       break;
     }
     break;
   case Attribute::Dereferenceable:
-    switch (MP) {
-    case AbstractAttribute::MP_RETURNED:
+    switch (PK) {
+    case IRPosition::IRP_RETURNED:
       NumFnReturnedDereferenceable++;
       break;
-    case AbstractAttribute::MP_ARGUMENT:
+    case IRPosition::IRP_ARGUMENT:
       NumFnArgumentDereferenceable++;
       break;
-    case AbstractAttribute::MP_CALL_SITE_ARGUMENT:
+    case IRPosition::IRP_CALL_SITE_ARGUMENT:
       NumCSArgumentDereferenceable++;
       break;
     default:
       break;
     }
     break;
   case Attribute::NoUnwind:
     NumFnNoUnwind++;
     return;
   case Attribute::Returned:
     NumFnArgumentReturned++;
     return;
   case Attribute::NoSync:
     NumFnNoSync++;
     break;
   case Attribute::NoFree:
     NumFnNoFree++;
     break;
   case Attribute::NonNull:
-    switch (MP) {
-    case AbstractAttribute::MP_RETURNED:
+    switch (PK) {
+    case IRPosition::IRP_RETURNED:
       NumFnReturnedNonNull++;
       break;
-    case AbstractAttribute::MP_ARGUMENT:
+    case IRPosition::IRP_ARGUMENT:
       NumFnArgumentNonNull++;
       break;
-    case AbstractAttribute::MP_CALL_SITE_ARGUMENT:
+    case IRPosition::IRP_CALL_SITE_ARGUMENT:
       NumCSArgumentNonNull++;
       break;
     default:
       break;
     }
     break;
   case Attribute::WillReturn:
     NumFnWillReturn++;
do {
     // Once a leaf is reached we inform the user through the callback.
     VisitValueCB(V, State);
   } while (!Worklist.empty());
 
   // All values have been visited.
   return true;
 }
 
-/// Helper to identify the correct offset into an attribute list.
-static unsigned getAttrIndex(AbstractAttribute::ManifestPosition MP,
-                             unsigned ArgNo = 0) {
-  switch (MP) {
-  case AbstractAttribute::MP_ARGUMENT:
-  case AbstractAttribute::MP_CALL_SITE_ARGUMENT:
-    return ArgNo + AttributeList::FirstArgIndex;
-  case AbstractAttribute::MP_FUNCTION:
-    return AttributeList::FunctionIndex;
-  case AbstractAttribute::MP_RETURNED:
-    return AttributeList::ReturnIndex;
-  }
-  llvm_unreachable("Unknown manifest position!");
-}
-
 /// Return true if \p New is equal or worse than \p Old.
 static bool isEqualOrWorse(const Attribute &New, const Attribute &Old) {
   if (!Old.isIntAttribute())
     return true;
 
   return Old.getValueAsInt() >= New.getValueAsInt();
 }
 
 /// Return true if the information provided by \p Attr was added to the
 /// attribute list \p Attrs. This is only the case if it was not already present
-/// in \p Attrs at the position describe by \p MP and \p ArgNo.
+/// in \p Attrs at the position describe by \p PK and \p AttrIdx.
 static bool addIfNotExistent(LLVMContext &Ctx, const Attribute &Attr,
-                             AttributeList &Attrs,
-                             AbstractAttribute::ManifestPosition MP,
-                             unsigned ArgNo = 0) {
-  unsigned AttrIdx = getAttrIndex(MP, ArgNo);
+                             AttributeList &Attrs, int AttrIdx) {
 
   if (Attr.isEnumAttribute()) {
     Attribute::AttrKind Kind = Attr.getKindAsEnum();
     if (Attrs.hasAttribute(AttrIdx, Kind))
       if (isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
         return false;
     Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
     return true;
LLVM_DEBUG(dbgs() << "[Attributor] Update " << HasChanged << " " << *this
                     << "\n");
 
   return HasChanged;
 }
 
 ChangeStatus AbstractAttribute::manifest(Attributor &A) {
   assert(getState().isValidState() &&
          "Attempted to manifest an invalid state!");
-  assert(getAssociatedValue() &&
+  assert(getIRPosition().getAssociatedValue() &&
          "Attempted to manifest an attribute without associated value!");
 
   ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
-  SmallVector<Attribute, 4> DeducedAttrs;
-  getDeducedAttributes(DeducedAttrs);
 
-  Function &ScopeFn = getAnchorScope();
+  IRPosition &Pos = getIRPosition();
+  Function &ScopeFn = Pos.getAnchorScope();
   LLVMContext &Ctx = ScopeFn.getContext();
-  ManifestPosition MP = getManifestPosition();
+  IRPosition::Kind PK = Pos.getPositionKind();
 
-  AttributeList Attrs;
-  SmallVector<unsigned, 4> ArgNos;
+  SmallVector<Attribute, 4> DeducedAttrs;
+  getDeducedAttributes(DeducedAttrs);
 
   // In the following some generic code that will manifest attributes in
   // DeducedAttrs if they improve the current IR. Due to the different
   // annotation positions we use the underlying AttributeList interface.
-  // Note that MP_CALL_SITE_ARGUMENT can annotate multiple locations.
 
-  switch (MP) {
-  case MP_ARGUMENT:
-    ArgNos.push_back(cast<Argument>(getAssociatedValue())->getArgNo());
+  AttributeList Attrs;
+  switch (PK) {
+  case IRPosition::IRP_ARGUMENT:
+  case IRPosition::IRP_FUNCTION:
+  case IRPosition::IRP_RETURNED:
     Attrs = ScopeFn.getAttributes();
     break;
-  case MP_FUNCTION:
-  case MP_RETURNED:
-    ArgNos.push_back(0);
-    Attrs = ScopeFn.getAttributes();
+  case IRPosition::IRP_CALL_SITE_ARGUMENT:
+    Attrs = ImmutableCallSite(&Pos.getAnchorValue()).getAttributes();
     break;
-  case MP_CALL_SITE_ARGUMENT: {
-    CallSite CS(&getAnchoredValue());
-    for (unsigned u = 0, e = CS.getNumArgOperands(); u != e; u++)
-      if (CS.getArgOperand(u) == getAssociatedValue())
-        ArgNos.push_back(u);
-    Attrs = CS.getAttributes();
-  }
   }
 
   for (const Attribute &Attr : DeducedAttrs) {
-    for (unsigned ArgNo : ArgNos) {
-      if (!addIfNotExistent(Ctx, Attr, Attrs, MP, ArgNo))
-        continue;
+    if (!addIfNotExistent(Ctx, Attr, Attrs, Pos.getAttrIdx()))
 
-      HasChanged = ChangeStatus::CHANGED;
-      bookkeeping(MP, Attr);
-    }
+    bookkeeping(PK, Attr);
   }
 
   if (HasChanged == ChangeStatus::UNCHANGED)
     return HasChanged;
 
-  switch (MP) {
-  case MP_ARGUMENT:
-  case MP_FUNCTION:
-  case MP_RETURNED:
+  switch (PK) {
+  case IRPosition::IRP_ARGUMENT:
+  case IRPosition::IRP_FUNCTION:
+  case IRPosition::IRP_RETURNED:
     ScopeFn.setAttributes(Attrs);
     break;
-  case MP_CALL_SITE_ARGUMENT:
-    CallSite(&getAnchoredValue()).setAttributes(Attrs);
+  case IRPosition::IRP_CALL_SITE_ARGUMENT:
+    CallSite(&Pos.getAnchorValue()).setAttributes(Attrs);
   }
 
   return HasChanged;
 }
 
-Function &AbstractAttribute::getAnchorScope() {
-  Value &V = getAnchoredValue();
-  if (isa<Function>(V))
-    return cast<Function>(V);
-  if (isa<Argument>(V))
-    return *cast<Argument>(V).getParent();
-  if (isa<Instruction>(V))
-    return *cast<Instruction>(V).getFunction();
-  llvm_unreachable("No scope for anchored value found!");
-}
-
-const Function &AbstractAttribute::getAnchorScope() const {
-  return const_cast<AbstractAttribute *>(this)->getAnchorScope();
-}
-
-// Helper function that returns argument index of value.
-// If the value is not an argument, this returns -1.
-static int getArgNo(Value &V) {
-  if (auto *Arg = dyn_cast<Argument>(&V))
-    return Arg->getArgNo();
-  return -1;
-}
-
 /// -----------------------NoUnwind Function Attribute--------------------------
 
-struct AANoUnwindFunction : AANoUnwind, BooleanState {
-
-  AANoUnwindFunction(Function &F) : AANoUnwind(F) {}
+#define IRPositionConstructorForward(NAME)                                     \
+  NAME(Argument &Arg) : IRPosition(Arg) {}                                     \
+  NAME(Function &Fn, IRPosition::Kind PK) : IRPosition(Fn, PK) {}              \
+  NAME(Value *AssociatedVal, Value &AnchorVal, unsigned ArgumentNo)            \
+      : IRPosition(AssociatedVal, AnchorVal, ArgumentNo) {}
+#define IRPositionGetter(IRP)                                                  \
+  IRPosition &getIRPosition() override { return IRP; }                         \
+  const IRPosition &getIRPosition() const override { return IRP; }
+
+struct AANoUnwindImpl : AANoUnwind, BooleanState, IRPosition {
+  IRPositionConstructorForward(AANoUnwindImpl);
+  IRPositionGetter(*this);
 
   /// 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, 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,
-                                            InformationCache &InfoCache) {
+struct AANoUnwindFunction final : public AANoUnwindImpl {
+  AANoUnwindFunction(Function &F) : AANoUnwindImpl(F, IRP_FUNCTION) {}
+};
+
+ChangeStatus AANoUnwindImpl::updateImpl(Attributor &A,
   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};

 
 /// --------------------- Function Return Values -------------------------------
 
 /// "Attribute" that collects all potential returned values and the return
 /// instructions that they arise from.
 ///
 /// If there is a unique returned value R, the manifest method will:
 ///   - mark R with the "returned" attribute, if R is an argument.
-class AAReturnedValuesImpl final : public AAReturnedValues, AbstractState {
+class AAReturnedValuesImpl : public AAReturnedValues,
+                             public AbstractState,
+                             public IRPosition {
 
   /// Mapping of values potentially returned by the associated function to the
   /// return instructions that might return them.
   DenseMap<Value *, SmallPtrSet<ReturnInst *, 2>> ReturnedValues;
 
   /// State flags
   ///
   ///{
void collectValuesRecursively(
     // If we did abort the above traversal we haven't see all the values.
     // 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) : AAReturnedValues(F) {
-    // We do not have an associated argument yet.
-    AssociatedVal = nullptr;
-  }
+  IRPositionConstructorForward(AAReturnedValuesImpl);
+  IRPositionGetter(*this);
 
   /// See AbstractAttribute::initialize(...).
   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());
+    Function &F = cast<Function>(getAnchorValue());
 
     // The map from instruction opcodes to those instructions in the function.
     auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
 
     // Look through all arguments, if one is marked as returned we are done.
     for (Argument &Arg : F.args()) {
       if (Arg.hasReturnedAttr()) {
 
public:
   ChangeStatus manifest(Attributor &A) override;
 
   /// See AbstractAttribute::getState(...).
   AbstractState &getState() override { return *this; }
 
   /// 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, InformationCache &InfoCache) override;
 
   /// Return the number of potential return values, -1 if unknown.
   size_t getNumReturnValues() const {
     return isValidState() ? ReturnedValues.size() : -1;
   }
 
public:
 
   ChangeStatus indicatePessimisticFixpoint() override {
     IsFixed = true;
     IsValidState = false;
     return ChangeStatus::CHANGED;
   }
 };
 
+struct AAReturnedValuesFunction final : public AAReturnedValuesImpl {
+  AAReturnedValuesFunction(Function &F)
+      : AAReturnedValuesImpl(F, IRP_FUNCTION) {}
+};
+
 ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) {
   ChangeStatus Changed = ChangeStatus::UNCHANGED;
 
   // Bookkeeping.
   assert(isValidState());
   NumFnKnownReturns++;
 
   auto *LivenessAA = A.getAAFor<AAIsDead>(*this, getAnchorScope());
 
   // Check if we have an assumed unique return value that we could manifest.
   Optional<Value *> UniqueRV = getAssumedUniqueReturnValue(LivenessAA);
 
   if (!UniqueRV.hasValue() || !UniqueRV.getValue())
     return Changed;
 
   // Bookkeeping.
   NumFnUniqueReturned++;
 
   // If the assumed unique return value is an argument, annotate it.
   if (auto *UniqueRVArg = dyn_cast<Argument>(UniqueRV.getValue())) {
-    AssociatedVal = UniqueRVArg;
+    setAssociatedValue(UniqueRVArg);
+    setAttributeIdx(UniqueRVArg->getArgNo() + AttributeList::FirstArgIndex);
     Changed = AbstractAttribute::manifest(A) | Changed;
   }
 
   return Changed;
 }
 
 const std::string AAReturnedValuesImpl::getAsStr() const {
   return (isAtFixpoint() ? "returns(#" : "may-return(#") +
if (!HasCallSite) {
     return ChangeStatus::CHANGED;
   }
 
   return Changed;
 }
 
 /// ------------------------ NoSync Function Attribute -------------------------
 
-struct AANoSyncFunction : AANoSync, BooleanState {
-
-  AANoSyncFunction(Function &F) : AANoSync(F) {}
+struct AANoSyncImpl : AANoSync, BooleanState, IRPosition {
+  IRPositionConstructorForward(AANoSyncImpl);
+  IRPositionGetter(*this);
 
   /// 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, InformationCache &InfoCache) override;
 
   /// See AANoSync::isAssumedNoSync()
struct AANoSyncImpl : AANoSync, BooleanState, IRPosition {
   /// Helper function used to determine whether an instruction is volatile.
   static bool isVolatile(Instruction *I);
 
   /// Helper function uset to check if intrinsic is volatile (memcpy, memmove,
   /// memset).
   static bool isNoSyncIntrinsic(Instruction *I);
 };
 
-bool AANoSyncFunction::isNonRelaxedAtomic(Instruction *I) {
+struct AANoSyncFunction final : public AANoSyncImpl {
+  AANoSyncFunction(Function &F) : AANoSyncImpl(F, IRP_FUNCTION) {}
+};
+
+bool AANoSyncImpl::isNonRelaxedAtomic(Instruction *I) {
   if (!I->isAtomic())
     return false;
 
   AtomicOrdering Ordering;
   switch (I->getOpcode()) {
   case Instruction::AtomicRMW:
     Ordering = cast<AtomicRMWInst>(I)->getOrdering();
     break;
bool AANoSyncImpl::isNonRelaxedAtomic(Instruction *I) {
   if (Ordering == AtomicOrdering::Unordered ||
       Ordering == AtomicOrdering::Monotonic)
     return false;
   return true;
 }
 
 /// Checks if an intrinsic is nosync. Currently only checks mem* intrinsics.
 /// FIXME: We should ipmrove the handling of intrinsics.
-bool AANoSyncFunction::isNoSyncIntrinsic(Instruction *I) {
+bool AANoSyncImpl::isNoSyncIntrinsic(Instruction *I) {
   if (auto *II = dyn_cast<IntrinsicInst>(I)) {
     switch (II->getIntrinsicID()) {
     /// Element wise atomic memory intrinsics are can only be unordered,
     /// therefore nosync.
     case Intrinsic::memset_element_unordered_atomic:
     case Intrinsic::memmove_element_unordered_atomic:
     case Intrinsic::memcpy_element_unordered_atomic:
       return true;
     case Intrinsic::memset:
     case Intrinsic::memmove:
     case Intrinsic::memcpy:
       if (!cast<MemIntrinsic>(II)->isVolatile())
         return true;
       return false;
     default:
       return false;
     }
   }
   return false;
 }
 
-bool AANoSyncFunction::isVolatile(Instruction *I) {
+bool AANoSyncImpl::isVolatile(Instruction *I) {
   assert(!ImmutableCallSite(I) && !isa<CallBase>(I) &&
          "Calls should not be checked here");
 
   switch (I->getOpcode()) {
   case Instruction::AtomicRMW:
     return cast<AtomicRMWInst>(I)->isVolatile();
   case Instruction::Store:
     return cast<StoreInst>(I)->isVolatile();
   case Instruction::Load:
     return cast<LoadInst>(I)->isVolatile();
   case Instruction::AtomicCmpXchg:
     return cast<AtomicCmpXchgInst>(I)->isVolatile();
   default:
     return false;
   }
 }
 
-ChangeStatus AANoSyncFunction::updateImpl(Attributor &A,
-                                          InformationCache &InfoCache) {
+ChangeStatus AANoSyncImpl::updateImpl(Attributor &A,
   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.
     if (LivenessAA && LivenessAA->isAssumedDead(I))
       continue;
 
     ImmutableCallSite ICS(I);
-    auto *NoSyncAA = A.getAAFor<AANoSyncFunction>(*this, *I);
+    auto *NoSyncAA = A.getAAFor<AANoSyncImpl>(*this, *I);
 
     if (isa<IntrinsicInst>(I) && isNoSyncIntrinsic(I))
       continue;
 
     if (ICS && (!NoSyncAA || !NoSyncAA->isAssumedNoSync()) &&
         !ICS.hasFnAttr(Attribute::NoSync))
       return indicatePessimisticFixpoint();
 
for (unsigned Opcode : Opcodes) {
     }
   }
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ No-Free Attributes ----------------------------
 
-struct AANoFreeFunction : AbstractAttribute, BooleanState {
-
-  /// See AbstractAttribute::AbstractAttribute(...).
-  AANoFreeFunction(Function &F) : AbstractAttribute(F) {}
+struct AANoFreeImpl : AbstractAttribute, BooleanState, IRPosition {
+  IRPositionConstructorForward(AANoFreeImpl);
+  IRPositionGetter(*this);
 
   /// 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, InformationCache &InfoCache) override;
 
   /// See AbstractAttribute::getAttrKind().
   Attribute::AttrKind getAttrKind() const override { return Attribute::NoFree; }
 
   /// Return true if "nofree" is assumed.
   bool isAssumedNoFree() const { return getAssumed(); }
 
   /// Return true if "nofree" is known.
   bool isKnownNoFree() const { return getKnown(); }
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
-ChangeStatus AANoFreeFunction::updateImpl(Attributor &A,
-                                          InformationCache &InfoCache) {
+struct AANoFreeFunction final : public AANoFreeImpl {
+  AANoFreeFunction(Function &F) : AANoFreeImpl(F, IRP_FUNCTION) {}
+};
+
+ChangeStatus AANoFreeImpl::updateImpl(Attributor &A,
   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 :
        {(unsigned)Instruction::Invoke, (unsigned)Instruction::CallBr,
         (unsigned)Instruction::Call}) {
     for (Instruction *I : OpcodeInstMap[Opcode]) {
       // Skip assumed dead instructions.
       if (LivenessAA && LivenessAA->isAssumedDead(I))
         continue;
       auto ICS = ImmutableCallSite(I);
-      auto *NoFreeAA = A.getAAFor<AANoFreeFunction>(*this, *I);
+      auto *NoFreeAA = A.getAAFor<AANoFreeImpl>(*this, *I);
 
       if ((!NoFreeAA || !NoFreeAA->isAssumedNoFree()) &&
           !ICS.hasFnAttr(Attribute::NoFree))
         return indicatePessimisticFixpoint();
     }
   }
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ NonNull Argument Attribute ------------------------
-struct AANonNullImpl : AANonNull, BooleanState {
-
-  AANonNullImpl(Value &V) : AANonNull(V) {}
-
-  AANonNullImpl(Value *AssociatedVal, Value &AnchoredValue)
-      : AANonNull(AssociatedVal, AnchoredValue) {}
+struct AANonNullImpl : AANonNull, BooleanState, IRPosition {
+  IRPositionConstructorForward(AANonNullImpl);
+  IRPositionGetter(*this);
 
   /// 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) : AANonNullImpl(F) {}
-
-  /// See AbstractAttribute::getManifestPosition().
-  ManifestPosition getManifestPosition() const override { return MP_RETURNED; }
+  AANonNullReturned(Function &F) : AANonNullImpl(F, IRP_RETURNED) {}
 
   /// See AbstractAttriubute::initialize(...).
   void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
 
     // Already nonnull.
     if (F.getAttributes().hasAttribute(AttributeList::ReturnIndex,
                                        Attribute::NonNull) ||
ChangeStatus AANonNullReturned::updateImpl(Attributor &A,
   return ChangeStatus::UNCHANGED;
 }
 
 /// NonNull attribute for function argument.
 struct AANonNullArgument : AANonNullImpl {
 
   AANonNullArgument(Argument &A) : AANonNullImpl(A) {}
 
-  /// See AbstractAttribute::getManifestPosition().
-  ManifestPosition getManifestPosition() const override { return MP_ARGUMENT; }
-
   /// See AbstractAttriubute::initialize(...).
   void initialize(Attributor &A, InformationCache &InfoCache) override {
     Argument *Arg = cast<Argument>(getAssociatedValue());
     if (Arg->hasNonNullAttr())
       indicateOptimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
   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)
-      : AANonNullImpl(CS.getArgOperand(ArgNo), *CS.getInstruction()),
-        ArgNo(ArgNo) {}
+      : AANonNullImpl(CS.getArgOperand(ArgNo), *CS.getInstruction(), ArgNo) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A, InformationCache &InfoCache) override {
-    CallSite CS(&getAnchoredValue());
-    if (CS.paramHasAttr(ArgNo, getAttrKind()) ||
-        CS.paramHasAttr(ArgNo, Attribute::Dereferenceable) ||
+    CallSite CS(&getAnchorValue());
+    if (CS.paramHasAttr(getArgNo(), getAttrKind()) ||
+        CS.paramHasAttr(getArgNo(), Attribute::Dereferenceable) ||
         isKnownNonZero(getAssociatedValue(),
                        getAnchorScope().getParent()->getDataLayout()))
       indicateOptimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
   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,
                                            InformationCache &InfoCache) {
   Function &F = getAnchorScope();
-  Argument &Arg = cast<Argument>(getAnchoredValue());
+  Argument &Arg = cast<Argument>(getAnchorValue());
 
   unsigned ArgNo = Arg.getArgNo();
 
   // Callback function
   std::function<bool(CallSite)> CallSiteCheck = [&](CallSite CS) {
     assert(CS && "Sanity check: Call site was not initialized properly!");
 
     auto *NonNullAA = A.getAAFor<AANonNull>(*this, *CS.getInstruction(), ArgNo);
 
     // Check that NonNullAA is AANonNullCallSiteArgument.
     if (NonNullAA) {
-      ImmutableCallSite ICS(&NonNullAA->getAnchoredValue());
+      ImmutableCallSite ICS(&NonNullAA->getIRPosition().getAnchorValue());
       if (ICS && CS.getInstruction() == ICS.getInstruction())
         return NonNullAA->isAssumedNonNull();
       return false;
     }
 
     if (CS.paramHasAttr(ArgNo, Attribute::NonNull))
       return true;
 
AANonNullCallSiteArgument::updateImpl(Attributor &A,
   if (!NonNullAA || !NonNullAA->isAssumedNonNull())
     return indicatePessimisticFixpoint();
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ Will-Return Attributes ----------------------------
 
-struct AAWillReturnImpl : public AAWillReturn, BooleanState {
-
-  /// See AbstractAttribute::AbstractAttribute(...).
-  AAWillReturnImpl(Function &F) : AAWillReturn(F) {}
+struct AAWillReturnImpl : public AAWillReturn, BooleanState, IRPosition {
+  IRPositionConstructorForward(AAWillReturnImpl);
+  IRPositionGetter(*this);
 
   /// 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) : AAWillReturnImpl(F) {}
-
-  /// See AbstractAttribute::getManifestPosition().
-  ManifestPosition getManifestPosition() const override { return MP_FUNCTION; }
+  AAWillReturnFunction(Function &F) : AAWillReturnImpl(F, IRP_FUNCTION) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A, InformationCache &InfoCache) override;
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
for (unsigned Opcode :
     }
   }
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ NoAlias Argument Attribute ------------------------
 
-struct AANoAliasImpl : AANoAlias, BooleanState {
-
-  AANoAliasImpl(Value &V) : AANoAlias(V) {}
+struct AANoAliasImpl : AANoAlias, BooleanState, IRPosition {
+  IRPositionConstructorForward(AANoAliasImpl);
+  IRPositionGetter(*this);
 
   /// 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) : AANoAliasImpl(F) {}
-
-  /// See AbstractAttribute::getManifestPosition().
-  virtual ManifestPosition getManifestPosition() const override {
-    return MP_RETURNED;
-  }
+  AANoAliasReturned(Function &F) : AANoAliasImpl(F, IRP_RETURNED) {}
 
   /// See AbstractAttriubute::initialize(...).
   void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
 
     // Already noalias.
     if (F.returnDoesNotAlias()) {
       indicateOptimisticFixpoint();
ChangeStatus AANoAliasReturned::updateImpl(Attributor &A,
   if (!AARetValImpl->checkForallReturnedValues(Pred))
     return indicatePessimisticFixpoint();
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// -------------------AAIsDead Function Attribute-----------------------
 
-struct AAIsDeadFunction : AAIsDead, BooleanState {
-
-  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; }
+struct AAIsDeadImpl : public AAIsDead, BooleanState, IRPosition {
+  IRPositionConstructorForward(AAIsDeadImpl);
+  IRPositionGetter(*this);
 
   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 =
struct AAIsDeadImpl : public AAIsDead, BooleanState, IRPosition {
   /// Check if instruction is after noreturn call, in other words, assumed dead.
   bool isAfterNoReturn(const Instruction *I) const;
 
   /// Determine if \p F might catch asynchronous exceptions.
   static bool mayCatchAsynchronousExceptions(const Function &F) {
     return F.hasPersonalityFn() && !canSimplifyInvokeNoUnwind(&F);
   }
 
+  /// See AbstractAttribute::getState()
+  /// {
+  AbstractState &getState() override { return *this; }
+  const AbstractState &getState() const override { return *this; }
+  /// }
+
   /// Collection of to be explored paths.
   SmallSetVector<const Instruction *, 8> ToBeExploredPaths;
 
   /// Collection of all assumed live BasicBlocks.
   DenseSet<const BasicBlock *> AssumedLiveBlocks;
 
   /// Collection of calls with noreturn attribute, assumed or knwon.
   SmallSetVector<const Instruction *, 4> NoReturnCalls;
 };
 
-bool AAIsDeadFunction::isAfterNoReturn(const Instruction *I) const {
+struct AAIsDeadFunction final : public AAIsDeadImpl {
+  AAIsDeadFunction(Function &F) : AAIsDeadImpl(F, IRP_FUNCTION) {}
+};
+
+bool AAIsDeadImpl::isAfterNoReturn(const Instruction *I) const {
   const Instruction *PrevI = I->getPrevNode();
   while (PrevI) {
     if (NoReturnCalls.count(PrevI))
       return true;
     PrevI = PrevI->getPrevNode();
   }
   return false;
 }
 
-const Instruction *AAIsDeadFunction::findNextNoReturn(Attributor &A,
-                                                      const Instruction *I) {
+const Instruction *AAIsDeadImpl::findNextNoReturn(Attributor &A,
   const BasicBlock *BB = I->getParent();
   const Function &F = *BB->getParent();
 
   // Flag to determine if we can change an invoke to a call assuming the callee
   // is nounwind. This is not possible if the personality of the function allows
   // to catch asynchronous exceptions.
   bool Invoke2CallAllowed = !mayCatchAsynchronousExceptions(F);
 
for (const BasicBlock *SuccBB : successors(BB)) {
     AssumedLiveBlocks.insert(SuccBB);
     ToBeExploredPaths.insert(&SuccBB->front());
   }
 
   // No noreturn instruction found.
   return nullptr;
 }
 
-ChangeStatus AAIsDeadFunction::updateImpl(Attributor &A,
-                                          InformationCache &InfoCache) {
+ChangeStatus AAIsDeadImpl::updateImpl(Attributor &A,
   // 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) : AADereferenceable(V) {}
 
-  AADereferenceableImpl(Value *AssociatedVal, Value &AnchoredValue)
-      : AADereferenceable(AssociatedVal, AnchoredValue) {}
+struct AADereferenceableImpl : AADereferenceable, DerefState, IRPosition {
+  IRPositionConstructorForward(AADereferenceableImpl);
+  IRPositionGetter(*this);
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AADereferenceable::getAssumedDereferenceableBytes().
struct AADereferenceableImpl : AADereferenceable, DerefState, IRPosition {
   }
 
   /// See AADereferenceable::isKnownNonNull().
   bool isKnownNonNull() const override {
     return NonNullGlobalState.isKnown(DEREF_NONNULL);
   }
 
   void getDeducedAttributes(SmallVectorImpl<Attribute> &Attrs) const override {
-    LLVMContext &Ctx = AnchoredVal.getContext();
+    LLVMContext &Ctx = AnchorVal.getContext();
 
     // TODO: Add *_globally support
     if (isAssumedNonNull())
       Attrs.emplace_back(Attribute::getWithDereferenceableBytes(
           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, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
-    unsigned AttrIdx =
-        getAttrIndex(getManifestPosition(), getArgNo(getAnchoredValue()));
+    unsigned AttrIdx = getIRPosition().getAttrIdx();
 
     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) : AADereferenceableImpl(F) {}
-
-  /// See AbstractAttribute::getManifestPosition().
-  ManifestPosition getManifestPosition() const override { return MP_RETURNED; }
+  AADereferenceableReturned(Function &F)
+      : AADereferenceableImpl(F, IRP_RETURNED) {}
 
   /// See AbstractAttribute::updateImpl(...).
   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) {
return BeforeState == static_cast<DerefState>(*this)
                : ChangeStatus::CHANGED;
   }
   return indicatePessimisticFixpoint();
 }
 
 struct AADereferenceableArgument : AADereferenceableImpl {
   AADereferenceableArgument(Argument &A) : AADereferenceableImpl(A) {}
 
-  /// See AbstractAttribute::getManifestPosition().
-  ManifestPosition getManifestPosition() const override { return MP_ARGUMENT; }
-
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
 ChangeStatus
 AADereferenceableArgument::updateImpl(Attributor &A,
                                       InformationCache &InfoCache) {
   Function &F = getAnchorScope();
-  Argument &Arg = cast<Argument>(getAnchoredValue());
+  Argument &Arg = cast<Argument>(getAnchorValue());
 
   auto BeforeState = static_cast<DerefState>(*this);
 
   unsigned ArgNo = Arg.getArgNo();
 
   syncNonNull(A.getAAFor<AANonNull>(*this, F, ArgNo));
 
   bool IsNonNull = isAssumedNonNull();
   bool IsGlobal = isAssumedGlobal();
 
   // Callback function
   std::function<bool(CallSite)> CallSiteCheck = [&](CallSite CS) -> bool {
     assert(CS && "Sanity check: Call site was not initialized properly!");
 
     // Check that DereferenceableAA is AADereferenceableCallSiteArgument.
     if (auto *DereferenceableAA =
             A.getAAFor<AADereferenceable>(*this, *CS.getInstruction(), ArgNo)) {
-      ImmutableCallSite ICS(&DereferenceableAA->getAnchoredValue());
+      ImmutableCallSite ICS(
+          &DereferenceableAA->getIRPosition().getAnchorValue());
       if (ICS && CS.getInstruction() == ICS.getInstruction()) {
         takeAssumedDerefBytesMinimum(
             DereferenceableAA->getAssumedDereferenceableBytes());
         IsNonNull &= DereferenceableAA->isAssumedNonNull();
         IsGlobal &= DereferenceableAA->isAssumedGlobal();
         return isValidState();
       }
     }
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)
-      : AADereferenceableImpl(CS.getArgOperand(ArgNo), *CS.getInstruction()),
-        ArgNo(ArgNo) {}
+      : AADereferenceableImpl(CS.getArgOperand(ArgNo), *CS.getInstruction(),
+                              ArgNo) {}
 
   /// See AbstractAttribute::initialize(...).
   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));
+    CallSite CS(&getAnchorValue());
+    if (CS.paramHasAttr(getArgNo(), Attribute::Dereferenceable))
+      takeKnownDerefBytesMaximum(CS.getDereferenceableBytes(getArgNo()));
+
+    if (CS.paramHasAttr(getArgNo(), Attribute::DereferenceableOrNull))
+      takeKnownDerefBytesMaximum(CS.getDereferenceableOrNullBytes(getArgNo()));
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
   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,
                                               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);
 
-  syncNonNull(A.getAAFor<AANonNull>(*this, getAnchoredValue(), ArgNo));
+  syncNonNull(A.getAAFor<AANonNull>(*this, getAnchorValue(), getArgNo()));
   bool IsNonNull = isAssumedNonNull();
   bool IsGlobal = isKnownGlobal();
 
   takeAssumedDerefBytesMinimum(
       computeAssumedDerefenceableBytes(A, V, IsNonNull, IsGlobal));
   updateAssumedNonNullGlobalState(IsNonNull, IsGlobal);
 
   return BeforeState == static_cast<DerefState>(*this) ? ChangeStatus::UNCHANGED
                                                        : ChangeStatus::CHANGED;
 }
 
 // ------------------------ Align Argument Attribute ------------------------
 
-struct AAAlignImpl : AAAlign, IntegerState {
+struct AAAlignImpl : AAAlign, IntegerState, IRPosition {
+  IRPositionConstructorForward(AAAlignImpl);
+  IRPositionGetter(*this);
 
   // Max alignemnt value allowed in IR
   static const unsigned MAX_ALIGN = 1U << 29;
 
-  AAAlignImpl(Value *AssociatedVal, Value &AnchoredValue)
-      : AAAlign(AssociatedVal, AnchoredValue), IntegerState(MAX_ALIGN) {}
-
-  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, InformationCache &InfoCache) override {
+    takeAssumedMinimum(MAX_ALIGN);
+
     Function &F = getAnchorScope();
 
-    unsigned AttrIdx =
-        getAttrIndex(getManifestPosition(), getArgNo(getAnchoredValue()));
+    unsigned AttrIdx = getIRPosition().getAttrIdx();
 
     // Already the function has align attribute on return value or argument.
     if (F.getAttributes().hasAttribute(AttrIdx, Attribute::Alignment))
       addKnownBits(
           F.getAttribute(AttrIdx, Attribute::Alignment).getAlignment());
   }
 
   /// See AbstractAttribute::getDeducedAttributes
   virtual void
   getDeducedAttributes(SmallVectorImpl<Attribute> &Attrs) const override {
-    LLVMContext &Ctx = AnchoredVal.getContext();
+    LLVMContext &Ctx = AnchorVal.getContext();
 
     Attrs.emplace_back(Attribute::getWithAlignment(Ctx, getAssumedAlign()));
   }
 };
 
 /// Align attribute for function return value.
-struct AAAlignReturned : AAAlignImpl {
+struct AAAlignReturned final : AAAlignImpl {
 
-  AAAlignReturned(Function &F) : AAAlignImpl(F) {}
-
-  /// See AbstractAttribute::getManifestPosition().
-  virtual ManifestPosition getManifestPosition() const override {
-    return MP_RETURNED;
-  }
+  AAAlignReturned(Function &F) : AAAlignImpl(F, IRP_RETURNED) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
 ChangeStatus AAAlignReturned::updateImpl(Attributor &A,
                                          InformationCache &InfoCache) {
   Function &F = getAnchorScope();
ChangeStatus AAAlignReturned::updateImpl(Attributor &A,
   if (!AARetValImpl->checkForallReturnedValues(Pred))
     return indicatePessimisticFixpoint();
 
   return (getAssumed() != BeforeState) ? ChangeStatus::CHANGED
                                        : ChangeStatus::UNCHANGED;
 }
 
 /// Align attribute for function argument.
-struct AAAlignArgument : AAAlignImpl {
+struct AAAlignArgument final : AAAlignImpl {
 
   AAAlignArgument(Argument &A) : AAAlignImpl(A) {}
 
-  /// See AbstractAttribute::getManifestPosition().
-  virtual ManifestPosition getManifestPosition() const override {
-    return MP_ARGUMENT;
-  }
-
   /// See AbstractAttribute::updateImpl(...).
   virtual ChangeStatus updateImpl(Attributor &A,
                                   InformationCache &InfoCache) override;
 };
 
 ChangeStatus AAAlignArgument::updateImpl(Attributor &A,
                                          InformationCache &InfoCache) {
 
   Function &F = getAnchorScope();
-  Argument &Arg = cast<Argument>(getAnchoredValue());
+  Argument &Arg = cast<Argument>(getAnchorValue());
 
   unsigned ArgNo = Arg.getArgNo();
   const DataLayout &DL = F.getParent()->getDataLayout();
 
   auto BeforeState = getAssumed();
 
   // Callback function
   std::function<bool(CallSite)> CallSiteCheck = [&](CallSite CS) {
     assert(CS && "Sanity check: Call site was not initialized properly!");
 
     auto *AlignAA = A.getAAFor<AAAlign>(*this, *CS.getInstruction(), ArgNo);
 
     // Check that AlignAA is AAAlignCallSiteArgument.
     if (AlignAA) {
-      ImmutableCallSite ICS(&AlignAA->getAnchoredValue());
+      ImmutableCallSite ICS(&AlignAA->getIRPosition().getAnchorValue());
       if (ICS && CS.getInstruction() == ICS.getInstruction()) {
         takeAssumedMinimum(AlignAA->getAssumedAlign());
         return isValidState();
       }
     }
 
     Value *V = CS.getArgOperand(ArgNo);
     takeAssumedMinimum(V->getPointerAlignment(DL));
     return isValidState();
   };
 
   if (!A.checkForAllCallSites(F, CallSiteCheck, true, *this))
     indicatePessimisticFixpoint();
 
   return BeforeState == getAssumed() ? ChangeStatus::UNCHANGED
                                      : ChangeStatus ::CHANGED;
 }
 
-struct AAAlignCallSiteArgument : AAAlignImpl {
+struct AAAlignCallSiteArgument final : AAAlignImpl {
 
   /// See AANonNullImpl::AANonNullImpl(...).
   AAAlignCallSiteArgument(CallSite CS, unsigned ArgNo)
-      : AAAlignImpl(CS.getArgOperand(ArgNo), *CS.getInstruction()),
-        ArgNo(ArgNo) {}
+      : AAAlignImpl(CS.getArgOperand(ArgNo), *CS.getInstruction(), ArgNo) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A, InformationCache &InfoCache) override {
-    CallSite CS(&getAnchoredValue());
+    CallSite CS(&getAnchorValue());
     takeKnownMaximum(getAssociatedValue()->getPointerAlignment(
         getAnchorScope().getParent()->getDataLayout()));
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
   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,
                                                  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) : AANoReturn(F) {}
+struct AANoReturnImpl : public AANoReturn, BooleanState, IRPosition {
+  IRPositionConstructorForward(AANoReturnImpl);
+  IRPositionGetter(*this);
 
   /// 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, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
virtual ChangeStatus updateImpl(Attributor &A,
     if (!LivenessAA ||
         LivenessAA->isLiveInstSet(ReturnInsts.begin(), ReturnInsts.end()))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 };
 
+struct AANoReturnFunction final : AANoReturnImpl {
+  AANoReturnFunction(Function &F) : AANoReturnImpl(F, IRP_FUNCTION) {}
+};
+
 /// ----------------------------------------------------------------------------
 ///                               Attributor
 /// ----------------------------------------------------------------------------
 
 bool Attributor::checkForAllCallSites(Function &F,
                                       std::function<bool(CallSite)> &Pred,
                                       bool RequireAllCallSites,
                                       AbstractAttribute &AA) {
void Attributor::identifyDefaultAbstractAttributes(
   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));
+      registerAA(*new AAReturnedValuesFunction(F));
 
     if (ReturnType->isPointerTy()) {
       // Every function with pointer return type might be marked align.
       if (!Whitelist || Whitelist->count(&AAAlignReturned::ID))
         registerAA(*new AAAlignReturned(F));
 
       // Every function with pointer return type might be marked nonnull.
       if (!Whitelist || Whitelist->count(&AANonNullReturned::ID))

 
 /// Helpers to ease debugging through output streams and print calls.
 ///
 ///{
 raw_ostream &llvm::operator<<(raw_ostream &OS, ChangeStatus S) {
   return OS << (S == ChangeStatus::CHANGED ? "changed" : "unchanged");
 }
 
-raw_ostream &llvm::operator<<(raw_ostream &OS,
-                              AbstractAttribute::ManifestPosition AP) {
+raw_ostream &llvm::operator<<(raw_ostream &OS, IRPosition::Kind AP) {
   switch (AP) {
-  case AbstractAttribute::MP_ARGUMENT:
+  case IRPosition::IRP_ARGUMENT:
     return OS << "arg";
-  case AbstractAttribute::MP_CALL_SITE_ARGUMENT:
+  case IRPosition::IRP_CALL_SITE_ARGUMENT:
     return OS << "cs_arg";
-  case AbstractAttribute::MP_FUNCTION:
+  case IRPosition::IRP_FUNCTION:
     return OS << "fn";
-  case AbstractAttribute::MP_RETURNED:
+  case IRPosition::IRP_RETURNED:
     return OS << "fn_ret";
   }
   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 ? AV->getName() : "n/a") << " ["
+            << Pos.getAnchorValue().getName() << "@" << Pos.getArgNo() << "]}";
+}
+
 raw_ostream &llvm::operator<<(raw_ostream &OS, const AbstractState &S) {
   return OS << (!S.isValidState() ? "top" : (S.isAtFixpoint() ? "fix" : ""));
 }
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const AbstractAttribute &AA) {
   AA.print(OS);
   return OS;
 }
 
 void AbstractAttribute::print(raw_ostream &OS) const {
-  OS << "[" << getManifestPosition() << "][" << getAsStr() << "]["
-     << AnchoredVal.getName() << "]";
+  OS << "[P: " << getIRPosition() << "][" << getAsStr() << "][S: " << getState()
+     << "]";
 }
 ///}
 
 /// ----------------------------------------------------------------------------
 ///                       Pass (Manager) Boilerplate
 /// ----------------------------------------------------------------------------
 
 static bool runAttributorOnModule(Module &M) {

 
 Pass *llvm::createAttributorLegacyPass() { return new AttributorLegacyPass(); }
 
 char AttributorLegacyPass::ID = 0;
 
 const char AAReturnedValues::ID = 0;
 const char AANoUnwind::ID = 0;
 const char AANoSync::ID = 0;
-const char AANoFreeFunction::ID = 0;
+const char AANoFreeImpl::ID = 0;
 const char AANonNull::ID = 0;
 const char AANoRecurse::ID = 0;
 const char AAWillReturn::ID = 0;
 const char AANoAlias::ID = 0;
 const char AANoReturn::ID = 0;
 const char AAIsDead::ID = 0;
 const char AADereferenceable::ID = 0;
 const char AAAlign::ID = 0;
 
 INITIALIZE_PASS_BEGIN(AttributorLegacyPass, "attributor",
                       "Deduce and propagate attributes", false, false)
 INITIALIZE_PASS_END(AttributorLegacyPass, "attributor",
                     "Deduce and propagate attributes", false, false)