Makefile备忘录

 

一、概述

一个Makefile中主要包含的内容有，注释、文件包含、变量定义、条件判断、函数、规则，其中规则是整个Makefile的核心。一个Makefile的主要任务就在规则中完成。

1、注释

2、文件包含

3、变量定义

4、条件判断

5、函数

6、规则

 

---

 

二、注释

在Makefile中，也允许注释，但只提供单行注释，其注释符和shell一样，‘#’，凡是以#开头的行都认为是注释行。如下所示：

view plaincopy to clipboardprint?

1. #this is a comment  

#this is a comment 

三、文件包含

在Makefile也和C语言一样有include的用法，include后面跟一个Makefile文件名，其功能和C语言中的include类似，就是把被包含的Makefile文件的内容全部原本的复制到包含文件中来，这个用法多用于在一个项目中有多个Makefile，分别在不同的目录下，这样我们可以写一个公共Makefile，这个Makefile中包含一些公共变量的定义，其他目录下的Makefile可以把这个公共Makefile文件包含进去。例子

view plaincopy to clipboardprint?

1. include ../Makefile.param  

include ../Makefile.param 

四、变量定义

1、变量的基础

在Makefile中，变量定义主要有如下几种方式：

view plaincopy to clipboardprint?

1. #方式一：定义多行变量   
2. define variable  
3. value  
4. value  
5. endef  
6. #方式二：   
7. variable = value  
8. #方式三：   
9. variable := value  
10. #方式四：   
11. variable += value  
12. #方式五：   
13. variable ?= value  

#方式一：定义多行变量define variablevaluevalueendef#方式二：variable = value#方式三：variable := value#方式四：variable += value#方式五：variable ?= value

这些定义方式中，按照展开方式不同分两类，方式一、方式二、方式五，都是使用时展开，就是无论前面如何定义，变量真正的含义都是到使用的时候才展开，而方式三是直接展开，就是变量定义的时候就展开为真正的值，而方式四是追加变量，他的展开方式要看原有的变量是如何定义的。有这种区别就导致一种结果，第一类方式定义的变量可以递归引用当前还未定义的变量，而第二类则不允许这样。

变量的引用可以采用$(variable)和${variable}两种方式。

2、变量的高级应用

变量的替换引用：$(VAR:A=B)把变量VAR中的所有有A的地方都替换为B，如

view plaincopy to clipboardprint?

1. foo := a.o b.o c.o  
2. bar := $(foo:.o=.c)  

foo := a.o b.o c.obar := $(foo:.o=.c)

override指示符：Makefile有一种特性，在Makefile中定义的常规变量，会被执行make命令是的参数变量覆盖，比如：

view plaincopy to clipboardprint?

1. #this is a makefile   
2. CFLAGS=-o  

#this is a makefileCFLAGS=-o

如果执行make时使用make CFLAGS=O2，那么CFLAGS会变为o2，

为了解决这个问题，可以使用override指示符

view plaincopy to clipboardprint?

1. #this is a makefile   
2. override CFLAGS=01  

#this is a makefileoverride CFLAGS=01

这样，参数变量中指定的内容不会覆盖Makefile中定义的变量。

目标指定变量和模式指定变量：通常Makefile中的变量都是全局的，而目标指定变量和模式指定变量都是对某个目标或者某种模式局部的，如：

view plaincopy to clipboardprint?

1. #目标指定变量   
2. foo:CFLAGS+=-O2  
3. #模式指定变量   
4. %.o:CFLAGS+=O1  

#目标指定变量foo:CFLAGS+=-O2#模式指定变量%.o:CFLAGS+=O1

五、条件判断

条件判断有如下四种形式：

view plaincopy to clipboardprint?

1. #1   
2. ifeq  
3.     do something  
4. else  
5.     do something  
6. endif  
7. #2   
8. ifneq   
9.     do something  
10. else  
11.     do something  
12. endif  
13. #3   
14. ifdef   
15.     do something  
16. else  
17.     do something  
18. endif  
19. #4   
20. ifndef   
21.     do something  
22. else  
23.     do something  
24. endif      

#1ifeq do somethingelse do somethingendif#2ifneq do somethingelse do somethingendif#3ifdef do somethingelse do somethingendif#4ifndef do somethingelse do somethingendif

六、函数

1、文本处理函数

subst

patsubst

strip

findstring

filter

filter-out

sort

word

words

wordlist

firstword

2、文件名处理

dir

notdir

suffix

basename

addsuffix

addprefix

join

wildcard

3、其他

error

warning

shell

origin

foreach

call

if

eval

value

七、规则

1、基础

规则是一个Makefile的核心，通俗的讲就是一句话：规则描述了何种情况下使用什么命令来重建一个特定的文件，三个元素，目标、依赖、命令，通常格式如下：

view plaincopy to clipboardprint?

1. TARGETS:PREREQUISITES  
2. [Tab]COMMAND  
3. TARGETS:PREREQUISITES;COMMAND  
4. [Tab]COMMAND  

TARGETS:PREREQUISITES[Tab]COMMANDTARGETS:PREREQUISITES;COMMAND[Tab]COMMAND

这三个要素都是有用户手动写出来的叫显示规则，如果没有，make也内建了一些常用的规则，make会自己去推导，这样的规则叫隐含规则。

2、显示规则

显示规则就是上面介绍的，规则的三要素都直接写出来的，

3、隐式规则

所谓隐式规则就是make会自动为一些目标推导依赖，推导命令的规则，可以在make中用-r或--no-builtin-rules来禁用。

下面列出c和c++相关的隐含规则：

1、编译c的隐含规则：<n>.o的目标的依赖会自动推导为<n>.c，并用命令$(CC) -c $(CPPFLAGS) $(CFLAGS)来生成.

2、编译c++的隐含规则:<n>.o的目标的依赖会自动推导为<n>.cc，并用命令$(CXX) -c $(CPPFLAGS) $(CFLAGS)来生成。

3、链接Object文件的隐含规则：<n>目标依赖于<n>.o，链接命令是$(CC) $(LDFLAGS)<n>.o $(LOADLIBES)$(LDLIBS),这一规则对多个依赖文件也是适用的，如x:y.o x.o z.o，但是依赖中至少要有同名的。

隐含规则通常都使用一些系统变量，先列出如下：

1、AR：默认是ar

2、CC：默认是cc

3、CXX:默认是g++

4、CPP：c程序的预处理器，默认是$(CC) -E

5、RM:删除文件，默认是rm -f

关于命令参数的变量：

1、ARFLAGS：打包程序AR的参数，默认是rv

2、CFLAGS：C语言的编译参数

3、CXXFLAGS：C++语言的编译器参数

4、CPPFLAGS：C预处理器参数

5、LDFLAFS：链接器参数

1、模式规则

隐含规则整体感觉太玄，但是可以用模式规则来定义隐含规则，它的目标中必须有%号，如:

 

view plaincopy to clipboardprint?

1. %.o:%.c  
2. <Tab>Command  

%.o:%.c<Tab>Command

这个就是模式规则，这个规则表明，所有<n>.c到<n>.o的编译都使用Command，而不是内建的默认命令。

2、静态模式规则

静态模式规则是模式规则中的一种特例，模式规则是对所有的符合模式的都起作用，而静态模式规则是对特定的目标是用的一种模式规则，如

view plaincopy to clipboardprint?

1. objects = foo.o bar.o  
2. all: $(objects)  
3. $(objects): %.o: %.c  
4. $(CC) -c $(CFLAGS) $< -o $@  
5.  
6. #相当于   
7. foo.o : foo.c  
8. $(CC) -c $(CFLAGS) foo.c -o foo.o  
9. bar.o : bar.c  
10. $(CC) -c $(CFLAGS) bar.c -o bar.o  

objects = foo.o bar.oall: $(objects)$(objects): %.o: %.c$(CC) -c $(CFLAGS) $< -o $@#相当于foo.o : foo.c$(CC) -c $(CFLAGS) foo.c -o foo.obar.o : bar.c$(CC) -c $(CFLAGS) bar.c -o bar.o

其中%.o:%.c这个模式规则是只对objects这个目标起作用的。

3、自动化变量

在写一些规则的时候，如果要把所有的目标和依赖都写出来，会很不方便，所以需要有个变量可以自动的赋值为目标或依赖，自动化变量就是这样一些变量，下面列举几个常用的自动化变量：

1、$@：规则中所有的目标文件集
2、$<：依赖的第一个文件，如果依赖是以模式定义的，那就表示所有依赖文件集

3、$^：规则中的依赖文件集，并且是做了重复删除的

4、$+：跟$^一样，就是没做重复删除。

八 例子

根据项目的大小，可以把项目建成平铺式（小型项目）和嵌套式（大型项目），而这两种项目的Makefile文件也会稍有不同，前者通常一个Makefile就可以，放在顶层目录，而后者需要分不同模块写几个不同的Makfile，通过一个顶层的Makefile来包含。

下面介绍一个可以用在通常平铺项目中的通用Makefile：

view plaincopy to clipboardprint?

1. #以下定义目录结构   
2. SRC_DIR := ./src  
3. INC_DIR := ./include/a /  
4.        ./include/b /  
5.        ./include  
6. LIB_DIR := ./lib  
7.  
8. #以下定义编译工具链   
9. CROSS=arm-hismall-linux-  
10. CC=$(CROSS)gcc  
11. AR=$(CROSS)ar  
12. RANLIB=$(CROSS)ranlib  
13. RM=rm -f  
14.  
15. #以下定义编译参数   
16. CFLAGS :=  
17. DEPENDFLAG :=-MM  
18. LIB=$(foreach dir, $(LIB_DIR), -L$(dir))  
19. LIBFLAGS=-lprint  
20. INC=$(foreach dir, $(INC_DIR), -I$(dir))  
21.  
22.  
23. #以下定义文件变量   
24. SRCS=$(foreach dir, $(SRC_DIR), $(wildcard $(dir)/*.c)) 
25. OBJS=$(SRCS:.c=.o) 
26. DEPENDS=$(SRCS:.c=.d) 
27. TARGET=test 
28.  
29.  
30. #下面定义规则 
31. all:$(TARGET)  
32.  
33. %.d:%.c 
34.     @set -e; rm -f $@;/ 
35.     $(CC) $(DEPENDFLAG) $(INC) $< |/ 
36.     sed "s?//(.*//):?$(basename $<).o $(basename $<).d:?g"/  
37.     > $@;/  
38.   
39. %.o:%.c  
40.     $(CC) -o $@ -c $< $(INC)  
41.   
42.   
43. $(TARGET):$(OBJS)  
44.     $(CC) -o $@ $< $(LIB) $(LIBFLAGS)  
45.   
46.   
47. -include $(DEPENDS)  
48.       
49.   
50. .PHONY:clean  
51. clean:  
52.     $(RM) $(OBJS) $(DEPENDS) $(TARGET)  

#以下定义目录结构SRC_DIR := ./srcINC_DIR := ./include/a / ./include/b / ./includeLIB_DIR := ./lib#以下定义编译工具链CROSS=arm-hismall-linux-CC=$(CROSS)gccAR=$(CROSS)arRANLIB=$(CROSS)ranlibRM=rm -f#以下定义编译参数CFLAGS :=DEPENDFLAG :=-MMLIB=$(foreach dir, $(LIB_DIR), -L$(dir))LIBFLAGS=-lprintINC=$(foreach dir, $(INC_DIR), -I$(dir))#以下定义文件变量SRCS=$(foreach dir, $(SRC_DIR), $(wildcard $(dir)/*.c))OBJS=$(SRCS:.c=.o)DEPENDS=$(SRCS:.c=.d)TARGET=test#下面定义规则all:$(TARGET) %.d:%.c@set -e; rm -f $@;/$(CC) $(DEPENDFLAG) $(INC) $< |/sed "s?//(.*//):?$(basename $<).o $(basename $<).d:?g"/> $@;/%.o:%.c$(CC) -o $@ -c $< $(INC)$(TARGET):$(OBJS)$(CC) -o $@ $< $(LIB) $(LIBFLAGS)-include $(DEPENDS).PHONY:cleanclean:$(RM) $(OBJS) $(DEPENDS) $(TARGET)

这里用到一个实用的技术，就是利用gcc的-MM选项，来自动分析一个.c文件所包含的.h文件，并用一段shell代码来生成一个叫依赖文件的.d文件，这个文件中包含一组依赖关系如：

view plaincopy to clipboardprint?

1. a.c a.d:a.h b.h c.h  

a.c a.d:a.h b.h c.h

用来产生.d文件的规则就是下面这段

view plaincopy to clipboardprint?

1. %.d:%.c  
2.     @set -e; rm -f $@;/  
3.     $(CC) $(DEPENDFLAG) $(INC) $< |/  
4.     sed "s?//(.*//):?$(basename $<).o $(basename $<).d:?g"/  
5.     > $@;/  

%.d:%.c@set -e; rm -f $@;/$(CC) $(DEPENDFLAG) $(INC) $< |/sed "s?//(.*//):?$(basename $<).o $(basename $<).d:?g"/> $@;/

这其实是一个模式规则，所有.c文件到.d文件的编译都用这组命令。

生成.d文件后，包含进Makefile，就是一组规则，这就是自动生成依赖