On 11/23/18 12:31 PM, Martin Sebor wrote: > 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? Note we have targets that support single byte opcodes and do not have any requirements for functions starting on any boundary. mn103 comes to mind.
However, the attribute can't be used to decrease a function's alignment, so values of 0 or 1 are in practice totally uninteresting and one could make an argument to warn for them. Whether or not to warn in general if the alignment attribute is smaller than the default may be subject to debate. I guess it depends on the general intent that we'd find in real world codes. jeff
