Reapply "Added support for copied parameters to the SSA compiler."

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/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 2279 matching lines @@
   TargetEntryInstr* normal_entry = new TargetEntryInstr();
   graph_entry_ = new GraphEntryInstr(normal_entry);
   EffectGraphVisitor for_effect(this, 0);
   parsed_function().node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   GrowableArray<intptr_t> parent;
   GrowableArray<BitVector*> assigned_vars;
 
-  const intptr_t fixed_parameter_count =
-      parsed_function_.function().num_fixed_parameters();
-  const intptr_t variable_count = fixed_parameter_count +
-      parsed_function_.copied_parameter_count() +
-      parsed_function_.stack_local_count();
+  // Either all parameters are fixed (none are named) or they are all copied.
+  // This could change, so we keep fixed/copied counts separate.
+  intptr_t fixed_parameter_count;  // This is really the "non-copied" count.
+  intptr_t copied_parameter_count;
+  if (parsed_function_.copied_parameter_count() > 0) {
+    fixed_parameter_count = 0;
+    copied_parameter_count = parsed_function_.copied_parameter_count();
+  } else {
+    fixed_parameter_count = parsed_function_.function().num_fixed_parameters();
+    copied_parameter_count = 0;
+  }
+  const intptr_t stack_local_count = parsed_function_.stack_local_count();
+  const intptr_t variable_count =
+      stack_local_count + fixed_parameter_count + copied_parameter_count;
+
   // Perform a depth-first traversal of the graph to build preorder and
   // postorder block orders.
   graph_entry_->DiscoverBlocks(NULL,  // Entry block predecessor.
                                &preorder_block_entries_,
                                &postorder_block_entries_,
                                &parent,
                                &assigned_vars,
                                variable_count,
                                fixed_parameter_count);
   // Number blocks in reverse postorder.
@@ skipping 15 matching lines @@
     }
   }
 
   if (for_optimized && use_ssa) {
     GrowableArray<BitVector*> dominance_frontier;
     ComputeDominators(&preorder_block_entries_, &parent, &dominance_frontier);
     InsertPhis(preorder_block_entries_,
                assigned_vars,
                variable_count,
                dominance_frontier);
-    Rename(variable_count);
+    Rename(stack_local_count, fixed_parameter_count, copied_parameter_count);
   }
   if (FLAG_print_flow_graph || (Dart::flow_graph_writer() != NULL)) {
     intptr_t length = postorder_block_entries_.length();
     GrowableArray<BlockEntryInstr*> reverse_postorder(length);
     for (intptr_t i = length - 1; i >= 0; --i) {
       reverse_postorder.Add(postorder_block_entries_[i]);
     }
     if (FLAG_print_flow_graph) {
       // Print flow graph to stdout.
       FlowGraphPrinter printer(function, reverse_postorder);
@@ skipping 181 matching lines @@
             work[index] = var_index;
             worklist.Add(block);
           }
         }
       }
     }
   }
 }
 
 
-void FlowGraphBuilder::Rename(intptr_t var_count) {
-  // TODO(fschneider): Store var_count in the FlowGraphBuilder instead of
+void FlowGraphBuilder::Rename(intptr_t stack_local_count,
+                              intptr_t fixed_parameter_count,
+                              intptr_t copied_parameter_count) {
+  // TODO(fschneider): Store counts in the FlowGraphBuilder instead of
   // passing it around.
   // TODO(fschneider): Support catch-entry.
   if (graph_entry_->SuccessorCount() > 1) {
     Bailout("Catch-entry support in SSA.");
   }
-  // TODO(fschneider): Support copied parameters.
-  if (parsed_function().copied_parameter_count() != 0) {
-    Bailout("Copied parameter support in SSA");
-  }
-  ASSERT(var_count == (parsed_function().stack_local_count() +
-                       parsed_function().function().num_fixed_parameters()));
+
+  const intptr_t parameter_count =
+      fixed_parameter_count + copied_parameter_count;
+  const intptr_t variable_count = parameter_count + stack_local_count;
 
   // Initialize start environment.
-  GrowableArray<Value*> start_env(var_count);
+  GrowableArray<Value*> start_env(variable_count);
   intptr_t i = 0;
-  const intptr_t fixed_parameter_count =
-      parsed_function().function().num_fixed_parameters();
-  for (; i < fixed_parameter_count; ++i) {
+  for (; i < parameter_count; ++i) {
     ParameterInstr* param = new ParameterInstr(i);
     param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
     start_env.Add(new UseVal(param));
   }
 
   // All locals are initialized with #null.
   Value* null_value = new ConstantVal(Object::ZoneHandle());
-  for (; i < var_count; i++) {
+  for (; i < variable_count; i++) {
     start_env.Add(null_value);
   }
   graph_entry_->set_start_env(
       new Environment(start_env, fixed_parameter_count));
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
   ASSERT(normal_entry != NULL);  // Must have entry.
-  GrowableArray<Value*> env(var_count);
+  GrowableArray<Value*> env(variable_count);
   env.AddArray(start_env);
-  RenameRecursive(normal_entry, &env, var_count, fixed_parameter_count);
+  RenameRecursive(normal_entry, &env, variable_count, fixed_parameter_count);
 }
 
 
 // Helper to a copy a value iff it is a UseVal.
 static Value* CopyValue(Value* value) {
   return value->IsUse()
       ? new UseVal(value->AsUse()->definition())
       : value;
 }
 
@@ skipping 135 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