手动建立makefile简单实例解析

合集下载

c语言makefile编写实例

c语言makefile编写实例

c语言makefile编写实例Makefile是用来管理程序编译的工具,可以方便地管理程序的编译过程。

使用Makefile可以大大简化程序的编译过程,提高程序的可维护性。

Makefile的语法比较简单,主要由目标、依赖和命令三部分组成。

下面我们以一个简单的C程序为例,来介绍如何使用Makefile进行编译。

假设我们有一个名为hello.c的程序,代码如下:```c#include <stdio.h>int main(){printf("Hello, world!\n");return 0;}```我们需要使用gcc编译器将其编译成可执行文件。

下面是一个简单的Makefile:```makefilehello: hello.cgcc -o hello hello.c```这个Makefile很简单,它定义了一个名为hello的目标,该目标依赖于hello.c文件,并使用gcc命令将其编译成可执行文件。

如果我们在终端中输入make命令,Makefile会自动执行编译过程:```$ makegcc -o hello hello.c```Makefile还可以定义多个目标,每个目标可以有多个依赖和多个命令。

下面是一个稍微复杂一些的Makefile:```makefileCC=gccCFLAGS=-Wall -gall: hello goodbyehello: hello.o$(CC) $(CFLAGS) -o hello hello.ogoodbye: goodbye.o$(CC) $(CFLAGS) -o goodbye goodbye.ohello.o: hello.c$(CC) $(CFLAGS) -c hello.cgoodbye.o: goodbye.c$(CC) $(CFLAGS) -c goodbye.cclean:rm -f *.o hello goodbye```这个Makefile定义了两个目标:all和clean。

makefile make install 用法举例

makefile make install 用法举例

makefile make install 用法举例Makefile是一种用于自动化编译和构建软件的工具,它可以根据不同的构建目标(如编译、安装等)自动生成相应的构建指令。

在Makefile中,可以使用make命令来执行构建任务,其中make install是一种常用的构建指令,用于安装软件包。

一、Makefile的创建在创建Makefile之前,需要了解项目的基本结构和依赖关系,并根据需求定义不同的构建目标。

Makefile通常包含多个规则,每个规则定义了一个特定的构建目标及其对应的构建指令。

以下是一个简单的Makefile示例,用于编译一个C语言程序:```makefileCC=gccCFLAGS=-Wall -gSRC=main.c utils.cOBJ=$(SRC:.c=.o)all: $(SRC) Makefile $(OBJ)$(CC) $(CFLAGS) $(OBJ) -o program%.o: %.c$(CC) $(CFLAGS) -c $< -o $@clean:rm -f $(OBJ) $(EXE) *.o core* *~ .depend```在这个示例中,我们定义了两个规则:all规则和%.o规则。

all规则用于定义编译和链接指令,而%.o规则用于定义编译指令。

在执行make命令时,Makefile会根据当前目录下的Makefile和源文件自动生成相应的构建指令。

二、make install的使用make install是Makefile中常用的一种构建指令,用于将软件包安装到目标系统中。

使用make install命令时,需要指定安装的目标目录和安装选项。

下面是一个简单的示例:假设我们有一个名为myapp的软件包,将其安装到/usr/local/目录下:```bashmake install prefix=/usr/local/```在这个示例中,我们使用make install命令将myapp软件包安装到/usr/local/目录下。

c++的makefile实例

c++的makefile实例

1. 将上述代码保存到一个名为 "Makefile"(注意大小写)的文件中。 2. 将 "your_program" 替换为你的目标程序的名称。 3. 将 "main.cpp"、"file1.cpp" 和 "file2.cpp" 替换为你的源代码文件的名称(如果有更 多文件,可以继续添加)。 4. 运行命令 `make` 来编译和构建你的程序。
c++的makefile实例
- `%.o: %.cpp`:这个规则用于编译每个源代码文件。它将每个 .cpp 文件编译为对应的 .o 文件。
- `clean`:这个规则用于清理生成的目标文件和目标程序。
你可以根据你的实际需要修改和调整这个 Makefile,例如添加其他编译选项、链接库等 。运行命令 `make clean` 可以删除生成的目标文件和目标程序。
all: $(TARGET)
$(TARGET): $(OBJS) $(CC) $(CFLAGS) -o $@ $^
%.o: %.cpp $(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f $(OBJS) $(TARGET)

c++的makefile实例
在这个示例中,你需要做以下几个步骤:
c++的makefile实例
这个 Makefile 的规则解释如下:
- `CC`:定义了编译器的名称(在这里使用了 g++)。 - `CFLAGS`:定义了编译器的选项(在这里使用了 -std=c++11 和 -Wall)。 - `TARGET`:定义了目标程序的名称。 - `SRCS`:定义了源代码文件的名称。 - `OBJS`:定义了目标文件的名称(通过将源文件的扩展名 .cpp 替换为 .o 而得到)。 - `all`:这是一个默认目标,用于构建目标程序。它依赖于 $(TARGET)。 - `$(TARGET)`:这个规则用于构建目标程序。它依赖于 $(OBJS)。通过 $(CC) 命令将目 标文件链接在一起生成最终的可执行文件。

Makefile.am文件的实例讲解

Makefile.am文件的实例讲解

Makefile.am⽂件的实例讲解Makefile.am是⼀种⽐Makefile更⾼层次的编译规则,可以和configure.in⽂件⼀起通过调⽤automake命令,⽣成Makefile.in⽂件,再调⽤./configure的时候,就将Makefile.in⽂件⾃动⽣成Makefile⽂件了。

所以Makefile.am⽂件是⽐Makefile⽂件更⾼的抽象。

下⾯我根据⾃⼰的⼯作中的⼀些应⽤,来讨论Makefile.am的编写。

我觉得主要是要注意的问题是将编译什么⽂件?这个⽂件会不会安装?这个⽂件被安装到什么⽬录下?可以将⽂件编译成可执⾏⽂件来安装,也可以编译成静态库⽂件安装,常见的⽂件编译类型有下⾯⼏种:1. PROGRAMS。

表⽰可执⾏⽂件2. LIBRARIES。

表⽰库⽂件3. LTLIBRARIES。

这也是表⽰库⽂件,前⾯的LT表⽰libtool。

4. HEADERS。

头⽂件。

5. SCRIPTS。

脚本⽂件,这个可以被⽤于执⾏。

如:example_SCRIPTS,如果⽤这样的话,需要我们⾃⼰定义安装⽬录下的example⽬录,很容易的,往下看。

6. DATA。

数据⽂件,不能执⾏。

⼀,可执⾏⽂件先看⼀个实例:bin_PROGRAMS = clientclient_SOURCES = key.c connect.c client.c main.c session.c hash.cclient_CPPFLAGS = -DCONFIG_DIR=\"$(sysconfdir)\" -DLIBRARY_DIR=\"$(pkglibdir)\"client_LDFLAGS = -export-dynamic -lmemcachednoinst_HEADERS = client.hINCLUDES = -I/usr/local/libmemcached/include/client_LDADD = $(top_builddir)/sx/ \$(top_builddir)/util/ 上⾯就是⼀个全部的Makefile.am⽂件,这个⽂件⽤于⽣成client可执⾏应⽤程序,引⽤了两个静态库和MC等动态库的连接。

【最新】makefile范例-word范文 (23页)

【最新】makefile范例-word范文 (23页)

本文部分内容来自网络整理,本司不为其真实性负责,如有异议或侵权请及时联系,本司将立即删除!== 本文为word格式,下载后可方便编辑和修改! ==makefile范例篇一:实例—使用make及Makefile文件2.3 实例—使用make及Makefile文件一个工程有3个头文件(head1.h、head2.h、exam2.h)和8个C文件(main.c、exam1.c、exam2.c、exam3.c、exam4.c、exam5.c、exam6.c、exam7.c),建立一个Makefile文件(文件名为makefile),内容如下。

注意,上述12个文件位于同一个目录中。

gcc -o example main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.omain.o : main.c head1.hgcc -c main.cexam1.o : exam1.c head1.h exam2.hgcc -c exam1.cexam2.o : exam2.c head1.h exam2.hgcc -c exam2.cexam3.o : exam3.c head1.h head2.hgcc -c exam3.cexam4.o : exam4.c head1.h head2.hgcc -c exam4.cexam5.o : exam5.c head1.h head2.hgcc -c exam5.cexam6.o : exam6.c head1.h head2.h exam2.hgcc -c exam6.cexam7.o : exam7.c head1.hgcc -c exam7.cclean :rm example main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.omakefile文件告诉make命令如何编译和链接这几个文件。

windows makefile编译

windows makefile编译

windows makefile编译随着仓库中的代码越来越复杂,对于不同的平台和系统,不同的编译工具都被用来生成可执行文件。

在Windows平台上,Makefile是一种非常流行的编译工具,这篇文章将会详细介绍如何使用Windows Makefile来编译。

下面我们将分步骤阐述这个过程。

1. 安装编译工具首先需要安装MinGW编译工具。

MinGW是一个Windows下基于GNU编译器集合的开发环境,它包含了编译器和各种实用程序。

你可以在MinGW的官网上下载。

下载完成后,进行安装并将MinGW添加到系统路径中。

2. 创建Makefile接下来,需要创建一个Makefile来告诉Make怎么去编译代码以及链接库文件。

在Makefile中,可以定义一些常量和变量,来提高Makefile的重用性。

同时,还需要定义源代码和头文件的位置,以及生成的可执行文件的名称。

3. 编写Makefile下面是一个简单的Makefile的例子:```CC=gccCFLAGS=-c -WallLDFLAGS=-lmSOURCES=main.cOBJECTS=$(SOURCES:.c=.o)EXECUTABLE=myappall: $(SOURCES) $(EXECUTABLE)$(EXECUTABLE): $(OBJECTS)$(CC) $(OBJECTS) $(LDFLAGS) -o $@.c.o:$(CC) $(CFLAGS) $< -o $@```在这个例子中,我们定义了CC变量为gcc编译器,CFLAGS变量为编译选项。

同时,还定义了LDFLAGS变量为链接选项,SOURCES变量为源代码文件名称,OBJECTS变量为生成的目标文件对象名称,EXECUTABLE变量为生成的可执行文件名称。

对于Makefile中的命令,需要使用Tab键缩进来区分命令和规则。

在这个例子中,我们定义了一个默认目标all,它依赖于源代码和可执行文件。

python makefile 用法

python makefile 用法

python makefile 用法在使用Python编写程序时,我们通常需要编译和运行代码,这就需要用到makefile。

makefile是一种可以自动化地构建程序的工具,它可以根据代码修改的情况自动判断哪些文件需要重新编译,从而提高程序的编译效率。

使用makefile的基本步骤如下:1. 创建一个名为makefile的文件,通常放在程序的根目录下。

2. 在makefile中定义一些变量,如编译器、编译选项等。

3. 定义一些规则,如编译规则、目标规则等。

4. 运行make命令,根据makefile的规则进行编译和链接。

下面是一个简单的makefile示例:```# 定义编译器和编译选项CC=gccCFLAGS=-Wall -g# 定义编译规则%.o: %.c$(CC) $(CFLAGS) -c $< -o $@# 定义目标规则main: main.o sub.o$(CC) $(CFLAGS) main.o sub.o -o main# 清除中间文件clean:rm -f *.o main```在这个示例中,我们定义了两个变量CC和CFLAGS,分别表示编译器和编译选项。

接着定义了一个编译规则,表示将.c文件编译成.o文件的过程。

其中,$<表示依赖文件(即输入文件),$@表示目标文件(即输出文件)。

最后定义了一个目标规则,表示将main.o和sub.o链接成可执行文件main。

最后,我们定义了一个清除中间文件的规则,可以通过运行make clean来清除中间文件。

可以通过运行make命令来编译和链接程序。

例如,如果你有一个名为main.c和sub.c的源文件,并想将它们编译成可执行文件main,可以在终端中输入以下命令:```$ make main```这将根据makefile中定义的规则自动编译和链接程序,并生成可执行文件main。

总之,makefile是一个非常有用的编译工具,可以帮助我们自动化地构建程序,提高编译效率。

makefile -d 用法

makefile -d 用法

makefile -d 用法摘要:1.Makefile 简介2.makefile -d 用法详解a.参数含义b.使用方法c.实例演示3.makefile -d 在实际项目中的应用4.总结正文:Makefile 是一个项目管理工具,主要用于自动化构建和编译软件项目。

在Makefile 中,我们可以定义一系列的规则,用于描述软件项目各文件的依赖关系以及编译命令等。

今天,我们将详细了解一下makefile -d 的用法。

1.Makefile 简介首先,让我们简要了解一下Makefile 的基本概念。

Makefile 是一个包含一系列命令和规则的文本文件,通常位于项目的根目录下。

它告诉make 命令如何自动构建、编译和链接项目。

2.makefile -d 用法详解接下来,我们将详细解释makefile -d 的参数含义、使用方法和实例演示。

a.参数含义-d 选项是makefile 的调试模式,它会在执行规则之前输出规则的详细信息,便于开发者调试和理解Makefile 的执行过程。

b.使用方法要使用makefile -d 选项,只需在调用make 命令时添加-d 参数即可,如下所示:```make -d```c.实例演示下面,我们通过一个简单的实例来演示如何使用makefile -d。

假设我们有一个名为`example.mk`的Makefile,其内容如下:```all: main.occ main.o -o mainmain.o: main.ccc main.c -o main.o```现在,我们使用make -d 命令来执行Makefile:```make -d```执行结果如下:```make: Entering directory `."main.mk:3: recipe for target "all"main.mk:3: cc main.o -o mainmake: Leaving directory `."```从输出结果中,我们可以看到makefile -d 选项输出了规则的详细信息。

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

Makefile_中的常用函数及实例分析

Makefile_中的常用函数及实例分析

Makefile 中的常用函数1.$(subset <from>,<to>,<text>)名称:字符串替换功能:把字符串<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> )名称:模式字符串替换函数功能:查找<text>中的单词(单词以"空格"、"Tab"或"回车""换行"分隔)是否符合模式<pattern>,如果匹配的话,则以<replacement>替换。

这里,<pattern>可以包括通配符"%",表示任意长度的字串。

如果<replacement>中也包含“%" ,那么,<replacement>中的这个“%" 将是<pattern> 中的那个"%" 所代表的字串。

(可以用"\"来转义,以"\%" 来表示真实含义的"%" 字符)返回值:函数返回被替换过后的字符串。

示例:$(patsubst %.c,%.o,x.c.c bar.c)把字串"x.c.c bar.c" 符合模式[%.c]的单词替换成[%.o],返回结果是"x.o.o bar.o"3.$(strip <string> )名称:去空格函数——strip功能:去掉<string>字符串中开头和结尾的空字符。

简单制作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不是个明智之举。

makefile的规则和编写方法

makefile的规则和编写方法

makefile的规则和编写方法Makefile是一种文本文件,它包含了一系列规则和命令,用于描述源代码的编译和构建过程。

Makefile的规则和编写方法对于项目的管理和维护非常重要。

下面是关于Makefile规则和编写方法的一些要点:1. 目标(Targets):每个Makefile中都应该定义一个或多个目标。

目标通常代表项目中的某个文件、可执行程序或者一个任务。

在Makefile中,目标的名称应该在冒号(:)后面给出,并且每个目标都应该独占一行。

2. 依赖(Dependencies):在Makefile中,每个目标通常都会依赖于其他文件或目标。

依赖关系表示了一个文件或目标的生成所依赖的其他文件或目标。

依赖关系可以使用冒号(:)来表示,冒号前是目标名称,冒号后是该目标所依赖的文件或目标。

3. 命令(Commands):在Makefile中,每个目标都需要定义一个或多个命令,用于生成该目标所描述的文件或任务。

每个命令需要以制表符(Tab)开头,紧随其后的是具体的操作指令,如编译命令、链接命令等。

命令之间可以使用换行符进行分隔。

4. 变量(Variables):在Makefile中,可以使用变量来存储常用的数值、目录路径或者编译器选项等信息。

变量可以使用等号(=)或冒号等号(:=)进行赋值。

通过使用变量,可以大大简化Makefile的编写和维护过程。

5. 注释(Comments):注释用于解释Makefile中的规则和命令,以提高代码的可读性。

在Makefile 中,可以使用井号(#)表示注释,井号后的内容会被忽略。

编写一个简单的Makefile示例:```# 定义变量CC = gccCFLAGS = -Wall -O2# 定义目标和依赖关系myprogram: main.o func1.o func2.o$(CC) $(CFLAGS) -o myprogram main.o func1.o func2.o# 生成目标的命令main.o: main.c$(CC) $(CFLAGS) -c main.cfunc1.o: func1.c$(CC) $(CFLAGS) -c func1.cfunc2.o: func2.c$(CC) $(CFLAGS) -c func2.c# 清理目标文件的命令clean:rm -f *.o myprogram```以上是一个简单的Makefile示例。

vivado makefile文件编写实例

vivado makefile文件编写实例

vivado makefile文件编写实例如何编写Vivado Makefile 文件。

Vivado 是一款由Xilinx 公司开发的集成电路设计工具,它提供了丰富的设计和仿真功能,可以用于设计和验证各种数字电路。

Makefile 是一种用于自动化构建和管理项目的文件,它可以定义编译、链接和运行等操作的规则。

在Vivado 中使用Makefile 可以方便地管理项目的编译和仿真过程,提高开发效率。

本文将以中括号内的内容为主题,一步一步回答如何编写Vivado Makefile 文件。

一、创建Makefile 文件首先,在Vivado 工程目录下创建一个名为Makefile 的文件。

可以使用文本编辑器或者命令行工具创建该文件。

二、Makefile 基本结构Makefile 是按照一定的规则编写的,它由一系列的规则定义组成,每个规则包含一个或多个目标、依赖和命令。

规则的语法如下:target: dependenciescommand其中,target 是规则的目标,dependencies 是目标的依赖,command 是执行的命令。

三、Vivado Makefile 常用规则1. all:编译和仿真整个工程all: build sim上述规则定义了一个名为all 的目标,它依赖于build 和sim 两个目标,执行的命令为空。

2. build:编译工程build:vivado -mode batch -source build.tcl上述规则定义了一个名为build 的目标,它执行vivado 命令,并传入-mode batch 和-source build.tcl 两个参数。

这里的build.tcl 是一个Vivado Tcl 脚本,用于自动化执行编译操作。

3. sim:仿真工程sim:vivado -mode batch -source sim.tcl上述规则定义了一个名为sim 的目标,它执行vivado 命令,并传入-mode batch 和-source sim.tcl 两个参数。

sv 中的makefile 写法

sv 中的makefile 写法

SV(SystemVerilog)是一种硬件描述语言,用于设计和验证数字电路。

在进行SV代码编写的过程中,makefile是一种非常有用的工具,可以帮助组织和管理SV项目中的代码文件。

本文将介绍SV中makefile的写法,希望能为SV开发者提供一些参考和帮助。

1. 为什么需要makefile在SV项目中,通常会涉及到多个源文件、库文件、测试文件等。

使用makefile可以帮助我们轻松地组织和管理这些文件,实现自动化编译、信息和运行测试的功能。

makefile还可以帮助我们避免重复编译文件,提高开发效率。

2. makefile的基本结构makefile由一系列规则组成,每个规则由一个目标、依赖列表和命令组成。

一个基本的makefile看起来像这样:```makefiletarget: dependenciesmand```其中,target表示规则的目标文件,dependencies表示该目标文件的依赖文件mand表示需要执行的命令。

3. 使用变量在makefile中,我们可以使用变量来定义一些常量,方便我们在后续的规则中使用。

例如:```makefileSV_SRC = file1.sv file2.sv file3.sv```这样,我们就可以在后续的规则中使用$(SV_SRC)来表示这些文件,而不需要重复地写出它们的文件名。

4. 基本规则在SV项目中,常见的makefile规则包括编译规则、信息规则和运行测试规则。

以下是一个简单的例子:```makefileall: $(SV_SRC)vlog $(SV_SRC)sim: allvsim top_module```在这个例子中,我们定义了两个规则,分别是all和sim。

all规则依赖于$(SV_SRC)中的文件,使用vlog命令对这些文件进行编译。

sim规则依赖于all规则,使用vsim命令来运行测试。

5. 使用通配符在makefile中,我们还可以使用通配符来表示一类文件。

单片机makefile编写

单片机makefile编写

单片机makefile编写编写一个针对单片机的Makefile通常涉及指定编译器、链接器、源文件、目标文件、依赖关系以及构建和清理过程。

以下是一个简单的Makefile示例,它假设你正在使用GCC编译器为单片机(如AVR)编译代码:make# 定义编译器和工具链CC=avr-gccOBJCOPY=avr-objcopySIZE=avr-size# 定义项目名称和CPU类型PROJECT=my_projectCPU=atmega328p# 定义源文件目录和源文件列表SRC_DIR=./srcSRC=$(wildcard $(SRC_DIR)/*.c)# 定义目标文件目录和目标文件列表OBJ_DIR=./objOBJ=$(SRC:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)# 定义编译选项CFLAGS=-Os -DF_CPU=16000000UL -mmcu=$(CPU) -I. -std=gnu99 -Wall -Wextra -Werror# 定义最终目标文件HEX_FILE=$(PROJECT).hexELF_FILE=$(PROJECT).elf# 默认目标,输入'make'时将执行此目标all: $(HEX_FILE)# 链接对象文件并生成elf文件$(ELF_FILE): $(OBJ)$(CC) $(CFLAGS) -o $@ $^# 将elf文件转换为hex文件$(HEX_FILE): $(ELF_FILE)$(OBJCOPY) -O ihex -R .eeprom $< $@# 编译源文件并生成对象文件$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c | $(OBJ_DIR)$(CC) $(CFLAGS) -c $< -o $@# 创建目标文件目录(如果不存在)$(OBJ_DIR):mkdir -p $@# 显示项目大小信息size: $(HEX_FILE)$(SIZE) -A $(ELF_FILE)# 清理生成的文件clean:rm -f $(OBJ_DIR)/*.o $(HEX_FILE) $(ELF_FILE)此Makefile将完成以下工作:使用AVR GCC编译器编译在src目录下的所有C源文件。

make 的用法精简版

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 文件。

Makefile第一章如何写一个简单的

Makefile第一章如何写一个简单的

63 64 当然你也可以在一行cc命令之内就做好编译,组译,连结的工作(要下很长的一串指
Page 1 of 7
2003-4-18 22:18
如何写一个简单的Makefile mini-HOWTO.txt
65 令),但是在实际的程式设计环境下这是很少发生的(因为指令实在是又长又复杂),因 66 为以下原因: 首先,每一个原始档都可能被不同的人所建立或测试. 第二,一个大程 67 式会花掉好几小时的编译工作,所以程式设计师一般都会尽可能的使用已经存在的目 68 的档而不要再重新编译(可以节省时间).
79 ?c main.c
80 5.iodat.o : iodat.c
81 ?c iodat.c
82 7.dorun.o : dorun.c
83 7.dorun.o : dorun.c
84 ?c dorun.cБайду номын сангаас
85 9.lo.o : lo.s
86 10.as ?0 lo.o lo.s
如何写一个简单的Makefile mini-HOWTO.txt
1 第一章 如何写一个简单的Makefile
2
3
描述档案(Description File)
4
5
检查附属档案(Dependency Checking)
6
7
重建最小化(Minimizing Rebuilds)
8 9 引用make (Invoking make)
124 125 例如,从第3列就可以看出main.o的建造必须依靠main.c. 因此,如果再main.o被建造 126 之后,main.c才又被修改,则make就会去执行第4列的指令重新建造一个新的main.o. 127 只有在program的必备档都被检查而且更新过(这必备档的必备档也要被检查且更新 128 过. 例如:main.o是program的必备档,main.c是main.o的必备档). make才会去执行

makefile文件编写

makefile文件编写

Makefile文件编写详解——WangYiwei 利用makefile工具可以自动完成编译工作。

如果仅修改了几个源文件,则只重新编译这几个源文件,其他没有修改的不再去编译。

如果某个头文件被修改,则只重新编译包含这几个头文件的源文件。

因此可以简化开发工作。

格式:TARGET(目标) :DEPENDENCIES(依赖)COMMOND(命令)目标:程序要产生的文件,如可执行文件和目标文件。

目标也可以是要执行的动作,如clean也成为伪目标。

依赖:是用来产生目标输入文件列表,一个目标通常依赖于多个文件。

命令:是make执行的动作(命令是shell命令或是可在shell下执行的程序)。

注意:每个命令行的起始字符都是table字符$@ 规则目标文件名$< 规则第一个依赖文件名$^ 规则的所有文件列表例子:(1)生成一个可执行文件:说明:在01目录下有main.c sub.c sub.h add.c add.h Makefile,以下部分是Makefile的内容①简单的例子.PHONY: clean#显示地指出clean为伪目标,防止当前目录下存在clean文件,不能进行清理工作main: main.o add.o sub.ogcc main.o add.o sub.o -o mainmain.o: main.c add.h sub.hgcc -c main.c -o main.oadd.o: add.c add.hgcc -c add.c -o add.osub.o: sub.c sub.hgcc -c sub.c -o sub.oclean:@echo "remove file ..."rm main main.o add.o sub.o②利用自定义变量和自动化变量.PHONY: clean#显示的指出clean为伪目标,防止当前目录下存在clean文件,不能进行清理工作OBJECTS = main.o add.o sub.o#自定义变量main: $(OBJECTS)gcc -Wall -g $^ -o $@main.o: main.c add.h sub.hgcc -Wall -g -c $< -o $@add.o: add.c add.hgcc -Wall -g -c $< -o $@sub.o: sub.c sub.hgcc -Wall -g -c $< -o $@clean:@echo "remove file ..."#在命令前加@表示不显示命令rm -f main $(OBJECTS)(2)生成多个可执行文件说明:在02目录下有01test.c 02test.c 03test.c Makefile,以下部分是Makefile 的内容①默认规则.PHONY: all clean#显示的指出clean为伪目标,防止当前目录下存在clean文件,不能进行清理工作CC = gccCFLAGS = -Wall -gBIN = 01test 02test 03testall: $(BIN)clean:@echo "Begin remove ..."rm -f $(BIN)执行之后生成01test 02test 03test可执行文件,系统执行的是隐含推导规则,也可以自己编写推导规则。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
gcc -o main $(OBJ)
main.o:main.c mytool1.h mytool2.h
gcc -c main.c
mytool1.o:mytool1.c mytool1.h
gcc -c mytool1.c
mytool2.o:mytool2.c mytool2.h
gcc -c mytool2.c
Makefile有三个非常有用的变量,分别是$@、$^、$<。代表的意义分别是:
$@--目标文件,
$^--所有的依赖文件,
$<--第一个依赖文件。
CC = gcc
OBJ = main.o mytool1.o mytool2.o
main: $(OBJ)
$(CC) -o $@ $^
main.o: main.c mytool1.h mytool2.h
clean:
rm -f main $(OBJ)
改进二:使用自动推导
让make自动推导,只要make看到一个.o文件,它就会自动的把对应的.c文件加到依赖文件中,并且gcc-c .c也会被推导出来,所以Makefile就简化了。
CC = gcc
OBJ = main.o mytool1.o mytool2.o
command:规则的命令行。是make程序所有执行的动作(任意的shell命令或者可在shell下执行的程序)。一个规则可以有多个命令行,每一条命令占一行。注意:每一个命令行必须以[Tab]字符开始,[Tab]字符告诉make此行是一个命令行。make按照命令完成相应的动作。这也是书写Makefile中容易产生,而且比较隐蔽的错误。命令就是在任何一个目标的依赖文件发生变化后重建目标的动作描述。一个目标可以没有依赖而只有动作(指定的命令)。比如Makefile中的目标“clean”,此目标没有依赖,只有命令。它所指定的命令用来删除make过程产生的中间文件(清理工作)。
return 0;
}
/*mytool1.c*/
#include "mytool1.h"
#include
void mytool1_print(char *print_str)
{
printf("This is mytool1 print : %s ",print_str);
}
/*mytool1.h*/
#ifndef _MYTOOL_1_H
main.o:main.c mytool1.h mytool2.h
gcc -c main.c
mytool1.o:mytool1.c mytool1.h
gcc -c mytool1.c
mytool2.o:mytool2.c mytool2.h
gcc -c mytool2.c
clean:
rm -f *.o main
make: $(OBJ)
$(CC) -o main $(OBJ)
main.o: mytool1.h mytool2.h
mytool1.o: mytool1.h
mytool2.o: mytool2.h
.PHONY: clean
clean:
rm -f main $(OBJ)
改进三:自动变量($^ $< $@)的应用
在Makefile中“规则”就是描述在什么情况下、如何重建规则的目标文件,通常规则中包括了目标的依赖关系(目标的依赖文件)和重建目标的命令。make执行重建目标的命令,来创建或者重建规则的目标(此目标文件也可以是触发这个规则的上一个规则中的依赖文件)。规则包含了目标和依赖的关系以及更新目标所要求的命令。
手动建立makefile简单实例解析
假设我们有一个程序由5个文件组成,源代码如下:
/*main.c*/
#include "mytool1.h"
#include "mytool2.h"
int main()
{
mytool1_print("hello mytool1!");
mytool2_print("hello mytool2!");
}
/*mytool2.h*/
#ifndef _MYTOOL_2_H
#define _MYTOOL_2_H
void mytool2_print(char *print_str);
#endif
首先了解一下make和Makefile。GNU make是一个工程管理器,它可以管理较多的文件。我所使用的RedHat 9.0的make版本为GNU Make version 3.79.1。使用make的最大好处就是实现了“自动化编译”。如果有一个上百个文件的代码构成的项目,其中一个或者几个文件进行了修改,make就能够自动识别更新了的文件代码,不需要输入冗长的命令行就可以完成最后的编译工作。make执行时,自动寻找Makefile(makefile)文件,然后执行编译工作。所以我们需要编写Makefile文件,这样可以提高实际项目的工作效率。
#define _MYTOOL_1_H
void mytool1_print(char *print_str);
#endif
/*mytool2.c*/
#include "mytool2.h"
#include
void mytool2_print(char *print_str)
{
printf("This is mytool2 print : %s ",print_str);
$(CC)ቤተ መጻሕፍቲ ባይዱ-c $<
mytool1.o: mytool1.c mytool1.h
$(CC) -c $<
mytool2.o: mytool2.c mytool2.h
$(CC) -c $<
.PHONY: clean
clean:
rm -f main $(OBJ)
这些是最为初级的知识,现在至少可以减少编译时的工作量。细节方面的东西还需要在以后的工作和学习中不断的总结,不断的深化理解。可以参考GNU Make手册,这里讲解的比较全面。
Makefile中可以包含除规则以外的部分。一个最简单的Makefile可能只包含规则描述。规则在有些Makefile中可能看起来非常复杂,但是无论规则的书写是多么的复杂,它都符合规则的基本格式。
下面就可以写出第一个Makefile了。
main:main.o mytool1.o mytool2.o
gcc -o main main.o mytool1.o mytool2.o
target:规则的目标。通常是程序中间或者最后需要生成的文件名,可以是.o文件、也可以是最后的可执行程序的文件名。另外,目标也可以是一个make执行的动作的名称,如目标“clean”,这样的目标称为“伪目标”。
dependency_files:规则的依赖。生成规则目标所需要的文件名列表。通常一个目标依赖于一个或者多个文件。
在shell提示符下输入make,执行显示:
gcc -c main.c
gcc -c mytool1.c
gcc -c mytool2.c
gcc -o main main.o mytool1.o mytool2.o
执行结果如下:
[armlinux@lqm makefile-easy]$ ./main
This is mytool1 print : hello mytool1!
This is mytool2 print : hello mytool2!
这只是最为初级的Makefile,现在来对这个Makefile进行改进。
改进一:使用变量
一般在书写Makefile时,各部分变量引用的格式如下:
1. make变量(Makefile中定义的或者是make的环境变量)的引用使用“$(VAR)”格式,无论“VAR”是单字符变量名还是多字符变量名。
2.出现在规则命令行中shell变量(一般为执行命令过程中的临时变量,它不属于Makefile变量,而是一个shell变量)引用使用shell的“$tmp”格式。
3.对出现在命令行中的make变量同样使用“$(CMDVAR)”格式来引用。
OBJ=main.o mytool1.o mytool2.o
make:$(OBJ)
在一个Makefile中通常包含下面内容:
1、需要由make工具创建的目标体(target),通常是目标文件或可执行文件。
2、要创建的目标体所依赖的文件(dependency_file)。
3、创建每个目标体时需要运行的命令(command)。
格式如下:
target:dependency_files
command
相关文档
最新文档