JIT: Extend escape analysis to account for arrays with non-gcref elements

src/coreclr/jit/assertionprop.cpp

@@ -170,16 +170,22 @@ bool IntegralRange::Contains(int64_t value) const
         {
             GenTree* const addr = node->AsIndir()->Addr();
 
-            if (node->TypeIs(TYP_INT) && addr->OperIs(GT_ADD) && addr->gtGetOp1()->OperIs(GT_LCL_VAR) &&
-                addr->gtGetOp2()->IsIntegralConst(OFFSETOF__CORINFO_Span__length))
+            if (node->TypeIs(TYP_INT) && addr->OperIs(GT_ADD) && addr->gtGetOp1()->OperIs(GT_LCL_VAR))
             {
                 GenTreeLclVar* const lclVar = addr->gtGetOp1()->AsLclVar();
 
-                if (compiler->lvaGetDesc(lclVar->GetLclNum())->IsSpan())
+                if (addr->gtGetOp2()->IsIntegralConst(OFFSETOF__CORINFO_Span__length) &&
+                    compiler->lvaGetDesc(lclVar->GetLclNum())->IsSpan())
                 {
                     assert(compiler->lvaIsImplicitByRefLocal(lclVar->GetLclNum()));
                     return {SymbolicIntegerValue::Zero, UpperBoundForType(rangeType)};
                 }
+
+                if (addr->gtGetOp2()->IsIntegralConst(OFFSETOF__CORINFO_Array__length) &&
+                    compiler->lvaGetDesc(lclVar->GetLclNum())->lvStackAllocatedArray == 1)
+                {
+                    return {SymbolicIntegerValue::Zero, SymbolicIntegerValue::ArrayLenMax};
+                }
             }
             break;
         }
@@ -189,9 +195,17 @@ bool IntegralRange::Contains(int64_t value) const
             GenTreeLclFld* const lclFld = node->AsLclFld();
             LclVarDsc* const     varDsc = compiler->lvaGetDesc(lclFld);
 
-            if (node->TypeIs(TYP_INT) && varDsc->IsSpan() && lclFld->GetLclOffs() == OFFSETOF__CORINFO_Span__length)
+            if (node->TypeIs(TYP_INT))
             {
-                return {SymbolicIntegerValue::Zero, UpperBoundForType(rangeType)};
+                if (varDsc->IsSpan() && lclFld->GetLclOffs() == OFFSETOF__CORINFO_Span__length)
+                {
+                    return {SymbolicIntegerValue::Zero, UpperBoundForType(rangeType)};
+                }
+
+                if (varDsc->lvStackAllocatedArray == 1 && lclFld->GetLclOffs() == OFFSETOF__CORINFO_Array__length)
+                {
+                    return {SymbolicIntegerValue::Zero, SymbolicIntegerValue::ArrayLenMax};
+                }
             }
 
             break;

src/coreclr/jit/compiler.h

@@ -690,8 +690,9 @@ class LclVarDsc
     unsigned char lvSingleDefDisqualifyReason = 'H';
 #endif
 
-    unsigned char lvAllDefsAreNoGc    : 1; // For pinned locals: true if all defs of this local are no-gc
-    unsigned char lvStackAllocatedBox : 1; // Local is a stack allocated box
+    unsigned char lvAllDefsAreNoGc      : 1; // For pinned locals: true if all defs of this local are no-gc
+    unsigned char lvStackAllocatedBox   : 1; // Local is a stack allocated box
+    unsigned char lvStackAllocatedArray : 1; // Local is a stack allocated array
 
 #if FEATURE_MULTIREG_ARGS
     regNumber lvRegNumForSlot(unsigned slotNum)

src/coreclr/jit/fgdiagnostic.cpp

@@ -955,6 +955,10 @@ bool Compiler::fgDumpFlowGraph(Phases phase, PhasePosition pos)
             {
                 fprintf(fgxFile, "\n            hot=\"true\"");
             }
+            if (block->HasFlag(BBF_HAS_NEWARR))
+            {
+                fprintf(fgxFile, "\n            callsNewArr=\"true\"");
+            }
             if (block->HasFlag(BBF_HAS_NEWOBJ))
             {
                 fprintf(fgxFile, "\n            callsNew=\"true\"");

src/coreclr/jit/gentree.h

@@ -7586,12 +7586,12 @@ struct GenTreeArrAddr : GenTreeUnOp
 
 public:
     GenTreeArrAddr(GenTree* addr, var_types elemType, CORINFO_CLASS_HANDLE elemClassHandle, uint8_t firstElemOffset)
-        : GenTreeUnOp(GT_ARR_ADDR, TYP_BYREF, addr DEBUGARG(/* largeNode */ false))
+        : GenTreeUnOp(GT_ARR_ADDR, addr->TypeGet(), addr DEBUGARG(/* largeNode */ false))
         , m_elemClassHandle(elemClassHandle)
         , m_elemType(elemType)
         , m_firstElemOffset(firstElemOffset)
     {
-        assert(addr->TypeIs(TYP_BYREF));
+        assert(addr->TypeIs(TYP_BYREF, TYP_I_IMPL));
         assert(((elemType == TYP_STRUCT) && (elemClassHandle != NO_CLASS_HANDLE)) ||
                (elemClassHandle == NO_CLASS_HANDLE));
     }

src/coreclr/jit/jitconfigvalues.h

@@ -668,6 +668,7 @@ CONFIG_STRING(JitObjectStackAllocationRange, "JitObjectStackAllocationRange")
 RELEASE_CONFIG_INTEGER(JitObjectStackAllocation, "JitObjectStackAllocation", 1)
 RELEASE_CONFIG_INTEGER(JitObjectStackAllocationRefClass, "JitObjectStackAllocationRefClass", 1)
 RELEASE_CONFIG_INTEGER(JitObjectStackAllocationBoxedValueClass, "JitObjectStackAllocationBoxedValueClass", 1)
+RELEASE_CONFIG_INTEGER(JitObjectStackAllocationArray, "JitObjectStackAllocationArray", 1)
 
 RELEASE_CONFIG_INTEGER(JitEECallTimingInfo, "JitEECallTimingInfo", 0)
 

src/coreclr/jit/jitmetadatalist.h

@@ -83,6 +83,8 @@ JITMETADATAMETRIC(NewRefClassHelperCalls,                int,              0)
 JITMETADATAMETRIC(StackAllocatedRefClasses,              int,              0)
 JITMETADATAMETRIC(NewBoxedValueClassHelperCalls,         int,              0)
 JITMETADATAMETRIC(StackAllocatedBoxedValueClasses,       int,              0)
+JITMETADATAMETRIC(NewArrayHelperCalls,                   int,              0)
+JITMETADATAMETRIC(StackAllocatedArrays,                  int,              0)
 JITMETADATAMETRIC(LocalAssertionCount,                   int,              0)
 JITMETADATAMETRIC(LocalAssertionOverflow,                int,              0)
 JITMETADATAMETRIC(MorphTrackedLocals,                    int,              0)

src/coreclr/jit/lclmorph.cpp

@@ -1353,6 +1353,77 @@ class LocalAddressVisitor final : public GenTreeVisitor<LocalAddressVisitor>
                 break;
             }
 
+            case GT_INDEX_ADDR:
+            {
+                assert(TopValue(2).Node() == node);
+                assert(TopValue(1).Node() == node->gtGetOp1());
+                assert(TopValue(0).Node() == node->gtGetOp2());
+
+                if (node->gtGetOp2()->IsCnsIntOrI() && TopValue(1).IsAddress() &&
+                    m_compiler->lvaGetDesc(TopValue(1).LclNum())->lvStackAllocatedArray == 1)
+                {
+                    ssize_t offset = node->AsIndexAddr()->gtElemOffset +
+                                     node->gtGetOp2()->AsIntCon()->IconValue() * node->AsIndexAddr()->gtElemSize;
+
+                    // For stack allocated arrays the local size is the size of the entire array
+                    if (!node->AsIndexAddr()->IsBoundsChecked() ||
+                        (static_cast<ssize_t>(node->AsIndexAddr()->gtElemOffset) <= offset &&
+                         offset < static_cast<ssize_t>(m_compiler->lvaLclExactSize(TopValue(1).LclNum()))))
+                    {
+                        if (FitsIn<unsigned>(offset) &&
+                            TopValue(2).AddOffset(TopValue(1), static_cast<unsigned>(offset)))
+                        {
+                            INDEBUG(TopValue(0).Consume());
+                            PopValue();
+                            PopValue();
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        *use           = m_compiler->gtNewOperNode(GT_COMMA, node->TypeGet(),
+                                                                   m_compiler->gtNewHelperCallNode(CORINFO_HELP_RNGCHKFAIL,
+                                                                                                   TYP_VOID),
+                                                                   m_compiler->gtNewIconNode(0, TYP_BYREF));
+                        m_stmtModified = true;
+                        INDEBUG(TopValue(0).Consume());
+                        PopValue();
+                        INDEBUG(TopValue(0).Consume());
+                        PopValue();
+                        break;
+                    }
+                }
+
+                EscapeValue(TopValue(0), node);
+                PopValue();
+                EscapeValue(TopValue(0), node);
+                PopValue();
+                break;
+            }
+
+            case GT_ARR_LENGTH:
+            {
+                assert(TopValue(1).Node() == node);
+                assert(TopValue(0).Node() == node->gtGetOp1());
+
+                if (TopValue(0).IsAddress() && m_compiler->lvaGetDesc(TopValue(0).LclNum())->lvStackAllocatedArray == 1)
+                {
+                    GenTree* gtLclFld =
+                        m_compiler->gtNewLclFldNode(TopValue(0).LclNum(), TYP_INT,
+                                                    TopValue(0).Offset() + OFFSETOF__CORINFO_Array__length);
+                    SequenceLocal(gtLclFld->AsLclVarCommon());
+                    *use           = gtLclFld;
+                    m_stmtModified = true;
+                    INDEBUG(TopValue(0).Consume());
+                    PopValue();
+                    break;
+                }
+
+                EscapeValue(TopValue(0), node);
+                PopValue();
+                break;
+            }
+
             default:
                 while (TopValue(0).Node() != node)
                 {

src/coreclr/jit/lclvars.cpp

@@ -2820,6 +2820,11 @@ void Compiler::StructPromotionHelper::PromoteStructVar(unsigned lclNum)
             fieldVarDsc->SetIsNeverNegative(true);
         }
 
+        if (varDsc->lvStackAllocatedArray == 1 && fieldVarDsc->lvFldOffset == OFFSETOF__CORINFO_Array__length)
+        {
+            fieldVarDsc->SetIsNeverNegative(true);
+        }
+
         // This new local may be the first time we've seen a long typed local.
         if (fieldVarDsc->lvType == TYP_LONG)
         {

src/coreclr/jit/morph.cpp

@@ -3571,6 +3571,7 @@ GenTree* Compiler::fgMorphIndexAddr(GenTreeIndexAddr* indexAddr)
     {
         indexAddr->Arr()   = fgMorphTree(indexAddr->Arr());
         indexAddr->Index() = fgMorphTree(indexAddr->Index());
+
         indexAddr->AddAllEffectsFlags(indexAddr->Arr(), indexAddr->Index());
 
         // Mark the indirection node as needing a range check if necessary.
@@ -3602,6 +3603,32 @@ GenTree* Compiler::fgMorphIndexAddr(GenTreeIndexAddr* indexAddr)
     GenTree*          indexDefn   = nullptr; // non-NULL if we need to allocate a temp for the index expression
     GenTreeBoundsChk* boundsCheck = nullptr;
 
+    if (arrRef->IsAnyLocal() && lvaGetDesc(arrRef->AsLclVarCommon()->GetLclNum())->lvStackAllocatedArray == 1)
+    {
+        index = fgMorphTree(index);
+        if (index->IsCnsIntOrI())
+        {
+            ssize_t offset = static_cast<ssize_t>(elemOffs) + index->AsIntCon()->IconValue() * elemSize;
+
+            // For stack allocated arrays the local size is the size of the entire array
+            if (!indexAddr->IsBoundsChecked() ||
+                (static_cast<ssize_t>(elemOffs) <= offset &&
+                 offset < static_cast<ssize_t>(lvaLclExactSize(arrRef->AsLclVarCommon()->GetLclNum()))))
+            {
+                if (FitsIn<unsigned>(offset))
+                {
+                    return fgMorphTree(gtNewOperNode(GT_ADD, indexAddr->TypeGet(), arrRef, gtNewIconNode(offset)));
+                }
+            }
+            else
+            {
+                return fgMorphTree(gtNewOperNode(GT_COMMA, indexAddr->TypeGet(),
+                                                 gtNewHelperCallNode(CORINFO_HELP_RNGCHKFAIL, TYP_VOID),
+                                                 gtNewIconNode(0, TYP_BYREF)));
+            }
+        }
+    }
+
     // If we're doing range checking, introduce a GT_BOUNDS_CHECK node for the address.
     if (indexAddr->IsBoundsChecked())
     {
@@ -3633,7 +3660,7 @@ GenTree* Compiler::fgMorphIndexAddr(GenTreeIndexAddr* indexAddr)
         }
 
         if (((index->gtFlags & (GTF_ASG | GTF_CALL | GTF_GLOB_REF)) != 0) ||
-            gtComplexityExceeds(index, MAX_ARR_COMPLEXITY) || index->OperIs(GT_LCL_FLD) ||
+            gtComplexityExceeds(index, MAX_INDEX_COMPLEXITY) || index->OperIs(GT_LCL_FLD) ||
             (index->OperIs(GT_LCL_VAR) && lvaIsLocalImplicitlyAccessedByRef(index->AsLclVar()->GetLclNum())))
         {
             unsigned indexTmpNum = lvaGrabTemp(true DEBUGARG("index expr"));
@@ -7755,6 +7782,12 @@ GenTree* Compiler::fgMorphSmpOp(GenTree* tree, MorphAddrContext* mac, bool* optA
                     return iconNode;
                 }
             }
+            if (op1->IsAnyLocal() && lvaGetDesc(op1->AsLclVarCommon())->lvStackAllocatedArray == 1)
+            {
+                return fgMorphTree(
+                    gtNewLclFldNode(op1->AsLclVarCommon()->GetLclNum(), tree->TypeGet(),
+                                    op1->AsLclVarCommon()->GetLclOffs() + OFFSETOF__CORINFO_Array__length));
+            }
             break;
 
         case GT_IND: