Linux Makefile学习（一）

本文是最近学习Linux Makefile的一些内容，Linux版本号为2.6.32。Makefile内容较多，分成了几个阶段。这里写下来，作为积累，

也想和大家分享下学习过程。

==============================================================================

VERSION = 2

PATCHLEVEL = 6

SUBLEVEL = 22

EXTRAVERSION = .6

NAME = Holy Dancing Manatees, Batman!

# *DOCUMENTATION*

# To see a list of typical targets execute "make help"

# More info can be located in ./README

# Comments in this file are targeted only to the developer, do not

# expect to learn how to build the kernel reading this file.

# *文档*

# 执行“make help”可以查看典型的目标

# 更多信息可以在./README中查看

# 这个文件的内容只适合不期望知道怎么构建内核的开发者来阅读。

# Do not:

# o use make's built-in rules and variables

# (this increases performance and avoid hard-to-debug behavour);

# o print "Entering directory ...";

# 不做哪些： ps：下面列出的都是makefile做的事情

# o 使用内嵌规则和变量

（这样做可以提高性能，同时便于调试）

# o 打印“Entering directory ...”

MAKEFLAGS += -rR --no-print-directory r 取消所有内嵌的隐含规则

R 取消 make 内嵌的隐含变量

--no-print-directory 在 make 进入一个目录读取 Makefile 之前打印工作目录

# We are using a recursive build, so we need to do a little thinking

# to get the ordering right.

#

# Most importantly: sub-Makefiles should only ever modify files in

# their own directory. If in some directory we have a dependency on

# a file in another dir (which doesn't happen often, but it's often

# unavoidable when linking the built-in.o targets which finally

# turn into vmlinux), we will call a sub make in that other dir, and

# after that we are sure that everything which is in that other dir

# is now up to date.

#

# The only cases where we need to modify files which have global

# effects are thus separated out and done before the recursive

# descending is started. They are now explicitly listed as the

# prepare rule.

# 我们使用递归的形式构建，所以我们需要花些心思了解权限职责问题。

#

# 最主要的：子Makefiles应该只修改它们自己目录下的文件。如果在某个目录下，我们依赖另一个目录下的文件

# （这种情况不经常发生，但当链接built-in.o文件时，这是不可避免的，built-in.o文件最终链接进vmlinux），

# 我们将调用另一个目录下的子make，在那之后，我们确定在这个目录下的所有文件都是最新的。

#

# 唯一的情况我们需要修改会造成全局影响的文件，这种情况被分离出来，在递归开始前完成。他们被作为预备规

# 则明确列出来了。

# To put more focus on warnings, be less verbose as default

# Use 'make V=1' to see the full commands

# 为了专注于警告信息，默认信息为非冗余的。

# 用‘make V=1’可以看完整的命令。

ifdef V

ifeq ("$(origin V)", "command line") //判断V是否为命令行参数

KBUILD_VERBOSE = $(V)

endif

endif

ifndef KBUILD_VERBOSE

KBUILD_VERBOSE = 0

endif

# Call a source code checker (by default, "sparse") as part of the

# C compilation.

#

# Use 'make C=1' to enable checking of only re-compiled files.

# Use 'make C=2' to enable checking of *all* source files, regardless

# of whether they are re-compiled or not.

#

# See the file "Documentation/sparse.txt" for more details, including

# where to get the "sparse" utility.

# 在C编译时使用代码检测工具（默认为“sparse”） sparse是由linux之父开发的, 目的就是提供一个静态检查

# 代码的工具, 从而减少linux内核的隐患

#

# 使用‘make C=1’使能仅检测预编译文件。

# 使用‘make C=2’使能检测所有文件，不论是不是预编译文件

#

# “Documentation/sparse.txt”中有更详细的描述，包括如何获取“sparse”效用。

ifdef C

ifeq ("$(origin C)", "command line")

KBUILD_CHECKSRC = $(C)

endif

endif

ifndef KBUILD_CHECKSRC

KBUILD_CHECKSRC = 0

endif

# Use make M=dir to specify directory of external module to build

# Old syntax make ... SUBDIRS=$PWD is still supported

# Setting the environment variable KBUILD_EXTMOD take precedence

# 使用“make M=dir”来指明所要构建的外部模块目录。

# 旧的语法“make ... SUBDIRS=$PWD”仍然被支持

# 设置环境变量KBUILD_EXTMOD优先级更高。

ifdef SUBDIRS

KBUILD_EXTMOD ?= $(SUBDIRS) //KBUILD_EXTMOD没有定义时等于$(SUBDIRS)

endif

ifeq ("$(origin M)", "command line")

KBUILD_EXTMOD := $(M)

endif

# kbuild supports saving output files in a separate directory.

# To locate output files in a separate directory two syntaxes are supported.

# In both cases the working directory must be the root of the kernel src.

# 1) O=

# Use "make O=dir/to/store/output/files/"

#

# 2) Set KBUILD_OUTPUT

# Set the environment variable KBUILD_OUTPUT to point to the directory

# where the output files shall be placed.

# export KBUILD_OUTPUT=dir/to/store/output/files/

# make

#

# The O= assignment takes precedence over the KBUILD_OUTPUT environment

# variable.

# kbuild支持将输出文件保存在单独的目录下。

# 将输出文件防止在单独的目录下有两种语法被支持。

# 两种方法的工作目录必须是内核源码的根目录。

# 1) O=

# 使用"make O=dir/to/store/output/files/"

#

# 2) 设置KBUILD_OUTPUT变量

# 设置KBUILD_OUTPUT环境变量去指明输出文件放置的目录。

# export KBUILD_OUTPUT=dir/to/store/output/files/

# make

#

# “O=”的方式比设置KBUILD_OUTPUT环境变量更优先考虑。

# KBUILD_SRC is set on invocation of make in OBJ directory

# KBUILD_SRC is not intended to be used by the regular user (for now)

# KBUILD_SRC在OBJ目录下调用make时设置的。

# KBUILD_SRC现在不是为了让一般用户使用的。

ifeq ($(KBUILD_SRC),)

# OK, Make called in directory where kernel src resides

# Do we want to locate output files in a separate directory?

# Make在内核源文件目录下调用。

# 我们是否想将输出文件放置到独立的目录中？

ifeq ("$(origin O)", "command line") //判断O是否为命令行参数

KBUILD_OUTPUT := $(O)

endif

# That's our default target when none is given on the command line

# 当命令行中没有给出目标时，这作为默认目标。

PHONY := _all

_all:

# Cancel implicit rules on top Makefile

# 取消顶层Makefile隐含规则

$(CURDIR)/Makefile Makefile: ; //没有查清楚此语句如何取消隐含规则

ifneq ($(KBUILD_OUTPUT),)

# Invoke a second make in the output directory, passing relevant variables

# check that the output directory actually exists

PS：这个地方翻译不太理解，大致意思是检测KBUILD_OUTPUT目录是否存在。

saved-output := $(KBUILD_OUTPUT)

KBUILD_OUTPUT := $(shell cd $(KBUILD_OUTPUT) && /bin/pwd) //KBUILD_OUTPUT变为绝对路径

$(if $(KBUILD_OUTPUT),, \

$(error output directory "$(saved-output)" does not exist))

//如果KBUILD_OUTPUT为空，打印错误输出*** output directory "xxx" does not exist。

PHONY += $(MAKECMDGOALS) sub-make //MAKECMDGOALS指定make的终极目标

$(filter-out _all sub-make $(CURDIR)/Makefile, $(MAKECMDGOALS)) _all: sub-make

$(Q)@: //过滤掉$(MAKECMDGOALS)中_all sub-make

//$(CURDIR)/Makefile

sub-make: FORCE

$(if $(KBUILD_VERBOSE:1=),@)$(MAKE) -C $(KBUILD_OUTPUT) \

KBUILD_SRC=$(CURDIR) \

KBUILD_EXTMOD="$(KBUILD_EXTMOD)" -f $(CURDIR)/Makefile \

$(filter-out _all sub-make,$(MAKECMDGOALS))

//(if $(KBUILD_VERBOSE:1=),@)使用了变量的替换引用。格式为“ $(VAR:A=B)”（或者“ ${VAR:A=B}”），意思是，

//替换变量“ VAR”中所有“ A”字符结尾的字为“ B”结尾的字。KBUILD_VERBOSE结尾为1时，整个表达式为空，否则

//为@，为@时是希望后面的命令能够静默执行。

# Leave processing to above invocation of make

# 离开处理到上面的make调用

skip-makefile := 1

endif # ifneq ($(KBUILD_OUTPUT),)

endif # ifeq ($(KBUILD_SRC),)

# We process the rest of the Makefile if this is the final invocation of make

# 如果这是最后的make调用，我们处理Makefile剩余部分

ifeq ($(skip-makefile),)

# If building an external module we do not care about the all: rule

# but instead _all depend on modules

# 如果是构建一个外部模块，我们不用关心all的规则，但是需要关系_all所以来的modules

PHONY += all

ifeq ($(KBUILD_EXTMOD),)

_all: all

else

_all: modules

endif

srctree := $(if $(KBUILD_SRC),$(KBUILD_SRC),$(CURDIR))

objtree := $(CURDIR)

src := $(srctree)

obj := $(objtree)

VPATH := $(srctree)$(if $(KBUILD_EXTMOD),:$(KBUILD_EXTMOD))

export srctree objtree VPATH

# SUBARCH tells the usermode build what the underlying arch is. That is set

# first, and if a usermode build is happening, the "ARCH=um" on the command

# line overrides the setting of ARCH below. If a native build is happening,

# then ARCH is assigned, getting whatever value it gets normally, and

# SUBARCH is subsequently ignored.

# SUBARCH通知自定义模式构建什么样的底层架构。这是最先设置的地方，如果自定义模式构建开始了，"ARCH=um"

# 命令行参数重写ARCH设置。如果本地构建开始了，ARCH被指定好了，不管获取到什么值，SUBARCH随后都会被忽

# 略。

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/ )

# Cross compiling and selecting different set of gcc/bin-utils

# ---------------------------------------------------------------------------

#

# When performing cross compilation for other architectures ARCH shall be set

# to the target architecture. (See arch/* for the possibilities).

# ARCH can be set during invocation of make:

# make ARCH=ia64

# Another way is to have ARCH set in the environment.

# The default ARCH is the host where make is executed.

# 交叉编译，选择不同的gcc/bin-utils设置。

# ---------------------------------------------------------------------------

#

# 当执行别的架构下交叉编译，ARCH被设置成目标架构.（看arch/*可以知道支持哪些架构）。

# ARCH在make调用的过程中可以设置：

# make ARCH=ia64

# 另外一种方法是在环境变量中设置ARCH。

# 默认的ARCH是make执行的主机端架构。

# CROSS_COMPILE specify the prefix used for all executables used

# during compilation. Only gcc and related bin-utils executables

# are prefixed with $(CROSS_COMPILE).

# CROSS_COMPILE can be set on the command line

# make CROSS_COMPILE=ia64-linux-

# Alternatively CROSS_COMPILE can be set in the environment.

# Default value for CROSS_COMPILE is not to prefix executables

# Note: Some architectures assign CROSS_COMPILE in their arch/*/Makefile

# CROSS_COMPILE指定编译过程中使用的所有可执行文件的前缀。只有gcc和bin-utils可执行文件才会有

# $(CROSS_COMPILE)前缀。

# CROSS_COMPILE可以在命令行中设置。

# make CROSS_COMPILE=ia64-linux-

# CROSS_COMPILE也可以在环境变量中设置。

# CROSS_COMPILE默认值是没有前缀的。

# 注意：一些架构在它们arch/*/Makefile文件中指定CROSS_COMPILE变量。

export KBUILD_BUILDHOST := $(SUBARCH)

ARCH ?= arm

CROSS_COMPILE ?= arm-linux-

# Architecture as present in compile.h

UTS_MACHINE := $(ARCH)

SRCARCH := $(ARCH)

# Additional ARCH settings for x86

# 对x86架构有额外设置

ifeq ($(ARCH),i386)

SRCARCH := x86

endif

ifeq ($(ARCH),x86_64)

SRCARCH := x86

endif

# Additional ARCH settings for sparc

ifeq ($(ARCH),sparc64)

SRCARCH := sparc

endif

# Additional ARCH settings for sh

ifeq ($(ARCH),sh64)

SRCARCH := sh

endif

# Where to locate arch specific headers

# 放置架构特定头文件的目录

hdr-arch := $(SRCARCH)

ifeq ($(ARCH),m68knommu)

hdr-arch := m68k

endif

KCONFIG_CONFIG ?= .config

# SHELL used by kbuild

# kbuild使用的SHELL

CONFIG_SHELL := $(shell if [ -x "$$BASH" ]; then echo $$BASH; \ //如果$BASH存在且是可执行的则为真

else if [ -x /bin/bash ]; then echo /bin/bash; \

else echo sh; fi ; fi)

HOSTCC = gcc

HOSTCXX = g++

HOSTCFLAGS = -Wall -Wmissing-prototypes -Wstrict-prototypes -O2 -fomit-frame-pointer

HOSTCXXFLAGS = -O2

//-Wall 基本打开了所有需要注意的警告信息。

//-Wmissing-prototypes

//-Wstrict-prototypes 使用了非原型的函数声明时给出警告

//-O2 编译优化级别

//-fomit-frame-pointer

# Decide whether to build built-in, modular, or both.

# Normally, just do built-in.

# 决定构建built-in还是modular，或者两者同时构建。

# 通常之构建built-in。

KBUILD_MODULES :=

KBUILD_BUILTIN := 1

# If we have only "make modules", don't compile built-in objects.

# When we're building modules with modversions, we need to consider

# the built-in objects during the descend as well, in order to

# make sure the checksums are up to date before we record them.

# 如果我们执行"make modules"，就不编译built-in目标。

# 当我们使用modversions构建模块，我们需要在进入下层目录是考虑built-in目标，这是为了确保在我们记录

# 他们之间，校验码是最新的。PS:这点不理解，翻译的也有问题。

ifeq ($(MAKECMDGOALS),modules)

KBUILD_BUILTIN := $(if $(CONFIG_MODVERSIONS),1)

endif

# If we have "make <whatever> modules", compile modules

# in addition to whatever we do anyway.

# Just "make" or "make all" shall build modules as well

# 如果我们执行了"make <whatever> modules"，就会编译我们指定的模块。

# 只执行"make"或"make all"将会编译所有模块。

ifneq ($(filter all _all modules,$(MAKECMDGOALS)),)

KBUILD_MODULES := 1

endif

ifeq ($(MAKECMDGOALS),)

KBUILD_MODULES := 1

endif

export KBUILD_MODULES KBUILD_BUILTIN

export KBUILD_CHECKSRC KBUILD_SRC KBUILD_EXTMOD

# Beautify output

# ---------------------------------------------------------------------------

#

# Normally, we echo the whole command before executing it. By making

# that echo $($(quiet)$(cmd)), we now have the possibility to set

# $(quiet) to choose other forms of output instead, e.g.

#

# quiet_cmd_cc_o_c = Compiling $(RELDIR)/$@

# cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<

#

# If $(quiet) is empty, the whole command will be printed.

# If it is set to "quiet_", only the short version will be printed.

# If it is set to "silent_", nothing will be printed at all, since

# the variable $(silent_cmd_cc_o_c) doesn't exist.

#

# A simple variant is to prefix commands with $(Q) - that's useful

# for commands that shall be hidden in non-verbose mode.

#

# $(Q)ln $@ :<

#

# If KBUILD_VERBOSE equals 0 then the above command will be hidden.

# If KBUILD_VERBOSE equals 1 then the above command is displayed.

# 美化输出

# ---------------------------------------------------------------------------

#

# 通常我们在执行命令前会输出整个命令。通过echo $($(quiet)$(cmd))，我们现在可以设置$(quiet)去选择别的

# 输出格式，例如：

#

# quiet_cmd_cc_o_c = Compiling $(RELDIR)/$@

# cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<

#

# 如果$(quiet)为空，整个命令都会被打印。

# 如果$(quiet)被设置成"quiet_"，只有会打印简短的版本。

# 如果$(quiet)被设置成"silent_"，什么都不会打印，因为$(silent_cmd_cc_o_c)值不存在。

#

# 一个简单的变量$(Q)被用于命令行的前缀——这对于在非冗余模式下隐藏命令非常有用。

#

# $(Q)ln $@ :<

#

# 如果KBUILD_VERBOSE等于0，上面的命令就会被隐藏。

# 如果KBUILD_VERBOSE等于1，上面的命令就会被打印。

ifeq ($(KBUILD_VERBOSE),1)

quiet =

Q =

else

quiet=quiet_

Q = @

endif

# If the user is running make -s (silent mode), suppress echoing of

# commands

# 如果用户运行make -s（静默模式），限制所有命令的输出。

ifneq ($(findstring s,$(MAKEFLAGS)),) //在$(MAKEFLAGS)中找到字符串s

quiet=silent_

endif

export quiet Q KBUILD_VERBOSE

# Look for make include files relative to root of kernel src

# 设置包含文件的路径，该路径相对于内核源码的根目录。

MAKEFLAGS += --include-dir=$(srctree) //用于make递归调用时传递命令行选项

# We need some generic definitions (do not try to remake the file).

# 我们需要一些一般的定义（不要尝试remake这个文件）。

$(srctree)/scripts/Kbuild.include: ;

include $(srctree)/scripts/Kbuild.include

# Make variables (CC, etc...)

# Make变量（CC，等...）

AS = $(CROSS_COMPILE)as

LD = $(CROSS_COMPILE)ld

CC = $(CROSS_COMPILE)gcc

CPP = $(CC) -E

AR = $(CROSS_COMPILE)ar

NM = $(CROSS_COMPILE)nm

STRIP = $(CROSS_COMPILE)strip

OBJCOPY = $(CROSS_COMPILE)objcopy

OBJDUMP = $(CROSS_COMPILE)objdump

AWK = awk

GENKSYMS = scripts/genksyms/genksyms

INSTALLKERNEL := installkernel

DEPMOD = /sbin/depmod

KALLSYMS = scripts/kallsyms

PERL = perl

CHECK = sparse

CHECKFLAGS := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ \

-Wbitwise -Wno-return-void $(CF)

MODFLAGS = -DMODULE

CFLAGS_MODULE = $(MODFLAGS)

AFLAGS_MODULE = $(MODFLAGS)

LDFLAGS_MODULE = -T $(srctree)/scripts/module-common.lds

CFLAGS_KERNEL =

AFLAGS_KERNEL =

CFLAGS_GCOV = -fprofile-arcs -ftest-coverage