Changeset 154797 in webkit for trunk/Source/JavaScriptCore/jit/JITStubs.cpp

Timestamp:

Aug 28, 2013, 5:28:42 PM (12 years ago)

Author:

[email protected]

Message:

Source/JavaScriptCore: ​https://bugs.webkit.org/show_bug.cgi?id=119548
Refactoring Exception throws.

Patch by Chris Curtis <​[email protected]> on 2013-08-28
Reviewed by Geoffrey Garen.

Gardening of exception throws. The act of throwing an exception was being handled in
different ways depending on whether the code was running in the LLint, Baseline JIT,
or the DFG Jit. This made development in the vm exception and error objects difficult.

• runtime/VM.cpp:

(JSC::appendSourceToError):
This function moved from the interpreter into the VM. It views the developers code
(if there is a codeBlock) to extract what was trying to be evaluated when the error
occurred.

(JSC::VM::throwException):
This function takes in the error object and sets the following:

1: The VM's exception stack
2: The VM's exception
3: Appends extra information on the error message(via appendSourceToError)
4: The error object's line number
5: The error object's column number
6: The error object's sourceURL
7: The error object's stack trace (unless it already exists because the developer

created the error object).

(JSC::VM::getExceptionInfo):
(JSC::VM::setExceptionInfo):
(JSC::VM::clearException):
(JSC::clearExceptionStack):

• runtime/VM.h:

(JSC::VM::exceptionOffset):
(JSC::VM::exception):
(JSC::VM::addressOfException):
(JSC::VM::exceptionStack):
VM exception and exceptionStack are now private data members.

• interpreter/Interpreter.h:

(JSC::ClearExceptionScope::ClearExceptionScope):
Created this structure to temporarily clear the exception within the VM. This
needed to see if addition errors occur when setting the debugger as we are
unwinding the stack.

• interpreter/Interpreter.cpp:

(JSC::Interpreter::unwind):
Removed the code that would try to add error information if it did not exist.
All of this functionality has moved into the VM and all error information is set
at the time the error occurs.

The rest of these functions reference the new calling convention to throw an error.

• API/APICallbackFunction.h:

(JSC::APICallbackFunction::call):

• API/JSCallbackConstructor.cpp:

(JSC::constructJSCallback):

• API/JSCallbackObjectFunctions.h:

(JSC::::getOwnPropertySlot):
(JSC::::defaultValue):
(JSC::::put):
(JSC::::putByIndex):
(JSC::::deleteProperty):
(JSC::::construct):
(JSC::::customHasInstance):
(JSC::::call):
(JSC::::getStaticValue):
(JSC::::staticFunctionGetter):
(JSC::::callbackGetter):

• debugger/Debugger.cpp:

(JSC::evaluateInGlobalCallFrame):

• debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::evaluate):

• dfg/DFGAssemblyHelpers.h:

(JSC::DFG::AssemblyHelpers::emitExceptionCheck):

• dfg/DFGOperations.cpp:

(JSC::DFG::operationPutByValInternal):

• ftl/FTLLowerDFGToLLVM.cpp:

(JSC::FTL::LowerDFGToLLVM::callCheck):

• heap/Heap.cpp:

(JSC::Heap::markRoots):

• interpreter/CallFrame.h:

(JSC::ExecState::clearException):
(JSC::ExecState::exception):
(JSC::ExecState::hadException):

• interpreter/Interpreter.cpp:

(JSC::eval):
(JSC::loadVarargs):
(JSC::stackTraceAsString):
(JSC::Interpreter::execute):
(JSC::Interpreter::executeCall):
(JSC::Interpreter::executeConstruct):
(JSC::Interpreter::prepareForRepeatCall):

• interpreter/Interpreter.h:

(JSC::ClearExceptionScope::ClearExceptionScope):

• jit/JITCode.cpp:

(JSC::JITCode::execute):

• jit/JITExceptions.cpp:

(JSC::genericThrow):

• jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_catch):

• jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_catch):

• jit/JITStubs.cpp:

(JSC::returnToThrowTrampoline):
(JSC::throwExceptionFromOpCall):
(JSC::DEFINE_STUB_FUNCTION):
(JSC::jitCompileFor):
(JSC::lazyLinkFor):
(JSC::putByVal):
(JSC::cti_vm_handle_exception):

• jit/SlowPathCall.h:

(JSC::JITSlowPathCall::call):

• jit/ThunkGenerators.cpp:

(JSC::nativeForGenerator):

• jsc.cpp:

(functionRun):
(functionLoad):
(functionCheckSyntax):

• llint/LLIntExceptions.cpp:

(JSC::LLInt::doThrow):
(JSC::LLInt::returnToThrow):
(JSC::LLInt::callToThrow):

• llint/LLIntSlowPaths.cpp:

(JSC::LLInt::LLINT_SLOW_PATH_DECL):

• llint/LowLevelInterpreter.cpp:

(JSC::CLoop::execute):

• llint/LowLevelInterpreter32_64.asm:
• llint/LowLevelInterpreter64.asm:
• runtime/ArrayConstructor.cpp:

(JSC::constructArrayWithSizeQuirk):

• runtime/CommonSlowPaths.cpp:

(JSC::SLOW_PATH_DECL):

• runtime/CommonSlowPaths.h:

(JSC::CommonSlowPaths::opIn):

• runtime/CommonSlowPathsExceptions.cpp:

(JSC::CommonSlowPaths::interpreterThrowInCaller):

• runtime/Completion.cpp:

(JSC::evaluate):

• runtime/Error.cpp:

(JSC::addErrorInfo):
(JSC::throwTypeError):
(JSC::throwSyntaxError):

• runtime/Error.h:

(JSC::throwVMError):

• runtime/ExceptionHelpers.cpp:

(JSC::throwOutOfMemoryError):
(JSC::throwStackOverflowError):
(JSC::throwTerminatedExecutionException):

• runtime/Executable.cpp:

(JSC::EvalExecutable::create):
(JSC::FunctionExecutable::produceCodeBlockFor):

• runtime/FunctionConstructor.cpp:

(JSC::constructFunction):
(JSC::constructFunctionSkippingEvalEnabledCheck):

• runtime/JSArray.cpp:

(JSC::JSArray::defineOwnProperty):
(JSC::JSArray::put):
(JSC::JSArray::push):

• runtime/JSCJSValue.cpp:

(JSC::JSValue::toObjectSlowCase):
(JSC::JSValue::synthesizePrototype):
(JSC::JSValue::putToPrimitive):

• runtime/JSFunction.cpp:

(JSC::JSFunction::defineOwnProperty):

• runtime/JSGenericTypedArrayViewInlines.h:

(JSC::::create):
(JSC::::createUninitialized):
(JSC::::validateRange):
(JSC::::setWithSpecificType):

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::encode):
(JSC::decode):
(JSC::globalFuncProtoSetter):

• runtime/JSNameScope.cpp:

(JSC::JSNameScope::put):

• runtime/JSONObject.cpp:

(JSC::Stringifier::appendStringifiedValue):
(JSC::Walker::walk):

• runtime/JSObject.cpp:

(JSC::JSObject::put):
(JSC::JSObject::defaultValue):
(JSC::JSObject::hasInstance):
(JSC::JSObject::defaultHasInstance):
(JSC::JSObject::defineOwnNonIndexProperty):
(JSC::throwTypeError):

• runtime/ObjectConstructor.cpp:

(JSC::toPropertyDescriptor):

• runtime/RegExpConstructor.cpp:

(JSC::constructRegExp):

• runtime/StringObject.cpp:

(JSC::StringObject::defineOwnProperty):

• runtime/StringRecursionChecker.cpp:

(JSC::StringRecursionChecker::throwStackOverflowError):

Source/WebCore: ​https://bugs.webkit.org/show_bug.cgi?id=119548
Refactoring Exception throws.

Patch by Chris Curtis <​[email protected]> on 2013-08-28
Reviewed by Geoffrey Garen.

Gets column information from the error object for reporting exceptions.

• bindings/js/JSDOMBinding.cpp:

(WebCore::reportException):

• bindings/js/ScriptCallStackFactory.cpp:

(WebCore::createScriptCallStackFromException):

Moved setting an exception into the vm, These functions changed to use the new functionality.

• bindings/js/JSAudioBufferSourceNodeCustom.cpp:

(WebCore::JSAudioBufferSourceNode::setBuffer):

• bindings/js/JSBiquadFilterNodeCustom.cpp:

(WebCore::JSBiquadFilterNode::setType):

• bindings/js/JSCryptoCustom.cpp:

(WebCore::JSCrypto::getRandomValues):

• bindings/js/JSDOMBinding.cpp:

(WebCore::setDOMException):

• bindings/js/JSInjectedScriptHostCustom.cpp:

(WebCore::JSInjectedScriptHost::setFunctionVariableValue):

• bindings/js/JSJavaScriptCallFrameCustom.cpp:

(WebCore::JSJavaScriptCallFrame::evaluate):
(WebCore::JSJavaScriptCallFrame::setVariableValue):

• bindings/js/JSNodeFilterCondition.cpp:

(WebCore::JSNodeFilterCondition::acceptNode):

• bindings/js/JSOscillatorNodeCustom.cpp:

(WebCore::JSOscillatorNode::setType):

• bindings/js/JSPannerNodeCustom.cpp:

(WebCore::JSPannerNode::setPanningModel):
(WebCore::JSPannerNode::setDistanceModel):

• bindings/js/JSSVGLengthCustom.cpp:

(WebCore::JSSVGLength::convertToSpecifiedUnits):

• bindings/js/JSWebGLRenderingContextCustom.cpp:

(WebCore::getObjectParameter):
(WebCore::JSWebGLRenderingContext::getAttachedShaders):
(WebCore::JSWebGLRenderingContext::getExtension):
(WebCore::JSWebGLRenderingContext::getFramebufferAttachmentParameter):
(WebCore::JSWebGLRenderingContext::getParameter):
(WebCore::JSWebGLRenderingContext::getProgramParameter):
(WebCore::JSWebGLRenderingContext::getShaderParameter):
(WebCore::JSWebGLRenderingContext::getUniform):
(WebCore::dataFunctionf):
(WebCore::dataFunctioni):
(WebCore::dataFunctionMatrix):

• bindings/js/JSXMLHttpRequestCustom.cpp:

(WebCore::JSXMLHttpRequest::open):

• bindings/js/SerializedScriptValue.cpp:

(WebCore::CloneBase::throwStackOverflow):
(WebCore::CloneDeserializer::throwValidationError):
(WebCore::SerializedScriptValue::maybeThrowExceptionIfSerializationFailed):

• bindings/js/WorkerScriptController.cpp:

(WebCore::WorkerScriptController::evaluate):
(WebCore::WorkerScriptController::setException):

• bridge/c/c_instance.cpp:

(JSC::Bindings::CInstance::moveGlobalExceptionToExecState):
(JSC::Bindings::CInstance::invokeMethod):
(JSC::Bindings::CInstance::invokeDefaultMethod):
(JSC::Bindings::CInstance::invokeConstruct):
(JSC::Bindings::CInstance::toJSPrimitive):

• bridge/objc/objc_instance.mm:

(ObjcInstance::invokeMethod):

• bridge/objc/objc_runtime.mm:

(JSC::Bindings::ObjcArray::setValueAt):
(JSC::Bindings::ObjcArray::valueAt):

• bridge/objc/objc_utility.mm:

(JSC::Bindings::throwError):

• bridge/qt/qt_instance.cpp:

(JSC::Bindings::QtField::valueFromInstance):
(JSC::Bindings::QtField::setValueToInstance):

• bridge/runtime_array.cpp:

(JSC::RuntimeArray::put):
(JSC::RuntimeArray::putByIndex):

• bridge/runtime_object.cpp:

(JSC::Bindings::RuntimeObject::throwInvalidAccessError):

Source/WebKit/mac: ​https://bugs.webkit.org/show_bug.cgi?id=119548
Refactoring Exception throws.

Patch by Chris Curtis <​[email protected]> on 2013-08-28
Reviewed by Geoffrey Garen.

Moved setting an exception into the vm, These functions changed to use the new functionality.

• Plugins/Hosted/NetscapePluginInstanceProxy.mm:

(WebKit::NetscapePluginInstanceProxy::moveGlobalExceptionToExecState):

• Plugins/Hosted/ProxyInstance.mm:

(WebKit::ProxyInstance::invokeMethod):

Source/WebKit2: ​https://bugs.webkit.org/show_bug.cgi?id=119548
Refactoring Exception throws.

Patch by Chris Curtis <​[email protected]> on 2013-08-28
Reviewed by Geoffrey Garen.

Moved setting an exception into the vm, These functions changed to use the new functionality.

• WebProcess/Plugins/Netscape/JSNPObject.cpp:

(WebKit::JSNPObject::callMethod):
(WebKit::JSNPObject::callObject):
(WebKit::JSNPObject::callConstructor):
(WebKit::JSNPObject::throwInvalidAccessError):

• WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp:

(WebKit::NPRuntimeObjectMap::moveGlobalExceptionToExecState):

LayoutTests: ​https://bugs.webkit.org/show_bug.cgi?id=119548
Refactoring Exception throws.

Patch by Chris Curtis <​[email protected]> on 2013-08-28
Reviewed by Geoffrey Garen.

Column/line information was added into these results.

• fast/events/window-onerror4-expected.txt:
• fast/js/global-recursion-on-full-stack-expected.txt:

fixed a variable name in a case when shouldThrowType failed.

• fast/js/mozilla/resources/js-test-pre.js:

(shouldThrowType):

Sorted the properties to allow the results always show in the same order.

• fast/js/script-tests/exception-properties.js:
• fast/js/exception-properties-expected.txt:

This test needed to be modified to have the line numbers match on the output across
wk and wk2. This test is inherently flaky because is relies on size of the available
native stack. To account for the flakiness an additional call was made to force the
results to match.
This patch now records and outputs the line number where the errors were occurring.
This was causing the test results to no longer match because of the line numbers.
By changing how to account for the flakiness, the results match again.

• fast/xmlhttprequest/xmlhttprequest-recursive-sync-event-expected.txt:
• fast/xmlhttprequest/xmlhttprequest-recursive-sync-event.html:

File:

• trunk/Source/JavaScriptCore/jit/JITStubs.cpp (modified) (28 diffs)

trunk/Source/JavaScriptCore/jit/JITStubs.cpp

@@ -45 +45 @@
 #include "Debugger.h"
 #include "DeferGC.h"
+#include "ErrorInstance.h"
 #include "ExceptionHelpers.h"
 #include "GetterSetter.h"
@@ -325 +326 @@
 static NEVER_INLINE void returnToThrowTrampoline(VM* vm, ReturnAddressPtr exceptionLocation, ReturnAddressPtr& returnAddressSlot)
 {
-    RELEASE_ASSERT(vm->exception);
+    RELEASE_ASSERT(vm->exception());
     vm->exceptionLocation = exceptionLocation;
     returnAddressSlot = ReturnAddressPtr(FunctionPtr(ctiVMThrowTrampoline));
@@ -342 +343 @@
 #define CHECK_FOR_EXCEPTION() \
     do { \
-        if (UNLIKELY(stackFrame.vm->exception)) \
+        if (UNLIKELY(stackFrame.vm->exception())) \
             VM_THROW_EXCEPTION(); \
     } while (0)
 #define CHECK_FOR_EXCEPTION_AT_END() \
     do { \
-        if (UNLIKELY(stackFrame.vm->exception)) \
+        if (UNLIKELY(stackFrame.vm->exception())) \
             VM_THROW_EXCEPTION_AT_END(); \
     } while (0)
 #define CHECK_FOR_EXCEPTION_VOID() \
     do { \
-        if (UNLIKELY(stackFrame.vm->exception)) { \
+        if (UNLIKELY(stackFrame.vm->exception())) { \
             VM_THROW_EXCEPTION_AT_END(); \
             return; \
@@ -398 +399 @@
 };
 
-class ErrorWithExceptionFunctor : public ErrorFunctor {
-    public:
-    ErrorWithExceptionFunctor(JSValue exception)
-        : m_exception(exception)
-    {
-    }
-    JSValue operator()(ExecState*)
-    {
-    return m_exception;
-    }
-
-private:
-    JSValue m_exception;
-};
-
 // Helper function for JIT stubs that may throw an exception in the middle of
 // processing a function call. This function rolls back the stack to
 // our caller, so exception processing can proceed from a valid state.
-template<typename T> static T throwExceptionFromOpCall(JITStackFrame& jitStackFrame, CallFrame* newCallFrame, ReturnAddressPtr& returnAddressSlot, ErrorFunctor& createError )
+template<typename T> static T throwExceptionFromOpCall(JITStackFrame& jitStackFrame, CallFrame* newCallFrame, ReturnAddressPtr& returnAddressSlot, ErrorFunctor* createError = 0)
 {
     CallFrame* callFrame = newCallFrame->callerFrame()->removeHostCallFrameFlag();
     jitStackFrame.callFrame = callFrame;
     callFrame->vm().topCallFrame = callFrame;
-    callFrame->vm().exception = createError(callFrame);
-    ASSERT(callFrame->vm().exception);
+    if (createError)
+        callFrame->vm().throwException(callFrame, (*createError)(callFrame));
+    ASSERT(callFrame->vm().exception());
     returnToThrowTrampoline(&callFrame->vm(), ReturnAddressPtr(newCallFrame->returnPC()), returnAddressSlot);
     return T();
-}
-
-template<typename T> static T throwExceptionFromOpCall(JITStackFrame& jitStackFrame, CallFrame* newCallFrame, ReturnAddressPtr& returnAddressSlot)
-{
-    CallFrame* callFrame = newCallFrame->callerFrame();
-    ASSERT(callFrame->vm().exception);
-    ErrorWithExceptionFunctor functor = ErrorWithExceptionFunctor(callFrame->vm().exception);
-    return throwExceptionFromOpCall<T>(jitStackFrame, newCallFrame, returnAddressSlot, functor);
 }
 
@@ -446 +425 @@
     VM* vm = stackFrame.vm;
     if (UNLIKELY(vm->watchdog.didFire(callFrame))) {
-        vm->exception = createTerminatedExecutionException(vm);
+        vm->throwException(callFrame, createTerminatedExecutionException(vm));
         VM_THROW_EXCEPTION_AT_END();
         return;
@@ -459 +438 @@
     if (UNLIKELY(!stackFrame.stack->grow(&callFrame->registers()[callFrame->codeBlock()->m_numCalleeRegisters]))) {
         ErrorWithExecFunctor functor = ErrorWithExecFunctor(createStackOverflowError);
-        return throwExceptionFromOpCall<void*>(stackFrame, callFrame, STUB_RETURN_ADDRESS, functor);
+        return throwExceptionFromOpCall<void*>(stackFrame, callFrame, STUB_RETURN_ADDRESS, &functor);
     }
 
@@ -895 +874 @@
     }
 
-    stackFrame.vm->exception = createInvalidParameterError(callFrame, "instanceof", baseVal);
+    stackFrame.vm->throwException(callFrame, createInvalidParameterError(callFrame, "instanceof", baseVal));
     VM_THROW_EXCEPTION_AT_END();
     return JSValue::encode(JSValue());
@@ -1153 +1132 @@
     JSValue result = jsBoolean(couldDelete);
     if (!couldDelete && callFrame->codeBlock()->isStrictMode())
-        stackFrame.vm->exception = createTypeError(stackFrame.callFrame, "Unable to delete property.");
+        stackFrame.vm->throwException(stackFrame.callFrame, createTypeError(stackFrame.callFrame, "Unable to delete property."));
 
     CHECK_FOR_EXCEPTION_AT_END();
@@ -1193 +1172 @@
     if (!error)
         return function;
-    callFrame->vm().exception = error;
+    callFrame->vm().throwException(callFrame, error);
     return 0;
 }
@@ -1240 +1219 @@
     if (missingArgCount < 0) {
         ErrorWithExecFunctor functor = ErrorWithExecFunctor(createStackOverflowError);
-        return throwExceptionFromOpCall<int>(stackFrame, callFrame, STUB_RETURN_ADDRESS, functor);
+        return throwExceptionFromOpCall<int>(stackFrame, callFrame, STUB_RETURN_ADDRESS, &functor);
     }
     return missingArgCount;
@@ -1254 +1233 @@
     if (missingArgCount < 0) {
         ErrorWithExecFunctor functor = ErrorWithExecFunctor(createStackOverflowError);
-        return throwExceptionFromOpCall<int>(stackFrame, callFrame, STUB_RETURN_ADDRESS, functor);
+        return throwExceptionFromOpCall<int>(stackFrame, callFrame, STUB_RETURN_ADDRESS, &functor);
     }
     return missingArgCount;
@@ -1290 +1269 @@
         FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
         if (JSObject* error = functionExecutable->compileFor(callFrame, callee->scope(), kind)) {
-            callFrame->vm().exception = error;
+            callFrame->vm().throwException(callFrame, error);
             return 0;
         }
@@ -1368 +1347 @@
         JSObject* error = functionExecutable->compileFor(callFrame, scopeChain, CodeForCall);
         if (error) {
-            callFrame->vm().exception = error;
+            callFrame->vm().throwException(callFrame, error);
             return 0;
         }
@@ -1422 +1401 @@
         ASSERT(callType == CallTypeNone);
         ErrorWithExecAndCalleeFunctor functor = ErrorWithExecAndCalleeFunctor(createNotAFunctionError, callee);
-        return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS, functor);
+        return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS, &functor);
     }
 
@@ -1431 +1410 @@
     }
 
-    if (stackFrame.vm->exception)
+    if (stackFrame.vm->exception())
         return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS);
 
@@ -1518 +1497 @@
         ASSERT(constructType == ConstructTypeNone);
         ErrorWithExecAndCalleeFunctor functor = ErrorWithExecAndCalleeFunctor(createNotAConstructorError, callee);
-        return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS, functor);
+        return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS, &functor);
     }
 
@@ -1527 +1506 @@
     }
 
-    if (stackFrame.vm->exception)
+    if (stackFrame.vm->exception())
         return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS);
 
@@ -1667 +1646 @@
     } else {
         Identifier property(callFrame, subscript.toString(callFrame)->value(callFrame));
-        if (!callFrame->vm().exception) { // Don't put to an object if toString threw an exception.
+        if (!callFrame->vm().exception()) { // Don't put to an object if toString threw an exception.
             PutPropertySlot slot(callFrame->codeBlock()->isStrictMode());
             baseValue.put(callFrame, property, value, slot);
@@ -1953 +1932 @@
     RegExp* regExp = stackFrame.args[0].regExp();
     if (!regExp->isValid()) {
-        stackFrame.vm->exception = createSyntaxError(callFrame, "Invalid flags supplied to RegExp constructor.");
+        stackFrame.vm->throwException(callFrame, createSyntaxError(callFrame, "Invalid flags supplied to RegExp constructor."));
         VM_THROW_EXCEPTION();
     }
@@ -1978 +1957 @@
 
     JSValue result = eval(callFrame);
-    if (stackFrame.vm->exception)
+    if (stackFrame.vm->exception())
         return throwExceptionFromOpCall<EncodedJSValue>(stackFrame, callFrame, STUB_RETURN_ADDRESS);
 
@@ -1987 +1966 @@
 {
     STUB_INIT_STACK_FRAME(stackFrame);
+    stackFrame.vm->throwException(stackFrame.callFrame, stackFrame.args[0].jsValue()); 
     ExceptionHandler handler = jitThrow(stackFrame.vm, stackFrame.callFrame, stackFrame.args[0].jsValue(), STUB_RETURN_ADDRESS);
     STUB_SET_RETURN_ADDRESS(handler.catchRoutine);
@@ -2142 +2122 @@
     String message = errorDescriptionForValue(callFrame, stackFrame.args[0].jsValue())->value(callFrame);
     if (stackFrame.args[1].asInt32)
-        stackFrame.vm->exception = createReferenceError(callFrame, message);
+        stackFrame.vm->throwException(callFrame, createReferenceError(callFrame, message));
     else
-        stackFrame.vm->exception = createTypeError(callFrame, message);
+        stackFrame.vm->throwException(callFrame, createTypeError(callFrame, message));
     VM_THROW_EXCEPTION_AT_END();
 }
@@ -2166 +2146 @@
     STUB_INIT_STACK_FRAME(stackFrame);
     VM* vm = stackFrame.vm;
-    ExceptionHandler handler = jitThrow(vm, stackFrame.callFrame, vm->exception, vm->exceptionLocation);
+    ExceptionHandler handler = jitThrow(vm, stackFrame.callFrame, vm->exception(), vm->exceptionLocation);
     STUB_SET_RETURN_ADDRESS(handler.catchRoutine);
     return handler.callFrame;
@@ -2182 +2162 @@
     VM* vm = callFrame->codeBlock()->vm();
     vm->topCallFrame = callFrame;
-    return encode(jitThrowNew(vm, callFrame, vm->exception));
+    return encode(jitThrowNew(vm, callFrame, vm->exception()));
 }
 #else
@@ -2195 +2175 @@
     VM* vm = callFrame->codeBlock()->vm();
     vm->topCallFrame = callFrame;
-    return jitThrowNew(vm, callFrame, vm->exception);
+    return jitThrowNew(vm, callFrame, vm->exception());
 }
 #endif
@@ -2230 +2210 @@
     if (!scope->getPropertySlot(exec, ident, slot)) {
         if (modeAndType.mode() == ThrowIfNotFound) {
-            throwError(exec, createUndefinedVariableError(exec, ident));
+            exec->vm().throwException(exec, createUndefinedVariableError(exec, ident));
             VM_THROW_EXCEPTION();
         }
@@ -2262 +2242 @@
 
     if (modeAndType.mode() == ThrowIfNotFound && !scope->hasProperty(exec, ident)) {
-        throwError(exec, createUndefinedVariableError(exec, ident));
+        exec->vm().throwException(exec, createUndefinedVariableError(exec, ident));
         VM_THROW_EXCEPTION_AT_END();
         return;
@@ -2270 +2250 @@
     scope->methodTable()->put(scope, exec, ident, value, slot);
     
-    if (exec->vm().exception) {
+    if (exec->vm().exception()) {
         VM_THROW_EXCEPTION_AT_END();
         return;