Next: Catalogue of Rules Up: Implicit Rules
Using Implicit Rules
To allow `make' to find a customary method for updating a target
file, all you have to do is refrain from specifying commands yourself.
Either write a rule with no command lines, or don't write a rule at
all. Then `make' will figure out which implicit rule to use based on
which kind of source file exists or can be made.
For example, suppose the makefile looks like this:
foo : foo.o bar.o
cc -o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)
Because you mention `foo.o' but do not give a rule for it, `make' will
automatically look for an implicit rule that tells how to update it.
This happens whether or not the file `foo.o' currently exists.
If an implicit rule is found, it can supply both commands and one or
more dependencies (the source files). You would want to write a rule
for `foo.o' with no command lines if you need to specify additional
dependencies, such as header files, that the implicit rule cannot
Each implicit rule has a target pattern and dependency patterns.
There may be many implicit rules with the same target pattern. For
example, numerous rules make `.o' files: one, from a `.c' file with the
C compiler; another, from a `.p' file with the Pascal compiler; and so
on. The rule that actually applies is the one whose dependencies exist
or can be made. So, if you have a file `foo.c', `make' will run the C
compiler; otherwise, if you have a file `foo.p', `make' will run the
Pascal compiler; and so on.
Of course, when you write the makefile, you know which implicit rule
you want `make' to use, and you know it will choose that one because you
know which possible dependency files are supposed to exist. *Note
Catalogue of Implicit Rules: Catalogue of Rules, for a catalogue of all
the predefined implicit rules.
Above, we said an implicit rule applies if the required dependencies
"exist or can be made". A file "can be made" if it is mentioned
explicitly in the makefile as a target or a dependency, or if an
implicit rule can be recursively found for how to make it. When an
implicit dependency is the result of another implicit rule, we say that
"chaining" is occurring. Note: Chains of Implicit Rules.
In general, `make' searches for an implicit rule for each target, and
for each double-colon rule, that has no commands. A file that is
mentioned only as a dependency is considered a target whose rule
specifies nothing, so implicit rule search happens for it. *Note
Implicit Rule Search Algorithm: Search Algorithm, for the details of
how the search is done.
Note that explicit dependencies do not influence implicit rule
search. For example, consider this explicit rule:
The dependency on `foo.p' does not necessarily mean that `make' will
remake `foo.o' according to the implicit rule to make an object file, a
`.o' file, from a Pascal source file, a `.p' file. For example, if
`foo.c' also exists, the implicit rule to make an object file from a C
source file is used instead, because it appears before the Pascal rule
in the list of predefined implicit rules (Note: Catalogue of Implicit
If you do not want an implicit rule to be used for a target that has
no commands, you can give that target empty commands by writing a
semicolon (Note: Defining Empty Commands.).
automatically generated by info2www