Changeset 34562 in webkit


Ignore:
Timestamp:
Jun 15, 2008 2:30:56 AM (16 years ago)
Author:
cwzwarich@webkit.org
Message:

2008-06-15 Cameron Zwarich <​cwzwarich@uwaterloo.ca>

Reviewed by Maciej.

Bug 19484: More instructions needs to use temporary registers
<​https://bugs.webkit.org/show_bug.cgi?id=19484>

Fix codegen for all binary operations so that temporaries are used if
necessary. This was done by making BinaryOpNode and ReverseBinaryOpNode
subclasses of ExpressionNode, and eliminating the custom emitCode()
methods for the individual node classes.

This only adds 3 new instructions to SunSpider code, and there is no
difference in SunSpider execution time.

JavaScriptCore:

  • VM/CodeGenerator.cpp: (KJS::CodeGenerator::emitBitNot): (KJS::CodeGenerator::emitBinaryOp):
  • VM/CodeGenerator.h:
  • kjs/grammar.y:
  • kjs/nodes.cpp: (KJS::PreIncResolveNode::emitCode): (KJS::PreDecResolveNode::emitCode): (KJS::BinaryOpNode::emitCode): (KJS::ReverseBinaryOpNode::emitCode): (KJS::emitReadModifyAssignment): (KJS::CaseBlockNode::emitCodeForBlock):
  • kjs/nodes.h: (KJS::BinaryOpNode::BinaryOpNode): (KJS::ReverseBinaryOpNode::ReverseBinaryOpNode): (KJS::MultNode::): (KJS::DivNode::): (KJS::DivNode::precedence): (KJS::ModNode::): (KJS::ModNode::precedence): (KJS::AddNode::): (KJS::AddNode::precedence): (KJS::SubNode::): (KJS::SubNode::precedence): (KJS::LeftShiftNode::): (KJS::LeftShiftNode::precedence): (KJS::RightShiftNode::): (KJS::RightShiftNode::precedence): (KJS::UnsignedRightShiftNode::): (KJS::UnsignedRightShiftNode::precedence): (KJS::LessNode::): (KJS::LessNode::precedence): (KJS::GreaterNode::): (KJS::GreaterNode::precedence): (KJS::LessEqNode::): (KJS::LessEqNode::precedence): (KJS::GreaterEqNode::): (KJS::GreaterEqNode::precedence): (KJS::InstanceOfNode::): (KJS::InstanceOfNode::precedence): (KJS::InNode::): (KJS::InNode::precedence): (KJS::EqualNode::): (KJS::EqualNode::precedence): (KJS::NotEqualNode::): (KJS::NotEqualNode::precedence): (KJS::StrictEqualNode::): (KJS::StrictEqualNode::precedence): (KJS::NotStrictEqualNode::): (KJS::NotStrictEqualNode::precedence): (KJS::BitAndNode::): (KJS::BitAndNode::precedence): (KJS::BitOrNode::): (KJS::BitOrNode::precedence): (KJS::BitXOrNode::): (KJS::BitXOrNode::precedence):
  • kjs/nodes2string.cpp: (KJS::LessNode::streamTo): (KJS::GreaterNode::streamTo): (KJS::LessEqNode::streamTo): (KJS::GreaterEqNode::streamTo): (KJS::InstanceOfNode::streamTo): (KJS::InNode::streamTo): (KJS::EqualNode::streamTo): (KJS::NotEqualNode::streamTo): (KJS::StrictEqualNode::streamTo): (KJS::NotStrictEqualNode::streamTo): (KJS::BitAndNode::streamTo): (KJS::BitXOrNode::streamTo): (KJS::BitOrNode::streamTo):

LayoutTests:

  • fast/js/codegen-temporaries-expected.txt:
  • fast/js/resources/codegen-temporaries.js:
Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r34560 r34562  
     12008-06-15  Cameron Zwarich  <cwzwarich@uwaterloo.ca>
     2
     3        Reviewed by Maciej.
     4
     5        Bug 19484: More instructions needs to use temporary registers
     6        <https://bugs.webkit.org/show_bug.cgi?id=19484>
     7
     8        Fix codegen for all binary operations so that temporaries are used if
     9        necessary. This was done by making BinaryOpNode and ReverseBinaryOpNode
     10        subclasses of ExpressionNode, and eliminating the custom emitCode()
     11        methods for the individual node classes.
     12
     13        This only adds 3 new instructions to SunSpider code, and there is no
     14        difference in SunSpider execution time.
     15
     16        * VM/CodeGenerator.cpp:
     17        (KJS::CodeGenerator::emitBitNot):
     18        (KJS::CodeGenerator::emitBinaryOp):
     19        * VM/CodeGenerator.h:
     20        * kjs/grammar.y:
     21        * kjs/nodes.cpp:
     22        (KJS::PreIncResolveNode::emitCode):
     23        (KJS::PreDecResolveNode::emitCode):
     24        (KJS::BinaryOpNode::emitCode):
     25        (KJS::ReverseBinaryOpNode::emitCode):
     26        (KJS::emitReadModifyAssignment):
     27        (KJS::CaseBlockNode::emitCodeForBlock):
     28        * kjs/nodes.h:
     29        (KJS::BinaryOpNode::BinaryOpNode):
     30        (KJS::ReverseBinaryOpNode::ReverseBinaryOpNode):
     31        (KJS::MultNode::):
     32        (KJS::DivNode::):
     33        (KJS::DivNode::precedence):
     34        (KJS::ModNode::):
     35        (KJS::ModNode::precedence):
     36        (KJS::AddNode::):
     37        (KJS::AddNode::precedence):
     38        (KJS::SubNode::):
     39        (KJS::SubNode::precedence):
     40        (KJS::LeftShiftNode::):
     41        (KJS::LeftShiftNode::precedence):
     42        (KJS::RightShiftNode::):
     43        (KJS::RightShiftNode::precedence):
     44        (KJS::UnsignedRightShiftNode::):
     45        (KJS::UnsignedRightShiftNode::precedence):
     46        (KJS::LessNode::):
     47        (KJS::LessNode::precedence):
     48        (KJS::GreaterNode::):
     49        (KJS::GreaterNode::precedence):
     50        (KJS::LessEqNode::):
     51        (KJS::LessEqNode::precedence):
     52        (KJS::GreaterEqNode::):
     53        (KJS::GreaterEqNode::precedence):
     54        (KJS::InstanceOfNode::):
     55        (KJS::InstanceOfNode::precedence):
     56        (KJS::InNode::):
     57        (KJS::InNode::precedence):
     58        (KJS::EqualNode::):
     59        (KJS::EqualNode::precedence):
     60        (KJS::NotEqualNode::):
     61        (KJS::NotEqualNode::precedence):
     62        (KJS::StrictEqualNode::):
     63        (KJS::StrictEqualNode::precedence):
     64        (KJS::NotStrictEqualNode::):
     65        (KJS::NotStrictEqualNode::precedence):
     66        (KJS::BitAndNode::):
     67        (KJS::BitAndNode::precedence):
     68        (KJS::BitOrNode::):
     69        (KJS::BitOrNode::precedence):
     70        (KJS::BitXOrNode::):
     71        (KJS::BitXOrNode::precedence):
     72        * kjs/nodes2string.cpp:
     73        (KJS::LessNode::streamTo):
     74        (KJS::GreaterNode::streamTo):
     75        (KJS::LessEqNode::streamTo):
     76        (KJS::GreaterEqNode::streamTo):
     77        (KJS::InstanceOfNode::streamTo):
     78        (KJS::InNode::streamTo):
     79        (KJS::EqualNode::streamTo):
     80        (KJS::NotEqualNode::streamTo):
     81        (KJS::StrictEqualNode::streamTo):
     82        (KJS::NotStrictEqualNode::streamTo):
     83        (KJS::BitAndNode::streamTo):
     84        (KJS::BitXOrNode::streamTo):
     85        (KJS::BitOrNode::streamTo):
     86
    1872008-06-14  Darin Adler  <darin@apple.com>
    288

  • trunk/JavaScriptCore/VM/CodeGenerator.cpp

    r34555 r34562  
    518518}
    519519
    520 RegisterID* CodeGenerator::emitEqual(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    521 {
    522     emitOpcode(op_eq);
    523     instructions().append(dst->index());
    524     instructions().append(src1->index());
    525     instructions().append(src2->index());
    526     return dst;
    527 }
    528 
    529 RegisterID* CodeGenerator::emitNotEqual(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    530 {
    531     emitOpcode(op_neq);
    532     instructions().append(dst->index());
    533     instructions().append(src1->index());
    534     instructions().append(src2->index());
    535     return dst;
    536 }
    537 
    538 RegisterID* CodeGenerator::emitStrictEqual(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    539 {
    540     emitOpcode(op_stricteq);
    541     instructions().append(dst->index());
    542     instructions().append(src1->index());
    543     instructions().append(src2->index());
    544     return dst;
    545 }
    546 
    547 RegisterID* CodeGenerator::emitNotStrictEqual(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    548 {
    549     emitOpcode(op_nstricteq);
    550     instructions().append(dst->index());
    551     instructions().append(src1->index());
    552     instructions().append(src2->index());
    553     return dst;
    554 }
    555 
    556 RegisterID* CodeGenerator::emitLess(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    557 {
    558     emitOpcode(op_less);
    559     instructions().append(dst->index());
    560     instructions().append(src1->index());
    561     instructions().append(src2->index());
    562     return dst;
    563 }
    564 
    565 RegisterID* CodeGenerator::emitLessEq(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    566 {
    567     emitOpcode(op_lesseq);
    568     instructions().append(dst->index());
    569     instructions().append(src1->index());
    570     instructions().append(src2->index());
    571     return dst;
    572 }
    573 
    574520RegisterID* CodeGenerator::emitPreInc(RegisterID* srcDst)
    575521{
    … …  
    618564}
    619565
    620 RegisterID* CodeGenerator::emitAdd(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    621 {
    622     emitOpcode(op_add);
     566RegisterID* CodeGenerator::emitBitNot(RegisterID* dst, RegisterID* src)
     567{
     568    emitOpcode(op_bitnot);
     569    instructions().append(dst->index());
     570    instructions().append(src->index());
     571    return dst;
     572}
     573
     574RegisterID* CodeGenerator::emitBinaryOp(OpcodeID opcode, RegisterID* dst, RegisterID* src1, RegisterID* src2)
     575{
     576    emitOpcode(opcode);
    623577    instructions().append(dst->index());
    624578    instructions().append(src1->index());
    625579    instructions().append(src2->index());
    626     return dst;
    627 }
    628 
    629 RegisterID* CodeGenerator::emitMul(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    630 {
    631     emitOpcode(op_mul);
    632     instructions().append(dst->index());
    633     instructions().append(src1->index());
    634     instructions().append(src2->index());
    635     return dst;
    636 }
    637 
    638 RegisterID* CodeGenerator::emitDiv(RegisterID* dst, RegisterID* dividend, RegisterID* divisor)
    639 {
    640     emitOpcode(op_div);
    641     instructions().append(dst->index());
    642     instructions().append(dividend->index());
    643     instructions().append(divisor->index());
    644     return dst;
    645 }
    646 
    647 RegisterID* CodeGenerator::emitMod(RegisterID* dst, RegisterID* dividend, RegisterID* divisor)
    648 {
    649     emitOpcode(op_mod);
    650     instructions().append(dst->index());
    651     instructions().append(dividend->index());
    652     instructions().append(divisor->index());
    653     return dst;
    654 }
    655 
    656 RegisterID* CodeGenerator::emitSub(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    657 {
    658     emitOpcode(op_sub);
    659     instructions().append(dst->index());
    660     instructions().append(src1->index());
    661     instructions().append(src2->index());
    662     return dst;
    663 }
    664 
    665 RegisterID* CodeGenerator::emitLeftShift(RegisterID* dst, RegisterID* val, RegisterID* shift)
    666 {
    667     emitOpcode(op_lshift);
    668     instructions().append(dst->index());
    669     instructions().append(val->index());
    670     instructions().append(shift->index());
    671     return dst;
    672 }
    673 
    674 RegisterID* CodeGenerator::emitRightShift(RegisterID* dst, RegisterID* val, RegisterID* shift)
    675 {
    676     emitOpcode(op_rshift);
    677     instructions().append(dst->index());
    678     instructions().append(val->index());
    679     instructions().append(shift->index());
    680     return dst;
    681 }
    682 
    683 RegisterID* CodeGenerator::emitUnsignedRightShift(RegisterID* dst, RegisterID* val, RegisterID* shift)
    684 {
    685     emitOpcode(op_urshift);
    686     instructions().append(dst->index());
    687     instructions().append(val->index());
    688     instructions().append(shift->index());
    689     return dst;
    690 }
    691 
    692 RegisterID* CodeGenerator::emitBitAnd(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    693 {
    694     emitOpcode(op_bitand);
    695     instructions().append(dst->index());
    696     instructions().append(src1->index());
    697     instructions().append(src2->index());
    698     return dst;
    699 }
    700 
    701 RegisterID* CodeGenerator::emitBitXOr(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    702 {
    703     emitOpcode(op_bitxor);
    704     instructions().append(dst->index());
    705     instructions().append(src1->index());
    706     instructions().append(src2->index());
    707     return dst;
    708 }
    709 
    710 RegisterID* CodeGenerator::emitBitOr(RegisterID* dst, RegisterID* src1, RegisterID* src2)
    711 {
    712     emitOpcode(op_bitor);
    713     instructions().append(dst->index());
    714     instructions().append(src1->index());
    715     instructions().append(src2->index());
    716     return dst;
    717 }
    718 
    719 RegisterID* CodeGenerator::emitBitNot(RegisterID* dst, RegisterID* src)
    720 {
    721     emitOpcode(op_bitnot);
    722     instructions().append(dst->index());
    723     instructions().append(src->index());
    724580    return dst;
    725581}

  • trunk/JavaScriptCore/VM/CodeGenerator.h

    r34555 r34562  
    203203
    204204        RegisterID* emitNot(RegisterID* dst, RegisterID* src);
    205         RegisterID* emitEqual(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    206         RegisterID* emitNotEqual(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    207         RegisterID* emitStrictEqual(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    208         RegisterID* emitNotStrictEqual(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    209         RegisterID* emitLess(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    210         RegisterID* emitLessEq(RegisterID* dst, RegisterID* src1, RegisterID* src2);
     205        RegisterID* emitBitNot(RegisterID* dst, RegisterID* src);
    211206
    212207        RegisterID* emitToJSNumber(RegisterID* dst, RegisterID* src);
    … …  
    216211        RegisterID* emitPostInc(RegisterID* dst, RegisterID* srcDst);
    217212        RegisterID* emitPostDec(RegisterID* dst, RegisterID* srcDst);
    218         RegisterID* emitAdd(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    219         RegisterID* emitMul(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    220         RegisterID* emitDiv(RegisterID* dst, RegisterID* dividend, RegisterID* divisor);
    221         RegisterID* emitMod(RegisterID* dst, RegisterID* dividend, RegisterID* divisor);
    222         RegisterID* emitSub(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    223 
    224         RegisterID* emitLeftShift(RegisterID* dst, RegisterID* val, RegisterID* shift);
    225         RegisterID* emitRightShift(RegisterID* dst, RegisterID* val, RegisterID* shift);
    226         RegisterID* emitUnsignedRightShift(RegisterID* dst, RegisterID* val, RegisterID* shift);
    227 
    228         RegisterID* emitBitAnd(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    229         RegisterID* emitBitXOr(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    230         RegisterID* emitBitOr(RegisterID* dst, RegisterID* src1, RegisterID* src2);
    231         RegisterID* emitBitNot(RegisterID* dst, RegisterID* src);
     213
     214        RegisterID* emitBinaryOp(OpcodeID opcode, RegisterID* dst, RegisterID* src1, RegisterID* src2);
    232215
    233216        RegisterID* emitInstanceOf(RegisterID* dst, RegisterID* value, RegisterID* base);

  • trunk/JavaScriptCore/kjs/grammar.y

    r34539 r34562  
    459459MultiplicativeExpr:
    460460    UnaryExpr
    461   | MultiplicativeExpr '*' UnaryExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new MultNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    462   | MultiplicativeExpr '/' UnaryExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new DivNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    463   | MultiplicativeExpr '%' UnaryExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new ModNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     461  | MultiplicativeExpr '*' UnaryExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new MultNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     462  | MultiplicativeExpr '/' UnaryExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new DivNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     463  | MultiplicativeExpr '%' UnaryExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new ModNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    464464;
    465465
    … …  
    467467    UnaryExprNoBF
    468468  | MultiplicativeExprNoBF '*' UnaryExpr
    469                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new MultNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     469                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new MultNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    470470  | MultiplicativeExprNoBF '/' UnaryExpr
    471                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new DivNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     471                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new DivNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    472472  | MultiplicativeExprNoBF '%' UnaryExpr
    473                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new ModNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     473                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new ModNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    474474;
    475475
    … …  
    490490ShiftExpr:
    491491    AdditiveExpr
    492   | ShiftExpr LSHIFT AdditiveExpr       { $$ = createNodeFeatureInfo<ExpressionNode*>(new LeftShiftNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    493   | ShiftExpr RSHIFT AdditiveExpr       { $$ = createNodeFeatureInfo<ExpressionNode*>(new RightShiftNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    494   | ShiftExpr URSHIFT AdditiveExpr      { $$ = createNodeFeatureInfo<ExpressionNode*>(new UnsignedRightShiftNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     492  | ShiftExpr LSHIFT AdditiveExpr       { $$ = createNodeFeatureInfo<ExpressionNode*>(new LeftShiftNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     493  | ShiftExpr RSHIFT AdditiveExpr       { $$ = createNodeFeatureInfo<ExpressionNode*>(new RightShiftNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     494  | ShiftExpr URSHIFT AdditiveExpr      { $$ = createNodeFeatureInfo<ExpressionNode*>(new UnsignedRightShiftNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    495495;
    496496
    497497ShiftExprNoBF:
    498498    AdditiveExprNoBF
    499   | ShiftExprNoBF LSHIFT AdditiveExpr   { $$ = createNodeFeatureInfo<ExpressionNode*>(new LeftShiftNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    500   | ShiftExprNoBF RSHIFT AdditiveExpr   { $$ = createNodeFeatureInfo<ExpressionNode*>(new RightShiftNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    501   | ShiftExprNoBF URSHIFT AdditiveExpr  { $$ = createNodeFeatureInfo<ExpressionNode*>(new UnsignedRightShiftNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     499  | ShiftExprNoBF LSHIFT AdditiveExpr   { $$ = createNodeFeatureInfo<ExpressionNode*>(new LeftShiftNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     500  | ShiftExprNoBF RSHIFT AdditiveExpr   { $$ = createNodeFeatureInfo<ExpressionNode*>(new RightShiftNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     501  | ShiftExprNoBF URSHIFT AdditiveExpr  { $$ = createNodeFeatureInfo<ExpressionNode*>(new UnsignedRightShiftNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    502502;
    503503
    504504RelationalExpr:
    505505    ShiftExpr
    506   | RelationalExpr '<' ShiftExpr        { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    507   | RelationalExpr '>' ShiftExpr        { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    508   | RelationalExpr LE ShiftExpr         { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessEqNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    509   | RelationalExpr GE ShiftExpr         { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    510   | RelationalExpr INSTANCEOF ShiftExpr { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    511   | RelationalExpr INTOKEN ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new InNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     506  | RelationalExpr '<' ShiftExpr        { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     507  | RelationalExpr '>' ShiftExpr        { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     508  | RelationalExpr LE ShiftExpr         { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessEqNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     509  | RelationalExpr GE ShiftExpr         { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     510  | RelationalExpr INSTANCEOF ShiftExpr { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     511  | RelationalExpr INTOKEN ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new InNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    512512;
    513513
    514514RelationalExprNoIn:
    515515    ShiftExpr
    516   | RelationalExprNoIn '<' ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    517   | RelationalExprNoIn '>' ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    518   | RelationalExprNoIn LE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessEqNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    519   | RelationalExprNoIn GE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     516  | RelationalExprNoIn '<' ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     517  | RelationalExprNoIn '>' ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     518  | RelationalExprNoIn LE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessEqNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     519  | RelationalExprNoIn GE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    520520  | RelationalExprNoIn INSTANCEOF ShiftExpr
    521                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     521                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    522522;
    523523
    524524RelationalExprNoBF:
    525525    ShiftExprNoBF
    526   | RelationalExprNoBF '<' ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    527   | RelationalExprNoBF '>' ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    528   | RelationalExprNoBF LE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessEqNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    529   | RelationalExprNoBF GE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     526  | RelationalExprNoBF '<' ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     527  | RelationalExprNoBF '>' ShiftExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     528  | RelationalExprNoBF LE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new LessEqNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     529  | RelationalExprNoBF GE ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new GreaterEqNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    530530  | RelationalExprNoBF INSTANCEOF ShiftExpr
    531                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    532   | RelationalExprNoBF INTOKEN ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new InNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     531                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new InstanceOfNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     532  | RelationalExprNoBF INTOKEN ShiftExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new InNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    533533;
    534534
    535535EqualityExpr:
    536536    RelationalExpr
    537   | EqualityExpr EQEQ RelationalExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new EqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    538   | EqualityExpr NE RelationalExpr      { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    539   | EqualityExpr STREQ RelationalExpr   { $$ = createNodeFeatureInfo<ExpressionNode*>(new StrictEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    540   | EqualityExpr STRNEQ RelationalExpr  { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotStrictEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     537  | EqualityExpr EQEQ RelationalExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new EqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     538  | EqualityExpr NE RelationalExpr      { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     539  | EqualityExpr STREQ RelationalExpr   { $$ = createNodeFeatureInfo<ExpressionNode*>(new StrictEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     540  | EqualityExpr STRNEQ RelationalExpr  { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotStrictEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    541541;
    542542
    … …  
    544544    RelationalExprNoIn
    545545  | EqualityExprNoIn EQEQ RelationalExprNoIn
    546                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new EqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     546                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new EqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    547547  | EqualityExprNoIn NE RelationalExprNoIn
    548                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     548                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    549549  | EqualityExprNoIn STREQ RelationalExprNoIn
    550                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new StrictEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     550                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new StrictEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    551551  | EqualityExprNoIn STRNEQ RelationalExprNoIn
    552                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotStrictEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     552                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotStrictEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    553553;
    554554
    … …  
    556556    RelationalExprNoBF
    557557  | EqualityExprNoBF EQEQ RelationalExpr
    558                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new EqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
    559   | EqualityExprNoBF NE RelationalExpr  { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     558                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new EqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
     559  | EqualityExprNoBF NE RelationalExpr  { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    560560  | EqualityExprNoBF STREQ RelationalExpr
    561                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new StrictEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     561                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new StrictEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    562562  | EqualityExprNoBF STRNEQ RelationalExpr
    563                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotStrictEqualNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     563                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new NotStrictEqualNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    564564;
    565565
    566566BitwiseANDExpr:
    567567    EqualityExpr
    568   | BitwiseANDExpr '&' EqualityExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitAndNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     568  | BitwiseANDExpr '&' EqualityExpr     { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitAndNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    569569;
    570570
    … …  
    572572    EqualityExprNoIn
    573573  | BitwiseANDExprNoIn '&' EqualityExprNoIn
    574                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitAndNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     574                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitAndNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    575575;
    576576
    577577BitwiseANDExprNoBF:
    578578    EqualityExprNoBF
    579   | BitwiseANDExprNoBF '&' EqualityExpr { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitAndNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     579  | BitwiseANDExprNoBF '&' EqualityExpr { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitAndNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    580580;
    581581
    582582BitwiseXORExpr:
    583583    BitwiseANDExpr
    584   | BitwiseXORExpr '^' BitwiseANDExpr   { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitXOrNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     584  | BitwiseXORExpr '^' BitwiseANDExpr   { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitXOrNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    585585;
    586586
    … …  
    588588    BitwiseANDExprNoIn
    589589  | BitwiseXORExprNoIn '^' BitwiseANDExprNoIn
    590                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitXOrNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     590                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitXOrNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    591591;
    592592
    … …  
    594594    BitwiseANDExprNoBF
    595595  | BitwiseXORExprNoBF '^' BitwiseANDExpr
    596                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitXOrNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     596                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitXOrNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    597597;
    598598
    599599BitwiseORExpr:
    600600    BitwiseXORExpr
    601   | BitwiseORExpr '|' BitwiseXORExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitOrNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     601  | BitwiseORExpr '|' BitwiseXORExpr    { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitOrNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    602602;
    603603
    … …  
    605605    BitwiseXORExprNoIn
    606606  | BitwiseORExprNoIn '|' BitwiseXORExprNoIn
    607                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitOrNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     607                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitOrNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    608608;
    609609
    … …  
    611611    BitwiseXORExprNoBF
    612612  | BitwiseORExprNoBF '|' BitwiseXORExpr
    613                                         { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitOrNode($1.m_node, $3.m_node), $1.m_featureInfo | $3.m_featureInfo); }
     613                                        { $$ = createNodeFeatureInfo<ExpressionNode*>(new BitOrNode($1.m_node, $3.m_node, $3.m_featureInfo & AssignFeature), $1.m_featureInfo | $3.m_featureInfo); }
    614614;
    615615

  • trunk/JavaScriptCore/kjs/nodes.cpp

    r34556 r34562  
    665665        if (generator.isLocalConstant(m_ident)) {
    666666            RefPtr<RegisterID> r0 = generator.emitLoad(generator.finalDestination(dst), 1.0);
    667             return generator.emitAdd(r0.get(), local, r0.get());
     667            return generator.emitBinaryOp(op_add, r0.get(), local, r0.get());
    668668        }
    669669       
    … …  
    693693        if (generator.isLocalConstant(m_ident)) {
    694694            RefPtr<RegisterID> r0 = generator.emitLoad(generator.finalDestination(dst), -1.0);
    695             return generator.emitAdd(r0.get(), local, r0.get());
     695            return generator.emitBinaryOp(op_add, r0.get(), local, r0.get());
    696696        }
    697697       
    … …  
    802802}
    803803
    804 // ------------------------------ Multiplicative Nodes -----------------------------------
    805 
    806 RegisterID* MultNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    807 {
    808     RefPtr<RegisterID> src1 = generator.emitNode(m_term1.get());
    809     RegisterID* src2 = generator.emitNode(m_term2.get());
    810     return generator.emitMul(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    811 }
    812 
    813 RegisterID* DivNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    814 {
    815     RefPtr<RegisterID> dividend = generator.emitNode(m_term1.get());
    816     RegisterID* divisor = generator.emitNode(m_term2.get());
    817     return generator.emitDiv(generator.finalDestination(dst, dividend.get()), dividend.get(), divisor);
    818 }
    819 
    820 RegisterID* ModNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    821 {
    822     RefPtr<RegisterID> dividend = generator.emitNode(m_term1.get());
    823     RegisterID* divisor = generator.emitNode(m_term2.get());
    824     return generator.emitMod(generator.finalDestination(dst, dividend.get()), dividend.get(), divisor);
    825 }
    826 
    827 // ------------------------------ Additive Nodes --------------------------------------
    828 
    829 RegisterID* AddNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     804// ------------------------------ Binary Operation Nodes -----------------------------------
     805
     806RegisterID* BinaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    830807{
    831808    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_term1.get(), m_rightHasAssignments, m_term2->isPure(generator));
    832809    RegisterID* src2 = generator.emitNode(m_term2.get());
    833     return generator.emitAdd(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    834 }
    835 
    836 RegisterID* SubNode::emitCode(CodeGenerator& generator, RegisterID* dst)
     810    return generator.emitBinaryOp(opcode(), generator.finalDestination(dst, src1.get()), src1.get(), src2);
     811}
     812
     813RegisterID* ReverseBinaryOpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    837814{
    838815    RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_term1.get(), m_rightHasAssignments, m_term2->isPure(generator));
    839816    RegisterID* src2 = generator.emitNode(m_term2.get());
    840     return generator.emitSub(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    841 }
    842 
    843 // ------------------------------ Shift Nodes ------------------------------------
    844 
    845 RegisterID* LeftShiftNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    846 {
    847     RefPtr<RegisterID> val = generator.emitNode(m_term1.get());
    848     RegisterID* shift = generator.emitNode(m_term2.get());
    849     return generator.emitLeftShift(generator.finalDestination(dst, val.get()), val.get(), shift);
    850 }
    851 
    852 RegisterID* RightShiftNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    853 {
    854     RefPtr<RegisterID> val = generator.emitNode(m_term1.get());
    855     RegisterID* shift = generator.emitNode(m_term2.get());
    856     return generator.emitRightShift(generator.finalDestination(dst, val.get()), val.get(), shift);
    857 }
    858 
    859 RegisterID* UnsignedRightShiftNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    860 {
    861     RefPtr<RegisterID> val = generator.emitNode(m_term1.get());
    862     RegisterID* shift = generator.emitNode(m_term2.get());
    863     return generator.emitUnsignedRightShift(generator.finalDestination(dst, val.get()), val.get(), shift);
    864 }
    865 
    866 // ------------------------------ Relational Nodes -------------------------------
    867 
    868 RegisterID* LessNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    869 {
    870     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    871     RegisterID* src2 = generator.emitNode(m_expr2.get());
    872     return generator.emitLess(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    873 }
    874 
    875 RegisterID* GreaterNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    876 {
    877     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    878     RegisterID* src2 = generator.emitNode(m_expr2.get());
    879     return generator.emitLess(generator.finalDestination(dst, src1.get()), src2, src1.get());
    880 }
    881 
    882 RegisterID* LessEqNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    883 {
    884     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    885     RegisterID* src2 = generator.emitNode(m_expr2.get());
    886     return generator.emitLessEq(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    887 }
    888 
    889 RegisterID* GreaterEqNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    890 {
    891     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    892     RegisterID* src2 = generator.emitNode(m_expr2.get());
    893     return generator.emitLessEq(generator.finalDestination(dst, src1.get()), src2, src1.get());
    894 }
    895 
    896 RegisterID* InstanceOfNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    897 {
    898     RefPtr<RegisterID> value = generator.emitNode(m_expr1.get());
    899     RegisterID* base = generator.emitNode(m_expr2.get());
    900     return generator.emitInstanceOf(generator.finalDestination(dst, value.get()), value.get(), base);
    901 }
    902 
    903 RegisterID* InNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    904 {
    905     RefPtr<RegisterID> property = generator.emitNode(m_expr1.get());
    906     RegisterID* base = generator.emitNode(m_expr2.get());
    907     return generator.emitIn(generator.finalDestination(dst, property.get()), property.get(), base);
    908 }
    909 
    910 // ------------------------------ Equality Nodes ------------------------------------
    911 
    912 RegisterID* EqualNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    913 {
    914     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    915     RegisterID* src2 = generator.emitNode(m_expr2.get());
    916     return generator.emitEqual(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    917 }
    918 
    919 RegisterID* NotEqualNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    920 {
    921     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    922     RegisterID* src2 = generator.emitNode(m_expr2.get());
    923     return generator.emitNotEqual(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    924 }
    925 
    926 RegisterID* StrictEqualNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    927 {
    928     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    929     RegisterID* src2 = generator.emitNode(m_expr2.get());
    930     return generator.emitStrictEqual(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    931 }
    932 
    933 RegisterID* NotStrictEqualNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    934 {
    935     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    936     RegisterID* src2 = generator.emitNode(m_expr2.get());
    937     return generator.emitNotStrictEqual(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    938 }
    939 
    940 // ------------------------------ Bit Operation Nodes ----------------------------------
    941 
    942 RegisterID* BitAndNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    943 {
    944     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    945     RegisterID* src2 = generator.emitNode(m_expr2.get());
    946     return generator.emitBitAnd(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    947 }
    948 
    949 RegisterID* BitXOrNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    950 {
    951     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    952     RegisterID* src2 = generator.emitNode(m_expr2.get());
    953     return generator.emitBitXOr(generator.finalDestination(dst, src1.get()), src1.get(), src2);
    954 }
    955 
    956 RegisterID* BitOrNode::emitCode(CodeGenerator& generator, RegisterID* dst)
    957 {
    958     RefPtr<RegisterID> src1 = generator.emitNode(m_expr1.get());
    959     RegisterID* src2 = generator.emitNode(m_expr2.get());
    960     return generator.emitBitOr(generator.finalDestination(dst, src1.get()), src1.get(), src2);
     817    return generator.emitBinaryOp(opcode(), generator.finalDestination(dst, src1.get()), src2, src1.get());
    961818}
    962819
    … …  
    1018875    switch (oper) {
    1019876        case OpMultEq:
    1020             return generator.emitMul(dst, src1, src2);
     877            return generator.emitBinaryOp(op_mul, dst, src1, src2);
    1021878        case OpDivEq:
    1022             return generator.emitDiv(dst, src1, src2);
     879            return generator.emitBinaryOp(op_div, dst, src1, src2);
    1023880        case OpPlusEq:
    1024             return generator.emitAdd(dst, src1, src2);
     881            return generator.emitBinaryOp(op_add, dst, src1, src2);
    1025882        case OpMinusEq:
    1026             return generator.emitSub(dst, src1, src2);
     883            return generator.emitBinaryOp(op_sub, dst, src1, src2);
    1027884        case OpLShift:
    1028             return generator.emitLeftShift(dst, src1, src2);
     885            return generator.emitBinaryOp(op_lshift, dst, src1, src2);
    1029886        case OpRShift:
    1030             return generator.emitRightShift(dst, src1, src2);
     887            return generator.emitBinaryOp(op_rshift, dst, src1, src2);
    1031888        case OpURShift:
    1032             return generator.emitUnsignedRightShift(dst, src1, src2);
     889            return generator.emitBinaryOp(op_urshift, dst, src1, src2);
    1033890        case OpAndEq:
    1034             return generator.emitBitAnd(dst, src1, src2);
     891            return generator.emitBinaryOp(op_bitand, dst, src1, src2);
    1035892        case OpXOrEq:
    1036             return generator.emitBitXOr(dst, src1, src2);
     893            return generator.emitBinaryOp(op_bitxor, dst, src1, src2);
    1037894        case OpOrEq:
    1038             return generator.emitBitOr(dst, src1, src2);
     895            return generator.emitBinaryOp(op_bitor, dst, src1, src2);
    1039896        case OpModEq:
    1040             return generator.emitMod(dst, src1, src2);
     897            return generator.emitBinaryOp(op_mod, dst, src1, src2);
    1041898        default:
    1042899            ASSERT_NOT_REACHED();
    … …  
    15731430    for (ClauseListNode* list = m_list1.get(); list; list = list->getNext()) {
    15741431        RegisterID* clauseVal = generator.emitNode(list->getClause()->expr());
    1575         generator.emitStrictEqual(clauseVal, clauseVal, switchExpression);
     1432        generator.emitBinaryOp(op_stricteq, clauseVal, clauseVal, switchExpression);
    15761433        labelVector.append(generator.newLabel());
    15771434        generator.emitJumpIfTrueMayCombine(clauseVal, labelVector[labelVector.size() - 1].get());
    … …  
    15801437    for (ClauseListNode* list = m_list2.get(); list; list = list->getNext()) {
    15811438        RegisterID* clauseVal = generator.emitNode(list->getClause()->expr());
    1582         generator.emitStrictEqual(clauseVal, clauseVal, switchExpression);
     1439        generator.emitBinaryOp(op_stricteq, clauseVal, clauseVal, switchExpression);
    15831440        labelVector.append(generator.newLabel());
    15841441        generator.emitJumpIfTrueMayCombine(clauseVal, labelVector[labelVector.size() - 1].get());

  • trunk/JavaScriptCore/kjs/nodes.h

    r34555 r34562  
    3232#include "SourceRange.h"
    3333#include "SymbolTable.h"
     34#include "VM/Opcode.h"
    3435#include <wtf/UnusedParam.h>
    3536#include <wtf/ListRefPtr.h>
    … …  
    11961197    };
    11971198
    1198     class MultNode : public ExpressionNode {
    1199     public:
    1200         MultNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
    1201             : ExpressionNode(NumberType)
    1202             , m_term1(term1)
    1203             , m_term2(term2)
    1204         {
    1205         }
    1206 
    1207         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
    1208         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    1209         virtual Precedence precedence() const { return PrecMultiplicitave; }
    1210 
    1211     private:
    1212         RefPtr<ExpressionNode> m_term1;
    1213         RefPtr<ExpressionNode> m_term2;
    1214     };
    1215 
    1216     class DivNode : public ExpressionNode {
    1217     public:
    1218         DivNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
    1219             : ExpressionNode(NumberType)
    1220             , m_term1(term1)
    1221             , m_term2(term2)
    1222         {
    1223         }
    1224 
    1225         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
    1226         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    1227         virtual Precedence precedence() const { return PrecMultiplicitave; }
    1228 
    1229     private:
    1230         RefPtr<ExpressionNode> m_term1;
    1231         RefPtr<ExpressionNode> m_term2;
    1232     };
    1233 
    1234     class ModNode : public ExpressionNode {
    1235     public:
    1236         ModNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
    1237             : ExpressionNode(NumberType)
    1238             , m_term1(term1)
    1239             , m_term2(term2)
    1240         {
    1241         }
    1242 
    1243         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
    1244         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    1245         virtual Precedence precedence() const { return PrecMultiplicitave; }
    1246 
    1247     private:
    1248         RefPtr<ExpressionNode> m_term1;
    1249         RefPtr<ExpressionNode> m_term2;
    1250     };
    1251 
    1252     class AddNode : public ExpressionNode {
    1253     public:
    1254         AddNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1199    class BinaryOpNode : public ExpressionNode {
     1200    public:
     1201        BinaryOpNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments)
    12551202            : m_term1(term1)
    12561203            , m_term2(term2)
    … …  
    12591206        }
    12601207
    1261         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
    1262         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    1263         virtual Precedence precedence() const { return PrecAdditive; }
    1264 
    1265     protected:
    1266         AddNode(ExpressionNode* term1, ExpressionNode* term2, JSType expectedReturn, bool rightHasAssignments) KJS_FAST_CALL
    1267             : ExpressionNode(expectedReturn)
     1208        BinaryOpNode(JSType type, ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments)
     1209            : ExpressionNode(type)
    12681210            , m_term1(term1)
    12691211            , m_term2(term2)
    … …  
    12721214        }
    12731215
     1216        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1217        virtual OpcodeID opcode() const KJS_FAST_CALL = 0;
     1218
     1219    protected:
    12741220        RefPtr<ExpressionNode> m_term1;
    12751221        RefPtr<ExpressionNode> m_term2;
    … …  
    12771223    };
    12781224
    1279     class SubNode : public ExpressionNode {
    1280     public:
    1281         SubNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
    1282             : ExpressionNode(NumberType)
     1225    class ReverseBinaryOpNode : public ExpressionNode {
     1226    public:
     1227        ReverseBinaryOpNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments)
     1228            : m_term1(term1)
     1229            , m_term2(term2)
     1230            , m_rightHasAssignments(rightHasAssignments)
     1231        {
     1232        }
     1233
     1234        ReverseBinaryOpNode(JSType type, ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments)
     1235            : ExpressionNode(type)
    12831236            , m_term1(term1)
    12841237            , m_term2(term2)
    … …  
    12881241
    12891242        virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
    1290         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    1291         virtual Precedence precedence() const { return PrecAdditive; }
    1292 
    1293     private:
     1243        virtual OpcodeID opcode() const KJS_FAST_CALL = 0;
     1244
     1245    protected:
    12941246        RefPtr<ExpressionNode> m_term1;
    12951247        RefPtr<ExpressionNode> m_term2;
    … …  
    12971249    };
    12981250
    1299     class LeftShiftNode : public ExpressionNode {
    1300     public:
    1301         LeftShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
    1302             : ExpressionNode(NumberType)
    1303             , m_term1(term1)
    1304             , m_term2(term2)
    1305         {
    1306         }
    1307 
    1308         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1251    class MultNode : public BinaryOpNode {
     1252    public:
     1253        MultNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1254            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1255        {
     1256        }
     1257
     1258        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_mul; }
     1259        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     1260        virtual Precedence precedence() const { return PrecMultiplicitave; }
     1261    };
     1262
     1263    class DivNode : public BinaryOpNode {
     1264    public:
     1265        DivNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1266            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1267        {
     1268        }
     1269
     1270        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_div; }
     1271        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     1272        virtual Precedence precedence() const { return PrecMultiplicitave; }
     1273    };
     1274
     1275    class ModNode : public BinaryOpNode {
     1276    public:
     1277        ModNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1278            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1279        {
     1280        }
     1281
     1282        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_mod; }
     1283        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     1284        virtual Precedence precedence() const { return PrecMultiplicitave; }
     1285    };
     1286
     1287    class AddNode : public BinaryOpNode {
     1288    public:
     1289        AddNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1290            : BinaryOpNode(term1, term2, rightHasAssignments)
     1291        {
     1292        }
     1293
     1294        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_add; }
     1295        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     1296        virtual Precedence precedence() const { return PrecAdditive; }
     1297    };
     1298
     1299    class SubNode : public BinaryOpNode {
     1300    public:
     1301        SubNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1302            : BinaryOpNode(term1, term2, rightHasAssignments)
     1303        {
     1304        }
     1305
     1306        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_sub; }
     1307        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     1308        virtual Precedence precedence() const { return PrecAdditive; }
     1309    };
     1310
     1311    class LeftShiftNode : public BinaryOpNode {
     1312    public:
     1313        LeftShiftNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1314            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1315        {
     1316        }
     1317
     1318        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_lshift; }
    13091319        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13101320        virtual Precedence precedence() const { return PrecShift; }
    1311 
    1312     private:
    1313         RefPtr<ExpressionNode> m_term1;
    1314         RefPtr<ExpressionNode> m_term2;
    1315     };
    1316 
    1317     class RightShiftNode : public ExpressionNode {
    1318     public:
    1319         RightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
    1320             : ExpressionNode(NumberType)
    1321             , m_term1(term1)
    1322             , m_term2(term2)
    1323         {
    1324         }
    1325 
    1326         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1321    };
     1322
     1323    class RightShiftNode : public BinaryOpNode {
     1324    public:
     1325        RightShiftNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1326            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1327        {
     1328        }
     1329
     1330        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_rshift; }
    13271331        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13281332        virtual Precedence precedence() const { return PrecShift; }
    1329 
    1330     private:
    1331         RefPtr<ExpressionNode> m_term1;
    1332         RefPtr<ExpressionNode> m_term2;
    1333     };
    1334 
    1335     class UnsignedRightShiftNode : public ExpressionNode {
    1336     public:
    1337         UnsignedRightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
    1338             : ExpressionNode(NumberType)
    1339             , m_term1(term1)
    1340             , m_term2(term2)
    1341         {
    1342         }
    1343 
    1344         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1333    };
     1334
     1335    class UnsignedRightShiftNode : public BinaryOpNode {
     1336    public:
     1337        UnsignedRightShiftNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1338            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1339        {
     1340        }
     1341
     1342        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_urshift; }
    13451343        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13461344        virtual Precedence precedence() const { return PrecShift; }
    1347 
    1348     private:
    1349         RefPtr<ExpressionNode> m_term1;
    1350         RefPtr<ExpressionNode> m_term2;
    1351     };
    1352 
    1353     class LessNode : public ExpressionNode {
    1354     public:
    1355         LessNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1356             : ExpressionNode(BooleanType)
    1357             , m_expr1(expr1)
    1358             , m_expr2(expr2)
    1359         {
    1360         }
    1361 
    1362         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1345    };
     1346
     1347    class LessNode : public BinaryOpNode {
     1348    public:
     1349        LessNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1350            : BinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1351        {
     1352        }
     1353
     1354        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_less; }
    13631355        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13641356        virtual Precedence precedence() const { return PrecRelational; }
    1365 
    1366     protected:
    1367         RefPtr<ExpressionNode> m_expr1;
    1368         RefPtr<ExpressionNode> m_expr2;
    1369     };
    1370 
    1371     class GreaterNode : public ExpressionNode {
    1372     public:
    1373         GreaterNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1374             : m_expr1(expr1)
    1375             , m_expr2(expr2)
    1376         {
    1377         }
    1378 
    1379         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1357    };
     1358
     1359    class GreaterNode : public ReverseBinaryOpNode {
     1360    public:
     1361        GreaterNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1362            : ReverseBinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1363        {
     1364        }
     1365
     1366        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_less; }
    13801367        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13811368        virtual Precedence precedence() const { return PrecRelational; }
    1382 
    1383     private:
    1384         RefPtr<ExpressionNode> m_expr1;
    1385         RefPtr<ExpressionNode> m_expr2;
    1386     };
    1387 
    1388     class LessEqNode : public ExpressionNode {
    1389     public:
    1390         LessEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1391             : m_expr1(expr1)
    1392             , m_expr2(expr2)
    1393         {
    1394         }
    1395 
    1396         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1369    };
     1370
     1371    class LessEqNode : public BinaryOpNode {
     1372    public:
     1373        LessEqNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1374            : BinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1375        {
     1376        }
     1377
     1378        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_lesseq; }
    13971379        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    13981380        virtual Precedence precedence() const { return PrecRelational; }
    1399 
    1400     private:
    1401         RefPtr<ExpressionNode> m_expr1;
    1402         RefPtr<ExpressionNode> m_expr2;
    1403     };
    1404 
    1405     class GreaterEqNode : public ExpressionNode {
    1406     public:
    1407         GreaterEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1408             : m_expr1(expr1)
    1409             , m_expr2(expr2)
    1410         {
    1411         }
    1412 
    1413         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1381    };
     1382
     1383    class GreaterEqNode : public ReverseBinaryOpNode {
     1384    public:
     1385        GreaterEqNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1386            : ReverseBinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1387        {
     1388        }
     1389
     1390        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_lesseq; }
    14141391        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    14151392        virtual Precedence precedence() const { return PrecRelational; }
    1416 
    1417     private:
    1418         RefPtr<ExpressionNode> m_expr1;
    1419         RefPtr<ExpressionNode> m_expr2;
    1420     };
    1421 
    1422     class InstanceOfNode : public ExpressionNode {
    1423     public:
    1424         InstanceOfNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1425             : ExpressionNode(BooleanType)
    1426             , m_expr1(expr1)
    1427             , m_expr2(expr2)
    1428         {
    1429         }
    1430 
    1431         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1393    };
     1394
     1395    class InstanceOfNode : public BinaryOpNode {
     1396    public:
     1397        InstanceOfNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1398            : BinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1399        {
     1400        }
     1401
     1402        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_instanceof; }
    14321403        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    14331404        virtual Precedence precedence() const { return PrecRelational; }
    1434 
    1435     private:
    1436         RefPtr<ExpressionNode> m_expr1;
    1437         RefPtr<ExpressionNode> m_expr2;
    1438     };
    1439 
    1440     class InNode : public ExpressionNode {
    1441     public:
    1442         InNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1443             : m_expr1(expr1)
    1444             , m_expr2(expr2)
    1445         {
    1446         }
    1447 
    1448         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
    1449 
     1405    };
     1406
     1407    class InNode : public BinaryOpNode {
     1408    public:
     1409        InNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1410            : BinaryOpNode(term1, term2, rightHasAssignments)
     1411        {
     1412        }
     1413
     1414        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_in; }
    14501415        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    14511416        virtual Precedence precedence() const { return PrecRelational; }
    1452 
    1453     private:
    1454         RefPtr<ExpressionNode> m_expr1;
    1455         RefPtr<ExpressionNode> m_expr2;
    1456     };
    1457 
    1458     class EqualNode : public ExpressionNode {
    1459     public:
    1460         EqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1461             : ExpressionNode(BooleanType)
    1462             , m_expr1(expr1)
    1463             , m_expr2(expr2)
    1464         {
    1465         }
    1466 
    1467         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1417    };
     1418
     1419    class EqualNode : public BinaryOpNode {
     1420    public:
     1421        EqualNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1422            : BinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1423        {
     1424        }
     1425
     1426        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_eq; }
    14681427        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    14691428        virtual Precedence precedence() const { return PrecEquality; }
    1470 
    1471     private:
    1472         RefPtr<ExpressionNode> m_expr1;
    1473         RefPtr<ExpressionNode> m_expr2;
    1474     };
    1475 
    1476     class NotEqualNode : public ExpressionNode {
    1477     public:
    1478         NotEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1479             : ExpressionNode(BooleanType)
    1480             , m_expr1(expr1)
    1481             , m_expr2(expr2)
    1482         {
    1483         }
    1484 
    1485         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1429    };
     1430
     1431    class NotEqualNode : public BinaryOpNode {
     1432    public:
     1433        NotEqualNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1434            : BinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1435        {
     1436        }
     1437
     1438        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_neq; }
    14861439        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    14871440        virtual Precedence precedence() const { return PrecEquality; }
    1488 
    1489     private:
    1490         RefPtr<ExpressionNode> m_expr1;
    1491         RefPtr<ExpressionNode> m_expr2;
    1492     };
    1493 
    1494     class StrictEqualNode : public ExpressionNode {
    1495     public:
    1496         StrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1497             : ExpressionNode(BooleanType)
    1498             , m_expr1(expr1)
    1499             , m_expr2(expr2)
    1500         {
    1501         }
    1502 
    1503         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1441    };
     1442
     1443    class StrictEqualNode : public BinaryOpNode {
     1444    public:
     1445        StrictEqualNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1446            : BinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1447        {
     1448        }
     1449
     1450        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_stricteq; }
    15041451        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    15051452        virtual Precedence precedence() const { return PrecEquality; }
    1506 
    1507     private:
    1508         RefPtr<ExpressionNode> m_expr1;
    1509         RefPtr<ExpressionNode> m_expr2;
    1510     };
    1511 
    1512     class NotStrictEqualNode : public ExpressionNode {
    1513     public:
    1514         NotStrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1515             : ExpressionNode(BooleanType)
    1516             , m_expr1(expr1)
    1517             , m_expr2(expr2)
    1518         {
    1519         }
    1520 
    1521         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1453    };
     1454
     1455    class NotStrictEqualNode : public BinaryOpNode {
     1456    public:
     1457        NotStrictEqualNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1458            : BinaryOpNode(BooleanType, term1, term2, rightHasAssignments)
     1459        {
     1460        }
     1461
     1462        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_nstricteq; }
    15221463        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    15231464        virtual Precedence precedence() const { return PrecEquality; }
    1524 
    1525     private:
    1526         RefPtr<ExpressionNode> m_expr1;
    1527         RefPtr<ExpressionNode> m_expr2;
    1528     };
    1529 
    1530     class BitAndNode : public ExpressionNode {
    1531     public:
    1532         BitAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1533             : ExpressionNode(NumberType)
    1534             , m_expr1(expr1)
    1535             , m_expr2(expr2)
    1536         {
    1537         }
    1538 
    1539         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1465    };
     1466
     1467    class BitAndNode : public BinaryOpNode {
     1468    public:
     1469        BitAndNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1470            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1471        {
     1472        }
     1473
     1474        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_bitand; }
    15401475        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    15411476        virtual Precedence precedence() const { return PrecBitwiseAnd; }
    1542 
    1543     private:
    1544         RefPtr<ExpressionNode> m_expr1;
    1545         RefPtr<ExpressionNode> m_expr2;
    1546     };
    1547 
    1548     class BitOrNode : public ExpressionNode {
    1549     public:
    1550         BitOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1551             : ExpressionNode(NumberType)
    1552             , m_expr1(expr1)
    1553             , m_expr2(expr2)
    1554         {
    1555         }
    1556 
    1557         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1477    };
     1478
     1479    class BitOrNode : public BinaryOpNode {
     1480    public:
     1481        BitOrNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1482            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1483        {
     1484        }
     1485
     1486        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_bitor; }
    15581487        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    15591488        virtual Precedence precedence() const { return PrecBitwiseOr; }
    1560 
    1561     private:
    1562         RefPtr<ExpressionNode> m_expr1;
    1563         RefPtr<ExpressionNode> m_expr2;
    1564     };
    1565 
    1566     class BitXOrNode : public ExpressionNode {
    1567     public:
    1568         BitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
    1569             : ExpressionNode(NumberType)
    1570             , m_expr1(expr1)
    1571             , m_expr2(expr2)
    1572         {
    1573         }
    1574 
    1575         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
     1489    };
     1490
     1491    class BitXOrNode : public BinaryOpNode {
     1492    public:
     1493        BitXOrNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
     1494            : BinaryOpNode(NumberType, term1, term2, rightHasAssignments)
     1495        {
     1496        }
     1497
     1498        virtual OpcodeID opcode() const KJS_FAST_CALL { return op_bitxor; }
    15761499        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    15771500        virtual Precedence precedence() const { return PrecBitwiseXor; }
    1578 
    1579     private:
    1580         RefPtr<ExpressionNode> m_expr1;
    1581         RefPtr<ExpressionNode> m_expr2;
    15821501    };
    15831502

  • trunk/JavaScriptCore/kjs/nodes2string.cpp

    r34529 r34562  
    630630void LessNode::streamTo(SourceStream& s) const
    631631{
    632     streamLeftAssociativeBinaryOperator(s, precedence(), "<", m_expr1, m_expr2);
     632    streamLeftAssociativeBinaryOperator(s, precedence(), "<", m_term1, m_term2);
    633633}
    634634
    635635void GreaterNode::streamTo(SourceStream& s) const
    636636{
    637     streamLeftAssociativeBinaryOperator(s, precedence(), ">", m_expr1, m_expr2);
     637    streamLeftAssociativeBinaryOperator(s, precedence(), ">", m_term1, m_term2);
    638638}
    639639
    640640void LessEqNode::streamTo(SourceStream& s) const
    641641{
    642     streamLeftAssociativeBinaryOperator(s, precedence(), "<=", m_expr1, m_expr2);
     642    streamLeftAssociativeBinaryOperator(s, precedence(), "<=", m_term1, m_term2);
    643643}
    644644
    645645void GreaterEqNode::streamTo(SourceStream& s) const
    646646{
    647     streamLeftAssociativeBinaryOperator(s, precedence(), ">=", m_expr1, m_expr2);
     647    streamLeftAssociativeBinaryOperator(s, precedence(), ">=", m_term1, m_term2);
    648648}
    649649
    650650void InstanceOfNode::streamTo(SourceStream& s) const
    651651{
    652     streamLeftAssociativeBinaryOperator(s, precedence(), "instanceof", m_expr1, m_expr2);
     652    streamLeftAssociativeBinaryOperator(s, precedence(), "instanceof", m_term1, m_term2);
    653653}
    654654
    655655void InNode::streamTo(SourceStream& s) const
    656656{
    657     streamLeftAssociativeBinaryOperator(s, precedence(), "in", m_expr1, m_expr2);
     657    streamLeftAssociativeBinaryOperator(s, precedence(), "in", m_term1, m_term2);
    658658}
    659659
    660660void EqualNode::streamTo(SourceStream& s) const
    661661{
    662     streamLeftAssociativeBinaryOperator(s, precedence(), "==", m_expr1, m_expr2);
     662    streamLeftAssociativeBinaryOperator(s, precedence(), "==", m_term1, m_term2);
    663663}
    664664
    665665void NotEqualNode::streamTo(SourceStream& s) const
    666666{
    667     streamLeftAssociativeBinaryOperator(s, precedence(), "!=", m_expr1, m_expr2);
     667    streamLeftAssociativeBinaryOperator(s, precedence(), "!=", m_term1, m_term2);
    668668}
    669669
    670670void StrictEqualNode::streamTo(SourceStream& s) const
    671671{
    672     streamLeftAssociativeBinaryOperator(s, precedence(), "===", m_expr1, m_expr2);
     672    streamLeftAssociativeBinaryOperator(s, precedence(), "===", m_term1, m_term2);
    673673}
    674674
    675675void NotStrictEqualNode::streamTo(SourceStream& s) const
    676676{
    677     streamLeftAssociativeBinaryOperator(s, precedence(), "!==", m_expr1, m_expr2);
     677    streamLeftAssociativeBinaryOperator(s, precedence(), "!==", m_term1, m_term2);
    678678}
    679679
    680680void BitAndNode::streamTo(SourceStream& s) const
    681681{
    682     streamLeftAssociativeBinaryOperator(s, precedence(), "&", m_expr1, m_expr2);
     682    streamLeftAssociativeBinaryOperator(s, precedence(), "&", m_term1, m_term2);
    683683}
    684684
    685685void BitXOrNode::streamTo(SourceStream& s) const
    686686{
    687     streamLeftAssociativeBinaryOperator(s, precedence(), "^", m_expr1, m_expr2);
     687    streamLeftAssociativeBinaryOperator(s, precedence(), "^", m_term1, m_term2);
    688688}
    689689
    690690void BitOrNode::streamTo(SourceStream& s) const
    691691{
    692     streamLeftAssociativeBinaryOperator(s, precedence(), "|", m_expr1, m_expr2);
     692    streamLeftAssociativeBinaryOperator(s, precedence(), "|", m_term1, m_term2);
    693693}
    694694

  • trunk/LayoutTests/ChangeLog

    r34544 r34562  
     12008-06-15  Cameron Zwarich  <cwzwarich@uwaterloo.ca>
     2
     3        Reviewed by Maciej.
     4
     5        Tests for:
     6
     7        Bug 19484: More instructions needs to use temporary registers
     8        <https://bugs.webkit.org/show_bug.cgi?id=19484>
     9
     10        * fast/js/codegen-temporaries-expected.txt:
     11        * fast/js/resources/codegen-temporaries.js:
     12
    1132008-06-14  Darin Adler  <darin@apple.com>
    214

  • trunk/LayoutTests/fast/js/codegen-temporaries-expected.txt

    r34535 r34562  
    4343PASS bracket_test5() is 1
    4444PASS bracket_test6() is 1
     45PASS mult_test1() is 2
     46PASS mult_test2() is 2
     47PASS mult_test3() is 2
     48PASS div_test1() is 0.5
     49PASS div_test2() is 0.5
     50PASS div_test3() is 0.5
     51PASS mod_test1() is 1
     52PASS mod_test2() is 1
     53PASS mod_test3() is 1
    4554PASS add_test1() is 3
    4655PASS add_test2() is 3
    … …  
    4958PASS sub_test2() is -1
    5059PASS sub_test3() is -1
     60PASS lshift_test1() is 4
     61PASS lshift_test2() is 4
     62PASS lshift_test3() is 4
     63PASS rshift_test1() is 1
     64PASS rshift_test2() is 1
     65PASS rshift_test3() is 1
     66PASS urshift_test1() is 1
     67PASS urshift_test2() is 1
     68PASS urshift_test3() is 1
     69PASS less_test1() is true
     70PASS less_test2() is true
     71PASS less_test3() is true
     72PASS greater_test1() is true
     73PASS greater_test2() is true
     74PASS greater_test3() is true
     75PASS lesseq_test1() is true
     76PASS lesseq_test2() is true
     77PASS lesseq_test3() is true
     78PASS greatereq_test1() is true
     79PASS greatereq_test2() is true
     80PASS greatereq_test3() is true
     81PASS instanceof_test1() is true
     82PASS instanceof_test2() is true
     83PASS instanceof_test3() is true
     84PASS in_test1() is true
     85PASS in_test2() is true
     86PASS in_test3() is true
     87PASS eq_test1() is false
     88PASS eq_test2() is false
     89PASS eq_test3() is false
     90PASS neq_test1() is true
     91PASS neq_test2() is true
     92PASS neq_test3() is true
     93PASS stricteq_test1() is false
     94PASS stricteq_test2() is false
     95PASS stricteq_test3() is false
     96PASS nstricteq_test1() is true
     97PASS nstricteq_test2() is true
     98PASS nstricteq_test3() is true
     99PASS bitand_test1() is 0
     100PASS bitand_test2() is 0
     101PASS bitand_test3() is 0
     102PASS bitor_test1() is 3
     103PASS bitor_test2() is 3
     104PASS bitor_test3() is 3
     105PASS bitxor_test1() is 3
     106PASS bitxor_test2() is 3
     107PASS bitxor_test3() is 3
    51108PASS successfullyParsed is true
    52109

  • trunk/LayoutTests/fast/js/resources/codegen-temporaries.js

    r34535 r34562  
    351351shouldBe("bracket_test6()", "1");
    352352
     353function mult_test1()
     354{
     355    var a = 1;
     356    return a * (a = 2);
     357}
     358
     359shouldBe("mult_test1()", "2");
     360
     361function mult_test2()
     362{
     363    var a = 1;
     364    return a * ++a;
     365}
     366
     367shouldBe("mult_test2()", "2");
     368
     369function mult_test3()
     370{
     371    var a = 1;
     372    return a * (a += 1);
     373}
     374
     375shouldBe("mult_test3()", "2");
     376
     377function div_test1()
     378{
     379    var a = 1;
     380    return a / (a = 2);
     381}
     382
     383shouldBe("div_test1()", "0.5");
     384
     385function div_test2()
     386{
     387    var a = 1;
     388    return a / ++a;
     389}
     390
     391shouldBe("div_test2()", "0.5");
     392
     393function div_test3()
     394{
     395    var a = 1;
     396    return a / (a += 1);
     397}
     398
     399shouldBe("div_test3()", "0.5");
     400
     401function mod_test1()
     402{
     403    var a = 1;
     404    return a % (a = 2);
     405}
     406
     407shouldBe("mod_test1()", "1");
     408
     409function mod_test2()
     410{
     411    var a = 1;
     412    return a % ++a;
     413}
     414
     415shouldBe("mod_test2()", "1");
     416
     417function mod_test3()
     418{
     419    var a = 1;
     420    return a % (a += 1);
     421}
     422
     423shouldBe("mod_test3()", "1");
     424
    353425function add_test1()
    354426{
    … …  
    399471shouldBe("sub_test3()", "-1");
    400472
    401 successfullyParsed = true;
     473function lshift_test1()
     474{
     475    var a = 1;
     476    return a << (a = 2);
     477}
     478
     479shouldBe("lshift_test1()", "4");
     480
     481function lshift_test2()
     482{
     483    var a = 1;
     484    return a << ++a;
     485}
     486
     487shouldBe("lshift_test2()", "4");
     488
     489function lshift_test3()
     490{
     491    var a = 1;
     492    return a << (a += 1);
     493}
     494
     495shouldBe("lshift_test3()", "4");
     496
     497function rshift_test1()
     498{
     499    var a = 4;
     500    return a >> (a = 2);
     501}
     502
     503shouldBe("rshift_test1()", "1");
     504
     505function rshift_test2()
     506{
     507    var a = 2;
     508    return a >> --a;
     509}
     510
     511shouldBe("rshift_test2()", "1");
     512
     513function rshift_test3()
     514{
     515    var a = 2;
     516    return a >> (a -= 1);
     517}
     518
     519shouldBe("rshift_test3()", "1");
     520
     521function urshift_test1()
     522{
     523    var a = 4;
     524    return a >>> (a = 2);
     525}
     526
     527shouldBe("urshift_test1()", "1");
     528
     529function urshift_test2()
     530{
     531    var a = 2;
     532    return a >>> --a;
     533}
     534
     535shouldBe("urshift_test2()", "1");
     536
     537function urshift_test3()
     538{
     539    var a = 2;
     540    return a >>> (a -= 1);
     541}
     542
     543shouldBe("urshift_test3()", "1");
     544
     545function less_test1()
     546{
     547    var a = 1;
     548    return a < (a = 2);
     549}
     550
     551shouldBeTrue("less_test1()");
     552
     553function less_test2()
     554{
     555    var a = 1;
     556    return a < ++a;
     557}
     558
     559shouldBeTrue("less_test2()");
     560
     561function less_test3()
     562{
     563    var a = 1;
     564    return a < (a += 1);
     565}
     566
     567shouldBeTrue("less_test3()");
     568
     569function greater_test1()
     570{
     571    var a = 2;
     572    return a > (a = 1);
     573}
     574
     575shouldBeTrue("greater_test1()");
     576
     577function greater_test2()
     578{
     579    var a = 2;
     580    return a > --a;
     581}
     582
     583shouldBeTrue("greater_test2()");
     584
     585function greater_test3()
     586{
     587    var a = 2;
     588    return a > (a -= 1);
     589}
     590
     591shouldBeTrue("greater_test3()");
     592
     593function lesseq_test1()
     594{
     595    var a = 1;
     596    return a <= (a = 3, 2);
     597}
     598
     599shouldBeTrue("lesseq_test1()");
     600
     601function lesseq_test2()
     602{
     603    var a = 1;
     604    return a <= (++a, 1);
     605}
     606
     607shouldBeTrue("lesseq_test2()");
     608
     609function lesseq_test3()
     610{
     611    var a = 1;
     612    return a <= (a += 1, 1);
     613}
     614
     615shouldBeTrue("lesseq_test3()");
     616
     617function greatereq_test1()
     618{
     619    var a = 2;
     620    return a >= (a = 1, 2);
     621}
     622
     623shouldBeTrue("greatereq_test1()");
     624
     625function greatereq_test2()
     626{
     627    var a = 2;
     628    return a >= (--a, 2);
     629}
     630
     631shouldBeTrue("greatereq_test2()");
     632
     633function greatereq_test3()
     634{
     635    var a = 2;
     636    return a >= (a -= 1, 2);
     637}
     638
     639shouldBeTrue("greatereq_test3()");
     640
     641function instanceof_test1()
     642{
     643    var a = { };
     644    return a instanceof (a = 1, Object);
     645}
     646
     647shouldBeTrue("instanceof_test1()");
     648
     649function instanceof_test2()
     650{
     651    var a = { valueOf: function() { return 1; } };
     652    return a instanceof (++a, Object);
     653}
     654
     655shouldBeTrue("instanceof_test2()");
     656
     657function instanceof_test3()
     658{
     659    var a = { valueOf: function() { return 1; } };
     660    return a instanceof (a += 1, Object);
     661}
     662
     663shouldBeTrue("instanceof_test3()");
     664
     665function in_test1()
     666{
     667    var a = "a";
     668    return a in (a = "b", { a: 1 });
     669}
     670
     671shouldBeTrue("in_test1()");
     672
     673function in_test2()
     674{
     675    var a = { toString: function() { return "a"; }, valueOf: function() { return 1; } };
     676    return a in (++a, { a: 1 });
     677}
     678
     679shouldBeTrue("in_test2()");
     680
     681function in_test3()
     682{
     683    var a = { toString: function() { return "a"; }, valueOf: function() { return 1; } };
     684    return a in (a += 1, { a: 1 });
     685}
     686
     687shouldBeTrue("in_test3()");
     688
     689function eq_test1()
     690{
     691    var a = 1;
     692    return a == (a = 2);
     693}
     694
     695shouldBeFalse("eq_test1()");
     696
     697function eq_test2()
     698{
     699    var a = 1;
     700    return a == ++a;
     701}
     702
     703shouldBeFalse("eq_test2()");
     704
     705function eq_test3()
     706{
     707    var a = 1;
     708    return a == (a += 1);
     709}
     710
     711shouldBeFalse("eq_test3()");
     712
     713function neq_test1()
     714{
     715    var a = 1;
     716    return a != (a = 2);
     717}
     718
     719shouldBeTrue("neq_test1()");
     720
     721function neq_test2()
     722{
     723    var a = 1;
     724    return a != ++a;
     725}
     726
     727shouldBeTrue("neq_test2()");
     728
     729function neq_test3()
     730{
     731    var a = 1;
     732    return a != (a += 1);
     733}
     734
     735shouldBeTrue("neq_test3()");
     736
     737function stricteq_test1()
     738{
     739    var a = 1;
     740    return a === (a = 2);
     741}
     742
     743shouldBeFalse("stricteq_test1()");
     744
     745function stricteq_test2()
     746{
     747    var a = 1;
     748    return a === ++a;
     749}
     750
     751shouldBeFalse("stricteq_test2()");
     752
     753function stricteq_test3()
     754{
     755    var a = 1;
     756    return a === (a += 1);
     757}
     758
     759shouldBeFalse("stricteq_test3()");
     760
     761function nstricteq_test1()
     762{
     763    var a = 1;
     764    return a !== (a = 2);
     765}
     766
     767shouldBeTrue("nstricteq_test1()");
     768
     769function nstricteq_test2()
     770{
     771    var a = 1;
     772    return a !== ++a;
     773}
     774
     775shouldBeTrue("nstricteq_test2()");
     776
     777function nstricteq_test3()
     778{
     779    var a = 1;
     780    return a !== (a += 1);
     781}
     782
     783shouldBeTrue("nstricteq_test3()");
     784
     785function bitand_test1()
     786{
     787    var a = 1;
     788    return a & (a = 2);
     789}
     790
     791shouldBe("bitand_test1()", "0");
     792
     793function bitand_test2()
     794{
     795    var a = 1;
     796    return a & ++a;
     797}
     798
     799shouldBe("bitand_test2()", "0");
     800
     801function bitand_test3()
     802{
     803    var a = 1;
     804    return a & (a += 1);
     805}
     806
     807shouldBe("bitand_test3()", "0");
     808
     809function bitor_test1()
     810{
     811    var a = 1;
     812    return a | (a = 2);
     813}
     814
     815shouldBe("bitor_test1()", "3");
     816
     817function bitor_test2()
     818{
     819    var a = 1;
     820    return a | ++a;
     821}
     822
     823shouldBe("bitor_test2()", "3");
     824
     825function bitor_test3()
     826{
     827    var a = 1;
     828    return a | (a += 1);
     829}
     830
     831shouldBe("bitor_test3()", "3");
     832
     833function bitxor_test1()
     834{
     835    var a = 1;
     836    return a ^ (a = 2);
     837}
     838
     839shouldBe("bitxor_test1()", "3");
     840
     841function bitxor_test2()
     842{
     843    var a = 1;
     844    return a ^ ++a;
     845}
     846
     847shouldBe("bitxor_test2()", "3");
     848
     849function bitxor_test3()
     850{
     851    var a = 1;
     852    return a ^ (a += 1);
     853}
     854
     855shouldBe("bitxor_test3()", "3");
     856
     857var successfullyParsed = true;
Note: See TracChangeset for help on using the changeset viewer.