Updating the JIT to support marshaling blittable generics. (#103)

* Adding some tests for marshalling generics.

* Updating the VM to allow marshalling blittable generic types.

* Adding comments for why certain blittable generics are blocked from being marshaled

* Removing the new IDS_EE_BADMARSHAL_BLITTABLE_GENERICS_RESTRICTION string in favor of fixing the text in IDS_EE_BADMARSHAL_GENERICS_RESTRICTION

* Updating CrossGen2 to handle marshalling blittable generics

src/coreclr/src/dlls/mscorrc/mscorrc.rc

@@ -627,7 +627,7 @@ BEGIN
     IDS_EE_BADMARSHAL_NOTMARSHALABLE        "The type definition of this field has layout information but has an invalid managed/unmanaged type combination or is unmarshalable."
     IDS_EE_BADMARSHAL_BADMETADATA           "Invalid marshaling metadata."
     IDS_EE_BADMARSHAL_CUSTOMMARSHALER       "Custom marshalers are only allowed on classes, strings, arrays, and boxed value types."
-    IDS_EE_BADMARSHAL_GENERICS_RESTRICTION  "Generic types cannot be marshaled."
+    IDS_EE_BADMARSHAL_GENERICS_RESTRICTION  "Non-blittable generic types cannot be marshaled."
     IDS_EE_BADMARSHAL_STRING_OUT            "Cannot marshal a string by-value with the [Out] attribute."
 
     IDS_EE_BADMARSHALPARAM_STRINGBUILDER    "Invalid managed/unmanaged type combination (StringBuilders must be paired with LPStr, LPWStr, or LPTStr)."

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

@@ -334,13 +334,29 @@ internal static MarshallerKind GetMarshallerKind(
                     return MarshallerKind.Invalid;
                 }
 
-                if (type.HasInstantiation)
+                bool isBlittable = MarshalUtils.IsBlittableType(type);
+
+                // Blittable generics are allowed to be marshalled with the following exceptions:
+                // * ByReference<T>: This represents an interior pointer and is not actually blittable
+                // * Nullable<T>: We don't want to be locked into the default behavior as we may want special handling later
+                // * 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
+                // * Vector<T>: Has a variable size (either __m128 or __m256) and isn't readily usable for inteorp scenarios
+
+                if (type.HasInstantiation && (!isBlittable
+                    || InteropTypes.IsSystemByReference(context, type)
+                    || InteropTypes.IsSystemNullable(context, type)
+                    || InteropTypes.IsSystemRuntimeIntrinsicsVector64T(context, type)
+                    || InteropTypes.IsSystemRuntimeIntrinsicsVector128T(context, type)
+                    || InteropTypes.IsSystemRuntimeIntrinsicsVector256T(context, type)
+                    || InteropTypes.IsSystemNumericsVectorT(context, type)))
                 {
                     // Generic types cannot be marshaled.
                     return MarshallerKind.Invalid;
                 }
 
-                if (MarshalUtils.IsBlittableType(type))
+                if (isBlittable)
                 {
                     if (nativeType != NativeTypeKind.Default && nativeType != NativeTypeKind.Struct)
                         return MarshallerKind.Invalid;

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

@@ -108,6 +108,36 @@ public static bool IsSystemArgIterator(TypeSystemContext context, TypeDesc type)
             return IsCoreNamedType(context, type, "System", "ArgIterator");
         }
 
+        public static bool IsSystemByReference(TypeSystemContext context, TypeDesc type)
+        {
+            return IsCoreNamedType(context, type, "System", "ByReference`1");
+        }
+
+        public static bool IsSystemNullable(TypeSystemContext context, TypeDesc type)
+        {
+            return IsCoreNamedType(context, type, "System", "Nullable`1");
+        }
+
+        public static bool IsSystemRuntimeIntrinsicsVector64T(TypeSystemContext context, TypeDesc type)
+        {
+            return IsCoreNamedType(context, type, "System.Runtime.Intrinsics", "Vector64`1");
+        }
+
+        public static bool IsSystemRuntimeIntrinsicsVector128T(TypeSystemContext context, TypeDesc type)
+        {
+            return IsCoreNamedType(context, type, "System.Runtime.Intrinsics", "Vector128`1");
+        }
+
+        public static bool IsSystemRuntimeIntrinsicsVector256T(TypeSystemContext context, TypeDesc type)
+        {
+            return IsCoreNamedType(context, type, "System.Runtime.Intrinsics", "Vector256`1");
+        }
+
+        public static bool IsSystemNumericsVectorT(TypeSystemContext context, TypeDesc type)
+        {
+            return IsCoreNamedType(context, type, "System.Numerics", "Vector`1");
+        }
+
         private static bool IsOrDerivesFromType(TypeDesc type, MetadataType targetType)
         {
             while (type != null)

src/coreclr/src/vm/mlinfo.cpp

@@ -2796,7 +2796,25 @@ MarshalInfo::MarshalInfo(Module* pModule,
                 }
 #endif // FEATURE_COMINTEROP
 
-                if (m_pMT->HasInstantiation())
+                // Blittable generics are allowed to be marshalled with the following exceptions:
+                // * ByReference<T>: This represents an interior pointer and is not actually blittable
+                // * Nullable<T>: We don't want to be locked into the default behavior as we may want special handling later
+                // * 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
+                // * Vector<T>: Has a variable size (either __m128 or __m256) and isn't readily usable for inteorp scenarios
+
+                if (m_pMT->HasInstantiation() && (!m_pMT->IsBlittable()
+                    || m_pMT->HasSameTypeDefAs(g_pByReferenceClass)
+                    || m_pMT->HasSameTypeDefAs(g_pNullableClass)
+                    || m_pMT->HasSameTypeDefAs(MscorlibBinder::GetClass(CLASS__VECTOR64T))
+                    || m_pMT->HasSameTypeDefAs(MscorlibBinder::GetClass(CLASS__VECTOR128T))
+                    || m_pMT->HasSameTypeDefAs(MscorlibBinder::GetClass(CLASS__VECTOR256T))
+#ifndef CROSSGEN_COMPILE
+                    // Crossgen scenarios block Vector<T> from even being loaded
+                    || m_pMT->HasSameTypeDefAs(MscorlibBinder::GetClass(CLASS__VECTORT))
+#endif // !CROSSGEN_COMPILE
+                    ))
                 {
                     m_resID = IDS_EE_BADMARSHAL_GENERICS_RESTRICTION;
                     IfFailGoto(E_FAIL, lFail);
@@ -2916,7 +2934,7 @@ MarshalInfo::MarshalInfo(Module* pModule,
             if (m_ms != MARSHAL_SCENARIO_WINRT)
 #endif // FEATURE_COMINTEROP
             {
-                if (thElement.HasInstantiation())
+                if (thElement.HasInstantiation() && !thElement.IsBlittable())
                 {
                     m_resID = IDS_EE_BADMARSHAL_GENERICS_RESTRICTION;
                     IfFailGoto(E_FAIL, lFail);

src/coreclr/src/vm/mscorlib.h

@@ -499,6 +499,14 @@ DEFINE_FIELD(MARSHAL,               SYSTEM_MAX_DBCS_CHAR_SIZE,         SystemMax
 DEFINE_CLASS(NATIVELIBRARY, Interop, NativeLibrary)
 DEFINE_METHOD(NATIVELIBRARY,        LOADLIBRARYCALLBACKSTUB, LoadLibraryCallbackStub, SM_Str_AssemblyBase_Bool_UInt_RetIntPtr)
 
+DEFINE_CLASS(VECTOR64T,             Intrinsics,             Vector64`1)
+DEFINE_CLASS(VECTOR128T,            Intrinsics,             Vector128`1)
+DEFINE_CLASS(VECTOR256T,            Intrinsics,             Vector256`1)
+
+#ifndef CROSSGEN_COMPILE
+DEFINE_CLASS(VECTORT,               Numerics,               Vector`1)
+#endif // !CROSSGEN_COMPILE
+
 DEFINE_CLASS(MEMBER,                Reflection,             MemberInfo)
 
 

src/coreclr/src/vm/namespace.h

@@ -40,6 +40,7 @@
 #endif // FEATURE_COMINTEROP
 
 #define g_IntrinsicsNS g_RuntimeNS ".Intrinsics"
+#define g_NumericsNS   g_SystemNS  ".Numerics"
 
 #define g_InternalCompilerServicesNS "Internal.Runtime.CompilerServices"
 #define g_CompilerServicesNS g_RuntimeNS ".CompilerServices"

src/coreclr/tests/src/Interop/CMakeLists.txt

@@ -30,6 +30,7 @@ add_subdirectory(PInvoke/Miscellaneous/HandleRef)
 add_subdirectory(PInvoke/Miscellaneous/ThisCall)
 add_subdirectory(PInvoke/Miscellaneous/MultipleAssembliesWithSamePInvoke)
 add_subdirectory(PInvoke/CriticalHandles)
+add_subdirectory(PInvoke/Generics)
 add_subdirectory(PInvoke/AsAny)
 add_subdirectory(PInvoke/SafeHandles)
 add_subdirectory(NativeCallable)

src/coreclr/tests/src/Interop/PInvoke/Generics/CMakeLists.txt

@@ -0,0 +1,87 @@
+cmake_minimum_required (VERSION 2.6) 
+project (GenericsNative) 
+include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake") 
+if(CLR_CMAKE_TARGET_ARCH_I386)
+  add_definitions(-D_TARGET_X86_)
+  add_definitions(-D_TARGET_XARCH_)
+elseif(CLR_CMAKE_TARGET_ARCH_AMD64)
+  add_definitions(-D_TARGET_AMD64_)
+  add_definitions(-D_TARGET_XARCH_)
+elseif(CLR_CMAKE_TARGET_ARCH_ARM)
+  add_definitions(-D_TARGET_ARM_)
+  add_definitions(-D_TARGET_ARMARCH_)
+elseif(CLR_CMAKE_TARGET_ARCH_ARM64)
+  add_definitions(-D_TARGET_ARM64_)
+  add_definitions(-D_TARGET_ARMARCH_)
+endif()
+set(SOURCES
+  GenericsNative.IUnknown.cpp
+  GenericsNative.NullableB.cpp
+  GenericsNative.NullableC.cpp
+  GenericsNative.NullableD.cpp
+  GenericsNative.NullableF.cpp
+  GenericsNative.NullableL.cpp
+  GenericsNative.NullableU.cpp
+  GenericsNative.Point1B.cpp
+  GenericsNative.Point1C.cpp
+  GenericsNative.Point1D.cpp
+  GenericsNative.Point1F.cpp
+  GenericsNative.Point1L.cpp
+  GenericsNative.Point1U.cpp
+  GenericsNative.Point2B.cpp
+  GenericsNative.Point2C.cpp
+  GenericsNative.Point2D.cpp
+  GenericsNative.Point2F.cpp
+  GenericsNative.Point2L.cpp
+  GenericsNative.Point2U.cpp
+  GenericsNative.Point3B.cpp
+  GenericsNative.Point3C.cpp
+  GenericsNative.Point3D.cpp
+  GenericsNative.Point3F.cpp
+  GenericsNative.Point3L.cpp
+  GenericsNative.Point3U.cpp
+  GenericsNative.Point4B.cpp
+  GenericsNative.Point4C.cpp
+  GenericsNative.Point4D.cpp
+  GenericsNative.Point4F.cpp
+  GenericsNative.Point4L.cpp
+  GenericsNative.Point4U.cpp
+  GenericsNative.SequentialClassB.cpp
+  GenericsNative.SequentialClassC.cpp
+  GenericsNative.SequentialClassD.cpp
+  GenericsNative.SequentialClassF.cpp
+  GenericsNative.SequentialClassL.cpp
+  GenericsNative.SequentialClassU.cpp
+  GenericsNative.SpanB.cpp
+  GenericsNative.SpanC.cpp
+  GenericsNative.SpanD.cpp
+  GenericsNative.SpanF.cpp
+  GenericsNative.SpanL.cpp
+  GenericsNative.SpanU.cpp
+  GenericsNative.Vector64B.cpp
+  GenericsNative.Vector64C.cpp
+  GenericsNative.Vector64D.cpp
+  GenericsNative.Vector64F.cpp
+  GenericsNative.Vector64L.cpp
+  GenericsNative.Vector64U.cpp
+  GenericsNative.Vector128B.cpp
+  GenericsNative.Vector128C.cpp
+  GenericsNative.Vector128D.cpp
+  GenericsNative.Vector128F.cpp
+  GenericsNative.Vector128L.cpp
+  GenericsNative.Vector128U.cpp
+  GenericsNative.Vector256B.cpp
+  GenericsNative.Vector256C.cpp
+  GenericsNative.Vector256D.cpp
+  GenericsNative.Vector256F.cpp
+  GenericsNative.Vector256L.cpp
+  GenericsNative.Vector256U.cpp
+  GenericsNative.VectorB.cpp
+  GenericsNative.VectorC.cpp
+  GenericsNative.VectorD.cpp
+  GenericsNative.VectorF.cpp
+  GenericsNative.VectorL.cpp
+  GenericsNative.VectorU.cpp
+)
+add_library (GenericsNative SHARED ${SOURCES})
+install (TARGETS GenericsNative DESTINATION bin) 

src/coreclr/tests/src/Interop/PInvoke/Generics/GenericsNative.IUnknown.cpp

@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#include <stdio.h>
+#include <stdint.h>
+#include <xplatform.h>
+#include <platformdefines.h>
+
+extern "C" DLL_EXPORT IUnknown* STDMETHODCALLTYPE GetIComInterface()
+{
+    throw "P/Invoke for IComInterface<T> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetIComInterfaceOut(IUnknown** pValue)
+{
+    throw "P/Invoke for IComInterface<T> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT const IUnknown** STDMETHODCALLTYPE GetIComInterfacePtr()
+{
+    throw "P/Invoke for IComInterface<T> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetIComInterfaces(IUnknown** pValues, int count)
+{
+    throw "P/Invoke for IComInterface<T> should be unsupported.";
+}
+

src/coreclr/tests/src/Interop/PInvoke/Generics/GenericsNative.NullableB.cpp

@@ -0,0 +1,41 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#include <stdio.h>
+#include <stdint.h>
+#include <xplatform.h>
+#include <platformdefines.h>
+
+struct NullableB
+{
+    bool hasValue;
+    bool value;
+};
+
+static NullableB NullableBValue = { };
+
+extern "C" DLL_EXPORT NullableB STDMETHODCALLTYPE GetNullableB(bool hasValue, bool value)
+{
+    throw "P/Invoke for Nullable<bool> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetNullableBOut(bool hasValue, bool value, NullableB* pValue)
+{
+    throw "P/Invoke for Nullable<bool> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT const NullableB* STDMETHODCALLTYPE GetNullableBPtr(bool hasValue, bool value)
+{
+    throw "P/Invoke for Nullable<bool> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT NullableB STDMETHODCALLTYPE AddNullableB(NullableB lhs, NullableB rhs)
+{
+    throw "P/Invoke for Nullable<bool> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT NullableB STDMETHODCALLTYPE AddNullableBs(const NullableB* pValues, uint32_t count)
+{
+    throw "P/Invoke for Nullable<bool> should be unsupported.";
+}

src/coreclr/tests/src/Interop/PInvoke/Generics/GenericsNative.NullableC.cpp

@@ -0,0 +1,41 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#include <stdio.h>
+#include <stdint.h>
+#include <xplatform.h>
+#include <platformdefines.h>
+
+struct NullableC
+{
+    bool hasValue;
+    char16_t value;
+};
+
+static NullableC NullableCValue = { };
+
+extern "C" DLL_EXPORT NullableC STDMETHODCALLTYPE GetNullableC(bool hasValue, char16_t value)
+{
+    throw "P/Invoke for Nullable<char> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetNullableCOut(bool hasValue, char16_t value, NullableC* pValue)
+{
+    throw "P/Invoke for Nullable<char> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT const NullableC* STDMETHODCALLTYPE GetNullableCPtr(bool hasValue, char16_t value)
+{
+    throw "P/Invoke for Nullable<char> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT NullableC STDMETHODCALLTYPE AddNullableC(NullableC lhs, NullableC rhs)
+{
+    throw "P/Invoke for Nullable<char> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT NullableC STDMETHODCALLTYPE AddNullableCs(const NullableC* pValues, uint32_t count)
+{
+    throw "P/Invoke for Nullable<char> should be unsupported.";
+}

src/coreclr/tests/src/Interop/PInvoke/Generics/GenericsNative.NullableD.cpp

@@ -0,0 +1,41 @@
+// Licensed to the .NET Doundation under one or more agreements.
+// The .NET Doundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#include <stdio.h>
+#include <stdint.h>
+#include <xplatform.h>
+#include <platformdefines.h>
+
+struct NullableD
+{
+    bool hasValue;
+    double value;
+};
+
+static NullableD NullableDValue = { };
+
+extern "C" DLL_EXPORT NullableD STDMETHODCALLTYPE GetNullableD(bool hasValue, double value)
+{
+    throw "P/Invoke for Nullable<double> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetNullableDOut(bool hasValue, double value, NullableD* pValue)
+{
+    throw "P/Invoke for Nullable<double> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT const NullableD* STDMETHODCALLTYPE GetNullableDPtr(bool hasValue, double value)
+{
+    throw "P/Invoke for Nullable<double> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT NullableD STDMETHODCALLTYPE AddNullableD(NullableD lhs, NullableD rhs)
+{
+    throw "P/Invoke for Nullable<double> should be unsupported.";
+}
+
+extern "C" DLL_EXPORT NullableD STDMETHODCALLTYPE AddNullableDs(const NullableD* pValues, uint32_t count)
+{
+    throw "P/Invoke for Nullable<double> should be unsupported.";
+}