Attachment 339291 Details for Bug 185189 – Patch

[patch] Patch

bug-185189-20180502174757.patch (text/plain), 13.79 KB, created by Yusuke Suzuki on 2018-05-02 01:47:58 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Yusuke Suzuki

Created: 2018-05-02 01:47:58 PDT

Size: 13.79 KB

patch

obsolete

>Subversion Revision: 231226
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 4a1162741a4ea0721993ac2a4fcb300b9910b63e..f40659b132bea5b958913ce04bf55b500faa15cc 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,26 @@
>+2018-05-02  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        [DFG] Unify compare related code in 32bit and 64bit
>+        https://bugs.webkit.org/show_bug.cgi?id=185189
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch unifies some part of compare related code in 32bit and 64bit
>+        to reduce the size of 32bit specific DFG code.
>+
>+        * dfg/DFGSpeculativeJIT.cpp:
>+        (JSC::DFG::SpeculativeJIT::compileInt32Compare):
>+        (JSC::DFG::SpeculativeJIT::compileDoubleCompare):
>+        (JSC::DFG::SpeculativeJIT::compileObjectEquality):
>+        * dfg/DFGSpeculativeJIT32_64.cpp:
>+        (JSC::DFG::SpeculativeJIT::compileObjectEquality): Deleted.
>+        (JSC::DFG::SpeculativeJIT::compileInt32Compare): Deleted.
>+        (JSC::DFG::SpeculativeJIT::compileDoubleCompare): Deleted.
>+        * dfg/DFGSpeculativeJIT64.cpp:
>+        (JSC::DFG::SpeculativeJIT::compileObjectEquality): Deleted.
>+        (JSC::DFG::SpeculativeJIT::compileInt32Compare): Deleted.
>+        (JSC::DFG::SpeculativeJIT::compileDoubleCompare): Deleted.
>+
> 2018-05-01  Yusuke Suzuki  <utatane.tea@gmail.com>
> 
>         [JSC] Add SameValue DFG node
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>index 81cbbe6911d5899cd7e4518d0111d781c185455c..735b629b264dd852f61ebbfe425adb7606a6a2da 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>@@ -6069,6 +6069,84 @@ void SpeculativeJIT::compileBooleanCompare(Node* node, MacroAssembler::Relationa
>     unblessedBooleanResult(result.gpr(), node);
> }
> 
>+void SpeculativeJIT::compileInt32Compare(Node* node, MacroAssembler::RelationalCondition condition)
>+{
>+    if (node->child1()->isInt32Constant()) {
>+        SpeculateInt32Operand op2(this, node->child2());
>+        GPRTemporary result(this, Reuse, op2);
>+        int32_t imm = node->child1()->asInt32();
>+        m_jit.compare32(condition, JITCompiler::Imm32(imm), op2.gpr(), result.gpr());
>+
>+        unblessedBooleanResult(result.gpr(), node);
>+    } else if (node->child2()->isInt32Constant()) {
>+        SpeculateInt32Operand op1(this, node->child1());
>+        GPRTemporary result(this, Reuse, op1);
>+        int32_t imm = node->child2()->asInt32();
>+        m_jit.compare32(condition, op1.gpr(), JITCompiler::Imm32(imm), result.gpr());
>+
>+        unblessedBooleanResult(result.gpr(), node);
>+    } else {
>+        SpeculateInt32Operand op1(this, node->child1());
>+        SpeculateInt32Operand op2(this, node->child2());
>+        GPRTemporary result(this, Reuse, op1, op2);
>+        m_jit.compare32(condition, op1.gpr(), op2.gpr(), result.gpr());
>+
>+        unblessedBooleanResult(result.gpr(), node);
>+    }
>+}
>+
>+void SpeculativeJIT::compileDoubleCompare(Node* node, MacroAssembler::DoubleCondition condition)
>+{
>+    SpeculateDoubleOperand op1(this, node->child1());
>+    SpeculateDoubleOperand op2(this, node->child2());
>+    GPRTemporary result(this);
>+
>+    FPRReg op1FPR = op1.fpr();
>+    FPRReg op2FPR = op2.fpr();
>+    GPRReg resultGPR = result.gpr();
>+
>+    m_jit.compareDouble(condition, op1FPR, op2FPR, resultGPR);
>+
>+    unblessedBooleanResult(resultGPR, node);
>+}
>+
>+void SpeculativeJIT::compileObjectEquality(Node* node)
>+{
>+    SpeculateCellOperand op1(this, node->child1());
>+    SpeculateCellOperand op2(this, node->child2());
>+    GPRTemporary result(this, Reuse, op1);
>+
>+    GPRReg op1GPR = op1.gpr();
>+    GPRReg op2GPR = op2.gpr();
>+    GPRReg resultGPR = result.gpr();
>+
>+    if (masqueradesAsUndefinedWatchpointIsStillValid()) {
>+        DFG_TYPE_CHECK(
>+            JSValueSource::unboxedCell(op1GPR), node->child1(), SpecObject, m_jit.branchIfNotObject(op1GPR));
>+        DFG_TYPE_CHECK(
>+            JSValueSource::unboxedCell(op2GPR), node->child2(), SpecObject, m_jit.branchIfNotObject(op2GPR));
>+    } else {
>+        DFG_TYPE_CHECK(
>+            JSValueSource::unboxedCell(op1GPR), node->child1(), SpecObject, m_jit.branchIfNotObject(op1GPR));
>+        speculationCheck(BadType, JSValueSource::unboxedCell(op1GPR), node->child1(),
>+            m_jit.branchTest8(
>+                MacroAssembler::NonZero,
>+                MacroAssembler::Address(op1GPR, JSCell::typeInfoFlagsOffset()),
>+                MacroAssembler::TrustedImm32(MasqueradesAsUndefined)));
>+
>+        DFG_TYPE_CHECK(
>+            JSValueSource::unboxedCell(op2GPR), node->child2(), SpecObject, m_jit.branchIfNotObject(op2GPR));
>+        speculationCheck(BadType, JSValueSource::unboxedCell(op2GPR), node->child2(),
>+            m_jit.branchTest8(
>+                MacroAssembler::NonZero,
>+                MacroAssembler::Address(op2GPR, JSCell::typeInfoFlagsOffset()),
>+                MacroAssembler::TrustedImm32(MasqueradesAsUndefined)));
>+    }
>+
>+    m_jit.comparePtr(MacroAssembler::Equal, op1GPR, op2GPR, resultGPR);
>+    unblessedBooleanResult(resultGPR, node);
>+}
>+
> void SpeculativeJIT::compileSymbolEquality(Node* node)
> {
>     SpeculateCellOperand left(this, node->child1());
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>index 3d39621335a7535e144c705d2f688a439fb6a5e8..962bd20ed839ea5623e1fda0cb21b389ab1f2674 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
>@@ -1222,49 +1222,6 @@ GPRReg SpeculativeJIT::fillSpeculateBoolean(Edge edge)
>     }
> }
> 
>-void SpeculativeJIT::compileObjectEquality(Node* node)
>-{
>-    SpeculateCellOperand op1(this, node->child1());
>-    SpeculateCellOperand op2(this, node->child2());
>-    GPRReg op1GPR = op1.gpr();
>-    GPRReg op2GPR = op2.gpr();
>-    
>-    if (masqueradesAsUndefinedWatchpointIsStillValid()) {
>-        DFG_TYPE_CHECK(
>-            JSValueSource::unboxedCell(op1GPR), node->child1(), SpecObject, m_jit.branchIfNotObject(op1GPR));
>-        DFG_TYPE_CHECK(
>-            JSValueSource::unboxedCell(op2GPR), node->child2(), SpecObject, m_jit.branchIfNotObject(op2GPR));
>-    } else {
>-        DFG_TYPE_CHECK(
>-            JSValueSource::unboxedCell(op1GPR), node->child1(), SpecObject, m_jit.branchIfNotObject(op1GPR));
>-        speculationCheck(BadType, JSValueSource::unboxedCell(op1GPR), node->child1(),
>-            m_jit.branchTest8(
>-                MacroAssembler::NonZero, 
>-                MacroAssembler::Address(op1GPR, JSCell::typeInfoFlagsOffset()),
>-                MacroAssembler::TrustedImm32(MasqueradesAsUndefined)));
>-
>-        DFG_TYPE_CHECK(
>-            JSValueSource::unboxedCell(op2GPR), node->child2(), SpecObject, m_jit.branchIfNotObject(op2GPR));
>-        speculationCheck(BadType, JSValueSource::unboxedCell(op2GPR), node->child2(),
>-            m_jit.branchTest8(
>-                MacroAssembler::NonZero,
>-                MacroAssembler::Address(op2GPR, JSCell::typeInfoFlagsOffset()),
>-                MacroAssembler::TrustedImm32(MasqueradesAsUndefined)));
>-    }
>-    
>-    GPRTemporary resultPayload(this, Reuse, op2);
>-    GPRReg resultPayloadGPR = resultPayload.gpr();
>-    
>-    MacroAssembler::Jump falseCase = m_jit.branchPtr(MacroAssembler::NotEqual, op1GPR, op2GPR);
>-    m_jit.move(TrustedImm32(1), resultPayloadGPR);
>-    MacroAssembler::Jump done = m_jit.jump();
>-    falseCase.link(&m_jit);
>-    m_jit.move(TrustedImm32(0), resultPayloadGPR);
>-    done.link(&m_jit);
>-
>-    booleanResult(resultPayloadGPR, node);
>-}
>-
> void SpeculativeJIT::compileObjectStrictEquality(Edge objectChild, Edge otherChild)
> {
>     SpeculateCellOperand op1(this, objectChild);
>@@ -1494,32 +1451,6 @@ void SpeculativeJIT::compileSymbolUntypedEquality(Node* node, Edge symbolEdge, E
>     booleanResult(resultPayloadGPR, node);
> }
> 
>-void SpeculativeJIT::compileInt32Compare(Node* node, MacroAssembler::RelationalCondition condition)
>-{
>-    SpeculateInt32Operand op1(this, node->child1());
>-    SpeculateInt32Operand op2(this, node->child2());
>-    GPRTemporary resultPayload(this);
>-    
>-    m_jit.compare32(condition, op1.gpr(), op2.gpr(), resultPayload.gpr());
>-    
>-    // If we add a DataFormatBool, we should use it here.
>-    booleanResult(resultPayload.gpr(), node);
>-}
>-
>-void SpeculativeJIT::compileDoubleCompare(Node* node, MacroAssembler::DoubleCondition condition)
>-{
>-    SpeculateDoubleOperand op1(this, node->child1());
>-    SpeculateDoubleOperand op2(this, node->child2());
>-    GPRTemporary resultPayload(this);
>-    
>-    m_jit.move(TrustedImm32(1), resultPayload.gpr());
>-    MacroAssembler::Jump trueCase = m_jit.branchDouble(condition, op1.fpr(), op2.fpr());
>-    m_jit.move(TrustedImm32(0), resultPayload.gpr());
>-    trueCase.link(&m_jit);
>-    
>-    booleanResult(resultPayload.gpr(), node);
>-}
>-
> void SpeculativeJIT::compileObjectOrOtherLogicalNot(Edge nodeUse)
> {
>     JSValueOperand value(this, nodeUse, ManualOperandSpeculation);
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>index ccc3cada01e3218d5a4eac9cfdb4a69d260aa3f3..32c6c22208b2f0657fea14f9f8c50c415fab861e 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
>@@ -1324,44 +1324,6 @@ GPRReg SpeculativeJIT::fillSpeculateBoolean(Edge edge)
>     }
> }
> 
>-void SpeculativeJIT::compileObjectEquality(Node* node)
>-{
>-    SpeculateCellOperand op1(this, node->child1());
>-    SpeculateCellOperand op2(this, node->child2());
>-    GPRTemporary result(this, Reuse, op1);
>-    
>-    GPRReg op1GPR = op1.gpr();
>-    GPRReg op2GPR = op2.gpr();
>-    GPRReg resultGPR = result.gpr();
>-   
>-    if (masqueradesAsUndefinedWatchpointIsStillValid()) {
>-        DFG_TYPE_CHECK(
>-            JSValueSource::unboxedCell(op1GPR), node->child1(), SpecObject, m_jit.branchIfNotObject(op1GPR));
>-        DFG_TYPE_CHECK(
>-            JSValueSource::unboxedCell(op2GPR), node->child2(), SpecObject, m_jit.branchIfNotObject(op2GPR));
>-    } else {
>-        DFG_TYPE_CHECK(
>-            JSValueSource::unboxedCell(op1GPR), node->child1(), SpecObject, m_jit.branchIfNotObject(op1GPR));
>-        speculationCheck(BadType, JSValueSource::unboxedCell(op1GPR), node->child1(),
>-            m_jit.branchTest8(
>-                MacroAssembler::NonZero, 
>-                MacroAssembler::Address(op1GPR, JSCell::typeInfoFlagsOffset()), 
>-                MacroAssembler::TrustedImm32(MasqueradesAsUndefined)));
>-
>-        DFG_TYPE_CHECK(
>-            JSValueSource::unboxedCell(op2GPR), node->child2(), SpecObject, m_jit.branchIfNotObject(op2GPR));
>-        speculationCheck(BadType, JSValueSource::unboxedCell(op2GPR), node->child2(),
>-            m_jit.branchTest8(
>-                MacroAssembler::NonZero, 
>-                MacroAssembler::Address(op2GPR, JSCell::typeInfoFlagsOffset()), 
>-                MacroAssembler::TrustedImm32(MasqueradesAsUndefined)));
>-    }
>-
>-    m_jit.compare64(MacroAssembler::Equal, op1GPR, op2GPR, resultGPR);
>-    m_jit.or32(TrustedImm32(ValueFalse), resultGPR);
>-    jsValueResult(resultGPR, m_currentNode, DataFormatJSBoolean);
>-}
>-
> void SpeculativeJIT::compileObjectStrictEquality(Edge objectChild, Edge otherChild)
> {
>     SpeculateCellOperand op1(this, objectChild);
>@@ -1564,38 +1526,6 @@ void SpeculativeJIT::compileSymbolUntypedEquality(Node* node, Edge symbolEdge, E
>     unblessedBooleanResult(resultGPR, node);
> }
> 
>-void SpeculativeJIT::compileInt32Compare(Node* node, MacroAssembler::RelationalCondition condition)
>-{
>-    if (node->child1()->isInt32Constant()) {
>-        SpeculateInt32Operand op2(this, node->child2());
>-        GPRTemporary result(this, Reuse, op2);
>-        int32_t imm = node->child1()->asInt32();
>-        m_jit.compare32(condition, JITCompiler::Imm32(imm), op2.gpr(), result.gpr());
>-
>-        // If we add a DataFormatBool, we should use it here.
>-        m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
>-        jsValueResult(result.gpr(), m_currentNode, DataFormatJSBoolean);
>-    } else if (node->child2()->isInt32Constant()) {
>-        SpeculateInt32Operand op1(this, node->child1());
>-        GPRTemporary result(this, Reuse, op1);
>-        int32_t imm = node->child2()->asInt32();
>-        m_jit.compare32(condition, op1.gpr(), JITCompiler::Imm32(imm), result.gpr());
>-
>-        // If we add a DataFormatBool, we should use it here.
>-        m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
>-        jsValueResult(result.gpr(), m_currentNode, DataFormatJSBoolean);
>-    } else {
>-        SpeculateInt32Operand op1(this, node->child1());
>-        SpeculateInt32Operand op2(this, node->child2());
>-        GPRTemporary result(this, Reuse, op1, op2);
>-        m_jit.compare32(condition, op1.gpr(), op2.gpr(), result.gpr());
>-
>-        // If we add a DataFormatBool, we should use it here.
>-        m_jit.or32(TrustedImm32(ValueFalse), result.gpr());
>-        jsValueResult(result.gpr(), m_currentNode, DataFormatJSBoolean);
>-    }
>-}
>-
> void SpeculativeJIT::compileInt52Compare(Node* node, MacroAssembler::RelationalCondition condition)
> {
>     SpeculateWhicheverInt52Operand op1(this, node->child1());
>@@ -1630,20 +1560,6 @@ void SpeculativeJIT::compilePeepHoleInt52Branch(Node* node, Node* branchNode, JI
>     jump(notTaken);
> }
> 
>-void SpeculativeJIT::compileDoubleCompare(Node* node, MacroAssembler::DoubleCondition condition)
>-{
>-    SpeculateDoubleOperand op1(this, node->child1());
>-    SpeculateDoubleOperand op2(this, node->child2());
>-    GPRTemporary result(this);
>-    
>-    m_jit.move(TrustedImm32(ValueTrue), result.gpr());
>-    MacroAssembler::Jump trueCase = m_jit.branchDouble(condition, op1.fpr(), op2.fpr());
>-    m_jit.xor64(TrustedImm32(true), result.gpr());
>-    trueCase.link(&m_jit);
>-    
>-    jsValueResult(result.gpr(), node, DataFormatJSBoolean);
>-}
>-
> void SpeculativeJIT::compileCompareEqPtr(Node* node)
> {
>     JSValueOperand value(this, node->child1());

Flags:

mark.lam: review+

Actions: View | Formatted Diff | Diff

Attachments on bug 185189: 339291