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

runtime/vm/deopt_instructions.cc

 // 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.
 
 #include "vm/deopt_instructions.h"
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
 #include "vm/parser.h"
 #include "vm/stack_frame.h"
+#include "vm/thread.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, compress_deopt_info, true,
             "Compress the size of the deoptimization info for optimized code.");
 DECLARE_FLAG(bool, trace_deoptimization);
 DECLARE_FLAG(bool, trace_deoptimization_verbose);
 
 
 DeoptContext::DeoptContext(const StackFrame* frame,
                            const Code& code,
                            DestFrameOptions dest_options,
                            fpu_register_t* fpu_registers,
                            intptr_t* cpu_registers)
     : code_(code.raw()),
       object_table_(code.object_table()),
       deopt_info_(DeoptInfo::null()),
       dest_frame_is_allocated_(false),
       dest_frame_(NULL),
       dest_frame_size_(0),
       source_frame_is_allocated_(false),
       source_frame_(NULL),
       source_frame_size_(0),
       cpu_registers_(cpu_registers),
       fpu_registers_(fpu_registers),
       num_args_(0),
       deopt_reason_(ICData::kDeoptUnknown),
       deopt_flags_(0),
-      isolate_(Isolate::Current()),
+      thread_(Thread::Current()),
       deferred_slots_(NULL),
       deferred_objects_count_(0),
       deferred_objects_(NULL) {
   const DeoptInfo& deopt_info = DeoptInfo::Handle(
       code.GetDeoptInfoAtPc(frame->pc(), &deopt_reason_, &deopt_flags_));
   ASSERT(!deopt_info.IsNull());
   deopt_info_ = deopt_info.raw();
 
   const Function& function = Function::Handle(code.function());
 
@@ skipping 279 matching lines @@
     OS::PrintErr("  Deopt args: %" Pd "\n", deopt_arg_count);
   }
 
   return deopt_arg_count;
 }
 
 
 RawArray* DeoptContext::DestFrameAsArray() {
   ASSERT(dest_frame_ != NULL && dest_frame_is_allocated_);
   const Array& dest_array =
-      Array::Handle(isolate(), Array::New(dest_frame_size_));
-  PassiveObject& obj = PassiveObject::Handle(isolate());
+      Array::Handle(zone(), Array::New(dest_frame_size_));
+  PassiveObject& obj = PassiveObject::Handle(zone());
   for (intptr_t i = 0; i < dest_frame_size_; i++) {
     obj = reinterpret_cast<RawObject*>(dest_frame_[i]);
     dest_array.SetAt(i, obj);
   }
   return dest_array.raw();
 }
 
 
 // Deoptimization instruction creating return address using function and
 // deopt-id stored at 'object_table_index'.
@@ skipping 11 matching lines @@
   }
 
   virtual intptr_t source_index() const {
     return ObjectTableIndex::encode(object_table_index_) |
         DeoptId::encode(deopt_id_);
   }
 
   virtual DeoptInstr::Kind kind() const { return kRetAddress; }
 
   virtual const char* ArgumentsToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
+    return Thread::Current()->zone()->PrintToString(
         "%" Pd ", %" Pd "", object_table_index_, deopt_id_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
-    Code& code = Code::Handle(deopt_context->isolate());
+    Code& code = Code::Handle(deopt_context->zone());
     code ^= deopt_context->ObjectAt(object_table_index_);
     ASSERT(!code.IsNull());
     uword continue_at_pc = code.GetPcForDeoptId(deopt_id_,
                                                 RawPcDescriptors::kDeopt);
     ASSERT(continue_at_pc != 0);
     *dest_addr = continue_at_pc;
 
     uword pc = code.GetPcForDeoptId(deopt_id_, RawPcDescriptors::kIcCall);
     if (pc != 0) {
       // If the deoptimization happened at an IC call, update the IC data
@@ skipping 36 matching lines @@
  public:
   explicit DeoptConstantInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
   }
 
   virtual intptr_t source_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kConstant; }
 
   virtual const char* ArgumentsToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
+    return Thread::Current()->zone()->PrintToString(
         "%" Pd "", object_table_index_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
     const PassiveObject& obj = PassiveObject::Handle(
-        deopt_context->isolate(), deopt_context->ObjectAt(object_table_index_));
+        deopt_context->zone(), deopt_context->ObjectAt(object_table_index_));
     *reinterpret_cast<RawObject**>(dest_addr) = obj.raw();
   }
 
  private:
   const intptr_t object_table_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptConstantInstr);
 };
 
 
@@ skipping 62 matching lines @@
   DeoptMintPairInstr(const CpuRegisterSource& lo, const CpuRegisterSource& hi)
       : DeoptIntegerInstrBase(), lo_(lo), hi_(hi) {}
 
   virtual intptr_t source_index() const {
     return LoRegister::encode(lo_.source_index()) |
            HiRegister::encode(hi_.source_index());
   }
   virtual DeoptInstr::Kind kind() const { return kMintPair; }
 
   virtual const char* ArgumentsToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
+    return Thread::Current()->zone()->PrintToString(
         "%s,%s",
         lo_.ToCString(),
         hi_.ToCString());
   }
 
   virtual int64_t GetValue(DeoptContext* deopt_context) {
     return Utils::LowHighTo64Bits(
         lo_.Value<uint32_t>(deopt_context), hi_.Value<int32_t>(deopt_context));
   }
 
@@ skipping 92 matching lines @@
  public:
   explicit DeoptPcMarkerInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
   }
 
   virtual intptr_t source_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kPcMarker; }
 
   virtual const char* ArgumentsToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
+    return Thread::Current()->zone()->PrintToString(
         "%" Pd "", object_table_index_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
-    Code& code = Code::Handle(deopt_context->isolate());
+    Code& code = Code::Handle(deopt_context->zone());
     code ^= deopt_context->ObjectAt(object_table_index_);
     if (code.IsNull()) {
       // Callee's PC marker is not used (pc of Deoptimize stub). Set to 0.
       *dest_addr = 0;
       return;
     }
     const Function& function =
-        Function::Handle(deopt_context->isolate(), code.function());
+        Function::Handle(deopt_context->zone(), code.function());
     ASSERT(function.HasCode());
     const intptr_t pc_marker =
         code.EntryPoint() + Assembler::EntryPointToPcMarkerOffset();
     *dest_addr = pc_marker;
     // Increment the deoptimization counter. This effectively increments each
     // function occurring in the optimized frame.
     function.set_deoptimization_counter(function.deoptimization_counter() + 1);
     if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
       OS::PrintErr("Deoptimizing %s (count %d)\n",
           function.ToFullyQualifiedCString(),
@@ skipping 20 matching lines @@
  public:
   explicit DeoptPpInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
   }
 
   virtual intptr_t source_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kPp; }
 
   virtual const char* ArgumentsToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
+    return Thread::Current()->zone()->PrintToString(
         "%" Pd "", object_table_index_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
-    Code& code = Code::Handle(deopt_context->isolate());
+    Code& code = Code::Handle(deopt_context->zone());
     code ^= deopt_context->ObjectAt(object_table_index_);
     ASSERT(!code.IsNull());
     const intptr_t pp = reinterpret_cast<intptr_t>(code.ObjectPool());
     *dest_addr = pp;
   }
 
  private:
   intptr_t object_table_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptPpInstr);
@@ skipping 71 matching lines @@
         suffix_length_(SuffixLength::decode(source_index)) {
   }
 
   virtual intptr_t source_index() const {
     return InfoNumber::encode(info_number_) |
         SuffixLength::encode(suffix_length_);
   }
   virtual DeoptInstr::Kind kind() const { return kSuffix; }
 
   virtual const char* ArgumentsToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
+    return Thread::Current()->zone()->PrintToString(
         "%" Pd ":%" Pd, info_number_, suffix_length_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
     // The deoptimization info is uncompressed by translating away suffixes
     // before executing the instructions.
     UNREACHABLE();
   }
 
  private:
@@ skipping 18 matching lines @@
  public:
   explicit DeoptMaterializedObjectRefInstr(intptr_t index)
       : index_(index) {
     ASSERT(index >= 0);
   }
 
   virtual intptr_t source_index() const { return index_; }
   virtual DeoptInstr::Kind kind() const { return kMaterializedObjectRef; }
 
   virtual const char* ArgumentsToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
+    return Thread::Current()->zone()->PrintToString(
         "#%" Pd "", index_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
     *reinterpret_cast<RawSmi**>(dest_addr) = Smi::New(0);
     deopt_context->DeferMaterializedObjectRef(
         index_, dest_addr);
   }
 
  private:
@@ skipping 10 matching lines @@
  public:
   explicit DeoptMaterializeObjectInstr(intptr_t field_count)
       : field_count_(field_count) {
     ASSERT(field_count >= 0);
   }
 
   virtual intptr_t source_index() const { return field_count_; }
   virtual DeoptInstr::Kind kind() const { return kMaterializeObject; }
 
   virtual const char* ArgumentsToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
+    return Thread::Current()->zone()->PrintToString(
         "%" Pd "", field_count_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
     // This instructions are executed manually by the DeoptimizeWithDeoptInfo.
     UNREACHABLE();
   }
 
  private:
   intptr_t field_count_;
@@ skipping 146 matching lines @@
   }
 
  private:
   const DeoptInstr* instruction_;  // Instruction that was written.
   const intptr_t info_number_;  // Index of the deopt info it was written to.
 
   GrowableArray<TrieNode*> children_;
 };
 
 
-DeoptInfoBuilder::DeoptInfoBuilder(Isolate* isolate, const intptr_t num_args)
-    : isolate_(isolate),
+DeoptInfoBuilder::DeoptInfoBuilder(Zone* zone, const intptr_t num_args)
+    : zone_(zone),
       instructions_(),
       object_table_(GrowableObjectArray::Handle(
           GrowableObjectArray::New(Heap::kOld))),
       num_args_(num_args),
-      trie_root_(new(isolate) TrieNode()),
+      trie_root_(new(zone) TrieNode()),
       current_info_number_(0),
       frame_start_(-1),
       materializations_() {
 }
 
 
 intptr_t DeoptInfoBuilder::FindOrAddObjectInTable(const Object& obj) const {
   for (intptr_t i = 0; i < object_table_.Length(); i++) {
     if (object_table_.At(i) == obj.raw()) {
       return i;
@@ skipping 44 matching lines @@
                                         intptr_t dest_index) {
   // Check that deopt_id exists.
   // TODO(vegorov): verify after deoptimization targets as well.
 #ifdef DEBUG
   ASSERT(Isolate::IsDeoptAfter(deopt_id) ||
          (code.GetPcForDeoptId(deopt_id, RawPcDescriptors::kDeopt) != 0));
 #endif
   const intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
   instructions_.Add(
-      new(isolate()) DeoptRetAddressInstr(object_table_index, deopt_id));
+      new(zone()) DeoptRetAddressInstr(object_table_index, deopt_id));
 }
 
 
 void DeoptInfoBuilder::AddPcMarker(const Code& code,
                                    intptr_t dest_index) {
   intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new(isolate()) DeoptPcMarkerInstr(object_table_index));
+  instructions_.Add(new(zone()) DeoptPcMarkerInstr(object_table_index));
 }
 
 
 void DeoptInfoBuilder::AddPp(const Code& code,
                              intptr_t dest_index) {
   intptr_t object_table_index = FindOrAddObjectInTable(code);
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new(isolate()) DeoptPpInstr(object_table_index));
+  instructions_.Add(new(zone()) DeoptPpInstr(object_table_index));
 }
 
 
 void DeoptInfoBuilder::AddCopy(Value* value,
                                const Location& source_loc,
                                const intptr_t dest_index) {
   DeoptInstr* deopt_instr = NULL;
   if (source_loc.IsConstant()) {
     intptr_t object_table_index = FindOrAddObjectInTable(source_loc.constant());
-    deopt_instr = new(isolate()) DeoptConstantInstr(object_table_index);
+    deopt_instr = new(zone()) DeoptConstantInstr(object_table_index);
   } else if (source_loc.IsInvalid() &&
              value->definition()->IsMaterializeObject()) {
     const intptr_t index = FindMaterialization(
         value->definition()->AsMaterializeObject());
     ASSERT(index >= 0);
-    deopt_instr = new(isolate()) DeoptMaterializedObjectRefInstr(index);
+    deopt_instr = new(zone()) DeoptMaterializedObjectRefInstr(index);
   } else {
     ASSERT(!source_loc.IsInvalid());
     switch (value->definition()->representation()) {
       case kTagged:
-        deopt_instr = new(isolate()) DeoptWordInstr(
+        deopt_instr = new(zone()) DeoptWordInstr(
           ToCpuRegisterSource(source_loc));
         break;
       case kUnboxedMint: {
         if (source_loc.IsPairLocation()) {
           PairLocation* pair = source_loc.AsPairLocation();
-          deopt_instr = new(isolate()) DeoptMintPairInstr(
+          deopt_instr = new(zone()) DeoptMintPairInstr(
               ToCpuRegisterSource(pair->At(0)),
               ToCpuRegisterSource(pair->At(1)));
         } else {
           ASSERT(!source_loc.IsPairLocation());
-          deopt_instr = new(isolate()) DeoptMintInstr(
+          deopt_instr = new(zone()) DeoptMintInstr(
               ToCpuRegisterSource(source_loc));
         }
         break;
       }
       case kUnboxedInt32:
-        deopt_instr = new(isolate()) DeoptInt32Instr(
+        deopt_instr = new(zone()) DeoptInt32Instr(
             ToCpuRegisterSource(source_loc));
         break;
       case kUnboxedUint32:
-        deopt_instr = new(isolate()) DeoptUint32Instr(
+        deopt_instr = new(zone()) DeoptUint32Instr(
             ToCpuRegisterSource(source_loc));
         break;
       case kUnboxedDouble:
-        deopt_instr = new(isolate()) DeoptDoubleInstr(
+        deopt_instr = new(zone()) DeoptDoubleInstr(
             ToFpuRegisterSource(source_loc, Location::kDoubleStackSlot));
         break;
       case kUnboxedFloat32x4:
-        deopt_instr = new(isolate()) DeoptFloat32x4Instr(
+        deopt_instr = new(zone()) DeoptFloat32x4Instr(
             ToFpuRegisterSource(source_loc, Location::kQuadStackSlot));
         break;
       case kUnboxedFloat64x2:
-        deopt_instr = new(isolate()) DeoptFloat64x2Instr(
+        deopt_instr = new(zone()) DeoptFloat64x2Instr(
             ToFpuRegisterSource(source_loc, Location::kQuadStackSlot));
         break;
       case kUnboxedInt32x4:
-        deopt_instr = new(isolate()) DeoptInt32x4Instr(
+        deopt_instr = new(zone()) DeoptInt32x4Instr(
             ToFpuRegisterSource(source_loc, Location::kQuadStackSlot));
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
   ASSERT(dest_index == FrameSize());
   ASSERT(deopt_instr != NULL);
   instructions_.Add(deopt_instr);
 }
 
 
 void DeoptInfoBuilder::AddCallerFp(intptr_t dest_index) {
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new(isolate()) DeoptCallerFpInstr());
+  instructions_.Add(new(zone()) DeoptCallerFpInstr());
 }
 
 
 void DeoptInfoBuilder::AddCallerPp(intptr_t dest_index) {
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new(isolate()) DeoptCallerPpInstr());
+  instructions_.Add(new(zone()) DeoptCallerPpInstr());
 }
 
 
 void DeoptInfoBuilder::AddCallerPc(intptr_t dest_index) {
   ASSERT(dest_index == FrameSize());
-  instructions_.Add(new(isolate()) DeoptCallerPcInstr());
+  instructions_.Add(new(zone()) DeoptCallerPcInstr());
 }
 
 
 void DeoptInfoBuilder::AddConstant(const Object& obj, intptr_t dest_index) {
   ASSERT(dest_index == FrameSize());
   intptr_t object_table_index = FindOrAddObjectInTable(obj);
-  instructions_.Add(new(isolate()) DeoptConstantInstr(object_table_index));
+  instructions_.Add(new(zone()) DeoptConstantInstr(object_table_index));
 }
 
 
 void DeoptInfoBuilder::AddMaterialization(MaterializeObjectInstr* mat) {
   const intptr_t index = FindMaterialization(mat);
   if (index >= 0) {
     return;  // Already added.
   }
   materializations_.Add(mat);
 
   // Count initialized fields and emit kMaterializeObject instruction.
   // There is no need to write nulls into fields because object is null
   // initialized by default.
   intptr_t non_null_fields = 0;
   for (intptr_t i = 0; i < mat->InputCount(); i++) {
     if (!mat->InputAt(i)->BindsToConstantNull()) {
       non_null_fields++;
     }
   }
 
   instructions_.Add(
-      new(isolate()) DeoptMaterializeObjectInstr(non_null_fields));
+      new(zone()) DeoptMaterializeObjectInstr(non_null_fields));
 
   for (intptr_t i = 0; i < mat->InputCount(); i++) {
     MaterializeObjectInstr* nested_mat = mat->InputAt(i)->definition()->
         AsMaterializeObject();
     if (nested_mat != NULL) {
       AddMaterialization(nested_mat);
     }
   }
 }
 
@@ skipping 47 matching lines @@
       if (node == NULL) break;
       suffix = node;
       ++suffix_length;
     }
   }
 
   // Allocate space for the translation.  If the shared suffix is longer
   // than one instruction, we replace it with a single suffix instruction.
   if (suffix_length > 1) length -= (suffix_length - 1);
   const DeoptInfo& deopt_info =
-      DeoptInfo::Handle(isolate(), DeoptInfo::New(length));
+      DeoptInfo::Handle(zone(), DeoptInfo::New(length));
 
   // Write the unshared instructions and build their sub-tree.
   TrieNode* node = NULL;
   intptr_t write_count = (suffix_length > 1) ? length - 1 : length;
   for (intptr_t i = 0; i < write_count; ++i) {
     DeoptInstr* instr = instructions_[i];
     deopt_info.SetAt(i, instr->kind(), instr->source_index());
     TrieNode* child = node;
-    node = new(isolate()) TrieNode(instr, current_info_number_);
+    node = new(zone()) TrieNode(instr, current_info_number_);
     node->AddChild(child);
   }
 
   if (suffix_length > 1) {
     suffix->AddChild(node);
     DeoptInstr* instr =
-        new(isolate()) DeoptSuffixInstr(suffix->info_number(), suffix_length);
+        new(zone()) DeoptSuffixInstr(suffix->info_number(), suffix_length);
     deopt_info.SetAt(length - 1, instr->kind(), instr->source_index());
   } else {
     trie_root_->AddChild(node);
   }
 
   ASSERT(deopt_info.VerifyDecompression(instructions_, deopt_table));
   instructions_.Clear();
   materializations_.Clear();
   frame_start_ = -1;
 
@@ skipping 30 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart