Optimize bools: hoisted jump destination check to optOptimizeBools() …

…and added test cases

src/coreclr/jit/compiler.h

@@ -80,7 +80,6 @@ class Instrumentor;        // defined in fgprofile.cpp
 class SpanningTreeVisitor; // defined in fgprofile.cpp
 class CSE_DataFlow;        // defined in OptCSE.cpp
 class OptBoolsDsc;         // defined in optimizer.cpp
-struct OptTestInfo;
 #ifdef DEBUG
 struct IndentStack;
 #endif

src/coreclr/jit/optimizer.cpp

@@ -7701,7 +7701,37 @@ bool OptBoolsDsc::optOptimizeBoolsCondBlock()
     // Check if m_b1 and m_b2 jump to the same target and get back pointers to m_testInfo1 and t2 tree nodes
 
     m_t3         = nullptr;
-    m_sameTarget = false; // Do m_b1 and m_b2 have the same bbJumpDest?
+
+    // Check if m_b1 and m_b2 have the same bbJumpDest
+
+    if (m_b1->bbJumpDest == m_b2->bbJumpDest)
+    {
+        // Given the following sequence of blocks :
+        //        B1: brtrue(t1, BX)
+        //        B2: brtrue(t2, BX)
+        //        B3:
+        // we will try to fold it to :
+        //        B1: brtrue(t1|t2, BX)
+        //        B3:
+
+        m_sameTarget = true;
+    }
+    else if (m_b1->bbJumpDest == m_b2->bbNext)
+    {
+        // Given the following sequence of blocks :
+        //        B1: brtrue(t1, B3)
+        //        B2: brtrue(t2, BX)
+        //        B3:
+        // we will try to fold it to :
+        //        B1: brtrue((!t1)&&t2, BX)
+        //        B3:
+
+        m_sameTarget = false;
+    }
+    else
+    {
+        return false;
+    }
 
     Statement* const s1 = optOptimizeBoolsChkBlkCond();
     if (s1 == nullptr)
@@ -7852,54 +7882,6 @@ Statement* OptBoolsDsc::optOptimizeBoolsChkBlkCond()
         optReturnBlock = true;
     }
 
-    // Check jump destination condition
-
-    if (!optReturnBlock)
-    {
-        if (m_b1->bbJumpDest == m_b2->bbJumpDest)
-        {
-            // Given the following sequence of blocks :
-            //        B1: brtrue(t1, BX)
-            //        B2: brtrue(t2, BX)
-            //        B3:
-            // we will try to fold it to :
-            //        B1: brtrue(t1|t2, BX)
-            //        B3:
-
-            m_sameTarget = true;
-        }
-        else if (m_b1->bbJumpDest == m_b2->bbNext)
-        {
-            // Given the following sequence of blocks :
-            //        B1: brtrue(t1, B3)
-            //        B2: brtrue(t2, BX)
-            //        B3:
-            // we will try to fold it to :
-            //        B1: brtrue((!t1)&&t2, BX)
-            //        B3:
-
-            m_sameTarget = false;
-        }
-        else
-        {
-            return nullptr;
-        }
-    }
-    else
-    {
-        // Does m_b1 jump to m_b3?
-        // One example: Given the following sequence of blocks :
-        //        B1: brtrue(!t1, B3)
-        //        B2: return(t2)
-        //        B3: return(false)
-        //    we will try to fold it to :
-        //        B1: return(t1|t2)
-        if (m_b1->bbJumpDest != m_b3)
-        {
-            return nullptr;
-        }
-    }
-
     // Find the block conditions of m_b1 and m_b2
 
     if (m_b2->countOfInEdges() > 1 || (optReturnBlock && m_b3->countOfInEdges() > 1))
@@ -8582,12 +8564,18 @@ void Compiler::optOptimizeBools()
 
             if (b2->bbJumpKind == BBJ_COND)
             {
+                if ((b1->bbJumpDest != b2->bbJumpDest) && (b1->bbJumpDest != b2->bbNext))
+                {
+                    continue;
+                }
+
                 // When it is conditional jumps
                 OptBoolsDsc optBoolsDsc;
                 optBoolsDsc.m_b1   = b1;
                 optBoolsDsc.m_b2   = b2;
                 optBoolsDsc.m_b3   = nullptr;
                 optBoolsDsc.m_comp = this;
+
                 if (optBoolsDsc.optOptimizeBoolsCondBlock())
                 {
                     change = true;

src/tests/JIT/opt/OptimizeBools/optboolsreturn.cs

@@ -63,7 +63,25 @@ public static int Main()
 
         if (!AreZero(0, 0))
         {
-            Console.WriteLine("CBoolTest:AreZero failed");
+            Console.WriteLine("CBoolTest:AreZero(0, 0) failed");
+            return 101;
+        }
+
+        if (AreZero(1, 1))
+        {
+            Console.WriteLine("CBoolTest:AreZero(1, 1) failed");
+            return 101;
+        }
+
+        if (AreZero(0, 2))
+        {
+            Console.WriteLine("CBoolTest:AreZero(0, 2) failed");
+            return 101;
+        }
+
+        if (AreZero(3, 0))
+        {
+            Console.WriteLine("CBoolTest:AreZero(3, 0) failed");
             return 101;
         }
 
@@ -79,27 +97,39 @@ public static int Main()
             return 101;
         }
 
-        if (AreZero(1, 1))
+        if (!AreZero2(0, 0))
         {
-            Console.WriteLine("CBoolTest:AreZero(1, 1) failed");
+            Console.WriteLine("CBoolTest:AreZero2(0, 0) failed");
             return 101;
         }
 
-        if (!AreZero2(0, 0))
+        if (AreZero2(2, 1))
         {
-            Console.WriteLine("CBoolTest:AreZero2 failed");
+            Console.WriteLine("CBoolTest:AreZero2(2, 1) failed");
             return 101;
         }
 
         if (!AreZero3(0, 0, 0))
         {
-            Console.WriteLine("CBoolTest:AreZero3 failed");
+            Console.WriteLine("CBoolTest:AreZero3(0, 0, 0) failed");
+            return 101;
+        }
+
+        if (AreZero3(0, 1, 2))
+        {
+            Console.WriteLine("CBoolTest:AreZero3(0, 1, 2) failed");
             return 101;
         }
 
         if (!AreZero4(0, 0, 0, 0))
         {
-            Console.WriteLine("CBoolTest:AreZero4 failed");
+            Console.WriteLine("CBoolTest:AreZero4(0, 0, 0, 0) failed");
+            return 101;
+        }
+
+        if (AreZero4(0, 1, 2, 3))
+        {
+            Console.WriteLine("CBoolTest:AreZero4(0, 1, 2, 3) failed");
             return 101;
         }
 
@@ -108,21 +138,42 @@ public static int Main()
         // Test if ANDing or GT_NE requires both operands to be boolean
         if (!AreOne(1, 1))
         {
-            Console.WriteLine("CBoolTest:AreOne failed");
+            Console.WriteLine("CBoolTest:AreOne(1, 1) failed");
+            return 101;
+        }
+
+        // Skip cases where x or y is greather than 1
+        if (AreOne(3, 1))
+        {
+            Console.WriteLine("CBoolTest:AreOne(1, 3) failed");
             return 101;
         }
 
         // Test if ANDing requires both operands to be boolean
         if (!IsEitherZero(0, 1))
         {
-            Console.WriteLine("CBoolTest:IsEitherZero failed");
+            Console.WriteLine("CBoolTest:IsEitherZero(0, 1) failed");
+            return 101;
+        }
+
+        // Skip cases where x and y have opposite bits set
+        if (IsEitherZero(2, 1))
+        {
+            Console.WriteLine("CBoolTest:IsEitherZero(2, 1) failed");
             return 101;
         }
 
         // Test if GT_NE requires both operands to be boolean
         if (!IsEitherOne(0, 1))
         {
-            Console.WriteLine("CBoolTest:IsEitherOne failed");
+            Console.WriteLine("CBoolTest:IsEitherOne(0, 1) failed");
+            return 101;
+        }
+
+        // Skip cases where either x or y is greater than 1
+        if (IsEitherOne(2, 0))
+        {
+            Console.WriteLine("CBoolTest:IsEitherOne(2, 0) failed");
             return 101;
         }