make_Makefile 结构分析

合集下载

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 arm编译

makefile arm编译Makefile是一种用于自动化构建项目的工具，可以帮助开发人员更方便地编译和链接程序。

在ARM架构下，Makefile也是一种常用的编译方式。

本文将介绍如何使用Makefile在ARM架构下进行编译。

为了能够正确地编译ARM架构的程序，我们需要确保系统上已经安装了ARM交叉编译工具链。

这个工具链包含了一系列的工具，如编译器、链接器等，可以将源代码编译成可在ARM架构上运行的机器码。

安装好工具链后，我们可以开始编写Makefile。

Makefile是一个文本文件，其中包含了一系列规则和命令，用于告诉Make工具如何编译和链接程序。

我们可以通过编写Makefile来定义编译的规则，如源文件和目标文件的依赖关系，以及编译和链接的命令。

下面是一个简单的Makefile示例：```CC = arm-linux-gccCFLAGS = -Wall -O2TARGET = programOBJS = main.o func.o$(TARGET): $(OBJS)$(CC) $(CFLAGS) -o $(TARGET) $(OBJS)main.o: main.c$(CC) $(CFLAGS) -c main.cfunc.o: func.c$(CC) $(CFLAGS) -c func.cclean:rm -f $(TARGET) $(OBJS)```在这个Makefile中，我们首先定义了编译器和编译选项的变量。

CC 变量指定了使用的编译器，CFLAGS变量指定了编译选项，如-Wall 表示开启所有警告信息，-O2表示启用优化。

接下来，我们定义了目标文件和源文件的变量。

TARGET变量指定了目标文件的名称，OBJS变量指定了源文件编译后生成的目标文件。

然后，我们定义了一个规则来编译目标文件。

$(TARGET): $(OBJS)表示$(TARGET)依赖于$(OBJS)，即目标文件依赖于源文件。

makefile中make指令传入的参数

makefile中make指令传入的参数（实用版）目录1.Makefile 简介2.Make 指令的作用3.Make 指令传入的参数4.示例与实践正文1.Makefile 简介Makefile 是一种构建脚本，用于自动化构建和编译软件项目。

它通常包含一系列的规则和指令，可以自动地执行编译、链接和安装等任务。

Makefile 最早用于 Unix 系统，现在已广泛应用于各种操作系统和编程语言。

2.Make 指令的作用在 Makefile 中，Make 指令是最核心的命令。

它可以自动地执行一系列的编译、链接和安装等任务，以构建软件项目。

Make 指令的工作原理是基于依赖关系，它可以自动地发现源文件和目标文件之间的依赖关系，并按照一定的顺序执行相应的操作。

3.Make 指令传入的参数Make 指令传入的参数主要有以下几种：（1）目标：指定要构建的目标文件，通常是可执行文件或库文件。

（2）源文件：指定构成目标文件的源文件，可以是 C、C++等源代码文件。

（3）编译器：指定用于编译源文件的编译器，例如 gcc、g++等。

（4）链接器：指定用于链接目标文件和库文件的链接器，例如 ld、ld.so 等。

（5）其他选项：还可以指定其他选项，例如优化级别、输出文件名等。

4.示例与实践下面是一个简单的 Makefile 示例，用于编译一个 C 语言程序：```CC = gccCFLAGS = -Wall -o2SOURCES = main.cOBJECTS = main.oTARGET = mainall: $(TARGET)$(TARGET): $(OBJECTS)t$(CC) $(CFLAGS) $^ -o $@$(OBJECTS): $(SOURCES)t$(CC) $(CFLAGS) -c $< -o $@```在这个示例中，我们指定了编译器（CC）、优化选项（CFLAGS）、源文件（SOURCES）、目标文件（TARGET）和依赖关系（all: $(TARGET)）。

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文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。

linux 顶层makefile分析

Linux顶层Makefile文件分析分类：Linux 系列2013-05-06 17:05 585人阅读评论(0) 收藏举报1、make menuconfigVERSION = 2PATCHLEVEL = 6SUBLEVEL = 26EXTRAVERSION =NAME = Rotary Wombat# *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 avoids hard-to-debug behaviour);# o print "Entering directory ...";MAKEFLAGS += -rR --no-print-directory#-r禁止使用build-in规则#--no-print-directory是:不要再屏幕上打印"Entering directory.."#记住变量SHELL,MAKEFLAGS在整个make的执行过程中#始终被自动的传递给所有的子make# We are using a recursive build, so we need to do a little thinking# to get the ordering right.## Most importantly: sub-Makefiles should only ever modify files in# their own directory. If in some directory we have a dependency on# a file in another dir (which doesn't happen often, but it's often# unavoidable when linking the built-in.o targets which finy# turn into vmlinux), we will call a sub make in that other dir, and# after that we are sure that everything which is in that other dir# is now up to date.## The only cases where we need to modify files which have global# effects are thus separated out and done before the recursive# descending is started. They are now explicitly listed as the# prepare rule.# To put more focus on warnings, be less verbose as default# Use 'make V=1' to see the full commandsifdef V #v=1ifeq ("$(origin V)", "command line")KBUILD_VERBOSE = $(V) #把V的值作为KBUILD_VERBOSE的值 endifendififndef KBUILD_VERBOSE #即默认我们是不回显的#回显即在命令执行前显示要执行的命令KBUILD_VERBOSE = 0endif# 函数origin并不操作变量的值，只是告诉你你的这个变量是哪里来的。

make的工作原理

make的工作原理引言make是一个流行的构建工具，广泛应用于软件开发中。

它能够根据代码的依赖关系自动构建并更新目标文件，提高编译效率。

本文将深入探讨make的工作原理。

1. make的概述Make是一个基于规则的构建工具，可以自动根据源文件的改变来更新目标文件。

它将每个文件的依赖关系描述为一个规则，然后根据这些规则来执行构建任务。

2. makefile文件make使用makefile文件来定义规则和构建任务。

makefile是一个文本文件，其中包含一系列目标、依赖关系和相应的构建命令。

make根据这些规则来决定是否需要重新构建目标文件。

2.1 目标和依赖关系makefile中的每个规则都由一个目标和依赖关系组成。

目标是需要构建的文件，而依赖关系是构建目标所需的文件或其他目标。

make会根据目标和依赖关系来确定构建顺序。

2.2 构建命令每个规则还包含一个或多个构建命令，用于执行构建任务。

构建命令通常是一些shell命令，用于编译源代码、链接目标文件等操作。

make通过执行这些命令来生成目标文件。

3. make的工作流程make的工作流程可以分为以下几个步骤：3.1 解析makefile当执行make命令时，首先会读取makefile文件，并解析其中的规则和命令。

make 会根据文件中的规则建立依赖关系图，并确定构建任务的顺序。

3.2 检查目标和依赖关系在执行构建任务之前，make会检查目标文件和依赖关系的状态。

如果目标文件不存在或者依赖关系中的文件有修改，则需要重新构建目标文件。

3.3 执行构建命令如果需要重新构建目标文件，make会依次执行与该目标关联的构建命令。

构建命令通常是通过调用编译器、链接器等工具来实现的。

执行构建命令后，生成新的目标文件。

3.4 更新目标文件在执行构建命令后，make会根据构建结果更新目标文件的状态。

如果构建成功，目标文件的时间戳会更新为最新时间；如果构建失败，则不会更新目标文件。

linux中make函数作用

linux中make函数作用make函数是Linux系统中常用的命令之一，它的作用是根据源文件的依赖关系，自动化地管理程序的编译、链接和安装过程。

在Linux系统中，make函数被广泛应用于软件开发、系统维护和自动化脚本编写等领域。

一、make函数的基本概念和用法make函数是一个构建工具，它通过读取名为Makefile的文件来执行相应的操作。

Makefile是一个文本文件，其中包含了一系列规则和指令，用于描述源文件之间的依赖关系和构建过程。

通过执行make命令，系统会根据Makefile中的规则来判断需要重新编译哪些文件，并自动执行编译、链接等操作。

make函数的基本用法如下：1. 创建Makefile文件：在项目目录下创建名为Makefile的文件，并使用文本编辑器打开。

2. 编写规则和指令：在Makefile中编写一系列规则和指令，用于描述源文件之间的依赖关系和构建过程。

每个规则由一个目标(target)、依赖(dependencies)和指令(commands)组成。

3. 执行make命令：在命令行终端中执行make命令，系统会读取Makefile文件，并根据规则和指令执行相应的操作。

二、Makefile文件的基本结构Makefile文件由一系列规则和指令组成，每个规则描述了一个或多个源文件的依赖关系和构建过程。

一个基本的Makefile文件包含以下几个部分：1. 声明变量：可以使用变量来定义一些常用的路径、编译选项等信息，使Makefile更加灵活和可维护。

2. 定义规则：通过规则来描述源文件之间的依赖关系和构建过程。

每个规则由一个目标(target)、依赖(dependencies)和指令(commands)组成。

3. 定义伪目标：伪目标是一种特殊的目标，它不表示真实的文件，而是用于执行一些特定的操作，比如清理临时文件、生成文档等。

4. 定义默认目标：默认目标是在执行make命令时，如果没有指定目标，则系统会执行的第一个目标。

简述Makefile文件的格式

简述Makefile文件的格式Makefile文件是一种常见的文本文件，用于描述一个项目中各个文件之间的依赖关系和编译规则。

Makefile文件通常由一系列规则组成，每个规则由一个目标、依赖关系和命令组成。

Makefile文件的格式如下：1. 目标(Target)目标是指需要生成的文件或者执行的操作。

在Makefile中，目标通常是一个可执行程序或者一个库文件。

目标的格式为：target: dependenciescommand其中，target表示目标名称，dependencies表示该目标所依赖的其他文件或者操作，command表示生成该目标所需要执行的命令。

2. 依赖关系(Dependencies)依赖关系指该目标所依赖的其他文件或者操作。

在Makefile中，可以通过在目标后面加上冒号(:)来定义该目标所依赖的其他文件或者操作。

多个依赖关系之间可以使用空格或者Tab键来进行分隔。

3. 命令(Command)命令是指生成该目标所需要执行的具体操作。

在Makefile中，可以通过在每个规则后面添加一行以Tab键开头的命令来定义具体操作。

4. 变量(Variables)变量是指用于存储各种编译参数和路径等信息的变量。

在Makefile中，可以通过使用$()符号来引用变量，并使用=符号来进行赋值操作。

例如：CFLAGS = -Wall -O2CC = gcctarget: dependencies$(CC) $(CFLAGS) -o target dependencies5. 注释(Comments)注释是指用于对Makefile中各个规则进行解释说明的文本。

在Makefile中，可以使用#符号来进行注释，#符号后面的内容将被忽略。

总之，Makefile文件是一个非常重要的工具，在项目开发过程中起到了至关重要的作用。

掌握Makefile文件的格式和编写方法，可以帮助我们更加高效地管理和组织项目代码，并提高项目开发效率。

makefile中的gcc -c -o语法

文章标题：深度探讨makefile中的gcc -c -o语法在makefile中，gcc -c -o是一个非常重要的语法结构，用于编译源文件并生成目标文件。

在本文中，我将对这个语法进行深入探讨，帮助你更好地理解它的用途和功能，并运用到实际的项目中。

1. gcc -c -o的基本概念在makefile中，gcc -c -o用于将源文件编译成目标文件。

其中，-c表示编译但不信息，-o用于指定编译后生成的目标文件名。

这个语法结构在实际的项目中非常常见，尤其是在大型的软件开发过程中。

2. 深入理解gcc -c -o的作用通过gcc -c -o，我们可以将源文件编译成目标文件，然后再将多个目标文件信息起来，生成可执行文件。

这样的分步编译方式可以提高编译的效率，尤其是在一个项目中包含大量源文件的情况下。

另外，通过指定-o参数，我们可以自定义目标文件的生成规则和命名规范，让项目结构更加清晰和灵活。

3. 实际应用案例举一个实际的例子，比如我们有一个项目包含多个源文件，分别是main.c、function1.c和function2.c。

我们可以使用gcc -c -o将这些源文件分别编译成目标文件main.o、function1.o和function2.o，然后通过gcc将这些目标文件信息起来，生成可执行文件。

这样的分步编译方式可以提高项目的维护性和灵活性。

4. 对于gcc -c -o的个人观点和理解个人认为，gcc -c -o是一个非常实用的编译选项，尤其是在大型的软件开发项目中。

通过这个选项，我们可以更加灵活地管理项目的结构，提高编译效率，同时也让代码更加清晰和易于维护。

在实际的项目中，我经常使用这个选项来进行分步编译，以便更好地管理和组织代码。

5. 总结通过本文的深入探讨，相信你对makefile中的gcc -c -o语法有了更深入的理解。

这个语法不仅在软件开发中非常常见，而且也非常实用。

通过灵活运用这个选项，我们可以更好地管理和组织项目，提高代码的可维护性和开发效率。

make语言

make语言介绍Make语言是一种用于构建软件的脚本语言，它在软件开发中扮演着重要的角色。

Make语言基于一种规则（rule）的概念，用于指导如何从源文件生成目标文件。

通过定义这些规则，开发者可以轻松地构建、编译和部署软件项目，提高开发效率、降低错误率。

MakefileMakefile是Make语言的核心部分，它是一个文本文件，包含了一系列规则。

每个规则由一个目标（target）和一系列依赖（dependency）组成，还包括了一条命令（command），用于指导如何生成目标文件。

Make会按照Makefile中定义的规则来进行构建工作。

规则示例以下是一个简单的Makefile示例：target: dependenciescommand•target是规则中的目标文件，它是规则的唯一标识符。

•dependencies是目标文件所依赖的文件或目录，用空格分隔。

•command是生成目标文件的命令。

当执行make命令时，Make会查找Makefile中的规则，并判断目标文件是否需要更新。

如果目标文件不存在或者依赖文件的时间戳更晚，Make会执行相应的命令生成目标文件。

Makefile的特性Makefile具有以下特性：1. 自动化构建Makefile使得软件项目的构建过程自动化，开发者只需要简单地编写Makefile，定义规则和命令，就能自动化地完成构建工作。

这样可以大大节省开发者的时间和精力，提高开发效率。

2. 跨平台Makefile是与操作系统无关的，可以在不同的操作系统上运行。

它可以轻松地适应不同的开发环境，使得项目能够在各种平台上进行构建和部署。

3. 依赖管理Makefile中的规则可以指定目标文件依赖的文件和目录。

当依赖文件发生变化时，Make会按照规则中定义的命令重新生成目标文件，从而保证目标文件的正确性。

4. 并行构建Make可以并行构建多个目标文件，提高构建速度。

通过定义适当的依赖关系，Make可以根据需要进行并行构建，充分利用多核处理器的性能。

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的流程。

makefile中make指令

文章标题：深度解析makefile中make指令的功能与作用1. 引言在软件开发过程中，makefile是一个非常重要的工具，它可以帮助程序员自动化构建和管理项目。

而make指令则是makefile中最常用的命令之一，它负责按照一定规则执行makefile中定义的任务，从而大大提高了开发效率。

本文将重点探讨makefile中make指令的功能与作用。

2. make指令的基本概念在makefile中，make指令用于执行makefile中定义的任务，比如编译、信息、生成目标文件等。

它可以根据目标文件的依赖关系和规则，自动识别需要更新的文件，并进行相应的操作。

3. make指令的使用方法在makefile中，make指令的使用方法非常简单，只需要在命令行中输入“make”即可。

当make指令被执行时，它会首先读取makefile中的规则和任务，然后根据规则执行相应的操作，如编译源文件、信息目标文件等。

4. make指令的作用和功能make指令的主要作用是帮助程序员自动构建和管理项目。

通过make 指令，程序员可以方便地对项目进行编译、信息、生成可执行文件等操作，从而减少了手动操作的繁琐和错误率。

5. make指令的深入分析make指令的深度和广度兼具，它不仅可以执行简单的编译操作，还可以根据makefile中定义的规则进行自动化构建、增量编译等高级操作。

这使得程序员能够更加高效地管理和维护项目。

6. 结语总结来说，makefile中的make指令是一个非常强大的工具，它为程序员提供了自动化构建和管理项目的便利。

通过深入探索make指令的功能与作用，我们可以更好地理解makefile的工作原理，进而提高软件开发的效率和质量。

个人观点和理解：作为我的文章写手，我深信make指令在软件开发中的重要性和价值。

它不仅帮助程序员高效地管理和维护项目，还提供了自动化构建的便利。

通过学习和使用make指令，可以更好地理解makefile的机制，从而提高软件开发的效率和质量。

makefile 命令行参数

2. -C选项
-C选项可以指定Makefile所在的路径。如果我们在当前路径下执行make命令，但是Makefile文件不在当前路径下，那么就需要使用-C选项来指定Makefile所在的路径。例如：
make -C /path/to/Makefile
3. -f选项
-f选项可以指定要使用的Makefile文件名。如果我们有多个Makefile文件，那么就可以使用-f选项来指定要使用哪个Makefile文件。例如：
makefile 命令行参数
Makefile是一种用来管理代码编译的工具，它可以自动化执行编译任务，帮助程序员更高效地管理代码。在Makefile中，可以定义一系列规则来指定如何编译代码。在使用Makefile时，我们可以通过命令行参数来控制编译过程的行为。本文将详细介绍makefile命令行参数的使用方法。项
-j选项可以指定并行编译时所使用的线程数。如果我们有多个CPU核心，并且要编译大型项目，那么就可以使用-j选项来加速编译过程。例如：
make -j4
5. --dry-run选项
--dry-run选项可以模拟执行make命令，并输出将要执行的命令列表，但是并不会真正地执行这些命令。这个功能非常实用，因为我们可以预先查看将要执行的命令，确保它们是正确的。例如：
这样做的好处是，我们可以在不修改Makefile的情况下，通过命令行参数来控制编译过程的行为。
四、总结
本文介绍了Makefile命令行参数的用法，包括make命令、-C选项、-f选项、-j选项、--dry-run选项和--print-data-base选项。同时，本文还介绍了一些Makefile常用技巧，包括使用变量来存储编译选项、使用通配符来自动生成目标文件列表和使用命令行参数来控制编译过程。希望本文能够对大家理解和学习Makefile有所帮助。

makefile 生成依赖关系

一、概述在软件开发过程中，源文件之间的依赖关系是非常重要的。

当一个文件发生变化时，其依赖文件可能也会受到影响，因此需要一个工具来管理这些依赖关系，确保在编译过程中能够正确地处理依赖关系。

makefile就是一个非常强大的工具，能够自动生成依赖关系，本文将详细介绍makefile生成依赖关系的方法。

二、什么是makefilemakefile是一个包含规则和命令的文本文件，用来描述软件项目的编译过程。

它告诉make工具，如何去利用源文件生成目标文件。

makefile通常包含了以下内容：1. 目标（target）：表示要生成的文件，可以是可执行文件、中间文件或其他类型的文件。

2. 依赖（dependencies）：表示目标文件所依赖的源文件或其他文件。

3. 命令mands）：表示生成目标文件的具体操作，通常是编译、信息等。

三、makefile生成依赖关系的原理在编译过程中，一个源文件可能会依赖于其他源文件或头文件，当这些依赖关系发生变化时，我们需要重新编译相关的文件。

makefile 生成依赖关系的原理就是通过分析源文件中的#include语句，自动识别出文件之间的依赖关系，并生成相应的规则。

1. 使用gcc的-M选项gcc是一个非常流行的编译器，在编译过程中，它提供了-M选项来生成依赖关系。

例如：```make.o: .cgcc -c $< -o $ -MMD -MF $*.d```这里，-MMD选项表示生成依赖关系文件，-MF选项指定了依赖关系文件的名称。

通过这样的makefile规则，gcc能够自动生成每个源文件的依赖关系。

2. 使用自定义脚本除了使用gcc的-M选项外，我们也可以编写一个自定义的脚本来生成依赖关系。

这样能够更加灵活地控制依赖关系的生成过程。

五、makefile生成依赖关系的优势1. 自动化：makefile能够自动分析源文件之间的依赖关系，不需要手动维护依赖关系。

2. 灵活性：makefile生成依赖关系的方法非常灵活，可以根据实际需要选择不同的生成方式。

linux make命令的工作原理

linux make命令的工作原理make命令是一个用于自动化编译和构建程序的工具，它通过读取Makefile 文件中的规则来确定如何构建目标文件。

Makefile文件包含了目标文件和依赖关系的描述，以及构建目标文件的命令。

Make命令的工作原理如下：1.读取Makefile文件：make命令首先会读取当前目录下的Makefile文件，该文件包含了目标文件和依赖关系的描述，以及构建目标文件的命令。

2.解析规则：make命令会解析Makefile文件中的规则，包括目标文件、依赖关系和命令。

3.检查依赖关系：make命令会检查目标文件的依赖关系，并判断是否需要重新构建目标文件。

如果目标文件不存在或者依赖的文件被修改过，则需要重新构建目标文件。

4.构建目标文件：如果需要重新构建目标文件，make命令会执行Makefile文件中对应目标文件的构建命令。

构建命令可以是编译源代码、链接目标文件等操作。

5.更新目标文件：构建完成后，make命令会更新目标文件的时间戳，以反映最新的修改时间。

6.递归构建：如果目标文件的依赖关系中还包含其他目标文件，make命令会递归地执行构建过程，以确保所有的依赖关系都得到满足。

7.完成构建：当所有的目标文件都构建完成后，make命令会输出构建成功的消息，并退出。

Make命令的优势在于它只会构建需要更新的目标文件，而不会重新构建所有的文件。

这样可以提高编译和构建的效率，尤其是在大型项目中。

另外，Make命令还支持并行构建，可以同时构建多个目标文件，进一步提高构建的效率。

总结起来，Make命令的工作原理是通过读取Makefile文件中的规则来确定如何构建目标文件，检查目标文件的依赖关系并判断是否需要重新构建，执行构建命令来生成目标文件，递归构建所有的依赖关系，最后输出构建成功的消息。

Make命令的优势在于只构建需要更新的文件，提高构建效率。

海思makefile结构解析

海思makefile结构解析全文共四篇示例，供读者参考第一篇示例：海思芯片是一家领先的半导体公司，在国际市场上拥有广泛的市场份额。

海思芯片的产品广泛应用在手机、网络通信、物联网、智能家居等领域，其芯片性能卓越，在同行业内享有很高的声誉。

在海思芯片的开发中，makefile是一个非常重要的工具，它负责管理整个项目的编译、链接和部署过程，帮助开发人员更高效地完成工作。

makefile是一个用于自动化编译的脚本文件，通过编写makefile 文件，可以告诉计算机如何编译源代码，生成可执行文件。

海思makefile结构解析主要包括以下几个部分：1. 定义变量：在makefile中定义变量是非常重要的，可以方便地管理项目的路径、编译参数等信息。

海思makefile中通常会定义一些常用的变量，比如CC表示编译器的路径，CXX表示C++编译器的路径，CFLAGS表示编译参数等。

通过定义这些变量，可以在整个makefile中直接引用，减少了代码的冗余，提高了代码的可维护性。

2. 设置编译规则：在makefile中，通常会定义一些编译规则，告诉make工具如何编译源文件和生成可执行文件。

海思makefile中的编译规则通常使用模式匹配的方式，比如"%.c:%.o"表示将所有的.c文件编译为.o文件，而"%.o:%.c"则表示将所有的.o文件根据对应的.c文件进行重新编译。

通过这些编译规则，make工具可以根据需要自动化地完成整个项目的编译过程。

3. 定义目标：在makefile中通常会定义一些目标，这些目标可以是编译生成可执行文件的命令，也可以是清理生成的临时文件的命令。

海思makefile中的目标通常包括all、clean、install等，通过定义这些目标，可以方便地管理整个项目的编译和部署过程。

4. 调用外部工具：在海思makefile中，通常会调用一些外部工具来完成一些特定的任务，比如编译器、链接器、打包工具等。

make 的用法精简版

make 的用法一、make 的简介make 是一个构建工具，用于自动化构建项目。

它通常用于编译和程序，但也可以用于执行其他自定义任务。

通过编写 Makefile 文件，我们可以定义构建过程中的各个步骤，以及它们之间的依赖关系和执行顺序。

make 会根据这些定义来执行相应的任务，从而使我们能够更高效地管理项目的构建过程。

二、Makefile 的基本语法Makefile 采用一种类似于 Shell 脚本的语法，它由一系列规则组成。

每个规则包含一个目标和一组依赖项，以及一条或多条命令。

make 在执行构建任务时，会根据这些规则来确定执行的顺序。

1. 定义目标每个规则都必须指定一个目标，用于表示所要构建的文件或任务。

目标通常是一个文件名，但也可以是一个任务的名称。

我们可以通过定义一系列规则来定义多个目标。

2. 定义依赖项每个规则还可以指定一组依赖项，用于表示该规则执行所依赖的文件或任务。

如果某个依赖项发生变化，则表示该规则需要重新执行。

3. 定义命令每个规则可以包含一条或多条命令。

这些命令用于执行构建任务的具体操作，如编译代码、拷贝文件、运行测试等。

命令会按照规则的顺序执行。

三、Makefile 的实例下面是一个简单的 Makefile 示例，用于编译一个 C 程序：makefile定义目标和依赖项hello: hello.ogcc -o hello hello.o定义编译命令hello.o: hello.cgcc -c hello.c清理的文件clean:rm -f hello hello.o在上面的示例中，我们定义了一个目标 hello，该目标依赖于一个名为 hello.o 的文件。

我们还定义了一个编译命令，用于将hello.c 编译成 hello.o。

我们还定义了一个用于清理文件的命令，以便在不需要时清理掉的可执行文件和目标文件。

四、常用的 make 命令make 提供了一系列常用的命令，用于执行构建任务和管理Makefile 文件。

cmake生成makefile流程

文章标题：深入剖析CMake生成Makefile的流程与原理1. CMake介绍CMake是一个跨评台的自动化构建工具，可用于管理软件构建过程中的编译、信息、测试和安装等任务。

它采用了一种称为“CMakeLists.txt”的文本配置文件来描述项目的构建过程，然后根据这些描述生成不同评台下的构建脚本，如Makefile。

2. CMake生成Makefile的流程（1）项目目录结构：需要在项目目录下创建一个CMakeLists.txt文件，描述项目的组织结构和构建过程。

（2）配置CMake：运行cmake命令，指定项目的路径和生成的构建系统，如Unix的Makefile、Windows的Visual Studio项目等。

（3）生成Makefile：CMake解析CMakeLists.txt文件，生成相应的Makefile文件。

（4）编译项目：运行生成的Makefile文件，执行编译、信息等操作。

3. CMake生成Makefile的原理（1） CMakeLists.txt文件：该文件描述了项目的结构、依赖关系、编译选项等信息，CMake根据这些信息生成Makefile。

（2） CMake内部算法：CMake利用内部的算法来解析CMakeLists.txt文件，生成对应评台的构建脚本。

4. 个人观点和理解CMake的优势在于其跨评台性和灵活性，能够简化项目的构建过程，提高开发效率。

而CMake生成Makefile的过程则是其核心功能之一，可以帮助开发人员快速、高效地进行项目构建和管理。

总结与回顾本文深入剖析了CMake生成Makefile的流程与原理，介绍了CMake的基本概念和使用方法。

通过本文的阐述，读者可以更全面地了解CMake在软件构建中的作用和重要性，以及其生成Makefile的内部工作机制，希望能对读者有所帮助。

通过本文的了解，你是否对CMake生成Makefile的流程有了更深入的认识呢？让我们一起来探索和学习吧！CMake作为一个跨评台的自动化构建工具，其生成Makefile的流程和原理是非常重要的，了解这些内容有助于开发人员更好地使用和理解CMake，提高项目构建的效率和质量。

make file的if fi写法

一、make file的概念及作用make file是一种用来描述文件之间的依赖关系，以及如何通过执行特定命令来生成目标文件的工具。

它的作用在于帮助程序员自动化编译、信息和部署程序，提高开发效率和代码质量。

二、make file的语法及基本结构1. make file以一组规则的形式存在，每个规则包含了目标、依赖以及命令三部分。

2. 目标指定了规则要生成的文件名，可以是可执行文件、中间文件或者其他类型的文件。

3. 依赖指定了生成目标文件所需要依赖的文件或者其他目标文件。

4. 命令指定了生成目标文件的具体操作，可以是编译、信息、复制等操作。

三、make file的if/then/fi写法1. if/then/fi是make file中用来判断条件并执行相应操作的语法结构，类似于C语言中的if语句。

2. if后面跟着条件表达式，根据条件的真假来决定执行then后面的命令还是fi后面的命令。

3. then后面跟着要执行的命令，可以是单个命令，也可以是多个命令使用分号分隔。

4. fi表示if语句的结束，标志着条件判断部分的结束。

四、if/then/fi的使用场景1. if/then/fi结构可以用来根据特定条件执行不同的命令，比如根据评台的不同选择不同的编译选项。

2. 可以在make file中根据文件的存在与否来判断是否执行特定操作，比如判断依赖文件是否存在，如果不存在则生成。

3. 可以根据变量的取值来选择不同的操作，比如根据DEBUG变量的取值来选择是否生成调试信息。

五、if/then/fi的注意事项1. 在make file中使用if/then/fi时需要注意语法的正确性，要保证if、then和fi的配对和嵌套关系正确。

2. 条件表达式要保证逻辑上的正确性，避免出现歧义和错误。

3. 命令部分的书写要符合make file的语法规范，保证可以正确执行。

4. 对于复杂的条件判断，可以考虑使用shell脚本来处理，然后在make file中调用对应的shell脚本。

OpenWrt构建过程（主Makefile分析）

OpenWrt构建过程（主Makefile分析）玩了这么久的OpenWrt，最近详细研究了⼀下整个⼯程的构建过程，也希望作为备份以便以后查阅。

⽹上这⽅⾯的⽂章⼀⼤把，不过多数都只提及⽪⽑，我就选取了感觉还不错的放了过来，毕竟全部⾃⼰写太⿇烦了。

我主要整理了下⾯这两篇⽂章，和整个构建过程基本相符，在这⾥也对原作者表⽰感谢。

编译过程概述编译的总体过程如下:1.编译host⼯具2.编译交叉⼯具链3.编译内核模块4.编译ipk5.安装ipk到⽂件系统6.编译内核7.将内核和⽂件系统组合成最终binary1. 编译host⼯具虽然我们在开始编译前已经安装了⼀些必要的⼯具，但编译过程中还需要其他⼀些主机⼯具。

这部分⼯具将⾸先编译。

2. 编译交叉⼯具链openwrt⾃带交叉编译链，当然在编译⽬标平台软件前，需要先编译。

3. 编译内核模块因为部分内核模块将会⽣成独⽴的ipk，所以内核模块需要⾸先编译。

4. 编译ipk这⾥将编译package⽬录下的各个软件包，这也是和我们最为息息相关的。

5. 安装ipk将⽣成的ipk安装到⽂件系统之中(⽐如build_dir/target-XXX/root-ramips⽬录)。

6. 编译内核在完成ipk编译之后,将会编译内核,压缩内核.同时使⽤mkimage⼯具，在内核前⾯⽣成⼀个⽤于uboot识别的头部。

7. 合成在最后⼀步,将⽂件系统和内核连接在⼀起,即⽣成了⽬标⼆进制镜像⽂件。

Makefile结构分析我们以chaos calmer的代码为例，整个编译的⼊⼝是在源码根⽬录下的Makefile。

编译的各种命令都应该在源码根⽬录下键⼊。

整个主Makefile的结构如下：world:ifneq ($(OPENWRT_BUILD),1)顶层else第⼆层endif开始部分是⼀些注释和变量定义及路径检查。

根据Makefile的规则,在没有指定编译⽬标的时候,Makefile中的第⼀个⽬标将作为默认⽬标。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Makefile结构分析-----uClinux （2.6.x内核）系统映像过程刘江欧阳昭暐吕熙隆1、源代码文件及目录构成解压缩uClinux-dist-20070130.tar.gz压缩文件，在uClinux-dist原始子目录下主要有：config、Bin、linux-2.4.x、linux-2.6.x 、lib、tools、Include、user和vendors，以及文件Makefile。

另外，在编译后生成子目录images和romfs，以及文件autoconfig.h、config.in和两个隐含文件：.config和.depend。

config子目录包含文件及下一级子目录，如config.in、configure.help、Fixconfig、Makefile、Mkconfig、Setconfig所有这些文件及子目录Scripts均与系统配置有关；linux-2.6.x子目录是嵌入式操作系统uClinux-2.6.x的核心目录，包括下一级子目录arch、include、init、drivers、fs、ipc、kernel、lib、Mm、scripts和关键文件Makefile、rules.make，编译后还要生成新文件romfs.o、linux和system.map；lib子目录为嵌入式操作系统提供压缩和改进了的函数库支持；tools子目录包含romfs-inst.sh文件，通过调用此文件，可以把目录或文件加入到romfs子目录中；user子目录包含各种驱动程序文件目录，根据用户的配置情况，不同的驱动程序会被编译进最后形成的操作系统中；vendors子目录包括与特定硬件平台相关的分类目录组。

目录结构如图1所示。

Makefile的详细介绍情况在uClinux-dist\linux-2.6.x\Documentation\kbuild中，如图2所示。

图1、目录结构即Linux 内核中的 Makefile 以及与 Makefile 直接相关的文件有：a. Makefile：顶层 Makefile，是整个内核配置、编译的总体控制文件。

b. .config：内核配置文件，包含由用户选择的配置选项，用来存放内核配置后的结果（如 make config）。

c. arch/*/Makefile：位于各种 CPU 体系目录下的 Makefile，如arch/arm/Makefile，是针对特定平台的 Makefile。

d. 各个子目录下的 Makefile：比如 drivers/Makefile，负责所在子目录下源代码的管理。

e. Rules.make：规则文件，被所有的 Makefile 使用。

图2、make说明文档2、编译过程简介该编译过程的方法在uClinux-dist/ linux-2.6.x /Readme中有详细描述。

将uClinux-dist-20070130.tar.gz放入/usr目录中，依次在终端输入如下命令：# cd /usr/# tar –zxvf uClinux-dist-20070130.tar.gz# cd uClinux-dist （Cd into the source tree）# make clean# make config （Configure the build target）# make dep （Build the dependencies）# make （Build the image）终端提示在/image目录下成功生成映像文件。

3、核心Make文件运行分析3.1、make clean执行情况分析3.1.1 uClinux-dist/Makefile中的clean命令图3、核心makefile中clean代码在根目录Makefile可以找到LINUXDIR = $(CONFIG_LINUXDIR)， CONFIG_ LINUXDIR定义在前面生成的.config文件中，CONFIG_LINUXDIR =linux-2.6.x。

所以执行该核心makefile首先调用modules clean命令进行扩充（modules_clean: -[ ! -d modules ] || $(MAKEARCH) -C modules clean），然后命令再执行删除/ linux-2.6.x/目录下以前编译生成的linux、asm、perlasm等文件。

3.1.2 uClinux-dist/ linux-2.6.x /Makefile中的clean命令在/linux-2.6.x/Makefile文件中，make clean相关部分代码如下：图4、linux-2.6.x /Makefile中clean代码"make clean"删除几乎所有的在编译内核时生成的文件，该命令首先删除相同目录下的文件和目录CLEAN_FILES,CLEAN_DIRS，接着通过archclean命令进行扩充。

此外，在"make clean"还会删除匹配 "*.[oas]"，"*.ko" 的文件。

Archclean在/linux-2.6.x/arch/arm/Makefile中，相关代码如下：图5、/arch/arm/Makefile中archclean代码当"make clean"执行时，make会递归访问archclean并清理boot，因此，make clean就相当于make archclean。

具有清除功能的命令还有make mrproper、make distclean。

他们和make clean 有区别，具体在核心Makefile中有说明，如图6所示：图6、/arch/arm/Makefile中archclean代码没搞清楚uClinux-dist/Makefile和uClinux-dist/ linux-2.6.x /Makefile中clean的联系，猜测在uClinux-dist/执行make clean命令时，根本不调用uClinux-dist/ linux-2.6.x /Makefile中clean命令。

3.2、make config执行情况分析make config的功能是完成系统配置，在uClinux-dist/文件中，源代码如图7所示：图7、核心makefile中config代码图8、核心makefile中config.in代码从该代码可以看出make config用scripts/Configure去解释执行在uClinux-dist/config/mkconfig/目录下的congif.in,同时还调用执行该目录下的setconfig配置文件进行环境设置。

由此可见uClinux-dist/ makefile只是个索引，最终调用指向uClinux-dist/config/Makefile。

在uClinux-dist/config/Makefile文件中，源代码如图9所示：图9、四种？config代码比较从该代码可以看出make config用scripts/Configure去解释执行在当前目录下的congif.in；make oldconfig配置情况与make config基本相同，仅仅多了一个参数 –d，大概表示它要使用默认配置文件的意思。

make menuconfig与前两种相比有很大的不同，虽然依然使用了config.in文件，但使用电工具不同，是Menuconfig，并且在开始部分还有一些准备工作要做。

主要因为将config.in转化为菜单形式，用户工作界面有较大的改进，工作就要复杂一些。

Make Xconfig更加复杂，首先要制作合理的文件，然后用wish执行，使config.in转变为xwindows方式进行系统配置的工具。

因此，以上四种配置方式在完成系统赋予的使命上功能是一致的，只不过操作界面有所不同。

用户通过 make config 配置后，产生了 .config。

顶层 Makefile 读入 .config 中的配置选择。

顶层 Makefile 有两个主要的任务：产生 vmlinux（未压缩的内核）文件和内核模块（module）。

为了达到此目的，顶层 Makefile 递归的进入到内核的各个子目录中，分别调用位于这些子目录中的 Makefile。

至于到底进入哪些子目录，取决于内核的配置。

在顶层 Makefile 中，有一句：include arch/$(ARCH)/Makefile，包含了特定 CPU 体系结构下的 Makefile，这个 Makefile 中包含了平台相关的信息。

3.3、make dep执行情况分析make dep读取系统配置以创建编译时可依赖的关系树，结果被存储在隐含文件.depend中，makefile通过包含.depend文件来包含这种依赖关系树，用于指导编译。

在uClinux-dist/makefile中dep代码如图10所示：图10、核心makefile中dep代码该代码告诉我们在/ linux-2.6.x/.config文件，如果找不到提示错误退出，反之执行该目录下的dep命令（假定配置时选定的为linux-2.6.新的内核），而在该目录下该命令根本找不到。

即使具有类似功能的depend dep仅有一个文本输出的提示信息。

depend dep:@echo '*** Warning: make $@ is unnecessary now.'由此可见，该命令主要是针对以前编译2.4内核的时候用的，以保证编译内核时所有的依赖，例如头文件，都存在。

但对于2.6来讲已经不需要了，直接一个make命令把make dep和make zImage的事请就做了。

3.4、make执行情况分析在Makefile中提供了配置编译选项的各种规则，执行make help命令可以打印出详细的帮助信息，从中我们可以看出执行“#make”或执行“make all”，将自动编译带“*”的目标，即自动自动编译vmlinux、modules、zImage（或xipImage）。

在uClinux-dist/目录下运行#make命令，进行编译链接内核映像，从makefile关联关系看，过程应该是：先编译链接生成顶层目录的vmlinux，然后再把vmlinux精简压缩成piggy.gz，最后加上自引导程序链接成linux-2.6.x/arch/arm/boot/zImage，这是一个具备自启动能力的linux内核映像。

对最后一步make命令详细分析如下：3.4.1 [uClinux-dist/makefile]： /*根目录下的入口*/（1）找到makefile程序执行的入口，如图11所示。