From Source to Running Program: Preprocessor, Compiler, Linker

Three things happened, and each one tells you what the preprocessor is.

• SIDE became 7. Both times. That is all #define does: replace a name with a piece of text.
• SIDE SIDE became 7 7, and not 49. The preprocessor does not do arithmetic. It moved text around and stopped. The multiplication is the compiler's job, and in fact the compiler does it before the program ever runs, because both operands are constants.
• #include and #define are gone, along with the blank line structure, replaced by line markers like # 5 "area.c" that let the compiler report errors against your file rather than against the 554-line stream.

If a comment had been in the file, it would be gone too. The preprocessor removes comments, which is why a comment costs nothing at run time.

Stage 2: the compiler

cc -std=c17 -S area.c -o area.s

-S means stop after compiling, and leave the result as assembly language: text, one instruction per line, for one specific processor. The nine-line program becomes 35 lines of it, beginning like this:

$ sed -n '1,11p' area.s
	.arch armv8-a
	.file	"area.c"
	.text
	.section	.rodata
	.align	3
.LC0:
	.string	"Area of a square of side %d is %d\n"
	.text
	.global	main
	.type	main, %function
main:

You are not expected to read assembly on this paper. Three things in it are worth seeing once.

.arch armv8-a names the processor family. This listing was produced on arm64, and the same program compiled in a lab with an Intel processor produces a different listing that does the same thing. Assembly is not portable; C is. That is the whole argument for a compiled high-level language.

.string "Area of a square of side %d is %d\n" is your text, stored as data. The format string was not turned into instructions, because it is not an instruction. It is a run of characters the program will hand to printf.

main: is a label, and it marks the place where your function's instructions begin. The linker will later look for exactly that name.

Stage 3: the assembler

cc -std=c17 -c area.c -o area.o

-c means compile and assemble, but do not link. The result is an object file, and it is the first thing in this chain you cannot read as text: it holds machine code. What you can read is its table of names, with nm:

$ nm area.o
0000000000000000 T main
                 U printf

Two lines, and they are the whole idea of linking.

• T main means this file defines a function called main, in its text (code) section, at offset 0. T is for text.
• U printf means this file uses a function called printf and does not define it. U is for undefined. There is a hole in the machine code where a call to printf should go, and this file cannot fill it.

The object file is 1,648 bytes on the machine that produced these numbers. Your own will differ, and the number does not matter. What matters is that it is small, because it holds your nine lines and nothing else.

Stage 4: the linker

cc -std=c17 area.o -o area

Now the hole gets filled. The linker takes your object file, finds printf in the standard C library, copies in the machine code for it and for everything printf itself needs, adds the small piece of start-up code that calls main for you, and writes one executable file.

$ stat -c %s area
70312
$ ./area
Area of a square of side 7 is 49

1,648 bytes of object file became a 70,312 byte program. Your nine lines are a tiny fraction of what you are running, and the rest is library and start-up code you did not write and did not have to.

All four in one command

cc -std=c17 -Wall -Wextra area.c -o area

This is what you will actually type. It runs the preprocessor, the compiler, the assembler and the linker in order, keeps none of the intermediate files, and stops at the first stage that fails. -o area names the output; without it the program is called a.out, which is a habit from the earliest Unix and has stuck for fifty years.

Then run it. The ./ is not decoration: it means "in this directory", and without it the shell looks for area in the standard places and does not find it.

./area

Which stage caught your mistake

This is the useful half of the chapter. An error message tells you which tool is complaining, and therefore what kind of thing is wrong. All five below are real messages from gcc 13.3.

The preprocessor cannot find a header. Misspell stdio.h and the chain stops before any C is looked at:

$ cc -std=c17 e1.c -o e1
e1.c:1:10: fatal error: stdioo.h: No such file or directory
    1 | #include <stdioo.h>
      |          ^~~~~~~~~~

The compiler finds a broken statement. Leave out a semicolon and the compiler complains, and notice where: it names line 5, although the missing semicolon is on line 4. The compiler discovered the problem when it read the next thing that could not follow.

$ cc -std=c17 e2.c -o e2
e2.c: In function 'main':
e2.c:5:5: error: expected ',' or ';' before 'return'
    5 |     return a;
      |     ^~~~~~

The linker cannot find a definition. Declare a function, call it, and never write it. Nothing is wrong with your C, so the compiler is satisfied, and the linker is the one that objects:

$ cc -std=c17 e3.c -o e3
/usr/bin/ld: in function `main':
e3.c:(.text+0xc): undefined reference to `twice'
collect2: error: ld returned 1 exit status

The linker cannot find main. Compile a file with functions but no main, and the start-up code is the thing left with a hole:

$ cc -std=c17 e4.c -o e4
(.text+0x1c): undefined reference to `main'
collect2: error: ld returned 1 exit status

A warning is not an error, and matters more. Delete #include <stdio.h> and the program still links and still runs, and gcc tells you that you are calling a function it knows nothing about:

$ cc -std=c17 -Wall -Wextra nohdr.c -o nohdr
nohdr.c:6:5: warning: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
nohdr.c:1:1: note: include '<stdio.h>' or provide a declaration of 'printf'

That is the class of mistake -Wall -Wextra exists to surface. Compile with them always. A program that runs today with a warning is a program that breaks on somebody else's compiler.

What this does NOT mean

The compiler does not produce a runnable program. It produces an object file with holes in it. Only the linker produces something you can run. Saying "the compiler turns C into an executable" is the single commonest error on this topic.

A header is not a library. stdio.h is text: declarations telling the compiler what printf looks like. The machine code for printf lives in a compiled library and is joined on by the linker. This is why a missing header gives a compiler warning while a missing library gives a linker error.

The preprocessor is not part of the C language. It has its own grammar, does not understand types, expressions or scope, and would happily replace a name inside something you never meant. Chapter 22 shows what that costs.

An interpreter is not doing this. In an interpreted language there is no separate translation step and no executable. C compiles ahead of time, which is why a C program starts instantly and why you must compile again after every edit.

cc and gcc are not necessarily different programs. On the machine these transcripts came from, cc is gcc 13.3 reached through another name. On a Mac, cc is usually clang. cc is the portable name, which is why this book uses it.

Quick revision

• Four stages in order: preprocessor, compiler, assembler, linker.
• Preprocessor: text only. Pastes #include, substitutes #define, strips comments. No arithmetic, no type checking. Stop after it with -E.
• Compiler: checks the C and emits assembly for one processor. Stop after it with -S.
• Assembler: assembly text into machine code, giving an object file. Stop after it with -c.
• Linker: joins object files and libraries, resolves every undefined name, adds start-up code, writes the executable.
• nm on an object file shows T name for defined and U name for used but undefined.
• undefined reference is always the linker. expected ';' is always the compiler.
• cc -std=c17 -Wall -Wextra file.c -o file then ./file.

Test yourself

1. Put these in order and say what each produces: linker, assembler, preprocessor, compiler.

Preprocessor, giving expanded C text. Compiler, giving assembly. Assembler, giving an object file. Linker, giving an executable.

2. You get undefined reference to 'average'. Which stage failed, and what are the two likely causes?

The linker. Either you declared or called average and never defined it, or its definition is in another file or library that you did not include in the link command.

3. A program prints the wrong answer. Which stage will find the bug?

None. Every stage succeeded; the program you described is the program you wrote. This is what tracing by hand and testing are for.

4. What does -E do, and why is the output so much longer than the input?

It stops after preprocessing. The output is longer because #include <stdio.h> pastes the whole header in, which is several hundred lines of declarations.

5. After #define N 5, does N * N reach the compiler as 25?

No. It reaches the compiler as 5 * 5. The preprocessor substitutes text and does no arithmetic. The compiler then works out 25 while compiling, because both operands are constants.

6. Why does ./area need the ./?

Because the shell searches only a fixed list of directories for a command name, and the current directory is not normally on that list. ./area says explicitly which file to run.

What can be asked on this, and how to answer it

"Explain the compilation and execution of a C program." Name the four stages in order, say what each takes in and gives out, and name the file at each boundary: .c, then expanded text, then .s, then .o, then the executable. Finish with the run step. A diagram of five boxes and four arrows earns the marks quickly; label the arrows with the tool and the boxes with the file.

"What is the role of the linker?" To resolve names. It joins your object files with the library code for every function you used but did not write, adds the start-up code that calls main, and produces a single executable. Give undefined reference as the error it reports when it cannot.

"Distinguish between the compiler and the interpreter." A compiler translates the whole program once, ahead of time, into machine code, which then runs on its own and runs fast; errors in the whole file are reported before anything runs. An interpreter translates and executes statement by statement every time the program runs, needs the interpreter present to run at all, and reports an error only when execution reaches it.

"What is the purpose of the preprocessor?" To process the file as text before compilation: insert headers, substitute defined names, select code conditionally, and remove comments. Say plainly that it does not understand C, because that is the part examiners are testing.

"A header file and a library file, distinguish." A header is source text holding declarations, read by the compiler so it can check your calls. A library is compiled machine code holding definitions, read by the linker so your calls have something to reach. stdio.h against the C standard library is the example to give.