[DAGCombiner] Add support for FCEIL, FFLOOR and FTRUNC vector constant folding

[RKSimon]

Summary

This patch adds supports for the vector constant folding of FCEIL, FFLOOR and FTRUNC instructions.

[RKSimon]

ping

[qcolombet]

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

2848

Naive question: Is it possible to have a BuildVector without a VT for a vector?

test/CodeGen/X86/vec_floor.ll

228

Could it be possible to add negative test when the conversion are not precise enough?

[RKSimon]

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

2848

Yes - x86_mmx registers choke on VT.getVectorElementType() if we don't have the VT.isVector() test to stop them.

test/CodeGen/X86/vec_floor.ll

228

Yes I should be able to get something to work - probably with explicit hex values though.

[RKSimon]

test/CodeGen/X86/vec_floor.ll

228

I haven't found anything that works yet - do you known of any equivalent values in other tests? I haven't found anything so far.

[qcolombet]

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

2848

Could you add a test case for that?

test/CodeGen/X86/vec_floor.ll

228

I guess you can check for FLT_MAX before doing a ceil and FLT_MIN for a floor.
Same for double.
But to be honest, I do not know better.

[RKSimon]

I've refreshed this patch after realising that I was being a little over the top with the original implementation:

1 - we no longer need to test for the output type being a vector - this can only occur from the folded unary op being a BITCAST (to a non vector type) and no code path requires BITCASTs to treat the VT as a vector anymore. There are plenty of existing test cases that do this (vec -> mmx, vec -> i64 vec -> i128 are examples I found).

2 - we can safely use the existing scalar path for FCEIL/FFLOOR/FTRUNC ops (and avoid all that functional duplication) - if they do fail to fold they will return a FCEIL/FFLOOR/FTRUNC scalar op which will fail the vector test for a UNDEF/CONSTANT/CONSTANTFP result.

3 - despite various suggestions I've not found any floating point constant that fails on the APFloat roundToIntegral - given the patch now uses the existing scalar path that already thoroughly tests this I think we can safely just use that and just accept that its being very, very cautious. I still wonder if its possible to cause it to fail with more exotic float types but haven't found any examples in the DAGCombine or InstCombine float constant folding tests.

[qcolombet]

Hi Simon,

LGTM.

Thanks,
-Quentin

[RKSimon]

Thanks Quentin - sorry for the false starts with this one.

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
     return SDValue(N, 0);   // Return N so it doesn't get rechecked!
   }
 
   return SDValue();
 }
 
 SDValue DAGCombiner::visitFCEIL(SDNode *N) {
   SDValue N0 = N->getOperand(0);
-  ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N0);
   EVT VT = N->getValueType(0);
 
   // fold (fceil c1) -> fceil(c1)
-  if (N0CFP)
+  if (isConstantFPBuildVectorOrConstantFP(N0))
     return DAG.getNode(ISD::FCEIL, SDLoc(N), VT, N0);
 
   return SDValue();
 }
 
 SDValue DAGCombiner::visitFTRUNC(SDNode *N) {
   SDValue N0 = N->getOperand(0);
-  ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N0);
   EVT VT = N->getValueType(0);
 
   // fold (ftrunc c1) -> ftrunc(c1)
-  if (N0CFP)
+  if (isConstantFPBuildVectorOrConstantFP(N0))
     return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0);
 
   return SDValue();
 }
 
 SDValue DAGCombiner::visitFFLOOR(SDNode *N) {
   SDValue N0 = N->getOperand(0);
-  ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N0);
   EVT VT = N->getValueType(0);
 
   // fold (ffloor c1) -> ffloor(c1)
-  if (N0CFP)
+  if (isConstantFPBuildVectorOrConstantFP(N0))
     return DAG.getNode(ISD::FFLOOR, SDLoc(N), VT, N0);
 
   return SDValue();
 }
 
 // FIXME: FNEG and FABS have a lot in common; refactor.
 SDValue DAGCombiner::visitFNEG(SDNode *N) {
   SDValue N0 = N->getOperand(0);

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

case ISD::BITCAST:
       else if (VT == MVT::i64 && C->getValueType(0) == MVT::f64)
         return getConstant(V.bitcastToAPInt().getZExtValue(), VT);
       break;
     }
   }
 
   // Constant fold unary operations with a vector integer or float operand.
   if (BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Operand.getNode())) {
     if (BV->isConstant()) {
       switch (Opcode) {
       default:
         // FIXME: Entirely reasonable to perform folding of other unary
         // operations here as the need arises.
         break;
       case ISD::FNEG:
       case ISD::FABS:
+      case ISD::FCEIL:
+      case ISD::FTRUNC:
+      case ISD::FFLOOR:
       case ISD::FP_EXTEND:
       case ISD::TRUNCATE:
       case ISD::UINT_TO_FP:
       case ISD::SINT_TO_FP: {
         // Let the above scalar folding handle the folding of each element.
         SmallVector<SDValue, 8> Ops;
         for (int i = 0, e = VT.getVectorNumElements(); i != e; ++i) {
           SDValue OpN = BV->getOperand(i);
           OpN = getNode(Opcode, DL, VT.getVectorElementType(), OpN);
           if (OpN.getOpcode() != ISD::UNDEF &&
               OpN.getOpcode() != ISD::Constant &&
               OpN.getOpcode() != ISD::ConstantFP)
             break;
           Ops.push_back(OpN);
         }
         if (Ops.size() == VT.getVectorNumElements())
           return getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
+        break;
       }
       }
     }
   }
 
   unsigned OpOpcode = Operand.getNode()->getOpcode();
   switch (Opcode) {
   case ISD::TokenFactor:

test/CodeGen/X86/vec_floor.ll

 define <8 x float> @nearbyint_v8f32(<8 x float> %p)
 {
   ; CHECK: nearbyint_v8f32
   ; CHECK: vroundps
   %t = call <8 x float> @llvm.nearbyint.v8f32(<8 x float> %p)
   ret <8 x float> %t
 }
 declare <8 x float> @llvm.nearbyint.v8f32(<8 x float> %p)
+
+;
+; Constant Folding
+;
+
+define <2 x double> @const_floor_v2f64() {
+  ; CHECK: const_floor_v2f64
+  ; CHECK: movaps {{.*#+}} xmm0 = [-2.000000e+00,2.000000e+00]
+  %t = call <2 x double> @llvm.floor.v2f64(<2 x double> <double -1.5, double 2.5>)
+  ret <2 x double> %t
+}
+
+define <4 x float> @const_floor_v4f32() {
+  ; CHECK: const_floor_v4f32
+  ; CHECK: movaps {{.*#+}} xmm0 = [-4.000000e+00,6.000000e+00,-9.000000e+00,2.000000e+00]
+  %t = call <4 x float> @llvm.floor.v4f32(<4 x float> <float -3.5, float 6.0, float -9.0, float 2.5>)
+  ret <4 x float> %t
+}
+
+define <2 x double> @const_ceil_v2f64() {
+  ; CHECK: const_ceil_v2f64
+  ; CHECK: movaps {{.*#+}} xmm0 = [-1.000000e+00,3.000000e+00]
+  %t = call <2 x double> @llvm.ceil.v2f64(<2 x double> <double -1.5, double 2.5>)
+  ret <2 x double> %t
+}
+
+define <4 x float> @const_ceil_v4f32() {
+  ; CHECK: const_ceil_v4f32
+  ; CHECK: movaps {{.*#+}} xmm0 = [-3.000000e+00,6.000000e+00,-9.000000e+00,3.000000e+00]
+  %t = call <4 x float> @llvm.ceil.v4f32(<4 x float> <float -3.5, float 6.0, float -9.0, float 2.5>)
+  ret <4 x float> %t
+}
+
+define <2 x double> @const_trunc_v2f64() {
+  ; CHECK: const_trunc_v2f64
+  ; CHECK: movaps {{.*#+}} xmm0 = [-1.000000e+00,2.000000e+00]
+  %t = call <2 x double> @llvm.trunc.v2f64(<2 x double> <double -1.5, double 2.5>)
+  ret <2 x double> %t
+}
+
+define <4 x float> @const_trunc_v4f32() {
+  ; CHECK: const_trunc_v4f32
+  ; CHECK: movaps {{.*#+}} xmm0 = [-3.000000e+00,6.000000e+00,-9.000000e+00,2.000000e+00]
+  %t = call <4 x float> @llvm.trunc.v4f32(<4 x float> <float -3.5, float 6.0, float -9.0, float 2.5>)
+  ret <4 x float> %t
+}