Use the constant pool for all constants, not just null.

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 16 matching lines @@
     num_stack_locals_(builder.num_stack_locals()),
     graph_entry_(graph_entry),
     preorder_(),
     postorder_(),
     reverse_postorder_(),
     block_effects_(NULL) {
   DiscoverBlocks();
 }
 
 
-ConstantInstr* FlowGraph::AddConstantToInitialDefinitions(
-    const Object& object) {
+ConstantInstr* FlowGraph::GetConstant(const Object& object) {
   // Check if the constant is already in the pool.
-  for (intptr_t i = 0; i < graph_entry_->initial_definitions()->length(); ++i) {
-    ConstantInstr* constant =
-        (*graph_entry_->initial_definitions())[i]->AsConstant();
+  GrowableArray<Definition*>* pool = graph_entry_->initial_definitions();
+  for (intptr_t i = 0; i < pool->length(); ++i) {
+    ConstantInstr* constant = (*pool)[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());
   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::InsertBefore(Instruction* next,
                              Instruction* instr,
@@ skipping 554 matching lines @@
                        ZoneGrowableArray<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.
-  constant_null_ =
-      AddConstantToInitialDefinitions(Object::ZoneHandle());
+  constant_null_ = GetConstant(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.
       AddToInitialDefinitions(defn);
       env.Add(defn);
@@ skipping 51 matching lines @@
           phi->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
         }
       }
     }
   }
 
   // Attach environment to the block entry.
   AttachEnvironment(block_entry, env);
 
   // 2. Process normal instructions.
-
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
 
     // Attach current environment to the instructions that need it.
     if (current->NeedsEnvironment()) {
       AttachEnvironment(current, env);
     }
 
     // 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.
+    // Update the expression stack renaming environment for each use by
+    // removing the renamed value.
+    // For each use of a LoadLocal, StoreLocal, or Constant: Replace it with
+    // the renamed value.
     for (intptr_t i = current->InputCount() - 1; i >= 0; --i) {
       Value* v = current->InputAt(i);
       // Update expression stack.
       ASSERT(env->length() > variable_count());
 
       Definition* reaching_defn = env->RemoveLast();
-
       Definition* input_defn = v->definition();
-      if (input_defn->IsLoadLocal() || input_defn->IsStoreLocal()) {
+      if (input_defn->IsLoadLocal() ||
+          input_defn->IsStoreLocal() ||
+          input_defn->IsConstant()) {
         // Remove the load/store from the graph.
         input_defn->RemoveFromGraph();
         // Assert we are not referencing nulls in the initial environment.
         ASSERT(reaching_defn->ssa_temp_index() != -1);
         v->set_definition(reaching_defn);
         input_defn = reaching_defn;
       }
       input_defn->AddInputUse(v);
     }
 
     // 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.
+    // 2b. Handle LoadLocal, StoreLocal, and Constant.
     Definition* definition = current->AsDefinition();
     if (definition != NULL) {
       LoadLocalInstr* load = definition->AsLoadLocal();
       StoreLocalInstr* store = definition->AsStoreLocal();
-      if ((load != NULL) || (store != NULL)) {
+      ConstantInstr* constant = definition->AsConstant();
+      if ((load != NULL) || (store != NULL) || (constant != NULL)) {
         intptr_t index;
         Definition* result;
         if (store != NULL) {
           // Update renaming environment.
           index = store->local().BitIndexIn(num_non_copied_params_);
           result = store->value()->definition();
 
           if (variable_liveness->IsStoreAlive(block_entry, store)) {
             (*env)[index] = result;
           } else {
             (*env)[index] = constant_null();
           }
-        } else {
+        } else if (load != NULL) {
           // The graph construction ensures we do not have an unused LoadLocal
           // computation.
           ASSERT(definition->is_used());
           index = load->local().BitIndexIn(num_non_copied_params_);
           result = (*env)[index];
 
           PhiInstr* phi = result->AsPhi();
           if ((phi != NULL) && !phi->is_alive()) {
             phi->mark_alive();
             live_phis->Add(phi);
           }
 
           if (variable_liveness->IsLastLoad(block_entry, load)) {
             (*env)[index] = constant_null();
           }
+        } else {
+          ASSERT(definition->is_used());
+          result = GetConstant(constant->value());
         }
         // Update expression stack or remove from graph.
         if (definition->is_used()) {
+          ASSERT(result != NULL);
           env->Add(result);
-          // We remove load/store instructions when we find their use in 2a.
+          // We remove load/store/constant instructions when we find their
+          // use in 2a.
         } else {
           it.RemoveCurrentFromGraph();
         }
       } else {
-        // Not a load or store.
+        // Not a load, store, or constant.
         if (definition->is_used()) {
           // Assign fresh SSA temporary and update expression stack.
           definition->set_ssa_temp_index(alloc_ssa_temp_index());
           env->Add(definition);
         }
       }
     }
 
     // 2c. Handle pushed argument.
     PushArgumentInstr* push = current->AsPushArgument();
@@ skipping 258 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart