[ValueTracking] Teach cannotBeOrderedLessThanZeroImpl to handle vector constants.

[craig.topper]

Summary

This allows vector fabs to be removed in more cases.

[spatel]

This is an improvement, so I won't hold it up if you want to get it committed...

But I wonder if here - and maybe also for D43774 - we can enhance PatternMatching for FP as we've recently done for integer with:
D42818
rL325466

The benefit is that those can also match vectors with undef lanes. Also, once we have that templated in PatternMatch, we won't have to keep rewriting this vector-constant loop with getAggregateElement(). I was looking at adding that anyway to improve some FP instcombines, but I hadn't gotten there yet.

[craig.topper]

I'd like to go ahead and get this in. I have another follow up patch to teach cannotBeOrderedLessThanZeroImpl to walk through ExtractElement too. The original place I saw this was two fabs on elements extracted from a vector.

But I think you're probably right that we should probably improve pattern matching for FP here.

[spatel]

LGTM.

I'll try to post a proposal for the FP pattern matching enhancement soon.

llvm/trunk/lib/Analysis/ValueTracking.cpp

static bool cannotBeOrderedLessThanZeroImpl(const Value *V,
   // which flips the sign bits of NaNs.  See
   // https://llvm.org/bugs/show_bug.cgi?id=31702.
 
   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
     return !CFP->getValueAPF().isNegative() ||
            (!SignBitOnly && CFP->getValueAPF().isZero());
   }
 
+  // Handle vector of constants.
+  if (auto *CV = dyn_cast<Constant>(V)) {
+    if (CV->getType()->isVectorTy()) {
+      unsigned NumElts = CV->getType()->getVectorNumElements();
+      for (unsigned i = 0; i != NumElts; ++i) {
+        auto *CFP = dyn_cast_or_null<ConstantFP>(CV->getAggregateElement(i));
+        if (!CFP)
+          return false;
+        if (CFP->getValueAPF().isNegative() &&
+            (SignBitOnly || !CFP->getValueAPF().isZero()))
+          return false;
+      }
+
+      // All non-negative ConstantFPs.
+      return true;
+    }
+  }
+
   if (Depth == MaxDepth)
     return false; // Limit search depth.
 
   const Operator *I = dyn_cast<Operator>(V);
   if (!I)
     return false;
 
   switch (I->getOpcode()) {

llvm/trunk/test/Transforms/InstSimplify/floating-point-arithmetic.ll

;
   %fabs = call float @llvm.fabs.f32(float %select)
   ret float %fabs
 }
 
 define <2 x float> @fabs_select_positive_constants_vector(i32 %c) {
 ; CHECK-LABEL: @fabs_select_positive_constants_vector(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[C:%.*]], 0
 ; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[CMP]], <2 x float> <float 1.000000e+00, float 1.000000e+00>, <2 x float> <float 2.000000e+00, float 2.000000e+00>
-; CHECK-NEXT:    [[FABS:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[SELECT]])
-; CHECK-NEXT:    ret <2 x float> [[FABS]]
+; CHECK-NEXT:    ret <2 x float> [[SELECT]]
 ;
   %cmp = icmp eq i32 %c, 0
   %select = select i1 %cmp, <2 x float> <float 1.0, float 1.0>, <2 x float> <float 2.0, float 2.0>
   %fabs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %select)
   ret <2 x float> %fabs
 }
 
 define float @fabs_select_constant_variable(i32 %c, float %x) {
;
   %fabs = call float @llvm.fabs.f32(float %select)
   ret float %fabs
 }
 
 define <2 x float> @fabs_select_nan_nan_vector(i32 %c) {
 ; CHECK-LABEL: @fabs_select_nan_nan_vector(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[C:%.*]], 0
 ; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[CMP]], <2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, <2 x float> <float 0x7FF8000100000000, float 0x7FF8000100000000>
-; CHECK-NEXT:    [[FABS:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[SELECT]])
-; CHECK-NEXT:    ret <2 x float> [[FABS]]
+; CHECK-NEXT:    ret <2 x float> [[SELECT]]
 ;
   %cmp = icmp eq i32 %c, 0
   %select = select i1 %cmp, <2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, <2 x float> <float 0x7FF8000100000000, float 0x7FF8000100000000>
   %fabs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %select)
   ret <2 x float> %fabs
 }
 
 define float @fabs_select_negnan_nan(i32 %c) {