Replace start_env with initial_definitions in GraphEntryInstr.

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"
@@ skipping 87 matching lines @@
       Value* use = it.CurrentValue();
       use->set_instruction(NULL);
       use->set_use_index(-1);
       use->set_next_use(NULL);
     }
   }
 }
 
 
 bool FlowGraph::ResetUseLists() {
-  // Reset global constants.
-  ResetUseListsInInstruction(graph_entry_->constant_null());
-
-  // Reset definitions referenced from the start environment.
-  for (intptr_t i = 0; i < graph_entry_->start_env()->Length(); ++i) {
-    Value* env_use = graph_entry_->start_env()->ValueAt(i);
-    ResetUseListsInInstruction(env_use->definition());
+  // Reset initial definitions.
+  for (intptr_t i = 0; i < graph_entry_->initial_definitions().length(); ++i) {
+    ResetUseListsInInstruction(graph_entry_->initial_definitions()[i]);
   }
 
   // Reset phis in join entries and the instructions in each block.
   for (intptr_t i = 0; i < preorder_.length(); ++i) {
     BlockEntryInstr* entry = preorder_[i];
     JoinEntryInstr* join = entry->AsJoinEntry();
     if (join != NULL && join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi != NULL) ResetUseListsInInstruction(phi);
@@ skipping 36 matching lines @@
          use = use->next_use()) {
       ASSERT(defn == use->definition());
       ASSERT(use ==
              use->instruction()->env()->ValueAtUseIndex(use->use_index()));
     }
   }
 }
 
 
 bool FlowGraph::ValidateUseLists() {
-  // Validate global constants.
-  ValidateUseListsInInstruction(graph_entry_->constant_null());
-
-  // Validate definitions referenced from the start environment.
-  for (intptr_t i = 0; i < graph_entry_->start_env()->Length(); ++i) {
-    Value* env_use = graph_entry_->start_env()->ValueAt(i);
-    ValidateUseListsInInstruction(env_use->definition());
+  // Validate initial definitions.
+  for (intptr_t i = 0; i < graph_entry_->initial_definitions().length(); ++i) {
+    ValidateUseListsInInstruction(graph_entry_->initial_definitions()[i]);
   }
 
   // Validate phis in join entries and the instructions in each block.
   for (intptr_t i = 0; i < preorder_.length(); ++i) {
     BlockEntryInstr* entry = preorder_[i];
     JoinEntryInstr* join = entry->AsJoinEntry();
     if (join != NULL && join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi != NULL) ValidateUseListsInInstruction(phi);
@@ skipping 91 matching lines @@
         use->set_use_index(pred_index);
         use->AddToInputUseList();
       }
     }
   }
 }
 
 
 void FlowGraph::ComputeUseLists() {
   DEBUG_ASSERT(ResetUseLists());
-  // Clear global constants and definitions in the start environment.
-  ClearUseLists(graph_entry_->constant_null());
-  for (intptr_t i = 0; i < graph_entry_->start_env()->Length(); ++i) {
-    ClearUseLists(graph_entry_->start_env()->ValueAt(i)->definition());
+  // Clear initial definitions.
+  for (intptr_t i = 0; i < graph_entry_->initial_definitions().length(); ++i) {
+    ClearUseLists(graph_entry_->initial_definitions()[i]);
   }
   ComputeUseListsRecursive(graph_entry_);
   DEBUG_ASSERT(ValidateUseLists());
 }
 
 
 void FlowGraph::ComputeSSA(intptr_t next_virtual_register_number) {
   current_ssa_temp_index_ = next_virtual_register_number;
   GrowableArray<BitVector*> dominance_frontier;
   ComputeDominators(&preorder_, &parent_, &dominance_frontier);
@@ skipping 185 matching lines @@
   }
 }
 
 
 void FlowGraph::Rename(GrowableArray<PhiInstr*>* live_phis) {
   // TODO(fschneider): Support catch-entry.
   if (graph_entry_->SuccessorCount() > 1) {
     Bailout("Catch-entry support in SSA.");
   }
 
-  // Name global constants.
+  // Initial renaming environment.
+  GrowableArray<Definition*> env(variable_count());
+
+  // Add global constants to the initial definitions.
   ConstantInstr* constant_null = new ConstantInstr(Object::ZoneHandle());
   constant_null->set_ssa_temp_index(alloc_ssa_temp_index());
-  graph_entry_->set_constant_null(constant_null);
+  graph_entry_->initial_definitions().Add(constant_null);
 
-  // Initialize start environment.
-  GrowableArray<Definition*> start_env(variable_count());
+  // Add incoming parameters to the initial definitions and the renaming
+  // environment.
   for (intptr_t i = 0; i < parameter_count(); ++i) {
     ParameterInstr* param = new ParameterInstr(i, graph_entry_);
     param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
-    start_env.Add(param);
+    graph_entry_->initial_definitions().Add(param);
+    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());
+  // Initialize all locals with #null in the renaming environment.
+  for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
+    env.Add(constant_null);
   }
-  graph_entry_->set_start_env(
-      Environment::From(start_env,
-                        num_non_copied_params_,
-                        parsed_function_.function()));
 
   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,
                                 GrowableArray<Definition*>* env,
                                 GrowableArray<PhiInstr*>* live_phis) {
   // 1. Process phis first.
   if (block_entry->IsJoinEntry()) {
     JoinEntryInstr* join = block_entry->AsJoinEntry();
@@ skipping 272 matching lines @@
     // TODO(zerny): Support multiple exits.
     UNREACHABLE();
   }
 
   // TODO(zerny): Adjust pre/post orders.
   // TODO(zerny): Update dominator tree.
 }
 
 
 }  // namespace dart