Improve mustInit for structs.

Author: Sergey

src/coreclr/jit/codegencommon.cpp

@@ -4794,14 +4794,41 @@ void CodeGen::genCheckUseBlockInit()
                 }
             }
 
-            /* With compInitMem, all untracked vars will have to be init'ed */
-            /* VSW 102460 - Do not force initialization of compiler generated temps,
-                unless they are untracked GC type or structs that contain GC pointers */
-            CLANG_FORMAT_COMMENT_ANCHOR;
+            bool mustInitThisVar = false;
+
+            const bool isTemp      = varDsc->lvIsTemp;
+            const bool hasGCPtr    = varDsc->HasGCPtr();
+            const bool isTracked   = varDsc->lvTracked;
+            const bool isStruct    = varTypeIsStruct(varDsc);
+            const bool compInitMem = compiler->info.compInitMem;
 
-            if ((!varDsc->lvTracked || (varDsc->lvType == TYP_STRUCT)) && varDsc->lvOnFrame)
+            if (hasGCPtr && !isTracked)
+            {
+                JITDUMP("must init V%02u because it has a GC ref\n", varNum);
+                mustInitThisVar = true;
+            }
+            else if (hasGCPtr && isStruct)
+            {
+                // TODO-1stClassStructs: support precise liveness reporting for such structs.
+                JITDUMP("must init a tracked V%02u because it a struct with a GC ref\n", varNum);
+                mustInitThisVar = true;
+            }
+            else
             {
+                // We are done with tracked or GC vars, now look at untracked vars without GC refs.
+                if (!isTracked)
+                {
+                    assert(!hasGCPtr);
+                    if (compInitMem && !isTemp)
+                    {
+                        JITDUMP("must init V%02u because compInitMem is set and it is not a temp\n", varNum);
+                        mustInitThisVar = true;
+                    }
+                }
+            }
 
+            if (mustInitThisVar)
+            {
                 varDsc->lvMustInit = true;
 
                 if (!counted)

src/coreclr/jit/compiler.h

@@ -971,7 +971,7 @@ class LclVarDsc
     var_types lvaArgType();
 
     // Returns true if this variable contains GC pointers (including being a GC pointer itself).
-    bool HasGCPtr()
+    bool HasGCPtr() const
     {
         return varTypeIsGC(lvType) || ((lvType == TYP_STRUCT) && m_layout->HasGCPtr());
     }

src/coreclr/jit/lower.cpp

@@ -5915,17 +5915,34 @@ void Lowering::CheckNode(Compiler* compiler, GenTree* node)
         {
             unsigned   lclNum = node->AsLclVarCommon()->GetLclNum();
             LclVarDsc* lclVar = &compiler->lvaTable[lclNum];
-#ifdef DEBUG
             if (node->TypeIs(TYP_SIMD12))
             {
                 assert(compiler->lvaIsFieldOfDependentlyPromotedStruct(lclVar) || (lclVar->lvSize() == 12));
             }
-#endif // DEBUG
         }
         break;
 #endif // TARGET_64BIT
 #endif // SIMD
 
+        case GT_LCL_VAR_ADDR:
+        case GT_LCL_FLD_ADDR:
+        {
+            const GenTreeLclVarCommon* lclVarAddr = node->AsLclVarCommon();
+            const LclVarDsc*           varDsc     = compiler->lvaGetDesc(lclVarAddr);
+            if (((lclVarAddr->gtFlags & GTF_VAR_DEF) != 0) && varDsc->HasGCPtr())
+            {
+                // Emitter does not correctly handle live updates for LCL_VAR_ADDR
+                // when they are not contained, for example, `STOREIND byref(GT_LCL_VAR_ADDR not-contained)`
+                // would generate:
+                // add     r1, sp, 48   // r1 contains address of a lclVar V01.
+                // str     r0, [r1]     // a gc ref becomes live in V01, but emitter would not report it.
+                // Make sure that we use uncontained address nodes only for variables
+                // that will be marked as mustInit and will be alive throught the whole block even when tracked.
+                assert(lclVarAddr->isContained() || !varDsc->lvTracked || varTypeIsStruct(varDsc));
+                // TODO: support this assert for uses, see https://github.com/dotnet/runtime/issues/51900.
+            }
+        }
+
         default:
             break;
     }

src/coreclr/jit/optimizer.cpp

@@ -9760,7 +9760,8 @@ void Compiler::optRemoveRedundantZeroInits()
                                 if (BitVecOps::IsMember(&bitVecTraits, zeroInitLocals, lclNum) ||
                                     (lclDsc->lvIsStructField &&
                                      BitVecOps::IsMember(&bitVecTraits, zeroInitLocals, lclDsc->lvParentLcl)) ||
-                                    (!lclDsc->lvTracked && !fgVarNeedsExplicitZeroInit(lclNum, bbInALoop, bbIsReturn)))
+                                    ((!lclDsc->lvTracked || !isEntire) &&
+                                     !fgVarNeedsExplicitZeroInit(lclNum, bbInALoop, bbIsReturn)))
                                 {
                                     // We are guaranteed to have a zero initialization in the prolog or a
                                     // dominating explicit zero initialization and the local hasn't been redefined