如何在 IAR linker 脚本中定义总图像大小或其结束地址的符号？

Question

I'd like to define a symbol in IAR C program to get the total size (or the end address) of the image, in the build time , so that this size or offset will be contained in the image after linking.

(I know that this can be done in a post-build action. Also, I know how to do this with the gnu linker)

The IAR documentation on expressions in the link scripts says about functions 'size' and 'end'. The problem is that I don't know the section or segment names.

From the map file, the linker creates sections named P1, P2, A1, and so on. The read-only code + data + init data section is likely what I want, it is named "P1".

Snippet from the map file:

*******************************************************************************
*** PLACEMENT SUMMARY
***

"A0":  place at address 0x800'8000 { ro section .intvec };
"P1":  place in [from 0x800'8000 to 0x807'ffff] { ro };
.......... etc.......

I tried: define exported symbol MY_SIZE = size("P1"); or define exported symbol MY_SIZE = size(P1); but get error message "Error[Lc007]: expected an identifier". "Error[Lc010]: "P1" is not a region name".

What is the correct argument for size and end functions? Or any other way to do this?

Answer 1

Yes. The current IAR linker comes with the start() , end() and size() functionalities. However, as for now, those only apply to regions.

define exported symbol _start_address = start(ROM_region);
define exported symbol _end_address = end(ROM_region);

However, in the linker configuration, regions are bound to literals. So, here the "_start_address" will refer to the initial address of the ROM_region and "_end_address" will be the ending address, which is independent from the program size.

An alternative approach for getting where the user program itself starts/ends can be to place 2 rooted dummy sections as wrappers around the sections actually being placed in the ROM_region:

define root section _start_section with alignment = 4 { public _ss: udata32 0xA5A5A5A5; };
define root section _end_section with alignment = 4 { public _es: udata32 0xBABABABA; };

"ROM": place in ROM_region { first section _start_section,
                             ro,
                             last section _end_section };  

From the C program (/debugger) these addresses can be accessed directly via "extern":

#include <stdio.h>
void main() {
  extern const void * _ss;
  extern const void * _es;
  printf("Initial 32-bit address: 0x%08x\n", &_ss);
  printf("Final 32-bit address: 0x%08x\n", &_es);
}
/* Output example (Terminal I/O) */
// Initial 32-bit address: 0x08000000
// Final 32-bit address: 0x08000B68

If your program's "ROM_region" has complex partitioning, the same concept would still be potentially usable as far as the "start section" and "end section" are placed in a fixed order block which lumps all the sections/blocks other than "ro":

define block RO_BLOCK with fixed order, end alignment = 4 {
                                         section _start_section,
                                         ro,
                                         /* sections/blocks other than "ro" */
                                         section _end_section };
                                         
"ROM": place in ROM_region { block RO_BLOCK };                                  

Either way, the addresses are defined within the ELF at linking time, without the need for an external utility to patch it during a post-build step.