Changeset 154833 in webkit for trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

Timestamp:

Aug 29, 2013, 12:28:55 PM (12 years ago)

Author:

[email protected]

Message:

CodeBlock::prepareForExecution() is silly
​https://bugs.webkit.org/show_bug.cgi?id=120453

Reviewed by Oliver Hunt.

Instead of saying:

codeBlock->prepareForExecution(stuff, BaselineJIT, more stuff)

we should just say:

JIT::compile(stuff, codeBlock, more stuff);

And similarly for the LLInt and DFG.

This kills a bunch of code, since CodeBlock::prepareForExecution() is just a
wrapper that uses the JITType argument to call into the appropriate execution
engine, which is what the user wanted to do in the first place.

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

(JSC::DFG::compileImpl):
(JSC::DFG::compile):

• dfg/DFGDriver.h:

(JSC::DFG::tryCompile):

• dfg/DFGOSRExitPreparation.cpp:

(JSC::DFG::prepareCodeOriginForOSRExit):

• dfg/DFGWorklist.cpp:

(JSC::DFG::globalWorklist):

• dfg/DFGWorklist.h:
• jit/JIT.cpp:

(JSC::JIT::privateCompile):

• jit/JIT.h:

(JSC::JIT::compile):

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

• llint/LLIntEntrypoint.cpp: Copied from Source/JavaScriptCore/llint/LLIntEntrypoints.cpp.

(JSC::LLInt::setFunctionEntrypoint):
(JSC::LLInt::setEvalEntrypoint):
(JSC::LLInt::setProgramEntrypoint):
(JSC::LLInt::setEntrypoint):

• llint/LLIntEntrypoint.h: Copied from Source/JavaScriptCore/llint/LLIntEntrypoints.h.
• llint/LLIntEntrypoints.cpp: Removed.
• llint/LLIntEntrypoints.h: Removed.
• llint/LLIntSlowPaths.cpp:

(JSC::LLInt::jitCompileAndSetHeuristics):

• runtime/Executable.cpp:

(JSC::ScriptExecutable::prepareForExecutionImpl):

File:

• trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp (modified) (2 diffs)

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -47 +47 @@
 #include "JSFunction.h"
 #include "JSNameScope.h"
-#include "LLIntEntrypoints.h"
 #include "LowLevelInterpreter.h"
 #include "Operations.h"
@@ -2694 +2693 @@
 }
 
-CompilationResult CodeBlock::prepareForExecutionImpl(
-    ExecState* exec, JITCode::JITType jitType, JITCompilationEffort effort,
-    unsigned bytecodeIndex, PassRefPtr<DeferredCompilationCallback> callback)
-{
-    VM& vm = exec->vm();
-    
-    if (jitType == JITCode::InterpreterThunk) {
-#if ENABLE(LLINT)
-        switch (codeType()) {
-        case GlobalCode:
-            LLInt::setProgramEntrypoint(vm, static_cast<ProgramCodeBlock*>(this));
-            break;
-        case EvalCode:
-            LLInt::setEvalEntrypoint(vm, static_cast<EvalCodeBlock*>(this));
-            break;
-        case FunctionCode:
-            LLInt::setFunctionEntrypoint(vm, static_cast<FunctionCodeBlock*>(this));
-            break;
-        }
-        return CompilationSuccessful;
-#else // ENABLE(LLINT)
-        return CompilationFailed;
-#endif // ENABLE(LLINT)
-    }
-    
-#if ENABLE(JIT)
-    if (JITCode::isOptimizingJIT(jitType)) {
-        ASSERT(effort == JITCompilationCanFail);
-        bool hadCallback = !!callback;
-        CompilationResult result = DFG::tryCompile(exec, this, bytecodeIndex, callback);
-        ASSERT_UNUSED(hadCallback, result != CompilationDeferred || hadCallback);
-        return result;
-    }
-    
-    MacroAssemblerCodePtr jitCodeWithArityCheck;
-    RefPtr<JITCode> jitCode = JIT::compile(&vm, this, effort, &jitCodeWithArityCheck);
-    if (!jitCode)
-        return CompilationFailed;
-    setJITCode(jitCode, jitCodeWithArityCheck);
-    return CompilationSuccessful;
-#else
-    UNUSED_PARAM(effort);
-    UNUSED_PARAM(bytecodeIndex);
-    UNUSED_PARAM(callback);
-    return CompilationFailed;
-#endif // ENABLE(JIT)
-}
-
-CompilationResult CodeBlock::prepareForExecution(
-    ExecState* exec, JITCode::JITType jitType,
-    JITCompilationEffort effort, unsigned bytecodeIndex)
-{
-    CompilationResult result =
-        prepareForExecutionImpl(exec, jitType, effort, bytecodeIndex, 0);
-    ASSERT(result != CompilationDeferred);
-    return result;
-}
-
-CompilationResult CodeBlock::prepareForExecutionAsynchronously(
-    ExecState* exec, JITCode::JITType jitType,
-    PassRefPtr<DeferredCompilationCallback> passedCallback,
-    JITCompilationEffort effort, unsigned bytecodeIndex)
-{
-    RefPtr<DeferredCompilationCallback> callback = passedCallback;
-    CompilationResult result =
-        prepareForExecutionImpl(exec, jitType, effort, bytecodeIndex, callback);
-    if (result != CompilationDeferred)
-        callback->compilationDidComplete(this, result);
-    return result;
-}
-
 void CodeBlock::install()
 {