Re: [PATCH 0/8] linker-section array fix and clean ups

[Jessica Yu]

+++ Johan Hovold [03/11/20 18:57 +0100]:
> We rely on the linker to create arrays for a number of things including
> kernel parameters and device-tree-match entries.
>
> The stride of these linker-section arrays obviously needs to match the
> expectations of the code accessing them or bad things will happen.
>
> One thing to watch out for is that gcc is known to increase the
> alignment of larger objects with static extent as an optimisation (on
> x86), but this can be suppressed by using the aligned attribute when
> declaring entries.
>
> We've been relying on this behaviour for 16 years for kernel parameters
> (and other structures) and it indeed hasn't changed since the
> introduction of the aligned attribute in gcc 3.1 (see align_variable()
> in [1]).
>
> Occasionally this gcc optimisation do cause problems which have instead
> been worked around in various creative ways including using indirection
> through an array of pointers. This was originally done for tracepoints
> [2] after a number of failed attempts to create properly aligned arrays,
> and the approach was later reused for module-version attributes [3] and
> earlycon entries.

> [2] https://lore.kernel.org/lkml/20110126222622.GA10794@Krystal/

Hi Johan,

So unfortunately, I am not familiar enough with the semantics of gcc's
aligned attribute. AFAICT from the patch you linked in [2], the
original purpose of the pointer indirection workaround was to avoid
relying on (potentially inconsistent) compiler-specific behavior with
respect to the aligned attribute. The main concern was potential
up-alignment being done by gcc (or the linker) despite the desired
alignment being specified. Indeed, the gcc documentation also states
that the aligned attribute only specifies the *minimum* alignment,
although there's no guarantee that up-alignment wouldn't occur.

So I guess my question is, is there some implicit guarantee that
specifying alignment by type via __alignof__ that's supposed to
prevent gcc from up-aligning? Or are we just assuming that gcc won't
increase the alignment? The gcc docs don't seem to clarify this
unfortunately.

Thanks,

Jessica