Changeset 38635 in webkit for trunk/JavaScriptCore/parser/Nodes.h

Timestamp:

Nov 20, 2008, 3:23:59 PM (17 years ago)

Author:

[email protected]

Message:

2008-11-20 Sam Weinig <​[email protected]>

Reviewed by Darin Adler.

Patch for ​https://bugs.webkit.org/show_bug.cgi?id=22385
<rdar://problem/6390179>
Lazily reparse FunctionBodyNodes on first execution.

• Saves 57MB on Membuster head.

• bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::generate): Remove vector shrinking since this is now handled by destroying the ScopeNodeData after generation.

• parser/Grammar.y: Add alternate NoNode version of the grammar that does not create nodes. This is used to lazily create FunctionBodyNodes on first execution.

• parser/Lexer.cpp: (JSC::Lexer::setCode): Fix bug where on reparse, the Lexer was confused about what position and length meant. Position is the current position in the original data buffer (important for getting correct line/column information) and length the end offset in the original buffer.
• parser/Lexer.h: (JSC::Lexer::sourceCode): Positions are relative to the beginning of the buffer.

• parser/Nodes.cpp: (JSC::ScopeNodeData::ScopeNodeData): Move initialization of ScopeNode data here. (JSC::ScopeNode::ScopeNode): Add constructor that only sets the JSGlobalData for FunctionBodyNode stubs. (JSC::ScopeNode::~ScopeNode): Release m_children now that we don't inherit from BlockNode. (JSC::ScopeNode::releaseNodes): Ditto. (JSC::EvalNode::generateBytecode): Only shrink m_children, as we need to keep around the rest of the data. (JSC::FunctionBodyNode::FunctionBodyNode): Add constructor that only sets the JSGlobalData. (JSC::FunctionBodyNode::create): Ditto. (JSC::FunctionBodyNode::generateBytecode): If we don't have the data, do a reparse to construct it. Then after generation, destroy the data. (JSC::ProgramNode::generateBytecode): After generation, destroy the AST data.
• parser/Nodes.h: (JSC::ExpressionNode::): Add isFuncExprNode for FunctionConstructor. (JSC::StatementNode::): Add isExprStatementNode for FunctionConstructor. (JSC::ExprStatementNode::): Ditto. (JSC::ExprStatementNode::expr): Add accessor for FunctionConstructor. (JSC::FuncExprNode::): Add isFuncExprNode for FunctionConstructor

(JSC::ScopeNode::adoptData): Adopts a ScopeNodeData.
(JSC::ScopeNode::data): Accessor for ScopeNodeData.
(JSC::ScopeNode::destroyData): Deletes the ScopeNodeData.
(JSC::ScopeNode::setFeatures): Added.
(JSC::ScopeNode::varStack): Added assert.
(JSC::ScopeNode::functionStack): Ditto.
(JSC::ScopeNode::children): Ditto.
(JSC::ScopeNode::neededConstants): Ditto.
Factor m_varStack, m_functionStack, m_children and m_numConstants into ScopeNodeData.

• parser/Parser.cpp: (JSC::Parser::reparse): Reparse the SourceCode in the FunctionBodyNode and set set up the ScopeNodeData for it.
• parser/Parser.h:

• parser/SourceCode.h: (JSC::SourceCode::endOffset): Added for use in the lexer.

• runtime/FunctionConstructor.cpp: (JSC::getFunctionBody): Assuming a ProgramNode with one FunctionExpression in it, get the FunctionBodyNode. Any issues signifies a parse failure in constructFunction. (JSC::constructFunction): Make parsing functions in the form new Function(""), easier by concatenating the strings together (with some glue) and parsing the function expression as a ProgramNode from which we can receive the FunctionBodyNode. This has the added benefit of not having special parsing code for the arguments and lazily constructing the FunctionBodyNode's AST on first execution.

• runtime/Identifier.h: (JSC::operator!=): Added.

File:

• trunk/JavaScriptCore/parser/Nodes.h (modified) (10 diffs)

trunk/JavaScriptCore/parser/Nodes.h

@@ -171 +171 @@
         virtual bool isBracketAccessorNode() const JSC_FAST_CALL { return false; }
         virtual bool isDotAccessorNode() const JSC_FAST_CALL { return false; }
+        virtual bool isFuncExprNode() const JSC_FAST_CALL { return false; } 
 
         virtual ExpressionNode* stripUnaryPlus() { return this; }
@@ -192 +193 @@
         virtual bool isEmptyStatement() const JSC_FAST_CALL { return false; }
         virtual bool isReturnNode() const JSC_FAST_CALL { return false; }
+        virtual bool isExprStatement() const JSC_FAST_CALL { return false; }
 
         virtual bool isBlock() const JSC_FAST_CALL { return false; }
@@ -1743 +1745 @@
         }
 
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
+        virtual bool isExprStatement() const JSC_FAST_CALL { return true; }
+
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
+
+        ExpressionNode* expr() const { return m_expr.get(); }
 
     private:
@@ -2057 +2063 @@
     };
 
-    class ScopeNode : public BlockNode {
-    public:
+    struct ScopeNodeData {
         typedef DeclarationStacks::VarStack VarStack;
         typedef DeclarationStacks::FunctionStack FunctionStack;
 
+        ScopeNodeData(SourceElements*, VarStack*, FunctionStack*, int numConstants);
+
+        VarStack m_varStack;
+        FunctionStack m_functionStack;
+        int m_numConstants;
+        StatementVector m_children;
+    };
+
+    class ScopeNode : public StatementNode {
+    public:
+        typedef DeclarationStacks::VarStack VarStack;
+        typedef DeclarationStacks::FunctionStack FunctionStack;
+
+        ScopeNode(JSGlobalData*) JSC_FAST_CALL;
         ScopeNode(JSGlobalData*, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, CodeFeatures, int numConstants) JSC_FAST_CALL;
+        virtual ~ScopeNode();
+        virtual void releaseNodes(NodeReleaser&);
+
+        void adoptData(std::auto_ptr<ScopeNodeData> data) { m_data.adopt(data); }
+        ScopeNodeData* data() const { return m_data.get(); }
+        void destroyData() { m_data.clear(); }
 
         const SourceCode& source() const { return m_source; }
@@ -2068 +2093 @@
         intptr_t sourceID() const { return m_source.provider()->asID(); }
 
+        void setFeatures(CodeFeatures features) { m_features = features; }
         bool usesEval() const { return m_features & EvalFeature; }
         bool usesArguments() const { return m_features & ArgumentsFeature; }
@@ -2074 +2100 @@
         bool needsActivation() const { return m_features & (EvalFeature | ClosureFeature | WithFeature | CatchFeature); }
 
-        VarStack& varStack() { return m_varStack; }
-        FunctionStack& functionStack() { return m_functionStack; }
+        VarStack& varStack() { ASSERT(m_data); return m_data->m_varStack; }
+        FunctionStack& functionStack() { ASSERT(m_data); return m_data->m_functionStack; }
+
+        StatementVector& children() { ASSERT(m_data); return m_data->m_children; }
 
         int neededConstants()
         {
+            ASSERT(m_data);
             // We may need 2 more constants than the count given by the parser,
             // because of the various uses of jsUndefined() and jsNull().
-            return m_numConstants + 2;
+            return m_data->m_numConstants + 2;
         }
 
@@ -2087 +2116 @@
         void setSource(const SourceCode& source) { m_source = source; }
 
-        VarStack m_varStack;
-        FunctionStack m_functionStack;
-
-    private:
+    private:
+        OwnPtr<ScopeNodeData> m_data;
+        CodeFeatures m_features;
         SourceCode m_source;
-        CodeFeatures m_features;
-        int m_numConstants;
     };
 
@@ -2142 +2168 @@
         friend class JIT;
     public:
+        static FunctionBodyNode* create(JSGlobalData*) JSC_FAST_CALL;
         static FunctionBodyNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL;
-        static FunctionBodyNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, CodeFeatures, int numConstants) JSC_FAST_CALL;
-        ~FunctionBodyNode();
+        virtual ~FunctionBodyNode();
 
         const Identifier* parameters() const JSC_FAST_CALL { return m_parameters; }
@@ -2194 +2220 @@
 
     private:
+        FunctionBodyNode(JSGlobalData*) JSC_FAST_CALL;
         FunctionBodyNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL;
 
@@ -2217 +2244 @@
         virtual ~FuncExprNode();
         virtual void releaseNodes(NodeReleaser&);
+
+        virtual bool isFuncExprNode() const JSC_FAST_CALL { return true; } 
 
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;