Changeset 160890 in webkit

Timestamp:

Dec 19, 2013 6:38:00 PM (10 years ago)

Author:

mark.lam@apple.com

Message:

CStack: The JIT does not need a slow path stack check.
​https://bugs.webkit.org/show_bug.cgi?id=126036.

Reviewed by Geoffrey Garen.

The JIT uses the C stack which is not growable. If we fail a stack
check in the function header, then a stack overflow is imminent, and
there's no need to redo the check in the slow path helper.

Hence, renamed operationStackCheck() to operationThrowStackOverflowError()
and change the JIT and DFG code to use this appropriately.

• dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::compileFunction):

• jit/JIT.cpp:

(JSC::JIT::privateCompile):

• jit/JITOperations.cpp:
• jit/JITOperations.h:

Location:

branches/jsCStack/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• dfg/DFGJITCompiler.cpp (modified) (2 diffs)
• jit/JIT.cpp (modified) (3 diffs)
• jit/JITOperations.cpp (modified) (2 diffs)
• jit/JITOperations.h (modified) (1 diff)

branches/jsCStack/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2013-12-19  Mark Lam  <mark.lam@apple.com>
+
+        CStack: The JIT does not need a slow path stack check.
+        https://bugs.webkit.org/show_bug.cgi?id=126036.
+
+        Reviewed by Geoffrey Garen.
+
+        The JIT uses the C stack which is not growable. If we fail a stack
+        check in the function header, then a stack overflow is imminent, and
+        there's no need to redo the check in the slow path helper.
+
+        Hence, renamed operationStackCheck() to operationThrowStackOverflowError()
+        and change the JIT and DFG code to use this appropriately.
+
+        * dfg/DFGJITCompiler.cpp:
+        (JSC::DFG::JITCompiler::compileFunction):
+        * jit/JIT.cpp:
+        (JSC::JIT::privateCompile):
+        * jit/JITOperations.cpp:
+        * jit/JITOperations.h:
+
 2013-12-19  Michael Saboff  <msaboff@apple.com>
 

branches/jsCStack/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp

@@ -328 +328 @@
     // Plant a check that sufficient space is available in the JSStack.
     addPtr(TrustedImm32(virtualRegisterForLocal(m_graph.requiredRegisterCountForExecutionAndExit() - 1).offset() * sizeof(Register)), GPRInfo::callFrameRegister, GPRInfo::regT1);
-    Jump stackCheck = branchPtr(Above, AbsoluteAddress(m_vm->addressOfJSStackLimit()), GPRInfo::regT1);
-    // Return here after stack check.
-    Label fromStackCheck = label();
+    Jump stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfJSStackLimit()), GPRInfo::regT1);
 
     checkStackPointerAlignment();
@@ -345 +343 @@
     // === Function footer code generation ===
     //
-    // Generate code to perform the slow stack check (if the fast one in
+    // Generate code to perform the stack overflow handling (if the stack check in
     // the function header fails), and generate the entry point with arity check.
     //
-    // Generate the stack check; if the fast check in the function head fails,
-    // we need to call out to a helper function to check whether more space is available.
-    // FIXME: change this from a cti call to a DFG style operation (normal C calling conventions).
-    stackCheck.link(this);
+    // Generate the stack overflow handling; if the stack check in the function head fails,
+    // we need to call out to a helper function to throw the StackOverflowError.
+    stackOverflow.link(this);
 
     emitStoreCodeOrigin(CodeOrigin(0));
-    m_speculative->callOperationWithCallFrameRollbackOnException(operationStackCheck, m_codeBlock);
-    jump(fromStackCheck);
+    m_speculative->callOperationWithCallFrameRollbackOnException(operationThrowStackOverflowError, m_codeBlock);
     
     // The fast entry point into a function does not check the correct number of arguments

branches/jsCStack/Source/JavaScriptCore/jit/JIT.cpp

@@ -520 +520 @@
 #endif
 
-    Jump stackCheck;
+    Jump stackOverflow;
     if (m_codeBlock->codeType() == FunctionCode) {
 #if ENABLE(VALUE_PROFILER)
@@ -543 +543 @@
 
         addPtr(TrustedImm32(stackPointerOffsetFor(m_codeBlock) * sizeof(Register)), callFrameRegister, regT1);
-        stackCheck = branchPtr(Above, AbsoluteAddress(m_vm->addressOfJSStackLimit()), regT1);
-    }
-
-    Label functionBody = label();
+        stackOverflow = branchPtr(Above, AbsoluteAddress(m_vm->addressOfJSStackLimit()), regT1);
+    }
 
     checkStackPointerAlignment();
@@ -561 +559 @@
     Label arityCheck;
     if (m_codeBlock->codeType() == FunctionCode) {
-        stackCheck.link(this);
+        stackOverflow.link(this);
         m_bytecodeOffset = 0;
-        // FIXME: CStack - This may need to have some stack space allocated to make the call
-        callOperationWithCallFrameRollbackOnException(operationStackCheck, m_codeBlock);
-#ifndef NDEBUG
-        m_bytecodeOffset = (unsigned)-1; // Reset this, in order to guard its use with ASSERTs.
-#endif
-        jump(functionBody);
+        callOperationWithCallFrameRollbackOnException(operationThrowStackOverflowError, m_codeBlock);
 
         arityCheck = label();

branches/jsCStack/Source/JavaScriptCore/jit/JITOperations.cpp

@@ -71 +71 @@
 
 
-void JIT_OPERATION operationStackCheck(ExecState* exec, CodeBlock* codeBlock)
+void JIT_OPERATION operationThrowStackOverflowError(ExecState* exec, CodeBlock* codeBlock)
 {
     // We pass in our own code block, because the callframe hasn't been populated.
@@ -80 +80 @@
 
     NativeCallFrameTracer tracer(vm, callerFrame);
-
-#if ENABLE(LLINT_CLOOP)
-    JSStack& stack = vm->interpreter->stack();
-
-    if (UNLIKELY(!stack.grow(&exec->registers()[codeBlock->stackPointerOffset()])))
-        vm->throwException(callerFrame, createStackOverflowError(callerFrame));
-#else
-    if (!exec->vm().isSafeToRecurse(codeBlock->frameRegisterCount() * sizeof(Register)))
-        vm->throwException(callerFrame, createStackOverflowError(callerFrame));
-#endif // ENABLE(LLINT_CLOOP)
+    vm->throwException(callerFrame, createStackOverflowError(callerFrame));
 }
 

branches/jsCStack/Source/JavaScriptCore/jit/JITOperations.h

@@ -188 +188 @@
 void JIT_OPERATION operationVMHandleException(ExecState*) WTF_INTERNAL;
 
-void JIT_OPERATION operationStackCheck(ExecState*, CodeBlock*) WTF_INTERNAL;
+void JIT_OPERATION operationThrowStackOverflowError(ExecState*, CodeBlock*) WTF_INTERNAL;
 int32_t JIT_OPERATION operationCallArityCheck(ExecState*) WTF_INTERNAL;
 int32_t JIT_OPERATION operationConstructArityCheck(ExecState*) WTF_INTERNAL;