Changeset 147658 in webkit


Ignore:
Timestamp:
Apr 4, 2013 11:31:37 AM (11 years ago)
Author:
ggaren@apple.com
Message:

Simplified bytecode generation by merging prefix and postfix nodes
​https://bugs.webkit.org/show_bug.cgi?id=113925

Reviewed by Filip Pizlo.

PostfixNode now inherits from PrefixNode, so when we detect that we're
in a context where postifx and prefix are equivalent, PostFixNode can
just call through to PrefixNode codegen, instead of duplicating the
logic.

  • bytecompiler/NodesCodegen.cpp:

(JSC::PostfixNode::emitResolve):
(JSC::PostfixNode::emitBracket):
(JSC::PostfixNode::emitDot):

  • parser/NodeConstructors.h:

(JSC::PostfixNode::PostfixNode):

  • parser/Nodes.h:

(JSC):
(PrefixNode):
(PostfixNode):

Location:
trunk/Source/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r147640 r147658  
     12013-04-04  Geoffrey Garen  <ggaren@apple.com>
     2
     3        Simplified bytecode generation by merging prefix and postfix nodes
     4        https://bugs.webkit.org/show_bug.cgi?id=113925
     5
     6        Reviewed by Filip Pizlo.
     7
     8        PostfixNode now inherits from PrefixNode, so when we detect that we're
     9        in a context where postifx and prefix are equivalent, PostFixNode can
     10        just call through to PrefixNode codegen, instead of duplicating the
     11        logic.
     12
     13        * bytecompiler/NodesCodegen.cpp:
     14        (JSC::PostfixNode::emitResolve):
     15        (JSC::PostfixNode::emitBracket):
     16        (JSC::PostfixNode::emitDot):
     17        * parser/NodeConstructors.h:
     18        (JSC::PostfixNode::PostfixNode):
     19        * parser/Nodes.h:
     20        (JSC):
     21        (PrefixNode):
     22        (PostfixNode):
     23
    1242013-04-04  Andras Becsi  <andras.becsi@digia.com>
    225

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

    r147234 r147658  
    625625RegisterID* PostfixNode::emitResolve(BytecodeGenerator& generator, RegisterID* dst)
    626626{
     627    if (dst == generator.ignoredResult())
     628        return PrefixNode::emitResolve(generator, dst);
     629
    627630    ASSERT(m_expr->isResolveNode());
    628631    ResolveNode* resolve = static_cast<ResolveNode*>(m_expr);
    … …  
    636639            return generator.emitToJSNumber(generator.finalDestination(dst), local);
    637640        }
    638         if (dst == generator.ignoredResult())
    639             return emitPreIncOrDec(generator, local, m_operator);
    640641        return emitPostIncOrDec(generator, generator.finalDestination(dst), local, m_operator);
    641642    }
    … …  
    643644    if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
    644645        RefPtr<RegisterID> value = generator.emitGetStaticVar(generator.newTemporary(), resolveResult, ident);
    645         RegisterID* oldValue;
    646         if (dst == generator.ignoredResult()) {
    647             oldValue = 0;
    648             emitPreIncOrDec(generator, value.get(), m_operator);
    649         } else
    650             oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
     646        RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
    651647        generator.emitPutStaticVar(resolveResult, ident, value.get());
    652         return oldValue;
     648        return oldValue.get();
    653649    }
    654650
    … …  
    657653    NonlocalResolveInfo resolveInfo;
    658654    RefPtr<RegisterID> base = generator.emitResolveWithBaseForPut(generator.newTemporary(), value.get(), resolveResult, ident, resolveInfo);
    659     RegisterID* oldValue;
    660     if (dst == generator.ignoredResult()) {
    661         oldValue = 0;
    662         emitPreIncOrDec(generator, value.get(), m_operator);
    663     } else
    664         oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
     655    RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
    665656    generator.emitPutToBase(base.get(), ident, value.get(), resolveInfo);
    666     return oldValue;
     657    return oldValue.get();
    667658}
    668659
    669660RegisterID* PostfixNode::emitBracket(BytecodeGenerator& generator, RegisterID* dst)
    670661{
     662    if (dst == generator.ignoredResult())
     663        return PrefixNode::emitBracket(generator, dst);
     664
    671665    ASSERT(m_expr->isBracketAccessorNode());
    672666    BracketAccessorNode* bracketAccessor = static_cast<BracketAccessorNode*>(m_expr);
    … …  
    679673    generator.emitExpressionInfo(bracketAccessor->divot(), bracketAccessor->startOffset(), bracketAccessor->endOffset());
    680674    RefPtr<RegisterID> value = generator.emitGetByVal(generator.newTemporary(), base.get(), property.get());
    681     if (dst == generator.ignoredResult()) {
    682         emitPreIncOrDec(generator, value.get(), m_operator);
    683         generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    684         generator.emitPutByVal(base.get(), property.get(), value.get());
    685         return 0;
    686     }
    687675    RegisterID* oldValue = emitPostIncOrDec(generator, generator.tempDestination(dst), value.get(), m_operator);
    688676    generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    … …  
    693681RegisterID* PostfixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
    694682{
     683    if (dst == generator.ignoredResult())
     684        return PrefixNode::emitDot(generator, dst);
     685
    695686    ASSERT(m_expr->isDotAccessorNode());
    696687    DotAccessorNode* dotAccessor = static_cast<DotAccessorNode*>(m_expr);
    … …  
    702693    generator.emitExpressionInfo(dotAccessor->divot(), dotAccessor->startOffset(), dotAccessor->endOffset());
    703694    RefPtr<RegisterID> value = generator.emitGetById(generator.newTemporary(), base.get(), ident);
    704     if (dst == generator.ignoredResult()) {
    705         emitPreIncOrDec(generator, value.get(), m_operator);
    706         generator.emitExpressionInfo(divot(), startOffset(), endOffset());
    707         generator.emitPutById(base.get(), ident, value.get());
    708         return 0;
    709     }
    710695    RegisterID* oldValue = emitPostIncOrDec(generator, generator.tempDestination(dst), value.get(), m_operator);
    711696    generator.emitExpressionInfo(divot(), startOffset(), endOffset());

  • trunk/Source/JavaScriptCore/parser/NodeConstructors.h

    r146318 r147658  
    289289
    290290    inline PostfixNode::PostfixNode(const JSTokenLocation& location, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
    291         : ExpressionNode(location)
    292         , ThrowableExpressionData(divot, startOffset, endOffset)
    293         , m_expr(expr)
    294         , m_operator(oper)
     291        : PrefixNode(location, expr, oper, divot, startOffset, endOffset)
    295292    {
    296293    }

  • trunk/Source/JavaScriptCore/parser/Nodes.h

    r147234 r147658  
    588588    };
    589589
    590     class PostfixNode : public ExpressionNode, public ThrowableExpressionData {
    591     public:
    592         PostfixNode(const JSTokenLocation&, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    593 
    594     private:
     590    class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
     591    public:
     592        DeleteResolveNode(const JSTokenLocation&, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
     593
     594    private:
     595        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     596
     597        const Identifier& m_ident;
     598    };
     599
     600    class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
     601    public:
     602        DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
     603
     604    private:
     605        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     606
     607        ExpressionNode* m_base;
     608        ExpressionNode* m_subscript;
     609    };
     610
     611    class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
     612    public:
     613        DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
     614
     615    private:
     616        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     617
     618        ExpressionNode* m_base;
     619        const Identifier& m_ident;
     620    };
     621
     622    class DeleteValueNode : public ExpressionNode {
     623    public:
     624        DeleteValueNode(const JSTokenLocation&, ExpressionNode*);
     625
     626    private:
     627        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     628
     629        ExpressionNode* m_expr;
     630    };
     631
     632    class VoidNode : public ExpressionNode {
     633    public:
     634        VoidNode(const JSTokenLocation&, ExpressionNode*);
     635
     636    private:
     637        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     638
     639        ExpressionNode* m_expr;
     640    };
     641
     642    class TypeOfResolveNode : public ExpressionNode {
     643    public:
     644        TypeOfResolveNode(const JSTokenLocation&, const Identifier&);
     645
     646        const Identifier& identifier() const { return m_ident; }
     647
     648    private:
     649        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     650
     651        const Identifier& m_ident;
     652    };
     653
     654    class TypeOfValueNode : public ExpressionNode {
     655    public:
     656        TypeOfValueNode(const JSTokenLocation&, ExpressionNode*);
     657
     658    private:
     659        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
     660
     661        ExpressionNode* m_expr;
     662    };
     663
     664    class PrefixNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
     665    public:
     666        PrefixNode(const JSTokenLocation&, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
     667
     668    protected:
    595669        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    596670        virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0);
    … …  
    602676    };
    603677
    604     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
    605     public:
    606         DeleteResolveNode(const JSTokenLocation&, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
    607 
    608     private:
    609         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    610 
    611         const Identifier& m_ident;
    612     };
    613 
    614     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
    615     public:
    616         DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
    617 
    618     private:
    619         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    620 
    621         ExpressionNode* m_base;
    622         ExpressionNode* m_subscript;
    623     };
    624 
    625     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
    626     public:
    627         DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
    628 
    629     private:
    630         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    631 
    632         ExpressionNode* m_base;
    633         const Identifier& m_ident;
    634     };
    635 
    636     class DeleteValueNode : public ExpressionNode {
    637     public:
    638         DeleteValueNode(const JSTokenLocation&, ExpressionNode*);
    639 
    640     private:
    641         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    642 
    643         ExpressionNode* m_expr;
    644     };
    645 
    646     class VoidNode : public ExpressionNode {
    647     public:
    648         VoidNode(const JSTokenLocation&, ExpressionNode*);
    649 
    650     private:
    651         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    652 
    653         ExpressionNode* m_expr;
    654     };
    655 
    656     class TypeOfResolveNode : public ExpressionNode {
    657     public:
    658         TypeOfResolveNode(const JSTokenLocation&, const Identifier&);
    659 
    660         const Identifier& identifier() const { return m_ident; }
    661 
    662     private:
    663         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    664 
    665         const Identifier& m_ident;
    666     };
    667 
    668     class TypeOfValueNode : public ExpressionNode {
    669     public:
    670         TypeOfValueNode(const JSTokenLocation&, ExpressionNode*);
    671 
    672     private:
    673         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
    674 
    675         ExpressionNode* m_expr;
    676     };
    677 
    678     class PrefixNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
    679     public:
    680         PrefixNode(const JSTokenLocation&, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
     678    class PostfixNode : public PrefixNode {
     679    public:
     680        PostfixNode(const JSTokenLocation&, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    681681
    682682    private:
    … …  
    685685        virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0);
    686686        virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0);
    687 
    688         ExpressionNode* m_expr;
    689         Operator m_operator;
    690687    };
    691688
Note: See TracChangeset for help on using the changeset viewer.