Support for multiple register values

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 97 matching lines @@
   InsertAfter(next->previous(), instr, env, use_kind);
 }
 
 
 void FlowGraph::InsertAfter(Instruction* prev,
                             Instruction* instr,
                             Environment* env,
                             Definition::UseKind use_kind) {
   if (use_kind == Definition::kValue) {
     ASSERT(instr->IsDefinition());
-    instr->AsDefinition()->set_ssa_temp_index(alloc_ssa_temp_index());
+    Definition* defn = instr->AsDefinition();
+    AllocateSSAIndexes(defn);

[srdjan, 2014/04/07 18:22:50]

AllocateSSAIndexes(instr->AsDefinition()) .. also below ?

[Cutch, 2014/04/08 15:56:16]

Done here and elsewhere.

   }
   instr->InsertAfter(prev);
   ASSERT(instr->env() == NULL);
   if (env != NULL) env->DeepCopyTo(instr);
 }
 
 
 Instruction* FlowGraph::AppendTo(Instruction* prev,
                                  Instruction* instr,
                                  Environment* env,
                                  Definition::UseKind use_kind) {
   if (use_kind == Definition::kValue) {
     ASSERT(instr->IsDefinition());
-    instr->AsDefinition()->set_ssa_temp_index(alloc_ssa_temp_index());
+    Definition* defn = instr->AsDefinition();
+    AllocateSSAIndexes(defn);
   }
   ASSERT(instr->env() == NULL);
   if (env != NULL) env->DeepCopyTo(instr);
   return prev->AppendInstruction(instr);
 }
 
 
 void FlowGraph::DiscoverBlocks() {
   // Initialize state.
   preorder_.Clear();
@@ skipping 566 matching lines @@
   // 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.
+      AllocateSSAIndexes(defn);
       AddToInitialDefinitions(defn);
       env.Add(defn);
     }
   } else {
     // Create new parameters.  For functions compiled for OSR, the locals
     // are unknown and so treated like parameters.
     intptr_t count = IsCompiledForOsr() ? variable_count() : parameter_count();
     for (intptr_t i = 0; i < count; ++i) {
       ParameterInstr* param = new ParameterInstr(i, entry);
       param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
@@ skipping 189 matching lines @@
           env->Add(result);
           // We remove load/store/constant instructions when we find their
           // use in 2a.
         } else {
           it.RemoveCurrentFromGraph();
         }
       } else {
         // 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());
+          AllocateSSAIndexes(definition);
           env->Add(definition);
         }
       }
     }
 
     // 2c. Handle pushed argument.
     PushArgumentInstr* push = current->AsPushArgument();
     if (push != NULL) {
       env->Add(push);
     }
@@ skipping 278 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart