简单的驱动makefile解析
Linux 2.6 （PC）简单驱动Makefile详解
ifneq ($(KERNELRELEASE),)
module-objs := book.o
obj-m := book.o
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
endif
clean:
rm -rf *.o *~core.depend.*.cmd *.ko *.mod.c.tmp versions
KERNELRELEASE 内核顶层目录Makefile的一个变量。
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
内核源码树目录。
该Makefile 共读取两次，在输入Makefile时，$(KERNELDIR) 第一次读取KERNELRELEASE并没有被定义，然后就开始读取内核源码的目录，开始定义KERNELRELEASE，然后到当前模块的目录里面，M=$(PWD) 进入该Makefile时KERNELRELEAS已经被定义了，读取要编译的模块，然后再返回到modules
编译完成，产生.KO文件
Linux 2.6 （ARM）简单驱动Makefile详解
ifneq ($(KERNELRELEASE),)
obj-m := fgpio011.o
else
KDIR := /dsw/8126/arm-linux-2.6.28/linux-2.6.28-fa/
all:
make -C $(KDIR) M=$(PWD) modules ARCH=arm
CROSS_COMPILE=arm-none-linux-gnueabi-
clean:
rm -f *.ko *.o *.mod.o *.mod.c *.symvers
endif
注释：
KDIR := /dsw/8126/arm-linux-2.6.28/linux-2.6.28-fa/ KDIR 指定开发板内核所在目录。
CROSS_COMPILE=arm-none-linux-gnueabi- 指定编译器。
其它项目与PC机的一样。
驱动模块编译进内核。
windows下makefile命令详解
windows下makefile命令详解1. 如果已经有vc6的dsp⼯程，可直接导出nmake脚本⽂件(.mak)“Project - Export Makefile...”nmake -f nMakeTest.mak CFG="nMakeTest - Win32 Debug"nmake -f nMakeTest.mak CFG="nMakeTest - Win32 Debug" allnmake -f nMakeTest.mak CFG="nMakeTest - Win32 Release" clean注：如果未指定/F选项，则使⽤当前⽬录下的名为makefile的⽂件【nmake /?】获取更多帮助！ vc6：【D:\program files\Microsoft Visual Studio\VC98\Bin】vs2008：【D:\program files\Microsoft Visual Studio 9.0\VC\bin】为了能正确地使⽤命令⾏⼯具及vc6或vs2008下的函数库，需要对⼀些环境变量进⾏设置，最快捷地⽅式是通过如下⽅式打开命令⾏窗⼝（以vs2008为例）：2. vs的c++⼯程没有提供导出nmake脚本⽂件的功能，我们只有借助⼯具或⼿动编写nmake脚本⽂件了++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++3. rc.exe 【将.rc资源⽂本转变成.res⼆进制⽂件】/l 0x804 // 默认语⾔ID(⼗六进制数表⽰) 0x804:简体中⽂ 0x409:美国/fo"nMakeTest.res" // 指定rc⽂件输出的res名称例：rc.exe /l 0x804 /fo"nMakeTest.res" /d "_DEBUG" /d "_AFXDLL" “nMakeTest.rc”4. cl.exe 常见选项【将.c，.cpp，.cxx编译成obj⽂件】/nologo // 不打印版权申明信息/I "../include" // 添加头⽂件查找路径（如果路径中带有空格，⼀定要⽤引号括起来）/DWIN32 // 预编译宏定义(win32程序)/D_CONSOLE // 预编译宏定义（控制台程序）/D "_DEBUG" // 预编译宏定义（Debug版本）/D_CRT_SECURE_NO_DEPRECATE // 预编译宏定义（关闭C4996警告。
Makefile 语法分析
Makefile 语法分析第一部分VERSION = 2# 给变量VERSION赋值PATCHLEVEL = 6# 给变量PATCHLEVEL赋值SUBLEVEL = 22# 给变量SUBLEVEL赋值EXTRAVERSION = .6# 给变量EXTRAVERSION赋值NAME = Holy Dancing Manatees, Batman!# 给变量NAME赋值# *DOCUMENTATION*# To see a list of typical targets execute "make help"# More info can be located in ./README# Comments in this file are targeted only to the developer, do not# expect to learn how to build the kernel reading this file.# Do not:# o use make's built-in rules and variables# (this increases performance and avoid hard-to-debug behavour);# o print "Entering directory ...";MAKEFLAGS += -rR --no-print-directory# 操作符“+=”的作用是给变量（“+=”前面的MAKEFLAGS）追加值。
# 如果变量（“+=”前面的MAKEFLAGS）之前没有定义过，那么，“+=”会自动变成“=”；# 如果前面有变量（“+=”前面的MAKEFLAGS）定义，那么“+=”会继承于前次操作的赋值符；# 如果前一次的是“:=”，那么“+=”会以“:=”作为其赋值符# 在执行make时的命令行选项参数被通过变量“MAKEFLAGS”传递给子目录下的make程序。
驾驭makefile
This program built for i686-pc-cygwin
图 1.1
1.2 规则
Hello World 几乎是所有编程语言进行语言讲解时采用的一个最为简单的例子，虽然 Makefile 不是一个编程语言，但同样不防碍我们写一个在命令终端上输出“Hello World”的简单 Makefile。 采用一个文本编辑器编写一个如图 1.2 所示的 Makefile 文件，文件的存放目录可以是任意的。 Makefile all:
我们说 Makefile 中第一个很重要的概念就是目标（target）, 图 1.2 所示的 Makefile 中的 all 就 是我们的目标，目标放在‘：’的前面，其名字可以是由字母和下划线‘_’组成。echo “Hello World” 就是生成目标的命令，这些命令可以是任何你可以在你的环境中运行的命令以及 make 所定义的函 数等等，后面我们会再细谈，现在只要知识 echo 是 BASH Shell 中的一个命令就行了，其功能是打 印字符串到终端上。all 目标在这里就是代表我们希望在终端上打印出“Hello World”，有时目标会 是一个比较抽象的概念。all 目标的定义，其实是定义了如何生成 all 目标，这我们也称之为规则， 即我们说图 1.2 的 Makefile 中定义了一个生成 all 目标的规则。
图 1.9
这里需要引入 Makefile 中依赖关系的概念，图 1.8 中 all 目标后面的 test 是告诉 make，all 目 标依赖 test 目标，这一依赖目标在 Makefile 中又被称之为先决条件。出现这种目标依赖关系时，make 工具会按从左到右的先后顺序先构建规则中所依赖的每一个目标。如果希望构建 all 目标不，那么 make 会在构建它之前得先构建 test 目标，这就是为什么我们称之为先决条件的原因。图 1.10 采用 UML 的类图表达了 all 目标的依赖关系。
python makefile 用法
python makefile 用法在使用Python编写程序时，我们通常需要编译和运行代码，这就需要用到makefile。
makefile是一种可以自动化地构建程序的工具，它可以根据代码修改的情况自动判断哪些文件需要重新编译，从而提高程序的编译效率。
使用makefile的基本步骤如下：1. 创建一个名为makefile的文件，通常放在程序的根目录下。
2. 在makefile中定义一些变量，如编译器、编译选项等。
3. 定义一些规则，如编译规则、目标规则等。
4. 运行make命令，根据makefile的规则进行编译和链接。
下面是一个简单的makefile示例：```# 定义编译器和编译选项CC=gccCFLAGS=-Wall -g# 定义编译规则%.o: %.c$(CC) $(CFLAGS) -c $< -o $@# 定义目标规则main: main.o sub.o$(CC) $(CFLAGS) main.o sub.o -o main# 清除中间文件clean:rm -f *.o main```在这个示例中，我们定义了两个变量CC和CFLAGS，分别表示编译器和编译选项。
接着定义了一个编译规则，表示将.c文件编译成.o文件的过程。
其中，$<表示依赖文件（即输入文件），$@表示目标文件（即输出文件）。
最后定义了一个目标规则，表示将main.o和sub.o链接成可执行文件main。
最后，我们定义了一个清除中间文件的规则，可以通过运行make clean来清除中间文件。
可以通过运行make命令来编译和链接程序。
例如，如果你有一个名为main.c和sub.c的源文件，并想将它们编译成可执行文件main，可以在终端中输入以下命令：```$ make main```这将根据makefile中定义的规则自动编译和链接程序，并生成可执行文件main。
总之，makefile是一个非常有用的编译工具，可以帮助我们自动化地构建程序，提高编译效率。
makefile -d 用法
makefile -d 用法摘要：1.Makefile 简介2.makefile -d 用法详解a.参数含义b.使用方法c.实例演示3.makefile -d 在实际项目中的应用4.总结正文：Makefile 是一个项目管理工具，主要用于自动化构建和编译软件项目。
在Makefile 中，我们可以定义一系列的规则，用于描述软件项目各文件的依赖关系以及编译命令等。
今天，我们将详细了解一下makefile -d 的用法。
1.Makefile 简介首先，让我们简要了解一下Makefile 的基本概念。
Makefile 是一个包含一系列命令和规则的文本文件，通常位于项目的根目录下。
它告诉make 命令如何自动构建、编译和链接项目。
2.makefile -d 用法详解接下来，我们将详细解释makefile -d 的参数含义、使用方法和实例演示。
a.参数含义-d 选项是makefile 的调试模式，它会在执行规则之前输出规则的详细信息，便于开发者调试和理解Makefile 的执行过程。
b.使用方法要使用makefile -d 选项，只需在调用make 命令时添加-d 参数即可，如下所示：```make -d```c.实例演示下面，我们通过一个简单的实例来演示如何使用makefile -d。
假设我们有一个名为`example.mk`的Makefile，其内容如下：```all: main.occ main.o -o mainmain.o: main.ccc main.c -o main.o```现在，我们使用make -d 命令来执行Makefile：```make -d```执行结果如下：```make: Entering directory `."main.mk:3: recipe for target "all"main.mk:3: cc main.o -o mainmake: Leaving directory `."```从输出结果中，我们可以看到makefile -d 选项输出了规则的详细信息。
Linux 内核配置机制(make menuconfig、Kconfig、makefile)讲解
printk(KERN_WARNING fmt, ##arg) printk(KERN_DEBUG fmt, ##arg)
/* Module Init & Exit function */ static int __init myModule_init(void) {
/* Module init code */ PRINTK("myModule_init\n"); return 0;
图形
工具
前面我们介绍模块编程的时候介绍了驱动进入内核有两种方式：模块和直接编译进内核，并介绍 了模块的一种编译方式——在一个独立的文件夹通过makefile配合内核源码路径完成
那么如何将驱动直接编译进内核呢？ 在我们实际内核的移植配置过程中经常听说的内核裁剪又是怎么麽回事呢？ 我们在进行linux内核配置的时候经常会执行make menuconfig这个命令，然后屏幕上会出现以下 界面：
首页 业界 移动 云计算 研发 论坛 博客 下载 更多
process的专栏
您还未登录！| 登录 | 注册 | 帮助
个人资料
dianhuiren
访问：71424次 积分：1219分 排名：第8764名 原创：37篇 转载：127篇 译文：0篇 评论：3条
目录视图
摘要视图
订阅
《这些年，我们读过的技术经典图书》主题有奖征文 经理
这些配置工具都是使用脚本语言，如 Tcl/TK、Perl 编写的（也包含一些用 C 编写的代码）。本文
/dianhuiren/article/details/6917132
1/5
2012年04月 (6) 2012年03月 (15) 2012年02月 (16)
并不是对配置系统本身进行分析，而是介绍如何使用配置系统。所以，除非是配置系统的维护者，一般 的内核开发者无须了解它们的原理，只需要知道如何编写 Makefile 和配置文件就可以。
makefile obj用法
文章标题：深入探讨Makefile中的Obj用法在软件开发中，Makefile是一个非常重要的工具，它帮助程序员管理项目的编译和信息过程。
而Makefile中的Obj用法则是Makefile中非常重要的一部分，它用来指定项目中的目标文件。
在本篇文章中，我们将深入探讨Makefile中的Obj用法，从简单到复杂，由浅入深，帮助读者更好地理解和运用Obj用法。
1. 什么是Makefile在开始深入探讨Makefile中的Obj用法之前，我们先来了解一下什么是Makefile。
Makefile是一种文件，其中包含了一系列规则和命令，用于指导编译器如何编译和信息项目中的源文件，最终生成可执行文件。
Makefile通过维护文件之间的依赖关系，可以使得在修改源文件后，只重新编译需要重新编译的文件，而不是整个项目。
这样可以提高编译的效率，特别是在大型项目中非常重要。
2. Obj用法的基础概念Obj用法是Makefile中用来指定目标文件的一个重要部分。
在Makefile中，通常通过指定目标文件来定义一个编译单元，Obj用法就是用来指定这些目标文件的。
在Makefile中，Obj用法通常是在规则中使用的，用来指定编译的目标文件是哪些。
我们可以这样定义一个规则：```main.o : main.cgcc -c main.c -o main.o```在这个例子中，main.o就是通过Obj用法指定的目标文件，它告诉Makefile需要生成名为main.o的目标文件，并且它是由main.c编译而来的。
3. Makefile中的Obj用法进阶除了简单地指定目标文件外，Obj用法还可以进一步扩展。
在实际开发中，一个目标文件可能由多个源文件编译而来，这时候就需要用到Obj用法的进阶用法了。
在Makefile中，我们可以使用通配符来指定一组目标文件，例如：```%.o : %.cgcc -c $< -o $@```这个规则中，%表示任意的文件名，$<表示依赖文件，$@表示目标文件。
MakeFile详解
引用其它的Makefile－实例
有这样几个Makefile：a.mk、b.mk、c.mk，还有 一个文件叫foo.make，以及一个变量$(bar)，其 包含了e.mk和f.mk，那么，下面的语句： include foo.make *.mk $(bar) 等价于： include foo.make a.mk b.mk c.mk e.mk f.mk
在大多数时候，由于源文件太多，编译生成的中间目标文 件太多，而在链接时需要明显地指出中间目标文件名，这
对于编译很不方便，所以，通常要给中间目标文件打个包，
在Windows 下这种包叫“库文件”（Library File)，也就 是 .lib 文件，在UNIX 下，是Archive File，也就是 .a 文件。
定义变量和引用变量
变量的定义和应用与Linux环境变量一样，变量名 要大写，变量一旦定义后，就可以通过将变量名 用圆括号括起来，并在前面加上“$”符号来进行 引用。 变量的主要作用： 1、保存文件名列表 2、保存可执行命令名，如编译器 3、保存编译器的参数 变量一般都在makefile的头部定义。按照惯例， 所有的makefile变量都应该是大写。
者，通常是你需要告诉编译器头文件的所在位置，只要所有的语法正
确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应 该对应于一个中间目标文件（O 文件或是OBJ 文件）。
孙钦东
程序的编译和链接
链接时，主要是链接函数和全局变量。链接器并不管函数
所在的源文件，只管函数的中间目标文件（Object File）。
clean: -rm -f $(EXEC) *.elf *.gdb *.o
Kconfig原理,makefile原理
Makefile文件面对树状结构的内核源码目录，内核编译采用了各个子目录拥有自己目录相关的Makefile（被称为sub-Makefile或kbuild Makefile），内核编译依赖于各个子目录下的子makefile（sub-Makefile）文件，这些sub-Makefile定义了根据该子目录下的源码文件构建目标文件的规则，并且仅对该目录下的文件作适当的修改。
顶层Makefile采用递归的方式调用位于init/, drivers/, sound/, net/, lib/ ，usr/等目录下的各个子目录中的Makefile文件。
在递归调用之前，kbuild首先要确定是否已经满足一些必要的条件，包括在必要时更新include/Linux /version.h文件，并设置符号链接include/asm，使之指向与目标体系结构相关的文件。
例如，如果为PPC编译代码，则include /asm指向include/asm-ppc。
kbuild还要对文件include/Linux/autoconf.h和include/Linux /config进行编译。
之后，从根目录开始进行递归。
各个子Makefile文件比较简单，指出了该如何编译目标文件，例如/mm目录下的Makefile 片段：16 obj-$(CONFIG_PROC_PAGE_MONITOR) += pagewalk.o17 obj-$(CONFIG_BOUNCE) += bounce.o18 obj-$(CONFIG_SW AP) += page_io.o swap_state.o swapfile.o thrash.o19 obj-$(CONFIG_HAS_DMA) += dmapool.o20 obj-$(CONFIG_HUGETLBFS) += hugetlb.oKconfig文件Kconfig的作用就是为了让用户配置内核，在Kconfig中定义了一些变量，用户通过设置变量的值来选择如何个性化自己的系统内核。
Makefile使用总结
Makefile使⽤总结1. Makefile 简介Makefile 是和 make 命令⼀起配合使⽤的.很多⼤型项⽬的编译都是通过 Makefile 来组织的, 如果没有 Makefile, 那很多项⽬中各种库和代码之间的依赖关系不知会多复杂. Makefile的组织流程的能⼒如此之强, 不仅可以⽤来编译项⽬, 还可以⽤来组织我们平时的⼀些⽇常操作. 这个需要⼤家发挥⾃⼰的想象⼒.本篇博客是基于⽽整理的, 有些删减, 追加了⼀些⽰例.⾮常感谢 gunguymadman_cu 提供如此详尽的Makefile介绍, 这正是我⼀直寻找的Makefile中⽂⽂档.1.1 Makefile 主要的 5个部分 (显⽰规则, 隐晦规则, 变量定义, ⽂件指⽰, 注释)Makefile基本格式如下:target ... : prerequisites ...command......其中,target - ⽬标⽂件, 可以是 Object File, 也可以是可执⾏⽂件prerequisites - ⽣成 target 所需要的⽂件或者⽬标command - make需要执⾏的命令 (任意的shell命令), Makefile中的命令必须以 [tab] 开头1. 显⽰规则 :: 说明如何⽣成⼀个或多个⽬标⽂件(包括⽣成的⽂件, ⽂件的依赖⽂件, ⽣成的命令)2. 隐晦规则 :: make的⾃动推导功能所执⾏的规则3. 变量定义 :: Makefile中定义的变量4. ⽂件指⽰ :: Makefile中引⽤其他Makefile; 指定Makefile中有效部分; 定义⼀个多⾏命令5. 注释 :: Makefile只有⾏注释 "#", 如果要使⽤或者输出"#"字符, 需要进⾏转义, "\#"1.2 GNU make 的⼯作⽅式1. 读⼊主Makefile (主Makefile中可以引⽤其他Makefile)2. 读⼊被include的其他Makefile3. 初始化⽂件中的变量4. 推导隐晦规则, 并分析所有规则5. 为所有的⽬标⽂件创建依赖关系链6. 根据依赖关系, 决定哪些⽬标要重新⽣成7. 执⾏⽣成命令2. Makefile 初级语法2.1 Makefile 规则2.1.1 规则语法规则主要有2部分: 依赖关系和⽣成⽬标的⽅法.语法有以下2种:target ... : prerequisites ...command...或者target ... : prerequisites ; commandcommand...*注* command太长, 可以⽤ "\" 作为换⾏符2.1.2 规则中的通配符* :: 表⽰任意⼀个或多个字符:: 表⽰任意⼀个字符[...] :: ex. [abcd] 表⽰a,b,c,d中任意⼀个字符, [^abcd]表⽰除a,b,c,d以外的字符, [0-9]表⽰ 0~9中任意⼀个数字~ :: 表⽰⽤户的home⽬录2.1.3 路径搜索当⼀个Makefile中涉及到⼤量源⽂件时(这些源⽂件和Makefile极有可能不在同⼀个⽬录中),这时, 最好将源⽂件的路径明确在Makefile中, 便于编译时查找. Makefile中有个特殊的变量VPATH就是完成这个功能的.指定了VPATH之后, 如果当前⽬录中没有找到相应⽂件或依赖的⽂件, Makefile 回到VPATH指定的路径中再去查找.. VPATH使⽤⽅法:vpath <directories> :: 当前⽬录中找不到⽂件时, 就从<directories>中搜索vpath <pattern> <directories> :: 符合<pattern>格式的⽂件, 就从<directories>中搜索vpath <pattern> :: 清除符合<pattern>格式的⽂件搜索路径vpath :: 清除所有已经设置好的⽂件路径# ⽰例1 - 当前⽬录中找不到⽂件时, 按顺序从 src⽬录 ../parent-dir⽬录中查找⽂件VPATH src:../parent-dir# ⽰例2 - .h结尾的⽂件都从 ./header ⽬录中查找VPATH %.h ./header# ⽰例3 - 清除⽰例2中设置的规则VPATH %.h# ⽰例4 - 清除所有VPATH的设置VPATH2.2 Makefile 中的变量2.2.1 变量定义 ( = or := )OBJS = programA.o programB.oOBJS-ADD = $(OBJS) programC.o# 或者OBJS := programA.o programB.oOBJS-ADD := $(OBJS) programC.o其中 = 和 := 的区别在于, := 只能使⽤前⾯定义好的变量, = 可以使⽤后⾯定义的变量测试 =# Makefile内容OBJS2 = $(OBJS1) programC.oOBJS1 = programA.o programB.oall:@echo $(OBJS2)# bash中执⾏make, 可以看出虽然 OBJS1 是在 OBJS2 之后定义的, 但在 OBJS2中可以提前使⽤$ makeprogramA.o programB.o programC.o测试 :=# Makefile内容OBJS2 := $(OBJS1) programC.oOBJS1 := programA.o programB.oall:@echo $(OBJS2)# bash中执⾏make, 可以看出 OBJS2 中的 $(OBJS1) 为空$ makeprogramC.o2.2.2 变量替换# Makefile内容SRCS := programA.c programB.c programC.cOBJS := $(SRCS:%.c=%.o)all:@echo "SRCS: " $(SRCS)@echo "OBJS: " $(OBJS)# bash中运⾏make$ makeSRCS: programA.c programB.c programC.cOBJS: programA.o programB.o programC.o2.2.3 变量追加值 +=# Makefile内容SRCS := programA.c programB.c programC.cSRCS += programD.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ makeSRCS: programA.c programB.c programC.c programD.c2.2.4 变量覆盖 override作⽤是使 Makefile中定义的变量能够覆盖 make 命令参数中指定的变量语法:override <variable> = <value>override <variable> := <value>override <variable> += <value>下⾯通过⼀个例⼦体会 override 的作⽤：# Makefile内容 (没有⽤override)SRCS := programA.c programB.c programC.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ make SRCS=nothingSRCS: nothing################################################## Makefile内容 (⽤override)override SRCS := programA.c programB.c programC.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ make SRCS=nothingSRCS: programA.c programB.c programC.c2.2.5 ⽬标变量作⽤是使变量的作⽤域仅限于这个⽬标(target), ⽽不像之前例⼦中定义的变量, 对整个Makefile都有效.语法:<target ...> :: <variable-assignment><target ...> :: override <variable-assignment> (override作⽤参见变量覆盖的介绍)⽰例:# Makefile 内容SRCS := programA.c programB.c programC.ctarget1: TARGET1-SRCS := programD.ctarget1:@echo "SRCS: " $(SRCS)@echo "SRCS: " $(TARGET1-SRCS)target2:@echo "SRCS: " $(SRCS)@echo "SRCS: " $(TARGET1-SRCS)# bash中执⾏make$ make target1SRCS: programA.c programB.c programC.cSRCS: programD.c$ make target2 <-- target2中显⽰不了 $(TARGET1-SRCS)SRCS: programA.c programB.c programC.cSRCS:2.3 Makefile 命令前缀Makefile 中书写shell命令时可以加2种前缀 @ 和 -, 或者不⽤前缀.3种格式的shell命令区别如下:不⽤前缀 :: 输出执⾏的命令以及命令执⾏的结果, 出错的话停⽌执⾏前缀 @ :: 只输出命令执⾏的结果, 出错的话停⽌执⾏前缀 - :: 命令执⾏有错的话, 忽略错误, 继续执⾏⽰例:# Makefile 内容 (不⽤前缀)all:echo"没有前缀"cat this_file_not_existecho"错误之后的命令" <-- 这条命令不会被执⾏# bash中执⾏make$ makeecho"没有前缀" <-- 命令本⾝显⽰出来没有前缀 <-- 命令执⾏结果显⽰出来cat this_file_not_existcat: this_file_not_exist: No such file or directorymake: *** [all] Error 1############################################################ Makefile 内容 (前缀 @)all:@echo "没有前缀"@cat this_file_not_exist@echo "错误之后的命令" <-- 这条命令不会被执⾏# bash中执⾏make$ make没有前缀 <-- 只有命令执⾏的结果, 不显⽰命令本⾝cat: this_file_not_exist: No such file or directorymake: *** [all] Error 1############################################################ Makefile 内容 (前缀 -)all:-echo"没有前缀"-cat this_file_not_exist-echo"错误之后的命令" <-- 这条命令会被执⾏# bash中执⾏make$ makeecho"没有前缀" <-- 命令本⾝显⽰出来没有前缀 <-- 命令执⾏结果显⽰出来cat this_file_not_existcat: this_file_not_exist: No such file or directorymake: [all] Error 1 (ignored)echo"错误之后的命令" <-- 出错之后的命令也会显⽰错误之后的命令 <-- 出错之后的命令也会执⾏2.4 伪⽬标伪⽬标并不是⼀个"⽬标(target)", 不像真正的⽬标那样会⽣成⼀个⽬标⽂件.典型的伪⽬标是 Makefile 中⽤来清理编译过程中中间⽂件的 clean 伪⽬标, ⼀般格式如下: .PHONY: clean <-- 这句没有也⾏, 但是最好加上clean:-rm -f *.o2.5 引⽤其他的 Makefile语法: include <filename> (filename 可以包含通配符和路径)⽰例:# Makefile 内容all:@echo "主 Makefile begin"@make other-all@echo "主 Makefile end"include ./other/Makefile# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "other makefile end"# bash中执⾏make$ lltotal 20K-rw-r--r-- 1 wangyubin wangyubin 125 Sep 2316:13 Makefile-rw-r--r-- 1 wangyubin wangyubin 11K Sep 2316:15 <-- 这个⽂件不⽤管drwxr-xr-x 2 wangyubin wangyubin 4.0K Sep 2316:11 other$ ll other/total 4.0K-rw-r--r-- 1 wangyubin wangyubin 71 Sep 2316:11 Makefile$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile'other makefile beginother makefile endmake[1]: Leaving directory `/path/to/test/makefile'主 Makefile end2.6 查看C⽂件的依赖关系写 Makefile 的时候, 需要确定每个⽬标的依赖关系.GNU提供⼀个机制可以查看C代码⽂件依赖那些⽂件, 这样我们在写 Makefile ⽬标的时候就不⽤打开C源码来看其依赖那些⽂件了.⽐如, 下⾯命令显⽰内核源码中 virt/kvm/kvm_main.c 中的依赖关系$ cd virt/kvm/$ gcc -MM kvm_main.ckvm_main.o: kvm_main.c iodev.h coalesced_mmio.h async_pf.h <-- 这句就可以加到 Makefile 中作为编译 kvm_main.o 的依赖关系2.7 make 退出码Makefile的退出码有以下3种：0 :: 表⽰成功执⾏1 :: 表⽰make命令出现了错误2 :: 使⽤了 "-q" 选项, 并且make使得⼀些⽬标不需要更新2.8 指定 Makefile，指定特定⽬标默认执⾏ make 命令时, GNU make在当前⽬录下依次搜索下⾯3个⽂件 "GNUmakefile", "makefile", "Makefile",找到对应⽂件之后, 就开始执⾏此⽂件中的第⼀个⽬标(target). 如果找不到这3个⽂件就报错.⾮默认情况下, 可以在 make 命令中指定特定的 Makefile 和特定的⽬标.⽰例：# Makefile⽂件名改为 MyMake, 内容target1:@echo "target [1] begin"@echo "target [1] end"target2:@echo "target [2] begin"@echo "target [2] end"# bash 中执⾏make$ lsMakefile$ mv Makefile MyMake$ lsMyMake$ make <-- 找不到默认的 Makefilemake: *** No targets specified and no makefile found. Stop.$ make -f MyMake <-- 指定特定的Makefiletarget [1] begintarget [1] end$ make -f MyMake target2 <-- 指定特定的⽬标(target)target [2] begintarget [2] end2.9 make 参数介绍make 的参数有很多, 可以通过 make -h 去查看, 下⾯只介绍⼏个我认为⽐较有⽤的.参数含义--debug[=<options>]输出make的调试信息, options 可以是 a, b, v-j --jobs同时运⾏的命令的个数, 也就是多线程执⾏ Makefile-r --no-builtin-rules禁⽌使⽤任何隐含规则-R --no-builtin-variabes禁⽌使⽤任何作⽤于变量上的隐含规则-B --always-make假设所有⽬标都有更新, 即强制重编译2.10 Makefile 隐含规则这⾥只列⼀个和编译C相关的.编译C时，<n>.o 的⽬标会⾃动推导为 <n>.c# Makefile 中main : main.ogcc -o main main.o#会⾃动变为:main : main.ogcc -o main main.omain.o: main.c <-- main.o 这个⽬标是隐含⽣成的gcc -c main.c2.11 隐含规则中的命令变量和命令参数变量2.11.1 命令变量, 书写Makefile可以直接写 shell时⽤这些变量.下⾯只列出⼀些C相关的变量名含义RM rm -fAR arCC ccCXX g++⽰例:# Makefile 内容all:@echo $(RM)@echo $(AR)@echo $(CC)@echo $(CXX)# bash 中执⾏make, 显⽰各个变量的值$ makerm -farccg++2.11.2 命令参数变量变量名含义ARFLAGS AR命令的参数CFLAGS C语⾔编译器的参数CXXFLAGS C++语⾔编译器的参数⽰例: 下⾯以 CFLAGS 为例演⽰# test.c 内容#include <stdio.h>int main(int argc, char *argv[]){printf ("Hello Makefile\n");return 0;}# Makefile 内容test: test.o$(CC) -o test test.o# bash 中⽤make来测试$ lltotal 24K-rw-r--r-- 1 wangyubin wangyubin 69 Sep 2317:31 Makefile-rw-r--r-- 1 wangyubin wangyubin 14K Sep 2319:51 <-- 请忽略这个⽂件-rw-r--r-- 1 wangyubin wangyubin 392 Sep 2317:31 test.c$ makecc -c -o test.o test.ccc -o test test.o <-- 这个是⾃动推导的$ rm -f test test.o$ make CFLAGS=-Wall <-- 命令中加的编译器参数⾃动追加⼊下⾯的编译中了cc -Wall -c -o test.o test.ccc -o test test.o2.12 ⾃动变量Makefile 中很多时候通过⾃动变量来简化书写, 各个⾃动变量的含义如下:⾃动变量含义$@⽬标集合$%当⽬标是函数库⽂件时, 表⽰其中的⽬标⽂件名$<第⼀个依赖⽬标. 如果依赖⽬标是多个, 逐个表⽰依赖⽬标$?⽐⽬标新的依赖⽬标的集合$^所有依赖⽬标的集合, 会去除重复的依赖⽬标$+所有依赖⽬标的集合, 不会去除重复的依赖⽬标$*这个是GNU make特有的, 其它的make不⼀定⽀持3. Makefile ⾼级语法3.1 嵌套Makefile在 Makefile 初级语法中已经提到过引⽤其它 Makefile的⽅法. 这⾥有另⼀种写法, 并且可以向引⽤的其它 Makefile 传递参数.⽰例: (不传递参数, 只是调⽤⼦⽂件夹 other 中的Makefile)# Makefile 内容all:@echo "主 Makefile begin"@cd ./other && make@echo "主 Makefile end"# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "other makefile end"# bash中执⾏make$ lltotal 28K-rw-r--r-- 1 wangyubin wangyubin 104 Sep 2320:43 Makefile-rw-r--r-- 1 wangyubin wangyubin 17K Sep 2320:44 <-- 这个⽂件不⽤管drwxr-xr-x 2 wangyubin wangyubin 4.0K Sep 2320:42 other$ ll other/total 4.0K-rw-r--r-- 1 wangyubin wangyubin 71 Sep 2316:11 Makefile$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile/other'other makefile beginother makefile endmake[1]: Leaving directory `/path/to/test/makefile/other'主 Makefile end⽰例: (⽤export传递参数)# Makefile 内容export VALUE1 := export.c <-- ⽤了 export, 此变量能够传递到 ./other/Makefile 中VALUE2 := no-export.c <-- 此变量不能传递到 ./other/Makefile 中all:@echo "主 Makefile begin"@cd ./other && make@echo "主 Makefile end"# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "VALUE1: " $(VALUE1)@echo "VALUE2: " $(VALUE2)@echo "other makefile end"# bash中执⾏make$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile/other'other makefile beginVALUE1: export.c <-- VALUE1 传递成功VALUE2: <-- VALUE2 传递失败other makefile endmake[1]: Leaving directory `/path/to/test/makefile/other'主 Makefile end*补充* export 语法格式如下:export variable = valueexport variable := valueexport variable += value3.2 定义命令包命令包有点像是个函数, 将连续的相同的命令合成⼀条, 减少 Makefile 中的代码量, 便于以后维护.语法:define <command-name>command...endef⽰例:# Makefile 内容define run-hello-makefile@echo -n "Hello"@echo " Makefile!"@echo "这⾥可以执⾏多条 Shell 命令!"endefall:$(run-hello-makefile)# bash 中运⾏make$ makeHello Makefile!这⾥可以执⾏多条 Shell 命令!3.3 条件判断条件判断的关键字主要有 ifeq ifneq ifdef ifndef语法:<conditional-directive><text-if-true>endif# 或者<conditional-directive><text-if-true>else<text-if-false>endif⽰例: ifeq的例⼦, ifneq和ifeq的使⽤⽅法类似, 就是取反# Makefile 内容all:ifeq ("aa", "bb")@echo "equal"else@echo "not equal"endif# bash 中执⾏make$ makenot equal⽰例: ifdef的例⼦, ifndef和ifdef的使⽤⽅法类似, 就是取反# Makefile 内容SRCS := program.call:ifdef SRCS@echo $(SRCS)else@echo "no SRCS"# bash 中执⾏make$ makeprogram.c3.4 Makefile 中的函数Makefile 中⾃带了⼀些函数, 利⽤这些函数可以简化 Makefile 的编写.函数调⽤语法如下:$(<function> <arguments>)# 或者${<function> <arguments>}<function> 是函数名<arguments> 是函数参数3.4.1 字符串函数字符串替换函数: $(subst <from>,<to>,<text>)功能: 把字符串<text> 中的 <from> 替换为 <to>返回: 替换过的字符串# Makefile 内容all:@echo $(subst t,e,maktfilt) <-- 将t替换为e# bash 中执⾏make$ makemakefile模式字符串替换函数: $(patsubst <pattern>,<replacement>,<text>)功能: 查找<text>中的单词(单词以"空格", "tab", "换⾏"来分割) 是否符合 <pattern>, 符合的话, ⽤ <replacement> 替代.返回: 替换过的字符串# Makefile 内容all:@echo $(patsubst %.c,%.o,programA.c programB.c)# bash 中执⾏make$ makeprogramA.o programB.o去空格函数: $(strip <string>)功能: 去掉 <string> 字符串中开头和结尾的空字符返回: 被去掉空格的字符串值# Makefile 内容VAL := " aa bb cc "all:@echo "去除空格前: " $(VAL)@echo "去除空格后: " $(strip $(VAL))# bash 中执⾏make去除空格前: aa bb cc去除空格后: aa bb cc查找字符串函数: $(findstring <find>,<in>)功能: 在字符串 <in> 中查找 <find> 字符串返回: 如果找到, 返回 <find> 字符串, 否则返回空字符串# Makefile 内容VAL := " aa bb cc "all:@echo $(findstring aa,$(VAL))@echo $(findstring ab,$(VAL))# bash 中执⾏make$ makeaa过滤函数: $(filter <pattern...>,<text>)功能: 以 <pattern> 模式过滤字符串 <text>, *保留* 符合模式 <pattern> 的单词, 可以有多个模式返回: 符合模式 <pattern> 的字符串# Makefile 内容all:@echo $(filter %.o %.a,program.c program.o program.a)# bash 中执⾏make$ makeprogram.o program.a反过滤函数: $(filter-out <pattern...>,<text>)功能: 以 <pattern> 模式过滤字符串 <text>, *去除* 符合模式 <pattern> 的单词, 可以有多个模式返回: 不符合模式 <pattern> 的字符串# Makefile 内容all:@echo $(filter-out %.o %.a,program.c program.o program.a)# bash 中执⾏make$ makeprogram.c排序函数: $(sort <list>)功能: 给字符串 <list> 中的单词排序 (升序)返回: 排序后的字符串# Makefile 内容all:@echo $(sort bac abc acb cab)# bash 中执⾏make$ makeabc acb bac cab取单词函数: $(word <n>,<text>)功能: 取字符串 <text> 中的第<n>个单词 (n从1开始)返回: <text> 中的第<n>个单词, 如果<n> ⽐ <text> 中单词个数要⼤, 则返回空字符串# Makefile 内容all:@echo $(word 1,aa bb cc dd)@echo $(word 5,aa bb cc dd)@echo $(word 4,aa bb cc dd)# bash 中执⾏make$ makeaadd取单词串函数: $(wordlist <s>,<e>,<text>)功能: 从字符串<text>中取从<s>开始到<e>的单词串. <s>和<e>是⼀个数字.返回: 从<s>到<e>的字符串# Makefile 内容all:@echo $(wordlist 1,3,aa bb cc dd)@echo $(word 5,6,aa bb cc dd)@echo $(word 2,5,aa bb cc dd)# bash 中执⾏make$ makeaa bb ccbb单词个数统计函数: $(words <text>)功能: 统计字符串 <text> 中单词的个数返回: 单词个数# Makefile 内容all:@echo $(words aa bb cc dd)@echo $(words aabbccdd)@echo $(words )# bash 中执⾏make$ make41⾸单词函数: $(firstword <text>)功能: 取字符串 <text> 中的第⼀个单词返回: 字符串 <text> 中的第⼀个单词# Makefile 内容all:@echo $(firstword aa bb cc dd)@echo $(firstword aabbccdd)@echo $(firstword )# bash 中执⾏make$ makeaaaabbccdd3.4.2 ⽂件名函数取⽬录函数: $(dir <names...>)功能: 从⽂件名序列 <names> 中取出⽬录部分返回: ⽂件名序列 <names> 中的⽬录部分# Makefile 内容all:@echo $(dir /home/a.c ./bb.c ../c.c d.c)# bash 中执⾏make$ make/home/ ./ ../ ./取⽂件函数: $(notdir <names...>)功能: 从⽂件名序列 <names> 中取出⾮⽬录部分返回: ⽂件名序列 <names> 中的⾮⽬录部分# Makefile 内容all:@echo $(notdir /home/a.c ./bb.c ../c.c d.c)# bash 中执⾏make$ makea.c bb.cc.cd.c取后缀函数: $(suffix <names...>)功能: 从⽂件名序列 <names> 中取出各个⽂件名的后缀返回: ⽂件名序列 <names> 中各个⽂件名的后缀, 没有后缀则返回空字符串# Makefile 内容all:@echo $(suffix /home/a.c ./b.o ../c.a d)# bash 中执⾏make$ make.c .o .a取前缀函数: $(basename <names...>)功能: 从⽂件名序列 <names> 中取出各个⽂件名的前缀返回: ⽂件名序列 <names> 中各个⽂件名的前缀, 没有前缀则返回空字符串# Makefile 内容all:@echo $(basename /home/a.c ./b.o ../c.a /home/.d .e)# bash 中执⾏make$ make/home/a ./b ../c /home/加后缀函数: $(addsuffix <suffix>,<names...>)功能: 把后缀 <suffix> 加到 <names> 中的每个单词后⾯返回: 加过后缀的⽂件名序列# Makefile 内容all:@echo $(addsuffix .c,/home/a b ./c.o ../d.c)# bash 中执⾏make$ make/home/a.c b.c ./c.o.c ../d.c.c加前缀函数: $(addprefix <prefix>,<names...>)功能: 把前缀 <prefix> 加到 <names> 中的每个单词前⾯返回: 加过前缀的⽂件名序列# Makefile 内容all:@echo $(addprefix test_,/home/a.c b.c ./d.c)# bash 中执⾏make$ maketest_/home/a.c test_b.c test_./d.c连接函数: $(join <list1>,<list2>)功能: <list2> 中对应的单词加到 <list1> 后⾯返回: 连接后的字符串# Makefile 内容all:@echo $(join a b c d,1234)@echo $(join a b c d,12345)@echo $(join a b c d e,1234)# bash 中执⾏make$ makea1 b2 c3 d4a1 b2 c3 d4 5a1 b2 c3 d4 e3.4.3 foreach语法:$(foreach <var>,<list>,<text>)⽰例:# Makefile 内容targets := a b c dobjects := $(foreach i,$(targets),$(i).o)all:@echo $(targets)@echo $(objects)# bash 中执⾏make$ makea b c da.ob.oc.od.o3.4.4 if这⾥的if是个函数, 和前⾯的条件判断不⼀样, 前⾯的条件判断属于Makefile的关键字语法:$(if <condition>,<then-part>)$(if <condition>,<then-part>,<else-part>)⽰例:# Makefile 内容val := aobjects := $(if $(val),$(val).o,nothing)no-objects := $(if $(no-val),$(val).o,nothing)all:@echo $(objects)@echo $(no-objects)# bash 中执⾏make$ makea.onothing3.4.5 call - 创建新的参数化函数语法:$(call <expression>,<parm1>,<parm2>,<parm3>...)⽰例:# Makefile 内容log = "====debug====" $(1) "====end===="all:@echo $(call log,"正在 Make")# bash 中执⾏make$ make====debug==== 正在 Make ====end====3.4.6 origin - 判断变量的来源语法:$(origin <variable>)返回值有如下类型:类型含义undefined<variable> 没有定义过default<variable> 是个默认的定义, ⽐如 CC 变量environment<variable> 是个环境变量, 并且 make时没有使⽤ -e 参数file<variable> 定义在Makefile中command line<variable> 定义在命令⾏中override<variable> 被 override 重新定义过automatic<variable> 是⾃动化变量⽰例:# Makefile 内容val-in-file := test-fileoverride val-override := test-overrideall:@echo $(origin not-define) # not-define 没有定义@echo $(origin CC) # CC 是Makefile默认定义的变量@echo $(origin PATH) # PATH 是 bash 环境变量@echo $(origin val-in-file) # 此Makefile中定义的变量@echo $(origin val-in-cmd) # 这个变量会加在make的参数中@echo $(origin val-override) # 此Makefile中定义的override变量@echo $(origin @) # ⾃动变量, 具体前⾯的介绍# bash 中执⾏make$ make val-in-cmd=val-cmdundefineddefaultenvironmentfilecommand lineoverrideautomatic3.4.7 shell语法:$(shell <shell command>)它的作⽤就是执⾏⼀个shell命令, 并将shell命令的结果作为函数的返回.作⽤和 `<shell command>` ⼀样, ` 是反引号3.4.8 make 控制函数产⽣⼀个致命错误: $(error <text ...>)功能: 输出错误信息, 停⽌Makefile的运⾏# Makefile 内容all:$(error there is an error!)@echo "这⾥不会执⾏!"# bash 中执⾏make$ makeMakefile:2: *** there is an error!. Stop.输出警告: $(warning <text ...>)功能: 输出警告信息, Makefile继续运⾏# Makefile 内容all:$(warning there is an warning!)@echo "这⾥会执⾏!"# bash 中执⾏make$ makeMakefile:2: there is an warning!这⾥会执⾏!3.5 Makefile中⼀些GNU约定俗成的伪⽬标如果有过在Linux上, 从源码安装软件的经历的话, 就会对 make clean, make install ⽐较熟悉.像 clean, install 这些伪⽬标, ⼴为⼈知, 不⽤解释就⼤家知道是什么意思了.下⾯列举⼀些常⽤的伪⽬标, 如果在⾃⼰项⽬的Makefile合理使⽤这些伪⽬标的话, 可以让我们⾃⼰的Makefile看起来更专业, 呵呵 :)伪⽬标含义all所有⽬标的⽬标，其功能⼀般是编译所有的⽬标clean删除所有被make创建的⽂件install安装已编译好的程序，其实就是把⽬标可执⾏⽂件拷贝到指定的⽬录中去print列出改变过的源⽂件tar把源程序打包备份. 也就是⼀个tar⽂件dist创建⼀个压缩⽂件, ⼀般是把tar⽂件压成Z⽂件. 或是gz⽂件TAGS更新所有的⽬标, 以备完整地重编译使⽤check 或 test⼀般⽤来测试makefile的流程。