Implement inlined version of binary arithmetic operations for doubles.

runtime/vm/intermediate_language.h

Index: runtime/vm/intermediate_language.h
diff --git a/runtime/vm/intermediate_language.h b/runtime/vm/intermediate_language.h
index e6d9861e806cd45ba0b28dd65f62ca2a506eb497..cc35499671c94f6d3c2eb954707c34fd4cbcc5f7 100644
--- a/runtime/vm/intermediate_language.h
+++ b/runtime/vm/intermediate_language.h
@@ -1294,11 +1294,19 @@ class CatchEntryComp : public TemplateComputation<0> {
 
 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;
@@ -1310,6 +1318,8 @@ class BinaryOpComp : public TemplateComputation<2> {
 
   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;
@@ -1318,6 +1328,7 @@ class BinaryOpComp : public TemplateComputation<2> {
 
  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);