Support for multiple register values

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 285 matching lines @@
   LoadIndexedInstr* load = new LoadIndexedInstr(new Value(instr),
                                                 new Value(index_instr),
                                                 index_scale,
                                                 cid,
                                                 Isolate::kNoDeoptId);
   instr->ReplaceUsesWith(load);
   flow_graph()->InsertAfter(instr, load, NULL, Definition::kValue);
 }
 
 
+void FlowGraphOptimizer::AppendExtractNthOutputForMerged(Definition* instr,
+                                                         intptr_t index,
+                                                         Representation rep) {
+  ExtractNthOutputInstr* extract = new ExtractNthOutputInstr(new Value(instr),
+                                                             index,
+                                                             rep);
+  instr->ReplaceUsesWith(extract);
+  flow_graph()->InsertAfter(instr, extract, NULL, Definition::kValue);
+}
+
+
 // Dart:
 //  var x = d % 10;
 //  var y = d ~/ 10;
 //  var z = x + y;
 //
 // IL:
 //  v4 <- %(v2, v3)
 //  v5 <- ~/(v2, v3)
 //  v6 <- +(v4, v5)
 //
@@ skipping 24 matching lines @@
     Definition* left_def = curr_instr->left()->definition();
     Definition* right_def = curr_instr->right()->definition();
     for (intptr_t k = i + 1; k < merge_candidates->length(); k++) {
       BinarySmiOpInstr* other_binop = (*merge_candidates)[k];
       // 'other_binop' can be NULL if it was already merged.
       if ((other_binop != NULL) &&
           (other_binop->op_kind() == other_kind) &&
           (other_binop->left()->definition() == left_def) &&
           (other_binop->right()->definition() == right_def)) {
         (*merge_candidates)[k] = NULL;  // Clear it.
-        // Append a LoadIndexed behind TRUNC_DIV and MOD.
         ASSERT(curr_instr->HasUses());
-        AppendLoadIndexedForMerged(
+        AppendExtractNthOutputForMerged(
             curr_instr,
-            MergedMathInstr::ResultIndexOf(curr_instr->op_kind()),
-            kArrayCid);
+            MergedMath2Instr::OutputIndexOf(curr_instr->op_kind()),
+            kTagged);
         ASSERT(other_binop->HasUses());
-        AppendLoadIndexedForMerged(
+        AppendExtractNthOutputForMerged(
             other_binop,
-            MergedMathInstr::ResultIndexOf(other_binop->op_kind()),
-            kArrayCid);
+            MergedMath2Instr::OutputIndexOf(other_binop->op_kind()),
+            kTagged);
 
         ZoneGrowableArray<Value*>* args = new ZoneGrowableArray<Value*>(2);
         args->Add(new Value(curr_instr->left()->definition()));
         args->Add(new Value(curr_instr->right()->definition()));
 
         // Replace with TruncDivMod.
-        MergedMathInstr* div_mod = new MergedMathInstr(
+        MergedMath2Instr* div_mod = new MergedMath2Instr(
             args,
             curr_instr->deopt_id(),
-            MergedMathInstr::kTruncDivMod);
+            MergedMath2Instr::kTruncDivMod);
         curr_instr->ReplaceWith(div_mod, current_iterator());
+        div_mod->set_ssa_temp_index2(flow_graph()->alloc_ssa_temp_index());
         other_binop->ReplaceUsesWith(div_mod);
         other_binop->RemoveFromGraph();
         // Only one merge possible. Because canonicalization happens later,
         // more candidates are possible.
         // TODO(srdjan): Allow merging of trunc-div/mod into truncDivMod.
         break;
       }
     }
   }
 }
 
 
 void FlowGraphOptimizer::TryMergeMathUnary(
     GrowableArray<MathUnaryInstr*>* merge_candidates) {
   if (!FlowGraphCompiler::SupportsSinCos()) {
     return;
   }
   if (merge_candidates->length() < 2) {
     // Need at least a SIN and a COS.
     return;
   }
   for (intptr_t i = 0; i < merge_candidates->length(); i++) {
     MathUnaryInstr* curr_instr = (*merge_candidates)[i];
     if (curr_instr == NULL) {
       // Instruction was merged already.
       continue;
     }
-    ASSERT((curr_instr->kind() == MethodRecognizer::kMathSin) ||
-           (curr_instr->kind() == MethodRecognizer::kMathCos));
+    const intptr_t kind = curr_instr->kind();
+    ASSERT((kind == MethodRecognizer::kMathSin) ||
+           (kind == MethodRecognizer::kMathCos));
     // Check if there is sin/cos binop with same inputs.
-    const intptr_t other_kind =
-        (curr_instr->kind() == MethodRecognizer::kMathSin) ?
-            MethodRecognizer::kMathCos : MethodRecognizer::kMathSin;
+    const intptr_t other_kind = (kind == MethodRecognizer::kMathSin) ?
+        MethodRecognizer::kMathCos : MethodRecognizer::kMathSin;
     Definition* def = curr_instr->value()->definition();
     for (intptr_t k = i + 1; k < merge_candidates->length(); k++) {
       MathUnaryInstr* other_op = (*merge_candidates)[k];
       // 'other_op' can be NULL if it was already merged.
       if ((other_op != NULL) && (other_op->kind() == other_kind) &&
           (other_op->value()->definition() == def)) {
         (*merge_candidates)[k] = NULL;  // Clear it.
-        // Append a LoadIndexed behind SIN and COS.
         ASSERT(curr_instr->HasUses());
-        AppendLoadIndexedForMerged(
-            curr_instr,
-            MergedMathInstr::ResultIndexOf(curr_instr->kind()),
-            kTypedDataFloat64ArrayCid);
+        // TODO(johnmccutchan): Fix up input indexes.
+        AppendExtractNthOutputForMerged(curr_instr,
+                                        MergedMath2Instr::OutputIndexOf(kind),
+                                        kUnboxedDouble);
         ASSERT(other_op->HasUses());
-        AppendLoadIndexedForMerged(
+        AppendExtractNthOutputForMerged(
             other_op,
-            MergedMathInstr::ResultIndexOf(other_op->kind()),
-            kTypedDataFloat64ArrayCid);
+            MergedMath2Instr::OutputIndexOf(other_kind),
+            kUnboxedDouble);
         ZoneGrowableArray<Value*>* args = new ZoneGrowableArray<Value*>(1);
         args->Add(new Value(curr_instr->value()->definition()));
-
         // Replace with SinCos.
-        MergedMathInstr* sin_cos = new MergedMathInstr(
-            args,
-            curr_instr->DeoptimizationTarget(),
-            MergedMathInstr::kSinCos);
+        MergedMath2Instr* sin_cos =
+            new MergedMath2Instr(args, curr_instr->DeoptimizationTarget(),
+                                 MergedMath2Instr::kSinCos);
         curr_instr->ReplaceWith(sin_cos, current_iterator());
+        sin_cos->set_ssa_temp_index2(flow_graph()->alloc_ssa_temp_index());
         other_op->ReplaceUsesWith(sin_cos);
         other_op->RemoveFromGraph();
         // Only one merge possible. Because canonicalization happens later,
         // more candidates are possible.
         // TODO(srdjan): Allow merging of sin/cos into sincos.
         break;
       }
     }
   }
 }
@@ skipping 306 matching lines @@
   if (unboxed != current) {
     phi->set_representation(unboxed);
     return true;
   }
 
   return false;
 }
 
 
 void FlowGraphOptimizer::SelectRepresentations() {
-  // Convervatively unbox all phis that were proven to be of Double,
+  // Conservatively unbox all phis that were proven to be of Double,
   // Float32x4, or Int32x4 type.
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     JoinEntryInstr* join_entry = block_order_[i]->AsJoinEntry();
     if (join_entry != NULL) {
       for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
         UnboxPhi(phi);
       }
     }
   }
@@ skipping 7137 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitMergedMath(MergedMathInstr* instr) {
   // TODO(srdjan): Handle merged instruction.
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitMergedMath2(MergedMath2Instr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitExtractNthOutput(ExtractNthOutputInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitConstant(ConstantInstr* instr) {
   SetValue(instr, instr->value());
 }
 
 
 void ConstantPropagator::VisitConstraint(ConstraintInstr* instr) {
   // Should not be used outside of range analysis.
   UNREACHABLE();
 }
 
@@ skipping 1114 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart