Changeset 47597 in webkit for trunk/JavaScriptCore/runtime

Timestamp:

Aug 20, 2009, 2:49:07 PM (16 years ago)

Author:

[email protected]

Message:

Remove FunctionCodeBlock.
​https://bugs.webkit.org/show_bug.cgi?id=28502

Reviewed by Oliver Hunt.

These only exist to allow JIT code to dereference properties off the
CodeBlock for any callee, regardless of whether it is a host function.

Instead just use the FunctionExecutable. Copy the m_parameters field
from the CodeBlock into the Executable, and use this to distinguish
between host functions, functions that have been bytecompiled, and
functions that have not.

m_parameters is moved to ExecutableBase rather than FunctionExecutable
so that (as a separate change) we can move make a separate class of
executable for host code, which is not devived from FunctionExecutable
(host code does not feature any of the properties that normal executable
do and will provide, such as source, attributes, and a parsed name).

1% win on v8 tests, 0.5% on sunspider.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::derefStructures):
(JSC::CodeBlock::refStructures):
(JSC::CodeBlock::reparseForExceptionInfoIfNecessary):
(JSC::CodeBlock::handlerForBytecodeOffset):
(JSC::CodeBlock::lineNumberForBytecodeOffset):
(JSC::CodeBlock::expressionRangeForBytecodeOffset):
(JSC::CodeBlock::getByIdExceptionInfoForBytecodeOffset):
(JSC::CodeBlock::functionRegisterForBytecodeOffset):
(JSC::CodeBlock::hasGlobalResolveInstructionAtBytecodeOffset):
(JSC::CodeBlock::hasGlobalResolveInfoAtBytecodeOffset):

• bytecode/CodeBlock.h:

(JSC::):
(JSC::CodeBlock::source):
(JSC::CodeBlock::sourceOffset):
(JSC::CodeBlock::evalCodeCache):
(JSC::CodeBlock::createRareDataIfNecessary):

remove NativeCodeBlocks and the NativeCode code type.

• jit/JIT.cpp:

(JSC::JIT::linkCall):

Revert to previous behaviour (as currently still commented!) that Hhost functions have a null codeblock.

• jit/JITCall.cpp:

(JSC::JIT::compileOpCallInitializeCallFrame):
(JSC::JIT::compileOpCallSetupArgs):
(JSC::JIT::compileOpCallVarargsSetupArgs):
(JSC::JIT::compileOpConstructSetupArgs):
(JSC::JIT::compileOpCallVarargs):
(JSC::JIT::compileOpCall):
(JSC::JIT::compileOpCallSlowCase):

Bring the 32_64 & non-32_64 JITs into line with each other, callee in regT0.

• jit/JITOpcodes.cpp:

(JSC::JIT::privateCompileCTIMachineTrampolines):

Rewrite call trampolines to not use the CodeBlock.

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

Make call_JSFunction & call_arityCheck return the callee, don't expect to be passed the CodeBlock.

• runtime/Executable.cpp:

(JSC::FunctionExecutable::generateBytecode):
(JSC::FunctionExecutable::recompile):
(JSC::FunctionExecutable::FunctionExecutable):

• runtime/Executable.h:

(JSC::ExecutableBase::):
(JSC::ExecutableBase::ExecutableBase):
(JSC::FunctionExecutable::isHostFunction):

Add m_numParameters.

• runtime/JSFunction.cpp:

(JSC::JSFunction::~JSFunction):

Only call generatedBytecode() on JSFunctions non-host FunctionExecutables.

Location:

trunk/JavaScriptCore/runtime

Files:

• Executable.cpp (modified) (4 diffs)
• Executable.h (modified) (3 diffs)
• JSFunction.cpp (modified) (1 diff)

trunk/JavaScriptCore/runtime/Executable.cpp

@@ -86 +86 @@
     OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(body(), globalObject->debugger(), scopeChain, &m_codeBlock->symbolTable(), m_codeBlock));
     generator->generate();
+    m_numParameters = m_codeBlock->m_numParameters;
+    ASSERT(m_numParameters);
 
     body()->destroyData();
@@ -126 +128 @@
 
 #endif
-
-bool FunctionExecutable::isHostFunction() const
-{
-    return m_codeBlock && m_codeBlock->codeType() == NativeCode;
-}
 
 void FunctionExecutable::markAggregate(MarkStack& markStack)
@@ -198 +195 @@
     delete m_codeBlock;
     m_codeBlock = 0;
+    m_numParameters = NUM_PARAMETERS_NOT_COMPILED;
 #if ENABLE(JIT)
     m_jitCode = JITCode();
@@ -205 +203 @@
 #if ENABLE(JIT)
 FunctionExecutable::FunctionExecutable(ExecState* exec)
-    : m_codeBlock(new NativeCodeBlock(this))
+    : m_codeBlock(0)
     , m_name(Identifier(exec, "<native thunk>"))
 {
     m_jitCode = JITCode(JITCode::HostFunction(exec->globalData().jitStubs.ctiNativeCallThunk()));
+    m_numParameters = NUM_PARAMETERS_IS_HOST;
 }
 #endif

trunk/JavaScriptCore/runtime/Executable.h

@@ -41 +41 @@
         friend class JIT;
     public:
+        enum Mode {
+            NoJITCode,
+            HasJITCode,
+            IsHost
+        };
+        static const int NUM_PARAMETERS_IS_HOST = 0;
+        static const int NUM_PARAMETERS_NOT_COMPILED = -1;
+    
         virtual ~ExecutableBase() {}
 
         ExecutableBase(const SourceCode& source)
             : m_source(source)
+            , m_numParameters(NUM_PARAMETERS_NOT_COMPILED)
         {
         }
@@ -63 +72 @@
         RefPtr<ScopeNode> m_node;
         SourceCode m_source;
+        int m_numParameters;
 
     private:
@@ -220 +230 @@
         UString paramString() const { return body()->paramString(); }
 
-        bool isHostFunction() const;
+        bool isHostFunction() const { return m_numParameters == NUM_PARAMETERS_IS_HOST; }
         bool isGenerated() const
         {

trunk/JavaScriptCore/runtime/JSFunction.cpp

@@ -90 +90 @@
     // are based on a check for the this pointer value for this JSFunction - which will no longer be valid once
     // this memory is freed and may be reused (potentially for another, different JSFunction).
+    if (!isHostFunction()) {
 #if ENABLE(JIT_OPTIMIZE_CALL)
-    if (m_executable && m_executable->isGenerated())
-        m_executable->generatedBytecode().unlinkCallers();
+        if (m_executable && m_executable->isGenerated())
+            m_executable->generatedBytecode().unlinkCallers();
 #endif
-    if (!isHostFunction())
         scopeChain().~ScopeChain(); // FIXME: Don't we need to do this in the interpreter too?
+    }
 }