[InstCombine] Fold Select with binary op - FP opcodes

[xbolva00]

Summary

Follow up for https://reviews.llvm.org/rL339520 and https://reviews.llvm.org/rL338300

Alive:

%A = fcmp oeq float %x, 0.0
%B = fadd nsz float %x, %z
%C = select i1 %A, float %B, float %y
=>
%C = select i1 %A, float %z, float %y
----------                                                                      
  %A = fcmp oeq float %x, 0.0
  %B = fadd nsz float %x, %z
  %C = select %A, float %B, float %y
=>
  %C = select %A, float %z, float %y

Done: 1                                                                         
Optimization is correct

%A = fcmp une float %x, -0.0
%B = fadd nsz float %x, %z
%C = select i1 %A, float %y, float %B
=>
%C = select i1 %A, float %y, float %z
----------                                                                      
  %A = fcmp une float %x, -0.0
  %B = fadd nsz float %x, %z
  %C = select %A, float %y, float %B
=>
  %C = select %A, float %y, float %z

Done: 1                                                                         
Optimization is correct

[xbolva00]

test/Transforms/InstCombine/select-binop-cmp.ll

201 ↗

(On Diff #160580)

not sure why select_fsub_fcmp is not folded.

[xbolva00]

• Updated

[spatel]

lib/Transforms/InstCombine/InstCombineSelect.cpp

71 ↗

(On Diff #160625)

Did you step through the scenarios where X is NAN? I don't think the transform is valid for both predicates (similarly for ONE/UNE).

[xbolva00]

lib/Transforms/InstCombine/InstCombineSelect.cpp

71 ↗

(On Diff #160625)

Ok, so probably not worth to with FP opcodes? if it is so complicated.. Alive has some problems with float?

[spatel]

lib/Transforms/InstCombine/InstCombineSelect.cpp

71 ↗

(On Diff #160625)

AFAIK, Alive doesn't support FP yet.
I think this is still a good optimization for FP, we just have to do it carefully. So that just means prove that the output is correct with a NAN input and one or more of the FP predicates.

[xbolva00]

lib/Transforms/InstCombine/InstCombineSelect.cpp

71 ↗

(On Diff #160625)

How can we prove it?

I will add many tests with nan tomorrow so we can see changes directly.

[xbolva00]

• Tests with nan

[spatel]

lib/Transforms/InstCombine/InstCombineSelect.cpp

71 ↗

(On Diff #160625)

Options:

1. Use an FP-capable version of Alive - https://github.com/rutgers-apl/alive-nj (I have no experience with that).

2. Substitute %x with NaN in the basic pattern:

%A = fcmp oeq float %x, -0.0
%B = fadd float %x, %z
%C = select i1 %A, float %B, float %y

And see if the result is the same after the transform by working through the code by hand.

3. Run this IR under 'lli'? (again, I'm not very familiar with that tool)

4. Create a C program that would produce the IR patterns and step/printf through to see if the output is the same given a NaN input.

test/Transforms/InstCombine/select-binop-cmp.ll

361 ↗

(On Diff #161394)

These tests don't do what we need. If we're using a NaN constant (rather than a variable that is dynamically set to NaN), other optimizations will prevent the transform in question.

[xbolva00]

Ok, I create this IR manually + lli to interpret it
https://pastebin.com/MxdSFyTL

xbolva00@xbolva00:~/opt$ lli fp.ll 5 6
noopt 2.000000
fpoeq 2.000000
fpueq 2.000000
noopt 2.000000
fpoeq 2.000000
fpueq 2.000000
noopt nan
fpoeq nan
fpueq 2.000000
noopt nan
fpoeq nan
fpueq nan

---

So OEQ seems good.

Next steps:

1. Remove UEQ from optimization
2. Change tests + add nan tests (No idea yet how to do proper ones, small tip?)

[xbolva00]

Alive says that we cannot transform it. OEQ maybe yes with the check if zero has no sign.

Alive: https://pastebin.com/TkJB4RTr

[spatel]

In D50714#1205336, @xbolva00 wrote:

Alive says that we cannot transform it. OEQ maybe yes with the check if zero has no sign.

Alive: https://pastebin.com/TkJB4RTr

Great! You got alive-nj working.

So yes, looks like we have to check for 'nsz' and only OEQ (but not UEQ). For the tests, there's no easy way to encode what we're showing here AFAIK. We just need to make sure that we have both positive and negative tests when 'nsz' is (not) there and for each possible predicate.

[xbolva00]

• New tests

[spatel]

lib/Transforms/InstCombine/InstCombineSelect.cpp

85 ↗

(On Diff #161465)

I think this is a correct predicate, but stronger than necessary. Does alive-fp say we can get away with CannotBeNegativeZero(Y)? If it doesn't recognize that function, you could fake it by adding another operation that creates 'Y' (or '%z' as shown in the test names) while guaranteeing that it is not -0.0. So something like:
%z = fadd %v, 0.0 (this can never produce -0.0)

[xbolva00]

lib/Transforms/InstCombine/InstCombineSelect.cpp

85 ↗

(On Diff #161465)

%A = fcmp oeq float %x, 0.0
%z = fadd %v, 0.0
%B = fadd nsz float %x, %z
%C = select i1 %A, float %B, float %y
=>
%C = select i1 %A, float %z, float %y
----------                                                                      
  %A = fcmp oeq float %x, 0.0
  %z = fadd %v, 0.0
  %B = fadd nsz float %x, %z
  %C = select %A, float %B, float %y
=>
  %C = select %A, float %z, float %y

Done: 1                                                                         
Optimization is correct

%A = fcmp oeq float %x, 0.0
%z = fadd %v, 0.0
%B = fadd float %x, %z
%C = select i1 %A, float %B, float %y
=>
%C = select i1 %A, float %z, float %y
----------                                                                      
  %A = fcmp oeq float %x, 0.0
  %z = fadd %v, 0.0
  %B = fadd float %x, %z
  %C = select %A, float %B, float %y
=>
  %C = select %A, float %z, float %y

Done: 1                                                                         
Optimization is correct

85 ↗

(On Diff #161465)

So we can use

ValueTracker::CannotBeNegativeZero ?

[xbolva00]

• Less restrictive checks + new tests

[xbolva00]

• One more test with ConstantFP

[spatel]

lib/Transforms/InstCombine/InstCombineSelect.cpp

72–73 ↗

(On Diff #161647)

Did you try testing ONE/UNE in alive-fp?

91 ↗

(On Diff #161647)

This comment should explain, not just repeat the code:
+0.0 compares equal to -0.0, and so it does not behave as required for this transform. Bail out if we can not exclude that possibility.

92 ↗

(On Diff #161647)

I don't think you need to have these checks? But I suppose checking for FPMathOperator is a good avoidance for calling CannotBeNegativeZero for the common (integer) case.

[xbolva00]

lib/Transforms/InstCombine/InstCombineSelect.cpp

72–73 ↗

(On Diff #161647)

%A = fcmp one float %x, 0.0
%B = fadd nsz float %x, %z
%C = select i1 %A, float %B, float %y
=>
%C = select i1 %A, float %B, float %z
----------                                                                      
  %A = fcmp one float %x, 0.0
  %B = fadd nsz float %x, %z
  %C = select %A, float %B, float %y
=>
  %C = select %A, float %B, float %z

ERROR: Mismatch in values for float %C                                          

Example:
float %x = NaN
   i1 %A = 0x0 (0)
float %z = 0.0640411376953125*(2**-126)
float %B = NaN
float %y = 1.00048828125*(2**1)
source: 1.00048828125*(2**1)
target: 0.0640411376953125*(2**-126)

xbolva00@xbolva00:~/alive-nj$ ./run.py                               
[Reading from terminal...]
%A = fcmp une float %x, 0.0
%B = fadd nsz float %x, %z
%C = select i1 %A, float %B, float %y
=>
%C = select i1 %A, float %B, float %z
----------                                                                      
  %A = fcmp une float %x, 0.0
  %B = fadd nsz float %x, %z
  %C = select %A, float %B, float %y
=>
  %C = select %A, float %B, float %z

ERROR: Mismatch in values for float %C                                          

Example:
float %x = = +0.0
   i1 %A = 0x0 (0)
float %z = NaN
float %B = NaN
float %y = 0.0000002384185791015625*(2**-126)
source: 0.0000002384185791015625*(2**-126)
target: NaN

[spatel]

lib/Transforms/InstCombine/InstCombineSelect.cpp

72–73 ↗

(On Diff #161647)

I think you want these tests to use -0.0 because that's the identity constant for fadd.

[xbolva00]

• Drop ONE
• Fixed comment/code

[xbolva00]

lib/Transforms/InstCombine/InstCombineSelect.cpp

72–73 ↗

(On Diff #161647)

%A = fcmp one float %x, -0.0
%B = fadd nsz float %x, %z
%C = select i1 %A, float %B, float %y
=>
%C = select i1 %A, float %B, float %z
----------                                                                      
  %A = fcmp one float %x, -0.0
  %B = fadd nsz float %x, %z
  %C = select %A, float %B, float %y
=>
  %C = select %A, float %B, float %z

ERROR: Mismatch in values for float %C                                          

Example:
float %x = +0.0
   i1 %A = 0x0 (0)
float %z = -0.504963397979736328125*(2**-126)
float %B = -0.504963397979736328125*(2**-126)
float %y = 1.5*(2**-125)
source: 1.5*(2**-125)
target: -0.504963397979736328125*(2**-126)

%A = fcmp une float %x, -0.0
%B = fadd nsz float %x, %z
%C = select i1 %A, float %B, float %y
=>
%C = select i1 %A, float %B, float %z
----------                                                                      
  %A = fcmp une float %x, -0.0
  %B = fadd nsz float %x, %z
  %C = select %A, float %B, float %y
=>
  %C = select %A, float %B, float %z

ERROR: Mismatch in values for float %C                                          

Example:
float %x = +0.0
   i1 %A = 0x0 (0)
float %z = +oo
float %B = +oo
float %y = -0.03125*(2**-126)
source: -0.03125*(2**-126)
target: +oo

[xbolva00]

lib/Transforms/InstCombine/InstCombineSelect.cpp

72–73 ↗

(On Diff #161647)

Ok.

%A = fcmp une float %x, -0.0
%B = fadd nsz float %x, %z
%C = select i1 %A, float %y, float %B
=>
%C = select i1 %A, float %y, float %z
----------                                                                      
  %A = fcmp une float %x, -0.0
  %B = fadd nsz float %x, %z
  %C = select %A, float %y, float %B
=>
  %C = select %A, float %y, float %z

Done: 1                                                                         
Optimization is correct

[xbolva00]

• Support UNE

[xbolva00]

• Fixed tests

[xbolva00]

One more fix

[spatel]

I think we're almost done! Just a few nits inline.

lib/Transforms/InstCombine/InstCombineSelect.cpp

95 ↗

(On Diff #161736)

indent

test/Transforms/InstCombine/select-binop-cmp.ll

193 ↗

(On Diff #161736)

This is identical to select_fadd_fcmp_2? Did you mean to check OEQ instead?

583–584 ↗

(On Diff #161736)

The 'bad' tests provide good coverage for all of the ways this transform should be limited, but FP is complicated, and it's very difficult to know exactly which condition in the test causes us to bypass the transform - and that's with this patch fresh in memory...we probably won't remember any of this in a month. :)

Please add a short comment above each test to explain why we can't do the fold for that test.

[xbolva00]

• Addressed review comments

[spatel]

LGTM

[xbolva00]

In D50714#1209877, @spatel wrote:

LGTM

Thanks for your review and patience!

---

Now I am interested in https://bugs.llvm.org/show_bug.cgi?id=38479, maybe you can give me some hints where I should start do that missed optimization?

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

static Value *createMinMax(InstCombiner::BuilderTy &Builder,
                            SelectPatternFlavor SPF, Value *A, Value *B) {
   CmpInst::Predicate Pred = getMinMaxPred(SPF);
   assert(CmpInst::isIntPredicate(Pred) && "Expected integer predicate");
   return Builder.CreateSelect(Builder.CreateICmp(Pred, A, B), A, B);
 }
 
 /// Replace a select operand based on an equality comparison with the identity
 /// constant of a binop.
-static Instruction *foldSelectBinOpIdentity(SelectInst &Sel) {
+static Instruction *foldSelectBinOpIdentity(SelectInst &Sel, const TargetLibraryInfo &TLI) {
   // The select condition must be an equality compare with a constant operand.
-  // TODO: Support FP compares.
   Value *X;
   Constant *C;
   CmpInst::Predicate Pred;
-  if (!match(Sel.getCondition(), m_ICmp(Pred, m_Value(X), m_Constant(C))) ||
-      !ICmpInst::isEquality(Pred))
+  if (!match(Sel.getCondition(), m_Cmp(Pred, m_Value(X), m_Constant(C))))
+    return nullptr;
+
+  bool IsEq;
+  if (ICmpInst::isEquality(Pred))
+    IsEq = Pred == ICmpInst::ICMP_EQ;
+  else if (Pred == FCmpInst::FCMP_OEQ)
+    IsEq = true;
+  else if (Pred == FCmpInst::FCMP_UNE)
+    IsEq = false;
+  else
     return nullptr;
 
   // A select operand must be a binop, and the compare constant must be the
   // identity constant for that binop.
-  bool IsEq = Pred == ICmpInst::ICMP_EQ;
   BinaryOperator *BO;
   if (!match(Sel.getOperand(IsEq ? 1 : 2), m_BinOp(BO)) ||
       ConstantExpr::getBinOpIdentity(BO->getOpcode(), BO->getType(), true) != C)
     return nullptr;
 
   // Last, match the compare variable operand with a binop operand.
   Value *Y;
   if (!BO->isCommutative() && !match(BO, m_BinOp(m_Value(Y), m_Specific(X))))
     return nullptr;
   if (!match(BO, m_c_BinOp(m_Value(Y), m_Specific(X))))
     return nullptr;
 
+  // +0.0 compares equal to -0.0, and so it does not behave as required for this
+  // transform. Bail out if we can not exclude that possibility.
+  if (isa<FPMathOperator>(BO))
+    if (!BO->hasNoSignedZeros() && !CannotBeNegativeZero(Y, &TLI))
+      return nullptr;
+
   // BO = binop Y, X
   // S = { select (cmp eq X, C), BO, ? } or { select (cmp ne X, C), ?, BO }
   // =>
   // S = { select (cmp eq X, C),  Y, ? } or { select (cmp ne X, C), ?,  Y }
   Sel.setOperand(IsEq ? 1 : 2, Y);
   return &Sel;
 }
 
Instruction *InstCombiner::visitSelectInst(SelectInst &SI) {
 
   if (Instruction *BitCastSel = foldSelectCmpBitcasts(SI, Builder))
     return BitCastSel;
 
   // Simplify selects that test the returned flag of cmpxchg instructions.
   if (Instruction *Select = foldSelectCmpXchg(SI))
     return Select;
 
-  if (Instruction *Select = foldSelectBinOpIdentity(SI))
+  if (Instruction *Select = foldSelectBinOpIdentity(SI, TLI))
     return Select;
 
   return nullptr;
 }

llvm/trunk/test/Transforms/InstCombine/select-binop-cmp.ll

;
   %B = xor i32 %x, %z
   %C = select i1 %A, i32 %y, i32 %B
   ret i32 %C
 }
 
 define float @select_fadd_fcmp(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fadd_fcmp(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], -0.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fadd float [[X]], [[Z:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Z:%.*]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp oeq float %x, -0.0
-  %B = fadd float %x, %z
+  %B = fadd nsz float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
-define float @select_fadd_fcmp_2(float %x, float %y, float %z) {
+define float @select_fadd_fcmp_2(float %x, float %y, float %v) {
 ; CHECK-LABEL: @select_fadd_fcmp_2(
-; CHECK-NEXT:    [[A:%.*]] = fcmp ueq float [[X:%.*]], -0.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fadd float [[X]], [[Z:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    [[A:%.*]] = fcmp une float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[Z:%.*]] = fadd float [[V:%.*]], 0.000000e+00
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[Z]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
-  %A = fcmp ueq float %x, -0.0
-  %B = fadd float %x, %z
-  %C = select i1 %A, float %B, float %y
+  %A = fcmp une float %x, -0.0
+  %z = fadd float %v, 0.0 ; cannot produce -0.0
+  %B = fadd float %z, %x
+  %C = select i1 %A, float %y, float %B
   ret float %C
 }
 
-define float @select_fadd_fcmp_3(float %x, float %y, float %z) {
+define float @select_fadd_fcmp_3(float %x, float %y) {
 ; CHECK-LABEL: @select_fadd_fcmp_3(
-; CHECK-NEXT:    [[A:%.*]] = fcmp one float [[X:%.*]], -0.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fadd float [[Z:%.*]], [[X]]
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    [[A:%.*]] = fcmp une float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float 6.000000e+00
 ; CHECK-NEXT:    ret float [[C]]
 ;
-  %A = fcmp one float %x, -0.0
-  %B = fadd float %z, %x
+  %A = fcmp une float %x, -0.0
+  %B = fadd float 6.0, %x
   %C = select i1 %A, float %y, float %B
   ret float %C
 }
 
 define float @select_fadd_fcmp_4(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fadd_fcmp_4(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp une float [[X:%.*]], -0.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fadd float [[Z:%.*]], [[X]]
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[Z:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp une float %x, -0.0
-  %B = fadd float %z, %x
+  %B = fadd nsz float %z, %x
   %C = select i1 %A, float %y, float %B
   ret float %C
 }
 
+define float @select_fadd_fcmp_5(float %x, float %y, float %v) {
+; CHECK-LABEL: @select_fadd_fcmp_5(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[Z:%.*]] = fadd float [[V:%.*]], 0.000000e+00
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Z]], float [[Y:%.*]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, -0.0
+  %z = fadd float %v, 0.0 ; cannot produce -0.0
+  %B = fadd float %z, %x
+  %C = select i1 %A, float %B, float %y
+  ret float %C
+}
+
+define float @select_fadd_fcmp_6(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_6(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float 6.000000e+00, float [[Y:%.*]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, -0.0
+  %B = fadd float %x, 6.0
+  %C = select i1 %A, float %B, float %y
+  ret float %C
+}
+
 define float @select_fmul_fcmp(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fmul_fcmp(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fmul float [[X]], [[Z:%.*]]
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Z:%.*]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp oeq float %x, 1.0
-  %B = fmul float %x, %z
+  %B = fmul nsz float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
 define float @select_fsub_fcmp(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fsub_fcmp(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fsub float [[Z:%.*]], [[X]]
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Z:%.*]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp oeq float %x, 0.0
-  %B = fsub float %z, %x
+  %B = fsub nsz float %z, %x
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
 define float @select_fdiv_fcmp(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fdiv_fcmp(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 1.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fdiv float [[Z:%.*]], [[X]]
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Z:%.*]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp oeq float %x, 1.0
-  %B = fdiv float %z, %x
+  %B = fdiv nsz float %z, %x
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
 define i32 @select_sub_icmp(i32 %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @select_sub_icmp(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i32 [[X:%.*]], 0
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], i32 [[Z:%.*]], i32 [[Y:%.*]]

 ; CHECK-NEXT:    ret i32 [[C]]
 ;
   %A = icmp eq i32 %x, 3
   %B = or i32 %x, %z
   %C = select i1 %A, i32 %B, i32 %y
   ret i32 %C
 }
 
+; Invalid identity constant for FP op
 define float @select_fadd_fcmp_bad(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fadd_fcmp_bad(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], -1.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fadd float [[X]], [[Z:%.*]]
+; CHECK-NEXT:    [[B:%.*]] = fadd nsz float [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp oeq float %x, -1.0
-  %B = fadd float %x, %z
+  %B = fadd nsz float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
+; Invalid comparison type
 define float @select_fadd_fcmp_bad_2(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fadd_fcmp_bad_2(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp ueq float [[X:%.*]], -1.000000e+00
 ; CHECK-NEXT:    [[B:%.*]] = fadd float [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp ueq float %x, -1.0
   %B = fadd float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
+; Invalid comparison type
 define float @select_fadd_fcmp_bad_3(float %x, float %y, float %z, float %k) {
 ; CHECK-LABEL: @select_fadd_fcmp_bad_3(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp one float [[X:%.*]], [[K:%.*]]
 ; CHECK-NEXT:    [[B:%.*]] = fadd float [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp one float %x, %k
   %B = fadd float %x, %z
   %C = select i1 %A, float %y, float %B
   ret float %C
 }
 
+; Invalid order of operands of select
 define float @select_fadd_fcmp_bad_4(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fadd_fcmp_bad_4(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp une float [[X:%.*]], -0.000000e+00
 ; CHECK-NEXT:    [[B:%.*]] = fadd float [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp une float %x, -0.0
   %B = fadd float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
+; Invalid comparison type
+define float @select_fadd_fcmp_bad_5(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_5(
+; CHECK-NEXT:    [[A:%.*]] = fcmp one float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd nsz float [[Z:%.*]], [[X]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp one float %x, -0.0
+  %B = fadd nsz float %z, %x
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Invalid order of operands of select
+define float @select_fadd_fcmp_bad_6(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_6(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd nsz float [[Z:%.*]], [[X]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, -0.0
+  %B = fadd nsz float %z, %x
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Do not transform if we have signed zeros and if Z is possibly negative zero
+define float @select_fadd_fcmp_bad_7(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_7(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd float [[X]], [[Z:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, -0.0
+  %B = fadd float %x, %z
+  %C = select i1 %A, float %B, float %y
+  ret float %C
+}
+
+; Invalid comparison type
+define float @select_fadd_fcmp_bad_8(float %x, float %y, float %v) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_8(
+; CHECK-NEXT:    [[A:%.*]] = fcmp one float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[Z:%.*]] = fadd float [[V:%.*]], -1.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd float [[Z]], [[X]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp one float %x, -0.0
+  %z = fadd float %v, -1.0
+  %B = fadd float %z, %x
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Invalid comparison type
+define float @select_fadd_fcmp_bad_9(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_9(
+; CHECK-NEXT:    [[A:%.*]] = fcmp one float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd nsz float [[Z:%.*]], [[X]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp one float %x, -0.0
+  %B = fadd nsz float %z, %x
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Invalid comparison type
+define float @select_fadd_fcmp_bad_10(float %x, float %y, float %v) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_10(
+; CHECK-NEXT:    [[A:%.*]] = fcmp one float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[Z:%.*]] = fadd float [[V:%.*]], 0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd float [[Z]], [[X]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp one float %x, -0.0
+  %z = fadd float %v, 0.0 ; cannot produce -0.0
+  %B = fadd float %z, %x
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Do not transform if Z is possibly negative zero
+define float @select_fadd_fcmp_bad_11(float %x, float %y, float %v) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_11(
+; CHECK-NEXT:    [[A:%.*]] = fcmp une float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[Z:%.*]] = fadd float [[V:%.*]], -1.000000e+00
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[Z]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp une float %x, -0.0
+  %z = fadd float %v, -1.0
+  %B = fadd nsz float %z, %x
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Do not transform if we have signed zeros and if Z is possibly negative zero
+define float @select_fadd_fcmp_bad_12(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_12(
+; CHECK-NEXT:    [[A:%.*]] = fcmp une float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd float [[Z:%.*]], [[X]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp une float %x, -0.0
+  %B = fadd float %z, %x
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Invalid order of operands of select
+define float @select_fadd_fcmp_bad_13(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_13(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], -0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd nsz float [[X]], [[Z:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, -0.0
+  %B = fadd nsz float %x, %z
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Invalid identity constant for FP op
+define float @select_fadd_fcmp_bad_14(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_14(
+; CHECK-NEXT:    [[A:%.*]] = fcmp une float [[X:%.*]], -1.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd nsz float [[X]], [[Z:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp une float %x, -1.0
+  %B = fadd nsz float %x, %z
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Invalid identity constant for FP op
+define float @select_fadd_fcmp_bad_15(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_15(
+; CHECK-NEXT:    [[A:%.*]] = fcmp une float [[X:%.*]], 0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd nsz float [[Z:%.*]], [[X]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[Y:%.*]], float [[B]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp une float %x, 0.0
+  %B = fadd nsz float %z, %x
+  %C = select i1 %A, float %y, float %B
+  ret float %C
+}
+
+; Invalid identity constant for FP op
+define float @select_fadd_fcmp_bad_16(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fadd_fcmp_bad_16(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fadd nsz float [[Z:%.*]], [[X]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, 0.0
+  %B = fadd nsz float %z, %x
+  %C = select i1 %A, float %B, float %y
+  ret float %C
+}
+
 define float @select_fmul_fcmp_bad(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fmul_fcmp_bad(
 ; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 3.000000e+00
-; CHECK-NEXT:    [[B:%.*]] = fmul float [[X]], [[Z:%.*]]
+; CHECK-NEXT:    [[B:%.*]] = fmul nsz float [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = fcmp oeq float %x, 3.0
+  %B = fmul nsz float %x, %z
+  %C = select i1 %A, float %B, float %y
+  ret float %C
+}
+
+define float @select_fmul_fcmp_bad_2(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fmul_fcmp_bad_2(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 1.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fmul float [[X]], [[Z:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, 1.0
   %B = fmul float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
 define float @select_fmul_icmp_bad(float %x, float %y, float %z, i32 %k) {
 ; CHECK-LABEL: @select_fmul_icmp_bad(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i32 [[K:%.*]], 0
 ; CHECK-NEXT:    [[B:%.*]] = fmul float [[X:%.*]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
   %A = icmp eq i32 %k, 0
   %B = fmul float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
+define float @select_fmul_icmp_bad_2(float %x, float %y, float %z, i32 %k) {
+; CHECK-LABEL: @select_fmul_icmp_bad_2(
+; CHECK-NEXT:    [[A:%.*]] = icmp eq i32 [[K:%.*]], 0
+; CHECK-NEXT:    [[B:%.*]] = fmul nsz float [[X:%.*]], [[Z:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = icmp eq i32 %k, 0
+  %B = fmul nsz float %x, %z
+  %C = select i1 %A, float %B, float %y
+  ret float %C
+}
+
 define float @select_fdiv_fcmp_bad(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fdiv_fcmp_bad(
-; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 3.000000e+00
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 1.000000e+00
 ; CHECK-NEXT:    [[B:%.*]] = fdiv float [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
-  %A = fcmp oeq float %x, 3.0
+  %A = fcmp oeq float %x, 1.0
   %B = fdiv float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
+define float @select_fdiv_fcmp_bad_2(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fdiv_fcmp_bad_2(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 3.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fdiv nsz float [[X]], [[Z:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, 3.0
+  %B = fdiv nsz float %x, %z
+  %C = select i1 %A, float %B, float %y
+  ret float %C
+}
+
 define float @select_fsub_fcmp_bad(float %x, float %y, float %z) {
 ; CHECK-LABEL: @select_fsub_fcmp_bad(
-; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 1.000000e+00
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 0.000000e+00
 ; CHECK-NEXT:    [[B:%.*]] = fsub float [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[C]]
 ;
-  %A = fcmp oeq float %x, 1.0
+  %A = fcmp oeq float %x, 0.0
   %B = fsub float %x, %z
   %C = select i1 %A, float %B, float %y
   ret float %C
 }
 
+define float @select_fsub_fcmp_bad_2(float %x, float %y, float %z) {
+; CHECK-LABEL: @select_fsub_fcmp_bad_2(
+; CHECK-NEXT:    [[A:%.*]] = fcmp oeq float [[X:%.*]], 1.000000e+00
+; CHECK-NEXT:    [[B:%.*]] = fsub nsz float [[X]], [[Z:%.*]]
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], float [[B]], float [[Y:%.*]]
+; CHECK-NEXT:    ret float [[C]]
+;
+  %A = fcmp oeq float %x, 1.0
+  %B = fsub nsz float %x, %z
+  %C = select i1 %A, float %B, float %y
+  ret float %C
+}
+
 define i32 @select_sub_icmp_bad(i32 %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @select_sub_icmp_bad(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i32 [[X:%.*]], 0
 ; CHECK-NEXT:    [[B:%.*]] = sub i32 [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], i32 [[B]], i32 [[Y:%.*]]
 ; CHECK-NEXT:    ret i32 [[C]]
 ;
   %A = icmp eq i32 %x, 0