Broaden FoldItoFPtoI to try and establish whether the integer value fits into the float type

[aarzee]

Summary

Previously, FoldItoFPtoI would only check if the width of the integer type fits into the width of the mantissa. This change will now let it fold if it can establish that the actual value of the integer fits within the floating point type (both mantissa and exponent are considered).

[aarzee]

See D19178.

lib/Transforms/InstCombine/InstCombineCasts.cpp

 }
 
 Instruction *InstCombiner::visitTrunc(TruncInst &CI) {
   if (Instruction *Result = commonCastTransforms(CI))
     return Result;
 
   // Test if the trunc is the user of a select which is part of a
   // minimum or maximum operation. If so, don't do any more simplification.
-  // Even simplifying demanded bits can break the canonical form of a 
+  // Even simplifying demanded bits can break the canonical form of a
   // min/max.
   Value *LHS, *RHS;
   if (SelectInst *SI = dyn_cast<SelectInst>(CI.getOperand(0)))
     if (matchSelectPattern(SI, LHS, RHS).Flavor != SPF_UNKNOWN)
       return nullptr;
-  
   // See if we can simplify any instructions used by the input whose sole
   // purpose is to compute bits we don't care about.
   if (SimplifyDemandedInstructionBits(CI))
     return &CI;
 
   Value *Src = CI.getOperand(0);
   Type *DestTy = CI.getType(), *SrcTy = Src->getType();
 
Instruction *InstCombiner::visitSExt(SExtInst &CI) {
   // purpose is to compute bits we don't care about.
   if (SimplifyDemandedInstructionBits(CI))
     return &CI;
 
   Value *Src = CI.getOperand(0);
   Type *SrcTy = Src->getType(), *DestTy = CI.getType();
 
   // If we know that the value being extended is positive, we can use a zext
-  // instead. 
+  // instead.
   bool KnownZero, KnownOne;
   ComputeSignBit(Src, KnownZero, KnownOne, 0, &CI);
   if (KnownZero) {
     Value *ZExt = Builder->CreateZExt(Src, DestTy);
     return replaceInstUsesWith(CI, ZExt);
   }
 
   // Attempt to extend the entire input expression tree to the destination

 Instruction *InstCombiner::visitFPExt(CastInst &CI) {
   return commonCastTransforms(CI);
 }
 
 // fpto{s/u}i({u/s}itofp(X)) --> X or zext(X) or sext(X) or trunc(X)
 // This is safe if the intermediate type has enough bits in its mantissa to
 // accurately represent all values of X.  For example, this won't work with
 // i64 -> float -> i64.
+// However, this is also safe if we can establish the range between most and
+// least significant set bits of abs(X) fits into the mantissa, and that the
+// number of trailing zeros fits into the exponent.
+
 Instruction *InstCombiner::FoldItoFPtoI(Instruction &FI) {
   if (!isa<UIToFPInst>(FI.getOperand(0)) && !isa<SIToFPInst>(FI.getOperand(0)))
     return nullptr;
   Instruction *OpI = cast<Instruction>(FI.getOperand(0));
 
   Value *SrcI = OpI->getOperand(0);
   Type *FITy = FI.getType();
   Type *OpITy = OpI->getType();
Instruction *InstCombiner::FoldItoFPtoI(Instruction &FI) {
   // of the input range and output range.
 
   // This means this is also safe for a signed input and unsigned output, since
   // a negative input would lead to undefined behavior.
   int InputSize = (int)SrcTy->getScalarSizeInBits() - IsInputSigned;
   int OutputSize = (int)FITy->getScalarSizeInBits() - IsOutputSigned;
   int ActualSize = std::min(InputSize, OutputSize);
 
-  if (ActualSize <= OpITy->getFPMantissaWidth()) {
+  int MantissaWidth = OpITy->getFPMantissaWidth();
+
+  bool safe;
+
+  if (ActualSize <= MantissaWidth) {
+    safe = true;
+    // No need to compute known bits.
+  } else {
+    // Now try and see if the integer value fits into the fp type.
+    int LeastSignificantPossiblySetBit = 0;
+    int MostSignificantPossiblySetBit = 0;
+    int BitRange = 0;
+    uint32_t BitWidth = SrcTy->getScalarSizeInBits();
+    APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
+    computeKnownBits(SrcI, KnownZero, KnownOne, 0, &FI);
+    for (unsigned i = 0; i < BitWidth - 1; i++) {
+      if (!KnownZero[i]) {
+        LeastSignificantPossiblySetBit = i;
+        break;
+      }
+    }
+    for (unsigned i = 0, j; i < BitWidth - 1; i++) {
+      j = BitWidth - i - 1;
+      if (!KnownZero[j]) {
+        bool offsetOne = (IsInputSigned || !KnownZero[BitWidth - 1]) &&
+            (!KnownOne[BitWidth - 1] || KnownZero.countTrailingOnes() < j);
+        MostSignificantPossiblySetBit = j - offsetOne;
+        break;
+      }
+    }
+    BitRange = MostSignificantPossiblySetBit - LeastSignificantPossiblySetBit + 1;
+    safe = BitRange < MantissaWidth && LeastSignificantPossiblySetBit <
+      ((int)OpITy->getScalarSizeInBits() - 1 - BitRange);
+  }
+
+  if (safe) {
     if (FITy->getScalarSizeInBits() > SrcTy->getScalarSizeInBits()) {
       if (IsInputSigned && IsOutputSigned)
         return new SExtInst(SrcI, FITy);
       return new ZExtInst(SrcI, FITy);
     }
     if (FITy->getScalarSizeInBits() < SrcTy->getScalarSizeInBits())
       return new TruncInst(SrcI, FITy);
     if (SrcTy == FITy)

test/Transforms/InstCombine/sitofp.ll

 ; CHECK: sitofp
 ; CHECK-NEXT: fptosi
 define i55 @test19(i64 %A) nounwind {
  %B = sitofp i64 %A to double
  %C = fptosi double %B to i55
  ret i55 %C
 }
 
+; This should fold because even though the bit width of the integer
+; is greater than that of the mantissa, we can establish that the
+; actual value of the integer will fit into the mantissa.
+; CHECK-LABEL: test20
+; CHECK: and
+; CHECK-NEST: ret i32
+define i32 @test20(i32 %A) nounwind {
+ %B = and i32 %A, 16777215
+ %C = sitofp i32 %B to float
+ %D = fptosi float %C to i32
+ ret i32 %D
+}
+
+; This should fold, because even though the effective exponent is
+; 2**24, which does not fit into float's exponent, we can just
+; shift the mantissa 1 bit to the left to compensate.
+; CHECK-LABEL: test21
+; CHECK: and
+; CHECK-NEST: ret i32
+define i32 @test21(i32 %A) nounwind {
+ %B = and i32 %A, 16777216
+ %C = sitofp i32 %B to float
+ %D = fptosi float %C to i32
+ ret i32 %D
+}