[Attributor][NFC] Move DerefState to header and use StateWrapper

[uenoku]

Summary

In D65402, I want to get DerefState from AADereferenceable but it was not allowed. This patch moves DerefState definition into Attributor.h and makes AADerefenceable inherit StateWrapper.

[jdoerfert]

LGTM

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

struct AAIsDead : public StateWrapper<BooleanState, AbstractAttribute>,
 
   /// Create an abstract attribute view for the position \p IRP.
   static AAIsDead &createForPosition(const IRPosition &IRP, Attributor &A);
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
+/// State for dereferenceable attribute
+struct DerefState : AbstractState {
+
+  /// State representing for dereferenceable bytes.
+  IntegerState DerefBytesState;
+
+  /// State representing that whether the value is globaly dereferenceable.
+  BooleanState GlobalState;
+
+  /// See AbstractState::isValidState()
+  bool isValidState() const override { return DerefBytesState.isValidState(); }
+
+  /// See AbstractState::isAtFixpoint()
+  bool isAtFixpoint() const override {
+    return !isValidState() ||
+           (DerefBytesState.isAtFixpoint() && GlobalState.isAtFixpoint());
+  }
+
+  /// See AbstractState::indicateOptimisticFixpoint(...)
+  ChangeStatus indicateOptimisticFixpoint() override {
+    DerefBytesState.indicateOptimisticFixpoint();
+    GlobalState.indicateOptimisticFixpoint();
+    return ChangeStatus::UNCHANGED;
+  }
+
+  /// See AbstractState::indicatePessimisticFixpoint(...)
+  ChangeStatus indicatePessimisticFixpoint() override {
+    DerefBytesState.indicatePessimisticFixpoint();
+    GlobalState.indicatePessimisticFixpoint();
+    return ChangeStatus::CHANGED;
+  }
+
+  /// Update known dereferenceable bytes.
+  void takeKnownDerefBytesMaximum(uint64_t Bytes) {
+    DerefBytesState.takeKnownMaximum(Bytes);
+  }
+
+  /// Update assumed dereferenceable bytes.
+  void takeAssumedDerefBytesMinimum(uint64_t Bytes) {
+    DerefBytesState.takeAssumedMinimum(Bytes);
+  }
+
+  /// Equality for DerefState.
+  bool operator==(const DerefState &R) {
+    return this->DerefBytesState == R.DerefBytesState &&
+           this->GlobalState == R.GlobalState;
+  }
+
+  /// Inequality for IntegerState.
+  bool operator!=(const DerefState &R) { return !(*this == R); }
+
+  /// See IntegerState::operator^=
+  DerefState operator^=(const DerefState &R) {
+    DerefBytesState ^= R.DerefBytesState;
+    GlobalState ^= R.GlobalState;
+    return *this;
+  }
+
+  /// See IntegerState::operator&=
+  DerefState operator&=(const DerefState &R) {
+    DerefBytesState &= R.DerefBytesState;
+    GlobalState &= R.GlobalState;
+    return *this;
+  }
+
+  /// See IntegerState::operator|=
+  DerefState operator|=(const DerefState &R) {
+    DerefBytesState |= R.DerefBytesState;
+    GlobalState |= R.GlobalState;
+    return *this;
+  }
+
+protected:
+  const AANonNull *NonNullAA = nullptr;
+};
+
 /// An abstract interface for all dereferenceable attribute.
 struct AADereferenceable
-    : public IRAttribute<Attribute::Dereferenceable, AbstractAttribute> {
+    : public IRAttribute<Attribute::Dereferenceable,
+                         StateWrapper<DerefState, AbstractAttribute>> {
   AADereferenceable(const IRPosition &IRP) : IRAttribute(IRP) {}
 
   /// Return true if we assume that the underlying value is nonnull.
-  virtual bool isAssumedNonNull() const = 0;
+  bool isAssumedNonNull() const {
+    return NonNullAA && NonNullAA->isAssumedNonNull();
+  }
 
   /// Return true if we assume that underlying value is
   /// dereferenceable(_or_null) globally.
-  virtual bool isAssumedGlobal() const = 0;
+  bool isAssumedGlobal() const { return GlobalState.getAssumed(); }
 
   /// Return true if we know that underlying value is
   /// dereferenceable(_or_null) globally.
-  virtual bool isKnownGlobal() const = 0;
+  bool isKnownGlobal() const { return GlobalState.getKnown(); }
 
   /// Return assumed dereferenceable bytes.
-  virtual uint32_t getAssumedDereferenceableBytes() const = 0;
+  uint32_t getAssumedDereferenceableBytes() const {
+    return DerefBytesState.getAssumed();
+  }
 
   /// Return known dereferenceable bytes.
-  virtual uint32_t getKnownDereferenceableBytes() const = 0;
+  uint32_t getKnownDereferenceableBytes() const {
+    return DerefBytesState.getKnown();
+  }
 
   /// Create an abstract attribute view for the position \p IRP.
   static AADereferenceable &createForPosition(const IRPosition &IRP,
                                               Attributor &A);
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };

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

 // TODO: Once we have call site specific value information we can provide call
 //       site specific liveness liveness information and then it makes sense to
 //       specialize attributes for call sites instead of redirecting requests to
 //       the callee.
 using AAIsDeadCallSite = AAIsDeadFunction;
 
 /// -------------------- Dereferenceable Argument Attribute --------------------
 
-struct DerefState : AbstractState {
-
-  /// State representing for dereferenceable bytes.
-  IntegerState DerefBytesState;
-
-  /// State representing that whether the value is globaly dereferenceable.
-  BooleanState GlobalState;
-
-  /// See AbstractState::isValidState()
-  bool isValidState() const override { return DerefBytesState.isValidState(); }
-
-  /// See AbstractState::isAtFixpoint()
-  bool isAtFixpoint() const override {
-    return !isValidState() ||
-           (DerefBytesState.isAtFixpoint() && GlobalState.isAtFixpoint());
-  }
-
-  /// See AbstractState::indicateOptimisticFixpoint(...)
-  ChangeStatus indicateOptimisticFixpoint() override {
-    DerefBytesState.indicateOptimisticFixpoint();
-    GlobalState.indicateOptimisticFixpoint();
-    return ChangeStatus::UNCHANGED;
-  }
-
-  /// See AbstractState::indicatePessimisticFixpoint(...)
-  ChangeStatus indicatePessimisticFixpoint() override {
-    DerefBytesState.indicatePessimisticFixpoint();
-    GlobalState.indicatePessimisticFixpoint();
-    return ChangeStatus::CHANGED;
-  }
-
-  /// Update known dereferenceable bytes.
-  void takeKnownDerefBytesMaximum(uint64_t Bytes) {
-    DerefBytesState.takeKnownMaximum(Bytes);
-  }
-
-  /// Update assumed dereferenceable bytes.
-  void takeAssumedDerefBytesMinimum(uint64_t Bytes) {
-    DerefBytesState.takeAssumedMinimum(Bytes);
-  }
-
-  /// Equality for DerefState.
-  bool operator==(const DerefState &R) {
-    return this->DerefBytesState == R.DerefBytesState &&
-           this->GlobalState == R.GlobalState;
-  }
-
-  /// Inequality for IntegerState.
-  bool operator!=(const DerefState &R) { return !(*this == R); }
-
-  /// See IntegerState::operator^=
-  DerefState operator^=(const DerefState &R) {
-    DerefBytesState ^= R.DerefBytesState;
-    GlobalState ^= R.GlobalState;
-    return *this;
-  }
-
-  /// See IntegerState::operator&=
-  DerefState operator&=(const DerefState &R) {
-    DerefBytesState &= R.DerefBytesState;
-    GlobalState &= R.GlobalState;
-    return *this;
-  }
-
-  /// See IntegerState::operator|=
-  DerefState operator|=(const DerefState &R) {
-    DerefBytesState |= R.DerefBytesState;
-    GlobalState |= R.GlobalState;
-    return *this;
-  }
-};
-
 template <>
 ChangeStatus clampStateAndIndicateChange<DerefState>(DerefState &S,
                                                      const DerefState &R) {
   ChangeStatus CS0 = clampStateAndIndicateChange<IntegerState>(
       S.DerefBytesState, R.DerefBytesState);
   ChangeStatus CS1 =
       clampStateAndIndicateChange<IntegerState>(S.GlobalState, R.GlobalState);
   return CS0 | CS1;
 }
 
-struct AADereferenceableImpl : AADereferenceable, DerefState {
+struct AADereferenceableImpl : AADereferenceable {
   AADereferenceableImpl(const IRPosition &IRP) : AADereferenceable(IRP) {}
   using StateType = DerefState;
 
   void initialize(Attributor &A) override {
     SmallVector<Attribute, 4> Attrs;
     getAttrs({Attribute::Dereferenceable, Attribute::DereferenceableOrNull},
              Attrs);
     for (const Attribute &Attr : Attrs)
       takeKnownDerefBytesMaximum(Attr.getValueAsInt());
 
     NonNullAA = &A.getAAFor<AANonNull>(*this, getIRPosition());
   }
 
   /// See AbstractAttribute::getState()
   /// {
   StateType &getState() override { return *this; }
   const StateType &getState() const override { return *this; }
   /// }
 
-  /// See AADereferenceable::getAssumedDereferenceableBytes().
-  uint32_t getAssumedDereferenceableBytes() const override {
-    return DerefBytesState.getAssumed();
-  }
-
-  /// See AADereferenceable::getKnownDereferenceableBytes().
-  uint32_t getKnownDereferenceableBytes() const override {
-    return DerefBytesState.getKnown();
-  }
-
-  /// See AADereferenceable::isAssumedGlobal().
-  bool isAssumedGlobal() const override { return GlobalState.getAssumed(); }
-
-  /// See AADereferenceable::isKnownGlobal().
-  bool isKnownGlobal() const override { return GlobalState.getKnown(); }
-
-  bool isAssumedNonNull() const override {
-    return NonNullAA && NonNullAA->isAssumedNonNull();
-  }
-
   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()));
   }
 
   /// 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()) + ">";
   }
-
-private:
-  const AANonNull *NonNullAA = nullptr;
 };
 
 /// Dereferenceable attribute for a floating value.
 struct AADereferenceableFloating : AADereferenceableImpl {
   AADereferenceableFloating(const IRPosition &IRP)
       : AADereferenceableImpl(IRP) {}
 
   /// See AbstractAttribute::updateImpl(...).