Apparently there is some disagreement about whether alignof is supposed to return the preferred alignment or the ABI alignment. Without reading the standard, my intuition is to agree with you: alignof should tell you how things are aligned in structs, nothing else.

However, this behavior has been changed before and that was reverted:

commit 9f1210c3280104417a4ad30f0a00825ac8fa718a
Author: Chad Rosier mcrosier@apple.com
Date: Tue Jul 26 07:03:04 2011 +0000

After further discussion it has been determined that alignof should report
the preferred alignment.  Thus, revert r135934, r135935, and r135940.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@136062 91177308-0d34-0410-b5e6-96231b3b80d8

I wouldn't touch it with a ten foot pole.

this behavior has been changed before and that was reverted:

That was OK back in 2011, for compatibility with how GCC behaved at the time. However, in GCC 4.9 (2014), GCC changed to conform to C11, and Clang should agree with GCC and should conform to the standard. See GCC Bug#52023 here:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52023

So, like it or not, this one's a no-brainer.

Chad, do you remember where this discussion took place and what the rationale was? This certainly looks like a bug.

Chad, do you remember where this discussion took place and what the
rationale was? This certainly looks like a bug.

Unfortunately, that was a lifetime ago and I don't recall the details.

Bob, do you have any additional details (perhaps, in a radar)?

Seems to be part of rdar://9802874

Yes, we had many discussions about this. Ultimately it came down to matching GCC. When I last tried it in 2012, GCC was still using the preferred alignment for alignof. If that has changed, it would make sense to reevaluate this for clang as well.

Just to clarify: this bug report is not about alignof, which is the preferred alignment. In x86 GCC, alignof(double) has not changed and is still 8.

This bug report is about alignof, which is the guaranteed alignment in conforming applications. alignof(double) was 8 in x86 GCC before GCC 4.9, but C11 says alignof(double) must be 4 if a standard-conforming program can generate a double with alignment of 4, as in the C program illustrating the bug here. That is why alignof(double) is 4 in x86 GCC 4.9 and later.

So, in recent versions of GCC, for x86_32:

alignof(double) == 8 for C and C++
alignof(double) == 8 for C++
_Alignof(double) == 4 for C

So there's a GCC bug in there somewhere. The C and C++ versions of the standard alignof facility should not be producing different results.

GCC bug filed as gcc.gnu.org/#69763 .

Is there any possibility of fixing this? GCC current returns the correct value for alignof(double); it'd be good to have the same behavior as the other major compiler. I'd be willing to fix it, if my change would be merged.

Is there any possibility of fixing this? GCC current returns the correct
value for alignof(double); it'd be good to have the same behavior as the
other major compiler. I'd be willing to fix it, if my change would be merged.

Yes, we should change alignof and _Alignof (and not alignof) to return the minimum alignment rather than preferred alignment (matching the new GCC behavior and CWG 1879). Please make -fclang-abi-compat=7 (and earlier) use the old rules, and send the patch to the cfe-commits mailing list (it'll likely not be seen if you post it here).

I've written a patch which fixes this bug, and have sent it to cfe-commits. I would appreciate if people check it out and give feedback :)

https://reviews.llvm.org/D53207