Implement support for ExtendedLayoutKind.CUnion (#123052)

jkoritzinsky · Copilot · web-flow · commit f7c4c8c509eb · 2026-01-13T21:03:43.000Z
Co-authored-by: Copilot &lt;175728472+Copilot@users.noreply.github.com&gt;
diff --git a/src/coreclr/inc/corhdr.h b/src/coreclr/inc/corhdr.h
@@ -329,6 +329,7 @@ typedef enum CorTypeAttr
 enum class CorExtendedLayoutKind
 {
     CStruct = 0, // C-style struct
+    CUnion = 1, // C-style union
 };
 
 // Macros for accessing the members of the CorTypeAttr.
diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs
@@ -2123,6 +2123,14 @@ private uint getClassAttribsInternal(TypeDesc type)
 
                 if (metadataType.IsInlineArray)
                     result |= CorInfoFlag.CORINFO_FLG_INDEXABLE_FIELDS;
+
+                if (metadataType.IsExtendedLayout)
+                {
+                    if (metadataType.GetClassLayout().Kind == MetadataLayoutKind.CUnion)
+                    {
+                        result |= CorInfoFlag.CORINFO_FLG_OVERLAPPING_FIELDS;
+                    }
+                }
             }
 
             if (type.IsCanonicalSubtype(CanonicalFormKind.Any))
diff --git a/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs b/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs
@@ -498,7 +498,7 @@ protected ComputedInstanceFieldLayout ComputeSequentialFieldLayout(MetadataType
 
         protected ComputedInstanceFieldLayout ComputeCStructFieldLayout(MetadataType type, int numInstanceFields)
         {
-            if (type.ContainsGCPointers || !type.IsValueType)
+            if (type.ContainsGCPointers || type.IsByRefLike || !type.IsValueType)
             {
                 // CStruct layout algorithm does not support GC pointers.
                 ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadBadFormat, type);
@@ -581,6 +581,91 @@ protected ComputedInstanceFieldLayout ComputeCStructFieldLayout(MetadataType typ
             return computedLayout;
         }
 
+        protected ComputedInstanceFieldLayout ComputeCUnionFieldLayout(MetadataType type, int numInstanceFields)
+        {
+            if (type.ContainsGCPointers || type.IsByRefLike || !type.IsValueType)
+            {
+                // CUnion layout algorithm does not support GC pointers.
+                ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadBadFormat, type);
+            }
+
+            var offsets = new FieldAndOffset[numInstanceFields];
+
+            LayoutInt largestFieldSize = LayoutInt.Zero;
+            LayoutInt largestAlignmentRequirement = LayoutInt.One;
+            int fieldOrdinal = 0;
+            int packingSize = type.Context.Target.MaximumAlignment;
+            bool layoutAbiStable = true;
+            bool hasAutoLayoutField = false;
+            bool hasInt128Field = false;
+            bool hasVectorTField = false;
+
+            foreach (var field in type.GetFields())
+            {
+                if (field.IsStatic)
+                    continue;
+
+                var fieldSizeAndAlignment = ComputeFieldSizeAndAlignment(field.FieldType.UnderlyingType, hasLayout: true, packingSize, out ComputedFieldData fieldData);
+                if (!fieldData.LayoutAbiStable)
+                    layoutAbiStable = false;
+                if (fieldData.HasAutoLayout)
+                    hasAutoLayoutField = true;
+                if (fieldData.HasInt128Field)
+                    hasInt128Field = true;
+                if (fieldData.HasVectorTField)
+                    hasVectorTField = true;
+
+                largestAlignmentRequirement = LayoutInt.Max(fieldSizeAndAlignment.Alignment, largestAlignmentRequirement);
+                largestFieldSize = LayoutInt.Max(fieldSizeAndAlignment.Size, largestFieldSize);
+
+                // All fields are placed at offset 0 in a union
+                offsets[fieldOrdinal] = new FieldAndOffset(field, LayoutInt.Zero);
+
+                fieldOrdinal++;
+            }
+
+            if (hasAutoLayoutField)
+            {
+                // CUnion does not support auto layout fields
+                ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadBadFormat, type);
+            }
+
+            if (largestFieldSize == LayoutInt.Zero)
+            {
+                // CUnion cannot have zero size.
+                ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadBadFormat, type);
+            }
+
+            if (type.IsInlineArray)
+            {
+                // CUnion types cannot be inline arrays
+                ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadBadFormat, type);
+            }
+
+            SizeAndAlignment instanceByteSizeAndAlignment;
+            var instanceSizeAndAlignment = ComputeInstanceSize(
+                type,
+                largestFieldSize,
+                largestAlignmentRequirement,
+                classLayoutSize: 0, // CUnion does not use the size from metadata.
+                out instanceByteSizeAndAlignment);
+
+            ComputedInstanceFieldLayout computedLayout = new ComputedInstanceFieldLayout
+            {
+                IsAutoLayoutOrHasAutoLayoutFields = false,
+                IsInt128OrHasInt128Fields = hasInt128Field,
+                IsVectorTOrHasVectorTFields = hasVectorTField,
+                FieldAlignment = instanceSizeAndAlignment.Alignment,
+                FieldSize = instanceSizeAndAlignment.Size,
+                ByteCountUnaligned = instanceByteSizeAndAlignment.Size,
+                ByteCountAlignment = instanceByteSizeAndAlignment.Alignment,
+                Offsets = offsets,
+                LayoutAbiStable = layoutAbiStable
+            };
+
+            return computedLayout;
+        }
+
         private static void AdjustForInlineArray(
             MetadataType type,
             int instanceFieldCount,
diff --git a/src/coreclr/tools/Common/TypeSystem/Common/MetadataType.cs b/src/coreclr/tools/Common/TypeSystem/Common/MetadataType.cs
@@ -125,6 +125,7 @@ public enum MetadataLayoutKind
         Auto,
         Sequential,
         Explicit,
-        CStruct
+        CStruct,
+        CUnion
     }
 }
diff --git a/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaType.cs b/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaType.cs
@@ -586,6 +586,9 @@ public override ClassLayoutMetadata GetClassLayout()
                     case 0:
                         layoutKind = MetadataLayoutKind.CStruct;
                         break;
+                    case 1:
+                        layoutKind = MetadataLayoutKind.CUnion;
+                        break;
                     default:
                         ThrowHelper.ThrowTypeLoadException(this);
                         return default; // Invalid kind value
diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalUtils.cs b/src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalUtils.cs
@@ -31,7 +31,7 @@ public static bool IsBlittableType(TypeDesc type)
 
             if (mdType.IsExtendedLayout)
             {
-                return mdType.GetClassLayout().Kind is MetadataLayoutKind.CStruct;
+                return mdType.GetClassLayout().Kind is MetadataLayoutKind.CStruct or MetadataLayoutKind.CUnion;
             }
 
             if (mdType.IsAutoLayout)
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilerMetadataFieldLayoutAlgorithm.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/CompilerMetadataFieldLayoutAlgorithm.cs
@@ -49,6 +49,7 @@ protected override ComputedInstanceFieldLayout ComputeInstanceFieldLayout(Metada
                 // all types without GC references (ie C# unmanaged types).
                 MetadataLayoutKind.Sequential when !type.ContainsGCPointers => ComputeSequentialFieldLayout(type, numInstanceFields, layoutMetadata),
                 MetadataLayoutKind.CStruct => ComputeCStructFieldLayout(type, numInstanceFields),
+                MetadataLayoutKind.CUnion => ComputeCUnionFieldLayout(type, numInstanceFields),
                 _ => ComputeAutoFieldLayout(type, numInstanceFields, layoutMetadata),
             };
         }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunMetadataFieldLayoutAlgorithm.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunMetadataFieldLayoutAlgorithm.cs
@@ -612,6 +612,8 @@ protected override ComputedInstanceFieldLayout ComputeInstanceFieldLayout(Metada
             {
                 case MetadataLayoutKind.CStruct:
                     return ComputeCStructFieldLayout(type, numInstanceFields);
+                case MetadataLayoutKind.CUnion:
+                    return ComputeCUnionFieldLayout(type, numInstanceFields);
                 case MetadataLayoutKind.Explicit:
                     // Works around https://github.com/dotnet/runtime/issues/102868
                     if (type is { IsValueType: false, BaseType.IsSequentialLayout: true })
diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/TestMetadataFieldLayoutAlgorithm.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/TestMetadataFieldLayoutAlgorithm.cs
@@ -43,6 +43,10 @@ protected override ComputedInstanceFieldLayout ComputeInstanceFieldLayout(Metada
             {
                 return ComputeCStructFieldLayout(type, numInstanceFields);
             }
+            else if (layoutMetadata.Kind == MetadataLayoutKind.CUnion)
+            {
+                return ComputeCUnionFieldLayout(type, numInstanceFields);
+            }
             else
             {
                 return ComputeAutoFieldLayout(type, numInstanceFields, layoutMetadata);
diff --git a/src/coreclr/vm/class.h b/src/coreclr/vm/class.h
@@ -342,7 +342,8 @@ class EEClassLayoutInfo
             Auto = 0, // Make sure Auto is the default value as the default-constructed value represents the "auto layout" case
             Sequential,
             Explicit,
-            CStruct
+            CStruct,
+            CUnion
         };
     private:
         enum {
@@ -496,6 +497,12 @@ class EEClassLayoutInfo
             ULONG cFields
         );
 
+        ULONG InitializeCUnionFieldLayout(
+            FieldDesc* pFields,
+            MethodTable** pByValueClassCache,
+            ULONG cFields
+        );
+
     private:
         void SetIsZeroSized(BOOL isZeroSized)
         {
diff --git a/src/coreclr/vm/classlayoutinfo.cpp b/src/coreclr/vm/classlayoutinfo.cpp
@@ -636,6 +636,45 @@ ULONG EEClassLayoutInfo::InitializeCStructFieldLayout(
     return SetInstanceBytesSize(managedSize);
 }
 
+ULONG EEClassLayoutInfo::InitializeCUnionFieldLayout(
+    FieldDesc* pFields,
+    MethodTable** pByValueClassCache,
+    ULONG cFields
+)
+{
+    STANDARD_VM_CONTRACT;
+
+    SetLayoutType(LayoutType::CUnion);
+
+    NewArrayHolder<LayoutRawFieldInfo> pInfoArray = new LayoutRawFieldInfo[cFields + 1];
+    UINT32 numInstanceFields;
+    BYTE fieldsAlignmentRequirement;
+    InitializeLayoutFieldInfoArray(pFields, cFields, pByValueClassCache, DEFAULT_PACKING_SIZE, pInfoArray, &numInstanceFields, &fieldsAlignmentRequirement);
+
+    BYTE alignmentRequirement = max<BYTE>(1, fieldsAlignmentRequirement);
+
+    SetAlignmentRequirement(alignmentRequirement);
+    SetPackingSize(DEFAULT_PACKING_SIZE);
+
+    // For a union, all fields are placed at offset 0
+    // and the size is the maximum of all field sizes
+    UINT32 maxFieldSize = 0;
+    for (UINT32 i = 0; i < numInstanceFields; i++)
+    {
+        pInfoArray[i].m_placement.m_offset = 0;
+        if (pInfoArray[i].m_placement.m_size > maxFieldSize)
+        {
+            maxFieldSize = pInfoArray[i].m_placement.m_size;
+        }
+    }
+
+    SetFieldOffsets(pFields, cFields, pInfoArray, numInstanceFields);
+
+    UINT32 managedSize = AlignSize(maxFieldSize, alignmentRequirement);
+
+    return SetInstanceBytesSize(managedSize);
+}
+
 namespace
 {
     #ifdef UNIX_AMD64_ABI
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
@@ -3724,6 +3724,9 @@ uint32_t CEEInfo::getClassAttribsInternal (CORINFO_CLASS_HANDLE clsHnd)
 
             if (pClass->IsUnsafeValueClass())
                 ret |= CORINFO_FLG_UNSAFE_VALUECLASS;
+
+            if (pClass->HasLayout() && pClass->GetLayoutInfo()->GetLayoutType() == EEClassLayoutInfo::LayoutType::CUnion)
+                ret |= CORINFO_FLG_OVERLAPPING_FIELDS;
         }
         if (pClass->HasExplicitFieldOffsetLayout() && pClass->HasOverlaidField())
             ret |= CORINFO_FLG_OVERLAPPING_FIELDS;
diff --git a/src/coreclr/vm/methodtablebuilder.cpp b/src/coreclr/vm/methodtablebuilder.cpp
@@ -8319,10 +8319,11 @@ VOID MethodTableBuilder::PlaceInstanceFields(MethodTable** pByValueClassCache)
     {
         if (!pParentMT->IsValueTypeClass()
             || hasGCFields
+            || bmtFP->fIsByRefLikeType
             || isAutoLayoutOrHasAutoLayoutField)
         {
             // CStruct layout types can't have a parent type, GC fields
-            // or auto layout fields.
+            // byreflike types, or auto layout fields.
             BuildMethodTableThrowException(IDS_CLASSLOAD_BADFORMAT);
         }
 
@@ -8335,6 +8336,27 @@ VOID MethodTableBuilder::PlaceInstanceFields(MethodTable** pByValueClassCache)
         break;
     }
 
+    case EEClassLayoutInfo::LayoutType::CUnion:
+    {
+        if (!pParentMT->IsValueTypeClass()
+            || hasGCFields
+            || bmtFP->fIsByRefLikeType
+            || isAutoLayoutOrHasAutoLayoutField)
+        {
+            // CUnion layout types can't have a parent type, GC fields
+            // byreflike types, or auto layout fields.
+            BuildMethodTableThrowException(IDS_CLASSLOAD_BADFORMAT);
+        }
+
+        // Explicit size is not used for CUnion layout.
+        pLayoutInfo->SetHasExplicitSize(FALSE);
+        // CUnion layouts are always blittable
+        pLayoutInfo->SetIsBlittable(TRUE);
+
+        HandleCUnionLayout(pByValueClassCache);
+        break;
+    }
+
     default:
         UNREACHABLE();
         break;
@@ -8824,6 +8846,33 @@ VOID MethodTableBuilder::HandleCStructLayout(MethodTable** pByValueClassCache)
     }
 }
 
+VOID MethodTableBuilder::HandleCUnionLayout(MethodTable** pByValueClassCache)
+{
+    STANDARD_VM_CONTRACT;
+
+    _ASSERTE(HasLayout());
+
+    EEClassLayoutInfo* pLayoutInfo = GetLayoutInfo();
+
+    CONSISTENCY_CHECK(pLayoutInfo != nullptr);
+
+    bmtFP->NumInstanceFieldBytes = pLayoutInfo->InitializeCUnionFieldLayout(
+        GetHalfBakedClass()->GetFieldDescList(),
+        pByValueClassCache,
+        bmtEnumFields->dwNumDeclaredFields
+    );
+
+    if (bmtFP->NumInlineArrayElements != 0)
+    {
+        BuildMethodTableThrowException(IDS_CLASSLOAD_BADFORMAT);
+    }
+
+    if (pLayoutInfo->IsZeroSized())
+    {
+        BuildMethodTableThrowException(IDS_CLASSLOAD_BADFORMAT);
+    }
+}
+
 //*******************************************************************************
 // this accesses the field size which is temporarily stored in m_pMTOfEnclosingClass
 // during class loading. Don't use any other time
@@ -12572,6 +12621,10 @@ BOOL HasLayoutMetadata(Assembly* pAssembly, IMDInternalImport* pInternalImport,
         {
             *pLayoutType = EEClassLayoutInfo::LayoutType::CStruct;
         }
+        else if (kind == CorExtendedLayoutKind::CUnion)
+        {
+            *pLayoutType = EEClassLayoutInfo::LayoutType::CUnion;
+        }
         else
         {
             pAssembly->ThrowTypeLoadException(pInternalImport, cl, IDS_CLASSLOAD_BADFORMAT);
diff --git a/src/coreclr/vm/methodtablebuilder.h b/src/coreclr/vm/methodtablebuilder.h
@@ -3000,6 +3000,9 @@ class MethodTableBuilder
     VOID HandleCStructLayout(
         MethodTable **);
 
+    VOID HandleCUnionLayout(
+        MethodTable **);
+
     VOID    CheckForHFA(MethodTable ** pByValueClassCache);
 
     VOID    CheckForNativeHFA();
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ExtendedLayoutKind.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ExtendedLayoutKind.cs
@@ -12,5 +12,11 @@ public enum ExtendedLayoutKind
         /// The value type should have its fields laid out in accordance with the C language struct layout rules.
         /// </summary>
         CStruct = 0,
+
+        /// <summary>
+        /// The value type should have its fields laid out like a C union, where all fields are placed at offset 0.
+        /// This layout only supports value types without GC pointers.
+        /// </summary>
+        CUnion = 1,
     }
 }
diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs
@@ -14534,6 +14534,7 @@ public ExtendedLayoutAttribute(System.Runtime.InteropServices.ExtendedLayoutKind
     public enum ExtendedLayoutKind
     {
         CStruct = 0,
+        CUnion = 1,
     }
     public partial class ExternalException : System.SystemException
     {
diff --git a/src/mono/mono/metadata/class-init.c b/src/mono/mono/metadata/class-init.c
diff --git a/src/tests/Loader/classloader/ExtendedLayout/CStruct.cs b/src/tests/Loader/classloader/ExtendedLayout/CStruct.cs
diff --git a/src/tests/Loader/classloader/ExtendedLayout/CUnion.cs b/src/tests/Loader/classloader/ExtendedLayout/CUnion.cs
diff --git a/src/tests/Loader/classloader/ExtendedLayout/ExtendedLayout.csproj b/src/tests/Loader/classloader/ExtendedLayout/ExtendedLayout.csproj
diff --git a/src/tests/Loader/classloader/ExtendedLayout/ExtendedLayoutTypes.il b/src/tests/Loader/classloader/ExtendedLayout/ExtendedLayoutTypes.il

Original file line number	Diff line number	Diff line change
`@@ -329,6 +329,7 @@ typedef enum CorTypeAttr`
`329`	`329`	`enum class CorExtendedLayoutKind`
`330`	`330`	`{`
`331`	`331`	`CStruct = 0, // C-style struct`
	`332`	`+ CUnion = 1, // C-style union`
`332`	`333`	`};`
`333`	`334`
`334`	`335`	`// Macros for accessing the members of the CorTypeAttr.`
Original file line number	Diff line number	Diff line change
`@@ -125,6 +125,7 @@ public enum MetadataLayoutKind`
`125`	`125`	`Auto,`
`126`	`126`	`Sequential,`
`127`	`127`	`Explicit,`
`128`		`- CStruct`
	`128`	`+ CStruct,`
	`129`	`+ CUnion`
`129`	`130`	`}`
`130`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public static bool IsBlittableType(TypeDesc type)`
`31`	`31`
`32`	`32`	`if (mdType.IsExtendedLayout)`
`33`	`33`	`{`
`34`		`- return mdType.GetClassLayout().Kind is MetadataLayoutKind.CStruct;`
	`34`	`+ return mdType.GetClassLayout().Kind is MetadataLayoutKind.CStruct or MetadataLayoutKind.CUnion;`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`if (mdType.IsAutoLayout)`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,7 @@ protected override ComputedInstanceFieldLayout ComputeInstanceFieldLayout(Metada`
`49`	`49`	`// all types without GC references (ie C# unmanaged types).`
`50`	`50`	`MetadataLayoutKind.Sequential when !type.ContainsGCPointers => ComputeSequentialFieldLayout(type, numInstanceFields, layoutMetadata),`
`51`	`51`	`MetadataLayoutKind.CStruct => ComputeCStructFieldLayout(type, numInstanceFields),`
	`52`	`+ MetadataLayoutKind.CUnion => ComputeCUnionFieldLayout(type, numInstanceFields),`
`52`	`53`	`_ => ComputeAutoFieldLayout(type, numInstanceFields, layoutMetadata),`
`53`	`54`	`};`
`54`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -612,6 +612,8 @@ protected override ComputedInstanceFieldLayout ComputeInstanceFieldLayout(Metada`
`612`	`612`	`{`
`613`	`613`	`case MetadataLayoutKind.CStruct:`
`614`	`614`	`return ComputeCStructFieldLayout(type, numInstanceFields);`
	`615`	`+ case MetadataLayoutKind.CUnion:`
	`616`	`+ return ComputeCUnionFieldLayout(type, numInstanceFields);`
`615`	`617`	`case MetadataLayoutKind.Explicit:`
`616`	`618`	`// Works around https://github.com/dotnet/runtime/issues/102868`
`617`	`619`	`if (type is { IsValueType: false, BaseType.IsSequentialLayout: true })`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,10 @@ protected override ComputedInstanceFieldLayout ComputeInstanceFieldLayout(Metada`
`43`	`43`	`{`
`44`	`44`	`return ComputeCStructFieldLayout(type, numInstanceFields);`
`45`	`45`	`}`
	`46`	`+ else if (layoutMetadata.Kind == MetadataLayoutKind.CUnion)`
	`47`	`+ {`
	`48`	`+ return ComputeCUnionFieldLayout(type, numInstanceFields);`
	`49`	`+ }`
`46`	`50`	`else`
`47`	`51`	`{`
`48`	`52`	`return ComputeAutoFieldLayout(type, numInstanceFields, layoutMetadata);`