xref: /freebsd-10.0-release/contrib/gcc/doc/makefile.texi

@c Copyright (C) 2001, 2002 Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.

@node Makefile
@subsection Makefile Targets
@cindex makefile targets
@cindex targets, makefile

@table @code
@item all
This is the default target.  Depending on what your build/host/target
configuration is, it coordinates all the things that need to be built.

@item doc
Produce info-formatted documentation.  Also, @code{make dvi} is
available for DVI-formatted documentation, and @code{make
generated-manpages} to generate man pages.

@item mostlyclean
Delete the files made while building the compiler.

@item clean
That, and all the other files built by @code{make all}.

@item distclean
That, and all the files created by @code{configure}.

@item extraclean
That, and any temporary or intermediate files, like emacs backup files.

@item maintainer-clean
Distclean plus any file that can be generated from other files.  Note
that additional tools may be required beyond what is normally needed to
build gcc.

@item install
Installs gcc.

@item uninstall
Deletes installed files.

@item check
Run the testsuite.  This creates a @file{testsuite} subdirectory that
has various @file{.sum} and @file{.log} files containing the results of
the testing.  You can run subsets with, for example, @code{make check-gcc}.
You can specify specific tests by setting RUNTESTFLAGS to be the name
of the @file{.exp} file, optionally followed by (for some tests) an equals
and a file wildcard, like:

@example
make check-gcc RUNTESTFLAGS="execute.exp=19980413-*"
@end example

Note that running the testsuite may require additional tools be
installed, such as TCL or dejagnu.

@item bootstrap
Builds gcc three times---once with the native compiler, once with the
native-built compiler it just built, and once with the compiler it built
the second time.  In theory, the last two should produce the same
results, which @code{make compare} can check.  Each step of this process
is called a ``stage'', and the results of each stage @var{N}
(@var{N} = 1@dots{}3) are copied to a subdirectory @file{stage@var{N}/}.

@item bootstrap-lean
Like @code{bootstrap}, except that the various stages are removed once
they're no longer needed.  This saves disk space.

@item bubblestrap
Once bootstrapped, this incrementally rebuilds each of the three stages,
one at a time.  It does this by ``bubbling'' the stages up from their
subdirectories, rebuilding them, and copying them back to their
subdirectories.  This will allow you to, for example, quickly rebuild a
bootstrapped compiler after changing the sources, without having to do a
full bootstrap.

@item quickstrap
Rebuilds the most recently built stage.  Since each stage requires
special invocation, using this target means you don't have to keep track
of which stage you're on or what invocation that stage needs.

@item cleanstrap
Removed everything (@code{make clean}) and rebuilds (@code{make bootstrap}).

@item stage@var{N} (@var{N} = 1@dots{}4)
For each stage, moves the appropriate files to the @file{stage@var{N}}
subdirectory.

@item unstage@var{N} (@var{N} = 1@dots{}4)
Undoes the corresponding @code{stage@var{N}}.

@item restage@var{N} (@var{N} = 1@dots{}4)
Undoes the corresponding @code{stage@var{N}} and rebuilds it with the
appropriate flags.

@item compare
Compares the results of stages 2 and 3.  This ensures that the compiler
is running properly, since it should produce the same object files
regardless of how it itself was compiled.

@end table