Move assert checking the size of structs with GC pointers. (#34053)

Codegen for CpObj assumes that we cannot have a struct with GC pointers
whose size is not a multiple of the register size. We had an assert that
 verified that in `ClassLayout::InitializeGCPtrs`.

The assert fired in the new pipeline that tests off-by-default features
in the leg that turns on object stack allocation. Stack-allocated
objects are never copied so the assert shouldn't apply to them.
I moved the assert to `Compiler::gtNewCpObjNode`. I clarified the
comment for the assert and changed it from `noway_assert` to a
regular `assert` since recompilation with minopts will not help if we
hit the assert.

I also added a repro case to ObjectStackAllocationTests that run with
COMPlus_JitObjectStackAllocation=1 in regular test runs.

Author: erozenfeld

src/coreclr/src/jit/gentree.cpp

@@ -6579,7 +6579,19 @@ GenTree* Compiler::gtNewCpObjNode(GenTree* dstAddr, GenTree* srcAddr, CORINFO_CL
 
     if (lhs->OperIs(GT_OBJ))
     {
-        gtSetObjGcInfo(lhs->AsObj());
+        GenTreeObj* lhsObj = lhs->AsObj();
+#if DEBUG
+        // Codegen for CpObj assumes that we cannot have a struct with GC pointers whose size is not a multiple
+        // of the register size. The EE currently does not allow this to ensure that GC pointers are aligned
+        // if the struct is stored in an array. Note that this restriction doesn't apply to stack-allocated objects:
+        // they are never stored in arrays. We should never get to this method with stack-allocated objects since they
+        // are never copied so we don't need to exclude them from the assert below.
+        // Let's assert it just to be safe.
+        ClassLayout* layout = lhsObj->GetLayout();
+        unsigned     size   = layout->GetSize();
+        assert((layout->GetGCPtrCount() == 0) || (roundUp(size, REGSIZE_BYTES) == size));
+#endif
+        gtSetObjGcInfo(lhsObj);
     }
 
     if (srcAddr->OperGet() == GT_ADDR)

src/coreclr/src/jit/layout.cpp

@@ -373,12 +373,6 @@ void ClassLayout::InitializeGCPtrs(Compiler* compiler)
         // so it should be safe to fit this into a 30 bits bit field.
         assert(gcPtrCount < (1 << 30));
 
-        // We assume that we cannot have a struct with GC pointers that is not a multiple
-        // of the register size.
-        // The EE currently does not allow this, but it could change.
-        // Let's assert it just to be safe.
-        noway_assert((gcPtrCount == 0) || (roundUp(m_size, REGSIZE_BYTES) == m_size));
-
         m_gcPtrCount = gcPtrCount;
     }
 

src/coreclr/tests/src/JIT/opt/ObjectStackAllocation/ObjectStackAllocationTests.cs

@@ -43,6 +43,18 @@ public SimpleClassWithGCField(int f1, int f2, object o) : base(f1, f2)
         }
     }
 
+    class ClassWithGCFieldAndInt
+    {
+        public object o;
+        public int i;
+
+        public ClassWithGCFieldAndInt(int i, object o)
+        {
+            this.o = o;
+            this.i = i;
+        }
+    }
+
     class ClassWithNestedStruct
     {
         public ClassWithNestedStruct(int f1, int f2)
@@ -137,6 +149,8 @@ public static int Main()
             // We don't have to use a helper in this case (even for R2R), https://github.com/dotnet/coreclr/issues/22086 tracks fixing that.
             CallTestAndVerifyAllocation(AllocateSimpleClassAndCheckTypeNoHelper, 1, AllocationKind.Undefined);
 
+            CallTestAndVerifyAllocation(AllocateClassWithGcFieldAndInt, 5, expectedAllocationKind);
+
             // The remaining tests currently never allocate on the stack
             if (expectedAllocationKind == AllocationKind.Stack) {
                 expectedAllocationKind = AllocationKind.Heap;
@@ -170,8 +184,6 @@ static bool GCStressEnabled()
 
         static void CallTestAndVerifyAllocation(Test test, int expectedResult, AllocationKind expectedAllocationsKind)
         {
-            // Run the test once to exclude any allocations during jitting, etc.
-            //test();
             long allocatedBytesBefore = GC.GetAllocatedBytesForCurrentThread();
             int testResult = test();
             long allocatedBytesAfter = GC.GetAllocatedBytesForCurrentThread();
@@ -326,5 +338,12 @@ static int TestMixOfReportingAndWriteBarriers()
 
             return c1.o.ToString().Length + c2.o.ToString().Length + c3.o.ToString().Length + c4.o.ToString().Length;
         }
+
+        static int AllocateClassWithGcFieldAndInt()
+        {
+            ClassWithGCFieldAndInt c = new ClassWithGCFieldAndInt(f1, null);
+            GC.Collect();
+            return c.i;
+        }
     }
 }