man pages section 1: User Commands

Exit Print View

Updated: July 2014

make (1g)


make - GNU make utility to maintain groups of programs


make [ -f makefile ] [ options ] ... [ targets ] ...


LOCAL USER COMMANDS                                       MAKE(1)

     make - GNU make utility to maintain groups of programs

     make [ -f makefile ] [ options ] ... [ targets ] ...

     This  man  page  is  an  extract of the documentation of GNU
     make.  It is updated  only  occasionally,  because  the  GNU
     project  does not use nroff.  For complete, current documen-
     tation, refer to the Info file which is made  from
     the Texinfo source file make.texi.

     The  purpose  of  the make utility is to determine automati-
     cally which pieces of a large program need to be recompiled,
     and  issue  the  commands  to  recompile  them.   The manual
     describes the GNU implementation of make, which was  written
     by  Richard  Stallman  and  Roland McGrath, and is currently
     maintained by Paul Smith.  Our  examples  show  C  programs,
     since  they  are  most common, but you can use make with any
     programming language whose compiler can be run with a  shell
     command.  In fact, make is not limited to programs.  You can
     use it to describe any task where some files must be updated
     automatically from others whenever the others change.

     To  prepare  to  use  make, you must write a file called the
     makefile that describes the  relationships  among  files  in
     your  program, and the states the commands for updating each
     file.  In  a  program,  typically  the  executable  file  is
     updated from object files, which are in turn made by compil-
     ing source files.

     Once a suitable makefile exists, each time you  change  some
     source files, this simple shell command:


     suffices  to perform all necessary recompilations.  The make
     program uses the makefile data base and  the  last-modifica-
     tion times of the files to decide which of the files need to
     be updated.  For each of those files, it issues the commands
     recorded in the data base.

     make executes commands in the makefile to update one or more
     target names, where name is typically a program.  If  no  -f
     option is present, make will look for the makefiles GNUmake-
     file, makefile, and Makefile, in that order.

     Normally you should call your makefile  either  makefile  or
     Makefile.   (We recommend Makefile because it appears promi-
     nently near the beginning of a directory listing, right near

GNU                Last change: 22 August 1989                  1

LOCAL USER COMMANDS                                       MAKE(1)

     other  important  files  such  as  README.)   The first name
     checked, GNUmakefile, is not recommended for most makefiles.
     You should use this name if you have a makefile that is spe-
     cific to GNU make, and will not be understood by other  ver-
     sions  of  make.   If makefile is `-', the standard input is

     make updates a target if it depends  on  prerequisite  files
     that  have been modified since the target was last modified,
     or if the target does not exist.

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

     -B, --always-make
          Unconditionally make all targets.

     -C dir, --directory=dir
          Change to directory dir before reading the makefiles or
          doing anything else.  If multiple -C options are speci-
          fied, each is interpreted relative to the previous one:
          -C / -C etc is equivalent to -C /etc.   This  is  typi-
          cally used with recursive invocations of make.

     -d   Print  debugging information in addition to normal pro-
          cessing.  The debugging information  says  which  files
          are being considered for remaking, which file-times are
          being compared and with what results, which files actu-
          ally  need  to be remade, which implicit rules are con-
          sidered and which are applied---everything  interesting
          about how make decides what to do.

          Print  debugging information in addition to normal pro-
          cessing.  If the FLAGS are omitted, then  the  behavior
          is the same as if -d was specified.  FLAGS may be a for
          all debugging output (same as using -d),  b  for  basic
          debugging,  v  for  more verbose basic debugging, i for
          showing implicit rules, j for details on invocation  of
          commands, and m for debugging while remaking makefiles.

     -e, --environment-overrides
          Give variables taken from  the  environment  precedence
          over variables from makefiles.

     -f file, --file=file, --makefile=FILE
          Use file as a makefile.

     -i, --ignore-errors
          Ignore all errors in commands executed to remake files.

GNU                Last change: 22 August 1989                  2

LOCAL USER COMMANDS                                       MAKE(1)

     -I dir, --include-dir=dir
          Specifies a directory dir to search for included  make-
          files.   If several -I options are used to specify sev-
          eral directories, the directories are searched  in  the
          order  specified.   Unlike the arguments to other flags
          of make, directories  given  with  -I  flags  may  come
          directly  after  the flag: -Idir is allowed, as well as
          -I dir.  This syntax is allowed for compatibility  with
          the C preprocessor's -I flag.

     -j [jobs], --jobs[=jobs]
          Specifies the number of jobs (commands) to run simulta-
          neously.  If there is more than one -j option, the last
          one is effective.  If the -j option is given without an
          argument, make will not limit the number of  jobs  that
          can run simultaneously.

     -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 dependencies of these targets can
          be processed all the same.

     -l [load], --load-average[=load]
          Specifies that no new jobs (commands) should be started
          if  there  are others jobs running and the load average
          is at least load (a floating-point  number).   With  no
          argument, removes a previous load limit.

     -L, --check-symlink-times
          Use the latest mtime between symlinks and target.

     -n, --just-print, --dry-run,
          Print  the  commands that would be executed, but do not
          execute them (except in certain circumstances).

     -o file, --old-file=file, --assume-old=file
          Do not remake the file file even if it  is  older  than
          its dependencies, and do not remake anything on account
          of changes in file.  Essentially the file is treated as
          very old and its rules are ignored.

     -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 -p -f/dev/null.

     -q, --question
          ``Question mode''.  Do not run any commands,  or  print

GNU                Last change: 22 August 1989                  3

LOCAL USER COMMANDS                                       MAKE(1)

          anything;  just  return  an exit status that is zero if
          the specified targets are already up to  date,  nonzero

     -r, --no-builtin-rules
          Eliminate  use  of  the  built-in implicit rules.  Also
          clear out the  default  list  of  suffixes  for  suffix

     -R, --no-builtin-variables
          Don't define any built-in variables.

     -s, --silent, --quiet
          Silent operation; do not print the commands as they are

     -S, --no-keep-going, --stop
          Cancel the effect of the -k option.  This is never nec-
          essary  except  in  a  recursive make where -k might be
          inherited from the top-level make via MAKEFLAGS  or  if
          you set -k in MAKEFLAGS in your environment.

     -t, --touch
          Touch files (mark them up to date without really chang-
          ing them) instead of running their commands.   This  is
          used  to  pretend that the commands were done, in order
          to fool future invocations of make.

     -v, --version
          Print the version of the make program plus a copyright,
          a  list  of  authors and a notice that there is no war-

     -w, --print-directory
          Print a message containing the working directory before
          and  after  other  processing.   This may be useful for
          tracking down errors from complicated nests  of  recur-
          sive make commands.

          Turn off -w, even if it was turned on implicitly.

     -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 modifi-
          cation time is changed only in the imagination of make.

          Warn when an undefined variable is referenced.

GNU                Last change: 22 August 1989                  4

LOCAL USER COMMANDS                                       MAKE(1)

     GNU  make  exits with a status of zero if all makefiles were
     successfully parsed and no targets that were  built  failed.
     A status of one will be returned if the -q flag was used and
     make determines that a target needs to be rebuilt.  A status
     of two will be returned if any errors were encountered.

     See   attributes(5)   for   descriptions  of  the  following

     |Availability   | developer/build/gnu-make |
     |Stability      | Volatile                 |
     The GNU Make Manual

     See the chapter `Problems and Bugs' in The GNU Make  Manual.

     This  manual  page  contributed  by Dennis Morse of Stanford
     University.  It has been reworked by Roland  McGrath.   Fur-
     ther updates contributed by Mike Frysinger.

     Copyright  (C)  1992,  1993,  1996, 1999, 2007 Free Software
     Foundation, Inc.  This file is part of GNU make.

     GNU Make is free software; you can  redistribute  it  and/or
     modify  it under the terms of the GNU General Public License
     as published by the Free Software Foundation; either version
     3 of the License, or (at your option) any later version.

     GNU  Make is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied  warranty
     the GNU General Public License for more details.

     You should have received a copy of the  GNU  General  Public
     License    along   with   this   program.    If   not,   see

     This  software  was   built   from   source   available   at

GNU                Last change: 22 August 1989                  5

LOCAL USER COMMANDS                                       MAKE(1)    The  original
     community       source       was       downloaded       from

     Further  information about this software can be found on the
     open source community  website  at

GNU                Last change: 22 August 1989                  6