This is doc/gcc.info, produced by makeinfo version 4.0 from
doc/gcc.texi.

INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* gcc: (gcc).                  The GNU Compiler Collection.
END-INFO-DIR-ENTRY
   This file documents the use and the internals of the GNU compiler.


   Published by the Free Software Foundation
59 Temple Place - Suite 330
Boston, MA 02111-1307 USA


   Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001 Free Software Foundation, Inc.


   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "GNU General Public License" and "Funding Free
Software", the Front-Cover texts being (a) (see below), and with the
Back-Cover Texts being (b) (see below).  A copy of the license is
included in the section entitled "GNU Free Documentation License".

   (a) The FSF's Front-Cover Text is:

   A GNU Manual

   (b) The FSF's Back-Cover Text is:

   You have freedom to copy and modify this GNU Manual, like GNU
software.  Copies published by the Free Software Foundation raise
funds for GNU development.


File: gcc.info,  Node: Preprocessor Options,  Next: Assembler Options,  Prev: Optimize Options,  Up: Invoking GCC

Options Controlling the Preprocessor
====================================

   These options control the C preprocessor, which is run on each C
source file before actual compilation.

   If you use the `-E' option, nothing is done except preprocessing.
Some of these options make sense only together with `-E' because they
cause the preprocessor output to be unsuitable for actual compilation.

`-include FILE'
     Process FILE as input before processing the regular input file.
     In effect, the contents of FILE are compiled first.  Any `-D' and
     `-U' options on the command line are always processed before
     `-include FILE', regardless of the order in which they are
     written.  All the `-include' and `-imacros' options are processed
     in the order in which they are written.

`-imacros FILE'
     Process FILE as input, discarding the resulting output, before
     processing the regular input file.  Because the output generated
     from FILE is discarded, the only effect of `-imacros FILE' is to
     make the macros defined in FILE available for use in the main
     input.  All the `-include' and `-imacros' options are processed in
     the order in which they are written.

`-idirafter DIR'
     Add the directory DIR to the second include path.  The directories
     on the second include path are searched when a header file is not
     found in any of the directories in the main include path (the one
     that `-I' adds to).

`-iprefix PREFIX'
     Specify PREFIX as the prefix for subsequent `-iwithprefix' options.

`-iwithprefix DIR'
     Add a directory to the second include path.  The directory's name
     is made by concatenating PREFIX and DIR, where PREFIX was
     specified previously with `-iprefix'.  If you have not specified a
     prefix yet, the directory containing the installed passes of the
     compiler is used as the default.

`-iwithprefixbefore DIR'
     Add a directory to the main include path.  The directory's name is
     made by concatenating PREFIX and DIR, as in the case of
     `-iwithprefix'.

`-isystem DIR'
     Add a directory to the beginning of the second include path,
     marking it as a system directory, so that it gets the same special
     treatment as is applied to the standard system directories.

`-nostdinc'
     Do not search the standard system directories for header files.
     Only the directories you have specified with `-I' options (and the
     current directory, if appropriate) are searched.  *Note Directory
     Options::, for information on `-I'.

     By using both `-nostdinc' and `-I-', you can limit the include-file
     search path to only those directories you specify explicitly.

`-remap'
     When searching for a header file in a directory, remap file names
     if a file named `header.gcc' exists in that directory.  This can
     be used to work around limitations of file systems with file name
     restrictions.  The `header.gcc' file should contain a series of
     lines with two tokens on each line: the first token is the name to
     map, and the second token is the actual name to use.

`-undef'
     Do not predefine any nonstandard macros.  (Including architecture
     flags).

`-E'
     Run only the C preprocessor.  Preprocess all the C source files
     specified and output the results to standard output or to the
     specified output file.

`-C'
     Tell the preprocessor not to discard comments.  Used with the `-E'
     option.

`-P'
     Tell the preprocessor not to generate `#line' directives.  Used
     with the `-E' option.

`-M'
     Instead of outputting the result of preprocessing, output a rule
     suitable for `make' describing the dependencies of the main source
     file.  The preprocessor outputs one `make' rule containing the
     object file name for that source file, a colon, and the names of
     all the included files.  Unless overridden explicitly, the object
     file name consists of the basename of the source file with any
     suffix replaced with object file suffix. If there are many
     included files then the rule is split into several lines using
     `\'-newline.

     `-M' implies `-E'.

`-MM'
     Like `-M', but mention only the files included with `#include
     "FILE"'.  System header files included with `#include <FILE>' are
     omitted.

`-MD'
     Like `-M' but the dependency information is written to a file
     rather than stdout.  `gcc' will use the same file name and
     directory as the object file, but with the suffix `.d' instead.

     This is in addition to compiling the main file as specified--`-MD'
     does not inhibit ordinary compilation the way `-M' does, unless
     you also specify `-MG'.

     With Mach, you can use the utility `md' to merge multiple
     dependency files into a single dependency file suitable for using
     with the `make' command.

`-MMD'
     Like `-MD' except mention only user header files, not system
     -header files.

`-MF FILE'
     When used with `-M' or `-MM', specifies a file to write the
     dependencies to.  This allows the preprocessor to write the
     preprocessed file to stdout normally.  If no `-MF' switch is
     given, CPP sends the rules to stdout and suppresses normal
     preprocessed output.

     Another way to specify output of a `make' rule is by setting the
     environment variable `DEPENDENCIES_OUTPUT' (*note Environment
     Variables::).

`-MG'
     When used with `-M' or `-MM', `-MG' says to treat missing header
     files as generated files and assume they live in the same
     directory as the source file.  It suppresses preprocessed output,
     as a missing header file is ordinarily an error.

     This feature is used in automatic updating of makefiles.

`-MP'
     This option instructs CPP to add a phony target for each dependency
     other than the main file, causing each to depend on nothing.  These
     dummy rules work around errors `make' gives if you remove header
     files without updating the `Makefile' to match.

     This is typical output:-

          /tmp/test.o: /tmp/test.c /tmp/test.h
          
          /tmp/test.h:

`-MQ TARGET'

`-MT TARGET'
     By default CPP uses the main file name, including any path, and
     appends the object suffix, normally ".o", to it to obtain the name
     of the target for dependency generation.  With `-MT' you can
     specify a target yourself, overriding the default one.

     If you want multiple targets, you can specify them as a single
     argument to `-MT', or use multiple `-MT' options.

     The targets you specify are output in the order they appear on the
     command line.  `-MQ' is identical to `-MT', except that the target
     name is quoted for Make, but with `-MT' it isn't.  For example,
     `-MT '$(objpfx)foo.o'' gives

          $(objpfx)foo.o: /tmp/foo.c

     but `-MQ '$(objpfx)foo.o'' gives

          $$(objpfx)foo.o: /tmp/foo.c

     The default target is automatically quoted, as if it were given
     with `-MQ'.

`-H'
     Print the name of each header file used, in addition to other
     normal activities.

`-AQUESTION(ANSWER)'
     Assert the answer ANSWER for QUESTION, in case it is tested with a
     preprocessing conditional such as `#if #QUESTION(ANSWER)'.  `-A-'
     disables the standard assertions that normally describe the target
     machine.

`-DMACRO'
     Define macro MACRO with the string `1' as its definition.

`-DMACRO=DEFN'
     Define macro MACRO as DEFN.  All instances of `-D' on the command
     line are processed before any `-U' options.

     Any `-D' and `-U' options on the command line are processed in
     order, and always before `-imacros FILE', regardless of the order
     in which they are written.

`-UMACRO'
     Undefine macro MACRO.  `-U' options are evaluated after all `-D'
     options, but before any `-include' and `-imacros' options.

     Any `-D' and `-U' options on the command line are processed in
     order, and always before `-imacros FILE', regardless of the order
     in which they are written.

`-dM'
     Tell the preprocessor to output only a list of the macro
     definitions that are in effect at the end of preprocessing.  Used
     with the `-E' option.

`-dD'
     Tell the preprocessing to pass all macro definitions into the
     output, in their proper sequence in the rest of the output.

`-dN'
     Like `-dD' except that the macro arguments and contents are
     omitted.  Only `#define NAME' is included in the output.

`-dI'
     Output `#include' directives in addition to the result of
     preprocessing.

`-fpreprocessed'
     Indicate to the preprocessor that the input file has already been
     preprocessed.  This suppresses things like macro expansion,
     trigraph conversion, escaped newline splicing, and processing of
     most directives.  In this mode the integrated preprocessor is
     little more than a tokenizer for the front ends.

     `-fpreprocessed' is implicit if the input file has one of the
     extensions `i', `ii' or `mi' indicating it has already been
     preprocessed.

`-trigraphs'
     Process ISO standard trigraph sequences.  These are three-character
     sequences, all starting with `??', that are defined by ISO C to
     stand for single characters.  For example, `??/' stands for `\',
     so `'??/n'' is a character constant for a newline.  By default,
     GCC ignores trigraphs, but in standard-conforming modes it
     converts them.  See the `-std' and `-ansi' options.

     The nine trigraph sequences are
    `??('
          -> `['

    `??)'
          -> `]'

    `??<'
          -> `{'

    `??>'
          -> `}'

    `??='
          -> `#'

    `??/'
          -> `\'

    `??''
          -> `^'

    `??!'
          -> `|'

    `??-'
          -> `~'

     Trigraph support is not popular, so many compilers do not
     implement it properly.  Portable code should not rely on trigraphs
     being either converted or ignored.

`-Wp,OPTION'
     Pass OPTION as an option to the preprocessor.  If OPTION contains
     commas, it is split into multiple options at the commas.


File: gcc.info,  Node: Assembler Options,  Next: Link Options,  Prev: Preprocessor Options,  Up: Invoking GCC

Passing Options to the Assembler
================================

   You can pass options to the assembler.

`-Wa,OPTION'
     Pass OPTION as an option to the assembler.  If OPTION contains
     commas, it is split into multiple options at the commas.


File: gcc.info,  Node: Link Options,  Next: Directory Options,  Prev: Assembler Options,  Up: Invoking GCC

Options for Linking
===================

   These options come into play when the compiler links object files
into an executable output file.  They are meaningless if the compiler is
not doing a link step.

`OBJECT-FILE-NAME'
     A file name that does not end in a special recognized suffix is
     considered to name an object file or library.  (Object files are
     distinguished from libraries by the linker according to the file
     contents.)  If linking is done, these object files are used as
     input to the linker.

`-c'
`-S'
`-E'
     If any of these options is used, then the linker is not run, and
     object file names should not be used as arguments.  *Note Overall
     Options::.

`-lLIBRARY'
     Search the library named LIBRARY when linking.

     It makes a difference where in the command you write this option;
     the linker searches processes libraries and object files in the
     order they are specified.  Thus, `foo.o -lz bar.o' searches
     library `z' after file `foo.o' but before `bar.o'.  If `bar.o'
     refers to functions in `z', those functions may not be loaded.

     The linker searches a standard list of directories for the library,
     which is actually a file named `libLIBRARY.a'.  The linker then
     uses this file as if it had been specified precisely by name.

     The directories searched include several standard system
     directories plus any that you specify with `-L'.

     Normally the files found this way are library files--archive files
     whose members are object files.  The linker handles an archive
     file by scanning through it for members which define symbols that
     have so far been referenced but not defined.  But if the file that
     is found is an ordinary object file, it is linked in the usual
     fashion.  The only difference between using an `-l' option and
     specifying a file name is that `-l' surrounds LIBRARY with `lib'
     and `.a' and searches several directories.

`-lobjc'
     You need this special case of the `-l' option in order to link an
     Objective C program.

`-nostartfiles'
     Do not use the standard system startup files when linking.  The
     standard system libraries are used normally, unless `-nostdlib' or
     `-nodefaultlibs' is used.

`-nodefaultlibs'
     Do not use the standard system libraries when linking.  Only the
     libraries you specify will be passed to the linker.  The standard
     startup files are used normally, unless `-nostartfiles' is used.
     The compiler may generate calls to memcmp, memset, and memcpy for
     System V (and ISO C) environments or to bcopy and bzero for BSD
     environments.  These entries are usually resolved by entries in
     libc.  These entry points should be supplied through some other
     mechanism when this option is specified.

`-nostdlib'
     Do not use the standard system startup files or libraries when
     linking.  No startup files and only the libraries you specify will
     be passed to the linker. The compiler may generate calls to
     memcmp, memset, and memcpy for System V (and ISO C) environments
     or to bcopy and bzero for BSD environments.  These entries are
     usually resolved by entries in libc.  These entry points should be
     supplied through some other mechanism when this option is
     specified.

     One of the standard libraries bypassed by `-nostdlib' and
     `-nodefaultlibs' is `libgcc.a', a library of internal subroutines
     that GCC uses to overcome shortcomings of particular machines, or
     special needs for some languages.  (*Note Interfacing to GCC
     Output: Interface, for more discussion of `libgcc.a'.)  In most
     cases, you need `libgcc.a' even when you want to avoid other
     standard libraries.  In other words, when you specify `-nostdlib'
     or `-nodefaultlibs' you should usually specify `-lgcc' as well.
     This ensures that you have no unresolved references to internal GCC
     library subroutines.  (For example, `__main', used to ensure C++
     constructors will be called; *note `collect2': Collect2..)

`-s'
     Remove all symbol table and relocation information from the
     executable.

`-static'
     On systems that support dynamic linking, this prevents linking
     with the shared libraries.  On other systems, this option has no
     effect.

`-shared'
     Produce a shared object which can then be linked with other
     objects to form an executable.  Not all systems support this
     option.  For predictable results, you must also specify the same
     set of options that were used to generate code (`-fpic', `-fPIC',
     or model suboptions) when you specify this option.(1)

`-shared-libgcc'
`-static-libgcc'
     On systems that provide `libgcc' as a shared library, these options
     force the use of either the shared or static version respectively.
     If no shared version of `libgcc' was built when the compiler was
     configured, these options have no effect.

     There are several situations in which an application should use the
     shared `libgcc' instead of the static version.  The most common of
     these is when the application wishes to throw and catch exceptions
     across different shared libraries.  In that case, each of the
     libraries as well as the application itself should use the shared
     `libgcc'.

     Therefore, whenever you specify the `-shared' option, the GCC
     driver automatically adds `-shared-libgcc', unless you explicitly
     specify `-static-libgcc'.  The G++ driver automatically adds
     `-shared-libgcc' when you build a main executable as well because
     for C++ programs that is typically the right thing to do.
     (Exception-handling will not work reliably otherwise.)

     However, when linking a main executable written in C, you must
     explicitly say `-shared-libgcc' if you want to use the shared
     `libgcc'.

`-symbolic'
     Bind references to global symbols when building a shared object.
     Warn about any unresolved references (unless overridden by the
     link editor option `-Xlinker -z -Xlinker defs').  Only a few
     systems support this option.

`-Xlinker OPTION'
     Pass OPTION as an option to the linker.  You can use this to
     supply system-specific linker options which GCC does not know how
     to recognize.

     If you want to pass an option that takes an argument, you must use
     `-Xlinker' twice, once for the option and once for the argument.
     For example, to pass `-assert definitions', you must write
     `-Xlinker -assert -Xlinker definitions'.  It does not work to write
     `-Xlinker "-assert definitions"', because this passes the entire
     string as a single argument, which is not what the linker expects.

`-Wl,OPTION'
     Pass OPTION as an option to the linker.  If OPTION contains
     commas, it is split into multiple options at the commas.

`-u SYMBOL'
     Pretend the symbol SYMBOL is undefined, to force linking of
     library modules to define it.  You can use `-u' multiple times with
     different symbols to force loading of additional library modules.

   ---------- Footnotes ----------

   (1) On some systems, `gcc -shared' needs to build supplementary stub
code for constructors to work. On multi-libbed systems, `gcc -shared'
must select the correct support libraries to link against.  Failing to
supply the correct flags may lead to subtle defects. Supplying them in
cases where they are not necessary is innocuous.


File: gcc.info,  Node: Directory Options,  Next: Spec Files,  Prev: Link Options,  Up: Invoking GCC

Options for Directory Search
============================

   These options specify directories to search for header files, for
libraries and for parts of the compiler:

`-IDIR'
     Add the directory DIR to the head of the list of directories to be
     searched for header files.  This can be used to override a system
     header file, substituting your own version, since these
     directories are searched before the system header file
     directories.  However, you should not use this option to add
     directories that contain vendor-supplied system header files (use
     `-isystem' for that). If you use more than one `-I' option, the
     directories are scanned in left-to-right order; the standard
     system directories come after.

`-I-'
     Any directories you specify with `-I' options before the `-I-'
     option are searched only for the case of `#include "FILE"'; they
     are not searched for `#include <FILE>'.

     If additional directories are specified with `-I' options after
     the `-I-', these directories are searched for all `#include'
     directives.  (Ordinarily _all_ `-I' directories are used this way.)

     In addition, the `-I-' option inhibits the use of the current
     directory (where the current input file came from) as the first
     search directory for `#include "FILE"'.  There is no way to
     override this effect of `-I-'.  With `-I.' you can specify
     searching the directory which was current when the compiler was
     invoked.  That is not exactly the same as what the preprocessor
     does by default, but it is often satisfactory.

     `-I-' does not inhibit the use of the standard system directories
     for header files.  Thus, `-I-' and `-nostdinc' are independent.

`-LDIR'
     Add directory DIR to the list of directories to be searched for
     `-l'.

`-BPREFIX'
     This option specifies where to find the executables, libraries,
     include files, and data files of the compiler itself.

     The compiler driver program runs one or more of the subprograms
     `cpp', `cc1', `as' and `ld'.  It tries PREFIX as a prefix for each
     program it tries to run, both with and without `MACHINE/VERSION/'
     (*note Target Options::).

     For each subprogram to be run, the compiler driver first tries the
     `-B' prefix, if any.  If that name is not found, or if `-B' was
     not specified, the driver tries two standard prefixes, which are
     `/usr/lib/gcc/' and `/usr/local/lib/gcc-lib/'.  If neither of
     those results in a file name that is found, the unmodified program
     name is searched for using the directories specified in your
     `PATH' environment variable.

     `-B' prefixes that effectively specify directory names also apply
     to libraries in the linker, because the compiler translates these
     options into `-L' options for the linker.  They also apply to
     includes files in the preprocessor, because the compiler
     translates these options into `-isystem' options for the
     preprocessor.  In this case, the compiler appends `include' to the
     prefix.

     The run-time support file `libgcc.a' can also be searched for using
     the `-B' prefix, if needed.  If it is not found there, the two
     standard prefixes above are tried, and that is all.  The file is
     left out of the link if it is not found by those means.

     Another way to specify a prefix much like the `-B' prefix is to use
     the environment variable `GCC_EXEC_PREFIX'.  *Note Environment
     Variables::.

`-specs=FILE'
     Process FILE after the compiler reads in the standard `specs'
     file, in order to override the defaults that the `gcc' driver
     program uses when determining what switches to pass to `cc1',
     `cc1plus', `as', `ld', etc.  More than one `-specs=FILE' can be
     specified on the command line, and they are processed in order,
     from left to right.


File: gcc.info,  Node: Spec Files,  Next: Target Options,  Prev: Directory Options,  Up: Invoking GCC

Specifying subprocesses and the switches to pass to them
========================================================

   `gcc' is a driver program.  It performs its job by invoking a
sequence of other programs to do the work of compiling, assembling and
linking.  GCC interprets its command-line parameters and uses these to
deduce which programs it should invoke, and which command-line options
it ought to place on their command lines.  This behaviour is controlled
by "spec strings".  In most cases there is one spec string for each
program that GCC can invoke, but a few programs have multiple spec
strings to control their behaviour.  The spec strings built into GCC can
be overridden by using the `-specs=' command-line switch to specify a
spec file.

   "Spec files" are plaintext files that are used to construct spec
strings.  They consist of a sequence of directives separated by blank
lines.  The type of directive is determined by the first non-whitespace
character on the line and it can be one of the following:

`%COMMAND'
     Issues a COMMAND to the spec file processor.  The commands that can
     appear here are:

    `%include <FILE>'
          Search for FILE and insert its text at the current point in
          the specs file.

    `%include_noerr <FILE>'
          Just like `%include', but do not generate an error message if
          the include file cannot be found.

    `%rename OLD_NAME NEW_NAME'
          Rename the spec string OLD_NAME to NEW_NAME.

`*[SPEC_NAME]:'
     This tells the compiler to create, override or delete the named
     spec string.  All lines after this directive up to the next
     directive or blank line are considered to be the text for the spec
     string.  If this results in an empty string then the spec will be
     deleted.  (Or, if the spec did not exist, then nothing will
     happened.)  Otherwise, if the spec does not currently exist a new
     spec will be created.  If the spec does exist then its contents
     will be overridden by the text of this directive, unless the first
     character of that text is the `+' character, in which case the
     text will be appended to the spec.

`[SUFFIX]:'
     Creates a new `[SUFFIX] spec' pair.  All lines after this directive
     and up to the next directive or blank line are considered to make
     up the spec string for the indicated suffix.  When the compiler
     encounters an input file with the named suffix, it will processes
     the spec string in order to work out how to compile that file.
     For example:

          .ZZ:
          z-compile -input %i

     This says that any input file whose name ends in `.ZZ' should be
     passed to the program `z-compile', which should be invoked with the
     command-line switch `-input' and with the result of performing the
     `%i' substitution.  (See below.)

     As an alternative to providing a spec string, the text that
     follows a suffix directive can be one of the following:

    `@LANGUAGE'
          This says that the suffix is an alias for a known LANGUAGE.
          This is similar to using the `-x' command-line switch to GCC
          to specify a language explicitly.  For example:

               .ZZ:
               @c++

          Says that .ZZ files are, in fact, C++ source files.

    `#NAME'
          This causes an error messages saying:

               NAME compiler not installed on this system.

     GCC already has an extensive list of suffixes built into it.  This
     directive will add an entry to the end of the list of suffixes, but
     since the list is searched from the end backwards, it is
     effectively possible to override earlier entries using this
     technique.

   GCC has the following spec strings built into it.  Spec files can
override these strings or create their own.  Note that individual
targets can also add their own spec strings to this list.

     asm          Options to pass to the assembler
     asm_final    Options to pass to the assembler post-processor
     cpp          Options to pass to the C preprocessor
     cc1          Options to pass to the C compiler
     cc1plus      Options to pass to the C++ compiler
     endfile      Object files to include at the end of the link
     link         Options to pass to the linker
     lib          Libraries to include on the command line to the linker
     libgcc       Decides which GCC support library to pass to the linker
     linker       Sets the name of the linker
     predefines   Defines to be passed to the C preprocessor
     signed_char  Defines to pass to CPP to say whether `char' is signed
                  by default
     startfile    Object files to include at the start of the link

   Here is a small example of a spec file:

     %rename lib                 old_lib
     
     *lib:
     --start-group -lgcc -lc -leval1 --end-group %(old_lib)

   This example renames the spec called `lib' to `old_lib' and then
overrides the previous definition of `lib' with a new one.  The new
definition adds in some extra command-line options before including the
text of the old definition.

   "Spec strings" are a list of command-line options to be passed to
their corresponding program.  In addition, the spec strings can contain
`%'-prefixed sequences to substitute variable text or to conditionally
insert text into the command line.  Using these constructs it is
possible to generate quite complex command lines.

   Here is a table of all defined `%'-sequences for spec strings.  Note
that spaces are not generated automatically around the results of
expanding these sequences.  Therefore you can concatenate them together
or combine them with constant text in a single argument.

`%%'
     Substitute one `%' into the program name or argument.

`%i'
     Substitute the name of the input file being processed.

`%b'
     Substitute the basename of the input file being processed.  This
     is the substring up to (and not including) the last period and not
     including the directory.

`%B'
     This is the same as `%b', but include the file suffix (text after
     the last period).

`%d'
     Marks the argument containing or following the `%d' as a temporary
     file name, so that that file will be deleted if GCC exits
     successfully.  Unlike `%g', this contributes no text to the
     argument.

`%gSUFFIX'
     Substitute a file name that has suffix SUFFIX and is chosen once
     per compilation, and mark the argument in the same way as `%d'.
     To reduce exposure to denial-of-service attacks, the file name is
     now chosen in a way that is hard to predict even when previously
     chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
     might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX
     matches the regexp `[.A-Za-z]*' or the special string `%O', which
     is treated exactly as if `%O' had been preprocessed.  Previously,
     `%g' was simply substituted with a file name chosen once per
     compilation, without regard to any appended suffix (which was
     therefore treated just like ordinary text), making such attacks
     more likely to succeed.

`%uSUFFIX'
     Like `%g', but generates a new temporary file name even if
     `%uSUFFIX' was already seen.

`%USUFFIX'
     Substitutes the last file name generated with `%uSUFFIX',
     generating a new one if there is no such last file name.  In the
     absence of any `%uSUFFIX', this is just like `%gSUFFIX', except
     they don't share the same suffix _space_, so `%g.s ... %U.s ...
     %g.s ... %U.s' would involve the generation of two distinct file
     names, one for each `%g.s' and another for each `%U.s'.
     Previously, `%U' was simply substituted with a file name chosen
     for the previous `%u', without regard to any appended suffix.

`%jSUFFIX'
     Substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
     writable, and if save-temps is off; otherwise, substitute the name
     of a temporary file, just like `%u'.  This temporary file is not
     meant for communication between processes, but rather as a junk
     disposal mechanism.

`%.SUFFIX'
     Substitutes .SUFFIX for the suffixes of a matched switch's args
     when it is subsequently output with `%*'. SUFFIX is terminated by
     the next space or %.

`%w'
     Marks the argument containing or following the `%w' as the
     designated output file of this compilation.  This puts the argument
     into the sequence of arguments that `%o' will substitute later.

`%o'
     Substitutes the names of all the output files, with spaces
     automatically placed around them.  You should write spaces around
     the `%o' as well or the results are undefined.  `%o' is for use in
     the specs for running the linker.  Input files whose names have no
     recognized suffix are not compiled at all, but they are included
     among the output files, so they will be linked.

`%O'
     Substitutes the suffix for object files.  Note that this is
     handled specially when it immediately follows `%g, %u, or %U',
     because of the need for those to form complete file names.  The
     handling is such that `%O' is treated exactly as if it had already
     been substituted, except that `%g, %u, and %U' do not currently
     support additional SUFFIX characters following `%O' as they would
     following, for example, `.o'.

`%p'
     Substitutes the standard macro predefinitions for the current
     target machine.  Use this when running `cpp'.

`%P'
     Like `%p', but puts `__' before and after the name of each
     predefined macro, except for macros that start with `__' or with
     `_L', where L is an uppercase letter.  This is for ISO C.

`%I'
     Substitute a `-iprefix' option made from GCC_EXEC_PREFIX.

`%s'
     Current argument is the name of a library or startup file of some
     sort.  Search for that file in a standard list of directories and
     substitute the full name found.

`%eSTR'
     Print STR as an error message.  STR is terminated by a newline.
     Use this when inconsistent options are detected.

`%|'
     Output `-' if the input for the current command is coming from a
     pipe.

`%(NAME)'
     Substitute the contents of spec string NAME at this point.

`%[NAME]'
     Like `%(...)' but put `__' around `-D' arguments.

`%x{OPTION}'
     Accumulate an option for `%X'.

`%X'
     Output the accumulated linker options specified by `-Wl' or a `%x'
     spec string.

`%Y'
     Output the accumulated assembler options specified by `-Wa'.

`%Z'
     Output the accumulated preprocessor options specified by `-Wp'.

`%v1'
     Substitute the major version number of GCC.  (For version 2.9.5,
     this is 2.)

`%v2'
     Substitute the minor version number of GCC.  (For version 2.9.5,
     this is 9.)

`%v3'
     Substitute the patch level number of GCC.  (For version 2.9.5,
     this is 5.)

`%a'
     Process the `asm' spec.  This is used to compute the switches to
     be passed to the assembler.

`%A'
     Process the `asm_final' spec.  This is a spec string for passing
     switches to an assembler post-processor, if such a program is
     needed.

`%l'
     Process the `link' spec.  This is the spec for computing the
     command line passed to the linker.  Typically it will make use of
     the `%L %G %S %D and %E' sequences.

`%D'
     Dump out a `-L' option for each directory that GCC believes might
     contain startup files.  If the target supports multilibs then the
     current multilib directory will be prepended to each of these
     paths.

`%M'
     Output the multilib directory with directory separators replaced
     with `_'.  If multilib directories are not set, or the multilib
     directory is `.' then this option emits nothing.

`%L'
     Process the `lib' spec.  This is a spec string for deciding which
     libraries should be included on the command line to the linker.

`%G'
     Process the `libgcc' spec.  This is a spec string for deciding
     which GCC support library should be included on the command line
     to the linker.

`%S'
     Process the `startfile' spec.  This is a spec for deciding which
     object files should be the first ones passed to the linker.
     Typically this might be a file named `crt0.o'.

`%E'
     Process the `endfile' spec.  This is a spec string that specifies
     the last object files that will be passed to the linker.

`%C'
     Process the `cpp' spec.  This is used to construct the arguments
     to be passed to the C preprocessor.

`%c'
     Process the `signed_char' spec.  This is intended to be used to
     tell cpp whether a char is signed.  It typically has the
     definition:
          %{funsigned-char:-D__CHAR_UNSIGNED__}

`%1'
     Process the `cc1' spec.  This is used to construct the options to
     be passed to the actual C compiler (`cc1').

`%2'
     Process the `cc1plus' spec.  This is used to construct the options
     to be passed to the actual C++ compiler (`cc1plus').

`%*'
     Substitute the variable part of a matched option.  See below.
     Note that each comma in the substituted string is replaced by a
     single space.

`%{`S'}'
     Substitutes the `-S' switch, if that switch was given to GCC.  If
     that switch was not specified, this substitutes nothing.  Note that
     the leading dash is omitted when specifying this option, and it is
     automatically inserted if the substitution is performed.  Thus the
     spec string `%{foo}' would match the command-line option `-foo'
     and would output the command line option `-foo'.

`%W{`S'}'
     Like %{`S'} but mark last argument supplied within as a file to be
     deleted on failure.

`%{`S'*}'
     Substitutes all the switches specified to GCC whose names start
     with `-S', but which also take an argument.  This is used for
     switches like `-o', `-D', `-I', etc.  GCC considers `-o foo' as
     being one switch whose names starts with `o'.  %{o*} would
     substitute this text, including the space.  Thus two arguments
     would be generated.

`%{^`S'*}'
     Like %{`S'*}, but don't put a blank between a switch and its
     argument.  Thus %{^o*} would only generate one argument, not two.

`%{`S'*&`T'*}'
     Like %{`S'*}, but preserve order of `S' and `T' options (the order
     of `S' and `T' in the spec is not significant).  There can be any
     number of ampersand-separated variables; for each the wild card is
     optional.  Useful for CPP as `%{D*&U*&A*}'.

`%{<`S'}'
     Remove all occurrences of `-S' from the command line.  Note--this
     command is position dependent.  `%' commands in the spec string
     before this option will see `-S', `%' commands in the spec string
     after this option will not.

`%{`S'*:`X'}'
     Substitutes `X' if one or more switches whose names start with
     `-S' are specified to GCC.  Note that the tail part of the `-S'
     option (i.e. the part matched by the `*') will be substituted for
     each occurrence of `%*' within `X'.

`%{`S':`X'}'
     Substitutes `X', but only if the `-S' switch was given to GCC.

`%{!`S':`X'}'
     Substitutes `X', but only if the `-S' switch was _not_ given to
     GCC.

`%{|`S':`X'}'
     Like %{`S':`X'}, but if no `S' switch, substitute `-'.

`%{|!`S':`X'}'
     Like %{!`S':`X'}, but if there is an `S' switch, substitute `-'.

`%{.`S':`X'}'
     Substitutes `X', but only if processing a file with suffix `S'.

`%{!.`S':`X'}'
     Substitutes `X', but only if _not_ processing a file with suffix
     `S'.

`%{`S'|`P':`X'}'
     Substitutes `X' if either `-S' or `-P' was given to GCC.  This may
     be combined with `!' and `.' sequences as well, although they have
     a stronger binding than the `|'.  For example a spec string like
     this:

          %{.c:-foo} %{!.c:-bar} %{.c|d:-baz} %{!.c|d:-boggle}

     will output the following command-line options from the following
     input command-line options:

          fred.c        -foo -baz
          jim.d         -bar -boggle
          -d fred.c     -foo -baz -boggle
          -d jim.d      -bar -baz -boggle

   The conditional text `X' in a %{`S':`X'} or %{!`S':`X'} construct
may contain other nested `%' constructs or spaces, or even newlines.
They are processed as usual, as described above.

   The `-O', `-f', `-m', and `-W' switches are handled specifically in
these constructs.  If another value of `-O' or the negated form of a
`-f', `-m', or `-W' switch is found later in the command line, the
earlier switch value is ignored, except with {`S'*} where `S' is just
one letter, which passes all matching options.

   The character `|' at the beginning of the predicate text is used to
indicate that a command should be piped to the following command, but
only if `-pipe' is specified.

   It is built into GCC which switches take arguments and which do not.
(You might think it would be useful to generalize this to allow each
compiler's spec to say which switches take arguments.  But this cannot
be done in a consistent fashion.  GCC cannot even decide which input
files have been specified without knowing which switches take arguments,
and it must know which input files to compile in order to tell which
compilers to run).

   GCC also knows implicitly that arguments starting in `-l' are to be
treated as compiler output files, and passed to the linker in their
proper position among the other output files.


File: gcc.info,  Node: Target Options,  Next: Submodel Options,  Prev: Spec Files,  Up: Invoking GCC

Specifying Target Machine and Compiler Version
==============================================

   By default, GCC compiles code for the same type of machine that you
are using.  However, it can also be installed as a cross-compiler, to
compile for some other type of machine.  In fact, several different
configurations of GCC, for different target machines, can be installed
side by side.  Then you specify which one to use with the `-b' option.

   In addition, older and newer versions of GCC can be installed side
by side.  One of them (probably the newest) will be the default, but
you may sometimes wish to use another.

`-b MACHINE'
     The argument MACHINE specifies the target machine for compilation.
     This is useful when you have installed GCC as a cross-compiler.

     The value to use for MACHINE is the same as was specified as the
     machine type when configuring GCC as a cross-compiler.  For
     example, if a cross-compiler was configured with `configure
     i386v', meaning to compile for an 80386 running System V, then you
     would specify `-b i386v' to run that cross compiler.

     When you do not specify `-b', it normally means to compile for the
     same type of machine that you are using.

`-V VERSION'
     The argument VERSION specifies which version of GCC to run.  This
     is useful when multiple versions are installed.  For example,
     VERSION might be `2.0', meaning to run GCC version 2.0.

     The default version, when you do not specify `-V', is the last
     version of GCC that you installed.

   The `-b' and `-V' options actually work by controlling part of the
file name used for the executable files and libraries used for
compilation.  A given version of GCC, for a given target machine, is
normally kept in the directory `/usr/local/lib/gcc-lib/MACHINE/VERSION'.

   Thus, sites can customize the effect of `-b' or `-V' either by
changing the names of these directories or adding alternate names (or
symbolic links).  If in directory `/usr/local/lib/gcc-lib/' the file
`80386' is a link to the file `i386v', then `-b 80386' becomes an alias
for `-b i386v'.

   In one respect, the `-b' or `-V' do not completely change to a
different compiler: the top-level driver program `gcc' that you
originally invoked continues to run and invoke the other executables
(preprocessor, compiler per se, assembler and linker) that do the real
work.  However, since no real work is done in the driver program, it
usually does not matter that the driver program in use is not the one
for the specified target.  It is common for the interface to the other
executables to change incompatibly between compiler versions, so unless
the version specified is very close to that of the driver (for example,
`-V 3.0' with a driver program from GCC version 3.0.1), use of `-V' may
not work; for example, using `-V 2.95.2' will not work with a driver
program from GCC 3.0.

   The only way that the driver program depends on the target machine is
in the parsing and handling of special machine-specific options.
However, this is controlled by a file which is found, along with the
other executables, in the directory for the specified version and
target machine.  As a result, a single installed driver program adapts
to any specified target machine, and sufficiently similar compiler
versions.

   The driver program executable does control one significant thing,
however: the default version and target machine.  Therefore, you can
install different instances of the driver program, compiled for
different targets or versions, under different names.

   For example, if the driver for version 2.0 is installed as `ogcc'
and that for version 2.1 is installed as `gcc', then the command `gcc'
will use version 2.1 by default, while `ogcc' will use 2.0 by default.
However, you can choose either version with either command with the
`-V' option.


File: gcc.info,  Node: Submodel Options,  Next: Code Gen Options,  Prev: Target Options,  Up: Invoking GCC

Hardware Models and Configurations
==================================

   Earlier we discussed the standard option `-b' which chooses among
different installed compilers for completely different target machines,
such as Vax vs. 68000 vs. 80386.

   In addition, each of these target machine types can have its own
special options, starting with `-m', to choose among various hardware
models or configurations--for example, 68010 vs 68020, floating
coprocessor or none.  A single installed version of the compiler can
compile for any model or configuration, according to the options
specified.

   Some configurations of the compiler also support additional special
options, usually for compatibility with other compilers on the same
platform.

   These options are defined by the macro `TARGET_SWITCHES' in the
machine description.  The default for the options is also defined by
that macro, which enables you to change the defaults.

* Menu:

* M680x0 Options::
* M68hc1x Options::
* VAX Options::
* SPARC Options::
* Convex Options::
* AMD29K Options::
* ARM Options::
* MN10200 Options::
* MN10300 Options::
* M32R/D Options::
* M88K Options::
* RS/6000 and PowerPC Options::
* RT Options::
* MIPS Options::
* i386 Options::
* HPPA Options::
* Intel 960 Options::
* DEC Alpha Options::
* Clipper Options::
* H8/300 Options::
* SH Options::
* System V Options::
* TMS320C3x/C4x Options::
* V850 Options::
* ARC Options::
* NS32K Options::
* AVR Options::
* MCore Options::
* IA-64 Options::
* D30V Options::

