[关闭]
@Purpose 2017-03-17T03:26:19.000000Z 字数 6513 阅读 1140

Makefile学习笔记

linux笔记

Makefile介绍

makefile的规则

  1. target ... : prerequisites ...
  2.     command
  3.     ...
  4.     ...
  1. target可以是一个object file(目标文件)，也可以是一个执行文件，还可以是一个标签（label）。
  2. prerequisites就是，要生成那个target所需要的文件或是目标。
  3. command也就是make需要执行的命令。（任意的shell命令）

示例

  1. edit : main.o kbd.o command.o display.o \
  2.         insert.o search.o files.o utils.o       /*注释:如果后面这些.o文件比edit可执行文件新,那么才会去执行下面这句命令*/
  3.     cc -o edit main.o kbd.o command.o display.o \
  4.         insert.o search.o files.o utils.o
  6. main.o : main.c defs.h
  7.     cc -c main.c
  8. kbd.o : kbd.c defs.h command.h
  9.     cc -c kbd.c
  10. command.o : command.c defs.h command.h
  11.     cc -c command.c
  12. display.o : display.c defs.h buffer.h
  13.     cc -c display.c
  14. insert.o : insert.c defs.h buffer.h
  15.     cc -c insert.c
  16. search.o : search.c defs.h buffer.h
  17.     cc -c search.c
  18. files.o : files.c defs.h buffer.h command.h
  19.     cc -c files.c
  20. utils.o : utils.c defs.h
  21.     cc -c utils.c
  22. clean :
  23.     rm edit main.o kbd.o command.o display.o \
  24.         insert.o search.o files.o utils.o

反斜杠（\）是换行符的意思。这样比较便于makefile的易读。我们可以把这个内容保存在名字为makefile或Makefile 的文件中，然后在该目录下直接输入命令make就可以生成执行文件edit。如果要删除执行文件和所有的中间目标文件，那么，只要简单地执行一下 make clean就可以了。

make是如何工作的

当我们输入make命令时，系统会执行以下操作：
1. make会在当前目录下找名字叫Makefile或makefile的文件。
2. 如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到edit这个文件，并把这个文件作为最终的目标文件。
3. 如果edit文件不存在，或是edit所依赖的后面的.o文件的文件修改时间要比edit这个文件新，那么，他就会执行后面所定义的命令来生成edit这个文件。
4. 如果edit所依赖的.o文件也不存在，那么make会在当前文件中找目标为.o文件的依赖性，如果找到则再根据那一个规则生成.o文件。（这有点像一个堆栈的过程）
5. 当然，你的C文件和H文件是存在的啦，于是make会生成 .o 文件，然后再用.o文件生成make的终极任务，也就是执行文件edit了。

这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。make只管文件的依赖性，即，如果在我找了依赖关系之后，冒号后面的文件还是不在，那么对不起，我就不工作啦。

在makefile中使用变量

在示例中

  1. edit : main.o kbd.o command.o display.o \
  2.         insert.o search.o files.o utils.o
  3.     cc -o edit main.o kbd.o command.o display.o \
  4.         insert.o search.o files.o utils.o

在这个例子中用了许多.o文件，如果我们的程序需要加入新的.o文件，那么我们就需要在其他相应的地方进行修改，如果程序变大，有一些地方忘记了修改，就会导致编译失败，这样会大大提高makefile的维护成本，所以我们可以使用变量，类似于我们C语言中的宏定义

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

然后我们就在makefile中以$(objects)来使用该变量（当然，作为一个变量，你起啥名字没太大关系，不过还是要尽量体现出他是一个obj文件的变量为宜）

  1. objects = main.o kbd.o command.o display.o \
  2.         insert.o search.o files.o utils.o
  4. edit : $(objects)
  5. 	cc -o edit $(objects)
  6. main.o : main.c defs.h
  7.     cc -c main.c
  8. kbd.o : kbd.c defs.h command.h
  9.     cc -c kbd.c
  10. command.o : command.c defs.h command.h
  11.     cc -c command.c
  12. display.o : display.c defs.h buffer.h
  13.     cc -c display.c
  14. insert.o : insert.c defs.h buffer.h
  15.     cc -c insert.c
  16. search.o : search.c defs.h buffer.h
  17.     cc -c search.c
  18. files.o : files.c defs.h buffer.h command.h
  19.     cc -c files.c
  20. utils.o : utils.c defs.h
  21.     cc -c utils.c
  22. clean :
  23.     rm edit $(objects)

如果在此之后有新的文件，我们只需要修改变量objects就可以了，大大降低了维护的成本

make自动推导

我们的make可是很强大的说，它会自己推导文件以及文件依赖关系之后的命令，所以我们没必要在每个[.o]文件的背后都写上类似的命令
当make看到一个[.o]文件，它会自动地把对应的[.c]文件加到依赖关系中，如main.o，make会自动加载main.c到依赖关系中，并且cc -c main.c也会被推导出来。
所以经过简化之后的makefile可以新鲜出炉了

  1. objects = main.o kbd.o command.o display.o \
  2.         insert.o search.o files.o utils.o
  3.  cc = gcc
  5. edit : $(objects)
  6. 	cc -o edit $(objects)
  8. main.o : defs.h
  9. kbd.o : defs.h command.h
  10. command.o : defs.h command.h
  11. display.o : defs.h buffer.h
  12. insert.o : defs.h buffer.h
  13. search.o : defs.h buffer.h
  14. files.o : defs.h buffer.h command.h
  15. utils.o : defs.h
  17. .PHONY : clean
  18. clean :
  19.     rm edit $(objects)

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

另类风格的makefile

可能有的人看到那一堆的[.o], [.h]很不爽，这么多重复的[.h]能不能把它们收拢起来呢？答案是肯定的，毕竟有需求就会有市场嘛，以下就是最新的makefile的文件风格

  1. objects = main.o kbd.o command.o display.o \
  2.         insert.o search.o files.o utils.o
  4. edit : $(objects)
  5. 	cc -o edit $(objects)
  7. $(objects) : defs.h
  8. kbd.o command.o files.o : command.h
  9. display.o insert.o search.o files.o : buffer.h
  11. .PHONY : clean
  12. clean :
  13.     rm edit $(objects)

这种风格让makefile变得简单了，然而文件的依赖关系看起来就有点乱了，我个人不是很喜欢这种风格，一是因为文件的依赖关系看不清楚了，二是如果文件要多加几个新的文件进来就理不清楚了

清空目标文件的规则

宛如一个基本法，每个Makefile中都应该写一个清空目标文件（.o和执行文件）的规则，这不仅便于重编译，也很利于保持文件的清洁。

  1. .PHONY : clean
  2. clean :
  3.     -rm edit $(objects)

前面说过，.PHONY意思表示clean是一个“伪目标”。而在rm命令前面加了一个小减号的意思就是，也许某些文件出现问题，但不要管，继续做后面的事。当然，clean的规则不要放在文件的开头，不然，这就会变成make的默认目标，相信谁也不愿意这样。不成文的规矩是——“clean从来都是放在文件的最后”。

Makefile里有什么？

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

最后，还值得一提的是，在Makefile中的命令，必须要以[Tab]键开始。

Makefile的文件名

默认的情况下，make命令会在当前目录下按顺序找寻文件名为“GNUmakefile”、“makefile”、“Makefile”的文件，找到了解释这个文件。
在这三个文件名中，最好使用“Makefile”这个文件名，因为，这个文件名第一个字符为大写，这样有一种显目的感觉。
最好不要用 “GNUmakefile”，这个文件是GNU的make识别的。
有另外一些make只对全小写的“makefile”文件名敏感，但是基本上来说，大多数的make都支持“makefile”和“Makefile”这两种默认文件名。

当然，你可以使用别的文件名来书写Makefile，比如：“Make.Linux”，“Make.Solaris”，“Make.AIX”等，
如果要指定特定的Makefile，你可以使用make的“-f”和“--file”参数，
如：make -f Make.Linux或make --file Make.AIX。

引用其它的Makefile

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

  1. include foo.make *.mk $(bar)

等价于

  1. include foo.make a.mk b.mk c.mk e.mk f.mk

make命令开始时，会找寻include所指出的其它Makefile，并把其内容安置在当前的位置。就好像C/C++的#include指令一样。如果文件都没有指定绝对路径或是相对路径的话，make会在当前目录下首先寻找，如果当前目录下没有找到，那么，make还会在下面的几个目录下找：

  1. 如果make执行时，有“-I”或“--include-dir”参数，那么make就会在这个参数所指定的目录下去寻找。
  2. 如果目录<prefix>;/include（一般是：/usr/local/bin或/usr/include）存在的话，make也会去找。

如果有文件没有找到的话，make会生成一条警告信息，但不会马上出现致命错误。它会继续载入其它的文件，一旦完成makefile的读取， make会再重试这些没有找到，或是不能读取的文件，如果还是不行，make才会出现一条致命信息。如果你想让make不理那些无法读取的文件，而继续执行，你可以在include前加一个减号“-”。如：

  1. -include <filename>;

其表示，无论include过程中出现什么错误，都不要报错继续执行。和其它版本make兼容的相关命令是sinclude，其作用和这一个是一样的。

环境变量 MAKEFILES

如果你的当前环境中定义了环境变量MAKEFILES，那么，make会把这个变量中的值做一个类似于include的动作。这个变量中的值是其它的Makefile，用空格分隔。只是，它和include不同的是，从这个环境变量中引入的Makefile的“目标”不会起作用，如果环境变量中定义的文件发现错误，make也会不理。

但是在这里我还是建议不要使用这个环境变量，因为只要这个变量一被定义，那么当你使用make时，所有的Makefile都会受到它的影响，这绝不是你想看到的。在这里提这个事，只是为了告诉大家，也许有时候你的Makefile出现了怪事，那么你可以看看当前环境中有没有定义这个变量。

make的工作方式


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

    1-5步为第一个阶段，6-7为第二个阶段。第一个阶段中，如果定义的变量被使用了，那么，make会把其展开在使用的位置。但make并不会完全马上展开，make使用的是拖延战术，如果变量出现在依赖关系的规则中，那么仅当这条依赖被决定要使用了，变量才会在其内部展开。

书写规则

规则包括两个部分，一个是依赖关系，一个是生成目标的方法。
在Makefile中，规则的顺序是很重要的，因为，Makefile中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让make知道你的最终目标是什么。一般来说，定义在Makefile中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个，那么，第一个目标会成为最终的目标。make所完成的也就是这个目标。

规则举例

  1. foo.o : foo.c defs.h       # foo模块
  2.     cc -c -g foo.c

foo.o是我们的目标，foo.c和defs.h是目标所依赖的源文件，而只有一个命令“cc -c -g foo.c”（以Tab键开头）。
这个规则告诉我们两件事：
1. 文件的依赖关系，foo.o依赖于foo.c和defs.h的文件，如果foo.c和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存在，那么依赖关系发生。
2. 生成或更新foo.o文件，就是那个cc命令。它说明了如何生成foo.o这个文件。（当然，foo.c文件include了defs.h文件）

规则的语法

  1. targets : prerequisites
  2.     command
  3.     ...
  5. targets : prerequisites ; command
  6.     command
  7.     ...
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注