Bogus alignment mismatch diagnostic

[PJBoy]

Testcase ( https://godbolt.org/z/o1b83cEbG )

#include <cstdint>

using UnalignedType [[gnu::aligned(1)]] = struct
{
    uint32_t x;
};

alignas(4) UnalignedType alignedVariable{};

void f(UnalignedType)
{}

static_assert(alignof(UnalignedType) == 1);
static_assert(alignof(alignedVariable) == 4);

int main()
{
    f(alignedVariable);
}

The diagnostic reported is

passing 1-byte aligned argument to 4-byte aligned parameter 'this' of 'UnalignedType' may result in an unaligned pointer access [-Walign-mismatch]
18 | f(alignedVariable);
| ^

However, the argument alignedVariable is 4-byte aligned, and I would expect UnalignedType to be a one-byte aligned parameter; the reported alignments seem to be reversed

[cor3ntin]

f(alignedVariable); calls the copy constructor of the unnamed type. That defaulted copy constructor of the unnamed type expect a 4-bytes this pointer, which is sensible - and at the point of declaration of the constructor, the unnamed struct has no knowledge of the enclosing alias, so the attribute has no effect yet.

As @Endilll pointed out to me, #pragma pack does what we expect. https://godbolt.org/z/hxjv9Pxoe
So I think the diagnostic is correct but maybe applying [[gnu::aligned]] to aliases is not - or maybe we are missing checks when applying the attribute

[Endilll]

So I think the diagnostic is correct but maybe applying [[gnu::aligned]] to aliases is not

I think you are right, giving that GCC doesn't agree that alignment of UnalignedType is 1: https://godbolt.org/z/13sfhT9c7

[AaronBallman]

From GCC's documentation:

When used on a struct, or struct member, the aligned attribute can only increase the alignment; in order to decrease it, the packed attribute must be specified as well. When used as part of a typedef, the aligned attribute can both increase and decrease alignment, and specifying the packed attribute generates a warning.

But I think that may only apply in C: https://godbolt.org/z/PnGbh6Eaa

[meator]

From GCC's documentation:

When used on a struct, or struct member, the aligned attribute can only increase the alignment; in order to decrease it, the packed attribute must be specified as well. When used as part of a typedef, the aligned attribute can both increase and decrease alignment, and specifying the packed attribute generates a warning.

But I think that may only apply in C: https://godbolt.org/z/PnGbh6Eaa

The original problem (which was the reason this issue was posted) is related to efivar's efi_guid_t type, which is a typedef, so aligned() is able to decrease the alignment in this case.

This is the struct:

typedef struct {
	uint32_t	a;
	uint16_t	b;
	uint16_t	c;
	uint16_t	d;
	uint8_t		e[6];
} efi_guid_t __attribute__((__aligned__(1)));

f(alignedVariable); calls the copy constructor of the unnamed type. That defaulted copy constructor of the unnamed type expect a 4-bytes this pointer, which is sensible - and at the point of declaration of the constructor, the unnamed struct has no knowledge of the enclosing alias, so the attribute has no effect yet.

If I understand your explanation correctly, there is no way to call f() with a well-aligned argument, because the default copy constructor will always be involved. Is that right?

I also find it weird that gcc doesn't care about alignment with all warnings enabled: https://test.godbolt.org/z/bPj514zx9

[AaronBallman]

If I understand your explanation correctly, there is no way to call f() with a well-aligned argument, because the default copy constructor will always be involved. Is that right?

That matches my understanding.