Can't calculate end address of the section at linker script - c

Question

I need to make firmware image with 8K size. Firmware image should have a version word at the end. Area between data section and version section must be filled with 0xFF.
This linker script works fine if test and data sections not too big.
MEMORY
{
PM_RAM (rwx): ORIGIN = 0x00000000, LENGTH = 20K
DM_RAM (rwx) : ORIGIN = 0x0001E000, LENGTH = 6K
PM_ROM (rx) : ORIGIN = 0x00080000, LENGTH = 256K
PM_OTP (rx): ORIGIN = 0x000C0000, LENGTH = 8K - VERSION_SIZE
PM_OTP_VER (rx): ORIGIN = 0x000C0000 + 8K - VERSION_SIZE, LENGTH = VERSION_SIZE
}
SECTIONS {
.text :
{
*(.text*)
. = ALIGN(4);
} >PM_OTP
_etext = .;
.data : {
_sdata = .;
_ldata = LOADADDR(.data);
*(.data .data.*)
*(.sdata .sdata.*)
. = ALIGN(4);
} >DM_RAM AT>PM_OTP
. = ALIGN(4);
_edata = .;
.fill : {
BYTE(0xFF)
FILL(0xFF)
. = LENGTH(PM_OTP) - SIZEOF(.text) - SIZEOF(.data) - 1;
} > PM_OTP = 0xFF
.version : {
. = ALIGN(4);
__version_start__ = .;
KEEP(*(.version .version*))
__version_end__ = .;
} > PM_OTP_VER
.bss : {
_sbss = .;
*(.bss .bss.*)
. = ALIGN(4);
*(.sbss .sbss.*)
. = ALIGN(4);
} >DM_RAM
. = ALIGN(4);
_ebss = .;
_end = .;
.stack ORIGIN(DM_RAM) + LENGTH(DM_RAM) - STACK_SIZE : {
PROVIDE(__STACK_START__ = .);
. += STACK_SIZE;
PROVIDE(__C_STACK_TOP__ = .);
} >DM_RAM
}
But if text + data close to 8K I get the error:
cannot move location counter backwards (from 00000000000c2095 to 00000000000c1ffb)
If change this string:
. = LENGTH(PM_OTP) - SIZEOF(.text) - SIZEOF(.data) - 1;
by hardcoded value like:
. = 0x3f;
Build completes successfully and all OK.
What is wrong with LENGTH(PM_OTP) - SIZEOF(.text) - SIZEOF(.data) calculations?
In listing file it corresponds to 0x3f.
UPDATE
I have linker script
STACK_SIZE = 1024;
TEST_MEMORY_SIZE = 4;
VERSION_SIZE = 4;
MEMORY
{
PM_RAM (rwx): ORIGIN = 0xFD000000, LENGTH = 120K
DM_RAM (rwx) : ORIGIN = 0xFD01E000, LENGTH = 6K
PM_ROM (rx) : ORIGIN = 0xFD080000, LENGTH = 256K
PM_OTP (rx): ORIGIN = 0xFD0C0000, LENGTH = 8K - VERSION_SIZE
PM_OTP_VER (rx): ORIGIN = 0xFD0C0000 + 8K - VERSION_SIZE, LENGTH = VERSION_SIZE
}
SECTIONS {
.init ORIGIN(PM_OTP):
{
. = 0x000;
*(.init.startup)
. = ALIGN(4);
*(.init.traphandler)
. = ALIGN(4);
} >PM_OTP
.text :
{
*(.text*)
. = ALIGN(4);
*(.text.emulate*)
. = ALIGN(4);
*(.rodata .rodata.*)
. = ALIGN(4);
} >PM_OTP
_etext = .;
.data : {
_sdata = .;
_ldata = LOADADDR(.data);
*(.data .data.*)
*(.sdata .sdata.*)
. = ALIGN(4);
} >DM_RAM AT>PM_OTP
. = ALIGN(4);
_edata = .;
.fill :
{
BYTE(0xFF)
FILL(0xFF)
} > PM_OTP = 0xFF
.version :
{
. = ALIGN(4);
__version_start__ = .;
KEEP(*(.version .version*))
__version_end__ = .;
} > PM_OTP_VER
.bss : {
_sbss = .;
*(.bss .bss.*)
. = ALIGN(4);
*(.sbss .sbss.*)
. = ALIGN(4);
} >DM_RAM
. = ALIGN(4);
_ebss = .;
_end = .;
.stack ORIGIN(DM_RAM) + LENGTH(DM_RAM) - STACK_SIZE : {
PROVIDE(__STACK_START__ = .);
. += STACK_SIZE;
PROVIDE(__C_STACK_TOP__ = .);
} >DM_RAM
_test_memory = ORIGIN(DM_RAM) + LENGTH(DM_RAM);
_loader_descr = _test_memory + TEST_MEMORY_SIZE;
}
Build terminates successfully and I get:
text data bss dec hex
7700 321 1056 9077 2375
Binary look:
00001f10 94 05 0c fd 98 05 0c fd 9c 05 0c fd a0 05 0c fd |................|
00001f20 a4 05 0c fd a8 05 0c fd 00 00 00 00 00 00 00 00 |................|
00001f30 00 00 00 00 ac 05 0c fd 00 00 00 00 00 00 00 00 |................|
00001f40 00 00 00 00 00 00 00 00 00 00 00 00 01 01 00 00 |................|
00001f50 ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
00001f60 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
*
00001ff0 00 00 00 00 00 00 00 00 00 00 00 00 60 b8 ee 61 |............`..a|
00002000
There are zeros here from 00001f60 to the end. But I need 0xFF.
I added line:
. = LENGTH(PM_OTP) - SIZEOF(.init) - SIZEOF(.text) - SIZEOF(.data);`
In setion .fill after FILL(0xFF) and got error:
cannot move location counter backwards (from 00000000fd0c2025 to 00000000fd0c1ffc)
Very strange. But ok. I gradually reduce my code volume. And at a certain code decrease, the build begins to be successful.
text data bss dec hex
7656 536 1056 9248 2420
Binary look:
00001ef0 a0 05 0c fd a4 05 0c fd a8 05 0c fd 00 00 00 00 |................|
00001f00 00 00 00 00 00 00 00 00 ac 05 0c fd 00 00 00 00 |................|
00001f10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
00001f20 01 01 00 00 ff ff ff ff ff ff ff ff ff ff ff ff |................|
00001f30 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
*
00001ff0 ff ff ff ff ff ff ff ff ff ff ff ff 50 bb ee 61 |............P..a|
00002000
There is a lot of 0xFF in the end. And offset is correctly calculated, because 0xFF goes up to version. But other side 0xFF is empty area that could be filled with useful code.

Answer 1

0x00000000000c2095 is apparently beyond PM_OTP (rx): ORIGIN = 0x000C0000, LENGTH = 8K - VERSION_SIZE. Your firmware is too large.