Pass Isolates explicitly in Deoptimizer-related code.

src/deoptimizer.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 22 matching lines @@
 #include "disasm.h"
 #include "full-codegen.h"
 #include "global-handles.h"
 #include "macro-assembler.h"
 #include "prettyprinter.h"
 
 
 namespace v8 {
 namespace internal {
 
-DeoptimizerData::DeoptimizerData() {
-  eager_deoptimization_entry_code_entries_ = -1;
-  lazy_deoptimization_entry_code_entries_ = -1;
-  size_t deopt_table_size = Deoptimizer::GetMaxDeoptTableSize();
-  MemoryAllocator* allocator = Isolate::Current()->memory_allocator();
-  size_t initial_commit_size = OS::CommitPageSize();
-  eager_deoptimization_entry_code_ =
-      allocator->AllocateChunk(deopt_table_size,
-                               initial_commit_size,
-                               EXECUTABLE,
-                               NULL);
-  lazy_deoptimization_entry_code_ =
-       allocator->AllocateChunk(deopt_table_size,
-                               initial_commit_size,
-                               EXECUTABLE,
-                               NULL);
-  current_ = NULL;
-  deoptimizing_code_list_ = NULL;
-#ifdef ENABLE_DEBUGGER_SUPPORT
-  deoptimized_frame_info_ = NULL;
-#endif
+static MemoryChunk* AllocateCodeChunk(MemoryAllocator* allocator) {
+  return allocator->AllocateChunk(Deoptimizer::GetMaxDeoptTableSize(),
+                                  OS::CommitPageSize(),
+                                  EXECUTABLE,
+                                  NULL);
 }
 
 
+DeoptimizerData::DeoptimizerData(MemoryAllocator* allocator)
+    : allocator_(allocator),
+      eager_deoptimization_entry_code_entries_(-1),
+      lazy_deoptimization_entry_code_entries_(-1),
+      eager_deoptimization_entry_code_(AllocateCodeChunk(allocator)),
+      lazy_deoptimization_entry_code_(AllocateCodeChunk(allocator)),
+      current_(NULL),
+#ifdef ENABLE_DEBUGGER_SUPPORT
+      deoptimized_frame_info_(NULL),
+#endif
+      deoptimizing_code_list_(NULL) { }
+
+
 DeoptimizerData::~DeoptimizerData() {
-  Isolate::Current()->memory_allocator()->Free(
-      eager_deoptimization_entry_code_);
+  allocator_->Free(eager_deoptimization_entry_code_);
   eager_deoptimization_entry_code_ = NULL;
-  Isolate::Current()->memory_allocator()->Free(
-      lazy_deoptimization_entry_code_);
+  allocator_->Free(lazy_deoptimization_entry_code_);
   lazy_deoptimization_entry_code_ = NULL;
 
   DeoptimizingCodeListNode* current = deoptimizing_code_list_;
   while (current != NULL) {
     DeoptimizingCodeListNode* prev = current;
     current = current->next();
     delete prev;
   }
   deoptimizing_code_list_ = NULL;
 }
@@ skipping 39 matching lines @@
 
 
 // We rely on this function not causing a GC.  It is called from generated code
 // without having a real stack frame in place.
 Deoptimizer* Deoptimizer::New(JSFunction* function,
                               BailoutType type,
                               unsigned bailout_id,
                               Address from,
                               int fp_to_sp_delta,
                               Isolate* isolate) {
-  ASSERT(isolate == Isolate::Current());
   Deoptimizer* deoptimizer = new Deoptimizer(isolate,
                                              function,
                                              type,
                                              bailout_id,
                                              from,
                                              fp_to_sp_delta,
                                              NULL);
   ASSERT(isolate->deoptimizer_data()->current_ == NULL);
   isolate->deoptimizer_data()->current_ = deoptimizer;
   return deoptimizer;
 }
 
 
 // No larger than 2K on all platforms
 static const int kDeoptTableMaxEpilogueCodeSize = 2 * KB;
 
 
 size_t Deoptimizer::GetMaxDeoptTableSize() {
   int entries_size =
       Deoptimizer::kMaxNumberOfEntries * Deoptimizer::table_entry_size_;
   int commit_page_size = static_cast<int>(OS::CommitPageSize());
   int page_count = ((kDeoptTableMaxEpilogueCodeSize + entries_size - 1) /
                     commit_page_size) + 1;
   return static_cast<size_t>(commit_page_size * page_count);
 }
 
 
 Deoptimizer* Deoptimizer::Grab(Isolate* isolate) {
-  ASSERT(isolate == Isolate::Current());
   Deoptimizer* result = isolate->deoptimizer_data()->current_;
   ASSERT(result != NULL);
   result->DeleteFrameDescriptions();
   isolate->deoptimizer_data()->current_ = NULL;
   return result;
 }
 
 
 int Deoptimizer::ConvertJSFrameIndexToFrameIndex(int jsframe_index) {
   if (jsframe_index == 0) return 0;
 
   int frame_index = 0;
   while (jsframe_index >= 0) {
     FrameDescription* frame = output_[frame_index];
     if (frame->GetFrameType() == StackFrame::JAVA_SCRIPT) {
       jsframe_index--;
     }
     frame_index++;
   }
 
   return frame_index - 1;
 }
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 DeoptimizedFrameInfo* Deoptimizer::DebuggerInspectableFrame(
     JavaScriptFrame* frame,
     int jsframe_index,
     Isolate* isolate) {
-  ASSERT(isolate == Isolate::Current());
   ASSERT(frame->is_optimized());
   ASSERT(isolate->deoptimizer_data()->deoptimized_frame_info_ == NULL);
 
   // Get the function and code from the frame.
   JSFunction* function = JSFunction::cast(frame->function());
   Code* code = frame->LookupCode();
 
   // Locate the deoptimization point in the code. As we are at a call the
   // return address must be at a place in the code with deoptimization support.
   SafepointEntry safepoint_entry = code->GetSafepointEntry(frame->pc());
@@ skipping 65 matching lines @@
 
   // Finished using the deoptimizer instance.
   delete deoptimizer;
 
   return info;
 }
 
 
 void Deoptimizer::DeleteDebuggerInspectableFrame(DeoptimizedFrameInfo* info,
                                                  Isolate* isolate) {
-  ASSERT(isolate == Isolate::Current());
   ASSERT(isolate->deoptimizer_data()->deoptimized_frame_info_ == info);
   delete info;
   isolate->deoptimizer_data()->deoptimized_frame_info_ = NULL;
 }
 #endif
 
 void Deoptimizer::GenerateDeoptimizationEntries(MacroAssembler* masm,
                                                 int count,
                                                 BailoutType type) {
   TableEntryGenerator generator(masm, type, count);
@@ skipping 24 matching lines @@
   // Run through the snapshot of optimized functions and visit them.
   for (int i = 0; i < snapshot.length(); ++i) {
     visitor->VisitFunction(snapshot.at(i));
   }
 
   visitor->LeaveContext(context);
 }
 
 
 void Deoptimizer::VisitAllOptimizedFunctions(
+    Isolate* isolate,
     OptimizedFunctionVisitor* visitor) {
   AssertNoAllocation no_allocation;
 
   // Run through the list of all native contexts and deoptimize.
-  Object* context = Isolate::Current()->heap()->native_contexts_list();
+  Object* context = isolate->heap()->native_contexts_list();
   while (!context->IsUndefined()) {
     VisitAllOptimizedFunctionsForContext(Context::cast(context), visitor);
     context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
   }
 }
 
 
 // Removes the functions selected by the given filter from the optimized
 // function list of the given context and partitions the removed functions
 // into one or more lists such that all functions in a list share the same
@@ skipping 50 matching lines @@
  public:
   explicit DeoptimizeWithMatchingCodeFilter(Code* code) : code_(code) {}
   virtual bool TakeFunction(JSFunction* function) {
     return function->code() == code_;
   }
  private:
   Code* code_;
 };
 
 
-void Deoptimizer::DeoptimizeAll() {
+void Deoptimizer::DeoptimizeAll(Isolate* isolate) {
   AssertNoAllocation no_allocation;
 
   if (FLAG_trace_deopt) {
     PrintF("[deoptimize all contexts]\n");
   }
 
   DeoptimizeAllFilter filter;
-  DeoptimizeAllFunctionsWith(&filter);
+  DeoptimizeAllFunctionsWith(isolate, &filter);
 }
 
 
 void Deoptimizer::DeoptimizeGlobalObject(JSObject* object) {
   AssertNoAllocation no_allocation;
   DeoptimizeAllFilter filter;
   if (object->IsJSGlobalProxy()) {
     Object* proto = object->GetPrototype();
     ASSERT(proto->IsJSGlobalObject());
     DeoptimizeAllFunctionsForContext(
@@ skipping 33 matching lines @@
   ZoneList<Code*> codes(1, zone);
   PartitionOptimizedFunctions(context, filter, &codes, zone, undefined);
   for (int i = 0; i < codes.length(); ++i) {
     DeoptimizeFunctionWithPreparedFunctionList(
         JSFunction::cast(codes.at(i)->deoptimizing_functions()));
     codes.at(i)->set_deoptimizing_functions(undefined);
   }
 }
 
 
-void Deoptimizer::DeoptimizeAllFunctionsWith(OptimizedFunctionFilter* filter) {
+void Deoptimizer::DeoptimizeAllFunctionsWith(Isolate* isolate,
+                                             OptimizedFunctionFilter* filter) {
   AssertNoAllocation no_allocation;
 
   // Run through the list of all native contexts and deoptimize.
-  Object* context = Isolate::Current()->heap()->native_contexts_list();
+  Object* context = isolate->heap()->native_contexts_list();
   while (!context->IsUndefined()) {
     DeoptimizeAllFunctionsForContext(Context::cast(context), filter);
     context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
   }
 }
 
 
 void Deoptimizer::HandleWeakDeoptimizedCode(v8::Isolate* isolate,
                                             v8::Persistent<v8::Value> obj,
                                             void* parameter) {
@@ skipping 159 matching lines @@
   ASSERT(!HEAP->allow_allocation(true));
 }
 
 
 Address Deoptimizer::GetDeoptimizationEntry(Isolate* isolate,
                                             int id,
                                             BailoutType type,
                                             GetEntryMode mode) {
   ASSERT(id >= 0);
   if (id >= kMaxNumberOfEntries) return NULL;
-  MemoryChunk* base = NULL;
   if (mode == ENSURE_ENTRY_CODE) {
     EnsureCodeForDeoptimizationEntry(isolate, type, id);
   } else {
     ASSERT(mode == CALCULATE_ENTRY_ADDRESS);
   }
   DeoptimizerData* data = isolate->deoptimizer_data();
-  if (type == EAGER) {
-    base = data->eager_deoptimization_entry_code_;
-  } else {
-    base = data->lazy_deoptimization_entry_code_;
-  }
+  MemoryChunk* base = (type == EAGER)
+      ? data->eager_deoptimization_entry_code_
+      : data->lazy_deoptimization_entry_code_;
   return base->area_start() + (id * table_entry_size_);
 }
 
 
-int Deoptimizer::GetDeoptimizationId(Address addr, BailoutType type) {
-  MemoryChunk* base = NULL;
-  DeoptimizerData* data = Isolate::Current()->deoptimizer_data();
-  if (type == EAGER) {
-    base = data->eager_deoptimization_entry_code_;
-  } else {
-    base = data->lazy_deoptimization_entry_code_;
-  }
+int Deoptimizer::GetDeoptimizationId(Isolate* isolate,
+                                     Address addr,
+                                     BailoutType type) {
+  DeoptimizerData* data = isolate->deoptimizer_data();
+  MemoryChunk* base = (type == EAGER)
+      ? data->eager_deoptimization_entry_code_
+      : data->lazy_deoptimization_entry_code_;
   Address start = base->area_start();
   if (base == NULL ||
       addr < start ||
       addr >= start + (kMaxNumberOfEntries * table_entry_size_)) {
     return kNotDeoptimizationEntry;
   }
   ASSERT_EQ(0,
             static_cast<int>(addr - start) % table_entry_size_);
   return static_cast<int>(addr - start) / table_entry_size_;
 }
@@ skipping 1451 matching lines @@
   while (max_entry_id >= entry_count) entry_count *= 2;
   ASSERT(entry_count <= Deoptimizer::kMaxNumberOfEntries);
 
   MacroAssembler masm(isolate, NULL, 16 * KB);
   masm.set_emit_debug_code(false);
   GenerateDeoptimizationEntries(&masm, entry_count, type);
   CodeDesc desc;
   masm.GetCode(&desc);
   ASSERT(!RelocInfo::RequiresRelocation(desc));
 
-  MemoryChunk* chunk = type == EAGER
+  MemoryChunk* chunk = (type == EAGER)
       ? data->eager_deoptimization_entry_code_
       : data->lazy_deoptimization_entry_code_;
   ASSERT(static_cast<int>(Deoptimizer::GetMaxDeoptTableSize()) >=
          desc.instr_size);
   chunk->CommitArea(desc.instr_size);
   memcpy(chunk->area_start(), desc.buffer, desc.instr_size);
   CPU::FlushICache(chunk->area_start(), desc.instr_size);
 
   if (type == EAGER) {
     data->eager_deoptimization_entry_code_entries_ = entry_count;
   } else {
     data->lazy_deoptimization_entry_code_entries_ = entry_count;
   }
 }
 
 
 void Deoptimizer::ReplaceCodeForRelatedFunctions(JSFunction* function,
                                                  Code* code) {
   SharedFunctionInfo* shared = function->shared();
-  Object* undefined = Isolate::Current()->heap()->undefined_value();
+  Object* undefined = function->GetHeap()->undefined_value();
   Object* current = function;
 
   while (current != undefined) {
     JSFunction* func = JSFunction::cast(current);
     current = func->next_function_link();
     func->set_code(shared->code());
     func->set_next_function_link(undefined);
   }
 }
 
@@ skipping 105 matching lines @@
     bits |= (next >> 1) << i;
     if ((next & 1) == 0) break;
   }
   // The bits encode the sign in the least significant bit.
   bool is_negative = (bits & 1) == 1;
   int32_t result = bits >> 1;
   return is_negative ? -result : result;
 }
 
 
-Handle<ByteArray> TranslationBuffer::CreateByteArray() {
+Handle<ByteArray> TranslationBuffer::CreateByteArray(Factory* factory) {
   int length = contents_.length();
-  Handle<ByteArray> result =
-      Isolate::Current()->factory()->NewByteArray(length, TENURED);
+  Handle<ByteArray> result = factory->NewByteArray(length, TENURED);
   memcpy(result->GetDataStartAddress(), contents_.ToVector().start(), length);
   return result;
 }
 
 
 void Translation::BeginConstructStubFrame(int literal_id, unsigned height) {
   buffer_->Add(CONSTRUCT_STUB_FRAME, zone());
   buffer_->Add(literal_id, zone());
   buffer_->Add(height, zone());
 }
@@ skipping 174 matching lines @@
       return "DUPLICATE";
   }
   UNREACHABLE();
   return "";
 }
 
 #endif
 
 
 DeoptimizingCodeListNode::DeoptimizingCodeListNode(Code* code): next_(NULL) {
-  GlobalHandles* global_handles = Isolate::Current()->global_handles();
+  GlobalHandles* global_handles = code->GetIsolate()->global_handles();
   // Globalize the code object and make it weak.
   code_ = Handle<Code>::cast(global_handles->Create(code));
   global_handles->MakeWeak(reinterpret_cast<Object**>(code_.location()),
                            this,
                            NULL,
                            Deoptimizer::HandleWeakDeoptimizedCode);
 }
 
 
 DeoptimizingCodeListNode::~DeoptimizingCodeListNode() {
-  GlobalHandles* global_handles = Isolate::Current()->global_handles();
+  GlobalHandles* global_handles = code_->GetIsolate()->global_handles();
   global_handles->Destroy(reinterpret_cast<Object**>(code_.location()));
 }
 
 
 // We can't intermix stack decoding and allocations because
 // deoptimization infrastracture is not GC safe.
 // Thus we build a temporary structure in malloced space.
 SlotRef SlotRef::ComputeSlotForNextArgument(TranslationIterator* iterator,
                                             DeoptimizationInputData* data,
                                             JavaScriptFrame* frame) {
@@ skipping 145 matching lines @@
                                            int frame_index,
                                            bool has_arguments_adaptor,
                                            bool has_construct_stub) {
   FrameDescription* output_frame = deoptimizer->output_[frame_index];
   function_ = output_frame->GetFunction();
   has_construct_stub_ = has_construct_stub;
   expression_count_ = output_frame->GetExpressionCount();
   expression_stack_ = new Object*[expression_count_];
   // Get the source position using the unoptimized code.
   Address pc = reinterpret_cast<Address>(output_frame->GetPc());
-  Code* code = Code::cast(Isolate::Current()->heap()->FindCodeObject(pc));
+  Code* code = Code::cast(deoptimizer->isolate()->heap()->FindCodeObject(pc));
   source_position_ = code->SourcePosition(pc);
 
   for (int i = 0; i < expression_count_; i++) {
     SetExpression(i, output_frame->GetExpression(i));
   }
 
   if (has_arguments_adaptor) {
     output_frame = deoptimizer->output_[frame_index - 1];
     ASSERT(output_frame->GetFrameType() == StackFrame::ARGUMENTS_ADAPTOR);
   }
@@ skipping 14 matching lines @@
 
 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&function_));
   v->VisitPointers(parameters_, parameters_ + parameters_count_);
   v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal