[InstCombine] fold fpext into Xitofp

[spatel]

Summary

We can combine a floating-point extension cast with a conversion from integer if we know the earlier cast is exact. For example:
fpext (sitofp (fptosi half F to iN) to float) to double --> sitofp (fptosi half F to iN) to double

This is an optimization suggested in PR36617:
https://bugs.llvm.org/show_bug.cgi?id=36617#c19

I left the mismatched unsigned -> signed pattern out of this patch just in case there's some weird type combo that I'm not seeing. I can add that here if there's no concern.

This gives us another opportunity to test-drive Alive2 with FP ops:
http://volta.cs.utah.edu:8080/z/NfYne7

[spatel]

Ping.

[efriedma]

So the general idea here is centered around an "exact" cast: an sitofp that, for whatever reason, we know never rounds the result. This is sort of the same idea as InstCombiner::FoldItoFPtoI, except that it's using a different method to prove the exact-ness.

Would it make sense to factor out the "IsExactIToFP" predicate into a separate method?

[spatel]

In D79116#2025707, @efriedma wrote:

So the general idea here is centered around an "exact" cast: an sitofp that, for whatever reason, we know never rounds the result. This is sort of the same idea as InstCombiner::FoldItoFPtoI, except that it's using a different method to prove the exact-ness.

Would it make sense to factor out the "IsExactIToFP" predicate into a separate method?

Sure, and that makes it possible to split this patch up. In the simplest case, we don't need the leading fptoi instruction (if the integer type is narrow enough, then the itofp may be known exact).

[spatel]

Patch updated:
Created an exact-ness helper function with rG5cf17034e537, so this patch is now only enabling the simplest case - where the narrow FP type has enough mantissa bits to guarantee that the conversion from integer is exact.

[spatel]

Alive2 agrees:
http://volta.cs.utah.edu:8080/z/oGwiUu

[efriedma]

LGTM

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

static bool isKnownExactCastIntToFP(CastInst &I) {
   if (SrcSize <= FPTy->getFPMantissaWidth())
     return true;
 
   // TODO:
   // Try harder to find if the source integer type has less significant bits.
   return false;
 }
 
-Instruction *InstCombiner::visitFPExt(CastInst &CI) {
-  return commonCastTransforms(CI);
+Instruction *InstCombiner::visitFPExt(CastInst &FPExt) {
+  // If the source operand is a cast from integer to FP and known exact, then
+  // cast the integer operand directly to the destination type.
+  Type *Ty = FPExt.getType();
+  Value *Src = FPExt.getOperand(0);
+  if (isa<SIToFPInst>(Src) || isa<UIToFPInst>(Src)) {
+    auto *FPCast = cast<CastInst>(Src);
+    if (isKnownExactCastIntToFP(*FPCast))
+      return CastInst::Create(FPCast->getOpcode(), FPCast->getOperand(0), Ty);
+  }
+
+  return commonCastTransforms(FPExt);
 }
 
 /// 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.
 Instruction *InstCombiner::foldItoFPtoI(CastInst &FI) {
   if (!isa<UIToFPInst>(FI.getOperand(0)) && !isa<SIToFPInst>(FI.getOperand(0)))

llvm/test/Transforms/InstCombine/fpextend.ll

 ;
   %t1 = fpext half %x to double
   %t23 = fpext half %y to double
   %t5 = frem double %t1, %t23
   %t56 = fptrunc double %t5 to float
   ret float %t56
 }
 
+; Convert from integer is exact, so convert directly to double.
+
 define double @ItoFtoF_s25_f32_f64(i25 %i) {
 ; CHECK-LABEL: @ItoFtoF_s25_f32_f64(
-; CHECK-NEXT:    [[X:%.*]] = sitofp i25 [[I:%.*]] to float
-; CHECK-NEXT:    [[R:%.*]] = fpext float [[X]] to double
+; CHECK-NEXT:    [[R:%.*]] = sitofp i25 [[I:%.*]] to double
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %x = sitofp i25 %i to float
   %r = fpext float %x to double
   ret double %r
 }
 
+; Convert from integer is exact, so convert directly to fp128.
+
 define fp128 @ItoFtoF_u24_f32_f128(i24 %i) {
 ; CHECK-LABEL: @ItoFtoF_u24_f32_f128(
-; CHECK-NEXT:    [[X:%.*]] = uitofp i24 [[I:%.*]] to float
-; CHECK-NEXT:    [[R:%.*]] = fpext float [[X]] to fp128
+; CHECK-NEXT:    [[R:%.*]] = uitofp i24 [[I:%.*]] to fp128
 ; CHECK-NEXT:    ret fp128 [[R]]
 ;
   %x = uitofp i24 %i to float
   %r = fpext float %x to fp128
   ret fp128 %r
 }
 
+; Negative test - intermediate rounding in float type.
+
 define double @ItoFtoF_s26_f32_f64(i26 %i) {
 ; CHECK-LABEL: @ItoFtoF_s26_f32_f64(
 ; CHECK-NEXT:    [[X:%.*]] = sitofp i26 [[I:%.*]] to float
 ; CHECK-NEXT:    [[R:%.*]] = fpext float [[X]] to double
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %x = sitofp i26 %i to float
   %r = fpext float %x to double
   ret double %r
 }
 
+; Negative test - intermediate rounding in float type.
+
 define double @ItoFtoF_u25_f32_f64(i25 %i) {
 ; CHECK-LABEL: @ItoFtoF_u25_f32_f64(
 ; CHECK-NEXT:    [[X:%.*]] = uitofp i25 [[I:%.*]] to float
 ; CHECK-NEXT:    [[R:%.*]] = fpext float [[X]] to double
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %x = uitofp i25 %i to float
   %r = fpext float %x to double