[Attributor] Use proper ID for attribute lookup

[jdoerfert]

Summary

The new scheme is similar to the pass manager and dyn_cast scheme where
we identify classes by the address of a static member. This is better
than the old scheme in which we had to "invent" new Attributor enums if
there was no corresponding one.

[uenoku]

To use the address as their id seems very reasonable.
I think we need to modify some comments which refer to AAType::ID.

Otherwise, LGTM.

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

226

"default attribute kind" to "attribute id" or something like that.

281

"attribute kinds(Attribute::AttrKind) " to "attribute id(AAType::ID)" or something like that.

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

struct Attributor {
   /// the one reasoning about the "captured" state for the argument or the one
   /// reasoning on the memory access behavior of the function as a whole.
   template <typename AAType>
   const AAType *getAAFor(AbstractAttribute &QueryingAA, const Value &V,
                          int ArgNo = -1) {
     static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
                   "Cannot query an attribute with a type not derived from "
                   "'AbstractAttribute'!");
-    assert(AAType::ID != Attribute::None &&
-           "Cannot lookup generic abstract attributes!");
 
     // Determine the argument number automatically for llvm::Arguments if none
     // is set. Do not override a given one as it could be a use of the argument
     // in a call site.
     if (ArgNo == -1)
       if (auto *Arg = dyn_cast<Argument>(&V))
         ArgNo = Arg->getArgNo();
 
     // If a function was given together with an argument number, perform the
     // lookup for the actual argument instead. Don't do it for variadic
     // arguments.
     if (ArgNo >= 0 && isa<Function>(&V) &&
         cast<Function>(&V)->arg_size() > (size_t)ArgNo)
       return getAAFor<AAType>(
           QueryingAA, *(cast<Function>(&V)->arg_begin() + ArgNo), ArgNo);
 
     // Lookup the abstract attribute of type AAType. If found, return it after
     // registering a dependence of QueryingAA on the one returned attribute.
     const auto &KindToAbstractAttributeMap = AAMap.lookup({&V, ArgNo});
     if (AAType *AA = static_cast<AAType *>(
-            KindToAbstractAttributeMap.lookup(AAType::ID))) {
+            KindToAbstractAttributeMap.lookup(&AAType::ID))) {
       // Do not return an attribute with an invalid state. This minimizes checks
       // at the calls sites and allows the fallback below to kick in.
       if (AA->getState().isValidState()) {
         QueryMap[AA].insert(&QueryingAA);
         return AA;
       }
     }
 
struct Attributor {
   /// Introduce a new abstract attribute into the fixpoint analysis.
   ///
   /// Note that ownership of the attribute is given to the Attributor. It will
   /// invoke delete for the Attributor on destruction of the Attributor.
   ///
   /// Attributes are identified by
   ///  (1) their anchored value (see AA.getAnchoredValue()),
   ///  (2) their argument number (\p ArgNo, or Argument::getArgNo()), and
   ///  (3) their default attribute kind (see AAType::ID).
   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();
     if (ArgNo == -1)
       if (auto *Arg = dyn_cast<Argument>(&AnchoredVal))
         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[{&AnchoredVal, 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.
   /// \param InfoCache A cache for information queryable by the new attributes.
   /// \param Whitelist If not null, a set limiting the attribute opportunities.
   ///
   /// Note that abstract attribute instances are generally created even if the
   /// IR already contains the information they would deduce. The most important
   /// reason for this is the single interface, the one of the abstract attribute
   /// instance, which can be queried without the need to look at the IR in
   /// various places.
   void identifyDefaultAbstractAttributes(
       Function &F, InformationCache &InfoCache,
-      DenseSet</* Attribute::AttrKind */ unsigned> *Whitelist = nullptr);
+      DenseSet<const char *> *Whitelist = nullptr);
 
   /// Check \p Pred on all function call sites.
   ///
   /// This method will evaluate \p Pred on call sites and return
   /// true if \p Pred holds in every call sites. However, this is only possible
   /// all call sites are known, hence the function has internal linkage.
   bool checkForAllCallSites(Function &F, std::function<bool(CallSite)> &Pred,
                             bool RequireAllCallSites, AbstractAttribute &AA);
 
 private:
   /// The set of all abstract attributes.
   ///{
   using AAVector = SmallVector<AbstractAttribute *, 64>;
   AAVector AllAbstractAttributes;
   ///}
 
   /// A nested map to lookup abstract attributes based on the anchored value and
   /// an argument positions (or -1) on the outer level, and attribute kinds
   /// (Attribute::AttrKind) on the inner level.
   ///{
-  using KindToAbstractAttributeMap = DenseMap<unsigned, AbstractAttribute *>;
+  using KindToAbstractAttributeMap =
+      DenseMap<const char *, AbstractAttribute *>;
   DenseMap<std::pair<const Value *, int>, KindToAbstractAttributeMap> AAMap;
   ///}
 
   /// A map from abstract attributes to the ones that queried them through calls
   /// to the getAAFor<...>(...) method.
   ///{
   using QueryMapTy =
       DenseMap<AbstractAttribute *, SetVector<AbstractAttribute *>>;
struct AAReturnedValues : public AbstractAttribute {
   /// This method will evaluate \p Pred on returned values and return
   /// true if (1) all returned values are known, and (2) \p Pred returned true
   /// for all returned values.
   virtual bool checkForallReturnedValues(
       std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> &Pred)
       const = 0;
 
   /// See AbstractAttribute::getAttrKind()
-  Attribute::AttrKind getAttrKind() const override { return ID; }
+  Attribute::AttrKind getAttrKind() const override {
+    return Attribute::Returned;
+  }
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = 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 ID; }
-
-  static constexpr Attribute::AttrKind ID = Attribute::NoUnwind;
+  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 ID; }
-
-  static constexpr Attribute::AttrKind ID =
-      Attribute::AttrKind(Attribute::NoSync);
+  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 ID; }
+  Attribute::AttrKind getAttrKind() const override {
+    return Attribute::NonNull;
+  }
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = 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;
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = Attribute::NoRecurse;
+  /// 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;
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = Attribute::WillReturn;
+  /// 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 ID; }
+  Attribute::AttrKind getAttrKind() const override {
+    return Attribute::NoAlias;
+  }
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = 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 ID; }
+  Attribute::AttrKind getAttrKind() const override {
+    return Attribute::NoReturn;
+  }
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = 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 ID; }
-
-  static constexpr Attribute::AttrKind ID =
-      Attribute::AttrKind(Attribute::EndAttrKinds + 1);
+  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.
for (const auto &I : llvm::make_range(begin, end)) {
              "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) {}
 
struct AADereferenceable : public AbstractAttribute {
 
   /// 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 ID; }
+  Attribute::AttrKind getAttrKind() const override {
+    return Attribute::Dereferenceable;
+  }
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = Attribute::Dereferenceable;
+  /// 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) {}
 
   /// See AbstractAttribute::AbstractAttribute(...).
   AAAlign(Value *AssociatedVal, Value &AnchoredValue)
       : AbstractAttribute(AssociatedVal, AnchoredValue) {}
 
   /// See AbastractState::getAttrKind().
-  Attribute::AttrKind getAttrKind() const override { return ID; }
+  Attribute::AttrKind getAttrKind() const override {
+    return Attribute::Alignment;
+  }
 
   /// Return assumed alignment.
   virtual unsigned getAssumedAlign() const = 0;
 
   /// Return known alignemnt.
   virtual unsigned getKnownAlign() const = 0;
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = Attribute::Alignment;
+  /// Unique ID (due to the unique address)
+  static const char ID;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H

llvm/lib/Transforms/IPO/Attributor.cpp

struct AANoFreeFunction : AbstractAttribute, BooleanState {
   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 ID; }
+  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(); }
 
-  /// The identifier used by the Attributor for this class of attributes.
-  static constexpr Attribute::AttrKind ID = Attribute::NoFree;
+  /// Unique ID (due to the unique address)
+  static const char ID;
 };
 
 ChangeStatus AANoFreeFunction::updateImpl(Attributor &A,
                                           InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
   auto *LivenessAA = A.getAAFor<AAIsDead>(*this, F);
 
struct AAAlignImpl : AAAlign, IntegerState {
   /// See AbstractAttriubute::initialize(...).
   void initialize(Attributor &A, InformationCache &InfoCache) override {
     Function &F = getAnchorScope();
 
     unsigned AttrIdx =
         getAttrIndex(getManifestPosition(), getArgNo(getAnchoredValue()));
 
     // Already the function has align attribute on return value or argument.
-    if (F.getAttributes().hasAttribute(AttrIdx, ID))
-      addKnownBits(F.getAttribute(AttrIdx, ID).getAlignment());
+    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();
 
     Attrs.emplace_back(Attribute::getWithAlignment(Ctx, getAssumedAlign()));
ChangeStatus Attributor::run(InformationCache &InfoCache) {
   NumAttributesManifested += NumManifested;
   NumAttributesValidFixpoint += NumAtFixpoint;
 
   return ManifestChange;
 }
 
 void Attributor::identifyDefaultAbstractAttributes(
     Function &F, InformationCache &InfoCache,
-    DenseSet</* Attribute::AttrKind */ unsigned> *Whitelist) {
+    DenseSet<const char *> *Whitelist) {
 
   // Check for dead BasicBlocks in every function.
   registerAA(*new AAIsDeadFunction(F));
 
   // Every function might be "will-return".
   registerAA(*new AAWillReturnFunction(F));
 
   // Every function can be nounwind.
   registerAA(*new AANoUnwindFunction(F));
 
   // Every function might be marked "nosync"
   registerAA(*new AANoSyncFunction(F));
 
   // Every function might be "no-free".
   registerAA(*new AANoFreeFunction(F));
 
   // Every function might be "no-return".
   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))
+    if (!Whitelist || Whitelist->count(&AAReturnedValues::ID))
       registerAA(*new AAReturnedValuesImpl(F));
 
     if (ReturnType->isPointerTy()) {
       // Every function with pointer return type might be marked align.
-      if (!Whitelist || Whitelist->count(AAAlignReturned::ID))
+      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))
+      if (!Whitelist || Whitelist->count(&AANonNullReturned::ID))
         registerAA(*new AANonNullReturned(F));
 
       // Every function with pointer return type might be marked noalias.
-      if (!Whitelist || Whitelist->count(AANoAliasReturned::ID))
+      if (!Whitelist || Whitelist->count(&AANoAliasReturned::ID))
         registerAA(*new AANoAliasReturned(F));
 
       // Every function with pointer return type might be marked
       // dereferenceable.
       if (ReturnType->isPointerTy() &&
-          (!Whitelist || Whitelist->count(AADereferenceableReturned::ID)))
+          (!Whitelist || Whitelist->count(&AADereferenceableReturned::ID)))
         registerAA(*new AADereferenceableReturned(F));
     }
   }
 
   for (Argument &Arg : F.args()) {
     if (Arg.getType()->isPointerTy()) {
       // Every argument with pointer type might be marked nonnull.
-      if (!Whitelist || Whitelist->count(AANonNullArgument::ID))
+      if (!Whitelist || Whitelist->count(&AANonNullArgument::ID))
         registerAA(*new AANonNullArgument(Arg));
 
       // Every argument with pointer type might be marked dereferenceable.
-      if (!Whitelist || Whitelist->count(AADereferenceableArgument::ID))
+      if (!Whitelist || Whitelist->count(&AADereferenceableArgument::ID))
         registerAA(*new AADereferenceableArgument(Arg));
 
       // Every argument with pointer type might be marked align.
-      if (!Whitelist || Whitelist->count(AAAlignArgument::ID))
+      if (!Whitelist || Whitelist->count(&AAAlignArgument::ID))
         registerAA(*new AAAlignArgument(Arg));
     }
   }
 
   // Walk all instructions to find more attribute opportunities and also
   // interesting instructions that might be queried by abstract attributes
   // during their initialization or update.
   auto &ReadOrWriteInsts = InfoCache.FuncRWInstsMap[&F];
for (Instruction &I : instructions(&F)) {
 
     CallSite CS(&I);
     if (CS && CS.getCalledFunction()) {
       for (int i = 0, e = CS.getCalledFunction()->arg_size(); i < e; i++) {
         if (!CS.getArgument(i)->getType()->isPointerTy())
           continue;
 
         // Call site argument attribute "non-null".
-        if (!Whitelist || Whitelist->count(AANonNullCallSiteArgument::ID))
+        if (!Whitelist || Whitelist->count(&AANonNullCallSiteArgument::ID))
           registerAA(*new AANonNullCallSiteArgument(CS, i), i);
 
         // Call site argument attribute "dereferenceable".
         if (!Whitelist ||
-            Whitelist->count(AADereferenceableCallSiteArgument::ID))
+            Whitelist->count(&AADereferenceableCallSiteArgument::ID))
           registerAA(*new AADereferenceableCallSiteArgument(CS, i), i);
 
         // Call site argument attribute "align".
-        if (!Whitelist || Whitelist->count(AAAlignCallSiteArgument::ID))
+        if (!Whitelist || Whitelist->count(&AAAlignCallSiteArgument::ID))
           registerAA(*new AAAlignCallSiteArgument(CS, i), i);
       }
     }
   }
 }
 
 /// Helpers to ease debugging through output streams and print calls.
 ///
struct AttributorLegacyPass : public ModulePass {
   }
 };
 
 } // end anonymous namespace
 
 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 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)