File: make.info,  Node: Options Summary,  Prev: Temporary Files,  Up: Running

9.8 Summary of Options
======================

Here is a table of all the options 'make' understands:

'-b'
'-m'
     These options are ignored for compatibility with other versions of
     'make'.

'-B'
'--always-make'
     Consider all targets out-of-date.  GNU 'make' proceeds to consider
     targets and their prerequisites using the normal algorithms;
     however, all targets so considered are always remade regardless of
     the status of their prerequisites.  To avoid infinite recursion, if
     'MAKE_RESTARTS' (*note Other Special Variables: Special Variables.)
     is set to a number greater than 0 this option is disabled when
     considering whether to remake makefiles (*note How Makefiles Are
     Remade: Remaking Makefiles.).

'-C DIR'
'--directory=DIR'
     Change to directory DIR before reading the makefiles.  If multiple
     '-C' options are specified, each is interpreted relative to the
     previous one: '-C / -C etc' is equivalent to '-C /etc'.  This is
     typically used with recursive invocations of 'make' (*note
     Recursive Use of 'make': Recursion.).

'-d'

     Print debugging information in addition to normal processing.  The
     debugging information says which files are being considered for
     remaking, which file-times are being compared and with what
     results, which files actually need to be remade, which implicit
     rules are considered and which are applied--everything interesting
     about how 'make' decides what to do.  The '-d' option is equivalent
     to '--debug=a' (see below).

'--debug[=OPTIONS]'

     Print debugging information in addition to normal processing.
     Various levels and types of output can be chosen.  With no
     arguments, print the "basic" level of debugging.  Possible
     arguments are below; only the first character is considered, and
     values must be comma- or space-separated.

     'a (all)'
          All types of debugging output are enabled.  This is equivalent
          to using '-d'.

     'b (basic)'
          Basic debugging prints each target that was found to be
          out-of-date, and whether the build was successful or not.

     'v (verbose)'
          A level above 'basic'; includes messages about which makefiles
          were parsed, prerequisites that did not need to be rebuilt,
          etc.  This option also enables 'basic' messages.

     'i (implicit)'
          Prints messages describing the implicit rule searches for each
          target.  This option also enables 'basic' messages.

     'j (jobs)'
          Prints messages giving details on the invocation of specific
          sub-commands.

     'm (makefile)'
          By default, the above messages are not enabled while trying to
          remake the makefiles.  This option enables messages while
          rebuilding makefiles, too.  Note that the 'all' option does
          enable this option.  This option also enables 'basic'
          messages.

     'p (print)'
          Prints the recipe to be executed, even when the recipe is
          normally silent (due to '.SILENT' or '@').  Also prints the
          makefile name and line number where the recipe was defined.

     'w (why)'
          Explains why each target must be remade by showing which
          prerequisites are more up to date than the target.

     'n (none)'
          Disable all debugging currently enabled.  If additional
          debugging flags are encountered after this they will still
          take effect.

'-e'
'--environment-overrides'
     Give variables taken from the environment precedence over variables
     from makefiles.  *Note Variables from the Environment: Environment.

'-E STRING'
'--eval=STRING'

     Evaluate STRING as makefile syntax.  This is a command-line version
     of the 'eval' function (*note Eval Function::).  The evaluation is
     performed after the default rules and variables have been defined,
     but before any makefiles are read.

'-f FILE'
'--file=FILE'
'--makefile=FILE'
     Read the file named FILE as a makefile.  *Note Writing Makefiles:
     Makefiles.

'-h'
'--help'

     Remind you of the options that 'make' understands and then exit.

'-i'
'--ignore-errors'
     Ignore all errors in recipes executed to remake files.  *Note
     Errors in Recipes: Errors.

'-I DIR'
'--include-dir=DIR'
     Specifies a directory DIR to search for included makefiles.  *Note
     Including Other Makefiles: Include.  If several '-I' options are
     used to specify several directories, the directories are searched
     in the order specified.  If the directory DIR is a single dash
     ('-') then any already-specified directories up to that point
     (including the default directory paths) will be discarded.  You can
     examine the current list of directories to be searched via the
     '.INCLUDE_DIRS' variable.

'-j [JOBS]'
'--jobs[=JOBS]'
     Specifies the number of recipes (jobs) to run simultaneously.  With
     no argument, 'make' runs as many recipes simultaneously as
     possible.  If there is more than one '-j' option, the last one is
     effective.  *Note Parallel Execution: Parallel, for more
     information on how recipes are run.  Note that this option is
     ignored on MS-DOS.

'--jobserver-style=[STYLE]'
     Chooses the style of jobserver to use.  This option only has effect
     if parallel builds are enabled (*note Parallel Execution:
     Parallel.).  On POSIX systems STYLE can be one of 'fifo' (the
     default) or 'pipe'.  On Windows the only acceptable STYLE is 'sem'
     (the default).  This option is useful if you need to use an older
     versions of GNU 'make', or a different tool that requires a
     specific jobserver style.

'-k'
'--keep-going'
     Continue as much as possible after an error.  While the target that
     failed, and those that depend on it, cannot be remade, the other
     prerequisites of these targets can be processed all the same.
     *Note Testing the Compilation of a Program: Testing.

'-l [LOAD]'
'--load-average[=LOAD]'
'--max-load[=LOAD]'
     Specifies that no new recipes should be started if there are other
     recipes running and the load average is at least LOAD (a
     floating-point number).  With no argument, removes a previous load
     limit.  *Note Parallel Execution: Parallel.

'-L'
'--check-symlink-times'
     On systems that support symbolic links, this option causes 'make'
     to consider the timestamps on any symbolic links in addition to the
     timestamp on the file referenced by those links.  When this option
     is provided, the most recent timestamp among the file and the
     symbolic links is taken as the modification time for this target
     file.

'-n'
'--just-print'
'--dry-run'
'--recon'

     Print the recipe that would be executed, but do not execute it
     (except in certain circumstances).  *Note Instead of Executing
     Recipes: Instead of Execution.

'-o FILE'
'--old-file=FILE'
'--assume-old=FILE'
     Do not remake the file FILE even if it is older than its
     prerequisites, and do not remake anything on account of changes in
     FILE.  Essentially the file is treated as very old and its rules
     are ignored.  *Note Avoiding Recompilation of Some Files: Avoiding
     Compilation.

'-O[TYPE]'
'--output-sync[=TYPE]'
     Ensure that the complete output from each recipe is printed in one
     uninterrupted sequence.  This option is only useful when using the
     '--jobs' option to run multiple recipes simultaneously (*note
     Parallel Execution: Parallel.) Without this option output will be
     displayed as it is generated by the recipes.

     With no type or the type 'target', output from the entire recipe of
     each target is grouped together.  With the type 'line', output from
     each line in the recipe is grouped together.  With the type
     'recurse', the output from an entire recursive make is grouped
     together.  With the type 'none', no output synchronization is
     performed.  *Note Output During Parallel Execution: Parallel
     Output.

'-p'
'--print-data-base'
     Print the data base (rules and variable values) that results from
     reading the makefiles; then execute as usual or as otherwise
     specified.  This also prints the version information given by the
     '-v' switch (see below).  To print the data base without trying to
     remake any files, use 'make -qp'.  To print the data base of
     predefined rules and variables, use 'make -p -f /dev/null'.  The
     data base output contains file name and line number information for
     recipe and variable definitions, so it can be a useful debugging
     tool in complex environments.

'-q'
'--question'
     "Question mode".  Do not run any recipes, or print anything; just
     return an exit status that is zero if the specified targets are
     already up to date, one if any remaking is required, or two if an
     error is encountered.  *Note Instead of Executing Recipes: Instead
     of Execution.

'-r'
'--no-builtin-rules'
     Eliminate use of the built-in implicit rules (*note Using Implicit
     Rules: Implicit Rules.).  You can still define your own by writing
     pattern rules (*note Defining and Redefining Pattern Rules: Pattern
     Rules.).  The '-r' option also clears out the default list of
     suffixes for suffix rules (*note Old-Fashioned Suffix Rules: Suffix
     Rules.).  But you can still define your own suffixes with a rule
     for '.SUFFIXES', and then define your own suffix rules.  Note that
     only _rules_ are affected by the '-r' option; default variables
     remain in effect (*note Variables Used by Implicit Rules: Implicit
     Variables.); see the '-R' option below.

'-R'
'--no-builtin-variables'
     Eliminate use of the built-in rule-specific variables (*note
     Variables Used by Implicit Rules: Implicit Variables.).  You can
     still define your own, of course.  The '-R' option also
     automatically enables the '-r' option (see above), since it doesn't
     make sense to have implicit rules without any definitions for the
     variables that they use.

'-s'
'--silent'
'--quiet'

     Silent operation; do not print the recipes as they are executed.
     *Note Recipe Echoing: Echoing.

'-S'
'--no-keep-going'
'--stop'

     Cancel the effect of the '-k' option.  This is never necessary
     except in a recursive 'make' where '-k' might be inherited from the
     top-level 'make' via 'MAKEFLAGS' (*note Recursive Use of 'make':
     Recursion.) or if you set '-k' in 'MAKEFLAGS' in your environment.

'--shuffle[=MODE]'

     This option enables a form of fuzz-testing of prerequisite
     relationships.  When parallelism is enabled ('-j') the order in
     which targets are built becomes less deterministic.  If
     prerequisites are not fully declared in the makefile this can lead
     to intermittent and hard-to-track-down build failures.

     The '--shuffle' option forces 'make' to purposefully reorder goals
     and prerequisites so target/prerequisite relationships still hold,
     but ordering of prerequisites of a given target are reordered as
     described below.

     The order in which prerequisites are listed in automatic variables
     is not changed by this option.

     The '.NOTPARALLEL' pseudo-target disables shuffling for that
     makefile.  Also any prerequisite list which contains '.WAIT' will
     not be shuffled.  *Note Disabling Parallel Execution: Parallel
     Disable.

     The '--shuffle=' option accepts these values:

     'random'
          Choose a random seed for the shuffle.  This is the default if
          no mode is specified.  The chosen seed is also provided to
          sub-'make' commands.  The seed is included in error messages
          so that it can be re-used in future runs to reproduce the
          problem or verify that it has been resolved.

     'reverse'
          Reverse the order of goals and prerequisites, rather than a
          random shuffle.

     'SEED'
          Use 'random' shuffle initialized with the specified seed
          value.  The SEED is an integer.

     'none'
          Disable shuffling.  This negates any previous '--shuffle'
          options.

'-t'
'--touch'

     Touch files (mark them up to date without really changing them)
     instead of running their recipes.  This is used to pretend that the
     recipes were done, in order to fool future invocations of 'make'.
     *Note Instead of Executing Recipes: Instead of Execution.

'--trace'
     Show tracing information for 'make' execution.  Using '--trace' is
     shorthand for '--debug=print,why'.

'-v'
'--version'
     Print the version of the 'make' program plus a copyright, a list of
     authors, and a notice that there is no warranty; then exit.

'-w'
'--print-directory'
     Print a message containing the working directory both before and
     after executing the makefile.  This may be useful for tracking down
     errors from complicated nests of recursive 'make' commands.  *Note
     Recursive Use of 'make': Recursion.  (In practice, you rarely need
     to specify this option since 'make' does it for you; see *note The
     '--print-directory' Option: -w Option.)

'--no-print-directory'
     Disable printing of the working directory under '-w'.  This option
     is useful when '-w' is turned on automatically, but you do not want
     to see the extra messages.  *Note The '--print-directory' Option:
     -w Option.

'-W FILE'
'--what-if=FILE'
'--new-file=FILE'
'--assume-new=FILE'
     Pretend that the target FILE has just been modified.  When used
     with the '-n' flag, this shows you what would happen if you were to
     modify that file.  Without '-n', it is almost the same as running a
     'touch' command on the given file before running 'make', except
     that the modification time is changed only in the imagination of
     'make'.  *Note Instead of Executing Recipes: Instead of Execution.

'--warn-undefined-variables'
     Issue a warning message whenever 'make' sees a reference to an
     undefined variable.  This can be helpful when you are trying to
     debug makefiles which use variables in complex ways.