ValueTracking: Handle insertelement in computeKnownFPClass

[arsenm]

llvm/lib/Analysis/ValueTracking.cpp

4583

I think these resets aren't necessary (and probably aren't in the computeKnownBits version either)

[arsenm]

Assume uninitialized Knowns are passed in

[jcranmer-intel]

llvm/lib/Analysis/ValueTracking.cpp

4572

This assert should be moved out of the switch statement, I think.

[arsenm]

Move assert

[foad]

Looks OK modulo nits.

llvm/lib/Analysis/ValueTracking.cpp

4128

Wouldn't it be simpler to make all these computeKnownFPClass functions return KnownFPClass?

4634–4635

Could call your new computeKnownFPClass overload rather than repeating this logic?

[arsenm]

llvm/lib/Analysis/ValueTracking.cpp

4128

Yes. I started by copying the raw signature for computeKnownBits. Probably should do a cleanup and replace the arguments at some point. The ordering doesn't make much sense (e.g. Depth before the others seems like a shortcut taken years ago). Plus TLI not being part of Query also doesn't make much sense

4634–4635

Yes, I think so

[arsenm]

8e70ed6efd212f7a261542e8d924219e80c5ccac

llvm/include/llvm/Analysis/ValueTracking.h

struct KnownFPClass {
   /// definitely set or false if the sign bit is definitely unset.
   std::optional<bool> SignBit;
 
   /// Return true if it's known this can never be one of the mask entries.
   bool isKnownNever(FPClassTest Mask) const {
     return (KnownFPClasses & Mask) == fcNone;
   }
 
+  bool isUnknown() const {
+    return KnownFPClasses == fcAllFlags && !SignBit;
+  }
+
   /// Return true if it's known this can never be a nan.
   bool isKnownNeverNaN() const {
     return isKnownNever(fcNan);
   }
 
   /// Return true if it's known this can never be an infinity.
   bool isKnownNeverInfinity() const {
     return isKnownNever(fcInf);

llvm/lib/Analysis/ValueTracking.cpp

if (match(I->getArgOperand(0), m_FCmp(Pred, m_Value(LHS), m_Value(RHS)))) {
                          m_Value(LHS), m_ConstantInt(ClassVal)))) {
       KnownFromAssume &= static_cast<FPClassTest>(ClassVal);
     }
   }
 
   return KnownFromAssume;
 }
 
+void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
+                         FPClassTest InterestedClasses, KnownFPClass &Known,
+                         unsigned Depth, const Query &Q,
+                         const TargetLibraryInfo *TLI);
+
+static void computeKnownFPClass(const Value *V, KnownFPClass &Known,
+                                FPClassTest InterestedClasses, unsigned Depth,
+                                const Query &Q, const TargetLibraryInfo *TLI) {
+  auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
+  APInt DemandedElts =
+      FVTy ? APInt::getAllOnes(FVTy->getNumElements()) : APInt(1, 1);
+  computeKnownFPClass(V, DemandedElts, InterestedClasses, Known, Depth, Q, TLI);
+}
+
 // TODO: Merge implementations of CannotBeNegativeZero,
 // cannotBeOrderedLessThanZero into here.
 void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
                          FPClassTest InterestedClasses, KnownFPClass &Known,
                          unsigned Depth, const Query &Q,
                          const TargetLibraryInfo *TLI) {
+  assert(Known.isUnknown() && "should not be called with known information");
+
   if (!DemandedElts) {
     // No demanded elts, better to assume we don't know anything.
     Known.resetAll();
     return;
   }
 
   assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
 
if (auto *VecTy = dyn_cast<FixedVectorType>(Vec->getType())) {
       if (CIdx && CIdx->getValue().ult(NumElts))
         DemandedVecElts = APInt::getOneBitSet(NumElts, CIdx->getZExtValue());
       return computeKnownFPClass(Vec, DemandedVecElts, InterestedClasses, Known,
                                  Depth + 1, Q, TLI);
     }
 
     break;
   }
+  case Instruction::InsertElement: {
+    if (isa<ScalableVectorType>(Op->getType()))
+      return;
+
+    const Value *Vec = Op->getOperand(0);
+    const Value *Elt = Op->getOperand(1);
+    auto *CIdx = dyn_cast<ConstantInt>(Op->getOperand(2));
+    // Early out if the index is non-constant or out-of-range.
+    unsigned NumElts = DemandedElts.getBitWidth();
+    if (!CIdx || CIdx->getValue().uge(NumElts))
+      return;
+
+    unsigned EltIdx = CIdx->getZExtValue();
+    // Do we demand the inserted element?
+    if (DemandedElts[EltIdx]) {
+      computeKnownFPClass(Elt, Known, InterestedClasses, Depth + 1, Q, TLI);
+      // If we don't know any bits, early out.
+      if (Known.isUnknown())
+        break;
+    } else {
+      Known.KnownFPClasses = fcNone;
+    }
+
+    // We don't need the base vector element that has been inserted.
+    APInt DemandedVecElts = DemandedElts;
+    DemandedVecElts.clearBit(EltIdx);
+    if (!!DemandedVecElts) {
+      KnownFPClass Known2;
+      computeKnownFPClass(Vec, DemandedVecElts, InterestedClasses, Known2,
+                          Depth + 1, Q, TLI);
+      Known |= Known2;
+    }
+
+    break;
+  }
   case Instruction::ExtractValue: {
     computeKnownFPClass(Op->getOperand(0), DemandedElts, InterestedClasses,
                         Known, Depth + 1, Q, TLI);
     break;
   }
   default:
     break;
   }

 }
 
 KnownFPClass
 llvm::computeKnownFPClass(const Value *V, const DataLayout &DL,
                           FPClassTest InterestedClasses, unsigned Depth,
                           const TargetLibraryInfo *TLI, AssumptionCache *AC,
                           const Instruction *CxtI, const DominatorTree *DT,
                           OptimizationRemarkEmitter *ORE, bool UseInstrInfo) {
   KnownFPClass Known;
-  auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
-  APInt DemandedElts =
-      FVTy ? APInt::getAllOnes(FVTy->getNumElements()) : APInt(1, 1);
-  ::computeKnownFPClass(V, DemandedElts, InterestedClasses, Known, Depth,
+  ::computeKnownFPClass(V, Known, InterestedClasses, Depth,
                         Query(DL, AC, safeCxtI(V, CxtI), DT, UseInstrInfo, ORE),
                         TLI);
   return Known;
 }
 
 Value *llvm::isBytewiseValue(Value *V, const DataLayout &DL) {
 
   // All byte-wide stores are splatable, even of arbitrary variables.

llvm/test/Transforms/Attributor/nofpclass.ll

 ; CHECK-LABEL: define nofpclass(nan) float @returned_extractvalue
 ; CHECK-SAME: ([4 x float] nofpclass(nan) [[ARRAY:%.*]]) #[[ATTR2]] {
 ; CHECK-NEXT:    [[EXTRACT:%.*]] = extractvalue [4 x float] [[ARRAY]], 0
 ; CHECK-NEXT:    ret float [[EXTRACT]]
 ;
   %extract = extractvalue [4 x float] %array, 0
   ret float %extract
 }
+
+define float @return_nofpclass_freeze_nan_arg(float nofpclass(nan) %arg) {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define noundef float @return_nofpclass_freeze_nan_arg
+; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[ARG]]
+; CHECK-NEXT:    ret float [[FREEZE]]
+;
+  %freeze = freeze float %arg
+  ret float %freeze
+}
+
+define float @return_nofpclass_extractelement_freeze_pinf_arg(<2 x float> nofpclass(pinf) %arg) {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define noundef float @return_nofpclass_extractelement_freeze_pinf_arg
+; CHECK-SAME: (<2 x float> nofpclass(pinf) [[ARG:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[FREEZE:%.*]] = freeze <2 x float> [[ARG]]
+; CHECK-NEXT:    [[ELT:%.*]] = extractelement <2 x float> [[FREEZE]], i32 0
+; CHECK-NEXT:    ret float [[ELT]]
+;
+  %freeze = freeze <2 x float> %arg
+  %elt = extractelement <2 x float> %freeze, i32 0
+  ret float %elt
+}
+
+define <4 x float> @insertelement_constant_chain() {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define nofpclass(nan ninf nzero sub) <4 x float> @insertelement_constant_chain
+; CHECK-SAME: () #[[ATTR2]] {
+; CHECK-NEXT:    [[INS_0:%.*]] = insertelement <4 x float> poison, float 1.000000e+00, i32 0
+; CHECK-NEXT:    [[INS_1:%.*]] = insertelement <4 x float> [[INS_0]], float 0.000000e+00, i32 1
+; CHECK-NEXT:    [[INS_2:%.*]] = insertelement <4 x float> [[INS_1]], float -9.000000e+00, i32 2
+; CHECK-NEXT:    [[INS_3:%.*]] = insertelement <4 x float> [[INS_2]], float 0x7FF0000000000000, i32 3
+; CHECK-NEXT:    ret <4 x float> [[INS_3]]
+;
+  %ins.0 = insertelement <4 x float> poison, float 1.0, i32 0
+  %ins.1 = insertelement <4 x float> %ins.0, float 0.0, i32 1
+  %ins.2 = insertelement <4 x float> %ins.1, float -9.0, i32 2
+  %ins.3 = insertelement <4 x float> %ins.2, float 0x7FF0000000000000, i32 3
+  ret <4 x float> %ins.3
+}
+
+define <vscale x 4 x float> @insertelement_scalable_constant_chain() {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define <vscale x 4 x float> @insertelement_scalable_constant_chain
+; CHECK-SAME: () #[[ATTR2]] {
+; CHECK-NEXT:    [[INS_0:%.*]] = insertelement <vscale x 4 x float> poison, float 1.000000e+00, i32 0
+; CHECK-NEXT:    [[INS_1:%.*]] = insertelement <vscale x 4 x float> [[INS_0]], float 0.000000e+00, i32 1
+; CHECK-NEXT:    [[INS_2:%.*]] = insertelement <vscale x 4 x float> [[INS_1]], float -9.000000e+00, i32 2
+; CHECK-NEXT:    [[INS_3:%.*]] = insertelement <vscale x 4 x float> [[INS_2]], float 0x7FF0000000000000, i32 3
+; CHECK-NEXT:    ret <vscale x 4 x float> [[INS_3]]
+;
+  %ins.0 = insertelement <vscale x 4 x float> poison, float 1.0, i32 0
+  %ins.1 = insertelement <vscale x 4 x float> %ins.0, float 0.0, i32 1
+  %ins.2 = insertelement <vscale x 4 x float> %ins.1, float -9.0, i32 2
+  %ins.3 = insertelement <vscale x 4 x float> %ins.2, float 0x7FF0000000000000, i32 3
+  ret <vscale x 4 x float> %ins.3
+}
+
+define <4 x float> @insertelement_unknown_base(<4 x float> %arg0) {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define <4 x float> @insertelement_unknown_base
+; CHECK-SAME: (<4 x float> [[ARG0:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
+; CHECK-NEXT:    ret <4 x float> [[INSERT]]
+;
+  %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
+  ret <4 x float> %insert
+}
+
+define float @insertelement_extractelement_same(<4 x float> %arg0) {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) float @insertelement_extractelement_same
+; CHECK-SAME: (<4 x float> [[ARG0:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
+; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 1
+; CHECK-NEXT:    ret float [[EXTRACT]]
+;
+  %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
+  %extract = extractelement <4 x float> %insert, i32 1
+  ret float %extract
+}
+
+define float @insertelement_extractelement_different(<4 x float> nofpclass(zero) %arg0) {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define nofpclass(zero) float @insertelement_extractelement_different
+; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
+; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 2
+; CHECK-NEXT:    ret float [[EXTRACT]]
+;
+  %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
+  %extract = extractelement <4 x float> %insert, i32 2
+  ret float %extract
+}
+
+define float @insertelement_extractelement_unknown(<4 x float> nofpclass(zero) %arg0, i32 %idx) {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define nofpclass(nzero) float @insertelement_extractelement_unknown
+; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]], i32 [[IDX:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
+; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 [[IDX]]
+; CHECK-NEXT:    ret float [[EXTRACT]]
+;
+  %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
+  %extract = extractelement <4 x float> %insert, i32 %idx
+  ret float %extract
+}
+
+define <4 x float> @insertelement_index_oob_chain() {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define <4 x float> @insertelement_index_oob_chain
+; CHECK-SAME: () #[[ATTR2]] {
+; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> zeroinitializer, float 0x7FF0000000000000, i32 4
+; CHECK-NEXT:    ret <4 x float> [[INSERT]]
+;
+  %insert = insertelement <4 x float> zeroinitializer, float 0x7FF0000000000000, i32 4
+  ret <4 x float> %insert
+}
+
+define <2 x float> @multiple_extractelement(<4 x float> nofpclass(zero) %arg0) {
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define nofpclass(zero) <2 x float> @multiple_extractelement
+; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
+; CHECK-NEXT:    [[EXTRACT2:%.*]] = extractelement <4 x float> [[INSERT]], i32 2
+; CHECK-NEXT:    [[EXTRACT3:%.*]] = extractelement <4 x float> [[INSERT]], i32 3
+; CHECK-NEXT:    [[INS_0:%.*]] = insertelement <2 x float> poison, float [[EXTRACT3]], i32 0
+; CHECK-NEXT:    [[INS_1:%.*]] = insertelement <2 x float> [[INS_0]], float [[EXTRACT2]], i32 1
+; CHECK-NEXT:    ret <2 x float> [[INS_1]]
+;
+  %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
+  %extract2 = extractelement <4 x float> %insert, i32 2
+  %extract3 = extractelement <4 x float> %insert, i32 3
+  %ins.0 = insertelement <2 x float> poison, float %extract3, i32 0
+  %ins.1 = insertelement <2 x float> %ins.0, float %extract2, i32 1
+  ret <2 x float> %ins.1
+}