Move deopt_id and related helpers/definitions from Isolate to Thread

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 581 matching lines @@
 
 #define DECLARE_INSTRUCTION_BACKEND()                                          \
   virtual LocationSummary* MakeLocationSummary(Zone* zone,                     \
                                                bool optimizing) const;         \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);                    \
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   DECLARE_INSTRUCTION_NO_BACKEND(type)                                         \
   DECLARE_INSTRUCTION_BACKEND()                                                \
 

[Florian Schneider, 2015/10/13 09:35:27]

Wouldn't it make sense to make kNoDeoptId top-level here in this file? It's
tedious to write Thread::kNoDeoptId, plus it is strange to depend on including
thread.h for this constant - intermediate_language.h seems like a better place.

enum {
  kNoDeoptId = -1;
};

[srdjan, 2015/10/13 19:23:15]

Good point. Note that Thread::kNoDeoptId is shorter than Isolate::kNoDeoptId
;-). 
Talked about it with others in MTV, and the only consensus is that we need to
make it better, and that making it a global is not the best solution.
Other possibilities: In the thread, store a compiler state instead of CHA,
deopt_id, .... and move the deopt_id handling there.

Leaving it as it is for now.

 class Instruction : public ZoneAllocated {
  public:
 #define DECLARE_TAG(type) k##type,
   enum Tag {
     FOR_EACH_INSTRUCTION(DECLARE_TAG)
   };
 #undef DECLARE_TAG
 
-  explicit Instruction(intptr_t deopt_id = Isolate::kNoDeoptId)
+  explicit Instruction(intptr_t deopt_id = Thread::kNoDeoptId)
       : deopt_id_(deopt_id),
         lifetime_position_(kNoPlaceId),
         previous_(NULL),
         next_(NULL),
         env_(NULL),
         locs_(NULL),
         inlining_id_(-1) { }
 
   virtual ~Instruction() { }
 
@@ skipping 143 matching lines @@
 
   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;
+    return Thread::kNoDeoptId;
   }
 
   // Returns a replacement for the instruction or NULL if the instruction can
   // be eliminated.  By default returns the this instruction which means no
   // change.
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   // Insert this instruction before 'next' after use lists are computed.
   // Instructions cannot be inserted before a block entry or any other
   // instruction without a previous instruction.
@@ skipping 152 matching lines @@
 struct NoCSE {
   typedef DefaultBase Base;
 };
 
 
 template<intptr_t N,
          typename ThrowsTrait,
          template<typename Default, typename Pure> class CSETrait = NoCSE>
 class TemplateInstruction: public CSETrait<Instruction, PureInstruction>::Base {
  public:
-  explicit TemplateInstruction(intptr_t deopt_id = Isolate::kNoDeoptId)
+  explicit TemplateInstruction(intptr_t deopt_id = Thread::kNoDeoptId)
       : CSETrait<Instruction, PureInstruction>::Base(deopt_id), inputs_() { }
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
@@ skipping 239 matching lines @@
   void set_offset(intptr_t offset) { offset_ = offset; }
 
   // For all instruction in this block: Remove all inputs (including in the
   // environment) from their definition's use lists for all instructions.
   void ClearAllInstructions();
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BlockEntry)
 
  protected:
   BlockEntryInstr(intptr_t block_id, intptr_t try_index)
-      : Instruction(Isolate::Current()->GetNextDeoptId()),
+      : Instruction(Thread::Current()->GetNextDeoptId()),
         block_id_(block_id),
         try_index_(try_index),
         preorder_number_(-1),
         postorder_number_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL),
         offset_(-1),
         parallel_move_(NULL),
         loop_info_(NULL) {
@@ skipping 105 matching lines @@
 
   void AddIndirectEntry(IndirectEntryInstr* entry) {
     indirect_entries_.Add(entry);
   }
 
   GrowableArray<Definition*>* initial_definitions() {
     return &initial_definitions_;
   }
   ConstantInstr* constant_null();
 
-  bool IsCompiledForOsr() const { return osr_id_ != Isolate::kNoDeoptId; }
+  bool IsCompiledForOsr() const { return osr_id_ != Thread::kNoDeoptId; }
 
   intptr_t entry_count() const { return entry_count_; }
   void set_entry_count(intptr_t count) { entry_count_ = count; }
 
   intptr_t spill_slot_count() const { return spill_slot_count_; }
   void set_spill_slot_count(intptr_t count) {
     ASSERT(count >= 0);
     spill_slot_count_ = count;
   }
 
@@ skipping 287 matching lines @@
   COMPILE_ASSERT((kAliased & kNotAliased) == 0);
   COMPILE_ASSERT((kAllocationSinkingCandidate & kNotAliased) != 0);
 
   intptr_t value_;
 };
 
 
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
-  explicit Definition(intptr_t deopt_id = Isolate::kNoDeoptId);
+  explicit Definition(intptr_t deopt_id = Thread::kNoDeoptId);
 
   // Overridden by definitions that have call counts.
   virtual intptr_t CallCount() const {
     UNREACHABLE();
     return -1;
   }
 
   intptr_t temp_index() const { return temp_index_; }
   void set_temp_index(intptr_t index) { temp_index_ = index; }
   void ClearTempIndex() { temp_index_ = -1; }
@@ skipping 182 matching lines @@
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 };
 
 
 template<intptr_t N,
          typename ThrowsTrait,
          template<typename Impure, typename Pure> class CSETrait = NoCSE>
 class TemplateDefinition : public CSETrait<Definition, PureDefinition>::Base {
  public:
-  explicit TemplateDefinition(intptr_t deopt_id = Isolate::kNoDeoptId)
+  explicit TemplateDefinition(intptr_t deopt_id = Thread::kNoDeoptId)
       : CSETrait<Definition, PureDefinition>::Base(deopt_id), inputs_() { }
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
@@ skipping 186 matching lines @@
 
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
 class ReturnInstr : public TemplateInstruction<1, NoThrow> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Return instruction might turn into a Goto instruction after inlining.
     // Every Goto must have an environment.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public TemplateInstruction<0, Throws> {
  public:
   explicit ThrowInstr(intptr_t token_pos)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
   }
 
   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(); }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public TemplateInstruction<0, Throws> {
  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)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         catch_try_index_(catch_try_index) {
   }
 
   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_; }
@@ skipping 32 matching lines @@
  private:
   const char* message_;
 
   DISALLOW_COPY_AND_ASSIGN(StopInstr);
 };
 
 
 class GotoInstr : public TemplateInstruction<0, NoThrow> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
-    : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+    : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
       block_(NULL),
       successor_(entry),
       edge_weight_(0.0),
       parallel_move_(NULL) {
   }
 
   DECLARE_INSTRUCTION(Goto)
 
   BlockEntryInstr* block() const { return block_; }
   void set_block(BlockEntryInstr* block) { block_ = block; }
@@ skipping 143 matching lines @@
         (operation_cid() == other_comparison->operation_cid());
   }
 
   DEFINE_INSTRUCTION_TYPE_CHECK(Comparison)
 
  protected:
   ComparisonInstr(intptr_t token_pos,
                   Token::Kind kind,
                   Value* left,
                   Value* right,
-                  intptr_t deopt_id = Isolate::kNoDeoptId)
+                  intptr_t deopt_id = Thread::kNoDeoptId)
       : TemplateDefinition(deopt_id),
         token_pos_(token_pos),
         kind_(kind),
         operation_cid_(kIllegalCid) {
     SetInputAt(0, left);
     if (right != NULL) {
       SetInputAt(1, right);
     }
   }
 
  private:
   const intptr_t token_pos_;
   Token::Kind kind_;
   intptr_t operation_cid_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(ComparisonInstr);
 };
 
 
 class BranchInstr : public Instruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison)
-      : Instruction(Isolate::Current()->GetNextDeoptId()),
+      : Instruction(Thread::Current()->GetNextDeoptId()),
         comparison_(comparison),
         is_checked_(false),
         constrained_type_(NULL),
         constant_target_(NULL) {
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
     }
   }
 
@@ skipping 287 matching lines @@
   AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1, Throws, Pure> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     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]; }
 
@@ skipping 10 matching lines @@
 
   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, NoThrow> {
  public:
   CurrentContextInstr()
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()) {
+      : TemplateDefinition(Thread::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; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
 class ClosureCallInstr : public TemplateDefinition<1, Throws> {
  public:
   ClosureCallInstr(Value* function,
                    ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         ast_node_(*node),
         arguments_(arguments) {
     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(); }
 
@@ skipping 21 matching lines @@
 
 class InstanceCallInstr : public TemplateDefinition<0, Throws> {
  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)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         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) {
     ic_data_ = GetICData(ic_data_array);
     ASSERT(function_name.IsNotTemporaryScopedHandle());
     ASSERT(!arguments->is_empty());
@@ skipping 203 matching lines @@
     return cid_results_;
   }
 
   DECLARE_INSTRUCTION(TestCids);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const {
-    return GetDeoptId() != Isolate::kNoDeoptId;
+    return GetDeoptId() != Thread::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
@@ skipping 91 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)
-      : Definition(Isolate::Current()->GetNextDeoptId()),
+      : Definition(Thread::Current()->GetNextDeoptId()),
         comparison_(comparison),
         if_true_(Smi::Cast(if_true->BoundConstant()).Value()),
         if_false_(Smi::Cast(if_false->BoundConstant()).Value()) {
     // 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);
     }
   }
 
@@ skipping 60 matching lines @@
 };
 
 
 class StaticCallInstr : public TemplateDefinition<0, Throws> {
  public:
   StaticCallInstr(intptr_t token_pos,
                   const Function& function,
                   const Array& argument_names,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                   const ZoneGrowableArray<const ICData*>& ic_data_array)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         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()) {
     ic_data_ = GetICData(ic_data_array);
@@ skipping 554 matching lines @@
   bool IsExternal() const {
     return array()->definition()->representation() == kUntagged;
   }
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
 
   virtual bool CanDeoptimize() const {
-    return GetDeoptId() != Isolate::kNoDeoptId;
+    return GetDeoptId() != Thread::kNoDeoptId;
   }
 
   virtual Representation representation() const;
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const intptr_t index_scale_;
   const intptr_t class_id_;
@@ skipping 122 matching lines @@
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringToCharCodeInstr);
 };
 
 
 class StringInterpolateInstr : public TemplateDefinition<1, Throws> {
  public:
   StringInterpolateInstr(Value* value, intptr_t token_pos)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         function_(Function::ZoneHandle()) {
     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.
@@ skipping 346 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<2, Throws> {
  public:
   CreateArrayInstr(intptr_t token_pos,
                    Value* element_type,
                    Value* num_elements)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         identity_(AliasIdentity::Unknown())  {
     SetInputAt(kElementTypePos, element_type);
     SetInputAt(kLengthPos, num_elements);
   }
 
   enum {
     kElementTypePos = 0,
     kLengthPos = 1
   };
@@ skipping 182 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
 
 class InstantiateTypeInstr : public TemplateDefinition<1, Throws> {
  public:
   InstantiateTypeInstr(intptr_t token_pos,
                        const AbstractType& type,
                        const Class& instantiator_class,
                        Value* instantiator)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         type_(type),
         instantiator_class_(instantiator_class) {
     ASSERT(type.IsZoneHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateType)
 
   Value* instantiator() const { return inputs_[0]; }
@@ skipping 16 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
 };
 
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<1, Throws> {
  public:
   InstantiateTypeArgumentsInstr(intptr_t token_pos,
                                 const TypeArguments& type_arguments,
                                 const Class& instantiator_class,
                                 Value* instantiator)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         type_arguments_(type_arguments),
         instantiator_class_(instantiator_class) {
     ASSERT(type_arguments.IsZoneHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
@@ skipping 43 matching lines @@
   const intptr_t token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class InitStaticFieldInstr : public TemplateInstruction<1, Throws> {
  public:
   InitStaticFieldInstr(Value* input, const Field& field)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         field_(field) {
     SetInputAt(0, input);
   }
 
   virtual intptr_t token_pos() const { return field_.token_pos(); }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
   virtual bool CanDeoptimize() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldInstr);
 };
 
 
 class CloneContextInstr : public TemplateDefinition<1, NoThrow> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     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;
 
@@ skipping 101 matching lines @@
   static BoxInstr* Create(Representation from, Value* value);
 
   Value* value() const { return inputs_[0]; }
   Representation from_representation() const { return from_representation_; }
 
   DECLARE_INSTRUCTION(Box)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
   virtual intptr_t DeoptimizationTarget() const {
-    return Isolate::kNoDeoptId;
+    return Thread::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return from_representation();
   }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsBox()->from_representation() == from_representation();
   }
@@ skipping 2381 matching lines @@
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryDoubleOpInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateInstruction<0, NoThrow> {
  public:
   CheckStackOverflowInstr(intptr_t token_pos, intptr_t loop_depth)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         loop_depth_(loop_depth) {
   }
 
   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)
 
@@ skipping 995 matching lines @@
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {    \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_