JavaScriptCore:
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 15 Nov 2008 19:55:20 +0000 (19:55 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 15 Nov 2008 19:55:20 +0000 (19:55 +0000)
2008-11-15  Geoffrey Garen  <ggaren@apple.com>

        Reviewed by Sam Weinig.

        Renamed Machine to BytecodeInterpreter.

        Nixed the Interpreter class, and changed its two functions to stand-alone
        functions.

        * JavaScriptCore.exp:
        * VM/CTI.cpp:
        (JSC::):
        (JSC::CTI::emitCTICall):
        (JSC::CTI::CTI):
        (JSC::CTI::compileOpCall):
        (JSC::CTI::emitSlowScriptCheck):
        (JSC::CTI::compileBinaryArithOpSlowCase):
        (JSC::CTI::privateCompileMainPass):
        (JSC::CTI::privateCompileSlowCases):
        (JSC::CTI::privateCompile):
        (JSC::CTI::privateCompileGetByIdSelf):
        (JSC::CTI::privateCompileGetByIdProto):
        (JSC::CTI::privateCompileGetByIdChain):
        (JSC::CTI::privateCompilePutByIdReplace):
        (JSC::CTI::privateCompilePutByIdTransition):
        (JSC::CTI::privateCompileCTIMachineTrampolines):
        (JSC::CTI::freeCTIMachineTrampolines):
        (JSC::CTI::patchGetByIdSelf):
        (JSC::CTI::patchPutByIdReplace):
        (JSC::CTI::privateCompilePatchGetArrayLength):
        (JSC::CTI::compileRegExp):
        * VM/CTI.h:
        * VM/CodeBlock.cpp:
        (JSC::CodeBlock::printStructureIDs):
        (JSC::CodeBlock::dump):
        (JSC::CodeBlock::derefStructureIDs):
        (JSC::CodeBlock::refStructureIDs):
        * VM/ExceptionHelpers.cpp:
        (JSC::createNotAnObjectError):
        * VM/Machine.cpp:
        (JSC::jsLess):
        (JSC::jsLessEq):
        (JSC::BytecodeInterpreter::resolve):
        (JSC::BytecodeInterpreter::resolveSkip):
        (JSC::BytecodeInterpreter::resolveGlobal):
        (JSC::BytecodeInterpreter::resolveBase):
        (JSC::BytecodeInterpreter::resolveBaseAndProperty):
        (JSC::BytecodeInterpreter::resolveBaseAndFunc):
        (JSC::BytecodeInterpreter::slideRegisterWindowForCall):
        (JSC::BytecodeInterpreter::callEval):
        (JSC::BytecodeInterpreter::BytecodeInterpreter):
        (JSC::BytecodeInterpreter::initialize):
        (JSC::BytecodeInterpreter::~BytecodeInterpreter):
        (JSC::BytecodeInterpreter::dumpCallFrame):
        (JSC::BytecodeInterpreter::dumpRegisters):
        (JSC::BytecodeInterpreter::isOpcode):
        (JSC::BytecodeInterpreter::unwindCallFrame):
        (JSC::BytecodeInterpreter::throwException):
        (JSC::BytecodeInterpreter::execute):
        (JSC::BytecodeInterpreter::debug):
        (JSC::BytecodeInterpreter::resetTimeoutCheck):
        (JSC::BytecodeInterpreter::checkTimeout):
        (JSC::BytecodeInterpreter::createExceptionScope):
        (JSC::BytecodeInterpreter::tryCachePutByID):
        (JSC::BytecodeInterpreter::uncachePutByID):
        (JSC::BytecodeInterpreter::tryCacheGetByID):
        (JSC::BytecodeInterpreter::uncacheGetByID):
        (JSC::BytecodeInterpreter::privateExecute):
        (JSC::BytecodeInterpreter::retrieveArguments):
        (JSC::BytecodeInterpreter::retrieveCaller):
        (JSC::BytecodeInterpreter::retrieveLastCaller):
        (JSC::BytecodeInterpreter::findFunctionCallFrame):
        (JSC::BytecodeInterpreter::tryCTICachePutByID):
        (JSC::BytecodeInterpreter::tryCTICacheGetByID):
        (JSC::BytecodeInterpreter::cti_op_convert_this):
        (JSC::BytecodeInterpreter::cti_op_end):
        (JSC::BytecodeInterpreter::cti_op_add):
        (JSC::BytecodeInterpreter::cti_op_pre_inc):
        (JSC::BytecodeInterpreter::cti_timeout_check):
        (JSC::BytecodeInterpreter::cti_register_file_check):
        (JSC::BytecodeInterpreter::cti_op_loop_if_less):
        (JSC::BytecodeInterpreter::cti_op_loop_if_lesseq):
        (JSC::BytecodeInterpreter::cti_op_new_object):
        (JSC::BytecodeInterpreter::cti_op_put_by_id):
        (JSC::BytecodeInterpreter::cti_op_put_by_id_second):
        (JSC::BytecodeInterpreter::cti_op_put_by_id_generic):
        (JSC::BytecodeInterpreter::cti_op_put_by_id_fail):
        (JSC::BytecodeInterpreter::cti_op_get_by_id):
        (JSC::BytecodeInterpreter::cti_op_get_by_id_second):
        (JSC::BytecodeInterpreter::cti_op_get_by_id_generic):
        (JSC::BytecodeInterpreter::cti_op_get_by_id_fail):
        (JSC::BytecodeInterpreter::cti_op_instanceof):
        (JSC::BytecodeInterpreter::cti_op_del_by_id):
        (JSC::BytecodeInterpreter::cti_op_mul):
        (JSC::BytecodeInterpreter::cti_op_new_func):
        (JSC::BytecodeInterpreter::cti_op_call_JSFunction):
        (JSC::BytecodeInterpreter::cti_op_call_arityCheck):
        (JSC::BytecodeInterpreter::cti_vm_dontLazyLinkCall):
        (JSC::BytecodeInterpreter::cti_vm_lazyLinkCall):
        (JSC::BytecodeInterpreter::cti_op_push_activation):
        (JSC::BytecodeInterpreter::cti_op_call_NotJSFunction):
        (JSC::BytecodeInterpreter::cti_op_create_arguments):
        (JSC::BytecodeInterpreter::cti_op_create_arguments_no_params):
        (JSC::BytecodeInterpreter::cti_op_tear_off_activation):
        (JSC::BytecodeInterpreter::cti_op_tear_off_arguments):
        (JSC::BytecodeInterpreter::cti_op_profile_will_call):
        (JSC::BytecodeInterpreter::cti_op_profile_did_call):
        (JSC::BytecodeInterpreter::cti_op_ret_scopeChain):
        (JSC::BytecodeInterpreter::cti_op_new_array):
        (JSC::BytecodeInterpreter::cti_op_resolve):
        (JSC::BytecodeInterpreter::cti_op_construct_JSConstruct):
        (JSC::BytecodeInterpreter::cti_op_construct_NotJSConstruct):
        (JSC::BytecodeInterpreter::cti_op_get_by_val):
        (JSC::BytecodeInterpreter::cti_op_resolve_func):
        (JSC::BytecodeInterpreter::cti_op_sub):
        (JSC::BytecodeInterpreter::cti_op_put_by_val):
        (JSC::BytecodeInterpreter::cti_op_put_by_val_array):
        (JSC::BytecodeInterpreter::cti_op_lesseq):
        (JSC::BytecodeInterpreter::cti_op_loop_if_true):
        (JSC::BytecodeInterpreter::cti_op_negate):
        (JSC::BytecodeInterpreter::cti_op_resolve_base):
        (JSC::BytecodeInterpreter::cti_op_resolve_skip):
        (JSC::BytecodeInterpreter::cti_op_resolve_global):
        (JSC::BytecodeInterpreter::cti_op_div):
        (JSC::BytecodeInterpreter::cti_op_pre_dec):
        (JSC::BytecodeInterpreter::cti_op_jless):
        (JSC::BytecodeInterpreter::cti_op_not):
        (JSC::BytecodeInterpreter::cti_op_jtrue):
        (JSC::BytecodeInterpreter::cti_op_post_inc):
        (JSC::BytecodeInterpreter::cti_op_eq):
        (JSC::BytecodeInterpreter::cti_op_lshift):
        (JSC::BytecodeInterpreter::cti_op_bitand):
        (JSC::BytecodeInterpreter::cti_op_rshift):
        (JSC::BytecodeInterpreter::cti_op_bitnot):
        (JSC::BytecodeInterpreter::cti_op_resolve_with_base):
        (JSC::BytecodeInterpreter::cti_op_new_func_exp):
        (JSC::BytecodeInterpreter::cti_op_mod):
        (JSC::BytecodeInterpreter::cti_op_less):
        (JSC::BytecodeInterpreter::cti_op_neq):
        (JSC::BytecodeInterpreter::cti_op_post_dec):
        (JSC::BytecodeInterpreter::cti_op_urshift):
        (JSC::BytecodeInterpreter::cti_op_bitxor):
        (JSC::BytecodeInterpreter::cti_op_new_regexp):
        (JSC::BytecodeInterpreter::cti_op_bitor):
        (JSC::BytecodeInterpreter::cti_op_call_eval):
        (JSC::BytecodeInterpreter::cti_op_throw):
        (JSC::BytecodeInterpreter::cti_op_get_pnames):
        (JSC::BytecodeInterpreter::cti_op_next_pname):
        (JSC::BytecodeInterpreter::cti_op_push_scope):
        (JSC::BytecodeInterpreter::cti_op_pop_scope):
        (JSC::BytecodeInterpreter::cti_op_typeof):
        (JSC::BytecodeInterpreter::cti_op_is_undefined):
        (JSC::BytecodeInterpreter::cti_op_is_boolean):
        (JSC::BytecodeInterpreter::cti_op_is_number):
        (JSC::BytecodeInterpreter::cti_op_is_string):
        (JSC::BytecodeInterpreter::cti_op_is_object):
        (JSC::BytecodeInterpreter::cti_op_is_function):
        (JSC::BytecodeInterpreter::cti_op_stricteq):
        (JSC::BytecodeInterpreter::cti_op_nstricteq):
        (JSC::BytecodeInterpreter::cti_op_to_jsnumber):
        (JSC::BytecodeInterpreter::cti_op_in):
        (JSC::BytecodeInterpreter::cti_op_push_new_scope):
        (JSC::BytecodeInterpreter::cti_op_jmp_scopes):
        (JSC::BytecodeInterpreter::cti_op_put_by_index):
        (JSC::BytecodeInterpreter::cti_op_switch_imm):
        (JSC::BytecodeInterpreter::cti_op_switch_char):
        (JSC::BytecodeInterpreter::cti_op_switch_string):
        (JSC::BytecodeInterpreter::cti_op_del_by_val):
        (JSC::BytecodeInterpreter::cti_op_put_getter):
        (JSC::BytecodeInterpreter::cti_op_put_setter):
        (JSC::BytecodeInterpreter::cti_op_new_error):
        (JSC::BytecodeInterpreter::cti_op_debug):
        (JSC::BytecodeInterpreter::cti_vm_throw):
        * VM/Machine.h:
        * VM/Register.h:
        * VM/SamplingTool.cpp:
        (JSC::SamplingTool::run):
        * VM/SamplingTool.h:
        (JSC::SamplingTool::SamplingTool):
        * bytecompiler/CodeGenerator.cpp:
        (JSC::CodeGenerator::generate):
        (JSC::CodeGenerator::CodeGenerator):
        (JSC::CodeGenerator::emitOpcode):
        * debugger/DebuggerCallFrame.cpp:
        (JSC::DebuggerCallFrame::evaluate):
        * jsc.cpp:
        (runWithScripts):
        * parser/Nodes.cpp:
        (JSC::ScopeNode::ScopeNode):
        * profiler/ProfileGenerator.cpp:
        (JSC::ProfileGenerator::addParentForConsoleStart):
        * runtime/ArrayPrototype.cpp:
        (JSC::arrayProtoFuncPop):
        (JSC::arrayProtoFuncPush):
        * runtime/Collector.cpp:
        (JSC::Heap::collect):
        * runtime/ExecState.h:
        (JSC::ExecState::interpreter):
        * runtime/FunctionPrototype.cpp:
        (JSC::functionProtoFuncApply):
        * runtime/Interpreter.cpp:
        (JSC::Interpreter::evaluate):
        * runtime/JSCell.h:
        * runtime/JSFunction.cpp:
        (JSC::JSFunction::call):
        (JSC::JSFunction::argumentsGetter):
        (JSC::JSFunction::callerGetter):
        (JSC::JSFunction::construct):
        * runtime/JSFunction.h:
        * runtime/JSGlobalData.cpp:
        (JSC::JSGlobalData::JSGlobalData):
        (JSC::JSGlobalData::~JSGlobalData):
        * runtime/JSGlobalData.h:
        * runtime/JSGlobalObject.cpp:
        (JSC::JSGlobalObject::~JSGlobalObject):
        (JSC::JSGlobalObject::setTimeoutTime):
        (JSC::JSGlobalObject::startTimeoutCheck):
        (JSC::JSGlobalObject::stopTimeoutCheck):
        (JSC::JSGlobalObject::mark):
        * runtime/JSGlobalObjectFunctions.cpp:
        (JSC::globalFuncEval):
        * runtime/JSString.h:
        * runtime/RegExp.cpp:
        (JSC::RegExp::RegExp):

JavaScriptGlue:

2008-11-15  Geoffrey Garen  <ggaren@apple.com>

        Reviewed by Sam Weinig.

        Updated for JavaScriptCore renames.

        * JSRun.cpp:
        (JSRun::Evaluate):
        (JSRun::CheckSyntax):

WebCore:

2008-11-15  Geoffrey Garen  <ggaren@apple.com>

        Reviewed by Sam Weinig.

        Updated for JavaScriptCore renames.

        * bindings/js/JSNodeCustom.cpp:
        (WebCore::JSNode::mark):
        * bindings/js/JSXMLHttpRequestCustom.cpp:
        (WebCore::JSXMLHttpRequest::send):
        * bindings/js/ScriptController.cpp:
        (WebCore::ScriptController::evaluate):
        * bindings/js/WorkerScriptController.cpp:
        (WebCore::WorkerScriptController::evaluate):
        * bindings/objc/WebScriptObject.mm:
        (-[WebScriptObject evaluateWebScript:]):
        * bridge/NP_jsobject.cpp:
        (_NPN_Evaluate):
        * bridge/jni/jni_jsobject.mm:
        (JavaJSObject::eval):
        * page/Console.cpp:
        (WebCore::retrieveLastCaller):
        (WebCore::Console::trace):

WebKit/win:

2008-11-15  Geoffrey Garen  <ggaren@apple.com>

        Reviewed by Sam Weinig.

        Updated for JavaScriptCore renames.

        * WebScriptCallFrame.cpp:
        (WebScriptCallFrame::valueByEvaluatingJavaScriptFromString):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@38423 268f45cc-cd09-0410-ab3c-d52691b4dbfc

45 files changed:
JavaScriptCore/API/JSBase.cpp
JavaScriptCore/ChangeLog
JavaScriptCore/JavaScriptCore.exp
JavaScriptCore/VM/CTI.cpp
JavaScriptCore/VM/CTI.h
JavaScriptCore/VM/CodeBlock.cpp
JavaScriptCore/VM/ExceptionHelpers.cpp
JavaScriptCore/VM/Machine.cpp
JavaScriptCore/VM/Machine.h
JavaScriptCore/VM/Register.h
JavaScriptCore/VM/SamplingTool.cpp
JavaScriptCore/VM/SamplingTool.h
JavaScriptCore/bytecompiler/CodeGenerator.cpp
JavaScriptCore/debugger/DebuggerCallFrame.cpp
JavaScriptCore/jsc.cpp
JavaScriptCore/parser/Nodes.cpp
JavaScriptCore/profiler/ProfileGenerator.cpp
JavaScriptCore/runtime/ArrayPrototype.cpp
JavaScriptCore/runtime/Collector.cpp
JavaScriptCore/runtime/ExecState.h
JavaScriptCore/runtime/FunctionPrototype.cpp
JavaScriptCore/runtime/Interpreter.cpp
JavaScriptCore/runtime/Interpreter.h
JavaScriptCore/runtime/JSCell.h
JavaScriptCore/runtime/JSFunction.cpp
JavaScriptCore/runtime/JSFunction.h
JavaScriptCore/runtime/JSGlobalData.cpp
JavaScriptCore/runtime/JSGlobalData.h
JavaScriptCore/runtime/JSGlobalObject.cpp
JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
JavaScriptCore/runtime/JSString.h
JavaScriptCore/runtime/RegExp.cpp
JavaScriptGlue/ChangeLog
JavaScriptGlue/JSRun.cpp
WebCore/ChangeLog
WebCore/bindings/js/JSNodeCustom.cpp
WebCore/bindings/js/JSXMLHttpRequestCustom.cpp
WebCore/bindings/js/ScriptController.cpp
WebCore/bindings/js/WorkerScriptController.cpp
WebCore/bindings/objc/WebScriptObject.mm
WebCore/bridge/NP_jsobject.cpp
WebCore/bridge/jni/jni_jsobject.mm
WebCore/page/Console.cpp
WebKit/win/ChangeLog
WebKit/win/WebScriptCallFrame.cpp

index a586aed..5d3164e 100644 (file)
@@ -48,10 +48,10 @@ JSValueRef JSEvaluateScript(JSContextRef ctx, JSStringRef script, JSObjectRef th
 
     JSObject* jsThisObject = toJS(thisObject);
 
-    // Interpreter::evaluate sets "this" to the global object if it is NULL
+    // evaluate sets "this" to the global object if it is NULL
     JSGlobalObject* globalObject = exec->dynamicGlobalObject();
     SourceCode source = makeSource(script->ustring(), sourceURL->ustring(), startingLineNumber);
-    Completion completion = Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), source, jsThisObject);
+    Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), source, jsThisObject);
 
     if (completion.complType() == Throw) {
         if (exception)
@@ -73,7 +73,7 @@ bool JSCheckScriptSyntax(JSContextRef ctx, JSStringRef script, JSStringRef sourc
     JSLock lock(exec);
 
     SourceCode source = makeSource(script->ustring(), sourceURL->ustring(), startingLineNumber);
-    Completion completion = Interpreter::checkSyntax(exec->dynamicGlobalObject()->globalExec(), source);
+    Completion completion = checkSyntax(exec->dynamicGlobalObject()->globalExec(), source);
     if (completion.complType() == Throw) {
         if (exception)
             *exception = toRef(completion.value());
index 1d644eb..70d96e8 100644 (file)
@@ -1,3 +1,228 @@
+2008-11-15  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig.
+        
+        Renamed Machine to BytecodeInterpreter.
+        
+        Nixed the Interpreter class, and changed its two functions to stand-alone
+        functions.
+
+        * JavaScriptCore.exp:
+        * VM/CTI.cpp:
+        (JSC::):
+        (JSC::CTI::emitCTICall):
+        (JSC::CTI::CTI):
+        (JSC::CTI::compileOpCall):
+        (JSC::CTI::emitSlowScriptCheck):
+        (JSC::CTI::compileBinaryArithOpSlowCase):
+        (JSC::CTI::privateCompileMainPass):
+        (JSC::CTI::privateCompileSlowCases):
+        (JSC::CTI::privateCompile):
+        (JSC::CTI::privateCompileGetByIdSelf):
+        (JSC::CTI::privateCompileGetByIdProto):
+        (JSC::CTI::privateCompileGetByIdChain):
+        (JSC::CTI::privateCompilePutByIdReplace):
+        (JSC::CTI::privateCompilePutByIdTransition):
+        (JSC::CTI::privateCompileCTIMachineTrampolines):
+        (JSC::CTI::freeCTIMachineTrampolines):
+        (JSC::CTI::patchGetByIdSelf):
+        (JSC::CTI::patchPutByIdReplace):
+        (JSC::CTI::privateCompilePatchGetArrayLength):
+        (JSC::CTI::compileRegExp):
+        * VM/CTI.h:
+        * VM/CodeBlock.cpp:
+        (JSC::CodeBlock::printStructureIDs):
+        (JSC::CodeBlock::dump):
+        (JSC::CodeBlock::derefStructureIDs):
+        (JSC::CodeBlock::refStructureIDs):
+        * VM/ExceptionHelpers.cpp:
+        (JSC::createNotAnObjectError):
+        * VM/Machine.cpp:
+        (JSC::jsLess):
+        (JSC::jsLessEq):
+        (JSC::BytecodeInterpreter::resolve):
+        (JSC::BytecodeInterpreter::resolveSkip):
+        (JSC::BytecodeInterpreter::resolveGlobal):
+        (JSC::BytecodeInterpreter::resolveBase):
+        (JSC::BytecodeInterpreter::resolveBaseAndProperty):
+        (JSC::BytecodeInterpreter::resolveBaseAndFunc):
+        (JSC::BytecodeInterpreter::slideRegisterWindowForCall):
+        (JSC::BytecodeInterpreter::callEval):
+        (JSC::BytecodeInterpreter::BytecodeInterpreter):
+        (JSC::BytecodeInterpreter::initialize):
+        (JSC::BytecodeInterpreter::~BytecodeInterpreter):
+        (JSC::BytecodeInterpreter::dumpCallFrame):
+        (JSC::BytecodeInterpreter::dumpRegisters):
+        (JSC::BytecodeInterpreter::isOpcode):
+        (JSC::BytecodeInterpreter::unwindCallFrame):
+        (JSC::BytecodeInterpreter::throwException):
+        (JSC::BytecodeInterpreter::execute):
+        (JSC::BytecodeInterpreter::debug):
+        (JSC::BytecodeInterpreter::resetTimeoutCheck):
+        (JSC::BytecodeInterpreter::checkTimeout):
+        (JSC::BytecodeInterpreter::createExceptionScope):
+        (JSC::BytecodeInterpreter::tryCachePutByID):
+        (JSC::BytecodeInterpreter::uncachePutByID):
+        (JSC::BytecodeInterpreter::tryCacheGetByID):
+        (JSC::BytecodeInterpreter::uncacheGetByID):
+        (JSC::BytecodeInterpreter::privateExecute):
+        (JSC::BytecodeInterpreter::retrieveArguments):
+        (JSC::BytecodeInterpreter::retrieveCaller):
+        (JSC::BytecodeInterpreter::retrieveLastCaller):
+        (JSC::BytecodeInterpreter::findFunctionCallFrame):
+        (JSC::BytecodeInterpreter::tryCTICachePutByID):
+        (JSC::BytecodeInterpreter::tryCTICacheGetByID):
+        (JSC::BytecodeInterpreter::cti_op_convert_this):
+        (JSC::BytecodeInterpreter::cti_op_end):
+        (JSC::BytecodeInterpreter::cti_op_add):
+        (JSC::BytecodeInterpreter::cti_op_pre_inc):
+        (JSC::BytecodeInterpreter::cti_timeout_check):
+        (JSC::BytecodeInterpreter::cti_register_file_check):
+        (JSC::BytecodeInterpreter::cti_op_loop_if_less):
+        (JSC::BytecodeInterpreter::cti_op_loop_if_lesseq):
+        (JSC::BytecodeInterpreter::cti_op_new_object):
+        (JSC::BytecodeInterpreter::cti_op_put_by_id):
+        (JSC::BytecodeInterpreter::cti_op_put_by_id_second):
+        (JSC::BytecodeInterpreter::cti_op_put_by_id_generic):
+        (JSC::BytecodeInterpreter::cti_op_put_by_id_fail):
+        (JSC::BytecodeInterpreter::cti_op_get_by_id):
+        (JSC::BytecodeInterpreter::cti_op_get_by_id_second):
+        (JSC::BytecodeInterpreter::cti_op_get_by_id_generic):
+        (JSC::BytecodeInterpreter::cti_op_get_by_id_fail):
+        (JSC::BytecodeInterpreter::cti_op_instanceof):
+        (JSC::BytecodeInterpreter::cti_op_del_by_id):
+        (JSC::BytecodeInterpreter::cti_op_mul):
+        (JSC::BytecodeInterpreter::cti_op_new_func):
+        (JSC::BytecodeInterpreter::cti_op_call_JSFunction):
+        (JSC::BytecodeInterpreter::cti_op_call_arityCheck):
+        (JSC::BytecodeInterpreter::cti_vm_dontLazyLinkCall):
+        (JSC::BytecodeInterpreter::cti_vm_lazyLinkCall):
+        (JSC::BytecodeInterpreter::cti_op_push_activation):
+        (JSC::BytecodeInterpreter::cti_op_call_NotJSFunction):
+        (JSC::BytecodeInterpreter::cti_op_create_arguments):
+        (JSC::BytecodeInterpreter::cti_op_create_arguments_no_params):
+        (JSC::BytecodeInterpreter::cti_op_tear_off_activation):
+        (JSC::BytecodeInterpreter::cti_op_tear_off_arguments):
+        (JSC::BytecodeInterpreter::cti_op_profile_will_call):
+        (JSC::BytecodeInterpreter::cti_op_profile_did_call):
+        (JSC::BytecodeInterpreter::cti_op_ret_scopeChain):
+        (JSC::BytecodeInterpreter::cti_op_new_array):
+        (JSC::BytecodeInterpreter::cti_op_resolve):
+        (JSC::BytecodeInterpreter::cti_op_construct_JSConstruct):
+        (JSC::BytecodeInterpreter::cti_op_construct_NotJSConstruct):
+        (JSC::BytecodeInterpreter::cti_op_get_by_val):
+        (JSC::BytecodeInterpreter::cti_op_resolve_func):
+        (JSC::BytecodeInterpreter::cti_op_sub):
+        (JSC::BytecodeInterpreter::cti_op_put_by_val):
+        (JSC::BytecodeInterpreter::cti_op_put_by_val_array):
+        (JSC::BytecodeInterpreter::cti_op_lesseq):
+        (JSC::BytecodeInterpreter::cti_op_loop_if_true):
+        (JSC::BytecodeInterpreter::cti_op_negate):
+        (JSC::BytecodeInterpreter::cti_op_resolve_base):
+        (JSC::BytecodeInterpreter::cti_op_resolve_skip):
+        (JSC::BytecodeInterpreter::cti_op_resolve_global):
+        (JSC::BytecodeInterpreter::cti_op_div):
+        (JSC::BytecodeInterpreter::cti_op_pre_dec):
+        (JSC::BytecodeInterpreter::cti_op_jless):
+        (JSC::BytecodeInterpreter::cti_op_not):
+        (JSC::BytecodeInterpreter::cti_op_jtrue):
+        (JSC::BytecodeInterpreter::cti_op_post_inc):
+        (JSC::BytecodeInterpreter::cti_op_eq):
+        (JSC::BytecodeInterpreter::cti_op_lshift):
+        (JSC::BytecodeInterpreter::cti_op_bitand):
+        (JSC::BytecodeInterpreter::cti_op_rshift):
+        (JSC::BytecodeInterpreter::cti_op_bitnot):
+        (JSC::BytecodeInterpreter::cti_op_resolve_with_base):
+        (JSC::BytecodeInterpreter::cti_op_new_func_exp):
+        (JSC::BytecodeInterpreter::cti_op_mod):
+        (JSC::BytecodeInterpreter::cti_op_less):
+        (JSC::BytecodeInterpreter::cti_op_neq):
+        (JSC::BytecodeInterpreter::cti_op_post_dec):
+        (JSC::BytecodeInterpreter::cti_op_urshift):
+        (JSC::BytecodeInterpreter::cti_op_bitxor):
+        (JSC::BytecodeInterpreter::cti_op_new_regexp):
+        (JSC::BytecodeInterpreter::cti_op_bitor):
+        (JSC::BytecodeInterpreter::cti_op_call_eval):
+        (JSC::BytecodeInterpreter::cti_op_throw):
+        (JSC::BytecodeInterpreter::cti_op_get_pnames):
+        (JSC::BytecodeInterpreter::cti_op_next_pname):
+        (JSC::BytecodeInterpreter::cti_op_push_scope):
+        (JSC::BytecodeInterpreter::cti_op_pop_scope):
+        (JSC::BytecodeInterpreter::cti_op_typeof):
+        (JSC::BytecodeInterpreter::cti_op_is_undefined):
+        (JSC::BytecodeInterpreter::cti_op_is_boolean):
+        (JSC::BytecodeInterpreter::cti_op_is_number):
+        (JSC::BytecodeInterpreter::cti_op_is_string):
+        (JSC::BytecodeInterpreter::cti_op_is_object):
+        (JSC::BytecodeInterpreter::cti_op_is_function):
+        (JSC::BytecodeInterpreter::cti_op_stricteq):
+        (JSC::BytecodeInterpreter::cti_op_nstricteq):
+        (JSC::BytecodeInterpreter::cti_op_to_jsnumber):
+        (JSC::BytecodeInterpreter::cti_op_in):
+        (JSC::BytecodeInterpreter::cti_op_push_new_scope):
+        (JSC::BytecodeInterpreter::cti_op_jmp_scopes):
+        (JSC::BytecodeInterpreter::cti_op_put_by_index):
+        (JSC::BytecodeInterpreter::cti_op_switch_imm):
+        (JSC::BytecodeInterpreter::cti_op_switch_char):
+        (JSC::BytecodeInterpreter::cti_op_switch_string):
+        (JSC::BytecodeInterpreter::cti_op_del_by_val):
+        (JSC::BytecodeInterpreter::cti_op_put_getter):
+        (JSC::BytecodeInterpreter::cti_op_put_setter):
+        (JSC::BytecodeInterpreter::cti_op_new_error):
+        (JSC::BytecodeInterpreter::cti_op_debug):
+        (JSC::BytecodeInterpreter::cti_vm_throw):
+        * VM/Machine.h:
+        * VM/Register.h:
+        * VM/SamplingTool.cpp:
+        (JSC::SamplingTool::run):
+        * VM/SamplingTool.h:
+        (JSC::SamplingTool::SamplingTool):
+        * bytecompiler/CodeGenerator.cpp:
+        (JSC::CodeGenerator::generate):
+        (JSC::CodeGenerator::CodeGenerator):
+        (JSC::CodeGenerator::emitOpcode):
+        * debugger/DebuggerCallFrame.cpp:
+        (JSC::DebuggerCallFrame::evaluate):
+        * jsc.cpp:
+        (runWithScripts):
+        * parser/Nodes.cpp:
+        (JSC::ScopeNode::ScopeNode):
+        * profiler/ProfileGenerator.cpp:
+        (JSC::ProfileGenerator::addParentForConsoleStart):
+        * runtime/ArrayPrototype.cpp:
+        (JSC::arrayProtoFuncPop):
+        (JSC::arrayProtoFuncPush):
+        * runtime/Collector.cpp:
+        (JSC::Heap::collect):
+        * runtime/ExecState.h:
+        (JSC::ExecState::interpreter):
+        * runtime/FunctionPrototype.cpp:
+        (JSC::functionProtoFuncApply):
+        * runtime/Interpreter.cpp:
+        (JSC::Interpreter::evaluate):
+        * runtime/JSCell.h:
+        * runtime/JSFunction.cpp:
+        (JSC::JSFunction::call):
+        (JSC::JSFunction::argumentsGetter):
+        (JSC::JSFunction::callerGetter):
+        (JSC::JSFunction::construct):
+        * runtime/JSFunction.h:
+        * runtime/JSGlobalData.cpp:
+        (JSC::JSGlobalData::JSGlobalData):
+        (JSC::JSGlobalData::~JSGlobalData):
+        * runtime/JSGlobalData.h:
+        * runtime/JSGlobalObject.cpp:
+        (JSC::JSGlobalObject::~JSGlobalObject):
+        (JSC::JSGlobalObject::setTimeoutTime):
+        (JSC::JSGlobalObject::startTimeoutCheck):
+        (JSC::JSGlobalObject::stopTimeoutCheck):
+        (JSC::JSGlobalObject::mark):
+        * runtime/JSGlobalObjectFunctions.cpp:
+        (JSC::globalFuncEval):
+        * runtime/JSString.h:
+        * runtime/RegExp.cpp:
+        (JSC::RegExp::RegExp):
+
 2008-11-15  Maciej Stachowiak  <mjs@apple.com>
 
         Reviewed by Sam Weinig.
index 07c9fa8..e660f15 100644 (file)
@@ -99,8 +99,6 @@ __ZN3JSC10JSFunction4infoE
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeE
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeEPKc
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeERKNS_7UStringE
-__ZN3JSC11Interpreter11checkSyntaxEPNS_9ExecStateERKNS_10SourceCodeE
-__ZN3JSC11Interpreter8evaluateEPNS_9ExecStateERNS_10ScopeChainERKNS_10SourceCodeEPNS_7JSValueE
 __ZN3JSC11JSImmediate12nonInlineNaNEv
 __ZN3JSC11JSImmediate8toObjectEPNS_7JSValueEPNS_9ExecStateE
 __ZN3JSC11JSImmediate8toStringEPNS_7JSValueE
@@ -119,6 +117,7 @@ __ZN3JSC11StructureID3getERKNS_10IdentifierERj
 __ZN3JSC11StructureID40addPropertyTransitionToExistingStructureEPS0_RKNS_10IdentifierEjRm
 __ZN3JSC11StructureIDC1EPNS_7JSValueERKNS_8TypeInfoE
 __ZN3JSC11StructureIDD1Ev
+__ZN3JSC11checkSyntaxEPNS_9ExecStateERKNS_10SourceCodeE
 __ZN3JSC12DateInstance4infoE
 __ZN3JSC12JSGlobalData10ClientDataD2Ev
 __ZN3JSC12JSGlobalData12createLeakedEv
@@ -257,6 +256,7 @@ __ZN3JSC8JSObject4markEv
 __ZN3JSC8Profiler13stopProfilingEPNS_9ExecStateERKNS_7UStringE
 __ZN3JSC8Profiler14startProfilingEPNS_9ExecStateERKNS_7UStringE
 __ZN3JSC8Profiler8profilerEv
+__ZN3JSC8evaluateEPNS_9ExecStateERNS_10ScopeChainERKNS_10SourceCodeEPNS_7JSValueE
 __ZN3JSC8jsStringEPNS_12JSGlobalDataERKNS_7UStringE
 __ZN3JSC9CodeBlockD1Ev
 __ZN3JSC9CodeBlockD2Ev
@@ -315,6 +315,8 @@ __ZNK3JSC17DebuggerCallFrame10thisObjectEv
 __ZNK3JSC17DebuggerCallFrame12functionNameEv
 __ZNK3JSC17DebuggerCallFrame4typeEv
 __ZNK3JSC17DebuggerCallFrame8evaluateERKNS_7UStringERPNS_7JSValueE
+__ZNK3JSC19BytecodeInterpreter14retrieveCallerEPNS_9ExecStateEPNS_16InternalFunctionE
+__ZNK3JSC19BytecodeInterpreter18retrieveLastCallerEPNS_9ExecStateERiRlRNS_7UStringERPNS_7JSValueE
 __ZNK3JSC6JSCell12toThisObjectEPNS_9ExecStateE
 __ZNK3JSC6JSCell12toThisStringEPNS_9ExecStateE
 __ZNK3JSC6JSCell14isGetterSetterEv
@@ -330,8 +332,6 @@ __ZNK3JSC7JSValue15toInt32SlowCaseEPNS_9ExecStateERb
 __ZNK3JSC7JSValue16toUInt32SlowCaseEPNS_9ExecStateERb
 __ZNK3JSC7JSValue7toFloatEPNS_9ExecStateE
 __ZNK3JSC7JSValue9toIntegerEPNS_9ExecStateE
-__ZNK3JSC7Machine14retrieveCallerEPNS_9ExecStateEPNS_16InternalFunctionE
-__ZNK3JSC7Machine18retrieveLastCallerEPNS_9ExecStateERiRlRNS_7UStringERPNS_7JSValueE
 __ZNK3JSC7UString10UTF8StringEb
 __ZNK3JSC7UString14toStrictUInt32EPb
 __ZNK3JSC7UString5asciiEv
index 7c2f801..ded70cb 100644 (file)
@@ -117,9 +117,9 @@ SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
 #else
     "movl %esp, 0(%esp)" "\n"
 #endif
-    "call " SYMBOL_STRING(_ZN3JSC7Machine12cti_vm_throwEPPv) "\n"
+    "call " SYMBOL_STRING(_ZN3JSC19BytecodeInterpreter12cti_vm_throwEPPv) "\n"
 #else
-    "call " SYMBOL_STRING(_ZN3JSC7Machine12cti_vm_throwEPvz) "\n"
+    "call " SYMBOL_STRING(_ZN3JSC19BytecodeInterpreter12cti_vm_throwEPvz) "\n"
 #endif
     "addl $0x20, %esp" "\n"
     "popl %ebx" "\n"
@@ -155,7 +155,7 @@ extern "C" {
     {
         __asm {
             mov ecx, esp;
-            call JSC::Machine::cti_vm_throw;
+            call JSC::BytecodeInterpreter::cti_vm_throw;
             add esp, 0x20;
             pop ebx;
             pop edi;
@@ -388,7 +388,7 @@ ALWAYS_INLINE  X86Assembler::JmpSrc CTI::emitNakedFastCall(unsigned opcodeIndex,
 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_j helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
 #else
     UNUSED_PARAM(vPC);
 #endif
@@ -397,7 +397,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
 #endif
     killLastResultRegister();
 
@@ -407,7 +407,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_o helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
 #else
     UNUSED_PARAM(vPC);
 #endif
@@ -416,7 +416,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
 #endif
     killLastResultRegister();
 
@@ -426,7 +426,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_p helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
 #else
     UNUSED_PARAM(vPC);
 #endif
@@ -435,7 +435,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
 #endif
     killLastResultRegister();
 
@@ -445,7 +445,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_b helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
 #else
     UNUSED_PARAM(vPC);
 #endif
@@ -454,7 +454,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
 #endif
     killLastResultRegister();
 
@@ -464,7 +464,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_v helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
 #else
     UNUSED_PARAM(vPC);
 #endif
@@ -473,7 +473,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
 #endif
     killLastResultRegister();
 
@@ -483,7 +483,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_s helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
 #else
     UNUSED_PARAM(vPC);
 #endif
@@ -492,7 +492,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
 #endif
     killLastResultRegister();
 
@@ -502,7 +502,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_2 helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
 #else
     UNUSED_PARAM(vPC);
 #endif
@@ -511,7 +511,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned o
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
-    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
+    m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
 #endif
     killLastResultRegister();
 
@@ -614,8 +614,8 @@ ALWAYS_INLINE void CTI::emitTagAsBoolImmediate(X86Assembler::RegisterID reg)
 }
 
 CTI::CTI(JSGlobalData* globalData, CodeBlock* codeBlock)
-    : m_jit(globalData->machine->jitCodeBuffer())
-    , m_machine(globalData->machine)
+    : m_jit(globalData->interpreter->jitCodeBuffer())
+    , m_interpreter(globalData->interpreter)
     , m_globalData(globalData)
     , m_codeBlock(codeBlock)
     , m_labels(codeBlock ? codeBlock->instructions.size() : 0)
@@ -630,7 +630,7 @@ CTI::CTI(JSGlobalData* globalData, CodeBlock* codeBlock)
     case name: { \
         emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
         emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
-        emitCTICall(instruction + i, i, Machine::cti_##name); \
+        emitCTICall(instruction + i, i, BytecodeInterpreter::cti_##name); \
         emitPutVirtualRegister(instruction[i + 1].u.operand); \
         i += 4; \
         break; \
@@ -639,7 +639,7 @@ CTI::CTI(JSGlobalData* globalData, CodeBlock* codeBlock)
 #define CTI_COMPILE_UNARY_OP(name) \
     case name: { \
         emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
-        emitCTICall(instruction + i, i, Machine::cti_##name); \
+        emitCTICall(instruction + i, i, BytecodeInterpreter::cti_##name); \
         emitPutVirtualRegister(instruction[i + 1].u.operand); \
         i += 3; \
         break; \
@@ -715,7 +715,7 @@ void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i,
         emitGetVirtualRegister(callee, X86::ecx, i);
         compileOpCallEvalSetupArgs(instruction);
 
-        emitCTICall(instruction, i, Machine::cti_op_call_eval);
+        emitCTICall(instruction, i, BytecodeInterpreter::cti_op_call_eval);
         m_jit.cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::eax);
         wasEval = m_jit.emitUnlinkedJne();
     }
@@ -738,7 +738,7 @@ void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i,
 
         emitPutCTIArg(X86::ecx, 0);
         emitPutCTIArgFromVirtualRegister(proto, 12, X86::eax);
-        emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct);
+        emitCTICall(instruction, i, BytecodeInterpreter::cti_op_construct_JSConstruct);
         emitPutVirtualRegister(thisRegister);
         emitGetVirtualRegister(callee, X86::ecx, i);
     }
@@ -763,7 +763,7 @@ void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i,
     emitPutVirtualRegister(dst);
 
 #if ENABLE(CODEBLOCK_SAMPLING)
-        m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_machine->sampler()->codeBlockSlot());
+        m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
 #endif
 }
 
@@ -826,11 +826,11 @@ void CTI::emitSlowScriptCheck(Instruction* vPC, unsigned opcodeIndex)
 {
     m_jit.subl_i8r(1, X86::esi);
     X86Assembler::JmpSrc skipTimeout = m_jit.emitUnlinkedJne();
-    emitCTICall(vPC, opcodeIndex, Machine::cti_timeout_check);
+    emitCTICall(vPC, opcodeIndex, BytecodeInterpreter::cti_timeout_check);
 
     emitGetCTIParam(CTI_ARGS_globalData, X86::ecx);
-    m_jit.movl_mr(OBJECT_OFFSET(JSGlobalData, machine), X86::ecx, X86::ecx);
-    m_jit.movl_mr(OBJECT_OFFSET(Machine, m_ticksUntilNextTimeoutCheck), X86::ecx, X86::esi);
+    m_jit.movl_mr(OBJECT_OFFSET(JSGlobalData, interpreter), X86::ecx, X86::ecx);
+    m_jit.movl_mr(OBJECT_OFFSET(BytecodeInterpreter, m_ticksUntilNextTimeoutCheck), X86::ecx, X86::esi);
     m_jit.link(skipTimeout, m_jit.label());
 
     killLastResultRegister();
@@ -1065,12 +1065,12 @@ void CTI::compileBinaryArithOpSlowCase(Instruction* vPC, OpcodeID opcodeID, Vect
     emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
     emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
     if (opcodeID == op_add)
-        emitCTICall(vPC, i, Machine::cti_op_add);
+        emitCTICall(vPC, i, BytecodeInterpreter::cti_op_add);
     else if (opcodeID == op_sub)
-        emitCTICall(vPC, i, Machine::cti_op_sub);
+        emitCTICall(vPC, i, BytecodeInterpreter::cti_op_sub);
     else {
         ASSERT(opcodeID == op_mul);
-        emitCTICall(vPC, i, Machine::cti_op_mul);
+        emitCTICall(vPC, i, BytecodeInterpreter::cti_op_mul);
     }
     emitPutVirtualRegister(dst);
 }
@@ -1084,15 +1084,15 @@ void CTI::privateCompileMainPass()
     unsigned callLinkInfoIndex = 0;
 
     for (unsigned i = 0; i < instructionCount; ) {
-        ASSERT_WITH_MESSAGE(m_machine->isOpcode(instruction[i].u.opcode), "privateCompileMainPass gone bad @ %d", i);
+        ASSERT_WITH_MESSAGE(m_interpreter->isOpcode(instruction[i].u.opcode), "privateCompileMainPass gone bad @ %d", i);
 
 #if ENABLE(OPCODE_SAMPLING)
         if (i > 0) // Avoid the overhead of sampling op_enter twice.
-            m_jit.movl_i32m(m_machine->sampler()->encodeSample(instruction + i), m_machine->sampler()->sampleSlot());
+            m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(instruction + i), m_interpreter->sampler()->sampleSlot());
 #endif
 
         m_labels[i] = m_jit.label();
-        OpcodeID opcodeID = m_machine->getOpcodeID(instruction[i].u.opcode);
+        OpcodeID opcodeID = m_interpreter->getOpcodeID(instruction[i].u.opcode);
         switch (opcodeID) {
         case op_mov: {
             unsigned src = instruction[i + 2].u.operand;
@@ -1128,7 +1128,7 @@ void CTI::privateCompileMainPass()
                 else {
                     emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
                     emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
-                    emitCTICall(instruction + i, i, Machine::cti_op_add);
+                    emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_add);
                     emitPutVirtualRegister(instruction[i + 1].u.operand);
                 }
             }
@@ -1138,7 +1138,7 @@ void CTI::privateCompileMainPass()
         }
         case op_end: {
             if (m_codeBlock->needsFullScopeChain)
-                emitCTICall(instruction + i, i, Machine::cti_op_end);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_end);
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
             m_jit.pushl_m(RegisterFile::ReturnPC * static_cast<int>(sizeof(Register)), X86::edi);
             m_jit.ret();
@@ -1210,7 +1210,7 @@ void CTI::privateCompileMainPass()
             break;
         }
         case op_new_object: {
-            emitCTICall(instruction + i, i, Machine::cti_op_new_object);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_new_object);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 2;
             break;
@@ -1340,7 +1340,7 @@ void CTI::privateCompileMainPass()
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_del_by_id);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_del_by_id);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -1379,7 +1379,7 @@ void CTI::privateCompileMainPass()
         case op_new_func: {
             FuncDeclNode* func = (m_codeBlock->functions[instruction[i + 2].u.operand]).get();
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(func), 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_new_func);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_new_func);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -1435,19 +1435,19 @@ void CTI::privateCompileMainPass()
         }
         case op_tear_off_activation: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_tear_off_activation);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_tear_off_activation);
             i += 2;
             break;
         }
         case op_tear_off_arguments: {
-            emitCTICall(instruction + i, i, Machine::cti_op_tear_off_arguments);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_tear_off_arguments);
             i += 1;
             break;
         }
         case op_ret: {
             // We could JIT generate the deref, only calling out to C when the refcount hits zero.
             if (m_codeBlock->needsFullScopeChain)
-                emitCTICall(instruction + i, i, Machine::cti_op_ret_scopeChain);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_ret_scopeChain);
 
             // Return the result in %eax.
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
@@ -1469,7 +1469,7 @@ void CTI::privateCompileMainPass()
             m_jit.leal_mr(sizeof(Register) * instruction[i + 2].u.operand, X86::edi, X86::edx);
             emitPutCTIArg(X86::edx, 0);
             emitPutCTIArgConstant(instruction[i + 3].u.operand, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_new_array);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_new_array);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -1477,7 +1477,7 @@ void CTI::privateCompileMainPass()
         case op_resolve: {
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_resolve);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_resolve);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -1505,7 +1505,7 @@ void CTI::privateCompileMainPass()
             emitFastArithImmToInt(X86::edx);
             m_jit.testl_i32r(JSImmediate::TagMask, X86::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
-            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), X86::eax);
+            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
 
             // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
@@ -1522,7 +1522,7 @@ void CTI::privateCompileMainPass()
         case op_resolve_func: {
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_resolve_func);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_resolve_func);
             emitPutVirtualRegister(instruction[i + 2].u.operand, X86::edx);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
@@ -1539,7 +1539,7 @@ void CTI::privateCompileMainPass()
             emitFastArithImmToInt(X86::edx);
             m_jit.testl_i32r(JSImmediate::TagMask, X86::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
-            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), X86::eax);
+            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
             m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
 
             // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
@@ -1586,7 +1586,7 @@ void CTI::privateCompileMainPass()
         case op_resolve_base: {
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_resolve_base);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_resolve_base);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -1611,7 +1611,7 @@ void CTI::privateCompileMainPass()
                 m_jit.link(overflow, m_jit.label());
                 m_jit.link(notImmediate, m_jit.label());
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
-                emitCTICall(instruction + i, i, Machine::cti_op_negate);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_negate);
                 emitPutVirtualRegister(instruction[i + 1].u.operand);
             } else {
                 // Slow case immediates
@@ -1645,7 +1645,7 @@ void CTI::privateCompileMainPass()
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
             emitPutCTIArgConstant(instruction[i + 3].u.operand + m_codeBlock->needsFullScopeChain, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_resolve_skip);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_resolve_skip);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -1675,7 +1675,7 @@ void CTI::privateCompileMainPass()
             emitPutCTIArgConstant(globalObject, 0);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(instruction + i), 8);
-            emitCTICall(instruction + i, i, Machine::cti_op_resolve_global);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_resolve_global);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             m_jit.link(end, m_jit.label());
             i += 6;
@@ -1901,7 +1901,7 @@ void CTI::privateCompileMainPass()
         case op_resolve_with_base: {
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_resolve_with_base);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_resolve_with_base);
             emitPutVirtualRegister(instruction[i + 2].u.operand, X86::edx);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
@@ -1910,7 +1910,7 @@ void CTI::privateCompileMainPass()
         case op_new_func_exp: {
             FuncExprNode* func = (m_codeBlock->functionExpressions[instruction[i + 2].u.operand]).get();
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(func), 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_new_func_exp);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_new_func_exp);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -1987,7 +1987,7 @@ void CTI::privateCompileMainPass()
         case op_new_regexp: {
             RegExp* regExp = m_codeBlock->regexps[instruction[i + 2].u.operand].get();
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(regExp), 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_new_regexp);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_new_regexp);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -2002,7 +2002,7 @@ void CTI::privateCompileMainPass()
         }
         case op_throw: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_throw);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_throw);
             m_jit.addl_i8r(0x20, X86::esp);
             m_jit.popl_r(X86::ebx);
             m_jit.popl_r(X86::edi);
@@ -2013,7 +2013,7 @@ void CTI::privateCompileMainPass()
         }
         case op_get_pnames: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_get_pnames);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_get_pnames);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -2021,7 +2021,7 @@ void CTI::privateCompileMainPass()
         case op_next_pname: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
             unsigned target = instruction[i + 3].u.operand;
-            emitCTICall(instruction + i, i, Machine::cti_op_next_pname);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_next_pname);
             m_jit.testl_rr(X86::eax, X86::eax);
             X86Assembler::JmpSrc endOfIter = m_jit.emitUnlinkedJe();
             emitPutVirtualRegister(instruction[i + 1].u.operand);
@@ -2032,12 +2032,12 @@ void CTI::privateCompileMainPass()
         }
         case op_push_scope: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_push_scope);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_push_scope);
             i += 2;
             break;
         }
         case op_pop_scope: {
-            emitCTICall(instruction + i, i, Machine::cti_op_pop_scope);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_pop_scope);
             i += 1;
             break;
         }
@@ -2081,7 +2081,7 @@ void CTI::privateCompileMainPass()
         case op_in: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
             emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_in);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_in);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2090,7 +2090,7 @@ void CTI::privateCompileMainPass()
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 0);
             emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_push_new_scope);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_push_new_scope);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2104,7 +2104,7 @@ void CTI::privateCompileMainPass()
         case op_jmp_scopes: {
             unsigned count = instruction[i + 1].u.operand;
             emitPutCTIArgConstant(count, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_jmp_scopes);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jmp_scopes);
             unsigned target = instruction[i + 2].u.operand;
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJmp(), i + 2 + target));
             i += 3;
@@ -2114,7 +2114,7 @@ void CTI::privateCompileMainPass()
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
             emitPutCTIArgConstant(instruction[i + 2].u.operand, 4);
             emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 8, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_put_by_index);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_put_by_index);
             i += 4;
             break;
         }
@@ -2130,7 +2130,7 @@ void CTI::privateCompileMainPass()
 
             emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
             emitPutCTIArgConstant(tableIndex, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_switch_imm);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_switch_imm);
             m_jit.jmp_r(X86::eax);
             i += 4;
             break;
@@ -2147,7 +2147,7 @@ void CTI::privateCompileMainPass()
 
             emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
             emitPutCTIArgConstant(tableIndex, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_switch_char);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_switch_char);
             m_jit.jmp_r(X86::eax);
             i += 4;
             break;
@@ -2163,7 +2163,7 @@ void CTI::privateCompileMainPass()
 
             emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
             emitPutCTIArgConstant(tableIndex, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_switch_string);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_switch_string);
             m_jit.jmp_r(X86::eax);
             i += 4;
             break;
@@ -2171,7 +2171,7 @@ void CTI::privateCompileMainPass()
         case op_del_by_val: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
             emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_del_by_val);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_del_by_val);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2181,7 +2181,7 @@ void CTI::privateCompileMainPass()
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
             emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 8, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_put_getter);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_put_getter);
             i += 4;
             break;
         }
@@ -2190,7 +2190,7 @@ void CTI::privateCompileMainPass()
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
             emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 8, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_put_setter);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_put_setter);
             i += 4;
             break;
         }
@@ -2199,7 +2199,7 @@ void CTI::privateCompileMainPass()
             emitPutCTIArgConstant(instruction[i + 2].u.operand, 0);
             emitPutCTIArgConstant(asInteger(message), 4);
             emitPutCTIArgConstant(m_codeBlock->lineNumberForVPC(&instruction[i]), 8);
-            emitCTICall(instruction + i, i, Machine::cti_op_new_error);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_new_error);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2208,7 +2208,7 @@ void CTI::privateCompileMainPass()
             emitPutCTIArgConstant(instruction[i + 1].u.operand, 0);
             emitPutCTIArgConstant(instruction[i + 2].u.operand, 4);
             emitPutCTIArgConstant(instruction[i + 3].u.operand, 8);
-            emitCTICall(instruction + i, i, Machine::cti_op_debug);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_debug);
             i += 4;
             break;
         }
@@ -2291,14 +2291,14 @@ void CTI::privateCompileMainPass()
             for (size_t j = 0; j < count; ++j)
                 emitInitRegister(j);
 
-            emitCTICall(instruction + i, i, Machine::cti_op_push_activation);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_push_activation);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
 
             i+= 2;
             break;
         }
         case op_create_arguments: {
-            emitCTICall(instruction + i, i, (m_codeBlock->numParameters == 1) ? Machine::cti_op_create_arguments_no_params : Machine::cti_op_create_arguments);
+            emitCTICall(instruction + i, i, (m_codeBlock->numParameters == 1) ? BytecodeInterpreter::cti_op_create_arguments_no_params : BytecodeInterpreter::cti_op_create_arguments);
             i += 1;
             break;
         }
@@ -2318,7 +2318,7 @@ void CTI::privateCompileMainPass()
             m_jit.cmpl_i32m(0, X86::eax);
             X86Assembler::JmpSrc noProfiler = m_jit.emitUnlinkedJe();
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
-            emitCTICall(instruction + i, i, Machine::cti_op_profile_will_call);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_profile_will_call);
             m_jit.link(noProfiler, m_jit.label());
 
             i += 2;
@@ -2329,7 +2329,7 @@ void CTI::privateCompileMainPass()
             m_jit.cmpl_i32m(0, X86::eax);
             X86Assembler::JmpSrc noProfiler = m_jit.emitUnlinkedJe();
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
-            emitCTICall(instruction + i, i, Machine::cti_op_profile_did_call);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_profile_did_call);
             m_jit.link(noProfiler, m_jit.label());
 
             i += 2;
@@ -2366,7 +2366,7 @@ void CTI::privateCompileLinkPass()
         m_jit.link(iter->from, m_jit.label()); \
         emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
         emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
-        emitCTICall(instruction + i, i, Machine::cti_##name); \
+        emitCTICall(instruction + i, i, BytecodeInterpreter::cti_##name); \
         emitPutVirtualRegister(instruction[i + 1].u.operand); \
         i += 4; \
         break; \
@@ -2378,7 +2378,7 @@ void CTI::privateCompileLinkPass()
         m_jit.link((++iter)->from, m_jit.label());                \
         emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
         emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
-        emitCTICall(instruction + i, i, Machine::cti_##name); \
+        emitCTICall(instruction + i, i, BytecodeInterpreter::cti_##name); \
         emitPutVirtualRegister(instruction[i + 1].u.operand); \
         i += 4; \
         break; \
@@ -2399,12 +2399,12 @@ void CTI::privateCompileSlowCases()
         unsigned firstTo = i;
 #endif
 
-        switch (OpcodeID opcodeID = m_machine->getOpcodeID(instruction[i].u.opcode)) {
+        switch (OpcodeID opcodeID = m_interpreter->getOpcodeID(instruction[i].u.opcode)) {
         case op_convert_this: {
             m_jit.link(iter->from, m_jit.label());
             m_jit.link((++iter)->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_convert_this);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_convert_this);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 2;
             break;
@@ -2420,7 +2420,7 @@ void CTI::privateCompileSlowCases()
                 m_jit.link(notImm, m_jit.label());
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::eax, 4);
-                emitCTICall(instruction + i, i, Machine::cti_op_add);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_add);
                 emitPutVirtualRegister(dst);
             } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
                 X86Assembler::JmpSrc notImm = iter->from;
@@ -2429,7 +2429,7 @@ void CTI::privateCompileSlowCases()
                 m_jit.link(notImm, m_jit.label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
-                emitCTICall(instruction + i, i, Machine::cti_op_add);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_add);
                 emitPutVirtualRegister(dst);
             } else {
                 OperandTypes types = OperandTypes::fromInt(instruction[i + 4].u.operand);
@@ -2453,7 +2453,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(notImm, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_get_by_val);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_get_by_val);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             m_jit.link(m_jit.emitUnlinkedJmp(), m_labels[i + 4]);
 
@@ -2490,7 +2490,7 @@ void CTI::privateCompileSlowCases()
             }
 
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_negate);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_negate);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2500,7 +2500,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link((++iter)->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::ecx, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_rshift);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_rshift);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2514,7 +2514,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(notImm2, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::ecx, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_lshift);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_lshift);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2528,7 +2528,7 @@ void CTI::privateCompileSlowCases()
                 m_jit.link(iter->from, m_jit.label());
                 emitPutCTIArg(X86::edx, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(instruction + i, i, Machine::cti_op_loop_if_less);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_loop_if_less);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
             } else {
@@ -2536,7 +2536,7 @@ void CTI::privateCompileSlowCases()
                 m_jit.link((++iter)->from, m_jit.label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
-                emitCTICall(instruction + i, i, Machine::cti_op_loop_if_less);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_loop_if_less);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
             }
@@ -2552,7 +2552,7 @@ void CTI::privateCompileSlowCases()
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 8);
-            X86Assembler::JmpSrc call = emitCTICall(instruction + i, i, Machine::cti_op_put_by_id);
+            X86Assembler::JmpSrc call = emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_put_by_id);
 
             // Track the location of the call; this will be used to recover repatch information.
             ASSERT(m_codeBlock->propertyAccessInstructions[propertyAccessInstructionIndex].opcodeIndex == i);
@@ -2579,7 +2579,7 @@ void CTI::privateCompileSlowCases()
             emitPutCTIArg(X86::eax, 0);
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
-            X86Assembler::JmpSrc call = emitCTICall(instruction + i, i, Machine::cti_op_get_by_id);
+            X86Assembler::JmpSrc call = emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_get_by_id);
             ASSERT(X86Assembler::getDifferenceBetweenLabels(coldPathBegin, call) == repatchOffsetGetByIdSlowCaseCall);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
 
@@ -2600,7 +2600,7 @@ void CTI::privateCompileSlowCases()
                 m_jit.link(iter->from, m_jit.label());
                 emitPutCTIArg(X86::edx, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(instruction + i, i, Machine::cti_op_loop_if_lesseq);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_loop_if_lesseq);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
             } else {
@@ -2608,7 +2608,7 @@ void CTI::privateCompileSlowCases()
                 m_jit.link((++iter)->from, m_jit.label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
-                emitCTICall(instruction + i, i, Machine::cti_op_loop_if_lesseq);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_loop_if_lesseq);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
             }
@@ -2622,7 +2622,7 @@ void CTI::privateCompileSlowCases()
             m_jit.subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
             m_jit.link(notImm, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_pre_inc);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_pre_inc);
             emitPutVirtualRegister(srcDst);
             i += 2;
             break;
@@ -2638,7 +2638,7 @@ void CTI::privateCompileSlowCases()
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
             emitPutCTIArg(X86::ecx, 8);
-            emitCTICall(instruction + i, i, Machine::cti_op_put_by_val);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_put_by_val);
             m_jit.link(m_jit.emitUnlinkedJmp(), m_labels[i + 4]);
 
             // slow cases for immediate int accesses to arrays
@@ -2648,7 +2648,7 @@ void CTI::privateCompileSlowCases()
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
             emitPutCTIArg(X86::ecx, 8);
-            emitCTICall(instruction + i, i, Machine::cti_op_put_by_val_array);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_put_by_val_array);
 
             i += 4;
             break;
@@ -2658,7 +2658,7 @@ void CTI::privateCompileSlowCases()
 
             m_jit.link(iter->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_jtrue);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jtrue);
             m_jit.testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
             m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 2 + target]);
@@ -2672,7 +2672,7 @@ void CTI::privateCompileSlowCases()
             m_jit.addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
             m_jit.link(notImm, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_pre_dec);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_pre_dec);
             emitPutVirtualRegister(srcDst);
             i += 2;
             break;
@@ -2684,7 +2684,7 @@ void CTI::privateCompileSlowCases()
                 m_jit.link(iter->from, m_jit.label());
                 emitPutCTIArg(X86::edx, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(instruction + i, i, Machine::cti_op_jless);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jless);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
             } else {
@@ -2692,7 +2692,7 @@ void CTI::privateCompileSlowCases()
                 m_jit.link((++iter)->from, m_jit.label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
-                emitCTICall(instruction + i, i, Machine::cti_op_jless);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jless);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
             }
@@ -2703,7 +2703,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             m_jit.xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_not);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_not);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -2711,7 +2711,7 @@ void CTI::privateCompileSlowCases()
         case op_jfalse: {
             m_jit.link(iter->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_jtrue);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jtrue);
             m_jit.testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
             m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 2 + target]); // inverted!
@@ -2723,7 +2723,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             m_jit.link((++iter)->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_post_inc);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_post_inc);
             emitPutVirtualRegister(srcDst, X86::edx);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
@@ -2732,7 +2732,7 @@ void CTI::privateCompileSlowCases()
         case op_bitnot: {
             m_jit.link(iter->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_bitnot);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitnot);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -2745,19 +2745,19 @@ void CTI::privateCompileSlowCases()
                 m_jit.link(iter->from, m_jit.label());
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::eax, 4);
-                emitCTICall(instruction + i, i, Machine::cti_op_bitand);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitand);
                 emitPutVirtualRegister(dst);
             } else if (getConstantImmediateNumericArg(src2)) {
                 m_jit.link(iter->from, m_jit.label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
-                emitCTICall(instruction + i, i, Machine::cti_op_bitand);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitand);
                 emitPutVirtualRegister(dst);
             } else {
                 m_jit.link(iter->from, m_jit.label());
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::edx, 4);
-                emitCTICall(instruction + i, i, Machine::cti_op_bitand);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitand);
                 emitPutVirtualRegister(dst);
             }
             i += 5;
@@ -2766,7 +2766,7 @@ void CTI::privateCompileSlowCases()
         case op_jtrue: {
             m_jit.link(iter->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_jtrue);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jtrue);
             m_jit.testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
             m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 2 + target]);
@@ -2778,7 +2778,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             m_jit.link((++iter)->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_post_dec);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_post_dec);
             emitPutVirtualRegister(srcDst, X86::edx);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
@@ -2788,7 +2788,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_bitxor);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitxor);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 5;
             break;
@@ -2797,7 +2797,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_bitor);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitor);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 5;
             break;
@@ -2806,7 +2806,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_eq);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_eq);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2815,7 +2815,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_neq);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_neq);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2829,7 +2829,7 @@ void CTI::privateCompileSlowCases()
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
             emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx);
             emitPutCTIArgFromVirtualRegister(instruction[i + 4].u.operand, 8, X86::ecx);
-            emitCTICall(instruction + i, i, Machine::cti_op_instanceof);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_instanceof);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 5;
             break;
@@ -2844,7 +2844,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(notImm2, m_jit.label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::ecx, 4);
-            emitCTICall(instruction + i, i, Machine::cti_op_mod);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_mod);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2862,7 +2862,7 @@ void CTI::privateCompileSlowCases()
                 // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
-                emitCTICall(instruction + i, i, Machine::cti_op_mul);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_mul);
                 emitPutVirtualRegister(dst);
             } else if (src2Value && ((value = JSImmediate::intValue(src2Value)) > 0)) {
                 m_jit.link(iter->from, m_jit.label());
@@ -2870,7 +2870,7 @@ void CTI::privateCompileSlowCases()
                 // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
-                emitCTICall(instruction + i, i, Machine::cti_op_mul);
+                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_mul);
                 emitPutVirtualRegister(dst);
             } else
                 compileBinaryArithOpSlowCase(instruction + i, op_mul, iter, dst, src1, src2, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
@@ -2897,12 +2897,12 @@ void CTI::privateCompileSlowCases()
             // Fast check for JS function.
             m_jit.testl_i32r(JSImmediate::TagMask, X86::ecx);
             X86Assembler::JmpSrc callLinkFailNotObject = m_jit.emitUnlinkedJne();
-            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsFunctionVptr), X86::ecx);
+            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsFunctionVptr), X86::ecx);
             X86Assembler::JmpSrc callLinkFailNotJSFunction = m_jit.emitUnlinkedJne();
 
             // First, in the case of a construct, allocate the new object.
             if (opcodeID == op_construct) {
-                emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct);
+                emitCTICall(instruction, i, BytecodeInterpreter::cti_op_construct_JSConstruct);
                 emitPutVirtualRegister(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
                 emitGetVirtualRegister(callee, X86::ecx, i);
             }
@@ -2914,7 +2914,7 @@ void CTI::privateCompileSlowCases()
             m_jit.addl_i32r(registerOffset * static_cast<int>(sizeof(Register)), X86::edi);
 
             m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation =
-                emitNakedCall(i, m_machine->m_ctiVirtualCallPreLink);
+                emitNakedCall(i, m_interpreter->m_ctiVirtualCallPreLink);
 
             X86Assembler::JmpSrc storeResultForFirstRun = m_jit.emitUnlinkedJmp();
 
@@ -2930,7 +2930,7 @@ void CTI::privateCompileSlowCases()
             // Check for JSFunctions.
             m_jit.testl_i32r(JSImmediate::TagMask, X86::ecx);
             X86Assembler::JmpSrc isNotObject = m_jit.emitUnlinkedJne();
-            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsFunctionVptr), X86::ecx);
+            m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsFunctionVptr), X86::ecx);
             X86Assembler::JmpSrc isJSFunction = m_jit.emitUnlinkedJe();
 
             // This handles host functions
@@ -2938,7 +2938,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(isNotObject, notJSFunctionlabel);
             m_jit.link(callLinkFailNotObject, notJSFunctionlabel);
             m_jit.link(callLinkFailNotJSFunction, notJSFunctionlabel);
-            emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? Machine::cti_op_construct_NotJSConstruct : Machine::cti_op_call_NotJSFunction));
+            emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? BytecodeInterpreter::cti_op_construct_NotJSConstruct : BytecodeInterpreter::cti_op_call_NotJSFunction));
             X86Assembler::JmpSrc wasNotJSFunction = m_jit.emitUnlinkedJmp();
 
             // Next, handle JSFunctions...
@@ -2946,7 +2946,7 @@ void CTI::privateCompileSlowCases()
 
             // First, in the case of a construct, allocate the new object.
             if (opcodeID == op_construct) {
-                emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct);
+                emitCTICall(instruction, i, BytecodeInterpreter::cti_op_construct_JSConstruct);
                 emitPutVirtualRegister(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
                 emitGetVirtualRegister(callee, X86::ecx, i);
             }
@@ -2956,7 +2956,7 @@ void CTI::privateCompileSlowCases()
             m_jit.addl_i32r(registerOffset * static_cast<int>(sizeof(Register)), X86::edi);
             m_jit.movl_i32r(argCount, X86::edx);
 
-            emitNakedCall(i, m_machine->m_ctiVirtualCall);
+            emitNakedCall(i, m_interpreter->m_ctiVirtualCall);
 
             // Put the return value in dst. In the interpreter, op_ret does this.
             X86Assembler::JmpDst storeResult = m_jit.label();
@@ -2965,7 +2965,7 @@ void CTI::privateCompileSlowCases()
             emitPutVirtualRegister(dst);
 
 #if ENABLE(CODEBLOCK_SAMPLING)
-            m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_machine->sampler()->codeBlockSlot());
+            m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
 #endif
             ++callLinkInfoIndex;
 
@@ -2978,7 +2978,7 @@ void CTI::privateCompileSlowCases()
             m_jit.link(iter->from, m_jit.label());
 
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, Machine::cti_op_to_jsnumber);
+            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_to_jsnumber);
 
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
@@ -3003,10 +3003,10 @@ void CTI::privateCompileSlowCases()
 void CTI::privateCompile()
 {
 #if ENABLE(CODEBLOCK_SAMPLING)
-        m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_machine->sampler()->codeBlockSlot());
+        m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_interpreter->sampler()->codeBlockSlot());
 #endif
 #if ENABLE(OPCODE_SAMPLING)
-        m_jit.movl_i32m(m_machine->sampler()->encodeSample(m_codeBlock->instructions.begin()), m_machine->sampler()->sampleSlot());
+        m_jit.movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin()), m_interpreter->sampler()->sampleSlot());
 #endif
 
     // Could use a popl_m, but would need to offset the following instruction if so.
@@ -3032,7 +3032,7 @@ void CTI::privateCompile()
 
     if (m_codeBlock->codeType == FunctionCode) {
         m_jit.link(slowRegisterFileCheck, m_jit.label());
-        emitCTICall(m_codeBlock->instructions.begin(), 0, Machine::cti_register_file_check);
+        emitCTICall(m_codeBlock->instructions.begin(), 0, BytecodeInterpreter::cti_register_file_check);
         X86Assembler::JmpSrc backToBody = m_jit.emitUnlinkedJmp();
         m_jit.link(backToBody, afterRegisterFileCheck);
     }
@@ -3115,8 +3115,8 @@ void CTI::privateCompileGetByIdSelf(StructureID* structureID, size_t cachedOffse
     void* code = m_jit.copy();
     ASSERT(code);
 
-    X86Assembler::link(code, failureCases1, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, failureCases2, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
+    X86Assembler::link(code, failureCases1, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, failureCases2, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
     
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
     
@@ -3129,7 +3129,7 @@ void CTI::privateCompileGetByIdProto(StructureID* structureID, StructureID* prot
     StructureStubInfo& info = m_codeBlock->getStubInfo(returnAddress);
 
     // We don't want to repatch more than once - in future go to cti_op_put_by_id_generic.
-    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
+    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
 
     // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a StructureID that is
     // referencing the prototype object - let's speculatively load it's table nice and early!)
@@ -3199,9 +3199,9 @@ void CTI::privateCompileGetByIdProto(StructureID* structureID, StructureID* prot
     void* code = m_jit.copy();
     ASSERT(code);
 
-    X86Assembler::link(code, failureCases1, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, failureCases2, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, failureCases3, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
+    X86Assembler::link(code, failureCases1, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, failureCases2, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, failureCases3, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
 
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
 
@@ -3246,7 +3246,7 @@ void CTI::privateCompileGetByIdChain(StructureID* structureID, StructureIDChain*
     ASSERT(code);
 
     for (unsigned i = 0; i < bucketsOfFail.size(); ++i)
-        X86Assembler::link(code, bucketsOfFail[i], reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
+        X86Assembler::link(code, bucketsOfFail[i], reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
 
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
 
@@ -3269,8 +3269,8 @@ void CTI::privateCompilePutByIdReplace(StructureID* structureID, size_t cachedOf
     void* code = m_jit.copy();
     ASSERT(code);
     
-    X86Assembler::link(code, failureCases1, reinterpret_cast<void*>(Machine::cti_op_put_by_id_fail));
-    X86Assembler::link(code, failureCases2, reinterpret_cast<void*>(Machine::cti_op_put_by_id_fail));
+    X86Assembler::link(code, failureCases1, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_put_by_id_fail));
+    X86Assembler::link(code, failureCases2, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_put_by_id_fail));
 
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
     
@@ -3366,7 +3366,7 @@ void CTI::privateCompilePutByIdTransition(StructureID* oldStructureID, Structure
     ASSERT(code);
 
     if (failureCases.size())
-        X86Assembler::link(code, failureJump, reinterpret_cast<void*>(Machine::cti_op_put_by_id_fail));
+        X86Assembler::link(code, failureJump, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_put_by_id_fail));
 
     if (transitionWillNeedStorageRealloc(oldStructureID, newStructureID))
         X86Assembler::link(code, callTarget, reinterpret_cast<void*>(resizePropertyStorage));
@@ -3408,7 +3408,7 @@ void CTI::privateCompileCTIMachineTrampolines()
     // Check eax is an array
     m_jit.testl_i32r(JSImmediate::TagMask, X86::eax);
     X86Assembler::JmpSrc array_failureCases1 = m_jit.emitUnlinkedJne();
-    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), X86::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
     X86Assembler::JmpSrc array_failureCases2 = m_jit.emitUnlinkedJne();
 
     // Checks out okay! - get the length from the storage
@@ -3428,7 +3428,7 @@ void CTI::privateCompileCTIMachineTrampolines()
     // Check eax is a string
     m_jit.testl_i32r(JSImmediate::TagMask, X86::eax);
     X86Assembler::JmpSrc string_failureCases1 = m_jit.emitUnlinkedJne();
-    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsStringVptr), X86::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsStringVptr), X86::eax);
     X86Assembler::JmpSrc string_failureCases2 = m_jit.emitUnlinkedJne();
 
     // Checks out okay! - get the length from the Ustring.
@@ -3570,31 +3570,31 @@ void CTI::privateCompileCTIMachineTrampolines()
     void* code = m_jit.copy();
     ASSERT(code);
 
-    X86Assembler::link(code, array_failureCases1, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, array_failureCases2, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, array_failureCases3, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, string_failureCases1, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, string_failureCases2, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, string_failureCases3, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
-    X86Assembler::link(code, callArityCheck1, reinterpret_cast<void*>(Machine::cti_op_call_arityCheck));
-    X86Assembler::link(code, callArityCheck2, reinterpret_cast<void*>(Machine::cti_op_call_arityCheck));
-    X86Assembler::link(code, callArityCheck3, reinterpret_cast<void*>(Machine::cti_op_call_arityCheck));
-    X86Assembler::link(code, callJSFunction1, reinterpret_cast<void*>(Machine::cti_op_call_JSFunction));
-    X86Assembler::link(code, callJSFunction2, reinterpret_cast<void*>(Machine::cti_op_call_JSFunction));
-    X86Assembler::link(code, callJSFunction3, reinterpret_cast<void*>(Machine::cti_op_call_JSFunction));
-    X86Assembler::link(code, callDontLazyLinkCall, reinterpret_cast<void*>(Machine::cti_vm_dontLazyLinkCall));
-    X86Assembler::link(code, callLazyLinkCall, reinterpret_cast<void*>(Machine::cti_vm_lazyLinkCall));
+    X86Assembler::link(code, array_failureCases1, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, array_failureCases2, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, array_failureCases3, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, string_failureCases1, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, string_failureCases2, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, string_failureCases3, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    X86Assembler::link(code, callArityCheck1, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_call_arityCheck));
+    X86Assembler::link(code, callArityCheck2, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_call_arityCheck));
+    X86Assembler::link(code, callArityCheck3, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_call_arityCheck));
+    X86Assembler::link(code, callJSFunction1, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_call_JSFunction));
+    X86Assembler::link(code, callJSFunction2, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_call_JSFunction));
+    X86Assembler::link(code, callJSFunction3, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_call_JSFunction));
+    X86Assembler::link(code, callDontLazyLinkCall, reinterpret_cast<void*>(BytecodeInterpreter::cti_vm_dontLazyLinkCall));
+    X86Assembler::link(code, callLazyLinkCall, reinterpret_cast<void*>(BytecodeInterpreter::cti_vm_lazyLinkCall));
 
-    m_machine->m_ctiArrayLengthTrampoline = code;
-    m_machine->m_ctiStringLengthTrampoline = X86Assembler::getRelocatedAddress(code, stringLengthBegin);
-    m_machine->m_ctiVirtualCallPreLink = X86Assembler::getRelocatedAddress(code, virtualCallPreLinkBegin);
-    m_machine->m_ctiVirtualCallLink = X86Assembler::getRelocatedAddress(code, virtualCallLinkBegin);
-    m_machine->m_ctiVirtualCall = X86Assembler::getRelocatedAddress(code, virtualCallBegin);
+    m_interpreter->m_ctiArrayLengthTrampoline = code;
+    m_interpreter->m_ctiStringLengthTrampoline = X86Assembler::getRelocatedAddress(code, stringLengthBegin);
+    m_interpreter->m_ctiVirtualCallPreLink = X86Assembler::getRelocatedAddress(code, virtualCallPreLinkBegin);
+    m_interpreter->m_ctiVirtualCallLink = X86Assembler::getRelocatedAddress(code, virtualCallLinkBegin);
+    m_interpreter->m_ctiVirtualCall = X86Assembler::getRelocatedAddress(code, virtualCallBegin);
 }
 
-void CTI::freeCTIMachineTrampolines(Machine* machine)
+void CTI::freeCTIMachineTrampolines(BytecodeInterpreter* interpreter)
 {
-    WTF::fastFreeExecutable(machine->m_ctiArrayLengthTrampoline);
+    WTF::fastFreeExecutable(interpreter->m_ctiArrayLengthTrampoline);
 }
 
 void CTI::patchGetByIdSelf(CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
@@ -3602,8 +3602,8 @@ void CTI::patchGetByIdSelf(CodeBlock* codeBlock, StructureID* structureID, size_
     StructureStubInfo& info = codeBlock->getStubInfo(returnAddress);
 
     // We don't want to repatch more than once - in future go to cti_op_get_by_id_generic.
-    // Should probably go to Machine::cti_op_get_by_id_fail, but that doesn't do anything interesting right now.
-    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(Machine::cti_op_get_by_id_generic));
+    // Should probably go to BytecodeInterpreter::cti_op_get_by_id_fail, but that doesn't do anything interesting right now.
+    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_generic));
 
     // Repatch the offset into the propoerty map to load from, then repatch the StructureID to look for.
     X86Assembler::repatchDisplacement(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetGetByIdPropertyMapOffset, cachedOffset * sizeof(JSValue*));
@@ -3615,8 +3615,8 @@ void CTI::patchPutByIdReplace(CodeBlock* codeBlock, StructureID* structureID, si
     StructureStubInfo& info = codeBlock->getStubInfo(returnAddress);
     
     // We don't want to repatch more than once - in future go to cti_op_put_by_id_generic.
-    // Should probably go to Machine::cti_op_put_by_id_fail, but that doesn't do anything interesting right now.
-    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(Machine::cti_op_put_by_id_generic));
+    // Should probably go to BytecodeInterpreter::cti_op_put_by_id_fail, but that doesn't do anything interesting right now.
+    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_put_by_id_generic));
 
     // Repatch the offset into the propoerty map to load from, then repatch the StructureID to look for.
     X86Assembler::repatchDisplacement(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetPutByIdPropertyMapOffset, cachedOffset * sizeof(JSValue*));
@@ -3628,12 +3628,12 @@ void CTI::privateCompilePatchGetArrayLength(void* returnAddress)
     StructureStubInfo& info = m_codeBlock->getStubInfo(returnAddress);
 
     // We don't want to repatch more than once - in future go to cti_op_put_by_id_generic.
-    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(Machine::cti_op_get_by_id_fail));
+    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
 
     // Check eax is an array
     m_jit.testl_i32r(JSImmediate::TagMask, X86::eax);
     X86Assembler::JmpSrc failureCases1 = m_jit.emitUnlinkedJne();
-    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsArrayVptr), X86::eax);
+    m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
     X86Assembler::JmpSrc failureCases2 = m_jit.emitUnlinkedJne();
 
     // Checks out okay! - get the length from the storage
@@ -3686,7 +3686,7 @@ void CTI::emitPutVariableObjectRegister(X86Assembler::RegisterID src, X86Assembl
 
 #if ENABLE(WREC)
 
-void* CTI::compileRegExp(Machine* machine, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase, bool multiline)
+void* CTI::compileRegExp(BytecodeInterpreter* interpreter, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase, bool multiline)
 {
     // TODO: better error messages
     if (pattern.size() > MaxPatternSize) {
@@ -3694,7 +3694,7 @@ void* CTI::compileRegExp(Machine* machine, const UString& pattern, unsigned* num
         return 0;
     }
 
-    X86Assembler jit(machine->jitCodeBuffer());
+    X86Assembler jit(interpreter->jitCodeBuffer());
     WRECParser parser(pattern, ignoreCase, multiline, jit);
     
     jit.emitConvertToFastCall();
index 38fdef9..113d421 100644 (file)
@@ -96,7 +96,7 @@ namespace JSC {
 
     class CodeBlock;
     class JSPropertyNameIterator;
-    class Machine;
+    class BytecodeInterpreter;
     class Register;
     class RegisterFile;
     class ScopeChainNode;
@@ -290,7 +290,7 @@ namespace JSC {
         }
 
 #if ENABLE(WREC)
-        static void* compileRegExp(Machine*, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
+        static void* compileRegExp(BytecodeInterpreter*, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
 #endif
 
         static void compileGetByIdSelf(JSGlobalData* globalData, CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
@@ -328,7 +328,7 @@ namespace JSC {
             CTI cti(globalData);
             cti.privateCompileCTIMachineTrampolines();
         }
-        static void freeCTIMachineTrampolines(Machine*);
+        static void freeCTIMachineTrampolines(BytecodeInterpreter*);
 
         static void patchGetByIdSelf(CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress);
         static void patchPutByIdReplace(CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress);
@@ -437,7 +437,7 @@ namespace JSC {
         void killLastResultRegister();
 
         X86Assembler m_jit;
-        Machine* m_machine;
+        BytecodeInterpreter* m_interpreter;
         JSGlobalData* m_globalData;
         CodeBlock* m_codeBlock;
 
index e96d869..886a12d 100644 (file)
@@ -181,44 +181,44 @@ void CodeBlock::printStructureID(const char* name, const Instruction* vPC, int o
 
 void CodeBlock::printStructureIDs(const Instruction* vPC) const
 {
-    Machine* machine = globalData->machine;
+    BytecodeInterpreter* interpreter = globalData->interpreter;
     unsigned instructionOffset = vPC - instructions.begin();
 
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id)) {
         printStructureID("get_by_id", vPC, 4);
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {
         printStructureID("get_by_id_self", vPC, 4);
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto)) {
         printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_proto", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str());
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_transition)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {
         printf("  [%4d] %s: %s, %s, %s\n", instructionOffset, "put_by_id_new", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[6].u.structureIDChain).UTF8String().c_str());
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain)) {
         printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_chain", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureIDChain).UTF8String().c_str());
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id)) {
         printStructureID("put_by_id", vPC, 4);
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_replace)) {
         printStructureID("put_by_id_replace", vPC, 4);
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_resolve_global)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_resolve_global)) {
         printStructureID("resolve_global", vPC, 4);
         return;
     }
 
     // These instructions doesn't ref StructureIDs.
-    ASSERT(vPC[0].u.opcode == machine->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_call) || vPC[0].u.opcode == machine->getOpcode(op_call_eval) || vPC[0].u.opcode == machine->getOpcode(op_construct));
+    ASSERT(vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_call) || vPC[0].u.opcode == interpreter->getOpcode(op_call_eval) || vPC[0].u.opcode == interpreter->getOpcode(op_construct));
 }
 
 void CodeBlock::dump(ExecState* exec) const
@@ -228,7 +228,7 @@ void CodeBlock::dump(ExecState* exec) const
 
     size_t instructionCount = 0;
     for (Vector<Instruction>::const_iterator it = begin; it != end; ++it)
-        if (exec->machine()->isOpcode(it->u.opcode))
+        if (exec->interpreter()->isOpcode(it->u.opcode))
             ++instructionCount;
 
     printf("%lu instructions; %lu bytes at %p; %d parameter(s); %d callee register(s)\n\n",
@@ -359,7 +359,7 @@ void CodeBlock::dump(ExecState* exec) const
 void CodeBlock::dump(ExecState* exec, const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator& it) const
 {
     int location = it - begin;
-    switch (exec->machine()->getOpcodeID(it->u.opcode)) {
+    switch (exec->interpreter()->getOpcodeID(it->u.opcode)) {
         case op_enter: {
             printf("[%4d] enter\n", location);
             break;
@@ -988,73 +988,73 @@ void CodeBlock::unlinkCallers()
 
 void CodeBlock::derefStructureIDs(Instruction* vPC) const
 {
-    Machine* machine = globalData->machine;
+    BytecodeInterpreter* interpreter = globalData->interpreter;
 
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {
         vPC[4].u.structureID->deref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto)) {
         vPC[4].u.structureID->deref();
         vPC[5].u.structureID->deref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain)) {
         vPC[4].u.structureID->deref();
         vPC[5].u.structureIDChain->deref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_transition)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {
         vPC[4].u.structureID->deref();
         vPC[5].u.structureID->deref();
         vPC[6].u.structureIDChain->deref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_replace)) {
         vPC[4].u.structureID->deref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_resolve_global)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_resolve_global)) {
         if(vPC[4].u.structureID)
             vPC[4].u.structureID->deref();
         return;
     }
     
     // These instructions don't ref their StructureIDs.
-    ASSERT(vPC[0].u.opcode == machine->getOpcode(op_get_by_id) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id) || vPC[0].u.opcode == machine->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_get_array_length) || vPC[0].u.opcode == machine->getOpcode(op_get_string_length));
+    ASSERT(vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_get_array_length) || vPC[0].u.opcode == interpreter->getOpcode(op_get_string_length));
 }
 
 void CodeBlock::refStructureIDs(Instruction* vPC) const
 {
-    Machine* machine = globalData->machine;
+    BytecodeInterpreter* interpreter = globalData->interpreter;
 
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_self)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {
         vPC[4].u.structureID->ref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_proto)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto)) {
         vPC[4].u.structureID->ref();
         vPC[5].u.structureID->ref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_get_by_id_chain)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain)) {
         vPC[4].u.structureID->ref();
         vPC[5].u.structureIDChain->ref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_transition)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {
         vPC[4].u.structureID->ref();
         vPC[5].u.structureID->ref();
         vPC[6].u.structureIDChain->ref();
         return;
     }
-    if (vPC[0].u.opcode == machine->getOpcode(op_put_by_id_replace)) {
+    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_replace)) {
         vPC[4].u.structureID->ref();
         return;
     }
     
     // These instructions don't ref their StructureIDs.
-    ASSERT(vPC[0].u.opcode == machine->getOpcode(op_get_by_id) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id) || vPC[0].u.opcode == machine->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == machine->getOpcode(op_put_by_id_generic));
+    ASSERT(vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_generic));
 }
 
 void CodeBlock::mark()
index 8e18d5f..208625e 100644 (file)
@@ -208,9 +208,9 @@ JSNotAnObjectErrorStub* createNotAnObjectErrorStub(ExecState* exec, bool isNull)
 
 JSObject* createNotAnObjectError(ExecState* exec, JSNotAnObjectErrorStub* error, const Instruction* vPC, CodeBlock* codeBlock)
 {
-    if (vPC[8].u.opcode == exec->machine()->getOpcode(op_instanceof))
+    if (vPC[8].u.opcode == exec->interpreter()->getOpcode(op_instanceof))
         return createInvalidParamError(exec, "instanceof", error->isNull() ? jsNull() : jsUndefined(), vPC, codeBlock);
-    if (vPC[8].u.opcode == exec->machine()->getOpcode(op_construct))
+    if (vPC[8].u.opcode == exec->interpreter()->getOpcode(op_construct))
         return createNotAConstructorError(exec, error->isNull() ? jsNull() : jsUndefined(), vPC, codeBlock);
 
     int startOffset = 0;
index 4730889..51a32b0 100644 (file)
@@ -177,8 +177,8 @@ static inline bool jsLess(CallFrame* callFrame, JSValue* v1, JSValue* v2)
     if (fastIsNumber(v1, n1) && fastIsNumber(v2, n2))
         return n1 < n2;
 
-    Machine* machine = callFrame->machine();
-    if (machine->isJSString(v1) && machine->isJSString(v2))
+    BytecodeInterpreter* interpreter = callFrame->interpreter();
+    if (interpreter->isJSString(v1) && interpreter->isJSString(v2))
         return asString(v1)->value() < asString(v2)->value();
 
     JSValue* p1;
@@ -202,8 +202,8 @@ static inline bool jsLessEq(CallFrame* callFrame, JSValue* v1, JSValue* v2)
     if (fastIsNumber(v1, n1) && fastIsNumber(v2, n2))
         return n1 <= n2;
 
-    Machine* machine = callFrame->machine();
-    if (machine->isJSString(v1) && machine->isJSString(v2))
+    BytecodeInterpreter* interpreter = callFrame->interpreter();
+    if (interpreter->isJSString(v1) && interpreter->isJSString(v2))
         return !(asString(v2)->value() < asString(v1)->value());
 
     JSValue* p1;
@@ -323,7 +323,7 @@ static bool jsIsFunctionType(JSValue* v)
     return false;
 }
 
-NEVER_INLINE bool Machine::resolve(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool BytecodeInterpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
@@ -351,7 +351,7 @@ NEVER_INLINE bool Machine::resolve(CallFrame* callFrame, Instruction* vPC, JSVal
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool BytecodeInterpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     CodeBlock* codeBlock = callFrame->codeBlock();
 
@@ -384,7 +384,7 @@ NEVER_INLINE bool Machine::resolveSkip(CallFrame* callFrame, Instruction* vPC, J
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool BytecodeInterpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     int dst = (vPC + 1)->u.operand;
     JSGlobalObject* globalObject = static_cast<JSGlobalObject*>((vPC + 2)->u.jsCell);
@@ -447,14 +447,14 @@ static ALWAYS_INLINE JSValue* inlineResolveBase(CallFrame* callFrame, Identifier
     return noValue();
 }
 
-NEVER_INLINE void Machine::resolveBase(CallFrame* callFrame, Instruction* vPC)
+NEVER_INLINE void BytecodeInterpreter::resolveBase(CallFrame* callFrame, Instruction* vPC)
 {
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
     callFrame[dst] = inlineResolveBase(callFrame, callFrame->codeBlock()->identifiers[property], callFrame->scopeChain());
 }
 
-NEVER_INLINE bool Machine::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool BytecodeInterpreter::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     int baseDst = (vPC + 1)->u.operand;
     int propDst = (vPC + 2)->u.operand;
@@ -490,7 +490,7 @@ NEVER_INLINE bool Machine::resolveBaseAndProperty(CallFrame* callFrame, Instruct
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveBaseAndFunc(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool BytecodeInterpreter::resolveBaseAndFunc(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     int baseDst = (vPC + 1)->u.operand;
     int funcDst = (vPC + 2)->u.operand;
@@ -535,7 +535,7 @@ NEVER_INLINE bool Machine::resolveBaseAndFunc(CallFrame* callFrame, Instruction*
     return false;
 }
 
-ALWAYS_INLINE CallFrame* Machine::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argc)
+ALWAYS_INLINE CallFrame* BytecodeInterpreter::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argc)
 {
     Register* r = callFrame->registers();
     Register* newEnd = r + registerOffset + newCodeBlock->numCalleeRegisters;
@@ -580,7 +580,7 @@ static NEVER_INLINE bool isNotObject(CallFrame* callFrame, bool forInstanceOf, C
     return true;
 }
 
-NEVER_INLINE JSValue* Machine::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValue*& exceptionValue)
+NEVER_INLINE JSValue* BytecodeInterpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValue*& exceptionValue)
 {
     if (argc < 2)
         return jsUndefined();
@@ -598,12 +598,12 @@ NEVER_INLINE JSValue* Machine::callEval(CallFrame* callFrame, RegisterFile* regi
 
     JSValue* result = jsUndefined();
     if (evalNode)
-        result = callFrame->globalData().machine->execute(evalNode.get(), callFrame, callFrame->thisValue()->toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue);
+        result = callFrame->globalData().interpreter->execute(evalNode.get(), callFrame, callFrame->thisValue()->toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue);
 
     return result;
 }
 
-Machine::Machine()
+BytecodeInterpreter::BytecodeInterpreter()
     : m_sampler(0)
 #if ENABLE(CTI)
     , m_ctiArrayLengthTrampoline(0)
@@ -641,7 +641,7 @@ Machine::Machine()
     fastFree(storage);
 }
 
-void Machine::initialize(JSGlobalData* globalData)
+void BytecodeInterpreter::initialize(JSGlobalData* globalData)
 {
 #if ENABLE(CTI)
     CTI::compileCTIMachineTrampolines(globalData);
@@ -650,7 +650,7 @@ void Machine::initialize(JSGlobalData* globalData)
 #endif
 }
 
-Machine::~Machine()
+BytecodeInterpreter::~BytecodeInterpreter()
 {
 #if ENABLE(CTI)
     CTI::freeCTIMachineTrampolines(this);
@@ -659,13 +659,13 @@ Machine::~Machine()
 
 #ifndef NDEBUG
 
-void Machine::dumpCallFrame(CallFrame* callFrame)
+void BytecodeInterpreter::dumpCallFrame(CallFrame* callFrame)
 {
     callFrame->codeBlock()->dump(callFrame);
     dumpRegisters(callFrame);
 }
 
-void Machine::dumpRegisters(CallFrame* callFrame)
+void BytecodeInterpreter::dumpRegisters(CallFrame* callFrame)
 {
     printf("Register frame: \n\n");
     printf("----------------------------------------------------\n");
@@ -673,7 +673,7 @@ void Machine::dumpRegisters(CallFrame* callFrame)
     printf("----------------------------------------------------\n");
 
     CodeBlock* codeBlock = callFrame->codeBlock();
-    RegisterFile* registerFile = &callFrame->scopeChain()->globalObject()->globalData()->machine->registerFile();
+    RegisterFile* registerFile = &callFrame->scopeChain()->globalObject()->globalData()->interpreter->registerFile();
     const Register* it;
     const Register* end;
 
@@ -743,7 +743,7 @@ void Machine::dumpRegisters(CallFrame* callFrame)
 
 #endif
 
-bool Machine::isOpcode(Opcode opcode)
+bool BytecodeInterpreter::isOpcode(Opcode opcode)
 {
 #if HAVE(COMPUTED_GOTO)
     return opcode != HashTraits<Opcode>::emptyValue()
@@ -754,7 +754,7 @@ bool Machine::isOpcode(Opcode opcode)
 #endif
 }
 
-NEVER_INLINE bool Machine::unwindCallFrame(CallFrame*& callFrame, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock)
+NEVER_INLINE bool BytecodeInterpreter::unwindCallFrame(CallFrame*& callFrame, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock)
 {
     CodeBlock* oldCodeBlock = codeBlock;
     ScopeChainNode* scopeChain = callFrame->scopeChain();
@@ -797,7 +797,7 @@ NEVER_INLINE bool Machine::unwindCallFrame(CallFrame*& callFrame, JSValue* excep
     return true;
 }
 
-NEVER_INLINE Instruction* Machine::throwException(CallFrame*& callFrame, JSValue*& exceptionValue, const Instruction* vPC, bool explicitThrow)
+NEVER_INLINE Instruction* BytecodeInterpreter::throwException(CallFrame*& callFrame, JSValue*& exceptionValue, const Instruction* vPC, bool explicitThrow)
 {
     // Set up the exception object
     
@@ -896,7 +896,7 @@ private:
     JSGlobalObject* m_savedDynamicGlobalObject;
 };
 
-JSValue* Machine::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
+JSValue* BytecodeInterpreter::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
 {
     ASSERT(!scopeChain->globalData->exception);
 
@@ -957,7 +957,7 @@ JSValue* Machine::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeC
     return result;
 }
 
-JSValue* Machine::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue** exception)
+JSValue* BytecodeInterpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue** exception)
 {
     ASSERT(!scopeChain->globalData->exception);
 
@@ -1019,12 +1019,12 @@ JSValue* Machine::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFra
     return result;
 }
 
-JSValue* Machine::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception)
+JSValue* BytecodeInterpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception)
 {
     return execute(evalNode, callFrame, thisObj, m_registerFile.size() + evalNode->byteCode(scopeChain).numParameters + RegisterFile::CallFrameHeaderSize, scopeChain, exception);
 }
 
-JSValue* Machine::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValue** exception)
+JSValue* BytecodeInterpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValue** exception)
 {
     ASSERT(!scopeChain->globalData->exception);
 
@@ -1111,7 +1111,7 @@ JSValue* Machine::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* th
     return result;
 }
 
-NEVER_INLINE void Machine::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine)
+NEVER_INLINE void BytecodeInterpreter::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine)
 {
     Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();
     if (!debugger)
@@ -1139,7 +1139,7 @@ NEVER_INLINE void Machine::debug(CallFrame* callFrame, DebugHookID debugHookID,
     }
 }
 
-void Machine::resetTimeoutCheck()
+void BytecodeInterpreter::resetTimeoutCheck()
 {
     m_ticksUntilNextTimeoutCheck = initialTickCountThreshold;
     m_timeAtLastCheckTimeout = 0;
@@ -1188,7 +1188,7 @@ static inline unsigned getCPUTime()
 
 // We have to return a JSValue here, gcc seems to produce worse code if 
 // we attempt to return a bool
-ALWAYS_INLINE JSValue* Machine::checkTimeout(JSGlobalObject* globalObject)
+ALWAYS_INLINE JSValue* BytecodeInterpreter::checkTimeout(JSGlobalObject* globalObject)
 {
     unsigned currentTime = getCPUTime();
     
@@ -1224,7 +1224,7 @@ ALWAYS_INLINE JSValue* Machine::checkTimeout(JSGlobalObject* globalObject)
     return noValue();
 }
 
-NEVER_INLINE ScopeChainNode* Machine::createExceptionScope(CallFrame* callFrame, const Instruction* vPC)
+NEVER_INLINE ScopeChainNode* BytecodeInterpreter::createExceptionScope(CallFrame* callFrame, const Instruction* vPC)
 {
     int dst = (++vPC)->u.operand;
     CodeBlock* codeBlock = callFrame->codeBlock();
@@ -1246,7 +1246,7 @@ static StructureIDChain* cachePrototypeChain(CallFrame* callFrame, StructureID*
     return structureID->cachedPrototypeChain();
 }
 
-NEVER_INLINE void Machine::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
 {
     // Recursive invocation may already have specialized this instruction.
     if (vPC[0].u.opcode != getOpcode(op_put_by_id))
@@ -1316,14 +1316,14 @@ NEVER_INLINE void Machine::tryCachePutByID(CallFrame* callFrame, CodeBlock* code
     codeBlock->refStructureIDs(vPC);
 }
 
-NEVER_INLINE void Machine::uncachePutByID(CodeBlock* codeBlock, Instruction* vPC)
+NEVER_INLINE void BytecodeInterpreter::uncachePutByID(CodeBlock* codeBlock, Instruction* vPC)
 {
     codeBlock->derefStructureIDs(vPC);
     vPC[0] = getOpcode(op_put_by_id);
     vPC[4] = 0;
 }
 
-NEVER_INLINE void Machine::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void BytecodeInterpreter::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
 {
     // Recursive invocation may already have specialized this instruction.
     if (vPC[0].u.opcode != getOpcode(op_get_by_id))
@@ -1441,14 +1441,14 @@ NEVER_INLINE void Machine::tryCacheGetByID(CallFrame* callFrame, CodeBlock* code
     codeBlock->refStructureIDs(vPC);
 }
 
-NEVER_INLINE void Machine::uncacheGetByID(CodeBlock* codeBlock, Instruction* vPC)
+NEVER_INLINE void BytecodeInterpreter::uncacheGetByID(CodeBlock* codeBlock, Instruction* vPC)
 {
     codeBlock->derefStructureIDs(vPC);
     vPC[0] = getOpcode(op_get_by_id);
     vPC[4] = 0;
 }
 
-JSValue* Machine::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValue** exception)
+JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValue** exception)
 {
     // One-time initialization of our address tables. We have to put this code
     // here because our labels are only in scope inside this function.
@@ -1502,7 +1502,7 @@ JSValue* Machine::privateExecute(ExecutionFlag flag, RegisterFile* registerFile,
     
 #if ENABLE(OPCODE_SAMPLING)
     #define SAMPLE(codeBlock, vPC) m_sampler->sample(codeBlock, vPC)
-    #define CTI_SAMPLER ARG_globalData->machine->sampler()
+    #define CTI_SAMPLER ARG_globalData->interpreter->sampler()
 #else
     #define SAMPLE(codeBlock, vPC)
     #define CTI_SAMPLER 0
@@ -3985,7 +3985,7 @@ JSValue* Machine::privateExecute(ExecutionFlag flag, RegisterFile* registerFile,
     #undef CHECK_FOR_TIMEOUT
 }
 
-JSValue* Machine::retrieveArguments(CallFrame* callFrame, JSFunction* function) const
+JSValue* BytecodeInterpreter::retrieveArguments(CallFrame* callFrame, JSFunction* function) const
 {
     CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
     if (!functionCallFrame)
@@ -4009,7 +4009,7 @@ JSValue* Machine::retrieveArguments(CallFrame* callFrame, JSFunction* function)
     return arguments;
 }
 
-JSValue* Machine::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const
+JSValue* BytecodeInterpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const
 {
     CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
     if (!functionCallFrame)
@@ -4026,7 +4026,7 @@ JSValue* Machine::retrieveCaller(CallFrame* callFrame, InternalFunction* functio
     return caller;
 }
 
-void Machine::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const
+void BytecodeInterpreter::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const
 {
     function = noValue();
     lineNumber = -1;
@@ -4047,7 +4047,7 @@ void Machine::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t
     function = callerFrame->callee();
 }
 
-CallFrame* Machine::findFunctionCallFrame(CallFrame* callFrame, InternalFunction* function)
+CallFrame* BytecodeInterpreter::findFunctionCallFrame(CallFrame* callFrame, InternalFunction* function)
 {
     for (CallFrame* candidate = callFrame; candidate; candidate = candidate->callerFrame()->removeHostCallFrameFlag()) {
         if (candidate->callee() == function)
@@ -4058,7 +4058,7 @@ CallFrame* Machine::findFunctionCallFrame(CallFrame* callFrame, InternalFunction
 
 #if ENABLE(CTI)
 
-NEVER_INLINE void Machine::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void BytecodeInterpreter::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const PutPropertySlot& slot)
 {
     // The interpreter checks for recursion here; I do not believe this can occur in CTI.
 
@@ -4127,7 +4127,7 @@ NEVER_INLINE void Machine::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* c
 #endif
 }
 
-NEVER_INLINE void Machine::tryCTICacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void BytecodeInterpreter::tryCTICacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* 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.
@@ -4344,7 +4344,7 @@ static NEVER_INLINE void throwStackOverflowError(CallFrame* callFrame, JSGlobalD
         } \
     } while (0)
 
-JSObject* Machine::cti_op_convert_this(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_convert_this(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4356,7 +4356,7 @@ JSObject* Machine::cti_op_convert_this(CTI_ARGS)
     return result;
 }
 
-void Machine::cti_op_end(CTI_ARGS)
+void BytecodeInterpreter::cti_op_end(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4365,7 +4365,7 @@ void Machine::cti_op_end(CTI_ARGS)
     scopeChain->deref();
 }
 
-JSValue* Machine::cti_op_add(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_add(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4410,7 +4410,7 @@ JSValue* Machine::cti_op_add(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_pre_inc(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_pre_inc(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4422,17 +4422,17 @@ JSValue* Machine::cti_op_pre_inc(CTI_ARGS)
     return result;
 }
 
-void Machine::cti_timeout_check(CTI_ARGS)
+void BytecodeInterpreter::cti_timeout_check(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
-    if (ARG_globalData->machine->checkTimeout(ARG_callFrame->dynamicGlobalObject())) {
+    if (ARG_globalData->interpreter->checkTimeout(ARG_callFrame->dynamicGlobalObject())) {
         ARG_globalData->exception = createInterruptedExecutionException(ARG_globalData);
         VM_THROW_EXCEPTION_AT_END();
     }
 }
 
-void Machine::cti_register_file_check(CTI_ARGS)
+void BytecodeInterpreter::cti_register_file_check(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4446,7 +4446,7 @@ void Machine::cti_register_file_check(CTI_ARGS)
     throwStackOverflowError(oldCallFrame, ARG_globalData, oldCallFrame->returnPC(), CTI_RETURN_ADDRESS);
 }
 
-int Machine::cti_op_loop_if_less(CTI_ARGS)
+int BytecodeInterpreter::cti_op_loop_if_less(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4459,7 +4459,7 @@ int Machine::cti_op_loop_if_less(CTI_ARGS)
     return result;
 }
 
-int Machine::cti_op_loop_if_lesseq(CTI_ARGS)
+int BytecodeInterpreter::cti_op_loop_if_lesseq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4472,14 +4472,14 @@ int Machine::cti_op_loop_if_lesseq(CTI_ARGS)
     return result;
 }
 
-JSObject* Machine::cti_op_new_object(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_new_object(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return constructEmptyObject(ARG_callFrame);
 }
 
-void Machine::cti_op_put_by_id(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_by_id(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4494,17 +4494,17 @@ void Machine::cti_op_put_by_id(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-void Machine::cti_op_put_by_id_second(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_by_id_second(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     PutPropertySlot slot;
     ARG_src1->put(ARG_callFrame, *ARG_id2, ARG_src3, slot);
-    ARG_globalData->machine->tryCTICachePutByID(ARG_callFrame, ARG_callFrame->codeBlock(), CTI_RETURN_ADDRESS, ARG_src1, slot);
+    ARG_globalData->interpreter->tryCTICachePutByID(ARG_callFrame, ARG_callFrame->codeBlock(), CTI_RETURN_ADDRESS, ARG_src1, slot);
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-void Machine::cti_op_put_by_id_generic(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_by_id_generic(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4513,7 +4513,7 @@ void Machine::cti_op_put_by_id_generic(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-void Machine::cti_op_put_by_id_fail(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_by_id_fail(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4529,7 +4529,7 @@ void Machine::cti_op_put_by_id_fail(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-JSValue* Machine::cti_op_get_by_id(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_get_by_id(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4546,7 +4546,7 @@ JSValue* Machine::cti_op_get_by_id(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_get_by_id_second(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_get_by_id_second(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4557,13 +4557,13 @@ JSValue* Machine::cti_op_get_by_id_second(CTI_ARGS)
     PropertySlot slot(baseValue);
     JSValue* result = baseValue->get(callFrame, ident, slot);
 
-    ARG_globalData->machine->tryCTICacheGetByID(callFrame, callFrame->codeBlock(), CTI_RETURN_ADDRESS, baseValue, ident, slot);
+    ARG_globalData->interpreter->tryCTICacheGetByID(callFrame, callFrame->codeBlock(), CTI_RETURN_ADDRESS, baseValue, ident, slot);
 
     VM_CHECK_EXCEPTION_AT_END();
     return result;
 }
 
-JSValue* Machine::cti_op_get_by_id_generic(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_get_by_id_generic(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4578,7 +4578,7 @@ JSValue* Machine::cti_op_get_by_id_generic(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_get_by_id_fail(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_get_by_id_fail(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4596,7 +4596,7 @@ JSValue* Machine::cti_op_get_by_id_fail(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_instanceof(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_instanceof(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4636,7 +4636,7 @@ JSValue* Machine::cti_op_instanceof(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_del_by_id(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_del_by_id(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4650,7 +4650,7 @@ JSValue* Machine::cti_op_del_by_id(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_mul(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_mul(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4668,14 +4668,14 @@ JSValue* Machine::cti_op_mul(CTI_ARGS)
     return result;
 }
 
-JSObject* Machine::cti_op_new_func(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_new_func(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return ARG_func1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
-void* Machine::cti_op_call_JSFunction(CTI_ARGS)
+void* BytecodeInterpreter::cti_op_call_JSFunction(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4693,7 +4693,7 @@ void* Machine::cti_op_call_JSFunction(CTI_ARGS)
     return newCodeBlock;
 }
 
-VoidPtrPair Machine::cti_op_call_arityCheck(CTI_ARGS)
+VoidPtrPair BytecodeInterpreter::cti_op_call_arityCheck(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4740,7 +4740,7 @@ VoidPtrPair Machine::cti_op_call_arityCheck(CTI_ARGS)
     return pair.i;
 }
 
-void* Machine::cti_vm_dontLazyLinkCall(CTI_ARGS)
+void* BytecodeInterpreter::cti_vm_dontLazyLinkCall(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4749,12 +4749,12 @@ void* Machine::cti_vm_dontLazyLinkCall(CTI_ARGS)
     if (!codeBlock->ctiCode)
         CTI::compile(ARG_globalData, codeBlock);
 
-    ctiRepatchCallByReturnAddress(ARG_returnAddress2, ARG_globalData->machine->m_ctiVirtualCallLink);
+    ctiRepatchCallByReturnAddress(ARG_returnAddress2, ARG_globalData->interpreter->m_ctiVirtualCallLink);
 
     return codeBlock->ctiCode;
 }
 
-void* Machine::cti_vm_lazyLinkCall(CTI_ARGS)
+void* BytecodeInterpreter::cti_vm_lazyLinkCall(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4769,7 +4769,7 @@ void* Machine::cti_vm_lazyLinkCall(CTI_ARGS)
     return codeBlock->ctiCode;
 }
 
-JSObject* Machine::cti_op_push_activation(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_push_activation(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4778,7 +4778,7 @@ JSObject* Machine::cti_op_push_activation(CTI_ARGS)
     return activation;
 }
 
-JSValue* Machine::cti_op_call_NotJSFunction(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_call_NotJSFunction(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4824,7 +4824,7 @@ JSValue* Machine::cti_op_call_NotJSFunction(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-void Machine::cti_op_create_arguments(CTI_ARGS)
+void BytecodeInterpreter::cti_op_create_arguments(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4833,7 +4833,7 @@ void Machine::cti_op_create_arguments(CTI_ARGS)
     ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
 }
 
-void Machine::cti_op_create_arguments_no_params(CTI_ARGS)
+void BytecodeInterpreter::cti_op_create_arguments_no_params(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4842,7 +4842,7 @@ void Machine::cti_op_create_arguments_no_params(CTI_ARGS)
     ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
 }
 
-void Machine::cti_op_tear_off_activation(CTI_ARGS)
+void BytecodeInterpreter::cti_op_tear_off_activation(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4850,7 +4850,7 @@ void Machine::cti_op_tear_off_activation(CTI_ARGS)
     asActivation(ARG_src1)->copyRegisters(ARG_callFrame->optionalCalleeArguments());
 }
 
-void Machine::cti_op_tear_off_arguments(CTI_ARGS)
+void BytecodeInterpreter::cti_op_tear_off_arguments(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4858,7 +4858,7 @@ void Machine::cti_op_tear_off_arguments(CTI_ARGS)
     ARG_callFrame->optionalCalleeArguments()->copyRegisters();
 }
 
-void Machine::cti_op_profile_will_call(CTI_ARGS)
+void BytecodeInterpreter::cti_op_profile_will_call(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4866,7 +4866,7 @@ void Machine::cti_op_profile_will_call(CTI_ARGS)
     (*ARG_profilerReference)->willExecute(ARG_callFrame, ARG_src1);
 }
 
-void Machine::cti_op_profile_did_call(CTI_ARGS)
+void BytecodeInterpreter::cti_op_profile_did_call(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4874,7 +4874,7 @@ void Machine::cti_op_profile_did_call(CTI_ARGS)
     (*ARG_profilerReference)->didExecute(ARG_callFrame, ARG_src1);
 }
 
-void Machine::cti_op_ret_scopeChain(CTI_ARGS)
+void BytecodeInterpreter::cti_op_ret_scopeChain(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4882,7 +4882,7 @@ void Machine::cti_op_ret_scopeChain(CTI_ARGS)
     ARG_callFrame->scopeChain()->deref();
 }
 
-JSObject* Machine::cti_op_new_array(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_new_array(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4890,7 +4890,7 @@ JSObject* Machine::cti_op_new_array(CTI_ARGS)
     return constructArray(ARG_callFrame, argList);
 }
 
-JSValue* Machine::cti_op_resolve(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_resolve(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4919,7 +4919,7 @@ JSValue* Machine::cti_op_resolve(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSObject* Machine::cti_op_construct_JSConstruct(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_construct_JSConstruct(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4936,7 +4936,7 @@ JSObject* Machine::cti_op_construct_JSConstruct(CTI_ARGS)
     return new (ARG_globalData) JSObject(structure);
 }
 
-JSValue* Machine::cti_op_construct_NotJSConstruct(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_construct_NotJSConstruct(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4968,12 +4968,12 @@ JSValue* Machine::cti_op_construct_NotJSConstruct(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* Machine::cti_op_get_by_val(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_get_by_val(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     CallFrame* callFrame = ARG_callFrame;
-    Machine* machine = ARG_globalData->machine;
+    BytecodeInterpreter* interpreter = ARG_globalData->interpreter;
 
     JSValue* baseValue = ARG_src1;
     JSValue* subscript = ARG_src2;
@@ -4983,13 +4983,13 @@ JSValue* Machine::cti_op_get_by_val(CTI_ARGS)
 
     bool isUInt32 = JSImmediate::getUInt32(subscript, i);
     if (LIKELY(isUInt32)) {
-        if (machine->isJSArray(baseValue)) {
+        if (interpreter->isJSArray(baseValue)) {
             JSArray* jsArray = asArray(baseValue);
             if (jsArray->canGetIndex(i))
                 result = jsArray->getIndex(i);
             else
                 result = jsArray->JSArray::get(callFrame, i);
-        } else if (machine->isJSString(baseValue) && asString(baseValue)->canGetIndex(i))
+        } else if (interpreter->isJSString(baseValue) && asString(baseValue)->canGetIndex(i))
             result = asString(baseValue)->getIndex(ARG_globalData, i);
         else
             result = baseValue->get(callFrame, i);
@@ -5002,7 +5002,7 @@ JSValue* Machine::cti_op_get_by_val(CTI_ARGS)
     return result;
 }
 
-VoidPtrPair Machine::cti_op_resolve_func(CTI_ARGS)
+VoidPtrPair BytecodeInterpreter::cti_op_resolve_func(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5046,7 +5046,7 @@ VoidPtrPair Machine::cti_op_resolve_func(CTI_ARGS)
     VM_THROW_EXCEPTION_2();
 }
 
-JSValue* Machine::cti_op_sub(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_sub(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5064,12 +5064,12 @@ JSValue* Machine::cti_op_sub(CTI_ARGS)
     return result;
 }
 
-void Machine::cti_op_put_by_val(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_by_val(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     CallFrame* callFrame = ARG_callFrame;
-    Machine* machine = ARG_globalData->machine;
+    BytecodeInterpreter* interpreter = ARG_globalData->interpreter;
 
     JSValue* baseValue = ARG_src1;
     JSValue* subscript = ARG_src2;
@@ -5079,7 +5079,7 @@ void Machine::cti_op_put_by_val(CTI_ARGS)
 
     bool isUInt32 = JSImmediate::getUInt32(subscript, i);
     if (LIKELY(isUInt32)) {
-        if (machine->isJSArray(baseValue)) {
+        if (interpreter->isJSArray(baseValue)) {
             JSArray* jsArray = asArray(baseValue);
             if (jsArray->canSetIndex(i))
                 jsArray->setIndex(i, value);
@@ -5098,7 +5098,7 @@ void Machine::cti_op_put_by_val(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-void Machine::cti_op_put_by_val_array(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_by_val_array(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5108,7 +5108,7 @@ void Machine::cti_op_put_by_val_array(CTI_ARGS)
     int i = ARG_int2;
     JSValue* value = ARG_src3;
 
-    ASSERT(ARG_globalData->machine->isJSArray(baseValue));
+    ASSERT(ARG_globalData->interpreter->isJSArray(baseValue));
 
     if (LIKELY(i >= 0))
         asArray(baseValue)->JSArray::put(callFrame, i, value);
@@ -5124,7 +5124,7 @@ void Machine::cti_op_put_by_val_array(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-JSValue* Machine::cti_op_lesseq(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_lesseq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5134,7 +5134,7 @@ JSValue* Machine::cti_op_lesseq(CTI_ARGS)
     return result;
 }
 
-int Machine::cti_op_loop_if_true(CTI_ARGS)
+int BytecodeInterpreter::cti_op_loop_if_true(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5147,7 +5147,7 @@ int Machine::cti_op_loop_if_true(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_negate(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_negate(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5163,14 +5163,14 @@ JSValue* Machine::cti_op_negate(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_resolve_base(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_resolve_base(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return inlineResolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain());
 }
 
-JSValue* Machine::cti_op_resolve_skip(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_resolve_skip(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5204,7 +5204,7 @@ JSValue* Machine::cti_op_resolve_skip(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* Machine::cti_op_resolve_global(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_resolve_global(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5234,7 +5234,7 @@ JSValue* Machine::cti_op_resolve_global(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* Machine::cti_op_div(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_div(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5252,7 +5252,7 @@ JSValue* Machine::cti_op_div(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_pre_dec(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_pre_dec(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5264,7 +5264,7 @@ JSValue* Machine::cti_op_pre_dec(CTI_ARGS)
     return result;
 }
 
-int Machine::cti_op_jless(CTI_ARGS)
+int BytecodeInterpreter::cti_op_jless(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5277,7 +5277,7 @@ int Machine::cti_op_jless(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_not(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_not(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5290,7 +5290,7 @@ JSValue* Machine::cti_op_not(CTI_ARGS)
     return result;
 }
 
-int SFX_CALL Machine::cti_op_jtrue(CTI_ARGS)
+int SFX_CALL BytecodeInterpreter::cti_op_jtrue(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5303,7 +5303,7 @@ int SFX_CALL Machine::cti_op_jtrue(CTI_ARGS)
     return result;
 }
 
-VoidPtrPair Machine::cti_op_post_inc(CTI_ARGS)
+VoidPtrPair BytecodeInterpreter::cti_op_post_inc(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5318,7 +5318,7 @@ VoidPtrPair Machine::cti_op_post_inc(CTI_ARGS)
     return pair.i;
 }
 
-JSValue* Machine::cti_op_eq(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_eq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5333,7 +5333,7 @@ JSValue* Machine::cti_op_eq(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_lshift(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_lshift(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5353,7 +5353,7 @@ JSValue* Machine::cti_op_lshift(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_bitand(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_bitand(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5371,7 +5371,7 @@ JSValue* Machine::cti_op_bitand(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_rshift(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_rshift(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5391,7 +5391,7 @@ JSValue* Machine::cti_op_rshift(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_bitnot(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_bitnot(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5407,7 +5407,7 @@ JSValue* Machine::cti_op_bitnot(CTI_ARGS)
     return result;
 }
 
-VoidPtrPair Machine::cti_op_resolve_with_base(CTI_ARGS)
+VoidPtrPair BytecodeInterpreter::cti_op_resolve_with_base(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5443,14 +5443,14 @@ VoidPtrPair Machine::cti_op_resolve_with_base(CTI_ARGS)
     VM_THROW_EXCEPTION_2();
 }
 
-JSObject* Machine::cti_op_new_func_exp(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_new_func_exp(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return ARG_funcexp1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
-JSValue* Machine::cti_op_mod(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_mod(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5464,7 +5464,7 @@ JSValue* Machine::cti_op_mod(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_less(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_less(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5474,7 +5474,7 @@ JSValue* Machine::cti_op_less(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_neq(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_neq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5489,7 +5489,7 @@ JSValue* Machine::cti_op_neq(CTI_ARGS)
     return result;
 }
 
-VoidPtrPair Machine::cti_op_post_dec(CTI_ARGS)
+VoidPtrPair BytecodeInterpreter::cti_op_post_dec(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5504,7 +5504,7 @@ VoidPtrPair Machine::cti_op_post_dec(CTI_ARGS)
     return pair.i;
 }
 
-JSValue* Machine::cti_op_urshift(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_urshift(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5522,7 +5522,7 @@ JSValue* Machine::cti_op_urshift(CTI_ARGS)
     }
 }
 
-JSValue* Machine::cti_op_bitxor(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_bitxor(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5536,14 +5536,14 @@ JSValue* Machine::cti_op_bitxor(CTI_ARGS)
     return result;
 }
 
-JSObject* Machine::cti_op_new_regexp(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_new_regexp(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return new (ARG_globalData) RegExpObject(ARG_callFrame->lexicalGlobalObject()->regExpStructure(), ARG_regexp1);
 }
 
-JSValue* Machine::cti_op_bitor(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_bitor(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5557,14 +5557,14 @@ JSValue* Machine::cti_op_bitor(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_call_eval(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_call_eval(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     CallFrame* callFrame = ARG_callFrame;
     RegisterFile* registerFile = ARG_registerFile;
 
-    Machine* machine = ARG_globalData->machine;
+    BytecodeInterpreter* interpreter = ARG_globalData->interpreter;
     
     JSValue* funcVal = ARG_src1;
     int registerOffset = ARG_int2;
@@ -5577,7 +5577,7 @@ JSValue* Machine::cti_op_call_eval(CTI_ARGS)
 
     if (thisValue == globalObject && funcVal == globalObject->evalFunction()) {
         JSValue* exceptionValue = noValue();
-        JSValue* result = machine->callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
+        JSValue* result = interpreter->callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
         if (UNLIKELY(exceptionValue != noValue())) {
             ARG_globalData->exception = exceptionValue;
             VM_THROW_EXCEPTION_AT_END();
@@ -5588,7 +5588,7 @@ JSValue* Machine::cti_op_call_eval(CTI_ARGS)
     return JSImmediate::impossibleValue();
 }
 
-JSValue* Machine::cti_op_throw(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_throw(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5601,7 +5601,7 @@ JSValue* Machine::cti_op_throw(CTI_ARGS)
     JSValue* exceptionValue = ARG_src1;
     ASSERT(exceptionValue);
 
-    Instruction* handlerVPC = ARG_globalData->machine->throwException(callFrame, exceptionValue, codeBlock->instructions.begin() + vPCIndex, true);
+    Instruction* handlerVPC = ARG_globalData->interpreter->throwException(callFrame, exceptionValue, codeBlock->instructions.begin() + vPCIndex, true);
 
     if (!handlerVPC) {
         *ARG_exception = exceptionValue;
@@ -5615,14 +5615,14 @@ JSValue* Machine::cti_op_throw(CTI_ARGS)
     return exceptionValue;
 }
 
-JSPropertyNameIterator* Machine::cti_op_get_pnames(CTI_ARGS)
+JSPropertyNameIterator* BytecodeInterpreter::cti_op_get_pnames(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return JSPropertyNameIterator::create(ARG_callFrame, ARG_src1);
 }
 
-JSValue* Machine::cti_op_next_pname(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_next_pname(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5633,7 +5633,7 @@ JSValue* Machine::cti_op_next_pname(CTI_ARGS)
     return temp;
 }
 
-void Machine::cti_op_push_scope(CTI_ARGS)
+void BytecodeInterpreter::cti_op_push_scope(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5642,21 +5642,21 @@ void Machine::cti_op_push_scope(CTI_ARGS)
     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->push(o));
 }
 
-void Machine::cti_op_pop_scope(CTI_ARGS)
+void BytecodeInterpreter::cti_op_pop_scope(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->pop());
 }
 
-JSValue* Machine::cti_op_typeof(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_typeof(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsTypeStringForValue(ARG_callFrame, ARG_src1);
 }
 
-JSValue* Machine::cti_op_is_undefined(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_is_undefined(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5664,42 +5664,42 @@ JSValue* Machine::cti_op_is_undefined(CTI_ARGS)
     return jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
 }
 
-JSValue* Machine::cti_op_is_boolean(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_is_boolean(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(ARG_src1->isBoolean());
 }
 
-JSValue* Machine::cti_op_is_number(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_is_number(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(ARG_src1->isNumber());
 }
 
-JSValue* Machine::cti_op_is_string(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_is_string(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
-    return jsBoolean(ARG_globalData->machine->isJSString(ARG_src1));
+    return jsBoolean(ARG_globalData->interpreter->isJSString(ARG_src1));
 }
 
-JSValue* Machine::cti_op_is_object(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_is_object(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(jsIsObjectType(ARG_src1));
 }
 
-JSValue* Machine::cti_op_is_function(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_is_function(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(jsIsFunctionType(ARG_src1));
 }
 
-JSValue* Machine::cti_op_stricteq(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_stricteq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5713,7 +5713,7 @@ JSValue* Machine::cti_op_stricteq(CTI_ARGS)
     return jsBoolean(strictEqualSlowCaseInline(src1, src2));
 }
 
-JSValue* Machine::cti_op_nstricteq(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_nstricteq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5727,7 +5727,7 @@ JSValue* Machine::cti_op_nstricteq(CTI_ARGS)
     return jsBoolean(!strictEqualSlowCaseInline(src1, src2));
 }
 
-JSValue* Machine::cti_op_to_jsnumber(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_to_jsnumber(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5739,7 +5739,7 @@ JSValue* Machine::cti_op_to_jsnumber(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_in(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_in(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5767,7 +5767,7 @@ JSValue* Machine::cti_op_in(CTI_ARGS)
     return jsBoolean(baseObj->hasProperty(callFrame, property));
 }
 
-JSObject* Machine::cti_op_push_new_scope(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_push_new_scope(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5778,7 +5778,7 @@ JSObject* Machine::cti_op_push_new_scope(CTI_ARGS)
     return scope;
 }
 
-void Machine::cti_op_jmp_scopes(CTI_ARGS)
+void BytecodeInterpreter::cti_op_jmp_scopes(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5791,7 +5791,7 @@ void Machine::cti_op_jmp_scopes(CTI_ARGS)
     callFrame->setScopeChain(tmp);
 }
 
-void Machine::cti_op_put_by_index(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_by_index(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5801,7 +5801,7 @@ void Machine::cti_op_put_by_index(CTI_ARGS)
     ARG_src1->put(callFrame, property, ARG_src3);
 }
 
-void* Machine::cti_op_switch_imm(CTI_ARGS)
+void* BytecodeInterpreter::cti_op_switch_imm(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5818,7 +5818,7 @@ void* Machine::cti_op_switch_imm(CTI_ARGS)
     return codeBlock->immediateSwitchJumpTables[tableIndex].ctiDefault;
 }
 
-void* Machine::cti_op_switch_char(CTI_ARGS)
+void* BytecodeInterpreter::cti_op_switch_char(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5838,7 +5838,7 @@ void* Machine::cti_op_switch_char(CTI_ARGS)
     return result;
 }
 
-void* Machine::cti_op_switch_string(CTI_ARGS)
+void* BytecodeInterpreter::cti_op_switch_string(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5857,7 +5857,7 @@ void* Machine::cti_op_switch_string(CTI_ARGS)
     return result;
 }
 
-JSValue* Machine::cti_op_del_by_val(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_op_del_by_val(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5882,7 +5882,7 @@ JSValue* Machine::cti_op_del_by_val(CTI_ARGS)
     return result;
 }
 
-void Machine::cti_op_put_getter(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_getter(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5895,7 +5895,7 @@ void Machine::cti_op_put_getter(CTI_ARGS)
     baseObj->defineGetter(callFrame, ident, asObject(ARG_src3));
 }
 
-void Machine::cti_op_put_setter(CTI_ARGS)
+void BytecodeInterpreter::cti_op_put_setter(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5908,7 +5908,7 @@ void Machine::cti_op_put_setter(CTI_ARGS)
     baseObj->defineSetter(callFrame, ident, asObject(ARG_src3));
 }
 
-JSObject* Machine::cti_op_new_error(CTI_ARGS)
+JSObject* BytecodeInterpreter::cti_op_new_error(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5921,7 +5921,7 @@ JSObject* Machine::cti_op_new_error(CTI_ARGS)
     return Error::create(callFrame, static_cast<ErrorType>(type), message->toString(callFrame), lineNumber, codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->sourceURL());
 }
 
-void Machine::cti_op_debug(CTI_ARGS)
+void BytecodeInterpreter::cti_op_debug(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5931,10 +5931,10 @@ void Machine::cti_op_debug(CTI_ARGS)
     int firstLine = ARG_int2;
     int lastLine = ARG_int3;
 
-    ARG_globalData->machine->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
+    ARG_globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
 }
 
-JSValue* Machine::cti_vm_throw(CTI_ARGS)
+JSValue* BytecodeInterpreter::cti_vm_throw(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5949,7 +5949,7 @@ JSValue* Machine::cti_vm_throw(CTI_ARGS)
     ASSERT(exceptionValue);
     globalData->exception = noValue();
 
-    Instruction* handlerVPC = globalData->machine->throwException(callFrame, exceptionValue, codeBlock->instructions.begin() + vPCIndex, false);
+    Instruction* handlerVPC = globalData->interpreter->throwException(callFrame, exceptionValue, codeBlock->instructions.begin() + vPCIndex, false);
 
     if (!handlerVPC) {
         *ARG_exception = exceptionValue;
index 44e244f..1df0fde 100644 (file)
@@ -101,11 +101,11 @@ namespace JSC {
 
     enum { MaxReentryDepth = 128 };
 
-    class Machine {
+    class BytecodeInterpreter {
         friend class CTI;
     public:
-        Machine();
-        ~Machine();
+        BytecodeInterpreter();
+        ~BytecodeInterpreter();
 
         void initialize(JSGlobalData*);
         
index c1fee3a..7f5a7f1 100644 (file)
@@ -59,9 +59,9 @@ namespace JSC {
         
     private:
         friend class ExecState;
-        friend class Machine;
+        friend class BytecodeInterpreter;
 
-        // Only CallFrame and Machine should use these functions.
+        // Only CallFrame and BytecodeInterpreter should use these functions.
 
         Register(intptr_t);
 
@@ -170,7 +170,7 @@ namespace JSC {
         getJSValue()->mark();
     }
     
-    // Machine functions
+    // BytecodeInterpreter functions
 
     ALWAYS_INLINE Register::Register(Arguments* arguments)
     {
index 3de3ff5..ec39a9c 100644 (file)
@@ -94,7 +94,7 @@ void SamplingTool::run()
             continue;
 
         if (!sample.inHostFunction()) {
-            unsigned opcodeID = m_machine->getOpcodeID(sample.vPC()[0].u.opcode);
+            unsigned opcodeID = m_interpreter->getOpcodeID(sample.vPC()[0].u.opcode);
 
             ++m_opcodeSampleCount;
             ++m_opcodeSamples[opcodeID];
index db9fb00..882375c 100644 (file)
@@ -40,7 +40,7 @@ namespace JSC {
 
     class CodeBlock;
     class ExecState;
-    class Machine;
+    class BytecodeInterpreter;
     class ScopeNode;
     struct Instruction;
 
@@ -125,8 +125,8 @@ namespace JSC {
         };
 #endif        
 
-        SamplingTool(Machine* machine)
-            : m_machine(machine)
+        SamplingTool(BytecodeInterpreter* interpreter)
+            : m_interpreter(interpreter)
             , m_running(false)
             , m_codeBlock(0)
             , m_sample(0)
@@ -188,7 +188,7 @@ namespace JSC {
         static void* threadStartFunc(void*);
         void run();
         
-        Machine* m_machine;
+        BytecodeInterpreter* m_interpreter;
         
         // Sampling thread state.
         bool m_running;
index 4ef2759..b62c4c8 100644 (file)
@@ -141,7 +141,7 @@ void CodeGenerator::generate()
 #endif
 
     m_scopeNode->children().shrinkCapacity(0);
-    if (m_codeType != EvalCode) { // eval code needs to hang on to its declaration stacks to keep declaration info alive until Machine::execute time.
+    if (m_codeType != EvalCode) { // eval code needs to hang on to its declaration stacks to keep declaration info alive until BytecodeInterpreter::execute time.
         m_scopeNode->varStack().shrinkCapacity(0);
         m_scopeNode->functionStack().shrinkCapacity(0);
     }
@@ -236,13 +236,13 @@ CodeGenerator::CodeGenerator(ProgramNode* programNode, const Debugger* debugger,
     emitOpcode(op_enter);
     codeBlock->globalData = m_globalData;
 
-    // FIXME: Move code that modifies the global object to Machine::execute.
+    // FIXME: Move code that modifies the global object to BytecodeInterpreter::execute.
     
     m_codeBlock->numParameters = 1; // Allocate space for "this"
 
     JSGlobalObject* globalObject = scopeChain.globalObject();
     ExecState* exec = globalObject->globalExec();
-    RegisterFile* registerFile = &exec->globalData().machine->registerFile();
+    RegisterFile* registerFile = &exec->globalData().interpreter->registerFile();
     
     // Shift register indexes in generated code to elide registers allocated by intermediate stack frames.
     m_globalVarStorageOffset = -RegisterFile::CallFrameHeaderSize - m_codeBlock->numParameters - registerFile->size();
@@ -518,7 +518,7 @@ PassRefPtr<LabelID> CodeGenerator::emitLabel(LabelID* l0)
 
 void CodeGenerator::emitOpcode(OpcodeID opcodeID)
 {
-    instructions().append(globalData()->machine->getOpcode(opcodeID));
+    instructions().append(globalData()->interpreter->getOpcode(opcodeID));
     m_lastOpcodeID = opcodeID;
 }
 
index ae62cd3..296cc75 100644 (file)
@@ -76,7 +76,7 @@ JSValue* DebuggerCallFrame::evaluate(const UString& script, JSValue*& exception)
     if (!evalNode)
         return Error::create(m_callFrame, SyntaxError, errMsg, errLine, source.provider()->asID(), source.provider()->url());
 
-    return m_callFrame->scopeChain()->globalData->machine->execute(evalNode.get(), m_callFrame, thisObject(), m_callFrame->scopeChain(), &exception);
+    return m_callFrame->scopeChain()->globalData->interpreter->execute(evalNode.get(), m_callFrame, thisObject(), m_callFrame->scopeChain(), &exception);
 }
 
 } // namespace JSC
index f998445..39a0c4c 100644 (file)
@@ -218,7 +218,7 @@ JSValue* functionRun(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
 
     stopWatch.start();
-    Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
+    evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
     stopWatch.stop();
 
     return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS());
@@ -232,7 +232,7 @@ JSValue* functionLoad(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
         return throwError(exec, GeneralError, "Could not open file.");
 
     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
-    Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
+    evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
 
     return jsUndefined();
 }
@@ -321,8 +321,8 @@ static bool runWithScripts(GlobalObject* globalObject, const Vector<UString>& fi
         CodeGenerator::setDumpsGeneratedCode(true);
 
 #if ENABLE(OPCODE_SAMPLING)
-    Machine* machine = globalObject->globalData()->machine;
-    machine->setSampler(new SamplingTool(machine));
+    BytecodeInterpreter* interpreter = globalObject->globalData()->interpreter;
+    interpreter->setSampler(new SamplingTool(machine));
 #endif
 
     bool success = true;
@@ -333,9 +333,9 @@ static bool runWithScripts(GlobalObject* globalObject, const Vector<UString>& fi
             return false; // fail early so we can catch missing files
 
 #if ENABLE(OPCODE_SAMPLING)
-        machine->sampler()->start();
+        interpreter->sampler()->start();
 #endif
-        Completion completion = Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
+        Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
         success = success && completion.complType() != Throw;
         if (dump) {
             if (completion.complType() == Throw)
@@ -347,13 +347,13 @@ static bool runWithScripts(GlobalObject* globalObject, const Vector<UString>& fi
         globalObject->globalExec()->clearException();
 
 #if ENABLE(OPCODE_SAMPLING)
-        machine->sampler()->stop();
+        interpreter->sampler()->stop();
 #endif
     }
 
 #if ENABLE(OPCODE_SAMPLING)
-    machine->sampler()->dump(globalObject->globalExec());
-    delete machine->sampler();
+    interpreter->sampler()->dump(globalObject->globalExec());
+    delete interpreter->sampler();
 #endif
     return success;
 }
@@ -367,7 +367,7 @@ static void runInteractive(GlobalObject* globalObject)
             break;
         if (line[0])
             add_history(line);
-        Completion completion = Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line, interpreterName));
+        Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line, interpreterName));
         free(line);
 #else
         puts(interactivePrompt);
@@ -380,7 +380,7 @@ static void runInteractive(GlobalObject* globalObject)
             line.append(c);
         }
         line.append('\0');
-        Completion completion = Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line.data(), interpreterName));
+        Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line.data(), interpreterName));
 #endif
         if (completion.complType() == Throw)
             printf("Exception: %s\n", completion.value()->toString(globalObject->globalExec()).ascii());
index bea539b..fdd08a3 100644 (file)
@@ -2390,7 +2390,7 @@ ScopeNode::ScopeNode(JSGlobalData* globalData, const SourceCode& source, SourceE
     if (funcStack)
         m_functionStack = *funcStack;
 #if ENABLE(OPCODE_SAMPLING)
-    globalData->machine->sampler()->notifyOfScope(this);
+    globalData->interpreter->sampler()->notifyOfScope(this);
 #endif
 }
 
index 1506788..6805828 100644 (file)
@@ -61,7 +61,7 @@ void ProfileGenerator::addParentForConsoleStart(ExecState* exec)
     UString sourceURL;
     JSValue* function;
 
-    exec->machine()->retrieveLastCaller(exec, lineNumber, sourceID, sourceURL, function);
+    exec->interpreter()->retrieveLastCaller(exec, lineNumber, sourceID, sourceURL, function);
     m_currentNode = ProfileNode::create(Profiler::createCallIdentifier(&exec->globalData(), function ? function->toThisObject(exec) : 0, sourceURL, lineNumber), m_head.get(), m_head.get());
     m_head->insertNode(m_currentNode.get());
 }
index ecf9c19..65c3cb8 100644 (file)
@@ -291,7 +291,7 @@ JSValue* arrayProtoFuncConcat(ExecState* exec, JSObject*, JSValue* thisValue, co
 
 JSValue* arrayProtoFuncPop(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&)
 {
-    if (exec->machine()->isJSArray(thisValue))
+    if (exec->interpreter()->isJSArray(thisValue))
         return asArray(thisValue)->pop();
 
     JSObject* thisObj = thisValue->toThisObject(exec);
@@ -310,7 +310,7 @@ JSValue* arrayProtoFuncPop(ExecState* exec, JSObject*, JSValue* thisValue, const
 
 JSValue* arrayProtoFuncPush(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
 {
-    if (exec->machine()->isJSArray(thisValue) && args.size() == 1) {
+    if (exec->interpreter()->isJSArray(thisValue) && args.size() == 1) {
         JSArray* array = asArray(thisValue);
         array->push(exec, args.begin()->jsValue(exec));
         return jsNumber(exec, array->length());
index a4c9860..c8b632e 100644 (file)
@@ -981,7 +981,7 @@ bool Heap::collect()
         ArgList::markLists(*m_markListSet);
     if (m_globalData->exception && !m_globalData->exception->marked())
         m_globalData->exception->mark();
-    m_globalData->machine->registerFile().markCallFrames(this);
+    m_globalData->interpreter->registerFile().markCallFrames(this);
     m_globalData->smallStrings.mark();
 
     JSGlobalObject* globalObject = m_globalData->head;
index f1891bb..43e83c8 100644 (file)
@@ -82,7 +82,7 @@ namespace JSC  {
 
         const CommonIdentifiers& propertyNames() const { return *globalData().propertyNames; }
         const ArgList& emptyList() const { return *globalData().emptyList; }
-        Machine* machine() { return globalData().machine; }
+        BytecodeInterpreter* interpreter() { return globalData().interpreter; }
         Heap* heap() { return &globalData().heap; }
 
         static const HashTable* arrayTable(CallFrame* callFrame) { return callFrame->globalData().arrayTable; }
@@ -97,7 +97,7 @@ namespace JSC  {
         friend class Arguments;
         friend class JSActivation;
         friend class JSGlobalObject;
-        friend class Machine;
+        friend class BytecodeInterpreter;
 
         static CallFrame* create(Register* callFrameBase) { return static_cast<CallFrame*>(callFrameBase); }
         Register* registers() { return this; }
index 8c3a260..9d2f20b 100644 (file)
@@ -100,7 +100,7 @@ JSValue* functionProtoFuncApply(ExecState* exec, JSObject*, JSValue* thisValue,
             return throwError(exec, TypeError);
         if (asObject(argArray)->classInfo() == &Arguments::info)
             asArguments(argArray)->fillArgList(exec, applyArgs);
-        else if (exec->machine()->isJSArray(argArray))
+        else if (exec->interpreter()->isJSArray(argArray))
             asArray(argArray)->fillArgList(exec, applyArgs);
         else if (asObject(argArray)->inherits(&JSArray::info)) {
             unsigned length = asArray(argArray)->get(exec, exec->propertyNames().length)->toUInt32(exec);
index 9f958dc..a0428ed 100644 (file)
@@ -38,7 +38,7 @@
 
 namespace JSC {
 
-Completion Interpreter::checkSyntax(ExecState* exec, const SourceCode& source)
+Completion checkSyntax(ExecState* exec, const SourceCode& source)
 {
     JSLock lock(exec);
 
@@ -51,7 +51,7 @@ Completion Interpreter::checkSyntax(ExecState* exec, const SourceCode& source)
     return Completion(Normal);
 }
 
-Completion Interpreter::evaluate(ExecState* exec, ScopeChain& scopeChain, const SourceCode& source, JSValue* thisValue)
+Completion evaluate(ExecState* exec, ScopeChain& scopeChain, const SourceCode& source, JSValue* thisValue)
 {
     JSLock lock(exec);
     
@@ -65,7 +65,7 @@ Completion Interpreter::evaluate(ExecState* exec, ScopeChain& scopeChain, const
     JSObject* thisObj = (!thisValue || thisValue->isUndefinedOrNull()) ? exec->dynamicGlobalObject() : thisValue->toObject(exec);
 
     JSValue* exception = noValue();
-    JSValue* result = exec->machine()->execute(programNode.get(), exec, scopeChain.node(), thisObj, &exception);
+    JSValue* result = exec->interpreter()->execute(programNode.get(), exec, scopeChain.node(), thisObj, &exception);
 
     if (exception) {
         if (exception->isObject() && asObject(exception)->isWatchdogException())
index 0366063..29a1144 100644 (file)
 
 namespace JSC {
 
-  class Completion;
-  class ExecState;
-  class ScopeChain;
-  class SourceCode;
-  
-  class Interpreter {
-  public:
-    /**
-     * Parses the supplied ECMAScript code and checks for syntax errors.
-     *
-     * @param code The code to check
-     * @return A normal completion if there were no syntax errors in the code, 
-     * otherwise a throw completion with the syntax error as its value.
-     */
-    static Completion checkSyntax(ExecState*, const SourceCode&);
+    class Completion;
+    class ExecState;
+    class ScopeChain;
+    class SourceCode;
 
-    /**
-     * Evaluates the supplied ECMAScript code.
-     *
-     * Since this method returns a Completion, you should check the type of
-     * completion to detect an error or before attempting to access the returned
-     * value. For example, if an error occurs during script execution and is not
-     * caught by the script, the completion type will be Throw.
-     *
-     * If the supplied code is invalid, a SyntaxError will be thrown.
-     *
-     * @param code The code to evaluate
-     * @param thisValue The value to pass in as the "this" value for the script
-     * execution. This should either be jsNull() or an Object.
-     * @return A completion object representing the result of the execution.
-     */
-    static Completion evaluate(ExecState*, ScopeChain&, const SourceCode&, JSValue* thisValue = noValue());
-  };
+    Completion checkSyntax(ExecState*, const SourceCode&);
+    Completion evaluate(ExecState*, ScopeChain&, const SourceCode&, JSValue* thisValue = noValue());
 
 } // namespace JSC
 
index de971fc..932aac2 100644 (file)
@@ -38,7 +38,7 @@ namespace JSC {
         friend class JSPropertyNameIterator;
         friend class JSString;
         friend class JSValue;
-        friend class Machine;
+        friend class BytecodeInterpreter;
 
     private:
         explicit JSCell(StructureID*);
index 2973d2d..8a9a5bf 100644 (file)
@@ -79,19 +79,19 @@ CallType JSFunction::getCallData(CallData& callData)
 
 JSValue* JSFunction::call(ExecState* exec, JSValue* thisValue, const ArgList& args)
 {
-    return exec->machine()->execute(m_body.get(), exec, this, thisValue->toThisObject(exec), args, m_scopeChain.node(), exec->exceptionSlot());
+    return exec->interpreter()->execute(m_body.get(), exec, this, thisValue->toThisObject(exec), args, m_scopeChain.node(), exec->exceptionSlot());
 }
 
 JSValue* JSFunction::argumentsGetter(ExecState* exec, const Identifier&, const PropertySlot& slot)
 {
     JSFunction* thisObj = asFunction(slot.slotBase());
-    return exec->machine()->retrieveArguments(exec, thisObj);
+    return exec->interpreter()->retrieveArguments(exec, thisObj);
 }
 
 JSValue* JSFunction::callerGetter(ExecState* exec, const Identifier&, const PropertySlot& slot)
 {
     JSFunction* thisObj = asFunction(slot.slotBase());
-    return exec->machine()->retrieveCaller(exec, thisObj);
+    return exec->interpreter()->retrieveCaller(exec, thisObj);
 }
 
 JSValue* JSFunction::lengthGetter(ExecState* exec, const Identifier&, const PropertySlot& slot)
@@ -191,7 +191,7 @@ JSObject* JSFunction::construct(ExecState* exec, const ArgList& args)
         structure = exec->lexicalGlobalObject()->emptyObjectStructure();
     JSObject* thisObj = new (exec) JSObject(structure);
 
-    JSValue* result = exec->machine()->execute(m_body.get(), exec, this, thisObj, args, m_scopeChain.node(), exec->exceptionSlot());
+    JSValue* result = exec->interpreter()->execute(m_body.get(), exec, this, thisObj, args, m_scopeChain.node(), exec->exceptionSlot());
     if (exec->hadException() || !result->isObject())
         return thisObj;
     return asObject(result);
index 944c3fb..1c6b2ae 100644 (file)
@@ -39,7 +39,7 @@ namespace JSC {
 
     class JSFunction : public InternalFunction {
         friend class CTI;
-        friend class Machine;
+        friend class BytecodeInterpreter;
 
         typedef InternalFunction Base;
         JSFunction(PassRefPtr<JSC::StructureID> st) : InternalFunction(st), m_scopeChain(NoScopeChain()) {}
index 6ce50f6..ec00edd 100644 (file)
@@ -64,7 +64,7 @@ extern const HashTable regExpConstructorTable;
 extern const HashTable stringTable;
 
 JSGlobalData::JSGlobalData(bool isShared)
-    : machine(new Machine)
+    : interpreter(new BytecodeInterpreter)
     , exception(noValue())
     , arrayTable(new HashTable(JSC::arrayTable))
     , dateTable(new HashTable(JSC::dateTable))
@@ -96,17 +96,17 @@ JSGlobalData::JSGlobalData(bool isShared)
 #if PLATFORM(MAC)
     startProfilerServerIfNeeded();
 #endif
-    machine->initialize(this);
+    interpreter->initialize(this);
 }
 
 JSGlobalData::~JSGlobalData()
 {
     // By the time this is destroyed, heap.destroy() must already have been called.
 
-    delete machine;
+    delete interpreter;
 #ifndef NDEBUG
     // Zeroing out to make the behavior more predictable when someone attempts to use a deleted instance.
-    machine = 0;
+    interpreter = 0;
 #endif
 
     arrayTable->deleteTable();
index 92bd090..d2f7e46 100644 (file)
@@ -47,7 +47,7 @@ namespace JSC {
     class JSGlobalObject;
     class JSObject;
     class Lexer;
-    class Machine;
+    class BytecodeInterpreter;
     class Parser;
     class ParserRefCounted;
     class StructureID;
@@ -63,7 +63,7 @@ namespace JSC {
         static PassRefPtr<JSGlobalData> createLeaked();
         ~JSGlobalData();
 
-        Machine* machine;
+        BytecodeInterpreter* interpreter;
 
         JSValue* exception;
 #if ENABLE(CTI)
index 89c32fd..af0ee25 100644 (file)
@@ -114,7 +114,7 @@ JSGlobalObject::~JSGlobalObject()
     for (HashSet<ProgramCodeBlock*>::const_iterator it = codeBlocks().begin(); it != end; ++it)
         (*it)->globalObject = 0;
         
-    RegisterFile& registerFile = globalData()->machine->registerFile();
+    RegisterFile& registerFile = globalData()->interpreter->registerFile();
     if (registerFile.globalObject() == this) {
         registerFile.setGlobalObject(0);
         registerFile.setNumGlobals(0);
@@ -345,17 +345,17 @@ void JSGlobalObject::resetPrototype(JSValue* prototype)
 
 void JSGlobalObject::setTimeoutTime(unsigned timeoutTime)
 {
-    globalData()->machine->setTimeoutTime(timeoutTime);
+    globalData()->interpreter->setTimeoutTime(timeoutTime);
 }
 
 void JSGlobalObject::startTimeoutCheck()
 {
-    globalData()->machine->startTimeoutCheck();
+    globalData()->interpreter->startTimeoutCheck();
 }
 
 void JSGlobalObject::stopTimeoutCheck()
 {
-    globalData()->machine->stopTimeoutCheck();
+    globalData()->interpreter->stopTimeoutCheck();
 }
 
 void JSGlobalObject::mark()
@@ -366,7 +366,7 @@ void JSGlobalObject::mark()
     for (HashSet<ProgramCodeBlock*>::const_iterator it = codeBlocks().begin(); it != end; ++it)
         (*it)->mark();
 
-    RegisterFile& registerFile = globalData()->machine->registerFile();
+    RegisterFile& registerFile = globalData()->interpreter->registerFile();
     if (registerFile.globalObject() == this)
         registerFile.markGlobals(&globalData()->heap);
 
index 067019d..cd79f10 100644 (file)
@@ -291,7 +291,7 @@ JSValue* globalFuncEval(ExecState* exec, JSObject* function, JSValue* thisValue,
     if (!evalNode)
         return throwError(exec, SyntaxError, errMsg, errLine, source.provider()->asID(), NULL);
 
-    return exec->machine()->execute(evalNode.get(), exec, thisObject, globalObject->globalScopeChain().node(), exec->exceptionSlot());
+    return exec->interpreter()->execute(evalNode.get(), exec, thisObject, globalObject->globalScopeChain().node(), exec->exceptionSlot());
 }
 
 JSValue* globalFuncParseInt(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
index b053258..45cbe2b 100644 (file)
@@ -60,7 +60,7 @@ namespace JSC {
 
     class JSString : public JSCell {
         friend class CTI;
-        friend class Machine;
+        friend class BytecodeInterpreter;
 
     public:
         JSString(JSGlobalData* globalData, const UString& value)
index 974a1fc..ae232a2 100644 (file)
@@ -41,7 +41,7 @@ inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern)
     , m_numSubpatterns(0)
 {
 #if ENABLE(WREC)
-    m_wrecFunction = CTI::compileRegExp(globalData->machine, pattern, &m_numSubpatterns, &m_constructionError);
+    m_wrecFunction = CTI::compileRegExp(globalData->interpreter, pattern, &m_numSubpatterns, &m_constructionError);
     if (m_wrecFunction)
         return;
     // Fall through to non-WREC case.
@@ -84,7 +84,7 @@ inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern, const US
     }
 
 #if ENABLE(WREC)
-    m_wrecFunction = CTI::compileRegExp(globalData->machine, pattern, &m_numSubpatterns, &m_constructionError, (m_flagBits & IgnoreCase), (m_flagBits & Multiline));
+    m_wrecFunction = CTI::compileRegExp(globalData->interpreter, pattern, &m_numSubpatterns, &m_constructionError, (m_flagBits & IgnoreCase), (m_flagBits & Multiline));
     if (m_wrecFunction)
         return;
     // Fall through to non-WREC case.
index 8be9e52..7c89ec0 100644 (file)
@@ -1,3 +1,13 @@
+2008-11-15  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig.
+        
+        Updated for JavaScriptCore renames.
+
+        * JSRun.cpp:
+        (JSRun::Evaluate):
+        (JSRun::CheckSyntax):
+
 2008-11-05  Cameron Zwarich  <zwarich@apple.com>
 
         Not reviewed.
index 58cd761..821cdef 100644 (file)
@@ -69,10 +69,10 @@ JSGlobalObject* JSRun::GlobalObject() const
 
 Completion JSRun::Evaluate()
 {
-    return Interpreter::evaluate(fGlobalObject->globalExec(), fGlobalObject->globalScopeChain(), makeSource(fSource));
+    return JSC::evaluate(fGlobalObject->globalExec(), fGlobalObject->globalScopeChain(), makeSource(fSource));
 }
 
 bool JSRun::CheckSyntax()
 {
-    return Interpreter::checkSyntax(fGlobalObject->globalExec(), makeSource(fSource)).complType() != Throw;
+    return JSC::checkSyntax(fGlobalObject->globalExec(), makeSource(fSource)).complType() != Throw;
 }
index c1655ca..4ef93a6 100644 (file)
@@ -1,3 +1,27 @@
+2008-11-15  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig.
+        
+        Updated for JavaScriptCore renames.
+
+        * bindings/js/JSNodeCustom.cpp:
+        (WebCore::JSNode::mark):
+        * bindings/js/JSXMLHttpRequestCustom.cpp:
+        (WebCore::JSXMLHttpRequest::send):
+        * bindings/js/ScriptController.cpp:
+        (WebCore::ScriptController::evaluate):
+        * bindings/js/WorkerScriptController.cpp:
+        (WebCore::WorkerScriptController::evaluate):
+        * bindings/objc/WebScriptObject.mm:
+        (-[WebScriptObject evaluateWebScript:]):
+        * bridge/NP_jsobject.cpp:
+        (_NPN_Evaluate):
+        * bridge/jni/jni_jsobject.mm:
+        (JavaJSObject::eval):
+        * page/Console.cpp:
+        (WebCore::retrieveLastCaller):
+        (WebCore::Console::trace):
+
 2008-11-14  Greg Bolsinga  <bolsinga@apple.com>
 
         Reviewed by Darin Adler.
index c40777b..5a8acea 100644 (file)
@@ -112,7 +112,7 @@ void JSNode::mark()
 
     Node* node = m_impl.get();
 
-    // Nodes in the document are kept alive by ScriptInterpreter::mark,
+    // Nodes in the document are kept alive by JSDocument::mark,
     // so we have no special responsibilities and can just call the base class here.
     if (node->inDocument()) {
         // But if the document isn't marked we have to mark it to ensure that
index 4524b16..67956af 100644 (file)
@@ -153,7 +153,7 @@ JSValue* JSXMLHttpRequest::send(ExecState* exec, const ArgList& args)
     intptr_t sourceID;
     UString sourceURL;
     JSValue* function;
-    exec->machine()->retrieveLastCaller(exec, signedLineNumber, sourceID, sourceURL, function);
+    exec->interpreter()->retrieveLastCaller(exec, signedLineNumber, sourceID, sourceURL, function);
     impl()->setLastSendLineNumber(signedLineNumber >= 0 ? signedLineNumber : 0);
     impl()->setLastSendURL(sourceURL);
 
index 37d08f9..e12626c 100644 (file)
@@ -108,7 +108,7 @@ JSValue* ScriptController::evaluate(const String& sourceURL, int baseLine, const
     m_frame->keepAlive();
 
     m_windowShell->window()->startTimeoutCheck();
-    Completion comp = Interpreter::evaluate(exec, exec->dynamicGlobalObject()->globalScopeChain(), makeSource(str, sourceURL, baseLine), m_windowShell);
+    Completion comp = JSC::evaluate(exec, exec->dynamicGlobalObject()->globalScopeChain(), makeSource(str, sourceURL, baseLine), m_windowShell);
     m_windowShell->window()->stopTimeoutCheck();
 
     if (comp.complType() == Normal || comp.complType() == ReturnValue) {
index 6fac6d0..f7007f9 100644 (file)
@@ -72,7 +72,7 @@ JSValue* WorkerScriptController::evaluate(const String& sourceURL, int baseLine,
 
     ExecState* exec = m_workerContextWrapper->globalExec();
     m_workerContextWrapper->startTimeoutCheck();
-    Completion comp = Interpreter::evaluate(exec, exec->dynamicGlobalObject()->globalScopeChain(), makeSource(code, sourceURL, baseLine), m_workerContextWrapper);
+    Completion comp = JSC::evaluate(exec, exec->dynamicGlobalObject()->globalScopeChain(), makeSource(code, sourceURL, baseLine), m_workerContextWrapper);
     m_workerContextWrapper->stopTimeoutCheck();
 
     if (comp.complType() == Normal || comp.complType() == ReturnValue)
index d4b11f5..10dc46e 100644 (file)
@@ -330,7 +330,7 @@ static void getListFromNSArray(ExecState *exec, NSArray *array, RootObject* root
     JSLock lock(false);
     
     [self _rootObject]->globalObject()->startTimeoutCheck();
-    Completion completion = Interpreter::evaluate([self _rootObject]->globalObject()->globalExec(), [self _rootObject]->globalObject()->globalScopeChain(), makeSource(String(script)));
+    Completion completion = JSC::evaluate([self _rootObject]->globalObject()->globalExec(), [self _rootObject]->globalObject()->globalScopeChain(), makeSource(String(script)));
     [self _rootObject]->globalObject()->stopTimeoutCheck();
     ComplType type = completion.complType();
     
index 66b5b2d..2ad43ce 100644 (file)
@@ -200,7 +200,7 @@ bool _NPN_Evaluate(NPP, NPObject* o, NPString* s, NPVariant* variant)
         JSLock lock(false);
         String scriptString = convertNPStringToUTF16(s);
         rootObject->globalObject()->startTimeoutCheck();
-        Completion completion = Interpreter::evaluate(rootObject->globalObject()->globalExec(), rootObject->globalObject()->globalScopeChain(), makeSource(scriptString));
+        Completion completion = JSC::evaluate(rootObject->globalObject()->globalExec(), rootObject->globalObject()->globalScopeChain(), makeSource(scriptString));
         rootObject->globalObject()->stopTimeoutCheck();
         ComplType type = completion.complType();
         
index 8ee6bad..328b4f1 100644 (file)
@@ -322,7 +322,7 @@ jobject JavaJSObject::eval(jstring script) const
         return 0;
 
     rootObject->globalObject()->startTimeoutCheck();
-    Completion completion = Interpreter::evaluate(rootObject->globalObject()->globalExec(), rootObject->globalObject()->globalScopeChain(), makeSource(JavaString(script)));
+    Completion completion = JSC::evaluate(rootObject->globalObject()->globalExec(), rootObject->globalObject()->globalScopeChain(), makeSource(JavaString(script)));
     rootObject->globalObject()->stopTimeoutCheck();
     ComplType type = completion.complType();
     
index 62448d9..37be4cf 100644 (file)
@@ -150,7 +150,7 @@ static inline void retrieveLastCaller(ExecState* exec, KURL& url, unsigned& line
     UString urlString;
     JSValue* function;
 
-    exec->machine()->retrieveLastCaller(exec, signedLineNumber, sourceID, urlString, function);
+    exec->interpreter()->retrieveLastCaller(exec, signedLineNumber, sourceID, urlString, function);
 
     url = KURL(urlString);
     lineNumber = (signedLineNumber >= 0 ? signedLineNumber : 0);
@@ -274,12 +274,12 @@ void Console::trace(ExecState* exec)
     UString urlString;
     JSValue* func;
 
-    exec->machine()->retrieveLastCaller(exec, signedLineNumber, sourceID, urlString, func);
+    exec->interpreter()->retrieveLastCaller(exec, signedLineNumber, sourceID, urlString, func);
 
     ArgList args;
     while (!func->isNull()) {
         args.append(func);
-        func = exec->machine()->retrieveCaller(exec, asInternalFunction(func));
+        func = exec->interpreter()->retrieveCaller(exec, asInternalFunction(func));
     }
     
     page->inspectorController()->addMessageToConsole(JSMessageSource, TraceMessageLevel, exec, args, 0, String());
index fd033f9..e70a625 100644 (file)
@@ -1,3 +1,12 @@
+2008-11-15  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig.
+        
+        Updated for JavaScriptCore renames.
+
+        * WebScriptCallFrame.cpp:
+        (WebScriptCallFrame::valueByEvaluatingJavaScriptFromString):
+
 2008-11-14  Dan Bernstein  <mitz@apple.com>
 
         - try to fix the Windows build
index a831565..e5002b8 100644 (file)
@@ -261,7 +261,7 @@ JSValue* WebScriptCallFrame::valueByEvaluatingJavaScriptFromString(BSTR script)
         scriptExecutionResult = eval->call(state, 0, args);
     } else
         // no "eval", or no context (i.e. global scope) - use global fallback
-        scriptExecutionResult = Interpreter::evaluate(state, UString(), 0, code.data(), code.size(), globObj).value();
+        scriptExecutionResult = JSC::evaluate(state, UString(), 0, code.data(), code.size(), globObj).value();
 
     if (state->hadException())
         scriptExecutionResult = state->exception();    // (may be redundant depending on which eval path was used)