Changeset 37405 in webkit for trunk/JavaScriptCore/kjs

Timestamp:

Oct 7, 2008, 8:46:34 PM (17 years ago)

Author:

[email protected]

Message:

2008-10-07 Maciej Stachowiak <​[email protected]>

Reviewed by Mark Rowe.

• optimize away multiplication by constant 1.0

2.3% speedup on v8 RayTrace benchmark

Apparently it's not uncommon for JavaScript code to multiply by
constant 1.0 in the mistaken belief that this converts integer to
floating point and that there is any operational difference.

• VM/CTI.cpp: (JSC::CTI::privateCompileMainPass): Optimize to_jsnumber for case where parameter is already number. (JSC::CTI::privateCompileSlowCases): ditto
• VM/Machine.cpp: (JSC::Machine::privateExecute): ditto
• kjs/grammar.y: (makeMultNode): Transform as follows: +FOO * BAR ==> FOO * BAR FOO * +BAR ==> FOO * BAR FOO * 1 ==> +FOO 1 * FOO ==> +FOO (makeDivNode): Transform as follows: +FOO / BAR ==> FOO / BAR FOO / +BAR ==> FOO / BAR (makeSubNode): Transform as follows: +FOO - BAR ==> FOO - BAR FOO - +BAR ==> FOO - BAR
• kjs/nodes.h: (JSC::ExpressionNode::stripUnaryPlus): Helper for above grammar.y changes (JSC::UnaryPlusNode::stripUnaryPlus): ditto

Location:

trunk/JavaScriptCore/kjs

Files:

• grammar.y (modified) (3 diffs)
• nodes.h (modified) (2 diffs)

trunk/JavaScriptCore/kjs/grammar.y

@@ -1425 +1425 @@
 static ExpressionNode* makeMultNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
+    // these transforms are valid because unary + only does a toNumber
+    // conversion, which * does anyway:
+    expr1 = expr1->stripUnaryPlus(); // +FOO * BAR ==> FOO * BAR
+    expr2 = expr2->stripUnaryPlus(); // FOO * +BAR ==> FOO * BAR
+
     if (expr1->isNumber() && expr2->isNumber())
         return makeNumberNode(globalPtr, static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());
+
+    // these transforms are valid because multiplying by 1 has no
+    // effect but toNumber conversion
+    if (expr1->isNumber() && static_cast<NumberNode*>(expr1)->value() == 1)
+        return new UnaryPlusNode(GLOBAL_DATA, expr2); // 1 * FOO ==> +FOO
+    if (expr2->isNumber() && static_cast<NumberNode*>(expr2)->value() == 1)
+        return new UnaryPlusNode(GLOBAL_DATA, expr1); // FOO * 1 ==> +FOO
+
     return new MultNode(GLOBAL_DATA, expr1, expr2, rightHasAssignments);
 }
@@ -1432 +1445 @@
 static ExpressionNode* makeDivNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
+    // these transforms are valid because unary + only does a toNumber
+    // conversion, which / does anyway:
+    expr1 = expr1->stripUnaryPlus(); // +FOO / BAR ==> FOO / BAR
+    expr2 = expr2->stripUnaryPlus(); // FOO / +BAR ==> FOO / BAR
+
     if (expr1->isNumber() && expr2->isNumber())
         return makeNumberNode(globalPtr, static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
@@ -1446 +1464 @@
 static ExpressionNode* makeSubNode(void* globalPtr, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 {
+    // these transforms are valid because unary + only does a toNumber
+    // conversion, which - does anyway:
+    expr1 = expr1->stripUnaryPlus(); // +FOO - BAR ==> FOO - BAR
+    expr2 = expr2->stripUnaryPlus(); // FOO - +BAR ==> FOO - BAR
+
     if (expr1->isNumber() && expr2->isNumber())
         return makeNumberNode(globalPtr, static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());

trunk/JavaScriptCore/kjs/nodes.h

@@ -227 +227 @@
         virtual bool isDotAccessorNode() const JSC_FAST_CALL { return false; }
 
+        virtual ExpressionNode* stripUnaryPlus() { return this; }
+
         ResultType resultDescriptor() const JSC_FAST_CALL { return m_resultDesc; }
 
@@ -1179 +1181 @@
         {
         }
+
+        virtual ExpressionNode* stripUnaryPlus() { return m_expr.get(); }
 
         virtual OpcodeID opcode() const JSC_FAST_CALL { return op_to_jsnumber; }