[InstCombine] Simplify and correct folding fcmps with the same children

[timshen]

Summary

Take advantage of FCmpInst::Predicate's bit pattern and handle (fcmp *, x, y) | (fcmp *, x, y) and (fcmp *, x, y) & (fcmp *, x, y) more consistently. Also fold more FCmpInst::FCMP_FALSE and FCmpInst::FCMP_TRUE to constants.

Currently InstCombine wrongly folds (fcmp ogt, x, y) | (fcmp ord, x, y) to (fcmp ogt, x, y); this patch also fixes that.

[spatel]

This looks fantastic...if it's true. :)

So that's my problem: before we even get to this patch, we only have ~13 tests covering the 256 possible (16 * 16 predicates * 2 (and+or) / 2 for commutation) combinations of predicates.

Is there some clever way to get more coverage from those tests? If there's nothing obvious, we might as well just copy/paste the entire set into the existing regression test files. It's cheap. That way, we're certain that we're choosing the right predicate in all cases. The regression tests would then also serve as an unofficial assert that the enum values never change from their perfectly chosen values. IMO, an official assert and some loud comments in the code are warranted too.

Whether or not we agree that we should have the full regression test coverage, please note that there's a script to generate exact checks for regression tests:
$ utils/update_test_checks.py --help

This removes the need for CHECK-NOTs.

I've updated the old tests using that script in rL274046 and rL274047 .

[timshen]

If there's nothing obvious, we might as well just copy/paste the entire set into the existing regression test files.

I guess I missed a bit of context. Copy from where? By saying regression test files do you mean test/Transforms/InstCombine/and-fcmp.ll and test/Transforms/InstCombine/or-fcmp.ll?

Besides, auto-generate the CHECKs (assertions?) won't help with the LLVM code coverage, will it? If not, should we generate all 512 (regardless of the commutations) cases, since it's not that many? But then we have to test the generator... :P.

[spatel]

In D21775#469307, @timshen wrote:

If there's nothing obvious, we might as well just copy/paste the entire set into the existing regression test files.

I guess I missed a bit of context. Copy from where? By saying regression test files do you mean test/Transforms/InstCombine/and-fcmp.ll and test/Transforms/InstCombine/or-fcmp.ll?

Yes, the files under the 'test' dir are the regression tests:
http://llvm.org/docs/TestingGuide.html#llvm-testing-infrastructure-organization

Sorry, 'copy/paste' wasn't the best phrase. I just meant we should stamp out all N of the logical combinations of predicates. Right now, we don't really know what the existing behavior for each combination looks like.

Besides, auto-generate the CHECKs (assertions?) won't help with the LLVM code coverage, will it? If not, should we generate all 512 (regardless of the commutations) cases, since it's not that many? But then we have to test the generator... :P.

I don't understand what you mean by 'test the generator'?

Here's how I would proceed:

1. Create all N tests in the existing test files. I don't think there's much value in the commuted variants, so this would actually be N = 16*17 = 272 I think.
2. Run the script to generate the CHECK lines.
3. Commit these test changes to trunk.
4. Now, we know what predicates the existing code produces (hopefully there are no existing bugs).
5. Apply your code patch.
6. Regenerate the CHECK lines using the script.
7. Update the patch here with those diffs, so we can see any functional differences from your change in logic.

[timshen]

1. Create all N tests in the existing test files. I don't think there's much value in the commuted variants, so this would actually be N = 16*17 = 272 I think.
2. Run the script to generate the CHECK lines.
3. Commit these test changes to trunk.

I prefer not to commit this to the trunk, but only locally, since @t6 in or-fcmp.ll is testing an actual existing bug (sorry for not put that explicitly). It'd be weird to check-in something that is known wrong, and make them pass later.

How about I compare the auto-generated CHECKs and post the functional differences here in the comments, we inspect it, and then check-in the patch with all N tests (with correct CHECKs) together?

[timshen]

The functional change is here:
https://gist.github.com/timshen91/51b209c8d1be22ef96a1a9fd4131595d#file-fcmp-diff-diff

I verified the differences, and considered them valid. PTAL. Specifically, there are bug fixes from line 2586 to line 2643; others are just optimizations.

[timshen]

Updated the patch with all 272 tests.

[echristo]

Sounds good. Thanks for checking.

[timshen]

Updated comments, and move the changed (perfectly handled actually) solutions prior to other heuristics. The move catches two more optimizations, see a local diff:

diff --git a/test/Transforms/InstCombine/and-fcmp.ll b/test/Transforms/InstCombine/and-fcmp.ll
index 8ad6779..fa9e441 100644
--- a/test/Transforms/InstCombine/and-fcmp.ll
+++ b/test/Transforms/InstCombine/and-fcmp.ll
@@ -546,10 +546,8 @@ bb:
 define i1 @auto_gen_35(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_35(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP0:%.*]] = fcmp ord double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP0]]
 ;
 bb:
   %cmp = fcmp ord double %a, %b
diff --git a/test/Transforms/InstCombine/or-fcmp.ll b/test/Transforms/InstCombine/or-fcmp.ll
index f961cfa..9d743c7 100644
--- a/test/Transforms/InstCombine/or-fcmp.ll
+++ b/test/Transforms/InstCombine/or-fcmp.ll
@@ -1579,10 +1579,8 @@ bb:
 define i1 @auto_gen_119(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_119(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP0:%.*]] = fcmp uno double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP0]]
 ;
 bb:
   %cmp = fcmp uno double %a, %b

[spatel]

In D21775#469456, @timshen wrote:

1. Create all N tests in the existing test files. I don't think there's much value in the commuted variants, so this would actually be N = 16*17 = 272 I think.
2. Run the script to generate the CHECK lines.
3. Commit these test changes to trunk.

I prefer not to commit this to the trunk, but only locally, since @t6 in or-fcmp.ll is testing an actual existing bug (sorry for not put that explicitly). It'd be weird to check-in something that is known wrong, and make them pass later.

How about I compare the auto-generated CHECKs and post the functional differences here in the comments, we inspect it, and then check-in the patch with all N tests (with correct CHECKs) together?

I started looking over the diffs in the gist, but I'm going to suggest again that you check in the tests with current output as a preliminary step to this patch. IMO, the fact that we have miscompiles is more reason to do it that way. The advantages are:

1. There's a direct before/after comparison in the commit log of the functional changes from this patch.
2. Post-commit reviewers can easily parse those diffs inline in email.
3. It's also easier for us to review the test diffs here in Phab in one shot alongside the code changes.

There should be no concern about documenting buggy behavior in a regression test; I do this all the time. Then there's no guesswork about the old codegen. Just add "; FIXME: miscompile" or "; FIXME: missed fold" before tests that you know are misbehaving.

To substantially reduce the size of the patch: remove the "bb:" label from each test and the corresponding CHECK line. These are all single basic-block tests, so there's no value in those lines.

[timshen]

SGTM.

[spatel]

test/Transforms/InstCombine/and-fcmp.ll

17–18 ↗

(On Diff #62239)

As you noted, these renaming changes in the scripted output are caused because the script uses the variable names in the IR to create FileCheck variable names.

The reason the IR names change with your patch is because the old code would reuse existing instructions, for example:

if (Op0CC == FCmpInst::FCMP_TRUE)
  return RHS;

...but the new code always creates a new instruction. So the old checks show that the instruction has the same variable name as the original test case, but the new checks show a new temp name (%1).

For the sake of cleanliness (and I think Eric was suggesting the same thing), can you remove these diffs? This could be done by either checking in the NFC changes before this patch or removing these hunks from this patch.

[timshen]

Updated to rebase onto D21775

[timshen]

if (Op0CC == FCmpInst::FCMP_TRUE)

return RHS;

I see. I created D21855.

[spatel]

Some good boolean logic puzzles in these changes. :)
See inline comments for some nits, then LGTM.

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

46 ↗

(On Diff #62263)

Take the advantage -> Take advantage

49 ↗

(On Diff #62263)

I would remove the message parameter from all of these static_asserts to tighten it up. If someone tries to change these values, it should be obvious why we don't want that. On that note, can you add a comment to the definition of CmpInst::Predicate in IntsrTypes.h that says something like, "These enum values have the magical property of matching the logical and/or of the predicates. Any changes to these values will require changes to InstCombine."

96 ↗

(On Diff #62263)

...or a constant true/false value.

1125–1133 ↗

(On Diff #62263)

This comment and the similar one below didn't make anything clearer to me. I would leave it out, but that's just my suggestion.

[timshen]

Updated comments as suggested.

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

1125–1133 ↗

(On Diff #62263)

The boolean logic deduction is quite different though. :)

I removed the first duplicated paragraph in FoldOrOfFCmps.

llvm/trunk/include/llvm/IR/InstrTypes.h

 /// This class is the base class for the comparison instructions.
 /// @brief Abstract base class of comparison instructions.
 class CmpInst : public Instruction {
 public:
   /// This enumeration lists the possible predicates for CmpInst subclasses.
   /// Values in the range 0-31 are reserved for FCmpInst, while values in the
   /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
   /// predicate values are not overlapping between the classes.
+  ///
+  /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
+  /// FCMP_* values. Changing the bit patterns requires a potential change to
+  /// those passes.
   enum Predicate {
     // Opcode              U L G E    Intuitive operation
     FCMP_FALSE =  0,  ///< 0 0 0 0    Always false (always folded)
     FCMP_OEQ   =  1,  ///< 0 0 0 1    True if ordered and equal
     FCMP_OGT   =  2,  ///< 0 0 1 0    True if ordered and greater than
     FCMP_OGE   =  3,  ///< 0 0 1 1    True if ordered and greater than or equal
     FCMP_OLT   =  4,  ///< 0 1 0 0    True if ordered and less than
     FCMP_OLE   =  5,  ///< 0 1 0 1    True if ordered and less than or equal

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

static inline Value *dyn_castNotVal(Value *V) {
 
   // Constants can be considered to be not'ed values...
   if (ConstantInt *C = dyn_cast<ConstantInt>(V))
     return ConstantInt::get(C->getType(), ~C->getValue());
   return nullptr;
 }
 
 /// Similar to getICmpCode but for FCmpInst. This encodes a fcmp predicate into
-/// a three bit mask. It also returns whether it is an ordered predicate by
-/// reference.
-static unsigned getFCmpCode(FCmpInst::Predicate CC, bool &isOrdered) {
-  isOrdered = false;
-  switch (CC) {
-  case FCmpInst::FCMP_ORD: isOrdered = true; return 0;  // 000
-  case FCmpInst::FCMP_UNO:                   return 0;  // 000
-  case FCmpInst::FCMP_OGT: isOrdered = true; return 1;  // 001
-  case FCmpInst::FCMP_UGT:                   return 1;  // 001
-  case FCmpInst::FCMP_OEQ: isOrdered = true; return 2;  // 010
-  case FCmpInst::FCMP_UEQ:                   return 2;  // 010
-  case FCmpInst::FCMP_OGE: isOrdered = true; return 3;  // 011
-  case FCmpInst::FCMP_UGE:                   return 3;  // 011
-  case FCmpInst::FCMP_OLT: isOrdered = true; return 4;  // 100
-  case FCmpInst::FCMP_ULT:                   return 4;  // 100
-  case FCmpInst::FCMP_ONE: isOrdered = true; return 5;  // 101
-  case FCmpInst::FCMP_UNE:                   return 5;  // 101
-  case FCmpInst::FCMP_OLE: isOrdered = true; return 6;  // 110
-  case FCmpInst::FCMP_ULE:                   return 6;  // 110
-    // True -> 7
-  default:
-    // Not expecting FCMP_FALSE and FCMP_TRUE;
-    llvm_unreachable("Unexpected FCmp predicate!");
-  }
+/// a four bit mask.
+static unsigned getFCmpCode(FCmpInst::Predicate CC) {
+  assert(FCmpInst::FCMP_FALSE <= CC && CC <= FCmpInst::FCMP_TRUE &&
+         "Unexpected FCmp predicate!");
+  // Take advantage of the bit pattern of FCmpInst::Predicate here.
+  //                                                 U L G E
+  static_assert(FCmpInst::FCMP_FALSE ==  0, "");  // 0 0 0 0
+  static_assert(FCmpInst::FCMP_OEQ   ==  1, "");  // 0 0 0 1
+  static_assert(FCmpInst::FCMP_OGT   ==  2, "");  // 0 0 1 0
+  static_assert(FCmpInst::FCMP_OGE   ==  3, "");  // 0 0 1 1
+  static_assert(FCmpInst::FCMP_OLT   ==  4, "");  // 0 1 0 0
+  static_assert(FCmpInst::FCMP_OLE   ==  5, "");  // 0 1 0 1
+  static_assert(FCmpInst::FCMP_ONE   ==  6, "");  // 0 1 1 0
+  static_assert(FCmpInst::FCMP_ORD   ==  7, "");  // 0 1 1 1
+  static_assert(FCmpInst::FCMP_UNO   ==  8, "");  // 1 0 0 0
+  static_assert(FCmpInst::FCMP_UEQ   ==  9, "");  // 1 0 0 1
+  static_assert(FCmpInst::FCMP_UGT   == 10, "");  // 1 0 1 0
+  static_assert(FCmpInst::FCMP_UGE   == 11, "");  // 1 0 1 1
+  static_assert(FCmpInst::FCMP_ULT   == 12, "");  // 1 1 0 0
+  static_assert(FCmpInst::FCMP_ULE   == 13, "");  // 1 1 0 1
+  static_assert(FCmpInst::FCMP_UNE   == 14, "");  // 1 1 1 0
+  static_assert(FCmpInst::FCMP_TRUE  == 15, "");  // 1 1 1 1
+  return CC;
 }
 
 /// This is the complement of getICmpCode, which turns an opcode and two
 /// operands into either a constant true or false, or a brand new ICmp
 /// instruction. The sign is passed in to determine which kind of predicate to
 /// use in the new icmp instruction.
 static Value *getNewICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS,
                               InstCombiner::BuilderTy *Builder) {
   ICmpInst::Predicate NewPred;
   if (Value *NewConstant = getICmpValue(Sign, Code, LHS, RHS, NewPred))
     return NewConstant;
   return Builder->CreateICmp(NewPred, LHS, RHS);
 }
 
 /// This is the complement of getFCmpCode, which turns an opcode and two
-/// operands into either a FCmp instruction. isordered is passed in to determine
-/// which kind of predicate to use in the new fcmp instruction.
-static Value *getFCmpValue(bool isordered, unsigned code,
-                           Value *LHS, Value *RHS,
+/// operands into either a FCmp instruction, or a true/false constant.
+static Value *getFCmpValue(unsigned Code, Value *LHS, Value *RHS,
                            InstCombiner::BuilderTy *Builder) {
-  CmpInst::Predicate Pred;
-  switch (code) {
-  default: llvm_unreachable("Illegal FCmp code!");
-  case 0: Pred = isordered ? FCmpInst::FCMP_ORD : FCmpInst::FCMP_UNO; break;
-  case 1: Pred = isordered ? FCmpInst::FCMP_OGT : FCmpInst::FCMP_UGT; break;
-  case 2: Pred = isordered ? FCmpInst::FCMP_OEQ : FCmpInst::FCMP_UEQ; break;
-  case 3: Pred = isordered ? FCmpInst::FCMP_OGE : FCmpInst::FCMP_UGE; break;
-  case 4: Pred = isordered ? FCmpInst::FCMP_OLT : FCmpInst::FCMP_ULT; break;
-  case 5: Pred = isordered ? FCmpInst::FCMP_ONE : FCmpInst::FCMP_UNE; break;
-  case 6: Pred = isordered ? FCmpInst::FCMP_OLE : FCmpInst::FCMP_ULE; break;
-  case 7:
-    if (!isordered)
-      return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1);
-    Pred = FCmpInst::FCMP_ORD; break;
-  }
+  const auto Pred = static_cast<FCmpInst::Predicate>(Code);
+  assert(FCmpInst::FCMP_FALSE <= Pred && Pred <= FCmpInst::FCMP_TRUE &&
+         "Unexpected FCmp predicate!");
+  if (Pred == FCmpInst::FCMP_FALSE)
+    return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
+  if (Pred == FCmpInst::FCMP_TRUE)
   return Builder->CreateFCmp(Pred, LHS, RHS);
 }
 
 /// \brief Transform BITWISE_OP(BSWAP(A),BSWAP(B)) to BSWAP(BITWISE_OP(A, B))
 /// \param I Binary operator to transform.
 /// \return Pointer to node that must replace the original binary operator, or
 ///         null pointer if no transformation was made.
 Value *InstCombiner::SimplifyBSwap(BinaryOperator &I) {
Value *InstCombiner::FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS) {
   }
 
   return nullptr;
 }
 
 /// Optimize (fcmp)&(fcmp).  NOTE: Unlike the rest of instcombine, this returns
 /// a Value which should already be inserted into the function.
 Value *InstCombiner::FoldAndOfFCmps(FCmpInst *LHS, FCmpInst *RHS) {
+  Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1);
+  Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1);
+  FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate();
+
+  if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) {
+    // Swap RHS operands to match LHS.
+    Op1CC = FCmpInst::getSwappedPredicate(Op1CC);
+    std::swap(Op1LHS, Op1RHS);
+  }
+
+  // Simplify (fcmp cc0 x, y) & (fcmp cc1 x, y).
+  // Suppose the relation between x and y is R, where R is one of
+  // U(1000), L(0100), G(0010) or E(0001), and CC0 and CC1 are the bitmasks for
+  // testing the desired relations.
+  //
+  // Since (R & CC0) and (R & CC1) are either R or 0, we actually have this:
+  //    bool(R & CC0) && bool(R & CC1)
+  //  = bool((R & CC0) & (R & CC1))
+  //  = bool(R & (CC0 & CC1)) <= by re-association, commutation, and idempotency
+  if (Op0LHS == Op1LHS && Op0RHS == Op1RHS)
+    return getFCmpValue(getFCmpCode(Op0CC) & getFCmpCode(Op1CC), Op0LHS, Op0RHS,
+                        Builder);
+
   if (LHS->getPredicate() == FCmpInst::FCMP_ORD &&
       RHS->getPredicate() == FCmpInst::FCMP_ORD) {
     if (LHS->getOperand(0)->getType() != RHS->getOperand(0)->getType())
       return nullptr;
 
     // (fcmp ord x, c) & (fcmp ord y, c)  -> (fcmp ord x, y)
     if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1)))
       if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) {
         // If either of the constants are nans, then the whole thing returns
         // false.
         if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN())
           return Builder->getFalse();
         return Builder->CreateFCmpORD(LHS->getOperand(0), RHS->getOperand(0));
       }
 
     // Handle vector zeros.  This occurs because the canonical form of
     // "fcmp ord x,x" is "fcmp ord x, 0".
     if (isa<ConstantAggregateZero>(LHS->getOperand(1)) &&
         isa<ConstantAggregateZero>(RHS->getOperand(1)))
       return Builder->CreateFCmpORD(LHS->getOperand(0), RHS->getOperand(0));
     return nullptr;
   }
 
-  Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1);
-  Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1);
-  FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate();
-
-
-  if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) {
-    // Swap RHS operands to match LHS.
-    Op1CC = FCmpInst::getSwappedPredicate(Op1CC);
-    std::swap(Op1LHS, Op1RHS);
-  }
-
-  if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) {
-    // Simplify (fcmp cc0 x, y) & (fcmp cc1 x, y).
-    if (Op0CC == Op1CC)
-      return Builder->CreateFCmp((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS);
-    if (Op0CC == FCmpInst::FCMP_FALSE || Op1CC == FCmpInst::FCMP_FALSE)
-      return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
-    if (Op0CC == FCmpInst::FCMP_TRUE)
-      return Builder->CreateFCmp(Op1CC, Op0LHS, Op0RHS);
-    if (Op1CC == FCmpInst::FCMP_TRUE)
-      return Builder->CreateFCmp(Op0CC, Op0LHS, Op0RHS);
-
-    bool Op0Ordered;
-    bool Op1Ordered;
-    unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered);
-    unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered);
-    // uno && ord -> false
-    if (Op0Pred == 0 && Op1Pred == 0 && Op0Ordered != Op1Ordered)
-        return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
-    if (Op1Pred == 0) {
-      std::swap(LHS, RHS);
-      std::swap(Op0Pred, Op1Pred);
-      std::swap(Op0Ordered, Op1Ordered);
-    }
-    if (Op0Pred == 0) {
-      // uno && ueq -> uno && (uno || eq) -> uno
-      // ord && olt -> ord && (ord && lt) -> olt
-      if (!Op0Ordered && (Op0Ordered == Op1Ordered))
-        return Builder->CreateFCmp(Op0CC, Op0LHS, Op0RHS);
-      if (Op0Ordered && (Op0Ordered == Op1Ordered))
-        return Builder->CreateFCmp(Op1CC, Op0LHS, Op0RHS);
-
-      // uno && oeq -> uno && (ord && eq) -> false
-      if (!Op0Ordered)
-        return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
-      // ord && ueq -> ord && (uno || eq) -> oeq
-      return getFCmpValue(true, Op1Pred, Op0LHS, Op0RHS, Builder);
-    }
-  }
-
   return nullptr;
 }
 
 /// Match De Morgan's Laws:
 /// (~A & ~B) == (~(A | B))
 /// (~A | ~B) == (~(A & B))
 static Instruction *matchDeMorgansLaws(BinaryOperator &I,
                                        InstCombiner::BuilderTy *Builder) {
case ICmpInst::ICMP_SGT:
     break;
   }
   return nullptr;
 }
 
 /// Optimize (fcmp)|(fcmp).  NOTE: Unlike the rest of instcombine, this returns
 /// a Value which should already be inserted into the function.
 Value *InstCombiner::FoldOrOfFCmps(FCmpInst *LHS, FCmpInst *RHS) {
+  Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1);
+  Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1);
+  FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate();
+
+  if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) {
+    // Swap RHS operands to match LHS.
+    Op1CC = FCmpInst::getSwappedPredicate(Op1CC);
+    std::swap(Op1LHS, Op1RHS);
+  }
+
+  // Simplify (fcmp cc0 x, y) | (fcmp cc1 x, y).
+  // This is a similar transformation to the one in FoldAndOfFCmps.
+  //
+  // Since (R & CC0) and (R & CC1) are either R or 0, we actually have this:
+  //    bool(R & CC0) || bool(R & CC1)
+  //  = bool((R & CC0) | (R & CC1))
+  //  = bool(R & (CC0 | CC1)) <= by reversed distribution (contribution? ;)
+  if (Op0LHS == Op1LHS && Op0RHS == Op1RHS)
+    return getFCmpValue(getFCmpCode(Op0CC) | getFCmpCode(Op1CC), Op0LHS, Op0RHS,
+                        Builder);
+
   if (LHS->getPredicate() == FCmpInst::FCMP_UNO &&
       RHS->getPredicate() == FCmpInst::FCMP_UNO &&
       LHS->getOperand(0)->getType() == RHS->getOperand(0)->getType()) {
     if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1)))
       if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) {
         // If either of the constants are nans, then the whole thing returns
         // true.
         if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN())
           return Builder->getTrue();
 
         // Otherwise, no need to compare the two constants, compare the
         // rest.
         return Builder->CreateFCmpUNO(LHS->getOperand(0), RHS->getOperand(0));
       }
 
     // Handle vector zeros.  This occurs because the canonical form of
     // "fcmp uno x,x" is "fcmp uno x, 0".
     if (isa<ConstantAggregateZero>(LHS->getOperand(1)) &&
         isa<ConstantAggregateZero>(RHS->getOperand(1)))
       return Builder->CreateFCmpUNO(LHS->getOperand(0), RHS->getOperand(0));
 
     return nullptr;
   }
 
-  Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1);
-  Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1);
-  FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate();
-
-  if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) {
-    // Swap RHS operands to match LHS.
-    Op1CC = FCmpInst::getSwappedPredicate(Op1CC);
-    std::swap(Op1LHS, Op1RHS);
-  }
-  if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) {
-    // Simplify (fcmp cc0 x, y) | (fcmp cc1 x, y).
-    if (Op0CC == Op1CC)
-      return Builder->CreateFCmp((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS);
-    if (Op0CC == FCmpInst::FCMP_TRUE || Op1CC == FCmpInst::FCMP_TRUE)
-      return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1);
-    if (Op0CC == FCmpInst::FCMP_FALSE)
-      return Builder->CreateFCmp(Op1CC, Op0LHS, Op0RHS);
-    if (Op1CC == FCmpInst::FCMP_FALSE)
-      return Builder->CreateFCmp(Op0CC, Op0LHS, Op0RHS);
-    bool Op0Ordered;
-    bool Op1Ordered;
-    unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered);
-    unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered);
-    if (Op0Ordered == Op1Ordered) {
-      // If both are ordered or unordered, return a new fcmp with
-      // or'ed predicates.
-      return getFCmpValue(Op0Ordered, Op0Pred|Op1Pred, Op0LHS, Op0RHS, Builder);
-    }
-  }
   return nullptr;
 }
 
 /// This helper function folds:
 ///
 ///     ((A | B) & C1) | (B & C2)
 ///
 /// into:

llvm/trunk/test/Transforms/InstCombine/and-fcmp.ll

;
   %cmp = fcmp ogt double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_4(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_4(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ogt double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_5(double %a, double %b) {
;
   %cmp = fcmp oge double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_7(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_7(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp oge double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_8(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_8(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp oge double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_9(double %a, double %b) {
;
   %cmp = fcmp olt double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_11(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_11(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp olt double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_12(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_12(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp olt double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_13(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_13(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp olt double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_14(double %a, double %b) {
;
   %cmp = fcmp ole double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_16(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_16(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ole double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_17(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_17(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ole double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_18(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_18(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ole double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_19(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_19(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ole double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_20(double %a, double %b) {
;
   %cmp = fcmp one double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_22(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_22(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp one double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_23(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_23(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp one double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_24(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_24(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp one double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_25(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_25(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp one double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_26(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_26(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp one double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_27(double %a, double %b) {
;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_35(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_35(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ord double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_36(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_36(
 ; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_37(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_37(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_38(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_38(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_39(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_39(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_40(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_40(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_41(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_41(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_42(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_42(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_43(double %a, double %b) {
;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_46(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_46(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_47(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_47(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_48(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_48(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_49(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_49(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_50(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_50(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_51(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_51(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_52(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_52(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_53(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_53(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uno double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp ueq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_54(double %a, double %b) {
;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_56(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_56(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_57(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_57(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_58(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_58(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_59(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_59(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_60(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_60(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_61(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_61(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_62(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_62(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oge double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_63(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_63(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ueq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp ueq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_64(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_64(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ugt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp ugt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_65(double %a, double %b) {
;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_67(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_67(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_68(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_68(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_69(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_69(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_70(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_70(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_71(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_71(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_72(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_72(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_73(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_73(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_74(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_74(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uno double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp ueq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_75(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_75(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uno double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp ugt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_76(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_76(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uno double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp uge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_77(double %a, double %b) {
;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_79(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_79(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_80(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_80(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_81(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_81(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_82(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_82(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_83(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_83(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ole double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_84(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_84(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_85(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_85(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ole double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_86(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_86(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ueq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ueq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_87(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_87(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uno double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ugt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_88(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_88(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ueq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp uge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_89(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_89(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ult double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ult double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_90(double %a, double %b) {
;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_92(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_92(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 false
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_93(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_93(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_94(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_94(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_95(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_95(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_96(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_96(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_97(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_97(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp one double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_98(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_98(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fcmp one double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_99(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_99(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uno double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ueq double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_100(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_100(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ugt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ugt double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_101(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_101(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ugt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp uge double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_102(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_102(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ult double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ult double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_103(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_103(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = and i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ult double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ule double %a, %b
   %retval = and i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_104(double %a, double %b) {

llvm/trunk/test/Transforms/InstCombine/or-fcmp.ll

 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
-; FIXME: this test, along with the several following ones,
-;        is wrong and will be fixed shortly.
 define i1 @auto_gen_29(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_29(
-; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oeq double %a, %b
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ord double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_30(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_30(
-; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ogt double %a, %b
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ord double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_31(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_31(
-; CHECK-NEXT:    [[TMP1:%.*]] = fcmp oge double %a, %b
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ord double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_32(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_32(
-; CHECK-NEXT:    [[TMP1:%.*]] = fcmp olt double %a, %b
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ord double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_33(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_33(
-; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ole double %a, %b
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ord double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_34(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_34(
-; CHECK-NEXT:    [[TMP1:%.*]] = fcmp one double %a, %b
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ord double %a, %b
 ; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ord double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_37(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_37(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ueq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_38(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_38(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_39(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_39(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_40(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_40(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ule double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_41(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_41(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ule double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_42(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_42(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_43(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_43(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ueq double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_44(double %a, double %b) {
;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_46(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_46(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_47(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_47(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ugt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_48(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_48(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_49(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_49(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp une double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_50(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_50(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_51(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_51(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp une double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_52(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_52(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ugt double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ugt double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_53(double %a, double %b) {
;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_56(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_56(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_57(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_57(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_58(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_58(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_59(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_59(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_60(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_60(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_61(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_61(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_62(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_62(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uge double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp uge double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_63(double %a, double %b) {
;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_67(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_67(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ule double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_68(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_68(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp une double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_69(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_69(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_70(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_70(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ult double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_71(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_71(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ule double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_72(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_72(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp une double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_73(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_73(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ult double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ult double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_74(double %a, double %b) {
;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_79(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_79(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ule double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_80(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_80(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_81(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_81(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_82(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_82(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ule double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_83(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_83(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ule double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_84(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_84(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_85(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_85(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp ule double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp ule double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_86(double %a, double %b) {
;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_92(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_92(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_93(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_93(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp une double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_94(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_94(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_95(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_95(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp une double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_96(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_96(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_97(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_97(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp une double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_98(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_98(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp une double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp une double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_99(double %a, double %b) {
;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp false double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_106(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_106(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oeq double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ueq double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp oeq double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_107(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_107(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ogt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ugt double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp ogt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_108(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_108(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp oge double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uge double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp oge double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_109(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_109(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp olt double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ult double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp olt double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_110(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_110(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ole double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp ule double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp ole double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_111(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_111(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp one double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp une double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp one double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_112(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_112(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp ord double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    ret i1 true
 ;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp ord double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_113(double %a, double %b) {
;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp une double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_119(double %a, double %b) {
 ; CHECK-LABEL: @auto_gen_119(
-; CHECK-NEXT:    [[CMP:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[CMP1:%.*]] = fcmp uno double %a, %b
-; CHECK-NEXT:    [[RETVAL:%.*]] = or i1 [[CMP]], [[CMP1]]
-; CHECK-NEXT:    ret i1 [[RETVAL]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fcmp uno double %a, %b
+; CHECK-NEXT:    ret i1 [[TMP1]]
 ;
   %cmp = fcmp uno double %a, %b
   %cmp1 = fcmp uno double %a, %b
   %retval = or i1 %cmp, %cmp1
   ret i1 %retval
 }
 
 define i1 @auto_gen_120(double %a, double %b) {