Are there any alignment guarantees for .data declarations?

[lorcanmooney]

I'd like to do something like the following, but safely on all architectures.

static ReadOnlySpan<byte> data => new byte[] { ... };
MemoryMarshal.Cast<byte, uint>(data);

I see that accessing data loads the address of a compiler-synthesized static field (and type), but what influences the alignment of a static field? Does the runtime provide any useful guarantees I can work with?

[jkotas]

Does the runtime provide any useful guarantees I can work with?

There is no useful guarantee today. (Nit: The alignment has to be guaranteed by the compiler. Runtime cannot do much about it.)

Dealing with the alignment guarantees has been a significant part of the work required to make #60948 and associated Roslyn feature happen. Look at the linked issue to see all places that had to be fixed to make the alignment work.

[lorcanmooney]

Understood. Thanks.

[lorcanmooney]

That was an interesting read.

I see a bunch of runtime work to deal with endianess concerns. I took a different approach, using a set of wrapper structs (UInt16LE, UInt32BE, etc) with implicit conversions to the matching runtime types which took care of any byte-swapping, and some basic interface implementations (IComparable, IEquatable). The JIT is shockingly good at removing the unecessary cruft and, as far as I could measure, basic operations on ReadOnlySpan such as BinarySearch and IndexOf saw no performance loss for little-endian data. Out of curiosity I tried some big-endian data, and the overhead was only about 3%.

I've opened dotnet/roslyn/issues/61259 to request the compiler to provide some sort of alignment guarantee.

[nguyenhoanghai1605]

You're absolutely right to raise concern about alignment, especially when working with low-level constructs like MemoryMarshal.Cast<byte, T>().

TL;DR: There are no runtime guarantees for alignment of static .data fields — it’s purely compiler-defined behavior. But we can work around this predictably.

---

🔍 Background

In .NET (and C# generally), alignment of static fields (even for readonly spans initialized from arrays) is not controlled by the runtime. The JIT or the compiler (Roslyn, RyuJIT) may or may not place such data with natural alignment.

Jon’s note about alignment being a compiler responsibility is spot-on — the runtime can’t influence field layout of pre-initialized static data.

---

⚠️ Why This Matters?

If you're casting byte[] to a span of uint, ulong, or even custom structs, misalignment can lead to:

• Unaligned memory access (costly on ARM or older CPUs).
• Hardware exceptions on strict platforms.
• Silent data corruption if assumptions break.

---

🛠 Workaround: Use Unsafe.AsRef or pinning with fixed

A safer approach is to:

ReadOnlySpan<byte> data = new byte[] { ... };

// Pin the array:
fixed (byte* ptr = data)
{
    // Cast safely using alignment-aware methods
    var span = MemoryMarshal.Cast<byte, uint>(data);
}

[jkotas]

// Cast safely using alignment-aware methods

There is nothing safe about this. Pinning alone won't fix the alignment problem.

@nguyenhoanghai1605 Please stop flooding the discussions in this repo with redundant invalid AI-generated answers.