Embedded Programming:

Compilation Techniques
Presenter: Dr. W Jino Hans, AsP/ECE
Session Outline
1 2 3

Compilation Stages for Cross-compilation Linking, Locating, and

Embedded Systems Concepts and Tools Memory Management
Detailed exploration of Understanding development Techniques for efficient memory
preprocessing, compilation, across different architectures and utilization and address allocation
assembly, and linking phases essential toolchains
specific to embedded
development
4 5

Build Systems and Optimization Strategies Debugging and Deployment Best Practices
Automating builds and implementing Methods for troubleshooting and efficiently deploying
performance/size optimizations embedded applications
Session Outcomes

Understand Compilation Stages Identify Key Tools

Gain comprehensive knowledge of all stages in Recognize and select appropriate cross-
the embedded compilation pipeline and their compilation tools and linking mechanisms for
significance specific embedded targets

Apply Optimization Methods Demonstrate Knowledge

Implement various optimization techniques to Show practical understanding of memory
enhance performance and reduce binary size addressing, binary creation, and debugging
processes
Introduction to Embedded Compilation
Unique Challenges
Resource Constraints
Embedded systems present distinct compilation
Programs must operate within tight memory, power,
challenges compared to general-purpose computing:
and processing limitations
• Limited memory and processing power
• Diverse hardware architectures (ARM, RISC-V, MSP430)
Target-Specific Code
• Real-time constraints and power efficiency requirements
• Direct hardware interaction through specialized interfaces Compilation converts high-level languages to
hardware-specific machine code

Toolchain Versatility

Specialized toolchains enable development for multiple archite

The Compilation Process Overview
Preprocessing 1
Expands macros, includes header files, removes
comments, and handles conditional compilation
directives
Example: #include statements, #define macros, 2 Compilation
#ifdef conditions
Translates preprocessed code into architecture-
specific assembly language
Assembly 3 Performs syntax checking, semantic analysis, and

Converts assembly code into object code basic optimizations

(machine instructions)

Creates relocatable object files (.o) with machine

4 Linking
code and symbol information Combines multiple object files and resolves
references between them

Links with libraries and produces the final executable bina

Preprocessing in Embedded Systems
Key Preprocessing Functions
Example: Preprocessor for
• File inclusion (#include) Hardware Configuration
• Macro expansion (#define)
• #ifdef TARGET_STM32F4
Conditional compilation (#ifdef, #ifndef)
#define LED_PIN GPIO_PIN_13
• Comment removal
#define LED_PORT GPIOC
• Line control #elif defined(TARGET_NRF52)
#define LED_PIN 17
Preprocessing is particularly crucial in embedded
#define LED_PORT 0
systems for conditional hardware support and
#endif
optimizing for specific targets.

Output: A single preprocessed source file (.i) with all

directives processed, ready for the compilation stage.
Compilation and Assembly Steps
1 Compilation to Assembly 2 Assembly to Object Code
The compiler translates preprocessed C/C++ The assembler converts assembly
code into assembly language specific to the instructions into machine code instructions
target architecture
• Syntax •
and semantic analysis of the source code Translation of mnemonics to binary opcodes
• Intermediate representation generation • Symbol table creation for variables and functions
• Architecture-specific code generation • Generation of relocatable object files (.o)
• Basic optimizations (loop unrolling, constant folding)• Preservation of debugging information if requested
Linking and Locating
The Linking Process Memory Locating
Linking combines multiple object files and resolves all Memory locating assigns physical memory addresses to
symbol references: code and data sections:

• Symbol resolution (function calls, variables) • Guided by linker scripts (.ld files)
• Relocation (adjusting addresses) • Maps sections (.text, .data, .bss) to specific memory regions
• Library inclusion (static or dynamic) • Respects hardware constraints (ROM, RAM sizes)
• Creates final binary image (hex, bin, elf)
Key outputs: executable or library files

Embedded-specific Consideration

Unlike desktop applications, embedded binaries must be precisely mapped to specific memory addresses
according to the hardware memory map. This makes the linker script a critical component in embedded
development.
Cross-Compilation Fundamentals
What is Cross- Essential Components Key Benefits
Compilation? • •
Cross-compiler: Generates Development without
Compiling code on one target-specific code constant access to target
architecture (host) to run on • Cross-linker: Links object • hardware
Faster development cycles
a different architecture files for target architecture using powerful host
(target) machines
Example: Developing on x86 • Target-specific libraries: • Testing in simulation
Windows/Linux PC for ARM Provides platform before hardware
Cortex-M microcontroller • functionality • deployment
Remote debugger: Tests Support for multiple target
code on actual hardware platforms from one
environment
Cross-Compiled Toolchains
Popular Toolchains Build System Integration
• GNU ARM Embedded Toolchain (arm-none-eabi-gcc) Modern build systems configure toolchains automatically:
• LLVM/Clang for various architectures
• Vendor-specific toolchains (TI, Microchip, cmake_minimum_required(VERSION

STM32CubeIDE) 3.10)set(CMAKE_SYSTEM_NAME
Generic)set(CMAKE_SYSTEM_PROCESSOR
• Arduino toolchain (avr-gcc, esp-gcc)
ARM)set(CMAKE_C_COMPILER arm-none-eabi-
gcc)set(CMAKE_CXX_COMPILER arm-none-
eabi-g++)project(EmbeddedProject)

Toolchains typically include the compiler, linker, archiver, objcopy, and debugger specifically configured for
the target architecture. They handle architecture-specific optimizations and ABI requirements.
Binary Optimization Techniques
Size Optimizations Performance Power Efficiency
•
Optimizations •
Compiler flags: -Os, - Compiler-assisted sleep modes
ffunction-sections, -fdata- • Instruction set extensions • Optimizing algorithm efficiency
• sections
Dead code elimination (SIMD, NEON for ARM)
• Cache-aware programming
• • Profile-guided
Link-time optimization (LTO) • Reducing memory operations
optimization (PGO)
• Binary compression (for
• Loop optimizations and
stored firmware)
inline functions
• Memory alignment for
faster access
Build Systems for Embedded Projects
Common Build Systems Build System Benefits
• Automated dependency management
• Reproducible builds across team members
CMake • Simplified configuration for different targets
• Integration with testing frameworks
Cross-platform build system generator with strong toolchain support
• Support for continuous integration
• Variant builds (debug, release, test)

Make

Traditional build automation tool widely used in embedded development

Meson

Modern, fast build system with excellent cross-compilation support

Debugging and Testing Embedded Binarie
1

Hardware Debugging Simulation Testing Automated Testing

• JTAG/SWD interfaces for • QEMU for architecture simulation • Unit testing with CppUTest
real-time debugging • Hardware-in-the-loop (HIL) testing or Unity
• Remote GDB sessions with • • Continuous integration with
Software models of
hardware probes peripheral behavior Jenkins/GitLab CI
• Trace capabilities for • • Static analysis tools
Fault injection for robustness
performance analysis testing (Coverity, MISRA checkers)
• Register and memory inspection • Code coverage analysis

Effective debugging strategies combine host-based testing with target hardware validation to ensure
reliability in the final deployment environment.
 Session Summary
Compilation Process Cross-Compilation
Preprocess → Compile → Essential for developing on
Assemble → Link → Locate different architectures

Each stage transforms code into Requires specialized toolchains

increasingly hardware-specific for target hardware
formats
Optimization
Building & Testing
Size, performance, and power
Automated build systems
optimizations
simplify development
Critical for resource-constrained
omprehensive testing ensures reliability
embedded systems

Embedded compilation requires specialized knowledge and tools to bridge the gap between high-level code
and hardware-specific binaries. Mastering these techniques enables the development of efficient, reliable
embedded systems.
Test Your Understanding
Further Learning Resources
What are the main stages of embedded compilation?
1 • "Embedded Software Development for Safety-Critical Systems" by Chris
Identify and explain each stage from source code to executable binary
• "Making Embedded Systems" by Elecia White
• Online: "Compiler Explorer" ([Link])
Why is cross-compilation important in • ARM Developer Documentation: compiler optimizations
2 embedded development?

Describe the benefits and challenges of cross-compilation

Name one optimization technique for

3 embedded binaries

Explain how it improves performance, size, or power efficiency

How does a build system simplify development?

4
Discuss the advantages of using build systems like CMake
in embedded projects