Compilation Process in C

📖 Introduction

Understanding how C source code transforms into an executable program is crucial for every C programmer. This knowledge helps you debug errors, optimize code, and understand what happens behind the scenes.

---

🔄 Overview of Compilation Process

The compilation process converts human-readable source code into machine-executable binary code. It involves four main stages:

┌─────────────┐    ┌──────────────┐    ┌──────────┐    ┌────────┐    ┌────────────┐
│ Source Code │───▶│ Preprocessor │───▶│ Compiler │───▶│ Assembler│───▶│  Linker   │
│   (.c)      │    │              │    │          │    │         │    │           │
└─────────────┘    └──────────────┘    └──────────┘    └────────┘    └────────────┘
                          │                  │              │              │
                          ▼                  ▼              ▼              ▼
                    ┌──────────┐      ┌──────────┐   ┌──────────┐   ┌──────────┐
                    │   .i     │      │   .s     │   │   .o     │   │   .exe   │
                    │(expanded)│      │(assembly)│   │ (object) │   │(executable)│
                    └──────────┘      └──────────┘   └──────────┘   └──────────┘

---

📝 Stage 1: Preprocessing

The preprocessor handles directives that begin with #. It prepares the source code for compilation.

What the Preprocessor Does:

1. File Inclusion (#include)

// Before preprocessing
#include <stdio.h>
#include "myheader.h"

// After preprocessing
// The entire content of stdio.h and myheader.h
// is inserted at this location

2. Macro Expansion (#define)

// Before preprocessing
#define PI 3.14159
#define SQUARE(x) ((x) * (x))

float area = PI * SQUARE(radius);

// After preprocessing
float area = 3.14159 * ((radius) * (radius));

3. Conditional Compilation (#ifdef, #ifndef, #if)

// Before preprocessing
#define DEBUG 1

#ifdef DEBUG
    printf("Debug mode enabled\n");
#endif

#ifndef RELEASE
    printf("Not in release mode\n");
#endif

// After preprocessing (with DEBUG defined)
    printf("Debug mode enabled\n");
    printf("Not in release mode\n");

4. Comment Removal

// Before preprocessing
int x = 10;  // This is a comment
/* This is also
   a comment */

// After preprocessing
int x = 10;

5. Line Continuation (\)

// Before preprocessing
#define LONG_MACRO(a, b, c) \
    do { \
        statement1; \
        statement2; \
    } while(0)

// After preprocessing
#define LONG_MACRO(a, b, c) do { statement1; statement2; } while(0)

Viewing Preprocessor Output

# Generate preprocessed output
gcc -E source.c -o source.i

# View the expanded code
cat source.i

Common Preprocessor Directives Table

---

⚙️ Stage 2: Compilation

The compiler translates the preprocessed C code into assembly language specific to the target processor.

What the Compiler Does:

1. •

   Lexical Analysis (Tokenization)

   • •Breaks code into tokens (keywords, identifiers, operators, literals)

   int sum = a + b;
   // Tokens: [int] [sum] [=] [a] [+] [b] [;]
   

2. •

   Syntax Analysis (Parsing)

   • •Checks grammar according to C language rules
   • •Builds a syntax tree

        =
       / \
     sum  +
         / \
        a   b
   

3. •

   Semantic Analysis

   • •Type checking
   • •Variable declaration verification
   • •Function call validation
4. •

   Intermediate Code Generation

   • •Creates platform-independent intermediate representation
5. •

   Code Optimization

   • •Improves efficiency without changing functionality

   // Before optimization
   int x = 2 + 3;
   int y = x * 2;
   
   // After optimization (constant folding)
   int x = 5;
   int y = 10;
   

6. •

   Assembly Code Generation

   • •Produces assembly language for target architecture

Viewing Assembly Output

# Generate assembly code
gcc -S source.c -o source.s

# View assembly (x86-64 example)
cat source.s

Sample Assembly Output

// C code
int add(int a, int b) {
    return a + b;
}

; Corresponding x86-64 assembly
add:
    pushq   %rbp
    movq    %rsp, %rbp
    movl    %edi, -4(%rbp)
    movl    %esi, -8(%rbp)
    movl    -4(%rbp), %edx
    movl    -8(%rbp), %eax
    addl    %edx, %eax
    popq    %rbp
    ret

Common Compiler Errors

---

🔧 Stage 3: Assembly

The assembler converts assembly language into machine code (object code).

What the Assembler Does:

1. •

   Translates mnemonics to machine code

   MOV AX, BX  →  10001011 11000011
   

2. •

   Creates object file (.o or .obj)

   • •Contains machine code
   • •Symbol table (function and variable names)
   • •Relocation information
3. •

   Handles different sections

   • •.text - Code section
   • •.data - Initialized data
   • •.bss - Uninitialized data
   • •.rodata - Read-only data (constants)

Generating Object Files

# Compile to object file
gcc -c source.c -o source.o

# View object file information
objdump -d source.o    # Disassembly
nm source.o            # Symbol table
size source.o          # Section sizes

Object File Contents

source.o:
├── Machine code (binary)
├── Symbol table
│   ├── main (defined)
│   ├── add (defined)
│   ├── printf (undefined - external)
│   └── ...
├── Relocation table
│   └── Addresses needing adjustment
└── Debug information (if compiled with -g)

---

🔗 Stage 4: Linking

The linker combines object files and resolves external references to create the final executable.

What the Linker Does:

1. •

   Symbol Resolution

   • •Matches undefined symbols with their definitions

   source1.o: calls printf()  ─┐
   source2.o: calls printf()  ─┼──▶ libc.so: defines printf()
   source3.o: calls printf()  ─┘
   

2. •

   Address Binding

   • •Assigns final memory addresses to code and data
3. •

   Library Linking

   • •Static Linking: Library code copied into executable
   • •Dynamic Linking: References to shared libraries
4. •

   Creates Executable

   • •Final runnable program

Types of Linking

Static Linking

# Create static library
ar rcs libmath.a math.o

# Link statically
gcc main.o -L. -lmath -static -o program

Advantages:

• •Self-contained executable
• •No external dependencies at runtime

Disadvantages:

• •Larger file size
• •Updates require recompilation

Dynamic Linking

# Create shared library
gcc -shared -fPIC -o libmath.so math.c

# Link dynamically
gcc main.o -L. -lmath -o program

Advantages:

• •Smaller executable size
• •Updates don't require recompilation
• •Memory sharing between programs

Disadvantages:

• •Requires library at runtime
• •Potential version conflicts

Common Linker Errors

---

🛠️ GCC Compilation Commands

Single File Compilation

# Complete compilation (all stages)
gcc source.c -o program

# Run the program
./program

Stage-by-Stage Compilation

# Stage 1: Preprocessing only
gcc -E source.c -o source.i

# Stage 2: Compile to assembly
gcc -S source.c -o source.s

# Stage 3: Assemble to object file
gcc -c source.c -o source.o

# Stage 4: Link to executable
gcc source.o -o program

Multiple Files

# Compile each file separately
gcc -c file1.c -o file1.o
gcc -c file2.c -o file2.o
gcc -c main.c -o main.o

# Link all together
gcc file1.o file2.o main.o -o program

# Or in one command
gcc file1.c file2.c main.c -o program

Common GCC Options

---

📊 Complete Compilation Flow Diagram

                        SOURCE CODE
                            │
                        hello.c
                            │
    ┌───────────────────────┼───────────────────────┐
    │                       ▼                       │
    │   ┌─────────────────────────────────────┐    │
    │   │         PREPROCESSOR (cpp)          │    │
    │   │                                     │    │
    │   │  • Removes comments                 │    │
    │   │  • Expands macros (#define)         │    │
    │   │  • Includes headers (#include)      │    │
    │   │  • Conditional compilation          │    │
    │   └─────────────────────────────────────┘    │
    │                       │                       │
    │                   hello.i                     │
    │              (expanded source)                │
    │                       │                       │
    │                       ▼                       │
    │   ┌─────────────────────────────────────┐    │
    │   │           COMPILER (cc1)            │    │
    │   │                                     │    │
    │   │  • Lexical analysis                 │    │
    │   │  • Syntax analysis                  │    │
    │   │  • Semantic analysis                │    │
    │   │  • Code optimization                │    │
    │   │  • Generates assembly               │    │
    │   └─────────────────────────────────────┘    │
    │                       │                       │
    │                   hello.s                     │
    │              (assembly code)                  │
    │                       │                       │
    │                       ▼                       │
    │   ┌─────────────────────────────────────┐    │
    │   │           ASSEMBLER (as)            │    │
    │   │                                     │    │
    │   │  • Converts assembly to machine     │    │
    │   │  • Creates object file              │    │
    │   │  • Generates symbol table           │    │
    │   └─────────────────────────────────────┘    │
    │                       │                       │
    │                   hello.o                     │
    │               (object file)                   │
    │                       │                       │
    └───────────────────────┼───────────────────────┘
                            │
                            ▼
    ┌─────────────────────────────────────────────────┐
    │                  LINKER (ld)                    │
    │                                                 │
    │  • Resolves external references                 │
    │  • Links with libraries (libc, etc.)           │
    │  • Assigns final addresses                      │
    │  • Creates executable                           │
    └─────────────────────────────────────────────────┘
                            │
                            ▼
                    ┌───────────────┐
                    │    hello      │
                    │ (executable)  │
                    └───────────────┘

---

🔍 Debugging Compilation Issues

Preprocessor Issues

# Check macro expansion
gcc -E -dM source.c  # List all macros
gcc -E source.c | grep "pattern"  # Search in expanded code

Compiler Issues

# Verbose output
gcc -v source.c -o program

# All warnings
gcc -Wall -Wextra -pedantic source.c

# Save intermediate files
gcc -save-temps source.c

Linker Issues

# Verbose linking
gcc -Wl,--verbose source.o -o program

# Check symbols
nm program           # List symbols
ldd program          # List shared libraries

---

🔑 Key Takeaways

1. •Four Stages: Preprocessing → Compilation → Assembly → Linking
2. •Preprocessor handles # directives and text substitution
3. •Compiler converts C to assembly and catches syntax errors
4. •Assembler converts assembly to machine code (object files)
5. •Linker combines objects and libraries into executable
6. •Use -E, -S, -c to see intermediate outputs
7. •Understanding errors helps in debugging at the right stage

---

⏭️ Next Topic

Continue to IDEs and Compilers to learn about development environments and compiler options.