MAKE(1L)               LOCAL USER COMMANDS               MAKE(1L)

       make - GNU make utility to maintain groups of programs

       make [ -f makefile ] [ option ] ...  target ...

       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 docu-
       mentation, refer to the Info file which is  made
       from the Texinfo source file make.texinfo.

       The  purpose of the make utility is to determine automati-
       cally which pieces of a large program need  to  be  recom-
       piled, and issue the commands to recompile them.  The man-
       ual describes the GNU implementation of  make,  which  was
       written by Richard Stallman and Roland McGrath.  Our exam-
       ples 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 com-
       piling 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-mod-
       ification  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
       GNUmakefile, makefile, and Makefile, in that order.

       Normally you should call your makefile either makefile  or
       Makefile.   (We  recommend  Makefile  because  it  appears
       prominently near the beginning  of  a  directory  listing,
       right  near  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 specific to GNU make,  and  will  not  be
       understood by other versions of make.  If makefile is `-',
       the standard input is read.

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


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

       -C dir
            Change  to directory dir before reading the makefiles
            or doing anything else.  If multiple -C  options  are
            specified, each is interpreted relative to the previ-
            ous one: -C / -C etc is equivalent to -C /etc.   This
            is typically used with recursive invocations of make.

       -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---every-
            thing interesting about how make decides what to  do.

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

       -f file
            Use file as a makefile.

       -i   Ignore all errors  in  commands  executed  to  remake

       -I dir
            Specifies  a  directory  dir  to  search for included
            makefiles.  If several -I options are used to specify
            several  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 compati-
            bility with the C preprocessor's -I flag.

       -j jobs
            Specifies the number of jobs (commands) to run simul-
            taneously.   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   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
            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.

       -n   Print the commands that would be executed, but do not
            execute them.

       -o 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 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 mode''.  Do not run any commands, or print
            anything; just return an exit status that is zero  if
            the specified targets are already up to date, nonzero

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

       -s   Silent operation; do not print the commands  as  they
            are executed.

       -S   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 or
            if you set -k in MAKEFLAGS in your environment.

       -t   Touch files (mark them  up  to  date  without  really
            changing  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   Print  the  version  of the make program plus a copy-
            right, a list of authors and a notice that  there  is
            no warranty.  After this information is printed, pro-
            cessing continues normally.  To get this  information
            without doing anything else, use make -v -f/dev/null.

       -w   Print a  message  containing  the  working  directory
            before  and after other processing.  This may be use-
            ful for tracking down errors from  complicated  nests
            of recursive make commands.

       -W 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.

       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.

GNU                       22 August 1989                        1