Adding the Vector512 and Vector512<T> types

src/coreclr/tools/Common/Compiler/VectorFieldLayoutAlgorithm.cs

@@ -44,7 +44,7 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp
                     alignment = new LayoutInt(16);
                 }
             }
-            else
+            else if (name == "Vector256`1")
             {
                 Debug.Assert(name == "Vector256`1");
 
@@ -65,6 +65,27 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp
                     alignment = new LayoutInt(32);
                 }
             }
+            else
+            {
+                Debug.Assert(name == "Vector512`1");
+
+                if (defType.Context.Target.Architecture == TargetArchitecture.ARM)
+                {
+                    // No such type exists for the Procedure Call Standard for ARM. We will default
+                    // to the same alignment as __m128, which is supported by the ABI.
+                    alignment = new LayoutInt(8);
+                }
+                else if (defType.Context.Target.Architecture == TargetArchitecture.ARM64)
+                {
+                    // The Procedure Call Standard for ARM 64-bit (with SVE support) defaults to
+                    // 16-byte alignment for __m256.
+                    alignment = new LayoutInt(16);
+                }
+                else
+                {
+                    alignment = new LayoutInt(64);
+                }
+            }
 
             ComputedInstanceFieldLayout layoutFromMetadata = _fallbackAlgorithm.ComputeInstanceLayout(defType, layoutKind);
 
@@ -116,9 +137,10 @@ public static bool IsVectorType(DefType type)
         {
             return type.IsIntrinsic &&
                 type.Namespace == "System.Runtime.Intrinsics" &&
-                (type.Name == "Vector64`1" ||
-                type.Name == "Vector128`1" ||
-                type.Name == "Vector256`1");
+                ((type.Name == "Vector64`1") ||
+                 (type.Name == "Vector128`1") ||
+                 (type.Name == "Vector256`1") ||
+                 (type.Name == "Vector512`1"));
         }
     }
 }

src/coreclr/tools/Common/TypeSystem/CodeGen/TargetDetails.CodeGen.cs

@@ -40,5 +40,10 @@ public enum SimdVectorLength
         /// Specifies that native vectors are 256 bit (e.g. AVX on x86).
         /// </summary>
         Vector256Bit,
+
+        /// <summary>
+        /// Specifies that native vectors are 512 bit (e.g. AVX512 on x86).
+        /// </summary>
+        Vector512Bit,
     }
 }

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

@@ -109,21 +109,21 @@ public int MaximumAlignment
             {
                 if (Architecture == TargetArchitecture.ARM)
                 {
-                    // Corresponds to alignment required for __m128 (there's no __m256)
+                    // Corresponds to alignment required for __m128 (there's no __m256/__m512)
                     return 8;
                 }
                 else if (Architecture == TargetArchitecture.ARM64)
                 {
-                    // Corresponds to alignmet required for __m256
+                    // Corresponds to alignmet required for __m128 (there's no __m256/__m512)
                     return 16;
                 }
                 else if (Architecture == TargetArchitecture.LoongArch64)
                 {
                     return 16;
                 }
 
-                // 256-bit vector is the type with the highest alignment we support
-                return 32;
+                // 512-bit vector is the type with the highest alignment we support
+                return 64;
             }
         }
 
@@ -136,8 +136,8 @@ public int DefaultPackingSize
         {
             get
             {
-                // We use default packing size of 32 irrespective of the platform.
-                return 32;
+                // We use default packing size of 64 irrespective of the platform.
+                return 64;
             }
         }
 

src/coreclr/tools/Common/TypeSystem/Interop/IL/MarshalHelpers.cs

@@ -873,13 +873,15 @@ private static bool IsValidForGenericMarshalling(
             // * Vector64<T>: Represents the __m64 ABI primitive which requires currently unimplemented handling
             // * Vector128<T>: Represents the __m128 ABI primitive which requires currently unimplemented handling
             // * Vector256<T>: Represents the __m256 ABI primitive which requires currently unimplemented handling
+            // * Vector512<T>: Represents the __m512 ABI primitive which requires currently unimplemented handling
             // * Vector<T>: Has a variable size (either __m128 or __m256) and isn't readily usable for interop scenarios
             return !InteropTypes.IsSystemNullable(type.Context, type)
                 && !InteropTypes.IsSystemSpan(type.Context, type)
                 && !InteropTypes.IsSystemReadOnlySpan(type.Context, type)
                 && !InteropTypes.IsSystemRuntimeIntrinsicsVector64T(type.Context, type)
                 && !InteropTypes.IsSystemRuntimeIntrinsicsVector128T(type.Context, type)
                 && !InteropTypes.IsSystemRuntimeIntrinsicsVector256T(type.Context, type)
+                && !InteropTypes.IsSystemRuntimeIntrinsicsVector512T(type.Context, type)
                 && !InteropTypes.IsSystemNumericsVectorT(type.Context, type);
         }
 

src/coreclr/tools/Common/TypeSystem/Interop/InteropTypes.cs

@@ -145,6 +145,11 @@ public static bool IsSystemRuntimeIntrinsicsVector256T(TypeSystemContext context
             return IsCoreNamedType(context, type, "System.Runtime.Intrinsics", "Vector256`1");
         }
 
+        public static bool IsSystemRuntimeIntrinsicsVector512T(TypeSystemContext context, TypeDesc type)
+        {
+            return IsCoreNamedType(context, type, "System.Runtime.Intrinsics", "Vector512`1");
+        }
+
         public static bool IsSystemNumericsVectorT(TypeSystemContext context, TypeDesc type)
         {
             return IsCoreNamedType(context, type, "System.Numerics", "Vector`1");

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/VectorOfTFieldLayoutAlgorithm.cs

@@ -36,6 +36,10 @@ public override ComputedInstanceFieldLayout ComputeInstanceLayout(DefType defTyp
             {
                 instanceFieldSize = new LayoutInt(32);
             }
+            else if (targetDetails.MaximumSimdVectorLength == SimdVectorLength.Vector512Bit)
+            {
+                instanceFieldSize = new LayoutInt(64);
+            }
             else
             {
                 Debug.Assert(targetDetails.MaximumSimdVectorLength == SimdVectorLength.None);

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

@@ -52,6 +52,8 @@ public ReadyToRunCompilerContext(TargetDetails details, SharedGenericsMode gener
                 matchingVectorType = "Vector128`1";
             else if (details.MaximumSimdVectorLength == SimdVectorLength.Vector256Bit)
                 matchingVectorType = "Vector256`1";
+            else if (details.MaximumSimdVectorLength == SimdVectorLength.Vector512Bit)
+                matchingVectorType = "Vector512`1";
 
             // No architecture has completely stable handling of Vector<T> in the abi (Arm64 may change to SVE)
             _vectorOfTFieldLayoutAlgorithm = new VectorOfTFieldLayoutAlgorithm(_r2rFieldLayoutAlgorithm, _vectorFieldLayoutAlgorithm, matchingVectorType, bubbleIncludesCorelib);

src/coreclr/vm/classlayoutinfo.cpp

@@ -162,6 +162,7 @@ namespace
             case 8:
             case 16:
             case 32:
+            case 64:
                 break;
             default:
                 COMPlusThrowHR(COR_E_INVALIDPROGRAM, BFA_METADATA_CORRUPT);
@@ -979,7 +980,8 @@ EEClassNativeLayoutInfo* EEClassNativeLayoutInfo::CollectNativeLayoutFieldMetada
             pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__UINT128)) ||
             pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR64T)) ||
             pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR128T)) ||
-            pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR256T)))
+            pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR256T)) ||
+            pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR512T)))
         {
             pNativeLayoutInfo->m_alignmentRequirement = pEEClassLayoutInfo->m_ManagedLargestAlignmentRequirementOfAllMembers;
         }

src/coreclr/vm/classnames.h

@@ -52,6 +52,9 @@
 #define g_Vector256ClassName "System.Runtime.Intrinsics.Vector256`1"
 #define g_Vector256Name "Vector256`1"
 
+#define g_Vector512ClassName "System.Runtime.Intrinsics.Vector512`1"
+#define g_Vector512Name "Vector512`1"
+
 #define g_EnumeratorToEnumClassName "System.Runtime.InteropServices.CustomMarshalers.EnumeratorToEnumVariantMarshaler"
 #define g_ExceptionClassName "System.Exception"
 #define g_ExecutionEngineExceptionClassName "System.ExecutionEngineException"

src/coreclr/vm/corelib.h

@@ -484,6 +484,7 @@ DEFINE_METHOD(NATIVELIBRARY,        LOADLIBRARYCALLBACKSTUB, LoadLibraryCallback
 DEFINE_CLASS(VECTOR64T,             Intrinsics,             Vector64`1)
 DEFINE_CLASS(VECTOR128T,            Intrinsics,             Vector128`1)
 DEFINE_CLASS(VECTOR256T,            Intrinsics,             Vector256`1)
+DEFINE_CLASS(VECTOR512T,            Intrinsics,             Vector512`1)
 
 DEFINE_CLASS(VECTORT,               Numerics,               Vector`1)
 

src/coreclr/vm/fieldmarshaler.h

@@ -24,7 +24,7 @@ class MethodTable;
 // Currently we set this to the packing size of the largest supported
 // fundamental type and let the field marshaller downsize where needed.
 //=======================================================================
-#define DEFAULT_PACKING_SIZE 32
+#define DEFAULT_PACKING_SIZE 64
 
 //=======================================================================
 // This structure contains information about where a field is placed in a structure, as well as it's size and alignment.

src/coreclr/vm/methodtable.cpp

@@ -2237,8 +2237,8 @@ bool MethodTable::ClassifyEightBytesWithManagedLayout(SystemVStructRegisterPassi
         LPCUTF8 namespaceName;
         LPCUTF8 className = GetFullyQualifiedNameInfo(&namespaceName);
 
-        if ((strcmp(className, "Vector256`1") == 0) || (strcmp(className, "Vector128`1") == 0) ||
-            (strcmp(className, "Vector64`1") == 0))
+        if ((strcmp(className, "Vector512`1") == 0) || (strcmp(className, "Vector256`1") == 0) ||
+            (strcmp(className, "Vector128`1") == 0) || (strcmp(className, "Vector64`1") == 0))
         {
             assert(strcmp(namespaceName, "System.Runtime.Intrinsics") == 0);
 
@@ -2487,8 +2487,8 @@ bool MethodTable::ClassifyEightBytesWithNativeLayout(SystemVStructRegisterPassin
         LPCUTF8 namespaceName;
         LPCUTF8 className = GetFullyQualifiedNameInfo(&namespaceName);
 
-        if ((strcmp(className, "Vector256`1") == 0) || (strcmp(className, "Vector128`1") == 0) ||
-            (strcmp(className, "Vector64`1") == 0))
+        if ((strcmp(className, "Vector512`1") == 0) || (strcmp(className, "Vector256`1") == 0) ||
+            (strcmp(className, "Vector128`1") == 0) || (strcmp(className, "Vector64`1") == 0))
         {
             assert(strcmp(namespaceName, "System.Runtime.Intrinsics") == 0);
 

src/coreclr/vm/methodtablebuilder.cpp

@@ -9884,6 +9884,22 @@ void MethodTableBuilder::CheckForSystemTypes()
                     pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 16;
     #else
                     pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 32; // sizeof(__m256)
+    #endif // TARGET_ARM elif TARGET_ARM64
+                }
+                else if (strcmp(name, g_Vector512Name) == 0)
+                {
+    #ifdef TARGET_ARM
+                    // No such type exists for the Procedure Call Standard for ARM. We will default
+                    // to the same alignment as __m128, which is supported by the ABI.
+
+                    pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 8;
+    #elif defined(TARGET_ARM64)
+                    // The Procedure Call Standard for ARM 64-bit (with SVE support) defaults to
+                    // 16-byte alignment for __m256.
+
+                    pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 16;
+    #else
+                    pLayout->m_ManagedLargestAlignmentRequirementOfAllMembers = 64; // sizeof(__m512)
     #endif // TARGET_ARM elif TARGET_ARM64
                 }
                 else

src/coreclr/vm/mlinfo.cpp

@@ -1081,13 +1081,15 @@ namespace
         // * Vector64<T>: Represents the __m64 ABI primitive which requires currently unimplemented handling
         // * Vector128<T>: Represents the __m128 ABI primitive which requires currently unimplemented handling
         // * Vector256<T>: Represents the __m256 ABI primitive which requires currently unimplemented handling
+        // * Vector512<T>: Represents the __m512 ABI primitive which requires currently unimplemented handling
         // * Vector<T>: Has a variable size (either __m128 or __m256) and isn't readily usable for interop scenarios
         return !pMT->HasSameTypeDefAs(g_pNullableClass)
             && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__SPAN))
             && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__READONLY_SPAN))
             && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR64T))
             && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR128T))
             && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR256T))
+            && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTOR512T))
             && !pMT->HasSameTypeDefAs(CoreLibBinder::GetClass(CLASS__VECTORT));
     }
 

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -927,6 +927,9 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector256.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector256_1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector256DebugView_1.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector512.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector512_1.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector512DebugView_1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector64.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector64_1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\Vector64DebugView_1.cs" />