Makefile在linux内核中如何使用_华清远见

合集下载

linux系统命令make、clean的用法讲解

linux系统命令make、clean的⽤法讲解先先看⼀下什么是makefilemakefile定义了⼀系列的规则来指定，哪些⽂件需要先编译，哪些⽂件需要后编译，哪些⽂件需要重新编译，甚⾄于进⾏更复杂的功能操作，因为 makefile就像⼀个Shell脚本⼀样，其中也可以执⾏操作系统的命令。

makefile带来的好处就是--“⾃动化编译”,⼀旦写好，只需要⼀个make命令，整个⼯程完全⾃动编译，极⼤的提⾼了软件开发的效率。

make是⼀个命令⼯具，是⼀个解释makefile中指令的命令⼯具，⼀般来说，⼤多数的IDE都有这个命令，⽐如：Delphi 的make,Visual C++的nmake,Linux下GNU的make.可见，makefile都成为了⼀种在⼯程⽅⾯的编译⽅法。

make根据Makefile⽂件编译源代码、连接、⽣成⽬标⽂件、可执⾏⽂件。

make clean清除上次的make命令所产⽣的object⽂件（后缀为“.o”的⽂件）及可执⾏⽂件。

make install将编译成功的可执⾏⽂件安装到系统⽬录中，⼀般为/usr/local/bin⽬录。

make dist产⽣发布软件包⽂件（即distribution package）。

这个命令将会将可执⾏⽂件及相关⽂件打包成⼀个tar.gz压缩的⽂件⽤来作为发布软件的软件包。

它会在当前⽬录下⽣成⼀个名字类似“PACKAGE-VERSION.tar.gz”的⽂件。

PACKAGE和VERSION,是我们在configure.in中定义的AM_INIT_AUTOMAKE（PACKAGE, VERSION）。

make distcheck⽣成发布软件包并对其进⾏测试检查，以确定发布包的正确性。

这个操作将⾃动把压缩包⽂件解开，然后执⾏configure命令，并且执⾏make,来确认编译不出现错误，最后提⽰你软件包已经准备好，可以发布了。

make distclean类似make clean,但同时也将configure⽣成的⽂件全部删除掉，包括Makefile⽂件。

linux makefile流程

linux makefile流程
在Linux系统中，Makefile是一种用于管理和自动化构建过程的工具。

它定义了
编译、链接和其他操作的规则，以及这些操作所依赖的文件和目标。

下面是Makefile的基本流程：
1. 确定目标：Makefile中首先需要指定要构建的目标，这些目标可以是执行文件、库文件或其他想要生成的输出。

2. 定义变量：在Makefile中，变量用于存储要使用的命令、编译器选项、源文件
列表等信息。

通过定义变量，可以简化Makefile的维护和修改。

3. 定义规则：规则描述了如何生成目标文件的过程。

每条规则包括目标、依赖和
命令。

目标是要生成的文件或动作，依赖是生成目标所需的文件或动作，命令是
执行操作的命令。

4. 构建依赖关系：Makefile使用依赖关系来确定何时重新构建目标。

依赖关系指
定了目标所依赖的文件或其他目标。

5. 执行命令：当执行make命令时，Makefile会检查目标及其依赖关系，并根据
需要执行相关命令。

Makefile会自动判断哪些文件需要重新构建，以及构建的顺序。

6. 更新目标：如果目标不存在或其依赖发生了变化，Makefile会根据规则中定义
的命令重新生成目标。

7. 清理目标：可以在Makefile中添加一个"clean"规则来删除生成的目标文件和其
他中间文件，以便重新构建项目。

8. 终止构建：在构建过程中，如果发生错误或出现其他异常情况，可以通过抛出
错误或使用特定命令来停止构建过程。

Linux内核中的Makefile文件

Linux内核中的Makefile文件本节不对内核的Makefile文件进行深入展开，更多语法和说明请阅读<Documentation/kbuild/makefiles.txt>文件。

1.1.1 顶层Makefile源码目录树顶层Makefile是整个内核源码管理的入口，对整个内核的源码编译起着决定性作用。

编译内核时，顶层Makefile会按规则递归历遍内核源码的所有子目录下的Makefile文件，完成各子目录下内核模块的编译。

熟悉一下该Makefile，对内核编译等方面会有所帮助。

1．内核版本号打开顶层Makefile，开头的几行记录了内核源码的版本号，通常如下所示：VERSION = 2PA TCHLEVEL = 6SUBLEVEL = 35EXTRA VERSION =3说明代码版本为2.6.35.3，编译得到的内核在目标板运行后，输入uname -a命令可以得到印证：# uname -aLinux boy 2.6.35.3-571-gcca29a0-gd431b3d-dirty #22 PREEMPT Tue Oct 27 20:12:33 CST 2015 armv5tejl GNU/Linux2．编译控制（1）体系结构Linux是一个支持众多体系结构的操作系统，在编译过程中需指定体系结构，以与实际平台对应。

在顶层Makefile中，通过变量ARCH来指定：ARCH ?= $(SUBARCH)如果没有在编译命令行中指定ARCH参数，系统将会进行本地编译，通过获取本机信息来自动指定：SUBARCH := $(shell uname -m | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \-e s/arm.*/arm/ -e s/sa110/arm/ \-e s/s390x/s390/ -e s/parisc64/parisc/ \-e s/ppc.*/powerpc/ -e s/mips.*/mips/ \-e s/sh[234].*/sh/ )如果进行ARM嵌入式Linux开发，则必须指定ARCH为arm（注意大小写，须与arch/目录下的arm一致），如：$make ARCH=arm当然，也可以修改Makefile，将修改为ARCH ?= $(SUBARCH)修改为ARCH = arm，在命令行直接make即可。

makefile用途和用法

makefile用途和用法Makefile是一种用于自动化构建和管理软件项目的工具，它由一系列规则和命令组成。

Makefile的主要作用是根据项目中源代码的依赖关系，判断哪些文件需要重新编译，然后执行相应的编译和链接操作，以生成最终的可执行文件或库文件。

Makefile的用法如下所示：1. 定义规则：Makefile中的规则由目标、依赖和命令组成。

目标是待生成的文件或操作的名称，依赖是生成目标所依赖的文件或操作，命令是生成目标的具体操作步骤。

2. 指定规则：使用“target: prerequisites”格式指定规则，其中target是目标文件，prerequisites是该目标所依赖的文件。

3. 编写命令：在每个规则中，使用Tab键缩进的命令行来定义生成目标的操作步骤。

命令行可以是任何Shell命令，包括编译器和链接器的命令。

4. 依赖关系：通过指定目标文件所依赖的源代码文件或其他目标文件，Makefile可以自动判断哪些文件需要重新编译。

5. 变量定义：Makefile中可以定义变量来存储常用的参数和选项，以便在各个规则中复用。

通过编写Makefile，可以实现以下几个方面的功能：1. 自动编译：Makefile可以根据源代码文件和依赖关系，自动判断哪些文件需要重新编译，从而避免重复编译不必要的文件，提高编译效率。

2. 自动链接：Makefile可以自动处理目标文件之间的依赖关系，并根据链接选项生成最终的可执行文件或库文件。

3. 构建工程：通过Makefile，可以定义多个目标文件和相应的规则，从而一次性构建整个项目，减少手动操作的工作量。

4. 管理项目：Makefile可以定义清理规则，用于删除生成的目标文件和临时文件，保持项目目录的清洁。

Makefile是一个强大的工具，可以大大简化软件项目的构建和管理过程，提高开发效率和可维护性。

通过合理使用Makefile，可以更好地组织和管理项目代码，实现自动化构建和持续集成。

linux vscode makefile语法

linux vscode makefile语法在Linux 系统中，如果您想使用VSCode 编写Makefile 相关的项目，可以参考以下步骤进行安装和配置：1. 首先，确保已经正确安装了Visual Studio Code。

如果尚未安装，可以参考[1] 中的教程进行安装。

2. 安装Makefile 插件。

打开VSCode，转到“扩展”选项卡（快捷键：Ctrl+Shift+X），搜索“Makefile”，找到名为“Makefile Support”的插件，点击“安装”。

3. 创建一个新的Makefile 项目。

在VSCode 中，创建一个新的文件夹，然后在该文件夹中打开终端（快捷键：Ctrl+`）。

4. 编写Makefile 语法。

在项目根目录下创建一个名为“Makefile”的文件，然后编写相应的Makefile 语法。

以下是一个简单的示例：```make# 设置变量MY_PROJECT_NAME = MyProjectMY_PROJECT_VERSION = 1.0# 设置目标all: build# 构建目标build:echo "Building $MY_PROJECT_NAME $MY_PROJECT_VERSION"# 在这里添加您的构建命令，例如：cmake、make等# 清理目标clean:echo "Cleaning $MY_PROJECT_NAME"# 在这里添加您的清理命令，例如：rm -rf build/# 默认执行构建目标default: build```5. 保存Makefile 文件并按F5 键运行项目。

VSCode 将会自动使用内置的终端执行Makefile 中的命令。

6. 如果需要使用GPU 加速构建，可以在Makefile 中添加相应的NVIDIA CUDA 或者AMD OpenCL 命令。

例如，如果您使用的是NVIDIA GPU，可以添加以下命令：```makebuild_gpu:echo "Building $MY_PROJECT_NAME $MY_PROJECT_VERSION using GPU"# 在这里添加您的GPU 构建命令，例如：nvcc、cuda编译器等```7. 按照项目需求修改Makefile 中的命令和目标。

linux makefile 写法

linux makefile 写法Linux Makefile 写法Makefile 是一种用于组织和管理软件项目的文件格式，它指导着编译器如何构建程序。

在Linux 环境下，Makefile 是一种特别常见的构建工具，它通过定义目标和规则，使得软件开发人员能够轻松地构建、编译和部署项目。

本文将一步一步回答关于Linux Makefile 写法的问题，帮助你深入了解如何编写高效的Makefile。

第一步：创建Makefile 文件首先，你需要在你的Linux 环境中创建一个名为"Makefile" 的文本文件。

你可以使用任何文本编辑器，如Vim、Nano 或者Emacs 来完成这个任务。

确保你的Makefile 文件保存在项目的根目录下，这样Make 命令才能找到它。

第二步：定义变量在Makefile 中，你可以定义各种变量来存储重复使用的值，如编译器名称、编译选项和目标文件名。

定义变量的语法是"变量名=值"，例如：CC=gccCFLAGS=-Wall -WerrorTARGET=myprogram在上面的例子中，我们定义了三个变量：`CC`、`CFLAGS` 和`TARGET`。

`CC` 变量的值是`gcc`，指定了使用GCC 编译器。

`CFLAGS` 变量的值是`-Wall -Werror`，这些编译选项用于启用所有警告，并将警告视为错误。

`TARGET` 变量的值是`myprogram`，这是我们期望生成的最终可执行文件的名称。

第三步：指定编译规则在Makefile 中，你需要指定编译规则来告诉编译器如何构建你的程序。

编译规则由目标、依赖和命令组成。

下面是一个简单的例子：(TARGET): main.o utils.o(CC) (CFLAGS) -o (TARGET) main.o utils.o在上面的例子中，我们指定了一个名为`(TARGET)` 的目标，它依赖于`main.o` 和`utils.o` 两个文件。

【完整版】Linux下makefile教程

Linux下makefile教程转自陈皓(CSDN)概述——什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE 都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。

这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。

特别在Unix下的软件编译，你就不能不自己写m akefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。

因为，makefile关系到了整个工程的编译规则。

一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为m akefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

makefile带来的好处就是——―自动化编译‖，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。

make是一个命令工具，是一个解释make file中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，V isual C++的nmake，Linux下GNU的make。

可见，makefile都成为了一种在工程方面的编译方法。

现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。

当然，不同厂商的make各不相同，也有不同的语法，但其本质都是在―文件依赖性‖上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。

必竟，这个make是应用最为广泛的，也是用得最多的。

而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。

linux makefile语法

linux makefile语法Makefile 是一种用于构建和管理项目的文件，特别适用于C/C++等编程语言。

下面是 Makefile 的一些常见语法：1. 变量定义：变量可以通过 `变量名 = 值` 的形式定义。

例如：`CC = gcc`。

在后续的规则中，可以通过`$(变量名)` 的形式引用变量的值。

2. 目标规则：目标规则指定了 Makefile 中的一个目标以及其依赖关系和命令。

一般的语法为：```目标: 依赖[tab]命令```其中，目标是一个文件或一个动作的名字，依赖是目标所依赖的其他文件或目标，命令是执行的操作。

命令必须以一个TAB 字符开始。

3. 通配符：在 Makefile 中，可以使用通配符来表示一组文件。

例如，`*.c` 表示所有以 `.c` 结尾的文件。

4. 伪目标：伪目标是一种特殊的目标，它不代表一个文件，而是代表一组操作。

伪目标一般用于执行一些特殊的操作，如清理文件、生成文档等。

在 Makefile 中，可以通过 `.PHONY` 关键字来定义伪目标：```.PHONY: cleanclean:[tab]rm -f *.o```5. 函数：Makefile 中也支持函数的使用。

常见的函数有：- `$(shell command)`：执行 command 命令，并返回输出结果。

- `$(wildcard pattern)`：返回符合 pattern 模式的文件列表。

- `$(patsubst pattern,replacement,text)`：将 text 中符合 pattern 模式的部分替换为 replacement。

- `$(foreach variable,list,text)`：对 list 中的每个元素，在 text 中进行替换操作。

这些只是 Makefile 的一部分语法，具体使用还需要根据具体情况和需求来灵活应用。

linux内核makefile浅析

Linux内核Makefile浅析1．配置系统的基本结构Linux内核的配置系统由三个部分组成，分别是：1.Makefile：分布在Linux 内核源代码中的Makefile，定义Linux 内核的编译规则；2.配置文件（config.in）：给用户提供配置选择的功能；3.配置工具：包括配置命令解释器（对配置脚本中使用的配置命令进行解释）和配置用户界面（提供基于字符界面、基于Ncurses 图形界面以及基于Xwindows 图形界面的用户配置界面，各自对应于Make config、Make menuconfig 和make xconfig）。

这些配置工具都是使用脚本语言，如Tcl/TK、Perl 编写的（也包含一些用C 编写的代码）。

本文并不是对配置系统本身进行分析，而是介绍如何使用配置系统。

所以，除非是配置系统的维护者，一般的内核开发者无须了解它们的原理，只需要知道如何编写Makefile 和配置文件就可以。

所以，在本文中，我们只对Makefile 和配置文件进行讨论。

另外，凡是涉及到与具体CPU 体系结构相关的内容，我们都以ARM 为例，这样不仅可以将讨论的问题明确化，而且对内容本身不产生影响。

2．Makefile2.1 Makefile 概述Makefile 的作用是根据配置的情况，构造出需要编译的源文件列表，然后分别编译，并把目标代码链接到一起，最终形成Linux 内核二进制文件。

由于Linux 内核源代码是按照树形结构组织的，所以Makefile 也被分布在目录树中。

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

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

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

Linux下Makefile的编写与使用详解

Linux下Makefile的编写与使⽤详解⽬录MakefileMakefile⽂件命名和规则Makefile的⼯作原理Makefile变量Makefile函数Makefile clean规则Makefile⼀个⼯程⽂件中的源⽂件可能有很多，并且不同的功能、模块等都放在不同的⽬录中，常规的编译已经不能⾼效化的处理这样的问题，⽽Makefile就是为解决这⼀问题⽽来。

Makefile⼀旦写好，只需⼀个make指令，即可完成Makefile⽂件中所编写的所有指令，从⽽编译整个⼯程⽂件，极⼤的提⾼了效率。

make是⼀个命令⼯具，⽤来解释Makefile中的命令。

Makefile⽂件命名和规则⽂件命名采⽤makefile或Makefile都可。

Makefile规则Makefile中的命令规则如下：xxx（⽬标⽂件）：xxx（依赖⽂件）（制表符）命令（shell命令）其中，⽬标⽂件即最终要⽣成的⽂件（伪⽬标除外），依赖⽂件即⽣成⽬标⽂件所需的⽂件，命令即shell命令。

注意，命令前必须有⼀个tab缩进。

例如：#Makefileapp: a.c b.c #⽬标：依赖gcc a.c b.c -o app #注意这⾏最开始的缩进make以上这个Makefile后就会将⽬录下的a.c与b.c编译为⽬标⽂件app。

Makefile的⼯作原理Makefile中的命令在执⾏前，会检查是否存在所需的依赖⽂件如果存在：执⾏命令如果不存在：向下检查其他规则，是否存在其他规则⽣成当前规则所需要的依赖，如果有，则执⾏该规则中的命令。

例如：#Makefileapp: a.o b.ogcc a.o b.o -o appa.o: a.cgcc -c a.c -o a.ob.o: b.cgcc -c b.c -o b.o在上⽅这个Makefile中，当执⾏到app规则时，会发现所需的依赖⽂件a.o与b.o都不存在于当前⽬录，所以会向下寻找是否有其他规则⽣成此⽂件，当寻找到a.o规则时，发现其是所需的⽂件，就执⾏gcc -c a.c -o a.o，b.o同理。

Linux系统Makefile编写与GCC编译实验报告

实验报告实验题目Linux系统Makefile编写与GCC编译实验姓名：学号：课程名称：所在学院：专业班级：任课教师：四、实验过程、步骤及内容（一）GCC编译1、准备环境2、建立相关目录$ cd workdir/linux/application$ mkdir 6-gcc3、将代码从共享目录拷入虚拟机L inux 操作系统下；（可使用【crtl+空格】切换输入法）$ cp /mnt/hgfs/share/实验代码/03.\ Linux 系统GCC 编译器的使用实验/实验代码/* 6-gcc/ -a$ cd 6-gcc/4、编译代码$ arm-none-linux-gnueabi-gcc helloworld.c -o hello$ mkdir /source/rootfs/app$ cp hello /source/rootfs/app/5、执行代码通过tftp 下载内核，nfs 挂载文件系统，启动开发板。

在开发板串口终端执行应用程序。

# cd /app# ./hello6、相关代码：#include <stdio.h>int main (int argc,char **argv){printf("hello,world!\n");return 0;}（二）Makefile编程1、环境准备2、建立相关目录$ cd workdir/linux/application$ mkdir 7-Makefile3、将代码从共享目录拷入虚拟机L inux 操作系统下；（可使用【crtl+空格】切换输入法）$ cp /mnt/hgfs/share/实验代码/05.\ Linux 系统Makefile 编写实验/实验代码/5.2/makefileTest/* 7-Makefile/ -a$ cd 7-Makefile/4、执行代码进入makefileTest 目录，执行make。

$ make CLEAN$ make会出现如下信息：5、在开发板上执行通过tftp下载内核，nfs挂载文件系统，启动开发板6、相关代码：CC = arm-none-linux-gnueabi-gcc SUBDIRS = f1 \f2 \main \objOBJS = f1.o f2.o main.oBIN = myappOBJS_DIR = objBIN_DIR = binexport CC OBJS BIN OBJS_DIR BIN_DIRall : CHECK_DIR $(SUBDIRS)cp bin/myapp /source/rootfs/app CHECK_DIR :mkdir -p $(BIN_DIR) $(SUBDIRS) : ECHOmake -C $@ECHO:@echo $(SUBDIRS)@echo begin compileCLEAN :@$(RM) $(OBJS_DIR)/*.o@rm -rf $(BIN_DIR)五、实验数据（现象）处理分析实验现象如下：（一）GCC编译（二）Makefile编程。

Makefile之Linux内核模块的Makefile写法分析

前些天写一个驱动模块。

竟然写内核模块
Makefile
时出了问题，于是将其总结下来，下次再用
时拿过来改下就行了。

#General Purpose Makefile for Linux Kernel module by guoqingbo
KERN_DIR = /home/gqb/development/linux-kernel-2.6.37
#KERN_DIR = /usr/src/$(shell uname -r)
#KERN_DIR = /lib/modules/$(shell uname -r)/build
all:
make -C $(KERN_DIR) M=$(shell pwd) modules
clean:
make -C $(KERN_DIR) M=$(shell pwd) modules clean
rm -rf modules.order
obj-m += xxx.o
第3行KERN_DIR表示内核源码目录，这种方式适用于嵌入式开发的交叉编译，KERN_DIR目录中包含了内核驱动模块所需要的各种头文件及依赖。

若在PC机开发内核模块则应使用第4、5行的写法。

第8行中-C表示指定进入指定的目录即KERN_DIR，是内核源代码目录，调用该目录顶层下的Makefile,目标为modules。

M=$(shell pwd)选项让该Makefile在构造modules目标之前返回到模块源代码目录并在当前目录生成obj-m指定的xxx.o目标模块。

clean这个目标表示将模块清理掉
obj-m += xxx.o即指定当前目录要生成的目标模块，然后modules目标指向obj-m变量中设定的模块。

通用而且简洁的Makefile_华清远见

通用而且简洁的Makefile如果你想学习这个通用而且简洁的Makefile，请往下看。

一个工程中的源文件不计其数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为 makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

make是一个命令工具，它解释Makefile 中的指令(应该说是规则)。

在Makefile文件中描述了整个工程所有文件的编译顺序、编译规则。

Makefile 有自己的书写格式、关键字、函数。

像C 语言有自己的格式、关键字和函数一样。

而且在Makefile 中可以使用系统shell所提供的任何命令来完成想要的工作。

Makefile(在其它的系统上可能是另外的文件名)在绝大多数的IDE 开发环境中都在使用，已经成为一种工程的编译方法。

我们在Linux环境下开发程序，少不了要自己编写Makefile，一个稍微大一些的工程下面都会包含很多.c 的源文件。

如果我们用gcc去一个一个编译每一个源文件的话，效率会低很多，但是如果我们可以写一个Makefile，那么只需要执行一个make就OK了，这样大大提高了开发效率。

但是Makefile的语法规则众多，而且缺乏参考资料，对于初学者来说，写起来还是有一定的难度，往往令很多人望而生畏。

下面我们介绍一个比较通用而且简洁的Makefile，大家只要对它稍作修改就可以用在你们自己的工程里了。

现在假设我们有一个工程叫my_project，工程源码目录下面有app1.c，app2.c，app3.c以及main.c这五个源文件。

我们现在需要编译出app1.o,app2.o,app3.o以及main.o，然后再把这些.o文件链接成为一个ELF格式的可执行程序叫做my_app。

我们先看一个最简单的Makefile如何编写：my_app : main.o, app1.o, app2.o, app3.o, app4.ogcc –o my_app main.o app1.o, app2.o, app3.o, app4.omain.o : main.cgcc –c main.capp1.o : app1.cgcc –c app1.capp2.o : app2.cgcc –c app2.capp3.o : app3.cgcc –c app3.cclean :rm main.o app1.o, app2.o, app3.o, app4.o这是一个非常简单的Makefile，不灵活，而且不具备可复制性，想象一个如果我们的工程下面有50个源文件，那岂不是要一个一个写出来。

linux makefile include用法

在 Linux 中，Makefile 是一种文本文件，用于定义项目的构建规则和依赖关系。

include是 Makefile 中的一个关键字，用于引入其他 Makefile 文件。

这对于将构建规则拆分为多个文件以提高可维护性非常有用。

以下是关于include在 Linux Makefile 中的用法的详细解释：include的基本语法：•include后面可以跟一个或多个文件名，用空格分隔。

•这些文件名可以包含通配符，例如*.mk。

示例：假设有两个 Makefile 文件，分别是main.mk和extra.mk。

main.mkextra.mk在上述例子中，main.mk包含了extra.mk。

这样，main.mk中的规则就可以使用extra.mk中定义的规则和变量。

使用场景和注意事项：1.模块化项目：–include用于将项目的不同部分拆分为独立的 Makefile，使得项目结构更加清晰和易于维护。

2.变量和规则共享：–通过include，可以在不同的 Makefile 文件中共享变量和规则，避免代码重复。

3.条件包含：–可以根据条件来选择是否包含某个 Makefile，例如基于不同的操作系统或构建类型。

1.文件名通配符：–include后面可以使用通配符，方便引入符合某个模式的多个文件。

注意事项：•文件名可以是相对路径或绝对路径。

•文件名中可以包含变量，这样可以动态地选择引入的文件。

•在引入文件时，Makefile 会在当前目录和系统的默认搜索路径中查找文件。

通过合理使用include，可以更好地组织和管理项目的构建规则，提高 Makefile 的可读性和可维护性。

linux2.6内核Makefile详解

linux2.6内核Makefile详解熟悉内核的Makefile对开发设备驱动、理解内核代码结构都是非常重要的linux2.6内核Makefile的许多特性和 2.4内核差别很大，在内核目录的documention/kbuild/makefiles.txt中有详细的说明。

给大家一个中文版的翻译=== 目录=== 1 概述=== 2 用户与作用=== 3 Kbuild文件--- 3.1 目标定义--- 3.2 编译进内核- obj-y--- 3.3 编译可装载模块- obj-m--- 3.4 输出的符号--- 3.5 目标库文件- lib-y--- 3.6 递归躺下访问目录--- 3.7 编辑标志--- 3.8 命令行的依赖关系(原文中没有写:-))--- 3.9 跟踪依赖--- 3.10 特殊规则--- 3.11 $(CC) 支持的函数=== 4 本机程序支持--- 4.1 简单的本机程序--- 4.2 复合的本机程序--- 4.3 定义共享库--- 4.4 使用用C++编写的本机程序--- 4.5 控制本机程序的编译选项--- 4.6 编译主机程序时--- 4.7 使用hostprogs-$(CONFIG_FOO)=== 5 Kbuild清理=== 6 架构Makefile--- 6.1 调整针对某一具体架构生成的镜像--- 6.2 将所需文件加到archprepare 中--- 6.3 递归下向时要访问的目录列表--- 6.4 具体架构的启动镜像--- 6.5 构造非Kbuild目标--- 6.6 构建启动镜像的命令--- 6.7 Kbuild自定义命令--- 6.8 联接器预处理脚本=== 7 Kbuild 变量=== 8 Makefile语言=== 9 关于作者=== 10 TODO=== 1 概述Linux内核的Makefile分为5个部分：Makefile 顶层Makefile.config 内核配置文件arch/$(ARCH)/Makefile 具体架构的Makefilescripts/Makefile.* 通用的规则等。

Linux关于Makefile的用法介绍

Linux关于Makefile的用法介绍对于GNU Make或许很多Windows开发的程序员并不是很了解，因为Windows中的很多集成开发环境（IDE）都帮我们做了这件事。

但是作为一个专业从事Linux 嵌入式开发的程序员就必须要了解GNU Make，会不会使用GNU Make从一定角度上反应了一个人是否具备大型工程能力。

本文主要围绕Make命令展开，介绍Linux下Make的使用以及Makefile的语法和使用Make进行源码安装。

一、什么是GNU MakeGNU Make是一个控制从程序的源文件中生成程序的可执行文件和其他非源文件的工具。

Make可以从一个名为Makefile的文件中获得如何构建程序的知识，该文件列出了每个非源文件以及如何从其他文件计算它。

当你编写一个程序时，你应该为它编写一个Makefile 文件，这样就可以使用Make来编译和安装这个程序。

二、如何获取MakeMake可以在GNU的主要FTP服务器上找到：http ：//ftp.gnu/gnu/make/ （通过HTTP）和ftp://ftp.gnu/gnu/make/ （通过FTP）。

它也可以在GNU镜像列表上找到; 请尽可能GNU的镜像列表。

三、为什么需要Make任何一种技能或知识都是源之于某种社会需求，那为什么要用Make 呢？当项目源文件很少的时候，我们也许还可以手动使用gcc命令来进行编译，但是当项目发展到一个庞大的规模时，再手动敲gcc命令去编译就变得不可能的事情。

所以呢，在这样的历史背景下，就出现了一位大牛（斯图亚特·费尔德曼），在1977年贝尔实验室制作了这样一个软件，它的名字就叫做Make。

所以实际开发中，我们在编译大型项目的时候往往会使用Make进行编译，为此我们还需要了解Make软件所依赖的Makefile规则文件。

四、MakefileMakefile 文件需要按照某种语法进行编写，文件中需要说明如何编译各个源文件并连接生成可执行文件，并要求定义源文件之间的依赖关系。

linux系统中make的用法

linux系统中make的用法make是一个常用的Linux命令，用于自动化编译程序。

当有多个源文件需要编译成可执行文件时，手动一个个编译比较麻烦。

这时候，我们就可以使用make命令实现自动化编译。

make命令的基本用法为：在Makefile文件中定义编译规则和依赖关系，然后运行make命令即可自动编译程序。

Makefile是一个文本文件，可以使用vi、nano等编辑器创建和编辑。

make命令的常用参数如下：* -f 指定Makefile文件，默认为当前目录下的Makefile或makefile文件。

* -n 或 --just-print 只打印命令，而不实际执行。

* -j 指定同时执行的任务数，加快编译速度。

* clean 清除中间文件和可执行文件等生成的文件。

Makefile文件中的基本语法为：```target: prerequisitescommand```其中，target为编译目标，prerequisites为编译目标所依赖的文件，command为执行编译的命令。

例如：```hello: hello.cgcc -o hello hello.c```这个Makefile文件中定义了一个名为“hello”的编译目标，它依赖于名为“hello.c”的源文件，执行命令为“gcc -o hellohello.c”，即将hello.c编译成可执行文件hello。

使用make命令进行编译时，可以直接运行“make”（默认编译第一个目标），也可以指定要编译的目标，例如“make hello”。

当定义的目标有多个依赖时，可以使用“$^”表示所有依赖文件，“$@”表示目标文件。

例如：```main.exe: main.c module1.o module2.ogcc -o $@ $^```这个Makefile文件中定义了一个名为“main.exe”的编译目标，它依赖于名为“main.c”、“module1.o”、“module2.o”的文件，执行命令为“gcc -o $@ $^”，即将这三个文件编译成可执行文件main.exe。

linux下Makefile文件的编写-红联Linux门户-中国领先的Linux技...

linux下Makefile文件的编写-红联Linux门户-中国领先的Linux技...linux下Makefile文件的编写victorywylbc发布于 2009-7-30 | 951次阅读字号: 大中小 (网友评论7条) 我要评论开始使用Linux编程时，一个很讨厌的问题就是如何写Makefile 文件，由于在Linux下不像在Windows下那么熟悉，有那么多好的软件（也许是对Linux孤陋寡闻了）。

虽然象Kylix和Anjuta这样的集成编译环境，但是Kylix太大太慢，用它编写console程序不亚于高射炮打蚊子——大材小用，而Anjuta又太不稳定，况且字体有那么难看。

不说了，还是言归正传，看看Makefile该如何编写。

1. 简单的GCC语法：如果你只有一个文件（或者只有几个文件），那么就可以不写Makefile文件（当然有Makefile更加方便），用gcc直接编译就行了。

在这里我们只介绍几个我经常用的几个参数，第一是“-o”，它后面的参数表示要输出的目标文件，再一个是“-c”，表示仅编译（Compile），不连接（Make），如果没有”-c”参数，那么就表示连接，如下面的几个命令：gcc –c test.c，表示只编译test.c文件，成功时输出目标文件test.ogcc –c test.c –o test.o ，与上一条命令完全相同gcc –o test test.o，将test.o连接成可执行的二进制文件testgcc –o test test.c，将test.c编译并连接成可执行的二进制文件testgcc test.c –o test，与上一条命令相同gcc –c test1.c，只编译test1.c，成功时输出目标文件test1.ogcc –c test2.c，只编译test2.c，成功时输出目标文件test2.ogcc –o test test1.o test2.o，将test1.o和test2.o连接为可执行的二进制文件testgcc –c test test1.c test2.c，将test1.o和test2.o编译并连接为可执行的二进制文件test注：如果你想编译cpp文件，那么请用g++，否则会有类似如下莫名其妙的错误：cc3r3i2U.o(.eh_frame+0x12): undefined reference to`__gxx_personality_v0’......还有一个参数是”-l”参数，与之紧紧相连的是表示连接时所要的链接库，比如多线程，如果你使用了pthread_create函数，那么你就应该在编译语句的最后加上”-lpthread”，”-l”表示连接，”pthread”表示要连接的库，注意他们在这里要连在一起写，还有比如你使用了光标库curses，那么呢就应该在后面加上”-lcurses”，比如下面的写法：gcc –o test test1.o test2.o –lpthread –lcurses当然gcc的参数我感觉有几百个，不过我们平时在x86机器上用的就这么些，况且这里也不是GCC教程，所以，就此打住。

linux内核模块编译makefile

linux内核模块编译makefilelinux内核可加载模块的makefile在开发linux内核驱动时，免不了要接触到makefile的编写和修改，尽管⽹上的makefile模板⼀⼤堆，做⼀些简单的修改就能⽤到⾃⼰的项⽬上，但是，对于这些基础的东西，更应该做到知其然并知其所以然。

本篇⽂章中只讨论linux内核模块编译的makefile，linux内核makefile总览可以参考另⼀篇博客：本篇博客参考。

linux内核使⽤的是kbuild编译系统，在编译可加载模块时，其makefile的风格和常⽤的编译C程序的makefile有所不同，尽管如此，makefile 的作⽤总归是给编译器提供编译信息。

最简单的makefile我们先来看看⼀个最简单的makefile是怎样的：obj-m+=hello.oall:make -C /lib/modules/$(shell uname -r)/build/ M=$(PWD) modulesclean:make -C /lib/modules/$(shell uname -r)/build/ M=$(PWD) clean这个makefile的作⽤就是编译hello.c⽂件，最终⽣成hello.ko⽂件。

obj-m+=hello.oobj-m表⽰编译⽣成可加载模块。

相对应的，obj-y表⽰直接将模块编译进内核。

可以看到，这⾥并没有输⼊hello.c源⽂件，熟悉makefile的⼈应该知道，这得益于makefile的⾃动推导功能，需要编译⽣成filename.o⽂件⽽没有显⽰地指定filename.c⽂件位置时，make查找filename.c是否存在，如果存在就正常编译，如果不存在，则报错。

obj-m+=hello.o，这条语句就是显式地将hello.o编译成hello.ko,⽽hello.o则由make的⾃动推导功能编译hello.c⽂件⽣成。

all，cleanall，clean这⼀类的是makefile中的伪⽬标，伪⽬标并不是⼀个真正的编译⽬标，它代表着⼀系列你想要执⾏的命令集合，通常⼀个makefile 会对应多个操作，例如编译，清除编译结果，安装，就可以使⽤这些伪⽬标来进⾏标记。

linux下makefile的执行顺序

linux下makefile的执行顺序linux下makefile的执行顺序Gnu make的执行过程分为两个阶段第一阶段：读取所有的makefile文件（包括“MAKEFILES”变量指定的、指示符“include”指定的、以及命令行选项“-f（--file）”指定的makefile文件），内建的变量、明确规则和隐含规则，并建立所有目标和依赖之间的依赖关系结构链表。

段：根据第一阶段已经建立的依赖关系结构链表决定哪些目标需要更新，并使用对应的第二阶段：规则来重建这些目标。

make的执行过程如下：1. 依次读取变量“MAKEFILES”定义的makefile文件列表2. 读取工作目录下的makefile文件（缺省的是根据命名的查找顺序“GNUmakefile”，“makefile”，“Makefile”，首先找到那个就读取那个）3. 依次读取工作目录makefile文件中使用指示符“include”包含的文件4. 查找重建所有已读取的makefile文件的规则（如果存在一个目标是当前读取的某一个makefile 文件，则执行此规则重建此makefile文件，完成以后从第一步开始重新执行）5. 初始化变量值并展开那些需要立即展开的变量和函数并根据预设条件确定执行分支6. 根据“终极目标”以及其他目标的依赖关系建立依赖关系链表7. 执行除“终极目标”以外的所有的目标的规则（规则中如果依赖文件中任一个文件的时间戳比目标文件新，则使用规则所定义的命令重建目标文件）8. 执行“终极目标”所在的规则（1）依次读取变量“MAKEFILES”定义的makefile文件列表在当前环境中查看一下有没有定义“MAKEFILES”这个环境变量，如果环境变量MAKEFILES被定义了，那么make会在读取其它makefile之前，先读取MAKEFILE定义的列表中的名字（由空格分隔）。

建议大家不要去定义这个环境变量，因为我们并不太了解这个变量的使用，那么经常会造成一些奇怪的错误。