Parse CallConvSwift in CoreCLR/NativeAOT (#96707)

jkoritzinsky · web-flow · commit f48a99ea3882 · 2024-01-30T14:52:52.000-08:00
diff --git a/src/coreclr/inc/corhdr.h b/src/coreclr/inc/corhdr.h
@@ -1715,6 +1715,7 @@ typedef enum LoadHintEnum
 #define CMOD_CALLCONV_NAME_STDCALL              "CallConvStdcall"
 #define CMOD_CALLCONV_NAME_THISCALL             "CallConvThiscall"
 #define CMOD_CALLCONV_NAME_FASTCALL             "CallConvFastcall"
+#define CMOD_CALLCONV_NAME_SWIFT                "CallConvSwift"
 #define CMOD_CALLCONV_NAME_SUPPRESSGCTRANSITION "CallConvSuppressGCTransition"
 #define CMOD_CALLCONV_NAME_MEMBERFUNCTION       "CallConvMemberFunction"
 
diff --git a/src/coreclr/inc/corinfo.h b/src/coreclr/inc/corinfo.h
@@ -772,7 +772,8 @@ enum class CorInfoCallConvExtension
     // New calling conventions supported with the extensible calling convention encoding go here.
     CMemberFunction,
     StdcallMemberFunction,
-    FastcallMemberFunction
+    FastcallMemberFunction,
+    Swift
 };
 
 #ifdef TARGET_X86
diff --git a/src/coreclr/jit/importercalls.cpp b/src/coreclr/jit/importercalls.cpp
@@ -5605,7 +5605,8 @@ void Compiler::impCheckForPInvokeCall(
     // return here without inlining the native call.
     if (unmanagedCallConv == CorInfoCallConvExtension::Managed ||
         unmanagedCallConv == CorInfoCallConvExtension::Fastcall ||
-        unmanagedCallConv == CorInfoCallConvExtension::FastcallMemberFunction)
+        unmanagedCallConv == CorInfoCallConvExtension::FastcallMemberFunction ||
+        unmanagedCallConv == CorInfoCallConvExtension::Swift)
     {
         return;
     }
diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs
@@ -1589,6 +1589,9 @@ private static CorInfoCallConvExtension ToCorInfoCallConvExtension(UnmanagedCall
                 case UnmanagedCallingConventions.Fastcall:
                     result = CorInfoCallConvExtension.Fastcall;
                     break;
+                case UnmanagedCallingConventions.Swift:
+                    result = CorInfoCallConvExtension.Swift;
+                    break;
                 default:
                     ThrowHelper.ThrowInvalidProgramException();
                     result = CorInfoCallConvExtension.Managed; // unreachable
@@ -4124,7 +4127,7 @@ private uint getJitFlags(ref CORJIT_FLAGS flags, uint sizeInBytes)
 
 #if READYTORUN
                 // TODO: enable this check in full AOT
-                if (Marshaller.IsMarshallingRequired(this.MethodBeingCompiled.Signature, Array.Empty<ParameterMetadata>(), ((MetadataType)this.MethodBeingCompiled.OwningType).Module)) // Only blittable arguments
+                if (Marshaller.IsMarshallingRequired(this.MethodBeingCompiled.Signature, ((MetadataType)this.MethodBeingCompiled.OwningType).Module, this.MethodBeingCompiled.GetUnmanagedCallersOnlyMethodCallingConventions())) // Only blittable arguments
                 {
                     ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramNonBlittableTypes, this.MethodBeingCompiled);
                 }
diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs b/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
diff --git a/src/coreclr/tools/Common/TypeSystem/Interop/UnmanagedCallingConventions.cs b/src/coreclr/tools/Common/TypeSystem/Interop/UnmanagedCallingConventions.cs
@@ -40,7 +40,7 @@ public enum UnmanagedCallingConventions
         // Unmanaged            = 0x00000009, - this one is always translated to cdecl/stdcall
 
         // The ones higher than 0xF are defined by the type system
-        // There are no such calling conventions yet.
+        Swift                   = 0x00000010
     }
 
     public static class CallingConventionExtensions
@@ -135,6 +135,25 @@ public static UnmanagedCallingConventions GetPInvokeMethodCallingConventions(thi
             return result;
         }
 
+        public static UnmanagedCallingConventions GetDelegateCallingConventions(this TypeDesc delegateType)
+        {
+            Debug.Assert(delegateType.IsDelegate);
+
+            if (delegateType is EcmaType ecmaDelegate)
+            {
+                MethodSignatureFlags unmanagedCallConv = ecmaDelegate.GetDelegatePInvokeFlags().UnmanagedCallingConvention;
+                if (unmanagedCallConv != MethodSignatureFlags.None)
+                {
+                    Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)UnmanagedCallingConventions.Cdecl
+                        && (int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)UnmanagedCallingConventions.Stdcall
+                        && (int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)UnmanagedCallingConventions.Thiscall);
+                    return (UnmanagedCallingConventions)unmanagedCallConv;
+                }
+            }
+
+            return GetPlatformDefaultUnmanagedCallingConvention(delegateType.Context);
+        }
+
         private static UnmanagedCallingConventions GetUnmanagedCallingConventionFromAttribute(CustomAttributeValue<TypeDesc> attributeWithCallConvsArray, TypeSystemContext context)
         {
             ImmutableArray<CustomAttributeTypedArgument<TypeDesc>> callConvArray = default;
@@ -181,6 +200,7 @@ private static UnmanagedCallingConventions AccumulateCallingConventions(Unmanage
                 "CallConvThiscall" => UnmanagedCallingConventions.Thiscall,
                 "CallConvSuppressGCTransition" => UnmanagedCallingConventions.IsSuppressGcTransition,
                 "CallConvMemberFunction" => UnmanagedCallingConventions.IsMemberFunction,
+                "CallConvSwift" => UnmanagedCallingConventions.Swift,
                 _ => null
             };
 
@@ -218,6 +238,7 @@ public static EmbeddedSignatureData[] EncodeAsEmbeddedSignatureData(this Unmanag
                     UnmanagedCallingConventions.Stdcall => "CallConvStdcall",
                     UnmanagedCallingConventions.Fastcall => "CallConvFastcall",
                     UnmanagedCallingConventions.Thiscall => "CallConvThiscall",
+                    UnmanagedCallingConventions.Swift => "CallConvSwift",
                     _ => throw new InvalidProgramException()
                 });
             }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Interop/IL/Marshaller.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Interop/IL/Marshaller.ReadyToRun.cs
@@ -130,6 +130,18 @@ public static bool IsMarshallingRequired(MethodDesc targetMethod)
             return false;
         }
 
+        public static bool IsMarshallingRequired(MethodSignature methodSig, ModuleDesc moduleContext, UnmanagedCallingConventions callingConvention)
+        {
+            Marshaller[] marshallers = GetMarshallersForSignature(methodSig, System.Array.Empty<ParameterMetadata>(), moduleContext);
+            for (int i = 0; i < marshallers.Length; i++)
+            {
+                if (marshallers[i].IsMarshallingRequired())
+                    return true;
+            }
+
+            return false;
+        }
+
         public static bool IsMarshallingRequired(MethodSignature methodSig, ParameterMetadata[] paramMetadata, ModuleDesc moduleContext)
         {
             Marshaller[] marshallers = GetMarshallersForSignature(methodSig, paramMetadata, moduleContext);
diff --git a/src/coreclr/vm/callconvbuilder.cpp b/src/coreclr/vm/callconvbuilder.cpp
@@ -53,7 +53,8 @@ namespace
     BASE_CALL_CONV(CMOD_CALLCONV_NAME_CDECL, C)             \
     BASE_CALL_CONV(CMOD_CALLCONV_NAME_STDCALL, Stdcall)     \
     BASE_CALL_CONV(CMOD_CALLCONV_NAME_THISCALL, Thiscall)   \
-    BASE_CALL_CONV(CMOD_CALLCONV_NAME_FASTCALL, Fastcall)
+    BASE_CALL_CONV(CMOD_CALLCONV_NAME_FASTCALL, Fastcall)   \
+    BASE_CALL_CONV(CMOD_CALLCONV_NAME_SWIFT, Swift)
 
 #define DECLARE_MOD_CALL_CONVS \
     CALL_CONV_MODIFIER(CMOD_CALLCONV_NAME_SUPPRESSGCTRANSITION, CALL_CONV_MOD_SUPPRESSGCTRANSITION) \
@@ -176,6 +177,8 @@ namespace
             return CorInfoCallConvExtension::FastcallMemberFunction;
         case CorInfoCallConvExtension::Thiscall:
             return CorInfoCallConvExtension::Thiscall;
+        case CorInfoCallConvExtension::Swift:
+            return CorInfoCallConvExtension::Swift;
         default:
             _ASSERTE("Calling convention is not an unmanaged base calling convention.");
             return baseCallConv;
diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h
@@ -724,6 +724,7 @@ DEFINE_CLASS(CALLCONV_THISCALL,              CompilerServices,       CallConvThi
 DEFINE_CLASS(CALLCONV_FASTCALL,              CompilerServices,       CallConvFastcall)
 DEFINE_CLASS(CALLCONV_SUPPRESSGCTRANSITION,  CompilerServices,       CallConvSuppressGCTransition)
 DEFINE_CLASS(CALLCONV_MEMBERFUNCTION,        CompilerServices,       CallConvMemberFunction)
+DEFINE_CLASS(CALLCONV_SWIFT,                 CompilerServices,       CallConvSwift)
 
 DEFINE_CLASS_U(Interop,                SafeHandle,         SafeHandle)
 DEFINE_FIELD_U(_ctorStackTrace,            SafeHandle,            m_ctorStackTrace)
diff --git a/src/coreclr/vm/dllimport.cpp b/src/coreclr/vm/dllimport.cpp
@@ -3167,7 +3167,6 @@ HRESULT NDirect::HasNAT_LAttribute(IMDInternalImport *pInternalImport, mdToken t
     return S_FALSE;
 }
 
-
 // Either MD or signature & module must be given.
 /*static*/
 BOOL NDirect::MarshalingRequired(
@@ -4257,7 +4256,8 @@ static void CreateNDirectStubAccessMetadata(
     {
         if (unmgdCallConv == CorInfoCallConvExtension::Managed ||
             unmgdCallConv == CorInfoCallConvExtension::Fastcall ||
-            unmgdCallConv == CorInfoCallConvExtension::FastcallMemberFunction)
+            unmgdCallConv == CorInfoCallConvExtension::FastcallMemberFunction ||
+            unmgdCallConv == CorInfoCallConvExtension::Swift)
         {
             COMPlusThrow(kTypeLoadException, IDS_INVALID_PINVOKE_CALLCONV);
         }
diff --git a/src/coreclr/vm/stubgen.cpp b/src/coreclr/vm/stubgen.cpp
@@ -2819,6 +2819,9 @@ void ILStubLinker::SetStubTargetCallingConv(CorInfoCallConvExtension callConv)
                 m_nativeFnSigBuilder.AddCallConvModOpt(GetToken(CoreLibBinder::GetClass(CLASS__CALLCONV_FASTCALL)));
                 m_nativeFnSigBuilder.AddCallConvModOpt(GetToken(CoreLibBinder::GetClass(CLASS__CALLCONV_MEMBERFUNCTION)));
                 break;
+            case CorInfoCallConvExtension::Swift:
+                m_nativeFnSigBuilder.AddCallConvModOpt(GetToken(CoreLibBinder::GetClass(CLASS__CALLCONV_SWIFT)));
+                break;
             default:
                 _ASSERTE("Unknown calling convention. Unable to encode it in the native function pointer signature.");
                 break;
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Swift/SwiftTypes.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Swift/SwiftTypes.cs
@@ -1,5 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
+using System.Runtime.CompilerServices;
 
 namespace System.Runtime.InteropServices.Swift
 {
@@ -19,7 +20,8 @@ namespace System.Runtime.InteropServices.Swift
     /// </code>
     /// </para>
     /// </remarks>
-    [CLSCompliantAttribute(false)]
+    [CLSCompliant(false)]
+    [Intrinsic]
     public readonly unsafe struct SwiftSelf
     {
         /// <summary>
@@ -52,7 +54,8 @@ public SwiftSelf(void* value)
     /// </code>
     /// </para>
     /// </remarks>
-    [CLSCompliantAttribute(false)]
+    [CLSCompliant(false)]
+    [Intrinsic]
     public readonly unsafe struct SwiftError
     {
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -5605,7 +5605,8 @@ void Compiler::impCheckForPInvokeCall(`
`5605`	`5605`	`// return here without inlining the native call.`
`5606`	`5606`	`if (unmanagedCallConv == CorInfoCallConvExtension::Managed \|\|`
`5607`	`5607`	`unmanagedCallConv == CorInfoCallConvExtension::Fastcall \|\|`
`5608`		`- unmanagedCallConv == CorInfoCallConvExtension::FastcallMemberFunction)`
	`5608`	`+ unmanagedCallConv == CorInfoCallConvExtension::FastcallMemberFunction \|\|`
	`5609`	`+ unmanagedCallConv == CorInfoCallConvExtension::Swift)`
`5609`	`5610`	`{`
`5610`	`5611`	`return;`
`5611`	`5612`	`}`
Original file line number	Diff line number	Diff line change
`@@ -392,7 +392,8 @@ public enum CorInfoCallConvExtension`
`392`	`392`	`// New calling conventions supported with the extensible calling convention encoding go here.`
`393`	`393`	`CMemberFunction,`
`394`	`394`	`StdcallMemberFunction,`
`395`		`- FastcallMemberFunction`
	`395`	`+ FastcallMemberFunction,`
	`396`	`+ Swift`
`396`	`397`	`}`
`397`	`398`
`398`	`399`	`public enum CORINFO_CALLINFO_FLAGS`
Original file line number	Diff line number	Diff line change
`@@ -3167,7 +3167,6 @@ HRESULT NDirect::HasNAT_LAttribute(IMDInternalImport *pInternalImport, mdToken t`
`3167`	`3167`	`return S_FALSE;`
`3168`	`3168`	`}`
`3169`	`3169`
`3170`		`-`
`3171`	`3170`	`// Either MD or signature & module must be given.`
`3172`	`3171`	`/static/`
`3173`	`3172`	`BOOL NDirect::MarshalingRequired(`
`@@ -4257,7 +4256,8 @@ static void CreateNDirectStubAccessMetadata(`
`4257`	`4256`	`{`
`4258`	`4257`	`if (unmgdCallConv == CorInfoCallConvExtension::Managed \|\|`
`4259`	`4258`	`unmgdCallConv == CorInfoCallConvExtension::Fastcall \|\|`
`4260`		`- unmgdCallConv == CorInfoCallConvExtension::FastcallMemberFunction)`
	`4259`	`+ unmgdCallConv == CorInfoCallConvExtension::FastcallMemberFunction \|\|`
	`4260`	`+ unmgdCallConv == CorInfoCallConvExtension::Swift)`
`4261`	`4261`	`{`
`4262`	`4262`	`COMPlusThrow(kTypeLoadException, IDS_INVALID_PINVOKE_CALLCONV);`
`4263`	`4263`	`}`