Attachment 356489 Details for Bug 182216 – WIP - Patch

[patch] WIP - Patch

bug-182216-20181204115357.patch (text/plain), 25.92 KB, created by Caio Lima on 2018-12-04 05:53:59 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Caio Lima

Created: 2018-12-04 05:53:59 PST

Size: 25.92 KB

patch

obsolete

>Subversion Revision: 238790
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 2ffd408d275ac8fc84e4cb34fa1520b269dde80b..14f668d467f1544d4dbad90f8654b717ce9426ed 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,52 @@
>+2018-12-04  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/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/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:
>+
> 2018-12-02  Caio Lima  <ticaiolima@gmail.com>
> 
>         [ESNext][BigInt] Implement support for "<<" and ">>"
>diff --git a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>index 25144b5b14240c7db2ce8716b79b9bfac38b547e..8285359953420ac1758ecac872ae2b00857c8409 100644
>--- a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>+++ b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
>@@ -375,13 +375,24 @@ 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();
>+            setConstant(node, JSValue(~a));
>             break;
>         }
> 
>+        clobberWorld();
>+        if (node->child1().useKind() == BigIntUse)
>+            setTypeForNode(node, SpecBigInt);
>+        else
>+            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/DFGByteCodeParser.cpp b/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
>index 71fc92b19449ab2f7f7c4120f832ca2e2856ba76..ac757dbb656b2bf777230952069b4abfed7b1634 100644
>--- a/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
>@@ -4895,7 +4895,10 @@ void ByteCodeParser::parseBlock(unsigned limit)
>         case op_bitnot: {
>             auto bytecode = currentInstruction->as<OpBitnot>();
>             Node* op1 = get(bytecode.operand);
>-            set(bytecode.dst, addToGraph(ArithBitNot, op1));
>+            if (isInt32Speculation(getPrediction()))
>+                set(bytecode.dst, addToGraph(ArithBitNot, op1));
>+            else
>+                set(bytecode.dst, addToGraph(ValueBitNot, op1));
>             NEXT_OPCODE(op_bitnot);
>         }
> 
>diff --git a/Source/JavaScriptCore/dfg/DFGClobberize.h b/Source/JavaScriptCore/dfg/DFGClobberize.h
>index 788eecc3c3bad1d915ba857f63a7578256705a0c..138fc5f36a999537d40783c240c993340d1751bf 100644
>--- a/Source/JavaScriptCore/dfg/DFGClobberize.h
>+++ b/Source/JavaScriptCore/dfg/DFGClobberize.h
>@@ -647,6 +647,7 @@ void clobberize(Graph& graph, Node* node, const ReadFunctor& read, const WriteFu
>     case ValueBitAnd:
>     case ValueBitXor:
>     case ValueBitOr:
>+    case ValueBitNot:
>     case ValueNegate:
>     case ValueAdd:
>     case ValueSub:
>diff --git a/Source/JavaScriptCore/dfg/DFGDoesGC.cpp b/Source/JavaScriptCore/dfg/DFGDoesGC.cpp
>index 6aa263cfa2a40a973ea229d83fa4215b9decabd1..4710f900c4546a39f80caf67793793275075e72f 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 ValueNegate:
>diff --git a/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp b/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
>index 964e5bc65998d14c5bfdfb9edf0de6dfeb7ce9b8..58e8af7d1e06776bfd016cddc9202b75603bb724 100644
>--- a/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
>@@ -144,14 +144,26 @@ private:
>             break;
>         }
> 
>+        case ValueBitNot: {
>+            Edge& operandEdge = node->child1();
>+
>+            if (operandEdge.node()->shouldSpeculateBigInt())
>+                fixEdge<BigIntUse>(operandEdge);
>+            else
>+                fixEdge<UntypedUse>(operandEdge);
>+            break;
>+        }
>+
>         case ArithBitNot: {
>-            if (node->child1().node()->shouldSpeculateUntypedForBitOps()) {
>-                fixEdge<UntypedUse>(node->child1());
>+            Edge& operandEdge = node->child1();
>+
>+            if (operandEdge.node()->shouldSpeculateUntypedForBitOps()) {
>+                fixEdge<UntypedUse>(operandEdge);
>+                node->setOpAndDefaultFlags(ValueBitNot);
>                 break;
>             }
> 
>-            fixIntConvertingEdge(node->child1());
>-            node->clearFlags(NodeMustGenerate);
>+            fixIntConvertingEdge(operandEdge);
>             break;
>         }
> 
>diff --git a/Source/JavaScriptCore/dfg/DFGNodeType.h b/Source/JavaScriptCore/dfg/DFGNodeType.h
>index 509fcc9043a695d8f9f907f6490a53aab6c1b36f..7aff6caa7f2d7abfb95613b9461f70b8058ff42e 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 3f1f494a56a300105024a00d278fdd3cad2e27bf..d61130cef7628595ef58573b4b0715d4a51162b1 100644
>--- a/Source/JavaScriptCore/dfg/DFGOperations.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGOperations.cpp
>@@ -341,10 +341,16 @@ 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)) {
>+        JSBigInt* result = JSBigInt::bitwiseNot(exec, WTF::get<JSBigInt*>(operandNumeric));
>+        RETURN_IF_EXCEPTION(scope, encodedJSValue());
>+        return JSValue::encode(result);
>+    }
>+
>+    return JSValue::encode(jsNumber(~WTF::get<int32_t>(operandNumeric)));
> }
> 
> EncodedJSValue JIT_OPERATION operationValueBitAnd(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
>@@ -1322,6 +1328,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 operationBitAndBigInt(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 512ac11153c8ff522cf62671551b9968df40c44e..c3c7b6b28b8b3d91ca6cf60000199385e53a5bee 100644
>--- a/Source/JavaScriptCore/dfg/DFGOperations.h
>+++ b/Source/JavaScriptCore/dfg/DFGOperations.h
>@@ -166,6 +166,7 @@ size_t JIT_OPERATION operationRegExpTestGeneric(ExecState*, JSGlobalObject*, Enc
> size_t JIT_OPERATION operationCompareStrictEqCell(ExecState*, JSCell* op1, JSCell* op2) WTF_INTERNAL;
> JSCell* JIT_OPERATION operationSubBigInt(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 f8209fb048c0bcc1ea0cb23c2c1556e6f09a9283..4d1971473caf0b73a038759f40fd4455986d1cec 100644
>--- a/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp
>@@ -277,6 +277,12 @@ private:
>             break;
>         }
> 
>+        case ValueBitNot: {
>+            if (node->child1()->shouldSpeculateBigInt())
>+                changed |= mergePrediction(SpecBigInt);
>+            break;
>+        }
>+
>         case ValueBitXor:
>         case ValueBitOr:
>         case ValueBitAnd: {
>@@ -1098,6 +1104,7 @@ private:
>         case ValueBitOr:
>         case ValueBitAnd:
>         case ValueBitXor:
>+        case ValueBitNot:
>         case ValueNegate:
>         case ValueAdd:
>         case ValueSub:
>diff --git a/Source/JavaScriptCore/dfg/DFGSafeToExecute.h b/Source/JavaScriptCore/dfg/DFGSafeToExecute.h
>index b43b7dfda9e779fd222eec3ef505d06fbd992d0e..538800e3ae67f9abb557373a22ade890079a58b8 100644
>--- a/Source/JavaScriptCore/dfg/DFGSafeToExecute.h
>+++ b/Source/JavaScriptCore/dfg/DFGSafeToExecute.h
>@@ -230,6 +230,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 2cda06dd6e37771551ddeacc161c9f25e7375893..2377de55ec21be33ff6ba3aee4541adb33b755c8 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 adb3ba1c8e17c0a435c772f0fb40c3837074571f..4fadf8e7f01fea02e8316f27bf22c9563c274a11 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
>@@ -1329,6 +1329,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 ce3e26635248959b19df566c8ee125838d758d5a..3c72e56fe4365f5eeb5adbcc7e4a87a337e3ee96 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 fb161a72b54074f15abadbfc755356d20380558e..c40acbd87af027c0351d40efadf5faa3af88bccf 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 da113812e17e1d0b044ad28c86ab8f8e74b78b9f..e49ef8f2d46c43c656caf421d03a64f2e5f06fae 100644
>--- a/Source/JavaScriptCore/ftl/FTLCapabilities.cpp
>+++ b/Source/JavaScriptCore/ftl/FTLCapabilities.cpp
>@@ -90,6 +90,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 c254892721f547271d730b1eb9fad203d46551de..86ef893c638913a1151e10e08941c25693784b62 100644
>--- a/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
>+++ b/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
>@@ -653,6 +653,9 @@ private:
>         case ArithUnary:
>             compileArithUnary();
>             break;
>+        case ValueBitNot:
>+            compileValueBitNot();
>+            break;
>         case ArithBitNot:
>             compileArithBitNot();
>             break;
>@@ -2851,15 +2854,23 @@ private:
>         }
>     }
>     
>-    void compileArithBitNot()
>+    void compileValueBitNot()
>     {
>-        if (m_node->child1().useKind() == UntypedUse) {
>-            LValue operand = lowJSValue(m_node->child1());
>-            LValue result = vmCall(pointerType(), m_out.operation(operationValueBitNot), m_callFrame, operand);
>+        if (m_node->child1().useKind() == BigIntUse) {
>+            LValue operand = lowBigInt(m_node->child1());
>+            
>+            LValue result = vmCall(Int64, 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 2dfeaa5e6007e028605a18bf682dc79a9d5db4b6..dfaf1b3e73831d46f8e6f6b94382a3492f36f957 100644
>--- a/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
>+++ b/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
>@@ -720,9 +720,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 2f25a2411edf1e4713a87f000aa12917ff47a83f..344cc1e86e23d63f4d74f3b808062210723a586d 100644
>--- a/Source/JavaScriptCore/runtime/JSBigInt.cpp
>+++ b/Source/JavaScriptCore/runtime/JSBigInt.cpp
>@@ -532,6 +532,21 @@ JSBigInt* JSBigInt::signedRightShift(ExecState* exec, JSBigInt* x, JSBigInt* y)
>     return rightShiftByAbsolute(exec, x, y);
> }
> 
>+JSBigInt* JSBigInt::bitwiseNot(ExecState* exec, JSBigInt* x)
>+{
>+    VM& vm = exec->vm();
>+    JSBigInt* result = nullptr;
>+    if (x->sign()) {
>+        // ~(-x) == ~(~(x-1)) == x-1
>+        result = absoluteSubOne(exec, x, x->length());
>+    } else {
>+        // ~x == -x-1 == -(x+1)
>+        result = absoluteAddOne(exec, x, SignOption::Signed);
>+    }
>+
>+    return result->rightTrim(vm);
>+}
>+
> #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 4e708de956893ef1c13da13d1639b149e9af5e02..bb191c57595121e909efca14e26b8be8115b1040 100644
>--- a/Source/JavaScriptCore/runtime/JSBigInt.h
>+++ b/Source/JavaScriptCore/runtime/JSBigInt.h
>@@ -118,6 +118,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 ab5f795342c039803eaff3f2260df7043514382f..215df6adb68d559b5e8ac4750550b3c808c64b0b 100644
>--- a/JSTests/ChangeLog
>+++ b/JSTests/ChangeLog
>@@ -1,3 +1,15 @@
>+2018-12-04  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/bitwise-not-fixup-rules.js: Added.
>+
> 2018-12-02  Caio Lima  <ticaiolima@gmail.com>
> 
>         [ESNext][BigInt] Implement support for "<<" and ">>"
>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..1bc571bd029a6040a0278f5b1b9aa6a2fd5f30e3
>--- /dev/null
>+++ b/JSTests/stress/big-int-bitwise-not-wrapped-value.js
>@@ -0,0 +1,36 @@
>+//@ 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");
>+
>diff --git a/JSTests/stress/bitwise-not-fixup-rules.js b/JSTests/stress/bitwise-not-fixup-rules.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..62be62a4ea70397a72b0def6241cf201ee9c277e
>--- /dev/null
>+++ b/JSTests/stress/bitwise-not-fixup-rules.js
>@@ -0,0 +1,27 @@
>+//@ runBigIntEnabled
>+
>+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 5d89525740e97c16feb154087968a42952d1a14c..420324f75a102fc6ae879343bed032aac8bb2266 100644
>--- a/PerformanceTests/ChangeLog
>+++ b/PerformanceTests/ChangeLog
>@@ -1,3 +1,13 @@
>+2018-12-04  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.
>+        (bigInt):
>+
> 2018-11-07  Caio Lima  <ticaiolima@gmail.com>
> 
>         [BigInt] Add support to BigInt into ValueAdd

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