[EarlyCSE] Avoid a poorly defined instruction comparison

[jmorse]

Summary

EarlyCSE currently attempts to eliminate equivalent comparisons like this:

fcmp ugt %a, %b
fcmp ult %b, %a

where the operands are swapped, by using getSwappedPredicate() to find what the equivalent predicate would be. However, it does not take account of comparisons between identical operands, like "fcmp ugt %a, %a". For identical operands getSwappedPredicate() is poorly defined as there is no other predicate that computes the same result. The net effect is that some instruction pairs hash differently, but compare equally, using hasher DenseMapInfo<SimpleValue>::getHashValue and equality DenseMapInfo<SimpleValue>::isEqual. For example:

fcmp ugt %a, %a
fcmp ult %a, %a

have different predicates as inputs to the hash, but then compare equal because one of the predicates gets flipped in the equality function.

DenseMap doesn't expect inconsistent hash/equality, which has tripped assertion failures in online fuzzers [0] as least once. However because EarlyCSE (legitimately) uses pointer values in its hash, that doesn't happen often, instead it usually causes nondeterministic behaviour. Running the test in this patch results in a different output to the auto-generated one about 50% of the time on Ubuntu 18.04 and LLVM compiled with clang / libstdc++.

The functional change in this patch filters out the edge case of identical operands. The regression test reproduces the problem with reasonable frequency, however it's not clear how useful it is in general: because the broken behaviour depends on pointer values, it's hard to test.

[0] https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=7892

[reames]

lib/Transforms/Scalar/EarlyCSE.cpp

266

If I'm reading this correctly, the problem only exists for fcmps not icmps right? If so, please restrict the early return to fcmps.

[• dberlin]

So, IMHO, the swapping should not be *determined* as part of the equality function, and that is your underlying problem.
This feels like a workaround instead of fixing that problem.

If you look at GVN and NewGVN, they take care of this the same way - the commutativeness/etc is taken care of by canonicalizing the expression prior to putting it in the hashtable.
The hashtable hashes and does equality based only on the contents of that structure as it exists in the table (IE they don't run around swapping operands in equality).

Admittedly, they have a different expression structure than EarlyCSE which makes this easier.

A couple paths forward i could see:

1. Determine what should be swapped or not swapped outside of hashing and equality functions, even if the equality function does the swapping.

IE add a flag to SimpleValue stating whether operands/predicate should be swapped, and that flag is set in the constructor.
Both hashing and equality do what that flag says prior to hashing/comparing.
Then you can make actual decisions about canonicalization outside of hashing and equality, even if hashing and equality have to do a little of the work.

This is kind of ugly but IMHO, still better than what we're doing now.

2. Create a CmpValue structure that works similar to how GVN/NewGVN (IE actually contains the operands and predicate).

All swapping/etc is taken care of by the things creating these structures, and hashing/equality of CmpValue is simply hashing of operands+predicate and equality comparison of structure members.

[jmorse]

Hi, Thanks all for reviewing,

So, IMHO, the swapping should not be *determined* as part of the equality function, and that is your underlying problem.
This feels like a workaround instead of fixing that problem.

True, the patch only fixes a symptom,

A couple paths forward i could see: [...]

I've taken a shot at the second option, which seems cleaner and reduces a reasonable amount of code duplication -- see updated patch. The downside is the more invasive patch, additional memory usage, and as I'm an LLVM newbie a risk that I've missed something (although the tests all pass on x86 Ubuntu 18.04).

Describing the logic of the revised patch:

• The opcode, main operands and flags get localised into SimpleValue
• During construction, the three replicated canonicalisations from the existing hash/equality functions are performed:
  • Commutative binary operations are ordered
  • Comparison operand swapping (the motivation for this patch)
  • Select pattern detection and operand ordering
• During hashing, the potentially canonicalised information is hashed in from the local storage (plus some non-canonicalised material for other instructions)
• Similarly for equality, if the instructions aren't already identical, we only examine the canonicalised local information

Which I think achieves the main aim: ensuring ordering decisions are only performed in one place (now the SimpleValue constructor). There's good coverage of these canonicalisation steps in test/Transforms/EarlyCSE/commute.ll.

[• dberlin]

Thanks.
This makes me wonder if there should be a real class hierarchy here, but i think this is something we can worry about in the future because it will be a larger change.

[jmorse]

Rebase on top of r332865:

https://reviews.llvm.org/rL332865

matchSelectPattern now canonicalises operand order itself: for this patch lines 168-173 take that into account by not trying to order them. Equality and hashing functions are unchanged (which is desirable), tests pass.

Also pseudo-ping: it's not clear to me whether one LGTM overrides another persons earlier needs-review, but the phab interface seems to think so. (My phab-foo is new).

[jmorse]

Ping, partially for rebase, mostly because the phab-workflow is unclear to me (see immediately previous comment).

[jmorse]

Add review response which (I think) clears up some confusion.

Note that dberlin replied to my procedure-ping above, but the message seemed to get attached to https://reviews.llvm.org/rL332865 (presumably a case of mistaken identity).

lib/Transforms/Scalar/EarlyCSE.cpp

266

Hmm, I think here you're referring to the fact that fcmps can have an "unordered" result if one operand is a NaN, is that right?

If so, I think this is based on some legitimate confusion: the "poorly defined comparison" I'm referring to in this patch is the call to getSwappedPredicate() which doesn't have a well defined result if both operands are the same; wheras I see now that you might read the review message as referring to "poorly defined comparisons" in the LLVM IR being processed, which isn't the case.

I didn't notice that that phrase could equally apply to both things, curses. If I've barked up the wrong tree here though, please do elaborate.

[jmorse]

ping @reames , does the inline comment clear up the question?

[jmorse]

piny

[reames]

Removing self from old stale review.

[jmorse]

Abandoning an ancient patch; EarlyCSE has been substantially refactored since then, in D62644

lib/Transforms/Scalar/EarlyCSE.cpp

 //===----------------------------------------------------------------------===//
 
 namespace {
 
 /// Struct representing the available values in the scoped hash table.
 struct SimpleValue {
   Instruction *Inst;
 
-  SimpleValue(Instruction *I) : Inst(I) {
-    assert((isSentinel() || canHandle(I)) && "Inst can't be handled!");
-  }
+  unsigned CmpOpcode;
+  Value *CmpOp1, *CmpOp2;
+  union {
+    CmpInst::Predicate Pred;
+    SelectPatternFlavor SPF;
+  } CmpU;
+  bool isMatchSelect;
+
+  SimpleValue(Instruction *I);
+
+  unsigned getHashValue() const;
+  bool isEqual(const SimpleValue &Other) const;
 
   bool isSentinel() const {
     return Inst == DenseMapInfo<Instruction *>::getEmptyKey() ||
            Inst == DenseMapInfo<Instruction *>::getTombstoneKey();
   }
 
   static bool canHandle(Instruction *Inst) {
     // This can only handle non-void readnone functions.
     if (CallInst *CI = dyn_cast<CallInst>(Inst))
       return CI->doesNotAccessMemory() && !CI->getType()->isVoidTy();
     return isa<CastInst>(Inst) || isa<BinaryOperator>(Inst) ||
            isa<GetElementPtrInst>(Inst) || isa<CmpInst>(Inst) ||
            isa<SelectInst>(Inst) || isa<ExtractElementInst>(Inst) ||
            isa<InsertElementInst>(Inst) || isa<ShuffleVectorInst>(Inst) ||
            isa<ExtractValueInst>(Inst) || isa<InsertValueInst>(Inst);
   }
 };
 
 } // end anonymous namespace
 
-namespace llvm {
-
-template <> struct DenseMapInfo<SimpleValue> {
-  static inline SimpleValue getEmptyKey() {
-    return DenseMapInfo<Instruction *>::getEmptyKey();
-  }
-
-  static inline SimpleValue getTombstoneKey() {
-    return DenseMapInfo<Instruction *>::getTombstoneKey();
-  }
+SimpleValue::SimpleValue(Instruction *I) : Inst(I) {
+  assert((isSentinel() || canHandle(I)) && "Inst can't be handled!");
 
-  static unsigned getHashValue(SimpleValue Val);
-  static bool isEqual(SimpleValue LHS, SimpleValue RHS);
-};
+  if (isSentinel())
+    return;
 
-} // end namespace llvm
+ // Set compare fields to default values.
+  CmpOpcode = I->getOpcode();
+  CmpOp1 = nullptr;
+  CmpOp2 = nullptr;
+  CmpU.Pred = CmpInst::FCMP_FALSE;
+  isMatchSelect = false;
 
-unsigned DenseMapInfo<SimpleValue>::getHashValue(SimpleValue Val) {
-  Instruction *Inst = Val.Inst;
-  // Hash in all of the operands as pointers.
-  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Inst)) {
-    Value *LHS = BinOp->getOperand(0);
-    Value *RHS = BinOp->getOperand(1);
-    if (BinOp->isCommutative() && BinOp->getOperand(0) > BinOp->getOperand(1))
-      std::swap(LHS, RHS);
-
-    return hash_combine(BinOp->getOpcode(), LHS, RHS);
-  }
-
-  if (CmpInst *CI = dyn_cast<CmpInst>(Inst)) {
-    Value *LHS = CI->getOperand(0);
-    Value *RHS = CI->getOperand(1);
-    CmpInst::Predicate Pred = CI->getPredicate();
-    if (Inst->getOperand(0) > Inst->getOperand(1)) {
-      std::swap(LHS, RHS);
-      Pred = CI->getSwappedPredicate();
-    }
-    return hash_combine(Inst->getOpcode(), Pred, LHS, RHS);
-  }
-
-  // Hash min/max/abs (cmp + select) to allow for commuted operands.
-  // Min/max may also have non-canonical compare predicate (eg, the compare for
-  // smin may use 'sgt' rather than 'slt'), and non-canonical operands in the
-  // compare.
+  // Potentially canonicalise commutative operations, comparisons and
+  // select patterns.
+  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Inst))  {
+    CmpOp1 = BinOp->getOperand(0);
+    CmpOp2 = BinOp->getOperand(1);
+    if (BinOp->isCommutative() && CmpOp1 > CmpOp2)
+      std::swap(CmpOp1, CmpOp2);
+  } else if (CmpInst *CI = dyn_cast<CmpInst>(Inst)) {
+    CmpOp1 = CI->getOperand(0);
+    CmpOp2 = CI->getOperand(1);
+    CmpU.Pred = CI->getPredicate();
+    if (CmpOp1 > CmpOp2) {
+      std::swap(CmpOp1, CmpOp2);
+      CmpU.Pred = CI->getSwappedPredicate();
+    }
+  } else if (CastInst *CI = dyn_cast<CastInst>(Inst)) {
+    CmpOp1 = CI->getOperand(0);
+  } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Inst)) {
+    CmpOp1 = EVI->getOperand(0);
+    // Indicies not stored locally.
+  } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(Inst)) {
+    CmpOp1 = IVI->getOperand(0);
+    CmpOp2 = IVI->getOperand(1);
+    // Indicies not stored locally.
+  } else {
     Value *A, *B;
     SelectPatternFlavor SPF = matchSelectPattern(Inst, A, B).Flavor;
     // TODO: We should also detect FP min/max.
     if (SPF == SPF_SMIN || SPF == SPF_SMAX ||
         SPF == SPF_UMIN || SPF == SPF_UMAX) {
-    if (A > B)
-      std::swap(A, B);
-    return hash_combine(Inst->getOpcode(), SPF, A, B);
-  }
-  if (SPF == SPF_ABS || SPF == SPF_NABS) {
-    // ABS/NABS always puts the input in A and its negation in B.
-    return hash_combine(Inst->getOpcode(), SPF, A, B);
-  }
-
-  if (CastInst *CI = dyn_cast<CastInst>(Inst))
-    return hash_combine(CI->getOpcode(), CI->getType(), CI->getOperand(0));
-
-  if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Inst))
-    return hash_combine(EVI->getOpcode(), EVI->getOperand(0),
-                        hash_combine_range(EVI->idx_begin(), EVI->idx_end()));
-
-  if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(Inst))
-    return hash_combine(IVI->getOpcode(), IVI->getOperand(0),
-                        IVI->getOperand(1),
-                        hash_combine_range(IVI->idx_begin(), IVI->idx_end()));
-
+      isMatchSelect = true;
+      CmpU.SPF = SPF;
+      CmpOp1 = A;
+      CmpOp2 = B;
+      if (CmpOp1 > CmpOp2)
+        std::swap(CmpOp1, CmpOp2);
+    } else if (SPF == SPF_ABS || SPF == SPF_NABS) {
+      // SPF cannonicalises order of ABS/NABS operands itself
+      isMatchSelect = true;
+      CmpU.SPF = SPF;
+      CmpOp1 = A;
+      CmpOp2 = B;
+    } else {
       assert((isa<CallInst>(Inst) || isa<BinaryOperator>(Inst) ||
               isa<GetElementPtrInst>(Inst) || isa<SelectInst>(Inst) ||
               isa<ExtractElementInst>(Inst) || isa<InsertElementInst>(Inst) ||
               isa<ShuffleVectorInst>(Inst)) &&
              "Invalid/unknown instruction");
+    }
+  }
+}
 
-  // Mix in the opcode.
-  return hash_combine(
-      Inst->getOpcode(),
+unsigned
+SimpleValue::getHashValue() const {
+  // First hash in localised and canonicalised data.
+  unsigned Hash = hash_combine(CmpOpcode, CmpOp1, CmpOp2, isMatchSelect);
+
+  // Potentially hash in additional canonical or extra operand data.
+  if (BinaryOperator *LHSBinOp = dyn_cast<BinaryOperator>(Inst)) {
+    ;
+  } else if (CmpInst *CI = dyn_cast<CmpInst>(Inst)) {
+    Hash = hash_combine(Hash, CmpU.Pred);
+  } else if (CastInst *CI = dyn_cast<CastInst>(Inst)) {
+    Hash = hash_combine(Hash, CI->getType());
+  } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Inst)) {
+    Hash = hash_combine(Hash,
+        hash_combine_range(EVI->idx_begin(), EVI->idx_end()));
+  } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(Inst)) {
+    Hash = hash_combine(Hash,
+        hash_combine_range(IVI->idx_begin(), IVI->idx_end()));
+  } else if (isMatchSelect) {
+    Hash = hash_combine(Hash, CmpU.SPF);
+  } else {
+    Hash = hash_combine(Hash,
         hash_combine_range(Inst->value_op_begin(), Inst->value_op_end()));
   }
 
-bool DenseMapInfo<SimpleValue>::isEqual(SimpleValue LHS, SimpleValue RHS) {
-  Instruction *LHSI = LHS.Inst, *RHSI = RHS.Inst;
+  return Hash;
+}
 
-  if (LHS.isSentinel() || RHS.isSentinel())
-    return LHSI == RHSI;
+bool
+SimpleValue::isEqual(const SimpleValue &Other) const {
+  const Instruction *LHSI = Inst, *RHSI = Other.Inst;
 
-  if (LHSI->getOpcode() != RHSI->getOpcode())
+  if (isSentinel() || Other.isSentinel())
+    return LHSI == RHSI;
+  if (CmpOpcode != Other.CmpOpcode)
     return false;
   if (LHSI->isIdenticalToWhenDefined(RHSI))
     return true;
 
-  // If we're not strictly identical, we still might be a commutable instruction
-  if (BinaryOperator *LHSBinOp = dyn_cast<BinaryOperator>(LHSI)) {
-    if (!LHSBinOp->isCommutative())
-      return false;
-
-    assert(isa<BinaryOperator>(RHSI) &&
-           "same opcode, but different instruction type?");
-    BinaryOperator *RHSBinOp = cast<BinaryOperator>(RHSI);
-
-    // Commuted equality
-    return LHSBinOp->getOperand(0) == RHSBinOp->getOperand(1) &&
-           LHSBinOp->getOperand(1) == RHSBinOp->getOperand(0);
-  }
-  if (CmpInst *LHSCmp = dyn_cast<CmpInst>(LHSI)) {
-    assert(isa<CmpInst>(RHSI) &&
-           "same opcode, but different instruction type?");
-    CmpInst *RHSCmp = cast<CmpInst>(RHSI);
-    // Commuted equality
-    return LHSCmp->getOperand(0) == RHSCmp->getOperand(1) &&
-           LHSCmp->getOperand(1) == RHSCmp->getOperand(0) &&
-           LHSCmp->getSwappedPredicate() == RHSCmp->getPredicate();
-  }
-
-  // Min/max/abs can occur with commuted operands, non-canonical predicates,
-  // and/or non-canonical operands.
-  Value *LHSA, *LHSB;
-  SelectPatternFlavor LSPF = matchSelectPattern(LHSI, LHSA, LHSB).Flavor;
-  // TODO: We should also detect FP min/max.
-  if (LSPF == SPF_SMIN || LSPF == SPF_SMAX ||
-      LSPF == SPF_UMIN || LSPF == SPF_UMAX ||
-      LSPF == SPF_ABS || LSPF == SPF_NABS) {
-    Value *RHSA, *RHSB;
-    SelectPatternFlavor RSPF = matchSelectPattern(RHSI, RHSA, RHSB).Flavor;
-    if (LSPF == RSPF) {
-      // Abs results are placed in a defined order by matchSelectPattern.
-      if (LSPF == SPF_ABS || LSPF == SPF_NABS)
-        return LHSA == RHSA && LHSB == RHSB;
-      return ((LHSA == RHSA && LHSB == RHSB) ||
-              (LHSA == RHSB && LHSB == RHSA));
-    }
+  // The instructions themselves differ, check whether they are the same in
+  // our canonicalised representation.
+  if (CmpOp1 != Other.CmpOp1 || CmpOp2 != Other.CmpOp2 ||
+      isMatchSelect != Other.isMatchSelect) {
+
+  // If this is one of the three flavours of instruction we canonicalise,
+  // examine more data and potentially return a match.
+  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Inst)) {
+    return true;
+  } else if (CmpInst *CI = dyn_cast<CmpInst>(Inst)) {
+    return CmpU.Pred == Other.CmpU.Pred;
+  } else if (isMatchSelect) {
+    return CmpU.SPF == Other.CmpU.SPF;
   }
 
   return false;
 }
 
+namespace llvm {
+
+template <> struct DenseMapInfo<SimpleValue> {
+  static inline SimpleValue getEmptyKey() {
+    return DenseMapInfo<Instruction *>::getEmptyKey();
+  }
+
+  static inline SimpleValue getTombstoneKey() {
+    return DenseMapInfo<Instruction *>::getTombstoneKey();
+  }
+
+  static unsigned getHashValue(const SimpleValue &Val) {
+    return Val.getHashValue();
+  }
+  static bool isEqual(const SimpleValue &LHS, const SimpleValue &RHS) {
+    return LHS.isEqual(RHS);
+  }
+};
+
+} // end namespace llvm
+
 //===----------------------------------------------------------------------===//
 // CallValue
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 /// Struct representing the available call values in the scoped hash
 /// table.
 struct CallValue {
   Instruction *Inst;
 

test/Transforms/EarlyCSE/sameoperand-cmp.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -early-cse -S | FileCheck %s
+; This test exposes nondeterministic output in broken versions of LLVM,
+; where some of the fcmp's below would be eliminated but others would not.
+define void @foo(double *%ptr, i1 *%out) {
+; CHECK-LABEL: @foo(
+; CHECK-NEXT:    [[A0:%.*]] = load volatile double, double* [[PTR:%.*]]
+; CHECK-NEXT:    [[A1:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A2:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A3:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A4:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A5:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A6:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A7:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A8:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A9:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A10:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A11:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A12:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A13:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A14:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A15:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A16:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A17:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A18:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A19:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A20:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A21:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A22:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A23:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A24:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A25:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A26:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A27:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A28:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A29:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A30:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A31:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A32:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A33:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A34:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A35:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A36:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A37:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A38:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A39:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A40:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A41:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A42:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A43:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A44:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A45:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A46:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A47:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A48:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A49:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A50:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A51:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A52:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A53:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A54:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A55:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A56:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A57:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A58:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A59:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A60:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A61:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A62:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[A63:%.*]] = load volatile double, double* [[PTR]]
+; CHECK-NEXT:    [[C0A:%.*]] = fcmp ult double [[A0]], [[A0]]
+; CHECK-NEXT:    [[C0B:%.*]] = fcmp ugt double [[A0]], [[A0]]
+; CHECK-NEXT:    [[C1A:%.*]] = fcmp ult double [[A1]], [[A1]]
+; CHECK-NEXT:    [[C1B:%.*]] = fcmp ugt double [[A1]], [[A1]]
+; CHECK-NEXT:    [[C2A:%.*]] = fcmp ult double [[A2]], [[A2]]
+; CHECK-NEXT:    [[C2B:%.*]] = fcmp ugt double [[A2]], [[A2]]
+; CHECK-NEXT:    [[C3A:%.*]] = fcmp ult double [[A3]], [[A3]]
+; CHECK-NEXT:    [[C3B:%.*]] = fcmp ugt double [[A3]], [[A3]]
+; CHECK-NEXT:    [[C4A:%.*]] = fcmp ult double [[A4]], [[A4]]
+; CHECK-NEXT:    [[C4B:%.*]] = fcmp ugt double [[A4]], [[A4]]
+; CHECK-NEXT:    [[C5A:%.*]] = fcmp ult double [[A5]], [[A5]]
+; CHECK-NEXT:    [[C5B:%.*]] = fcmp ugt double [[A5]], [[A5]]
+; CHECK-NEXT:    [[C6A:%.*]] = fcmp ult double [[A6]], [[A6]]
+; CHECK-NEXT:    [[C6B:%.*]] = fcmp ugt double [[A6]], [[A6]]
+; CHECK-NEXT:    [[C7A:%.*]] = fcmp ult double [[A7]], [[A7]]
+; CHECK-NEXT:    [[C7B:%.*]] = fcmp ugt double [[A7]], [[A7]]
+; CHECK-NEXT:    [[C8A:%.*]] = fcmp ult double [[A8]], [[A8]]
+; CHECK-NEXT:    [[C8B:%.*]] = fcmp ugt double [[A8]], [[A8]]
+; CHECK-NEXT:    [[C9A:%.*]] = fcmp ult double [[A9]], [[A9]]
+; CHECK-NEXT:    [[C9B:%.*]] = fcmp ugt double [[A9]], [[A9]]
+; CHECK-NEXT:    [[C10A:%.*]] = fcmp ult double [[A10]], [[A10]]
+; CHECK-NEXT:    [[C10B:%.*]] = fcmp ugt double [[A10]], [[A10]]
+; CHECK-NEXT:    [[C11A:%.*]] = fcmp ult double [[A11]], [[A11]]
+; CHECK-NEXT:    [[C11B:%.*]] = fcmp ugt double [[A11]], [[A11]]
+; CHECK-NEXT:    [[C12A:%.*]] = fcmp ult double [[A12]], [[A12]]
+; CHECK-NEXT:    [[C12B:%.*]] = fcmp ugt double [[A12]], [[A12]]
+; CHECK-NEXT:    [[C13A:%.*]] = fcmp ult double [[A13]], [[A13]]
+; CHECK-NEXT:    [[C13B:%.*]] = fcmp ugt double [[A13]], [[A13]]
+; CHECK-NEXT:    [[C14A:%.*]] = fcmp ult double [[A14]], [[A14]]
+; CHECK-NEXT:    [[C14B:%.*]] = fcmp ugt double [[A14]], [[A14]]
+; CHECK-NEXT:    [[C15A:%.*]] = fcmp ult double [[A15]], [[A15]]
+; CHECK-NEXT:    [[C15B:%.*]] = fcmp ugt double [[A15]], [[A15]]
+; CHECK-NEXT:    [[C16A:%.*]] = fcmp ult double [[A16]], [[A16]]
+; CHECK-NEXT:    [[C16B:%.*]] = fcmp ugt double [[A16]], [[A16]]
+; CHECK-NEXT:    [[C17A:%.*]] = fcmp ult double [[A17]], [[A17]]
+; CHECK-NEXT:    [[C17B:%.*]] = fcmp ugt double [[A17]], [[A17]]
+; CHECK-NEXT:    [[C18A:%.*]] = fcmp ult double [[A18]], [[A18]]
+; CHECK-NEXT:    [[C18B:%.*]] = fcmp ugt double [[A18]], [[A18]]
+; CHECK-NEXT:    [[C19A:%.*]] = fcmp ult double [[A19]], [[A19]]
+; CHECK-NEXT:    [[C19B:%.*]] = fcmp ugt double [[A19]], [[A19]]
+; CHECK-NEXT:    [[C20A:%.*]] = fcmp ult double [[A20]], [[A20]]
+; CHECK-NEXT:    [[C20B:%.*]] = fcmp ugt double [[A20]], [[A20]]
+; CHECK-NEXT:    [[C21A:%.*]] = fcmp ult double [[A21]], [[A21]]
+; CHECK-NEXT:    [[C21B:%.*]] = fcmp ugt double [[A21]], [[A21]]
+; CHECK-NEXT:    [[C22A:%.*]] = fcmp ult double [[A22]], [[A22]]
+; CHECK-NEXT:    [[C22B:%.*]] = fcmp ugt double [[A22]], [[A22]]
+; CHECK-NEXT:    [[C23A:%.*]] = fcmp ult double [[A23]], [[A23]]
+; CHECK-NEXT:    [[C23B:%.*]] = fcmp ugt double [[A23]], [[A23]]
+; CHECK-NEXT:    [[C24A:%.*]] = fcmp ult double [[A24]], [[A24]]
+; CHECK-NEXT:    [[C24B:%.*]] = fcmp ugt double [[A24]], [[A24]]
+; CHECK-NEXT:    [[C25A:%.*]] = fcmp ult double [[A25]], [[A25]]
+; CHECK-NEXT:    [[C25B:%.*]] = fcmp ugt double [[A25]], [[A25]]
+; CHECK-NEXT:    [[C26A:%.*]] = fcmp ult double [[A26]], [[A26]]
+; CHECK-NEXT:    [[C26B:%.*]] = fcmp ugt double [[A26]], [[A26]]
+; CHECK-NEXT:    [[C27A:%.*]] = fcmp ult double [[A27]], [[A27]]
+; CHECK-NEXT:    [[C27B:%.*]] = fcmp ugt double [[A27]], [[A27]]
+; CHECK-NEXT:    [[C28A:%.*]] = fcmp ult double [[A28]], [[A28]]
+; CHECK-NEXT:    [[C28B:%.*]] = fcmp ugt double [[A28]], [[A28]]
+; CHECK-NEXT:    [[C29A:%.*]] = fcmp ult double [[A29]], [[A29]]
+; CHECK-NEXT:    [[C29B:%.*]] = fcmp ugt double [[A29]], [[A29]]
+; CHECK-NEXT:    [[C30A:%.*]] = fcmp ult double [[A30]], [[A30]]
+; CHECK-NEXT:    [[C30B:%.*]] = fcmp ugt double [[A30]], [[A30]]
+; CHECK-NEXT:    [[C31A:%.*]] = fcmp ult double [[A31]], [[A31]]
+; CHECK-NEXT:    [[C31B:%.*]] = fcmp ugt double [[A31]], [[A31]]
+; CHECK-NEXT:    [[C32A:%.*]] = fcmp ult double [[A32]], [[A32]]
+; CHECK-NEXT:    [[C32B:%.*]] = fcmp ugt double [[A32]], [[A32]]
+; CHECK-NEXT:    [[C33A:%.*]] = fcmp ult double [[A33]], [[A33]]
+; CHECK-NEXT:    [[C33B:%.*]] = fcmp ugt double [[A33]], [[A33]]
+; CHECK-NEXT:    [[C34A:%.*]] = fcmp ult double [[A34]], [[A34]]
+; CHECK-NEXT:    [[C34B:%.*]] = fcmp ugt double [[A34]], [[A34]]
+; CHECK-NEXT:    [[C35A:%.*]] = fcmp ult double [[A35]], [[A35]]
+; CHECK-NEXT:    [[C35B:%.*]] = fcmp ugt double [[A35]], [[A35]]
+; CHECK-NEXT:    [[C36A:%.*]] = fcmp ult double [[A36]], [[A36]]
+; CHECK-NEXT:    [[C36B:%.*]] = fcmp ugt double [[A36]], [[A36]]
+; CHECK-NEXT:    [[C37A:%.*]] = fcmp ult double [[A37]], [[A37]]
+; CHECK-NEXT:    [[C37B:%.*]] = fcmp ugt double [[A37]], [[A37]]
+; CHECK-NEXT:    [[C38A:%.*]] = fcmp ult double [[A38]], [[A38]]
+; CHECK-NEXT:    [[C38B:%.*]] = fcmp ugt double [[A38]], [[A38]]
+; CHECK-NEXT:    [[C39A:%.*]] = fcmp ult double [[A39]], [[A39]]
+; CHECK-NEXT:    [[C39B:%.*]] = fcmp ugt double [[A39]], [[A39]]
+; CHECK-NEXT:    [[C40A:%.*]] = fcmp ult double [[A40]], [[A40]]
+; CHECK-NEXT:    [[C40B:%.*]] = fcmp ugt double [[A40]], [[A40]]
+; CHECK-NEXT:    [[C41A:%.*]] = fcmp ult double [[A41]], [[A41]]
+; CHECK-NEXT:    [[C41B:%.*]] = fcmp ugt double [[A41]], [[A41]]
+; CHECK-NEXT:    [[C42A:%.*]] = fcmp ult double [[A42]], [[A42]]
+; CHECK-NEXT:    [[C42B:%.*]] = fcmp ugt double [[A42]], [[A42]]
+; CHECK-NEXT:    [[C43A:%.*]] = fcmp ult double [[A43]], [[A43]]
+; CHECK-NEXT:    [[C43B:%.*]] = fcmp ugt double [[A43]], [[A43]]
+; CHECK-NEXT:    [[C44A:%.*]] = fcmp ult double [[A44]], [[A44]]
+; CHECK-NEXT:    [[C44B:%.*]] = fcmp ugt double [[A44]], [[A44]]
+; CHECK-NEXT:    [[C45A:%.*]] = fcmp ult double [[A45]], [[A45]]
+; CHECK-NEXT:    [[C45B:%.*]] = fcmp ugt double [[A45]], [[A45]]
+; CHECK-NEXT:    [[C46A:%.*]] = fcmp ult double [[A46]], [[A46]]
+; CHECK-NEXT:    [[C46B:%.*]] = fcmp ugt double [[A46]], [[A46]]
+; CHECK-NEXT:    [[C47A:%.*]] = fcmp ult double [[A47]], [[A47]]
+; CHECK-NEXT:    [[C47B:%.*]] = fcmp ugt double [[A47]], [[A47]]
+; CHECK-NEXT:    [[C48A:%.*]] = fcmp ult double [[A48]], [[A48]]
+; CHECK-NEXT:    [[C48B:%.*]] = fcmp ugt double [[A48]], [[A48]]
+; CHECK-NEXT:    [[C49A:%.*]] = fcmp ult double [[A49]], [[A49]]
+; CHECK-NEXT:    [[C49B:%.*]] = fcmp ugt double [[A49]], [[A49]]
+; CHECK-NEXT:    [[C50A:%.*]] = fcmp ult double [[A50]], [[A50]]
+; CHECK-NEXT:    [[C50B:%.*]] = fcmp ugt double [[A50]], [[A50]]
+; CHECK-NEXT:    [[C51A:%.*]] = fcmp ult double [[A51]], [[A51]]
+; CHECK-NEXT:    [[C51B:%.*]] = fcmp ugt double [[A51]], [[A51]]
+; CHECK-NEXT:    [[C52A:%.*]] = fcmp ult double [[A52]], [[A52]]
+; CHECK-NEXT:    [[C52B:%.*]] = fcmp ugt double [[A52]], [[A52]]
+; CHECK-NEXT:    [[C53A:%.*]] = fcmp ult double [[A53]], [[A53]]
+; CHECK-NEXT:    [[C53B:%.*]] = fcmp ugt double [[A53]], [[A53]]
+; CHECK-NEXT:    [[C54A:%.*]] = fcmp ult double [[A54]], [[A54]]
+; CHECK-NEXT:    [[C54B:%.*]] = fcmp ugt double [[A54]], [[A54]]
+; CHECK-NEXT:    [[C55A:%.*]] = fcmp ult double [[A55]], [[A55]]
+; CHECK-NEXT:    [[C55B:%.*]] = fcmp ugt double [[A55]], [[A55]]
+; CHECK-NEXT:    [[C56A:%.*]] = fcmp ult double [[A56]], [[A56]]
+; CHECK-NEXT:    [[C56B:%.*]] = fcmp ugt double [[A56]], [[A56]]
+; CHECK-NEXT:    [[C57A:%.*]] = fcmp ult double [[A57]], [[A57]]
+; CHECK-NEXT:    [[C57B:%.*]] = fcmp ugt double [[A57]], [[A57]]
+; CHECK-NEXT:    [[C58A:%.*]] = fcmp ult double [[A58]], [[A58]]
+; CHECK-NEXT:    [[C58B:%.*]] = fcmp ugt double [[A58]], [[A58]]
+; CHECK-NEXT:    [[C59A:%.*]] = fcmp ult double [[A59]], [[A59]]
+; CHECK-NEXT:    [[C59B:%.*]] = fcmp ugt double [[A59]], [[A59]]
+; CHECK-NEXT:    [[C60A:%.*]] = fcmp ult double [[A60]], [[A60]]
+; CHECK-NEXT:    [[C60B:%.*]] = fcmp ugt double [[A60]], [[A60]]
+; CHECK-NEXT:    [[C61A:%.*]] = fcmp ult double [[A61]], [[A61]]
+; CHECK-NEXT:    [[C61B:%.*]] = fcmp ugt double [[A61]], [[A61]]
+; CHECK-NEXT:    [[C62A:%.*]] = fcmp ult double [[A62]], [[A62]]
+; CHECK-NEXT:    [[C62B:%.*]] = fcmp ugt double [[A62]], [[A62]]
+; CHECK-NEXT:    [[C63A:%.*]] = fcmp ult double [[A63]], [[A63]]
+; CHECK-NEXT:    [[C63B:%.*]] = fcmp ugt double [[A63]], [[A63]]
+; CHECK-NEXT:    store volatile i1 [[C0A]], i1* [[OUT:%.*]]
+; CHECK-NEXT:    store volatile i1 [[C0B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C1A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C1B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C2A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C2B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C3A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C3B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C4A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C4B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C5A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C5B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C6A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C6B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C7A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C7B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C8A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C8B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C9A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C9B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C10A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C10B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C11A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C11B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C12A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C12B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C13A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C13B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C14A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C14B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C15A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C15B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C16A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C16B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C17A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C17B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C18A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C18B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C19A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C19B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C20A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C20B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C21A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C21B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C22A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C22B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C23A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C23B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C24A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C24B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C25A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C25B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C26A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C26B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C27A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C27B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C28A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C28B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C29A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C29B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C30A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C30B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C31A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C31B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C32A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C32B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C33A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C33B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C34A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C34B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C35A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C35B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C36A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C36B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C37A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C37B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C38A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C38B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C39A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C39B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C40A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C40B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C41A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C41B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C42A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C42B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C43A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C43B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C44A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C44B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C45A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C45B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C46A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C46B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C47A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C47B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C48A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C48B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C49A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C49B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C50A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C50B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C51A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C51B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C52A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C52B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C53A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C53B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C54A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C54B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C55A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C55B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C56A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C56B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C57A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C57B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C58A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C58B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C59A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C59B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C60A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C60B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C61A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C61B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C62A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C62B]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C63A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[C63B]], i1* [[OUT]]
+; CHECK-NEXT:    [[TOGO_A:%.*]] = fcmp ugt double [[A0]], [[A1]]
+; CHECK-NEXT:    store volatile i1 [[TOGO_A]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[TOGO_A]], i1* [[OUT]]
+; CHECK-NEXT:    [[TOGO_C:%.*]] = fcmp ult double [[A0]], [[A1]]
+; CHECK-NEXT:    store volatile i1 [[TOGO_C]], i1* [[OUT]]
+; CHECK-NEXT:    store volatile i1 [[TOGO_C]], i1* [[OUT]]
+; CHECK-NEXT:    ret void
+;
+  %A0 = load volatile double, double *%ptr
+  %A1 = load volatile double, double *%ptr
+  %A2 = load volatile double, double *%ptr
+  %A3 = load volatile double, double *%ptr
+  %A4 = load volatile double, double *%ptr
+  %A5 = load volatile double, double *%ptr
+  %A6 = load volatile double, double *%ptr
+  %A7 = load volatile double, double *%ptr
+  %A8 = load volatile double, double *%ptr
+  %A9 = load volatile double, double *%ptr
+  %A10 = load volatile double, double *%ptr
+  %A11 = load volatile double, double *%ptr
+  %A12 = load volatile double, double *%ptr
+  %A13 = load volatile double, double *%ptr
+  %A14 = load volatile double, double *%ptr
+  %A15 = load volatile double, double *%ptr
+  %A16 = load volatile double, double *%ptr
+  %A17 = load volatile double, double *%ptr
+  %A18 = load volatile double, double *%ptr
+  %A19 = load volatile double, double *%ptr
+  %A20 = load volatile double, double *%ptr
+  %A21 = load volatile double, double *%ptr
+  %A22 = load volatile double, double *%ptr
+  %A23 = load volatile double, double *%ptr
+  %A24 = load volatile double, double *%ptr
+  %A25 = load volatile double, double *%ptr
+  %A26 = load volatile double, double *%ptr
+  %A27 = load volatile double, double *%ptr
+  %A28 = load volatile double, double *%ptr
+  %A29 = load volatile double, double *%ptr
+  %A30 = load volatile double, double *%ptr
+  %A31 = load volatile double, double *%ptr
+  %A32 = load volatile double, double *%ptr
+  %A33 = load volatile double, double *%ptr
+  %A34 = load volatile double, double *%ptr
+  %A35 = load volatile double, double *%ptr
+  %A36 = load volatile double, double *%ptr
+  %A37 = load volatile double, double *%ptr
+  %A38 = load volatile double, double *%ptr
+  %A39 = load volatile double, double *%ptr
+  %A40 = load volatile double, double *%ptr
+  %A41 = load volatile double, double *%ptr
+  %A42 = load volatile double, double *%ptr
+  %A43 = load volatile double, double *%ptr
+  %A44 = load volatile double, double *%ptr
+  %A45 = load volatile double, double *%ptr
+  %A46 = load volatile double, double *%ptr
+  %A47 = load volatile double, double *%ptr
+  %A48 = load volatile double, double *%ptr
+  %A49 = load volatile double, double *%ptr
+  %A50 = load volatile double, double *%ptr
+  %A51 = load volatile double, double *%ptr
+  %A52 = load volatile double, double *%ptr
+  %A53 = load volatile double, double *%ptr
+  %A54 = load volatile double, double *%ptr
+  %A55 = load volatile double, double *%ptr
+  %A56 = load volatile double, double *%ptr
+  %A57 = load volatile double, double *%ptr
+  %A58 = load volatile double, double *%ptr
+  %A59 = load volatile double, double *%ptr
+  %A60 = load volatile double, double *%ptr
+  %A61 = load volatile double, double *%ptr
+  %A62 = load volatile double, double *%ptr
+  %A63 = load volatile double, double *%ptr
+  %C0a = fcmp ult double %A0, %A0
+  %C0b = fcmp ugt double %A0, %A0
+  %C1a = fcmp ult double %A1, %A1
+  %C1b = fcmp ugt double %A1, %A1
+  %C2a = fcmp ult double %A2, %A2
+  %C2b = fcmp ugt double %A2, %A2
+  %C3a = fcmp ult double %A3, %A3
+  %C3b = fcmp ugt double %A3, %A3
+  %C4a = fcmp ult double %A4, %A4
+  %C4b = fcmp ugt double %A4, %A4
+  %C5a = fcmp ult double %A5, %A5
+  %C5b = fcmp ugt double %A5, %A5
+  %C6a = fcmp ult double %A6, %A6
+  %C6b = fcmp ugt double %A6, %A6
+  %C7a = fcmp ult double %A7, %A7
+  %C7b = fcmp ugt double %A7, %A7
+  %C8a = fcmp ult double %A8, %A8
+  %C8b = fcmp ugt double %A8, %A8
+  %C9a = fcmp ult double %A9, %A9
+  %C9b = fcmp ugt double %A9, %A9
+  %C10a = fcmp ult double %A10, %A10
+  %C10b = fcmp ugt double %A10, %A10
+  %C11a = fcmp ult double %A11, %A11
+  %C11b = fcmp ugt double %A11, %A11
+  %C12a = fcmp ult double %A12, %A12
+  %C12b = fcmp ugt double %A12, %A12
+  %C13a = fcmp ult double %A13, %A13
+  %C13b = fcmp ugt double %A13, %A13
+  %C14a = fcmp ult double %A14, %A14
+  %C14b = fcmp ugt double %A14, %A14
+  %C15a = fcmp ult double %A15, %A15
+  %C15b = fcmp ugt double %A15, %A15
+  %C16a = fcmp ult double %A16, %A16
+  %C16b = fcmp ugt double %A16, %A16
+  %C17a = fcmp ult double %A17, %A17
+  %C17b = fcmp ugt double %A17, %A17
+  %C18a = fcmp ult double %A18, %A18
+  %C18b = fcmp ugt double %A18, %A18
+  %C19a = fcmp ult double %A19, %A19
+  %C19b = fcmp ugt double %A19, %A19
+  %C20a = fcmp ult double %A20, %A20
+  %C20b = fcmp ugt double %A20, %A20
+  %C21a = fcmp ult double %A21, %A21
+  %C21b = fcmp ugt double %A21, %A21
+  %C22a = fcmp ult double %A22, %A22
+  %C22b = fcmp ugt double %A22, %A22
+  %C23a = fcmp ult double %A23, %A23
+  %C23b = fcmp ugt double %A23, %A23
+  %C24a = fcmp ult double %A24, %A24
+  %C24b = fcmp ugt double %A24, %A24
+  %C25a = fcmp ult double %A25, %A25
+  %C25b = fcmp ugt double %A25, %A25
+  %C26a = fcmp ult double %A26, %A26
+  %C26b = fcmp ugt double %A26, %A26
+  %C27a = fcmp ult double %A27, %A27
+  %C27b = fcmp ugt double %A27, %A27
+  %C28a = fcmp ult double %A28, %A28
+  %C28b = fcmp ugt double %A28, %A28
+  %C29a = fcmp ult double %A29, %A29
+  %C29b = fcmp ugt double %A29, %A29
+  %C30a = fcmp ult double %A30, %A30
+  %C30b = fcmp ugt double %A30, %A30
+  %C31a = fcmp ult double %A31, %A31
+  %C31b = fcmp ugt double %A31, %A31
+  %C32a = fcmp ult double %A32, %A32
+  %C32b = fcmp ugt double %A32, %A32
+  %C33a = fcmp ult double %A33, %A33
+  %C33b = fcmp ugt double %A33, %A33
+  %C34a = fcmp ult double %A34, %A34
+  %C34b = fcmp ugt double %A34, %A34
+  %C35a = fcmp ult double %A35, %A35
+  %C35b = fcmp ugt double %A35, %A35
+  %C36a = fcmp ult double %A36, %A36
+  %C36b = fcmp ugt double %A36, %A36
+  %C37a = fcmp ult double %A37, %A37
+  %C37b = fcmp ugt double %A37, %A37
+  %C38a = fcmp ult double %A38, %A38
+  %C38b = fcmp ugt double %A38, %A38
+  %C39a = fcmp ult double %A39, %A39
+  %C39b = fcmp ugt double %A39, %A39
+  %C40a = fcmp ult double %A40, %A40
+  %C40b = fcmp ugt double %A40, %A40
+  %C41a = fcmp ult double %A41, %A41
+  %C41b = fcmp ugt double %A41, %A41
+  %C42a = fcmp ult double %A42, %A42
+  %C42b = fcmp ugt double %A42, %A42
+  %C43a = fcmp ult double %A43, %A43
+  %C43b = fcmp ugt double %A43, %A43
+  %C44a = fcmp ult double %A44, %A44
+  %C44b = fcmp ugt double %A44, %A44
+  %C45a = fcmp ult double %A45, %A45
+  %C45b = fcmp ugt double %A45, %A45
+  %C46a = fcmp ult double %A46, %A46
+  %C46b = fcmp ugt double %A46, %A46
+  %C47a = fcmp ult double %A47, %A47
+  %C47b = fcmp ugt double %A47, %A47
+  %C48a = fcmp ult double %A48, %A48
+  %C48b = fcmp ugt double %A48, %A48
+  %C49a = fcmp ult double %A49, %A49
+  %C49b = fcmp ugt double %A49, %A49
+  %C50a = fcmp ult double %A50, %A50
+  %C50b = fcmp ugt double %A50, %A50
+  %C51a = fcmp ult double %A51, %A51
+  %C51b = fcmp ugt double %A51, %A51
+  %C52a = fcmp ult double %A52, %A52
+  %C52b = fcmp ugt double %A52, %A52
+  %C53a = fcmp ult double %A53, %A53
+  %C53b = fcmp ugt double %A53, %A53
+  %C54a = fcmp ult double %A54, %A54
+  %C54b = fcmp ugt double %A54, %A54
+  %C55a = fcmp ult double %A55, %A55
+  %C55b = fcmp ugt double %A55, %A55
+  %C56a = fcmp ult double %A56, %A56
+  %C56b = fcmp ugt double %A56, %A56
+  %C57a = fcmp ult double %A57, %A57
+  %C57b = fcmp ugt double %A57, %A57
+  %C58a = fcmp ult double %A58, %A58
+  %C58b = fcmp ugt double %A58, %A58
+  %C59a = fcmp ult double %A59, %A59
+  %C59b = fcmp ugt double %A59, %A59
+  %C60a = fcmp ult double %A60, %A60
+  %C60b = fcmp ugt double %A60, %A60
+  %C61a = fcmp ult double %A61, %A61
+  %C61b = fcmp ugt double %A61, %A61
+  %C62a = fcmp ult double %A62, %A62
+  %C62b = fcmp ugt double %A62, %A62
+  %C63a = fcmp ult double %A63, %A63
+  %C63b = fcmp ugt double %A63, %A63
+  store volatile i1 %C0a, i1 *%out
+  store volatile i1 %C0b, i1 *%out
+  store volatile i1 %C1a, i1 *%out
+  store volatile i1 %C1b, i1 *%out
+  store volatile i1 %C2a, i1 *%out
+  store volatile i1 %C2b, i1 *%out
+  store volatile i1 %C3a, i1 *%out
+  store volatile i1 %C3b, i1 *%out
+  store volatile i1 %C4a, i1 *%out
+  store volatile i1 %C4b, i1 *%out
+  store volatile i1 %C5a, i1 *%out
+  store volatile i1 %C5b, i1 *%out
+  store volatile i1 %C6a, i1 *%out
+  store volatile i1 %C6b, i1 *%out
+  store volatile i1 %C7a, i1 *%out
+  store volatile i1 %C7b, i1 *%out
+  store volatile i1 %C8a, i1 *%out
+  store volatile i1 %C8b, i1 *%out
+  store volatile i1 %C9a, i1 *%out
+  store volatile i1 %C9b, i1 *%out
+  store volatile i1 %C10a, i1 *%out
+  store volatile i1 %C10b, i1 *%out
+  store volatile i1 %C11a, i1 *%out
+  store volatile i1 %C11b, i1 *%out
+  store volatile i1 %C12a, i1 *%out
+  store volatile i1 %C12b, i1 *%out
+  store volatile i1 %C13a, i1 *%out
+  store volatile i1 %C13b, i1 *%out
+  store volatile i1 %C14a, i1 *%out
+  store volatile i1 %C14b, i1 *%out
+  store volatile i1 %C15a, i1 *%out
+  store volatile i1 %C15b, i1 *%out
+  store volatile i1 %C16a, i1 *%out
+  store volatile i1 %C16b, i1 *%out
+  store volatile i1 %C17a, i1 *%out
+  store volatile i1 %C17b, i1 *%out
+  store volatile i1 %C18a, i1 *%out
+  store volatile i1 %C18b, i1 *%out
+  store volatile i1 %C19a, i1 *%out
+  store volatile i1 %C19b, i1 *%out
+  store volatile i1 %C20a, i1 *%out
+  store volatile i1 %C20b, i1 *%out
+  store volatile i1 %C21a, i1 *%out
+  store volatile i1 %C21b, i1 *%out
+  store volatile i1 %C22a, i1 *%out
+  store volatile i1 %C22b, i1 *%out
+  store volatile i1 %C23a, i1 *%out
+  store volatile i1 %C23b, i1 *%out
+  store volatile i1 %C24a, i1 *%out
+  store volatile i1 %C24b, i1 *%out
+  store volatile i1 %C25a, i1 *%out
+  store volatile i1 %C25b, i1 *%out
+  store volatile i1 %C26a, i1 *%out
+  store volatile i1 %C26b, i1 *%out
+  store volatile i1 %C27a, i1 *%out
+  store volatile i1 %C27b, i1 *%out
+  store volatile i1 %C28a, i1 *%out
+  store volatile i1 %C28b, i1 *%out
+  store volatile i1 %C29a, i1 *%out
+  store volatile i1 %C29b, i1 *%out
+  store volatile i1 %C30a, i1 *%out
+  store volatile i1 %C30b, i1 *%out
+  store volatile i1 %C31a, i1 *%out
+  store volatile i1 %C31b, i1 *%out
+  store volatile i1 %C32a, i1 *%out
+  store volatile i1 %C32b, i1 *%out
+  store volatile i1 %C33a, i1 *%out
+  store volatile i1 %C33b, i1 *%out
+  store volatile i1 %C34a, i1 *%out
+  store volatile i1 %C34b, i1 *%out
+  store volatile i1 %C35a, i1 *%out
+  store volatile i1 %C35b, i1 *%out
+  store volatile i1 %C36a, i1 *%out
+  store volatile i1 %C36b, i1 *%out
+  store volatile i1 %C37a, i1 *%out
+  store volatile i1 %C37b, i1 *%out
+  store volatile i1 %C38a, i1 *%out
+  store volatile i1 %C38b, i1 *%out
+  store volatile i1 %C39a, i1 *%out
+  store volatile i1 %C39b, i1 *%out
+  store volatile i1 %C40a, i1 *%out
+  store volatile i1 %C40b, i1 *%out
+  store volatile i1 %C41a, i1 *%out
+  store volatile i1 %C41b, i1 *%out
+  store volatile i1 %C42a, i1 *%out
+  store volatile i1 %C42b, i1 *%out
+  store volatile i1 %C43a, i1 *%out
+  store volatile i1 %C43b, i1 *%out
+  store volatile i1 %C44a, i1 *%out
+  store volatile i1 %C44b, i1 *%out
+  store volatile i1 %C45a, i1 *%out
+  store volatile i1 %C45b, i1 *%out
+  store volatile i1 %C46a, i1 *%out
+  store volatile i1 %C46b, i1 *%out
+  store volatile i1 %C47a, i1 *%out
+  store volatile i1 %C47b, i1 *%out
+  store volatile i1 %C48a, i1 *%out
+  store volatile i1 %C48b, i1 *%out
+  store volatile i1 %C49a, i1 *%out
+  store volatile i1 %C49b, i1 *%out
+  store volatile i1 %C50a, i1 *%out
+  store volatile i1 %C50b, i1 *%out
+  store volatile i1 %C51a, i1 *%out
+  store volatile i1 %C51b, i1 *%out
+  store volatile i1 %C52a, i1 *%out
+  store volatile i1 %C52b, i1 *%out
+  store volatile i1 %C53a, i1 *%out
+  store volatile i1 %C53b, i1 *%out
+  store volatile i1 %C54a, i1 *%out
+  store volatile i1 %C54b, i1 *%out
+  store volatile i1 %C55a, i1 *%out
+  store volatile i1 %C55b, i1 *%out
+  store volatile i1 %C56a, i1 *%out
+  store volatile i1 %C56b, i1 *%out
+  store volatile i1 %C57a, i1 *%out
+  store volatile i1 %C57b, i1 *%out
+  store volatile i1 %C58a, i1 *%out
+  store volatile i1 %C58b, i1 *%out
+  store volatile i1 %C59a, i1 *%out
+  store volatile i1 %C59b, i1 *%out
+  store volatile i1 %C60a, i1 *%out
+  store volatile i1 %C60b, i1 *%out
+  store volatile i1 %C61a, i1 *%out
+  store volatile i1 %C61b, i1 *%out
+  store volatile i1 %C62a, i1 *%out
+  store volatile i1 %C62b, i1 *%out
+  store volatile i1 %C63a, i1 *%out
+  store volatile i1 %C63b, i1 *%out
+
+  ; Should be eliminated.
+  %togo_a = fcmp ugt double %A0, %A1
+  %togo_b = fcmp ult double %A1, %A0
+  store volatile i1 %togo_a, i1 *%out
+  store volatile i1 %togo_b, i1 *%out
+
+  ; Similarly, these equivalent compares should
+  %togo_c = fcmp ult double %A0, %A1
+  %togo_d = fcmp ult double %A0, %A1
+  store volatile i1 %togo_c, i1 *%out
+  store volatile i1 %togo_d, i1 *%out
+
+
+  ret void
+}