Changeset 185259 in webkit

Timestamp:

Jun 5, 2015, 11:52:12 AM (10 years ago)

Author:

mark.lam@apple.com

Message:

finally blocks should not set the exception stack trace when re-throwing the exception.
​https://bugs.webkit.org/show_bug.cgi?id=145525

Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

How exceptions presently work:
=============================

1. op_throw can throw any JSValue.
2. the VM tries to capture the stack at the throw point and propagate that as needed.
3. finally blocks are implemented using op_catch to catch the thrown value, and throws it again using op_throw.

What's wrong with how it presently works:
========================================

1. finally's makes for bad exception throw line numbers in the Inspector console.

The op_throw in finally will throw the value anew i.e. it captures a stack from the re-throw point.
As a result, the Inspector sees the finally block as the throw point. The original stack is lost.

2. finally's breaks the Inspector's "Breaks on Uncaught Exception"

This is because finally blocks are indistinguishable from catch blocks. As a result, a try-finally,
which should break in the Inspector on the throw, does not because the Inspector thought the
exception was "caught".

3. finally's yields confusing break points when the Inspector "Breaks on All Exceptions"

1. In a try-finally scenario, the Inspector breaks 2 times: 1 at the throw, 1 at the finally.
2. In a for-of loop (which has synthesized finallys), the Inspector will do another break. Similarly for other cases of JS code which synthesize finallys.
3. At VM re-entry boundaries (e.g. js throws & returns to native code, which returns to js), the Inspector will do another break if there's an uncaught exception.

How this patch fixes the issues:
===============================

1. We introduce an Exception object that wraps the thrown value and the exception stack.

When throwing an exception, the VM will check if the thrown value is an Exception
object or not. If it is not an Exception object, then we must be throwing a new
exception. The VM will create an Exception object to wrap the thrown value and
capture the current stack for it.

If the thrown value is already an Exception object, then the requested throw operation
must be a re-throw. The VM will not capture a new stack for it.

2. op_catch will now populate 2 locals: 1 for the Exception, 1 for the thrown JSValue.

The VM is aware of the Exception object and uses it for rethrows in finally blocks.
JS source code is never aware of the Exception object.

JS code is aware of the thrown value. If it throws the caught thrown value, that
constitutes a new throw, and a new Exception object will be created for it.

3. The VM no longer tracks the thrown JSValue and the exception stack. It will only track a m_exception field which is an Exception*.

4. The BytecodeGenerator has already been updated in a prior patch to distinguish between Catch, Finally, and SynthesizedFinally blocks. The interpreter runtime will now report to the debugger whether we have a Catch handler, not just any handlers.

The debugger will use this detail to determine whether to break or not. "Break on
uncaught exceptions" will only break if no Catch handler was found.

This solves the issue of the debugger breaking at finally blocks, and for-of statements.

5. The Exception object will also have a flag to indicate whether the debugger has been notified of the Exception being thrown. Once the Interpreter notifies the debugger of the Exception object, it will mark this flag and not repeat the notify the debugger again of the same Exception.

This solves the issue of the debugger breaking at VM re-entry points due to uncaught
exceptions.

6. The life-cycle of the captured exception stack trace will now follow the life-cycle of the Exception object.

Other changes:

7. Change all clients of the VM::exception() to expect an Exception* instead of JSValue.

8. Fixed a few bugs where thrown exceptions are not cleared before exiting the VM.

9. Also renamed some variables and classes to better describe what they are.

• API/JSBase.cpp:

(JSEvaluateScript):
(JSCheckScriptSyntax):

• API/JSObjectRef.cpp:

(handleExceptionIfNeeded):

• The functions below all do the same exception check. Added this helper to simplify the code.

(JSClassCreate):
(JSObjectMakeFunction):
(JSObjectMakeArray):
(JSObjectMakeDate):
(JSObjectMakeError):
(JSObjectMakeRegExp):
(JSObjectGetProperty):
(JSObjectSetProperty):
(JSObjectGetPropertyAtIndex):
(JSObjectSetPropertyAtIndex):
(JSObjectDeleteProperty):
(JSObjectCallAsFunction):
(JSObjectCallAsConstructor):

• API/JSScriptRef.cpp:
• API/JSValue.mm:

(JSContainerConvertor::take):
(reportExceptionToInspector):

• API/JSValueRef.cpp:

(handleExceptionIfNeeded):

• The functions below all do the same exception check. Added this helper to simplify the code.

(evernoteHackNeeded):
(JSValueIsEqual):
(JSValueIsInstanceOfConstructor):
(JSValueCreateJSONString):
(JSValueToNumber):
(JSValueToStringCopy):
(JSValueToObject):

• CMakeLists.txt:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Added new files Exception.h and Exception.cpp.

• bindings/ScriptFunctionCall.cpp:

(Deprecated::ScriptFunctionCall::call):

• bindings/ScriptFunctionCall.h:

• bytecode/BytecodeList.json:
• op_catch now had 2 operands: the exception register, and the thrown value register.

• bytecode/BytecodeUseDef.h:

(JSC::computeDefsForBytecodeOffset):

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::dumpBytecode):
(JSC::CodeBlock::handlerForBytecodeOffset):

• bytecode/CodeBlock.h:
• handlerForBytecodeOffset() now can look for just Catch handlers only.

• bytecode/HandlerInfo.h:
• Cleaned up some white space I accidentally added in a previous patch.

• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::pushTry):
(JSC::BytecodeGenerator::popTryAndEmitCatch):
(JSC::BytecodeGenerator::emitThrowReferenceError):
(JSC::BytecodeGenerator::emitEnumeration):

• bytecompiler/BytecodeGenerator.h:

(JSC::BytecodeGenerator::emitThrow):

• bytecompiler/NodesCodegen.cpp:

(JSC::TryNode::emitBytecode):

• Adding support for op_catch's 2 operands.

• debugger/Debugger.cpp:

(JSC::Debugger::hasBreakpoint):
(JSC::Debugger::pauseIfNeeded):
(JSC::Debugger::exception):

• debugger/Debugger.h:
• debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::thisValue):
(JSC::DebuggerCallFrame::evaluate):

• debugger/DebuggerCallFrame.h:

(JSC::DebuggerCallFrame::isValid):

• inspector/InjectedScriptManager.cpp:

(Inspector::InjectedScriptManager::createInjectedScript):

• inspector/InspectorEnvironment.h:
• inspector/JSGlobalObjectInspectorController.cpp:

(Inspector::JSGlobalObjectInspectorController::appendAPIBacktrace):
(Inspector::JSGlobalObjectInspectorController::reportAPIException):

• inspector/JSGlobalObjectInspectorController.h:
• inspector/JSGlobalObjectScriptDebugServer.h:
• inspector/JSJavaScriptCallFrame.cpp:

(Inspector::JSJavaScriptCallFrame::evaluate):

• inspector/JavaScriptCallFrame.h:

(Inspector::JavaScriptCallFrame::vmEntryGlobalObject):
(Inspector::JavaScriptCallFrame::thisValue):
(Inspector::JavaScriptCallFrame::evaluate):

• inspector/ScriptCallStackFactory.cpp:

(Inspector::extractSourceInformationFromException):
(Inspector::createScriptCallStackFromException):

• inspector/ScriptCallStackFactory.h:
• inspector/ScriptDebugServer.cpp:

(Inspector::ScriptDebugServer::evaluateBreakpointAction):
(Inspector::ScriptDebugServer::handleBreakpointHit):
(Inspector::ScriptDebugServer::handleExceptionInBreakpointCondition):

• inspector/ScriptDebugServer.h:
• interpreter/CallFrame.h:

(JSC::ExecState::clearException):
(JSC::ExecState::exception):
(JSC::ExecState::hadException):
(JSC::ExecState::atomicStringTable):
(JSC::ExecState::propertyNames):
(JSC::ExecState::clearSupplementaryExceptionInfo): Deleted.

• interpreter/Interpreter.cpp:

(JSC::unwindCallFrame):
(JSC::Interpreter::stackTraceAsString):
(JSC::GetCatchHandlerFunctor::GetCatchHandlerFunctor):
(JSC::GetCatchHandlerFunctor::operator()):
(JSC::Interpreter::unwind):

• Added a check for didNotifyInspectorOfThrow() here to prevent duplicate reports of the same Exception to the debugger.

(JSC::GetExceptionHandlerFunctor::GetExceptionHandlerFunctor): Deleted.
(JSC::GetExceptionHandlerFunctor::operator()): Deleted.

• Renamed GetExceptionHandlerFunctor to GetCatchHandlerFunctor since the debugger is only interested in knowing whether we have Catch handlers.

• interpreter/Interpreter.h:

(JSC::SuspendExceptionScope::SuspendExceptionScope):
(JSC::SuspendExceptionScope::~SuspendExceptionScope):
(JSC::Interpreter::sampler):
(JSC::ClearExceptionScope::ClearExceptionScope): Deleted.
(JSC::ClearExceptionScope::~ClearExceptionScope): Deleted.

• Renamed ClearExceptionScope to SuspendExceptionScope because "clear" implies that we're purging the exception. Instead, we're merely suspending any handling of that exception for a period defined by the scope.

• jit/AssemblyHelpers.cpp:

(JSC::AssemblyHelpers::emitExceptionCheck):

• jit/JITExceptions.cpp:

(JSC::genericUnwind):

• Removed the exception argument. It is always the value in VM::exception() anyway. genericUnwind() can just get it from the VM, and save everyone some work.

• jit/JITExceptions.h:
• jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_catch):

• jit/JITOpcodes32_64.cpp:

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

• Add support for the new op_catch operands.

• jit/JITOperations.cpp:
• jit/ThunkGenerators.cpp:

(JSC::nativeForGenerator):

• jsc.cpp:

(functionRun):
(functionLoad):
(runWithScripts):
(runInteractive):

• llint/LLIntOffsetsExtractor.cpp:
• llint/LLIntSlowPaths.cpp:

(JSC::LLInt::LLINT_SLOW_PATH_DECL):

• llint/LowLevelInterpreter32_64.asm:
• llint/LowLevelInterpreter64.asm:
• Add support for the new op_catch operands. Also update the code to handle VM::m_exception being an Exception pointer, not a JSValue.

• parser/NodeConstructors.h:

(JSC::TryNode::TryNode):

• parser/Nodes.h:
• runtime/CallData.cpp:

(JSC::call):

• runtime/CallData.h:

• runtime/Completion.cpp:

(JSC::evaluate):

• runtime/Completion.h:

(JSC::evaluate):

• Change evaluate() to take a reference to the returned exception value instead of a pointer. In all but 2 or 3 cases, we want the returned exception anyway. Might as well simplify the code by requiring the reference.

• runtime/Error.h:

(JSC::throwVMError):
(JSC::throwVMTypeError):

• runtime/Exception.cpp: Added.

(JSC::Exception::create):
(JSC::Exception::destroy):
(JSC::Exception::createStructure):
(JSC::Exception::visitChildren):
(JSC::Exception::Exception):
(JSC::Exception::~Exception):

• runtime/Exception.h: Added.

(JSC::Exception::valueOffset):
(JSC::Exception::cast):
(JSC::Exception::value):
(JSC::Exception::stack):
(JSC::Exception::didNotifyInspectorOfThrow):
(JSC::Exception::setDidNotifyInspectorOfThrow):

• runtime/ExceptionHelpers.cpp:

(JSC::createTerminatedExecutionException):
(JSC::isTerminatedExecutionException):
(JSC::createStackOverflowError):

• runtime/ExceptionHelpers.h:
• runtime/GetterSetter.cpp:

(JSC::callGetter):

• runtime/IteratorOperations.cpp:

(JSC::iteratorClose):

• runtime/JSObject.cpp:
• runtime/JSPromiseConstructor.cpp:

(JSC::constructPromise):

• runtime/JSPromiseDeferred.cpp:

(JSC::updateDeferredFromPotentialThenable):
(JSC::abruptRejection):

• runtime/JSPromiseReaction.cpp:

(JSC::ExecutePromiseReactionMicrotask::run):

• runtime/VM.cpp:

(JSC::VM::VM):
(JSC::VM::releaseExecutableMemory):
(JSC::VM::throwException):
(JSC::VM::setStackPointerAtVMEntry):
(JSC::VM::getExceptionInfo): Deleted.
(JSC::VM::setExceptionInfo): Deleted.
(JSC::VM::clearException): Deleted.
(JSC::clearExceptionStack): Deleted.

• runtime/VM.h:

(JSC::VM::targetMachinePCForThrowOffset):
(JSC::VM::clearException):
(JSC::VM::setException):
(JSC::VM::exception):
(JSC::VM::addressOfException):
(JSC::VM::exceptionStack): Deleted.

• runtime/VMEntryScope.cpp:

(JSC::VMEntryScope::VMEntryScope):
(JSC::VMEntryScope::setEntryScopeDidPopListener):

Source/WebCore:

Update to use the new JSC::Exception object.

Test: inspector/debugger/break-on-exceptions.html

• ForwardingHeaders/runtime/Exception.h: Added.
• bindings/js/JSCallbackData.cpp:

(WebCore::JSCallbackData::invokeCallback):

• bindings/js/JSCustomXPathNSResolver.cpp:

(WebCore::JSCustomXPathNSResolver::lookupNamespaceURI):

• bindings/js/JSDOMBinding.cpp:

(WebCore::jsArray):
(WebCore::reportException):
(WebCore::reportCurrentException):

• bindings/js/JSDOMBinding.h:
• bindings/js/JSErrorHandler.cpp:

(WebCore::JSErrorHandler::handleEvent):

• bindings/js/JSEventListener.cpp:

(WebCore::JSEventListener::handleEvent):

• bindings/js/JSMainThreadExecState.cpp:

(WebCore::JSMainThreadExecState::didLeaveScriptContext):
(WebCore::functionCallHandlerFromAnyThread):
(WebCore::evaluateHandlerFromAnyThread):

• bindings/js/JSMainThreadExecState.h:

(WebCore::JSMainThreadExecState::currentState):
(WebCore::JSMainThreadExecState::call):
(WebCore::JSMainThreadExecState::evaluate):
(WebCore::JSMainThreadExecState::runTask):

• bindings/js/JSMediaDevicesCustom.cpp:

(WebCore::JSMediaDevices::getUserMedia):

• Fixed a bug where the exception was not cleared before entering the VM to call JS code.

• bindings/js/JSMutationCallback.cpp:

(WebCore::JSMutationCallback::call):

• bindings/js/ReadableJSStream.cpp:

(WebCore::getPropertyFromObject):
(WebCore::callFunction):
(WebCore::ReadableJSStream::Source::start):

• bindings/js/ScheduledAction.cpp:

(WebCore::ScheduledAction::executeFunctionInContext):

• bindings/js/ScriptController.cpp:

(WebCore::ScriptController::evaluateInWorld):

• bindings/js/SerializedScriptValue.cpp:

(WebCore::SerializedScriptValue::create):
(WebCore::SerializedScriptValue::deserialize):

• bindings/js/WorkerScriptController.cpp:

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

• bindings/js/WorkerScriptController.h:

(WebCore::WorkerScriptController::workerGlobalScopeWrapper):

• bindings/js/WorkerScriptDebugServer.cpp:

(WebCore::WorkerScriptDebugServer::runEventLoopWhilePaused):
(WebCore::WorkerScriptDebugServer::reportException):

• bindings/js/WorkerScriptDebugServer.h:
• bindings/objc/WebScriptObject.mm:

(WebCore::createJSWrapper):
(WebCore::addExceptionToConsole):
(-[WebScriptObject callWebScriptMethod:withArguments:]):
(-[WebScriptObject evaluateWebScript:]):

• Changed to call a version of JSMainThreadExecState::evaluate() that provides a stub returnedException because evaluateWebScript: doesn't need the exception.

• inspector/PageScriptDebugServer.cpp:

(WebCore::PageScriptDebugServer::isContentScript):
(WebCore::PageScriptDebugServer::reportException):

• inspector/PageScriptDebugServer.h:
• workers/WorkerGlobalScope.cpp:

(WebCore::WorkerGlobalScope::importScripts):

Source/WebKit/mac:

• WebView/WebView.mm:

(+[WebView _reportException:inContext:]):
(WebKitInitializeApplicationCachePathIfNecessary):

• Changed to use the new Exception object.

Source/WebKit/win:

• WebView.cpp:

(WebView::reportException):

• Changed to use the new Exception object.

Source/WebKit2:

• WebProcess/InjectedBundle/InjectedBundle.cpp:

(WebKit::InjectedBundle::reportException):

• Changed to use the new Exception object.

LayoutTests:

• TestExpectations:
• Skip the new tests until webkit.org/b/145090 is fixed.

• fast/dom/regress-131530-expected.txt:
• Rebased results because we now have a proper line number.

• http/tests/inspector/inspector-test.js:

(InspectorTestProxy.clearResults):
(InspectorTestProxy.reportUncaughtException):

• Add the feature to sanitize the url reported by reportUncaughtException() since we can have tests that do expect uncaught exceptions, and we need the test results to be invariant. Sanitization of the url, in this case means, stripping off the preceding path.

• inspector/debugger/break-on-exception-expected.txt: Added.
• inspector/debugger/break-on-exception.html: Added.
• inspector/debugger/break-on-exception-catch-expected.txt: Added.
• inspector/debugger/break-on-exception-catch.html: Added.
• inspector/debugger/break-on-exception-finally-expected.txt: Added.
• inspector/debugger/break-on-exception-finally.html: Added.
• inspector/debugger/break-on-exception-native-expected.txt: Added.
• inspector/debugger/break-on-exception-native.html: Added.

• inspector/debugger/break-on-exception-throw-in-promise-expected.txt: Added.
• inspector/debugger/break-on-exception-throw-in-promise.html: Added.
• inspector/debugger/break-on-exception-throw-in-promise-with-catch-expected.txt: Added.
• inspector/debugger/break-on-exception-throw-in-promise-with-catch.html: Added.
• inspector/debugger/break-on-exception-throw-in-promise-then-expected.txt: Added.
• inspector/debugger/break-on-exception-throw-in-promise-then.html: Added.
• inspector/debugger/break-on-exception-throw-in-promise-then-with-catch-expected.txt: Added.
• inspector/debugger/break-on-exception-throw-in-promise-then-with-catch.html: Added.
• inspector/debugger/break-on-exception-throw-in-promise-rethrow-in-catch-expected.txt: Added.
• inspector/debugger/break-on-exception-throw-in-promise-rethrow-in-catch.html: Added.

• inspector/debugger/break-on-exception-window-onerror-expected.txt: Added.
• inspector/debugger/break-on-exception-window-onerror.html: Added.

• inspector/debugger/break-on-uncaught-exception-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception.html: Added.
• inspector/debugger/break-on-uncaught-exception-catch-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-catch.html: Added.
• inspector/debugger/break-on-uncaught-exception-finally-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-finally.html: Added.
• inspector/debugger/break-on-uncaught-exception-native-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-native.html: Added.

• inspector/debugger/break-on-uncaught-exception-throw-in-promise-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise.html: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise-with-catch-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise-with-catch.html: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise-then.html: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-with-catch-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-with-catch.html: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise-rethrow-in-catch-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-throw-in-promise-rethrow-in-catch.html: Added.

• inspector/debugger/break-on-uncaught-exception-window-onerror-expected.txt: Added.
• inspector/debugger/break-on-uncaught-exception-window-onerror.html: Added.

• inspector/debugger/resources/break-on-exception-tests.js: Added.

(doThrow):
(testCatch):
(testFinally):
(testThrowingThruNativeCode):
(testThrowingInPromise):
(testThrowingInPromiseWithCatch):
(testThrowingInPromiseThen):
(testThrowingInPromiseThenWithCatch):
(testThrowingInPromiseWithRethrowInCatch):

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/TestExpectations (modified) (1 diff)
• LayoutTests/fast/dom/regress-131530-expected.txt (modified) (1 diff)
• LayoutTests/http/tests/inspector/inspector-test.js (modified) (1 diff)
• LayoutTests/inspector/debugger/break-on-exception-catch-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-catch.html (added)
• LayoutTests/inspector/debugger/break-on-exception-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-finally-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-finally.html (added)
• LayoutTests/inspector/debugger/break-on-exception-native-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-native.html (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-rethrow-in-catch-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-rethrow-in-catch.html (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-then-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-then-with-catch-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-then-with-catch.html (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-then.html (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-with-catch-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise-with-catch.html (added)
• LayoutTests/inspector/debugger/break-on-exception-throw-in-promise.html (added)
• LayoutTests/inspector/debugger/break-on-exception-window-onerror-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-exception-window-onerror.html (added)
• LayoutTests/inspector/debugger/break-on-exception.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-catch-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-catch.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-finally-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-finally.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-native-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-native.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-rethrow-in-catch-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-rethrow-in-catch.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-with-catch-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-with-catch.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-then.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-with-catch-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise-with-catch.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-throw-in-promise.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-window-onerror-expected.txt (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception-window-onerror.html (added)
• LayoutTests/inspector/debugger/break-on-uncaught-exception.html (added)
• LayoutTests/inspector/debugger/resources/break-on-exception-tests.js (added)
• Source/JavaScriptCore/API/JSBase.cpp (modified) (3 diffs)
• Source/JavaScriptCore/API/JSObjectRef.cpp (modified) (14 diffs)
• Source/JavaScriptCore/API/JSScriptRef.cpp (modified) (2 diffs)
• Source/JavaScriptCore/API/JSValue.mm (modified) (2 diffs)
• Source/JavaScriptCore/API/JSValueRef.cpp (modified) (8 diffs)
• Source/JavaScriptCore/CMakeLists.txt (modified) (1 diff)
• Source/JavaScriptCore/ChangeLog (modified) (1 diff)
• Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj (modified) (2 diffs)
• Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters (modified) (2 diffs)
• Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj (modified) (5 diffs)
• Source/JavaScriptCore/bindings/ScriptFunctionCall.cpp (modified) (1 diff)
• Source/JavaScriptCore/bindings/ScriptFunctionCall.h (modified) (1 diff)
• Source/JavaScriptCore/bytecode/BytecodeList.json (modified) (1 diff)
• Source/JavaScriptCore/bytecode/BytecodeUseDef.h (modified) (2 diffs)
• Source/JavaScriptCore/bytecode/CodeBlock.cpp (modified) (3 diffs)
• Source/JavaScriptCore/bytecode/CodeBlock.h (modified) (1 diff)
• Source/JavaScriptCore/bytecode/HandlerInfo.h (modified) (2 diffs)
• Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp (modified) (4 diffs)
• Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h (modified) (1 diff)
• Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp (modified) (3 diffs)
• Source/JavaScriptCore/debugger/Debugger.cpp (modified) (3 diffs)
• Source/JavaScriptCore/debugger/Debugger.h (modified) (2 diffs)
• Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp (modified) (2 diffs)
• Source/JavaScriptCore/debugger/DebuggerCallFrame.h (modified) (2 diffs)
• Source/JavaScriptCore/inspector/InjectedScriptManager.cpp (modified) (1 diff)
• Source/JavaScriptCore/inspector/InspectorEnvironment.h (modified) (2 diffs)
• Source/JavaScriptCore/inspector/JSGlobalObjectInspectorController.cpp (modified) (3 diffs)
• Source/JavaScriptCore/inspector/JSGlobalObjectInspectorController.h (modified) (2 diffs)
• Source/JavaScriptCore/inspector/JSGlobalObjectScriptDebugServer.h (modified) (1 diff)
• Source/JavaScriptCore/inspector/JSJavaScriptCallFrame.cpp (modified) (2 diffs)
• Source/JavaScriptCore/inspector/JavaScriptCallFrame.h (modified) (1 diff)
• Source/JavaScriptCore/inspector/ScriptCallStackFactory.cpp (modified) (3 diffs)
• Source/JavaScriptCore/inspector/ScriptCallStackFactory.h (modified) (2 diffs)
• Source/JavaScriptCore/inspector/ScriptDebugServer.cpp (modified) (5 diffs)
• Source/JavaScriptCore/inspector/ScriptDebugServer.h (modified) (2 diffs)
• Source/JavaScriptCore/interpreter/CallFrame.h (modified) (2 diffs)
• Source/JavaScriptCore/interpreter/Interpreter.cpp (modified) (7 diffs)
• Source/JavaScriptCore/interpreter/Interpreter.h (modified) (2 diffs)
• Source/JavaScriptCore/jit/AssemblyHelpers.cpp (modified) (1 diff)
• Source/JavaScriptCore/jit/JITExceptions.cpp (modified) (2 diffs)
• Source/JavaScriptCore/jit/JITExceptions.h (modified) (1 diff)
• Source/JavaScriptCore/jit/JITOpcodes.cpp (modified) (2 diffs)
• Source/JavaScriptCore/jit/JITOpcodes32_64.cpp (modified) (3 diffs)
• Source/JavaScriptCore/jit/JITOperations.cpp (modified) (4 diffs)
• Source/JavaScriptCore/jit/ThunkGenerators.cpp (modified) (1 diff)
• Source/JavaScriptCore/jsc.cpp (modified) (6 diffs)
• Source/JavaScriptCore/llint/LLIntOffsetsExtractor.cpp (modified) (1 diff)
• Source/JavaScriptCore/llint/LLIntSlowPaths.cpp (modified) (1 diff)
• Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm (modified) (3 diffs)
• Source/JavaScriptCore/llint/LowLevelInterpreter64.asm (modified) (1 diff)
• Source/JavaScriptCore/parser/NodeConstructors.h (modified) (1 diff)
• Source/JavaScriptCore/parser/Nodes.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/CallData.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/CallData.h (modified) (2 diffs)
• Source/JavaScriptCore/runtime/Completion.cpp (modified) (4 diffs)
• Source/JavaScriptCore/runtime/Completion.h (modified) (2 diffs)
• Source/JavaScriptCore/runtime/Error.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/Exception.cpp (added)
• Source/JavaScriptCore/runtime/Exception.h (added)
• Source/JavaScriptCore/runtime/ExceptionHelpers.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/ExceptionHelpers.h (modified) (1 diff)
• Source/JavaScriptCore/runtime/GetterSetter.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/IteratorOperations.cpp (modified) (4 diffs)
• Source/JavaScriptCore/runtime/JSObject.cpp (modified) (1 diff)
• Source/JavaScriptCore/runtime/JSPromiseConstructor.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/JSPromiseDeferred.cpp (modified) (4 diffs)
• Source/JavaScriptCore/runtime/JSPromiseReaction.cpp (modified) (2 diffs)
• Source/JavaScriptCore/runtime/VM.cpp (modified) (4 diffs)
• Source/JavaScriptCore/runtime/VM.h (modified) (5 diffs)
• Source/JavaScriptCore/runtime/VMEntryScope.cpp (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/ForwardingHeaders/runtime/Exception.h (added)
• Source/WebCore/bindings/js/JSCallbackData.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/JSCustomXPathNSResolver.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/JSDOMBinding.cpp (modified) (5 diffs)
• Source/WebCore/bindings/js/JSDOMBinding.h (modified) (1 diff)
• Source/WebCore/bindings/js/JSErrorHandler.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/JSEventListener.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/JSMainThreadExecState.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/JSMainThreadExecState.h (modified) (2 diffs)
• Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp (modified) (2 diffs)
• Source/WebCore/bindings/js/JSMutationCallback.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/ReadableJSStream.cpp (modified) (2 diffs)
• Source/WebCore/bindings/js/ScheduledAction.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/ScriptController.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/SerializedScriptValue.cpp (modified) (3 diffs)
• Source/WebCore/bindings/js/WorkerScriptController.cpp (modified) (4 diffs)
• Source/WebCore/bindings/js/WorkerScriptController.h (modified) (1 diff)
• Source/WebCore/bindings/js/WorkerScriptDebugServer.cpp (modified) (1 diff)
• Source/WebCore/bindings/js/WorkerScriptDebugServer.h (modified) (1 diff)
• Source/WebCore/bindings/objc/WebScriptObject.mm (modified) (4 diffs)
• Source/WebCore/inspector/PageScriptDebugServer.cpp (modified) (1 diff)
• Source/WebCore/inspector/PageScriptDebugServer.h (modified) (1 diff)
• Source/WebCore/workers/WorkerGlobalScope.cpp (modified) (1 diff)
• Source/WebKit/mac/ChangeLog (modified) (1 diff)
• Source/WebKit/mac/WebView/WebView.mm (modified) (2 diffs)
• Source/WebKit/win/ChangeLog (modified) (1 diff)
• Source/WebKit/win/WebView.cpp (modified) (2 diffs)
• Source/WebKit2/ChangeLog (modified) (1 diff)
• Source/WebKit2/WebProcess/InjectedBundle/InjectedBundle.cpp (modified) (2 diffs)

trunk/LayoutTests/ChangeLog ¶

@@ +1 @@
+2015-06-05  Mark Lam  <mark.lam@apple.com>
+
+        finally blocks should not set the exception stack trace when re-throwing the exception.
+        https://bugs.webkit.org/show_bug.cgi?id=145525
+
+        Reviewed by Geoffrey Garen.
+
+        * TestExpectations:
+        - Skip the new tests until webkit.org/b/145090 is fixed.
+
+        * fast/dom/regress-131530-expected.txt:
+        - Rebased results because we now have a proper line number.
+
+        * http/tests/inspector/inspector-test.js:
+        (InspectorTestProxy.clearResults):
+        (InspectorTestProxy.reportUncaughtException):
+        - Add the feature to sanitize the url reported by reportUncaughtException() since
+          we can have tests that do expect uncaught exceptions, and we need the test
+          results to be invariant.  Sanitization of the url, in this case means, stripping
+          off the preceding path.
+
+        * inspector/debugger/break-on-exception-expected.txt: Added.
+        * inspector/debugger/break-on-exception.html: Added.
+        * inspector/debugger/break-on-exception-catch-expected.txt: Added.
+        * inspector/debugger/break-on-exception-catch.html: Added.
+        * inspector/debugger/break-on-exception-finally-expected.txt: Added.
+        * inspector/debugger/break-on-exception-finally.html: Added.
+        * inspector/debugger/break-on-exception-native-expected.txt: Added.
+        * inspector/debugger/break-on-exception-native.html: Added.
+
+        * inspector/debugger/break-on-exception-throw-in-promise-expected.txt: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise.html: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise-with-catch-expected.txt: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise-with-catch.html: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise-then-expected.txt: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise-then.html: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise-then-with-catch-expected.txt: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise-then-with-catch.html: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise-rethrow-in-catch-expected.txt: Added.
+        * inspector/debugger/break-on-exception-throw-in-promise-rethrow-in-catch.html: Added.
+
+        * inspector/debugger/break-on-exception-window-onerror-expected.txt: Added.
+        * inspector/debugger/break-on-exception-window-onerror.html: Added.
+
+        * inspector/debugger/break-on-uncaught-exception-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception.html: Added.
+        * inspector/debugger/break-on-uncaught-exception-catch-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-catch.html: Added.
+        * inspector/debugger/break-on-uncaught-exception-finally-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-finally.html: Added.
+        * inspector/debugger/break-on-uncaught-exception-native-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-native.html: Added.
+
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise.html: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-with-catch-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-with-catch.html: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-then.html: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-with-catch-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-with-catch.html: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-rethrow-in-catch-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-throw-in-promise-rethrow-in-catch.html: Added.
+
+        * inspector/debugger/break-on-uncaught-exception-window-onerror-expected.txt: Added.
+        * inspector/debugger/break-on-uncaught-exception-window-onerror.html: Added.
+
+        * inspector/debugger/resources/break-on-exception-tests.js: Added.
+        (doThrow):
+        (testCatch):
+        (testFinally):
+        (testThrowingThruNativeCode):
+        (testThrowingInPromise):
+        (testThrowingInPromiseWithCatch):
+        (testThrowingInPromiseThen):
+        (testThrowingInPromiseThenWithCatch):
+        (testThrowingInPromiseWithRethrowInCatch):
+
 2015-06-05  Eric Carlson  <eric.carlson@apple.com>
 

trunk/LayoutTests/TestExpectations ¶

@@ -526 +526 @@
 
 webkit.org/b/145390 storage/indexeddb/deleteIndex-bug110792.html [ Pass Failure ]
+
+webkit.org/b/145090 inspector/debugger/break-on-exception.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-catch.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-finally.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-native.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-throw-in-promise.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-throw-in-promise-with-catch.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-throw-in-promise-then.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-throw-in-promise-then-with-catch.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-throw-in-promise-rethrow-in-catch.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-exception-window-onerror.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-catch.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-finally.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-native.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-throw-in-promise.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-throw-in-promise-with-catch.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-throw-in-promise-then.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-throw-in-promise-then-with-catch.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-throw-in-promise-rethrow-in-catch.html [ Skip ]
+webkit.org/b/145090 inspector/debugger/break-on-uncaught-exception-window-onerror.html [ Skip ]
+

trunk/LayoutTests/fast/dom/regress-131530-expected.txt ¶

@@ -1 +1 @@
 CONSOLE MESSAGE: line 5: Exception to trigger unwinding in MutationObserver
-CONSOLE MESSAGE: Pending exception before MutationObservers are called.
+CONSOLE MESSAGE: line 22: Pending exception before MutationObservers are called.
 Regression test for https://webkit.org/b/131530. This test should not crash.
 

trunk/LayoutTests/http/tests/inspector/inspector-test.js ¶

@@ -144 +144 @@
 }
 
+InspectorTestProxy.needToSanitizeUncaughtExceptionURLs = false;
+
 InspectorTestProxy.reportUncaughtException = function(message, url, lineNumber)
 {
+    if (InspectorTestProxy.needToSanitizeUncaughtExceptionURLs) {
+        if (typeof url == "string") {
+            var lastSlash = url.lastIndexOf("/");
+            var lastBackSlash = url.lastIndexOf("\\");
+            var lastPathSeparator = Math.max(lastSlash, lastBackSlash);
+            if (lastPathSeparator > 0)
+                url = url.substr(lastPathSeparator + 1);
+        }
+    }
+
     var result = "Uncaught exception in test page: " + message + " [" + url + ":" + lineNumber + "]";
     InspectorTestProxy.addResult(result);

trunk/Source/JavaScriptCore/API/JSBase.cpp ¶

@@ -31 +31 @@
 #include "CallFrame.h"
 #include "Completion.h"
+#include "Exception.h"
 #include "GCActivityCallback.h"
 #include "InitializeThreading.h"
@@ -64 +65 @@
     SourceCode source = makeSource(script->string(), sourceURL ? sourceURL->string() : String(), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber::first()));
 
-    JSValue evaluationException;
-    JSValue returnValue = evaluate(globalObject->globalExec(), source, jsThisObject, &evaluationException);
+    Exception* evaluationException;
+    JSValue returnValue = evaluate(globalObject->globalExec(), source, jsThisObject, evaluationException);
 
     if (evaluationException) {
         if (exception)
-            *exception = toRef(exec, evaluationException);
+            *exception = toRef(exec, evaluationException->value());
 #if ENABLE(REMOTE_INSPECTOR)
         // FIXME: If we have a debugger attached we could learn about ParseError exceptions through
@@ -108 +109 @@
             *exception = toRef(exec, syntaxException);
 #if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, syntaxException);
+        Exception* exception = Exception::create(exec->vm(), syntaxException);
+        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exception);
 #endif
         return false;

trunk/Source/JavaScriptCore/API/JSObjectRef.cpp ¶

@@ -35 +35 @@
 #include "DateConstructor.h"
 #include "ErrorConstructor.h"
+#include "Exception.h"
 #include "FunctionConstructor.h"
 #include "Identifier.h"
@@ -62 +63 @@
 using namespace JSC;
 
+enum class ExceptionStatus {
+    DidThrow,
+    DidNotThrow
+};
+
+static ExceptionStatus handleExceptionIfNeeded(ExecState* exec, JSValueRef* returnedExceptionRef)
+{
+    if (exec->hadException()) {
+        Exception* exception = exec->exception();
+        if (returnedExceptionRef)
+            *returnedExceptionRef = toRef(exec, exception->value());
+        exec->clearException();
+#if ENABLE(REMOTE_INSPECTOR)
+        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exception);
+#endif
+        return ExceptionStatus::DidThrow;
+    }
+    return ExceptionStatus::DidNotThrow;
+}
+
 JSClassRef JSClassCreate(const JSClassDefinition* definition)
 {
@@ -149 +170 @@
 
     JSObject* result = constructFunction(exec, exec->lexicalGlobalObject(), args, nameID, sourceURL ? sourceURL->string() : String(), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber::first()));
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         result = 0;
-    }
     return toRef(result);
 }
@@ -181 +194 @@
         result = constructEmptyArray(exec, 0);
 
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         result = 0;
-    }
 
     return toRef(result);
@@ -209 +214 @@
 
     JSObject* result = constructDate(exec, exec->lexicalGlobalObject(), argList);
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         result = 0;
-    }
 
     return toRef(result);
@@ -236 +233 @@
     JSObject* result = ErrorInstance::create(exec, errorStructure, message);
 
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         result = 0;
-    }
 
     return toRef(result);
@@ -264 +253 @@
 
     JSObject* result = constructRegExp(exec, exec->lexicalGlobalObject(),  argList);
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         result = 0;
-    }
     
     return toRef(result);
@@ -340 +321 @@
 
     JSValue jsValue = jsObject->get(exec, propertyName->identifier(&exec->vm()));
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
-    }
+    handleExceptionIfNeeded(exec, exception);
     return toRef(exec, jsValue);
 }
@@ -373 +346 @@
     }
 
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
-    }
+    handleExceptionIfNeeded(exec, exception);
 }
 
@@ -396 +361 @@
 
     JSValue jsValue = jsObject->get(exec, propertyIndex);
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
-    }
+    handleExceptionIfNeeded(exec, exception);
     return toRef(exec, jsValue);
 }
@@ -422 +379 @@
     
     jsObject->methodTable()->putByIndex(jsObject, exec, propertyIndex, jsValue, false);
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
-    }
+    handleExceptionIfNeeded(exec, exception);
 }
 
@@ -445 +394 @@
 
     bool result = jsObject->methodTable()->deleteProperty(jsObject, exec, propertyName->identifier(&exec->vm()));
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
-    }
+    handleExceptionIfNeeded(exec, exception);
     return result;
 }
@@ -617 +558 @@
 
     JSValueRef result = toRef(exec, call(exec, jsObject, callType, callData, jsThisObject, argList));
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         result = 0;
-    }
     return result;
 }
@@ -658 +591 @@
         argList.append(toJS(exec, arguments[i]));
     JSObjectRef result = toRef(construct(exec, jsObject, constructType, constructData, argList));
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         result = 0;
-    }
     return result;
 }

trunk/Source/JavaScriptCore/API/JSScriptRef.cpp ¶

@@ -28 +28 @@
 #include "APICast.h"
 #include "Completion.h"
+#include "Exception.h"
 #include "JSBasePrivate.h"
 #include "VM.h"
@@ -143 +144 @@
         return 0;
     }
-    JSValue internalException;
+    Exception* internalException;
     JSValue thisValue = thisValueRef ? toJS(exec, thisValueRef) : jsUndefined();
-    JSValue result = evaluate(exec, SourceCode(script), thisValue, &internalException);
+    JSValue result = evaluate(exec, SourceCode(script), thisValue, internalException);
     if (internalException) {
         if (exception)
-            *exception = toRef(exec, internalException);
+            *exception = toRef(exec, internalException->value());
         return 0;
     }

trunk/Source/JavaScriptCore/API/JSValue.mm ¶

@@ -29 +29 @@
 #import "DateInstance.h"
 #import "Error.h"
+#import "Exception.h"
 #import "JavaScriptCore.h"
 #import "JSContextInternal.h"
@@ -646 +647 @@
 
 #if ENABLE(REMOTE_INSPECTOR)
-static void reportExceptionToInspector(JSGlobalContextRef context, JSC::JSValue exception)
+static void reportExceptionToInspector(JSGlobalContextRef context, JSC::JSValue exceptionValue)
 {
     JSC::ExecState* exec = toJS(context);
+    JSC::Exception* exception = JSC::Exception::create(exec->vm(), exceptionValue);
     exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exception);
 }

trunk/Source/JavaScriptCore/API/JSValueRef.cpp ¶

@@ -29 +29 @@
 #include "APICast.h"
 #include "DateInstance.h"
+#include "Exception.h"
 #include "JSAPIWrapperObject.h"
 #include "JSCInlines.h"
@@ -53 +54 @@
 using namespace JSC;
 
+enum class ExceptionStatus {
+    DidThrow,
+    DidNotThrow
+};
+
+static ExceptionStatus handleExceptionIfNeeded(ExecState* exec, JSValueRef* returnedExceptionRef)
+{
+    if (exec->hadException()) {
+        Exception* exception = exec->exception();
+        if (returnedExceptionRef)
+            *returnedExceptionRef = toRef(exec, exception->value());
+        exec->clearException();
+#if ENABLE(REMOTE_INSPECTOR)
+        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exception);
+#endif
+        return ExceptionStatus::DidThrow;
+    }
+    return ExceptionStatus::DidNotThrow;
+}
+
 #if PLATFORM(MAC)
 static bool evernoteHackNeeded()
@@ -225 +246 @@
 
     bool result = JSValue::equal(exec, jsA, jsB); // false if an exception is thrown
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
-    }
+    handleExceptionIfNeeded(exec, exception);
+    
     return result;
 }
@@ -267 +281 @@
         return false;
     bool result = jsConstructor->hasInstance(exec, jsValue); // false if an exception is thrown
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
-    }
+    handleExceptionIfNeeded(exec, exception);
     return result;
 }
@@ -369 +375 @@
     if (exception)
         *exception = 0;
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
-        return 0;
-    }
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
+        return 0;
     return OpaqueJSString::create(result).leakRef();
 }
@@ -407 +405 @@
 
     double number = jsValue.toNumber(exec);
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         number = PNaN;
-    }
     return number;
 }
@@ -432 +422 @@
     
     RefPtr<OpaqueJSString> stringRef(OpaqueJSString::create(jsValue.toString(exec)->value(exec)));
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         stringRef.clear();
-    }
     return stringRef.release().leakRef();
 }
@@ -457 +439 @@
     
     JSObjectRef objectRef = toRef(jsValue.toObject(exec));
-    if (exec->hadException()) {
-        JSValue exceptionValue = exec->exception();
-        if (exception)
-            *exception = toRef(exec, exceptionValue);
-        exec->clearException();
-#if ENABLE(REMOTE_INSPECTOR)
-        exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exceptionValue);
-#endif
+    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
         objectRef = 0;
-    }
     return objectRef;
 }

trunk/Source/JavaScriptCore/CMakeLists.txt ¶

@@ -455 +455 @@
     runtime/ErrorInstance.cpp
     runtime/ErrorPrototype.cpp
+    runtime/Exception.cpp
     runtime/ExceptionFuzz.cpp
     runtime/ExceptionHelpers.cpp

trunk/Source/JavaScriptCore/ChangeLog ¶

@@ +1 @@
+2015-06-05  Mark Lam  <mark.lam@apple.com>
+
+        finally blocks should not set the exception stack trace when re-throwing the exception.
+        https://bugs.webkit.org/show_bug.cgi?id=145525
+
+        Reviewed by Geoffrey Garen.
+
+        How exceptions presently work:
+        =============================
+        1. op_throw can throw any JSValue.
+        2. the VM tries to capture the stack at the throw point and propagate that as needed.
+        3. finally blocks are implemented using op_catch to catch the thrown value, and throws it again using op_throw.
+
+        What's wrong with how it presently works:
+        ========================================
+        1. finally's makes for bad exception throw line numbers in the Inspector console.
+
+           The op_throw in finally will throw the value anew i.e. it captures a stack from the re-throw point.
+           As a result, the Inspector sees the finally block as the throw point.  The original stack is lost.
+
+        2. finally's breaks the Inspector's "Breaks on Uncaught Exception"
+
+           This is because finally blocks are indistinguishable from catch blocks.  As a result, a try-finally,
+           which should break in the Inspector on the throw, does not because the Inspector thought the
+           exception was "caught".
+
+        3. finally's yields confusing break points when the Inspector "Breaks on All Exceptions"
+
+           a. In a try-finally scenario, the Inspector breaks 2 times: 1 at the throw, 1 at the finally.
+           b. In a for-of loop (which has synthesized finallys), the Inspector will do another break.
+              Similarly for other cases of JS code which synthesize finallys.
+           c. At VM re-entry boundaries (e.g. js throws & returns to native code, which returns to js),
+              the Inspector will do another break if there's an uncaught exception.
+
+        How this patch fixes the issues:
+        ===============================
+        1. We introduce an Exception object that wraps the thrown value and the exception stack.
+
+           When throwing an exception, the VM will check if the thrown value is an Exception
+           object or not.  If it is not an Exception object, then we must be throwing a new
+           exception.  The VM will create an Exception object to wrap the thrown value and
+           capture the current stack for it.
+
+           If the thrown value is already an Exception object, then the requested throw operation
+           must be a re-throw.  The VM will not capture a new stack for it.
+
+        2. op_catch will now populate 2 locals: 1 for the Exception, 1 for the thrown JSValue.
+
+           The VM is aware of the Exception object and uses it for rethrows in finally blocks.
+           JS source code is never aware of the Exception object.
+
+           JS code is aware of the thrown value.  If it throws the caught thrown value, that
+           constitutes a new throw, and a new Exception object will be created for it.
+
+        3. The VM no longer tracks the thrown JSValue and the exception stack.  It will only
+           track a m_exception field which is an Exception*.
+
+        4. The BytecodeGenerator has already been updated in a prior patch to distinguish
+           between Catch, Finally, and SynthesizedFinally blocks.  The interpreter runtime will
+           now report to the debugger whether we have a Catch handler, not just any handlers.
+
+           The debugger will use this detail to determine whether to break or not.  "Break on
+           uncaught exceptions" will only break if no Catch handler was found.
+
+           This solves the issue of the debugger breaking at finally blocks, and for-of statements.
+
+        5. The Exception object will also have a flag to indicate whether the debugger has been
+           notified of the Exception being thrown.  Once the Interpreter notifies the debugger
+           of the Exception object, it will mark this flag and not repeat the notify the debugger
+           again of the same Exception.
+
+           This solves the issue of the debugger breaking at VM re-entry points due to uncaught
+           exceptions.
+
+        6. The life-cycle of the captured exception stack trace will now follow the life-cycle
+           of the Exception object.
+
+        Other changes:
+        7. Change all clients of the VM::exception() to expect an Exception* instead of JSValue.
+
+        8. Fixed a few bugs where thrown exceptions are not cleared before exiting the VM.
+
+        9. Also renamed some variables and classes to better describe what they are.
+
+        * API/JSBase.cpp:
+        (JSEvaluateScript):
+        (JSCheckScriptSyntax):
+
+        * API/JSObjectRef.cpp:
+        (handleExceptionIfNeeded):
+        - The functions below all do the same exception check.  Added this helper
+          to simplify the code.
+        (JSClassCreate):
+        (JSObjectMakeFunction):
+        (JSObjectMakeArray):
+        (JSObjectMakeDate):
+        (JSObjectMakeError):
+        (JSObjectMakeRegExp):
+        (JSObjectGetProperty):
+        (JSObjectSetProperty):
+        (JSObjectGetPropertyAtIndex):
+        (JSObjectSetPropertyAtIndex):
+        (JSObjectDeleteProperty):
+        (JSObjectCallAsFunction):
+        (JSObjectCallAsConstructor):
+
+        * API/JSScriptRef.cpp:
+        * API/JSValue.mm:
+        (JSContainerConvertor::take):
+        (reportExceptionToInspector):
+
+        * API/JSValueRef.cpp:
+        (handleExceptionIfNeeded):
+        - The functions below all do the same exception check.  Added this helper
+          to simplify the code.
+        (evernoteHackNeeded):
+        (JSValueIsEqual):
+        (JSValueIsInstanceOfConstructor):
+        (JSValueCreateJSONString):
+        (JSValueToNumber):
+        (JSValueToStringCopy):
+        (JSValueToObject):
+
+        * CMakeLists.txt:
+        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
+        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        - Added new files Exception.h and Exception.cpp.
+
+        * bindings/ScriptFunctionCall.cpp:
+        (Deprecated::ScriptFunctionCall::call):
+        * bindings/ScriptFunctionCall.h:
+
+        * bytecode/BytecodeList.json:
+        - op_catch now had 2 operands: the exception register, and the thrown value register.
+
+        * bytecode/BytecodeUseDef.h:
+        (JSC::computeDefsForBytecodeOffset):
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::dumpBytecode):
+        (JSC::CodeBlock::handlerForBytecodeOffset):
+        * bytecode/CodeBlock.h:
+        - handlerForBytecodeOffset() now can look for just Catch handlers only.
+
+        * bytecode/HandlerInfo.h:
+        - Cleaned up some white space I accidentally added in a previous patch.
+
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::pushTry):
+        (JSC::BytecodeGenerator::popTryAndEmitCatch):
+        (JSC::BytecodeGenerator::emitThrowReferenceError):
+        (JSC::BytecodeGenerator::emitEnumeration):
+        * bytecompiler/BytecodeGenerator.h:
+        (JSC::BytecodeGenerator::emitThrow):
+        * bytecompiler/NodesCodegen.cpp:
+        (JSC::TryNode::emitBytecode):
+        - Adding support for op_catch's 2 operands.
+
+        * debugger/Debugger.cpp:
+        (JSC::Debugger::hasBreakpoint):
+        (JSC::Debugger::pauseIfNeeded):
+        (JSC::Debugger::exception):
+        * debugger/Debugger.h:
+        * debugger/DebuggerCallFrame.cpp:
+        (JSC::DebuggerCallFrame::thisValue):
+        (JSC::DebuggerCallFrame::evaluate):
+        * debugger/DebuggerCallFrame.h:
+        (JSC::DebuggerCallFrame::isValid):
+        * inspector/InjectedScriptManager.cpp:
+        (Inspector::InjectedScriptManager::createInjectedScript):
+        * inspector/InspectorEnvironment.h:
+        * inspector/JSGlobalObjectInspectorController.cpp:
+        (Inspector::JSGlobalObjectInspectorController::appendAPIBacktrace):
+        (Inspector::JSGlobalObjectInspectorController::reportAPIException):
+        * inspector/JSGlobalObjectInspectorController.h:
+        * inspector/JSGlobalObjectScriptDebugServer.h:
+        * inspector/JSJavaScriptCallFrame.cpp:
+        (Inspector::JSJavaScriptCallFrame::evaluate):
+        * inspector/JavaScriptCallFrame.h:
+        (Inspector::JavaScriptCallFrame::vmEntryGlobalObject):
+        (Inspector::JavaScriptCallFrame::thisValue):
+        (Inspector::JavaScriptCallFrame::evaluate):
+        * inspector/ScriptCallStackFactory.cpp:
+        (Inspector::extractSourceInformationFromException):
+        (Inspector::createScriptCallStackFromException):
+        * inspector/ScriptCallStackFactory.h:
+        * inspector/ScriptDebugServer.cpp:
+        (Inspector::ScriptDebugServer::evaluateBreakpointAction):
+        (Inspector::ScriptDebugServer::handleBreakpointHit):
+        (Inspector::ScriptDebugServer::handleExceptionInBreakpointCondition):
+        * inspector/ScriptDebugServer.h:
+        * interpreter/CallFrame.h:
+        (JSC::ExecState::clearException):
+        (JSC::ExecState::exception):
+        (JSC::ExecState::hadException):
+        (JSC::ExecState::atomicStringTable):
+        (JSC::ExecState::propertyNames):
+        (JSC::ExecState::clearSupplementaryExceptionInfo): Deleted.
+
+        * interpreter/Interpreter.cpp:
+        (JSC::unwindCallFrame):
+        (JSC::Interpreter::stackTraceAsString):
+        (JSC::GetCatchHandlerFunctor::GetCatchHandlerFunctor):
+        (JSC::GetCatchHandlerFunctor::operator()):
+        (JSC::Interpreter::unwind):
+        - Added a check for didNotifyInspectorOfThrow() here to prevent duplicate reports
+          of the same Exception to the debugger.
+
+        (JSC::GetExceptionHandlerFunctor::GetExceptionHandlerFunctor): Deleted.
+        (JSC::GetExceptionHandlerFunctor::operator()): Deleted.
+        - Renamed GetExceptionHandlerFunctor to GetCatchHandlerFunctor since the debugger
+          is only interested in knowing whether we have Catch handlers.
+
+        * interpreter/Interpreter.h:
+        (JSC::SuspendExceptionScope::SuspendExceptionScope):
+        (JSC::SuspendExceptionScope::~SuspendExceptionScope):
+        (JSC::Interpreter::sampler):
+        (JSC::ClearExceptionScope::ClearExceptionScope): Deleted.
+        (JSC::ClearExceptionScope::~ClearExceptionScope): Deleted.
+        - Renamed ClearExceptionScope to SuspendExceptionScope because "clear" implies that
+          we're purging the exception.  Instead, we're merely suspending any handling of
+          that exception for a period defined by the scope.
+
+        * jit/AssemblyHelpers.cpp:
+        (JSC::AssemblyHelpers::emitExceptionCheck):
+
+        * jit/JITExceptions.cpp:
+        (JSC::genericUnwind):
+        - Removed the exception argument.  It is always the value in VM::exception() anyway.
+          genericUnwind() can just get it from the VM, and save everyone some work.
+
+        * jit/JITExceptions.h:
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::emit_op_catch):
+        * jit/JITOpcodes32_64.cpp:
+        (JSC::JIT::privateCompileCTINativeCall):
+        (JSC::JIT::emit_op_catch):
+        - Add support for the new op_catch operands.
+
+        * jit/JITOperations.cpp:
+        * jit/ThunkGenerators.cpp:
+        (JSC::nativeForGenerator):
+        * jsc.cpp:
+        (functionRun):
+        (functionLoad):
+        (runWithScripts):
+        (runInteractive):
+        * llint/LLIntOffsetsExtractor.cpp:
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+
+        * llint/LowLevelInterpreter32_64.asm:
+        * llint/LowLevelInterpreter64.asm:
+        - Add support for the new op_catch operands.  Also update the code to handle
+          VM::m_exception being an Exception pointer, not a JSValue.
+
+        * parser/NodeConstructors.h:
+        (JSC::TryNode::TryNode):
+        * parser/Nodes.h:
+        * runtime/CallData.cpp:
+        (JSC::call):
+        * runtime/CallData.h:
+
+        * runtime/Completion.cpp:
+        (JSC::evaluate):
+        * runtime/Completion.h:
+        (JSC::evaluate):
+        - Change evaluate() to take a reference to the returned exception value instead
+          of a pointer.  In all but 2 or 3 cases, we want the returned exception anyway.
+          Might as well simplify the code by requiring the reference.
+
+        * runtime/Error.h:
+        (JSC::throwVMError):
+        (JSC::throwVMTypeError):
+
+        * runtime/Exception.cpp: Added.
+        (JSC::Exception::create):
+        (JSC::Exception::destroy):
+        (JSC::Exception::createStructure):
+        (JSC::Exception::visitChildren):
+        (JSC::Exception::Exception):
+        (JSC::Exception::~Exception):
+        * runtime/Exception.h: Added.
+        (JSC::Exception::valueOffset):
+        (JSC::Exception::cast):
+        (JSC::Exception::value):
+        (JSC::Exception::stack):
+        (JSC::Exception::didNotifyInspectorOfThrow):
+        (JSC::Exception::setDidNotifyInspectorOfThrow):
+
+        * runtime/ExceptionHelpers.cpp:
+        (JSC::createTerminatedExecutionException):
+        (JSC::isTerminatedExecutionException):
+        (JSC::createStackOverflowError):
+        * runtime/ExceptionHelpers.h:
+        * runtime/GetterSetter.cpp:
+        (JSC::callGetter):
+        * runtime/IteratorOperations.cpp:
+        (JSC::iteratorClose):
+        * runtime/JSObject.cpp:
+        * runtime/JSPromiseConstructor.cpp:
+        (JSC::constructPromise):
+        * runtime/JSPromiseDeferred.cpp:
+        (JSC::updateDeferredFromPotentialThenable):
+        (JSC::abruptRejection):
+        * runtime/JSPromiseReaction.cpp:
+        (JSC::ExecutePromiseReactionMicrotask::run):
+
+        * runtime/VM.cpp:
+        (JSC::VM::VM):
+        (JSC::VM::releaseExecutableMemory):
+        (JSC::VM::throwException):
+        (JSC::VM::setStackPointerAtVMEntry):
+        (JSC::VM::getExceptionInfo): Deleted.
+        (JSC::VM::setExceptionInfo): Deleted.
+        (JSC::VM::clearException): Deleted.
+        (JSC::clearExceptionStack): Deleted.
+        * runtime/VM.h:
+        (JSC::VM::targetMachinePCForThrowOffset):
+        (JSC::VM::clearException):
+        (JSC::VM::setException):
+        (JSC::VM::exception):
+        (JSC::VM::addressOfException):
+        (JSC::VM::exceptionStack): Deleted.
+        * runtime/VMEntryScope.cpp:
+        (JSC::VMEntryScope::VMEntryScope):
+        (JSC::VMEntryScope::setEntryScopeDidPopListener):
+
 2015-06-04  Benjamin Poulain  <bpoulain@apple.com>
 

trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj ¶

@@ -713 +713 @@
     <ClCompile Include="..\runtime\ErrorInstance.cpp" />
     <ClCompile Include="..\runtime\ErrorPrototype.cpp" />
+    <ClCompile Include="..\runtime\Exception.cpp" />
     <ClCompile Include="..\runtime\ExceptionFuzz.cpp" />
     <ClCompile Include="..\runtime\ExceptionHelpers.cpp" />
@@ -1504 +1505 @@
     <ClInclude Include="..\runtime\ErrorInstance.h" />
     <ClInclude Include="..\runtime\ErrorPrototype.h" />
+    <ClInclude Include="..\runtime\Exception.h" />
     <ClInclude Include="..\runtime\ExceptionFuzz.h" />
     <ClInclude Include="..\runtime\ExceptionHelpers.h" />

trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters ¶

@@ -1699 +1699 @@
       <Filter>dfg</Filter>
     </ClCompile>
+    <ClCompile Include="..\runtime\Exception.cpp">
+      <Filter>runtime</Filter>
+    </ClCompile>
     <ClCompile Include="..\runtime\ExceptionFuzz.cpp">
       <Filter>runtime</Filter>
@@ -4190 +4193 @@
     <ClInclude Include="..\dfg\DFGValueStrength.h">
       <Filter>dfg</Filter>
+    </ClInclude>
+    <ClInclude Include="..\runtime\Exception.h">
+      <Filter>runtime</Filter>
     </ClInclude>
     <ClInclude Include="..\runtime\ExceptionFuzz.h">

trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj ¶

@@ -1661 +1661 @@
                 FE0D4A061AB8DD0A002F54BF /* ExecutionTimeLimitTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE0D4A041AB8DD0A002F54BF /* ExecutionTimeLimitTest.cpp */; };
                 FE0D4A091ABA2437002F54BF /* GlobalContextWithFinalizerTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE0D4A071ABA2437002F54BF /* GlobalContextWithFinalizerTest.cpp */; };
+                FE1C0FFD1B193E9800B53FCA /* Exception.h in Headers */ = {isa = PBXBuildFile; fileRef = FE1C0FFC1B193E9800B53FCA /* Exception.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                FE1C0FFF1B194FD100B53FCA /* Exception.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE1C0FFE1B194FD100B53FCA /* Exception.cpp */; };
                 FE20CE9D15F04A9500DF3430 /* LLIntCLoop.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE20CE9B15F04A9500DF3430 /* LLIntCLoop.cpp */; };
                 FE20CE9E15F04A9500DF3430 /* LLIntCLoop.h in Headers */ = {isa = PBXBuildFile; fileRef = FE20CE9C15F04A9500DF3430 /* LLIntCLoop.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -3464 +3466 @@
                 FE0D4A071ABA2437002F54BF /* GlobalContextWithFinalizerTest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GlobalContextWithFinalizerTest.cpp; path = API/tests/GlobalContextWithFinalizerTest.cpp; sourceTree = "<group>"; };
                 FE0D4A081ABA2437002F54BF /* GlobalContextWithFinalizerTest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GlobalContextWithFinalizerTest.h; path = API/tests/GlobalContextWithFinalizerTest.h; sourceTree = "<group>"; };
+                FE1C0FFC1B193E9800B53FCA /* Exception.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Exception.h; sourceTree = "<group>"; };
+                FE1C0FFE1B194FD100B53FCA /* Exception.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Exception.cpp; sourceTree = "<group>"; };
                 FE20CE9B15F04A9500DF3430 /* LLIntCLoop.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LLIntCLoop.cpp; path = llint/LLIntCLoop.cpp; sourceTree = "<group>"; };
                 FE20CE9C15F04A9500DF3430 /* LLIntCLoop.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LLIntCLoop.h; path = llint/LLIntCLoop.h; sourceTree = "<group>"; };
@@ -4428 +4432 @@
                                 BC02E9060E1839DB000F9297 /* ErrorPrototype.cpp */,
                                 BC02E9070E1839DB000F9297 /* ErrorPrototype.h */,
+                                FE1C0FFC1B193E9800B53FCA /* Exception.h */,
+                                FE1C0FFE1B194FD100B53FCA /* Exception.cpp */,
                                 0F12DE0D1979D5FD0006FF4E /* ExceptionFuzz.cpp */,
                                 0F12DE0E1979D5FD0006FF4E /* ExceptionFuzz.h */,
@@ -5625 +5631 @@
                                 FE5068651AE246390009DAB7 /* DeferredSourceDump.h in Headers */,
                                 C442CB251A6CDB8C005D3D7C /* JSInputs.json in Headers */,
+                                FE1C0FFD1B193E9800B53FCA /* Exception.h in Headers */,
                                 52678F911A04177C006A306D /* ControlFlowProfiler.h in Headers */,
                                 52678F8F1A031009006A306D /* BasicBlockLocation.h in Headers */,
@@ -7409 +7416 @@
                                 7C008CD2186F8A9300955C24 /* JSPromiseFunctions.cpp in Sources */,
                                 7C184E1E17BEE22E007CB63A /* JSPromisePrototype.cpp in Sources */,
+                                FE1C0FFF1B194FD100B53FCA /* Exception.cpp in Sources */,
                                 709FB86B1AE335C60039D069 /* WeakSetPrototype.cpp in Sources */,
                                 7C008CDE1871258D00955C24 /* JSPromiseReaction.cpp in Sources */,

trunk/Source/JavaScriptCore/bindings/ScriptFunctionCall.cpp ¶

@@ -134 +134 @@
 
     JSValue result;
-    JSValue exception;
+    Exception* exception;
     if (m_callHandler)
-        result = m_callHandler(m_exec, function, callType, callData, thisObject, m_arguments, &exception);
+        result = m_callHandler(m_exec, function, callType, callData, thisObject, m_arguments, exception);
     else
-        result = JSC::call(m_exec, function, callType, callData, thisObject, m_arguments, &exception);
+        result = JSC::call(m_exec, function, callType, callData, thisObject, m_arguments, exception);
 
     if (exception) {

trunk/Source/JavaScriptCore/bindings/ScriptFunctionCall.h ¶

@@ -72 +72 @@
 class JS_EXPORT_PRIVATE ScriptFunctionCall : public ScriptCallArgumentHandler {
 public:
-    typedef JSC::JSValue (*ScriptFunctionCallHandler)(JSC::ExecState* exec, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::JSValue* exception);
+    typedef JSC::JSValue (*ScriptFunctionCallHandler)(JSC::ExecState* exec, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::Exception*& exception);
     ScriptFunctionCall(const ScriptObject& thisObject, const String& name, ScriptFunctionCallHandler handler = nullptr);
     ScriptValue call(bool& hadException);

trunk/Source/JavaScriptCore/bytecode/BytecodeList.json ¶

@@ -114 +114 @@
             { "name" : "op_pop_scope", "length" : 2 },
             { "name" : "op_push_name_scope", "length" : 5 },
-            { "name" : "op_catch", "length" : 2 },
+            { "name" : "op_catch", "length" : 3 },
             { "name" : "op_throw", "length" : 2 },
             { "name" : "op_throw_static_error", "length" : 3 },

trunk/Source/JavaScriptCore/bytecode/BytecodeUseDef.h ¶

@@ -304 +304 @@
     case op_strcat:
     case op_to_primitive:
-    case op_catch:
     case op_create_this:
     case op_new_array:
@@ -375 +374 @@
         return;
     }
+    case op_catch:
     case op_create_lexical_environment: {
         functor(codeBlock, instruction, opcodeID, instruction[1].u.operand);

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp ¶

@@ -1485 +1485 @@
         case op_catch: {
             int r0 = (++it)->u.operand;
-            printLocationOpAndRegisterOperand(out, exec, location, it, "catch", r0);
+            int r1 = (++it)->u.operand;
+            printLocationAndOp(out, exec, location, it, "catch");
+            out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());
             break;
         }
@@ -2879 +2881 @@
 #endif
 
-HandlerInfo* CodeBlock::handlerForBytecodeOffset(unsigned bytecodeOffset)
+HandlerInfo* CodeBlock::handlerForBytecodeOffset(unsigned bytecodeOffset, RequiredHandler requiredHandler)
 {
     RELEASE_ASSERT(bytecodeOffset < instructions().size());
@@ -2889 +2891 @@
     for (size_t i = 0; i < exceptionHandlers.size(); ++i) {
         HandlerInfo& handler = exceptionHandlers[i];
+        if ((requiredHandler == RequiredHandler::CatchHandler) && !handler.isCatchHandler())
+            continue;
+
         // Handlers are ordered innermost first, so the first handler we encounter
         // that contains the source address is the correct handler to use.

trunk/Source/JavaScriptCore/bytecode/CodeBlock.h ¶

@@ -186 +186 @@
     }
 
-    HandlerInfo* handlerForBytecodeOffset(unsigned bytecodeOffset);
+    enum class RequiredHandler {
+        CatchHandler,
+        AnyHandler
+    };
+    HandlerInfo* handlerForBytecodeOffset(unsigned bytecodeOffset, RequiredHandler = RequiredHandler::AnyHandler);
     unsigned lineNumberForBytecodeOffset(unsigned bytecodeOffset);
     unsigned columnNumberForBytecodeOffset(unsigned bytecodeOffset);

trunk/Source/JavaScriptCore/bytecode/HandlerInfo.h ¶

@@ -41 +41 @@
     HandlerType type() const { return static_cast<HandlerType>(typeBits); }
     void setType(HandlerType type) { typeBits = static_cast<uint32_t>(type); }
-    
+
     const char* typeName()
     {
@@ -56 +56 @@
         return nullptr;
     }
-    
+
     bool isCatchHandler() const { return type() == HandlerType::Catch; }
-    
+
     uint32_t start;
     uint32_t end;

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp ¶

@@ -2529 +2529 @@
 }
 
-RegisterID* BytecodeGenerator::popTryAndEmitCatch(TryData* tryData, RegisterID* targetRegister, Label* end, HandlerType handlerType)
+void BytecodeGenerator::popTryAndEmitCatch(TryData* tryData, RegisterID* exceptionRegister, RegisterID* thrownValueRegister, Label* end, HandlerType handlerType)
 {
     m_usesExceptions = true;
@@ -2547 +2547 @@
 
     emitOpcode(op_catch);
-    instructions().append(targetRegister->index());
-    return targetRegister;
+    instructions().append(exceptionRegister->index());
+    instructions().append(thrownValueRegister->index());
 }
 
@@ -2761 +2761 @@
         {
             RefPtr<Label> catchHere = emitLabel(newLabel().get());
-            RefPtr<RegisterID> exceptionRegister = popTryAndEmitCatch(tryData, newTemporary(), catchHere.get(), HandlerType::SynthesizedFinally);
+            RefPtr<RegisterID> exceptionRegister = newTemporary();
+            RefPtr<RegisterID> thrownValueRegister = newTemporary();
+            popTryAndEmitCatch(tryData, exceptionRegister.get(),
+                thrownValueRegister.get(), catchHere.get(), HandlerType::SynthesizedFinally);
+
             RefPtr<Label> catchDone = newLabel();
 
@@ -2779 +2783 @@
 
             // Absorb exception.
-            popTryAndEmitCatch(returnCallTryData, newTemporary(), catchDone.get(), HandlerType::SynthesizedFinally);
+            popTryAndEmitCatch(returnCallTryData, newTemporary(),
+                newTemporary(), catchDone.get(), HandlerType::SynthesizedFinally);
             emitThrow(exceptionRegister.get());
         }

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h ¶

@@ -554 +554 @@
         TryData* pushTry(Label* start);
         // End a try block. 'end' must have been emitted.
-        RegisterID* popTryAndEmitCatch(TryData*, RegisterID* targetRegister, Label* end, HandlerType);
+        void popTryAndEmitCatch(TryData*, RegisterID* exceptionRegister, RegisterID* thrownValueRegister, Label* end, HandlerType);
 
         void emitThrow(RegisterID* exc)

trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp ¶

@@ -2882 +2882 @@
         // Uncaught exception path: the catch block.
         RefPtr<Label> here = generator.emitLabel(generator.newLabel().get());
-        RefPtr<RegisterID> exceptionRegister = generator.popTryAndEmitCatch(tryData, generator.newTemporary(), here.get(), HandlerType::Catch);
+        RefPtr<RegisterID> exceptionRegister = generator.newTemporary();
+        RefPtr<RegisterID> thrownValueRegister = generator.newTemporary();
+        generator.popTryAndEmitCatch(tryData, exceptionRegister.get(), thrownValueRegister.get(), here.get(), HandlerType::Catch);
         
         if (m_finallyBlock) {
@@ -2890 +2892 @@
         }
 
-        generator.emitPushCatchScope(generator.scopeRegister(), m_exceptionIdent, exceptionRegister.get(), DontDelete);
+        generator.emitPushCatchScope(generator.scopeRegister(), m_thrownValueIdent, thrownValueRegister.get(), DontDelete);
         generator.emitProfileControlFlow(m_tryBlock->endOffset() + 1);
         generator.emitNode(dst, m_catchBlock);
@@ -2913 +2915 @@
 
         // Uncaught exception path: invoke the finally block, then re-throw the exception.
-        RefPtr<RegisterID> tempExceptionRegister = generator.popTryAndEmitCatch(tryData, generator.newTemporary(), preFinallyLabel.get(), HandlerType::Finally);
+        RefPtr<RegisterID> exceptionRegister = generator.newTemporary();
+        RefPtr<RegisterID> thrownValueRegister = generator.newTemporary();
+        generator.popTryAndEmitCatch(tryData, exceptionRegister.get(), thrownValueRegister.get(), preFinallyLabel.get(), HandlerType::Finally);
         generator.emitProfileControlFlow(finallyStartOffset);
         generator.emitNode(dst, m_finallyBlock);
-        generator.emitThrow(tempExceptionRegister.get());
+        generator.emitThrow(exceptionRegister.get());
 
         generator.emitLabel(finallyEndLabel.get());

trunk/Source/JavaScriptCore/debugger/Debugger.cpp ¶

@@ -488 +488 @@
     TemporaryPausedState pausedState(*this);
 
-    JSValue exception;
+    Exception* exception;
     DebuggerCallFrame* debuggerCallFrame = currentDebuggerCallFrame();
     JSValue result = debuggerCallFrame->evaluate(breakpoint->condition, exception);
@@ -696 +696 @@
 }
 
-void Debugger::exception(CallFrame* callFrame, JSValue exception, bool hasHandler)
+void Debugger::exception(CallFrame* callFrame, JSValue exception, bool hasCatchHandler)
 {
     if (m_isPaused)
@@ -702 +702 @@
 
     PauseReasonDeclaration reason(*this, PausedForException);
-    if (m_pauseOnExceptionsState == PauseOnAllExceptions || (m_pauseOnExceptionsState == PauseOnUncaughtExceptions && !hasHandler)) {
+    if (m_pauseOnExceptionsState == PauseOnAllExceptions || (m_pauseOnExceptionsState == PauseOnUncaughtExceptions && !hasCatchHandler)) {
         m_pauseOnNextStatement = true;
         setSteppingMode(SteppingModeEnabled);

trunk/Source/JavaScriptCore/debugger/Debugger.h ¶

@@ -110 +110 @@
     virtual void sourceParsed(ExecState*, SourceProvider*, int errorLineNumber, const WTF::String& errorMessage) = 0;
 
-    void exception(CallFrame*, JSValue exceptionValue, bool hasHandler);
+    void exception(CallFrame*, JSValue exceptionValue, bool hasCatchHandler);
     void atStatement(CallFrame*);
     void callEvent(CallFrame*);
@@ -125 +125 @@
     virtual bool needPauseHandling(JSGlobalObject*) { return false; }
     virtual void handleBreakpointHit(JSGlobalObject*, const Breakpoint&) { }
-    virtual void handleExceptionInBreakpointCondition(ExecState*, JSValue exception) const { UNUSED_PARAM(exception); }
+    virtual void handleExceptionInBreakpointCondition(ExecState*, Exception*) const { }
     virtual void handlePause(JSGlobalObject*, ReasonForPause) { }
     virtual void notifyDoneProcessingDebuggerEvents() { }

trunk/Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp ¶

@@ -33 +33 @@
 #include "DebuggerEvalEnabler.h"
 #include "DebuggerScope.h"
+#include "Exception.h"
 #include "Interpreter.h"
 #include "JSFunction.h"
@@ -177 +178 @@
 
 // Evaluate some JavaScript code in the scope of this frame.
-JSValue DebuggerCallFrame::evaluate(const String& script, JSValue& exception)
+JSValue DebuggerCallFrame::evaluate(const String& script, Exception*& exception)
 {
     ASSERT(isValid());

trunk/Source/JavaScriptCore/debugger/DebuggerCallFrame.h ¶

@@ -39 +39 @@
 
 class DebuggerScope;
+class Exception;
 class ExecState;
 typedef ExecState CallFrame;
@@ -67 +68 @@
     JS_EXPORT_PRIVATE Type type() const;
     JS_EXPORT_PRIVATE JSValue thisValue() const;
-    JSValue evaluate(const String&, JSValue& exception);
+    JSValue evaluate(const String&, Exception*&);
 
     bool isValid() const { return !!m_callFrame; }

trunk/Source/JavaScriptCore/inspector/InjectedScriptManager.cpp ¶

@@ -140 +140 @@
     JSValue globalThisValue = scriptState->globalThisValue();
 
-    JSValue evaluationException;
+    Exception* evaluationException;
     InspectorEvaluateHandler evaluateHandler = m_environment.evaluateHandler();
-    JSValue functionValue = evaluateHandler(scriptState, sourceCode, globalThisValue, &evaluationException);
+    JSValue functionValue = evaluateHandler(scriptState, sourceCode, globalThisValue, evaluationException);
     if (evaluationException)
         return Deprecated::ScriptObject();

trunk/Source/JavaScriptCore/inspector/InspectorEnvironment.h ¶

@@ -34 +34 @@
 
 namespace JSC {
+class Exception;
 class SourceCode;
 }
@@ -39 +40 @@
 namespace Inspector {
 
-typedef JSC::JSValue (*InspectorFunctionCallHandler)(JSC::ExecState* exec, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::JSValue* exception);
-typedef JSC::JSValue (*InspectorEvaluateHandler)(JSC::ExecState*, const JSC::SourceCode&, JSC::JSValue thisValue, JSC::JSValue* exception);
+typedef JSC::JSValue (*InspectorFunctionCallHandler)(JSC::ExecState* exec, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::Exception*& returnedException);
+typedef JSC::JSValue (*InspectorEvaluateHandler)(JSC::ExecState*, const JSC::SourceCode&, JSC::JSValue thisValue, JSC::Exception*& returnedException);
 
 class InspectorEnvironment {

trunk/Source/JavaScriptCore/inspector/JSGlobalObjectInspectorController.cpp ¶

@@ -30 +30 @@
 #include "ConsoleMessage.h"
 #include "ErrorHandlingScope.h"
+#include "Exception.h"
 #include "InjectedScriptHost.h"
 #include "InjectedScriptManager.h"
@@ -189 +190 @@
 }
 
-void JSGlobalObjectInspectorController::reportAPIException(ExecState* exec, JSValue exception)
+void JSGlobalObjectInspectorController::reportAPIException(ExecState* exec, Exception* exception)
 {
     if (isTerminatedExecutionException(exception))
@@ -202 +203 @@
     // FIXME: <http://webkit.org/b/115087> Web Inspector: Should not evaluate JavaScript handling exceptions
     // If this is a custom exception object, call toString on it to try and get a nice string representation for the exception.
-    String errorMessage = exception.toString(exec)->value(exec);
+    String errorMessage = exception->value().toString(exec)->value(exec);
     exec->clearException();
 

trunk/Source/JavaScriptCore/inspector/JSGlobalObjectInspectorController.h ¶

@@ -44 +44 @@
 namespace JSC {
 class ConsoleClient;
+class Exception;
 class ExecState;
 class JSGlobalObject;
@@ -82 +83 @@
 
     void pause();
-    void reportAPIException(JSC::ExecState*, JSC::JSValue exception);
+    void reportAPIException(JSC::ExecState*, JSC::Exception*);
 
     JSC::ConsoleClient* consoleClient() const;

trunk/Source/JavaScriptCore/inspector/JSGlobalObjectScriptDebugServer.h ¶

@@ -55 +55 @@
     // Until a time comes where an exception can be caused outside of the API (e.g. setTimeout
     // or some other async operation in a pure JSContext) we can ignore exceptions reported here.
-    virtual void reportException(JSC::ExecState*, JSC::JSValue) const override { }
+    virtual void reportException(JSC::ExecState*, JSC::Exception*) const override { }
 
     ListenerSet m_listeners;

trunk/Source/JavaScriptCore/inspector/JSJavaScriptCallFrame.cpp ¶

@@ -29 +29 @@
 #include "DebuggerScope.h"
 #include "Error.h"
+#include "Exception.h"
 #include "JSCJSValue.h"
 #include "JSCellInlines.h"
@@ -76 +77 @@
 JSValue JSJavaScriptCallFrame::evaluate(ExecState* exec)
 {
-    JSValue exception;
+    Exception* exception;
     JSValue result = impl().evaluate(exec->argument(0).toString(exec)->value(exec), exception);
     if (exception)

trunk/Source/JavaScriptCore/inspector/JavaScriptCallFrame.h ¶

@@ -56 +56 @@
 
     JSC::JSValue thisValue() const { return m_debuggerCallFrame->thisValue(); }
-    JSC::JSValue evaluate(const String& script, JSC::JSValue& exception) const  { return m_debuggerCallFrame->evaluate(script, exception); }
+    JSC::JSValue evaluate(const String& script, JSC::Exception*& exception) const  { return m_debuggerCallFrame->evaluate(script, exception); }
 
 private:

trunk/Source/JavaScriptCore/inspector/ScriptCallStackFactory.cpp ¶

@@ -35 +35 @@
 
 #include "CallFrame.h"
+#include "Exception.h"
 #include "JSCJSValue.h"
 #include "JSCInlines.h"
@@ -129 +130 @@
 }
 
-PassRefPtr<ScriptCallStack> createScriptCallStackFromException(JSC::ExecState* exec, JSC::JSValue& exception, size_t maxStackSize)
+PassRefPtr<ScriptCallStack> createScriptCallStackFromException(JSC::ExecState* exec, JSC::Exception* exception, size_t maxStackSize)
 {
     Vector<ScriptCallFrame> frames;
-    RefCountedArray<StackFrame> stackTrace = exec->vm().exceptionStack();
+    RefCountedArray<StackFrame> stackTrace = exception->stack();
     for (size_t i = 0; i < stackTrace.size() && i < maxStackSize; i++) {
         unsigned line;
@@ -142 +143 @@
 
     // Fallback to getting at least the line and sourceURL from the exception object if it has values and the exceptionStack doesn't.
-    JSObject* exceptionObject = exception.toObject(exec);
-    if (exception.isObject()) {
+    if (exception->value().isObject()) {
+        JSObject* exceptionObject = exception->value().toObject(exec);
         int lineNumber;
         int columnNumber;

trunk/Source/JavaScriptCore/inspector/ScriptCallStackFactory.h ¶

@@ -36 +36 @@
 
 namespace JSC {
+class Exception;
 class ExecState;
 class JSValue;
@@ -48 +49 @@
 JS_EXPORT_PRIVATE PassRefPtr<ScriptCallStack> createScriptCallStack(JSC::ExecState*, size_t maxStackSize);
 JS_EXPORT_PRIVATE PassRefPtr<ScriptCallStack> createScriptCallStackForConsole(JSC::ExecState*, size_t maxStackSize);
-JS_EXPORT_PRIVATE PassRefPtr<ScriptCallStack> createScriptCallStackFromException(JSC::ExecState*, JSC::JSValue& exception, size_t maxStackSize);
+JS_EXPORT_PRIVATE PassRefPtr<ScriptCallStack> createScriptCallStackFromException(JSC::ExecState*, JSC::Exception*, size_t maxStackSize);
 JS_EXPORT_PRIVATE PassRefPtr<ScriptArguments> createScriptArguments(JSC::ExecState*, unsigned skipArgumentCount);
 

trunk/Source/JavaScriptCore/inspector/ScriptDebugServer.cpp ¶

@@ -34 +34 @@
 #include "DebuggerCallFrame.h"
 #include "DebuggerScope.h"
+#include "Exception.h"
 #include "JSJavaScriptCallFrame.h"
 #include "JSLock.h"
@@ -94 +95 @@
     }
     case ScriptBreakpointActionTypeEvaluate: {
-        JSValue exception;
+        Exception* exception;
         debuggerCallFrame->evaluate(breakpointAction.data, exception);
         if (exception)
@@ -104 +105 @@
         break;
     case ScriptBreakpointActionTypeProbe: {
-        JSValue exception;
+        Exception* exception;
         JSValue result = debuggerCallFrame->evaluate(breakpointAction.data, exception);
         if (exception)
@@ -110 +111 @@
         
         JSC::ExecState* state = debuggerCallFrame->scope()->globalObject()->globalExec();
-        Deprecated::ScriptValue wrappedResult = Deprecated::ScriptValue(state->vm(), exception ? exception : result);
+        Deprecated::ScriptValue wrappedResult = Deprecated::ScriptValue(state->vm(), exception ? exception->value() : result);
         dispatchBreakpointActionProbe(state, breakpointAction, wrappedResult);
         break;
@@ -303 +304 @@
 }
 
-void ScriptDebugServer::handleExceptionInBreakpointCondition(JSC::ExecState* exec, JSC::JSValue exception) const
+void ScriptDebugServer::handleExceptionInBreakpointCondition(JSC::ExecState* exec, JSC::Exception* exception) const
 {
     reportException(exec, exception);

trunk/Source/JavaScriptCore/inspector/ScriptDebugServer.h ¶

@@ -80 +80 @@
     virtual void runEventLoopWhilePaused() = 0;
     virtual bool isContentScript(JSC::ExecState*) const = 0;
-    virtual void reportException(JSC::ExecState*, JSC::JSValue) const = 0;
+    virtual void reportException(JSC::ExecState*, JSC::Exception*) const = 0;
 
     bool evaluateBreakpointAction(const ScriptBreakpointAction&);
@@ -102 +102 @@
     virtual bool needPauseHandling(JSC::JSGlobalObject*) override final { return true; }
     virtual void handleBreakpointHit(JSC::JSGlobalObject*, const JSC::Breakpoint&) override final;
-    virtual void handleExceptionInBreakpointCondition(JSC::ExecState*, JSC::JSValue exception) const override final;
+    virtual void handleExceptionInBreakpointCondition(JSC::ExecState*, JSC::Exception*) const override final;
     virtual void handlePause(JSC::JSGlobalObject*, JSC::Debugger::ReasonForPause) override final;
     virtual void notifyDoneProcessingDebuggerEvents() override final;

trunk/Source/JavaScriptCore/interpreter/CallFrame.h ¶

@@ -25 +25 @@
 
 #include "AbstractPC.h"
-#include "VM.h"
 #include "JSStack.h"
 #include "MacroAssemblerCodeRef.h"
 #include "Register.h"
 #include "StackVisitor.h"
+#include "VM.h"
 #include "VMEntryRecord.h"
 
@@ -76 +76 @@
 
         void clearException() { vm().clearException(); }
-        void clearSupplementaryExceptionInfo()
-        {
-            vm().clearExceptionStack();
-        }
-
-        JSValue exception() const { return vm().exception(); }
-        bool hadException() const { return !vm().exception().isEmpty(); }
+
+        Exception* exception() const { return vm().exception(); }
+        bool hadException() const { return !!vm().exception(); }
 
         AtomicStringTable* atomicStringTable() const { return vm().atomicStringTable(); }

trunk/Source/JavaScriptCore/interpreter/Interpreter.cpp ¶

@@ -42 +42 @@
 #include "ErrorInstance.h"
 #include "EvalCodeCache.h"
+#include "Exception.h"
 #include "ExceptionHelpers.h"
 #include "GetterSetter.h"
@@ -436 +437 @@
     CallFrame* callFrame = visitor->callFrame();
     if (Debugger* debugger = callFrame->vmEntryGlobalObject()->debugger()) {
-        ClearExceptionScope scope(&callFrame->vm());
+        SuspendExceptionScope scope(&callFrame->vm());
         if (jsDynamicCast<JSFunction*>(callFrame->callee()))
             debugger->returnEvent(callFrame);
@@ -584 +585 @@
 }
 
-class GetExceptionHandlerFunctor {
+class GetCatchHandlerFunctor {
 public:
-    GetExceptionHandlerFunctor()
+    GetCatchHandlerFunctor()
         : m_handler(0)
     {
@@ -600 +601 @@
 
         unsigned bytecodeOffset = visitor->bytecodeOffset();
-        m_handler = codeBlock->handlerForBytecodeOffset(bytecodeOffset);
+        m_handler = codeBlock->handlerForBytecodeOffset(bytecodeOffset, CodeBlock::RequiredHandler::CatchHandler);
         if (m_handler)
             return StackVisitor::Done;
@@ -650 +651 @@
 };
 
-NEVER_INLINE HandlerInfo* Interpreter::unwind(VMEntryFrame*& vmEntryFrame, CallFrame*& callFrame, JSValue& exceptionValue)
+NEVER_INLINE HandlerInfo* Interpreter::unwind(VMEntryFrame*& vmEntryFrame, CallFrame*& callFrame, Exception* exception)
 {
     CodeBlock* codeBlock = callFrame->codeBlock();
     bool isTermination = false;
 
+    JSValue exceptionValue = exception->value();
     ASSERT(!exceptionValue.isEmpty());
     ASSERT(!exceptionValue.isCell() || exceptionValue.asCell());
@@ -663 +665 @@
 
     if (exceptionValue.isObject())
-        isTermination = isTerminatedExecutionException(asObject(exceptionValue));
-
-    ASSERT(callFrame->vm().exceptionStack().size());
+        isTermination = isTerminatedExecutionException(exception);
+
+    ASSERT(callFrame->vm().exception() && callFrame->vm().exception()->stack().size());
 
     Debugger* debugger = callFrame->vmEntryGlobalObject()->debugger();
-    if (debugger && debugger->needsExceptionCallbacks()) {
-        // We need to clear the exception and the exception stack here in order to see if a new exception happens.
+    if (debugger && debugger->needsExceptionCallbacks() && !exception->didNotifyInspectorOfThrow()) {
+        // We need to clear the exception here in order to see if a new exception happens.
         // Afterwards, the values are put back to continue processing this error.
-        ClearExceptionScope scope(&callFrame->vm());
+        SuspendExceptionScope scope(&callFrame->vm());
         // This code assumes that if the debugger is enabled then there is no inlining.
         // If that assumption turns out to be false then we'll ignore the inlined call
@@ -677 +679 @@
         // https://bugs.webkit.org/show_bug.cgi?id=121754
 
-        bool hasHandler;
+        bool hasCatchHandler;
         if (isTermination)
-            hasHandler = false;
+            hasCatchHandler = false;
         else {
-            GetExceptionHandlerFunctor functor;
+            GetCatchHandlerFunctor functor;
             callFrame->iterate(functor);
-            hasHandler = !!functor.handler();
-        }
-
-        debugger->exception(callFrame, exceptionValue, hasHandler);
+            HandlerInfo* handler = functor.handler();
+            ASSERT(!handler || handler->isCatchHandler());
+            hasCatchHandler = !!handler;
+        }
+
+        debugger->exception(callFrame, exceptionValue, hasCatchHandler);
         ASSERT(!callFrame->hadException());
     }
+    exception->setDidNotifyInspectorOfThrow();
 
     // Calculate an exception handler vPC, unwinding call frames as necessary.

trunk/Source/JavaScriptCore/interpreter/Interpreter.h ¶

@@ -99 +99 @@
     };
 
-    class ClearExceptionScope {
-    public:
-        ClearExceptionScope(VM* vm): m_vm(vm)
-        {
-            vm->getExceptionInfo(oldException, oldExceptionStack);
+    class SuspendExceptionScope {
+    public:
+        SuspendExceptionScope(VM* vm)
+            : m_vm(vm)
+        {
+            oldException = vm->exception();
             vm->clearException();
         }
-        ~ClearExceptionScope()
-        {
-            m_vm->setExceptionInfo(oldException, oldExceptionStack);
-        }
-    private:
-        JSC::JSValue oldException;
-        RefCountedArray<JSC::StackFrame> oldExceptionStack;
+        ~SuspendExceptionScope()
+        {
+            m_vm->setException(oldException);
+        }
+    private:
+        Exception* oldException;
         VM* m_vm;
     };
@@ -216 +216 @@
         SamplingTool* sampler() { return m_sampler.get(); }
 
-        NEVER_INLINE HandlerInfo* unwind(VMEntryFrame*&, CallFrame*&, JSValue&);
+        NEVER_INLINE HandlerInfo* unwind(VMEntryFrame*&, CallFrame*&, Exception*);
         NEVER_INLINE void debug(CallFrame*, DebugHookID);
         JSString* stackTraceAsString(ExecState*, Vector<StackFrame>);

trunk/Source/JavaScriptCore/jit/AssemblyHelpers.cpp ¶

@@ -224 +224 @@
     result = branchTest64(kind == NormalExceptionCheck ? NonZero : Zero, AbsoluteAddress(vm()->addressOfException()));
 #elif USE(JSVALUE32_64)
-    result = branch32(kind == NormalExceptionCheck ? NotEqual : Equal, AbsoluteAddress(reinterpret_cast<char*>(vm()->addressOfException()) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag));
+    result = branch32(kind == NormalExceptionCheck ? NotEqual : Equal, AbsoluteAddress(vm()->addressOfException()), TrustedImm32(0));
 #endif
     

trunk/Source/JavaScriptCore/jit/JITExceptions.cpp ¶

@@ -41 +41 @@
 namespace JSC {
 
-void genericUnwind(VM* vm, ExecState* callFrame, JSValue exceptionValue)
+void genericUnwind(VM* vm, ExecState* callFrame)
 {
     if (Options::breakOnThrow()) {
@@ -48 +48 @@
     }
     
-    RELEASE_ASSERT(exceptionValue);
+    Exception* exception = vm->exception();
+    RELEASE_ASSERT(exception);
     VMEntryFrame* vmEntryFrame = vm->topVMEntryFrame;
-    HandlerInfo* handler = vm->interpreter->unwind(vmEntryFrame, callFrame, exceptionValue); // This may update vmEntryFrame and callFrame.
+    HandlerInfo* handler = vm->interpreter->unwind(vmEntryFrame, callFrame, exception); // This may update vmEntryFrame and callFrame.
 
     void* catchRoutine;

trunk/Source/JavaScriptCore/jit/JITExceptions.h ¶

@@ -34 +34 @@
 class VM;
 
-void genericUnwind(VM*, ExecState*, JSValue exceptionValue);
+void genericUnwind(VM*, ExecState*);
 
 } // namespace JSC

trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp ¶

@@ -32 +32 @@
 #include "CopiedSpaceInlines.h"
 #include "Debugger.h"
+#include "Exception.h"
 #include "Heap.h"
 #include "JITInlines.h"
@@ -530 +531 @@
     store64(TrustedImm64(JSValue::encode(JSValue())), Address(regT3, VM::exceptionOffset()));
     emitPutVirtualRegister(currentInstruction[1].u.operand);
+
+    load64(Address(regT0, Exception::valueOffset()), regT0);
+    emitPutVirtualRegister(currentInstruction[2].u.operand);
 }
 

trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp ¶

@@ -33 +33 @@
 #include "CCallHelpers.h"
 #include "Debugger.h"
+#include "Exception.h"
 #include "JITInlines.h"
 #include "JSArray.h"
@@ -98 +99 @@
 
     // Check for an exception
-    Jump sawException = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(vm->addressOfException()) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag)); 
+    Jump sawException = branch32(NotEqual, AbsoluteAddress(vm->addressOfException()), TrustedImm32(0));
 
     emitFunctionEpilogue();
@@ -830 +831 @@
 
     // Now store the exception returned by operationThrow.
-    load32(Address(regT3, VM::exceptionOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
-    load32(Address(regT3, VM::exceptionOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
-    store32(TrustedImm32(JSValue().payload()), Address(regT3, VM::exceptionOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
-    store32(TrustedImm32(JSValue().tag()), Address(regT3, VM::exceptionOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
+    load32(Address(regT3, VM::exceptionOffset()), regT2);
+    move(TrustedImm32(JSValue::CellTag), regT1);
+
+    store32(TrustedImm32(0), Address(regT3, VM::exceptionOffset()));
 
     unsigned exception = currentInstruction[1].u.operand;
-    emitStore(exception, regT1, regT0);
+    emitStore(exception, regT1, regT2);
+
+    load32(Address(regT2, Exception::valueOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
+    load32(Address(regT2, Exception::valueOffset() + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
+
+    unsigned thrownValue = currentInstruction[2].u.operand;
+    emitStore(thrownValue, regT1, regT0);
 }
 

trunk/Source/JavaScriptCore/jit/JITOperations.cpp ¶

@@ -1919 +1919 @@
 
     // Results stored out-of-band in vm.targetMachinePCForThrow, vm.callFrameForThrow & vm.vmEntryFrameForThrow
-    genericUnwind(vm, exec, exceptionValue);
+    genericUnwind(vm, exec);
 }
 
@@ -1958 +1958 @@
 {
     NativeCallFrameTracer tracer(vm, exec);
-
-    JSValue exceptionValue = vm->exception();
-    ASSERT(exceptionValue);
-    
-    genericUnwind(vm, exec, exceptionValue);
+    genericUnwind(vm, exec);
     ASSERT(vm->targetMachinePCForThrow);
 }
@@ -1973 +1969 @@
 
     NativeCallFrameTracerWithRestore tracer(vm, vmEntryFrame, callerFrame);
-
-    JSValue exceptionValue = vm->exception();
-    ASSERT(exceptionValue);
-    
-    genericUnwind(vm, callerFrame, exceptionValue);
+    genericUnwind(vm, callerFrame);
     ASSERT(vm->targetMachinePCForThrow);
 }
@@ -1985 +1977 @@
     VM* vm = &exec->vm();
     NativeCallFrameTracer tracer(vm, exec);
-
-    genericUnwind(vm, exec, vm->exception());
+    genericUnwind(vm, exec);
 }
 

trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp ¶

@@ -350 +350 @@
     JSInterfaceJIT::Jump exceptionHandler = jit.branch32(
         JSInterfaceJIT::NotEqual,
-        JSInterfaceJIT::AbsoluteAddress(reinterpret_cast<char*>(vm->addressOfException()) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)),
-        JSInterfaceJIT::TrustedImm32(JSValue::EmptyValueTag));
+        JSInterfaceJIT::AbsoluteAddress(vm->addressOfException()),
+        JSInterfaceJIT::TrustedImm32(0));
 #endif
 

trunk/Source/JavaScriptCore/jsc.cpp ¶

@@ -30 +30 @@
 #include "CopiedSpaceInlines.h"
 #include "Disassembler.h"
+#include "Exception.h"
 #include "ExceptionHelpers.h"
 #include "HeapStatistics.h"
@@ -900 +901 @@
         exec->vm(), Identifier::fromString(globalObject->globalExec(), "arguments"), array);
 
-    JSValue exception;
+    Exception* exception;
     StopWatch stopWatch;
     stopWatch.start();
-    evaluate(globalObject->globalExec(), jscSource(script.data(), fileName), JSValue(), &exception);
+    evaluate(globalObject->globalExec(), jscSource(script.data(), fileName), JSValue(), exception);
     stopWatch.stop();
 
-    if (!!exception) {
+    if (exception) {
         exec->vm().throwException(globalObject->globalExec(), exception);
         return JSValue::encode(jsUndefined());
@@ -923 +924 @@
     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
     
-    JSValue evaluationException;
-    JSValue result = evaluate(globalObject->globalExec(), jscSource(script.data(), fileName), JSValue(), &evaluationException);
+    Exception* evaluationException;
+    JSValue result = evaluate(globalObject->globalExec(), jscSource(script.data(), fileName), JSValue(), evaluationException);
     if (evaluationException)
         exec->vm().throwException(exec, evaluationException);
@@ -1286 +1287 @@
         vm.startSampling();
 
-        JSValue evaluationException;
-        JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), &evaluationException);
+        Exception* evaluationException;
+        JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), evaluationException);
         success = success && !evaluationException;
         if (dump && !evaluationException)
             printf("End: %s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
         if (evaluationException) {
-            printf("Exception: %s\n", evaluationException.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
+            printf("Exception: %s\n", evaluationException->value().toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
             Identifier stackID = Identifier::fromString(globalObject->globalExec(), "stack");
-            JSValue stackValue = evaluationException.get(globalObject->globalExec(), stackID);
+            JSValue stackValue = evaluationException->value().get(globalObject->globalExec(), stackID);
             if (!stackValue.isUndefinedOrNull())
                 printf("%s\n", stackValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
@@ -1350 +1351 @@
         
         
-        JSValue evaluationException;
-        JSValue returnValue = evaluate(globalObject->globalExec(), makeSource(source, interpreterName), JSValue(), &evaluationException);
+        Exception* evaluationException;
+        JSValue returnValue = evaluate(globalObject->globalExec(), makeSource(source, interpreterName), JSValue(), evaluationException);
 #else
         printf("%s", interactivePrompt);
@@ -1366 +1367 @@
         line.append('\0');
 
-        JSValue evaluationException;
-        JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(line.data(), interpreterName), JSValue(), &evaluationException);
+        Exception* evaluationException;
+        JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(line.data(), interpreterName), JSValue(), evaluationException);
 #endif
         if (evaluationException)
-            printf("Exception: %s\n", evaluationException.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
+            printf("Exception: %s\n", evaluationException->value().toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
         else
             printf("%s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());

trunk/Source/JavaScriptCore/llint/LLIntOffsetsExtractor.cpp ¶

@@ -31 +31 @@
 #include "Debugger.h"
 #include "DirectArguments.h"
+#include "Exception.h"
 #include "Executable.h"
 #include "Heap.h"

trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp ¶

@@ -1376 +1376 @@
 {
     LLINT_BEGIN_NO_SET_PC();
-    ASSERT(vm.exception());
-    genericUnwind(&vm, exec, vm.exception());
+    genericUnwind(&vm, exec);
     LLINT_END_IMPL();
 }

trunk/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm ¶

@@ -694 +694 @@
     andp MarkedBlockMask, t3
     loadp MarkedBlock::m_weakSet + WeakSet::m_vm[t3], t3
-    bieq VM::m_exception + TagOffset[t3], EmptyValueTag, .noException
+    btiz VM::m_exception[t3], .noException
     jmp label
 .noException:
@@ -1953 +1953 @@
 
     loadi VM::targetInterpreterPCForThrow[t3], PC
-    loadi VM::m_exception + PayloadOffset[t3], t0
-    loadi VM::m_exception + TagOffset[t3], t1
-    storei 0, VM::m_exception + PayloadOffset[t3]
-    storei EmptyValueTag, VM::m_exception + TagOffset[t3]
+    loadi VM::m_exception[t3], t0
+    storei 0, VM::m_exception[t3]
     loadi 4[PC], t2
     storei t0, PayloadOffset[cfr, t2, 8]
+    storei CellTag, TagOffset[cfr, t2, 8]
+
+    loadi Exception::m_value + TagOffset[t0], t1
+    loadi Exception::m_value + PayloadOffset[t0], t0
+    loadi 8[PC], t2
+    storei t0, PayloadOffset[cfr, t2, 8]
     storei t1, TagOffset[cfr, t2, 8]
+
     traceExecution()  # This needs to be here because we don't want to clobber t0, t1, t2, t3 above.
-    dispatch(2)
+    dispatch(3)
 
 _llint_op_end:
@@ -2039 +2044 @@
     
     functionEpilogue()
-    bineq VM::m_exception + TagOffset[t3], EmptyValueTag, .handleException
+    btinz VM::m_exception[t3], .handleException
     ret
 

trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm ¶

@@ -1821 +1821 @@
     subp PB, PC
     rshiftp 3, PC
+
     loadq VM::m_exception[t3], t0
     storeq 0, VM::m_exception[t3]
     loadisFromInstruction(1, t2)
     storeq t0, [cfr, t2, 8]
-    traceExecution()
-    dispatch(2)
+
+    loadq Exception::m_value[t0], t3
+    loadisFromInstruction(2, t2)
+    storeq t3, [cfr, t2, 8]
+
+    traceExecution()
+    dispatch(3)
 
 

trunk/Source/JavaScriptCore/parser/NodeConstructors.h ¶

@@ -812 +812 @@
     }
 
-    inline TryNode::TryNode(const JSTokenLocation& location, StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock)
+    inline TryNode::TryNode(const JSTokenLocation& location, StatementNode* tryBlock, const Identifier& thrownValueIdent, StatementNode* catchBlock, StatementNode* finallyBlock)
         : StatementNode(location)
         , m_tryBlock(tryBlock)
-        , m_exceptionIdent(exceptionIdent)
+        , m_thrownValueIdent(thrownValueIdent)
         , m_catchBlock(catchBlock)
         , m_finallyBlock(finallyBlock)

trunk/Source/JavaScriptCore/parser/Nodes.h ¶

@@ -1512 +1512 @@
 
         StatementNode* m_tryBlock;
-        const Identifier& m_exceptionIdent;
+        const Identifier& m_thrownValueIdent;
         StatementNode* m_catchBlock;
         StatementNode* m_finallyBlock;

trunk/Source/JavaScriptCore/runtime/CallData.cpp ¶

@@ -27 +27 @@
 #include "CallData.h"
 
+#include "Exception.h"
 #include "Executable.h"
 #include "Interpreter.h"
@@ -40 +41 @@
 }
 
-JSValue call(ExecState* exec, JSValue functionObject, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args, JSValue* exception)
+JSValue call(ExecState* exec, JSValue functionObject, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args, Exception*& returnedException)
 {
     JSValue result = call(exec, functionObject, callType, callData, thisValue, args);
     if (exec->hadException()) {
-        if (exception)
-            *exception = exec->exception();
+        returnedException = exec->exception();
         exec->clearException();
         return jsUndefined();
-    }
+    } else
+        returnedException = nullptr;
     RELEASE_ASSERT(result);
     return result;

trunk/Source/JavaScriptCore/runtime/CallData.h ¶

@@ -35 +35 @@
 
 class ArgList;
+class Exception;
 class ExecState;
 class FunctionExecutable;
@@ -59 +60 @@
 
 JS_EXPORT_PRIVATE JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
-JS_EXPORT_PRIVATE JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&, JSValue* exception);
+JS_EXPORT_PRIVATE JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&, Exception*& returnedException);
 
 } // namespace JSC

trunk/Source/JavaScriptCore/runtime/Completion.cpp ¶

@@ -27 +27 @@
 #include "CodeProfiling.h"
 #include "Debugger.h"
+#include "Exception.h"
 #include "Interpreter.h"
 #include "JSGlobalObject.h"
@@ -61 +62 @@
 }
 
-JSValue evaluate(ExecState* exec, const SourceCode& source, JSValue thisValue, JSValue* returnedException)
+JSValue evaluate(ExecState* exec, const SourceCode& source, JSValue thisValue, Exception*& returnedException)
 {
     JSLockHolder lock(exec);
     RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
     RELEASE_ASSERT(!exec->vm().isCollectorBusy());
+    returnedException = nullptr;
 
     CodeProfiling profile(source);
@@ -71 +73 @@
     ProgramExecutable* program = ProgramExecutable::create(exec, source);
     if (!program) {
-        if (returnedException)
-            *returnedException = exec->vm().exception();
-
+        returnedException = exec->vm().exception();
         exec->vm().clearException();
         return jsUndefined();
@@ -84 +84 @@
 
     if (exec->hadException()) {
-        if (returnedException)
-            *returnedException = exec->exception();
-
+        returnedException = exec->exception();
         exec->clearException();
         return jsUndefined();

trunk/Source/JavaScriptCore/runtime/Completion.h ¶

@@ -27 +27 @@
 
 namespace JSC {
-    
+
+class Exception;
 class ExecState;
 class JSScope;
@@ -36 +37 @@
 JS_EXPORT_PRIVATE bool checkSyntax(VM&, const SourceCode&, ParserError&);
 JS_EXPORT_PRIVATE bool checkSyntax(ExecState*, const SourceCode&, JSValue* exception = 0);
-JS_EXPORT_PRIVATE JSValue evaluate(ExecState*, const SourceCode&, JSValue thisValue = JSValue(), JSValue* exception = 0);
+JS_EXPORT_PRIVATE JSValue evaluate(ExecState*, const SourceCode&, JSValue thisValue, Exception*& returnedException);
+inline JSValue evaluate(ExecState* exec, const SourceCode& sourceCode, JSValue thisValue = JSValue())
+{
+    Exception* unused;
+    return evaluate(exec, sourceCode, thisValue, unused);
+}
 
 } // namespace JSC

trunk/Source/JavaScriptCore/runtime/Error.h ¶

@@ -77 +77 @@
 
 // Convenience wrappers, wrap result as an EncodedJSValue.
+inline void throwVMError(ExecState* exec, Exception* exception) { exec->vm().throwException(exec, exception); }
 inline EncodedJSValue throwVMError(ExecState* exec, JSValue error) { return JSValue::encode(exec->vm().throwException(exec, error)); }
 inline EncodedJSValue throwVMTypeError(ExecState* exec) { return JSValue::encode(throwTypeError(exec)); }

trunk/Source/JavaScriptCore/runtime/ExceptionHelpers.cpp ¶

@@ -33 +33 @@
 #include "CallFrame.h"
 #include "ErrorHandlingScope.h"
+#include "Exception.h"
 #include "JSGlobalObjectFunctions.h"
 #include "JSNotAnObject.h"
@@ -60 +61 @@
 }
 
-bool isTerminatedExecutionException(JSObject* object)
-{
-    return object->inherits(TerminatedExecutionError::info());
-}
-
-bool isTerminatedExecutionException(JSValue value)
-{
-    return value.inherits(TerminatedExecutionError::info());
-}
-
+bool isTerminatedExecutionException(Exception* exception)
+{
+    return exception->value().inherits(TerminatedExecutionError::info());
+}
 
 JSObject* createStackOverflowError(ExecState* exec)

trunk/Source/JavaScriptCore/runtime/ExceptionHelpers.h ¶

@@ -38 +38 @@
 
 JSObject* createTerminatedExecutionException(VM*);
-bool isTerminatedExecutionException(JSObject*);
-JS_EXPORT_PRIVATE bool isTerminatedExecutionException(JSValue);
+JS_EXPORT_PRIVATE bool isTerminatedExecutionException(Exception*);
 JS_EXPORT_PRIVATE JSObject* createError(ExecState*, JSValue, const String&, ErrorInstance::SourceAppender);
 JS_EXPORT_PRIVATE JSObject* createStackOverflowError(ExecState*);

trunk/Source/JavaScriptCore/runtime/GetterSetter.cpp ¶

@@ -25 +25 @@
 
 #include "Error.h"
+#include "Exception.h"
 #include "JSObject.h"
 #include "JSCInlines.h"
@@ -76 +77 @@
     // We work around that by checking here.
     if (exec->hadException())
-        return exec->exception();
+        return exec->exception()->value();
 
     JSObject* getter = jsCast<GetterSetter*>(getterSetter)->getter();

trunk/Source/JavaScriptCore/runtime/IteratorOperations.cpp ¶

@@ -90 +90 @@
 void iteratorClose(ExecState* exec, JSValue iterator)
 {
-    JSValue exception;
+    Exception* exception = nullptr;
     if (exec->hadException()) {
         exception = exec->exception();
@@ -100 +100 @@
 
     if (returnFunction.isUndefined()) {
-        if (!exception.isEmpty())
+        if (exception)
             exec->vm().throwException(exec, exception);
         return;
@@ -108 +108 @@
     CallType returnFunctionCallType = getCallData(returnFunction, returnFunctionCallData);
     if (returnFunctionCallType == CallTypeNone) {
-        if (!exception.isEmpty())
+        if (exception)
             exec->vm().throwException(exec, exception);
         else
@@ -118 +118 @@
     JSValue innerResult = call(exec, returnFunction, returnFunctionCallType, returnFunctionCallData, iterator, returnFunctionArguments);
 
-    if (!exception.isEmpty()) {
+    if (exception) {
         exec->vm().throwException(exec, exception);
         return;

trunk/Source/JavaScriptCore/runtime/JSObject.cpp ¶

@@ -32 +32 @@
 #include "DatePrototype.h"
 #include "ErrorConstructor.h"
+#include "Exception.h"
 #include "Executable.h"
 #include "GetterSetter.h"

trunk/Source/JavaScriptCore/runtime/JSPromiseConstructor.cpp ¶

@@ -30 +30 @@
 
 #include "Error.h"
+#include "Exception.h"
 #include "IteratorOperations.h"
 #include "JSCJSValueInlines.h"
@@ -137 +138 @@
     // 14. If result is an abrupt completion, call PromiseReject(promise, result.[[value]]).
     if (exec->hadException()) {
-        JSValue exception = exec->exception();
+        JSValue exception = exec->exception()->value();
         exec->clearException();
 

trunk/Source/JavaScriptCore/runtime/JSPromiseDeferred.cpp ¶

@@ -30 +30 @@
 
 #include "Error.h"
+#include "Exception.h"
 #include "JSCJSValueInlines.h"
 #include "JSCellInlines.h"
@@ -151 +152 @@
         //    deferred.[[Reject]] with undefined as thisArgument and a List containing
         //    then.[[value]] as argumentsList.
-        JSValue exception = exec->exception();
+        JSValue exception = exec->exception()->value();
         exec->clearException();
 
@@ -186 +187 @@
         //    deferred.[[Reject]] with undefined as thisArgument and a List containing
         //    thenCallResult.[[value]] as argumentsList.
-        JSValue exception = exec->exception();
+        JSValue exception = exec->exception()->value();
         exec->clearException();
 
@@ -229 +230 @@
 {
     ASSERT(exec->hadException());
-    JSValue argument = exec->exception();
+    JSValue argument = exec->exception()->value();
     exec->clearException();
 

trunk/Source/JavaScriptCore/runtime/JSPromiseReaction.cpp ¶

@@ -30 +30 @@
 
 #include "Error.h"
+#include "Exception.h"
 #include "JSCJSValueInlines.h"
 #include "JSCellInlines.h"
@@ -89 +90 @@
     //    and a List containing handlerResult.[[value]] as argumentsList.
     if (exec->hadException()) {
-        JSValue exception = exec->exception();
+        JSValue exception = exec->exception()->value();
         exec->clearException();
 

trunk/Source/JavaScriptCore/runtime/VM.cpp ¶

@@ -43 +43 @@
 #include "Disassembler.h"
 #include "ErrorInstance.h"
+#include "Exception.h"
 #include "FTLThunks.h"
 #include "FunctionConstructor.h"
@@ -236 +237 @@
     inferredValueStructure.set(*this, InferredValue::createStructure(*this, 0, jsNull()));
     functionRareDataStructure.set(*this, FunctionRareData::createStructure(*this, 0, jsNull()));
+    exceptionStructure.set(*this, Exception::createStructure(*this, 0, jsNull()));
 #if ENABLE(PROMISES)
     promiseDeferredStructure.set(*this, JSPromiseDeferred::createStructure(*this, 0, jsNull()));
@@ -546 +548 @@
 }
 
-JSValue VM::throwException(ExecState* exec, JSValue error)
+void VM::throwException(ExecState* exec, Exception* exception)
 {
     if (Options::breakOnThrow()) {
@@ -554 +556 @@
     
     ASSERT(exec == topCallFrame || exec == exec->lexicalGlobalObject()->globalExec() || exec == exec->vmEntryGlobalObject()->globalExec());
-    
-    Vector<StackFrame> stackTrace;
-    interpreter->getStackTrace(stackTrace);
-    m_exceptionStack = RefCountedArray<StackFrame>(stackTrace);
-    m_exception = error;
-
-    return error;
-}
-    
+    setException(exception);
+}
+
+JSValue VM::throwException(ExecState* exec, JSValue thrownValue)
+{
+    Exception* exception = jsDynamicCast<Exception*>(thrownValue);
+    if (!exception)
+        exception = Exception::create(*this, thrownValue);
+
+    throwException(exec, exception);
+    return JSValue(exception);
+}
+
 JSObject* VM::throwException(ExecState* exec, JSObject* error)
 {
     return asObject(throwException(exec, JSValue(error)));
-}
-void VM::getExceptionInfo(JSValue& exception, RefCountedArray<StackFrame>& exceptionStack)
-{
-    exception = m_exception;
-    exceptionStack = m_exceptionStack;
-}
-void VM::setExceptionInfo(JSValue& exception, RefCountedArray<StackFrame>& exceptionStack)
-{
-    m_exception = exception;
-    m_exceptionStack = exceptionStack;
-}
-
-void VM::clearException()
-{
-    m_exception = JSValue();
-}
-void VM:: clearExceptionStack()
-{
-    m_exceptionStack = RefCountedArray<StackFrame>();
 }
 

trunk/Source/JavaScriptCore/runtime/VM.h ¶

@@ -59 +59 @@
 #include <wtf/HashMap.h>
 #include <wtf/HashSet.h>
-#include <wtf/RefCountedArray.h>
 #include <wtf/SimpleStats.h>
 #include <wtf/StackBounds.h>
@@ -79 +78 @@
 class CommonIdentifiers;
 class ExecState;
+class Exception;
 class HandleStack;
 class TypeProfiler;
@@ -275 +275 @@
     Strong<Structure> inferredValueStructure;
     Strong<Structure> functionRareDataStructure;
+    Strong<Structure> exceptionStructure;
 #if ENABLE(PROMISES)
     Strong<Structure> promiseDeferredStructure;
@@ -373 +374 @@
     }
 
-    JS_EXPORT_PRIVATE void clearException();
-    JS_EXPORT_PRIVATE void clearExceptionStack();
-    void getExceptionInfo(JSValue& exception, RefCountedArray<StackFrame>& exceptionStack);
-    void setExceptionInfo(JSValue& exception, RefCountedArray<StackFrame>& exceptionStack);
-    JSValue exception() const { return m_exception; }
-    JSValue* addressOfException() { return &m_exception; }
-    const RefCountedArray<StackFrame>& exceptionStack() const { return m_exceptionStack; }
-
+    void clearException() { m_exception = nullptr; }
+    void setException(Exception* exception) { m_exception = exception; }
+
+    Exception* exception() const { return m_exception; }
+    JSCell** addressOfException() { return reinterpret_cast<JSCell**>(&m_exception); }
+
+    JS_EXPORT_PRIVATE void throwException(ExecState*, Exception*);
     JS_EXPORT_PRIVATE JSValue throwException(ExecState*, JSValue);
     JS_EXPORT_PRIVATE JSObject* throwException(ExecState*, JSObject*);
@@ -570 +570 @@
 #endif
     void* m_lastStackTop;
-    JSValue m_exception;
+    Exception* m_exception { nullptr };
     bool m_inDefineOwnProperty;
     std::unique_ptr<CodeCache> m_codeCache;
     LegacyProfiler* m_enabledProfiler;
     std::unique_ptr<BuiltinExecutables> m_builtinExecutables;
-    RefCountedArray<StackFrame> m_exceptionStack;
     HashMap<String, RefPtr<WatchpointSet>> m_impurePropertyWatchpointSets;
     std::unique_ptr<TypeProfiler> m_typeProfiler;

trunk/Source/JavaScriptCore/runtime/VMEntryScope.cpp ¶

@@ -50 +50 @@
         vm.resetDateCache();
     }
-
-    // Clear the captured exception stack between entries
-    vm.clearExceptionStack();
 }
 

trunk/Source/WebCore/ChangeLog ¶

@@ +1 @@
+2015-06-05  Mark Lam  <mark.lam@apple.com>
+
+        finally blocks should not set the exception stack trace when re-throwing the exception.
+        https://bugs.webkit.org/show_bug.cgi?id=145525
+
+        Reviewed by Geoffrey Garen.
+
+        Update to use the new JSC::Exception object.
+
+        Test: inspector/debugger/break-on-exceptions.html
+
+        * ForwardingHeaders/runtime/Exception.h: Added.
+        * bindings/js/JSCallbackData.cpp:
+        (WebCore::JSCallbackData::invokeCallback):
+        * bindings/js/JSCustomXPathNSResolver.cpp:
+        (WebCore::JSCustomXPathNSResolver::lookupNamespaceURI):
+        * bindings/js/JSDOMBinding.cpp:
+        (WebCore::jsArray):
+        (WebCore::reportException):
+        (WebCore::reportCurrentException):
+        * bindings/js/JSDOMBinding.h:
+        * bindings/js/JSErrorHandler.cpp:
+        (WebCore::JSErrorHandler::handleEvent):
+        * bindings/js/JSEventListener.cpp:
+        (WebCore::JSEventListener::handleEvent):
+        * bindings/js/JSMainThreadExecState.cpp:
+        (WebCore::JSMainThreadExecState::didLeaveScriptContext):
+        (WebCore::functionCallHandlerFromAnyThread):
+        (WebCore::evaluateHandlerFromAnyThread):
+        * bindings/js/JSMainThreadExecState.h:
+        (WebCore::JSMainThreadExecState::currentState):
+        (WebCore::JSMainThreadExecState::call):
+        (WebCore::JSMainThreadExecState::evaluate):
+        (WebCore::JSMainThreadExecState::runTask):
+
+        * bindings/js/JSMediaDevicesCustom.cpp:
+        (WebCore::JSMediaDevices::getUserMedia):
+        - Fixed a bug where the exception was not cleared before entering the VM to
+          call JS code.
+
+        * bindings/js/JSMutationCallback.cpp:
+        (WebCore::JSMutationCallback::call):
+        * bindings/js/ReadableJSStream.cpp:
+        (WebCore::getPropertyFromObject):
+        (WebCore::callFunction):
+        (WebCore::ReadableJSStream::Source::start):
+        * bindings/js/ScheduledAction.cpp:
+        (WebCore::ScheduledAction::executeFunctionInContext):
+        * bindings/js/ScriptController.cpp:
+        (WebCore::ScriptController::evaluateInWorld):
+        * bindings/js/SerializedScriptValue.cpp:
+        (WebCore::SerializedScriptValue::create):
+        (WebCore::SerializedScriptValue::deserialize):
+        * bindings/js/WorkerScriptController.cpp:
+        (WebCore::WorkerScriptController::evaluate):
+        (WebCore::WorkerScriptController::setException):
+        (WebCore::WorkerScriptController::scheduleExecutionTermination):
+        * bindings/js/WorkerScriptController.h:
+        (WebCore::WorkerScriptController::workerGlobalScopeWrapper):
+        * bindings/js/WorkerScriptDebugServer.cpp:
+        (WebCore::WorkerScriptDebugServer::runEventLoopWhilePaused):
+        (WebCore::WorkerScriptDebugServer::reportException):
+        * bindings/js/WorkerScriptDebugServer.h:
+        * bindings/objc/WebScriptObject.mm:
+        (WebCore::createJSWrapper):
+        (WebCore::addExceptionToConsole):
+        (-[WebScriptObject callWebScriptMethod:withArguments:]):
+        (-[WebScriptObject evaluateWebScript:]):
+        - Changed to call a version of JSMainThreadExecState::evaluate() that provides
+          a stub returnedException because evaluateWebScript: doesn't need the exception.
+
+        * inspector/PageScriptDebugServer.cpp:
+        (WebCore::PageScriptDebugServer::isContentScript):
+        (WebCore::PageScriptDebugServer::reportException):
+        * inspector/PageScriptDebugServer.h:
+        * workers/WorkerGlobalScope.cpp:
+        (WebCore::WorkerGlobalScope::importScripts):
+
 2015-06-05  Eric Carlson  <eric.carlson@apple.com>
 

trunk/Source/WebCore/bindings/js/JSCallbackData.cpp ¶

@@ -74 +74 @@
     InspectorInstrumentationCookie cookie = JSMainThreadExecState::instrumentFunctionCall(context, callType, callData);
 
-    JSValue exception;
+    Exception* exception;
     JSValue result = context->isDocument()
-        ? JSMainThreadExecState::call(exec, function, callType, callData, thisValue, args, &exception)
-        : JSC::call(exec, function, callType, callData, thisValue, args, &exception);
+        ? JSMainThreadExecState::call(exec, function, callType, callData, thisValue, args, exception)
+        : JSC::call(exec, function, callType, callData, thisValue, args, exception);
 
     InspectorInstrumentation::didCallFunction(cookie, context);

trunk/Source/WebCore/bindings/js/JSCustomXPathNSResolver.cpp ¶

@@ -94 +94 @@
     args.append(jsStringWithCache(exec, prefix));
 
-    JSValue exception;
-    JSValue retval = JSMainThreadExecState::call(exec, function, callType, callData, m_customResolver.get(), args, &exception);
+    Exception* exception;
+    JSValue retval = JSMainThreadExecState::call(exec, function, callType, callData, m_customResolver.get(), args, exception);
 
     String result;

trunk/Source/WebCore/bindings/js/JSDOMBinding.cpp ¶

@@ -41 +41 @@
 #include <runtime/Error.h>
 #include <runtime/ErrorHandlingScope.h>
+#include <runtime/Exception.h>
 #include <runtime/ExceptionHelpers.h>
 #include <runtime/JSFunction.h>
@@ -139 +140 @@
 }
 
-void reportException(ExecState* exec, JSValue exception, CachedScript* cachedScript)
+void reportException(ExecState* exec, Exception* exception, CachedScript* cachedScript)
 {
     RELEASE_ASSERT(exec->vm().currentThreadIsHoldingAPILock());
@@ -149 +150 @@
     RefPtr<ScriptCallStack> callStack(createScriptCallStackFromException(exec, exception, ScriptCallStack::maxCallStackSizeToCapture));
     exec->clearException();
-    exec->clearSupplementaryExceptionInfo();
 
     JSDOMGlobalObject* globalObject = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject());
@@ -167 +167 @@
 
     String errorMessage;
-    if (ExceptionBase* exceptionBase = toExceptionBase(exception))
+    if (ExceptionBase* exceptionBase = toExceptionBase(exception->value()))
         errorMessage = exceptionBase->message() + ": "  + exceptionBase->description();
     else {
         // FIXME: <http://webkit.org/b/115087> Web Inspector: WebCore::reportException should not evaluate JavaScript handling exceptions
         // If this is a custon exception object, call toString on it to try and get a nice string representation for the exception.
-        errorMessage = exception.toString(exec)->value(exec);
+        errorMessage = exception->value().toString(exec)->value(exec);
         exec->clearException();
-        exec->clearSupplementaryExceptionInfo();
     }
 
@@ -183 +182 @@
 void reportCurrentException(ExecState* exec)
 {
-    JSValue exception = exec->exception();
+    Exception* exception = exec->exception();
     exec->clearException();
     reportException(exec, exception);

trunk/Source/WebCore/bindings/js/JSDOMBinding.h ¶

@@ -248 +248 @@
 const JSC::HashTable& getHashTableForGlobalData(JSC::VM&, const JSC::HashTable& staticTable);
 
-WEBCORE_EXPORT void reportException(JSC::ExecState*, JSC::JSValue exception, CachedScript* = nullptr);
+WEBCORE_EXPORT void reportException(JSC::ExecState*, JSC::Exception*, CachedScript* = nullptr);
 void reportCurrentException(JSC::ExecState*);
 

trunk/Source/WebCore/bindings/js/JSErrorHandler.cpp ¶

@@ -99 +99 @@
         VMEntryScope entryScope(vm, vm.entryScope ? vm.entryScope->globalObject() : globalObject);
 
-        JSValue exception;
+        Exception* exception;
         JSValue returnValue = scriptExecutionContext->isDocument()
-            ? JSMainThreadExecState::call(exec, jsFunction, callType, callData, globalObject, args, &exception)
-            : JSC::call(exec, jsFunction, callType, callData, globalObject, args, &exception);
+            ? JSMainThreadExecState::call(exec, jsFunction, callType, callData, globalObject, args, exception)
+            : JSC::call(exec, jsFunction, callType, callData, globalObject, args, exception);
 
         globalObject->setCurrentEvent(savedEvent);

trunk/Source/WebCore/bindings/js/JSEventListener.cpp ¶

@@ -125 +125 @@
 
         JSValue thisValue = handleEventFunction == jsFunction ? toJS(exec, globalObject, event->currentTarget()) : jsFunction;
-        JSValue exception;
+        Exception* exception;
         JSValue retval = scriptExecutionContext->isDocument()
-            ? JSMainThreadExecState::call(exec, handleEventFunction, callType, callData, thisValue, args, &exception)
-            : JSC::call(exec, handleEventFunction, callType, callData, thisValue, args, &exception);
+            ? JSMainThreadExecState::call(exec, handleEventFunction, callType, callData, thisValue, args, exception)
+            : JSC::call(exec, handleEventFunction, callType, callData, thisValue, args, exception);
 
         InspectorInstrumentation::didCallFunction(cookie, scriptExecutionContext);

trunk/Source/WebCore/bindings/js/JSMainThreadExecState.cpp ¶

@@ -47 +47 @@
 }
 
-JSC::JSValue functionCallHandlerFromAnyThread(JSC::ExecState* exec, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::JSValue* exception)
+JSC::JSValue functionCallHandlerFromAnyThread(JSC::ExecState* exec, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::Exception*& returnedException)
 {
     if (isMainThread())
-        return JSMainThreadExecState::call(exec, functionObject, callType, callData, thisValue, args, exception);
-    return JSC::call(exec, functionObject, callType, callData, thisValue, args, exception);
+        return JSMainThreadExecState::call(exec, functionObject, callType, callData, thisValue, args, returnedException);
+    return JSC::call(exec, functionObject, callType, callData, thisValue, args, returnedException);
 }
 
-JSC::JSValue evaluateHandlerFromAnyThread(JSC::ExecState* exec, const JSC::SourceCode& source, JSC::JSValue thisValue, JSC::JSValue* exception)
+JSC::JSValue evaluateHandlerFromAnyThread(JSC::ExecState* exec, const JSC::SourceCode& source, JSC::JSValue thisValue, JSC::Exception*& returnedException)
 {
     if (isMainThread())
-        return JSMainThreadExecState::evaluate(exec, source, thisValue, exception);
-    return JSC::evaluate(exec, source, thisValue, exception);
+        return JSMainThreadExecState::evaluate(exec, source, thisValue, returnedException);
+    return JSC::evaluate(exec, source, thisValue, returnedException);
 }
 

trunk/Source/WebCore/bindings/js/JSMainThreadExecState.h ¶

@@ -51 +51 @@
     };
     
-    static JSC::JSValue call(JSC::ExecState* exec, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::JSValue* exception)
+    static JSC::JSValue call(JSC::ExecState* exec, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::Exception*& returnedException)
     {
         JSMainThreadExecState currentState(exec);
-        return JSC::call(exec, functionObject, callType, callData, thisValue, args, exception);
+        return JSC::call(exec, functionObject, callType, callData, thisValue, args, returnedException);
     };
 
-    static JSC::JSValue evaluate(JSC::ExecState* exec, const JSC::SourceCode& source, JSC::JSValue thisValue, JSC::JSValue* exception)
+    static JSC::JSValue evaluate(JSC::ExecState* exec, const JSC::SourceCode& source, JSC::JSValue thisValue, JSC::Exception*& returnedException)
     {
         JSMainThreadExecState currentState(exec);
-        return JSC::evaluate(exec, source, thisValue, exception);
+        return JSC::evaluate(exec, source, thisValue, returnedException);
+    };
+
+    static JSC::JSValue evaluate(JSC::ExecState* exec, const JSC::SourceCode& source, JSC::JSValue thisValue = JSC::JSValue())
+    {
+        JSC::Exception* unused;
+        return evaluate(exec, source, thisValue, unused);
     };
 
@@ -122 +128 @@
 };
 
-JSC::JSValue functionCallHandlerFromAnyThread(JSC::ExecState*, JSC::JSValue functionObject, JSC::CallType, const JSC::CallData&, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::JSValue* exception);
-JSC::JSValue evaluateHandlerFromAnyThread(JSC::ExecState*, const JSC::SourceCode&, JSC::JSValue thisValue, JSC::JSValue* exception);
+JSC::JSValue functionCallHandlerFromAnyThread(JSC::ExecState*, JSC::JSValue functionObject, JSC::CallType, const JSC::CallData&, JSC::JSValue thisValue, const JSC::ArgList& args, JSC::Exception*& returnedException);
+JSC::JSValue evaluateHandlerFromAnyThread(JSC::ExecState*, const JSC::SourceCode&, JSC::JSValue thisValue, JSC::Exception*& returnedException);
 
 } // namespace WebCore

trunk/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp ¶

@@ -40 +40 @@
 #include "JSMediaStream.h"
 #include "JSNavigatorUserMediaError.h"
+#include <runtime/Exception.h>
 
 using namespace JSC;
@@ -51 +52 @@
     Dictionary options(exec, exec->argument(0));
     if (exec->hadException()) {
-        wrapper.reject(exec->exception());
+        Exception* exception = exec->exception();
+        exec->clearException();
+        wrapper.reject(exception->value());
         return wrapper.promise();
     }

trunk/Source/WebCore/bindings/js/JSMutationCallback.cpp ¶

@@ -88 +88 @@
     InspectorInstrumentationCookie cookie = JSMainThreadExecState::instrumentFunctionCall(context, callType, callData);
 
-    JSValue exception;
-    JSMainThreadExecState::call(exec, callback, callType, callData, jsObserver, args, &exception);
+    Exception* exception;
+    JSMainThreadExecState::call(exec, callback, callType, callData, jsObserver, args, exception);
 
     InspectorInstrumentation::didCallFunction(cookie, context);

trunk/Source/WebCore/bindings/js/ReadableJSStream.cpp ¶

@@ -53 +53 @@
 }
 
-static inline JSValue callFunction(ExecState* exec, JSValue jsFunction, JSValue thisValue, const ArgList& arguments, JSValue* exception)
+static inline JSValue callFunction(ExecState* exec, JSValue jsFunction, JSValue thisValue, const ArgList& arguments, Exception*& exception)
 {
     CallData callData;
@@ -89 +89 @@
     arguments.append(jsController(exec, globalObject()));
 
-    JSValue exception;
-    callFunction(&exec, startFunction, m_source.get(), arguments, &exception);
+    Exception* exception;
+    callFunction(&exec, startFunction, m_source.get(), arguments, exception);
 
     if (exception) {

trunk/Source/WebCore/bindings/js/ScheduledAction.cpp ¶

@@ -100 +100 @@
     InspectorInstrumentationCookie cookie = JSMainThreadExecState::instrumentFunctionCall(&context, callType, callData);
 
-    JSValue exception;
+    Exception* exception;
     if (is<Document>(context))
-        JSMainThreadExecState::call(exec, m_function.get(), callType, callData, thisValue, args, &exception);
+        JSMainThreadExecState::call(exec, m_function.get(), callType, callData, thisValue, args, exception);
     else
-        JSC::call(exec, m_function.get(), callType, callData, thisValue, args, &exception);
+        JSC::call(exec, m_function.get(), callType, callData, thisValue, args, exception);
 
     InspectorInstrumentation::didCallFunction(cookie, &context);

trunk/Source/WebCore/bindings/js/ScriptController.cpp ¶

@@ -161 +161 @@
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willEvaluateScript(m_frame, sourceURL, sourceCode.startLine());
 
-    JSValue evaluationException;
-
-    JSValue returnValue = JSMainThreadExecState::evaluate(exec, jsSourceCode, shell, &evaluationException);
+    Exception* evaluationException;
+    JSValue returnValue = JSMainThreadExecState::evaluate(exec, jsSourceCode, shell, evaluationException);
 
     InspectorInstrumentation::didEvaluateScript(cookie, m_frame);

trunk/Source/WebCore/bindings/js/SerializedScriptValue.cpp ¶

@@ -56 +56 @@
 #include <runtime/DateInstance.h>
 #include <runtime/Error.h>
+#include <runtime/Exception.h>
 #include <runtime/ExceptionHelpers.h>
 #include <runtime/JSArrayBuffer.h>
@@ -2703 +2704 @@
     if (exec->hadException()) {
         if (exception)
-            *exception = toRef(exec, exec->exception());
+            *exception = toRef(exec, exec->exception()->value());
         exec->clearException();
         return 0;
@@ -2733 +2734 @@
     if (exec->hadException()) {
         if (exception)
-            *exception = toRef(exec, exec->exception());
+            *exception = toRef(exec, exec->exception()->value());
         exec->clearException();
         return nullptr;

trunk/Source/WebCore/bindings/js/WorkerScriptController.cpp ¶

@@ -41 +41 @@
 #include <interpreter/Interpreter.h>
 #include <runtime/Completion.h>
+#include <runtime/Exception.h>
 #include <runtime/ExceptionHelpers.h>
 #include <runtime/Error.h>
@@ -99 +100 @@
         return;
 
-    Deprecated::ScriptValue exception;
-    evaluate(sourceCode, &exception);
-    if (exception.jsValue()) {
+    Exception* exception;
+    evaluate(sourceCode, exception);
+    if (exception) {
         JSLockHolder lock(vm());
-        reportException(m_workerGlobalScopeWrapper->globalExec(), exception.jsValue());
-    }
-}
-
-void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, Deprecated::ScriptValue* exception)
+        reportException(m_workerGlobalScopeWrapper->globalExec(), exception);
+    }
+}
+
+void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, JSC::Exception*& returnedException)
 {
     if (isExecutionForbidden())
@@ -117 +118 @@
     JSLockHolder lock(exec);
 
-    JSValue evaluationException;
-    JSC::evaluate(exec, sourceCode.jsSourceCode(), m_workerGlobalScopeWrapper->globalThis(), &evaluationException);
+    JSC::Exception* evaluationException;
+    JSC::evaluate(exec, sourceCode.jsSourceCode(), m_workerGlobalScopeWrapper->globalThis(), evaluationException);
 
     VM& vm = exec->vm();
@@ -132 +133 @@
         int columnNumber = 0;
         String sourceURL = sourceCode.url().string();
-        if (m_workerGlobalScope->sanitizeScriptError(errorMessage, lineNumber, columnNumber, sourceURL, sourceCode.cachedScript()))
-            *exception = Deprecated::ScriptValue(*m_vm, exec->vm().throwException(exec, createError(exec, errorMessage.impl())));
-        else
-            *exception = Deprecated::ScriptValue(*m_vm, evaluationException);
-    }
-}
-
-void WorkerScriptController::setException(const Deprecated::ScriptValue& exception)
-{
-    m_workerGlobalScopeWrapper->globalExec()->vm().throwException(m_workerGlobalScopeWrapper->globalExec(), exception.jsValue());
+        if (m_workerGlobalScope->sanitizeScriptError(errorMessage, lineNumber, columnNumber, sourceURL, sourceCode.cachedScript())) {
+            vm.throwException(exec, createError(exec, errorMessage.impl()));
+            evaluationException = vm.exception();
+            vm.clearException();
+        }
+    }
+    returnedException = evaluationException;
+}
+
+void WorkerScriptController::setException(JSC::Exception* exception)
+{
+    JSC::ExecState* exec = m_workerGlobalScopeWrapper->globalExec();
+    exec->vm().throwException(exec, exception);
 }
 

trunk/Source/WebCore/bindings/js/WorkerScriptController.h ¶

@@ -61 +61 @@
 
         void evaluate(const ScriptSourceCode&);
-        void evaluate(const ScriptSourceCode&, Deprecated::ScriptValue* exception);
+        void evaluate(const ScriptSourceCode&, JSC::Exception*& returnedException);
 
-        void setException(const Deprecated::ScriptValue&);
+        void setException(JSC::Exception*);
 
         // Async request to terminate a JS run execution. Eventually causes termination

trunk/Source/WebCore/bindings/js/WorkerScriptDebugServer.cpp ¶

@@ -100 +100 @@
 }
 
-void WorkerScriptDebugServer::reportException(JSC::ExecState* exec, JSC::JSValue exception) const
+void WorkerScriptDebugServer::reportException(JSC::ExecState* exec, JSC::Exception* exception) const
 {
     WebCore::reportException(exec, exception);

trunk/Source/WebCore/bindings/js/WorkerScriptDebugServer.h ¶

@@ -57 +57 @@
     virtual void runEventLoopWhilePaused() override;
     virtual bool isContentScript(JSC::ExecState*) const override { return false; }
-    virtual void reportException(JSC::ExecState*, JSC::JSValue) const override;
+    virtual void reportException(JSC::ExecState*, JSC::Exception*) const override;
 
     WorkerGlobalScope* m_workerGlobalScope;

trunk/Source/WebCore/bindings/objc/WebScriptObject.mm ¶

@@ -122 +122 @@
 }
 
-static void addExceptionToConsole(ExecState* exec, JSC::JSValue& exception)
+static void addExceptionToConsole(ExecState* exec, JSC::Exception* exception)
 {
     JSDOMWindow* window = asJSDOMWindow(exec->vmEntryGlobalObject());
@@ -132 +132 @@
 static void addExceptionToConsole(ExecState* exec)
 {
-    JSC::JSValue exception = exec->exception();
+    JSC::Exception* exception = exec->exception();
     exec->clearException();
     addExceptionToConsole(exec, exception);
@@ -343 +343 @@
         return nil;
 
-    JSC::JSValue exception;
-    JSC::JSValue result = JSMainThreadExecState::call(exec, function, callType, callData, [self _imp], argList, &exception);
+    JSC::Exception* exception;
+    JSC::JSValue result = JSMainThreadExecState::call(exec, function, callType, callData, [self _imp], argList, exception);
 
     if (exception) {
@@ -367 +367 @@
     JSLockHolder lock(exec);
     
-    JSC::JSValue returnValue = JSMainThreadExecState::evaluate(exec, makeSource(String(script)), JSC::JSValue(), 0);
+    JSC::JSValue returnValue = JSMainThreadExecState::evaluate(exec, makeSource(String(script)), JSC::JSValue());
 
     id resultObj = [WebScriptObject _convertValueToObjcValue:returnValue originRootObject:[self _originRootObject] rootObject:[self _rootObject]];

trunk/Source/WebCore/inspector/PageScriptDebugServer.cpp ¶

@@ -138 +138 @@
 }
 
-void PageScriptDebugServer::reportException(ExecState* exec, JSValue exception) const
+void PageScriptDebugServer::reportException(ExecState* exec, Exception* exception) const
 {
     WebCore::reportException(exec, exception);

trunk/Source/WebCore/inspector/PageScriptDebugServer.h ¶

@@ -55 +55 @@
     virtual void runEventLoopWhilePaused() override;
     virtual bool isContentScript(JSC::ExecState*) const override;
-    virtual void reportException(JSC::ExecState*, JSC::JSValue) const override;
+    virtual void reportException(JSC::ExecState*, JSC::Exception*) const override;
 
     void runEventLoopWhilePausedInternal();

trunk/Source/WebCore/workers/WorkerGlobalScope.cpp ¶

@@ -198 +198 @@
         InspectorInstrumentation::scriptImported(scriptExecutionContext(), scriptLoader->identifier(), scriptLoader->script());
 
-        Deprecated::ScriptValue exception;
-        m_script->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), &exception);
-        if (!exception.hasNoValue()) {
+        JSC::Exception* exception;
+        m_script->evaluate(ScriptSourceCode(scriptLoader->script(), scriptLoader->responseURL()), exception);
+        if (exception) {
             m_script->setException(exception);
             return;

trunk/Source/WebKit/mac/ChangeLog ¶

@@ +1 @@
+2015-06-05  Mark Lam  <mark.lam@apple.com>
+
+        finally blocks should not set the exception stack trace when re-throwing the exception.
+        https://bugs.webkit.org/show_bug.cgi?id=145525
+
+        Reviewed by Geoffrey Garen.
+
+        * WebView/WebView.mm:
+        (+[WebView _reportException:inContext:]):
+        (WebKitInitializeApplicationCachePathIfNecessary):
+        - Changed to use the new Exception object.
+
 2015-06-03  Anders Carlsson  <andersca@apple.com>
 

trunk/Source/WebKit/mac/WebView/WebView.mm ¶

@@ -115 +115 @@
 #import <Foundation/NSURLConnection.h>
 #import <JavaScriptCore/APICast.h>
+#import <JavaScriptCore/Exception.h>
 #import <JavaScriptCore/JSValueRef.h>
 #import <WebCore/AlternativeTextUIController.h>
@@ -725 +726 @@
         return;
 
-    reportException(execState, toJS(execState, exception));
+    Exception* vmException = Exception::cast(toJS(execState, exception));
+    reportException(execState, vmException);
 }
 

trunk/Source/WebKit/win/ChangeLog ¶

@@ +1 @@
+2015-06-05  Mark Lam  <mark.lam@apple.com>
+
+        finally blocks should not set the exception stack trace when re-throwing the exception.
+        https://bugs.webkit.org/show_bug.cgi?id=145525
+
+        Reviewed by Geoffrey Garen.
+
+        * WebView.cpp:
+        (WebView::reportException):
+        - Changed to use the new Exception object.
+
 2015-06-02  Brady Eidson  <beidson@apple.com>
 

trunk/Source/WebKit/win/WebView.cpp ¶

@@ -73 +73 @@
 #include "resource.h"
 #include <JavaScriptCore/APICast.h>
+#include <JavaScriptCore/Exception.h>
 #include <JavaScriptCore/InitializeThreading.h>
 #include <JavaScriptCore/JSCJSValue.h>
@@ -6030 +6031 @@
         return E_FAIL;
 
-    WebCore::reportException(execState, toJS(execState, exception));
+    JSC::Exception* vmException = JSC::Exception::cast(toJS(execState, exception));
+    WebCore::reportException(execState, vmException);
     return S_OK;
 }

trunk/Source/WebKit2/ChangeLog ¶

@@ +1 @@
+2015-06-05  Mark Lam  <mark.lam@apple.com>
+
+        finally blocks should not set the exception stack trace when re-throwing the exception.
+        https://bugs.webkit.org/show_bug.cgi?id=145525
+
+        Reviewed by Geoffrey Garen.
+
+        * WebProcess/InjectedBundle/InjectedBundle.cpp:
+        (WebKit::InjectedBundle::reportException):
+        - Changed to use the new Exception object.
+
 2015-06-05  Anders Carlsson  <andersca@apple.com>
 

trunk/Source/WebKit2/WebProcess/InjectedBundle/InjectedBundle.cpp ¶

@@ -51 +51 @@
 #include "WebProcessPoolMessages.h"
 #include <JavaScriptCore/APICast.h>
+#include <JavaScriptCore/Exception.h>
 #include <JavaScriptCore/JSLock.h>
 #include <WebCore/ApplicationCache.h>
@@ -523 +524 @@
         return;
 
-    WebCore::reportException(execState, toJS(execState, exception));
+    WebCore::reportException(execState, Exception::cast(toJS(execState, exception)));
 }