Changeset 153165 in webkit for trunk/Source/JavaScriptCore/dfg/DFGDriver.cpp

Timestamp:

Jul 24, 2013, 9:00:22 PM (12 years ago)

Author:

[email protected]

Message:

fourthTier: Executable and CodeBlock should be aware of DFG::Plans that complete asynchronously
​https://bugs.webkit.org/show_bug.cgi?id=116350

Reviewed by Oliver Hunt.

This refactors compilation so that:

• JITStubs knows exactly what the result of compilation was. For example, if compilation was deferred, it will now know this.

• The set of things that has to happen to install compiled code is now factored out into JSC::installOptimizedCode().

• A bunch of the code in Executable.cpp is now made more common to reduce code duplication. For example, the heap heuristics stuff is now in one place.

• JavaScriptCore.xcodeproj/project.pbxproj:
• bytecode/CodeBlock.cpp:

(JSC::ProgramCodeBlock::compileOptimized):
(JSC::ProgramCodeBlock::replaceWithDeferredOptimizedCode):
(JSC):
(JSC::EvalCodeBlock::compileOptimized):
(JSC::EvalCodeBlock::replaceWithDeferredOptimizedCode):
(JSC::FunctionCodeBlock::compileOptimized):
(JSC::FunctionCodeBlock::replaceWithDeferredOptimizedCode):
(JSC::ProgramCodeBlock::jitCompileImpl):
(JSC::EvalCodeBlock::jitCompileImpl):
(JSC::FunctionCodeBlock::jitCompileImpl):

• bytecode/CodeBlock.h:

(CodeBlock):
(JSC::CodeBlock::jitCompile):
(ProgramCodeBlock):
(EvalCodeBlock):
(FunctionCodeBlock):

• dfg/DFGDesiredIdentifiers.cpp:

(JSC::DFG::DesiredIdentifiers::numberOfIdentifiers):
(DFG):
(JSC::DFG::DesiredIdentifiers::at):

• dfg/DFGDesiredIdentifiers.h:

(JSC):
(DesiredIdentifiers):

• dfg/DFGDriver.cpp:

(JSC::DFG::compile):
(JSC::DFG::tryCompile):
(JSC::DFG::tryCompileFunction):
(JSC::DFG::tryFinalizePlan):
(DFG):

• dfg/DFGDriver.h:

(DFG):
(JSC::DFG::tryCompile):
(JSC::DFG::tryCompileFunction):
(JSC::DFG::tryFinalizePlan):

• dfg/DFGGraph.cpp:

(JSC::DFG::Graph::Graph):

• dfg/DFGJITFinalizer.cpp:

(JSC::DFG::JITFinalizer::finalizeCommon):

• dfg/DFGPlan.cpp:

(JSC::DFG::Plan::Plan):
(JSC::DFG::Plan::compileInThread):
(JSC::DFG::Plan::reallyAdd):

• dfg/DFGPlan.h:

(JSC):
(Plan):
(DFG):

• ftl/FTLJITFinalizer.cpp:

(JSC::FTL::JITFinalizer::finalizeFunction):

• jit/JITDriver.h:

(JSC::jitCompileIfAppropriateImpl):
(JSC::jitCompileFunctionIfAppropriateImpl):
(JSC):
(JSC::jitCompileIfAppropriate):
(JSC::jitCompileFunctionIfAppropriate):

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

• llint/LLIntSlowPaths.cpp:

(JSC::LLInt::jitCompileAndSetHeuristics):

• runtime/CompilationResult.cpp: Added.

(WTF):
(WTF::printInternal):

• runtime/CompilationResult.h: Added.

(JSC):
(WTF):

• runtime/Executable.cpp:

(JSC::EvalExecutable::compileOptimized):
(JSC::EvalExecutable::jitCompile):
(JSC::EvalExecutable::compileInternal):
(JSC::EvalExecutable::replaceWithDeferredOptimizedCode):
(JSC):
(JSC::ProgramExecutable::compileOptimized):
(JSC::ProgramExecutable::jitCompile):
(JSC::ProgramExecutable::compileInternal):
(JSC::ProgramExecutable::replaceWithDeferredOptimizedCode):
(JSC::FunctionExecutable::compileOptimizedForCall):
(JSC::FunctionExecutable::compileOptimizedForConstruct):
(JSC::FunctionExecutable::jitCompileForCall):
(JSC::FunctionExecutable::jitCompileForConstruct):
(JSC::FunctionExecutable::compileForCallInternal):
(JSC::FunctionExecutable::replaceWithDeferredOptimizedCodeForCall):
(JSC::FunctionExecutable::compileForConstructInternal):
(JSC::FunctionExecutable::replaceWithDeferredOptimizedCodeForConstruct):

• runtime/Executable.h:

(ScriptExecutable):
(EvalExecutable):
(ProgramExecutable):
(FunctionExecutable):
(JSC::FunctionExecutable::compileOptimizedFor):
(JSC::FunctionExecutable::replaceWithDeferredOptimizedCodeFor):
(JSC::FunctionExecutable::jitCompileFor):

• runtime/ExecutionHarness.h:

(JSC::prepareForExecutionImpl):
(JSC::prepareFunctionForExecutionImpl):
(JSC):
(JSC::installOptimizedCode):
(JSC::prepareForExecution):
(JSC::prepareFunctionForExecution):
(JSC::replaceWithDeferredOptimizedCode):

File:

• trunk/Source/JavaScriptCore/dfg/DFGDriver.cpp (modified) (6 diffs)

trunk/Source/JavaScriptCore/dfg/DFGDriver.cpp

@@ -32 +32 @@
 #if ENABLE(DFG_JIT)
 
+#include "CodeBlock.h"
 #include "DFGJITCode.h"
 #include "DFGPlan.h"
@@ -39 +40 @@
 #include "Operations.h"
 #include "Options.h"
+#include "SamplingTool.h"
 
 namespace JSC { namespace DFG {
@@ -49 +51 @@
 }
 
-static bool compile(CompileMode compileMode, ExecState* exec, CodeBlock* codeBlock, RefPtr<JSC::JITCode>& jitCode, MacroAssemblerCodePtr* jitCodeWithArityCheck, unsigned osrEntryBytecodeIndex)
+static CompilationResult compile(CompileMode compileMode, ExecState* exec, CodeBlock* codeBlock, RefPtr<JSC::JITCode>& jitCode, MacroAssemblerCodePtr* jitCodeWithArityCheck, unsigned osrEntryBytecodeIndex)
 {
     SamplingRegion samplingRegion("DFG Compilation (Driver)");
@@ -62 +64 @@
 
     if (!Options::useDFGJIT())
-        return false;
+        return CompilationFailed;
 
     if (!Options::bytecodeRangeToDFGCompile().isInRange(codeBlock->instructionCount()))
-        return false;
+        return CompilationFailed;
 
     if (logCompilationChanges())
@@ -90 +92 @@
     else
         numVarsWithValues = 0;
-    Plan plan(compileMode, codeBlock, osrEntryBytecodeIndex, numVarsWithValues);
-    for (size_t i = 0; i < plan.mustHandleValues.size(); ++i) {
-        int operand = plan.mustHandleValues.operandForIndex(i);
+    RefPtr<Plan> plan = adoptRef(
+        new Plan(compileMode, codeBlock, osrEntryBytecodeIndex, numVarsWithValues));
+    for (size_t i = 0; i < plan->mustHandleValues.size(); ++i) {
+        int operand = plan->mustHandleValues.operandForIndex(i);
         if (operandIsArgument(operand)
             && !operandToArgument(operand)
@@ -101 +104 @@
             // but it has to be an actual value that can be grokked by subsequent DFG passes,
             // so we sanitize it here by turning it into Undefined.
-            plan.mustHandleValues[i] = jsUndefined();
+            plan->mustHandleValues[i] = jsUndefined();
         } else
-            plan.mustHandleValues[i] = exec->uncheckedR(operand).jsValue();
+            plan->mustHandleValues[i] = exec->uncheckedR(operand).jsValue();
     }
     
-    plan.compileInThread();
-    if (plan.finalize(jitCode, jitCodeWithArityCheck) != CompilationSuccessful)
-        return false;
-    return true;
+    plan->compileInThread();
+    return plan->finalize(jitCode, jitCodeWithArityCheck);
 }
 
-bool tryCompile(ExecState* exec, CodeBlock* codeBlock, RefPtr<JSC::JITCode>& jitCode, unsigned bytecodeIndex)
+CompilationResult tryCompile(ExecState* exec, CodeBlock* codeBlock, RefPtr<JSC::JITCode>& jitCode, unsigned bytecodeIndex)
 {
     return compile(CompileOther, exec, codeBlock, jitCode, 0, bytecodeIndex);
 }
 
-bool tryCompileFunction(ExecState* exec, CodeBlock* codeBlock, RefPtr<JSC::JITCode>& jitCode, MacroAssemblerCodePtr& jitCodeWithArityCheck, unsigned bytecodeIndex)
+CompilationResult tryCompileFunction(ExecState* exec, CodeBlock* codeBlock, RefPtr<JSC::JITCode>& jitCode, MacroAssemblerCodePtr& jitCodeWithArityCheck, unsigned bytecodeIndex)
 {
     return compile(CompileFunction, exec, codeBlock, jitCode, &jitCodeWithArityCheck, bytecodeIndex);
+}
+
+CompilationResult tryFinalizePlan(PassRefPtr<Plan> plan, RefPtr<JSC::JITCode>& jitCode, MacroAssemblerCodePtr* jitCodeWithArityCheck)
+{
+    return plan->finalize(jitCode, jitCodeWithArityCheck);
 }