GCC currently accepts the declaration of f0 below but ignores the attribute. On aarch64 (and I presume on other targets with a default function alignment greater than 1), GCC rejects f1 with an error, even though it accepts -falign-functions=1 without as much as a warning.
Clang, on the other hand, rejects f0 with a hard error because the alignment is not a power of two, but accepts f1 and appears to honor the attribute. It also accepts -falign-functions=1. I think diagnosing f0 with a warning is helpful because an explicit zero alignment is most likely a mistake (especially when it comes from a macro or some computation). But I don't see a good reason to reject a program that specifies a smaller alignment for a function when the default (or minimum) alignment is greater. A smaller alignment is trivially satisfied by a greater alignment so either accepting it or dropping it seems preferable to failing with an error (either could be with or without a warning). __attribute__ ((aligned (0))) void f0 (void); // accepted, ignored __attribute__ ((aligned (1))) void f1 (void); // aarch64 error __attribute__ ((aligned (4))) void f4 (void); // okay Does anyone know why GCC rejects the program, or can anyone think of a reason why GCC should not behave as suggested above? Thanks Martin
