Set previous pointer to graph entry for initial definitions.

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 31 matching lines @@
   for (intptr_t i = 0; i < graph_entry_->initial_definitions()->length(); ++i) {
     ConstantInstr* constant =
         (*graph_entry_->initial_definitions())[i]->AsConstant();
     if ((constant != NULL) && (constant->value().raw() == object.raw())) {
       return constant;
     }
   }
   // Otherwise, allocate and add it to the pool.
   ConstantInstr* constant = new ConstantInstr(object);
   constant->set_ssa_temp_index(alloc_ssa_temp_index());
-  graph_entry_->initial_definitions()->Add(constant);
+  AddToInitialDefinitions(constant);
   return constant;
 }
 
+void FlowGraph::AddToInitialDefinitions(Definition* defn) {
+  // TODO(zerny): Set previous to the graph entry so it is accessible by
+  // GetBlock. Remove this once there is a direct pointer to the block.
+  defn->set_previous(graph_entry_);
+  graph_entry_->initial_definitions()->Add(defn);
+}
+
 
 void FlowGraph::DiscoverBlocks() {
   // Initialize state.
   preorder_.Clear();
   postorder_.Clear();
   reverse_postorder_.Clear();
   parent_.Clear();
   assigned_vars_.Clear();
   // Perform a depth-first traversal of the graph to build preorder and
   // postorder block orders.
@@ skipping 429 matching lines @@
                        GrowableArray<Definition*>* inlining_parameters) {
   // TODO(fschneider): Support catch-entry.
   if (graph_entry_->SuccessorCount() > 1) {
     Bailout("Catch-entry support in SSA.");
   }
 
   // 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_->initial_definitions()->Add(constant_null);
+  ConstantInstr* constant_null =
+      AddConstantToInitialDefinitions(Object::ZoneHandle());
 
   // Add parameters to the initial definitions and renaming environment.
   if (inlining_parameters != NULL) {
     // Use known parameters.
     ASSERT(parameter_count() == inlining_parameters->length());
     for (intptr_t i = 0; i < parameter_count(); ++i) {
       Definition* defn = (*inlining_parameters)[i];
       defn->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
-      graph_entry_->initial_definitions()->Add(defn);
+      AddToInitialDefinitions(defn);
       env.Add(defn);
     }
   } else {
     // Create new parameters.
     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.
-      graph_entry_->initial_definitions()->Add(param);
+      AddToInitialDefinitions(param);
       env.Add(param);
     }
   }
 
   // Initialize all locals with #null in the renaming environment.
   for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
     env.Add(constant_null);
   }
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
@@ skipping 467 matching lines @@
          !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 }  // namespace dart