Thread/Isolate refactoring: new(Isolate) -> new(Zone)

runtime/vm/deopt_instructions.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_DEOPT_INSTRUCTIONS_H_
 #define VM_DEOPT_INSTRUCTIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/deferred_objects.h"
 #include "vm/growable_array.h"
 #include "vm/locations.h"
 #include "vm/object.h"
+#include "vm/thread.h"
 
 namespace dart {
 
 class Location;
 class Value;
 class MaterializeObjectInstr;
 class StackFrame;
 
 // Holds all data relevant for execution of deoptimization instructions.
 class DeoptContext {
@@ skipping 52 matching lines @@
     ASSERT(reg < kNumberOfFpuRegisters);
     const float* address = reinterpret_cast<float*>(&fpu_registers_[reg]);
     return simd128_value_t().readFrom(address);
   }
 
   void set_dest_frame(intptr_t* dest_frame) {
     ASSERT(dest_frame != NULL && dest_frame_ == NULL);
     dest_frame_ = dest_frame;
   }
 
-  Isolate* isolate() const { return isolate_; }
+  Zone* zone() const { return thread_->zone(); }
 
   intptr_t source_frame_size() const { return source_frame_size_; }
   intptr_t dest_frame_size() const { return dest_frame_size_; }
 
   RawCode* code() const { return code_; }
 
   ICData::DeoptReasonId deopt_reason() const { return deopt_reason_; }
   bool HasDeoptFlag(ICData::DeoptFlags flag) {
     return (deopt_flags_ & flag) != 0;
   }
@@ skipping 91 matching lines @@
   intptr_t dest_frame_size_;
   bool source_frame_is_allocated_;
   intptr_t* source_frame_;
   intptr_t source_frame_size_;
   intptr_t* cpu_registers_;
   fpu_register_t* fpu_registers_;
   intptr_t num_args_;
   ICData::DeoptReasonId deopt_reason_;
   uint32_t deopt_flags_;
   intptr_t caller_fp_;
-  Isolate* isolate_;
+  Thread* thread_;
 
   DeferredSlot* deferred_slots_;
 
   intptr_t deferred_objects_count_;
   DeferredObject** deferred_objects_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptContext);
 };
 
 
@@ skipping 30 matching lines @@
   };
 
   static DeoptInstr* Create(intptr_t kind_as_int, intptr_t source_index);
 
   DeoptInstr() {}
   virtual ~DeoptInstr() {}
 
   virtual const char* ToCString() const {
     const char* args = ArgumentsToCString();
     if (args != NULL) {
-      return Isolate::Current()->current_zone()->PrintToString(
+      return Thread::Current()->zone()->PrintToString(
           "%s(%s)", KindToCString(kind()), args);
     } else {
       return KindToCString(kind());
     }
   }
 
   virtual void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) = 0;
 
   virtual DeoptInstr::Kind kind() const = 0;
 
@@ skipping 94 matching lines @@
           context->source_frame_size() - raw_index() - 1));
     }
   }
 
   intptr_t source_index() const { return source_index_; }
 
   const char* ToCString() const {
     if (is_register()) {
       return Name(reg());
     } else {
-      return Isolate::Current()->current_zone()->PrintToString(
+      return Thread::Current()->zone()->PrintToString(
           "s%" Pd "", raw_index());
     }
   }
 
  private:
   class KindField : public BitField<intptr_t, 0, 1> { };
   class RawIndexField : public BitField<intptr_t, 1, kBitsPerWord - 1> { };
 
   bool is_register() const {
     return KindField::decode(source_index_) == kRegister;
@@ skipping 18 matching lines @@
 typedef RegisterSource<FpuRegister> FpuRegisterSource;
 
 
 // Builds a deoptimization info table, one DeoptInfo at a time.  Call AddXXX
 // methods in the order of their target, starting wih deoptimized code
 // continuation pc and ending with the first argument of the deoptimized
 // code.  Call CreateDeoptInfo to write the accumulated instructions into
 // the heap and reset the builder's internal state for the next DeoptInfo.
 class DeoptInfoBuilder : public ValueObject {
  public:
-  DeoptInfoBuilder(Isolate* isolate, const intptr_t num_args);
+  DeoptInfoBuilder(Zone* zone, const intptr_t num_args);
 
   // 'object_table' holds all objects referred to by DeoptInstr in
   // all DeoptInfo instances for a single Code object.
   const GrowableObjectArray& object_table() { return object_table_; }
 
   // Return address before instruction.
   void AddReturnAddress(const Code& code,
                         intptr_t deopt_id,
                         intptr_t dest_index);
 
@@ skipping 40 matching lines @@
   intptr_t FindOrAddObjectInTable(const Object& obj) const;
   intptr_t FindMaterialization(MaterializeObjectInstr* mat) const;
   intptr_t CalculateStackIndex(const Location& source_loc) const;
 
   intptr_t FrameSize() const {
     return instructions_.length() - frame_start_;
   }
 
   void AddConstant(const Object& obj, intptr_t dest_index);
 
-  Isolate* isolate() const { return isolate_; }
+  Zone* zone() const { return zone_; }
 
-  Isolate* isolate_;
+  Zone* zone_;
 
   GrowableArray<DeoptInstr*> instructions_;
   const GrowableObjectArray& object_table_;
   const intptr_t num_args_;
 
   // Used to compress entries by sharing suffixes.
   TrieNode* trie_root_;
   intptr_t current_info_number_;
 
   intptr_t frame_start_;
@@ skipping 39 matching lines @@
   class ReasonField : public BitField<ICData::DeoptReasonId, 0, 8> { };
   class FlagsField : public BitField<uint32_t, 8, 8> { };
 
  private:
   static const intptr_t kEntrySize = 3;
 };
 
 }  // namespace dart
 
 #endif  // VM_DEOPT_INSTRUCTIONS_H_