Use fast hashing helpers for types with trailing padding

[MichalStrehovsky]

This is same as #111620 but with an extra thing: enable unconditional method body folding on __GetFieldHelper overrides (both the simplified ones that just return a negative number and normal ones).

Before this PR we considered valuetypes as byte-hashable/comparable only if the valuetype didn't have any trailing padding.

This fixes things up so that we can consider types with trailing padding byte-hashable/comparable if the other requirements still hold (such as no double/float fields, no GC references, etc.) and there is a trailing padding. In this case, we remember the number of bytes that we should be looking at and ignore the rest.

Since this doesn't seem to provide meaningful size savings according to rt-sz, this is a throughput improvement, not a size improvement.

class Program
{
    [MethodImpl(MethodImplOptions.NoInlining)]
    static object Get() => default(Helper);

    static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            var s = Stopwatch.StartNew();

            object o = Get();
            int acc = 0;

            for (int j = 0; j < 10000000; j++)
            {
                acc += o.GetHashCode();
            }

            Console.WriteLine($"{s.ElapsedMilliseconds} ({acc})");
        }
    }

    struct Helper
    {
        long _one;
        byte _two;
        byte _three;
        byte _four;
        byte _five;
    }
}

Before:

243 (-899317760)
243 (-899317760)
246 (-899317760)
244 (-899317760)
244 (-899317760)
245 (-899317760)
240 (-899317760)
240 (-899317760)
232 (-899317760)
248 (-899317760)

After:

229 (565863296)
229 (565863296)
228 (565863296)
229 (565863296)
233 (565863296)
228 (565863296)
229 (565863296)
230 (565863296)
228 (565863296)
230 (565863296)

Resolves #111542

Cc @dotnet/ilc-contrib

[Copilot]

Pull Request Overview

This PR improves performance of value type hashing and equality comparisons by enabling fast hashing helpers for types with trailing padding. The changes allow value types to use memory-based comparisons up to a specified offset rather than requiring field-by-field comparisons when there's trailing padding.

Key changes:

• Modified the compiler to enable method body folding for __GetFieldHelper overrides unconditionally
• Enhanced the fast path logic to handle value types with trailing padding by comparing memory up to the last field's end offset
• Updated the API semantics to use negative return values to indicate the byte offset for memory comparison

Reviewed Changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated no comments.

File	Description
ObjectDataInterner.cs	Enables unconditional method body folding for ValueTypeGetFieldHelperMethodOverride methods
ValueTypeGetFieldHelperMethodOverride.cs	Adds fast path for value types that can use memory comparison up to a specific offset
ComparerIntrinsics.cs	Extends the analysis to support partial memory comparison up to the last field's end offset
ValueType.cs	Updates the runtime implementation to handle negative return values as byte offsets for memory comparison

[dotnet-policy-service]

Tagging subscribers to this area: @agocke, @MichalStrehovsky, @jkotas
See info in area-owners.md if you want to be subscribed.

[MichalStrehovsky]

/azp run runtime-nativeaot-outerloop

[azure-pipelines]

Azure Pipelines successfully started running 1 pipeline(s).

[MichalStrehovsky]

/ba-g the arm32 failures are known and have a fix out