Changeset 251457 in webkit for trunk/Source/JavaScriptCore/interpreter

Timestamp:

Oct 22, 2019, 2:23:26 PM (6 years ago)

Author:

[email protected]

Message:

[JSC] Remove non-LargeAllocation restriction for JSCallee
​https://bugs.webkit.org/show_bug.cgi?id=203260

Reviewed by Saam Barati.

Source/JavaScriptCore:

We now pass JSGlobalObject* instead of ExecState*. And we are getting VM& from JSGlobalObject*.
Because now accessing ExecState::vm() becomes less frequent, we can remove the restriction that
callee is only allocated in non-LargeAllocation, which restriction made ExecState::vm fast.

This patch renames CallFrame::vm to CallFrame::deprecatedVM. And we avoid using it as much as possible.
And we also remove the restriction that callee needs to be in non-LargeAllocation.

• API/JSContextRef.cpp:

(JSContextCreateBacktrace):

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::noticeIncomingCall):

• debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::deprecatedVMEntryGlobalObject const):
(JSC::DebuggerCallFrame::functionName const):
(JSC::DebuggerCallFrame::scope):
(JSC::DebuggerCallFrame::type const):
(JSC::DebuggerCallFrame::evaluateWithScopeExtension):
(JSC::DebuggerCallFrame::positionForCallFrame):

• dfg/DFGOSRExit.cpp:

(JSC::DFG::OSRExit::executeOSRExit):
(JSC::DFG::OSRExit::compileOSRExit):
(JSC::DFG::OSRExit::debugOperationPrintSpeculationFailure):

• dfg/DFGOperations.cpp:
• ftl/FTLOSRExitCompiler.cpp:

(JSC::FTL::compileFTLOSRExit):

• ftl/FTLOperations.cpp:

(JSC::FTL::compileFTLLazySlowPath):

• inspector/JSInjectedScriptHost.cpp:

(Inspector::JSInjectedScriptHost::evaluateWithScopeExtension):

• inspector/ScriptCallStackFactory.cpp:

(Inspector::createScriptCallStack):
(Inspector::createScriptCallStackForConsole):

• interpreter/CallFrame.cpp:

(JSC::CallFrame::callerSourceOrigin):
(JSC::CallFrame::friendlyFunctionName):

• interpreter/CallFrame.h:

(JSC::CallFrame::iterate):

• interpreter/Interpreter.cpp:

(JSC::sizeOfVarargs):
(JSC::sizeFrameForVarargs):
(JSC::Interpreter::getStackTrace):
(JSC::Interpreter::unwind):
(JSC::Interpreter::notifyDebuggerOfExceptionToBeThrown):
(JSC::Interpreter::debug):

• interpreter/Interpreter.h:
• interpreter/ShadowChicken.cpp:

(JSC::ShadowChicken::update):

• interpreter/StackVisitor.cpp:

(JSC::StackVisitor::StackVisitor):
(JSC::StackVisitor::Frame::functionName const):

• interpreter/StackVisitor.h:

(JSC::StackVisitor::visit):

• jit/HostCallReturnValue.cpp:

(JSC::getHostCallReturnValueWithExecState):

• jit/JITOperations.cpp:
• jit/Repatch.cpp:

(JSC::linkFor):
(JSC::linkPolymorphicCall):

• jit/Repatch.h:
• jsc.cpp:

(functionJSCStack):
(functionRunString):
(functionLoadString):
(functionCallerSourceOrigin):
(functionCallerIsOMGCompiled):
(functionDollarEvalScript):

• llint/LLIntSlowPaths.cpp:

(JSC::LLInt::LLINT_SLOW_PATH_DECL):

• runtime/Error.cpp:

(JSC::getBytecodeOffset):

• runtime/FunctionConstructor.cpp:

(JSC::constructFunction):

• runtime/JSCellInlines.h:

(JSC::CallFrame::deprecatedVM const):
(JSC::CallFrame::vm const): Deleted.

• runtime/JSFunction.cpp:

(JSC::retrieveArguments):
(JSC::JSFunction::argumentsGetter):
(JSC::retrieveCallerFunction):
(JSC::JSFunction::callerGetter):
(JSC::JSFunction::defineOwnProperty):

• runtime/JSGlobalObject.cpp:

(JSC::assertCall):

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncEval):
(JSC::globalFuncImportModule):

• runtime/NullSetterFunction.cpp:

(JSC::callerIsStrict):
(JSC::NullSetterFunctionInternal::callReturnUndefined):

• tools/JSDollarVM.cpp:

(IGNORE_WARNINGS_BEGIN):
(JSC::functionLLintTrue):
(JSC::functionJITTrue):
(JSC::functionDumpRegisters):
(JSC::functionShadowChickenFunctionsOnStack):

• tools/VMInspector.cpp:

(JSC::VMInspector::codeBlockForFrame):
(JSC::VMInspector::dumpCallFrame):
(JSC::VMInspector::dumpRegisters):
(JSC::VMInspector::dumpStack):

• wasm/js/WasmToJS.cpp:

(JSC::Wasm::wasmToJS):

Source/WebCore:

Passing VM& instead of calling CallFrame::vm.

• bindings/js/JSDOMGlobalObject.cpp:

(WebCore::callerGlobalObject):

• bindings/js/JSDOMWindowBase.cpp:

(WebCore::responsibleDocument):

• bindings/js/JSDOMWindowBase.h:
• bindings/scripts/CodeGeneratorJS.pm:

(GenerateCallWith):

• testing/Internals.cpp:

(WebCore::Internals::parserMetaData):

Location:

trunk/Source/JavaScriptCore/interpreter

Files:

• CallFrame.cpp (modified) (2 diffs)
• CallFrame.h (modified) (3 diffs)
• Interpreter.cpp (modified) (7 diffs)
• Interpreter.h (modified) (1 diff)
• ShadowChicken.cpp (modified) (2 diffs)
• StackVisitor.cpp (modified) (3 diffs)
• StackVisitor.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/interpreter/CallFrame.cpp

@@ -234 +234 @@
 }
 
-SourceOrigin CallFrame::callerSourceOrigin()
+SourceOrigin CallFrame::callerSourceOrigin(VM& vm)
 {
     RELEASE_ASSERT(callee().isCell());
-    VM* vm = &this->vm();
     SourceOrigin sourceOrigin;
     bool haveSkippedFirstFrame = false;
@@ -293 +292 @@
     case FunctionCode:
         if (jsCallee())
-            return getCalculatedDisplayName(vm(), jsCallee());
+            return getCalculatedDisplayName(codeBlock->vm(), jsCallee());
         return emptyString();
     }

trunk/Source/JavaScriptCore/interpreter/CallFrame.h

@@ -137 +137 @@
         JSGlobalObject* lexicalGlobalObject() const;
 
-        VM& vm() const;
+        // FIXME: Remove this function
+        // https://bugs.webkit.org/show_bug.cgi?id=203272
+        VM& deprecatedVM() const;
 
         static CallFrame* create(Register* callFrameBase) { return static_cast<CallFrame*>(callFrameBase); }
@@ -152 +154 @@
         JS_EXPORT_PRIVATE CallFrame* callerFrame(EntryFrame*&) const;
 
-        JS_EXPORT_PRIVATE SourceOrigin callerSourceOrigin();
+        JS_EXPORT_PRIVATE SourceOrigin callerSourceOrigin(VM&);
 
         static ptrdiff_t callerFrameOffset() { return OBJECT_OFFSETOF(CallerFrameAndPC, callerFrame); }
@@ -281 +283 @@
         // receiver. We should always be using StackVisitor directly.
         // It's only valid to call this from a non-wasm top frame.
-        template <StackVisitor::EmptyEntryFrameAction action = StackVisitor::ContinueIfTopEntryFrameIsEmpty, typename Functor> void iterate(const Functor& functor)
-        {
-            VM* vm;
+        template <StackVisitor::EmptyEntryFrameAction action = StackVisitor::ContinueIfTopEntryFrameIsEmpty, typename Functor> void iterate(VM& vm, const Functor& functor)
+        {
             void* rawThis = this;
-            if (!!rawThis) {
+            if (!!rawThis)
                 RELEASE_ASSERT(callee().isCell());
-                vm = &this->vm();
-            } else
-                vm = nullptr;
             StackVisitor::visit<action, Functor>(this, vm, functor);
         }

trunk/Source/JavaScriptCore/interpreter/Interpreter.cpp

@@ -177 +177 @@
 }
 
-unsigned sizeOfVarargs(JSGlobalObject* globalObject, CallFrame* callFrame, JSValue arguments, uint32_t firstVarArgOffset)
-{
-    VM& vm = callFrame->vm();
+unsigned sizeOfVarargs(JSGlobalObject* globalObject, JSValue arguments, uint32_t firstVarArgOffset)
+{
+    VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
@@ -242 +242 @@
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    unsigned length = sizeOfVarargs(globalObject, callFrame, arguments, firstVarArgOffset);
+    unsigned length = sizeOfVarargs(globalObject, arguments, firstVarArgOffset);
     RETURN_IF_EXCEPTION(scope, 0);
 
@@ -441 +441 @@
     size_t framesCount = 0;
     size_t maxFramesCountNeeded = maxStackSize + framesToSkip;
-    StackVisitor::visit(callFrame, &vm, [&] (StackVisitor&) -> StackVisitor::Status {
+    StackVisitor::visit(callFrame, vm, [&] (StackVisitor&) -> StackVisitor::Status {
         if (++framesCount < maxFramesCountNeeded)
             return StackVisitor::Continue;
@@ -453 +453 @@
 
     GetStackTraceFunctor functor(vm, owner, results, framesToSkip, framesCount);
-    StackVisitor::visit(callFrame, &vm, functor);
+    StackVisitor::visit(callFrame, vm, functor);
     ASSERT(results.size() == results.capacity());
 }
@@ -628 +628 @@
     HandlerInfo* handler = nullptr;
     UnwindFunctor functor(vm, callFrame, isTerminatedExecutionException(vm, exception), codeBlock, handler);
-    StackVisitor::visit<StackVisitor::TerminateIfTopEntryFrameIsEmpty>(callFrame, &vm, functor);
+    StackVisitor::visit<StackVisitor::TerminateIfTopEntryFrameIsEmpty>(callFrame, vm, functor);
     if (!handler)
         return nullptr;
@@ -650 +650 @@
         else {
             GetCatchHandlerFunctor functor;
-            StackVisitor::visit(callFrame, &vm, functor);
+            StackVisitor::visit(callFrame, vm, functor);
             HandlerInfo* handler = functor.handler();
             ASSERT(!handler || handler->isCatchHandler());
@@ -1215 +1215 @@
 NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookType debugHookType)
 {
-    VM& vm = callFrame->vm();
+    VM& vm = callFrame->deprecatedVM();
     auto scope = DECLARE_CATCH_SCOPE(vm);
     Debugger* debugger = callFrame->lexicalGlobalObject()->debugger();

trunk/Source/JavaScriptCore/interpreter/Interpreter.h

@@ -168 +168 @@
     }
 
-    unsigned sizeOfVarargs(JSGlobalObject*, CallFrame*, JSValue arguments, uint32_t firstVarArgOffset);
+    unsigned sizeOfVarargs(JSGlobalObject*, JSValue arguments, uint32_t firstVarArgOffset);
     static constexpr unsigned maxArguments = 0x10000;
     unsigned sizeFrameForVarargs(JSGlobalObject*, CallFrame*, VM&, JSValue arguments, unsigned numUsedStackSlots, uint32_t firstVarArgOffset);

trunk/Source/JavaScriptCore/interpreter/ShadowChicken.cpp

@@ -174 +174 @@
         Vector<Frame> stackRightNow;
         StackVisitor::visit(
-            callFrame, &vm, [&] (StackVisitor& visitor) -> StackVisitor::Status {
+            callFrame, vm, [&] (StackVisitor& visitor) -> StackVisitor::Status {
                 if (visitor->isInlinedFrame())
                     return StackVisitor::Continue;
@@ -295 +295 @@
     Vector<Frame> toPush;
     StackVisitor::visit(
-        callFrame, &vm, [&] (StackVisitor& visitor) -> StackVisitor::Status {
+        callFrame, vm, [&] (StackVisitor& visitor) -> StackVisitor::Status {
             if (visitor->isInlinedFrame()) {
                 // FIXME: Handle inlining.

trunk/Source/JavaScriptCore/interpreter/StackVisitor.cpp

@@ -40 +40 @@
 namespace JSC {
 
-StackVisitor::StackVisitor(CallFrame* startFrame, VM* vm)
+StackVisitor::StackVisitor(CallFrame* startFrame, VM& vm)
 {
     m_frame.m_index = 0;
@@ -46 +46 @@
     CallFrame* topFrame;
     if (startFrame) {
-        ASSERT(vm);
-        ASSERT(!vm->topCallFrame || reinterpret_cast<void*>(vm->topCallFrame) != vm->topEntryFrame);
-
-        m_frame.m_entryFrame = vm->topEntryFrame;
-        topFrame = vm->topCallFrame;
+        ASSERT(!vm.topCallFrame || reinterpret_cast<void*>(vm.topCallFrame) != vm.topEntryFrame);
+
+        m_frame.m_entryFrame = vm.topEntryFrame;
+        topFrame = vm.topCallFrame;
 
         if (topFrame && topFrame->isStackOverflowFrame()) {
             topFrame = topFrame->callerFrame(m_frame.m_entryFrame);
-            m_topEntryFrameIsEmpty = (m_frame.m_entryFrame != vm->topEntryFrame);
-            if (startFrame == vm->topCallFrame)
+            m_topEntryFrameIsEmpty = (m_frame.m_entryFrame != vm.topEntryFrame);
+            if (startFrame == vm.topCallFrame)
                 startFrame = topFrame;
         }
@@ -304 +303 @@
         JSCell* callee = this->callee().asCell();
         if (callee)
-            traceLine = getCalculatedDisplayName(callFrame()->vm(), jsCast<JSObject*>(callee)).impl();
+            traceLine = getCalculatedDisplayName(callFrame()->deprecatedVM(), jsCast<JSObject*>(callee)).impl();
         break;
     }
     case CodeType::Function: 
-        traceLine = getCalculatedDisplayName(callFrame()->vm(), jsCast<JSObject*>(this->callee().asCell())).impl();
+        traceLine = getCalculatedDisplayName(callFrame()->deprecatedVM(), jsCast<JSObject*>(this->callee().asCell())).impl();
         break;
     case CodeType::Global:

trunk/Source/JavaScriptCore/interpreter/StackVisitor.h

@@ -143 +143 @@
 
     template <EmptyEntryFrameAction action = ContinueIfTopEntryFrameIsEmpty, typename Functor>
-    static void visit(CallFrame* startFrame, VM* vm, const Functor& functor)
+    static void visit(CallFrame* startFrame, VM& vm, const Functor& functor)
     {
         StackVisitor visitor(startFrame, vm);
@@ -163 +163 @@
 
 private:
-    JS_EXPORT_PRIVATE StackVisitor(CallFrame* startFrame, VM*);
+    JS_EXPORT_PRIVATE StackVisitor(CallFrame* startFrame, VM&);
 
     JS_EXPORT_PRIVATE void gotoNextFrame();