← PREV_LECNEXT_LEC →

1. Build Process Overview

When you hit “Build” in an IDE, a lot happens behind the scenes. Understanding each stage helps you debug build errors, optimize binary size, and write correct Makefiles. The entire process is driven by a single command — arm-none-eabi-gcc — which internally calls the preprocessor, compiler, assembler, and linker.

You can run all stages with one command, or run each individually to inspect intermediate output. Running stages individually is extremely useful for debugging.

2. Stage 1: Preprocessing (.c → .i)

The preprocessor handles all directives that begin with #. It expands macros, inserts included headers, and evaluates conditional compilation blocks. The output is a pure C file with no # directives remaining.

What the Preprocessor Does

• #include — inserts the full content of the header file inline.
• #define — performs text substitution of macros.
• #ifdef/#ifndef — includes/excludes code blocks based on conditions.
• Strips all comments.

C — Input: led.c

#include "stm32f4xx.h"
#define LED_PIN  12U

void led_init(void)
{
    /* Enable GPIOD clock */
    RCC->AHB1ENR |= (1U << 3U);
    /* Set pin 12 as output */
    GPIOD->MODER |= (1U << (LED_PIN * 2U));
}

Shell — Run Preprocessor Only

# -E flag: stop after preprocessing, output .i file
arm-none-eabi-gcc -E led.c -o led.i

# Inspect the output (can be very large due to header expansion)
# grep for led_init to find the relevant section
grep -A 10 "led_init" led.i

3. Stage 2: Code Generation (.i → .s)

The compiler’s core takes the preprocessed C code and translates it into ARM assembly language. This is the most intellectually complex stage — the parser builds an abstract syntax tree (AST), an optimizer transforms the tree, and the code generator emits ARM Thumb-2 assembly mnemonics.

What Happens Inside the Compiler

Shell — Compile to Assembly

# -S flag: stop after compilation, produce .s assembly file
arm-none-eabi-gcc \
    -mcpu=cortex-m4 \
    -mthumb \
    -O0 \          # no optimization for readable output
    -S led.c \
    -o led.s

# View the generated assembly
cat led.s

Sample Generated Assembly

ARM Assembly Output (led.s fragment)

; led_init function compiled to Thumb-2 instructions
led_init:
    PUSH    {R4, LR}          ; save link register
    LDR     R3, =0x40023830   ; address of RCC->AHB1ENR
    LDR     R2, [R3]          ; read current value
    ORR     R2, R2, #0x8      ; set bit 3 (GPIOD clock)
    STR     R2, [R3]          ; write back
    LDR     R3, =0x40020C00   ; address of GPIOD->MODER
    LDR     R2, [R3]
    ORR     R2, R2, #0x1000000 ; set pin 12 as output
    STR     R2, [R3]
    POP     {R4, PC}          ; restore and return

4. Stage 3: Assembly (.s → .o)

The assembler converts human-readable ARM assembly mnemonics into binary machine code (opcodes). The output is a relocatable object file in ELF (Executable and Linkable Format). “Relocatable” means the code has no fixed memory addresses yet — those are assigned by the linker.

What is an ELF Object File?

ELF is a standard binary format. A relocatable .o file contains:

• .text — machine code instructions
• .data — initialized global/static variables
• .bss — uninitialized global/static variables (size only, no data)
• .rodata — read-only data (string literals, const arrays)
• Symbol table — names and (relative) addresses of functions and variables
• Relocation entries — placeholders for addresses to be filled in by the linker

Shell — Assemble to Object File

# -c flag: compile and assemble but do not link
arm-none-eabi-gcc \
    -mcpu=cortex-m4 \
    -mthumb \
    -c led.c \
    -o led.o

# Inspect sections in the object file
arm-none-eabi-objdump -h led.o

# Expected output (section headers):
# Idx Name    Size     VMA      LMA      Offset   Align
#   0 .text   00000018 00000000 00000000 00000034 2**1
#   1 .data   00000000 00000000 00000000 0000004c 2**0
#   2 .bss    00000000 00000000 00000000 0000004c 2**0

# Disassemble — shows machine opcodes with mnemonics
arm-none-eabi-objdump -d led.o

# Show symbol table
arm-none-eabi-nm led.o

5. Stage 4: Linking (.o → .elf)

The linker combines multiple .o files, resolves cross-file symbol references (e.g., main.c calls led_init() defined in led.c), and assigns absolute addresses to all sections using the linker script.

Shell — Link Object Files

# Link all .o files using a linker script
arm-none-eabi-gcc \
    -mcpu=cortex-m4 \
    -mthumb \
    -T linker.ld \       # provide linker script
    -nostdlib \          # no standard library (bare metal)
    -o firmware.elf \    # output ELF file
    main.o led.o startup.o

# Check section sizes and addresses
arm-none-eabi-objdump -h firmware.elf

# Convert ELF to raw binary for flashing
arm-none-eabi-objcopy -O binary firmware.elf firmware.bin

# Or Intel hex format
arm-none-eabi-objcopy -O ihex firmware.elf firmware.hex

6. Important GCC Flags for ARM Embedded

7. Programming Exercises

Exercise 1 — Inspect Each Build Stage

Write a simple C function and walk through all four stages manually. At each stage, inspect the output file.

C — Source File (blink.c)

#define GPIOD_ODR  (*((volatile uint32_t*)0x40020C14))
#define LED_BIT    (1U << 12U)

static uint32_t blink_count = 0;

void toggle_led(void)
{
    GPIOD_ODR ^= LED_BIT;
    blink_count++;
}

Shell — Step-by-Step Build

# Step 1: Preprocess
arm-none-eabi-gcc -E blink.c -o blink.i
wc -l blink.i      # count lines after expansion

# Step 2: Compile to assembly
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -O0 -S blink.c -o blink.s
cat blink.s

# Step 3: Assemble to object file
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -c blink.c -o blink.o
arm-none-eabi-objdump -h blink.o   # inspect sections
arm-none-eabi-nm blink.o           # list symbols (blink_count, toggle_led)

# Note: blink_count should appear as a .data symbol
# toggle_led should appear as a .text symbol

Exercise 2 — Compare Optimization Levels

Compile the same function with -O0, -O1, -O2, and -Os. Compare the generated assembly and object file sizes. Record your findings.

Shell

for OPT in O0 O1 O2 Os; do
    arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -$OPT -c blink.c -o blink_$OPT.o
    echo "=== -$OPT ==="
    arm-none-eabi-size blink_$OPT.o
done

Exercise 3 — Find Undefined Symbols

Create a file main.c that calls toggle_led() but does NOT include blink.c during linking. Observe the linker error. Then add blink.o to the link command and verify it succeeds.

8. Frequently Asked Questions

Quick Knowledge Check