InstCombine: Fold select of ldexp to ldexp of select

[arsenm]

Summary

The select-of-different-exp pattern appears in the device
libraries. I haven't seen the select-of-values case.

[arsenm]

Flag guard is overkill for one instruction

[nikic]

Should be part of foldSelectOpOp()?

[arsenm]

Move to foldSelectOpOp, which has slightly more liberal hasOneUse checks

[arsenm]

ping

[kpn]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

3407

Is this leftover from a previous version of the patch?

[arsenm]

Remove leftover

[kpn]

LGTM

[arsenm]

17eaa55e9f717bb724d7097155296622ac72ac79

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

if ((Cmp0 == TrueVal && Cmp1 == FalseVal) ||
         Value *NewCond = Builder.CreateFCmp(InvPred, Cmp0, Cmp1,
                                             FCmp->getName() + ".inv");
         Value *NewSel = Builder.CreateSelect(NewCond, FalseVal, TrueVal);
         return replaceInstUsesWith(SI, NewSel);
       }
     }
   }
 
-  if (isa<FPMathOperator>(SI)) {
+  if (FPMathOperator *SelectFPOp = dyn_cast<FPMathOperator>(&SI)) {
     // TODO: Try to forward-propagate FMF from select arms to the select.
 
     // Canonicalize select of FP values where NaN and -0.0 are not valid as
     // minnum/maxnum intrinsics.
     if (SI.hasNoNaNs() && SI.hasNoSignedZeros()) {
       Value *X, *Y;
       if (match(&SI, m_OrdFMax(m_Value(X), m_Value(Y))))
         return replaceInstUsesWith(
             SI, Builder.CreateBinaryIntrinsic(Intrinsic::maxnum, X, Y, &SI));
 
       if (match(&SI, m_OrdFMin(m_Value(X), m_Value(Y))))
         return replaceInstUsesWith(
             SI, Builder.CreateBinaryIntrinsic(Intrinsic::minnum, X, Y, &SI));
     }
+
+    Value *LdexpVal0, *LdexpVal1, *LdexpExp0, *LdexpExp1;
+
+    // select c, (ldexp v, e0), (ldexp v, e1) -> ldexp v, (select c, e0, e1)
+    // select c, (ldexp v0, e), (ldexp v1, e) -> ldexp (select c, v0, v1), e
+    //
+    // select c, (ldexp v0, e0), (ldexp v1, e1) ->
+    //     ldexp (select c, v0, v1), (select c, e0, e1)
+    if (match(TrueVal, m_OneUse(m_Intrinsic<Intrinsic::ldexp>(
+                           m_Value(LdexpVal0), m_Value(LdexpExp0)))) &&
+        match(FalseVal, m_OneUse(m_Intrinsic<Intrinsic::ldexp>(
+                            m_Value(LdexpVal1), m_Value(LdexpExp1)))) &&
+        LdexpExp0->getType() == LdexpExp1->getType()) {
+      FastMathFlags FMF = cast<FPMathOperator>(TrueVal)->getFastMathFlags();
+      FMF &= cast<FPMathOperator>(FalseVal)->getFastMathFlags();
+      FMF |= SelectFPOp->getFastMathFlags();
+
+      Value *SelectVal = Builder.CreateSelect(CondVal, LdexpVal0, LdexpVal1);
+      Value *SelectExp = Builder.CreateSelect(CondVal, LdexpExp0, LdexpExp1);
+
+      CallInst *NewLdexp = Builder.CreateIntrinsic(
+          TrueVal->getType(), Intrinsic::ldexp, {SelectVal, SelectExp});
+      NewLdexp->setFastMathFlags(FMF);
+      return replaceInstUsesWith(SI, NewLdexp);
+    }
   }
 
   // Fold selecting to fabs.
   if (Instruction *Fabs = foldSelectWithFCmpToFabs(SI, *this))
     return Fabs;
 
   // See if we are selecting two values based on a comparison of the two values.
   if (ICmpInst *ICI = dyn_cast<ICmpInst>(CondVal))

llvm/test/Transforms/InstCombine/ldexp.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
 
 declare float @llvm.ldexp.f32.i32(float, i32)
 declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>)
 declare float @llvm.ldexp.f32.i64(float, i64)
 
 ; select c, (ldexp val, e0), (ldexp val, e1) -> ldexp val, (select c, e0, e1)
 define float @select_ldexp_f32_sameval_differentexp(i1 %cond, float %val, i32 %exp0, i32 %exp1) {
 ; CHECK-LABEL: define float @select_ldexp_f32_sameval_differentexp
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL:%.*]], i32 [[EXP0:%.*]], i32 [[EXP1:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP0]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP1]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], i32 [[EXP0]], i32 [[EXP1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[TMP1]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call float @llvm.ldexp.f32.i32(float %val, i32 %exp0)
   %ldexp1 = call float @llvm.ldexp.f32.i32(float %val, i32 %exp1)
   %select = select i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 define float @select_ldexp_f32_sameval_differentexp_selectflags(i1 %cond, float %val, i32 %exp0, i32 %exp1) {
 ; CHECK-LABEL: define float @select_ldexp_f32_sameval_differentexp_selectflags
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL:%.*]], i32 [[EXP0:%.*]], i32 [[EXP1:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP0]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP1]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select nnan i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], i32 [[EXP0]], i32 [[EXP1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[TMP1]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call float @llvm.ldexp.f32.i32(float %val, i32 %exp0)
   %ldexp1 = call float @llvm.ldexp.f32.i32(float %val, i32 %exp1)
   %select = select nnan i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 define float @select_ldexp_f32_sameval_differentexp_ldexp_intersect_flags(i1 %cond, float %val, i32 %exp0, i32 %exp1) {
 ; CHECK-LABEL: define float @select_ldexp_f32_sameval_differentexp_ldexp_intersect_flags
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL:%.*]], i32 [[EXP0:%.*]], i32 [[EXP1:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call nnan nsz float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP0]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP1]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], i32 [[EXP0]], i32 [[EXP1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[TMP1]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call nnan nsz float @llvm.ldexp.f32.i32(float %val, i32 %exp0)
   %ldexp1 = call nnan float @llvm.ldexp.f32.i32(float %val, i32 %exp1)
   %select = select i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 define float @select_ldexp_f32_sameval_differentexp_ldexp_intersect_flags_union_select(i1 %cond, float %val, i32 %exp0, i32 %exp1) {
 ; CHECK-LABEL: define float @select_ldexp_f32_sameval_differentexp_ldexp_intersect_flags_union_select
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL:%.*]], i32 [[EXP0:%.*]], i32 [[EXP1:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call nnan nsz float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP0]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP1]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select ninf i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], i32 [[EXP0]], i32 [[EXP1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call nnan ninf float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[TMP1]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call nnan nsz float @llvm.ldexp.f32.i32(float %val, i32 %exp0)
   %ldexp1 = call nnan float @llvm.ldexp.f32.i32(float %val, i32 %exp1)
   %select = select ninf i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
;
   %select = select i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 ; select c, (ldexp val0, e), (ldexp val1, ee) -> ldexp (select c, val0, val1), e
 define float @select_ldexp_f32_differentval_sameexp(i1 %cond, float %val0, float %val1, i32 %exp) {
 ; CHECK-LABEL: define float @select_ldexp_f32_differentval_sameexp
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL0:%.*]], float [[VAL1:%.*]], i32 [[EXP:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL0]], i32 [[EXP]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL1]], i32 [[EXP]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], float [[VAL0]], float [[VAL1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[EXP]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call float @llvm.ldexp.f32.i32(float %val0, i32 %exp)
   %ldexp1 = call float @llvm.ldexp.f32.i32(float %val1, i32 %exp)
   %select = select i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 define float @select_ldexp_f32_differentval_sameexp_selectflags(i1 %cond, float %val0, float %val1, i32 %exp) {
 ; CHECK-LABEL: define float @select_ldexp_f32_differentval_sameexp_selectflags
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL0:%.*]], float [[VAL1:%.*]], i32 [[EXP:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL0]], i32 [[EXP]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL1]], i32 [[EXP]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select nnan i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], float [[VAL0]], float [[VAL1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[EXP]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call float @llvm.ldexp.f32.i32(float %val0, i32 %exp)
   %ldexp1 = call float @llvm.ldexp.f32.i32(float %val1, i32 %exp)
   %select = select nnan i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 define float @select_ldexp_f32_differentval_sameexp_ldexp_intersect_flags(i1 %cond, float %val0, float %val1, i32 %exp) {
 ; CHECK-LABEL: define float @select_ldexp_f32_differentval_sameexp_ldexp_intersect_flags
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL0:%.*]], float [[VAL1:%.*]], i32 [[EXP:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call nnan nsz float @llvm.ldexp.f32.i32(float [[VAL0]], i32 [[EXP]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[VAL1]], i32 [[EXP]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], float [[VAL0]], float [[VAL1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[EXP]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call nnan nsz float @llvm.ldexp.f32.i32(float %val0, i32 %exp)
   %ldexp1 = call nnan float @llvm.ldexp.f32.i32(float %val1, i32 %exp)
   %select = select i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 define float @select_ldexp_f32_differentval_sameexp_ldexp_intersect_flags_unino_select(i1 %cond, float %val0, float %val1, i32 %exp) {
 ; CHECK-LABEL: define float @select_ldexp_f32_differentval_sameexp_ldexp_intersect_flags_unino_select
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL0:%.*]], float [[VAL1:%.*]], i32 [[EXP:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call nnan nsz float @llvm.ldexp.f32.i32(float [[VAL0]], i32 [[EXP]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[VAL1]], i32 [[EXP]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select ninf i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], float [[VAL0]], float [[VAL1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call nnan ninf float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[EXP]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call nnan nsz float @llvm.ldexp.f32.i32(float %val0, i32 %exp)
   %ldexp1 = call nnan float @llvm.ldexp.f32.i32(float %val1, i32 %exp)
   %select = select ninf i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
;
   store float %ldexp1, ptr %ptr
   %select = select i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 define float @select_ldexp_f32_differentval_differentexp(i1 %cond, float %val0, float %val1, i32 %exp0, i32 %exp1) {
 ; CHECK-LABEL: define float @select_ldexp_f32_differentval_differentexp
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL0:%.*]], float [[VAL1:%.*]], i32 [[EXP0:%.*]], i32 [[EXP1:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL0]], i32 [[EXP0]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL1]], i32 [[EXP1]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select i1 [[COND]], float [[VAL0]], float [[VAL1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[COND]], i32 [[EXP0]], i32 [[EXP1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[TMP2]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call float @llvm.ldexp.f32.i32(float %val0, i32 %exp0)
   %ldexp1 = call float @llvm.ldexp.f32.i32(float %val1, i32 %exp1)
   %select = select i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }
 
 define <2 x float> @select_ldexp_v2f32_sameval_differentexp(<2 x i1> %cond, <2 x float> %val, <2 x i32> %exp0, <2 x i32> %exp1) {
 ; CHECK-LABEL: define <2 x float> @select_ldexp_v2f32_sameval_differentexp
 ; CHECK-SAME: (<2 x i1> [[COND:%.*]], <2 x float> [[VAL:%.*]], <2 x i32> [[EXP0:%.*]], <2 x i32> [[EXP1:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[VAL]], <2 x i32> [[EXP0]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[VAL]], <2 x i32> [[EXP1]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select <2 x i1> [[COND]], <2 x float> [[LDEXP0]], <2 x float> [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select <2 x i1> [[COND]], <2 x i32> [[EXP0]], <2 x i32> [[EXP1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[VAL]], <2 x i32> [[TMP1]])
 ; CHECK-NEXT:    ret <2 x float> [[SELECT]]
 ;
   %ldexp0 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %val, <2 x i32> %exp0)
   %ldexp1 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %val, <2 x i32> %exp1)
   %select = select <2 x i1> %cond, <2 x float> %ldexp0, <2 x float> %ldexp1
   ret <2 x float> %select
 }
 
 define <2 x float> @select_ldexp_v2f32_differentval_sameexp(<2 x i1> %cond, <2 x float> %val0, <2 x float> %val1, <2 x i32> %exp) {
 ; CHECK-LABEL: define <2 x float> @select_ldexp_v2f32_differentval_sameexp
 ; CHECK-SAME: (<2 x i1> [[COND:%.*]], <2 x float> [[VAL0:%.*]], <2 x float> [[VAL1:%.*]], <2 x i32> [[EXP:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[VAL0]], <2 x i32> [[EXP]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[VAL1]], <2 x i32> [[EXP]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select <2 x i1> [[COND]], <2 x float> [[LDEXP0]], <2 x float> [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select <2 x i1> [[COND]], <2 x float> [[VAL0]], <2 x float> [[VAL1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[TMP1]], <2 x i32> [[EXP]])
 ; CHECK-NEXT:    ret <2 x float> [[SELECT]]
 ;
   %ldexp0 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %val0, <2 x i32> %exp)
   %ldexp1 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %val1, <2 x i32> %exp)
   %select = select <2 x i1> %cond, <2 x float> %ldexp0, <2 x float> %ldexp1
   ret <2 x float> %select
 }
 
 define <2 x float> @select_ldexp_v2f32_differentval_differentexp(<2 x i1> %cond, <2 x float> %val0, <2 x float> %val1, <2 x i32> %exp0, <2 x i32> %exp1) {
 ; CHECK-LABEL: define <2 x float> @select_ldexp_v2f32_differentval_differentexp
 ; CHECK-SAME: (<2 x i1> [[COND:%.*]], <2 x float> [[VAL0:%.*]], <2 x float> [[VAL1:%.*]], <2 x i32> [[EXP0:%.*]], <2 x i32> [[EXP1:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[VAL0]], <2 x i32> [[EXP0]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[VAL1]], <2 x i32> [[EXP1]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select <2 x i1> [[COND]], <2 x float> [[LDEXP0]], <2 x float> [[LDEXP1]]
+; CHECK-NEXT:    [[TMP1:%.*]] = select <2 x i1> [[COND]], <2 x float> [[VAL0]], <2 x float> [[VAL1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = select <2 x i1> [[COND]], <2 x i32> [[EXP0]], <2 x i32> [[EXP1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[TMP1]], <2 x i32> [[TMP2]])
 ; CHECK-NEXT:    ret <2 x float> [[SELECT]]
 ;
   %ldexp0 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %val0, <2 x i32> %exp0)
   %ldexp1 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %val1, <2 x i32> %exp1)
   %select = select <2 x i1> %cond, <2 x float> %ldexp0, <2 x float> %ldexp1
   ret <2 x float> %select
 }
 
 define float @select_ldexp_f32_same(i1 %cond, float %val, i32 %exp) {
 ; CHECK-LABEL: define float @select_ldexp_f32_same
 ; CHECK-SAME: (i1 [[COND:%.*]], float [[VAL:%.*]], i32 [[EXP:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP]])
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP]])
-; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[COND]], float [[LDEXP0]], float [[LDEXP1]]
+; CHECK-NEXT:    [[SELECT:%.*]] = call float @llvm.ldexp.f32.i32(float [[VAL]], i32 [[EXP]])
 ; CHECK-NEXT:    ret float [[SELECT]]
 ;
   %ldexp0 = call float @llvm.ldexp.f32.i32(float %val, i32 %exp)
   %ldexp1 = call float @llvm.ldexp.f32.i32(float %val, i32 %exp)
   %select = select i1 %cond, float %ldexp0, float %ldexp1
   ret float %select
 }