[InstCombine] Enable Add/Sub simplifications with only 'reassoc' FMF

[wristow]

Summary

These simplifications were previously enabled only with isFast(), but that
is more restrictive than required. Since r317488, FMF has 'reassoc' to
control these cases at a finer level.

[spatel]

The tests here demonstrate the overlap between instcombine and reassociate, and based on feedback I've gotten, I'd say that rL170471 was a mistake for instcombine. It created a mini-reassociation pass within instcombine.

I've been cataloging, testing, and updating FP binop instcombines recently (eg, rL328502, rL329501), and the remaining big blob is FAddCombine() - which is poorly named because as shown in this patch, it's also called from visitFSub()...

I don't actually know everything that can happen in this code, but if others are confident that it's just reassociation (without need for nsz/nnan/ninf), then I suppose this is ok to loosen up. I'd still like to have dedicated tests in instcombine for whatever is happening in FAddCombine() though, so add to the tests from rL170471 to demonstrate at least some of the diffs without needing -reassociate?

[wristow]

A couple of short comments/questions, and one longer one:

In D45453#1063225, @spatel wrote:

... the remaining big blob is FAddCombine() - which is poorly named because as shown in this patch, it's also called from visitFSub()...

Should we rename it to FAddSubCombine() in this work (assuming this patch moves forward, given the other questions here)?

... I'd still like to have dedicated tests in instcombine for whatever is happening in FAddCombine() though, so add to the tests from rL170471 to demonstrate at least some of the diffs without needing -reassociate?

To be sure I'm understanding, you mean demonstrate some diffs in those tests using the flag 'reassoc' rather than 'fast' (without needing -reassociate), right? I have a concern that meaningful transformations based on the 'reassoc' flag alone may require both -instcombine and -reassociate.

My longer question relates to:

... but if others are confident that it's just reassociation (without need for nsz/nnan/ninf), then I suppose this is ok to loosen up.

In a sense, I do feel we should check 'nsz' in addition to 'reassoc' (and maybe others). And similarly, the tests in the other files that I modified in this patch possibly should only do the transformation if 'reassoc' and 'nsz' (and others?) are set. But when starting with C/C++ (when -ffast-math isn't specified), we only will set 'reassoc' if some other switches in addition to -fassociative-math are passed. Specifically:
-fassociative-math -fno-signed-zeros -fno-trapping-math

(details at D39812).

So in a sense, an instruction that has only 'reassoc' set on it isn't complete, in that it cannot be generated by Clang. I feel like this is an IEEE thing, rather than a C/C++ thing (so other language front-ends ought to do something similar). But from this perspective, is checking only 'reassoc' OK? Or is should we change tests that have only 'reassoc' on an instruction to also have 'nsz'? Which then leads me to the problem/question that -fno-trapping-math doesn't have a bit in FMF, so it creates a new dimension to the problem/question.

Anyway, I took the interpretation that when the 'reassoc' bit is set, it in a sense means the equivalent of at least -fassociative-math -fno-signed-zeros -fno-trapping-math from a C/C++ command-line perspective. I'm not sure how we should interpret this. As I write this comment, I feel like I've opened a can of worms.

[spatel]

In D45453#1063950, @wristow wrote:

A couple of short comments/questions, and one longer one:

In D45453#1063225, @spatel wrote:

... the remaining big blob is FAddCombine() - which is poorly named because as shown in this patch, it's also called from visitFSub()...

Should we rename it to FAddSubCombine() in this work (assuming this patch moves forward, given the other questions here)?

I'd prefer more specific like reassociateFAddFSub(), but I wouldn't bother unless we want to keep that code in its current form.

... I'd still like to have dedicated tests in instcombine for whatever is happening in FAddCombine() though, so add to the tests from rL170471 to demonstrate at least some of the diffs without needing -reassociate?

To be sure I'm understanding, you mean demonstrate some diffs in those tests using the flag 'reassoc' rather than 'fast' (without needing -reassociate), right?

Yes. Example from fast-math.ll:

; (X + C1) + C2 => X + (C1 + C2)
define float @fold5_reassoc(float %f1, float %f2) {
; CHECK-LABEL: @fold5(
; CHECK-NEXT:    [[ADD1:%.*]] = fadd reassoc float [[F1:%.*]], 9.000000e+00
; CHECK-NEXT:    ret float [[ADD1]]
;
  %add = fadd float %f1, 4.000000e+00
  %add1 = fadd reassoc float %add, 5.000000e+00
  ret float %add1
}

So put something like that under the existing test to show the minimal FMF requirement. Or just replace the 'fast' in the existing test with 'reassoc'.

I have a concern that meaningful transformations based on the 'reassoc' flag alone may require both -instcombine and -reassociate.

There could be some kind of symbiotic behavior here, but this is really saying that we don't have a well-defined division of labor between these passes, right?

My longer question relates to:

... but if others are confident that it's just reassociation (without need for nsz/nnan/ninf), then I suppose this is ok to loosen up.

In a sense, I do feel we should check 'nsz' in addition to 'reassoc' (and maybe others). And similarly, the tests in the other files that I modified in this patch possibly should only do the transformation if 'reassoc' and 'nsz' (and others?) are set. But when starting with C/C++ (when -ffast-math isn't specified), we only will set 'reassoc' if some other switches in addition to -fassociative-math are passed. Specifically:
-fassociative-math -fno-signed-zeros -fno-trapping-math

(details at D39812).

So in a sense, an instruction that has only 'reassoc' set on it isn't complete, in that it cannot be generated by Clang. I feel like this is an IEEE thing, rather than a C/C++ thing (so other language front-ends ought to do something similar). But from this perspective, is checking only 'reassoc' OK? Or is should we change tests that have only 'reassoc' on an instruction to also have 'nsz'? Which then leads me to the problem/question that -fno-trapping-math doesn't have a bit in FMF, so it creates a new dimension to the problem/question.

Anyway, I took the interpretation that when the 'reassoc' bit is set, it in a sense means the equivalent of at least -fassociative-math -fno-signed-zeros -fno-trapping-math from a C/C++ command-line perspective. I'm not sure how we should interpret this. As I write this comment, I feel like I've opened a can of worms.

Hopefully, not. :)

We need to be careful here - just because clang is behaving some way doesn't mean other front-ends are doing the same. We defined the LLVM FMF (maybe not precisely enough in the LangRef) so 'reassoc' and 'nsz' are independent bits.

I've made several recent changes to the FMF requirements in instsimplify/instcombine assuming that 'reassoc' does not imply anything beyond the ability to rearrange math ops. If the sign-of-zero doesn't match the IEEE requirements, then the transform needs 'nsz' too. Trapping isn't a concern because we assume a default FP environment (see recent edits to the LangRef).

So a few ways forward:

1. Easiest: change the FMF requirements in this patch to reassoc + nsz. We're confident that this code only deals with fadd/fsub, so { nnan , ninf , arcp , afn , contract } shouldn't be in play.
2. More involved: audit (and add tests for) all of the potential transforms enabled by FAddCombine and determine when only 'reassoc' is needed.
3. Ideal: audit instcombine and the reassociate pass and split up the transforms, so we don't have redundancies - or at least the redundancies are justified and documented. Note that this goes beyond just the FAddCombine chunk of code. We also do reassociation in instcombine under the name SimplifyAssociativeOrCommutative(), and I think FAddCombine() has redundant code for things that are handled there too.

[wristow]

Thanks for the clarifications Sanjay!

In D45453#1064271, @spatel wrote:

...
Yes. Example from fast-math.ll:

; (X + C1) + C2 => X + (C1 + C2)
define float @fold5_reassoc(float %f1, float %f2) {
; CHECK-LABEL: @fold5(
; CHECK-NEXT:    [[ADD1:%.*]] = fadd reassoc float [[F1:%.*]], 9.000000e+00
; CHECK-NEXT:    ret float [[ADD1]]
;
  %add = fadd float %f1, 4.000000e+00
  %add1 = fadd reassoc float %add, 5.000000e+00
  ret float %add1
}

So put something like that under the existing test to show the minimal FMF requirement. Or just replace the 'fast' in the existing test with 'reassoc'.

I have a concern that meaningful transformations based on the 'reassoc' flag alone may require both -instcombine and -reassociate.

There could be some kind of symbiotic behavior here, but this is really saying that we don't have a well-defined division of labor between these passes, right?

Yes, a lack of a well-defined division of labor between these passes is exactly my concern. I'll look into adding or modifying tests. Depending on possible interaction, that may not be fruitful. Ultimately, that should be addressed.

To be explicit, my immediate goal is to make reassociation "work" when unrelated FMF are disabled. For example:

float foo(float arg, float x) { return (arg + x) - x; }

should simply return arg when compiled at -O2 -ffast-math -fno-reciprocal-math. But as it currently stands, since -fno-reciprocal-math makes isFast() false, disabling the reciprocal transformation incorrectly prevents the reassoication.

So although ultimately the -instcombine/-reassociate division of labor should be addressed, I'd prefer to make this small step in improving the FMF status without doing that more substantial piece of work.

So in a sense, an instruction that has only 'reassoc' set on it isn't complete, in that it cannot be generated by Clang. I feel like this is an IEEE thing, rather than a C/C++ thing (so other language front-ends ought to do something similar). But from this perspective, is checking only 'reassoc' OK? Or is should we change tests that have only 'reassoc' on an instruction to also have 'nsz'? Which then leads me to the problem/question that -fno-trapping-math doesn't have a bit in FMF, so it creates a new dimension to the problem/question.

Anyway, I took the interpretation that when the 'reassoc' bit is set, it in a sense means the equivalent of at least -fassociative-math -fno-signed-zeros -fno-trapping-math from a C/C++ command-line perspective. I'm not sure how we should interpret this. As I write this comment, I feel like I've opened a can of worms.

Hopefully, not. :)

We need to be careful here - just because clang is behaving some way doesn't mean other front-ends are doing the same. We defined the LLVM FMF (maybe not precisely enough in the LangRef) so 'reassoc' and 'nsz' are independent bits.

OK, I can certainly be on board with that. My point about it feels like an IEEE thing rather than a C/C++ thing was to imply that other front-ends really should be doing the same. But in any case, I do like that clarity of (for example) 'reassoc' and 'nsz' explicitly being understood to be independent bits (or more directly, that 'reassoc' alone isn't generally enough to enable reassoication). Further, that clarification helps to keep the can of worms closed.

...
So a few ways forward:

1. Easiest: change the FMF requirements in this patch to reassoc + nsz. We're confident that this code only deals with fadd/fsub, so { nnan , ninf , arcp , afn , contract } shouldn't be in play.
2. More involved: audit (and add tests for) all of the potential transforms enabled by FAddCombine and determine when only 'reassoc' is needed.
3. Ideal: audit instcombine and the reassociate pass and split up the transforms, so we don't have redundancies - or at least the redundancies are justified and documented. Note that this goes beyond just the FAddCombine chunk of code. We also do reassociation in instcombine under the name SimplifyAssociativeOrCommutative(), and I think FAddCombine() has redundant code for things that are handled there too.

Short term, I'll intend to do (1) -- this approach will let me meet my goal of making reassociation work when unrelated FMF are disabled (at least it will in some cases). In doing that, I'll experiment with updating the tests in fast-math.ll, like you suggest.
Also in doing that, I'll look into (2) at least somewhat, to see if there are additional changes that clearly would go well as part of this sort of change.

Longer term, I'll look into (3). Not sure when I'll get to that, though.

[wristow]

I've updated the code-change in "InstCombineAddSub.cpp" to require both 'reassoc' and 'nsz' to do the transformations. (I haven't changed the name from FAddCombine to FAddSubCombine or ReassociateFAddFSub. I could do that if we move forward with this.)

There could be some kind of symbiotic behavior here, but this is really saying that we don't have a well-defined division of labor between these passes, right?

Yes, a lack of a well-defined division of labor between these passes is exactly my concern. I'll look into adding or modifying tests. Depending on possible interaction, that may not be fruitful. Ultimately, that should be addressed.

In looking this over, I was pleasantly surprised that I didn't run into the troublesome interaction I was concerned about. So I've added new tests to "InstCombine/fast-math.ll" to check for the transformations happening when 'reassoc' + 'nsz' are on (with only '-instcombine' used). I've also added tests that verify that 'reassoc' alone doesn't enable the transformation in the appropriate places. Lastly, I updated the tests I had previously modified to use both 'reassoc' and 'nsz' where appropriate when testing for the minimal set of needed flags to transform things.

[spatel]

In D45453#1066811, @wristow wrote:

I've updated the code-change in "InstCombineAddSub.cpp" to require both 'reassoc' and 'nsz' to do the transformations. (I haven't changed the name from FAddCombine to FAddSubCombine or ReassociateFAddFSub. I could do that if we move forward with this.)

There could be some kind of symbiotic behavior here, but this is really saying that we don't have a well-defined division of labor between these passes, right?

Yes, a lack of a well-defined division of labor between these passes is exactly my concern. I'll look into adding or modifying tests. Depending on possible interaction, that may not be fruitful. Ultimately, that should be addressed.

In looking this over, I was pleasantly surprised that I didn't run into the troublesome interaction I was concerned about. So I've added new tests to "InstCombine/fast-math.ll" to check for the transformations happening when 'reassoc' + 'nsz' are on (with only '-instcombine' used). I've also added tests that verify that 'reassoc' alone doesn't enable the transformation in the appropriate places. Lastly, I updated the tests I had previously modified to use both 'reassoc' and 'nsz' where appropriate when testing for the minimal set of needed flags to transform things.

Thanks - more instcombine tests in this area are needed IMO.

I think the code change is fine in that it removes the unrelated FMF from these transforms. And it may be that after this change, we're 'good enough'. Ie, it may be that nobody cares about splitting the FMF hairs further than this.

But I have pointed out some test comments that I don't think are correct. I didn't look at all tests, but I suggest softening the language in general and adding 'TODO', so if someone does decide to improve more, the tests acknowledge that what we have currently isn't complete.

test/Transforms/InstCombine/fast-math.ll

61–62

x * 2.0 + x --> x * 3.0

This doesn't require 'nsz'? If x = -0.0, this preserves that the output is -0.0.

In fact, this exact case doesn't need any fast-ness? (cc @scanon)
https://reviews.llvm.org/D31164?id=92521#inline-270764

99–101

(4.0 - x) + (5.0 - y) --> 9.0 - (x + y)

Again, I don't think this actually requires 'nsz'. Maybe it's better to mark all similar tests with "TODO: We may be able to remove the 'nsz' requirement."

232–235

See the earlier link - another potential special-case where we don't need any FMF.

407–414

-x + y --> y - x

This doesn't require any FMF.

429–436

x + (-y) --> x - y

Again, no FMF needed at all.

[wristow]

Thanks Sanjay. Updated the tests to be more careful about when 'nsz' is and isn't needed, along with comments to clarify. Also simplified some tests where no FMF is needed (irrespective of this patch).

[wristow]

test/Transforms/InstCombine/fast-math.ll

61–62

I've updated the comment about 'nsz' not being needed, and I've changed the test so as not to be exercising the special-case of 3*x (and added a comment about the special-case as a TODO, in case anyone ever wants to take advantage of that point).

99–101

Thanks. In looking, I think this one definitely doesn't require 'nsz', so I've added a TODO comment that's says 'nsz' is unneeded (rather than "may be able to remove..."). Same for many of the others, so I've added similar TODO comments, where appropriate.

232–235

I've updated the test to have the opportunity for more folding, so it's not the special-case of x+x+x.
Also, 'nsz' isn't technically required, so I've added a TODO.

407–414

Good point! In fact, it does fold without any FMF, even without my patch. I've updated the test to demonstrate the folding without 'fast' (or anything else).

429–436

As with 'fold14()' above, this does fold without any FMF, even without my patch. Test updated.

[spatel]

LGTM - see inline for a couple of potential follow-ups.

test/Transforms/InstCombine/fast-math.ll

379

Maybe independent of this patch, but the fmul shouldn't need any FMF for this fold, so it's worth checking if that actually happens. Another consideration is whether the fmul hasOneUse(). We definitely don't have enough multi-use tests to show that folds are not unintentionally creating extra instructions.

407–414

Nit: it's a bit crazy that there are no existing regression tests for these always-safe fneg folds; must be from the early cowboy compiler days. :)
There really should be an 'fadd.ll' test file for non-FMF folds.

[wristow]

Thanks for the review Sanjay. Now committed, at r330089

https://reviews.llvm.org/rL330089

[wristow]

test/Transforms/InstCombine/fast-math.ll

379

Hmmm... You're saying that the transformation:
c1 * x - x => (c1 - 1.0) * x
shouldn't need any FMF? That doesn't seem right to me. I think both 'reassoc' and 'nsz' should be needed.

[spatel]

test/Transforms/InstCombine/fast-math.ll

379

The fsub needs FMF, but not the fmul. That's the general rule we're using in FMF-enabled folds. The non-strict final value (the result of the fsub) is what we're reassociating/factoring here, so as long as that instruction has reassoc+nsz, it doesn't matter if the fmul intermediate value is strict.

[wristow]

The fsub needs FMF, but not the fmul. That's the general rule we're using in FMF-enabled folds. The non-strict final value (the result of the fsub) is what we're reassociating/factoring here, so as long as that instruction has reassoc+nsz, it doesn't matter if the fmul intermediate value is strict

Got it. Thanks for explaining,

lib/Transforms/InstCombine/InstCombineAddSub.cpp

Value *FAddCombine::performFactorization(Instruction *I) {
 
   Value *RI = createFDiv(NewAddSub, Factor);
   if (Instruction *II = dyn_cast<Instruction>(RI))
     II->setFastMathFlags(Flags);
   return RI;
 }
 
 Value *FAddCombine::simplify(Instruction *I) {
-  assert(I->isFast() && "Expected 'fast' instruction");
+  assert(I->hasAllowReassoc() && I->hasNoSignedZeros() &&
+         "Expected 'reassoc'+'nsz' instruction");
 
   // Currently we are not able to handle vector type.
   if (I->getType()->isVectorTy())
     return nullptr;
 
   assert((I->getOpcode() == Instruction::FAdd ||
           I->getOpcode() == Instruction::FSub) && "Expect add/sub");
 
if (SIToFPInst *RHSConv = dyn_cast<SIToFPInst>(RHS)) {
       }
     }
   }
 
   // Handle specials cases for FAdd with selects feeding the operation
   if (Value *V = SimplifySelectsFeedingBinaryOp(I, LHS, RHS))
     return replaceInstUsesWith(I, V);
 
-  if (I.isFast()) {
+  if (I.hasAllowReassoc() && I.hasNoSignedZeros()) {
     if (Value *V = FAddCombine(Builder).simplify(&I))
       return replaceInstUsesWith(I, V);
   }
 
   return Changed ? &I : nullptr;
 }
 
 /// Optimize pointer differences into the same array into a size.  Consider:
if (match(Op1, m_OneUse(m_FPExt(m_FNeg(m_Value(Y)))))) {
     Value *ExtY = Builder.CreateFPExt(Y, I.getType());
     return BinaryOperator::CreateFAddFMF(Op0, ExtY, &I);
   }
 
   // Handle specials cases for FSub with selects feeding the operation
   if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))
     return replaceInstUsesWith(I, V);
 
-  if (I.isFast()) {
+  if (I.hasAllowReassoc() && I.hasNoSignedZeros()) {
     if (Value *V = FAddCombine(Builder).simplify(&I))
       return replaceInstUsesWith(I, V);
   }
 
   return nullptr;
 }

test/Transforms/InstCombine/fast-math.ll

 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast double [[F1:%.*]], 3.000000e+00
 ; CHECK-NEXT:    ret double [[TMP1]]
 ;
   %t1 = fmul fast double 2.000000e+00, %f1
   %t2 = fadd fast double %f1, %t1
   ret double %t2
 }
 
+; Check again using the minimal subset of FMF.
+define double @fold3_reassoc_nsz(double %f1) {
+; CHECK-LABEL: @fold3_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc nsz double [[F1:%.*]], 3.000000e+00
+; CHECK-NEXT:    ret double [[TMP1]]
+;
+  %t1 = fmul reassoc nsz double 2.000000e+00, %f1
+  %t2 = fadd reassoc nsz double %f1, %t1
+  ret double %t2
+}
+
+; Verify the fold is not done with only reassoc.
+define double @fold3_reassoc(double %f1) {
+; CHECK-LABEL: @fold3_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc double [[F1:%.*]], 2.000000e+00
+; CHECK-NEXT:    [[TMP2:%.*]] = fadd reassoc double [[TMP1]], [[F1]]
+; CHECK-NEXT:    ret double [[TMP2]]
+;
+  %t1 = fmul reassoc double 2.000000e+00, %f1
+  %t2 = fadd reassoc double %f1, %t1
+  ret double %t2
+}
+
 ; (C1 - X) + (C2 - Y) => (C1+C2) - (X + Y)
 define float @fold4(float %f1, float %f2) {
 ; CHECK-LABEL: @fold4(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fadd fast float [[F1:%.*]], [[F2:%.*]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fsub fast float 9.000000e+00, [[TMP1]]
 ; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %sub = fsub float 4.000000e+00, %f1
   %sub1 = fsub float 5.000000e+00, %f2
   %add = fadd fast float %sub, %sub1
   ret float %add
 }
 
+; Check again using the minimal subset of FMF.
+define float @fold4_reassoc_nsz(float %f1, float %f2) {
+; CHECK-LABEL: @fold4_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd reassoc nsz float [[F1:%.*]], [[F2:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fsub reassoc nsz float 9.000000e+00, [[TMP1]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %sub = fsub float 4.000000e+00, %f1
+  %sub1 = fsub float 5.000000e+00, %f2
+  %add = fadd reassoc nsz float %sub, %sub1
+  ret float %add
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fold4_reassoc(float %f1, float %f2) {
+; CHECK-LABEL: @fold4_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub float 4.000000e+00, [[F1:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fsub float 5.000000e+00, [[F2:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fadd reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %sub = fsub float 4.000000e+00, %f1
+  %sub1 = fsub float 5.000000e+00, %f2
+  %add = fadd reassoc float %sub, %sub1
+  ret float %add
+}
+
 ; (X + C1) + C2 => X + (C1 + C2)
 define float @fold5(float %f1, float %f2) {
 ; CHECK-LABEL: @fold5(
 ; CHECK-NEXT:    [[ADD1:%.*]] = fadd fast float [[F1:%.*]], 9.000000e+00
 ; CHECK-NEXT:    ret float [[ADD1]]
 ;
   %add = fadd float %f1, 4.000000e+00
   %add1 = fadd fast float %add, 5.000000e+00
   ret float %add1
 }
 
+; Check again using the minimal subset of FMF.
+define float @fold5_reassoc_nsz(float %f1, float %f2) {
+; CHECK-LABEL: @fold5_reassoc_nsz(
+; CHECK-NEXT:    [[ADD1:%.*]] = fadd reassoc nsz float [[F1:%.*]], 9.000000e+00
+; CHECK-NEXT:    ret float [[ADD1]]
+;
+  %add = fadd float %f1, 4.000000e+00
+  %add1 = fadd reassoc nsz float %add, 5.000000e+00
+  ret float %add1
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fold5_reassoc(float %f1, float %f2) {
+; CHECK-LABEL: @fold5_reassoc(
+; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[F1:%.*]], 4.000000e+00
+; CHECK-NEXT:    [[ADD1:%.*]] = fadd reassoc float [[ADD]], 5.000000e+00
+; CHECK-NEXT:    ret float [[ADD1]]
+;
+  %add = fadd float %f1, 4.000000e+00
+  %add1 = fadd reassoc float %add, 5.000000e+00
+  ret float %add1
+}
+
 ; (X + X) + X => 3.0 * X
 define float @fold6(float %f1) {
 ; CHECK-LABEL: @fold6(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[F1:%.*]], 3.000000e+00
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %t1 = fadd fast float %f1, %f1
   %t2 = fadd fast float %f1, %t1
   ret float %t2
 }
 
+; Check again using the minimal subset of FMF.
+define float @fold6_reassoc_nsz(float %f1) {
+; CHECK-LABEL: @fold6_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc nsz float [[F1:%.*]], 3.000000e+00
+; CHECK-NEXT:    ret float [[TMP1]]
+;
+  %t1 = fadd reassoc nsz float %f1, %f1
+  %t2 = fadd reassoc nsz float %f1, %t1
+  ret float %t2
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fold6_reassoc(float %f1) {
+; CHECK-LABEL: @fold6_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd reassoc float [[F1:%.*]], [[F1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fadd reassoc float [[TMP1]], [[F1]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %t1 = fadd reassoc float %f1, %f1
+  %t2 = fadd reassoc float %f1, %t1
+  ret float %t2
+}
+
 ; C1 * X + (X + X) = (C1 + 2) * X
 define float @fold7(float %f1) {
 ; CHECK-LABEL: @fold7(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[F1:%.*]], 7.000000e+00
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %t1 = fmul fast float %f1, 5.000000e+00
   %t2 = fadd fast float %f1, %f1
   %t3 = fadd fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fold7_reassoc_nsz(float %f1) {
+; CHECK-LABEL: @fold7_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc nsz float [[F1:%.*]], 7.000000e+00
+; CHECK-NEXT:    ret float [[TMP1]]
+;
+  %t1 = fmul reassoc nsz float %f1, 5.000000e+00
+  %t2 = fadd reassoc nsz float %f1, %f1
+  %t3 = fadd reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fold7_reassoc(float %f1) {
+; CHECK-LABEL: @fold7_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[F1:%.*]], 5.000000e+00
+; CHECK-NEXT:    [[TMP2:%.*]] = fadd reassoc float [[F1]], [[F1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fadd reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t1 = fmul reassoc float %f1, 5.000000e+00
+  %t2 = fadd reassoc float %f1, %f1
+  %t3 = fadd reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; (X + X) + (X + X) => 4.0 * X
 define float @fold8(float %f1) {
 ; CHECK-LABEL: @fold8(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[F1:%.*]], 4.000000e+00
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %t1 = fadd fast float %f1, %f1
   %t2 = fadd fast float %f1, %f1
   %t3 = fadd fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fold8_reassoc_nsz(float %f1) {
+; CHECK-LABEL: @fold8_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc nsz float [[F1:%.*]], 4.000000e+00
+; CHECK-NEXT:    ret float [[TMP1]]
+;
+  %t1 = fadd reassoc nsz float %f1, %f1
+  %t2 = fadd reassoc nsz float %f1, %f1
+  %t3 = fadd reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fold8_reassoc(float %f1) {
+; CHECK-LABEL: @fold8_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd reassoc float [[F1:%.*]], [[F1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fadd reassoc float [[F1]], [[F1]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fadd reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t1 = fadd reassoc float %f1, %f1
+  %t2 = fadd reassoc float %f1, %f1
+  %t3 = fadd reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; X - (X + Y) => 0 - Y
 define float @fold9(float %f1, float %f2) {
 ; CHECK-LABEL: @fold9(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast float -0.000000e+00, [[F2:%.*]]
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %t1 = fadd float %f1, %f2
   %t3 = fsub fast float %f1, %t1
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fold9_reassoc_nsz(float %f1, float %f2) {
+; CHECK-LABEL: @fold9_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc nsz float -0.000000e+00, [[F2:%.*]]
+; CHECK-NEXT:    ret float [[TMP1]]
+;
+  %t1 = fadd float %f1, %f2
+  %t3 = fsub reassoc nsz float %f1, %t1
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fold9_reassoc(float %f1, float %f2) {
+; CHECK-LABEL: @fold9_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd float [[F1:%.*]], [[F2:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fsub reassoc float [[F1]], [[TMP1]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %t1 = fadd float %f1, %f2
+  %t3 = fsub reassoc float %f1, %t1
+  ret float %t3
+}
+
 ; Let C3 = C1 + C2. (f1 + C1) + (f2 + C2) => (f1 + f2) + C3 instead of
 ; "(f1 + C3) + f2" or "(f2 + C3) + f1". Placing constant-addend at the
 ; top of resulting simplified expression tree may potentially reveal some
 ; optimization opportunities in the super-expression trees.
 ;
 define float @fold10(float %f1, float %f2) {
 ; CHECK-LABEL: @fold10(
 ; CHECK-NEXT:    [[T2:%.*]] = fadd fast float [[F1:%.*]], [[F2:%.*]]
 ; CHECK-NEXT:    [[T3:%.*]] = fadd fast float [[T2]], -1.000000e+00
 ; CHECK-NEXT:    ret float [[T3]]
 ;
   %t1 = fadd fast float 2.000000e+00, %f1
   %t2 = fsub fast float %f2, 3.000000e+00
   %t3 = fadd fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fold10_reassoc_nsz(float %f1, float %f2) {
+; CHECK-LABEL: @fold10_reassoc_nsz(
+; CHECK-NEXT:    [[T2:%.*]] = fadd reassoc nsz float [[F1:%.*]], [[F2:%.*]]
+; CHECK-NEXT:    [[T3:%.*]] = fadd reassoc nsz float [[T2]], -1.000000e+00
+; CHECK-NEXT:    ret float [[T3]]
+;
+  %t1 = fadd reassoc nsz float 2.000000e+00, %f1
+  %t2 = fsub reassoc nsz float %f2, 3.000000e+00
+  %t3 = fadd reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc (the instructions are
+; canonicalized, but not folded).
+define float @fold10_reassoc(float %f1, float %f2) {
+; CHECK-LABEL: @fold10_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd reassoc float [[F1:%.*]], 2.000000e+00
+; CHECK-NEXT:    [[TMP2:%.*]] = fadd reassoc float [[F2:%.*]], -3.000000e+00
+; CHECK-NEXT:    [[TMP3:%.*]] = fadd reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t1 = fadd reassoc float 2.000000e+00, %f1
+  %t2 = fsub reassoc float %f2, 3.000000e+00
+  %t3 = fadd reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; This used to crash/miscompile.
 
 define float @fail1(float %f1, float %f2) {
 ; CHECK-LABEL: @fail1(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[F1:%.*]], 3.000000e+00
 ; CHECK-NEXT:    [[TMP2:%.*]] = fadd fast float [[TMP1]], -3.000000e+00
 ; CHECK-NEXT:    ret float [[TMP2]]
 ;

 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul fast float [[X:%.*]], 6.000000e+00
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %mul = fmul fast float %x, 7.000000e+00
   %sub = fsub fast float %mul, %x
   ret float %sub
 }
 
+; Check again using the minimal subset of FMF.
+define float @fold13_reassoc_nsz(float %x) {
+; CHECK-LABEL: @fold13_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc nsz float [[X:%.*]], 6.000000e+00
+; CHECK-NEXT:    ret float [[TMP1]]
+;
+  %mul = fmul reassoc nsz float %x, 7.000000e+00
+  %sub = fsub reassoc nsz float %mul, %x
+  ret float %sub
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fold13_reassoc(float %x) {
+; CHECK-LABEL: @fold13_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], 7.000000e+00
+; CHECK-NEXT:    [[TMP2:%.*]] = fsub reassoc float [[TMP1]], [[X]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %mul = fmul reassoc float %x, 7.000000e+00
+  %sub = fsub reassoc float %mul, %x
+  ret float %sub
+}
+
 ; -x + y => y - x
 define float @fold14(float %x, float %y) {
 ; CHECK-LABEL: @fold14(
 ; CHECK-NEXT:    [[ADD:%.*]] = fsub fast float [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %neg = fsub fast float -0.0, %x
   %add = fadd fast float %neg, %y
   ret float %add
 }
 
+; Check again using the minimal subset of FMF (reassoc is sufficient).
+define float @fold14_reassoc(float %x, float %y) {
+; CHECK-LABEL: @fold14_reassoc(
+; CHECK-NEXT:    [[ADD:%.*]] = fsub reassoc float [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT:    ret float [[ADD]]
+;
+  %neg = fsub reassoc float -0.0, %x
+  %add = fadd reassoc float %neg, %y
+  ret float %add
+}
+
 ; x + -y => x - y
 define float @fold15(float %x, float %y) {
 ; CHECK-LABEL: @fold15(
 ; CHECK-NEXT:    [[ADD:%.*]] = fsub fast float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[ADD]]
 ;
   %neg = fsub fast float -0.0, %y
   %add = fadd fast float %x, %neg
   ret float %add
 }
 
+; Check again using the minimal subset of FMF (reassoc is sufficient).
+define float @fold15_reassoc(float %x, float %y) {
+; CHECK-LABEL: @fold15_reassoc(
+; CHECK-NEXT:    [[ADD:%.*]] = fsub reassoc float [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret float [[ADD]]
+;
+  %neg = fsub reassoc float -0.0, %y
+  %add = fadd reassoc float %x, %neg
+  ret float %add
+}
+
 ; (select X+Y, X-Y) => X + (select Y, -Y)
 define float @fold16(float %x, float %y) {
 ; CHECK-LABEL: @fold16(
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast float -0.000000e+00, [[Y]]
 ; CHECK-NEXT:    [[R_P:%.*]] = select i1 [[CMP]], float [[Y]], float [[TMP1]]
 ; CHECK-NEXT:    [[R:%.*]] = fadd fast float [[R_P]], [[X]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %cmp = fcmp ogt float %x, %y
   %plus = fadd fast float %x, %y
   %minus = fsub fast float %x, %y
   %r = select i1 %cmp, float %plus, float %minus
   ret float %r
 }
 
+; Check again using the minimal subset of FMF (reassoc is sufficient).
+define float @fold16_reassoc(float %x, float %y) {
+; CHECK-LABEL: @fold16_reassoc(
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt float [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc float -0.000000e+00, [[Y]]
+; CHECK-NEXT:    [[R_P:%.*]] = select i1 [[CMP]], float [[Y]], float [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fadd reassoc float [[R_P]], [[X]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %cmp = fcmp ogt float %x, %y
+  %plus = fadd reassoc float %x, %y
+  %minus = fsub reassoc float %x, %y
+  %r = select i1 %cmp, float %plus, float %minus
+  ret float %r
+}
+
 ; =========================================================================
 ;
 ;   Testing-cases about negation
 ;
 ; =========================================================================
 define float @fneg1(float %f1, float %f2) {
 ; CHECK-LABEL: @fneg1(
 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[F1:%.*]], [[F2:%.*]]

 ; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %t1 = fmul fast float %x, %z
   %t2 = fmul fast float %y, %z
   %t3 = fadd fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fact_mul1_reassoc_nsz(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_mul1_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd reassoc nsz float [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc nsz float [[TMP1]], [[Z:%.*]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %t1 = fmul reassoc nsz float %x, %z
+  %t2 = fmul reassoc nsz float %y, %z
+  %t3 = fadd reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fact_mul1_reassoc(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_mul1_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], [[Z:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc float [[Y:%.*]] [[Z]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fadd reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t1 = fmul reassoc float %x, %z
+  %t2 = fmul reassoc float %y, %z
+  %t3 = fadd reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; z*x + y*z => (x+y) * z
 define float @fact_mul2(float %x, float %y, float %z) {
 ; CHECK-LABEL: @fact_mul2(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast float [[TMP1]], [[Z:%.*]]
 ; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %t1 = fmul fast float %z, %x
   %t2 = fmul fast float %y, %z
   %t3 = fsub fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fact_mul2_reassoc_nsz(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_mul2_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc nsz float [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc nsz float [[TMP1]], [[Z:%.*]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %t1 = fmul reassoc nsz float %z, %x
+  %t2 = fmul reassoc nsz float %y, %z
+  %t3 = fsub reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fact_mul2_reassoc(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_mul2_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[Z:%.*]], [[X:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc float [[Y:%.*]], [[Z]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fsub reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t1 = fmul reassoc float %z, %x
+  %t2 = fmul reassoc float %y, %z
+  %t3 = fsub reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; z*x - z*y => (x-y) * z
 define float @fact_mul3(float %x, float %y, float %z) {
 ; CHECK-LABEL: @fact_mul3(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast float [[TMP1]], [[Z:%.*]]
 ; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %t2 = fmul fast float %z, %y
   %t1 = fmul fast float %z, %x
   %t3 = fsub fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fact_mul3_reassoc_nsz(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_mul3_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc nsz float [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc nsz float [[TMP1]], [[Z:%.*]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %t2 = fmul reassoc nsz float %z, %y
+  %t1 = fmul reassoc nsz float %z, %x
+  %t3 = fsub reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fact_mul3_reassoc(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_mul3_reassoc(
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc float [[Z:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[Z]], [[X:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fsub reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t2 = fmul reassoc float %z, %y
+  %t1 = fmul reassoc float %z, %x
+  %t3 = fsub reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; x*z - z*y => (x-y) * z
 define float @fact_mul4(float %x, float %y, float %z) {
 ; CHECK-LABEL: @fact_mul4(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fmul fast float [[TMP1]], [[Z:%.*]]
 ; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %t1 = fmul fast float %x, %z
   %t2 = fmul fast float %z, %y
   %t3 = fsub fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fact_mul4_reassoc_nsz(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_mul4_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc nsz float [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc nsz float [[TMP1]], [[Z:%.*]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %t1 = fmul reassoc nsz float %x, %z
+  %t2 = fmul reassoc nsz float %z, %y
+  %t3 = fsub reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fact_mul4_reassoc(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_mul4_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], [[Z:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc float [[Z]], [[Y:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fsub reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t1 = fmul reassoc float %x, %z
+  %t2 = fmul reassoc float %z, %y
+  %t3 = fsub reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; x/y + x/z, no xform
 define float @fact_div1(float %x, float %y, float %z) {
 ; CHECK-LABEL: @fact_div1(
 ; CHECK-NEXT:    [[T1:%.*]] = fdiv fast float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[T2:%.*]] = fdiv fast float [[X]], [[Z:%.*]]
 ; CHECK-NEXT:    [[T3:%.*]] = fadd fast float [[T1]], [[T2]]
 ; CHECK-NEXT:    ret float [[T3]]
 ;

 ; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %t1 = fdiv fast float %y, %x
   %t2 = fdiv fast float %z, %x
   %t3 = fadd fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fact_div3_reassoc_nsz(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_div3_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd reassoc nsz float [[Y:%.*]], [[Z:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fdiv reassoc nsz float [[TMP1]], [[X:%.*]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %t1 = fdiv reassoc nsz float %y, %x
+  %t2 = fdiv reassoc nsz float %z, %x
+  %t3 = fadd reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fact_div3_reassoc(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_div3_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fdiv reassoc float [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fdiv reassoc float [[Z:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fadd reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t1 = fdiv reassoc float %y, %x
+  %t2 = fdiv reassoc float %z, %x
+  %t3 = fadd reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; y/x - z/x => (y-z)/x
 define float @fact_div4(float %x, float %y, float %z) {
 ; CHECK-LABEL: @fact_div4(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast float [[Y:%.*]], [[Z:%.*]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = fdiv fast float [[TMP1]], [[X:%.*]]
 ; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %t1 = fdiv fast float %y, %x
   %t2 = fdiv fast float %z, %x
   %t3 = fsub fast float %t1, %t2
   ret float %t3
 }
 
+; Check again using the minimal subset of FMF.
+define float @fact_div4_reassoc_nsz(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_div4_reassoc_nsz(
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc nsz float [[Y:%.*]], [[Z:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fdiv reassoc nsz float [[TMP1]], [[X:%.*]]
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %t1 = fdiv reassoc nsz float %y, %x
+  %t2 = fdiv reassoc nsz float %z, %x
+  %t3 = fsub reassoc nsz float %t1, %t2
+  ret float %t3
+}
+
+; Verify the fold is not done with only reassoc.
+define float @fact_div4_reassoc(float %x, float %y, float %z) {
+; CHECK-LABEL: @fact_div4_reassoc(
+; CHECK-NEXT:    [[TMP1:%.*]] = fdiv reassoc float [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fdiv reassoc float [[Z:%.*]], [[X]]
+; CHECK-NEXT:    [[TMP3:%.*]] = fsub reassoc float [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret float [[TMP3]]
+;
+  %t1 = fdiv reassoc float %y, %x
+  %t2 = fdiv reassoc float %z, %x
+  %t3 = fsub reassoc float %t1, %t2
+  ret float %t3
+}
+
 ; y/x - z/x => (y-z)/x is disabled if y-z is denormal.
 define float @fact_div5(float %x) {
 ; CHECK-LABEL: @fact_div5(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fdiv fast float 0x3818000000000000, [[X:%.*]]
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %t1 = fdiv fast float 0x3810000000000000, %x
   %t2 = fdiv fast float 0x3800000000000000, %x
delay:
   br label %final
 
 final:
   %A = phi float [ 2.0, %entry ], [ %a, %delay ]
   %value = fadd fast float %A, 1.0
   ret float %value
 }
 
+; Check again using the minimal subset of FMF (reassoc is sufficient).
+define float @test55_reassoc(i1 %which, float %a) {
+; CHECK-LABEL: @test55_reassoc(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
+; CHECK:       delay:
+; CHECK-NEXT:    [[PHITMP:%.*]] = fadd reassoc float [[A:%.*]], 1.000000e+00
+; CHECK-NEXT:    br label [[FINAL]]
+; CHECK:       final:
+; CHECK-NEXT:    [[A:%.*]] = phi float [ 3.000000e+00, [[ENTRY:%.*]] ], [ [[PHITMP]], [[DELAY]] ]
+; CHECK-NEXT:    ret float [[A]]
+;
+entry:
+  br i1 %which, label %final, label %delay
+
+delay:
+  br label %final
+
+final:
+  %A = phi float [ 2.0, %entry ], [ %a, %delay ]
+  %value = fadd reassoc float %A, 1.0
+  ret float %value
+}

test/Transforms/Reassociate/fast-MissedTree.ll

 ; RUN: opt < %s -reassociate -instcombine -S | FileCheck %s
 
 define float @test1(float %A, float %B) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[Z:%.*]] = fadd fast float %A, %B
 ; CHECK-NEXT:    ret float [[Z]]
 ;
   %W = fadd fast float %B, -5.0
   %Y = fadd fast float %A, 5.0
   %Z = fadd fast float %W, %Y
   ret float %Z
 }
 
 ; Check again using minimal subset of FMF.
 
-define float @test1_reassoc(float %A, float %B) {
-; CHECK-LABEL: @test1_reassoc(
-; CHECK-NEXT:    [[W:%.*]] = fadd reassoc float %B, -5.000000e+00
-; CHECK-NEXT:    [[Y:%.*]] = fadd reassoc float %A, 5.000000e+00
-; CHECK-NEXT:    [[Z:%.*]] = fadd reassoc float [[Y]], [[W]]
+define float @test1_minimal(float %A, float %B) {
+; CHECK-LABEL: @test1_minimal(
+; CHECK-NEXT:    [[Z:%.*]] = fadd reassoc nsz float %A, %B
 ; CHECK-NEXT:    ret float [[Z]]
 ;
-  %W = fadd reassoc float %B, -5.0
-  %Y = fadd reassoc float %A, 5.0
-  %Z = fadd reassoc float %W, %Y
+  %W = fadd reassoc nsz float %B, -5.0
+  %Y = fadd reassoc nsz float %A, 5.0
+  %Z = fadd reassoc nsz float %W, %Y
   ret float %Z
 }
 

test/Transforms/Reassociate/fast-SubReassociate.ll

;
   %X = fadd fast float %A, -7.000000e+00
   %Y = fsub fast float %X, %W
   %Z = fadd fast float %Y, 1.200000e+01
   ret float %Z
 }
 
 ; Check again using minimal subset of FMF.
 
-define float @test2_reassoc(float %A, float %B) {
-; CHECK-LABEL: @test2_reassoc(
-; CHECK-NEXT:    [[W:%.*]] = fadd reassoc float %B, 5.000000e+00
-; CHECK-NEXT:    [[X:%.*]] = fadd reassoc float %A, -7.000000e+00
-; CHECK-NEXT:    [[Y:%.*]] = fsub reassoc float [[X]], [[W]]
-; CHECK-NEXT:    [[Z:%.*]] = fadd reassoc float [[Y]], 1.200000e+01
+define float @test2_minimal(float %A, float %B) {
+; CHECK-LABEL: @test2_minimal(
+; CHECK-NEXT:    [[Z:%.*]] = fsub reassoc nsz float %A, %B
 ; CHECK-NEXT:    ret float [[Z]]
 ;
-  %W = fadd reassoc float %B, 5.000000e+00
-  %X = fadd reassoc float %A, -7.000000e+00
-  %Y = fsub reassoc float %X, %W
-  %Z = fadd reassoc float %Y, 1.200000e+01
+  %W = fadd reassoc nsz float %B, 5.000000e+00
+  %X = fadd reassoc nsz float %A, -7.000000e+00
+  %Y = fsub reassoc nsz float %X, %W
+  %Z = fadd reassoc nsz float %Y, 1.200000e+01
   ret float %Z
 }
 
 define float @test3(float %A, float %B, float %C, float %D) {
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT:    [[M:%.*]] = fadd float %A, 1.200000e+01
 ; CHECK-NEXT:    [[N:%.*]] = fadd float [[M]], %B
 ; CHECK-NEXT:    [[O:%.*]] = fadd float [[N]], %C

test/Transforms/Reassociate/fast-basictest.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -reassociate -gvn -instcombine -S | FileCheck %s
 
 ; With reassociation, constant folding can eliminate the 12 and -12 constants.
 define float @test1(float %arg) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[ARG_NEG:%.*]] = fsub fast float -0.000000e+00, [[ARG:%.*]]
 ; CHECK-NEXT:    ret float [[ARG_NEG]]
 ;
   %t1 = fsub fast float -1.200000e+01, %arg
   %t2 = fadd fast float %t1, 1.200000e+01
   ret float %t2
 }
 
-define float @test1_reassoc(float %arg) {
-; CHECK-LABEL: @test1_reassoc(
-; CHECK-NEXT:    [[T1:%.*]] = fsub reassoc float -1.200000e+01, [[ARG:%.*]]
-; CHECK-NEXT:    [[T2:%.*]] = fadd reassoc float [[T1]], 1.200000e+01
-; CHECK-NEXT:    ret float [[T2]]
+; Check again using the minimal subset of FMF.
+define float @test1_minimal(float %arg) {
+; CHECK-LABEL: @test1_minimal(
+; CHECK-NEXT:    [[ARG_NEG:%.*]] = fsub reassoc nsz float -0.000000e+00, [[ARG:%.*]]
+; CHECK-NEXT:    ret float [[ARG_NEG]]
 ;
-  %t1 = fsub reassoc float -1.200000e+01, %arg
-  %t2 = fadd reassoc float %t1, 1.200000e+01
+  %t1 = fsub reassoc nsz float -1.200000e+01, %arg
+  %t2 = fadd reassoc nsz float %t1, 1.200000e+01
   ret float %t2
 }
 
 define float @test2(float %reg109, float %reg1111) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    [[REG115:%.*]] = fadd float [[REG109:%.*]], -3.000000e+01
 ; CHECK-NEXT:    [[REG116:%.*]] = fadd float [[REG115]], [[REG1111:%.*]]
 ; CHECK-NEXT:    [[REG117:%.*]] = fadd float [[REG116]], 3.000000e+01

 ; CHECK-NEXT:    [[FACTOR:%.*]] = fmul fast float [[X:%.*]], 9.400000e+01
 ; CHECK-NEXT:    ret float [[FACTOR]]
 ;
   %Y = fmul fast float %X, 4.700000e+01
   %Z = fadd fast float %Y, %Y
   ret float %Z
 }
 
-define float @test9_reassoc(float %X) {
-; CHECK-LABEL: @test9_reassoc(
-; CHECK-NEXT:    [[Y:%.*]] = fmul reassoc float [[X:%.*]], 4.700000e+01
-; CHECK-NEXT:    [[Z:%.*]] = fadd reassoc float [[Y]], [[Y]]
-; CHECK-NEXT:    ret float [[Z]]
+; Check again using the minimal subset of FMF.
+define float @test9_minimal(float %X) {
+; CHECK-LABEL: @test9_minimal(
+; CHECK-NEXT:    [[FACTOR:%.*]] = fmul reassoc nsz float [[X:%.*]], 9.400000e+01
+; CHECK-NEXT:    ret float [[FACTOR]]
 ;
-  %Y = fmul reassoc float %X, 4.700000e+01
-  %Z = fadd reassoc float %Y, %Y
+  %Y = fmul reassoc nsz float %X, 4.700000e+01
+  %Z = fadd reassoc nsz float %Y, %Y
   ret float %Z
 }
 
 define float @test10(float %X) {
 ; CHECK-LABEL: @test10(
 ; CHECK-NEXT:    [[FACTOR:%.*]] = fmul fast float [[X:%.*]], 3.000000e+00
 ; CHECK-NEXT:    ret float [[FACTOR]]
 ;
   %Y = fadd fast float %X ,%X
   %Z = fadd fast float %Y, %X
   ret float %Z
 }
 
-define float @test10_reassoc(float %X) {
-; CHECK-LABEL: @test10_reassoc(
-; CHECK-NEXT:    [[Y:%.*]] = fadd reassoc float [[X:%.*]], [[X]]
-; CHECK-NEXT:    [[Z:%.*]] = fadd reassoc float [[Y]], [[X]]
-; CHECK-NEXT:    ret float [[Z]]
+; Check again using the minimal subset of FMF.
+define float @test10_minimal(float %X) {
+; CHECK-LABEL: @test10_minimal(
+; CHECK-NEXT:    [[FACTOR:%.*]] = fmul reassoc nsz float [[X:%.*]], 3.000000e+00
+; CHECK-NEXT:    ret float [[FACTOR]]
 ;
-  %Y = fadd reassoc float %X ,%X
-  %Z = fadd reassoc float %Y, %X
+  %Y = fadd reassoc nsz float %X ,%X
+  %Z = fadd reassoc nsz float %Y, %X
   ret float %Z
 }
 
 define float @test11(float %W) {
 ; CHECK-LABEL: @test11(
 ; CHECK-NEXT:    [[FACTOR:%.*]] = fmul fast float [[W:%.*]], 3.810000e+02
 ; CHECK-NEXT:    ret float [[FACTOR]]
 ;
   %X = fmul fast float %W, 127.0
   %Y = fadd fast float %X ,%X
   %Z = fadd fast float %Y, %X
   ret float %Z
 }
 
-define float @test11_reassoc(float %W) {
-; CHECK-LABEL: @test11_reassoc(
-; CHECK-NEXT:    [[X:%.*]] = fmul reassoc float [[W:%.*]], 1.270000e+02
-; CHECK-NEXT:    [[Y:%.*]] = fadd reassoc float [[X]], [[X]]
-; CHECK-NEXT:    [[Z:%.*]] = fadd reassoc float [[X]], [[Y]]
-; CHECK-NEXT:    ret float [[Z]]
+; Check again using the minimal subset of FMF.
+define float @test11_minimal(float %W) {
+; CHECK-LABEL: @test11_minimal(
+; CHECK-NEXT:    [[FACTOR:%.*]] = fmul reassoc nsz float [[W:%.*]], 3.810000e+02
+; CHECK-NEXT:    ret float [[FACTOR]]
 ;
-  %X = fmul reassoc float %W, 127.0
-  %Y = fadd reassoc float %X ,%X
-  %Z = fadd reassoc float %Y, %X
+  %X = fmul reassoc nsz float %W, 127.0
+  %Y = fadd reassoc nsz float %X ,%X
+  %Z = fadd reassoc nsz float %Y, %X
   ret float %Z
 }
 
 define float @test12(float %X) {
 ; CHECK-LABEL: @test12(
 ; CHECK-NEXT:    [[FACTOR:%.*]] = fmul fast float [[X:%.*]], -3.000000e+00
 ; CHECK-NEXT:    [[Z:%.*]] = fadd fast float [[FACTOR]], 6.000000e+00
 ; CHECK-NEXT:    ret float [[Z]]
 ;
   %A = fsub fast float 1.000000e+00, %X
   %B = fsub fast float 2.000000e+00, %X
   %C = fsub fast float 3.000000e+00, %X
   %Y = fadd fast float %A ,%B
   %Z = fadd fast float %Y, %C
   ret float %Z
 }
 
-define float @test12_reassoc(float %X) {
-; CHECK-LABEL: @test12_reassoc(
-; CHECK-NEXT:    [[A:%.*]] = fsub reassoc float 1.000000e+00, [[X:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = fsub reassoc float 2.000000e+00, [[X]]
-; CHECK-NEXT:    [[C:%.*]] = fsub reassoc float 3.000000e+00, [[X]]
-; CHECK-NEXT:    [[Y:%.*]] = fadd reassoc float [[A]], [[B]]
-; CHECK-NEXT:    [[Z:%.*]] = fadd reassoc float [[C]], [[Y]]
+; Check again using the minimal subset of FMF.
+define float @test12_minimal(float %X) {
+; CHECK-LABEL: @test12_minimal(
+; CHECK-NEXT:    [[FACTOR:%.*]] = fmul reassoc nsz float [[X:%.*]], 3.000000e+00
+; CHECK-NEXT:    [[Z:%.*]] = fsub reassoc nsz float 6.000000e+00, [[FACTOR]]
 ; CHECK-NEXT:    ret float [[Z]]
 ;
-  %A = fsub reassoc float 1.000000e+00, %X
-  %B = fsub reassoc float 2.000000e+00, %X
-  %C = fsub reassoc float 3.000000e+00, %X
-  %Y = fadd reassoc float %A ,%B
-  %Z = fadd reassoc float %Y, %C
+  %A = fsub reassoc nsz float 1.000000e+00, %X
+  %B = fsub reassoc nsz float 2.000000e+00, %X
+  %C = fsub reassoc nsz float 3.000000e+00, %X
+  %Y = fadd reassoc nsz float %A ,%B
+  %Z = fadd reassoc nsz float %Y, %C
   ret float %Z
 }
 
 define float @test13(float %X1, float %X2, float %X3) {
 ; CHECK-LABEL: @test13(
 ; CHECK-NEXT:    [[REASS_ADD:%.*]] = fsub fast float [[X3:%.*]], [[X2:%.*]]
 ; CHECK-NEXT:    [[REASS_MUL:%.*]] = fmul fast float [[REASS_ADD]], [[X1:%.*]]
 ; CHECK-NEXT:    ret float [[REASS_MUL]]

 ; CHECK-NEXT:    ret float [[TMP2]]
 ;
   %B = fmul fast float %X1, 47.   ; X1*47
   %C = fmul fast float %X2, -47.  ; X2*-47
   %D = fadd fast float %B, %C    ; X1*47 + X2*-47 -> 47*(X1-X2)
   ret float %D
 }
 
-define float @test14_reassoc(float %X1, float %X2) {
-; CHECK-LABEL: @test14_reassoc(
-; CHECK-NEXT:    [[B:%.*]] = fmul reassoc float [[X1:%.*]], 4.700000e+01
-; CHECK-NEXT:    [[C:%.*]] = fmul reassoc float [[X2:%.*]], 4.700000e+01
-; CHECK-NEXT:    [[D1:%.*]] = fsub reassoc float [[B]], [[C]]
-; CHECK-NEXT:    ret float [[D1]]
-;
-  %B = fmul reassoc float %X1, 47.   ; X1*47
-  %C = fmul reassoc float %X2, -47.  ; X2*-47
-  %D = fadd reassoc float %B, %C    ; X1*47 + X2*-47 -> 47*(X1-X2)
+; Check again using the minimal subset of FMF.
+define float @test14_minimal(float %X1, float %X2) {
+; CHECK-LABEL: @test14_minimal(
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub reassoc nsz float [[X1:%.*]], [[X2:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fmul reassoc nsz float [[TMP1]], 4.700000e+01
+; CHECK-NEXT:    ret float [[TMP2]]
+;
+  %B = fmul reassoc nsz float %X1, 47.   ; X1*47
+  %C = fmul reassoc nsz float %X2, -47.  ; X2*-47
+  %D = fadd reassoc nsz float %B, %C    ; X1*47 + X2*-47 -> 47*(X1-X2)
   ret float %D
 }
 
 define float @test15(float %arg) {
 ; CHECK-LABEL: @test15(
 ; CHECK-NEXT:    [[T2:%.*]] = fmul fast float [[ARG:%.*]], 1.440000e+02
 ; CHECK-NEXT:    ret float [[T2]]
 ;