Initial support for polymorphic inlining.

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 479 matching lines @@
 
 // M is a single argument macro.  It is applied to each concrete instruction
 // type name.  The concrete instruction classes are the name with Instr
 // concatenated.
 #define FOR_EACH_INSTRUCTION(M)                                                \
   M(GraphEntry)                                                                \
   M(JoinEntry)                                                                 \
   M(TargetEntry)                                                               \
   M(CatchBlockEntry)                                                           \
   M(Phi)                                                                       \
+  M(Redefinition)                                                              \
   M(Parameter)                                                                 \
   M(ParallelMove)                                                              \
   M(PushArgument)                                                              \
   M(Return)                                                                    \
   M(Throw)                                                                     \
   M(ReThrow)                                                                   \
   M(Goto)                                                                      \
   M(Branch)                                                                    \
   M(AssertAssignable)                                                          \
   M(AssertBoolean)                                                             \
@@ skipping 17 matching lines @@
   M(StoreStaticField)                                                          \
   M(BooleanNegate)                                                             \
   M(InstanceOf)                                                                \
   M(CreateArray)                                                               \
   M(CreateClosure)                                                             \
   M(AllocateObject)                                                            \
   M(AllocateObjectWithBoundsCheck)                                             \
   M(LoadField)                                                                 \
   M(StoreVMField)                                                              \
   M(LoadUntagged)                                                              \
+  M(LoadClassId)                                                               \
   M(InstantiateTypeArguments)                                                  \
   M(ExtractConstructorTypeArguments)                                           \
   M(ExtractConstructorInstantiator)                                            \
   M(AllocateContext)                                                           \
   M(ChainContext)                                                              \
   M(CloneContext)                                                              \
   M(CatchEntry)                                                                \
   M(BinarySmiOp)                                                               \
   M(UnarySmiOp)                                                                \
   M(CheckStackOverflow)                                                        \
@@ skipping 322 matching lines @@
   friend class InvokeMathCFunctionInstr;
   friend class FlowGraphOptimizer;
   friend class LoadIndexedInstr;
   friend class StoreIndexedInstr;
   friend class StoreInstanceFieldInstr;
   friend class ControlInstruction;
   friend class ComparisonInstr;
   friend class TargetEntryInstr;
   friend class JoinEntryInstr;
   friend class InstanceOfInstr;
+  friend class PolymorphicInstanceCallInstr;
+  friend class SmiToDoubleInstr;
+  friend class DoubleToIntegerInstr;
+  friend class BranchSimplifier;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   intptr_t expr_id_;
 
@@ skipping 148 matching lines @@
   void set_postorder_number(intptr_t number) { postorder_number_ = number; }
 
   intptr_t block_id() const { return block_id_; }
 
   void set_start_pos(intptr_t pos) { start_pos_ = pos; }
   intptr_t start_pos() const { return start_pos_; }
   void  set_end_pos(intptr_t pos) { end_pos_ = pos; }
   intptr_t end_pos() const { return end_pos_; }
 
   BlockEntryInstr* dominator() const { return dominator_; }
-  void set_dominator(BlockEntryInstr* instr) { dominator_ = instr; }
 
   const GrowableArray<BlockEntryInstr*>& dominated_blocks() {
     return dominated_blocks_;
   }
 
   void AddDominatedBlock(BlockEntryInstr* block) {
+    block->set_dominator(this);
     dominated_blocks_.Add(block);
   }
   void ClearDominatedBlocks() { dominated_blocks_.Clear(); }
 
   bool Dominates(BlockEntryInstr* other) const;
 
   Instruction* last_instruction() const { return last_instruction_; }
   void set_last_instruction(Instruction* instr) { last_instruction_ = instr; }
 
   ParallelMoveInstr* parallel_move() const {
@@ skipping 80 matching lines @@
         last_instruction_(NULL),
         parallel_move_(NULL),
         loop_info_(NULL) { }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual void ClearPredecessors() = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
 
+  void set_dominator(BlockEntryInstr* instr) { dominator_ = instr; }
+
   intptr_t block_id_;
   const intptr_t try_index_;
   intptr_t preorder_number_;
   intptr_t postorder_number_;
   // Starting and ending lifetime positions for this block.  Used by
   // the linear scan register allocator.
   intptr_t start_pos_;
   intptr_t end_pos_;
   BlockEntryInstr* dominator_;  // Immediate dominator, NULL for graph entry.
   // TODO(fschneider): Optimize the case of one child to save space.
@@ skipping 138 matching lines @@
 
   virtual void PrintTo(BufferFormatter* f) const;
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
  private:
   // Classes that have access to predecessors_ when inlining.
   friend class BlockEntryInstr;
   friend class InlineExitCollector;
+  friend class PolymorphicInliner;
 
   // Direct access to phis_ in order to resize it due to phi elimination.
   friend class ConstantPropagator;
 
   virtual void ClearPredecessors() { predecessors_.Clear(); }
   virtual void AddPredecessor(BlockEntryInstr* predecessor);
 
   GrowableArray<BlockEntryInstr*> predecessors_;
   ZoneGrowableArray<PhiInstr*>* phis_;
 
@@ skipping 671 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 class StoreContextInstr : public TemplateInstruction<1> {
  public:
   explicit StoreContextInstr(Value* value) {
     SetInputAt(0, value);
   }
 
-  DECLARE_INSTRUCTION(StoreContext);
+  DECLARE_INSTRUCTION(StoreContext)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
@@ skipping 25 matching lines @@
   friend class BranchInstr;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     inputs_[i] = value;
   }
 
   LocationSummary* locs_;
 };
 
 
+class RedefinitionInstr : public TemplateDefinition<1> {
+ public:
+  explicit RedefinitionInstr(Value* value) {
+    SetInputAt(0, value);
+  }
+
+  DECLARE_INSTRUCTION(Redefinition)
+
+  Value* value() const { return inputs_[0]; }
+
+  virtual CompileType ComputeType() const;
+  virtual bool RecomputeType();
+
+  virtual bool CanDeoptimize() const { return false; }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
+};
+
+
 class RangeBoundary : public ValueObject {
  public:
   enum Kind { kUnknown, kSymbol, kConstant };
 
   RangeBoundary() : kind_(kUnknown), value_(0), offset_(0) { }
 
   RangeBoundary(const RangeBoundary& other)
       : ValueObject(),
         kind_(other.kind_),
         value_(other.value_),
@@ skipping 480 matching lines @@
 
 class PolymorphicInstanceCallInstr : public TemplateDefinition<0> {
  public:
   PolymorphicInstanceCallInstr(InstanceCallInstr* instance_call,
                                const ICData& ic_data,
                                bool with_checks)
       : instance_call_(instance_call),
         ic_data_(ic_data),
         with_checks_(with_checks) {
     ASSERT(instance_call_ != NULL);
+    deopt_id_ = instance_call->deopt_id();
   }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
   bool with_checks() const { return with_checks_; }
 
   virtual intptr_t ArgumentCount() const {
     return instance_call()->ArgumentCount();
   }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return instance_call()->PushArgumentAt(index);
@@ skipping 586 matching lines @@
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(GuardFieldInstr);
 };
 
 
 class LoadStaticFieldInstr : public TemplateDefinition<0> {
  public:
   explicit LoadStaticFieldInstr(const Field& field) : field_(field) {}
 
-  DECLARE_INSTRUCTION(LoadStaticField);
+  DECLARE_INSTRUCTION(LoadStaticField)
   virtual CompileType ComputeType() const;
 
   const Field& field() const { return field_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return field_.is_final(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
 class StoreStaticFieldInstr : public TemplateDefinition<1> {
  public:
   StoreStaticFieldInstr(const Field& field, Value* value)
       : field_(field) {
     ASSERT(field.IsZoneHandle());
     SetInputAt(0, value);
   }
 
-  DECLARE_INSTRUCTION(StoreStaticField);
+  DECLARE_INSTRUCTION(StoreStaticField)
   virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   // Currently CSE/LICM don't operate on any instructions that can be affected
@@ skipping 372 matching lines @@
   const Function& function_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureInstr);
 };
 
 
 class LoadUntaggedInstr : public TemplateDefinition<1> {
  public:
-  explicit LoadUntaggedInstr(Value* object, intptr_t offset) : offset_(offset) {
+  LoadUntaggedInstr(Value* object, intptr_t offset) : offset_(offset) {
     SetInputAt(0, object);
   }
 
   virtual Representation representation() const {
     return kUntagged;
   }
   DECLARE_INSTRUCTION(LoadUntagged)
   virtual CompileType ComputeType() const;
 
   Value* object() const { return inputs_[0]; }
   intptr_t offset() const { return offset_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   // This instruction must not be moved without the indexed access that
   // depends on it (e.g. out of loops). GC may cause collect
   // the array while the external data-array is still accessed.
   virtual bool AllowsCSE() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   intptr_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
 
+class LoadClassIdInstr : public TemplateDefinition<1> {
+ public:
+  explicit LoadClassIdInstr(Value* object) {
+    SetInputAt(0, object);
+  }
+
+  virtual Representation representation() const {
+    return kTagged;
+  }
+  DECLARE_INSTRUCTION(LoadClassId)
+  virtual CompileType ComputeType() const;
+
+  Value* object() const { return inputs_[0]; }
+
+  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::Externalization();
+  }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LoadClassIdInstr);
+};
+
+
 class LoadFieldInstr : public TemplateDefinition<1> {
  public:
   LoadFieldInstr(Value* instance,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  bool immutable = false)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(immutable),
@@ skipping 200 matching lines @@
 };
 
 
 class AllocateContextInstr : public TemplateDefinition<0> {
  public:
   AllocateContextInstr(intptr_t token_pos,
                        intptr_t num_context_variables)
       : token_pos_(token_pos),
         num_context_variables_(num_context_variables) {}
 
-  DECLARE_INSTRUCTION(AllocateContext);
+  DECLARE_INSTRUCTION(AllocateContext)
   virtual CompileType ComputeType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
@@ skipping 292 matching lines @@
     SetInputAt(0, value);
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kUint32x4Cid);
   }
 
-  virtual bool HasSideEffect() const { return false; }
-
   virtual Representation representation() const {
     return kUnboxedUint32x4;
   }
 
   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; }
 
   DECLARE_INSTRUCTION(UnboxUint32x4)
@@ skipping 1074 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
 
 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_; }
 
   DECLARE_INSTRUCTION(DoubleToInteger)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
@@ skipping 476 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_