GCC Compiler - Complete Guide to GNU C Compiler

GCC (GNU Compiler Collection) is the most widely used open-source compiler for C and C++ programming. Originally created by Richard Stallman in 1987 as part of the GNU Project, GCC has become the default compiler on Linux systems and is available on virtually every platform. Whether you're a student writing your first program or a systems programmer building operating systems, understanding GCC is essential.

What is GCC?

GCC stands for GNU Compiler Collection. While it originally stood for "GNU C Compiler," it has grown to support multiple programming languages including C, C++, Objective-C, Fortran, Ada, and Go.

When people say "GCC" in the context of C programming, they typically mean the gcc command-line tool that compiles C source code into executable programs.

Why GCC is Important

• Free and Open Source — Available at no cost under the GPL license
• Cross-Platform — Works on Linux, macOS, Windows (via MinGW/MSYS2), and many other systems
• Standards Compliant — Supports C89, C99, C11, C17, and C23 standards
• Industry Standard — Used to compile the Linux kernel, Git, Python interpreter, and thousands of other projects
• Powerful Optimization — Includes advanced optimization capabilities for producing fast executables

Basic GCC Usage

The simplest way to compile a C program with GCC:

This produces an executable named a.out (on Linux/macOS) or a.exe (on Windows). To specify a custom output name:

Now you can run it with ./program on Linux/macOS or program.exe on Windows.

The Four Stages of Compilation

GCC doesn't convert your source code to an executable in a single step. It goes through four distinct stages, and understanding these stages will make you a better programmer and debugger.

Stage 1: Preprocessing (-E)

The preprocessor handles all directives that start with #:

• Expands #include directives (inserts header file contents)
• Replaces #define macros with their values
• Evaluates #ifdef / #ifndef conditional compilation
• Removes comments

The output .i file contains the expanded source code. For a simple Hello World program, this file can be thousands of lines long because the entire stdio.h header (and its dependencies) gets included.

Stage 2: Compilation (-S)

The compiler takes the preprocessed source code and converts it into assembly language specific to your target architecture (x86, ARM, etc.).

You can open the .s file to see the assembly instructions. This is useful for understanding how the CPU will actually execute your code.

Stage 3: Assembly (-c)

The assembler converts the assembly language into machine code (binary object file). This file contains the actual instructions that the CPU understands, but it's not yet a complete executable.

The .o file (object file) contains machine code but may have unresolved references to external functions (like printf from the C library).

Stage 4: Linking

The linker takes one or more object files and combines them with library code (like the C standard library) to produce the final executable.

During linking, all external function calls are resolved — the linker finds where printf actually lives in the C library and connects your code to it.

Essential GCC Flags and Options

Compilation Control Flags

Warning Flags

Warnings help you catch potential bugs and write cleaner code. Always compile with warnings enabled!

Recommended command for development:

This forces you to write clean, warning-free code — a great habit to build early.

C Standard Selection

You can tell GCC which version of the C standard to use:

Optimization Levels

GCC can optimize your code to run faster or use less memory:

Debugging Flags

Compiling Multiple Files

Real projects usually have multiple source files. GCC handles this easily:

The second approach is preferred for large projects because you only need to recompile files that changed — this is the basis of how make and build systems work.

Linking with Libraries

Standard Math Library

The math library (libm) needs to be explicitly linked:

The -l flag tells the linker to search for a library. -lm means "link with libm" (the math library).

Custom Libraries

Checking GCC Version

gcc (Ubuntu 13.2.0-23ubuntu4) 13.2.0
Copyright (C) 2023 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.

To see detailed configuration:

Useful GCC Commands for Students

GCC vs Other Compilers

Common GCC Errors and Solutions

Undefined Reference

undefined reference to 'sqrt'

Solution: Link with the math library: gcc prog.c -o prog -lm

No Such File or Directory

fatal error: myheader.h: No such file or directory

Solution: Use -I to specify the include path: gcc -I./includes prog.c -o prog

Implicit Declaration Warning

warning: implicit declaration of function 'myFunc'

Solution: Include the proper header file or add a function prototype before use.

Interview Questions

Q1: What are the four stages of GCC compilation?

The four stages are: (1) Preprocessing — handles #include, #define, removes comments; (2) Compilation — converts preprocessed code to assembly language; (3) Assembly — converts assembly to machine code (object files); (4) Linking — combines object files with libraries to create the final executable. You can stop at any stage using flags -E, -S, -c respectively.

Q2: What is the difference between -O2 and -O3 optimization levels?

-O2 enables standard optimizations that improve performance without significantly increasing binary size or compilation time. -O3 enables all -O2 optimizations plus additional aggressive ones like function inlining, loop vectorization, and loop unrolling. -O3 may produce faster code but can increase binary size and occasionally cause issues with floating-point precision or code that relies on undefined behavior.

Q3: Why should you compile with -Wall -Wextra flags?

These flags enable comprehensive warning messages that help catch potential bugs, uninitialized variables, unused parameters, type mismatches, and other issues at compile time rather than runtime. -Wall enables common warnings while -Wextra adds additional checks. Using these flags promotes writing cleaner, more portable, and more reliable code.

Q4: What is the difference between static and dynamic linking?

Static linking (-static) copies all library code directly into the executable, making it self-contained but larger. Dynamic linking (default) references shared libraries (.so on Linux, .dll on Windows) at runtime, producing smaller executables but requiring the libraries to be present on the system. Static linking is portable; dynamic linking saves memory when multiple programs use the same library.

Q5: What does the -g flag do in GCC?

The -g flag tells GCC to include debugging information (symbol tables, line numbers, variable names) in the compiled binary. This information is used by debuggers like GDB to map machine instructions back to source code lines, allowing you to set breakpoints, inspect variables, and step through code during debugging sessions. It increases binary size but has no effect on runtime performance.

Summary

• GCC (GNU Compiler Collection) is the industry-standard open-source compiler for C programming
• Compilation involves four stages: preprocessing, compilation, assembly, and linking
• Always use -Wall -Wextra during development to catch potential bugs early
• Use -g flag when you need to debug with GDB
• Optimization levels range from -O0 (none) to -O3 (aggressive)
• Use -std=c11 or -std=c17 to specify which C standard to follow
• Link external libraries with -l flag (e.g., -lm for math)
• Multiple source files can be compiled separately and linked together
• GCC is available on all major platforms and is essential knowledge for any C programmer

Mastering GCC flags and options will make you significantly more productive as a C programmer. Start with the basics (-Wall -o), and gradually incorporate more flags as your programs grow in complexity.