GNU Make Mastery Part 16: Ecosystem, Alternatives & Professional Mastery

Sample Source Files

utils.h

/* utils.h */
#ifndef UTILS_H
#define UTILS_H
void utils_greet(const char *name);
int  utils_add(int a, int b);
#endif

utils.c

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

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

int utils_add(int a, int b) { return a + b; }

main.c

/* main.c — identical source, built by every tool in this part */
#include <stdio.h>
#include "utils.h"

int main(void) {
    utils_greet("Modern Build Tools");
    printf("3 + 4 = %d\n", utils_add(3, 4));
    return 0;
}

CMake

CMake is a meta-build system — it generates Makefiles, Ninja build files, Visual Studio project files, and others from a high-level CMakeLists.txt. It does not build code itself.

Modern CMake (Target-Based)

Post-CMake 3.0 ("Modern CMake") uses targets and properties rather than global variables:

cmake_minimum_required(VERSION 3.20)
project(MyApp VERSION 1.0 LANGUAGES C)

# Create an executable target
add_executable(myapp src/main.c src/utils.c)

# Everything attached to the target — no global CFLAGS
target_compile_options(myapp PRIVATE -Wall -Wextra -O2)
target_compile_definitions(myapp PRIVATE VERSION="${PROJECT_VERSION}")
target_include_directories(myapp PRIVATE include/)

# Linking — deps propagate transitively
target_link_libraries(myapp PRIVATE m pthread)

# Configure (generate Makefiles or Ninja files)
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release

# Build
cmake --build build -j$(nproc)

# Install
cmake --install build --prefix /usr/local

CMake vs Make

Ninja

Ninja is a minimal build system designed for speed. It was created by Evan Martin at Google specifically as a Make replacement for the Chromium build — which at the time was taking 10+ minutes just for dependency checking.

Why Ninja Is Fast

# A minimal hand-written build.ninja
rule cc
  command = gcc -MMD -MF $out.d $in -c -o $out
  depfile = $out.d
  deps = gcc

build src/main.o: cc src/main.c
build src/utils.o: cc src/utils.c

rule link
  command = gcc $in -o $out

build myapp: link src/main.o src/utils.o

ninja -j$(nproc)         # build
ninja -t clean           # clean
ninja -t deps src/main.o # show deps for a target

Meson

Meson is a modern meta-build system with a clean Python-inspired syntax, automatic dependency detection, and Ninja as its default backend. It targets developer ergonomics: fast configure times, simple syntax, and first-class cross-compilation support.

Meson Workflow

# meson.build — the equivalent of CMakeLists.txt
project('myapp', 'c', version: '1.0', default_options: ['c_std=c11'])

executable('myapp',
    sources: ['src/main.c', 'src/utils.c'],
    include_directories: include_directories('include'),
    c_args: ['-Wall', '-Wextra'],
    install: true
)

# Setup (one-time, like cmake -S . -B build)
meson setup builddir

# Build
meson compile -C builddir

# Test
meson test -C builddir

# Install
meson install -C builddir

Bazel

Bazel (open-source version of Google's Blaze) is a hermetic, scalable build system designed for monorepos with millions of lines of code. It builds everything in sandboxed environments to guarantee reproducibility, and supports remote execution across build farms.

Hermetic Builds & Remote Execution

cc_binary(
    name = "myapp",
    srcs = ["src/main.c", "src/utils.c"],
    hdrs = ["include/utils.h"],
    copts = ["-Wall", "-Wextra"],
    deps = ["//lib/net:netlib"],
)

Key Bazel concepts:

• Hermeticity: All inputs must be declared. Undeclared files (including /usr/include headers) are invisible inside the build sandbox — guaranteeing that the build result is identical on any machine.
• Remote execution: Build actions ship to a cluster of workers (--remote_executor), caching outputs by content hash. Large monorepos cut clean build times from hours to minutes.
• Multi-language: The same BUILD file can combine C, C++, Java, Python, Go, and Protobuf rules.
• Starlark: Bazel's configuration language (Python subset) is stricter and more readable than CMake's language, albeit with a steep learning curve.

Full Comparison Table

When to Migrate from Make

When to Stay on Make

Migration Signals

Production-Grade Capstone Makefile

Structure Overview

The following Makefile integrates all 16 parts of this series into a single reference implementation. It handles a multi-module C project with:

• Out-of-source build/ directory (Part 9)
• Automatic header dependency generation (Part 7)
• Static and shared library targets (Part 8)
• Parallel-safe ordering with | order-only prerequisites (Part 11)
• test, coverage, and asan targets (Part 12)
• install, dist, and docker-build targets (Part 13)
• CI-compatible check target and MAKEFLAGS for noise-free output (Part 14)
• $(warning) tracing (Part 15)
• Cross-compilation via CROSS_COMPILE (Part 10)

The Complete Makefile

# =============================================================================
# Production-Grade Capstone Makefile
# GNU Make Mastery Series — Part 16
# =============================================================================

# ── Configuration ─────────────────────────────────────────────────────────────
CROSS_COMPILE   ?=
CC              := $(CROSS_COMPILE)gcc
AR              := $(CROSS_COMPILE)ar
STRIP           := $(CROSS_COMPILE)strip

PROJECT         := myapp
VERSION         := $(shell git describe --tags --abbrev=0 2>/dev/null || echo 0.0.0)
PREFIX          ?= /usr/local

BUILD_TYPE      ?= release          # release | debug | asan | coverage
BUILD_DIR       := build/$(BUILD_TYPE)
BIN_DIR         := $(BUILD_DIR)/bin
LIB_DIR         := $(BUILD_DIR)/lib
OBJ_DIR         := $(BUILD_DIR)/obj
DEP_DIR         := $(BUILD_DIR)/dep

# ── Sources ───────────────────────────────────────────────────────────────────
SRC_DIRS        := src src/net src/crypto
SRCS            := $(foreach d,$(SRC_DIRS),$(wildcard $(d)/*.c))
OBJS            := $(patsubst %.c,$(OBJ_DIR)/%.o,$(SRCS))
DEPS            := $(OBJS:.o=.d)             # auto-generated .d dependency files

# Library objects = everything except main.c (no entry point in a library)
LIB_SRCS        := $(filter-out src/main.c,$(SRCS))
LIB_OBJS        := $(patsubst %.c,$(OBJ_DIR)/%.o,$(LIB_SRCS))

# ── Flags ─────────────────────────────────────────────────────────────────────
CFLAGS_common   := -Wall -Wextra -Wpedantic -Wno-unused-parameter
CFLAGS_common   += -DPROJECT_VERSION='"$(VERSION)"'    # embed version as string literal
CFLAGS_common   += $(addprefix -I,$(SRC_DIRS)) -Iinclude  # -I flag per source directory

CFLAGS_release  := -O2 -DNDEBUG                # optimised, disable assert()
CFLAGS_debug    := -g -Og -DDEBUG              # debug info, minimal optimisation
CFLAGS_asan     := -g -fsanitize=address,undefined -DDEBUG  # ASan + UBSan combined
CFLAGS_coverage := -g --coverage -DDEBUG        # gcov instrumentation

# Computed variable: CFLAGS_$(BUILD_TYPE) selects the right set above
CFLAGS          := $(CFLAGS_common) $(CFLAGS_$(BUILD_TYPE))
LDFLAGS_asan    := -fsanitize=address,undefined
LDFLAGS         := $(LDFLAGS_$(BUILD_TYPE))

# ── Quiet / Verbose ───────────────────────────────────────────────────────────
# V=0 (default): suppress commands, show short "CC src/main.c" messages
# V=1 (make V=1): print every command in full (traditional Make output)
V               ?= 0
Q               := $(if $(filter 1,$(V)),,@)    # Q=@ when quiet, empty when verbose
LOG             = $(if $(filter 1,$(V)),,$(info  $(1)  $(2)))  # short log: "CC file.c"

# ── Output directories ────────────────────────────────────────────────────────
DIRS            := $(BIN_DIR) $(LIB_DIR) $(OBJ_DIR) \
                   $(foreach d,$(SRC_DIRS),$(OBJ_DIR)/$(d))

# ── Default target ────────────────────────────────────────────────────────────
.PHONY: all
all: $(BIN_DIR)/$(PROJECT) $(LIB_DIR)/lib$(PROJECT).a $(LIB_DIR)/lib$(PROJECT).so

# ── Binary ────────────────────────────────────────────────────────────────────
$(BIN_DIR)/$(PROJECT): $(OBJS) | $(BIN_DIR)
	$(call LOG,LD,$@)
	$(Q)$(CC) $(CFLAGS) $^ $(LDFLAGS) -o $@

# ── Static library ────────────────────────────────────────────────────────────
$(LIB_DIR)/lib$(PROJECT).a: $(LIB_OBJS) | $(LIB_DIR)
	$(call LOG,AR,$@)
	$(Q)$(AR) rcs $@ $^

# ── Shared library ────────────────────────────────────────────────────────────
$(LIB_DIR)/lib$(PROJECT).so: $(LIB_OBJS) | $(LIB_DIR)
	$(call LOG,SO,$@)
	$(Q)$(CC) -shared -Wl,-soname,lib$(PROJECT).so.1 $(LDFLAGS) $^ -o $@  # soname for ABI versioning

# ── Compile pattern ───────────────────────────────────────────────────────────
$(OBJ_DIR)/%.o: %.c | $(DIRS)
	$(call LOG,CC,$<)
	$(Q)$(CC) $(CFLAGS) -MMD -MP -MF $(DEP_DIR)/$*.d -c $< -o $@
	#                   -MMD : dependency file (user headers only)
	#                   -MP  : phony targets for deleted headers
	#                   -MF  : write deps to explicit path in DEP_DIR

-include $(DEPS)

# ── Directories ───────────────────────────────────────────────────────────────
$(DIRS):
	$(Q)mkdir -p $@

# ── Convenience targets ───────────────────────────────────────────────────────
.PHONY: debug
debug:
	$(MAKE) BUILD_TYPE=debug

.PHONY: asan
asan:
	$(MAKE) BUILD_TYPE=asan

.PHONY: coverage
coverage:
	$(MAKE) BUILD_TYPE=coverage

# ── Test ──────────────────────────────────────────────────────────────────────
TEST_SRCS       := $(wildcard tests/*.c)
TEST_BINS       := $(patsubst tests/%.c,$(BIN_DIR)/test_%,$(TEST_SRCS))

.PHONY: test
test: $(TEST_BINS)
	$(Q)for t in $(TEST_BINS); do echo "RUN $$t"; $$t; done

$(BIN_DIR)/test_%: tests/%.c $(LIB_OBJS) | $(BIN_DIR)
	$(Q)$(CC) $(CFLAGS) $^ $(LDFLAGS) -o $@

# ── Coverage report ───────────────────────────────────────────────────────────
.PHONY: coverage-report
coverage-report: BUILD_TYPE := coverage
coverage-report: test
	$(Q)lcov --capture --directory $(OBJ_DIR) --output-file $(BUILD_DIR)/lcov.info
	$(Q)genhtml $(BUILD_DIR)/lcov.info --output-directory $(BUILD_DIR)/coverage-html
	$(info Coverage report: $(BUILD_DIR)/coverage-html/index.html)

# ── Install ───────────────────────────────────────────────────────────────────
# install -D creates parent dirs; -m sets permissions (755=exec, 644=data)
.PHONY: install
install: all
	install -Dm755 $(BIN_DIR)/$(PROJECT) $(DESTDIR)$(PREFIX)/bin/$(PROJECT)
	install -Dm644 $(LIB_DIR)/lib$(PROJECT).a $(DESTDIR)$(PREFIX)/lib/lib$(PROJECT).a
	install -Dm755 $(LIB_DIR)/lib$(PROJECT).so $(DESTDIR)$(PREFIX)/lib/lib$(PROJECT).so.$(VERSION)
	ln -sf lib$(PROJECT).so.$(VERSION) $(DESTDIR)$(PREFIX)/lib/lib$(PROJECT).so  # symlink for -l flag
	install -Dm644 include/$(PROJECT).h $(DESTDIR)$(PREFIX)/include/$(PROJECT).h
	ldconfig                                        # refresh shared library cache

# ── Distribution tarball ──────────────────────────────────────────────────────
.PHONY: dist
dist:
	$(Q)git archive --format=tar.gz --prefix=$(PROJECT)-$(VERSION)/ HEAD \
	    -o $(PROJECT)-$(VERSION).tar.gz
	$(info Created $(PROJECT)-$(VERSION).tar.gz)

# ── Docker build ──────────────────────────────────────────────────────────────
.PHONY: docker-build
docker-build:
	docker build --build-arg VERSION=$(VERSION) -t $(PROJECT):$(VERSION) .
	docker tag $(PROJECT):$(VERSION) $(PROJECT):latest

# ── CI check target ───────────────────────────────────────────────────────────
.PHONY: check
check: MAKEFLAGS += --no-print-directory
check:
	$(MAKE) clean
	$(MAKE) BUILD_TYPE=release
	$(MAKE) BUILD_TYPE=asan test
	$(MAKE) coverage-report
	@echo "ALL CHECKS PASSED — version $(VERSION)"

# ── Clean ─────────────────────────────────────────────────────────────────────
.PHONY: clean distclean
clean:
	$(Q)rm -rf build/

distclean: clean
	$(Q)rm -f $(PROJECT)-*.tar.gz

# ── Variable Inspector ─────────────────────────────────────────────────────────
.PHONY: info
info:
	@echo "PROJECT      = $(PROJECT)"
	@echo "VERSION      = $(VERSION)"
	@echo "BUILD_TYPE   = $(BUILD_TYPE)"
	@echo "CROSS_COMPILE= $(CROSS_COMPILE)"
	@echo "CC           = $(CC)"
	@echo "CFLAGS       = $(CFLAGS)"
	@echo "LDFLAGS      = $(LDFLAGS)"
	@echo "PREFIX       = $(PREFIX)"
	@echo "BUILD_DIR    = $(BUILD_DIR)"
	@echo "SRC_DIRS     = $(SRC_DIRS)"
	@echo "SRCS         = $(SRCS)"
	@echo "OBJS         = $(OBJS)"
	@echo "LIB_SRCS     = $(LIB_SRCS)"
	@echo "TEST_SRCS    = $(TEST_SRCS)"

# ── Help ──────────────────────────────────────────────────────────────────────
.PHONY: help
help:
	@echo "Targets:"
	@echo "  all             Build binary + static + shared libs (default)"
	@echo "  debug           Build with -g -Og"
	@echo "  asan            Build with AddressSanitizer + UBSan"
	@echo "  coverage        Build with gcov instrumentation"
	@echo "  test            Run all unit tests"
	@echo "  coverage-report Generate HTML coverage report (requires lcov)"
	@echo "  install         Install to PREFIX=$(PREFIX)"
	@echo "  dist            Create source tarball"
	@echo "  docker-build    Build Docker image"
	@echo "  check           CI gatekeeping: clean + release + asan + coverage"
	@echo "  clean           Remove build/ directory"
	@echo "  distclean       Remove build/ and tarballs"
	@echo "  info            Print all variable values"
	@echo ""
	@echo "Options:"
	@echo "  BUILD_TYPE=release|debug|asan|coverage  (default: release)"
	@echo "  CROSS_COMPILE=arm-linux-gnueabihf-       (default: empty)"
	@echo "  PREFIX=/usr/local                         (install prefix)"
	@echo "  V=1                                       (verbose output)"

Create Source Files

The capstone Makefile scans src/, src/net/, src/crypto/, tests/, and expects include/myapp.h. Create the full layout:

mkdir -p src src/net src/crypto tests include

cat > include/myapp.h << 'EOF'
#ifndef MYAPP_H
#define MYAPP_H
void net_init(void);
void crypto_hash(const char *data);
#endif
EOF

cat > src/main.c << 'EOF'
#include <stdio.h>
#include "myapp.h"

int main(void) {
    printf("myapp starting\n");
    net_init();
    crypto_hash("hello");
    return 0;
}
EOF

cat > src/net/client.c << 'EOF'
#include <stdio.h>
#include "myapp.h"
void net_init(void) { printf("Network initialized\n"); }
EOF

cat > src/crypto/cipher.c << 'EOF'
#include <stdio.h>
#include "myapp.h"
void crypto_hash(const char *data) { printf("Hash(%s) = 0xDEAD\n", data); }
EOF

cat > tests/test_net.c << 'EOF'
#include <stdio.h>
#include <assert.h>
#include "myapp.h"

int main(void) {
    printf("Running net tests...\n");
    net_init();   /* smoke test — verifies no crash */
    printf("PASS\n");
    return 0;
}
EOF

Try It

# See all available targets
make help

# Inspect every resolved variable
make info

# Build (release by default)
make
./build/release/bin/myapp

# Debug build
make debug
./build/debug/bin/myapp

# Run tests
make test

# Verbose output (see raw commands)
make V=1 clean all

make clean

Series Summary & Next Learning

You have completed the GNU Make Mastery Series. Here is what you now know: