Unreviewed, rolling out r249721.
authorysuzuki@apple.com <ysuzuki@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 Sep 2019 00:17:03 +0000 (00:17 +0000)
committerysuzuki@apple.com <ysuzuki@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 Sep 2019 00:17:03 +0000 (00:17 +0000)
https://bugs.webkit.org/show_bug.cgi?id=201667

Discovering existing bug (Requested by yusukesuzuki on
#webkit).

Reverted changeset:

"[JSC] 32bit bitwide operation with all-one (-1) is wrong in
B3"
https://bugs.webkit.org/show_bug.cgi?id=201634
https://trac.webkit.org/changeset/249721

Patch by Commit Queue <commit-queue@webkit.org> on 2019-09-10

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@249743 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/b3/B3LowerToAir.cpp
Source/JavaScriptCore/b3/B3ReduceStrength.cpp
Source/JavaScriptCore/b3/testb3.h
Source/JavaScriptCore/b3/testb3_2.cpp
Source/JavaScriptCore/b3/testb3_3.cpp

index 1f7c2ec..6ef876a 100644 (file)
@@ -1,3 +1,18 @@
+2019-09-10  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r249721.
+        https://bugs.webkit.org/show_bug.cgi?id=201667
+
+        Discovering existing bug (Requested by yusukesuzuki on
+        #webkit).
+
+        Reverted changeset:
+
+        "[JSC] 32bit bitwide operation with all-one (-1) is wrong in
+        B3"
+        https://bugs.webkit.org/show_bug.cgi?id=201634
+        https://trac.webkit.org/changeset/249721
+
 2019-09-10  Yusuke Suzuki  <ysuzuki@apple.com>
 
         [JSC] CodeBlock::calleeSaveRegisters should not see half-baked JITData
index 7d6bbb2..3cc75c3 100644 (file)
@@ -2749,7 +2749,7 @@ private:
                 return;
             }
 
-            if (m_value->child(1)->isInt64(0xffffffff) || m_value->child(1)->isInt32(0xffffffff)) {
+            if (m_value->child(1)->isInt(0xffffffff)) {
                 appendUnOp<Move32, Move32>(m_value->child(0));
                 return;
             }
index bf30daa..fdc6ffd 100644 (file)
@@ -1033,8 +1033,8 @@ private:
 
             // Turn this: BitAnd(value, all-ones)
             // Into this: value.
-            if ((m_value->type() == Int64 && m_value->child(1)->isInt64(std::numeric_limits<uint64_t>::max()))
-                || (m_value->type() == Int32 && m_value->child(1)->isInt32(std::numeric_limits<uint32_t>::max()))) {
+            if ((m_value->type() == Int64 && m_value->child(1)->isInt(std::numeric_limits<uint64_t>::max()))
+                || (m_value->type() == Int32 && m_value->child(1)->isInt(std::numeric_limits<uint32_t>::max()))) {
                 replaceWithIdentity(m_value->child(0));
                 break;
             }
@@ -1083,7 +1083,6 @@ private:
             //       and Op is BitOr or BitXor
             // into this: BitAnd(value, constant2)
             if (m_value->child(1)->hasInt()) {
-                bool replaced = false;
                 int64_t constant2 = m_value->child(1)->asInt();
                 switch (m_value->child(0)->opcode()) {
                 case BitOr:
@@ -1092,15 +1091,13 @@ private:
                         && !(m_value->child(0)->child(1)->asInt() & constant2)) {
                         m_value->child(0) = m_value->child(0)->child(0);
                         m_changed = true;
-                        replaced = true;
                         break;
                     }
                     break;
                 default:
                     break;
                 }
-                if (replaced)
-                    break;
+                break;
             }
 
             // Turn this: BitAnd(BitXor(x1, allOnes), BitXor(x2, allOnes)
@@ -1109,11 +1106,11 @@ private:
             if (m_value->child(0)->opcode() == BitXor
                 && m_value->child(1)->opcode() == BitXor
                 && ((m_value->type() == Int64
-                        && m_value->child(0)->child(1)->isInt64(std::numeric_limits<uint64_t>::max())
-                        && m_value->child(1)->child(1)->isInt64(std::numeric_limits<uint64_t>::max()))
+                        && m_value->child(0)->child(1)->isInt(std::numeric_limits<uint64_t>::max())
+                        && m_value->child(1)->child(1)->isInt(std::numeric_limits<uint64_t>::max()))
                     || (m_value->type() == Int32
-                        && m_value->child(0)->child(1)->isInt32(std::numeric_limits<uint32_t>::max())
-                        && m_value->child(1)->child(1)->isInt32(std::numeric_limits<uint32_t>::max())))) {
+                        && m_value->child(0)->child(1)->isInt(std::numeric_limits<uint32_t>::max())
+                        && m_value->child(1)->child(1)->isInt(std::numeric_limits<uint32_t>::max())))) {
                 Value* bitOr = m_insertionSet.insert<Value>(m_index, BitOr, m_value->origin(), m_value->child(0)->child(0), m_value->child(1)->child(0));
                 replaceWithNew<Value>(BitXor, m_value->origin(), bitOr, m_value->child(1)->child(1));
                 break;
@@ -1126,9 +1123,9 @@ private:
             if (m_value->child(0)->opcode() == BitXor
                 && m_value->child(1)->hasInt()
                 && ((m_value->type() == Int64
-                        && m_value->child(0)->child(1)->isInt64(std::numeric_limits<uint64_t>::max()))
+                        && m_value->child(0)->child(1)->isInt(std::numeric_limits<uint64_t>::max()))
                     || (m_value->type() == Int32
-                        && m_value->child(0)->child(1)->isInt32(std::numeric_limits<uint32_t>::max())))) {
+                        && m_value->child(0)->child(1)->isInt(std::numeric_limits<uint32_t>::max())))) {
                 Value* bitOr = m_insertionSet.insert<Value>(m_index, BitOr, m_value->origin(), m_value->child(0)->child(0), m_value->child(1)->bitXorConstant(m_proc, m_value->child(0)->child(1)));
                 replaceWithNew<Value>(BitXor, m_value->origin(), bitOr, m_value->child(0)->child(1));
                 break;
@@ -1174,8 +1171,8 @@ private:
 
             // Turn this: BitOr(value, all-ones)
             // Into this: all-ones.
-            if ((m_value->type() == Int64 && m_value->child(1)->isInt64(std::numeric_limits<uint64_t>::max()))
-                || (m_value->type() == Int32 && m_value->child(1)->isInt32(std::numeric_limits<uint32_t>::max()))) {
+            if ((m_value->type() == Int64 && m_value->child(1)->isInt(std::numeric_limits<uint64_t>::max()))
+                || (m_value->type() == Int32 && m_value->child(1)->isInt(std::numeric_limits<uint32_t>::max()))) {
                 replaceWithIdentity(m_value->child(1));
                 break;
             }
@@ -1186,11 +1183,11 @@ private:
             if (m_value->child(0)->opcode() == BitXor
                 && m_value->child(1)->opcode() == BitXor
                 && ((m_value->type() == Int64
-                        && m_value->child(0)->child(1)->isInt64(std::numeric_limits<uint64_t>::max())
-                        && m_value->child(1)->child(1)->isInt64(std::numeric_limits<uint64_t>::max()))
+                        && m_value->child(0)->child(1)->isInt(std::numeric_limits<uint64_t>::max())
+                        && m_value->child(1)->child(1)->isInt(std::numeric_limits<uint64_t>::max()))
                     || (m_value->type() == Int32
-                        && m_value->child(0)->child(1)->isInt32(std::numeric_limits<uint32_t>::max())
-                        && m_value->child(1)->child(1)->isInt32(std::numeric_limits<uint32_t>::max())))) {
+                        && m_value->child(0)->child(1)->isInt(std::numeric_limits<uint32_t>::max())
+                        && m_value->child(1)->child(1)->isInt(std::numeric_limits<uint32_t>::max())))) {
                 Value* bitAnd = m_insertionSet.insert<Value>(m_index, BitAnd, m_value->origin(), m_value->child(0)->child(0), m_value->child(1)->child(0));
                 replaceWithNew<Value>(BitXor, m_value->origin(), bitAnd, m_value->child(1)->child(1));
                 break;
@@ -1203,9 +1200,9 @@ private:
             if (m_value->child(0)->opcode() == BitXor
                 && m_value->child(1)->hasInt()
                 && ((m_value->type() == Int64
-                        && m_value->child(0)->child(1)->isInt64(std::numeric_limits<uint64_t>::max()))
+                        && m_value->child(0)->child(1)->isInt(std::numeric_limits<uint64_t>::max()))
                     || (m_value->type() == Int32
-                        && m_value->child(0)->child(1)->isInt32(std::numeric_limits<uint32_t>::max())))) {
+                        && m_value->child(0)->child(1)->isInt(std::numeric_limits<uint32_t>::max())))) {
                 Value* bitAnd = m_insertionSet.insert<Value>(m_index, BitAnd, m_value->origin(), m_value->child(0)->child(0), m_value->child(1)->bitXorConstant(m_proc, m_value->child(0)->child(1)));
                 replaceWithNew<Value>(BitXor, m_value->origin(), bitAnd, m_value->child(0)->child(1));
                 break;
index 924c9c5..b504096 100644 (file)
@@ -459,9 +459,7 @@ void testBitOrArgsFloatWithUselessDoubleConversion(float, float);
 void testBitXorArgs(int64_t, int64_t);
 void testBitXorSameArg(int64_t);
 void testBitXorAndAndArgs(int64_t, int64_t, int64_t c);
-void testBitXorAndAndArgs32(int32_t, int32_t, int32_t c);
 void testBitXorAndSameArgs(int64_t, int64_t);
-void testBitXorAndSameArgs32(int32_t, int32_t);
 void testBitXorImms(int64_t, int64_t);
 void testBitXorArgImm(int64_t, int64_t);
 void testBitXorImmArg(int64_t, int64_t);
index 7cb34c8..bc61b54 100644 (file)
@@ -2565,24 +2565,6 @@ static void testBitAndNotNot(int64_t a, int64_t b)
     CHECK_EQ(compileAndRun<int64_t>(proc, a, b), (~a & ~b));
 }
 
-static void testBitAndNotNot32(int32_t a, int32_t b)
-{
-    Procedure proc;
-    BasicBlock* root = proc.addBlock();
-    Value* argA = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
-    Value* argB = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
-    Value* notA = root->appendNew<Value>(proc, BitXor, Origin(), argA, root->appendNew<Const32Value>(proc, Origin(), -1));
-    Value* notB = root->appendNew<Value>(proc, BitXor, Origin(), argB, root->appendNew<Const32Value>(proc, Origin(), -1));
-    root->appendNewControlValue(
-        proc, Return, Origin(),
-        root->appendNew<Value>(
-            proc, BitAnd, Origin(),
-            notA,
-            notB));
-
-    CHECK_EQ(compileAndRun<int32_t>(proc, a, b), (~a & ~b));
-}
-
 static void testBitAndNotImm(int64_t a, int64_t b)
 {
     Procedure proc;
@@ -2597,24 +2579,7 @@ static void testBitAndNotImm(int64_t a, int64_t b)
             notA,
             cstB));
 
-    CHECK_EQ(compileAndRun<int64_t>(proc, a), (~a & b));
-}
-
-static void testBitAndNotImm32(int32_t a, int32_t b)
-{
-    Procedure proc;
-    BasicBlock* root = proc.addBlock();
-    Value* argA = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
-    Value* notA = root->appendNew<Value>(proc, BitXor, Origin(), argA, root->appendNew<Const32Value>(proc, Origin(), -1));
-    Value* cstB = root->appendNew<Const32Value>(proc, Origin(), b);
-    root->appendNewControlValue(
-        proc, Return, Origin(),
-        root->appendNew<Value>(
-            proc, BitAnd, Origin(),
-            notA,
-            cstB));
-
-    CHECK_EQ(compileAndRun<int32_t>(proc, a), (~a & b));
+    CHECK_EQ(compileAndRun<int64_t>(proc, a, b), (~a & b));
 }
 
 static void testBitAndImms(int64_t a, int64_t b)
@@ -3029,34 +2994,6 @@ static void testBitOrAndAndArgs(int64_t a, int64_t b, int64_t c)
     }
 }
 
-static void testBitOrAndAndArgs32(int32_t a, int32_t b, int32_t c)
-{
-    // We want to check every possible ordering of arguments (to properly check every path in B3ReduceStrength):
-    // ((a & b) | (a & c))
-    // ((a & b) | (c & a))
-    // ((b & a) | (a & c))
-    // ((b & a) | (c & a))
-    for (int i = 0; i < 4; ++i) {
-        Procedure proc;
-        BasicBlock* root = proc.addBlock();
-        Value* argA = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
-        Value* argB = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
-        Value* argC = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));
-        Value* andAB = i & 2 ? root->appendNew<Value>(proc, BitAnd, Origin(), argA, argB)
-            : root->appendNew<Value>(proc, BitAnd, Origin(), argB, argA);
-        Value* andAC = i & 1 ? root->appendNew<Value>(proc, BitAnd, Origin(), argA, argC)
-            : root->appendNew<Value>(proc, BitAnd, Origin(), argC, argA);
-        root->appendNewControlValue(
-            proc, Return, Origin(),
-            root->appendNew<Value>(
-                proc, BitOr, Origin(),
-                andAB,
-                andAC));
-
-        CHECK_EQ(compileAndRun<int32_t>(proc, a, b, c), ((a & b) | (a & c)));
-    }
-}
-
 static void testBitOrAndSameArgs(int64_t a, int64_t b)
 {
     // We want to check every possible ordering of arguments (to properly check every path in B3ReduceStrength):
@@ -3079,28 +3016,6 @@ static void testBitOrAndSameArgs(int64_t a, int64_t b)
     }
 }
 
-static void testBitOrAndSameArgs32(int32_t a, int32_t b)
-{
-    // We want to check every possible ordering of arguments (to properly check every path in B3ReduceStrength):
-    // ((a & b) | a)
-    // ((b & a) | a)
-    // (a | (a & b))
-    // (a | (b & a))
-    for (int i = 0; i < 4; ++i) {
-        Procedure proc;
-        BasicBlock* root = proc.addBlock();
-        Value* argA = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
-        Value* argB = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
-        Value* andAB = i & 1 ? root->appendNew<Value>(proc, BitAnd, Origin(), argA, argB)
-            : root->appendNew<Value>(proc, BitAnd, Origin(), argB, argA);
-        Value* result = i & 2 ? root->appendNew<Value>(proc, BitOr, Origin(), andAB, argA)
-            : root->appendNew<Value>(proc, BitOr, Origin(), argA, andAB);
-        root->appendNewControlValue(proc, Return, Origin(), result);
-
-        CHECK_EQ(compileAndRun<int32_t>(proc, a, b), ((a & b) | a));
-    }
-}
-
 static void testBitOrNotNot(int64_t a, int64_t b)
 {
     Procedure proc;
@@ -3119,24 +3034,6 @@ static void testBitOrNotNot(int64_t a, int64_t b)
     CHECK_EQ(compileAndRun<int64_t>(proc, a, b), (~a | ~b));
 }
 
-static void testBitOrNotNot32(int32_t a, int32_t b)
-{
-    Procedure proc;
-    BasicBlock* root = proc.addBlock();
-    Value* argA = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
-    Value* argB = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
-    Value* notA = root->appendNew<Value>(proc, BitXor, Origin(), argA, root->appendNew<Const32Value>(proc, Origin(), -1));
-    Value* notB = root->appendNew<Value>(proc, BitXor, Origin(), argB, root->appendNew<Const32Value>(proc, Origin(), -1));
-    root->appendNewControlValue(
-        proc, Return, Origin(),
-        root->appendNew<Value>(
-            proc, BitOr, Origin(),
-            notA,
-            notB));
-
-    CHECK_EQ(compileAndRun<int32_t>(proc, a, b), (~a | ~b));
-}
-
 static void testBitOrNotImm(int64_t a, int64_t b)
 {
     Procedure proc;
@@ -3154,23 +3051,6 @@ static void testBitOrNotImm(int64_t a, int64_t b)
     CHECK_EQ(compileAndRun<int64_t>(proc, a, b), (~a | b));
 }
 
-static void testBitOrNotImm32(int32_t a, int32_t b)
-{
-    Procedure proc;
-    BasicBlock* root = proc.addBlock();
-    Value* argA = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
-    Value* notA = root->appendNew<Value>(proc, BitXor, Origin(), argA, root->appendNew<Const32Value>(proc, Origin(), -1));
-    Value* cstB = root->appendNew<Const32Value>(proc, Origin(), b);
-    root->appendNewControlValue(
-        proc, Return, Origin(),
-        root->appendNew<Value>(
-            proc, BitOr, Origin(),
-            notA,
-            cstB));
-
-    CHECK_EQ(compileAndRun<int32_t>(proc, a), (~a | b));
-}
-
 static void testBitOrImms(int64_t a, int64_t b)
 {
     Procedure proc;
@@ -3407,9 +3287,7 @@ void addBitTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     RUN_BINARY(testBitAndImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     RUN_BINARY(testBitAndArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     RUN_BINARY(testBitAndNotNot, int64Operands(), int64Operands());
-    RUN_BINARY(testBitAndNotNot32, int32Operands(), int32Operands());
     RUN_BINARY(testBitAndNotImm, int64Operands(), int64Operands());
-    RUN_BINARY(testBitAndNotImm32, int32Operands(), int32Operands());
     
     RUN(testBitOrArgs(43, 43));
     RUN(testBitOrArgs(43, 0));
@@ -3473,13 +3351,9 @@ void addBitTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     RUN_BINARY(testBitOrImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     RUN_BINARY(testBitOrArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     RUN_TERNARY(testBitOrAndAndArgs, int64Operands(), int64Operands(), int64Operands());
-    RUN_TERNARY(testBitOrAndAndArgs32, int32Operands(), int32Operands(), int32Operands());
     RUN_BINARY(testBitOrAndSameArgs, int64Operands(), int64Operands());
-    RUN_BINARY(testBitOrAndSameArgs32, int32Operands(), int32Operands());
     RUN_BINARY(testBitOrNotNot, int64Operands(), int64Operands());
-    RUN_BINARY(testBitOrNotNot32, int32Operands(), int32Operands());
     RUN_BINARY(testBitOrNotImm, int64Operands(), int64Operands());
-    RUN_BINARY(testBitOrNotImm32, int32Operands(), int32Operands());
     
     RUN_BINARY(testBitXorArgs, int64Operands(), int64Operands());
     RUN_UNARY(testBitXorSameArg, int64Operands());
@@ -3519,9 +3393,7 @@ void addBitTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     RUN(testBitXorImmBitXorArgImm32(6, 1, 6));
     RUN(testBitXorImmBitXorArgImm32(24, 0xffff, 7));
     RUN_TERNARY(testBitXorAndAndArgs, int64Operands(), int64Operands(), int64Operands());
-    RUN_TERNARY(testBitXorAndAndArgs32, int32Operands(), int32Operands(), int32Operands());
     RUN_BINARY(testBitXorAndSameArgs, int64Operands(), int64Operands());
-    RUN_BINARY(testBitXorAndSameArgs32, int32Operands(), int32Operands());
     
     RUN_UNARY(testBitNotArg, int64Operands());
     RUN_UNARY(testBitNotImm, int64Operands());
index 7091672..336c822 100644 (file)
@@ -259,34 +259,6 @@ void testBitXorAndAndArgs(int64_t a, int64_t b, int64_t c)
     }
 }
 
-void testBitXorAndAndArgs32(int32_t a, int32_t b, int32_t c)
-{
-    // We want to check every possible ordering of arguments (to properly check every path in B3ReduceStrength):
-    // ((a & b) ^ (a & c))
-    // ((a & b) ^ (c & a))
-    // ((b & a) ^ (a & c))
-    // ((b & a) ^ (c & a))
-    for (int i = 0; i < 4; ++i) {
-        Procedure proc;
-        BasicBlock* root = proc.addBlock();
-        Value* argA = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
-        Value* argB = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
-        Value* argC = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR2));
-        Value* andAB = i & 2 ? root->appendNew<Value>(proc, BitAnd, Origin(), argA, argB)
-            : root->appendNew<Value>(proc, BitAnd, Origin(), argB, argA);
-        Value* andAC = i & 1 ? root->appendNew<Value>(proc, BitAnd, Origin(), argA, argC)
-            : root->appendNew<Value>(proc, BitAnd, Origin(), argC, argA);
-        root->appendNewControlValue(
-            proc, Return, Origin(),
-            root->appendNew<Value>(
-                proc, BitXor, Origin(),
-                andAB,
-                andAC));
-
-        CHECK_EQ(compileAndRun<int32_t>(proc, a, b, c), ((a & b) ^ (a & c)));
-    }
-}
-
 void testBitXorAndSameArgs(int64_t a, int64_t b)
 {
     // We want to check every possible ordering of arguments (to properly check every path in B3ReduceStrength):
@@ -309,28 +281,6 @@ void testBitXorAndSameArgs(int64_t a, int64_t b)
     }
 }
 
-void testBitXorAndSameArgs32(int32_t a, int32_t b)
-{
-    // We want to check every possible ordering of arguments (to properly check every path in B3ReduceStrength):
-    // ((a & b) ^ a)
-    // ((b & a) ^ a)
-    // (a ^ (a & b))
-    // (a ^ (b & a))
-    for (int i = 0; i < 4; ++i) {
-        Procedure proc;
-        BasicBlock* root = proc.addBlock();
-        Value* argA = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
-        Value* argB = root->appendNew<Value>(proc, Trunc, Origin(), root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
-        Value* andAB = i & 1 ? root->appendNew<Value>(proc, BitAnd, Origin(), argA, argB)
-            : root->appendNew<Value>(proc, BitAnd, Origin(), argB, argA);
-        Value* result = i & 2 ? root->appendNew<Value>(proc, BitXor, Origin(), andAB, argA)
-            : root->appendNew<Value>(proc, BitXor, Origin(), argA, andAB);
-        root->appendNewControlValue(proc, Return, Origin(), result);
-
-        CHECK_EQ(compileAndRun<int32_t>(proc, a, b), ((a & b) ^ a));
-    }
-}
-
 void testBitXorImms(int64_t a, int64_t b)
 {
     Procedure proc;