| .\" Copyright (c) 1991, 1992, 1993, 1994 Free Software Foundation -*-Text-*- |
| .\" See section COPYING for conditions for redistribution |
| .\" |
| .\" Set up \*(lq, \*(rq if -man hasn't already set it up. |
| .if @@\*(lq@ \{\ |
| . ds lq " |
| . if t .ds lq `` |
| . if !@@\(lq@ .ds lq "\(lq |
| .\} |
| .if @@\*(rq@ \{\ |
| . ds rq " |
| . if t .ds rq '' |
| . if !@@\(rq@ .ds rq "\(rq |
| .\} |
| .de Id |
| .ds Rv \\$3 |
| .ds Dt \\$4 |
| .. |
| .de Sp |
| .if n .sp |
| .if t .sp 0.4 |
| .. |
| .Id $Id: gcc.1,v 1.1.1.1.2.1 1997/12/03 08:07:52 law Exp $ |
| .TH GCC 1 "\*(Dt" "GNU Tools" "GNU Tools" |
| .SH NAME |
| gcc, g++ \- GNU project C and C++ Compiler (egcs-1.0.3) |
| .SH SYNOPSIS |
| .B gcc |
| .RI "[ " option " | " filename " ].\|.\|." |
| .br |
| .B g++ |
| .RI "[ " option " | " filename " ].\|.\|." |
| .SH WARNING |
| The information in this man page is an extract from the full |
| documentation of the GNU C compiler, and is limited to the meaning of |
| the options. |
| .PP |
| This man page is not kept up to date except when volunteers want to |
| maintain it. If you find a discrepancy between the man page and the |
| software, please check the Info file, which is the authoritative |
| documentation. |
| .PP |
| If we find that the things in this man page that are out of date cause |
| significant confusion or complaints, we will stop distributing the man |
| page. The alternative, updating the man page when we update the Info |
| file, is impossible because the rest of the work of maintaining GNU CC |
| leaves us no time for that. The GNU project regards man pages as |
| obsolete and should not let them take time away from other things. |
| .PP |
| For complete and current documentation, refer to the Info file `\|\c |
| .B gcc\c |
| \&\|' or the manual |
| .I |
| Using and Porting GNU CC (for version 2.0)\c |
| \&. Both are made from the Texinfo source file |
| .BR gcc.texinfo . |
| .SH DESCRIPTION |
| The C and C++ compilers are integrated. Both process input files |
| through one or more of four stages: preprocessing, compilation, |
| assembly, and linking. Source filename suffixes identify the source |
| language, but which name you use for the compiler governs default |
| assumptions: |
| .TP |
| .B gcc |
| assumes preprocessed (\c |
| .B .i\c |
| \&) files are C and assumes C style linking. |
| .TP |
| .B g++ |
| assumes preprocessed (\c |
| .B .i\c |
| \&) files are C++ and assumes C++ style linking. |
| .PP |
| Suffixes of source file names indicate the language and kind of |
| processing to be done: |
| .Sp |
| .nf |
| .ta \w'\fB.cxx\fP 'u |
| \&\fB.c\fP C source; preprocess, compile, assemble |
| \&\fB.C\fP C++ source; preprocess, compile, assemble |
| \&\fB.cc\fP C++ source; preprocess, compile, assemble |
| \&\fB.cxx\fP C++ source; preprocess, compile, assemble |
| \&\fB.m\fP Objective-C source; preprocess, compile, assemble |
| \&\fB.i\fP preprocessed C; compile, assemble |
| \&\fB.ii\fP preprocessed C++; compile, assemble |
| \&\fB.s\fP Assembler source; assemble |
| \&\fB.S\fP Assembler source; preprocess, assemble |
| \&\fB.h\fP Preprocessor file; not usually named on command line |
| .Sp |
| .fi |
| Files with other suffixes are passed to the linker. Common cases include: |
| .Sp |
| .nf |
| \&\fB.o\fP Object file |
| \&\fB.a\fP Archive file |
| .br |
| .fi |
| .Sp |
| Linking is always the last stage unless you use one of the |
| .BR \-c , |
| .BR \-S , |
| or |
| .B \-E |
| options to avoid it (or unless compilation errors stop the whole |
| process). For the link stage, all |
| .B .o |
| files corresponding to source files, |
| .B \-l |
| libraries, unrecognized filenames (including named |
| .B .o |
| object files and |
| .B .a |
| archives) |
| are passed to the linker in command-line order. |
| .SH OPTIONS |
| Options must be separate: `\|\c |
| .B \-dr\c |
| \&\|' is quite different from `\|\c |
| .B \-d \-r |
| \&\|'. |
| .PP |
| Most `\|\c |
| .B \-f\c |
| \&\|' and `\|\c |
| .B \-W\c |
| \&\|' options have two contrary forms: |
| .BI \-f name |
| and |
| .BI \-fno\- name\c |
| \& (or |
| .BI \-W name |
| and |
| .BI \-Wno\- name\c |
| \&). Only the non-default forms are shown here. |
| .PP |
| Here is a summary of all the options, grouped by type. Explanations are |
| in the following sections. |
| .hy 0 |
| .na |
| .TP |
| .B Overall Options |
| .br |
| \-c |
| \-S |
| \-E |
| .RI "\-o " file |
| \-pipe |
| \-v |
| .RI "\-x " language |
| .TP |
| .B Language Options |
| \-ansi |
| \-fall\-virtual |
| \-fcond\-mismatch |
| \-fdollars\-in\-identifiers |
| \-fenum\-int\-equiv |
| \-fexternal\-templates |
| \-fno\-asm |
| \-fno\-builtin |
| \-fhosted |
| \-fno\-hosted |
| \-ffreestanding |
| \-fno\-freestanding |
| \-fno\-strict\-prototype |
| \-fsigned\-bitfields |
| \-fsigned\-char |
| \-fthis\-is\-variable |
| \-funsigned\-bitfields |
| \-funsigned\-char |
| \-fwritable\-strings |
| \-traditional |
| \-traditional\-cpp |
| \-trigraphs |
| .TP |
| .B Warning Options |
| \-fsyntax\-only |
| \-pedantic |
| \-pedantic\-errors |
| \-w |
| \-W |
| \-Wall |
| \-Waggregate\-return |
| \-Wcast\-align |
| \-Wcast\-qual |
| \-Wchar\-subscript |
| \-Wcomment |
| \-Wconversion |
| \-Wenum\-clash |
| \-Werror |
| \-Wformat |
| .RI \-Wid\-clash\- len |
| \-Wimplicit |
| \-Winline |
| \-Wmain |
| \-Wmissing\-prototypes |
| \-Wmissing\-declarations |
| \-Wnested\-externs |
| \-Wno\-import |
| \-Wparentheses |
| \-Wpointer\-arith |
| \-Wredundant\-decls |
| \-Wreturn\-type |
| \-Wshadow |
| \-Wstrict\-prototypes |
| \-Wswitch |
| \-Wtemplate\-debugging |
| \-Wtraditional |
| \-Wtrigraphs |
| \-Wuninitialized |
| \-Wunused |
| \-Wwrite\-strings |
| .TP |
| .B Debugging Options |
| \-a |
| .RI \-d letters |
| \-fpretend\-float |
| \-g |
| .RI \-g level |
| \-gcoff |
| \-gxcoff |
| \-gxcoff+ |
| \-gdwarf |
| \-gdwarf+ |
| \-gstabs |
| \-gstabs+ |
| \-ggdb |
| \-p |
| \-pg |
| \-save\-temps |
| .RI \-print\-file\-name= library |
| \-print\-libgcc\-file\-name |
| .RI \-print\-prog\-name= program |
| .TP |
| .B 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 |
| .TP |
| .B Preprocessor Options |
| .RI \-A assertion |
| \-C |
| \-dD |
| \-dM |
| \-dN |
| .RI \-D macro [\|= defn \|] |
| \-E |
| \-H |
| .RI "\-idirafter " dir |
| .RI "\-include " file |
| .RI "\-imacros " file |
| .RI "\-iprefix " file |
| .RI "\-iwithprefix " dir |
| \-M |
| \-MD |
| \-MM |
| \-MMD |
| \-nostdinc |
| \-P |
| .RI \-U macro |
| \-undef |
| .TP |
| .B Assembler Option |
| .RI \-Wa, option |
| .TP |
| .B Linker Options |
| .RI \-l library |
| \-nostartfiles |
| \-nostdlib |
| \-static |
| \-shared |
| \-symbolic |
| .RI "\-Xlinker\ " option |
| .RI \-Wl, option |
| .RI "\-u " symbol |
| .TP |
| .B Directory Options |
| .RI \-B prefix |
| .RI \-I dir |
| \-I\- |
| .RI \-L dir |
| .TP |
| .B Target Options |
| .RI "\-b " machine |
| .RI "\-V " version |
| .TP |
| .B Configuration Dependent Options |
| .I M680x0\ Options |
| .br |
| \-m68000 |
| \-m68020 |
| \-m68020\-40 |
| \-m68030 |
| \-m68040 |
| \-m68881 |
| \-mbitfield |
| \-mc68000 |
| \-mc68020 |
| \-mfpa |
| \-mnobitfield |
| \-mrtd |
| \-mshort |
| \-msoft\-float |
| .Sp |
| .I VAX Options |
| .br |
| \-mg |
| \-mgnu |
| \-munix |
| .Sp |
| .I SPARC Options |
| .br |
| \-mepilogue |
| \-mfpu |
| \-mhard\-float |
| \-mno\-fpu |
| \-mno\-epilogue |
| \-msoft\-float |
| \-msparclite |
| \-mv8 |
| \-msupersparc |
| \-mcypress |
| .Sp |
| .I Convex Options |
| .br |
| \-margcount |
| \-mc1 |
| \-mc2 |
| \-mnoargcount |
| .Sp |
| .I AMD29K Options |
| .br |
| \-m29000 |
| \-m29050 |
| \-mbw |
| \-mdw |
| \-mkernel\-registers |
| \-mlarge |
| \-mnbw |
| \-mnodw |
| \-msmall |
| \-mstack\-check |
| \-muser\-registers |
| .Sp |
| .I M88K Options |
| .br |
| \-m88000 |
| \-m88100 |
| \-m88110 |
| \-mbig\-pic |
| \-mcheck\-zero\-division |
| \-mhandle\-large\-shift |
| \-midentify\-revision |
| \-mno\-check\-zero\-division |
| \-mno\-ocs\-debug\-info |
| \-mno\-ocs\-frame\-position |
| \-mno\-optimize\-arg\-area |
| \-mno\-serialize\-volatile |
| \-mno\-underscores |
| \-mocs\-debug\-info |
| \-mocs\-frame\-position |
| \-moptimize\-arg\-area |
| \-mserialize\-volatile |
| .RI \-mshort\-data\- num |
| \-msvr3 |
| \-msvr4 |
| \-mtrap\-large\-shift |
| \-muse\-div\-instruction |
| \-mversion\-03.00 |
| \-mwarn\-passed\-structs |
| .Sp |
| .I RS6000 Options |
| .br |
| \-mfp\-in\-toc |
| \-mno\-fop\-in\-toc |
| .Sp |
| .I RT Options |
| .br |
| \-mcall\-lib\-mul |
| \-mfp\-arg\-in\-fpregs |
| \-mfp\-arg\-in\-gregs |
| \-mfull\-fp\-blocks |
| \-mhc\-struct\-return |
| \-min\-line\-mul |
| \-mminimum\-fp\-blocks |
| \-mnohc\-struct\-return |
| .Sp |
| .I MIPS Options |
| .br |
| \-mcpu=\fIcpu type\fP |
| \-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 \fInum\fP |
| \-nocpp |
| .Sp |
| .I i386 Options |
| .br |
| \-m486 |
| \-mno\-486 |
| \-msoft\-float |
| \-mno\-fp\-ret\-in\-387 |
| .Sp |
| .I HPPA Options |
| .br |
| \-mpa\-risc\-1\-0 |
| \-mpa\-risc\-1\-1 |
| \-mkernel |
| \-mshared\-libs |
| \-mno\-shared\-libs |
| \-mlong\-calls |
| \-mdisable\-fpregs |
| \-mdisable\-indexing |
| \-mtrailing\-colon |
| .Sp |
| .I i960 Options |
| .br |
| \-m\fIcpu-type\fP |
| \-mnumerics |
| \-msoft\-float |
| \-mleaf\-procedures |
| \-mno\-leaf\-procedures |
| \-mtail\-call |
| \-mno\-tail\-call |
| \-mcomplex\-addr |
| \-mno\-complex\-addr |
| \-mcode\-align |
| \-mno\-code\-align |
| \-mic\-compat |
| \-mic2.0\-compat |
| \-mic3.0\-compat |
| \-masm\-compat |
| \-mintel\-asm |
| \-mstrict\-align |
| \-mno\-strict\-align |
| \-mold\-align |
| \-mno\-old\-align |
| .Sp |
| .I DEC Alpha Options |
| .br |
| \-mfp\-regs |
| \-mno\-fp\-regs |
| \-mno\-soft\-float |
| \-msoft\-float |
| .Sp |
| .I System V Options |
| .br |
| \-G |
| \-Qy |
| \-Qn |
| .RI \-YP, paths |
| .RI \-Ym, dir |
| .TP |
| .B Code Generation Options |
| .RI \-fcall\-saved\- reg |
| .RI \-fcall\-used\- reg |
| .RI \-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 |
| .ad b |
| .hy 1 |
| .SH OVERALL OPTIONS |
| .TP |
| .BI "\-x " "language" |
| Specify explicitly the |
| .I language\c |
| \& 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 `\|\c |
| .B \-x\c |
| \&\|' option. Possible values of \c |
| .I language\c |
| \& are |
| `\|\c |
| .B c\c |
| \&\|', `\|\c |
| .B objective\-c\c |
| \&\|', `\|\c |
| .B c\-header\c |
| \&\|', `\|\c |
| .B c++\c |
| \&\|', |
| `\|\c |
| .B cpp\-output\c |
| \&\|', `\|\c |
| .B assembler\c |
| \&\|', and `\|\c |
| .B assembler\-with\-cpp\c |
| \&\|'. |
| .TP |
| .B \-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 `\|\c |
| .B \-x\c |
| \&\|' |
| has not been used at all). |
| .PP |
| If you want only some of the four stages (preprocess, compile, |
| assemble, link), you can use |
| `\|\c |
| .B \-x\c |
| \&\|' (or filename suffixes) to tell \c |
| .B gcc\c |
| \& where to start, and |
| one of the options `\|\c |
| .B \-c\c |
| \&\|', `\|\c |
| .B \-S\c |
| \&\|', or `\|\c |
| .B \-E\c |
| \&\|' to say where |
| .B gcc\c |
| \& is to stop. Note that some combinations (for example, |
| `\|\c |
| .B \-x cpp\-output \-E\c |
| \&\|') instruct \c |
| .B gcc\c |
| \& to do nothing at all. |
| .TP |
| .B \-c |
| Compile or assemble the source files, but do not link. The compiler |
| output is an object file corresponding to each source file. |
| .Sp |
| By default, GCC makes the object file name for a source file by replacing |
| the suffix `\|\c |
| .B .c\c |
| \&\|', `\|\c |
| .B .i\c |
| \&\|', `\|\c |
| .B .s\c |
| \&\|', etc., with `\|\c |
| .B .o\c |
| \&\|'. Use |
| .B \-o\c |
| \& to select another name. |
| .Sp |
| GCC ignores any unrecognized input files (those that do not require |
| compilation or assembly) with the |
| .B \-c |
| option. |
| .TP |
| .B \-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. |
| .Sp |
| By default, GCC makes the assembler file name for a source file by |
| replacing the suffix `\|\c |
| .B .c\c |
| \&\|', `\|\c |
| .B .i\c |
| \&\|', etc., with `\|\c |
| .B .s\c |
| \&\|'. Use |
| .B \-o\c |
| \& to select another name. |
| .Sp |
| GCC ignores any input files that don't require compilation. |
| .TP |
| .B \-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. |
| .Sp |
| GCC ignores input files which don't require preprocessing. |
| .TP |
| .BI "\-o " file |
| Place output in file \c |
| .I file\c |
| \&. 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. |
| .Sp |
| Since only one output file can be specified, it does not make sense to |
| use `\|\c |
| .B \-o\c |
| \&\|' when compiling more than one input file, unless you are |
| producing an executable file as output. |
| .Sp |
| If you do not specify `\|\c |
| .B \-o\c |
| \&\|', the default is to put an executable file |
| in `\|\c |
| .B a.out\c |
| \&\|', the object file for `\|\c |
| .I source\c |
| .B \&.\c |
| .I suffix\c |
| \&\c |
| \&\|' in |
| `\|\c |
| .I source\c |
| .B \&.o\c |
| \&\|', its assembler file in `\|\c |
| .I source\c |
| .B \&.s\c |
| \&\|', and |
| all preprocessed C source on standard output. |
| .TP |
| .B \-v |
| Print (on standard error output) the commands executed to run the stages |
| of compilation. Also print the version number of the compiler driver |
| program and of the preprocessor and the compiler proper. |
| .TP |
| .B \-pipe |
| Use pipes rather than temporary files for communication between the |
| various stages of compilation. This fails to work on some systems where |
| the assembler cannot read from a pipe; but the GNU assembler has |
| no trouble. |
| .PP |
| .SH LANGUAGE OPTIONS |
| The following options control the dialect of C that the compiler |
| accepts: |
| .TP |
| .B \-ansi |
| Support all ANSI standard C programs. |
| .Sp |
| This turns off certain features of GNU C that are incompatible with |
| ANSI C, such as the \c |
| .B asm\c |
| \&, \c |
| .B inline\c |
| \& and \c |
| .B typeof |
| keywords, and predefined macros such as \c |
| .B unix\c |
| \& and \c |
| .B vax |
| that identify the type of system you are using. It also enables the |
| undesirable and rarely used ANSI trigraph feature, and disallows `\|\c |
| .B $\c |
| \&\|' as part of identifiers. |
| .Sp |
| The alternate keywords \c |
| .B _\|_asm_\|_\c |
| \&, \c |
| .B _\|_extension_\|_\c |
| \&, |
| .B _\|_inline_\|_\c |
| \& and \c |
| .B _\|_typeof_\|_\c |
| \& continue to work despite |
| `\|\c |
| .B \-ansi\c |
| \&\|'. 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 compilations done with `\|\c |
| .B \-ansi\c |
| \&\|'. Alternate predefined macros |
| such as \c |
| .B _\|_unix_\|_\c |
| \& and \c |
| .B _\|_vax_\|_\c |
| \& are also available, with or |
| without `\|\c |
| .B \-ansi\c |
| \&\|'. |
| .Sp |
| The `\|\c |
| .B \-ansi\c |
| \&\|' option does not cause non-ANSI programs to be |
| rejected gratuitously. For that, `\|\c |
| .B \-pedantic\c |
| \&\|' is required in |
| addition to `\|\c |
| .B \-ansi\c |
| \&\|'. |
| .Sp |
| The preprocessor predefines a macro \c |
| .B _\|_STRICT_ANSI_\|_\c |
| \& when you use the `\|\c |
| .B \-ansi\c |
| \&\|' |
| 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. |
| .TP |
| .B \-fno\-asm |
| Do not recognize \c |
| .B asm\c |
| \&, \c |
| .B inline\c |
| \& or \c |
| .B typeof\c |
| \& as a |
| keyword. These words may then be used as identifiers. You can |
| use \c |
| .B _\|_asm_\|_\c |
| \&, \c |
| .B _\|_inline_\|_\c |
| \& and \c |
| .B _\|_typeof_\|_\c |
| \& instead. |
| `\|\c |
| .B \-ansi\c |
| \&\|' implies `\|\c |
| .B \-fno\-asm\c |
| \&\|'. |
| .TP |
| .B \-fno\-builtin |
| Don't recognize built-in functions that do not begin with two leading |
| underscores. Currently, the functions affected include \c |
| .B _exit\c |
| \&, |
| .B abort\c |
| \&, \c |
| .B abs\c |
| \&, \c |
| .B alloca\c |
| \&, \c |
| .B cos\c |
| \&, \c |
| .B exit\c |
| \&, |
| .B fabs\c |
| \&, \c |
| .B labs\c |
| \&, \c |
| .B memcmp\c |
| \&, \c |
| .B memcpy\c |
| \&, \c |
| .B sin\c |
| \&, |
| .B sqrt\c |
| \&, \c |
| .B strcmp\c |
| \&, \c |
| .B strcpy\c |
| \&, and \c |
| .B strlen\c |
| \&. |
| .Sp |
| The `\|\c |
| .B \-ansi\c |
| \&\|' option prevents \c |
| .B alloca\c |
| \& and \c |
| .B _exit\c |
| \& from |
| being builtin functions. |
| .TP |
| .B \-fhosted |
| Compile for a hosted environment; this implies the `\|\c |
| .B \-fbuiltin\c |
| \&\|' option, and implies that suspicious declarations of |
| .B main\c |
| \& should be warned about. |
| .TP |
| .B \-ffreestanding |
| Compile for a freestanding environment; this implies the `\|\c |
| .B \-fno-builtin\c |
| \&\|' option, and implies that |
| .B main\c |
| \& has no special requirements. |
| .TP |
| .B \-fno\-strict\-prototype |
| Treat a function declaration with no arguments, such as `\|\c |
| .B int foo |
| ();\c |
| \&\|', as C would treat it\(em\&as saying nothing about the number of |
| arguments or their types (C++ only). Normally, such a declaration in |
| C++ means that the function \c |
| .B foo\c |
| \& takes no arguments. |
| .TP |
| .B \-trigraphs |
| Support ANSI C trigraphs. The `\|\c |
| .B \-ansi\c |
| \&\|' option implies `\|\c |
| .B \-trigraphs\c |
| \&\|'. |
| .TP |
| .B \-traditional |
| Attempt to support some aspects of traditional C compilers. |
| For details, see the GNU C Manual; the duplicate list here |
| has been deleted so that we won't get complaints when it |
| is out of date. |
| .Sp |
| But one note about C++ programs only (not C). `\|\c |
| .B \-traditional\c |
| \&\|' has one additional effect for C++: assignment to |
| .B this |
| is permitted. This is the same as the effect of `\|\c |
| .B \-fthis\-is\-variable\c |
| \&\|'. |
| .TP |
| .B \-traditional\-cpp |
| 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 `\|\c |
| .B \-traditional\c |
| \&\|'. |
| .TP |
| .B \-fdollars\-in\-identifiers |
| Permit the use of `\|\c |
| .B $\c |
| \&\|' in identifiers (C++ only). You can also use |
| `\|\c |
| .B \-fno\-dollars\-in\-identifiers\c |
| \&\|' to explicitly prohibit use of |
| `\|\c |
| .B $\c |
| \&\|'. (GNU C++ allows `\|\c |
| .B $\c |
| \&\|' by default on some target systems |
| but not others.) |
| .TP |
| .B \-fenum\-int\-equiv |
| Permit implicit conversion of \c |
| .B int\c |
| \& to enumeration types (C++ |
| only). Normally GNU C++ allows conversion of \c |
| .B enum\c |
| \& to \c |
| .B int\c |
| \&, |
| but not the other way around. |
| .TP |
| .B \-fexternal\-templates |
| Produce smaller code for template declarations, by generating only a |
| single copy of each template function where it is defined (C++ only). |
| To use this option successfully, you must also mark all files that |
| use templates with either `\|\c |
| .B #pragma implementation\c |
| \&\|' (the definition) or |
| `\|\c |
| .B #pragma interface\c |
| \&\|' (declarations). |
| |
| When your code is compiled with `\|\c |
| .B \-fexternal\-templates\c |
| \&\|', all |
| template instantiations are external. You must arrange for all |
| necessary instantiations to appear in the implementation file; you can |
| do this with a \c |
| .B typedef\c |
| \& that references each instantiation needed. |
| Conversely, when you compile using the default option |
| `\|\c |
| .B \-fno\-external\-templates\c |
| \&\|', all template instantiations are |
| explicitly internal. |
| .TP |
| .B \-fall\-virtual |
| Treat all possible member functions as virtual, implicitly. All |
| member functions (except for constructor functions and |
| .B new |
| or |
| .B delete |
| member operators) are treated as virtual functions of the class where |
| they appear. |
| .Sp |
| This does not mean that all calls to these member functions will be |
| made through the internal table of virtual functions. Under some |
| circumstances, the compiler can determine that a call to a given |
| virtual function can be made directly; in these cases the calls are |
| direct in any case. |
| .TP |
| .B \-fcond\-mismatch |
| Allow conditional expressions with mismatched types in the second and |
| third arguments. The value of such an expression is void. |
| .TP |
| .B \-fthis\-is\-variable |
| Permit assignment to \c |
| .B this\c |
| \& (C++ only). The incorporation of |
| user-defined free store management into C++ has made assignment to |
| `\|\c |
| .B this\c |
| \&\|' an anachronism. Therefore, by default it is invalid to |
| assign to \c |
| .B this\c |
| \& within a class member function. However, for |
| backwards compatibility, you can make it valid with |
| `\|\c |
| .B \-fthis-is-variable\c |
| \&\|'. |
| .TP |
| .B \-funsigned\-char |
| Let the type \c |
| .B char\c |
| \& be unsigned, like \c |
| .B unsigned char\c |
| \&. |
| .Sp |
| Each kind of machine has a default for what \c |
| .B char\c |
| \& should |
| be. It is either like \c |
| .B unsigned char\c |
| \& by default or like |
| .B signed char\c |
| \& by default. |
| .Sp |
| Ideally, a portable program should always use \c |
| .B signed char\c |
| \& or |
| .B unsigned char\c |
| \& when it depends on the signedness of an object. |
| But many programs have been written to use plain \c |
| .B char\c |
| \& and |
| expect it to be signed, or expect it to be unsigned, depending on the |
| machines they were written for. This option, and its inverse, let you |
| make such a program work with the opposite default. |
| .Sp |
| The type \c |
| .B char\c |
| \& is always a distinct type from each of |
| .B signed char\c |
| \& and \c |
| .B unsigned char\c |
| \&, even though its behavior |
| is always just like one of those two. |
| .TP |
| .B \-fsigned\-char |
| Let the type \c |
| .B char\c |
| \& be signed, like \c |
| .B signed char\c |
| \&. |
| .Sp |
| Note that this is equivalent to `\|\c |
| .B \-fno\-unsigned\-char\c |
| \&\|', which is |
| the negative form of `\|\c |
| .B \-funsigned\-char\c |
| \&\|'. Likewise, |
| `\|\c |
| .B \-fno\-signed\-char\c |
| \&\|' is equivalent to `\|\c |
| .B \-funsigned\-char\c |
| \&\|'. |
| .TP |
| .B \-fsigned\-bitfields |
| .TP |
| .B \-funsigned\-bitfields |
| .TP |
| .B \-fno\-signed\-bitfields |
| .TP |
| .B \-fno\-unsigned\-bitfields |
| These options control whether a bitfield is |
| signed or unsigned, when declared with no explicit `\|\c |
| .B signed\c |
| \&\|' or `\|\c |
| .B unsigned\c |
| \&\|' qualifier. By default, such a bitfield is |
| signed, because this is consistent: the basic integer types such as |
| .B int\c |
| \& are signed types. |
| .Sp |
| However, when you specify `\|\c |
| .B \-traditional\c |
| \&\|', bitfields are all unsigned |
| no matter what. |
| .TP |
| .B \-fwritable\-strings |
| Store string constants in the writable data segment and don't uniquize |
| them. This is for compatibility with old programs which assume they |
| can write into string constants. `\|\c |
| .B \-traditional\c |
| \&\|' also has this |
| effect. |
| .Sp |
| Writing into string constants is a very bad idea; \*(lqconstants\*(rq should |
| be constant. |
| .SH PREPROCESSOR OPTIONS |
| These options control the C preprocessor, which is run on each C source |
| file before actual compilation. |
| .PP |
| If you use the `\|\c |
| .B \-E\c |
| \&\|' option, GCC does nothing except preprocessing. |
| Some of these options make sense only together with `\|\c |
| .B \-E\c |
| \&\|' because |
| they cause the preprocessor output to be unsuitable for actual |
| compilation. |
| .TP |
| .BI "\-include " "file" |
| Process \c |
| .I file\c |
| \& as input before processing the regular input file. |
| In effect, the contents of \c |
| .I file\c |
| \& are compiled first. Any `\|\c |
| .B \-D\c |
| \&\|' |
| and `\|\c |
| .B \-U\c |
| \&\|' options on the command line are always processed before |
| `\|\c |
| .B \-include \c |
| .I file\c |
| \&\c |
| \&\|', regardless of the order in which they are |
| written. All the `\|\c |
| .B \-include\c |
| \&\|' and `\|\c |
| .B \-imacros\c |
| \&\|' options are |
| processed in the order in which they are written. |
| .TP |
| .BI "\-imacros " file |
| Process \c |
| .I file\c |
| \& as input, discarding the resulting output, before |
| processing the regular input file. Because the output generated from |
| .I file\c |
| \& is discarded, the only effect of `\|\c |
| .B \-imacros \c |
| .I file\c |
| \&\c |
| \&\|' is to |
| make the macros defined in \c |
| .I file\c |
| \& available for use in the main |
| input. The preprocessor evaluates any `\|\c |
| .B \-D\c |
| \&\|' and `\|\c |
| .B \-U\c |
| \&\|' options |
| on the command line before processing `\|\c |
| .B \-imacros\c |
| .I file\c |
| \&\|', regardless of the order in |
| which they are written. All the `\|\c |
| .B \-include\c |
| \&\|' and `\|\c |
| .B \-imacros\c |
| \&\|' |
| options are processed in the order in which they are written. |
| .TP |
| .BI "\-idirafter " "dir" |
| Add the directory \c |
| .I dir\c |
| \& to the second include path. The directories |
| on the second include path are searched when a header file is not found |
| in any of the directories in the main include path (the one that |
| `\|\c |
| .B \-I\c |
| \&\|' adds to). |
| .TP |
| .BI "\-iprefix " "prefix" |
| Specify \c |
| .I prefix\c |
| \& as the prefix for subsequent `\|\c |
| .B \-iwithprefix\c |
| \&\|' |
| options. |
| .TP |
| .BI "\-iwithprefix " "dir" |
| Add a directory to the second include path. The directory's name is |
| made by concatenating \c |
| .I prefix\c |
| \& and \c |
| .I dir\c |
| \&, where \c |
| .I prefix |
| was specified previously with `\|\c |
| .B \-iprefix\c |
| \&\|'. |
| .TP |
| .B \-nostdinc |
| Do not search the standard system directories for header files. Only |
| the directories you have specified with `\|\c |
| .B \-I\c |
| \&\|' options (and the |
| current directory, if appropriate) are searched. |
| .Sp |
| By using both `\|\c |
| .B \-nostdinc\c |
| \&\|' and `\|\c |
| .B \-I\-\c |
| \&\|', you can limit the include-file search file to only those |
| directories you specify explicitly. |
| .TP |
| .B \-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 `\|\c |
| .B libg++\c |
| \&\|'.) |
| .TP |
| .B \-undef |
| Do not predefine any nonstandard macros. (Including architecture flags). |
| .TP |
| .B \-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. |
| .TP |
| .B \-C |
| Tell the preprocessor not to discard comments. Used with the |
| `\|\c |
| .B \-E\c |
| \&\|' option. |
| .TP |
| .B \-P |
| Tell the preprocessor not to generate `\|\c |
| .B #line\c |
| \&\|' commands. |
| Used with the `\|\c |
| .B \-E\c |
| \&\|' option. |
| .TP |
| .B \-M\ [ \-MG ] |
| Tell the preprocessor to output a rule suitable for \c |
| .B make |
| describing the dependencies of each object file. For each source file, |
| the preprocessor outputs one \c |
| .B make\c |
| \&-rule whose target is the object |
| file name for that source file and whose dependencies are all the files |
| `\|\c |
| .B #include\c |
| \&\|'d in it. This rule may be a single line or may be |
| continued with `\|\c |
| .B \e\c |
| \&\|'-newline if it is long. The list of rules is |
| printed on standard output instead of the preprocessed C program. |
| .Sp |
| `\|\c |
| .B \-M\c |
| \&\|' implies `\|\c |
| .B \-E\c |
| \&\|'. |
| .Sp |
| `\|\c |
| .B \-MG\c |
| \&\|' says to treat missing header files as generated files and assume \c |
| they live in the same directory as the source file. It must be specified \c |
| in addition to `\|\c |
| .B \-M\c |
| \&\|'. |
| .TP |
| .B \-MM\ [ \-MG ] |
| Like `\|\c |
| .B \-M\c |
| \&\|' but the output mentions only the user header files |
| included with `\|\c |
| .B #include "\c |
| .I file\c |
| \&"\c |
| \&\|'. System header files |
| included with `\|\c |
| .B #include <\c |
| .I file\c |
| \&>\c |
| \&\|' are omitted. |
| .TP |
| .B \-MD |
| Like `\|\c |
| .B \-M\c |
| \&\|' but the dependency information is written to files with |
| names made by replacing `\|\c |
| .B .o\c |
| \&\|' with `\|\c |
| .B .d\c |
| \&\|' at the end of the |
| output file names. This is in addition to compiling the file as |
| specified\(em\&`\|\c |
| .B \-MD\c |
| \&\|' does not inhibit ordinary compilation the way |
| `\|\c |
| .B \-M\c |
| \&\|' does. |
| .Sp |
| The Mach utility `\|\c |
| .B md\c |
| \&\|' can be used to merge the `\|\c |
| .B .d\c |
| \&\|' files |
| into a single dependency file suitable for using with the `\|\c |
| .B make\c |
| \&\|' |
| command. |
| .TP |
| .B \-MMD |
| Like `\|\c |
| .B \-MD\c |
| \&\|' except mention only user header files, not system |
| header files. |
| .TP |
| .B \-H |
| Print the name of each header file used, in addition to other normal |
| activities. |
| .TP |
| .BI "\-A" "question" ( answer ) |
| Assert the answer |
| .I answer |
| for |
| .I question\c |
| \&, in case it is tested |
| with a preprocessor conditional such as `\|\c |
| .BI "#if #" question ( answer )\c |
| \&\|'. `\|\c |
| .B \-A\-\c |
| \&\|' disables the standard |
| assertions that normally describe the target machine. |
| .TP |
| .BI "\-A" "question"\c |
| \&(\c |
| .I answer\c |
| \&) |
| Assert the answer \c |
| .I answer\c |
| \& for \c |
| .I question\c |
| \&, in case it is tested |
| with a preprocessor conditional such as `\|\c |
| .B #if |
| #\c |
| .I question\c |
| \&(\c |
| .I answer\c |
| \&)\c |
| \&\|'. `\|\c |
| .B \-A-\c |
| \&\|' disables the standard |
| assertions that normally describe the target machine. |
| .TP |
| .BI \-D macro |
| Define macro \c |
| .I macro\c |
| \& with the string `\|\c |
| .B 1\c |
| \&\|' as its definition. |
| .TP |
| .BI \-D macro = defn |
| Define macro \c |
| .I macro\c |
| \& as \c |
| .I defn\c |
| \&. All instances of `\|\c |
| .B \-D\c |
| \&\|' on |
| the command line are processed before any `\|\c |
| .B \-U\c |
| \&\|' options. |
| .TP |
| .BI \-U macro |
| Undefine macro \c |
| .I macro\c |
| \&. `\|\c |
| .B \-U\c |
| \&\|' options are evaluated after all `\|\c |
| .B \-D\c |
| \&\|' options, but before any `\|\c |
| .B \-include\c |
| \&\|' and `\|\c |
| .B \-imacros\c |
| \&\|' options. |
| .TP |
| .B \-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 `\|\c |
| .B \-E\c |
| \&\|' |
| option. |
| .TP |
| .B \-dD |
| Tell the preprocessor to pass all macro definitions into the output, in |
| their proper sequence in the rest of the output. |
| .TP |
| .B \-dN |
| Like `\|\c |
| .B \-dD\c |
| \&\|' except that the macro arguments and contents are omitted. |
| Only `\|\c |
| .B #define \c |
| .I name\c |
| \&\c |
| \&\|' is included in the output. |
| .SH ASSEMBLER OPTION |
| .TP |
| .BI "\-Wa," "option" |
| Pass \c |
| .I option\c |
| \& as an option to the assembler. If \c |
| .I option |
| contains commas, it is split into multiple options at the commas. |
| .SH LINKER OPTIONS |
| 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. |
| .TP |
| .I 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 GCC does a link step, these object files are used as input |
| to the linker. |
| .TP |
| .BI \-l library |
| Use the library named \c |
| .I library\c |
| \& when linking. |
| .Sp |
| The linker searches a standard list of directories for the library, |
| which is actually a file named `\|\c |
| .B lib\c |
| .I library\c |
| \&.a\c |
| \&\|'. The linker |
| then uses this file as if it had been specified precisely by name. |
| .Sp |
| The directories searched include several standard system directories |
| plus any that you specify with `\|\c |
| .B \-L\c |
| \&\|'. |
| .Sp |
| Normally the files found this way are library files\(em\&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. 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 `\|\c |
| .B \-l\c |
| \&\|' option and specifying a file |
| name is that `\|\c |
| .B \-l\c |
| \&\|' surrounds |
| .I library |
| with `\|\c |
| .B lib\c |
| \&\|' and `\|\c |
| .B .a\c |
| \&\|' and searches several directories. |
| .TP |
| .B \-lobjc |
| You need this special case of the |
| .B \-l |
| option in order to link an Objective C program. |
| .TP |
| .B \-nostartfiles |
| Do not use the standard system startup files when linking. |
| The standard libraries are used normally. |
| .TP |
| .B \-nostdlib |
| Don't use the standard system libraries and startup files when linking. |
| Only the files you specify will be passed to the linker. |
| .TP |
| .B \-static |
| On systems that support dynamic linking, this prevents linking with the shared |
| libraries. On other systems, this option has no effect. |
| .TP |
| .B \-shared |
| Produce a shared object which can then be linked with other objects to |
| form an executable. Only a few systems support this option. |
| .TP |
| .B \-symbolic |
| Bind references to global symbols when building a shared object. Warn |
| about any unresolved references (unless overridden by the link editor |
| option `\|\c |
| .B |
| \-Xlinker \-z \-Xlinker defs\c |
| \&\|'). Only a few systems support |
| this option. |
| .TP |
| .BI "\-Xlinker " "option" |
| Pass \c |
| .I 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. |
| .Sp |
| If you want to pass an option that takes an argument, you must use |
| `\|\c |
| .B \-Xlinker\c |
| \&\|' twice, once for the option and once for the argument. |
| For example, to pass `\|\c |
| .B |
| \-assert definitions\c |
| \&\|', you must write |
| `\|\c |
| .B |
| \-Xlinker \-assert \-Xlinker definitions\c |
| \&\|'. It does not work to write |
| `\|\c |
| .B |
| \-Xlinker "\-assert definitions"\c |
| \&\|', because this passes the entire |
| string as a single argument, which is not what the linker expects. |
| .TP |
| .BI "\-Wl," "option" |
| Pass \c |
| .I option\c |
| \& as an option to the linker. If \c |
| .I option\c |
| \& contains |
| commas, it is split into multiple options at the commas. |
| .TP |
| .BI "\-u " "symbol" |
| Pretend the symbol |
| .I symbol |
| is undefined, to force linking of |
| library modules to define it. You can use `\|\c |
| .B \-u\c |
| \&\|' multiple times with |
| different symbols to force loading of additional library modules. |
| .SH DIRECTORY OPTIONS |
| These options specify directories to search for header files, for |
| libraries and for parts of the compiler: |
| .TP |
| .BI "\-I" "dir" |
| Append directory \c |
| .I dir\c |
| \& to the list of directories searched for include files. |
| .TP |
| .B \-I\- |
| Any directories you specify with `\|\c |
| .B \-I\c |
| \&\|' options before the `\|\c |
| .B \-I\-\c |
| \&\|' |
| option are searched only for the case of `\|\c |
| .B |
| #include "\c |
| .I file\c |
| .B |
| \&"\c |
| \&\|'; |
| they are not searched for `\|\c |
| .B #include <\c |
| .I file\c |
| \&>\c |
| \&\|'. |
| .Sp |
| If additional directories are specified with `\|\c |
| .B \-I\c |
| \&\|' options after |
| the `\|\c |
| .B \-I\-\c |
| \&\|', these directories are searched for all `\|\c |
| .B #include\c |
| \&\|' |
| directives. (Ordinarily \c |
| .I all\c |
| \& `\|\c |
| .B \-I\c |
| \&\|' directories are used |
| this way.) |
| .Sp |
| In addition, the `\|\c |
| .B \-I\-\c |
| \&\|' option inhibits the use of the current |
| directory (where the current input file came from) as the first search |
| directory for `\|\c |
| .B |
| #include "\c |
| .I file\c |
| .B |
| \&"\c |
| \&\|'. There is no way to |
| override this effect of `\|\c |
| .B \-I\-\c |
| \&\|'. With `\|\c |
| .B \-I.\c |
| \&\|' 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. |
| .Sp |
| `\|\c |
| .B \-I\-\c |
| \&\|' does not inhibit the use of the standard system directories |
| for header files. Thus, `\|\c |
| .B \-I\-\c |
| \&\|' and `\|\c |
| .B \-nostdinc\c |
| \&\|' are |
| independent. |
| .TP |
| .BI "\-L" "dir" |
| Add directory \c |
| .I dir\c |
| \& to the list of directories to be searched |
| for `\|\c |
| .B \-l\c |
| \&\|'. |
| .TP |
| .BI "\-B" "prefix" |
| This option specifies where to find the executables, libraries and |
| data files of the compiler itself. |
| .Sp |
| The compiler driver program runs one or more of the subprograms |
| `\|\c |
| .B cpp\c |
| \&\|', `\|\c |
| .B cc1\c |
| \&\|' (or, for C++, `\|\c |
| .B cc1plus\c |
| \&\|'), `\|\c |
| .B as\c |
| \&\|' and `\|\c |
| .B ld\c |
| \&\|'. It tries |
| .I prefix\c |
| \& as a prefix for each program it tries to run, both with and |
| without `\|\c |
| .I machine\c |
| .B /\c |
| .I version\c |
| .B /\c |
| \&\|'. |
| .Sp |
| For each subprogram to be run, the compiler driver first tries the |
| `\|\c |
| .B \-B\c |
| \&\|' prefix, if any. If that name is not found, or if `\|\c |
| .B \-B\c |
| \&\|' |
| was not specified, the driver tries two standard prefixes, which are |
| `\|\c |
| .B /usr/lib/gcc/\c |
| \&\|' and `\|\c |
| .B /usr/local/lib/gcc-lib/\c |
| \&\|'. If neither of |
| those results in a file name that is found, the compiler driver |
| searches for the unmodified program |
| name, using the directories specified in your |
| `\|\c |
| .B PATH\c |
| \&\|' environment variable. |
| .Sp |
| The run-time support file `\|\c |
| .B libgcc.a\c |
| \&\|' is also searched for using the |
| `\|\c |
| .B \-B\c |
| \&\|' 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, `\|\c |
| .B libgcc.a\c |
| \&\|' is not actually necessary. |
| .Sp |
| You can get a similar result from the environment variable |
| .B GCC_EXEC_PREFIX\c |
| \&; if it is defined, its value is used as a prefix |
| in the same way. If both the `\|\c |
| .B \-B\c |
| \&\|' option and the |
| .B GCC_EXEC_PREFIX\c |
| \& variable are present, the `\|\c |
| .B \-B\c |
| \&\|' option is |
| used first and the environment variable value second. |
| .SH WARNING OPTIONS |
| Warnings are diagnostic messages that report constructions which |
| are not inherently erroneous but which are risky or suggest there |
| may have been an error. |
| .Sp |
| These options control the amount and kinds of warnings produced by GNU |
| CC: |
| .TP |
| .B \-fsyntax\-only |
| Check the code for syntax errors, but don't emit any output. |
| .TP |
| .B \-w |
| Inhibit all warning messages. |
| .TP |
| .B \-Wno\-import |
| Inhibit warning messages about the use of |
| .BR #import . |
| .TP |
| .B \-pedantic |
| Issue all the warnings demanded by strict ANSI standard C; reject |
| all programs that use forbidden extensions. |
| .Sp |
| Valid ANSI standard C programs should compile properly with or without |
| this option (though a rare few will require `\|\c |
| .B \-ansi\c |
| \&\|'). However, |
| without this option, certain GNU extensions and traditional C features |
| are supported as well. With this option, they are rejected. There is |
| no reason to \c |
| .I use\c |
| \& this option; it exists only to satisfy pedants. |
| .Sp |
| `\|\c |
| .B \-pedantic\c |
| \&\|' does not cause warning messages for use of the |
| alternate keywords whose names begin and end with `\|\c |
| .B _\|_\c |
| \&\|'. Pedantic |
| warnings are also disabled in the expression that follows |
| .B _\|_extension_\|_\c |
| \&. However, only system header files should use |
| these escape routes; application programs should avoid them. |
| .TP |
| .B \-pedantic\-errors |
| Like `\|\c |
| .B \-pedantic\c |
| \&\|', except that errors are produced rather than |
| warnings. |
| .TP |
| .B \-W |
| Print extra warning messages for these events: |
| .TP |
| \ \ \ \(bu |
| A nonvolatile automatic variable might be changed by a call to |
| .B longjmp\c |
| \&. These warnings are possible only in |
| optimizing compilation. |
| .Sp |
| The compiler sees only the calls to \c |
| .B setjmp\c |
| \&. It cannot know |
| where \c |
| .B longjmp\c |
| \& 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 \c |
| .B longjmp\c |
| \& cannot |
| in fact be called at the place which would cause a problem. |
| .TP |
| \ \ \ \(bu |
| 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: |
| .Sp |
| .nf |
| foo (a) |
| { |
| if (a > 0) |
| return a; |
| } |
| .Sp |
| .fi |
| Spurious warnings can occur because GNU CC does not realize that |
| certain functions (including \c |
| .B abort\c |
| \& and \c |
| .B longjmp\c |
| \&) |
| will never return. |
| .TP |
| \ \ \ \(bu |
| An expression-statement or the left-hand side of a comma expression |
| contains no side effects. |
| To suppress the warning, cast the unused expression to void. |
| For example, an expression such as `\|\c |
| .B x[i,j]\c |
| \&\|' will cause a warning, |
| but `\|\c |
| .B x[(void)i,j]\c |
| \&\|' will not. |
| .TP |
| \ \ \ \(bu |
| An unsigned value is compared against zero with `\|\c |
| .B >\c |
| \&\|' or `\|\c |
| .B <=\c |
| \&\|'. |
| .PP |
| .TP |
| .B \-Wimplicit |
| Warn whenever a function or parameter is implicitly declared. |
| .TP |
| .B \-Wmain |
| Warn if the |
| .B main |
| function is declared or defined with a suspicious type. |
| Typically, it is a function with external linkage, returning |
| .B int\c |
| \&, and |
| taking zero or two arguments. |
| |
| .TP |
| .B \-Wreturn\-type |
| Warn whenever a function is defined with a return-type that defaults |
| to \c |
| .B int\c |
| \&. Also warn about any \c |
| .B return\c |
| \& statement with no |
| return-value in a function whose return-type is not \c |
| .B void\c |
| \&. |
| .TP |
| .B \-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. |
| .TP |
| .B \-Wswitch |
| Warn whenever a \c |
| .B switch\c |
| \& statement has an index of enumeral type |
| and lacks a \c |
| .B case\c |
| \& for one or more of the named codes of that |
| enumeration. (The presence of a \c |
| .B default\c |
| \& label prevents this |
| warning.) \c |
| .B case\c |
| \& labels outside the enumeration range also |
| provoke warnings when this option is used. |
| .TP |
| .B \-Wcomment |
| Warn whenever a comment-start sequence `\|\c |
| .B /\(**\c |
| \&\|' appears in a comment. |
| .TP |
| .B \-Wtrigraphs |
| Warn if any trigraphs are encountered (assuming they are enabled). |
| .TP |
| .B \-Wformat |
| Check calls to \c |
| .B printf\c |
| \& and \c |
| .B scanf\c |
| \&, etc., to make sure that |
| the arguments supplied have types appropriate to the format string |
| specified. |
| .TP |
| .B \-Wchar\-subscripts |
| Warn if an array subscript has type |
| .BR char . |
| This is a common cause of error, as programmers often forget that this |
| type is signed on some machines. |
| .TP |
| .B \-Wuninitialized |
| An automatic variable is used without first being initialized. |
| .Sp |
| 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 `\|\c |
| .B \-O\c |
| \&\|', you simply won't |
| get these warnings. |
| .Sp |
| These warnings occur only for variables that are candidates for |
| register allocation. Therefore, they do not occur for a variable that |
| is declared \c |
| .B volatile\c |
| \&, 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. |
| .Sp |
| 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. |
| .Sp |
| 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: |
| .Sp |
| .nf |
| { |
| int x; |
| switch (y) |
| { |
| case 1: x = 1; |
| break; |
| case 2: x = 4; |
| break; |
| case 3: x = 5; |
| } |
| foo (x); |
| } |
| .Sp |
| .fi |
| If the value of \c |
| .B y\c |
| \& is always 1, 2 or 3, then \c |
| .B x\c |
| \& is |
| always initialized, but GNU CC doesn't know this. Here is |
| another common case: |
| .Sp |
| .nf |
| { |
| int save_y; |
| if (change_y) save_y = y, y = new_y; |
| .\|.\|. |
| if (change_y) y = save_y; |
| } |
| .Sp |
| .fi |
| This has no bug because \c |
| .B save_y\c |
| \& is used only if it is set. |
| .Sp |
| Some spurious warnings can be avoided if you declare as |
| .B volatile\c |
| \& all the functions you use that never return. |
| .TP |
| .B \-Wparentheses |
| Warn if parentheses are omitted in certain contexts. |
| .TP |
| .B \-Wtemplate\-debugging |
| When using templates in a C++ program, warn if debugging is not yet |
| fully available (C++ only). |
| .TP |
| .B \-Wall |
| All of the above `\|\c |
| .B \-W\c |
| \&\|' 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. |
| .PP |
| The remaining `\|\c |
| .B \-W.\|.\|.\c |
| \&\|' options are not implied by `\|\c |
| .B \-Wall\c |
| \&\|' |
| because they warn about constructions that we consider reasonable to |
| use, on occasion, in clean programs. |
| .TP |
| .B \-Wtraditional |
| Warn about certain constructs that behave differently in traditional and |
| ANSI C. |
| .TP |
| \ \ \ \(bu |
| 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. |
| .TP |
| \ \ \ \(bu |
| A function declared external in one block and then used after the end of |
| the block. |
| .TP |
| \ \ \ \(bu |
| A \c |
| .B switch\c |
| \& statement has an operand of type \c |
| .B long\c |
| \&. |
| .PP |
| .TP |
| .B \-Wshadow |
| Warn whenever a local variable shadows another local variable. |
| .TP |
| .BI "\-Wid\-clash\-" "len" |
| Warn whenever two distinct identifiers match in the first \c |
| .I len |
| characters. This may help you prepare a program that will compile |
| with certain obsolete, brain-damaged compilers. |
| .TP |
| .B \-Wpointer\-arith |
| Warn about anything that depends on the \*(lqsize of\*(rq a function type or |
| of \c |
| .B void\c |
| \&. GNU C assigns these types a size of 1, for |
| convenience in calculations with \c |
| .B void \(**\c |
| \& pointers and pointers |
| to functions. |
| .TP |
| .B \-Wcast\-qual |
| Warn whenever a pointer is cast so as to remove a type qualifier from |
| the target type. For example, warn if a \c |
| .B const char \(**\c |
| \& is cast |
| to an ordinary \c |
| .B char \(**\c |
| \&. |
| .TP |
| .B \-Wcast\-align |
| Warn whenever a pointer is cast such that the required alignment of the |
| target is increased. For example, warn if a \c |
| .B char \(**\c |
| \& is cast to |
| an \c |
| .B int \(**\c |
| \& on machines where integers can only be accessed at |
| two- or four-byte boundaries. |
| .TP |
| .B \-Wwrite\-strings |
| Give string constants the type \c |
| .B const char[\c |
| .I length\c |
| .B ]\c |
| \& so that |
| copying the address of one into a non-\c |
| .B const\c |
| \& \c |
| .B 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 \c |
| .B const\c |
| \& in |
| declarations and prototypes. Otherwise, it will just be a nuisance; |
| this is why we did not make `\|\c |
| .B \-Wall\c |
| \&\|' request these warnings. |
| .TP |
| .B \-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. |
| .TP |
| .B \-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.) |
| .TP |
| .B \-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.) |
| .TP |
| .B \-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. |
| .TP |
| .B \-Wmissing\-declarations |
| 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 in |
| header files. |
| .TP |
| .B \-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. |
| .TP |
| .B \-Wnested-externs |
| Warn if an \c |
| .B extern\c |
| \& declaration is encountered within an function. |
| .TP |
| .B \-Wenum\-clash |
| Warn about conversion between different enumeration types (C++ only). |
| .TP |
| .B \-Woverloaded\-virtual |
| (C++ only.) |
| In a derived class, the definitions of virtual functions must match |
| the type signature of a virtual function declared in the base class. |
| Use this option to request warnings when a derived class declares a |
| function that may be an erroneous attempt to define a virtual |
| function: that is, warn when a function with the same name as a |
| virtual function in the base class, but with a type signature that |
| doesn't match any virtual functions from the base class. |
| .TP |
| .B \-Winline |
| Warn if a function can not be inlined, and either it was declared as inline, |
| or else the |
| .B \-finline\-functions |
| option was given. |
| .TP |
| .B \-Werror |
| Treat warnings as errors; abort compilation after any warning. |
| .SH DEBUGGING OPTIONS |
| GNU CC has various special options that are used for debugging |
| either your program or GCC: |
| .TP |
| .B \-g |
| Produce debugging information in the operating system's native format |
| (stabs, COFF, XCOFF, or DWARF). GDB can work with this debugging |
| information. |
| .Sp |
| On most systems that use stabs format, `\|\c |
| .B \-g\c |
| \&\|' enables use of extra |
| debugging information that only GDB can use; this extra information |
| makes debugging work better in GDB but will probably make other debuggers |
| crash or |
| refuse to read the program. If you want to control for certain whether |
| to generate the extra information, use `\|\c |
| .B \-gstabs+\c |
| \&\|', `\|\c |
| .B \-gstabs\c |
| \&\|', |
| `\|\c |
| .B \-gxcoff+\c |
| \&\|', `\|\c |
| .B \-gxcoff\c |
| \&\|', `\|\c |
| .B \-gdwarf+\c |
| \&\|', or `\|\c |
| .B \-gdwarf\c |
| \&\|' |
| (see below). |
| .Sp |
| Unlike most other C compilers, GNU CC allows you to use `\|\c |
| .B \-g\c |
| \&\|' with |
| `\|\c |
| .B \-O\c |
| \&\|'. 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. |
| .Sp |
| Nevertheless it proves possible to debug optimized output. This makes |
| it reasonable to use the optimizer for programs that might have bugs. |
| .PP |
| The following options are useful when GNU CC is generated with the |
| capability for more than one debugging format. |
| .TP |
| .B \-ggdb |
| Produce debugging information in the native format (if that is supported), |
| including GDB extensions if at all possible. |
| .TP |
| .B \-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. |
| .TP |
| .B \-gstabs+ |
| Produce debugging information in stabs format (if that is supported), |
| using GNU extensions understood only by the GNU debugger (GDB). The |
| use of these extensions is likely to make other debuggers crash or |
| refuse to read the program. |
| .TP |
| .B \-gcoff |
| Produce debugging information in COFF format (if that is supported). |
| This is the format used by SDB on most System V systems prior to |
| System V Release 4. |
| .TP |
| .B \-gxcoff |
| Produce debugging information in XCOFF format (if that is supported). |
| This is the format used by the DBX debugger on IBM RS/6000 systems. |
| .TP |
| .B \-gxcoff+ |
| Produce debugging information in XCOFF format (if that is supported), |
| using GNU extensions understood only by the GNU debugger (GDB). The |
| use of these extensions is likely to make other debuggers crash or |
| refuse to read the program. |
| .TP |
| .B \-gdwarf |
| Produce debugging information in DWARF format (if that is supported). |
| This is the format used by SDB on most System V Release 4 systems. |
| .TP |
| .B \-gdwarf+ |
| Produce debugging information in DWARF format (if that is supported), |
| using GNU extensions understood only by the GNU debugger (GDB). The |
| use of these extensions is likely to make other debuggers crash or |
| refuse to read the program. |
| .PP |
| .BI "\-g" "level" |
| .br |
| .BI "\-ggdb" "level" |
| .br |
| .BI "\-gstabs" "level" |
| .br |
| .BI "\-gcoff" "level" |
| .BI "\-gxcoff" "level" |
| .TP |
| .BI "\-gdwarf" "level" |
| Request debugging information and also use \c |
| .I level\c |
| \& to specify how |
| much information. The default level is 2. |
| .Sp |
| 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. |
| .Sp |
| Level 3 includes extra information, such as all the macro definitions |
| present in the program. Some debuggers support macro expansion when |
| you use `\|\c |
| .B \-g3\c |
| \&\|'. |
| .TP |
| .B \-p |
| Generate extra code to write profile information suitable for the |
| analysis program \c |
| .B prof\c |
| \&. |
| .TP |
| .B \-pg |
| Generate extra code to write profile information suitable for the |
| analysis program \c |
| .B gprof\c |
| \&. |
| .TP |
| .B \-a |
| 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 \c |
| .B tcov\c |
| \&. Note, |
| however, that the format of the data is not what \c |
| .B tcov\c |
| \& expects. |
| Eventually GNU \c |
| .B gprof\c |
| \& should be extended to process this data. |
| .TP |
| .B \-ax |
| Generate extra code to read basic block profiling parameters from |
| file `bb.in' and write profiling results to file `bb.out'. |
| `bb.in' contains a list of functions. Whenever a function on the list |
| is 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 not |
| unique it can be disambiguated by writing |
| `/path/filename.d:functionname'. `bb.out' will list some available |
| filenames. |
| 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 from |
| the trace. |
| `__bb_showret__' will cause return instructions to be included in |
| the trace. |
| .TP |
| .BI "\-d" "letters" |
| Says to make debugging dumps during compilation at times specified by |
| .I letters\c |
| \&. 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. `\|\c |
| .B foo.c.rtl\c |
| \&\|' or `\|\c |
| .B foo.c.jump\c |
| \&\|'). |
| .TP |
| .B \-dM |
| Dump all macro definitions, at the end of preprocessing, and write no |
| output. |
| .TP |
| .B \-dN |
| Dump all macro names, at the end of preprocessing. |
| .TP |
| .B \-dD |
| Dump all macro definitions, at the end of preprocessing, in addition to |
| normal output. |
| .TP |
| .B \-dy |
| Dump debugging information during parsing, to standard error. |
| .TP |
| .B \-dr |
| Dump after RTL generation, to `\|\c |
| .I file\c |
| .B \&.rtl\c |
| \&\|'. |
| .TP |
| .B \-dx |
| Just generate RTL for a function instead of compiling it. Usually used |
| with `\|\c |
| .B r\c |
| \&\|'. |
| .TP |
| .B \-dj |
| Dump after first jump optimization, to `\|\c |
| .I file\c |
| .B \&.jump\c |
| \&\|'. |
| .TP |
| .B \-ds |
| Dump after CSE (including the jump optimization that sometimes |
| follows CSE), to `\|\c |
| .I file\c |
| .B \&.cse\c |
| \&\|'. |
| .TP |
| .B \-dL |
| Dump after loop optimization, to `\|\c |
| .I file\c |
| .B \&.loop\c |
| \&\|'. |
| .TP |
| .B \-dt |
| Dump after the second CSE pass (including the jump optimization that |
| sometimes follows CSE), to `\|\c |
| .I file\c |
| .B \&.cse2\c |
| \&\|'. |
| .TP |
| .B \-df |
| Dump after flow analysis, to `\|\c |
| .I file\c |
| .B \&.flow\c |
| \&\|'. |
| .TP |
| .B \-dc |
| Dump after instruction combination, to `\|\c |
| .I file\c |
| .B \&.combine\c |
| \&\|'. |
| .TP |
| .B \-dS |
| Dump after the first instruction scheduling pass, to |
| `\|\c |
| .I file\c |
| .B \&.sched\c |
| \&\|'. |
| .TP |
| .B \-dl |
| Dump after local register allocation, to `\|\c |
| .I file\c |
| .B \&.lreg\c |
| \&\|'. |
| .TP |
| .B \-dg |
| Dump after global register allocation, to `\|\c |
| .I file\c |
| .B \&.greg\c |
| \&\|'. |
| .TP |
| .B \-dR |
| Dump after the second instruction scheduling pass, to |
| `\|\c |
| .I file\c |
| .B \&.sched2\c |
| \&\|'. |
| .TP |
| .B \-dJ |
| Dump after last jump optimization, to `\|\c |
| .I file\c |
| .B \&.jump2\c |
| \&\|'. |
| .TP |
| .B \-dd |
| Dump after delayed branch scheduling, to `\|\c |
| .I file\c |
| .B \&.dbr\c |
| \&\|'. |
| .TP |
| .B \-dk |
| Dump after conversion from registers to stack, to `\|\c |
| .I file\c |
| .B \&.stack\c |
| \&\|'. |
| .TP |
| .B \-da |
| Produce all the dumps listed above. |
| .TP |
| .B \-dm |
| Print statistics on memory usage, at the end of the run, to |
| standard error. |
| .TP |
| .B \-dp |
| Annotate the assembler output with a comment indicating which |
| pattern and alternative was used. |
| .TP |
| .B \-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. |
| .TP |
| .B \-save\-temps |
| Store the usual \*(lqtemporary\*(rq intermediate files permanently; place them |
| in the current directory and name them based on the source file. Thus, |
| compiling `\|\c |
| .B foo.c\c |
| \&\|' with `\|\c |
| .B \-c \-save\-temps\c |
| \&\|' would produce files |
| `\|\c |
| .B foo.cpp\c |
| \&\|' and `\|\c |
| .B foo.s\c |
| \&\|', as well as `\|\c |
| .B foo.o\c |
| \&\|'. |
| .TP |
| .BI "\-print\-file\-name=" "library" |
| Print the full absolute name of the library file \|\c |
| .nh |
| .I library |
| .hy |
| \&\| that |
| would be used when linking\(em\&and do not do anything else. With this |
| option, GNU CC does not compile or link anything; it just prints the |
| file name. |
| .TP |
| .B \-print\-libgcc\-file\-name |
| Same as `\|\c |
| .B \-print\-file\-name=libgcc.a\c |
| \&\|'. |
| .TP |
| .BI "\-print\-prog\-name=" "program" |
| Like `\|\c |
| .B \-print\-file\-name\c |
| \&\|', but searches for a program such as `\|\c |
| cpp\c |
| \&\|'. |
| .SH OPTIMIZATION OPTIONS |
| These options control various sorts of optimizations: |
| .TP |
| .B \-O |
| .TP |
| .B \-O1 |
| Optimize. Optimizing compilation takes somewhat more time, and a lot |
| more memory for a large function. |
| .Sp |
| Without `\|\c |
| .B \-O\c |
| \&\|', 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. |
| .Sp |
| Without `\|\c |
| .B \-O\c |
| \&\|', only variables declared \c |
| .B register\c |
| \& are |
| allocated in registers. The resulting compiled code is a little worse |
| than produced by PCC without `\|\c |
| .B \-O\c |
| \&\|'. |
| .Sp |
| With `\|\c |
| .B \-O\c |
| \&\|', the compiler tries to reduce code size and execution |
| time. |
| .Sp |
| When you specify `\|\c |
| .B \-O\c |
| \&\|', the two options `\|\c |
| .B \-fthread\-jumps\c |
| \&\|' and `\|\c |
| .B \-fdefer\-pop\c |
| \&\|' are turned on. On machines that have delay slots, the `\|\c |
| .B \-fdelayed\-branch\c |
| \&\|' option is turned on. For those machines that can support debugging even |
| without a frame pointer, the `\|\c |
| .B \-fomit\-frame\-pointer\c |
| \&\|' option is turned on. On some machines other flags may also be turned on. |
| .TP |
| .B \-O2 |
| Optimize even more. Nearly all supported optimizations that do not |
| involve a space-speed tradeoff are performed. Loop unrolling and function |
| inlining are not done, for example. As compared to |
| .B \-O\c |
| \&, |
| this option increases both compilation time and the performance of the |
| generated code. |
| .TP |
| .B \-O3 |
| Optimize yet more. This turns on everything |
| .B \-O2 |
| does, along with also turning on |
| .B \-finline\-functions. |
| .TP |
| .B \-O0 |
| Do not optimize. |
| .Sp |
| If you use multiple |
| .B \-O |
| options, with or without level numbers, the last such option is the |
| one that is effective. |
| .PP |
| Options of the form `\|\c |
| .B \-f\c |
| .I flag\c |
| \&\c |
| \&\|' specify machine-independent |
| flags. Most flags have both positive and negative forms; the negative |
| form of `\|\c |
| .B \-ffoo\c |
| \&\|' would be `\|\c |
| .B \-fno\-foo\c |
| \&\|'. The following list shows |
| only one form\(em\&the one which is not the default. |
| You can figure out the other form by either removing `\|\c |
| .B no\-\c |
| \&\|' or |
| adding it. |
| .TP |
| .B \-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 \c |
| .B double\c |
| \& is supposed to have. |
| .Sp |
| For most programs, the excess precision does only good, but a few |
| programs rely on the precise definition of IEEE floating point. |
| Use `\|\c |
| .B \-ffloat\-store\c |
| \&\|' for such programs. |
| .TP |
| .B \-fmemoize\-lookups |
| .TP |
| .B \-fsave\-memoized |
| Use heuristics to compile faster (C++ only). These heuristics are not |
| enabled by default, since they are only effective for certain input |
| files. Other input files compile more slowly. |
| .Sp |
| The first time the compiler must build a call to a member function (or |
| reference to a data member), it must (1) determine whether the class |
| implements member functions of that name; (2) resolve which member |
| function to call (which involves figuring out what sorts of type |
| conversions need to be made); and (3) check the visibility of the member |
| function to the caller. All of this adds up to slower compilation. |
| Normally, the second time a call is made to that member function (or |
| reference to that data member), it must go through the same lengthy |
| process again. This means that code like this |
| .Sp |
| \& cout << "This " << p << " has " << n << " legs.\en"; |
| .Sp |
| makes six passes through all three steps. By using a software cache, |
| a \*(lqhit\*(rq significantly reduces this cost. Unfortunately, using the |
| cache introduces another layer of mechanisms which must be implemented, |
| and so incurs its own overhead. `\|\c |
| .B \-fmemoize\-lookups\c |
| \&\|' enables |
| the software cache. |
| .Sp |
| Because access privileges (visibility) to members and member functions |
| may differ from one function context to the next, |
| .B g++ |
| may need to flush the cache. With the `\|\c |
| .B \-fmemoize\-lookups\c |
| \&\|' flag, the cache is flushed after every |
| function that is compiled. The `\|\c |
| \-fsave\-memoized\c |
| \&\|' flag enables the same software cache, but when the compiler |
| determines that the context of the last function compiled would yield |
| the same access privileges of the next function to compile, it |
| preserves the cache. |
| This is most helpful when defining many member functions for the same |
| class: with the exception of member functions which are friends of |
| other classes, each member function has exactly the same access |
| privileges as every other, and the cache need not be flushed. |
| .TP |
| .B \-fno\-default\-inline |
| Don't make member functions inline by default merely because they are |
| defined inside the class scope (C++ only). |
| .TP |
| .B \-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. |
| .TP |
| .B \-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. |
| .TP |
| .B \-fforce\-addr |
| Force memory address constants to be copied into registers before |
| doing arithmetic on them. This may produce better code just as |
| `\|\c |
| .B \-fforce\-mem\c |
| \&\|' may. I am interested in hearing about the |
| difference this makes. |
| .TP |
| .B \-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. \c |
| .I It also makes debugging impossible on most machines\c |
| \&. |
| .Sp |
| 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 \c |
| .B FRAME_POINTER_REQUIRED\c |
| \& controls |
| whether a target machine supports this flag. |
| .TP |
| .B \-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. |
| .Sp |
| If all calls to a given function are integrated, and the function is |
| declared \c |
| .B static\c |
| \&, then GCC normally does not output the function as |
| assembler code in its own right. |
| .TP |
| .B \-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. |
| .Sp |
| This option is enabled by default on certain machines, usually those |
| which have no call-preserved registers to use instead. |
| .TP |
| .B \-fkeep\-inline\-functions |
| Even if all calls to a given function are integrated, and the function |
| is declared \c |
| .B static\c |
| \&, nevertheless output a separate run-time |
| callable version of the function. |
| .TP |
| .B \-fno\-function\-cse |
| Do not put function addresses in registers; make each instruction that |
| calls a constant function contain the function's address explicitly. |
| .Sp |
| 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. |
| .TP |
| .B \-fno\-peephole |
| Disable any machine-specific peephole optimizations. |
| .TP |
| .B \-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 \c |
| .B sqrt\c |
| \& function are |
| non-negative numbers. |
| .Sp |
| This option should never be turned on by any `\|\c |
| .B \-O\c |
| \&\|' 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. |
| .PP |
| The following options control specific optimizations. The `\|\c |
| .B \-O2\c |
| \&\|' |
| option turns on all of these optimizations except `\|\c |
| .B \-funroll\-loops\c |
| \&\|' |
| and `\|\c |
| .B \-funroll\-all\-loops\c |
| \&\|'. |
| .PP |
| The `\|\c |
| .B \-O\c |
| \&\|' option usually turns on |
| the `\|\c |
| .B \-fthread\-jumps\c |
| \&\|' and `\|\c |
| .B \-fdelayed\-branch\c |
| \&\|' options, but |
| specific machines may change the default optimizations. |
| .PP |
| You can use the following flags in the rare cases when \*(lqfine-tuning\*(rq |
| of optimizations to be performed is desired. |
| .TP |
| .B \-fstrength\-reduce |
| Perform the optimizations of loop strength reduction and |
| elimination of iteration variables. |
| .TP |
| .B \-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. |
| .TP |
| .B \-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. |
| .TP |
| .B \-funroll\-all\-loops |
| Perform the optimization of loop unrolling. This is done for all loops. |
| This usually makes programs run more slowly. |
| .TP |
| .B \-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 \c |
| .B if\c |
| \& statement with an |
| .B else\c |
| \& clause, CSE will follow the jump when the condition |
| tested is false. |
| .TP |
| .B \-fcse\-skip\-blocks |
| This is similar to `\|\c |
| .B \-fcse\-follow\-jumps\c |
| \&\|', but causes CSE to |
| follow jumps which conditionally skip over blocks. When CSE |
| encounters a simple \c |
| .B if\c |
| \& statement with no else clause, |
| `\|\c |
| .B \-fcse\-skip\-blocks\c |
| \&\|' causes CSE to follow the jump around the |
| body of the \c |
| .B if\c |
| \&. |
| .TP |
| .B \-frerun\-cse\-after\-loop |
| Re-run common subexpression elimination after loop optimizations has been |
| performed. |
| .TP |
| .B \-felide\-constructors |
| Elide constructors when this seems plausible (C++ only). With this |
| flag, GNU C++ initializes \c |
| .B y\c |
| \& directly from the call to \c |
| .B foo |
| without going through a temporary in the following code: |
| .Sp |
| A foo (); |
| A y = foo (); |
| .Sp |
| Without this option, GNU C++ first initializes \c |
| .B y\c |
| \& by calling the |
| appropriate constructor for type \c |
| .B A\c |
| \&; then assigns the result of |
| .B foo\c |
| \& to a temporary; and, finally, replaces the initial value of |
| `\|\c |
| .B y\c |
| \&\|' with the temporary. |
| .Sp |
| The default behavior (`\|\c |
| .B \-fno\-elide\-constructors\c |
| \&\|') is specified by |
| the draft ANSI C++ standard. If your program's constructors have side |
| effects, using `\|\c |
| .B \-felide-constructors\c |
| \&\|' can make your program act |
| differently, since some constructor calls may be omitted. |
| .TP |
| .B \-fexpensive\-optimizations |
| Perform a number of minor optimizations that are relatively expensive. |
| .TP |
| .B \-fdelayed\-branch |
| If supported for the target machine, attempt to reorder instructions |
| to exploit instruction slots available after delayed branch |
| instructions. |
| .TP |
| .B \-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. |
| .TP |
| .B \-fschedule\-insns2 |
| Similar to `\|\c |
| .B \-fschedule\-insns\c |
| \&\|', 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. |
| .SH TARGET OPTIONS |
| 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 |
| `\|\c |
| .B \-b\c |
| \&\|' option. |
| .PP |
| 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. |
| .TP |
| .BI "\-b " "machine" |
| The argument \c |
| .I machine\c |
| \& specifies the target machine for compilation. |
| This is useful when you have installed GNU CC as a cross-compiler. |
| .Sp |
| The value to use for \c |
| .I machine\c |
| \& 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 `\|\c |
| .B configure |
| i386v\c |
| \&\|', meaning to compile for an 80386 running System V, then you |
| would specify `\|\c |
| .B \-b i386v\c |
| \&\|' to run that cross compiler. |
| .Sp |
| When you do not specify `\|\c |
| .B \-b\c |
| \&\|', it normally means to compile for |
| the same type of machine that you are using. |
| .TP |
| .BI "\-V " "version" |
| The argument \c |
| .I version\c |
| \& specifies which version of GNU CC to run. |
| This is useful when multiple versions are installed. For example, |
| .I version\c |
| \& might be `\|\c |
| .B 2.0\c |
| \&\|', meaning to run GNU CC version 2.0. |
| .Sp |
| The default version, when you do not specify `\|\c |
| .B \-V\c |
| \&\|', is controlled |
| by the way GNU CC is installed. Normally, it will be a version that |
| is recommended for general use. |
| .SH MACHINE DEPENDENT OPTIONS |
| Each of the target machine types can have its own special options, |
| starting with `\|\c |
| .B \-m\c |
| \&\|', to choose among various hardware models or |
| configurations\(em\&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. |
| .PP |
| Some configurations of the compiler also support additional special |
| options, usually for command-line compatibility with other compilers on |
| the same platform. |
| .PP |
| These are the `\|\c |
| .B \-m\c |
| \&\|' options defined for the 68000 series: |
| .TP |
| .B \-m68000 |
| .TP |
| .B \-mc68000 |
| Generate output for a 68000. This is the default when the compiler is |
| configured for 68000-based systems. |
| .TP |
| .B \-m68020 |
| .TP |
| .B \-mc68020 |
| Generate output for a 68020 (rather than a 68000). This is the |
| default when the compiler is configured for 68020-based systems. |
| .TP |
| .B \-m68881 |
| Generate output containing 68881 instructions for floating point. |
| This is the default for most 68020-based systems unless |
| .B \-nfp |
| was specified when the compiler was configured. |
| .TP |
| .B \-m68030 |
| Generate output for a 68030. This is the default when the compiler is |
| configured for 68030-based systems. |
| .TP |
| .B \-m68040 |
| Generate output for a 68040. This is the default when the compiler is |
| configured for 68040-based systems. |
| .TP |
| .B \-m68020\-40 |
| Generate output for a 68040, without using any of the new instructions. |
| This results in code which can run relatively efficiently on either a |
| 68020/68881 or a 68030 or a 68040. |
| .TP |
| .B \-mfpa |
| Generate output containing Sun FPA instructions for floating point. |
| .TP |
| .B \-msoft\-float |
| Generate output containing library calls for floating point. |
| .I |
| 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. |
| .TP |
| .B \-mshort |
| Consider type \c |
| .B int\c |
| \& to be 16 bits wide, like \c |
| .B short int\c |
| \&. |
| .TP |
| .B \-mnobitfield |
| Do not use the bit-field instructions. `\|\c |
| .B \-m68000\c |
| \&\|' implies |
| `\|\c |
| .B \-mnobitfield\c |
| \&\|'. |
| .TP |
| .B \-mbitfield |
| Do use the bit-field instructions. `\|\c |
| .B \-m68020\c |
| \&\|' implies |
| `\|\c |
| .B \-mbitfield\c |
| \&\|'. This is the default if you use the unmodified |
| sources. |
| .TP |
| .B \-mrtd |
| Use a different function-calling convention, in which functions |
| that take a fixed number of arguments return with the \c |
| .B 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. |
| .Sp |
| 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. |
| .Sp |
| Also, you must provide function prototypes for all functions that |
| take variable numbers of arguments (including \c |
| .B printf\c |
| \&); |
| otherwise incorrect code will be generated for calls to those |
| functions. |
| .Sp |
| In addition, seriously incorrect code will result if you call a |
| function with too many arguments. (Normally, extra arguments are |
| harmlessly ignored.) |
| .Sp |
| The \c |
| .B rtd\c |
| \& instruction is supported by the 68010 and 68020 |
| processors, but not by the 68000. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the Vax: |
| .TP |
| .B \-munix |
| Do not output certain jump instructions (\c |
| .B aobleq\c |
| \& and so on) |
| that the Unix assembler for the Vax cannot handle across long |
| ranges. |
| .TP |
| .B \-mgnu |
| Do output those jump instructions, on the assumption that you |
| will assemble with the GNU assembler. |
| .TP |
| .B \-mg |
| Output code for g-format floating point numbers instead of d-format. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' switches are supported on the SPARC: |
| .PP |
| .B \-mfpu |
| .TP |
| .B \-mhard\-float |
| Generate output containing floating point instructions. This is the |
| default. |
| .PP |
| .B \-mno\-fpu |
| .TP |
| .B \-msoft\-float |
| Generate output containing library calls for floating point. |
| .I Warning: |
| there is no GNU floating-point library for SPARC. |
| Normally the facilities of the machine's usual C compiler are used, but |
| this cannot be done directly in cross-compilation. You must make your |
| own arrangements to provide suitable library functions for |
| cross-compilation. |
| .Sp |
| .B \-msoft\-float |
| changes the calling convention in the output file; |
| therefore, it is only useful if you compile |
| .I all |
| of a program with this option. |
| .PP |
| .B \-mno\-epilogue |
| .TP |
| .B \-mepilogue |
| With |
| .B \-mepilogue |
| (the default), the compiler always emits code for |
| function exit at the end of each function. Any function exit in |
| the middle of the function (such as a return statement in C) will |
| generate a jump to the exit code at the end of the function. |
| .Sp |
| With |
| .BR \-mno\-epilogue , |
| the compiler tries to emit exit code inline at every function exit. |
| .PP |
| .B \-mno\-v8 |
| .TP |
| .B \-mv8 |
| .TP |
| .B \-msparclite |
| These three options select variations on the SPARC architecture. |
| .Sp |
| By default (unless specifically configured for the Fujitsu SPARClite), |
| GCC generates code for the v7 variant of the SPARC architecture. |
| .Sp |
| .B \-mv8 |
| will give you SPARC v8 code. The only difference from v7 |
| code is that the compiler emits the integer multiply and integer |
| divide instructions which exist in SPARC v8 but not in SPARC v7. |
| .Sp |
| .B \-msparclite |
| will give you SPARClite code. This adds the integer |
| multiply, integer divide step and scan (ffs) instructions which |
| exist in SPARClite but not in SPARC v7. |
| .PP |
| .B \-mcypress |
| .TP |
| .B \-msupersparc |
| These two options select the processor for which the code is optimised. |
| .Sp |
| With |
| .B \-mcypress |
| (the default), the compiler optimises code for the Cypress CY7C602 chip, as |
| used in the SparcStation/SparcServer 3xx series. This is also appropriate for |
| the older SparcStation 1, 2, IPX etc. |
| .Sp |
| With |
| .B \-msupersparc |
| the compiler optimises code for the SuperSparc cpu, as used in the SparcStation |
| 10, 1000 and 2000 series. This flag also enables use of the full SPARC v8 |
| instruction set. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the Convex: |
| .TP |
| .B \-mc1 |
| Generate output for a C1. This is the default when the compiler is |
| configured for a C1. |
| .TP |
| .B \-mc2 |
| Generate output for a C2. This is the default when the compiler is |
| configured for a C2. |
| .TP |
| .B \-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.) |
| .TP |
| .B \-mnoargcount |
| Omit the argument count word. This is the default if you use the |
| unmodified sources. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the AMD Am29000: |
| .TP |
| .B \-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. |
| .TP |
| .B \-mnodw |
| Generate code that assumes the DW bit is not set. |
| .TP |
| .B \-mbw |
| Generate code that assumes the system supports byte and halfword write |
| operations. This is the default. |
| .TP |
| .B \-mnbw |
| Generate code that assumes the systems does not support byte and |
| halfword write operations. This implies `\|\c |
| .B \-mnodw\c |
| \&\|'. |
| .TP |
| .B \-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 \c |
| .B call\c |
| \& instruction to be used instead |
| of a \c |
| .B const\c |
| \&, \c |
| .B consth\c |
| \&, \c |
| .B calli\c |
| \& sequence. |
| .TP |
| .B \-mlarge |
| Do not assume that the \c |
| .B call\c |
| \& instruction can be used; this is the |
| default. |
| .TP |
| .B \-m29050 |
| Generate code for the Am29050. |
| .TP |
| .B \-m29000 |
| Generate code for the Am29000. This is the default. |
| .TP |
| .B \-mkernel\-registers |
| Generate references to registers \c |
| .B gr64-gr95\c |
| \& instead of |
| .B gr96-gr127\c |
| \&. This option can be used when compiling kernel code |
| that wants a set of global registers disjoint from that used by |
| user-mode code. |
| .Sp |
| Note that when this option is used, register names in `\|\c |
| .B \-f\c |
| \&\|' flags |
| must use the normal, user-mode, names. |
| .TP |
| .B \-muser\-registers |
| Use the normal set of global registers, \c |
| .B gr96-gr127\c |
| \&. This is the |
| default. |
| .TP |
| .B \-mstack\-check |
| Insert a call to \c |
| .B _\|_msp_check\c |
| \& after each stack adjustment. This |
| is often used for kernel code. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for Motorola 88K architectures: |
| .TP |
| .B \-m88000 |
| Generate code that works well on both the m88100 and the |
| m88110. |
| .TP |
| .B \-m88100 |
| Generate code that works best for the m88100, but that also |
| runs on the m88110. |
| .TP |
| .B \-m88110 |
| Generate code that works best for the m88110, and may not run |
| on the m88100. |
| .TP |
| .B \-midentify\-revision |
| Include an \c |
| .B ident\c |
| \& directive in the assembler output recording the |
| source file name, compiler name and version, timestamp, and compilation |
| flags used. |
| .TP |
| .B \-mno\-underscores |
| In assembler output, emit symbol names without adding an underscore |
| character at the beginning of each name. The default is to use an |
| underscore as prefix on each name. |
| .TP |
| .B \-mno\-check\-zero\-division |
| .TP |
| .B \-mcheck\-zero\-division |
| Early models of the 88K architecture had problems with division by zero; |
| in particular, many of them didn't trap. Use these options to avoid |
| including (or to include explicitly) additional code to detect division |
| by zero and signal an exception. All GCC configurations for the 88K use |
| `\|\c |
| .B \-mcheck\-zero\-division\c |
| \&\|' by default. |
| .TP |
| .B \-mocs\-debug\-info |
| .TP |
| .B \-mno\-ocs\-debug\-info |
| Include (or omit) additional debugging information (about |
| registers used in each stack frame) as specified in the 88Open Object |
| Compatibility Standard, \*(lqOCS\*(rq. This extra information is not needed |
| by GDB. The default for DG/UX, SVr4, and Delta 88 SVr3.2 is to |
| include this information; other 88k configurations omit this information |
| by default. |
| .TP |
| .B \-mocs\-frame\-position |
| .TP |
| .B \-mno\-ocs\-frame\-position |
| Force (or do not require) register values to be stored in a particular |
| place in stack frames, as specified in OCS. The DG/UX, Delta88 SVr3.2, |
| and BCS configurations use `\|\c |
| .B \-mocs\-frame\-position\c |
| \&\|'; other 88k |
| configurations have the default `\|\c |
| .B \-mno\-ocs\-frame\-position\c |
| \&\|'. |
| .TP |
| .B \-moptimize\-arg\-area |
| .TP |
| .B \-mno\-optimize\-arg\-area |
| Control how to store function arguments in stack frames. |
| `\|\c |
| .B \-moptimize\-arg\-area\c |
| \&\|' saves space, but may break some |
| debuggers (not GDB). `\|\c |
| .B \-mno\-optimize\-arg\-area\c |
| \&\|' conforms better to |
| standards. By default GCC does not optimize the argument area. |
| .TP |
| .BI "\-mshort\-data\-" "num" |
| .I num |
| Generate smaller data references by making them relative to \c |
| .B r0\c |
| \&, |
| which allows loading a value using a single instruction (rather than the |
| usual two). You control which data references are affected by |
| specifying \c |
| .I num\c |
| \& with this option. For example, if you specify |
| `\|\c |
| .B \-mshort\-data\-512\c |
| \&\|', then the data references affected are those |
| involving displacements of less than 512 bytes. |
| `\|\c |
| .B \-mshort\-data\-\c |
| .I num\c |
| \&\c |
| \&\|' is not effective for \c |
| .I num\c |
| \& greater |
| than 64K. |
| .PP |
| .B \-mserialize-volatile |
| .TP |
| .B \-mno-serialize-volatile |
| Do, or do not, generate code to guarantee sequential consistency of |
| volatile memory references. |
| .Sp |
| GNU CC always guarantees consistency by default, for the preferred |
| processor submodel. How this is done depends on the submodel. |
| .Sp |
| The m88100 processor does not reorder memory references and so always |
| provides sequential consistency. If you use `\|\c |
| .B \-m88100\c |
| \&\|', GNU CC does |
| not generate any special instructions for sequential consistency. |
| .Sp |
| The order of memory references made by the m88110 processor does not |
| always match the order of the instructions requesting those references. |
| In particular, a load instruction may execute before a preceding store |
| instruction. Such reordering violates sequential consistency of |
| volatile memory references, when there are multiple processors. When |
| you use `\|\c |
| .B \-m88000\c |
| \&\|' or `\|\c |
| .B \-m88110\c |
| \&\|', GNU CC generates special |
| instructions when appropriate, to force execution in the proper order. |
| .Sp |
| The extra code generated to guarantee consistency may affect the |
| performance of your application. If you know that you can safely forgo |
| this guarantee, you may use the option `\|\c |
| .B \-mno-serialize-volatile\c |
| \&\|'. |
| .Sp |
| If you use the `\|\c |
| .B \-m88100\c |
| \&\|' option but require sequential consistency |
| when running on the m88110 processor, you should use |
| `\|\c |
| .B \-mserialize-volatile\c |
| \&\|'. |
| .PP |
| .B \-msvr4 |
| .TP |
| .B \-msvr3 |
| Turn on (`\|\c |
| .B \-msvr4\c |
| \&\|') or off (`\|\c |
| .B \-msvr3\c |
| \&\|') compiler extensions |
| related to System V release 4 (SVr4). This controls the following: |
| .TP |
| \ \ \ \(bu |
| Which variant of the assembler syntax to emit (which you can select |
| independently using `\|\c |
| .B \-mversion\-03.00\c |
| \&\|'). |
| .TP |
| \ \ \ \(bu |
| `\|\c |
| .B \-msvr4\c |
| \&\|' makes the C preprocessor recognize `\|\c |
| .B #pragma weak\c |
| \&\|' |
| .TP |
| \ \ \ \(bu |
| `\|\c |
| .B \-msvr4\c |
| \&\|' makes GCC issue additional declaration directives used in |
| SVr4. |
| .PP |
| `\|\c |
| .B \-msvr3\c |
| \&\|' is the default for all m88K configurations except |
| the SVr4 configuration. |
| .TP |
| .B \-mtrap\-large\-shift |
| .TP |
| .B \-mhandle\-large\-shift |
| Include code to detect bit-shifts of more than 31 bits; respectively, |
| trap such shifts or emit code to handle them properly. By default GCC |
| makes no special provision for large bit shifts. |
| .TP |
| .B \-muse\-div\-instruction |
| Very early models of the 88K architecture didn't have a divide |
| instruction, so GCC avoids that instruction by default. Use this option |
| to specify that it's safe to use the divide instruction. |
| .TP |
| .B \-mversion\-03.00 |
| In the DG/UX configuration, there are two flavors of SVr4. This option |
| modifies |
| .B \-msvr4 |
| to select whether the hybrid-COFF or real-ELF |
| flavor is used. All other configurations ignore this option. |
| .TP |
| .B \-mwarn\-passed\-structs |
| Warn when a function passes a struct as an argument or result. |
| Structure-passing conventions have changed during the evolution of the C |
| language, and are often the source of portability problems. By default, |
| GCC issues no such warning. |
| .PP |
| These options are defined for the IBM RS6000: |
| .PP |
| .B \-mfp\-in\-toc |
| .TP |
| .B \-mno\-fp\-in\-toc |
| Control whether or not floating-point constants go in the Table of |
| Contents (TOC), a table of all global variable and function addresses. By |
| default GCC puts floating-point constants there; if the TOC overflows, |
| `\|\c |
| .B \-mno\-fp\-in\-toc\c |
| \&\|' will reduce the size of the TOC, which may avoid |
| the overflow. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the IBM RT PC: |
| .TP |
| .B \-min\-line\-mul |
| Use an in-line code sequence for integer multiplies. This is the |
| default. |
| .TP |
| .B \-mcall\-lib\-mul |
| Call \c |
| .B lmul$$\c |
| \& for integer multiples. |
| .TP |
| .B \-mfull\-fp\-blocks |
| Generate full-size floating point data blocks, including the minimum |
| amount of scratch space recommended by IBM. This is the default. |
| .TP |
| .B \-mminimum\-fp\-blocks |
| Do not include extra scratch space in floating point data blocks. This |
| results in smaller code, but slower execution, since scratch space must |
| be allocated dynamically. |
| .TP |
| .B \-mfp\-arg\-in\-fpregs |
| Use a calling sequence incompatible with the IBM calling convention in |
| which floating point arguments are passed in floating point registers. |
| Note that \c |
| .B varargs.h\c |
| \& and \c |
| .B stdargs.h\c |
| \& will not work with |
| floating point operands if this option is specified. |
| .TP |
| .B \-mfp\-arg\-in\-gregs |
| Use the normal calling convention for floating point arguments. This is |
| the default. |
| .TP |
| .B \-mhc\-struct\-return |
| Return structures of more than one word in memory, rather than in a |
| register. This provides compatibility with the MetaWare HighC (hc) |
| compiler. Use `\|\c |
| .B \-fpcc\-struct\-return\c |
| \&\|' for compatibility with the |
| Portable C Compiler (pcc). |
| .TP |
| .B \-mnohc\-struct\-return |
| Return some structures of more than one word in registers, when |
| convenient. This is the default. For compatibility with the |
| IBM-supplied compilers, use either `\|\c |
| .B \-fpcc\-struct\-return\c |
| \&\|' or |
| `\|\c |
| .B \-mhc\-struct\-return\c |
| \&\|'. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the MIPS family of computers: |
| .TP |
| .BI "\-mcpu=" "cpu-type" |
| Assume the defaults for the machine type |
| .I cpu-type |
| when |
| scheduling instructions. The default |
| .I cpu-type |
| is |
| .BR default , |
| which picks the longest cycles times for any of the machines, in order |
| that the code run at reasonable rates on all MIPS cpu's. Other |
| choices for |
| .I cpu-type |
| are |
| .BR r2000 , |
| .BR r3000 , |
| .BR r4000 , |
| and |
| .BR r6000 . |
| While picking a specific |
| .I cpu-type |
| will schedule things appropriately for that particular chip, the |
| compiler will not generate any code that does not meet level 1 of the |
| MIPS ISA (instruction set architecture) without the |
| .B \-mips2 |
| or |
| .B \-mips3 |
| switches being used. |
| .TP |
| .B \-mips2 |
| Issue instructions from level 2 of the MIPS ISA (branch likely, square |
| root instructions). The |
| .B \-mcpu=r4000 |
| or |
| .B \-mcpu=r6000 |
| switch must be used in conjunction with |
| .BR \-mips2 . |
| .TP |
| .B \-mips3 |
| Issue instructions from level 3 of the MIPS ISA (64 bit instructions). |
| The |
| .B \-mcpu=r4000 |
| switch must be used in conjunction with |
| .BR \-mips2 . |
| .TP |
| .B \-mint64 |
| .TP |
| .B \-mlong64 |
| .TP |
| .B \-mlonglong128 |
| These options don't work at present. |
| .TP |
| .B \-mmips\-as |
| Generate code for the MIPS assembler, and invoke |
| .B mips\-tfile |
| to add normal debug information. This is the default for all |
| platforms except for the OSF/1 reference platform, using the OSF/rose |
| object format. If any of the |
| .BR \-ggdb , |
| .BR \-gstabs , |
| or |
| .B \-gstabs+ |
| switches are used, the |
| .B mips\-tfile |
| program will encapsulate the stabs within MIPS ECOFF. |
| .TP |
| .B \-mgas |
| Generate code for the GNU assembler. This is the default on the OSF/1 |
| reference platform, using the OSF/rose object format. |
| .TP |
| .B \-mrnames |
| .TP |
| .B \-mno\-rnames |
| The |
| .B \-mrnames |
| switch says to output code using the MIPS software names for the |
| registers, instead of the hardware names (ie, |
| .B a0 |
| instead of |
| .BR $4 ). |
| The GNU assembler does not support the |
| .B \-mrnames |
| switch, and the MIPS assembler will be instructed to run the MIPS C |
| preprocessor over the source file. The |
| .B \-mno\-rnames |
| switch is default. |
| .TP |
| .B \-mgpopt |
| .TP |
| .B \-mno\-gpopt |
| The |
| .B \-mgpopt |
| switch says to write all of the data declarations before the |
| instructions in the text section, to all the MIPS assembler to |
| generate one word memory references instead of using two words for |
| short global or static data items. This is on by default if |
| optimization is selected. |
| .TP |
| .B \-mstats |
| .TP |
| .B \-mno\-stats |
| For each non-inline function processed, the |
| .B \-mstats |
| switch causes the compiler to emit one line to the standard error file |
| to print statistics about the program (number of registers saved, |
| stack size, etc.). |
| .TP |
| .B \-mmemcpy |
| .TP |
| .B \-mno\-memcpy |
| The |
| .B \-mmemcpy |
| switch makes all block moves call the appropriate string function |
| .RB ( memcpy |
| or |
| .BR bcopy ) |
| instead of possibly generating inline code. |
| .TP |
| .B \-mmips\-tfile |
| .TP |
| .B \-mno\-mips\-tfile |
| The |
| .B \-mno\-mips\-tfile |
| switch causes the compiler not postprocess the object file with the |
| .B mips\-tfile |
| program, after the MIPS assembler has generated it to add debug |
| support. If |
| .B mips\-tfile |
| is not run, then no local variables will be available to the debugger. |
| In addition, |
| .B stage2 |
| and |
| .B stage3 |
| objects will have the temporary file names passed to the assembler |
| embedded in the object file, which means the objects will not compare |
| the same. |
| .TP |
| .B \-msoft\-float |
| Generate output containing library calls for floating point. |
| .I |
| 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. |
| .TP |
| .B \-mhard\-float |
| Generate output containing floating point instructions. This is the |
| default if you use the unmodified sources. |
| .TP |
| .B \-mfp64 |
| Assume that the |
| .B FR |
| bit in the status word is on, and that there are 32 64-bit floating |
| point registers, instead of 32 32-bit floating point registers. You |
| must also specify the |
| .B \-mcpu=r4000 |
| and |
| .B \-mips3 |
| switches. |
| .TP |
| .B \-mfp32 |
| Assume that there are 32 32-bit floating point registers. This is the |
| default. |
| .PP |
| .B \-mabicalls |
| .TP |
| .B \-mno\-abicalls |
| Emit (or do not emit) the |
| .BR \&.abicalls , |
| .BR \&.cpload , |
| and |
| .B \&.cprestore |
| pseudo operations that some System V.4 ports use for position |
| independent code. |
| .TP |
| .B \-mhalf\-pic |
| .TP |
| .B \-mno\-half\-pic |
| The |
| .B \-mhalf\-pic |
| switch says to put pointers to extern references into the data section |
| and load them up, rather than put the references in the text section. |
| This option does not work at present. |
| .B |
| .BI \-G num |
| Put global and static items less than or equal to |
| .I num |
| bytes into the small data or bss sections instead of the normal data |
| or bss section. This allows the assembler to emit one word memory |
| reference instructions based on the global pointer |
| .RB ( gp |
| or |
| .BR $28 ), |
| instead of the normal two words used. By default, |
| .I num |
| is 8 when the MIPS assembler is used, and 0 when the GNU |
| assembler is used. The |
| .BI \-G num |
| switch is also passed to the assembler and linker. All modules should |
| be compiled with the same |
| .BI \-G num |
| value. |
| .TP |
| .B \-nocpp |
| Tell the MIPS assembler to not run it's preprocessor over user |
| assembler files (with a `\|\c |
| .B .s\c |
| \&\|' suffix) when assembling them. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the Intel 80386 family of computers: |
| .B \-m486 |
| .TP |
| .B \-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. |
| .TP |
| .B \-msoft\-float |
| Generate output containing library calls for floating point. |
| .I 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. |
| .Sp |
| On machines where a function returns floating point results in the 80387 |
| register stack, some floating point opcodes may be emitted even if |
| `\|\c |
| .B \-msoft-float\c |
| \&\|' is used. |
| .TP |
| .B \-mno-fp-ret-in-387 |
| Do not use the FPU registers for return values of functions. |
| .Sp |
| The usual calling convention has functions return values of types |
| .B float\c |
| \& and \c |
| .B double\c |
| \& in an FPU register, even if there |
| is no FPU. The idea is that the operating system should emulate |
| an FPU. |
| .Sp |
| The option `\|\c |
| .B \-mno-fp-ret-in-387\c |
| \&\|' causes such values to be returned |
| in ordinary CPU registers instead. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the HPPA family of computers: |
| .TP |
| .B \-mpa-risc-1-0 |
| Generate code for a PA 1.0 processor. |
| .TP |
| .B \-mpa-risc-1-1 |
| Generate code for a PA 1.1 processor. |
| .TP |
| .B \-mkernel |
| Generate code which is suitable for use in kernels. Specifically, avoid |
| .B add\c |
| \& instructions in which one of the arguments is the DP register; |
| generate \c |
| .B addil\c |
| \& instructions instead. This avoids a rather serious |
| bug in the HP-UX linker. |
| .TP |
| .B \-mshared-libs |
| Generate code that can be linked against HP-UX shared libraries. This option |
| is not fully function yet, and is not on by default for any PA target. Using |
| this option can cause incorrect code to be generated by the compiler. |
| .TP |
| .B \-mno-shared-libs |
| Don't generate code that will be linked against shared libraries. This is |
| the default for all PA targets. |
| .TP |
| .B \-mlong-calls |
| Generate code which allows calls to functions greater than 256K away from |
| the caller when the caller and callee are in the same source file. Do |
| not turn this option on unless code refuses to link with \*(lqbranch out of |
| range errors\*('' from the linker. |
| .TP |
| .B \-mdisable-fpregs |
| Prevent floating point registers from being used in any manner. This is |
| necessary for compiling kernels which perform lazy context switching of |
| floating point registers. If you use this option and attempt to perform |
| floating point operations, the compiler will abort. |
| .TP |
| .B \-mdisable-indexing |
| Prevent the compiler from using indexing address modes. This avoids some |
| rather obscure problems when compiling MIG generated code under MACH. |
| .TP |
| .B \-mtrailing-colon |
| Add a colon to the end of label definitions (for ELF assemblers). |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the Intel 80960 family of computers: |
| .TP |
| .BI "\-m" "cpu-type" |
| Assume the defaults for the machine type |
| .I cpu-type |
| for instruction and addressing-mode availability and alignment. |
| The default |
| .I cpu-type |
| is |
| .BR kb ; |
| other choices are |
| .BR ka , |
| .BR mc , |
| .BR ca , |
| .BR cf , |
| .BR sa , |
| and |
| .BR sb . |
| .TP |
| .B \-mnumerics |
| .TP |
| .B \-msoft\-float |
| The |
| .B \-mnumerics |
| option indicates that the processor does support |
| floating-point instructions. The |
| .B \-msoft\-float |
| option indicates |
| that floating-point support should not be assumed. |
| .TP |
| .B \-mleaf\-procedures |
| .TP |
| .B \-mno\-leaf\-procedures |
| Do (or do not) attempt to alter leaf procedures to be callable with the |
| .I bal |
| instruction as well as |
| .IR call . |
| This will result in more |
| efficient code for explicit calls when the |
| .I bal |
| instruction can be |
| substituted by the assembler or linker, but less efficient code in other |
| cases, such as calls via function pointers, or using a linker that doesn't |
| support this optimization. |
| .TP |
| .B \-mtail\-call |
| .TP |
| .B \-mno\-tail\-call |
| Do (or do not) make additional attempts (beyond those of the |
| machine-independent portions of the compiler) to optimize tail-recursive |
| calls into branches. You may not want to do this because the detection of |
| cases where this is not valid is not totally complete. The default is |
| .BR \-mno\-tail\-call . |
| .TP |
| .B \-mcomplex\-addr |
| .TP |
| .B \-mno\-complex\-addr |
| Assume (or do not assume) that the use of a complex addressing mode is a |
| win on this implementation of the i960. Complex addressing modes may not |
| be worthwhile on the K-series, but they definitely are on the C-series. |
| The default is currently |
| .B \-mcomplex\-addr |
| for all processors except |
| the CB and CC. |
| .TP |
| .B \-mcode\-align |
| .TP |
| .B \-mno\-code\-align |
| Align code to 8-byte boundaries for faster fetching (or don't bother). |
| Currently turned on by default for C-series implementations only. |
| .TP |
| .B \-mic\-compat |
| .TP |
| .B \-mic2.0\-compat |
| .TP |
| .B \-mic3.0\-compat |
| Enable compatibility with iC960 v2.0 or v3.0. |
| .TP |
| .B \-masm\-compat |
| .TP |
| .B \-mintel\-asm |
| Enable compatibility with the iC960 assembler. |
| .TP |
| .B \-mstrict\-align |
| .TP |
| .B \-mno\-strict\-align |
| Do not permit (do permit) unaligned accesses. |
| .TP |
| .B \-mold\-align |
| Enable structure-alignment compatibility with Intel's gcc release version |
| 1.3 (based on gcc 1.37). Currently this is buggy in that |
| .B #pragma align 1 |
| is always assumed as well, and cannot be turned off. |
| .PP |
| These `\|\c |
| .B \-m\c |
| \&\|' options are defined for the DEC Alpha implementations: |
| .TP |
| .B \-mno-soft-float |
| .TP |
| .B \-msoft-float |
| Use (do not use) the hardware floating-point instructions for |
| floating-point operations. When \c |
| .B \-msoft-float\c |
| \& is specified, |
| functions in `\|\c |
| .B libgcc1.c\c |
| \&\|' will be used to perform floating-point |
| operations. Unless they are replaced by routines that emulate the |
| floating-point operations, or compiled in such a way as to call such |
| emulations routines, these routines will issue floating-point |
| operations. If you are compiling for an Alpha without floating-point |
| operations, you must ensure that the library is built so as not to call |
| them. |
| .Sp |
| Note that Alpha implementations without floating-point operations are |
| required to have floating-point registers. |
| .TP |
| .B \-mfp-reg |
| .TP |
| .B \-mno-fp-regs |
| Generate code that uses (does not use) the floating-point register set. |
| .B \-mno-fp-regs\c |
| \& implies \c |
| .B \-msoft-float\c |
| \&. If the floating-point |
| register set is not used, floating point operands are passed in integer |
| registers as if they were integers and floating-point results are passed |
| in $0 instead of $f0. This is a non-standard calling sequence, so any |
| function with a floating-point argument or return value called by code |
| compiled with \c |
| .B \-mno-fp-regs\c |
| \& must also be compiled with that |
| option. |
| .Sp |
| A typical use of this option is building a kernel that does not use, |
| and hence need not save and restore, any floating-point registers. |
| .PP |
| These additional options are available on System V Release 4 for |
| compatibility with other compilers on those systems: |
| .TP |
| .B \-G |
| On SVr4 systems, \c |
| .B gcc\c |
| \& accepts the option `\|\c |
| .B \-G\c |
| \&\|' (and passes |
| it to the system linker), for compatibility with other compilers. |
| However, we suggest you use `\|\c |
| .B \-symbolic\c |
| \&\|' or `\|\c |
| .B \-shared\c |
| \&\|' as |
| appropriate, instead of supplying linker options on the \c |
| .B gcc |
| command line. |
| .TP |
| .B \-Qy |
| Identify the versions of each tool used by the compiler, in a |
| .B .ident\c |
| \& assembler directive in the output. |
| .TP |
| .B \-Qn |
| Refrain from adding \c |
| .B .ident\c |
| \& directives to the output file (this is |
| the default). |
| .TP |
| .BI "\-YP," "dirs" |
| Search the directories \c |
| .I dirs\c |
| \&, and no others, for libraries |
| specified with `\|\c |
| .B \-l\c |
| \&\|'. You can separate directory entries in |
| .I dirs\c |
| \& from one another with colons. |
| .TP |
| .BI "\-Ym," "dir" |
| Look in the directory \c |
| .I dir\c |
| \& to find the M4 preprocessor. |
| The assembler uses this option. |
| .SH CODE GENERATION OPTIONS |
| These machine-independent options control the interface conventions |
| used in code generation. |
| .PP |
| Most of them begin with `\|\c |
| \-f\c |
| \&\|'. These options have both positive and negative forms; the negative form |
| of `\|\c |
| .B \-ffoo\c |
| \&\|' would be `\|\c |
| .B \-fno\-foo\c |
| \&\|'. In the table below, only |
| one of the forms is listed\(em\&the one which is not the default. You |
| can figure out the other form by either removing `\|\c |
| .B no\-\c |
| \&\|' or adding |
| it. |
| .TP |
| .B \-fnonnull\-objects |
| Assume that objects reached through references are not null |
| (C++ only). |
| .Sp |
| Normally, GNU C++ makes conservative assumptions about objects reached |
| through references. For example, the compiler must check that \c |
| .B a |
| is not null in code like the following: |
| .Sp |
| obj &a = g (); |
| a.f (2); |
| .Sp |
| Checking that references of this sort have non-null values requires |
| extra code, however, and it is unnecessary for many programs. You can |
| use `\|\c |
| .B \-fnonnull-objects\c |
| \&\|' to omit the checks for null, if your |
| program doesn't require checking. |
| .TP |
| .B \-fpcc\-struct\-return |
| Use the same convention for returning \c |
| .B struct\c |
| \& and \c |
| .B 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 |
| allowing intercallability between GCC-compiled code and PCC-compiled |
| code. |
| .TP |
| .B \-freg\-struct\-return |
| Use the convention that |
| .B struct |
| and |
| .B union |
| values are returned in registers when possible. This is more |
| efficient for small structures than |
| .BR \-fpcc\-struct\-return . |
| .Sp |
| If you specify neither |
| .B \-fpcc\-struct\-return |
| nor |
| .BR \-freg\-struct\-return , |
| GNU CC defaults to whichever convention is standard for the target. |
| If there is no standard convention, GNU CC defaults to |
| .BR \-fpcc\-struct\-return . |
| .TP |
| .B \-fshort\-enums |
| Allocate to an \c |
| .B enum\c |
| \& type only as many bytes as it needs for the |
| declared range of possible values. Specifically, the \c |
| .B enum\c |
| \& type |
| will be equivalent to the smallest integer type which has enough room. |
| .TP |
| .B \-fshort\-double |
| Use the same size for |
| .B double |
| as for |
| .B float |
| \&. |
| .TP |
| .B \-fshared\-data |
| Requests that the data and non-\c |
| .B const\c |
| \& 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 between processes running the same program, while private data |
| exists in one copy per process. |
| .TP |
| .B \-fno\-common |
| Allocate even uninitialized global variables in the bss section of the |
| object file, rather than generating them as common blocks. This has the |
| effect that if the same variable is declared (without \c |
| .B extern\c |
| \&) 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. |
| .TP |
| .B \-fno\-ident |
| Ignore the `\|\c |
| .B #ident\c |
| \&\|' directive. |
| .TP |
| .B \-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 |
| .B collect2\c |
| \& program to make sure the system linker includes |
| constructors and destructors. (\c |
| .B collect2\c |
| \& is included in the GNU CC |
| distribution.) For systems which \c |
| .I must\c |
| \& use \c |
| .B collect2\c |
| \&, the |
| compiler driver \c |
| .B gcc\c |
| \& is configured to do this automatically. |
| .TP |
| .B \-finhibit-size-directive |
| Don't output a \c |
| .B .size\c |
| \& assembler directive, or anything 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 option is |
| used when compiling `\|\c |
| .B crtstuff.c\c |
| \&\|'; you should not need to use it |
| for anything else. |
| .TP |
| .B \-fverbose-asm |
| Put extra commentary information in the generated assembly code to |
| make it more readable. This option is generally only of use to those |
| who actually need to read the generated assembly code (perhaps while |
| debugging the compiler itself). |
| .TP |
| .B \-fvolatile |
| Consider all memory references through pointers to be volatile. |
| .TP |
| .B \-fvolatile\-global |
| Consider all memory references to extern and global data items to |
| be volatile. |
| .TP |
| .B \-fpic |
| If supported for the target machines, generate position-independent code, |
| suitable for use in a shared library. |
| .TP |
| .B \-fPIC |
| If supported for the target machine, emit position-independent code, |
| suitable for dynamic linking, even if branches need large displacements. |
| .TP |
| .BI "\-ffixed\-" "reg" |
| Treat the register named \c |
| .I reg\c |
| \& 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). |
| .Sp |
| .I reg\c |
| \& must be the name of a register. The register names accepted |
| are machine-specific and are defined in the \c |
| .B REGISTER_NAMES |
| macro in the machine description macro file. |
| .Sp |
| This flag does not have a negative form, because it specifies a |
| three-way choice. |
| .TP |
| .BI "\-fcall\-used\-" "reg" |
| Treat the register named \c |
| .I reg\c |
| \& as an allocatable register 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 \c |
| .I reg\c |
| \&. |
| .Sp |
| 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. |
| .Sp |
| This flag does not have a negative form, because it specifies a |
| three-way choice. |
| .TP |
| .BI "\-fcall\-saved\-" "reg" |
| Treat the register named \c |
| .I reg\c |
| \& as an allocatable register 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 \c |
| .I reg\c |
| \& if they use it. |
| .Sp |
| 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. |
| .Sp |
| A different sort of disaster will result from the use of this flag for |
| a register in which function values may be returned. |
| .Sp |
| This flag does not have a negative form, because it specifies a |
| three-way choice. |
| .SH PRAGMAS |
| Two `\|\c |
| .B #pragma\c |
| \&\|' directives are supported for GNU C++, to permit using the same |
| header file for two purposes: as a definition of interfaces to a given |
| object class, and as the full definition of the contents of that object class. |
| .TP |
| .B #pragma interface |
| (C++ only.) |
| Use this directive in header files that define object classes, to save |
| space in most of the object files that use those classes. Normally, |
| local copies of certain information (backup copies of inline member |
| functions, debugging information, and the internal tables that |
| implement virtual functions) must be kept in each object file that |
| includes class definitions. You can use this pragma to avoid such |
| duplication. When a header file containing `\|\c |
| .B #pragma interface\c |
| \&\|' is included in a compilation, this auxiliary information |
| will not be generated (unless the main input source file itself uses |
| `\|\c |
| .B #pragma implementation\c |
| \&\|'). Instead, the object files will contain references to be |
| resolved at link time. |
| .TP |
| .B #pragma implementation |
| .TP |
| \fB#pragma implementation "\fP\fIobjects\fP\fB.h"\fP |
| (C++ only.) |
| Use this pragma in a main input file, when you want full output from |
| included header files to be generated (and made globally visible). |
| The included header file, in turn, should use `\|\c |
| .B #pragma interface\c |
| \&\|'. |
| Backup copies of inline member functions, debugging information, and |
| the internal tables used to implement virtual functions are all |
| generated in implementation files. |
| .Sp |
| If you use `\|\c |
| .B #pragma implementation\c |
| \&\|' with no argument, it applies to an include file with the same |
| basename as your source file; for example, in `\|\c |
| .B allclass.cc\c |
| \&\|', `\|\c |
| .B #pragma implementation\c |
| \&\|' by itself is equivalent to `\|\c |
| .B |
| #pragma implementation "allclass.h"\c |
| \&\|'. Use the string argument if you want a single implementation |
| file to include code from multiple header files. |
| .Sp |
| There is no way to split up the contents of a single header file into |
| multiple implementation files. |
| .SH FILES |
| .nf |
| .ta \w'LIBDIR/g++\-include 'u |
| 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 |
| \fITMPDIR\fR/cc\(** temporary files |
| \fILIBDIR\fR/cpp preprocessor |
| \fILIBDIR\fR/cc1 compiler for C |
| \fILIBDIR\fR/cc1plus compiler for C++ |
| \fILIBDIR\fR/collect linker front end needed on some machines |
| \fILIBDIR\fR/libgcc.a GCC subroutine library |
| /lib/crt[01n].o start-up routine |
| \fILIBDIR\fR/ccrt0 additional start-up routine for C++ |
| /lib/libc.a standard C library, see |
| .IR intro (3) |
| /usr/include standard directory for \fB#include\fP files |
| \fILIBDIR\fR/include standard gcc directory for \fB#include\fP files |
| \fILIBDIR\fR/g++\-include additional g++ directory for \fB#include\fP |
| .Sp |
| .fi |
| .I LIBDIR |
| is usually |
| .B /usr/local/lib/\c |
| .IR machine / version . |
| .br |
| .I TMPDIR |
| comes from the environment variable |
| .B TMPDIR |
| (default |
| .B /usr/tmp |
| if available, else |
| .B /tmp\c |
| \&). |
| .SH "SEE ALSO" |
| cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1). |
| .br |
| .RB "`\|" gcc "\|', `\|" cpp \|', |
| .RB "`\|" as "\|', `\|" ld \|', |
| and |
| .RB `\| gdb \|' |
| entries in |
| .B info\c |
| \&. |
| .br |
| .I |
| Using and Porting GNU CC (for version 2.0)\c |
| , Richard M. Stallman; |
| .I |
| The C Preprocessor\c |
| , Richard M. Stallman; |
| .I |
| Debugging with GDB: the GNU Source-Level Debugger\c |
| , Richard M. Stallman and Roland H. Pesch; |
| .I |
| Using as: the GNU Assembler\c |
| , Dean Elsner, Jay Fenlason & friends; |
| .I |
| ld: the GNU linker\c |
| , Steve Chamberlain and Roland Pesch. |
| .SH BUGS |
| For instructions on reporting bugs, see the GCC manual. |
| .SH COPYING |
| Copyright |
| .if t \(co |
| 1991, 1992, 1993 Free Software Foundation, Inc. |
| .PP |
| 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. |
| .PP |
| Permission is granted to copy and distribute modified versions 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. |
| .PP |
| Permission is granted to copy and distribute translations of this |
| manual into another language, under the above conditions for modified |
| versions, except that this permission notice may be included in |
| translations approved by the Free Software Foundation instead of in |
| the original English. |
| .SH AUTHORS |
| See the GNU CC Manual for the contributors to GNU CC. |