When replacing one value with another ensure that replacement has SSA index assigned.

runtime/vm/flow_graph_optimizer.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_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 99 matching lines @@
         call->deopt_id(),
         class_ids.length()));
     ic_data.AddReceiverCheck(class_ids[0], function);
     call->set_ic_data(&ic_data);
     return true;
   }
   return false;
 }
 
 
+static void EnsureSSATempIndex(FlowGraph* graph,
+                               Definition* defn,
+                               Definition* replacement) {
+  if ((replacement->ssa_temp_index() == -1) &&
+      (defn->ssa_temp_index() != -1)) {
+    replacement->set_ssa_temp_index(graph->alloc_ssa_temp_index());
+  }
+}
+
+
 static void ReplaceCurrentInstruction(ForwardInstructionIterator* it,
                                       Instruction* current,
-                                      Instruction* replacement) {
+                                      Instruction* replacement,
+                                      FlowGraph* graph) {
   if ((replacement != NULL) && current->IsDefinition()) {
     Definition* current_defn = current->AsDefinition();
     Definition* replacement_defn = replacement->AsDefinition();
     ASSERT(replacement_defn != NULL);
     current_defn->ReplaceUsesWith(replacement_defn);
+    EnsureSSATempIndex(graph, current_defn, replacement_defn);
 
     if (FLAG_trace_optimization) {
       OS::Print("Replacing v%"Pd" with v%"Pd"\n",
                 current_defn->ssa_temp_index(),
                 replacement_defn->ssa_temp_index());
     }
   } else if (FLAG_trace_optimization) {
     ASSERT(!current->IsDefinition() ||
            ((current->AsDefinition()->input_use_list() == NULL) &&
             (current->AsDefinition()->env_use_list() == NULL)));
@@ skipping 12 matching lines @@
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
     entry->Accept(this);
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
       Instruction* replacement = current->Canonicalize(this);
       if (replacement != current) {
         // For non-definitions Canonicalize should return either NULL or
         // this.
         ASSERT((replacement == NULL) || current->IsDefinition());
-        ReplaceCurrentInstruction(&it, current, replacement);
+        ReplaceCurrentInstruction(&it, current, replacement, flow_graph_);
       }
     }
   }
 }
 
 
 void FlowGraphOptimizer::InsertConversion(Representation from,
                                           Representation to,
                                           Instruction* instr,
                                           Value* use,
@@ skipping 2927 matching lines @@
         Definition* defn = instr->AsDefinition();
         if ((defn == NULL) || !IsLoadEliminationCandidate(defn)) {
           continue;
         }
 
         const intptr_t expr_id = defn->expr_id();
         if (gen->Contains(expr_id)) {
           // This is a locally redundant load.
           ASSERT((out_values != NULL) && ((*out_values)[expr_id] != NULL));
 
+          Definition* replacement = (*out_values)[expr_id];
+          EnsureSSATempIndex(graph_, defn, replacement);
           if (FLAG_trace_optimization) {
             OS::Print("Replacing load v%"Pd" with v%"Pd"\n",
                       defn->ssa_temp_index(),
-                      (*out_values)[expr_id]->ssa_temp_index());
+                      replacement->ssa_temp_index());
           }
 
-          defn->ReplaceUsesWith((*out_values)[expr_id]);
+          defn->ReplaceUsesWith(replacement);
           instr_it.RemoveCurrentFromGraph();
           continue;
         } else if (!kill->Contains(expr_id)) {
           // This is an exposed load: it is the first representative of a
           // given expression id and it is not killed on the path from
           // the block entry.
           if (exposed_values == NULL) {
             static const intptr_t kMaxExposedValuesInitialSize = 5;
             exposed_values = new ZoneGrowableArray<Definition*>(
                 Utils::Minimum(kMaxExposedValuesInitialSize, max_expr_id_));
@@ skipping 181 matching lines @@
         Definition* replacement = MergeIncomingValues(block, load->expr_id());
 
         // Sets of outgoing values are not linked into use lists so
         // they might contain values that were replace and removed
         // from the graph by this iteration.
         // To prevent using them we additionally mark definitions themselves
         // as replaced and store a pointer to the replacement.
         replacement = replacement->Replacement();
 
         if (load != replacement) {
+          EnsureSSATempIndex(graph_, load, replacement);
+
           if (FLAG_trace_optimization) {
             OS::Print("Replacing load v%"Pd" with v%"Pd"\n",
                       load->ssa_temp_index(),
                       replacement->ssa_temp_index());
           }
 
           load->ReplaceUsesWith(replacement);
           load->RemoveFromGraph();
           load->SetReplacement(replacement);
         }
@@ skipping 116 matching lines @@
     DirectChainedHashMap<LoadKeyValueTrait> map;
     const intptr_t max_expr_id =
         NumberLoadExpressions(graph, &map, &kill_by_offs);
     if (max_expr_id > 0) {
       LoadOptimizer load_optimizer(graph, max_expr_id, &map, kill_by_offs);
       load_optimizer.Optimize();
     }
   }
 
   DirectChainedHashMap<PointerKeyValueTrait<Instruction> > map;
-  changed = OptimizeRecursive(graph->graph_entry(), &map) || changed;
+  changed = OptimizeRecursive(graph, graph->graph_entry(), &map) || changed;
 
   return changed;
 }
 
 
 bool DominatorBasedCSE::OptimizeRecursive(
+    FlowGraph* graph,
     BlockEntryInstr* block,
     DirectChainedHashMap<PointerKeyValueTrait<Instruction> >* map) {
   bool changed = false;
   for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     if (current->AffectedBySideEffect()) continue;
     Instruction* replacement = map->Lookup(current);
     if (replacement == NULL) {
       map->Insert(current);
       continue;
     }
     // Replace current with lookup result.
-    ReplaceCurrentInstruction(&it, current, replacement);
+    ReplaceCurrentInstruction(&it, current, replacement, graph);
     changed = true;
   }
 
   // Process children in the dominator tree recursively.
   intptr_t num_children = block->dominated_blocks().length();
   for (intptr_t i = 0; i < num_children; ++i) {
     BlockEntryInstr* child = block->dominated_blocks()[i];
     if (i  < num_children - 1) {
       // Copy map.
       DirectChainedHashMap<PointerKeyValueTrait<Instruction> > child_map(*map);
-      changed = OptimizeRecursive(child, &child_map) || changed;
+      changed = OptimizeRecursive(graph, child, &child_map) || changed;
     } else {
       // Reuse map for the last child.
-      changed = OptimizeRecursive(child, map) || changed;
+      changed = OptimizeRecursive(graph, child, map) || changed;
     }
   }
   return changed;
 }
 
 
 ConstantPropagator::ConstantPropagator(
     FlowGraph* graph,
     const GrowableArray<BlockEntryInstr*>& ignored)
     : FlowGraphVisitor(ignored),
@@ skipping 837 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart