WebKit side of merge from r41149 to r41181.

JavaScriptCore/jit/JITStubs.cpp

 /*
  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 10 matching lines @@
  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
-#include "Interpreter.h"
+#include "JITStubs.h"
+
+#if ENABLE(JIT)
 
 #include "Arguments.h"
-#include "BatchedTransitionOptimizer.h"
+#include "CallFrame.h"
 #include "CodeBlock.h"
-#include "DebuggerCallFrame.h"
-#include "EvalCodeCache.h"
+#include "Collector.h"
+#include "Debugger.h"
 #include "ExceptionHelpers.h"
-#include "CallFrame.h"
 #include "GlobalEvalFunction.h"
+#include "JIT.h"
 #include "JSActivation.h"
 #include "JSArray.h"
 #include "JSByteArray.h"
 #include "JSFunction.h"
 #include "JSNotAnObject.h"
 #include "JSPropertyNameIterator.h"
 #include "JSStaticScopeObject.h"
 #include "JSString.h"
 #include "ObjectPrototype.h"
+#include "Operations.h"
 #include "Parser.h"
 #include "Profiler.h"
 #include "RegExpObject.h"
 #include "RegExpPrototype.h"
 #include "Register.h"
-#include "Collector.h"
-#include "Debugger.h"
-#include "Operations.h"
 #include "SamplingTool.h"
 #include <stdio.h>
 
-#if ENABLE(JIT)
-#include "JIT.h"
-#endif
-
-#if ENABLE(ASSEMBLER)
-#include "AssemblerBuffer.h"
-#endif
-
-#if PLATFORM(DARWIN)
-#include <mach/mach.h>
-#endif
-
-#if HAVE(SYS_TIME_H)
-#include <sys/time.h>
-#endif
-
-#if PLATFORM(WIN_OS)
-#include <windows.h>
-#endif
-
-#if PLATFORM(QT)
-#include <QDateTime>
-#endif
-
 using namespace std;
 
 namespace JSC {
 
-#if ENABLE(JIT)
-
 #if ENABLE(OPCODE_SAMPLING)
     #define CTI_SAMPLER ARG_globalData->interpreter->sampler()
 #else
     #define CTI_SAMPLER 0
 #endif
 
+JITStubs::JITStubs(JSGlobalData* globalData)
+    : m_ctiArrayLengthTrampoline(0)
+    , m_ctiStringLengthTrampoline(0)
+    , m_ctiVirtualCallPreLink(0)
+    , m_ctiVirtualCallLink(0)
+    , m_ctiVirtualCall(0)
+{
+    JIT::compileCTIMachineTrampolines(globalData, &m_executablePool, &m_ctiArrayLengthTrampoline, &m_ctiStringLengthTrampoline, &m_ctiVirtualCallPreLink, &m_ctiVirtualCallLink, &m_ctiVirtualCall);
+}
+
 #if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
 
-NEVER_INLINE void Interpreter::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValuePtr baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void JITStubs::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValuePtr baseValue, const PutPropertySlot& slot)
 {
     // The interpreter checks for recursion here; I do not believe this can occur in CTI.
 
     if (!baseValue.isCell())
         return;
 
     // Uncacheable: give up.
     if (!slot.isCacheable()) {
-        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_put_by_id_generic));
+        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(JITStubs::cti_op_put_by_id_generic));
         return;
     }
     
     JSCell* baseCell = asCell(baseValue);
     Structure* structure = baseCell->structure();
 
     if (structure->isDictionary()) {
-        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_put_by_id_generic));
+        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(JITStubs::cti_op_put_by_id_generic));
         return;
     }
 
     // If baseCell != base, then baseCell must be a proxy for another object.
     if (baseCell != slot.base()) {
-        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_put_by_id_generic));
+        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(JITStubs::cti_op_put_by_id_generic));
         return;
     }
 
     StructureStubInfo* stubInfo = &codeBlock->getStubInfo(returnAddress);
 
     // Cache hit: Specialize instruction and ref Structures.
 
     // Structure transition, cache transition info
     if (slot.type() == PutPropertySlot::NewProperty) {
         StructureChain* chain = structure->cachedPrototypeChain();
@@ skipping 12 matching lines @@
     
     stubInfo->initPutByIdReplace(structure);
 
 #if USE(CTI_REPATCH_PIC)
     JIT::patchPutByIdReplace(stubInfo, structure, slot.cachedOffset(), returnAddress);
 #else
     JIT::compilePutByIdReplace(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, structure, slot.cachedOffset(), returnAddress);
 #endif
 }
 
-NEVER_INLINE void Interpreter::tryCTICacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValuePtr baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void JITStubs::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValuePtr baseValue, const Identifier& propertyName, const PropertySlot& slot)
 {
     // FIXME: Write a test that proves we need to check for recursion here just
     // like the interpreter does, then add a check for recursion.
 
     // FIXME: Cache property access for immediates.
     if (!baseValue.isCell()) {
-        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_get_by_id_generic));
+        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(JITStubs::cti_op_get_by_id_generic));
         return;
     }
+    
+    JSGlobalData* globalData = &callFrame->globalData();
 
-    if (isJSArray(baseValue) && propertyName == callFrame->propertyNames().length) {
+    if (isJSArray(globalData, baseValue) && propertyName == callFrame->propertyNames().length) {
 #if USE(CTI_REPATCH_PIC)
         JIT::compilePatchGetArrayLength(callFrame->scopeChain()->globalData, codeBlock, returnAddress);
 #else
-        ctiPatchCallByReturnAddress(returnAddress, m_ctiArrayLengthTrampoline);
+        ctiPatchCallByReturnAddress(returnAddress, globalData->jitStubs.ctiArrayLengthTrampoline());
 #endif
         return;
     }
-    if (isJSString(baseValue) && propertyName == callFrame->propertyNames().length) {
+    
+    if (isJSString(globalData, baseValue) && propertyName == callFrame->propertyNames().length) {
         // The tradeoff of compiling an patched inline string length access routine does not seem
         // to pay off, so we currently only do this for arrays.
-        ctiPatchCallByReturnAddress(returnAddress, m_ctiStringLengthTrampoline);
+        ctiPatchCallByReturnAddress(returnAddress, globalData->jitStubs.ctiStringLengthTrampoline());
         return;
     }
 
     // Uncacheable: give up.
     if (!slot.isCacheable()) {
-        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_get_by_id_generic));
+        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(JITStubs::cti_op_get_by_id_generic));
         return;
     }
 
     JSCell* baseCell = asCell(baseValue);
     Structure* structure = baseCell->structure();
 
     if (structure->isDictionary()) {
-        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_get_by_id_generic));
+        ctiPatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(JITStubs::cti_op_get_by_id_generic));
         return;
     }
 
     // In the interpreter the last structure is trapped here; in CTI we use the
     // *_second method to achieve a similar (but not quite the same) effect.
 
     StructureStubInfo* stubInfo = &codeBlock->getStubInfo(returnAddress);
 
     // Cache hit: Specialize instruction and ref Structures.
 
@@ skipping 134 matching lines @@
             VM_THROW_EXCEPTION_AT_END(); \
     } while (0)
 #define CHECK_FOR_EXCEPTION_VOID() \
     do { \
         if (UNLIKELY(ARG_globalData->exception != noValue())) { \
             VM_THROW_EXCEPTION_AT_END(); \
             return; \
         } \
     } while (0)
 
-JSObject* Interpreter::cti_op_convert_this(STUB_ARGS)
+JSObject* JITStubs::cti_op_convert_this(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr v1 = ARG_src1;
     CallFrame* callFrame = ARG_callFrame;
 
     JSObject* result = v1.toThisObject(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
     return result;
 }
 
-void Interpreter::cti_op_end(STUB_ARGS)
+void JITStubs::cti_op_end(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     ScopeChainNode* scopeChain = ARG_callFrame->scopeChain();
     ASSERT(scopeChain->refCount > 1);
     scopeChain->deref();
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_add(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_add(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr v1 = ARG_src1;
     JSValuePtr v2 = ARG_src2;
 
     double left;
     double right = 0.0;
 
     bool rightIsNumber = v2.getNumber(right);
@@ skipping 24 matching lines @@
         }
         return JSValuePtr::encode(jsString(ARG_globalData, value.release()));
     }
 
     // All other cases are pretty uncommon
     JSValuePtr result = jsAddSlowCase(callFrame, v1, v2);
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_pre_inc(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_pre_inc(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr v = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, v.toNumber(callFrame) + 1);
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-int Interpreter::cti_timeout_check(STUB_ARGS)
+int JITStubs::cti_timeout_check(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
-    Interpreter* interpreter = ARG_globalData->interpreter;
+    
+    JSGlobalData* globalData = ARG_globalData;
+    TimeoutChecker& timeoutChecker = globalData->timeoutChecker;
 
-    if (interpreter->checkTimeout(ARG_callFrame->dynamicGlobalObject())) {
-        ARG_globalData->exception = createInterruptedExecutionException(ARG_globalData);
+    if (timeoutChecker.didTimeOut(ARG_callFrame)) {
+        globalData->exception = createInterruptedExecutionException(globalData);
         VM_THROW_EXCEPTION_AT_END();
     }
     
-    return interpreter->m_ticksUntilNextTimeoutCheck;
+    return timeoutChecker.ticksUntilNextCheck();
 }
 
-void Interpreter::cti_register_file_check(STUB_ARGS)
+void JITStubs::cti_register_file_check(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     if (LIKELY(ARG_registerFile->grow(ARG_callFrame + ARG_callFrame->codeBlock()->m_numCalleeRegisters)))
         return;
 
     // Rewind to the previous call frame because op_call already optimistically
     // moved the call frame forward.
     CallFrame* oldCallFrame = ARG_callFrame->callerFrame();
     ARG_setCallFrame(oldCallFrame);
     throwStackOverflowError(oldCallFrame, ARG_globalData, oldCallFrame->returnPC(), STUB_RETURN_ADDRESS);
 }
 
-int Interpreter::cti_op_loop_if_less(STUB_ARGS)
+int JITStubs::cti_op_loop_if_less(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
     CallFrame* callFrame = ARG_callFrame;
 
     bool result = jsLess(callFrame, src1, src2);
     CHECK_FOR_EXCEPTION_AT_END();
     return result;
 }
 
-int Interpreter::cti_op_loop_if_lesseq(STUB_ARGS)
+int JITStubs::cti_op_loop_if_lesseq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
     CallFrame* callFrame = ARG_callFrame;
 
     bool result = jsLessEq(callFrame, src1, src2);
     CHECK_FOR_EXCEPTION_AT_END();
     return result;
 }
 
-JSObject* Interpreter::cti_op_new_object(STUB_ARGS)
+JSObject* JITStubs::cti_op_new_object(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return constructEmptyObject(ARG_callFrame);
 }
 
-void Interpreter::cti_op_put_by_id_generic(STUB_ARGS)
+void JITStubs::cti_op_put_by_id_generic(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     PutPropertySlot slot;
     ARG_src1.put(ARG_callFrame, *ARG_id2, ARG_src3, slot);
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_generic(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id_generic(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(callFrame, ident, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
 #if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
 
-void Interpreter::cti_op_put_by_id(STUB_ARGS)
+void JITStubs::cti_op_put_by_id(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     PutPropertySlot slot;
     ARG_src1.put(callFrame, ident, ARG_src3, slot);
 
     ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_put_by_id_second));
 
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-void Interpreter::cti_op_put_by_id_second(STUB_ARGS)
+void JITStubs::cti_op_put_by_id_second(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     PutPropertySlot slot;
     ARG_src1.put(ARG_callFrame, *ARG_id2, ARG_src3, slot);
-    ARG_globalData->interpreter->tryCTICachePutByID(ARG_callFrame, ARG_callFrame->codeBlock(), STUB_RETURN_ADDRESS, ARG_src1, slot);
+    tryCachePutByID(ARG_callFrame, ARG_callFrame->codeBlock(), STUB_RETURN_ADDRESS, ARG_src1, slot);
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-void Interpreter::cti_op_put_by_id_fail(STUB_ARGS)
+void JITStubs::cti_op_put_by_id_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     PutPropertySlot slot;
     ARG_src1.put(callFrame, ident, ARG_src3, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(callFrame, ident, slot);
 
     ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_id_second));
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_second(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id_second(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(callFrame, ident, slot);
 
-    ARG_globalData->interpreter->tryCTICacheGetByID(callFrame, callFrame->codeBlock(), STUB_RETURN_ADDRESS, baseValue, ident, slot);
+    tryCacheGetByID(callFrame, callFrame->codeBlock(), STUB_RETURN_ADDRESS, baseValue, ident, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_self_fail(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id_self_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(callFrame, ident, slot);
 
@@ skipping 54 matching lines @@
         stubInfo->u.getByIdProtoList.listSize++;
         break;
     default:
         ASSERT_NOT_REACHED();
     }
     
     ASSERT(listIndex < POLYMORPHIC_LIST_CACHE_SIZE);
     return prototypeStructureList;
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_list(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id_proto_list(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION();
@@ skipping 40 matching lines @@
         JIT::compileGetByIdChainList(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, chain, count, slot.cachedOffset());
 
         if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
             ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_id_proto_list_full));
     } else
         ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_id_proto_fail));
 
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_list_full(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id_proto_list_full(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(ARG_callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_fail(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id_proto_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(ARG_callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_array_fail(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id_array_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(ARG_callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_string_fail(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_id_string_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
     JSValuePtr result = baseValue.get(ARG_callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
 #endif
 
-JSValueEncodedAsPointer* Interpreter::cti_op_instanceof(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_instanceof(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr value = ARG_src1;
     JSValuePtr baseVal = ARG_src2;
     JSValuePtr proto = ARG_src3;
 
     // at least one of these checks must have failed to get to the slow case
     ASSERT(!value.isCell() || !baseVal.isCell() || !proto.isCell()
@@ skipping 18 matching lines @@
         
     if (!value.isObject())
         return JSValuePtr::encode(jsBoolean(false));
 
     JSValuePtr result = jsBoolean(asObject(baseVal)->hasInstance(callFrame, value, proto));
     CHECK_FOR_EXCEPTION_AT_END();
 
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_del_by_id(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_del_by_id(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     
     JSObject* baseObj = ARG_src1.toObject(callFrame);
 
     JSValuePtr result = jsBoolean(baseObj->deleteProperty(callFrame, *ARG_id2));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_mul(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_mul(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     double left;
     double right;
     if (src1.getNumber(left) && src2.getNumber(right))
         return JSValuePtr::encode(jsNumber(ARG_globalData, left * right));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, src1.toNumber(callFrame) * src2.toNumber(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSObject* Interpreter::cti_op_new_func(STUB_ARGS)
+JSObject* JITStubs::cti_op_new_func(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return ARG_func1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
-void* Interpreter::cti_op_call_JSFunction(STUB_ARGS)
+void* JITStubs::cti_op_call_JSFunction(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
 #ifndef NDEBUG
     CallData callData;
     ASSERT(ARG_src1.getCallData(callData) == CallTypeJS);
 #endif
 
-    ScopeChainNode* callDataScopeChain = asFunction(ARG_src1)->m_scopeChain.node();
+    ScopeChainNode* callDataScopeChain = asFunction(ARG_src1)->scope().node();
     CodeBlock* newCodeBlock = &asFunction(ARG_src1)->body()->bytecode(callDataScopeChain);
 
     if (!newCodeBlock->jitCode())
         JIT::compile(ARG_globalData, newCodeBlock);
 
     return newCodeBlock;
 }
 
-VoidPtrPair Interpreter::cti_op_call_arityCheck(STUB_ARGS)
+VoidPtrPair JITStubs::cti_op_call_arityCheck(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* newCodeBlock = ARG_codeBlock4;
     int argCount = ARG_int3;
 
     ASSERT(argCount != newCodeBlock->m_numParameters);
 
     CallFrame* oldCallFrame = callFrame->callerFrame();
@@ skipping 24 matching lines @@
         for (size_t i = 0; i < omittedArgCount; ++i)
             argv[i] = jsUndefined();
 
         callFrame = CallFrame::create(r);
         callFrame->setCallerFrame(oldCallFrame);
     }
 
     RETURN_PAIR(newCodeBlock, callFrame);
 }
 
-void* Interpreter::cti_vm_dontLazyLinkCall(STUB_ARGS)
+void* JITStubs::cti_vm_dontLazyLinkCall(STUB_ARGS)
+{
+    BEGIN_STUB_FUNCTION();
+
+    JSGlobalData* globalData = ARG_globalData;
+    JSFunction* callee = asFunction(ARG_src1);
+    CodeBlock* codeBlock = &callee->body()->bytecode(callee->scope().node());
+    if (!codeBlock->jitCode())
+        JIT::compile(globalData, codeBlock);
+
+    ctiPatchNearCallByReturnAddress(ARG_returnAddress2, globalData->jitStubs.ctiVirtualCallLink());
+
+    return codeBlock->jitCode().addressForCall();
+}
+
+void* JITStubs::cti_vm_lazyLinkCall(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSFunction* callee = asFunction(ARG_src1);
-    CodeBlock* codeBlock = &callee->body()->bytecode(callee->m_scopeChain.node());
+    CodeBlock* codeBlock = &callee->body()->bytecode(callee->scope().node());
     if (!codeBlock->jitCode())
         JIT::compile(ARG_globalData, codeBlock);
 
-    ctiPatchNearCallByReturnAddress(ARG_returnAddress2, ARG_globalData->interpreter->m_ctiVirtualCallLink);
-
-    return codeBlock->jitCode().addressForCall();
-}
-
-void* Interpreter::cti_vm_lazyLinkCall(STUB_ARGS)
-{
-    BEGIN_STUB_FUNCTION();
-
-    JSFunction* callee = asFunction(ARG_src1);
-    CodeBlock* codeBlock = &callee->body()->bytecode(callee->m_scopeChain.node());
-    if (!codeBlock->jitCode())
-        JIT::compile(ARG_globalData, codeBlock);
-
     CallLinkInfo* callLinkInfo = &ARG_callFrame->callerFrame()->codeBlock()->getCallLinkInfo(ARG_returnAddress2);
     JIT::linkCall(callee, codeBlock, codeBlock->jitCode(), callLinkInfo, ARG_int3);
 
     return codeBlock->jitCode().addressForCall();
 }
 
-JSObject* Interpreter::cti_op_push_activation(STUB_ARGS)
+JSObject* JITStubs::cti_op_push_activation(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSActivation* activation = new (ARG_globalData) JSActivation(ARG_callFrame, static_cast<FunctionBodyNode*>(ARG_callFrame->codeBlock()->ownerNode()));
     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->copy()->push(activation));
     return activation;
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_call_NotJSFunction(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_call_NotJSFunction(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr funcVal = ARG_src1;
 
     CallData callData;
     CallType callType = funcVal.getCallData(callData);
 
     ASSERT(callType != CallTypeJS);
 
@@ skipping 28 matching lines @@
 
     ASSERT(callType == CallTypeNone);
 
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
     ARG_globalData->exception = createNotAFunctionError(ARG_callFrame, funcVal, vPCIndex, codeBlock);
     VM_THROW_EXCEPTION();
 }
 
-void Interpreter::cti_op_create_arguments(STUB_ARGS)
+void JITStubs::cti_op_create_arguments(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     Arguments* arguments = new (ARG_globalData) Arguments(ARG_callFrame);
     ARG_callFrame->setCalleeArguments(arguments);
     ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
 }
 
-void Interpreter::cti_op_create_arguments_no_params(STUB_ARGS)
+void JITStubs::cti_op_create_arguments_no_params(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     Arguments* arguments = new (ARG_globalData) Arguments(ARG_callFrame, Arguments::NoParameters);
     ARG_callFrame->setCalleeArguments(arguments);
     ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
 }
 
-void Interpreter::cti_op_tear_off_activation(STUB_ARGS)
+void JITStubs::cti_op_tear_off_activation(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain());
     asActivation(ARG_src1)->copyRegisters(ARG_callFrame->optionalCalleeArguments());
 }
 
-void Interpreter::cti_op_tear_off_arguments(STUB_ARGS)
+void JITStubs::cti_op_tear_off_arguments(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     ASSERT(ARG_callFrame->codeBlock()->usesArguments() && !ARG_callFrame->codeBlock()->needsFullScopeChain());
     ARG_callFrame->optionalCalleeArguments()->copyRegisters();
 }
 
-void Interpreter::cti_op_profile_will_call(STUB_ARGS)
+void JITStubs::cti_op_profile_will_call(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     ASSERT(*ARG_profilerReference);
     (*ARG_profilerReference)->willExecute(ARG_callFrame, ARG_src1);
 }
 
-void Interpreter::cti_op_profile_did_call(STUB_ARGS)
+void JITStubs::cti_op_profile_did_call(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     ASSERT(*ARG_profilerReference);
     (*ARG_profilerReference)->didExecute(ARG_callFrame, ARG_src1);
 }
 
-void Interpreter::cti_op_ret_scopeChain(STUB_ARGS)
+void JITStubs::cti_op_ret_scopeChain(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain());
     ARG_callFrame->scopeChain()->deref();
 }
 
-JSObject* Interpreter::cti_op_new_array(STUB_ARGS)
+JSObject* JITStubs::cti_op_new_array(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     ArgList argList(&ARG_callFrame->registers()[ARG_int1], ARG_int2);
     return constructArray(ARG_callFrame, argList);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_resolve(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_resolve(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
     ASSERT(iter != end);
 
     Identifier& ident = *ARG_id1;
     do {
         JSObject* o = *iter;
         PropertySlot slot(o);
         if (o->getPropertySlot(callFrame, ident, slot)) {
             JSValuePtr result = slot.getValue(callFrame, ident);
             CHECK_FOR_EXCEPTION_AT_END();
             return JSValuePtr::encode(result);
         }
     } while (++iter != end);
 
     CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
     VM_THROW_EXCEPTION();
 }
 
-JSObject* Interpreter::cti_op_construct_JSConstruct(STUB_ARGS)
+JSObject* JITStubs::cti_op_construct_JSConstruct(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
 #ifndef NDEBUG
     ConstructData constructData;
     ASSERT(asFunction(ARG_src1)->getConstructData(constructData) == ConstructTypeJS);
 #endif
 
     Structure* structure;
     if (ARG_src4.isObject())
         structure = asObject(ARG_src4)->inheritorID();
     else
-        structure = asFunction(ARG_src1)->m_scopeChain.node()->globalObject()->emptyObjectStructure();
+        structure = asFunction(ARG_src1)->scope().node()->globalObject()->emptyObjectStructure();
     return new (ARG_globalData) JSObject(structure);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_construct_NotJSConstruct(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_construct_NotJSConstruct(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr constrVal = ARG_src1;
     int argCount = ARG_int3;
     int thisRegister = ARG_int5;
 
     ConstructData constructData;
@@ skipping 13 matching lines @@
     }
 
     ASSERT(constructType == ConstructTypeNone);
 
     CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
     ARG_globalData->exception = createNotAConstructorError(callFrame, constrVal, vPCIndex, codeBlock);
     VM_THROW_EXCEPTION();
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_val(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_val(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
-    Interpreter* interpreter = ARG_globalData->interpreter;
+    JSGlobalData* globalData = ARG_globalData;
 
     JSValuePtr baseValue = ARG_src1;
     JSValuePtr subscript = ARG_src2;
 
     JSValuePtr result;
 
     if (LIKELY(subscript.isUInt32Fast())) {
         uint32_t i = subscript.getUInt32Fast();
-        if (interpreter->isJSArray(baseValue)) {
+        if (isJSArray(globalData, baseValue)) {
             JSArray* jsArray = asArray(baseValue);
             if (jsArray->canGetIndex(i))
                 result = jsArray->getIndex(i);
             else
                 result = jsArray->JSArray::get(callFrame, i);
-        } else if (interpreter->isJSString(baseValue) && asString(baseValue)->canGetIndex(i))
+        } else if (isJSString(globalData, baseValue) && asString(baseValue)->canGetIndex(i))
             result = asString(baseValue)->getIndex(ARG_globalData, i);
-        else if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
+        else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
             // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
             ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_val_byte_array));
             return JSValuePtr::encode(asByteArray(baseValue)->getIndex(callFrame, i));
         } else
             result = baseValue.get(callFrame, i);
     } else {
         Identifier property(callFrame, subscript.toString(callFrame));
         result = baseValue.get(callFrame, property);
     }
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_get_by_val_byte_array(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_get_by_val_byte_array(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
     
     CallFrame* callFrame = ARG_callFrame;
-    Interpreter* interpreter = ARG_globalData->interpreter;
+    JSGlobalData* globalData = ARG_globalData;
     
     JSValuePtr baseValue = ARG_src1;
     JSValuePtr subscript = ARG_src2;
     
     JSValuePtr result;
 
     if (LIKELY(subscript.isUInt32Fast())) {
         uint32_t i = subscript.getUInt32Fast();
-        if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
+        if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
             // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
             return JSValuePtr::encode(asByteArray(baseValue)->getIndex(callFrame, i));
         }
 
         result = baseValue.get(callFrame, i);
-        if (!interpreter->isJSByteArray(baseValue))
+        if (!isJSByteArray(globalData, baseValue))
             ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_val));
     } else {
         Identifier property(callFrame, subscript.toString(callFrame));
         result = baseValue.get(callFrame, property);
     }
     
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-VoidPtrPair Interpreter::cti_op_resolve_func(STUB_ARGS)
+VoidPtrPair JITStubs::cti_op_resolve_func(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
 
     // FIXME: add scopeDepthIsZero optimization
@@ skipping 21 matching lines @@
         }
         ++iter;
     } while (iter != end);
 
     CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
     VM_THROW_EXCEPTION_2();
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_sub(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_sub(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     double left;
     double right;
     if (src1.getNumber(left) && src2.getNumber(right))
         return JSValuePtr::encode(jsNumber(ARG_globalData, left - right));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, src1.toNumber(callFrame) - src2.toNumber(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-void Interpreter::cti_op_put_by_val(STUB_ARGS)
+void JITStubs::cti_op_put_by_val(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
-    Interpreter* interpreter = ARG_globalData->interpreter;
+    JSGlobalData* globalData = ARG_globalData;
 
     JSValuePtr baseValue = ARG_src1;
     JSValuePtr subscript = ARG_src2;
     JSValuePtr value = ARG_src3;
 
     if (LIKELY(subscript.isUInt32Fast())) {
         uint32_t i = subscript.getUInt32Fast();
-        if (interpreter->isJSArray(baseValue)) {
+        if (isJSArray(globalData, baseValue)) {
             JSArray* jsArray = asArray(baseValue);
             if (jsArray->canSetIndex(i))
                 jsArray->setIndex(i, value);
             else
                 jsArray->JSArray::put(callFrame, i, value);
-        } else if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
+        } else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
             JSByteArray* jsByteArray = asByteArray(baseValue);
             ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_put_by_val_byte_array));
             // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
             if (value.isInt32Fast()) {
                 jsByteArray->setIndex(i, value.getInt32Fast());
                 return;
             } else {
                 double dValue = 0;
                 if (value.getNumber(dValue)) {
                     jsByteArray->setIndex(i, dValue);
                     return;
                 }
             }
 
             baseValue.put(callFrame, i, value);
         } else
             baseValue.put(callFrame, i, value);
     } else {
         Identifier property(callFrame, subscript.toString(callFrame));
         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
             PutPropertySlot slot;
             baseValue.put(callFrame, property, value, slot);
         }
     }
 
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-void Interpreter::cti_op_put_by_val_array(STUB_ARGS)
+void JITStubs::cti_op_put_by_val_array(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
-
     JSValuePtr baseValue = ARG_src1;
     int i = ARG_int2;
     JSValuePtr value = ARG_src3;
 
-    ASSERT(ARG_globalData->interpreter->isJSArray(baseValue));
+    ASSERT(isJSArray(ARG_globalData, baseValue));
 
     if (LIKELY(i >= 0))
         asArray(baseValue)->JSArray::put(callFrame, i, value);
     else {
         // This should work since we're re-boxing an immediate unboxed in JIT code.
         ASSERT(JSValuePtr::makeInt32Fast(i));
         Identifier property(callFrame, JSValuePtr::makeInt32Fast(i).toString(callFrame));
         // FIXME: can toString throw an exception here?
         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
             PutPropertySlot slot;
             baseValue.put(callFrame, property, value, slot);
         }
     }
 
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-void Interpreter::cti_op_put_by_val_byte_array(STUB_ARGS)
+void JITStubs::cti_op_put_by_val_byte_array(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
     
     CallFrame* callFrame = ARG_callFrame;
-    Interpreter* interpreter = ARG_globalData->interpreter;
+    JSGlobalData* globalData = ARG_globalData;
     
     JSValuePtr baseValue = ARG_src1;
     JSValuePtr subscript = ARG_src2;
     JSValuePtr value = ARG_src3;
     
     if (LIKELY(subscript.isUInt32Fast())) {
         uint32_t i = subscript.getUInt32Fast();
-        if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
+        if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
             JSByteArray* jsByteArray = asByteArray(baseValue);
             
             // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
             if (value.isInt32Fast()) {
                 jsByteArray->setIndex(i, value.getInt32Fast());
                 return;
             } else {
                 double dValue = 0;                
                 if (value.getNumber(dValue)) {
                     jsByteArray->setIndex(i, dValue);
                     return;
                 }
             }
         }
 
-        if (!interpreter->isJSByteArray(baseValue))
+        if (!isJSByteArray(globalData, baseValue))
             ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_put_by_val));
         baseValue.put(callFrame, i, value);
     } else {
         Identifier property(callFrame, subscript.toString(callFrame));
         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
             PutPropertySlot slot;
             baseValue.put(callFrame, property, value, slot);
         }
     }
     
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_lesseq(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_lesseq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsBoolean(jsLessEq(callFrame, ARG_src1, ARG_src2));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-int Interpreter::cti_op_loop_if_true(STUB_ARGS)
+int JITStubs::cti_op_loop_if_true(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
     bool result = src1.toBoolean(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
     return result;
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_negate(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_negate(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src = ARG_src1;
 
     double v;
     if (src.getNumber(v))
         return JSValuePtr::encode(jsNumber(ARG_globalData, -v));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, -src.toNumber(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_resolve_base(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_resolve_base(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return JSValuePtr::encode(JSC::resolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain()));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_resolve_skip(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_resolve_skip(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     int skip = ARG_int2;
 
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
@@ skipping 12 matching lines @@
             return JSValuePtr::encode(result);
         }
     } while (++iter != end);
 
     CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
     VM_THROW_EXCEPTION();
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_resolve_global(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_resolve_global(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     JSGlobalObject* globalObject = asGlobalObject(ARG_src1);
     Identifier& ident = *ARG_id2;
     unsigned globalResolveInfoIndex = ARG_int3;
     ASSERT(globalObject->isGlobalObject());
 
     PropertySlot slot(globalObject);
@@ skipping 11 matching lines @@
 
         CHECK_FOR_EXCEPTION_AT_END();
         return JSValuePtr::encode(result);
     }
 
     unsigned vPCIndex = callFrame->codeBlock()->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, callFrame->codeBlock());
     VM_THROW_EXCEPTION();
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_div(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_div(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     double left;
     double right;
     if (src1.getNumber(left) && src2.getNumber(right))
         return JSValuePtr::encode(jsNumber(ARG_globalData, left / right));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, src1.toNumber(callFrame) / src2.toNumber(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_pre_dec(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_pre_dec(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr v = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, v.toNumber(callFrame) - 1);
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-int Interpreter::cti_op_jless(STUB_ARGS)
+int JITStubs::cti_op_jless(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
     CallFrame* callFrame = ARG_callFrame;
 
     bool result = jsLess(callFrame, src1, src2);
     CHECK_FOR_EXCEPTION_AT_END();
     return result;
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_not(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_not(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr result = jsBoolean(!src.toBoolean(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-int Interpreter::cti_op_jtrue(STUB_ARGS)
+int JITStubs::cti_op_jtrue(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
     bool result = src1.toBoolean(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
     return result;
 }
 
-VoidPtrPair Interpreter::cti_op_post_inc(STUB_ARGS)
+VoidPtrPair JITStubs::cti_op_post_inc(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr v = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr number = v.toJSNumber(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
 
     RETURN_PAIR(JSValuePtr::encode(number), JSValuePtr::encode(jsNumber(ARG_globalData, number.uncheckedGetNumber() + 1)));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_eq(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_eq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
 
     ASSERT(!JSValuePtr::areBothInt32Fast(src1, src2));
     JSValuePtr result = jsBoolean(JSValuePtr::equalSlowCaseInline(callFrame, src1, src2));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_lshift(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_lshift(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr val = ARG_src1;
     JSValuePtr shift = ARG_src2;
 
     int32_t left;
     uint32_t right;
     if (JSValuePtr::areBothInt32Fast(val, shift))
         return JSValuePtr::encode(jsNumber(ARG_globalData, val.getInt32Fast() << (shift.getInt32Fast() & 0x1f)));
     if (val.numberToInt32(left) && shift.numberToUInt32(right))
         return JSValuePtr::encode(jsNumber(ARG_globalData, left << (right & 0x1f)));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, (val.toInt32(callFrame)) << (shift.toUInt32(callFrame) & 0x1f));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_bitand(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_bitand(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     int32_t left;
     int32_t right;
     if (src1.numberToInt32(left) && src2.numberToInt32(right))
         return JSValuePtr::encode(jsNumber(ARG_globalData, left & right));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, src1.toInt32(callFrame) & src2.toInt32(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_rshift(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_rshift(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr val = ARG_src1;
     JSValuePtr shift = ARG_src2;
 
     int32_t left;
     uint32_t right;
     if (JSFastMath::canDoFastRshift(val, shift))
         return JSValuePtr::encode(JSFastMath::rightShiftImmediateNumbers(val, shift));
     if (val.numberToInt32(left) && shift.numberToUInt32(right))
         return JSValuePtr::encode(jsNumber(ARG_globalData, left >> (right & 0x1f)));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, (val.toInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_bitnot(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_bitnot(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src = ARG_src1;
 
     int value;
     if (src.numberToInt32(value))
         return JSValuePtr::encode(jsNumber(ARG_globalData, ~value));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsNumber(ARG_globalData, ~src.toInt32(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-VoidPtrPair Interpreter::cti_op_resolve_with_base(STUB_ARGS)
+VoidPtrPair JITStubs::cti_op_resolve_with_base(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
 
     // FIXME: add scopeDepthIsZero optimization
@@ skipping 13 matching lines @@
         }
         ++iter;
     } while (iter != end);
 
     CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
     ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPCIndex, codeBlock);
     VM_THROW_EXCEPTION_2();
 }
 
-JSObject* Interpreter::cti_op_new_func_exp(STUB_ARGS)
+JSObject* JITStubs::cti_op_new_func_exp(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return ARG_funcexp1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_mod(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_mod(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr dividendValue = ARG_src1;
     JSValuePtr divisorValue = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
     double d = dividendValue.toNumber(callFrame);
     JSValuePtr result = jsNumber(ARG_globalData, fmod(d, divisorValue.toNumber(callFrame)));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_less(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_less(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsBoolean(jsLess(callFrame, ARG_src1, ARG_src2));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_neq(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_neq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     ASSERT(!JSValuePtr::areBothInt32Fast(src1, src2));
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr result = jsBoolean(!JSValuePtr::equalSlowCaseInline(callFrame, src1, src2));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-VoidPtrPair Interpreter::cti_op_post_dec(STUB_ARGS)
+VoidPtrPair JITStubs::cti_op_post_dec(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr v = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr number = v.toJSNumber(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
 
     RETURN_PAIR(JSValuePtr::encode(number), JSValuePtr::encode(jsNumber(ARG_globalData, number.uncheckedGetNumber() - 1)));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_urshift(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_urshift(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr val = ARG_src1;
     JSValuePtr shift = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
 
     if (JSFastMath::canDoFastUrshift(val, shift))
         return JSValuePtr::encode(JSFastMath::rightShiftImmediateNumbers(val, shift));
     else {
         JSValuePtr result = jsNumber(ARG_globalData, (val.toUInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
         CHECK_FOR_EXCEPTION_AT_END();
         return JSValuePtr::encode(result);
     }
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_bitxor(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_bitxor(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr result = jsNumber(ARG_globalData, src1.toInt32(callFrame) ^ src2.toInt32(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSObject* Interpreter::cti_op_new_regexp(STUB_ARGS)
+JSObject* JITStubs::cti_op_new_regexp(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return new (ARG_globalData) RegExpObject(ARG_callFrame->lexicalGlobalObject()->regExpStructure(), ARG_regexp1);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_bitor(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_bitor(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr result = jsNumber(ARG_globalData, src1.toInt32(callFrame) | src2.toInt32(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_call_eval(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_call_eval(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     RegisterFile* registerFile = ARG_registerFile;
 
     Interpreter* interpreter = ARG_globalData->interpreter;
     
     JSValuePtr funcVal = ARG_src1;
     int registerOffset = ARG_int2;
@@ skipping 10 matching lines @@
         if (UNLIKELY(exceptionValue != noValue())) {
             ARG_globalData->exception = exceptionValue;
             VM_THROW_EXCEPTION_AT_END();
         }
         return JSValuePtr::encode(result);
     }
 
     return JSValuePtr::encode(jsImpossibleValue());
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_throw(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_throw(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
 
     unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
 
     JSValuePtr exceptionValue = ARG_src1;
     ASSERT(exceptionValue);
 
     HandlerInfo* handler = ARG_globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex, true);
 
     if (!handler) {
         *ARG_exception = exceptionValue;
         return JSValuePtr::encode(jsNull());
     }
 
     ARG_setCallFrame(callFrame);
     void* catchRoutine = handler->nativeCode.addressForExceptionHandler();
     ASSERT(catchRoutine);
     STUB_SET_RETURN_ADDRESS(catchRoutine);
     return JSValuePtr::encode(exceptionValue);
 }
 
-JSPropertyNameIterator* Interpreter::cti_op_get_pnames(STUB_ARGS)
+JSPropertyNameIterator* JITStubs::cti_op_get_pnames(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return JSPropertyNameIterator::create(ARG_callFrame, ARG_src1);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_next_pname(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_next_pname(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSPropertyNameIterator* it = ARG_pni1;
     JSValuePtr temp = it->next(ARG_callFrame);
     if (!temp)
         it->invalidate();
     return JSValuePtr::encode(temp);
 }
 
-JSObject* Interpreter::cti_op_push_scope(STUB_ARGS)
+JSObject* JITStubs::cti_op_push_scope(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSObject* o = ARG_src1.toObject(ARG_callFrame);
     CHECK_FOR_EXCEPTION();
     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->push(o));
     return o;
 }
 
-void Interpreter::cti_op_pop_scope(STUB_ARGS)
+void JITStubs::cti_op_pop_scope(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->pop());
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_typeof(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_typeof(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return JSValuePtr::encode(jsTypeStringForValue(ARG_callFrame, ARG_src1));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_is_undefined(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_is_undefined(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr v = ARG_src1;
     return JSValuePtr::encode(jsBoolean(v.isCell() ? v.asCell()->structure()->typeInfo().masqueradesAsUndefined() : v.isUndefined()));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_is_boolean(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_is_boolean(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return JSValuePtr::encode(jsBoolean(ARG_src1.isBoolean()));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_is_number(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_is_number(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return JSValuePtr::encode(jsBoolean(ARG_src1.isNumber()));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_is_string(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_is_string(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    return JSValuePtr::encode(jsBoolean(ARG_globalData->interpreter->isJSString(ARG_src1)));
+    return JSValuePtr::encode(jsBoolean(isJSString(ARG_globalData, ARG_src1)));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_is_object(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_is_object(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return JSValuePtr::encode(jsBoolean(jsIsObjectType(ARG_src1)));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_is_function(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_is_function(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     return JSValuePtr::encode(jsBoolean(jsIsFunctionType(ARG_src1)));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_stricteq(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_stricteq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     return JSValuePtr::encode(jsBoolean(JSValuePtr::strictEqual(src1, src2)));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_nstricteq(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_nstricteq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src1 = ARG_src1;
     JSValuePtr src2 = ARG_src2;
 
     return JSValuePtr::encode(jsBoolean(!JSValuePtr::strictEqual(src1, src2)));
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_to_jsnumber(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_to_jsnumber(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr src = ARG_src1;
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr result = src.toJSNumber(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_in(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_in(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     JSValuePtr baseVal = ARG_src2;
 
     if (!baseVal.isObject()) {
         CallFrame* callFrame = ARG_callFrame;
         CodeBlock* codeBlock = callFrame->codeBlock();
         unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, STUB_RETURN_ADDRESS);
         ARG_globalData->exception = createInvalidParamError(callFrame, "in", baseVal, vPCIndex, codeBlock);
         VM_THROW_EXCEPTION();
     }
 
     JSValuePtr propName = ARG_src1;
     JSObject* baseObj = asObject(baseVal);
 
     uint32_t i;
     if (propName.getUInt32(i))
         return JSValuePtr::encode(jsBoolean(baseObj->hasProperty(callFrame, i)));
 
     Identifier property(callFrame, propName.toString(callFrame));
     CHECK_FOR_EXCEPTION();
     return JSValuePtr::encode(jsBoolean(baseObj->hasProperty(callFrame, property)));
 }
 
-JSObject* Interpreter::cti_op_push_new_scope(STUB_ARGS)
+JSObject* JITStubs::cti_op_push_new_scope(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSObject* scope = new (ARG_globalData) JSStaticScopeObject(ARG_callFrame, *ARG_id1, ARG_src2, DontDelete);
 
     CallFrame* callFrame = ARG_callFrame;
     callFrame->setScopeChain(callFrame->scopeChain()->push(scope));
     return scope;
 }
 
-void Interpreter::cti_op_jmp_scopes(STUB_ARGS)
+void JITStubs::cti_op_jmp_scopes(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     unsigned count = ARG_int1;
     CallFrame* callFrame = ARG_callFrame;
 
     ScopeChainNode* tmp = callFrame->scopeChain();
     while (count--)
         tmp = tmp->pop();
     callFrame->setScopeChain(tmp);
 }
 
-void Interpreter::cti_op_put_by_index(STUB_ARGS)
+void JITStubs::cti_op_put_by_index(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     unsigned property = ARG_int2;
 
     ARG_src1.put(callFrame, property, ARG_src3);
 }
 
-void* Interpreter::cti_op_switch_imm(STUB_ARGS)
+void* JITStubs::cti_op_switch_imm(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
 
     if (scrutinee.isInt32Fast())
         return codeBlock->immediateSwitchJumpTable(tableIndex).ctiForValue(scrutinee.getInt32Fast()).addressForSwitch();
     else {
         int32_t value;
         if (scrutinee.numberToInt32(value))
             return codeBlock->immediateSwitchJumpTable(tableIndex).ctiForValue(value).addressForSwitch();
         else
             return codeBlock->immediateSwitchJumpTable(tableIndex).ctiDefault.addressForSwitch();
     }
 }
 
-void* Interpreter::cti_op_switch_char(STUB_ARGS)
+void* JITStubs::cti_op_switch_char(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
 
     void* result = codeBlock->characterSwitchJumpTable(tableIndex).ctiDefault.addressForSwitch();
 
     if (scrutinee.isString()) {
         UString::Rep* value = asString(scrutinee)->value().rep();
         if (value->size() == 1)
             result = codeBlock->characterSwitchJumpTable(tableIndex).ctiForValue(value->data()[0]).addressForSwitch();
     }
 
     return result;
 }
 
-void* Interpreter::cti_op_switch_string(STUB_ARGS)
+void* JITStubs::cti_op_switch_string(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSValuePtr scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
 
     void* result = codeBlock->stringSwitchJumpTable(tableIndex).ctiDefault.addressForSwitch();
 
     if (scrutinee.isString()) {
         UString::Rep* value = asString(scrutinee)->value().rep();
         result = codeBlock->stringSwitchJumpTable(tableIndex).ctiForValue(value).addressForSwitch();
     }
 
     return result;
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_op_del_by_val(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_op_del_by_val(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
     JSValuePtr baseValue = ARG_src1;
     JSObject* baseObj = baseValue.toObject(callFrame); // may throw
 
     JSValuePtr subscript = ARG_src2;
     JSValuePtr result;
     uint32_t i;
     if (subscript.getUInt32(i))
         result = jsBoolean(baseObj->deleteProperty(callFrame, i));
     else {
         CHECK_FOR_EXCEPTION();
         Identifier property(callFrame, subscript.toString(callFrame));
         CHECK_FOR_EXCEPTION();
         result = jsBoolean(baseObj->deleteProperty(callFrame, property));
     }
 
     CHECK_FOR_EXCEPTION_AT_END();
     return JSValuePtr::encode(result);
 }
 
-void Interpreter::cti_op_put_getter(STUB_ARGS)
+void JITStubs::cti_op_put_getter(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
     ASSERT(ARG_src1.isObject());
     JSObject* baseObj = asObject(ARG_src1);
     ASSERT(ARG_src3.isObject());
     baseObj->defineGetter(callFrame, *ARG_id2, asObject(ARG_src3));
 }
 
-void Interpreter::cti_op_put_setter(STUB_ARGS)
+void JITStubs::cti_op_put_setter(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
     ASSERT(ARG_src1.isObject());
     JSObject* baseObj = asObject(ARG_src1);
     ASSERT(ARG_src3.isObject());
     baseObj->defineSetter(callFrame, *ARG_id2, asObject(ARG_src3));
 }
 
-JSObject* Interpreter::cti_op_new_error(STUB_ARGS)
+JSObject* JITStubs::cti_op_new_error(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned type = ARG_int1;
     JSValuePtr message = ARG_src2;
     unsigned bytecodeOffset = ARG_int3;
 
     unsigned lineNumber = codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset);
     return Error::create(callFrame, static_cast<ErrorType>(type), message.toString(callFrame), lineNumber, codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->sourceURL());
 }
 
-void Interpreter::cti_op_debug(STUB_ARGS)
+void JITStubs::cti_op_debug(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
     int debugHookID = ARG_int1;
     int firstLine = ARG_int2;
     int lastLine = ARG_int3;
 
     ARG_globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
 }
 
-JSValueEncodedAsPointer* Interpreter::cti_vm_throw(STUB_ARGS)
+JSValueEncodedAsPointer* JITStubs::cti_vm_throw(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
     JSGlobalData* globalData = ARG_globalData;
 
     unsigned vPCIndex = codeBlock->getBytecodeIndex(callFrame, globalData->exceptionLocation);
 
     JSValuePtr exceptionValue = globalData->exception;
@@ skipping 17 matching lines @@
 #undef STUB_RETURN_ADDRESS
 #undef STUB_SET_RETURN_ADDRESS
 #undef BEGIN_STUB_FUNCTION
 #undef CHECK_FOR_EXCEPTION
 #undef CHECK_FOR_EXCEPTION_AT_END
 #undef CHECK_FOR_EXCEPTION_VOID
 #undef VM_THROW_EXCEPTION
 #undef VM_THROW_EXCEPTION_2
 #undef VM_THROW_EXCEPTION_AT_END
 
+} // namespace JSC
+
 #endif // ENABLE(JIT)
-
-} // namespace JSC