Refactor building arguments for InstanceCall and fix deoptimization environment for pushed argument…

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 541 matching lines @@
     if (node->kind() == Token::kAND) {
       Join(for_left, for_right, empty);
     } else {
       Join(for_left, empty, for_right);
     }
     return;
   }
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
+  PushArgumentInstr* push_left = PushArgument(for_left_value.value());
+
   ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
-  ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
-  arguments->Add(for_left_value.value());
-  arguments->Add(for_right_value.value());
+  PushArgumentInstr* push_right = PushArgument(for_right_value.value());
+
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(2);
+  arguments->Add(push_left);
+  arguments->Add(push_right);
   const String& name = String::ZoneHandle(Symbols::New(node->Name()));
   InstanceCallComp* call = new InstanceCallComp(node->token_pos(),
                                                 owner()->try_index(),
                                                 name,
                                                 node->kind(),
                                                 arguments,
                                                 Array::ZoneHandle(),
                                                 2);
   ReturnComputation(call);
 }
@@ skipping 323 matching lines @@
                                      owner()->try_index(),
                                      value));
     }
     BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
   ValueGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
-  ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
-  arguments->Add(for_value.value());
+  PushArgumentInstr* push_value = PushArgument(for_value.value());
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(1);
+  arguments->Add(push_value);
   Token::Kind token_kind =
       (node->kind() == Token::kSUB) ? Token::kNEGATE : node->kind();
-
   const String& name =
       String::ZoneHandle(Symbols::New(Token::Str(token_kind)));
   InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(), owner()->try_index(), name, token_kind,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
@@ skipping 493 matching lines @@
     ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     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);
+  int length = node->arguments()->length();

[Vyacheslav Egorov (Google), 2012/07/30 13:17:58]

const int length

[Florian Schneider, 2012/07/30 13:26:14]

Done.

 
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
-  values->Add(for_receiver.value());
+  PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(length + 1);
+  arguments->Add(push_receiver);
 
-  TranslateArgumentList(*arguments, values);
+  BuildPushArguments(*node->arguments(), arguments);
   InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(), owner()->try_index(),
-      node->function_name(), Token::kILLEGAL, values,
-      arguments->names(), 1);
+      node->function_name(), Token::kILLEGAL, arguments,
+      node->arguments()->names(), 1);
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   int length = node->arguments()->length();
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(length);
@@ skipping 310 matching lines @@
       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);
   Append(for_receiver);
-  ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
-  arguments->Add(for_receiver.value());
+  PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
+  ZoneGrowableArray<PushArgumentInstr*>* arguments =
+      new ZoneGrowableArray<PushArgumentInstr*>(1);
+  arguments->Add(push_receiver);
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallComp* call = new InstanceCallComp(
       node->token_pos(), owner()->try_index(), name, Token::kGET,
       arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterValues(
@@ skipping 866 matching lines @@
       if ((as_bind != NULL) && as_bind->computation()->IsStoreLocal()) {
         // For each use of a StoreLocal: Replace it with the value from the
         // environment.
         Computation* comp = as_bind->computation();
         intptr_t index =
             comp->AsStoreLocal()->local().BitIndexIn(fixed_parameter_count);
         current->SetInputAt(i, CopyValue((*env)[index]));
       }
     }
 
+    // Drop pushed arguments for calls.
+    for (intptr_t j = 0; j < current->ArgumentCount(); j++) {
+      env->RemoveLast();
+    }
+
     // 2b. Handle LoadLocal and StoreLocal.
     // For each LoadLocal: Remove it from the graph.
     // For each StoreLocal: Remove it from the graph and update the environment.
     BindInstr* bind = current->AsBind();
     if (bind != NULL) {
       LoadLocalComp* load = bind->computation()->AsLoadLocal();
       StoreLocalComp* store = bind->computation()->AsStoreLocal();
       if ((load != NULL) || (store != NULL)) {
         intptr_t index;
         if (store != NULL) {
@@ skipping 13 matching lines @@
         it.RemoveCurrentFromGraph();
       } else {
         // Not a load or store.
         if (bind->is_used()) {
           // Assign fresh SSA temporary and update expression stack.
           bind->set_ssa_temp_index(alloc_ssa_temp_index());
           env->Add(new UseVal(bind));
         }
       }
     }
+
+    // 2c. Handle pushed argument.
+    PushArgumentInstr* push = current->AsPushArgument();
+    if (push != NULL) {
+      env->Add(push->value());
+    }
   }
 
   // 3. Process dominated blocks.
   for (intptr_t i = 0; i < block_entry->dominated_blocks().length(); ++i) {
     BlockEntryInstr* block = block_entry->dominated_blocks()[i];
     GrowableArray<Value*> new_env(env->length());
     new_env.AddArray(*env);
     RenameRecursive(block, &new_env, var_count, fixed_parameter_count);
   }
 
@@ skipping 28 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