Delete parts of type system that deal with layouts (#79366)

The layout of type is always the same as the template so we don't need the logic. This gets rid of uncertainities around "can I reliably ask type system questions around layouts" (see the deleted FieldLayoutAlgorithms). Now the answer is: "you can't ask those questions", which is better than "you could get an answer that you might not like" (an assert).

Author: MichalStrehovsky

src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/EETypeCreator.cs

@@ -161,7 +161,6 @@ private static void CreateEETypeWorker(MethodTable* pTemplateEEType, uint hashCo
                     pTemplateEEType = pTemplateEEType->DynamicTemplateType;
                 }
 
-                uint valueTypeFieldPaddingEncoded = 0;
                 int baseSize = 0;
 
                 bool isValueType;
@@ -171,68 +170,32 @@ private static void CreateEETypeWorker(MethodTable* pTemplateEEType, uint hashCo
                 bool isGeneric;
                 uint flags;
                 ushort runtimeInterfacesLength = 0;
-                bool isAbstractClass;
-                bool isByRefLike;
                 IntPtr typeManager = IntPtr.Zero;
 
                 if (state.RuntimeInterfaces != null)
                 {
                     runtimeInterfacesLength = checked((ushort)state.RuntimeInterfaces.Length);
                 }
 
-                valueTypeFieldPaddingEncoded = EETypeBuilderHelpers.ComputeValueTypeFieldPaddingFieldValue(
-                    pTemplateEEType->ValueTypeFieldPadding,
-                    (uint)pTemplateEEType->FieldAlignmentRequirement,
-                    IntPtr.Size);
                 baseSize = (int)pTemplateEEType->BaseSize;
                 isValueType = pTemplateEEType->IsValueType;
                 hasFinalizer = pTemplateEEType->IsFinalizable;
                 isNullable = pTemplateEEType->IsNullable;
                 flags = pTemplateEEType->Flags;
                 isArray = pTemplateEEType->IsArray;
                 isGeneric = pTemplateEEType->IsGeneric;
-                isAbstractClass = pTemplateEEType->IsAbstract && !pTemplateEEType->IsInterface;
-                isByRefLike = pTemplateEEType->IsByRefLike;
                 typeManager = pTemplateEEType->PointerToTypeManager;
                 Debug.Assert(pTemplateEEType->NumInterfaces == runtimeInterfacesLength);
 
                 flags |= (uint)EETypeFlags.IsDynamicTypeFlag;
 
-                // TODO! Change to if template is Universal or non-Existent
-
-                // FEATURE_UNIVERSAL_GENERICS?
-                if (state.TypeSize.HasValue)
+                if (state.TypeBeingBuilt.IsMdArray)
                 {
-                    baseSize = state.TypeSize.Value;
-
-                    int baseSizeBeforeAlignment = baseSize;
-
-                    baseSize = MemoryHelpers.AlignUp(baseSize, IntPtr.Size);
-
-                    if (isValueType)
-                    {
-                        // Compute the valuetype padding size based on size before adding the object type pointer field to the size
-                        uint cbValueTypeFieldPadding = (uint)(baseSize - baseSizeBeforeAlignment);
-
-                        // Add Object type pointer field to base size
-                        baseSize += IntPtr.Size;
-
-                        valueTypeFieldPaddingEncoded = (uint)EETypeBuilderHelpers.ComputeValueTypeFieldPaddingFieldValue(cbValueTypeFieldPadding, (uint)state.FieldAlignment.Value, IntPtr.Size);
-                    }
-
-                    // Minimum base size is 3 pointers, and requires us to bump the size of an empty class type
-                    if (baseSize <= IntPtr.Size)
-                    {
-                        // ValueTypes should already have had their size bumped up by the normal type layout process
-                        Debug.Assert(!isValueType);
-                        baseSize += IntPtr.Size;
-                    }
-
-                    // Add sync block skew
-                    baseSize += IntPtr.Size;
-
-                    // Minimum basesize is 3 pointers
-                    Debug.Assert(baseSize >= (IntPtr.Size * 3));
+                    // If we're building an MDArray, the template is object[,] and we
+                    // need to recompute the base size.
+                    baseSize = IntPtr.Size + // sync block
+                        2 * IntPtr.Size + // EETypePtr + Length
+                        state.ArrayRank.Value * sizeof(int) * 2; // 2 ints per rank for bounds
                 }
 
                 // Optional fields encoding
@@ -241,7 +204,11 @@ private static void CreateEETypeWorker(MethodTable* pTemplateEEType, uint hashCo
 
                 uint rareFlags = optionalFields.GetFieldValue(EETypeOptionalFieldTag.RareFlags, 0);
 
-                if (state.NonGcDataSize != 0)
+                int allocatedNonGCDataSize = state.NonGcDataSize;
+                if (state.HasStaticConstructor)
+                    allocatedNonGCDataSize += -TypeBuilder.ClassConstructorOffset;
+
+                if (allocatedNonGCDataSize != 0)
                     rareFlags |= (uint)EETypeRareFlags.IsDynamicTypeWithNonGcStatics;
 
                 if (state.GcDataSize != 0)
@@ -250,60 +217,11 @@ private static void CreateEETypeWorker(MethodTable* pTemplateEEType, uint hashCo
                 if (state.ThreadDataSize != 0)
                     rareFlags |= (uint)EETypeRareFlags.IsDynamicTypeWithThreadStatics;
 
-#if TARGET_ARM
-                if (state.FieldAlignment == 8)
-                    rareFlags |= (uint)EETypeRareFlags.RequiresAlign8Flag;
-                else
-                    rareFlags &= ~(uint)EETypeRareFlags.RequiresAlign8Flag;
-#endif
-
-#if TARGET_ARM || TARGET_ARM64
-                if (state.IsHFA)
-                    rareFlags |= (uint)EETypeRareFlags.IsHFAFlag;
-                else
-                    rareFlags &= ~(uint)EETypeRareFlags.IsHFAFlag;
-#endif
-                if (state.HasStaticConstructor)
-                    rareFlags |= (uint)EETypeRareFlags.HasCctorFlag;
-                else
-                    rareFlags &= ~(uint)EETypeRareFlags.HasCctorFlag;
-
-                if (isAbstractClass)
-                    rareFlags |= (uint)EETypeRareFlags.IsAbstractClassFlag;
-                else
-                    rareFlags &= ~(uint)EETypeRareFlags.IsAbstractClassFlag;
-
-                if (isByRefLike)
-                    rareFlags |= (uint)EETypeRareFlags.IsByRefLikeFlag;
-                else
-                    rareFlags &= ~(uint)EETypeRareFlags.IsByRefLikeFlag;
-
-                if (isNullable)
-                {
-                    uint nullableValueOffset = state.NullableValueOffset;
-
-                    // The stored offset is never zero (Nullable has a boolean there indicating whether the value is valid).
-                    // If the real offset is one, then the field isn't set. Otherwise the offset is encoded - 1 to save space.
-                    if (nullableValueOffset == 1)
-                        optionalFields.ClearField(EETypeOptionalFieldTag.NullableValueOffset);
-                    else
-                        optionalFields.SetFieldValue(EETypeOptionalFieldTag.NullableValueOffset, checked(nullableValueOffset - 1));
-                }
-                else
-                {
-                    optionalFields.ClearField(EETypeOptionalFieldTag.NullableValueOffset);
-                }
-
                 optionalFields.SetFieldValue(EETypeOptionalFieldTag.RareFlags, rareFlags);
 
                 // Dispatch map is fetched from template type
                 optionalFields.ClearField(EETypeOptionalFieldTag.DispatchMap);
 
-                optionalFields.ClearField(EETypeOptionalFieldTag.ValueTypeFieldPadding);
-
-                if (valueTypeFieldPaddingEncoded != 0)
-                    optionalFields.SetFieldValue(EETypeOptionalFieldTag.ValueTypeFieldPadding, valueTypeFieldPaddingEncoded);
-
                 // Compute size of optional fields encoding
                 cbOptionalFieldsSize = optionalFields.Encode();
                 Debug.Assert(cbOptionalFieldsSize > 0);
@@ -328,7 +246,7 @@ private static void CreateEETypeWorker(MethodTable* pTemplateEEType, uint hashCo
                         true,
                         (rareFlags & (int)EETypeRareFlags.HasSealedVTableEntriesFlag) != 0,
                         isGeneric,
-                        state.NonGcDataSize != 0,
+                        allocatedNonGCDataSize != 0,
                         state.GcDataSize != 0,
                         state.ThreadDataSize != 0);
 
@@ -401,19 +319,19 @@ private static void CreateEETypeWorker(MethodTable* pTemplateEEType, uint hashCo
                     nonGCStaticDataOffset = state.HasStaticConstructor ? -TypeBuilder.ClassConstructorOffset : 0;
 
                     // If we have a class constructor, our NonGcDataSize MUST be non-zero
-                    Debug.Assert(!state.HasStaticConstructor || (state.NonGcDataSize != 0));
+                    Debug.Assert(!state.HasStaticConstructor || (allocatedNonGCDataSize != 0));
                 }
 
                 if (isGeneric)
                 {
                     genericComposition = MemoryHelpers.AllocateMemory(MethodTable.GetGenericCompositionSize(arity, pEEType->HasGenericVariance));
                     pEEType->SetGenericComposition(genericComposition);
 
-                    if (state.NonGcDataSize > 0)
+                    if (allocatedNonGCDataSize > 0)
                     {
-                        nonGcStaticData = MemoryHelpers.AllocateMemory(state.NonGcDataSize);
-                        MemoryHelpers.Memset(nonGcStaticData, state.NonGcDataSize, 0);
-                        Debug.Assert(nonGCStaticDataOffset <= state.NonGcDataSize);
+                        nonGcStaticData = MemoryHelpers.AllocateMemory(allocatedNonGCDataSize);
+                        MemoryHelpers.Memset(nonGcStaticData, allocatedNonGCDataSize, 0);
+                        Debug.Assert(nonGCStaticDataOffset <= allocatedNonGCDataSize);
                         pEEType->DynamicNonGcStaticsData = (IntPtr)((byte*)nonGcStaticData + nonGCStaticDataOffset);
                     }
                 }