Implement System.Runtime.CompilerServices.DisabledRuntimeMarshallingAttribute on CoreCLR-family of runtimes/type systems

src/coreclr/dlls/mscorrc/mscorrc.rc

@@ -194,6 +194,9 @@ BEGIN
     IDS_EE_NDIRECT_GETPROCADDR_WIN_DLL      "Unable to find an entry point named '%1' in DLL."
     IDS_EE_NDIRECT_GETPROCADDR_UNIX_SO      "Unable to find an entry point named '%1' in shared library."
     IDS_EE_NDIRECT_GETPROCADDRESS_NONAME    "A library name must be specified in a DllImport attribute applied to non-IJW methods."
+    IDS_EE_NDIRECT_DISABLEDMARSHAL_SETLASTERROR "Setting SetLastError=true is not supported when runtime marshalling is disabled."
+    IDS_EE_NDIRECT_DISABLEDMARSHAL_LCID     "The LCIDConversionAttribute is not supported when runtime marshalling is disabled."
+    IDS_EE_NDIRECT_DISABLEDMARSHAL_PRESERVESIG "Setting PreserveSig to false for a P/Invoke is not supported when runtime marshalling is disabled."
     IDS_EE_CLASS_CONSTRAINTS_VIOLATION      "GenericArguments[%1], '%2', on '%3' violates the constraint of type parameter '%4'."
     IDS_EE_METHOD_CONSTRAINTS_VIOLATION     "Method %1.%2: type argument '%3' violates the constraint of type parameter '%4'."
     IDS_EE_NOSYNCHRONIZED                   "Synchronized attribute cannot be used with this method type."
@@ -297,6 +300,7 @@ BEGIN
     IDS_EE_BADMARSHAL_GENERICS_RESTRICTION  "Non-blittable generic types cannot be marshaled."
     IDS_EE_BADMARSHAL_AUTOLAYOUT            "Structures marked with [StructLayout(LayoutKind.Auto)] cannot be marshaled."
     IDS_EE_BADMARSHAL_STRING_OUT            "Cannot marshal a string by-value with the [Out] attribute."
+    IDS_EE_BADMARSHAL_MARSHAL_DISABLED      "Cannot marshal managed types when the built-in marshaling system is disabled."
 
     IDS_EE_BADMARSHALPARAM_STRINGBUILDER    "Invalid managed/unmanaged type combination (StringBuilders must be paired with LPStr, LPWStr, or LPTStr)."
     IDS_EE_BADMARSHALPARAM_NO_LPTSTR        "Invalid managed/unmanaged type combination (Strings cannot be paired with LPTStr for parameters and return types of methods in interfaces exposed to COM)."

src/coreclr/dlls/mscorrc/resource.h

@@ -588,3 +588,7 @@
 #define IDS_EE_BADMARSHAL_DELEGATE_TLB_INTERFACE   0x2649
 #define IDS_EE_THREAD_APARTMENT_NOT_SUPPORTED      0x264A
 #define IDS_EE_NO_IINSPECTABLE                     0x264B
+#define IDS_EE_BADMARSHAL_MARSHAL_DISABLED         0x264C
+#define IDS_EE_NDIRECT_DISABLEDMARSHAL_SETLASTERROR 0x264D
+#define IDS_EE_NDIRECT_DISABLEDMARSHAL_LCID        0x264E
+#define IDS_EE_NDIRECT_DISABLEDMARSHAL_PRESERVESIG 0x264F

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

@@ -3747,7 +3747,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>())) // Only blittable arguments
+                if (Marshaller.IsMarshallingRequired(this.MethodBeingCompiled.Signature, Array.Empty<ParameterMetadata>(), ((MetadataType)this.MethodBeingCompiled.OwningType).Module)) // Only blittable arguments
                 {
                     ThrowHelper.ThrowInvalidProgramException(ExceptionStringID.InvalidProgramNonBlittableTypes, this.MethodBeingCompiled);
                 }

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

@@ -21,11 +21,13 @@ public partial class CalliMarshallingMethodThunk : ILStubMethod
         private MethodSignature _signature;
 
         public CalliMarshallingMethodThunk(MethodSignature targetSignature, TypeDesc owningType,
-                InteropStateManager interopStateManager)
+                InteropStateManager interopStateManager,
+                bool useRuntimeMarshalling)
         {
             _targetSignature = targetSignature;
             _owningType = owningType;
             _interopStateManager = interopStateManager;
+            UseRuntimeMarshalling = useRuntimeMarshalling;
         }
 
         public MethodSignature TargetSignature
@@ -87,6 +89,8 @@ public override string DiagnosticName
             }
         }
 
+        public bool UseRuntimeMarshalling { get; }
+
         public override PInvokeMetadata GetPInvokeMethodMetadata()
         {
             // Return PInvokeAttributes.PreserveSig to circumvent marshalling required checks

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

@@ -12,7 +12,7 @@ namespace Internal.IL.Stubs
 {
     /// <summary>
     /// Provides method bodies for PInvoke methods
-    /// 
+    ///
     /// This by no means intends to provide full PInvoke support. The intended use of this is to
     /// a) prevent calls getting generated to targets that require a full marshaller
     /// (this compiler doesn't provide that), and b) offer a hand in some very simple marshalling
@@ -55,23 +55,27 @@ private static Marshaller[] InitializeMarshallers(MethodDesc targetMethod, Inter
         {
             MarshalDirection direction = MarshalDirection.Forward;
             MethodSignature methodSig;
+            bool runtimeMarshallingEnabled;
             switch (targetMethod)
             {
                 case DelegateMarshallingMethodThunk delegateMethod:
                     methodSig = delegateMethod.DelegateSignature;
                     direction = delegateMethod.Direction;
+                    runtimeMarshallingEnabled = MarshalHelpers.IsRuntimeMarshallingEnabled(delegateMethod.DelegateType.Module);
                     break;
                 case CalliMarshallingMethodThunk calliMethod:
                     methodSig = calliMethod.TargetSignature;
+                    runtimeMarshallingEnabled = calliMethod.UseRuntimeMarshalling;
                     break;
                 default:
                     methodSig = targetMethod.Signature;
+                    runtimeMarshallingEnabled = MarshalHelpers.IsRuntimeMarshallingEnabled(((EcmaMethod)targetMethod).Module);
                     break;
             }
             int indexOffset = 0;
             if (!methodSig.IsStatic && direction == MarshalDirection.Forward)
             {
-                // For instance methods(eg. Forward delegate marshalling thunk), first argument is 
+                // For instance methods(eg. Forward delegate marshalling thunk), first argument is
                 // the instance
                 indexOffset = 1;
             }
@@ -88,7 +92,7 @@ private static Marshaller[] InitializeMarshallers(MethodDesc targetMethod, Inter
                     // if we don't have metadata for the parameter, create a dummy one
                     parameterMetadata = new ParameterMetadata(i, ParameterMetadataAttributes.None, null);
                 }
-                else 
+                else
                 {
                     Debug.Assert(i == parameterMetadataArray[parameterIndex].Index);
                     parameterMetadata = parameterMetadataArray[parameterIndex++];
@@ -104,7 +108,7 @@ private static Marshaller[] InitializeMarshallers(MethodDesc targetMethod, Inter
                     {
                         // PreserveSig = false can only show up an regular forward PInvokes
                         Debug.Assert(direction == MarshalDirection.Forward);
-                    
+
                         parameterType = methodSig.Context.GetByRefType(parameterType);
                         isHRSwappedRetVal = true;
                     }
@@ -114,20 +118,36 @@ private static Marshaller[] InitializeMarshallers(MethodDesc targetMethod, Inter
                     parameterType = methodSig[i - 1];
                 }
 
-                marshallers[i] = Marshaller.CreateMarshaller(parameterType,
-                                                    parameterIndex,
-                                                    methodSig.GetEmbeddedSignatureData(),
-                                                    MarshallerType.Argument,
-                                                    parameterMetadata.MarshalAsDescriptor,
-                                                    direction,
-                                                    marshallers,
-                                                    interopStateManager,
-                                                    indexOffset + parameterMetadata.Index,
-                                                    flags,
-                                                    parameterMetadata.In,
-                                                    isHRSwappedRetVal ? true : parameterMetadata.Out,
-                                                    isHRSwappedRetVal ? false : parameterMetadata.Return
-                                                    );
+                if (runtimeMarshallingEnabled)
+                {
+                    marshallers[i] = Marshaller.CreateMarshaller(parameterType,
+                                                        parameterIndex,
+                                                        methodSig.GetEmbeddedSignatureData(),
+                                                        MarshallerType.Argument,
+                                                        parameterMetadata.MarshalAsDescriptor,
+                                                        direction,
+                                                        marshallers,
+                                                        interopStateManager,
+                                                        indexOffset + parameterMetadata.Index,
+                                                        flags,
+                                                        parameterMetadata.In,
+                                                        isHRSwappedRetVal ? true : parameterMetadata.Out,
+                                                        isHRSwappedRetVal ? false : parameterMetadata.Return
+                                                        );
+                }
+                else
+                {
+                    marshallers[i] = Marshaller.CreateDisabledRuntimeMarshallingMarshaller(
+                        parameterType,
+                        parameterIndex,
+                        MarshallerType.Argument,
+                        direction,
+                        marshallers,
+                        interopStateManager,
+                        indexOffset + parameterMetadata.Index,
+                        flags,
+                        parameterMetadata.Return);
+                }
             }
 
             return marshallers;
@@ -146,10 +166,10 @@ private void EmitDelegateCall(DelegateMarshallingMethodThunk delegateMethod, PIn
             if (delegateMethod.Kind == DelegateMarshallingMethodThunkKind.ReverseOpenStatic)
             {
                 //
-                // For Open static delegates call 
+                // For Open static delegates call
                 //     InteropHelpers.GetCurrentCalleeOpenStaticDelegateFunctionPointer()
                 // which returns a function pointer. Just call the function pointer and we are done.
-                // 
+                //
                 TypeDesc[] parameters = new TypeDesc[_marshallers.Length - 1];
                 for (int i = 1; i < _marshallers.Length; i++)
                 {
@@ -193,7 +213,7 @@ private void EmitDelegateCall(DelegateMarshallingMethodThunk delegateMethod, PIn
             else if (delegateMethod.Kind == DelegateMarshallingMethodThunkKind
                 .ForwardNativeFunctionWrapper)
             {
-                // if the SetLastError flag is set in UnmanagedFunctionPointerAttribute, clear the error code before doing P/Invoke 
+                // if the SetLastError flag is set in UnmanagedFunctionPointerAttribute, clear the error code before doing P/Invoke
                 if (_flags.SetLastError)
                 {
                     callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(
@@ -225,7 +245,7 @@ private void EmitDelegateCall(DelegateMarshallingMethodThunk delegateMethod, PIn
                 MethodSignatureFlags unmanagedCallingConvention = _flags.UnmanagedCallingConvention;
                 if (unmanagedCallingConvention == MethodSignatureFlags.None)
                     unmanagedCallingConvention = MethodSignatureFlags.UnmanagedCallingConvention;
- 
+
                 MethodSignature nativeSig = new MethodSignature(
                     MethodSignatureFlags.Static | unmanagedCallingConvention, 0, nativeReturnType, nativeParameterTypes);
 
@@ -257,9 +277,17 @@ private void EmitPInvokeCall(PInvokeILCodeStreams ilCodeStreams)
             TypeDesc nativeReturnType = _flags.PreserveSig ? _marshallers[0].NativeParameterType : context.GetWellKnownType(WellKnownType.Int32);
             TypeDesc[] nativeParameterTypes = new TypeDesc[isHRSwappedRetVal ? _marshallers.Length : _marshallers.Length - 1];
 
-            // if the SetLastError flag is set in DllImport, clear the error code before doing P/Invoke 
+            bool runtimeMarshallingEnabled = _targetMethod is not EcmaMethod ecmaMethod
+                    || MarshalHelpers.IsRuntimeMarshallingEnabled(ecmaMethod.Module);
+
+            // if the SetLastError flag is set in DllImport, clear the error code before doing P/Invoke
             if (_flags.SetLastError)
             {
+                if (!runtimeMarshallingEnabled)
+                {
+                    // When runtime marshalling is disabled, we don't support SetLastError
+                    throw new NotSupportedException();
+                }
                 callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(
                             InteropTypes.GetPInvokeMarshal(context).GetKnownMethod("ClearLastError", null)));
             }
@@ -271,6 +299,11 @@ private void EmitPInvokeCall(PInvokeILCodeStreams ilCodeStreams)
 
             if (isHRSwappedRetVal)
             {
+                if (!runtimeMarshallingEnabled)
+                {
+                    // When runtime marshalling is disabled, we don't support HResult-return-swapping
+                    throw new NotSupportedException();
+                }
                 nativeParameterTypes[_marshallers.Length - 1] = _marshallers[0].NativeParameterType;
             }
 
@@ -364,6 +397,9 @@ private void EmitCalli(PInvokeILCodeStreams ilCodeStreams, CalliMarshallingMetho
 
         private MethodIL EmitIL()
         {
+            if (_targetMethod.HasCustomAttribute("System.Runtime.InteropServices", "LCIDConversionAttribute"))
+                throw new NotSupportedException();
+
             PInvokeILCodeStreams pInvokeILCodeStreams = new PInvokeILCodeStreams();
             ILEmitter emitter = pInvokeILCodeStreams.Emitter;
             ILCodeStream marshallingCodestream = pInvokeILCodeStreams.MarshallingCodeStream;
@@ -417,8 +453,8 @@ private MethodIL EmitIL()
             return new PInvokeILStubMethodIL((ILStubMethodIL)emitter.Link(_targetMethod), IsStubRequired());
         }
 
-        public static MethodIL EmitIL(MethodDesc method, 
-            PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration, 
+        public static MethodIL EmitIL(MethodDesc method,
+            PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration,
             InteropStateManager interopStateManager)
         {
             try

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

@@ -126,7 +126,7 @@ public static MethodIL EmitExceptionBody(string message, MethodDesc method)
             TypeSystemContext context = method.Context;
             MethodSignature ctorSignature = new MethodSignature(0, 0, context.GetWellKnownType(WellKnownType.Void),
                 new TypeDesc[] { context.GetWellKnownType(WellKnownType.String) });
-            MethodDesc exceptionCtor = method.Context.GetWellKnownType(WellKnownType.Exception).GetKnownMethod(".ctor", ctorSignature);
+            MethodDesc exceptionCtor = InteropTypes.GetMarshalDirectiveException(context).GetKnownMethod(".ctor", ctorSignature);
 
             ILCodeStream codeStream = emitter.NewCodeStream();
             codeStream.Emit(ILOpcode.ldstr, emitter.NewToken(message));

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

@@ -5,6 +5,7 @@
 using Internal.IL;
 using Debug = System.Diagnostics.Debug;
 using Internal.IL.Stubs;
+using Internal.TypeSystem.Ecma;
 
 namespace Internal.TypeSystem.Interop
 {
@@ -844,6 +845,28 @@ private static MarshallerKind GetArrayElementMarshallerKind(
             }
         }
 
+        internal static MarshallerKind GetRuntimeDisabledMarshallingMarshallerKind(
+            TypeDesc type)
+        {
+            if (type.Category == TypeFlags.Void)
+            {
+                return MarshallerKind.VoidReturn;
+            }
+            if (type.IsPrimitive)
+            {
+                return MarshallerKind.BlittableValue;
+            }
+            else if (type.IsPointer || type.IsFunctionPointer)
+            {
+                return MarshallerKind.BlittableValue;
+            }
+            else if (type.IsValueType && !((DefType)type).ContainsGCPointers)
+            {
+                return MarshallerKind.BlittableValue;
+            }
+            return MarshallerKind.Invalid;
+        }
+
         internal static bool ShouldCheckForPendingException(TargetDetails target, PInvokeMetadata metadata)
         {
             if (!target.IsOSX)
@@ -861,5 +884,10 @@ internal static bool ShouldCheckForPendingException(TargetDetails target, PInvok
             return metadata.Module.Equals(ObjectiveCLibrary)
                 && metadata.Name.StartsWith(ObjectiveCMsgSend);
         }
+
+        public static bool IsRuntimeMarshallingEnabled(ModuleDesc module)
+        {
+            return module.Assembly is not EcmaAssembly assembly || assembly.HasAssemblyCustomAttribute("System.Runtime.CompilerServices", "DisableRuntimeMarshallingAttribute");
+        }
     }
 }

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

@@ -382,6 +382,58 @@ public static Marshaller CreateMarshaller(TypeDesc parameterType,
 
             return marshaller;
         }
+
+        /// <summary>
+        /// Create a marshaller
+        /// </summary>
+        /// <param name="parameterType">type of the parameter to marshal</param>
+        /// <returns>The created Marshaller</returns>
+        public static Marshaller CreateDisabledRuntimeMarshallingMarshaller(TypeDesc parameterType,
+            int? parameterIndex,
+            MarshallerType marshallerType,
+            MarshalDirection direction,
+            Marshaller[] marshallers,
+#if !READYTORUN
+            InteropStateManager interopStateManager,
+#endif
+            int index,
+            PInvokeFlags flags,
+            bool isReturn)
+        {
+            bool isAnsi = flags.CharSet switch
+            {
+                CharSet.Ansi => true,
+                CharSet.Unicode => false,
+                CharSet.Auto => !parameterType.Context.Target.IsWindows,
+                _ => true
+            };
+
+            MarshallerKind marshallerKind = MarshalHelpers.GetRuntimeDisabledMarshallingMarshallerKind(parameterType);
+
+            TypeSystemContext context = parameterType.Context;
+            // Create the marshaller based on MarshallerKind
+            Marshaller marshaller = CreateMarshaller(marshallerKind);
+            marshaller.Context = context;
+#if !READYTORUN
+            marshaller.InteropStateManager = interopStateManager;
+#endif
+            marshaller.MarshallerKind = marshallerKind;
+            marshaller.MarshallerType = marshallerType;
+            marshaller.ElementMarshallerKind = MarshallerKind.Unknown;
+            marshaller.ManagedParameterType = parameterType;
+            marshaller.ManagedType = parameterType.IsByRef ? parameterType.GetParameterType() : parameterType;
+            marshaller.Return = isReturn;
+            marshaller.IsManagedByRef = parameterType.IsByRef;
+            marshaller.IsNativeByRef = marshaller.IsManagedByRef;
+            marshaller.MarshalDirection = direction;
+            marshaller.MarshalAsDescriptor = null;
+            marshaller.Marshallers = marshallers;
+            marshaller.Index = index;
+            marshaller.PInvokeFlags = flags;
+            marshaller.In = true;
+            marshaller.Out = marshaller.IsManagedByRef;
+            return marshaller;
+        }
         #endregion