When a value has been optimized away by the compiler, set its value to

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 @@
     builder_(builder),
     parsed_function_(*builder.parsed_function()),
     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_(),
     optimized_block_order_(),
+    constant_null_(NULL),
+    constant_dead_(NULL),
     block_effects_(NULL),
     licm_allowed_(true),
     use_far_branches_(false),
     loop_headers_(NULL),
     loop_invariant_loads_(NULL),
     guarded_fields_(builder.guarded_fields()) {
   DiscoverBlocks();
 }
 
 
@@ skipping 652 matching lines @@
   GraphEntryInstr* entry = graph_entry();
   if (!FLAG_optimize_try_catch && (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_ = GetConstant(Object::ZoneHandle());
+  constant_dead_ = GetConstant(Symbols::OptimizedOut());
 
   // 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 78 matching lines @@
       (*env)[i] = param;
       block_entry->AsCatchBlockEntry()->initial_definitions()->Add(param);
     }
   }
 
   // Prune non-live variables at block entry by replacing their environment
   // slots with null.
   BitVector* live_in = variable_liveness->GetLiveInSet(block_entry);
   for (intptr_t i = 0; i < variable_count(); i++) {
     if (!live_in->Contains(i)) {
-      (*env)[i] = constant_null();
+      (*env)[i] = constant_dead();
     }
   }
 
   // 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();
 
@@ skipping 50 matching lines @@
         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();
+            (*env)[index] = constant_dead();
           }
         } 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();
+            (*env)[index] = constant_dead();
           }
         } else if (push != NULL) {
           result = push->value()->definition();
           env->Add(result);
           it.RemoveCurrentFromGraph();
           continue;
         } else if (drop != NULL) {
           // Drop temps from the environment.
           for (intptr_t j = 0; j < drop->num_temps(); j++) {
             env->RemoveLast();
@@ skipping 287 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart