Inline toDouble calls on mints

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, 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 458 matching lines @@
   M(AllocateContext)                                                           \
   M(AllocateUninitializedContext)                                              \
   M(CloneContext)                                                              \
   M(BinarySmiOp)                                                               \
   M(BinaryInt32Op)                                                             \
   M(UnarySmiOp)                                                                \
   M(UnaryDoubleOp)                                                             \
   M(CheckStackOverflow)                                                        \
   M(SmiToDouble)                                                               \
   M(Int32ToDouble)                                                             \
+  M(MintToDouble)                                                              \
   M(DoubleToInteger)                                                           \
   M(DoubleToSmi)                                                               \
   M(DoubleToDouble)                                                            \
   M(DoubleToFloat)                                                             \
   M(FloatToDouble)                                                             \
   M(CheckClass)                                                                \
   M(CheckClassId)                                                              \
   M(CheckSmi)                                                                  \
   M(Constant)                                                                  \
   M(UnboxedConstant)                                                           \
@@ skipping 408 matching lines @@
   friend class FlowGraphOptimizer;
   friend class LoadIndexedInstr;
   friend class StoreIndexedInstr;
   friend class StoreInstanceFieldInstr;
   friend class ComparisonInstr;
   friend class TargetEntryInstr;
   friend class JoinEntryInstr;
   friend class InstanceOfInstr;
   friend class PolymorphicInstanceCallInstr;
   friend class SmiToDoubleInstr;
+  friend class MintToDoubleInstr;
   friend class DoubleToIntegerInstr;
   friend class BranchSimplifier;
   friend class BlockEntryInstr;
   friend class RelationalOpInstr;
   friend class EqualityCompareInstr;
   friend class TestCidsInstr;
   friend class BinaryUint32OpInstr;
   friend class UnaryUint32OpInstr;
   friend class ShiftUint32OpInstr;
   friend class UnboxIntNInstr;
@@ skipping 6256 matching lines @@
   Value* value() const { return inputs_[0]; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(SmiToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual intptr_t ArgumentCount() const { return 1; }

[Florian Schneider, 2014/09/17 11:15:32]

Why is ArgumentCount 1? There should not be any pushed arguments for this
instructions.

[Cutch, 2014/09/18 16:39:49]

Fixed here.

 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool MayThrow() const { return false; }
 
@@ skipping 31 matching lines @@
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32ToDoubleInstr);
 };
 
 
+class MintToDoubleInstr : public TemplateDefinition<1> {
+ public:
+  MintToDoubleInstr(Value* value, intptr_t deopt_id)
+      : deopt_id_(deopt_id) {
+    SetInputAt(0, value);
+  }
+
+  Value* value() const { return inputs_[0]; }
+
+  DECLARE_INSTRUCTION(MintToDouble)
+  virtual CompileType ComputeType() const;
+
+  virtual Representation RequiredInputRepresentation(intptr_t index) const {
+    ASSERT(index == 0);
+    return kUnboxedMint;
+  }
+
+  virtual Representation representation() const {
+    return kUnboxedDouble;
+  }
+
+  virtual intptr_t DeoptimizationTarget() const {
+    // Direct access since this instruction cannot deoptimize, and the deopt-id
+    // was inherited from another instruction that could deoptimize.
+    return deopt_id_;
+  }
+
+  virtual intptr_t ArgumentCount() const { return 1; }

[Florian Schneider, 2014/09/17 11:15:32]

Why is ArgumentCount 1? There should not be any pushed arguments for this
instructions.

[Cutch, 2014/09/18 16:39:49]

And here.

+
+  virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
+  virtual bool MayThrow() const { return false; }
+
+ private:
+  const intptr_t deopt_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(MintToDoubleInstr);
+};
+
+
 class DoubleToIntegerInstr : public TemplateDefinition<1> {
  public:
   DoubleToIntegerInstr(Value* value, InstanceCallInstr* instance_call)
       : instance_call_(instance_call) {
     SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
   InstanceCallInstr* instance_call() const { return instance_call_; }
@@ skipping 1208 matching lines @@
       Isolate* isolate, bool opt) const {                                     \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_