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 151 matching lines @@
   if (ic_data.NumberOfChecks() != 1) return kIllegalCid;
   ASSERT(HasOneTarget(ic_data));
 
   Function& target = Function::Handle();
   intptr_t class_id;
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   return class_id;
 }
 
 
-// Insert a check computation before an instruction and set the environment
-// of the check to the same as the instruction.
-static void InsertCheckBefore(BindInstr* instr,
-                              Computation* check,
-                              Environment* env) {
-  BindInstr* check_instr = new BindInstr(BindInstr::kUnused, check);
-  check_instr->InsertBefore(instr);
-  ASSERT(env != NULL);
-  // Attach an environment to the check instruction.
-  check_instr->set_env(env);
-}
-
-
-static void AddCheckClass(BindInstr* instr,
-                          InstanceCallComp* comp,
-                          Value* value) {
+void FlowGraphOptimizer::AddCheckClass(BindInstr* instr,
+                                       InstanceCallComp* comp,
+                                       Value* value) {
   // Type propagation has not run yet, we cannot eliminate the check.
   CheckClassComp* check = new CheckClassComp(value, comp);
   const ICData& unary_checks =
       ICData::ZoneHandle(comp->ic_data()->AsUnaryClassChecks());
   check->set_ic_data(&unary_checks);
-  InsertCheckBefore(instr, check, instr->env());
+  InsertBefore(instr, check, instr->env(), BindInstr::kUnused);
   // Detach environment from the original instruction because it can't
   // deoptimize.
   instr->set_env(NULL);
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithArrayOp(BindInstr* instr,
                                                InstanceCallComp* comp,
                                                Token::Kind op_kind) {
   // TODO(fschneider): Optimize []= operator in checked mode as well.
@@ skipping 25 matching lines @@
       instr->set_computation(array_op);
       RemovePushArguments(comp);
       return true;
     }
     default:
       return false;
   }
 }
 
 
+BindInstr* FlowGraphOptimizer::InsertBefore(Instruction* instr,
+                                            Computation* comp,
+                                            Environment* env,
+                                            BindInstr::UseKind use_kind) {
+  BindInstr* bind = new BindInstr(use_kind, comp);
+  if (env != NULL) bind->set_env(env->Copy());
+  if (use_kind == BindInstr::kUsed) {
+    bind->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
+  }
+  bind->InsertBefore(instr);
+  return bind;
+}
+
+
+BindInstr* FlowGraphOptimizer::InsertAfter(Instruction* instr,
+                                           Computation* comp,
+                                           Environment* env,
+                                           BindInstr::UseKind use_kind) {
+  BindInstr* bind = new BindInstr(use_kind, comp);
+  if (env != NULL) bind->set_env(env->Copy());
+  if (use_kind == BindInstr::kUsed) {
+    bind->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
+  }
+  bind->InsertAfter(instr);
+  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();
+
+      // Check that either left or right are not a smi.  Result or a
+      // binary operation with two smis is a smi not a double.
+      InsertBefore(instr,
+                   new CheckEitherNonSmiComp(left, right, comp),
+                   instr->env(),
+                   BindInstr::kUnused);
+
+      // Unbox operands.
+      BindInstr* unbox_left = InsertBefore(
+          instr,
+          new UnboxDoubleComp(left->CopyValue(), comp),
+          instr->env(),
+          BindInstr::kUsed);
+      BindInstr* unbox_right = InsertBefore(
+          instr,
+          new UnboxDoubleComp(right->CopyValue(), comp),
+          instr->env(),
+          BindInstr::kUsed);
+
+      UnboxedDoubleBinaryOpComp* double_bin_op =
+          new UnboxedDoubleBinaryOpComp(op_kind,
+                                        new UseVal(unbox_left),
+                                        new UseVal(unbox_right));
+      double_bin_op->set_ic_data(comp->ic_data());
+      instr->set_computation(double_bin_op);
+
+      if (instr->is_used()) {
+        // Box result.
+        UseVal* use_val = new UseVal(instr);
+        BindInstr* bind = InsertAfter(instr,
+                                      new BoxDoubleComp(use_val, comp),
+                                      NULL,
+                                      BindInstr::kUsed);
+        instr->ReplaceUsesWith(bind);
+      }
+
+      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);
   } else {
     ASSERT(operands_type == kSmiCid);
     Value* left = comp->ArgumentAt(0)->value();
     Value* right = comp->ArgumentAt(1)->value();
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
-    InsertCheckBefore(instr,
-                      new CheckSmiComp(left->CopyValue(), comp),
-                      instr->env()->Copy());
-    InsertCheckBefore(instr,
-                      new CheckSmiComp(right->CopyValue(), comp),
-                      instr->env()->Copy());
+    InsertBefore(instr,
+                 new CheckSmiComp(left->CopyValue(), comp),
+                 instr->env(),
+                 BindInstr::kUnused);
+    InsertBefore(instr,
+                 new CheckSmiComp(right->CopyValue(), comp),
+                 instr->env(),
+                 BindInstr::kUnused);
     BinarySmiOpComp* bin_op = new BinarySmiOpComp(op_kind,
                                                   comp,
                                                   left,
                                                   right);
     bin_op->set_ic_data(comp->ic_data());
     instr->set_computation(bin_op);
     RemovePushArguments(comp);
   }
   return true;
 }
@@ skipping 194 matching lines @@
       const ICData& unary_checks =
           ICData::ZoneHandle(comp->ic_data()->AsUnaryClassChecks());
       bool call_with_checks;
       // TODO(srdjan): Add check class comp for mixed smi/non-smi.
       if (HasOneTarget(unary_checks) &&
           (unary_checks.GetReceiverClassIdAt(0) != kSmiCid)) {
         Value* value = comp->ArgumentAt(0)->value()->CopyValue();
         // Type propagation has not run yet, we cannot eliminate the check.
         CheckClassComp* check = new CheckClassComp(value, comp);
         check->set_ic_data(&unary_checks);
-        InsertCheckBefore(instr, check, instr->env()->Copy());
+        InsertBefore(instr, check, instr->env(), BindInstr::kUnused);
         // Call can still deoptimize, do not detach environment from instr.
         call_with_checks = false;
       } else {
         call_with_checks = true;
       }
       PolymorphicInstanceCallComp* call =
           new PolymorphicInstanceCallComp(comp, call_with_checks);
       call->set_ic_data(&unary_checks);
       instr->set_computation(call);
     }
@@ skipping 440 matching lines @@
       DirectChainedHashMap<BindInstr*> child_map(*map);  // Copy map.
       OptimizeRecursive(child, &child_map);
     } else {
       OptimizeRecursive(child, map);  // Reuse map for the last child.
     }
   }
 }
 
 
 }  // namespace dart