MAN page from Trustix gcc-2.95.3-1tr.i586.rpm


Section: GNU Tools (1)
Updated: 1998/12/16


gcc, g++ - GNU project C and C++ Compiler (gcc-2.95) 


gcc[ option | filename ]...
g++[ option | filename ]... 


The information in this man page is an extract from the fulldocumentation of the GNU C compiler, and is limited to the meaning ofthe options.

This man page is not kept up to date except when volunteers want tomaintain it. If you find a discrepancy between the man page and thesoftware, please check the Info file, which is the authoritativedocumentation.

If we find that the things in this man page that are out of date causesignificant confusion or complaints, we will stop distributing the manpage. The alternative, updating the man page when we update the Infofile, is impossible because the rest of the work of maintaining GNU CCleaves us no time for that. The GNU project regards man pages asobsolete and should not let them take time away from other things.

For complete and current documentation, refer to the Info file `gcc' or the manualUsing and Porting GNU CC (for version 2.0). Both are made from the Texinfo source filegcc.texinfo. 


The C and C++ compilers are integrated. Both process input filesthrough one or more of four stages: preprocessing, compilation,assembly, and linking. Source filename suffixes identify the sourcelanguage, but which name you use for the compiler governs defaultassumptions:
assumes preprocessed (.i) files are C and assumes C style linking.
assumes preprocessed (.i) files are C++ and assumes C++ style linking.

Suffixes of source file names indicate the language and kind ofprocessing to be done:

.c      C source; preprocess, compile, assemble.C      C++ source; preprocess, compile,     C++ source; preprocess, compile, assemble.cxx    C++ source; preprocess, compile, assemble.m      Objective-C source; preprocess, compile, assemble.i      preprocessed C; compile, assemble.ii     preprocessed C++; compile, assemble.s      Assembler source; assemble.S      Assembler source; preprocess, assemble.h      Preprocessor file; not usually named on command line
Files with other suffixes are passed to the linker. Common cases include:

.o      Object file.a      Archive file

Linking is always the last stage unless you use one of the-c,-S,or-Eoptions to avoid it (or unless compilation errors stop the wholeprocess). For the link stage, all.ofiles corresponding to source files,-llibraries, unrecognized filenames (including named.oobject files and.aarchives)are passed to the linker in command-line order. 


Options must be separate: `-dr' is quite different from `-d -r'.

Most `-f' and `-W' options have two contrary forms:-fnameand-fno-name (or-Wnameand-Wno-name). Only the non-default forms are shown here.

Here is a summary of all the options, grouped by type. Explanations arein the following sections.

Overall Options

-c-S-E-o file-pipe-v-x language
Language Options
Warning Options
Debugging Options
Optimization Options
Preprocessor Options
-Aassertion-C-dD-dM-dN-Dmacro[=defn]-E-H-idirafter dir-include file-imacros file-iprefix file-iwithprefix dir-M-MD-MM-MMD-nostdinc-P-Umacro-undef
Assembler Option
Linker Options
-llibrary-nostartfiles-nostdlib-static-shared-symbolic-Xlinker option-Wl,option-u symbol
Directory Options
Target Options
-b machine-V version
Configuration Dependent Options
M680x0 Options

VAX Options

SPARC Options

Convex Options

AMD29K Options

M88K Options

RS6000 Options

RT Options

MIPS Options
-mcpu=cpu type-mips2-mips3-mint64-mlong64-mlonglong128-mmips-as-mgas-mrnames-mno-rnames-mgpopt-mno-gpopt-mstats-mno-stats-mmemcpy-mno-memcpy-mno-mips-tfile-mmips-tfile-msoft-float-mhard-float-mabicalls-mno-abicalls-mhalf-pic-mno-half-pic-G num-nocpp

i386 Options

HPPA Options

i960 Options

DEC Alpha Options

System V Options

Code Generation Options


-x language
Specify explicitly thelanguage for the following input files (rather than choosing a default basedon the file name suffix) . This option applies to all following inputfiles until the next `-x' option. Possible values of language are`c', `objective-c', `c-header', `c++',`cpp-output', `assembler', and `assembler-with-cpp'.
-x none
Turn off any specification of a language, so that subsequent files arehandled according to their file name suffixes (as they are if `-x'has not been used at all).

If you want only some of the four stages (preprocess, compile,assemble, link), you can use`-x' (or filename suffixes) to tell gcc where to start, andone of the options `-c', `-S', or `-E' to say wheregcc is to stop. Note that some combinations (for example,`-x cpp-output -E') instruct gcc to do nothing at all.

Compile or assemble the source files, but do not link. The compileroutput is an object file corresponding to each source file.

By default, GCC makes the object file name for a source file by replacingthe suffix `.c', `.i', `.s', etc., with `.o'. Use-o to select another name.

GCC ignores any unrecognized input files (those that do not requirecompilation or assembly) with the-coption.

Stop after the stage of compilation proper; do not assemble. The outputis an assembler code file for each non-assembler inputfile specified.

By default, GCC makes the assembler file name for a source file byreplacing the suffix `.c', `.i', etc., with `.s'. Use-o to select another name.

GCC ignores any input files that don't require compilation.

Stop after the preprocessing stage; do not run the compiler proper. Theoutput is preprocessed source code, which is sent to thestandard output.

GCC ignores input files which don't require preprocessing.

-o file
Place output in file file. This applies regardless to whateversort of output GCC is producing, whether it be an executable file,an object file, an assembler file or preprocessed C code.

Since only one output file can be specified, it does not make sense touse `-o' when compiling more than one input file, unless you areproducing an executable file as output.

If you do not specify `-o', the default is to put an executable filein `a.out', the object file for `source.suffix' in`source.o', its assembler file in `source.s', andall preprocessed C source on standard output.

Print (on standard error output) the commands executed to run the stagesof compilation. Also print the version number of the compiler driverprogram and of the preprocessor and the compiler proper.
Use pipes rather than temporary files for communication between thevarious stages of compilation. This fails to work on some systems wherethe assembler cannot read from a pipe; but the GNU assembler hasno trouble.



The following options control the dialect of C that the compileraccepts:
Support all ANSI standard C programs.

This turns off certain features of GNU C that are incompatible withANSI C, such as the asm, inline and typeofkeywords, and predefined macros such as unix and vaxthat identify the type of system you are using. It also enables theundesirable and rarely used ANSI trigraph feature, and disallows `$' as part of identifiers.

The alternate keywords __asm__, __extension__,__inline__ and __typeof__ continue to work despite`-ansi'. You would not want to use them in an ANSI C program, ofcourse, but it is useful to put them in header files that might be includedin compilations done with `-ansi'. Alternate predefined macrossuch as __unix__ and __vax__ are also available, with orwithout `-ansi'.

The `-ansi' option does not cause non-ANSI programs to berejected gratuitously. For that, `-pedantic' is required inaddition to `-ansi'.

The preprocessor predefines a macro __STRICT_ANSI__ when you use the `-ansi'option. Some header files may notice this macro and refrainfrom declaring certain functions or defining certain macros that theANSI standard doesn't call for; this is to avoid interfering with anyprograms that might use these names for other things.

Do not recognize asm, inline or typeof as akeyword. These words may then be used as identifiers. You canuse __asm__, __inline__ and __typeof__ instead.`-ansi' implies `-fno-asm'.
Don't recognize built-in functions that do not begin with two leadingunderscores. Currently, the functions affected include _exit,abort, abs, alloca, cos, exit,fabs, labs, memcmp, memcpy, sin,sqrt, strcmp, strcpy, and strlen.

The `-ansi' option prevents alloca and _exit frombeing builtin functions.

Compile for a hosted environment; this implies the `-fbuiltin' option, and implies that suspicious declarations ofmain should be warned about.
Compile for a freestanding environment; this implies the `-fno-builtin' option, and implies thatmain has no special requirements.
Treat a function declaration with no arguments, such as `int foo();', as C would treat it---as saying nothing about the number ofarguments or their types (C++ only). Normally, such a declaration inC++ means that the function foo takes no arguments.
Support ANSI C trigraphs. The `-ansi' option implies `-trigraphs'.
Attempt to support some aspects of traditional C compilers.For details, see the GNU C Manual; the duplicate list herehas been deleted so that we won't get complaints when itis out of date.

But one note about C++ programs only (not C). `-traditional' has one additional effect for C++: assignment tothisis permitted. This is the same as the effect of `-fthis-is-variable'.

Attempt to support some aspects of traditional C preprocessors.This includes the items that specifically mention the preprocessor above,but none of the other effects of `-traditional'.
Permit the use of `$' in identifiers (C++ only). You can also use`-fno-dollars-in-identifiers' to explicitly prohibit use of`$'. (GNU C++ allows `$' by default on some target systemsbut not others.)
Permit implicit conversion of int to enumeration types (C++only). Normally GNU C++ allows conversion of enum to int,but not the other way around.
Produce smaller code for template declarations, by generating only asingle copy of each template function where it is defined (C++ only).To use this option successfully, you must also mark all files thatuse templates with either `#pragma implementation' (the definition) or`#pragma interface' (declarations).

When your code is compiled with `-fexternal-templates', alltemplate instantiations are external. You must arrange for allnecessary instantiations to appear in the implementation file; you cando this with a typedef that references each instantiation needed.Conversely, when you compile using the default option`-fno-external-templates', all template instantiations areexplicitly internal.

Treat all possible member functions as virtual, implicitly. Allmember functions (except for constructor functions andnewordeletemember operators) are treated as virtual functions of the class wherethey appear.

This does not mean that all calls to these member functions will bemade through the internal table of virtual functions. Under somecircumstances, the compiler can determine that a call to a givenvirtual function can be made directly; in these cases the calls aredirect in any case.

Allow conditional expressions with mismatched types in the second andthird arguments. The value of such an expression is void.
Permit assignment to this (C++ only). The incorporation ofuser-defined free store management into C++ has made assignment to`this' an anachronism. Therefore, by default it is invalid toassign to this within a class member function. However, forbackwards compatibility, you can make it valid with`-fthis-is-variable'.
Let the type char be unsigned, like unsigned char.

Each kind of machine has a default for what char shouldbe. It is either like unsigned char by default or likesigned char by default.

Ideally, a portable program should always use signed char orunsigned char when it depends on the signedness of an object.But many programs have been written to use plain char andexpect it to be signed, or expect it to be unsigned, depending on themachines they were written for. This option, and its inverse, let youmake such a program work with the opposite default.

The type char is always a distinct type from each ofsigned char and unsigned char, even though its behavioris always just like one of those two.

Let the type char be signed, like signed char.

Note that this is equivalent to `-fno-unsigned-char', which isthe negative form of `-funsigned-char'. Likewise,`-fno-signed-char' is equivalent to `-funsigned-char'.

These options control whether a bitfield issigned or unsigned, when declared with no explicit `signed' or `unsigned' qualifier. By default, such a bitfield issigned, because this is consistent: the basic integer types such asint are signed types.

However, when you specify `-traditional', bitfields are all unsignedno matter what.

Store string constants in the writable data segment and don't uniquizethem. This is for compatibility with old programs which assume theycan write into string constants. `-traditional' also has thiseffect.

Writing into string constants is a very bad idea; ``constants'' shouldbe constant.



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

If you use the `-E' option, GCC does nothing except preprocessing.Some of these options make sense only together with `-E' becausethey cause the preprocessor output to be unsuitable for actualcompilation.

-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 arewritten. All the `-include' and `-imacros' options areprocessed in the order in which they are written.
-imacros file
Process file as input, discarding the resulting output, beforeprocessing the regular input file. Because the output generated fromfile is discarded, the only effect of `-imacros file' is tomake the macros defined in file available for use in the maininput. The preprocessor evaluates any `-D' and `-U' optionson the command line before processing `-imacrosfile', regardless of the order inwhich they are written. 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 directorieson the second include path are searched when a header file is not foundin 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 ismade by concatenating prefix and dir, where prefixwas specified previously with `-iprefix'.
Do not search the standard system directories for header files. Onlythe directories you have specified with `-I' options (and thecurrent directory, if appropriate) are searched.

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

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++'.)
Do not predefine any nonstandard macros. (Including architecture flags).
Run only the C preprocessor. Preprocess all the C source filesspecified and output the results to standard output or to thespecified 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.
-M  [ -MG ]
Tell the preprocessor to output a rule suitable for makedescribing the dependencies of each object file. For each source file,the preprocessor outputs one make-rule whose target is the objectfile 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 becontinued with `\'-newline if it is long. The list of rules isprinted on standard output instead of the preprocessed C program.

`-M' implies `-E'.

`-MG' says to treat missing header files as generated files and assume they live in the same directory as the source file. It must be specified in addition to `-M'.

-MM  [ -MG ]
Like `-M' but the output mentions only the user header filesincluded with `#include file"'. System header filesincluded with `#include <file>' are omitted.
Like `-M' but the dependency information is written to files withnames made by replacing `.o' with `.d' at the end of theoutput file names. This is in addition to compiling the file asspecified---`-MD' does not inhibit ordinary compilation the way`-M' does.

The Mach utility `md' can be used to merge the `.d' filesinto a single dependency file suitable for using with the `make'command.

Like `-MD' except mention only user header files, not systemheader files.
Print the name of each header file used, in addition to other normalactivities.
Assert the answeranswerforquestion, in case it is testedwith a preprocessor conditional such as `#if #question(answer)'. `-A-' disables the standardassertions that normally describe the target machine.
(answer)Assert the answer answer for question, in case it is testedwith a preprocessor conditional such as `#if#question(answer)'. `-A-' disables the standardassertions that normally describe the target machine.
Define macro macro with the string `1' as its definition.
Define macro macro as defn. All instances of `-D' onthe command line are processed before any `-U' options.
Undefine macro macro. `-U' options are evaluated after all `-D' options, but before any `-include' and `-imacros' options.
Tell the preprocessor to output only a list of the macro definitionsthat are in effect at the end of preprocessing. Used with the `-E'option.
Tell the preprocessor to pass all macro definitions into the output, intheir proper sequence in the rest of the output.
Like `-dD' except that the macro arguments and contents are omitted.Only `#define name' is included in the output.


Pass option as an option to the assembler. If optioncontains commas, it is split into multiple options at the commas.


These options come into play when the compiler links object files intoan executable output file. They are meaningless if the compiler isnot doing a link step.
A file name that does not end in a special recognized suffix isconsidered to name an object file or library. (Object files aredistinguished from libraries by the linker according to the filecontents.) If GCC does a link step, these object files are used as inputto the linker.
Use the library named library when linking.

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

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

Normally the files found this way are library files---archive fileswhose members are object files. The linker handles an archive file byscanning through it for members which define symbols that have so farbeen referenced but not defined. However, if the linker finds anordinary object file rather than a library, the object file is linkedin the usual fashion. The only difference between using an `-l' option and specifying a filename is that `-l' surroundslibrarywith `lib' and `.a' and searches several directories.

You need this special case of the-loption in order to link an Objective C program.
Do not use the standard system startup files when linking.The standard libraries are used normally.
Don't use the standard system libraries and startup files when linking.Only the files you specify will be passed to the linker.
On systems that support dynamic linking, this prevents linking with the sharedlibraries. On other systems, this option has no effect.
Produce a shared object which can then be linked with other objects toform an executable. Only a few systems support this option.
Bind references to global symbols when building a shared object. Warnabout any unresolved references (unless overridden by the link editoroption `-Xlinker -z -Xlinker defs'). Only a few systems supportthis option.
-Xlinker option
Pass optionas an option to the linker. You can use this tosupply system-specific linker options which GNU CC does not know how torecognize.

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 entirestring as a single argument, which is not what the linker expects.

Pass option as an option to the linker. If option containscommas, it is split into multiple options at the commas.
-u symbol
Pretend the symbolsymbolis undefined, to force linking oflibrary modules to define it. You can use `-u' multiple times withdifferent symbols to force loading of additional library modules.


These options specify directories to search for header files, forlibraries and for parts of the compiler:
Append directory dir to the list of directories searched for include files.
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 afterthe `-I-', these directories are searched for all `#include'directives. (Ordinarily all `-I' directories are usedthis way.)

In addition, the `-I-' option inhibits the use of the currentdirectory (where the current input file came from) as the first searchdirectory for `#include "file"'. There is no way tooverride this effect of `-I-'. With `-I.' you can specifysearching the directory which was current when the compiler wasinvoked. That is not exactly the same as what the preprocessor doesby default, but it is often satisfactory.

`-I-' does not inhibit the use of the standard system directoriesfor header files. Thus, `-I-' and `-nostdinc' areindependent.

Add directory dir to the list of directories to be searchedfor `-l'.
This option specifies where to find the executables, libraries anddata files of the compiler itself.

The compiler driver program runs one or more of the subprograms`cpp', `cc1' (or, for C++, `cc1plus'), `as' and `ld'. It triesprefix as a prefix for each program it tries to run, both with andwithout `machine/version/'.

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 ofthose results in a file name that is found, the compiler driversearches for the unmodified programname, using the directories specified in your`PATH' environment variable.

The run-time support file `libgcc.a' is also searched for using the`-B' prefix, if needed. If it is not found there, the twostandard prefixes above are tried, and that is all. The file is leftout of the link if it is not found by those means. Most of the time,on most machines, `libgcc.a' is not actually necessary.

You can get a similar result from the environment variableGCC_EXEC_PREFIX; if it is defined, its value is used as a prefixin the same way. If both the `-B' option and theGCC_EXEC_PREFIX variable are present, the `-B' option isused first and the environment variable value second.



Warnings are diagnostic messages that report constructions whichare not inherently erroneous but which are risky or suggest theremay have been an error.

These options control the amount and kinds of warnings produced by GNUCC:

Check the code for syntax errors, but don't emit any output.
Inhibit all warning messages.
Inhibit warning messages about the use of#import.
Issue all the warnings demanded by strict ANSI standard C; rejectall programs that use forbidden extensions.

Valid ANSI standard C programs should compile properly with or withoutthis option (though a rare few will require `-ansi'). However,without this option, certain GNU extensions and traditional C featuresare supported as well. With this option, they are rejected. There isno reason to use this option; it exists only to satisfy pedants.

`-pedantic' does not cause warning messages for use of thealternate keywords whose names begin and end with `__'. Pedanticwarnings are also disabled in the expression that follows__extension__. However, only system header files should usethese escape routes; application programs should avoid them.

Like `-pedantic', except that errors are produced rather thanwarnings.
Print extra warning messages for these events:
A nonvolatile automatic variable might be changed by a call tolongjmp. These warnings are possible only inoptimizing compilation.

The compiler sees only the calls to setjmp. It cannot knowwhere longjmp will be called; in fact, a signal handler couldcall it at any point in the code. As a result, you may get a warningeven when there is in fact no problem because longjmp cannotin fact be called at the place which would cause a problem.

A function can return either with or without a value. (Fallingoff the end of the function body is considered returning withouta value.) For example, this function would evoke such awarning:

foo (a){  if (a > 0)    return a;}
Spurious warnings can occur because GNU CC does not realize thatcertain functions (including abort and longjmp)will never return.
An expression-statement or the left-hand side of a comma expressioncontains no side effects. To suppress the warning, cast the unused expression to void.For example, an expression such as `x[i,j]' will cause a warning,but `x[(void)i,j]' will not.
An unsigned value is compared against zero with `>' or `<='.

Warn whenever a declaration does not specify a type.
Warn whenever a function is used before being declared.
Same as -Wimplicit-int and -Wimplicit-function-declaration.
Warn if themainfunction is declared or defined with a suspicious type.Typically, it is a function with external linkage, returningint, andtaking zero or two arguments.

Warn whenever a function is defined with a return-type that defaultsto int. Also warn about any return statement with noreturn-value in a function whose return-type is not void.
Warn whenever a local variable is unused aside from its declaration,whenever a function is declared static but never defined, and whenevera statement computes a result that is explicitly not used.
Warn whenever a switch statement has an index of enumeral typeand lacks a case for one or more of the named codes of thatenumeration. (The presence of a default label prevents thiswarning.) case labels outside the enumeration range alsoprovoke warnings when this option is used.
Warn whenever a comment-start sequence `/*' appears in a comment.
Warn if any trigraphs are encountered (assuming they are enabled).
Check calls to printf and scanf, etc., to make sure thatthe arguments supplied have types appropriate to the format stringspecified.
Warn if an array subscript has typechar.This is a common cause of error, as programmers often forget that thistype is signed on some machines.
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 onlywhen optimizing. If you don't specify `-O', you simply won'tget these warnings.

These warnings occur only for variables that are candidates forregister allocation. Therefore, they do not occur for a variable thatis declared volatile, or whose address is taken, or whose sizeis other than 1, 2, 4 or 8 bytes. Also, they do not occur forstructures, unions or arrays, even when they are in registers.

Note that there may be no warning about a variable that is used onlyto compute a value that itself is never used, because suchcomputations may be deleted by data flow analysis before the warningsare printed.

These warnings are made optional because GNU CC is not smartenough to see all the reasons why the code might be correctdespite appearing to have an error. Here is one example of howthis 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 isalways initialized, but GNU CC doesn't know this. Here isanother 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 asvolatile all the functions you use that never return.

Warn if parentheses are omitted in certain contexts.
When using templates in a C++ program, warn if debugging is not yetfully available (C++ only).
All of the above `-W' options combined. These are all theoptions which pertain to usage that we recommend avoiding and that webelieve 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 touse, on occasion, in clean programs.

Warn about certain constructs that behave differently in traditional andANSI C.
Macro arguments occurring within string constants in the macro body.These would substitute the argument in traditional C, but are part ofthe constant in ANSI C.
A function declared external in one block and then used after the end ofthe block.
A switch statement has an operand of type long.

Warn whenever a local variable shadows another local variable.
Warn whenever two distinct identifiers match in the first lencharacters. This may help you prepare a program that will compilewith certain obsolete, brain-damaged compilers.
Warn about anything that depends on the ``size of'' a function type orof void. GNU C assigns these types a size of 1, forconvenience in calculations with void * pointers and pointersto functions.
Warn whenever a pointer is cast so as to remove a type qualifier fromthe target type. For example, warn if a const char * is castto an ordinary char *.
Warn whenever a pointer is cast such that the required alignment of thetarget is increased. For example, warn if a char * is cast toan int * on machines where integers can only be accessed attwo- or four-byte boundaries.
Give string constants the type const char[length] so thatcopying the address of one into a non-const char *pointer will get a warning. These warnings will help you find atcompile time code that can try to write into a string constant, butonly if you have been very careful about using const indeclarations and prototypes. Otherwise, it will just be a nuisance;this is why we did not make `-Wall' request these warnings.
Warn if a prototype causes a type conversion that is different from whatwould happen to the same argument in the absence of a prototype. Thisincludes conversions of fixed point to floating and vice versa, andconversions changing the width or signedness of a fixed point argumentexcept when the same as the default promotion.
Warn if any functions that return structures or unions are defined orcalled. (In languages where you can return an array, this also elicitsa warning.)
Warn if a function is declared or defined without specifying theargument types. (An old-style function definition is permitted withouta warning if preceded by a declaration which specifies the argumenttypes.)
Warn if a global function is defined without a previous prototypedeclaration. This warning is issued even if the definition itselfprovides a prototype. The aim is to detect global functions that failto be declared in header files.
Warn if a global function is defined without a previous declaration.Do so even if the definition itself provides a prototype.Use this option to detect global functions that are not declared inheader files.
Warn if anything is declared more than once in the same scope, even incases where multiple declaration is valid and changes nothing.
Warn if an extern declaration is encountered within an function.
Warn about conversion between different enumeration types (C++ only).
Warn iflong long type is used. This is default. To inhibitthe warning messages, use flag `-Wno-long-long'. Flags `-W-long-long' and `-Wno-long-long' are taken into account only when flag `-pedantic' is used.
(C++ only.)In a derived class, the definitions of virtual functions must matchthe type signature of a virtual function declared in the base class.Use this option to request warnings when a derived class declares afunction that may be an erroneous attempt to define a virtualfunction: that is, warn when a function with the same name as avirtual function in the base class, but with a type signature thatdoesn't match any virtual functions from the base class.
Warn if a function can not be inlined, and either it was declared as inline,or else the-finline-functionsoption was given.
Treat warnings as errors; abort compilation after any warning.


GNU CC has various special options that are used for debuggingeither your program or GCC:
Produce debugging information in the operating system's native format(stabs, COFF, XCOFF, or DWARF). GDB can work with this debugginginformation.

On most systems that use stabs format, `-g' enables use of extradebugging information that only GDB can use; this extra informationmakes debugging work better in GDB but will probably make other debuggerscrash orrefuse to read the program. If you want to control for certain whetherto generate the extra information, use `-gstabs+', `-gstabs',`-gxcoff+', `-gxcoff', `-gdwarf+', or `-gdwarf'(see below).

Unlike most other C compilers, GNU CC allows you to use `-g' with`-O'. The shortcuts taken by optimized code may occasionallyproduce surprising results: some variables you declared may not existat all; flow of control may briefly move where you did not expect it;some statements may not be executed because they compute constantresults or their values were already at hand; some statements mayexecute in different places because they were moved out of loops.

Nevertheless it proves possible to debug optimized output. This makesit reasonable to use the optimizer for programs that might have bugs.

The following options are useful when GNU CC is generated with thecapability for more than one debugging format.

Produce debugging information in the native format (if that is supported),including GDB extensions if at all possible.
Produce debugging information in stabs format (if that is supported),without GDB extensions. This is the format used by DBX on most BSDsystems.
Produce debugging information in stabs format (if that is supported),using GNU extensions understood only by the GNU debugger (GDB). Theuse of these extensions is likely to make other debuggers crash orrefuse to read the program.
Produce debugging information in COFF format (if that is supported).This is the format used by SDB on most System V systems prior toSystem V Release 4.
Produce debugging information in XCOFF format (if that is supported).This is the format used by the DBX debugger on IBM RS/6000 systems.
Produce debugging information in XCOFF format (if that is supported),using GNU extensions understood only by the GNU debugger (GDB). Theuse of these extensions is likely to make other debuggers crash orrefuse to read the program.
Produce debugging information in DWARF format (if that is supported).This is the format used by SDB on most System V Release 4 systems.
Produce debugging information in DWARF format (if that is supported),using GNU extensions understood only by the GNU debugger (GDB). Theuse of these extensions is likely to make other debuggers crash orrefuse to read the program.


Request debugging information and also use level to specify howmuch information. The default level is 2.

Level 1 produces minimal information, enough for making backtraces inparts of the program that you don't plan to debug. This includesdescriptions of functions and external variables, but no informationabout local variables and no line numbers.

Level 3 includes extra information, such as all the macro definitionspresent in the program. Some debuggers support macro expansion whenyou use `-g3'.

Generate extra code to write profile information suitable for theanalysis program prof.
Generate extra code to write profile information suitable for theanalysis 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.
Generate extra code to read basic block profiling parameters from file `' and write profiling results to file `bb.out'.`' contains a list of functions. Whenever a function on the listis entered, profiling is turned on. When the outmost function is left,profiling is turned off. If a function name is prefixed with `-'the function is excluded from profiling. If a function name is notunique it can be disambiguated by writing`/path/filename.d:functionname'. `bb.out' will list some availablefilenames.Four function names have a special meaning:`__bb_jumps__' will cause jump frequencies to be written to `bb.out'.`__bb_trace__' will cause the sequence of basic blocks to be piped into `gzip' and written to file `bbtrace.gz'.`__bb_hidecall__' will cause call instructions to be excluded fromthe trace.`__bb_showret__' will cause return instructions to be included inthe trace.
Says to make debugging dumps during compilation at times specified byletters. This is used for debugging the compiler. The file namesfor most of the dumps are made by appending a word to the source filename (e.g. `foo.c.rtl' or `foo.c.jump').
Dump all macro definitions, at the end of preprocessing, and write nooutput.
Dump all macro names, at the end of preprocessing.
Dump all macro definitions, at the end of preprocessing, in addition tonormal output.
Dump debugging information during parsing, to standard error.
Dump after RTL generation, to `file.rtl'.
Just generate RTL for a function instead of compiling it. Usually usedwith `r'.
Dump after first jump optimization, to `file.jump'.
Dump after CSE (including the jump optimization that sometimesfollows CSE), to `file.cse'.
Dump after loop optimization, to `file.loop'.
Dump after the second CSE pass (including the jump optimization thatsometimes follows CSE), to `file.cse2'.
Dump after flow analysis, to `file.flow'.
Dump after instruction combination, to `file.combine'.
Dump after the first instruction scheduling pass, to`file.sched'.
Dump after local register allocation, to `file.lreg'.
Dump after global register allocation, to `file.greg'.
Dump after the second instruction scheduling pass, to`file.sched2'.
Dump after last jump optimization, to `file.jump2'.
Dump after delayed branch scheduling, to `file.dbr'.
Dump after conversion from registers to stack, to `file.stack'.
Produce all the dumps listed above.
Print statistics on memory usage, at the end of the run, tostandard error.
Annotate the assembler output with a comment indicating whichpattern and alternative was used.
When running a cross-compiler, pretend that the target machine uses thesame floating point format as the host machine. This causes incorrectoutput of the actual floating constants, but the actual instructionsequence will probably be the same as GNU CC would make when running onthe target machine.
Store the usual ``temporary'' intermediate files permanently; place themin the current directory and name them based on the source file. Thus,compiling `foo.c' with `-c -save-temps' would produce files`foo.cpp' and `foo.s', as well as `foo.o'.
Print the full absolute name of the library file library thatwould be used when linking---and do not do anything else. With thisoption, GNU CC does not compile or link anything; it just prints thefile name.
Same as `-print-file-name=libgcc.a'.
Like `-print-file-name', but searches for a program such as `cpp'.


These options control various sorts of optimizations:
Optimize. Optimizing compilation takes somewhat more time, and a lotmore memory for a large function.

Without `-O', the compiler's goal is to reduce the cost ofcompilation and to make debugging produce the expected results.Statements are independent: if you stop the program with a breakpointbetween statements, you can then assign a new value to any variable orchange the program counter to any other statement in the function andget exactly the results you would expect from the source code.

Without `-O', only variables declared register areallocated in registers. The resulting compiled code is a little worsethan produced by PCC without `-O'.

With `-O', the compiler tries to reduce code size and executiontime.

When you specify `-O', the two options `-fthread-jumps' and `-fdefer-pop' are turned on. On machines that have delay slots, the `-fdelayed-branch' option is turned on. For those machines that can support debugging evenwithout a frame pointer, the `-fomit-frame-pointer' option is turned on. On some machines other flags may also be turned on.

Optimize even more. Nearly all supported optimizations that do notinvolve a space-speed tradeoff are performed. Loop unrolling and functioninlining are not done, for example. As compared to-O,this option increases both compilation time and the performance of thegenerated code.
Optimize yet more. This turns on everything-O2does, along with also turning on-finline-functions.
Do not optimize.

If you use multiple-Ooptions, with or without level numbers, the last such option is theone that is effective.

Options of the form `-fflag' specify machine-independentflags. Most flags have both positive and negative forms; the negativeform of `-ffoo' would be `-fno-foo'. The following list showsonly one form---the one which is not the default.You can figure out the other form by either removing `no-' oradding it.

Do not store floating point variables in registers. Thisprevents undesirable excess precision on machines such as the68000 where the floating registers (of the 68881) keep moreprecision than a double is supposed to have.

For most programs, the excess precision does only good, but a fewprograms rely on the precise definition of IEEE floating point.Use `-ffloat-store' for such programs.

Use heuristics to compile faster (C++ only). These heuristics are notenabled by default, since they are only effective for certain inputfiles. Other input files compile more slowly.

The first time the compiler must build a call to a member function (orreference to a data member), it must (1) determine whether the classimplements member functions of that name; (2) resolve which memberfunction to call (which involves figuring out what sorts of typeconversions need to be made); and (3) check the visibility of the memberfunction to the caller. All of this adds up to slower compilation.Normally, the second time a call is made to that member function (orreference to that data member), it must go through the same lengthyprocess again. This means that code like this

cout << "This " << p << " has " << n << " legs.\n";

makes six passes through all three steps. By using a software cache,a ``hit'' significantly reduces this cost. Unfortunately, using thecache introduces another layer of mechanisms which must be implemented,and so incurs its own overhead. `-fmemoize-lookups' enablesthe software cache.

Because access privileges (visibility) to members and member functionsmay differ from one function context to the next,g++may need to flush the cache. With the `-fmemoize-lookups' flag, the cache is flushed after everyfunction that is compiled. The `-fsave-memoized' flag enables the same software cache, but when the compilerdetermines that the context of the last function compiled would yieldthe same access privileges of the next function to compile, itpreserves the cache.This is most helpful when defining many member functions for the sameclass: with the exception of member functions which are friends ofother classes, each member function has exactly the same accessprivileges as every other, and the cache need not be flushed.

Don't make member functions inline by default merely because they aredefined inside the class scope (C++ only).
Always pop the arguments to each function call as soon as thatfunction returns. For machines which must pop arguments after afunction call, the compiler normally lets arguments accumulate on thestack for several function calls and pops them all at once.
Force memory operands to be copied into registers before doingarithmetic on them. This may produce better code by making allmemory references potential common subexpressions. When they arenot common subexpressions, instruction combination shouldeliminate the separate register-load. I am interested in hearingabout the difference this makes.
Force memory address constants to be copied into registers beforedoing arithmetic on them. This may produce better code just as`-fforce-mem' may. I am interested in hearing about thedifference this makes.
Don't keep the frame pointer in a register for functions thatdon't need one. This avoids the instructions to save, set up andrestore frame pointers; it also makes an extra register availablein many functions. It also makes debugging impossible on most machines.

On some machines, such as the Vax, this flag has no effect, becausethe standard calling sequence automatically handles the frame pointerand nothing is saved by pretending it doesn't exist. Themachine-description macro FRAME_POINTER_REQUIRED controlswhether a target machine supports this flag.

Integrate all simple functions into their callers. The compilerheuristically decides which functions are simple enough to be worthintegrating in this way.

If all calls to a given function are integrated, and the function isdeclared static, then GCC normally does not output the function asassembler code in its own right.

Enable values to be allocated in registers that will be clobbered byfunction calls, by emitting extra instructions to save and restore theregisters around such calls. Such allocation is done only when itseems to result in better code than would otherwise be produced.

This option is enabled by default on certain machines, usually thosewhich have no call-preserved registers to use instead.

Even if all calls to a given function are integrated, and the functionis declared static, nevertheless output a separate run-timecallable version of the function.
Do not put function addresses in registers; make each instruction thatcalls a constant function contain the function's address explicitly.

This option results in less efficient code, but some strange hacksthat alter the assembler output may be confused by the optimizationsperformed when this option is not used.

Disable any machine-specific peephole optimizations.
This option allows GCC to violate some ANSI or IEEE rules/specificationsin the interest of optimizing code for speed. For example, it allowsthe compiler to assume arguments to the sqrt function arenon-negative numbers.

This option should never be turned on by any `-O' option sinceit can result in incorrect output for programs which depend onan exact implementation of IEEE or ANSI rules/specifications formath 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 onthe `-fthread-jumps' and `-fdelayed-branch' options, butspecific 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.

Perform the optimizations of loop strength reduction andelimination of iteration variables.
Perform optimizations where we check to see if a jump branches to alocation where another comparison subsumed by the first is found. Ifso, the first branch is redirected to either the destination of thesecond branch or a point immediately following it, depending on whetherthe condition is known to be true or false.
Perform the optimization of loop unrolling. This is only done for loopswhose number of iterations can be determined at compile time or run time.
Perform the optimization of loop unrolling. This is done for all loops.This usually makes programs run more slowly.
In common subexpression elimination, scan through jump instructionswhen the target of the jump is not reached by any other path. Forexample, when CSE encounters an if statement with anelse clause, CSE will follow the jump when the conditiontested is false.
This is similar to `-fcse-follow-jumps', but causes CSE tofollow jumps which conditionally skip over blocks. When CSEencounters a simple if statement with no else clause,`-fcse-skip-blocks' causes CSE to follow the jump around thebody of the if.
Re-run common subexpression elimination after loop optimizations has beenperformed.
Elide constructors when this seems plausible (C++ only). With thisflag, GNU C++ initializes y directly from the call to foowithout going through a temporary in the following code:

A foo ();A y = foo ();

Without this option, GNU C++ first initializes y by calling theappropriate constructor for type A; then assigns the result offoo to