make evaluates the dependencies specified in makefile and executes the associated commands to update one or more targets, specified by name. Targets typically are programs. If no -f option is present, then the files makefile, Makefile, and the Source Code Control System (SCCS) files s.makefile, and s.Makefile are tried in order. If makefile is -, the standard input is read. More than one -f makefile argument pair may appear.
make updates a target only if its dependents are newer than the target. All prerequisite files of a target are added recursively to the list of targets. Missing files are deemed to be out-of-date, that is, they are newer than the target.
makefile contains a sequence of entries that specify dependencies. A dependency has the following syntax:
target1 [target2 ... ] :[:] [dependency1 ... ] [; commands [# ... ] [[<Tab> commands][# ... ] ... ]
(<Tab> is the tab character on your keyboard. It is printed here as <Tab>, instead of a sequence a blank characters for the purposes of this description.)
Tokens on the first line of an entry are blank-separated. The first non-empty line that does not begin with a tab or # begins a new dependency or macro definition. If the targets are separated from the dependent files by double colon (::), then the targets can appear in several dependencies. Each such dependency will be evaluated separately, using the original last modification time of the target to determine whether the commands are executed.
Shell commands and comments may be continued across lines with the <backslash><new-line> sequence. Everything printed by make (except the initial tab) is passed directly to the shell as is. If the last character on a line is a backslash, then the backslash and the new-line character are replaced by a single blank.
Sharp (#) and new-line surround comments.
The following makefile says that pgm depends on two files a.o and b.o, and that they in turn depend on their corresponding source files (a.c and b.c) and a common file incl.h:
pgm: a.o b.o cc a.o b.o -o pgm
a.o: incl.h a.c cc -c a.c
b.o: incl.h b.c cc -c b.c
Command lines are executed one at a time, each by its own shell. The SHELL environment variable can be used to specify which shell make should use to execute commands. The default is the users default shell. The first one or two characters in a command can be the following: -, @, -@, or @-. If @ is present, printing of the command is suppressed. If - is present, make ignores return codes. A line is printed when it is executed unless the -s option is present, or the entry .SILENT: is in makefile, or unless the initial character sequence contains a @. The -n option specifies printing without execution; however, if the command line has the string $(MAKE) in it, the line is always executed (see discussion of theMAKEFLAGS macro under ``Environment''). The -t (touch) option updates the modified date of a file without executing any commands.
Commands returning non-zero status normally terminate make. If the -i option is present, or the entry .IGNORE: appears in makefile, or the initial character sequence of the command contains -, the error is ignored. If the -k option is present, work is abandoned on the current entry, but continues on other branches that do not depend on that entry.
Interrupt and quit cause the target to be deleted unless the target is a dependent of the special name .PRECIOUS.
The number of targets make will try to build in parallel is determined by the value of the environment variable PARALLEL. If -P is invoked, but PARALLEL is not set, then make will try to build no more than two targets in parallel.
You can use the .MUTEX directive to serialize the updating of some specified targets. This is useful when two or more targets modify a common output file, such as when inserting modules into an archive or when creating an intermediate file with the same name, as is done by lex and yacc. If the makefile in the previous section contained a .MUTEX directive of the form
.MUTEX: a.o b.o
it would prevent make from building a.o and b.o in parallel.
The MAKEFLAGS environment variable is processed by make as containing any legal input option (except -f and -p) defined for the command line. Further, upon invocation, make ``invents'' the variable if it is not in the environment, puts the current options into it, and passes it on to invocations of commands. Thus, MAKEFLAGS always contains the current input options. This proves very useful for ``super-makes''. In fact, as noted above, when the -n option is used, the command $(MAKE) is executed anyway; hence, one can perform a make -n recursively on a whole software system to see what would have been executed. This is because the -n is put in MAKEFLAGS and passed to further invocations of $(MAKE). This is one way of debugging all of the makefiles for a software project without executing the commands in the makefile.
If a macro named VPATH
is assigned a list of colon separated directory names,
will search these directories when looking for files with relative path
names, in the same way the shells use the PATH
Using the inference rules, the first example can be done more briefly.
pgm: a.o b.o cc a.o b.o -o pgm a.o b.o: incl.h
Certain macros are used by the default inference rules to permit the inclusion of optional matter in any resulting commands. For example, CFLAGS, LFLAGS, and YFLAGS are used for compiler options to cc(CP), lex(CP), and yacc(CP), respectively. Use the -p option to list the internal rules.
The optional :subst1=subst2 is a substitute sequence.
The parentheses are optional if a single character macro name is used
and there is no substitute sequence.
If a substitute sequence is specified,
all nonoverlapping occurances of subst1 in the
named macro are replaced by subst2.
If string2 in the single equal sign assignment contains macros, they are not evaluated until string1 is evaluated in a dependency line or a command line. This saves time and space. However, if two or more substitution operator assignments are done using single equal sign assignments, an error will occur when the macro is evaluated on a dependency line or command line because make does not support nested evaluations of the substitution operator. For example, if the description file is:
SRC=src/file1.c src/file2.c src/file3.c TMP=$(SRC:.c=.o) OBJ=$(TMP:src=obj)
clean: rm $(OBJ)
and you execute it, requesting clean to be updated,
an error will occur because
make will only evaluate the outer substitution
operator of $(OBJ) resulting
in the shell executing rm $(SRC:src=obj).
If the double equal sign assignment
were used in the TMP assignment,
then TMP would immediately be evaluated,
removing the inner substitution operator from OBJ
and the clean target would evaluate correctly.
cc -c -O $.c
cc -c -O $<
p q: r @echo $! r: s @echo $! s: @echo $!
If this file were called requesting 'q' be updated, then the following would be printed:
s r q r q qThe line
s r qis printed by echo following the s target, the line
r qis printed by echo following the r target, and the line
qis printed by echo following the p q targets.
All of the internal macros can have an alternative form.
When an uppercase D or F is appended
to any of the macros, the meaning is changed to ``directory
part'' for D and ``file part'' for F.
Thus, $(@D) refers to the directory part of the
If there is no directory part, ./ is generated.
To print out the rules compiled into make on any machine in a form suitable for reuse, the following command is used:
make -fp - 2>/dev/null </dev/null
A tilde in the above rules refers to an SCCS file
Thus, the rule .c~.o would transform an SCCS
C source file into an object file (.o).
Because the s. of the SCCS files is a prefix,
it is incompatible with make's suffix point of view.
Hence, the tilde is a way of changing any file reference into an
SCCS file reference.
A rule with only one suffix (for example, .c:)
is the definition of how to build x from x.c.
In effect, the other suffix is null.
This is useful for building targets from only one source
file (for example, shell procedures, simple C programs).
Additional suffixes can be given as the dependency list for .SUFFIXES. Order is significant; the first possible name for which both a file and a rule exist is inferred as a prerequisite. The default list is:
.SUFFIXES: .o .c .c~ .y .y~ .l .l~ .s .s~ .sh .sh~ .h .h~ .f .f~ .C .C~ .Y .Y~ .L .L~ .asm .asm~ .src .src~.inc .inc~ .a
Here again, the above command for printing the internal rules will
display the list of suffixes implemented on the current machine.
Multiple suffix lists accumulate; .SUFFIXES:
with no dependencies clears the list of suffixes.
An unfortunate byproduct of the current implementation requires the XX to be different from the suffix of the archive member. Thus, one cannot have lib(file.o) depend upon file.o explicitly. The most common use of the archive interface follows. Here, we assume the source files are all C type source:
lib: lib(file1.o) lib(file2.o) lib(file3.o) @echo lib is now up-to-date .c.a: $(CC) -c $(CFLAGS) $< $(AR) $(ARFLAGS) $@ $*.o rm -f $*.o
In fact, the .c.a rule listed above is built into make and is unnecessary in this example. A more interesting, but more limited example of an archive library maintenance construction follows:
lib: lib(file1.o) lib(file2.o) lib(file3.o) $(CC) -c $(CFLAGS) $(?:.o=.c) $(AR) $(ARFLAGS) lib $? rm $? @echo lib is now up-to-dateHere the substitution mode of the macro expansions is used. The $? list is defined to be the set of object filenames (inside lib) whose C source files are out-of-date. The substitution mode translates the .o to .c. Note also, the disabling of the .c.a: rule, which would have created each object file, one by one. This particular construct speeds up archive library maintenance considerably. Also, you can use the double form of dependency if the archive library contains a mix of assembly programs and C programs: one dependency for C source files and one for assembly source files.
Some commands return non-zero status inappropriately; use -i, .IGNORE, or preprend the command with a ``-'' to overcome the difficulty.
Filenames which include the characters ``='', ``:'', or ``@'' will not work.
Commands that alter the environment notably cd(C), are ineffectual across new-lines in make.
The argument list to a command executed by make must be less than 5120 characters minus the length of the environment. This is a UNIX limitation.
The syntax (lib(file1.o file2.o file3.o)) is illegal; you cannot build lib(file.o) from file.o.
Named pipes are not handled well.
X/Open Portability Guide, Issue 3, 1989 .