[Attributor] Introduce the IRAttribute helper struct

[jdoerfert]

Summary

Certain properties, e.g., an AttrKind, are not shared among all abstract
attributes. This patch extracts the functionality into a helper struct.

[sstefan1]

LGTM.

[aprantl]

This series of commits broke the modular builds of LLVM.

See http://green.lab.llvm.org/green/view/Clang/job/clang-stage2-Rthinlto/242/
http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/32798/consoleFull#-285067057a1ca8a51-895e-46c6-af87-ce24fa4cd561

I think the problem that the virtual method definitions in the modular headers pull in link-time dependencies for every client that imports the IPO module. The correct fix is likely to move all the virtual function bodies into the respective .cpp files. Can you please either revert the patch series or quickly fix this?

thanks!

[RKSimon]

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

959

@jdoerfert Is this correct? I'm seeing cppcheck warnings that these are missing override specifiers.

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

 // have to change. Generally, we assume abstract attribute state to be a finite
 // 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 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.
+// generate a single or multiple LLVM-IR attributes already in the helper struct
+// IRAttribute. In the simplest case, a subclass inherits from IRAttribute with
+// a proper Attribute::AttrKind as template parameter. 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 AbstractAttribute or IRAttribute 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
explicit IRPosition(Value *AssociatedVal, Value &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!");
   }
 
+#define IRPositionConstructorForward(NAME, BASE)                               \
+  explicit NAME(Argument &Arg) : BASE(Arg) {}                                  \
+  explicit NAME(Function &Fn, IRPosition::Kind PK) : BASE(Fn, PK) {}           \
+  NAME(Value *AssociatedVal, Value &AnchorVal, unsigned ArgumentNo)            \
+      : BASE(AssociatedVal, AnchorVal, ArgumentNo) {}
+
   IRPosition(const IRPosition &AAP)
       : IRPosition(AAP.AssociatedVal, AAP.AnchorVal, AAP.AttributeIdx) {}
 
   /// Virtual destructor.
   virtual ~IRPosition() {}
 
   /// Return the value this abstract attribute is anchored with.
   ///
protected:
 
   /// The value this abstract attribute is anchored at.
   Value &AnchorVal;
 
   /// The index in the attribute list.
   int AttributeIdx;
 };
 
+/// Helper class that provides common functionality to manifest IR attributes.
+template <Attribute::AttrKind AK, typename Base>
+struct IRAttribute : public IRPosition, public Base {
+
+  /// Constructors for the IRPosition.
+  ///
+  ///{
+  IRPositionConstructorForward(IRAttribute, IRPosition);
+  ///}
+
+  /// See AbstractAttribute::manifest(...).
+  virtual ChangeStatus manifest(Attributor &A);
+
+  /// Return the kind that identifies the abstract attribute implementation.
+  Attribute::AttrKind getAttrKind() const { return AK; }
+
+  /// Return the deduced attributes in \p Attrs.
+  virtual void getDeducedAttributes(LLVMContext &Ctx,
+                                    SmallVectorImpl<Attribute> &Attrs) const {
+    Attrs.emplace_back(Attribute::get(Ctx, getAttrKind()));
+  }
+
+  /// Return an IR position, see struct IRPosition.
+  ///
+  ///{
+  IRPosition &getIRPosition() { return *this; }
+  const IRPosition &getIRPosition() const { return *this; }
+  ///}
+};
+
 /// 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
struct AbstractAttribute {
   virtual void initialize(Attributor &A, InformationCache &InfoCache) {}
 
   /// Return the internal abstract state for inspection.
   virtual const AbstractState &getState() 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 = 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()); }
 
   /// This function should return the "summarized" assumed state as string.
   virtual const std::string getAsStr() const = 0;
   ///}
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);
+  virtual ChangeStatus manifest(Attributor &A) {
+    return ChangeStatus::UNCHANGED;
+  }
   /// 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.

 
 Pass *createAttributorLegacyPass();
 
 /// ----------------------------------------------------------------------------
 ///                       Abstract Attribute Classes
 /// ----------------------------------------------------------------------------
 
 /// An abstract attribute for the returned values of a function.
-struct AAReturnedValues : public AbstractAttribute {
+struct AAReturnedValues
+    : public IRAttribute<Attribute::Returned, AbstractAttribute> {
+  IRPositionConstructorForward(AAReturnedValues, IRAttribute);
 
   /// 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 {
-
-  /// See AbstractAttribute::getAttrKind()/
-  Attribute::AttrKind getAttrKind() const override {
-    return Attribute::NoUnwind;
-  }
+struct AANoUnwind : public IRAttribute<Attribute::NoUnwind, AbstractAttribute> {
+  IRPositionConstructorForward(AANoUnwind, IRAttribute);
 
   /// 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 {
-
-  /// See AbstractAttribute::getAttrKind().
-  Attribute::AttrKind getAttrKind() const override { return Attribute::NoSync; }
+struct AANoSync : public IRAttribute<Attribute::NoSync, AbstractAttribute> {
+  IRPositionConstructorForward(AANoSync, IRAttribute);
 
   /// 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 {
+struct AANonNull : public IRAttribute<Attribute::NonNull, AbstractAttribute> {
+  IRPositionConstructorForward(AANonNull, IRAttribute);
 
   /// 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::getAttrKind()
-  virtual Attribute::AttrKind getAttrKind() const override {
-    return Attribute::NoRecurse;
-  }
+struct AANoRecurse
+    : public IRAttribute<Attribute::NoRecurse, AbstractAttribute> {
+  IRPositionConstructorForward(AANoRecurse, IRAttribute);
 
   /// 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::getAttrKind()
-  virtual Attribute::AttrKind getAttrKind() const override {
-    return Attribute::WillReturn;
-  }
+struct AAWillReturn
+    : public IRAttribute<Attribute::WillReturn, AbstractAttribute> {
+  IRPositionConstructorForward(AAWillReturn, IRAttribute);
 
   /// 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 {
+struct AANoAlias : public IRAttribute<Attribute::NoAlias, AbstractAttribute> {
+  IRPositionConstructorForward(AANoAlias, IRAttribute);
 
   /// 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 nofree.
+struct AANoFree : public IRAttribute<Attribute::NoFree, AbstractAttribute> {
+  IRPositionConstructorForward(AANoFree, IRAttribute);
+
+  /// Return true if "nofree" is known.
+  virtual bool isKnownNoFree() const = 0;
+
+  /// Return true if "nofree" is assumed.
+  virtual bool isAssumedNoFree() const = 0;
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An AbstractAttribute for noreturn.
-struct AANoReturn : public AbstractAttribute {
+struct AANoReturn : public IRAttribute<Attribute::NoReturn, AbstractAttribute> {
+  IRPositionConstructorForward(AANoReturn, IRAttribute);
 
   /// 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::getAttrKind()
-  Attribute::AttrKind getAttrKind() const override { return Attribute::None; }
+struct AAIsDead : public AbstractAttribute, public IRPosition {
+  IRPositionConstructorForward(AAIsDead, IRPosition);
 
   /// 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.
for (const auto &I : llvm::make_range(begin, end)) {
 
       if (!isAssumedDead(I))
         return true;
     }
 
     return false;
   }
 
+  /// Return an IR position, see struct IRPosition.
+  ///
+  ///{
+  IRPosition &getIRPosition() { return *this; }
+  const IRPosition &getIRPosition() const { return *this; }
+  ///}
+
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract interface for all dereferenceable attribute.
-struct AADereferenceable : public AbstractAttribute {
+struct AADereferenceable
+    : public IRAttribute<Attribute::Dereferenceable, AbstractAttribute> {
+  IRPositionConstructorForward(AADereferenceable, IRAttribute);
 
   /// 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.
   virtual bool isAssumedGlobal() const = 0;
 
   /// Return true if we know that underlying value is
   /// dereferenceable(_or_null) globally.
   virtual bool isKnownGlobal() const = 0;
 
   /// Return assumed dereferenceable bytes.
   virtual uint32_t getAssumedDereferenceableBytes() const = 0;
 
   /// Return known dereferenceable bytes.
   virtual uint32_t getKnownDereferenceableBytes() const = 0;
 
-  /// See AbastractState::getAttrKind().
-  Attribute::AttrKind getAttrKind() const override {
-    return Attribute::Dereferenceable;
-  }
-
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 /// An abstract interface for all align attributes.
-struct AAAlign : public AbstractAttribute {
+struct AAAlign : public IRAttribute<Attribute::Alignment, AbstractAttribute> {
+  IRPositionConstructorForward(AAAlign, IRAttribute);
 
   /// Return assumed alignment.
   virtual unsigned getAssumedAlign() const = 0;
 
   /// Return known alignemnt.
   virtual unsigned getKnownAlign() const = 0;
 
-  /// See AbastractState::getAttrKind().
-  Attribute::AttrKind getAttrKind() const override {
-    return Attribute::Alignment;
-  }
-
   /// 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 AbstractAttribute::update(Attributor &A,
   HasChanged = updateImpl(A, InfoCache);
 
   LLVM_DEBUG(dbgs() << "[Attributor] Update " << HasChanged << " " << *this
                     << "\n");
 
   return HasChanged;
 }
 
-ChangeStatus AbstractAttribute::manifest(Attributor &A) {
-  assert(getState().isValidState() &&
+template <Attribute::AttrKind AK, typename Base>
+ChangeStatus IRAttribute<AK, Base>::manifest(Attributor &A) {
+  assert(this->getState().isValidState() &&
          "Attempted to manifest an invalid state!");
   assert(getIRPosition().getAssociatedValue() &&
          "Attempted to manifest an attribute without associated value!");
 
   ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
 
-  IRPosition &Pos = getIRPosition();
-  Function &ScopeFn = Pos.getAnchorScope();
+  Function &ScopeFn = getAnchorScope();
   LLVMContext &Ctx = ScopeFn.getContext();
-  IRPosition::Kind PK = Pos.getPositionKind();
+  IRPosition::Kind PK = getPositionKind();
 
   SmallVector<Attribute, 4> DeducedAttrs;
-  getDeducedAttributes(DeducedAttrs);
+  getDeducedAttributes(Ctx, 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.
 
   AttributeList Attrs;
   switch (PK) {
   case IRPosition::IRP_ARGUMENT:
   case IRPosition::IRP_FUNCTION:
   case IRPosition::IRP_RETURNED:
     Attrs = ScopeFn.getAttributes();
     break;
   case IRPosition::IRP_CALL_SITE_ARGUMENT:
-    Attrs = ImmutableCallSite(&Pos.getAnchorValue()).getAttributes();
+    Attrs = ImmutableCallSite(&getAnchorValue()).getAttributes();
     break;
   }
 
   for (const Attribute &Attr : DeducedAttrs) {
-    if (!addIfNotExistent(Ctx, Attr, Attrs, Pos.getAttrIdx()))
+    if (!addIfNotExistent(Ctx, Attr, Attrs, getAttrIdx()))
       continue;
 
     HasChanged = ChangeStatus::CHANGED;
     bookkeeping(PK, Attr);
   }
 
   if (HasChanged == ChangeStatus::UNCHANGED)
     return HasChanged;
 
   switch (PK) {
   case IRPosition::IRP_ARGUMENT:
   case IRPosition::IRP_FUNCTION:
   case IRPosition::IRP_RETURNED:
     ScopeFn.setAttributes(Attrs);
     break;
   case IRPosition::IRP_CALL_SITE_ARGUMENT:
-    CallSite(&Pos.getAnchorValue()).setAttributes(Attrs);
+    CallSite(&getAnchorValue()).setAttributes(Attrs);
   }
 
   return HasChanged;
 }
 
 /// -----------------------NoUnwind Function Attribute--------------------------
 
-#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);
+struct AANoUnwindImpl : AANoUnwind, BooleanState {
+  IRPositionConstructorForward(AANoUnwindImpl, AANoUnwind);
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   const std::string getAsStr() const override {

 
 /// --------------------- 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 : public AAReturnedValues,
-                             public AbstractState,
-                             public IRPosition {
+class AAReturnedValuesImpl : public AAReturnedValues, public AbstractState {
 
   /// 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:
-  IRPositionConstructorForward(AAReturnedValuesImpl);
-  IRPositionGetter(*this);
+  IRPositionConstructorForward(AAReturnedValuesImpl, AAReturnedValues);
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A, InformationCache &InfoCache) override {
     // Reset the state.
     AssociatedVal = nullptr;
     IsFixed = false;
     IsValidState = true;
     HasOverdefinedReturnedCalls = false;
ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) {
 
   // Bookkeeping.
   NumFnUniqueReturned++;
 
   // If the assumed unique return value is an argument, annotate it.
   if (auto *UniqueRVArg = dyn_cast<Argument>(UniqueRV.getValue())) {
     setAssociatedValue(UniqueRVArg);
     setAttributeIdx(UniqueRVArg->getArgNo() + AttributeList::FirstArgIndex);
-    Changed = AbstractAttribute::manifest(A) | Changed;
+    Changed = IRAttribute::manifest(A) | Changed;
   }
 
   return Changed;
 }
 
 const std::string AAReturnedValuesImpl::getAsStr() const {
   return (isAtFixpoint() ? "returns(#" : "may-return(#") +
          (isValidState() ? std::to_string(getNumReturnValues()) : "?") +
if (!HasCallSite) {
     return ChangeStatus::CHANGED;
   }
 
   return Changed;
 }
 
 /// ------------------------ NoSync Function Attribute -------------------------
 
-struct AANoSyncImpl : AANoSync, BooleanState, IRPosition {
-  IRPositionConstructorForward(AANoSyncImpl);
-  IRPositionGetter(*this);
+struct AANoSyncImpl : AANoSync, BooleanState {
+  IRPositionConstructorForward(AANoSyncImpl, AANoSync);
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   const std::string getAsStr() const override {
for (unsigned Opcode : Opcodes) {
     }
   }
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ No-Free Attributes ----------------------------
 
-struct AANoFreeImpl : AbstractAttribute, BooleanState, IRPosition {
-  IRPositionConstructorForward(AANoFreeImpl);
-  IRPositionGetter(*this);
+struct AANoFreeImpl : public AANoFree, BooleanState {
+  IRPositionConstructorForward(AANoFreeImpl, AANoFree);
 
   /// See AbstractAttribute::getState()
   ///{
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   ///}
 
   /// 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(); }
+  bool isAssumedNoFree() const override { return getAssumed(); }
 
   /// Return true if "nofree" is known.
-  bool isKnownNoFree() const { return getKnown(); }
-
-  /// Unique ID (due to the unique address)
-  static const char ID;
+  bool isKnownNoFree() const override { return getKnown(); }
 };
 
 struct AANoFreeFunction final : public AANoFreeImpl {
   AANoFreeFunction(Function &F) : AANoFreeImpl(F, IRP_FUNCTION) {}
 };
 
 ChangeStatus AANoFreeImpl::updateImpl(Attributor &A,
                                       InformationCache &InfoCache) {
for (Instruction *I : OpcodeInstMap[Opcode]) {
           !ICS.hasFnAttr(Attribute::NoFree))
         return indicatePessimisticFixpoint();
     }
   }
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ NonNull Argument Attribute ------------------------
-struct AANonNullImpl : AANonNull, BooleanState, IRPosition {
-  IRPositionConstructorForward(AANonNullImpl);
-  IRPositionGetter(*this);
+struct AANonNullImpl : AANonNull, BooleanState {
+  IRPositionConstructorForward(AANonNullImpl, AANonNull);
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AbstractAttribute::getAsStr().
AANonNullCallSiteArgument::updateImpl(Attributor &A,
   if (!NonNullAA || !NonNullAA->isAssumedNonNull())
     return indicatePessimisticFixpoint();
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ Will-Return Attributes ----------------------------
 
-struct AAWillReturnImpl : public AAWillReturn, BooleanState, IRPosition {
-  IRPositionConstructorForward(AAWillReturnImpl);
-  IRPositionGetter(*this);
+struct AAWillReturnImpl : public AAWillReturn, BooleanState {
+  IRPositionConstructorForward(AAWillReturnImpl, AAWillReturn);
 
   /// See AAWillReturn::isKnownWillReturn().
   bool isKnownWillReturn() const override { return getKnown(); }
 
   /// See AAWillReturn::isAssumedWillReturn().
   bool isAssumedWillReturn() const override { return getAssumed(); }
 
   /// See AbstractAttribute::getState(...).
for (unsigned Opcode :
     }
   }
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ NoAlias Argument Attribute ------------------------
 
-struct AANoAliasImpl : AANoAlias, BooleanState, IRPosition {
-  IRPositionConstructorForward(AANoAliasImpl);
-  IRPositionGetter(*this);
+struct AANoAliasImpl : AANoAlias, BooleanState {
+  IRPositionConstructorForward(AANoAliasImpl, AANoAlias);
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   const std::string getAsStr() const override {
ChangeStatus AANoAliasReturned::updateImpl(Attributor &A,
   if (!AARetValImpl->checkForallReturnedValues(Pred))
     return indicatePessimisticFixpoint();
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// -------------------AAIsDead Function Attribute-----------------------
 
-struct AAIsDeadImpl : public AAIsDead, BooleanState, IRPosition {
-  IRPositionConstructorForward(AAIsDeadImpl);
-  IRPositionGetter(*this);
+struct AAIsDeadImpl : public AAIsDead, BooleanState {
+  IRPositionConstructorForward(AAIsDeadImpl, AAIsDead);
 
   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 DerefState : AbstractState {
 
   /// Equality for DerefState.
   bool operator==(const DerefState &R) {
     return this->DerefBytesState == R.DerefBytesState &&
            this->NonNullGlobalState == R.NonNullGlobalState;
   }
 };
 
-struct AADereferenceableImpl : AADereferenceable, DerefState, IRPosition {
-  IRPositionConstructorForward(AADereferenceableImpl);
-  IRPositionGetter(*this);
+struct AADereferenceableImpl : AADereferenceable, DerefState {
+  IRPositionConstructorForward(AADereferenceableImpl, AADereferenceable);
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   /// }
 
   /// See AADereferenceable::getAssumedDereferenceableBytes().
bool isAssumedNonNull() const override {
     return NonNullGlobalState.isAssumed(DEREF_NONNULL);
   }
 
   /// See AADereferenceable::isKnownNonNull().
   bool isKnownNonNull() const override {
     return NonNullGlobalState.isKnown(DEREF_NONNULL);
   }
 
-  void getDeducedAttributes(SmallVectorImpl<Attribute> &Attrs) const override {
-    LLVMContext &Ctx = AnchorVal.getContext();
-
+  void getDeducedAttributes(LLVMContext &Ctx,
+                            SmallVectorImpl<Attribute> &Attrs) const override {
     // TODO: Add *_globally support
     if (isAssumedNonNull())
       Attrs.emplace_back(Attribute::getWithDereferenceableBytes(
           Ctx, getAssumedDereferenceableBytes()));
     else
       Attrs.emplace_back(Attribute::getWithDereferenceableOrNullBytes(
           Ctx, getAssumedDereferenceableBytes()));
   }
AADereferenceableCallSiteArgument::updateImpl(Attributor &A,
   updateAssumedNonNullGlobalState(IsNonNull, IsGlobal);
 
   return BeforeState == static_cast<DerefState>(*this) ? ChangeStatus::UNCHANGED
                                                        : ChangeStatus::CHANGED;
 }
 
 // ------------------------ Align Argument Attribute ------------------------
 
-struct AAAlignImpl : AAAlign, IntegerState, IRPosition {
-  IRPositionConstructorForward(AAAlignImpl);
-  IRPositionGetter(*this);
+struct AAAlignImpl : AAAlign, IntegerState {
+  IRPositionConstructorForward(AAAlignImpl, AAAlign);
 
   // Max alignemnt value allowed in IR
   static const unsigned MAX_ALIGN = 1U << 29;
 
   /// See AbstractAttribute::getState()
   /// {
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
void initialize(Attributor &A, InformationCache &InfoCache) override {
     // 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 = AnchorVal.getContext();
-
+  getDeducedAttributes(LLVMContext &Ctx,
+                       SmallVectorImpl<Attribute> &Attrs) const override {
     Attrs.emplace_back(Attribute::getWithAlignment(Ctx, getAssumedAlign()));
   }
 };
 
 /// Align attribute for function return value.
 struct AAAlignReturned final : AAAlignImpl {
 
   AAAlignReturned(Function &F) : AAAlignImpl(F, IRP_RETURNED) {}
ChangeStatus AAAlignCallSiteArgument::updateImpl(Attributor &A,
   else
     indicatePessimisticFixpoint();
 
   return BeforeState == getAssumed() ? ChangeStatus::UNCHANGED
                                      : ChangeStatus::CHANGED;
 }
 
 /// ------------------ Function No-Return Attribute ----------------------------
-struct AANoReturnImpl : public AANoReturn, BooleanState, IRPosition {
-  IRPositionConstructorForward(AANoReturnImpl);
-  IRPositionGetter(*this);
+struct AANoReturnImpl : public AANoReturn, BooleanState {
+  IRPositionConstructorForward(AANoReturnImpl, AANoReturn);
 
   /// 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.

 
 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 AANoFreeImpl::ID = 0;
+const char AANoFree::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)