[InstCombine] Allow fptrunc (fpext X)) to be reduced to a single fpext/ftrunc

[craig.topper]

Summary

If we are only removing bits that were added by the extend we should be able to use a smaller extend. I think.

We already reduce cases like this when there is binop in between. For example:

define float @bar(half %a, half %x) {
    %b = fpext half %a to double
    %z = fpext half %x to double
    %y = fmul double %b, %z
    %c = fptrunc double %y to float
    ret float %c
}

[scanon]

We should be able to go farther and just do a fptrunc if SrcSize > DstSize.

[craig.topper]

Allow it to be turned into fptrunc as well. Which I believe makes it equivalent to the handler for integers.

[craig.topper]

Add directed tests

[efriedma]

Does this do the right thing for a trunc/ext sequence converting from ppc_fp128 to fp128?

[craig.topper]

Probably not, but I don't know how to create that case without an intermediate type larger than 128-bits. Unless I'm missing something.

[efriedma]

Oh, yes, you're right; not sure what I was thinking.

[scanon]

lib/IR/Instructions.cpp

2269–2270

I don't think that this comment clarifies anything, since case 10 no longer exists. It would probably be clearer to just remove it; the repository history documents what it "used to be".

[craig.topper]

Remove comment and rebase

[scanon]

LGTM.

lib/IR/Instructions.cpp

static const uint8_t CastResults[numCastOps][numCastOps] = {
     {  1, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // Trunc         -+
     {  8, 1, 9,99,99, 2,17,99,99,99, 2, 3, 0}, // ZExt           |
     {  8, 0, 1,99,99, 0, 2,99,99,99, 0, 3, 0}, // SExt           |
     {  0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToUI         |
     {  0, 0, 0,99,99, 0, 0,99,99,99, 0, 3, 0}, // FPToSI         |
     { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // UIToFP         +- firstOp
     { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // SIToFP         |
     { 99,99,99, 0, 0,99,99, 0, 0,99,99, 4, 0}, // FPTrunc        |
-    { 99,99,99, 2, 2,99,99,10, 2,99,99, 4, 0}, // FPExt          |
+    { 99,99,99, 2, 2,99,99, 8, 2,99,99, 4, 0}, // FPExt          |
     {  1, 0, 0,99,99, 0, 0,99,99,99, 7, 3, 0}, // PtrToInt       |
     { 99,99,99,99,99,99,99,99,99,11,99,15, 0}, // IntToPtr       |
     {  5, 5, 5, 6, 6, 5, 5, 6, 6,16, 5, 1,14}, // BitCast        |
     {  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,13,12}, // AddrSpaceCast -+
   };
 
   // TODO: This logic could be encoded into the table above and handled in the
   // switch below.
case 8: {
       if (SrcSize == DstSize)
         return Instruction::BitCast;
       else if (SrcSize < DstSize)
         return firstOp;
       return secondOp;
     }
     case 9:
       // zext, sext -> zext, because sext can't sign extend after zext
       return Instruction::ZExt;
-    case 10:
-      // fpext followed by ftrunc is allowed if the bit size returned to is
-      // the same as the original, in which case its just a bitcast
-      if (SrcTy == DstTy)
-        return Instruction::BitCast;
-      return 0; // If the types are not the same we can't eliminate it.
     case 11: {
       // inttoptr, ptrtoint -> bitcast if SrcSize<=PtrSize and SrcSize==DstSize
       if (!MidIntPtrTy)
         return 0;
       unsigned PtrSize = MidIntPtrTy->getScalarSizeInBits();
       unsigned SrcSize = SrcTy->getScalarSizeInBits();
       unsigned DstSize = DstTy->getScalarSizeInBits();
       if (SrcSize <= PtrSize && SrcSize == DstSize)
         return Instruction::BitCast;

test/Transforms/InstCombine/double-float-shrink-2.ll

;
   %E = call fast double @llvm.fabs.f64(double %D)
   %F = fptrunc double %E to half
   ret half %F
 }
 
 define float @test_shrink_intrin_floor_fp16_src(half %C) {
 ; ALL-LABEL: @test_shrink_intrin_floor_fp16_src(
 ; ALL-NEXT:    [[E:%.*]] = call half @llvm.floor.f16(half [[C:%.*]])
-; ALL-NEXT:    [[TMP1:%.*]] = fpext half [[E]] to double
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[TMP1]] to float
+; ALL-NEXT:    [[F:%.*]] = fpext half [[E]] to float
 ; ALL-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.floor.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
 define float @test_shrink_intrin_ceil_fp16_src(half %C) {
 ; ALL-LABEL: @test_shrink_intrin_ceil_fp16_src(
 ; ALL-NEXT:    [[E:%.*]] = call half @llvm.ceil.f16(half [[C:%.*]])
-; ALL-NEXT:    [[TMP1:%.*]] = fpext half [[E]] to double
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[TMP1]] to float
+; ALL-NEXT:    [[F:%.*]] = fpext half [[E]] to float
 ; ALL-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.ceil.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
 define float @test_shrink_intrin_round_fp16_src(half %C) {
 ; ALL-LABEL: @test_shrink_intrin_round_fp16_src(
 ; ALL-NEXT:    [[E:%.*]] = call half @llvm.round.f16(half [[C:%.*]])
-; ALL-NEXT:    [[TMP1:%.*]] = fpext half [[E]] to double
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[TMP1]] to float
+; ALL-NEXT:    [[F:%.*]] = fpext half [[E]] to float
 ; ALL-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.round.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
 define float @test_shrink_intrin_nearbyint_fp16_src(half %C) {
 ; ALL-LABEL: @test_shrink_intrin_nearbyint_fp16_src(
 ; ALL-NEXT:    [[E:%.*]] = call half @llvm.nearbyint.f16(half [[C:%.*]])
-; ALL-NEXT:    [[TMP1:%.*]] = fpext half [[E]] to double
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[TMP1]] to float
+; ALL-NEXT:    [[F:%.*]] = fpext half [[E]] to float
 ; ALL-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.nearbyint.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
 define float @test_shrink_intrin_trunc_fp16_src(half %C) {
 ; ALL-LABEL: @test_shrink_intrin_trunc_fp16_src(
 ; ALL-NEXT:    [[E:%.*]] = call half @llvm.trunc.f16(half [[C:%.*]])
-; ALL-NEXT:    [[TMP1:%.*]] = fpext half [[E]] to double
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[TMP1]] to float
+; ALL-NEXT:    [[F:%.*]] = fpext half [[E]] to float
 ; ALL-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.trunc.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
 define float @test_shrink_intrin_fabs_fp16_src(half %C) {
 ; ALL-LABEL: @test_shrink_intrin_fabs_fp16_src(
 ; ALL-NEXT:    [[E:%.*]] = call half @llvm.fabs.f16(half [[C:%.*]])
-; ALL-NEXT:    [[TMP1:%.*]] = fpext half [[E]] to double
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[TMP1]] to float
+; ALL-NEXT:    [[F:%.*]] = fpext half [[E]] to float
 ; ALL-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call double @llvm.fabs.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 
 ; Make sure fast math flags are preserved
 define float @test_shrink_intrin_fabs_fast_fp16_src(half %C) {
 ; ALL-LABEL: @test_shrink_intrin_fabs_fast_fp16_src(
 ; ALL-NEXT:    [[E:%.*]] = call fast half @llvm.fabs.f16(half [[C:%.*]])
-; ALL-NEXT:    [[TMP1:%.*]] = fpext half [[E]] to double
-; ALL-NEXT:    [[F:%.*]] = fptrunc double [[TMP1]] to float
+; ALL-NEXT:    [[F:%.*]] = fpext half [[E]] to float
 ; ALL-NEXT:    ret float [[F]]
 ;
   %D = fpext half %C to double
   %E = call fast double @llvm.fabs.f64(double %D)
   %F = fptrunc double %E to float
   ret float %F
 }
 

test/Transforms/InstCombine/fpextend.ll

;
   %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
 }
 
 define half @test7(float %a) nounwind {
 ; CHECK-LABEL: @test7(
-; CHECK-NEXT:    [[Y:%.*]] = fpext float [[A:%.*]] to double
-; CHECK-NEXT:    [[Z:%.*]] = fptrunc double [[Y]] to half
+; CHECK-NEXT:    [[Z:%.*]] = fptrunc float [[A:%.*]] to half
 ; CHECK-NEXT:    ret half [[Z]]
 ;
   %y = fpext float %a to double
   %z = fptrunc double %y to half
   ret half %z
 }
 
 define float @test8(half %a) nounwind {
 ; CHECK-LABEL: @test8(
-; CHECK-NEXT:    [[Y:%.*]] = fpext half [[A:%.*]] to double
-; CHECK-NEXT:    [[Z:%.*]] = fptrunc double [[Y]] to float
+; CHECK-NEXT:    [[Z:%.*]] = fpext half [[A:%.*]] to float
 ; CHECK-NEXT:    ret float [[Z]]
 ;
   %y = fpext half %a to double
   %z = fptrunc double %y to float
   ret float %z
 }
 
 define float @test9(half %x, half %y) nounwind  {