Allow vector types and SwiftSelf as parameter types for CallConvSwift signatures

Author: jkoritzinsky

src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs

@@ -392,7 +392,8 @@ public enum CorInfoCallConvExtension
         // New calling conventions supported with the extensible calling convention encoding go here.
         CMemberFunction,
         StdcallMemberFunction,
-        FastcallMemberFunction
+        FastcallMemberFunction,
+        Swift
     }
 
     public enum CORINFO_CALLINFO_FLAGS

src/coreclr/tools/Common/TypeSystem/IL/Stubs/PInvokeILEmitter.cs

@@ -394,8 +394,8 @@ private PInvokeILStubMethodIL EmitIL()
                 // Throw an exception if we encounter a value type that is not a primitive (and as such needs this lowering logic applied).
                 foreach (var marshaller in _marshallers)
                 {
-                    if (marshaller.ManagedType is DefType { IsValueType: true, IsEnum: false, IsPrimitive: false } paramType
-                        && !VectorFieldLayoutAlgorithm.IsVectorType(paramType))
+                    if (marshaller.ManagedType is { IsValueType: true, IsEnum: false, IsPrimitive: false } param
+                        && !MarshalHelpers.IsSwiftIntrinsicValueType(param))
                     {
                         throw new NotSupportedException();
                     }

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

@@ -4,6 +4,7 @@
 using System;
 using Debug = System.Diagnostics.Debug;
 using System.Runtime.InteropServices.ObjectiveC;
+using ILCompiler;
 using Internal.TypeSystem.Ecma;
 
 namespace Internal.TypeSystem.Interop
@@ -971,5 +972,23 @@ public static bool IsRuntimeMarshallingEnabled(ModuleDesc module)
         {
             return module.Assembly is not EcmaAssembly assembly || !assembly.HasAssemblyCustomAttribute("System.Runtime.CompilerServices", "DisableRuntimeMarshallingAttribute");
         }
+
+        public static bool IsSwiftIntrinsicValueType(TypeDesc type)
+        {
+            Debug.Assert(type.IsValueType && !type.IsPrimitive && !type.IsEnum);
+            if (!type.IsIntrinsic)
+                return false;
+
+            if (type is not DefType defType)
+                return false;
+
+            if (VectorFieldLayoutAlgorithm.IsVectorType(defType))
+                return true;
+
+            if (defType is { Namespace: "System.Runtime.InteropServices.Swift", Name: "SwiftSelf" })
+                return true;
+
+            return false;
+        }
     }
 }

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Interop/IL/Marshaller.ReadyToRun.cs

@@ -126,8 +126,8 @@ public static bool IsMarshallingRequired(MethodDesc targetMethod)
                 // Skip stub generation of Swift methods with value types to allow an exception at runtime.
                 foreach (var param in targetMethod.Signature)
                 {
-                    if (param is DefType { IsValueType: true, IsEnum: false, IsPrimitive: false } defType
-                        && !VectorFieldLayoutAlgorithm.IsVectorType(paramType))
+                    if (param is { IsValueType: true, IsEnum: false, IsPrimitive: false }
+                        && !MarshalHelpers.IsSwiftIntrinsicValueType(param))
                     {
                         return true;
                     }
@@ -152,8 +152,8 @@ public static bool IsMarshallingRequired(MethodSignature methodSig, ParameterMet
                 // Skip stub generation of Swift methods with value types to allow an exception at runtime.
                 foreach (var param in methodSig)
                 {
-                    if (param is DefType { IsValueType: true, IsEnum: false, IsPrimitive: false } defType
-                        && !VectorFieldLayoutAlgorithm.IsVectorType(paramType))
+                    if (param is { IsValueType: true, IsEnum: false, IsPrimitive: false }
+                        && !MarshalHelpers.IsSwiftIntrinsicValueType(param))
                     {
                         return true;
                     }

src/coreclr/vm/dllimport.cpp

@@ -3167,6 +3167,40 @@ HRESULT NDirect::HasNAT_LAttribute(IMDInternalImport *pInternalImport, mdToken t
     return S_FALSE;
 }
 
+namespace
+{
+    bool IsSwiftIntrinsicValueType(TypeHandle hnd)
+    {
+        STANDARD_VM_CONTRACT;
+
+        _ASSERTE(hnd.IsValueType());
+        MethodTable* pMT = hnd.GetMethodTable();
+        if (!pMT->IsIntrinsicType())
+            return false;
+
+        LPCUTF8 namespaceName;
+        LPCUTF8 className = pMT->GetFullyQualifiedNameInfo(&namespaceName);
+
+        // We treat the .NET vector types as projections of the Swift SIMD intrinsic types.
+        if ((strcmp(className, "Vector512`1") == 0) || (strcmp(className, "Vector256`1") == 0) ||
+            (strcmp(className, "Vector128`1") == 0) || (strcmp(className, "Vector64`1") == 0))
+        {
+            _ASSERTE(strcmp(namespaceName, "System.Runtime.Intrinsics") == 0);
+            return true;
+        }
+
+        // The SwiftSelf type is an intrinsic type that represents the Swift self register.
+        if (strcmp(className, "SwiftSelf") == 0)
+        {
+            _ASSERTE(strcmp(namespaceName, "System.Runtime.InteropServices.Swift") == 0);
+            return true;
+        }
+
+        // We don't need to treat the SwiftError type as an intrinsic here as it should always be passed
+        // as a SwiftError* parameter.
+        return false;
+    }
+}
 
 // Either MD or signature & module must be given.
 /*static*/
@@ -3349,7 +3383,7 @@ BOOL NDirect::MarshalingRequired(
                     // Instead, we implement it in the projection layer. The runtime and JIT should only see pre-lowered, LLVM-IR-equivalent
                     // signatures.
                     // Require marshalling here so we can easily throw an exception during IL Stub generation.
-                    return TRUE;
+                    return !IsSwiftIntrinsicValueType(hndArgType);
                 }
 
                 if (i > 0)
@@ -4350,14 +4384,12 @@ static void CreateNDirectStubAccessMetadata(
     {
         // Swift has a very complicated lowering algorithm for structs. The .NET JIT does not support it,
         // so throw an exception here if we encounter a signature that uses any value types.
-        if (msig.GetReturnTypeNormalized() == ELEMENT_TYPE_VALUETYPE)
-        {
-            COMPlusThrow(kNotSupportedException, IDS_EE_NDIRECT_SWIFT_VALUETYPE);
-        }
 
         for (int i = 0; i < (*pNumArgs); i++)
         {
-            if (msig.NextArgNormalized() == ELEMENT_TYPE_VALUETYPE)
+            TypeHandle hnd;
+            if (msig.NextArgNormalized(&hnd) == ELEMENT_TYPE_VALUETYPE
+                && !IsSwiftIntrinsicValueType(hnd))
             {
                 COMPlusThrow(kNotSupportedException, IDS_EE_NDIRECT_SWIFT_VALUETYPE);
             }