Makefiles and Build Systems

Make is a build automation tool that tracks file dependencies and only recompiles what changed. A Makefile defines targets, their dependencies, and the commands to build them.

Why It Matters

Real C projects have dozens of source files. Recompiling everything after changing one file wastes time. Make’s dependency graph means editing utils.c only recompiles utils.o and relinks — not the entire project. Understanding Make also helps you read build systems in any C/C++ project.

Makefile Anatomy

CC = gcc
CFLAGS = -Wall -Wextra -O2 -g
LDFLAGS = -lm
 
SRCS = main.c utils.c parser.c
OBJS = $(SRCS:.c=.o)
 
# Default target (first rule)
program: $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
 
# Pattern rule: how to build any .o from its .c
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@
 
clean:
	rm -f $(OBJS) program
 
.PHONY: clean

Automatic Variables

Variable	Meaning	Example
$@	Target name	program
$<	First dependency	main.c
$^	All dependencies	main.o utils.o parser.o
$*	Stem of pattern match	main (from main.o)

Key gcc Flags

Flag	Purpose
-Wall -Wextra	Enable warnings (always use)
-O2	Optimize for speed
-g	Debug symbols for GDB
-fsanitize=address	AddressSanitizer — catches memory bugs at runtime
-MMD -MP	Generate dependency files (see below)
-I./include	Add header search path
-static	Static linking (self-contained binary)
-lm	Link math library

Automatic Dependency Tracking

Header changes should trigger recompilation. Use -MMD -MP to auto-generate .d files:

CFLAGS += -MMD -MP
DEPS = $(OBJS:.o=.d)
 
-include $(DEPS)   # include if they exist, ignore if not

This generates main.d containing something like:

main.o: main.c utils.h parser.h

Now changing utils.h correctly rebuilds main.o.

Static vs Dynamic Linking

Aspect	Static (.a)	Dynamic (.so)
Binary size	Larger — code copied in	Smaller — loaded at runtime
Deployment	Self-contained	Needs library on target system
Updates	Must recompile to update lib	Just replace .so file
Load time	Faster (no dynamic linking)	Slightly slower

# Create and use static library
ar rcs libutils.a utils.o parser.o
gcc main.c -L. -lutils -o program
 
# Create and use shared library
gcc -shared -fPIC -o libutils.so utils.c parser.c
gcc main.c -L. -lutils -o program
# At runtime: LD_LIBRARY_PATH=. ./program

Complete Project Example

CC      = gcc
CFLAGS  = -Wall -Wextra -O2 -g -MMD -MP
LDFLAGS =
 
SRC_DIR = src
OBJ_DIR = build
SRCS    = $(wildcard $(SRC_DIR)/*.c)
OBJS    = $(SRCS:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)
DEPS    = $(OBJS:.o=.d)
TARGET  = program
 
$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
 
$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c | $(OBJ_DIR)
	$(CC) $(CFLAGS) -c $< -o $@
 
$(OBJ_DIR):
	mkdir -p $@
 
clean:
	rm -rf $(OBJ_DIR) $(TARGET)
 
-include $(DEPS)
.PHONY: clean

Related

• C Language Essentials — compilation pipeline that Make automates
• Debugging with GDB — use -g -O0 flags for debugging builds
• System Calls — linking against libraries that wrap syscalls