Changeset 229517 in webkit for trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp

Timestamp:

Mar 11, 2018, 12:52:24 PM (7 years ago)

Author:

Yusuke Suzuki

Message:

[B3] Above/Below should be strength-reduced for comparison with 0
​https://bugs.webkit.org/show_bug.cgi?id=183543

Reviewed by Filip Pizlo.

Above(0, x) and BelowEqual(0, x) can be converted to constants false and true respectively.
This can be seen in ArraySlice(0) case: Select(Above(0, length), length, 0) this should
be converted to 0. This patch adds such a folding to comparisons.

We also fix B3ReduceStrength issue creating an orphan value. If a flipped value is folded to
a constant, we do not insert flipped value and make it an orphan. This issue causes JSC test
failure with this B3Const32/64Value change. With this patch, we create a flipped value only
when we fail to fold it to a constant.

• b3/B3Const32Value.cpp:

(JSC::B3::Const32Value::lessThanConstant const):
(JSC::B3::Const32Value::greaterThanConstant const):
(JSC::B3::Const32Value::lessEqualConstant const):
(JSC::B3::Const32Value::greaterEqualConstant const):
(JSC::B3::Const32Value::aboveConstant const):
(JSC::B3::Const32Value::belowConstant const):
(JSC::B3::Const32Value::aboveEqualConstant const):
(JSC::B3::Const32Value::belowEqualConstant const):

• b3/B3Const64Value.cpp:

(JSC::B3::Const64Value::lessThanConstant const):
(JSC::B3::Const64Value::greaterThanConstant const):
(JSC::B3::Const64Value::lessEqualConstant const):
(JSC::B3::Const64Value::greaterEqualConstant const):
(JSC::B3::Const64Value::aboveConstant const):
(JSC::B3::Const64Value::belowConstant const):
(JSC::B3::Const64Value::aboveEqualConstant const):
(JSC::B3::Const64Value::belowEqualConstant const):

• b3/B3ReduceStrength.cpp:
• b3/testb3.cpp:

(JSC::B3::int64Operands):
(JSC::B3::int32Operands):

File:

• trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp (modified) (4 diffs)

trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp

@@ -1674 +1674 @@
         case AboveEqual:
         case BelowEqual: {
-            auto* value = newComparisonVaueIfNecessary();
+            CanonicalizedComparison comparison = canonicalizeComparison(m_value);
             TriState result = MixedTriState;
-            switch (value->opcode()) {
+            switch (comparison.opcode) {
             case LessThan:
-                result = value->child(1)->greaterThanConstant(value->child(0));
+                result = comparison.operands[1]->greaterThanConstant(comparison.operands[0]);
                 break;
             case GreaterThan:
-                result = value->child(1)->lessThanConstant(value->child(0));
+                result = comparison.operands[1]->lessThanConstant(comparison.operands[0]);
                 break;
             case LessEqual:
-                result = value->child(1)->greaterEqualConstant(value->child(0));
+                result = comparison.operands[1]->greaterEqualConstant(comparison.operands[0]);
                 break;
             case GreaterEqual:
-                result = value->child(1)->lessEqualConstant(value->child(0));
+                result = comparison.operands[1]->lessEqualConstant(comparison.operands[0]);
                 break;
             case Above:
-                result = value->child(1)->belowConstant(value->child(0));
+                result = comparison.operands[1]->belowConstant(comparison.operands[0]);
                 break;
             case Below:
-                result = value->child(1)->aboveConstant(value->child(0));
+                result = comparison.operands[1]->aboveConstant(comparison.operands[0]);
                 break;
             case AboveEqual:
-                result = value->child(1)->belowEqualConstant(value->child(0));
+                result = comparison.operands[1]->belowEqualConstant(comparison.operands[0]);
                 break;
             case BelowEqual:
-                result = value->child(1)->aboveEqualConstant(value->child(0));
+                result = comparison.operands[1]->aboveEqualConstant(comparison.operands[0]);
                 break;
             default:
@@ -1706 +1706 @@
             }
 
-            if (auto* constant = m_proc.addBoolConstant(value->origin(), result)) {
+            if (auto* constant = m_proc.addBoolConstant(m_value->origin(), result)) {
                 replaceWithNewValue(constant);
                 break;
             }
-
-            // Replace with newly created "value". Its opcode is flipped and operands are swapped from m_value.
-            if (m_value != value)
-                replaceWithNewValue(value);
+            if (comparison.opcode != m_value->opcode()) {
+                replaceWithNew<Value>(comparison.opcode, m_value->origin(), comparison.operands[0], comparison.operands[1]);
+                break;
+            }
             break;
         }
@@ -2167 +2167 @@
     }
 
-    Value* newComparisonVaueIfNecessary()
+    struct CanonicalizedComparison {
+        Opcode opcode;
+        Value* operands[2];
+    };
+    static CanonicalizedComparison canonicalizeComparison(Value* value)
     {
         auto flip = [] (Opcode opcode) {
@@ -2191 +2195 @@
             }
         };
-        if (shouldSwapBinaryOperands(m_value)) {
-            m_changed = true;
-            return m_proc.add<Value>(flip(m_value->opcode()), m_value->origin(), m_value->child(1), m_value->child(0));
-        }
-        return m_value;
+        if (shouldSwapBinaryOperands(value))
+            return { flip(value->opcode()), { value->child(1), value->child(0) } };
+        return { value->opcode(), { value->child(0), value->child(1) } };
     }