[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/include/llvm/IR/PatternMatch.h

 }
 
 /// Matches SIToFP.
 template <typename OpTy>
 inline CastClass_match<OpTy, Instruction::SIToFP> m_SIToFP(const OpTy &Op) {
   return CastClass_match<OpTy, Instruction::SIToFP>(Op);
 }
 
+template <typename OpTy>
+inline CastClass_match<OpTy, Instruction::FPToUI> m_FPToUI(const OpTy &Op) {
+  return CastClass_match<OpTy, Instruction::FPToUI>(Op);
+}
+
+template <typename OpTy>
+inline CastClass_match<OpTy, Instruction::FPToSI> m_FPToSI(const OpTy &Op) {
+  return CastClass_match<OpTy, Instruction::FPToSI>(Op);
+}
+
 /// Matches FPTrunc
 template <typename OpTy>
 inline CastClass_match<OpTy, Instruction::FPTrunc> m_FPTrunc(const OpTy &Op) {
   return CastClass_match<OpTy, Instruction::FPTrunc>(Op);
 }
 
 /// Matches FPExt
 template <typename OpTy>

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

Instruction *InstCombiner::visitFPTrunc(FPTruncInst &FPT) {
   }
 
   if (Instruction *I = shrinkInsertElt(FPT, Builder))
     return I;
 
   return nullptr;
 }
 
-Instruction *InstCombiner::visitFPExt(CastInst &CI) {
-  return commonCastTransforms(CI);
+Instruction *InstCombiner::visitFPExt(CastInst &FPExt) {
+  Value *X = FPExt.getOperand(0);
+
+  // If a value is being cast to integer and to the same or wider FP type before
+  // being extended, the extend can be folded into the cast from integer to FP.
+  // The cast from integer to FP must be exact in the intermediate FP type (and
+  // therefore also in the final FP type). If the cast to integer had
+  // overflowed, the result would be poison. Example:
+  //     fpext (sitofp (fptosi half F to iN) to float) to double -->
+  //     sitofp (fptosi half F to iN) to double
+  Value *I, *F;
+  if (match(X, m_SIToFP(m_Value(I))) && match(I, m_FPToSI(m_Value(F))) &&
+      F->getType()->getFPMantissaWidth() <= X->getType()->getFPMantissaWidth())
+    return CastInst::Create(CastInst::SIToFP, I, FPExt.getType());
+
+  if (match(X, m_UIToFP(m_Value(I))) && match(I, m_FPToUI(m_Value(F))) &&
+      F->getType()->getFPMantissaWidth() <= X->getType()->getFPMantissaWidth())
+    return CastInst::Create(CastInst::UIToFP, I, FPExt.getType());
+
+  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(Instruction &FI) {
   if (!isa<UIToFPInst>(FI.getOperand(0)) && !isa<SIToFPInst>(FI.getOperand(0)))

llvm/test/Transforms/InstCombine/fpextend.ll

;
   %t5 = frem double %t1, %t23
   %t56 = fptrunc double %t5 to float
   ret float %t56
 }
 
 define double @FtoItoFtoF_f32_s32_f32_f64(float %f) {
 ; CHECK-LABEL: @FtoItoFtoF_f32_s32_f32_f64(
 ; CHECK-NEXT:    [[I:%.*]] = fptosi float [[F:%.*]] to i32
-; CHECK-NEXT:    [[X:%.*]] = sitofp i32 [[I]] to float
-; CHECK-NEXT:    [[R:%.*]] = fpext float [[X]] to double
+; CHECK-NEXT:    [[R:%.*]] = sitofp i32 [[I]] to double
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %i = fptosi float %f to i32
   %x = sitofp i32 %i to float
   %r = fpext float %x to double
   ret double %r
 }
 
 declare void @use_i32(i32)
 declare void @use_f32(float)
 
 ; Extra uses are ok; unsigned is ok.
 
 define double @FtoItoFtoF_f32_u32_f32_f64_extra_uses(float %f) {
 ; CHECK-LABEL: @FtoItoFtoF_f32_u32_f32_f64_extra_uses(
 ; CHECK-NEXT:    [[I:%.*]] = fptoui float [[F:%.*]] to i32
 ; CHECK-NEXT:    call void @use_i32(i32 [[I]])
 ; CHECK-NEXT:    [[X:%.*]] = uitofp i32 [[I]] to float
 ; CHECK-NEXT:    call void @use_f32(float [[X]])
-; CHECK-NEXT:    [[R:%.*]] = fpext float [[X]] to double
+; CHECK-NEXT:    [[R:%.*]] = uitofp i32 [[I]] to double
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %i = fptoui float %f to i32
   call void @use_i32(i32 %i)
   %x = uitofp i32 %i to float
   call void @use_f32(float %x)
   %r = fpext float %x to double
   ret double %r
 }
 
 ; Vectors are ok; initial type can be smaller than intermediate type.
 
 define <3 x double> @FtoItoFtoF_v3f16_v3s32_v3f32_v3f64(<3 x half> %f) {
 ; CHECK-LABEL: @FtoItoFtoF_v3f16_v3s32_v3f32_v3f64(
 ; CHECK-NEXT:    [[I:%.*]] = fptosi <3 x half> [[F:%.*]] to <3 x i32>
-; CHECK-NEXT:    [[X:%.*]] = sitofp <3 x i32> [[I]] to <3 x float>
-; CHECK-NEXT:    [[R:%.*]] = fpext <3 x float> [[X]] to <3 x double>
+; CHECK-NEXT:    [[R:%.*]] = sitofp <3 x i32> [[I]] to <3 x double>
 ; CHECK-NEXT:    ret <3 x double> [[R]]
 ;
   %i = fptosi <3 x half> %f to <3 x i32>
   %x = sitofp <3 x i32> %i to <3 x float>
   %r = fpext <3 x float> %x to <3 x double>
   ret <3 x double> %r
 }
 
+; Wider than double is ok.
+
 define fp128 @FtoItoFtoF_f32_s64_f64_f128(float %f) {
 ; CHECK-LABEL: @FtoItoFtoF_f32_s64_f64_f128(
 ; CHECK-NEXT:    [[I:%.*]] = fptosi float [[F:%.*]] to i64
-; CHECK-NEXT:    [[X:%.*]] = sitofp i64 [[I]] to double
-; CHECK-NEXT:    [[R:%.*]] = fpext double [[X]] to fp128
+; CHECK-NEXT:    [[R:%.*]] = sitofp i64 [[I]] to fp128
 ; CHECK-NEXT:    ret fp128 [[R]]
 ;
   %i = fptosi float %f to i64
   %x = sitofp i64 %i to double
   %r = fpext double %x to fp128
   ret fp128 %r
 }
 
+; Target-specific type is ok.
+
 define x86_fp80 @FtoItoFtoF_f64_u32_f64_f80(double %f) {
 ; CHECK-LABEL: @FtoItoFtoF_f64_u32_f64_f80(
 ; CHECK-NEXT:    [[I:%.*]] = fptoui double [[F:%.*]] to i32
-; CHECK-NEXT:    [[X:%.*]] = uitofp i32 [[I]] to double
-; CHECK-NEXT:    [[R:%.*]] = fpext double [[X]] to x86_fp80
+; CHECK-NEXT:    [[R:%.*]] = uitofp i32 [[I]] to x86_fp80
 ; CHECK-NEXT:    ret x86_fp80 [[R]]
 ;
   %i = fptoui double %f to i32
   %x = uitofp i32 %i to double
   %r = fpext double %x to x86_fp80
   ret x86_fp80 %r
 }
 
+; Weird target-specific type is ok (not possible to extend *from* that type).
+
 define ppc_fp128 @FtoItoFtoF_f64_u32_f64_p128(double %f) {
 ; CHECK-LABEL: @FtoItoFtoF_f64_u32_f64_p128(
 ; CHECK-NEXT:    [[I:%.*]] = fptoui double [[F:%.*]] to i32
-; CHECK-NEXT:    [[X:%.*]] = uitofp i32 [[I]] to double
-; CHECK-NEXT:    [[R:%.*]] = fpext double [[X]] to ppc_fp128
+; CHECK-NEXT:    [[R:%.*]] = uitofp i32 [[I]] to ppc_fp128
 ; CHECK-NEXT:    ret ppc_fp128 [[R]]
 ;
   %i = fptoui double %f to i32
   %x = uitofp i32 %i to double
   %r = fpext double %x to ppc_fp128
   ret ppc_fp128 %r
 }
 
+; TODO: unsigned to signed is ok because signed int has smaller magnitude.
+
 define double @FtoItoFtoF_f32_us32_f32_f64(float %f) {
 ; CHECK-LABEL: @FtoItoFtoF_f32_us32_f32_f64(
 ; CHECK-NEXT:    [[I:%.*]] = fptoui float [[F:%.*]] to i32
 ; CHECK-NEXT:    [[X:%.*]] = sitofp i32 [[I]] to float
 ; CHECK-NEXT:    [[R:%.*]] = fpext float [[X]] to double
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %i = fptoui float %f to i32
   %x = sitofp i32 %i to float
   %r = fpext float %x to double
   ret double %r
 }
 
+; Negative test: consider -1.0
+
 define double @FtoItoFtoF_f32_su32_f32_f64(float %f) {
 ; CHECK-LABEL: @FtoItoFtoF_f32_su32_f32_f64(
 ; CHECK-NEXT:    [[I:%.*]] = fptosi float [[F:%.*]] to i32
 ; CHECK-NEXT:    [[X:%.*]] = uitofp i32 [[I]] to float
 ; CHECK-NEXT:    [[R:%.*]] = fpext float [[X]] to double
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %i = fptosi float %f to i32
   %x = uitofp i32 %i to float
   %r = fpext float %x to double
   ret double %r
 }