From 5b86121af2c83d4f5a4d1f0e9b9d5789855b5a68 Mon Sep 17 00:00:00 2001 From: Matthijs Kooijman Date: Wed, 4 Mar 2020 17:07:14 +0100 Subject: [PATCH] Support a .noinit section for variables This is inspired by the linker sripts on the AVR architecture, which support a .noinit section (or any section starting with .noinit, actually) for variables that should be allocated an address in RAM, but not be initialized to any particular value (not even zero) on startup. These can then be used to remember values across resets. From the sketch perspective, this works exactly the same as on AVR: Just annote a global variable with `__attribute__((__section__(".noinit")))` and it will have an unpredictable value on power-up and retain its value during resets. To implement this without having to change all board-specific linker scripts, the linker commandline is changed to pass the board-specific linker script to the `--default-script` linker script, and change the main linker script (passed to `--script`, previously `-T`) to a generic "override" linker script. This new generic linker script contains an `INSERT BEFORE` command, which causes the linker to load it *in addition to* the default linker script, while adding an extra `.noinit` output section in the right place. Because these new variables take up RAM but have their own section in the .elf file, they should be accounted for in the size summary after compilation. This is done by adapting the `recipe.size.regex.data` entry to include this new section. --- platform.txt | 4 ++-- system/ldscript.ld | 44 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+), 2 deletions(-) create mode 100644 system/ldscript.ld diff --git a/platform.txt b/platform.txt index f9109293f1..25dc8544dd 100644 --- a/platform.txt +++ b/platform.txt @@ -128,7 +128,7 @@ recipe.S.o.pattern="{compiler.path}{compiler.S.cmd}" {compiler.S.flags} {build.i recipe.ar.pattern="{compiler.path}{compiler.ar.cmd}" {compiler.ar.flags} {compiler.ar.extra_flags} "{archive_file_path}" "{object_file}" ## Combine gc-sections, archives, and objects -recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" {compiler.c.elf.flags} "-T{build.variant.path}/{build.ldscript}" "-Wl,-Map,{build.path}/{build.project_name}.map" {compiler.c.elf.extra_flags} {compiler.ldflags} {compiler.arm.cmsis.ldflags} -o "{build.path}/{build.project_name}.elf" "-L{build.path}" -Wl,--start-group {object_files} {compiler.libraries.ldflags} "{archive_file_path}" -lc -Wl,--end-group -lm -lgcc -lstdc++ +recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" {compiler.c.elf.flags} "-Wl,--default-script={build.variant.path}/{build.ldscript}" "-Wl,--script={build.system.path}/ldscript.ld" "-Wl,-Map,{build.path}/{build.project_name}.map" {compiler.c.elf.extra_flags} {compiler.ldflags} {compiler.arm.cmsis.ldflags} -o "{build.path}/{build.project_name}.elf" "-L{build.path}" -Wl,--start-group {object_files} {compiler.libraries.ldflags} "{archive_file_path}" -lc -Wl,--end-group -lm -lgcc -lstdc++ ## Create output (.bin file) recipe.objcopy.bin.pattern="{compiler.path}{compiler.objcopy.cmd}" {compiler.elf2bin.flags} {compiler.elf2bin.extra_flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.bin" @@ -147,7 +147,7 @@ recipe.output.save_file={build.project_name}.{build.variant}.hex ## Compute size recipe.size.pattern="{compiler.path}{compiler.size.cmd}" -A "{build.path}/{build.project_name}.elf" recipe.size.regex=^(?:\.text|\.data|\.rodata)\s+([0-9]+).* -recipe.size.regex.data=^(?:\.data|\.bss)\s+([0-9]+).* +recipe.size.regex.data=^(?:\.data|\.bss|\.noinit)\s+([0-9]+).* recipe.size.regex.eeprom=^(?:\.eeprom)\s+([0-9]+).* diff --git a/system/ldscript.ld b/system/ldscript.ld new file mode 100644 index 0000000000..d356b50cbc --- /dev/null +++ b/system/ldscript.ld @@ -0,0 +1,44 @@ +/* + * This script extends the default linker script to add a .noinit + * section. This section is just mapped to RAM, but it is emitted + * separately from the .data and .bss sections (both of which are + * initialized by startup code), so any variables in this section are + * untouched on startup (so they survive across resets). + * + * This script is intended to supplied to the linker's -T / --script + * option as the primary linker script. When the linker sees an INSERT + * command, this will cause it to *also* read the default linker script + * (after reading this script) and then executing the INSERT commands + * after both scripts have been read. + * + * Note that parsing of linker scripts is a bit peculiar, e.g. INSERT + * does not textually inserts, it inserts any generated output sections. + * Also, because this script is read *first*, we cannot refer to things + * in the default script. In particular, it would make sense to add > + * RAM to the output section below to ensure that the section is mapped + * into RAM, but the RAM region is not defined yet (I think it would + * work though, but produces warnings). Instead, we just rely on the + * defaults used by the linker: If no region is defined for an output + * section, it will just map to first address after the previous section + * (.bss in this case, which is fine). + */ +SECTIONS +{ + /* Define a noinit output section and mark it as NOLOAD to prevent + * putting its contents into the resulting .bin file (which is the + * default). */ + .noinit (NOLOAD) : + { + /* Ensure output is aligned */ + . = ALIGN(4); + /* Define a global _snoinit (and _enoinit below) symbol just in case + * code wants to iterate over all noinit variables for some reason */ + _snoinit = .; + /* Actually import the .noinit and .noinit* import sections */ + *(.noinit) + *(.noinit*) + . = ALIGN(4); + _enoinit = .; + } +} +INSERT AFTER .bss;