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

src/ia32/assembler-ia32.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 28 matching lines @@
 #include "disassembler.h"
 #include "macro-assembler.h"
 #include "serialize.h"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------------
 // Implementation of CpuFeatures
 
-// Safe default is no features.
-uint64_t CpuFeatures::supported_ = 0;
-uint64_t CpuFeatures::enabled_ = 0;
-uint64_t CpuFeatures::found_by_runtime_probing_ = 0;
-
-
 // The Probe method needs executable memory, so it uses Heap::CreateCode.
 // Allocation failure is silent and leads to safe default.
 void CpuFeatures::Probe() {
+  AssemblerData* data = v8_context()->assembler_data_;
   ASSERT(Heap::HasBeenSetup());
-  ASSERT(supported_ == 0);
+  ASSERT(data->supported_ == 0);
   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 esp, since we are going to modify the stack.
   __ push(ebp);
   __ pushfd();
   __ push(ecx);
@@ skipping 15 matching lines @@
   // CPUID not supported. Clear the supported features in edx:eax.
   __ xor_(eax, Operand(eax));
   __ xor_(edx, Operand(edx));
   __ 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);
   __ mov(eax, 1);
-  supported_ = (1 << CPUID);
+  data->supported_ = (1 << CPUID);
   { Scope fscope(CPUID);
     __ cpuid();
   }
-  supported_ = 0;
+  data->supported_ = 0;
 
   // Move the result from ecx:edx to edx:eax and make sure to mark the
   // CPUID feature as supported.
   __ mov(eax, Operand(edx));
   __ or_(eax, 1 << CPUID);
   __ mov(edx, Operand(ecx));
 
   // Done.
   __ bind(&done);
   __ mov(esp, Operand(ebp));
   __ pop(ebx);
   __ pop(ecx);
   __ popfd();
   __ pop(ebp);
   __ ret(0);
 #undef __
 
   CodeDesc desc;
   assm.GetCode(&desc);
   Object* code = Heap::CreateCode(desc,
                                   NULL,
                                   Code::ComputeFlags(Code::STUB),
                                   Handle<Code>::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_;
+  data->supported_ = probe();
+  data->found_by_runtime_probing_ = data->supported_;
   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;
 }
 
 
 // -----------------------------------------------------------------------------
 // Implementation of Displacement
 
 void Displacement::init(Label* L, Type type) {
   ASSERT(!L->is_bound());
   int next = 0;
   if (L->is_linked()) {
@@ skipping 126 matching lines @@
 
 // Emit a single byte. Must always be inlined.
 #define EMIT(x)                                 \
   *pc_++ = (x)
 
 
 #ifdef GENERATED_CODE_COVERAGE
 static void InitCoverageLog();
 #endif
 
-// spare_buffer_
-byte* Assembler::spare_buffer_ = NULL;
 
 Assembler::Assembler(void* buffer, int buffer_size) {
   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();
   desc->reloc_size = (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 1776 matching lines @@
   memset(desc.buffer, 0xCC, desc.buffer_size);
 #endif
 
   // copy the data
   int pc_delta = desc.buffer - buffer_;
   int 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);
 
+  AssemblerData* const data = v8_context()->assembler_data_;
   // switch buffers
-  if (spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) {
-    spare_buffer_ = buffer_;
+  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 89 matching lines @@
     }
 #endif
     if (!Serializer::enabled() && !FLAG_debug_code) {
       return;
     }
   }
   RelocInfo rinfo(pc_, rmode, data);
   reloc_info_writer.Write(&rinfo);
 }
 
+void Assembler::PostConstruct() {
+  v8_context()->assembler_data_ = new AssemblerData();
+}
+
+void Assembler::PreDestroy() {
+  delete v8_context()->assembler_data_;
+}
 
 #ifdef GENERATED_CODE_COVERAGE
 static FILE* coverage_log = NULL;
 
 
 static void InitCoverageLog() {
   char* file_name = getenv("V8_GENERATED_CODE_COVERAGE_LOG");
   if (file_name != NULL) {
     coverage_log = fopen(file_name, "aw+");
   }
 }
 
 
 void LogGeneratedCodeCoverage(const char* file_line) {
   const char* return_address = (&file_line)[-1];
   char* push_insn = const_cast<char*>(return_address - 12);
   push_insn[0] = 0xeb;  // Relative branch insn.
   push_insn[1] = 13;    // Skip over coverage insns.
   if (coverage_log != NULL) {
     fprintf(coverage_log, "%s\n", file_line);
     fflush(coverage_log);
   }
 }
 
 #endif
 
 } }  // namespace v8::internal