Makefile两个实验
实验十四Makefile工程管理器
14.1 编写包含多文件的Makefile
【实验内容】
编写一个包含多文件的Makefile。
【实验目的】
通过对包含多文件的Makefile的编写，熟悉各种形式的Makefile，并且进一步加深对Makefile中用户自定义变量、自动变量及预定义变量的理解。
【实验平台】
PC机、CentOS 5 操作系统、gcc等工具。
【实验步骤】
1.用vi在同一目录下编辑两个简单的Hello程序，如下所示：
#hello.c
#include "hello.h"
int main()
{
printf("Hello everyone!\n");
}
#hello.h
#include
2.仍在同一目录下用vim编辑Makefile，不使用变量替换，用一个目标体实现（即直接将
hello.c和hello.h编译成hello目标体）。并用make验证所编写的Makefile是否正确。
3.将上述Makefile使用变量替换实现。同样用make验证所编写的Makefile是否正确
4.用编辑另一Makefile，取名为Makefile1，不使用变量替换，但用两个目标体实现（也
就是首先将hello.c和hello.h编译为hello.o，再将hello.o编译为hello），再用make 的‘-f’选项验证这个Makefile1的正确性。
5.将上述Makefile1使用变量替换实现
【详细步骤】
1.用vi打开上述两个代码文件…hello.c?和…hello.h?
2.在shell命令行中用gcc尝试编译，使用命令：…gcc hello.c -o hello?，并运行hello可执
行文件查看结果。
3.删除此次编译的可执行文件：rm –rf hello
4.用vim编辑Makefile，如下所示：
hello:hello.c hello.h
gcc hello.c -o hello
5.退出保存，在shell中键入：make查看结果
6.再次用vim打开Makefile，用变量进行替换，如下所示：
OBJS :=hello.o
CC :=gcc
hello:$(OBJS)
$(CC) $^ -o $@
7.退出保存，在shell中键入：make查看结果
8.用vim编辑Makefile1，如下所示：
hello:hello.o
gcc hello.o -o hello
hello.o:hello.c hello.h
gcc -c hello.c -o hello.o
9.退出保存，在shell中键入：make –f Makefile1查看结果
10.再次用vi编辑Makefile1，如下所示：
OBJS1 :=hello.o
OBJS2 :=hello.c hello.h
CC :=gcc
hello:$(OBJS1)
$(CC) $^ -o $@
$(OBJS1):$(OBJS2)
$(CC) -c $< -o $@
在这里请注意区别…$^?和…$
11.退出保存，在shell中键入：make –f Makefile1查看结果14.2嵌套Makefile实验
【实验目的】
1、读懂makefile文件，能根据makefile文件理清程序结构
2、能编写简单makefile
3、掌握嵌套执行makefile
【实验环境】
PC机、CentOS 5 操作系统，gcc等工具。
【实验步骤】
我们要创建的目录结构如下：
顶层Makefile
1.创建顶层目录
我们首先在用户目录下创建一个makefileTest的文件夹：#cd /opt
#mkdir makefileTest
#cd makefileTest
创建好需要用到的文件夹
#mkdir f1 f2 main obj include
进入include文件夹创建一个共用头文件
#cd include
#vim myinclude.h
输入如下内容：
#include
保存退出
返回顶层目录:
#cd ..
2.创建顶层Makefile文件
#vim Makefile
输入以下内容：
CC = gcc
SUBDIRS = f1 \
f2 \
main \
obj
OBJS = f1.o f2.o main.o
BIN = myapp
OBJS_DIR = obj
BIN_DIR = bin
export CC OBJS BIN OBJS_DIR BIN_DIR
all : CHECK_DIR $(SUBDIRS)
CHECK_DIR :
mkdir -p $(BIN_DIR)
$(SUBDIRS) : ECHO
make -C $@
ECHO:
@echo $(SUBDIRS)
@echo begin compile
CLEAN :
@$(RM) $(OBJS_DIR)/*.o
@rm -rf $(BIN_DIR)
3.进入在f1目录下创建makefile #cd f1
#vim f1.c
输入如下测试代码：
#include “../include/myinclude.h”
void print1()
{
printf("Message from f1.c...\n");
return;
}
保存退出。
#vim Makefile
输入如下内容：
../$(OBJS_DIR)/f1.o: f1.c
$(CC) -c $^ -o $@
保存退出。
进入f2目录
#cd ../f2
#vim f2.c
输入如下测试代码：
#include “../include/myinclude.h”
void print2()
{
printf("Message from f2.c…\n");
return;
}
保存退出。
#vim Makefile
输入如下内容：
../$(OBJS_DIR)/f2.o: f2.c
$(CC) -c $^ -o $@
保存退出。
进入main目录
#cd ../main
#vim main.c
输入如下内容：
#include
int main()
{
print1();
print2();
return 0;
}
保存退出。
#vim Makefile
输入如下内容：
../$(OBJS_DIR)/main.o: main.c
$(CC) -c $^ -o $@
保存退出。
进入obj目录
#cd ../obj
#vim Makefile
输入如下内容：
../$(BIN_DIR)/$(BIN) : $(OBJS)
$(CC) -o $@ $^
好了，到此准备工作已经完毕，然我们来测试一下写的makefile是否好用。进入顶层Makefile所在目录，即makefileTest目录。
#make
会出现如下信息：
目录树结构如下：
我们看到在bin目录下生成了我们的目标文件myapp，在obj目录下生成了.o的中间文件。让我们运行下myapp看下结果吧。
#bin/myapp
我们也可以用如下命令清除中间文件和目标文件，恢复make之前的状态：
#make CLEAN
我们可以看到已经变为make之前的目录状态了。
大功告成。最后给大家解释一下顶层makefile中一些命令的的含义吧。
a)我们注意到有一句@echo $(SUBDIRS)
@echo其实是一句显示命令
通常，make会把其要执行的命令行在命令执行前输出到屏幕上。当我们用“@”字符在命令行前，那么，这个命令将不被make显示出来，最具代表性的例子是，我们用这个功能来像屏幕显示一些信息。如：
@echo 正在编译XXX模块......
当make执行时，会输出“正在编译XXX模块......”字串，但不会输出命令，如果没有“@”，那么，make将输出：
echo 正在编译XXX模块......
正在编译XXX模块......
如果make执行时，带入make参数“-n”或“--just-print”，那么其只是显示命令，但不会执行命令，这个功能很有利于我们调试我们的Makefile，看看我们书写的命令是执行起来是什么样子的或是什么顺序的。
而make参数“-s”或“--slient”则是全面禁止命令的显示。
b)@(RM)并不是我们自己定义的变量，那它是从哪里来的呢？
通常在清除文件的伪目标所定义的命令中“rm”使用选项“–f”（--force）来防止
在缺少删除文件时出错并退出，使“make clean”过程失败。也可以在“rm”之前加
上“-”来防止“rm”错误退出，这种方式时 make 会提示错误信息但不会退出。为了
不看到这些讨厌的信息，需要使用上述的第一种方式。
另外 make存在一个内嵌隐含变量“RM”，它被定义为：“RM = rm –f”。因此在书
写“clean”规则的命令行时可以使用变量“$(RM)”来代替“rm”，这样可以免出现一
些不必要的麻烦！这是我们推荐的用法。
c)make -C $@
这是一句嵌套makefile的语法，在一些大的工程中，我们会把我们不同模块或是不同功能的源文件放在不同的目录中，我们可以在每个目录中都书写一个该目录的Makefile，这有利于让我们的Makefile变得更加地简洁，而不至于把所有的东西全部写在一个Makefile中，这样会很难维护我们的Makefile，这个技术对于我们模块编译和分段编译有着非常大的好处。
例如，我们有一个子目录叫subdir，这个目录下有个Makefile文件，来指明了这个目录下文件的编译规则。那么我们总控的Makefile可以这样书写：
subsystem:
cd subdir && $(MAKE)
其等价于：
subsystem:
$(MAKE) -C subdir
定义$(MAKE)宏变量的意思是，也许我们的make需要一些参数，所以定义成一个变量比较利于维护。这两个例子的意思都是先进入“subdir”目录，然后执行make命令。
d)export CC OBJS BIN OBJS_DIR BIN_DIR
我们把这个Makefile叫做“总控Makefile”，总控Makefile的变量可以传递到下级的Makefile中（如果你显示的声明），但是不会覆盖下层的Makefile中所定义的变量，除非指定了“-e”参数。
如果你要传递变量到下级Makefile中，那么你可以使用这样的声明：
export
跟我一起写Makefile
跟我一起写Makefile 陈皓 1 概述 什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。 在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。 2 关于程序的编译和链接 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是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中找寻函数的实现，如果找不到，那到就会报链接错
实验四：Makefile 实验
实验四：Makefile 实验 一、实验目的： 1、了解make； 2、了解makefile； 3、掌握makefile 编程； 二、实验内容： 通过makefile 来编译程序 三、实验设备： PC 机、飞凌6410 开发板 四、实验原理： 1、MAKE 当运行make 命令时,make 命令会在当前目录下按顺序寻找文件名为“GUNmakefile”、“Makefile”、“makefile”的文件,找到后解释这些文件。所以说make是一个解释makefile 中指令的命令工具。 Makefile 或makefile: 告诉make 维护一个大型程序,该做什么。Makefile 说明了组成程序的各模块间的相互关系及更新模块时必须进行的动作,make 按照这些说明自动地维护这些模块。 简单的说makefile 就像批处理的脚本文件,里边写好了一些命令的集合,当运行make 命令时,便会按着makefile 提供的命令及顺序来完成编译。Makefile 文件包含了五部分内容:显示规则、隐式规则、变量定义、文件指示和注释 2、Makeile 中的变量 Makefile 里的变量就像一个环境变量。事实上,环境变量在make 中也被解释成make 的变量。这些变量对大小写敏感,一般使用大写宇母。几乎可以从任何地方引用定义的变量。Makefile 中的变量是用一个文本串在Makefile 中定义的,这个文本串就是变量的值。只要在一行的开始写下这个变量的名字,后面跟一个“=”号,以及要设定这个变量的值即可定义变量,下面是定义变量的语法: VARNAME=string 使用时, 把变量用括号括起来, 并在前面加上$ 符号, 就可以引用变量的 值:${VARNAME} 3、Make 工作时的执行步骤 (1)读入所有的makefile 文件； (2)读入被include 包括的其他makefile 文件； (3)初始化文件中的变量； (4)推到隐士规则，并分析所有规则； (5)根据依赖关系，决定哪些目标要重新生成； (6)执行生成命令； 第(1)~(5)步为第一个阶段,第(6)~(7)步为第二个阶段。第一个阶段中,如果定义的变量被使用了,make 会在它使用的位置把它展开。但make 并不会马
手动建立makefile简单实例解析
手动建立makefile简单实例解析 假设我们有一个程序由5个文件组成，源代码如下：/*main.c*/ #include "mytool1.h" #include "mytool2.h" int main() { mytool1_print("hello mytool1!"); mytool2_print("hello mytool2!"); 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 #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); }
/*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文件，这样可以提高实际项目的工作效率。 在一个Makefile中通常包含下面内容： 1、需要由make工具创建的目标体（target），通常是目标文件或可执行文件。 2、要创建的目标体所依赖的文件（dependency_file）。 3、创建每个目标体时需要运行的命令（command）。 格式如下： target：dependency_files command target：规则的目标。通常是程序中间或者最后需要生成的文件名，可以是.o文件、也可以是最后的可执行程序的文件名。另外，目标也可以是一个make执行的动作的名称，如目标“clean”，这样的目标称为“伪目标”。 dependency_files：规则的依赖。生成规则目标所需要的文件名列表。通常一个目标依赖于一个或者多个文件。 command：规则的命令行。是make程序所有执行的动作（任意的shell命令或者可在shell下执行的程序）。一个规则可以有多个命令行，每一条命令占一行。注意：每一个命令行必须以[Tab]字符开始，[Tab]字符告诉make此行是一个命令行。make按照命令完成相应的动作。这也是书写Makefile中容易产生，而且比较隐蔽的错误。命令就是在任何一个目标的依赖文件发生变化后重建目标的动作描述。一个目标可以没有依赖而只有动作（指定的命令）。比如Makefile中的目标“clean”，此目标没有依赖，只有命令。它所指定的命令用来删除make过程产生的中间文件（清理工作）。 在Makefile中“规则”就是描述在什么情况下、如何重建规则的目标文件，通常规则
Linu系统编程实验二gccgdb的使用以及Makefile文件的编写
实验二：gcc、gdb、Makefile的使用 实验目的： （一）学会使用gcc编译器 （二）学会gdb调试器的使用 （三）学会编写Makefile 实验要求： （一）编写一应用程序，使用gcc进行编译，并分别使用-o，-g，-static，-O2等选项（二）编写一应用程序，使用gdb调试，调试中使用到该小节所介绍的所有命令 （三）实现一应用程序，该程序有两个c文件构成，使用makefile来完成对该程序的编译实验器材： 软件：安装了Linux的vmware虚拟机 硬件：PC机一台 实验步骤： （一）gcc编译器 1、先用vi编辑文件，内容如下： 2、gcc指令的一般格式为：gcc [选项] 要编译的文件 [选项] [目标文件] 例：使用gcc编译命令，编译生成可执行文件hello，并运行hello 上面的命令一步由.c文件生成了可执行文件，将gcc的四个编译流程：预处理、编译、汇编、连接一步完成，下面将介绍四个流程分别做了什么工作 3、-E选项的作用：只进行预处理，不做其他处理。 例：只对文件进行预处理，生成文件，并查看 通过查看可以看到头文件包含部分代码#include <>经过预处理阶段之后，编译器已将的内容贴了进来。 4、-S选项的使用 -S选项的作用：只是编译不汇编，生成汇编代码
例：将文件只进行编译而不进行汇编，生成汇编代码 5、-c选项的使用 -c选项的作用：只是编译不连接，生成目标文件.o 例：将汇编代码只编译不链接成文件 6、将编译好的链接库，生成可执行文件hello 7、-static选项的使用 -static选项的作用：链接静态库 例：比较连接动态库生成的可执行文件hello和链接静态库生成的可执行文件hello1的大小 可以看到静态链接库的可执行文件hello1比动态链接库的可执行文件hello要大的多，他们的执行效果是一样的 8、-g选项的使用 -g选项的作用：在可执行程序中包含标准调试信息 例：将编译成包含标准调试信息的可执行文件hello2
Makefile下编写Helloworld的例子
什么是makefile？或许很多Windows的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得 要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专 业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile， 从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中， makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复 杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make 命令，整个工程完全自动编译，极大的提高了软件 开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如： Delphi的make，VisualC++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 更新版本 hello.c程序 ＃include
return 0;}=== makefile开始=== Helloworld: hello.o gcc hello.o–o Helloworld Hello.o: hello.c hello.h gcc–MM hello.c gcc–c hello.c–o hello.o .PHONY: clean Clean: rm–rf*.o hellworld === makefile结束===
嵌入式系统实验的makefile
实验七 Makefile与Helloworld（1学时） 一、实验目的 熟悉Linux开发环境 学习嵌入式开发的基本过程 了解Makefile的基本内容 二、基础知识 C语言基础知识 掌握Linux环境下vi编译器的使用方法 掌握Linux下的程序编译与交叉编译过程 三、实验环境 PC机Pentium500以上，硬盘40GB以上，内存128MB以上 PC机操作系统Ubuntu10.10 arm-Linux开发环境 四、情景描述 创建一个新目录，并在其中编写hello.c和Makefile文件。 五、实验内容 1、完成一个简单程序的编译过程 1)切换到/work文件夹 2)建一个文件夹“Makefile”， 3)进入Makefile文件夹 4)Vi编辑hello.c， 5)Vi编辑Makefile 6)编译
命令：make
实验八编写包含多文件的Makefile（1学时） 备注：详见《嵌入式Linux应用开发教程》第53页 一、实验目的 通过对包含多文件的Makefile的编写，熟悉各种形式的Makefile，并且进一步加深对Makefile中用户自定义变量、自动变量及预定义变量的理解。 二、实验环境 PC机Pentium500以上，硬盘40GB以上，内存128MB以上 PC机操作系统Ubuntu10.10 arm-Linux开发环境 三、实验内容 1)切换到/work文件夹 2)建一个文件夹“Makefile2”， 3)进入Makefile2文件夹 4)Vi编辑hello.c，hello.h hello.c hello.h 5)仍在同一目录下用vi编辑Makefile，且不使用变量替换，用一个目标体实现（即直接 将hello.c和hello.h编译成hello目标体）。然后用make验证所编写的Makefile是否正确。 6)将上述Makefile使用变量替换实现。同样用make验证所编写的Makefile6是否正确。
Makefile两个实验
实验十四Makefile工程管理器 14.1 编写包含多文件的Makefile 【实验内容】 编写一个包含多文件的Makefile。 【实验目的】 通过对包含多文件的Makefile的编写，熟悉各种形式的Makefile，并且进一步加深对Makefile中用户自定义变量、自动变量及预定义变量的理解。 【实验平台】 PC机、CentOS 5 操作系统、gcc等工具。 【实验步骤】 1.用vi在同一目录下编辑两个简单的Hello程序，如下所示： #hello.c #include "hello.h" int main() { printf("Hello everyone!\n"); } #hello.h #include
Linux如何写makefile文件
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
linux内核编译和生成makefile文件实验报告
操作系统实验报告 姓名：学号： 一、实验题目 1.编译linux内核 2.使用autoconf和automake工具为project工程自动生成Makefile，并测试 3.在内核中添加一个模块 二、实验目的 1.了解一些命令提示符，也里了解一些linux系统的操作。 2.练习使用autoconf和automake工具自动生成Makefile，使同学们了解Makefile的生成原理，熟悉linux编程开发环境 三、实验要求 1使用静态库编译链接swap.c，同时使用动态库编译链接myadd.c。可运行程序生成在src/main目录下。 2要求独立完成，按时提交 四、设计思路和流程图（如：包括主要数据结构及其说明、测试数据的设计及测试结果分析） 1.Makefile的流程图： 2.内核的编译基本操作 1.在ubuntu环境下获取内核源码 2.解压内核源码用命令符：tar xvf linux- 3.18.12.tar.xz 3.配置内核特性：make allnoconfig 4.编译内核：make 5.安装内核：make install
6.测试：cat/boot/grub/grub.conf 7.重启系统：sudo reboot,看是否成功的安装上了内核 8.详情及结构见附录 3.生成makefile文件： 1.用老师给的projec里的main.c函数。 2．需要使用automake和autoconf两个工具，所以用命令符：sudo apt-get install autoconf 进行安装。 3．进入主函数所在目录执行命令：autoscan,这时会在目录下生成两个文件 autoscan.log和configure.scan，将configure.Scan改名为configure.ac，同时用gedit打开，打开后文件修改后的如下： # -*- Autoconf -*- # Process this file with autoconf to produce a configure script. AC_PREREQ([2.69]) AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS]) AC_CONFIG_SRCDIR([main.c]) AC_CONFIG_HEADERS([config.h]) AM_INIT_AUTOMAKE(main,1.0) # Checks for programs. AC_PROG_CC # Checks for libraries. # Checks for header files. # Checks for typedefs, structures, and compiler characteristics. # Checks for library functions. AC_OUTPUT(Makefile) 4.新建Makefile文件，如下： AUTOMAKE_OPTIONS=foreign bin_PROGRAMS=main first_SOURCES=main.c 5．运行命令aclocal 命令成功之后，在目录下会产生aclocal.m4和autom4te.cache两个文件。 6.运行命令autoheader 命令成功之后，会在目录下产生config.h.in这个新文件。 7.运行命令autoconf 命令成功之后，会在目录下产生configure这个新文件。 8.运行命令automake --add-missing输出结果为： Configure.ac:11:installing./compile’ Configure.ac:8:installing ‘.install-sh’ Configure.ac:8:installing ‘./missing’ Makefile.am:installing ‘./decomp’ 9. 命令成功之后，会在目录下产生depcomp，install-sh和missing这三个新文件和执行下一步的Makefile.in文件。 10.运行命令./configure就可以自动生成Makefile。 4.添加内核模块
Makefile两个实验教案
Makefile工程管理器 14.1 编写包含多文件的Makefile 【实验内容】 编写一个包含多文件的Makefile。 【实验目的】 通过对包含多文件的Makefile的编写，熟悉各种形式的Makefile，并且进一步加深对Makefile中用户自定义变量、自动变量及预定义变量的理解。 【实验平台】 PC机、CentOS 5 操作系统、gcc等工具。 【实验步骤】 1.用vi在同一目录下编辑两个简单的Hello程序，如下所示： #hello.c #include "hello.h" int main() { printf("Hello everyone!\n"); } #hello.h #include
makefile 中 $@ $^ % 使用
makefile 中$@ $^ %< 使用 https://www.wendangku.net/doc/0112456804.html,/kesaihao862/article/details/7332528 这篇文章介绍在LINUX下进行C语言编程所需要的基础知识。在这篇文章当中，我们将会学到以下内容：源程序编译Makefile的编写程序库的链接程序的调试头文件和系统求助1.源程序的编译在Linux下面，如果要编译一个C语言源程序，我们要使用GNU的gcc编译器。下面我们以一个实例来说明如何使用gcc编译器。假设我们有下面一个非常简单的源程序(hello.c)：int main(int argc，char **argv){printf("Hello Linux\n")；}要编译这个程序，我们只要在命令行下执行：gcc -o hello hello.cgcc 编译器就会为我们生成一个hello的可执行文件。执行./hello就可以看到程序的输出结果了。命令行中gcc表示我们是用gcc来编译我们的源程序，-o 选项表示我们要求编译器给我们输出的可执行文件名为hello 而hello.c是我们的源程序文件。gcc编译器有许多选项，一般来说我们只要知道其中的几个就够了。-o 选项我们已经知道了，表示我们要求输出的可执行文件名。-c选项表示我们只要求编译器输出目标代码，而不必要输出可执行文件。-g选项表示我们要求编译器在编译的时候提供我们以后对程序进行调试的信息。知道了这三个选项，我
们就可以编译我们自己所写的简单的源程序了，如果你想要知道更多的选项，可以查看gcc的帮助文档，那里有着许多对其它选项的详细说明。2.Makefile的编写假设我们有下面这样的一个程序，源代码如下：/* main.c */#include "mytool1.h"#include "mytool2.h" int main(int argc，char **argv){mytool1_print("hello")；mytool2_print("hello")；}/* mytool1.h */ #ifndef _MYTOOL_1_H#define _MYTOOL_1_Hvoid mytool1_print(char *print_str)；#endif/* mytool1.c */#include "mytool1.h"void mytool1_print(char *print_str){printf("This is mytool1 print %s\n"，print_str)；}/* mytool2.h */#ifndef _MYTOOL_2_H#define _MYTOOL_2_Hvoid mytool2_print(char *print_str)；#endif/* mytool2.c */#include "mytool2.h"void mytool2_print(char *print_str){printf("This is mytool2 print %s\n"，print_str)；}当然由于这个程序是很短的我们可以这样来编译gcc -c main.cgcc -c mytool1.cgcc -c mytool2.cgcc -o main main.o mytool1.o mytool2.o这样的话我们也可以产生main程序，而且也不时很麻烦。但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)那么我们难道还要重新输入上面的命令?也许你会说，这个很容易解决啊，我写一个SHELL脚本，让她帮我去完成不就可以了。是的对于这个程序来说，是可
C++项目的Makefile编写
一个C++项目的Makefile编写-Tony与Alex的对话系列- - Tony : Hey Alex, How are you doing? Alex : 不怎么样。(显得很消沉的样子) Tony : Oh , Really ? What is the matter? Alex : 事情是这样的。最近有一个Unix下的C++项目要求我独自完成，以前都是跟着别人做，现在让自己独立完成，还真是不知道该怎么办，就连一个最简单的项目的Makefile都搞不定。昨晚看了一晚上资料也没有什么头绪。唉！！ Tony : 别急，我曾经有一段时间研究过一些关于Makefile的东西，也许能帮得上忙，来，我们一起来设计这个项目的Makefile。 Alex : So it is a deal。(一言为定) Tony : 我们现在就开始吧，给我拿把椅子过来。 (Tony坐在Alex电脑的旁边) Tony : 把你的项目情况大概给我讲讲吧。 Alex : No Problem ! 这是一个“半成品”项目，也就是说我将提供一个开发框架供应用开发人员使用，一个类似MFC的东西。 Tony : 继续。 Alex : 我现在头脑中的项目目录结构是这样的： APL (Alex's Programming Library) -Make.properties -Makefile(1) -include //存放头文件 -Module1_1.h -Module1_2.h -Module2_1.h -Module2_2.h -src //存放源文件 -Makefile(2) -module1 -Module1_1.cpp -Module1_2.cpp -Makefile(3) -module2 -Module2_1.cpp -Module2_2.cpp -Makefile(3) -... -lib //存放该Project依赖的库文件,型如libxxx.a -dist //存放该Project编译连接后的库文件libapl.a -examples //存放使用该“半成品”搭建的例子应用的源程序 Makefile(4)
如何编写Makefile
概述 —— 什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE 都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile 中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make 是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。 在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX 下的GCC和CC。 关于程序的编译和链接 —————————— 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即 Object File，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。 编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。
实验八 makefile
实验四Makefile 一、实验目的 1、了解和掌握makefile文件的编写； 2、学会使用交叉编译工具和make工具。 二、实验环境 预装Fedora10的pc机一台，CVT-A8系列实验箱，以太网线一根，串口线一根。 三、实验步骤 1、连接主机和目标板；（三根线，注意网线和串口线是否连接正常） 2、Makefile文件的编写 a) 编写一个文件prime.h，包含一个判断unsigned int是否为素数的函数定义。 b) 编写一个文件prime.c，实现上面的那个函数。 c) 编写一个文件main.c，实现用户输入整数，程序告诉用户这个数是否为素数，直到用户输入0结束。 d) 使用gcc编译，查看运行结果。 e) 编写makefile文件实现第d步的功能，并使用make工具编译生成这个可执行文件；运行。 f) 使用定义宏来改写makefile，实现第d步的功能，并使用make工具编译生成这个可执行文件；运行。
g) 使用对依赖文件的预定义变量改写makefile，实现第d 步的功能，并使用make工具编译生成这个可执行文件；运行。 h) 使用标签改写makefile，此标签功能为删除项目编译生成中的所有中间文件，并使用make工具删除项目编译生成中的所有中间文件。 i) 使用CC宏指代编译器命令gcc，修改makefile文件，实现第d步的功能，并使用make工具编译生成这个可执行文件；运行。 j) 使用CC宏指代编译器命令arm-linux-gcc，修改makefile 文件，实现第d步的功能，并使用make工具编译生成这个可执行文件；下载到目标板运行。 k) 使用make CC=gcc 命令生成可执行文件，使用file查看可执行文件信息。再查看makefile文件。 四、实验要求 1、要求随时观察记录实验结果； 2、保留编写的源文件和每一步的makefile； 3、掌握makefile文件的三种编写方法。 五、实验报告要求 1、每人一份实验报告； 2、实验报告中要求对每一步操作和出现的结果详细记录并解释；
实验三 Makefile的编写及应用
闽江学院电子系 实验报告 学生姓名：3142731班级：学号：课程：实时操作系统 一、实验题目：Makefile的编写及应用 二、实验地点：大成楼A210 三、实验目的： 1、了解Makefile的基本概念和基本结构； 2、初步掌握编写简单Makefile的方法； 3、了解递归Make的编译过程； 4、初步掌握应用GNU Make编译应用程序的方法。 四、实验内容： 1、使用命令行的方式手动编译程序的方法； 五、实验环境（使用的软硬件）： 硬件：计算机 软件：Ubuntu Linux 六、实验结果： （1）使用命令行的方式手动编译程序方法 1、利用文本编辑器创建hello.c 文件
2、手动编译hello 应用程序 在hello.c 的目录的终端下输入： #gcc -c hello.c #gcc hello.o -o hello 通过ls 命令查看当前目录下是否生成源代码hello.c 的object 文件hello.o 和可执行文件hello，运行可执行文件hello。查看一下运行结果。 3、修改hello.c 文件，重新手动编译应用程序。
4、删除hello.o 和hello 文件 #rm -f hello.o #rm -f hello (2) 利用GNU make 自动编译应用程序方法 1、利用文本编辑器创建一个Makefile 文件，并将其保存到与hello.c 相同的目录下。 2、先执行如下命令。 #make #ls #./hello 查看并记录所生成的文件和运行的结果。
3、执行make clean 命令： 4、修改hello.c 文件，重复第2、3 步操作，查看并记录所生成的文件和运行结果，并与手动编译进行比较，写出你的结论。 5、重新编辑Makefile 文件（斜黑体表示修改部分）
Linux Makefile实验
实验二Makefile实验 【实验目的】 1、了解Makefile的基本概念和基本结构 2、初步掌握编写简单Makefile的方法 3、了解递归Make的编译过程 4、初步掌握利用GNU Make编译应用程序的方法 【实验原理】 在Linux或Unix环境下，对于只含有几个源代码文件的小程序（如hello.c）的编译，可以手工键入gcc命令对源代码文件逐个进行编译；然而在大型的项目开发中，可能涉及几十到几百个源文件，采用手工键入的方式进行编译，则非常不方便，而且一旦修改了源代码，尤其头文件发生了的修改，采用手工方式进行编译和维护的工作量相当大，而且容易出错。所以在Linux或Unix环境下，人们通常利用GNU make工具来自动完成应用程序的维护和编译工作。实际上，GNU make工具通过一个称为Makefile的文件来完成对应用程序的自动维护和编译工作。Makefile是按照某种脚本语法编写的文本文件，而GNU make能够对Makefile中指令进行解释并执行编译操作。Makefile文件定义了一系列的规则来指定哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作。GNU make工作时的执行步骤如下： 1、读入所有的Makefile。 2、读入被include的其它Makefile。 3、初始化文件中的变量。 4、推导隐晦规则，并分析所有规则。 5、为所有的目标文件创建依赖关系链。 6、根据依赖关系，决定哪些目标要重新生成。 7、执行生成命令。 1-5步为第一个阶段，6-7为第二个阶段。第一个阶段中，如果定义的变量被使用了，那么，make会把其展开在使用的位置。但make并不会完全马上展开，make使用的是拖延战术，如果变量出现在依赖关系的规则中，那么仅当这条依赖被决定要使用了，变量才会在其内部展开。下面对makefile的相关问题进行简单介绍： 1、Makefile的基本结构 Makefile的一般结构： target……：dependency…… command…… 结构中各部分的含义： （1）、target（目标）：一个目标文件，可以是Object文件，也可以是执行文件。还可以是一个标签（Label）。 （2）、dependency（依赖）：要生成目标文件（target）所依赖哪些文件 （3）、command（命令）：创建项目时需要运行的shell命令（注：命令（command）部分的每行的缩进必须要使用Tab而不能使用多个空格）。 Makefile实际上是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于dependency中的文件，其生成规则定义在命令command中。如果依赖文件（dependency）中有一个以上的文件比目标（target）文件要新的话，shell命令（command）所定义的命令
- 实验三 Makefile的编写及应用
- (基础篇)讲稿-makefile及交叉开发环境
- Linux系统编程实验二：gcc、gdb的使用以及Makefile文件的编写
- 实验四：Makefile 实验
- 实验指导书：makefile的使用
- Makefile文件编写
- 实验三Makefile地编写及应用
- 实验3-6 Makefile编写实验
- Linux系统编程实验二：gcc、gdb的使用以及Makefile文件的编写
- Makefile两个实验
- 嵌入式系统实验makefile
- 实验八 makefile
- 实验五 makefile文件编写
- LINUX下Makefile的编写
- 第五章 Makefile
- 实验六 Makefile实验
- 实验六
- makefile
- 嵌入式编程基础实验报告之Makefile文件的使用
- 试验4：Makefile实验