arm64: rela relocation
Subsystems (3)
cover arm64: rela relocation
This lets us remove the manual relocation stuff from the arm64 patchset (the symbol itself is removed by this patchset, but not all the new manual relocations added by the arm64 patchset).
I'm not terribly happy with the way relocate-rela is now, versus something cleaner that operates on the ELF file, but it's good enough for now and waiting longer to get rid of the manual relocations would be worse.
This patchset is based on David's arm64 patchset v13. David, the first two patches should be applied before your arm64 patches. Maybe the fourth as well (except for the removal of the arm64 ifdef you added, which would then need to be squashed with your patch). The third patch should be squashed with your patches (plus you should remove the manual relocs).
Scott Wood (4):
arm64: Add tool to statically apply RELA relocations
arm64: Turn u-boot.bin back into an ELF file after relocate-rela
arm64: Non-manual relocation
arm64: Make checkarmreloc accept arm64 relocations
Makefile | 39 ++++++-- arch/arm/config.mk | 4 - arch/arm/cpu/armv8/config.mk | 1 - arch/arm/cpu/armv8/u-boot.lds | 32 +++++-- arch/arm/include/asm/config.h | 5 -- arch/arm/lib/crt0_64.S | 7 +- arch/arm/lib/relocate_64.S | 41 ++++----- include/configs/vexpress_aemv8a.h | 3 + tools/Makefile | 6 ++ tools/relocate-rela.c | 185 ++++++++++++++++++++++++++++++++++++++ 10 files changed, 276 insertions(+), 47 deletions(-) create mode 100644 tools/relocate-rela.c
Signature · 1 line
1.8.1.2
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
ARM64 uses the newer RELA-style relocations rather than the older REL. RELA relocations have an addend in the relocation struct, rather than expecting the loader to read a value from the location to be updated.
While this is beneficial for ordinary program loading, it's problematic for U-Boot because the location to be updated starts out with zero, rather than a pre-relocation value. Since we need to be able to run C code before relocation, we need a tool to apply the relocations at build time.
In theory this tool is applicable to other newer architectures (mainly 64-bit), but currently the only relocations it supports are for arm64, and it assumes a 64-bit little-endian target. If the latter limitation is ever to be changed, we'll need a way to tell the tool what format the image is in. Eventually this may be replaced by a tool that uses libelf or similar and operates directly on the ELF file. I've written some code for such an approach but libelf does not make it easy to poke addresses by memory address (rather than by section), and I was hesitant to write code to manually parse the program headers and do the update outside of libelf (or to iterate over sections) -- especially since it wouldn't get test coverage on things like binaries with multiple PT_LOAD segments. This should be good enough for now to let the manual relocation stuff be removed from the arm64 patches.
--- Makefile | 12 ++++ tools/Makefile | 6 ++ tools/relocate-rela.c | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 203 insertions(+) create mode 100644 tools/relocate-rela.c
Makefile +12 -0
@@ -392,6 +392,17 @@ else BOARD_SIZE_CHECK = endif +# Statically apply RELA-style relocations (currently arm64 only) +ifneq ($(CONFIG_STATIC_RELA),) +# $(1) is u-boot ELF, $(2) is u-boot bin, $(3) is text base +DO_STATIC_RELA = \ + start=$$($(NM) $(1) | grep __rel_dyn_start | cut -f 1 -d ' '); \ + end=$$($(NM) $(1) | grep __rel_dyn_end | cut -f 1 -d ' '); \ + $(obj)tools/relocate-rela $(2) $(3) $$start $$end +else +DO_STATIC_RELA = +endif + # Always append ALL so that arch config.mk's can add custom ones ALL-y += $(obj)u-boot.srec $(obj)u-boot.bin $(obj)System.map
@@ -431,6 +442,7 @@ $(obj)u-boot.srec: $(obj)u-boot $(obj)u-boot.bin: $(obj)u-boot $(OBJCOPY) ${OBJCFLAGS} -O binary $< $@ + $(call DO_STATIC_RELA,$<,$@,$(CONFIG_SYS_TEXT_BASE)) $(BOARD_SIZE_CHECK) $(obj)u-boot.ldr: $(obj)u-boot
tools/Makefile +6 -0
@@ -59,6 +59,7 @@ BIN_FILES-$(CONFIG_NETCONSOLE) += ncb$(SFX) BIN_FILES-$(CONFIG_SHA1_CHECK_UB_IMG) += ubsha1$(SFX) BIN_FILES-$(CONFIG_KIRKWOOD) += kwboot$(SFX) BIN_FILES-y += proftool(SFX) +BIN_FILES-$(CONFIG_STATIC_RELA) += relocate-rela$(SFX) # Source files which exist outside the tools directory EXT_OBJ_FILES-$(CONFIG_BUILD_ENVCRC) += common/env_embedded.o
@@ -84,6 +85,7 @@ NOPED_OBJ_FILES-y += os_support.o NOPED_OBJ_FILES-y += pblimage.o NOPED_OBJ_FILES-y += proftool.o NOPED_OBJ_FILES-y += ublimage.o +NOPED_OBJ_FILES-y += relocate-rela.o OBJ_FILES-$(CONFIG_BUILD_ENVCRC) += envcrc.o OBJ_FILES-$(CONFIG_CMD_LOADS) += img2srec.o OBJ_FILES-$(CONFIG_CMD_NET) += gen_eth_addr.o
@@ -250,6 +252,10 @@ $(obj)kwboot$(SFX): $(obj)kwboot.o $(HOSTCC) $(HOSTCFLAGS) $(HOSTLDFLAGS) -o $@ $^ $(HOSTSTRIP) $@ +$(obj)relocate-rela$(SFX): $(obj)relocate-rela.o + $(HOSTCC) $(HOSTCFLAGS) $(HOSTLDFLAGS) -o $@ $^ + $(HOSTSTRIP) $@ + # Some of the tool objects need to be accessed from outside the tools directory $(obj)%.o: $(SRCTREE)/common/%.c $(HOSTCC) -g $(HOSTCFLAGS_NOPED) -c -o $@ $<
tools/relocate-rela.c new file +185 -0
185 lines not on this page · raw message
Signature · 1 line
1.8.1.2
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
Quoted 6 lines
ARM64 uses the newer RELA-style relocations rather than the older REL. RELA relocations have an addend in the relocation struct, rather than expecting the loader to read a value from the location to be updated.
While this is beneficial for ordinary program loading, it's problematic
How it is beneficial than rel format?
Why aarch64-gcc use rela format only instead of supporting two format? these confuse me a few months.
David,
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
Quoted 7 lines · FengHua
Quoted 5 lines
ARM64 uses the newer RELA-style relocations rather than the older REL. RELA relocations have an addend in the relocation struct, rather than expecting the loader to read a value from the location to be updated.
While this is beneficial for ordinary program loading, it's problematic
How it is beneficial than rel format?
It avoids the need to read anything other than the rela descriptor, and thus makes relocation faster.
Quoted 2 lines
Why aarch64-gcc use rela format only instead of supporting two format? these confuse me a few months.
It's probably specified by the ABI which type to use, and it's not worth adding toolchain support for something different just for weird cases like this.
-Scott
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
In reply to Scott WoodHi Scott,
Quoted 9 lines · Scott Wood
ARM64 uses the newer RELA-style relocations rather than the older REL. RELA relocations have an addend in the relocation struct, rather than expecting the loader to read a value from the location to be updated.
While this is beneficial for ordinary program loading, it's problematic for U-Boot because the location to be updated starts out with zero, rather than a pre-relocation value. Since we need to be able to run C code before relocation, we need a tool to apply the relocations at build time.
I love it when support for a feature which offers more capabilities is replaced with support for one which offers less. What's the point of a relocation system that produces a binary which will *never* work if not relocated first? What's the point of zeroing position-dependent locations instead of putting some useful value in it, like the value they would have if no relocation occurred? :/
I really don't understand why REL-style relocation is impossible. Is it an EABI specification? A toolchain limitation? A toolchain design decision (i.e., a limitation that will not be lifted)?
OTOH, I don't have an EABI doc for arm64. Could someone just copy-paster its URL to me? Thanks in advance.
Quoted 5 lines
In theory this tool is applicable to other newer architectures (mainly 64-bit), but currently the only relocations it supports are for arm64, and it assumes a 64-bit little-endian target. If the latter limitation is ever to be changed, we'll need a way to tell the tool what format the image is in. Eventually this may be replaced by a tool that uses
Quoted 8 lines
libelf or similar and operates directly on the ELF file. I've written some code for such an approach but libelf does not make it easy to poke addresses by memory address (rather than by section), and I was hesitant to write code to manually parse the program headers and do the update outside of libelf (or to iterate over sections) -- especially since it wouldn't get test coverage on things like binaries with multiple
PT_LOADsegments. This should be good enough for now to let the manual relocation stuff be removed from the arm64 patches.
Can you clarify what makes this tool beneficial as opposed to e.g. doing an objcopy from .elf to binary? After all, if we're going to relocate at build time from address A to B, why not directly build for address B, objcopy the resulting ELF and be done with it?
Amicalement,
Signature · 1 line
Albert.
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
Quoted 15 lines · Albert ARIBAUD
Hi Scott,
Quoted 9 lines · Scott Wood
ARM64 uses the newer RELA-style relocations rather than the older REL. RELA relocations have an addend in the relocation struct, rather than expecting the loader to read a value from the location to be updated.
While this is beneficial for ordinary program loading, it's problematic for U-Boot because the location to be updated starts out with zero, rather than a pre-relocation value. Since we need to be able to run C code before relocation, we need a tool to apply the relocations at build time.
Quoted 6 lines
I love it when support for a feature which offers more capabilities is replaced with support for one which offers less. What's the point of a relocation system that produces a binary which will *never* work if not relocated first? What's the point of zeroing position-dependent locations instead of putting some useful value in it, like the value they would have if no relocation occurred? :/
Yeah, it's annoying. It also seems to affect gdb printing global variables before a program has started.
Quoted 3 lines
I really don't understand why REL-style relocation is impossible. Is it an EABI specification? A toolchain limitation? A toolchain design decision (i.e., a limitation that will not be lifted)?
It looks like one of the latter two. I don't know which. I tried looking at the linker code to see if there was an option to switch, and had difficulty following it. If someone else wants to engage with the binutils people and get a REL option added, that'd be great, but I don't have the bandwidth right now, and in any case it would be a while before we could rely on such a solution.
Quoted 2 lines
OTOH, I don't have an EABI doc for arm64. Could someone just copy-paster its URL to me? Thanks in advance.
I don't know of an "E"ABI for arm64, but googling "aarch64 abi" turns up an ELF ABI document as the first result. I tried to copy and paste the URL but it's google-encoded crap, and it's PDF so I can't copy it from the browser window that opens.
That document says that both REL and RELA are acceptable.
Quoted 14 lines
Quoted 5 lines
In theory this tool is applicable to other newer architectures (mainly 64-bit), but currently the only relocations it supports are for arm64, and it assumes a 64-bit little-endian target. If the latter limitation is ever to be changed, we'll need a way to tell the tool what format the image is in. Eventually this may be replaced by a tool that uses
Quoted 8 lines
libelf or similar and operates directly on the ELF file. I've written some code for such an approach but libelf does not make it easy to poke addresses by memory address (rather than by section), and I was hesitant to write code to manually parse the program headers and do the update outside of libelf (or to iterate over sections) -- especially since it wouldn't get test coverage on things like binaries with multiple
PT_LOADsegments. This should be good enough for now to let the manual relocation stuff be removed from the arm64 patches.
Quoted 4 lines
Can you clarify what makes this tool beneficial as opposed to e.g. doing an objcopy from .elf to binary? After all, if we're going to relocate at build time from address A to B, why not directly build for address B, objcopy the resulting ELF and be done with it?
We do use objcopy, but it doesn't apply the relocations. It doesn't matter what address we build for; if the relocations aren't applied, all to-be-relocated pointers will be zero.
-Scott
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
Hi Scott,
Quoted 61 lines · Scott Wood
Quoted 15 lines · Albert ARIBAUD
Hi Scott,
Quoted 9 lines · Scott Wood
ARM64 uses the newer RELA-style relocations rather than the older REL. RELA relocations have an addend in the relocation struct, rather than expecting the loader to read a value from the location to be updated.
While this is beneficial for ordinary program loading, it's problematic for U-Boot because the location to be updated starts out with zero, rather than a pre-relocation value. Since we need to be able to run C code before relocation, we need a tool to apply the relocations at build time.
Quoted 6 lines
I love it when support for a feature which offers more capabilities is replaced with support for one which offers less. What's the point of a relocation system that produces a binary which will *never* work if not relocated first? What's the point of zeroing position-dependent locations instead of putting some useful value in it, like the value they would have if no relocation occurred? :/
Yeah, it's annoying. It also seems to affect gdb printing global variables before a program has started.
Quoted 3 lines
I really don't understand why REL-style relocation is impossible. Is it an EABI specification? A toolchain limitation? A toolchain design decision (i.e., a limitation that will not be lifted)?
It looks like one of the latter two. I don't know which. I tried looking at the linker code to see if there was an option to switch, and had difficulty following it. If someone else wants to engage with the binutils people and get a REL option added, that'd be great, but I don't have the bandwidth right now, and in any case it would be a while before we could rely on such a solution.
Quoted 2 lines
OTOH, I don't have an EABI doc for arm64. Could someone just copy-paster its URL to me? Thanks in advance.
I don't know of an "E"ABI for arm64, but googling "aarch64 abi" turns up an ELF ABI document as the first result. I tried to copy and paste the URL but it's google-encoded crap, and it's PDF so I can't copy it from the browser window that opens.
That document says that both REL and RELA are acceptable.
Quoted 14 lines
Quoted 13 lines
In theory this tool is applicable to other newer architectures (mainly 64-bit), but currently the only relocations it supports are for arm64, and it assumes a 64-bit little-endian target. If the latter limitation is ever to be changed, we'll need a way to tell the tool what format the image is in. Eventually this may be replaced by a tool that uses libelf or similar and operates directly on the ELF file. I've written some code for such an approach but libelf does not make it easy to poke addresses by memory address (rather than by section), and I was hesitant to write code to manually parse the program headers and do the update outside of libelf (or to iterate over sections) -- especially since it wouldn't get test coverage on things like binaries with multiple
PT_LOADsegments. This should be good enough for now to let the manual relocation stuff be removed from the arm64 patches.
Quoted 8 lines
Quoted 4 lines
Can you clarify what makes this tool beneficial as opposed to e.g. doing an objcopy from .elf to binary? After all, if we're going to relocate at build time from address A to B, why not directly build for address B, objcopy the resulting ELF and be done with it?
We do use objcopy, but it doesn't apply the relocations. It doesn't matter what address we build for; if the relocations aren't applied, all to-be-relocated pointers will be zero.
Thanks Scott fot the heads-up. I have found the arm64 ABI and traced it back to this URL:
<http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ihi0056b/index.html>
(Somehow the document can be read in Firefox but evince chokes on it)
I see that some relocation types are deemed mandatory (4.6.1, page 13) and the way I read it, R_AARCH64_RELATIVE should be one of them...
I'll have a stab at investigating both binutil and gcc.
Meanwhile, even if we end up being able to use R_AARCH64_RELATIVE, part of the patch series will remain useful, notably the filtering in the makefile. I would just like a note added somewhere stating that this is hopefully an interim solution until R_AARCH64_RELATIVE is available.
Quoted 1 line
-Scott
Amicalement,
Signature · 1 line
Albert.
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
Quoted 6 lines · Albert ARIBAUD
Thanks Scott fot the heads-up. I have found the arm64 ABI and traced it back to this URL:
<http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ihi0056b/index.html>
(Somehow the document can be read in Firefox but evince chokes on it)
It works for me in evince 3.6.1.
-Scott
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
Hi Scott,
Quoted 9 lines · Scott Wood
Quoted 6 lines · Albert ARIBAUD
Thanks Scott fot the heads-up. I have found the arm64 ABI and traced it back to this URL:
<http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ihi0056b/index.html>
(Somehow the document can be read in Firefox but evince chokes on it)
It works for me in evince 3.6.1.
Thanks. Mine is 3.10.0. Could be a regression.
Quoted 1 line
-Scott
Amicalement,
Signature · 1 line
Albert.
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
In reply to Scott WoodQuoted 36 lines
tools/relocate-rela.c new file +29
-0@@ -0,0 +1,185 @@ +/* +* Copyright 2013 Freescale Semiconductor, Inc. +* +* SPDX-License-Identifier: GPL-2.0+ BSD-2-Clause +* +* 64-bit and little-endian target only until we need to support a different +* arch that needs this. +*/ + +#include <elf.h> +#include <errno.h> +#include <inttypes.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +static const bool debug_en; + +static void debug (const char *fmt, ...) +{ +va_list args; + +va_start (args, fmt); +if (debug_en) +vprintf (fmt, args); +} +
tools/relocate-rela.c line 39
Quoted 10 lines
tools/relocate-rela.c new file +10
-0+static bool supported_rela (Elf64_Rela *rela) +{ +uint64_t mask =0xffffffffULL ;/* would be different on 32-bit */ +uint32_t type = rela->r_info & mask; + +switch (type) { +#ifdef R_AARCH64_RELATIVE +case R_AARCH64_RELATIVE : +return true; +#endif
hi Scott,
the R_AARCH64_RELATIVE is not deinfed in my system. Whether we should define it at somewhere?
David
PATCH 1/4 arm64: Add tool to statically apply RELA relocations
Quoted 40 lines · FengHua
Quoted 40 lines
tools/relocate-rela.c new file +34
-0@@ -0,0 +1,185 @@ +/* +* Copyright 2013 Freescale Semiconductor, Inc. +* +* SPDX-License-Identifier: GPL-2.0+ BSD-2-Clause +* +* 64-bit and little-endian target only until we need to support a different +* arch that needs this. +*/ + +#include <elf.h> +#include <errno.h> +#include <inttypes.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +static const bool debug_en; + +static void debug (const char *fmt, ...) +{ +va_list args; + +va_start (args, fmt); +if (debug_en) +vprintf (fmt, args); +} + +static bool supported_rela (Elf64_Rela *rela) +{ +uint64_t mask =0xffffffffULL ;/* would be different on 32-bit */ +uint32_t type = rela->r_info & mask; +
Quoted 8 lines
tools/relocate-rela.c line 39
Quoted 5 lines
tools/relocate-rela.c new file +5
-0+switch (type) { +#ifdef R_AARCH64_RELATIVE +case R_AARCH64_RELATIVE : +return true; +#endif hi Scott,
theR_AARCH64_RELATIVEis not deinfed in my system. Whether we should define it at somewhere?
A newer host elf.h should fix this, but if it's going to be a problem maybe we should just define it ourselves (value is 1027).
-Scott
PATCH 2/4 arm64: Turn u-boot.bin back into an ELF file after relocate-rela
In reply to Scott WoodWhile performing relocations on u-boot.bin should be good enough for booting on real hardware, some simulators insist on booting an ELF file (and yet don't perform ELF relocations), so convert the relocated binary back into an ELF file. This can go away in the future if we change relocate-rela to operate directly on the ELF file, or if and when we stop caring about a simulator with this restriction.
--- Makefile | 13 +++++++++++++ 1 file changed, 13 insertions(+)
Makefile +13 -0
@@ -415,6 +415,7 @@ ALL-$(CONFIG_OF_SEPARATE) += $(obj)u-boot.dtb $(obj)u-boot-dtb.bin ifneq ($(CONFIG_SPL_TARGET),) ALL-$(CONFIG_SPL) += $(obj)$(subst ",,$(CONFIG_SPL_TARGET)) endif +ALL-$(CONFIG_REMAKE_ELF) += $(obj)u-boot.elf # enable combined SPL/u-boot/dtb rules for tegra ifneq ($(CONFIG_TEGRA),)
@@ -581,6 +582,18 @@ $(obj)u-boot-img-spl-at-end.bin: $(obj)spl/u-boot-spl.bin $(obj)u-boot.img conv=notrunc 2>/dev/null cat $(obj)u-boot-pad.img $(obj)spl/u-boot-spl.bin > $@ +# Create a new ELF from a raw binary file. This is useful for arm64 +# where static relocation needs to be performed on the raw binary, +# but certain simulators only accept an ELF file (but don't do the +# relocation). +# FIXME refactor dts/Makefile to share target/arch detection +$(obj)u-boot.elf: $(obj)u-boot.bin + @$(OBJCOPY) -B aarch64 -I binary -O elf64-littleaarch64 \ + $< $(obj)u-boot-elf.o + @$(LD) $(obj)u-boot-elf.o -o $@ \ + --defsym=_start=$(CONFIG_SYS_TEXT_BASE) \ + -Ttext=$(CONFIG_SYS_TEXT_BASE) + ifeq ($(CONFIG_SANDBOX),y) GEN_UBOOT = \ cd $(LNDIR) && $(CC) $(SYMS) -T $(obj)u-boot.lds \
Signature · 1 line
1.8.1.2
PATCH 3/4 arm64: Non-manual relocation
In reply to Scott WoodThis turns off CONFIG_NEEDS_MANUAL_RELOC and turns on -pie.
The bss part of the linker script is changed to be more like arm32, as the previous arm64 approach was generating bad relocations (even readelf didn't like them).
relocate_64.S is made to look more like relocate.S, and then changed to support RELA style relocations rather than REL.
--- arch/arm/config.mk | 2 -- arch/arm/cpu/armv8/config.mk | 1 - arch/arm/cpu/armv8/u-boot.lds | 32 +++++++++++++++++++++++------- arch/arm/include/asm/config.h | 5 ----- arch/arm/lib/crt0_64.S | 7 ++----- arch/arm/lib/relocate_64.S | 41 ++++++++++++++++++++------------------- include/configs/vexpress_aemv8a.h | 3 +++ 7 files changed, 51 insertions(+), 40 deletions(-)
arch/arm/config.mk +0 -2
@@ -74,9 +74,7 @@ endif endif # needed for relocation -ifndef CONFIG_ARM64 LDFLAGS_u-boot += -pie -endif # # FIXME: binutils versions < 2.22 have a bug in the assembler where
arch/arm/cpu/armv8/config.mk +0 -1
@@ -13,4 +13,3 @@ PLATFORM_NO_UNALIGNED := $(PF_NO_UNALIGNED) PF_CPPFLAGS_ARMV8 := $(call cc-option, -march=armv8-a) PLATFORM_CPPFLAGS += $(PF_CPPFLAGS_ARMV8) PLATFORM_CPPFLAGS += $(PF_NO_UNALIGNED) -PLATFORM_CPPFLAGS += -fpic
arch/arm/cpu/armv8/u-boot.lds +25 -7
@@ -41,25 +41,43 @@ SECTIONS } . = ALIGN(8); - .reloc : { - __rel_got_start = .; - *(.got) - __rel_got_end = .; - } .image_copy_end : { *(.__image_copy_end) } + . = ALIGN(8); + + .rel_dyn_start : + { + *(.__rel_dyn_start) + } + + .rela.dyn : { + *(.rela*) + } + + .rel_dyn_end : + { + *(.__rel_dyn_end) + } + _end = .; . = ALIGN(8); + + .bss_start : { + KEEP(*(.__bss_start)); + } + .bss : { - __bss_start = .; *(.bss*) . = ALIGN(8); - __bss_end = .; + } + + .bss_end : { + KEEP(*(.__bss_end)); } /DISCARD/ : { *(.dynsym) }
arch/arm/include/asm/config.h +0 -5
@@ -11,11 +11,6 @@#define CONFIG_SYS_BOOT_RAMDISK_HIGH #ifdef CONFIG_ARM64 -/* -* Currently, GOT is used to relocate u-boot and -* configuration CONFIG_NEEDS_MANUAL_RELOC is needed. -*/ -#define CONFIG_NEEDS_MANUAL_RELOC #define CONFIG_PHYS_64BIT #endif
arch/arm/lib/crt0_64.S +2 -5
@@ -94,11 +94,8 @@ relocation_return: /* * Clear BSS section */ - ldr x9, [x18, #GD_RELOC_OFF] /* x9 <- gd->reloc_off */ - ldr x0, =__bss_start - add x0, x0, x9 /* x0 <- __bss_start in RAM */ - ldr x1, =__bss_end - add x1, x1, x9 /* x1 <- __bss_end in RAM */ + ldr x0, =__bss_start /* this is auto-relocated! */ + ldr x1, =__bss_end /* this is auto-relocated! */ mov x2, #0 clear_loop: str x2, [x0]
arch/arm/lib/relocate_64.S +21 -20
61 lines not on this page · raw message
include/configs/vexpress_aemv8a.h +3 -0
@@ -10,6 +10,9 @@#define DEBUG +#define CONFIG_REMAKE_ELF +#define CONFIG_STATIC_RELA +/*#define CONFIG_BOOTING_EL1*/ /*#define CONFIG_SYS_GENERIC_BOARD*/
Signature · 1 line
1.8.1.2
PATCH 3/4 arm64: Non-manual relocation
Quoted 204 lines
This turns off
CONFIG_NEEDS_MANUAL_RELOCand turns on -pie.The bss part of the linker script is changed to be more like arm32, as the previous arm64 approach was generating bad relocations (even readelf didn't like them).
relocate_64.Sis made to look more likerelocate.S, and then changed to support RELA style relocations rather than REL.Signed-off-by Scott Wood <[email protected]>--- arch/arm/config.mk | 2 -- arch/arm/cpu/armv8/config.mk | 1 - arch/arm/cpu/armv8/u-boot.lds | 32 +++++++++++++++++++++++------- arch/arm/include/asm/config.h | 5 ----- arch/arm/lib/crt0_64.S | 7 ++----- arch/arm/lib/relocate_64.S | 41 ++++++++++++++++++++------------------- include/configs/vexpress_aemv8a.h | 3 +++ 7 files changed, 51 insertions(+), 40 deletions(-)arch/arm/config.mk +0
-2@@ -74,9 +74,7 @@ endif endif # needed for relocation -ifndef CONFIG_ARM64 LDFLAGS_u-boot += -pie -endif # # FIXME: binutils versions < 2.22 have a bug in the assembler wherearch/arm/cpu/armv8/config.mk +0
-1@@ -13,4 +13,3 @@ PLATFORM_NO_UNALIGNED := $(PF_NO_UNALIGNED) PF_CPPFLAGS_ARMV8 := $(call cc-option, -march=armv8-a) PLATFORM_CPPFLAGS += $(PF_CPPFLAGS_ARMV8) PLATFORM_CPPFLAGS += $(PF_NO_UNALIGNED) -PLATFORM_CPPFLAGS += -fpicarch/arm/cpu/armv8/u-boot.lds +25
-7@@ -41,25 +41,43 @@ SECTIONS } . = ALIGN(8); - .reloc : { - __rel_got_start = .; - *(.got) - __rel_got_end = .; - } .image_copy_end : { *(.__image_copy_end) } + . = ALIGN(8); + + .rel_dyn_start : + { + *(.__rel_dyn_start) + } + + .rela.dyn : { + *(.rela*) + } + + .rel_dyn_end : + { + *(.__rel_dyn_end) + } + _end = .; . = ALIGN(8); + + .bss_start : { + KEEP(*(.__bss_start)); + } + .bss : { - __bss_start = .; *(.bss*) . = ALIGN(8); - __bss_end = .; + } + + .bss_end : { + KEEP(*(.__bss_end)); } /DISCARD/ : { *(.dynsym) }arch/arm/include/asm/config.h +0
-5@@ -11,11 +11,6 @@#define CONFIG_SYS_BOOT_RAMDISK_HIGH #ifdef CONFIG_ARM64 -/* -* Currently, GOT is used to relocate u-boot and -* configuration CONFIG_NEEDS_MANUAL_RELOC is needed. -*/ -#define CONFIG_NEEDS_MANUAL_RELOC #define CONFIG_PHYS_64BIT #endif arch/arm/lib/crt0_64.S +2
-5@@ -94,11 +94,8 @@ relocation_return: /* * Clear BSS section */ - ldr x9, [x18, #GD_RELOC_OFF] /* x9 <- gd->reloc_off */ - ldr x0, =__bss_start - add x0, x0, x9 /* x0 <- __bss_start in RAM */ - ldr x1, =__bss_end - add x1, x1, x9 /* x1 <- __bss_end in RAM */ + ldr x0, =__bss_start /* this is auto-relocated! */ + ldr x1, =__bss_end /* this is auto-relocated! */ mov x2, #0 clear_loop: str x2, [x0]arch/arm/lib/relocate_64.S +21
-20@@ -16,40 +16,41 @@ * void relocate_code (addr_moni) * * This function relocates the monitor code. - * - * NOTE: - * GOT is used and configuration CONFIG_NEEDS_MANUAL_RELOC is needed. + * x0 holds the destination address. */ ENTRY(relocate_code) /* * Copy u-boot from flash to RAM */ - ldr x1, =__image_copy_start /* x1 <- copy source */ - cmp x1, x0 + ldr x1, =__image_copy_start /* x1 <- SRC &__image_copy_start */ + subs x9, x0, x1 /* x9 <- relocation offset */ b.eq relocate_done /* skip relocation */ - mov x2, x0 /* x2 <- copy destination */ - ldr x3, =__image_copy_end /* x3 <- source end address */ + ldr x2, =__image_copy_end /* x2 <- SRC &__image_copy_end */ copy_loop: ldp x10, x11, [x1], #16 /* copy from source address [x1] */ - stp x10, x11, [x2], #16 /* copy to target address [x2] */ - cmp x1, x3 /* until source end address [x3] */ + stp x10, x11, [x0], #16 /* copy to target address [x0] */ + cmp x1, x2 /* until source end address [x2] */ b.lo copy_loop /* - * Fix .reloc relocations + * Fix .rela.dyn relocations */ - ldr x9, [x18, #GD_RELOC_OFF]/* x9 <- relocation offset */ - ldr x1, =__rel_got_start /* x1 <- rel got start ofs */ - add x1, x1, x9 /* x1 <- rel got start in RAM */ - ldr x2, =__rel_got_end /* x2 <- rel got end ofs */ - add x2, x2, x9 /* x2 <- rel got end in RAM */ + ldr x2, =__rel_dyn_start /* x2 <- SRC &__rel_dyn_start */ + ldr x3, =__rel_dyn_end /* x3 <- SRC &__rel_dyn_end */ fixloop: - ldr x10, [x1] - add x10, x10, x9 /* x10 <- address to be fixed up */ - str x10, [x1] - add x1, x1, #8 /* each got entry is 8 bytes */ - cmp x1, x2 + ldp x0, x1, [x2], #16 /* (x0,x1) <- (SRC location, fixup) */ + ldr x4, [x2], #8 /* x4 <- addend */ + and x1, x1, #0xffffffff + cmp x1, #1027 /* relative fixup? */ + bne fixnext + + /* relative fix: store addend plus offset at dest location */ + add x0, x0, x9 + add x4, x4, x9 + str x4, [x0] +fixnext: + cmp x2, x3 b.lo fixloop relocate_done:include/configs/vexpress_aemv8a.h +0
-0
include/configs/vexpress_aemv8a.h line 15
Quoted 6 lines
include/configs/vexpress_aemv8a.h +3
-0@@ -10,6 +10,9 @@#define DEBUG +#define CONFIG_REMAKE_ELF +#define CONFIG_STATIC_RELA +
CONFIG_STATIC_RELA is always needed, How about remove this macro.
David,
PATCH 3/4 arm64: Non-manual relocation
Quoted 6 lines · FengHua
Quoted 6 lines
include/configs/vexpress_aemv8a.h +0
-0@@ -10,6 +10,9 @@
Quoted 6 lines
include/configs/vexpress_aemv8a.h line 15
Quoted 5 lines
include/configs/vexpress_aemv8a.h +3
-0#define DEBUG +#define CONFIG_REMAKE_ELF +#define CONFIG_STATIC_RELA +
CONFIG_STATIC_RELAis always needed, How about remove this macro.
It's always needed for arm64, but not for all architectures. I don't want to just use CONFIG_ARM64 because in theory another arch could be added that needs it. Eventually this should be moved out of the board config and into a file that defines general arm64 stuff.
-Scott
PATCH 4/4 arm64: Make checkarmreloc accept arm64 relocations
In reply to Scott Wood--- Makefile | 14 +++++++++----- arch/arm/config.mk | 2 -- 2 files changed, 9 insertions(+), 7 deletions(-)
Makefile +9 -5
@@ -805,12 +805,16 @@ tools: $(VERSION_FILE) $(TIMESTAMP_FILE) $(MAKE) -C $@ all endif # config.mk -# ARM relocations should all be R_ARM_RELATIVE. +# ARM relocations should all be R_ARM_RELATIVE (32-bit) or +# R_AARCH64_RELATIVE (64-bit). checkarmreloc: $(obj)u-boot - @if test "R_ARM_RELATIVE" != \ - "`$(CROSS_COMPILE)readelf -r $< | cut -d ' ' -f 4 | grep R_ARM | sort -u`"; \ - then echo "$< contains relocations other than \ - R_ARM_RELATIVE"; false; fi + @RELOC="`$(CROSS_COMPILE)readelf -r -W $< | cut -d ' ' -f 4 | \ + grep R_A | sort -u`"; \ + if test "$$RELOC" != "R_ARM_RELATIVE" -a \ + "$$RELOC" != "R_AARCH64_RELATIVE"; then \ + echo "$< contains unexpected relocations: $$RELOC"; \ + false; \ + fi $(VERSION_FILE): @mkdir -p $(dir $(VERSION_FILE))
arch/arm/config.mk +0 -2
@@ -95,8 +95,6 @@ endif endif # check that only R_ARM_RELATIVE relocations are generated -ifndef CONFIG_ARM64 ifneq ($(CONFIG_SPL_BUILD),y) ALL-y += checkarmreloc endif -endif
Signature · 1 line
1.8.1.2
cover arm64: rela relocation
In reply to Scott WoodQuoted 25 lines
arm64: rela relocation
This lets us remove the manual relocation stuff from the arm64 patchset (the symbol itself is removed by this patchset, but not all the new manual relocations added by the arm64 patchset).
I'm not terribly happy with the way relocate-rela is now, versus something cleaner that operates on the ELF file, but it's good enough for now and waiting longer to get rid of the manual relocations would be worse.
This patchset is based on David's arm64 patchset v13. David, the first two patches should be applied before your arm64 patches. Maybe the fourth as well (except for the removal of the arm64 ifdef you added, which would then need to be squashed with your patch). The third patch should be squashed with your patches (plus you should remove the manual relocs).
Scott Wood (4):
arm64: Add tool to statically apply RELA relocations
arm64: Turn u-boot.bin back into an ELF file after relocate-rela
arm64: Non-manual relocation
arm64: Make checkarmreloc accept arm64 relocations
Quoted 13 lines
Makefile | 39 ++++++-- arch/arm/config.mk | 4 - arch/arm/cpu/armv8/config.mk | 1 - arch/arm/cpu/armv8/u-boot.lds | 32 +++++-- arch/arm/include/asm/config.h | 5 -- arch/arm/lib/crt0_64.S | 7 +- arch/arm/lib/relocate_64.S | 41 ++++----- include/configs/vexpress_aemv8a.h | 3 + tools/Makefile | 6 ++ tools/relocate-rela.c | 185 ++++++++++++++++++++++++++++++++++++++ 10 files changed, 276 insertions(+), 47 deletions(-) create mode 100644 tools/relocate-rela.c
Great, some fixups related with relocation could be removed. I will modify arm64 patchset according this.
David
cover arm64: rela relocation
Hi FengHua,
Quoted 38 lines · FengHua
Quoted 25 lines
arm64: rela relocation
This lets us remove the manual relocation stuff from the arm64 patchset (the symbol itself is removed by this patchset, but not all the new manual relocations added by the arm64 patchset).
I'm not terribly happy with the way relocate-rela is now, versus something cleaner that operates on the ELF file, but it's good enough for now and waiting longer to get rid of the manual relocations would be worse.
This patchset is based on David's arm64 patchset v13. David, the first two patches should be applied before your arm64 patches. Maybe the fourth as well (except for the removal of the arm64 ifdef you added, which would then need to be squashed with your patch). The third patch should be squashed with your patches (plus you should remove the manual relocs).
Scott Wood (4):
arm64: Add tool to statically apply RELA relocations
arm64: Turn u-boot.bin back into an ELF file after relocate-rela
arm64: Non-manual relocation
arm64: Make checkarmreloc accept arm64 relocationsQuoted 13 lines
Makefile | 39 ++++++-- arch/arm/config.mk | 4 - arch/arm/cpu/armv8/config.mk | 1 - arch/arm/cpu/armv8/u-boot.lds | 32 +++++-- arch/arm/include/asm/config.h | 5 -- arch/arm/lib/crt0_64.S | 7 +- arch/arm/lib/relocate_64.S | 41 ++++----- include/configs/vexpress_aemv8a.h | 3 + tools/Makefile | 6 ++ tools/relocate-rela.c | 185 ++++++++++++++++++++++++++++++++++++++ 10 files changed, 276 insertions(+), 47 deletions(-) create mode 100644 tools/relocate-rela.c
Quoted 2 lines
Great, some fixups related with relocation could be removed. I will modify arm64 patchset according this.
Stop me if I'm missing something, but doesn't Scott's patch series need yours? And if you remove the manual relocas in yours, doesn't that make your series unable to function properly until Scott's series is applied too?
If I am not mistaken, then maybe Scott's and your patches should be merged in a single series, with adequate attribution of course.
Quoted 1 line
David
Amicalement,
Signature · 1 line
Albert.
cover arm64: rela relocation
Quoted 46 lines · Albert ARIBAUD
Hi FengHua,
Quoted 38 lines · FengHua
Quoted 25 lines
arm64: rela relocation
This lets us remove the manual relocation stuff from the arm64 patchset (the symbol itself is removed by this patchset, but not all the new manual relocations added by the arm64 patchset).
I'm not terribly happy with the way relocate-rela is now, versus something cleaner that operates on the ELF file, but it's good enough for now and waiting longer to get rid of the manual relocations would be worse.
This patchset is based on David's arm64 patchset v13. David, the first two patches should be applied before your arm64 patches. Maybe the fourth as well (except for the removal of the arm64 ifdef you added, which would then need to be squashed with your patch). The third patch should be squashed with your patches (plus you should remove the manual relocs).
Scott Wood (4):
arm64: Add tool to statically apply RELA relocations
arm64: Turn u-boot.bin back into an ELF file after relocate-rela
arm64: Non-manual relocation
arm64: Make checkarmreloc accept arm64 relocationsQuoted 13 lines
Makefile | 39 ++++++-- arch/arm/config.mk | 4 - arch/arm/cpu/armv8/config.mk | 1 - arch/arm/cpu/armv8/u-boot.lds | 32 +++++-- arch/arm/include/asm/config.h | 5 -- arch/arm/lib/crt0_64.S | 7 +- arch/arm/lib/relocate_64.S | 41 ++++----- include/configs/vexpress_aemv8a.h | 3 + tools/Makefile | 6 ++ tools/relocate-rela.c | 185 ++++++++++++++++++++++++++++++++++++++ 10 files changed, 276 insertions(+), 47 deletions(-) create mode 100644 tools/relocate-rela.cQuoted 2 lines
Great, some fixups related with relocation could be removed. I will modify arm64 patchset according this.
Quoted 7 lines
Stop me if I'm missing something, but doesn't Scott's patch series need yours? And if you remove the manual relocas in yours, doesn't that make your series unable to function properly until Scott's series is applied too?
If I am not mistaken, then maybe Scott's and your patches should be merged in a single series, with adequate attribution of course.
What you're missing is the note above where I suggest merging the two patchsets. :-)
-Scott
cover arm64: rela relocation
In reply to Albert ARIBAUDQuoted 52 lines
Hi FengHua,
Quoted 38 lines · FengHua
Quoted 25 lines
arm64: rela relocation
This lets us remove the manual relocation stuff from the arm64 patchset (the symbol itself is removed by this patchset, but not all the new manual relocations added by the arm64 patchset).
I'm not terribly happy with the way relocate-rela is now, versus something cleaner that operates on the ELF file, but it's good enough for now and waiting longer to get rid of the manual relocations would be worse.
This patchset is based on David's arm64 patchset v13. David, the first two patches should be applied before your arm64 patches. Maybe the fourth as well (except for the removal of the arm64 ifdef you added, which would then need to be squashed with your patch). The third patch should be squashed with your patches (plus you should remove the manual relocs).
Scott Wood (4):
arm64: Add tool to statically apply RELA relocations
arm64: Turn u-boot.bin back into an ELF file after relocate-rela
arm64: Non-manual relocation
arm64: Make checkarmreloc accept arm64 relocationsQuoted 13 lines
Makefile | 39 ++++++-- arch/arm/config.mk | 4 - arch/arm/cpu/armv8/config.mk | 1 - arch/arm/cpu/armv8/u-boot.lds | 32 +++++-- arch/arm/include/asm/config.h | 5 -- arch/arm/lib/crt0_64.S | 7 +- arch/arm/lib/relocate_64.S | 41 ++++----- include/configs/vexpress_aemv8a.h | 3 + tools/Makefile | 6 ++ tools/relocate-rela.c | 185 ++++++++++++++++++++++++++++++++++++++ 10 files changed, 276 insertions(+), 47 deletions(-) create mode 100644 tools/relocate-rela.cQuoted 2 lines
Great, some fixups related with relocation could be removed. I will modify arm64 patchset according this.
Stop me if I'm missing something, but doesn't Scott's patch series need yours? And if you remove the manual relocas in yours, doesn't that make your series unable to function properly until Scott's series is applied too?
Quoted 8 lines
If I am not mistaken, then maybe Scott's and your patches should be merged in a single series, with adequate attribution of course.
Quoted 1 line
David
Amicalement,
Signature · 1 line
Albert.
Yes, these two patches should work together.
We'd better merge them to one patchset.
The point is we should make choice between CONFIG_NEED_MANUAL_RELOC and relocation-rela tool before aarch64-gcc support rel relocation format or maybe aarch64-gcc will never do it. Another motivation to update arm64 patch is that it's too old and got wrong when applied to current u-boot master.
Best Regards.
David.
cover arm64: rela relocation
Hi FengHua,
Quoted 55 lines · FengHua
Quoted 55 lines
Hi FengHua,
Quoted 38 lines · FengHua
Quoted 25 lines
arm64: rela relocation
This lets us remove the manual relocation stuff from the arm64 patchset (the symbol itself is removed by this patchset, but not all the new manual relocations added by the arm64 patchset).
I'm not terribly happy with the way relocate-rela is now, versus something cleaner that operates on the ELF file, but it's good enough for now and waiting longer to get rid of the manual relocations would be worse.
This patchset is based on David's arm64 patchset v13. David, the first two patches should be applied before your arm64 patches. Maybe the fourth as well (except for the removal of the arm64 ifdef you added, which would then need to be squashed with your patch). The third patch should be squashed with your patches (plus you should remove the manual relocs).
Scott Wood (4):
arm64: Add tool to statically apply RELA relocations
arm64: Turn u-boot.bin back into an ELF file after relocate-rela
arm64: Non-manual relocation
arm64: Make checkarmreloc accept arm64 relocationsQuoted 13 lines
Makefile | 39 ++++++-- arch/arm/config.mk | 4 - arch/arm/cpu/armv8/config.mk | 1 - arch/arm/cpu/armv8/u-boot.lds | 32 +++++-- arch/arm/include/asm/config.h | 5 -- arch/arm/lib/crt0_64.S | 7 +- arch/arm/lib/relocate_64.S | 41 ++++----- include/configs/vexpress_aemv8a.h | 3 + tools/Makefile | 6 ++ tools/relocate-rela.c | 185 ++++++++++++++++++++++++++++++++++++++ 10 files changed, 276 insertions(+), 47 deletions(-) create mode 100644 tools/relocate-rela.cQuoted 2 lines
Great, some fixups related with relocation could be removed. I will modify arm64 patchset according this.
Stop me if I'm missing something, but doesn't Scott's patch series need yours? And if you remove the manual relocas in yours, doesn't that make your series unable to function properly until Scott's series is applied too?
If I am not mistaken, then maybe Scott's and your patches should be merged in a single series, with adequate attribution of course.
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
David
Amicalement,
Signature · 1 line
Albert.Yes, these two patches should work together.
Yep, Scott pointed me to where my eyes would not look. Must have been a SEP field. :)
Quoted 6 lines
We'd better merge them to one patchset.
The point is we should make choice betweenCONFIG_NEED_MANUAL_RELOCand relocation-rela tool before aarch64-gcc support rel relocation format or maybe aarch64-gcc will never do it. Another motivation to update arm64 patch is that it's too old and got wrong when applied to current u-boot master.
I am in favor of going for relocation-rela, if only because manual relocations are a major pain in the long run, so I want relocation handling to be automated.
Quoted 3 lines
Best Regards.
David.
Amicalement,
Signature · 1 line
Albert.