JavaScriptCore:
authorbarraclough@apple.com <barraclough@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 7 Jan 2009 05:11:57 +0000 (05:11 +0000)
committerbarraclough@apple.com <barraclough@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 7 Jan 2009 05:11:57 +0000 (05:11 +0000)
2009-01-05  Gavin Barraclough  <baraclough@apple.com>

        Reviewed by Oliver Hunt.

        Replace all uses of JSValue* with a new smart pointer type, JSValuePtr.

        A JavaScript value may be a heap object or boxed primitive, represented by a
        pointer, or may be an unboxed immediate value, such as an integer.  Since a
        value may dynamically need to contain either a pointer value or an immediate,
        we encode immediates as pointer values (since all valid JSCell pointers are
        allocated at alligned addesses, unaligned addresses are available to encode
        immediates).  As such all JavaScript values are represented using a JSValue*.

        This implementation is encumbered by a number of constraints.  It ties the
        JSValue representation to the size of pointer on the platform, which, for
        example, means that we currently can represent different ranges of integers
        as immediates on x86 and x86-64.  It also prevents us from overloading the
        to-boolean conversion used to test for noValue() - effectively forcing us
        to represent noValue() as 0.  This would potentially be problematic were we
        to wish to encode integer values differently (e.g. were we to use the v8
        encoding, where pointers are tagged with 1 and integers with 0, then the
        immediate integer 0 would conflict with noValue()).

        This patch replaces all usage of JSValue* with a new class, JSValuePtr,
        which encapsulates the pointer.  JSValuePtr maintains the same interface as
        JSValue*, overloading operator-> and operator bool such that previous
        operations in the code on variables of type JSValue* are still supported.

        In order to provide a ProtectPtr<> type with support for the new value
        representation (without using the internal JSValue type directly), a new
        ProtectJSValuePtr type has been added, equivalent to the previous type
        ProtectPtr<JSValue>.

        This patch is likely the first in a sequence of three changes.  With the
        value now encapsulated it will likely make sense to migrate the functionality
        from JSValue into JSValuePtr, such that the internal pointer representation
        need not be exposed.  Through migrating the functionality to the wrapper
        class the existing JSValue should be rendered redundant, and the class is
        likely to be removed (the JSValuePtr now wrapping a pointer to a JSCell).
        At this stage it will likely make sense to rename JSValuePtr to JSValue.

        https://bugs.webkit.org/show_bug.cgi?id=23114

        * API/APICast.h:
        (toJS):
        (toRef):
        * API/JSBase.cpp:
        (JSEvaluateScript):
        * API/JSCallbackConstructor.h:
        (JSC::JSCallbackConstructor::createStructure):
        * API/JSCallbackFunction.cpp:
        (JSC::JSCallbackFunction::call):
        * API/JSCallbackFunction.h:
        (JSC::JSCallbackFunction::createStructure):
        * API/JSCallbackObject.h:
        (JSC::JSCallbackObject::createStructure):
        * API/JSCallbackObjectFunctions.h:
        (JSC::::asCallbackObject):
        (JSC::::put):
        (JSC::::hasInstance):
        (JSC::::call):
        (JSC::::staticValueGetter):
        (JSC::::staticFunctionGetter):
        (JSC::::callbackGetter):
        * API/JSContextRef.cpp:
        * API/JSObjectRef.cpp:
        (JSObjectMakeConstructor):
        (JSObjectSetPrototype):
        (JSObjectGetProperty):
        (JSObjectSetProperty):
        (JSObjectGetPropertyAtIndex):
        (JSObjectSetPropertyAtIndex):
        * API/JSValueRef.cpp:
        (JSValueGetType):
        (JSValueIsUndefined):
        (JSValueIsNull):
        (JSValueIsBoolean):
        (JSValueIsNumber):
        (JSValueIsString):
        (JSValueIsObject):
        (JSValueIsObjectOfClass):
        (JSValueIsEqual):
        (JSValueIsStrictEqual):
        (JSValueIsInstanceOfConstructor):
        (JSValueToBoolean):
        (JSValueToNumber):
        (JSValueToStringCopy):
        (JSValueToObject):
        (JSValueProtect):
        (JSValueUnprotect):
        * JavaScriptCore.exp:
        * bytecode/CodeBlock.cpp:
        (JSC::valueToSourceString):
        (JSC::constantName):
        (JSC::CodeBlock::dump):
        * bytecode/CodeBlock.h:
        (JSC::CodeBlock::getConstant):
        (JSC::CodeBlock::addUnexpectedConstant):
        (JSC::CodeBlock::unexpectedConstant):
        * bytecode/EvalCodeCache.h:
        (JSC::EvalCodeCache::get):
        * bytecompiler/BytecodeGenerator.cpp:
        (JSC::BytecodeGenerator::BytecodeGenerator):
        (JSC::BytecodeGenerator::addConstant):
        (JSC::BytecodeGenerator::addUnexpectedConstant):
        (JSC::BytecodeGenerator::emitLoad):
        (JSC::BytecodeGenerator::emitLoadJSV):
        (JSC::BytecodeGenerator::emitGetScopedVar):
        (JSC::BytecodeGenerator::emitPutScopedVar):
        (JSC::BytecodeGenerator::emitNewError):
        (JSC::keyForImmediateSwitch):
        * bytecompiler/BytecodeGenerator.h:
        (JSC::BytecodeGenerator::JSValueHashTraits::constructDeletedValue):
        (JSC::BytecodeGenerator::JSValueHashTraits::isDeletedValue):
        * debugger/DebuggerCallFrame.cpp:
        (JSC::DebuggerCallFrame::evaluate):
        * debugger/DebuggerCallFrame.h:
        (JSC::DebuggerCallFrame::DebuggerCallFrame):
        (JSC::DebuggerCallFrame::exception):
        * interpreter/CallFrame.cpp:
        (JSC::CallFrame::thisValue):
        * interpreter/CallFrame.h:
        (JSC::ExecState::setException):
        (JSC::ExecState::exception):
        (JSC::ExecState::exceptionSlot):
        (JSC::ExecState::hadException):
        * interpreter/Interpreter.cpp:
        (JSC::fastIsNumber):
        (JSC::fastToInt32):
        (JSC::fastToUInt32):
        (JSC::jsLess):
        (JSC::jsLessEq):
        (JSC::jsAddSlowCase):
        (JSC::jsAdd):
        (JSC::jsTypeStringForValue):
        (JSC::jsIsObjectType):
        (JSC::jsIsFunctionType):
        (JSC::Interpreter::resolve):
        (JSC::Interpreter::resolveSkip):
        (JSC::Interpreter::resolveGlobal):
        (JSC::inlineResolveBase):
        (JSC::Interpreter::resolveBase):
        (JSC::Interpreter::resolveBaseAndProperty):
        (JSC::Interpreter::resolveBaseAndFunc):
        (JSC::isNotObject):
        (JSC::Interpreter::callEval):
        (JSC::Interpreter::unwindCallFrame):
        (JSC::Interpreter::throwException):
        (JSC::Interpreter::execute):
        (JSC::Interpreter::checkTimeout):
        (JSC::Interpreter::createExceptionScope):
        (JSC::cachePrototypeChain):
        (JSC::Interpreter::tryCachePutByID):
        (JSC::countPrototypeChainEntriesAndCheckForProxies):
        (JSC::Interpreter::tryCacheGetByID):
        (JSC::Interpreter::privateExecute):
        (JSC::Interpreter::retrieveArguments):
        (JSC::Interpreter::retrieveCaller):
        (JSC::Interpreter::retrieveLastCaller):
        (JSC::Interpreter::tryCTICachePutByID):
        (JSC::Interpreter::tryCTICacheGetByID):
        (JSC::returnToThrowTrampoline):
        (JSC::Interpreter::cti_op_convert_this):
        (JSC::Interpreter::cti_op_add):
        (JSC::Interpreter::cti_op_pre_inc):
        (JSC::Interpreter::cti_op_loop_if_less):
        (JSC::Interpreter::cti_op_loop_if_lesseq):
        (JSC::Interpreter::cti_op_get_by_id_generic):
        (JSC::Interpreter::cti_op_get_by_id):
        (JSC::Interpreter::cti_op_get_by_id_second):
        (JSC::Interpreter::cti_op_get_by_id_self_fail):
        (JSC::Interpreter::cti_op_get_by_id_proto_list):
        (JSC::Interpreter::cti_op_get_by_id_proto_list_full):
        (JSC::Interpreter::cti_op_get_by_id_proto_fail):
        (JSC::Interpreter::cti_op_get_by_id_array_fail):
        (JSC::Interpreter::cti_op_get_by_id_string_fail):
        (JSC::Interpreter::cti_op_instanceof):
        (JSC::Interpreter::cti_op_del_by_id):
        (JSC::Interpreter::cti_op_mul):
        (JSC::Interpreter::cti_op_call_NotJSFunction):
        (JSC::Interpreter::cti_op_resolve):
        (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_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_bitor):
        (JSC::Interpreter::cti_op_call_eval):
        (JSC::Interpreter::cti_op_throw):
        (JSC::Interpreter::cti_op_next_pname):
        (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_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_new_error):
        (JSC::Interpreter::cti_vm_throw):
        * interpreter/Interpreter.h:
        (JSC::Interpreter::isJSArray):
        (JSC::Interpreter::isJSString):
        * interpreter/Register.h:
        (JSC::Register::):
        (JSC::Register::Register):
        (JSC::Register::jsValue):
        (JSC::Register::getJSValue):
        * jit/JIT.cpp:
        (JSC::):
        (JSC::JIT::compileOpStrictEq):
        (JSC::JIT::privateCompileMainPass):
        (JSC::JIT::privateCompileSlowCases):
        * jit/JIT.h:
        (JSC::):
        (JSC::JIT::execute):
        * jit/JITArithmetic.cpp:
        (JSC::JIT::compileFastArith_op_rshift):
        (JSC::JIT::compileFastArithSlow_op_rshift):
        * jit/JITCall.cpp:
        (JSC::JIT::unlinkCall):
        (JSC::JIT::compileOpCallInitializeCallFrame):
        (JSC::JIT::compileOpCall):
        * jit/JITInlineMethods.h:
        (JSC::JIT::emitGetVirtualRegister):
        (JSC::JIT::getConstantOperand):
        (JSC::JIT::isOperandConstant31BitImmediateInt):
        (JSC::JIT::emitPutJITStubArgFromVirtualRegister):
        (JSC::JIT::emitInitRegister):
        * jit/JITPropertyAccess.cpp:
        (JSC::resizePropertyStorage):
        (JSC::JIT::privateCompilePutByIdTransition):
        (JSC::JIT::patchGetByIdSelf):
        (JSC::JIT::patchPutByIdReplace):
        (JSC::JIT::privateCompileGetByIdSelf):
        (JSC::JIT::privateCompileGetByIdProto):
        (JSC::JIT::privateCompileGetByIdSelfList):
        (JSC::JIT::privateCompileGetByIdProtoList):
        (JSC::JIT::privateCompileGetByIdChainList):
        (JSC::JIT::privateCompileGetByIdChain):
        (JSC::JIT::privateCompilePutByIdReplace):
        * jsc.cpp:
        (functionPrint):
        (functionDebug):
        (functionGC):
        (functionVersion):
        (functionRun):
        (functionLoad):
        (functionReadline):
        (functionQuit):
        * parser/Nodes.cpp:
        (JSC::NullNode::emitBytecode):
        (JSC::ArrayNode::emitBytecode):
        (JSC::FunctionCallValueNode::emitBytecode):
        (JSC::FunctionCallResolveNode::emitBytecode):
        (JSC::VoidNode::emitBytecode):
        (JSC::ConstDeclNode::emitCodeSingle):
        (JSC::ReturnNode::emitBytecode):
        (JSC::processClauseList):
        (JSC::EvalNode::emitBytecode):
        (JSC::FunctionBodyNode::emitBytecode):
        (JSC::ProgramNode::emitBytecode):
        * profiler/ProfileGenerator.cpp:
        (JSC::ProfileGenerator::addParentForConsoleStart):
        * profiler/Profiler.cpp:
        (JSC::Profiler::willExecute):
        (JSC::Profiler::didExecute):
        (JSC::Profiler::createCallIdentifier):
        * profiler/Profiler.h:
        * runtime/ArgList.cpp:
        (JSC::ArgList::slowAppend):
        * runtime/ArgList.h:
        (JSC::ArgList::at):
        (JSC::ArgList::append):
        * runtime/Arguments.cpp:
        (JSC::Arguments::put):
        * runtime/Arguments.h:
        (JSC::Arguments::createStructure):
        (JSC::asArguments):
        * runtime/ArrayConstructor.cpp:
        (JSC::callArrayConstructor):
        * runtime/ArrayPrototype.cpp:
        (JSC::getProperty):
        (JSC::putProperty):
        (JSC::arrayProtoFuncToString):
        (JSC::arrayProtoFuncToLocaleString):
        (JSC::arrayProtoFuncJoin):
        (JSC::arrayProtoFuncConcat):
        (JSC::arrayProtoFuncPop):
        (JSC::arrayProtoFuncPush):
        (JSC::arrayProtoFuncReverse):
        (JSC::arrayProtoFuncShift):
        (JSC::arrayProtoFuncSlice):
        (JSC::arrayProtoFuncSort):
        (JSC::arrayProtoFuncSplice):
        (JSC::arrayProtoFuncUnShift):
        (JSC::arrayProtoFuncFilter):
        (JSC::arrayProtoFuncMap):
        (JSC::arrayProtoFuncEvery):
        (JSC::arrayProtoFuncForEach):
        (JSC::arrayProtoFuncSome):
        (JSC::arrayProtoFuncIndexOf):
        (JSC::arrayProtoFuncLastIndexOf):
        * runtime/BooleanConstructor.cpp:
        (JSC::callBooleanConstructor):
        (JSC::constructBooleanFromImmediateBoolean):
        * runtime/BooleanConstructor.h:
        * runtime/BooleanObject.h:
        (JSC::asBooleanObject):
        * runtime/BooleanPrototype.cpp:
        (JSC::booleanProtoFuncToString):
        (JSC::booleanProtoFuncValueOf):
        * runtime/CallData.cpp:
        (JSC::call):
        * runtime/CallData.h:
        * runtime/Collector.cpp:
        (JSC::Heap::protect):
        (JSC::Heap::unprotect):
        (JSC::Heap::heap):
        (JSC::Heap::collect):
        * runtime/Collector.h:
        * runtime/Completion.cpp:
        (JSC::evaluate):
        * runtime/Completion.h:
        (JSC::Completion::Completion):
        (JSC::Completion::value):
        (JSC::Completion::setValue):
        (JSC::Completion::isValueCompletion):
        * runtime/ConstructData.cpp:
        (JSC::construct):
        * runtime/ConstructData.h:
        * runtime/DateConstructor.cpp:
        (JSC::constructDate):
        (JSC::callDate):
        (JSC::dateParse):
        (JSC::dateNow):
        (JSC::dateUTC):
        * runtime/DateInstance.h:
        (JSC::asDateInstance):
        * runtime/DatePrototype.cpp:
        (JSC::dateProtoFuncToString):
        (JSC::dateProtoFuncToUTCString):
        (JSC::dateProtoFuncToDateString):
        (JSC::dateProtoFuncToTimeString):
        (JSC::dateProtoFuncToLocaleString):
        (JSC::dateProtoFuncToLocaleDateString):
        (JSC::dateProtoFuncToLocaleTimeString):
        (JSC::dateProtoFuncValueOf):
        (JSC::dateProtoFuncGetTime):
        (JSC::dateProtoFuncGetFullYear):
        (JSC::dateProtoFuncGetUTCFullYear):
        (JSC::dateProtoFuncToGMTString):
        (JSC::dateProtoFuncGetMonth):
        (JSC::dateProtoFuncGetUTCMonth):
        (JSC::dateProtoFuncGetDate):
        (JSC::dateProtoFuncGetUTCDate):
        (JSC::dateProtoFuncGetDay):
        (JSC::dateProtoFuncGetUTCDay):
        (JSC::dateProtoFuncGetHours):
        (JSC::dateProtoFuncGetUTCHours):
        (JSC::dateProtoFuncGetMinutes):
        (JSC::dateProtoFuncGetUTCMinutes):
        (JSC::dateProtoFuncGetSeconds):
        (JSC::dateProtoFuncGetUTCSeconds):
        (JSC::dateProtoFuncGetMilliSeconds):
        (JSC::dateProtoFuncGetUTCMilliseconds):
        (JSC::dateProtoFuncGetTimezoneOffset):
        (JSC::dateProtoFuncSetTime):
        (JSC::setNewValueFromTimeArgs):
        (JSC::setNewValueFromDateArgs):
        (JSC::dateProtoFuncSetMilliSeconds):
        (JSC::dateProtoFuncSetUTCMilliseconds):
        (JSC::dateProtoFuncSetSeconds):
        (JSC::dateProtoFuncSetUTCSeconds):
        (JSC::dateProtoFuncSetMinutes):
        (JSC::dateProtoFuncSetUTCMinutes):
        (JSC::dateProtoFuncSetHours):
        (JSC::dateProtoFuncSetUTCHours):
        (JSC::dateProtoFuncSetDate):
        (JSC::dateProtoFuncSetUTCDate):
        (JSC::dateProtoFuncSetMonth):
        (JSC::dateProtoFuncSetUTCMonth):
        (JSC::dateProtoFuncSetFullYear):
        (JSC::dateProtoFuncSetUTCFullYear):
        (JSC::dateProtoFuncSetYear):
        (JSC::dateProtoFuncGetYear):
        * runtime/DatePrototype.h:
        (JSC::DatePrototype::createStructure):
        * runtime/ErrorConstructor.cpp:
        (JSC::callErrorConstructor):
        * runtime/ErrorPrototype.cpp:
        (JSC::errorProtoFuncToString):
        * runtime/ExceptionHelpers.cpp:
        (JSC::createInterruptedExecutionException):
        (JSC::createError):
        (JSC::createStackOverflowError):
        (JSC::createUndefinedVariableError):
        (JSC::createErrorMessage):
        (JSC::createInvalidParamError):
        (JSC::createNotAConstructorError):
        (JSC::createNotAFunctionError):
        * runtime/ExceptionHelpers.h:
        * runtime/FunctionConstructor.cpp:
        (JSC::callFunctionConstructor):
        * runtime/FunctionPrototype.cpp:
        (JSC::callFunctionPrototype):
        (JSC::functionProtoFuncToString):
        (JSC::functionProtoFuncApply):
        (JSC::functionProtoFuncCall):
        * runtime/FunctionPrototype.h:
        (JSC::FunctionPrototype::createStructure):
        * runtime/GetterSetter.cpp:
        (JSC::GetterSetter::toPrimitive):
        (JSC::GetterSetter::getPrimitiveNumber):
        * runtime/GetterSetter.h:
        (JSC::asGetterSetter):
        * runtime/InitializeThreading.cpp:
        * runtime/InternalFunction.h:
        (JSC::InternalFunction::createStructure):
        (JSC::asInternalFunction):
        * runtime/JSActivation.cpp:
        (JSC::JSActivation::getOwnPropertySlot):
        (JSC::JSActivation::put):
        (JSC::JSActivation::putWithAttributes):
        (JSC::JSActivation::argumentsGetter):
        * runtime/JSActivation.h:
        (JSC::JSActivation::createStructure):
        (JSC::asActivation):
        * runtime/JSArray.cpp:
        (JSC::storageSize):
        (JSC::JSArray::JSArray):
        (JSC::JSArray::getOwnPropertySlot):
        (JSC::JSArray::put):
        (JSC::JSArray::putSlowCase):
        (JSC::JSArray::deleteProperty):
        (JSC::JSArray::getPropertyNames):
        (JSC::JSArray::setLength):
        (JSC::JSArray::pop):
        (JSC::JSArray::push):
        (JSC::JSArray::mark):
        (JSC::JSArray::sort):
        (JSC::JSArray::compactForSorting):
        (JSC::JSArray::checkConsistency):
        (JSC::constructArray):
        * runtime/JSArray.h:
        (JSC::JSArray::getIndex):
        (JSC::JSArray::setIndex):
        (JSC::JSArray::createStructure):
        (JSC::asArray):
        * runtime/JSCell.cpp:
        (JSC::JSCell::put):
        (JSC::JSCell::getJSNumber):
        * runtime/JSCell.h:
        (JSC::asCell):
        (JSC::JSValue::asCell):
        (JSC::JSValue::toPrimitive):
        (JSC::JSValue::getPrimitiveNumber):
        (JSC::JSValue::getJSNumber):
        * runtime/JSFunction.cpp:
        (JSC::JSFunction::call):
        (JSC::JSFunction::argumentsGetter):
        (JSC::JSFunction::callerGetter):
        (JSC::JSFunction::lengthGetter):
        (JSC::JSFunction::getOwnPropertySlot):
        (JSC::JSFunction::put):
        (JSC::JSFunction::construct):
        * runtime/JSFunction.h:
        (JSC::JSFunction::createStructure):
        (JSC::asFunction):
        * runtime/JSGlobalData.h:
        * runtime/JSGlobalObject.cpp:
        (JSC::markIfNeeded):
        (JSC::JSGlobalObject::put):
        (JSC::JSGlobalObject::putWithAttributes):
        (JSC::JSGlobalObject::reset):
        (JSC::JSGlobalObject::resetPrototype):
        * runtime/JSGlobalObject.h:
        (JSC::JSGlobalObject::createStructure):
        (JSC::JSGlobalObject::GlobalPropertyInfo::GlobalPropertyInfo):
        (JSC::asGlobalObject):
        (JSC::Structure::prototypeForLookup):
        * runtime/JSGlobalObjectFunctions.cpp:
        (JSC::encode):
        (JSC::decode):
        (JSC::globalFuncEval):
        (JSC::globalFuncParseInt):
        (JSC::globalFuncParseFloat):
        (JSC::globalFuncIsNaN):
        (JSC::globalFuncIsFinite):
        (JSC::globalFuncDecodeURI):
        (JSC::globalFuncDecodeURIComponent):
        (JSC::globalFuncEncodeURI):
        (JSC::globalFuncEncodeURIComponent):
        (JSC::globalFuncEscape):
        (JSC::globalFuncUnescape):
        (JSC::globalFuncJSCPrint):
        * runtime/JSGlobalObjectFunctions.h:
        * runtime/JSImmediate.cpp:
        (JSC::JSImmediate::toThisObject):
        (JSC::JSImmediate::toObject):
        (JSC::JSImmediate::prototype):
        (JSC::JSImmediate::toString):
        * runtime/JSImmediate.h:
        (JSC::JSImmediate::isImmediate):
        (JSC::JSImmediate::isNumber):
        (JSC::JSImmediate::isPositiveNumber):
        (JSC::JSImmediate::isBoolean):
        (JSC::JSImmediate::isUndefinedOrNull):
        (JSC::JSImmediate::isNegative):
        (JSC::JSImmediate::isEitherImmediate):
        (JSC::JSImmediate::isAnyImmediate):
        (JSC::JSImmediate::areBothImmediate):
        (JSC::JSImmediate::areBothImmediateNumbers):
        (JSC::JSImmediate::andImmediateNumbers):
        (JSC::JSImmediate::xorImmediateNumbers):
        (JSC::JSImmediate::orImmediateNumbers):
        (JSC::JSImmediate::rightShiftImmediateNumbers):
        (JSC::JSImmediate::canDoFastAdditiveOperations):
        (JSC::JSImmediate::addImmediateNumbers):
        (JSC::JSImmediate::subImmediateNumbers):
        (JSC::JSImmediate::incImmediateNumber):
        (JSC::JSImmediate::decImmediateNumber):
        (JSC::JSImmediate::makeValue):
        (JSC::JSImmediate::makeInt):
        (JSC::JSImmediate::makeBool):
        (JSC::JSImmediate::makeUndefined):
        (JSC::JSImmediate::makeNull):
        (JSC::JSImmediate::intValue):
        (JSC::JSImmediate::uintValue):
        (JSC::JSImmediate::boolValue):
        (JSC::JSImmediate::rawValue):
        (JSC::JSImmediate::trueImmediate):
        (JSC::JSImmediate::falseImmediate):
        (JSC::JSImmediate::undefinedImmediate):
        (JSC::JSImmediate::nullImmediate):
        (JSC::JSImmediate::zeroImmediate):
        (JSC::JSImmediate::oneImmediate):
        (JSC::JSImmediate::impossibleValue):
        (JSC::JSImmediate::toBoolean):
        (JSC::JSImmediate::getTruncatedUInt32):
        (JSC::JSImmediate::from):
        (JSC::JSImmediate::getTruncatedInt32):
        (JSC::JSImmediate::toDouble):
        (JSC::JSImmediate::getUInt32):
        (JSC::jsNull):
        (JSC::jsBoolean):
        (JSC::jsUndefined):
        (JSC::JSValue::isUndefined):
        (JSC::JSValue::isNull):
        (JSC::JSValue::isUndefinedOrNull):
        (JSC::JSValue::isBoolean):
        (JSC::JSValue::getBoolean):
        (JSC::JSValue::toInt32):
        (JSC::JSValue::toUInt32):
        (JSC::toInt32):
        (JSC::toUInt32):
        * runtime/JSNotAnObject.cpp:
        (JSC::JSNotAnObject::toPrimitive):
        (JSC::JSNotAnObject::getPrimitiveNumber):
        (JSC::JSNotAnObject::put):
        * runtime/JSNotAnObject.h:
        (JSC::JSNotAnObject::createStructure):
        * runtime/JSNumberCell.cpp:
        (JSC::JSNumberCell::toPrimitive):
        (JSC::JSNumberCell::getPrimitiveNumber):
        (JSC::JSNumberCell::getJSNumber):
        (JSC::jsNumberCell):
        (JSC::jsNaN):
        * runtime/JSNumberCell.h:
        (JSC::JSNumberCell::createStructure):
        (JSC::asNumberCell):
        (JSC::jsNumber):
        (JSC::JSValue::toJSNumber):
        * runtime/JSObject.cpp:
        (JSC::JSObject::mark):
        (JSC::JSObject::put):
        (JSC::JSObject::putWithAttributes):
        (JSC::callDefaultValueFunction):
        (JSC::JSObject::getPrimitiveNumber):
        (JSC::JSObject::defaultValue):
        (JSC::JSObject::defineGetter):
        (JSC::JSObject::defineSetter):
        (JSC::JSObject::lookupGetter):
        (JSC::JSObject::lookupSetter):
        (JSC::JSObject::hasInstance):
        (JSC::JSObject::toNumber):
        (JSC::JSObject::toString):
        (JSC::JSObject::fillGetterPropertySlot):
        * runtime/JSObject.h:
        (JSC::JSObject::getDirect):
        (JSC::JSObject::getDirectLocation):
        (JSC::JSObject::offsetForLocation):
        (JSC::JSObject::locationForOffset):
        (JSC::JSObject::getDirectOffset):
        (JSC::JSObject::putDirectOffset):
        (JSC::JSObject::createStructure):
        (JSC::asObject):
        (JSC::JSObject::prototype):
        (JSC::JSObject::setPrototype):
        (JSC::JSObject::inlineGetOwnPropertySlot):
        (JSC::JSObject::getOwnPropertySlotForWrite):
        (JSC::JSObject::getPropertySlot):
        (JSC::JSObject::get):
        (JSC::JSObject::putDirect):
        (JSC::JSObject::putDirectWithoutTransition):
        (JSC::JSObject::toPrimitive):
        (JSC::JSValue::get):
        (JSC::JSValue::put):
        (JSC::JSObject::allocatePropertyStorageInline):
        * runtime/JSPropertyNameIterator.cpp:
        (JSC::JSPropertyNameIterator::toPrimitive):
        (JSC::JSPropertyNameIterator::getPrimitiveNumber):
        * runtime/JSPropertyNameIterator.h:
        (JSC::JSPropertyNameIterator::create):
        (JSC::JSPropertyNameIterator::next):
        * runtime/JSStaticScopeObject.cpp:
        (JSC::JSStaticScopeObject::put):
        (JSC::JSStaticScopeObject::putWithAttributes):
        * runtime/JSStaticScopeObject.h:
        (JSC::JSStaticScopeObject::JSStaticScopeObject):
        (JSC::JSStaticScopeObject::createStructure):
        * runtime/JSString.cpp:
        (JSC::JSString::toPrimitive):
        (JSC::JSString::getPrimitiveNumber):
        (JSC::JSString::getOwnPropertySlot):
        * runtime/JSString.h:
        (JSC::JSString::createStructure):
        (JSC::asString):
        * runtime/JSValue.h:
        (JSC::JSValuePtr::makeImmediate):
        (JSC::JSValuePtr::immediateValue):
        (JSC::JSValuePtr::JSValuePtr):
        (JSC::JSValuePtr::operator->):
        (JSC::JSValuePtr::hasValue):
        (JSC::JSValuePtr::operator==):
        (JSC::JSValuePtr::operator!=):
        (JSC::JSValuePtr::encode):
        (JSC::JSValuePtr::decode):
        (JSC::JSValue::asValue):
        (JSC::noValue):
        (JSC::operator==):
        (JSC::operator!=):
        * runtime/JSVariableObject.h:
        (JSC::JSVariableObject::symbolTablePut):
        (JSC::JSVariableObject::symbolTablePutWithAttributes):
        * runtime/JSWrapperObject.cpp:
        (JSC::JSWrapperObject::mark):
        * runtime/JSWrapperObject.h:
        (JSC::JSWrapperObject::internalValue):
        (JSC::JSWrapperObject::setInternalValue):
        * runtime/Lookup.cpp:
        (JSC::setUpStaticFunctionSlot):
        * runtime/Lookup.h:
        (JSC::lookupPut):
        * runtime/MathObject.cpp:
        (JSC::mathProtoFuncAbs):
        (JSC::mathProtoFuncACos):
        (JSC::mathProtoFuncASin):
        (JSC::mathProtoFuncATan):
        (JSC::mathProtoFuncATan2):
        (JSC::mathProtoFuncCeil):
        (JSC::mathProtoFuncCos):
        (JSC::mathProtoFuncExp):
        (JSC::mathProtoFuncFloor):
        (JSC::mathProtoFuncLog):
        (JSC::mathProtoFuncMax):
        (JSC::mathProtoFuncMin):
        (JSC::mathProtoFuncPow):
        (JSC::mathProtoFuncRandom):
        (JSC::mathProtoFuncRound):
        (JSC::mathProtoFuncSin):
        (JSC::mathProtoFuncSqrt):
        (JSC::mathProtoFuncTan):
        * runtime/MathObject.h:
        (JSC::MathObject::createStructure):
        * runtime/NativeErrorConstructor.cpp:
        (JSC::callNativeErrorConstructor):
        * runtime/NumberConstructor.cpp:
        (JSC::numberConstructorNaNValue):
        (JSC::numberConstructorNegInfinity):
        (JSC::numberConstructorPosInfinity):
        (JSC::numberConstructorMaxValue):
        (JSC::numberConstructorMinValue):
        (JSC::callNumberConstructor):
        * runtime/NumberConstructor.h:
        (JSC::NumberConstructor::createStructure):
        * runtime/NumberObject.cpp:
        (JSC::NumberObject::getJSNumber):
        (JSC::constructNumberFromImmediateNumber):
        * runtime/NumberObject.h:
        * runtime/NumberPrototype.cpp:
        (JSC::numberProtoFuncToString):
        (JSC::numberProtoFuncToLocaleString):
        (JSC::numberProtoFuncValueOf):
        (JSC::numberProtoFuncToFixed):
        (JSC::numberProtoFuncToExponential):
        (JSC::numberProtoFuncToPrecision):
        * runtime/ObjectConstructor.cpp:
        (JSC::constructObject):
        (JSC::callObjectConstructor):
        * runtime/ObjectPrototype.cpp:
        (JSC::objectProtoFuncValueOf):
        (JSC::objectProtoFuncHasOwnProperty):
        (JSC::objectProtoFuncIsPrototypeOf):
        (JSC::objectProtoFuncDefineGetter):
        (JSC::objectProtoFuncDefineSetter):
        (JSC::objectProtoFuncLookupGetter):
        (JSC::objectProtoFuncLookupSetter):
        (JSC::objectProtoFuncPropertyIsEnumerable):
        (JSC::objectProtoFuncToLocaleString):
        (JSC::objectProtoFuncToString):
        * runtime/ObjectPrototype.h:
        * runtime/Operations.cpp:
        (JSC::equal):
        (JSC::equalSlowCase):
        (JSC::strictEqual):
        (JSC::strictEqualSlowCase):
        (JSC::throwOutOfMemoryError):
        * runtime/Operations.h:
        (JSC::equalSlowCaseInline):
        (JSC::strictEqualSlowCaseInline):
        * runtime/PropertySlot.cpp:
        (JSC::PropertySlot::functionGetter):
        * runtime/PropertySlot.h:
        (JSC::PropertySlot::PropertySlot):
        (JSC::PropertySlot::getValue):
        (JSC::PropertySlot::putValue):
        (JSC::PropertySlot::setValueSlot):
        (JSC::PropertySlot::setValue):
        (JSC::PropertySlot::setCustom):
        (JSC::PropertySlot::setCustomIndex):
        (JSC::PropertySlot::slotBase):
        (JSC::PropertySlot::setBase):
        (JSC::PropertySlot::):
        * runtime/Protect.h:
        (JSC::gcProtect):
        (JSC::gcUnprotect):
        (JSC::ProtectedPtr::ProtectedPtr):
        (JSC::ProtectedPtr::operator JSValuePtr):
        (JSC::ProtectedJSValuePtr::ProtectedJSValuePtr):
        (JSC::ProtectedJSValuePtr::get):
        (JSC::ProtectedJSValuePtr::operator JSValuePtr):
        (JSC::ProtectedJSValuePtr::operator->):
        (JSC::::ProtectedPtr):
        (JSC::::~ProtectedPtr):
        (JSC::::operator):
        (JSC::ProtectedJSValuePtr::~ProtectedJSValuePtr):
        (JSC::ProtectedJSValuePtr::operator=):
        (JSC::operator==):
        (JSC::operator!=):
        * runtime/RegExpConstructor.cpp:
        (JSC::RegExpConstructor::getBackref):
        (JSC::RegExpConstructor::getLastParen):
        (JSC::RegExpConstructor::getLeftContext):
        (JSC::RegExpConstructor::getRightContext):
        (JSC::regExpConstructorDollar1):
        (JSC::regExpConstructorDollar2):
        (JSC::regExpConstructorDollar3):
        (JSC::regExpConstructorDollar4):
        (JSC::regExpConstructorDollar5):
        (JSC::regExpConstructorDollar6):
        (JSC::regExpConstructorDollar7):
        (JSC::regExpConstructorDollar8):
        (JSC::regExpConstructorDollar9):
        (JSC::regExpConstructorInput):
        (JSC::regExpConstructorMultiline):
        (JSC::regExpConstructorLastMatch):
        (JSC::regExpConstructorLastParen):
        (JSC::regExpConstructorLeftContext):
        (JSC::regExpConstructorRightContext):
        (JSC::RegExpConstructor::put):
        (JSC::setRegExpConstructorInput):
        (JSC::setRegExpConstructorMultiline):
        (JSC::constructRegExp):
        (JSC::callRegExpConstructor):
        * runtime/RegExpConstructor.h:
        (JSC::RegExpConstructor::createStructure):
        (JSC::asRegExpConstructor):
        * runtime/RegExpMatchesArray.h:
        (JSC::RegExpMatchesArray::put):
        * runtime/RegExpObject.cpp:
        (JSC::regExpObjectGlobal):
        (JSC::regExpObjectIgnoreCase):
        (JSC::regExpObjectMultiline):
        (JSC::regExpObjectSource):
        (JSC::regExpObjectLastIndex):
        (JSC::RegExpObject::put):
        (JSC::setRegExpObjectLastIndex):
        (JSC::RegExpObject::test):
        (JSC::RegExpObject::exec):
        (JSC::callRegExpObject):
        * runtime/RegExpObject.h:
        (JSC::RegExpObject::createStructure):
        (JSC::asRegExpObject):
        * runtime/RegExpPrototype.cpp:
        (JSC::regExpProtoFuncTest):
        (JSC::regExpProtoFuncExec):
        (JSC::regExpProtoFuncCompile):
        (JSC::regExpProtoFuncToString):
        * runtime/StringConstructor.cpp:
        (JSC::stringFromCharCodeSlowCase):
        (JSC::stringFromCharCode):
        (JSC::callStringConstructor):
        * runtime/StringObject.cpp:
        (JSC::StringObject::put):
        * runtime/StringObject.h:
        (JSC::StringObject::createStructure):
        (JSC::asStringObject):
        * runtime/StringObjectThatMasqueradesAsUndefined.h:
        (JSC::StringObjectThatMasqueradesAsUndefined::createStructure):
        * runtime/StringPrototype.cpp:
        (JSC::stringProtoFuncReplace):
        (JSC::stringProtoFuncToString):
        (JSC::stringProtoFuncCharAt):
        (JSC::stringProtoFuncCharCodeAt):
        (JSC::stringProtoFuncConcat):
        (JSC::stringProtoFuncIndexOf):
        (JSC::stringProtoFuncLastIndexOf):
        (JSC::stringProtoFuncMatch):
        (JSC::stringProtoFuncSearch):
        (JSC::stringProtoFuncSlice):
        (JSC::stringProtoFuncSplit):
        (JSC::stringProtoFuncSubstr):
        (JSC::stringProtoFuncSubstring):
        (JSC::stringProtoFuncToLowerCase):
        (JSC::stringProtoFuncToUpperCase):
        (JSC::stringProtoFuncLocaleCompare):
        (JSC::stringProtoFuncBig):
        (JSC::stringProtoFuncSmall):
        (JSC::stringProtoFuncBlink):
        (JSC::stringProtoFuncBold):
        (JSC::stringProtoFuncFixed):
        (JSC::stringProtoFuncItalics):
        (JSC::stringProtoFuncStrike):
        (JSC::stringProtoFuncSub):
        (JSC::stringProtoFuncSup):
        (JSC::stringProtoFuncFontcolor):
        (JSC::stringProtoFuncFontsize):
        (JSC::stringProtoFuncAnchor):
        (JSC::stringProtoFuncLink):
        * runtime/Structure.cpp:
        (JSC::Structure::Structure):
        (JSC::Structure::changePrototypeTransition):
        (JSC::Structure::createCachedPrototypeChain):
        * runtime/Structure.h:
        (JSC::Structure::create):
        (JSC::Structure::setPrototypeWithoutTransition):
        (JSC::Structure::storedPrototype):

JavaScriptGlue:

2009-01-05  Gavin Barraclough  <baraclough@apple.com>

        Rubber Stamped by Oliver Hunt.

        Replace all uses of JSValue* with new wrapper class, JSValuePtr.
        See JavaScriptCore/ChangeLog for more detailed description.

        * JSObject.cpp:
        (nativeCallFunction):
        * JSUtils.cpp:
        (KJSValueToJSObject):
        (JSObjectKJSValue):
        (KJSValueToCFTypeInternal):
        (KJSValueToCFType):
        * JSUtils.h:
        * JSValueWrapper.cpp:
        (JSValueWrapper::JSValueWrapper):
        (JSValueWrapper::GetValue):
        (JSValueWrapper::JSObjectCopyProperty):
        (JSValueWrapper::JSObjectSetProperty):
        (JSValueWrapper::JSObjectCallFunction):
        * JSValueWrapper.h:
        * UserObjectImp.cpp:
        (UserObjectImp::callAsFunction):
        (UserObjectImp::userObjectGetter):
        (UserObjectImp::getOwnPropertySlot):
        (UserObjectImp::put):
        (UserObjectImp::toPrimitive):
        * UserObjectImp.h:
        (UserObjectImp::createStructure):

WebCore:

2009-01-05  Gavin Barraclough  <baraclough@apple.com>

        Rubber Stamped by Oliver Hunt.

        Replace all uses of JSValue* with new wrapper class, JSValuePtr.
        See JavaScriptCore/ChangeLog for more detailed description.

        * bindings/js/JSAttrCustom.cpp:
        (WebCore::JSAttr::setValue):
        * bindings/js/JSCSSRuleCustom.cpp:
        (WebCore::toJS):
        * bindings/js/JSCSSStyleDeclarationCustom.cpp:
        (WebCore::JSCSSStyleDeclaration::nameGetter):
        (WebCore::JSCSSStyleDeclaration::customPut):
        * bindings/js/JSCSSValueCustom.cpp:
        (WebCore::toJS):
        * bindings/js/JSCanvasPixelArrayCustom.h:
        (WebCore::JSCanvasPixelArray::getByIndex):
        (WebCore::JSCanvasPixelArray::indexSetter):
        * bindings/js/JSCanvasRenderingContext2DCustom.cpp:
        (WebCore::toJS):
        (WebCore::toHTMLCanvasStyle):
        (WebCore::JSCanvasRenderingContext2D::strokeStyle):
        (WebCore::JSCanvasRenderingContext2D::setStrokeStyle):
        (WebCore::JSCanvasRenderingContext2D::fillStyle):
        (WebCore::JSCanvasRenderingContext2D::setFillStyle):
        (WebCore::JSCanvasRenderingContext2D::setFillColor):
        (WebCore::JSCanvasRenderingContext2D::setStrokeColor):
        (WebCore::JSCanvasRenderingContext2D::strokeRect):
        (WebCore::JSCanvasRenderingContext2D::drawImage):
        (WebCore::JSCanvasRenderingContext2D::drawImageFromRect):
        (WebCore::JSCanvasRenderingContext2D::setShadow):
        (WebCore::JSCanvasRenderingContext2D::createPattern):
        (WebCore::JSCanvasRenderingContext2D::putImageData):
        (WebCore::JSCanvasRenderingContext2D::fillText):
        (WebCore::JSCanvasRenderingContext2D::strokeText):
        * bindings/js/JSClipboardCustom.cpp:
        (WebCore::JSClipboard::types):
        (WebCore::JSClipboard::clearData):
        (WebCore::JSClipboard::getData):
        (WebCore::JSClipboard::setData):
        (WebCore::JSClipboard::setDragImage):
        * bindings/js/JSConsoleCustom.cpp:
        (WebCore::JSConsole::profiles):
        * bindings/js/JSCustomPositionCallback.cpp:
        (WebCore::JSCustomPositionCallback::handleEvent):
        * bindings/js/JSCustomPositionErrorCallback.cpp:
        (WebCore::JSCustomPositionErrorCallback::handleEvent):
        * bindings/js/JSCustomSQLStatementCallback.cpp:
        (WebCore::JSCustomSQLStatementCallback::handleEvent):
        * bindings/js/JSCustomSQLStatementErrorCallback.cpp:
        (WebCore::JSCustomSQLStatementErrorCallback::handleEvent):
        * bindings/js/JSCustomSQLTransactionCallback.cpp:
        (WebCore::JSCustomSQLTransactionCallback::handleEvent):
        * bindings/js/JSCustomSQLTransactionErrorCallback.cpp:
        (WebCore::JSCustomSQLTransactionErrorCallback::handleEvent):
        * bindings/js/JSCustomVoidCallback.cpp:
        (WebCore::JSCustomVoidCallback::handleEvent):
        (WebCore::toVoidCallback):
        * bindings/js/JSCustomVoidCallback.h:
        * bindings/js/JSCustomXPathNSResolver.cpp:
        (WebCore::JSCustomXPathNSResolver::create):
        (WebCore::JSCustomXPathNSResolver::lookupNamespaceURI):
        * bindings/js/JSCustomXPathNSResolver.h:
        * bindings/js/JSDOMApplicationCacheCustom.cpp:
        (WebCore::JSDOMApplicationCache::add):
        (WebCore::JSDOMApplicationCache::remove):
        (WebCore::JSDOMApplicationCache::addEventListener):
        (WebCore::JSDOMApplicationCache::removeEventListener):
        * bindings/js/JSDOMBinding.cpp:
        (WebCore::jsStringOrNull):
        (WebCore::jsOwnedStringOrNull):
        (WebCore::jsStringOrUndefined):
        (WebCore::jsStringOrFalse):
        (WebCore::valueToStringWithNullCheck):
        (WebCore::valueToStringWithUndefinedOrNullCheck):
        (WebCore::reportException):
        (WebCore::reportCurrentException):
        (WebCore::setDOMException):
        (WebCore::objectToStringFunctionGetter):
        * bindings/js/JSDOMBinding.h:
        (WebCore::getDOMObjectWrapper):
        (WebCore::getDOMNodeWrapper):
        (WebCore::toJS):
        * bindings/js/JSDOMGlobalObject.cpp:
        (WebCore::JSDOMGlobalObject::findJSEventListener):
        (WebCore::JSDOMGlobalObject::findOrCreateJSEventListener):
        (WebCore::JSDOMGlobalObject::findJSUnprotectedEventListener):
        (WebCore::JSDOMGlobalObject::findOrCreateJSUnprotectedEventListener):
        * bindings/js/JSDOMGlobalObject.h:
        * bindings/js/JSDOMWindowBase.cpp:
        (WebCore::createWindow):
        (WebCore::showModalDialog):
        (jsDOMWindowBaseCrypto):
        (jsDOMWindowBaseEvent):
        (jsDOMWindowBaseImage):
        (jsDOMWindowBaseMessageChannel):
        (jsDOMWindowBaseOption):
        (jsDOMWindowBaseXMLHttpRequest):
        (jsDOMWindowBaseAudio):
        (jsDOMWindowBaseWorker):
        (jsDOMWindowBaseXSLTProcessor):
        (setJSDOMWindowBaseEvent):
        (setJSDOMWindowBaseAudio):
        (setJSDOMWindowBaseImage):
        (setJSDOMWindowBaseMessageChannel):
        (setJSDOMWindowBaseOption):
        (setJSDOMWindowBaseWorker):
        (setJSDOMWindowBaseXMLHttpRequest):
        (setJSDOMWindowBaseXSLTProcessor):
        (WebCore::JSDOMWindowBase::childFrameGetter):
        (WebCore::JSDOMWindowBase::indexGetter):
        (WebCore::JSDOMWindowBase::namedItemGetter):
        (WebCore::JSDOMWindowBase::getOwnPropertySlot):
        (WebCore::JSDOMWindowBase::put):
        (WebCore::JSDOMWindowBase::clear):
        (windowProtoFuncOpen):
        (windowProtoFuncShowModalDialog):
        (windowProtoFuncNotImplemented):
        (WebCore::JSDOMWindowBase::setReturnValueSlot):
        (WebCore::JSDOMWindowBase::installTimeout):
        (WebCore::toJS):
        (WebCore::toJSDOMWindow):
        * bindings/js/JSDOMWindowBase.h:
        * bindings/js/JSDOMWindowCustom.cpp:
        (WebCore::JSDOMWindow::lookupGetter):
        (WebCore::JSDOMWindow::lookupSetter):
        (WebCore::JSDOMWindow::setLocation):
        (WebCore::JSDOMWindow::postMessage):
        (WebCore::setTimeoutOrInterval):
        (WebCore::JSDOMWindow::setTimeout):
        (WebCore::JSDOMWindow::clearTimeout):
        (WebCore::JSDOMWindow::setInterval):
        (WebCore::JSDOMWindow::clearInterval):
        (WebCore::JSDOMWindow::atob):
        (WebCore::JSDOMWindow::btoa):
        (WebCore::JSDOMWindow::addEventListener):
        (WebCore::JSDOMWindow::removeEventListener):
        (WebCore::toDOMWindow):
        (WebCore::nonCachingStaticCloseFunctionGetter):
        (WebCore::nonCachingStaticBlurFunctionGetter):
        (WebCore::nonCachingStaticFocusFunctionGetter):
        (WebCore::nonCachingStaticPostMessageFunctionGetter):
        * bindings/js/JSDOMWindowCustom.h:
        (WebCore::JSDOMWindow::customPut):
        * bindings/js/JSDOMWindowShell.cpp:
        (WebCore::JSDOMWindowShell::put):
        (WebCore::JSDOMWindowShell::putWithAttributes):
        (WebCore::JSDOMWindowShell::lookupGetter):
        (WebCore::JSDOMWindowShell::lookupSetter):
        (WebCore::toJS):
        * bindings/js/JSDOMWindowShell.h:
        (WebCore::JSDOMWindowShell::createStructure):
        * bindings/js/JSDatabaseCustom.cpp:
        (WebCore::JSDatabase::changeVersion):
        (WebCore::JSDatabase::transaction):
        * bindings/js/JSDocumentCustom.cpp:
        (WebCore::JSDocument::location):
        (WebCore::JSDocument::setLocation):
        (WebCore::toJS):
        * bindings/js/JSElementCustom.cpp:
        (WebCore::JSElement::setAttribute):
        (WebCore::JSElement::setAttributeNode):
        (WebCore::JSElement::setAttributeNS):
        (WebCore::JSElement::setAttributeNodeNS):
        (WebCore::toJSNewlyCreated):
        * bindings/js/JSEventCustom.cpp:
        (WebCore::JSEvent::clipboardData):
        (WebCore::toJS):
        * bindings/js/JSEventListener.cpp:
        (WebCore::JSAbstractEventListener::handleEvent):
        (WebCore::eventParameterName):
        (WebCore::JSLazyEventListener::parseCode):
        * bindings/js/JSEventTarget.cpp:
        (WebCore::toJS):
        * bindings/js/JSEventTarget.h:
        * bindings/js/JSEventTargetBase.h:
        * bindings/js/JSEventTargetNodeCustom.cpp:
        (WebCore::JSEventTargetNode::addEventListener):
        (WebCore::JSEventTargetNode::removeEventListener):
        * bindings/js/JSGeolocationCustom.cpp:
        (WebCore::createPositionOptions):
        (WebCore::JSGeolocation::getCurrentPosition):
        (WebCore::JSGeolocation::watchPosition):
        * bindings/js/JSHTMLAllCollection.h:
        (WebCore::JSHTMLAllCollection::createStructure):
        * bindings/js/JSHTMLAppletElementCustom.cpp:
        (WebCore::JSHTMLAppletElement::customPut):
        (WebCore::JSHTMLAppletElement::nameGetter):
        * bindings/js/JSHTMLCollectionCustom.cpp:
        (WebCore::getNamedItems):
        (WebCore::callHTMLCollection):
        (WebCore::JSHTMLCollection::nameGetter):
        (WebCore::JSHTMLCollection::item):
        (WebCore::JSHTMLCollection::namedItem):
        (WebCore::toJS):
        * bindings/js/JSHTMLDocumentCustom.cpp:
        (WebCore::JSHTMLDocument::nameGetter):
        (WebCore::JSHTMLDocument::all):
        (WebCore::JSHTMLDocument::setAll):
        (WebCore::JSHTMLDocument::open):
        (WebCore::JSHTMLDocument::write):
        (WebCore::JSHTMLDocument::writeln):
        * bindings/js/JSHTMLEmbedElementCustom.cpp:
        (WebCore::JSHTMLEmbedElement::customPut):
        (WebCore::JSHTMLEmbedElement::nameGetter):
        * bindings/js/JSHTMLFormElementCustom.cpp:
        (WebCore::JSHTMLFormElement::nameGetter):
        * bindings/js/JSHTMLFrameElementCustom.cpp:
        (WebCore::JSHTMLFrameElement::setSrc):
        (WebCore::JSHTMLFrameElement::setLocation):
        * bindings/js/JSHTMLFrameSetElementCustom.cpp:
        (WebCore::JSHTMLFrameSetElement::nameGetter):
        * bindings/js/JSHTMLIFrameElementCustom.cpp:
        (WebCore::JSHTMLIFrameElement::setSrc):
        * bindings/js/JSHTMLInputElementCustom.cpp:
        (WebCore::JSHTMLInputElement::selectionStart):
        (WebCore::JSHTMLInputElement::selectionEnd):
        * bindings/js/JSHTMLObjectElementCustom.cpp:
        (WebCore::JSHTMLObjectElement::customPut):
        (WebCore::JSHTMLObjectElement::nameGetter):
        * bindings/js/JSHTMLOptionsCollectionCustom.cpp:
        (WebCore::JSHTMLOptionsCollection::length):
        (WebCore::JSHTMLOptionsCollection::setLength):
        (WebCore::JSHTMLOptionsCollection::indexSetter):
        (WebCore::JSHTMLOptionsCollection::add):
        (WebCore::JSHTMLOptionsCollection::remove):
        * bindings/js/JSHTMLSelectElementCustom.cpp:
        (WebCore::JSHTMLSelectElement::remove):
        (WebCore::selectIndexSetter):
        (WebCore::JSHTMLSelectElement::indexSetter):
        * bindings/js/JSHTMLSelectElementCustom.h:
        * bindings/js/JSHistoryCustom.cpp:
        (WebCore::nonCachingStaticBackFunctionGetter):
        (WebCore::nonCachingStaticForwardFunctionGetter):
        (WebCore::nonCachingStaticGoFunctionGetter):
        (WebCore::JSHistory::customPut):
        * bindings/js/JSImageDataCustom.cpp:
        (WebCore::toJS):
        * bindings/js/JSInspectedObjectWrapper.cpp:
        (WebCore::JSInspectedObjectWrapper::wrap):
        (WebCore::JSInspectedObjectWrapper::prepareIncomingValue):
        * bindings/js/JSInspectedObjectWrapper.h:
        (WebCore::JSInspectedObjectWrapper::wrapOutgoingValue):
        * bindings/js/JSInspectorCallbackWrapper.cpp:
        (WebCore::JSInspectorCallbackWrapper::wrap):
        (WebCore::JSInspectorCallbackWrapper::prepareIncomingValue):
        * bindings/js/JSInspectorCallbackWrapper.h:
        (WebCore::JSInspectorCallbackWrapper::wrapOutgoingValue):
        * bindings/js/JSJavaScriptCallFrameCustom.cpp:
        (WebCore::JSJavaScriptCallFrame::evaluate):
        (WebCore::JSJavaScriptCallFrame::thisObject):
        (WebCore::JSJavaScriptCallFrame::type):
        (WebCore::JSJavaScriptCallFrame::scopeChain):
        * bindings/js/JSLocationCustom.cpp:
        (WebCore::nonCachingStaticReplaceFunctionGetter):
        (WebCore::nonCachingStaticReloadFunctionGetter):
        (WebCore::nonCachingStaticAssignFunctionGetter):
        (WebCore::JSLocation::customPut):
        (WebCore::JSLocation::setHref):
        (WebCore::JSLocation::setProtocol):
        (WebCore::JSLocation::setHost):
        (WebCore::JSLocation::setHostname):
        (WebCore::JSLocation::setPort):
        (WebCore::JSLocation::setPathname):
        (WebCore::JSLocation::setSearch):
        (WebCore::JSLocation::setHash):
        (WebCore::JSLocation::replace):
        (WebCore::JSLocation::reload):
        (WebCore::JSLocation::assign):
        (WebCore::JSLocation::toString):
        * bindings/js/JSMessageChannelConstructor.h:
        * bindings/js/JSMessagePortCustom.cpp:
        (WebCore::JSMessagePort::startConversation):
        (WebCore::JSMessagePort::addEventListener):
        (WebCore::JSMessagePort::removeEventListener):
        * bindings/js/JSMimeTypeArrayCustom.cpp:
        (WebCore::JSMimeTypeArray::nameGetter):
        * bindings/js/JSNamedNodeMapCustom.cpp:
        (WebCore::JSNamedNodeMap::nameGetter):
        * bindings/js/JSNamedNodesCollection.cpp:
        (WebCore::JSNamedNodesCollection::lengthGetter):
        (WebCore::JSNamedNodesCollection::indexGetter):
        * bindings/js/JSNamedNodesCollection.h:
        (WebCore::JSNamedNodesCollection::createStructure):
        * bindings/js/JSNavigatorCustom.cpp:
        (WebCore::needsYouTubeQuirk):
        (WebCore::JSNavigator::appVersion):
        * bindings/js/JSNodeCustom.cpp:
        (WebCore::JSNode::insertBefore):
        (WebCore::JSNode::replaceChild):
        (WebCore::JSNode::removeChild):
        (WebCore::JSNode::appendChild):
        (WebCore::createWrapper):
        (WebCore::toJSNewlyCreated):
        (WebCore::toJS):
        * bindings/js/JSNodeFilterCondition.cpp:
        (WebCore::JSNodeFilterCondition::JSNodeFilterCondition):
        (WebCore::JSNodeFilterCondition::acceptNode):
        * bindings/js/JSNodeFilterCondition.h:
        (WebCore::JSNodeFilterCondition::create):
        * bindings/js/JSNodeFilterCustom.cpp:
        (WebCore::JSNodeFilter::acceptNode):
        (WebCore::toNodeFilter):
        * bindings/js/JSNodeIteratorCustom.cpp:
        (WebCore::JSNodeIterator::nextNode):
        (WebCore::JSNodeIterator::previousNode):
        * bindings/js/JSNodeListCustom.cpp:
        (WebCore::callNodeList):
        (WebCore::JSNodeList::nameGetter):
        * bindings/js/JSPluginArrayCustom.cpp:
        (WebCore::JSPluginArray::nameGetter):
        * bindings/js/JSPluginCustom.cpp:
        (WebCore::JSPlugin::nameGetter):
        * bindings/js/JSPluginElementFunctions.cpp:
        (WebCore::runtimeObjectGetter):
        (WebCore::runtimeObjectPropertyGetter):
        (WebCore::runtimeObjectCustomPut):
        (WebCore::callPlugin):
        * bindings/js/JSPluginElementFunctions.h:
        * bindings/js/JSQuarantinedObjectWrapper.cpp:
        (WebCore::JSQuarantinedObjectWrapper::asWrapper):
        (WebCore::JSQuarantinedObjectWrapper::cachedValueGetter):
        (WebCore::JSQuarantinedObjectWrapper::getOwnPropertySlot):
        (WebCore::JSQuarantinedObjectWrapper::put):
        (WebCore::JSQuarantinedObjectWrapper::construct):
        (WebCore::JSQuarantinedObjectWrapper::hasInstance):
        (WebCore::JSQuarantinedObjectWrapper::call):
        * bindings/js/JSQuarantinedObjectWrapper.h:
        (WebCore::JSQuarantinedObjectWrapper::createStructure):
        * bindings/js/JSRGBColor.cpp:
        (WebCore::getJSRGBColor):
        (jsRGBColorRed):
        (jsRGBColorGreen):
        (jsRGBColorBlue):
        * bindings/js/JSRGBColor.h:
        (WebCore::JSRGBColor::createStructure):
        * bindings/js/JSSQLResultSetRowListCustom.cpp:
        (WebCore::JSSQLResultSetRowList::item):
        * bindings/js/JSSQLTransactionCustom.cpp:
        (WebCore::JSSQLTransaction::executeSql):
        * bindings/js/JSSVGElementInstanceCustom.cpp:
        (WebCore::JSSVGElementInstance::addEventListener):
        (WebCore::JSSVGElementInstance::removeEventListener):
        * bindings/js/JSSVGLengthCustom.cpp:
        (WebCore::JSSVGLength::value):
        (WebCore::JSSVGLength::convertToSpecifiedUnits):
        * bindings/js/JSSVGMatrixCustom.cpp:
        (WebCore::JSSVGMatrix::multiply):
        (WebCore::JSSVGMatrix::inverse):
        (WebCore::JSSVGMatrix::translate):
        (WebCore::JSSVGMatrix::scale):
        (WebCore::JSSVGMatrix::scaleNonUniform):
        (WebCore::JSSVGMatrix::rotate):
        (WebCore::JSSVGMatrix::rotateFromVector):
        (WebCore::JSSVGMatrix::flipX):
        (WebCore::JSSVGMatrix::flipY):
        (WebCore::JSSVGMatrix::skewX):
        (WebCore::JSSVGMatrix::skewY):
        * bindings/js/JSSVGPathSegCustom.cpp:
        (WebCore::toJS):
        * bindings/js/JSSVGPathSegListCustom.cpp:
        (WebCore::JSSVGPathSegList::clear):
        (WebCore::JSSVGPathSegList::initialize):
        (WebCore::JSSVGPathSegList::getItem):
        (WebCore::JSSVGPathSegList::insertItemBefore):
        (WebCore::JSSVGPathSegList::replaceItem):
        (WebCore::JSSVGPathSegList::removeItem):
        (WebCore::JSSVGPathSegList::appendItem):
        * bindings/js/JSSVGPointListCustom.cpp:
        (WebCore::finishGetter):
        (WebCore::finishSetter):
        (WebCore::finishSetterReadOnlyResult):
        (WebCore::JSSVGPointList::clear):
        (WebCore::JSSVGPointList::initialize):
        (WebCore::JSSVGPointList::getItem):
        (WebCore::JSSVGPointList::insertItemBefore):
        (WebCore::JSSVGPointList::replaceItem):
        (WebCore::JSSVGPointList::removeItem):
        (WebCore::JSSVGPointList::appendItem):
        * bindings/js/JSSVGTransformListCustom.cpp:
        (WebCore::finishGetter):
        (WebCore::finishSetter):
        (WebCore::finishSetterReadOnlyResult):
        (WebCore::JSSVGTransformList::clear):
        (WebCore::JSSVGTransformList::initialize):
        (WebCore::JSSVGTransformList::getItem):
        (WebCore::JSSVGTransformList::insertItemBefore):
        (WebCore::JSSVGTransformList::replaceItem):
        (WebCore::JSSVGTransformList::removeItem):
        (WebCore::JSSVGTransformList::appendItem):
        * bindings/js/JSStorageCustom.cpp:
        (WebCore::JSStorage::nameGetter):
        (WebCore::JSStorage::deleteProperty):
        (WebCore::JSStorage::customPut):
        * bindings/js/JSStyleSheetCustom.cpp:
        (WebCore::toJS):
        * bindings/js/JSStyleSheetListCustom.cpp:
        (WebCore::JSStyleSheetList::nameGetter):
        * bindings/js/JSTextCustom.cpp:
        (WebCore::toJSNewlyCreated):
        * bindings/js/JSTreeWalkerCustom.cpp:
        (WebCore::JSTreeWalker::parentNode):
        (WebCore::JSTreeWalker::firstChild):
        (WebCore::JSTreeWalker::lastChild):
        (WebCore::JSTreeWalker::nextSibling):
        (WebCore::JSTreeWalker::previousSibling):
        (WebCore::JSTreeWalker::previousNode):
        (WebCore::JSTreeWalker::nextNode):
        * bindings/js/JSWorkerContextBase.cpp:
        (WebCore::JSWorkerContextBase::put):
        * bindings/js/JSWorkerContextBase.h:
        * bindings/js/JSWorkerContextCustom.cpp:
        (WebCore::JSWorkerContext::self):
        (WebCore::JSWorkerContext::setSelf):
        (WebCore::JSWorkerContext::addEventListener):
        (WebCore::JSWorkerContext::removeEventListener):
        * bindings/js/JSWorkerCustom.cpp:
        (WebCore::JSWorker::addEventListener):
        (WebCore::JSWorker::removeEventListener):
        * bindings/js/JSXMLHttpRequestCustom.cpp:
        (WebCore::JSXMLHttpRequest::open):
        (WebCore::JSXMLHttpRequest::setRequestHeader):
        (WebCore::JSXMLHttpRequest::send):
        (WebCore::JSXMLHttpRequest::getResponseHeader):
        (WebCore::JSXMLHttpRequest::overrideMimeType):
        (WebCore::JSXMLHttpRequest::addEventListener):
        (WebCore::JSXMLHttpRequest::removeEventListener):
        (WebCore::JSXMLHttpRequest::responseText):
        * bindings/js/JSXMLHttpRequestUploadCustom.cpp:
        (WebCore::JSXMLHttpRequestUpload::addEventListener):
        (WebCore::JSXMLHttpRequestUpload::removeEventListener):
        * bindings/js/JSXSLTProcessorCustom.cpp:
        (WebCore::JSXSLTProcessor::importStylesheet):
        (WebCore::JSXSLTProcessor::transformToFragment):
        (WebCore::JSXSLTProcessor::transformToDocument):
        (WebCore::JSXSLTProcessor::setParameter):
        (WebCore::JSXSLTProcessor::getParameter):
        (WebCore::JSXSLTProcessor::removeParameter):
        * bindings/js/ScheduledAction.cpp:
        (WebCore::ScheduledAction::ScheduledAction):
        (WebCore::ScheduledAction::execute):
        * bindings/js/ScheduledAction.h:
        * bindings/js/ScriptCallStack.cpp:
        (WebCore::ScriptCallStack::ScriptCallStack):
        (WebCore::ScriptCallStack::initialize):
        * bindings/js/ScriptController.cpp:
        (WebCore::ScriptController::createScriptObjectForPluginElement):
        * bindings/js/ScriptValue.cpp:
        (WebCore::ScriptValue::getString):
        (WebCore::ScriptValue::isNull):
        (WebCore::ScriptValue::isUndefined):
        * bindings/js/ScriptValue.h:
        (WebCore::ScriptValue::ScriptValue):
        (WebCore::ScriptValue::jsValue):
        * bindings/objc/WebScriptObject.mm:
        (-[WebScriptObject callWebScriptMethod:withArguments:]):
        (-[WebScriptObject evaluateWebScript:]):
        (-[WebScriptObject valueForKey:]):
        (-[WebScriptObject webScriptValueAtIndex:]):
        (+[WebScriptObject _convertValueToObjcValue:originRootObject:rootObject:]):
        * bindings/objc/WebScriptObjectPrivate.h:
        * bindings/scripts/CodeGeneratorJS.pm:
        * bridge/NP_jsobject.cpp:
        (_NPN_InvokeDefault):
        (_NPN_Invoke):
        (_NPN_Evaluate):
        (_NPN_GetProperty):
        (_NPN_HasMethod):
        (_NPN_Construct):
        * bridge/c/c_instance.cpp:
        (JSC::Bindings::CInstance::invokeMethod):
        (JSC::Bindings::CInstance::invokeDefaultMethod):
        (JSC::Bindings::CInstance::invokeConstruct):
        (JSC::Bindings::CInstance::defaultValue):
        (JSC::Bindings::CInstance::stringValue):
        (JSC::Bindings::CInstance::numberValue):
        (JSC::Bindings::CInstance::booleanValue):
        (JSC::Bindings::CInstance::valueOf):
        * bridge/c/c_instance.h:
        * bridge/c/c_runtime.cpp:
        (JSC::Bindings::CField::valueFromInstance):
        (JSC::Bindings::CField::setValueToInstance):
        * bridge/c/c_runtime.h:
        * bridge/c/c_utility.cpp:
        (JSC::Bindings::convertValueToNPVariant):
        (JSC::Bindings::convertNPVariantToValue):
        * bridge/c/c_utility.h:
        * bridge/jni/jni_instance.cpp:
        (JavaInstance::stringValue):
        (JavaInstance::numberValue):
        (JavaInstance::booleanValue):
        (JavaInstance::invokeMethod):
        (JavaInstance::defaultValue):
        (JavaInstance::valueOf):
        * bridge/jni/jni_instance.h:
        * bridge/jni/jni_jsobject.h:
        * bridge/jni/jni_jsobject.mm:
        (JavaJSObject::call):
        (JavaJSObject::eval):
        (JavaJSObject::getMember):
        (JavaJSObject::getSlot):
        (JavaJSObject::convertValueToJObject):
        (JavaJSObject::convertJObjectToValue):
        * bridge/jni/jni_objc.mm:
        (JSC::Bindings::dispatchJNICall):
        * bridge/jni/jni_runtime.cpp:
        (JavaArray::convertJObjectToArray):
        (JavaField::dispatchValueFromInstance):
        (JavaField::valueFromInstance):
        (JavaField::dispatchSetValueToInstance):
        (JavaField::setValueToInstance):
        (JavaArray::setValueAt):
        (JavaArray::valueAt):
        * bridge/jni/jni_runtime.h:
        * bridge/jni/jni_utility.cpp:
        (JSC::Bindings::convertArrayInstanceToJavaArray):
        (JSC::Bindings::convertValueToJValue):
        * bridge/jni/jni_utility.h:
        * bridge/objc/WebScriptObject.h:
        * bridge/objc/objc_class.h:
        * bridge/objc/objc_class.mm:
        (JSC::Bindings::ObjcClass::fallbackObject):
        * bridge/objc/objc_instance.h:
        * bridge/objc/objc_instance.mm:
        (ObjcInstance::invokeMethod):
        (ObjcInstance::invokeDefaultMethod):
        (ObjcInstance::setValueOfUndefinedField):
        (ObjcInstance::getValueOfUndefinedField):
        (ObjcInstance::defaultValue):
        (ObjcInstance::stringValue):
        (ObjcInstance::numberValue):
        (ObjcInstance::booleanValue):
        (ObjcInstance::valueOf):
        * bridge/objc/objc_runtime.h:
        (JSC::Bindings::ObjcFallbackObjectImp::createStructure):
        * bridge/objc/objc_runtime.mm:
        (JSC::Bindings::ObjcField::valueFromInstance):
        (JSC::Bindings::convertValueToObjcObject):
        (JSC::Bindings::ObjcField::setValueToInstance):
        (JSC::Bindings::ObjcArray::setValueAt):
        (JSC::Bindings::ObjcArray::valueAt):
        (JSC::Bindings::ObjcFallbackObjectImp::put):
        (JSC::Bindings::callObjCFallbackObject):
        (JSC::Bindings::ObjcFallbackObjectImp::defaultValue):
        * bridge/objc/objc_utility.h:
        * bridge/objc/objc_utility.mm:
        (JSC::Bindings::convertValueToObjcValue):
        (JSC::Bindings::convertNSStringToString):
        (JSC::Bindings::convertObjcValueToValue):
        * bridge/runtime.cpp:
        (JSC::Bindings::Instance::getValueOfField):
        (JSC::Bindings::Instance::setValueOfField):
        * bridge/runtime.h:
        (JSC::Bindings::Class::fallbackObject):
        (JSC::Bindings::Instance::getValueOfUndefinedField):
        (JSC::Bindings::Instance::setValueOfUndefinedField):
        (JSC::Bindings::Instance::invokeDefaultMethod):
        (JSC::Bindings::Instance::invokeConstruct):
        (JSC::Bindings::Instance::valueOf):
        * bridge/runtime_array.cpp:
        (JSC::RuntimeArray::lengthGetter):
        (JSC::RuntimeArray::indexGetter):
        (JSC::RuntimeArray::put):
        * bridge/runtime_array.h:
        (JSC::RuntimeArray::createStructure):
        * bridge/runtime_method.cpp:
        (JSC::RuntimeMethod::lengthGetter):
        (JSC::callRuntimeMethod):
        * bridge/runtime_method.h:
        (JSC::RuntimeMethod::createStructure):
        * bridge/runtime_object.cpp:
        (JSC::RuntimeObjectImp::fallbackObjectGetter):
        (JSC::RuntimeObjectImp::fieldGetter):
        (JSC::RuntimeObjectImp::methodGetter):
        (JSC::RuntimeObjectImp::put):
        (JSC::RuntimeObjectImp::defaultValue):
        (JSC::callRuntimeObject):
        (JSC::callRuntimeConstructor):
        * bridge/runtime_object.h:
        (JSC::RuntimeObjectImp::createStructure):
        * inspector/InspectorController.cpp:
        * inspector/JavaScriptCallFrame.cpp:
        (WebCore::JavaScriptCallFrame::evaluate):
        * inspector/JavaScriptCallFrame.h:
        * inspector/JavaScriptProfile.cpp:
        (WebCore::toJS):
        * inspector/JavaScriptProfile.h:
        * inspector/JavaScriptProfileNode.cpp:
        (WebCore::toJS):
        * inspector/JavaScriptProfileNode.h:
        * xml/XMLHttpRequest.cpp:
        (WebCore::XMLHttpRequest::dropProtection):

WebKit/mac:

2009-01-05  Gavin Barraclough  <baraclough@apple.com>

        Rubber Stamped by Oliver Hunt.

        Replace all uses of JSValue* with new wrapper class, JSValuePtr.
        See JavaScriptCore/ChangeLog for more detailed description.

        * WebView/WebFrame.mm:
        (-[WebFrame _stringByEvaluatingJavaScriptFromString:forceUserGesture:]):
        * WebView/WebScriptDebugDelegate.mm:
        (-[WebScriptCallFrame _convertValueToObjcValue:]):
        (-[WebScriptCallFrame exception]):
        (-[WebScriptCallFrame evaluateWebScript:]):
        * WebView/WebView.mm:
        (aeDescFromJSValue):
        (-[WebView aeDescByEvaluatingJavaScriptFromString:]):

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

297 files changed:
JavaScriptCore/API/APICast.h
JavaScriptCore/API/JSCallbackConstructor.h
JavaScriptCore/API/JSCallbackFunction.cpp
JavaScriptCore/API/JSCallbackFunction.h
JavaScriptCore/API/JSCallbackObject.h
JavaScriptCore/API/JSCallbackObjectFunctions.h
JavaScriptCore/API/JSContextRef.cpp
JavaScriptCore/API/JSObjectRef.cpp
JavaScriptCore/API/JSValueRef.cpp
JavaScriptCore/ChangeLog
JavaScriptCore/JavaScriptCore.exp
JavaScriptCore/bytecode/CodeBlock.cpp
JavaScriptCore/bytecode/CodeBlock.h
JavaScriptCore/bytecode/EvalCodeCache.h
JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
JavaScriptCore/bytecompiler/BytecodeGenerator.h
JavaScriptCore/debugger/DebuggerCallFrame.cpp
JavaScriptCore/debugger/DebuggerCallFrame.h
JavaScriptCore/interpreter/CallFrame.cpp
JavaScriptCore/interpreter/CallFrame.h
JavaScriptCore/interpreter/Interpreter.cpp
JavaScriptCore/interpreter/Interpreter.h
JavaScriptCore/interpreter/Register.h
JavaScriptCore/jit/JIT.cpp
JavaScriptCore/jit/JIT.h
JavaScriptCore/jit/JITArithmetic.cpp
JavaScriptCore/jit/JITCall.cpp
JavaScriptCore/jit/JITInlineMethods.h
JavaScriptCore/jit/JITPropertyAccess.cpp
JavaScriptCore/jsc.cpp
JavaScriptCore/profiler/ProfileGenerator.cpp
JavaScriptCore/profiler/Profiler.cpp
JavaScriptCore/profiler/Profiler.h
JavaScriptCore/runtime/ArgList.cpp
JavaScriptCore/runtime/ArgList.h
JavaScriptCore/runtime/Arguments.cpp
JavaScriptCore/runtime/Arguments.h
JavaScriptCore/runtime/ArrayConstructor.cpp
JavaScriptCore/runtime/ArrayPrototype.cpp
JavaScriptCore/runtime/BooleanConstructor.cpp
JavaScriptCore/runtime/BooleanConstructor.h
JavaScriptCore/runtime/BooleanObject.h
JavaScriptCore/runtime/BooleanPrototype.cpp
JavaScriptCore/runtime/CallData.cpp
JavaScriptCore/runtime/CallData.h
JavaScriptCore/runtime/Collector.cpp
JavaScriptCore/runtime/Collector.h
JavaScriptCore/runtime/Completion.cpp
JavaScriptCore/runtime/Completion.h
JavaScriptCore/runtime/ConstructData.cpp
JavaScriptCore/runtime/ConstructData.h
JavaScriptCore/runtime/DateConstructor.cpp
JavaScriptCore/runtime/DateInstance.h
JavaScriptCore/runtime/DatePrototype.cpp
JavaScriptCore/runtime/DatePrototype.h
JavaScriptCore/runtime/ErrorConstructor.cpp
JavaScriptCore/runtime/ErrorPrototype.cpp
JavaScriptCore/runtime/ExceptionHelpers.cpp
JavaScriptCore/runtime/ExceptionHelpers.h
JavaScriptCore/runtime/FunctionConstructor.cpp
JavaScriptCore/runtime/FunctionPrototype.cpp
JavaScriptCore/runtime/FunctionPrototype.h
JavaScriptCore/runtime/GetterSetter.cpp
JavaScriptCore/runtime/GetterSetter.h
JavaScriptCore/runtime/InitializeThreading.cpp
JavaScriptCore/runtime/InternalFunction.h
JavaScriptCore/runtime/JSActivation.cpp
JavaScriptCore/runtime/JSActivation.h
JavaScriptCore/runtime/JSArray.cpp
JavaScriptCore/runtime/JSArray.h
JavaScriptCore/runtime/JSByteArray.cpp
JavaScriptCore/runtime/JSByteArray.h
JavaScriptCore/runtime/JSCell.cpp
JavaScriptCore/runtime/JSCell.h
JavaScriptCore/runtime/JSFunction.cpp
JavaScriptCore/runtime/JSFunction.h
JavaScriptCore/runtime/JSGlobalData.h
JavaScriptCore/runtime/JSGlobalObject.cpp
JavaScriptCore/runtime/JSGlobalObject.h
JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp
JavaScriptCore/runtime/JSGlobalObjectFunctions.h
JavaScriptCore/runtime/JSImmediate.cpp
JavaScriptCore/runtime/JSImmediate.h
JavaScriptCore/runtime/JSNotAnObject.cpp
JavaScriptCore/runtime/JSNotAnObject.h
JavaScriptCore/runtime/JSNumberCell.cpp
JavaScriptCore/runtime/JSNumberCell.h
JavaScriptCore/runtime/JSObject.cpp
JavaScriptCore/runtime/JSObject.h
JavaScriptCore/runtime/JSPropertyNameIterator.cpp
JavaScriptCore/runtime/JSPropertyNameIterator.h
JavaScriptCore/runtime/JSStaticScopeObject.cpp
JavaScriptCore/runtime/JSStaticScopeObject.h
JavaScriptCore/runtime/JSString.cpp
JavaScriptCore/runtime/JSString.h
JavaScriptCore/runtime/JSValue.h
JavaScriptCore/runtime/JSVariableObject.h
JavaScriptCore/runtime/JSWrapperObject.h
JavaScriptCore/runtime/Lookup.cpp
JavaScriptCore/runtime/Lookup.h
JavaScriptCore/runtime/MathObject.cpp
JavaScriptCore/runtime/MathObject.h
JavaScriptCore/runtime/NativeErrorConstructor.cpp
JavaScriptCore/runtime/NumberConstructor.cpp
JavaScriptCore/runtime/NumberConstructor.h
JavaScriptCore/runtime/NumberObject.cpp
JavaScriptCore/runtime/NumberObject.h
JavaScriptCore/runtime/NumberPrototype.cpp
JavaScriptCore/runtime/ObjectConstructor.cpp
JavaScriptCore/runtime/ObjectPrototype.cpp
JavaScriptCore/runtime/ObjectPrototype.h
JavaScriptCore/runtime/Operations.cpp
JavaScriptCore/runtime/Operations.h
JavaScriptCore/runtime/PropertySlot.cpp
JavaScriptCore/runtime/PropertySlot.h
JavaScriptCore/runtime/Protect.h
JavaScriptCore/runtime/RegExpConstructor.cpp
JavaScriptCore/runtime/RegExpConstructor.h
JavaScriptCore/runtime/RegExpMatchesArray.h
JavaScriptCore/runtime/RegExpObject.cpp
JavaScriptCore/runtime/RegExpObject.h
JavaScriptCore/runtime/RegExpPrototype.cpp
JavaScriptCore/runtime/StringConstructor.cpp
JavaScriptCore/runtime/StringObject.cpp
JavaScriptCore/runtime/StringObject.h
JavaScriptCore/runtime/StringObjectThatMasqueradesAsUndefined.h
JavaScriptCore/runtime/StringPrototype.cpp
JavaScriptCore/runtime/Structure.cpp
JavaScriptCore/runtime/Structure.h
JavaScriptGlue/ChangeLog
JavaScriptGlue/JSObject.cpp
JavaScriptGlue/JSUtils.cpp
JavaScriptGlue/JSUtils.h
JavaScriptGlue/JSValueWrapper.cpp
JavaScriptGlue/JSValueWrapper.h
JavaScriptGlue/UserObjectImp.cpp
JavaScriptGlue/UserObjectImp.h
WebCore/ChangeLog
WebCore/bindings/js/JSAttrCustom.cpp
WebCore/bindings/js/JSCSSRuleCustom.cpp
WebCore/bindings/js/JSCSSStyleDeclarationCustom.cpp
WebCore/bindings/js/JSCSSValueCustom.cpp
WebCore/bindings/js/JSCanvasRenderingContext2DCustom.cpp
WebCore/bindings/js/JSClipboardCustom.cpp
WebCore/bindings/js/JSConsoleCustom.cpp
WebCore/bindings/js/JSCustomPositionCallback.cpp
WebCore/bindings/js/JSCustomPositionErrorCallback.cpp
WebCore/bindings/js/JSCustomSQLStatementCallback.cpp
WebCore/bindings/js/JSCustomSQLStatementErrorCallback.cpp
WebCore/bindings/js/JSCustomSQLTransactionCallback.cpp
WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.cpp
WebCore/bindings/js/JSCustomVoidCallback.cpp
WebCore/bindings/js/JSCustomVoidCallback.h
WebCore/bindings/js/JSCustomXPathNSResolver.cpp
WebCore/bindings/js/JSCustomXPathNSResolver.h
WebCore/bindings/js/JSDOMApplicationCacheCustom.cpp
WebCore/bindings/js/JSDOMBinding.cpp
WebCore/bindings/js/JSDOMBinding.h
WebCore/bindings/js/JSDOMGlobalObject.cpp
WebCore/bindings/js/JSDOMGlobalObject.h
WebCore/bindings/js/JSDOMWindowBase.cpp
WebCore/bindings/js/JSDOMWindowBase.h
WebCore/bindings/js/JSDOMWindowCustom.cpp
WebCore/bindings/js/JSDOMWindowCustom.h
WebCore/bindings/js/JSDOMWindowShell.cpp
WebCore/bindings/js/JSDOMWindowShell.h
WebCore/bindings/js/JSDatabaseCustom.cpp
WebCore/bindings/js/JSDocumentCustom.cpp
WebCore/bindings/js/JSElementCustom.cpp
WebCore/bindings/js/JSEventCustom.cpp
WebCore/bindings/js/JSEventListener.cpp
WebCore/bindings/js/JSEventTarget.cpp
WebCore/bindings/js/JSEventTarget.h
WebCore/bindings/js/JSEventTargetBase.h
WebCore/bindings/js/JSEventTargetNodeCustom.cpp
WebCore/bindings/js/JSGeolocationCustom.cpp
WebCore/bindings/js/JSHTMLAllCollection.h
WebCore/bindings/js/JSHTMLAppletElementCustom.cpp
WebCore/bindings/js/JSHTMLCollectionCustom.cpp
WebCore/bindings/js/JSHTMLDocumentCustom.cpp
WebCore/bindings/js/JSHTMLEmbedElementCustom.cpp
WebCore/bindings/js/JSHTMLFormElementCustom.cpp
WebCore/bindings/js/JSHTMLFrameElementCustom.cpp
WebCore/bindings/js/JSHTMLFrameSetElementCustom.cpp
WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp
WebCore/bindings/js/JSHTMLInputElementCustom.cpp
WebCore/bindings/js/JSHTMLObjectElementCustom.cpp
WebCore/bindings/js/JSHTMLOptionsCollectionCustom.cpp
WebCore/bindings/js/JSHTMLSelectElementCustom.cpp
WebCore/bindings/js/JSHTMLSelectElementCustom.h
WebCore/bindings/js/JSHistoryCustom.cpp
WebCore/bindings/js/JSImageDataCustom.cpp
WebCore/bindings/js/JSInspectedObjectWrapper.cpp
WebCore/bindings/js/JSInspectedObjectWrapper.h
WebCore/bindings/js/JSInspectorCallbackWrapper.cpp
WebCore/bindings/js/JSInspectorCallbackWrapper.h
WebCore/bindings/js/JSJavaScriptCallFrameCustom.cpp
WebCore/bindings/js/JSLocationCustom.cpp
WebCore/bindings/js/JSMessageChannelConstructor.h
WebCore/bindings/js/JSMessagePortCustom.cpp
WebCore/bindings/js/JSMimeTypeArrayCustom.cpp
WebCore/bindings/js/JSNamedNodeMapCustom.cpp
WebCore/bindings/js/JSNamedNodesCollection.cpp
WebCore/bindings/js/JSNamedNodesCollection.h
WebCore/bindings/js/JSNavigatorCustom.cpp
WebCore/bindings/js/JSNodeCustom.cpp
WebCore/bindings/js/JSNodeFilterCondition.cpp
WebCore/bindings/js/JSNodeFilterCondition.h
WebCore/bindings/js/JSNodeFilterCustom.cpp
WebCore/bindings/js/JSNodeIteratorCustom.cpp
WebCore/bindings/js/JSNodeListCustom.cpp
WebCore/bindings/js/JSPluginArrayCustom.cpp
WebCore/bindings/js/JSPluginCustom.cpp
WebCore/bindings/js/JSPluginElementFunctions.cpp
WebCore/bindings/js/JSPluginElementFunctions.h
WebCore/bindings/js/JSQuarantinedObjectWrapper.cpp
WebCore/bindings/js/JSQuarantinedObjectWrapper.h
WebCore/bindings/js/JSRGBColor.cpp
WebCore/bindings/js/JSRGBColor.h
WebCore/bindings/js/JSSQLResultSetRowListCustom.cpp
WebCore/bindings/js/JSSQLTransactionCustom.cpp
WebCore/bindings/js/JSSVGElementInstanceCustom.cpp
WebCore/bindings/js/JSSVGLengthCustom.cpp
WebCore/bindings/js/JSSVGMatrixCustom.cpp
WebCore/bindings/js/JSSVGPathSegCustom.cpp
WebCore/bindings/js/JSSVGPathSegListCustom.cpp
WebCore/bindings/js/JSSVGPointListCustom.cpp
WebCore/bindings/js/JSSVGTransformListCustom.cpp
WebCore/bindings/js/JSStorageCustom.cpp
WebCore/bindings/js/JSStyleSheetCustom.cpp
WebCore/bindings/js/JSStyleSheetListCustom.cpp
WebCore/bindings/js/JSTextCustom.cpp
WebCore/bindings/js/JSTreeWalkerCustom.cpp
WebCore/bindings/js/JSWorkerContextBase.cpp
WebCore/bindings/js/JSWorkerContextBase.h
WebCore/bindings/js/JSWorkerContextCustom.cpp
WebCore/bindings/js/JSWorkerCustom.cpp
WebCore/bindings/js/JSXMLHttpRequestCustom.cpp
WebCore/bindings/js/JSXMLHttpRequestUploadCustom.cpp
WebCore/bindings/js/JSXSLTProcessorCustom.cpp
WebCore/bindings/js/ScheduledAction.cpp
WebCore/bindings/js/ScheduledAction.h
WebCore/bindings/js/ScriptCallStack.cpp
WebCore/bindings/js/ScriptController.cpp
WebCore/bindings/js/ScriptValue.h
WebCore/bindings/objc/WebScriptObject.mm
WebCore/bindings/objc/WebScriptObjectPrivate.h
WebCore/bindings/scripts/CodeGeneratorJS.pm
WebCore/bridge/NP_jsobject.cpp
WebCore/bridge/c/c_instance.cpp
WebCore/bridge/c/c_instance.h
WebCore/bridge/c/c_runtime.cpp
WebCore/bridge/c/c_runtime.h
WebCore/bridge/c/c_utility.cpp
WebCore/bridge/c/c_utility.h
WebCore/bridge/jni/jni_instance.cpp
WebCore/bridge/jni/jni_instance.h
WebCore/bridge/jni/jni_jsobject.h
WebCore/bridge/jni/jni_jsobject.mm
WebCore/bridge/jni/jni_objc.mm
WebCore/bridge/jni/jni_runtime.cpp
WebCore/bridge/jni/jni_runtime.h
WebCore/bridge/jni/jni_utility.cpp
WebCore/bridge/jni/jni_utility.h
WebCore/bridge/objc/WebScriptObject.h
WebCore/bridge/objc/objc_class.h
WebCore/bridge/objc/objc_class.mm
WebCore/bridge/objc/objc_instance.h
WebCore/bridge/objc/objc_instance.mm
WebCore/bridge/objc/objc_runtime.h
WebCore/bridge/objc/objc_runtime.mm
WebCore/bridge/objc/objc_utility.h
WebCore/bridge/objc/objc_utility.mm
WebCore/bridge/runtime.cpp
WebCore/bridge/runtime.h
WebCore/bridge/runtime_array.cpp
WebCore/bridge/runtime_array.h
WebCore/bridge/runtime_method.cpp
WebCore/bridge/runtime_method.h
WebCore/bridge/runtime_object.cpp
WebCore/bridge/runtime_object.h
WebCore/inspector/InspectorController.cpp
WebCore/inspector/JavaScriptCallFrame.cpp
WebCore/inspector/JavaScriptCallFrame.h
WebCore/inspector/JavaScriptProfile.cpp
WebCore/inspector/JavaScriptProfile.h
WebCore/inspector/JavaScriptProfileNode.cpp
WebCore/inspector/JavaScriptProfileNode.h
WebCore/plugins/PluginView.cpp
WebCore/xml/XMLHttpRequest.cpp
WebKit/mac/ChangeLog
WebKit/mac/WebView/WebFrame.mm
WebKit/mac/WebView/WebScriptDebugDelegate.mm
WebKit/mac/WebView/WebView.mm
WebKit/win/WebScriptCallFrame.cpp
WebKit/win/WebScriptCallFrame.h
WebKit/win/WebView.cpp

index adb1902..d356bca 100644 (file)
 #ifndef APICast_h
 #define APICast_h
 
+#include "JSValue.h"
+
 namespace JSC {
     class ExecState;
     class PropertyNameArray;
     class JSGlobalData;
     class JSObject;
     class JSValue;
+    class JSValuePtr;
 }
 
 typedef const struct OpaqueJSContextGroup* JSContextGroupRef;
@@ -53,9 +56,9 @@ inline JSC::ExecState* toJS(JSGlobalContextRef c)
     return reinterpret_cast<JSC::ExecState*>(c);
 }
 
-inline JSC::JSValue* toJS(JSValueRef v)
+inline JSC::JSValuePtr toJS(JSValueRef v)
 {
-    return reinterpret_cast<JSC::JSValue*>(const_cast<OpaqueJSValue*>(v));
+    return JSC::JSValuePtr::decode(reinterpret_cast<JSC::JSValueEncodedAsPointer*>(const_cast<OpaqueJSValue*>(v)));
 }
 
 inline JSC::JSObject* toJS(JSObjectRef o)
@@ -73,14 +76,14 @@ inline JSC::JSGlobalData* toJS(JSContextGroupRef g)
     return reinterpret_cast<JSC::JSGlobalData*>(const_cast<OpaqueJSContextGroup*>(g));
 }
 
-inline JSValueRef toRef(JSC::JSValue* v)
+inline JSValueRef toRef(JSC::JSValuePtr v)
 {
-    return reinterpret_cast<JSValueRef>(v);
+    return reinterpret_cast<JSValueRef>(JSC::JSValuePtr::encode(v));
 }
 
-inline JSValueRef* toRef(JSC::JSValue** v)
+inline JSValueRef* toRef(JSC::JSValuePtr* v)
 {
-    return reinterpret_cast<JSValueRef*>(const_cast<const JSC::JSValue**>(v));
+    return reinterpret_cast<JSValueRef*>(v);
 }
 
 inline JSObjectRef toRef(JSC::JSObject* o)
index 9e80509..cb8307f 100644 (file)
@@ -39,7 +39,7 @@ public:
     JSObjectCallAsConstructorCallback callback() const { return m_callback; }
     static const ClassInfo info;
     
-    static PassRefPtr<Structure> createStructure(JSValue* proto) 
+    static PassRefPtr<Structure> createStructure(JSValuePtr proto) 
     { 
         return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | HasStandardGetOwnPropertySlot)); 
     }
index 45d726a..b82932e 100644 (file)
@@ -46,7 +46,7 @@ JSCallbackFunction::JSCallbackFunction(ExecState* exec, JSObjectCallAsFunctionCa
 {
 }
 
-JSValue* JSCallbackFunction::call(ExecState* exec, JSObject* functionObject, JSValue* thisValue, const ArgList& args)
+JSValuePtr JSCallbackFunction::call(ExecState* exec, JSObject* functionObject, JSValuePtr thisValue, const ArgList& args)
 {
     JSContextRef execRef = toRef(exec);
     JSObjectRef functionRef = toRef(functionObject);
index 1ad122f..46f6fcc 100644 (file)
@@ -39,7 +39,7 @@ public:
     
     // InternalFunction mish-mashes constructor and function behavior -- we should 
     // refactor the code so this override isn't necessary
-    static PassRefPtr<Structure> createStructure(JSValue* proto) 
+    static PassRefPtr<Structure> createStructure(JSValuePtr proto) 
     { 
         return Structure::create(proto, TypeInfo(ObjectType, HasStandardGetOwnPropertySlot)); 
     }
@@ -48,7 +48,7 @@ private:
     virtual CallType getCallData(CallData&);
     virtual const ClassInfo* classInfo() const { return &info; }
 
-    static JSValue* call(ExecState*, JSObject*, JSValue*, const ArgList&);
+    static JSValuePtr call(ExecState*, JSObject*, JSValuePtr, const ArgList&);
 
     JSObjectCallAsFunctionCallback m_callback;
 };
index 4f3571e..9001c43 100644 (file)
@@ -48,7 +48,7 @@ public:
     JSClassRef classRef() const { return m_callbackObjectData->jsClass; }
     bool inherits(JSClassRef) const;
 
-    static PassRefPtr<Structure> createStructure(JSValue* proto) 
+    static PassRefPtr<Structure> createStructure(JSValuePtr proto) 
     { 
         return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | OverridesHasInstance)); 
     }
@@ -59,12 +59,12 @@ private:
     virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
     virtual bool getOwnPropertySlot(ExecState*, unsigned, PropertySlot&);
     
-    virtual void put(ExecState*, const Identifier&, JSValue*, PutPropertySlot&);
+    virtual void put(ExecState*, const Identifier&, JSValuePtr, PutPropertySlot&);
 
     virtual bool deleteProperty(ExecState*, const Identifier&);
     virtual bool deleteProperty(ExecState*, unsigned);
 
-    virtual bool hasInstance(ExecState* exec, JSValue* value, JSValue* proto);
+    virtual bool hasInstance(ExecState* exec, JSValuePtr value, JSValuePtr proto);
 
     virtual void getPropertyNames(ExecState*, PropertyNameArray&);
 
@@ -77,14 +77,14 @@ private:
 
     void init(ExecState*);
  
-    static JSCallbackObject* asCallbackObject(JSValue*);
+    static JSCallbackObject* asCallbackObject(JSValuePtr);
  
-    static JSValue* call(ExecState*, JSObject* functionObject, JSValue* thisValue, const ArgList&);
+    static JSValuePtr call(ExecState*, JSObject* functionObject, JSValuePtr thisValue, const ArgList&);
     static JSObject* construct(ExecState*, JSObject* constructor, const ArgList&);
    
-    static JSValue* staticValueGetter(ExecState*, const Identifier&, const PropertySlot&);
-    static JSValue* staticFunctionGetter(ExecState*, const Identifier&, const PropertySlot&);
-    static JSValue* callbackGetter(ExecState*, const Identifier&, const PropertySlot&);
+    static JSValuePtr staticValueGetter(ExecState*, const Identifier&, const PropertySlot&);
+    static JSValuePtr staticFunctionGetter(ExecState*, const Identifier&, const PropertySlot&);
+    static JSValuePtr callbackGetter(ExecState*, const Identifier&, const PropertySlot&);
 
     struct JSCallbackObjectData {
         JSCallbackObjectData(void* privateData, JSClassRef jsClass)
index 9aa5c06..fdbafbc 100644 (file)
@@ -40,7 +40,7 @@
 namespace JSC {
 
 template <class Base>
-inline JSCallbackObject<Base>* JSCallbackObject<Base>::asCallbackObject(JSValue* value)
+inline JSCallbackObject<Base>* JSCallbackObject<Base>::asCallbackObject(JSValuePtr value)
 {
     ASSERT(asObject(value)->inherits(&info));
     return static_cast<JSCallbackObject*>(asObject(value));
@@ -157,7 +157,7 @@ bool JSCallbackObject<Base>::getOwnPropertySlot(ExecState* exec, unsigned proper
 }
 
 template <class Base>
-void JSCallbackObject<Base>::put(ExecState* exec, const Identifier& propertyName, JSValue* value, PutPropertySlot& slot)
+void JSCallbackObject<Base>::put(ExecState* exec, const Identifier& propertyName, JSValuePtr value, PutPropertySlot& slot)
 {
     JSContextRef ctx = toRef(exec);
     JSObjectRef thisRef = toRef(this);
@@ -277,7 +277,7 @@ JSObject* JSCallbackObject<Base>::construct(ExecState* exec, JSObject* construct
 }
 
 template <class Base>
-bool JSCallbackObject<Base>::hasInstance(ExecState* exec, JSValue* value, JSValue*)
+bool JSCallbackObject<Base>::hasInstance(ExecState* exec, JSValuePtr value, JSValuePtr)
 {
     JSContextRef execRef = toRef(exec);
     JSObjectRef thisRef = toRef(this);
@@ -304,7 +304,7 @@ CallType JSCallbackObject<Base>::getCallData(CallData& callData)
 }
 
 template <class Base>
-JSValue* JSCallbackObject<Base>::call(ExecState* exec, JSObject* functionObject, JSValue* thisValue, const ArgList& args)
+JSValuePtr JSCallbackObject<Base>::call(ExecState* exec, JSObject* functionObject, JSValuePtr thisValue, const ArgList& args)
 {
     JSContextRef execRef = toRef(exec);
     JSObjectRef functionRef = toRef(functionObject);
@@ -427,7 +427,7 @@ bool JSCallbackObject<Base>::inherits(JSClassRef c) const
 }
 
 template <class Base>
-JSValue* JSCallbackObject<Base>::staticValueGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot)
+JSValuePtr JSCallbackObject<Base>::staticValueGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot)
 {
     JSCallbackObject* thisObj = asCallbackObject(slot.slotBase());
     
@@ -449,7 +449,7 @@ JSValue* JSCallbackObject<Base>::staticValueGetter(ExecState* exec, const Identi
 }
 
 template <class Base>
-JSValue* JSCallbackObject<Base>::staticFunctionGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot)
+JSValuePtr JSCallbackObject<Base>::staticFunctionGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot)
 {
     JSCallbackObject* thisObj = asCallbackObject(slot.slotBase());
     
@@ -474,7 +474,7 @@ JSValue* JSCallbackObject<Base>::staticFunctionGetter(ExecState* exec, const Ide
 }
 
 template <class Base>
-JSValue* JSCallbackObject<Base>::callbackGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot)
+JSValuePtr JSCallbackObject<Base>::callbackGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot)
 {
     JSCallbackObject* thisObj = asCallbackObject(slot.slotBase());
     
index 859dcd1..40c45d3 100644 (file)
@@ -95,7 +95,7 @@ JSGlobalContextRef JSGlobalContextCreateInGroup(JSContextGroupRef group, JSClass
 
     JSGlobalObject* globalObject = new (globalData.get()) JSCallbackObject<JSGlobalObject>(globalObjectClass);
     ExecState* exec = globalObject->globalExec();
-    JSValue* prototype = globalObjectClass->prototype(exec);
+    JSValuePtr prototype = globalObjectClass->prototype(exec);
     if (!prototype)
         prototype = jsNull();
     globalObject->resetPrototype(prototype);
index 639d61b..c08b8b0 100644 (file)
@@ -103,7 +103,7 @@ JSObjectRef JSObjectMakeConstructor(JSContextRef ctx, JSClassRef jsClass, JSObje
     exec->globalData().heap.registerThread();
     JSLock lock(exec);
 
-    JSValue* jsPrototype = jsClass 
+    JSValuePtr jsPrototype = jsClass 
         ? jsClass->prototype(exec)
         : exec->lexicalGlobalObject()->objectPrototype();
     
@@ -233,7 +233,7 @@ JSValueRef JSObjectGetPrototype(JSContextRef, JSObjectRef object)
 void JSObjectSetPrototype(JSContextRef, JSObjectRef object, JSValueRef value)
 {
     JSObject* jsObject = toJS(object);
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
 
     jsObject->setPrototype(jsValue->isObject() ? jsValue : jsNull());
 }
@@ -257,7 +257,7 @@ JSValueRef JSObjectGetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef
 
     JSObject* jsObject = toJS(object);
 
-    JSValue* jsValue = jsObject->get(exec, propertyName->identifier(&exec->globalData()));
+    JSValuePtr jsValue = jsObject->get(exec, propertyName->identifier(&exec->globalData()));
     if (exec->hadException()) {
         if (exception)
             *exception = toRef(exec->exception());
@@ -274,7 +274,7 @@ void JSObjectSetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef prope
 
     JSObject* jsObject = toJS(object);
     Identifier name(propertyName->identifier(&exec->globalData()));
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
 
     if (attributes && !jsObject->hasProperty(exec, name))
         jsObject->putWithAttributes(exec, name, jsValue, attributes);
@@ -298,7 +298,7 @@ JSValueRef JSObjectGetPropertyAtIndex(JSContextRef ctx, JSObjectRef object, unsi
 
     JSObject* jsObject = toJS(object);
 
-    JSValue* jsValue = jsObject->get(exec, propertyIndex);
+    JSValuePtr jsValue = jsObject->get(exec, propertyIndex);
     if (exec->hadException()) {
         if (exception)
             *exception = toRef(exec->exception());
@@ -315,7 +315,7 @@ void JSObjectSetPropertyAtIndex(JSContextRef ctx, JSObjectRef object, unsigned p
     JSLock lock(exec);
 
     JSObject* jsObject = toJS(object);
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     
     jsObject->put(exec, propertyIndex, jsValue);
     if (exec->hadException()) {
index 4c57553..351a105 100644 (file)
@@ -43,7 +43,7 @@
 
 JSType JSValueGetType(JSContextRef, JSValueRef value)
 {
-    JSC::JSValue* jsValue = toJS(value);
+    JSC::JSValuePtr jsValue = toJS(value);
     if (jsValue->isUndefined())
         return kJSTypeUndefined;
     if (jsValue->isNull())
@@ -62,43 +62,43 @@ using namespace JSC; // placed here to avoid conflict between JSC::JSType and JS
 
 bool JSValueIsUndefined(JSContextRef, JSValueRef value)
 {
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     return jsValue->isUndefined();
 }
 
 bool JSValueIsNull(JSContextRef, JSValueRef value)
 {
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     return jsValue->isNull();
 }
 
 bool JSValueIsBoolean(JSContextRef, JSValueRef value)
 {
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     return jsValue->isBoolean();
 }
 
 bool JSValueIsNumber(JSContextRef, JSValueRef value)
 {
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     return jsValue->isNumber();
 }
 
 bool JSValueIsString(JSContextRef, JSValueRef value)
 {
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     return jsValue->isString();
 }
 
 bool JSValueIsObject(JSContextRef, JSValueRef value)
 {
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     return jsValue->isObject();
 }
 
 bool JSValueIsObjectOfClass(JSContextRef, JSValueRef value, JSClassRef jsClass)
 {
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     
     if (JSObject* o = jsValue->getObject()) {
         if (o->inherits(&JSCallbackObject<JSGlobalObject>::info))
@@ -115,8 +115,8 @@ bool JSValueIsEqual(JSContextRef ctx, JSValueRef a, JSValueRef b, JSValueRef* ex
     exec->globalData().heap.registerThread();
     JSLock lock(exec);
 
-    JSValue* jsA = toJS(a);
-    JSValue* jsB = toJS(b);
+    JSValuePtr jsA = toJS(a);
+    JSValuePtr jsB = toJS(b);
 
     bool result = equal(exec, jsA, jsB); // false if an exception is thrown
     if (exec->hadException()) {
@@ -129,8 +129,8 @@ bool JSValueIsEqual(JSContextRef ctx, JSValueRef a, JSValueRef b, JSValueRef* ex
 
 bool JSValueIsStrictEqual(JSContextRef, JSValueRef a, JSValueRef b)
 {
-    JSValue* jsA = toJS(a);
-    JSValue* jsB = toJS(b);
+    JSValuePtr jsA = toJS(a);
+    JSValuePtr jsB = toJS(b);
     
     bool result = strictEqual(jsA, jsB);
     return result;
@@ -142,7 +142,7 @@ bool JSValueIsInstanceOfConstructor(JSContextRef ctx, JSValueRef value, JSObject
     exec->globalData().heap.registerThread();
     JSLock lock(exec);
 
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     JSObject* jsConstructor = toJS(constructor);
     if (!jsConstructor->structure()->typeInfo().implementsHasInstance())
         return false;
@@ -191,7 +191,7 @@ JSValueRef JSValueMakeString(JSContextRef ctx, JSStringRef string)
 bool JSValueToBoolean(JSContextRef ctx, JSValueRef value)
 {
     ExecState* exec = toJS(ctx);
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     return jsValue->toBoolean(exec);
 }
 
@@ -201,7 +201,7 @@ double JSValueToNumber(JSContextRef ctx, JSValueRef value, JSValueRef* exception
     exec->globalData().heap.registerThread();
     JSLock lock(exec);
 
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
 
     double number = jsValue->toNumber(exec);
     if (exec->hadException()) {
@@ -219,7 +219,7 @@ JSStringRef JSValueToStringCopy(JSContextRef ctx, JSValueRef value, JSValueRef*
     exec->globalData().heap.registerThread();
     JSLock lock(exec);
 
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     
     RefPtr<OpaqueJSString> stringRef(OpaqueJSString::create(jsValue->toString(exec)));
     if (exec->hadException()) {
@@ -237,7 +237,7 @@ JSObjectRef JSValueToObject(JSContextRef ctx, JSValueRef value, JSValueRef* exce
     exec->globalData().heap.registerThread();
     JSLock lock(exec);
 
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     
     JSObjectRef objectRef = toRef(jsValue->toObject(exec));
     if (exec->hadException()) {
@@ -255,7 +255,7 @@ void JSValueProtect(JSContextRef ctx, JSValueRef value)
     exec->globalData().heap.registerThread();
     JSLock lock(exec);
 
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     gcProtect(jsValue);
 }
 
@@ -265,6 +265,6 @@ void JSValueUnprotect(JSContextRef ctx, JSValueRef value)
     exec->globalData().heap.registerThread();
     JSLock lock(exec);
 
-    JSValue* jsValue = toJS(value);
+    JSValuePtr jsValue = toJS(value);
     gcUnprotect(jsValue);
 }
index 78d9418..12a4ba3 100644 (file)
@@ -1,3 +1,884 @@
+2009-01-05  Gavin Barraclough  <baraclough@apple.com>
+
+        Reviewed by Oliver Hunt.
+
+        Replace all uses of JSValue* with a new smart pointer type, JSValuePtr.
+        
+        A JavaScript value may be a heap object or boxed primitive, represented by a
+        pointer, or may be an unboxed immediate value, such as an integer.  Since a
+        value may dynamically need to contain either a pointer value or an immediate,
+        we encode immediates as pointer values (since all valid JSCell pointers are
+        allocated at alligned addesses, unaligned addresses are available to encode
+        immediates).  As such all JavaScript values are represented using a JSValue*.
+
+        This implementation is encumbered by a number of constraints.  It ties the
+        JSValue representation to the size of pointer on the platform, which, for
+        example, means that we currently can represent different ranges of integers
+        as immediates on x86 and x86-64.  It also prevents us from overloading the
+        to-boolean conversion used to test for noValue() - effectively forcing us
+        to represent noValue() as 0.  This would potentially be problematic were we
+        to wish to encode integer values differently (e.g. were we to use the v8
+        encoding, where pointers are tagged with 1 and integers with 0, then the
+        immediate integer 0 would conflict with noValue()).
+
+        This patch replaces all usage of JSValue* with a new class, JSValuePtr,
+        which encapsulates the pointer.  JSValuePtr maintains the same interface as
+        JSValue*, overloading operator-> and operator bool such that previous
+        operations in the code on variables of type JSValue* are still supported.
+
+        In order to provide a ProtectPtr<> type with support for the new value
+        representation (without using the internal JSValue type directly), a new
+        ProtectJSValuePtr type has been added, equivalent to the previous type
+        ProtectPtr<JSValue>.
+
+        This patch is likely the first in a sequence of three changes.  With the
+        value now encapsulated it will likely make sense to migrate the functionality
+        from JSValue into JSValuePtr, such that the internal pointer representation
+        need not be exposed.  Through migrating the functionality to the wrapper
+        class the existing JSValue should be rendered redundant, and the class is
+        likely to be removed (the JSValuePtr now wrapping a pointer to a JSCell).
+        At this stage it will likely make sense to rename JSValuePtr to JSValue.
+
+        https://bugs.webkit.org/show_bug.cgi?id=23114
+
+        * API/APICast.h:
+        (toJS):
+        (toRef):
+        * API/JSBase.cpp:
+        (JSEvaluateScript):
+        * API/JSCallbackConstructor.h:
+        (JSC::JSCallbackConstructor::createStructure):
+        * API/JSCallbackFunction.cpp:
+        (JSC::JSCallbackFunction::call):
+        * API/JSCallbackFunction.h:
+        (JSC::JSCallbackFunction::createStructure):
+        * API/JSCallbackObject.h:
+        (JSC::JSCallbackObject::createStructure):
+        * API/JSCallbackObjectFunctions.h:
+        (JSC::::asCallbackObject):
+        (JSC::::put):
+        (JSC::::hasInstance):
+        (JSC::::call):
+        (JSC::::staticValueGetter):
+        (JSC::::staticFunctionGetter):
+        (JSC::::callbackGetter):
+        * API/JSContextRef.cpp:
+        * API/JSObjectRef.cpp:
+        (JSObjectMakeConstructor):
+        (JSObjectSetPrototype):
+        (JSObjectGetProperty):
+        (JSObjectSetProperty):
+        (JSObjectGetPropertyAtIndex):
+        (JSObjectSetPropertyAtIndex):
+        * API/JSValueRef.cpp:
+        (JSValueGetType):
+        (JSValueIsUndefined):
+        (JSValueIsNull):
+        (JSValueIsBoolean):
+        (JSValueIsNumber):
+        (JSValueIsString):
+        (JSValueIsObject):
+        (JSValueIsObjectOfClass):
+        (JSValueIsEqual):
+        (JSValueIsStrictEqual):
+        (JSValueIsInstanceOfConstructor):
+        (JSValueToBoolean):
+        (JSValueToNumber):
+        (JSValueToStringCopy):
+        (JSValueToObject):
+        (JSValueProtect):
+        (JSValueUnprotect):
+        * JavaScriptCore.exp:
+        * bytecode/CodeBlock.cpp:
+        (JSC::valueToSourceString):
+        (JSC::constantName):
+        (JSC::CodeBlock::dump):
+        * bytecode/CodeBlock.h:
+        (JSC::CodeBlock::getConstant):
+        (JSC::CodeBlock::addUnexpectedConstant):
+        (JSC::CodeBlock::unexpectedConstant):
+        * bytecode/EvalCodeCache.h:
+        (JSC::EvalCodeCache::get):
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::BytecodeGenerator):
+        (JSC::BytecodeGenerator::addConstant):
+        (JSC::BytecodeGenerator::addUnexpectedConstant):
+        (JSC::BytecodeGenerator::emitLoad):
+        (JSC::BytecodeGenerator::emitLoadJSV):
+        (JSC::BytecodeGenerator::emitGetScopedVar):
+        (JSC::BytecodeGenerator::emitPutScopedVar):
+        (JSC::BytecodeGenerator::emitNewError):
+        (JSC::keyForImmediateSwitch):
+        * bytecompiler/BytecodeGenerator.h:
+        (JSC::BytecodeGenerator::JSValueHashTraits::constructDeletedValue):
+        (JSC::BytecodeGenerator::JSValueHashTraits::isDeletedValue):
+        * debugger/DebuggerCallFrame.cpp:
+        (JSC::DebuggerCallFrame::evaluate):
+        * debugger/DebuggerCallFrame.h:
+        (JSC::DebuggerCallFrame::DebuggerCallFrame):
+        (JSC::DebuggerCallFrame::exception):
+        * interpreter/CallFrame.cpp:
+        (JSC::CallFrame::thisValue):
+        * interpreter/CallFrame.h:
+        (JSC::ExecState::setException):
+        (JSC::ExecState::exception):
+        (JSC::ExecState::exceptionSlot):
+        (JSC::ExecState::hadException):
+        * interpreter/Interpreter.cpp:
+        (JSC::fastIsNumber):
+        (JSC::fastToInt32):
+        (JSC::fastToUInt32):
+        (JSC::jsLess):
+        (JSC::jsLessEq):
+        (JSC::jsAddSlowCase):
+        (JSC::jsAdd):
+        (JSC::jsTypeStringForValue):
+        (JSC::jsIsObjectType):
+        (JSC::jsIsFunctionType):
+        (JSC::Interpreter::resolve):
+        (JSC::Interpreter::resolveSkip):
+        (JSC::Interpreter::resolveGlobal):
+        (JSC::inlineResolveBase):
+        (JSC::Interpreter::resolveBase):
+        (JSC::Interpreter::resolveBaseAndProperty):
+        (JSC::Interpreter::resolveBaseAndFunc):
+        (JSC::isNotObject):
+        (JSC::Interpreter::callEval):
+        (JSC::Interpreter::unwindCallFrame):
+        (JSC::Interpreter::throwException):
+        (JSC::Interpreter::execute):
+        (JSC::Interpreter::checkTimeout):
+        (JSC::Interpreter::createExceptionScope):
+        (JSC::cachePrototypeChain):
+        (JSC::Interpreter::tryCachePutByID):
+        (JSC::countPrototypeChainEntriesAndCheckForProxies):
+        (JSC::Interpreter::tryCacheGetByID):
+        (JSC::Interpreter::privateExecute):
+        (JSC::Interpreter::retrieveArguments):
+        (JSC::Interpreter::retrieveCaller):
+        (JSC::Interpreter::retrieveLastCaller):
+        (JSC::Interpreter::tryCTICachePutByID):
+        (JSC::Interpreter::tryCTICacheGetByID):
+        (JSC::returnToThrowTrampoline):
+        (JSC::Interpreter::cti_op_convert_this):
+        (JSC::Interpreter::cti_op_add):
+        (JSC::Interpreter::cti_op_pre_inc):
+        (JSC::Interpreter::cti_op_loop_if_less):
+        (JSC::Interpreter::cti_op_loop_if_lesseq):
+        (JSC::Interpreter::cti_op_get_by_id_generic):
+        (JSC::Interpreter::cti_op_get_by_id):
+        (JSC::Interpreter::cti_op_get_by_id_second):
+        (JSC::Interpreter::cti_op_get_by_id_self_fail):
+        (JSC::Interpreter::cti_op_get_by_id_proto_list):
+        (JSC::Interpreter::cti_op_get_by_id_proto_list_full):
+        (JSC::Interpreter::cti_op_get_by_id_proto_fail):
+        (JSC::Interpreter::cti_op_get_by_id_array_fail):
+        (JSC::Interpreter::cti_op_get_by_id_string_fail):
+        (JSC::Interpreter::cti_op_instanceof):
+        (JSC::Interpreter::cti_op_del_by_id):
+        (JSC::Interpreter::cti_op_mul):
+        (JSC::Interpreter::cti_op_call_NotJSFunction):
+        (JSC::Interpreter::cti_op_resolve):
+        (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_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_bitor):
+        (JSC::Interpreter::cti_op_call_eval):
+        (JSC::Interpreter::cti_op_throw):
+        (JSC::Interpreter::cti_op_next_pname):
+        (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_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_new_error):
+        (JSC::Interpreter::cti_vm_throw):
+        * interpreter/Interpreter.h:
+        (JSC::Interpreter::isJSArray):
+        (JSC::Interpreter::isJSString):
+        * interpreter/Register.h:
+        (JSC::Register::):
+        (JSC::Register::Register):
+        (JSC::Register::jsValue):
+        (JSC::Register::getJSValue):
+        * jit/JIT.cpp:
+        (JSC::):
+        (JSC::JIT::compileOpStrictEq):
+        (JSC::JIT::privateCompileMainPass):
+        (JSC::JIT::privateCompileSlowCases):
+        * jit/JIT.h:
+        (JSC::):
+        (JSC::JIT::execute):
+        * jit/JITArithmetic.cpp:
+        (JSC::JIT::compileFastArith_op_rshift):
+        (JSC::JIT::compileFastArithSlow_op_rshift):
+        * jit/JITCall.cpp:
+        (JSC::JIT::unlinkCall):
+        (JSC::JIT::compileOpCallInitializeCallFrame):
+        (JSC::JIT::compileOpCall):
+        * jit/JITInlineMethods.h:
+        (JSC::JIT::emitGetVirtualRegister):
+        (JSC::JIT::getConstantOperand):
+        (JSC::JIT::isOperandConstant31BitImmediateInt):
+        (JSC::JIT::emitPutJITStubArgFromVirtualRegister):
+        (JSC::JIT::emitInitRegister):
+        * jit/JITPropertyAccess.cpp:
+        (JSC::resizePropertyStorage):
+        (JSC::JIT::privateCompilePutByIdTransition):
+        (JSC::JIT::patchGetByIdSelf):
+        (JSC::JIT::patchPutByIdReplace):
+        (JSC::JIT::privateCompileGetByIdSelf):
+        (JSC::JIT::privateCompileGetByIdProto):
+        (JSC::JIT::privateCompileGetByIdSelfList):
+        (JSC::JIT::privateCompileGetByIdProtoList):
+        (JSC::JIT::privateCompileGetByIdChainList):
+        (JSC::JIT::privateCompileGetByIdChain):
+        (JSC::JIT::privateCompilePutByIdReplace):
+        * jsc.cpp:
+        (functionPrint):
+        (functionDebug):
+        (functionGC):
+        (functionVersion):
+        (functionRun):
+        (functionLoad):
+        (functionReadline):
+        (functionQuit):
+        * parser/Nodes.cpp:
+        (JSC::NullNode::emitBytecode):
+        (JSC::ArrayNode::emitBytecode):
+        (JSC::FunctionCallValueNode::emitBytecode):
+        (JSC::FunctionCallResolveNode::emitBytecode):
+        (JSC::VoidNode::emitBytecode):
+        (JSC::ConstDeclNode::emitCodeSingle):
+        (JSC::ReturnNode::emitBytecode):
+        (JSC::processClauseList):
+        (JSC::EvalNode::emitBytecode):
+        (JSC::FunctionBodyNode::emitBytecode):
+        (JSC::ProgramNode::emitBytecode):
+        * profiler/ProfileGenerator.cpp:
+        (JSC::ProfileGenerator::addParentForConsoleStart):
+        * profiler/Profiler.cpp:
+        (JSC::Profiler::willExecute):
+        (JSC::Profiler::didExecute):
+        (JSC::Profiler::createCallIdentifier):
+        * profiler/Profiler.h:
+        * runtime/ArgList.cpp:
+        (JSC::ArgList::slowAppend):
+        * runtime/ArgList.h:
+        (JSC::ArgList::at):
+        (JSC::ArgList::append):
+        * runtime/Arguments.cpp:
+        (JSC::Arguments::put):
+        * runtime/Arguments.h:
+        (JSC::Arguments::createStructure):
+        (JSC::asArguments):
+        * runtime/ArrayConstructor.cpp:
+        (JSC::callArrayConstructor):
+        * runtime/ArrayPrototype.cpp:
+        (JSC::getProperty):
+        (JSC::putProperty):
+        (JSC::arrayProtoFuncToString):
+        (JSC::arrayProtoFuncToLocaleString):
+        (JSC::arrayProtoFuncJoin):
+        (JSC::arrayProtoFuncConcat):
+        (JSC::arrayProtoFuncPop):
+        (JSC::arrayProtoFuncPush):
+        (JSC::arrayProtoFuncReverse):
+        (JSC::arrayProtoFuncShift):
+        (JSC::arrayProtoFuncSlice):
+        (JSC::arrayProtoFuncSort):
+        (JSC::arrayProtoFuncSplice):
+        (JSC::arrayProtoFuncUnShift):
+        (JSC::arrayProtoFuncFilter):
+        (JSC::arrayProtoFuncMap):
+        (JSC::arrayProtoFuncEvery):
+        (JSC::arrayProtoFuncForEach):
+        (JSC::arrayProtoFuncSome):
+        (JSC::arrayProtoFuncIndexOf):
+        (JSC::arrayProtoFuncLastIndexOf):
+        * runtime/BooleanConstructor.cpp:
+        (JSC::callBooleanConstructor):
+        (JSC::constructBooleanFromImmediateBoolean):
+        * runtime/BooleanConstructor.h:
+        * runtime/BooleanObject.h:
+        (JSC::asBooleanObject):
+        * runtime/BooleanPrototype.cpp:
+        (JSC::booleanProtoFuncToString):
+        (JSC::booleanProtoFuncValueOf):
+        * runtime/CallData.cpp:
+        (JSC::call):
+        * runtime/CallData.h:
+        * runtime/Collector.cpp:
+        (JSC::Heap::protect):
+        (JSC::Heap::unprotect):
+        (JSC::Heap::heap):
+        (JSC::Heap::collect):
+        * runtime/Collector.h:
+        * runtime/Completion.cpp:
+        (JSC::evaluate):
+        * runtime/Completion.h:
+        (JSC::Completion::Completion):
+        (JSC::Completion::value):
+        (JSC::Completion::setValue):
+        (JSC::Completion::isValueCompletion):
+        * runtime/ConstructData.cpp:
+        (JSC::construct):
+        * runtime/ConstructData.h:
+        * runtime/DateConstructor.cpp:
+        (JSC::constructDate):
+        (JSC::callDate):
+        (JSC::dateParse):
+        (JSC::dateNow):
+        (JSC::dateUTC):
+        * runtime/DateInstance.h:
+        (JSC::asDateInstance):
+        * runtime/DatePrototype.cpp:
+        (JSC::dateProtoFuncToString):
+        (JSC::dateProtoFuncToUTCString):
+        (JSC::dateProtoFuncToDateString):
+        (JSC::dateProtoFuncToTimeString):
+        (JSC::dateProtoFuncToLocaleString):
+        (JSC::dateProtoFuncToLocaleDateString):
+        (JSC::dateProtoFuncToLocaleTimeString):
+        (JSC::dateProtoFuncValueOf):
+        (JSC::dateProtoFuncGetTime):
+        (JSC::dateProtoFuncGetFullYear):
+        (JSC::dateProtoFuncGetUTCFullYear):
+        (JSC::dateProtoFuncToGMTString):
+        (JSC::dateProtoFuncGetMonth):
+        (JSC::dateProtoFuncGetUTCMonth):
+        (JSC::dateProtoFuncGetDate):
+        (JSC::dateProtoFuncGetUTCDate):
+        (JSC::dateProtoFuncGetDay):
+        (JSC::dateProtoFuncGetUTCDay):
+        (JSC::dateProtoFuncGetHours):
+        (JSC::dateProtoFuncGetUTCHours):
+        (JSC::dateProtoFuncGetMinutes):
+        (JSC::dateProtoFuncGetUTCMinutes):
+        (JSC::dateProtoFuncGetSeconds):
+        (JSC::dateProtoFuncGetUTCSeconds):
+        (JSC::dateProtoFuncGetMilliSeconds):
+        (JSC::dateProtoFuncGetUTCMilliseconds):
+        (JSC::dateProtoFuncGetTimezoneOffset):
+        (JSC::dateProtoFuncSetTime):
+        (JSC::setNewValueFromTimeArgs):
+        (JSC::setNewValueFromDateArgs):
+        (JSC::dateProtoFuncSetMilliSeconds):
+        (JSC::dateProtoFuncSetUTCMilliseconds):
+        (JSC::dateProtoFuncSetSeconds):
+        (JSC::dateProtoFuncSetUTCSeconds):
+        (JSC::dateProtoFuncSetMinutes):
+        (JSC::dateProtoFuncSetUTCMinutes):
+        (JSC::dateProtoFuncSetHours):
+        (JSC::dateProtoFuncSetUTCHours):
+        (JSC::dateProtoFuncSetDate):
+        (JSC::dateProtoFuncSetUTCDate):
+        (JSC::dateProtoFuncSetMonth):
+        (JSC::dateProtoFuncSetUTCMonth):
+        (JSC::dateProtoFuncSetFullYear):
+        (JSC::dateProtoFuncSetUTCFullYear):
+        (JSC::dateProtoFuncSetYear):
+        (JSC::dateProtoFuncGetYear):
+        * runtime/DatePrototype.h:
+        (JSC::DatePrototype::createStructure):
+        * runtime/ErrorConstructor.cpp:
+        (JSC::callErrorConstructor):
+        * runtime/ErrorPrototype.cpp:
+        (JSC::errorProtoFuncToString):
+        * runtime/ExceptionHelpers.cpp:
+        (JSC::createInterruptedExecutionException):
+        (JSC::createError):
+        (JSC::createStackOverflowError):
+        (JSC::createUndefinedVariableError):
+        (JSC::createErrorMessage):
+        (JSC::createInvalidParamError):
+        (JSC::createNotAConstructorError):
+        (JSC::createNotAFunctionError):
+        * runtime/ExceptionHelpers.h:
+        * runtime/FunctionConstructor.cpp:
+        (JSC::callFunctionConstructor):
+        * runtime/FunctionPrototype.cpp:
+        (JSC::callFunctionPrototype):
+        (JSC::functionProtoFuncToString):
+        (JSC::functionProtoFuncApply):
+        (JSC::functionProtoFuncCall):
+        * runtime/FunctionPrototype.h:
+        (JSC::FunctionPrototype::createStructure):
+        * runtime/GetterSetter.cpp:
+        (JSC::GetterSetter::toPrimitive):
+        (JSC::GetterSetter::getPrimitiveNumber):
+        * runtime/GetterSetter.h:
+        (JSC::asGetterSetter):
+        * runtime/InitializeThreading.cpp:
+        * runtime/InternalFunction.h:
+        (JSC::InternalFunction::createStructure):
+        (JSC::asInternalFunction):
+        * runtime/JSActivation.cpp:
+        (JSC::JSActivation::getOwnPropertySlot):
+        (JSC::JSActivation::put):
+        (JSC::JSActivation::putWithAttributes):
+        (JSC::JSActivation::argumentsGetter):
+        * runtime/JSActivation.h:
+        (JSC::JSActivation::createStructure):
+        (JSC::asActivation):
+        * runtime/JSArray.cpp:
+        (JSC::storageSize):
+        (JSC::JSArray::JSArray):
+        (JSC::JSArray::getOwnPropertySlot):
+        (JSC::JSArray::put):
+        (JSC::JSArray::putSlowCase):
+        (JSC::JSArray::deleteProperty):
+        (JSC::JSArray::getPropertyNames):
+        (JSC::JSArray::setLength):
+        (JSC::JSArray::pop):
+        (JSC::JSArray::push):
+        (JSC::JSArray::mark):
+        (JSC::JSArray::sort):
+        (JSC::JSArray::compactForSorting):
+        (JSC::JSArray::checkConsistency):
+        (JSC::constructArray):
+        * runtime/JSArray.h:
+        (JSC::JSArray::getIndex):
+        (JSC::JSArray::setIndex):
+        (JSC::JSArray::createStructure):
+        (JSC::asArray):
+        * runtime/JSCell.cpp:
+        (JSC::JSCell::put):
+        (JSC::JSCell::getJSNumber):
+        * runtime/JSCell.h:
+        (JSC::asCell):
+        (JSC::JSValue::asCell):
+        (JSC::JSValue::toPrimitive):
+        (JSC::JSValue::getPrimitiveNumber):
+        (JSC::JSValue::getJSNumber):
+        * runtime/JSFunction.cpp:
+        (JSC::JSFunction::call):
+        (JSC::JSFunction::argumentsGetter):
+        (JSC::JSFunction::callerGetter):
+        (JSC::JSFunction::lengthGetter):
+        (JSC::JSFunction::getOwnPropertySlot):
+        (JSC::JSFunction::put):
+        (JSC::JSFunction::construct):
+        * runtime/JSFunction.h:
+        (JSC::JSFunction::createStructure):
+        (JSC::asFunction):
+        * runtime/JSGlobalData.h:
+        * runtime/JSGlobalObject.cpp:
+        (JSC::markIfNeeded):
+        (JSC::JSGlobalObject::put):
+        (JSC::JSGlobalObject::putWithAttributes):
+        (JSC::JSGlobalObject::reset):
+        (JSC::JSGlobalObject::resetPrototype):
+        * runtime/JSGlobalObject.h:
+        (JSC::JSGlobalObject::createStructure):
+        (JSC::JSGlobalObject::GlobalPropertyInfo::GlobalPropertyInfo):
+        (JSC::asGlobalObject):
+        (JSC::Structure::prototypeForLookup):
+        * runtime/JSGlobalObjectFunctions.cpp:
+        (JSC::encode):
+        (JSC::decode):
+        (JSC::globalFuncEval):
+        (JSC::globalFuncParseInt):
+        (JSC::globalFuncParseFloat):
+        (JSC::globalFuncIsNaN):
+        (JSC::globalFuncIsFinite):
+        (JSC::globalFuncDecodeURI):
+        (JSC::globalFuncDecodeURIComponent):
+        (JSC::globalFuncEncodeURI):
+        (JSC::globalFuncEncodeURIComponent):
+        (JSC::globalFuncEscape):
+        (JSC::globalFuncUnescape):
+        (JSC::globalFuncJSCPrint):
+        * runtime/JSGlobalObjectFunctions.h:
+        * runtime/JSImmediate.cpp:
+        (JSC::JSImmediate::toThisObject):
+        (JSC::JSImmediate::toObject):
+        (JSC::JSImmediate::prototype):
+        (JSC::JSImmediate::toString):
+        * runtime/JSImmediate.h:
+        (JSC::JSImmediate::isImmediate):
+        (JSC::JSImmediate::isNumber):
+        (JSC::JSImmediate::isPositiveNumber):
+        (JSC::JSImmediate::isBoolean):
+        (JSC::JSImmediate::isUndefinedOrNull):
+        (JSC::JSImmediate::isNegative):
+        (JSC::JSImmediate::isEitherImmediate):
+        (JSC::JSImmediate::isAnyImmediate):
+        (JSC::JSImmediate::areBothImmediate):
+        (JSC::JSImmediate::areBothImmediateNumbers):
+        (JSC::JSImmediate::andImmediateNumbers):
+        (JSC::JSImmediate::xorImmediateNumbers):
+        (JSC::JSImmediate::orImmediateNumbers):
+        (JSC::JSImmediate::rightShiftImmediateNumbers):
+        (JSC::JSImmediate::canDoFastAdditiveOperations):
+        (JSC::JSImmediate::addImmediateNumbers):
+        (JSC::JSImmediate::subImmediateNumbers):
+        (JSC::JSImmediate::incImmediateNumber):
+        (JSC::JSImmediate::decImmediateNumber):
+        (JSC::JSImmediate::makeValue):
+        (JSC::JSImmediate::makeInt):
+        (JSC::JSImmediate::makeBool):
+        (JSC::JSImmediate::makeUndefined):
+        (JSC::JSImmediate::makeNull):
+        (JSC::JSImmediate::intValue):
+        (JSC::JSImmediate::uintValue):
+        (JSC::JSImmediate::boolValue):
+        (JSC::JSImmediate::rawValue):
+        (JSC::JSImmediate::trueImmediate):
+        (JSC::JSImmediate::falseImmediate):
+        (JSC::JSImmediate::undefinedImmediate):
+        (JSC::JSImmediate::nullImmediate):
+        (JSC::JSImmediate::zeroImmediate):
+        (JSC::JSImmediate::oneImmediate):
+        (JSC::JSImmediate::impossibleValue):
+        (JSC::JSImmediate::toBoolean):
+        (JSC::JSImmediate::getTruncatedUInt32):
+        (JSC::JSImmediate::from):
+        (JSC::JSImmediate::getTruncatedInt32):
+        (JSC::JSImmediate::toDouble):
+        (JSC::JSImmediate::getUInt32):
+        (JSC::jsNull):
+        (JSC::jsBoolean):
+        (JSC::jsUndefined):
+        (JSC::JSValue::isUndefined):
+        (JSC::JSValue::isNull):
+        (JSC::JSValue::isUndefinedOrNull):
+        (JSC::JSValue::isBoolean):
+        (JSC::JSValue::getBoolean):
+        (JSC::JSValue::toInt32):
+        (JSC::JSValue::toUInt32):
+        (JSC::toInt32):
+        (JSC::toUInt32):
+        * runtime/JSNotAnObject.cpp:
+        (JSC::JSNotAnObject::toPrimitive):
+        (JSC::JSNotAnObject::getPrimitiveNumber):
+        (JSC::JSNotAnObject::put):
+        * runtime/JSNotAnObject.h:
+        (JSC::JSNotAnObject::createStructure):
+        * runtime/JSNumberCell.cpp:
+        (JSC::JSNumberCell::toPrimitive):
+        (JSC::JSNumberCell::getPrimitiveNumber):
+        (JSC::JSNumberCell::getJSNumber):
+        (JSC::jsNumberCell):
+        (JSC::jsNaN):
+        * runtime/JSNumberCell.h:
+        (JSC::JSNumberCell::createStructure):
+        (JSC::asNumberCell):
+        (JSC::jsNumber):
+        (JSC::JSValue::toJSNumber):
+        * runtime/JSObject.cpp:
+        (JSC::JSObject::mark):
+        (JSC::JSObject::put):
+        (JSC::JSObject::putWithAttributes):
+        (JSC::callDefaultValueFunction):
+        (JSC::JSObject::getPrimitiveNumber):
+        (JSC::JSObject::defaultValue):
+        (JSC::JSObject::defineGetter):
+        (JSC::JSObject::defineSetter):
+        (JSC::JSObject::lookupGetter):
+        (JSC::JSObject::lookupSetter):
+        (JSC::JSObject::hasInstance):
+        (JSC::JSObject::toNumber):
+        (JSC::JSObject::toString):
+        (JSC::JSObject::fillGetterPropertySlot):
+        * runtime/JSObject.h:
+        (JSC::JSObject::getDirect):
+        (JSC::JSObject::getDirectLocation):
+        (JSC::JSObject::offsetForLocation):
+        (JSC::JSObject::locationForOffset):
+        (JSC::JSObject::getDirectOffset):
+        (JSC::JSObject::putDirectOffset):
+        (JSC::JSObject::createStructure):
+        (JSC::asObject):
+        (JSC::JSObject::prototype):
+        (JSC::JSObject::setPrototype):
+        (JSC::JSObject::inlineGetOwnPropertySlot):
+        (JSC::JSObject::getOwnPropertySlotForWrite):
+        (JSC::JSObject::getPropertySlot):
+        (JSC::JSObject::get):
+        (JSC::JSObject::putDirect):
+        (JSC::JSObject::putDirectWithoutTransition):
+        (JSC::JSObject::toPrimitive):
+        (JSC::JSValue::get):
+        (JSC::JSValue::put):
+        (JSC::JSObject::allocatePropertyStorageInline):
+        * runtime/JSPropertyNameIterator.cpp:
+        (JSC::JSPropertyNameIterator::toPrimitive):
+        (JSC::JSPropertyNameIterator::getPrimitiveNumber):
+        * runtime/JSPropertyNameIterator.h:
+        (JSC::JSPropertyNameIterator::create):
+        (JSC::JSPropertyNameIterator::next):
+        * runtime/JSStaticScopeObject.cpp:
+        (JSC::JSStaticScopeObject::put):
+        (JSC::JSStaticScopeObject::putWithAttributes):
+        * runtime/JSStaticScopeObject.h:
+        (JSC::JSStaticScopeObject::JSStaticScopeObject):
+        (JSC::JSStaticScopeObject::createStructure):
+        * runtime/JSString.cpp:
+        (JSC::JSString::toPrimitive):
+        (JSC::JSString::getPrimitiveNumber):
+        (JSC::JSString::getOwnPropertySlot):
+        * runtime/JSString.h:
+        (JSC::JSString::createStructure):
+        (JSC::asString):
+        * runtime/JSValue.h:
+        (JSC::JSValuePtr::makeImmediate):
+        (JSC::JSValuePtr::immediateValue):
+        (JSC::JSValuePtr::JSValuePtr):
+        (JSC::JSValuePtr::operator->):
+        (JSC::JSValuePtr::hasValue):
+        (JSC::JSValuePtr::operator==):
+        (JSC::JSValuePtr::operator!=):
+        (JSC::JSValuePtr::encode):
+        (JSC::JSValuePtr::decode):
+        (JSC::JSValue::asValue):
+        (JSC::noValue):
+        (JSC::operator==):
+        (JSC::operator!=):
+        * runtime/JSVariableObject.h:
+        (JSC::JSVariableObject::symbolTablePut):
+        (JSC::JSVariableObject::symbolTablePutWithAttributes):
+        * runtime/JSWrapperObject.cpp:
+        (JSC::JSWrapperObject::mark):
+        * runtime/JSWrapperObject.h:
+        (JSC::JSWrapperObject::internalValue):
+        (JSC::JSWrapperObject::setInternalValue):
+        * runtime/Lookup.cpp:
+        (JSC::setUpStaticFunctionSlot):
+        * runtime/Lookup.h:
+        (JSC::lookupPut):
+        * runtime/MathObject.cpp:
+        (JSC::mathProtoFuncAbs):
+        (JSC::mathProtoFuncACos):
+        (JSC::mathProtoFuncASin):
+        (JSC::mathProtoFuncATan):
+        (JSC::mathProtoFuncATan2):
+        (JSC::mathProtoFuncCeil):
+        (JSC::mathProtoFuncCos):
+        (JSC::mathProtoFuncExp):
+        (JSC::mathProtoFuncFloor):
+        (JSC::mathProtoFuncLog):
+        (JSC::mathProtoFuncMax):
+        (JSC::mathProtoFuncMin):
+        (JSC::mathProtoFuncPow):
+        (JSC::mathProtoFuncRandom):
+        (JSC::mathProtoFuncRound):
+        (JSC::mathProtoFuncSin):
+        (JSC::mathProtoFuncSqrt):
+        (JSC::mathProtoFuncTan):
+        * runtime/MathObject.h:
+        (JSC::MathObject::createStructure):
+        * runtime/NativeErrorConstructor.cpp:
+        (JSC::callNativeErrorConstructor):
+        * runtime/NumberConstructor.cpp:
+        (JSC::numberConstructorNaNValue):
+        (JSC::numberConstructorNegInfinity):
+        (JSC::numberConstructorPosInfinity):
+        (JSC::numberConstructorMaxValue):
+        (JSC::numberConstructorMinValue):
+        (JSC::callNumberConstructor):
+        * runtime/NumberConstructor.h:
+        (JSC::NumberConstructor::createStructure):
+        * runtime/NumberObject.cpp:
+        (JSC::NumberObject::getJSNumber):
+        (JSC::constructNumberFromImmediateNumber):
+        * runtime/NumberObject.h:
+        * runtime/NumberPrototype.cpp:
+        (JSC::numberProtoFuncToString):
+        (JSC::numberProtoFuncToLocaleString):
+        (JSC::numberProtoFuncValueOf):
+        (JSC::numberProtoFuncToFixed):
+        (JSC::numberProtoFuncToExponential):
+        (JSC::numberProtoFuncToPrecision):
+        * runtime/ObjectConstructor.cpp:
+        (JSC::constructObject):
+        (JSC::callObjectConstructor):
+        * runtime/ObjectPrototype.cpp:
+        (JSC::objectProtoFuncValueOf):
+        (JSC::objectProtoFuncHasOwnProperty):
+        (JSC::objectProtoFuncIsPrototypeOf):
+        (JSC::objectProtoFuncDefineGetter):
+        (JSC::objectProtoFuncDefineSetter):
+        (JSC::objectProtoFuncLookupGetter):
+        (JSC::objectProtoFuncLookupSetter):
+        (JSC::objectProtoFuncPropertyIsEnumerable):
+        (JSC::objectProtoFuncToLocaleString):
+        (JSC::objectProtoFuncToString):
+        * runtime/ObjectPrototype.h:
+        * runtime/Operations.cpp:
+        (JSC::equal):
+        (JSC::equalSlowCase):
+        (JSC::strictEqual):
+        (JSC::strictEqualSlowCase):
+        (JSC::throwOutOfMemoryError):
+        * runtime/Operations.h:
+        (JSC::equalSlowCaseInline):
+        (JSC::strictEqualSlowCaseInline):
+        * runtime/PropertySlot.cpp:
+        (JSC::PropertySlot::functionGetter):
+        * runtime/PropertySlot.h:
+        (JSC::PropertySlot::PropertySlot):
+        (JSC::PropertySlot::getValue):
+        (JSC::PropertySlot::putValue):
+        (JSC::PropertySlot::setValueSlot):
+        (JSC::PropertySlot::setValue):
+        (JSC::PropertySlot::setCustom):
+        (JSC::PropertySlot::setCustomIndex):
+        (JSC::PropertySlot::slotBase):
+        (JSC::PropertySlot::setBase):
+        (JSC::PropertySlot::):
+        * runtime/Protect.h:
+        (JSC::gcProtect):
+        (JSC::gcUnprotect):
+        (JSC::ProtectedPtr::ProtectedPtr):
+        (JSC::ProtectedPtr::operator JSValuePtr):
+        (JSC::ProtectedJSValuePtr::ProtectedJSValuePtr):
+        (JSC::ProtectedJSValuePtr::get):
+        (JSC::ProtectedJSValuePtr::operator JSValuePtr):
+        (JSC::ProtectedJSValuePtr::operator->):
+        (JSC::::ProtectedPtr):
+        (JSC::::~ProtectedPtr):
+        (JSC::::operator):
+        (JSC::ProtectedJSValuePtr::~ProtectedJSValuePtr):
+        (JSC::ProtectedJSValuePtr::operator=):
+        (JSC::operator==):
+        (JSC::operator!=):
+        * runtime/RegExpConstructor.cpp:
+        (JSC::RegExpConstructor::getBackref):
+        (JSC::RegExpConstructor::getLastParen):
+        (JSC::RegExpConstructor::getLeftContext):
+        (JSC::RegExpConstructor::getRightContext):
+        (JSC::regExpConstructorDollar1):
+        (JSC::regExpConstructorDollar2):
+        (JSC::regExpConstructorDollar3):
+        (JSC::regExpConstructorDollar4):
+        (JSC::regExpConstructorDollar5):
+        (JSC::regExpConstructorDollar6):
+        (JSC::regExpConstructorDollar7):
+        (JSC::regExpConstructorDollar8):
+        (JSC::regExpConstructorDollar9):
+        (JSC::regExpConstructorInput):
+        (JSC::regExpConstructorMultiline):
+        (JSC::regExpConstructorLastMatch):
+        (JSC::regExpConstructorLastParen):
+        (JSC::regExpConstructorLeftContext):
+        (JSC::regExpConstructorRightContext):
+        (JSC::RegExpConstructor::put):
+        (JSC::setRegExpConstructorInput):
+        (JSC::setRegExpConstructorMultiline):
+        (JSC::constructRegExp):
+        (JSC::callRegExpConstructor):
+        * runtime/RegExpConstructor.h:
+        (JSC::RegExpConstructor::createStructure):
+        (JSC::asRegExpConstructor):
+        * runtime/RegExpMatchesArray.h:
+        (JSC::RegExpMatchesArray::put):
+        * runtime/RegExpObject.cpp:
+        (JSC::regExpObjectGlobal):
+        (JSC::regExpObjectIgnoreCase):
+        (JSC::regExpObjectMultiline):
+        (JSC::regExpObjectSource):
+        (JSC::regExpObjectLastIndex):
+        (JSC::RegExpObject::put):
+        (JSC::setRegExpObjectLastIndex):
+        (JSC::RegExpObject::test):
+        (JSC::RegExpObject::exec):
+        (JSC::callRegExpObject):
+        * runtime/RegExpObject.h:
+        (JSC::RegExpObject::createStructure):
+        (JSC::asRegExpObject):
+        * runtime/RegExpPrototype.cpp:
+        (JSC::regExpProtoFuncTest):
+        (JSC::regExpProtoFuncExec):
+        (JSC::regExpProtoFuncCompile):
+        (JSC::regExpProtoFuncToString):
+        * runtime/StringConstructor.cpp:
+        (JSC::stringFromCharCodeSlowCase):
+        (JSC::stringFromCharCode):
+        (JSC::callStringConstructor):
+        * runtime/StringObject.cpp:
+        (JSC::StringObject::put):
+        * runtime/StringObject.h:
+        (JSC::StringObject::createStructure):
+        (JSC::asStringObject):
+        * runtime/StringObjectThatMasqueradesAsUndefined.h:
+        (JSC::StringObjectThatMasqueradesAsUndefined::createStructure):
+        * runtime/StringPrototype.cpp:
+        (JSC::stringProtoFuncReplace):
+        (JSC::stringProtoFuncToString):
+        (JSC::stringProtoFuncCharAt):
+        (JSC::stringProtoFuncCharCodeAt):
+        (JSC::stringProtoFuncConcat):
+        (JSC::stringProtoFuncIndexOf):
+        (JSC::stringProtoFuncLastIndexOf):
+        (JSC::stringProtoFuncMatch):
+        (JSC::stringProtoFuncSearch):
+        (JSC::stringProtoFuncSlice):
+        (JSC::stringProtoFuncSplit):
+        (JSC::stringProtoFuncSubstr):
+        (JSC::stringProtoFuncSubstring):
+        (JSC::stringProtoFuncToLowerCase):
+        (JSC::stringProtoFuncToUpperCase):
+        (JSC::stringProtoFuncLocaleCompare):
+        (JSC::stringProtoFuncBig):
+        (JSC::stringProtoFuncSmall):
+        (JSC::stringProtoFuncBlink):
+        (JSC::stringProtoFuncBold):
+        (JSC::stringProtoFuncFixed):
+        (JSC::stringProtoFuncItalics):
+        (JSC::stringProtoFuncStrike):
+        (JSC::stringProtoFuncSub):
+        (JSC::stringProtoFuncSup):
+        (JSC::stringProtoFuncFontcolor):
+        (JSC::stringProtoFuncFontsize):
+        (JSC::stringProtoFuncAnchor):
+        (JSC::stringProtoFuncLink):
+        * runtime/Structure.cpp:
+        (JSC::Structure::Structure):
+        (JSC::Structure::changePrototypeTransition):
+        (JSC::Structure::createCachedPrototypeChain):
+        * runtime/Structure.h:
+        (JSC::Structure::create):
+        (JSC::Structure::setPrototypeWithoutTransition):
+        (JSC::Structure::storedPrototype):
+
 2009-01-06  Oliver Hunt  <oliver@apple.com>
 
         Reviewed by Cameron Zwarich.
index cbf0378..d65a977 100644 (file)
@@ -99,12 +99,12 @@ __ZN3JSC10JSFunction4infoE
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeE
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeEPKc
 __ZN3JSC10throwErrorEPNS_9ExecStateENS_9ErrorTypeERKNS_7UStringE
-__ZN3JSC11JSByteArray15createStructureEPNS_7JSValueE
+__ZN3JSC11JSByteArray15createStructureENS_10JSValuePtrE
 __ZN3JSC11JSByteArrayC1EPNS_9ExecStateEN3WTF10PassRefPtrINS_9StructureEEEPNS_9ByteArrayEPKNS_9ClassInfoE
 __ZN3JSC11JSImmediate12nonInlineNaNEv
-__ZN3JSC11JSImmediate8toObjectEPNS_7JSValueEPNS_9ExecStateE
-__ZN3JSC11JSImmediate8toStringEPNS_7JSValueE
-__ZN3JSC11JSImmediate9prototypeEPNS_7JSValueEPNS_9ExecStateE
+__ZN3JSC11JSImmediate8toObjectENS_10JSValuePtrEPNS_9ExecStateE
+__ZN3JSC11JSImmediate8toStringENS_10JSValuePtrE
+__ZN3JSC11JSImmediate9prototypeENS_10JSValuePtrEPNS_9ExecStateE
 __ZN3JSC11ProfileNode4sortEPFbRKN3WTF6RefPtrIS0_EES5_E
 __ZN3JSC11checkSyntaxEPNS_9ExecStateERKNS_10SourceCodeE
 __ZN3JSC12DateInstance4infoE
@@ -122,7 +122,7 @@ __ZN3JSC12StringObject14toThisJSStringEPNS_9ExecStateE
 __ZN3JSC12StringObject16getPropertyNamesEPNS_9ExecStateERNS_17PropertyNameArrayE
 __ZN3JSC12StringObject18getOwnPropertySlotEPNS_9ExecStateERKNS_10IdentifierERNS_12PropertySlotE
 __ZN3JSC12StringObject18getOwnPropertySlotEPNS_9ExecStateEjRNS_12PropertySlotE
-__ZN3JSC12StringObject3putEPNS_9ExecStateERKNS_10IdentifierEPNS_7JSValueERNS_15PutPropertySlotE
+__ZN3JSC12StringObject3putEPNS_9ExecStateERKNS_10IdentifierENS_10JSValuePtrERNS_15PutPropertySlotE
 __ZN3JSC12StringObject4infoE
 __ZN3JSC12StringObjectC2EPNS_9ExecStateEN3WTF10PassRefPtrINS_9StructureEEERKNS_7UStringE
 __ZN3JSC12jsNumberCellEPNS_9ExecStateEd
@@ -133,9 +133,9 @@ __ZN3JSC14JSGlobalObject12defineGetterEPNS_9ExecStateERKNS_10IdentifierEPNS_8JSO
 __ZN3JSC14JSGlobalObject12defineSetterEPNS_9ExecStateERKNS_10IdentifierEPNS_8JSObjectE
 __ZN3JSC14JSGlobalObject14setTimeoutTimeEj
 __ZN3JSC14JSGlobalObject16stopTimeoutCheckEv
-__ZN3JSC14JSGlobalObject17putWithAttributesEPNS_9ExecStateERKNS_10IdentifierEPNS_7JSValueEj
+__ZN3JSC14JSGlobalObject17putWithAttributesEPNS_9ExecStateERKNS_10IdentifierENS_10JSValuePtrEj
 __ZN3JSC14JSGlobalObject17startTimeoutCheckEv
-__ZN3JSC14JSGlobalObject3putEPNS_9ExecStateERKNS_10IdentifierEPNS_7JSValueERNS_15PutPropertySlotE
+__ZN3JSC14JSGlobalObject3putEPNS_9ExecStateERKNS_10IdentifierENS_10JSValuePtrERNS_15PutPropertySlotE
 __ZN3JSC14JSGlobalObject4initEPNS_8JSObjectE
 __ZN3JSC14JSGlobalObject4markEv
 __ZN3JSC14JSGlobalObjectD2Ev
@@ -154,13 +154,13 @@ __ZN3JSC16ParserRefCounted3refEv
 __ZN3JSC16ParserRefCounted5derefEv
 __ZN3JSC17BytecodeGenerator21setDumpsGeneratedCodeEb
 __ZN3JSC17PropertyNameArray3addEPNS_7UString3RepE
-__ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEN3WTF10PassRefPtrINS_9StructureEEEiRKNS_10IdentifierEPFPNS_7JSValueES2_PNS_8JSObjectESB_RKNS_7ArgListEE
-__ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEiRKNS_10IdentifierEPFPNS_7JSValueES2_PNS_8JSObjectES7_RKNS_7ArgListEE
+__ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEN3WTF10PassRefPtrINS_9StructureEEEiRKNS_10IdentifierEPFNS_10JSValuePtrES2_PNS_8JSObjectESA_RKNS_7ArgListEE
+__ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEiRKNS_10IdentifierEPFNS_10JSValuePtrES2_PNS_8JSObjectES6_RKNS_7ArgListEE
 __ZN3JSC17constructFunctionEPNS_9ExecStateERKNS_7ArgListERKNS_10IdentifierERKNS_7UStringEi
 __ZN3JSC19constructEmptyArrayEPNS_9ExecStateE
 __ZN3JSC19initializeThreadingEv
 __ZN3JSC20constructEmptyObjectEPNS_9ExecStateE
-__ZN3JSC23objectProtoFuncToStringEPNS_9ExecStateEPNS_8JSObjectEPNS_7JSValueERKNS_7ArgListE
+__ZN3JSC23objectProtoFuncToStringEPNS_9ExecStateEPNS_8JSObjectENS_10JSValuePtrERKNS_7ArgListE
 __ZN3JSC23setUpStaticFunctionSlotEPNS_9ExecStateEPKNS_9HashEntryEPNS_8JSObjectERKNS_10IdentifierERNS_12PropertySlotE
 __ZN3JSC4Heap11objectCountEv
 __ZN3JSC4Heap14allocateNumberEm
@@ -172,14 +172,14 @@ __ZN3JSC4Heap20protectedObjectCountEv
 __ZN3JSC4Heap24setGCProtectNeedsLockingEv
 __ZN3JSC4Heap25protectedObjectTypeCountsEv
 __ZN3JSC4Heap26protectedGlobalObjectCountEv
-__ZN3JSC4Heap4heapEPNS_7JSValueE
+__ZN3JSC4Heap4heapENS_10JSValuePtrE
 __ZN3JSC4Heap6isBusyEv
 __ZN3JSC4Heap7collectEv
 __ZN3JSC4Heap7destroyEv
-__ZN3JSC4Heap7protectEPNS_7JSValueE
+__ZN3JSC4Heap7protectENS_10JSValuePtrE
 __ZN3JSC4Heap8allocateEm
-__ZN3JSC4Heap9unprotectEPNS_7JSValueE
-__ZN3JSC4callEPNS_9ExecStateEPNS_7JSValueENS_8CallTypeERKNS_8CallDataES3_RKNS_7ArgListE
+__ZN3JSC4Heap9unprotectENS_10JSValuePtrE
+__ZN3JSC4callEPNS_9ExecStateENS_10JSValuePtrENS_8CallTypeERKNS_8CallDataES2_RKNS_7ArgListE
 __ZN3JSC5equalEPKNS_7UString3RepES3_
 __ZN3JSC6JSCell11getCallDataERNS_8CallDataE
 __ZN3JSC6JSCell11getJSNumberEv
@@ -189,8 +189,8 @@ __ZN3JSC6JSCell14toThisJSStringEPNS_9ExecStateE
 __ZN3JSC6JSCell16getConstructDataERNS_13ConstructDataE
 __ZN3JSC6JSCell18getOwnPropertySlotEPNS_9ExecStateERKNS_10IdentifierERNS_12PropertySlotE
 __ZN3JSC6JSCell18getOwnPropertySlotEPNS_9ExecStateEjRNS_12PropertySlotE
-__ZN3JSC6JSCell3putEPNS_9ExecStateERKNS_10IdentifierEPNS_7JSValueERNS_15PutPropertySlotE
-__ZN3JSC6JSCell3putEPNS_9ExecStateEjPNS_7JSValueE
+__ZN3JSC6JSCell3putEPNS_9ExecStateERKNS_10IdentifierENS_10JSValuePtrERNS_15PutPropertySlotE
+__ZN3JSC6JSCell3putEPNS_9ExecStateEjNS_10JSValuePtrE
 __ZN3JSC6JSCell9getObjectEv
 __ZN3JSC6JSCellnwEmPNS_9ExecStateE
 __ZN3JSC6JSLock12DropAllLocksC1EPNS_9ExecStateE
@@ -201,7 +201,7 @@ __ZN3JSC6JSLock6unlockEb
 __ZN3JSC6JSLock9lockCountEv
 __ZN3JSC6JSLockC1EPNS_9ExecStateE
 __ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE
-__ZN3JSC7ArgList10slowAppendEPNS_7JSValueE
+__ZN3JSC7ArgList10slowAppendENS_10JSValuePtrE
 __ZN3JSC7CStringD1Ev
 __ZN3JSC7CStringaSERKS0_
 __ZN3JSC7JSArray4infoE
@@ -223,7 +223,7 @@ __ZN3JSC8Debugger6attachEPNS_14JSGlobalObjectE
 __ZN3JSC8Debugger6detachEPNS_14JSGlobalObjectE
 __ZN3JSC8DebuggerC2Ev
 __ZN3JSC8DebuggerD2Ev
-__ZN3JSC8JSObject11hasInstanceEPNS_9ExecStateEPNS_7JSValueES4_
+__ZN3JSC8JSObject11hasInstanceEPNS_9ExecStateENS_10JSValuePtrES3_
 __ZN3JSC8JSObject12defineGetterEPNS_9ExecStateERKNS_10IdentifierEPS0_
 __ZN3JSC8JSObject12defineSetterEPNS_9ExecStateERKNS_10IdentifierEPS0_
 __ZN3JSC8JSObject12lookupGetterEPNS_9ExecStateERKNS_10IdentifierE
@@ -234,19 +234,19 @@ __ZN3JSC8JSObject15unwrappedObjectEv
 __ZN3JSC8JSObject16getPropertyNamesEPNS_9ExecStateERNS_17PropertyNameArrayE
 __ZN3JSC8JSObject17createInheritorIDEv
 __ZN3JSC8JSObject17putDirectFunctionEPNS_9ExecStateEPNS_16InternalFunctionEj
-__ZN3JSC8JSObject17putWithAttributesEPNS_9ExecStateERKNS_10IdentifierEPNS_7JSValueEj
-__ZN3JSC8JSObject17putWithAttributesEPNS_9ExecStateEjPNS_7JSValueEj
+__ZN3JSC8JSObject17putWithAttributesEPNS_9ExecStateERKNS_10IdentifierENS_10JSValuePtrEj
+__ZN3JSC8JSObject17putWithAttributesEPNS_9ExecStateEjNS_10JSValuePtrEj
 __ZN3JSC8JSObject18getOwnPropertySlotEPNS_9ExecStateEjRNS_12PropertySlotE
-__ZN3JSC8JSObject18getPrimitiveNumberEPNS_9ExecStateERdRPNS_7JSValueE
-__ZN3JSC8JSObject22fillGetterPropertySlotERNS_12PropertySlotEPPNS_7JSValueE
+__ZN3JSC8JSObject18getPrimitiveNumberEPNS_9ExecStateERdRNS_10JSValuePtrE
+__ZN3JSC8JSObject22fillGetterPropertySlotERNS_12PropertySlotEPNS_10JSValuePtrE
 __ZN3JSC8JSObject23allocatePropertyStorageEmm
-__ZN3JSC8JSObject3putEPNS_9ExecStateERKNS_10IdentifierEPNS_7JSValueERNS_15PutPropertySlotE
-__ZN3JSC8JSObject3putEPNS_9ExecStateEjPNS_7JSValueE
+__ZN3JSC8JSObject3putEPNS_9ExecStateERKNS_10IdentifierENS_10JSValuePtrERNS_15PutPropertySlotE
+__ZN3JSC8JSObject3putEPNS_9ExecStateEjNS_10JSValuePtrE
 __ZN3JSC8JSObject4markEv
 __ZN3JSC8Profiler13stopProfilingEPNS_9ExecStateERKNS_7UStringE
 __ZN3JSC8Profiler14startProfilingEPNS_9ExecStateERKNS_7UStringE
 __ZN3JSC8Profiler8profilerEv
-__ZN3JSC8evaluateEPNS_9ExecStateERNS_10ScopeChainERKNS_10SourceCodeEPNS_7JSValueE
+__ZN3JSC8evaluateEPNS_9ExecStateERNS_10ScopeChainERKNS_10SourceCodeENS_10JSValuePtrE
 __ZN3JSC8jsStringEPNS_12JSGlobalDataERKNS_7UStringE
 __ZN3JSC9ByteArray6createEm
 __ZN3JSC9CodeBlockD1Ev
@@ -255,13 +255,13 @@ __ZN3JSC9Structure17stopIgnoringLeaksEv
 __ZN3JSC9Structure18startIgnoringLeaksEv
 __ZN3JSC9Structure21addPropertyTransitionEPS0_RKNS_10IdentifierEjRm
 __ZN3JSC9Structure22materializePropertyMapEv
-__ZN3JSC9Structure25changePrototypeTransitionEPS0_PNS_7JSValueE
+__ZN3JSC9Structure25changePrototypeTransitionEPS0_NS_10JSValuePtrE
 __ZN3JSC9Structure28addPropertyWithoutTransitionERKNS_10IdentifierEj
 __ZN3JSC9Structure3getERKNS_10IdentifierERj
 __ZN3JSC9Structure40addPropertyTransitionToExistingStructureEPS0_RKNS_10IdentifierEjRm
-__ZN3JSC9StructureC1EPNS_7JSValueERKNS_8TypeInfoE
+__ZN3JSC9StructureC1ENS_10JSValuePtrERKNS_8TypeInfoE
 __ZN3JSC9StructureD1Ev
-__ZN3JSC9constructEPNS_9ExecStateEPNS_7JSValueENS_13ConstructTypeERKNS_13ConstructDataERKNS_7ArgListE
+__ZN3JSC9constructEPNS_9ExecStateENS_10JSValuePtrENS_13ConstructTypeERKNS_13ConstructDataERKNS_7ArgListE
 __ZN3JSCeqERKNS_7UStringEPKc
 __ZN3JSCeqERKNS_7UStringES2_
 __ZN3JSCgtERKNS_7UStringES2_
@@ -308,7 +308,7 @@ __ZN3WTF8CollatorC1EPKc
 __ZN3WTF8CollatorD1Ev
 __ZN3WTF8fastFreeEPv
 __ZNK3JSC11Interpreter14retrieveCallerEPNS_9ExecStateEPNS_16InternalFunctionE
-__ZNK3JSC11Interpreter18retrieveLastCallerEPNS_9ExecStateERiRlRNS_7UStringERPNS_7JSValueE
+__ZNK3JSC11Interpreter18retrieveLastCallerEPNS_9ExecStateERiRlRNS_7UStringERNS_10JSValuePtrE
 __ZNK3JSC12DateInstance7getTimeERdRi
 __ZNK3JSC12StringObject12toThisStringEPNS_9ExecStateE
 __ZNK3JSC12StringObject8toStringEPNS_9ExecStateE
@@ -319,7 +319,7 @@ __ZNK3JSC16JSVariableObject21getPropertyAttributesEPNS_9ExecStateERKNS_10Identif
 __ZNK3JSC17DebuggerCallFrame10thisObjectEv
 __ZNK3JSC17DebuggerCallFrame12functionNameEv
 __ZNK3JSC17DebuggerCallFrame4typeEv
-__ZNK3JSC17DebuggerCallFrame8evaluateERKNS_7UStringERPNS_7JSValueE
+__ZNK3JSC17DebuggerCallFrame8evaluateERKNS_7UStringERNS_10JSValuePtrE
 __ZNK3JSC4Heap10statisticsEv
 __ZNK3JSC6JSCell12toThisObjectEPNS_9ExecStateE
 __ZNK3JSC6JSCell12toThisStringEPNS_9ExecStateE
index 07c3241..154e741 100644 (file)
@@ -55,7 +55,7 @@ static UString escapeQuotes(const UString& str)
     return result;
 }
 
-static UString valueToSourceString(ExecState* exec, JSValue* val)
+static UString valueToSourceString(ExecState* exec, JSValuePtr val)
 {
     if (val->isString()) {
         UString result("\"");
@@ -74,7 +74,7 @@ static CString registerName(int r)
     return (UString("r") + UString::from(r)).UTF8String();
 }
 
-static CString constantName(ExecState* exec, int k, JSValue* value)
+static CString constantName(ExecState* exec, int k, JSValuePtr value)
 {
     return (valueToSourceString(exec, value) + "(@k" + UString::from(k) + ")").UTF8String();
 }
@@ -703,7 +703,7 @@ void CodeBlock::dump(ExecState* exec, const Vector<Instruction>::const_iterator&
         }
         case op_resolve_global: {
             int r0 = (++it)->u.operand;
-            JSValue* scope = static_cast<JSValue*>((++it)->u.jsCell);
+            JSValuePtr scope = JSValuePtr((++it)->u.jsCell);
             int id0 = (++it)->u.operand;
             printf("[%4d] resolve_global\t %s, %s, %s\n", location, registerName(r0).c_str(), valueToSourceString(exec, scope).ascii(), idName(id0, m_identifiers[id0]).c_str());
             it += 2;
@@ -725,13 +725,13 @@ void CodeBlock::dump(ExecState* exec, const Vector<Instruction>::const_iterator&
         }
         case op_get_global_var: {
             int r0 = (++it)->u.operand;
-            JSValue* scope = static_cast<JSValue*>((++it)->u.jsCell);
+            JSValuePtr scope = JSValuePtr((++it)->u.jsCell);
             int index = (++it)->u.operand;
             printf("[%4d] get_global_var\t %s, %s, %d\n", location, registerName(r0).c_str(), valueToSourceString(exec, scope).ascii(), index);
             break;
         }
         case op_put_global_var: {
-            JSValue* scope = static_cast<JSValue*>((++it)->u.jsCell);
+            JSValuePtr scope = JSValuePtr((++it)->u.jsCell);
             int index = (++it)->u.operand;
             int r0 = (++it)->u.operand;
             printf("[%4d] put_global_var\t %s, %d, %s\n", location, valueToSourceString(exec, scope).ascii(), index, registerName(r0).c_str());
index 57de292..dc9ccb7 100644 (file)
@@ -252,7 +252,7 @@ namespace JSC {
             return index >= m_numVars && index < m_numVars + m_numConstants;
         }
 
-        ALWAYS_INLINE JSValue* getConstant(int index)
+        ALWAYS_INLINE JSValuePtr getConstant(int index)
         {
             return m_constantRegisters[index - m_numVars].getJSValue();
         }
@@ -388,8 +388,8 @@ namespace JSC {
         unsigned addFunction(FuncDeclNode* n) { createRareDataIfNecessary(); unsigned size = m_rareData->m_functions.size(); m_rareData->m_functions.append(n); return size; }
         FuncDeclNode* function(int index) const { ASSERT(m_rareData); return m_rareData->m_functions[index].get(); }
 
-        unsigned addUnexpectedConstant(JSValue* v) { createRareDataIfNecessary(); unsigned size = m_rareData->m_unexpectedConstants.size(); m_rareData->m_unexpectedConstants.append(v); return size; }
-        JSValue* unexpectedConstant(int index) const { ASSERT(m_rareData); return m_rareData->m_unexpectedConstants[index]; }
+        unsigned addUnexpectedConstant(JSValuePtr v) { createRareDataIfNecessary(); unsigned size = m_rareData->m_unexpectedConstants.size(); m_rareData->m_unexpectedConstants.append(v); return size; }
+        JSValuePtr unexpectedConstant(int index) const { ASSERT(m_rareData); return m_rareData->m_unexpectedConstants[index]; }
 
         unsigned addRegExp(RegExp* r) { createRareDataIfNecessary(); unsigned size = m_rareData->m_regexps.size(); m_rareData->m_regexps.append(r); return size; }
         RegExp* regexp(int index) const { ASSERT(m_rareData); return m_rareData->m_regexps[index].get(); }
@@ -493,7 +493,7 @@ namespace JSC {
 
             // Rare Constants
             Vector<RefPtr<FuncDeclNode> > m_functions;
-            Vector<JSValue*> m_unexpectedConstants;
+            Vector<JSValuePtr> m_unexpectedConstants;
             Vector<RefPtr<RegExp> > m_regexps;
 
             // Jump Tables
index 25abd7c..29be295 100644 (file)
@@ -41,7 +41,7 @@ namespace JSC {
 
     class EvalCodeCache {
     public:
-        PassRefPtr<EvalNode> get(ExecState* exec, const UString& evalSource, ScopeChainNode* scopeChain, JSValue*& exceptionValue)
+        PassRefPtr<EvalNode> get(ExecState* exec, const UString& evalSource, ScopeChainNode* scopeChain, JSValuePtr& exceptionValue)
         {
             RefPtr<EvalNode> evalNode;
 
index 482c6f5..99f26c2 100644 (file)
@@ -705,22 +705,22 @@ unsigned BytecodeGenerator::addConstant(const Identifier& ident)
     return result.first->second;
 }
 
-RegisterID* BytecodeGenerator::addConstant(JSValue* v)
+RegisterID* BytecodeGenerator::addConstant(JSValuePtr v)
 {
-    pair<JSValueMap::iterator, bool> result = m_jsValueMap.add(v, m_nextConstantIndex);
+    pair<JSValueMap::iterator, bool> result = m_jsValueMap.add(JSValuePtr::encode(v), m_nextConstantIndex);
     if (result.second) {
         RegisterID& constant = m_calleeRegisters[m_nextConstantIndex];
         
         ++m_nextConstantIndex;
 
-        m_codeBlock->addConstantRegister(v);
+        m_codeBlock->addConstantRegister(JSValuePtr(v));
         return &constant;
     }
 
     return &registerFor(result.first->second);
 }
 
-unsigned BytecodeGenerator::addUnexpectedConstant(JSValue* v)
+unsigned BytecodeGenerator::addUnexpectedConstant(JSValuePtr v)
 {
     return m_codeBlock->addUnexpectedConstant(v);
 }
@@ -867,7 +867,7 @@ RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, double number)
     // Later we can do the extra work to handle that like the other cases.
     if (number == HashTraits<double>::emptyValue() || HashTraits<double>::isDeletedValue(number))
         return emitLoad(dst, jsNumber(globalData(), number));
-    JSValue*& valueInMap = m_numberMap.add(number, noValue()).first->second;
+    JSValuePtr valueInMap = m_numberMap.add(number, noValue()).first->second;
     if (!valueInMap)
         valueInMap = jsNumber(globalData(), number);
     return emitLoad(dst, valueInMap);
@@ -875,13 +875,13 @@ RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, double number)
 
 RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, const Identifier& identifier)
 {
-    JSString*& valueInMap = m_stringMap.add(identifier.ustring().rep(), 0).first->second;
+    JSValuePtr valueInMap = m_stringMap.add(identifier.ustring().rep(), 0).first->second;
     if (!valueInMap)
         valueInMap = jsOwnedString(globalData(), identifier.ustring());
     return emitLoad(dst, valueInMap);
 }
 
-RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSValue* v)
+RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSValuePtr v)
 {
     RegisterID* constantID = addConstant(v);
     if (dst)
@@ -889,12 +889,6 @@ RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSValue* v)
     return constantID;
 }
 
-RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSCell* cell)
-{
-    JSValue* value = cell;
-    return emitLoad(dst, value);
-}
-
 RegisterID* BytecodeGenerator::emitUnexpectedLoad(RegisterID* dst, bool b)
 {
     emitOpcode(op_unexpected_load);
@@ -1017,7 +1011,7 @@ RegisterID* BytecodeGenerator::emitResolve(RegisterID* dst, const Identifier& pr
     return dst;
 }
 
-RegisterID* BytecodeGenerator::emitGetScopedVar(RegisterID* dst, size_t depth, int index, JSValue* globalObject)
+RegisterID* BytecodeGenerator::emitGetScopedVar(RegisterID* dst, size_t depth, int index, JSValuePtr globalObject)
 {
     if (globalObject) {
         emitOpcode(op_get_global_var);
@@ -1034,7 +1028,7 @@ RegisterID* BytecodeGenerator::emitGetScopedVar(RegisterID* dst, size_t depth, i
     return dst;
 }
 
-RegisterID* BytecodeGenerator::emitPutScopedVar(size_t depth, int index, RegisterID* value, JSValue* globalObject)
+RegisterID* BytecodeGenerator::emitPutScopedVar(size_t depth, int index, RegisterID* value, JSValuePtr globalObject)
 {
     if (globalObject) {
         emitOpcode(op_put_global_var);
@@ -1602,7 +1596,7 @@ RegisterID* BytecodeGenerator::emitCatch(RegisterID* targetRegister, Label* star
     return targetRegister;
 }
 
-RegisterID* BytecodeGenerator::emitNewError(RegisterID* dst, ErrorType type, JSValue* message)
+RegisterID* BytecodeGenerator::emitNewError(RegisterID* dst, ErrorType type, JSValuePtr message)
 {
     emitOpcode(op_new_error);
     instructions().append(dst->index());
index 9bfab82..5d14144 100644 (file)
@@ -240,8 +240,7 @@ namespace JSC {
         RegisterID* emitLoad(RegisterID* dst, bool);
         RegisterID* emitLoad(RegisterID* dst, double);
         RegisterID* emitLoad(RegisterID* dst, const Identifier&);
-        RegisterID* emitLoad(RegisterID* dst, JSValue*);
-        RegisterID* emitLoad(RegisterID* dst, JSCell*);
+        RegisterID* emitLoad(RegisterID* dst, JSValuePtr);
         RegisterID* emitUnexpectedLoad(RegisterID* dst, bool);
         RegisterID* emitUnexpectedLoad(RegisterID* dst, double);
 
@@ -270,8 +269,8 @@ namespace JSC {
         RegisterID* emitIn(RegisterID* dst, RegisterID* property, RegisterID* base) { return emitBinaryOp(op_in, dst, property, base, OperandTypes()); }
 
         RegisterID* emitResolve(RegisterID* dst, const Identifier& property);
-        RegisterID* emitGetScopedVar(RegisterID* dst, size_t skip, int index, JSValue* globalObject);
-        RegisterID* emitPutScopedVar(size_t skip, int index, RegisterID* value, JSValue* globalObject);
+        RegisterID* emitGetScopedVar(RegisterID* dst, size_t skip, int index, JSValuePtr globalObject);
+        RegisterID* emitPutScopedVar(size_t skip, int index, RegisterID* value, JSValuePtr globalObject);
 
         RegisterID* emitResolveBase(RegisterID* dst, const Identifier& property);
         RegisterID* emitResolveWithBase(RegisterID* baseDst, RegisterID* propDst, const Identifier& property);
@@ -309,7 +308,7 @@ namespace JSC {
 
         RegisterID* emitCatch(RegisterID*, Label* start, Label* end);
         void emitThrow(RegisterID* exc) { emitUnaryNoDstOp(op_throw, exc); }
-        RegisterID* emitNewError(RegisterID* dst, ErrorType type, JSValue* message);
+        RegisterID* emitNewError(RegisterID* dst, ErrorType type, JSValuePtr message);
         void emitPushNewScope(RegisterID* dst, Identifier& property, RegisterID* value);
 
         RegisterID* emitPushScope(RegisterID* scope);
@@ -339,12 +338,12 @@ namespace JSC {
 
         PassRefPtr<Label> emitComplexJumpScopes(Label* target, ControlFlowContext* topScope, ControlFlowContext* bottomScope);
 
-        struct JSValueHashTraits : HashTraits<JSValue*> {
-            static void constructDeletedValue(JSValue*& slot) { slot = JSImmediate::impossibleValue(); }
-            static bool isDeletedValue(JSValue* value) { return value == JSImmediate::impossibleValue(); }
+        struct JSValueHashTraits : HashTraits<JSValueEncodedAsPointer*> {
+            static void constructDeletedValue(JSValueEncodedAsPointer*& slot) { slot = JSValuePtr::encode(JSImmediate::impossibleValue()); }
+            static bool isDeletedValue(JSValueEncodedAsPointer* value) { return value == JSValuePtr::encode(JSImmediate::impossibleValue()); }
         };
 
-        typedef HashMap<JSValue*, unsigned, PtrHash<JSValue*>, JSValueHashTraits> JSValueMap;
+        typedef HashMap<JSValueEncodedAsPointer*, unsigned, PtrHash<JSValueEncodedAsPointer*>, JSValueHashTraits> JSValueMap;
 
         struct IdentifierMapIndexHashTraits {
             typedef int TraitType;
@@ -356,7 +355,7 @@ namespace JSC {
         };
 
         typedef HashMap<RefPtr<UString::Rep>, int, IdentifierRepHash, HashTraits<RefPtr<UString::Rep> >, IdentifierMapIndexHashTraits> IdentifierMap;
-        typedef HashMap<double, JSValue*> NumberMap;
+        typedef HashMap<double, JSValuePtr> NumberMap;
         typedef HashMap<UString::Rep*, JSString*, IdentifierRepHash> IdentifierStringMap;
 
         RegisterID* emitCall(OpcodeID, RegisterID* dst, RegisterID* func, RegisterID* thisRegister, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
@@ -406,8 +405,8 @@ namespace JSC {
         unsigned addConstant(FuncDeclNode*);
         unsigned addConstant(FuncExprNode*);
         unsigned addConstant(const Identifier&);
-        RegisterID* addConstant(JSValue*);
-        unsigned addUnexpectedConstant(JSValue*);
+        RegisterID* addConstant(JSValuePtr);
+        unsigned addUnexpectedConstant(JSValuePtr);
         unsigned addRegExp(RegExp*);
 
         Vector<Instruction>& instructions() { return m_codeBlock->instructions(); }
index e9b825a..27b824c 100644 (file)
@@ -63,7 +63,7 @@ JSObject* DebuggerCallFrame::thisObject() const
     return asObject(m_callFrame->thisValue());
 }
 
-JSValue* DebuggerCallFrame::evaluate(const UString& script, JSValue*& exception) const
+JSValuePtr DebuggerCallFrame::evaluate(const UString& script, JSValuePtr& exception) const
 {
     if (!m_callFrame->codeBlock())
         return noValue();
index 4b96b7f..cdf4965 100644 (file)
@@ -43,7 +43,7 @@ namespace JSC {
         {
         }
 
-        DebuggerCallFrame(CallFrame* callFrame, JSValue* exception)
+        DebuggerCallFrame(CallFrame* callFrame, JSValuePtr exception)
             : m_callFrame(callFrame)
             , m_exception(exception)
         {
@@ -54,12 +54,12 @@ namespace JSC {
         const UString* functionName() const;
         Type type() const;
         JSObject* thisObject() const;
-        JSValue* evaluate(const UString&, JSValue*& exception) const;
-        JSValue* exception() const { return m_exception; }
+        JSValuePtr evaluate(const UString&, JSValuePtr& exception) const;
+        JSValuePtr exception() const { return m_exception; }
 
     private:
         CallFrame* m_callFrame;
-        JSValue* m_exception;
+        JSValuePtr m_exception;
     };
 
 } // namespace JSC
index 16283ab..1c74280 100644 (file)
@@ -30,7 +30,7 @@
 
 namespace JSC {
 
-JSValue* CallFrame::thisValue()
+JSValuePtr CallFrame::thisValue()
 {
     return this[codeBlock()->thisRegister()].jsValue(this);
 }
index 42a3ec8..d6b9b79 100644 (file)
@@ -41,7 +41,7 @@ namespace JSC  {
         CodeBlock* codeBlock() const { return this[RegisterFile::CodeBlock].Register::codeBlock(); }
         ScopeChainNode* scopeChain() const { return this[RegisterFile::ScopeChain].Register::scopeChain(); }
 
-        JSValue* thisValue();
+        JSValuePtr thisValue();
 
         // Global object in which execution began.
         JSGlobalObject* dynamicGlobalObject();
@@ -73,11 +73,11 @@ namespace JSC  {
         // pointer, so these are inefficient, and should be used sparingly in new code.
         // But they're used in many places in legacy code, so they're not going away any time soon.
 
-        void setException(JSValue* exception) { globalData().exception = exception; }
+        void setException(JSValuePtr exception) { globalData().exception = exception; }
         void clearException() { globalData().exception = noValue(); }
-        JSValue* exception() const { return globalData().exception; }
-        JSValue** exceptionSlot() { return &globalData().exception; }
-        bool hadException() const { return !!globalData().exception; }
+        JSValuePtr exception() const { return globalData().exception; }
+        JSValuePtr* exceptionSlot() { return &globalData().exception; }
+        bool hadException() const { return globalData().exception; }
 
         const CommonIdentifiers& propertyNames() const { return *globalData().propertyNames; }
         const ArgList& emptyList() const { return *globalData().emptyList; }
index e581683..fdc7d36 100644 (file)
@@ -108,7 +108,7 @@ static int depth(CodeBlock* codeBlock, ScopeChain& sc)
 
 // FIXME: This operation should be called "getNumber", not "isNumber" (as it is in JSValue.h).
 // FIXME: There's no need to have a "slow" version of this. All versions should be fast.
-static ALWAYS_INLINE bool fastIsNumber(JSValue* value, double& arg)
+static ALWAYS_INLINE bool fastIsNumber(JSValuePtr value, double& arg)
 {
     if (JSImmediate::isNumber(value))
         arg = JSImmediate::getTruncatedInt32(value);
@@ -119,8 +119,8 @@ static ALWAYS_INLINE bool fastIsNumber(JSValue* value, double& arg)
     return true;
 }
 
-// FIXME: Why doesn't JSValue*::toInt32 have the Heap::isNumber optimization?
-static bool fastToInt32(JSValue* value, int32_t& arg)
+// FIXME: Why doesn't JSValuePtr::toInt32 have the Heap::isNumber optimization?
+static bool fastToInt32(JSValuePtr value, int32_t& arg)
 {
     if (JSImmediate::isNumber(value))
         arg = JSImmediate::getTruncatedInt32(value);
@@ -131,7 +131,7 @@ static bool fastToInt32(JSValue* value, int32_t& arg)
     return true;
 }
 
-static ALWAYS_INLINE bool fastToUInt32(JSValue* value, uint32_t& arg)
+static ALWAYS_INLINE bool fastToUInt32(JSValuePtr value, uint32_t& arg)
 {
     if (JSImmediate::isNumber(value)) {
         if (JSImmediate::getTruncatedUInt32(value, arg))
@@ -146,7 +146,7 @@ static ALWAYS_INLINE bool fastToUInt32(JSValue* value, uint32_t& arg)
     return true;
 }
 
-static inline bool jsLess(CallFrame* callFrame, JSValue* v1, JSValue* v2)
+static inline bool jsLess(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
 {
     if (JSImmediate::areBothImmediateNumbers(v1, v2))
         return JSImmediate::getTruncatedInt32(v1) < JSImmediate::getTruncatedInt32(v2);
@@ -160,8 +160,8 @@ static inline bool jsLess(CallFrame* callFrame, JSValue* v1, JSValue* v2)
     if (interpreter->isJSString(v1) && interpreter->isJSString(v2))
         return asString(v1)->value() < asString(v2)->value();
 
-    JSValue* p1;
-    JSValue* p2;
+    JSValuePtr p1;
+    JSValuePtr p2;
     bool wasNotString1 = v1->getPrimitiveNumber(callFrame, n1, p1);
     bool wasNotString2 = v2->getPrimitiveNumber(callFrame, n2, p2);
 
@@ -171,7 +171,7 @@ static inline bool jsLess(CallFrame* callFrame, JSValue* v1, JSValue* v2)
     return asString(p1)->value() < asString(p2)->value();
 }
 
-static inline bool jsLessEq(CallFrame* callFrame, JSValue* v1, JSValue* v2)
+static inline bool jsLessEq(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
 {
     if (JSImmediate::areBothImmediateNumbers(v1, v2))
         return JSImmediate::getTruncatedInt32(v1) <= JSImmediate::getTruncatedInt32(v2);
@@ -185,8 +185,8 @@ static inline bool jsLessEq(CallFrame* callFrame, JSValue* v1, JSValue* v2)
     if (interpreter->isJSString(v1) && interpreter->isJSString(v2))
         return !(asString(v2)->value() < asString(v1)->value());
 
-    JSValue* p1;
-    JSValue* p2;
+    JSValuePtr p1;
+    JSValuePtr p2;
     bool wasNotString1 = v1->getPrimitiveNumber(callFrame, n1, p1);
     bool wasNotString2 = v2->getPrimitiveNumber(callFrame, n2, p2);
 
@@ -196,11 +196,11 @@ static inline bool jsLessEq(CallFrame* callFrame, JSValue* v1, JSValue* v2)
     return !(asString(p2)->value() < asString(p1)->value());
 }
 
-static NEVER_INLINE JSValue* jsAddSlowCase(CallFrame* callFrame, JSValue* v1, JSValue* v2)
+static NEVER_INLINE JSValuePtr jsAddSlowCase(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
 {
     // exception for the Date exception in defaultValue()
-    JSValue* p1 = v1->toPrimitive(callFrame);
-    JSValue* p2 = v2->toPrimitive(callFrame);
+    JSValuePtr p1 = v1->toPrimitive(callFrame);
+    JSValuePtr p2 = v2->toPrimitive(callFrame);
 
     if (p1->isString() || p2->isString()) {
         RefPtr<UString::Rep> value = concatenate(p1->toString(callFrame).rep(), p2->toString(callFrame).rep());
@@ -221,7 +221,7 @@ static NEVER_INLINE JSValue* jsAddSlowCase(CallFrame* callFrame, JSValue* v1, JS
 //    13962   Add case: 5 3
 //    4000    Add case: 3 5
 
-static ALWAYS_INLINE JSValue* jsAdd(CallFrame* callFrame, JSValue* v1, JSValue* v2)
+static ALWAYS_INLINE JSValuePtr jsAdd(CallFrame* callFrame, JSValuePtr v1, JSValuePtr v2)
 {
     double left;
     double right = 0.0;
@@ -252,7 +252,7 @@ static ALWAYS_INLINE JSValue* jsAdd(CallFrame* callFrame, JSValue* v1, JSValue*
     return jsAddSlowCase(callFrame, v1, v2);
 }
 
-static JSValue* jsTypeStringForValue(CallFrame* callFrame, JSValue* v)
+static JSValuePtr jsTypeStringForValue(CallFrame* callFrame, JSValuePtr v)
 {
     if (v->isUndefined())
         return jsNontrivialString(callFrame, "undefined");
@@ -274,7 +274,7 @@ static JSValue* jsTypeStringForValue(CallFrame* callFrame, JSValue* v)
     return jsNontrivialString(callFrame, "object");
 }
 
-static bool jsIsObjectType(JSValue* v)
+static bool jsIsObjectType(JSValuePtr v)
 {
     if (JSImmediate::isImmediate(v))
         return v->isNull();
@@ -292,7 +292,7 @@ static bool jsIsObjectType(JSValue* v)
     return true;
 }
 
-static bool jsIsFunctionType(JSValue* v)
+static bool jsIsFunctionType(JSValuePtr v)
 {
     if (v->isObject()) {
         CallData callData;
@@ -302,7 +302,7 @@ static bool jsIsFunctionType(JSValue* v)
     return false;
 }
 
-NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue)
 {
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
@@ -318,11 +318,11 @@ NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, J
         JSObject* o = *iter;
         PropertySlot slot(o);
         if (o->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSValuePtr result = slot.getValue(callFrame, ident);
             exceptionValue = callFrame->globalData().exception;
             if (exceptionValue)
                 return false;
-            callFrame[dst] = result;
+            callFrame[dst] = JSValuePtr(result);
             return true;
         }
     } while (++iter != end);
@@ -330,7 +330,7 @@ NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, J
     return false;
 }
 
-NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue)
 {
     CodeBlock* codeBlock = callFrame->codeBlock();
 
@@ -351,11 +351,11 @@ NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vP
         JSObject* o = *iter;
         PropertySlot slot(o);
         if (o->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSValuePtr result = slot.getValue(callFrame, ident);
             exceptionValue = callFrame->globalData().exception;
             if (exceptionValue)
                 return false;
-            callFrame[dst] = result;
+            callFrame[dst] = JSValuePtr(result);
             return true;
         }
     } while (++iter != end);
@@ -363,7 +363,7 @@ NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vP
     return false;
 }
 
-NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue)
 {
     int dst = (vPC + 1)->u.operand;
     JSGlobalObject* globalObject = static_cast<JSGlobalObject*>((vPC + 2)->u.jsCell);
@@ -373,7 +373,7 @@ NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction*
     int offset = (vPC + 5)->u.operand;
 
     if (structure == globalObject->structure()) {
-        callFrame[dst] = globalObject->getDirectOffset(offset);
+        callFrame[dst] = JSValuePtr(globalObject->getDirectOffset(offset));
         return true;
     }
 
@@ -381,21 +381,21 @@ NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction*
     Identifier& ident = codeBlock->identifier(property);
     PropertySlot slot(globalObject);
     if (globalObject->getPropertySlot(callFrame, ident, slot)) {
-        JSValue* result = slot.getValue(callFrame, ident);
+        JSValuePtr result = slot.getValue(callFrame, ident);
         if (slot.isCacheable() && !globalObject->structure()->isDictionary()) {
             if (vPC[4].u.structure)
                 vPC[4].u.structure->deref();
             globalObject->structure()->ref();
             vPC[4] = globalObject->structure();
             vPC[5] = slot.cachedOffset();
-            callFrame[dst] = result;
+            callFrame[dst] = JSValuePtr(result);
             return true;
         }
 
         exceptionValue = callFrame->globalData().exception;
         if (exceptionValue)
             return false;
-        callFrame[dst] = result;
+        callFrame[dst] = JSValuePtr(result);
         return true;
     }
 
@@ -403,7 +403,7 @@ NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction*
     return false;
 }
 
-static ALWAYS_INLINE JSValue* inlineResolveBase(CallFrame* callFrame, Identifier& property, ScopeChainNode* scopeChain)
+static ALWAYS_INLINE JSValuePtr inlineResolveBase(CallFrame* callFrame, Identifier& property, ScopeChainNode* scopeChain)
 {
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator next = iter;
@@ -430,10 +430,10 @@ NEVER_INLINE void Interpreter::resolveBase(CallFrame* callFrame, Instruction* vP
 {
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
-    callFrame[dst] = inlineResolveBase(callFrame, callFrame->codeBlock()->identifier(property), callFrame->scopeChain());
+    callFrame[dst] = JSValuePtr(inlineResolveBase(callFrame, callFrame->codeBlock()->identifier(property), callFrame->scopeChain()));
 }
 
-NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue)
 {
     int baseDst = (vPC + 1)->u.operand;
     int propDst = (vPC + 2)->u.operand;
@@ -454,12 +454,12 @@ NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Inst
         base = *iter;
         PropertySlot slot(base);
         if (base->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSValuePtr result = slot.getValue(callFrame, ident);
             exceptionValue = callFrame->globalData().exception;
             if (exceptionValue)
                 return false;
-            callFrame[propDst] = result;
-            callFrame[baseDst] = base;
+            callFrame[propDst] = JSValuePtr(result);
+            callFrame[baseDst] = JSValuePtr(base);
             return true;
         }
         ++iter;
@@ -469,7 +469,7 @@ NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Inst
     return false;
 }
 
-NEVER_INLINE bool Interpreter::resolveBaseAndFunc(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Interpreter::resolveBaseAndFunc(CallFrame* callFrame, Instruction* vPC, JSValuePtr& exceptionValue)
 {
     int baseDst = (vPC + 1)->u.operand;
     int funcDst = (vPC + 2)->u.operand;
@@ -498,13 +498,13 @@ NEVER_INLINE bool Interpreter::resolveBaseAndFunc(CallFrame* callFrame, Instruct
             // that in host objects you always get a valid object for this.
             // We also handle wrapper substitution for the global object at the same time.
             JSObject* thisObj = base->toThisObject(callFrame);
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSValuePtr result = slot.getValue(callFrame, ident);
             exceptionValue = callFrame->globalData().exception;
             if (exceptionValue)
                 return false;
 
-            callFrame[baseDst] = thisObj;
-            callFrame[funcDst] = result;
+            callFrame[baseDst] = JSValuePtr(thisObj);
+            callFrame[funcDst] = JSValuePtr(result);
             return true;
         }
         ++iter;
@@ -551,7 +551,7 @@ ALWAYS_INLINE CallFrame* Interpreter::slideRegisterWindowForCall(CodeBlock* newC
     return CallFrame::create(r);
 }
 
-static NEVER_INLINE bool isNotObject(CallFrame* callFrame, bool forInstanceOf, CodeBlock* codeBlock, const Instruction* vPC, JSValue* value, JSValue*& exceptionData)
+static NEVER_INLINE bool isNotObject(CallFrame* callFrame, bool forInstanceOf, CodeBlock* codeBlock, const Instruction* vPC, JSValuePtr value, JSValuePtr& exceptionData)
 {
     if (value->isObject())
         return false;
@@ -559,12 +559,12 @@ static NEVER_INLINE bool isNotObject(CallFrame* callFrame, bool forInstanceOf, C
     return true;
 }
 
-NEVER_INLINE JSValue* Interpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValue*& exceptionValue)
+NEVER_INLINE JSValuePtr Interpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValuePtr& exceptionValue)
 {
     if (argc < 2)
         return jsUndefined();
 
-    JSValue* program = argv[1].jsValue(callFrame);
+    JSValuePtr program = argv[1].jsValue(callFrame);
 
     if (!program->isString())
         return program;
@@ -575,7 +575,7 @@ NEVER_INLINE JSValue* Interpreter::callEval(CallFrame* callFrame, RegisterFile*
     CodeBlock* codeBlock = callFrame->codeBlock();
     RefPtr<EvalNode> evalNode = codeBlock->evalCodeCache().get(callFrame, programSource, scopeChain, exceptionValue);
 
-    JSValue* result = jsUndefined();
+    JSValuePtr result = jsUndefined();
     if (evalNode)
         result = callFrame->globalData().interpreter->execute(evalNode.get(), callFrame, callFrame->thisValue()->toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue);
 
@@ -733,7 +733,7 @@ bool Interpreter::isOpcode(Opcode opcode)
 #endif
 }
 
-NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValue* exceptionValue, unsigned& bytecodeOffset, CodeBlock*& codeBlock)
+NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValuePtr exceptionValue, unsigned& bytecodeOffset, CodeBlock*& codeBlock)
 {
     CodeBlock* oldCodeBlock = codeBlock;
     ScopeChainNode* scopeChain = callFrame->scopeChain();
@@ -776,7 +776,7 @@ NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValue* e
     return true;
 }
 
-NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSValue*& exceptionValue, unsigned bytecodeOffset, bool explicitThrow)
+NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSValuePtr& exceptionValue, unsigned bytecodeOffset, bool explicitThrow)
 {
     // Set up the exception object
 
@@ -861,7 +861,7 @@ NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSV
     return handler;
 }
 
-JSValue* Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
+JSValuePtr Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValuePtr* exception)
 {
     ASSERT(!scopeChain->globalData->exception);
 
@@ -886,7 +886,7 @@ JSValue* Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, Sc
     globalObject->copyGlobalsTo(m_registerFile);
 
     CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->m_numParameters + RegisterFile::CallFrameHeaderSize);
-    newCallFrame[codeBlock->thisRegister()] = thisObj;
+    newCallFrame[codeBlock->thisRegister()] = JSValuePtr(thisObj);
     newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), 0, 0, 0);
 
     if (codeBlock->needsFullScopeChain())
@@ -896,7 +896,7 @@ JSValue* Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, Sc
     if (*profiler)
         (*profiler)->willExecute(newCallFrame, programNode->sourceURL(), programNode->lineNo());
 
-    JSValue* result;
+    JSValuePtr result;
     {
         SamplingTool::CallRecord callRecord(m_sampler);
 
@@ -922,7 +922,7 @@ JSValue* Interpreter::execute(ProgramNode* programNode, CallFrame* callFrame, Sc
     return result;
 }
 
-JSValue* Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue** exception)
+JSValuePtr Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValuePtr* exception)
 {
     ASSERT(!scopeChain->globalData->exception);
 
@@ -943,7 +943,7 @@ JSValue* Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* cal
 
     CallFrame* newCallFrame = CallFrame::create(oldEnd);
     size_t dst = 0;
-    newCallFrame[0] = thisObj;
+    newCallFrame[0] = JSValuePtr(thisObj);
     ArgList::const_iterator end = args.end();
     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
         newCallFrame[++dst] = *it;
@@ -962,7 +962,7 @@ JSValue* Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* cal
     if (*profiler)
         (*profiler)->willExecute(newCallFrame, function);
 
-    JSValue* result;
+    JSValuePtr result;
     {
         SamplingTool::CallRecord callRecord(m_sampler);
 
@@ -984,12 +984,12 @@ JSValue* Interpreter::execute(FunctionBodyNode* functionBodyNode, CallFrame* cal
     return result;
 }
 
-JSValue* Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception)
+JSValuePtr Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValuePtr* exception)
 {
     return execute(evalNode, callFrame, thisObj, m_registerFile.size() + evalNode->bytecode(scopeChain).m_numParameters + RegisterFile::CallFrameHeaderSize, scopeChain, exception);
 }
 
-JSValue* Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValue** exception)
+JSValuePtr Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValuePtr* exception)
 {
     ASSERT(!scopeChain->globalData->exception);
 
@@ -1044,7 +1044,7 @@ JSValue* Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject
     CallFrame* newCallFrame = CallFrame::create(m_registerFile.start() + globalRegisterOffset);
 
     // a 0 codeBlock indicates a built-in caller
-    newCallFrame[codeBlock->thisRegister()] = thisObj;
+    newCallFrame[codeBlock->thisRegister()] = JSValuePtr(thisObj);
     newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, 0, 0);
 
     if (codeBlock->needsFullScopeChain())
@@ -1054,7 +1054,7 @@ JSValue* Interpreter::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject
     if (*profiler)
         (*profiler)->willExecute(newCallFrame, evalNode->sourceURL(), evalNode->lineNo());
 
-    JSValue* result;
+    JSValuePtr result;
     {
         SamplingTool::CallRecord callRecord(m_sampler);
 
@@ -1155,14 +1155,14 @@ 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* Interpreter::checkTimeout(JSGlobalObject* globalObject)
+ALWAYS_INLINE bool Interpreter::checkTimeout(JSGlobalObject* globalObject)
 {
     unsigned currentTime = getCPUTime();
     
     if (!m_timeAtLastCheckTimeout) {
         // Suspicious amount of looping in a script -- start timing it
         m_timeAtLastCheckTimeout = currentTime;
-        return noValue();
+        return false;
     }
     
     unsigned timeDiff = currentTime - m_timeAtLastCheckTimeout;
@@ -1183,12 +1183,12 @@ ALWAYS_INLINE JSValue* Interpreter::checkTimeout(JSGlobalObject* globalObject)
     
     if (m_timeoutTime && m_timeExecuting > m_timeoutTime) {
         if (globalObject->shouldInterruptScript())
-            return jsNull(); // Appeasing GCC, all we need is a non-null js value.
+            return true;
         
         resetTimeoutCheck();
     }
     
-    return noValue();
+    return false;
 }
 
 NEVER_INLINE ScopeChainNode* Interpreter::createExceptionScope(CallFrame* callFrame, const Instruction* vPC)
@@ -1196,16 +1196,16 @@ NEVER_INLINE ScopeChainNode* Interpreter::createExceptionScope(CallFrame* callFr
     int dst = (++vPC)->u.operand;
     CodeBlock* codeBlock = callFrame->codeBlock();
     Identifier& property = codeBlock->identifier((++vPC)->u.operand);
-    JSValue* value = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+    JSValuePtr value = callFrame[(++vPC)->u.operand].jsValue(callFrame);
     JSObject* scope = new (callFrame) JSStaticScopeObject(callFrame, property, value, DontDelete);
-    callFrame[dst] = scope;
+    callFrame[dst] = JSValuePtr(scope);
 
     return callFrame->scopeChain()->push(scope);
 }
 
 static StructureChain* cachePrototypeChain(CallFrame* callFrame, Structure* structure)
 {
-    JSValue* prototype = structure->prototypeForLookup(callFrame);
+    JSValuePtr prototype = structure->prototypeForLookup(callFrame);
     if (JSImmediate::isImmediate(prototype))
         return 0;
     RefPtr<StructureChain> chain = StructureChain::create(asObject(prototype)->structure());
@@ -1213,7 +1213,7 @@ static StructureChain* cachePrototypeChain(CallFrame* callFrame, Structure* stru
     return structure->cachedPrototypeChain();
 }
 
-NEVER_INLINE void Interpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void Interpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValuePtr baseValue, const PutPropertySlot& slot)
 {
     // Recursive invocation may already have specialized this instruction.
     if (vPC[0].u.opcode != getOpcode(op_put_by_id))
@@ -1290,13 +1290,13 @@ NEVER_INLINE void Interpreter::uncachePutByID(CodeBlock* codeBlock, Instruction*
     vPC[4] = 0;
 }
 
-static size_t countPrototypeChainEntriesAndCheckForProxies(CallFrame* callFrame, JSValue* baseValue, const PropertySlot& slot)
+static size_t countPrototypeChainEntriesAndCheckForProxies(CallFrame* callFrame, JSValuePtr baseValue, const PropertySlot& slot)
 {
     JSCell* cell = asCell(baseValue);
     size_t count = 0;
 
     while (slot.slotBase() != cell) {
-        JSValue* v = cell->structure()->prototypeForLookup(callFrame);
+        JSValuePtr v = cell->structure()->prototypeForLookup(callFrame);
 
         // If we didn't find slotBase in baseValue's prototype chain, then baseValue
         // must be a proxy for another object.
@@ -1321,7 +1321,7 @@ static size_t countPrototypeChainEntriesAndCheckForProxies(CallFrame* callFrame,
     return count;
 }
 
-NEVER_INLINE void Interpreter::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, JSValuePtr 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))
@@ -1427,7 +1427,7 @@ NEVER_INLINE void Interpreter::uncacheGetByID(CodeBlock* codeBlock, Instruction*
     vPC[4] = 0;
 }
 
-JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValue** exception)
+JSValuePtr Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValuePtr* 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.
@@ -1451,7 +1451,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
 #endif
 
     JSGlobalData* globalData = &callFrame->globalData();
-    JSValue* exceptionValue = noValue();
+    JSValuePtr exceptionValue = noValue();
     HandlerInfo* handler = 0;
 
     Instruction* vPC = callFrame->codeBlock()->instructions().begin();
@@ -1472,8 +1472,10 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
 
 #define CHECK_FOR_TIMEOUT() \
     if (!--tickCount) { \
-        if ((exceptionValue = checkTimeout(callFrame->dynamicGlobalObject()))) \
+        if (checkTimeout(callFrame->dynamicGlobalObject())) { \
+            exceptionValue = jsNull(); \
             goto vm_throw; \
+        } \
         tickCount = m_ticksUntilNextTimeoutCheck; \
     }
     
@@ -1512,7 +1514,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            constructor, and puts the result in register dst.
         */
         int dst = (++vPC)->u.operand;
-        callFrame[dst] = constructEmptyObject(callFrame);
+        callFrame[dst] = JSValuePtr(constructEmptyObject(callFrame));
 
         ++vPC;
         NEXT_INSTRUCTION();
@@ -1529,7 +1531,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int firstArg = (++vPC)->u.operand;
         int argCount = (++vPC)->u.operand;
         ArgList args(callFrame->registers() + firstArg, argCount);
-        callFrame[dst] = constructArray(callFrame, args);
+        callFrame[dst] = JSValuePtr(constructArray(callFrame, args));
 
         ++vPC;
         NEXT_INSTRUCTION();
@@ -1543,7 +1545,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int dst = (++vPC)->u.operand;
         int regExp = (++vPC)->u.operand;
-        callFrame[dst] = new (globalData) RegExpObject(callFrame->scopeChain()->globalObject()->regExpStructure(), callFrame->codeBlock()->regexp(regExp));
+        callFrame[dst] = JSValuePtr(new (globalData) RegExpObject(callFrame->scopeChain()->globalObject()->regExpStructure(), callFrame->codeBlock()->regexp(regExp)));
 
         ++vPC;
         NEXT_INSTRUCTION();
@@ -1568,12 +1570,12 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            as a boolean in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
             callFrame[dst] = jsBoolean(src1 == src2);
         else {
-            JSValue* result = jsBoolean(equalSlowCase(callFrame, src1, src2));
+            JSValuePtr result = jsBoolean(equalSlowCase(callFrame, src1, src2));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1588,7 +1590,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            operator, and puts the result as a boolean in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
 
         if (src->isUndefinedOrNull()) {
             callFrame[dst] = jsBoolean(true);
@@ -1608,12 +1610,12 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            result as a boolean in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
             callFrame[dst] = jsBoolean(src1 != src2);
         else {
-            JSValue* result = jsBoolean(!equalSlowCase(callFrame, src1, src2));
+            JSValuePtr result = jsBoolean(!equalSlowCase(callFrame, src1, src2));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1628,7 +1630,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            operator, and puts the result as a boolean in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
 
         if (src->isUndefinedOrNull()) {
             callFrame[dst] = jsBoolean(false);
@@ -1648,8 +1650,8 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            result as a boolean in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::areBothImmediate(src1, src2))
             callFrame[dst] = jsBoolean(src1 == src2);
         else if (JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate()))
@@ -1668,8 +1670,8 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            puts the result as a boolean in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
 
         if (JSImmediate::areBothImmediate(src1, src2))
             callFrame[dst] = jsBoolean(src1 != src2);
@@ -1689,9 +1691,9 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            a boolean in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* result = jsBoolean(jsLess(callFrame, src1, src2));
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr result = jsBoolean(jsLess(callFrame, src1, src2));
         CHECK_FOR_EXCEPTION();
         callFrame[dst] = result;
 
@@ -1706,9 +1708,9 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            puts the result as a boolean in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* result = jsBoolean(jsLessEq(callFrame, src1, src2));
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr result = jsBoolean(jsLessEq(callFrame, src1, src2));
         CHECK_FOR_EXCEPTION();
         callFrame[dst] = result;
 
@@ -1722,11 +1724,11 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            back in register srcDst.
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = callFrame[srcDst].jsValue(callFrame);
+        JSValuePtr v = callFrame[srcDst].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(v))
-            callFrame[srcDst] = JSImmediate::incImmediateNumber(v);
+            callFrame[srcDst] = JSValuePtr(JSImmediate::incImmediateNumber(v));
         else {
-            JSValue* result = jsNumber(callFrame, v->toNumber(callFrame) + 1);
+            JSValuePtr result = jsNumber(callFrame, v->toNumber(callFrame) + 1);
             CHECK_FOR_EXCEPTION();
             callFrame[srcDst] = result;
         }
@@ -1741,11 +1743,11 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            back in register srcDst.
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = callFrame[srcDst].jsValue(callFrame);
+        JSValuePtr v = callFrame[srcDst].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(v))
-            callFrame[srcDst] = JSImmediate::decImmediateNumber(v);
+            callFrame[srcDst] = JSValuePtr(JSImmediate::decImmediateNumber(v));
         else {
-            JSValue* result = jsNumber(callFrame, v->toNumber(callFrame) - 1);
+            JSValuePtr result = jsNumber(callFrame, v->toNumber(callFrame) - 1);
             CHECK_FOR_EXCEPTION();
             callFrame[srcDst] = result;
         }
@@ -1762,15 +1764,15 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = callFrame[srcDst].jsValue(callFrame);
+        JSValuePtr v = callFrame[srcDst].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(v)) {
             callFrame[dst] = v;
-            callFrame[srcDst] = JSImmediate::incImmediateNumber(v);
+            callFrame[srcDst] = JSValuePtr(JSImmediate::incImmediateNumber(v));
         } else {
-            JSValue* number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
+            JSValuePtr number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = number;
-            callFrame[srcDst] = jsNumber(callFrame, number->uncheckedGetNumber() + 1);
+            callFrame[srcDst] = JSValuePtr(jsNumber(callFrame, number->uncheckedGetNumber() + 1));
         }
 
         ++vPC;
@@ -1785,15 +1787,15 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = callFrame[srcDst].jsValue(callFrame);
+        JSValuePtr v = callFrame[srcDst].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(v)) {
             callFrame[dst] = v;
-            callFrame[srcDst] = JSImmediate::decImmediateNumber(v);
+            callFrame[srcDst] = JSValuePtr(JSImmediate::decImmediateNumber(v));
         } else {
-            JSValue* number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
+            JSValuePtr number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = number;
-            callFrame[srcDst] = jsNumber(callFrame, number->uncheckedGetNumber() - 1);
+            callFrame[srcDst] = JSValuePtr(jsNumber(callFrame, number->uncheckedGetNumber() - 1));
         }
 
         ++vPC;
@@ -1808,12 +1810,12 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
 
-        JSValue* srcVal = callFrame[src].jsValue(callFrame);
+        JSValuePtr srcVal = callFrame[src].jsValue(callFrame);
 
         if (LIKELY(srcVal->isNumber()))
             callFrame[dst] = callFrame[src];
         else {
-            JSValue* result = srcVal->toJSNumber(callFrame);
+            JSValuePtr result = srcVal->toJSNumber(callFrame);
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1828,13 +1830,13 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            result in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         ++vPC;
         double v;
         if (fastIsNumber(src, v))
-            callFrame[dst] = jsNumber(callFrame, -v);
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, -v));
         else {
-            JSValue* result = jsNumber(callFrame, -src->toNumber(callFrame));
+            JSValuePtr result = jsNumber(callFrame, -src->toNumber(callFrame));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1849,12 +1851,12 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            numeric add, depending on the types of the operands.)
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
-            callFrame[dst] = JSImmediate::addImmediateNumbers(src1, src2);
+            callFrame[dst] = JSValuePtr(JSImmediate::addImmediateNumbers(src1, src2));
         else {
-            JSValue* result = jsAdd(callFrame, src1, src2);
+            JSValuePtr result = jsAdd(callFrame, src1, src2);
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1868,21 +1870,21 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            numbers), and puts the product in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         double left;
         double right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2)) {
             int32_t left = JSImmediate::getTruncatedInt32(src1);
             int32_t right = JSImmediate::getTruncatedInt32(src2);
             if ((left | right) >> 15 == 0)
-                callFrame[dst] = jsNumber(callFrame, left * right);
+                callFrame[dst] = JSValuePtr(jsNumber(callFrame, left * right));
             else
-                callFrame[dst] = jsNumber(callFrame, static_cast<double>(left) * static_cast<double>(right));
+                callFrame[dst] = JSValuePtr(jsNumber(callFrame, static_cast<double>(left) * static_cast<double>(right)));
         } else if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left * right);
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left * right));
         else {
-            JSValue* result = jsNumber(callFrame, src1->toNumber(callFrame) * src2->toNumber(callFrame));
+            JSValuePtr result = jsNumber(callFrame, src1->toNumber(callFrame) * src2->toNumber(callFrame));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1898,14 +1900,14 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            quotient in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* dividend = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* divisor = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr dividend = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr divisor = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         double left;
         double right;
         if (fastIsNumber(dividend, left) && fastIsNumber(divisor, right))
-            callFrame[dst] = jsNumber(callFrame, left / right);
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left / right));
         else {
-            JSValue* result = jsNumber(callFrame, dividend->toNumber(callFrame) / divisor->toNumber(callFrame));
+            JSValuePtr result = jsNumber(callFrame, dividend->toNumber(callFrame) / divisor->toNumber(callFrame));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1923,17 +1925,17 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int dividend = (++vPC)->u.operand;
         int divisor = (++vPC)->u.operand;
 
-        JSValue* dividendValue = callFrame[dividend].jsValue(callFrame);
-        JSValue* divisorValue = callFrame[divisor].jsValue(callFrame);
+        JSValuePtr dividendValue = callFrame[dividend].jsValue(callFrame);
+        JSValuePtr divisorValue = callFrame[divisor].jsValue(callFrame);
 
         if (JSImmediate::areBothImmediateNumbers(dividendValue, divisorValue) && divisorValue != JSImmediate::from(0)) {
-            callFrame[dst] = JSImmediate::from(JSImmediate::getTruncatedInt32(dividendValue) % JSImmediate::getTruncatedInt32(divisorValue));
+            callFrame[dst] = JSValuePtr(JSImmediate::from(JSImmediate::getTruncatedInt32(dividendValue) % JSImmediate::getTruncatedInt32(divisorValue)));
             ++vPC;
             NEXT_INSTRUCTION();
         }
 
         double d = dividendValue->toNumber(callFrame);
-        JSValue* result = jsNumber(callFrame, fmod(d, divisorValue->toNumber(callFrame)));
+        JSValuePtr result = jsNumber(callFrame, fmod(d, divisorValue->toNumber(callFrame)));
         CHECK_FOR_EXCEPTION();
         callFrame[dst] = result;
         ++vPC;
@@ -1947,16 +1949,16 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         double left;
         double right;
         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
-            callFrame[dst] = JSImmediate::subImmediateNumbers(src1, src2);
+            callFrame[dst] = JSValuePtr(JSImmediate::subImmediateNumbers(src1, src2));
         else if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left - right);
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left - right));
         else {
-            JSValue* result = jsNumber(callFrame, src1->toNumber(callFrame) - src2->toNumber(callFrame));
+            JSValuePtr result = jsNumber(callFrame, src1->toNumber(callFrame) - src2->toNumber(callFrame));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1971,16 +1973,16 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         uint32_t right;
         if (JSImmediate::areBothImmediateNumbers(val, shift))
-            callFrame[dst] = jsNumber(callFrame, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f));
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f)));
         else if (fastToInt32(val, left) && fastToUInt32(shift, right))
-            callFrame[dst] = jsNumber(callFrame, left << (right & 0x1f));
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left << (right & 0x1f)));
         else {
-            JSValue* result = jsNumber(callFrame, (val->toInt32(callFrame)) << (shift->toUInt32(callFrame) & 0x1f));
+            JSValuePtr result = jsNumber(callFrame, (val->toInt32(callFrame)) << (shift->toUInt32(callFrame) & 0x1f));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -1996,16 +1998,16 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            uint32), and puts the result in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         uint32_t right;
         if (JSImmediate::areBothImmediateNumbers(val, shift))
-            callFrame[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
+            callFrame[dst] = JSValuePtr(JSImmediate::rightShiftImmediateNumbers(val, shift));
         else if (fastToInt32(val, left) && fastToUInt32(shift, right))
-            callFrame[dst] = jsNumber(callFrame, left >> (right & 0x1f));
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left >> (right & 0x1f)));
         else {
-            JSValue* result = jsNumber(callFrame, (val->toInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
+            JSValuePtr result = jsNumber(callFrame, (val->toInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -2021,12 +2023,12 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            uint32), and puts the result in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
-            callFrame[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
+            callFrame[dst] = JSValuePtr(JSImmediate::rightShiftImmediateNumbers(val, shift));
         else {
-            JSValue* result = jsNumber(callFrame, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
+            JSValuePtr result = jsNumber(callFrame, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -2042,16 +2044,16 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            callFrame[dst] = JSImmediate::andImmediateNumbers(src1, src2);
+            callFrame[dst] = JSValuePtr(JSImmediate::andImmediateNumbers(src1, src2));
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left & right);
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left & right));
         else {
-            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) & src2->toInt32(callFrame));
+            JSValuePtr result = jsNumber(callFrame, src1->toInt32(callFrame) & src2->toInt32(callFrame));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -2067,16 +2069,16 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            callFrame[dst] = JSImmediate::xorImmediateNumbers(src1, src2);
+            callFrame[dst] = JSValuePtr(JSImmediate::xorImmediateNumbers(src1, src2));
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left ^ right);
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left ^ right));
         else {
-            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) ^ src2->toInt32(callFrame));
+            JSValuePtr result = jsNumber(callFrame, src1->toInt32(callFrame) ^ src2->toInt32(callFrame));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -2092,16 +2094,16 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            result in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            callFrame[dst] = JSImmediate::orImmediateNumbers(src1, src2);
+            callFrame[dst] = JSValuePtr(JSImmediate::orImmediateNumbers(src1, src2));
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left | right);
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, left | right));
         else {
-            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) | src2->toInt32(callFrame));
+            JSValuePtr result = jsNumber(callFrame, src1->toInt32(callFrame) | src2->toInt32(callFrame));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -2116,12 +2118,12 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            and puts the result in register dst.
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t value;
         if (fastToInt32(src, value))
-            callFrame[dst] = jsNumber(callFrame, ~value);
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, ~value));
         else {
-            JSValue* result = jsNumber(callFrame, ~src->toInt32(callFrame));
+            JSValuePtr result = jsNumber(callFrame, ~src->toInt32(callFrame));
             CHECK_FOR_EXCEPTION();
             callFrame[dst] = result;
         }
@@ -2136,7 +2138,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* result = jsBoolean(!callFrame[src].jsValue(callFrame)->toBoolean(callFrame));
+        JSValuePtr result = jsBoolean(!callFrame[src].jsValue(callFrame)->toBoolean(callFrame));
         CHECK_FOR_EXCEPTION();
         callFrame[dst] = result;
 
@@ -2161,7 +2163,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int base = vPC[3].u.operand;
         int baseProto = vPC[4].u.operand;
 
-        JSValue* baseVal = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseVal = callFrame[base].jsValue(callFrame);
 
         if (isNotObject(callFrame, true, callFrame->codeBlock(), vPC, baseVal, exceptionValue))
             goto vm_throw;
@@ -2180,7 +2182,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsTypeStringForValue(callFrame, callFrame[src].jsValue(callFrame));
+        callFrame[dst] = JSValuePtr(jsTypeStringForValue(callFrame, callFrame[src].jsValue(callFrame)));
 
         ++vPC;
         NEXT_INSTRUCTION();
@@ -2194,7 +2196,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* v = callFrame[src].jsValue(callFrame);
+        JSValuePtr v = callFrame[src].jsValue(callFrame);
         callFrame[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structure()->typeInfo().masqueradesAsUndefined());
 
         ++vPC;
@@ -2283,13 +2285,13 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int property = (++vPC)->u.operand;
         int base = (++vPC)->u.operand;
 
-        JSValue* baseVal = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseVal = callFrame[base].jsValue(callFrame);
         if (isNotObject(callFrame, false, callFrame->codeBlock(), vPC, baseVal, exceptionValue))
             goto vm_throw;
 
         JSObject* baseObj = asObject(baseVal);
 
-        JSValue* propName = callFrame[property].jsValue(callFrame);
+        JSValuePtr propName = callFrame[property].jsValue(callFrame);
 
         uint32_t i;
         if (propName->getUInt32(i))
@@ -2369,7 +2371,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int index = (++vPC)->u.operand;
         int value = (++vPC)->u.operand;
         
-        scope->registerAt(index) = callFrame[value].jsValue(callFrame);
+        scope->registerAt(index) = JSValuePtr(callFrame[value].jsValue(callFrame));
         ++vPC;
         NEXT_INSTRUCTION();
     }            
@@ -2417,7 +2419,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
 
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        scope->registerAt(index) = callFrame[value].jsValue(callFrame);
+        scope->registerAt(index) = JSValuePtr(callFrame[value].jsValue(callFrame));
         ++vPC;
         NEXT_INSTRUCTION();
     }
@@ -2485,9 +2487,9 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
 
         CodeBlock* codeBlock = callFrame->codeBlock();
         Identifier& ident = codeBlock->identifier(property);
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
         PropertySlot slot(baseValue);
-        JSValue* result = baseValue->get(callFrame, ident, slot);
+        JSValuePtr result = baseValue->get(callFrame, ident, slot);
         CHECK_FOR_EXCEPTION();
 
         tryCacheGetByID(callFrame, codeBlock, vPC, baseValue, ident, slot);
@@ -2504,7 +2506,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            op_get_by_id.
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
@@ -2517,7 +2519,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
                 int offset = vPC[5].u.operand;
 
                 ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == baseObject->getDirectOffset(offset));
-                callFrame[dst] = baseObject->getDirectOffset(offset);
+                callFrame[dst] = JSValuePtr(baseObject->getDirectOffset(offset));
 
                 vPC += 8;
                 NEXT_INSTRUCTION();
@@ -2535,7 +2537,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            reverts to op_get_by_id.
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
@@ -2551,7 +2553,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
                     int offset = vPC[6].u.operand;
 
                     ASSERT(protoObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == protoObject->getDirectOffset(offset));
-                    callFrame[dst] = protoObject->getDirectOffset(offset);
+                    callFrame[dst] = JSValuePtr(protoObject->getDirectOffset(offset));
 
                     vPC += 8;
                     NEXT_INSTRUCTION();
@@ -2584,7 +2586,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            reverts to op_get_by_id.
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
@@ -2606,7 +2608,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
                         int offset = vPC[7].u.operand;
 
                         ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == baseObject->getDirectOffset(offset));
-                        callFrame[dst] = baseObject->getDirectOffset(offset);
+                        callFrame[dst] = JSValuePtr(baseObject->getDirectOffset(offset));
 
                         vPC += 8;
                         NEXT_INSTRUCTION();
@@ -2629,9 +2631,9 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int property = vPC[3].u.operand;
 
         Identifier& ident = callFrame->codeBlock()->identifier(property);
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
         PropertySlot slot(baseValue);
-        JSValue* result = baseValue->get(callFrame, ident, slot);
+        JSValuePtr result = baseValue->get(callFrame, ident, slot);
         CHECK_FOR_EXCEPTION();
 
         callFrame[dst] = result;
@@ -2647,10 +2649,10 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
 
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
         if (LIKELY(isJSArray(baseValue))) {
             int dst = vPC[1].u.operand;
-            callFrame[dst] = jsNumber(callFrame, asArray(baseValue)->length());
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, asArray(baseValue)->length()));
             vPC += 8;
             NEXT_INSTRUCTION();
         }
@@ -2667,10 +2669,10 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
 
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
         if (LIKELY(isJSString(baseValue))) {
             int dst = vPC[1].u.operand;
-            callFrame[dst] = jsNumber(callFrame, asString(baseValue)->value().size());
+            callFrame[dst] = JSValuePtr(jsNumber(callFrame, asString(baseValue)->value().size()));
             vPC += 8;
             NEXT_INSTRUCTION();
         }
@@ -2693,7 +2695,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int value = vPC[3].u.operand;
 
         CodeBlock* codeBlock = callFrame->codeBlock();
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
         Identifier& ident = codeBlock->identifier(property);
         PutPropertySlot slot;
         baseValue->put(callFrame, ident, callFrame[value].jsValue(callFrame), slot);
@@ -2716,7 +2718,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            the register file.
          */
         int base = vPC[1].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
         
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
@@ -2729,7 +2731,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
 
                 RefPtr<Structure>* it = vPC[6].u.structureChain->head();
 
-                JSValue* proto = baseObject->structure()->prototypeForLookup(callFrame);
+                JSValuePtr proto = baseObject->structure()->prototypeForLookup(callFrame);
                 while (!proto->isNull()) {
                     if (UNLIKELY(asObject(proto)->structure() != (*it).get())) {
                         uncachePutByID(callFrame->codeBlock(), vPC);
@@ -2766,7 +2768,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            the register file.
         */
         int base = vPC[1].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
@@ -2802,7 +2804,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int property = vPC[2].u.operand;
         int value = vPC[3].u.operand;
 
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
         Identifier& ident = callFrame->codeBlock()->identifier(property);
         PutPropertySlot slot;
         baseValue->put(callFrame, ident, callFrame[value].jsValue(callFrame), slot);
@@ -2825,7 +2827,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
 
         JSObject* baseObj = callFrame[base].jsValue(callFrame)->toObject(callFrame);
         Identifier& ident = callFrame->codeBlock()->identifier(property);
-        JSValue* result = jsBoolean(baseObj->deleteProperty(callFrame, ident));
+        JSValuePtr result = jsBoolean(baseObj->deleteProperty(callFrame, ident));
         CHECK_FOR_EXCEPTION();
         callFrame[dst] = result;
         ++vPC;
@@ -2843,10 +2845,10 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int base = (++vPC)->u.operand;
         int property = (++vPC)->u.operand;
         
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
-        JSValue* subscript = callFrame[property].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr subscript = callFrame[property].jsValue(callFrame);
 
-        JSValue* result;
+        JSValuePtr result;
         unsigned i;
 
         bool isUInt32 = JSImmediate::getUInt32(subscript, i);
@@ -2888,8 +2890,8 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int property = (++vPC)->u.operand;
         int value = (++vPC)->u.operand;
 
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
-        JSValue* subscript = callFrame[property].jsValue(callFrame);
+        JSValuePtr baseValue = callFrame[base].jsValue(callFrame);
+        JSValuePtr subscript = callFrame[property].jsValue(callFrame);
 
         unsigned i;
 
@@ -2904,7 +2906,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
             } else if (isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
                 JSByteArray* jsByteArray = asByteArray(baseValue);
                 double dValue = 0;
-                JSValue* jsValue = callFrame[value].jsValue(callFrame);
+                JSValuePtr jsValue = callFrame[value].jsValue(callFrame);
                 if (JSImmediate::isNumber(jsValue))
                     jsByteArray->setIndex(i, JSImmediate::getTruncatedInt32(jsValue));
                 else if (fastIsNumber(jsValue, dValue))
@@ -2939,8 +2941,8 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
 
         JSObject* baseObj = callFrame[base].jsValue(callFrame)->toObject(callFrame); // may throw
 
-        JSValue* subscript = callFrame[property].jsValue(callFrame);
-        JSValue* result;
+        JSValuePtr subscript = callFrame[property].jsValue(callFrame);
+        JSValuePtr result;
         uint32_t i;
         if (subscript->getUInt32(i))
             result = jsBoolean(baseObj->deleteProperty(callFrame, i));
@@ -3068,7 +3070,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int src = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        JSValue* srcValue = callFrame[src].jsValue(callFrame);
+        JSValuePtr srcValue = callFrame[src].jsValue(callFrame);
 
         if (srcValue->isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) && srcValue->asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
             vPC += target;
@@ -3086,7 +3088,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int src = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        JSValue* srcValue = callFrame[src].jsValue(callFrame);
+        JSValuePtr srcValue = callFrame[src].jsValue(callFrame);
 
         if (!srcValue->isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) && !srcValue->asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
             vPC += target;
@@ -3107,8 +3109,8 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            Additionally this loop instruction may terminate JS execution is
            the JS timeout is reached.
          */
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int target = (++vPC)->u.operand;
         
         bool result = jsLess(callFrame, src1, src2);
@@ -3134,8 +3136,8 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            Additionally this loop instruction may terminate JS execution is
            the JS timeout is reached.
         */
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int target = (++vPC)->u.operand;
         
         bool result = jsLessEq(callFrame, src1, src2);
@@ -3158,8 +3160,8 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            target from the current instruction, if and only if the 
            result of the comparison is false.
         */
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int target = (++vPC)->u.operand;
 
         bool result = jsLess(callFrame, src1, src2);
@@ -3184,7 +3186,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
          */
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (!JSImmediate::isNumber(scrutinee))
             vPC += defaultOffset;
         else {
@@ -3204,7 +3206,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
          */
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (!scrutinee->isString())
             vPC += defaultOffset;
         else {
@@ -3227,7 +3229,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
          */
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValuePtr scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (!scrutinee->isString())
             vPC += defaultOffset;
         else 
@@ -3283,15 +3285,15 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int argCount = vPC[3].u.operand;
         int registerOffset = vPC[4].u.operand;
 
-        JSValue* funcVal = callFrame[func].jsValue(callFrame);
+        JSValuePtr funcVal = callFrame[func].jsValue(callFrame);
 
         Register* newCallFrame = callFrame->registers() + registerOffset;
         Register* argv = newCallFrame - RegisterFile::CallFrameHeaderSize - argCount;
-        JSValue* thisValue = argv[0].jsValue(callFrame);
+        JSValuePtr thisValue = argv[0].jsValue(callFrame);
         JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject();
 
         if (thisValue == globalObject && funcVal == globalObject->evalFunction()) {
-            JSValue* result = callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
+            JSValuePtr result = callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
             if (exceptionValue)
                 goto vm_throw;
             callFrame[dst] = result;
@@ -3320,7 +3322,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int argCount = vPC[3].u.operand;
         int registerOffset = vPC[4].u.operand;
 
-        JSValue* v = callFrame[func].jsValue(callFrame);
+        JSValuePtr v = callFrame[func].jsValue(callFrame);
 
         CallData callData;
         CallType callType = v->getCallData(callData);
@@ -3358,18 +3360,18 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
             ArgList args(thisRegister + 1, argCount - 1);
 
             // FIXME: All host methods should be calling toThisObject, but this is not presently the case.
-            JSValue* thisValue = thisRegister->jsValue(callFrame);
+            JSValuePtr thisValue = thisRegister->jsValue(callFrame);
             if (thisValue == jsNull())
                 thisValue = callFrame->globalThisValue();
 
-            JSValue* returnValue;
+            JSValuePtr returnValue;
             {
                 SamplingTool::HostCallRecord callRecord(m_sampler);
                 returnValue = callData.native.function(newCallFrame, asObject(v), thisValue, args);
             }
             CHECK_FOR_EXCEPTION();
 
-            callFrame[dst] = returnValue;
+            callFrame[dst] = JSValuePtr(returnValue);
 
             vPC += 5;
             NEXT_INSTRUCTION();
@@ -3436,7 +3438,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         if (callFrame->codeBlock()->needsFullScopeChain())
             callFrame->scopeChain()->deref();
 
-        JSValue* returnValue = callFrame[result].jsValue(callFrame);
+        JSValuePtr returnValue = callFrame[result].jsValue(callFrame);
 
         vPC = callFrame->returnPC();
         int dst = callFrame->returnValueRegister();
@@ -3445,7 +3447,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         if (callFrame->hasHostCallFrameFlag())
             return returnValue;
 
-        callFrame[dst] = returnValue;
+        callFrame[dst] = JSValuePtr(returnValue);
 
         NEXT_INSTRUCTION();
     }
@@ -3515,9 +3517,9 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
 
         int thisRegister = (++vPC)->u.operand;
-        JSValue* thisVal = callFrame[thisRegister].getJSValue();
+        JSValuePtr thisVal = callFrame[thisRegister].getJSValue();
         if (thisVal->needsThisConversion())
-            callFrame[thisRegister] = thisVal->toThisObject(callFrame);
+            callFrame[thisRegister] = JSValuePtr(thisVal->toThisObject(callFrame));
 
         ++vPC;
         NEXT_INSTRUCTION();
@@ -3562,7 +3564,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int proto = vPC[5].u.operand;
         int thisRegister = vPC[6].u.operand;
 
-        JSValue* v = callFrame[func].jsValue(callFrame);
+        JSValuePtr v = callFrame[func].jsValue(callFrame);
 
         ConstructData constructData;
         ConstructType constructType = v->getConstructData(constructData);
@@ -3573,14 +3575,14 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
             CodeBlock* newCodeBlock = &functionBodyNode->bytecode(callDataScopeChain);
 
             Structure* structure;
-            JSValue* prototype = callFrame[proto].jsValue(callFrame);
+            JSValuePtr prototype = callFrame[proto].jsValue(callFrame);
             if (prototype->isObject())
                 structure = asObject(prototype)->inheritorID();
             else
                 structure = callDataScopeChain->globalObject()->emptyObjectStructure();
             JSObject* newObject = new (globalData) JSObject(structure);
 
-            callFrame[thisRegister] = newObject; // "this" value
+            callFrame[thisRegister] = JSValuePtr(newObject); // "this" value
 
             CallFrame* previousCallFrame = callFrame;
 
@@ -3608,13 +3610,13 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
             CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + registerOffset);
             newCallFrame->init(0, vPC + 7, scopeChain, callFrame, dst, argCount, 0);
 
-            JSValue* returnValue;
+            JSValuePtr returnValue;
             {
                 SamplingTool::HostCallRecord callRecord(m_sampler);
                 returnValue = constructData.native.function(newCallFrame, asObject(v), args);
             }
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = returnValue;
+            callFrame[dst] = JSValuePtr(returnValue);
 
             vPC += 7;
             NEXT_INSTRUCTION();
@@ -3652,11 +3654,11 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
            are replaced by the result of toObject conversion of the scope.
         */
         int scope = (++vPC)->u.operand;
-        JSValue* v = callFrame[scope].jsValue(callFrame);
+        JSValuePtr v = callFrame[scope].jsValue(callFrame);
         JSObject* o = v->toObject(callFrame);
         CHECK_FOR_EXCEPTION();
 
-        callFrame[scope] = o;
+        callFrame[scope] = JSValuePtr(o);
         callFrame->setScopeChain(callFrame->scopeChain()->push(o));
 
         ++vPC;
@@ -3701,9 +3703,9 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int target = (++vPC)->u.operand;
 
         JSPropertyNameIterator* it = callFrame[iter].propertyNameIterator();
-        if (JSValue* temp = it->next(callFrame)) {
+        if (JSValuePtr temp = it->next(callFrame)) {
             CHECK_FOR_TIMEOUT();
-            callFrame[dst] = temp;
+            callFrame[dst] = JSValuePtr(temp);
             vPC += target;
             NEXT_INSTRUCTION();
         }
@@ -3795,7 +3797,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         */
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = callFrame->codeBlock()->unexpectedConstant(src);
+        callFrame[dst] = JSValuePtr(callFrame->codeBlock()->unexpectedConstant(src));
 
         ++vPC;
         NEXT_INSTRUCTION();
@@ -3813,7 +3815,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
         int message = (++vPC)->u.operand;
 
         CodeBlock* codeBlock = callFrame->codeBlock();
-        callFrame[dst] = Error::create(callFrame, (ErrorType)type, codeBlock->unexpectedConstant(message)->toString(callFrame), codeBlock->lineNumberForBytecodeOffset(vPC - codeBlock->instructions().begin()), codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->sourceURL());
+        callFrame[dst] = JSValuePtr(Error::create(callFrame, (ErrorType)type, codeBlock->unexpectedConstant(message)->toString(callFrame), codeBlock->lineNumberForBytecodeOffset(vPC - codeBlock->instructions().begin()), codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->sourceURL()));
 
         ++vPC;
         NEXT_INSTRUCTION();
@@ -3974,7 +3976,7 @@ JSValue* Interpreter::privateExecute(ExecutionFlag flag, RegisterFile* registerF
     #undef CHECK_FOR_TIMEOUT
 }
 
-JSValue* Interpreter::retrieveArguments(CallFrame* callFrame, JSFunction* function) const
+JSValuePtr Interpreter::retrieveArguments(CallFrame* callFrame, JSFunction* function) const
 {
     CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
     if (!functionCallFrame)
@@ -3998,7 +4000,7 @@ JSValue* Interpreter::retrieveArguments(CallFrame* callFrame, JSFunction* functi
     return arguments;
 }
 
-JSValue* Interpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const
+JSValuePtr Interpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const
 {
     CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
     if (!functionCallFrame)
@@ -4008,14 +4010,14 @@ JSValue* Interpreter::retrieveCaller(CallFrame* callFrame, InternalFunction* fun
     if (callerFrame->hasHostCallFrameFlag())
         return jsNull();
 
-    JSValue* caller = callerFrame->callee();
+    JSValuePtr caller = callerFrame->callee();
     if (!caller)
         return jsNull();
 
     return caller;
 }
 
-void Interpreter::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, JSValuePtr& function) const
 {
     function = noValue();
     lineNumber = -1;
@@ -4049,7 +4051,7 @@ CallFrame* Interpreter::findFunctionCallFrame(CallFrame* callFrame, InternalFunc
 
 #if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
 
-NEVER_INLINE void Interpreter::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void Interpreter::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValuePtr baseValue, const PutPropertySlot& slot)
 {
     // The interpreter checks for recursion here; I do not believe this can occur in CTI.
 
@@ -4106,7 +4108,7 @@ NEVER_INLINE void Interpreter::tryCTICachePutByID(CallFrame* callFrame, CodeBloc
 #endif
 }
 
-NEVER_INLINE void Interpreter::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, JSValuePtr baseValue, const Identifier& propertyName, const PropertySlot& slot)
 {
     // FIXME: Write a test that proves we need to check for recursion here just
     // like the interpreter does, then add a check for recursion.
@@ -4301,7 +4303,7 @@ JSObject* Interpreter::cti_op_convert_this(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* v1 = ARG_src1;
+    JSValuePtr v1 = ARG_src1;
     CallFrame* callFrame = ARG_callFrame;
 
     JSObject* result = v1->toThisObject(callFrame);
@@ -4318,19 +4320,19 @@ void Interpreter::cti_op_end(STUB_ARGS)
     scopeChain->deref();
 }
 
-JSValue* Interpreter::cti_op_add(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_add(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* v1 = ARG_src1;
-    JSValue* v2 = ARG_src2;
+    JSValuePtr v1 = ARG_src1;
+    JSValuePtr v2 = ARG_src2;
 
     double left;
     double right = 0.0;
 
     bool rightIsNumber = fastIsNumber(v2, right);
     if (rightIsNumber && fastIsNumber(v1, left))
-        return jsNumber(ARG_globalData, left + right);
+        return JSValuePtr::encode(jsNumber(ARG_globalData, left + right));
     
     CallFrame* callFrame = ARG_callFrame;
 
@@ -4342,7 +4344,7 @@ JSValue* Interpreter::cti_op_add(STUB_ARGS)
             VM_THROW_EXCEPTION();
         }
 
-        return jsString(ARG_globalData, value.release());
+        return JSValuePtr::encode(jsString(ARG_globalData, value.release()));
     }
 
     if (rightIsNumber & leftIsString) {
@@ -4354,25 +4356,25 @@ JSValue* Interpreter::cti_op_add(STUB_ARGS)
             throwOutOfMemoryError(callFrame);
             VM_THROW_EXCEPTION();
         }
-        return jsString(ARG_globalData, value.release());
+        return JSValuePtr::encode(jsString(ARG_globalData, value.release()));
     }
 
     // All other cases are pretty uncommon
-    JSValue* result = jsAddSlowCase(callFrame, v1, v2);
+    JSValuePtr result = jsAddSlowCase(callFrame, v1, v2);
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_pre_inc(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_pre_inc(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* v = ARG_src1;
+    JSValuePtr v = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, v->toNumber(callFrame) + 1);
+    JSValuePtr result = jsNumber(ARG_globalData, v->toNumber(callFrame) + 1);
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 int Interpreter::cti_timeout_check(STUB_ARGS)
@@ -4406,8 +4408,8 @@ int Interpreter::cti_op_loop_if_less(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
     CallFrame* callFrame = ARG_callFrame;
 
     bool result = jsLess(callFrame, src1, src2);
@@ -4419,8 +4421,8 @@ int Interpreter::cti_op_loop_if_lesseq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
     CallFrame* callFrame = ARG_callFrame;
 
     bool result = jsLessEq(callFrame, src1, src2);
@@ -4444,19 +4446,19 @@ void Interpreter::cti_op_put_by_id_generic(STUB_ARGS)
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-JSValue* Interpreter::cti_op_get_by_id_generic(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_generic(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, ident, slot);
+    JSValuePtr result = baseValue->get(callFrame, ident, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 #if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
@@ -4499,50 +4501,50 @@ void Interpreter::cti_op_put_by_id_fail(STUB_ARGS)
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-JSValue* Interpreter::cti_op_get_by_id(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, ident, slot);
+    JSValuePtr result = baseValue->get(callFrame, ident, slot);
 
     ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_id_second));
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_get_by_id_second(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_second(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, ident, slot);
+    JSValuePtr result = baseValue->get(callFrame, ident, slot);
 
     ARG_globalData->interpreter->tryCTICacheGetByID(callFrame, callFrame->codeBlock(), STUB_RETURN_ADDRESS, baseValue, ident, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_get_by_id_self_fail(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_self_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, ident, slot);
+    JSValuePtr result = baseValue->get(callFrame, ident, slot);
 
     CHECK_FOR_EXCEPTION();
 
@@ -4576,7 +4578,7 @@ JSValue* Interpreter::cti_op_get_by_id_self_fail(STUB_ARGS)
     } else {
         ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_id_generic));
     }
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 static PolymorphicAccessStructureList* getPolymorphicAccessStructureListSlot(StructureStubInfo* stubInfo, int& listIndex)
@@ -4608,21 +4610,21 @@ static PolymorphicAccessStructureList* getPolymorphicAccessStructureListSlot(Str
     return prototypeStructureList;
 }
 
-JSValue* Interpreter::cti_op_get_by_id_proto_list(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_list(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, *ARG_id2, slot);
+    JSValuePtr result = baseValue->get(callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION();
 
     if (JSImmediate::isImmediate(baseValue) || !slot.isCacheable() || asCell(baseValue)->structure()->isDictionary()) {
         ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_id_proto_fail));
-        return result;
+        return JSValuePtr::encode(result);
     }
 
     Structure* structure = asCell(baseValue)->structure();
@@ -4666,67 +4668,67 @@ JSValue* Interpreter::cti_op_get_by_id_proto_list(STUB_ARGS)
     } else
         ctiPatchCallByReturnAddress(STUB_RETURN_ADDRESS, reinterpret_cast<void*>(cti_op_get_by_id_proto_fail));
 
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_get_by_id_proto_list_full(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_list_full(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(ARG_callFrame, *ARG_id2, slot);
+    JSValuePtr result = baseValue->get(ARG_callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_get_by_id_proto_fail(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_proto_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(ARG_callFrame, *ARG_id2, slot);
+    JSValuePtr result = baseValue->get(ARG_callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_get_by_id_array_fail(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_array_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(ARG_callFrame, *ARG_id2, slot);
+    JSValuePtr result = baseValue->get(ARG_callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_get_by_id_string_fail(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_id_string_fail(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(ARG_callFrame, *ARG_id2, slot);
+    JSValuePtr result = baseValue->get(ARG_callFrame, *ARG_id2, slot);
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 #endif
 
-JSValue* Interpreter::cti_op_instanceof(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_instanceof(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* value = ARG_src1;
-    JSValue* baseVal = ARG_src2;
-    JSValue* proto = ARG_src3;
+    JSValuePtr value = ARG_src1;
+    JSValuePtr baseVal = ARG_src2;
+    JSValuePtr proto = ARG_src3;
 
     // at least one of these checks must have failed to get to the slow case
     ASSERT(JSImmediate::isAnyImmediate(value, baseVal, proto) 
@@ -4742,7 +4744,7 @@ JSValue* Interpreter::cti_op_instanceof(STUB_ARGS)
     }
 
     if (!asObject(baseVal)->structure()->typeInfo().implementsHasInstance())
-        return jsBoolean(false);
+        return JSValuePtr::encode(jsBoolean(false));
 
     if (!proto->isObject()) {
         throwError(callFrame, TypeError, "instanceof called on an object with an invalid prototype property.");
@@ -4750,15 +4752,15 @@ JSValue* Interpreter::cti_op_instanceof(STUB_ARGS)
     }
         
     if (!value->isObject())
-        return jsBoolean(false);
+        return JSValuePtr::encode(jsBoolean(false));
 
-    JSValue* result = jsBoolean(asObject(baseVal)->hasInstance(callFrame, value, proto));
+    JSValuePtr result = jsBoolean(asObject(baseVal)->hasInstance(callFrame, value, proto));
     CHECK_FOR_EXCEPTION_AT_END();
 
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_del_by_id(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_del_by_id(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
@@ -4766,27 +4768,27 @@ JSValue* Interpreter::cti_op_del_by_id(STUB_ARGS)
     
     JSObject* baseObj = ARG_src1->toObject(callFrame);
 
-    JSValue* result = jsBoolean(baseObj->deleteProperty(callFrame, *ARG_id2));
+    JSValuePtr result = jsBoolean(baseObj->deleteProperty(callFrame, *ARG_id2));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_mul(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_mul(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     double left;
     double right;
     if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-        return jsNumber(ARG_globalData, left * right);
+        return JSValuePtr::encode(jsNumber(ARG_globalData, left * right));
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) * src2->toNumber(callFrame));
+    JSValuePtr result = jsNumber(ARG_globalData, src1->toNumber(callFrame) * src2->toNumber(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 JSObject* Interpreter::cti_op_new_func(STUB_ARGS)
@@ -4897,11 +4899,11 @@ JSObject* Interpreter::cti_op_push_activation(STUB_ARGS)
     return activation;
 }
 
-JSValue* Interpreter::cti_op_call_NotJSFunction(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_call_NotJSFunction(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* funcVal = ARG_src1;
+    JSValuePtr funcVal = ARG_src1;
 
     CallData callData;
     CallType callType = funcVal->getCallData(callData);
@@ -4920,12 +4922,12 @@ JSValue* Interpreter::cti_op_call_NotJSFunction(STUB_ARGS)
         Register* argv = ARG_callFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
         ArgList argList(argv + 1, argCount - 1);
 
-        JSValue* returnValue;
+        JSValuePtr returnValue;
         {
             SamplingTool::HostCallRecord callRecord(CTI_SAMPLER);
 
             // FIXME: All host methods should be calling toThisObject, but this is not presently the case.
-            JSValue* thisValue = argv[0].jsValue(callFrame);
+            JSValuePtr thisValue = argv[0].jsValue(callFrame);
             if (thisValue == jsNull())
                 thisValue = callFrame->globalThisValue();
 
@@ -4934,7 +4936,7 @@ JSValue* Interpreter::cti_op_call_NotJSFunction(STUB_ARGS)
         ARG_setCallFrame(previousCallFrame);
         CHECK_FOR_EXCEPTION();
 
-        return returnValue;
+        return JSValuePtr::encode(returnValue);
     }
 
     ASSERT(callType == CallTypeNone);
@@ -5011,7 +5013,7 @@ JSObject* Interpreter::cti_op_new_array(STUB_ARGS)
     return constructArray(ARG_callFrame, argList);
 }
 
-JSValue* Interpreter::cti_op_resolve(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_resolve(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
@@ -5027,9 +5029,9 @@ JSValue* Interpreter::cti_op_resolve(STUB_ARGS)
         JSObject* o = *iter;
         PropertySlot slot(o);
         if (o->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSValuePtr result = slot.getValue(callFrame, ident);
             CHECK_FOR_EXCEPTION_AT_END();
-            return result;
+            return JSValuePtr::encode(result);
         }
     } while (++iter != end);
 
@@ -5056,13 +5058,13 @@ JSObject* Interpreter::cti_op_construct_JSConstruct(STUB_ARGS)
     return new (ARG_globalData) JSObject(structure);
 }
 
-JSValue* Interpreter::cti_op_construct_NotJSConstruct(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_construct_NotJSConstruct(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* constrVal = ARG_src1;
+    JSValuePtr constrVal = ARG_src1;
     int argCount = ARG_int3;
     int thisRegister = ARG_int5;
 
@@ -5072,14 +5074,14 @@ JSValue* Interpreter::cti_op_construct_NotJSConstruct(STUB_ARGS)
     if (constructType == ConstructTypeHost) {
         ArgList argList(callFrame->registers() + thisRegister + 1, argCount - 1);
 
-        JSValue* returnValue;
+        JSValuePtr returnValue;
         {
             SamplingTool::HostCallRecord callRecord(CTI_SAMPLER);
             returnValue = constructData.native.function(callFrame, asObject(constrVal), argList);
         }
         CHECK_FOR_EXCEPTION();
 
-        return returnValue;
+        return JSValuePtr::encode(returnValue);
     }
 
     ASSERT(constructType == ConstructTypeNone);
@@ -5090,17 +5092,17 @@ JSValue* Interpreter::cti_op_construct_NotJSConstruct(STUB_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* Interpreter::cti_op_get_by_val(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_get_by_val(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
     Interpreter* interpreter = ARG_globalData->interpreter;
 
-    JSValue* baseValue = ARG_src1;
-    JSValue* subscript = ARG_src2;
+    JSValuePtr baseValue = ARG_src1;
+    JSValuePtr subscript = ARG_src2;
 
-    JSValue* result;
+    JSValuePtr result;
     unsigned i;
 
     bool isUInt32 = JSImmediate::getUInt32(subscript, i);
@@ -5112,9 +5114,9 @@ JSValue* Interpreter::cti_op_get_by_val(STUB_ARGS)
             else
                 result = jsArray->JSArray::get(callFrame, i);
         } else if (interpreter->isJSString(baseValue) && asString(baseValue)->canGetIndex(i))
-            return asString(baseValue)->getIndex(ARG_globalData, i);
+            return JSValuePtr::encode(asString(baseValue)->getIndex(ARG_globalData, i));
         else if (interpreter->isJSByteArray(baseValue) && asByteArray(baseValue)->canAccessIndex(i))
-            return asByteArray(baseValue)->getIndex(i);
+            return JSValuePtr::encode(asByteArray(baseValue)->getIndex(i));
         else
             result = baseValue->get(callFrame, i);
     } else {
@@ -5123,7 +5125,7 @@ JSValue* Interpreter::cti_op_get_by_val(STUB_ARGS)
     }
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 VoidPtrPair Interpreter::cti_op_resolve_func(STUB_ARGS)
@@ -5154,10 +5156,10 @@ VoidPtrPair Interpreter::cti_op_resolve_func(STUB_ARGS)
             // that in host objects you always get a valid object for this.
             // We also handle wrapper substitution for the global object at the same time.
             JSObject* thisObj = base->toThisObject(callFrame);
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSValuePtr result = slot.getValue(callFrame, ident);
             CHECK_FOR_EXCEPTION_AT_END();
 
-            RETURN_PAIR(thisObj, asPointer(result));
+            RETURN_PAIR(thisObj, JSValuePtr::encode(result));
         }
         ++iter;
     } while (iter != end);
@@ -5168,22 +5170,22 @@ VoidPtrPair Interpreter::cti_op_resolve_func(STUB_ARGS)
     VM_THROW_EXCEPTION_2();
 }
 
-JSValue* Interpreter::cti_op_sub(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_sub(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     double left;
     double right;
     if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-        return jsNumber(ARG_globalData, left - right);
+        return JSValuePtr::encode(jsNumber(ARG_globalData, left - right));
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) - src2->toNumber(callFrame));
+    JSValuePtr result = jsNumber(ARG_globalData, src1->toNumber(callFrame) - src2->toNumber(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 void Interpreter::cti_op_put_by_val(STUB_ARGS)
@@ -5193,9 +5195,9 @@ void Interpreter::cti_op_put_by_val(STUB_ARGS)
     CallFrame* callFrame = ARG_callFrame;
     Interpreter* interpreter = ARG_globalData->interpreter;
 
-    JSValue* baseValue = ARG_src1;
-    JSValue* subscript = ARG_src2;
-    JSValue* value = ARG_src3;
+    JSValuePtr baseValue = ARG_src1;
+    JSValuePtr subscript = ARG_src2;
+    JSValuePtr value = ARG_src3;
 
     unsigned i;
 
@@ -5237,9 +5239,9 @@ void Interpreter::cti_op_put_by_val_array(STUB_ARGS)
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     int i = ARG_int2;
-    JSValue* value = ARG_src3;
+    JSValuePtr value = ARG_src3;
 
     ASSERT(ARG_globalData->interpreter->isJSArray(baseValue));
 
@@ -5257,21 +5259,21 @@ void Interpreter::cti_op_put_by_val_array(STUB_ARGS)
     CHECK_FOR_EXCEPTION_AT_END();
 }
 
-JSValue* Interpreter::cti_op_lesseq(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_lesseq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsBoolean(jsLessEq(callFrame, ARG_src1, ARG_src2));
+    JSValuePtr result = jsBoolean(jsLessEq(callFrame, ARG_src1, ARG_src2));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 int Interpreter::cti_op_loop_if_true(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
+    JSValuePtr src1 = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
@@ -5280,30 +5282,30 @@ int Interpreter::cti_op_loop_if_true(STUB_ARGS)
     return result;
 }
 
-JSValue* Interpreter::cti_op_negate(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_negate(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src = ARG_src1;
+    JSValuePtr src = ARG_src1;
 
     double v;
     if (fastIsNumber(src, v))
-        return jsNumber(ARG_globalData, -v);
+        return JSValuePtr::encode(jsNumber(ARG_globalData, -v));
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, -src->toNumber(callFrame));
+    JSValuePtr result = jsNumber(ARG_globalData, -src->toNumber(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_resolve_base(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_resolve_base(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    return inlineResolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain());
+    return JSValuePtr::encode(inlineResolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain()));
 }
 
-JSValue* Interpreter::cti_op_resolve_skip(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_resolve_skip(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
@@ -5324,9 +5326,9 @@ JSValue* Interpreter::cti_op_resolve_skip(STUB_ARGS)
         JSObject* o = *iter;
         PropertySlot slot(o);
         if (o->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSValuePtr result = slot.getValue(callFrame, ident);
             CHECK_FOR_EXCEPTION_AT_END();
-            return result;
+            return JSValuePtr::encode(result);
         }
     } while (++iter != end);
 
@@ -5336,7 +5338,7 @@ JSValue* Interpreter::cti_op_resolve_skip(STUB_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* Interpreter::cti_op_resolve_global(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_resolve_global(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
@@ -5348,7 +5350,7 @@ JSValue* Interpreter::cti_op_resolve_global(STUB_ARGS)
 
     PropertySlot slot(globalObject);
     if (globalObject->getPropertySlot(callFrame, ident, slot)) {
-        JSValue* result = slot.getValue(callFrame, ident);
+        JSValuePtr result = slot.getValue(callFrame, ident);
         if (slot.isCacheable() && !globalObject->structure()->isDictionary()) {
             GlobalResolveInfo& globalResolveInfo = callFrame->codeBlock()->globalResolveInfo(globalResolveInfoIndex);
             if (globalResolveInfo.structure)
@@ -5356,11 +5358,11 @@ JSValue* Interpreter::cti_op_resolve_global(STUB_ARGS)
             globalObject->structure()->ref();
             globalResolveInfo.structure = globalObject->structure();
             globalResolveInfo.offset = slot.cachedOffset();
-            return result;
+            return JSValuePtr::encode(result);
         }
 
         CHECK_FOR_EXCEPTION_AT_END();
-        return result;
+        return JSValuePtr::encode(result);
     }
 
     unsigned vPCIndex = ARG_callFrame->codeBlock()->getBytecodeIndex(STUB_RETURN_ADDRESS);
@@ -5368,42 +5370,42 @@ JSValue* Interpreter::cti_op_resolve_global(STUB_ARGS)
     VM_THROW_EXCEPTION();
 }
 
-JSValue* Interpreter::cti_op_div(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_div(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     double left;
     double right;
     if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-        return jsNumber(ARG_globalData, left / right);
+        return JSValuePtr::encode(jsNumber(ARG_globalData, left / right));
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) / src2->toNumber(callFrame));
+    JSValuePtr result = jsNumber(ARG_globalData, src1->toNumber(callFrame) / src2->toNumber(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_pre_dec(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_pre_dec(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* v = ARG_src1;
+    JSValuePtr v = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, v->toNumber(callFrame) - 1);
+    JSValuePtr result = jsNumber(ARG_globalData, v->toNumber(callFrame) - 1);
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 int Interpreter::cti_op_jless(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
     CallFrame* callFrame = ARG_callFrame;
 
     bool result = jsLess(callFrame, src1, src2);
@@ -5411,24 +5413,24 @@ int Interpreter::cti_op_jless(STUB_ARGS)
     return result;
 }
 
-JSValue* Interpreter::cti_op_not(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_not(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src = ARG_src1;
+    JSValuePtr src = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* result = jsBoolean(!src->toBoolean(callFrame));
+    JSValuePtr result = jsBoolean(!src->toBoolean(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 int Interpreter::cti_op_jtrue(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
+    JSValuePtr src1 = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
@@ -5441,103 +5443,103 @@ VoidPtrPair Interpreter::cti_op_post_inc(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* v = ARG_src1;
+    JSValuePtr v = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* number = v->toJSNumber(callFrame);
+    JSValuePtr number = v->toJSNumber(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
 
-    RETURN_PAIR(asPointer(number), asPointer(jsNumber(ARG_globalData, number->uncheckedGetNumber() + 1)));
+    RETURN_PAIR(JSValuePtr::encode(number), JSValuePtr::encode(jsNumber(ARG_globalData, number->uncheckedGetNumber() + 1)));
 }
 
-JSValue* Interpreter::cti_op_eq(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_eq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
 
     ASSERT(!JSImmediate::areBothImmediateNumbers(src1, src2));
-    JSValue* result = jsBoolean(equalSlowCaseInline(callFrame, src1, src2));
+    JSValuePtr result = jsBoolean(equalSlowCaseInline(callFrame, src1, src2));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_lshift(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_lshift(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* val = ARG_src1;
-    JSValue* shift = ARG_src2;
+    JSValuePtr val = ARG_src1;
+    JSValuePtr shift = ARG_src2;
 
     int32_t left;
     uint32_t right;
     if (JSImmediate::areBothImmediateNumbers(val, shift))
-        return jsNumber(ARG_globalData, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f));
+        return JSValuePtr::encode(jsNumber(ARG_globalData, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f)));
     if (fastToInt32(val, left) && fastToUInt32(shift, right))
-        return jsNumber(ARG_globalData, left << (right & 0x1f));
+        return JSValuePtr::encode(jsNumber(ARG_globalData, left << (right & 0x1f)));
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(callFrame)) << (shift->toUInt32(callFrame) & 0x1f));
+    JSValuePtr result = jsNumber(ARG_globalData, (val->toInt32(callFrame)) << (shift->toUInt32(callFrame) & 0x1f));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_bitand(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_bitand(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     int32_t left;
     int32_t right;
     if (fastToInt32(src1, left) && fastToInt32(src2, right))
-        return jsNumber(ARG_globalData, left & right);
+        return JSValuePtr::encode(jsNumber(ARG_globalData, left & right));
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) & src2->toInt32(callFrame));
+    JSValuePtr result = jsNumber(ARG_globalData, src1->toInt32(callFrame) & src2->toInt32(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_rshift(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_rshift(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* val = ARG_src1;
-    JSValue* shift = ARG_src2;
+    JSValuePtr val = ARG_src1;
+    JSValuePtr shift = ARG_src2;
 
     int32_t left;
     uint32_t right;
     if (JSImmediate::areBothImmediateNumbers(val, shift))
-        return JSImmediate::rightShiftImmediateNumbers(val, shift);
+        return JSValuePtr::encode(JSImmediate::rightShiftImmediateNumbers(val, shift));
     if (fastToInt32(val, left) && fastToUInt32(shift, right))
-        return jsNumber(ARG_globalData, left >> (right & 0x1f));
+        return JSValuePtr::encode(jsNumber(ARG_globalData, left >> (right & 0x1f)));
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
+    JSValuePtr result = jsNumber(ARG_globalData, (val->toInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_bitnot(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_bitnot(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src = ARG_src1;
+    JSValuePtr src = ARG_src1;
 
     int value;
     if (fastToInt32(src, value))
-        return jsNumber(ARG_globalData, ~value);
-            
+        return JSValuePtr::encode(jsNumber(ARG_globalData, ~value));
+
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, ~src->toInt32(callFrame));
+    JSValuePtr result = jsNumber(ARG_globalData, ~src->toInt32(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 VoidPtrPair Interpreter::cti_op_resolve_with_base(STUB_ARGS)
@@ -5560,10 +5562,10 @@ VoidPtrPair Interpreter::cti_op_resolve_with_base(STUB_ARGS)
         base = *iter;
         PropertySlot slot(base);
         if (base->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSValuePtr result = slot.getValue(callFrame, ident);
             CHECK_FOR_EXCEPTION_AT_END();
 
-            RETURN_PAIR(base, asPointer(result));
+            RETURN_PAIR(base, JSValuePtr::encode(result));
         }
         ++iter;
     } while (iter != end);
@@ -5581,89 +5583,89 @@ JSObject* Interpreter::cti_op_new_func_exp(STUB_ARGS)
     return ARG_funcexp1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
-JSValue* Interpreter::cti_op_mod(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_mod(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* dividendValue = ARG_src1;
-    JSValue* divisorValue = ARG_src2;
+    JSValuePtr dividendValue = ARG_src1;
+    JSValuePtr divisorValue = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
     double d = dividendValue->toNumber(callFrame);
-    JSValue* result = jsNumber(ARG_globalData, fmod(d, divisorValue->toNumber(callFrame)));
+    JSValuePtr result = jsNumber(ARG_globalData, fmod(d, divisorValue->toNumber(callFrame)));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_less(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_less(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsBoolean(jsLess(callFrame, ARG_src1, ARG_src2));
+    JSValuePtr result = jsBoolean(jsLess(callFrame, ARG_src1, ARG_src2));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_neq(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_neq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     ASSERT(!JSImmediate::areBothImmediateNumbers(src1, src2));
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsBoolean(!equalSlowCaseInline(callFrame, src1, src2));
+    JSValuePtr result = jsBoolean(!equalSlowCaseInline(callFrame, src1, src2));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 VoidPtrPair Interpreter::cti_op_post_dec(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* v = ARG_src1;
+    JSValuePtr v = ARG_src1;
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* number = v->toJSNumber(callFrame);
+    JSValuePtr number = v->toJSNumber(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
 
-    RETURN_PAIR(asPointer(number), asPointer(jsNumber(ARG_globalData, number->uncheckedGetNumber() - 1)));
+    RETURN_PAIR(JSValuePtr::encode(number), JSValuePtr::encode(jsNumber(ARG_globalData, number->uncheckedGetNumber() - 1)));
 }
 
-JSValue* Interpreter::cti_op_urshift(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_urshift(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* val = ARG_src1;
-    JSValue* shift = ARG_src2;
+    JSValuePtr val = ARG_src1;
+    JSValuePtr shift = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
 
     if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
-        return JSImmediate::rightShiftImmediateNumbers(val, shift);
+        return JSValuePtr::encode(JSImmediate::rightShiftImmediateNumbers(val, shift));
     else {
-        JSValue* result = jsNumber(ARG_globalData, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
+        JSValuePtr result = jsNumber(ARG_globalData, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
         CHECK_FOR_EXCEPTION_AT_END();
-        return result;
+        return JSValuePtr::encode(result);
     }
 }
 
-JSValue* Interpreter::cti_op_bitxor(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_bitxor(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) ^ src2->toInt32(callFrame));
+    JSValuePtr result = jsNumber(ARG_globalData, src1->toInt32(callFrame) ^ src2->toInt32(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 JSObject* Interpreter::cti_op_new_regexp(STUB_ARGS)
@@ -5673,21 +5675,21 @@ JSObject* Interpreter::cti_op_new_regexp(STUB_ARGS)
     return new (ARG_globalData) RegExpObject(ARG_callFrame->lexicalGlobalObject()->regExpStructure(), ARG_regexp1);
 }
 
-JSValue* Interpreter::cti_op_bitor(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_bitor(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) | src2->toInt32(callFrame));
+    JSValuePtr result = jsNumber(ARG_globalData, src1->toInt32(callFrame) | src2->toInt32(callFrame));
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_call_eval(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_call_eval(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
@@ -5696,29 +5698,29 @@ JSValue* Interpreter::cti_op_call_eval(STUB_ARGS)
 
     Interpreter* interpreter = ARG_globalData->interpreter;
     
-    JSValue* funcVal = ARG_src1;
+    JSValuePtr funcVal = ARG_src1;
     int registerOffset = ARG_int2;
     int argCount = ARG_int3;
 
     Register* newCallFrame = callFrame->registers() + registerOffset;
     Register* argv = newCallFrame - RegisterFile::CallFrameHeaderSize - argCount;
-    JSValue* thisValue = argv[0].jsValue(callFrame);
+    JSValuePtr thisValue = argv[0].jsValue(callFrame);
     JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject();
 
     if (thisValue == globalObject && funcVal == globalObject->evalFunction()) {
-        JSValue* exceptionValue = noValue();
-        JSValue* result = interpreter->callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
+        JSValuePtr exceptionValue = noValue();
+        JSValuePtr result = interpreter->callEval(callFrame, registerFile, argv, argCount, registerOffset, exceptionValue);
         if (UNLIKELY(exceptionValue != noValue())) {
             ARG_globalData->exception = exceptionValue;
             VM_THROW_EXCEPTION_AT_END();
         }
-        return result;
+        return JSValuePtr::encode(result);
     }
 
-    return JSImmediate::impossibleValue();
+    return JSValuePtr::encode(JSImmediate::impossibleValue());
 }
 
-JSValue* Interpreter::cti_op_throw(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_throw(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
@@ -5727,21 +5729,21 @@ JSValue* Interpreter::cti_op_throw(STUB_ARGS)
 
     unsigned vPCIndex = codeBlock->getBytecodeIndex(STUB_RETURN_ADDRESS);
 
-    JSValue* exceptionValue = ARG_src1;
+    JSValuePtr exceptionValue = ARG_src1;
     ASSERT(exceptionValue);
 
     HandlerInfo* handler = ARG_globalData->interpreter->throwException(callFrame, exceptionValue, vPCIndex, true);
 
     if (!handler) {
         *ARG_exception = exceptionValue;
-        return JSImmediate::nullImmediate();
+        return JSValuePtr::encode(JSImmediate::nullImmediate());
     }
 
     ARG_setCallFrame(callFrame);
     void* catchRoutine = handler->nativeCode;
     ASSERT(catchRoutine);
     STUB_SET_RETURN_ADDRESS(catchRoutine);
-    return exceptionValue;
+    return JSValuePtr::encode(exceptionValue);
 }
 
 JSPropertyNameIterator* Interpreter::cti_op_get_pnames(STUB_ARGS)
@@ -5751,15 +5753,15 @@ JSPropertyNameIterator* Interpreter::cti_op_get_pnames(STUB_ARGS)
     return JSPropertyNameIterator::create(ARG_callFrame, ARG_src1);
 }
 
-JSValue* Interpreter::cti_op_next_pname(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_next_pname(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     JSPropertyNameIterator* it = ARG_pni1;
-    JSValue* temp = it->next(ARG_callFrame);
+    JSValuePtr temp = it->next(ARG_callFrame);
     if (!temp)
         it->invalidate();
-    return temp;
+    return JSValuePtr::encode(temp);
 }
 
 JSObject* Interpreter::cti_op_push_scope(STUB_ARGS)
@@ -5779,102 +5781,102 @@ void Interpreter::cti_op_pop_scope(STUB_ARGS)
     ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->pop());
 }
 
-JSValue* Interpreter::cti_op_typeof(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_typeof(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    return jsTypeStringForValue(ARG_callFrame, ARG_src1);
+    return JSValuePtr::encode(jsTypeStringForValue(ARG_callFrame, ARG_src1));
 }
 
-JSValue* Interpreter::cti_op_is_undefined(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_is_undefined(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* v = ARG_src1;
-    return jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structure()->typeInfo().masqueradesAsUndefined());
+    JSValuePtr v = ARG_src1;
+    return JSValuePtr::encode(jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structure()->typeInfo().masqueradesAsUndefined()));
 }
 
-JSValue* Interpreter::cti_op_is_boolean(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_is_boolean(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    return jsBoolean(ARG_src1->isBoolean());
+    return JSValuePtr::encode(jsBoolean(ARG_src1->isBoolean()));
 }
 
-JSValue* Interpreter::cti_op_is_number(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_is_number(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    return jsBoolean(ARG_src1->isNumber());
+    return JSValuePtr::encode(jsBoolean(ARG_src1->isNumber()));
 }
 
-JSValue* Interpreter::cti_op_is_string(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_is_string(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    return jsBoolean(ARG_globalData->interpreter->isJSString(ARG_src1));
+    return JSValuePtr::encode(jsBoolean(ARG_globalData->interpreter->isJSString(ARG_src1)));
 }
 
-JSValue* Interpreter::cti_op_is_object(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_is_object(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    return jsBoolean(jsIsObjectType(ARG_src1));
+    return JSValuePtr::encode(jsBoolean(jsIsObjectType(ARG_src1)));
 }
 
-JSValue* Interpreter::cti_op_is_function(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_is_function(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    return jsBoolean(jsIsFunctionType(ARG_src1));
+    return JSValuePtr::encode(jsBoolean(jsIsFunctionType(ARG_src1)));
 }
 
-JSValue* Interpreter::cti_op_stricteq(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_stricteq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     // handled inline as fast cases
     ASSERT(!JSImmediate::areBothImmediate(src1, src2));
     ASSERT(!(JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate())));
 
-    return jsBoolean(strictEqualSlowCaseInline(src1, src2));
+    return JSValuePtr::encode(jsBoolean(strictEqualSlowCaseInline(src1, src2)));
 }
 
-JSValue* Interpreter::cti_op_nstricteq(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_nstricteq(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src1 = ARG_src1;
-    JSValue* src2 = ARG_src2;
+    JSValuePtr src1 = ARG_src1;
+    JSValuePtr src2 = ARG_src2;
 
     // handled inline as fast cases
     ASSERT(!JSImmediate::areBothImmediate(src1, src2));
     ASSERT(!(JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate())));
     
-    return jsBoolean(!strictEqualSlowCaseInline(src1, src2));
+    return JSValuePtr::encode(jsBoolean(!strictEqualSlowCaseInline(src1, src2)));
 }
 
-JSValue* Interpreter::cti_op_to_jsnumber(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_to_jsnumber(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* src = ARG_src1;
+    JSValuePtr src = ARG_src1;
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* result = src->toJSNumber(callFrame);
+    JSValuePtr result = src->toJSNumber(callFrame);
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
-JSValue* Interpreter::cti_op_in(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_in(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
-    JSValue* baseVal = ARG_src2;
+    JSValuePtr baseVal = ARG_src2;
 
     if (!baseVal->isObject()) {
         CallFrame* callFrame = ARG_callFrame;
@@ -5884,16 +5886,16 @@ JSValue* Interpreter::cti_op_in(STUB_ARGS)
         VM_THROW_EXCEPTION();
     }
 
-    JSValue* propName = ARG_src1;
+    JSValuePtr propName = ARG_src1;
     JSObject* baseObj = asObject(baseVal);
 
     uint32_t i;
     if (propName->getUInt32(i))
-        return jsBoolean(baseObj->hasProperty(callFrame, i));
+        return JSValuePtr::encode(jsBoolean(baseObj->hasProperty(callFrame, i)));
 
     Identifier property(callFrame, propName->toString(callFrame));
     CHECK_FOR_EXCEPTION();
-    return jsBoolean(baseObj->hasProperty(callFrame, property));
+    return JSValuePtr::encode(jsBoolean(baseObj->hasProperty(callFrame, property)));
 }
 
 JSObject* Interpreter::cti_op_push_new_scope(STUB_ARGS)
@@ -5934,7 +5936,7 @@ void* Interpreter::cti_op_switch_imm(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* scrutinee = ARG_src1;
+    JSValuePtr scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
@@ -5951,7 +5953,7 @@ void* Interpreter::cti_op_switch_char(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* scrutinee = ARG_src1;
+    JSValuePtr scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
@@ -5971,7 +5973,7 @@ void* Interpreter::cti_op_switch_string(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
-    JSValue* scrutinee = ARG_src1;
+    JSValuePtr scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
@@ -5986,17 +5988,17 @@ void* Interpreter::cti_op_switch_string(STUB_ARGS)
     return result;
 }
 
-JSValue* Interpreter::cti_op_del_by_val(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_op_del_by_val(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
     CallFrame* callFrame = ARG_callFrame;
 
-    JSValue* baseValue = ARG_src1;
+    JSValuePtr baseValue = ARG_src1;
     JSObject* baseObj = baseValue->toObject(callFrame); // may throw
 
-    JSValue* subscript = ARG_src2;
-    JSValue* result;
+    JSValuePtr subscript = ARG_src2;
+    JSValuePtr result;
     uint32_t i;
     if (subscript->getUInt32(i))
         result = jsBoolean(baseObj->deleteProperty(callFrame, i));
@@ -6008,7 +6010,7 @@ JSValue* Interpreter::cti_op_del_by_val(STUB_ARGS)
     }
 
     CHECK_FOR_EXCEPTION_AT_END();
-    return result;
+    return JSValuePtr::encode(result);
 }
 
 void Interpreter::cti_op_put_getter(STUB_ARGS)
@@ -6042,7 +6044,7 @@ JSObject* Interpreter::cti_op_new_error(STUB_ARGS)
     CallFrame* callFrame = ARG_callFrame;
     CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned type = ARG_int1;
-    JSValue* message = ARG_src2;
+    JSValuePtr message = ARG_src2;
     unsigned lineNumber = ARG_int3;
 
     return Error::create(callFrame, static_cast<ErrorType>(type), message->toString(callFrame), lineNumber, codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->sourceURL());
@@ -6061,7 +6063,7 @@ void Interpreter::cti_op_debug(STUB_ARGS)
     ARG_globalData->interpreter->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
 }
 
-JSValue* Interpreter::cti_vm_throw(STUB_ARGS)
+JSValueEncodedAsPointer* Interpreter::cti_vm_throw(STUB_ARGS)
 {
     BEGIN_STUB_FUNCTION();
 
@@ -6071,7 +6073,7 @@ JSValue* Interpreter::cti_vm_throw(STUB_ARGS)
 
     unsigned vPCIndex = codeBlock->getBytecodeIndex(globalData->exceptionLocation);
 
-    JSValue* exceptionValue = globalData->exception;
+    JSValuePtr exceptionValue = globalData->exception;
     ASSERT(exceptionValue);
     globalData->exception = noValue();
 
@@ -6079,14 +6081,14 @@ JSValue* Interpreter::cti_vm_throw(STUB_ARGS)
 
     if (!handler) {
         *ARG_exception = exceptionValue;
-        return JSImmediate::nullImmediate();
+        return JSValuePtr::encode(JSImmediate::nullImmediate());
     }
 
     ARG_setCallFrame(callFrame);
     void* catchRoutine = handler->nativeCode;
     ASSERT(catchRoutine);
     STUB_SET_RETURN_ADDRESS(catchRoutine);
-    return exceptionValue;
+    return JSValuePtr::encode(exceptionValue);
 }
 
 #undef STUB_RETURN_ADDRESS
index a11f20b..26d6732 100644 (file)
@@ -140,13 +140,13 @@ namespace JSC {
 
         bool isOpcode(Opcode);
         
-        JSValue* execute(ProgramNode*, CallFrame*, ScopeChainNode*, JSObject* thisObj, JSValue** exception);
-        JSValue* execute(FunctionBodyNode*, CallFrame*, JSFunction*, JSObject* thisObj, const ArgList& args, ScopeChainNode*, JSValue** exception);
-        JSValue* execute(EvalNode* evalNode, CallFrame* exec, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception);
+        JSValuePtr execute(ProgramNode*, CallFrame*, ScopeChainNode*, JSObject* thisObj, JSValuePtr* exception);
+        JSValuePtr execute(FunctionBodyNode*, CallFrame*, JSFunction*, JSObject* thisObj, const ArgList& args, ScopeChainNode*, JSValuePtr* exception);
+        JSValuePtr execute(EvalNode* evalNode, CallFrame* exec, JSObject* thisObj, ScopeChainNode* scopeChain, JSValuePtr* exception);
 
-        JSValue* retrieveArguments(CallFrame*, JSFunction*) const;
-        JSValue* retrieveCaller(CallFrame*, InternalFunction*) const;
-        void retrieveLastCaller(CallFrame*, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const;
+        JSValuePtr retrieveArguments(CallFrame*, JSFunction*) const;
+        JSValuePtr retrieveCaller(CallFrame*, InternalFunction*) const;
+        void retrieveLastCaller(CallFrame*, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValuePtr& function) const;
         
         void getArgumentsData(CallFrame*, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);
         void setTimeoutTime(unsigned timeoutTime) { m_timeoutTime = timeoutTime; }
@@ -183,8 +183,8 @@ namespace JSC {
 
         static JSObject* JIT_STUB cti_op_convert_this(STUB_ARGS);
         static void JIT_STUB cti_op_end(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_add(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_pre_inc(STUB_ARGS);
+        static JSValueEncodedAsPointer* JIT_STUB cti_op_add(STUB_ARGS);
+        static JSValueEncodedAsPointer* JIT_STUB cti_op_pre_inc(STUB_ARGS);
         static int JIT_STUB cti_op_loop_if_less(STUB_ARGS);
         static int JIT_STUB cti_op_loop_if_lesseq(STUB_ARGS);
         static JSObject* JIT_STUB cti_op_new_object(STUB_ARGS);
@@ -192,22 +192,22 @@ namespace JSC {
         static void JIT_STUB cti_op_put_by_id_second(STUB_ARGS);
         static void JIT_STUB cti_op_put_by_id_generic(STUB_ARGS);
         static void JIT_STUB cti_op_put_by_id_fail(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_get_by_id(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_get_by_id_second(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_get_by_id_generic(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_get_by_id_self_fail(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_get_by_id_proto_list(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_get_by_id_proto_list_full(STUB_ARGS);
-        static JSValue* JIT_STUB cti_op_