嵌入式系统实验的makefile
buildroot make 原理
buildroot make 原理（实用版）目录1.Buildroot 简介2.Make 原理3.Buildroot 与 Make 的结合正文1.Buildroot 简介Buildroot 是一个基于 Linux 内核的嵌入式系统构建工具，它可以帮助开发者快速创建一个可运行在目标硬件上的完整系统。
Buildroot 提供了一个简化的脚本接口，用于配置和构建嵌入式系统。
通过使用Buildroot，开发者可以轻松地将 Linux 内核、根文件系统以及各种用户空间工具和库整合到一个可启动的镜像文件中。
2.Make 原理Make 是一个跨平台的构建系统，它使用 Makefiles 来描述项目的构建过程。
Makefiles 包含了一系列的规则，用于指定如何编译源代码文件、链接目标文件以及如何处理依赖关系等。
Make 可以自动处理项目的依赖关系，并根据依赖关系自动执行相应的编译和链接操作，从而简化了构建过程。
Make 的核心原理是基于依赖关系进行递归处理。
当 Make 读取到一个目标时，它会检查该目标是否已经存在，或者是否可以通过依赖关系构建。
如果目标已经存在，或者可以通过依赖关系构建，那么 Make 就会跳过该目标，继续处理下一个目标。
如果目标无法通过依赖关系构建，那么Make 就会调用相应的编译或链接命令，生成该目标。
3.Buildroot 与 Make 的结合Buildroot 和 Make 可以很好地结合在一起，共同构建嵌入式系统。
在 Buildroot 中，开发者可以通过 Makefile 来描述嵌入式系统的构建过程。
这样，Buildroot 就可以根据 Makefile 中的规则自动处理依赖关系，并执行相应的编译和链接操作。
通过使用 Buildroot 和 Make 的组合，开发者可以轻松地构建一个完整的嵌入式系统。
在这种组合中，Buildroot 负责处理底层的硬件抽象层（HAL）和内核配置，而 Make 则负责处理上层的用户空间工具和库的编译和链接。
make makefile 的参数
make makefile 的参数make是一个常用的构建工具，用于自动化编译和构建软件项目。
makefile是make工具的配置文件，用于描述项目的构建规则和依赖关系。
本文将介绍makefile的参数，包括常用的参数及其用法。
一、常用参数及其用法1. -f 文件名：指定makefile的文件名，默认为"makefile"或"Makefile"。
通过该参数，可以使用其他名称的makefile文件。
2. -C 目录：指定make命令的工作目录。
在执行make命令时，会切换到指定的目录，并在该目录下查找makefile文件进行构建。
3. -n：显示执行make命令时的操作，但不实际执行。
通过该参数，可以预览make命令的执行过程，检查构建规则是否正确。
4. -p：显示make命令的内置变量和规则。
通过该参数，可以查看make命令的内部工作机制，了解makefile文件的编写规则和使用方法。
5. -B：强制重新构建目标文件。
通过该参数，可以忽略文件的时间戳，强制重新执行构建规则，生成新的目标文件。
6. -j 并发数：指定make命令的并发执行数。
通过该参数，可以提高构建速度，同时执行多个任务。
7. -s：静默模式，不显示执行的命令。
通过该参数，可以减少输出信息，使构建过程更加清晰。
二、makefile的构建规则makefile由一系列构建规则组成，每个规则定义了目标文件、依赖文件和构建命令。
make命令根据构建规则，自动判断需要更新的文件，并执行相应的构建命令。
构建规则的基本格式如下：目标文件: 依赖文件构建命令其中，目标文件是要生成的文件，依赖文件是目标文件依赖的文件，构建命令是生成目标文件的命令。
构建规则中的目标文件和依赖文件可以是文件名，也可以是变量。
通过使用变量，可以提高makefile的可维护性和灵活性。
构建命令可以是任意的Shell命令，包括编译、链接、拷贝等操作。
makefile--参数传递、条件判断、include（五）
makefile--参数传递、条件判断、include（五）在多个Makefile嵌套调⽤时，有时我们需要传递⼀些参数给下⼀层Makefile。
⽐如我们在顶层Makefile⾥⾯定义的打开调试信息变量DEBUG_SYMBOLS，我们希望在进⼊⼦⽬录执⾏⼦Makefile时该变量仍然有效，这是需要将该变量传递给⼦Makefile，那怎么传递呢？这⾥有两种⽅法：1. 在上层Makefile中使⽤”export”关键字对需要传递的变量进⾏声明。
⽐如：1 2DEBUG_SYMBOLS = TRUE export DEBUG_SYMBOLS当不希望将⼀个变量传递给⼦ make 时，可以使⽤指⽰符 “unexport”来声明这个变量。
export⼀般⽤法是在定义变量的同时对它进⾏声明。
如下：1export DEBUG_SYMBOLS = TRUE2. 在命令⾏上指定变量。
⽐如：1$(MAKE) -C xxx DEBUG_SYMBOLS = TRUE这样在进⼊⼦⽬录xxx执⾏make时该变量也有效。
像编程语⾔⼀样，Makefile也有⾃⼰的条件语句。
条件语句可以根据⼀个变量值来控制make的执⾏逻辑。
⽐较常⽤的条件语句是ifeq –else-endif、ifneq-else-endif、ifdef-else-endif。
ifeq关键字⽤来判断参数是否相等。
⽐如判断是否⽣成调试信息可以这么⽤：1 2 3 4 5 6ifeq ($(DEBUG_SYMBOLS), TRUE) >---CFLAGS += -g -Wall -Werror -O0 else>---CFLAGS += -Wall -Werror -O2 endifIfneq和ifeq作⽤相反，此关键字是⽤来判断参数是否不相等。
ifdef关键字⽤来判断⼀个变量是否已经定义。
后两个关键字⽤法和ifeq类似。
现在我们继续改进我们上⼀节的Makefile，上⼀节的Makefile完成Makefile的嵌套调⽤，每⼀个模块都有⾃⼰的Makefile。
《嵌入式软件设计》实验报告-9_1 模块驱动_1107082116_陈堃霖
实验序号：9_1实验项目名称：模块驱动设计
学 号
XXX
姓 名
XXX
专业、班
物联网
实验地点
实1-318
指导教师
XXX
实验时间
2013-12-6
一、实验目的
1．学习在LINUX下进行驱动设计的原理
2．掌握使用模块方式进行驱动开发调试的过程
二、实验设备（环境）及要求
硬件：PC机；PXA270试验箱
#define DEVICE_NAME"UP-TECH DEMO"
#define DEMORAW_MINOR1
#define DEMO_Devfs_path"demo/0"
static int demoMajor = 0;
（6）用mknod命令建立demo设备节点
mkdir /dev/demo(注意：2.4kernel不需要建这个路径)
Cat /proc/devices
结果如下：
Character devices:
…
180 usb
253 UP-TECH DEMO
254 pcmcia
BlockБайду номын сангаасdevices:
7 loop
8 sd
31 mtdblock…
其中的253就是主设备号；UP-TECH DEMO是设备名称。这在demo.c里有定义：
（2）使用以下命令编译2.6kernel的驱动程序，编译出来的模块是demo.ko，测试程序是test_demo
make
（3）将demo.ko和test_demo传送到目标机，并修改test_demo权限为可执行
嵌入式实验一(嵌入式 Linux 开发环境的搭建及 Makefile 应用)
实验一嵌入式 Linux 开发环境的搭建及 Makefile 应用一、实验目的：1.熟悉嵌入式 Linux 开发基本过程及基本命令。
2.了解嵌入式 Linux 开发中各种工具的基本用途。
3.搭建好嵌入式 Linux 的开发环境。
4.通过对包含多文件的 Makefile 的编写，熟悉各种形式的Makefile 编写，加深对 Makefile 中用户自定义变量、自动变量及预定义变量的理解。
二、实验内容：1.安装 Vmware 及 Ubuntu；2.熟悉 Linux 下相关命令：属性查询、修改，路径、目录的查询、修改、删除，压缩、解压等；3.熟悉编辑工具；4.熟悉 makefile 文件的基本作用（编写一个包含多文件的Makefile）。
三、Make 工程管理器：Makefile如今能得以广泛应用，这还得归功于它被包含在Unix系统中。
在make诞生之前，Unix系统的编译系统主要由“make”、“install”shell脚本程序和程序的源代码组成。
它可以把不同目标的命令组成一个文件，而且可以抽象化依赖关系的检查和存档。
这是向现代编译环境发展的重要一步。
1977年，斯图亚特·费尔德曼在1贝尔实验室里制作了这个软件。
2003年，斯图亚特·费尔德曼因发明了这样一个重要的工具而接受了美国计算机协会（ACM）颁发的软件系统奖。
Makefile文件是可以实现自动化编译，只需要一个“make”命令，整个工程就能完全自动编译，极大的提高了软件开发的效率。
目前虽有众多依赖关系检查工具，但是make是应用最广泛的一个。
一个程序员会不会写makefile，从一个侧面说明了这个程序员是否具备完成大型工程的能力。
1.Makefile 基本规则一个简单的 Makefile 语句由目标、依赖条件、指令组成。
smdk6400_config :unconfig@mkdir -p $(obj)include $(obj)board/samsung/smdk6400其中：smdk6400_config：目标；unconfig：先决条件；@mkdir -p $(obj)include $(obj)board/samsung/smdk6400：指令。
Makefile所有内嵌函数
Makefile所有内嵌函数⼀、⽂本处理函数以下是GNU make内嵌的⽂本（字符串）处理函数。
1 $(subst FROM,TO,TEXT)函数名称：字符串替换函数—subst。
函数功能：把字串“TEXT”中的“FROM”字符替换为“TO”。
返回值：替换后的新字符串。
⽰例：$(subst ee,EE,feet on the street)替换“feet on the street”中的“ee”为“EE”，结果得到字符串“fEEt on the strEEt”。
2 $(patsubst PATTERN,REPLACEMENT,TEXT)函数名称：模式替换函数—patsubst。
函数功能：搜索“TEXT”中以空格分开的单词，将否符合模式“TATTERN”替换为“REPLACEMENT”。
参数“PATTERN”中可以使⽤模式通配符“%”来代表⼀个单词中的若⼲字符。
如果参数“REPLACEMENT”中也包含⼀个“%”，那么“REPLACEMENT”中的“%”将是“TATTERN”中的那个“%”所代表的字符串。
在“TATTERN”和“REPLACEMENT”中，只有第⼀个“%”被作为模式字符来处理，之后出现的不再作模式字符（作为⼀个字符）。
在参数中如果需要将第⼀个出现的“%”作为字符本⾝⽽不作为模式字符时，可使⽤反斜杠“\”进⾏转义处理。
返回值：替换后的新字符串。
函数说明：参数“TEXT”单词之间的多个空格在处理时被合并为⼀个空格，并忽略前导和结尾空格。
⽰例：$(patsubst %.c,%.o,x.c.c bar.c)把字串“x.c.c bar.c”中以.c结尾的单词替换成以.o结尾的字符。
函数的返回结果是“x.c.o bar.o”变量的替换引⽤，它是⼀个简化版的“patsubst”函数在变量引⽤过程的实现。
变量替换引⽤中：$(VAR:PATTERN=REPLACEMENT)就相当于：$(patsubst PATTERN,REPLACEMENT,$(VAR))⽽另外⼀种更为简单的替换字符后缀的实现：$(VAR:SUFFIX=REPLACEMENT)它等于：$(patsubst %SUFFIX,%REPLACEMENT,$(VAR))例如我们存在⼀个代表所有.o⽂件的变量。
makefile if用法
makefile if用法Makefile 是一种常用的构建工具，用于自动化构建软件项目。
在Makefile 中，if 语句能够根据条件来选择不同的命令或变量赋值。
本文将逐步介绍Makefile 中if 语句的用法，包括条件判断、变量赋值、嵌套使用等方面的内容。
首先，我们需要了解Makefile 中if 语句的基本语法。
if 语句可以写在任何位置，但通常我们将其放在文件的顶部，用于设置全局变量或选择不同的命令。
if 语句的基本结构如下：ifeq (条件,值)# 条件成立时执行的命令或变量赋值else# 条件不成立时执行的命令或变量赋值endif在这个基本结构中，ifeq 为条件判断语句，它用于判断条件是否等于某个值。
若条件成立，则执行if 代码块内的命令或进行变量赋值，否则执行else 代码块内的命令或变量赋值。
endif 表示if 语句的结束。
接下来，我们来看一些具体的示例，以帮助理解if 语句的用法。
1. 条件判断：在Makefile 中，我们可以使用各种条件进行判断。
以下是一些常用的判断方式：- 变量是否为空：ifeq ((VAR),)# VAR 为空时执行的命令或变量赋值else# VAR 不为空时执行的命令或变量赋值endif- 变量是否等于某个值：ifeq ((VAR),某个值)# VAR 等于某个值时执行的命令或变量赋值else# VAR 不等于某个值时执行的命令或变量赋值endif- 多个条件判断：ifeq ((VAR),某个值)# VAR 等于某个值时执行的命令或变量赋值else ifeq ((VAR),另一个值)# VAR 等于另一个值时执行的命令或变量赋值else# VAR 既不等于某个值，也不等于另一个值时执行的命令或变量赋值endif2. 变量赋值：在if 语句中，我们可以根据条件选择不同的变量赋值，使得程序更具有灵活性。
以下示例展示了如何根据条件选择不同的变量赋值：ifeq ((OS),Linux)# OS 等于Linux 时，执行以下变量赋值CC = gccelse# OS 不等于Linux 时，执行以下变量赋值CC = clangendif根据上述示例，当操作系统为Linux 时，CC 的值将被赋为gcc，否则为clang。
Makefile面试
Makefile⾯试介绍⼀下make? 为什么使⽤make1、包含多个源⽂件的项⽬在编译时有长⽽复杂的命令⾏，可以通过makefile保存这些命令⾏来简化该⼯作2、make可以减少重新编译所需要的时间，因为make可以识别出哪些⽂件是新修改的3、make维护了当前项⽬中各⽂件的相关关系，从⽽可以在编译前检查是否可以找到所有的⽂件makefile：⼀个⽂本形式的⽂件，其中包含⼀些规则告诉make编译哪些⽂件以及怎样编译这些⽂件，每条规则包含以下内容：⼀个target，即最终创建的东西⼀个和多个dependencies列表，通常是编译⽬标⽂件所需要的其他⽂件需要执⾏的⼀系列commands，⽤于从指定的相关⽂件创建⽬标⽂件make执⾏时按顺序查找名为GNUmakefile，makefile或者Makefile⽂件，通常，⼤多数⼈常⽤MakefileMakefile规则：target: dependency dependency [..] command command [..]注意：command前⾯必须是制表符例⼦：editor: editor.o screen.o keyboard.ogcc -o editor editor.o screen.o keyboard.oeditor.o : editor.c editor.h keyboard.h screen.hgcc -c editor.cscreen.o: screen.c screen.hgcc -c screen.ckeyboard.o : keyboard.c keyboard.hgcc -c keyboard.cclean:rm editor *.o。
makefile基本使用方法
makefile基本使用方法makefile是一种用来管理和自动化构建程序的工具。
它可以根据源代码文件的依赖关系和编译规则来自动构建目标文件和可执行文件。
makefile的基本使用方法如下：1. 创建makefile文件：在项目的根目录下创建一个名为makefile 的文件。
2. 定义变量：在makefile中，可以使用变量来存储一些常用的参数和路径，以便于后续的使用。
例如，可以定义一个名为CC的变量来指定编译器的名称，如：CC=gcc。
3. 编写规则：在makefile中，可以使用规则来指定如何编译源代码文件和生成目标文件。
一个规则由两部分组成：目标和依赖。
目标是要生成的文件，依赖是生成目标文件所需要的源代码文件。
例如，可以编写以下规则：```target: dependency1 dependency2command1command2```其中，target是目标文件，dependency1和dependency2是依赖的源代码文件，command1和command2是生成目标文件所需要执行的命令。
4. 编写默认规则：在makefile中，可以使用一个默认规则来指定如何生成最终的可执行文件。
默认规则的目标通常是可执行文件，依赖是所有的源代码文件。
例如，可以编写以下默认规则：```all: target1 target2```其中，target1和target2是生成的目标文件。
5. 编写clean规则：在makefile中，可以使用clean规则来清理生成的目标文件和可执行文件。
例如，可以编写以下clean规则： ```clean:rm -f target1 target2```其中，target1和target2是要清理的目标文件。
6. 运行make命令：在命令行中，使用make命令来执行makefile 文件。
make命令会自动根据规则和依赖关系来编译源代码文件和生成目标文件。
例如，可以运行以下命令：``````make命令会根据makefile文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。
makefile规则
makefile规则makefile规则是指在编译和链接源程序时使用的指令说明集合，它主要实现对源程序进行编译和链接操作。
makefile规则通常包括定义、变量（ macro ）、条件语句、文件名模式、关系性质，以及各种命令的执行。
定义是指在 makefile 中定义一些环境变量，这样可以同时供make 命令和源程序使用。
变量就是把变量名称定义为字符内容或者字符串。
条件语句是指在 makefile 中可以使用 if-then-else 语句条件判断，实现对不同平台的兼容和不同编译器的支持。
文件名模式是指在 makefile 中，可以使用文件名模式来精确针对特定文件和目录，完成不同操作。
关系性质是指 makefile 支持多个文件之间的依赖关系，即如果文件 A 依赖于文件 B，当文件 B 的内容发生变化时，系统自动执行文件 A 的操作。
makefile 还支持各种命令的执行，包括编译、链接、拷贝、安装等操作。
通过这些命令的执行，可以非常方便地把源程序编译和链接，实现最终的编译和链接结果。
通常，makefile 规则是由多个项目构成的，每一项都有一个名称，每一个项目都可以包含一些变量，关系和命令等，用于指定 make 命令的行为。
每个规则以一个制表符开头，然后是目标文件、依赖文件、变量名和命令，分别以冒号、逗号、空格和分号等符号隔开。
每个 makefile 都有一个默认的目标，如果在编译和链接时没有指定特定的目标，则 make 命令会执行默认的目标。
因此，完整的makefile 是必须设置默认目标的，才能在执行 make 命令时得到正确的结果。
嵌入式uClinux开发中makefile的设计
【 关键词 】 ｃｉＩ ；ａ ｌ； 式操作 系统 ：ｕ ｌ ｌ ｍ ｋ ｅ ｎｘ 嵌入
１ｕ ｌｕ ． Ｃｉ ｘ嵌 入 式 系 统 开 发 编 译 特 点 ｎ
ｇ ｅ ｍａ ｎＯ ｉ ． Ｏ ｅ ｅ ｕａ ｌ ｅ ｉ ． ｏＯ— ｘ ｃ ｔ ｂｅ
ｍａｎ． ：ｍａ ｎＣ ｉ ｏ ｉ ．
维普资讯
１８ ７
福
建 电
脑
２０ ０ ６年第 １ ２期
嵌 入式 ｕ ｌ ｕ Ｃｉ ｘ开发 中 ｍａｅ ｌ ｎ ｋｆｅ的设计 ｉ
张军红 ， 少清 ， 刘 于 谦
（ 州职 业 技 术 学 院 计 算 机 系 福 建 福 州 ３ ０ ０ ） 福 ５ １８
标 文 件 ｍ ｉ． ｉ．． ａ ｏ和 ｏＯ 只要 ｅｅｕａｌ 它依 赖 的文 件 中的 任 何 ｎ ｘｃｔｂ ｅ比 个 旧 的话 ． 一 行 的命 令 就 会 被执 行 。 是 ． 检 查 文 件 ｍ ｉ． 下 但 在 ａｎ Ｏ和 ｉ． ｏ ｏ的 １ 之 前 ． 会 往 下 查 找 那 些 把 ｍ ｉ． ３期 它 ａｎ ０或 ｉ０做 为 ｏ ． 目标 文 件 的 规 则 。 ｍ ｋ ａｅ先 找 到 了关 于 ｍ ｉ． ａ ｏ的规 则 ． 目标 文 ｎ 该 件 的 依 赖 文 件 是 ｍ ｉ． ｍ ｋｆｅ 面 的 文 件 中 再 也找 不 到 生 成 ａ ｃ ａｅ 后 ｎ ｄ ＇ 这 个 依 赖 文 件 的规 则 了 。此 时 ． ａｅ开 始 检 查 磁 盘 上 这 个 依 赖 ｍｋ 文 件 的 日期 ． 果 这 个 文 件 的 日期 比 ｍ ｉ． 日期 新 的话 ． 么 如 ａ Ｏ ｎ 那 这 个 规 则 下 面 的 命 令 ｇ ｃ ｃｍ ｉ． ｏｍ ｉ． ｃ — ａｎ ｃ— ａｎ Ｏ就会 执行 ． 以更 新 文 件 ｍ ｉ． ａ ｏ。同样 ｍ ｋ ｎ ａｅ对 文件 ｉ． 类 似 的 检查 ． 的依 赖 文 ｏ ｏ做 它
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的流程。
实验1-嵌入式Linux基础 答案
$ rm–rf test
(17)综合：根据各人学号or姓名，为自己新建一个工作目录，并利用pwd命令查看自己的工作目录，并记录如下：
工作目录是（请填写）：
系统信息类命令：
(1)利用date命令显示系统当前时间
$ date
(2)利用free命令显示内存的使用情况
$ free
(3)利用df命令显示系统的硬盘分区及使用状况
$ cd..
$ tarzcvf test.tar.gz test
(12)将test.tar.gz改名为backup.tar.gz，并把文件backup.tar.gz移动到test目录下；显示当前目录下的文件和目录列表，确认移动成功。
$ mv test.进入test目录，显示目录中的文件列表；把文件backup.tar.gz解包
}
hello2.h
void test2(void);
makefile
CC=gcc
CFLAGS=
OBJS=hello1.o hello2.o
all: hello
hello: $(OBJS)
$(CC) $(CFLAGS) $^-o $@
hello1.o: hello1.c
$(CC) $(CFLAGS)–c $<-o $@
hello1.c
#include <stdio.h>
int main(){
printf(“Hello world!\n”);
test2();
return 1;
}
hello2.c
#include <stdio.h>
#include“hello2.h”
void test2(void){
openwrt makefile编译流程 -回复
openwrt makefile编译流程-回复OpenWrt是一个针对嵌入式设备的嵌入式操作系统，它提供了一个基于Linux的操作环境，可以在各种路由器和其他嵌入式设备上运行。
编译OpenWrt的makefile是一个重要的步骤，本文将一步一步回答有关OpenWrt makefile编译流程的问题。
Makefile是一个包含了一系列编译和链接规则的文本文件，用于指导编译器将源代码转换为可执行文件或库文件。
编译OpenWrt的makefile可以根据用户需求进行修改和优化，在原始的OpenWrt系统上添加或删除模块。
一、准备环境编译OpenWrt的第一步是确保系统环境的准备工作已经完成。
在Linux 系统上编译OpenWrt需要以下环境：1. 软件包管理器：OpenWrt使用opkg来管理软件包，确保已经安装了opkg。
2. 构建工具链：OpenWrt需要安装适当的构建工具链，可以通过安装gcc 等相关工具来满足这一需求。
3. 源代码：从OpenWrt官方网站下载源代码，并在本地解压缩。
二、配置makefile1. 打开终端并进入源代码目录，可以使用cd命令来切换目录。
2. 运行make menuconfig命令，配置编译选项。
该命令将打开一个基于文本的界面，用于选择编译参数。
在该界面中可以选择要编译的软件包、目标设备、内核选项、文件系统等。
根据需要进行配置，并保存修改。
三、编译makefile1. 执行make命令，开始编译过程。
此时，make工具将根据makefile 中的规则，递归地编译源代码，并生成可执行文件和库文件。
2. 等待编译完成，时间长度取决于系统配置和编译内容的庞大程度。
四、安装编译结果1. 编译完成后，可以在目标目录中找到编译生成的文件。
默认情况下，编译结果位于./bin/目录下。
可以使用ls命令来查看生成的文件列表。
2. 将编译生成的文件安装到目标设备上。
通过scp命令将文件复制到目标设备上，然后运行相应的命令进行安装。
Qt源码中生成Makefile文件-KC08141208-d02(精)
生成Makefile文件
3.步骤三：设置vi编辑器行号。由于Makefile文件内容较多，为了能够后续修改方便，这里需要打 开行号。在命令模式下，输入“:set nu”命令打开，具体操作如下图3所示：
图3
生成Makefile文件
4.步骤四：修改 Makefile文件内容。 初步生成的Makefile 文件，存在一些无 用的信息和重复的 内容需要去除，同 时还要添加新的内 容，具体操作如下 图4、图5、图6和图 7所示：
生成Makefile文件
Makefile dht11.pro”命令进
行生成，具体操作如下图1所示：
图1
生成Makefile文件
生成Makefile文件
2.步骤二：打开Makefile文件。在虚拟机终端中，使用vi编辑器打开文件，输入“vi Makefile” 命令打开，具体操作如下图2所示：
图2
生成Makefile文件
ቤተ መጻሕፍቲ ባይዱ
生成Makefile文件
图4
图5
图6
图7
生成Makefile文件
生成Makefile文件
5.步骤五：保存退出。修改完成后，再单击键盘“Esc”键进入命令模式，输入“：wq!”保存 退出，具体操作如下图8所示：
图8
谢谢关注！
08 嵌入式技术应用－模块四
嵌入式网关之温湿度采集系统设计
Qt源码中生成Makefile文件
• 生成Makefile文件
*
生成Makefile文件
根据前面获取的 dht11.pro 文件， 这里可以使用 tmake 软件生成初步 的Makefile文件，然后再修改 Makefile 文件，最终得到需要的。 具体步骤如下： 1.步骤一：生成Makefile文件。在虚 拟机终端中，输入 “ tmake -o
openwrt make kernel_menuconfig命令的实现机制
openwrt make kernel_menuconfig命令的实现机制OpenWrt是一个专门为嵌入式设备设计的开源操作系统，它具有高度自定义性的特点。
在进行OpenWrt的自定义配置时，需经常使用到make kernel_menuconfig命令，即在内核配置菜单中对内核选项进行编辑。
实现机制如下：一、Makefile在OpenWrt源码的目录下经常出现名为Makefile的文件，它是Make自动化工具的一个文件，用于指导编译器以及链接器如何进行编译和链接操作。
通过对该文件的修改，可以对编译行为进行自定义。
二、Kernel_makefile在Makefile中有一个名为Kernel_makefile的文件，它是OpenWrt为内核锅炉定制的一个Makefile文件。
通过Kernel_makefile，可以实现内核的编译、调试以及配置等操作。
在Kernel_makefile中，使用obj-y变量指定内核源代码文件的编译方式以及参与编译的文件。
三、Kernel_menuconfigKernel_menuconfig是OpenWrt提供的一个菜单项，用于对内核选项进行编辑。
使用make kernel_menuconfig命令即可进入内核配置菜单，可以对内核选项进行编辑和修改，这些修改会被保存至.config 文件中。
在菜单项中使用的内核选项也会保存至.config文件中，从而方便后续的内核编译。
四、.config文件.config文件是OpenWrt中用于保存内核配置选项的文件。
它是一个文本文件，可以手动编辑。
当通过make kernel_menuconfig命令修改内核选项时，所做的修改都会被保存至.config文件中。
五、编译内核当所有的内核选项修改完成后，需要执行make命令编译内核。
在编译内核时，会根据.config文件中的选项配置进行编译。
根据内核选项的不同，编译时间可能会较长。
综上所述，通过Makefile、Kernel_makefile、Kernel_menuconfig、.config文件和编译内核这五个步骤，就可以实现OpenWrt的内核选项配置。
stm32 makefile编写规则
stm32 makefile编写规则STM32是一款广泛应用于嵌入式系统开发的微控制器系列，而Makefile是一种常用的构建工具，用于自动化编译和构建程序。
在STM32的开发过程中，使用Makefile可以方便地管理项目的构建过程，提高开发效率。
本文将介绍如何使用Makefile编写规则来进行STM32的开发。
在开始编写Makefile规则之前，需要了解一些基本概念。
首先，Makefile是一个文本文件，其中包含了一系列规则，用于描述如何生成目标文件。
每个规则由一个或多个依赖项和一个命令组成。
当目标文件的依赖项发生变化时，Make工具会根据规则执行相应的命令来生成目标文件。
下面是一个简单的Makefile规则示例：```Makefile# 定义目标文件名TARGET = main# 定义编译器和编译选项CC = arm-none-eabi-gccCFLAGS = -mcpu=cortex-m4 -mthumb -c -g -O0 -std=c99# 定义链接器和链接选项LD = arm-none-eabi-ldLDFLAGS = -Tstm32.ld# 定义目标文件和源文件OBJS = main.oSRCS = main.c# 默认规则all: $(TARGET).elf# 生成目标文件$(TARGET).elf: $(OBJS)$(LD) $(LDFLAGS) -o $@ $^# 生成目标文件的依赖关系$(OBJS): $(SRCS)$(CC) $(CFLAGS) -o $@ $<# 清理生成的文件clean:rm -rf $(TARGET).elf $(OBJS)```在上述示例中，首先定义了目标文件名（TARGET）、编译器（CC）和编译选项（CFLAGS）、链接器（LD）和链接选项（LDFLAGS）、目标文件（OBJS）以及源文件（SRCS）等变量。
接着定义了一个默认规则（all），该规则依赖于目标文件（$(TARGET).elf）。
合工大嵌入式系统实验报告
计算机与信息学院《嵌入式系统》实验报告学生姓名：学号：专业班级：2014 年 6 月20 日实验一（1）：熟悉Linux 开发环境一、实验目的熟悉Linux 开发环境，学会基于Mini6410 的Linux 开发环境的配置和使用。
使用Linux 的arm-linux-gcc 编译，minicom串口方式下载调试二、实验内容本次实验使用Fedora 9.0 操作系统环境,安装ARM-Linux 的开发库及编译器。
创建一个新目录，并在其中编写hello.c 和Makefile 文件。
学习在Linux 下的编程和编译过程，以及ARM 开发板的使用和开发环境的设置。
下载已经编译好的文件到目标开发板上运行。
三、实验设备及工具（包括软件调试工具）硬件：Mini6410嵌入式实验平台、PC机Pentium 500以上, 硬盘10G以上。
软件：PC机操作系统Fedora9＋MINICOM＋ARM-LINUX 开发环境四、实验步骤1 、建立工作目录[root@zxt smile]# mkdir hello[root@zxt smile]# cd hello2 、编写程序源代码在 Linux 下的文本编辑器有许多，常用的是 vi 和 Xwindow 界面下的 gedit 等，开发过程中推荐使用 vi。
Kdevelope、anjuta 软件的界面与 vc6.0 类似，使用它们对于熟悉 windows 环境下开发的用户更容易上手。
实际的 hello.c 源代码较简单，如下：＃include <stdio.h>main() {printf(“hello world \n”);}我们可以是用下面的命令来编写 hello.c 的源代码，进入 hello 目录使用 vi 命令来编辑代码：[root@zxt hello]# vi hello.c按“i”或者“a”进入编辑模式，将上面的代码录入进去，完成后按 Esc 键进入命令状态，再用命令“：wq”保存并退出。
makefile条件语嵌套使用 -回复
makefile条件语嵌套使用-回复问题的具体步骤如下：第一步：什么是makefile？在开始讨论makefile条件语嵌套的使用之前，我们先了解一下什么是makefile。
Makefile是一个包含一系列规则和命令的文本文件，它描述了源文件之间的依赖关系，以及如何编译和链接这些源文件。
通过makefile，我们可以在一个命令中一次性构建复杂的项目，而不需要手动编译每个源文件。
第二步：条件语的基本概念在makefile中，条件语可以根据一定的条件执行不同的命令或者规则。
条件语的基本语法如下：ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则else# 参数1和参数2不相等时执行的命令或规则endif通过if语句中的参数1和参数2的比较，可以决定不同条件下的执行逻辑。
第三步：条件语嵌套的基本概念与其他编程语言类似，makefile也支持条件语的嵌套使用。
通过条件语的嵌套，我们可以实现更加复杂的逻辑判断和命令执行。
例如，我们可以通过以下的方式嵌套使用if语句：ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则ifeq (参数3, 参数4)# 参数3和参数4相等时执行的命令或规则else# 参数3和参数4不相等时执行的命令或规则endifelse# 参数1和参数2不相等时执行的命令或规则endif通过条件语嵌套，我们可以实现更加复杂的逻辑判断和流程控制。
第四步：条件语嵌套的实际应用接下来，我们来看一些实际的例子，以更好地理解条件语嵌套的使用。
假设我们有一个项目，该项目可以在不同的操作系统上编译和运行。
我们可以通过条件语嵌套来实现根据操作系统的不同选择不同的编译命令。
首先，我们可以定义一个变量来表示当前操作系统的类型：OS := (shell uname -s)然后，我们可以使用条件语嵌套来根据操作系统的类型选择不同的编译命令：ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则ifeq ((OS), Linux)# 在Linux系统上执行的命令或规则else ifeq ((OS), Windows)# 在Windows系统上执行的命令或规则else ifeq ((OS), Darwin)# 在Darwin (MacOS)系统上执行的命令或规则else# 其他操作系统上执行的命令或规则endifelse# 参数1和参数2不相等时执行的命令或规则endif通过以上的例子，我们可以看到，通过条件语嵌套，我们可以根据不同的操作系统类型选择不同的编译命令，从而实现在不同操作系统上的构建和运行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验七 Makefile与Helloworld（1学时）
一、实验目的
熟悉Linux开发环境
学习嵌入式开发的基本过程
了解Makefile的基本内容
二、基础知识
C语言基础知识
掌握Linux环境下vi编译器的使用方法
掌握Linux下的程序编译与交叉编译过程
三、实验环境
PC机Pentium500以上，硬盘40GB以上，内存128MB以上
PC机操作系统Ubuntu10.10
arm-Linux开发环境
四、情景描述
创建一个新目录，并在其中编写hello.c和Makefile文件。
五、实验内容
1、完成一个简单程序的编译过程
1)切换到/work文件夹
2)建一个文件夹“Makefile”，
3)进入Makefile文件夹
4)Vi编辑hello.c，
5)Vi编辑Makefile
6)编译
命令：make
实验八编写包含多文件的Makefile（1学时）
备注：详见《嵌入式Linux应用开发教程》第53页
一、实验目的
通过对包含多文件的Makefile的编写，熟悉各种形式的Makefile，并且进一步加深对Makefile中用户自定义变量、自动变量及预定义变量的理解。
二、实验环境
PC机Pentium500以上，硬盘40GB以上，内存128MB以上
PC机操作系统Ubuntu10.10
arm-Linux开发环境
三、实验内容
1)切换到/work文件夹
2)建一个文件夹“Makefile2”，
3)进入Makefile2文件夹
4)Vi编辑hello.c，hello.h
hello.c
hello.h
5)仍在同一目录下用vi编辑Makefile，且不使用变量替换，用一个目标体实现（即直接
将hello.c和hello.h编译成hello目标体）。
然后用make验证所编写的Makefile是否正确。
6)将上述Makefile使用变量替换实现。
同样用make验证所编写的Makefile6是否正确。
7)编辑另一个Makefile，取名为Makefile7，不使用变量替换，但用两个目标体实现（也
就是首先将hello.c和hello.h编译为hello.o，再将hello.o编译为hello），再用make的“-f”选项验证这个Makefile7的正确性。
命令：
make -f Makefile7
8)将上述Makefile7使用变量替换实现Makefile8。
实验九使用autotools生成包含多文件的Makefile（1学时）
备注：详见《嵌入式Linux应用开发教程》第53~54页
一、实验目的
通过使用autotools生成包含多文件的Makefile，进一步掌握autotools的使用方法。
同时，掌握Linux下安装软件的常用方法。
二、实验环境
PC机Pentium500以上，硬盘40GB以上，内存128MB以上
PC机操作系统Ubuntu10.10
arm-Linux开发环境
三、实验内容
（1）/work下新建文件夹auto。
（2）将实验七“hello.c”复制到该目录下。
（3）使用autoscan生成configure.scan。
（4）编辑configure.scan，修改相关内容，并将其重命名为configure.in。
有改动的地方是第5,6,7,20行。
（5）使用aclocal生成aclocal.m4。
（6）使用autoconf生成configure。
（7）使用autoheader生成config.h.in。
（8）编辑Makefile.am。
（9）使用automake --add-missing生成Makefile.in。
（10）使用./configure生成Makefile。
（11）使用make生成hello可执行文件，并在当前目录下运行hello查看结果。
（12）使用sudo make install将hello安装到系统目录下，并运行，查看结果。
(密码：
（13）使用make dist生成hello压缩包。
（14）解压hello压缩包。
（15）进入解压目录。
（16）在该目录下安装hello软件。