Generalize IsBitwiseEquatable to field-wise IEquatable value types

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

@@ -352,6 +352,13 @@ public static object GetUninitializedObject(
         /// <returns>true if given type is bitwise equatable (memcmp can be used for equality checking)</returns>
         /// <remarks>
         /// Only use the result of this for Equals() comparison, not for CompareTo() comparison.
+        /// <para>
+        /// A bitwise comparison may read the value using accesses wider than an individual field. Under an
+        /// unsynchronized concurrent mutation -- already a data race with undefined behavior -- this can observe
+        /// a torn value within a single field that a strictly field-wise comparison would not. A torn read cannot
+        /// fabricate an invalid managed reference; only the already-undefined total comparison result is affected. This is
+        /// acceptable for bitwise-based APIs such as <see cref="MemoryExtensions.SequenceEqual{T}(ReadOnlySpan{T}, ReadOnlySpan{T})"/>.
+        /// </para>
         /// </remarks>
         [Intrinsic]
         internal static bool IsBitwiseEquatable<T>()

src/coreclr/nativeaot/Test.CoreLib/src/System/IEquatable.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System
+{
+    public interface IEquatable<T>
+    {
+        bool Equals(T other);
+    }
+}

src/coreclr/nativeaot/Test.CoreLib/src/Test.CoreLib.csproj

@@ -236,6 +236,7 @@
     <Compile Include="System\SpanHelpers.cs" />
     <Compile Include="System\RuntimeExceptionHelpers.cs" />
     <Compile Include="System\Object.cs" />
+    <Compile Include="System\IEquatable.cs" />
     <Compile Include="System\Type.cs" />
     <Compile Include="System\RuntimeTypeHandle.cs" />
     <Compile Include="$(AotCommonPath)\Internal\Runtime\TypeManagerHandle.cs">

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

@@ -3,7 +3,6 @@
 
 using System;
 
-using Internal.Text;
 using Internal.TypeSystem;
 
 using Debug = System.Diagnostics.Debug;
@@ -32,51 +31,8 @@ public static MethodIL EmitIL(MethodDesc method)
             bool result;
             if (method.Name == "IsBitwiseEquatable"u8)
             {
-                // Ideally we could detect automatically whether a type is trivially equatable
-                // (i.e., its operator == could be implemented via memcmp). But for now we'll
-                // do the simple thing and hardcode the list of types we know fulfill this contract.
-                // n.b. This doesn't imply that the type's CompareTo method can be memcmp-implemented,
-                // as a method like CompareTo may need to take a type's signedness into account.
-                switch (elementType.UnderlyingType.Category)
-                {
-                    case TypeFlags.Boolean:
-                    case TypeFlags.Byte:
-                    case TypeFlags.SByte:
-                    case TypeFlags.Char:
-                    case TypeFlags.UInt16:
-                    case TypeFlags.Int16:
-                    case TypeFlags.UInt32:
-                    case TypeFlags.Int32:
-                    case TypeFlags.UInt64:
-                    case TypeFlags.Int64:
-                    case TypeFlags.IntPtr:
-                    case TypeFlags.UIntPtr:
-                        result = true;
-                        break;
-                    default:
-                        result = false;
-                        if (elementType is MetadataType mdType)
-                        {
-                            if (IsKnownBitwiseEquatableType(mdType))
-                            {
-                                result = true;
-                            }
-                            else if (mdType.IsValueType)
-                            {
-                                bool? equatable = ComparerIntrinsics.ImplementsIEquatable(mdType.GetTypeDefinition());
-
-                                if (equatable.HasValue && !equatable.Value)
-                                {
-                                    // Value type that can use memcmp and that doesn't override object.Equals or implement IEquatable<T>.Equals.
-                                    MethodDesc objectEquals = mdType.Context.GetWellKnownType(WellKnownType.Object).GetMethod("Equals"u8, null);
-                                    result =
-                                        mdType.FindVirtualFunctionTargetMethodOnObjectType(objectEquals).OwningType != mdType &&
-                                        ComparerIntrinsics.CanCompareValueTypeBits(mdType, objectEquals);
-                                }
-                            }
-                        }
-                        break;
-                }
+                // The runtime and the ILC share a single determination of what is bitwise-equatable.
+                result = ComparerIntrinsics.IsBitwiseEquatable(elementType);
             }
             else
             {
@@ -87,21 +43,5 @@ public static MethodIL EmitIL(MethodDesc method)
 
             return new ILStubMethodIL(method, new byte[] { (byte)opcode, (byte)ILOpcode.ret }, Array.Empty<LocalVariableDefinition>(), Array.Empty<object>());
         }
-
-        private static bool IsKnownBitwiseEquatableType(MetadataType type)
-        {
-            if (type.Module != type.Context.SystemModule)
-            {
-                return false;
-            }
-
-            Utf8Span ns = type.Namespace;
-            if (ns == "System"u8)
-            {
-                Utf8Span name = type.Name;
-                return name == "Guid"u8 || name == "Int128"u8 || name == "UInt128"u8;
-            }
-            return ns == "System.Text"u8 && type.Name == "Rune"u8;
-        }
     }
 }

src/coreclr/vm/comutilnative.cpp

@@ -1775,9 +1775,17 @@ BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt)
         return mt->CanCompareBitsOrUseFastGetHashCode();
     }
 
+    if (mt->GetClass()->IsInlineArray())
+    {
+        // Inline arrays must always throw from ValueType.Equals/GetHashCode, which only happens on the
+        // QCALL entry point. Return false without caching so the managed fast path keeps routing there
+        // instead of reading a cached 'false' (e.g. primed by an enclosing type's field recursion) that
+        // would silently skip the throw.
+        return FALSE;
+    }
+
     if (mt->ContainsGCPointers()
-        || mt->IsNotTightlyPacked()
-        || mt->GetClass()->IsInlineArray())
+        || !mt->IsTightlyPacked())
     {
         mt->SetHasCheckedCanCompareBitsOrUseFastGetHashCode();
         return FALSE;

src/coreclr/vm/corelib.h

@@ -273,8 +273,6 @@ DEFINE_FIELD(ENC_HELPER,            OBJECT_REFERENCE,       _objectReference)
 
 DEFINE_CLASS(ENCODING,              Text,                   Encoding)
 
-DEFINE_CLASS(RUNE,                  Text,                   Rune)
-
 DEFINE_CLASS(ENUM,                  System,                 Enum)
 
 DEFINE_CLASS(ENVIRONMENT,           System,                 Environment)
@@ -1301,6 +1299,7 @@ DEFINE_CLASS(ICOMPARABLEGENERIC,    System,                 IComparable`1)
 DEFINE_METHOD(ICOMPARABLEGENERIC,   COMPARE_TO,             CompareTo,                  NoSig)
 
 DEFINE_CLASS(IEQUATABLEGENERIC,     System,                 IEquatable`1)
+DEFINE_METHOD(IEQUATABLEGENERIC,    EQUALS,                 Equals,                     NoSig)
 
 DEFINE_CLASS_U(Reflection,             LoaderAllocator,          LoaderAllocatorObject)
 DEFINE_FIELD_U(m_slots,                  LoaderAllocatorObject,      m_pSlots)
@@ -1330,6 +1329,7 @@ DEFINE_METHOD(UTF8BUFFERMARSHALER, CONVERT_TO_MANAGED, ConvertToManaged, NoSig)
 
 // Classes referenced in EqualityComparer<T>.Default optimization
 
+DEFINE_CLASS(EQUALITY_COMPARER, CollectionsGeneric, EqualityComparer`1)
 DEFINE_CLASS(STRING_EQUALITYCOMPARER, CollectionsGeneric, StringEqualityComparer)
 DEFINE_CLASS(ENUM_EQUALITYCOMPARER, CollectionsGeneric, EnumEqualityComparer`1)
 DEFINE_CLASS(NULLABLE_EQUALITYCOMPARER, CollectionsGeneric, NullableEqualityComparer`1)