Changeset 47641 in webkit for trunk/JavaScriptCore/runtime/JSFunction.cpp

Timestamp:

Aug 21, 2009, 2:54:20 PM (16 years ago)

Author:

[email protected]

Message:

Restructure Executable types so that host functions do not hold a FunctionExecutable.
​https://bugs.webkit.org/show_bug.cgi?id=28621

Reviewed by Oliver Hunt.

All JSFunction objects have a pointer to an Executable*. This is currently always a
FunctionExecutable, however this has a couple of drawbacks. Host functions do not
store a range of information that the FunctionExecutable provides (source, name,
CodeBlock & information presently held on the FunctionBodyNode).

[ * nearly all... see below! ]

Instead, make JSFunctions hold a pointer to an ExecutableBase, move fields specific
to JS sourced executable types (source, node) into a new subclass (ScriptExecutable),
and create a new NativeExecutable type. We now provide a new method in JSFunction
to access & downcast to FunctionExecutable, but in doing so we can make an early
check (with an ASSERT) to ensure that the Executable read from a function will only
be treated as a FunctionExecutable (and thus the JS sepcific fields will only be
accessed) if the JSFunction is not a host function.

There is one JSFunction that currently does not have an Executable, which is the
object created to allow us to read out the vtable pointer. By making this change
we can also add a new Executable type fror this object (VPtrHackExecutable).
Since this means that really all JSFunctions have an Executable we no longer have
to null-check m_executable before us it - particularly in isHostFunction().

This patch removes CacheableEvalExecutable, since all subclasses of ExecutableBase
can now be ref-counted - since both JSFunction holds (and ref-counts) an ExecutableBase
that might be a FunctionExecutable or a NativeExecutable. This does now mean that all
ProgramExecutables and EvalExecutables (unnecessarily) provide an interface to be
ref-counted, however this seems less-bad than host functions unnecessarily providing
interface to access non-host specific information.

The class hierarcy has changed from this:

• ExecutableBase
  • ProgramExecutable
  • EvalExecutable
    • CacheableEvalExecutable (also RefCounted by multiple-inheritance)
  • FunctionExecutable (also RefCounted by multiple-inheritance, 'special' FunctionExecutable also used for host functions)

To this:

• RefCounted
  • ExecutableBase
    • NativeExecutable
    • VPtrHackExecutable
    • ScriptExecutable
      • ProgramExecutable
      • EvalExecutable
      • FunctionExecutable

This patch speeds up sunspidey by a couple of ms (presumably due to the changes to isHostFunction()).

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::CodeBlock):

• bytecode/CodeBlock.h:

(JSC::CodeBlock::ownerExecutable):
(JSC::GlobalCodeBlock::GlobalCodeBlock):

• bytecode/EvalCodeCache.h:

(JSC::EvalCodeCache::get):

• debugger/Debugger.cpp:

(JSC::Debugger::recompileAllJSFunctions):

• interpreter/CachedCall.h:

(JSC::CachedCall::CachedCall):

• interpreter/Interpreter.cpp:

(JSC::Interpreter::callEval):
(JSC::Interpreter::privateExecute):

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

• profiler/Profiler.cpp:

(JSC::createCallIdentifierFromFunctionImp):

• runtime/Arguments.h:

(JSC::Arguments::getArgumentsData):
(JSC::Arguments::Arguments):

• runtime/Executable.cpp:

(JSC::NativeExecutable::~NativeExecutable):
(JSC::VPtrHackExecutable::~VPtrHackExecutable):

• runtime/Executable.h:

(JSC::ExecutableBase::ExecutableBase):
(JSC::ExecutableBase::~ExecutableBase):
(JSC::ExecutableBase::isHostFunction):
(JSC::NativeExecutable::NativeExecutable):
(JSC::VPtrHackExecutable::VPtrHackExecutable):
(JSC::ScriptExecutable::ScriptExecutable):
(JSC::ScriptExecutable::source):
(JSC::ScriptExecutable::sourceID):
(JSC::ScriptExecutable::sourceURL):
(JSC::ScriptExecutable::lineNo):
(JSC::ScriptExecutable::lastLine):
(JSC::ScriptExecutable::usesEval):
(JSC::ScriptExecutable::usesArguments):
(JSC::ScriptExecutable::needsActivation):
(JSC::EvalExecutable::EvalExecutable):
(JSC::EvalExecutable::create):
(JSC::ProgramExecutable::ProgramExecutable):
(JSC::FunctionExecutable::FunctionExecutable):

• runtime/FunctionPrototype.cpp:

(JSC::functionProtoFuncToString):

• runtime/JSFunction.cpp:

(JSC::JSFunction::JSFunction):
(JSC::JSFunction::~JSFunction):
(JSC::JSFunction::markChildren):
(JSC::JSFunction::getCallData):
(JSC::JSFunction::call):
(JSC::JSFunction::lengthGetter):
(JSC::JSFunction::getConstructData):
(JSC::JSFunction::construct):

• runtime/JSFunction.h:

(JSC::JSFunction::executable):
(JSC::JSFunction::jsExecutable):
(JSC::JSFunction::isHostFunction):

File:

• trunk/JavaScriptCore/runtime/JSFunction.cpp (modified) (10 diffs)

trunk/JavaScriptCore/runtime/JSFunction.cpp

@@ -46 +46 @@
 const ClassInfo JSFunction::info = { "Function", &InternalFunction::info, 0, 0 };
 
-inline bool JSFunction::isHostFunction() const
-{
-    return m_executable && m_executable->isHostFunction();
-}
-
 bool JSFunction::isHostFunctionNonInline() const
 {
@@ -58 +53 @@
 JSFunction::JSFunction(PassRefPtr<Structure> structure)
     : Base(structure)
-{
-    clearScopeChain();
+#if ENABLE(JIT)
+    , m_executable(adoptRef(new VPtrHackExecutable()))
+#endif
+{
 }
 
@@ -65 +62 @@
     : Base(&exec->globalData(), structure, name)
 #if ENABLE(JIT)
-    , m_executable(FunctionExecutable::createNativeThunk(exec))
+    , m_executable(adoptRef(new NativeExecutable(exec)))
 #endif
 {
@@ -92 +89 @@
     if (!isHostFunction()) {
 #if ENABLE(JIT_OPTIMIZE_CALL)
-        if (m_executable && m_executable->isGenerated())
-            m_executable->generatedBytecode().unlinkCallers();
+        ASSERT(m_executable);
+        if (jsExecutable()->isGenerated())
+            jsExecutable()->generatedBytecode().unlinkCallers();
 #endif
         scopeChain().~ScopeChain(); // FIXME: Don't we need to do this in the interpreter too?
@@ -102 +100 @@
 {
     Base::markChildren(markStack);
-    m_executable->markAggregate(markStack);
-    if (!isHostFunction())
+    if (!isHostFunction()) {
+        jsExecutable()->markAggregate(markStack);
         scopeChain().markAggregate(markStack);
+    }
 }
 
@@ -113 +112 @@
         return CallTypeHost;
     }
-    callData.js.functionExecutable = m_executable.get();
+    callData.js.functionExecutable = jsExecutable();
     callData.js.scopeChain = scopeChain().node();
     return CallTypeJS;
@@ -121 +120 @@
 {
     ASSERT(!isHostFunction());
-    return exec->interpreter()->execute(m_executable.get(), exec, this, thisValue.toThisObject(exec), args, scopeChain().node(), exec->exceptionSlot());
+    return exec->interpreter()->execute(jsExecutable(), exec, this, thisValue.toThisObject(exec), args, scopeChain().node(), exec->exceptionSlot());
 }
 
@@ -142 +141 @@
     JSFunction* thisObj = asFunction(slot.slotBase());
     ASSERT(!thisObj->isHostFunction());
-    return jsNumber(exec, thisObj->m_executable->parameterCount());
+    return jsNumber(exec, thisObj->jsExecutable()->parameterCount());
 }
 
@@ -206 +205 @@
     if (isHostFunction())
         return ConstructTypeNone;
-    constructData.js.functionExecutable = m_executable.get();
+    constructData.js.functionExecutable = jsExecutable();
     constructData.js.scopeChain = scopeChain().node();
     return ConstructTypeJS;
@@ -222 +221 @@
     JSObject* thisObj = new (exec) JSObject(structure);
 
-    JSValue result = exec->interpreter()->execute(m_executable.get(), exec, this, thisObj, args, scopeChain().node(), exec->exceptionSlot());
+    JSValue result = exec->interpreter()->execute(jsExecutable(), exec, this, thisObj, args, scopeChain().node(), exec->exceptionSlot());
     if (exec->hadException() || !result.isObject())
         return thisObj;