Fix DBC double comparisons for NaN.

runtime/vm/intermediate_language_dbc.cc

Index: runtime/vm/intermediate_language_dbc.cc
diff --git a/runtime/vm/intermediate_language_dbc.cc b/runtime/vm/intermediate_language_dbc.cc
index aca13bdda4f4d677e5fae7d59cca94a1699c7b3f..179f0b4e0105b225d9390c2adc0ee182f4440d49 100644
--- a/runtime/vm/intermediate_language_dbc.cc
+++ b/runtime/vm/intermediate_language_dbc.cc
@@ -454,7 +454,7 @@ static void EmitBranchOnCondition(FlowGraphCompiler* compiler,
     }
   } else {
     ASSERT(true_condition == NEXT_IS_FALSE);
-    // NEXT_IS_FALSE indicates that the preceeing test has been flipped and
+    // NEXT_IS_FALSE indicates that the preceeding test has been flipped and
     // expects the false case to be in the subsequent instruction, which it
     // skips if the test succeeds.
     __ Jump(labels.false_label);
@@ -479,7 +479,7 @@ Condition StrictCompareInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
     condition = NEXT_IS_TRUE;
     comparison = kind();
   } else {
-    // Flip comparision to save a jump.
+    // Flip comparison to save a jump.
     condition = NEXT_IS_FALSE;
     comparison = (kind() == Token::kEQ_STRICT) ? Token::kNE_STRICT
                                                : Token::kEQ_STRICT;
@@ -1788,15 +1788,12 @@ static Condition EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
   const Register left = locs->in(0).reg();
   const Register right = locs->in(1).reg();
   Token::Kind comparison = kind;
+  // For double comparisons we can't flip the condition like with smi

[zra, 2016/10/07 02:14:43]

Can we flip for all but == and/or != ?

[Florian Schneider, 2016/10/07 16:49:33]

As discussed offline, we could do inline assembly to handle the nan-case like in
other architectures. Or we could reorder blocks so that the fall-through is
always the false-label.

I'll do some performance measurements to figure out the impact of this change.

+  // comparisons because of NaN which will compare false for all except !=
+  // operations.
+  // TODO(fschneider): Change the block order instead in DBC so that the
+  // false block in always the fall-through block.
   Condition condition = NEXT_IS_TRUE;
-  if (labels.fall_through != labels.false_label) {
-    // If we aren't falling through to the false label, we can save a Jump
-    // instruction in the case that the true case is the fall through by
-    // flipping the sense of the test such that the instruction following the
-    // test is the Jump to the false label.
-    condition = NEXT_IS_FALSE;
-    comparison = FlipCondition(kind);
-  }
   __ Emit(Bytecode::Encode(OpcodeForDoubleCondition(comparison), left, right));
   return condition;
 }