Changeset 47304 in webkit for trunk/JavaScriptCore/bytecode

Timestamp:

Aug 14, 2009, 6:14:00 PM (16 years ago)

Author:

[email protected]

Message:

Remove AST nodes from use within the Runtime (outside of parsing), stage 1
​https://bugs.webkit.org/show_bug.cgi?id=28330

Reviewed by Oliver Hunt.

Remove the EvalNode and ProgramNode from use in the runtime. They still exist
after this patch, but are hidden behind EvalExecutable and FunctionExecutable,
and are also still reachable behind CodeBlock::m_ownerNode.

The next step will be to beat back FunctionBodyNode in the same fashion.
Then remove the usage via CodeBlock, then only construct these nodes only on
demand during bytecode generation.

• JavaScriptCore.xcodeproj/project.pbxproj:
• bytecode/CodeBlock.h:

(JSC::GlobalCodeBlock::GlobalCodeBlock):
(JSC::GlobalCodeBlock::~GlobalCodeBlock):
(JSC::ProgramCodeBlock::ProgramCodeBlock):
(JSC::EvalCodeBlock::EvalCodeBlock):
(JSC::FunctionCodeBlock::FunctionCodeBlock):
(JSC::NativeCodeBlock::NativeCodeBlock):

• bytecode/EvalCodeCache.h:

(JSC::EvalCodeCache::get):

• debugger/Debugger.cpp:

(JSC::evaluateInGlobalCallFrame):

• debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::evaluate):

• interpreter/Interpreter.cpp:

(JSC::Interpreter::callEval):
(JSC::Interpreter::execute):

• interpreter/Interpreter.h:
• parser/Nodes.cpp:

(JSC::FunctionBodyNode::createNativeThunk):
(JSC::FunctionBodyNode::generateBytecode):
(JSC::FunctionBodyNode::bytecodeForExceptionInfoReparse):

• parser/Parser.h:

(JSC::Parser::parse):
(JSC::Parser::reparse):
(JSC::Parser::parseFunctionFromGlobalCode):
(JSC::::parse):

• runtime/Completion.cpp:

(JSC::checkSyntax):
(JSC::evaluate):

• runtime/Error.cpp:

(JSC::throwError):

• runtime/Error.h:
• runtime/Executable.h: Added.

(JSC::TemplateExecutable::TemplateExecutable):
(JSC::TemplateExecutable::markAggregate):
(JSC::TemplateExecutable::sourceURL):
(JSC::TemplateExecutable::lineNo):
(JSC::TemplateExecutable::bytecode):
(JSC::TemplateExecutable::jitCode):
(JSC::EvalExecutable::EvalExecutable):
(JSC::ProgramExecutable::ProgramExecutable):

• runtime/FunctionConstructor.cpp:

(JSC::constructFunction):

• runtime/FunctionConstructor.h:
• runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::numericCompareFunction):

• runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::~JSGlobalObject):
(JSC::JSGlobalObject::markChildren):

• runtime/JSGlobalObject.h:

(JSC::JSGlobalObject::codeBlocks):

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncEval):

Location:

trunk/JavaScriptCore/bytecode

Files:

• CodeBlock.h (modified) (3 diffs)
• EvalCodeCache.h (modified) (3 diffs)

trunk/JavaScriptCore/bytecode/CodeBlock.h

@@ -251 +251 @@
     class CodeBlock : public FastAllocBase {
         friend class JIT;
-    public:
+    protected:
         CodeBlock(ScopeNode* ownerNode);
         CodeBlock(ScopeNode* ownerNode, CodeType, PassRefPtr<SourceProvider>, unsigned sourceOffset);
+    public:
         ~CodeBlock();
 
@@ -551 +552 @@
     // responsible for marking it.
 
-    class ProgramCodeBlock : public CodeBlock {
+    class GlobalCodeBlock : public CodeBlock {
+    public:
+        GlobalCodeBlock(ScopeNode* ownerNode, CodeType codeType, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset, JSGlobalObject* globalObject)
+            : CodeBlock(ownerNode, codeType, sourceProvider, sourceOffset)
+            , m_globalObject(globalObject)
+        {
+            m_globalObject->codeBlocks().add(this);
+        }
+
+        ~GlobalCodeBlock()
+        {
+            if (m_globalObject)
+                m_globalObject->codeBlocks().remove(this);
+        }
+
+        void clearGlobalObject() { m_globalObject = 0; }
+
+    private:
+        JSGlobalObject* m_globalObject; // For program and eval nodes, the global object that marks the constant pool.
+    };
+
+    class ProgramCodeBlock : public GlobalCodeBlock {
     public:
         ProgramCodeBlock(ScopeNode* ownerNode, CodeType codeType, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider)
-            : CodeBlock(ownerNode, codeType, sourceProvider, 0)
-            , m_globalObject(globalObject)
-        {
-            m_globalObject->codeBlocks().add(this);
-        }
-
-        ~ProgramCodeBlock()
-        {
-            if (m_globalObject)
-                m_globalObject->codeBlocks().remove(this);
-        }
-
-        void clearGlobalObject() { m_globalObject = 0; }
-
-    private:
-        JSGlobalObject* m_globalObject; // For program and eval nodes, the global object that marks the constant pool.
-    };
-
-    class EvalCodeBlock : public ProgramCodeBlock {
+            : GlobalCodeBlock(ownerNode, codeType, sourceProvider, 0, globalObject)
+        {
+        }
+    };
+
+    class EvalCodeBlock : public GlobalCodeBlock {
     public:
         EvalCodeBlock(ScopeNode* ownerNode, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider, int baseScopeDepth)
-            : ProgramCodeBlock(ownerNode, EvalCode, globalObject, sourceProvider)
+            : GlobalCodeBlock(ownerNode, EvalCode, sourceProvider, 0, globalObject)
             , m_baseScopeDepth(baseScopeDepth)
         {
@@ -584 +593 @@
     private:
         int m_baseScopeDepth;
+    };
+
+    class FunctionCodeBlock : public CodeBlock {
+    public:
+        FunctionCodeBlock(ScopeNode* ownerNode, CodeType codeType, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset)
+            : CodeBlock(ownerNode, codeType, sourceProvider, sourceOffset)
+        {
+        }
+    };
+
+    class NativeCodeBlock : public CodeBlock {
+    public:
+        NativeCodeBlock(ScopeNode* ownerNode)
+            : CodeBlock(ownerNode)
+        {
+        }
     };
 

trunk/JavaScriptCore/bytecode/EvalCodeCache.h

@@ -30 +30 @@
 #define EvalCodeCache_h
 
+#include "Executable.h"
 #include "JSGlobalObject.h"
 #include "Nodes.h"
@@ -42 +43 @@
     class EvalCodeCache {
     public:
-        PassRefPtr<EvalNode> get(ExecState* exec, const UString& evalSource, ScopeChainNode* scopeChain, JSValue& exceptionValue)
+        PassRefPtr<EvalExecutable> get(ExecState* exec, const UString& evalSource, ScopeChainNode* scopeChain, JSValue& exceptionValue)
         {
-            RefPtr<EvalNode> evalNode;
+            RefPtr<EvalExecutable> evalExecutable;
 
             if (evalSource.size() < maxCacheableSourceLength && (*scopeChain->begin())->isVariableObject())
-                evalNode = m_cacheMap.get(evalSource.rep());
+                evalExecutable = m_cacheMap.get(evalSource.rep());
 
-            if (!evalNode) {
-                int errorLine;
-                UString errorMessage;
-                
-                SourceCode source = makeSource(evalSource);
-                evalNode = exec->globalData().parser->parse<EvalNode>(exec, exec->dynamicGlobalObject()->debugger(), source, &errorLine, &errorMessage);
-                if (evalNode) {
-                    if (evalSource.size() < maxCacheableSourceLength && (*scopeChain->begin())->isVariableObject() && m_cacheMap.size() < maxCacheEntries)
-                        m_cacheMap.set(evalSource.rep(), evalNode);
-                } else {
-                    exceptionValue = Error::create(exec, SyntaxError, errorMessage, errorLine, source.provider()->asID(), 0);
+            if (!evalExecutable) {
+                evalExecutable = new EvalExecutable(makeSource(evalSource));
+                exceptionValue = evalExecutable->parse(exec);
+                if (exceptionValue)
                     return 0;
-                }
+
+                if (evalSource.size() < maxCacheableSourceLength && (*scopeChain->begin())->isVariableObject() && m_cacheMap.size() < maxCacheEntries)
+                    m_cacheMap.set(evalSource.rep(), evalExecutable);
             }
 
-            return evalNode.release();
+            return evalExecutable.release();
         }
 
@@ -79 +75 @@
         static const int maxCacheEntries = 64;
 
-        typedef HashMap<RefPtr<UString::Rep>, RefPtr<EvalNode> > EvalCacheMap;
+        typedef HashMap<RefPtr<UString::Rep>, RefPtr<EvalExecutable> > EvalCacheMap;
         EvalCacheMap m_cacheMap;
     };