Attachment 359236 Details for Bug 182216 – Patch

[patch] Patch

bug-182216-20190115230622.patch (text/plain), 32.12 KB, created by Caio Lima on 2019-01-15 18:06:25 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Caio Lima

Created: 2019-01-15 18:06:25 PST

Size: 32.12 KB

patch

obsolete

>Subversion Revision: 239982
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 3e57f55dc915ebb4fa52941378ea919206d816de..84de3b528fc49d15b69373f7e00fab21c18bee11 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,56 @@
>+2019-01-15  Caio Lima  <ticaiolima@gmail.com>
>+
>+        [ESNext][BigInt] Implement "~" unary operation
>+        https://bugs.webkit.org/show_bug.cgi?id=182216
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This Patch is adding support of BigInt into op_bitnot operations. In
>+        addition, we are changing ArithBitNot to handle only Number operands,
>+        while introducing a new node named ValueBitNot to handle Untyped and
>+        BigInt. This node follows the same approach we are doing into other
>+        arithimetic operations into DFG.
>+
>+        * dfg/DFGAbstractInterpreterInlines.h:
>+        (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
>+        * dfg/DFGBackwardsPropagationPhase.cpp:
>+        (JSC::DFG::BackwardsPropagationPhase::propagate):
>+        * dfg/DFGByteCodeParser.cpp:
>+        (JSC::DFG::ByteCodeParser::parseBlock):
>+        * dfg/DFGClobberize.h:
>+        (JSC::DFG::clobberize):
>+        * dfg/DFGDoesGC.cpp:
>+        (JSC::DFG::doesGC):
>+        * dfg/DFGFixupPhase.cpp:
>+        (JSC::DFG::FixupPhase::fixupNode):
>+        * dfg/DFGNode.h:
>+        (JSC::DFG::Node::hasHeapPrediction):
>+        * dfg/DFGNodeType.h:
>+        * dfg/DFGOperations.cpp:
>+        * dfg/DFGOperations.h:
>+        * dfg/DFGPredictionPropagationPhase.cpp:
>+        * dfg/DFGSafeToExecute.h:
>+        (JSC::DFG::safeToExecute):
>+        * dfg/DFGSpeculativeJIT.cpp:
>+        (JSC::DFG::SpeculativeJIT::compileValueBitNot):
>+        (JSC::DFG::SpeculativeJIT::compileBitwiseNot):
>+        * dfg/DFGSpeculativeJIT.h:
>+        * dfg/DFGSpeculativeJIT32_64.cpp:
>+        (JSC::DFG::SpeculativeJIT::compile):
>+        * dfg/DFGSpeculativeJIT64.cpp:
>+        (JSC::DFG::SpeculativeJIT::compile):
>+        * ftl/FTLCapabilities.cpp:
>+        (JSC::FTL::canCompile):
>+        * ftl/FTLLowerDFGToB3.cpp:
>+        (JSC::FTL::DFG::LowerDFGToB3::compileNode):
>+        (JSC::FTL::DFG::LowerDFGToB3::compileValueBitNot):
>+        (JSC::FTL::DFG::LowerDFGToB3::compileArithBitNot):
>+        * runtime/CommonSlowPaths.cpp:
>+        (JSC::SLOW_PATH_DECL):
>+        * runtime/JSBigInt.cpp:
>+        (JSC::JSBigInt::bitwiseNot):
>+        * runtime/JSBigInt.h:
>+
> 2019-01-15  Tomas Popela  <tpopela@redhat.com>
> 
>         Unreviewed: Fix the -Wformat compiler warnings
>diff --git a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>index f87fcd532c12f72bedc816b9f560a1eb58bec053..99bad513ccf90ee144d6ea31825e213e44c87e0d 100644
>--- a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>+++ b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>@@ -376,13 +376,26 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
>         break;
>     }
> 
>-    case ArithBitNot: {
>-        if (node->child1().useKind() == UntypedUse) {
>-            clobberWorld();
>-            setNonCellTypeForNode(node, SpecInt32Only);
>+    case ValueBitNot: {
>+        JSValue operand = forNode(node->child1()).value();
>+        if (operand && operand.isInt32()) {
>+            int32_t a = operand.asInt32();
>+            didFoldClobberWorld();
>+            setConstant(node, JSValue(~a));
>             break;
>         }
> 
>+        if (node->child1().useKind() == BigIntUse)
>+            setTypeForNode(node, SpecBigInt);
>+        else {
>+            clobberWorld();
>+            setTypeForNode(node, SpecBoolInt32 | SpecBigInt);
>+        }
>+
>+        break;
>+    }
>+
>+    case ArithBitNot: {
>         JSValue operand = forNode(node->child1()).value();
>         if (operand && operand.isInt32()) {
>             int32_t a = operand.asInt32();
>diff --git a/Source/JavaScriptCore/dfg/DFGBackwardsPropagationPhase.cpp b/Source/JavaScriptCore/dfg/DFGBackwardsPropagationPhase.cpp
>index f4ce71eba58adbd5b36109e6fb6b32962cdd72f9..6ecc199d72670bdfa96e0b1b24da48c0f36c5279 100644
>--- a/Source/JavaScriptCore/dfg/DFGBackwardsPropagationPhase.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGBackwardsPropagationPhase.cpp
>@@ -210,6 +210,7 @@ private:
>         case CheckVarargs:
>             break;
>             
>+        case ValueBitNot:
>         case ArithBitNot: {
>             flags |= NodeBytecodeUsesAsInt;
>             flags &= ~(NodeBytecodeUsesAsNumber | NodeBytecodeNeedsNegZero | NodeBytecodeUsesAsOther);
>diff --git a/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp b/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
>index 6b0d92a2f4354d4d823c10e45f6f478b98ed9cd0..877cd460b3ec1be6be7fc8207a4cf1ecf12f02e7 100644
>--- a/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
>@@ -4932,8 +4932,12 @@ void ByteCodeParser::parseBlock(unsigned limit)
> 
>         case op_bitnot: {
>             auto bytecode = currentInstruction->as<OpBitnot>();
>+            SpeculatedType prediction = getPrediction();
>             Node* op1 = get(bytecode.operand);
>-            set(bytecode.dst, addToGraph(ArithBitNot, op1));
>+            if (op1->hasNumberOrAnyIntResult())
>+                set(bytecode.dst, addToGraph(ArithBitNot, op1));
>+            else
>+                set(bytecode.dst, addToGraph(ValueBitNot, OpInfo(), OpInfo(prediction), op1));
>             NEXT_OPCODE(op_bitnot);
>         }
> 
>diff --git a/Source/JavaScriptCore/dfg/DFGClobberize.h b/Source/JavaScriptCore/dfg/DFGClobberize.h
>index 58ec03035053a8d9e31aff33ccedf46ebc049331..d45d88260e4191e471f83aa255a7740fafd1012d 100644
>--- a/Source/JavaScriptCore/dfg/DFGClobberize.h
>+++ b/Source/JavaScriptCore/dfg/DFGClobberize.h
>@@ -263,6 +263,15 @@ void clobberize(Graph& graph, Node* node, const ReadFunctor& read, const WriteFu
>         def(PureValue(node, node->queriedType()));
>         return;
> 
>+    case ValueBitNot:
>+        if (node->child1().useKind() == BigIntUse) {
>+            def(PureValue(node));
>+            return;
>+        }
>+        read(World);
>+        write(Heap);
>+        return;
>+
>     case ArithBitNot:
>         if (node->child1().useKind() == UntypedUse) {
>             read(World);
>diff --git a/Source/JavaScriptCore/dfg/DFGDoesGC.cpp b/Source/JavaScriptCore/dfg/DFGDoesGC.cpp
>index 4f79af6c4cc5c1d9a9581e712441ad703994cb2d..a132ada4bce027a8ccb50be757b71264b0865141 100644
>--- a/Source/JavaScriptCore/dfg/DFGDoesGC.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGDoesGC.cpp
>@@ -100,6 +100,7 @@ bool doesGC(Graph& graph, Node* node)
>     case ValueBitAnd:
>     case ValueBitOr:
>     case ValueBitXor:
>+    case ValueBitNot:
>     case ValueAdd:
>     case ValueSub:
>     case ValueMul:
>diff --git a/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp b/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
>index 05112da4d6f5161403173eccd23dfc2f7091079b..92414f79ed7eb661fdc057321f280cef92fe925d 100644
>--- a/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
>@@ -235,14 +235,26 @@ private:
>             break;
>         }
> 
>-        case ArithBitNot: {
>-            if (node->child1().node()->shouldSpeculateUntypedForBitOps()) {
>-                fixEdge<UntypedUse>(node->child1());
>-                break;
>+        case ValueBitNot: {
>+            Edge& operandEdge = node->child1();
>+
>+            if (operandEdge.node()->shouldSpeculateBigInt())
>+                fixEdge<BigIntUse>(operandEdge);
>+            else if (operandEdge.node()->shouldSpeculateUntypedForBitOps())
>+                fixEdge<UntypedUse>(operandEdge);
>+            else {
>+                node->setOp(ArithBitNot);
>+                node->setResult(NodeResultInt32);
>+                node->clearFlags(NodeMustGenerate);
>+                fixIntConvertingEdge(operandEdge);
>             }
>+            break;
>+        }
> 
>-            fixIntConvertingEdge(node->child1());
>-            node->clearFlags(NodeMustGenerate);
>+        case ArithBitNot: {
>+            Edge& operandEdge = node->child1();
>+
>+            fixIntConvertingEdge(operandEdge);
>             break;
>         }
> 
>diff --git a/Source/JavaScriptCore/dfg/DFGNode.h b/Source/JavaScriptCore/dfg/DFGNode.h
>index 0faaab723033bdc7bf4aa90db17757e12323d082..ff90c7a4f2233a2144fbda802e8ae14c08860baf 100644
>--- a/Source/JavaScriptCore/dfg/DFGNode.h
>+++ b/Source/JavaScriptCore/dfg/DFGNode.h
>@@ -1698,6 +1698,7 @@ public:
>         case ValueBitAnd:
>         case ValueBitOr:
>         case ValueBitXor:
>+        case ValueBitNot:
>         case CallObjectConstructor:
>         case LoadKeyFromMapBucket:
>         case LoadValueFromMapBucket:
>diff --git a/Source/JavaScriptCore/dfg/DFGNodeType.h b/Source/JavaScriptCore/dfg/DFGNodeType.h
>index ded0e2680b8e82018c3d4868335b4d03e4ac8fd2..9cbe1625e975b063fe7cbeeb8dd792f6139b2fa2 100644
>--- a/Source/JavaScriptCore/dfg/DFGNodeType.h
>+++ b/Source/JavaScriptCore/dfg/DFGNodeType.h
>@@ -111,7 +111,8 @@ namespace JSC { namespace DFG {
>     macro(InvalidationPoint, NodeMustGenerate) \
>     \
>     /* Nodes for bitwise operations. */\
>-    macro(ArithBitNot, NodeResultInt32 | NodeMustGenerate) \
>+    macro(ValueBitNot, NodeResultJS | NodeMustGenerate) \
>+    macro(ArithBitNot, NodeResultInt32) \
>     macro(ValueBitAnd, NodeResultJS | NodeMustGenerate) \
>     macro(ArithBitAnd, NodeResultInt32) \
>     macro(ValueBitOr, NodeResultJS | NodeMustGenerate) \
>diff --git a/Source/JavaScriptCore/dfg/DFGOperations.cpp b/Source/JavaScriptCore/dfg/DFGOperations.cpp
>index dfced10bf264f41040c0d47e3854dcb0dc91c999..2195ab370c2bc766616ff6ebaaaf3f26d7d18b2c 100644
>--- a/Source/JavaScriptCore/dfg/DFGOperations.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGOperations.cpp
>@@ -362,10 +362,13 @@ EncodedJSValue JIT_OPERATION operationValueBitNot(ExecState* exec, EncodedJSValu
> 
>     JSValue op1 = JSValue::decode(encodedOp1);
> 
>-    int32_t operandValue = op1.toInt32(exec);
>+    auto operandNumeric = op1.toBigIntOrInt32(exec);
>     RETURN_IF_EXCEPTION(scope, encodedJSValue());
> 
>-    return JSValue::encode(jsNumber(~operandValue));
>+    if (WTF::holds_alternative<JSBigInt*>(operandNumeric))
>+        RELEASE_AND_RETURN(scope, JSValue::encode(JSBigInt::bitwiseNot(exec, WTF::get<JSBigInt*>(operandNumeric))));
>+
>+    return JSValue::encode(jsNumber(~WTF::get<int32_t>(operandNumeric)));
> }
> 
> EncodedJSValue JIT_OPERATION operationValueBitAnd(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
>@@ -383,11 +386,8 @@ EncodedJSValue JIT_OPERATION operationValueBitAnd(ExecState* exec, EncodedJSValu
>     RETURN_IF_EXCEPTION(scope, encodedJSValue());
> 
>     if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>-        if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>-            JSBigInt* result = JSBigInt::bitwiseAnd(exec, WTF::get<JSBigInt*>(leftNumeric), WTF::get<JSBigInt*>(rightNumeric));
>-            RETURN_IF_EXCEPTION(scope, encodedJSValue());
>-            return JSValue::encode(result);
>-        }
>+        if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric))
>+            RELEASE_AND_RETURN(scope, JSValue::encode(JSBigInt::bitwiseAnd(exec, WTF::get<JSBigInt*>(leftNumeric), WTF::get<JSBigInt*>(rightNumeric))));
> 
>         return throwVMTypeError(exec, scope, "Invalid mix of BigInt and other type in bitwise 'and' operation.");
>     }
>@@ -410,11 +410,8 @@ EncodedJSValue JIT_OPERATION operationValueBitOr(ExecState* exec, EncodedJSValue
>     RETURN_IF_EXCEPTION(scope, encodedJSValue());
> 
>     if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>-        if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>-            JSBigInt* result = JSBigInt::bitwiseOr(exec, WTF::get<JSBigInt*>(leftNumeric), WTF::get<JSBigInt*>(rightNumeric));
>-            RETURN_IF_EXCEPTION(scope, encodedJSValue());
>-            return JSValue::encode(result);
>-        }
>+        if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric))
>+            RELEASE_AND_RETURN(scope, JSValue::encode(JSBigInt::bitwiseOr(exec, WTF::get<JSBigInt*>(leftNumeric), WTF::get<JSBigInt*>(rightNumeric))));
> 
>         return throwVMTypeError(exec, scope, "Invalid mix of BigInt and other type in bitwise 'or' operation.");
>     }
>@@ -437,11 +434,8 @@ EncodedJSValue JIT_OPERATION operationValueBitXor(ExecState* exec, EncodedJSValu
>     RETURN_IF_EXCEPTION(scope, encodedJSValue());
> 
>     if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>-        if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>-            JSBigInt* result = JSBigInt::bitwiseXor(exec, WTF::get<JSBigInt*>(leftNumeric), WTF::get<JSBigInt*>(rightNumeric));
>-            RETURN_IF_EXCEPTION(scope, encodedJSValue());
>-            return JSValue::encode(result);
>-        }
>+        if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric))
>+            RELEASE_AND_RETURN(scope, JSValue::encode(JSBigInt::bitwiseXor(exec, WTF::get<JSBigInt*>(leftNumeric), WTF::get<JSBigInt*>(rightNumeric))));
> 
>         return throwVMTypeError(exec, scope, "Invalid mix of BigInt and other type in bitwise 'xor' operation.");
>     }
>@@ -529,9 +523,7 @@ EncodedJSValue JIT_OPERATION operationValueDiv(ExecState* exec, EncodedJSValue e
> 
>     if (WTF::holds_alternative<JSBigInt*>(leftNumeric) || WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>         if (WTF::holds_alternative<JSBigInt*>(leftNumeric) && WTF::holds_alternative<JSBigInt*>(rightNumeric)) {
>-            JSBigInt* result = JSBigInt::divide(exec, WTF::get<JSBigInt*>(leftNumeric), WTF::get<JSBigInt*>(rightNumeric));
>-            RETURN_IF_EXCEPTION(scope, encodedJSValue());
>-            return JSValue::encode(result);
>+            RELEASE_AND_RETURN(scope, JSValue::encode(JSBigInt::divide(exec, WTF::get<JSBigInt*>(leftNumeric), WTF::get<JSBigInt*>(rightNumeric))));
>         }
> 
>         return throwVMTypeError(exec, scope, "Invalid mix of BigInt and other type in division operation.");
>@@ -1343,6 +1335,16 @@ JSCell* JIT_OPERATION operationSubBigInt(ExecState* exec, JSCell* op1, JSCell* o
>     return JSBigInt::sub(exec, leftOperand, rightOperand);
> }
> 
>+JSCell* JIT_OPERATION operationBitNotBigInt(ExecState* exec, JSCell* op1)
>+{
>+    VM* vm = &exec->vm();
>+    NativeCallFrameTracer tracer(vm, exec);
>+
>+    JSBigInt* operand = jsCast<JSBigInt*>(op1);
>+
>+    return JSBigInt::bitwiseNot(exec, operand);
>+}
>+
> JSCell* JIT_OPERATION operationMulBigInt(ExecState* exec, JSCell* op1, JSCell* op2)
> {
>     VM* vm = &exec->vm();
>diff --git a/Source/JavaScriptCore/dfg/DFGOperations.h b/Source/JavaScriptCore/dfg/DFGOperations.h
>index 8b76f4d6bf37401de2c4a97c1c3205527cc63951..1f00ec061b1bcf3b4c74c61cbc22ad41a767635e 100644
>--- a/Source/JavaScriptCore/dfg/DFGOperations.h
>+++ b/Source/JavaScriptCore/dfg/DFGOperations.h
>@@ -170,6 +170,7 @@ JSCell* JIT_OPERATION operationSubBigInt(ExecState*, JSCell* op1, JSCell* op2) W
> JSCell* JIT_OPERATION operationMulBigInt(ExecState*, JSCell* op1, JSCell* op2) WTF_INTERNAL;
> JSCell* JIT_OPERATION operationDivBigInt(ExecState*, JSCell* op1, JSCell* op2) WTF_INTERNAL;
> JSCell* JIT_OPERATION operationBitAndBigInt(ExecState*, JSCell* op1, JSCell* op2) WTF_INTERNAL;
>+JSCell* JIT_OPERATION operationBitNotBigInt(ExecState*, JSCell* op1) WTF_INTERNAL;
> JSCell* JIT_OPERATION operationBitOrBigInt(ExecState*, JSCell* op1, JSCell* op2) WTF_INTERNAL;
> JSCell* JIT_OPERATION operationAddBigInt(ExecState*, JSCell* op1, JSCell* op2) WTF_INTERNAL;
> JSCell* JIT_OPERATION operationBitXorBigInt(ExecState*, JSCell* op1, JSCell* op2) WTF_INTERNAL;
>diff --git a/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp b/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp
>index b0d49e08539baafadd215df51c784938cddee2f4..2f25ddf47d5d4eecc55fc40a29c33f130280eec1 100644
>--- a/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp
>@@ -802,6 +802,7 @@ private:
>         case ValueBitAnd:
>         case ValueBitXor:
>         case ValueBitOr:
>+        case ValueBitNot:
>         case CallObjectConstructor:
>         case GetArgument:
>         case CallDOMGetter:
>diff --git a/Source/JavaScriptCore/dfg/DFGSafeToExecute.h b/Source/JavaScriptCore/dfg/DFGSafeToExecute.h
>index 48444a1409c49a188c5b0b926a27137824548909..34a5b8e13a74b60d443413bd1beab21ee7a73b15 100644
>--- a/Source/JavaScriptCore/dfg/DFGSafeToExecute.h
>+++ b/Source/JavaScriptCore/dfg/DFGSafeToExecute.h
>@@ -231,6 +231,7 @@ bool safeToExecute(AbstractStateType& state, Graph& graph, Node* node, bool igno
>     case ValueBitAnd:
>     case ValueBitXor:
>     case ValueBitOr:
>+    case ValueBitNot:
>     case ValueNegate:
>     case ValueAdd:
>     case ValueSub:
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>index 61269bc37971b21a11ef69de5365f7f7d99fd6ef..ff1a7bd52a4ddfc30b38c449a1bca821dc377feb 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>@@ -3510,24 +3510,43 @@ void SpeculativeJIT::compileInstanceOf(Node* node)
>     return;
> }
> 
>-void SpeculativeJIT::compileBitwiseNot(Node* node)
>+void SpeculativeJIT::compileValueBitNot(Node* node)
> {
>     Edge& child1 = node->child1();
> 
>-    if (child1.useKind() == UntypedUse) {
>-        JSValueOperand operand(this, child1);
>-        JSValueRegs operandRegs = operand.jsValueRegs();
>+    if (child1.useKind() == BigIntUse) {
>+        SpeculateCellOperand operand(this, child1);
>+        GPRReg operandGPR = operand.gpr();
>+
>+        speculateBigInt(child1, operandGPR);
> 
>         flushRegisters();
>-        JSValueRegsFlushedCallResult result(this);
>-        JSValueRegs resultRegs = result.regs();
>-        callOperation(operationValueBitNot, resultRegs, operandRegs);
>+        GPRFlushedCallResult result(this);
>+        GPRReg resultGPR = result.gpr();
>+
>+        callOperation(operationBitNotBigInt, resultGPR, operandGPR);
>         m_jit.exceptionCheck();
>+        cellResult(resultGPR, node);
> 
>-        jsValueResult(resultRegs, node);
>         return;
>     }
> 
>+    JSValueOperand operand(this, child1);
>+    JSValueRegs operandRegs = operand.jsValueRegs();
>+
>+    flushRegisters();
>+    JSValueRegsFlushedCallResult result(this);
>+    JSValueRegs resultRegs = result.regs();
>+    callOperation(operationValueBitNot, resultRegs, operandRegs);
>+    m_jit.exceptionCheck();
>+
>+    jsValueResult(resultRegs, node);
>+}
>+
>+void SpeculativeJIT::compileBitwiseNot(Node* node)
>+{
>+    Edge& child1 = node->child1();
>+
>     SpeculateInt32Operand operand(this, child1);
>     GPRTemporary result(this);
>     GPRReg resultGPR = result.gpr();
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
>index 28369106eb5fabf0e72d005a56c01fc2d06a5825..9df20a55e59518fe91184dc430b66793dc9f6141 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
>@@ -1330,6 +1330,7 @@ public:
>     void compileUInt32ToNumber(Node*);
>     void compileDoubleAsInt32(Node*);
> 
>+    void compileValueBitNot(Node*);
>     void compileBitwiseNot(Node*);
> 
>     template<typename SnippetGenerator, J_JITOperation_EJJ slowPathFunction>
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>index c299bccd61322c2ebbe8136447f34d15f6b97545..e07cd581d7a105836e7bdc527339ac6890f49599 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>@@ -1991,6 +1991,10 @@ void SpeculativeJIT::compile(Node* node)
>         compileBitwiseOp(node);
>         break;
> 
>+    case ValueBitNot:
>+        compileValueBitNot(node);
>+        break;
>+
>     case ArithBitNot:
>         compileBitwiseNot(node);
>         break;
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>index 32e08c99f465f006c19731bd2bb0a02b4c1488ba..2c4442ec422d43c060719d2a9e0331cdce2e97ea 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>@@ -2074,6 +2074,10 @@ void SpeculativeJIT::compile(Node* node)
>         recordSetLocal(dataFormatFor(node->variableAccessData()->flushFormat()));
>         break;
> 
>+    case ValueBitNot:
>+        compileValueBitNot(node);
>+        break;
>+
>     case ArithBitNot:
>         compileBitwiseNot(node);
>         break;
>diff --git a/Source/JavaScriptCore/ftl/FTLCapabilities.cpp b/Source/JavaScriptCore/ftl/FTLCapabilities.cpp
>index 7db5b56d326ddad666ec69cfa4d8d186d224ff4a..90b271a0e335682a2e4455303212680325b99e61 100644
>--- a/Source/JavaScriptCore/ftl/FTLCapabilities.cpp
>+++ b/Source/JavaScriptCore/ftl/FTLCapabilities.cpp
>@@ -91,6 +91,7 @@ inline CapabilityLevel canCompile(Node* node)
>     case ValueBitAnd:
>     case ValueBitXor:
>     case ValueBitOr:
>+    case ValueBitNot:
>     case ValueNegate:
>     case ValueAdd:
>     case ValueSub:
>diff --git a/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp b/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
>index 73836a8aad901e4324a7eea8e40e1ad9368d5137..79313df6d34c85d0ed403c88dbe7e8c56702828a 100644
>--- a/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
>+++ b/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
>@@ -659,6 +659,9 @@ private:
>         case ArithUnary:
>             compileArithUnary();
>             break;
>+        case ValueBitNot:
>+            compileValueBitNot();
>+            break;
>         case ArithBitNot:
>             compileArithBitNot();
>             break;
>@@ -2887,15 +2890,22 @@ private:
>         }
>     }
>     
>-    void compileArithBitNot()
>+    void compileValueBitNot()
>     {
>-        if (m_node->child1().useKind() == UntypedUse) {
>-            LValue operand = lowJSValue(m_node->child1());
>-            LValue result = vmCall(Int64, m_out.operation(operationValueBitNot), m_callFrame, operand);
>+        if (m_node->child1().useKind() == BigIntUse) {
>+            LValue operand = lowBigInt(m_node->child1());
>+            LValue result = vmCall(pointerType(), m_out.operation(operationBitNotBigInt), m_callFrame, operand);
>             setJSValue(result);
>             return;
>         }
> 
>+        LValue operand = lowJSValue(m_node->child1());
>+        LValue result = vmCall(Int64, m_out.operation(operationValueBitNot), m_callFrame, operand);
>+        setJSValue(result);
>+    }
>+
>+    void compileArithBitNot()
>+    {
>         setInt32(m_out.bitNot(lowInt32(m_node->child1())));
>     }
> 
>diff --git a/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp b/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
>index 3118b315a8cb8c5df2218d823381886cef582819..7aef09448a0e967cc50592af7fecb699384de0c2 100644
>--- a/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
>+++ b/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
>@@ -722,9 +722,16 @@ SLOW_PATH_DECL(slow_path_bitnot)
> {
>     BEGIN();
>     auto bytecode = pc->as<OpBitnot>();
>-    int32_t operand = GET_C(bytecode.operand).jsValue().toInt32(exec);
>+    auto operandNumeric = GET_C(bytecode.operand).jsValue().toBigIntOrInt32(exec);
>     CHECK_EXCEPTION();
>-    RETURN_PROFILED(jsNumber(~operand));
>+
>+    if (WTF::holds_alternative<JSBigInt*>(operandNumeric)) {
>+        JSBigInt* result = JSBigInt::bitwiseNot(exec, WTF::get<JSBigInt*>(operandNumeric));
>+        CHECK_EXCEPTION();
>+        RETURN_PROFILED(result);
>+    }
>+
>+    RETURN_PROFILED(jsNumber(~WTF::get<int32_t>(operandNumeric)));
> }
> 
> SLOW_PATH_DECL(slow_path_bitand)
>diff --git a/Source/JavaScriptCore/runtime/JSBigInt.cpp b/Source/JavaScriptCore/runtime/JSBigInt.cpp
>index ca531636b781e869ea78f76d25b5e4aead416185..6d6518c0d0b4f0e3798465b95dffe0b060d40342 100644
>--- a/Source/JavaScriptCore/runtime/JSBigInt.cpp
>+++ b/Source/JavaScriptCore/runtime/JSBigInt.cpp
>@@ -525,6 +525,16 @@ JSBigInt* JSBigInt::signedRightShift(ExecState* exec, JSBigInt* x, JSBigInt* y)
>     return rightShiftByAbsolute(exec, x, y);
> }
> 
>+JSBigInt* JSBigInt::bitwiseNot(ExecState* exec, JSBigInt* x)
>+{
>+    if (x->sign()) {
>+        // ~(-x) == ~(~(x-1)) == x-1
>+        return absoluteSubOne(exec, x, x->length());
>+    } 
>+    // ~x == -x-1 == -(x+1)
>+    return absoluteAddOne(exec, x, SignOption::Signed);
>+}
>+
> #if USE(JSVALUE32_64)
> #define HAVE_TWO_DIGIT 1
> typedef uint64_t TwoDigit;
>diff --git a/Source/JavaScriptCore/runtime/JSBigInt.h b/Source/JavaScriptCore/runtime/JSBigInt.h
>index 2b3bf9307d8dbbb1107533ed830347bcdd4a610b..8aa94427e35e821a8bf81b1df73da741793b37d3 100644
>--- a/Source/JavaScriptCore/runtime/JSBigInt.h
>+++ b/Source/JavaScriptCore/runtime/JSBigInt.h
>@@ -123,6 +123,7 @@ public:
>     static JSBigInt* bitwiseAnd(ExecState*, JSBigInt* x, JSBigInt* y);
>     static JSBigInt* bitwiseOr(ExecState*, JSBigInt* x, JSBigInt* y);
>     static JSBigInt* bitwiseXor(ExecState*, JSBigInt* x, JSBigInt* y);
>+    static JSBigInt* bitwiseNot(ExecState*, JSBigInt* x);
> 
>     static JSBigInt* leftShift(ExecState*, JSBigInt* x, JSBigInt* y);
>     static JSBigInt* signedRightShift(ExecState*, JSBigInt* x, JSBigInt* y);
>diff --git a/JSTests/ChangeLog b/JSTests/ChangeLog
>index 54c47fac29ba7b7ae6aee5dd2bee0be449b2e143..eab9e408361dd88f43f1a5c5e2483d400615aa2f 100644
>--- a/JSTests/ChangeLog
>+++ b/JSTests/ChangeLog
>@@ -1,3 +1,16 @@
>+2019-01-15  Caio Lima  <ticaiolima@gmail.com>
>+
>+        [ESNext][BigInt] Implement "~" unary operation
>+        https://bugs.webkit.org/show_bug.cgi?id=182216
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * stress/big-int-bit-not-general.js: Added.
>+        * stress/big-int-bitwise-not-jit.js: Added.
>+        * stress/big-int-bitwise-not-wrapped-value.js: Added.
>+        * stress/bit-op-with-object-returning-int32.js:
>+        * stress/bitwise-not-fixup-rules.js: Added.
>+
> 2019-01-15  Tomas Popela  <tpopela@redhat.com>
> 
>         Unreviewed, skip JIT tests if it's not enabled
>diff --git a/JSTests/stress/big-int-bit-not-general.js b/JSTests/stress/big-int-bit-not-general.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..07eb056479a8588ce8fdb0497ba31d9273c37609
>--- /dev/null
>+++ b/JSTests/stress/big-int-bit-not-general.js
>@@ -0,0 +1,39 @@
>+//@ runBigIntEnabled
>+
>+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
>+// This code is governed by the BSD license found in the LICENSE file.
>+
>+function assert(a) {
>+    if (!a)
>+        throw new Error("Bad assertion");
>+}
>+
>+assert.sameValue = function (input, expected, message) {
>+    if (input !== expected)
>+        throw new Error(message);
>+}
>+
>+assert.sameValue(~0n, -1n, "~0n === -1n");
>+assert.sameValue(~(0n), -1n, "~(0n) === -1n");
>+assert.sameValue(~1n, -2n, "~1n === -2n");
>+assert.sameValue(~-1n, 0n, "~-1n === 0n");
>+assert.sameValue(~(-1n), 0n, "~(-1n) === 0n");
>+assert.sameValue(~~1n, 1n, "~~1n === 1n");
>+assert.sameValue(~0x5an, -0x5bn, "~0x5an === -0x5bn");
>+assert.sameValue(~-0x5an, 0x59n, "~-0x5an === 0x59n");
>+assert.sameValue(~0xffn, -0x100n, "~0xffn === -0x100n");
>+assert.sameValue(~-0xffn, 0xfen, "~-0xffn === 0xfen");
>+assert.sameValue(~0xffffn, -0x10000n, "~0xffffn === -0x10000n");
>+assert.sameValue(~-0xffffn, 0xfffen, "~-0xffffn === 0xfffen");
>+assert.sameValue(~0xffffffffn, -0x100000000n, "~0xffffffffn === -0x100000000n");
>+assert.sameValue(~-0xffffffffn, 0xfffffffen, "~-0xffffffffn === 0xfffffffen");
>+assert.sameValue(
>+  ~0xffffffffffffffffn, -0x10000000000000000n,
>+  "~0xffffffffffffffffn === -0x10000000000000000n");
>+assert.sameValue(
>+  ~-0xffffffffffffffffn, 0xfffffffffffffffen,
>+  "~-0xffffffffffffffffn === 0xfffffffffffffffen");
>+assert.sameValue(
>+  ~0x123456789abcdef0fedcba9876543210n, -0x123456789abcdef0fedcba9876543211n,
>+  "~0x123456789abcdef0fedcba9876543210n === -0x123456789abcdef0fedcba9876543211n");
>+
>diff --git a/JSTests/stress/big-int-bitwise-not-jit.js b/JSTests/stress/big-int-bitwise-not-jit.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..d761e1f75976a54cacdc0de2d205c19b7183b5f3
>--- /dev/null
>+++ b/JSTests/stress/big-int-bitwise-not-jit.js
>@@ -0,0 +1,19 @@
>+//@ runBigIntEnabled
>+
>+let assert = {
>+    sameValue: function(i, e, m) {
>+        if (i !== e)
>+            throw new Error(m);
>+    }
>+}
>+
>+function bigIntBitNot(a) {
>+    return ~(~a);
>+}
>+noInline(bigIntBitNot);
>+
>+for (let i = 0; i < 10000; i++) {
>+    let r = bigIntBitNot(3n);
>+    assert.sameValue(r, 3n, "~~" + 3n + " = " + r);
>+}
>+
>diff --git a/JSTests/stress/big-int-bitwise-not-wrapped-value.js b/JSTests/stress/big-int-bitwise-not-wrapped-value.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..7f4a5dfe56a069853052ebc0bee792d9629a946b
>--- /dev/null
>+++ b/JSTests/stress/big-int-bitwise-not-wrapped-value.js
>@@ -0,0 +1,59 @@
>+//@ runBigIntEnabled
>+
>+assert = {
>+    sameValue: function (input, expected, message) {
>+        if (input !== expected)
>+            throw new Error(message);
>+    }
>+};
>+
>+function testBitNot(x, z, message) {
>+    assert.sameValue(~x, z, message);
>+}
>+
>+testBitNot(Object(1n), -2n, "ToPrimitive: unbox object with internal slot");
>+
>+let o = {
>+    [Symbol.toPrimitive]: function() {
>+        return 1n;
>+    }
>+};
>+testBitNot(o, -2n, "ToPrimitive: @@toPrimitive");
>+
>+o = {
>+    valueOf: function() {
>+        return 1n;
>+    }
>+};
>+testBitNot(o, -2n, "ToPrimitive: valueOf");
>+
>+o = {
>+    toString: function() {
>+        return 1n;
>+    }
>+}
>+testBitNot(o, -2n, "ToPrimitive: toString");
>+
>+// Test priority
>+
>+function badAssertion() {
>+    throw new Error("This should never be called");
>+}
>+
>+o = {
>+    [Symbol.toPrimitive]: function() {
>+        return 1n;
>+    },
>+    valueOf: badAssertion,
>+    toString: badAssertion
>+};
>+testBitNot(o, -2n, "ToPrimitive: @@toPrimitive and others throw");
>+
>+o = {
>+    valueOf: function() {
>+        return 1n;
>+    },
>+    toString: badAssertion
>+};
>+testBitNot(o, -2n, "ToPrimitive: valueOf and toString throws");
>+
>diff --git a/JSTests/stress/bit-op-with-object-returning-int32.js b/JSTests/stress/bit-op-with-object-returning-int32.js
>index 7e9134498e9b751c1dbad26b157e04a520c67274..1749afbc50a4f47a93cfc6e66e5729761c24bb27 100644
>--- a/JSTests/stress/bit-op-with-object-returning-int32.js
>+++ b/JSTests/stress/bit-op-with-object-returning-int32.js
>@@ -36,3 +36,13 @@ for (var i = 0; i < 10000; i++)
> 
> assert(numberOfDFGCompiles(bitXor) <= 1, true);
> 
>+function bitNot(a) {
>+    return ~a;
>+}
>+noInline(bitNot);
>+
>+for (var i = 0; i < 10000; i++)
>+    assert(bitNot(o), -14);
>+
>+assert(numberOfDFGCompiles(bitNot) <= 1, true);
>+
>diff --git a/JSTests/stress/bitwise-not-fixup-rules.js b/JSTests/stress/bitwise-not-fixup-rules.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..ead2ce24b0b5888df1ddd575f70100ed812e8a8c
>--- /dev/null
>+++ b/JSTests/stress/bitwise-not-fixup-rules.js
>@@ -0,0 +1,27 @@
>+//@ if $jitTests then runBigIntEnabled else skip end
>+
>+function assert(a, e) {
>+    if (a !== e)
>+        throw new Error("Expected to be: " + e + " but got: " + a);
>+}
>+
>+function foo(a) {
>+    return ~a;
>+}
>+noInline(foo);
>+
>+let c = 0;
>+let o = {
>+    valueOf: () => {
>+        c++;
>+        return 3;
>+    }
>+};
>+
>+for (let i = 0; i < 10000; i++)
>+    foo(o);
>+
>+assert(c, 10000);
>+if (numberOfDFGCompiles(foo) > 1)
>+    throw new Error("Function 'foo' should be compiled just once");
>+
>diff --git a/PerformanceTests/BigIntBench/big-int-simple-bit-not.js b/PerformanceTests/BigIntBench/big-int-simple-bit-not.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..488a70d4f74038a1eaad5aab0d744cb431137f19
>--- /dev/null
>+++ b/PerformanceTests/BigIntBench/big-int-simple-bit-not.js
>@@ -0,0 +1,15 @@
>+function bigInt(a, b) {
>+    let c = ~a;
>+    return ~a + ~c;
>+}
>+noInline(bigInt);
>+
>+for (let i = 0; i < 100000; i++) {
>+    bigInt(0b1111n, 0b1010n);
>+}
>+
>+let out;
>+for (let i = 0; i < 100000; i++) {
>+    out = bigInt(0xffffffffffffffffffn, 0xaaffffffffffffffffffn);
>+}
>+
>diff --git a/PerformanceTests/ChangeLog b/PerformanceTests/ChangeLog
>index e3244041bc49a8815d701b362cb647c454178d54..92fdd2eb512c60ba29e0159483fb3dbf1e84ea88 100644
>--- a/PerformanceTests/ChangeLog
>+++ b/PerformanceTests/ChangeLog
>@@ -1,3 +1,12 @@
>+2019-01-15  Caio Lima  <ticaiolima@gmail.com>
>+
>+        [ESNext][BigInt] Implement "~" unary operation
>+        https://bugs.webkit.org/show_bug.cgi?id=182216
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * BigIntBench/big-int-simple-bit-not.js: Added.
>+
> 2018-12-20  Caio Lima  <ticaiolima@gmail.com>
> 
>         [BigInt] We should enable CSE into arithmetic operations that speculate BigIntUse

Actions: View | Formatted Diff | Diff

Attachments on bug 182216: 356382 | 356489 | 356498 | 357224 | 357227 | 358064 | 359198 | 359235 | 359236 | 359885 | 359890 | 359898 | 360006 | 360007 | 360931 | 362250 | 363089 | 363878 | 364004