Changeset 163027 in webkit for trunk/Source/JavaScriptCore/jit/JITOperations.cpp

Timestamp:

Jan 29, 2014, 11:18:54 AM (12 years ago)

Author:

[email protected]

Message:

Merge the jsCStack branch
​https://bugs.webkit.org/show_bug.cgi?id=127763

Reviewed by Mark Hahnenberg.

Source/JavaScriptCore:

Changes from ​http://svn.webkit.org/repository/webkit/branches/jsCStack
up to changeset 162958.

Source/WebCore:

Changes from ​http://svn.webkit.org/repository/webkit/branches/jsCStack
up to changeset 162958.

Source/WTF:

Changes from ​http://svn.webkit.org/repository/webkit/branches/jsCStack
up to changeset 162958.

File:

• trunk/Source/JavaScriptCore/jit/JITOperations.cpp (modified) (39 diffs)

trunk/Source/JavaScriptCore/jit/JITOperations.cpp

@@ -1 +1 @@
 /*
- * Copyright (C) 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31 +31 @@
 #include "ArrayConstructor.h"
 #include "CallFrameInlines.h"
-#include "CommonSlowPaths.h"
 #include "DFGCompilationMode.h"
 #include "DFGDriver.h"
@@ -37 +36 @@
 #include "DFGWorklist.h"
 #include "Error.h"
+#include "ErrorHandlingScope.h"
 #include "GetterSetter.h"
 #include "HostCallReturnValue.h"
@@ -72 +72 @@
 
 
-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.
@@ -81 +81 @@
 
     NativeCallFrameTracer tracer(vm, callerFrame);
-
-    JSStack& stack = vm->interpreter->stack();
-
-    if (UNLIKELY(!stack.grow(&exec->registers()[virtualRegisterForLocal(codeBlock->frameRegisterCount()).offset()])))
-        vm->throwException(callerFrame, createStackOverflowError(callerFrame));
+    ErrorHandlingScope errorScope(*vm);
+    vm->throwException(callerFrame, createStackOverflowError(callerFrame));
 }
 
@@ -98 +95 @@
     int32_t missingArgCount = CommonSlowPaths::arityCheckFor(exec, &stack, CodeForCall);
     if (missingArgCount < 0)
-        vm->throwException(callerFrame, createStackOverflowError(callerFrame));
+        throwStackOverflowError(callerFrame);
 
     return missingArgCount;
@@ -113 +110 @@
     int32_t missingArgCount = CommonSlowPaths::arityCheckFor(exec, &stack, CodeForConstruct);
     if (missingArgCount < 0)
-        vm->throwException(callerFrame, createStackOverflowError(callerFrame));
+        throwStackOverflowError(callerFrame);
 
     return missingArgCount;
@@ -613 +610 @@
 }
 
-EncodedJSValue JIT_OPERATION operationCallEval(ExecState* execCallee)
-{
-    CallFrame* callerFrame = execCallee->callerFrame();
-    ASSERT(execCallee->callerFrame()->codeBlock()->codeType() != FunctionCode
-        || !execCallee->callerFrame()->codeBlock()->needsFullScopeChain()
-        || execCallee->callerFrame()->uncheckedR(execCallee->callerFrame()->codeBlock()->activationRegister().offset()).jsValue());
-
-    execCallee->setScope(callerFrame->scope());
-    execCallee->setReturnPC(static_cast<Instruction*>(OUR_RETURN_ADDRESS));
+EncodedJSValue JIT_OPERATION operationCallEval(ExecState* exec, ExecState* execCallee)
+{
+    ASSERT(exec->codeBlock()->codeType() != FunctionCode
+        || !exec->codeBlock()->needsFullScopeChain()
+        || exec->uncheckedR(exec->codeBlock()->activationRegister().offset()).jsValue());
+
+    execCallee->setScope(exec->scope());
     execCallee->setCodeBlock(0);
 
@@ -686 +681 @@
 }
 
-inline char* linkFor(ExecState* execCallee, CodeSpecializationKind kind)
+inline char* linkFor(
+    ExecState* execCallee, CodeSpecializationKind kind, RegisterPreservationMode registers)
 {
     ExecState* exec = execCallee->callerFrame();
@@ -705 +701 @@
     CallLinkInfo& callLinkInfo = exec->codeBlock()->getCallLinkInfo(execCallee->returnPC());
     if (executable->isHostFunction())
-        codePtr = executable->generatedJITCodeFor(kind)->addressForCall();
+        codePtr = executable->entrypointFor(*vm, kind, MustCheckArity, registers);
     else {
         FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
         JSObject* error = functionExecutable->prepareForExecution(execCallee, callee->scope(), kind);
         if (error) {
-            vm->throwException(exec, createStackOverflowError(exec));
+            throwStackOverflowError(exec);
             return reinterpret_cast<char*>(vm->getCTIStub(throwExceptionFromCallSlowPathGenerator).code().executableAddress());
         }
         codeBlock = functionExecutable->codeBlockFor(kind);
+        ArityCheckMode arity;
         if (execCallee->argumentCountIncludingThis() < static_cast<size_t>(codeBlock->numParameters()) || callLinkInfo.callType == CallLinkInfo::CallVarargs)
-            codePtr = functionExecutable->generatedJITCodeWithArityCheckFor(kind);
+            arity = MustCheckArity;
         else
-            codePtr = functionExecutable->generatedJITCodeFor(kind)->addressForCall();
+            arity = ArityCheckNotRequired;
+        codePtr = functionExecutable->entrypointFor(*vm, kind, arity, registers);
     }
     if (!callLinkInfo.seenOnce())
         callLinkInfo.setSeen();
     else
-        linkFor(execCallee, callLinkInfo, codeBlock, callee, codePtr, kind);
+        linkFor(execCallee, callLinkInfo, codeBlock, callee, codePtr, kind, registers);
     return reinterpret_cast<char*>(codePtr.executableAddress());
 }
@@ -728 +726 @@
 char* JIT_OPERATION operationLinkCall(ExecState* execCallee)
 {
-    return linkFor(execCallee, CodeForCall);
+    return linkFor(execCallee, CodeForCall, RegisterPreservationNotRequired);
 }
 
 char* JIT_OPERATION operationLinkConstruct(ExecState* execCallee)
 {
-    return linkFor(execCallee, CodeForConstruct);
-}
-
-inline char* virtualForWithFunction(ExecState* execCallee, CodeSpecializationKind kind, JSCell*& calleeAsFunctionCell)
+    return linkFor(execCallee, CodeForConstruct, RegisterPreservationNotRequired);
+}
+
+char* JIT_OPERATION operationLinkCallThatPreservesRegs(ExecState* execCallee)
+{
+    return linkFor(execCallee, CodeForCall, MustPreserveRegisters);
+}
+
+char* JIT_OPERATION operationLinkConstructThatPreservesRegs(ExecState* execCallee)
+{
+    return linkFor(execCallee, CodeForConstruct, MustPreserveRegisters);
+}
+
+inline char* virtualForWithFunction(
+    ExecState* execCallee, CodeSpecializationKind kind, RegisterPreservationMode registers,
+    JSCell*& calleeAsFunctionCell)
 {
     ExecState* exec = execCallee->callerFrame();
@@ -758 +768 @@
         }
     }
-    return reinterpret_cast<char*>(executable->generatedJITCodeWithArityCheckFor(kind).executableAddress());
-}
-
-inline char* virtualFor(ExecState* execCallee, CodeSpecializationKind kind)
+    return reinterpret_cast<char*>(executable->entrypointFor(
+        *vm, kind, MustCheckArity, registers).executableAddress());
+}
+
+inline char* virtualFor(
+    ExecState* execCallee, CodeSpecializationKind kind, RegisterPreservationMode registers)
 {
     JSCell* calleeAsFunctionCellIgnored;
-    return virtualForWithFunction(execCallee, kind, calleeAsFunctionCellIgnored);
-}
-
-static bool attemptToOptimizeClosureCall(ExecState* execCallee, JSCell* calleeAsFunctionCell, CallLinkInfo& callLinkInfo)
+    return virtualForWithFunction(execCallee, kind, registers, calleeAsFunctionCellIgnored);
+}
+
+static bool attemptToOptimizeClosureCall(
+    ExecState* execCallee, RegisterPreservationMode registers, JSCell* calleeAsFunctionCell,
+    CallLinkInfo& callLinkInfo)
 {
     if (!calleeAsFunctionCell)
@@ -781 +795 @@
     
     ASSERT(callee->executable()->hasJITCodeForCall());
-    MacroAssemblerCodePtr codePtr = callee->executable()->generatedJITCodeForCall()->addressForCall();
+    MacroAssemblerCodePtr codePtr =
+        callee->executable()->generatedJITCodeForCall()->addressForCall(
+            *execCallee->callerFrame()->codeBlock()->vm(), callee->executable(),
+            ArityCheckNotRequired, registers);
     
     CodeBlock* codeBlock;
@@ -794 +811 @@
     linkClosureCall(
         execCallee, callLinkInfo, codeBlock,
-        callee->structure(), callee->executable(), codePtr);
+        callee->structure(), callee->executable(), codePtr, registers);
     
     return true;
@@ -802 +819 @@
 {
     JSCell* calleeAsFunctionCell;
-    char* result = virtualForWithFunction(execCallee, CodeForCall, calleeAsFunctionCell);
+    char* result = virtualForWithFunction(execCallee, CodeForCall, RegisterPreservationNotRequired, calleeAsFunctionCell);
     CallLinkInfo& callLinkInfo = execCallee->callerFrame()->codeBlock()->getCallLinkInfo(execCallee->returnPC());
 
-    if (!attemptToOptimizeClosureCall(execCallee, calleeAsFunctionCell, callLinkInfo))
-        linkSlowFor(execCallee, callLinkInfo, CodeForCall);
+    if (!attemptToOptimizeClosureCall(execCallee, RegisterPreservationNotRequired, calleeAsFunctionCell, callLinkInfo))
+        linkSlowFor(execCallee, callLinkInfo, CodeForCall, RegisterPreservationNotRequired);
     
     return result;
@@ -813 +830 @@
 char* JIT_OPERATION operationVirtualCall(ExecState* execCallee)
 {    
-    return virtualFor(execCallee, CodeForCall);
+    return virtualFor(execCallee, CodeForCall, RegisterPreservationNotRequired);
 }
 
 char* JIT_OPERATION operationVirtualConstruct(ExecState* execCallee)
 {
-    return virtualFor(execCallee, CodeForConstruct);
-}
-
+    return virtualFor(execCallee, CodeForConstruct, RegisterPreservationNotRequired);
+}
+
+char* JIT_OPERATION operationLinkClosureCallThatPreservesRegs(ExecState* execCallee)
+{
+    JSCell* calleeAsFunctionCell;
+    char* result = virtualForWithFunction(execCallee, CodeForCall, MustPreserveRegisters, calleeAsFunctionCell);
+    CallLinkInfo& callLinkInfo = execCallee->callerFrame()->codeBlock()->getCallLinkInfo(execCallee->returnPC());
+
+    if (!attemptToOptimizeClosureCall(execCallee, MustPreserveRegisters, calleeAsFunctionCell, callLinkInfo))
+        linkSlowFor(execCallee, callLinkInfo, CodeForCall, MustPreserveRegisters);
+    
+    return result;
+}
+
+char* JIT_OPERATION operationVirtualCallThatPreservesRegs(ExecState* execCallee)
+{    
+    return virtualFor(execCallee, CodeForCall, MustPreserveRegisters);
+}
+
+char* JIT_OPERATION operationVirtualConstructThatPreservesRegs(ExecState* execCallee)
+{
+    return virtualFor(execCallee, CodeForConstruct, MustPreserveRegisters);
+}
 
 size_t JIT_OPERATION operationCompareLess(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
@@ -975 +1013 @@
 
 #if ENABLE(DFG_JIT)
-char* JIT_OPERATION operationOptimize(ExecState* exec, int32_t bytecodeIndex)
+SlowPathReturnType JIT_OPERATION operationOptimize(ExecState* exec, int32_t bytecodeIndex)
 {
     VM& vm = exec->vm();
@@ -1025 +1063 @@
         if (Options::verboseOSR())
             dataLog("Choosing not to optimize ", *codeBlock, " yet, because the threshold hasn't been reached.\n");
-        return 0;
+        return encodeResult(0, 0);
     }
     
@@ -1033 +1071 @@
         if (Options::verboseOSR())
             dataLog("Choosing not to optimize ", *codeBlock, " yet, because m_shouldAlwaysBeInlined == true.\n");
-        return 0;
+        return encodeResult(0, 0);
     }
 
     // We cannot be in the process of asynchronous compilation and also have an optimized
     // replacement.
+    DFG::Worklist* worklist = DFG::existingGlobalDFGWorklistOrNull();
     ASSERT(
-        !vm.worklist
-        || !(vm.worklist->compilationState(DFG::CompilationKey(codeBlock, DFG::DFGMode)) != DFG::Worklist::NotKnown
+        !worklist
+        || !(worklist->compilationState(DFG::CompilationKey(codeBlock, DFG::DFGMode)) != DFG::Worklist::NotKnown
         && codeBlock->hasOptimizedReplacement()));
 
     DFG::Worklist::State worklistState;
-    if (vm.worklist) {
+    if (worklist) {
         // The call to DFG::Worklist::completeAllReadyPlansForVM() will complete all ready
         // (i.e. compiled) code blocks. But if it completes ours, we also need to know
@@ -1063 +1102 @@
         // possible in order to minimize the chances of us executing baseline code after
         // optimized code is already available.
-        worklistState = vm.worklist->completeAllReadyPlansForVM(
+        worklistState = worklist->completeAllReadyPlansForVM(
             vm, DFG::CompilationKey(codeBlock, DFG::DFGMode));
     } else
@@ -1073 +1112 @@
         RELEASE_ASSERT(!codeBlock->hasOptimizedReplacement());
         codeBlock->setOptimizationThresholdBasedOnCompilationResult(CompilationDeferred);
-        return 0;
+        return encodeResult(0, 0);
     }
 
@@ -1086 +1125 @@
             if (Options::verboseOSR())
                 dataLog("Code block ", *codeBlock, " was compiled but it doesn't have an optimized replacement.\n");
-            return 0;
+            return encodeResult(0, 0);
         }
     } else if (codeBlock->hasOptimizedReplacement()) {
@@ -1111 +1150 @@
             }
             codeBlock->replacement()->jettison(CountReoptimization);
-            return 0;
+            return encodeResult(0, 0);
         }
     } else {
@@ -1120 +1159 @@
                     " because of insufficient profiling.\n");
             }
-            return 0;
+            return encodeResult(0, 0);
         }
 
@@ -1148 +1187 @@
 
         CompilationResult result = DFG::compile(
-            vm, codeBlock->newReplacement().get(), DFG::DFGMode, bytecodeIndex,
-            mustHandleValues, JITToDFGDeferredCompilationCallback::create(),
-            vm.ensureWorklist());
+            vm, codeBlock->newReplacement().get(), 0, DFG::DFGMode, bytecodeIndex,
+            mustHandleValues, JITToDFGDeferredCompilationCallback::create());
         
         if (result != CompilationSuccessful)
-            return 0;
+            return encodeResult(0, 0);
     }
     
@@ -1167 +1205 @@
 
         codeBlock->optimizeSoon();
-        return static_cast<char*>(address);
+        ASSERT(exec->codeBlock() == optimizedCodeBlock);
+        return encodeResult(address, exec->topOfFrame());
     }
 
@@ -1196 +1235 @@
         }
         optimizedCodeBlock->jettison(CountReoptimization);
-        return 0;
+        return encodeResult(0, 0);
     }
 
@@ -1203 +1242 @@
     codeBlock->optimizeAfterWarmUp();
     
-    return 0;
+    return encodeResult(0, 0);
 }
 #endif
@@ -1531 +1570 @@
 }
 
-CallFrame* JIT_OPERATION operationSizeAndAllocFrameForVarargs(ExecState* exec, EncodedJSValue encodedArguments, int32_t firstFreeRegister)
+CallFrame* JIT_OPERATION operationSizeFrameForVarargs(ExecState* exec, EncodedJSValue encodedArguments, int32_t firstFreeRegister)
 {
     VM& vm = exec->vm();
@@ -1537 +1576 @@
     JSStack* stack = &exec->interpreter()->stack();
     JSValue arguments = JSValue::decode(encodedArguments);
-    CallFrame* newCallFrame = sizeAndAllocFrameForVarargs(exec, stack, arguments, firstFreeRegister);
+    CallFrame* newCallFrame = sizeFrameForVarargs(exec, stack, arguments, firstFreeRegister);
     return newCallFrame;
 }
@@ -1730 +1769 @@
 }
 
-void JIT_OPERATION lookupExceptionHandler(ExecState* exec)
-{
-    VM* vm = &exec->vm();
-    NativeCallFrameTracer tracer(vm, exec);
-
-    JSValue exceptionValue = exec->exception();
+void JIT_OPERATION lookupExceptionHandler(VM* vm, ExecState* exec)
+{
+    NativeCallFrameTracer tracer(vm, exec, NativeCallFrameTracer::VMEntrySentinelOK);
+
+    JSValue exceptionValue = vm->exception();
     ASSERT(exceptionValue);
     
@@ -1768 +1806 @@
 HIDE_SYMBOL(getHostCallReturnValue) "\n"
 SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
-    "mov 0(%rbp), %rbp\n" // CallerFrameAndPC::callerFrame
     "mov %rbp, %rdi\n"
     "jmp " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
@@ -1779 +1816 @@
 HIDE_SYMBOL(getHostCallReturnValue) "\n"
 SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
-    "mov 0(%ebp), %ebp\n" // CallerFrameAndPC::callerFrame
-    "mov %ebp, 4(%esp)\n"
+    "mov (%esp), %eax\n"
+    "push %ebp\n"
+    "leal -4(%esp), %esp\n"
+    "push %ebp\n"
+    "push %eax\n"
     "jmp " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
 );
@@ -1793 +1833 @@
 ".thumb_func " THUMB_FUNC_PARAM(getHostCallReturnValue) "\n"
 SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
-    "ldr r7, [r7, #0]" "\n" // CallerFrameAndPC::callerFrame
     "mov r0, r7" "\n"
     "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
@@ -1805 +1844 @@
 INLINE_ARM_FUNCTION(getHostCallReturnValue)
 SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
-    "ldr r11, [r11, #0]" "\n" // CallerFrameAndPC::callerFrame
     "mov r0, r11" "\n"
     "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
@@ -1817 +1855 @@
 HIDE_SYMBOL(getHostCallReturnValue) "\n"
 SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
-    "ldur x29, [x29, #0]" "\n"
      "mov x0, x29" "\n"
      "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
@@ -1829 +1866 @@
 SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
     LOAD_FUNCTION_TO_T9(getHostCallReturnValueWithExecState)
-    "lw $fp, 0($fp)" "\n" // CallerFrameAndPC::callerFrame
     "move $a0, $fp" "\n"
     "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
@@ -1840 +1876 @@
 HIDE_SYMBOL(getHostCallReturnValue) "\n"
 SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
-    "mov.l @r14, r14" "\n" // CallerFrameAndPC::callerFrame
     "mov r14, r4" "\n"
     "mov.l 2f, " SH4_SCRATCH_REGISTER "\n"
@@ -1853 +1888 @@
     __declspec(naked) EncodedJSValue HOST_CALL_RETURN_VALUE_OPTION getHostCallReturnValue()
     {
-        __asm mov ebp, [ebp + 0]; // CallerFrameAndPC::callerFrame
         __asm mov [esp + 4], ebp;
         __asm jmp getHostCallReturnValueWithExecState