Makefile and Paul's Rules of Makefiles

Defining and Redefining Pattern Rules

Here are some examples of pattern rules actually predefined in make. First, the rule that compiles ‘.c’ files into ‘.o’ files:

     %.o : %.c             $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

defines a rule that can make any file x.o from x.c. The recipe uses the automatic variables ‘$@’ and ‘$<’ to substitute the names of the target file and the source file in each case where the rule applies (seeAutomatic Variables).

https://www.gnu.org/software/make/manual/make.html#Pattern-Intro

Automatic Variables

11 Using make to Update Archive Files

https://www.gnu.org/software/make/manual/make.html#Archives

     libfoo.a: libfoo.a(x.o) libfoo.a(y.o) ...             ranlib libfoo.a

You can write a special kind of suffix rule for dealing with archive files. See Suffix Rules, for a full explanation of suffix rules. Archive suffix rules are obsolete in GNU make, because pattern rules for archives are a more general mechanism (see Archive Update). But they are retained for compatibility with other makes.

To write a suffix rule for archives, you simply write a suffix rule using the target suffix ‘.a’ (the usual suffix for archive files). For example, here is the old-fashioned suffix rule to update a library archive from C source files:

     .c.a:             $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o             $(AR) r $@ $*.o             $(RM) $*.o

This works just as if you had written the pattern rule:

     (%.o): %.c             $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o             $(AR) r $@ $*.o             $(RM) $*.o

In fact, this is just what make does when it sees a suffix rule with ‘.a’ as the target suffix. Any double-suffix rule ‘.x.a’ is converted to a pattern rule with the target pattern ‘(%.o)’ and a prerequisite pattern of ‘%.x’.

Since you might want to use ‘.a’ as the suffix for some other kind of file, make also converts archive suffix rules to pattern rules in the normal way (see Suffix Rules). Thus a double-suffix rule ‘.x.a’ produces two pattern rules: ‘(%.o): %.x’ and ‘%.a: %.x’.

‘$?’ is useful even in explicit rules when you wish to operate on only the prerequisites that have changed. For example, suppose that an archive named lib is supposed to contain copies of several object files. This rule copies just the changed object files into the archive:

     lib: foo.o bar.o lose.o win.o             ar r lib $?

https://www.gnu.org/software/make/manual/make.html#Automatic-Variables

http://mad-scientist.net/make/rules.html#rule3

The Basics: VPATH and vpath

http://www.cmcrossroads.com/article/basics-vpath-and-vpath

Paul's Rules of Makefiles

A somewhat tongue-in-cheek title, but this page lists a few very important rules you should always keep in mind when creating makefiles. Following these rules will allow your makefiles to be both pithy and beautiful. And they will make maintaining and modifying them, and thus your entire life, a much more pleasant experience.

1. Use GNU make.

   Don't hassle with writing portable makefiles, use a portable make instead!

2. Every non-.PHONY rule must update a file with the exact name of its target.

   Make sure every command script touches the file "$@"-- not "../$@", or "$(notdir $@)", but exactly $@. That way you and GNUmake always agree.

3. Life is simplest if the targets are built in the current working directory.

   Use VPATH to locate the sources from the objects directory, not to locate the objects from the sources directory.

4. Follow the Principle of Least Repetition.

   Try to never write a filename more than once. Do this through a combination of make variables, pattern rules, automatic variables, and GNU make functions.

5. Every non-continued line that starts with a TAB is part of a command script--and vice versa.

   If a non-continued line does not begin with a TAB character, it is never part of a command script: it is always interpreted asmakefile syntax. If a non-continued line does begin with a TAB character, it is always part of a command script: it is never interpreted as makefile syntax.

   Continued lines are always of the same type as their predecessor, regardless of what characters they start with.

Yes, that's all of them... so far. It's not that that's all I have to say on the subject, but coming up with points which are both truly fundamental and expressible in a succinct rule format, ain't easy.

Let me know if you have suggestions.