Makefile中的include命令详解

kenson

. J1 U) v& F& I3 R! g关于Makefile中的include命令，网上有很多介绍，比较普遍的说法是：Makefile中的include命令与C语言中的include命令类似，命令include file.dep，即把file.dep文件在当前Makefile文件中展开，亦即把file.dep文件的内容包含进当前Makefile文件；如果Makefile中有以file.dep为目标的规则，make会先使用规则对file.dep文件进行更新，然后将更新后的file.dep文件包含进当前Makefile文件。[网上描述]
0 ]8 v4 [) m( o6 @) n$ d8 l
) {* e& a7 Y7 g3 s　　这种关于include命令功能的描述只是大体正确，但还不够清楚和准确，下面将我认为的对include命令的功能更清楚和准确的描述（以include file.dep为例）表述如下，不妥之处请读者指正。

# M$ B. O: h/ p  Q　　首先给出几个定义：由Makefile文件中的所有规则组成的集合称为U1；由file.dep文件中的所有规则组成的集合称为U2；集合U1和集合U2的并集称为集合U。

/ W6 `# ]2 L+ J' z　　Makefile中的include命令先将文件file.dep包含进当前Makefile文件（第一次包含），这样Makefile文件中就有了file.dep文件的内容；[断点A]
& L( E1 H$ Y7 }  v
2 i/ E4 W8 p! a% e0 \: [& h5 U　　然后在集合U（特别注意，这里是集合U）中检查是否有以file.dep为目标的规则。如果U中没有以file.dep为目标的规则，或者虽然有以file.dep为目标的规则，但根据依赖关系（即便在规则中的命令执行后也）不能使file.dep文件发生更新，则Makefile文件最终包含的就是file.dep文件的当前内容，include命令执行结束；[断点B]
& ~) ^3 `# O( v7 z3 b/ g; I: H7 m
　　如果集合U中有以file.dep为目标的规则，并且该规则使得file.dep文件发生了更新，则include命令会将更新后的file.dep文件再次包含进当前Makefile文件（再次包含），跳转到断点A往下继续执行。
- Q) W  A; J5 N4 ?0 d3 t; H1 G
6 h3 e. @. J3 v' S- O4 F　　这里需要澄清的有几点：

　　第一，多数情况下，U中没有规则能使file.dep文件发生更新，这就给我们这样一个假象：Makefile的include命令和C语言的include命令一样，只是简单的把file.dep文件的内容包含进当前Makefile文件，即include命令执行到断点A就执行完毕了，甚至都没有执行到断点B。

　　第二，很多情况下，file.dep文件中并不包含以file.dep为目标的规则，这就给我们另外一个假象：include file.dep后，检查是否有规则对file.dep文件进行更新时，检查的范围仅仅是集合U1，而不是集合U。
  d4 k! }$ `& f, E; o9 B$ @1 t
( p, Y2 x) S% ]+ {  _! k: @　　第三，由于多数情况下include命令会在第一次执行到断点B后结束，这就给我们第三个假象：include命令只会把file.dep文件包含一次，不会将其再次包含甚至多次包含。
( l( O6 \& h# T) I
　　以上三点就是[网上描述]不清楚，不准确，含糊之处。
, i4 F: f6 w' H* B: @5 F

9 [- L( _4 k4 J
　　为了验证以上表述，我们来设计几个小的Makefile实验。

实验一 首先，在一个文件夹中用touch命令新建如下几个文件；
1 N# H/ A- e3 H9 A: ?. m' F5 r
1 $touch a.h
8 v- e0 n8 u; [+ C8 E$ X. M2 $touch b.h
* {$ G' y- `# U7 T1 w+ p0 ~3 $touch c.h
5 ^' \8 w) f. I- O4 $touch Makefile
修改Makefile文件为以下内容：

复制代码
$ c/ j8 ~0 C# ^' Z0 a- V1 all:test
) U7 i: g* G* M4 ^; |2
2 F9 @* n( S3 A  m$ z3 test:a.h
4 test:b.h
5 test:c.h
6     @echo "hello world";
  ]) ~; B" z% g) o7     touch test;
5 j5 x2 G" H( E1 a/ h复制代码
7 h8 l8 e* ^3 M执行make命令；

( f# B4 n( }* U* K2 G7 F由于test文件不存在，所以，命令行输出以下内容：

1 $ make
2 hello world
3 touch test;
4 $ ls
5 a.h  b.h  c.h  Makefile  test
: u/ T. c0 F  R/ k! N: M从ls命令的结果可以看到，的确产生了test文件。

4 m$ Y& x0 C* y再次执行make命令，命令行输出以下内容：
2 O4 g0 ~; @+ Q2 Y: |" P6 o
1 $ make
2 make: Nothing to be done for `all'.
# A8 @3 Q5 z: ^5 P/ t这是因为当前test文件是最新生成的，比a.h，b.h和c.h都要新，所以根据规则不会再更新test文件。
! `3 ^0 ]- a* s
　　下面我们分别在更新a.h，b.h和c.h文件后执行make命令，命令行输出以下内容：
# w5 ]% }! Q# x( L( t9 e
3 E0 Y1 A1 d9 l; h) M复制代码
2 @) U8 \6 M$ e6 f9 X; T9 j1 R+ i 1 $ touch a.h
! @8 R, p, t7 t0 ~0 a3 y" c* d5 U, B 2 $ make
3 hello world
% m9 Q, z1 B3 |& O( } 4 touch test;
5
* K% v) ~9 ?, j: ~' q% c3 p& b* c 6 $ touch b.h
7 $ make
$ [) s" Q& A: ^2 Q9 [2 ?" X9 ~ 8 hello world
9 touch test;
9 B2 a0 B" P1 Y6 S& c' @# {) _10
4 ]4 q2 t5 o, V8 |' j/ E2 Q0 d! }0 B# l: b11 $ touch c.h
12 $ make
5 x: R2 m  G. H& I2 F13 hello world
' t* K  Z/ g  f" u0 Q* D8 p. o14 touch test;
3 {  o/ p) \( p0 i$ P! N复制代码
从命令行输出可知，每次都输出了“hello world”并且更新了test文件。

　　以上实验说明：在同一个Makefile文件中，如果两个或两个以上规则具有相同的目标，则在这些规则中，任一规则中的依赖文件的更新都会导致规则中的命令被执行。

7 n2 Q, Z" S2 _% g* G
" i: p8 m5 t% W% G* F6 p6 q/ i* ]
实验二 下面我们对Makefile文件做一些改动，改动后的Makefile文件内容如下；

复制代码
1 all:test
3 t+ q  X! R: X3 H2
3 test:a.h
4 e. L8 P1 Y# H  ?) y8 D7 M* y4     @echo "this is a.h";
5 test:b.h
4 x: ~/ n' ]3 ^3 E6     @echo "this is b.h";
7 test:c.h
1 G6 B. r' J2 z6 x3 I) a- c+ }8     @echo "this is c.h";
9     touch test;
复制代码
下面我们分别在更新a.h，b.h和c.h文件后执行make命令，命令行输出以下内容：

复制代码
* C/ Z$ [! \8 @0 W1 $ touch a.h(b.h,c.h,由于输出结果一样，这里为节省篇幅写在一行)
2 $ make
3 Makefile:6: warning: overriding commands for target `test'
# v5 v( S6 T7 W5 p4 Makefile:4: warning: ignoring old commands for target `test'
3 ]! m+ \- ?6 z0 X5 Makefile:8: warning: overriding commands for target `test'
6 Makefile:6: warning: ignoring old commands for target `test'
# z) J9 [$ p$ F7 k) w7 this is c.h
8 touch test;
复制代码
从执行结果可以看出，只有最后一条规则的命令得到了执行。

　　以上实验说明：在同一Makefile文件中，如果有两个或两个以上规则具有相同的目标，则在这些规则中，任一规则中的依赖文件的更新都会且仅会导致最后一个规则中的命令被执行，前面规则的命令被忽略。



/ V) A9 ?" d  j6 Y3 I实验三 下面我们再对Makefile文件做一些改动，并且新建file.dep文件。把Makefile文件中以test为目标的第一条规则抠出来放在文件file.dep中，并在原位置使用include命令把file.dep文件包含进来，修改后的Makefile文件和file.dep文件的内容分别如下：

& H1 V0 \. e" `$ m  _<file.dep>
+ ?8 {" O8 h! q1 J; H
1 test:a.h
2 ^& [4 O. K7 W/ I  N( _, I2     @echo "this is a.h";
<Makefile>

复制代码
1 all:test
3 [+ j8 P# |$ h* Y/ X2 j2
$ w; Z4 W/ a* s( I/ v3 include file.dep
- [# T/ a, T% {- C4 test:b.h
5     @echo "this is b.h";
6 test:c.h
# w2 c; Z- {" v2 [  [8 _7     @echo "this is c.h";
8     touch test;
5 W( z+ n3 X- A5 I  b% M复制代码
下面我们分别在更新a.h，b.h和c.h文件后执行make命令，命令行输出以下内容：

" t( v  Y/ P6 M' ?5 i8 \复制代码
2 v. P3 j! ]- `7 |9 ?/ Z1 $ touch a.h(b.h,c.h,由于输出结果一样，这里为节省篇幅写在一行)
7 i0 [: ?. c+ U0 T0 O/ p, y2 $ make
  o$ {! Y* {8 k# U. f7 A+ H' s3 Makefile:5: warning: overriding commands for target `test'
4 file.dep:2: warning: ignoring old commands for target `test'
* m4 z" {- Z4 R0 U4 E2 L% l& p4 m  e5 Makefile:7: warning: overriding commands for target `test'
6 Makefile:5: warning: ignoring old commands for target `test'
7 this is c.h
8 touch test;
复制代码
) t( ^" U6 J4 t: I  m从命令行输出可知，执行结果与实验二的非常相似，不同的只是第四行的警告信息发生在了file.dep文件中。

8 T+ [, |" T1 X' S　　以上实验说明：include命令的确把file.dep文件包含进了Makefile文件，并且include命令至少执行到了断点A。
1 z4 Q6 j# J$ U8 C; F( }, e
% \- U4 V2 r! [# j- j
% T9 h# H4 x- |/ [6 ]4 A; _
实验四 下面我们继续对Makefile文件和file.dep文件进行修改，并新建d.h文件；
6 K* U# j6 f8 l8 N0 z! z) H
' M" q7 U% ?) a1 $touch d.h
7 S; p% A% r' ?3 ]* A9 n  `修改后的file.dep文件和Makefile文件的内容分别如下：

<file.dep>
6 U/ A; x5 `  i8 [9 F
1 file.dep:a.h
<Makefile>

) w7 b4 M2 k: o' t: n1 all:test
3 b9 v, H  H4 J) w2 include file.dep
3 file.dep:b.h
4     @echo "test:d.h" > file.dep;
5 test:c.h
6     touch test;
" j7 f  C6 v+ ?: D我们依次输入以下命令：

1 $touch file.dep
2 $touch test
3 $make
命令行结果如下：
# [$ v5 w" C$ a% t, C0 z; B
5 L" W( z& f0 m  r$ l: O1 make: Nothing to be done for `all'.
分析一下该结果的产生过程：首先include命令先把file.dep 文件包含进Makefile文件，包含进Makefile文件的内容为file.dep:a.h。然后，在集合U中检查是否有能使得file.dep文件发生更新的规则，此时，规则
$ q2 B5 v5 p* O+ y3 S
file.dep:a.h

和规则

file.dep:b.h
    @echo "test:d.h" > file.dep;

都不能使file.dep文件发生更新，include命令在包含一次file.dep文件后执行结束。Makefile接着去执行all目标的规则，由于all依赖于test并且test文件比c.h文件新，所以会出现命令行所示的结果。
) [9 E! ?7 [, V2 ~: V
, T' V+ {5 {# t3 y下面接着依次输入以下命令：

1 $touch b.h
2 $touch d.h
; V2 }  W/ O' W) x* U# _3 $make
9 _1 n* A8 n6 C3 Q: a命令行输出：

- b, {. w: Y9 ?) l7 P1 touch test;
- P  }- X/ E/ J# w然后我们查看file.dep文件的内容，发现其内容已变为：
2 S3 Q% H$ x% y0 T. ]* V  }
1 test:d.h
, y' h1 l7 ]- c' r/ n  N依据命令行的输出结果和file.dep文件的内容，我们同样来分析一下该结果的产生过程：

7 @1 Q' x" s7 M5 g# h首先include命令先把file.dep文件包含进Makefile文件，包含进Makefile文件的内容为file.dep:a.h。然后，在集合U中检查是否有能使得file.dep文件发生更新的规则，此时，规则
" Q6 N* }( K7 Z' M. K7 [6 D
4 s4 F6 }  ?$ M$ V' hfile.dep:a.h
; n2 B* A! ?( |6 k
不能使file.dep文件发生更新，但是规则
' \2 d' i3 j! a8 E0 b/ H
  d# y* x% L8 C7 x5 f( D- nfile.dep:b.h
' `& O2 S6 `; Y1 d( v5 R3 E    @echo "test:d.h" > file.dep;

却可以使file.dep文件发生更新，所以include命令会将更新后的file.dep文件再次包含进Makefile文件，而更新后的file.dep文件的内容也变为test:d.h。然后继续在U中检查是否有规则能使file.dep文件发生更新，此时U中以file.dep为目标的规则只有
1 U: ^8 a+ |+ d. A1 s" E; E
file.dep:b.h
) O# Q+ L* i6 w; Y8 w# `) V    @echo "test:d.h" > file.dep;
6 O5 j% H+ [% ]' e& X
- p( m# d: H# h8 n并且此时的file.dep比b.h新，所以该规则中的命令不会被执行且该规则也不能使file.dep文件发生更新，include命令到此执行结束，最终包含在Makefile文件的内容为test:d.h。

　　接下来就是去执行all目标的规则了，all依赖于test，此时Makefile文件中有两条以test为目标的规则：

4 G& [, {# z3 ?- d1 z4 ctest:d.h和
* G1 P2 h' y! a! L( h+ l6 Q# a9 K
7 }( @+ P4 N2 p" y) Gtest:c.h
    touch test;
) x  _. Y% b6 M1 U8 _7 s
2 L: ]& ^$ q7 d4 F8 ~( q3 [此时test比c.h新，而d.h比test新，根据文件的新旧关系以及实验一可知，最后会输出“touch test;”，并且该命令的执行是由依赖关系test:d.h触发的。

　　以上实验说明：如果在集合U（这里是U1）中存在以file.dep为目标的规则，并且该规则使得file.dep发生了更新，则file.dep文件会被再次包含进Makefile文件。



' ?* f8 I. M) z/ c% K! D" k实验五 下面接着对Makefile文件和file.dep文件进行修改，修改后的file.dep文件和Makefile文件的内容分别如下：
* ]: E3 {% d  |0 {
<file.dep>
# y- _5 O+ @9 f& H3 b4 H* Q
" B; r0 r" D. h6 t1 file.dep:a.h
2     @echo "file.dep:b.h" > file.dep;
# A" o& n! _  B4 m3     @echo "    @echo \"hello world.\"" >> file.dep;
4     touch b.h;
<Makefile>
6 i* s# l) a9 j" `/ t, @. m' y) ~
1 all:test
* [' @. f+ P  W# M& N2
3 include file.dep
- x7 }+ x4 u4 F4 v$ H6 h4 test:c.h
7 M/ Z5 v+ E6 W( c" Q( `5     @echo "this is c.h";
然后依次执行以下命令：

1 $touch a.h
* X; P1 c1 _( b2 $touch c.h
3 $make
命令行输出结果如下：
  m/ q8 `8 p' s& Z
1 touch b.h
2 B* K) D2 b: s. C$ z2 hello world.
3 this is c.h
7 e& _+ l3 Q' h打开file.dep文件，其内容如下：
6 Z+ Y* d$ T* _* g' e/ B
1 file.dep:b.h
2     @echo "hello world."
依据命令行输出结果和file.dep文件的内容这两个方面，我们再来分析一下以上结果的产生过程：

首先，include命令将file.dep文件包含进Makefile文件，然后在集合U中查看是否有规则能使file.dep文件发生更新，而集合U2（U2包含于U）中正好有一条能使file.dep发生更新的规则，
2 \; I4 Q1 R9 H+ z+ ?9 G  |
file.dep:a.h

" R6 R% H& o: m8 v9 H4 P; s    @echo "file.dep:b.h" > file.dep;

    @echo "    @echo \"hello world.\"" >> file.dep;
! B7 }' D7 i- z8 I: q+ p4 l" J' k
    touch b.h;
6 c% O* X" b, l
7 e$ R: H# B8 T* H; ]# D1 S, v: U接着这条规则中的三条命令被执行。这样，file.dep文件的内容被重写，b.h文件被更新，输出“touch b.h”。这样完成对file.dep文件的更新后，接着把这个刚更新完的file.dep文件再次包含进Makefile文件，然后跳转到断点A继续往下执行。此时，Makefile文件中包含了file.dep文件的内容：
5 C0 ?" }6 [8 ~
file.dep:b.h
3 F- L+ b2 h# B
5 o) r6 G3 d# x/ B3 Y3 |' Y& j. |    @echo "hello world."

  D- }# ?4 x. c  y5 Z+ l. c4 b$ i注意，这也是一个以file.dep为目标的规则，且该规则在集合U中；此时，file.dep没有b.h新，根据依赖关系此规则里的命令会被执行，于是有了输出”hello world.”。但该规则并没有使file.dep文件再次发生更新，所以Makefile文件中最终包含的file.dep文件即此时的file.dep文件，内容为：
7 {( a' S# j: O& K) ~
file.dep:b.h

    @echo "hello world."
* B$ }) u9 E- E
) U- C: J5 O6 o6 t' W- p1 E接下来执行all目标的规则，输出“this is c.h”。
& U& y- u" Z+ E( F& g
　　以上实验说明：如果在集合U（这里是U2）中存在以file.dep为目标的规则，并且该规则使得file.dep发生了更新，则file.dep文件会被再次包含进Makefile文件。

& o) R9 e- j' V) [1 L; ^
. K6 z+ K1 Y5 u; {0 o, }
- k( j8 ?  W; B　　实验四和实验五分别分别演示了在集合U1、U2中存在更新被包含文件的规则情况下，被包含文件两次被include进Makefile文件的详细情形。下面我们再演示一种被包含文件多次被include进Makefile文件的情形。

% U. i( k# B9 E4 c" X

* E, |0 I/ l( B实验六 我们来编写一个简单的小程序，在一个单独的文件夹中新建以下几个文件，main.c,cola.c，cola.h和Makefile文件，它们的文件内容分别如下：
( p. Q" {+ F+ }6 v# ?$ U
<main.c>

1 #include "cola.h"
2
3 void main()
9 @0 x  l) g+ X$ u7 ^, d3 a4 {
5     cola();
6 }
<cola.h>
" J, I' V. D2 x) }6 d
# ~1 z: N! K' G1 #ifndef __COLA_H
2 #define __COLA_H
3 void cola();
3 [0 m3 f7 b3 K0 f5 u, B4 #endif
, p$ v% l+ \) |) ~. w6 J8 f<cola.c>
1 H/ c. g$ z& b/ g7 U8 l. r- o
* A4 Y- ~: N) _; A$ u2 Q/ @复制代码
! x; C! }& a  O9 Q3 E/ i: J1 #include <stdio.h>
2 #include "cola.h"
3
* ^1 |3 M; h  s# r' C4 void cola()
5 {
6     printf("I am Coca Cola!\n");
7 }
复制代码
& \8 @: ~4 R" C' a& ]0 Q1 g<Makefile>
, |" W5 @. _* q6 _
复制代码
1 dep_files=dep_dir/main.dep dep_dir/cola.dep
2 all:
3     @echo "hello world."
4 `+ P4 ?) U, f  y% b: I8 O- ^ 4
& `+ _  [: X, o8 L5 Y 5 -include $(dep_files)
- e+ S. c3 c* [* |+ e 6
7 dep_dir:
8 t  ~, V" V3 B* R6 ?/ S* S 8     mkdir $@
9
9 t& Y  G' V: J) N+ k10 dep_dir/%.dep:dep_dir %.c
11     @echo "Making $@..."
12     @set -e; \
13     rm -rf $@; \
- o4 [! s" x" x8 |( b6 X2 ^" h14     gcc -E -MM $(filter %.c,$^) > $@;
复制代码
　　该程序非常小，只是简单的输出一句话“I am Coca Cola!”。Makefile是用来控制程序的编译流程的，并且要求在程序修改后也要能适用。很明显，上面的这个不完善的Makefile并不能满足对这个简单程序进行编译的要求，但足以用来说明include命令的功能。

　　我们先在命令行中输入make命令，看看命令行显示的结果：

) c, `9 u1 ?+ y) d  ^复制代码
1 $ make
2 mkdir dep_dir
3 Making dep_dir/cola.dep...
" `  R/ i" c4 _% N+ u. A 4 Making dep_dir/main.dep...
5 Making dep_dir/cola.dep...
6 Making dep_dir/main.dep...
" u5 D" U8 n  N2 ]. k* y# S& w 7 Making dep_dir/cola.dep...
7 G; D/ A6 w  e 8 Making dep_dir/main.dep...
% {) [& e) h9 c" `$ C$ ]2 r 9 Making dep_dir/cola.dep...
( y( _7 S: D, E4 m: S" g3 f/ ]10 Making dep_dir/main.dep...
11 Making dep_dir/cola.dep...
   ……
复制代码
) ~$ w7 h5 E% v' v　　从命令行的输出可知，Makefile先创建了文件夹dep_dir，然后不停的创建文件main.dep和cola.dep，看起来像个死循环。下面我们来分析一下该Makefile的功能以及为什么会出现不停的创建文件main.dep和cola.dep的死循环。

& P% B- x% W" Y* O) \　　首先，我们编译程序的过程一般是先将.c档和.h档编译为.o档，然后对.o档进行链接生成可执行档。从这样的编译过程可以看出，.o档依赖于.c档和.h档，可执行档又依赖于.o档；这样，若对.c档和.h档进行了修改，编译时就可以通过依赖关系将修改反映到可执行档。这种依赖关系在Makefile中的表现形式就是规则，规则中的目标和跟在后面的先决条件表达的就是一种依赖关系，它控制着Makefile对程序的编译过程，.o档对.c档和.h档的依赖以及可执行档对.o档的依赖都可以用规则来表达。所以，在Makefile中用规则描述好各个文件之间的依赖关系是我们成功进行编译的基础。
- g: @" }# s( k$ d+ J& s6 n
( Y; `7 {& U5 n2 _* p; J5 l　　对于简单的程序，我们可以很容易的写出表达文件依赖关系的规则，比如该例：
8 S5 h+ |0 ?' \. r# {+ |- X8 ?
$ D2 h% u2 J: q$ E7 x　　　　　　　　　　　cola.o: cola.c cola.h
+ R2 C, Q  V2 J3 Q' u1 f
% R! e; P1 _0 ?　　　　　　　　　　　main.o: main.c cola.h

以上两条规则就分别表达了cola.o依赖于 cola.c和cola.h；main.o依赖于main.c和 cola.h。
( e1 _* @) D6 ]5 C+ u1 {
! x! {* U2 q0 {# ?( a# U　　但当程序复杂起来时，比如这样一个程序：main.c 包含了10个头文件：a0.h，a1.h，……，a9.h;而这10个头文件每个又包含了10个头文件：00.h，…，09.h；……；90.h，…，99.h；这样要编译生成mian.o，我们需要手工在Makefile中添加以下规则：
3 N( ?2 v0 T* j% J0 p& X
　　　　　　　　　　　mian.o:main.c  a0.h … a9.h 00.h … 09.h …… 90.h … 99.h
: m+ ^7 Z7 {& _( ?/ Q- A
后面的依赖文件多达111个，这是一件多么繁琐、艰巨且易错的事情！更糟糕的是，当其中任何一个头文件发生更改时，比如a3.h，34.h和79.h又发生了更改，它们又包含了一些新的头文件并去掉了一些没用的头文件，这时还要对上面的规则进行相应的修改，这几乎是一件手工不能完成的事情！谢天谢地，这件事我们可以用命令自动完成^-^。这个命令就是：
: z  X* u2 G  g9 A9 E1 R
. Y7 A/ z7 l; w+ c　　　　　　　　　　　gcc -E -MM main.c;

5 C) [9 V' h4 m) {3 B- F该命令会产生以下输出：

　　　　　　　　　　　mian.o:main.c  a0.h … a9.h 00.h … 09.h …… 90.h … 99.h
7 O0 R. x& O4 |- P9 j6 e
( E) a$ a5 Z2 x. s4 S3 I9 U它正是我们需要的规则。如果我们把这条自动生成的规则重定向到一个文件（比如main.dep）中,然后把该文件include到当前Makefile中，我们就不用手工在Makefile中添加了，这样看起来很美好～～

　　假设我们已经在某处生成了main.dep文件，现在我们可以描绘下Makefile的大体轮廓了：
2 U' J( L1 G( n8 d8 r: T+ W& j9 H7 L
( @# s( B0 h" X8 M0 b6 }" E1 l5 T2 ]! u# |1 all:main.exe
2 include main.dep
& t- r8 R8 a2 h, d& f& \) R! D3 main.exe: main.o
  Z# ~+ c* G& e8 C- G. V( i4     gcc -o $@ $^
5 main.o:main.c
1 V" x$ _9 E2 f6     gcc -o $@ -c $^
9 p9 ~, h# j, h  X从上面这个大体的轮廓可以看出，main.dep被包含进了Makefile文件，也就是规则
" Q0 [. w: b& A, k1 K
. S2 e% X9 K% r% N　　　　　　　　　　　mian.o:main.c  a0.h … a9.h 00.h … 09.h …… 90.h … 99.h
, w5 V" j! K% b9 A
被包含进Makefile文件，结合实验一可知，后面的111个依赖文件中的任何一个发生了修改都会导致最终的main.exe文件被重新生成，而这正是我们需要的。

, H8 S3 O; x" C3 `6 [7 t2 e   
( n5 m2 Y( V4 M& z
　　现在我们还有一个问题要面对：刚才我们假设已经在某处生成了main.dep文件，也就是说在Makefile开始程序编译这个主要流程前，某处需要先把main.dep文件准备好，以供Makefile使用，显然某处的内容应该要包含类似gcc -E -MM main.c > main.dep的命令，那我们将某处放在哪里合适呢？

5 l. p& i+ S2 U$ g　　要回答这个问题，我们先要知道某处具有的一个最重要的特点，那就是它的内容的执行先于程序编译的主流程。我们再来看下实验四和实验五，从这两个实验可知，以被包含文件file.dep为目标的规则总是被先执行，而代表着程序编译主流程的all目标所牵连的规则在其后执行。这样，不难想象，如果我们将某处设计成以main.dep为目标的规则，并在规则的命令部分添加上产生main.dep文件的命令，类似“gcc -E -MM main.c > main.dep”，并把某处放置在Makefile文件中，则当用include命令把main.dep包含进Makefile文件后，某处的内容自然会先执行，然后代表程序编译主流程的all目标所牵连的规则之后再执行。

　　这个方法很精巧，解决了某处到底放哪里合适的问题，而我们需要做的就是把某处设计成以main.dep为目标的规则并且规则的命令部分能够生成main.dep文件，然后将某处放在Makefile文件中。我们面对的问题现在有了明确的方向，一切看起来都很美好！让我们来憧憬一下我们的Makefile文件的大体轮廓，它应该是酱紫滴：
0 O% I& H) X4 j
复制代码
7 N" T' V8 ]1 e1 all:main.exe
# A" t$ P/ Y1 F" H2 include main.dep
* D: e) l, ?* c, O( V! ?3 Y: U! I3 main.exe: main.o
4     gcc -o $@ $^
7 c: d: j: q; V- L5 main.o:main.c
. Z0 Y1 f# R( y+ w. ^" W3 M' M8 |6     gcc -o $@ -c $^
% s7 X7 A, B- o* r8 h+ B. N7 某处
8 main.dep：
9     gcc -E -MM main.c > main.dep
# |  l0 d; V4 @8 L6 q, i复制代码

2 g- J& {9 k  z6 \) k2 |$ d* b2 s& ]# @
    现在回过头来看我们的cola程序，分析一下cola程序的Makefile死循环的原因。为了便于观察，再将Makefile文件内容列出如下：
, H1 ]" y/ d; O: A/ C
复制代码
; Z+ O) E  Q6 `+ K  H. k1 l) U* f. O# i 1 dep_files=dep_dir/main.dep dep_dir/cola.dep
2 all:
, Z* `( `8 K2 S, i2 ~, a# r 3     @echo "hello world."
4
* m" W: c" n3 u! q  x 5 -include $(dep_files)
6
$ R; U! i3 o2 N9 u" m8 B 7 dep_dir:
8     mkdir $@
% z' f7 P, n1 Q' \& x8 j 9
10 dep_dir/%.dep:dep_dir %.c
11     @echo "Making $@..."
12     @set -e; \
13     rm -rf $@; \
- |: ?, b, m1 X2 P14     gcc -E -MM $(filter %.c,$^) > $@;
( `- n2 i4 Z4 }5 ^复制代码
    从该Makefile可以看出，它的主要功能是为当前文件夹中的main.c和cola.c文件自动生成依赖文件main.dep和cola.dep，并且为main.dep和cola.dep在当前文件夹中建立了单独的文件夹dep_dir，以使当前文件夹中的文件有条理。

+ c2 l+ \) Z3 b- x% P! K& z    当该Makefile开始执行时，include先在当前文件夹中查看dep_dir/main.dep和 dep_dir/cola.dep是否存在，结果是否定的。不过没关系，include命令前的符号“-”标示了当被包含文件不存在时不予理会，继续往下执行。下面在集合U中检查是否有以dep_dir/main.dep和 dep_dir/cola.dep为目标的规则，答案是肯定的，就在某处的规则：
# j* a; n' j1 O* n% g, W
dep_dir/%.dep:dep_dir %.c
) l$ u  x# `9 M6 _
, a! f! W; w; n' q- L( p: @% {    @echo "Making $@..."

    @set -e; \

    rm -rf $@; \
! O2 h, ^# L! d3 c. j& q7 V
9 I! s0 i1 ~; h2 }. i: K! H    gcc -E -MM $(filter %.c,$^) > $@;

从该规则的依赖关系dep_dir/%.dep:dep_dir %.c可知，dep_dir/main.dep和dep_dir/cola.dep依赖于dep_dir，而dep_dir现在不存在，所以以 dep_dir为目标的规则
. p4 ?. |4 _, W- y
dep_dir:

    mkdir $@

被执行，结果就是我们命令行的第一行输出：

3 s3 I' x  X" i/ S$ l+ Zmkdir dep_dir

产生了文件夹dep_dir。

接着，根据依赖关系，会执行该规则中的命令，在命令行产生输出：

Making dep_dir/cola.dep...
5 U% O9 Y+ X" T& t  u
& p4 c: s- b' K, cMaking dep_dir/main.dep...
+ T+ V; ?2 v3 k- O$ P4 b* ^
并在文件夹dep_dir中产生依赖文件cola.dep和main.dep。现在有了新产生的依赖文件cola.dep和main.dep，根据实验四和试验五，include命令会把这两个新产生的文件再次包含进Makefile文件，然后在集合U中检查是否有以dep_dir/main.dep和dep_dir/cola.dep为目标的规则，答案依旧是肯定的：
9 K( b3 R1 u! N7 n
. z$ n$ _$ q* W$ `; [! I) ~8 \! xdep_dir/%.dep:dep_dir %.c
- ~( r6 n( S2 L* i* H! Q2 _
1 h( O) k- I% O    @echo "Making $@..."

" D5 n: M" p, Z5 d. W    @set -e; \

    rm -rf $@; \
7 x4 b5 x" M* d* P  V# Y: T4 r
    gcc -E -MM $(filter %.c,$^) > $@;
3 |2 ]8 w3 i* G, Y
乍一看，我们没有手工做过对dep_dir,mian.c和cola.c的更新，理论上就不会导致cola.dep和main.dep的更新，include命令应该到此执行结束，可命令行不停的输出：

Making dep_dir/cola.dep...

) X4 {* K" Z( qMaking dep_dir/main.dep...

# Z, s" X; I. R; N# O5 E2 lMaking dep_dir/cola.dep...
* o5 a/ d1 p% f! m; i
. W/ j4 J4 p7 `3 J. wMaking dep_dir/main.dep...
* f1 H5 e$ w% s) T! O  A
  w3 C7 L( d( J. X/ h却和我们的认识有差别，它分明在向我们强势宣告dep_dir,mian.c或cola.c有更新，而我们自己也真的没有手工对这几个文件进行过任何更新，好无奈～～

   

　　为了找出问题究竟在哪，我们来做个小实验。新建文件夹test，在test中新建文件夹test_dir，然后在test_dir中依次新建文件test_file1和test_file2，注意在新建完test_file1后使用stat命令查看一下test_dir和test_file1的时间戳，同样在新建完然后test_file2后也使用stat命令查看一下test_dir和test_file2的时间戳，如下所示：
" B" V: ?& P6 m" U. J9 l" V
4 b$ K0 n  p: {7 _6 t2 s复制代码
+ ?4 @% [6 g0 l8 y) n6 W; q2 P* a 1 test $ touch test_dir/test_file1
2 test $ stat test_dir/
3   File: ‘test_dir/’
, e) m: N3 M, Y# d% k 4   Size: 4096          Blocks: 8          IO Block: 4096   directory
5 Device: 80bh/2059d    Inode: 3675101     Links: 2
6 Access: (0755/drwxr-xr-x)  Uid: ( 1000/ )   Gid: ( 1000/ )
7 Access: 2016-03-25 23:17:22.488157324 +0800
8 Modify: 2016-03-25 23:27:18.084130770 +0800
: @4 V9 T+ d9 m$ b8 L 9 Change: 2016-03-25 23:27:18.084130770 +0800
! H0 f5 f3 {* \9 Z! T10  Birth: -
11 test $ stat test_dir/test_file1
12   File: ‘test_dir/test_file1’
3 d) I" [8 d0 B" I1 g) D13   Size: 0             Blocks: 0          IO Block: 4096   regular empty file
/ b0 p: a8 W5 C6 C. V14 Device: 80bh/2059d    Inode: 3675102     Links: 1
15 Access: (0644/-rw-r--r--)  Uid: ( 1000/ )   Gid: ( 1000/ )
8 ~2 z" ^4 `+ n6 N16 Access: 2016-03-25 23:27:18.084130770 +0800
7 B7 A  I: M+ K! w8 `4 ~17 Modify: 2016-03-25 23:27:18.084130770 +0800
4 @) S% k& y* y3 Z- B( U7 V1 f4 C18 Change: 2016-03-25 23:27:18.084130770 +0800
/ V+ S( }1 S# g7 }( q  ~6 {19  Birth: -
20 test $ touch test_dir/test_file2
0 x$ q# m9 E& O21 test $ stat test_dir/
! ?  l5 d( h0 {22   File: ‘test_dir/’
( k6 N8 E% T2 m23   Size: 4096          Blocks: 8          IO Block: 4096   directory
4 m# K  J+ E- l6 |5 ?24 Device: 80bh/2059d    Inode: 3675101     Links: 2
25 Access: (0755/drwxr-xr-x)  Uid: ( 1000/ )   Gid: ( 1000/ )
26 Access: 2016-03-25 23:27:35.916129975 +0800
27 Modify: 2016-03-25 23:28:07.332128575 +0800
0 T5 ^+ W% y) w" u7 a4 P28 Change: 2016-03-25 23:28:07.332128575 +0800
( k8 m4 C: E) N$ @. `29  Birth: -
30 test $ stat test_dir/test_file2
( K+ R* [( d) y2 z+ p( q& Q31   File: ‘test_dir/test_file2’
$ y1 r5 @7 U! b& J% I4 k32   Size: 0             Blocks: 0          IO Block: 4096   regular empty file
% c/ H. g1 I3 B5 @1 H33 Device: 80bh/2059d    Inode: 3675112     Links: 1
' w9 B- s- L. a: P) U, f; @, W# I34 Access: (0644/-rw-r--r--)  Uid: ( 1000/ )   Gid: ( 1000/ )
! I' f0 d/ y, R5 ?$ o/ ]35 Access: 2016-03-25 23:28:07.332128575 +0800
" d& Z. V% }5 O. W4 O36 Modify: 2016-03-25 23:28:07.332128575 +0800
37 Change: 2016-03-25 23:28:07.332128575 +0800
2 {* _! @0 {$ a$ w3 b38  Birth: -
! P! `' s( [% _: {5 W- h4 p/ A复制代码
% M2 c; N, H; l# q3 q上面的输出结果看起来比较繁杂，我们抽出对我们有用的文件更新时间来做一下的对比：
* R6 q  ~8 u2 w. ]- I! X! K' D
9 I1 q' S$ S, W# Y7 C创建test_file1后test_dir和test_file1 的更新时间为

  r/ ?  ?6 @( S! c" j( I' qtest_dir        2016-03-25 23:27:18.084130770
' v2 j' j" O+ H, L* |8 Stest_file1        2016-03-25 23:27:18.084130770
/ J8 D+ p- E6 y, V9 o- I- Z
. {5 \% r3 e1 v9 I6 @

7 U: ~7 W" P& a* Q- N( z

6 e8 h. P) k: [9 s: `5 a/ ?
5 {4 [  x1 u' R3 f" k2 \" o创建test_file2后test_dir和test_file2 的更新时间为
' }, B" F7 q# j1 `
# F: ^( k, g+ {8 K: W6 K+ rtest_dir        2016-03-25 23:28:07.332128575
test_file2        2016-03-25 23:28:07.332128575
+ G; g, x) D# z
* t, }( j9 H. z2 o1 S5 J


% T5 ^7 x! u  a. K

　　可见，在test_dir文件夹中每次创建（删除）一个新的文件后，系统都会自动修改test_dir的更新时间。这样在创建test_file1后，虽然test_dir和test_file1的更新时间相同，但在创建test_file2后，test_dir的时间戳已经比test_file1文件的时间戳要新了。

　　

" Q4 o  ]8 V$ v1 v, Q　　现在让我们再来看看这个让我们无奈的死循环。从命令行的输出情况可以看出，Makefile在dep_dir文件夹中先创建依赖文件cola.dep，然后再创建依赖文件main.dep。但此时依赖文件main.dep在文件夹dep_dir中的创建，导致了dep_dir的时间戳发生了更新，dep_dir要比cola.dep新。规则中的命令被执行完后，cola.dep，main.dep和dep_dir都发生了更新。

( Q# l  }6 Q* q0 v# D    根据实验四和实验五，include会将cola.dep和main.dep再次包含进Makefile文件，然后在集合U中检查是否有规则能使得cola.dep和main.dep产生更新，过程如下：

对于cola.dep，在以下规则中，
* D, ?- R; a: W$ i1 |
dep_dir/%.dep:dep_dir %.c
4 c" R8 i/ \! @
, R9 C. m7 J; D' [6 Y) o3 l' N    @echo "Making $@..."
2 u! ]7 |$ E* A  a0 t- c& l
    @set -e; \
$ g8 c  G) P  C' I& y
; p/ i$ z* ~0 {. _" o  s' C+ M    rm -rf $@; \
7 o0 j7 U; B% e
    gcc -E -MM $(filter %.c,$^) > $@;

+ H3 }; Y; c; p  V! R由于此时的dep_dir要比cola.dep新，所以规则中的命令被执行，规则中的删除和新建操作导致dep_dir和cola.dep都得到了更新，这样dep_dir又比main.dep新了。对于main.dep，在上面规则中，它依赖于dep_dir和main.c，由于上一步的操作使得dep_dir比main.dep新，所以规则中的命令也会被执行，规则中的删除和新建操作导致dep_dir和main.dep都得到了更新，这样dep_dir又比cola.dep新了。

0 B$ |! p  ~7 F    这样产生的结果就是 cola.dep，main.dep和dep_dir都发生了更新，且dep_dir要比cola.dep新。include命令会将更新后的cola.dep和main.dep重新包含进Makefile文件中，然后在集合U中检查是否有规则能使得cola.dep和main.dep产生更新。——这一幕重新上演！死循环了！
& c; m) v' j& K6 \# b
9 G6 j7 c  r# w! ~9 Q/ s    以上实验和分析说明：include命令在一定条件下可以将被包含文件（cola.dep和main.dep）多次包含进Makefile文件。
2 ?' B- L& L/ h% C8 F
, O  O$ m( t# z    现在我们已经知道了产生死循环的原因，即：cola.dep和main.dep在规则中所依赖的dep_dir总是会比这两个文件中的一个要新。那么我们如何避免这个死循环呢？方法很简单，我们可以添加一个判断条件，只有在dep_dir不存在时，才让cola.dep和main.dep依赖于dep_dir，以创建该文件夹；当dep_dir已经存在时，就不让cola.dep和main.dep依赖于dep_dir了，这样就避免了dep_dir比cola.dep或main.dep新的时候，规则中的命令会不停地循环执行情况的发生。修改方法如下所示：

6 S3 R8 ~& z/ G0 s; g6 ^3 f<Makefile>
: d6 Y/ k$ A- ]: u
复制代码
8 [9 X5 _8 f6 T% w4 U0 m! A 1 dep_files=dep_dir/main.dep dep_dir/cola.dep
) v& T# w% {  ^7 i) _" F- H  R 2
4 V1 p1 F# y. [# @ 3 ifeq ("$(wildcard dep_dir)", "")
4 DEP_DIR_DEPS := dep_dir
5 endif
) q- s/ w$ k0 r/ m! L- I# a- M% `+ z 6
7 all:
  f' C( @) T" R- `: a0 S 8     @echo "hello world."
$ W; P: G: R4 f: o/ @, r* Q 9
10 -include $(dep_files)
11
12 dep_dir:
" n/ p- E- `3 b# H13     mkdir $@
: F% N- n1 N/ w14
4 |- Q8 B. Y$ E# e. A  |15 dep_dir/%.dep:$(DEP_DIR_DEPS) %.c
& {5 f/ R% M6 }! w1 m16     @echo "Making $@..."
17     @set -e; \
2 O% \+ j$ E% t+ x18     rm -rf $@; \
19     gcc -E -MM $(filter %.c,$^) > $@;
复制代码
0 u6 l# f* o( Y, D! X% M3 A0 B现在我们来执行一下Make命令，命令行输出如下：
; x9 C. S4 n  J! n
2 A7 x1 z: \6 \+ E1 $ make
2 mkdir dep_dir
3 Making dep_dir/cola.dep...
) n4 Z6 w- J" t& t: {& i7 X2 ^4 Making dep_dir/main.dep...
2 G: I  P5 D2 v. g# L- j5 hello world.
这个输出结果正是我们所预期的，一切看起来都很美好～～

    总结：通过以上六个实验，我们一步步详细分析了Makefile中的include命令的功能，看起来和[网上描述]还是有很大的差别。该文章前后修改了多次，共用15页A4纸来描述一个include命令的功能，只是想把其刻画的更准确，也使读者理解起来更易懂。对于文中仍有的不妥之处，还请读者指出。也希望各位读者在网上发文时尽量将内容表达清楚（我也是实在搞不清网上含糊的描述才忍不了写出此文），以便别的读者理解学习。

liuchengliaaa

话说以前玩过winavr   
想起艺芯写的那个gcc入门教程，学习用的是atmega16l
都忘的差不多了。

kenson

liuchengliaaa 发表于 2018-6-8 20:26
话说以前玩过winavr   
9 ^2 j/ r+ b+ K* ?( \' R4 b% t想起艺芯写的那个gcc入门教程，学习用的是atmega16l
都忘的差不多了。

gcc不只是单单用在AVR的，但用不上也是件好事。

kenson

不知道为什么有些转载过来的网站好多格式都不一样，搞得只能用纯文字