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

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 727 matching lines @@
       for_true.Do(BuildStoreExprTemp(constant_true));
       Join(for_test, for_true, for_right);
     }
     ReturnDefinition(BuildLoadExprTemp());
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
+void EffectGraphVisitor::BuildTypecheckPushArguments(
+    intptr_t token_pos,
+    PushArgumentInstr** push_instantiator_result,
+    PushArgumentInstr** push_instantiator_type_arguments_result) {
+  const Class& instantiator_class = Class::Handle(
+      owner()->parsed_function().function().Owner());
+  // Since called only when type tested against is not instantiated.
+  ASSERT(instantiator_class.NumTypeParameters() > 0);
+  Value* instantiator_type_arguments = NULL;
+  Value* instantiator = BuildInstantiator();
+  if (instantiator == NULL) {
+    // No instantiator when inside factory.
+    *push_instantiator_result = PushArgument(BuildNullValue());
+    instantiator_type_arguments =
+        BuildInstantiatorTypeArguments(token_pos, NULL);
+  } else {
+    instantiator = Bind(BuildStoreExprTemp(instantiator));
+    *push_instantiator_result = PushArgument(instantiator);
+    Value* loaded = Bind(BuildLoadExprTemp());
+    instantiator_type_arguments =
+        BuildInstantiatorTypeArguments(token_pos, loaded);
+  }
+  *push_instantiator_type_arguments_result =
+      PushArgument(instantiator_type_arguments);
+}
+
+
+
 void EffectGraphVisitor::BuildTypecheckArguments(
     intptr_t token_pos,
     Value** instantiator_result,
     Value** instantiator_type_arguments_result) {
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
@@ skipping 120 matching lines @@
         result = new ConstantInstr(negate_result ? bool_true : bool_false);
       }
     }
     ReturnDefinition(result);
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  Value* instantiator = NULL;
-  Value* instantiator_type_arguments = NULL;
+  PushArgumentInstr* push_left = PushArgument(for_left_value.value());
+  PushArgumentInstr* push_instantiator = NULL;
+  PushArgumentInstr* push_type_args = NULL;
   if (type.IsInstantiated()) {
-    instantiator = BuildNullValue();
-    instantiator_type_arguments = BuildNullValue();
+    push_instantiator = PushArgument(BuildNullValue());
+    push_type_args = PushArgument(BuildNullValue());
   } else {
-    BuildTypecheckArguments(node->token_pos(),
-                            &instantiator,
-                            &instantiator_type_arguments);
+    BuildTypecheckPushArguments(node->token_pos(),
+                                &push_instantiator,
+                                &push_type_args);
   }
-  InstanceOfInstr* instance_of =
-      new InstanceOfInstr(node->token_pos(),
-                          for_left_value.value(),
-                          instantiator,
-                          instantiator_type_arguments,
-                          node->right()->AsTypeNode()->type(),
-                          (node->kind() == Token::kISNOT));
-  ReturnDefinition(instance_of);
+  const String& name = String::ZoneHandle(Symbols::New("_instanceOf"));
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(5);
+  arguments->Add(push_left);
+  arguments->Add(push_instantiator);
+  arguments->Add(push_type_args);
+  ASSERT(!node->right()->AsTypeNode()->type().IsNull());
+  Value* type_arg = Bind(
+      new ConstantInstr(node->right()->AsTypeNode()->type()));
+  arguments->Add(PushArgument(type_arg));
+  const Bool& negate = Bool::ZoneHandle(node->kind() == Token::kISNOT ?
+      Bool::True() : Bool::False());
+  Value* negate_arg = Bind(new ConstantInstr(negate));
+  arguments->Add(PushArgument(negate_arg));
+  const intptr_t kNumArgsChecked = 1;
+  InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
+                                                  name,
+                                                  node->kind(),
+                                                  arguments,
+                                                  Array::ZoneHandle(),
+                                                  kNumArgsChecked);
+  ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
   ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_value);
   Append(for_value);
@@ skipping 2102 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart