Introduction

Ever wondered How C code compiles and runs 🤔 ?

In this blog, we will take a look at the C compilation process in details. We will start by explaining the different steps of the compilation process, then we will explain the different types of errors that can occur during the compilation process, and finally, we will explain the different types of files that are generated during the compilation process.

as you see in the picture above, the C compilation process is divided into 5 main steps:

1. Preprocessing
2. Compilation
3. Assembly
4. Linking
5. Execution

which we will explain in details in the following sections.

Prerequisites

Before you start, make sure you have the following:

• a linux based operating system. If you don't have one, consider using a vm (virtual box or vmware or a remote machine that runs linux )
• GCC installed on your system. You can check this by running gcc --version in your terminal.
• Access to a Linux terminal. You can check your Linux kernel version by running uname -a in your terminal.

Preprocessing

preprocessing isn't part of the code compilation itself but from the compilation process as a whole,it happens before compilation and done by a software component called preprocessor which interprets directives such as #define, #include. remember that all directives starts with a # symbol.

there 4 main steps in the preprocessing phase:

1. expanding macros: the preprocessor replaces the macros with their values.
2. expanding include directives: the preprocessor replaces the #include directive with the content of the file.
3. conditional compilation: the preprocessor evaluates the #if, #ifdef, #ifndef, #else, #elif, #endif directives and includes or excludes the code based on the evaluation.
4. directives such as #pragma and #undef are also processed by the preprocessor.

create a main.c file and write the following :

#include <stdio.h>

#define print_hello() printf("hello world\n")
#define PI 3.14

#ifndef PI
#define PI 3.1415 // this won't be executed since PI is already defined
#endif


int main() {
    print_hello();
    printf("PI value is %f\n", PI);
    return 0;
}

then run the following command to see the output of the preprocessing phase:

gcc -E main.c -o main.i

the first thing you will notice is that the #include directive is replaced with the content of the file stdio.h and the #define directives are replaced with their values and the main function now looks like this:

int main() {
    printf("hello world\n");
    printf("PI value is %f\n", 3.14);
    return 0;
}

Compilation

the compilation phase is the phase where the preprocessed file is converted to an assembly file. the compiler is responsible for this phase.

there is a popular quote by compiler designers :

"compile the compiler with the compiler. So it doesn't have problems it has"- unknown

the compiler is a software component that takes the preprocessed file and converts it to an assembly file.

to see the output of the compilation phase, run the following command:

gcc -S main.i -o main.s

let's conitnue. This will generate a main.s file that contains the assembly code of the main.i file.

Assembly

the assembly phase is the phase where the assembly file is converted to an object file.

the assembler who is responsible for this phase, takes the assembly file and converts it to a Relocatable object file of type elf.

to see the output of the assembly phase, run the following command:

gcc -c main.s -o main.o

this will generate a main.o file that contains the object code of the main.s file.

this main.o file is called a relocatable file because it contains the code and data sections of the main.s file and it will be merged with other relocatable files in the linking phase.

cool bear has something to say:

Linking

this part is the boss of the compilation process, it's the phase where all the relocatable files are merged together to create an executable file.

relocatable files and executable files are both of type elf.

let's view the elf file structure:

the elf file contains the following sections:

• header : contains the elf file header.
• text : contains the executable code.
• data : contains the initialized data.
• bss : contains the uninitialized data.
• symtab : contains the symbol table.
• strtab : contains the string table.
• debug : contains the debugging information.
• line : contains the line number information.
• shstrtab : contains the section header string table.
• init : contains the initialization code.

using readelf command

let's see the type and content in each section of the main.o file using the following commands:

file main.o
readelf -h main.o // to see the header
readelf -S main.o // to see the sections

using objdump command

objdump -h main.o // to see the header
objdump -D main.o // disassembly of all sections
objdump -d main.o // disassembly of main only
objdump -d -M intel hello.o // intel format

objdump and readelf are tools to help you see the content of the elf files as well as the disassembly of the code in the desired architecture. you may get something like this when running the disassembly using the intel format :

what you need to know for now is that programs you write in C are not standalone programs, they depend on other libraries like libc, libm, etc. and the linking phase is the phase where these libraries are linked to your program. to view the symbol table of the main.o file, run the following command:

nm main.o

you will see something like this :

$ nm main.o 
                 U _GLOBAL_OFFSET_TABLE_
0000000000000000 T main
                 U printf
                 U puts

to see the output of the linking phase, run the following command:

gcc main.o -o main

finally, you will get an executable file named main* that contains the executable code of the main.o file.

let's see the symbol table of the main file again:

nm main

there are a lot of symbols in the main file, but the most important ones are the main function and the printf and puts functions.

0000000000001169 T main
                 U printf@@GLIBC_2.2.5
                 U puts@@GLIBC_2.2.5

printf and puts are still undefined because they are loaded from the libc library dynamically at runtime. we will talk about that in a later blog posts. but what i want you to retain is that it knows where to find the main function in the main file. so at run time, the main functions will be executed from the libc library.

Execution

the last phase of the compilation process is the execution phase, this is the phase where the executable file is executed.

to execute the main file, run the following command:

./main

Congratulations 🎉 ! you made it to the end. let's say what you have learned in this blog post:

• the stages of the C compilation process which are preprocessing, compilation, assembly, linking, and execution.
• the different types of files that are generated during the compilation process.
• the elf file structure and the different sections of the elf file.
• the different tools that can be used to view the content of the elf files and the disassembly of the code such as readelf, objdump.
• use of nm command to view the symbol table of the elf files.