Makefile

:material-circle-edit-outline: 约 2670 个字 :fontawesome-solid-code: 67 行代码 :material-clock-time-two-outline: 预计阅读时间 10 分钟

makefile介绍 — 跟我一起写Makefile 1.0 文档 (seisman.github.io)

简介

前言

我们要写一个makefile来告诉make命令如何编译和链接文件。我们的规则是：

如果这个工程没有编译过，那么我们的所有c文件都要编译并被链接。
如果这个工程的某几个c文件被修改，那么我们只编译被修改的c文件，并链接目标程序。
如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的c文件，并链接目标程序。

只要我们的makefile写得够好，所有的这一切，我们只用一个make命令就可以完成

make命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自动编译所需要的文件和链接目标程序。

主要内容

Makefile 可以包含五个东西：

显式规则。显式规则说明了如何生成一个或多个目标文件。这是由Makefile的书写者明显指出要生成的文件、文件的依赖文件和生成的命令。
隐式规则。由于我们的make有自动推导的功能，所以隐式规则可以让我们比较简略地书写Makefile，这是由make所支持的。
变量的定义。在Makefile中我们要定义一系列的变量，变量一般都是字符串，这个有点像你C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。
指令。其包括了三个部分，一个是在一个Makefile中引用另一个Makefile，就像C语言中的include一样；另一个是指根据某些情况指定Makefile中的有效部分，就像C语言中的预编译#if一样；还有就是定义一个多行的命令。有关这一部分的内容，我会在后续的部分中讲述。
注释。Makefile中只有行注释，和UNIX的Shell脚本一样，其注释是用 # 字符，这个就像C/C++中的 // 一样。如果你要在你的Makefile中使用 # 字符，可以用反斜杠进行转义，如： \# 。

注意，Makefile中的命令，必须要以 Tab 开始。

核心规则

target ... : prerequisites ...
    recipe
    ...
    ...

target
- 可以是一个object file（目标文件），也可以是一个可执行文件，还可以是一个标签（label）。对于标签这种特性，在后续的“伪目标”章节中会有叙述。
prerequisites
- 生成该target所依赖的文件和/或target。
recipe
- 该target要执行的命令（任意的shell命令）。

这是一个文件的依赖关系，target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在 command 中。

prerequisites 中如果有一个以上的文件比 target 文件要新的话，recipe所定义的命令就会被执行。

这就是makefile的规则，也就是makefile中最核心的内容。

一个实例

一个有3个头文件和8个C文件的工程

edit : main.o kbd.o command.o display.o \
        insert.o search.o files.o utils.o
    cc -o edit main.o kbd.o command.o display.o \
        insert.o search.o files.o utils.o

main.o : main.c defs.h
    cc -c main.c
kbd.o : kbd.c defs.h command.h
    cc -c kbd.c
command.o : command.c defs.h command.h
    cc -c command.c
display.o : display.c defs.h buffer.h
    cc -c display.c
insert.o : insert.c defs.h buffer.h
    cc -c insert.c
search.o : search.c defs.h buffer.h
    cc -c search.c
files.o : files.c defs.h buffer.h command.h
    cc -c files.c
utils.o : utils.c defs.h
    cc -c utils.c
clean :
    rm edit main.o kbd.o command.o display.o \
        insert.o search.o files.o utils.o

反斜杠（ \ ）是换行符，如果要删除可执行文件和所有的中间目标文件，执行 make clean

在这个makefile中，目标文件（target）包含可执行文件edit和中间目标文件（ *.o ）

依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h 文件

每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是可执行文件 edit 的依赖文件

依赖关系的实质就是说明了目标文件是由哪些文件生成的，即目标文件是哪些文件更新的。

定义好依赖关系后，recipe行定义了如何生成目标文件的操作系统命令，一定要以 Tab 开头

make并不管命令怎么工作，只管执行命令

make会比较targets文件和prerequisites文件的修改日期

如果prerequisites文件的日期要比targets文件的日期要新，或者target不存在，make才会执行后续定义的命令

这一特性使得重编译时只会重编被修改的部分，未受修改影响的部分就不会重新编译

clean 不是一个文件，它只不过是一个动作名字，有点像C语言中的label

其冒号后什么也没有，make就不会自动去找它的依赖性，也就不会自动执行其后所定义的命令

要执行其后的命令，就要在make命令后指出这个label的名字，make clean

这样的方法非常有用，我们可以在一个makefile中定义不用的编译或是和编译无关的命令，比如程序的打包，程序的备份

make如何工作

在默认的方式下，也就是我们只输入 make 命令。那么，

make会在当前目录下找名字叫“Makefile”或“makefile”的文件。
如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到“edit”这个文件，并把这个文件作为最终的目标文件。
如果edit文件不存在，或是edit所依赖的后面的 .o 文件的文件修改时间要比 edit 这个文件新，那么，他就会执行后面所定义的命令来生成 edit 这个文件。
如果 edit 所依赖的 .o 文件也不存在，那么make会在当前文件中找目标为 .o 文件的依赖性，如果找到则再根据那一个规则生成 .o 文件。（这有点像一个堆栈的过程）

这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。

在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错

对于所定义的命令的错误，或是编译不成功，make根本不理

使用变量

makefile的变量也就是一个字符串，理解成C语言中的宏可能会更好。

objects = main.o kbd.o command.o display.o \
     insert.o search.o files.o utils.o

可以用 $(objects) 的方式使用这个变量

自动推导

GNU的make很强大，它可以自动推导文件以及文件依赖关系后面的命令，于是我们就没必要去在每一个 .o 文件后都写上类似的命令，因为，我们的make会自动识别，并自己推导命令。

只要make看到一个 .o 文件，它就会自动的把 .c 文件加在依赖关系中

如果make找到一个 whatever.o ，那么 whatever.c 就会是 whatever.o 的依赖文件。

并且 cc -c whatever.c 也会被推导出来，于是，我们的makefile再也不用写得这么复杂。我们的新makefile又出炉了。

objects = main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

edit : $(objects)
    cc -o edit $(objects)

main.o : defs.h
kbd.o : defs.h command.h
command.o : defs.h command.h
display.o : defs.h buffer.h
insert.o : defs.h buffer.h
search.o : defs.h buffer.h
files.o : defs.h buffer.h command.h
utils.o : defs.h

.PHONY : clean
clean :
    rm edit $(objects)

这种方法就是make的“隐式规则”。上面文件内容中， .PHONY 表示 clean 是个伪目标文件。

更全面全面的自动推导：

objects = main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

edit : $(objects)
    cc -o edit $(objects)

$(objects) : defs.h
kbd.o command.o files.o : command.h
display.o insert.o search.o files.o : buffer.h

.PHONY : clean
clean :
    rm edit $(objects)

defs.h 是所有目标文件的依赖文件， command.h 和 buffer.h 是对应目标文件的依赖文件。

这种风格能让我们的makefile变得很短，但我们的文件依赖关系就显得有点凌乱了。

鱼和熊掌不可兼得，自己喜欢哪个就哪个。

清空目录

.PHONY : clean #想稳健一点就加这个
clean :
    -rm edit $(objects)

文件命名

make命令会在当前目录下按顺序寻找文件名为 GNUmakefile 、 makefile 和 Makefile 的文件。

最好使用 Makefile 这个文件名，因为这个文件名在排序上靠近其它比较重要的文件，比如 README。

最好不要用 GNUmakefile，因为这个文件名只能由GNU make ，其它版本的 make 无法识别

基本上来说，大多数的 make 都支持 makefile 和 Makefile 这两种默认文件名。

当然，可以使用别的文件名来书写Makefile，比如：“Make.Solaris”，“Make.Linux”等

如果要指定特定的Makefile，你可以使用make的 -f 或 --file 参数，如： make -f Make.Solaris 或 make --file Make.Linux

如果你使用多条 -f 或 --file 参数，你可以指定多个makefile。

嵌套引入

在Makefile使用 include 指令可以把别的Makefile包含进来，这很像C语言的 #include ，被包含的文件会原模原样的放在当前文件的包含位置。

include 的语法是：

include <filenames>...

<filenames> 可以是当前操作系统Shell的文件模式（可以包含路径和通配符）。

在 include 前面可以有一些空字符，但是绝不能是 Tab 键开始。

include 和 <filenames> 可以用一个或多个空格隔开。举个例子，你有这样几个Makefile： a.mk 、 b.mk 、 c.mk ，还有一个文件叫 foo.make ，以及一个变量 $(bar) ，其包含了 bish 和 bash ，那么，下面的语句：

include foo.make *.mk $(bar)

等价于：

include foo.make a.mk b.mk c.mk bish bash

make命令开始时，会找寻 include 所指出的其它Makefile，并把其内容安置在当前的位置。

如果文件都没有指定绝对路径或是相对路径的话，make会在当前目录下首先寻找，如果当前目录下没有找到，那么，make还会在下面的几个目录下找：

如果make执行时，有 -I 或 --include-dir 参数，那么make就会在这个参数所指定的目录下去寻找。
接下来按顺序寻找目录 <prefix>/include （一般是 /usr/local/bin ）、 /usr/gnu/include 、 /usr/local/include 、 /usr/include 。

你应当避免使用命令行参数 -I 来寻找以上这些默认目录，否则会使得 make “忘掉”所有已经设定的包含目录，包括默认目录。

环境变量 .INCLUDE_DIRS 包含当前 make 会寻找的目录列表。

如果有文件没有找到的话，make会生成一条警告信息，但不会马上出现致命错误，它会继续载入其它的文件

一旦完成makefile的读取，make会再重试这些没有找到，或是不能读取的文件，如果还是不行，make才会出现一条致命信息。

如果你想让make不理那些无法读取的文件，而继续执行，你可以在include前加一个减号“-”。如：

-include <filenames>...

其表示，无论include过程中出现什么错误，都不要报错继续执行。

如果要和其它版本 make 兼容，可以使用 sinclude 代替 -include 。

make的工作方式

GNU的make工作时的执行步骤如下：

读入所有的Makefile。
读入被include的其它Makefile。
初始化文件中的变量。
推导隐式规则，并分析所有规则。
为所有的目标文件创建依赖关系链。
根据依赖关系，决定哪些目标要重新生成。
执行生成命令。