Linux如何写makefile文件

合集下载

交叉编译makefile编写

交叉编译makefile编写

交叉编译makefile编写交叉编译Makefile编写在软件开发中,我们通常会遇到需要在不同平台上编译程序的情况。

当我们需要在一台主机上编译运行另一种架构的程序时,就需要进行交叉编译。

而Makefile作为一种构建工具,可以帮助我们自动化编译过程,提高开发效率。

本文将介绍如何编写适用于交叉编译的Makefile,以实现在不同平台上的程序构建。

一、了解交叉编译概念交叉编译是指在一台主机上编译生成另一种架构的可执行文件。

通常情况下,我们在本机上编写并编译程序,然后在本机上运行。

但是,当我们需要在不同的平台上运行程序时,由于不同平台的指令集、库文件等差异,我们就需要使用交叉编译来生成适用于目标平台的可执行文件。

二、Makefile的基本结构Makefile是一种用于描述程序构建过程的文件,它包含了一系列规则(rules),每个规则由一个或多个目标(target)和依赖项(dependencies)组成。

当某个目标的依赖项发生变化时,Make工具会根据规则自动更新目标文件。

一个基本的Makefile结构如下所示:```target: dependenciescommand```其中,target表示目标文件,dependencies表示目标文件的依赖项,command表示生成目标文件的命令。

三、交叉编译的Makefile编写在编写交叉编译的Makefile之前,我们需要了解目标平台的相关信息,如架构、编译器、库文件等。

以ARM架构为例,我们可以使用arm-linux-gnueabi-gcc作为交叉编译器。

我们需要定义一些变量,用于指定交叉编译工具链和相关参数:```CC = arm-linux-gnueabi-gccCFLAGS = -Wall -O2```其中,CC表示编译器,CFLAGS表示编译参数。

接下来,我们可以定义目标文件和依赖项:```TARGET = myprogramSRCS = main.c foo.c bar.cOBJS = $(SRCS:.c=.o)```其中,TARGET表示目标文件,SRCS表示源文件列表,OBJS表示目标文件列表。

linux makefile中路径写法

linux makefile中路径写法

linux makefile中路径写法================Makefile在Linux系统中被广泛用于编译和构建项目,它能够自动化地完成许多重复的任务,大大提高了开发效率。

在Makefile中,路径的书写是一个重要的组成部分。

下面我们将详细讨论在Linux Makefile中如何正确地书写路径。

一、绝对路径与相对路径-----------在Makefile中,路径的书写主要有两种方式:绝对路径和相对路径。

1. **绝对路径**:从文件系统的根目录开始的路径。

例如`/home/user/myfile.txt`就是一个绝对路径。

在Makefile中,绝对路径通常是从构建系统的根目录开始的。

2. **相对路径**:相对于当前工作目录的路径。

在Makefile 中,通常使用`./`表示当前目录,`../`表示上级目录。

选择使用绝对路径还是相对路径取决于你的项目结构和开发者的偏好。

一般来说,推荐使用相对路径,因为它们更灵活,可以适应不同的项目目录结构。

二、路径书写规范--------在Makefile中书写路径时,有一些规范和最佳实践需要遵循:1. **文件名**:文件名应该简洁明了,不要使用空格或其他特殊字符。

避免使用长文件名或难以理解的文件名。

2. **目录分隔符**:在Linux系统中,路径的分隔符是反斜杠(`\`)。

当路径包含多个目录时,需要使用两个反斜杠(`\\` 或`/`)。

在Makefile中,推荐使用正斜杠(`/`),因为它在所有平台上都是通用的。

3. **自动更新**:在Makefile中,可以使用`$(wildcard)`函数来匹配目录中的文件。

例如,`$(wildcard source/*.c)`将匹配source目录下的所有C源文件。

4. **构建系统根目录**:在Makefile中,通常使用构建系统的根目录作为路径的起点。

这可以通过变量来实现,例如`ROOT :=/path/to/build`。

Linux之make的用法讲解

Linux之make的用法讲解

Linux之make的⽤法讲解在 Linux环境下使⽤ GNU 的 make⼯具能够⽐较容易的构建⼀个属于你⾃⼰的⼯程,整个⼯程的编译只需要⼀个命令就可以完成编译、连接以⾄于最后的执⾏。

不过这需要我们投⼊⼀些时间去完成⼀个或者多个称之为 Makefile ⽂件的编写。

此⽂件正是 make 正常⼯作的基础。

make 是⼀个命令⼯具,它解释 Makefile 中的指令(应该说是规则)。

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

准备知识:编译,链接,静态库,共享库编译:把⾼级语⾔所书写的代码转换成机器可识别的指令,此时还不能够被执⾏,编译器通过检查⾼级语⾔的语法,函数和变量的声明是否正确!如果正确则产⽣中间⽬标⽂件(⽬标⽂件在Liunx中默认后缀为“.o”)链接:将多.o ⽂件,或者.o ⽂件和库⽂件链接成为可被操作系统执⾏的可执⾏程序静态库:⼜称为⽂档⽂件(Archive File)。

它是多个.o⽂件的集合。

Linux中静态库⽂件的后缀为“.a”共享库:也是多个.o ⽂件的集合,但是这些.o ⽂件时有编译器按照⼀种特殊的⽅式⽣成(共享库已经具备了可执⾏条件)在执⾏ make 之前,需要⼀个命名为 Makefile 的特殊⽂件(本⽂的后续将使⽤Makefile 作为这个特殊⽂件的⽂件名)来告诉 make 需要做什么(完成什么任务),该怎么做。

当使⽤make ⼯具进⾏编译时,⼯程中以下⼏种⽂件在执⾏make 时将会被编译(重新编译):1.所有的源⽂件没有被编译过,则对各个 C 源⽂件进⾏编译并进⾏链接,⽣成最后的可执⾏程序;2.每⼀个在上次执⾏ make 之后修改过的 C 源代码⽂件在本次执⾏make 时将会被重新编译;3.头⽂件在上⼀次执⾏make 之后被修改。

则所有包含此头⽂件的 C 源⽂件在本次执make 时将会被重新编译。

Makefile规则介绍⼀个简单的 Makefile 描述规则组成:TARGET... : PREREQUISITES...COMMAND......target:规则的⽬标。

linux vscode 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 中的命令和目标。

makefile编译流程

makefile编译流程

makefile编译流程Makefile是一种用于自动化编译的工具,它可以根据源代码文件的依赖关系自动编译出目标文件。

Makefile的编写需要遵循一定的规则和语法,下面将介绍Makefile的编译流程。

1. 编写Makefile文件Makefile文件是一个文本文件,其中包含了编译的规则和依赖关系。

在编写Makefile文件时,需要遵循一定的语法规则,如使用TAB键缩进、使用变量和函数等。

2. 执行make命令在Makefile文件所在的目录下执行make命令,make会自动读取Makefile文件,并根据其中的规则和依赖关系进行编译。

如果Makefile文件中没有指定目标,则默认编译第一个目标。

3. 分析依赖关系在执行make命令时,make会先分析Makefile文件中的依赖关系,确定哪些文件需要重新编译。

如果某个源文件被修改了,那么与之相关的目标文件也需要重新编译。

4. 编译源文件在确定需要重新编译的文件后,make会依次编译每个源文件,生成对应的目标文件。

编译过程中,make会根据Makefile文件中的规则和命令进行编译。

5. 链接目标文件在所有的源文件都编译完成后,make会将所有的目标文件链接起来,生成最终的可执行文件。

链接过程中,make会根据Makefile文件中的规则和命令进行链接。

6. 完成编译当所有的源文件都编译完成并链接成功后,make会输出编译成功的信息,并生成最终的可执行文件。

如果编译过程中出现错误,make会输出错误信息并停止编译。

总之,Makefile编译流程是一个自动化的过程,它可以大大提高编译的效率和准确性。

在编写Makefile文件时,需要注意语法规则和依赖关系,以确保编译过程的正确性。

makefile基本使用方法

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下C语言多文件的编译以及makefile的应用

Linux下C语言多文件的编译以及makefile的应用

Linux下C语⾔多⽂件的编译以及makefile的应⽤1.关于编译和链接⼀般来说,⽆论是C、C++,⾸先要把源⽂件编译成中间代码⽂件,在Windows下也就是.obj⽂件,UNIX下是.o⽂件,即Object File,这个动作叫做编译(compile)。

然后再把⼤量的Object File合成执⾏⽂件,这个动作叫作链接(link)。

也就是源⽂件(.c ⽂件或者.cpp⽂件)⾸先会⽣成中间⽬标⽂件,再由中间⽬标⽂件⽣成执⾏⽂件。

在编译时,编译器只检测程序语法,和函数、变量是否被声明。

如果函数未被声明,编译器会给出⼀个警告,但可以⽣成Object File。

⽽在链接程序时,链接器会在所有的Object File中找寻函数的实现,如果找不到,那到就会报链接错误码(Linker Error)。

2.使⽤命令编译链接 如果使⽤命令编译,过程⽐较⿇烦。

假如我有三个.h的头⽂件和四个.c的代码⽂件。

⾸先将这七个⽂件放到⼀个⽂件夹⾥(这⾥只介绍简单应⽤,所以放在⼀个⽂件夹,以后慢慢填坑)如下图。

接下来打开终端,并转到这个⽂件夹。

然后在终端输⼊gcc -c main.cgcc -c AAA.cgcc -c BBB.cgcc -c CCC.c 这样就把四个⽂件编译完成,查看⽂件会出现四个.o⽂件(下图) 接下来链接即可。

在终端输⼊gcc main.o AAA.o BBB.o CCC.o -o main 就可以⽣成可执⾏⽂件 main 这样执⾏ ./main即可。

整个执⾏过程如下:3.使⽤make编译链接虽然上述⽅式可以实现,但是只要修改⽂件就需要重新编译链接,特别⿇烦。

⽤makefile实现更为巧妙。

先放出⼀种写法,如果仅是为了执⾏⾃⼰的代码可以先看⼀下,后⾯的坑慢慢补。

objects = main.o AAA.o BBB.o CCC.occ = gccedit : $(objects)cc -o edit $(objects)main.o : main.cAAA.o : AAA.c AAA.hBBB.o : BBB.c BBB.hCCC.o : CCC.c CCC.h.PHONY : cleanclean :rm edit main.o AAA.o BBB.o CCC.o这样可以直接运⾏,我将刚才⽣成的编译链接⽂件删掉然后重新运⾏之后如果在make的时候出现makefile:3: *** missing separator:原因是丢失了tab键,每⼀条命令在执⾏的时候需要⼀个tab键。

linux下makefile文件中比较大小的语法

linux下makefile文件中比较大小的语法

linux下makefile文件中比较大小的语法在Linux下,Makefile是一种常用的构建工具,用于自动化编译和构建软件项目。

在Makefile中,我们经常需要比较文件的大小来判断是否需要重新编译或执行某些操作。

本文将介绍在Linux下Makefile 文件中比较大小的语法。

在Makefile中,我们可以使用shell命令来执行系统命令。

比较文件大小的常用命令是`stat`和`du`。

`stat`命令用于获取文件的详细信息,包括文件大小,而`du`命令用于计算文件或目录的大小。

首先,我们可以使用`stat`命令获取文件的大小,并将结果保存到一个变量中。

下面是一个示例:```file_size := $(shell stat -c %s file.txt)```上述命令将获取文件`file.txt`的大小,并将结果保存到变量`file_size`中。

`-c %s`选项用于指定输出文件大小的格式。

接下来,我们可以使用条件语句来比较文件大小。

常用的条件语句有`ifeq`和`ifneq`。

下面是一个示例:```ifeq ($(file_size), 0)@echo "文件为空"else@echo "文件大小为$(file_size)字节"endif```上述代码将判断文件大小是否为0,如果是,则输出"文件为空",否则输出"文件大小为$(file_size)字节"。

`@echo`命令用于输出信息,`$(file_size)`表示变量的值。

除了使用`stat`命令获取文件大小外,我们还可以使用`du`命令计算文件或目录的大小。

下面是一个示例:```file_size := $(shell du -b file.txt | cut -f1)```上述命令将使用`du`命令计算文件`file.txt`的大小,并使用`cut`命令提取文件大小。

简单制作Makefile方法

简单制作Makefile方法

1.在当前目录下创建一个名为hello的子目录。hello这个目录用于存放hello.c这个程序及相关文件。新建一个源程序文件hello.c
#include <stdio.h>
int main(int argc, char** argv)
{
printf("Welcome to use autoconf and automake\n");
通过以上步骤,在源代码所在目录下自动生成了Makefile文件。
configure.in文件
autoconf提用来产生"configure"文件的工具。"configure"是一个Shell脚本,它可以自动设定一些编译参数使程序能够在不同平台上进行编译。autoconf读取configure.in文件然后产生,"configure"这个Shell脚本。
如何使用产生的Makefile文件
执行configure脚本文件所产生的Makefile文件有几个预定的选项可供使用。
l make all:产生设定的目标,即生成所有的可执行文件。使用make也可以达到此目的。
l make clean:删除之前编译时生成的可执行文件及目标文件(形如*.o的中间文件)。
configure.in文件的内容是一系列GNU m4的宏,这些宏经autoconf理后会变成检查系统特性的Shell脚本。configure.in文件中宏的顺序并没有特别的规定,但是每一个configure.in文件必须以宏AC_INIT开头,以宏AC_OUTPUT结束。一般可先用autoscan这个工具扫描原始文件以产生一个configure.scan文件,再对configure.scan作些修改,从而生成configure.in文件

(完整版)浅谈手动书写Makefile与自动生成Makefile

(完整版)浅谈手动书写Makefile与自动生成Makefile

最近一直在搞Makefile文件的编辑,一直想通过自己的心得体会与广大网友分享。

Linux学习者只有参与的大多人当中去,才能体会到乐趣。

同时慢慢培养自己的学习linux的兴趣爱好。

与广大网上爱好者互动。

Linux的GNU计划:Linux下构建自己的开源软件使用的是linux下自己带的强大的工具。

Autoconf libtoolize 和automake .这是开源软件必须的基本工具。

如果使用了autoconf和automake,除了编译应用程序,用户并不需要有这些工具。

使用这些工具的目的是创建能在用户环境使用的、可移植的shell脚本和Makefile文件。

Autoconf实际上是一个工具集,其中包含aclocal、autoheader和autoconf等可执行文件。

这些工具生成一个可移植的shell脚本—configure,configure和软件包一起发布给用户。

它探查编译系统,生成Makefile文件和一个特殊的头文件config.h。

由configure生成的文件能适应用户系统的特定环境。

configure脚本从一个称为Makefile.in的模板文件生成每个Makefile文件。

而Makefile.in 有Makefile.am 生成。

Configure.in 有开发者自己手动修改。

Makefile.am 是由开发者自己手写。

Libtool软件包是第三个重要的GNU工具,它的作用是确定共享库在特定平台上的特性。

因为共享库在不同平台上可能会有所不同。

上述是自动生成Makefile的概括。

以后再细讲。

手动书写Makefile:手动书写顾名思义就是自己跳过configure.Scan configure.in configure Makefile.am Makefile.in 的生成过程。

直接书写Makefile 这种方式只能用于相对简单的源代码。

如有几个,几十个或者上百个源文件时,自己编写Makefile往往是可行的,但是如果我们所编写的源文件有几千,几万,几十万甚至更多时,显然手动书写Makefile不是个明智之举。

linux驱动编程初级+makefile

linux驱动编程初级+makefile

驱动编程1 模块的概述 (2)2 source insight 加载内核源码方法 (2)3 模块makefile的编写 (3)4 模块makefile编写方法 (4)5 在X86上运行模块: (5)6 编写模块 (5)7 模块的加载进内核命令 (5)8 最简单的上层调用+ 调用驱动方法 (6)9 复杂框架上层应用+驱动调用方法 (7)10 复杂框架字符设备创建并注册过程 (7)11 file_operations常用函数 (9)12 同步互斥操作 (10)13 同步互斥函数总结 (10)14 阻塞IO编程流程 (11)15 轮询操作上层select 下层poll (12)16 信号处理 (12)17 中断 (13)18 中断新模型--上半部中断和下半部中断的实现 (14)19 内核定时器编程 (15)20 内核延时函数 (15)21 内核源代码中头文件分配方式 (15)22 linux内核管理和内核的内存管理 (16)23 设备io端口和io内存访问–如何控制led的亮灭 (16)24 * 驱动-设备分离思想编程————内核进阶 (18)25 驱动-设备分离-核心最小架构 (18)26 驱动设备分离思想- 上层架构(基于封装) (20)27 头文件总结 (24)28 设置系统自启动命令u-boot (24)第一天需要理清的东西1)模块的概念,模块与应用的区别2)模块主要的组成头文件、module_init() modoule_exit() module_lisence()3)模块的如何编辑,如何编译,如何加载到内核中运行使用makefile4)模块驱动编写,必须通过上层应用程序调用。

1模块的概述模块是内核的一部分,为了防止内核太大,把它放在文件系统里面。

也可以在编译内核的直接编译进内核。

1,存储位置可以在开始时编译进内核,也可以编译进模块,最后加载2、运行时环境在哪个内核树下编译,就对应这个运行环境3、模块的编译问题:前提条件是需要对应的内核源码树,或者必须有对应的内核版本匹配4、模块编译使用makefile 注意makefile的编写2source insight 加载内核源码方法在windows下创建工程,使用source insight查看内核代码:2.1 先将内核源码拷到对应的文件夹2.2 在source insight 里添加工程,筛选需要添加的文件注意选择按照树来添加,然后按照remove来踢出不需要的文件夹2.3 最后同步3模块makefile的编写模块的编译:1)、模块编译的核心语句:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules-C :进入内核源码树M= : 返回到当前目录,再次执行该目录下的makefileeg: /tnt/abc.c -----> abc.ko1、在/tnt目录下敲make,只有/tnt目录下的Makefile被调用2、目的是要进入到内核源码树中,一进一回,-C来进,M=带着内核源码树中的makefile的功能回来了-------内核源码树中Makefile的目标:obj-y:汇集了所有编译进内核的目标文件obj-m:汇集了所有编译成模块的目标文件3、回来过后,我们只有确定obj-m变量的集合4、make modules告诉内核的makefile,只做编译模块的功能4模块makefile编写方法ifeq ($(KERNELRELEASE),)KERNELDIR := /work/linux-2.6.35-farsightPWD := $(shell pwd)modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modulesinstall:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_installclean:rm -rf .tmp_versions *.ko *.o .*.cmd *.mod.c *.order *.symvers.PHONY: modules cleanelseobj-m := ex1.oendif以上是makefile的内容,●注意原来的内核目录树不要进行make clean 或者make distclean●KERNELDIR 表示模块加载在哪个内核的文件夹(又叫内核源码树),●$(MAKE) -C $(KERNELDIR) M=$(PWD) modules 表示进入该内核文件夹,将顶层makefile 中的内容带回,再重新执行一次该makefile 将obj-m := ex1.o 编译,并执行make modules (并只编译ex1.c ,不编译其它模块)●$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install 表示执行顶层makefile的modules install 标签下的命令●安装的位置原来默认在/lib 下面,所以需要修改其到我们制作的根文件系统下/work/rootfs/在顶层Makefile位置搜索:MODLIB修改为:●obj-m := ex1.o 你需要编译的.c的文件名****************************此时简单的编译环境已经搭建完毕******************* ****************************执行make ***********************************************执行make install *******************在/work/rootfs/lib/modules/2.6.35/extra即可找到该模块.ko*****************************************************************************搭建好环境,保证虚拟机与板子与计算机网络连通,并设置板子u-boot 从nfs挂载,启动内核,并成功通过nfs 加载rootfs,此时环境完毕,进入/work/rootfs/lib/modules/2.6.35/extra ,找到模块,加载卸装模块操纵5在X86上运行模块:修改Makefile中的内核源码树的目录X86下的内核源码树:/lib/modules/2.6.35-22-generic/build如果没有在控制台上交互,默认是看不到信息的,需要dmesg这个命令去查看6编写模块模块最小组成如下:●注意:module_init module_exit 必须放在末尾●注意:函数的原型返回值●头文件7模块的加载进内核命令insmodrmmodlsmod8最简单的上层调用+ 调用驱动方法8.1 首先在module_init(abc) abc函数中注册设备register_chrdev(注册设备号,上层可见的设备名,操作封装)该函数完成设备注册,在板子上用cat /proc/devices 便可以看见该设备8.2 完成fops 操作的封装●注意格式●必须在函数后面声明该结构体●头文件#include <linux/fs.h>8.3 查看到该字符设备后,创建设备节点,则上层通过设备字符名与该设备号绑定mknod /dev/hf_char c 245 0ls /dev/ 可以查看注册的所有设备节点8.4 此时上层应用的open(”hf_char”,O_RDWR),即可完成该设备的打开,即可以完成上层应用于下层驱动相关fops 的操作。

linux makefile include用法

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 的可读性和可维护性。

linux makefile basename函数

linux makefile basename函数

linux makefile basename函数摘要:1.Linux Makefile 简介2.Makefile 中的函数3.basename 函数的作用4.basename 函数的参数5.basename 函数的返回值6.basename 函数在Makefile 中的应用示例正文:Linux Makefile 是一个用于管理编译过程的文件,它可以根据源文件之间的依赖关系自动编译、链接和安装软件。

在Makefile 中,可以定义一些函数来简化重复的操作,提高自动化程度。

basename 函数就是其中一个常用的函数。

basename 函数是用来获取文件名的函数,它可以从给定的路径名中提取文件名部分。

该函数的定义和使用方式类似于shell 脚本中的basename 命令。

在Makefile 中,basename 函数可以方便地提取源文件名,以便进行后续操作。

basename 函数的语法如下:```basename(prefix, suffix)```其中,`prefix` 参数表示路径名的前缀部分,`suffix` 参数表示路径名的后缀部分。

函数返回值是去掉前缀和后缀后的文件名。

basename 函数的参数都是可选的。

如果不提供`prefix` 参数,那么默认前缀为空字符串;如果不提供`suffix` 参数,那么默认后缀为空字符串。

basename 函数的返回值是一个字符串,表示去掉前缀和后缀后的文件名。

如果源路径名中不包含前缀或后缀,那么返回值将与源路径名相同。

下面举一个basename 函数在Makefile 中的应用示例。

假设我们有一个源文件`main.c`,我们想要提取文件名并生成一个名为`main` 的目标文件。

我们可以这样写Makefile:```all: mainmain: main.ct$(CC) $(CFLAGS) -o $@ $<.PHONY: cleanclean:trm -f main```在这个例子中,我们使用了`$(CC) $(CFLAGS) -o $@ $<` 命令来编译源文件。

Linux下makefile多文件编译

Linux下makefile多文件编译
实验步骤:
1.用mkdir指令新建一个mian目录
2.用cd指令进入main目录
3.用gedit指令分别建立main.c,sum.c,sum.h文件,并在main.c,sum.c,sum.h文件中编写程序。
4.用gedit指令建立一个makefile文件,并将以下代码写入文件中
object=main.o sum.o
实 验 报 告
【2017-2018学年第5学期】
【基本信息】
【开课部门】
【实验课程】
物联网网技术
【设课形式】
独立非独立□
【实验项目】
Linux下makefile多文件编译
【项目类型】
基础综合□ 设计□
研究创新□ 其它□
【项目学时】
5
【学生姓名】
【学 号】
【专 业】
【班 级】
【同组学生】
【实验室名】
【实验日期】
12.9
【教师对报告的最终评价及处理意见】
成绩(百分制):(涂改无效)
教师:年 月 日
【实验报告】
实验目的:
1.掌握makefile的撰写
2.掌握多文件的编译
3.掌握Linux gcc、ld的作用
4.完成C语言,main.c, sum.c sum.h三个文件;实现给定两个整数的加法运算,sum.c里封装加法函数,在main.c中完成调用。
main:$(object)
<tab>gcc -o main $(object)
main.o:main.c
<tab>gcc -c main.c
sum.o:sum.c sum.h
<tab>gcc -c sum.c
clean:

跟我一起写Makefile(Linux)

跟我一起写Makefile(Linux)

跟我⼀起写Makefile(Linux)
1、昨天在 Linux 下⽤ touch 指令新建了⼀个 hello.c 并且使⽤ vim 编辑器写了代码,使⽤ gcc 指令编译最后运⾏成功了。

具体⽅式如下:
在Linux 根⽬录/ 下 root ⽂件下新建⼀个 learngit ⽂件夹(mkdir 指令),使⽤touch 指令创建⽂件 hello.c,使⽤vim 打开并编写以下代码
#include <stdio.h>
void main()
{
printf("Hello World\n");
}
接着使⽤指令: gcc hello.c,会发现在 learngit ⽂件下⽣成了 a.out ⽂件
接着使⽤ ./a.out 会发现会输出"Hello World",这⾥查了⼀下./ 表⽰当前⽬录,../表⽰上⼀⽬录。

2017年2⽉23⽇16:43:14。

# 根据Makefile 的过程1。

应该第⼀步:在所在的hello.c ⽂件路径下,新建⼀个⽂件名字为 Makefile”或“makefile”的⽂件。

# 根据Makefile 的过程2、3。

应该第⼆步:⽤ vim 打开 Makefile⽂件,第⼀⾏写代码 edit : hello.o
注意在 Makefile中不能随便出现 table,因为table代表接下来的信息是命令,命令⾏会被识别成红⾊如下截图!(注意截图中红⾊字体前⾯有⼀个 table 长度为4)
2017年2⽉25⽇18:42:42。

makefile 条件编译

makefile 条件编译

makefile 条件编译MakefileUnix/Linux译系统编写程序所必需的文件,其中包含了定义规则以及编译程序所必需的指令。

通常情况下,一个规则描述了从一个或多个源文件到一个或多个目标文件之间的变换过程。

在特定的编译环境中,定义的规则必须能够生成所有需要的目标文件及时准确的。

有时候,一个源文件或多个源文件具有不同的编译条件,此时Makefile件编译的技术就派上用场了。

这种技术可以根据指定的编译条件自动生成 Makefile则,使得编译器只有在满足编译条件时才会编译特定的源文件。

Makefile件编译基本依赖于 make令,它可以根据给定的源文件及编译条件,自动生成 Makefile则。

Make令使用 C言编写,可以从一个或多个文本文件中读取输入,比如源文件,然后根据相应的编译条件,使用 if句来生成 Makefile则。

要想理解 Makefile件编译,首先必须明白 Makefile几个基本概念。

Makefile 中有若干规则,每个规则由一个目标文件,一个或多个依赖文件,以及一系列的命令组成。

它们通常以三个元素表示: target: dependenciestcommands其中,target 代表目标文件,dependencies该目标文件的依赖文件,commands该目标文件生成所需的命令。

为了利用 Makefile件编译,可以将每个文件的编译条件定义为一个 Makefile量,这样 Make编译文件时就可以根据指定的编译条件来生成 Makefile则。

例如,对于两个源文件 A B,A编译条件为BUILD_A,B编译条件为 BUILD_B,只有当 BUILD_A 为真,A会被编译,当 BUILD_B 为真,B会被编译。

要实现 Makefile件编译,可以使用 Make 中的 if件语句:ifeq (BUILD_A,1)A: ../A.cpptg++ -o A ../A.cppendififeq (BUILD_B,1)B: ../B.cpptg++ -o B ../B.cppendif上面的 Makefile 中,对于 A B两个源文件,它们的编译条件分别是 BUILD_A BUILD_B,即 BUILD_A 为真时,A会被编译,BUILD_B 为真时,B会被编译。

Linux学习笔记——例说makefile头文件查找路径

Linux学习笔记——例说makefile头文件查找路径

Linux学习笔记——例说makefile头⽂件查找路径0.前⾔从学习C语⾔開始就慢慢開始接触makefile,查阅了⾮常多的makefile的资料但总感觉没有真正掌握makefile,假设⾃⼰动⼿写⼀个makefile总认为⾮常吃⼒。

所以特意借助博客总结makefile的相关知识,通过样例说明makefile的详细使⽤⽅法。

例说makefile分为下⾯⼏个部分,很多其它内容请參考【】1.仅仅有单个C⽂件2.含有多个C⽂件3.须要包含头⽂件路径4.添加宏定义5.添加系统共享库6.添加⾃⼰定义共享库7.⼀个实际的样例【代码仓库】——代码仓库位于bitbucket,可借助TortoiseHg(GUI⼯具)克隆代码或者在⽹页中直接下载zip包。

1.三个C⽂件和三个头⽂件此处的样例略微复杂些但更接近实际情况。

⽂件结果例如以下:根⽬录中包括test.c makefileh和⽬录test-add和⽬录test-sub。

test.c makefile【test-add】test-add.c test-add.h【test-sub】test-sub.c test-sub.h【test.c】#include <stdio.h>#include <test-add.h>#include <test-sub.h>int main(void){int a = 3;int b = 2;printf("a=%d\n", a);printf("b=%d\n", b);printf("a+b=%d\n", add(a,b));printf("a-b=%d\n", sub(a,b));return 0;}【test-add.c】#include <test-add.h>int add(int a, int b){return a+b;}【test-add.h】#ifndef __TEST_ADDint add(int a, int b);#endif【test-sub.c】#include "test-sub.h"int sub(int a, int b){return a-b;}【test-sub.h】#ifndef __TEST_SUBint sub(int a, int b);#endif2.复习gcc指令gcc指令可通过-I前缀指定头⽂件路径,特别说明./代表当前路径,../代表上⼀级⽂件夹。

Linux编程 makefile文件

Linux编程  makefile文件

Linux 编程 makefile 文件Makefile 文件中包含着一些目标文件,来告诉make 做什么,通常目标就是文件名,对每一个目标,提供了实现这个目标的一组命令以及和这个目标有依赖关系的其他目标或文件名。

可以是要执行的动作,例如clean 。

Dependencies (依赖)是用来产生目标的输入文件,一个目标通常依赖于多个文件。

Command (命令)是make 执行的动作,一个规则可以有多个命令,每个占单独一行,每个命令行的起始字符必须为Tab 字符。

提 示 规则解释如何和何时重做该规则中的文件,make 根据依赖关系执行产生或更新目标;规则也说明如何和何时执行动作。

有的规则看起来很复杂,但都符合这个模式。

例如,以下是一个简单的makefile 的例子:以上Mamefile 中定义了三个目标:prog 、prog1和prog2,分号后是依赖文件列表,中间用一个分号隔开;对于第一个目标文件prog 来说,他有两个依赖文件:prog1.o 和prog2.o ,任何一个依赖文件更新,prog 也要随之更新,命令gcc prog1.o prog2.o -o prog 是生成prog 的命令。

make 检查目标是否需要更新时采用递归的方法,递归从底层向上对过时目标进行更新,只有当一个目标所依赖的所有目标都为最新时,这个目标才会被更新。

以上面的Makefile 为例,我们修改了prog2.c ,执行make 时,由于目标prog 依赖prog1.o 和 prog2.o ,所以要先检查prog1.o 和prog2.o 是否过时,目标prog1.o 依赖prog1.c 和lib.h ,由于我们并没修改这两个文件,所以他们都没有过期,接下来再检查目标prog2.o ,他依赖prog2.c ,由于我们修改了prog2.c ,所以prog2.c 比目标文件prog2.o要新,即prog2.o过期,而导致了依赖prog2.o的所有目标都过时;这样make会先更新prog2.o再更新prog。

linux系统中make的用法

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 make 编译参数

linux make 编译参数

linux make 编译参数1. -C目录切换到指定的目录下进行编译。

Change to the specified directory before compiling.2. -f文件名指定要编译的Makefile文件。

Specify the Makefile file to be compiled.3. -j[n]同时进行n个任务的编译。

Compile n tasks simultaneously.4. -k忽略错误,继续编译下去。

Ignore errors and continue compiling.5. -p打印编译规则,但不进行编译。

Print compilation rules without compiling.6. -r忽略Makefile文件的时间戳。

Ignore the timestamp of Makefile.7. -s静默模式,不输出编译过程的详细信息。

Silent mode, do not output detailed information of the compilation process.8. -t执行比较时间戳规则。

Execute the comparison timestamp rule.9. -w打开警告信息输出。

Enable warning message output.10. --no-print-directory不打印编译目录。

Do not print the compile directory.11. --werror将所有警告信息转换为错误信息。

Convert all warning messages to error messages.12. --always-make忽略时间戳,重新编译所有文件。

Ignore the timestamp and recompile all files.13. --print-data-base打印Makefile数据库信息。

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

Linux如何写makefile文件关于程序的编译和链接——————————在此,我想多说关于程序编译的一些规范和方法,一般来说,无论是C、C++、还是pas,首先要把源文件编译成中间代码文件,在Windows下也就是 .obj 文件,UNIX下是 .o 文件,即 Object File,这个动作叫做编译(compile)。

然后再把大量的Object File合成执行文件,这个动作叫作链接(link)。

编译时,编译器需要的是语法的正确,函数与变量的声明的正确。

对于后者,通常是你需要告诉编译器头文件的所在位置(头文件中应该只是声明,而定义应该放在 C/C++文件中),只要所有的语法正确,编译器就可以编译出中间目标文件。

一般来说,每个源文件都应该对应于一个中间目标文件(O文件或是OBJ文 件)。

链接时,主要是链接函数和全局变量,所以,我们可以使用这些中间目标文件(O文件或是OBJ文件)来链接我们的应用程序。

链接器并不管函数所在的源文件, 只管函数的中间目标文件(Object File),在大多数时候,由于源文件太多,编译生成的中间目标文件太多,而在链接时需要明显地指出中间目标文件名,这对于编译很不方便,所以,我们要给 中间目标文件打个包,在Windows 下这种包叫“库文件”(Library File),也就是 .lib 文件,在UNIX下,是Archive File,也就是 .a 文件。

总结一下,源文件首先会生成中间目标文件,再由中间目标文件生成执行文件。

在编译时,编译器只检测程序语法,和函数、变量是否被声明。

如果函数未被声明, 编译器会给出一个警告,但可以生成Object File。

而在链接程序时,链接器会在所有的Object File中找寻函数的实现,如果找不到,那到就会报链接错误码(Linker Error),在VC下,这种错误一般是:Link 2001错误,意思说是说,链接器未能找到函数的实现。

你需要指定函数的Object File.好,言归正传,GNU的make有许多的内容,闲言少叙,还是让我们开始吧。

Makefile 介绍———————make命令执行时,需要一个 Makefile 文件,以告诉make命令需要怎么样的去编译和链接程序。

首先,我们用一个示例来说明Makefile的书写规则。

以便给大家一个感兴认识。

这个示例来源于GNU的make使用手册,在这个示例中,我们的工程有 8个C文件,和3个头文件,我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。

我们的规则是:1)如果这个工程没有编译过,那么我们的所有C文件都要编译并被链接。

2)如果这个工程的某几个C文件被修改,那么我们只编译被修改的C文件,并链接目标程序。

3)如果这个工程的头文件被改变了,那么我们需要编译引用了这几个头文件的C文件,并链接目标程序。

只要我们的Makefile写得够好,所有的这一切,我们只用一个make命令就可以完成,make命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译,从而自己编译所需要的文件和链接目标程序。

一、Makefile的规则在讲述这个Makefile之前,还是让我们先来粗略地看一看Makefile的规则。

target ... : prerequisites ...command......target也就是一个目标文件,可以是Object File,也可以是执行文件。

还可以是一个标签(Label),对于标签这种特性,在后续的“伪目标”章节中会有叙述。

prerequisites就是,要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。

(任意的Shell命令)这是一个文件的依赖关系,也就是说,target这一个或多个的目标文件依赖于prerequisites中的文件,其生成规则定义在command中。

说白一点就是说,prerequisites中如果有一个以上的文件比target文件要新的话,command 所定义的命令就会被执行。

这就是 Makefile的规则。

也就是Makefile中最核心的内容。

说到底,Makefile的东西就是这样一点,好像我的这篇文档也该结束了。

呵呵。

还不尽然,这是Makefile的主线和核心,但要写好一个Makefile还不够,我会以后面一点一点地结合我的工作经验给你慢慢到来。

内容还多着呢。

:)二、一个示例正如前面所说的,如果一个工程有3个头文件,和8个C文件,我们为了完成前面所述的那三个规则,我们的Makefile应该是下面的这个样子的。

edit : main.o kbd.o command.o display.o \insert.o search.o files.o utils.occ -o edit main.o kbd.o command.o display.o \insert.o search.o files.o utils.omain.o : main.c defs.hcc -c main.ckbd.o : kbd.c defs.h command.hcc -c kbd.ccommand.o : command.c defs.h command.hcc -c command.cdisplay.o : display.c defs.h buffer.hcc -c display.cinsert.o : insert.c defs.h buffer.hcc -c insert.csearch.o : search.c defs.h buffer.hcc -c search.cfiles.o : files.c defs.h buffer.h command.hcc -c files.cutils.o : utils.c defs.hcc -c utils.cclean :rm edit main.o kbd.o command.o display.o \insert.o search.o files.o utils.o反斜杠(\)是换行符的意思。

这样比较便于Makefile的易读。

我们可以把这个内容保存在文件为“Makefile”或“makefile”的文件 中,然后在该目录下直接输入命令“make”就可以生成执行文件edit。

如果要删除执行文件和所有的中间目标文件,那么,只要简单地执行一下“make clean”就可以了。

在这个makefile中,目标文件(target)包含:执行文件edit和中间目标文件(*.o),依赖文件(prerequisites)就是冒号 后面的那些 .c 文件和 .h 文件。

每一个 .o 文件都有一组依赖文件,而这些 .o 文件又是执行文件 edit 的依赖文件。

依赖关系的实质上就是说明了目标文件是由哪些文件生成的,换言之,目标文件是哪些文件更新的。

在定义好依赖关系后,后续的那一行定义了如何生成目标文件的操作系统命令,一定要以一个Tab键作为开头。

记住,make并不管命令是怎么工作的,他只管 执行所定义的命令。

make会比较targets文件和prerequisites文件的修改日期,如果prerequisites文件的日期要比 targets文件的日期要新,或者target不存在的话,那么,make就会执行后续定义的命令。

这里要说明一点的是,clean不是一个文件,它只不过是一个动作名字,有点像C语言中的lable一样,其冒号后什么也没有,那么,make就不会自动 去找文件的依赖性,也就不会自动执行其后所定义的命令。

要执行其后的命令,就要在make命令后明显得指出这个lable的名字。

这样的方法非常有用,我 们可以在一个makefile中定义不用的编译或是和编译无关的命令,比如程序的打包,程序的备份,等等。

三、make是如何工作的在默认的方式下,也就是我们只输入make命令。

那么,1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。

2、如果找到,它会找文件中的第一个目标文件(target),在上面的例子中,他会找到“edit”这个文件,并把这个文件作为最终的目标文件。

3、如果edit文件不存在,或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个文件新,那么,他就会执行后面所定义的命令来生成edit这个文件。

4、如果edit所依赖的.o文件也存在,那么make会在当前文件中找目标为.o 文件的依赖性,如果找到则再根据那一个规则生成.o文件。

(这有点像一个堆栈的过程)5、当然,你的C文件和H文件是存在的啦,于是make会生成 .o 文件,然后再用 .o 文件生命make的终极任务,也就是执行文件edit了。

这就是整个make的依赖性,make会一层又一层地去找文件的依赖关系,直到最终编译出第一个目标文件。

在找寻的过程中,如果出现错误,比如最后被依赖 的文件找不到,那么make就会直接退出,并报错,而对于所定义的命令的错误,或是编译不成功,make根本不理。

make只管文件的依赖性,即,如果在 我找了依赖关系之后,冒号后面的文件还是不在,那么对不起,我就不工作啦。

通过上述分析,我们知道,像clean这种,没有被第一个目标文件直接或间接关联,那么它后面所定义的命令将不会被自动执行,不过,我们可以显示要make执行。

即命令——“make clean”,以此来清除所有的目标文件,以便重编译。

于是在我们编程中,如果这个工程已被编译过了,当我们修改了其中一个源文件,比如file.c,那么根据我们的依赖性,我们的目标file.o会被重编译 (也就是在这个依性关系后面所定义的命令),于是file.o的文件也是最新的啦,于是file.o的文件修改时间要比edit要新,所以edit也会被 重新链接了(详见edit目标文件后定义的命令)。

而如果我们改变了“command.h”,那么,kdb.o、command.o和files.o都会被重编译,并且,edit会被重链接。

四、makefile中使用变量在上面的例子中,先让我们看看edit的规则:edit : main.o kbd.o command.o display.o \insert.o search.o files.o utils.occ -o edit main.o kbd.o command.o display.o \insert.o search.o files.o utils.o我们可以看到[.o]文件的字符串被重复了两次,如果我们的工程需要加入一个新的[.o]文件,那么我们需要在两个地方加(应该是三个地方,还有一个地方 在clean中)。

相关文档
最新文档