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

src/x64/codegen-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 288 matching lines @@
 #ifdef DEBUG
   if (strlen(FLAG_stop_at) > 0 &&
       function->name()->IsEqualTo(CStrVector(FLAG_stop_at))) {
     frame_->SpillAll();
     __ int3();
   }
 #endif
 
   // New scope to get automatic timing calculation.
   {  // NOLINT
-    HistogramTimerScope codegen_timer(&Counters::code_generation);
+    HistogramTimerScope codegen_timer(&COUNTER(code_generation));
     CodeGenState state(this);
 
     // Entry:
     // Stack: receiver, arguments, return address.
     // rbp: caller's frame pointer
     // rsp: stack pointer
     // rdi: called JS function
     // rsi: callee's context
     allocator_->Initialize();
     frame_->Enter();
@@ skipping 141 matching lines @@
 
   // Code generation state must be reset.
   ASSERT(state_ == NULL);
   ASSERT(loop_nesting() == 0);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
   DeleteFrame();
 
   // Process any deferred code using the register allocator.
   if (!HasStackOverflow()) {
-    HistogramTimerScope deferred_timer(&Counters::deferred_code_generation);
+    HistogramTimerScope deferred_timer(&COUNTER(deferred_code_generation));
     JumpTarget::set_compiling_deferred_code(true);
     ProcessDeferred();
     JumpTarget::set_compiling_deferred_code(false);
   }
 
   // There is no need to delete the register allocator, it is a
   // stack-allocated local.
   allocator_ = NULL;
   scope_ = NULL;
 }
@@ skipping 96 matching lines @@
   // macro because the macro sometimes uses macro expansion to turn
   // into something that can't return a value.  This is encountered
   // when doing generated code coverage tests.
   int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   // Here we use masm_-> instead of the __ macro because this is the
   // instruction that gets patched and coverage code gets in the way.
   // TODO(X64): Consider whether it's worth switching the test to a
   // 7-byte NOP with non-zero immediate (0f 1f 80 xxxxxxxx) which won't
   // be generated normally.
   masm_->testl(rax, Immediate(-delta_to_patch_site));
-  __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
+  __ IncrementCounter(&COUNTER(keyed_load_inline_miss), 1);
 
   if (!dst_.is(rax)) __ movq(dst_, rax);
   __ pop(key_);
   __ pop(receiver_);
 }
 
 
 class DeferredReferenceSetKeyedValue: public DeferredCode {
  public:
   DeferredReferenceSetKeyedValue(Register value,
                                  Register key,
                                  Register receiver)
       : value_(value), key_(key), receiver_(receiver) {
     set_comment("[ DeferredReferenceSetKeyedValue");
   }
 
   virtual void Generate();
 
   Label* patch_site() { return &patch_site_; }
 
  private:
   Register value_;
   Register key_;
   Register receiver_;
   Label patch_site_;
 };
 
 
 void DeferredReferenceSetKeyedValue::Generate() {
-  __ IncrementCounter(&Counters::keyed_store_inline_miss, 1);
+  __ IncrementCounter(&COUNTER(keyed_store_inline_miss), 1);
   // Push receiver and key arguments on the stack.
   __ push(receiver_);
   __ push(key_);
   // Move value argument to eax as expected by the IC stub.
   if (!value_.is(rax)) __ movq(rax, value_);
   // Call the IC stub.
   Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
   __ Call(ic, RelocInfo::CODE_TARGET);
   // The delta from the start of the map-compare instructions (initial movq)
   // to the test instruction.  We use masm_-> directly here instead of the
@@ skipping 4637 matching lines @@
   // The call must be followed by a test rax instruction to indicate
   // that the inobject property case was inlined.
   //
   // Store the delta to the map check instruction here in the test
   // instruction.  Use masm_-> instead of the __ macro since the
   // latter can't return a value.
   int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   // Here we use masm_-> instead of the __ macro because this is the
   // instruction that gets patched and coverage code gets in the way.
   masm_->testl(rax, Immediate(-delta_to_patch_site));
-  __ IncrementCounter(&Counters::named_load_inline_miss, 1);
+  __ IncrementCounter(&COUNTER(named_load_inline_miss), 1);
 
   if (!dst_.is(rax)) __ movq(dst_, rax);
   __ pop(receiver_);
 }
 
 
 void DeferredInlineSmiAdd::Generate() {
   GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, NO_SMI_CODE_IN_STUB);
   igostub.GenerateCall(masm_, dst_, value_);
   if (!dst_.is(rax)) __ movq(dst_, rax);
@@ skipping 610 matching lines @@
         // The delta from the patch label to the load offset must be
         // statically known.
         ASSERT(masm->SizeOfCodeGeneratedSince(deferred->patch_site()) ==
                LoadIC::kOffsetToLoadInstruction);
         // The initial (invalid) offset has to be large enough to force
         // a 32-bit instruction encoding to allow patching with an
         // arbitrary offset.  Use kMaxInt (minus kHeapObjectTag).
         int offset = kMaxInt;
         masm->movq(value.reg(), FieldOperand(receiver.reg(), offset));
 
-        __ IncrementCounter(&Counters::named_load_inline, 1);
+        __ IncrementCounter(&COUNTER(named_load_inline), 1);
         deferred->BindExit();
         cgen_->frame()->Push(&receiver);
         cgen_->frame()->Push(&value);
       }
       break;
     }
 
     case KEYED: {
       Comment cmnt(masm, "[ Load from keyed Property");
       Variable* var = expression_->AsVariableProxy()->AsVariable();
@@ skipping 77 matching lines @@
         Result value = index;
         __ movq(value.reg(),
                 Operand(elements.reg(),
                         index.reg(),
                         times_pointer_size,
                         FixedArray::kHeaderSize - kHeapObjectTag));
         elements.Unuse();
         index.Unuse();
         __ CompareRoot(value.reg(), Heap::kTheHoleValueRootIndex);
         deferred->Branch(equal);
-        __ IncrementCounter(&Counters::keyed_load_inline, 1);
+        __ IncrementCounter(&COUNTER(keyed_load_inline), 1);
 
         deferred->BindExit();
         // Restore the receiver and key to the frame and push the
         // result on top of it.
         cgen_->frame()->Push(&receiver);
         cgen_->frame()->Push(&key);
         cgen_->frame()->Push(&value);
 
       } else {
         Comment cmnt(masm, "[ Load from keyed Property");
@@ skipping 150 matching lines @@
         deferred->Branch(not_equal);
 
         // Store the value.
         SmiIndex index =
             masm->SmiToIndex(kScratchRegister, key.reg(), kPointerSizeLog2);
               __ movq(Operand(tmp.reg(),
                         index.reg,
                         index.scale,
                         FixedArray::kHeaderSize - kHeapObjectTag),
                 value.reg());
-        __ IncrementCounter(&Counters::keyed_store_inline, 1);
+        __ IncrementCounter(&COUNTER(keyed_store_inline), 1);
 
         deferred->BindExit();
 
         cgen_->frame()->Push(&receiver);
         cgen_->frame()->Push(&key);
         cgen_->frame()->Push(&value);
       } else {
         Result answer = cgen_->frame()->CallKeyedStoreIC();
         // Make sure that we do not have a test instruction after the
         // call.  A test instruction after the call is used to
@@ skipping 1243 matching lines @@
         __ movq(left_arg, left);
       } else {
         // Order of moves is not important.
         __ movq(left_arg, left);
         __ movq(right_arg, right);
       }
     }
 
     // Update flags to indicate that arguments are in registers.
     SetArgsInRegisters();
-    __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
+    __ IncrementCounter(&COUNTER(generic_binary_stub_calls_regs), 1);
   }
 
   // Call the stub.
   __ CallStub(this);
 }
 
 
 void GenericBinaryOpStub::GenerateCall(
     MacroAssembler* masm,
     Register left,
@@ skipping 11 matching lines @@
     } else if (left.is(right_arg) && IsOperationCommutative()) {
       __ Move(left_arg, right);
       SetArgsReversed();
     } else {
       __ movq(left_arg, left);
       __ Move(right_arg, right);
     }
 
     // Update flags to indicate that arguments are in registers.
     SetArgsInRegisters();
-    __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
+    __ IncrementCounter(&COUNTER(generic_binary_stub_calls_regs), 1);
   }
 
   // Call the stub.
   __ CallStub(this);
 }
 
 
 void GenericBinaryOpStub::GenerateCall(
     MacroAssembler* masm,
     Smi* left,
@@ skipping 10 matching lines @@
       __ Move(left_arg, left);
     } else if (right.is(left_arg) && IsOperationCommutative()) {
       __ Move(right_arg, left);
       SetArgsReversed();
     } else {
       __ Move(left_arg, left);
       __ movq(right_arg, right);
     }
     // Update flags to indicate that arguments are in registers.
     SetArgsInRegisters();
-    __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
+    __ IncrementCounter(&COUNTER(generic_binary_stub_calls_regs), 1);
   }
 
   // Call the stub.
   __ CallStub(this);
 }
 
 
 void GenericBinaryOpStub::GenerateSmiCode(MacroAssembler* masm, Label* slow) {
   // Perform fast-case smi code for the operation (rax <op> rbx) and
   // leave result in register rax.
@@ skipping 455 matching lines @@
   masm.GetCode(&desc);
   // Call the function from C++.
   return FUNCTION_CAST<ModuloFunction>(buffer);
 }
 
 #endif
 
 #undef __
 
 } }  // namespace v8::internal