The linker script is one of the most powerful but least understood parts of the build process for embedded ARM development.
Most developers spend their time writing application code, but the linker script quietly decides how that code is stored in memory, how different parts are organised, and where important runtime parts like the stack and heap are located.
Even code that is written correctly won’t work as expected if the linker script isn’t set up correctly. To have full control over memory usage, improve performance, and build reliable embedded systems, you need to know how linker scripts work.
What Is a Linker Script?
A linker script is a configuration file used by the linker to map compiled object files into the final executable binary. After source code is compiled into object files, the linker combines these pieces into a single program. The linker script tells the linker exactly where each part of the program should be placed in memory.
In embedded systems, memory is limited and divided into distinct regions such as flash and RAM. The linker script defines these regions and assigns program sections to them. This ensures that executable code is placed in non-volatile memory while runtime data is stored in RAM.
The script also defines symbols that are later used by the startup code to initialize memory and set up the system correctly.
Why Linker Scripts Are Critical in Embedded Systems
Unlike general-purpose computing environments, embedded systems do not have an operating system to manage memory dynamically. Instead, memory must be explicitly defined and controlled at compile time.
The linker script provides this control, allowing developers to allocate memory precisely and ensure that no region is overused or misconfigured.
This level of control is particularly important in ARM Cortex-M microcontrollers, where memory is often limited and performance requirements are strict. By carefully organizing memory, developers can reduce latency, improve efficiency, and prevent runtime errors.
The linker script also plays a key role in enabling features such as bootloaders, memory protection, and multi-region applications.
Memory Regions: Flash and RAM
The definition of memory regions is at the heart of every linker script. These areas show the microcontroller’s physical memory and tell you how big and where it is. Flash and RAM are the two most common areas.
Flash memory is not volatile, which means that it can store program code and constant data. It keeps its contents even when the power goes out. RAM, on the other hand, is not stable and is used for variables, the stack, and the heap while a program is running.
The linker script tells you where these areas are and how long they are. This information helps the linker put different parts of the program in the right places. For example, executable instructions are placed in flash, while writable data is placed in RAM.
Sections and Their Placement
Sections are an important part of linker scripts. When you compile source code, it gets split up into parts like text, data, and bss. The text section has the program’s instructions, the data section has variables that have been set up, and the bss section has variables that haven’t been set up yet.
The linker script tells the computer how to put these sections into memory. For example, the text section usually goes in flash memory, and the data and bss sections usually go in RAM. When the computer starts up, the data that has been set up is copied from flash to RAM, and the bss section is set to zero.
This mapping makes sure that each type of data is stored in the best memory area, which balances performance and resource use.
Symbols and Their Role
Linker scripts define symbols that represent specific memory addresses or boundaries. These symbols are used by the startup code and application to access important locations in memory. For example, symbols may indicate the start and end of the data section, the top of the stack, or the boundaries of the heap.
These symbols act as a bridge between the linker and the runtime environment. The startup file uses them to perform tasks such as copying data and initializing memory. Developers can also use these symbols in their code to manage memory explicitly or implement custom features.
Stack and Heap Configuration
The linker script is responsible for defining the size and location of the stack and heap. The stack is typically placed at the top of RAM and grows downward, while the heap starts at a lower address and grows upward. This arrangement allows efficient use of available memory but requires careful configuration to prevent overlap.
By adjusting the sizes of these regions in the linker script, developers can optimize memory usage for their specific application. For example, applications with deep function calls or frequent interrupts may require a larger stack, while applications that use dynamic memory allocation may need a larger heap.
Proper configuration is essential to avoid issues such as stack overflow or heap exhaustion, both of which can lead to system instability.
The Role of the Linker Script in Startup
The linker script works closely with the startup file to initialize the system. It provides the addresses and sizes of memory sections, which the startup code uses to prepare the runtime environment.
For example, the startup code uses linker-defined symbols to copy initialized data from flash to RAM and to clear the bss section.
This collaboration ensures that the system is correctly initialized before the main application begins. Without accurate information from the linker script, the startup process would not be able to set up memory correctly, leading to unpredictable behavior.
Customizing Linker Scripts
One of the most powerful aspects of linker scripts is their flexibility. Developers can modify them to suit specific application requirements. For example, they can place certain functions in faster memory regions, reserve space for a bootloader, or create separate memory areas for different tasks.
Custom linker scripts are often used in advanced applications where precise control over memory layout is required. This might include real-time systems, multi-core applications, or systems with external memory components.
While customization provides great flexibility, it also requires a deep understanding of the system. Incorrect modifications can lead to difficult-to-diagnose errors, so changes should be made carefully and tested thoroughly.
Common Pitfalls and Debugging
Linker scripts can be hard to work with, especially for people who are just starting out. One common problem is going over memory limits, which causes linker errors when you try to compile.
Another problem is putting sections in the wrong place, which can lead to runtime errors or strange behaviour.
When you debug these problems, you often have to look at the linker map file, which shows you in detail how memory is used. This file can help you figure out which parts are taking up the most space and if any parts are overlapping.
To fix these problems well, you need to know how the linker script, startup code, and application work together.
Why This Knowledge Matters
With a good understanding of linker scripts, developers can go beyond basic programming and take charge of the whole embedded system. It helps make better use of limited resources, boosts performance, and makes the system more reliable.
The linker script is a key tool for managing memory and making sure that all the parts of a complex project work together correctly.
It is very important to know how to use linker scripts if you want to develop embedded ARM applications, whether they are simple or complex.
