Reduce number of times a deopt-id is computed.

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 583 matching lines @@
 
 class Instruction : public ZoneAllocated {
  public:
 #define DECLARE_TAG(type) k##type,
   enum Tag {
     FOR_EACH_INSTRUCTION(DECLARE_TAG)
   };
 #undef DECLARE_TAG
 
   Instruction()
-      : deopt_id_(Isolate::Current()->GetNextDeoptId()),
+      : deopt_id_(Isolate::kNoDeoptId),
         lifetime_position_(-1),
         previous_(NULL),
         next_(NULL),
         env_(NULL),
         locs_(NULL),
         place_id_(kNoPlaceId) { }
 
   virtual ~Instruction() { }
 
   virtual Tag tag() const = 0;
@@ skipping 302 matching lines @@
   friend class EqualityCompareInstr;
   friend class TestCidsInstr;
   friend class UnboxIntNInstr;
   friend class UnboxInt32Instr;
   friend class UnboxUint32Instr;
   friend class UnboxedIntConverterInstr;
   friend class UnaryIntegerOpInstr;
   friend class BinaryIntegerOpInstr;
   friend class DeoptimizeInstr;
 
+  // deopt_id_ access.
+  friend class InstanceCallInstr;
+  friend class StaticCallInstr;
+  friend class GotoInstr;
+  friend class ReturnInstr;
+  friend class BranchInstr;
+  friend class AssertAssignableInstr;
+  friend class TestSmiInstr;
+  friend class IfThenElseInstr;
+  friend class StrictCompareInstr;
+  friend class ThrowInstr;
+  friend class ReThrowInstr;
+  friend class AssertBooleanInstr;
+  friend class CurrentContextInstr;
+  friend class ClosureCallInstr;
+  friend class StringInterpolateInstr;
+  friend class CreateArrayInstr;
+  friend class InstantiateTypeInstr;
+  friend class InstantiateTypeArgumentsInstr;
+  friend class InitStaticFieldInstr;
+  friend class CloneContextInstr;
+  friend class CheckStackOverflowInstr;
+
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
   enum {
     kNoPlaceId = -1
   };
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
@@ skipping 259 matching lines @@
  protected:
   BlockEntryInstr(intptr_t block_id, intptr_t try_index)
       : block_id_(block_id),
         try_index_(try_index),
         preorder_number_(-1),
         postorder_number_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL),
         parallel_move_(NULL),
-        loop_info_(NULL) { }
+        loop_info_(NULL) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+  }
 
  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_;
@@ skipping 214 matching lines @@
   ZoneGrowableArray<PhiInstr*>* phis_;
   intptr_t index_;
 };
 
 
 class TargetEntryInstr : public BlockEntryInstr {
  public:
   TargetEntryInstr(intptr_t block_id, intptr_t try_index)
       : BlockEntryInstr(block_id, try_index),
         predecessor_(NULL),
-        edge_weight_(0.0) {
-  }
+        edge_weight_(0.0) { }
 
   DECLARE_INSTRUCTION(TargetEntry)
 
   double edge_weight() const { return edge_weight_; }
   void set_edge_weight(double weight) { edge_weight_ = weight; }
   void adjust_edge_weight(double scale_factor) { edge_weight_ *= scale_factor; }
 
   virtual intptr_t PredecessorCount() const {
     return (predecessor_ == NULL) ? 0 : 1;
   }
@@ skipping 541 matching lines @@
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
 class ReturnInstr : public TemplateInstruction<1> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : token_pos_(token_pos) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
@@ skipping 11 matching lines @@
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public TemplateInstruction<0> {
  public:
-  explicit ThrowInstr(intptr_t token_pos) : token_pos_(token_pos) { }
+  explicit ThrowInstr(intptr_t token_pos) : token_pos_(token_pos) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+  }
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return true; }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public TemplateInstruction<0> {
  public:
   // 'catch_try_index' can be CatchClauseNode::kInvalidTryIndex if the
   // rethrow has been artifically generated by the parser.
   ReThrowInstr(intptr_t token_pos, intptr_t catch_try_index)
-      : token_pos_(token_pos), catch_try_index_(catch_try_index) {}
+      : token_pos_(token_pos), catch_try_index_(catch_try_index) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+  }
 
   DECLARE_INSTRUCTION(ReThrow)
 
   virtual intptr_t ArgumentCount() const { return 2; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   intptr_t catch_try_index() const { return catch_try_index_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return true; }
 
  private:
   const intptr_t token_pos_;
   const intptr_t catch_try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class GotoInstr : public TemplateInstruction<0> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
     : successor_(entry),
       edge_weight_(0.0),
       parallel_move_(NULL) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
   }
 
   DECLARE_INSTRUCTION(Goto)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
@@ skipping 92 matching lines @@
 };
 
 
 class BranchInstr : public Instruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison)
       : comparison_(comparison),
         is_checked_(false),
         constrained_type_(NULL),
         constant_target_(NULL) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
     }
   }
 
   DECLARE_INSTRUCTION(Branch)
 
   virtual intptr_t ArgumentCount() const {
     return comparison()->ArgumentCount();
@@ skipping 290 matching lines @@
  public:
   AssertAssignableInstr(intptr_t token_pos,
                         Value* value,
                         Value* instantiator,
                         Value* instantiator_type_arguments,
                         const AbstractType& dst_type,
                         const String& dst_name)
       : token_pos_(token_pos),
         dst_type_(AbstractType::ZoneHandle(dst_type.raw())),
         dst_name_(dst_name) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(!dst_type.IsNull());
     ASSERT(!dst_name.IsNull());
     SetInputAt(0, value);
     SetInputAt(1, instantiator);
     SetInputAt(2, instantiator_type_arguments);
   }
 
   DECLARE_INSTRUCTION(AssertAssignable)
   virtual CompileType* ComputeInitialType() const;
   virtual bool RecomputeType();
@@ skipping 34 matching lines @@
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
       : token_pos_(token_pos) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 13 matching lines @@
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
 class CurrentContextInstr : public TemplateDefinition<0> {
  public:
-  CurrentContextInstr() { }
+  CurrentContextInstr() {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+  }
 
   DECLARE_INSTRUCTION(CurrentContext)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() 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; }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
 class ClosureCallInstr : public TemplateDefinition<1> {
  public:
   ClosureCallInstr(Value* function,
                    ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         arguments_(arguments) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     SetInputAt(0, function);
   }
 
   DECLARE_INSTRUCTION(ClosureCall)
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   virtual intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
@@ skipping 21 matching lines @@
 
 class InstanceCallInstr : public TemplateDefinition<0> {
  public:
   InstanceCallInstr(intptr_t token_pos,
                     const String& function_name,
                     Token::Kind token_kind,
                     ZoneGrowableArray<PushArgumentInstr*>* arguments,
                     const Array& argument_names,
                     intptr_t checked_argument_count,
                     const ZoneGrowableArray<const ICData*>& ic_data_array)
-      : ic_data_(GetICData(ic_data_array)),
+      : ic_data_(NULL),
         token_pos_(token_pos),
         function_name_(function_name),
         token_kind_(token_kind),
         arguments_(arguments),
         argument_names_(argument_names),
         checked_argument_count_(checked_argument_count) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+    ic_data_ = GetICData(ic_data_array);
     ASSERT(function_name.IsNotTemporaryScopedHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
     ASSERT(Token::IsBinaryOperator(token_kind) ||
            Token::IsEqualityOperator(token_kind) ||
            Token::IsRelationalOperator(token_kind) ||
            Token::IsPrefixOperator(token_kind) ||
            Token::IsIndexOperator(token_kind) ||
            Token::IsTypeTestOperator(token_kind) ||
            Token::IsTypeCastOperator(token_kind) ||
@@ skipping 153 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(StrictCompareInstr);
 };
 
 
 // Comparison instruction that is equivalent to the (left & right) == 0
 // comparison pattern.
 class TestSmiInstr : public ComparisonInstr {
  public:
   TestSmiInstr(intptr_t token_pos, Token::Kind kind, Value* left, Value* right)
       : ComparisonInstr(token_pos, kind, left, right) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(kind == Token::kEQ || kind == Token::kNE);
   }
 
   DECLARE_INSTRUCTION(TestSmi);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 210 matching lines @@
 // TODO(vegorov): ComparisonInstr should be switched to use IfTheElseInstr for
 // materialization of true and false constants.
 class IfThenElseInstr : public Definition {
  public:
   IfThenElseInstr(ComparisonInstr* comparison,
                   Value* if_true,
                   Value* if_false)
       : comparison_(comparison),
         if_true_(Smi::Cast(if_true->BoundConstant()).Value()),
         if_false_(Smi::Cast(if_false->BoundConstant()).Value()) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     // Adjust uses at the comparison.
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
     }
   }
 
   // Returns true if this combination of comparison and values flowing on
   // the true and false paths is supported on the current platform.
   static bool Supports(ComparisonInstr* comparison, Value* v1, Value* v2);
@@ skipping 57 matching lines @@
 };
 
 
 class StaticCallInstr : public TemplateDefinition<0> {
  public:
   StaticCallInstr(intptr_t token_pos,
                   const Function& function,
                   const Array& argument_names,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                   const ZoneGrowableArray<const ICData*>& ic_data_array)
-      : ic_data_(GetICData(ic_data_array)),
+      : ic_data_(NULL),
         token_pos_(token_pos),
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments),
         result_cid_(kDynamicCid),
         is_known_list_constructor_(false),
         is_native_list_factory_(false),
         identity_(AliasIdentity::Unknown()) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+    ic_data_ = GetICData(ic_data_array);
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle() ||  argument_names.InVMHeap());
   }
 
   // ICData for static calls carries call count.
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
@@ skipping 656 matching lines @@
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringToCharCodeInstr);
 };
 
 
 class StringInterpolateInstr : public TemplateDefinition<1> {
  public:
   StringInterpolateInstr(Value* value, intptr_t token_pos)
       : token_pos_(token_pos), function_(Function::Handle()) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   virtual CompileType ComputeType() const;
   // Issues a static call to Dart code which calls toString on objects.
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual bool CanDeoptimize() const { return true; }
@@ skipping 296 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<2> {
  public:
   CreateArrayInstr(intptr_t token_pos,
                    Value* element_type,
                    Value* num_elements)
       : token_pos_(token_pos), identity_(AliasIdentity::Unknown())  {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     SetInputAt(kElementTypePos, element_type);
     SetInputAt(kLengthPos, num_elements);
   }
 
   enum {
     kElementTypePos = 0,
     kLengthPos = 1
   };
 
   DECLARE_INSTRUCTION(CreateArray)
@@ skipping 186 matching lines @@
 
 class InstantiateTypeInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeInstr(intptr_t token_pos,
                        const AbstractType& type,
                        const Class& instantiator_class,
                        Value* instantiator)
       : token_pos_(token_pos),
         type_(type),
         instantiator_class_(instantiator_class) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(type.IsZoneHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateType)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractType& type() const { return type_;
   }
   const Class& instantiator_class() const { return instantiator_class_; }
@@ skipping 18 matching lines @@
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeArgumentsInstr(intptr_t token_pos,
                                 const TypeArguments& type_arguments,
                                 const Class& instantiator_class,
                                 Value* instantiator)
       : token_pos_(token_pos),
         type_arguments_(type_arguments),
         instantiator_class_(instantiator_class) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(type_arguments.IsZoneHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
   const TypeArguments& type_arguments() const {
     return type_arguments_;
   }
@@ skipping 45 matching lines @@
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class InitStaticFieldInstr : public TemplateInstruction<1> {
  public:
   InitStaticFieldInstr(Value* input, const Field& field)
       : field_(field) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     SetInputAt(0, input);
   }
 
   virtual intptr_t token_pos() const { return field_.token_pos(); }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
   virtual intptr_t ArgumentCount() const { return 0; }
   virtual bool CanDeoptimize() const { return true; }
@@ skipping 34 matching lines @@
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateUninitializedContextInstr);
 };
 
 
 class CloneContextInstr : public TemplateDefinition<1> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
       : token_pos_(token_pos) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     SetInputAt(0, context_value);
   }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return true; }
@@ skipping 2237 matching lines @@
   const Token::Kind op_kind_;
 };
 
 
 // Handles both Smi operations: BIT_OR and NEGATE.
 class UnarySmiOpInstr : public UnaryIntegerOpInstr {
  public:
   UnarySmiOpInstr(Token::Kind op_kind,
                   Value* value,
                   intptr_t deopt_id)
-      : UnaryIntegerOpInstr(op_kind, value, deopt_id) {
-  }
+      : UnaryIntegerOpInstr(op_kind, value, deopt_id) {}
 
   virtual bool CanDeoptimize() const { return op_kind() == Token::kNEGATE; }
 
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(UnarySmiOp)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
@@ skipping 389 matching lines @@
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryDoubleOpInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateInstruction<0> {
  public:
   CheckStackOverflowInstr(intptr_t token_pos, intptr_t loop_depth)
-      : token_pos_(token_pos), loop_depth_(loop_depth) {}
+      : token_pos_(token_pos), loop_depth_(loop_depth) {
+    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+  }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   bool in_loop() const { return loop_depth_ > 0; }
   intptr_t loop_depth() const { return loop_depth_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
@@ skipping 1167 matching lines @@
       Isolate* isolate, bool opt) const {                                     \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_