InstCombine: Reduce minnum/maxnum if inputs are casted

[arsenm]

Summary

This is already done for the libcall. Also canonicalize constants to RHS.

[majnemer]

LGTM

[arsenm]

57a55313c3dcea2f3208d9d16463908d8eb41603

lib/Transforms/InstCombine/InstCombineCalls.cpp

case Intrinsic::ssub_with_overflow: {
     Value *OperationResult = nullptr;
     Constant *OverflowResult = nullptr;
     if (OptimizeOverflowCheck(OCF, II->getArgOperand(0), II->getArgOperand(1),
                               *II, OperationResult, OverflowResult))
       return CreateOverflowTuple(II, OperationResult, OverflowResult);
 
     break;
   }
-
-  case Intrinsic::minnum:
-  case Intrinsic::maxnum: {
-    Value *Arg0 = II->getArgOperand(0);
-    Value *Arg1 = II->getArgOperand(1);
-    // Canonicalize constants to the RHS.
-    if (isa<ConstantFP>(Arg0) && !isa<ConstantFP>(Arg1)) {
-      II->setArgOperand(0, Arg1);
-      II->setArgOperand(1, Arg0);
-      return II;
-    }
-    if (Value *V = simplifyMinnumMaxnum(*II))
-      return replaceInstUsesWith(*II, V);
-    break;
-  }
   case Intrinsic::fma:
   case Intrinsic::fmuladd: {
     Value *Src0 = II->getArgOperand(0);
     Value *Src1 = II->getArgOperand(1);
 
     // Canonicalize constants into the RHS.
     if (isa<Constant>(Src0) && !isa<Constant>(Src1)) {
       II->setArgOperand(0, Src1);
if (match(Src, m_FNeg(m_Value(SrcSrc))) ||
       // cos(-x) -> cos(x)
       // cos(fabs(x)) -> cos(x)
       II->setArgOperand(0, SrcSrc);
       return II;
     }
 
     break;
   }
+  case Intrinsic::minnum:
+  case Intrinsic::maxnum: {
+    Value *Arg0 = II->getArgOperand(0);
+    Value *Arg1 = II->getArgOperand(1);
+
+    // Canonicalize constants to the RHS.
+    if (match(Arg0, m_Constant()) && !match(Arg1, m_Constant())) {
+      II->setArgOperand(0, Arg1);
+      II->setArgOperand(1, Arg0);
+      return II;
+    }
+    if (Value *V = simplifyMinnumMaxnum(*II))
+      return replaceInstUsesWith(*II, V);
+
+    LLVM_FALLTHROUGH;
+  }
   case Intrinsic::copysign: {
     Value *ExtSrc0;
     Value *ExtSrc1;
 
     // copysign (fpext x), (fpext y) -> copysign x, y
+    // minnum (fpext x), (fpext y) -> minnum x, y
+    // maxnum (fpext x), (fpext y) -> maxnum x, y
     if (match(II->getArgOperand(0), m_FPExt(m_Value(ExtSrc0))) &&
         match(II->getArgOperand(1), m_FPExt(m_Value(ExtSrc1))) &&
         ExtSrc0->getType() == ExtSrc1->getType()) {
       Value *F = Intrinsic::getDeclaration(II->getModule(), II->getIntrinsicID(),
                                            { ExtSrc0->getType() });
       CallInst *NewCall = Builder->CreateCall(F, { ExtSrc0, ExtSrc1 });
       NewCall->copyFastMathFlags(II);
       NewCall->takeName(II);

test/Transforms/InstCombine/maxnum.ll

 ; RUN: opt -S -instcombine < %s | FileCheck %s
 
 declare float @llvm.maxnum.f32(float, float) #0
-declare float @llvm.maxnum.v2f32(<2 x float>, <2 x float>) #0
+declare <2 x float> @llvm.maxnum.v2f32(<2 x float>, <2 x float>) #0
 declare <4 x float> @llvm.maxnum.v4f32(<4 x float>, <4 x float>) #0
 
 declare double @llvm.maxnum.f64(double, double) #0
 declare <2 x double> @llvm.maxnum.v2f64(<2 x double>, <2 x double>) #0
 
 ; CHECK-LABEL: @constant_fold_maxnum_f32
 ; CHECK-NEXT: ret float 2.000000e+00
 define float @constant_fold_maxnum_f32() #0 {

 
 ; CHECK-LABEL: @fold_maxnum_f32_undef_val
 ; CHECK-NEXT: ret float %x
 define float @fold_maxnum_f32_undef_val(float %x) nounwind {
   %val = call float @llvm.maxnum.f32(float undef, float %x) #0
   ret float %val
 }
 
+; CHECK-LABEL: @canonicalize_constant_maxnum_v2f32(
+; CHECK: call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> <float 1.000000e+00, float 2.000000e+00>)
+define <2 x float> @canonicalize_constant_maxnum_v2f32(<2 x float> %x) #0 {
+  %y = call <2 x float> @llvm.maxnum.v2f32(<2 x float> <float 1.0, float 2.0>, <2 x float> %x) #0
+  ret <2 x float> %y
+}
+
 ; CHECK-LABEL: @maxnum_x_maxnum_x_y
 ; CHECK-NEXT: call float @llvm.maxnum.f32(float %x, float %y)
 ; CHECK-NEXT: ret float
 define float @maxnum_x_maxnum_x_y(float %x, float %y) #0 {
   %a = call float @llvm.maxnum.f32(float %x, float %y) #0
   %b = call float @llvm.maxnum.f32(float %x, float %a) #0
   ret float %b
 }

 ; CHECK-LABEL: @fold_maxnum_f32_neginf_val
 ; CHECK-NEXT: call float @llvm.maxnum.f32(float %x, float 0xFFF0000000000000)
 ; CHECK-NEXT: ret float
 define float @fold_maxnum_f32_neginf_val(float %x) nounwind {
   %val = call float @llvm.maxnum.f32(float 0xFFF0000000000000, float %x) #0
   ret float %val
 }
 
+; CHECK-LABEL: @reduce_precision(
+; CHECK: %maxnum = call float @llvm.maxnum.f32(float %x, float %y)
+; CHECK-NEXT: ret float %maxnum
+define float @reduce_precision(float %x, float %y) {
+  %x.ext = fpext float %x to double
+  %y.ext = fpext float %y to double
+  %maxnum = call double @llvm.maxnum.f64(double %x.ext, double %y.ext)
+  %trunc = fptrunc double %maxnum to float
+  ret float %trunc
+}
+
+; CHECK-LABEL: @reduce_precision_fmf(
+; CHECK: %maxnum = call nnan float @llvm.maxnum.f32(float %x, float %y)
+; CHECK-NEXT: ret float %maxnum
+define float @reduce_precision_fmf(float %x, float %y) {
+  %x.ext = fpext float %x to double
+  %y.ext = fpext float %y to double
+  %maxnum = call nnan double @llvm.maxnum.f64(double %x.ext, double %y.ext)
+  %trunc = fptrunc double %maxnum to float
+  ret float %trunc
+}
+
 attributes #0 = { nounwind readnone }

test/Transforms/InstCombine/minnum.ll

 ; RUN: opt -S -instcombine < %s | FileCheck %s
 
 declare float @llvm.minnum.f32(float, float) #0
-declare float @llvm.minnum.v2f32(<2 x float>, <2 x float>) #0
+declare <2 x float> @llvm.minnum.v2f32(<2 x float>, <2 x float>) #0
 declare <4 x float> @llvm.minnum.v4f32(<4 x float>, <4 x float>) #0
 
 declare double @llvm.minnum.f64(double, double) #0
 declare <2 x double> @llvm.minnum.v2f64(<2 x double>, <2 x double>) #0
 
 declare float @llvm.maxnum.f32(float, float) #0
 
 ; CHECK-LABEL: @constant_fold_minnum_f32

 
 ; CHECK-LABEL: @fold_minnum_f32_undef_val
 ; CHECK-NEXT: ret float %x
 define float @fold_minnum_f32_undef_val(float %x) nounwind {
   %val = call float @llvm.minnum.f32(float undef, float %x) #0
   ret float %val
 }
 
+; CHECK-LABEL: @canonicalize_constant_minnum_v2f32(
+; CHECK: call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> <float 1.000000e+00, float 2.000000e+00>)
+define <2 x float> @canonicalize_constant_minnum_v2f32(<2 x float> %x) #0 {
+  %y = call <2 x float> @llvm.minnum.v2f32(<2 x float> <float 1.0, float 2.0>, <2 x float> %x) #0
+  ret <2 x float> %y
+}
+
 ; CHECK-LABEL: @minnum_x_minnum_x_y
 ; CHECK-NEXT: call float @llvm.minnum.f32(float %x, float %y)
 ; CHECK-NEXT: ret float
 define float @minnum_x_minnum_x_y(float %x, float %y) #0 {
   %a = call float @llvm.minnum.f32(float %x, float %y) #0
   %b = call float @llvm.minnum.f32(float %x, float %a) #0
   ret float %b
 }

 
 ; CHECK-LABEL: @fold_minnum_f32_minf_val
 ; CHECK-NEXT: ret float 0xFFF0000000000000
 define float @fold_minnum_f32_minf_val(float %x) nounwind {
   %val = call float @llvm.minnum.f32(float 0xFFF0000000000000, float %x) #0
   ret float %val
 }
 
+; CHECK-LABEL: @reduce_precision(
+; CHECK: %minnum = call float @llvm.minnum.f32(float %x, float %y)
+; CHECK-NEXT: ret float %minnum
+define float @reduce_precision(float %x, float %y) {
+  %x.ext = fpext float %x to double
+  %y.ext = fpext float %y to double
+  %minnum = call double @llvm.minnum.f64(double %x.ext, double %y.ext)
+  %trunc = fptrunc double %minnum to float
+  ret float %trunc
+}
+
+; CHECK-LABEL: @reduce_precision_fmf(
+; CHECK: %minnum = call nnan float @llvm.minnum.f32(float %x, float %y)
+; CHECK-NEXT: ret float %minnum
+define float @reduce_precision_fmf(float %x, float %y) {
+  %x.ext = fpext float %x to double
+  %y.ext = fpext float %y to double
+  %minnum = call nnan double @llvm.minnum.f64(double %x.ext, double %y.ext)
+  %trunc = fptrunc double %minnum to float
+  ret float %trunc
+}
+
 attributes #0 = { nounwind readnone }