test

src/coreclr/jit/assertionprop.cpp

@@ -2195,6 +2195,8 @@ AssertionInfo Compiler::optCreateJTrueBoundsAssertion(GenTree* tree)
     bool hasTestAgainstZero =
         (relop->gtOper == GT_EQ || relop->gtOper == GT_NE) && (op2VN == vnStore->VNZeroForType(op2->TypeGet()));
 
+    bool isUnsignedRelop = false;
+
     ValueNumStore::UnsignedCompareCheckedBoundInfo unsignedCompareBnd;
     // Cases where op1 holds the upper bound arithmetic and op2 is 0.
     // Loop condition like: "i < bnd +/-k == 0"
@@ -2293,7 +2295,7 @@ AssertionInfo Compiler::optCreateJTrueBoundsAssertion(GenTree* tree)
     // Cases where op1 holds the condition bound check and op2 is 0.
     // Loop condition like: "i < 100 == 0"
     // Assertion: "i < 100 == false"
-    else if (hasTestAgainstZero && vnStore->IsVNConstantBound(op1VN))
+    else if (hasTestAgainstZero && vnStore->IsVNConstantBound(op1VN, &isUnsignedRelop) && !isUnsignedRelop)
     {
         AssertionDsc dsc;
         dsc.assertionKind    = relop->gtOper == GT_EQ ? OAK_EQUAL : OAK_NOT_EQUAL;
@@ -2310,7 +2312,7 @@ AssertionInfo Compiler::optCreateJTrueBoundsAssertion(GenTree* tree)
     // Cases where op1 holds the lhs of the condition op2 holds rhs.
     // Loop condition like "i < 100"
     // Assertion: "i < 100 != 0"
-    else if (vnStore->IsVNConstantBound(relopVN))
+    else if (vnStore->IsVNConstantBound(relopVN, &isUnsignedRelop))
     {
         AssertionDsc dsc;
         dsc.assertionKind    = OAK_NOT_EQUAL;

src/coreclr/jit/valuenum.cpp

@@ -4771,14 +4771,17 @@ bool ValueNumStore::IsVNRelop(ValueNum vn)
     }
 }
 
-bool ValueNumStore::IsVNConstantBound(ValueNum vn)
+bool ValueNumStore::IsVNConstantBound(ValueNum vn, bool* viaUnsigned)
 {
+    assert(viaUnsigned);
+
     VNFuncApp funcApp;
     if ((vn != NoVN) && GetVNFunc(vn, &funcApp))
     {
         if ((funcApp.m_func == (VNFunc)GT_LE) || (funcApp.m_func == (VNFunc)GT_GE) ||
             (funcApp.m_func == (VNFunc)GT_LT) || (funcApp.m_func == (VNFunc)GT_GT))
         {
+            *viaUnsigned          = false;
             const bool op1IsConst = IsVNInt32Constant(funcApp.m_args[0]);
             const bool op2IsConst = IsVNInt32Constant(funcApp.m_args[1]);
             return op1IsConst != op2IsConst;
@@ -4790,12 +4793,14 @@ bool ValueNumStore::IsVNConstantBound(ValueNum vn)
         {
             // (uint)index < CNS
             // (uint)index >= CNS
+            *viaUnsigned = true;
             return (funcApp.m_func == VNF_LT_UN) || (funcApp.m_func == VNF_GE_UN);
         }
         else if (op1IsPositiveConst && !op2IsPositiveConst)
         {
             // CNS > (uint)index
             // CNS <= (uint)index
+            *viaUnsigned = true;
             return (funcApp.m_func == VNF_GT_UN) || (funcApp.m_func == VNF_LE_UN);
         }
     }
@@ -4804,42 +4809,36 @@ bool ValueNumStore::IsVNConstantBound(ValueNum vn)
 
 void ValueNumStore::GetConstantBoundInfo(ValueNum vn, ConstantBoundInfo* info)
 {
-    assert(IsVNConstantBound(vn));
+    bool viaUnsigned = false;
+    assert(IsVNConstantBound(vn, &viaUnsigned));
     assert(info);
 
     VNFuncApp funcAttr;
     GetVNFunc(vn, &funcAttr);
 
-    bool isOp1Const = IsVNInt32Constant(funcAttr.m_args[1]);
-
+    bool       isUnsigned = true;
     genTreeOps op;
-    if (funcAttr.m_func == VNF_GT_UN)
+    switch (funcAttr.m_func)
     {
-        op               = GT_GT;
-        info->isUnsigned = true;
-    }
-    else if (funcAttr.m_func == VNF_GE_UN)
-    {
-        op               = GT_GE;
-        info->isUnsigned = true;
-    }
-    else if (funcAttr.m_func == VNF_LT_UN)
-    {
-        op               = GT_LT;
-        info->isUnsigned = true;
-    }
-    else if (funcAttr.m_func == VNF_LE_UN)
-    {
-        op               = GT_LE;
-        info->isUnsigned = true;
-    }
-    else
-    {
-        op               = (genTreeOps)funcAttr.m_func;
-        info->isUnsigned = false;
+        case VNF_GT_UN:
+            op = GT_GT;
+            break;
+        case VNF_GE_UN:
+            op = GT_GE;
+            break;
+        case VNF_LT_UN:
+            op = GT_LT;
+            break;
+        case VNF_LE_UN:
+            op = GT_LE;
+            break;
+        default:
+            op         = (genTreeOps)funcAttr.m_func;
+            isUnsigned = false;
+            break;
     }
 
-    if (isOp1Const)
+    if (IsVNInt32Constant(funcAttr.m_args[1]))
     {
         info->cmpOper  = op;
         info->cmpOpVN  = funcAttr.m_args[0];
@@ -4851,6 +4850,7 @@ void ValueNumStore::GetConstantBoundInfo(ValueNum vn, ConstantBoundInfo* info)
         info->cmpOpVN  = funcAttr.m_args[1];
         info->constVal = GetConstantInt32(funcAttr.m_args[0]);
     }
+    info->isUnsigned = isUnsigned;
 }
 
 //------------------------------------------------------------------------

src/coreclr/jit/valuenum.h

@@ -798,7 +798,7 @@ class ValueNumStore
     ValueNum GetArrForLenVn(ValueNum vn);
 
     // Return true with any Relop except for == and !=  and one operand has to be a 32-bit integer constant.
-    bool IsVNConstantBound(ValueNum vn);
+    bool IsVNConstantBound(ValueNum vn, bool* viaUnsigned);
 
     // If "vn" is constant bound, then populate the "info" fields for constVal, cmpOp, cmpOper.
     void GetConstantBoundInfo(ValueNum vn, ConstantBoundInfo* info);