Reading Makefiles and the Environment

When make first starts, it reads the MAKEFLAGS environment variable to obtain any of the following options specified present in its value: -a, -d, -D, -e, -i, -k, -n, -N, -p, -q, -r, -s, -S, -t, -T, -u, or -w. Due to the implementation of POSIX.2 (see POSIX.2(5), the MAKEFLAGS values contains a leading − character. The make utility then reads the command line for additional options, which also take effect.

Next, make reads in a default makefile that typically contains predefined macro definitions, target entries for implicit rules, and additional rules, such as the rule for retrieving SCCS files. If present, make uses the file make.rules in the current directory; otherwise it reads the file /usr/share/lib/make/make.rules, which contains the standard definitions and rules. Use the directive:

include /usr/share/lib/make/make.rules

in your local make.rules file to include them.

Next, make imports variables from the environment (unless the -e option is in effect), and treats them as defined macros. Because make uses the most recent definition it encounters, a macro definition in the makefile normally overrides an environment variable of the same name. When -e is in effect, however, environment variables are read in after all makefiles have been read. In that case, the environment variables take precedence over definitions in the makefile.

Next, make reads any makefiles you specify with -f, or one of makefile or Makefile as described above and then the state file, in the local directory if it exists. If the makefile contains a .KEEP_STATE_FILE target, then it reads the state file that follows the target. Refer to special target .KEEP_STATE_FILE for details.

Next (after reading the environment if -e is in effect), make reads in any macro definitions supplied as command line arguments. These override macro definitions in the makefile and the environment both, but only for the make command itself.

make exports environment variables, using the most recently defined value. Macro definitions supplied on the command line are not normally exported, unless the macro is also an environment variable.

make does not export macros defined in the makefile. If an environment variable is set, and a macro with the same name is defined on the command line, make exports its value as defined on the command line. Unless -e is in effect, macro definitions within the makefile take precedence over those imported from the environment.

The macros MAKEFLAGS, MAKE, MAKE_NAME, SHELL, HOST_ARCH, HOST_MACH, TARGET_ARCH, and TARGET_MACH are special cases. See Special-Purpose Macros below for details.

Makefile Target Entries

A target entry has the following format:

       target [target...] :|:: [dependency] ... [; command] ...
                      [command]
                      ...

The first line contains the name of a target, or a space-separated list of target names, terminated with a colon or double colon. If a list of targets is given, this is equivalent to having a separate entry of the same form for each target. The colon(s) can be followed by a dependency, or a dependency list. make checks this list before building the target. The dependency list can be terminated with a semicolon (;), which in turn can be followed by a single Bourne shell command. Subsequent lines in the target entry begin with a TAB and contain Bourne shell commands. These commands comprise the rule for building the target.

Shell commands can be continued across input lines by escaping the NEWLINE with a backslash (\). The continuing line must also start with a TAB.

To rebuild a target, make expands macros, strips off initial TAB characters and either executes the command directly (if it contains no shell metacharacters), or passes each command line to a Bourne shell for execution.

The first non-empty line that does not begin with a TAB or # begins another target or macro definition.

Special Characters

Special characters are defined below.

Global

#

Start a comment. The comment ends at the next NEWLINE. If the # follows the TAB in a command line, that line is passed to the shell (which also treats # as the start of a comment).

export macro ...

If the word export appears as the first six letters of a line and is followed by a SPACE or TAB, the strings that follows are taken as a list of macros that should be exported in the list of environment variables.

If an environment variable with the same name already exists, it's value is replaced by the current value of the related make macro. An empty list of macro names is not considered an error. If the PATH macro is in the list of parameters, the path search of the current make process is also affected. If the SHELL macro is in the list of parameters, it is ignored and the previous SHELL environment is kept.

Previous versions of make did not support the export directive. With an empty SUN_MAKE_COMPAT_MODE environment, make does not support this feature.

include filename ...

If the word include appears as the first seven letters of a line and is followed by a SPACE or TAB, the string that follows is taken as a filename to interpolate at that line. include files can be nested to a depth of no more than 38 nested makefiles. If filename is a macro reference, it is expanded.

Previous versions of make did only supoport one filename after the include directive, this version supports any number of filenames and macros that expand to more than one name. With an empty SUN_MAKE_COMPAT_MODE environment, make only supports one filename after the include directive.

-include filename ...

If the word -include appears as the first nine letters of a line and is followed by a SPACE or TAB, the string that follows is taken as a filename to interpolate at that line.

The -include directive is implemented similar to the include directive, except that a nonexistent file is not considered to be an error.

Previous versions of make did not support the -include directive. With an empty SUN_MAKE_COMPAT_MODE environment, make does not support this feature.

readonly macro ...

If the word readonly appears as the first eight letters of a line and is followed by a SPACE or TAB, the strings that follows are taken as a list of macros that should be marked as readonly. This prevents further modification of the content of the related macros. An empty list of macro names is not considered an error.

Previous versions of make did not support the readonly directive. With an empty SUN_MAKE_COMPAT_MODE environment, make does not support this feature.

unexport macro ...

If the word unexport appears as the first eight letters of a line and is followed by a SPACE or TAB, the strings that follows are taken as a list of macros that should be removed from the list of environment variables. An empty list of macro names is not considered an error. If the PATH macro is in the list of parameters, the path search of the current make process is also affected. If the SHELL macro is in the list of parameters, it is ignored and the previous SHELL environment is kept.

Previous versions of make did not support the unexport directive. With an empty SUN_MAKE_COMPAT_MODE environment, make does not support this feature.

Automake Features

Automake special purpose macros

Automake special targets

Targets and Dependencies

::

target [+ target...] :

%

./pathname

Macros

$

( )
{ }

$$

\$

+=

+:=

?=

::=

:::=

:=

:sh =

:shell =

:sh

:shell

Rules

−

@

?

!

Special-Function Targets

When incorporated in a makefile, the following target names perform special-functions:

.BUILT_LAST_MAKE_RUN:

.DEFAULT:

.DONE:

.FAILED:

.GET_POSIX:

.IGNORE:

.INCLUDE_FAILED:

.INIT:

.KEEP_STATE:

.KEEP_STATE_FILE:

.LOCAL:

.MAKE_VERSION:

.MAKE_VERSION:  VERSION−number

.NO_PARALLEL:

.NOTPARALLEL:

.PARALLEL:

.PHONY:

.POSIX:

.PRECIOUS:

.SCCS_GET:

.SCCS_GET_POSIX:

.SILENT:

.SUFFIXES:

.SVR4:

.WAIT:

Clearing Special Targets

In this version of make, you can clear the definition of the following special targets by supplying entries for them with no dependencies and no rule:

.DEFAULT, .SCCS_GET, and .SUFFIXES

Command Dependencies

When the .KEEP_STATE: target is effective, make checks the command for building a target against the state file. If the command has changed since the last make run, make rebuilds the target.

Hidden Dependencies

When the .KEEP_STATE: target is effective, make reads reports from cpp(1) and other compilation processors for any "hidden" files, such as #include files. If the target is out of date with respect to any of these files, make rebuilds it.

Macros

Entries of the form

macro=value

define macros. macro is the name of the macro, and value, which consists of all characters up to a comment character or unescaped NEWLINE, is the value. make strips both leading and trailing white space in accepting the value.

Subsequent references to the macro, of the forms: $(name ) or ${name} are replaced by value. The parentheses or brackets can be omitted in a reference to a macro with a single-character name.

Macro references can contain references to other macros, in which case nested references are expanded first.

Suffix Replacement Macro References

Substitutions within macros can be made as follows:

     $(name:string1=string2)

where string1 is either a suffix, or a word to be replaced in the macro definition, and string2 is the replacement suffix or word. Words in a macro value are separated by SPACE, TAB, and escaped NEWLINE characters.

Pattern Replacement Macro References

Pattern matching replacements can also be applied to macros, with a reference of the form:

     $(name:op%os=np%ns)

where op is the existing (old) prefix and os is the existing (old) suffix, np and ns are the new prefix and new suffix, respectively, and the pattern matched by % (a string of zero or more characters), is carried forward from the value being replaced. For example:

PROGRAM=fabricate
DEBUG= $(PROGRAM:%=tmp/%−g)

sets the value of DEBUG to tmp/fabricate−g.

The replacement is done on a word by word base and the white space between words is literally retained. If there is no match, the result is unmodified.

Notice that pattern replacement macro references cannot be used in the dependency list of a pattern matching rule; the % characters are not evaluated independently. Also, any number of % metacharacters can appear after the equal-sign, including no % metacharacter after the equal-sign.

Appending to a Macro

Words can be appended to macro values as follows:

     macro += word ...

Special-Purpose Macros

When the MAKEFLAGS variable is present in the environment, make takes options from it, in combination with options entered on the command line. make retains this combined value as the MAKEFLAGS macro, and exports it automatically to each command or shell it invokes.

Notice that flags passed by way of MAKEFLAGS are only displayed when the -d, or -dd options are in effect.

The MAKE macro is another special case. It has the value make by default, and temporarily overrides the -n option for any line in which it is referred to. This allows nested invocations of make written as:

     $(MAKE) ...

to run recursively, with the -n flag in effect for all commands but make. This lets you use make -n to test an entire hierarchy of makefiles.

The MAKE macro contains a path name that is sufficient to recursively call the same make program again (it either contains the last path component or the full path name of the make program). Note that this may differ from the name that was used on the command line if the name that was used on the command line would not allow to call the same make program from a different directory using this name. For this reason $(MAKE) may not be used to check for a specific make program. Use $(MAKE_NAME) instead.

If not in SunPro make or in SysV compatibility mode, the MAKE_NAME macro is set up by make to help writing makefiles that depend on vendor specific features. It contains the official name of the make program - in our case sunpro.

For compatibility with the 4.2 BSD make, the MFLAGS macro is set from the MAKEFLAGS variable by prepending a -. MFLAGS is not exported automatically.

The SHELL macro, when set to a single-word value such as /usr/bin/csh, indicates the name of an alternate shell to use. The default is /bin/sh. Notice that make executes commands that contain no shell metacharacters itself. Built-in commands, such as dirs in the C shell, are not recognized unless the command line includes a metacharacter (for instance, a semicolon). This macro is neither imported from, nor exported to the environment, regardless of -e. To be sure it is set properly, you must define this macro within every makefile that requires it.

The syntax of the VPATH macro is:

     VPATH = [ pathname [ : pathname ] ... ]

VPATH specifies a list of directories to search for the files, which are targets or dependencies, when make is executed. VPATH is also used in order to search for the include files mentioned in the particular makefile.

When processing a target or a dependency or an include directive, make checks the existence of the file with the same name in the current directory. If the file is found to be missing, make searches for this file in the list of directories presented in VPATH (like the PATH variable in the shell). Unlike the PATH variable, VPATH is used in order to search for the files with relative pathnames. When make attempts to apply implicit rules to the target, it also searches for the dependency files using VPATH.

When the file is found using VPATH, internal macros $@, @<, $?, $*, and their alternative forms (with D or F appended) are set in accordance with the name derived from VPATH. For instance, if the target subdir/foo.o is found in the directory /aaa/bbb using VPATH, then the value of the internal macro $@ for this target is /aaa/bbb/subdir/foo.o.

If a target or a dependency file is found using VPATH, then any occurrences of the word that is the same as the target name in the subsequent rules are replaced with the actual name of the target derived from VPATH.

For example:

VPATH=./subdir
file.o : file.c
         cc -c file.c -o file.o

If file.c is found in ./subdir, then the command

cc -c ./subdir/file.c -o file.o

are executed.

The following macros are provided for use with cross-compilation:

HOST_ARCH

The processor type of the host system. By default, this is the output of the mach(1) command or uname -p, prepended with -. Under normal circumstances, this value should never be altered by the user.

HOST_MACH

The machine architecture of the host system. By default, this is the output of the arch(1) command or uname -m, prepended with −. Under normal circumstances, this value should never be altered by the user. Note that on Solaris, sun4 is returned in case that uname -p returns sparc, sun3 is returned for mc68020 and i86pc is returned for i386.

TARGET_ARCH

The processor type of the target system. By default, the output of the mach(1) command, prepended with −.

TARGET_MACH

The machine architecture of the target system. By default, this is the output of the arch(1) command, prepended with −.

The following macros are provided for compatibility with smake:

MAKE_ARCH

This macro is set up by make as part of the automake features of make. It contains the processor architecture of the current machine from uname -p (e.g. mc68020, sparc, pentium, i386).

MAKE_BRAND

This macro is set up by make as part of the automake features of make. It contains the brand of the current machine from sysinfo(SI_HW_PROVIDER) (e.g. Sun_Microsystems).

MAKE_DOMAIN

This macro is set up by make as part of the automake features of make. It contains the domainname of the current machine from domainname(1) (e.g. acme.com).

MAKE_HOST

This macro is set up by make as part of the automake features of make. It contains the host name of the current machine from uname -n (e.g. duffy, sherwood, ghost).

MAKE_HOST_OS

This macro is set up by make as part of the automake features of make. It contains the host OS name from uname -Hs of the current machine in case that there is a layered OS like Cygwin (e.g. windows).

MAKE_HOST_OSREL

This macro is set up by make as part of the automake features of make. It contains the host OS release from uname -Hr of the current machine in case that there is a layered OS like Cygwin (e.g. 5.1).

MAKE_HOST_OSVERSION

This macro is set up by make as part of the automake features of make. It contains the host OS version from uname -Hv of the current machine in case that there is a layered OS like Cygwin (e.g. sp2).

MAKE_HWSERIAL

This macro is set up by make as part of the automake features of make. It contains the serial number of the current machine (e.g. 1920098175).

MAKE_ISALIST

This macro is set up by make as part of the automake features of make. It contains the instruction set architecture list of the current machine from sysinfo(SI_ISALIST) (e.g. amd64 pentium_pro+mmx pentium_pro pentium+mmx pentium i486 i386 i86).

MAKE_M_ARCH

This macro is set up by make as part of the automake features of make. It contains the machine architecture of the current machine derived from MAKE_MACH (e.g. sun3, sun4).

MAKE_MACH

This macro is set up by bmake as part of the automake features of make. It contains the kernel architecture of the current machine from uname -m (e.g. sun3, sun4c, sun4m, sun4u, i86pc).

MAKE_MODEL

This macro is set up by bmake as part of the automake features of make. It contains the model name of the current machine from sysinfo(SI_PLATFORM) or uname -i (e.g. SUNW,SPARCstation-20).

MAKE_NAME

This macro is set up by make as part of the automake features of make. It contains the official name of the make program - in our case smake.

MAKE_OS

This macro is set up by make as part of the automake features of make. It contains the operating system name of the current machine from uname -s (e.g. sunos, linux, dgux).

MAKE_OSDEFS

This macro is set up by bmake as part of the automake features of make. It contains operating system specific defines for the compiler (e.g. -D__SVR4).

MAKE_OSREL

This macro is set up by bmake as part of the automake features of bmake. It contains the operating system release name of the current machine from uname -r (e.g. 5.5, 4.1.1).

MAKE_OSVERSION

This macro is set up by bmake as part of the automake features of make. It contains the operating system version of the current machine from uname -v (e.g. generic).

The following macros are provided for compatibility with GNU make:

CURDIR

After make has processed all -C options (if any), it sets the variable CURDIR to the absolute pathname of the current working directory. This value is never touched by make again. An environment variable will not overwrite it, but a makefile may. Setting this variable has no effect on the operation of make.

Dynamic Macros

There are several dynamically maintained macros that are useful as abbreviations within rules. They are shown here as references; if you were to define them, make would simply override the definition.

$*

$<

$@

$^

$?

$%

To refer to the $@ dynamic macro within a dependency list, precede the reference with an additional $ character (as in, $$@). Because make assigns $< and $* as it would for implicit rules (according to the suffixes list and the directory contents), they can be unreliable when used within explicit target entries.

These macros can be modified to apply either to the filename part, or the directory part of the strings they stand for, by adding an upper case F or D, respectively (and enclosing the resulting name in parentheses or braces). Thus, $(@D) refers to the directory part of the string $@; if there is no directory part, . is assigned. $(@F) refers to the filename part.

Conditional Macro Definitions

A macro definition of the form:

target-list := macro = value

indicates that when processing any of the targets listed and their dependencies, macro is to be set to the value supplied. Notice that if a conditional macro is referred to in a dependency list, the $ must be delayed (use $$ instead). Also, target-list can contain a % pattern, in which case the macro is conditionally defined for all targets encountered that match the pattern. A pattern replacement reference can be used within the value.

You can temporarily append to a macros value with a conditional definition of the form:

target-list := macro += value

Predefined Macros

make supplies the macros shown in the table that follows for compilers and their options, host architectures, and other commands. Unless these macros are read in as environment variables, their values are not exported by make. If you run make with any of these set in the environment, it is a good idea to add commentary to the makefile to indicate what value each is expected to take. If -r is in effect, make does not read the default makefile (./make.rules or /usr/share/lib/make/make.rules) in which these macro definitions are supplied.

Implicit Rules

When a target has no entry in the makefile, make attempts to determine its class (if any) and apply the rule for that class. An implicit rule describes how to build any target of a given class, from an associated dependency file. The class of a target can be determined either by a pattern, or by a suffix; the corresponding dependency file (with the same basename) from which such a target might be built. In addition to a predefined set of implicit rules, make allows you to define your own, either by pattern, or by suffix.

Pattern Matching Rules

A target entry of the form:

tp%ts: dp%ds
     rule

or

tp%ts:
     rule

is a pattern matching rule, in which tp is a target prefix, ts is a target suffix, dp is a dependency prefix, and ds is a dependency suffix (any of which can be null).

The % stands for a basename of zero or more characters that is matched in the target, and is used to construct the name of a dependency. When make encounters a match in its search for an implicit rule, it uses the rule in that target entry to build the target from the dependency file. Pattern-matching implicit rules typically make use of the $@ and $< dynamic macros as placeholders for the target and dependency names. Other, regular dependencies can occur in the dependency list; however, none of the regular dependencies can contain %. An entry of the form:

tp%ts: [dependency ...] dp%ds [dependency ...]
     rule

or

tp%ts: [dependency ...]
     rule

is a valid pattern matching rule.

Pattern Matching Rules are searched in in the same order as they appear in the makefile.

Pattern Matching Rules have precedence over Suffix Rules. The builtin rules defined by make are intentionally defined as Suffix Rules to allow them to be overwritten by Pattern Matching Rules in the customers makefiles.

Suffix Rules

When no pattern matching rule applies, make checks the target name to see if it ends with a suffix in the known suffixes list. If so, make checks for any suffix rules, as well as a dependency file with same root and another recognized suffix, from which to build it.

The target entry for a suffix rule takes the form:

DsTs:
     rule

where Ts is the suffix of the target, Ds is the suffix of the dependency file, and rule is the rule for building a target in the class. Both Ds and Ts must appear in the suffixes list. (A suffix need not begin with a . to be recognized.)

A suffix rule with only one suffix describes how to build a target having a null (or no) suffix from a dependency file with the indicated suffix. For instance, the .c rule could be used to build an executable program named file from a C source file named file.c. If a target with a null suffix has an explicit dependency, make omits the search for a suffix rule.

make reads in the standard set of implicit rules from the file /usr/share/lib/make/make.rules, unless -r is in effect, or there is a make.rules file in the local directory that does not include that file.

The Suffixes List

The suffixes list is given as the list of dependencies for the .SUFFIXES: special-function target. The default list is contained in the SUFFIXES macro (See Table of Predefined Macros for the standard list of suffixes). You can define additional .SUFFIXES: targets; a .SUFFIXES target with no dependencies clears the list of suffixes. Order is significant within the list; make selects a rule that corresponds to the target's suffix and the first dependency-file suffix found in the list. To place suffixes at the head of the list, clear the list and replace it with the new suffixes, followed by the default list:

   .SUFFIXES:
   .SUFFIXES: suffixes $(SUFFIXES)

A tilde (~) indicates that if a dependency file with the indicated suffix (minus the ~) is under SCCS its most recent version should be retrieved, if necessary, before the target is processed.

Library Maintenance

A target name of the form:

   lib(member ...)

refers to a member, or a space-separated list of members, in an ar(1) library.

The dependency of the library member on the corresponding file must be given as an explicit entry in the makefile. This can be handled by a pattern matching rule of the form:

   lib(%.s): %.s

where .s is the suffix of the member; this suffix is typically .o for object libraries.

A target name of the form:

   lib((symbol))

refers to the member of a randomized object library that defines the entry point named symbol.

Command Execution

Command lines are executed one at a time, each by its own process or shell. Shell commands, notably cd, are ineffectual across an unescaped NEWLINE in the makefile. A line is printed (after macro expansion) just before being executed. This is suppressed if it starts with a @, if there is a .SILENT: entry in the makefile, or if make is run with the -s option. Although the -n option specifies printing without execution, lines containing the macro $(MAKE) are executed regardless, and lines containing the @ special character are printed. The -t (touch) option updates the modification date of a file without executing any rules. This can be dangerous when sources are maintained by more than one person.

make invokes the shell with the -e (exit-on-errors) argument. Thus, with semicolon-separated command sequences, execution of the later commands depends on the success of the former. This behavior can be overridden by starting the command line with a -, or by writing a shell script that returns a non-zero status only as it finds appropriate.

Bourne Shell Constructs

To use the Bourne shell if control structure for branching, use a command line of the form:

if expression ; \
then command ; \
     ... ; \
else command; \
     ... ; \
fi

Although composed of several input lines, the escaped NEWLINE characters insure that make treats them all as one (shell) command line.

To use the Bourne shell for control structure for loops, use a command line of the form:

for var in list ; \
do command; \
     ... ; \done

To refer to a shell variable, use a double-dollar-sign ($$). This prevents expansion of the dollar-sign by make.

Command Substitutions

To incorporate the standard output of a shell command in a macro, use a definition of the form:

   MACRO:sh =command

The command is executed only once, standard error output is discarded, and NEWLINE characters are replaced with SPACEs. If the command has a non-zero exit status, make halts with an error.

To capture the output of a shell command in a macro reference, use a reference of the form:

$(MACRO:sh)

where MACRO is the name of a macro containing a valid Bourne shell command line. In this case, the command is executed whenever the reference is evaluated. As with shell command substitutions, the reference is replaced with the standard output of the command. If the command has a non-zero exit status, make halts with an error.

In contrast to commands in rules, the command is not subject for macro substitution; therefore, a dollar sign ($) need not be replaced with a double dollar sign ($$).

Signals

INT, SIGTERM, and QUIT signals received from the keyboard halt make and remove the target file being processed unless that target is in the dependency list for .PRECIOUS:.

/usr/bin/make

/usr/xpg4/bin/make