[InstCombine] Add constant vector support to getMinimumFPType for visitFPTrunc.

[craig.topper]

Summary

This patch teaches lookThroughFPExtensions to support shrinking a vector of ConstantFPs. This should improve our ability to combine vector fptrunc with fp binops.

[spatel]

lib/Transforms/InstCombine/InstCombineCasts.cpp

1441–1443

The existing code has a bug, but I don't think there's a way to expose it other than as an inefficiency. We will (usually?) create a half constant and then extend it back to single because that's not the type we wanted in the first place.

For scalars, this is wasteful, but constant folding hides the problem. Maybe nobody cares for scalars, but now we're doing that extra work N times for vector constants. And the bug is now visible (so we should add a test like this where the constants can't shrink to the same narrow type):

define <2 x float> @not_half_shrinkable(<2 x float> %x) {
  %ext = fpext <2 x float> %x to <2 x double>
  %add = fadd <2 x double> %ext, <double 0.0, double 2049.0>
  %r = fptrunc <2 x double> %add to <2 x float>
  ret <2 x float>  %r
}

1479–1483

The usual pattern has the vector constant check inside the helper function, so move the vector type check into 'shrinkFPConstantVector' and rename the functions?

Ideally, these wouldn't be instcombine-specific helpers. They'd be queries on constants. I recently made a similar change in rL325398.

test/Transforms/InstCombine/fpextend.ll

65–69

I think we can remove the load/store/globals from all of the tests in this file as a preliminary cleanup.

[craig.topper]

The scalar code is now type based and doesn't new constants. Rework this patch to build on that and find a minimal safe type by looking at each element. Then turn that into a vector type.

[spatel]

LGTM, but please add a TODO comment (and ideally a test to show it) that we don't handle vectors with undef elements.

lib/Transforms/InstCombine/InstCombineCasts.cpp

static Type *shrinkFPConstant(ConstantFP *CFP) {
   if (CFP->getType()->isDoubleTy())
     return nullptr;  // Won't shrink.
   if (fitsInFPType(CFP, APFloat::IEEEdouble()))
     return Type::getDoubleTy(CFP->getContext());
   // Don't try to shrink to various long double types.
   return nullptr;
 }
 
+// Determine if this is a vector of ConstantFPs and if so, return the minimal
+// type we can safely truncate all elements to.
+static Type *shrinkFPConstantVector(Value *V) {
+  auto *CV = dyn_cast<Constant>(V);
+  if (!CV || !CV->getType()->isVectorTy())
+    return nullptr;
+
+  Type *MinType = nullptr;
+
+  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 nullptr;
+
+    Type *T = shrinkFPConstant(CFP);
+    if (!T)
+      return nullptr;
+
+    // If we haven't found a type yet or this type has a larger mantissa than
+    // our previous type, this is our new minimal type.
+    if (!MinType || T->getFPMantissaWidth() > MinType->getFPMantissaWidth())
+      MinType = T;
+  }
+
+  // Make a vector type from the minimal type.
+  return VectorType::get(MinType, NumElts);
+}
+
 /// Find the minimum FP type we can safely truncate to.
 static Type *getMinimumFPType(Value *V) {
   if (auto *FPExt = dyn_cast<FPExtInst>(V))
     return FPExt->getOperand(0)->getType();
 
   // If this value is a constant, return the constant in the smallest FP type
   // that can accurately represent it.  This allows us to turn
   // (float)((double)X+2.0) into x+2.0f.
   if (auto *CFP = dyn_cast<ConstantFP>(V))
     if (Type *T = shrinkFPConstant(CFP))
       return T;
 
+  // Try to shrink a vector of FP constants.
+  if (Type *T = shrinkFPConstantVector(V))
+    return T;
+
   return V->getType();
 }
 
 Instruction *InstCombiner::visitFPTrunc(FPTruncInst &CI) {
   if (Instruction *I = commonCastTransforms(CI))
     return I;
   // If we have fptrunc(OpI (fpextend x), (fpextend y)), we would like to
   // simplify this expression to avoid one or more of the trunc/extend
   // operations if we can do so without changing the numerical results.

test/Transforms/InstCombine/fpextend.ll

entry:
   %tmp34 = fptrunc double %tmp2 to float
   ret float %tmp34
 }
 
 ; Test with vector splat constant
 define <2 x float> @test5(<2 x float> %x) nounwind  {
 ; CHECK-LABEL: @test5(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP1:%.*]] = fpext <2 x float> [[X:%.*]] to <2 x double>
-; CHECK-NEXT:    [[TMP3:%.*]] = fadd <2 x double> [[TMP1]], zeroinitializer
-; CHECK-NEXT:    [[TMP34:%.*]] = fptrunc <2 x double> [[TMP3]] to <2 x float>
+; CHECK-NEXT:    [[TMP34:%.*]] = fadd <2 x float> [[X:%.*]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x float> [[TMP34]]
 ;
 entry:
   %tmp1 = fpext <2 x float> %x to <2 x double>
   %tmp3 = fadd <2 x double> %tmp1, <double 0.000000e+00, double 0.000000e+00>
   %tmp34 = fptrunc <2 x double> %tmp3 to <2 x float>
   ret <2 x float> %tmp34
 }
 
 ; Test with a non-splat constant
 define <2 x float> @test6(<2 x float> %x) nounwind  {
 ; CHECK-LABEL: @test6(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP1:%.*]] = fpext <2 x float> [[X:%.*]] to <2 x double>
-; CHECK-NEXT:    [[TMP3:%.*]] = fadd <2 x double> [[TMP1]], <double 0.000000e+00, double -0.000000e+00>
-; CHECK-NEXT:    [[TMP34:%.*]] = fptrunc <2 x double> [[TMP3]] to <2 x float>
+; CHECK-NEXT:    [[TMP34:%.*]] = fadd <2 x float> [[X:%.*]], <float 0.000000e+00, float -0.000000e+00>
 ; CHECK-NEXT:    ret <2 x float> [[TMP34]]
 ;
 entry:
   %tmp1 = fpext <2 x float> %x to <2 x double>
   %tmp3 = fadd <2 x double> %tmp1, <double 0.000000e+00, double -0.000000e+00>
   %tmp34 = fptrunc <2 x double> %tmp3 to <2 x float>
   ret <2 x float> %tmp34
 }
 
 define <2 x float> @not_half_shrinkable(<2 x float> %x) {
 ; CHECK-LABEL: @not_half_shrinkable(
-; CHECK-NEXT:    [[EXT:%.*]] = fpext <2 x float> [[X:%.*]] to <2 x double>
-; CHECK-NEXT:    [[ADD:%.*]] = fadd <2 x double> [[EXT]], <double 0.000000e+00, double 2.049000e+03>
-; CHECK-NEXT:    [[R:%.*]] = fptrunc <2 x double> [[ADD]] to <2 x float>
+; CHECK-NEXT:    [[R:%.*]] = fadd <2 x float> [[X:%.*]], <float 0.000000e+00, float 2.049000e+03>
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %ext = fpext <2 x float> %x to <2 x double>
   %add = fadd <2 x double> %ext, <double 0.0, double 2049.0>
   %r = fptrunc <2 x double> %add to <2 x float>
   ret <2 x float>  %r
 }