The Dance of Compilation: C/C++ and GCC Collaboration

On the modern stage of computing, programming languages are like dancers, while compilers are the choreographers guiding them from behind the scenes. Every piece of code written is like a carefully designed dance. On this stage, C language and GCC (GNU Compiler Collection) are a classic duo. Together, they perform a magnificent dance of compilation, transforming source code into executable files.

This article will explore the wonderful collaboration between C language and GCC, delving into how they together create the programs that ultimately run on computers.

1. The Four Stages of C/C++ Compilation

1. The Dance Behind the Scenes

Almost every beginner in programming starts with the output Hello World! (with some minor modifications in the code below).

#include <stdio.h>

int main(int argc, char *argv[]) {
    if(argc >= 2)
        printf("Hello %s!\n", argv[1]);
    else
        printf("Hello World!\n");

    return 0;
}

To compile this code into an executable file, you only need a simple command:

gcc hello.c -o hello

Using the gcc command with the -o option generates the executable file hello. However, the entire compilation process is not as simple as it seems.

One or more C/C++ files must go through preprocessing, compilation, assembly, and linking stages to become an executable file.

The Dance of Compilation: C/C++ and GCC Collaboration

As shown in the figure above, a source code file with the extension .c can generate a temporary file with the extension .i after preprocessing. The .i file, after compilation, can generate an assembly file with the extension .s. The assembly file with the extension .s can then be assembled into a binary file with the extension .o. Finally, these binary files are linked together to form an executable file.

Next, we will use GCC to compile this code into machine-understandable instructions.

2. Setting the Stage – Preprocessing

In C/C++ source files, commands starting with # are called preprocessing commands, such as the include command #include, macro definition command #define, conditional compilation commands #if, #ifndef, etc. Preprocessing involves inserting the files to be included into the original file, expanding macro definitions, selecting code to use based on conditional compilation commands, and finally outputting these to a temporary file with the extension .i, waiting for the next step.

For the previous hello.c example, you can use the -E option to let GCC only preprocess and output the result:

gcc -E hello.c -o hello.i

Using vim to open the hello.i file, you will find that this is a fully expanded file of the header files in hello.c:

The Dance of Compilation: C/C++ and GCC Collaboration

The source code only has 11 lines, but after expansion, it has as many as 803 lines. However, the main content of the source code can still be seen at the end of hello.i.

3. The Dancer’s Basic Training – Compilation

What we commonly refer to as “compilation” actually encompasses these four stages and is not specifically referring to just the “compilation” stage itself. However, it is important to specify that here, “compilation” refers to the step immediately following preprocessing. The compilation stage translates the temporary file with the extension .i into assembly code, using the tool cc1 (do not doubt, this tool is indeed called cc1. Different architectures have their own cc1 tools; the x86 architecture has its own cc1 tool, and the ARM architecture has its own cc1 tool).

This step can be accomplished using the -S option:

gcc -S hello.i -o hello.s

Similarly, you can open the hello.s file using vim:

The Dance of Compilation: C/C++ and GCC Collaboration

As seen in the image above, the generated hello.s file contains assembly code that describes the basic operations of the program. These instructions are still human-readable, but further conversion is needed for the computer to execute them.

4. The Choreographer’s Fine-Tuning – Assembly

The assembly stage translates assembly code into machine code in a specific format, which on Linux systems generally appears as an ELF object file (OBJ file), using the tool as.

Using the -c option, GCC will convert the assembly code into object code (machine code):

gcc -c hello.s -o hello.o

At this point, opening the hello.o file with vim will reveal a bunch of incomprehensible content:

The Dance of Compilation: C/C++ and GCC Collaboration We can use another command-line tool to open the hello.o file, which is used to display the file’s content in hexadecimal format, called hexdump. Enter the following command:

hexdump -C hello.o

As shown in the image below, the first line indicates the file format. The entire file contains the machine instructions of the program but has not yet completed the final linking.

The Dance of Compilation: C/C++ and GCC Collaboration

5. The Harmony of the Ensemble – Linking

The linking stage is the final step of the compilation process, which links the OBJ files and the system library OBJ files and library files, ultimately generating an executable file that can run on a specific platform, using the tools ld or collect2. Enter the following command to generate the final executable file:

gcc hello.o -o hello

At this point, a complete executable file named hello has been generated. Of course, this executable file is indistinguishable from the one generated by gcc hello.c -o hello.

2. The Dance’s Detailed Movements – Detailed Compilation Mode

In the GCC compilation process, using the -v option can enable detailed mode, displaying each step of the compilation and detailed information about the tools invoked. This is very useful for debugging and understanding the compilation process. The specific command is as follows:

gcc hello.c -o hello -v

Executing this command will produce a lot of information, but we can also find some key information from it to verify some of the content we mentioned earlier.

The first part of this information is the compiler configuration information, and we extract the main information from it:

Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/7/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
Configured with: ../src/configure -v ...... # omitted unimportant content
Thread model: posix
gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)

Specific explanations are as follows:

• Using built-in specs.: Indicates that built-in compiler specifications are being used.
• COLLECT_GCC=gcc: Indicates that the main compiler is gcc.
• Target: x86_64-linux-gnu: The target architecture is 64-bit x86 architecture running on GNU/Linux system.
• Configured with: Displays the compiler configuration options.
• Thread model: posix: Uses the POSIX thread model.
• gcc version 7.5.0: The compiler version is 7.5.0.

Next, as mentioned earlier, the first step is preprocessing, but from the output information, it can be seen that GCC will perform both preprocessing and compilation stages together. The cc1 tool is also used here:

Key information extracted (as follows), here the cc1 tool is used to compile the hello.c file into a temporary /tmp/ccEwwHut.s, which is an assembly file.

COLLECT_GCC_OPTIONS='-o' 'hello' '-v' '-mtune=generic' '-march=x86-64'
/usr/lib/gcc/x86_64-linux-gnu/7/cc1 hello.c -o /tmp/ccEwwHut.s # many parameters omitted

[!NOTE]

When enabling the cc1 tool, many options are used, which can be difficult for beginners to understand. However, for the convenience of those already in the field, here are some descriptions of the options for learning purposes:

• /usr/lib/gcc/x86_64-linux-gnu/7/cc1： Calls cc1, which is the front end of GCC, responsible for preprocessing, lexical analysis, and syntax analysis.

• -quiet： Reduces output information.

• -imultiarch x86_64-linux-gnu： Specifies the target platform.

• -dumpbase hello.c： Specifies the source file name.

• -mtune=generic： Optimizes for generic architecture.

• -march=x86-64： Target architecture is x86-64.

• -fstack-protector-strong： Enables strong stack protection.

• -Wformat： Enables format string warnings.

• -Wformat-security： Enables format string security checks.

This also includes a step that was not mentioned earlier, which is search paths, as shown below:

#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/gcc/x86_64-linux-gnu/7/include
 /usr/local/include
 /usr/lib/gcc/x86_64-linux-gnu/7/include-fixed
 /usr/include/x86_64-linux-gnu
 /usr/include
End of search list.

This step is actually just preparing for the following linking stage, identifying the libraries to be loaded in advance.

During the assembly stage, it can be seen that the as assembler is called to perform the assembly, where the -v option indicates detailed mode, and --64 indicates generating 64-bit object code, ultimately generating the specified output object file tmp/cc8dsQ4D.o, which is also a temporary file.

Finally, in the linking stage, it can be seen that the collect2 linker is called. Among the parameters following the linker, in addition to some related libraries, the most crucial is the /tmp/cc8dsQ4D.o file, which is also included. It can also be seen that the -o hello option and parameter will generate the executable file hello.

[!NOTE]

There are also many options that are relatively difficult to understand, so here are some explanations for enhancement purposes:

• -plugin： Uses LTO plugins for optimization during linking.

• -plugin-opt： Options passed to the plugin.

• -m elf_x86_64： Specifies the ELF format as 64-bit.

• -dynamic-linker /lib64/ld-linux-x86-64.so.2： Specifies the dynamic linker.

• -pie： Generates position-independent executable files.

• -z now： Makes certain symbols immediately available.

• -z relro： Creates read-only relocation sections.

• -lgcc, -lgcc_s, -lc： Links necessary libraries.

3. Behind the Scenes – Various Options of GCC (Overall Option)

GCC (GNU Compiler Collection) provides many options to control the behavior of the compiler. These options can be roughly divided into several categories, including preprocessing options, compilation options, assembly options, and linking options. Below are explanations of relatively important options:

1. Preprocessing Options

• -E： Only perform the preprocessing stage and then stop. The output is the preprocessed source code.
• -P： Do not output line control information (e.g., #line directive).
• -C： Retain all comments.
• -M： Output dependency list.
• -MM： Output dependency list, ignoring standard header files.

2. Compilation Options

• -c： Only compile and assemble, but do not link. Generates an object file.
• -S： Only compile, generating assembly code.
• -E： Only preprocess, do not compile.
• -g： Generates debugging information.
• -O： Sets optimization level. -O0 indicates no optimization, -O1 to -O3 represent different optimization levels, and -O3 is the highest level of optimization.
• -Os： Optimize to reduce code size.
• -Og： Optimize while maintaining the availability of debugging information.
• -Wall： Enable all warnings.
• -Wextra： Enable extra warnings.
• -Werror： Treat all warnings as errors.
• -pedantic： Enable all language extensions prohibited by ISO C and ISO C++ standards.
• -pedantic-errors： Similar to -pedantic but treats extensions as errors.
• -std=standard： Specifies the standard to follow (e.g., -std=c99 or -std=c++11<code>).
• -fPIC： Generates position-independent code (Position Independent Code) for shared libraries.

3. Assembly Options

• -Wa,option： Passes option to the assembler.
• -masm=att： Selects AT&T assembly style.
• -masm=intel： Selects Intel assembly style.

4. Linking Options

• -Ldir： Adds directory dir to the search path of the linker.
• -lfoo： Links the library named libfoo.
• -static： Produces an executable file with static linking.
• -shared： Generates a shared library.
• -pie： Generates position-independent executable files.
• -fPIC： Similar to -pie, for generating position-independent code, usually for shared libraries.
• -Wl,option： Passes options to the linker.
• -T： Specifies the linker script.
• -nostartfiles： Does not use any startup files.
• -nostdlib： Does not use the standard library.

5. Other Options

• -v： Displays compiler version information and detailed information during the compilation process.
• -V： Displays the compiler version.
• -Bprefix： Specifies the prefix path prefix to look for compiler-related tools.
• -print-file-name=filename： Prints the full path of the specified file.
• -print-prog-name=program： Prints the full path of the specified program.
• -print-libgcc-file-name： Prints the path of libgcc.
• -dumpversion： Prints the version number.

1. The Four Stages of C/C++ Compilation

1. The Dance Behind the Scenes

2. Setting the Stage – Preprocessing

3. The Dancer’s Basic Training – Compilation

4. The Choreographer’s Fine-Tuning – Assembly

5. The Harmony of the Ensemble – Linking

2. The Dance’s Detailed Movements – Detailed Compilation Mode

3. Behind the Scenes – Various Options of GCC (Overall Option)

1. Preprocessing Options

2. Compilation Options

3. Assembly Options

4. Linking Options

5. Other Options

Related posts

Leave a Comment Cancel reply