Implement inlined version of binary arithmetic operations for doubles.

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/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, trace_optimization);
 
 void FlowGraphOptimizer::ApplyICData() {
   VisitBlocks();
   if (FLAG_print_flow_graph) {
     OS::Print("After Optimizations:\n");
     FlowGraphPrinter printer(Function::Handle(), block_order_);
     printer.PrintBlocks();
   }
 }
 
 
 void FlowGraphOptimizer::VisitBlocks() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     Instruction* instr = block_order_[i]->Accept(this);
-    // Compile all successors until an exit, branch, or a block entry.
+    // Optimize all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       instr = instr->Accept(this);
     }
   }
 }
 
 
 static bool ICDataHasReceiverClass(const ICData& ic_data, const Class& cls) {
   ASSERT(!cls.IsNull());
   ASSERT(ic_data.num_args_tested() > 0);
@@ skipping 45 matching lines @@
 }
 
 
 static bool HasOneDouble(const ICData& ic_data) {
   const Class& double_class =
       Class::Handle(Isolate::Current()->object_store()->double_class());
   return ICDataHasReceiverClass(ic_data, double_class);
 }
 
 
+static bool HasTwoDouble(const ICData& ic_data) {
+  const Class& double_class =
+      Class::Handle(Isolate::Current()->object_store()->double_class());
+  return ICDataHasTwoReceiverClasses(ic_data, double_class, double_class);
+}
+
 
 void FlowGraphOptimizer::TryReplaceWithBinaryOp(InstanceCallComp* comp,
                                                 Token::Kind op_kind) {
   if (comp->ic_data()->NumberOfChecks() != 1) {
     // TODO(srdjan): Not yet supported.
     return;
   }
-  if (!HasTwoSmi(*comp->ic_data())) {
+
+  BinaryOpComp::OperandsType operands_type;
+
+  if (HasTwoSmi(*comp->ic_data())) {
+    if (op_kind == Token::kDIV ||
+        op_kind == Token::kMOD) {
+      // TODO(srdjan): Not yet supported.
+      return;
+    }
+
+    operands_type = BinaryOpComp::kSmiOperands;
+  } else if (HasTwoDouble(*comp->ic_data())) {
+    if (op_kind != Token::kADD &&
+        op_kind != Token::kSUB &&
+        op_kind != Token::kMUL &&
+        op_kind != Token::kDIV) {

[srdjan, 2012/06/08 05:18:22]

TODO(vegorov)  ;-)?

[Vyacheslav Egorov (Google), 2012/06/08 11:11:13]

Done.

I think they are not supported even by ia32 opt compiler :-)

+      return;
+    }
+
+    operands_type = BinaryOpComp::kDoubleOperands;
+  } else {
     // TODO(srdjan): Not yet supported.
     return;
   }
+
   ASSERT(comp->instr() != NULL);
   ASSERT(comp->InputCount() == 2);
+  Value* left = comp->InputAt(0);
+  Value* right = comp->InputAt(1);
   BinaryOpComp* bin_op =
-      new BinaryOpComp(op_kind, comp, comp->InputAt(0), comp->InputAt(1));
+      new BinaryOpComp(op_kind,
+                       operands_type,
+                       comp,
+                       left,
+                       right);
   ASSERT(bin_op->ic_data() == NULL);
   bin_op->set_ic_data(comp->ic_data());
   bin_op->set_instr(comp->instr());
   comp->instr()->replace_computation(bin_op);
 }
 
 
 void FlowGraphOptimizer::TryReplaceWithUnaryOp(InstanceCallComp* comp,
                                               Token::Kind op_kind) {
   if (comp->ic_data()->NumberOfChecks() != 1) {
@@ skipping 37 matching lines @@
   instr->computation()->Accept(this);
 }
 
 
 void FlowGraphOptimizer::VisitBind(BindInstr* instr) {
   instr->computation()->Accept(this);
 }
 
 
 }  // namespace dart