Add DoubleTestOp instruction

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
@@ skipping 2384 matching lines @@
                                  new(Z) Value(left),
                                  new(Z) Value(right),
                                  call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(*entry, double_bin_op, call->env(), FlowGraph::kValue);
   *last = double_bin_op;
 
   return true;
 }
 
 
+static bool InlineDoubleTestOp(FlowGraph* flow_graph,
+                               Instruction* call,
+                               MethodRecognizer::Kind kind,
+                               TargetEntryInstr** entry,
+                               Definition** last) {
+  if (!CanUnboxDouble()) {
+    return false;
+  }
+  Definition* d = call->ArgumentAt(0);
+
+  *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
+                                   call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(Z, call);
+  // Arguments are checked. No need for class check.
+
+  DoubleTestOpInstr* double_test_op =
+      new(Z) DoubleTestOpInstr(kind,
+                               new(Z) Value(d),
+                               call->deopt_id(),
+                               call->token_pos());
+  flow_graph->AppendTo(
+      *entry, double_test_op, call->env(), FlowGraph::kValue);
+  *last = double_test_op;
+
+  return true;
+}
+
+
 static bool InlineSmiBitAndFromSmi(FlowGraph* flow_graph,
                                    Instruction* call,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                    call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
@@ skipping 1227 matching lines @@
       return InlineStringBaseCharAt(
           flow_graph, call, receiver_cid, entry, last);
     case MethodRecognizer::kDoubleAdd:
       return InlineDoubleOp(flow_graph, Token::kADD, call, entry, last);
     case MethodRecognizer::kDoubleSub:
       return InlineDoubleOp(flow_graph, Token::kSUB, call, entry, last);
     case MethodRecognizer::kDoubleMul:
       return InlineDoubleOp(flow_graph, Token::kMUL, call, entry, last);
     case MethodRecognizer::kDoubleDiv:
       return InlineDoubleOp(flow_graph, Token::kDIV, call, entry, last);
+    case MethodRecognizer::kDoubleIsNaN:

[Florian Schneider, 2016/10/18 20:34:20]

Handle DoubleIsNegative?

[zra, 2016/10/18 22:36:32]

Acknowledged.

+    case MethodRecognizer::kDoubleIsInfinite:
+      return InlineDoubleTestOp(flow_graph, call, kind, entry, last);
     case MethodRecognizer::kGrowableArraySetData:
       ASSERT(receiver_cid == kGrowableObjectArrayCid);
       ASSERT(ic_data.NumberOfChecks() == 1);
       return InlineGrowableArraySetter(
           flow_graph, GrowableObjectArray::data_offset(), kEmitStoreBarrier,
           call, entry, last);
     case MethodRecognizer::kGrowableArraySetLength:
       ASSERT(receiver_cid == kGrowableObjectArrayCid);
       ASSERT(ic_data.NumberOfChecks() == 1);
       return InlineGrowableArraySetter(
@@ skipping 143 matching lines @@
       return true;
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart