[mono] Mono doesn't respect explicit size for structures when marked with LayoutKind.Sequential

[matouskozak]

Mono doesn't respect explicit struct size when combined with sequential layout, i.e., when using [StructLayout(LayoutKind.Sequential, Size = X)], the structure doesn't have the desired size X.

Repro code:

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Size = 12)]
struct F3_S0_S0
{
    public nint F0;
    public uint F1;

    public F3_S0_S0(nint f0, uint f1)
    {
        F0 = f0;
        F1 = f1;
    }
}

private static void Main(string[] args)
{
    Console.WriteLine(Marshal.SizeOf(typeof(F3_S0_S0)));
}

Mono output:

16

CoreCLR output:

12

[lambdageek]

This goes back a long time to 6fcc759

  * class.h, class.h: take minimum alignment into consideration so
   that the fields of a class remain aligned also when in an array.

Here:

runtime/src/mono/mono/metadata/class-init.c

Lines 2391 to 2396 in 2e75aac

	if (!((layout == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) && explicit_size)) {
	if (instance_size & (min_align - 1)) {
	instance_size += min_align - 1;
	instance_size &= ~(min_align - 1);
	}
	}

It might be possible to change this to respect the specified size also for sequential layouts, not just explicit. But I'm not sure how much code that will break downstream of mono.

[jakobbotsch]

It's more evidence that something like #100896 is necessary, even without generics. These kind of struct layouts are necessary to model Swift structures in C#. cc @jkoritzinsky

@matouskozak if you are blocked on the Swift work I can give you some instructions on generating the Swift unit tests with ExplicitLayout.

[lambdageek]

What happens in swift if you allocate an array of frozen structs that have a size that is not a multiple of the minimum alignment of any members? Do the array elements end up packing tightly and misaligning the members?

[jakobbotsch]

Swift has the notion of "stride" for this:

https://github.com/apple/swift/blob/4b440a1d80a0900b6121b6e4a15fff2a96263bc5/docs/ABI/TypeLayout.rst#fragile-struct-and-tuple-layout

The final size and alignment are the size and alignment of the aggregate. The stride of the type is the final size rounded up to alignment.

I believe the stride is used for array allocations, but for struct layout Swift allows fields to pack into the "tail padding" of previous structures, like as follows:

[StructLayout(LayoutKind.Sequential, Size = 12)]
struct F3_S0_S0
{
    public nint F0;
    public uint F1;

    public F3_S0_S0(nint f0, uint f1)
    {
        F0 = f0;
        F1 = f1;
    }
}

[StructLayout(LayoutKind.Sequential, Pack = 16)]
public struct S
{
  public F3_S0_S0 S;
  public int X; // at offset 12
}

[lambdageek]

I believe the stride is used for array allocations, but for struct layout Swift allows fields to pack into the "tail padding" of previous structures, like as follows:

that makes sense, thanks

[lambdageek]

Fixed in #101529