Convert fast path of ValueType.GetHashCode to managed

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs

@@ -330,6 +330,9 @@ internal static unsafe bool ObjectHasComponentSize(object obj)
  [return: MarshalAs(UnmanagedType.Bool)]
  internal static unsafe partial bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb);
 
+ [LibraryImport(QCall, EntryPoint = "MethodTable_GetTypeID")]
+ internal static unsafe partial uint GetTypeID(MethodTable* pMT);
+
  /// <summary>
  /// Allocate memory that is associated with the <paramref name="type"/> and
  /// will be freed if and when the <see cref="Type"/> is unloaded.
@@ -467,7 +470,13 @@ internal unsafe struct MethodTable
 
  // Additional conditional fields (see methodtable.h).
  // m_pModule
- // m_pAuxiliaryData
+
+ /// <summary>
+ /// A pointer to auxiliary data that is cold for method table.
+ /// </summary>
+ [FieldOffset(AuxiliaryDataOffset)]
+ public MethodTableAuxiliaryData* AuxiliaryData;
+
  // union {
  // m_pEEClass (pointer to the EE class)
  // m_pCanonMT (pointer to the canonical method table)
@@ -528,6 +537,12 @@ internal unsafe struct MethodTable
 
  private const int ParentMethodTableOffset = 0x10 + DebugClassNamePtr;
 
+#if TARGET_64BIT
+ private const int AuxiliaryDataOffset = 0x20 + DebugClassNamePtr;
+#else
+ private const int AuxiliaryDataOffset = 0x18 + DebugClassNamePtr;
+#endif
+
 #if TARGET_64BIT
  private const int ElementTypeOffset = 0x30 + DebugClassNamePtr;
 #else
@@ -615,6 +630,28 @@ public TypeHandle GetArrayElementTypeHandle()
  public extern uint GetNumInstanceFieldBytes();
  }
 
+ // Subset of src\vm\methodtable.h
+ [StructLayout(LayoutKind.Explicit)]
+ internal unsafe struct MethodTableAuxiliaryData
+ {
+ [FieldOffset(0)]
+ private uint Flags;
+
+ private const uint enum_flag_CanCompareBitsOrUseFastGetHashCode = 0x0001; // Is any field type or sub field type overrode Equals or GetHashCode
+ private const uint enum_flag_HasCheckedCanCompareBitsOrUseFastGetHashCode = 0x0002; // Whether we have checked the overridden Equals or GetHashCode
+
+ public bool HasCheckedCanCompareBitsOrUseFastGetHashCode => (Flags & enum_flag_HasCheckedCanCompareBitsOrUseFastGetHashCode) != 0;
+
+ public bool CanCompareBitsOrUseFastGetHashCode
+ {
+ get
+ {
+ Debug.Assert(HasCheckedCanCompareBitsOrUseFastGetHashCode);
+ return (Flags & enum_flag_CanCompareBitsOrUseFastGetHashCode) != 0;
+ }
+ }
+ }
+
  /// <summary>
  /// A type handle, which can wrap either a pointer to a <c>TypeDesc</c> or to a <see cref="MethodTable"/>.
  /// </summary>

src/coreclr/System.Private.CoreLib/src/System/ValueType.cs

@@ -13,12 +13,13 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace System
 {
  [Serializable]
  [TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public abstract class ValueType
+ public abstract partial class ValueType
  {
  [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern",
  Justification = "Trimmed fields don't make a difference for equality")]
@@ -36,7 +37,7 @@ public override unsafe bool Equals([NotNullWhen(true)] object? obj)
 
  // if there are no GC references in this object we can avoid reflection
  // and do a fast memcmp
- if (CanCompareBits(this))
+ if (CanCompareBitsOrUseFastGetHashCode(RuntimeHelpers.GetMethodTable(obj))) // MethodTable kept alive by access to object below
  {
  return SpanHelpers.SequenceEqual(
  ref RuntimeHelpers.GetRawData(this),
@@ -66,8 +67,23 @@ ref RuntimeHelpers.GetRawData(obj),
  return true;
  }
 
- [MethodImpl(MethodImplOptions.InternalCall)]
- private static extern bool CanCompareBits(object obj);
+ // Return true if the valuetype does not contain pointer, is tightly packed,
+ // does not have floating point number field and does not override Equals method.
+ private static unsafe bool CanCompareBitsOrUseFastGetHashCode(MethodTable* pMT)
+ {
+ MethodTableAuxiliaryData* pAuxData = pMT->AuxiliaryData;
+
+ if (pAuxData->HasCheckedCanCompareBitsOrUseFastGetHashCode)
+ {
+ return pAuxData->CanCompareBitsOrUseFastGetHashCode;
+ }
+
+ return CanCompareBitsOrUseFastGetHashCodeHelper(pMT);
+ }
+
+ [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodTable_CanCompareBitsOrUseFastGetHashCode")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ private static unsafe partial bool CanCompareBitsOrUseFastGetHashCodeHelper(MethodTable* pMT);
 
  /*=================================GetHashCode==================================
  **Action: Our algorithm for returning the hashcode is a little bit complex. We look
@@ -79,8 +95,44 @@ ref RuntimeHelpers.GetRawData(obj),
  **Arguments: None.
  **Exceptions: None.
  ==============================================================================*/
- [MethodImpl(MethodImplOptions.InternalCall)]
- public extern override int GetHashCode();
+ public override unsafe int GetHashCode()
+ {
+ // The default implementation of GetHashCode() for all value types.
+ // Note that this implementation reveals the value of the fields.
+ // So if the value type contains any sensitive information it should
+ // implement its own GetHashCode().
+
+ MethodTable* pMT = RuntimeHelpers.GetMethodTable(this);
+
+ // We don't want to expose the method table pointer in the hash code
+ // Let's use the typeID instead.
+ uint typeID = RuntimeHelpers.GetTypeID(pMT);
+
+ // To get less colliding and more evenly distributed hash codes,
+ // we munge the class index with two big prime numbers
+ int hashCode = (int)(typeID * 711650207 + 2506965631U);
+
+ if (CanCompareBitsOrUseFastGetHashCode(pMT))
+ {
+ // this is a struct with no refs and no "strange" offsets
+ HashCode hash = default;
+ uint size = pMT->GetNumInstanceFieldBytes();
+ hash.AddBytes(MemoryMarshal.CreateReadOnlySpan(ref this.GetRawData(), (int)size));
+ hashCode ^= hash.ToHashCode();
+ }
+ else
+ {
+ object obj = this;
+ hashCode ^= RegularGetValueTypeHashCode(pMT, ObjectHandleOnStack.Create(ref obj));
+ }
+
+ GC.KeepAlive(this);
+ return hashCode;
+ }
+
+ [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ValueType_RegularGetValueTypeHashCode")]
+ [SuppressGCTransition]
+ private static unsafe partial int RegularGetValueTypeHashCode(MethodTable* pMT, ObjectHandleOnStack obj);
 
  public override string? ToString()
  {

src/coreclr/vm/comutilnative.cpp

@@ -1681,45 +1681,21 @@ BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt)
  return canCompareBitsOrUseFastGetHashCode;
 }
 
-NOINLINE static FC_BOOL_RET CanCompareBitsHelper(MethodTable* mt, OBJECTREF objRef)
+extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable * mt)
 {
- FC_INNER_PROLOG(ValueTypeHelper::CanCompareBits);
-
- _ASSERTE(mt != NULL);
- _ASSERTE(objRef != NULL);
+ QCALL_CONTRACT;
 
  BOOL ret = FALSE;
 
- HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_EXACT_DEPTH|Frame::FRAME_ATTR_CAPTURE_DEPTH_2, objRef);
+ BEGIN_QCALL;
 
  ret = CanCompareBitsOrUseFastGetHashCode(mt);
 
- HELPER_METHOD_FRAME_END();
- FC_INNER_EPILOG();
+ END_QCALL;
 
- FC_RETURN_BOOL(ret);
+ return ret;
 }
 
-// Return true if the valuetype does not contain pointer, is tightly packed,
-// does not have floating point number field and does not override Equals method.
-FCIMPL1(FC_BOOL_RET, ValueTypeHelper::CanCompareBits, Object* obj)
-{
- FCALL_CONTRACT;
-
- _ASSERTE(obj != NULL);
- MethodTable* mt = obj->GetMethodTable();
-
- if (mt->HasCheckedCanCompareBitsOrUseFastGetHashCode())
- {
- FC_RETURN_BOOL(mt->CanCompareBitsOrUseFastGetHashCode());
- }
-
- OBJECTREF objRef(obj);
-
- FC_INNER_RETURN(FC_BOOL_RET, CanCompareBitsHelper(mt, objRef));
-}
-FCIMPLEND
-
 static INT32 FastGetValueTypeHashCodeHelper(MethodTable *mt, void *pObjRef)
 {
  CONTRACTL
@@ -1842,65 +1818,25 @@ static INT32 RegularGetValueTypeHashCode(MethodTable *mt, void *pObjRef)
  return hashCode;
 }
 
-// The default implementation of GetHashCode() for all value types.
-// Note that this implementation reveals the value of the fields.
-// So if the value type contains any sensitive information it should
-// implement its own GetHashCode().
-FCIMPL1(INT32, ValueTypeHelper::GetHashCode, Object* objUNSAFE)
+extern "C" INT32 QCALLTYPE ValueType_RegularGetValueTypeHashCode(MethodTable * pMT, QCall::ObjectHandleOnStack objHandle)
 {
- FCALL_CONTRACT;
-
- if (objUNSAFE == NULL)
- FCThrow(kNullReferenceException);
-
- OBJECTREF obj = ObjectToOBJECTREF(objUNSAFE);
- VALIDATEOBJECTREF(obj);
-
- INT32 hashCode = 0;
- MethodTable *pMT = objUNSAFE->GetMethodTable();
-
- // We don't want to expose the method table pointer in the hash code
- // Let's use the typeID instead.
- UINT32 typeID = pMT->LookupTypeID();
- if (typeID == TypeIDProvider::INVALID_TYPE_ID)
+ CONTRACTL
  {
- // If the typeID has yet to be generated, fall back to GetTypeID
- // This only needs to be done once per MethodTable
- HELPER_METHOD_FRAME_BEGIN_RET_1(obj);
- typeID = pMT->GetTypeID();
- HELPER_METHOD_FRAME_END();
- }
+ THROWS;
+ GC_TRIGGERS;
+ MODE_COOPERATIVE;
+ } CONTRACTL_END;
 
- // To get less colliding and more evenly distributed hash codes,
- // we munge the class index with two big prime numbers
- hashCode = typeID * 711650207 + 2506965631U;
+ INT32 ret = 0;
 
- BOOL canUseFastGetHashCodeHelper = FALSE;
- if (pMT->HasCheckedCanCompareBitsOrUseFastGetHashCode())
- {
- canUseFastGetHashCodeHelper = pMT->CanCompareBitsOrUseFastGetHashCode();
- }
- else
- {
- HELPER_METHOD_FRAME_BEGIN_RET_1(obj);
- canUseFastGetHashCodeHelper = CanCompareBitsOrUseFastGetHashCode(pMT);
- HELPER_METHOD_FRAME_END();
- }
+ BEGIN_QCALL;
 
- if (canUseFastGetHashCodeHelper)
- {
- hashCode ^= FastGetValueTypeHashCodeHelper(pMT, obj->UnBox());
- }
- else
- {
- HELPER_METHOD_FRAME_BEGIN_RET_1(obj);
- hashCode ^= RegularGetValueTypeHashCode(pMT, obj->UnBox());
- HELPER_METHOD_FRAME_END();
- }
+ ret = RegularGetValueTypeHashCode(pMT, objHandle.Get()->UnBox());
 
- return hashCode;
+ END_QCALL;
+
+ return ret;
 }
-FCIMPLEND
 
 FCIMPL1(UINT32, MethodTableNative::GetNumInstanceFieldBytes, MethodTable* mt)
 {
@@ -1924,6 +1860,27 @@ extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, Metho
  return bResult;
 }
 
+extern "C" UINT32 QCALLTYPE MethodTable_GetTypeID(MethodTable * mt)
+{
+ QCALL_CONTRACT;
+
+ UINT32 typeID = 0;
+
+ BEGIN_QCALL;
+
+ typeID = mt->LookupTypeID();
+ if (typeID == TypeIDProvider::INVALID_TYPE_ID)
+ {
+ // If the typeID has yet to be generated, fall back to GetTypeID
+ // This only needs to be done once per MethodTable
+ typeID = mt->GetTypeID();
+ }
+
+ END_QCALL;
+
+ return typeID;
+}
+
 static MethodTable * g_pStreamMT;
 static WORD g_slotBeginRead, g_slotEndRead;
 static WORD g_slotBeginWrite, g_slotEndWrite;

src/coreclr/vm/comutilnative.h

@@ -245,18 +245,15 @@ class COMInterlocked
 
 extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide();
 
-class ValueTypeHelper {
-public:
- static FCDECL1(FC_BOOL_RET, CanCompareBits, Object* obj);
- static FCDECL1(INT32, GetHashCode, Object* objRef);
-};
-
 class MethodTableNative {
 public:
  static FCDECL1(UINT32, GetNumInstanceFieldBytes, MethodTable* mt);
 };
 
 extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb);
+extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt);
+extern "C" UINT32 QCALLTYPE MethodTable_GetTypeID(MethodTable* mt);
+extern "C" INT32 QCALLTYPE ValueType_RegularGetValueTypeHashCode(MethodTable * pMT, QCall::ObjectHandleOnStack objHandle);
 
 class StreamNative {
 public:

src/coreclr/vm/ecalllist.h

@@ -76,11 +76,6 @@ FCFuncStart(gStringFuncs)
  FCDynamicSig(COR_CTOR_METHOD_NAME, &gsig_IM_PtrSByt_Int_Int_Encoding_RetVoid, ECall::CtorSBytePtrStartLengthEncodingManaged)
 FCFuncEnd()
 
-FCFuncStart(gValueTypeFuncs)
- FCFuncElement("CanCompareBits", ValueTypeHelper::CanCompareBits)
- FCFuncElement("GetHashCode", ValueTypeHelper::GetHashCode)
-FCFuncEnd()
-
 FCFuncStart(gDiagnosticsDebugger)
  FCFuncElement("BreakInternal", DebugDebugger::Break)
  FCFuncElement("get_IsAttached", DebugDebugger::IsDebuggerAttached)
@@ -660,7 +655,6 @@ FCClassElement("Thread", "System.Threading", gThreadFuncs)
 FCClassElement("ThreadPool", "System.Threading", gThreadPoolFuncs)
 FCClassElement("Type", "System", gSystem_Type)
 FCClassElement("TypedReference", "System", gTypedReferenceFuncs)
-FCClassElement("ValueType", "System", gValueTypeFuncs)
 #ifdef FEATURE_COMINTEROP
 FCClassElement("Variant", "System", gVariantFuncs)
 #endif

src/coreclr/vm/qcallentrypoints.cpp

@@ -100,6 +100,9 @@ static const Entry s_QCall[] =
  DllImportEntry(QCall_GetGCHandleForTypeHandle)
  DllImportEntry(QCall_FreeGCHandleForTypeHandle)
  DllImportEntry(MethodTable_AreTypesEquivalent)
+ DllImportEntry(MethodTable_CanCompareBitsOrUseFastGetHashCode)
+ DllImportEntry(MethodTable_GetTypeID)
+ DllImportEntry(ValueType_RegularGetValueTypeHashCode)
  DllImportEntry(RuntimeTypeHandle_MakePointer)
  DllImportEntry(RuntimeTypeHandle_MakeByRef)
  DllImportEntry(RuntimeTypeHandle_MakeSZArray)