Implement inlined version of binary arithmetic operations for doubles.

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 1276 matching lines @@
  private:
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchEntryComp);
 };
 
 
 class BinaryOpComp : public TemplateComputation<2> {
  public:
+  enum OperandsType {
+    kSmiOperands,
+    kDoubleOperands
+  };
+
   BinaryOpComp(Token::Kind op_kind,
+               OperandsType operands_type,
                InstanceCallComp* instance_call,
                Value* left,
                Value* right)
-      : op_kind_(op_kind), instance_call_(instance_call) {
+      : op_kind_(op_kind),
+        operands_type_(operands_type),
+        instance_call_(instance_call) {
     ASSERT(left != NULL);
     ASSERT(right != NULL);
     inputs_[0] = left;
     inputs_[1] = right;
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
+  OperandsType operands_type() const { return operands_type_; }
+
   InstanceCallComp* instance_call() const { return instance_call_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_COMPUTATION(BinaryOp)
 
  private:
   const Token::Kind op_kind_;
+  const OperandsType operands_type_;

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

This works for now, but in Dart it is quite frequent that we have to support a
mix of double and int types (result is always double). Sometimes it is a mix
Smi/Smi and Smi/Double.. maybe that can be handled by additional OperandsTypes?

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

We will have to decide how we want to implement them. For example V8 decision
was that binary arithmetic operation always has a single type and inputs are
coerced explicitly in the IR:

d1 = <...> ; real double
d2 = Change i to d i4 ; int operand was coerced to double
d3 = mul-d d1, d2

The benefit of handling conversions outside of the op is that you can optimize
away redundancies and select single representation for loop phies which is very
important for performance of tight loops.

[srdjan, 2012/06/08 16:05:55]

Sounds good.

   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryOpComp);
 };
 
 
 // Handles both Smi operations: BIT_OR and NEGATE.
 class UnarySmiOpComp : public TemplateComputation<1> {
  public:
   UnarySmiOpComp(Token::Kind op_kind,
@@ skipping 694 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_