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

src/ia32/codegen-ia32.cc

 // Copyright 2006-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 136 matching lines @@
 #ifdef DEBUG
   if (strlen(FLAG_stop_at) > 0 &&
       fun->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.
     // ebp: caller's frame pointer
     // esp: stack pointer
     // edi: called JS function
     // esi: 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 5690 matching lines @@
   // The call must be followed by a test eax 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_->test(eax, Immediate(-delta_to_patch_site));
-  __ IncrementCounter(&Counters::named_load_inline_miss, 1);
+  __ IncrementCounter(&COUNTER(named_load_inline_miss), 1);
 
   if (!dst_.is(eax)) __ mov(dst_, eax);
   __ pop(receiver_);
 }
 
 
 class DeferredReferenceGetKeyedValue: public DeferredCode {
  public:
   explicit DeferredReferenceGetKeyedValue(Register dst,
                                           Register receiver,
@@ skipping 33 matching lines @@
   __ call(ic, mode);
   // The delta from the start of the map-compare instruction to the
   // test instruction.  We use masm_-> directly here instead of the __
   // 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.
   masm_->test(eax, Immediate(-delta_to_patch_site));
-  __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
+  __ IncrementCounter(&COUNTER(keyed_load_inline_miss), 1);
 
   if (!dst_.is(eax)) __ mov(dst_, eax);
   __ 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(eax)) __ mov(eax, 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 instruction to the
   // test instruction.  We use masm_-> directly here instead of the
@@ skipping 108 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->mov(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 74 matching lines @@
         // coming from the deferred code will be in eax.
         Result value = index;
         __ mov(value.reg(), Operand(elements.reg(),
                                     index.reg(),
                                     times_4,
                                     FixedArray::kHeaderSize - kHeapObjectTag));
         elements.Unuse();
         index.Unuse();
         __ cmp(Operand(value.reg()), Immediate(Factory::the_hole_value()));
         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 148 matching lines @@
         __ cmp(FieldOperand(tmp.reg(), HeapObject::kMapOffset),
                Immediate(Factory::fixed_array_map()));
         deferred->Branch(not_equal);
 
         // Store the value.
         __ mov(Operand(tmp.reg(),
                        key.reg(),
                        times_2,
                        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 104 matching lines @@
         __ mov(left_arg, left);
       } else {
         // Order of moves is not important.
         __ mov(left_arg, left);
         __ mov(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()) {
       __ mov(left_arg, Immediate(right));
       SetArgsReversed();
     } else {
       __ mov(left_arg, left);
       __ mov(right_arg, Immediate(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 @@
       __ mov(left_arg, Immediate(left));
     } else if (right.is(left_arg) && IsOperationCommutative()) {
       __ mov(right_arg, Immediate(left));
       SetArgsReversed();
     } else {
       __ mov(left_arg, Immediate(left));
       __ mov(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 (eax <op> ebx) and
   // leave result in register eax.
@@ skipping 134 matching lines @@
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void GenericBinaryOpStub::Generate(MacroAssembler* masm) {
   Label call_runtime;
 
-  __ IncrementCounter(&Counters::generic_binary_stub_calls, 1);
+  __ IncrementCounter(&COUNTER(generic_binary_stub_calls), 1);
 
   // Generate fast case smi code if requested. This flag is set when the fast
   // case smi code is not generated by the caller. Generating it here will speed
   // up common operations.
   if (HasSmiCodeInStub()) {
     Label slow;
     __ mov(ebx, Operand(esp, 1 * kPointerSize));
     __ mov(eax, Operand(esp, 2 * kPointerSize));
     GenerateSmiCode(masm, &slow);
     GenerateReturn(masm);
@@ skipping 1398 matching lines @@
 
   // Both arguments are strings.
   // eax: first string
   // edx: second string
   // Check if either of the strings are empty. In that case return the other.
   Label second_not_zero_length, both_not_zero_length;
   __ mov(ecx, FieldOperand(edx, String::kLengthOffset));
   __ test(ecx, Operand(ecx));
   __ j(not_zero, &second_not_zero_length);
   // Second string is empty, result is first string which is already in eax.
-  __ IncrementCounter(&Counters::string_add_native, 1);
+  __ IncrementCounter(&COUNTER(string_add_native), 1);
   __ ret(2 * kPointerSize);
   __ bind(&second_not_zero_length);
   __ mov(ebx, FieldOperand(eax, String::kLengthOffset));
   __ test(ebx, Operand(ebx));
   __ j(not_zero, &both_not_zero_length);
   // First string is empty, result is second string which is in edx.
   __ mov(eax, edx);
-  __ IncrementCounter(&Counters::string_add_native, 1);
+  __ IncrementCounter(&COUNTER(string_add_native), 1);
   __ ret(2 * kPointerSize);
 
   // Both strings are non-empty.
   // eax: first string
   // ebx: length of first string
   // ecx: length of second string
   // edx: second string
   // Look at the length of the result of adding the two strings.
   Label string_add_flat_result;
   __ bind(&both_not_zero_length);
@@ skipping 23 matching lines @@
   // Allocate an acsii cons string.
   __ AllocateAsciiConsString(ecx, edi, no_reg, &string_add_runtime);
   __ bind(&allocated);
   // Fill the fields of the cons string.
   __ mov(FieldOperand(ecx, ConsString::kLengthOffset), ebx);
   __ mov(FieldOperand(ecx, ConsString::kHashFieldOffset),
          Immediate(String::kEmptyHashField));
   __ mov(FieldOperand(ecx, ConsString::kFirstOffset), eax);
   __ mov(FieldOperand(ecx, ConsString::kSecondOffset), edx);
   __ mov(eax, ecx);
-  __ IncrementCounter(&Counters::string_add_native, 1);
+  __ IncrementCounter(&COUNTER(string_add_native), 1);
   __ ret(2 * kPointerSize);
   __ bind(&non_ascii);
   // Allocate a two byte cons string.
   __ AllocateConsString(ecx, edi, no_reg, &string_add_runtime);
   __ jmp(&allocated);
 
   // Handle creating a flat result. First check that both strings are not
   // external strings.
   // eax: first string
   // ebx: length of resulting flat string
@@ skipping 40 matching lines @@
   GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
   // Load second argument and locate first character.
   __ mov(edx, Operand(esp, 1 * kPointerSize));
   __ mov(edi, FieldOperand(edx, String::kLengthOffset));
   __ add(Operand(edx), Immediate(SeqAsciiString::kHeaderSize - kHeapObjectTag));
   // eax: result string
   // ecx: next character of result
   // edx: first char of second argument
   // edi: length of second argument
   GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
-  __ IncrementCounter(&Counters::string_add_native, 1);
+  __ IncrementCounter(&COUNTER(string_add_native), 1);
   __ ret(2 * kPointerSize);
 
   // Handle creating a flat two byte result.
   // eax: first string - known to be two byte
   // ebx: length of resulting flat string
   // edx: second string
   __ bind(&non_ascii_string_add_flat_result);
   __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset));
   __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
   __ and_(ecx, kAsciiStringTag);
@@ skipping 18 matching lines @@
   GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
   // Load second argument and locate first character.
   __ mov(edx, Operand(esp, 1 * kPointerSize));
   __ mov(edi, FieldOperand(edx, String::kLengthOffset));
   __ add(Operand(edx), Immediate(SeqAsciiString::kHeaderSize - kHeapObjectTag));
   // eax: result string
   // ecx: next character of result
   // edx: first char of second argument
   // edi: length of second argument
   GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
-  __ IncrementCounter(&Counters::string_add_native, 1);
+  __ IncrementCounter(&COUNTER(string_add_native), 1);
   __ ret(2 * kPointerSize);
 
   // Just jump to runtime to add the two strings.
   __ bind(&string_add_runtime);
   __ TailCallRuntime(ExternalReference(Runtime::kStringAdd), 2, 1);
 }
 
 
 void StringAddStub::GenerateCopyCharacters(MacroAssembler* masm,
                                            Register dest,
@@ skipping 17 matching lines @@
     __ add(Operand(dest), Immediate(2));
   }
   __ sub(Operand(count), Immediate(1));
   __ j(not_zero, &loop);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal