Attributor: Start looking at uses when inferring nofpclass

[arsenm]

Summary

Pretty much just copy pasted from noundef handling

[sameerds]

Not familiar enough to assess if this covers everything. But LGTM. Might want to wait for comments from other reviewers.

[jdoerfert]

LG

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10307

This code doesn't seem to affect a test.
I think something like this should work now:

call void @extern(%fp) willreturn nounwind ; < annotate this use
call void @extern(nofpclass(nan inf) %fp)

10336

You can add a test with an alloca if you want to verify it works not only through PHIs but also memory.

[jdoerfert]

llvm/test/Transforms/Attributor/nofpclass.ll

267

If you introduce a block for the non-nan case you can use the value and instruction in the VisitValueCB to determine its non-nan. Only need to do that if the CtxI of the AA for the value is not the CtxI of the VisitValueCB though.

[arsenm]

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

10307

It also doesn't change this test

10336

Like this? Doesn't work

define float @returned_load(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define float @returned_load
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[PTR:%.*]]) #[[ATTR4:[0-9]+]] {
; CHECK-NEXT:    [[LOAD:%.*]] = load float, ptr [[PTR]], align 4
; CHECK-NEXT:    ret float [[LOAD]]
;
  %load = load float, ptr %ptr
  ret float %load
}

define float @pass_nofpclass_inf_through_memory(float nofpclass(inf) %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define float @pass_nofpclass_inf_through_memory
; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT:    [[ALLOCA:%.*]] = alloca float, align 4
; TUNIT-NEXT:    store float [[ARG]], ptr [[ALLOCA]], align 4
; TUNIT-NEXT:    [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR7]]
; TUNIT-NEXT:    ret float [[RET]]
;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define float @pass_nofpclass_inf_through_memory
; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT:    [[ALLOCA:%.*]] = alloca float, align 4
; CGSCC-NEXT:    store float [[ARG]], ptr [[ALLOCA]], align 4
; CGSCC-NEXT:    [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR6]]
; CGSCC-NEXT:    ret float [[RET]]
;
  %alloca = alloca float
  store float %arg, ptr %alloca
  %ret = call float @returned_load(ptr %alloca)
  ret float %ret
}

[arsenm]

6705f634f6455100ba66734c96a3cc04a5f00d7d

[arsenm]

llvm/test/Transforms/Attributor/nofpclass.ll

267

I missed this comment initially and don't quite follow it

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

void initialize(Attributor &A) override {
 
     const DataLayout &DL = A.getDataLayout();
     if (getPositionKind() != IRPosition::IRP_RETURNED) {
       KnownFPClass KnownFPClass = computeKnownFPClass(&V, DL);
       addKnownBits(~KnownFPClass.KnownFPClasses);
     }
   }
 
+  /// See followUsesInMBEC
+  bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
+                       AANoFPClass::StateType &State) {
+    const Value *UseV = U->get();
+    const DominatorTree *DT = nullptr;
+    AssumptionCache *AC = nullptr;
+    const TargetLibraryInfo *TLI = nullptr;
+    InformationCache &InfoCache = A.getInfoCache();
+
+    if (Function *F = getAnchorScope()) {
+      DT = InfoCache.getAnalysisResultForFunction<DominatorTreeAnalysis>(*F);
+      AC = InfoCache.getAnalysisResultForFunction<AssumptionAnalysis>(*F);
+      TLI = InfoCache.getTargetLibraryInfoForFunction(*F);
+    }
+
+    const DataLayout &DL = A.getDataLayout();
+
+    KnownFPClass KnownFPClass =
+        computeKnownFPClass(UseV, DL,
+                            /*InterestedClasses=*/fcAllFlags,
+                            /*Depth=*/0, TLI, AC, I, DT);
+    State.addKnownBits(~KnownFPClass.KnownFPClasses);
+
+    bool TrackUse = false;
+    return TrackUse;
+  }
+
   const std::string getAsStr() const override {
     std::string Result = "nofpclass";
     raw_string_ostream OS(Result);
     OS << getAssumedNoFPClass();
     return Result;
   }
 
   ChangeStatus manifest(Attributor &A) override {
void getDeducedAttributes(LLVMContext &Ctx,
     Attrs.emplace_back(Attribute::getWithNoFPClass(Ctx, getAssumedNoFPClass()));
   }
 };
 
 struct AANoFPClassFloating : public AANoFPClassImpl {
   AANoFPClassFloating(const IRPosition &IRP, Attributor &A)
       : AANoFPClassImpl(IRP, A) {}
 
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    AANoFPClassImpl::initialize(A);
+    if (!getState().isAtFixpoint())
+      if (Instruction *CtxI = getCtxI())
+        followUsesInMBEC(*this, A, getState(), *CtxI);
+  }
+
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override {
+    SmallVector<AA::ValueAndContext> Values;
+    bool UsedAssumedInformation = false;
+    if (!A.getAssumedSimplifiedValues(getIRPosition(), *this, Values,
+                                      AA::AnyScope, UsedAssumedInformation)) {
+      Values.push_back({getAssociatedValue(), getCtxI()});
+    }
+
+    StateType T;
+    auto VisitValueCB = [&](Value &V, const Instruction *CtxI) -> bool {
+      const auto &AA = A.getAAFor<AANoFPClass>(*this, IRPosition::value(V),
+                                               DepClassTy::REQUIRED);
+      if (this == &AA) {
+        T.indicatePessimisticFixpoint();
+      } else {
+        const AANoFPClass::StateType &S =
+            static_cast<const AANoFPClass::StateType &>(AA.getState());
+        T ^= S;
+      }
+      return T.isValidState();
+    };
+
+    for (const auto &VAC : Values)
+      if (!VisitValueCB(*VAC.getValue(), VAC.getCtxI()))
         return indicatePessimisticFixpoint();
+
+    return clampStateAndIndicateChange(getState(), T);
   }
 
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_FNRET_ATTR(nofpclass)
   }
 };
 

llvm/test/Transforms/Attributor/nofpclass.ll

;
   call void @extern.use(float nofpclass(nan) %arg)
   ret void
 }
 
 ; Callsite can union the incoming and outgoing
 define void @ninf_arg_used_by_nofpclass_nan_callsite(float nofpclass(inf) %arg) {
 ; CHECK-LABEL: define void @ninf_arg_used_by_nofpclass_nan_callsite
 ; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) {
-; CHECK-NEXT:    call void @extern.use(float nofpclass(nan) [[ARG]])
+; CHECK-NEXT:    call void @extern.use(float nofpclass(nan inf) [[ARG]])
 ; CHECK-NEXT:    ret void
 ;
   call void @extern.use(float nofpclass(nan) %arg)
   ret void
 }
 
 define void @ninf_arg_used_by_callsite_array([2 x [3 x float]] nofpclass(inf) %arg) {
 ; CHECK-LABEL: define void @ninf_arg_used_by_callsite_array

 ; Should be able to infer nofpclass(nan) return
 define float @fcmp_uno_check(float %arg) local_unnamed_addr {
 ; CHECK-LABEL: define float @fcmp_uno_check
 ; CHECK-SAME: (float [[ARG:%.*]]) local_unnamed_addr {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ISNAN:%.*]] = fcmp uno float [[ARG]], 0.000000e+00
 ; CHECK-NEXT:    br i1 [[ISNAN]], label [[BB0:%.*]], label [[BB1:%.*]]
 ; CHECK:       bb0:
-; CHECK-NEXT:    [[CALL:%.*]] = call float @ret_nofpclass_nan()
+; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan) float @ret_nofpclass_nan()
 ; CHECK-NEXT:    br label [[BB1]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[PHI:%.*]] = phi float [ [[CALL]], [[BB0]] ], [ [[ARG]], [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret float [[PHI]]
 ;
 entry:
   %isnan = fcmp uno float %arg, 0.0
   br i1 %isnan, label %bb0, label %bb1
 
 bb0:
   %call = call float @ret_nofpclass_nan()
   br label %bb1
 
 bb1:
   %phi = phi float [ %call, %bb0 ], [ %arg, %entry ]
   ret float %phi
 }
 
 ; Should be able to infer nofpclass(nan) on %arg use
 define void @fcmp_ord_guard_callsite_arg(float %arg) {
 ; CHECK-LABEL: define void @fcmp_ord_guard_callsite_arg
 ; CHECK-SAME: (float [[ARG:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[IS_NOT_NAN:%.*]] = fcmp ord float [[ARG]], 0.000000e+00