Fix Unnecessary sign-extension for (nuint)span.Length

src/coreclr/jit/assertionprop.cpp

@@ -168,6 +168,25 @@ bool IntegralRange::Contains(int64_t value) const
             }
             break;
 
+        case GT_IND:
+        {
+#if defined(_WIN64)
+            if (node->gtGetOp1()->OperGet() == GT_ADD
+                && node->gtGetOp1()->gtGetOp1()->OperGet() == GT_LCL_VAR
+                && node->gtGetOp1()->gtGetOp2()->IsIntegralConst(OFFSETOF__CORINFO_Span__length))
+            {
+                GenTreeLclVar* const lclVar = node->gtGetOp1()->gtGetOp1()->AsLclVar();
+                if (lclVar->IsSpan(compiler))
+                {
+                    // TODO: this check can be moved inside isSpan?
+                    assert(compiler->lvaIsImplicitByRefLocal(lclVar->GetLclNum()));
+                    return {SymbolicIntegerValue::Zero, UpperBoundForType(rangeType)};
+                }
+            }
+#endif // _WIN64
+            break;
+        }
+
         case GT_LCL_VAR:
         {
             LclVarDsc* const varDsc = compiler->lvaGetDesc(node->AsLclVar());

src/coreclr/jit/compiler.h

@@ -653,6 +653,8 @@ class LclVarDsc
 private:
     unsigned char lvIsNeverNegative : 1; // The local is known to be never negative
 
+    unsigned char lvIsSpan : 1; // The local is a Span<T>
+
 public:
     union {
         unsigned lvFieldLclStart; // The index of the local var representing the first field in the promoted struct
@@ -956,6 +958,18 @@ class LclVarDsc
         lvIsNeverNegative = value;
     }
 
+    // Is this is local a Span<T>?
+    bool IsSpan() const
+    {
+        return lvIsSpan;
+    }
+
+    // Is this is local a Span<T>?
+    void SetIsSpan(bool value)
+    {
+        lvIsSpan = value;
+    }
+
     /////////////////////
 
     regNumber GetArgInitReg() const

src/coreclr/jit/gentree.cpp

@@ -26020,6 +26020,21 @@ bool GenTreeLclVar::IsNeverNegative(Compiler* comp) const
     return comp->lvaGetDesc(GetLclNum())->IsNeverNegative();
 }
 
+//------------------------------------------------------------------------
+// GenTreeLclVar::IsSpan: Gets true if the lcl var is a Span<T>; otherwise false.
+//
+// Arguments:
+//    comp - the compiler instance
+//
+// Return Value:
+//    true if the lcl var is a Span<T>; otherwise false.
+//
+bool GenTreeLclVar::IsSpan(Compiler* comp) const
+{
+    assert(OperIs(GT_LCL_VAR));
+    return comp->lvaGetDesc(GetLclNum())->IsSpan();
+}
+
 #if defined(TARGET_XARCH) && defined(FEATURE_HW_INTRINSICS)
 //------------------------------------------------------------------------
 // GetResultOpNumForRmwIntrinsic: check if the result is written into one of the operands.

src/coreclr/jit/gentree.h

@@ -3648,6 +3648,8 @@ struct GenTreeLclVar : public GenTreeLclVarCommon
 
     bool IsNeverNegative(Compiler* comp) const;
 
+    bool IsSpan(Compiler* comp) const;
+
     //-------------------------------------------------------------------
     // clearOtherRegFlags: clear GTF_* flags associated with gtOtherRegs
     //

src/coreclr/jit/lclmorph.cpp

@@ -1242,7 +1242,13 @@ class LocalAddressVisitor final : public GenTreeVisitor<LocalAddressVisitor>
 
         if (addr->IsLclVarAddr())
         {
-            const LclVarDsc* varDsc = m_compiler->lvaGetDesc(addr->AsLclVarCommon());
+            LclVarDsc* varDsc = m_compiler->lvaGetDesc(addr->AsLclVarCommon());
+
+            // addr is a span field so this lclVar must be a span
+            if (isSpanLength)
+            {
+                varDsc->SetIsSpan(true);
+            }
 
             if (varDsc->lvPromoted)
             {
@@ -1256,18 +1262,19 @@ class LocalAddressVisitor final : public GenTreeVisitor<LocalAddressVisitor>
 
                 LclVarDsc* fieldVarDsc = m_compiler->lvaGetDesc(fieldLclNum);
 
+                // Span's Length is never negative unconditionally
+                if (isSpanLength && (accessSize == genTypeSize(TYP_INT)))
+                {
+                    fieldVarDsc->SetIsNeverNegative(true);
+                }
+
                 // Retargeting the indirection to reference the promoted field would make it "wide", exposing
                 // the whole parent struct (with all of its fields).
                 if (accessSize > genTypeSize(fieldVarDsc))
                 {
                     return BAD_VAR_NUM;
                 }
 
-                if (isSpanLength && (accessSize == genTypeSize(TYP_INT)))
-                {
-                    fieldVarDsc->SetIsNeverNegative(true);
-                }
-
                 JITDUMP("Replacing the field in promoted struct with local var V%02u\n", fieldLclNum);
                 m_stmtModified = true;