Remove instantiator argument in generated code for type tests.

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 "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 1451 matching lines @@
                                                      arguments,
                                                      Object::null_array(),
                                                      kNumArgsChecked,
                                                      owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckPushArguments(
     intptr_t token_pos,
-    PushArgumentInstr** push_instantiator_result,
     PushArgumentInstr** push_instantiator_type_arguments_result) {
   const Class& instantiator_class = Class::Handle(
       Z, owner()->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(instantiator_class);
   if (instantiator == NULL) {
     // No instantiator when inside factory.
-    *push_instantiator_result = PushArgument(BuildNullValue());
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   } else {
-    instantiator = Bind(BuildStoreExprTemp(instantiator));
-    *push_instantiator_result = PushArgument(instantiator);
-    Value* loaded = Bind(BuildLoadExprTemp());
-    instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_pos, instantiator_class, loaded);
+    instantiator_type_arguments = BuildInstantiatorTypeArguments(
+        token_pos, instantiator_class, instantiator);
   }
   *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(
       Z, owner()->function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   instantiator = BuildInstantiator(instantiator_class);
   if (instantiator == NULL) {
     // No instantiator when inside factory.
-    instantiator = BuildNullValue();
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   } else {
-    // Preserve instantiator.
-    instantiator = Bind(BuildStoreExprTemp(instantiator));
-    Value* loaded = Bind(BuildLoadExprTemp());
-    instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_pos, instantiator_class, loaded);
+    instantiator_type_arguments = BuildInstantiatorTypeArguments(
+        token_pos, instantiator_class, instantiator);
   }
-  *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue() {
   return Bind(new(Z) ConstantInstr(Object::ZoneHandle(Z, Object::null())));
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableInstr* EffectGraphVisitor::BuildAssertAssignable(
     intptr_t token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
-  Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   if (dst_type.IsInstantiated()) {
-    instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
-    BuildTypecheckArguments(token_pos,
-                            &instantiator,
-                            &instantiator_type_arguments);
+    BuildTypecheckArguments(token_pos, &instantiator_type_arguments);
   }
 
   const intptr_t deopt_id = Thread::Current()->GetNextDeoptId();
   return new(Z) AssertAssignableInstr(token_pos,
                                       value,
-                                      instantiator,
                                       instantiator_type_arguments,
                                       dst_type,
                                       dst_name,
                                       deopt_id);
 }
 
 
 // Used for type casts and to test assignments.
 Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_pos,
                                                 Value* value,
@@ skipping 81 matching lines @@
           arguments,
           Object::null_array(),  // No argument names.
           kNumArgsChecked,
           owner()->ic_data_array());
       ReturnDefinition(call);
       return;
     }
   }
 
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
-  PushArgumentInstr* push_instantiator = NULL;
   PushArgumentInstr* push_type_args = NULL;
   if (type.IsInstantiated()) {
-    push_instantiator = PushArgument(BuildNullValue());
     push_type_args = PushArgument(BuildNullValue());
   } else {
-    BuildTypecheckPushArguments(node->token_pos(),
-                                &push_instantiator,
-                                &push_type_args);
+    BuildTypecheckPushArguments(node->token_pos(), &push_type_args);
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(Z) ZoneGrowableArray<PushArgumentInstr*>(5);
+      new(Z) ZoneGrowableArray<PushArgumentInstr*>(4);
   arguments->Add(push_left);
-  arguments->Add(push_instantiator);
   arguments->Add(push_type_args);
   ASSERT(!node->right()->AsTypeNode()->type().IsNull());
   Value* type_const = Bind(new(Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_const));
   const Bool& negate = Bool::Get(node->kind() == Token::kISNOT);
   Value* negate_arg = Bind(new(Z) ConstantInstr(negate));
   arguments->Add(PushArgument(negate_arg));
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new(Z) InstanceCallInstr(
       node->token_pos(),
@@ skipping 23 matching lines @@
                        dst_name)) {
     // Check for javascript compatibility.
     // Do not skip type check if javascript compatibility warning is required.
     if (!FLAG_warn_on_javascript_compatibility ||
         !owner()->WarnOnJSIntegralNumTypeTest(node->left(), type)) {
       ReturnValue(for_value.value());
       return;
     }
   }
   PushArgumentInstr* push_left = PushArgument(for_value.value());
-  PushArgumentInstr* push_instantiator = NULL;
   PushArgumentInstr* push_type_args = NULL;
   if (type.IsInstantiated()) {
-    push_instantiator = PushArgument(BuildNullValue());
     push_type_args = PushArgument(BuildNullValue());
   } else {
-    BuildTypecheckPushArguments(node->token_pos(),
-                                &push_instantiator,
-                                &push_type_args);
+    BuildTypecheckPushArguments(node->token_pos(), &push_type_args);
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(Z) ZoneGrowableArray<PushArgumentInstr*>(4);
+      new(Z) ZoneGrowableArray<PushArgumentInstr*>(3);
   arguments->Add(push_left);
-  arguments->Add(push_instantiator);
   arguments->Add(push_type_args);
   Value* type_arg = Bind(new(Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_arg));
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new(Z) InstanceCallInstr(
       node->token_pos(),
       Library::PrivateCoreLibName(Symbols::_as()),
       node->kind(),
       arguments,
       Object::null_array(),  // No argument names.
       kNumArgsChecked,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 StrictCompareInstr* EffectGraphVisitor::BuildStrictCompare(AstNode* left,
                                                            AstNode* right,
                                                            Token::Kind kind,
                                                            intptr_t token_pos) {
   ValueGraphVisitor for_left_value(owner());
   left->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner());
   right->Visit(&for_right_value);
   Append(for_right_value);
   StrictCompareInstr* comp = new(Z) StrictCompareInstr(token_pos,
-                                                    kind,
-                                                    for_left_value.value(),
-                                                    for_right_value.value(),
-                                                    true);  // Number check.
+                                                       kind,
+                                                       for_left_value.value(),
+                                                       for_right_value.value(),
+                                                       true);  // Number check.
   return comp;
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsTypeTestOperator(node->kind())) {
     BuildTypeTest(node);
@@ skipping 2840 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart