⁠

One command, four stages, and a surprisingly interesting journey from C code to a working program.

When I started learning C at Holberton School, I noticed something: GCC seemed to appear everywhere.

gcc -E, gcc -S, gcc -c…

Same three letters, different commands, and somehow different files appearing every time.

As someone coming from a business background, I had a simple question:

Why do we need all these steps just to make a computer run our code?

So I decided to look beyond the commands and understand what actually happens behind the scenes.

And it turns out that typing gcc main.c starts an entire production process.

First, Meet GCC

GCC stands for GNU Compiler Collection.

It’s a collection of tools that helps translate programming languages, including C, into instructions a computer can execute.

Think of GCC as a factory.

You provide the raw material (your C code), and GCC coordinates the steps needed to turn it into a finished product (an executable program).

And like any production process, there are stages.

Here’s the journey:

main.c → Preprocessing → Compilation → Assembly → Linking → Executable

Let’s follow a simple program through each one.

Our Starting Point: A C Program

Imagine we write this inside a file called main.c:

#include <stdio.h>

int main(void)
{
    puts("Hello, world!");
    return 0;
}

Nothing complicated. We just want to display Hello, world!.

But here’s the catch: writing a C program doesn’t automatically make it runnable.

The computer needs it translated into machine instructions first.

That’s GCC’s job.

1. Preprocessing: Preparing the Ingredients

Before GCC can translate our C code, it needs to prepare it.

That’s what the preprocessor does.

For example, remember this line?

#include <stdio.h>

It tells the preprocessor to include the contents of the header file, making declarations such as puts available to the compiler.

The preprocessor also handles macros (code substitutions) and conditional compilation instructions.

To see the result, we use:

gcc -E main.c -o main.i

Here’s what we’re saying:

• gcc — Use GCC.
• -E — Stop after preprocessing.
• main.c — Read our original file.
• -o main.i — Save the result as main.i.

The .i extension is commonly used for preprocessed C code.

Our result: main.i — preprocessed C code, but not yet a runnable program.

2. Compilation: Translating the Instructions

Now the actual translation begins.

The compiler converts the preprocessed C code into assembly language.

Assembly is a low-level language that describes operations much closer to what a processor understands.

To generate assembly, we use:

gcc -S main.i -o main.s

Notice the capital S!

It tells GCC to stop after generating assembly code.

Open main.s, and you may see instructions such as mov, call, and ret, depending on your computer's processor architecture.

They probably won’t look like the C code we started with.

And that’s the point: we’re getting closer to the machine’s language.

Our result: main.s — assembly instructions.

But we’re not finished yet.

3. Assembly: Creating Machine Code

Here’s where things get interesting.

The previous stage produced assembly language, which is still readable text.

Now the assembler transforms those instructions into machine code.

Machine code is the binary representation of instructions that a processor can execute.

We can produce an object file using:

gcc -c main.s -o main.o

The lowercase -c tells GCC to compile or assemble the source into an object file without linking it.

And .o means object file.

If you try opening main.o in an ordinary text editor, you'll probably see strange symbols.

That’s because an object file contains machine code and other technical information, not normal text.

But wait.

If we already have machine code, why can’t we run it?

Because an object file isn’t necessarily a complete program. It may still contain unresolved references to functions and other code.

Which brings us to the final stage.

4. Linking: Putting Everything Together

Imagine organizing a business event.

You’ve prepared the speakers, venue, schedule, and equipment. Everything exists, but it still needs to work together.

That’s similar to what the linker does.

Our program uses puts, which is provided by the C standard library.

The linker resolves references to external functions and combines the required object files and libraries to produce the final executable.

Let’s finish:

gcc main.o -o hello

We’ve now created an executable named hello.

Time to run it:

./hello

And the result?

Hello, world!

Finally!

We went from a C file to a working program.

So Why Do We Usually Just Type gcc main.c?

Here’s the best part.

We don’t need to run each stage separately every time.

When we type:

gcc main.c

GCC normally coordinates all four stages automatically.

On Ubuntu, the default executable is named a.out, unless we choose another name.

We can run it with:

./a.out

One distinction worth remembering:

gcc main.c builds the program.

./a.out runs the program.

They are two completely different actions.

The GCC Cheat Sheet I Wish I Had Earlier

CommandMeaningResultgcc -E main.c -o main.iPreprocess onlymain.igcc -S main.i -o main.sGenerate assemblymain.sgcc -c main.s -o main.oAssemble without linkingmain.ogcc main.o -o helloLink the object filehellogcc main.cRun all stages automaticallya.outgcc main.c -o helloBuild with a chosen executable namehello./helloRun the executableProgram output

A tiny detail that makes a big difference: -S and -c are GCC options, while .s, .c, and .o are file extensions. Similar letters, completely different purposes.

My Biggest Takeaway

At first, I thought gcc main.c was just another command I needed to memorize.

But now I see it differently.

Our C code doesn’t magically become a working program. It moves through a series of transformations, and each stage solves a specific problem.

That’s what makes understanding the process more useful than memorizing the commands.

And I think that’s one of the most interesting things about learning computer science: behind every simple action, there’s usually a whole system working together.

So next time I type gcc main.c, I'll know there's much more happening behind those few characters.

One command. Four stages. A working program.

Further reading: GCC Official Documentation — Overall Options

Part of my C programming learning journey at Holberton School.