[中文版本](/posts/c教程/zh-CN/06-编译与构建/058-Compiler Flags and Optimization Levels)

Once your program compiles and links correctly, the next step is mastering compiler flags, the switches that control warnings, debugging info, optimization, and performance.

Using the right flags can make your C code safer, faster, and easier to debug.

Let’s go through the essentialgcc andclang options every C developer should know.

Step 1. The Basic Compilation Command

The most common compile command looks like:

gcc main.c -o main

This compilesmain.c into an executable calledmain using default settings, minimal warnings, no optimization, and no debug info.

For serious development, you’ll want more control.

Step 2. Warning Flags

Warnings are the compiler’s early-warning system. They catch mistakes before they become bugs.

Flag	Meaning
-Wall	Enable most common warnings
-Wextra	Enable additional, stricter warnings
-Werror	Treat warnings as errors
-Wpedantic	Enforce strict ISO C compliance
-Wshadow	Warn if a local variable hides another variable
-Wconversion	Warn about implicit type conversions
-Wunused	Warn about unused variables or functions

Example:

gcc -Wall -Wextra -Werror main.c -o main

If your code has:

int x;
printf("%d\n", x);

You’ll get:

warning: 'x' is used uninitialized

With-Werror, that warning becomes a build-stopping error, a good habit for clean codebases.

Step 3. Debugging Flags

Debugging information allows tools likegdb orlldb to map machine code back to your C source.

Flag	Description
-g	Include debug symbols (file names, line numbers)
-ggdb	Include GNU-specific symbols for gdb
-O0	Disable optimization (makes debugging easier)

Example:

gcc -g -O0 main.c -o main

Now run:

gdb ./main

You’ll be able to inspect variables and step through source lines.

Step 4. Optimization Levels

Optimization tells the compiler how aggressively to transform your code for speed or size.

Flag	Description
-O0	No optimization (fast compile, easy to debug)
-O1	Basic optimization
-O2	General speed optimization (default for most builds)
-O3	Aggressive optimization (may increase size)
-Os	Optimize for size
-Ofast	Ignore strict standards for speed (dangerous)

Example:

gcc -O2 main.c -o main

Compare sizes:

gcc -O0 main.c -o slow
gcc -O2 main.c -o fast
ls -lh slow fast

fast will be smaller and run faster, the compiler reorders code, inlines functions, and removes dead logic.

Step 5. Profiling and Instrumentation Flags

Profiling helps measure which parts of your program consume the most CPU time.

Flag	Purpose
-pg	Generate profiling data forgprof
-fprofile-generate/-fprofile-use	Use profile-guided optimization (PGO)
-ftime-report	Show how long each compilation phase took

Example:

gcc -pg main.c -o main
./main
gprof main gmon.out > report.txt

Step 6. Standards Compliance Flags

The C language evolves, you can specify which version to follow.

Flag	Meaning
-std=c89	ANSI C (1989)
-std=c99	Modern C withinline,bool,// comments
-std=c11	Adds_Generic,_Thread_local, safer atomics
-std=c17	Minor cleanup
-std=c23	Latest (addstypeof, safer macros, etc.)

Example:

gcc -std=c99 -Wall main.c -o main

Always choose a consistent standard for your project.

Step 7. Platform and Architecture Flags

Flag	Description
-m32/-m64	Compile for 32-bit or 64-bit architecture
-march=native	Optimize for the host CPU
-fPIC	Position-independent code (required for shared libraries)
-static	Fully static linking
-DNAME=value	Define a macro (same as#define in code)

Example:

gcc -DDEBUG=1 -O2 -m64 main.c -o main

Step 8. Linking Flags

Flag	Description
-L	Add library search path
-l	Link with library (e.g.,-lm for math)
-static	Force static linking
-shared	Build a shared library
-rpath	Add runtime library search path

Example:

gcc main.o -L. -lmylib -Wl,-rpath=. -o app

-Wl, passes options directly to the linker (ld).

Tiny Code: Debug and Release Builds

Makefile

CC = gcc
CFLAGS = -Wall -std=c99
DEBUG_FLAGS = -g -O0 -DDEBUG
RELEASE_FLAGS = -O2 -DNDEBUG
SRC = main.c util.c
OBJ = $(SRC:.c=.o)
TARGET = app
debug: CFLAGS += $(DEBUG_FLAGS)
debug: $(TARGET)
release: CFLAGS += $(RELEASE_FLAGS)
release: $(TARGET)
$(TARGET): $(OBJ)
    $(CC) $(CFLAGS) $(OBJ) -o $(TARGET)
%.o: %.c
    $(CC) $(CFLAGS) -c $< -o $@
clean:
    rm -f $(OBJ) $(TARGET)

Run:

make debug
make release

• Debug build: full symbols, no optimization.
• Release build: optimized, no debugging info.

Step 9. Sanitizers (Runtime Safety Tools)

Modern compilers include built-in sanitizers to detect memory and thread errors:

Flag	Detects
-fsanitize=address	Memory leaks, buffer overflows
-fsanitize=undefined	Undefined behavior
-fsanitize=thread	Data races in multithreaded code

Example:

gcc -g -fsanitize=address main.c -o main
./main

If your code writes past an array boundary, you’ll get an instant, readable report, no guessing.

Step 10. Combining Flags

Typical development build:

gcc -Wall -Wextra -Werror -g -O0 -std=c99 main.c -o debug_app

Typical release build:

gcc -O2 -march=native -flto -DNDEBUG main.c -o fast_app

• -flto enables link-time optimization (LTO), optimizing across files.
• -DNDEBUG disablesassert() calls.

Why It Matters

Compiler flags are how professionals control:

• Safety (warnings, sanitizers)
• Performance (optimization levels)
• Debuggability (symbols and checks)
• Portability (standards and architectures)

Mastering them gives you precise control over how your code behaves, builds, and performs, essential for reliable systems programming.

Try It Yourself

1. Compile the same program with-O0,-O2, and-O3, time each run.
2. Add-fsanitize=address and find hidden memory bugs.
3. Compare binary sizes between-g and-s.
4. Add-Wall -Wextra -Werror to your Makefile and fix every warning.
5. Exploregcc --help=optimizers to see all available optimization passes.

Next, you’ll peek inside the object file itself, learning what’s stored inside.o binaries and how the linker stitches them together to form a complete executable.