Understand the GNU linker script of cortex M4

12/341/2018 | 01:30 AM

Introduction:

The goal of this article is to provide a brief introduction about the GNU linker script of EFM32 Arm Cortex M4 devices. With this article, you should able to understand how the GNU linker creates the executable file from the object files.

We will take the GNU linker script of EFM32GG11 efm32gg11b.ld provided by the SDK as example, you can get the linker file in the folder below after installing the gecko SDK.

.\sdks\gecko_sdk_suite\v2.x\platform\Device\SiliconLabs\EFM32GG11B\Source\GCC

Overview of the Linker Script

The Linker script consist of few parts below.

Memory layout
Entry point definition
Section definitions

Memory layout

The linker's default configuration permits allocation of all available memory, include the flash and embedded SRAM. If user need to specify the memory region that will be used by the linker and avoid using some memory region in their project, they can override the default configuration by using the MEMORY command.

The MEMORY command describes the location and size of memory blocks in the target. And for each linker script, it can only has at most one use of the MEMROY command, however, user can define as may memory regions within it.

The syntax of MEMORY command is below.

MEMORY
  {
    name (attr) : ORIGIN = origin, LENGTH = len
    ...
  }

name: defines the name of the regions that referred by the GNU linker.

attr: defines the attributes of a particular memory region. What the valid attribute should be made up of the options below (e.g. rwx).

ORIGIN: specify the start address of the memory region in the physical memory.

LENGTH: specify the size of the memory region in bytes.

For example, the default GNU linker script of EFM32GG11B820F2048GL192 efm32gg11b.ld defined two memory regions by using the MEMROY command. The first region named as FLASH start at physical address 0x0 with 2048kB size. And the second region named as RAM start as physical address 0x20000000 with 512kB size. The memory regions defined here corresponding to the whole Flash and RAM memory of the specified part number, read “Section definitions” in this article for how to use the memory regions.

MEMORY
{
	FLASH (rx) : ORIGIN = 0x0, LENGTH = 0x200000 /* 2048k */
	RAM (rwx) : ORIGIN = 0x20000000, LENGTH = 0x80000 /* 512k */
}

We do have some other KBAs discuss how to create memory regions by using the MEMORY command, and then locate functions or entire file at the specific memory regions. Please refer to link below to get more information.

https://www.silabs.com/community/mcu/32-bit/knowledge-base.entry.html/2018/06/27/how_to_locate_anent-Uyrh

https://www.silabs.com/community/mcu/32-bit/knowledge-base.entry.html/2016/03/07/using_a_linker_scrip-s5bu

Entry point definition

The ENTRY command is used for defining the first executable instruction. The syntax of ENTRY command is:

ENTRY(symbol)

What the argument of the command is a symbol name.

For example, the default GNU linker script of EFM32GG11 efm32gg11b.ld defined the first executable instruction of the target is the ‘Reset_Handler’.

ENTRY(Reset_Handler)

The symbol ‘Reset_Handler’ must be defined in code. Refer to the KBA here for more information about the definition of the ‘Reset_Handler’.

Section definitions

The SECTIONS command controls how to map the input sections into output sections, and also the order of the output sections in memory. It can only has at most one SECTIONS command in a linker script file, however, many statements can be included within the SECTIONS command.

The most frequently used statement in the SECTIONS command is the section definition, which specifies the properties of an output section: its location, alignment, contents, fill pattern, and target memory region.

The full syntax of a SECTIONS command is:

SECTIONS {
...
secname start BLOCK(align) (NOLOAD) : AT ( ldadr )
  { contents } >region :phdr =fill
...
}

secname: The name of the output section.

start: Specify the address that the output section will be loaded at.

BLOCK(align): Advance the location counter . prior to the beginning of the section, so the section will begin at the specified alignment.

(NOLOAD): Mark a section to not be loaded at run time.

AT ( ldadr ): Specify the load address of the section to 'ldadr'. If don't use the AT keyword, the default load address of the section is same as the relocation address.

>region: Assign this section to a defined region of memory.

The ‘secname’ and ‘contents’ are required for a section definition, others are optional.

Take the .text section definition in the default linker file as an example to illustrate how to define a section.

  .text :
  {
    KEEP(*(.vectors))
    __Vectors_End = .;
    __Vectors_Size = __Vectors_End - __Vectors;
    __end__ = .;

    *(.text*)

    KEEP(*(.init))
    KEEP(*(.fini))

    /* .ctors */
    *crtbegin.o(.ctors)
    *crtbegin?.o(.ctors)
    *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
    *(SORT(.ctors.*))
    *(.ctors)

    /* .dtors */
    *crtbegin.o(.dtors)
    *crtbegin?.o(.dtors)
    *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
    *(SORT(.dtors.*))
    *(.dtors)

    *(.rodata*)

    KEEP(*(.eh_frame*))
  } > FLASH

.text is the name of the section, and the KEEP((*(.vectors)) is used for marking the ‘.vectors’ input section not be eliminated, the similar method also applied to ‘.init’ ‘.fini’ and the ‘.eh_frame’ input sections. The special linker variable dot ‘.’ always contains the current output location counter, so it can get the end address of the vectors by using the dot ‘.’ variable following the KEEP((*(.vectors)), and calculate the size of the ‘.vectors’ input section.

And then place the ‘.ctors’ and ‘.dtors’ input section from the crtgebin.o and crtbegin?.o files into the .text output section.

The '.ctors' section is set aside for a list of constructors (also called initialization routines) that include functions to initialize data in the program when the program is started. And the '.dtors' is set aside for a list of destructors (also called termination routines) that should be called when the program terminates. For more information about the ‘.ctors’ and ‘.dtors’ sections, please refer to the link below.

https://gcc.gnu.org/onlinedocs/gccint/Initialization.html

> FLASH assign the .text output section to the FLASH memory region that defined previously.

Reference:

Using ld (The GNU linker)
https://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_mono/ld.html

Understand the GNU assembler startup file of cortex M4

https://www.silabs.com/community/mcu/32-bit/knowledge-base.entry.html/2018/11/11/understand_the_gnua-zyam

32-bit MCU Knowledge Base

Understand the GNU linker script of cortex M4

Tags

Top Authors

Archives