Compilation process and toolchains

The compilation process in C involves converting human-readable source code into machine-readable executable code. This process can be broken down into several stages: preprocessing, compiling, assembling, and linking. We’ll use a simple “Hello, World!” program to demonstrate how these stages work with a common toolchain (gcc).

Here’s the code we’ll compile (hello.c):

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

Steps in the Compilation Process

Let’s look at each stage in the compilation process using the gcc toolchain.

1. Preprocessing (gcc -E hello.c -o hello.i)

• Command: gcc -E hello.c -o hello.i
• The preprocessor (-E flag) handles #include directives, #define macros, and other preprocessor directives.
• The result of this step is an “expanded” version of the source code saved in hello.i. This file contains the original code, but with all macros expanded and header files included.
• Example Output (hello.i): This output file shows your code with all external dependencies (like stdio.h) expanded.

2. Compilation (gcc -S hello.i -o hello.s)

• Command: gcc -S hello.i -o hello.s
• The compiler translates the preprocessed code into assembly code using the -S flag. Assembly language is specific to the CPU architecture.
• The output, hello.s, contains low-level assembly instructions corresponding to the high-level C code.
• Example Output (hello.s): Contains architecture-specific assembly code representing the program.

3. Assembling (gcc -c hello.s -o hello.o)

• Command: gcc -c hello.s -o hello.o
• The assembler converts the assembly code into machine code, producing an object file (hello.o).
• This step translates human-readable assembly code into binary, CPU-executable instructions.
• Example Output (hello.o): This is a binary file that contains machine code, not yet fully linked into an executable.

4. Linking (gcc hello.o -o hello)

• Command: gcc hello.o -o hello
• The linker takes the object file (hello.o) and links it with libraries (such as the standard C library libc) to create the final executable.
• This stage resolves references to external libraries and functions (like printf in stdio.h) and produces a single executable file called hello.
• Example Output (hello): This is the final executable file, which can be run on the system.

Complete Compilation Command

Instead of running each step manually, you can compile the entire program in one step with gcc hello.c -o hello. This command will handle all four stages—preprocessing, compiling, assembling, and linking—to produce the executable file hello.

Explanation of Toolchain Commands

• Preprocessor (-E): Expands macros and includes headers.
• Compiler (-S): Converts expanded C code into assembly code.
• Assembler (-c): Translates assembly code into machine code, resulting in an object file.
• Linker: Links object files and libraries to produce an executable.

Each of these stages is essential for building a C program from source code, allowing for modular and efficient code development and compilation management.