2008-11-16 Geoffrey Garen <ggaren@apple.com>
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 17 Nov 2008 01:48:55 +0000 (01:48 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 17 Nov 2008 01:48:55 +0000 (01:48 +0000)
        Reviewed by Sam Weinig.

        A few more renames:

        BytecodeInterpreter => Interpreter
        WREC => JSC::WREC, removing JSC:: prefix in a lot of places
        X86Assembler::copy => X86Assembler::executableCopy
        AssemblerBuffer::copy => AssemblerBuffer::executableCopy
        WRECFunction => WREC::RegExpFunction
        OBJECT_OFFSET => FIELD_OFFSET

        Also:

        Nixed use of OBJECT_OFFSET outside of CTI.cpp by making CTI a friend in more places.
        Nixed X86:: and X86Assembler:: prefixes in a lot of places using typedefs

        * JavaScriptCore.exp:
        * VM/CTI.cpp:
        (JSC::):
        (JSC::CTI::emitGetVirtualRegister):
        (JSC::CTI::emitGetVirtualRegisters):
        (JSC::CTI::emitPutCTIArgFromVirtualRegister):
        (JSC::CTI::emitPutCTIArg):
        (JSC::CTI::emitGetCTIArg):
        (JSC::CTI::emitPutCTIParam):
        (JSC::CTI::emitGetCTIParam):
        (JSC::CTI::emitPutToCallFrameHeader):
        (JSC::CTI::emitGetFromCallFrameHeader):
        (JSC::CTI::emitPutVirtualRegister):
        (JSC::CTI::emitNakedCall):
        (JSC::CTI::emitNakedFastCall):
        (JSC::CTI::emitCTICall):
        (JSC::CTI::emitJumpSlowCaseIfNotJSCell):
        (JSC::CTI::emitJumpSlowCaseIfNotImmNum):
        (JSC::CTI::emitJumpSlowCaseIfNotImmNums):
        (JSC::CTI::emitFastArithDeTagImmediate):
        (JSC::CTI::emitFastArithDeTagImmediateJumpIfZero):
        (JSC::CTI::emitFastArithReTagImmediate):
        (JSC::CTI::emitFastArithPotentiallyReTagImmediate):
        (JSC::CTI::emitFastArithImmToInt):
        (JSC::CTI::emitFastArithIntToImmOrSlowCase):
        (JSC::CTI::emitFastArithIntToImmNoCheck):
        (JSC::CTI::emitArithIntToImmWithJump):
        (JSC::CTI::emitTagAsBoolImmediate):
        (JSC::CTI::compileOpCallInitializeCallFrame):
        (JSC::CTI::compileOpCall):
        (JSC::CTI::compileOpStrictEq):
        (JSC::CTI::emitSlowScriptCheck):
        (JSC::CTI::putDoubleResultToJSNumberCellOrJSImmediate):
        (JSC::CTI::compileBinaryArithOp):
        (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::emitGetVariableObjectRegister):
        (JSC::CTI::emitPutVariableObjectRegister):
        * VM/CTI.h:
        (JSC::CallRecord::CallRecord):
        (JSC::JmpTable::JmpTable):
        (JSC::SlowCaseEntry::SlowCaseEntry):
        (JSC::CTI::JSRInfo::JSRInfo):
        * VM/CodeBlock.cpp:
        (JSC::CodeBlock::printStructures):
        (JSC::CodeBlock::derefStructures):
        (JSC::CodeBlock::refStructures):
        * VM/Machine.cpp:
        (JSC::jsLess):
        (JSC::jsLessEq):
        (JSC::Interpreter::resolve):
        (JSC::Interpreter::resolveSkip):
        (JSC::Interpreter::resolveGlobal):
        (JSC::Interpreter::resolveBase):
        (JSC::Interpreter::resolveBaseAndProperty):
        (JSC::Interpreter::resolveBaseAndFunc):
        (JSC::Interpreter::slideRegisterWindowForCall):
        (JSC::Interpreter::callEval):
        (JSC::Interpreter::Interpreter):
        (JSC::Interpreter::initialize):
        (JSC::Interpreter::~Interpreter):
        (JSC::Interpreter::dumpCallFrame):
        (JSC::Interpreter::dumpRegisters):
        (JSC::Interpreter::isOpcode):
        (JSC::Interpreter::unwindCallFrame):
        (JSC::Interpreter::throwException):
        (JSC::Interpreter::execute):
        (JSC::Interpreter::debug):
        (JSC::Interpreter::resetTimeoutCheck):
        (JSC::Interpreter::checkTimeout):
        (JSC::Interpreter::createExceptionScope):
        (JSC::Interpreter::tryCachePutByID):
        (JSC::Interpreter::uncachePutByID):
        (JSC::Interpreter::tryCacheGetByID):
        (JSC::Interpreter::uncacheGetByID):
        (JSC::Interpreter::privateExecute):
        (JSC::Interpreter::retrieveArguments):
        (JSC::Interpreter::retrieveCaller):
        (JSC::Interpreter::retrieveLastCaller):
        (JSC::Interpreter::findFunctionCallFrame):
        (JSC::Interpreter::tryCTICachePutByID):
        (JSC::Interpreter::tryCTICacheGetByID):
        (JSC::):
        (JSC::Interpreter::cti_op_convert_this):
        (JSC::Interpreter::cti_op_end):
        (JSC::Interpreter::cti_op_add):
        (JSC::Interpreter::cti_op_pre_inc):
        (JSC::Interpreter::cti_timeout_check):
        (JSC::Interpreter::cti_register_file_check):
        (JSC::Interpreter::cti_op_loop_if_less):
        (JSC::Interpreter::cti_op_loop_if_lesseq):
        (JSC::Interpreter::cti_op_new_object):
        (JSC::Interpreter::cti_op_put_by_id):
        (JSC::Interpreter::cti_op_put_by_id_second):
        (JSC::Interpreter::cti_op_put_by_id_generic):
        (JSC::Interpreter::cti_op_put_by_id_fail):
        (JSC::Interpreter::cti_op_get_by_id):
        (JSC::Interpreter::cti_op_get_by_id_second):
        (JSC::Interpreter::cti_op_get_by_id_generic):
        (JSC::Interpreter::cti_op_get_by_id_fail):
        (JSC::Interpreter::cti_op_instanceof):
        (JSC::Interpreter::cti_op_del_by_id):
        (JSC::Interpreter::cti_op_mul):
        (JSC::Interpreter::cti_op_new_func):
        (JSC::Interpreter::cti_op_call_JSFunction):
        (JSC::Interpreter::cti_op_call_arityCheck):
        (JSC::Interpreter::cti_vm_dontLazyLinkCall):
        (JSC::Interpreter::cti_vm_lazyLinkCall):
        (JSC::Interpreter::cti_op_push_activation):
        (JSC::Interpreter::cti_op_call_NotJSFunction):
        (JSC::Interpreter::cti_op_create_arguments):
        (JSC::Interpreter::cti_op_create_arguments_no_params):
        (JSC::Interpreter::cti_op_tear_off_activation):
        (JSC::Interpreter::cti_op_tear_off_arguments):
        (JSC::Interpreter::cti_op_profile_will_call):
        (JSC::Interpreter::cti_op_profile_did_call):
        (JSC::Interpreter::cti_op_ret_scopeChain):
        (JSC::Interpreter::cti_op_new_array):
        (JSC::Interpreter::cti_op_resolve):
        (JSC::Interpreter::cti_op_construct_JSConstruct):
        (JSC::Interpreter::cti_op_construct_NotJSConstruct):
        (JSC::Interpreter::cti_op_get_by_val):
        (JSC::Interpreter::cti_op_resolve_func):
        (JSC::Interpreter::cti_op_sub):
        (JSC::Interpreter::cti_op_put_by_val):
        (JSC::Interpreter::cti_op_put_by_val_array):
        (JSC::Interpreter::cti_op_lesseq):
        (JSC::Interpreter::cti_op_loop_if_true):
        (JSC::Interpreter::cti_op_negate):
        (JSC::Interpreter::cti_op_resolve_base):
        (JSC::Interpreter::cti_op_resolve_skip):
        (JSC::Interpreter::cti_op_resolve_global):
        (JSC::Interpreter::cti_op_div):
        (JSC::Interpreter::cti_op_pre_dec):
        (JSC::Interpreter::cti_op_jless):
        (JSC::Interpreter::cti_op_not):
        (JSC::Interpreter::cti_op_jtrue):
        (JSC::Interpreter::cti_op_post_inc):
        (JSC::Interpreter::cti_op_eq):
        (JSC::Interpreter::cti_op_lshift):
        (JSC::Interpreter::cti_op_bitand):
        (JSC::Interpreter::cti_op_rshift):
        (JSC::Interpreter::cti_op_bitnot):
        (JSC::Interpreter::cti_op_resolve_with_base):
        (JSC::Interpreter::cti_op_new_func_exp):
        (JSC::Interpreter::cti_op_mod):
        (JSC::Interpreter::cti_op_less):
        (JSC::Interpreter::cti_op_neq):
        (JSC::Interpreter::cti_op_post_dec):
        (JSC::Interpreter::cti_op_urshift):
        (JSC::Interpreter::cti_op_bitxor):
        (JSC::Interpreter::cti_op_new_regexp):
        (JSC::Interpreter::cti_op_bitor):
        (JSC::Interpreter::cti_op_call_eval):
        (JSC::Interpreter::cti_op_throw):
        (JSC::Interpreter::cti_op_get_pnames):
        (JSC::Interpreter::cti_op_next_pname):
        (JSC::Interpreter::cti_op_push_scope):
        (JSC::Interpreter::cti_op_pop_scope):
        (JSC::Interpreter::cti_op_typeof):
        (JSC::Interpreter::cti_op_is_undefined):
        (JSC::Interpreter::cti_op_is_boolean):
        (JSC::Interpreter::cti_op_is_number):
        (JSC::Interpreter::cti_op_is_string):
        (JSC::Interpreter::cti_op_is_object):
        (JSC::Interpreter::cti_op_is_function):
        (JSC::Interpreter::cti_op_stricteq):
        (JSC::Interpreter::cti_op_nstricteq):
        (JSC::Interpreter::cti_op_to_jsnumber):
        (JSC::Interpreter::cti_op_in):
        (JSC::Interpreter::cti_op_push_new_scope):
        (JSC::Interpreter::cti_op_jmp_scopes):
        (JSC::Interpreter::cti_op_put_by_index):
        (JSC::Interpreter::cti_op_switch_imm):
        (JSC::Interpreter::cti_op_switch_char):
        (JSC::Interpreter::cti_op_switch_string):
        (JSC::Interpreter::cti_op_del_by_val):
        (JSC::Interpreter::cti_op_put_getter):
        (JSC::Interpreter::cti_op_put_setter):
        (JSC::Interpreter::cti_op_new_error):
        (JSC::Interpreter::cti_op_debug):
        (JSC::Interpreter::cti_vm_throw):
        * VM/Machine.h:
        * VM/Register.h:
        * VM/SamplingTool.cpp:
        (JSC::SamplingTool::dump):
        * VM/SamplingTool.h:
        (JSC::SamplingTool::SamplingTool):
        * bytecompiler/CodeGenerator.cpp:
        (JSC::BytecodeGenerator::generate):
        (JSC::BytecodeGenerator::BytecodeGenerator):
        * jsc.cpp:
        (runWithScripts):
        * masm/X86Assembler.h:
        (JSC::AssemblerBuffer::executableCopy):
        (JSC::X86Assembler::executableCopy):
        * runtime/ExecState.h:
        (JSC::ExecState::interpreter):
        * runtime/JSCell.h:
        * runtime/JSFunction.h:
        * runtime/JSGlobalData.cpp:
        (JSC::JSGlobalData::JSGlobalData):
        * runtime/JSGlobalData.h:
        * runtime/JSImmediate.h:
        * runtime/JSString.h:
        * runtime/JSValue.h:
        * runtime/JSVariableObject.h:
        * runtime/RegExp.cpp:
        (JSC::RegExp::RegExp):
        (JSC::RegExp::~RegExp):
        (JSC::RegExp::match):
        * runtime/RegExp.h:
        * wrec/CharacterClassConstructor.cpp:
        * wrec/CharacterClassConstructor.h:
        * wrec/WREC.cpp:
        (JSC::WREC::compileRegExp):
        * wrec/WREC.h:
        (JSC::WREC::Generator::Generator):
        (JSC::WREC::Parser::):
        (JSC::WREC::Parser::Parser):
        (JSC::WREC::Parser::parseAlternative):

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

27 files changed:
JavaScriptCore/ChangeLog
JavaScriptCore/JavaScriptCore.exp
JavaScriptCore/VM/CTI.cpp
JavaScriptCore/VM/CTI.h
JavaScriptCore/VM/CodeBlock.cpp
JavaScriptCore/VM/Machine.cpp
JavaScriptCore/VM/Machine.h
JavaScriptCore/VM/Register.h
JavaScriptCore/VM/SamplingTool.h
JavaScriptCore/bytecompiler/CodeGenerator.cpp
JavaScriptCore/jsc.cpp
JavaScriptCore/masm/X86Assembler.h
JavaScriptCore/runtime/ExecState.h
JavaScriptCore/runtime/JSCell.h
JavaScriptCore/runtime/JSFunction.h
JavaScriptCore/runtime/JSGlobalData.cpp
JavaScriptCore/runtime/JSGlobalData.h
JavaScriptCore/runtime/JSImmediate.h
JavaScriptCore/runtime/JSString.h
JavaScriptCore/runtime/JSValue.h
JavaScriptCore/runtime/JSVariableObject.h
JavaScriptCore/runtime/RegExp.cpp
JavaScriptCore/runtime/RegExp.h
JavaScriptCore/wrec/CharacterClassConstructor.cpp
JavaScriptCore/wrec/CharacterClassConstructor.h
JavaScriptCore/wrec/WREC.cpp
JavaScriptCore/wrec/WREC.h

index 5f20cf4..4109b8f 100644 (file)
@@ -1,3 +1,255 @@
+2008-11-16  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        A few more renames:
+
+        BytecodeInterpreter => Interpreter
+        WREC => JSC::WREC, removing JSC:: prefix in a lot of places
+        X86Assembler::copy => X86Assembler::executableCopy
+        AssemblerBuffer::copy => AssemblerBuffer::executableCopy
+        WRECFunction => WREC::RegExpFunction
+        OBJECT_OFFSET => FIELD_OFFSET
+        
+        Also:
+
+        Nixed use of OBJECT_OFFSET outside of CTI.cpp by making CTI a friend in more places.
+        Nixed X86:: and X86Assembler:: prefixes in a lot of places using typedefs
+
+        * JavaScriptCore.exp:
+        * VM/CTI.cpp:
+        (JSC::):
+        (JSC::CTI::emitGetVirtualRegister):
+        (JSC::CTI::emitGetVirtualRegisters):
+        (JSC::CTI::emitPutCTIArgFromVirtualRegister):
+        (JSC::CTI::emitPutCTIArg):
+        (JSC::CTI::emitGetCTIArg):
+        (JSC::CTI::emitPutCTIParam):
+        (JSC::CTI::emitGetCTIParam):
+        (JSC::CTI::emitPutToCallFrameHeader):
+        (JSC::CTI::emitGetFromCallFrameHeader):
+        (JSC::CTI::emitPutVirtualRegister):
+        (JSC::CTI::emitNakedCall):
+        (JSC::CTI::emitNakedFastCall):
+        (JSC::CTI::emitCTICall):
+        (JSC::CTI::emitJumpSlowCaseIfNotJSCell):
+        (JSC::CTI::emitJumpSlowCaseIfNotImmNum):
+        (JSC::CTI::emitJumpSlowCaseIfNotImmNums):
+        (JSC::CTI::emitFastArithDeTagImmediate):
+        (JSC::CTI::emitFastArithDeTagImmediateJumpIfZero):
+        (JSC::CTI::emitFastArithReTagImmediate):
+        (JSC::CTI::emitFastArithPotentiallyReTagImmediate):
+        (JSC::CTI::emitFastArithImmToInt):
+        (JSC::CTI::emitFastArithIntToImmOrSlowCase):
+        (JSC::CTI::emitFastArithIntToImmNoCheck):
+        (JSC::CTI::emitArithIntToImmWithJump):
+        (JSC::CTI::emitTagAsBoolImmediate):
+        (JSC::CTI::compileOpCallInitializeCallFrame):
+        (JSC::CTI::compileOpCall):
+        (JSC::CTI::compileOpStrictEq):
+        (JSC::CTI::emitSlowScriptCheck):
+        (JSC::CTI::putDoubleResultToJSNumberCellOrJSImmediate):
+        (JSC::CTI::compileBinaryArithOp):
+        (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::emitGetVariableObjectRegister):
+        (JSC::CTI::emitPutVariableObjectRegister):
+        * VM/CTI.h:
+        (JSC::CallRecord::CallRecord):
+        (JSC::JmpTable::JmpTable):
+        (JSC::SlowCaseEntry::SlowCaseEntry):
+        (JSC::CTI::JSRInfo::JSRInfo):
+        * VM/CodeBlock.cpp:
+        (JSC::CodeBlock::printStructures):
+        (JSC::CodeBlock::derefStructures):
+        (JSC::CodeBlock::refStructures):
+        * VM/Machine.cpp:
+        (JSC::jsLess):
+        (JSC::jsLessEq):
+        (JSC::Interpreter::resolve):
+        (JSC::Interpreter::resolveSkip):
+        (JSC::Interpreter::resolveGlobal):
+        (JSC::Interpreter::resolveBase):
+        (JSC::Interpreter::resolveBaseAndProperty):
+        (JSC::Interpreter::resolveBaseAndFunc):
+        (JSC::Interpreter::slideRegisterWindowForCall):
+        (JSC::Interpreter::callEval):
+        (JSC::Interpreter::Interpreter):
+        (JSC::Interpreter::initialize):
+        (JSC::Interpreter::~Interpreter):
+        (JSC::Interpreter::dumpCallFrame):
+        (JSC::Interpreter::dumpRegisters):
+        (JSC::Interpreter::isOpcode):
+        (JSC::Interpreter::unwindCallFrame):
+        (JSC::Interpreter::throwException):
+        (JSC::Interpreter::execute):
+        (JSC::Interpreter::debug):
+        (JSC::Interpreter::resetTimeoutCheck):
+        (JSC::Interpreter::checkTimeout):
+        (JSC::Interpreter::createExceptionScope):
+        (JSC::Interpreter::tryCachePutByID):
+        (JSC::Interpreter::uncachePutByID):
+        (JSC::Interpreter::tryCacheGetByID):
+        (JSC::Interpreter::uncacheGetByID):
+        (JSC::Interpreter::privateExecute):
+        (JSC::Interpreter::retrieveArguments):
+        (JSC::Interpreter::retrieveCaller):
+        (JSC::Interpreter::retrieveLastCaller):
+        (JSC::Interpreter::findFunctionCallFrame):
+        (JSC::Interpreter::tryCTICachePutByID):
+        (JSC::Interpreter::tryCTICacheGetByID):
+        (JSC::):
+        (JSC::Interpreter::cti_op_convert_this):
+        (JSC::Interpreter::cti_op_end):
+        (JSC::Interpreter::cti_op_add):
+        (JSC::Interpreter::cti_op_pre_inc):
+        (JSC::Interpreter::cti_timeout_check):
+        (JSC::Interpreter::cti_register_file_check):
+        (JSC::Interpreter::cti_op_loop_if_less):
+        (JSC::Interpreter::cti_op_loop_if_lesseq):
+        (JSC::Interpreter::cti_op_new_object):
+        (JSC::Interpreter::cti_op_put_by_id):
+        (JSC::Interpreter::cti_op_put_by_id_second):
+        (JSC::Interpreter::cti_op_put_by_id_generic):
+        (JSC::Interpreter::cti_op_put_by_id_fail):
+        (JSC::Interpreter::cti_op_get_by_id):
+        (JSC::Interpreter::cti_op_get_by_id_second):
+        (JSC::Interpreter::cti_op_get_by_id_generic):
+        (JSC::Interpreter::cti_op_get_by_id_fail):
+        (JSC::Interpreter::cti_op_instanceof):
+        (JSC::Interpreter::cti_op_del_by_id):
+        (JSC::Interpreter::cti_op_mul):
+        (JSC::Interpreter::cti_op_new_func):
+        (JSC::Interpreter::cti_op_call_JSFunction):
+        (JSC::Interpreter::cti_op_call_arityCheck):
+        (JSC::Interpreter::cti_vm_dontLazyLinkCall):
+        (JSC::Interpreter::cti_vm_lazyLinkCall):
+        (JSC::Interpreter::cti_op_push_activation):
+        (JSC::Interpreter::cti_op_call_NotJSFunction):
+        (JSC::Interpreter::cti_op_create_arguments):
+        (JSC::Interpreter::cti_op_create_arguments_no_params):
+        (JSC::Interpreter::cti_op_tear_off_activation):
+        (JSC::Interpreter::cti_op_tear_off_arguments):
+        (JSC::Interpreter::cti_op_profile_will_call):
+        (JSC::Interpreter::cti_op_profile_did_call):
+        (JSC::Interpreter::cti_op_ret_scopeChain):
+        (JSC::Interpreter::cti_op_new_array):
+        (JSC::Interpreter::cti_op_resolve):
+        (JSC::Interpreter::cti_op_construct_JSConstruct):
+        (JSC::Interpreter::cti_op_construct_NotJSConstruct):
+        (JSC::Interpreter::cti_op_get_by_val):
+        (JSC::Interpreter::cti_op_resolve_func):
+        (JSC::Interpreter::cti_op_sub):
+        (JSC::Interpreter::cti_op_put_by_val):
+        (JSC::Interpreter::cti_op_put_by_val_array):
+        (JSC::Interpreter::cti_op_lesseq):
+        (JSC::Interpreter::cti_op_loop_if_true):
+        (JSC::Interpreter::cti_op_negate):
+        (JSC::Interpreter::cti_op_resolve_base):
+        (JSC::Interpreter::cti_op_resolve_skip):
+        (JSC::Interpreter::cti_op_resolve_global):
+        (JSC::Interpreter::cti_op_div):
+        (JSC::Interpreter::cti_op_pre_dec):
+        (JSC::Interpreter::cti_op_jless):
+        (JSC::Interpreter::cti_op_not):
+        (JSC::Interpreter::cti_op_jtrue):
+        (JSC::Interpreter::cti_op_post_inc):
+        (JSC::Interpreter::cti_op_eq):
+        (JSC::Interpreter::cti_op_lshift):
+        (JSC::Interpreter::cti_op_bitand):
+        (JSC::Interpreter::cti_op_rshift):
+        (JSC::Interpreter::cti_op_bitnot):
+        (JSC::Interpreter::cti_op_resolve_with_base):
+        (JSC::Interpreter::cti_op_new_func_exp):
+        (JSC::Interpreter::cti_op_mod):
+        (JSC::Interpreter::cti_op_less):
+        (JSC::Interpreter::cti_op_neq):
+        (JSC::Interpreter::cti_op_post_dec):
+        (JSC::Interpreter::cti_op_urshift):
+        (JSC::Interpreter::cti_op_bitxor):
+        (JSC::Interpreter::cti_op_new_regexp):
+        (JSC::Interpreter::cti_op_bitor):
+        (JSC::Interpreter::cti_op_call_eval):
+        (JSC::Interpreter::cti_op_throw):
+        (JSC::Interpreter::cti_op_get_pnames):
+        (JSC::Interpreter::cti_op_next_pname):
+        (JSC::Interpreter::cti_op_push_scope):
+        (JSC::Interpreter::cti_op_pop_scope):
+        (JSC::Interpreter::cti_op_typeof):
+        (JSC::Interpreter::cti_op_is_undefined):
+        (JSC::Interpreter::cti_op_is_boolean):
+        (JSC::Interpreter::cti_op_is_number):
+        (JSC::Interpreter::cti_op_is_string):
+        (JSC::Interpreter::cti_op_is_object):
+        (JSC::Interpreter::cti_op_is_function):
+        (JSC::Interpreter::cti_op_stricteq):
+        (JSC::Interpreter::cti_op_nstricteq):
+        (JSC::Interpreter::cti_op_to_jsnumber):
+        (JSC::Interpreter::cti_op_in):
+        (JSC::Interpreter::cti_op_push_new_scope):
+        (JSC::Interpreter::cti_op_jmp_scopes):
+        (JSC::Interpreter::cti_op_put_by_index):
+        (JSC::Interpreter::cti_op_switch_imm):
+        (JSC::Interpreter::cti_op_switch_char):
+        (JSC::Interpreter::cti_op_switch_string):
+        (JSC::Interpreter::cti_op_del_by_val):
+        (JSC::Interpreter::cti_op_put_getter):
+        (JSC::Interpreter::cti_op_put_setter):
+        (JSC::Interpreter::cti_op_new_error):
+        (JSC::Interpreter::cti_op_debug):
+        (JSC::Interpreter::cti_vm_throw):
+        * VM/Machine.h:
+        * VM/Register.h:
+        * VM/SamplingTool.cpp:
+        (JSC::SamplingTool::dump):
+        * VM/SamplingTool.h:
+        (JSC::SamplingTool::SamplingTool):
+        * bytecompiler/CodeGenerator.cpp:
+        (JSC::BytecodeGenerator::generate):
+        (JSC::BytecodeGenerator::BytecodeGenerator):
+        * jsc.cpp:
+        (runWithScripts):
+        * masm/X86Assembler.h:
+        (JSC::AssemblerBuffer::executableCopy):
+        (JSC::X86Assembler::executableCopy):
+        * runtime/ExecState.h:
+        (JSC::ExecState::interpreter):
+        * runtime/JSCell.h:
+        * runtime/JSFunction.h:
+        * runtime/JSGlobalData.cpp:
+        (JSC::JSGlobalData::JSGlobalData):
+        * runtime/JSGlobalData.h:
+        * runtime/JSImmediate.h:
+        * runtime/JSString.h:
+        * runtime/JSValue.h:
+        * runtime/JSVariableObject.h:
+        * runtime/RegExp.cpp:
+        (JSC::RegExp::RegExp):
+        (JSC::RegExp::~RegExp):
+        (JSC::RegExp::match):
+        * runtime/RegExp.h:
+        * wrec/CharacterClassConstructor.cpp:
+        * wrec/CharacterClassConstructor.h:
+        * wrec/WREC.cpp:
+        (JSC::WREC::compileRegExp):
+        * wrec/WREC.h:
+        (JSC::WREC::Generator::Generator):
+        (JSC::WREC::Parser::):
+        (JSC::WREC::Parser::Parser):
+        (JSC::WREC::Parser::parseAlternative):
+
 2008-11-16  Greg Bolsinga  <bolsinga@apple.com>
 
         Reviewed by Darin Adler.
index 6518a53..6671c6e 100644 (file)
@@ -299,6 +299,8 @@ __ZN3WTF8Collator18setOrderLowerFirstEb
 __ZN3WTF8CollatorC1EPKc
 __ZN3WTF8CollatorD1Ev
 __ZN3WTF8fastFreeEPv
+__ZNK3JSC11Interpreter14retrieveCallerEPNS_9ExecStateEPNS_16InternalFunctionE
+__ZNK3JSC11Interpreter18retrieveLastCallerEPNS_9ExecStateERiRlRNS_7UStringERPNS_7JSValueE
 __ZNK3JSC12DateInstance7getTimeERdRi
 __ZNK3JSC12StringObject12toThisStringEPNS_9ExecStateE
 __ZNK3JSC12StringObject8toStringEPNS_9ExecStateE
@@ -311,8 +313,6 @@ __ZNK3JSC17DebuggerCallFrame10thisObjectEv
 __ZNK3JSC17DebuggerCallFrame12functionNameEv
 __ZNK3JSC17DebuggerCallFrame4typeEv
 __ZNK3JSC17DebuggerCallFrame8evaluateERKNS_7UStringERPNS_7JSValueE
-__ZNK3JSC19BytecodeInterpreter14retrieveCallerEPNS_9ExecStateEPNS_16InternalFunctionE
-__ZNK3JSC19BytecodeInterpreter18retrieveLastCallerEPNS_9ExecStateERiRlRNS_7UStringERPNS_7JSValueE
 __ZNK3JSC6JSCell12toThisObjectEPNS_9ExecStateE
 __ZNK3JSC6JSCell12toThisStringEPNS_9ExecStateE
 __ZNK3JSC6JSCell14isGetterSetterEv
index 221ab14..b31bf44 100644 (file)
 #include <stdio.h>
 #endif
 
+// FIELD_OFFSET: A clone of the C++ "offsetof" macro that can be used with classes,
+// at the expense of some type safety.
+// The magic number 0x4000 here has no significance. We use it to avoid using NULL,
+// because NULL can have unexpected compiler effects, particularly in cases of
+// multiple inheritance.
+#define FIELD_OFFSET(class, member) (reinterpret_cast<ptrdiff_t>(&(reinterpret_cast<class*>(0x4000)->member)) - 0x4000)
+
 #define __ m_assembler. 
 
 using namespace std;
 
 namespace JSC {
 
+typedef X86Assembler::JmpSrc JmpSrc;
+
 #if PLATFORM(MAC)
 
 static inline bool isSSE2Present()
@@ -119,9 +128,9 @@ SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
 #else
     "movl %esp, 0(%esp)" "\n"
 #endif
-    "call " SYMBOL_STRING(_ZN3JSC19BytecodeInterpreter12cti_vm_throwEPPv) "\n"
+    "call " SYMBOL_STRING(_ZN3JSC11Interpreter12cti_vm_throwEPPv) "\n"
 #else
-    "call " SYMBOL_STRING(_ZN3JSC19BytecodeInterpreter12cti_vm_throwEPvz) "\n"
+    "call " SYMBOL_STRING(_ZN3JSC11Interpreter12cti_vm_throwEPvz) "\n"
 #endif
     "addl $0x20, %esp" "\n"
     "popl %ebx" "\n"
@@ -157,7 +166,7 @@ extern "C" {
     {
         __asm {
             mov ecx, esp;
-            call JSC::BytecodeInterpreter::cti_vm_throw;
+            call JSC::Interpreter::cti_vm_throw;
             add esp, 0x20;
             pop ebx;
             pop edi;
@@ -181,7 +190,7 @@ ALWAYS_INLINE void CTI::killLastResultRegister()
 }
 
 // get arg puts an arg from the SF register array into a h/w register
-ALWAYS_INLINE void CTI::emitGetVirtualRegister(int src, X86Assembler::RegisterID dst, unsigned currentInstructionIndex)
+ALWAYS_INLINE void CTI::emitGetVirtualRegister(int src, RegisterID dst, unsigned currentInstructionIndex)
 {
     // TODO: we want to reuse values that are already in registers if we can - add a register allocator!
     if (m_codeBlock->isConstantRegisterIndex(src)) {
@@ -212,7 +221,7 @@ ALWAYS_INLINE void CTI::emitGetVirtualRegister(int src, X86Assembler::RegisterID
     killLastResultRegister();
 }
 
-ALWAYS_INLINE void CTI::emitGetVirtualRegisters(int src1, X86Assembler::RegisterID dst1, int src2, X86Assembler::RegisterID dst2, unsigned i)
+ALWAYS_INLINE void CTI::emitGetVirtualRegisters(int src1, RegisterID dst1, int src2, RegisterID dst2, unsigned i)
 {
     if (src2 == m_lastResultBytecodeRegister) {
         emitGetVirtualRegister(src2, dst2, i);
@@ -224,7 +233,7 @@ ALWAYS_INLINE void CTI::emitGetVirtualRegisters(int src1, X86Assembler::Register
 }
 
 // get arg puts an arg from the SF register array onto the stack, as an arg to a context threaded function.
-ALWAYS_INLINE void CTI::emitPutCTIArgFromVirtualRegister(unsigned src, unsigned offset, X86Assembler::RegisterID scratch)
+ALWAYS_INLINE void CTI::emitPutCTIArgFromVirtualRegister(unsigned src, unsigned offset, RegisterID scratch)
 {
     if (m_codeBlock->isConstantRegisterIndex(src)) {
         JSValue* value = m_codeBlock->getConstant(src);
@@ -238,12 +247,12 @@ ALWAYS_INLINE void CTI::emitPutCTIArgFromVirtualRegister(unsigned src, unsigned
 }
 
 // puts an arg onto the stack, as an arg to a context threaded function.
-ALWAYS_INLINE void CTI::emitPutCTIArg(X86Assembler::RegisterID src, unsigned offset)
+ALWAYS_INLINE void CTI::emitPutCTIArg(RegisterID src, unsigned offset)
 {
     __ movl_rm(src, offset + sizeof(void*), X86::esp);
 }
 
-ALWAYS_INLINE void CTI::emitGetCTIArg(unsigned offset, X86Assembler::RegisterID dst)
+ALWAYS_INLINE void CTI::emitGetCTIArg(unsigned offset, RegisterID dst)
 {
     __ movl_mr(offset + sizeof(void*), X86::esp, dst);
 }
@@ -268,29 +277,29 @@ ALWAYS_INLINE void CTI::emitPutCTIParam(void* value, unsigned name)
     __ movl_i32m(reinterpret_cast<intptr_t>(value), name * sizeof(void*), X86::esp);
 }
 
-ALWAYS_INLINE void CTI::emitPutCTIParam(X86Assembler::RegisterID from, unsigned name)
+ALWAYS_INLINE void CTI::emitPutCTIParam(RegisterID from, unsigned name)
 {
     __ movl_rm(from, name * sizeof(void*), X86::esp);
 }
 
-ALWAYS_INLINE void CTI::emitGetCTIParam(unsigned name, X86Assembler::RegisterID to)
+ALWAYS_INLINE void CTI::emitGetCTIParam(unsigned name, RegisterID to)
 {
     __ movl_mr(name * sizeof(void*), X86::esp, to);
     killLastResultRegister();
 }
 
-ALWAYS_INLINE void CTI::emitPutToCallFrameHeader(X86Assembler::RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
+ALWAYS_INLINE void CTI::emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
 {
     __ movl_rm(from, entry * sizeof(Register), X86::edi);
 }
 
-ALWAYS_INLINE void CTI::emitGetFromCallFrameHeader(RegisterFile::CallFrameHeaderEntry entry, X86Assembler::RegisterID to)
+ALWAYS_INLINE void CTI::emitGetFromCallFrameHeader(RegisterFile::CallFrameHeaderEntry entry, RegisterID to)
 {
     __ movl_mr(entry * sizeof(Register), X86::edi, to);
     killLastResultRegister();
 }
 
-ALWAYS_INLINE void CTI::emitPutVirtualRegister(unsigned dst, X86Assembler::RegisterID from)
+ALWAYS_INLINE void CTI::emitPutVirtualRegister(unsigned dst, RegisterID from)
 {
     __ movl_rm(from, dst * sizeof(Register), X86::edi);
     m_lastResultBytecodeRegister = (from == X86::eax) ? dst : std::numeric_limits<int>::max();
@@ -365,29 +374,29 @@ ALWAYS_INLINE void CTI::emitAllocateNumber(JSGlobalData* globalData, unsigned by
     emitNakedFastCall(bytecodeIndex, (void*)allocateNumber);
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitNakedCall(unsigned bytecodeIndex, X86::RegisterID r)
+ALWAYS_INLINE JmpSrc CTI::emitNakedCall(unsigned bytecodeIndex, X86::RegisterID r)
 {
-    X86Assembler::JmpSrc call = __ emitCall(r);
+    JmpSrc call = __ emitCall(r);
     m_calls.append(CallRecord(call, bytecodeIndex));
 
     return call;
 }
 
-ALWAYS_INLINE  X86Assembler::JmpSrc CTI::emitNakedCall(unsigned bytecodeIndex, void* function)
+ALWAYS_INLINE  JmpSrc CTI::emitNakedCall(unsigned bytecodeIndex, void* function)
 {
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, reinterpret_cast<CTIHelper_v>(function), bytecodeIndex));
     return call;
 }
 
-ALWAYS_INLINE  X86Assembler::JmpSrc CTI::emitNakedFastCall(unsigned bytecodeIndex, void* function)
+ALWAYS_INLINE  JmpSrc CTI::emitNakedFastCall(unsigned bytecodeIndex, void* function)
 {
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, reinterpret_cast<CTIHelper_v>(function), bytecodeIndex));
     return call;
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_j helper)
+ALWAYS_INLINE JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_j helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
@@ -396,7 +405,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
 #endif
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, helper, bytecodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
@@ -406,7 +415,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
     return call;
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_o helper)
+ALWAYS_INLINE JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_o helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
@@ -415,7 +424,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
 #endif
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, helper, bytecodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
@@ -425,7 +434,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
     return call;
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_p helper)
+ALWAYS_INLINE JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_p helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
@@ -434,7 +443,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
 #endif
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, helper, bytecodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
@@ -444,7 +453,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
     return call;
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_b helper)
+ALWAYS_INLINE JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_b helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
@@ -453,7 +462,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
 #endif
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, helper, bytecodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
@@ -463,7 +472,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
     return call;
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_v helper)
+ALWAYS_INLINE JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_v helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
@@ -472,7 +481,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
 #endif
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, helper, bytecodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
@@ -482,7 +491,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
     return call;
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_s helper)
+ALWAYS_INLINE JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_s helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
@@ -491,7 +500,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
 #endif
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, helper, bytecodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
@@ -501,7 +510,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
     return call;
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_2 helper)
+ALWAYS_INLINE JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_2 helper)
 {
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, true), m_interpreter->sampler()->sampleSlot());
@@ -510,7 +519,7 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
 #endif
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc call = __ emitCall();
+    JmpSrc call = __ emitCall();
     m_calls.append(CallRecord(call, helper, bytecodeIndex));
 #if ENABLE(OPCODE_SAMPLING)
     __ movl_i32m(m_interpreter->sampler()->encodeSample(vPC, false), m_interpreter->sampler()->sampleSlot());
@@ -520,13 +529,13 @@ ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned b
     return call;
 }
 
-ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotJSCell(X86Assembler::RegisterID reg, unsigned bytecodeIndex)
+ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotJSCell(RegisterID reg, unsigned bytecodeIndex)
 {
     __ testl_i32r(JSImmediate::TagMask, reg);
     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), bytecodeIndex));
 }
 
-ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotJSCell(X86Assembler::RegisterID reg, unsigned bytecodeIndex, int vReg)
+ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotJSCell(RegisterID reg, unsigned bytecodeIndex, int vReg)
 {
     if (m_codeBlock->isKnownNotImmediate(vReg))
         return;
@@ -543,13 +552,13 @@ ALWAYS_INLINE bool CTI::linkSlowCaseIfNotJSCell(const Vector<SlowCaseEntry>::ite
     return true;
 }
 
-ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotImmNum(X86Assembler::RegisterID reg, unsigned bytecodeIndex)
+ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotImmNum(RegisterID reg, unsigned bytecodeIndex)
 {
     __ testl_i32r(JSImmediate::TagBitTypeInteger, reg);
     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), bytecodeIndex));
 }
 
-ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotImmNums(X86Assembler::RegisterID reg1, X86Assembler::RegisterID reg2, unsigned bytecodeIndex)
+ALWAYS_INLINE void CTI::emitJumpSlowCaseIfNotImmNums(RegisterID reg1, RegisterID reg2, unsigned bytecodeIndex)
 {
     __ movl_rr(reg1, X86::ecx);
     __ andl_rr(reg2, X86::ecx);
@@ -562,54 +571,54 @@ ALWAYS_INLINE unsigned CTI::getDeTaggedConstantImmediate(JSValue* imm)
     return asInteger(imm) & ~JSImmediate::TagBitTypeInteger;
 }
 
-ALWAYS_INLINE void CTI::emitFastArithDeTagImmediate(X86Assembler::RegisterID reg)
+ALWAYS_INLINE void CTI::emitFastArithDeTagImmediate(RegisterID reg)
 {
     __ subl_i8r(JSImmediate::TagBitTypeInteger, reg);
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitFastArithDeTagImmediateJumpIfZero(X86Assembler::RegisterID reg)
+ALWAYS_INLINE JmpSrc CTI::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
 {
     __ subl_i8r(JSImmediate::TagBitTypeInteger, reg);
     return __ emitUnlinkedJe();
 }
 
-ALWAYS_INLINE void CTI::emitFastArithReTagImmediate(X86Assembler::RegisterID reg)
+ALWAYS_INLINE void CTI::emitFastArithReTagImmediate(RegisterID reg)
 {
     __ addl_i8r(JSImmediate::TagBitTypeInteger, reg);
 }
 
-ALWAYS_INLINE void CTI::emitFastArithPotentiallyReTagImmediate(X86Assembler::RegisterID reg)
+ALWAYS_INLINE void CTI::emitFastArithPotentiallyReTagImmediate(RegisterID reg)
 {
     __ orl_i32r(JSImmediate::TagBitTypeInteger, reg);
 }
 
-ALWAYS_INLINE void CTI::emitFastArithImmToInt(X86Assembler::RegisterID reg)
+ALWAYS_INLINE void CTI::emitFastArithImmToInt(RegisterID reg)
 {
     __ sarl_i8r(1, reg);
 }
 
-ALWAYS_INLINE void CTI::emitFastArithIntToImmOrSlowCase(X86Assembler::RegisterID reg, unsigned bytecodeIndex)
+ALWAYS_INLINE void CTI::emitFastArithIntToImmOrSlowCase(RegisterID reg, unsigned bytecodeIndex)
 {
     __ addl_rr(reg, reg);
     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJo(), bytecodeIndex));
     emitFastArithReTagImmediate(reg);
 }
 
-ALWAYS_INLINE void CTI::emitFastArithIntToImmNoCheck(X86Assembler::RegisterID reg)
+ALWAYS_INLINE void CTI::emitFastArithIntToImmNoCheck(RegisterID reg)
 {
     __ addl_rr(reg, reg);
     emitFastArithReTagImmediate(reg);
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitArithIntToImmWithJump(X86Assembler::RegisterID reg)
+ALWAYS_INLINE JmpSrc CTI::emitArithIntToImmWithJump(RegisterID reg)
 {
     __ addl_rr(reg, reg);
-    X86Assembler::JmpSrc jmp = __ emitUnlinkedJo();
+    JmpSrc jmp = __ emitUnlinkedJo();
     emitFastArithReTagImmediate(reg);
     return jmp;
 }
 
-ALWAYS_INLINE void CTI::emitTagAsBoolImmediate(X86Assembler::RegisterID reg)
+ALWAYS_INLINE void CTI::emitTagAsBoolImmediate(RegisterID reg)
 {
     __ shl_i8r(JSImmediate::ExtendedPayloadShift, reg);
     __ orl_i32r(JSImmediate::FullTagTypeBool, reg);
@@ -632,7 +641,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, BytecodeInterpreter::cti_##name); \
+        emitCTICall(instruction + i, i, Interpreter::cti_##name); \
         emitPutVirtualRegister(instruction[i + 1].u.operand); \
         i += 4; \
         break; \
@@ -641,7 +650,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, BytecodeInterpreter::cti_##name); \
+        emitCTICall(instruction + i, i, Interpreter::cti_##name); \
         emitPutVirtualRegister(instruction[i + 1].u.operand); \
         i += 3; \
         break; \
@@ -657,7 +666,7 @@ void CTI::compileOpCallInitializeCallFrame()
 {
     __ movl_rm(X86::edx, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register)), X86::edi);
 
-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_scopeChain) + OBJECT_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
+    __ movl_mr(FIELD_OFFSET(JSFunction, m_scopeChain) + FIELD_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
 
     __ movl_i32m(asInteger(noValue()), RegisterFile::OptionalCalleeArguments * static_cast<int>(sizeof(Register)), X86::edi);
     __ movl_rm(X86::ecx, RegisterFile::Callee * static_cast<int>(sizeof(Register)), X86::edi);
@@ -712,12 +721,12 @@ void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i,
     int registerOffset = instruction[4].u.operand;
 
     // Handle eval
-    X86Assembler::JmpSrc wasEval;
+    JmpSrc wasEval;
     if (opcodeID == op_call_eval) {
         emitGetVirtualRegister(callee, X86::ecx, i);
         compileOpCallEvalSetupArgs(instruction);
 
-        emitCTICall(instruction, i, BytecodeInterpreter::cti_op_call_eval);
+        emitCTICall(instruction, i, Interpreter::cti_op_call_eval);
         __ cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::eax);
         wasEval = __ emitUnlinkedJne();
     }
@@ -726,9 +735,9 @@ void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i,
     // This deliberately leaves the callee in ecx, used when setting up the stack frame below
     emitGetVirtualRegister(callee, X86::ecx, i);
     __ cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::ecx);
-    X86Assembler::JmpDst addressOfLinkedFunctionCheck = __ label();
+    JmpDst addressOfLinkedFunctionCheck = __ label();
     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
-    ASSERT(X86Assembler::getDifferenceBetweenLabels(addressOfLinkedFunctionCheck, __ label()) == repatchOffsetOpCallCall);
+    ASSERT(__ getDifferenceBetweenLabels(addressOfLinkedFunctionCheck, __ label()) == repatchOffsetOpCallCall);
     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;
 
     // The following is the fast case, only used whan a callee can be linked.
@@ -740,7 +749,7 @@ void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i,
 
         emitPutCTIArg(X86::ecx, 0);
         emitPutCTIArgFromVirtualRegister(proto, 12, X86::eax);
-        emitCTICall(instruction, i, BytecodeInterpreter::cti_op_construct_JSConstruct);
+        emitCTICall(instruction, i, Interpreter::cti_op_construct_JSConstruct);
         emitPutVirtualRegister(thisRegister);
         emitGetVirtualRegister(callee, X86::ecx, i);
     }
@@ -749,7 +758,7 @@ void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i,
     // Note that this omits to set up RegisterFile::CodeBlock, which is set in the callee
     __ movl_i32m(asInteger(noValue()), (registerOffset + RegisterFile::OptionalCalleeArguments) * static_cast<int>(sizeof(Register)), X86::edi);
     __ movl_rm(X86::ecx, (registerOffset + RegisterFile::Callee) * static_cast<int>(sizeof(Register)), X86::edi);
-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_scopeChain) + OBJECT_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
+    __ movl_mr(FIELD_OFFSET(JSFunction, m_scopeChain) + FIELD_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
     __ movl_i32m(argCount, (registerOffset + RegisterFile::ArgumentCount) * static_cast<int>(sizeof(Register)), X86::edi);
     __ movl_rm(X86::edi, (registerOffset + RegisterFile::CallerFrame) * static_cast<int>(sizeof(Register)), X86::edi);
     __ movl_rm(X86::edx, (registerOffset + RegisterFile::ScopeChain) * static_cast<int>(sizeof(Register)), X86::edi);
@@ -780,9 +789,9 @@ void CTI::compileOpStrictEq(Instruction* instruction, unsigned i, CompileOpStric
     emitGetVirtualRegisters(src1, X86::eax, src2, X86::edx, i);
 
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    X86Assembler::JmpSrc firstNotImmediate = __ emitUnlinkedJe();
+    JmpSrc firstNotImmediate = __ emitUnlinkedJe();
     __ testl_i32r(JSImmediate::TagMask, X86::edx);
-    X86Assembler::JmpSrc secondNotImmediate = __ emitUnlinkedJe();
+    JmpSrc secondNotImmediate = __ emitUnlinkedJe();
 
     __ cmpl_rr(X86::edx, X86::eax);
     if (negated)
@@ -792,7 +801,7 @@ void CTI::compileOpStrictEq(Instruction* instruction, unsigned i, CompileOpStric
     __ movzbl_rr(X86::eax, X86::eax);
     emitTagAsBoolImmediate(X86::eax);
             
-    X86Assembler::JmpSrc bothWereImmediates = __ emitUnlinkedJmp();
+    JmpSrc bothWereImmediates = __ emitUnlinkedJmp();
 
     __ link(firstNotImmediate, __ label());
 
@@ -809,7 +818,7 @@ void CTI::compileOpStrictEq(Instruction* instruction, unsigned i, CompileOpStric
 
     __ movl_i32r(asInteger(jsBoolean(negated)), X86::eax);
 
-    X86Assembler::JmpSrc firstWasNotImmediate = __ emitUnlinkedJmp();
+    JmpSrc firstWasNotImmediate = __ emitUnlinkedJmp();
 
     __ link(secondNotImmediate, __ label());
     // check that eax is not the zero immediate (we know it must be immediate)
@@ -827,12 +836,12 @@ void CTI::compileOpStrictEq(Instruction* instruction, unsigned i, CompileOpStric
 void CTI::emitSlowScriptCheck(Instruction* vPC, unsigned bytecodeIndex)
 {
     __ subl_i8r(1, X86::esi);
-    X86Assembler::JmpSrc skipTimeout = __ emitUnlinkedJne();
-    emitCTICall(vPC, bytecodeIndex, BytecodeInterpreter::cti_timeout_check);
+    JmpSrc skipTimeout = __ emitUnlinkedJne();
+    emitCTICall(vPC, bytecodeIndex, Interpreter::cti_timeout_check);
 
     emitGetCTIParam(CTI_ARGS_globalData, X86::ecx);
-    __ movl_mr(OBJECT_OFFSET(JSGlobalData, interpreter), X86::ecx, X86::ecx);
-    __ movl_mr(OBJECT_OFFSET(BytecodeInterpreter, m_ticksUntilNextTimeoutCheck), X86::ecx, X86::esi);
+    __ movl_mr(FIELD_OFFSET(JSGlobalData, interpreter), X86::ecx, X86::ecx);
+    __ movl_mr(FIELD_OFFSET(Interpreter, m_ticksUntilNextTimeoutCheck), X86::ecx, X86::esi);
     __ link(skipTimeout, __ label());
 
     killLastResultRegister();
@@ -847,7 +856,7 @@ void CTI::emitSlowScriptCheck(Instruction* vPC, unsigned bytecodeIndex)
   However if the value from xmmSource is representable as a JSImmediate, then the JSImmediate value will be written to the output, and flow
   control will fall through from the code planted.
 */
-void CTI::putDoubleResultToJSNumberCellOrJSImmediate(X86::XMMRegisterID xmmSource, X86::RegisterID jsNumberCell, unsigned dst, X86Assembler::JmpSrc* wroteJSNumberCell,  X86::XMMRegisterID tempXmm, X86::RegisterID tempReg1, X86::RegisterID tempReg2)
+void CTI::putDoubleResultToJSNumberCellOrJSImmediate(X86::XMMRegisterID xmmSource, X86::RegisterID jsNumberCell, unsigned dst, JmpSrc* wroteJSNumberCell,  X86::XMMRegisterID tempXmm, X86::RegisterID tempReg1, X86::RegisterID tempReg2)
 {
     // convert (double -> JSImmediate -> double), and check if the value is unchanged - in which case the value is representable as a JSImmediate.
     __ cvttsd2si_rr(xmmSource, tempReg1);
@@ -856,11 +865,11 @@ void CTI::putDoubleResultToJSNumberCellOrJSImmediate(X86::XMMRegisterID xmmSourc
     __ cvtsi2sd_rr(tempReg1, tempXmm);
     // Compare & branch if immediate. 
     __ ucomis_rr(tempXmm, xmmSource);
-    X86Assembler::JmpSrc resultIsImm = __ emitUnlinkedJe();
-    X86Assembler::JmpDst resultLookedLikeImmButActuallyIsnt = __ label();
+    JmpSrc resultIsImm = __ emitUnlinkedJe();
+    JmpDst resultLookedLikeImmButActuallyIsnt = __ label();
     
     // Store the result to the JSNumberCell and jump.
-    __ movsd_rm(xmmSource, OBJECT_OFFSET(JSNumberCell, m_value), jsNumberCell);
+    __ movsd_rm(xmmSource, FIELD_OFFSET(JSNumberCell, m_value), jsNumberCell);
     if (jsNumberCell != X86::eax)
         __ movl_rr(jsNumberCell, X86::eax);
     emitPutVirtualRegister(dst);
@@ -883,10 +892,10 @@ void CTI::putDoubleResultToJSNumberCellOrJSImmediate(X86::XMMRegisterID xmmSourc
 void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
 {
     Structure* numberStructure = m_globalData->numberStructure.get();
-    X86Assembler::JmpSrc wasJSNumberCell1;
-    X86Assembler::JmpSrc wasJSNumberCell1b;
-    X86Assembler::JmpSrc wasJSNumberCell2;
-    X86Assembler::JmpSrc wasJSNumberCell2b;
+    JmpSrc wasJSNumberCell1;
+    JmpSrc wasJSNumberCell1b;
+    JmpSrc wasJSNumberCell2;
+    JmpSrc wasJSNumberCell2b;
 
     emitGetVirtualRegisters(src1, X86::eax, src2, X86::edx, i);
 
@@ -895,26 +904,26 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
 
         // Check op2 is a number
         __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::edx);
-        X86Assembler::JmpSrc op2imm = __ emitUnlinkedJne();
+        JmpSrc op2imm = __ emitUnlinkedJne();
         if (!types.second().definitelyIsNumber()) {
             emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
-            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::edx);
+            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::edx);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
         }
 
         // (1) In this case src2 is a reusable number cell.
         //     Slow case if src1 is not a number type.
         __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
-        X86Assembler::JmpSrc op1imm = __ emitUnlinkedJne();
+        JmpSrc op1imm = __ emitUnlinkedJne();
         if (!types.first().definitelyIsNumber()) {
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
-            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
         }
 
         // (1a) if we get here, src1 is also a number cell
-        __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
-        X86Assembler::JmpSrc loadedDouble = __ emitUnlinkedJmp();
+        __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
+        JmpSrc loadedDouble = __ emitUnlinkedJmp();
         // (1b) if we get here, src1 is an immediate
         __ link(op1imm, __ label());
         emitFastArithImmToInt(X86::eax);
@@ -922,12 +931,12 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
         // (1c) 
         __ link(loadedDouble, __ label());
         if (opcodeID == op_add)
-            __ addsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
+            __ addsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
         else if (opcodeID == op_sub)
-            __ subsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
+            __ subsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
         else {
             ASSERT(opcodeID == op_mul);
-            __ mulsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
+            __ mulsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
         }
 
         putDoubleResultToJSNumberCellOrJSImmediate(X86::xmm0, X86::edx, dst, &wasJSNumberCell2, X86::xmm1, X86::ecx, X86::eax);
@@ -942,33 +951,33 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
 
         // Check op1 is a number
         __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
-        X86Assembler::JmpSrc op1imm = __ emitUnlinkedJne();
+        JmpSrc op1imm = __ emitUnlinkedJne();
         if (!types.first().definitelyIsNumber()) {
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
-            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
         }
 
         // (1) In this case src1 is a reusable number cell.
         //     Slow case if src2 is not a number type.
         __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::edx);
-        X86Assembler::JmpSrc op2imm = __ emitUnlinkedJne();
+        JmpSrc op2imm = __ emitUnlinkedJne();
         if (!types.second().definitelyIsNumber()) {
             emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
-            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::edx);
+            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::edx);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
         }
 
         // (1a) if we get here, src2 is also a number cell
-        __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm1);
-        X86Assembler::JmpSrc loadedDouble = __ emitUnlinkedJmp();
+        __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm1);
+        JmpSrc loadedDouble = __ emitUnlinkedJmp();
         // (1b) if we get here, src2 is an immediate
         __ link(op2imm, __ label());
         emitFastArithImmToInt(X86::edx);
         __ cvtsi2sd_rr(X86::edx, X86::xmm1);
         // (1c) 
         __ link(loadedDouble, __ label());
-        __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
+        __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
         if (opcodeID == op_add)
             __ addsd_rr(X86::xmm1, X86::xmm0);
         else if (opcodeID == op_sub)
@@ -977,7 +986,7 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
             ASSERT(opcodeID == op_mul);
             __ mulsd_rr(X86::xmm1, X86::xmm0);
         }
-        __ movsd_rm(X86::xmm0, OBJECT_OFFSET(JSNumberCell, m_value), X86::eax);
+        __ movsd_rm(X86::xmm0, FIELD_OFFSET(JSNumberCell, m_value), X86::eax);
         emitPutVirtualRegister(dst);
 
         putDoubleResultToJSNumberCellOrJSImmediate(X86::xmm0, X86::eax, dst, &wasJSNumberCell1, X86::xmm1, X86::ecx, X86::edx);
@@ -1002,9 +1011,9 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
         ASSERT(opcodeID == op_mul);
         // convert eax & edx from JSImmediates to ints, and check if either are zero
         emitFastArithImmToInt(X86::edx);
-        X86Assembler::JmpSrc op1Zero = emitFastArithDeTagImmediateJumpIfZero(X86::eax);
+        JmpSrc op1Zero = emitFastArithDeTagImmediateJumpIfZero(X86::eax);
         __ testl_rr(X86::edx, X86::edx);
-        X86Assembler::JmpSrc op2NonZero = __ emitUnlinkedJne();
+        JmpSrc op2NonZero = __ emitUnlinkedJne();
         __ link(op1Zero, __ label());
         // if either input is zero, add the two together, and check if the result is < 0.
         // If it is, we have a problem (N < 0), (N * 0) == -0, not representatble as a JSImmediate. 
@@ -1031,7 +1040,7 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
 
 void CTI::compileBinaryArithOpSlowCase(Instruction* vPC, OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
 {
-    X86Assembler::JmpDst here = __ label();
+    JmpDst here = __ label();
     __ link(iter->from, here);
     if (types.second().isReusable() && isSSE2Present()) {
         if (!types.first().definitelyIsNumber()) {
@@ -1067,12 +1076,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, BytecodeInterpreter::cti_op_add);
+        emitCTICall(vPC, i, Interpreter::cti_op_add);
     else if (opcodeID == op_sub)
-        emitCTICall(vPC, i, BytecodeInterpreter::cti_op_sub);
+        emitCTICall(vPC, i, Interpreter::cti_op_sub);
     else {
         ASSERT(opcodeID == op_mul);
-        emitCTICall(vPC, i, BytecodeInterpreter::cti_op_mul);
+        emitCTICall(vPC, i, Interpreter::cti_op_mul);
     }
     emitPutVirtualRegister(dst);
 }
@@ -1130,7 +1139,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, BytecodeInterpreter::cti_op_add);
+                    emitCTICall(instruction + i, i, Interpreter::cti_op_add);
                     emitPutVirtualRegister(instruction[i + 1].u.operand);
                 }
             }
@@ -1140,7 +1149,7 @@ void CTI::privateCompileMainPass()
         }
         case op_end: {
             if (m_codeBlock->needsFullScopeChain)
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_end);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_end);
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
             __ pushl_m(RegisterFile::ReturnPC * static_cast<int>(sizeof(Register)), X86::edi);
             __ ret();
@@ -1212,7 +1221,7 @@ void CTI::privateCompileMainPass()
             break;
         }
         case op_new_object: {
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_new_object);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_new_object);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 2;
             break;
@@ -1230,19 +1239,19 @@ void CTI::privateCompileMainPass()
             // Jump to a slow case if either the base object is an immediate, or if the Structure does not match.
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, baseVReg);
 
-            X86Assembler::JmpDst hotPathBegin = __ label();
+            JmpDst hotPathBegin = __ label();
             m_propertyAccessCompilationInfo[propertyAccessInstructionIndex].hotPathBegin = hotPathBegin;
             ++propertyAccessInstructionIndex;
 
             // It is important that the following instruction plants a 32bit immediate, in order that it can be patched over.
-            __ cmpl_i32m(repatchGetByIdDefaultStructure, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
-            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdStructure);
+            __ cmpl_i32m(repatchGetByIdDefaultStructure, FIELD_OFFSET(JSCell, m_structure), X86::eax);
+            ASSERT(__ getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdStructure);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
 
             // Plant a load from a bogus ofset in the object's property map; we will patch this later, if it is to be used.
-            __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
+            __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
             __ movl_rm(X86::edx, repatchGetByIdDefaultOffset, X86::eax);
-            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdPropertyMapOffset);
+            ASSERT(__ getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdPropertyMapOffset);
 
             i += 8;
             break;
@@ -1260,18 +1269,18 @@ void CTI::privateCompileMainPass()
 
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, baseVReg);
 
-            X86Assembler::JmpDst hotPathBegin = __ label();
+            JmpDst hotPathBegin = __ label();
             m_propertyAccessCompilationInfo[propertyAccessInstructionIndex].hotPathBegin = hotPathBegin;
             ++propertyAccessInstructionIndex;
 
-            __ cmpl_i32m(repatchGetByIdDefaultStructure, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
-            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdStructure);
+            __ cmpl_i32m(repatchGetByIdDefaultStructure, FIELD_OFFSET(JSCell, m_structure), X86::eax);
+            ASSERT(__ getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdStructure);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
-            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdBranchToSlowCase);
+            ASSERT(__ getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdBranchToSlowCase);
 
-            __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
+            __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
             __ movl_mr(repatchGetByIdDefaultOffset, X86::eax, X86::eax);
-            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdPropertyMapOffset);
+            ASSERT(__ getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdPropertyMapOffset);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
 
             i += 8;
@@ -1293,18 +1302,18 @@ void CTI::privateCompileMainPass()
             // we check that the sum of the three type codes from Structures is exactly 3 * ObjectType,
             // this works because NumberType and StringType are smaller
             __ movl_i32r(3 * ObjectType, X86::ecx);
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::eax);
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
-            __ subl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::eax, X86::ecx);
-            __ subl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::edx, X86::ecx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::eax);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
+            __ subl_mr(FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::eax, X86::ecx);
+            __ subl_mr(FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::edx, X86::ecx);
             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::edx, i); // reload baseVal
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
-            __ cmpl_rm(X86::ecx, OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::edx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
+            __ cmpl_rm(X86::ecx, FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::edx);
 
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
 
             // check that baseVal's flags include ImplementsHasInstance but not OverridesHasInstance
-            __ movl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::edx, X86::ecx);
+            __ movl_mr(FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::edx, X86::ecx);
             __ andl_i32r(ImplementsHasInstance | OverridesHasInstance, X86::ecx);
             __ cmpl_i32r(ImplementsHasInstance, X86::ecx);
 
@@ -1316,17 +1325,17 @@ void CTI::privateCompileMainPass()
             // optimistically load true result
             __ movl_i32r(asInteger(jsBoolean(true)), X86::eax);
 
-            X86Assembler::JmpDst loop = __ label();
+            JmpDst loop = __ label();
 
             // load value's prototype
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
-            __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
+            __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
             
             __ cmpl_rr(X86::ecx, X86::edx);
-            X86Assembler::JmpSrc exit = __ emitUnlinkedJe();
+            JmpSrc exit = __ emitUnlinkedJe();
 
             __ cmpl_i32r(asInteger(jsNull()), X86::ecx);
-            X86Assembler::JmpSrc goToLoop = __ emitUnlinkedJne();
+            JmpSrc goToLoop = __ emitUnlinkedJne();
             __ link(goToLoop, loop);
 
             __ movl_i32r(asInteger(jsBoolean(false)), X86::eax);
@@ -1342,7 +1351,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, BytecodeInterpreter::cti_op_del_by_id);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_del_by_id);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -1381,7 +1390,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, BytecodeInterpreter::cti_op_new_func);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_new_func);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -1414,9 +1423,9 @@ void CTI::privateCompileMainPass()
 
             emitGetVirtualRegister(RegisterFile::ScopeChain, X86::eax, i);
             while (skip--)
-                __ movl_mr(OBJECT_OFFSET(ScopeChainNode, next), X86::eax, X86::eax);
+                __ movl_mr(FIELD_OFFSET(ScopeChainNode, next), X86::eax, X86::eax);
 
-            __ movl_mr(OBJECT_OFFSET(ScopeChainNode, object), X86::eax, X86::eax);
+            __ movl_mr(FIELD_OFFSET(ScopeChainNode, object), X86::eax, X86::eax);
             emitGetVariableObjectRegister(X86::eax, instruction[i + 2].u.operand, X86::eax);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
@@ -1428,28 +1437,28 @@ void CTI::privateCompileMainPass()
             emitGetVirtualRegister(RegisterFile::ScopeChain, X86::edx, i);
             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::eax, i);
             while (skip--)
-                __ movl_mr(OBJECT_OFFSET(ScopeChainNode, next), X86::edx, X86::edx);
+                __ movl_mr(FIELD_OFFSET(ScopeChainNode, next), X86::edx, X86::edx);
 
-            __ movl_mr(OBJECT_OFFSET(ScopeChainNode, object), X86::edx, X86::edx);
+            __ movl_mr(FIELD_OFFSET(ScopeChainNode, object), X86::edx, X86::edx);
             emitPutVariableObjectRegister(X86::eax, X86::edx, instruction[i + 1].u.operand);
             i += 4;
             break;
         }
         case op_tear_off_activation: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_tear_off_activation);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_tear_off_activation);
             i += 2;
             break;
         }
         case op_tear_off_arguments: {
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_tear_off_arguments);
+            emitCTICall(instruction + i, i, Interpreter::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, BytecodeInterpreter::cti_op_ret_scopeChain);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_ret_scopeChain);
 
             // Return the result in %eax.
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
@@ -1471,7 +1480,7 @@ void CTI::privateCompileMainPass()
             __ 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, BytecodeInterpreter::cti_op_new_array);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_new_array);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -1479,7 +1488,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, BytecodeInterpreter::cti_op_resolve);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_resolve);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -1488,10 +1497,10 @@ void CTI::privateCompileMainPass()
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
 
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
-            X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJne();
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
-            X86Assembler::JmpSrc isObject = __ emitUnlinkedJe();
+            JmpSrc isImmediate = __ emitUnlinkedJne();
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
+            JmpSrc isObject = __ emitUnlinkedJe();
 
             __ link(isImmediate, __ label());
             emitGetVirtualRegister(instruction[i + 2].u.operand, X86::eax, i);
@@ -1511,12 +1520,12 @@ void CTI::privateCompileMainPass()
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
 
             // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
-            __ movl_mr(OBJECT_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
+            __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
+            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJbe(), i));
 
             // Get the value from the vector
-            __ movl_mr(OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::eax);
+            __ movl_mr(FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::eax);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -1524,7 +1533,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, BytecodeInterpreter::cti_op_resolve_func);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_func);
             emitPutVirtualRegister(instruction[i + 2].u.operand, X86::edx);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
@@ -1545,22 +1554,22 @@ void CTI::privateCompileMainPass()
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
 
             // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
-            __ movl_mr(OBJECT_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
-            X86Assembler::JmpSrc inFastVector = __ emitUnlinkedJa();
+            __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
+            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
+            JmpSrc inFastVector = __ emitUnlinkedJa();
             // No; oh well, check if the access if within the vector - if so, we may still be okay.
-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
+            __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJbe(), i));
 
             // This is a write to the slow part of the vector; first, we have to check if this would be the first write to this location.
             // FIXME: should be able to handle initial write to array; increment the the number of items in the array, and potentially update fast access cutoff. 
-            __ cmpl_i8m(0, OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
+            __ cmpl_i8m(0, FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), i));
 
             // All good - put the value into the array.
             __ link(inFastVector, __ label());
             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::eax, i);
-            __ movl_rm(X86::eax, OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
+            __ movl_rm(X86::eax, FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
             i += 4;
             break;
         }
@@ -1572,7 +1581,7 @@ void CTI::privateCompileMainPass()
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
 
             __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
-            X86Assembler::JmpSrc isZero = __ emitUnlinkedJe();
+            JmpSrc isZero = __ emitUnlinkedJe();
             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
             m_jmpTable.append(JmpTable(__ emitUnlinkedJne(), i + 2 + target));
 
@@ -1588,7 +1597,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, BytecodeInterpreter::cti_op_resolve_base);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_base);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -1598,22 +1607,22 @@ void CTI::privateCompileMainPass()
             emitGetVirtualRegister(srcVReg, X86::eax, i);
 
             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
-            X86Assembler::JmpSrc notImmediate = __ emitUnlinkedJe();
+            JmpSrc notImmediate = __ emitUnlinkedJe();
 
             __ cmpl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
-            X86Assembler::JmpSrc zeroImmediate = __ emitUnlinkedJe();
+            JmpSrc zeroImmediate = __ emitUnlinkedJe();
             emitFastArithImmToInt(X86::eax);
             __ negl_r(X86::eax); // This can't overflow as we only have a 31bit int at this point
-            X86Assembler::JmpSrc overflow = emitArithIntToImmWithJump(X86::eax);
+            JmpSrc overflow = emitArithIntToImmWithJump(X86::eax);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
-            X86Assembler::JmpSrc immediateNegateSuccess = __ emitUnlinkedJmp();
+            JmpSrc immediateNegateSuccess = __ emitUnlinkedJmp();
 
             if (!isSSE2Present()) {
                 __ link(zeroImmediate, __ label());
                 __ link(overflow, __ label());
                 __ link(notImmediate, __ label());
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_negate);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_negate);
                 emitPutVirtualRegister(instruction[i + 1].u.operand);
             } else {
                 // Slow case immediates
@@ -1624,14 +1633,14 @@ void CTI::privateCompileMainPass()
                 if (!resultType.definitelyIsNumber()) {
                     emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
                     Structure* numberStructure = m_globalData->numberStructure.get();
-                    __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+                    __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
                     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
                 }
-                __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
+                __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
                 // We need 3 copies of the sign bit mask so we can assure alignment and pad for the 128bit load
                 static double doubleSignBit[] = { -0.0, -0.0, -0.0 };
                 __ xorpd_mr((void*)((((uintptr_t)doubleSignBit)+15)&~15), X86::xmm0);
-                X86Assembler::JmpSrc wasCell;
+                JmpSrc wasCell;
                 if (!resultType.isReusableNumber())
                     emitAllocateNumber(m_globalData, i);
 
@@ -1647,7 +1656,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, BytecodeInterpreter::cti_op_resolve_skip);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_skip);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -1662,22 +1671,22 @@ void CTI::privateCompileMainPass()
             // Check Structure of global object
             __ movl_i32r(globalObject, X86::eax);
             __ movl_mr(structureAddress, X86::edx);
-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
-            X86Assembler::JmpSrc noMatch = __ emitUnlinkedJne(); // Structures don't match
+            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSCell, m_structure), X86::eax);
+            JmpSrc noMatch = __ emitUnlinkedJne(); // Structures don't match
 
             // Load cached property
-            __ movl_mr(OBJECT_OFFSET(JSGlobalObject, m_propertyStorage), X86::eax, X86::eax);
+            __ movl_mr(FIELD_OFFSET(JSGlobalObject, m_propertyStorage), X86::eax, X86::eax);
             __ movl_mr(offsetAddr, X86::edx);
             __ movl_mr(0, X86::eax, X86::edx, sizeof(JSValue*), X86::eax);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
-            X86Assembler::JmpSrc end = __ emitUnlinkedJmp();
+            JmpSrc end = __ emitUnlinkedJmp();
 
             // Slow case
             __ link(noMatch, __ label());
             emitPutCTIArgConstant(globalObject, 0);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(ident), 4);
             emitPutCTIArgConstant(reinterpret_cast<unsigned>(instruction + i), 8);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_resolve_global);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_global);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             __ link(end, __ label());
             i += 6;
@@ -1729,7 +1738,7 @@ void CTI::privateCompileMainPass()
             __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
             m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
-            X86Assembler::JmpSrc isNonZero = __ emitUnlinkedJne();
+            JmpSrc isNonZero = __ emitUnlinkedJne();
 
             __ cmpl_i32r(asInteger(JSImmediate::falseImmediate()), X86::eax);
             m_jmpTable.append(JmpTable(__ emitUnlinkedJe(), i + 2 + target));
@@ -1746,13 +1755,13 @@ void CTI::privateCompileMainPass()
 
             emitGetVirtualRegister(src, X86::eax, i);
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
-            X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
+            JmpSrc isImmediate = __ emitUnlinkedJnz();
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
             __ setnz_r(X86::eax);
 
-            X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
+            JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
 
             __ link(isImmediate, __ label());
 
@@ -1776,13 +1785,13 @@ void CTI::privateCompileMainPass()
 
             emitGetVirtualRegister(src, X86::eax, i);
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
-            X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
+            JmpSrc isImmediate = __ emitUnlinkedJnz();
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
             __ setz_r(X86::eax);
 
-            X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
+            JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
 
             __ link(isImmediate, __ label());
 
@@ -1823,9 +1832,9 @@ void CTI::privateCompileMainPass()
             int retAddrDst = instruction[i + 1].u.operand;
             int target = instruction[i + 2].u.operand;
             __ movl_i32m(0, sizeof(Register) * retAddrDst, X86::edi);
-            X86Assembler::JmpDst addrPosition = __ label();
+            JmpDst addrPosition = __ label();
             m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 2 + target));
-            X86Assembler::JmpDst sretTarget = __ label();
+            JmpDst sretTarget = __ label();
             m_jsrSites.append(JSRInfo(addrPosition, sretTarget));
             i += 3;
             break;
@@ -1903,7 +1912,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, BytecodeInterpreter::cti_op_resolve_with_base);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_resolve_with_base);
             emitPutVirtualRegister(instruction[i + 2].u.operand, X86::edx);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
@@ -1912,7 +1921,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, BytecodeInterpreter::cti_op_new_func_exp);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_new_func_exp);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -1936,7 +1945,7 @@ void CTI::privateCompileMainPass()
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
 
             __ cmpl_i32r(asInteger(JSImmediate::zeroImmediate()), X86::eax);
-            X86Assembler::JmpSrc isZero = __ emitUnlinkedJe();
+            JmpSrc isZero = __ emitUnlinkedJe();
             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
             m_jmpTable.append(JmpTable(__ emitUnlinkedJne(), i + 2 + target));
 
@@ -1989,7 +1998,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, BytecodeInterpreter::cti_op_new_regexp);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_new_regexp);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -2004,7 +2013,7 @@ void CTI::privateCompileMainPass()
         }
         case op_throw: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_throw);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_throw);
             __ addl_i8r(0x20, X86::esp);
             __ popl_r(X86::ebx);
             __ popl_r(X86::edi);
@@ -2015,7 +2024,7 @@ void CTI::privateCompileMainPass()
         }
         case op_get_pnames: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_get_pnames);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_get_pnames);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -2023,9 +2032,9 @@ 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, BytecodeInterpreter::cti_op_next_pname);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_next_pname);
             __ testl_rr(X86::eax, X86::eax);
-            X86Assembler::JmpSrc endOfIter = __ emitUnlinkedJe();
+            JmpSrc endOfIter = __ emitUnlinkedJe();
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 3 + target));
             __ link(endOfIter, __ label());
@@ -2034,12 +2043,12 @@ void CTI::privateCompileMainPass()
         }
         case op_push_scope: {
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_push_scope);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_push_scope);
             i += 2;
             break;
         }
         case op_pop_scope: {
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_pop_scope);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_pop_scope);
             i += 1;
             break;
         }
@@ -2065,12 +2074,12 @@ void CTI::privateCompileMainPass()
             emitGetVirtualRegister(srcVReg, X86::eax, i);
             
             __ testl_i32r(JSImmediate::TagBitTypeInteger, X86::eax);
-            X86Assembler::JmpSrc wasImmediate = __ emitUnlinkedJnz();
+            JmpSrc wasImmediate = __ emitUnlinkedJnz();
 
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ cmpl_i32m(NumberType, OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::ecx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ cmpl_i32m(NumberType, FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::ecx);
             
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
             
@@ -2083,7 +2092,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, BytecodeInterpreter::cti_op_in);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_in);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2092,7 +2101,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, BytecodeInterpreter::cti_op_push_new_scope);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_push_new_scope);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2106,7 +2115,7 @@ void CTI::privateCompileMainPass()
         case op_jmp_scopes: {
             unsigned count = instruction[i + 1].u.operand;
             emitPutCTIArgConstant(count, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jmp_scopes);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_jmp_scopes);
             unsigned target = instruction[i + 2].u.operand;
             m_jmpTable.append(JmpTable(__ emitUnlinkedJmp(), i + 2 + target));
             i += 3;
@@ -2116,7 +2125,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, BytecodeInterpreter::cti_op_put_by_index);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_index);
             i += 4;
             break;
         }
@@ -2132,7 +2141,7 @@ void CTI::privateCompileMainPass()
 
             emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
             emitPutCTIArgConstant(tableIndex, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_switch_imm);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_switch_imm);
             __ jmp_r(X86::eax);
             i += 4;
             break;
@@ -2149,7 +2158,7 @@ void CTI::privateCompileMainPass()
 
             emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
             emitPutCTIArgConstant(tableIndex, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_switch_char);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_switch_char);
             __ jmp_r(X86::eax);
             i += 4;
             break;
@@ -2165,7 +2174,7 @@ void CTI::privateCompileMainPass()
 
             emitPutCTIArgFromVirtualRegister(scrutinee, 0, X86::ecx);
             emitPutCTIArgConstant(tableIndex, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_switch_string);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_switch_string);
             __ jmp_r(X86::eax);
             i += 4;
             break;
@@ -2173,7 +2182,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, BytecodeInterpreter::cti_op_del_by_val);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_del_by_val);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2183,7 +2192,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, BytecodeInterpreter::cti_op_put_getter);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_put_getter);
             i += 4;
             break;
         }
@@ -2192,7 +2201,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, BytecodeInterpreter::cti_op_put_setter);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_put_setter);
             i += 4;
             break;
         }
@@ -2201,7 +2210,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, BytecodeInterpreter::cti_op_new_error);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_new_error);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2210,7 +2219,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, BytecodeInterpreter::cti_op_debug);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_debug);
             i += 4;
             break;
         }
@@ -2220,13 +2229,13 @@ void CTI::privateCompileMainPass()
 
             emitGetVirtualRegister(src1, X86::eax, i);
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
-            X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
+            JmpSrc isImmediate = __ emitUnlinkedJnz();
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
             __ setnz_r(X86::eax);
 
-            X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
+            JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
 
             __ link(isImmediate, __ label());
 
@@ -2250,13 +2259,13 @@ void CTI::privateCompileMainPass()
 
             emitGetVirtualRegister(src1, X86::eax, i);
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
-            X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
+            JmpSrc isImmediate = __ emitUnlinkedJnz();
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
             __ setz_r(X86::eax);
 
-            X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
+            JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
 
             __ link(isImmediate, __ label());
 
@@ -2293,14 +2302,14 @@ void CTI::privateCompileMainPass()
             for (size_t j = 0; j < count; ++j)
                 emitInitRegister(j);
 
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_push_activation);
+            emitCTICall(instruction + i, i, Interpreter::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) ? BytecodeInterpreter::cti_op_create_arguments_no_params : BytecodeInterpreter::cti_op_create_arguments);
+            emitCTICall(instruction + i, i, (m_codeBlock->numParameters == 1) ? Interpreter::cti_op_create_arguments_no_params : Interpreter::cti_op_create_arguments);
             i += 1;
             break;
         }
@@ -2308,8 +2317,8 @@ void CTI::privateCompileMainPass()
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
 
             emitJumpSlowCaseIfNotJSCell(X86::eax, i);
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::edx);
-            __ testl_i32m(NeedsThisConversion, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::edx);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::edx);
+            __ testl_i32m(NeedsThisConversion, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::edx);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
 
             i += 2;
@@ -2318,9 +2327,9 @@ void CTI::privateCompileMainPass()
         case op_profile_will_call: {
             emitGetCTIParam(CTI_ARGS_profilerReference, X86::eax);
             __ cmpl_i32m(0, X86::eax);
-            X86Assembler::JmpSrc noProfiler = __ emitUnlinkedJe();
+            JmpSrc noProfiler = __ emitUnlinkedJe();
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_profile_will_call);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_profile_will_call);
             __ link(noProfiler, __ label());
 
             i += 2;
@@ -2329,9 +2338,9 @@ void CTI::privateCompileMainPass()
         case op_profile_did_call: {
             emitGetCTIParam(CTI_ARGS_profilerReference, X86::eax);
             __ cmpl_i32m(0, X86::eax);
-            X86Assembler::JmpSrc noProfiler = __ emitUnlinkedJe();
+            JmpSrc noProfiler = __ emitUnlinkedJe();
             emitPutCTIArgFromVirtualRegister(instruction[i + 1].u.operand, 0, X86::eax);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_profile_did_call);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_profile_did_call);
             __ link(noProfiler, __ label());
 
             i += 2;
@@ -2368,7 +2377,7 @@ void CTI::privateCompileLinkPass()
         __ link(iter->from, __ label()); \
         emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
         emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
-        emitCTICall(instruction + i, i, BytecodeInterpreter::cti_##name); \
+        emitCTICall(instruction + i, i, Interpreter::cti_##name); \
         emitPutVirtualRegister(instruction[i + 1].u.operand); \
         i += 4; \
         break; \
@@ -2380,7 +2389,7 @@ void CTI::privateCompileLinkPass()
         __ link((++iter)->from, __ label());                \
         emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx); \
         emitPutCTIArgFromVirtualRegister(instruction[i + 3].u.operand, 4, X86::ecx); \
-        emitCTICall(instruction + i, i, BytecodeInterpreter::cti_##name); \
+        emitCTICall(instruction + i, i, Interpreter::cti_##name); \
         emitPutVirtualRegister(instruction[i + 1].u.operand); \
         i += 4; \
         break; \
@@ -2406,7 +2415,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
             __ link((++iter)->from, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_convert_this);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_convert_this);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 2;
             break;
@@ -2416,22 +2425,22 @@ void CTI::privateCompileSlowCases()
             unsigned src1 = instruction[i + 2].u.operand;
             unsigned src2 = instruction[i + 3].u.operand;
             if (JSValue* value = getConstantImmediateNumericArg(src1)) {
-                X86Assembler::JmpSrc notImm = iter->from;
+                JmpSrc notImm = iter->from;
                 __ link((++iter)->from, __ label());
                 __ subl_i32r(getDeTaggedConstantImmediate(value), X86::eax);
                 __ link(notImm, __ label());
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::eax, 4);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_add);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_add);
                 emitPutVirtualRegister(dst);
             } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
-                X86Assembler::JmpSrc notImm = iter->from;
+                JmpSrc notImm = iter->from;
                 __ link((++iter)->from, __ label());
                 __ subl_i32r(getDeTaggedConstantImmediate(value), X86::eax);
                 __ link(notImm, __ label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_add);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_add);
                 emitPutVirtualRegister(dst);
             } else {
                 OperandTypes types = OperandTypes::fromInt(instruction[i + 4].u.operand);
@@ -2446,27 +2455,27 @@ void CTI::privateCompileSlowCases()
         }
         case op_get_by_val: {
             // The slow case that handles accesses to arrays (below) may jump back up to here. 
-            X86Assembler::JmpDst beginGetByValSlow = __ label();
+            JmpDst beginGetByValSlow = __ label();
 
-            X86Assembler::JmpSrc notImm = iter->from;
+            JmpSrc notImm = iter->from;
             __ link((++iter)->from, __ label());
             __ link((++iter)->from, __ label());
             emitFastArithIntToImmNoCheck(X86::edx);
             __ link(notImm, __ label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_get_by_val);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_get_by_val);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             __ link(__ emitUnlinkedJmp(), m_labels[i + 4]);
 
             // This is slow case that handles accesses to arrays above the fast cut-off.
             // First, check if this is an access to the vector
             __ link((++iter)->from, __ label());
-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
+            __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
             __ link(__ emitUnlinkedJbe(), beginGetByValSlow);
 
             // okay, missed the fast region, but it is still in the vector.  Get the value.
-            __ movl_mr(OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::ecx);
+            __ movl_mr(FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::ecx);
             // Check whether the value loaded is zero; if so we need to return undefined.
             __ testl_rr(X86::ecx, X86::ecx);
             __ link(__ emitUnlinkedJe(), beginGetByValSlow);
@@ -2492,7 +2501,7 @@ void CTI::privateCompileSlowCases()
             }
 
             emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 0, X86::ecx);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_negate);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_negate);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2502,21 +2511,21 @@ void CTI::privateCompileSlowCases()
             __ link((++iter)->from, __ label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::ecx, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_rshift);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_rshift);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
         }
         case op_lshift: {
-            X86Assembler::JmpSrc notImm1 = iter->from;
-            X86Assembler::JmpSrc notImm2 = (++iter)->from;
+            JmpSrc notImm1 = iter->from;
+            JmpSrc notImm2 = (++iter)->from;
             __ link((++iter)->from, __ label());
             emitGetVirtualRegisters(instruction[i + 2].u.operand, X86::eax, instruction[i + 3].u.operand, X86::ecx, i);
             __ link(notImm1, __ label());
             __ link(notImm2, __ label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::ecx, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_lshift);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_lshift);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2530,7 +2539,7 @@ void CTI::privateCompileSlowCases()
                 __ link(iter->from, __ label());
                 emitPutCTIArg(X86::edx, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_loop_if_less);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_less);
                 __ testl_rr(X86::eax, X86::eax);
                 __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
             } else {
@@ -2538,7 +2547,7 @@ void CTI::privateCompileSlowCases()
                 __ link((++iter)->from, __ label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_loop_if_less);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_less);
                 __ testl_rr(X86::eax, X86::eax);
                 __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
             }
@@ -2554,7 +2563,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, BytecodeInterpreter::cti_op_put_by_id);
+            JmpSrc call = emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_id);
 
             // Track the location of the call; this will be used to recover repatch information.
             ASSERT(m_codeBlock->propertyAccessInstructions[propertyAccessInstructionIndex].bytecodeIndex == i);
@@ -2576,13 +2585,13 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
 
 #ifndef NDEBUG
-            X86Assembler::JmpDst coldPathBegin = __ label();
+            JmpDst coldPathBegin = __ label();
 #endif        
             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, BytecodeInterpreter::cti_op_get_by_id);
-            ASSERT(X86Assembler::getDifferenceBetweenLabels(coldPathBegin, call) == repatchOffsetGetByIdSlowCaseCall);
+            JmpSrc call = emitCTICall(instruction + i, i, Interpreter::cti_op_get_by_id);
+            ASSERT(__ getDifferenceBetweenLabels(coldPathBegin, call) == repatchOffsetGetByIdSlowCaseCall);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
 
             // Track the location of the call; this will be used to recover repatch information.
@@ -2602,7 +2611,7 @@ void CTI::privateCompileSlowCases()
                 __ link(iter->from, __ label());
                 emitPutCTIArg(X86::edx, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_loop_if_lesseq);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_lesseq);
                 __ testl_rr(X86::eax, X86::eax);
                 __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
             } else {
@@ -2610,7 +2619,7 @@ void CTI::privateCompileSlowCases()
                 __ link((++iter)->from, __ label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_loop_if_lesseq);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_loop_if_lesseq);
                 __ testl_rr(X86::eax, X86::eax);
                 __ link(__ emitUnlinkedJne(), m_labels[i + 3 + target]);
             }
@@ -2619,19 +2628,19 @@ void CTI::privateCompileSlowCases()
         }
         case op_pre_inc: {
             unsigned srcDst = instruction[i + 1].u.operand;
-            X86Assembler::JmpSrc notImm = iter->from;
+            JmpSrc notImm = iter->from;
             __ link((++iter)->from, __ label());
             __ subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
             __ link(notImm, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_pre_inc);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_pre_inc);
             emitPutVirtualRegister(srcDst);
             i += 2;
             break;
         }
         case op_put_by_val: {
             // Normal slow cases - either is not an immediate imm, or is an array.
-            X86Assembler::JmpSrc notImm = iter->from;
+            JmpSrc notImm = iter->from;
             __ link((++iter)->from, __ label());
             __ link((++iter)->from, __ label());
             emitFastArithIntToImmNoCheck(X86::edx);
@@ -2640,7 +2649,7 @@ void CTI::privateCompileSlowCases()
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
             emitPutCTIArg(X86::ecx, 8);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_put_by_val);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_val);
             __ link(__ emitUnlinkedJmp(), m_labels[i + 4]);
 
             // slow cases for immediate int accesses to arrays
@@ -2650,7 +2659,7 @@ void CTI::privateCompileSlowCases()
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
             emitPutCTIArg(X86::ecx, 8);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_put_by_val_array);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_put_by_val_array);
 
             i += 4;
             break;
@@ -2660,7 +2669,7 @@ void CTI::privateCompileSlowCases()
 
             __ link(iter->from, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jtrue);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
             __ testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
             __ link(__ emitUnlinkedJne(), m_labels[i + 2 + target]);
@@ -2669,12 +2678,12 @@ void CTI::privateCompileSlowCases()
         }
         case op_pre_dec: {
             unsigned srcDst = instruction[i + 1].u.operand;
-            X86Assembler::JmpSrc notImm = iter->from;
+            JmpSrc notImm = iter->from;
             __ link((++iter)->from, __ label());
             __ addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
             __ link(notImm, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_pre_dec);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_pre_dec);
             emitPutVirtualRegister(srcDst);
             i += 2;
             break;
@@ -2686,7 +2695,7 @@ void CTI::privateCompileSlowCases()
                 __ link(iter->from, __ label());
                 emitPutCTIArg(X86::edx, 0);
                 emitPutCTIArgFromVirtualRegister(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jless);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_jless);
                 __ testl_rr(X86::eax, X86::eax);
                 __ link(__ emitUnlinkedJe(), m_labels[i + 3 + target]);
             } else {
@@ -2694,7 +2703,7 @@ void CTI::privateCompileSlowCases()
                 __ link((++iter)->from, __ label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArg(X86::edx, 4);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jless);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_jless);
                 __ testl_rr(X86::eax, X86::eax);
                 __ link(__ emitUnlinkedJe(), m_labels[i + 3 + target]);
             }
@@ -2705,7 +2714,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
             __ xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_not);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_not);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -2713,7 +2722,7 @@ void CTI::privateCompileSlowCases()
         case op_jfalse: {
             __ link(iter->from, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jtrue);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
             __ testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
             __ link(__ emitUnlinkedJe(), m_labels[i + 2 + target]); // inverted!
@@ -2725,7 +2734,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
             __ link((++iter)->from, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_post_inc);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_post_inc);
             emitPutVirtualRegister(srcDst, X86::edx);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
@@ -2734,7 +2743,7 @@ void CTI::privateCompileSlowCases()
         case op_bitnot: {
             __ link(iter->from, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitnot);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_bitnot);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
             break;
@@ -2747,19 +2756,19 @@ void CTI::privateCompileSlowCases()
                 __ link(iter->from, __ label());
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::eax, 4);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitand);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_bitand);
                 emitPutVirtualRegister(dst);
             } else if (getConstantImmediateNumericArg(src2)) {
                 __ link(iter->from, __ label());
                 emitPutCTIArg(X86::eax, 0);
                 emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitand);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_bitand);
                 emitPutVirtualRegister(dst);
             } else {
                 __ link(iter->from, __ label());
                 emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
                 emitPutCTIArg(X86::edx, 4);
-                emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitand);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_bitand);
                 emitPutVirtualRegister(dst);
             }
             i += 5;
@@ -2768,7 +2777,7 @@ void CTI::privateCompileSlowCases()
         case op_jtrue: {
             __ link(iter->from, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_jtrue);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_jtrue);
             __ testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
             __ link(__ emitUnlinkedJne(), m_labels[i + 2 + target]);
@@ -2780,7 +2789,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
             __ link((++iter)->from, __ label());
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_post_dec);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_post_dec);
             emitPutVirtualRegister(srcDst, X86::edx);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
@@ -2790,7 +2799,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitxor);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_bitxor);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 5;
             break;
@@ -2799,7 +2808,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_bitor);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_bitor);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 5;
             break;
@@ -2808,7 +2817,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_eq);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_eq);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2817,7 +2826,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::edx, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_neq);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_neq);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2831,14 +2840,14 @@ 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, BytecodeInterpreter::cti_op_instanceof);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_instanceof);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 5;
             break;
         }
         case op_mod: {
-            X86Assembler::JmpSrc notImm1 = iter->from;
-            X86Assembler::JmpSrc notImm2 = (++iter)->from;
+            JmpSrc notImm1 = iter->from;
+            JmpSrc notImm2 = (++iter)->from;
             __ link((++iter)->from, __ label());
             emitFastArithReTagImmediate(X86::eax);
             emitFastArithReTagImmediate(X86::ecx);
@@ -2846,7 +2855,7 @@ void CTI::privateCompileSlowCases()
             __ link(notImm2, __ label());
             emitPutCTIArg(X86::eax, 0);
             emitPutCTIArg(X86::ecx, 4);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_mod);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_mod);
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 4;
             break;
@@ -2864,7 +2873,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, BytecodeInterpreter::cti_op_mul);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_mul);
                 emitPutVirtualRegister(dst);
             } else if (src2Value && ((value = JSImmediate::intValue(src2Value)) > 0)) {
                 __ link(iter->from, __ label());
@@ -2872,7 +2881,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, BytecodeInterpreter::cti_op_mul);
+                emitCTICall(instruction + i, i, Interpreter::cti_op_mul);
                 emitPutVirtualRegister(dst);
             } else
                 compileBinaryArithOpSlowCase(instruction + i, op_mul, iter, dst, src1, src2, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
@@ -2898,13 +2907,13 @@ void CTI::privateCompileSlowCases()
 
             // Fast check for JS function.
             __ testl_i32r(JSImmediate::TagMask, X86::ecx);
-            X86Assembler::JmpSrc callLinkFailNotObject = __ emitUnlinkedJne();
+            JmpSrc callLinkFailNotObject = __ emitUnlinkedJne();
             __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsFunctionVptr), X86::ecx);
-            X86Assembler::JmpSrc callLinkFailNotJSFunction = __ emitUnlinkedJne();
+            JmpSrc callLinkFailNotJSFunction = __ emitUnlinkedJne();
 
             // First, in the case of a construct, allocate the new object.
             if (opcodeID == op_construct) {
-                emitCTICall(instruction, i, BytecodeInterpreter::cti_op_construct_JSConstruct);
+                emitCTICall(instruction, i, Interpreter::cti_op_construct_JSConstruct);
                 emitPutVirtualRegister(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
                 emitGetVirtualRegister(callee, X86::ecx, i);
             }
@@ -2918,7 +2927,7 @@ void CTI::privateCompileSlowCases()
             m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation =
                 emitNakedCall(i, m_interpreter->m_ctiVirtualCallPreLink);
 
-            X86Assembler::JmpSrc storeResultForFirstRun = __ emitUnlinkedJmp();
+            JmpSrc storeResultForFirstRun = __ emitUnlinkedJmp();
 
             // This is the address for the cold path *after* the first run (which tries to link the call).
             m_callStructureStubCompilationInfo[callLinkInfoIndex].coldPathOther = __ label();
@@ -2931,24 +2940,24 @@ void CTI::privateCompileSlowCases()
 
             // Check for JSFunctions.
             __ testl_i32r(JSImmediate::TagMask, X86::ecx);
-            X86Assembler::JmpSrc isNotObject = __ emitUnlinkedJne();
+            JmpSrc isNotObject = __ emitUnlinkedJne();
             __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsFunctionVptr), X86::ecx);
-            X86Assembler::JmpSrc isJSFunction = __ emitUnlinkedJe();
+            JmpSrc isJSFunction = __ emitUnlinkedJe();
 
             // This handles host functions
-            X86Assembler::JmpDst notJSFunctionlabel = __ label();
+            JmpDst notJSFunctionlabel = __ label();
             __ link(isNotObject, notJSFunctionlabel);
             __ link(callLinkFailNotObject, notJSFunctionlabel);
             __ link(callLinkFailNotJSFunction, notJSFunctionlabel);
-            emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? BytecodeInterpreter::cti_op_construct_NotJSConstruct : BytecodeInterpreter::cti_op_call_NotJSFunction));
-            X86Assembler::JmpSrc wasNotJSFunction = __ emitUnlinkedJmp();
+            emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? Interpreter::cti_op_construct_NotJSConstruct : Interpreter::cti_op_call_NotJSFunction));
+            JmpSrc wasNotJSFunction = __ emitUnlinkedJmp();
 
             // Next, handle JSFunctions...
             __ link(isJSFunction, __ label());
 
             // First, in the case of a construct, allocate the new object.
             if (opcodeID == op_construct) {
-                emitCTICall(instruction, i, BytecodeInterpreter::cti_op_construct_JSConstruct);
+                emitCTICall(instruction, i, Interpreter::cti_op_construct_JSConstruct);
                 emitPutVirtualRegister(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
                 emitGetVirtualRegister(callee, X86::ecx, i);
             }
@@ -2961,7 +2970,7 @@ void CTI::privateCompileSlowCases()
             emitNakedCall(i, m_interpreter->m_ctiVirtualCall);
 
             // Put the return value in dst. In the interpreter, op_ret does this.
-            X86Assembler::JmpDst storeResult = __ label();
+            JmpDst storeResult = __ label();
             __ link(wasNotJSFunction, storeResult);
             __ link(storeResultForFirstRun, storeResult);
             emitPutVirtualRegister(dst);
@@ -2980,7 +2989,7 @@ void CTI::privateCompileSlowCases()
             __ link(iter->from, __ label());
 
             emitPutCTIArg(X86::eax, 0);
-            emitCTICall(instruction + i, i, BytecodeInterpreter::cti_op_to_jsnumber);
+            emitCTICall(instruction + i, i, Interpreter::cti_op_to_jsnumber);
 
             emitPutVirtualRegister(instruction[i + 1].u.operand);
             i += 3;
@@ -3015,15 +3024,15 @@ void CTI::privateCompile()
     __ popl_r(X86::ecx);
     emitPutToCallFrameHeader(X86::ecx, RegisterFile::ReturnPC);
 
-    X86Assembler::JmpSrc slowRegisterFileCheck;
-    X86Assembler::JmpDst afterRegisterFileCheck;
+    JmpSrc slowRegisterFileCheck;
+    JmpDst afterRegisterFileCheck;
     if (m_codeBlock->codeType == FunctionCode) {
         // In the case of a fast linked call, we do not set this up in the caller.
         __ movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), RegisterFile::CodeBlock * static_cast<int>(sizeof(Register)), X86::edi);
 
         emitGetCTIParam(CTI_ARGS_registerFile, X86::eax);
         __ leal_mr(m_codeBlock->numCalleeRegisters * sizeof(Register), X86::edi, X86::edx);
-        __ cmpl_mr(OBJECT_OFFSET(RegisterFile, m_end), X86::eax, X86::edx);
+        __ cmpl_mr(FIELD_OFFSET(RegisterFile, m_end), X86::eax, X86::edx);
         slowRegisterFileCheck = __ emitUnlinkedJg();
         afterRegisterFileCheck = __ label();
     }
@@ -3034,14 +3043,14 @@ void CTI::privateCompile()
 
     if (m_codeBlock->codeType == FunctionCode) {
         __ link(slowRegisterFileCheck, __ label());
-        emitCTICall(m_codeBlock->instructions.begin(), 0, BytecodeInterpreter::cti_register_file_check);
-        X86Assembler::JmpSrc backToBody = __ emitUnlinkedJmp();
+        emitCTICall(m_codeBlock->instructions.begin(), 0, Interpreter::cti_register_file_check);
+        JmpSrc backToBody = __ emitUnlinkedJmp();
         __ link(backToBody, afterRegisterFileCheck);
     }
 
     ASSERT(m_jmpTable.isEmpty());
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
 
     // Translate vPC offsets into addresses in JIT generated code, for switch tables.
@@ -3077,25 +3086,25 @@ void CTI::privateCompile()
 
     for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
         if (iter->to)
-            X86Assembler::link(code, iter->from, iter->to);
+            __ link(code, iter->from, iter->to);
         m_codeBlock->ctiReturnAddressVPCMap.add(__ getRelocatedAddress(code, iter->from), iter->bytecodeIndex);
     }
 
     // Link absolute addresses for jsr
     for (Vector<JSRInfo>::iterator iter = m_jsrSites.begin(); iter != m_jsrSites.end(); ++iter)
-        X86Assembler::linkAbsoluteAddress(code, iter->addrPosition, iter->target);
+        __ linkAbsoluteAddress(code, iter->addrPosition, iter->target);
 
     for (unsigned i = 0; i < m_codeBlock->propertyAccessInstructions.size(); ++i) {
         StructureStubInfo& info = m_codeBlock->propertyAccessInstructions[i];
-        info.callReturnLocation = X86Assembler::getRelocatedAddress(code, m_propertyAccessCompilationInfo[i].callReturnLocation);
-        info.hotPathBegin = X86Assembler::getRelocatedAddress(code, m_propertyAccessCompilationInfo[i].hotPathBegin);
+        info.callReturnLocation = __ getRelocatedAddress(code, m_propertyAccessCompilationInfo[i].callReturnLocation);
+        info.hotPathBegin = __ getRelocatedAddress(code, m_propertyAccessCompilationInfo[i].hotPathBegin);
     }
     for (unsigned i = 0; i < m_codeBlock->callLinkInfos.size(); ++i) {
         CallLinkInfo& info = m_codeBlock->callLinkInfos[i];
-        info.callReturnLocation = X86Assembler::getRelocatedAddress(code, m_callStructureStubCompilationInfo[i].callReturnLocation);
-        info.hotPathBegin = X86Assembler::getRelocatedAddress(code, m_callStructureStubCompilationInfo[i].hotPathBegin);
-        info.hotPathOther = X86Assembler::getRelocatedAddress(code, m_callStructureStubCompilationInfo[i].hotPathOther);
-        info.coldPathOther = X86Assembler::getRelocatedAddress(code, m_callStructureStubCompilationInfo[i].coldPathOther);
+        info.callReturnLocation = __ getRelocatedAddress(code, m_callStructureStubCompilationInfo[i].callReturnLocation);
+        info.hotPathBegin = __ getRelocatedAddress(code, m_callStructureStubCompilationInfo[i].hotPathBegin);
+        info.hotPathOther = __ getRelocatedAddress(code, m_callStructureStubCompilationInfo[i].hotPathOther);
+        info.coldPathOther = __ getRelocatedAddress(code, m_callStructureStubCompilationInfo[i].coldPathOther);
     }
 
     m_codeBlock->ctiCode = code;
@@ -3105,20 +3114,20 @@ void CTI::privateCompileGetByIdSelf(Structure* structure, size_t cachedOffset, v
 {
     // Check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
-    X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
+    JmpSrc failureCases1 = __ emitUnlinkedJne();
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
+    JmpSrc failureCases2 = __ emitUnlinkedJne();
 
     // Checks out okay! - getDirectOffset
-    __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
     __ movl_mr(cachedOffset * sizeof(JSValue*), X86::eax, X86::eax);
     __ ret();
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
 
-    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));
+    __ link(code, failureCases1, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, failureCases2, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
     
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
     
@@ -3131,7 +3140,7 @@ void CTI::privateCompileGetByIdProto(Structure* structure, Structure* prototypeS
     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*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
 
     // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a Structure that is
     // referencing the prototype object - let's speculatively load it's table nice and early!)
@@ -3141,32 +3150,32 @@ void CTI::privateCompileGetByIdProto(Structure* structure, Structure* prototypeS
 
     // check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
-    X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
+    JmpSrc failureCases1 = __ emitUnlinkedJne();
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
+    JmpSrc failureCases2 = __ emitUnlinkedJne();
 
     // Check the prototype object's Structure had not changed.
     Structure** prototypeStructureAddress = &(protoObject->m_structure);
     __ cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructure), static_cast<void*>(prototypeStructureAddress));
-    X86Assembler::JmpSrc failureCases3 = __ emitUnlinkedJne();
+    JmpSrc failureCases3 = __ emitUnlinkedJne();
 
     // Checks out okay! - getDirectOffset
     __ movl_mr(cachedOffset * sizeof(JSValue*), X86::edx, X86::eax);
 
-    X86Assembler::JmpSrc success = __ emitUnlinkedJmp();
+    JmpSrc success = __ emitUnlinkedJmp();
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
 
     // Use the repatch information to link the failure cases back to the original slow case routine.
     void* slowCaseBegin = reinterpret_cast<char*>(info.callReturnLocation) - repatchOffsetGetByIdSlowCaseCall;
-    X86Assembler::link(code, failureCases1, slowCaseBegin);
-    X86Assembler::link(code, failureCases2, slowCaseBegin);
-    X86Assembler::link(code, failureCases3, slowCaseBegin);
+    __ link(code, failureCases1, slowCaseBegin);
+    __ link(code, failureCases2, slowCaseBegin);
+    __ link(code, failureCases3, slowCaseBegin);
 
     // On success return back to the hot patch code, at a point it will perform the store to dest for us.
     intptr_t successDest = (intptr_t)(info.hotPathBegin) + repatchOffsetGetByIdPropertyMapOffset;
-    X86Assembler::link(code, success, reinterpret_cast<void*>(successDest));
+    __ link(code, success, reinterpret_cast<void*>(successDest));
 
     // Track the stub we have created so that it will be deleted later.
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
@@ -3174,7 +3183,7 @@ void CTI::privateCompileGetByIdProto(Structure* structure, Structure* prototypeS
     // Finally repatch the jump to sow case back in the hot path to jump here instead.
     // FIXME: should revert this repatching, on failure.
     intptr_t jmpLocation = reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetGetByIdBranchToSlowCase;
-    X86Assembler::repatchBranchOffset(jmpLocation, code);
+    __ repatchBranchOffset(jmpLocation, code);
 #else
     // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a Structure that is
     // referencing the prototype object - let's speculatively load it's table nice and early!)
@@ -3184,26 +3193,26 @@ void CTI::privateCompileGetByIdProto(Structure* structure, Structure* prototypeS
 
     // check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
-    X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
+    JmpSrc failureCases1 = __ emitUnlinkedJne();
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
+    JmpSrc failureCases2 = __ emitUnlinkedJne();
 
     // Check the prototype object's Structure had not changed.
     Structure** prototypeStructureAddress = &(protoObject->m_structure);
     __ cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructure), static_cast<void*>(prototypeStructureAddress));
-    X86Assembler::JmpSrc failureCases3 = __ emitUnlinkedJne();
+    JmpSrc failureCases3 = __ emitUnlinkedJne();
 
     // Checks out okay! - getDirectOffset
     __ movl_mr(cachedOffset * sizeof(JSValue*), X86::edx, X86::eax);
 
     __ ret();
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
 
-    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));
+    __ link(code, failureCases1, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, failureCases2, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, failureCases3, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
 
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
 
@@ -3215,12 +3224,12 @@ void CTI::privateCompileGetByIdChain(Structure* structure, StructureChain* chain
 {
     ASSERT(count);
     
-    Vector<X86Assembler::JmpSrc> bucketsOfFail;
+    Vector<JmpSrc> bucketsOfFail;
 
     // Check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
     bucketsOfFail.append(__ emitUnlinkedJne());
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
     bucketsOfFail.append(__ emitUnlinkedJne());
 
     Structure* currStructure = structure;
@@ -3244,11 +3253,11 @@ void CTI::privateCompileGetByIdChain(Structure* structure, StructureChain* chain
 
     bucketsOfFail.append(__ emitUnlinkedJmp());
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
 
     for (unsigned i = 0; i < bucketsOfFail.size(); ++i)
-        X86Assembler::link(code, bucketsOfFail[i], reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+        __ link(code, bucketsOfFail[i], reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
 
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
 
@@ -3259,20 +3268,20 @@ void CTI::privateCompilePutByIdReplace(Structure* structure, size_t cachedOffset
 {
     // check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
-    X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
+    JmpSrc failureCases1 = __ emitUnlinkedJne();
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
+    JmpSrc failureCases2 = __ emitUnlinkedJne();
 
     // checks out okay! - putDirectOffset
-    __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
     __ movl_rm(X86::edx, cachedOffset * sizeof(JSValue*), X86::eax);
     __ ret();
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
     
-    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));
+    __ link(code, failureCases1, reinterpret_cast<void*>(Interpreter::cti_op_put_by_id_fail));
+    __ link(code, failureCases2, reinterpret_cast<void*>(Interpreter::cti_op_put_by_id_fail));
 
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
     
@@ -3296,20 +3305,20 @@ static inline bool transitionWillNeedStorageRealloc(Structure* oldStructure, Str
 
 void CTI::privateCompilePutByIdTransition(Structure* oldStructure, Structure* newStructure, size_t cachedOffset, StructureChain* chain, void* returnAddress)
 {
-    Vector<X86Assembler::JmpSrc, 16> failureCases;
+    Vector<JmpSrc, 16> failureCases;
     // check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
     failureCases.append(__ emitUnlinkedJne());
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(oldStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(oldStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
     failureCases.append(__ emitUnlinkedJne());
-    Vector<X86Assembler::JmpSrc> successCases;
+    Vector<JmpSrc> successCases;
 
     //  ecx = baseObject
-    __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+    __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
     // proto(ecx) = baseObject->structure()->prototype()
-    __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
+    __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
     failureCases.append(__ emitUnlinkedJne());
-    __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
+    __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
     
     // ecx = baseObject->m_structure
     for (RefPtr<Structure>* it = chain->head(); *it; ++it) {
@@ -3318,20 +3327,20 @@ void CTI::privateCompilePutByIdTransition(Structure* oldStructure, Structure* ne
         successCases.append(__ emitUnlinkedJe());
 
         // Check the structure id
-        __ cmpl_i32m(reinterpret_cast<uint32_t>(it->get()), OBJECT_OFFSET(JSCell, m_structure), X86::ecx);
+        __ cmpl_i32m(reinterpret_cast<uint32_t>(it->get()), FIELD_OFFSET(JSCell, m_structure), X86::ecx);
         failureCases.append(__ emitUnlinkedJne());
         
-        __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
-        __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
+        __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
+        __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
         failureCases.append(__ emitUnlinkedJne());
-        __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
+        __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
     }
 
     failureCases.append(__ emitUnlinkedJne());
     for (unsigned i = 0; i < successCases.size(); ++i)
         __ link(successCases[i], __ label());
 
-    X86Assembler::JmpSrc callTarget;
+    JmpSrc callTarget;
 
     // emit a call only if storage realloc is needed
     if (transitionWillNeedStorageRealloc(oldStructure, newStructure)) {
@@ -3348,15 +3357,15 @@ void CTI::privateCompilePutByIdTransition(Structure* oldStructure, Structure* ne
     // codeblock should ensure oldStructure->m_refCount > 0
     __ subl_i8m(1, reinterpret_cast<void*>(oldStructure));
     __ addl_i8m(1, reinterpret_cast<void*>(newStructure));
-    __ movl_i32m(reinterpret_cast<uint32_t>(newStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+    __ movl_i32m(reinterpret_cast<uint32_t>(newStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
 
     // write the value
-    __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
     __ movl_rm(X86::edx, cachedOffset * sizeof(JSValue*), X86::eax);
 
     __ ret();
     
-    X86Assembler::JmpSrc failureJump;
+    JmpSrc failureJump;
     if (failureCases.size()) {
         for (unsigned i = 0; i < failureCases.size(); ++i)
             __ link(failureCases[i], __ label());
@@ -3364,14 +3373,14 @@ void CTI::privateCompilePutByIdTransition(Structure* oldStructure, Structure* ne
         failureJump = __ emitUnlinkedJmp();
     }
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
 
     if (failureCases.size())
-        X86Assembler::link(code, failureJump, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_put_by_id_fail));
+        __ link(code, failureJump, reinterpret_cast<void*>(Interpreter::cti_op_put_by_id_fail));
 
     if (transitionWillNeedStorageRealloc(oldStructure, newStructure))
-        X86Assembler::link(code, callTarget, reinterpret_cast<void*>(resizePropertyStorage));
+        __ link(code, callTarget, reinterpret_cast<void*>(resizePropertyStorage));
     
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
     
@@ -3409,67 +3418,67 @@ void CTI::privateCompileCTIMachineTrampolines()
     
     // Check eax is an array
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    X86Assembler::JmpSrc array_failureCases1 = __ emitUnlinkedJne();
+    JmpSrc array_failureCases1 = __ emitUnlinkedJne();
     __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
-    X86Assembler::JmpSrc array_failureCases2 = __ emitUnlinkedJne();
+    JmpSrc array_failureCases2 = __ emitUnlinkedJne();
 
     // Checks out okay! - get the length from the storage
-    __ movl_mr(OBJECT_OFFSET(JSArray, m_storage), X86::eax, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(ArrayStorage, m_length), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(ArrayStorage, m_length), X86::eax, X86::eax);
 
     __ addl_rr(X86::eax, X86::eax);
-    X86Assembler::JmpSrc array_failureCases3 = __ emitUnlinkedJo();
+    JmpSrc array_failureCases3 = __ emitUnlinkedJo();
     __ addl_i8r(1, X86::eax);
     
     __ ret();
 
     // (2) The second function provides fast property access for string length
     
-    X86Assembler::JmpDst stringLengthBegin = __ align(16);
+    JmpDst stringLengthBegin = __ align(16);
 
     // Check eax is a string
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    X86Assembler::JmpSrc string_failureCases1 = __ emitUnlinkedJne();
+    JmpSrc string_failureCases1 = __ emitUnlinkedJne();
     __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsStringVptr), X86::eax);
-    X86Assembler::JmpSrc string_failureCases2 = __ emitUnlinkedJne();
+    JmpSrc string_failureCases2 = __ emitUnlinkedJne();
 
     // Checks out okay! - get the length from the Ustring.
-    __ movl_mr(OBJECT_OFFSET(JSString, m_value) + OBJECT_OFFSET(UString, m_rep), X86::eax, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(UString::Rep, len), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(JSString, m_value) + FIELD_OFFSET(UString, m_rep), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(UString::Rep, len), X86::eax, X86::eax);
 
     __ addl_rr(X86::eax, X86::eax);
-    X86Assembler::JmpSrc string_failureCases3 = __ emitUnlinkedJo();
+    JmpSrc string_failureCases3 = __ emitUnlinkedJo();
     __ addl_i8r(1, X86::eax);
     
     __ ret();
 
     // (3) Trampolines for the slow cases of op_call / op_call_eval / op_construct.
     
-    X86Assembler::JmpDst virtualCallPreLinkBegin = __ align(16);
+    JmpDst virtualCallPreLinkBegin = __ align(16);
 
     // Load the callee CodeBlock* into eax
-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
+    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
     __ testl_rr(X86::eax, X86::eax);
-    X86Assembler::JmpSrc hasCodeBlock1 = __ emitUnlinkedJne();
+    JmpSrc hasCodeBlock1 = __ emitUnlinkedJne();
     __ popl_r(X86::ebx);
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc callJSFunction1 = __ emitCall();
+    JmpSrc callJSFunction1 = __ emitCall();
     emitGetCTIArg(0, X86::ecx);
     emitGetCTIArg(8, X86::edx);
     __ pushl_r(X86::ebx);
     __ link(hasCodeBlock1, __ label());
 
     // Check argCount matches callee arity.
-    __ cmpl_rm(X86::edx, OBJECT_OFFSET(CodeBlock, numParameters), X86::eax);
-    X86Assembler::JmpSrc arityCheckOkay1 = __ emitUnlinkedJe();
+    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
+    JmpSrc arityCheckOkay1 = __ emitUnlinkedJe();
     __ popl_r(X86::ebx);
     emitPutCTIArg(X86::ebx, 4);
     emitPutCTIArg(X86::eax, 12);
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc callArityCheck1 = __ emitCall();
+    JmpSrc callArityCheck1 = __ emitCall();
     __ movl_rr(X86::edx, X86::edi);
     emitGetCTIArg(0, X86::ecx);
     emitGetCTIArg(8, X86::edx);
@@ -3482,36 +3491,36 @@ void CTI::privateCompileCTIMachineTrampolines()
     emitPutCTIArg(X86::ebx, 4);
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc callDontLazyLinkCall = __ emitCall();
+    JmpSrc callDontLazyLinkCall = __ emitCall();
     __ pushl_r(X86::ebx);
 
     __ jmp_r(X86::eax);
 
-    X86Assembler::JmpDst virtualCallLinkBegin = __ align(16);
+    JmpDst virtualCallLinkBegin = __ align(16);
 
     // Load the callee CodeBlock* into eax
-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
+    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
     __ testl_rr(X86::eax, X86::eax);
-    X86Assembler::JmpSrc hasCodeBlock2 = __ emitUnlinkedJne();
+    JmpSrc hasCodeBlock2 = __ emitUnlinkedJne();
     __ popl_r(X86::ebx);
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc callJSFunction2 = __ emitCall();
+    JmpSrc callJSFunction2 = __ emitCall();
     emitGetCTIArg(0, X86::ecx);
     emitGetCTIArg(8, X86::edx);
     __ pushl_r(X86::ebx);
     __ link(hasCodeBlock2, __ label());
 
     // Check argCount matches callee arity.
-    __ cmpl_rm(X86::edx, OBJECT_OFFSET(CodeBlock, numParameters), X86::eax);
-    X86Assembler::JmpSrc arityCheckOkay2 = __ emitUnlinkedJe();
+    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
+    JmpSrc arityCheckOkay2 = __ emitUnlinkedJe();
     __ popl_r(X86::ebx);
     emitPutCTIArg(X86::ebx, 4);
     emitPutCTIArg(X86::eax, 12);
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc callArityCheck2 = __ emitCall();
+    JmpSrc callArityCheck2 = __ emitCall();
     __ movl_rr(X86::edx, X86::edi);
     emitGetCTIArg(0, X86::ecx);
     emitGetCTIArg(8, X86::edx);
@@ -3524,36 +3533,36 @@ void CTI::privateCompileCTIMachineTrampolines()
     emitPutCTIArg(X86::ebx, 4);
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc callLazyLinkCall = __ emitCall();
+    JmpSrc callLazyLinkCall = __ emitCall();
     __ pushl_r(X86::ebx);
 
     __ jmp_r(X86::eax);
 
-    X86Assembler::JmpDst virtualCallBegin = __ align(16);
+    JmpDst virtualCallBegin = __ align(16);
 
     // Load the callee CodeBlock* into eax
-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
+    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
     __ testl_rr(X86::eax, X86::eax);
-    X86Assembler::JmpSrc hasCodeBlock3 = __ emitUnlinkedJne();
+    JmpSrc hasCodeBlock3 = __ emitUnlinkedJne();
     __ popl_r(X86::ebx);
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc callJSFunction3 = __ emitCall();
+    JmpSrc callJSFunction3 = __ emitCall();
     emitGetCTIArg(0, X86::ecx);
     emitGetCTIArg(8, X86::edx);
     __ pushl_r(X86::ebx);
     __ link(hasCodeBlock3, __ label());
 
     // Check argCount matches callee arity.
-    __ cmpl_rm(X86::edx, OBJECT_OFFSET(CodeBlock, numParameters), X86::eax);
-    X86Assembler::JmpSrc arityCheckOkay3 = __ emitUnlinkedJe();
+    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
+    JmpSrc arityCheckOkay3 = __ emitUnlinkedJe();
     __ popl_r(X86::ebx);
     emitPutCTIArg(X86::ebx, 4);
     emitPutCTIArg(X86::eax, 12);
     __ emitRestoreArgumentReference();
     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
-    X86Assembler::JmpSrc callArityCheck3 = __ emitCall();
+    JmpSrc callArityCheck3 = __ emitCall();
     __ movl_rr(X86::edx, X86::edi);
     emitGetCTIArg(0, X86::ecx);
     emitGetCTIArg(8, X86::edx);
@@ -3563,38 +3572,38 @@ void CTI::privateCompileCTIMachineTrampolines()
     compileOpCallInitializeCallFrame();
 
     // load ctiCode from the new codeBlock.
-    __ movl_mr(OBJECT_OFFSET(CodeBlock, ctiCode), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(CodeBlock, ctiCode), X86::eax, X86::eax);
 
     __ jmp_r(X86::eax);
 
     // All trampolines constructed! copy the code, link up calls, and set the pointers on the Machine object.
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
 
-    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));
+    __ link(code, array_failureCases1, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, array_failureCases2, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, array_failureCases3, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, string_failureCases1, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, string_failureCases2, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, string_failureCases3, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
+    __ link(code, callArityCheck1, reinterpret_cast<void*>(Interpreter::cti_op_call_arityCheck));
+    __ link(code, callArityCheck2, reinterpret_cast<void*>(Interpreter::cti_op_call_arityCheck));
+    __ link(code, callArityCheck3, reinterpret_cast<void*>(Interpreter::cti_op_call_arityCheck));
+    __ link(code, callJSFunction1, reinterpret_cast<void*>(Interpreter::cti_op_call_JSFunction));
+    __ link(code, callJSFunction2, reinterpret_cast<void*>(Interpreter::cti_op_call_JSFunction));
+    __ link(code, callJSFunction3, reinterpret_cast<void*>(Interpreter::cti_op_call_JSFunction));
+    __ link(code, callDontLazyLinkCall, reinterpret_cast<void*>(Interpreter::cti_vm_dontLazyLinkCall));
+    __ link(code, callLazyLinkCall, reinterpret_cast<void*>(Interpreter::cti_vm_lazyLinkCall));
 
     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);
+    m_interpreter->m_ctiStringLengthTrampoline = __ getRelocatedAddress(code, stringLengthBegin);
+    m_interpreter->m_ctiVirtualCallPreLink = __ getRelocatedAddress(code, virtualCallPreLinkBegin);
+    m_interpreter->m_ctiVirtualCallLink = __ getRelocatedAddress(code, virtualCallLinkBegin);
+    m_interpreter->m_ctiVirtualCall = __ getRelocatedAddress(code, virtualCallBegin);
 }
 
-void CTI::freeCTIMachineTrampolines(BytecodeInterpreter* interpreter)
+void CTI::freeCTIMachineTrampolines(Interpreter* interpreter)
 {
     WTF::fastFreeExecutable(interpreter->m_ctiArrayLengthTrampoline);
 }
@@ -3604,8 +3613,8 @@ void CTI::patchGetByIdSelf(CodeBlock* codeBlock, Structure* structure, size_t ca
     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 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));
+    // Should probably go to Interpreter::cti_op_get_by_id_fail, but that doesn't do anything interesting right now.
+    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_generic));
 
     // Repatch the offset into the propoerty map to load from, then repatch the Structure to look for.
     X86Assembler::repatchDisplacement(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetGetByIdPropertyMapOffset, cachedOffset * sizeof(JSValue*));
@@ -3617,8 +3626,8 @@ void CTI::patchPutByIdReplace(CodeBlock* codeBlock, Structure* structure, size_t
     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 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));
+    // Should probably go to Interpreter::cti_op_put_by_id_fail, but that doesn't do anything interesting right now.
+    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(Interpreter::cti_op_put_by_id_generic));
 
     // Repatch the offset into the propoerty map to load from, then repatch the Structure to look for.
     X86Assembler::repatchDisplacement(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetPutByIdPropertyMapOffset, cachedOffset * sizeof(JSValue*));
@@ -3630,38 +3639,38 @@ 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*>(BytecodeInterpreter::cti_op_get_by_id_fail));
+    ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(Interpreter::cti_op_get_by_id_fail));
 
     // Check eax is an array
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
-    X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
+    JmpSrc failureCases1 = __ emitUnlinkedJne();
     __ cmpl_i32m(reinterpret_cast<unsigned>(m_interpreter->m_jsArrayVptr), X86::eax);
-    X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
+    JmpSrc failureCases2 = __ emitUnlinkedJne();
 
     // Checks out okay! - get the length from the storage
-    __ movl_mr(OBJECT_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
-    __ movl_mr(OBJECT_OFFSET(ArrayStorage, m_length), X86::ecx, X86::ecx);
+    __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
+    __ movl_mr(FIELD_OFFSET(ArrayStorage, m_length), X86::ecx, X86::ecx);
 
     __ cmpl_i32r(JSImmediate::maxImmediateInt, X86::ecx);
-    X86Assembler::JmpSrc failureCases3 = __ emitUnlinkedJa();
+    JmpSrc failureCases3 = __ emitUnlinkedJa();
 
     __ addl_rr(X86::ecx, X86::ecx);
     __ addl_i8r(1, X86::ecx);
     __ movl_rr(X86::ecx, X86::eax);
-    X86Assembler::JmpSrc success = __ emitUnlinkedJmp();
+    JmpSrc success = __ emitUnlinkedJmp();
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
 
     // Use the repatch information to link the failure cases back to the original slow case routine.
     void* slowCaseBegin = reinterpret_cast<char*>(info.callReturnLocation) - repatchOffsetGetByIdSlowCaseCall;
-    X86Assembler::link(code, failureCases1, slowCaseBegin);
-    X86Assembler::link(code, failureCases2, slowCaseBegin);
-    X86Assembler::link(code, failureCases3, slowCaseBegin);
+    __ link(code, failureCases1, slowCaseBegin);
+    __ link(code, failureCases2, slowCaseBegin);
+    __ link(code, failureCases3, slowCaseBegin);
 
     // On success return back to the hot patch code, at a point it will perform the store to dest for us.
     intptr_t successDest = (intptr_t)(info.hotPathBegin) + repatchOffsetGetByIdPropertyMapOffset;
-    X86Assembler::link(code, success, reinterpret_cast<void*>(successDest));
+    __ link(code, success, reinterpret_cast<void*>(successDest));
 
     // Track the stub we have created so that it will be deleted later.
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
@@ -3669,20 +3678,20 @@ void CTI::privateCompilePatchGetArrayLength(void* returnAddress)
     // Finally repatch the jump to sow case back in the hot path to jump here instead.
     // FIXME: should revert this repatching, on failure.
     intptr_t jmpLocation = reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetGetByIdBranchToSlowCase;
-    X86Assembler::repatchBranchOffset(jmpLocation, code);
+    __ repatchBranchOffset(jmpLocation, code);
 }
 
-void CTI::emitGetVariableObjectRegister(X86Assembler::RegisterID variableObject, int index, X86Assembler::RegisterID dst)
+void CTI::emitGetVariableObjectRegister(RegisterID variableObject, int index, RegisterID dst)
 {
-    __ movl_mr(JSVariableObject::offsetOf_d(), variableObject, dst);
-    __ movl_mr(JSVariableObject::offsetOf_Data_registers(), dst, dst);
+    __ movl_mr(FIELD_OFFSET(JSVariableObject, d), variableObject, dst);
+    __ movl_mr(FIELD_OFFSET(JSVariableObject::JSVariableObjectData, registers), dst, dst);
     __ movl_mr(index * sizeof(Register), dst, dst);
 }
 
-void CTI::emitPutVariableObjectRegister(X86Assembler::RegisterID src, X86Assembler::RegisterID variableObject, int index)
+void CTI::emitPutVariableObjectRegister(RegisterID src, RegisterID variableObject, int index)
 {
-    __ movl_mr(JSVariableObject::offsetOf_d(), variableObject, variableObject);
-    __ movl_mr(JSVariableObject::offsetOf_Data_registers(), variableObject, variableObject);
+    __ movl_mr(FIELD_OFFSET(JSVariableObject, d), variableObject, src);
+    __ movl_mr(FIELD_OFFSET(JSVariableObject::JSVariableObjectData, registers), src, src);
     __ movl_rm(src, index * sizeof(Register), variableObject);
 }
 
index a1d979d..0c86978 100644 (file)
@@ -96,7 +96,7 @@ namespace JSC {
 
     class CodeBlock;
     class JSPropertyNameIterator;
-    class BytecodeInterpreter;
+    class Interpreter;
     class Register;
     class RegisterFile;
     class ScopeChainNode;
@@ -117,7 +117,9 @@ namespace JSC {
     typedef VoidPtrPair (SFX_CALL *CTIHelper_2)(CTI_ARGS);
 
     struct CallRecord {
-        X86Assembler::JmpSrc from;
+        typedef X86Assembler::JmpSrc JmpSrc;
+
+        JmpSrc from;
         void* to;
         unsigned bytecodeIndex;
 
@@ -125,56 +127,56 @@ namespace JSC {
         {
         }
 
-        CallRecord(X86Assembler::JmpSrc f, CTIHelper_j t, unsigned i)
+        CallRecord(JmpSrc f, CTIHelper_j t, unsigned i)
             : from(f)
             , to(reinterpret_cast<void*>(t))
             , bytecodeIndex(i)
         {
         }
 
-        CallRecord(X86Assembler::JmpSrc f, CTIHelper_o t, unsigned i)
+        CallRecord(JmpSrc f, CTIHelper_o t, unsigned i)
             : from(f)
             , to(reinterpret_cast<void*>(t))
             , bytecodeIndex(i)
         {
         }
 
-        CallRecord(X86Assembler::JmpSrc f, CTIHelper_p t, unsigned i)
+        CallRecord(JmpSrc f, CTIHelper_p t, unsigned i)
             : from(f)
             , to(reinterpret_cast<void*>(t))
             , bytecodeIndex(i)
         {
         }
         
-        CallRecord(X86Assembler::JmpSrc f, CTIHelper_v t, unsigned i)
+        CallRecord(JmpSrc f, CTIHelper_v t, unsigned i)
             : from(f)
             , to(reinterpret_cast<void*>(t))
             , bytecodeIndex(i)
         {
         }
         
-        CallRecord(X86Assembler::JmpSrc f, CTIHelper_s t, unsigned i)
+        CallRecord(JmpSrc f, CTIHelper_s t, unsigned i)
             : from(f)
             , to(reinterpret_cast<void*>(t))
             , bytecodeIndex(i)
         {
         }
         
-        CallRecord(X86Assembler::JmpSrc f, CTIHelper_b t, unsigned i)
+        CallRecord(JmpSrc f, CTIHelper_b t, unsigned i)
             : from(f)
             , to(reinterpret_cast<void*>(t))
             , bytecodeIndex(i)
         {
         }
 
-        CallRecord(X86Assembler::JmpSrc f, CTIHelper_2 t, unsigned i)
+        CallRecord(JmpSrc f, CTIHelper_2 t, unsigned i)
             : from(f)
             , to(reinterpret_cast<void*>(t))
             , bytecodeIndex(i)
         {
         }
 
-        CallRecord(X86Assembler::JmpSrc f, unsigned i)
+        CallRecord(JmpSrc f, unsigned i)
             : from(f)
             , to(0)
             , bytecodeIndex(i)
@@ -183,10 +185,12 @@ namespace JSC {
     };
 
     struct JmpTable {
-        X86Assembler::JmpSrc from;
+        typedef X86Assembler::JmpSrc JmpSrc;
+
+        JmpSrc from;
         unsigned to;
         
-        JmpTable(X86Assembler::JmpSrc f, unsigned t)
+        JmpTable(JmpSrc f, unsigned t)
             : from(f)
             , to(t)
         {
@@ -194,11 +198,13 @@ namespace JSC {
     };
 
     struct SlowCaseEntry {
-        X86Assembler::JmpSrc from;
+        typedef X86Assembler::JmpSrc JmpSrc;
+
+        JmpSrc from;
         unsigned to;
         unsigned hint;
         
-        SlowCaseEntry(X86Assembler::JmpSrc f, unsigned t, unsigned h = 0)
+        SlowCaseEntry(JmpSrc f, unsigned t, unsigned h = 0)
             : from(f)
             , to(t)
             , hint(h)
@@ -241,10 +247,13 @@ namespace JSC {
     };
 
     struct StructureStubCompilationInfo {
-        X86Assembler::JmpSrc callReturnLocation;
-        X86Assembler::JmpDst hotPathBegin;
-        X86Assembler::JmpSrc hotPathOther;
-        X86Assembler::JmpDst coldPathOther;
+        typedef X86Assembler::JmpSrc JmpSrc;
+        typedef X86Assembler::JmpDst JmpDst;
+
+        JmpSrc callReturnLocation;
+        JmpDst hotPathBegin;
+        JmpSrc hotPathOther;
+        JmpDst coldPathOther;
     };
 
     extern "C" {
@@ -256,6 +265,11 @@ namespace JSC {
     void ctiRepatchCallByReturnAddress(void* where, void* what);
 
     class CTI {
+        typedef X86Assembler::JmpSrc JmpSrc;
+        typedef X86Assembler::JmpDst JmpDst;
+        typedef X86Assembler::RegisterID RegisterID;
+        typedef X86Assembler::XMMRegisterID XMMRegisterID;
+
         static const int repatchGetByIdDefaultStructure = -1;
         // Magic number - initial offset cannot be representable as a signed 8bit value, or the X86Assembler
         // will compress the displacement, and we may not be able to fit a repatched offset.
@@ -324,7 +338,7 @@ namespace JSC {
             CTI cti(globalData);
             cti.privateCompileCTIMachineTrampolines();
         }
-        static void freeCTIMachineTrampolines(BytecodeInterpreter*);
+        static void freeCTIMachineTrampolines(Interpreter*);
 
         static void patchGetByIdSelf(CodeBlock* codeBlock, Structure* structure, size_t cachedOffset, void* returnAddress);
         static void patchPutByIdReplace(CodeBlock* codeBlock, Structure* structure, size_t cachedOffset, void* returnAddress);
@@ -366,64 +380,64 @@ namespace JSC {
         void compileOpConstructSetupArgs(Instruction*);
         enum CompileOpStrictEqType { OpStrictEq, OpNStrictEq };
         void compileOpStrictEq(Instruction* instruction, unsigned i, CompileOpStrictEqType type);
-        void putDoubleResultToJSNumberCellOrJSImmediate(X86::XMMRegisterID xmmSource, X86::RegisterID jsNumberCell, unsigned dst, X86Assembler::JmpSrc* wroteJSNumberCell,  X86::XMMRegisterID tempXmm, X86::RegisterID tempReg1, X86::RegisterID tempReg2);
+        void putDoubleResultToJSNumberCellOrJSImmediate(XMMRegisterID xmmSource, RegisterID jsNumberCell, unsigned dst, JmpSrc* wroteJSNumberCell,  XMMRegisterID tempXmm, RegisterID tempReg1, RegisterID tempReg2);
         void compileBinaryArithOp(OpcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
         void compileBinaryArithOpSlowCase(Instruction*, OpcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
 
-        void emitGetVirtualRegister(int src, X86Assembler::RegisterID dst, unsigned i);
-        void emitGetVirtualRegisters(int src1, X86Assembler::RegisterID dst1, int src2, X86Assembler::RegisterID dst2, unsigned i);
-        void emitPutVirtualRegister(unsigned dst, X86Assembler::RegisterID from = X86::eax);
+        void emitGetVirtualRegister(int src, RegisterID dst, unsigned i);
+        void emitGetVirtualRegisters(int src1, RegisterID dst1, int src2, RegisterID dst2, unsigned i);
+        void emitPutVirtualRegister(unsigned dst, RegisterID from = X86::eax);
 
-        void emitPutCTIArg(X86Assembler::RegisterID src, unsigned offset);
-        void emitPutCTIArgFromVirtualRegister(unsigned src, unsigned offset, X86Assembler::RegisterID scratch);
+        void emitPutCTIArg(RegisterID src, unsigned offset);
+        void emitPutCTIArgFromVirtualRegister(unsigned src, unsigned offset, RegisterID scratch);
         void emitPutCTIArgConstant(unsigned value, unsigned offset);
-        void emitGetCTIArg(unsigned offset, X86Assembler::RegisterID dst);
+        void emitGetCTIArg(unsigned offset, RegisterID dst);
 
         void emitInitRegister(unsigned dst);
 
         void emitPutCTIParam(void* value, unsigned name);
-        void emitPutCTIParam(X86Assembler::RegisterID from, unsigned name);
-        void emitGetCTIParam(unsigned name, X86Assembler::RegisterID to);
+        void emitPutCTIParam(RegisterID from, unsigned name);
+        void emitGetCTIParam(unsigned name, RegisterID to);
 
-        void emitPutToCallFrameHeader(X86Assembler::RegisterID from, RegisterFile::CallFrameHeaderEntry entry);
-        void emitGetFromCallFrameHeader(RegisterFile::CallFrameHeaderEntry entry, X86Assembler::RegisterID to);
+        void emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry);
+        void emitGetFromCallFrameHeader(RegisterFile::CallFrameHeaderEntry entry, RegisterID to);
 
         JSValue* getConstantImmediateNumericArg(unsigned src);
         unsigned getDeTaggedConstantImmediate(JSValue* imm);
 
         bool linkSlowCaseIfNotJSCell(const Vector<SlowCaseEntry>::iterator&, int vReg);
-        void emitJumpSlowCaseIfNotJSCell(X86Assembler::RegisterID, unsigned bytecodeIndex);
-        void emitJumpSlowCaseIfNotJSCell(X86Assembler::RegisterID, unsigned bytecodeIndex, int VReg);
+        void emitJumpSlowCaseIfNotJSCell(RegisterID, unsigned bytecodeIndex);
+        void emitJumpSlowCaseIfNotJSCell(RegisterID, unsigned bytecodeIndex, int VReg);
 
-        void emitJumpSlowCaseIfNotImmNum(X86Assembler::RegisterID, unsigned bytecodeIndex);
-        void emitJumpSlowCaseIfNotImmNums(X86Assembler::RegisterID, X86Assembler::RegisterID, unsigned bytecodeIndex);
+        void emitJumpSlowCaseIfNotImmNum(RegisterID, unsigned bytecodeIndex);
+        void emitJumpSlowCaseIfNotImmNums(RegisterID, RegisterID, unsigned bytecodeIndex);
 
-        void emitFastArithDeTagImmediate(X86Assembler::RegisterID);
-        X86Assembler::JmpSrc emitFastArithDeTagImmediateJumpIfZero(X86Assembler::RegisterID);
-        void emitFastArithReTagImmediate(X86Assembler::RegisterID);
-        void emitFastArithPotentiallyReTagImmediate(X86Assembler::RegisterID);
-        void emitFastArithImmToInt(X86Assembler::RegisterID);
-        void emitFastArithIntToImmOrSlowCase(X86Assembler::RegisterID, unsigned bytecodeIndex);
-        void emitFastArithIntToImmNoCheck(X86Assembler::RegisterID);
-        X86Assembler::JmpSrc emitArithIntToImmWithJump(X86Assembler::RegisterID reg);
+        void emitFastArithDeTagImmediate(RegisterID);
+        JmpSrc emitFastArithDeTagImmediateJumpIfZero(RegisterID);
+        void emitFastArithReTagImmediate(RegisterID);
+        void emitFastArithPotentiallyReTagImmediate(RegisterID);
+        void emitFastArithImmToInt(RegisterID);
+        void emitFastArithIntToImmOrSlowCase(RegisterID, unsigned bytecodeIndex);
+        void emitFastArithIntToImmNoCheck(RegisterID);
+        JmpSrc emitArithIntToImmWithJump(RegisterID reg);
 
-        void emitTagAsBoolImmediate(X86Assembler::RegisterID reg);
+        void emitTagAsBoolImmediate(RegisterID reg);
 
         void emitAllocateNumber(JSGlobalData*, unsigned);
 
-        X86Assembler::JmpSrc emitNakedCall(unsigned bytecodeIndex, X86::RegisterID);
-        X86Assembler::JmpSrc emitNakedCall(unsigned bytecodeIndex, void* function);
-        X86Assembler::JmpSrc emitNakedFastCall(unsigned bytecodeIndex, void*);
-        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_j);
-        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_o);
-        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_p);
-        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_v);
-        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_s);
-        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_b);
-        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_2);
-
-        void emitGetVariableObjectRegister(X86Assembler::RegisterID variableObject, int index, X86Assembler::RegisterID dst);
-        void emitPutVariableObjectRegister(X86Assembler::RegisterID src, X86Assembler::RegisterID variableObject, int index);
+        JmpSrc emitNakedCall(unsigned bytecodeIndex, X86::RegisterID);
+        JmpSrc emitNakedCall(unsigned bytecodeIndex, void* function);
+        JmpSrc emitNakedFastCall(unsigned bytecodeIndex, void*);
+        JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_j);
+        JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_o);
+        JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_p);
+        JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_v);
+        JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_s);
+        JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_b);
+        JmpSrc emitCTICall(Instruction*, unsigned bytecodeIndex, CTIHelper_2);
+
+        void emitGetVariableObjectRegister(RegisterID variableObject, int index, RegisterID dst);
+        void emitPutVariableObjectRegister(RegisterID src, RegisterID variableObject, int index);
         
         void emitSlowScriptCheck(Instruction*, unsigned bytecodeIndex);
 #ifndef NDEBUG
@@ -433,21 +447,21 @@ namespace JSC {
         void killLastResultRegister();
 
         X86Assembler m_assembler;
-        BytecodeInterpreter* m_interpreter;
+        Interpreter* m_interpreter;
         JSGlobalData* m_globalData;
         CodeBlock* m_codeBlock;
 
         Vector<CallRecord> m_calls;
-        Vector<X86Assembler::JmpDst> m_labels;
+        Vector<JmpDst> m_labels;
         Vector<StructureStubCompilationInfo> m_propertyAccessCompilationInfo;
         Vector<StructureStubCompilationInfo> m_callStructureStubCompilationInfo;
         Vector<JmpTable> m_jmpTable;
 
         struct JSRInfo {
-            X86Assembler::JmpDst addrPosition;
-            X86Assembler::JmpDst target;
+            JmpDst addrPosition;
+            JmpDst target;
 
-            JSRInfo(const X86Assembler::JmpDst& storeLocation, const X86Assembler::JmpDst& targetLocation)
+            JSRInfo(const JmpDst& storeLocation, const JmpDst& targetLocation)
                 : addrPosition(storeLocation)
                 , target(targetLocation)
             {
index c925f91..12895f3 100644 (file)
@@ -181,7 +181,7 @@ void CodeBlock::printStructure(const char* name, const Instruction* vPC, int ope
 
 void CodeBlock::printStructures(const Instruction* vPC) const
 {
-    BytecodeInterpreter* interpreter = globalData->interpreter;
+    Interpreter* interpreter = globalData->interpreter;
     unsigned instructionOffset = vPC - instructions.begin();
 
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id)) {
@@ -988,7 +988,7 @@ void CodeBlock::unlinkCallers()
 
 void CodeBlock::derefStructures(Instruction* vPC) const
 {
-    BytecodeInterpreter* interpreter = globalData->interpreter;
+    Interpreter* interpreter = globalData->interpreter;
 
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {
         vPC[4].u.structure->deref();
@@ -1026,7 +1026,7 @@ void CodeBlock::derefStructures(Instruction* vPC) const
 
 void CodeBlock::refStructures(Instruction* vPC) const
 {
-    BytecodeInterpreter* interpreter = globalData->interpreter;
+    Interpreter* interpreter = globalData->interpreter;
 
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {
         vPC[4].u.structure->ref();
index 9d4c5a7..6d29308 100644 (file)
@@ -177,7 +177,7 @@ static inline bool jsLess(CallFrame* callFrame, JSValue* v1, JSValue* v2)
     if (fastIsNumber(v1, n1) && fastIsNumber(v2, n2))
         return n1 < n2;
 
-    BytecodeInterpreter* interpreter = callFrame->interpreter();
+    Interpreter* interpreter = callFrame->interpreter();
     if (interpreter->isJSString(v1) && interpreter->isJSString(v2))
         return asString(v1)->value() < asString(v2)->value();
 
@@ -202,7 +202,7 @@ static inline bool jsLessEq(CallFrame* callFrame, JSValue* v1, JSValue* v2)
     if (fastIsNumber(v1, n1) && fastIsNumber(v2, n2))
         return n1 <= n2;
 
-    BytecodeInterpreter* interpreter = callFrame->interpreter();
+    Interpreter* interpreter = callFrame->interpreter();
     if (interpreter->isJSString(v1) && interpreter->isJSString(v2))
         return !(asString(v2)->value() < asString(v1)->value());
 
@@ -323,7 +323,7 @@ static bool jsIsFunctionType(JSValue* v)
     return false;
 }
 
-NEVER_INLINE bool BytecodeInterpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::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 BytecodeInterpreter::resolve(CallFrame* callFrame, Instruction
     return false;
 }
 
-NEVER_INLINE bool BytecodeInterpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     CodeBlock* codeBlock = callFrame->codeBlock();
 
@@ -384,7 +384,7 @@ NEVER_INLINE bool BytecodeInterpreter::resolveSkip(CallFrame* callFrame, Instruc
     return false;
 }
 
-NEVER_INLINE bool BytecodeInterpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::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 BytecodeInterpreter::resolveBase(CallFrame* callFrame, Instruction* vPC)
+NEVER_INLINE void Interpreter::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 BytecodeInterpreter::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::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 BytecodeInterpreter::resolveBaseAndProperty(CallFrame* callFra
     return false;
 }
 
-NEVER_INLINE bool BytecodeInterpreter::resolveBaseAndFunc(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::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 BytecodeInterpreter::resolveBaseAndFunc(CallFrame* callFrame,
     return false;
 }
 
-ALWAYS_INLINE CallFrame* BytecodeInterpreter::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argc)
+ALWAYS_INLINE CallFrame* Interpreter::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* BytecodeInterpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValue*& exceptionValue)
+NEVER_INLINE JSValue* Interpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValue*& exceptionValue)
 {
     if (argc < 2)
         return jsUndefined();
@@ -603,7 +603,7 @@ NEVER_INLINE JSValue* BytecodeInterpreter::callEval(CallFrame* callFrame, Regist
     return result;
 }
 
-BytecodeInterpreter::BytecodeInterpreter()
+Interpreter::Interpreter()
     : m_sampler(0)
 #if ENABLE(CTI)
     , m_ctiArrayLengthTrampoline(0)
@@ -641,7 +641,7 @@ BytecodeInterpreter::BytecodeInterpreter()
     fastFree(storage);
 }
 
-void BytecodeInterpreter::initialize(JSGlobalData* globalData)
+void Interpreter::initialize(JSGlobalData* globalData)
 {
 #if ENABLE(CTI)
     CTI::compileCTIMachineTrampolines(globalData);
@@ -650,7 +650,7 @@ void BytecodeInterpreter::initialize(JSGlobalData* globalData)
 #endif
 }
 
-BytecodeInterpreter::~BytecodeInterpreter()
+Interpreter::~Interpreter()
 {
 #if ENABLE(CTI)
     CTI::freeCTIMachineTrampolines(this);
@@ -659,13 +659,13 @@ BytecodeInterpreter::~BytecodeInterpreter()
 
 #ifndef NDEBUG
 
-void BytecodeInterpreter::dumpCallFrame(CallFrame* callFrame)
+void Interpreter::dumpCallFrame(CallFrame* callFrame)
 {
     callFrame->codeBlock()->dump(callFrame);
     dumpRegisters(callFrame);
 }
 
-void BytecodeInterpreter::dumpRegisters(CallFrame* callFrame)
+void Interpreter::dumpRegisters(CallFrame* callFrame)
 {
     printf("Register frame: \n\n");
     printf("----------------------------------------------------\n");
@@ -743,7 +743,7 @@ void BytecodeInterpreter::dumpRegisters(CallFrame* callFrame)
 
 #endif
 
-bool BytecodeInterpreter::isOpcode(Opcode opcode)
+bool Interpreter::isOpcode(Opcode opcode)
 {
 #if HAVE(COMPUTED_GOTO)
     return opcode != HashTraits<Opcode>::emptyValue()
@@ -754,7 +754,7 @@ bool BytecodeInterpreter::isOpcode(Opcode opcode)
 #endif
 }
 
-NEVER_INLINE bool BytecodeInterpreter::unwindCallFrame(CallFrame*& callFrame, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock)
+NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock)
 {
     CodeBlock* oldCodeBlock = codeBlock;
     ScopeChainNode* scopeChain = callFrame->scopeChain();
@@ -797,7 +797,7 @@ NEVER_INLINE bool BytecodeInterpreter::unwindCallFrame(CallFrame*& callFrame, JS
     return true;
 }
 
-NEVER_INLINE Instruction* BytecodeInterpreter::throwException(CallFrame*& callFrame, JSValue*& exceptionValue, const Instruction* vPC, bool explicitThrow)
+NEVER_INLINE Instruction* Interpreter::throwException(CallFrame*& callFrame, JSValue*& exceptionValue, const Instruction* vPC, bool explicitThrow)
 {
     // Set up the exception object
     
@@ -896,7 +896,7 @@ private:
     JSGlobalObject* m_savedDynamicGlobalObject;
 };
 
-JSValue* BytecodeInterpreter::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
+JSValue* Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
 {
     ASSERT(!scopeChain->globalData->exception);
 
@@ -957,7 +957,7 @@ JSValue* BytecodeInterpreter::execute(ProgramNode* programNode, CallFrame* callF
     return result;
 }
 
-JSValue* BytecodeInterpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue** exception)
+JSValue* Interpreter::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* BytecodeInterpreter::execute(FunctionBodyNode* functionBodyNode, CallFr
     return result;
 }
 
-JSValue* BytecodeInterpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception)
+JSValue* Interpreter::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* BytecodeInterpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValue** exception)
+JSValue* Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValue** exception)
 {
     ASSERT(!scopeChain->globalData->exception);
 
@@ -1111,7 +1111,7 @@ JSValue* BytecodeInterpreter::execute(EvalNode* evalNode, CallFrame* callFrame,
     return result;
 }
 
-NEVER_INLINE void BytecodeInterpreter::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine)
+NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine)
 {
     Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();
     if (!debugger)
@@ -1139,7 +1139,7 @@ NEVER_INLINE void BytecodeInterpreter::debug(CallFrame* callFrame, DebugHookID d
     }
 }
 
-void BytecodeInterpreter::resetTimeoutCheck()
+void Interpreter::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* BytecodeInterpreter::checkTimeout(JSGlobalObject* globalObject)
+ALWAYS_INLINE JSValue* Interpreter::checkTimeout(JSGlobalObject* globalObject)
 {
     unsigned currentTime = getCPUTime();
     
@@ -1224,7 +1224,7 @@ ALWAYS_INLINE JSValue* BytecodeInterpreter::checkTimeout(JSGlobalObject* globalO
     return noValue();
 }
 
-NEVER_INLINE ScopeChainNode* BytecodeInterpreter::createExceptionScope(CallFrame* callFrame, const Instruction* vPC)
+NEVER_INLINE ScopeChainNode* Interpreter::createExceptionScope(CallFrame* callFrame, const Instruction* vPC)
 {
     int dst = (++vPC)->u.operand;
     CodeBlock* codeBlock = callFrame->codeBlock();
@@ -1246,7 +1246,7 @@ static StructureChain* cachePrototypeChain(CallFrame* callFrame, Structure* stru
     return structure->cachedPrototypeChain();
 }
 
-NEVER_INLINE void BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void Interpreter::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 BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, Cod
     codeBlock->refStructures(vPC);
 }
 
-NEVER_INLINE void BytecodeInterpreter::uncachePutByID(CodeBlock* codeBlock, Instruction* vPC)
+NEVER_INLINE void Interpreter::uncachePutByID(CodeBlock* codeBlock, Instruction* vPC)
 {
     codeBlock->derefStructures(vPC);
     vPC[0] = getOpcode(op_put_by_id);
     vPC[4] = 0;
 }
 
-NEVER_INLINE void BytecodeInterpreter::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void Interpreter::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 BytecodeInterpreter::tryCacheGetByID(CallFrame* callFrame, Cod
     codeBlock->refStructures(vPC);
 }
 
-NEVER_INLINE void BytecodeInterpreter::uncacheGetByID(CodeBlock* codeBlock, Instruction* vPC)
+NEVER_INLINE void Interpreter::uncacheGetByID(CodeBlock* codeBlock, Instruction* vPC)
 {
     codeBlock->derefStructures(vPC);
     vPC[0] = getOpcode(op_get_by_id);
     vPC[4] = 0;
 }
 
-JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValue** exception)
+JSValue* Interpreter::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.
@@ -3985,7 +3985,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
     #undef CHECK_FOR_TIMEOUT
 }
 
-JSValue* BytecodeInterpreter::retrieveArguments(CallFrame* callFrame, JSFunction* function) const
+JSValue* Interpreter::retrieveArguments(CallFrame* callFrame, JSFunction* function) const
 {
     CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
     if (!functionCallFrame)
@@ -4009,7 +4009,7 @@ JSValue* BytecodeInterpreter::retrieveArguments(CallFrame* callFrame, JSFunction
     return arguments;
 }
 
-JSValue* BytecodeInterpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const
+JSValue* Interpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const
 {
     CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
     if (!functionCallFrame)
@@ -4026,7 +4026,7 @@ JSValue* BytecodeInterpreter::retrieveCaller(CallFrame* callFrame, InternalFunct
     return caller;
 }
 
-void BytecodeInterpreter::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const
+void Interpreter::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const
 {
     function = noValue();
     lineNumber = -1;
@@ -4047,7 +4047,7 @@ void BytecodeInterpreter::retrieveLastCaller(CallFrame* callFrame, int& lineNumb
     function = callerFrame->callee();
 }
 
-CallFrame* BytecodeInterpreter::findFunctionCallFrame(CallFrame* callFrame, InternalFunction* function)
+CallFrame* Interpreter::findFunctionCallFrame(CallFrame* callFrame, InternalFunction* function)
 {
     for (CallFrame* candidate = callFrame; candidate; candidate = candidate->callerFrame()->removeHostCallFrameFlag()) {
         if (candidate->callee() == function)
@@ -4058,7 +4058,7 @@ CallFrame* BytecodeInterpreter::findFunctionCallFrame(CallFrame* callFrame, Inte
 
 #if ENABLE(CTI)
 
-NEVER_INLINE void BytecodeInterpreter::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void Interpreter::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 BytecodeInterpreter::tryCTICachePutByID(CallFrame* callFrame,
 #endif
 }
 
-NEVER_INLINE void BytecodeInterpreter::tryCTICacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void Interpreter::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* BytecodeInterpreter::cti_op_convert_this(CTI_ARGS)
+JSObject* Interpreter::cti_op_convert_this(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4356,7 +4356,7 @@ JSObject* BytecodeInterpreter::cti_op_convert_this(CTI_ARGS)
     return result;
 }
 
-void BytecodeInterpreter::cti_op_end(CTI_ARGS)
+void Interpreter::cti_op_end(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4365,7 +4365,7 @@ void BytecodeInterpreter::cti_op_end(CTI_ARGS)
     scopeChain->deref();
 }
 
-JSValue* BytecodeInterpreter::cti_op_add(CTI_ARGS)
+JSValue* Interpreter::cti_op_add(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4410,7 +4410,7 @@ JSValue* BytecodeInterpreter::cti_op_add(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_pre_inc(CTI_ARGS)
+JSValue* Interpreter::cti_op_pre_inc(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4422,7 +4422,7 @@ JSValue* BytecodeInterpreter::cti_op_pre_inc(CTI_ARGS)
     return result;
 }
 
-void BytecodeInterpreter::cti_timeout_check(CTI_ARGS)
+void Interpreter::cti_timeout_check(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4432,7 +4432,7 @@ void BytecodeInterpreter::cti_timeout_check(CTI_ARGS)
     }
 }
 
-void BytecodeInterpreter::cti_register_file_check(CTI_ARGS)
+void Interpreter::cti_register_file_check(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4446,7 +4446,7 @@ void BytecodeInterpreter::cti_register_file_check(CTI_ARGS)
     throwStackOverflowError(oldCallFrame, ARG_globalData, oldCallFrame->returnPC(), CTI_RETURN_ADDRESS);
 }
 
-int BytecodeInterpreter::cti_op_loop_if_less(CTI_ARGS)
+int Interpreter::cti_op_loop_if_less(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4459,7 +4459,7 @@ int BytecodeInterpreter::cti_op_loop_if_less(CTI_ARGS)
     return result;
 }
 
-int BytecodeInterpreter::cti_op_loop_if_lesseq(CTI_ARGS)
+int Interpreter::cti_op_loop_if_lesseq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4472,14 +4472,14 @@ int BytecodeInterpreter::cti_op_loop_if_lesseq(CTI_ARGS)
     return result;
 }
 
-JSObject* BytecodeInterpreter::cti_op_new_object(CTI_ARGS)
+JSObject* Interpreter::cti_op_new_object(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return constructEmptyObject(ARG_callFrame);
 }
 
-void BytecodeInterpreter::cti_op_put_by_id(CTI_ARGS)
+void Interpreter::cti_op_put_by_id(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4494,7 +4494,7 @@ void BytecodeInterpreter::cti_op_put_by_id(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-void BytecodeInterpreter::cti_op_put_by_id_second(CTI_ARGS)
+void Interpreter::cti_op_put_by_id_second(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4504,7 +4504,7 @@ void BytecodeInterpreter::cti_op_put_by_id_second(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-void BytecodeInterpreter::cti_op_put_by_id_generic(CTI_ARGS)
+void Interpreter::cti_op_put_by_id_generic(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4513,7 +4513,7 @@ void BytecodeInterpreter::cti_op_put_by_id_generic(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-void BytecodeInterpreter::cti_op_put_by_id_fail(CTI_ARGS)
+void Interpreter::cti_op_put_by_id_fail(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4529,7 +4529,7 @@ void BytecodeInterpreter::cti_op_put_by_id_fail(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-JSValue* BytecodeInterpreter::cti_op_get_by_id(CTI_ARGS)
+JSValue* Interpreter::cti_op_get_by_id(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4546,7 +4546,7 @@ JSValue* BytecodeInterpreter::cti_op_get_by_id(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_get_by_id_second(CTI_ARGS)
+JSValue* Interpreter::cti_op_get_by_id_second(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4563,7 +4563,7 @@ JSValue* BytecodeInterpreter::cti_op_get_by_id_second(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_get_by_id_generic(CTI_ARGS)
+JSValue* Interpreter::cti_op_get_by_id_generic(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4578,7 +4578,7 @@ JSValue* BytecodeInterpreter::cti_op_get_by_id_generic(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_get_by_id_fail(CTI_ARGS)
+JSValue* Interpreter::cti_op_get_by_id_fail(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4596,7 +4596,7 @@ JSValue* BytecodeInterpreter::cti_op_get_by_id_fail(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_instanceof(CTI_ARGS)
+JSValue* Interpreter::cti_op_instanceof(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4636,7 +4636,7 @@ JSValue* BytecodeInterpreter::cti_op_instanceof(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_del_by_id(CTI_ARGS)
+JSValue* Interpreter::cti_op_del_by_id(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4650,7 +4650,7 @@ JSValue* BytecodeInterpreter::cti_op_del_by_id(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_mul(CTI_ARGS)
+JSValue* Interpreter::cti_op_mul(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4668,14 +4668,14 @@ JSValue* BytecodeInterpreter::cti_op_mul(CTI_ARGS)
     return result;
 }
 
-JSObject* BytecodeInterpreter::cti_op_new_func(CTI_ARGS)
+JSObject* Interpreter::cti_op_new_func(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return ARG_func1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
-void* BytecodeInterpreter::cti_op_call_JSFunction(CTI_ARGS)
+void* Interpreter::cti_op_call_JSFunction(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4693,7 +4693,7 @@ void* BytecodeInterpreter::cti_op_call_JSFunction(CTI_ARGS)
     return newCodeBlock;
 }
 
-VoidPtrPair BytecodeInterpreter::cti_op_call_arityCheck(CTI_ARGS)
+VoidPtrPair Interpreter::cti_op_call_arityCheck(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4740,7 +4740,7 @@ VoidPtrPair BytecodeInterpreter::cti_op_call_arityCheck(CTI_ARGS)
     return pair.i;
 }
 
-void* BytecodeInterpreter::cti_vm_dontLazyLinkCall(CTI_ARGS)
+void* Interpreter::cti_vm_dontLazyLinkCall(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4754,7 +4754,7 @@ void* BytecodeInterpreter::cti_vm_dontLazyLinkCall(CTI_ARGS)
     return codeBlock->ctiCode;
 }
 
-void* BytecodeInterpreter::cti_vm_lazyLinkCall(CTI_ARGS)
+void* Interpreter::cti_vm_lazyLinkCall(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4769,7 +4769,7 @@ void* BytecodeInterpreter::cti_vm_lazyLinkCall(CTI_ARGS)
     return codeBlock->ctiCode;
 }
 
-JSObject* BytecodeInterpreter::cti_op_push_activation(CTI_ARGS)
+JSObject* Interpreter::cti_op_push_activation(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4778,7 +4778,7 @@ JSObject* BytecodeInterpreter::cti_op_push_activation(CTI_ARGS)
     return activation;
 }
 
-JSValue* BytecodeInterpreter::cti_op_call_NotJSFunction(CTI_ARGS)
+JSValue* Interpreter::cti_op_call_NotJSFunction(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4824,7 +4824,7 @@ JSValue* BytecodeInterpreter::cti_op_call_NotJSFunction(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-void BytecodeInterpreter::cti_op_create_arguments(CTI_ARGS)
+void Interpreter::cti_op_create_arguments(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4833,7 +4833,7 @@ void BytecodeInterpreter::cti_op_create_arguments(CTI_ARGS)
     ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
 }
 
-void BytecodeInterpreter::cti_op_create_arguments_no_params(CTI_ARGS)
+void Interpreter::cti_op_create_arguments_no_params(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4842,7 +4842,7 @@ void BytecodeInterpreter::cti_op_create_arguments_no_params(CTI_ARGS)
     ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
 }
 
-void BytecodeInterpreter::cti_op_tear_off_activation(CTI_ARGS)
+void Interpreter::cti_op_tear_off_activation(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4850,7 +4850,7 @@ void BytecodeInterpreter::cti_op_tear_off_activation(CTI_ARGS)
     asActivation(ARG_src1)->copyRegisters(ARG_callFrame->optionalCalleeArguments());
 }
 
-void BytecodeInterpreter::cti_op_tear_off_arguments(CTI_ARGS)
+void Interpreter::cti_op_tear_off_arguments(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4858,7 +4858,7 @@ void BytecodeInterpreter::cti_op_tear_off_arguments(CTI_ARGS)
     ARG_callFrame->optionalCalleeArguments()->copyRegisters();
 }
 
-void BytecodeInterpreter::cti_op_profile_will_call(CTI_ARGS)
+void Interpreter::cti_op_profile_will_call(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4866,7 +4866,7 @@ void BytecodeInterpreter::cti_op_profile_will_call(CTI_ARGS)
     (*ARG_profilerReference)->willExecute(ARG_callFrame, ARG_src1);
 }
 
-void BytecodeInterpreter::cti_op_profile_did_call(CTI_ARGS)
+void Interpreter::cti_op_profile_did_call(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4874,7 +4874,7 @@ void BytecodeInterpreter::cti_op_profile_did_call(CTI_ARGS)
     (*ARG_profilerReference)->didExecute(ARG_callFrame, ARG_src1);
 }
 
-void BytecodeInterpreter::cti_op_ret_scopeChain(CTI_ARGS)
+void Interpreter::cti_op_ret_scopeChain(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4882,7 +4882,7 @@ void BytecodeInterpreter::cti_op_ret_scopeChain(CTI_ARGS)
     ARG_callFrame->scopeChain()->deref();
 }
 
-JSObject* BytecodeInterpreter::cti_op_new_array(CTI_ARGS)
+JSObject* Interpreter::cti_op_new_array(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4890,7 +4890,7 @@ JSObject* BytecodeInterpreter::cti_op_new_array(CTI_ARGS)
     return constructArray(ARG_callFrame, argList);
 }
 
-JSValue* BytecodeInterpreter::cti_op_resolve(CTI_ARGS)
+JSValue* Interpreter::cti_op_resolve(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4919,7 +4919,7 @@ JSValue* BytecodeInterpreter::cti_op_resolve(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSObject* BytecodeInterpreter::cti_op_construct_JSConstruct(CTI_ARGS)
+JSObject* Interpreter::cti_op_construct_JSConstruct(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4936,7 +4936,7 @@ JSObject* BytecodeInterpreter::cti_op_construct_JSConstruct(CTI_ARGS)
     return new (ARG_globalData) JSObject(structure);
 }
 
-JSValue* BytecodeInterpreter::cti_op_construct_NotJSConstruct(CTI_ARGS)
+JSValue* Interpreter::cti_op_construct_NotJSConstruct(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -4968,12 +4968,12 @@ JSValue* BytecodeInterpreter::cti_op_construct_NotJSConstruct(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* BytecodeInterpreter::cti_op_get_by_val(CTI_ARGS)
+JSValue* Interpreter::cti_op_get_by_val(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     CallFrame* callFrame = ARG_callFrame;
-    BytecodeInterpreter* interpreter = ARG_globalData->interpreter;
+    Interpreter* interpreter = ARG_globalData->interpreter;
 
     JSValue* baseValue = ARG_src1;
     JSValue* subscript = ARG_src2;
@@ -5002,7 +5002,7 @@ JSValue* BytecodeInterpreter::cti_op_get_by_val(CTI_ARGS)
     return result;
 }
 
-VoidPtrPair BytecodeInterpreter::cti_op_resolve_func(CTI_ARGS)
+VoidPtrPair Interpreter::cti_op_resolve_func(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5046,7 +5046,7 @@ VoidPtrPair BytecodeInterpreter::cti_op_resolve_func(CTI_ARGS)
     VM_THROW_EXCEPTION_2();
 }
 
-JSValue* BytecodeInterpreter::cti_op_sub(CTI_ARGS)
+JSValue* Interpreter::cti_op_sub(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5064,12 +5064,12 @@ JSValue* BytecodeInterpreter::cti_op_sub(CTI_ARGS)
     return result;
 }
 
-void BytecodeInterpreter::cti_op_put_by_val(CTI_ARGS)
+void Interpreter::cti_op_put_by_val(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     CallFrame* callFrame = ARG_callFrame;
-    BytecodeInterpreter* interpreter = ARG_globalData->interpreter;
+    Interpreter* interpreter = ARG_globalData->interpreter;
 
     JSValue* baseValue = ARG_src1;
     JSValue* subscript = ARG_src2;
@@ -5098,7 +5098,7 @@ void BytecodeInterpreter::cti_op_put_by_val(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-void BytecodeInterpreter::cti_op_put_by_val_array(CTI_ARGS)
+void Interpreter::cti_op_put_by_val_array(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5124,7 +5124,7 @@ void BytecodeInterpreter::cti_op_put_by_val_array(CTI_ARGS)
     VM_CHECK_EXCEPTION_AT_END();
 }
 
-JSValue* BytecodeInterpreter::cti_op_lesseq(CTI_ARGS)
+JSValue* Interpreter::cti_op_lesseq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5134,7 +5134,7 @@ JSValue* BytecodeInterpreter::cti_op_lesseq(CTI_ARGS)
     return result;
 }
 
-int BytecodeInterpreter::cti_op_loop_if_true(CTI_ARGS)
+int Interpreter::cti_op_loop_if_true(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5147,7 +5147,7 @@ int BytecodeInterpreter::cti_op_loop_if_true(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_negate(CTI_ARGS)
+JSValue* Interpreter::cti_op_negate(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5163,14 +5163,14 @@ JSValue* BytecodeInterpreter::cti_op_negate(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_resolve_base(CTI_ARGS)
+JSValue* Interpreter::cti_op_resolve_base(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return inlineResolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain());
 }
 
-JSValue* BytecodeInterpreter::cti_op_resolve_skip(CTI_ARGS)
+JSValue* Interpreter::cti_op_resolve_skip(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5204,7 +5204,7 @@ JSValue* BytecodeInterpreter::cti_op_resolve_skip(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* BytecodeInterpreter::cti_op_resolve_global(CTI_ARGS)
+JSValue* Interpreter::cti_op_resolve_global(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5234,7 +5234,7 @@ JSValue* BytecodeInterpreter::cti_op_resolve_global(CTI_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* BytecodeInterpreter::cti_op_div(CTI_ARGS)
+JSValue* Interpreter::cti_op_div(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5252,7 +5252,7 @@ JSValue* BytecodeInterpreter::cti_op_div(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_pre_dec(CTI_ARGS)
+JSValue* Interpreter::cti_op_pre_dec(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5264,7 +5264,7 @@ JSValue* BytecodeInterpreter::cti_op_pre_dec(CTI_ARGS)
     return result;
 }
 
-int BytecodeInterpreter::cti_op_jless(CTI_ARGS)
+int Interpreter::cti_op_jless(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5277,7 +5277,7 @@ int BytecodeInterpreter::cti_op_jless(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_not(CTI_ARGS)
+JSValue* Interpreter::cti_op_not(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5290,7 +5290,7 @@ JSValue* BytecodeInterpreter::cti_op_not(CTI_ARGS)
     return result;
 }
 
-int SFX_CALL BytecodeInterpreter::cti_op_jtrue(CTI_ARGS)
+int SFX_CALL Interpreter::cti_op_jtrue(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5303,7 +5303,7 @@ int SFX_CALL BytecodeInterpreter::cti_op_jtrue(CTI_ARGS)
     return result;
 }
 
-VoidPtrPair BytecodeInterpreter::cti_op_post_inc(CTI_ARGS)
+VoidPtrPair Interpreter::cti_op_post_inc(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5318,7 +5318,7 @@ VoidPtrPair BytecodeInterpreter::cti_op_post_inc(CTI_ARGS)
     return pair.i;
 }
 
-JSValue* BytecodeInterpreter::cti_op_eq(CTI_ARGS)
+JSValue* Interpreter::cti_op_eq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5333,7 +5333,7 @@ JSValue* BytecodeInterpreter::cti_op_eq(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_lshift(CTI_ARGS)
+JSValue* Interpreter::cti_op_lshift(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5353,7 +5353,7 @@ JSValue* BytecodeInterpreter::cti_op_lshift(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_bitand(CTI_ARGS)
+JSValue* Interpreter::cti_op_bitand(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5371,7 +5371,7 @@ JSValue* BytecodeInterpreter::cti_op_bitand(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_rshift(CTI_ARGS)
+JSValue* Interpreter::cti_op_rshift(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5391,7 +5391,7 @@ JSValue* BytecodeInterpreter::cti_op_rshift(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_bitnot(CTI_ARGS)
+JSValue* Interpreter::cti_op_bitnot(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5407,7 +5407,7 @@ JSValue* BytecodeInterpreter::cti_op_bitnot(CTI_ARGS)
     return result;
 }
 
-VoidPtrPair BytecodeInterpreter::cti_op_resolve_with_base(CTI_ARGS)
+VoidPtrPair Interpreter::cti_op_resolve_with_base(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5443,14 +5443,14 @@ VoidPtrPair BytecodeInterpreter::cti_op_resolve_with_base(CTI_ARGS)
     VM_THROW_EXCEPTION_2();
 }
 
-JSObject* BytecodeInterpreter::cti_op_new_func_exp(CTI_ARGS)
+JSObject* Interpreter::cti_op_new_func_exp(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return ARG_funcexp1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
-JSValue* BytecodeInterpreter::cti_op_mod(CTI_ARGS)
+JSValue* Interpreter::cti_op_mod(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5464,7 +5464,7 @@ JSValue* BytecodeInterpreter::cti_op_mod(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_less(CTI_ARGS)
+JSValue* Interpreter::cti_op_less(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5474,7 +5474,7 @@ JSValue* BytecodeInterpreter::cti_op_less(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_neq(CTI_ARGS)
+JSValue* Interpreter::cti_op_neq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5489,7 +5489,7 @@ JSValue* BytecodeInterpreter::cti_op_neq(CTI_ARGS)
     return result;
 }
 
-VoidPtrPair BytecodeInterpreter::cti_op_post_dec(CTI_ARGS)
+VoidPtrPair Interpreter::cti_op_post_dec(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5504,7 +5504,7 @@ VoidPtrPair BytecodeInterpreter::cti_op_post_dec(CTI_ARGS)
     return pair.i;
 }
 
-JSValue* BytecodeInterpreter::cti_op_urshift(CTI_ARGS)
+JSValue* Interpreter::cti_op_urshift(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5522,7 +5522,7 @@ JSValue* BytecodeInterpreter::cti_op_urshift(CTI_ARGS)
     }
 }
 
-JSValue* BytecodeInterpreter::cti_op_bitxor(CTI_ARGS)
+JSValue* Interpreter::cti_op_bitxor(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5536,14 +5536,14 @@ JSValue* BytecodeInterpreter::cti_op_bitxor(CTI_ARGS)
     return result;
 }
 
-JSObject* BytecodeInterpreter::cti_op_new_regexp(CTI_ARGS)
+JSObject* Interpreter::cti_op_new_regexp(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return new (ARG_globalData) RegExpObject(ARG_callFrame->lexicalGlobalObject()->regExpStructure(), ARG_regexp1);
 }
 
-JSValue* BytecodeInterpreter::cti_op_bitor(CTI_ARGS)
+JSValue* Interpreter::cti_op_bitor(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5557,14 +5557,14 @@ JSValue* BytecodeInterpreter::cti_op_bitor(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_call_eval(CTI_ARGS)
+JSValue* Interpreter::cti_op_call_eval(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     CallFrame* callFrame = ARG_callFrame;
     RegisterFile* registerFile = ARG_registerFile;
 
-    BytecodeInterpreter* interpreter = ARG_globalData->interpreter;
+    Interpreter* interpreter = ARG_globalData->interpreter;
     
     JSValue* funcVal = ARG_src1;
     int registerOffset = ARG_int2;
@@ -5588,7 +5588,7 @@ JSValue* BytecodeInterpreter::cti_op_call_eval(CTI_ARGS)
     return JSImmediate::impossibleValue();
 }
 
-JSValue* BytecodeInterpreter::cti_op_throw(CTI_ARGS)
+JSValue* Interpreter::cti_op_throw(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5615,14 +5615,14 @@ JSValue* BytecodeInterpreter::cti_op_throw(CTI_ARGS)
     return exceptionValue;
 }
 
-JSPropertyNameIterator* BytecodeInterpreter::cti_op_get_pnames(CTI_ARGS)
+JSPropertyNameIterator* Interpreter::cti_op_get_pnames(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return JSPropertyNameIterator::create(ARG_callFrame, ARG_src1);
 }
 
-JSValue* BytecodeInterpreter::cti_op_next_pname(CTI_ARGS)
+JSValue* Interpreter::cti_op_next_pname(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5633,7 +5633,7 @@ JSValue* BytecodeInterpreter::cti_op_next_pname(CTI_ARGS)
     return temp;
 }
 
-void BytecodeInterpreter::cti_op_push_scope(CTI_ARGS)
+void Interpreter::cti_op_push_scope(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5642,21 +5642,21 @@ void BytecodeInterpreter::cti_op_push_scope(CTI_ARGS)
     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->push(o));
 }
 
-void BytecodeInterpreter::cti_op_pop_scope(CTI_ARGS)
+void Interpreter::cti_op_pop_scope(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->pop());
 }
 
-JSValue* BytecodeInterpreter::cti_op_typeof(CTI_ARGS)
+JSValue* Interpreter::cti_op_typeof(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsTypeStringForValue(ARG_callFrame, ARG_src1);
 }
 
-JSValue* BytecodeInterpreter::cti_op_is_undefined(CTI_ARGS)
+JSValue* Interpreter::cti_op_is_undefined(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5664,42 +5664,42 @@ JSValue* BytecodeInterpreter::cti_op_is_undefined(CTI_ARGS)
     return jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structure()->typeInfo().masqueradesAsUndefined());
 }
 
-JSValue* BytecodeInterpreter::cti_op_is_boolean(CTI_ARGS)
+JSValue* Interpreter::cti_op_is_boolean(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(ARG_src1->isBoolean());
 }
 
-JSValue* BytecodeInterpreter::cti_op_is_number(CTI_ARGS)
+JSValue* Interpreter::cti_op_is_number(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(ARG_src1->isNumber());
 }
 
-JSValue* BytecodeInterpreter::cti_op_is_string(CTI_ARGS)
+JSValue* Interpreter::cti_op_is_string(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(ARG_globalData->interpreter->isJSString(ARG_src1));
 }
 
-JSValue* BytecodeInterpreter::cti_op_is_object(CTI_ARGS)
+JSValue* Interpreter::cti_op_is_object(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(jsIsObjectType(ARG_src1));
 }
 
-JSValue* BytecodeInterpreter::cti_op_is_function(CTI_ARGS)
+JSValue* Interpreter::cti_op_is_function(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
     return jsBoolean(jsIsFunctionType(ARG_src1));
 }
 
-JSValue* BytecodeInterpreter::cti_op_stricteq(CTI_ARGS)
+JSValue* Interpreter::cti_op_stricteq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5713,7 +5713,7 @@ JSValue* BytecodeInterpreter::cti_op_stricteq(CTI_ARGS)
     return jsBoolean(strictEqualSlowCaseInline(src1, src2));
 }
 
-JSValue* BytecodeInterpreter::cti_op_nstricteq(CTI_ARGS)
+JSValue* Interpreter::cti_op_nstricteq(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5727,7 +5727,7 @@ JSValue* BytecodeInterpreter::cti_op_nstricteq(CTI_ARGS)
     return jsBoolean(!strictEqualSlowCaseInline(src1, src2));
 }
 
-JSValue* BytecodeInterpreter::cti_op_to_jsnumber(CTI_ARGS)
+JSValue* Interpreter::cti_op_to_jsnumber(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5739,7 +5739,7 @@ JSValue* BytecodeInterpreter::cti_op_to_jsnumber(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_in(CTI_ARGS)
+JSValue* Interpreter::cti_op_in(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5767,7 +5767,7 @@ JSValue* BytecodeInterpreter::cti_op_in(CTI_ARGS)
     return jsBoolean(baseObj->hasProperty(callFrame, property));
 }
 
-JSObject* BytecodeInterpreter::cti_op_push_new_scope(CTI_ARGS)
+JSObject* Interpreter::cti_op_push_new_scope(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5778,7 +5778,7 @@ JSObject* BytecodeInterpreter::cti_op_push_new_scope(CTI_ARGS)
     return scope;
 }
 
-void BytecodeInterpreter::cti_op_jmp_scopes(CTI_ARGS)
+void Interpreter::cti_op_jmp_scopes(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5791,7 +5791,7 @@ void BytecodeInterpreter::cti_op_jmp_scopes(CTI_ARGS)
     callFrame->setScopeChain(tmp);
 }
 
-void BytecodeInterpreter::cti_op_put_by_index(CTI_ARGS)
+void Interpreter::cti_op_put_by_index(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5801,7 +5801,7 @@ void BytecodeInterpreter::cti_op_put_by_index(CTI_ARGS)
     ARG_src1->put(callFrame, property, ARG_src3);
 }
 
-void* BytecodeInterpreter::cti_op_switch_imm(CTI_ARGS)
+void* Interpreter::cti_op_switch_imm(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5818,7 +5818,7 @@ void* BytecodeInterpreter::cti_op_switch_imm(CTI_ARGS)
     return codeBlock->immediateSwitchJumpTables[tableIndex].ctiDefault;
 }
 
-void* BytecodeInterpreter::cti_op_switch_char(CTI_ARGS)
+void* Interpreter::cti_op_switch_char(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5838,7 +5838,7 @@ void* BytecodeInterpreter::cti_op_switch_char(CTI_ARGS)
     return result;
 }
 
-void* BytecodeInterpreter::cti_op_switch_string(CTI_ARGS)
+void* Interpreter::cti_op_switch_string(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5857,7 +5857,7 @@ void* BytecodeInterpreter::cti_op_switch_string(CTI_ARGS)
     return result;
 }
 
-JSValue* BytecodeInterpreter::cti_op_del_by_val(CTI_ARGS)
+JSValue* Interpreter::cti_op_del_by_val(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5882,7 +5882,7 @@ JSValue* BytecodeInterpreter::cti_op_del_by_val(CTI_ARGS)
     return result;
 }
 
-void BytecodeInterpreter::cti_op_put_getter(CTI_ARGS)
+void Interpreter::cti_op_put_getter(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5895,7 +5895,7 @@ void BytecodeInterpreter::cti_op_put_getter(CTI_ARGS)
     baseObj->defineGetter(callFrame, ident, asObject(ARG_src3));
 }
 
-void BytecodeInterpreter::cti_op_put_setter(CTI_ARGS)
+void Interpreter::cti_op_put_setter(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5908,7 +5908,7 @@ void BytecodeInterpreter::cti_op_put_setter(CTI_ARGS)
     baseObj->defineSetter(callFrame, ident, asObject(ARG_src3));
 }
 
-JSObject* BytecodeInterpreter::cti_op_new_error(CTI_ARGS)
+JSObject* Interpreter::cti_op_new_error(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5921,7 +5921,7 @@ JSObject* BytecodeInterpreter::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 BytecodeInterpreter::cti_op_debug(CTI_ARGS)
+void Interpreter::cti_op_debug(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
@@ -5934,7 +5934,7 @@ void BytecodeInterpreter::cti_op_debug(CTI_ARGS)
     ARG_globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
 }
 
-JSValue* BytecodeInterpreter::cti_vm_throw(CTI_ARGS)
+JSValue* Interpreter::cti_vm_throw(CTI_ARGS)
 {
     CTI_STACK_HACK();
 
index 7614410..b391ea3 100644 (file)
@@ -101,11 +101,11 @@ namespace JSC {
 
     enum { MaxReentryDepth = 128 };
 
-    class BytecodeInterpreter {
+    class Interpreter {
         friend class CTI;
     public:
-        BytecodeInterpreter();
-        ~BytecodeInterpreter();
+        Interpreter();
+        ~Interpreter();
 
         void initialize(JSGlobalData*);
         
index 7f5a7f1..7c54e60 100644 (file)
@@ -59,9 +59,9 @@ namespace JSC {
         
     private:
         friend class ExecState;
-        friend class BytecodeInterpreter;
+        friend class Interpreter;
 
-        // Only CallFrame and BytecodeInterpreter should use these functions.
+        // Only CallFrame and Interpreter should use these functions.
 
         Register(intptr_t);
 
@@ -170,7 +170,7 @@ namespace JSC {
         getJSValue()->mark();
     }
     
-    // BytecodeInterpreter functions
+    // Interpreter functions
 
     ALWAYS_INLINE Register::Register(Arguments* arguments)
     {
index 882375c..daf99d2 100644 (file)
@@ -40,7 +40,7 @@ namespace JSC {
 
     class CodeBlock;
     class ExecState;
-    class BytecodeInterpreter;
+    class Interpreter;
     class ScopeNode;
     struct Instruction;
 
@@ -125,7 +125,7 @@ namespace JSC {
         };
 #endif        
 
-        SamplingTool(BytecodeInterpreter* interpreter)
+        SamplingTool(Interpreter* interpreter)
             : m_interpreter(interpreter)
             , m_running(false)
             , m_codeBlock(0)
@@ -188,7 +188,7 @@ namespace JSC {
         static void* threadStartFunc(void*);
         void run();
         
-        BytecodeInterpreter* m_interpreter;
+        Interpreter* m_interpreter;
         
         // Sampling thread state.
         bool m_running;
index 7c4b2e4..22911dd 100644 (file)
@@ -141,7 +141,7 @@ void BytecodeGenerator::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 BytecodeInterpreter::execute time.
+    if (m_codeType != EvalCode) { // eval code needs to hang on to its declaration stacks to keep declaration info alive until Interpreter::execute time.
         m_scopeNode->varStack().shrinkCapacity(0);
         m_scopeNode->functionStack().shrinkCapacity(0);
     }
@@ -236,7 +236,7 @@ BytecodeGenerator::BytecodeGenerator(ProgramNode* programNode, const Debugger* d
     emitOpcode(op_enter);
     codeBlock->globalData = m_globalData;
 
-    // FIXME: Move code that modifies the global object to BytecodeInterpreter::execute.
+    // FIXME: Move code that modifies the global object to Interpreter::execute.
     
     m_codeBlock->numParameters = 1; // Allocate space for "this"
 
index c098d6b..b7af125 100644 (file)
@@ -320,7 +320,7 @@ static bool runWithScripts(GlobalObject* globalObject, const Vector<UString>& fi
         BytecodeGenerator::setDumpsGeneratedCode(true);
 
 #if ENABLE(OPCODE_SAMPLING)
-    BytecodeInterpreter* interpreter = globalObject->globalData()->interpreter;
+    Interpreter* interpreter = globalObject->globalData()->interpreter;
     interpreter->setSampler(new SamplingTool(machine));
 #endif
 
index 953bbfd..8b209eb 100644 (file)
@@ -122,7 +122,7 @@ public:
         return this;
     }
     
-    void* copy()
+    void* executableCopy()
     {
         if (!m_size)
             return 0;
@@ -1106,9 +1106,9 @@ public:
         reinterpret_cast<intptr_t*>(where)[-1] = (reinterpret_cast<intptr_t>(destination) - where);
     }
     
-    void* copy() 
+    void* executableCopy() 
     {
-        return m_buffer->copy();
+        return m_buffer->executableCopy();
     }
 
 #if COMPILER(MSVC)
index 43e83c8..6493406 100644 (file)
@@ -82,7 +82,7 @@ namespace JSC  {
 
         const CommonIdentifiers& propertyNames() const { return *globalData().propertyNames; }
         const ArgList& emptyList() const { return *globalData().emptyList; }
-        BytecodeInterpreter* interpreter() { return globalData().interpreter; }
+        Interpreter* 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 BytecodeInterpreter;
+        friend class Interpreter;
 
         static CallFrame* create(Register* callFrameBase) { return static_cast<CallFrame*>(callFrameBase); }
         Register* registers() { return this; }
index ce20f07..5cea57a 100644 (file)
@@ -38,7 +38,7 @@ namespace JSC {
         friend class JSPropertyNameIterator;
         friend class JSString;
         friend class JSValue;
-        friend class BytecodeInterpreter;
+        friend class Interpreter;
 
     private:
         explicit JSCell(Structure*);
index d501edc..cf618d4 100644 (file)
@@ -39,7 +39,7 @@ namespace JSC {
 
     class JSFunction : public InternalFunction {
         friend class CTI;
-        friend class BytecodeInterpreter;
+        friend class Interpreter;
 
         typedef InternalFunction Base;
         JSFunction(PassRefPtr<JSC::Structure> st) : InternalFunction(st), m_scopeChain(NoScopeChain()) {}
index 0751d30..2e5a175 100644 (file)
@@ -64,7 +64,7 @@ extern const HashTable regExpConstructorTable;
 extern const HashTable stringTable;
 
 JSGlobalData::JSGlobalData(bool isShared)
-    : interpreter(new BytecodeInterpreter)
+    : interpreter(new Interpreter)
     , exception(noValue())
     , arrayTable(new HashTable(JSC::arrayTable))
     , dateTable(new HashTable(JSC::dateTable))
index 265d289..ea72071 100644 (file)
@@ -47,7 +47,7 @@ namespace JSC {
     class JSGlobalObject;
     class JSObject;
     class Lexer;
-    class BytecodeInterpreter;
+    class Interpreter;
     class Parser;
     class ParserRefCounted;
     class Structure;
@@ -63,7 +63,7 @@ namespace JSC {
         static PassRefPtr<JSGlobalData> createLeaked();
         ~JSGlobalData();
 
-        BytecodeInterpreter* interpreter;
+        Interpreter* interpreter;
 
         JSValue* exception;
 #if ENABLE(CTI)
index c0758ee..1f9156a 100644 (file)
@@ -86,7 +86,7 @@ namespace JSC {
 
     class JSImmediate {
     private:
-        friend class CTI; // Whooo!
+        friend class CTI;
     
         static const uintptr_t TagMask           = 0x3u; // primary tag is 2 bits long
         static const uintptr_t TagBitTypeInteger = 0x1u; // bottom bit set indicates integer, this dominates the following bit
index d6212d8..0c97196 100644 (file)
@@ -60,7 +60,7 @@ namespace JSC {
 
     class JSString : public JSCell {
         friend class CTI;
-        friend class BytecodeInterpreter;
+        friend class Interpreter;
 
     public:
         JSString(JSGlobalData* globalData, const UString& value)
index 815a600..f6ca030 100644 (file)
 #include "UString.h"
 #include <stddef.h> // for size_t
 
-// The magic number 0x4000 is not important here, it is being subtracted back out (avoiding using zero since this
-// can have unexpected effects in this type of macro, particularly where multiple-inheritance is involved).
-#define OBJECT_OFFSET(class, member) (reinterpret_cast<ptrdiff_t>(&(reinterpret_cast<class*>(0x4000)->member)) - 0x4000)
-
 namespace JSC {
 
     class Identifier;
index 91ad698..fe2bad2 100644 (file)
@@ -41,6 +41,8 @@ namespace JSC {
     class Register;
 
     class JSVariableObject : public JSObject {
+        friend class CTI;
+
     public:
         SymbolTable& symbolTable() const { return *d->symbolTable; }
 
@@ -72,11 +74,6 @@ namespace JSC {
             Register* registers; // "r" in the register file.
             OwnArrayPtr<Register> registerArray; // Independent copy of registers, used when a variable object copies its registers out of the register file.
 
-            static inline ptrdiff_t offsetOf_registers()
-            {
-                return OBJECT_OFFSET(JSVariableObjectData, registers);
-            }
-
         private:
             JSVariableObjectData(const JSVariableObjectData&);
             JSVariableObjectData& operator=(const JSVariableObjectData&);
@@ -97,17 +94,6 @@ namespace JSC {
         bool symbolTablePutWithAttributes(const Identifier&, JSValue*, unsigned attributes);
 
         JSVariableObjectData* d;
-
-    public:
-        static inline ptrdiff_t offsetOf_d()
-        {
-            return OBJECT_OFFSET(JSVariableObject, d);
-        }
-
-        static inline ptrdiff_t offsetOf_Data_registers()
-        {
-            return JSVariableObjectData::offsetOf_registers();
-        }
     };
 
     inline bool JSVariableObject::symbolTableGet(const Identifier& propertyName, PropertySlot& slot)
index 850134d..26e82f6 100644 (file)
 #include "config.h"
 #include "RegExp.h"
 
-#include "CTI.h"
 #include "Lexer.h"
 #include <pcre/pcre.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <wrec/WREC.h>
 #include <wtf/Assertions.h>
 #include <wtf/OwnArrayPtr.h>
 
@@ -45,7 +43,7 @@ inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern)
     , m_numSubpatterns(0)
 {
 #if ENABLE(WREC)
-    m_wrecFunction = WREC::compileRegExp(globalData->interpreter, pattern, &m_numSubpatterns, &m_constructionError);
+    m_wrecFunction = compileRegExp(globalData->interpreter, pattern, &m_numSubpatterns, &m_constructionError);
     if (m_wrecFunction)
         return;
     // Fall through to non-WREC case.
@@ -88,7 +86,7 @@ inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern, const US
     }
 
 #if ENABLE(WREC)
-    m_wrecFunction = WREC::compileRegExp(globalData->interpreter, pattern, &m_numSubpatterns, &m_constructionError, (m_flagBits & IgnoreCase), (m_flagBits & Multiline));
+    m_wrecFunction = compileRegExp(globalData->interpreter, pattern, &m_numSubpatterns, &m_constructionError, (m_flagBits & IgnoreCase), (m_flagBits & Multiline));
     if (m_wrecFunction)
         return;
     // Fall through to non-WREC case.
@@ -109,7 +107,7 @@ RegExp::~RegExp()
     jsRegExpFree(m_regExp);
 #if ENABLE(WREC)
     if (m_wrecFunction)
-        WTF::fastFreeExecutable(m_wrecFunction);
+        WTF::fastFreeExecutable(reinterpret_cast<void*>(m_wrecFunction));
 #endif
 }
 
@@ -136,7 +134,7 @@ int RegExp::match(const UString& s, int i, OwnArrayPtr<int>* ovector)
         else
             ovector->set(offsetVector);
 
-        int result = reinterpret_cast<WRECFunction>(m_wrecFunction)(s.data(), i, s.size(), offsetVector);
+        int result = m_wrecFunction(s.data(), i, s.size(), offsetVector);
 
         if (result < 0) {
 #ifndef NDEBUG
index 2abb805..0a5b65a 100644 (file)
@@ -22,6 +22,7 @@
 #define KJS_REGEXP_H
 
 #include "UString.h"
+#include "WREC.h"
 #include <wtf/Forward.h>
 #include <wtf/RefCounted.h>
 
@@ -66,8 +67,7 @@ namespace JSC {
         unsigned m_numSubpatterns;
 
 #if ENABLE(WREC)
-        // Called as a WRECFunction
-        void* m_wrecFunction;
+        WREC::RegExpFunction m_wrecFunction;
 #endif
     };
 
index e75a2f4..549e2d2 100644 (file)
@@ -32,9 +32,8 @@
 #include <wtf/ASCIICType.h>
 
 using namespace WTF;
-using namespace JSC;
 
-namespace WREC {
+namespace JSC { namespace WREC {
 
 static const UChar asciiNewlines[2] = { '\n', '\r' };
 static const UChar unicodeNewlines[2] = { 0x2028, 0x2029 };
@@ -356,6 +355,6 @@ void CharacterClassConstructor::append(CharacterClass& other)
     }
 }
 
-} // namespace WREC
+} } // namespace JSC::WREC
 
 #endif // ENABLE(WREC)
index abe2b3c..9e28c1d 100644 (file)
 #ifndef CharacterClassConstructor_h
 #define CharacterClassConstructor_h
 
+#include <wtf/Platform.h>
+
 #if ENABLE(WREC)
 
 #include "UString.h"
 
-namespace WREC {
+namespace JSC { namespace WREC {
 
     struct CharacterClassRange {
         UChar begin;
@@ -114,7 +116,7 @@ namespace WREC {
         Vector<CharacterClassRange> m_rangesUnicode;
     };
 
-} // namespace WREC
+} } // namespace JSC::WREC
 
 #endif // ENABLE(WREC)
 
index 36dffe0..f4b4e50 100644 (file)
@@ -35,9 +35,8 @@
 #define __ m_assembler.
 
 using namespace WTF;
-using namespace JSC;
 
-namespace WREC {
+namespace JSC { namespace WREC {
 
 class GenerateAtomFunctor {
 public:
@@ -1328,7 +1327,7 @@ void Parser::parseDisjunction(JmpSrcVector& failures)
 // This limit comes from the limit set in PCRE
 static const int MaxPatternSize = (1 << 16);
 
-void* compileRegExp(BytecodeInterpreter* interpreter, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase, bool multiline)
+RegExpFunction compileRegExp(Interpreter* interpreter, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase, bool multiline)
 {
     // TODO: better error messages
     if (pattern.size() > MaxPatternSize) {
@@ -1414,11 +1413,11 @@ void* compileRegExp(BytecodeInterpreter* interpreter, const UString& pattern, un
 
     *numSubpatterns_ptr = parser.m_numSubpatterns;
 
-    void* code = __ copy();
+    void* code = __ executableCopy();
     ASSERT(code);
-    return code;
+    return reinterpret_cast<RegExpFunction>(code);
 }
 
-} // namespace WREC
+} } // namespace JSC::WREC
 
 #endif // ENABLE(WREC)
index cae21e4..4c078e0 100644 (file)
@@ -26,6 +26,8 @@
 #ifndef WREC_h
 #define WREC_h
 
+#include <wtf/Platform.h>
+
 #if ENABLE(WREC)
 
 #include "UString.h"
 #endif
 
 namespace JSC {
-    class BytecodeInterpreter;
+    class Interpreter;
 }
 
-namespace WREC {
+namespace JSC { namespace WREC {
 
     class GenerateAtomFunctor;
     struct CharacterClassRange;
     struct CharacterClass;
 
-    typedef int (*WRECFunction)(const UChar* input, unsigned start, unsigned length, int* output) WREC_CALL;
+    typedef int (*RegExpFunction)(const UChar* input, unsigned start, unsigned length, int* output) WREC_CALL;
 
-    void* compileRegExp(JSC::BytecodeInterpreter*, const JSC::UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
+    RegExpFunction compileRegExp(Interpreter*, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
 
     struct Quantifier {
         enum Type {
@@ -85,22 +87,23 @@ namespace WREC {
 
     class Generator {
     public:
-        Generator(Parser& parser, JSC::X86Assembler& assembler)
+        Generator(Parser& parser, X86Assembler& assembler)
             : m_parser(parser)
             , m_assembler(assembler)
         {
         }
 
-        typedef JSC::X86Assembler::JmpSrc JmpSrc;
-        typedef JSC::X86Assembler::JmpDst JmpDst;
+        typedef X86Assembler::JmpSrc JmpSrc;
+        typedef X86Assembler::JmpDst JmpDst;
+        typedef X86Assembler::RegisterID RegisterID;
 
         // these regs setup by the params
-        static const JSC::X86Assembler::RegisterID inputRegister = JSC::X86::eax;
-        static const JSC::X86Assembler::RegisterID currentPositionRegister = JSC::X86::edx;
-        static const JSC::X86Assembler::RegisterID lengthRegister = JSC::X86::ecx;
-        static const JSC::X86Assembler::RegisterID currentValueRegister = JSC::X86::esi;
-        static const JSC::X86Assembler::RegisterID outputRegister = JSC::X86::edi;
-        static const JSC::X86Assembler::RegisterID quantifierCountRegister = JSC::X86::ebx;
+        static const RegisterID inputRegister = X86::eax;
+        static const RegisterID currentPositionRegister = X86::edx;
+        static const RegisterID lengthRegister = X86::ecx;
+        static const RegisterID currentValueRegister = X86::esi;
+        static const RegisterID outputRegister = X86::edi;
+        static const RegisterID quantifierCountRegister = X86::ebx;
 
         friend class GenerateAtomFunctor;
         friend class GeneratePatternCharacterFunctor;
@@ -108,30 +111,30 @@ namespace WREC {
         friend class GenerateBackreferenceFunctor;
         friend class GenerateParenthesesNonGreedyFunctor;
 
-        void generateGreedyQuantifier(JSC::JmpSrcVector& failures, GenerateAtomFunctor& functor, unsigned min, unsigned max);
-        void generateNonGreedyQuantifier(JSC::JmpSrcVector& failures, GenerateAtomFunctor& functor, unsigned min, unsigned max);
+        void generateGreedyQuantifier(JmpSrcVector& failures, GenerateAtomFunctor& functor, unsigned min, unsigned max);
+        void generateNonGreedyQuantifier(JmpSrcVector& failures, GenerateAtomFunctor& functor, unsigned min, unsigned max);
         void generateBacktrack1();
         void generateBacktrackBackreference(unsigned subpatternId);
-        void generateCharacterClass(JSC::JmpSrcVector& failures, CharacterClass& charClass, bool invert);
-        void generateCharacterClassInverted(JSC::JmpSrcVector& failures, CharacterClass& charClass);
-        void generateCharacterClassInvertedRange(JSC::JmpSrcVector& failures, JSC::JmpSrcVector& matchDest, const CharacterClassRange* ranges, unsigned count, unsigned* matchIndex, const UChar* matches, unsigned matchCount);
-        void generatePatternCharacter(JSC::JmpSrcVector& failures, int ch);
-        void generateAssertionWordBoundary(JSC::JmpSrcVector& failures, bool invert);
-        void generateAssertionBOL(JSC::JmpSrcVector& failures);
-        void generateAssertionEOL(JSC::JmpSrcVector& failures);
-        void generateBackreference(JSC::JmpSrcVector& failures, unsigned subpatternID);
-        void generateBackreferenceQuantifier(JSC::JmpSrcVector& failures, Quantifier::Type quantifierType, unsigned subpatternId, unsigned min, unsigned max);
+        void generateCharacterClass(JmpSrcVector& failures, CharacterClass& charClass, bool invert);
+        void generateCharacterClassInverted(JmpSrcVector& failures, CharacterClass& charClass);
+        void generateCharacterClassInvertedRange(JmpSrcVector& failures, JmpSrcVector& matchDest, const CharacterClassRange* ranges, unsigned count, unsigned* matchIndex, const UChar* matches, unsigned matchCount);
+        void generatePatternCharacter(JmpSrcVector& failures, int ch);
+        void generateAssertionWordBoundary(JmpSrcVector& failures, bool invert);
+        void generateAssertionBOL(JmpSrcVector& failures);
+        void generateAssertionEOL(JmpSrcVector& failures);
+        void generateBackreference(JmpSrcVector& failures, unsigned subpatternID);
+        void generateBackreferenceQuantifier(JmpSrcVector& failures, Quantifier::Type quantifierType, unsigned subpatternId, unsigned min, unsigned max);
         enum ParenthesesType { capturing, non_capturing, assertion, inverted_assertion }; // order is relied on in generateParentheses()
         JmpSrc generateParentheses(ParenthesesType type);
-        JmpSrc generateParenthesesResetTrampoline(JSC::JmpSrcVector& newFailures, unsigned subpatternIdBefore, unsigned subpatternIdAfter);
-        void generateParenthesesNonGreedy(JSC::JmpSrcVector& failures, JmpDst start, JmpSrc success, JmpSrc fail);
+        JmpSrc generateParenthesesResetTrampoline(JmpSrcVector& newFailures, unsigned subpatternIdBefore, unsigned subpatternIdAfter);
+        void generateParenthesesNonGreedy(JmpSrcVector& failures, JmpDst start, JmpSrc success, JmpSrc fail);
 
-        void generateDisjunction(JSC::JmpSrcVector& successes, JSC::JmpSrcVector& failures);
-        void terminateDisjunction(JSC::JmpSrcVector& successes);
+        void generateDisjunction(JmpSrcVector& successes, JmpSrcVector& failures);
+        void terminateDisjunction(JmpSrcVector& successes);
 
     private:
         Parser& m_parser;
-        JSC::X86Assembler& m_assembler;
+        X86Assembler& m_assembler;
     };
 
     class Parser {
@@ -139,7 +142,7 @@ namespace WREC {
         bool m_ignoreCase;
         bool m_multiline;
         unsigned m_numSubpatterns;
-        enum WRECError {
+        enum {
             NoError,
             Error_malformedCharacterClass,
             Error_malformedParentheses,
@@ -150,7 +153,7 @@ namespace WREC {
             TempError_unsupportedParentheses,
         } m_err;
 
-        Parser(const JSC::UString& pattern, bool ignoreCase, bool multiline, JSC::X86Assembler& assembler)
+        Parser(const UString& pattern, bool ignoreCase, bool multiline, X86Assembler& assembler)
             : m_ignoreCase(ignoreCase)
             , m_multiline(multiline)
             , m_numSubpatterns(0)
@@ -162,21 +165,21 @@ namespace WREC {
         {
         }
 
-        void parseAlternative(JSC::JmpSrcVector& failures)
+        void parseAlternative(JmpSrcVector& failures)
         {
             while (parseTerm(failures)) { }
         }
 
-        void parseDisjunction(JSC::JmpSrcVector& failures);
+        void parseDisjunction(JmpSrcVector& failures);
 
-        bool parseTerm(JSC::JmpSrcVector& failures);
-        bool parseEscape(JSC::JmpSrcVector& failures);
-        bool parseOctalEscape(JSC::JmpSrcVector& failures);
-        bool parseParentheses(JSC::JmpSrcVector& failures);
-        bool parseCharacterClass(JSC::JmpSrcVector& failures);
-        bool parseCharacterClassQuantifier(JSC::JmpSrcVector& failures, CharacterClass& charClass, bool invert);
-        bool parsePatternCharacterQualifier(JSC::JmpSrcVector& failures, int ch);
-        bool parseBackreferenceQuantifier(JSC::JmpSrcVector& failures, unsigned subpatternId);
+        bool parseTerm(JmpSrcVector& failures);
+        bool parseEscape(JmpSrcVector& failures);
+        bool parseOctalEscape(JmpSrcVector& failures);
+        bool parseParentheses(JmpSrcVector& failures);
+        bool parseCharacterClass(JmpSrcVector& failures);
+        bool parseCharacterClassQuantifier(JmpSrcVector& failures, CharacterClass& charClass, bool invert);
+        bool parsePatternCharacterQualifier(JmpSrcVector& failures, int ch);
+        bool parseBackreferenceQuantifier(JmpSrcVector& failures, unsigned subpatternId);
 
         ALWAYS_INLINE Quantifier parseGreedyQuantifier();
         Quantifier parseQuantifier();
@@ -255,7 +258,7 @@ namespace WREC {
         unsigned m_index;
     };
 
-} // namespace JSC
+} } // namespace JSC::WREC
 
 #endif // ENABLE(WREC)