C Program Compilation Process

The Complete C Program Compilation Process

The compilation of a C program is a sophisticated process that transforms high-level C code into machine-executable instructions. This multi-stage pipeline ensures that human-readable code is converted into efficient binary code that computers can execute directly.

1. Preprocessing

The preprocessing stage prepares the source code for compilation by performing several text manipulations:

• Receives the raw source code from .c files
• Removes all comments from the source code
• Processes preprocessor directives that begin with #.

#include: Inserts the contents of header files into the source code

#define: Replaces macros and constants with their defined values

#ifdef, #ifndef, #endif: Handles conditional compilation

#pragma: Provides implementation-specific instructions to the compiler

For example, when encountering #include, the preprocessor locates the stdio.h file and inserts its entire content at that position. Similarly, for #define MAX_SIZE 100, every occurrence of MAX_SIZE in the code is replaced with 100.

The output of this stage is an expanded source code file (typically with a .i extension) that contains no preprocessor directives.

2. Compilation

The compilation stage converts the preprocessed code into assembly language:

• Performs lexical analysis to break the code into tokens
• Conducts syntax analysis to verify code structure against C grammar rules
• Checks for syntax and semantic errors
• Translates valid C code into assembly language instructions
• Performs various optimizations to improve code efficiency
• Generates intermediate code or directly produces assembly code

During this stage, the compiler detects errors such as missing semicolons, undeclared variables, type mismatches, and other syntax violations. The output is typically an assembly file (.s extension) containing human-readable assembly instructions.

3. Assembly

The assembly stage converts assembly code into machine code:

• Translates assembly instructions into binary machine code
• Allocates memory addresses for variables and functions
• Creates an object file (.o or .obj extension) containing machine code
• Includes symbol tables for linking purposes

The resulting object file contains machine instructions that correspond directly to the target processor's instruction set, but it cannot be executed yet as it lacks necessary linking information.

4. Linking

The linking stage combines multiple object files and libraries to create the final executable:

• Resolves external references between object files
• Incorporates code from standard libraries and other external modules
• Assigns final memory addresses to all functions and variables
• Performs relocation adjustments for memory references
• Creates the final executable file (.exe on Windows or no extension on Unix/Linux)

The linker detects errors such as undefined references, multiple definitions of the same symbol, or missing the main() function. The output is a complete executable program ready to be loaded and run by the operating system.

Static And Dynamic Linking

If we used functions stored inside libraries, it will link it to our file so that the program knows where to look at to find said function. There are two types of libraries:
- Static libraries (.lib, .a): its code is put inside the binary file, which increase its size;
- Dynamic libraries (.dll, .so): the name of the library is put inside the binary file and is loaded when first called.

By default, gcc use dynamic libraries.

Static Linking

Static lib have extension (.a)

Example:
- I have a file is isalpha to check if the character is alphabetic while the other checks if the integer is even

#ifdef MAIN_H
#define MAIN_H

// prototypes
int _iseven(int n);
int _isalpha(int c);

#endif /* MAIN_H*/

// file isalpha.c
#include "main.h"
int _isalpha(int c) {
  if (condition) {
    return ...
  }
}

Similar with file iseven.c

Then, stop at step assembly with:

# all file c
gcc -c *.c

Create the static library using:

ar cr libname.a *.o

Explain command:

• ar: create, modify, and extract from archives
• r: Insert the files member... into archive (with replacement)
• c: Create the archive
• s: Add an index to the archive, or update it if it already exists
• We can look at the function stored inside the library by using ar -t lib(name).a
  - ar: create, modify, and extract from archives
  - t: Display a table listing the contents of archive, or those of the files listed in member... that are present in the archive
  - To use libname.a, using command gcc file.c -L. -l(name) or gcc file_exe file.c lib

Dynamic Linking

With the extension .so for dynamic libraries. Using libraries enable us to call functions without hard coding them inside the source code file as we can call a lot of different functions depending on the program we are creating.

How to create dynamic lib:

gcc -c -fPIC *.c

Explain command:

• c: Compile or assemble the source files, but do not link.
• fPIC: If supported for the target machine, emit position-independent code, suitable for dynamic linking and avoiding any limit on the size of the global offset table.

# create lib
gcc -shared -o lib(name).so *.o

Explain command:

• shared: Produce a shared object which can then be linked with other objects to form an executable.
• o: Place output in file file.

To verify that we did it correctly and have the right functions as dynamic symbols we can use nm -D libname.so.

Practical Example

Consider a simple C program in a file named "example.c":

#include
#define GREETING "Hello, World!"

int main() {
// Print greeting message
printf("%s\n", GREETING);
return 0;
}

The compilation process would proceed as follows:

1. Preprocessing: Comments are removed, GREETING is replaced with "Hello, World!", and the contents of stdio.h are inserted.

2. Compilation: The preprocessed code is analyzed and converted to assembly language specific to the target architecture.

3. Assembly: The assembly code is converted to machine code, creating the object file example.o.

4. Linking: The object file is linked with the C standard library (which contains the implementation of printf) to create the final executable.

Using a C Compiler

To compile a C program using GCC (GNU Compiler Collection), you can use:

gcc -o example example.c

This command performs all four stages and produces an executable named "example". To perform each stage separately:

# Preprocessing only
gcc -E example.c -o example.i

# Compilation to assembly
gcc -S example.i -o example.s

# Assembly to object code
gcc -c example.s -o example.o

# Linking to create executable
gcc example.o -o example

# It is possible to keep a file for each steps by doing
gcc file.c -save-temps

Reference link here

Reference link here

Reference link here

Reference link here

Reference link here