Changeset 154814 in webkit for trunk/Source/JavaScriptCore/jit/JITStubs.cpp

Timestamp:

Aug 29, 2013, 9:41:07 AM (12 years ago)

Author:

[email protected]

Message:

Unreviewed, rolling out r154804.
​http://trac.webkit.org/changeset/154804
​https://bugs.webkit.org/show_bug.cgi?id=120477

Broke Windows build (assumes LLInt features not enabled on
this build) (Requested by bfulgham on #webkit).

• CMakeLists.txt:
• GNUmakefile.list.am:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Target.pri:
• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::linkIncomingCall):
(JSC::CodeBlock::unlinkIncomingCalls):
(JSC::CodeBlock::reoptimize):
(JSC::ProgramCodeBlock::replacement):
(JSC::EvalCodeBlock::replacement):
(JSC::FunctionCodeBlock::replacement):
(JSC::ProgramCodeBlock::compileOptimized):
(JSC::ProgramCodeBlock::replaceWithDeferredOptimizedCode):
(JSC::EvalCodeBlock::compileOptimized):
(JSC::EvalCodeBlock::replaceWithDeferredOptimizedCode):
(JSC::FunctionCodeBlock::compileOptimized):
(JSC::FunctionCodeBlock::replaceWithDeferredOptimizedCode):
(JSC::ProgramCodeBlock::jitCompileImpl):
(JSC::EvalCodeBlock::jitCompileImpl):
(JSC::FunctionCodeBlock::jitCompileImpl):

• bytecode/CodeBlock.h:

(JSC::CodeBlock::jitType):
(JSC::CodeBlock::jitCompile):

• bytecode/DeferredCompilationCallback.cpp: Removed.
• bytecode/DeferredCompilationCallback.h: Removed.
• dfg/DFGDriver.cpp:

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

• dfg/DFGDriver.h:

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

• dfg/DFGFailedFinalizer.cpp:

(JSC::DFG::FailedFinalizer::finalize):
(JSC::DFG::FailedFinalizer::finalizeFunction):

• dfg/DFGFailedFinalizer.h:
• dfg/DFGFinalizer.h:
• dfg/DFGJITFinalizer.cpp:

(JSC::DFG::JITFinalizer::finalize):
(JSC::DFG::JITFinalizer::finalizeFunction):

• dfg/DFGJITFinalizer.h:
• dfg/DFGOSRExitPreparation.cpp:

(JSC::DFG::prepareCodeOriginForOSRExit):

• dfg/DFGOperations.cpp:
• dfg/DFGPlan.cpp:

(JSC::DFG::Plan::Plan):
(JSC::DFG::Plan::compileInThreadImpl):
(JSC::DFG::Plan::finalize):

• dfg/DFGPlan.h:
• dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::compile):

• dfg/DFGWorklist.cpp:

(JSC::DFG::Worklist::completeAllReadyPlansForVM):
(JSC::DFG::Worklist::runThread):

• ftl/FTLJITFinalizer.cpp:

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

• ftl/FTLJITFinalizer.h:
• heap/Heap.h:
• interpreter/Interpreter.cpp:

(JSC::Interpreter::execute):
(JSC::Interpreter::executeCall):
(JSC::Interpreter::executeConstruct):
(JSC::Interpreter::prepareForRepeatCall):

• jit/JITDriver.h: Added.

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

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):
(JSC::jitCompileFor):
(JSC::lazyLinkFor):

• jit/JITToDFGDeferredCompilationCallback.cpp: Removed.
• jit/JITToDFGDeferredCompilationCallback.h: Removed.
• llint/LLIntEntrypoints.cpp:

(JSC::LLInt::getFunctionEntrypoint):
(JSC::LLInt::getEvalEntrypoint):
(JSC::LLInt::getProgramEntrypoint):

• llint/LLIntEntrypoints.h:

(JSC::LLInt::getEntrypoint):

• llint/LLIntSlowPaths.cpp:

(JSC::LLInt::jitCompileAndSetHeuristics):
(JSC::LLInt::setUpCall):

• runtime/ArrayPrototype.cpp:

(JSC::isNumericCompareFunction):

• runtime/CommonSlowPaths.cpp:
• runtime/CompilationResult.cpp:

(WTF::printInternal):

• runtime/CompilationResult.h:
• runtime/Executable.cpp:

(JSC::EvalExecutable::compileOptimized):
(JSC::EvalExecutable::jitCompile):
(JSC::EvalExecutable::compileInternal):
(JSC::EvalExecutable::replaceWithDeferredOptimizedCode):
(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::produceCodeBlockFor):
(JSC::FunctionExecutable::compileForCallInternal):
(JSC::FunctionExecutable::replaceWithDeferredOptimizedCodeForCall):
(JSC::FunctionExecutable::compileForConstructInternal):
(JSC::FunctionExecutable::replaceWithDeferredOptimizedCodeForConstruct):

• runtime/Executable.h:

(JSC::ExecutableBase::offsetOfJITCodeWithArityCheckFor):
(JSC::ExecutableBase::offsetOfNumParametersFor):
(JSC::ExecutableBase::catchRoutineFor):
(JSC::EvalExecutable::compile):
(JSC::ProgramExecutable::compile):
(JSC::FunctionExecutable::compileForCall):
(JSC::FunctionExecutable::compileForConstruct):
(JSC::FunctionExecutable::compileFor):
(JSC::FunctionExecutable::compileOptimizedFor):
(JSC::FunctionExecutable::replaceWithDeferredOptimizedCodeFor):
(JSC::FunctionExecutable::jitCompileFor):

• runtime/ExecutionHarness.h: Added.

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

File:

• trunk/Source/JavaScriptCore/jit/JITStubs.cpp (modified) (6 diffs)

trunk/Source/JavaScriptCore/jit/JITStubs.cpp

@@ -52 +52 @@
 #include "JIT.h"
 #include "JITExceptions.h"
-#include "JITToDFGDeferredCompilationCallback.h"
 #include "JSActivation.h"
 #include "JSArray.h"
@@ -1000 +999 @@
             dataLog("Considering OSR ", *codeBlock, " -> ", *codeBlock->replacement(), ".\n");
         // If we have an optimized replacement, then it must be the case that we entered
-        // cti_optimize from a loop. That's because if there's an optimized replacement,
+        // cti_optimize from a loop. That's because is there's an optimized replacement,
         // then all calls to this function will be relinked to the replacement and so
         // the prologue OSR will never fire.
@@ -1034 +1033 @@
             dataLog("Triggering optimized compilation of ", *codeBlock, "\n");
         
-        RefPtr<DeferredCompilationCallback> callback =
-            JITToDFGDeferredCompilationCallback::create();
-        RefPtr<CodeBlock> newCodeBlock = codeBlock->newReplacement();
-        CompilationResult result = newCodeBlock->prepareForExecutionAsynchronously(
-            callFrame, JITCode::DFGJIT, callback, JITCompilationCanFail, bytecodeIndex);
+        JSScope* scope = callFrame->scope();
+        CompilationResult result;
+        JSObject* error = codeBlock->compileOptimized(callFrame, scope, result, bytecodeIndex);
+        if (Options::verboseOSR()) {
+            dataLog("Optimizing compilation of ", *codeBlock, " result: ", result, "\n");
+            if (error)
+                dataLog("WARNING: optimized compilation failed with a JS error.\n");
+        }
         
+        codeBlock->setOptimizationThresholdBasedOnCompilationResult(result);
         if (result != CompilationSuccessful)
             return;
@@ -1166 +1169 @@
     FunctionExecutable* executable = function->jsExecutable();
     JSScope* callDataScopeChain = function->scope();
-    JSObject* error = executable->prepareForExecution(callFrame, callDataScopeChain, kind);
+    JSObject* error = executable->compileFor(callFrame, callDataScopeChain, kind);
     if (!error)
         return function;
@@ -1265 +1268 @@
     else {
         FunctionExecutable* functionExecutable = static_cast<FunctionExecutable*>(executable);
-        if (JSObject* error = functionExecutable->prepareForExecution(callFrame, callee->scope(), kind)) {
+        if (JSObject* error = functionExecutable->compileFor(callFrame, callee->scope(), kind)) {
             callFrame->vm().throwException(callFrame, error);
             return 0;
@@ -1342 +1345 @@
         FunctionExecutable* functionExecutable = jsCast<FunctionExecutable*>(executable);
         JSScope* scopeChain = callee->scope();
-        JSObject* error = functionExecutable->prepareForExecution(callFrame, scopeChain, CodeForCall);
+        JSObject* error = functionExecutable->compileFor(callFrame, scopeChain, CodeForCall);
         if (error) {
             callFrame->vm().throwException(callFrame, error);