先有一段没被 rule 管过的原材料。template.c 里只有一个函数:

#include <stdio.h>
 
void fun()
{
    printf("hello fun!\n");
}

用一个脚本把它变成 101 份,每份的函数名换成 fun0、fun1……fun100,再拼出一个全都调一遍的 main.c:

#!/bin/bash
for i in $(seq 0 100); do
    sed "s/fun/fun$i/" template.c > "code$i.c"
done
 
{
    printf '#include <stdio.h>\n\nint main()\n{\n'
    for i in $(seq 0 100); do
        printf '    fun%d();\n' "$i"
    done
    printf '    return 0;\n}\n'
} > main.c

这份规模不是为了炫技,是为了让"手写每条规则"这条路彻底走不通:101 条编译规则、1 条链接规则,改一个变量名就要改 101 行。Makefile 的进阶内容,本质上都在解决这一件事——规则能不能由 make 自己推导出来。

wildcard 是在赋值那一刻去看磁盘

SRCS = $(wildcard *.c)
OBJS = $(SRC:.c=.o)

这两行里有两个问题。先看 wildcard:它返回当前目录下所有匹配 *.c 的真实文件名,空格分隔。不用它直接写 SRCS = *.c 行不行?不行——*.c 只在 recipe 里被 shell 展开,在变量赋值这一侧 make 不会替你展开,你会得到一个字面量 *.c,后面 $(CC) -c *.c 才有 shell 兜底,但用 $(OBJS) 做链接时就是灾难。

第二条是课件的笔误:定义了 SRCS,用的却是 $(SRC)。SRC 从未定义,展开为空,OBJS 也就是空的,make 会安静地什么都不做。这类"变量名差一个字母"的错在 Makefile 里没有任何报错,只能靠 $(info $(OBJS)) 或 make -p 自查。

.c=.o 这种写法叫替换引用(substitution reference),是 patsubst 的简写:把每个词的结尾 .c 换成 .o。它只能换后缀,不能加前缀、不能改中间,要做更复杂的事就得写完整的 patsubst。

模式规则把 101 条规则压成 1 条

CC     = gcc
CFLAGS = -c
 
SRCS = $(wildcard *.c)
OBJS = $(SRCS:.c=.o)
 
.PHONY: all
all: $(OBJS)
 
%.o: %.c
	@echo "compiling ... $<"
	@$(CC) $(CFLAGS) $< -o $@
 
.PHONY: clean
clean:
	@rm -f $(OBJS)

%.o: %.c 是模式规则(pattern rule):% 代表"任意一段非空字符串",%.o 和 %.c 里的两个 % 必须匹配同一段。所以 code99.o 对上 code99.c,main.o 对上 main.c,一条规则覆盖一百多个目标。

规则体里的三个符号是自动变量(automatic variable):

变量含义
$@当前规则的目标文件名
$<第一个前置条件
$^全部前置条件,重复的只留一份
$?比目标更新的那些前置条件
$*模式规则中 % 匹配到的那一段

链接时用 $^(所有 .o)、编译时用 $<(当前那一个 .c),这一对是模式规则里最常用的组合。命令前的 @ 抑制命令回显,只留下自己 @echo 的输出。

.PHONY 声明的是伪目标(phony target):clean 不产生同名文件,声明之后即使目录里真有个叫 clean 的文件,make clean 也照样执行。场景 1 里那个用来打印变量的 test 目标没加 .PHONY,如果恰好存在名为 test 的文件,它就会"已经是最新的"而什么都不打印。

顺带一个事实:GNU Make 自带一条 %.o: %.c 的内置规则,所以你删掉自己写的那条,make 一样能把 .c 编成 .o,只是命令变成默认的 $(CC) $(CFLAGS) -c。后面会用到这个事实来判断课件里某条规则到底有没有生效。

= 是延迟展开,:= 是当场展开

a = hello
b = $(a) bit
a = world
 
all:
	@echo $(a)
	@echo $(b)

输出 world 和 world bit。b 用的是 =(递归展开),右边那一串 $(a) bit 被原样存着,直到 echo 那一刻才去求 a 的值;此时 a 已经是 world。

把第二行换成 b := $(a) bit,输出变成 world 和 hello bit。:= 是简单展开(simple expansion),赋值当场就把 $(a) 换成 hello,之后 a 再怎么变都影响不到 b。

+= 的行为取决于左边变量的出身:左边是 := 定义的,追加时立刻展开;左边是 = 定义的,追加的内容保持延迟展开。所以

MODULES := main
MODULES += $(shell ls -d Module*)

这两行的 $(shell ...) 会在读入阶段就执行一次,把 Module0…Module9 拼进变量。

$(shell ...) 和 $(wildcard ...) 的差别是前者真的起一个 shell 跑命令、后者只在 make 内部看目录。$(shell ls -d Module*) 和 $(wildcard Module*) 在这里结果相同,后者更省一次进程。

至于 := 为什么在场景 2 里必须用:

BIN := $(addprefix $(BIN_DIR)/, $(BIN))   # bin/project

如果写成 =,右边引用了 BIN 自己,展开时又要展开右边,右边又引用 BIN,就是无限递归,make 会直接报 Recursive variable 'BIN' references itself。addprefix 本身只做一件事:给列表中每个词加上同一个前缀,这里就是把 project 变成 bin/project。

条件判断也在读入阶段决定,写在规则之外、不缩进:

DEBUG ?= 0
ifeq ($(DEBUG), 1)
CFLAGS += -g
else
CFLAGS += -O2
endif

?= 只在变量尚未定义时赋值,所以命令行 make DEBUG=1 能覆盖文件里的默认值。ifeq 比较的是展开后的字符串,ifdef 只判断变量是否有非空值,ifndef 是它的反面。

patsubst 与目录:% 匹配的不只是文件名

场景 2 要把临时文件收进 objs/、可执行文件收进 bin/,清理时删目录即可。用 addprefix 能拼出 objs/code1.o,但源文件一旦分散在 Module0/ 这样的子目录里,addprefix 的路子就断了——它只会在最前面贴一段前缀,而 Module0/code1.c 的目标应该是 objs/Module0/code1.o,前缀要插在中间。

patsubst 能干这件事:

OBJS := $(patsubst %.c, $(OBJDIR)/%.o, $(SRCS))

patsubst 的语义是"把列表中每个词按 pattern 匹配,匹配上就套用 replacement"。这里的 %.c 匹配的是整个词,% 吞掉的是 Module0/code1 这一整段(斜杠也算在里面),替换后自然得到 objs/Module0/code1.o。这跟直觉上"% 只匹配文件名"的假设不同,% 匹配的是从词头到词尾的任意一段字符串。

目标名带目录后,模式规则写法要跟着改:

$(OBJDIR)/%.o: %.c
	@mkdir -p $(dir $@)
	$(CC) $(CFLAGS) -c $< -o $@

$(dir $@) 是另一个文件名函数,取路径部分并保留结尾的斜杠(objs/Module0/code1.o 得到 objs/Module0/)。mkdir -p 保证子目录存在,否则 gcc -o 会报找不到路径。

课件场景 2 里给目录单独写了规则:

$(DIR_LIST):
	@$(MKDIR) $@

一条规则写多个目标,等价于每个目标各有一条同样的规则,objs 和 bin 都会建出来。它的隐患在于目录不是 .o 的前置条件,make -j 并行时编译可能抢在 mkdir 前面。稳妥写法用 order-only 前置条件,竖线右边的东西只在缺失时构建、且它的时间戳变化不会引起目标重建:

$(OBJDIR)/%.o: %.c | $(OBJDIR)

多模块:foreach 拼出一份全局列表

把 100 个源文件分进 10 个目录后,*.c 只看得见当前目录,需要按模块逐个 wildcard 再拼起来:

SRCS := $(foreach module, $(MODULES), $(wildcard $(module)/*.c))

$(foreach var, list, text) 的规则是:var 是临时变量名,list 按空格切成若干词,每个词赋给 var 后对 text 求值一次,所有结果用空格连起来。这里的 list 是 main 加上 Module0 到 Module9,text 是 $(wildcard $(module)/*.c),于是得到 main/main.c Module0/code1.c 这样一串。

头文件路径同理,只是不需要 patsubst,直接给每个模块名贴一个 -I:

INCLUDES := $(addprefix -I, $(MODULES))

gcc -c 的命令行加上 $(INCLUDES) 之后,main.c 里的 #include "code1.h" 才找得到。把这一套合成一份可跑的 Makefile:

MODULES := main
MODULES += $(wildcard Module*)
 
CC     := gcc
CFLAGS := -Wall -MMD -MP
BIN    := project
OBJDIR := objs
 
SRCS := $(foreach m, $(MODULES), $(wildcard $(m)/*.c))
OBJS := $(patsubst %.c, $(OBJDIR)/%.o, $(SRCS))
DEPS := $(OBJS:.o=.d)
INCLUDES := $(addprefix -I, $(MODULES))
 
$(BIN): $(OBJS)
	$(CC) $^ -o $@
 
$(OBJDIR)/%.o: %.c
	@mkdir -p $(dir $@)
	$(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@
 
-include $(DEPS)
 
.PHONY: clean test
test:
	@echo "$(MODULES)"
	@echo "$(SRCS)"
	@echo "$(OBJS)"
 
clean:
	rm -rf $(OBJDIR) $(BIN)

$(wildcard Module*) 会返回所有以 Module 开头的目录名,和 ls -d Module* 等价,少起一个 shell。

多 Makefile:顶层只负责挨个敲门

模块各自独立编译时,每个目录一份 Makefile,顶层那份不需要认识源码,只需要会循环:

MODULES := $(wildcard Module*)
 
.PHONY: build clean output
build:
	@for m in $(MODULES); do \
	    $(MAKE) -C $$m || exit 1; \
	    echo "build $$m ... done"; \
	done
 
clean:
	@for m in $(MODULES); do $(MAKE) -C $$m clean; done
 
output:
	@for m in $(MODULES); do $(MAKE) -C $$m output; done

三个细节。第一,$$m 里的两个美元号:Makefile 先吃掉一层 $,传给 shell 的才是 $m。第二,recipe 的每一行默认起一个独立 shell,所以这个 for 必须写成带反斜杠续行的一条命令,拆成多行的话 m 在下一个 shell 里就没了。第三,用 $(MAKE) -C 而不是手工 cd:-C 由 make 自己切换目录并负责错误传递,$(MAKE) 还能把 -j 之类的选项传下去。|| exit 1 是为那些用 cd && make 手法的版本准备的,一旦某个模块失败就停下,别让后面的模块继续往下编。

子目录的 Makefile 用的是场景 1 的结构,课件模板里有这么一行:

*.o:%.c
	$(CC) -c $<

这里 *.o 应该是 %.o。* 是 shell 的通配符,% 才是 Make 的模式规则里的通配符,两者不可互换:写成 *.o 的目标不会被当成"任意 .o 都能用的规则",它只会在读入时被展开成当下已存在的那些 .o 文件名,而第一次构建时这些文件一个都不存在。可以验证:课件后面的编译输出是

gcc    -c -o code3.o code3.c

既没有 @echo,命令形式也带 -o 且参数顺序是 gcc 默认的——这是 Make 内置 %.o:%.c 规则干出来的,说明自定义的那条压根没生效。字面量目标 *.o 没有任何文件与之匹配,它自己也永远不会被构建。

改头文件不重编,是因为依赖图上没有 .h

一个 .o 的目标只依赖它的 .c,头文件改了,.c 的时间戳没变,make 认为目标还是最新的,于是什么都不做。这个问题的正解不是手写头文件列表,而是让编译器自己把依赖写出来:

  • -MMD:编译时额外产出一个 .d 文件,内容是这条命令真正用到的用户头文件依赖,系统头文件不列;
  • -MP:给每个头文件再补一条空规则,这样删掉某个头文件时,make 不会因为"找不到前置条件"而报错;
  • -include $(DEPS):把这些 .d 读进来。用 -include(前面有减号)而不是 include,是因为第一次 make 时 .d 还不存在,include 会直接失败。

以 objs/Module0/code1.o 为例,生成的 objs/Module0/code1.d 大概是:

objs/Module0/code1.o: Module0/code1.c Module0/code1.h
Module0/code1.h:

第一行就是一条完整规则。把它 include 进来,.h 正式进入依赖图。

验证一次:touch Module0/code1.h 之后再 make,只会重编 code1.c 一个文件,然后链接;把 -MMD -MP 从 CFLAGS 里删掉再试同样的动作,make 会说无事可做。

另外,CC、CFLAGS 不是语法关键字,只是内置规则会引用的普通变量。写成 CC ?= gcc 可以让环境变量里的 CC 优先;而命令行上的 make CC=clang 会覆盖文件里的任何赋值,与 ?= 无关。$(MAKE) 是唯一有特殊行为的那个,它会把 -j 之类的选项一并传进递归调用。

增量编译的全部依据只有时间戳:make 先看目标存不存在,不存在就构建;存在就比较目标和所有前置的修改时间,只要有任何一个前置比目标新,就重建这一条,并继续向上传播。伪目标永远"不存在",所以 clean、build 这种每次都会跑。这一点解释了两件常见的困惑:改了 .c 会重编是因为规则里写着 .c;改了 .h 不重编是因为规则里没写 .h——-MMD 的作用就是把这件事补上,而不是让 make 更聪明。