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

src/ia32/builtins-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 296 matching lines @@
   // Restore the arguments count and leave the construct frame.
   __ bind(&exit);
   __ mov(ebx, Operand(esp, kPointerSize));  // get arguments count
   __ LeaveConstructFrame();
 
   // Remove caller arguments from the stack and return.
   ASSERT(kSmiTagSize == 1 && kSmiTag == 0);
   __ pop(ecx);
   __ lea(esp, Operand(esp, ebx, times_2, 1 * kPointerSize));  // 1 ~ receiver
   __ push(ecx);
-  __ IncrementCounter(&Counters::constructed_objects, 1);
+  __ IncrementCounter(&COUNTER(constructed_objects), 1);
   __ ret(0);
 }
 
 
 static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
                                              bool is_construct) {
   // Clear the context before we push it when entering the JS frame.
   __ xor_(esi, Operand(esi));  // clear esi
 
   // Enter an internal frame.
@@ skipping 572 matching lines @@
 
   // Handle construction of an empty array.
   AllocateEmptyJSArray(masm,
                        edi,
                        eax,
                        ebx,
                        ecx,
                        edi,
                        kPreallocatedArrayElements,
                        &prepare_generic_code_call);
-  __ IncrementCounter(&Counters::array_function_native, 1);
+  __ IncrementCounter(&COUNTER(array_function_native), 1);
   __ pop(ebx);
   if (construct_call) {
     __ pop(edi);
   }
   __ ret(kPointerSize);
 
   // Check for one argument. Bail out if argument is not smi or if it is
   // negative.
   __ bind(&argc_one_or_more);
   __ cmp(eax, 1);
@@ skipping 19 matching lines @@
   // esp[C]: argument
   AllocateJSArray(masm,
                   edi,
                   edx,
                   eax,
                   ebx,
                   ecx,
                   edi,
                   true,
                   &prepare_generic_code_call);
-  __ IncrementCounter(&Counters::array_function_native, 1);
+  __ IncrementCounter(&COUNTER(array_function_native), 1);
   __ pop(ebx);
   if (construct_call) {
     __ pop(edi);
   }
   __ ret(2 * kPointerSize);
 
   // Handle construction of an array from a list of arguments.
   __ bind(&argc_two_or_more);
   ASSERT(kSmiTag == 0);
   __ shl(eax, kSmiTagSize);  // Convet argc to a smi.
   // eax: array_size (smi)
   // edi: constructor
   // esp[0] : argc
   // esp[4]: constructor (only if construct_call)
   // esp[8] : return address
   // esp[C] : last argument
   AllocateJSArray(masm,
                   edi,
                   eax,
                   ebx,
                   ecx,
                   edx,
                   edi,
                   false,
                   &prepare_generic_code_call);
-  __ IncrementCounter(&Counters::array_function_native, 1);
+  __ IncrementCounter(&COUNTER(array_function_native), 1);
   __ mov(eax, ebx);
   __ pop(ebx);
   if (construct_call) {
     __ pop(edi);
   }
   __ push(eax);
   // eax: JSArray
   // ebx: argc
   // edx: elements_array_end (untagged)
   // esp[0]: JSArray
@@ skipping 149 matching lines @@
 
 
 void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- eax : actual number of arguments
   //  -- ebx : expected number of arguments
   //  -- edx : code entry to call
   // -----------------------------------
 
   Label invoke, dont_adapt_arguments;
-  __ IncrementCounter(&Counters::arguments_adaptors, 1);
+  __ IncrementCounter(&COUNTER(arguments_adaptors), 1);
 
   Label enough, too_few;
   __ cmp(eax, Operand(ebx));
   __ j(less, &too_few);
   __ cmp(ebx, SharedFunctionInfo::kDontAdaptArgumentsSentinel);
   __ j(equal, &dont_adapt_arguments);
 
   {  // Enough parameters: Actual >= expected.
     __ bind(&enough);
     EnterArgumentsAdaptorFrame(masm);
@@ skipping 54 matching lines @@
   // Dont adapt arguments.
   // -------------------------------------------
   __ bind(&dont_adapt_arguments);
   __ jmp(Operand(edx));
 }
 
 
 #undef __
 
 } }  // namespace v8::internal