GNU Make Mastery Part 3: Variables, Expansion & Scope

Sample Source Files

main.c

/* main.c — entry point */
#include <stdio.h>
#include "utils.h"

int main(void) {
    utils_greet("Make Variables");
    return 0;
}

utils.h

/* utils.h — declarations */
#ifndef UTILS_H
#define UTILS_H
void utils_greet(const char *name);
#endif

utils.c

/* utils.c — implementations */
#include <stdio.h>
#include "utils.h"

void utils_greet(const char *name) {
    printf("Hello from %s!\n", name);
}

network.c

/* network.c — stub network layer */
#include <stdio.h>

void net_connect(const char *host, int port) {
    printf("Connecting to %s:%d ...\n", host, port);
}

void net_disconnect(void) {
    printf("Disconnected.\n");
}

Assignment Operators

Conditional Assignment (?=)

Sets the variable only if it has not already been set (including by the environment or CLI). This is ideal for providing defaults that users can override.

# Set defaults that the caller can override
CC      ?= gcc          # use gcc unless CC is already in the environment
PREFIX  ?= /usr/local   # default install prefix
BUILD   ?= debug        # default build type

# Usage: make BUILD=release PREFIX=/opt/myapp

Append Operator (+=)

Appends to an existing variable with a single space separator. If the variable was previously defined with :=, append uses simple expansion. If with =, it remains recursive.

CFLAGS  := -Wall -Wextra        # start with base flags
CFLAGS  += -std=c11             # += appends with a space → -Wall -Wextra -std=c11
CFLAGS  += -g                   # append again → -Wall -Wextra -std=c11 -g

SRCS    := main.c utils.c       # initial source list
SRCS    += network.c            # add another file → main.c utils.c network.c

CLI Overrides & Environment

Variables set on the Make command line override assignments inside the Makefile (unless the Makefile uses override). This is how you pass build configuration without editing the Makefile.

# In the Makefile:
CC      ?= gcc
CFLAGS  := -Wall -O2
BUILD   ?= debug

ifeq ($(BUILD),release)
    CFLAGS += -O3 -DNDEBUG
else
    CFLAGS += -g -DDEBUG
endif

# Override from CLI:
make CC=clang                        # use Clang instead of GCC
make BUILD=release                   # enable release optimisation
make CC=arm-linux-gnueabihf-gcc BUILD=release   # cross-compile release

# Force override even if Makefile uses override keyword:
make CFLAGS="-O0 -g3"

Environment Variable Export

# Export a variable to all sub-make processes and shell commands
export BUILD_DIR := $(CURDIR)/build
export PATH      := $(PATH):/opt/toolchain/bin

# Export all Make variables to the environment
.EXPORT_ALL_VARIABLES:

# Unexport a specific variable
unexport SENSITIVE_TOKEN

Scoped Variables

Target-Specific Variables

Variables can be scoped to a specific target (and its prerequisites). They override global values within that target's recipe.

CFLAGS := -Wall -O2              # global flags used by all targets

# Override CFLAGS only for the debug target (and its prerequisites)
debug: CFLAGS := -Wall -O0 -g -DDEBUG   # target-specific: replaces global value
debug: myapp
	@echo "Built debug version with $(CFLAGS)"

# Override for a single object file only
special.o: CFLAGS += -fno-strict-aliasing  # appends to global; relaxes aliasing rules
special.o: special.c
	$(CC) $(CFLAGS) -c $< -o $@             # $< = special.c, $@ = special.o

Pattern-Specific Variables

Like target-specific variables, but applied to all targets matching a pattern.

# All .o files compiled from test_*.c get extra sanitizer flags
test_%.o: CFLAGS += -fsanitize=address,undefined

# All .o files get position-independent code flag
%.o: CFLAGS += -fPIC

Multiline Variables (define/endef)

define/endef defines a variable containing newlines — useful for reusable command sequences (macros) that can be called or expanded inline.

# Define a reusable compilation macro (multi-line variable)
define COMPILE_C
@echo "  CC  $@"                 # $@ expands to the target filename at recipe time
$(CC) $(CFLAGS) -c $< -o $@    # $< expands to the first prerequisite (.c file)
endef

# Use it in a pattern rule — $(COMPILE_C) expands to both lines above
%.o: %.c
	$(COMPILE_C)

# Multi-line variable for a build banner
define BUILD_BANNER
@echo "=============================="
@echo " Building $(TARGET) v$(VERSION)"   # variables expanded when the macro runs
@echo "=============================="
endef

all: $(TARGET)
	$(BUILD_BANNER)              # expands the entire 3-line block into this recipe

Hands-On Milestone

# Parameterised Makefile — try: make, make BUILD=release, make CC=clang BUILD=release

# ── Variables (? = set only if not already defined on CLI) ──
CC      ?= gcc                   # allow caller to override compiler
BUILD   ?= debug                 # default build type
TARGET  := myapp
SRCS    := main.c utils.c
OBJS    := $(SRCS:.c=.o)         # .c → .o substitution

# ── Common flags ────────────────────────────────────
CFLAGS  := -Wall -Wextra -std=c11

# ── Build-type flags (chosen by ifeq conditional) ──
ifeq ($(BUILD),release)
    CFLAGS  += -O3 -DNDEBUG      # max optimisation, disable assert()
    LDFLAGS += -s                # strip symbols from binary
else
    CFLAGS  += -O0 -g3 -DDEBUG  # no optimisation, full debug info
endif

.PHONY: all clean info

# ── Default target ──
all: $(TARGET)

# ── Link ──
$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^   # $@ = target, $^ = all .o files

# ── Compile (pattern rule: any .c → .o) ──
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@           # $< = the .c source file

clean:
	rm -f $(TARGET) $(OBJS)

info:
	@echo "CC      = $(CC)"
	@echo "BUILD   = $(BUILD)"
	@echo "CFLAGS  = $(CFLAGS)"
	@echo "LDFLAGS = $(LDFLAGS)"
	@echo "TARGET  = $(TARGET)"
	@echo "SRCS    = $(SRCS)"
	@echo "OBJS    = $(OBJS)"

# --- Try different configurations ---
make                              # default: debug build with gcc
make info                         # display all variable values
make BUILD=release                # optimised release build
make BUILD=release info           # see release flags
make CC=clang BUILD=release       # use clang with release flags
make CC=clang BUILD=release info  # verify clang + release settings
make clean                        # remove artefacts