Add support for XMM registers in SSA code generation pipeline.

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/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/scopes.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 DEFINE_FLAG(bool, trace_optimization, false, "Print optimization details.");
 DECLARE_FLAG(bool, trace_type_check_elimination);
 DEFINE_FLAG(bool, use_cha, true, "Use class hierarchy analysis.");
+DEFINE_FLAG(bool, use_unboxed_doubles, true, "Try unboxing double values.");
 
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
 void FlowGraphOptimizer::OptimizeComputations() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
     entry->Accept(this);
@@ skipping 209 matching lines @@
       instr->set_computation(array_op);
       RemovePushArguments(comp);
       return true;
     }
     default:
       return false;
   }
 }
 
 
+Value* FlowGraphOptimizer::InsertBefore(Instruction* instr,
+                                        Computation* comp,
+                                        Environment* env) {
+  BindInstr* bind = new BindInstr(BindInstr::kUsed, comp);
+  bind->set_env(env->Clone());

[Florian Schneider, 2012/08/24 11:09:28]

Use Environment::Copy?

[Vyacheslav Egorov (Google), 2012/08/24 13:23:01]

Done.

+  bind->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
+
+  bind->InsertBefore(instr);
+
+  return new UseVal(bind);
+}
+
+
+BindInstr* FlowGraphOptimizer::InsertAfter(Instruction* instr,
+                                           Computation* comp) {
+  BindInstr* bind = new BindInstr(BindInstr::kUsed, comp);
+  bind->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
+
+  Instruction* next = instr->next();
+  instr->set_next(bind);
+  bind->set_previous(instr);
+  bind->set_next(next);
+  next->set_previous(bind);
+
+  return bind;
+}
+
+
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(BindInstr* instr,
                                                 InstanceCallComp* comp,
                                                 Token::Kind op_kind) {
   intptr_t operands_type = kIllegalCid;
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   switch (op_kind) {
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL:
@@ skipping 31 matching lines @@
       } else {
         return false;
       }
       break;
     default:
       UNREACHABLE();
   };
 
   ASSERT(comp->ArgumentCount() == 2);
   if (operands_type == kDoubleCid) {
-    BinaryDoubleOpComp* double_bin_op = new BinaryDoubleOpComp(op_kind, comp);
-    double_bin_op->set_ic_data(comp->ic_data());
-    instr->set_computation(double_bin_op);
+    if (FLAG_use_unboxed_doubles) {
+      Value* left = comp->ArgumentAt(0)->value();
+      Value* right = comp->ArgumentAt(1)->value();
+
+      CheckEitherNonSmiComp* check =
+          new CheckEitherNonSmiComp(left, right, comp);
+      BindInstr* check_instr = new BindInstr(BindInstr::kUnused, check);
+      check_instr->set_env(instr->env());
+      check_instr->InsertBefore(instr);
+
+      Value* unbox_left =
+          InsertBefore(instr, new UnboxDoubleComp(left, comp), instr->env());

[Florian Schneider, 2012/08/24 11:09:28]

Since left and right are used multiple times now, you need to do CopyValue for
each new use.

[Vyacheslav Egorov (Google), 2012/08/24 13:23:01]

Done.

+      Value* unbox_right =
+          InsertBefore(instr, new UnboxDoubleComp(right, comp), instr->env());
+      UnboxedDoubleBinaryOpComp* double_bin_op =
+          new UnboxedDoubleBinaryOpComp(op_kind, comp, unbox_left, unbox_right);
+      double_bin_op->set_ic_data(comp->ic_data());
+      instr->set_computation(double_bin_op);
+      if (instr->is_used()) {
+        UseVal* use_val = new UseVal(instr);
+        BindInstr* bind = InsertAfter(instr, new BoxDoubleComp(use_val, comp));
+        instr->ReplaceUsesWith(bind);
+        use_val->SetDefinition(instr);
+      }
+      RemovePushArguments(comp);
+    } else {
+      BinaryDoubleOpComp* double_bin_op = new BinaryDoubleOpComp(op_kind, comp);
+      double_bin_op->set_ic_data(comp->ic_data());
+      instr->set_computation(double_bin_op);
+    }
   } else if (operands_type == kMintCid) {
     Value* left = comp->ArgumentAt(0)->value();
     Value* right = comp->ArgumentAt(1)->value();
     BinaryMintOpComp* bin_op = new BinaryMintOpComp(op_kind,
                                                     comp,
                                                     left,
                                                     right);
     bin_op->set_ic_data(comp->ic_data());
     instr->set_computation(bin_op);
     RemovePushArguments(comp);
@@ skipping 637 matching lines @@
         OS::Print("Replacing v%d with v%d\n",
                   instr->ssa_temp_index(),
                   result->ssa_temp_index());
       }
     }
   }
 }
 
 
 }  // namespace dart