[Attributor] Use the AANoNull attribute directly in AADereferenceable

[jdoerfert]

Summary

Instead of constantly keeping track of the nonnull status with the
dereferenceable information we can simply query the nonnull attribute
whenever we need the information (debug + manifest).

[uenoku]

I think it is better to use intersectAssumedBits for BooleanState.
Otherwise, LGTM.

llvm/lib/Transforms/IPO/Attributor.cpp

1769 ↗

(On Diff #214717)

intersectAssumedBits is better.

1825 ↗

(On Diff #214717)

intersectAssumedBits is better.

1858 ↗

(On Diff #214717)

intersectAssumedBits is better.

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

 /// An abstract interface for all dereferenceable attribute.
 struct AADereferenceable
     : public IRAttribute<Attribute::Dereferenceable, AbstractAttribute> {
   AADereferenceable(const IRPosition &IRP) : IRAttribute(IRP) {}
 
   /// 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;
 

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

 
 /// -------------------- Dereferenceable Argument Attribute --------------------
 
 struct DerefState : AbstractState {
 
   /// State representing for dereferenceable bytes.
   IntegerState DerefBytesState;
 
-  /// State representing that whether the value is nonnull or global.
-  IntegerState NonNullGlobalState;
-
-  /// Bits encoding for NonNullGlobalState.
-  enum {
-    DEREF_NONNULL = 1 << 0,
-    DEREF_GLOBAL = 1 << 1,
-  };
+  /// 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() &&
-                               NonNullGlobalState.isAtFixpoint());
+    return !isValidState() ||
+           (DerefBytesState.isAtFixpoint() && GlobalState.isAtFixpoint());
   }
 
   /// See AbstractState::indicateOptimisticFixpoint(...)
   ChangeStatus indicateOptimisticFixpoint() override {
     DerefBytesState.indicateOptimisticFixpoint();
-    NonNullGlobalState.indicateOptimisticFixpoint();
+    GlobalState.indicateOptimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
   /// See AbstractState::indicatePessimisticFixpoint(...)
   ChangeStatus indicatePessimisticFixpoint() override {
     DerefBytesState.indicatePessimisticFixpoint();
-    NonNullGlobalState.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);
   }
 
-  /// Update assumed NonNullGlobalState
-  void updateAssumedNonNullGlobalState(bool IsNonNull, bool IsGlobal) {
-    if (!IsNonNull)
-      NonNullGlobalState.removeAssumedBits(DEREF_NONNULL);
-    if (!IsGlobal)
-      NonNullGlobalState.removeAssumedBits(DEREF_GLOBAL);
-  }
-
   /// Equality for DerefState.
   bool operator==(const DerefState &R) {
     return this->DerefBytesState == R.DerefBytesState &&
-           this->NonNullGlobalState == R.NonNullGlobalState;
+           this->GlobalState == R.GlobalState;
   }
 };
 
 struct AADereferenceableImpl : AADereferenceable, DerefState {
   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();
   }
 
-  // Helper function for syncing nonnull state.
-  void syncNonNull(const AANonNull *NonNullAA) {
-    if (!NonNullAA) {
-      NonNullGlobalState.removeAssumedBits(DEREF_NONNULL);
-      return;
-    }
-
-    if (NonNullAA->isKnownNonNull())
-      NonNullGlobalState.addKnownBits(DEREF_NONNULL);
-
-    if (!NonNullAA->isAssumedNonNull())
-      NonNullGlobalState.removeAssumedBits(DEREF_NONNULL);
-  }
-
   /// See AADereferenceable::isAssumedGlobal().
-  bool isAssumedGlobal() const override {
-    return NonNullGlobalState.isAssumed(DEREF_GLOBAL);
-  }
+  bool isAssumedGlobal() const override { return GlobalState.getAssumed(); }
 
   /// See AADereferenceable::isKnownGlobal().
-  bool isKnownGlobal() const override {
-    return NonNullGlobalState.isKnown(DEREF_GLOBAL);
-  }
+  bool isKnownGlobal() const override { return GlobalState.getKnown(); }
 
-  /// See AADereferenceable::isAssumedNonNull().
   bool isAssumedNonNull() const override {
-    return NonNullGlobalState.isAssumed(DEREF_NONNULL);
-  }
-
-  /// See AADereferenceable::isKnownNonNull().
-  bool isKnownNonNull() const override {
-    return NonNullGlobalState.isKnown(DEREF_NONNULL);
+    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()));
   }
   uint64_t computeAssumedDerefenceableBytes(Attributor &A, Value &V,
-                                            bool &IsNonNull, bool &IsGlobal);
-
-  void initialize(Attributor &A) override {
-    SmallVector<Attribute, 4> Attrs;
-    getAttrs({Attribute::Dereferenceable, Attribute::DereferenceableOrNull},
-             Attrs);
-    for (const Attribute &Attr : Attrs)
-      takeKnownDerefBytesMaximum(Attr.getValueAsInt());
-  }
+                                            bool &IsGlobal);
 
   /// 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;
 };
 
 struct AADereferenceableReturned final : AADereferenceableImpl {
   AADereferenceableReturned(const IRPosition &IRP)
       : AADereferenceableImpl(IRP) {}
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override;
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECL_AND_TRACK_FNRET_ATTR(dereferenceable)
   }
 };
 
 // Helper function that returns dereferenceable bytes.
 static uint64_t calcDifferenceIfBaseIsNonNull(int64_t DerefBytes,
                                               int64_t Offset, bool IsNonNull) {
   if (!IsNonNull)
     return 0;
   return std::max((int64_t)0, DerefBytes - Offset);
 }
 
-uint64_t AADereferenceableImpl::computeAssumedDerefenceableBytes(
-    Attributor &A, Value &V, bool &IsNonNull, bool &IsGlobal) {
+uint64_t
+AADereferenceableImpl::computeAssumedDerefenceableBytes(Attributor &A, Value &V,
+                                                        bool &IsGlobal) {
   // TODO: Tracking the globally flag.
   IsGlobal = false;
 
   // First, we try to get information about V from Attributor.
   if (auto *DerefAA =
           A.getAAFor<AADereferenceable>(*this, IRPosition::value(V))) {
-    IsNonNull &= DerefAA->isAssumedNonNull();
     return DerefAA->getAssumedDereferenceableBytes();
   }
 
   // Otherwise, we try to compute assumed bytes from base pointer.
   const DataLayout &DL = A.getDataLayout();
   unsigned IdxWidth =
       DL.getIndexSizeInBits(V.getType()->getPointerAddressSpace());
   APInt Offset(IdxWidth, 0);
   Value *Base = V.stripAndAccumulateInBoundsConstantOffsets(DL, Offset);
 
   if (auto *BaseDerefAA =
           A.getAAFor<AADereferenceable>(*this, IRPosition::value(*Base))) {
-    IsNonNull &= Offset != 0;
     return calcDifferenceIfBaseIsNonNull(
         BaseDerefAA->getAssumedDereferenceableBytes(), Offset.getSExtValue(),
         Offset != 0 || BaseDerefAA->isAssumedNonNull());
   }
 
   // Then, use IR information.
 
   if (isDereferenceablePointer(Base, Base->getType(), DL))
     return calcDifferenceIfBaseIsNonNull(
         DL.getTypeStoreSize(Base->getType()->getPointerElementType()),
         Offset.getSExtValue(),
         !NullPointerIsDefined(getAnchorScope(),
                               V.getType()->getPointerAddressSpace()));
 
-  IsNonNull = false;
   return 0;
 }
 
 ChangeStatus AADereferenceableReturned::updateImpl(Attributor &A) {
   auto BeforeState = static_cast<DerefState>(*this);
 
-  syncNonNull(A.getAAFor<AANonNull>(*this, getIRPosition()));
-
-  bool IsNonNull = isAssumedNonNull();
   bool IsGlobal = isAssumedGlobal();
 
   auto CheckReturnValue = [&](Value &RV) -> bool {
     takeAssumedDerefBytesMinimum(
-        computeAssumedDerefenceableBytes(A, RV, IsNonNull, IsGlobal));
+        computeAssumedDerefenceableBytes(A, RV, IsGlobal));
     return isValidState();
   };
 
   if (A.checkForAllReturnedValues(CheckReturnValue, *this)) {
-    updateAssumedNonNullGlobalState(IsNonNull, IsGlobal);
+    GlobalState.intersectAssumedBits(IsGlobal);
     return BeforeState == static_cast<DerefState>(*this)
                ? ChangeStatus::UNCHANGED
                : ChangeStatus::CHANGED;
   }
   return indicatePessimisticFixpoint();
 }
 
 struct AADereferenceableArgument final : AADereferenceableImpl {

 
 ChangeStatus AADereferenceableArgument::updateImpl(Attributor &A) {
   Argument &Arg = cast<Argument>(getAnchorValue());
 
   auto BeforeState = static_cast<DerefState>(*this);
 
   unsigned ArgNo = Arg.getArgNo();
 
-  syncNonNull(A.getAAFor<AANonNull>(*this, getIRPosition()));
-
-  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, IRPosition::callsite_argument(CS, ArgNo))) {
       ImmutableCallSite ICS(
           &DereferenceableAA->getIRPosition().getAnchorValue());
       if (ICS && CS.getInstruction() == ICS.getInstruction()) {
         takeAssumedDerefBytesMinimum(
             DereferenceableAA->getAssumedDereferenceableBytes());
-        IsNonNull &= DereferenceableAA->isAssumedNonNull();
         IsGlobal &= DereferenceableAA->isAssumedGlobal();
         return isValidState();
       }
     }
 
     takeAssumedDerefBytesMinimum(computeAssumedDerefenceableBytes(
-        A, *CS.getArgOperand(ArgNo), IsNonNull, IsGlobal));
+        A, *CS.getArgOperand(ArgNo), IsGlobal));
 
     return isValidState();
   };
 
   if (!A.checkForAllCallSites(CallSiteCheck, *this, true))
     return indicatePessimisticFixpoint();
 
-  updateAssumedNonNullGlobalState(IsNonNull, IsGlobal);
+  GlobalState.intersectAssumedBits(IsGlobal);
 
   return BeforeState == static_cast<DerefState>(*this) ? ChangeStatus::UNCHANGED
                                                        : ChangeStatus::CHANGED;
 }
 
 /// Dereferenceable attribute for a call site argument.
 struct AADereferenceableCallSiteArgument final : AADereferenceableImpl {
   AADereferenceableCallSiteArgument(const IRPosition &IRP)
ChangeStatus AADereferenceableCallSiteArgument::updateImpl(Attributor &A) {
   // 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, getIRPosition()));
-  bool IsNonNull = isAssumedNonNull();
-  bool IsGlobal = isKnownGlobal();
+  bool IsGlobal = isAssumedGlobal();
 
   takeAssumedDerefBytesMinimum(
-      computeAssumedDerefenceableBytes(A, V, IsNonNull, IsGlobal));
-  updateAssumedNonNullGlobalState(IsNonNull, IsGlobal);
+      computeAssumedDerefenceableBytes(A, V, IsGlobal));
+  GlobalState.intersectAssumedBits(IsGlobal);
 
   return BeforeState == static_cast<DerefState>(*this) ? ChangeStatus::UNCHANGED
                                                        : ChangeStatus::CHANGED;
 }
 
 // ------------------------ Align Argument Attribute ------------------------
 
 struct AAAlignImpl : AAAlign {