Use MemoryChunk-based allocation for deoptimization entry code

src/deoptimizer.cc

 // Copyright 2012 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 26 matching lines @@
 #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();
+#if defined(V8_TARGET_ARCH_X64)
+  CodeRange* code_range = Isolate::Current()->code_range();
+  eager_deoptimization_entry_start_ =
+    code_range->ReserveChunk(deopt_table_size,
+                             &eager_deoptimization_reserved_size_);
+  eager_deoptimization_entry_code_ = NULL;
+  lazy_deoptimization_entry_start_ =
+    code_range->ReserveChunk(deopt_table_size,
+                             &lazy_deoptimization_reserved_size_);
+  lazy_deoptimization_entry_code_ = NULL;
+#else
   eager_deoptimization_entry_code_ = new VirtualMemory(deopt_table_size);
   lazy_deoptimization_entry_code_ = new VirtualMemory(deopt_table_size);
+#endif
   current_ = NULL;
   deoptimizing_code_list_ = NULL;
 #ifdef ENABLE_DEBUGGER_SUPPORT
   deoptimized_frame_info_ = NULL;
 #endif
 }
 
 
 DeoptimizerData::~DeoptimizerData() {
+#if defined(V8_TARGET_ARCH_X64)
+  if (eager_deoptimization_entry_code_ != NULL) {
+    Isolate::Current()->memory_allocator()->Free(
+            eager_deoptimization_entry_code_);
+    eager_deoptimization_entry_code_ = NULL;
+  }
+  if (lazy_deoptimization_entry_code_ != NULL) {
+    Isolate::Current()->memory_allocator()->Free(
+            lazy_deoptimization_entry_code_);
+    lazy_deoptimization_entry_code_ = NULL;
+  }
+#else
   delete eager_deoptimization_entry_code_;
   eager_deoptimization_entry_code_ = NULL;
   delete lazy_deoptimization_entry_code_;
   lazy_deoptimization_entry_code_ = NULL;
+#endif
 
   DeoptimizingCodeListNode* current = deoptimizing_code_list_;
   while (current != NULL) {
     DeoptimizingCodeListNode* prev = current;
     current = current->next();
     delete prev;
   }
   deoptimizing_code_list_ = NULL;
 }
 
@@ skipping 399 matching lines @@
   output_ = NULL;
   ASSERT(!HEAP->allow_allocation(true));
 }
 
 
 Address Deoptimizer::GetDeoptimizationEntry(int id,
                                             BailoutType type,
                                             GetEntryMode mode) {
   ASSERT(id >= 0);
   if (id >= kMaxNumberOfEntries) return NULL;
+#if defined(V8_TARGET_ARCH_X64)
+  Address base = 0;
+#else
   VirtualMemory* base = NULL;
+#endif
   if (mode == ENSURE_ENTRY_CODE) {
     EnsureCodeForDeoptimizationEntry(type, id);
   } else {
     ASSERT(mode == CALCULATE_ENTRY_ADDRESS);
   }
   DeoptimizerData* data = Isolate::Current()->deoptimizer_data();
+#if defined(V8_TARGET_ARCH_X64)
+  if (type == EAGER) {
+    base = data->eager_deoptimization_entry_start_ +
+           MemoryAllocator::CodePageAreaStartOffset();
+  } else {
+    base = data->lazy_deoptimization_entry_start_ +
+           MemoryAllocator::CodePageAreaStartOffset();
+  }
+  return
+      base + (id * table_entry_size_);
+#else
   if (type == EAGER) {
     base = data->eager_deoptimization_entry_code_;
   } else {
     base = data->lazy_deoptimization_entry_code_;
   }
   return
       static_cast<Address>(base->address()) + (id * table_entry_size_);
+#endif
 }
 
 
 int Deoptimizer::GetDeoptimizationId(Address addr, BailoutType type) {
+#if defined(V8_TARGET_ARCH_X64)
+  Address base = 0;
+  DeoptimizerData* data = Isolate::Current()->deoptimizer_data();
+  if (type == EAGER) {
+    base = data->eager_deoptimization_entry_start_ +
+           MemoryAllocator::CodePageAreaStartOffset();
+  } else {
+    base = data->lazy_deoptimization_entry_start_ +
+           MemoryAllocator::CodePageAreaStartOffset();
+  }
+  if (base == 0 ||
+      addr < base ||
+      addr >= base + (kMaxNumberOfEntries * table_entry_size_)) {
+    return kNotDeoptimizationEntry;
+  }
+  ASSERT_EQ(0,
+            static_cast<int>(addr - base) % table_entry_size_);
+  return static_cast<int>(addr - base) / table_entry_size_;
+#else
   VirtualMemory* base = NULL;
   DeoptimizerData* data = Isolate::Current()->deoptimizer_data();
   if (type == EAGER) {
     base = data->eager_deoptimization_entry_code_;
   } else {
     base = data->lazy_deoptimization_entry_code_;
   }
   Address base_casted = reinterpret_cast<Address>(base->address());
   if (base == NULL ||
       addr < base->address() ||
       addr >= base_casted + (kMaxNumberOfEntries * table_entry_size_)) {
     return kNotDeoptimizationEntry;
   }
   ASSERT_EQ(0,
             static_cast<int>(addr - base_casted) % table_entry_size_);
   return static_cast<int>(addr - base_casted) / table_entry_size_;
+#endif
 }
 
 
 int Deoptimizer::GetOutputInfo(DeoptimizationOutputData* data,
                                BailoutId id,
                                SharedFunctionInfo* shared) {
   // TODO(kasperl): For now, we do a simple linear search for the PC
   // offset associated with the given node id. This should probably be
   // changed to a binary search.
   int length = data->DeoptPoints();
@@ skipping 889 matching lines @@
   entry_count = Min(Max(entry_count * 2, Deoptimizer::kMinNumberOfEntries),
                     Deoptimizer::kMaxNumberOfEntries);
 
   MacroAssembler masm(Isolate::Current(), NULL, 16 * KB);
   masm.set_emit_debug_code(false);
   GenerateDeoptimizationEntries(&masm, entry_count, type);
   CodeDesc desc;
   masm.GetCode(&desc);
   ASSERT(desc.reloc_size == 0);
 
+  size_t table_size = Deoptimizer::GetMaxDeoptTableSize();
+  ASSERT(static_cast<int>(table_size) >= desc.instr_size);
+#if defined(V8_TARGET_ARCH_X64)
+  MemoryAllocator* allocator = Isolate::Current()->memory_allocator();
+  Address base = type == EAGER
+      ? data->eager_deoptimization_entry_start_
+      : data->lazy_deoptimization_entry_start_;
+  size_t reserved_size = type == EAGER
+      ? data->eager_deoptimization_reserved_size_
+      : data->lazy_deoptimization_reserved_size_;
+  MemoryChunk** chunk = type == EAGER
+      ? &data->eager_deoptimization_entry_code_
+      : &data->lazy_deoptimization_entry_code_;
+  *chunk = allocator->CommitChunkInCodeRange(base, table_size, reserved_size);
+  if (*chunk == NULL) {
+    V8::FatalProcessOutOfMemory("Not enough memory for deoptimization table");
+  }
+  memcpy((*chunk)->area_start(), desc.buffer, desc.instr_size);
+  CPU::FlushICache((*chunk)->area_start(), desc.instr_size);
+#else
   VirtualMemory* memory = type == EAGER
       ? data->eager_deoptimization_entry_code_
       : data->lazy_deoptimization_entry_code_;
-  size_t table_size = Deoptimizer::GetMaxDeoptTableSize();
-  ASSERT(static_cast<int>(table_size) >= desc.instr_size);
   memory->Commit(memory->address(), table_size, true);
   memcpy(memory->address(), desc.buffer, desc.instr_size);
   CPU::FlushICache(memory->address(), desc.instr_size);
+#endif
 
   if (type == EAGER) {
     data->eager_deoptimization_entry_code_entries_ = entry_count;
   } else {
     data->lazy_deoptimization_entry_code_entries_ = entry_count;
   }
 }
 
 
 Code* Deoptimizer::FindDeoptimizingCodeFromAddress(Address addr) {
@@ skipping 580 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