Convert fast path of ValueType.GetHashCode to managed

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

@@ -467,7 +467,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 +534,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 +627,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

@@ -10,15 +10,17 @@
 **
 ===========================================================*/
 
+using System.Diagnostics;
 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 +38,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 +68,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 +96,67 @@ 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);
+ ref byte rawData = ref RuntimeHelpers.GetRawData(this);
+ HashCode hashCode = default;
+
+ // To get less colliding and more evenly distributed hash codes,
+ // we munge the class index into the hashcode
+ hashCode.Add((IntPtr)pMT);
+
+ if (CanCompareBitsOrUseFastGetHashCode(pMT))
+ {
+ // this is a struct with no refs and no "strange" offsets
+ uint size = pMT->GetNumInstanceFieldBytes();
+ hashCode.AddBytes(MemoryMarshal.CreateReadOnlySpan(ref rawData, (int)size));
+ }
+ else
+ {
+ object thisRef = this;
+ switch (GetHashCodeStrategy(pMT, ObjectHandleOnStack.Create(ref thisRef), out uint fieldOffset, out uint fieldSize))
+ {
+ case ValueTypeHashCodeStrategy.ReferenceField:
+ hashCode.Add(Unsafe.As<byte, object>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode());
+ break;
+
+ case ValueTypeHashCodeStrategy.DoubleField:
+ hashCode.Add(Unsafe.As<byte, double>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode());
+ break;
+
+ case ValueTypeHashCodeStrategy.SingleField:
+ hashCode.Add(Unsafe.As<byte, float>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode());
+ break;
+
+ case ValueTypeHashCodeStrategy.FastGetHashCode:
+ Debug.Assert(fieldSize != 0);
+ hashCode.AddBytes(MemoryMarshal.CreateReadOnlySpan(ref Unsafe.AddByteOffset(ref rawData, fieldOffset), (int)fieldSize));
+ break;
+ }
+ }
+
+ return hashCode.ToHashCode();
+ }
+
+ // Must match the definition in src\vm\comutilnative.cpp
+ private enum ValueTypeHashCodeStrategy
+ {
+ None,
+ ReferenceField,
+ DoubleField,
+ SingleField,
+ FastGetHashCode,
+ }
+
+ [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ValueType_GetHashCodeStrategy")]
+ private static unsafe partial ValueTypeHashCodeStrategy GetHashCodeStrategy(
+ MethodTable* pMT, ObjectHandleOnStack objHandle, out uint fieldOffset, out uint fieldSize);
 
  public override string? ToString()
  {