0
点赞
收藏
分享

微信扫一扫

一起学习Makefile

婉殇成长笔记 2022-04-19 阅读 174
c++

        在介绍makefile和make的具体概念前,我们先通过一个例子来说明makefile和make到底是为解决什么问题而存在的。

假设有一个如图所示的C工程:

那么我们需要按照如下步骤依次编译

# 步骤1:编译主程序模块
$ gcc -o <100个主程序模块的o文件> -c <100个主程序模块的c文件>

# 步骤2:编译功能模块a
$ gcc -o <1000个功能模块a的o文件> <1000个功能模块a的c文件>
$ ar rcs liba.a <1000个功能模块a的o文件>

# 步骤3:编译功能模块b
$ gcc -o <1000个功能模块b的o文件> <1000个功能模块b的c文件>
$ ar rcs libb.a <1000个功能模块b的o文件>

# 步骤4:生成可执行文件demo
$ gcc -o demo <100个主程序模块的o文件> -L. -la -lb

上面的编译需要将所有的文件列出,并且修改其中一部分后仍然需要重新编译所有文件,这个过程如果项目很大的话,会很耗时。

make和makefile的存在正是为了解决上述两个问题的:

  1. makefile文件帮助我们记录了整个项目工程的所有需要编译的文件列表,这样我们在编译时仅需要输入简单的make命令就能编译出我们期望的结果
  2. makefile文件反映了整个项目中各个模块的依赖关系,这样我们改动了某些源文件后,仅需简单的输入make命令,make工具就会根据makefile文件里描述的依赖关系帮助我们分析哪些模块需要重新编译,并执行相应的操作。

在linux/unix开发环境中,makefile文件则是描述了一个特定编译系统所需要的策略,而make工具则是通过解析makefile文件并执行相应的命令来帮助我们构建其编译系统。

一条makefile的规则构成如下:

target:prerequisites
<tab> command1
<tab> command2
.....
<tab> commandN
  • target:规则的目标,可以简单理解为这条规则存在的目的是什么。通常是程序中间或者最后需要生成的文件名,也可以不对应具体的文件,而仅仅就是个概念上的规则目标。
  • prerequisites:规则的依赖列表,可以简单的理解为要达到本条规则的目标所需要的先决条件是什么。可以是文件名,也可以是其他规则的目标;
  • command:规则的命令,可以简单的理解为当目标所需要的先决条件的满足了之后,需要执行什么动作来达成规则的目标。规则的命令其实就是shell命令。一条规则中可以有多行命令,特别注意:每行命令都必须以tab键开始!

这个简单的makefile文件,只有一条规则,规则的目标是all,没有任何依赖(规则不可以没有目标但是可以没有依赖),以及一条命令(其实规则也是可以不需要任何命令的)。

举个简单的例子,创建makefile然后填入如下代码:

all:
    echo "Hello world"

保存后执行 make语句。

make命令的基本使用范式如下:

make [ -f makefile ] [ options ] ... [ targets ] ...

使用make命令的最简单的方式主要有以下四种形式:

在执行make的时候,我们可以带上-f <文件名>参数,来指定make命令从哪里读取makefile文件;而如果我们不显式指定,则make就会在当前目录下依次查找名字为GNUmakefile, makefile,和 Makefile的文件来作为其makefile文件。

在读取完makefile的内容后,make工具并不是逐条去执行makefile里的规则,而是以某条规则为突破口,多米诺骨牌效应式的去执行makefile里的规则。而这条作为突破口的规则的目标,称为终极目标 ,我们可以在执行make时以参数的形式指定终极目标,从而执行作为突破口的规则,如果我们不显式指定终极目标,make一般情况下将选择makefile的第一条规则的目标作为终极目标。

make解析makefile的流程如下:

假设有mekefile内容如下:

终极目标:依赖A  依赖B 依赖C
    终极目标命令
    
依赖A:子依赖A1 子依赖A2 
    依赖A命令
    
依赖B:子依赖B1 子依赖B2 
    依赖B命令

依赖C:子依赖C1 子依赖C2 
    依赖C命令

 过程二,对整颗依赖树以从底到上,从左到右的顺序,解析执行每一条规则:

本节我们将通过构建一个简单的c语言项目工程(我们命名为project_simple)来理解makefile的基本概念。

在linux系统下执行如下一系列命令来探索makefile

shiyanlou:Code/ $ mkdir project                                      [14:58:09]
shiyanlou:Code/ $ cd project                                         [14:58:18]
shiyanlou:project/ $ cat > main.c <<EOF                              [14:58:21]
heredoc> extern void simple();
heredoc> int main()
heredoc> {
heredoc>        simple();
heredoc>        return 0;
heredoc> }
heredoc> EOF
shiyanlou:project/ $ cat main.c                                      [14:59:44]
extern void simple();
int main()
{
	simple();
	return 0;
}
shiyanlou:project/ $ cat >simple.c <<EOF                             [14:59:56]
heredoc> #include<stdio.h>
heredoc> void simple()
heredoc> {
heredoc>        printf("This is simple project!
");
heredoc> }
heredoc> EOF
shiyanlou:project/ $ cat simple.c                                    [15:01:42]
#include<stdio.h>
void simple()
{
	printf("This is simple project!
");
}
shiyanlou:project/ $ cat >makefile <<EOF                             [15:01:45]
heredoc> simple: main.c simple.c
heredoc>        gcc -o simple main.c simple.c
heredoc> EOF
shiyanlou:project/ $ cat ma                                          [15:02:59]
cat: ma: ?????????
shiyanlou:project/ $ cat makefile                                    [15:03:02]
simple: main.c simple.c
	gcc -o simple main.c simple.c
shiyanlou:project/ $ pwd                                             [15:03:11]
/home/shiyanlou/Code/project
shiyanlou:project/ $ ls                                              [15:03:16]
main.c  makefile  simple.c
shiyanlou:project/ $ make                                            [15:03:17]
gcc -o simple main.c simple.c
shiyanlou:project/ $ ./simple                                        [15:03:25]
This is simple project!
shiyanlou:project/ $   

 

makefile 工具箱1

// ---------------------------------------------
// main.c
#include <stdio.h>
#include "complicated.h"
int main()
{
    printf("%s\n", HELLO_STRING);
    complicated();
    return 0;
}
// ---------------------------------------------
// complicated.h
#ifndef __COMPLICATED_H__
#define __COMPLICATED_H__
#define HELLO_STRING "Hello !"
#define PROJECT_NAME "complicated"
extern void complicated(void);
#endif
// ---------------------------------------------
// complicated.c
#include <stdio.h>
#include "complicated.h"
void complicated(void)
{
    printf("This is a %s porject!\n", PROJECT_NAME);
}

 

各个项目间的依赖关系

        熟悉gcc编译过程的朋友应该知道,其实我们在用gcc 编译出可执行文件的过程中是包含两个阶段的:编译阶段和链接阶段。

        我们上述的依赖关系图更加准确的反映出了整个项目的构建过程,这样我们据此写出来的makefile才能更加灵活及更具可扩展性,记住:精确的分析清楚项目的依赖关系,是编写一个好的makefile的关键。

makefile文件如下:

complicated: main.o complicated.o
    gcc -o complicated main.o complicated.o

main.o: main.c
    gcc -o main.o -c main.c
    
complicated.o: complicated.c
    gcc -o complicated.o -c complicated.c

makefile中的变量

        makefile中的变量,与C语言中的宏类似,它为一个文本字符串(变量的值,其类型只能是字符串类型)提供了一个名字(变量名)。

变量定义的格式:

变量名 赋值符 变量值

 

  • 变量名指的就是该变量的名字,是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。需要注意的是,尽管在GNU make中没有对变量的命名有其它的限制,但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的,因为除字母、数字和下划线以外的其它字符可能会在以后的make版本中被赋予特殊含义,并且这样命名的变量对于一些shell来说不能作为环境变量使用。变量名是大小写敏感的。变量“foo”、“Foo”和“FOO”指的是三个不同的变量。Makefile传统做法是变量名是全采用大写的方式。推荐的做法是在对于内部定义定义的一般变量(例如:目标文件列表objects)使用小写方式,而对于一些参数列表(例如:编译选项CFLAGS)采用大写方式。
  • 变量值,指的是变量所代表的内容,可以是一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列表、编译输出的目录列表和所有我们能够想到的事物。变量的值,其本质就是一个字符串。
  • 赋值符,有= 、 := 、 ?=和 +=四种格式,其中= 和 := 为基本定义类型, ?=和 +=为基于=的扩展定义类型。

一个具体的例子:

objects = program.o foo.o utils.o

变量引用 

当我们定义了一个变量之后,我们就可以在makfile中的目标依赖命令中引用我们的变量;而所谓的变量引用,就是在引用变量名的地方,用变量所代表的内容,执行一个严格的文本替换过程(该过程也称为变量被展开的过程 ),替换掉变量的名字。

变量的引用有以下几种方式:

${变量名}
$(变量名)
$单字符变量名 ,变量名仅包含一个字符,如$@ 、$^等
# 变量定义
objects = program.o foo.o utils.o

program : $(objects)          #在依赖中引用变量
    gcc -o program ${objects} #在命令中引用变量

$(objects) : defs.h           #在目标中引用变量

 变量分类与赋值

根据变量定义时所使用的赋值操作符的不同,可以将变量分成两种类型(或者说是两种风格):

递归展开式变量直接展开式变量

foo1 = $(bar)   #递归展开式变量
foo2 := $(bar)  #直接展开式变量
bar = $(ugh)
ugh = Huh?

all:
    echo "foo1 is $(foo1), foo2 is $(foo2)"

 

由于变量foo1的变量值是在执行echo命令时才求的值,所以foo1的值被递归的展开为Huh?; 而变量foo2的变量值在定义时就被求值了,此时由于变量bar的值为空,因此foo2的值也为空。

+= 和 ?=是基于=扩展而来的两种变量赋值操作符;

+= 称为追加赋值操作符,它实现对于一个已经存在定义的变量进行追加赋值,如下例子:

bar = foo1   
bar += foo2  #追加赋值,bar的值将为 foo1 foo2

all:
    echo $(bar)

 

在makefile 中用户除了可以自定义变量外,还可以使用make工具为我们提供的一些特殊的变量及用法。

$@ -- 代表规则中的目标文件名

$< -- 代表规则的第一个依赖的文件名

$^ -- 代表规则中所有依赖文件的列表,文件名用空格分割

看例子,编写makefile 文件 /home/shiyanlou/Code/makefile_sample/auto_var.mk:

all: first second third
    echo "\$$@ = $@"
    echo "$$< = $<"
    echo "$$^ = $^"

first second third:

这里有几点需要说明一下:

 

变量的替换引用 

  • 变量的分类与赋值

对于一个已经定义的变量,可以使用“替换引用”将其值使用指定的字符(字符串)进行替换。格式为$(VAR:A=B)或者${VAR:A=B},意思是,将变量“VAR”所表示的值中所有字符串“A”结尾的字符替换为“B”的字。“结尾”的含义是空格之前(变量值的多个字以空格分开)。而对于变量其它部分的“A”字符不进行替换。例如:

sources := a.c b.c c.c d.d
objects := $(sources:.c=.o)
all:
    echo "objects = $(objects)"

 

//结果
sources := a.c b.c c.c d.d
objects := $(sources:.c=.o)
all:
    echo "objects = $(objects)"

在这个定义中,变量“objects”的值就为“a.c b.c c.c d.d”。使用变量的替换引用将变量“sources”以空格分开的值中的所有的字的尾字符“o”替换为“c”,其他部分不变,注意这里的d.d并不会被替换。

使用变量改进我们complicated项目的makefile(v1.2):

# 描述:complicated 项目 makefile文件
# 版本:v1.2
# 修改记录:
# 1. 为complicated项目makefile添加注释
# 2. 使用变量改进我们complicated项目的makefile

# 定义可执行文件变量
executbale := complicated
# 定义源文件列表变量
sources := main.c complicated.c
# 使用变量的引用替换,定义object文件列表
objects := $(sources:.c=.o)
# 定义编译命令变量
CC := gcc

# 终极目标规则,生成complicated可执行文件
$(executbale): $(objects)
#  使用自动化变量改造我们的编译命令
    $(CC) -o $@ $^

# 子规则1, main.o的生成规则
main.o: main.c
    $(CC) -o $@  -c $<
    
# 子规则2,complicated.o的生成规则
complicated.o: complicated.c
    $(CC) -o $@  -c $<

更加深入认识makefile规则 

  • 多目标规则
targets...: prerequisites...
    commands
    ...
all: target1 target2
    echo "This is a rule for $@"

# 利用多目标规则合并 target1 和target2的规则
target1 target2: dep
    echo "This is a rule for $@"
    
dep:

 

  • 多规则目标

Makefile中,一个目标可以同时出现在多条规则中。

  静态规则模式

仔细观察我们的complicated项目中的两条子规则:

# 子规则1, main.o的生成规则
main.o: main.c
    $(CC) -o $@  -c $<
    
# 子规则2,complicated.o的生成规则
complicated.o: complicated.c
    $(CC) -o $@  -c $<

静态模式规则:

静态模式规则,其基本语法:

其大致意思就是,用TARGET-PATTERN: PREREQ-PATTERNS ...描述的模式,从TARGETS ...取值来形成一条条规则,所有规则的命令都用COMMANDS

TARGETS ...代表具有相同模式的规则的目标列表,在我们的项目中就是main.o和complicated.o,我们可以直接引用我们先前定义的objects变量。

TARGET-PATTERN: PREREQ-PATTERNS ...部分定义了,如何为目标列表中的目标,生成依赖;TARGET-PATTERN称为目标模式,PREREQ-PATTERNS称为依赖模式;目标模式和依赖模式中,一般需要包含模式字符%

目标模式的作用就是从目标列表中的目标匹配过滤出需要的值,目标模式中的字符%表示在匹配过滤的过程中不做过滤的部分,目标模式中的其他字符表示要与目标列表中的目标精确匹配,例如,目标模式%.o, 表示从目标列表的目标中匹配所有以.o结尾的目标,然后过滤掉匹配目标的.o部分, 因此目标main.o经过目标模式%.o匹配过滤后,得到的输出就是main

依赖模式的作用就是表示要如何生成依赖文件。具体的生成过程,就是使用目标模式过滤出来的值,替换依赖模式字符%所表示的位置。因此,如果依赖模式为%.c, 则使用上述例子过滤出来的main来替换字符%, 最终得到依赖文件main.c

因此,我们可以这么用静态模式规则来简化我们的complicated项目:

# 静态模式规则简化complicated makefile
$(objects): %.o: %.c
    $(CC) -o $@  -c $<

伪目标 

我们的complicated项目编译完成后,会有可执行文件及中间目标文件,有时出于某些需求,需要将编译生成的文件都删除,让整个项目回到最初的状态。我们可以在该项目makefile定义添加一条目标为clean的规则,如下:

# complicated项目添加clean 规则
clean:
    rm -rf complicated complicated.o main.o

出现以上问题的原因是,当编译目录下存在clean文件时,由于clean规则没有依赖,所以clean文件的时间戳永远显得都是最新的,故其命令也无法被执行,这时我们就得请伪目标出手帮助了。

当我们将一个目标定义成伪目标时,意味着它不代表一个真正的文件名,在执行make时可以指定这个目标来执行其所在规则定义的命令。

定义一个伪目标的基本语法:

.PHONY: <伪目标>

因此我们以定义complicated项目的clean目标,为伪目标,如下:

# complicated项目添加clean 规则
.PHONY: clean
clean:
    rm -rf complicated complicated.o main.o

这样目标clean就是一个伪目标,无论当前目录下是否存在clean这个文件。我们输入make clean之后。rm命令都会被执行。

对makefile规则更加深入认识 

  • 命令的回显

通常,make在执行命令行之前会把要执行的命令行进行输出,如以下makefile:

在执行make时,其输出:

关闭命令回显有以下几种方式:

  1. 每个需要关闭回显的命令行前加上"@"字符,上述例子关闭回显:

    all:
        @echo "Hello world!"
    

  2. 执行make时带上参数-s--slient禁止所有执行命令的显示

  3. 在Makefile中使用没有依赖的特殊目标.SILENT也可以禁止所有命令的回显

在Makefile中书写在同一行中的多个命令属于一个完整的shell命令行书写在独立行的一条命令是一个独立的shell命令行。所以需要注意:在一个规则的命令中,命令行cd改变目录不会对其后的命令的执行产生影响。就是说其后的命令执行的工作目录不会是之前使用cd进入的那个目录。如果要实现这个目的就不能把cd和其后的命令放在两行来书写。而应该把这两条命令写在一行上,用分号分隔。这样它们才是一个完整的shell命令行。

对比以下例子两个规则的输出,编写makefile 文件 /home/shiyanlou/Code/makefile_sample/cmd.mk:

target1:
    @echo "target1"
    @cd ~
    @pwd
    
target2:
    @echo "target2"
    @cd ~; pwd

 

  • 命令执行的错误处理

通常情况下,规则中的每一条命令在运行结束后,make都会检测命令执行的返回状态,如果返回成功,就执行下一条命令;命令出错(返回状态非0),make就会放弃对当前规则的执行,或者终止对当前makefile的解析执行。

在一些情况下,规则中的一个命令的执行失败并不代表规则执行的错误。为了忽略一些无关紧要的命令执行失败的情况,我们可以在命令之前加一个减号-,来告诉make忽略此命令的执行失败检查。 

在更加深入的认识了makefile的规则后,我们complicated项目的makefile(v1.3)就可以这样写了:

 

# 描述:complicated 项目 makefile文件
# 版本:v1.3
# 修改记录:
# 1. 为complicated项目makefile添加注释
# 2. 使用变量改进我们complicated项目的makefile
# 3. 使用静态模式规则,简化makefile
# 4. 使用伪目标,加上clean规则

# 定义可执行文件变量
executbale := complicated
# 定义源文件列表变量
sources := main.c complicated.c
# 使用变量的引用替换,定义object文件列表
objects := $(sources:.c=.o)
# 定义编译命令变量
CC := gcc
RM := rm -rf

# 终极目标规则,生成complicated可执行文件
$(executbale): $(objects)
#  使用自动化变量改造我们的编译命令
    $(CC) -o $@ $^

# 子规则, main.o和complicated.o的生成规则,使用静态模式规则
$(objects):%.o:%.c
    $(CC) -o $@  -c $<
        
# clean规则
.PHONY: clean
clean:
    $(RM) $(executbale) $(objects)

 内嵌函数

make的内嵌函数为我们提供了处理文件名、变量、文本和命令的方法。使我们的Makefile更为灵活和健壮。我们可以在需要的地方调用函数来处理指定的文本(参数),函数在调用它的地方被替换为它的处理结果。函数调用(引用)的展开和变量引用的展开方式类似:

函数调用方式1:

函数调用方式2:

  • 内嵌函数的分类

 

  • 使用wildcard函数改进complicated项目makefile

wildcard函数,其使用范式:

$(wildcard *.c) 

返回值为当前目录下所有.c源文件列表。

我们可以引进wildcard函数,改进complicated项目的makefile,使其能够自动扫描当前目录下的源文件:

# 描述:complicated 项目 makefile文件
# 版本:v1.4
# 修改记录:
# 1. 为complicated项目makefile添加注释
# 2. 使用变量改进我们complicated项目的makefile
# 3. 使用静态模式规则,简化makefile
# 4. 使用伪目标,加上clean规则
# 5. 引进wildcard函数,自动扫描当前目录下的源文件

# 定义可执行文件变量
executbale := complicated
# 引进wildcard函数扫描源文件,定义列表变量
sources := $(wildcard *.c)
# 使用变量的引用替换,定义object文件列表
objects := $(sources:.c=.o)
# 定义编译命令变量
CC := gcc
RM := rm -rf

# 终极目标规则,生成complicated可执行文件
$(executbale): $(objects)
#  使用自动化变量改造我们的编译命令
    $(CC) -o $@ $^

# 子规则, main.o和complicated.o的生成规则,使用静态模式规则
$(objects):%.o:%.c
    $(CC) -o $@ -c $<
        
# clean规则
.PHONY: clean
clean:
    $(RM) $(executbale) $(objects) 

  自动生成依赖关系

至此,我们complicated项目的makefile已经完成的比较完善了,但还存在一个问题,当我们更新头文件complicated.h的内容后,执行make时,项目并不会重新编译,看演示:

出现以上问题的根本原因是,我们的makefile还没能精确的反映整个项目工程的依赖关系!很明显,项目的依赖关系应该加入对于头文件的依赖,即如下图:

根据上述依赖关系,我们可以在makefile加上如下规则:

$(objects): complicated.h

上述新增规则,是一条多目标规则,它与之前的静态模式规则,又组成了多规则目标,读者可自行思考其工作原理。

上述规则加入虽然能解决我们的问题,但是对于大型复杂的项目,这种需要我们逐个去分析头文件被依赖的关系,几乎是不可能的。所以我们需要工具来帮我们做这个事。下面我们来介绍如何实现自动生成依赖关系。

gcc为我们提供了这样的功能,帮助我们分析一个文件对其他文件的依赖关系列表。当我们在执行gcc时带上-MM选项时,gcc工具就会为我们列出指定文件对其他文件的依赖关系列表。直接来看例子:

接下来要考虑的问题就是如何将gcc的输出导入到我们的makefile中了。

makefile支持使用sinclude关键字将指定文件导入到当前的makefile当中,它的作用与C语言的#inlucde预处理命令是一样的。使用方式sinclude <other_makefiles>。因此,我们可以将gcc对于源文件的依赖关系分析输出到某个文件(我们可以称为依赖描述文件,一般命名为与源文件同名但以.d结尾的文件)当中,然后再将依赖描述文件导入到makefile中。

# 使用变量的引用替换,定义依赖描述文件列表

deps := $(sources:.c=.d) # 导入依赖描述文件列表

sinclude $(deps)

当我们使用sinclude关键字向当前makefile导入文件时,如果所导入的文件不存在,make会试图去执行可以生产导入文件的规则去生产被导入的文件,然后再执行导入。因此我们可以使用静态模式规则,让make在执行时,去调用gcc生成依赖关系文件,我们可以这么写:

$(deps):%.d:%.c
    gcc -MM $< > $@

 因此,我们complicated项目的最终makefile可以这么写:

# 描述:complicated 项目 makefile文件
# 版本:v1.5
# 修改记录:
# 1. 为complicated项目makefile添加注释
# 2. 使用变量改进我们complicated项目的makefile
# 3. 使用静态模式规则,简化makefile
# 4. 使用伪目标,加上clean规则
# 5. 引进wildcard函数,自动扫描当前目录下的源文件
# 6. 加入自动规则依赖

# 定义可执行文件变量
executbale := complicated
# wildcard函数扫描源文件,定义列表变量
sources := $(wildcard *.c)
# 使用变量的引用替换,定义object文件列表
objects := $(sources:.c=.o)
# 使用变量的引用替换,定义依赖描述文件列表
deps := $(sources:.c=.d)

# 定义编译命令变量
CC := gcc
RM := rm -rf

# 终极目标规则,生成complicated可执行文件
$(executbale): $(objects)
#  使用自动化变量改造我们的编译命令
    $(CC) -o $@ $^

# 子规则, main.o和complicated.o的生成规则,使用静态模式规则
$(objects):%.o:%.c
    $(CC) -o $@  -c $<
        
# clean规则
.PHONY: clean
clean:
    $(RM) $(executbale) $(objects) $(deps)

# 自动规则依赖
sinclude $(deps)

$(deps):%.d:%.c
    $(CC) -MM $< > $@

总结 

我们学习了 make 工具的使用,主要包括以下的内容:

  • makefile 规则的概念
  • makefile 变量的使用
  • makefile 函数的使用
  • makefile 自动生成依赖

参考资料

  • 专业嵌入式软件开发
  • Gnu make 中文手册

 

 

 

举报

相关推荐

0 条评论