diff --git a/JSTests/ChangeLog b/JSTests/ChangeLog
index dcae489..62482a2 100644
--- a/JSTests/ChangeLog
+++ b/JSTests/ChangeLog
@@ -1,5 +1,41 @@
 2018-03-22  Yusuke Suzuki  <utatane.tea@gmail.com>
 
+        [DFG] Introduces fused compare and jump
+        https://bugs.webkit.org/show_bug.cgi?id=177100
+
+        Reviewed by Mark Lam.
+
+        * stress/fused-jeq-slow.js: Added.
+        (shouldBe):
+        (testJEQ):
+        (testJNEQB):
+        (testJEQB):
+        (testJNEQF):
+        (testJEQF):
+        * stress/fused-jeq.js: Added.
+        (shouldBe):
+        (testJEQ):
+        (testJNEQB):
+        (testJEQB):
+        (testJNEQF):
+        (testJEQF):
+        * stress/fused-jstricteq-slow.js: Added.
+        (shouldBe):
+        (testJSTRICTEQ):
+        (testJNSTRICTEQB):
+        (testJSTRICTEQB):
+        (testJNSTRICTEQF):
+        (testJSTRICTEQF):
+        * stress/fused-jstricteq.js: Added.
+        (shouldBe):
+        (testJSTRICTEQ):
+        (testJNSTRICTEQB):
+        (testJSTRICTEQB):
+        (testJNSTRICTEQF):
+        (testJSTRICTEQF):
+
+2018-03-22  Yusuke Suzuki  <utatane.tea@gmail.com>
+
         [JSC] Clear MustGenerate for ToString(Number) converted from NumberToStringWithRadix
         https://bugs.webkit.org/show_bug.cgi?id=183559
 
diff --git a/JSTests/stress/fused-jeq-slow.js b/JSTests/stress/fused-jeq-slow.js
new file mode 100644
index 0000000..8b34b3d
--- /dev/null
+++ b/JSTests/stress/fused-jeq-slow.js
@@ -0,0 +1,91 @@
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error(`bad value: ${String(actual)} ${String(expected)}`);
+}
+
+function testJNEQ(a, b)
+{
+    if (a == b) {
+        return 42;
+    }
+    return 30;
+}
+noInline(testJNEQ);
+
+function testJEQ(a, b)
+{
+    if (a != b) {
+        return 42;
+    }
+    return 30;
+}
+noInline(testJEQ);
+
+function testJNEQB(a, b)
+{
+    var i = 0;
+    do {
+        ++i;
+    } while (!(a == b));
+    return i;
+}
+noInline(testJNEQB);
+
+function testJEQB(a, b)
+{
+    var i = 0;
+    do {
+        ++i;
+    } while (!(a != b));
+    return i;
+}
+noInline(testJEQB);
+
+function testJNEQF(a, b)
+{
+    var i = 0;
+    while (!(a == b))
+        ++i;
+    return i;
+}
+noInline(testJNEQF);
+
+function testJEQF(a, b)
+{
+    var i = 0;
+    while (!(a != b))
+        ++i;
+    return i;
+}
+noInline(testJEQF);
+
+for (var i = 0; i < 1e4; ++i) {
+    shouldBe(testJNEQ('hello', 'world'), 30);
+    shouldBe(testJEQ('hello', 'world'), 42);
+    shouldBe(testJNEQ('world', 'world'), 42);
+    shouldBe(testJEQ('world', 'world'), 30);
+    shouldBe(testJNEQ(20.5, 'world'), 30);
+    shouldBe(testJEQ(20.5, 'world'), 42);
+
+    shouldBe(testJNEQ(20.5, 21.3), 30);
+    shouldBe(testJEQ(20.5, 21.3), 42);
+    shouldBe(testJNEQ(20.5, 20.5), 42);
+    shouldBe(testJEQ(20.5, 20.5), 30);
+
+    shouldBe(testJNEQB(0, 0), 1);
+    shouldBe(testJEQB(0, 1), 1);
+    shouldBe(testJNEQB('hello', 'hello'), 1);
+    shouldBe(testJEQB('hello', 'world'), 1);
+    shouldBe(testJNEQB(20.4, 20.4), 1);
+    shouldBe(testJEQB('hello', 20.4), 1);
+    shouldBe(testJNEQB(0, -0), 1);
+
+    shouldBe(testJNEQF(0, 0), 0);
+    shouldBe(testJEQF(0, 1), 0);
+    shouldBe(testJNEQF(20.4, 20.4), 0);
+    shouldBe(testJEQF(20.4, 10.5), 0);
+    shouldBe(testJNEQF(0, -0), 0);
+    shouldBe(testJEQF('hello', 10.5), 0);
+    shouldBe(testJNEQF('hello', 'hello'), 0);
+    shouldBe(testJEQF('hello', 'world'), 0);
+}
diff --git a/JSTests/stress/fused-jeq.js b/JSTests/stress/fused-jeq.js
new file mode 100644
index 0000000..234bf2d
--- /dev/null
+++ b/JSTests/stress/fused-jeq.js
@@ -0,0 +1,69 @@
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error(`bad value: ${String(actual)} ${String(expected)}`);
+}
+
+function testJNEQ(a, b)
+{
+    if (a == b) {
+        return 42;
+    }
+    return 30;
+}
+noInline(testJNEQ);
+
+function testJEQ(a, b)
+{
+    if (a != b) {
+        return 42;
+    }
+    return 30;
+}
+noInline(testJEQ);
+
+function testJNEQB(a, b)
+{
+    var i = 0;
+    do {
+        ++i;
+    } while (!(a == b));
+    return i;
+}
+noInline(testJNEQB);
+
+function testJEQB(a, b)
+{
+    var i = 0;
+    do {
+        ++i;
+    } while (!(a != b));
+    return i;
+}
+noInline(testJEQB);
+
+function testJNEQF(a, b)
+{
+    var i = 0;
+    while (!(a == b))
+        ++i;
+    return i;
+}
+noInline(testJNEQF);
+
+function testJEQF(a, b)
+{
+    var i = 0;
+    while (!(a != b))
+        ++i;
+    return i;
+}
+noInline(testJEQF);
+
+for (var i = 0; i < 1e4; ++i) {
+    shouldBe(testJNEQ(0, 42), 30);
+    shouldBe(testJEQ(0, 42), 42);
+    shouldBe(testJNEQB(0, 0), 1);
+    shouldBe(testJEQB(0, 1), 1);
+    shouldBe(testJNEQF(0, 0), 0);
+    shouldBe(testJEQF(0, 1), 0);
+}
diff --git a/JSTests/stress/fused-jstricteq-slow.js b/JSTests/stress/fused-jstricteq-slow.js
new file mode 100644
index 0000000..3b321fe
--- /dev/null
+++ b/JSTests/stress/fused-jstricteq-slow.js
@@ -0,0 +1,91 @@
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error(`bad value: ${String(actual)} ${String(expected)}`);
+}
+
+function testJNSTRICTEQ(a, b)
+{
+    if (a === b) {
+        return 42;
+    }
+    return 30;
+}
+noInline(testJNSTRICTEQ);
+
+function testJSTRICTEQ(a, b)
+{
+    if (a !== b) {
+        return 42;
+    }
+    return 30;
+}
+noInline(testJSTRICTEQ);
+
+function testJNSTRICTEQB(a, b)
+{
+    var i = 0;
+    do {
+        ++i;
+    } while (!(a === b));
+    return i;
+}
+noInline(testJNSTRICTEQB);
+
+function testJSTRICTEQB(a, b)
+{
+    var i = 0;
+    do {
+        ++i;
+    } while (!(a !== b));
+    return i;
+}
+noInline(testJSTRICTEQB);
+
+function testJNSTRICTEQF(a, b)
+{
+    var i = 0;
+    while (!(a === b))
+        ++i;
+    return i;
+}
+noInline(testJNSTRICTEQF);
+
+function testJSTRICTEQF(a, b)
+{
+    var i = 0;
+    while (!(a !== b))
+        ++i;
+    return i;
+}
+noInline(testJSTRICTEQF);
+
+for (var i = 0; i < 1e4; ++i) {
+    shouldBe(testJNSTRICTEQ('hello', 'world'), 30);
+    shouldBe(testJSTRICTEQ('hello', 'world'), 42);
+    shouldBe(testJNSTRICTEQ('world', 'world'), 42);
+    shouldBe(testJSTRICTEQ('world', 'world'), 30);
+    shouldBe(testJNSTRICTEQ(20.5, 'world'), 30);
+    shouldBe(testJSTRICTEQ(20.5, 'world'), 42);
+
+    shouldBe(testJNSTRICTEQ(20.5, 21.3), 30);
+    shouldBe(testJSTRICTEQ(20.5, 21.3), 42);
+    shouldBe(testJNSTRICTEQ(20.5, 20.5), 42);
+    shouldBe(testJSTRICTEQ(20.5, 20.5), 30);
+
+    shouldBe(testJNSTRICTEQB(0, 0), 1);
+    shouldBe(testJSTRICTEQB(0, 1), 1);
+    shouldBe(testJNSTRICTEQB('hello', 'hello'), 1);
+    shouldBe(testJSTRICTEQB('hello', 'world'), 1);
+    shouldBe(testJNSTRICTEQB(20.4, 20.4), 1);
+    shouldBe(testJSTRICTEQB('hello', 20.4), 1);
+    shouldBe(testJNSTRICTEQB(0, -0), 1);
+
+    shouldBe(testJNSTRICTEQF(0, 0), 0);
+    shouldBe(testJSTRICTEQF(0, 1), 0);
+    shouldBe(testJNSTRICTEQF(20.4, 20.4), 0);
+    shouldBe(testJSTRICTEQF(20.4, 10.5), 0);
+    shouldBe(testJNSTRICTEQF(0, -0), 0);
+    shouldBe(testJSTRICTEQF('hello', 10.5), 0);
+    shouldBe(testJNSTRICTEQF('hello', 'hello'), 0);
+    shouldBe(testJSTRICTEQF('hello', 'world'), 0);
+}
diff --git a/JSTests/stress/fused-jstricteq.js b/JSTests/stress/fused-jstricteq.js
new file mode 100644
index 0000000..3e8fe6c
--- /dev/null
+++ b/JSTests/stress/fused-jstricteq.js
@@ -0,0 +1,69 @@
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error(`bad value: ${String(actual)} ${String(expected)}`);
+}
+
+function testJNSTRICTEQ(a, b)
+{
+    if (a === b) {
+        return 42;
+    }
+    return 30;
+}
+noInline(testJNSTRICTEQ);
+
+function testJSTRICTEQ(a, b)
+{
+    if (a !== b) {
+        return 42;
+    }
+    return 30;
+}
+noInline(testJSTRICTEQ);
+
+function testJNSTRICTEQB(a, b)
+{
+    var i = 0;
+    do {
+        ++i;
+    } while (!(a === b));
+    return i;
+}
+noInline(testJNSTRICTEQB);
+
+function testJSTRICTEQB(a, b)
+{
+    var i = 0;
+    do {
+        ++i;
+    } while (!(a !== b));
+    return i;
+}
+noInline(testJSTRICTEQB);
+
+function testJNSTRICTEQF(a, b)
+{
+    var i = 0;
+    while (!(a === b))
+        ++i;
+    return i;
+}
+noInline(testJNSTRICTEQF);
+
+function testJSTRICTEQF(a, b)
+{
+    var i = 0;
+    while (!(a !== b))
+        ++i;
+    return i;
+}
+noInline(testJSTRICTEQF);
+
+for (var i = 0; i < 1e4; ++i) {
+    shouldBe(testJNSTRICTEQ(0, 42), 30);
+    shouldBe(testJSTRICTEQ(0, 42), 42);
+    shouldBe(testJNSTRICTEQB(0, 0), 1);
+    shouldBe(testJSTRICTEQB(0, 1), 1);
+    shouldBe(testJNSTRICTEQF(0, 0), 0);
+    shouldBe(testJSTRICTEQF(0, 1), 0);
+}
diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
index 3d32a00..090d1bc 100644
--- a/Source/JavaScriptCore/ChangeLog
+++ b/Source/JavaScriptCore/ChangeLog
@@ -1,3 +1,89 @@
+2018-03-22  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        [DFG] Introduces fused compare and jump
+        https://bugs.webkit.org/show_bug.cgi?id=177100
+
+        Reviewed by Mark Lam.
+
+        This patch introduces op_jeq, op_jneq, op_jstricteq, and op_jnstricteq.
+        It offers 3 benefit.
+
+        1. They are introduced due to the similar purpose to op_jless etc. It aligns
+        op_eq families to op_jless families.
+
+        2. It reduces the size of bytecode to represent the typical code sequence.
+
+        3. It offers the way to fuse check and jump in DFG code generation. Since
+        we have MovHint between Branch and CompareEq/CompareStrictEq previously,
+        we cannot do this optimization. It reduces the machine code size in DFG too.
+
+        It slightly improves Octane/boyer.
+
+            boyer  6.18038+-0.05002    ^     6.06990+-0.04176       ^ definitely 1.0182x faster
+
+        * bytecode/BytecodeDumper.cpp:
+        (JSC::BytecodeDumper<Block>::dumpBytecode):
+        * bytecode/BytecodeList.json:
+        * bytecode/BytecodeUseDef.h:
+        (JSC::computeUsesForBytecodeOffset):
+        (JSC::computeDefsForBytecodeOffset):
+        * bytecode/Opcode.h:
+        (JSC::isBranch):
+        * bytecode/PreciseJumpTargetsInlines.h:
+        (JSC::extractStoredJumpTargetsForBytecodeOffset):
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::emitJumpIfTrue):
+        (JSC::BytecodeGenerator::emitJumpIfFalse):
+        * dfg/DFGByteCodeParser.cpp:
+        (JSC::DFG::ByteCodeParser::parseBlock):
+        * dfg/DFGCapabilities.cpp:
+        (JSC::DFG::capabilityLevel):
+        * dfg/DFGOperations.cpp:
+        * dfg/DFGOperations.h:
+        * dfg/DFGSpeculativeJIT.cpp:
+        (JSC::DFG::SpeculativeJIT::compileStrictEq):
+        * jit/JIT.cpp:
+        (JSC::JIT::privateCompileMainPass):
+        (JSC::JIT::privateCompileSlowCases):
+        * jit/JIT.h:
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::emit_op_jeq):
+        (JSC::JIT::emit_op_neq):
+        (JSC::JIT::emit_op_jneq):
+        (JSC::JIT::compileOpStrictEq):
+        (JSC::JIT::emit_op_stricteq):
+        (JSC::JIT::emit_op_nstricteq):
+        (JSC::JIT::compileOpStrictEqJump):
+        (JSC::JIT::emit_op_jstricteq):
+        (JSC::JIT::emit_op_jnstricteq):
+        (JSC::JIT::emitSlow_op_jstricteq):
+        (JSC::JIT::emitSlow_op_jnstricteq):
+        (JSC::JIT::emitSlow_op_jeq):
+        (JSC::JIT::emitSlow_op_jneq):
+        * jit/JITOpcodes32_64.cpp:
+        (JSC::JIT::emitSlow_op_eq):
+        (JSC::JIT::emit_op_jeq):
+        (JSC::JIT::compileOpEqJumpSlow):
+        (JSC::JIT::emitSlow_op_jeq):
+        (JSC::JIT::emit_op_jneq):
+        (JSC::JIT::emitSlow_op_jneq):
+        (JSC::JIT::compileOpStrictEq):
+        (JSC::JIT::emit_op_stricteq):
+        (JSC::JIT::emit_op_nstricteq):
+        (JSC::JIT::compileOpStrictEqJump):
+        (JSC::JIT::emit_op_jstricteq):
+        (JSC::JIT::emit_op_jnstricteq):
+        (JSC::JIT::emitSlow_op_jstricteq):
+        (JSC::JIT::emitSlow_op_jnstricteq):
+        * jit/JITOperations.cpp:
+        * jit/JITOperations.h:
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+        * llint/LLIntSlowPaths.h:
+        * llint/LowLevelInterpreter.asm:
+        * llint/LowLevelInterpreter32_64.asm:
+        * llint/LowLevelInterpreter64.asm:
+
 2018-03-24  Yusuke Suzuki  <utatane.tea@gmail.com>
 
         [JSC] Improve constants and add comments for CodeBlockHash
diff --git a/Source/JavaScriptCore/bytecode/BytecodeDumper.cpp b/Source/JavaScriptCore/bytecode/BytecodeDumper.cpp
index 3cef4b4..b655efe 100644
--- a/Source/JavaScriptCore/bytecode/BytecodeDumper.cpp
+++ b/Source/JavaScriptCore/bytecode/BytecodeDumper.cpp
@@ -1250,6 +1250,22 @@
         printCompareJump(out, begin, it, location, "jngreatereq");
         break;
     }
+    case op_jeq: {
+        printCompareJump(out, begin, it, location, "jeq");
+        break;
+    }
+    case op_jneq: {
+        printCompareJump(out, begin, it, location, "jneq");
+        break;
+    }
+    case op_jstricteq: {
+        printCompareJump(out, begin, it, location, "jstricteq");
+        break;
+    }
+    case op_jnstricteq: {
+        printCompareJump(out, begin, it, location, "jnstricteq");
+        break;
+    }
     case op_jbelow: {
         printCompareJump(out, begin, it, location, "jbelow");
         break;
diff --git a/Source/JavaScriptCore/bytecode/BytecodeList.json b/Source/JavaScriptCore/bytecode/BytecodeList.json
index a156d54..ff302ac 100644
--- a/Source/JavaScriptCore/bytecode/BytecodeList.json
+++ b/Source/JavaScriptCore/bytecode/BytecodeList.json
@@ -109,6 +109,10 @@
             { "name" : "op_jeq_null", "length" : 3 },
             { "name" : "op_jneq_null", "length" : 3 },
             { "name" : "op_jneq_ptr", "length" : 5 },
+            { "name" : "op_jeq", "length" : 4 },
+            { "name" : "op_jstricteq", "length" : 4 },
+            { "name" : "op_jneq", "length" : 4 },
+            { "name" : "op_jnstricteq", "length" : 4 },
             { "name" : "op_jless", "length" : 4 },
             { "name" : "op_jlesseq", "length" : 4 },
             { "name" : "op_jgreater", "length" : 4 },
diff --git a/Source/JavaScriptCore/bytecode/BytecodeUseDef.h b/Source/JavaScriptCore/bytecode/BytecodeUseDef.h
index 71c2a28..b250def 100644
--- a/Source/JavaScriptCore/bytecode/BytecodeUseDef.h
+++ b/Source/JavaScriptCore/bytecode/BytecodeUseDef.h
@@ -85,6 +85,10 @@
     case op_jngreater:
     case op_jngreatereq:
     case op_jless:
+    case op_jeq:
+    case op_jneq:
+    case op_jstricteq:
+    case op_jnstricteq:
     case op_jbelow:
     case op_jbeloweq:
     case op_set_function_name:
@@ -347,6 +351,10 @@
     case op_jnlesseq:
     case op_jngreater:
     case op_jngreatereq:
+    case op_jeq:
+    case op_jneq:
+    case op_jstricteq:
+    case op_jnstricteq:
     case op_jbelow:
     case op_jbeloweq:
     case op_loop_hint:
diff --git a/Source/JavaScriptCore/bytecode/Opcode.h b/Source/JavaScriptCore/bytecode/Opcode.h
index 758d340..07d9a73 100644
--- a/Source/JavaScriptCore/bytecode/Opcode.h
+++ b/Source/JavaScriptCore/bytecode/Opcode.h
@@ -151,6 +151,10 @@
     case op_jnlesseq:
     case op_jngreater:
     case op_jngreatereq:
+    case op_jeq:
+    case op_jneq:
+    case op_jstricteq:
+    case op_jnstricteq:
     case op_jbelow:
     case op_jbeloweq:
     case op_switch_imm:
diff --git a/Source/JavaScriptCore/bytecode/PreciseJumpTargetsInlines.h b/Source/JavaScriptCore/bytecode/PreciseJumpTargetsInlines.h
index 36725f9..070fde9 100644
--- a/Source/JavaScriptCore/bytecode/PreciseJumpTargetsInlines.h
+++ b/Source/JavaScriptCore/bytecode/PreciseJumpTargetsInlines.h
@@ -55,6 +55,10 @@
     case op_jnlesseq:
     case op_jngreater:
     case op_jngreatereq:
+    case op_jeq:
+    case op_jneq:
+    case op_jstricteq:
+    case op_jnstricteq:
     case op_jbelow:
     case op_jbeloweq:
         function(current[3].u.operand);
diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
index 1448ede..97eb3bb 100644
--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
@@ -1397,6 +1397,18 @@
     } else if (m_lastOpcodeID == op_greatereq) {
         if (fuseCompareAndJump(op_jgreatereq))
             return;
+    } else if (m_lastOpcodeID == op_eq) {
+        if (fuseCompareAndJump(op_jeq))
+            return;
+    } else if (m_lastOpcodeID == op_stricteq) {
+        if (fuseCompareAndJump(op_jstricteq))
+            return;
+    } else if (m_lastOpcodeID == op_neq) {
+        if (fuseCompareAndJump(op_jneq))
+            return;
+    } else if (m_lastOpcodeID == op_nstricteq) {
+        if (fuseCompareAndJump(op_jnstricteq))
+            return;
     } else if (m_lastOpcodeID == op_below) {
         if (fuseCompareAndJump(op_jbelow))
             return;
@@ -1479,6 +1491,18 @@
     } else if (m_lastOpcodeID == op_greatereq && target.isForward()) {
         if (fuseCompareAndJump(op_jngreatereq, false))
             return;
+    } else if (m_lastOpcodeID == op_eq && target.isForward()) {
+        if (fuseCompareAndJump(op_jneq, false))
+            return;
+    } else if (m_lastOpcodeID == op_stricteq && target.isForward()) {
+        if (fuseCompareAndJump(op_jnstricteq, false))
+            return;
+    } else if (m_lastOpcodeID == op_neq && target.isForward()) {
+        if (fuseCompareAndJump(op_jeq, false))
+            return;
+    } else if (m_lastOpcodeID == op_nstricteq && target.isForward()) {
+        if (fuseCompareAndJump(op_jstricteq, false))
+            return;
     } else if (m_lastOpcodeID == op_below && target.isForward()) {
         if (fuseCompareAndJump(op_jbeloweq, true))
             return;
diff --git a/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp b/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
index 5f8c2bb..9b45b1b 100644
--- a/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
+++ b/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
@@ -5328,6 +5328,24 @@
             LAST_OPCODE(op_jgreatereq);
         }
 
+        case op_jeq: {
+            unsigned relativeOffset = currentInstruction[3].u.operand;
+            Node* op1 = get(VirtualRegister(currentInstruction[1].u.operand));
+            Node* op2 = get(VirtualRegister(currentInstruction[2].u.operand));
+            Node* condition = addToGraph(CompareEq, op1, op2);
+            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + OPCODE_LENGTH(op_jeq))), condition);
+            LAST_OPCODE(op_jeq);
+        }
+
+        case op_jstricteq: {
+            unsigned relativeOffset = currentInstruction[3].u.operand;
+            Node* op1 = get(VirtualRegister(currentInstruction[1].u.operand));
+            Node* op2 = get(VirtualRegister(currentInstruction[2].u.operand));
+            Node* condition = addToGraph(CompareStrictEq, op1, op2);
+            addToGraph(Branch, OpInfo(branchData(m_currentIndex + relativeOffset, m_currentIndex + OPCODE_LENGTH(op_jstricteq))), condition);
+            LAST_OPCODE(op_jstricteq);
+        }
+
         case op_jnless: {
             unsigned relativeOffset = currentInstruction[3].u.operand;
             Node* op1 = get(VirtualRegister(currentInstruction[1].u.operand));
@@ -5364,6 +5382,24 @@
             LAST_OPCODE(op_jngreatereq);
         }
 
+        case op_jneq: {
+            unsigned relativeOffset = currentInstruction[3].u.operand;
+            Node* op1 = get(VirtualRegister(currentInstruction[1].u.operand));
+            Node* op2 = get(VirtualRegister(currentInstruction[2].u.operand));
+            Node* condition = addToGraph(CompareEq, op1, op2);
+            addToGraph(Branch, OpInfo(branchData(m_currentIndex + OPCODE_LENGTH(op_jneq), m_currentIndex + relativeOffset)), condition);
+            LAST_OPCODE(op_jneq);
+        }
+
+        case op_jnstricteq: {
+            unsigned relativeOffset = currentInstruction[3].u.operand;
+            Node* op1 = get(VirtualRegister(currentInstruction[1].u.operand));
+            Node* op2 = get(VirtualRegister(currentInstruction[2].u.operand));
+            Node* condition = addToGraph(CompareStrictEq, op1, op2);
+            addToGraph(Branch, OpInfo(branchData(m_currentIndex + OPCODE_LENGTH(op_jnstricteq), m_currentIndex + relativeOffset)), condition);
+            LAST_OPCODE(op_jnstricteq);
+        }
+
         case op_jbelow: {
             unsigned relativeOffset = currentInstruction[3].u.operand;
             Node* op1 = get(VirtualRegister(currentInstruction[1].u.operand));
diff --git a/Source/JavaScriptCore/dfg/DFGCapabilities.cpp b/Source/JavaScriptCore/dfg/DFGCapabilities.cpp
index ae58395..e205863 100644
--- a/Source/JavaScriptCore/dfg/DFGCapabilities.cpp
+++ b/Source/JavaScriptCore/dfg/DFGCapabilities.cpp
@@ -194,6 +194,10 @@
     case op_jnlesseq:
     case op_jngreater:
     case op_jngreatereq:
+    case op_jeq:
+    case op_jneq:
+    case op_jstricteq:
+    case op_jnstricteq:
     case op_jbelow:
     case op_jbeloweq:
     case op_loop_hint:
diff --git a/Source/JavaScriptCore/dfg/DFGOperations.cpp b/Source/JavaScriptCore/dfg/DFGOperations.cpp
index a00f091..ec30500 100644
--- a/Source/JavaScriptCore/dfg/DFGOperations.cpp
+++ b/Source/JavaScriptCore/dfg/DFGOperations.cpp
@@ -1243,17 +1243,6 @@
     return JSValue::strictEqualSlowCaseInline(exec, op1, op2);
 }
 
-size_t JIT_OPERATION operationCompareStrictEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
-{
-    VM* vm = &exec->vm();
-    NativeCallFrameTracer tracer(vm, exec);
-
-    JSValue src1 = JSValue::decode(encodedOp1);
-    JSValue src2 = JSValue::decode(encodedOp2);
-    
-    return JSValue::strictEqual(exec, src1, src2);
-}
-
 EncodedJSValue JIT_OPERATION operationToPrimitive(ExecState* exec, EncodedJSValue value)
 {
     VM* vm = &exec->vm();
diff --git a/Source/JavaScriptCore/dfg/DFGOperations.h b/Source/JavaScriptCore/dfg/DFGOperations.h
index 7add59d..a356d82 100644
--- a/Source/JavaScriptCore/dfg/DFGOperations.h
+++ b/Source/JavaScriptCore/dfg/DFGOperations.h
@@ -162,7 +162,6 @@
 size_t JIT_OPERATION operationRegExpTest(ExecState*, JSGlobalObject*, RegExpObject*, EncodedJSValue) WTF_INTERNAL;
 size_t JIT_OPERATION operationRegExpTestGeneric(ExecState*, JSGlobalObject*, EncodedJSValue, EncodedJSValue) WTF_INTERNAL;
 size_t JIT_OPERATION operationCompareStrictEqCell(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2) WTF_INTERNAL;
-size_t JIT_OPERATION operationCompareStrictEq(ExecState*, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2) WTF_INTERNAL;
 JSCell* JIT_OPERATION operationCreateActivationDirect(ExecState*, Structure*, JSScope*, SymbolTable*, EncodedJSValue);
 JSCell* JIT_OPERATION operationCreateDirectArguments(ExecState*, Structure*, uint32_t length, uint32_t minCapacity);
 JSCell* JIT_OPERATION operationCreateDirectArgumentsDuringExit(ExecState*, InlineCallFrame*, JSFunction*, uint32_t argumentCount);
diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
index 5275c6c..816156b 100644
--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
@@ -5737,12 +5737,6 @@
 
 bool SpeculativeJIT::compileStrictEq(Node* node)
 {
-    // FIXME: Currently, we have op_jless, op_jgreater etc. But we don't have op_jeq, op_jstricteq etc.
-    // `==` and `===` operations with branching will be compiled to op_{eq,stricteq} and op_{jfalse,jtrue}.
-    // In DFG bytecodes, between op_eq and op_jfalse, we have MovHint to store the result of op_eq.
-    // As a result, detectPeepHoleBranch() never detects peep hole for that case.
-    // https://bugs.webkit.org/show_bug.cgi?id=149713
-
     if (node->isBinaryUseKind(BooleanUse)) {
         unsigned branchIndexInBlock = detectPeepHoleBranch();
         if (branchIndexInBlock != UINT_MAX) {
diff --git a/Source/JavaScriptCore/jit/JIT.cpp b/Source/JavaScriptCore/jit/JIT.cpp
index c4269d6..d4706e3 100644
--- a/Source/JavaScriptCore/jit/JIT.cpp
+++ b/Source/JavaScriptCore/jit/JIT.cpp
@@ -358,6 +358,10 @@
         DEFINE_OP(op_jnlesseq)
         DEFINE_OP(op_jngreater)
         DEFINE_OP(op_jngreatereq)
+        DEFINE_OP(op_jeq)
+        DEFINE_OP(op_jneq)
+        DEFINE_OP(op_jstricteq)
+        DEFINE_OP(op_jnstricteq)
         DEFINE_OP(op_jbelow)
         DEFINE_OP(op_jbeloweq)
         DEFINE_OP(op_jtrue)
@@ -520,6 +524,10 @@
         DEFINE_SLOWCASE_OP(op_jnlesseq)
         DEFINE_SLOWCASE_OP(op_jngreater)
         DEFINE_SLOWCASE_OP(op_jngreatereq)
+        DEFINE_SLOWCASE_OP(op_jeq)
+        DEFINE_SLOWCASE_OP(op_jneq)
+        DEFINE_SLOWCASE_OP(op_jstricteq)
+        DEFINE_SLOWCASE_OP(op_jnstricteq)
         DEFINE_SLOWCASE_OP(op_loop_hint)
         DEFINE_SLOWCASE_OP(op_check_traps)
         DEFINE_SLOWCASE_OP(op_mod)
diff --git a/Source/JavaScriptCore/jit/JIT.h b/Source/JavaScriptCore/jit/JIT.h
index c5dda73..1cd69f7 100644
--- a/Source/JavaScriptCore/jit/JIT.h
+++ b/Source/JavaScriptCore/jit/JIT.h
@@ -313,8 +313,11 @@
         void compileCallEvalSlowCase(Instruction*, Vector<SlowCaseEntry>::iterator&);
         void emitPutCallResult(Instruction*);
 
-        enum CompileOpStrictEqType { OpStrictEq, OpNStrictEq };
-        void compileOpStrictEq(Instruction* instruction, CompileOpStrictEqType type);
+        enum class CompileOpStrictEqType { StrictEq, NStrictEq };
+        void compileOpStrictEq(Instruction*, CompileOpStrictEqType);
+        void compileOpStrictEqJump(Instruction*, CompileOpStrictEqType);
+        enum class CompileOpEqType { Eq, NEq };
+        void compileOpEqJumpSlow(Vector<SlowCaseEntry>::iterator&, CompileOpEqType, int jumpTarget);
         bool isOperandConstantDouble(int src);
         
         void emitLoadDouble(int index, FPRegisterID value);
@@ -523,6 +526,10 @@
         void emit_op_jnlesseq(Instruction*);
         void emit_op_jngreater(Instruction*);
         void emit_op_jngreatereq(Instruction*);
+        void emit_op_jeq(Instruction*);
+        void emit_op_jneq(Instruction*);
+        void emit_op_jstricteq(Instruction*);
+        void emit_op_jnstricteq(Instruction*);
         void emit_op_jbelow(Instruction*);
         void emit_op_jbeloweq(Instruction*);
         void emit_op_jtrue(Instruction*);
@@ -616,6 +623,10 @@
         void emitSlow_op_jnlesseq(Instruction*, Vector<SlowCaseEntry>::iterator&);
         void emitSlow_op_jngreater(Instruction*, Vector<SlowCaseEntry>::iterator&);
         void emitSlow_op_jngreatereq(Instruction*, Vector<SlowCaseEntry>::iterator&);
+        void emitSlow_op_jeq(Instruction*, Vector<SlowCaseEntry>::iterator&);
+        void emitSlow_op_jneq(Instruction*, Vector<SlowCaseEntry>::iterator&);
+        void emitSlow_op_jstricteq(Instruction*, Vector<SlowCaseEntry>::iterator&);
+        void emitSlow_op_jnstricteq(Instruction*, Vector<SlowCaseEntry>::iterator&);
         void emitSlow_op_jtrue(Instruction*, Vector<SlowCaseEntry>::iterator&);
         void emitSlow_op_loop_hint(Instruction*, Vector<SlowCaseEntry>::iterator&);
         void emitSlow_op_check_traps(Instruction*, Vector<SlowCaseEntry>::iterator&);
diff --git a/Source/JavaScriptCore/jit/JITOpcodes.cpp b/Source/JavaScriptCore/jit/JITOpcodes.cpp
index 89d12e2..8f320b7 100644
--- a/Source/JavaScriptCore/jit/JITOpcodes.cpp
+++ b/Source/JavaScriptCore/jit/JITOpcodes.cpp
@@ -425,6 +425,14 @@
     emitPutVirtualRegister(currentInstruction[1].u.operand);
 }
 
+void JIT::emit_op_jeq(Instruction* currentInstruction)
+{
+    unsigned target = currentInstruction[3].u.operand;
+    emitGetVirtualRegisters(currentInstruction[1].u.operand, regT0, currentInstruction[2].u.operand, regT1);
+    emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
+    addJump(branch32(Equal, regT0, regT1), target);
+}
+
 void JIT::emit_op_jtrue(Instruction* currentInstruction)
 {
     unsigned target = currentInstruction[2].u.operand;
@@ -446,7 +454,14 @@
     emitTagBool(regT0);
 
     emitPutVirtualRegister(currentInstruction[1].u.operand);
+}
 
+void JIT::emit_op_jneq(Instruction* currentInstruction)
+{
+    unsigned target = currentInstruction[3].u.operand;
+    emitGetVirtualRegisters(currentInstruction[1].u.operand, regT0, currentInstruction[2].u.operand, regT1);
+    emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
+    addJump(branch32(NotEqual, regT0, regT1), target);
 }
 
 void JIT::emit_op_throw(Instruction* currentInstruction)
@@ -480,7 +495,7 @@
     addSlowCase(emitJumpIfNumber(regT1));
     rightOK.link(this);
 
-    if (type == OpStrictEq)
+    if (type == CompileOpStrictEqType::StrictEq)
         compare64(Equal, regT1, regT0, regT0);
     else
         compare64(NotEqual, regT1, regT0, regT0);
@@ -491,12 +506,68 @@
 
 void JIT::emit_op_stricteq(Instruction* currentInstruction)
 {
-    compileOpStrictEq(currentInstruction, OpStrictEq);
+    compileOpStrictEq(currentInstruction, CompileOpStrictEqType::StrictEq);
 }
 
 void JIT::emit_op_nstricteq(Instruction* currentInstruction)
 {
-    compileOpStrictEq(currentInstruction, OpNStrictEq);
+    compileOpStrictEq(currentInstruction, CompileOpStrictEqType::NStrictEq);
+}
+
+void JIT::compileOpStrictEqJump(Instruction* currentInstruction, CompileOpStrictEqType type)
+{
+    int target = currentInstruction[3].u.operand;
+    int src1 = currentInstruction[1].u.operand;
+    int src2 = currentInstruction[2].u.operand;
+
+    emitGetVirtualRegisters(src1, regT0, src2, regT1);
+
+    // Jump slow if both are cells (to cover strings).
+    move(regT0, regT2);
+    or64(regT1, regT2);
+    addSlowCase(emitJumpIfJSCell(regT2));
+
+    // Jump slow if either is a double. First test if it's an integer, which is fine, and then test
+    // if it's a double.
+    Jump leftOK = emitJumpIfInt(regT0);
+    addSlowCase(emitJumpIfNumber(regT0));
+    leftOK.link(this);
+    Jump rightOK = emitJumpIfInt(regT1);
+    addSlowCase(emitJumpIfNumber(regT1));
+    rightOK.link(this);
+
+    if (type == CompileOpStrictEqType::StrictEq)
+        addJump(branch64(Equal, regT1, regT0), target);
+    else
+        addJump(branch64(NotEqual, regT1, regT0), target);
+}
+
+void JIT::emit_op_jstricteq(Instruction* currentInstruction)
+{
+    compileOpStrictEqJump(currentInstruction, CompileOpStrictEqType::StrictEq);
+}
+
+void JIT::emit_op_jnstricteq(Instruction* currentInstruction)
+{
+    compileOpStrictEqJump(currentInstruction, CompileOpStrictEqType::NStrictEq);
+}
+
+void JIT::emitSlow_op_jstricteq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    linkAllSlowCases(iter);
+
+    unsigned target = currentInstruction[3].u.operand;
+    callOperation(operationCompareStrictEq, regT0, regT1);
+    emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
+}
+
+void JIT::emitSlow_op_jnstricteq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    linkAllSlowCases(iter);
+
+    unsigned target = currentInstruction[3].u.operand;
+    callOperation(operationCompareStrictEq, regT0, regT1);
+    emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
 }
 
 void JIT::emit_op_to_number(Instruction* currentInstruction)
@@ -818,6 +889,24 @@
     emitPutVirtualRegister(currentInstruction[1].u.operand, returnValueGPR);
 }
 
+void JIT::emitSlow_op_jeq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    linkAllSlowCases(iter);
+
+    unsigned target = currentInstruction[3].u.operand;
+    callOperation(operationCompareEq, regT0, regT1);
+    emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
+}
+
+void JIT::emitSlow_op_jneq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    linkAllSlowCases(iter);
+
+    unsigned target = currentInstruction[3].u.operand;
+    callOperation(operationCompareEq, regT0, regT1);
+    emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
+}
+
 void JIT::emitSlow_op_instanceof(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkAllSlowCases(iter);
diff --git a/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp b/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
index 0d751ea..46e507b 100644
--- a/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
+++ b/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
@@ -469,8 +469,6 @@
 void JIT::emitSlow_op_eq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     int dst = currentInstruction[1].u.operand;
-    int op1 = currentInstruction[2].u.operand;
-    int op2 = currentInstruction[3].u.operand;
 
     JumpList storeResult;
     JumpList genericCase;
@@ -488,14 +486,56 @@
     // Generic case.
     genericCase.append(getSlowCase(iter)); // doubles
     genericCase.link(this);
-    emitLoad(op1, regT1, regT0);
-    emitLoad(op2, regT3, regT2);
     callOperation(operationCompareEq, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
 
     storeResult.link(this);
     emitStoreBool(dst, returnValueGPR);
 }
 
+void JIT::emit_op_jeq(Instruction* currentInstruction)
+{
+    int target = currentInstruction[3].u.operand;
+    int src1 = currentInstruction[1].u.operand;
+    int src2 = currentInstruction[2].u.operand;
+
+    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
+    addSlowCase(branch32(NotEqual, regT1, regT3));
+    addSlowCase(branch32(Equal, regT1, TrustedImm32(JSValue::CellTag)));
+    addSlowCase(branch32(Below, regT1, TrustedImm32(JSValue::LowestTag)));
+
+    addJump(branch32(Equal, regT0, regT2), target);
+}
+
+void JIT::compileOpEqJumpSlow(Vector<SlowCaseEntry>::iterator& iter, CompileOpEqType type, int jumpTarget)
+{
+    JumpList done;
+    JumpList genericCase;
+
+    genericCase.append(getSlowCase(iter)); // tags not equal
+
+    linkSlowCase(iter); // tags equal and JSCell
+    genericCase.append(branchPtr(NotEqual, Address(regT0, JSCell::structureIDOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
+    genericCase.append(branchPtr(NotEqual, Address(regT2, JSCell::structureIDOffset()), TrustedImmPtr(m_vm->stringStructure.get())));
+
+    // String case.
+    callOperation(operationCompareStringEq, regT0, regT2);
+    emitJumpSlowToHot(branchTest32(type == CompileOpEqType::Eq ? NonZero : Zero, returnValueGPR), jumpTarget);
+    done.append(jump());
+
+    // Generic case.
+    genericCase.append(getSlowCase(iter)); // doubles
+    genericCase.link(this);
+    callOperation(operationCompareEq, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
+    emitJumpSlowToHot(branchTest32(type == CompileOpEqType::Eq ? NonZero : Zero, returnValueGPR), jumpTarget);
+
+    done.link(this);
+}
+
+void JIT::emitSlow_op_jeq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    compileOpEqJumpSlow(iter, CompileOpEqType::Eq, currentInstruction[3].u.operand);
+}
+
 void JIT::emit_op_neq(Instruction* currentInstruction)
 {
     int dst = currentInstruction[1].u.operand;
@@ -539,6 +579,25 @@
     emitStoreBool(dst, returnValueGPR);
 }
 
+void JIT::emit_op_jneq(Instruction* currentInstruction)
+{
+    int target = currentInstruction[3].u.operand;
+    int src1 = currentInstruction[1].u.operand;
+    int src2 = currentInstruction[2].u.operand;
+
+    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
+    addSlowCase(branch32(NotEqual, regT1, regT3));
+    addSlowCase(branch32(Equal, regT1, TrustedImm32(JSValue::CellTag)));
+    addSlowCase(branch32(Below, regT1, TrustedImm32(JSValue::LowestTag)));
+
+    addJump(branch32(NotEqual, regT0, regT2), target);
+}
+
+void JIT::emitSlow_op_jneq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    compileOpEqJumpSlow(iter, CompileOpEqType::NEq, currentInstruction[3].u.operand);
+}
+
 void JIT::compileOpStrictEq(Instruction* currentInstruction, CompileOpStrictEqType type)
 {
     int dst = currentInstruction[1].u.operand;
@@ -559,7 +618,7 @@
     firstIsObject.link(this);
 
     // Simply compare the payloads.
-    if (type == OpStrictEq)
+    if (type == CompileOpStrictEqType::StrictEq)
         compare32(Equal, regT0, regT2, regT0);
     else
         compare32(NotEqual, regT0, regT2, regT0);
@@ -569,12 +628,66 @@
 
 void JIT::emit_op_stricteq(Instruction* currentInstruction)
 {
-    compileOpStrictEq(currentInstruction, OpStrictEq);
+    compileOpStrictEq(currentInstruction, CompileOpStrictEqType::StrictEq);
 }
 
 void JIT::emit_op_nstricteq(Instruction* currentInstruction)
 {
-    compileOpStrictEq(currentInstruction, OpNStrictEq);
+    compileOpStrictEq(currentInstruction, CompileOpStrictEqType::NStrictEq);
+}
+
+void JIT::compileOpStrictEqJump(Instruction* currentInstruction, CompileOpStrictEqType type)
+{
+    int target = currentInstruction[3].u.operand;
+    int src1 = currentInstruction[1].u.operand;
+    int src2 = currentInstruction[2].u.operand;
+
+    emitLoad2(src1, regT1, regT0, src2, regT3, regT2);
+
+    // Bail if the tags differ, or are double.
+    addSlowCase(branch32(NotEqual, regT1, regT3));
+    addSlowCase(branch32(Below, regT1, TrustedImm32(JSValue::LowestTag)));
+
+    // Jump to a slow case if both are strings or symbols (non object).
+    Jump notCell = branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag));
+    Jump firstIsObject = emitJumpIfCellObject(regT0);
+    addSlowCase(emitJumpIfCellNotObject(regT2));
+    notCell.link(this);
+    firstIsObject.link(this);
+
+    // Simply compare the payloads.
+    if (type == CompileOpStrictEqType::StrictEq)
+        addJump(branch32(Equal, regT0, regT2), target);
+    else
+        addJump(branch32(NotEqual, regT0, regT2), target);
+}
+
+void JIT::emit_op_jstricteq(Instruction* currentInstruction)
+{
+    compileOpStrictEqJump(currentInstruction, CompileOpStrictEqType::StrictEq);
+}
+
+void JIT::emit_op_jnstricteq(Instruction* currentInstruction)
+{
+    compileOpStrictEqJump(currentInstruction, CompileOpStrictEqType::NStrictEq);
+}
+
+void JIT::emitSlow_op_jstricteq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    linkAllSlowCases(iter);
+
+    unsigned target = currentInstruction[3].u.operand;
+    callOperation(operationCompareStrictEq, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
+    emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
+}
+
+void JIT::emitSlow_op_jnstricteq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
+{
+    linkAllSlowCases(iter);
+
+    unsigned target = currentInstruction[3].u.operand;
+    callOperation(operationCompareStrictEq, JSValueRegs(regT1, regT0), JSValueRegs(regT3, regT2));
+    emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target);
 }
 
 void JIT::emit_op_eq_null(Instruction* currentInstruction)
diff --git a/Source/JavaScriptCore/jit/JITOperations.cpp b/Source/JavaScriptCore/jit/JITOperations.cpp
index e46a3d7..e0072fa 100644
--- a/Source/JavaScriptCore/jit/JITOperations.cpp
+++ b/Source/JavaScriptCore/jit/JITOperations.cpp
@@ -1170,6 +1170,17 @@
 #endif
 }
 
+size_t JIT_OPERATION operationCompareStrictEq(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
+{
+    VM* vm = &exec->vm();
+    NativeCallFrameTracer tracer(vm, exec);
+
+    JSValue src1 = JSValue::decode(encodedOp1);
+    JSValue src2 = JSValue::decode(encodedOp2);
+
+    return JSValue::strictEqual(exec, src1, src2);
+}
+
 EncodedJSValue JIT_OPERATION operationNewArrayWithProfile(ExecState* exec, ArrayAllocationProfile* profile, const JSValue* values, int size)
 {
     VM* vm = &exec->vm();
diff --git a/Source/JavaScriptCore/jit/JITOperations.h b/Source/JavaScriptCore/jit/JITOperations.h
index 4a91ab8..909eaa0 100644
--- a/Source/JavaScriptCore/jit/JITOperations.h
+++ b/Source/JavaScriptCore/jit/JITOperations.h
@@ -396,6 +396,7 @@
 size_t JIT_OPERATION operationCompareGreater(ExecState*, EncodedJSValue, EncodedJSValue) WTF_INTERNAL;
 size_t JIT_OPERATION operationCompareGreaterEq(ExecState*, EncodedJSValue, EncodedJSValue) WTF_INTERNAL;
 size_t JIT_OPERATION operationCompareEq(ExecState*, EncodedJSValue, EncodedJSValue) WTF_INTERNAL;
+size_t JIT_OPERATION operationCompareStrictEq(ExecState*, EncodedJSValue, EncodedJSValue) WTF_INTERNAL;
 #if USE(JSVALUE64)
 EncodedJSValue JIT_OPERATION operationCompareStringEq(ExecState*, JSCell* left, JSCell* right) WTF_INTERNAL;
 #else
diff --git a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp b/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
index 8b6b610..58481a5 100644
--- a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
+++ b/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
@@ -1149,6 +1149,30 @@
     LLINT_BRANCH(op_jngreatereq, !jsLessEq<false>(exec, LLINT_OP_C(2).jsValue(), LLINT_OP_C(1).jsValue()));
 }
 
+LLINT_SLOW_PATH_DECL(slow_path_jeq)
+{
+    LLINT_BEGIN();
+    LLINT_BRANCH(op_jeq, JSValue::equal(exec, LLINT_OP_C(1).jsValue(), LLINT_OP_C(2).jsValue()));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_jneq)
+{
+    LLINT_BEGIN();
+    LLINT_BRANCH(op_jneq, !JSValue::equal(exec, LLINT_OP_C(1).jsValue(), LLINT_OP_C(2).jsValue()));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_jstricteq)
+{
+    LLINT_BEGIN();
+    LLINT_BRANCH(op_jstricteq, JSValue::strictEqual(exec, LLINT_OP_C(1).jsValue(), LLINT_OP_C(2).jsValue()));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_jnstricteq)
+{
+    LLINT_BEGIN();
+    LLINT_BRANCH(op_jnstricteq, !JSValue::strictEqual(exec, LLINT_OP_C(1).jsValue(), LLINT_OP_C(2).jsValue()));
+}
+
 LLINT_SLOW_PATH_DECL(slow_path_switch_imm)
 {
     LLINT_BEGIN();
diff --git a/Source/JavaScriptCore/llint/LLIntSlowPaths.h b/Source/JavaScriptCore/llint/LLIntSlowPaths.h
index 6e5051b..d241f71 100644
--- a/Source/JavaScriptCore/llint/LLIntSlowPaths.h
+++ b/Source/JavaScriptCore/llint/LLIntSlowPaths.h
@@ -92,6 +92,10 @@
 LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_jnlesseq);
 LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_jgreatereq);
 LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_jngreatereq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_jeq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_jneq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_jstricteq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_jnstricteq);
 LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_switch_imm);
 LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_switch_char);
 LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_switch_string);
diff --git a/Source/JavaScriptCore/llint/LowLevelInterpreter.asm b/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
index d1b3ffd..e81a492 100644
--- a/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
+++ b/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
@@ -1455,6 +1455,20 @@
     dispatch(constexpr op_greatereq_length)
 
 
+_llint_op_eq:
+    traceExecution()
+    equalityComparison(
+        macro (left, right, result) cieq left, right, result end,
+        _slow_path_eq)
+
+
+_llint_op_neq:
+    traceExecution()
+    equalityComparison(
+        macro (left, right, result) cineq left, right, result end,
+        _slow_path_neq)
+
+
 _llint_op_below:
     traceExecution()
     compareUnsigned(
@@ -1578,7 +1592,7 @@
 
 _llint_op_jless:
     traceExecution()
-    compare(
+    compareJump(
         macro (left, right, target) bilt left, right, target end,
         macro (left, right, target) bdlt left, right, target end,
         _llint_slow_path_jless)
@@ -1586,7 +1600,7 @@
 
 _llint_op_jnless:
     traceExecution()
-    compare(
+    compareJump(
         macro (left, right, target) bigteq left, right, target end,
         macro (left, right, target) bdgtequn left, right, target end,
         _llint_slow_path_jnless)
@@ -1594,7 +1608,7 @@
 
 _llint_op_jgreater:
     traceExecution()
-    compare(
+    compareJump(
         macro (left, right, target) bigt left, right, target end,
         macro (left, right, target) bdgt left, right, target end,
         _llint_slow_path_jgreater)
@@ -1602,7 +1616,7 @@
 
 _llint_op_jngreater:
     traceExecution()
-    compare(
+    compareJump(
         macro (left, right, target) bilteq left, right, target end,
         macro (left, right, target) bdltequn left, right, target end,
         _llint_slow_path_jngreater)
@@ -1610,7 +1624,7 @@
 
 _llint_op_jlesseq:
     traceExecution()
-    compare(
+    compareJump(
         macro (left, right, target) bilteq left, right, target end,
         macro (left, right, target) bdlteq left, right, target end,
         _llint_slow_path_jlesseq)
@@ -1618,7 +1632,7 @@
 
 _llint_op_jnlesseq:
     traceExecution()
-    compare(
+    compareJump(
         macro (left, right, target) bigt left, right, target end,
         macro (left, right, target) bdgtun left, right, target end,
         _llint_slow_path_jnlesseq)
@@ -1626,7 +1640,7 @@
 
 _llint_op_jgreatereq:
     traceExecution()
-    compare(
+    compareJump(
         macro (left, right, target) bigteq left, right, target end,
         macro (left, right, target) bdgteq left, right, target end,
         _llint_slow_path_jgreatereq)
@@ -1634,12 +1648,26 @@
 
 _llint_op_jngreatereq:
     traceExecution()
-    compare(
+    compareJump(
         macro (left, right, target) bilt left, right, target end,
         macro (left, right, target) bdltun left, right, target end,
         _llint_slow_path_jngreatereq)
 
 
+_llint_op_jeq:
+    traceExecution()
+    equalityJump(
+        macro (left, right, target) bieq left, right, target end,
+        _llint_slow_path_jeq)
+
+
+_llint_op_jneq:
+    traceExecution()
+    equalityJump(
+        macro (left, right, target) bineq left, right, target end,
+        _llint_slow_path_jneq)
+
+
 _llint_op_jbelow:
     traceExecution()
     compareUnsignedJump(
diff --git a/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm b/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm
index 3361cb9..8f99f5a 100644
--- a/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm
+++ b/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm
@@ -755,8 +755,7 @@
     dispatch(constexpr op_not_length)
 
 
-_llint_op_eq:
-    traceExecution()
+macro equalityComparison(integerComparison, slowPath)
     loadi 12[PC], t2
     loadi 8[PC], t0
     loadConstantOrVariable(t2, t3, t1)
@@ -765,14 +764,35 @@
     bieq t2, CellTag, .opEqSlow
     bib t2, LowestTag, .opEqSlow
     loadi 4[PC], t2
-    cieq t0, t1, t0
+    integerComparison(t0, t1, t0)
     storei BooleanTag, TagOffset[cfr, t2, 8]
     storei t0, PayloadOffset[cfr, t2, 8]
     dispatch(constexpr op_eq_length)
 
 .opEqSlow:
-    callSlowPath(_slow_path_eq)
+    callSlowPath(slowPath)
     dispatch(constexpr op_eq_length)
+end
+
+
+macro equalityJump(integerComparison, slowPath)
+    loadi 8[PC], t2
+    loadi 4[PC], t0
+    loadConstantOrVariable(t2, t3, t1)
+    loadConstantOrVariable2Reg(t0, t2, t0)
+    bineq t2, t3, .slow
+    bieq t2, CellTag, .slow
+    bib t2, LowestTag, .slow
+    integerComparison(t0, t1, .jumpTarget)
+    dispatch(constexpr op_jeq_length)
+
+.jumpTarget:
+    dispatchBranch(12[PC])
+
+.slow:
+    callSlowPath(slowPath)
+    dispatch(0)
+end
 
 
 _llint_op_eq_null:
@@ -802,26 +822,6 @@
     dispatch(constexpr op_eq_null_length)
 
 
-_llint_op_neq:
-    traceExecution()
-    loadi 12[PC], t2
-    loadi 8[PC], t0
-    loadConstantOrVariable(t2, t3, t1)
-    loadConstantOrVariable2Reg(t0, t2, t0)
-    bineq t2, t3, .opNeqSlow
-    bieq t2, CellTag, .opNeqSlow
-    bib t2, LowestTag, .opNeqSlow
-    loadi 4[PC], t2
-    cineq t0, t1, t0
-    storei BooleanTag, TagOffset[cfr, t2, 8]
-    storei t0, PayloadOffset[cfr, t2, 8]
-    dispatch(constexpr op_neq_length)
-
-.opNeqSlow:
-    callSlowPath(_slow_path_neq)
-    dispatch(constexpr op_neq_length)
-    
-
 _llint_op_neq_null:
     traceExecution()
     loadi 8[PC], t0
@@ -871,6 +871,30 @@
     dispatch(4)
 end
 
+
+macro strictEqualityJump(equalityOperation, slowPath)
+    loadi 8[PC], t2
+    loadi 4[PC], t0
+    loadConstantOrVariable(t2, t3, t1)
+    loadConstantOrVariable2Reg(t0, t2, t0)
+    bineq t2, t3, .slow
+    bib t2, LowestTag, .slow
+    bineq t2, CellTag, .notStringOrSymbol
+    bbaeq JSCell::m_type[t0], ObjectType, .notStringOrSymbol
+    bbb JSCell::m_type[t1], ObjectType, .slow
+.notStringOrSymbol:
+    equalityOperation(t0, t1, .jumpTarget)
+    dispatch(constexpr op_jstricteq_length)
+
+.jumpTarget:
+    dispatchBranch(12[PC])
+
+.slow:
+    callSlowPath(slowPath)
+    dispatch(0)
+end
+
+
 _llint_op_stricteq:
     traceExecution()
     strictEq(macro (left, right, result) cieq left, right, result end, _slow_path_stricteq)
@@ -881,6 +905,20 @@
     strictEq(macro (left, right, result) cineq left, right, result end, _slow_path_nstricteq)
 
 
+_llint_op_jstricteq:
+    traceExecution()
+    strictEqualityJump(
+        macro (left, right, target) bieq left, right, target end,
+        _llint_slow_path_jstricteq)
+
+
+_llint_op_jnstricteq:
+    traceExecution()
+    strictEqualityJump(
+        macro (left, right, target) bineq left, right, target end,
+        _llint_slow_path_jnstricteq)
+
+
 _llint_op_inc:
     traceExecution()
     loadi 4[PC], t0
@@ -1826,7 +1864,7 @@
 end
 
 
-macro compare(integerCompare, doubleCompare, slowPath)
+macro compareJump(integerCompare, doubleCompare, slowPath)
     loadi 4[PC], t2
     loadi 8[PC], t3
     loadConstantOrVariable(t2, t0, t1)
diff --git a/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm b/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm
index 8bd50ff..6b250aa 100644
--- a/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm
+++ b/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm
@@ -722,7 +722,6 @@
 
 
 macro equalityComparison(integerComparison, slowPath)
-    traceExecution()
     loadisFromInstruction(3, t0)
     loadisFromInstruction(2, t2)
     loadisFromInstruction(1, t3)
@@ -738,16 +737,22 @@
     dispatch(4)
 end
 
-_llint_op_eq:
-    equalityComparison(
-        macro (left, right, result) cieq left, right, result end,
-        _slow_path_eq)
 
+macro equalityJump(integerComparison, slowPath)
+    loadisFromInstruction(1, t2)
+    loadisFromInstruction(2, t3)
+    loadConstantOrVariableInt32(t2, t0, .slow)
+    loadConstantOrVariableInt32(t3, t1, .slow)
+    integerComparison(t0, t1, .jumpTarget)
+    dispatch(constexpr op_jeq_length)
 
-_llint_op_neq:
-    equalityComparison(
-        macro (left, right, result) cineq left, right, result end,
-        _slow_path_neq)
+.jumpTarget:
+    dispatchIntIndirect(3)
+
+.slow:
+    callSlowPath(slowPath)
+    dispatch(0)
+end
 
 
 macro equalNullComparison()
@@ -788,7 +793,6 @@
 
 
 macro strictEq(equalityOperation, slowPath)
-    traceExecution()
     loadisFromInstruction(3, t0)
     loadisFromInstruction(2, t2)
     loadConstantOrVariable(t0, t1)
@@ -813,18 +817,61 @@
     dispatch(4)
 end
 
+
+macro strictEqualityJump(equalityOperation, slowPath)
+    loadisFromInstruction(1, t2)
+    loadisFromInstruction(2, t3)
+    loadConstantOrVariable(t2, t0)
+    loadConstantOrVariable(t3, t1)
+    move t0, t2
+    orq t1, t2
+    btqz t2, tagMask, .slow
+    bqaeq t0, tagTypeNumber, .leftOK
+    btqnz t0, tagTypeNumber, .slow
+.leftOK:
+    bqaeq t1, tagTypeNumber, .rightOK
+    btqnz t1, tagTypeNumber, .slow
+.rightOK:
+    equalityOperation(t0, t1, .jumpTarget)
+    dispatch(constexpr op_jstricteq_length)
+
+.jumpTarget:
+    dispatchIntIndirect(3)
+
+.slow:
+    callSlowPath(slowPath)
+    dispatch(0)
+end
+
+
 _llint_op_stricteq:
+    traceExecution()
     strictEq(
         macro (left, right, result) cqeq left, right, result end,
         _slow_path_stricteq)
 
 
 _llint_op_nstricteq:
+    traceExecution()
     strictEq(
         macro (left, right, result) cqneq left, right, result end,
         _slow_path_nstricteq)
 
 
+_llint_op_jstricteq:
+    traceExecution()
+    strictEqualityJump(
+        macro (left, right, target) bqeq left, right, target end,
+        _llint_slow_path_jstricteq)
+
+
+_llint_op_jnstricteq:
+    traceExecution()
+    strictEqualityJump(
+        macro (left, right, target) bqneq left, right, target end,
+        _llint_slow_path_jnstricteq)
+
+
 macro preOp(arithmeticOperation, slowPath)
     traceExecution()
     loadisFromInstruction(1, t0)
@@ -1848,7 +1895,7 @@
     dispatchIntIndirect(3)
 
 
-macro compare(integerCompare, doubleCompare, slowPath)
+macro compareJump(integerCompare, doubleCompare, slowPath)
     loadisFromInstruction(1, t2)
     loadisFromInstruction(2, t3)
     loadConstantOrVariable(t2, t0)
@@ -1904,7 +1951,6 @@
 
 
 macro compareUnsigned(integerCompareAndSet)
-    traceExecution()
     loadisFromInstruction(3, t0)
     loadisFromInstruction(2, t2)
     loadisFromInstruction(1, t3)