Change all "unmanaged" (no GC fields) sequential types to have sequential layout.

src/coreclr/inc/readytorun.h

@@ -15,15 +15,17 @@
 #define READYTORUN_SIGNATURE 0x00525452 // 'RTR'
 
 // Keep these in sync with src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs
-#define READYTORUN_MAJOR_VERSION 0x0005
-#define READYTORUN_MINOR_VERSION 0x0004
+#define READYTORUN_MAJOR_VERSION 0x0006
+#define READYTORUN_MINOR_VERSION 0x0000
 
-#define MINIMUM_READYTORUN_MAJOR_VERSION 0x003
+#define MINIMUM_READYTORUN_MAJOR_VERSION 0x006
 
 // R2R Version 2.1 adds the InliningInfo section
 // R2R Version 2.2 adds the ProfileDataInfo section
 // R2R Version 3.0 changes calling conventions to correctly handle explicit structures to spec.
 //     R2R 3.0 is not backward compatible with 2.x.
+// R2R Version 6.0 changes managed layout for sequential types with any unmanaged non-blittable fields.
+//     R2R 6.0 is not backward compatible with 5.x or earlier.
 
 struct READYTORUN_CORE_HEADER
 {

src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs

@@ -14,8 +14,8 @@ internal struct ReadyToRunHeaderConstants
     {
         public const uint Signature = 0x00525452; // 'RTR'
 
-        public const ushort CurrentMajorVersion = 5;
-        public const ushort CurrentMinorVersion = 4;
+        public const ushort CurrentMajorVersion = 6;
+        public const ushort CurrentMinorVersion = 0;
     }
 
 #pragma warning disable 0169

src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs

@@ -305,8 +305,6 @@ protected virtual void FinalizeRuntimeSpecificStaticFieldLayout(TypeSystemContex
         {
         }
 
-        protected virtual bool AlignUpInstanceByteSizeForExplicitFieldLayoutCompatQuirk(TypeDesc type) => true;
-
         protected ComputedInstanceFieldLayout ComputeExplicitFieldLayout(MetadataType type, int numInstanceFields)
         {
             // Instance slice size is the total size of instance not including the base type.
@@ -369,7 +367,7 @@ protected ComputedInstanceFieldLayout ComputeExplicitFieldLayout(MetadataType ty
                 instanceSize,
                 largestAlignmentRequired,
                 layoutMetadata.Size,
-                alignUpInstanceByteSize: AlignUpInstanceByteSizeForExplicitFieldLayoutCompatQuirk(type),
+                alignUpInstanceByteSize: false,
                 out instanceByteSizeAndAlignment);
 
             ComputedInstanceFieldLayout computedLayout = new ComputedInstanceFieldLayout();

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunMetadataFieldLayoutAlgorithm.cs

@@ -196,9 +196,9 @@ protected override ModuleFieldLayout CreateValueFromKey(EcmaModule module)
                         }
                     }
 
-                    if (nonGcBytes[StaticIndex.Regular] != 0 || 
+                    if (nonGcBytes[StaticIndex.Regular] != 0 ||
                         nonGcBytes[StaticIndex.ThreadLocal] != 0 ||
-                        gcBytes[StaticIndex.Regular] != 0 || 
+                        gcBytes[StaticIndex.Regular] != 0 ||
                         gcBytes[StaticIndex.ThreadLocal] != 0)
                     {
                         OffsetsForType offsetsForType = new OffsetsForType(LayoutInt.Indeterminate, LayoutInt.Indeterminate, LayoutInt.Indeterminate, LayoutInt.Indeterminate);
@@ -290,14 +290,14 @@ private void GetElementTypeInfoGeneric(
             }
 
             private void GetElementTypeInfo(
-                EcmaModule module, 
+                EcmaModule module,
                 FieldDesc fieldDesc,
-                EntityHandle valueTypeHandle, 
+                EntityHandle valueTypeHandle,
                 CorElementType elementType,
                 int pointerSize,
                 bool moduleLayout,
-                out int alignment, 
-                out int size, 
+                out int alignment,
+                out int size,
                 out bool isGcPointerField,
                 out bool isGcBoxedField)
             {
@@ -357,7 +357,7 @@ private void GetElementTypeInfo(
                         ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadGeneral, fieldDesc.OwningType);
                         break;
 
-                    // Statics for valuetypes where the valuetype is defined in this module are handled here. 
+                    // Statics for valuetypes where the valuetype is defined in this module are handled here.
                     // Other valuetype statics utilize the pessimistic model below.
                     case CorElementType.ELEMENT_TYPE_VALUETYPE:
                         if (IsTypeByRefLike(valueTypeHandle, module.MetadataReader))
@@ -522,7 +522,7 @@ public FieldAndOffset[] CalculateTypeLayout(DefType defType, EcmaModule module,
                     offsetsForType.GcOffsets[StaticIndex.ThreadLocal],
                 };
 
-                LayoutInt[] gcPointerFieldOffsets = new LayoutInt[StaticIndex.Count] 
+                LayoutInt[] gcPointerFieldOffsets = new LayoutInt[StaticIndex.Count]
                 {
                     offsetsForType.GcOffsets[StaticIndex.Regular] + new LayoutInt(gcBoxedCount[StaticIndex.Regular] * pointerSize),
                     offsetsForType.GcOffsets[StaticIndex.ThreadLocal] + new LayoutInt(gcBoxedCount[StaticIndex.ThreadLocal] * pointerSize)
@@ -768,10 +768,10 @@ private class ModuleFieldLayout
             private ConcurrentDictionary<DefType, FieldAndOffset[]> _genericTypeToFieldMap;
 
             public ModuleFieldLayout(
-                EcmaModule module, 
-                StaticsBlock gcStatics, 
-                StaticsBlock nonGcStatics, 
-                StaticsBlock threadGcStatics, 
+                EcmaModule module,
+                StaticsBlock gcStatics,
+                StaticsBlock nonGcStatics,
+                StaticsBlock threadGcStatics,
                 StaticsBlock threadNonGcStatics,
                 IReadOnlyDictionary<TypeDefinitionHandle, OffsetsForType> typeOffsets)
             {
@@ -803,7 +803,7 @@ protected override ComputedInstanceFieldLayout ComputeInstanceFieldLayout(Metada
                 return ComputeExplicitFieldLayout(type, numInstanceFields);
             }
             else
-            if (type.IsEnum || MarshalUtils.IsBlittableType(type) || IsManagedSequentialType(type))
+            if (type.IsSequentialLayout && !type.ContainsGCPointers)
             {
                 return ComputeSequentialFieldLayout(type, numInstanceFields);
             }
@@ -814,7 +814,7 @@ protected override ComputedInstanceFieldLayout ComputeInstanceFieldLayout(Metada
         }
 
         /// <summary>
-        /// This method decides whether the type needs aligned base offset in order to have layout resilient to 
+        /// This method decides whether the type needs aligned base offset in order to have layout resilient to
         /// base class layout changes.
         /// </summary>
         protected override void AlignBaseOffsetIfNecessary(MetadataType type, ref LayoutInt baseOffset, bool requiresAlign8, bool requiresAlignedBase)
@@ -827,43 +827,26 @@ protected override void AlignBaseOffsetIfNecessary(MetadataType type, ref Layout
             }
         }
 
-        protected override bool AlignUpInstanceByteSizeForExplicitFieldLayoutCompatQuirk(TypeDesc type)
-        {
-            return MarshalUtils.IsBlittableType(type) || IsManagedSequentialType(type);
-        }
-
         public static bool IsManagedSequentialType(TypeDesc type)
         {
-            if (type.IsPointer)
+            if (type.IsPointer || type.IsFunctionPointer)
             {
                 return true;
             }
 
-            if (!type.IsValueType)
-            {
-                return false;
-            }
-
-            MetadataType metadataType = (MetadataType)type;
-            if (metadataType.IsExplicitLayout || !metadataType.IsSequentialLayout)
-            {
-                return false;
-            }
-
             if (type.IsPrimitive)
             {
                 return true;
             }
 
-            foreach (FieldDesc field in type.GetFields())
+            if (!type.IsValueType)
             {
-                if (!field.IsStatic && !IsManagedSequentialType(field.FieldType.UnderlyingType))
-                {
-                    return false;
-                }
+                return false;
             }
 
-            return true;
+            MetadataType metadataType = (MetadataType)type;
+
+            return metadataType.IsSequentialLayout && !metadataType.ContainsGCPointers;
         }
     }
 }

src/coreclr/vm/classlayoutinfo.cpp

@@ -288,10 +288,15 @@ namespace
             }
             else
             {
+#ifdef FEATURE_64BIT_ALIGNMENT
+                pManagedPlacementInfo->m_alignment = pNestedType.RequiresAlign8() ? 8 : TARGET_POINTER_SIZE;
+#else
                 pManagedPlacementInfo->m_alignment = TARGET_POINTER_SIZE;
+#endif
             }
 
-            return !pNestedType.GetMethodTable()->IsManagedSequential();
+            // Types that have GC Pointer fields (objects or byrefs) are disqualified from ManagedSequential layout.
+            return pNestedType.GetMethodTable()->ContainsPointers() != FALSE;
         }
 
         // No other type permitted for ManagedSequential.

src/coreclr/vm/methodtablebuilder.cpp

@@ -8567,15 +8567,6 @@ MethodTableBuilder::HandleExplicitLayout(
         SetHasOverLayedFields();
     }
 
-    if (IsBlittable() || IsManagedSequential())
-    {
-        // Bug 849333: We shouldn't update "bmtFP->NumInstanceFieldBytes"
-        // for Blittable/ManagedSequential types.  As this will break backward compatiblity
-        // for the size of types that return true for HasExplicitFieldOffsetLayout()
-        //
-        return;
-    }
-
     FindPointerSeriesExplicit(instanceSliceSize, pFieldLayout);
 
     // Fixup the offset to include parent as current offsets are relative to instance slice
@@ -8612,6 +8603,16 @@ MethodTableBuilder::HandleExplicitLayout(
                 numInstanceFieldBytes = S_UINT32(clstotalsize);
             }
         }
+        else
+        {
+            // align up to the alignment requirements of the members of this value type.
+            dwInstanceSliceOffset.AlignUp(GetLayoutInfo()->m_ManagedLargestAlignmentRequirementOfAllMembers);
+            if (dwInstanceSliceOffset.IsOverflow())
+            {
+                // addition overflow or cast truncation
+                BuildMethodTableThrowException(IDS_CLASSLOAD_GENERAL);
+            }
+        }
     }
 
     // The GC requires that all valuetypes containing orefs be sized to a multiple of TARGET_POINTER_SIZE.