Changeset 206899 in webkit for trunk/Source/JavaScriptCore/dfg/DFGDOMJITPatchpointParams.cpp

Timestamp:

Oct 6, 2016, 10:07:13 PM (9 years ago)

Author:

Yusuke Suzuki

Message:

[DOMJIT] Support slow path call
​https://bugs.webkit.org/show_bug.cgi?id=162978

Reviewed by Saam Barati.

One of the most important features required in DOMJIT::Patchpoint is slow path calls.
DOM operation typically returns DOMWrapper object. At that time, if wrapper cache hits, we can go
to the fast path. However, if we cannot use the cache, we need to go to the slow path to call toJS function.
At that time, slow path call functionality is necessary.

This patch expose DOMJIT::PatchpointParams::addSlowPathCall. We can request slow path call code generation
through this interface. DOMJIT::PatchpointParams automatically leverages appropriate slow path call systems
in each tier. In DFG, we use slow path call system. In FTL, we implement slow path call by using addLatePath
to construct slow path call. But these details are completely hidden by DOMJIT::PatchpointParams. Users can
just use addSlowPathCall.

Since DFG and FTL slow path call systems are implemented in variadic templates, directly using this means
that we need to expose core part of DFG and FTL. For example, DFG::SpeculativeJIT need to be exposed in
such a design. That is too bad. Instead, we use magical macro in DOMJITSlowPathCalls.h. We can list up the
call signatures in DOMJIT_SLOW_PATH_CALLS. DOMJIT uses these signatures to generate an interface to request
slow path calls inside DFG and FTL instead of exposing everything.

• CMakeLists.txt:
• JavaScriptCore.xcodeproj/project.pbxproj:
• dfg/DFGCommon.h:
• dfg/DFGDOMJITPatchpointParams.cpp: Copied from Source/JavaScriptCore/domjit/DOMJITPatchpointParams.h.

(JSC::DFG::dispatch):

• dfg/DFGDOMJITPatchpointParams.h: Copied from Source/JavaScriptCore/domjit/DOMJITPatchpointParams.h.

(JSC::DFG::DOMJITPatchpointParams::DOMJITPatchpointParams):

• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileCallDOM):
(JSC::DFG::SpeculativeJIT::compileCheckDOM):

• dfg/DFGSpeculativeJIT.h:

(JSC::DFG::extractResult): Deleted.

• domjit/DOMJITPatchpointParams.h:

(JSC::DOMJIT::PatchpointParams::addSlowPathCall):

• domjit/DOMJITSlowPathCalls.h: Copied from Source/JavaScriptCore/domjit/DOMJITPatchpointParams.h.
• ftl/FTLDOMJITPatchpointParams.cpp: Added.

(JSC::FTL::dispatch):

• ftl/FTLDOMJITPatchpointParams.h: Copied from Source/JavaScriptCore/domjit/DOMJITPatchpointParams.h.

(JSC::FTL::DOMJITPatchpointParams::DOMJITPatchpointParams):

• ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileCheckDOM):
(JSC::FTL::DFG::LowerDFGToB3::compileCallDOM):

• jit/GPRInfo.h:

(JSC::extractResult):

• jsc.cpp:

File:

• trunk/Source/JavaScriptCore/dfg/DFGDOMJITPatchpointParams.cpp (copied) (copied from trunk/Source/JavaScriptCore/domjit/DOMJITPatchpointParams.h ) (1 diff)

trunk/Source/JavaScriptCore/dfg/DFGDOMJITPatchpointParams.cpp

@@ -24 +24 @@
  */
 
-#pragma once
+#include "config.h"
+#include "DFGDOMJITPatchpointParams.h"
 
-#if ENABLE(JIT)
+#if ENABLE(DFG_JIT)
 
-#include "CCallHelpers.h"
-#include "DOMJITReg.h"
-#include "RegisterSet.h"
+#include "DFGSlowPathGenerator.h"
+#include "DFGSpeculativeJIT.h"
 
-namespace JSC { namespace DOMJIT {
+namespace JSC { namespace DFG {
 
-class PatchpointParams {
-WTF_MAKE_NONCOPYABLE(PatchpointParams);
-public:
-    virtual ~PatchpointParams() { }
+template<typename OperationType, typename ResultType, typename Arguments, size_t... ArgumentsIndex>
+static void dispatch(SpeculativeJIT* jit, CCallHelpers::JumpList from, OperationType operation, ResultType result, Arguments arguments, std::index_sequence<ArgumentsIndex...>)
+{
+    jit->addSlowPathGenerator(slowPathCall(from, jit, operation, result, std::get<ArgumentsIndex>(arguments)...));
+}
 
-    unsigned size() const { return m_regs.size(); }
-    const Reg& at(unsigned index) const { return m_regs[index]; }
-    const Reg& operator[](unsigned index) const { return at(index); }
+#define JSC_DEFINE_CALL_OPERATIONS(OperationType, ResultType, ...) \
+    void DOMJITPatchpointParams::addSlowPathCallImpl(CCallHelpers::JumpList from, CCallHelpers&, OperationType operation, ResultType result, std::tuple<__VA_ARGS__> args) const \
+    { \
+        dispatch(m_jit, from, operation, result, args, std::make_index_sequence<std::tuple_size<decltype(args)>::value>()); \
+    } \
 
-    GPRReg gpScratch(unsigned index) const { return m_gpScratch[index]; }
-    FPRReg fpScratch(unsigned index) const { return m_fpScratch[index]; }
-
-    PatchpointParams(Vector<Reg>&& regs, Vector<GPRReg>&& gpScratch, Vector<FPRReg>&& fpScratch)
-        : m_regs(WTFMove(regs))
-        , m_gpScratch(WTFMove(gpScratch))
-        , m_fpScratch(WTFMove(fpScratch))
-    {
-    }
-
-private:
-
-    Vector<Reg> m_regs;
-    Vector<GPRReg> m_gpScratch;
-    Vector<FPRReg> m_fpScratch;
-};
+DOMJIT_SLOW_PATH_CALLS(JSC_DEFINE_CALL_OPERATIONS)
+#undef JSC_DEFINE_CALL_OPERATIONS
 
 } }