[InstCombine] Combine nested min/max intrinsics with constants

[spatel]

1. Please add the tests to trunk as a preliminary commit.
2. Add tests with 0.0 and -0.0 constants, so we are sure that edge case is handled correctly.
3. Sprinkle around some fast-math-flags, so we know those are propagated correctly.
4. Make at least 1 test use vector splat constants, so we know that type works.

Side note: do you know if the reassociate pass handles these? I imagine we're going to miss the optimization in instcombine if the constants are separated in a longer chain of min/max ops.

lib/Transforms/InstCombine/InstCombineCalls.cpp

2067 ↗

(On Diff #171329)

Just call this "M" to match the code comment.

[volkan]

• Updated the tests.
• Added missing copyIRFlags call.

[volkan]

In D53774#1279675, @spatel wrote:

Side note: do you know if the reassociate pass handles these? I imagine we're going to miss the optimization in instcombine if the constants are separated in a longer chain of min/max ops.

Probably not, I couldn't find anything related to these intrinsics.

[lebedev.ri]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2067–2072 ↗

(On Diff #171735)

Can this be simplified at all using existing m_Intrinsic<>()?

[volkan]

lib/Transforms/InstCombine/InstCombineCalls.cpp

2067–2072 ↗

(On Diff #171735)

m_Intrinsic<> can be used here, but that wouldn't be simpler as we need to call that for each intrinsics.

[spatel]

Is it worth adjusting/adding some tests with NaN constants?

test/Transforms/InstCombine/maxnum.ll

177 ↗

(On Diff #171735)

maxnum(0.0, -0.0) is unspecified, but consistent within LLVM, right? Ie, we should not get random test failures on this test and the similar minnum test.

[volkan]

In D53774#1281306, @spatel wrote:

Is it worth adjusting/adding some tests with NaN constants?

I don't think it's necessary as there are already some tests in unittests/ADT/APFloatTest.cpp.

test/Transforms/InstCombine/maxnum.ll

177 ↗

(On Diff #171735)

Yes, it's consistent since we use the functions defined in APFloat to get the result. See: maxnum in include/llvm/ADT/APFloat.h.

[spatel]

LGTM

llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp

case Intrinsic::maximum: {
     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;
     }
 
+    Intrinsic::ID IID = II->getIntrinsicID();
     Value *X, *Y;
     if (match(Arg0, m_FNeg(m_Value(X))) && match(Arg1, m_FNeg(m_Value(Y))) &&
         (Arg0->hasOneUse() || Arg1->hasOneUse())) {
       // If both operands are negated, invert the call and negate the result:
       // min(-X, -Y) --> -(max(X, Y))
       // max(-X, -Y) --> -(min(X, Y))
       Intrinsic::ID NewIID;
-      switch (II->getIntrinsicID()) {
+      switch (IID) {
       case Intrinsic::maxnum:
         NewIID = Intrinsic::minnum;
         break;
       case Intrinsic::minnum:
         NewIID = Intrinsic::maxnum;
         break;
       case Intrinsic::maximum:
         NewIID = Intrinsic::minimum;
         break;
       case Intrinsic::minimum:
         NewIID = Intrinsic::maximum;
         break;
       default:
         llvm_unreachable("unexpected intrinsic ID");
       }
       Value *NewCall = Builder.CreateBinaryIntrinsic(NewIID, X, Y, II);
       Instruction *FNeg = BinaryOperator::CreateFNeg(NewCall);
       FNeg->copyIRFlags(II);
       return FNeg;
     }
+
+    // m(m(X, C2), C1) -> m(X, C)
+    const APFloat *C1, *C2;
+    if (auto *M = dyn_cast<IntrinsicInst>(Arg0)) {
+      if (M->getIntrinsicID() == IID && match(Arg1, m_APFloat(C1)) &&
+          ((match(M->getArgOperand(0), m_Value(X)) &&
+            match(M->getArgOperand(1), m_APFloat(C2))) ||
+           (match(M->getArgOperand(1), m_Value(X)) &&
+            match(M->getArgOperand(0), m_APFloat(C2))))) {
+        APFloat Res(0.0);
+        switch (IID) {
+        case Intrinsic::maxnum:
+          Res = maxnum(*C1, *C2);
+          break;
+        case Intrinsic::minnum:
+          Res = minnum(*C1, *C2);
+          break;
+        case Intrinsic::maximum:
+          Res = maximum(*C1, *C2);
+          break;
+        case Intrinsic::minimum:
+          Res = minimum(*C1, *C2);
+          break;
+        default:
+          llvm_unreachable("unexpected intrinsic ID");
+        }
+        Instruction *NewCall = Builder.CreateBinaryIntrinsic(
+            IID, X, ConstantFP::get(Arg0->getType(), Res));
+        NewCall->copyIRFlags(II);
+        return replaceInstUsesWith(*II, NewCall);
+      }
+    }
+
     break;
   }
   case Intrinsic::fmuladd: {
     // Canonicalize fast fmuladd to the separate fmul + fadd.
     if (II->isFast()) {
       BuilderTy::FastMathFlagGuard Guard(Builder);
       Builder.setFastMathFlags(II->getFastMathFlags());
       Value *Mul = Builder.CreateFMul(II->getArgOperand(0),

llvm/trunk/test/Transforms/InstCombine/maximum.ll

 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %y = call float @llvm.maximum.f32(float %x, float 0x7FF8000000000000)
   ret float %y
 }
 
 define float @maximum_f32_1_maximum_val_p0(float %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_val_p0(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float %x, float 1.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maximum.f32(float %x, float 0.0)
   %z = call float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maximum_f32_1_maximum_p0_val_fast(float %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_p0_val_fast(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.maximum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.maximum.f32(float %x, float 1.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maximum.f32(float 0.0, float %x)
   %z = call fast float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maximum_f32_1_maximum_p0_val_nnan_ninf(float %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_p0_val_nnan_ninf(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.maximum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.maximum.f32(float %x, float 1.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maximum.f32(float 0.0, float %x)
   %z = call nnan ninf float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maximum_f32_p0_maximum_val_n0(float %x) {
 ; CHECK-LABEL: @maximum_f32_p0_maximum_val_n0(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float -0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float [[Y]], float 0.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maximum.f32(float %x, float -0.0)
   %z = call float @llvm.maximum.f32(float %y, float 0.0)
   ret float %z
 }
 
 define float @maximum_f32_1_maximum_p0_val(float %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_p0_val(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maximum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maximum.f32(float %x, float 1.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maximum.f32(float 0.0, float %x)
   %z = call float @llvm.maximum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define <2 x float> @maximum_f32_1_maximum_val_p0_val_v2f32(<2 x float> %x) {
 ; CHECK-LABEL: @maximum_f32_1_maximum_val_p0_val_v2f32(
-; CHECK-NEXT: [[Y:%.*]] = call <2 x float> @llvm.maximum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
-; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.maximum.v2f32(<2 x float> [[Y]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
+; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.maximum.v2f32(<2 x float> %x, <2 x float> <float 1.000000e+00, float 1.000000e+00>)
 ; CHECK-NEXT: ret <2 x float> [[RES]]
   %y = call <2 x float> @llvm.maximum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
   %z = call <2 x float> @llvm.maximum.v2f32(<2 x float> %y, <2 x float><float 1.0, float 1.0>)
   ret <2 x float> %z
 }
 
 define float @maximum4(float %x, float %y, float %z, float %w) {
 ; CHECK-LABEL: @maximum4(

llvm/trunk/test/Transforms/InstCombine/maxnum.ll

 ; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %y = call float @llvm.maxnum.f32(float %x, float 0x7FF8000000000000)
   ret float %y
 }
 
 define float @maxnum_f32_1_maxnum_val_p0(float %x) {
 ; CHECK-LABEL: @maxnum_f32_1_maxnum_val_p0(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float %x, float 1.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maxnum.f32(float %x, float 0.0)
   %z = call float @llvm.maxnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maxnum_f32_1_maxnum_p0_val_fast(float %x) {
 ; CHECK-LABEL: @maxnum_f32_1_maxnum_p0_val_fast(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.maxnum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.maxnum.f32(float %x, float 1.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maxnum.f32(float 0.0, float %x)
   %z = call fast float @llvm.maxnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maxnum_f32_1_maxnum_p0_val_nnan_ninf(float %x) {
 ; CHECK-LABEL: @maxnum_f32_1_maxnum_p0_val_nnan_ninf(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.maxnum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.maxnum.f32(float %x, float 1.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maxnum.f32(float 0.0, float %x)
   %z = call nnan ninf float @llvm.maxnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @maxnum_f32_p0_maxnum_val_n0(float %x) {
 ; CHECK-LABEL: @maxnum_f32_p0_maxnum_val_n0(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float -0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float [[Y]], float 0.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maxnum.f32(float %x, float -0.0)
   %z = call float @llvm.maxnum.f32(float %y, float 0.0)
   ret float %z
 }
 
 define float @maxnum_f32_1_maxnum_p0_val(float %x) {
 ; CHECK-LABEL: @maxnum_f32_1_maxnum_p0_val(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.maxnum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.maxnum.f32(float %x, float 1.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.maxnum.f32(float 0.0, float %x)
   %z = call float @llvm.maxnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define <2 x float> @maxnum_f32_1_maxnum_val_p0_val_v2f32(<2 x float> %x) {
 ; CHECK-LABEL: @maxnum_f32_1_maxnum_val_p0_val_v2f32(
-; CHECK-NEXT: [[Y:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
-; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> [[Y]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
+; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> <float 1.000000e+00, float 1.000000e+00>)
 ; CHECK-NEXT: ret <2 x float> [[RES]]
   %y = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
   %z = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %y, <2 x float><float 1.0, float 1.0>)
   ret <2 x float> %z
 }
 
 define float @maxnum4(float %x, float %y, float %z, float %w) {
 ; CHECK-LABEL: @maxnum4(

llvm/trunk/test/Transforms/InstCombine/minimum.ll

 ; CHECK-NEXT:    ret float 0x7FF8000000000000
 ;
   %y = call float @llvm.minimum.f32(float %x, float 0x7FF8000000000000)
   ret float %y
 }
 
 define float @minimum_f32_1_minimum_val_p0(float %x) {
 ; CHECK-LABEL: @minimum_f32_1_minimum_val_p0(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minimum.f32(float %x, float 0.0)
   %z = call float @llvm.minimum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minimum_f32_1_minimum_p0_val_fast(float %x) {
 ; CHECK-LABEL: @minimum_f32_1_minimum_p0_val_fast(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.minimum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.minimum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minimum.f32(float 0.0, float %x)
   %z = call fast float @llvm.minimum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minimum_f32_1_minimum_p0_val_nnan_ninf(float %x) {
 ; CHECK-LABEL: @minimum_f32_1_minimum_p0_val_nnan_ninf(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.minimum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.minimum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minimum.f32(float 0.0, float %x)
   %z = call nnan ninf float @llvm.minimum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minimum_f32_p0_minimum_val_n0(float %x) {
 ; CHECK-LABEL: @minimum_f32_p0_minimum_val_n0(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float -0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float [[Y]], float 0.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float %x, float -0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minimum.f32(float %x, float -0.0)
   %z = call float @llvm.minimum.f32(float %y, float 0.0)
   ret float %z
 }
 
 define float @minimum_f32_1_minimum_p0_val(float %x) {
 ; CHECK-LABEL: @minimum_f32_1_minimum_p0_val(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minimum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minimum.f32(float 0.0, float %x)
   %z = call float @llvm.minimum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define <2 x float> @minimum_f32_1_minimum_val_p0_val_v2f32(<2 x float> %x) {
 ; CHECK-LABEL: @minimum_f32_1_minimum_val_p0_val_v2f32(
-; CHECK-NEXT: [[Y:%.*]] = call <2 x float> @llvm.minimum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
-; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.minimum.v2f32(<2 x float> [[Y]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
+; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.minimum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
 ; CHECK-NEXT: ret <2 x float> [[RES]]
   %y = call <2 x float> @llvm.minimum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
   %z = call <2 x float> @llvm.minimum.v2f32(<2 x float> %y, <2 x float><float 1.0, float 1.0>)
   ret <2 x float> %z
 }
 
 define float @minimum4(float %x, float %y, float %z, float %w) {
 ; CHECK-LABEL: @minimum4(

llvm/trunk/test/Transforms/InstCombine/minnum.ll

 ; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %y = call float @llvm.minnum.f32(float %x, float 0x7FF8000000000000)
   ret float %y
 }
 
 define float @minnum_f32_1_minnum_val_p0(float %x) {
 ; CHECK-LABEL: @minnum_f32_1_minnum_val_p0(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minnum.f32(float %x, float 0.0)
   %z = call float @llvm.minnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_1_minnum_p0_val_fast(float %x) {
 ; CHECK-LABEL: @minnum_f32_1_minnum_p0_val_fast(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.minnum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call fast float @llvm.minnum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minnum.f32(float 0.0, float %x)
   %z = call fast float @llvm.minnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_1_minnum_p0_val_nnan_ninf(float %x) {
 ; CHECK-LABEL: @minnum_f32_1_minnum_p0_val_nnan_ninf(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.minnum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call nnan ninf float @llvm.minnum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minnum.f32(float 0.0, float %x)
   %z = call nnan ninf float @llvm.minnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define float @minnum_f32_p0_minnum_val_n0(float %x) {
 ; CHECK-LABEL: @minnum_f32_p0_minnum_val_n0(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float -0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float [[Y]], float 0.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minnum.f32(float %x, float -0.0)
   %z = call float @llvm.minnum.f32(float %y, float 0.0)
   ret float %z
 }
 
 define float @minnum_f32_1_minnum_p0_val(float %x) {
 ; CHECK-LABEL: @minnum_f32_1_minnum_p0_val(
-; CHECK-NEXT: [[Y:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
-; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float [[Y]], float 1.000000e+00)
+; CHECK-NEXT: [[RES:%.*]] = call float @llvm.minnum.f32(float %x, float 0.000000e+00)
 ; CHECK-NEXT: ret float [[RES]]
   %y = call float @llvm.minnum.f32(float 0.0, float %x)
   %z = call float @llvm.minnum.f32(float %y, float 1.0)
   ret float %z
 }
 
 define <2 x float> @minnum_f32_1_minnum_val_p0_val_v2f32(<2 x float> %x) {
 ; CHECK-LABEL: @minnum_f32_1_minnum_val_p0_val_v2f32(
-; CHECK-NEXT: [[Y:%.*]] = call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
-; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.minnum.v2f32(<2 x float> [[Y]], <2 x float> <float 1.000000e+00, float 1.000000e+00>)
+; CHECK-NEXT: [[RES:%.*]] = call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
 ; CHECK-NEXT: ret <2 x float> [[RES]]
   %y = call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> zeroinitializer)
   %z = call <2 x float> @llvm.minnum.v2f32(<2 x float> %y, <2 x float><float 1.0, float 1.0>)
   ret <2 x float> %z
 }
 
 define float @minnum4(float %x, float %y, float %z, float %w) {
 ; CHECK-LABEL: @minnum4(