Changeset 47641 in webkit for trunk/JavaScriptCore/runtime/Executable.h

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/Executable.h (modified) (8 diffs)

trunk/JavaScriptCore/runtime/Executable.h

@@ -28 +28 @@
 
 #include "Nodes.h"
+#include "JSFunction.h"
 
 namespace JSC {
@@ -38 +39 @@
     struct ExceptionInfo;
 
-    class ExecutableBase {
+    class ExecutableBase : public RefCounted<ExecutableBase> {
         friend class JIT;
-    public:
-        enum Mode {
-            NoJITCode,
-            HasJITCode,
-            IsHost
-        };
+
+    protected:
         static const int NUM_PARAMETERS_IS_HOST = 0;
         static const int NUM_PARAMETERS_NOT_COMPILED = -1;
     
+    public:
+        ExecutableBase(int numParameters)
+            : m_numParameters(numParameters)
+        {
+        }
+
         virtual ~ExecutableBase() {}
 
-        ExecutableBase(const SourceCode& source)
-            : m_source(source)
-            , m_numParameters(NUM_PARAMETERS_NOT_COMPILED)
+        bool isHostFunction() const { return m_numParameters == NUM_PARAMETERS_IS_HOST; }
+
+    protected:
+        int m_numParameters;
+
+#if ENABLE(JIT)
+    public:
+        JITCode& generatedJITCode()
+        {
+            ASSERT(m_jitCode);
+            return m_jitCode;
+        }
+
+        ExecutablePool* getExecutablePool()
+        {
+            return m_jitCode.getExecutablePool();
+        }
+
+    protected:
+        JITCode m_jitCode;
+#endif
+    };
+
+    class NativeExecutable : public ExecutableBase {
+    public:
+        NativeExecutable(ExecState* exec)
+            : ExecutableBase(NUM_PARAMETERS_IS_HOST)
+        {
+            m_jitCode = JITCode(JITCode::HostFunction(exec->globalData().jitStubs.ctiNativeCallThunk()));
+        }
+
+        ~NativeExecutable();
+    };
+
+    class VPtrHackExecutable : public ExecutableBase {
+    public:
+        VPtrHackExecutable()
+            : ExecutableBase(NUM_PARAMETERS_IS_HOST)
+        {
+        }
+
+        ~VPtrHackExecutable();
+    };
+
+    class ScriptExecutable : public ExecutableBase {
+    public:
+        ScriptExecutable(const SourceCode& source)
+            : ExecutableBase(NUM_PARAMETERS_NOT_COMPILED)
+            , m_source(source)
         {
         }
@@ -70 +119 @@
 
     protected:
+        SourceCode m_source;
         RefPtr<ScopeNode> m_node;
-        SourceCode m_source;
-        int m_numParameters;
-
-    private:
-        // For use making native thunk.
-        friend class FunctionExecutable;
-        ExecutableBase()
-        {
-        }
-
-#if ENABLE(JIT)
-    public:
-        JITCode& generatedJITCode()
-        {
-            ASSERT(m_jitCode);
-            return m_jitCode;
-        }
-
-        ExecutablePool* getExecutablePool()
-        {
-            return m_jitCode.getExecutablePool();
-        }
-
-    protected:
-        JITCode m_jitCode;
-#endif
-    };
-
-    class EvalExecutable : public ExecutableBase {
+    };
+
+    class EvalExecutable : public ScriptExecutable {
     public:
         EvalExecutable(const SourceCode& source)
-            : ExecutableBase(source)
+            : ScriptExecutable(source)
             , m_evalCodeBlock(0)
         {
@@ -120 +144 @@
         ExceptionInfo* reparseExceptionInfo(JSGlobalData*, ScopeChainNode*, CodeBlock*);
 
+        static PassRefPtr<EvalExecutable> create(const SourceCode& source) { return adoptRef(new EvalExecutable(source)); }
+
     private:
         EvalNode* evalNode() { return static_cast<EvalNode*>(m_node.get()); }
@@ -141 +167 @@
     };
 
-    class CacheableEvalExecutable : public EvalExecutable, public RefCounted<CacheableEvalExecutable> {
-    public:
-        static PassRefPtr<CacheableEvalExecutable> create(const SourceCode& source) { return adoptRef(new CacheableEvalExecutable(source)); }
-
-    private:
-        CacheableEvalExecutable(const SourceCode& source)
-            : EvalExecutable(source)
-        {
-        }
-    };
-
-    class ProgramExecutable : public ExecutableBase {
+    class ProgramExecutable : public ScriptExecutable {
     public:
         ProgramExecutable(const SourceCode& source)
-            : ExecutableBase(source)
+            : ScriptExecutable(source)
             , m_programCodeBlock(0)
         {
@@ -195 +210 @@
     };
 
-    class FunctionExecutable : public ExecutableBase, public RefCounted<FunctionExecutable> {
+    class FunctionExecutable : public ScriptExecutable {
         friend class JIT;
     public:
         FunctionExecutable(const Identifier& name, FunctionBodyNode* body)
-            : ExecutableBase(body->source())
+            : ScriptExecutable(body->source())
             , m_codeBlock(0)
             , m_name(name)
@@ -232 +247 @@
         UString paramString() const { return body()->paramString(); }
 
-        bool isHostFunction() const { return m_numParameters == NUM_PARAMETERS_IS_HOST; }
         bool isGenerated() const
         {
@@ -262 +276 @@
         }
 
-        static PassRefPtr<FunctionExecutable> createNativeThunk(ExecState* exec)
-        {
-            return adoptRef(new FunctionExecutable(exec));
-        }
-
-    private:
-        FunctionExecutable(ExecState* exec);
+    private:
         void generateJITCode(ScopeChainNode*);
 #endif
     };
 
-};
-
-#endif
+    inline FunctionExecutable* JSFunction::jsExecutable() const { ASSERT(!isHostFunctionNonInline()); return static_cast<FunctionExecutable*>(m_executable.get()); }
+
+    inline JSFunction* FunctionExecutable::make(ExecState* exec, ScopeChainNode* scopeChain)
+    {
+        return new (exec) JSFunction(exec, this, scopeChain);
+    }
+
+    inline bool JSFunction::isHostFunction() const
+    {
+        ASSERT(m_executable);
+        return m_executable->isHostFunction();
+    }
+
+}
+
+#endif