So you’ve written your first few C programs. You type gcc hello.c or maybe hit that shiny "Build & Run" button in your IDE… and magically, your code runs.
But wait 🤔 — what really happens between writing a .c file and seeing output on your screen?
That’s where the C Compilation Model comes in.
Think of it like ordering food at your favorite café:
You place your order (your code).
The chef preprocesses it (cleans it up, adds missing stuff).
The kitchen compiles it into raw food materials (machine instructions).
The staff assembles everything (linker puts it all together).
Finally, you get a nice dish on your table (the executable program).
Let’s break it down step by step.
🛠The Four Stages of C Compilation
When you compile a C program, it goes through four major steps:
1. Preprocessing
2. Compilation
3. Assembly
4. Linking
We’ll use a simple example along the way.
Example Program
#include <stdio.h>
int main() { printf("Hello, Compilation Model!\n"); return 0;}
Saved as hello.c.
1) Preprocessing
This stage handles directives (things starting with # like #include and #define).
#include <stdio.h> → replaced with the actual contents of the stdio.h header file (which contains function declarations like printf).
Comments (// ... or /* ... */) are removed.
Macros (#define) are expanded.
👉 Output: a .i file (preprocessed source).
Command to see it:
gcc -E hello.c -o hello.i
2) Compilation
Now, the compiler translates your preprocessed code into assembly language.
This is human-readable but closer to machine language.
The compiler checks for syntax errors here.
👉 Output: a .s file (assembly code).
Command:
gcc -S hello.i -o hello.s
3) Assembly
The assembler takes the assembly code and converts it into object code (machine-readable binary instructions).
👉 Output: a .o file (object file).
Command:
gcc -c hello.s -o hello.o
4) Linking
Finally, the linker comes into play.
Your object file alone doesn’t know what printf means (it’s just a symbol).
The linker connects your object file with the standard C library (where printf is defined).
It also combines multiple object files if your program is split across files.
👉 Output: an executable file (usually a.out on Linux, .exe on Windows).
Command:
gcc hello.o -o hello
Run it:
./hello
Output:
Hello, Compilation Model!
A Note on Loader
When you run the program, the loader (part of the operating system) does its magic:
● Loads the executable into main memory (RAM).
● Allocates space for stack, heap, and global variables.
● Sets the instruction pointer to the program’s main() function.
● Hands over control to the CPU.
At this point, your program actually starts executing.
🌀 Visualizing the Compilation Flow
| Input File | Stage | Output File |
| hello.c | Preprocessor | hello.i |
| hello.i | Compiler | hello.s |
| hello.s | Assembler | hello.o |
| hello.o | Linker | hello (executable) |
🎯 Why Should You Care?
Debugging: If you know the stages, you’ll know where errors come from.
Optimization: You can inspect assembly to see how your code behaves at machine level.
Multiple files: Linking explains how big projects are stitched together.
Power: It shows that “C isn’t magic” — it’s a pipeline.
✨ Wrap-Up
Next time you press compile, remember it’s not just one step. It’s a full journey from human-readable C code to machine-executable binary:
Preprocessing 🧹 (clean and prepare)
Compilation ✍ (translate to assembly)
Assembly ⚙ (make object code)
Linking 🔗 (put it all together)
This is why C is often called a “low-level high-level language” — it gives you human-friendly syntax but still keeps you close to the metal.