Implement System.Runtime.InteropServices.CLong/CULong/NFloat

src/coreclr/jit/compiler.cpp

@@ -560,6 +560,35 @@ bool Compiler::isTrivialPointerSizedStruct(CORINFO_CLASS_HANDLE clsHnd) const
 }
 #endif // TARGET_X86
 
+//---------------------------------------------------------------------------
+// isNativePrimitiveStructType:
+// Check if the given struct type is an intrinsic type that should be treated as though
+// it is not a struct at the unmanaged ABI boundary.
+//
+// Arguments:
+// clsHnd - the handle for the struct type.
+//
+// Return Value:
+// true if the given struct type should be treated as a primitive for unmanaged calls,
+// false otherwise.
+//
+bool Compiler::isNativePrimitiveStructType(CORINFO_CLASS_HANDLE clsHnd)
+{
+ if (!isIntrinsicType(clsHnd))
+ {
+ return false;
+ }
+ const char* namespaceName = nullptr;
+ const char* typeName = getClassNameFromMetadata(clsHnd, &namespaceName);
+
+ if (strcmp(namespaceName, "System.Runtime.InteropServices") != 0)
+ {
+ return false;
+ }
+
+ return strcmp(typeName, "CLong") == 0 || strcmp(typeName, "CULong") == 0 || strcmp(typeName, "NFloat") == 0;
+}
+
 //-----------------------------------------------------------------------------
 // getPrimitiveTypeForStruct:
 // Get the "primitive" type that is is used for a struct
@@ -1013,14 +1042,14 @@ var_types Compiler::getReturnTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,
  }
  }
 #elif UNIX_X86_ABI
- if (callConv != CorInfoCallConvExtension::Managed)
+ if (callConv != CorInfoCallConvExtension::Managed && !isNativePrimitiveStructType(clsHnd))
  {
  canReturnInRegister = false;
  howToReturnStruct = SPK_ByReference;
  useType = TYP_UNKNOWN;
  }
 #elif defined(TARGET_WINDOWS) && !defined(TARGET_ARM)
- if (callConvIsInstanceMethodCallConv(callConv))
+ if (callConvIsInstanceMethodCallConv(callConv) && !isNativePrimitiveStructType(clsHnd))
  {
  canReturnInRegister = false;
  howToReturnStruct = SPK_ByReference;

src/coreclr/jit/compiler.h

@@ -5046,6 +5046,10 @@ class Compiler
  // Convert a BYTE which represents the VM's CorInfoGCtype to the JIT's var_types
  var_types getJitGCType(BYTE gcType);
 
+ // Returns true if the provided type should be treated as a primitive type
+ // for the unmanaged calling conventions.
+ bool isNativePrimitiveStructType(CORINFO_CLASS_HANDLE clsHnd);
+
  enum structPassingKind
  {
  SPK_Unknown, // Invalid value, never returned
@@ -8045,6 +8049,21 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 #endif
  }
 
+ bool isIntrinsicType(CORINFO_CLASS_HANDLE clsHnd)
+ {
+ return info.compCompHnd->isIntrinsicType(clsHnd);
+ }
+
+ const char* getClassNameFromMetadata(CORINFO_CLASS_HANDLE cls, const char** namespaceName)
+ {
+ return info.compCompHnd->getClassNameFromMetadata(cls, namespaceName);
+ }
+
+ CORINFO_CLASS_HANDLE getTypeInstantiationArgument(CORINFO_CLASS_HANDLE cls, unsigned index)
+ {
+ return info.compCompHnd->getTypeInstantiationArgument(cls, index);
+ }
+
 #ifdef FEATURE_SIMD
 
  // Should we support SIMD intrinsics?
@@ -8263,21 +8282,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  return false;
  }
 
- bool isIntrinsicType(CORINFO_CLASS_HANDLE clsHnd)
- {
- return info.compCompHnd->isIntrinsicType(clsHnd);
- }
-
- const char* getClassNameFromMetadata(CORINFO_CLASS_HANDLE cls, const char** namespaceName)
- {
- return info.compCompHnd->getClassNameFromMetadata(cls, namespaceName);
- }
-
- CORINFO_CLASS_HANDLE getTypeInstantiationArgument(CORINFO_CLASS_HANDLE cls, unsigned index)
- {
- return info.compCompHnd->getTypeInstantiationArgument(cls, index);
- }
-
  bool isSIMDClass(typeInfo* pTypeInfo)
  {
  return pTypeInfo->IsStruct() && isSIMDClass(pTypeInfo->GetClassHandleForValueClass());

src/coreclr/vm/dllimportcallback.cpp

@@ -178,7 +178,7 @@ VOID UMEntryThunk::CompileUMThunkWorker(UMThunkStubInfo *pInfo,
  // push edx - repush the return address
  pcpusl->X86EmitPushReg(kEDX);
  }
- 
+
  // The native signature doesn't have a return buffer
  // but the managed signature does.
  // Set up the return buffer address here.
@@ -188,12 +188,12 @@ VOID UMEntryThunk::CompileUMThunkWorker(UMThunkStubInfo *pInfo,
  // Calculate the offset to the return buffer we establish for EAX:EDX below.
  // lea edx [esp - offset to EAX:EDX return buffer]
  pcpusl->X86EmitEspOffset(0x8d, kEDX, -0xc /* skip return addr, EBP, EBX */ -0x8 /* point to start of EAX:EDX return buffer */ );
- 
+
  // exchange edx (which has the return buffer address)
  // with the return address
  // xchg edx, [esp]
- pcpusl->X86EmitOp(0x87, kEDX, (X86Reg)kESP_Unsafe); 
- 
+ pcpusl->X86EmitOp(0x87, kEDX, (X86Reg)kESP_Unsafe);
+
  // push edx
  pcpusl->X86EmitPushReg(kEDX);
  }
@@ -497,7 +497,7 @@ VOID UMEntryThunk::CompileUMThunkWorker(UMThunkStubInfo *pInfo,
  pcpusl->X86EmitIndexRegStore(kEBX, -0x8 /* to outer EBP */ -0x8 /* skip saved EBP, EBX */, kEDX);
  }
  // In the umtmlBufRetValToEnreg case,
- // we set up the return buffer to output 
+ // we set up the return buffer to output
  // into the EDX:EAX buffer we set up for the register return case.
  // So we don't need to do more work here.
  else if ((pInfo->m_wFlags & umtmlBufRetValToEnreg) == 0)
@@ -684,7 +684,7 @@ Stub *UMThunkMarshInfo::CompileNExportThunk(LoaderHeap *pLoaderHeap, PInvokeStat
  UINT nOffset = 0;
  int numRegistersUsed = 0;
  int numStackSlotsIndex = nStackBytes / STACK_ELEM_SIZE;
- 
+
  // This could have been set in the UnmanagedCallersOnly scenario.
  if (m_callConv == UINT16_MAX)
  m_callConv = static_cast<UINT16>(pSigInfo->GetCallConv());
@@ -699,8 +699,30 @@ Stub *UMThunkMarshInfo::CompileNExportThunk(LoaderHeap *pLoaderHeap, PInvokeStat
  numRegistersUsed++;
  }
 
+ bool hasReturnBuffer = argit.HasRetBuffArg() || (m_callConv == pmCallConvThiscall && argit.HasValueTypeReturn());
+ bool hasNativeExchangeTypeReturn = false;
+
+ if (hasReturnBuffer)
+ {
+ // If think we have a return buffer, lets make sure that we aren't returning one of the intrinsic native exchange types.
+ TypeHandle returnType = pMetaSig->GetRetTypeHandleThrowing();
+ if (returnType.GetMethodTable()->IsIntrinsicType())
+ {
+ LPCUTF8 pszNamespace;
+ LPCUTF8 pszTypeName = returnType.GetMethodTable()->GetFullyQualifiedNameInfo(&pszNamespace);
+ if ((strcmp(pszNamespace, g_InteropServicesNS) == 0)
+ && (strcmp(pszTypeName, "CLong") == 0 || strcmp(pszTypeName, "CULong") == 0 || strcmp(pszTypeName, "NFloat") == 0))
+ {
+ // We have one of the intrinsic native exchange types.
+ // As a result, we don't have a return buffer.
+ hasReturnBuffer = false;
+ hasNativeExchangeTypeReturn = true;
+ }
+ }
+ }
+
  // process the return buffer parameter
- if (argit.HasRetBuffArg() || (m_callConv == pmCallConvThiscall && argit.HasValueTypeReturn()))
+ if (hasReturnBuffer)
  {
  // Only copy the retbuf arg from the src call when both the managed call and native call
  // have a return buffer.
@@ -808,7 +830,7 @@ Stub *UMThunkMarshInfo::CompileNExportThunk(LoaderHeap *pLoaderHeap, PInvokeStat
  {
  stubInfo.m_wFlags |= umtmlThisCallHiddenArg;
  }
- else if (argit.HasValueTypeReturn())
+ else if (argit.HasValueTypeReturn() && !hasNativeExchangeTypeReturn)
  {
  stubInfo.m_wFlags |= umtmlThisCallHiddenArg | umtmlEnregRetValToBuf;
  // When the native signature has a return buffer but the

src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs

@@ -43,6 +43,7 @@ public static partial class PlatformDetection
  public static bool IsArgIteratorSupported => IsMonoRuntime || (IsWindows && IsNotArmProcess);
  public static bool IsArgIteratorNotSupported => !IsArgIteratorSupported;
  public static bool Is32BitProcess => IntPtr.Size == 4;
+ public static bool Is64BitProcess => IntPtr.Size == 8;
  public static bool IsNotWindows => !IsWindows;
 
  public static bool IsThreadingSupported => !IsBrowser;

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

@@ -707,6 +707,7 @@
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CharSet.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\ClassInterfaceAttribute.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\ClassInterfaceType.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CLong.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CoClassAttribute.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CollectionsMarshal.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\ComDefaultInterfaceAttribute.cs" />
@@ -735,6 +736,7 @@
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\ComTypes\ITypeLib2.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\ComVisibleAttribute.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CriticalHandle.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CULong.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CurrencyWrapper.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CustomQueryInterfaceMode.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\CustomQueryInterfaceResult.cs" />
@@ -769,6 +771,7 @@
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\MemoryMarshal.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\UnmanagedCallersOnlyAttribute.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\NativeLibrary.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\NFloat.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\OptionalAttribute.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\OutAttribute.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\InteropServices\PreserveSigAttribute.cs" />

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/CLong.cs

@@ -0,0 +1,78 @@
+// 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;
+
+#pragma warning disable SA1121 // We use our own aliases since they differ per platform
+#if TARGET_WINDOWS
+using NativeType = System.Int32;
+#else
+using NativeType = System.IntPtr;
+#endif
+
+namespace System.Runtime.InteropServices
+{
+ /// <summary>
+ /// <see cref="CLong"/> is an immutable value type that represents the <c>long</c> type in C and C++.
+ /// It is meant to be used as an exchange type at the managed/unmanaged boundary to accurately represent
+ /// in managed code unmanaged APIs that use the <c>long</c> type.
+ /// This type has 32-bits of storage on all Windows platforms and 32-bit Unix-based platforms.
+ /// It has 64-bits of storage on 64-bit Unix platforms.
+ /// </summary>
+ [CLSCompliant(false)]
+ [Intrinsic]
+ public readonly struct CLong : IEquatable<CLong>
+ {
+ private readonly NativeType _value;
+
+ /// <summary>
+ /// Constructs an instance from a 32-bit integer.
+ /// </summary>
+ /// <param name="value">The integer vaule.</param>
+ public CLong(int value)
+ {
+ _value = (NativeType)value;
+ }
+
+ /// <summary>
+ /// Constructs an instance from a native sized integer.
+ /// </summary>
+ /// <param name="value">The integer vaule.</param>
+ /// <exception cref="OverflowException"><paramref name="value"/> is outside the range of the underlying storage type.</exception>
+ public CLong(nint value)
+ {
+ _value = checked((NativeType)value);
+ }
+
+ /// <summary>
+ /// The underlying integer value of this instance.
+ /// </summary>
+ public nint Value => _value;
+
+ /// <summary>
+ /// Returns a value indicating whether this instance is equal to a specified object.
+ /// </summary>
+ /// <param name="o">An object to compare with this instance.</param>
+ /// <returns><c>true</c> if <paramref name="o"/> is an instance of <see cref="CLong"/> and equals the value of this instance; otherwise, <c>false</c>.</returns>
+ public override bool Equals(object? o) => o is CLong other && Equals(other);
+
+ /// <summary>
+ /// Returns a value indicating whether this instance is equal to a specified <see cref="CLong"/> value.
+ /// </summary>
+ /// <param name="other">A <see cref="CLong"/> value to compare to this instance.</param>
+ /// <returns><c>true</c> if <paramref name="other"/> has the same value as this instance; otherwise, <c>false</c>.</returns>
+ public bool Equals(CLong other) => _value == other._value;
+
+ /// <summary>
+ /// Returns the hash code for this instance.
+ /// </summary>
+ /// <returns>A 32-bit signed integer hash code.</returns>
+ public override int GetHashCode() => _value.GetHashCode();
+
+ /// <summary>
+ /// Converts the numeric value of this instance to its equivalent string representation.
+ /// </summary>
+ /// <returns>The string representation of the value of this instance, consisting of a negative sign if the value is negative, and a sequence of digits ranging from 0 to 9 with no leading zeroes.</returns>
+ public override string ToString() => _value.ToString();
+ }
+}

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/CULong.cs

@@ -0,0 +1,78 @@
+// 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;
+
+#pragma warning disable SA1121 // We use our own aliases since they differ per platform
+#if TARGET_WINDOWS
+using NativeType = System.UInt32;
+#else
+using NativeType = System.UIntPtr;
+#endif
+
+namespace System.Runtime.InteropServices
+{
+ /// <summary>
+ /// <see cref="CULong"/> is an immutable value type that represents the <c>unsigned long</c> type in C and C++.
+ /// It is meant to be used as an exchange type at the managed/unmanaged boundary to accurately represent
+ /// in managed code unmanaged APIs that use the <c>unsigned long</c> type.
+ /// This type has 32-bits of storage on all Windows platforms and 32-bit Unix-based platforms.
+ /// It has 64-bits of storage on 64-bit Unix platforms.
+ /// </summary>
+ [CLSCompliant(false)]
+ [Intrinsic]
+ public readonly struct CULong : IEquatable<CULong>
+ {
+ private readonly NativeType _value;
+
+ /// <summary>
+ /// Constructs an instance from a 32-bit unsigned integer.
+ /// </summary>
+ /// <param name="value">The integer vaule.</param>
+ public CULong(uint value)
+ {
+ _value = (NativeType)value;
+ }
+
+ /// <summary>
+ /// Constructs an instance from a native sized unsigned integer.
+ /// </summary>
+ /// <param name="value">The integer vaule.</param>
+ /// <exception cref="OverflowException"><paramref name="value"/> is outside the range of the underlying storage type.</exception>
+ public CULong(nuint value)
+ {
+ _value = checked((NativeType)value);
+ }
+
+ /// <summary>
+ /// The underlying integer value of this instance.
+ /// </summary>
+ public nuint Value => _value;
+
+ /// <summary>
+ /// Returns a value indicating whether this instance is equal to a specified object.
+ /// </summary>
+ /// <param name="o">An object to compare with this instance.</param>
+ /// <returns><c>true</c> if <paramref name="o"/> is an instance of <see cref="CULong"/> and equals the value of this instance; otherwise, <c>false</c>.</returns>
+ public override bool Equals(object? o) => o is CULong other && Equals(other);
+
+ /// <summary>
+ /// Returns a value indicating whether this instance is equal to a specified <see cref="CLong"/> value.
+ /// </summary>
+ /// <param name="other">A <see cref="CULong"/> value to compare to this instance.</param>
+ /// <returns><c>true</c> if <paramref name="other"/> has the same value as this instance; otherwise, <c>false</c>.</returns>
+ public bool Equals(CULong other) => _value == other._value;
+
+ /// <summary>
+ /// Returns the hash code for this instance.
+ /// </summary>
+ /// <returns>A 32-bit signed integer hash code.</returns>
+ public override int GetHashCode() => _value.GetHashCode();
+
+ /// <summary>
+ /// Converts the numeric value of this instance to its equivalent string representation.
+ /// </summary>
+ /// <returns>The string representation of the value of this instance, consisting of a sequence of digits ranging from 0 to 9 with no leading zeroes.</returns>
+ public override string ToString() => _value.ToString();
+ }
+}