Patch for allowing several V8 instances in process:...

src/x64/assembler-x64.cc

 // Copyright 2009 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 60 matching lines @@
 XMMRegister xmm13 = { 13 };
 XMMRegister xmm14 = { 14 };
 XMMRegister xmm15 = { 15 };
 
 
 // -----------------------------------------------------------------------------
 // Implementation of CpuFeatures
 
 // The required user mode extensions in X64 are (from AMD64 ABI Table A.1):
 //   fpu, tsc, cx8, cmov, mmx, sse, sse2, fxsr, syscall
-uint64_t CpuFeatures::supported_ = kDefaultCpuFeatures;
-uint64_t CpuFeatures::enabled_ = 0;
-uint64_t CpuFeatures::found_by_runtime_probing_ = 0;
+AssemblerData::AssemblerData()
+  :BasicAssemblerData(),
+  spare_buffer_(NULL),
+  supported_(CpuFeatures::kDefaultCpuFeatures),
+  enabled_(0),
+  found_by_runtime_probing_(0) {
+}
 
 void CpuFeatures::Probe()  {
+  AssemblerData* data = v8_context()->assembler_data_;
   ASSERT(Heap::HasBeenSetup());
-  ASSERT(supported_ == kDefaultCpuFeatures);
+  ASSERT(data->supported_ == kDefaultCpuFeatures);
   if (Serializer::enabled()) {
-    supported_ |= OS::CpuFeaturesImpliedByPlatform();
+    data->supported_ |= OS::CpuFeaturesImpliedByPlatform();
     return;  // No features if we might serialize.
   }
 
   Assembler assm(NULL, 0);
   Label cpuid, done;
 #define __ assm.
   // Save old rsp, since we are going to modify the stack.
   __ push(rbp);
   __ pushfq();
   __ push(rcx);
@@ skipping 14 matching lines @@
 
   // CPUID not supported. Clear the supported features in edx:eax.
   __ xor_(rax, rax);
   __ jmp(&done);
 
   // Invoke CPUID with 1 in eax to get feature information in
   // ecx:edx. Temporarily enable CPUID support because we know it's
   // safe here.
   __ bind(&cpuid);
   __ movq(rax, Immediate(1));
-  supported_ = kDefaultCpuFeatures | (1 << CPUID);
+  data->supported_ = kDefaultCpuFeatures | (1 << CPUID);
   { Scope fscope(CPUID);
     __ cpuid();
     // Move the result from ecx:edx to rdi.
     __ movl(rdi, rdx);  // Zero-extended to 64 bits.
     __ shl(rcx, Immediate(32));
     __ or_(rdi, rcx);
 
     // Get the sahf supported flag, from CPUID(0x80000001)
     __ movq(rax, 0x80000001, RelocInfo::NONE);
     __ cpuid();
   }
-  supported_ = kDefaultCpuFeatures;
+  data->supported_ = kDefaultCpuFeatures;
 
   // Put the CPU flags in rax.
   // rax = (rcx & 1) | (rdi & ~1) | (1 << CPUID).
   __ movl(rax, Immediate(1));
   __ and_(rcx, rax);  // Bit 0 is set if SAHF instruction supported.
   __ not_(rax);
   __ and_(rax, rdi);
   __ or_(rax, rcx);
   __ or_(rax, Immediate(1 << CPUID));
 
   // Done.
   __ bind(&done);
   __ movq(rsp, rbp);
   __ pop(rbx);
   __ pop(rcx);
   __ popfq();
   __ pop(rbp);
   __ ret(0);
 #undef __
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Object* code =
       Heap::CreateCode(desc, NULL, Code::ComputeFlags(Code::STUB), NULL);
   if (!code->IsCode()) return;
   LOG(CodeCreateEvent(Logger::BUILTIN_TAG,
                       Code::cast(code), "CpuFeatures::Probe"));
   typedef uint64_t (*F0)();
   F0 probe = FUNCTION_CAST<F0>(Code::cast(code)->entry());
-  supported_ = probe();
-  found_by_runtime_probing_ = supported_;
-  found_by_runtime_probing_ &= ~kDefaultCpuFeatures;
+  data->supported_ = probe();
+  data->found_by_runtime_probing_ = data->supported_;
+  data->found_by_runtime_probing_ &= ~kDefaultCpuFeatures;
   uint64_t os_guarantees = OS::CpuFeaturesImpliedByPlatform();
-  supported_ |= os_guarantees;
-  found_by_runtime_probing_ &= ~os_guarantees;
+  data->supported_ |= os_guarantees;
+  data->found_by_runtime_probing_ &= ~os_guarantees;
   // SSE2 and CMOV must be available on an X64 CPU.
   ASSERT(IsSupported(CPUID));
   ASSERT(IsSupported(SSE2));
   ASSERT(IsSupported(CMOV));
 }
 
 
 // -----------------------------------------------------------------------------
 // Implementation of RelocInfo
 
@@ skipping 82 matching lines @@
 }
 
 
 // -----------------------------------------------------------------------------
 // Implementation of Assembler
 
 #ifdef GENERATED_CODE_COVERAGE
 static void InitCoverageLog();
 #endif
 
-byte* Assembler::spare_buffer_ = NULL;
-
 Assembler::Assembler(void* buffer, int buffer_size)
     : code_targets_(100) {
   if (buffer == NULL) {
     // do our own buffer management
     if (buffer_size <= kMinimalBufferSize) {
       buffer_size = kMinimalBufferSize;
-
-      if (spare_buffer_ != NULL) {
-        buffer = spare_buffer_;
-        spare_buffer_ = NULL;
+      AssemblerData* const data = v8_context()->assembler_data_;
+      if (data->spare_buffer_ != NULL) {
+        buffer = data->spare_buffer_;
+        data->spare_buffer_ = NULL;
       }
     }
     if (buffer == NULL) {
       buffer_ = NewArray<byte>(buffer_size);
     } else {
       buffer_ = static_cast<byte*>(buffer);
     }
     buffer_size_ = buffer_size;
     own_buffer_ = true;
   } else {
@@ skipping 24 matching lines @@
   written_statement_position_ = current_statement_position_;
   written_position_ = current_position_;
 #ifdef GENERATED_CODE_COVERAGE
   InitCoverageLog();
 #endif
 }
 
 
 Assembler::~Assembler() {
   if (own_buffer_) {
-    if (spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) {
-      spare_buffer_ = buffer_;
+    AssemblerData* const data = v8_context()->assembler_data_;
+    if (data->spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) {
+      data->spare_buffer_ = buffer_;
     } else {
       DeleteArray(buffer_);
     }
   }
 }
 
 
 void Assembler::GetCode(CodeDesc* desc) {
   // finalize code
   // (at this point overflow() may be true, but the gap ensures that
   // we are still not overlapping instructions and relocation info)
   ASSERT(pc_ <= reloc_info_writer.pos());  // no overlap
   // setup desc
   desc->buffer = buffer_;
   desc->buffer_size = buffer_size_;
   desc->instr_size = pc_offset();
   ASSERT(desc->instr_size > 0);  // Zero-size code objects upset the system.
   desc->reloc_size =
       static_cast<int>((buffer_ + buffer_size_) - reloc_info_writer.pos());
   desc->origin = this;
 
-  Counters::reloc_info_size.Increment(desc->reloc_size);
+  INCREMENT_COUNTER(reloc_info_size, desc->reloc_size);
 }
 
 
 void Assembler::Align(int m) {
   ASSERT(IsPowerOf2(m));
   while ((pc_offset() & (m - 1)) != 0) {
     nop();
   }
 }
 
@@ skipping 57 matching lines @@
 
   // copy the data
   intptr_t pc_delta = desc.buffer - buffer_;
   intptr_t rc_delta = (desc.buffer + desc.buffer_size) -
       (buffer_ + buffer_size_);
   memmove(desc.buffer, buffer_, desc.instr_size);
   memmove(rc_delta + reloc_info_writer.pos(),
           reloc_info_writer.pos(), desc.reloc_size);
 
   // switch buffers
-  if (spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) {
-    spare_buffer_ = buffer_;
+  AssemblerData* const data = v8_context()->assembler_data_;
+  if (data->spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) {
+    data->spare_buffer_ = buffer_;
   } else {
     DeleteArray(buffer_);
   }
   buffer_ = desc.buffer;
   buffer_size_ = desc.buffer_size;
   pc_ += pc_delta;
   if (last_pc_ != NULL) {
     last_pc_ += pc_delta;
   }
   reloc_info_writer.Reposition(reloc_info_writer.pos() + rc_delta,
@@ skipping 2086 matching lines @@
     RecordRelocInfo(RelocInfo::POSITION, current_position_);
     written_position_ = current_position_;
   }
 }
 
 
 const int RelocInfo::kApplyMask = RelocInfo::kCodeTargetMask |
                                   1 << RelocInfo::INTERNAL_REFERENCE |
                                   1 << RelocInfo::JS_RETURN;
 
+void Assembler::PostConstruct() {
+  v8_context()->assembler_data_ = new AssemblerData();
+}
+
+void Assembler::PreDestroy() {
+  delete v8_context()->assembler_data_;
+}
+
 } }  // namespace v8::internal