Ignore:
Timestamp:
Aug 24, 2009, 7:53:51 PM (16 years ago)
Author:
[email protected]
Message:

​https://bugs.webkit.org/show_bug.cgi?id=28691
Do not retain ScopeNodes outside of parsing

Reviewed by Oliver Adler & Darin Hunt.

There is now no need for these to exist outside of parsing - their use in the runtime is replaced by Executable types.

  • bytecode/EvalCodeCache.h:

(JSC::EvalCodeCache::get):

  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::BytecodeGenerator):
(JSC::BytecodeGenerator::emitNewFunction):
(JSC::BytecodeGenerator::emitNewFunctionExpression):

  • bytecompiler/BytecodeGenerator.h:

(JSC::BytecodeGenerator::makeFunction):

  • debugger/Debugger.cpp:

(JSC::Debugger::recompileAllJSFunctions):
(JSC::evaluateInGlobalCallFrame):

  • debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::evaluate):

  • interpreter/Interpreter.cpp:

(JSC::Interpreter::execute):
(JSC::Interpreter::prepareForRepeatCall):
(JSC::Interpreter::privateExecute):

  • jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

  • parser/Nodes.cpp:

(JSC::ScopeNodeData::ScopeNodeData):
(JSC::ProgramNode::create):
(JSC::EvalNode::create):
(JSC::FunctionBodyNode::create):

  • parser/Nodes.h:

(JSC::ScopeNode::adoptData):
(JSC::FunctionBodyNode::parameterCount):

  • parser/Parser.cpp:
  • parser/Parser.h:

(JSC::Parser::arena):
(JSC::Parser::Parser):
(JSC::Parser::parse):

  • runtime/ArrayPrototype.cpp:

(JSC::isNumericCompareFunction):
(JSC::arrayProtoFuncSort):

  • runtime/Completion.cpp:

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

  • runtime/Executable.cpp:

(JSC::FunctionExecutable::~FunctionExecutable):
(JSC::EvalExecutable::compile):
(JSC::ProgramExecutable::checkSyntax):
(JSC::ProgramExecutable::compile):
(JSC::FunctionExecutable::compile):
(JSC::EvalExecutable::generateJITCode):
(JSC::ProgramExecutable::generateJITCode):
(JSC::FunctionExecutable::generateJITCode):
(JSC::FunctionExecutable::reparseExceptionInfo):
(JSC::EvalExecutable::reparseExceptionInfo):
(JSC::FunctionExecutable::recompile):
(JSC::FunctionExecutable::fromGlobalCode):
(JSC::FunctionExecutable::copyParameters):
(JSC::FunctionExecutable::paramString):

  • runtime/Executable.h:

(JSC::ScriptExecutable::ScriptExecutable):
(JSC::ScriptExecutable::sourceID):
(JSC::ScriptExecutable::sourceURL):
(JSC::ScriptExecutable::lineNo):
(JSC::ScriptExecutable::lastLine):
(JSC::ScriptExecutable::usesEval):
(JSC::ScriptExecutable::usesArguments):
(JSC::ScriptExecutable::needsActivation):
(JSC::ScriptExecutable::recordParse):
(JSC::EvalExecutable::bytecode):
(JSC::EvalExecutable::jitCode):
(JSC::ProgramExecutable::bytecode):
(JSC::ProgramExecutable::reparseExceptionInfo):
(JSC::ProgramExecutable::jitCode):
(JSC::FunctionExecutable::FunctionExecutable):
(JSC::FunctionExecutable::make):
(JSC::FunctionExecutable::bytecode):
(JSC::FunctionExecutable::isGenerated):
(JSC::FunctionExecutable::name):
(JSC::FunctionExecutable::parameterCount):
(JSC::FunctionExecutable::jitCode):

  • runtime/FunctionConstructor.cpp:

(JSC::constructFunction):

  • runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::numericCompareFunction):

  • runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncEval):

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/runtime/Executable.cpp

    r47660 r47738  
    3131#include "JIT.h"
    3232#include "Parser.h"
     33#include "Vector.h"
    3334
    3435namespace JSC {
    … …  
    5657FunctionExecutable::~FunctionExecutable()
    5758{
     59    for (int i = 0; i < m_parameterCount; ++i)
     60        m_parameters[i].~Identifier();
     61    fastFree(m_parameters);
    5862    delete m_codeBlock;
    5963}
    6064
    61 void EvalExecutable::generateBytecode(ScopeChainNode* scopeChainNode)
    62 {
     65JSObject* EvalExecutable::compile(ExecState* exec, ScopeChainNode* scopeChainNode)
     66{
     67    int errLine;
     68    UString errMsg;
     69    RefPtr<EvalNode> evalNode = exec->globalData().parser->parse<EvalNode>(&exec->globalData(), exec->lexicalGlobalObject()->debugger(), exec, m_source, &errLine, &errMsg);
     70    if (!evalNode)
     71        return Error::create(exec, SyntaxError, errMsg, errLine, m_source.provider()->asID(), m_source.provider()->url());
     72    recordParse(evalNode->features(), evalNode->lineNo(), evalNode->lastLine());
     73
    6374    ScopeChain scopeChain(scopeChainNode);
    6475    JSGlobalObject* globalObject = scopeChain.globalObject();
    … …  
    6677    ASSERT(!m_evalCodeBlock);
    6778    m_evalCodeBlock = new EvalCodeBlock(this, globalObject, source().provider(), scopeChain.localDepth());
    68     OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(evalNode(), globalObject->debugger(), scopeChain, m_evalCodeBlock->symbolTable(), m_evalCodeBlock));
     79    OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(evalNode.get(), globalObject->debugger(), scopeChain, m_evalCodeBlock->symbolTable(), m_evalCodeBlock));
    6980    generator->generate();
    7081   
    71     evalNode()->destroyData();
    72 }
    73 
    74 void ProgramExecutable::generateBytecode(ScopeChainNode* scopeChainNode)
    75 {
     82    evalNode->destroyData();
     83    return 0;
     84}
     85
     86JSObject* ProgramExecutable::checkSyntax(ExecState* exec)
     87{
     88    int errLine;
     89    UString errMsg;
     90    RefPtr<ProgramNode> programNode = exec->globalData().parser->parse<ProgramNode>(&exec->globalData(), exec->lexicalGlobalObject()->debugger(), exec, m_source, &errLine, &errMsg);
     91    if (!programNode)
     92        return Error::create(exec, SyntaxError, errMsg, errLine, m_source.provider()->asID(), m_source.provider()->url());
     93    return 0;
     94}
     95
     96JSObject* ProgramExecutable::compile(ExecState* exec, ScopeChainNode* scopeChainNode)
     97{
     98    int errLine;
     99    UString errMsg;
     100    RefPtr<ProgramNode> programNode = exec->globalData().parser->parse<ProgramNode>(&exec->globalData(), exec->lexicalGlobalObject()->debugger(), exec, m_source, &errLine, &errMsg);
     101    if (!programNode)
     102        return Error::create(exec, SyntaxError, errMsg, errLine, m_source.provider()->asID(), m_source.provider()->url());
     103    recordParse(programNode->features(), programNode->lineNo(), programNode->lastLine());
     104
    76105    ScopeChain scopeChain(scopeChainNode);
    77106    JSGlobalObject* globalObject = scopeChain.globalObject();
    … …  
    79108    ASSERT(!m_programCodeBlock);
    80109    m_programCodeBlock = new ProgramCodeBlock(this, GlobalCode, globalObject, source().provider());
    81     OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(programNode(), globalObject->debugger(), scopeChain, &globalObject->symbolTable(), m_programCodeBlock));
    82     generator->generate();
    83 
    84     programNode()->destroyData();
    85 }
    86 
    87 void FunctionExecutable::generateBytecode(ScopeChainNode* scopeChainNode)
    88 {
    89     body()->reparseDataIfNecessary(scopeChainNode);
     110    OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(programNode.get(), globalObject->debugger(), scopeChain, &globalObject->symbolTable(), m_programCodeBlock));
     111    generator->generate();
     112
     113    programNode->destroyData();
     114    return 0;
     115}
     116
     117void FunctionExecutable::compile(ExecState*, ScopeChainNode* scopeChainNode)
     118{
     119    JSGlobalData* globalData = scopeChainNode->globalData;
     120    RefPtr<FunctionBodyNode> body = globalData->parser->parse<FunctionBodyNode>(globalData, 0, 0, m_source);
     121    if (m_forceUsesArguments)
     122        body->setUsesArguments();
     123    body->finishParsing(copyParameters(), m_parameterCount, m_name);
     124    recordParse(body->features(), body->lineNo(), body->lastLine());
    90125
    91126    ScopeChain scopeChain(scopeChainNode);
    … …  
    94129    ASSERT(!m_codeBlock);
    95130    m_codeBlock = new FunctionCodeBlock(this, FunctionCode, source().provider(), source().startOffset());
    96     OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(body(), globalObject->debugger(), scopeChain, m_codeBlock->symbolTable(), m_codeBlock));
     131    OwnPtr<BytecodeGenerator> generator(new BytecodeGenerator(body.get(), globalObject->debugger(), scopeChain, m_codeBlock->symbolTable(), m_codeBlock));
    97132    generator->generate();
    98133    m_numParameters = m_codeBlock->m_numParameters;
    … …  
    100135    m_numVariables = m_codeBlock->m_numVars;
    101136
    102     body()->destroyData();
    103 }
    104 
    105 #if ENABLE(JIT)
    106 
    107 void EvalExecutable::generateJITCode(ScopeChainNode* scopeChainNode)
    108 {
    109     CodeBlock* codeBlock = &bytecode(scopeChainNode);
     137    body->destroyData();
     138}
     139
     140#if ENABLE(JIT)
     141
     142void EvalExecutable::generateJITCode(ExecState* exec, ScopeChainNode* scopeChainNode)
     143{
     144    CodeBlock* codeBlock = &bytecode(exec, scopeChainNode);
    110145    m_jitCode = JIT::compile(scopeChainNode->globalData, codeBlock);
    111146
    … …  
    116151}
    117152
    118 void ProgramExecutable::generateJITCode(ScopeChainNode* scopeChainNode)
    119 {
    120     CodeBlock* codeBlock = &bytecode(scopeChainNode);
     153void ProgramExecutable::generateJITCode(ExecState* exec, ScopeChainNode* scopeChainNode)
     154{
     155    CodeBlock* codeBlock = &bytecode(exec, scopeChainNode);
    121156    m_jitCode = JIT::compile(scopeChainNode->globalData, codeBlock);
    122157
    … …  
    127162}
    128163
    129 void FunctionExecutable::generateJITCode(ScopeChainNode* scopeChainNode)
    130 {
    131     CodeBlock* codeBlock = &bytecode(scopeChainNode);
     164void FunctionExecutable::generateJITCode(ExecState* exec, ScopeChainNode* scopeChainNode)
     165{
     166    CodeBlock* codeBlock = &bytecode(exec, scopeChainNode);
    132167    m_jitCode = JIT::compile(scopeChainNode->globalData, codeBlock);
    133168
    … …  
    148183ExceptionInfo* FunctionExecutable::reparseExceptionInfo(JSGlobalData* globalData, ScopeChainNode* scopeChainNode, CodeBlock* codeBlock)
    149184{
    150     RefPtr<FunctionBodyNode> newFunctionBody = globalData->parser->reparse<FunctionBodyNode>(globalData, body());
    151     ASSERT(newFunctionBody);
    152     newFunctionBody->finishParsing(body()->copyParameters(), body()->parameterCount(), body()->ident());
     185    RefPtr<FunctionBodyNode> newFunctionBody = globalData->parser->parse<FunctionBodyNode>(globalData, 0, 0, m_source);
     186    if (m_forceUsesArguments)
     187        newFunctionBody->setUsesArguments();
     188    newFunctionBody->finishParsing(copyParameters(), m_parameterCount, m_name);
    153189
    154190    ScopeChain scopeChain(scopeChainNode);
    … …  
    176212ExceptionInfo* EvalExecutable::reparseExceptionInfo(JSGlobalData* globalData, ScopeChainNode* scopeChainNode, CodeBlock* codeBlock)
    177213{
    178     RefPtr<EvalNode> newEvalBody = globalData->parser->reparse<EvalNode>(globalData, evalNode());
     214    RefPtr<EvalNode> newEvalBody = globalData->parser->parse<EvalNode>(globalData, 0, 0, m_source);
    179215
    180216    ScopeChain scopeChain(scopeChainNode);
    … …  
    197233}
    198234
    199 void FunctionExecutable::recompile(ExecState* exec)
    200 {
    201     FunctionBodyNode* oldBody = body();
    202     RefPtr<FunctionBodyNode> newBody = exec->globalData().parser->parse<FunctionBodyNode>(exec, 0, m_source);
    203     ASSERT(newBody);
    204     newBody->finishParsing(oldBody->copyParameters(), oldBody->parameterCount(), oldBody->ident());
    205     m_node = newBody;
     235void FunctionExecutable::recompile(ExecState*)
     236{
    206237    delete m_codeBlock;
    207238    m_codeBlock = 0;
    … …  
    212243}
    213244
     245PassRefPtr<FunctionExecutable> FunctionExecutable::fromGlobalCode(const Identifier& functionName, ExecState* exec, Debugger* debugger, const SourceCode& source, int* errLine, UString* errMsg)
     246{
     247    RefPtr<ProgramNode> program = exec->globalData().parser->parse<ProgramNode>(&exec->globalData(), debugger, exec, source, errLine, errMsg);
     248    if (!program)
     249        return 0;
     250
     251    StatementNode* exprStatement = program->singleStatement();
     252    ASSERT(exprStatement);
     253    ASSERT(exprStatement->isExprStatement());
     254    if (!exprStatement || !exprStatement->isExprStatement())
     255        return 0;
     256
     257    ExpressionNode* funcExpr = static_cast<ExprStatementNode*>(exprStatement)->expr();
     258    ASSERT(funcExpr);
     259    ASSERT(funcExpr->isFuncExprNode());
     260    if (!funcExpr || !funcExpr->isFuncExprNode())
     261        return 0;
     262
     263    FunctionBodyNode* body = static_cast<FuncExprNode*>(funcExpr)->body();
     264    ASSERT(body);
     265    return adoptRef(new FunctionExecutable(functionName, body->source(), body->usesArguments(), body->copyParameters(), body->parameterCount(), body->lineNo(), body->lastLine()));
     266}
     267
     268Identifier* FunctionExecutable::copyParameters()
     269{
     270    // This code uses the internal vector copier to make copy-constructed copies of the data in the array
     271    // (the array contains Identfiers which reference count Ustring::Reps, which must be ref'ed correctly).
     272    Identifier* parameters = static_cast<Identifier*>(fastMalloc(m_parameterCount * sizeof(Identifier)));
     273    WTF::VectorCopier<false, Identifier>::uninitializedCopy(m_parameters, m_parameters + m_parameterCount, parameters);
     274    return parameters;
     275}
     276
     277UString FunctionExecutable::paramString() const
     278{
     279    UString s("");
     280    for (int pos = 0; pos < m_parameterCount; ++pos) {
     281        if (!s.isEmpty())
     282            s += ", ";
     283        s += m_parameters[pos].ustring();
     284    }
     285
     286    return s;
     287}
     288
    214289};
    215290
Note: See TracChangeset for help on using the changeset viewer.