Attachment 357795 Details for Bug 192921 – ROLLOUT of r239377

[patch] ROLLOUT of r239377

bug-192921-20181219233345.patch (text/plain), 12.46 KB, created by WebKit Commit Bot on 2018-12-19 23:33:46 PST

(hide)

Description:

Filename:

MIME Type:

Creator: WebKit Commit Bot

Created: 2018-12-19 23:33:46 PST

Size: 12.46 KB

patch

obsolete

>Subversion Revision: 239433
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 7017533c8041959ca35a2379a31888c0a0a4525c..d60fcf1ebe66043703430efc8392f45f2b124c51 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,17 @@
>+2018-12-19  Commit Queue  <commit-queue@webkit.org>
>+
>+        Unreviewed, rolling out r239377.
>+        https://bugs.webkit.org/show_bug.cgi?id=192921
>+
>+        broke 32-bit JSC tests (Requested by keith_miller on #webkit).
>+
>+        Reverted changeset:
>+
>+        "[BigInt] We should enable CSE into arithmetic operations that
>+        speculate BigIntUse"
>+        https://bugs.webkit.org/show_bug.cgi?id=192723
>+        https://trac.webkit.org/changeset/239377
>+
> 2018-12-19  Chris Dumez  <cdumez@apple.com>
> 
>         wtf/Optional.h: move-constructor and move-assignment operator should disengage the value being moved from
>diff --git a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>index 5197133ead4b2d28d1fb3ecfc547ff77f01ba905..f288d6e6a7407ee11002d9d2eb85b6c2229add13 100644
>--- a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>+++ b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>@@ -397,12 +397,11 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
>     case ValueBitXor:
>     case ValueBitAnd:
>     case ValueBitOr:
>+        clobberWorld();
>         if (node->binaryUseKind() == BigIntUse)
>             setTypeForNode(node, SpecBigInt);
>-        else {
>-            clobberWorld();
>+        else
>             setTypeForNode(node, SpecBoolInt32 | SpecBigInt);
>-        }
>         break;
>             
>     case ArithBitAnd:
>@@ -614,12 +613,11 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
>     case ValueSub:
>     case ValueAdd: {
>         DFG_ASSERT(m_graph, node, node->binaryUseKind() == UntypedUse || node->binaryUseKind() == BigIntUse);
>+        clobberWorld();
>         if (node->binaryUseKind() == BigIntUse)
>             setTypeForNode(node, SpecBigInt);
>-        else {
>-            clobberWorld();
>+        else
>             setTypeForNode(node, SpecString | SpecBytecodeNumber | SpecBigInt);
>-        }
>         break;
>     }
> 
>@@ -858,12 +856,11 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
>     }
>         
>     case ValueMul: {
>+        clobberWorld();
>         if (node->binaryUseKind() == BigIntUse)
>             setTypeForNode(node, SpecBigInt);
>-        else {
>-            clobberWorld();
>+        else
>             setTypeForNode(node, SpecBytecodeNumber | SpecBigInt);
>-        }
>         break;
>     }
> 
>@@ -918,12 +915,11 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
>     }
>         
>     case ValueDiv: {
>+        clobberWorld();
>         if (node->binaryUseKind() == BigIntUse)
>             setTypeForNode(node, SpecBigInt);
>-        else {
>-            clobberWorld();
>+        else
>             setTypeForNode(node, SpecBytecodeNumber | SpecBigInt);
>-        }
>         break;
>     }
> 
>diff --git a/Source/JavaScriptCore/dfg/DFGClobberize.h b/Source/JavaScriptCore/dfg/DFGClobberize.h
>index 48c846bd3897d14de4e25b27d9570d82da871ae9..250ec00443d12c063aa43eeebdc48c70294125a5 100644
>--- a/Source/JavaScriptCore/dfg/DFGClobberize.h
>+++ b/Source/JavaScriptCore/dfg/DFGClobberize.h
>@@ -644,7 +644,14 @@ void clobberize(Graph& graph, Node* node, const ReadFunctor& read, const WriteFu
>     case InByVal:
>     case InById:
>     case HasOwnProperty:
>+    case ValueBitAnd:
>+    case ValueBitXor:
>+    case ValueBitOr:
>     case ValueNegate:
>+    case ValueAdd:
>+    case ValueSub:
>+    case ValueMul:
>+    case ValueDiv:
>     case SetFunctionName:
>     case GetDynamicVar:
>     case PutDynamicVar:
>@@ -666,21 +673,6 @@ void clobberize(Graph& graph, Node* node, const ReadFunctor& read, const WriteFu
>         write(Heap);
>         return;
> 
>-    case ValueBitAnd:
>-    case ValueBitXor:
>-    case ValueBitOr:
>-    case ValueAdd:
>-    case ValueSub:
>-    case ValueMul:
>-    case ValueDiv:
>-        if (node->isBinaryUseKind(BigIntUse)) {
>-            def(PureValue(node));
>-            return;
>-        }
>-        read(World);
>-        write(Heap);
>-        return;
>-
>     case AtomicsAdd:
>     case AtomicsAnd:
>     case AtomicsCompareExchange:
>diff --git a/Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp b/Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp
>index 16258a1fba79429e162b16a621a47cb292afb094..4f2f1d0b85fb3f70c225e47a59c4f706511e7d41 100644
>--- a/Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp
>@@ -121,15 +121,6 @@ private:
>             }
>             break;
>             
>-        case ValueMul:
>-        case ValueBitOr:
>-        case ValueBitAnd:
>-        case ValueBitXor: {
>-            if (m_node->binaryUseKind() == BigIntUse)
>-                handleCommutativity();
>-            break;
>-        }
>-
>         case ArithMul: {
>             handleCommutativity();
>             Edge& child2 = m_node->child2();
>@@ -373,10 +364,6 @@ private:
>                 convertToLazyJSValue(m_node, LazyJSValue::newString(m_graph, builder.toString()));
>                 m_changed = true;
>             }
>-
>-            if (m_node->binaryUseKind() == BigIntUse)
>-                handleCommutativity();
>-
>             break;
>         }
> 
>diff --git a/PerformanceTests/BigIntBench/big-int-cse.js b/PerformanceTests/BigIntBench/big-int-cse.js
>deleted file mode 100644
>index d8b53dd7212746f590e15b66853270905ec52230..0000000000000000000000000000000000000000
>--- a/PerformanceTests/BigIntBench/big-int-cse.js
>+++ /dev/null
>@@ -1,103 +0,0 @@
>-function assert(a, e) {
>-    if (a !== e)
>-        throw new Error("Expected " + e + " but got: " + a);
>-}
>-
>-function bigIntAdd(a, b) {
>-    let c = a + b;
>-    return b + a + c;
>-}
>-noInline(bigIntAdd);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntAdd(3n, 5n), 16n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntAdd(0xffffffffffffffffffn, 0xaaffffffffffffffffffn), 1624494070107157953511420n);
>-}
>-
>-function bigIntMul(a, b) {
>-    let c = a * b;
>-    return b * a + c;
>-}
>-noInline(bigIntMul);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntMul(3n, 5n), 30n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntMul(0xffffffffffffffffffn, 0xaaffffffffffffffffffn), 7626854857897473114403591155175632477091790850n);
>-}
>-
>-function bigIntDiv(a, b) {
>-    let c = a / b;
>-    return a / b + c;
>-}
>-noInline(bigIntDiv);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntDiv(15n, 5n), 6n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntDiv(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 342n);
>-}
>-
>-function bigIntSub(a, b) {
>-    let c = a - b;
>-    return a - b + c;
>-}
>-noInline(bigIntSub);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntSub(15n, 5n), 20n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntSub(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 1605604604175679372656640n);
>-}
>-
>-function bigIntBitOr(a, b) {
>-    let c = a | b;
>-    return (b | a) + c;
>-}
>-noInline(bigIntBitOr);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitOr(0b1101n, 0b0010n), 30n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitOr(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 1615049337141418663084030n);
>-}
>-
>-function bigIntBitAnd(a, b) {
>-    let c = a & b;
>-    return (b & a) + c;
>-}
>-noInline(bigIntBitAnd);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitAnd(0b1101n, 0b0010n), 0n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitAnd(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 9444732965739290427390n);
>-}
>-
>-function bigIntBitXor(a, b) {
>-    let c = a ^ b;
>-    return (b ^ a) + c;
>-}
>-noInline(bigIntBitXor);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitXor(0b1101n, 0b0010n), 30n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitXor(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 1605604604175679372656640n);
>-}
>-
>diff --git a/PerformanceTests/BigIntBench/big-int-global-cse.js b/PerformanceTests/BigIntBench/big-int-global-cse.js
>deleted file mode 100644
>index d5c0246b263ca7770af1ee7081e6c5a3d4c17c3b..0000000000000000000000000000000000000000
>--- a/PerformanceTests/BigIntBench/big-int-global-cse.js
>+++ /dev/null
>@@ -1,124 +0,0 @@
>-function assert(a, e) {
>-    if (a !== e)
>-        throw new Error("Expected " + e + " but got: " + a);
>-}
>-
>-function bigIntAdd(a, b) {
>-    let c = a + b;
>-    if (b) {
>-        assert(c, a + b);
>-    }
>-    return a + b + c;
>-}
>-noInline(bigIntAdd);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntAdd(3n, 5n), 16n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntAdd(0xffffffffffffffffffn, 0xaaffffffffffffffffffn), 1624494070107157953511420n);
>-}
>-
>-function bigIntMul(a, b) {
>-    let c = a * b;
>-    if (b) {
>-        assert(c, a * b);
>-    }
>-    return a * b + c;
>-}
>-noInline(bigIntMul);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntMul(3n, 5n), 30n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntMul(0xffffffffffffffffffn, 0xaaffffffffffffffffffn), 7626854857897473114403591155175632477091790850n);
>-}
>-
>-function bigIntDiv(a, b) {
>-    let c = a / b;
>-    if (b) {
>-        assert(c, a / b);
>-    }
>-    return a / b + c;
>-}
>-noInline(bigIntDiv);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntDiv(15n, 5n), 6n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntDiv(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 342n);
>-}
>-
>-function bigIntSub(a, b) {
>-    let c = a - b;
>-    if (b) {
>-        assert(c, a - b);
>-    }
>-    return a - b + c;
>-}
>-noInline(bigIntSub);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntSub(15n, 5n), 20n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntSub(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 1605604604175679372656640n);
>-}
>-
>-function bigIntBitOr(a, b) {
>-    let c = a | b;
>-    if (b) {
>-        assert(c, a | b);
>-    }
>-    return (a | b) + c;
>-}
>-noInline(bigIntBitOr);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitOr(0b1101n, 0b0010n), 30n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitOr(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 1615049337141418663084030n);
>-}
>-
>-function bigIntBitAnd(a, b) {
>-    let c = a & b;
>-    if (b) {
>-        assert(c, a & b);
>-    }
>-    return (a & b) + c;
>-}
>-noInline(bigIntBitAnd);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitAnd(0b1101n, 0b0010n), 0n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitAnd(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 9444732965739290427390n);
>-}
>-
>-function bigIntBitXor(a, b) {
>-    let c = a ^ b;
>-    if (b) {
>-        assert(c, a ^ b);
>-    }
>-    return (a ^ b) + c;
>-}
>-noInline(bigIntBitXor);
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitXor(0b1101n, 0b0010n), 30n);
>-}
>-
>-for (let i = 0; i < 100000; i++) {
>-    assert(bigIntBitXor(0xaaffffffffffffffffffn, 0xffffffffffffffffffn), 1605604604175679372656640n);
>-}
>-
>diff --git a/PerformanceTests/BigIntBench/big-int-licm.js b/PerformanceTests/BigIntBench/big-int-licm.js
>deleted file mode 100644
>index 6c64c9757983edc59e25e6bd912a049f07e6b2ce..0000000000000000000000000000000000000000
>--- a/PerformanceTests/BigIntBench/big-int-licm.js
>+++ /dev/null
>@@ -1,19 +0,0 @@
>-function assert(a, e) {
>-    if (a !== e)
>-        throw new Error("Expected " + e + " but got: " + a);
>-}
>-
>-function iteration(a, b, r) {
>-    let acc = 0n;
>-    for (let i = 0n; i < r; i += 1n) {
>-        acc += a + b;
>-    }
>-
>-    return acc;
>-}
>-noInline(iteration);
>-
>-for (let i = 0; i < 10000; i++) {
>-    assert(iteration(1n, 2n, 100n), 300n)
>-}
>-
>diff --git a/PerformanceTests/ChangeLog b/PerformanceTests/ChangeLog
>index 8bc4eefe68471163e5ede053b9be3e6b68b42958..c115c5ba31af34ff96ba6cc966b319ddbd025c6e 100644
>--- a/PerformanceTests/ChangeLog
>+++ b/PerformanceTests/ChangeLog
>@@ -1,3 +1,17 @@
>+2018-12-19  Commit Queue  <commit-queue@webkit.org>
>+
>+        Unreviewed, rolling out r239377.
>+        https://bugs.webkit.org/show_bug.cgi?id=192921
>+
>+        broke 32-bit JSC tests (Requested by keith_miller on #webkit).
>+
>+        Reverted changeset:
>+
>+        "[BigInt] We should enable CSE into arithmetic operations that
>+        speculate BigIntUse"
>+        https://bugs.webkit.org/show_bug.cgi?id=192723
>+        https://trac.webkit.org/changeset/239377
>+
> 2018-12-19  Caio Lima  <ticaiolima@gmail.com>
> 
>         [BigInt] We should enable CSE into arithmetic operations that speculate BigIntUse

Actions: View | Formatted Diff | Diff

Attachments on bug 192921: 357795