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.

[Florian Schneider, 2014/09/25 09:55:34]

How about moving deopt_id_ out of Instruction and only have it in those
instructions that need it (essentially the list of friend classes here and
above)

This way we can also get rid of these friend class declarations and save space
in unoptimzied instructions that never need a deopt-id (e.g. LoadLocal,
PushArgument, StoreLocal, ConstantIntr, etc)

[srdjan, 2014/09/25 17:42:16]

That is a much more invasive change, but should reduce compiler's memory
consumption. I will try it out.

+  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_