# for comments in Makefiles.
Write rules as
Specify update actions in a tab-indented block under the rule.
.PHONY to mark targets that don’t correspond to files.
$@ to refer to the target of the current rule.
$^ to refer to the dependencies of the current rule.
$< to refer to the first dependency of the current rule.
Dependencies on Data and Code
Make results depend on processing scripts as well as data files.
Dependencies are transitive: if A depends on B and B depends on C, a change to C will indirectly trigger an update to A.
Make is actually a small programming language with many built-in functions.
wildcard function to get lists of files matching a pattern.
patsubst function to rewrite file names.
To run Make:
Make will look for a Makefile called
Makefile and will build the
default target, the first target in the Makefile.
To use a Makefile with a different name, use the
-f flag e.g.
$ make -f build-files/analyze.mk
To build a specific target, provide it as an argument e.g.
If the target is up-to-date, Make will print a message like:
make: `isles.dat' is up to date.
To see the actions Make will run when building a target, without
running the actions, use the
--dry-run flag e.g.
$ make --dry-run isles.dat
Alternatively, use the abbreviation
If Make prints a message like,
Makefile:3: *** missing separator. Stop.
then check that all the actions are indented by TAB characters and not
If Make prints a message like,
No such file or directory: 'books/%.txt'
make: *** [isles.dat] Error 1
then you may have used the Make wildcard,
%, in an action in a
pattern rule. Make wildcards cannot be used in actions.
target : dependency1 dependency2 ...
Each rule has a target, a file to be created, or built.
Each rule has zero or more dependencies, files that are needed to
build the target.
: separates the target and the dependencies.
Dependencies are separated by spaces.
Each rule has zero or more actions, commands to run to build the
target using the dependencies.
Actions are indented using the TAB character, not 8 spaces.
If any dependency does not exist then Make will look for a rule to
The order of rebuilding dependencies is arbitrary. You should not
assume that they will be built in the order in which they are listed.
Dependencies must form a directed acyclic graph. A target cannot
depend on a dependency which, in turn depends upon, or has a
dependency which depends upon, that target.
# This is a Make comment.
Line continuation character:
ARCHIVE = isles.dat isles.png \
abyss.dat abyss.png \
If a list of dependencies or an action is too long, a Makefile can
become more difficult to read.
\, the line continuation character, allows you to split
up a list of dependencies or an action over multiple lines, to make
them easier to read.
Make will combine the multiple lines into a single list of dependencies
.PHONY : clean
rm -f *.dat
Phony targets are a short-hand for sequences of actions.
No file with the target name is built when a rule with a phony
target is run.
$< denotes ‘the first dependency of the current rule’.
$@ denotes ‘the target of the current rule’.
$^ denotes ‘the dependencies of the current rule’.
$* denotes ‘the stem with which the pattern of the current rule matched’.
%.dat : books/%.txt $(COUNT_SRC)
$(COUNT_EXE) $< $@
The Make wildcard,
%, specifies a pattern.
If Make finds a dependency matching the pattern, then the pattern is
substituted into the target.
The Make wildcard can only be used in targets and dependencies.
e.g. if Make found a file called
books/abyss.txt, it would set the
target to be
Defining and using variables:
A variable is assigned a value. For example,
is assigned the value
$(...) is a reference to a variable. It requests that
Make substitutes the name of a variable for its value.
Suppress printing of actions:
.PHONY : variables
@echo TXT_FILES: $(TXT_FILES)
Prefix an action by
@ to instruct Make not to print that action.
Include the contents of a Makefile in another Makefile:
Looks for all files matching a pattern e.g.
return these in a list.
TXT_FILES is set to
patsubst (‘path substitution’) function:
DAT_FILES=$(patsubst books/%.txt, %.dat, $(TXT_FILES))
Every string that matches
%.dat and the strings are returned in a list.
books/last.txt books/sierra.txt this sets
isles.dat last.dat sierra.dat.
In Make version 3.79 the default target is the first target in the
In Make 3.81, the default target can be explicitly set using the
GNU Make Manual. Reference sections include: Glossary
The steps a
build manager must take to create or
update a file or other object. assignment
A request that
Make stores something in a
variable. automatic variable
A variable whose value is automatically redefined for each
rule. Make’s automatic variables include
which holds the rule’s
$^, which holds its
$<, which holds the first of
its dependencies, and
$*, which holds the
stem with which
the pattern was matched. Automatic variables are typically used in
pattern rules. build file
A description of
dependencies and rules
for a build manager. build manager
A program, such as
Make, whose main purpose is to build or
update software, documentation, web sites, data files, images, and
other things. default rule
rule that is executed if no target is
specified when a build manager is run. default target
target of the default rule. dependency
A file that a
target depends on. If any of a target’s
dependencies are newer than the target itself, the
target needs to be updated. A target’s dependencies are also
called its prerequisites. If a target’s dependencies do not exist,
then they need to be built first. false dependency
This can refer to a
dependency that is artificial.
e.g. a false dependency is introduced if a data analysis script
is added as a dependency to the data files that the script
Make utility that performs some operation, for
example gets a list of files matching a pattern. incremental build
The feature of a
build manager by
which it only rebuilds files that, either directory
or indirectly, depend on a file that was changed. macro
Used as a synonym for
variable in certain versions of
build manager, from GNU, created in 1977. Makefile
build file used by Make, which, by
default, are named
rule that specifies a general way to build or update an
entire class of files that can be managed the same way. For
example, a pattern rule can specify how to compile any C file
rather than a single, specific C file, or, to analyze any data
file rather than a single, specific data file. Pattern rules
typically make use of automatic variables
and wildcards. phony target
target that does not correspond to a file or other
object. Phony targets are usually symbolic names for sequences of
A synonym for
A request that
Make substitutes the name of a
variable for its value. rule
A specification of a
dependencies and what actions need to be
executed to build or update the target. stem
The part of the target that was matched by the pattern rule. If
the target is
file.dat and the target pattern was
A thing to be created or updated, for example a file. Targets can
dependencies that must exist, and be
up-to-date, before the target itself can be built or updated. variable
A symbolic name for something in a
A pattern that can be specified in
targets. If Make finds a dependency matching
the pattern, then the pattern is substituted into the
target. wildcards are often used in pattern
rules. The Make wildcard is