struct with StructLayout(LayoutKind.Explicit) and EqualityComparer<TKey>.Default.Equals

[lakecherry]

Given following simple struct union:

[StructLayout(LayoutKind.Explicit)]
public readonly struct Key : IEquatable<Key>
{
	public Key (ushort index1, ushort index2)
	{
		Unsafe.SkipInit (out this.value);

		this.Index1 = index1;
		this.Index2 = index2;
	}

	public bool Equals (Key other) => this.value == other.value;
	public override int GetHashCode() => this.value;

	public override string ToString() => $"{this.Index1} => {this.Index2}";

	#region Data (4 bytes)

	[FieldOffset(0)]
	public readonly ushort Index1;
	[FieldOffset(2)]
	public readonly ushort Index2;

	[FieldOffset(0)]
	readonly int value;

	#endregion
}

Dictionary<Key, int> test = new();

...
if (entries[num3].hashCode == num && EqualityComparer<TKey>.Default.Equals(entries[num3].key, key))
...

X64 Expected:

00007FF7E88683E9 mov eax,eax
00007FF7E88683EB shl rax,4
00007FF7E88683EF cmp dword ptr [rbp+rax+10h],r15d
00007FF7E88683F4 jne System.Collections.Generic.Dictionary
00007FF7E88683F6 lea rdx,[rbp+rax+10h]
00007FF7E88683FB mov ecx,dword ptr [rdx+8]
00007FF7E88683FE cmp ecx,edi
00007FF7E8868400 je System.Collections.Generic.Dictionary

X64 Reality:

00007FF7E88683F1 mov eax,eax
00007FF7E88683F3 shl rax,4
00007FF7E88683F7 cmp dword ptr [rbx+rax+10h],r14d
00007FF7E88683FC jne System.Collections.Generic.Dictionary
00007FF7E88683FE lea rdx,[rbx+rax+10h]
00007FF7E8868403 mov ecx,dword ptr [rdx+8]
00007FF7E8868406 mov dword ptr [rsp+40h],ecx
00007FF7E886840A mov ecx,dword ptr [rsp+98h]
00007FF7E8868411 mov dword ptr [rsp+38h],ecx
00007FF7E8868415 mov ecx,dword ptr [rsp+40h]
00007FF7E8868419 cmp ecx,dword ptr [rsp+38h]
00007FF7E886841D je System.Collections.Generic.Dictionary

Removing Index1 and Index2 will deliver the expected result, but shouldn't "Key.Equals" depend on "value" only?

[StructLayout(LayoutKind.Explicit)]
public readonly struct Key : IEquatable<Key>
{
	public Key (ushort index1, ushort index2)
	{
//		Unsafe.SkipInit (out this.value);

		this.value = index1 << 16 | index2;

//		this.Index1 = index1;
//		this.Index2 = index2;
	}

	public bool Equals (Key other) => this.value == other.value;
	public override int GetHashCode() => this.value;

//	public override string ToString() => $"{this.Index1} => {this.Index2}";

	#region Data (4 bytes)

//	[FieldOffset(0)]
//	public readonly ushort Index1;
//	[FieldOffset(2)]
//	public readonly ushort Index2;

	[FieldOffset(0)]
	readonly int value;

	#endregion
}

[MichalPetryka]

Explicit layouts, especially those with overlapping fields, have historically been pessimized in their codegen quality. While there are regular improvements to them, in most cases it's better to define your types as Sequential layout and use Unsafe.Bitcast and Unsafe.As for reinterpreting them to different layouts.

[lakecherry]

That helps, thank you ... will find a workaround.

[jakobbotsch]

This isn't good advice. Bitcasting or reinterpreting a 2x ushort struct to an int (or vice versa) will generally not result in good codegen.

@lakecherry is the code examples from .NET 7 or .NET 8? In .NET 8 we made improvements in this area, so the codegen might already be improved for you. In particular the JIT is able to reason about structs with overlapping fields if you aren't mixing accesses within the same function.

[lakecherry]

That is good news, thank you ... already heard about improved struct promotion in .NET 8 ... currently working with .NET 7 environment ... tried unsafe casting without success ... lets see how .NET 8 will do next month.

[lakecherry]

Works fine in .NET8 :)