Visual C++ not respecting alignment for stack variables

Question

The following sometimes fails after compiling for x86 with Visual Studio 16.8.1:

#include <cassert>
#include <cstdint>

struct X { uint64_t value; };

int main() {
    X x;
    assert(reinterpret_cast<uintptr_t>(&x) % alignof(X) == 0);
}

Interestingly, the assert doesn't trigger if X has an explicit alignment specifier: struct alignas(uint64_t) X.

Am I correct to assume this is a compiler bug and not some quirk of the C++ standard?

maybe the quirk is in your expectations. Why do you expect the assertion to hold? — 463035818_is_not_an_ai, Nov 16 '20 at 20:21
I expect `x` to be placed in memory per its alignment requirement. — Valentin Milea, Nov 16 '20 at 20:28
but the address of `x` is just some address, alignment with respect to what? (btw, I don't know what is happening here, I am just curious and look forward to answers) — 463035818_is_not_an_ai, Nov 16 '20 at 20:30
Alignment with respect to address `0`. If `x` has alignment `N`, I'd expect its address to be a multiple of `N`. — Valentin Milea, Nov 16 '20 at 20:42
Quoting cppreference: "Every object type has the property called alignment requirement, which is an integer value (of type std::size_t, always a power of 2) representing the number of bytes between successive addresses at which objects of this type can be allocated." — Valentin Milea, Nov 16 '20 at 20:43
@Dialecticus `alignof(X)` is 8 regardless of 32-bit / 64-bit build. — Valentin Milea, Nov 16 '20 at 20:43
Check this out: https://stackoverflow.com/questions/55920103/why-is-the-alignment-the-same-on-32-bit-and-64-bit-systems — Vlad Feinstein, Nov 16 '20 at 21:35
Thanks, that does explain it. I'll try to summarize the answer below. — Valentin Milea, Nov 17 '20 at 14:33

Valentin Milea · Answer 1 · 2020-11-19T11:40:48.803

1

It's a bug.

On x86, some operations may incur a performance penalty unless the operand is naturally aligned. Apparently Visual C++ has a nonconformant alignof operator which returns the natural alignment instead of the required alignment for a type. When building with MSVC for 32-bit, the natural alignment of uint64_t / double is 8, while its required alignment is 4. So in the code above the address of x must be a multiple of 4, but not necessarily a multiple of alignof(X).

This baffling behavior is underlined by uint64_t x; not having the same meaning as alignas(uint64_t) uint64_t x;. Only the latter has the expected alignment.

See also: GCC fixing a similar bug and associated libc++ updates.

edited Nov 19 '20 at 11:40

answered Nov 17 '20 at 14:46

Valentin Milea

3,186
3
28
29

Reported [here](https://developercommunity.visualstudio.com/content/problem/1258506/visual-c-alignof-is-not-conformant-on-x86.html). – Valentin Milea Nov 17 '20 at 15:32
Documented [here](https://learn.microsoft.com/en-us/cpp/build/x64-software-conventions?view=msvc-160#conflicts-with-the-x86-compiler). – Hans Passant Nov 19 '20 at 12:40
Thanks for the link. This explains the alignment of stack variables on x86. But it doesn't address `alignof`, which should report the _required_ alignment of 4. – Valentin Milea Feb 01 '21 at 08:03

Visual C++ not respecting alignment for stack variables

1 Answers1