GCC(1) GNU Tools GCC(1) NAME gcc - GNU project C Compiler (gcc-2.96) SYNOPSIS gcc [ option | filename ]... DESCRIPTION The C compiler is integrated: it processes input files through one or more of four stages: prepro­ cessing, compilation, assembly, and linking. Source file­ name suffixes identify the source language, but which name you use for the compiler governs default assumptions: gcc assumes preprocessed (.i) files are C and assumes C style linking. Suffixes of source file names indicate the language and kind of processing to be done: .c C source; preprocess, compile, assemble .m Objective-C source; preprocess, compile, assemble .i 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. Com­ mon cases include: .o Object file .a Archive file Linking is always the last stage unless you use one of the -c, -S, or -E options to avoid it (or unless compilation errors stop the whole process). For the link stage, all .o files corresponding to source files, -l libraries, unrecognized filenames (including named .o object files and .a archives) are passed to the linker in command-line order. OPTIONS Options must be separate: `-dr' is quite different from `-d -r '. Most `-f' and `-W' options have two contrary forms: -fname and -fno-name (or -Wname and -Wno-name). Only the non- default forms are shown here. Overall Options -c -S -E -o file -pipe -v -x language Language Options -ansi -fcond-mismatch -fdollars-in-identifiers -fexternal-templates -fno-asm -fno-builtin -fhosted -fno-hosted -ffreestanding -fno-freestanding -fno-strict-prototype -fsigned-bitfields -fsigned-char -funsigned-bitfields -funsigned-char -fwritable-strings -traditional -traditional-cpp -trigraphs Warning Options -fsyntax-only -pedantic -pedantic-errors -w -W -Wall -Waggregate-return -Wcast-align -Wcast-qual -Wchar-subscript -Wcomment -Wconversion -Werror -Wformat -Wid-clash-len -Wimplicit -Wimplicit-int -Wimplicit-function-declaration -Winline -Wlong-long -Wmain -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Wno-import -Wparentheses -Wpointer-arith -Wredundant-decls -Wreturn-type -Wshadow -Wstrict-prototypes -Wswitch -Wtraditional -Wtrigraphs -Wuninitialized -Wunused -Wunused-function -Wunused-label -Wunused-parameter -Wunused-variable -Wunused-value -Wwrite-strings Debugging Options -a -dletters -fpretend-float -g -glevel -gcoff -gxcoff -gxcoff+ -gdwarf -gdwarf+ -gstabs -gstabs+ -ggdb -p -pg -save-temps -print-file-name=library -print-libgcc-file-name -print-prog-name=program Optimization Options -fcaller-saves -fcse-follow-jumps -fcse-skip-blocks -fdelayed-branch -felide-constructors -fexpensive-optimizations -ffast-math -ffloat-store -fforce-addr -fforce-mem -finline-functions -fkeep-inline-functions -fmemoize-lookups -fno-default-inline -fno-defer-pop -fno-function-cse -fno-inline -fno-peephole -fomit-frame-pointer -frerun-cse-after-loop -fschedule-insns -fschedule-insns2 -fstrength-reduce -fthread-jumps -funroll-all-loops -funroll-loops -O -O2 -O3 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 -Wa,option Linker Options -llibrary -nostartfiles -nostdlib -static -shared -symbolic -Xlinker option -Wl,option -u symbol Directory Options -Bprefix -Idir -I- -Ldir 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 i386 Options -m486 -mno-486 -msoft-float -mno-fp-ret-in-387 HPPA Options i960 Options DEC Alpha Options System V Options Code Generation Options -fcall-saved-reg -fcall-used-reg -ffixed-reg -finhibit-size-directive -fnonnull-objects -fno-common -fno-ident -fno-gnu-linker -fpcc-struct-return -fpic -fPIC -freg-struct-return -fshared-data -fshort-enums -fshort-double -fvolatile -fvolatile-global -fverbose-asm OVERALL OPTIONS -x language Specify explicitly the language for the following input files (rather than choosing a default based on the file name suffix) . This option applies to all following input files until the next `-x' op­ tion. 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 are handled 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, com­ pile, assemble, link), you can use `-x' (or filename suf­ fixes) to tell gcc where to start, and one of the options `-c', `-S', or `-E' to say where gcc is to stop. Note that some combinations (for example, `-x cpp-output -E') instruct gcc to do nothing at all. -c Compile or assemble the source files, but do not link. The compiler output is an object file corre­ sponding to each source file. By default, GCC makes the object file name for a source file by replacing the suffix `.c', `.i', `.s', etc., with `.o'. Use -o to select another name. GCC ignores any unrecognized input files (those that do not require compilation or assembly) with the -c option. -S Stop after the stage of compilation proper; do not assemble. The output is an assembler code file for each non-assembler input file specified. By default, GCC makes the assembler file name for a source file by replacing the suffix `.c', `.i', etc., with `.s'. Use -o to select another name. GCC ignores any input files that don't require com­ pilation. -E Stop after the preprocessing stage; do not run the compiler proper. The output is preprocessed source code, which is sent to the standard output. GCC ignores input files which don't require prepro­ cessing. -o file Place output in file file. This applies regardless to whatever sort 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 to use `-o' when compiling more than one input file, unless you are producing an executable file as output. If you do not specify `-o', the default is to put an executable file in `a.out', the object file for `source.suffix' in `source.o', its assembler file in `source.s', and all preprocessed C source on standard output. -v Print (on standard error output) the commands exe­ cuted to run the stages of compilation. Also print the version number of the compiler driver program and of the preprocessor and the compiler proper. -pipe Use pipes rather than temporary files for communi­ cation between the various stages of compilation. This fails to work on some systems where the assem­ bler cannot read from a pipe; but the GNU assembler has no trouble. LANGUAGE OPTIONS The following options control the dialect of C that the compiler accepts: -ansi Support all ANSI standard C programs. This turns off certain features of GNU C that are incompatible with ANSI C, such as the asm, inline and typeof keywords, and predefined macros such as unix and vax that identify the type of system you are using. It also enables the undesirable 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, of course, but it is useful to put them in header files that might be included in compila­ tions done with `-ansi'. Alternate predefined macros such as __unix__ and __vax__ are also avail­ able, with or without `-ansi'. The `-ansi' option does not cause non-ANSI programs to be rejected gratuitously. For that, `-pedantic' is required in addition to `-ansi'. The preprocessor predefines a macro __STRICT_ANSI__ when you use the `-ansi' option. Some header files may notice this macro and refrain from declaring certain functions or defining certain macros that the ANSI standard doesn't call for; this is to avoid interfering with any programs that might use these names for other things. -fno-asm Do not recognize asm, inline or typeof as a key­ word. These words may then be used as identifiers. You can use __asm__, __inline__ and __typeof__ in­ stead. `-ansi' implies `-fno-asm'. PREPROCESSOR OPTIONS These options control the C preprocessor, which is run on each C source file before actual compilation. If you use the `-E' option, GCC does nothing except pre­ processing. Some of these options make sense only togeth­ er 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 writ­ ten. -E Run only the C preprocessor. Preprocess all the C source files specified and output the results to standard output or to the specified output file. -C Tell the preprocessor not to discard comments. Used with the `-E' option. -P Tell the preprocessor not to generate `#line' com­ mands. Used with the `-E' option. ASSEMBLER OPTION -Wa,option Pass option as an option to the assembler. If op­ tion contains commas, it is split into multiple op­ tions at the commas. LINKER OPTIONS These options come into play when the compiler links ob­ ject files into an executable output file. They are mean­ ingless if the compiler is not doing a link step. object-file-name A file name that does not end in a special recog­ nized suffix is considered to name an object file or library. (Object files are distinguished from libraries by the linker according to the file con­ tents.) If GCC does a link step, these object files are used as input to the linker. -llibrary 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 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 scan­ ning through it for members which define symbols that have so far been referenced but not defined. However, if the linker finds an ordinary object file rather than a library, the object file is linked in the usual fashion. The only difference between using an `-l' option and specifying a file name is that `-l' surrounds library with `lib' and `.a' and searches several directories. -lobjc You need this special case of the -l option in or­ der to link an Objective C program. -nostartfiles Do not use the standard system startup files when linking. The standard libraries are used normally. -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 pre­ vents 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 refer­ ences (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 argu­ ment, you must use `-Xlinker' twice, once for the option and once for the argument. For example, to pass `-assert definitions', you must write `-Xlink­ er -assert -Xlinker definitions'. It does not work to write `-Xlinker "-assert definitions"', because this passes the entire string as a single argument, which is not what the linker expects. -Wl,option Pass option as an option to the linker. If option contains commas, it is split into multiple options at the commas. -u symbol Pretend the symbol symbol is undefined, to force linking of library modules to define it. You can use `-u' multiple times with different symbols to force loading of additional library modules. DIRECTORY OPTIONS 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 be­ fore the `-I-' option are searched only for the case of `#include "file"'; they are not searched for `#include '. If additional directories are specified with `-I' options after the `-I-', these directories are searched for all `#include' directives. (Ordinari­ ly 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 `#in­ clude "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 sys­ tem 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 executa­ bles, libraries and data files of the compiler it­ self. The compiler driver program runs one or more of the subprograms `cpp', `cc1' (or, for C++, `cc1plus'), `as' and `ld'. It tries prefix as a prefix for each program it tries to run, both with and without `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 of those results in a file name that is found, the compiler driver searches for the unmodi­ fied program name, 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 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. Most of the time, on most machines, `libgcc.a' is not actually necessary. You can get a similar result from the environment variable GCC_EXEC_PREFIX; if it is defined, its value is used as a prefix in the same way. If both the `-B' option and the GCC_EXEC_PREFIX variable are present, the `-B' option is used first and the environment variable value second. WARNING OPTIONS DEBUGGING OPTIONS OPTIMIZATION OPTIONS These options control various sorts of optimizations: -O -O1 Optimize. Optimizing compilation takes somewhat more time, and a lot more memory for a large func­ tion. 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 re­ sults 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 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 even without a frame pointer, the `-fomit-frame-pointer' option is turned on. On some machines other flags may also be turned on. -O2 Optimize even more. Nearly all supported optimiza­ tions that do not involve a space-speed tradeoff are performed. Loop unrolling and function inlin­ ing are not done, for example. As compared to -O, this option increases both compilation time and the performance of the generated code. -O3 Optimize yet more. This turns on everything -O2 does, along with also turning on -finline-func­ tions. -O0 Do not optimize. If you use multiple -O options, with or without level numbers, the last such option is the one that is effective. 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'. The following list shows only one form--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 ma­ chines such as the 68000 where the floating regis­ ters (of the 68881) keep more precision than a dou­ ble is supposed to have. For most programs, the excess precision does only good, but a few programs rely on the precise defi­ nition of IEEE floating point. Use `-ffloat-store' for such programs. -fmemoize-lookups -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 com­ piler 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 poten­ tial common subexpressions. When they are not com­ mon subexpressions, instruction combination should eliminate the separate register-load. -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 in­ structions to save, set up and restore frame point­ ers; it also makes an extra register available in many functions. It also makes debugging impossible on most machines. On some machines, such as the Vax, this flag has no effect, because the standard calling sequence auto­ matically 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. -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 GCC nor­ mally does not output the function as assembler code in its own right. -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 regis­ ters 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 ma­ chines, usually those which have no call-preserved registers to use instead. -fkeep-inline-functions Even if all calls to a given function are integrat­ ed, and the function is declared static, neverthe­ less 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. -fno-peephole Disable any machine-specific peephole optimiza­ tions. -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 compil­ er 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 func­ tions. 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 reduc­ tion and elimination of iteration variables. -fthread-jumps Perform optimizations where we check to see if a jump branches to a location where another compari­ son subsumed by the first is found. If so, the first branch is redirected to either the destina­ tion of the second branch or a point immediately following it, depending on whether the condition is known to be true or false. -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-all-loops Perform the optimization of loop unrolling. This is done for all loops. This usually makes programs run more slowly. -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 re­ order instructions to exploit instruction slots available after delayed branch instructions. -fschedule-insns If supported for the target machine, attempt to re­ order 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 ad­ ditional pass of instruction scheduling after reg­ ister 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. TARGET OPTIONS By default, GNU CC compiles code for the same type of ma­ chine that you are using. However, it can also be in­ stalled as a cross-compiler, to compile for some other type of machine. In fact, several different configura­ tions of GNU CC, for different target machines, can be in­ stalled 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 in­ stalled side by side. One of them (probably the newest) will be the default, but you may sometimes wish to use an­ other. MACHINE DEPENDENT OPTIONS Each of the target machine types can have its own special options, starting with `-m', to choose among various hard­ ware 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 con­ figuration, according to the options specified. Some configurations of the compiler also support addition­ al special options, usually for command-line compatibility with other compilers on the same platform. These are the `-m' options defined for the 68000 series: These `-m' options are defined for the Vax: These `-m' switches are supported on the SPARC: These `-m' options are defined for the Convex: These `-m' options are defined for the AMD Am29000: These `-m' options are defined for Motorola 88K architec­ tures: These options are defined for the IBM RS6000: These `-m' options are defined for the IBM RT PC: These `-m' options are defined for the MIPS family of com­ puters: These `-m' options are defined for the Intel 80386 family of computers: -m486 -mno-486 Control whether or not code is optimized for a 486 instead of an 386. Code generated for a 486 will run on a 386 and vice versa. -msoft-float Generate output containing library calls for float­ ing 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 li­ brary functions for cross-compilation. On machines where a function returns floating point results in the 80387 register stack, some floating point opcodes may be emitted even if `-msoft-float' is used. -mno-fp-ret-in-387 Do not use the FPU registers for return values of functions. The usual calling convention has functions return values of types float and double in an FPU regis­ ter, even if there is no FPU. The idea is that the operating system should emulate an FPU. The option `-mno-fp-ret-in-387' causes such values to be returned in ordinary CPU registers instead. These `-m' options are defined for the HPPA family of com­ puters: These `-m' options are defined for the Intel 80960 family of computers: These `-m' options are defined for the DEC Alpha implemen­ tations: These additional options are available on System V Release 4 for compatibility with other compilers on those systems: CODE GENERATION OPTIONS These machine-independent options control the interface conventions used in code generation. Most of them begin with `-f'. These options 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. -fpcc-struct-return Use the same convention for returning struct and union values that is used by the usual C compiler on your system. This convention is less efficient for small structures, and on many machines it fails to be reentrant; but it has the advantage of allow­ ing intercallability between GCC-compiled code and PCC-compiled code. -freg-struct-return Use the convention that struct and union values are returned in registers when possible. This is more efficient for small structures than -fpcc-struct-return. If you specify neither -fpcc-struct-return nor -freg-struct-return, GNU CC defaults to whichever convention is standard for the target. If there is no standard convention, GNU CC defaults to -fpcc-struct-return. -fshort-enums Allocate to an enum type only as many bytes as it needs for the declared range of possible values. Specifically, the enum type will be equivalent to the smallest integer type which has enough room. -fshort-double Use the same size for double as for float . -fshared-data Requests that the data and non-const variables of this compilation be shared data rather than private data. The distinction makes sense only on certain operating systems, where shared data is shared be­ tween processes running the same program, while private data exists in one copy per process. -fno-common Allocate even uninitialized global variables in the bss section of the object file, rather than gener­ ating them as common blocks. This has the effect that if the same variable is declared (without ex­ tern) in two different compilations, you will get an error when you link them. The only reason this might be useful is if you wish to verify that the program will work on other systems which always work this way. -fno-ident Ignore the `#ident' directive. -fno-gnu-linker Do not output global initializations (such as C++ constructors and destructors) in the form used by the GNU linker (on systems where the GNU linker is the standard method of handling them). Use this option when you want to use a non-GNU linker, which also requires using the collect2 program to make sure the system linker includes constructors and destructors. (collect2 is included in the GNU CC distribution.) For systems which must use col­ lect2, the compiler driver gcc is configured to do this automatically. -finhibit-size-directive Don't output a .size assembler directive, or any­ thing else that would cause trouble if the function is split in the middle, and the two halves are placed at locations far apart in memory. This op­ tion is used when compiling `crtstuff.c'; you should not need to use it for anything else. -fverbose-asm Put extra commentary information in the generated assembly code to make it more readable. This op­ tion is generally only of use to those who actually need to read the generated assembly code (perhaps while debugging the compiler itself). -fvolatile Consider all memory references through pointers to be volatile. -fvolatile-global Consider all memory references to extern and global data items to be volatile. -fpic If supported for the target machines, generate po­ sition-independent code, suitable for use in a shared library. -fPIC If supported for the target machine, emit position- independent code, suitable for dynamic linking, even if branches need large displacements. -ffixed-reg Treat the register named reg as a fixed register; generated code should never refer to it (except perhaps as a stack pointer, frame pointer or in some other fixed role). reg must be the name of a register. The register names accepted are machine-specific and are defined in the REGISTER_NAMES macro in the machine descrip­ tion macro file. This flag does not have a negative form, because it specifies a three-way choice. -fcall-used-reg Treat the register named reg as an allocable regis­ ter that is clobbered by function calls. It may be allocated for temporaries or variables that do not live across a call. Functions compiled this way will not save and restore the register reg. Use of this flag for a register that has a fixed pervasive role in the machine's execution model, such as the stack pointer or frame pointer, will produce disastrous results. This flag does not have a negative form, because it specifies a three-way choice. -fcall-saved-reg Treat the register named reg as an allocable regis­ ter saved by functions. It may be allocated even for temporaries or variables that live across a call. Functions compiled this way will save and restore the register reg if they use it. Use of this flag for a register that has a fixed pervasive role in the machine's execution model, such as the stack pointer or frame pointer, will produce disastrous results. A different sort of disaster will result from the use of this flag for a register in which function values may be returned. This flag does not have a negative form, because it specifies a three-way choice. FILES file.c C source file file.h C header (preprocessor) file file.i preprocessed C source file file.C C++ source file file.cc C++ source file file.cxx C++ source file file.m Objective-C source file file.s assembly language file file.o object file a.out link edited output TMPDIR/cc* temporary files LIBDIR/cpp preprocessor LIBDIR/cc1 compiler for C LIBDIR/cc1plus compiler for C++ LIBDIR/collect linker front end needed on some machines LIBDIR/libgcc.a GCC subroutine library /lib/crt[01n].o start-up routine LIBDIR/ccrt0 additional start-up routine for C++ /lib/libc.a standard C library, see intro(3) /usr/include standard directory for #include files LIBDIR/include standard gcc directory for #include files LIBDIR/g++-include additional g++ directory for #include LIBDIR is usually /usr/local/lib/machine/version. TMPDIR comes from the environment variable TMPDIR (default /usr/tmp if available, else /tmp). EXIT STATUS Normally the exit status is 0, if compilation or link edit are successful, and nonzero else. The option -Werror treats each warning as an error. SEE ALSO cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1). `gcc', `cpp', `as', `ld', and `gdb' entries in info. Using and Porting GNU CC (for version 2.0), Richard M. Stallman; The C Preprocessor, Richard M. Stallman; Debug­ ging with GDB: the GNU Source-Level Debugger, Richard M. Stallman and Roland H. Pesch; Using as: the GNU Assembler, Dean Elsner, Jay Fenlason & friends; ld: the GNU linker, Steve Chamberlain and Roland Pesch. BUGS For instructions on reporting bugs, see the GCC manual. COPYING Copyright 1991, 1992, 1993 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 ver­ sions of this manual under the conditions for verbatim copying, 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 con­ ditions for modified versions, except that this permission notice may be included in translations approved by the Free Software Foundation instead of in the original En­ glish. AUTHORS See the GNU CC Manual for the contributors to GNU CC.