tree d6024351435f3d2b22514ae8c31bc20b23eb5893
parent 45b1bd955ca1bc3b850556e2378f1cd60c05daf6
author Ilias Apalodimas <ilias.apalodimas@linaro.org> 1710485029 +0200
committer Tom Rini <trini@konsulko.com> 1711723165 -0400

arm: fix __efi_runtime_start/end definitions

__efi_runtime_start/end are defined as c variables for arm7 only in
order to force the compiler emit relative references. However, defining
those within a section definition will do the same thing since [0].
On top of that the v8 linker scripts define it as a symbol.

So let's remove the special sections from the linker scripts, the
variable definitions from sections.c and define them as a symbols within
the correct section.

[0] binutils commit 6b3b0ab89663 ("Make linker assigned symbol dynamic only for shared object")

Suggested-by: Sam Edwards <CFSworks@gmail.com>
Reviewed-by: Sam Edwards <CFSworks@gmail.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: Sam Edwards <CFSworks@gmail.com> # Binary output identical
Signed-off-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
