Fix unsigned compares && reduce chain check recursion

src/coreclr/jit/codegenarm64.cpp

@@ -2579,6 +2579,7 @@ void CodeGen::genCodeForBinary(GenTreeOp* tree)
 
         // Move the result from flags into a register.
         genTreeOps opCond = GT_EQ;
+        bool isUnsigned = false;
         switch (cond)
         {
             case INS_COND_EQ:
@@ -2599,10 +2600,26 @@ void CodeGen::genCodeForBinary(GenTreeOp* tree)
             case INS_COND_LE:
                 opCond = GT_LE;
                 break;
+            case INS_COND_HS:
+                isUnsigned = true;
+                opCond = GT_GE;
+                break;
+            case INS_COND_HI:
+                isUnsigned = true;
+                opCond = GT_GT;
+                break;
+            case INS_COND_LO:
+                isUnsigned = true;
+                opCond = GT_LT;
+                break;
+            case INS_COND_LS:
+                isUnsigned = true;
+                opCond = GT_LE;
+                break;
             default:
                 assert(!"Unexpected cond");
         }
-        inst_SETCC(GenCondition::FromIntegralRelop(opCond, false), tree->TypeGet(), targetReg);
+        inst_SETCC(GenCondition::FromIntegralRelop(opCond, isUnsigned), tree->TypeGet(), targetReg);
         genProduceReg(tree);
         return;
     }
@@ -10603,13 +10620,13 @@ insCond CodeGen::InsCondForCompareOp(GenTree* tree)
         case GT_TEST_NE:
             return INS_COND_NE;
         case GT_GE:
-            return INS_COND_GE;
+            return tree->IsUnsigned() ? INS_COND_HS : INS_COND_GE;
         case GT_GT:
-            return INS_COND_GT;
+            return tree->IsUnsigned() ? INS_COND_HI : INS_COND_GT;
         case GT_LT:
-            return INS_COND_LT;
+            return tree->IsUnsigned() ? INS_COND_LO : INS_COND_LT;
         case GT_LE:
-            return INS_COND_LE;
+            return tree->IsUnsigned() ? INS_COND_LS : INS_COND_LE;
         default:
             assert(false && "Invalid condition");
             return INS_COND_EQ;
@@ -10638,6 +10655,14 @@ insCond CodeGen::InvertInsCond(insCond cond)
             return INS_COND_GE;
         case INS_COND_LE:
             return INS_COND_GT;
+        case INS_COND_HS:
+            return INS_COND_LO;
+        case INS_COND_HI:
+            return INS_COND_LS;
+        case INS_COND_LO:
+            return INS_COND_HS;
+        case INS_COND_LS:
+            return INS_COND_HI;
         default:
             assert(false && "Invalid condition");
             return INS_COND_EQ;
@@ -10673,6 +10698,14 @@ insCflags CodeGen::InsCflagsForCcmp(insCond cond)
             return INS_FLAGS_NC;
         case INS_COND_LE:
             return INS_FLAGS_NZC;
+        case INS_COND_HS:
+            return INS_FLAGS_C;
+        case INS_COND_HI:
+            return INS_FLAGS_C;
+        case INS_COND_LO:
+            return INS_FLAGS_NONE;
+        case INS_COND_LS:
+            return INS_FLAGS_Z;
         default:
             assert(false && "Invalid condition");
             return INS_FLAGS_NONE;

src/coreclr/jit/lower.cpp

@@ -7080,21 +7080,27 @@ int Lowering::CompareChainSize(GenTree* child, GenTree* parent, bool* inChain)
 // Arguments:
 //    child - pointer to the node being checked.
 //    parent - parent node of the child.
-//    earliestValid - If found, returns the earliest valid op in the chain.
+//    startOfChain - If found, returns the earliest valid op in the chain.
 //
-bool Lowering::ContainCheckCompareChain(GenTree* child, GenTree* parent, GenTree** earliestValid)
+bool Lowering::ContainCheckCompareChain(GenTree* child, GenTree* parent, GenTree** startOfChain)
 {
     assert(parent->OperIs(GT_AND) || parent->OperIs(GT_SELECT));
 
-    // Can the child compare be contained.
-    if (IsSafeToContainMem(parent, child))
+    if (child->isContainedAndNotIntOrIImmed())
+    {
+        // Already have a chain.
+        *startOfChain = nullptr;
+        return true;
+    }
+    // Can the child be contained.
+    else if (IsSafeToContainMem(parent, child))
     {
         if (child->OperIs(GT_AND))
         {
             // If Op2 is not contained, then try to contain it.
             if (!child->AsOp()->gtGetOp2()->isContainedAndNotIntOrIImmed())
             {
-                if (!ContainCheckCompareChain(child->gtGetOp2(), child, earliestValid))
+                if (!ContainCheckCompareChain(child->gtGetOp2(), child, startOfChain))
                 {
                     // Op2 must be contained in order to contain Op1 or the AND.
                     return false;
@@ -7104,7 +7110,7 @@ bool Lowering::ContainCheckCompareChain(GenTree* child, GenTree* parent, GenTree
             // If Op1 is not contained, then try to contain it.
             if (!child->AsOp()->gtGetOp1()->isContainedAndNotIntOrIImmed())
             {
-                if (!ContainCheckCompareChain(child->gtGetOp1(), child, earliestValid))
+                if (!ContainCheckCompareChain(child->gtGetOp1(), child, startOfChain))
                 {
                     return false;
                 }
@@ -7117,14 +7123,13 @@ bool Lowering::ContainCheckCompareChain(GenTree* child, GenTree* parent, GenTree
 #ifdef TARGET_ARM64
         else if (child->OperIsCompare())
         {
-
             child->AsOp()->SetContained();
 
             // Ensure the children of the compare are contained correctly.
             child->AsOp()->gtGetOp1()->ClearContained();
             child->AsOp()->gtGetOp2()->ClearContained();
             ContainCheckConditionalCompare(child->AsOp());
-            *earliestValid = child;
+            *startOfChain = child;
             return true;
         }
 #endif
@@ -7203,16 +7208,16 @@ void Lowering::ContainCheckSelect(GenTreeConditional* node)
     }
 
     // Check if the compare does not need to be generated into a register.
-    GenTree* earliestValid = nullptr;
-    ContainCheckCompareChain(node->gtCond, node, &earliestValid);
+    GenTree* startOfChain = nullptr;
+    ContainCheckCompareChain(node->gtCond, node, &startOfChain);
 
-    if (earliestValid != nullptr)
+    if (startOfChain != nullptr)
     {
         // The earliest node in the chain will be generated as a standard compare.
-        assert(earliestValid->OperIsCompare());
-        earliestValid->AsOp()->gtGetOp1()->ClearContained();
-        earliestValid->AsOp()->gtGetOp2()->ClearContained();
-        ContainCheckCompare(earliestValid->AsOp());
+        assert(startOfChain->OperIsCompare());
+        startOfChain->AsOp()->gtGetOp1()->ClearContained();
+        startOfChain->AsOp()->gtGetOp2()->ClearContained();
+        ContainCheckCompare(startOfChain->AsOp());
     }
 }