Implement new optional parameters syntax in the vm (issue 4290).

runtime/vm/flow_graph.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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
 #include "vm/growable_array.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_optimization);
 
 FlowGraph::FlowGraph(const FlowGraphBuilder& builder,
                      GraphEntryInstr* graph_entry)
   : parent_(),
     assigned_vars_(),
     current_ssa_temp_index_(0),
     parsed_function_(builder.parsed_function()),
-    copied_parameter_count_(builder.copied_parameter_count()),
-    non_copied_parameter_count_(builder.non_copied_parameter_count()),
-    stack_local_count_(builder.stack_local_count()),
+    num_copied_params_(builder.num_copied_params()),
+    num_non_copied_params_(builder.num_non_copied_params()),
+    num_stack_locals_(builder.num_stack_locals()),
     graph_entry_(graph_entry),
     preorder_(),
     postorder_(),
     reverse_postorder_(),
     exits_(NULL) {
   DiscoverBlocks();
 }
 
 
 void FlowGraph::DiscoverBlocks() {
   // Initialize state.
   preorder_.TruncateTo(0);
   postorder_.TruncateTo(0);
   reverse_postorder_.TruncateTo(0);
   parent_.TruncateTo(0);
   assigned_vars_.TruncateTo(0);
   // Perform a depth-first traversal of the graph to build preorder and
   // postorder block orders.
   graph_entry_->DiscoverBlocks(NULL,  // Entry block predecessor.
                                &preorder_,
                                &postorder_,
                                &parent_,
                                &assigned_vars_,
                                variable_count(),
-                               non_copied_parameter_count());
+                               num_non_copied_params());
   // Number blocks in reverse postorder.
   intptr_t block_count = postorder_.length();
   for (intptr_t i = 0; i < block_count; ++i) {
     postorder_[i]->set_block_id(block_count - i - 1);
     reverse_postorder_.Add(postorder_[block_count - i - 1]);
   }
   // Link instructions backwards for optimized compilation.
   // TODO(zerny): The builder should do this at construction time.
   for (intptr_t i = 0; i < block_count; ++i) {
     BlockEntryInstr* entry = postorder_[i];
@@ skipping 442 matching lines @@
     param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
     start_env.Add(param);
   }
 
   // All locals are initialized with #null.  Use the global definition, uses
   // will be created in the Environment constructor.
   while (start_env.length() < variable_count()) {
     start_env.Add(graph_entry_->constant_null());
   }
   graph_entry_->set_start_env(
-      new Environment(start_env, non_copied_parameter_count_));
+      new Environment(start_env, num_non_copied_params_));
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
   ASSERT(normal_entry != NULL);  // Must have entry.
   GrowableArray<Definition*> env(variable_count());
   env.AddArray(start_env);
   RenameRecursive(normal_entry, &env, live_phis);
 }
 
 
 void FlowGraph::RenameRecursive(BlockEntryInstr* block_entry,
@@ skipping 12 matching lines @@
       }
     }
   }
 
   // 2. Process normal instructions.
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     // Attach current environment to the instruction. First, each instruction
     // gets a full copy of the environment. Later we optimize this by
     // eliminating unnecessary environments.
-    current->set_env(new Environment(*env, non_copied_parameter_count_));
+    current->set_env(new Environment(*env, num_non_copied_params_));
 
     // 2a. Handle uses:
     // Update expression stack environment for each use.
     // For each use of a LoadLocal or StoreLocal: Replace it with the value
     // from the environment.
     for (intptr_t i = current->InputCount() - 1; i >= 0; --i) {
       Value* v = current->InputAt(i);
       // Update expression stack.
       ASSERT(env->length() > variable_count());
 
@@ skipping 18 matching lines @@
     // 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.
     Definition* definition = current->AsDefinition();
     if (definition != NULL) {
       LoadLocalInstr* load = definition->AsLoadLocal();
       StoreLocalInstr* store = definition->AsStoreLocal();
       if ((load != NULL) || (store != NULL)) {
         intptr_t index;
         if (store != NULL) {
-          index = store->local().BitIndexIn(non_copied_parameter_count_);
+          index = store->local().BitIndexIn(num_non_copied_params_);
           // Update renaming environment.
           (*env)[index] = store->value()->definition();
         } else {
           // The graph construction ensures we do not have an unused LoadLocal
           // computation.
           ASSERT(definition->is_used());
-          index = load->local().BitIndexIn(non_copied_parameter_count_);
+          index = load->local().BitIndexIn(num_non_copied_params_);
 
           PhiInstr* phi = (*env)[index]->AsPhi();
           if ((phi != NULL) && !phi->is_alive()) {
             phi->mark_alive();
             live_phis->Add(phi);
           }
         }
         // Update expression stack or remove from graph.
         if (definition->is_used()) {
           env->Add((*env)[index]);
@@ skipping 189 matching lines @@
   // Remove original arguments to the call.
   for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
     PushArgumentInstr* push = call->ArgumentAt(i);
     push->ReplaceUsesWith(push->value()->definition());
     push->RemoveFromGraph();
   }
 }
 
 
 }  // namespace dart