How C Code Becomes an Executable: The Complete Compilation Journey

The compilation process in C programming is a fundamental step that every developer should understand. It involves transforming human-readable source code into machine-executable programs. In this blog, we'll walk through the key stages of the C compilation process: preprocessing, compilation, assembly, and linking. By mastering these steps, you'll gain a deeper understanding of how your code is transformed into an executable file.

1. Preprocessing: The First Stage of Compilation

The first stage in the C compilation process is preprocessing. This step involves the preprocessor, which handles all directives that start with the # symbol, such as #include and #define.

• What happens at this stage?

You can use the cc -E command to see the output of the preprocessing stage.

To get and view the pre-processed output:

$ cc -E Program1.c -o Program1.i

$ cat Program1.i

2. Compilation: From Preprocessed Code to Assembly

In the compilation stage, the preprocessed code is translated into assembly code, which is a low-level, human-readable representation of machine instructions specific to the target architecture.

• Key steps in this stage:

Use the cc -S command to generate the assembly output.

To get and view the compilation output:

$ cc -S Program1.i -o Program1.s

$ cat Program1.s

3. Assembly: Converting Assembly Code to Machine Code

After the assembly stage, the assembler steps in to convert the assembly code into machine code—binary instructions that your CPU can directly understand.

• Outcome of this stage:

The cc -c command helps you generate the object file from the assembly code.

To get and view the assembling output:

$ cc -c Program1.s -o Program1.o

$ cat Program1.o

4. Linking: Combining Object Files into an Executable

The final stage of the C compilation process is linking, where the object files are combined with any necessary libraries to create the final executable.

• What happens in linking:

Simply running cc yourfile.c will go through all the stages to produce the final executable.

To compile object file:

$ cc Program1.o -o output

Saving Intermediate Files During the Compilation Process

If you want to examine each intermediate file generated during compilation, you can use the -save-temps option with the cc compiler. This allows you to keep all the intermediate files produced at each stage, including the preprocessed, assembly, and object files.

For example, running the following command:

$ cc -save-temps Program1.c -o outputfile

The C Compilation Process: A Summary

To summarize, here’s the flow of the C compilation process:

1. Preprocessing: Converts .c to .i (Preprocessed source code)
2. Compilation: Converts .i to .s (Assembly code)
3. Assembly: Converts .s to .o (Object code)
4. Linking: Combines .o into an executable file

Each stage of the process is crucial for transforming source code into an executable program that your system can run.

Exploring Each Stage with CC Commands

You can explore each stage of the compilation process using these cc commands:

• Preprocessing: cc -E yourfile.c -o yourfile.i
• Compilation: cc -S yourfile.i -o yourfile.s
• Assembly: cc -c yourfile.s -o yourfile.o
• Linking: cc yourfile.o -o outputfile

By understanding how these stages work, you’ll gain greater control over your C programs and improve your debugging and optimization skills.

Conclusion

The C compilation process is a crucial part of systems programming, enabling developers to create efficient and optimized applications. Whether you're a beginner or an experienced developer, understanding each stage—preprocessing, compilation, assembly, and linking—will enhance your coding skills and give you more insight into how software works at the machine level.