InstCombine: Fold out scale-if-denormal pattern

[arsenm]

Summary

Fold select (fcmp oeq x, 0), (fmul x, y), x => x

This cleans up a pattern left behind by denormal range checks under
denormals are zero.

The pattern starts out as something like:
x = x < smallest_normal ? x * K : x;

The comparison folds to an == 0 when the denormal mode treats input
denormals as zero. This makes library denormal checks free after
linked into DAZ enabled code.

alive2 is mostly happy with this, but there are some issues. First,
there are many reported failures in some of the negative tests that
happen to trigger some preexisting canonicalize introducing
combine. Second, alive2 is incorrectly asserting that denormals must
be flushed with the DAZ modes. It's allowed to drop a canonicalize.

[foad]

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

260

Seems a bit strong to say that fmul nsz MulVal, +0.0 will yield +0.0 when MulVal is negative. I think the nsz flag just means that optimizations applied to this instruction don't have to respect the sign of zero. It's still possible that some other later (non-nsz) instruction would observe a -0.0 result from this fmul.

I think the behaviour is fine but the comment could use improving.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

3468

Stray "and"?

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

3504

There is alot of duplicate code between the two if statements.
Maybe fold it into a lambda and pass TrueVal/FalseVal and eq/ne as constraints?
At the very least the actual creation of the new instruction code can be hoisted to some shared codes.

[arsenm]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

3329

This is essentially reinventing D151887

[arsenm]

ping

[arsenm]

ping

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

3337

matchFMulByZeroIfResultEqZero? Seems a lot clearer.

3465

What do you mean by "This drops a canonicalization"? Causes us to miss it?

Can you also describe the "scale-if-equals-zero" pattern. Mostly for my sake, not familiar with it. If another reviewer is they might be better fit for this patch.

3468

Missing something after the "so"?

3484

Imo:

Value * MatchCmp0 = nullptr;
if(Pred == CmpInst::FCMP_OEQ || ...UEQ)
   MatchCmp0 = FalseVal;
else if(Pred == CmpInst::FCMP_ONE || ...UNE)
   MatchCmp0 = TrueVal;
if(Cmp0 == MatchCmp0 && matchFMulByZeroIfEqZero(this, Cmp0, Cmp1, Cmp1, Cmp0, SI))
   return replaceInstUsesWith(SI, Cmp0);

[arsenm]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

3465

Before this you always get a value that goes through a multiply, which if we strictly followed FP behavior would require quieting a signaling nan and flushing denormals. By replacing with a direct x reference, that doesn't happen (but per the langref is allowed without strictfp)

The pattern is covered by the select, the multiply if equal 0 pattern

[arsenm]

ping

[goldstein.w.n]

This needs to be rebased.

Code looks good (once rebased) I'll test + accept.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

3339

nit: Would replace SelectInst &SI with Instruction * CxtI here. TrueVal/FalseVal don't actually match the select operands heres which seems bugprone if at somepoint someone thinks "oh I can just get these from the select".

[goldstein.w.n]

When I try to check this out locally I'm getting an issue. Is there a missing patch in this series?

$> arc patch D157030
 INFO  Base commit is not in local repository; trying to fetch.
Created and checked out branch arcpatch-D157030.
Checking patch llvm/test/Transforms/InstCombine/fold-select-fmul-if-zero.ll...
error: llvm/test/Transforms/InstCombine/fold-select-fmul-if-zero.ll: does not exist in index
Checking patch llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp...
Checking patch llvm/lib/Transforms/InstCombine/InstCombineInternal.h...
Checking patch llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp...
Applied patch llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp cleanly.
Applied patch llvm/lib/Transforms/InstCombine/InstCombineInternal.h cleanly.
Applied patch llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp cleanly.

 Patch Failed! 
Usage Exception: Unable to apply patch!

[arsenm]

In D157030#4623057, @goldstein.w.n wrote:

When I try to check this out locally I'm getting an issue. Is there a missing patch in this series?

$> arc patch D157030
 INFO  Base commit is not in local repository; trying to fetch.
Created and checked out branch arcpatch-D157030.
Checking patch llvm/test/Transforms/InstCombine/fold-select-fmul-if-zero.ll...
error: llvm/test/Transforms/InstCombine/fold-select-fmul-if-zero.ll: does not exist in index
Checking patch llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp...
Checking patch llvm/lib/Transforms/InstCombine/InstCombineInternal.h...
Checking patch llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp...
Applied patch llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp cleanly.
Applied patch llvm/lib/Transforms/InstCombine/InstCombineInternal.h cleanly.
Applied patch llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp cleanly.

 Patch Failed! 
Usage Exception: Unable to apply patch!

You don't have the baseline test commit, just pushed it

[goldstein.w.n]

llvm/test/Transforms/InstCombine/fold-select-fmul-if-zero.ll

398

Why does this fail?

[arsenm]

Use flag helper now that it's pushed

[arsenm]

llvm/test/Transforms/InstCombine/fold-select-fmul-if-zero.ll

398

The nsz needs to be set on the select. nsz on the fmul is insufficient

[goldstein.w.n]

Okay, LGTM.

FP stuff is not an area I'm really qualified to review so it would be nice if a second opinion
also chimed in, but if no one else is up to review think its okay to push.
Please way a few days to push to give other times to review.

llvm/test/Transforms/InstCombine/fold-select-fmul-if-zero.ll

398

Ah yeah that makes sense.

[arsenm]

5ae881ff0ab3a38121f240c9e73427367284e802

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (!IsStrict && (IsOrdered || IsUnordered) &&
     Value *FCmp = Builder.CreateFCmp(
         IsUnordered ? FCmpInst::getUnorderedPredicate(PredType) : PredType,
         Src0, Zero);
 
     FCmp->takeName(&II);
     return replaceInstUsesWith(II, FCmp);
   }
 
-  KnownFPClass Known = computeKnownFPClass(
-      Src0, DL, Mask, 0, &getTargetLibraryInfo(), &AC, &II, &DT);
+  KnownFPClass Known = computeKnownFPClass(Src0, Mask, &II);
 
   // Clear test bits we know must be false from the source value.
   // fp_class (nnan x), qnan|snan|other -> fp_class (nnan x), other
   // fp_class (ninf x), ninf|pinf|other -> fp_class (ninf x), other
   if ((Mask & Known.KnownFPClasses) != Mask) {
     II.setArgOperand(
         1, ConstantInt::get(Src1->getType(), Mask & Known.KnownFPClasses));
     return ⅈ

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

public:
 
   /// Try to replace select with select operand SIOpd in SI-ICmp sequence.
   bool replacedSelectWithOperand(SelectInst *SI, const ICmpInst *Icmp,
                                  const unsigned SIOpd);
 
   LoadInst *combineLoadToNewType(LoadInst &LI, Type *NewTy,
                                  const Twine &Suffix = "");
 
+  KnownFPClass computeKnownFPClass(Value *Val,
+                                   FPClassTest Interested = fcAllFlags,
+                                   FastMathFlags FMF = FastMathFlags(),
+                                   const Instruction *CtxI = nullptr,
+                                   unsigned Depth = 0) const {
+    // TODO: Use FMF when computeKnownFPClass FMF wrapper is pushed.
+    return llvm::computeKnownFPClass(Val, DL, Interested, Depth, &TLI, &AC,
+                                     CtxI, &DT);
+  }
+
+  KnownFPClass computeKnownFPClass(Value *Val,
+                                   FPClassTest Interested = fcAllFlags,
+                                   const Instruction *CtxI = nullptr,
+                                   unsigned Depth = 0) const {
+    return llvm::computeKnownFPClass(Val, DL, Interested, Depth, &TLI, &AC,
+                                     CtxI, &DT);
+  }
+
+  /// Check if fmul \p MulVal, +0.0 will yield +0.0 (or signed zero is
+  /// ignorable).
+  bool fmulByZeroIsZero(Value *MulVal, FastMathFlags FMF,
+                        const Instruction *CtxI) const;
+
 private:
   bool annotateAnyAllocSite(CallBase &Call, const TargetLibraryInfo *TLI);
   bool isDesirableIntType(unsigned BitWidth) const;
   bool shouldChangeType(unsigned FromBitWidth, unsigned ToBitWidth) const;
   bool shouldChangeType(Type *From, Type *To) const;
   Value *dyn_castNegVal(Value *V) const;
 
   /// Classify whether a cast is worth optimizing.
private:
   /// OverflowResult, and return true.  If no simplification is possible,
   /// returns false.
   bool OptimizeOverflowCheck(Instruction::BinaryOps BinaryOp, bool IsSigned,
                              Value *LHS, Value *RHS,
                              Instruction &CtxI, Value *&OperationResult,
                              Constant *&OverflowResult);
 
   Instruction *visitCallBase(CallBase &Call);
   Instruction *tryOptimizeCall(CallInst *CI);
   bool transformConstExprCastCall(CallBase &Call);
   Instruction *transformCallThroughTrampoline(CallBase &Call,
                                               IntrinsicInst &Tramp);
 
   Value *simplifyMaskedLoad(IntrinsicInst &II);
   Instruction *simplifyMaskedStore(IntrinsicInst &II);
   Instruction *simplifyMaskedGather(IntrinsicInst &II);
   Instruction *simplifyMaskedScatter(IntrinsicInst &II);

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

static Instruction *foldBitCeil(SelectInst &SI, IRBuilderBase &Builder) {
   // hardware as part of the shift instruction.
   Value *Neg = Builder.CreateNeg(Ctlz);
   Value *Masked =
       Builder.CreateAnd(Neg, ConstantInt::get(SelType, BitWidth - 1));
   return BinaryOperator::Create(Instruction::Shl, ConstantInt::get(SelType, 1),
                                 Masked);
 }
 
+bool InstCombinerImpl::fmulByZeroIsZero(Value *MulVal, FastMathFlags FMF,
+                                        const Instruction *CtxI) const {
+  KnownFPClass Known = computeKnownFPClass(MulVal, FMF, fcNegative, FMF, CtxI);
+
+  return Known.isKnownNeverNaN() && Known.isKnownNeverInfinity() &&
+         (FMF.noSignedZeros() || Known.signBitIsZeroOrNaN());
+}
+
+static bool matchFMulByZeroIfResultEqZero(InstCombinerImpl &IC, Value *Cmp0,
+                                          Value *Cmp1, Value *TrueVal,
+                                          Value *FalseVal, Instruction &CtxI,
+                                          bool SelectIsNSZ) {
+  Value *MulRHS;
+  if (match(Cmp1, m_PosZeroFP()) &&
+      match(TrueVal, m_c_FMul(m_Specific(Cmp0), m_Value(MulRHS)))) {
+    FastMathFlags FMF = cast<FPMathOperator>(TrueVal)->getFastMathFlags();
+    // nsz must be on the select, it must be ignored on the multiply. We
+    // need nnan and ninf on the multiply for the other value.
+    FMF.setNoSignedZeros(SelectIsNSZ);
+    return IC.fmulByZeroIsZero(MulRHS, FMF, &CtxI);
+  }
+
+  return false;
+}
+
 Instruction *InstCombinerImpl::visitSelectInst(SelectInst &SI) {
   Value *CondVal = SI.getCondition();
   Value *TrueVal = SI.getTrueValue();
   Value *FalseVal = SI.getFalseValue();
   Type *SelType = SI.getType();
 
   if (Value *V = simplifySelectInst(CondVal, TrueVal, FalseVal,
                                     SQ.getWithInstruction(&SI)))
if (SelType->isIntOrIntVectorTy() && !SelType->isIntOrIntVectorTy(1) &&
 
     // select C, 0, -1 -> sext !C to int
     if (match(TrueVal, m_Zero()) && match(FalseVal, m_AllOnes())) {
       Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
       return new SExtInst(NotCond, SelType);
     }
   }
 
+  auto *SIFPOp = dyn_cast<FPMathOperator>(&SI);
+
   if (auto *FCmp = dyn_cast<FCmpInst>(CondVal)) {
+    FCmpInst::Predicate Pred = FCmp->getPredicate();
     Value *Cmp0 = FCmp->getOperand(0), *Cmp1 = FCmp->getOperand(1);
     // Are we selecting a value based on a comparison of the two values?
     if ((Cmp0 == TrueVal && Cmp1 == FalseVal) ||
         (Cmp0 == FalseVal && Cmp1 == TrueVal)) {
       // Canonicalize to use ordered comparisons by swapping the select
       // operands.
       //
       // e.g.
       // (X ugt Y) ? X : Y -> (X ole Y) ? Y : X
-      if (FCmp->hasOneUse() && FCmpInst::isUnordered(FCmp->getPredicate())) {
+      if (FCmp->hasOneUse() && FCmpInst::isUnordered(Pred)) {
         FCmpInst::Predicate InvPred = FCmp->getInversePredicate();
         IRBuilder<>::FastMathFlagGuard FMFG(Builder);
         // FIXME: The FMF should propagate from the select, not the fcmp.
         Builder.setFastMathFlags(FCmp->getFastMathFlags());
         Value *NewCond = Builder.CreateFCmp(InvPred, Cmp0, Cmp1,
                                             FCmp->getName() + ".inv");
         Value *NewSel = Builder.CreateSelect(NewCond, FalseVal, TrueVal);
         return replaceInstUsesWith(SI, NewSel);
       }
     }
+
+    if (SIFPOp) {
+      // Fold out scale-if-equals-zero pattern.
+      //
+      // This pattern appears in code with denormal range checks after it's
+      // assumed denormals are treated as zero. This drops a canonicalization.
+
+      // TODO: Could relax the signed zero logic. We just need to know the sign
+      // of the result matches (fmul x, y has the same sign as x).
+      //
+      // TODO: Handle always-canonicalizing variant that selects some value or 1
+      // scaling factor in the fmul visitor.
+
+      // TODO: Handle ldexp too
+
+      Value *MatchCmp0 = nullptr;
+      Value *MatchCmp1 = nullptr;
+
+      // (select (fcmp [ou]eq x, 0.0), (fmul x, K), x => x
+      // (select (fcmp [ou]ne x, 0.0), x, (fmul x, K) => x
+      if (Pred == CmpInst::FCMP_OEQ || Pred == CmpInst::FCMP_UEQ) {
+        MatchCmp0 = FalseVal;
+        MatchCmp1 = TrueVal;
+      } else if (Pred == CmpInst::FCMP_ONE || Pred == CmpInst::FCMP_UNE) {
+        MatchCmp0 = TrueVal;
+        MatchCmp1 = FalseVal;
+      }
+
+      if (Cmp0 == MatchCmp0 &&
+          matchFMulByZeroIfResultEqZero(*this, Cmp0, Cmp1, MatchCmp1, MatchCmp0,
+                                        SI, SIFPOp->hasNoSignedZeros()))
+        return replaceInstUsesWith(SI, Cmp0);
+    }
   }
 
-  if (isa<FPMathOperator>(SI)) {
+  if (SIFPOp) {
     // 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()) {
+    if (SIFPOp->hasNoNaNs() && SIFPOp->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));
     }
   }
 
   // Fold selecting to fabs.

llvm/test/Transforms/InstCombine/fold-select-fmul-if-zero.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --scrub-attributes
 ; RUN: opt -S -passes=instcombine < %s | FileCheck -check-prefixes=CHECK,IEEE %s
 ; RUN: opt -S -passes=instcombine -denormal-fp-math=preserve-sign < %s | FileCheck -check-prefixes=CHECK,DAZ  %s
 ; RUN: opt -S -passes=instcombine -denormal-fp-math=positive-zero < %s | FileCheck -check-prefixes=CHECK,DAPZ  %s
 
 ; Test for patterns that appear when denormal range checks are folded
 ; to compares to 0, which drop canonicalizing
 
 declare void @llvm.assume(i1 noundef)
 declare float @llvm.fabs.f32(float)
 declare float @llvm.ldexp.f32.i32(float, i32)
 declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>)
 
 
 define i32 @fcmp_zero_select_is_not_fp(float %x) {
 ; CHECK-LABEL: @fcmp_zero_select_is_not_fp(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL_V:%.*]] = select i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = bitcast float [[SCALED_IF_DENORMAL_V]] to i32
+; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = bitcast float [[X:%.*]] to i32
 ; CHECK-NEXT:    ret i32 [[SCALED_IF_DENORMAL]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, 32.0
   %bitcast.scaled.x = bitcast float %scaled.x to i32
   %bitcast.x = bitcast float %x to i32
   %scaled.if.denormal = select i1 %x.is.zero, i32 %bitcast.scaled.x, i32 %bitcast.x
   ret i32 %scaled.if.denormal
 }
 
 define i32 @fcmp_zero_select_is_not_fp_unfoldable(float %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @fcmp_zero_select_is_not_fp_unfoldable(
 ; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
 ; CHECK-NEXT:    [[SELECT:%.*]] = select i1 [[X_IS_ZERO]], i32 [[Y:%.*]], i32 [[Z:%.*]]
 ; CHECK-NEXT:    ret i32 [[SELECT]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %select = select i1 %x.is.zero, i32 %y, i32 %z
   ret i32 %select
 }
 
 ; Real case
 define float @fmul_by_32_if_0_oeq_zero_f32(float %x) {
 ; CHECK-LABEL: @fmul_by_32_if_0_oeq_zero_f32(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, 32.0
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @ldexp_by_5_if_0_oeq_zero_f32(float %x) {
;
   %scaled.x = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 ; Real case, vector splat
 define <2 x float> @fmul_by_32_if_0_oeq_zero_v2f32_splat(<2 x float> %x) {
 ; CHECK-LABEL: @fmul_by_32_if_0_oeq_zero_v2f32_splat(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq <2 x float> [[X:%.*]], zeroinitializer
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul <2 x float> [[X]], <float 3.200000e+01, float 3.200000e+01>
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select <2 x i1> [[X_IS_ZERO]], <2 x float> [[SCALED_X]], <2 x float> [[X]]
-; CHECK-NEXT:    ret <2 x float> [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret <2 x float> [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq <2 x float> %x, zeroinitializer
   %scaled.x = fmul <2 x float> %x, <float 32.0, float 32.0>
   %scaled.if.denormal = select <2 x i1> %x.is.zero, <2 x float> %scaled.x, <2 x float> %x
   ret <2 x float> %scaled.if.denormal
 }
 
 define <2 x float> @fmul_by_32_if_0_oeq_zero_v2f32_nonsplat(<2 x float> %x) {
 ; CHECK-LABEL: @fmul_by_32_if_0_oeq_zero_v2f32_nonsplat(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq <2 x float> [[X:%.*]], zeroinitializer
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul <2 x float> [[X]], <float 3.200000e+01, float 6.400000e+01>
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select <2 x i1> [[X_IS_ZERO]], <2 x float> [[SCALED_X]], <2 x float> [[X]]
-; CHECK-NEXT:    ret <2 x float> [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret <2 x float> [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq <2 x float> %x, zeroinitializer
   %scaled.x = fmul <2 x float> %x, <float 32.0, float 64.0>
   %scaled.if.denormal = select <2 x i1> %x.is.zero, <2 x float> %scaled.x, <2 x float> %x
   ret <2 x float> %scaled.if.denormal
 }
 
 define <2 x float> @fmul_by_32_if_0_oeq_zero_v2f32_eq_mixed_zero_vector(<2 x float> %x) {
 ; CHECK-LABEL: @fmul_by_32_if_0_oeq_zero_v2f32_eq_mixed_zero_vector(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq <2 x float> [[X:%.*]], zeroinitializer
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul <2 x float> [[X]], <float 3.200000e+01, float 3.200000e+01>
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select <2 x i1> [[X_IS_ZERO]], <2 x float> [[SCALED_X]], <2 x float> [[X]]
-; CHECK-NEXT:    ret <2 x float> [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret <2 x float> [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq <2 x float> %x, <float 0.0, float -0.0>
   %scaled.x = fmul <2 x float> %x, <float 32.0, float 32.0>
   %scaled.if.denormal = select <2 x i1> %x.is.zero, <2 x float> %scaled.x, <2 x float> %x
   ret <2 x float> %scaled.if.denormal
 }
 
 define <2 x float> @fmul_by_32_if_0_oeq_zero_v2f32_eq_zero_vector_undef(<2 x float> %x) {
 ; CHECK-LABEL: @fmul_by_32_if_0_oeq_zero_v2f32_eq_zero_vector_undef(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq <2 x float> [[X:%.*]], <float 0.000000e+00, float poison>
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul <2 x float> [[X]], <float 3.200000e+01, float 3.200000e+01>
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select <2 x i1> [[X_IS_ZERO]], <2 x float> [[SCALED_X]], <2 x float> [[X]]
-; CHECK-NEXT:    ret <2 x float> [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret <2 x float> [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq <2 x float> %x, <float 0.0, float poison>
   %scaled.x = fmul <2 x float> %x, <float 32.0, float 32.0>
   %scaled.if.denormal = select <2 x i1> %x.is.zero, <2 x float> %scaled.x, <2 x float> %x
   ret <2 x float> %scaled.if.denormal
 }
 
 define float @select_wrong_value(float %x, float %y) {
;
   %x.is.one = fcmp oeq float %x, %y
   %scaled.x = fmul float %x, 32.0
   %scaled.if.denormal = select i1 %x.is.one, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_32_if_0_ueq_zero_f32(float %x) {
 ; CHECK-LABEL: @fmul_by_32_if_0_ueq_zero_f32(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp ueq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.zero = fcmp ueq float %x, 0.0
   %scaled.x = fmul float %x, 32.0
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_32_if_0_oeq_negzero_f32(float %x) {
 ; CHECK-LABEL: @fmul_by_32_if_0_oeq_negzero_f32(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq float %x, -0.0
   %scaled.x = fmul float %x, 32.0
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_32_if_0_oeq_zero_f32_multiple_use_cmp(float %x, ptr %ptr) {
 ; CHECK-LABEL: @fmul_by_32_if_0_oeq_zero_f32_multiple_use_cmp(
 ; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
 ; CHECK-NEXT:    store i1 [[X_IS_ZERO]], ptr [[PTR:%.*]], align 1
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, 32.0
   store i1 %x.is.zero, ptr %ptr
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_32_if_0_oeq_zero_f32_multiple_use_fmul(float %x, ptr %ptr) {
 ; CHECK-LABEL: @fmul_by_32_if_0_oeq_zero_f32_multiple_use_fmul(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
+; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X:%.*]], 3.200000e+01
 ; CHECK-NEXT:    store float [[SCALED_X]], ptr [[PTR:%.*]], align 4
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, 32.0
   store float %scaled.x, ptr %ptr
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_0_if_0_oeq_zero_f32(float %x) {
 ; CHECK-LABEL: @fmul_by_0_if_0_oeq_zero_f32(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, 0.0
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 ; Inverse of the real case
 define float @x_if_one_zero_else_mul_by_32(float %x) {
 ; CHECK-LABEL: @x_if_one_zero_else_mul_by_32(
-; CHECK-NEXT:    [[X_IS_NOT_ZERO:%.*]] = fcmp one float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_NOT_ZERO]], float [[X]], float [[SCALED_X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.not.zero = fcmp one float %x, 0.0
   %scaled.x = fmul float %x, 32.0
   %scaled.if.denormal = select i1 %x.is.not.zero, float %x, float %scaled.x
   ret float %scaled.if.denormal
 }
 
 define float @x_if_one_negzero_else_mul_by_32(float %x) {
 ; CHECK-LABEL: @x_if_one_negzero_else_mul_by_32(
-; CHECK-NEXT:    [[X_IS_NOT_ZERO:%.*]] = fcmp one float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_NOT_ZERO]], float [[X]], float [[SCALED_X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.not.zero = fcmp one float %x, -0.0
   %scaled.x = fmul float %x, 32.0
   %scaled.if.denormal = select i1 %x.is.not.zero, float %x, float %scaled.x
   ret float %scaled.if.denormal
 }
 
 define float @x_if_une_zero_else_mul_by_32(float %x) {
 ; CHECK-LABEL: @x_if_une_zero_else_mul_by_32(
-; CHECK-NEXT:    [[X_IS_NOT_ZERO:%.*]] = fcmp une float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_NOT_ZERO]], float [[X]], float [[SCALED_X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.not.zero = fcmp une float %x, 0.0
   %scaled.x = fmul float %x, 32.0
   %scaled.if.denormal = select i1 %x.is.not.zero, float %x, float %scaled.x
   ret float %scaled.if.denormal
 }
 
 define float @x_if_une_negzero_else_mul_by_32(float %x) {
 ; CHECK-LABEL: @x_if_une_negzero_else_mul_by_32(
-; CHECK-NEXT:    [[X_IS_NOT_ZERO:%.*]] = fcmp une float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], 3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_NOT_ZERO]], float [[X]], float [[SCALED_X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.not.zero = fcmp une float %x, -0.0
   %scaled.x = fmul float %x, 32.0
   %scaled.if.denormal = select i1 %x.is.not.zero, float %x, float %scaled.x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_neg32_if_0_oeq_zero_f32(float %x) {
;
   %x.is.not.zero = fcmp one float %x, 0.0
   %scaled.x = fmul float %x, -32.0
   %scaled.if.denormal = select i1 %x.is.not.zero, float %x, float %scaled.x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_neg32_if_0_oeq_zero_f32_select_nsz(float %x) {
 ; CHECK-LABEL: @fmul_by_neg32_if_0_oeq_zero_f32_select_nsz(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], -3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select nsz i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, -32.0
   %scaled.if.denormal = select nsz i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_neg32_if_0_one_zero_f32_select_nsz(float %x) {
 ; CHECK-LABEL: @fmul_by_neg32_if_0_one_zero_f32_select_nsz(
-; CHECK-NEXT:    [[X_IS_NOT_ZERO:%.*]] = fcmp one float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul float [[X]], -3.200000e+01
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select nsz i1 [[X_IS_NOT_ZERO]], float [[X]], float [[SCALED_X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.not.zero = fcmp one float %x, 0.0
   %scaled.x = fmul float %x, -32.0
   %scaled.if.denormal = select nsz i1 %x.is.not.zero, float %x, float %scaled.x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_neg32_if_0_oeq_zero_f32_fmul_nsz(float %x) {
 ; CHECK-LABEL: @fmul_by_neg32_if_0_oeq_zero_f32_fmul_nsz(
 ; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
 ; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul nsz float [[X]], -3.200000e+01
 ; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_ZERO]], float [[SCALED_X]], float [[X]]
 ; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul nsz float %x, -32.0
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_neg32_if_0_one_zero_f32_mul_nsz(float %x) {
 ; CHECK-LABEL: @fmul_by_neg32_if_0_one_zero_f32_mul_nsz(
 ; CHECK-NEXT:    [[X_IS_NOT_ZERO:%.*]] = fcmp one float [[X:%.*]], 0.000000e+00
 ; CHECK-NEXT:    [[SCALED_X:%.*]] = fmul nsz float [[X]], -3.200000e+01
 ; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = select i1 [[X_IS_NOT_ZERO]], float [[X]], float [[SCALED_X]]
 ; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
 ;
;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, %y.fabs
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_fabs_nnan_ninf_var_if_0_oeq_zero_f32(float %x, float %y) {
 ; CHECK-LABEL: @fmul_by_fabs_nnan_ninf_var_if_0_oeq_zero_f32(
-; CHECK-NEXT:    [[Y_FABS:%.*]] = call nnan ninf float @llvm.fabs.f32(float [[Y:%.*]])
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = select i1 [[X_IS_ZERO]], float [[Y_FABS]], float 1.000000e+00
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = fmul float [[SCALED_X]], [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %y.fabs = call nnan ninf float @llvm.fabs.f32(float %y)
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, %y.fabs
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
;
   %scaled.x = fmul float %x, %y
   %scaled.if.denormal = select nsz nnan ninf i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 ; nsz can come from only the select
 define float @fmul_by_var_if_0_oeq_zero_f32_fmul_nnan_ninf_select_nsz(float %x, float %y) {
 ; CHECK-LABEL: @fmul_by_var_if_0_oeq_zero_f32_fmul_nnan_ninf_select_nsz(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = select nsz i1 [[X_IS_ZERO]], float [[Y:%.*]], float 1.000000e+00
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = fmul nnan ninf float [[SCALED_X]], [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul nnan ninf float %x, %y
   %scaled.if.denormal = select nsz i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 ; nsz can come from only the select
 define float @fmul_by_var_if_0_oeq_zero_f32_fmul_nnan_ninf_select_nsz_inverted(float %x, float %y) {
 ; CHECK-LABEL: @fmul_by_var_if_0_oeq_zero_f32_fmul_nnan_ninf_select_nsz_inverted(
-; CHECK-NEXT:    [[X_IS_NOT_ZERO:%.*]] = fcmp one float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = select nsz i1 [[X_IS_NOT_ZERO]], float 1.000000e+00, float [[Y:%.*]]
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = fmul nnan ninf float [[SCALED_X]], [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.not.zero = fcmp one float %x, 0.0
   %scaled.x = fmul nnan ninf float %x, %y
   %scaled.if.denormal = select nsz i1 %x.is.not.zero, float %x, float %scaled.x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_var_if_0_oeq_zero_f32_fmul_nnan_ninf_nsz(float %x, float %y) {
;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul nnan ninf float %x, %y
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_var_if_0_oeq_zero_f32_known_never_nan_inf_select_nsz(float %x, float nofpclass(nan inf) %y) {
 ; CHECK-LABEL: @fmul_by_var_if_0_oeq_zero_f32_known_never_nan_inf_select_nsz(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = select nsz i1 [[X_IS_ZERO]], float [[Y:%.*]], float 1.000000e+00
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = fmul float [[SCALED_X]], [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, %y
   %scaled.if.denormal = select nsz i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 ; Infer everything from incoming multiplied value
;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, %y
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 define float @fmul_by_var_if_0_oeq_zero_f32_fmul_known_never_nan_inf_neg(float %x, float nofpclass(nan inf nzero nsub nnorm) %y) {
 ; CHECK-LABEL: @fmul_by_var_if_0_oeq_zero_f32_fmul_known_never_nan_inf_neg(
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = select i1 [[X_IS_ZERO]], float [[Y:%.*]], float 1.000000e+00
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = fmul float [[SCALED_X]], [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, %y
   %scaled.if.denormal = select i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 ; Test assume of y works
 define float @fmul_by_var_if_0_oeq_zero_f32_assume_finite_fmul_nsz(float %x, float %y) {
 ; CHECK-LABEL: @fmul_by_var_if_0_oeq_zero_f32_assume_finite_fmul_nsz(
 ; CHECK-NEXT:    [[FABS_Y:%.*]] = call float @llvm.fabs.f32(float [[Y:%.*]])
 ; CHECK-NEXT:    [[IS_FINITE:%.*]] = fcmp olt float [[FABS_Y]], 0x7FF0000000000000
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[IS_FINITE]])
-; CHECK-NEXT:    [[X_IS_ZERO:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = select nsz i1 [[X_IS_ZERO]], float [[Y]], float 1.000000e+00
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = fmul float [[SCALED_X]], [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %fabs.y = call float @llvm.fabs.f32(float %y)
   %is.finite = fcmp olt float %fabs.y, 0x7FF0000000000000
   call void @llvm.assume(i1 %is.finite)
   %x.is.zero = fcmp oeq float %x, 0.0
   %scaled.x = fmul float %x, %y
   %scaled.if.denormal = select nsz i1 %x.is.zero, float %scaled.x, float %x
   ret float %scaled.if.denormal
 }
 
 ; Test assume of y works in inverted case
 define float @fmul_by_var_if_not_one_0_zero_f32_assume_finite_fmul_nsz(float %x, float %y) {
 ; CHECK-LABEL: @fmul_by_var_if_not_one_0_zero_f32_assume_finite_fmul_nsz(
 ; CHECK-NEXT:    [[FABS_Y:%.*]] = call float @llvm.fabs.f32(float [[Y:%.*]])
 ; CHECK-NEXT:    [[IS_FINITE:%.*]] = fcmp olt float [[FABS_Y]], 0x7FF0000000000000
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[IS_FINITE]])
-; CHECK-NEXT:    [[X_IS_NOT_ZERO:%.*]] = fcmp one float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[SCALED_X:%.*]] = select nsz i1 [[X_IS_NOT_ZERO]], float 1.000000e+00, float [[Y]]
-; CHECK-NEXT:    [[SCALED_IF_DENORMAL:%.*]] = fmul float [[SCALED_X]], [[X]]
-; CHECK-NEXT:    ret float [[SCALED_IF_DENORMAL]]
+; CHECK-NEXT:    ret float [[X:%.*]]
 ;
   %fabs.y = call float @llvm.fabs.f32(float %y)
   %is.finite = fcmp olt float %fabs.y, 0x7FF0000000000000
   call void @llvm.assume(i1 %is.finite)
   %x.is.not.zero = fcmp one float %x, 0.0
   %scaled.x = fmul float %x, %y
   %scaled.if.denormal = select nsz i1 %x.is.not.zero, float %x, float %scaled.x
   ret float %scaled.if.denormal