Add explicit PushArgument IL instructions to static calls.

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/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 181 matching lines @@
     Goto(join);
     body_exit->Goto(join);
   }
 
   // 3. Set the exit to the graph to be the false successor of the test, a
   // fresh target node
   exit_ = *test_fragment.false_successor_address() = new TargetEntryInstr();
 }
 
 
+PushArgumentInstr* EffectGraphVisitor::PushArgument(Value* value) {
+  PushArgumentInstr* result = new PushArgumentInstr(value);
+  AddInstruction(result);
+  return result;
+}
+
+
 Computation* EffectGraphVisitor::BuildStoreLocal(
     const LocalVariable& local, Value* value) {
   if (local.is_captured()) {
     intptr_t delta = owner()->context_level() -
                      local.owner()->context_level();
     ASSERT(delta >= 0);
     Value* context = Bind(new CurrentContextComp());
     while (delta-- > 0) {
       context = Bind(new LoadVMFieldComp(
           context, Context::parent_offset(), Type::ZoneHandle()));
@@ skipping 1149 matching lines @@
     }
     receiver = BuildNullValue();
   } else if (function.IsImplicitInstanceClosureFunction()) {
     ValueGraphVisitor for_receiver(owner(), temp_index());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     receiver = for_receiver.value();
   } else {
     receiver = BuildNullValue();
   }
-  PushArgumentInstr* push_receiver = new PushArgumentInstr(receiver);
+  PushArgumentInstr* push_receiver = PushArgument(receiver);
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_receiver);
-  AddInstruction(push_receiver);
   ASSERT(function.context_scope() != ContextScope::null());
 
   // The function type of a closure may have type arguments. In that case, pass
   // the type arguments of the instantiator. Otherwise, pass null object.
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     type_arguments = BuildInstantiatorTypeArguments(node->token_pos(), NULL);
   } else {
     type_arguments = BuildNullValue();
   }
-  PushArgumentInstr* push_type_arguments =
-      new PushArgumentInstr(type_arguments);
+  PushArgumentInstr* push_type_arguments = PushArgument(type_arguments);
   arguments->Add(push_type_arguments);
-  AddInstruction(push_type_arguments);
   ReturnComputation(
       new CreateClosureComp(node, owner()->try_index(), arguments));
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     ZoneGrowableArray<Value*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     values->Add(for_argument.value());
   }
 }
 
 
 void EffectGraphVisitor::BuildPushArguments(
     const ArgumentListNode& node,
     ZoneGrowableArray<PushArgumentInstr*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
-    PushArgumentInstr* push_arg = new PushArgumentInstr(for_argument.value());
-    AddInstruction(push_arg);
+    PushArgumentInstr* push_arg = PushArgument(for_argument.value());
     values->Add(push_arg);
   }
 }
 
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
   ArgumentListNode* arguments = node->arguments();
   int length = arguments->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
 
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   values->Add(for_receiver.value());
 
   TranslateArgumentList(*arguments, values);
   InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(), owner()->try_index(),
       node->function_name(), Token::kILLEGAL, values,
       arguments->names(), 1);
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   int length = node->arguments()->length();
-  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
-  TranslateArgumentList(*node->arguments(), values);
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(length);
+  BuildPushArguments(*node->arguments(), arguments);
   StaticCallComp* call =
       new StaticCallComp(node->token_pos(),
                          owner()->try_index(),
                          node->function(),
                          node->arguments()->names(),
-                         values);
+                         arguments);
   ReturnComputation(call);
 }
 
 
 ClosureCallComp* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
   ValueGraphVisitor for_closure(owner(), temp_index());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
-  PushArgumentInstr* push_closure = new PushArgumentInstr(for_closure.value());
-  AddInstruction(push_closure);
+  PushArgumentInstr* push_closure = PushArgument(for_closure.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   // Save context around the call.
   BuildStoreContext(*owner()->parsed_function().expression_temp_var());
   return new ClosureCallComp(node, owner()->try_index(), arguments);
 }
@@ skipping 53 matching lines @@
                                                           allocate_arguments);
   } else {
     allocate_comp = new AllocateObjectComp(node,
                                            owner()->try_index(),
                                            allocate_arguments);
   }
   return Bind(allocate_comp);
 }
 
 
-void EffectGraphVisitor::BuildConstructorCall(ConstructorCallNode* node,
-                                              Value* alloc_value) {
+void EffectGraphVisitor::BuildConstructorCall(
+    ConstructorCallNode* node,
+    PushArgumentInstr* push_alloc_value) {
   Value* ctor_arg = Bind(
       new ConstantVal(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
+  PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
 
-  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
-  values->Add(alloc_value);
-  values->Add(ctor_arg);
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(2);
+  arguments->Add(push_alloc_value);
+  arguments->Add(push_ctor_arg);
 
-  TranslateArgumentList(*node->arguments(), values);
+  BuildPushArguments(*node->arguments(), arguments);
   Do(new StaticCallComp(node->token_pos(),
                         owner()->try_index(),
                         node->constructor(),
                         node->arguments()->names(),
-                        values));
+                        arguments));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
-    ZoneGrowableArray<Value*>* factory_arguments =
-        new ZoneGrowableArray<Value*>();
-    factory_arguments->Add(
+    ZoneGrowableArray<PushArgumentInstr*>* arguments =
+        new ZoneGrowableArray<PushArgumentInstr*>();
+    PushArgumentInstr* push_type_arguments = PushArgument(
         BuildInstantiatedTypeArguments(node->token_pos(),
                                        node->type_arguments()));
-    ASSERT(factory_arguments->length() == 1);
-    TranslateArgumentList(*node->arguments(), factory_arguments);
+    arguments->Add(push_type_arguments);
+    ASSERT(arguments->length() == 1);
+    BuildPushArguments(*node->arguments(), arguments);
     StaticCallComp* call =
         new StaticCallComp(node->token_pos(),
                            owner()->try_index(),
                            node->constructor(),
                            node->arguments()->names(),
-                           factory_arguments);
+                           arguments);
     ReturnComputation(call);
     return;
   }
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
-  Value* allocate = BuildObjectAllocation(node);
-  BuildConstructorCall(node, allocate);
+  Value* allocated_value = BuildObjectAllocation(node);
+  PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
+  BuildConstructorCall(node, push_allocated_value);
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiator() {
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     return NULL;
   }
   Function& outer_function =
@@ skipping 148 matching lines @@
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n, t_n+1, ...)
   //   tn       <- LoadLocal(temp)
 
   Value* allocate = BuildObjectAllocation(node);
   Computation* store_allocated = BuildStoreLocal(
       node->allocated_object_var(),
       allocate);
   Value* allocated_value = Bind(store_allocated);
-  BuildConstructorCall(node, allocated_value);
+  PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
+  BuildConstructorCall(node, push_allocated_value);
   Computation* load_allocated = BuildLoadLocal(
       node->allocated_object_var());
   allocated_value = Bind(load_allocated);
   ReturnValue(allocated_value);
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
@@ skipping 50 matching lines @@
        BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::Handle(Field::GetterName(node->field_name()));
   const Function& getter_function =
       Function::ZoneHandle(node->cls().LookupStaticFunction(getter_name));
   ASSERT(!getter_function.IsNull());
-  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>();
   StaticCallComp* call = new StaticCallComp(node->token_pos(),
                                             owner()->try_index(),
                                             getter_function,
                                             Array::ZoneHandle(),  // No names.
-                                            values);
+                                            arguments);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStaticSetterNode(StaticSetterNode* node) {
   const String& setter_name =
       String::Handle(Field::SetterName(node->field_name()));
   const Function& setter_function =
       Function::ZoneHandle(node->cls().LookupStaticFunction(setter_name));
   ASSERT(!setter_function.IsNull());
@@ skipping 883 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(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