This is Info file gcc.info, produced by Makeinfo-1.47 from the input
file gcc.texi.
   This file documents the use and the internals of the GNU compiler.
   Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc.
   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and "Boycott"
are included exactly as in the original, and provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.
   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License" and "Boycott", and this permission notice, may be included in
translations approved by the Free Software Foundation instead of in the
original English.
File: gcc.info,  Node: Warning Options,  Next: Debugging Options,  Prev: Dialect Options,  Up: Invoking GCC
Options to Request or Suppress Warnings
=======================================
   Warnings are diagnostic messages that report constructions which are
not inherently erroneous but which are risky or suggest there may have
been an error.
   You can request many specific warnings with options beginning `-W',
for example `-Wimplicit' to request warnings on implicit declarations. 
Each of these specific warning options also has a negative form
beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'. 
This manual lists only one of the two forms, whichever is not the
default.
   These options control the amount and kinds of warnings produced by
GNU CC:
`-fsyntax-only'
     Check the code for syntax errors, but don't emit any output.
     Inhibit all warning messages.
`-Wno_import'
     Inhibit warning messages about the use of `#import'.
`-pedantic'
     Issue all the warnings demanded by strict ANSI standard C; reject
     all programs that use forbidden extensions.
     Valid ANSI standard C programs should compile properly with or
     without this option (though a rare few will require `-ansi'). 
     However, without this option, certain GNU extensions and
     traditional C features are supported as well.  With this option,
     they are rejected.
     `-pedantic' does not cause warning messages for use of the
     alternate keywords whose names begin and end with `__'.  Pedantic
     warnings are also disabled in the expression that follows
     `__extension__'.  However, only system header files should use
     these escape routes; application programs should avoid them. *Note
     Alternate Keywords::.
     This option is not intended to be useful; it exists only to satisfy
     pedants who would otherwise claim that GNU CC fails to support the
     ANSI standard.
     Some users try to use `-pedantic' to check programs for strict ANSI
     C conformance.  They soon find that it does not do quite what they
     want: it finds some non-ANSI practices, but not all--only those
     for which ANSI C *requires* a diagnostic.
     A feature to report any failure to conform to ANSI C might be
     useful in some instances, but would require considerable
     additional work and would be quite different from `-pedantic'.  We
     recommend, rather, that users take advantage of the extensions of
     GNU C and disregard the limitations of other compilers.  Aside
     from certain supercomputers and obsolete small machines, there is
     less and less reason ever to use any other C compiler other than
     for bootstrapping GNU CC.
`-pedantic-errors'
     Like `-pedantic', except that errors are produced rather than
     warnings.
     Print extra warning messages for these events:
        * A nonvolatile automatic variable might be changed by a call to
          `longjmp'.  These warnings as well are possible only in
          optimizing compilation.
          The compiler sees only the calls to `setjmp'.  It cannot know
          where `longjmp' will be called; in fact, a signal handler
          could call it at any point in the code.  As a result, you may
          get a warning even when there is in fact no problem because
          `longjmp' cannot in fact be called at the place which would
          cause a problem.
        * A function can return either with or without a value. 
          (Falling off the end of the function body is considered
          returning without a value.)  For example, this function would
          evoke such a warning:
               foo (a)
               {
                 if (a > 0)
                   return a;
               }
        * An expression-statement contains no side effects.
        * An unsigned value is compared against zero with `>' or `<='.
`-Wimplicit'
     Warn whenever a function or parameter is implicitly declared.
`-Wreturn-type'
     Warn whenever a function is defined with a return-type that
     defaults to `int'.  Also warn about any `return' statement with no
     return-value in a function whose return-type is not `void'.
`-Wunused'
     Warn whenever a local variable is unused aside from its
     declaration, whenever a function is declared static but never
     defined, and whenever a statement computes a result that is
     explicitly not used.
`-Wswitch'
     Warn whenever a `switch' statement has an index of enumeral type
     and lacks a `case' for one or more of the named codes of that
     enumeration.  (The presence of a `default' label prevents this
     warning.)  `case' labels outside the enumeration range also
     provoke warnings when this option is used.
`-Wcomment'
     Warn whenever a comment-start sequence `/*' appears in a comment.
`-Wtrigraphs'
     Warn if any trigraphs are encountered (assuming they are enabled).
`-Wformat'
     Check calls to `printf' and `scanf', etc., to make sure that the
     arguments supplied have types appropriate to the format string
     specified.
`-Wchar-subscripts'
     Warn if an array subscript has type `char'.  This is a common cause
     of error, as programmers often forget that this type is signed on
     some machines.
`-Wuninitialized'
     An automatic variable is used without first being initialized.
     These warnings are possible only in optimizing compilation,
     because they require data flow information that is computed only
     when optimizing.  If you don't specify `-O', you simply won't get
     these warnings.
     These warnings occur only for variables that are candidates for
     register allocation.  Therefore, they do not occur for a variable
     that is declared `volatile', or whose address is taken, or whose
     size is other than 1, 2, 4 or 8 bytes.  Also, they do not occur for
     structures, unions or arrays, even when they are in registers.
     Note that there may be no warning about a variable that is used
     only to compute a value that itself is never used, because such
     computations may be deleted by data flow analysis before the
     warnings are printed.
     These warnings are made optional because GNU CC is not smart
     enough to see all the reasons why the code might be correct
     despite appearing to have an error.  Here is one example of how
     this can happen:
          {
            int x;
            switch (y)
              {
              case 1: x = 1;
                break;
              case 2: x = 4;
                break;
              case 3: x = 5;
              }
            foo (x);
          }
     If the value of `y' is always 1, 2 or 3, then `x' is always
     initialized, but GNU CC doesn't know this.  Here is another common
     case:
          {
            int save_y;
            if (change_y) save_y = y, y = new_y;
            ...
            if (change_y) y = save_y;
          }
     This has no bug because `save_y' is used only if it is set.
     Some spurious warnings can be avoided if you declare as `volatile'
     all the functions you use that never return. *Note Function
     Attributes::.
`-Wparentheses'
     Warn if parentheses are omitted in certain contexts.
`-Wall'
     All of the above `-W' options combined.  These are all the options
     which pertain to usage that we recommend avoiding and that we
     believe is easy to avoid, even in conjunction with macros.
   The remaining `-W...' options are not implied by `-Wall' because
they warn about constructions that we consider reasonable to use, on
occasion, in clean programs.
`-Wtraditional'
     Warn about certain constructs that behave differently in
     traditional and ANSI C.
        * Macro arguments occurring within string constants in the
          macro body. These would substitute the argument in
          traditional C, but are part of the constant in ANSI C.
        * A function declared external in one block and then used after
          the end of the block.
        * A `switch' statement has an operand of type `long'.
`-Wshadow'
     Warn whenever a local variable shadows another local variable.
`-Wid-clash-LEN'
     Warn whenever two distinct identifiers match in the first LEN
     characters.  This may help you prepare a program that will compile
     with certain obsolete, brain-damaged compilers.
`-Wpointer-arith'
     Warn about anything that depends on the "size of" a function type
     or of `void'.  GNU C assigns these types a size of 1, for
     convenience in calculations with `void *' pointers and pointers to
     functions.
`-Wcast-qual'
     Warn whenever a pointer is cast so as to remove a type qualifier
     from the target type.  For example, warn if a `const char *' is
     cast to an ordinary `char *'.
`-Wcast-align'
     Warn whenever a pointer is cast such that the required alignment
     of the target is increased.  For example, warn if a `char *' is
     cast to an `int *' on machines where integers can only be accessed
     at two- or four-byte boundaries.
`-Wwrite-strings'
     Give string constants the type `const char[LENGTH]' so that
     copying the address of one into a non-`const' `char *' pointer
     will get a warning.  These warnings will help you find at compile
     time code that can try to write into a string constant, but only
     if you have been very careful about using `const' in declarations
     and prototypes.  Otherwise, it will just be a nuisance; this is
     why we did not make `-Wall' request these warnings.
`-Wconversion'
     Warn if a prototype causes a type conversion that is different
     from what would happen to the same argument in the absence of a
     prototype.  This includes conversions of fixed point to floating
     and vice versa, and conversions changing the width or signedness
     of a fixed point argument except when the same as the default
     promotion.
`-Waggregate-return'
     Warn if any functions that return structures or unions are defined
     or called.  (In languages where you can return an array, this also
     elicits a warning.)
`-Wstrict-prototypes'
     Warn if a function is declared or defined without specifying the
     argument types.  (An old-style function definition is permitted
     without a warning if preceded by a declaration which specifies the
     argument types.)
`-Wmissing-prototypes'
     Warn if a global function is defined without a previous prototype
     declaration.  This warning is issued even if the definition itself
     provides a prototype.  The aim is to detect global functions that
     fail to be declared in header files.
`-Wredundant-decls'
     Warn if anything is declared more than once in the same scope,
     even in cases where multiple declaration is valid and changes
     nothing.
`-Wnested-externs'
     Warn if an `extern' declaration is encountered within an function.
`-Winline'
     Warn if a function can not be inlined, and either it was declared
     as inline, or else the `-finline-functions' option was given.
`-Werror'
     Make all warnings into errors.
File: gcc.info,  Node: Debugging Options,  Next: Optimize Options,  Prev: Warning Options,  Up: Invoking GCC
Options for Debugging Your Program or GNU CC
============================================
   GNU CC has various special options that are used for debugging
either your program or GCC:
     Produce debugging information in the operating system's native
     format (stabs, COFF, XCOFF, or DWARF).  GDB can work with this
     debugging information.
     On most systems that use stabs format, `-g' enables use of extra
     debugging information that only GDB can use; this extra information
     makes debugging work better in GDB but will probably make DBX
     crash or refuse to read the program.  If you want to control for
     certain whether to generate the extra information, use `-gstabs+'
     or `-gstabs' (see below).
     Unlike most other C compilers, GNU CC allows you to use `-g' with
     `-O'.  The shortcuts taken by optimized code may occasionally
     produce surprising results: some variables you declared may not
     exist at all; flow of control may briefly move where you did not
     expect it; some statements may not be executed because they
     compute constant results or their values were already at hand;
     some statements may execute in different places because they were
     moved out of loops.
     Nevertheless it proves possible to debug optimized output.  This
     makes it reasonable to use the optimizer for programs that might
     have bugs.
     The following options are useful when GNU CC is generated with the
     capability for more than one debugging format.
`-ggdb'
     Produce debugging information in the native format (if that is
     supported), including GDB extensions if at all possible.
`-gstabs'
     Produce debugging information in stabs format (if that is
     supported), without GDB extensions.  This is the format used by
     DBX on most BSD systems.
`-gstabs+'
     Produce debugging information in stabs format (if that is
     supported), using GDB extensions.  The use of these extensions is
     likely to make DBX crash or refuse to read the program.
`-gcoff'
     Produce debugging information in COFF format (if that is
     supported). This is the format used by SDB on COFF systems.
`-gxcoff'
     Produce debugging information in XCOFF format (if that is
     supported). This is the format used on IBM RS/6000 systems.
`-gdwarf'
     Produce debugging information in DWARF format (if that is
     supported). This is the format used by SDB on systems that use
     DWARF.
`-gLEVEL'
`-ggdbLEVEL'
`-gstabsLEVEL'
`-gcoffLEVEL'
`-gxcoffLEVEL'
`-gdwarfLEVEL'
     Request debugging information and also use LEVEL to specify how
     much information.  The default level is 2.
     Level 1 produces minimal information, enough for making backtraces
     in parts of the program that you don't plan to debug.  This
     includes descriptions of functions and external variables, but no
     information about local variables and no line numbers.
     Level 3 includes extra information, such as all the macro
     definitions present in the program.  Some debuggers support macro
     expansion when you use `-g3'.
     Generate extra code to write profile information suitable for the
     analysis program `prof'.
`-pg'
     Generate extra code to write profile information suitable for the
     analysis program `gprof'.
     Generate extra code to write profile information for basic blocks,
     which will record the number of times each basic block is executed.
     This data could be analyzed by a program like `tcov'.  Note,
     however, that the format of the data is not what `tcov' expects.
     Eventually GNU `gprof' should be extended to process this data.
`-dLETTERS'
     Says to make debugging dumps during compilation at times specified
     by LETTERS.  This is used for debugging the compiler.  The file
     names for most of the dumps are made by appending a word to the
     source file name (e.g.  `foo.c.rtl' or `foo.c.jump').  Here are the
     possible letters for use in LETTERS, and their meanings:
    `M'
          Dump all macro definitions, at the end of preprocessing, and
          write no output.
    `N'
          Dump all macro names, at the end of preprocessing.
    `D'
          Dump all macro definitions, at the end of preprocessing, in
          addition to normal output.
    `y'
          Dump debugging information during parsing, to standard error.
    `r'
          Dump after RTL generation, to `FILE.rtl'.
    `x'
          Just generate RTL for a function instead of compiling it. 
          Usually used with `r'.
    `j'
          Dump after first jump optimization, to `FILE.jump'.
    `s'
          Dump after CSE (including the jump optimization that sometimes
          follows CSE), to `FILE.cse'.
    `L'
          Dump after loop optimization, to `FILE.loop'.
    `t'
          Dump after the second CSE pass (including the jump
          optimization that sometimes follows CSE), to `FILE.cse2'.
    `f'
          Dump after flow analysis, to `FILE.flow'.
    `c'
          Dump after instruction combination, to `FILE.combine'.
    `S'
          Dump after the first instruction scheduling pass, to
          `FILE.sched'.
    `l'
          Dump after local register allocation, to `FILE.lreg'.
    `g'
          Dump after global register allocation, to `FILE.greg'.
    `R'
          Dump after the second instruction scheduling pass, to
          `FILE.sched2'.
    `J'
          Dump after last jump optimization, to `FILE.jump2'.
    `d'
          Dump after delayed branch scheduling, to `FILE.dbr'.
    `k'
          Dump after conversion from registers to stack, to
          `FILE.stack'.
    `a'
          Produce all the dumps listed above.
    `m'
          Print statistics on memory usage, at the end of the run, to
          standard error.
    `p'
          Annotate the assembler output with a comment indicating which
          pattern and alternative was used.
`-fpretend-float'
     When running a cross-compiler, pretend that the target machine
     uses the same floating point format as the host machine.  This
     causes incorrect output of the actual floating constants, but the
     actual instruction sequence will probably be the same as GNU CC
     would make when running on the target machine.
`-save-temps'
     Store the usual "temporary" intermediate files permanently; place
     them in the current directory and name them based on the source
     file.  Thus, compiling `foo.c' with `-c -save-temps' would produce
     files `foo.i' and `foo.s', as well as `foo.o'.
File: gcc.info,  Node: Optimize Options,  Next: Preprocessor Options,  Prev: Debugging Options,  Up: Invoking GCC
Options That Control Optimization
=================================
   These options control various sorts of optimizations:
     Optimize.  Optimizing compilation takes somewhat more time, and a
     lot more memory for a large function.
     Without `-O', the compiler's goal is to reduce the cost of
     compilation and to make debugging produce the expected results.
     Statements are independent: if you stop the program with a
     breakpoint between statements, you can then assign a new value to
     any variable or change the program counter to any other statement
     in the function and get exactly the results you would expect from
     the source code.
     Without `-O', only variables declared `register' are allocated in
     registers.  The resulting compiled code is a little worse than
     produced by PCC without `-O'.
     With `-O', the compiler tries to reduce code size and execution
     time.
     When `-O' is specified, `-fthread-jumps' and `-fdelayed-branch'
     are turned on.  On some machines other flags may also be turned on.
`-O2'
     Optimize even more.  Nearly all supported optimizations that do not
     involve a space-speed tradeoff are performed.  As compared to `-O',
     this option increases both compilation time and the performance of
     the generated code.
     `-O2' turns on all `-fFLAG' options that enable more optimization,
     except for `-funroll-loops', `-funroll-all-loops' and
     `-fomit-frame-pointer'.
   Options of the form `-fFLAG' specify machine-independent flags. 
Most flags have both positive and negative forms; the negative form of
`-ffoo' would be `-fno-foo'.  In the table below, only one of the forms
is listed--the one which is not the default. You can figure out the
other form by either removing `no-' or adding it.
`-ffloat-store'
     Do not store floating point variables in registers.  This prevents
     undesirable excess precision on machines such as the 68000 where
     the floating registers (of the 68881) keep more precision than a
     `double' is supposed to have.
     For most programs, the excess precision does only good, but a few
     programs rely on the precise definition of IEEE floating point.
     Use `-ffloat-store' for such programs.
`-fno-defer-pop'
     Always pop the arguments to each function call as soon as that
     function returns.  For machines which must pop arguments after a
     function call, the compiler normally lets arguments accumulate on
     the stack for several function calls and pops them all at once.
`-fforce-mem'
     Force memory operands to be copied into registers before doing
     arithmetic on them.  This may produce better code by making all
     memory references potential common subexpressions.  When they are
     not common subexpressions, instruction combination should
     eliminate the separate register-load.  I am interested in hearing
     about the difference this makes.
`-fforce-addr'
     Force memory address constants to be copied into registers before
     doing arithmetic on them.  This may produce better code just as
     `-fforce-mem' may.  I am interested in hearing about the
     difference this makes.
`-fomit-frame-pointer'
     Don't keep the frame pointer in a register for functions that
     don't need one.  This avoids the instructions to save, set up and
     restore frame pointers; it also makes an extra register available
     in many functions.  *It also makes debugging impossible on some
     machines.*
     On some machines, such as the Vax, this flag has no effect, because
     the standard calling sequence automatically handles the frame
     pointer and nothing is saved by pretending it doesn't exist.  The
     machine-description macro `FRAME_POINTER_REQUIRED' controls
     whether a target machine supports this flag.  *Note Registers::.
`-fno-inline'
     Don't pay attention to the `inline' keyword.  Normally this option
     is used to keep the compiler from expanding any functions inline.
`-finline-functions'
     Integrate all simple functions into their callers.  The compiler
     heuristically decides which functions are simple enough to be worth
     integrating in this way.
     If all calls to a given function are integrated, and the function
     is declared `static', then the function is normally not output as
     assembler code in its own right.
`-fkeep-inline-functions'
     Even if all calls to a given function are integrated, and the
     function is declared `static', nevertheless output a separate
     run-time callable version of the function.
`-fno-function-cse'
     Do not put function addresses in registers; make each instruction
     that calls a constant function contain the function's address
     explicitly.
     This option results in less efficient code, but some strange hacks
     that alter the assembler output may be confused by the
     optimizations performed when this option is not used.
`-ffast-math'
     This option allows GCC to violate some ANSI or IEEE
     rules/specifications in the interest of optimizing code for speed.
      For example, it allows the compiler to assume arguments to the
     `sqrt' function are non-negative numbers.
     This option should never be turned on by any `-O' option since it
     can result in incorrect output for programs which depend on an
     exact implementation of IEEE or ANSI rules/specifications for math
     functions.
   The following options control specific optimizations.  The `-O2'
option turns on all of these optimizations except `-funroll-loops' and
`-funroll-all-loops'.  The `-O' option usually turns on the
`-fthread-jumps' and `-fdelayed-branch' options, but specific machines
may change the default optimizations.
   You can use the following flags in the rare cases when "fine-tuning"
of optimizations to be performed is desired.
`-fstrength-reduce'
     Perform the optimizations of loop strength reduction and
     elimination of iteration variables.
`-fthread-jumps'
     Perform optimizations where we check to see if a jump branches to a
     location where another comparison subsumed by the first is found. 
     If so, the first branch is redirected to either the destination of
     the second branch or a point immediately following it, depending
     on whether the condition is known to be true or false.
`-fcse-follow-jumps'
     In common subexpression elimination, scan through jump instructions
     when the target of the jump is not reached by any other path.  For
     example, when CSE encounters an `if' statement with an `else'
     clause, CSE will follow the jump when the condition tested is
     false.
`-fcse-skip-blocks'
     This is similar to `-fcse-follow-jumps', but causes CSE to follow
     jumps which conditionally skip over blocks.  When CSE encounters a
     simple `if' statement with no else clause, `-fcse-skip-blocks'
     causes CSE to follow the jump around the body of the `if'.
`-frerun-cse-after-loop'
     Re-run common subexpression elimination after loop optimizations
     has been performed.
`-fexpensive-optimizations'
     Perform a number of minor optimizations that are relatively
     expensive.
`-fdelayed-branch'
     If supported for the target machine, attempt to reorder
     instructions to exploit instruction slots available after delayed
     branch instructions.
`-fschedule-insns'
     If supported for the target machine, attempt to reorder
     instructions to eliminate execution stalls due to required data
     being unavailable.  This helps machines that have slow floating
     point or memory load instructions by allowing other instructions
     to be issued until the result of the load or floating point
     instruction is required.
`-fschedule-insns2'
     Similar to `-fschedule-insns', but requests an additional pass of
     instruction scheduling after register allocation has been done. 
     This is especially useful on machines with a relatively small
     number of registers and where memory load instructions take more
     than one cycle.
`-fcaller-saves'
     Enable values to be allocated in registers that will be clobbered
     by function calls, by emitting extra instructions to save and
     restore the registers around such calls.  Such allocation is done
     only when it seems to result in better code than would otherwise
     be produced.
     This option is enabled by default on certain machines, usually
     those which have no call-preserved registers to use instead.
`-funroll-loops'
     Perform the optimization of loop unrolling.  This is only done for
     loops whose number of iterations can be determined at compile time
     or run time. `-funroll-loop' implies `-fstrength-reduce' and
     `-frerun-cse-after-loop'.
`-funroll-all-loops'
     Perform the optimization of loop unrolling.  This is done for all
     loops and usually makes programs run more slowly. 
     `-funroll-all-loops' implies `-fstrength-reduce' and
     `-frerun-cse-after-loop'.
`-fno-peephole'
     Disable any machine-specific peephole optimizations.
File: gcc.info,  Node: Preprocessor Options,  Next: Link 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.
     Any `-D' and `-U' options on the command line are always processed
     before `-imacros 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.
`-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.
`-nostdinc++'
     Do not search for header files in the C++-specific standard
     directories, but do still search the other standard directories.
     (This option is used when building `libg++'.)
`-undef'
     Do not predefine any nonstandard macros.  (Including architecture
     flags).
     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.
     Tell the preprocessor not to discard comments.  Used with the `-E'
     option.
     Tell the preprocessor not to generate `#line' commands. Used with
     the `-E' option.
     Tell the preprocessor to output a rule suitable for `make'
     describing the dependencies of each object file.  For each source
     file, the preprocessor outputs one `make'-rule whose target is the
     object file name for that source file and whose dependencies are
     all the files `#include'd in it.  This rule may be a single line
     or may be continued with `\'-newline if it is long.  The list of
     rules is printed on standard output instead of the preprocessed C
     program.
     `-M' implies `-E'.
     Another way to specify output of a `make' rule is by setting the
     environment variable `DEPENDENCIES_OUTPUT' (*note Environment
     Variables::.).
`-MM'
     Like `-M' but the output mentions only the user header files
     included with `#include "FILE"'.  System header files included
     with `#include <FILE>' are omitted.
`-MD'
     Like `-M' but the dependency information is written to files with
     names made by replacing `.c' with `.d' at the end of the input
     file names.  This is in addition to compiling the file as
     specified--`-MD' does not inhibit ordinary compilation the way
     `-M' does.
     The Mach utility `md' can be used to merge the `.d' 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.
     Print the name of each header file used, in addition to other
     normal activities.
`-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.
`-UMACRO'
     Undefine macro MACRO.  `-U' options are evaluated after all `-D'
     options, but before any `-include' and `-imacros' options.
`-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.
`-trigraphs'
     Support ANSI C trigraphs.  You don't want to know about this
     brain-damage.  The `-ansi' option also has this effect.
File: gcc.info,  Node: Link Options,  Next: Directory Options,  Prev: Preprocessor 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.
     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.
`-nostdlib'
     Don't use the standard system libraries and startup files when
     linking. Only the files you specify will be passed to the linker.
`-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.  Only a few systems support this
     option.
`-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 GNU CC 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.
File: gcc.info,  Node: Directory Options,  Next: Target Options,  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'
     Append directory DIR to the list of directories searched for
     include files.
`-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 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.
     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::.
File: gcc.info,  Node: Target Options,  Next: Submodel Options,  Prev: Directory Options,  Up: Invoking GCC
Specifying Target Machine and Compiler Version
==============================================
   By default, GNU CC 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 GNU CC, 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 GNU CC 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 GNU CC as a cross-compiler.
     The value to use for MACHINE is the same as was specified as the
     machine type when configuring GNU CC 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 GNU CC to run.
     This is useful when multiple versions are installed.  For example,
     VERSION might be `2.0', meaning to run GNU CC version 2.0.
     The default version, when you do not specify `-V', is controlled
     by the way GNU CC is installed.  Normally, it will be a version
     that is recommended for general use.
   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 GNU CC, for a given target machine, is
normally kept in the directory `/usr/local/lib/gcc-lib/MACHINE/VERSION'.
   It follows that sites can customize the effect of `-b' or `-V'
either by changing the names of these directories or adding alternate
names (or symbolic links).  Thus, if `/usr/local/lib/gcc-lib/80386' is
a link to `/usr/local/lib/gcc-lib/i386v', then `-b 80386' will be 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 and version.
   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 compiler version.
   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
Specifying 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.
   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::
* VAX Options::
* SPARC Options::
* Convex Options::
* AMD29K Options::
* M88K Options::
* RS/6000 Options::
* RT Options::
* MIPS Options::
* i386 Options::
File: gcc.info,  Node: M680x0 Options,  Next: Vax Options,  Prev: Submodel Options,  Up: Submodel Options
M680x0 Options
--------------
   These are the `-m' options defined for the 68000 series.  The default
values for these options depends on which style of 68000 was selected
when the compiler was configured; the defaults for the most common
choices are given below.
`-m68020'
`-mc68020'
     Generate output for a 68020 (rather than a 68000).  This is the
     default when the compiler is configured for 68020-based systems.
`-m68000'
`-mc68000'
     Generate output for a 68000 (rather than a 68020).  This is the
     default when the compiler is configured for a 68000-based systems.
`-m68881'
     Generate output containing 68881 instructions for floating point.
     This is the default for most 68020 systems unless `-nfp' was
     specified when the compiler was configured.
`-mfpa'
     Generate output containing Sun FPA instructions for floating point.
`-msoft-float'
     Generate output containing library calls for floating point.
     *Warning:* the requisite libraries are not part of GNU CC.
     Normally the facilities of the machine's usual C compiler are
     used, but this can't be done directly in cross-compilation.  You
     must make your own arrangements to provide suitable library
     functions for cross-compilation.
`-mshort'
     Consider type `int' to be 16 bits wide, like `short int'.
`-mnobitfield'
     Do not use the bit-field instructions.  `-m68000' implies
     `-mnobitfield'.
`-mbitfield'
     Do use the bit-field instructions.  `-m68020' implies
     `-mbitfield'.  This is the default if you use the unmodified
     sources configured for a 68020.
`-mrtd'
     Use a different function-calling convention, in which functions
     that take a fixed number of arguments return with the `rtd'
     instruction, which pops their arguments while returning.  This
     saves one instruction in the caller since there is no need to pop
     the arguments there.
     This calling convention is incompatible with the one normally used
     on Unix, so you cannot use it if you need to call libraries
     compiled with the Unix compiler.
     Also, you must provide function prototypes for all functions that
     take variable numbers of arguments (including `printf'); otherwise
     incorrect code will be generated for calls to those functions.
     In addition, seriously incorrect code will result if you call a
     function with too many arguments.  (Normally, extra arguments are
     harmlessly ignored.)
     The `rtd' instruction is supported by the 68010 and 68020
     processors, but not by the 68000.
File: gcc.info,  Node: VAX Options,  Next: Sparc Options,  Prev: M680x0 Options,  Up: Submodel Options
VAX Options
-----------
   These `-m' options are defined for the Vax:
`-munix'
     Do not output certain jump instructions (`aobleq' and so on) that
     the Unix assembler for the Vax cannot handle across long ranges.
`-mgnu'
     Do output those jump instructions, on the assumption that you will
     assemble with the GNU assembler.
`-mg'
     Output code for g-format floating point numbers instead of
     d-format.
File: gcc.info,  Node: Sparc Options,  Next: Convex Options,  Prev: Vax Options,  Up: Submodel Options
SPARC Options
-------------
   These `-m' switches are supported on the Sparc:
`-mforce-align'
     Make sure all objects of type `double' are 8-byte aligned in memory
     and use double-word instructions to reference them.
`-mno-epilogue'
     Generate separate return instructions for `return' statements.
     This has both advantages and disadvantages; I don't recall what
     they are.
File: gcc.info,  Node: Convex Options,  Next: AMD29K Options,  Prev: SPARC Options,  Up: Submodel Options
Convex Options
--------------
   These `-m' options are defined for the Convex:
`-mc1'
     Generate output for a C1.  This is the default when the compiler is
     configured for a C1.
`-mc2'
     Generate output for a C2.  This is the default when the compiler is
     configured for a C2.
`-margcount'
     Generate code which puts an argument count in the word preceding
     each argument list.  Some nonportable Convex and Vax programs need
     this word. (Debuggers don't, except for functions with
     variable-length argument lists; this info is in the symbol table.)
`-mnoargcount'
     Omit the argument count word.  This is the default if you use the
     unmodified sources.
File: gcc.info,  Node: AMD29K Options,  Next: M88K Options,  Prev: Convex Options,  Up: Submodel Options
AMD29K Options
--------------
   These `-m' options are defined for the AMD Am29000:
`-mdw'
     Generate code that assumes the `DW' bit is set, i.e., that byte and
     halfword operations are directly supported by the hardware.  This
     is the default.
`-mnodw'
     Generate code that assumes the `DW' bit is not set.
`-mbw'
     Generate code that assumes the system supports byte and halfword
     write operations.  This is the default.
`-mnbw'
     Generate code that assumes the systems does not support byte and
     halfword write operations.  `-mnbw' implies `-mnodw'.
`-msmall'
     Use a small memory model that assumes that all function addresses
     are either within a single 256 KB segment or at an absolute
     address of less than 256K.  This allows the `call' instruction to
     be used instead of a `const', `consth', `calli' sequence.
`-mlarge'
     Do not assume that the `call' instruction can be used; this is the
     default.
`-m29050'
     Generate code for the Am29050.
`-m29000'
     Generate code for the Am29000.  This is the default.
`-mkernel-registers'
     Generate references to registers `gr64-gr95' instead of
     `gr96-gr127'.  This option can be used when compiling kernel code
     that wants a set of global registers disjoint from that used by
     user-mode code.
     Note that when this option is used, register names in `-f' flags
     must use the normal, user-mode, names.
`-muser-registers'
     Use the normal set of global registers, `gr96-gr127'.  This is the
     default.
`-mstack-check'
     Insert a call to `__msp_check' after each stack adjustment.  This
     is often used for kernel code.