In unoptimized code use call for instanceof instead of inlined checks. This allows us to collect ty…

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2012, 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_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 1231 matching lines @@
     }
     call->ReplaceWith(d2i_instr, current_iterator());
     RemovePushArguments(call);
     return true;
   }
 
   return false;
 }
 
 
+// TODO(srdjan): Use ICData to check if always true or false.
+void FlowGraphOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
+  ASSERT(Token::IsTypeTestOperator(call->token_kind()));
+  Value* left_val = call->ArgumentAt(0)->value();
+  Value* instantiator_val = call->ArgumentAt(1)->value();
+  Value* type_args_val = call->ArgumentAt(2)->value();
+  const AbstractType& type =
+      AbstractType::Cast(call->ArgumentAt(3)->value()->BoundConstant());
+  const Bool& negate =
+      Bool::Cast(call->ArgumentAt(4)->value()->BoundConstant());
+  InstanceOfInstr* instance_of =
+      new InstanceOfInstr(call->token_pos(),
+                          left_val,
+                          instantiator_val,
+                          type_args_val,
+                          type,
+                          negate.value());
+  call->ReplaceWith(instance_of, current_iterator());
+  RemovePushArguments(call);
+}
+
+
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   if (!instr->HasICData() || (instr->ic_data()->NumberOfChecks() == 0)) {
     // An instance call without ICData will trigger deoptimization.
     return;
   }
 
+  const Token::Kind op_kind = instr->token_kind();
+  // Type test is special as it always gets converted into inlined code.
+  if (Token::IsTypeTestOperator(op_kind)) {
+    ReplaceWithInstanceOf(instr);
+    return;
+  }
+
   const ICData& unary_checks =
       ICData::ZoneHandle(instr->ic_data()->AsUnaryClassChecks());
   if ((unary_checks.NumberOfChecks() > FLAG_max_polymorphic_checks) &&
       InstanceCallNeedsClassCheck(instr)) {
     // Too many checks, it will be megamorphic which needs unary checks.
     instr->set_ic_data(&unary_checks);
     return;
   }
 
-  const Token::Kind op_kind = instr->token_kind();
   if ((op_kind == Token::kASSIGN_INDEX) &&
       TryReplaceWithStoreIndexed(instr)) {
     return;
   }
   if ((op_kind == Token::kINDEX) && TryReplaceWithLoadIndexed(instr)) {
     return;
   }
   if (Token::IsBinaryOperator(op_kind) &&
       TryReplaceWithBinaryOp(instr, op_kind)) {
     return;
@@ skipping 3069 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart