Changeset 34562 in webkit for trunk/JavaScriptCore/kjs/nodes.h


Ignore:
Timestamp:
Jun 15, 2008, 2:30:56 AM (17 years ago)
Author:
[email protected]
Message:

2008-06-15 Cameron Zwarich <​[email protected]>

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:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.