Ignore:
Timestamp:
Sep 5, 2012, 4:00:29 PM (13 years ago)
Author:
[email protected]
Message:

Merge prefix/postfix nodes
​https://bugs.webkit.org/show_bug.cgi?id=95898

Reviewed by Geoff Garen.

Simplify the AST.
This will also mean we have access to m_subscriptHasAssignments when generating a prefix/postfix op applied to a bracket access.

  • bytecompiler/NodesCodegen.cpp:

(JSC::PostfixNode::emitResolve):

  • was PostfixResolveNode::emitBytecode

(JSC::PostfixNode::emitBracket):

  • was PostfixBracketNode::emitBytecode

(JSC::PostfixNode::emitDot):

  • was PostfixDotNode::emitBytecode

(JSC::PostfixNode::emitBytecode):

  • was PostfixErrorNode::emitBytecode, call resolve/bracket/dot version as appropriate.

(JSC::PrefixNode::emitResolve):

  • was PrefixResolveNode::emitBytecode

(JSC::PrefixNode::emitBracket):

  • was PrefixBracketNode::emitBytecode

(JSC::PrefixNode::emitDot):

  • was PrefixDotNode::emitBytecode

(JSC::PrefixNode::emitBytecode):

  • was PrefixErrorNode::emitBytecode, call resolve/bracket/dot version as appropriate.
  • parser/ASTBuilder.h:

(JSC::ASTBuilder::makePrefixNode):

  • Just makes a PrefixNode!

(JSC::ASTBuilder::makePostfixNode):

  • Just makes a PostfixNode!
  • parser/NodeConstructors.h:

(JSC::PostfixNode::PostfixNode):

  • Added, merge of PostfixResolveNode/PostfixBracketNode/PostfixDotNode/PostfixErrorNode.

(JSC::PrefixNode::PrefixNode):

  • Added, merge of PrefixResolveNode/PrefixBracketNode/PrefixDotNode/PrefixErrorNode.
  • parser/Nodes.h:

(PostfixNode):

  • Added, merge of PostfixResolveNode/PostfixBracketNode/PostfixDotNode/PostfixErrorNode.

(PrefixNode):

  • Added, merge of PrefixResolveNode/PrefixBracketNode/PrefixDotNode/PrefixErrorNode.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

    r127647 r127654  
    591591}
    592592
    593 // ------------------------------ PostfixResolveNode ----------------------------------
     593// ------------------------------ PostfixNode ----------------------------------
    594594
    595595static RegisterID* emitPreIncOrDec(BytecodeGenerator& generator, RegisterID* srcDst, Operator oper)
    … …  
    605605}
    606606
    607 RegisterID* PostfixResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    608 {
    609     ResolveResult resolveResult = generator.resolve(m_ident);
     607RegisterID* PostfixNode::emitResolve(BytecodeGenerator& generator, RegisterID* dst)
     608{
     609    ASSERT(m_expr->isResolveNode());
     610    ResolveNode* resolve = static_cast<ResolveNode*>(m_expr);
     611    const Identifier& ident = resolve->identifier();
     612
     613    ResolveResult resolveResult = generator.resolve(ident);
    610614
    611615    if (RegisterID* local = resolveResult.local()) {
    … …  
    620624
    621625    if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
    622         RefPtr<RegisterID> value = generator.emitGetStaticVar(generator.newTemporary(), resolveResult, m_ident);
     626        RefPtr<RegisterID> value = generator.emitGetStaticVar(generator.newTemporary(), resolveResult, ident);
    623627        RegisterID* oldValue;
    624628        if (dst == generator.ignoredResult()) {
    … …  
    628632            oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
    629633        }
    630         generator.emitPutStaticVar(resolveResult, m_ident, value.get());
     634        generator.emitPutStaticVar(resolveResult, ident, value.get());
    631635        return oldValue;
    632636    }
    … …  
    634638    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    635639    RefPtr<RegisterID> value = generator.newTemporary();
    636     RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), value.get(), resolveResult, m_ident);
     640    RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), value.get(), resolveResult, ident);
    637641    RegisterID* oldValue;
    638642    if (dst == generator.ignoredResult()) {
    … …  
    642646        oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
    643647    }
    644     generator.emitPutById(base.get(), m_ident, value.get());
     648    generator.emitPutById(base.get(), ident, value.get());
    645649    return oldValue;
    646650}
    647651
    648 // ------------------------------ PostfixBracketNode ----------------------------------
    649 
    650 RegisterID* PostfixBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    651 {
    652     RefPtr<RegisterID> base = generator.emitNode(m_base);
    653     RefPtr<RegisterID> property = generator.emitNode(m_subscript);
    654 
    655     generator.emitExpressionInfo(divot() - m_subexpressionDivotOffset, startOffset() - m_subexpressionDivotOffset, m_subexpressionEndOffset);
     652RegisterID* PostfixNode::emitBracket(BytecodeGenerator& generator, RegisterID* dst)
     653{
     654    ASSERT(m_expr->isBracketAccessorNode());
     655    BracketAccessorNode* bracketAccessor = static_cast<BracketAccessorNode*>(m_expr);
     656    ExpressionNode* baseNode = bracketAccessor->base();
     657    ExpressionNode* subscript = bracketAccessor->subscript();
     658
     659    RefPtr<RegisterID> base = generator.emitNode(baseNode);
     660    RefPtr<RegisterID> property = generator.emitNode(subscript);
     661
     662    generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->startOffset(), bracketAccessor->endOffset());
    656663    RefPtr<RegisterID> value = generator.emitGetByVal(generator.newTemporary(), base.get(), property.get());
    657664    RegisterID* oldValue;
    … …  
    670677}
    671678
    672 // ------------------------------ PostfixDotNode ----------------------------------
    673 
    674 RegisterID* PostfixDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    675 {
    676     RefPtr<RegisterID> base = generator.emitNode(m_base);
    677 
    678     generator.emitExpressionInfo(divot() - m_subexpressionDivotOffset, startOffset() - m_subexpressionDivotOffset, m_subexpressionEndOffset);
    679     RefPtr<RegisterID> value = generator.emitGetById(generator.newTemporary(), base.get(), m_ident);
     679RegisterID* PostfixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
     680{
     681    ASSERT(m_expr->isDotAccessorNode());
     682    DotAccessorNode* dotAccessor = static_cast<DotAccessorNode*>(m_expr);
     683    ExpressionNode* baseNode = dotAccessor->base();
     684    const Identifier& ident = dotAccessor->identifier();
     685
     686    RefPtr<RegisterID> base = generator.emitNode(baseNode);
     687
     688    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->startOffset(), dotAccessor->endOffset());
     689    RefPtr<RegisterID> value = generator.emitGetById(generator.newTemporary(), base.get(), ident);
    680690    RegisterID* oldValue;
    681691    if (dst == generator.ignoredResult()) {
    … …  
    689699    }
    690700    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    691     generator.emitPutById(base.get(), m_ident, value.get());
     701    generator.emitPutById(base.get(), ident, value.get());
    692702    return oldValue;
    693703}
    694704
    695 // ------------------------------ PostfixErrorNode -----------------------------------
    696 
    697 RegisterID* PostfixErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    698 {
     705RegisterID* PostfixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
     706{
     707    if (m_expr->isResolveNode())
     708        return emitResolve(generator, dst);
     709
     710    if (m_expr->isBracketAccessorNode())
     711        return emitBracket(generator, dst);
     712
     713    if (m_expr->isDotAccessorNode())
     714        return emitDot(generator, dst);
     715
    699716    return emitThrowReferenceError(generator, m_operator == OpPlusPlus
    700717        ? "Postfix ++ operator applied to value that is not a reference."
    … …  
    788805}
    789806
    790 // ------------------------------ PrefixResolveNode ----------------------------------
    791 
    792 RegisterID* PrefixResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    793 {
    794     ResolveResult resolveResult = generator.resolve(m_ident);
     807// ------------------------------ PrefixNode ----------------------------------
     808
     809RegisterID* PrefixNode::emitResolve(BytecodeGenerator& generator, RegisterID* dst)
     810{
     811    ASSERT(m_expr->isResolveNode());
     812    ResolveNode* resolve = static_cast<ResolveNode*>(m_expr);
     813    const Identifier& ident = resolve->identifier();
     814
     815    ResolveResult resolveResult = generator.resolve(ident);
    795816    if (RegisterID* local = resolveResult.local()) {
    796817        if (resolveResult.isReadOnly()) {
    … …  
    807828
    808829    if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
    809         RefPtr<RegisterID> propDst = generator.emitGetStaticVar(generator.tempDestination(dst), resolveResult, m_ident);
     830        RefPtr<RegisterID> propDst = generator.emitGetStaticVar(generator.tempDestination(dst), resolveResult, ident);
    810831        emitPreIncOrDec(generator, propDst.get(), m_operator);
    811         generator.emitPutStaticVar(resolveResult, m_ident, propDst.get());
     832        generator.emitPutStaticVar(resolveResult, ident, propDst.get());
    812833        return generator.moveToDestinationIfNeeded(dst, propDst.get());
    813834    }
    … …  
    815836    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    816837    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    817     RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), propDst.get(), resolveResult, m_ident);
     838    RefPtr<RegisterID> base = generator.emitResolveWithBase(generator.newTemporary(), propDst.get(), resolveResult, ident);
    818839    emitPreIncOrDec(generator, propDst.get(), m_operator);
    819     generator.emitPutById(base.get(), m_ident, propDst.get());
     840    generator.emitPutById(base.get(), ident, propDst.get());
    820841    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    821842}
    822843
    823 // ------------------------------ PrefixBracketNode ----------------------------------
    824 
    825 RegisterID* PrefixBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    826 {
    827     RefPtr<RegisterID> base = generator.emitNode(m_base);
    828     RefPtr<RegisterID> property = generator.emitNode(m_subscript);
     844RegisterID* PrefixNode::emitBracket(BytecodeGenerator& generator, RegisterID* dst)
     845{
     846    ASSERT(m_expr->isBracketAccessorNode());
     847    BracketAccessorNode* bracketAccessor = static_cast<BracketAccessorNode*>(m_expr);
     848    ExpressionNode* baseNode = bracketAccessor->base();
     849    ExpressionNode* subscript = bracketAccessor->subscript();
     850
     851    RefPtr<RegisterID> base = generator.emitNode(baseNode);
     852    RefPtr<RegisterID> property = generator.emitNode(subscript);
    829853    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    830854
    831     generator.emitExpressionInfo(divot() + m_subexpressionDivotOffset, m_subexpressionStartOffset, endOffset() - m_subexpressionDivotOffset);
     855    generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->startOffset(), bracketAccessor->endOffset());
    832856    RegisterID* value = generator.emitGetByVal(propDst.get(), base.get(), property.get());
    833857    if (m_operator == OpPlusPlus)
    … …  
    840864}
    841865
    842 // ------------------------------ PrefixDotNode ----------------------------------
    843 
    844 RegisterID* PrefixDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    845 {
    846     RefPtr<RegisterID> base = generator.emitNode(m_base);
     866RegisterID* PrefixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
     867{
     868    ASSERT(m_expr->isDotAccessorNode());
     869    DotAccessorNode* dotAccessor = static_cast<DotAccessorNode*>(m_expr);
     870    ExpressionNode* baseNode = dotAccessor->base();
     871    const Identifier& ident = dotAccessor->identifier();
     872
     873    RefPtr<RegisterID> base = generator.emitNode(baseNode);
    847874    RefPtr<RegisterID> propDst = generator.tempDestination(dst);
    848875
    849     generator.emitExpressionInfo(divot() + m_subexpressionDivotOffset, m_subexpressionStartOffset, endOffset() - m_subexpressionDivotOffset);
    850     RegisterID* value = generator.emitGetById(propDst.get(), base.get(), m_ident);
     876    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->startOffset(), dotAccessor->endOffset());
     877    RegisterID* value = generator.emitGetById(propDst.get(), base.get(), ident);
    851878    if (m_operator == OpPlusPlus)
    852879        generator.emitPreInc(value);
    … …  
    854881        generator.emitPreDec(value);
    855882    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    856     generator.emitPutById(base.get(), m_ident, value);
     883    generator.emitPutById(base.get(), ident, value);
    857884    return generator.moveToDestinationIfNeeded(dst, propDst.get());
    858885}
    859886
    860 // ------------------------------ PrefixErrorNode -----------------------------------
    861 
    862 RegisterID* PrefixErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
    863 {
     887RegisterID* PrefixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
     888{
     889    if (m_expr->isResolveNode())
     890        return emitResolve(generator, dst);
     891
     892    if (m_expr->isBracketAccessorNode())
     893        return emitBracket(generator, dst);
     894
     895    if (m_expr->isDotAccessorNode())
     896        return emitDot(generator, dst);
     897
    864898    return emitThrowReferenceError(generator, m_operator == OpPlusPlus
    865899        ? "Prefix ++ operator applied to value that is not a reference."
Note: See TracChangeset for help on using the changeset viewer.