Unbox phis that were proven to be of type Double.

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 223 matching lines @@
   enum ComputationKind {
 #define DECLARE_COMPUTATION_KIND(ShortName, ClassName) k##ShortName,
 
   FOR_EACH_COMPUTATION(DECLARE_COMPUTATION_KIND)
 
 #undef DECLARE_COMPUTATION_KIND
   };
 
   virtual ComputationKind computation_kind() const = 0;
 
+  // Returns representation expected for the input operand at the given index.
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    return kTagged;
+  }
+
+  // Representation of the value produced by this computation.
   virtual Representation representation() const {
     return kTagged;
   }
 
+  // Returns deoptimization id that corresponds to the deoptimization target
+  // that input operands conversions inserted for this instruction can jump
+  // to. Can return kNoDeoptId.
+  virtual intptr_t DeoptimizationTarget() const {
+    UNREACHABLE();
+    return Isolate::kNoDeoptId;
+  }
+
   // Declare predicate for each computation.
 #define DECLARE_PREDICATE(ShortName, ClassName)                                \
   inline bool Is##ShortName() const;                                           \
   inline const ClassName* As##ShortName() const;                               \
   inline ClassName* As##ShortName();
 FOR_EACH_COMPUTATION(DECLARE_PREDICATE)
 #undef DECLARE_PREDICATE
 
+ protected:
+  // Fetch deopt id without checking if this computation can deoptimize.
+  intptr_t GetDeoptId() const {
+    return deopt_id_;
+  }
+
  private:
   friend class BranchInstr;
 
   intptr_t deopt_id_;
   const ICData* ic_data_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(Computation);
 };
 
@@ skipping 473 matching lines @@
   DECLARE_COMPUTATION(EqualityCompare)
 
   intptr_t token_pos() const { return token_pos_; }
 
   // Receiver class id is computed from collected ICData.
   void set_receiver_class_id(intptr_t value) { receiver_class_id_ = value; }
   intptr_t receiver_class_id() const { return receiver_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool CanDeoptimize() const {
+    return (receiver_class_id() != kDoubleCid);
+  }
+
   virtual intptr_t ResultCid() const;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
+  virtual intptr_t DeoptimizationTarget() const {
+    return GetDeoptId();
+  }
+
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    ASSERT((idx == 0) || (idx == 1));
+    return (receiver_class_id() == kDoubleCid) ? kUnboxedDouble : kTagged;
+  }
+
  private:
   const intptr_t token_pos_;
   intptr_t receiver_class_id_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareComp);
 };
 
 
 class RelationalOpComp : public ComparisonComp {
  public:
@@ skipping 14 matching lines @@
   // TODO(srdjan): instead of class-id pass an enum that can differentiate
   // between boxed and unboxed doubles and integers.
   void set_operands_class_id(intptr_t value) {
     operands_class_id_ = value;
   }
 
   intptr_t operands_class_id() const { return operands_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual bool CanDeoptimize() const {
+    return operands_class_id() != kDoubleCid;
+  }
+
   virtual intptr_t ResultCid() const;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
+
+  virtual intptr_t DeoptimizationTarget() const {
+    return GetDeoptId();
+  }
+
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    ASSERT((idx == 0) || (idx == 1));
+    return (operands_class_id() == kDoubleCid) ? kUnboxedDouble : kTagged;
+  }
+
  private:
   const intptr_t token_pos_;
   intptr_t operands_class_id_;  // class id of both operands.
 
   DISALLOW_COPY_AND_ASSIGN(RelationalOpComp);
 };
 
 
 class StaticCallComp : public TemplateComputation<0> {
  public:
@@ skipping 786 matching lines @@
  private:
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiComp);
 };
 
 
 class BoxDoubleComp : public TemplateComputation<1> {
  public:
   BoxDoubleComp(Value* value, InstanceCallComp* instance_call)
-      : instance_call_(instance_call) {
+      : token_pos_((instance_call != NULL) ? instance_call->token_pos() : 0) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
-  InstanceCallComp* instance_call() const { return instance_call_; }
+
+  intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
+  virtual bool HasSideEffect() const { return false; }
+  virtual bool AttributesEqual(Computation* other) const { return true; }
 
   virtual intptr_t ResultCid() const;
 
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    ASSERT(idx == 0);
+    return kUnboxedDouble;
+  }
+
   DECLARE_COMPUTATION(BoxDouble)
 
  private:
-  InstanceCallComp* instance_call_;
+  const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(BoxDoubleComp);
 };
 
 
 class UnboxDoubleComp : public TemplateComputation<1> {
  public:
-  UnboxDoubleComp(Value* value, InstanceCallComp* instance_call)
-      : instance_call_(instance_call) {
+  UnboxDoubleComp(Value* value, intptr_t deopt_id)
+      : deopt_id_(deopt_id) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
-  InstanceCallComp* instance_call() const { return instance_call_; }
 
   virtual bool CanDeoptimize() const {
     return value()->ResultCid() != kDoubleCid;
   }
-  // The output is not an instance.
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
+
+  // The output is not an instance but when it is boxed it becomes double.
+  virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
+  virtual bool HasSideEffect() const { return false; }
+  virtual bool AttributesEqual(Computation* other) const { return true; }
+
   DECLARE_COMPUTATION(UnboxDouble)
 
  private:
-  InstanceCallComp* instance_call_;
+  const intptr_t deopt_id_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleComp);
 };
 
 
 class UnboxedDoubleBinaryOpComp : public TemplateComputation<2> {
  public:
   UnboxedDoubleBinaryOpComp(Token::Kind op_kind,
                             Value* left,
-                            Value* right)
-      : op_kind_(op_kind) {
+                            Value* right,
+                            InstanceCallComp* call)
+      : op_kind_(op_kind), deopt_id_(call->deopt_id()) {
     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_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
-  // The output is not an instance.
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
+  virtual bool HasSideEffect() const { return false; }
+
+  virtual bool AttributesEqual(Computation* other) const {
+    return op_kind() == other->AsUnboxedDoubleBinaryOp()->op_kind();
+  }
+
+  // The output is not an instance but when it is boxed it becomes double.
+  virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    ASSERT((idx == 0) || (idx == 1));
+    return kUnboxedDouble;
+  }
+
+  virtual intptr_t DeoptimizationTarget() const {
+    return deopt_id_;
+  }
+
   DECLARE_COMPUTATION(UnboxedDoubleBinaryOp)
 
  private:
   const Token::Kind op_kind_;
+  const intptr_t deopt_id_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboxedDoubleBinaryOpComp);
 };
 
 
 class BinarySmiOpComp : public TemplateComputation<2> {
  public:
   BinarySmiOpComp(Token::Kind op_kind,
                   InstanceCallComp* instance_call,
                   Value* left,
@@ skipping 483 matching lines @@
   }
 
   Environment* env() const { return env_; }
   void set_env(Environment* env) { env_ = env; }
 
   intptr_t lifetime_position() const { return lifetime_position_; }
   void set_lifetime_position(intptr_t pos) {
     lifetime_position_ = pos;
   }
 
+  // Returns representation expected for the input operand at the given index.
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    return kTagged;
+  }
+
+  // Representation of the value produced by this computation.
   virtual Representation representation() const {
     return kTagged;
   }
 
+  bool WasEliminated() const {
+    return next() == NULL;
+  }
+
+  // Returns deoptimization id that corresponds to the deoptimization target
+  // that input operands conversions inserted for this instruction can jump
+  // to.
+  virtual intptr_t DeoptimizationTarget() const {
+    UNREACHABLE();
+    return Isolate::kNoDeoptId;
+  }
+
  private:
   friend class BindInstr;  // Needed for BindInstr::InsertBefore.
 
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
@@ skipping 545 matching lines @@
   }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   // Insert this instruction before 'next'.
   void InsertBefore(Instruction* next);
 
   // Insert this instruction after 'prev'.
   void InsertAfter(Instruction* prev);
 
+  virtual Representation RequiredInputRepresentation(intptr_t i) const {
+    return computation()->RequiredInputRepresentation(i);
+  }
+
   virtual Representation representation() const {
     return computation()->representation();
   }
 
+  virtual intptr_t DeoptimizationTarget() const {
+    return computation()->DeoptimizationTarget();
+  }
+
  private:
   Computation* computation_;
   const bool is_used_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
 class PhiInstr : public Definition {
  public:
-  explicit PhiInstr(intptr_t num_inputs)
-    : inputs_(num_inputs), is_alive_(false) {
+  explicit PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
+    : block_(block),
+      inputs_(num_inputs),
+      is_alive_(false),
+      representation_(kTagged) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
+  JoinEntryInstr* block() const { return block_; }
+
   virtual RawAbstractType* CompileType() const;
   virtual intptr_t GetPropagatedCid() { return propagated_cid(); }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   void SetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   // TODO(regis): This helper will be removed once we support type sets.
   RawAbstractType* LeastSpecificInputType() const;
 
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
   void mark_alive() { is_alive_ = true; }
 
+  virtual Representation RequiredInputRepresentation(intptr_t i) const {
+    return representation_;
+  }
+
+  virtual Representation representation() const {
+    return representation_;
+  }
+
+  virtual void set_representation(Representation r) {
+    representation_ = r;
+  }
+
   DECLARE_INSTRUCTION(Phi)
 
  private:
+  JoinEntryInstr* block_;
   GrowableArray<Value*> inputs_;
   bool is_alive_;
+  Representation representation_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
 class ParameterInstr : public Definition {
  public:
   explicit ParameterInstr(intptr_t index) : index_(index) { }
 
   DECLARE_INSTRUCTION(Parameter)
@@ skipping 54 matching lines @@
     }
     return locs_;
   }
 
   LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
-  bool WasEliminated() const {
-    return next() == NULL;
-  }
-
  private:
   Value* value_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 class ReturnInstr : public TemplateInstruction<1> {
  public:
@@ skipping 189 matching lines @@
   virtual LocationSummary* locs() {
     if (computation_->locs_ == NULL) {
       LocationSummary* summary = computation_->MakeLocationSummary();
       // Branches don't produce a result.
       summary->set_out(Location::NoLocation());
       computation_->locs_ = summary;
     }
     return computation_->locs_;
   }
 
+  virtual intptr_t DeoptimizationTarget() const {
+    return computation_->DeoptimizationTarget();
+  }
+
+  virtual Representation RequiredInputRepresentation(intptr_t i) const {
+    return computation()->RequiredInputRepresentation(i);
+  }
+
  private:
   ComparisonComp* computation_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 #undef DECLARE_INSTRUCTION
 
@@ skipping 84 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_