![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-2 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to gcc.info-2 CVS log | Up to [GCC 2.x] / gcc |
1.1.1.9 ! root 1: This is Info file gcc.info, produced by Makeinfo version 1.67 from the ! 2: input file gcc.texi. 1.1 root 3: 4: This file documents the use and the internals of the GNU compiler. 5: 1.1.1.8 root 6: Published by the Free Software Foundation 59 Temple Place - Suite 330 7: Boston, MA 02111-1307 USA 1.1.1.5 root 8: 1.1.1.8 root 9: Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995 Free Software 10: Foundation, Inc. 1.1 root 11: 1.1.1.3 root 12: Permission is granted to make and distribute verbatim copies of this 13: manual provided the copyright notice and this permission notice are 14: preserved on all copies. 1.1 root 15: 16: Permission is granted to copy and distribute modified versions of 17: this manual under the conditions for verbatim copying, provided also 1.1.1.7 root 18: that the sections entitled "GNU General Public License," "Funding for 19: Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are 20: included exactly as in the original, and provided that the entire 21: resulting derived work is distributed under the terms of a permission 22: notice identical to this one. 1.1 root 23: 24: Permission is granted to copy and distribute translations of this 25: manual into another language, under the above conditions for modified 1.1.1.3 root 26: versions, except that the sections entitled "GNU General Public 1.1.1.7 root 27: License," "Funding for Free Software," and "Protect Your Freedom--Fight 28: `Look And Feel'", and this permission notice, may be included in 29: translations approved by the Free Software Foundation instead of in the 30: original English. 31: 32: 33: File: gcc.info, Node: Option Summary, Next: Overall Options, Up: Invoking GCC 34: 35: Option Summary 36: ============== 37: 38: Here is a summary of all the options, grouped by type. Explanations 39: are in the following sections. 40: 41: *Overall Options* 42: *Note Options Controlling the Kind of Output: Overall Options. 43: -c -S -E -o FILE -pipe -v -x LANGUAGE 44: 45: *C Language Options* 46: *Note Options Controlling C Dialect: C Dialect Options. 47: -ansi -fallow-single-precision -fcond-mismatch -fno-asm 48: -fno-builtin -fsigned-bitfields -fsigned-char 49: -funsigned-bitfields -funsigned-char -fwritable-strings 50: -traditional -traditional-cpp -trigraphs 51: 52: *C++ Language Options* 53: *Note Options Controlling C++ Dialect: C++ Dialect Options. 54: -fall-virtual -fdollars-in-identifiers -felide-constructors 1.1.1.8 root 55: -fenum-int-equiv -fexternal-templates -ffor-scope -fno-for-scope 56: -fhandle-signatures -fmemoize-lookups -fno-default-inline -fno-gnu-keywords 57: -fnonnull-objects -foperator-names -fstrict-prototype 58: -fthis-is-variable -nostdinc++ -traditional +eN 1.1.1.7 root 59: 60: *Warning Options* 61: *Note Options to Request or Suppress Warnings: Warning Options. 62: -fsyntax-only -pedantic -pedantic-errors 63: -w -W -Wall -Waggregate-return -Wbad-function-cast 64: -Wcast-align -Wcast-qual -Wchar-subscript -Wcomment 65: -Wconversion -Wenum-clash -Werror -Wformat 66: -Wid-clash-LEN -Wimplicit -Wimport -Winline 67: -Wlarger-than-LEN -Wmissing-declarations 68: -Wmissing-prototypes -Wnested-externs 69: -Wno-import -Woverloaded-virtual -Wparentheses 70: -Wpointer-arith -Wredundant-decls -Wreorder -Wreturn-type -Wshadow 71: -Wstrict-prototypes -Wswitch -Wsynth -Wtemplate-debugging 72: -Wtraditional -Wtrigraphs -Wuninitialized -Wunused 73: -Wwrite-strings 74: 75: *Debugging Options* 76: *Note Options for Debugging Your Program or GCC: Debugging Options. 77: -a -dLETTERS -fpretend-float 78: -g -gLEVEL -gcoff -gdwarf -gdwarf+ 79: -ggdb -gstabs -gstabs+ -gxcoff -gxcoff+ 80: -p -pg -print-file-name=LIBRARY -print-libgcc-file-name 1.1.1.8 root 81: -print-prog-name=PROGRAM -print-search-dirs -save-temps 1.1.1.7 root 82: 83: *Optimization Options* 84: *Note Options that Control Optimization: Optimize Options. 85: -fcaller-saves -fcse-follow-jumps -fcse-skip-blocks 86: -fdelayed-branch -fexpensive-optimizations 87: -ffast-math -ffloat-store -fforce-addr -fforce-mem 88: -finline-functions -fkeep-inline-functions 89: -fno-default-inline -fno-defer-pop -fno-function-cse 90: -fno-inline -fno-peephole -fomit-frame-pointer 91: -frerun-cse-after-loop -fschedule-insns 92: -fschedule-insns2 -fstrength-reduce -fthread-jumps 93: -funroll-all-loops -funroll-loops 94: -O -O0 -O1 -O2 -O3 95: 96: *Preprocessor Options* 97: *Note Options Controlling the Preprocessor: Preprocessor Options. 98: -AQUESTION(ANSWER) -C -dD -dM -dN 99: -DMACRO[=DEFN] -E -H 100: -idirafter DIR 101: -include FILE -imacros FILE 102: -iprefix FILE -iwithprefix DIR 103: -iwithprefixbefore DIR -isystem DIR 104: -M -MD -MM -MMD -MG -nostdinc -P -trigraphs 105: -undef -UMACRO -Wp,OPTION 106: 107: *Assembler Option* 108: *Note Passing Options to the Assembler: Assembler Options. 109: -Wa,OPTION 110: 111: *Linker Options* 112: *Note Options for Linking: Link Options. 1.1.1.8 root 113: OBJECT-FILE-NAME -lLIBRARY 114: -nostartfiles -nodefaultlibs -nostdlib 1.1.1.7 root 115: -s -static -shared -symbolic 116: -Wl,OPTION -Xlinker OPTION 117: -u SYMBOL 118: 119: *Directory Options* 120: *Note Options for Directory Search: Directory Options. 121: -BPREFIX -IDIR -I- -LDIR 122: 123: *Target Options* 124: *Note Target Options::. 125: -b MACHINE -V VERSION 126: 127: *Machine Dependent Options* 128: *Note Hardware Models and Configurations: Submodel Options. 129: *M680x0 Options* 130: -m68000 -m68020 -m68020-40 -m68030 -m68040 -m68881 131: -mbitfield -mc68000 -mc68020 -mfpa -mnobitfield 132: -mrtd -mshort -msoft-float 133: 134: *VAX Options* 135: -mg -mgnu -munix 136: 137: *SPARC Options* 138: -mapp-regs -mcypress -mepilogue -mflat -mfpu -mhard-float 139: -mhard-quad-float -mno-app-regs -mno-flat -mno-fpu 140: -mno-epilogue -mno-unaligned-doubles 141: -msoft-float -msoft-quad-float 142: -msparclite -msupersparc -munaligned-doubles -mv8 143: 144: SPARC V9 compilers support the following options 145: in addition to the above: 146: 147: -mmedlow -mmedany 148: -mint32 -mint64 -mlong32 -mlong64 149: -mno-stack-bias -mstack-bias 150: 151: *Convex Options* 152: -mc1 -mc2 -mc32 -mc34 -mc38 153: -margcount -mnoargcount 154: -mlong32 -mlong64 155: -mvolatile-cache -mvolatile-nocache 156: 157: *AMD29K Options* 158: -m29000 -m29050 -mbw -mnbw -mdw -mndw 159: -mlarge -mnormal -msmall 160: -mkernel-registers -mno-reuse-arg-regs 161: -mno-stack-check -mno-storem-bug 162: -mreuse-arg-regs -msoft-float -mstack-check 163: -mstorem-bug -muser-registers 164: 165: *ARM Options* 166: -mapcs -m2 -m3 -m6 -mbsd -mxopen -mno-symrename 167: 168: *M88K Options* 169: -m88000 -m88100 -m88110 -mbig-pic 170: -mcheck-zero-division -mhandle-large-shift 171: -midentify-revision -mno-check-zero-division 172: -mno-ocs-debug-info -mno-ocs-frame-position 173: -mno-optimize-arg-area -mno-serialize-volatile 174: -mno-underscores -mocs-debug-info 175: -mocs-frame-position -moptimize-arg-area 176: -mserialize-volatile -mshort-data-NUM -msvr3 177: -msvr4 -mtrap-large-shift -muse-div-instruction 178: -mversion-03.00 -mwarn-passed-structs 179: 1.1.1.8 root 180: *RS/6000 and PowerPC Options* 181: -mcpu=CPU TYPE 182: -mpower -mno-power -mpower2 -mno-power2 183: -mpowerpc -mno-powerpc 184: -mpowerpc-gpopt -mno-powerpc-gpopt 185: -mpowerpc-gfxopt -mno-powerpc-gfxopt 186: -mnew-mnemonics -mno-new-mnemonics 1.1.1.7 root 187: -mfull-toc -mminimal-toc -mno-fop-in-toc -mno-sum-in-toc 1.1.1.8 root 188: -msoft-float -mhard-float -mmultiple -mno-multiple 189: -mstring -mno-string -mbit-align -mno-bit-align 190: -mstrict-align -mno-strict-align -mrelocatable -mno-relocatable 191: -mtoc -mno-toc -mtraceback -mno-traceback 192: -mlittle -mlittle-endian -mbig -mbig-endian 193: -mcall-aix -mcall-sysv -mprototype 1.1.1.7 root 194: 195: *RT Options* 196: -mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs 197: -mfull-fp-blocks -mhc-struct-return -min-line-mul 198: -mminimum-fp-blocks -mnohc-struct-return 199: 200: *MIPS Options* 201: -mabicalls -mcpu=CPU TYPE -membedded-data 202: -membedded-pic -mfp32 -mfp64 -mgas -mgp32 -mgp64 203: -mgpopt -mhalf-pic -mhard-float -mint64 -mips1 204: -mips2 -mips3 -mlong64 -mlong-calls -mmemcpy 205: -mmips-as -mmips-tfile -mno-abicalls 206: -mno-embedded-data -mno-embedded-pic 207: -mno-gpopt -mno-long-calls 208: -mno-memcpy -mno-mips-tfile -mno-rnames -mno-stats 209: -mrnames -msoft-float 1.1.1.8 root 210: -m4650 -msingle-float -mmad 211: -mstats -EL -EB -G NUM -nocpp 1.1.1.7 root 212: 213: *i386 Options* 1.1.1.8 root 214: -m486 -m386 -mieee-fp -mno-fancy-math-387 1.1.1.7 root 215: -mno-fp-ret-in-387 -msoft-float -msvr3-shlib 1.1.1.8 root 216: -mno-wide-multiply -mrtd -malign-double 217: -mreg-alloc=LIST -mregparm=NUM 218: -malign-jumps=NUM -malign-loops=NUM 219: -malign-functions=NUM 1.1.1.7 root 220: 221: *HPPA Options* 1.1.1.8 root 222: -mdisable-fpregs -mdisable-indexing -mfast-indirect-calls 223: -mgas -mjump-in-delay -mlong-millicode-calls -mno-disable-fpregs 224: -mno-disable-indexing -mno-fast-indirect-calls -mno-gas 225: -mno-jump-in-delay -mno-millicode-long-calls 226: -mno-portable-runtime -mno-soft-float -msoft-float 227: -mpa-risc-1-0 -mpa-risc-1-1 -mportable-runtime -mschedule=LIST 1.1.1.7 root 228: 229: *Intel 960 Options* 230: -mCPU TYPE -masm-compat -mclean-linkage 231: -mcode-align -mcomplex-addr -mleaf-procedures 232: -mic-compat -mic2.0-compat -mic3.0-compat 233: -mintel-asm -mno-clean-linkage -mno-code-align 234: -mno-complex-addr -mno-leaf-procedures 235: -mno-old-align -mno-strict-align -mno-tail-call 236: -mnumerics -mold-align -msoft-float -mstrict-align 237: -mtail-call 238: 239: *DEC Alpha Options* 240: -mfp-regs -mno-fp-regs -mno-soft-float 241: -msoft-float 242: 243: *Clipper Options* 244: -mc300 -mc400 245: 246: *H8/300 Options* 247: -mrelax -mh 248: 249: *System V Options* 250: -Qy -Qn -YP,PATHS -Ym,DIR 251: 252: *Code Generation Options* 253: *Note Options for Code Generation Conventions: Code Gen Options. 254: -fcall-saved-REG -fcall-used-REG 255: -ffixed-REG -finhibit-size-directive 256: -fno-common -fno-ident -fno-gnu-linker 257: -fpcc-struct-return -fpic -fPIC 258: -freg-struct-return -fshared-data -fshort-enums 259: -fshort-double -fvolatile -fvolatile-global 1.1.1.8 root 260: -fverbose-asm -fpack-struct +e0 +e1 1.1.1.7 root 261: 262: * Menu: 263: 264: * Overall Options:: Controlling the kind of output: 265: an executable, object files, assembler files, 266: or preprocessed source. 267: * C Dialect Options:: Controlling the variant of C language compiled. 268: * C++ Dialect Options:: Variations on C++. 269: * Warning Options:: How picky should the compiler be? 270: * Debugging Options:: Symbol tables, measurements, and debugging dumps. 271: * Optimize Options:: How much optimization? 272: * Preprocessor Options:: Controlling header files and macro definitions. 273: Also, getting dependency information for Make. 274: * Assembler Options:: Passing options to the assembler. 275: * Link Options:: Specifying libraries and so on. 276: * Directory Options:: Where to find header files and libraries. 277: Where to find the compiler executable files. 278: * Target Options:: Running a cross-compiler, or an old version of GNU CC. 279: 280: 281: File: gcc.info, Node: Overall Options, Next: Invoking G++, Prev: Option Summary, Up: Invoking GCC 282: 283: Options Controlling the Kind of Output 284: ====================================== 285: 286: Compilation can involve up to four stages: preprocessing, compilation 287: proper, assembly and linking, always in that order. The first three 288: stages apply to an individual source file, and end by producing an 289: object file; linking combines all the object files (those newly 290: compiled, and those specified as input) into an executable file. 291: 292: For any given input file, the file name suffix determines what kind 293: of compilation is done: 294: 295: `FILE.c' 296: C source code which must be preprocessed. 297: 298: `FILE.i' 299: C source code which should not be preprocessed. 300: 301: `FILE.ii' 302: C++ source code which should not be preprocessed. 303: 304: `FILE.m' 305: Objective-C source code. Note that you must link with the library 306: `libobjc.a' to make an Objective-C program work. 307: 308: `FILE.h' 309: C header file (not to be compiled or linked). 310: 311: `FILE.cc' 312: `FILE.cxx' 313: `FILE.cpp' 314: `FILE.C' 315: C++ source code which must be preprocessed. Note that in `.cxx', 316: the last two letters must both be literally `x'. Likewise, `.C' 317: refers to a literal capital C. 318: 319: `FILE.s' 320: Assembler code. 321: 322: `FILE.S' 323: Assembler code which must be preprocessed. 324: 325: `OTHER' 326: An object file to be fed straight into linking. Any file name 327: with no recognized suffix is treated this way. 328: 329: You can specify the input language explicitly with the `-x' option: 330: 331: `-x LANGUAGE' 332: Specify explicitly the LANGUAGE for the following input files 333: (rather than letting the compiler choose a default based on the 334: file name suffix). This option applies to all following input 335: files until the next `-x' option. Possible values for LANGUAGE 336: are: 337: c objective-c c++ 338: c-header cpp-output c++-cpp-output 339: assembler assembler-with-cpp 340: 341: `-x none' 342: Turn off any specification of a language, so that subsequent files 343: are handled according to their file name suffixes (as they are if 344: `-x' has not been used at all). 345: 346: If you only want some of the stages of compilation, you can use `-x' 347: (or filename suffixes) to tell `gcc' where to start, and one of the 348: options `-c', `-S', or `-E' to say where `gcc' is to stop. Note that 349: some combinations (for example, `-x cpp-output -E' instruct `gcc' to do 350: nothing at all. 351: 352: `-c' 353: Compile or assemble the source files, but do not link. The linking 354: stage simply is not done. The ultimate output is in the form of an 355: object file for each source file. 356: 357: By default, the object file name for a source file is made by 358: replacing the suffix `.c', `.i', `.s', etc., with `.o'. 359: 360: Unrecognized input files, not requiring compilation or assembly, 361: are ignored. 362: 363: `-S' 364: Stop after the stage of compilation proper; do not assemble. The 365: output is in the form of an assembler code file for each 366: non-assembler input file specified. 367: 368: By default, the assembler file name for a source file is made by 369: replacing the suffix `.c', `.i', etc., with `.s'. 370: 371: Input files that don't require compilation are ignored. 372: 373: `-E' 374: Stop after the preprocessing stage; do not run the compiler 375: proper. The output is in the form of preprocessed source code, 376: which is sent to the standard output. 377: 378: Input files which don't require preprocessing are ignored. 379: 380: `-o FILE' 381: Place output in file FILE. This applies regardless to whatever 382: sort of output is being produced, whether it be an executable file, 383: an object file, an assembler file or preprocessed C code. 384: 385: Since only one output file can be specified, it does not make 386: sense to use `-o' when compiling more than one input file, unless 387: you are producing an executable file as output. 388: 389: If `-o' is not specified, the default is to put an executable file 390: in `a.out', the object file for `SOURCE.SUFFIX' in `SOURCE.o', its 391: assembler file in `SOURCE.s', and all preprocessed C source on 392: standard output. 393: 394: `-v' 395: Print (on standard error output) the commands executed to run the 396: stages of compilation. Also print the version number of the 397: compiler driver program and of the preprocessor and the compiler 398: proper. 399: 400: `-pipe' 401: Use pipes rather than temporary files for communication between the 402: various stages of compilation. This fails to work on some systems 403: where the assembler is unable to read from a pipe; but the GNU 404: assembler has no trouble. 1.1.1.4 root 405: 406: 1.1.1.5 root 407: File: gcc.info, Node: Invoking G++, Next: C Dialect Options, Prev: Overall Options, Up: Invoking GCC 408: 409: Compiling C++ Programs 410: ====================== 411: 412: C++ source files conventionally use one of the suffixes `.C', `.cc', 1.1.1.7 root 413: `cpp', or `.cxx'; preprocessed C++ files use the suffix `.ii'. GNU CC 1.1.1.5 root 414: recognizes files with these names and compiles them as C++ programs 415: even if you call the compiler the same way as for compiling C programs 416: (usually with the name `gcc'). 417: 418: However, C++ programs often require class libraries as well as a 419: compiler that understands the C++ language--and under some 420: circumstances, you might want to compile programs from standard input, 421: or otherwise without a suffix that flags them as C++ programs. `g++' 1.1.1.7 root 422: is a program that calls GNU CC with the default language set to C++, 423: and automatically specifies linking against the GNU class library 1.1.1.5 root 424: libg++. (1) On many systems, the script `g++' is also installed with 425: the name `c++'. 426: 427: When you compile C++ programs, you may specify many of the same 428: command-line options that you use for compiling programs in any 429: language; or command-line options meaningful for C and related 430: languages; or options that are meaningful only for C++ programs. *Note 431: Options Controlling C Dialect: C Dialect Options, for explanations of 432: options for languages related to C. *Note Options Controlling C++ 433: Dialect: C++ Dialect Options, for explanations of options that are 434: meaningful only for C++ programs. 435: 436: ---------- Footnotes ---------- 437: 438: (1) Prior to release 2 of the compiler, there was a separate `g++' 439: compiler. That version was based on GNU CC, but not integrated with 440: it. Versions of `g++' with a `1.XX' version number--for example, `g++' 441: version 1.37 or 1.42--are much less reliable than the versions 442: integrated with GCC 2. Moreover, combining G++ `1.XX' with a version 2 443: GCC will simply not work. 444: 445: 446: File: gcc.info, Node: C Dialect Options, Next: C++ Dialect Options, Prev: Invoking G++, Up: Invoking GCC 1.1.1.4 root 447: 1.1.1.5 root 448: Options Controlling C Dialect 449: ============================= 1.1.1.4 root 450: 1.1.1.5 root 451: The following options control the dialect of C (or languages derived 452: from C, such as C++ and Objective C) that the compiler accepts: 1.1.1.4 root 453: 454: `-ansi' 455: Support all ANSI standard C programs. 456: 457: This turns off certain features of GNU C that are incompatible 458: with ANSI C, such as the `asm', `inline' and `typeof' keywords, and 459: predefined macros such as `unix' and `vax' that identify the type 460: of system you are using. It also enables the undesirable and 1.1.1.8 root 461: rarely used ANSI trigraph feature, disallows `$' as part of 462: identifiers, and disables recognition of C++ style `//' comments. 1.1.1.4 root 463: 464: The alternate keywords `__asm__', `__extension__', `__inline__' 465: and `__typeof__' continue to work despite `-ansi'. You would not 1.1.1.7 root 466: want to use them in an ANSI C program, of course, but it is useful 467: to put them in header files that might be included in compilations 1.1.1.4 root 468: done with `-ansi'. Alternate predefined macros such as `__unix__' 469: and `__vax__' are also available, with or without `-ansi'. 470: 471: The `-ansi' option does not cause non-ANSI programs to be rejected 472: gratuitously. For that, `-pedantic' is required in addition to 473: `-ansi'. *Note Warning Options::. 474: 475: The macro `__STRICT_ANSI__' is predefined when the `-ansi' option 476: is used. Some header files may notice this macro and refrain from 477: declaring certain functions or defining certain macros that the 478: ANSI standard doesn't call for; this is to avoid interfering with 479: any programs that might use these names for other things. 480: 481: The functions `alloca', `abort', `exit', and `_exit' are not 482: builtin functions when `-ansi' is used. 483: 484: `-fno-asm' 1.1.1.8 root 485: Do not recognize `asm', `inline' or `typeof' as a keyword, so that 486: code can use these words as identifiers. You can use the keywords 1.1.1.5 root 487: `__asm__', `__inline__' and `__typeof__' instead. `-ansi' implies 488: `-fno-asm'. 1.1.1.4 root 489: 1.1.1.8 root 490: In C++, this switch only affects the `typeof' keyword, since `asm' 491: and `inline' are standard keywords. You may want to use the 492: `-fno-gnu-keywords' flag instead, as it also disables the other, 493: C++-specific, extension keywords such as `headof'. 494: 1.1.1.4 root 495: `-fno-builtin' 1.1.1.6 root 496: Don't recognize builtin functions that do not begin with two 1.1.1.5 root 497: leading underscores. Currently, the functions affected include 498: `abort', `abs', `alloca', `cos', `exit', `fabs', `ffs', `labs', 1.1.1.4 root 499: `memcmp', `memcpy', `sin', `sqrt', `strcmp', `strcpy', and 500: `strlen'. 501: 1.1.1.6 root 502: GCC normally generates special code to handle certain builtin 503: functions more efficiently; for instance, calls to `alloca' may 504: become single instructions that adjust the stack directly, and 505: calls to `memcpy' may become inline copy loops. The resulting 506: code is often both smaller and faster, but since the function 507: calls no longer appear as such, you cannot set a breakpoint on 508: those calls, nor can you change the behavior of the functions by 509: linking with a different library. 510: 1.1.1.5 root 511: The `-ansi' option prevents `alloca' and `ffs' from being builtin 512: functions, since these functions do not have an ANSI standard 513: meaning. 1.1.1.4 root 514: 515: `-trigraphs' 516: Support ANSI C trigraphs. You don't want to know about this 517: brain-damage. The `-ansi' option implies `-trigraphs'. 518: 519: `-traditional' 520: Attempt to support some aspects of traditional C compilers. 521: Specifically: 522: 523: * All `extern' declarations take effect globally even if they 524: are written inside of a function definition. This includes 525: implicit declarations of functions. 526: 1.1.1.5 root 527: * The newer keywords `typeof', `inline', `signed', `const' and 1.1.1.4 root 528: `volatile' are not recognized. (You can still use the 529: alternative keywords such as `__typeof__', `__inline__', and 530: so on.) 531: 532: * Comparisons between pointers and integers are always allowed. 533: 534: * Integer types `unsigned short' and `unsigned char' promote to 535: `unsigned int'. 536: 537: * Out-of-range floating point literals are not an error. 538: 1.1.1.5 root 539: * Certain constructs which ANSI regards as a single invalid 540: preprocessing number, such as `0xe-0xd', are treated as 541: expressions instead. 542: 1.1.1.4 root 543: * String "constants" are not necessarily constant; they are 544: stored in writable space, and identical looking constants are 545: allocated separately. (This is the same as the effect of 546: `-fwritable-strings'.) 547: 548: * All automatic variables not declared `register' are preserved 549: by `longjmp'. Ordinarily, GNU C follows ANSI C: automatic 550: variables not declared `volatile' may be clobbered. 551: 1.1.1.5 root 552: * The character escape sequences `\x' and `\a' evaluate as the 553: literal characters `x' and `a' respectively. Without 554: `-traditional', `\x' is a prefix for the hexadecimal 555: representation of a character, and `\a' produces a bell. 556: 557: * In C++ programs, assignment to `this' is permitted with 558: `-traditional'. (The option `-fthis-is-variable' also has 559: this effect.) 1.1.1.4 root 560: 561: You may wish to use `-fno-builtin' as well as `-traditional' if 562: your program uses names that are normally GNU C builtin functions 563: for other purposes of its own. 564: 1.1.1.7 root 565: You cannot use `-traditional' if you include any header files that 566: rely on ANSI C features. Some vendors are starting to ship 567: systems with ANSI C header files and you cannot use `-traditional' 568: on such systems to compile files that include any system headers. 569: 570: `' 571: In the preprocessor, comments convert to nothing at all, rather 572: than to a space. This allows traditional token concatenation. 573: 574: `' 1.1.1.8 root 575: In preprocessing directive, the `#' symbol must appear as the first 1.1.1.7 root 576: character of a line. 577: 578: `' 579: In the preprocessor, macro arguments are recognized within string 580: constants in a macro definition (and their values are stringified, 581: though without additional quote marks, when they appear in such a 582: context). The preprocessor always considers a string constant to 583: end at a newline. 584: 585: `' 586: The predefined macro `__STDC__' is not defined when you use 587: `-traditional', but `__GNUC__' is (since the GNU extensions which 588: `__GNUC__' indicates are not affected by `-traditional'). If you 589: need to write header files that work differently depending on 590: whether `-traditional' is in use, by testing both of these 591: predefined macros you can distinguish four situations: GNU C, 592: traditional GNU C, other ANSI C compilers, and other old C 1.1.1.8 root 593: compilers. The predefined macro `__STDC_VERSION__' is also not 594: defined when you use `-traditional'. *Note Standard Predefined 595: Macros: (cpp.info)Standard Predefined, for more discussion of 596: these and other predefined macros. 1.1.1.7 root 597: 598: `' 599: The preprocessor considers a string constant to end at a newline 600: (unless the newline is escaped with `\'). (Without `-traditional', 601: string constants can contain the newline character as typed.) 602: 1.1.1.4 root 603: `-traditional-cpp' 604: Attempt to support some aspects of traditional C preprocessors. 1.1.1.7 root 605: This includes the last five items in the table immediately above, 1.1.1.4 root 606: but none of the other effects of `-traditional'. 607: 608: `-fcond-mismatch' 609: Allow conditional expressions with mismatched types in the second 610: and third arguments. The value of such an expression is void. 611: 612: `-funsigned-char' 613: Let the type `char' be unsigned, like `unsigned char'. 614: 615: Each kind of machine has a default for what `char' should be. It 616: is either like `unsigned char' by default or like `signed char' by 617: default. 618: 619: Ideally, a portable program should always use `signed char' or 620: `unsigned char' when it depends on the signedness of an object. 621: But many programs have been written to use plain `char' and expect 622: it to be signed, or expect it to be unsigned, depending on the 623: machines they were written for. This option, and its inverse, let 624: you make such a program work with the opposite default. 625: 626: The type `char' is always a distinct type from each of `signed 627: char' or `unsigned char', even though its behavior is always just 628: like one of those two. 629: 630: `-fsigned-char' 631: Let the type `char' be signed, like `signed char'. 632: 633: Note that this is equivalent to `-fno-unsigned-char', which is the 1.1.1.5 root 634: negative form of `-funsigned-char'. Likewise, the option 635: `-fno-signed-char' is equivalent to `-funsigned-char'. 1.1.1.4 root 636: 637: `-fsigned-bitfields' 638: `-funsigned-bitfields' 639: `-fno-signed-bitfields' 640: `-fno-unsigned-bitfields' 641: These options control whether a bitfield is signed or unsigned, 1.1.1.5 root 642: when the declaration does not use either `signed' or `unsigned'. 1.1.1.4 root 643: By default, such a bitfield is signed, because this is consistent: 644: the basic integer types such as `int' are signed types. 645: 646: However, when `-traditional' is used, bitfields are all unsigned 647: no matter what. 648: 649: `-fwritable-strings' 650: Store string constants in the writable data segment and don't 651: uniquize them. This is for compatibility with old programs which 1.1.1.5 root 652: assume they can write into string constants. The option 653: `-traditional' also has this effect. 1.1.1.4 root 654: 655: Writing into string constants is a very bad idea; "constants" 656: should be constant. 1.1 root 657: 1.1.1.6 root 658: `-fallow-single-precision' 659: Do not promote single precision math operations to double 660: precision, even when compiling with `-traditional'. 661: 662: Traditional K&R C promotes all floating point operations to double 663: precision, regardless of the sizes of the operands. On the 664: architecture for which you are compiling, single precision may be 665: faster than double precision. If you must use `-traditional', 666: but want to use single precision operations when the operands are 667: single precision, use this option. This option has no effect 668: when compiling with ANSI or GNU C conventions (the default). 669: 1.1 root 670: 1.1.1.5 root 671: File: gcc.info, Node: C++ Dialect Options, Next: Warning Options, Prev: C Dialect Options, Up: Invoking GCC 672: 673: Options Controlling C++ Dialect 674: =============================== 675: 676: This section describes the command-line options that are only 677: meaningful for C++ programs; but you can also use most of the GNU 678: compiler options regardless of what language your program is in. For 679: example, you might compile a file `firstClass.C' like this: 680: 681: g++ -g -felide-constructors -O -c firstClass.C 682: 683: In this example, only `-felide-constructors' is an option meant only 684: for C++ programs; you can use the other options with any language 685: supported by GNU CC. 686: 687: Here is a list of options that are *only* for compiling C++ programs: 688: 1.1.1.7 root 689: `-fno-access-control' 690: Turn off all access checking. This switch is mainly useful for 691: working around bugs in the access control code. 692: 1.1.1.5 root 693: `-fall-virtual' 694: Treat all possible member functions as virtual, implicitly. All 695: member functions (except for constructor functions and `new' or 696: `delete' member operators) are treated as virtual functions of the 697: class where they appear. 698: 699: This does not mean that all calls to these member functions will 700: be made through the internal table of virtual functions. Under 701: some circumstances, the compiler can determine that a call to a 702: given virtual function can be made directly; in these cases the 703: calls are direct in any case. 704: 1.1.1.8 root 705: `-fcheck-new' 706: Check that the pointer returned by `operator new' is non-null 707: before attempting to modify the storage allocated. The current 708: Working Paper requires that `operator new' never return a null 709: pointer, so this check is normally unnecessary. 710: 1.1.1.7 root 711: `-fconserve-space' 712: Put uninitialized or runtime-initialized global variables into the 713: common segment, as C does. This saves space in the executable at 1.1.1.8 root 714: the cost of not diagnosing duplicate definitions. If you compile 715: with this flag and your program mysteriously crashes after 716: `main()' has completed, you may have an object that is being 717: destroyed twice because two definitions were merged. 1.1.1.7 root 718: 1.1.1.5 root 719: `-fdollars-in-identifiers' 720: Accept `$' in identifiers. You can also explicitly prohibit use of 721: `$' with the option `-fno-dollars-in-identifiers'. (GNU C++ 722: allows `$' by default on some target systems but not others.) 723: Traditional C allowed the character `$' to form part of 724: identifiers. However, ANSI C and C++ forbid `$' in identifiers. 725: 726: `-fenum-int-equiv' 1.1.1.8 root 727: Anachronistically permit implicit conversion of `int' to 728: enumeration types. Current C++ allows conversion of `enum' to 729: `int', but not the other way around. 1.1.1.5 root 730: 1.1.1.6 root 731: `-fexternal-templates' 1.1.1.7 root 732: Cause template instantiations to obey `#pragma interface' and 733: `implementation'; template instances are emitted or not according 734: to the location of the template definition. *Note Template 735: Instantiation::, for more information. 736: 737: `-falt-external-templates' 738: Similar to -fexternal-templates, but template instances are 739: emitted or not according to the place where they are first 740: instantiated. *Note Template Instantiation::, for more 741: information. 742: 1.1.1.8 root 743: `-ffor-scope' 744: `-fno-for-scope' 745: If -ffor-scope is specified, the scope of variables declared in a 746: for-init-statement is limited to the `for' loop itself, as 747: specified by the draft C++ standard. If -fno-for-scope is 748: specified, the scope of variables declared in a for-init-statement 749: extends to the end of the enclosing scope, as was the case in old 750: versions of gcc, and other (traditional) implementations of C++. 751: 752: The default if neither flag is given to follow the standard, but 753: to allow and give a warning for old-style code that would 754: otherwise be invalid, or have different behavior. 755: 756: `-fno-gnu-keywords' 757: Do not recognize `classof', `headof', `signature', `sigof' or 758: `typeof' as a keyword, so that code can use these words as 759: identifiers. You can use the keywords `__classof__', 760: `__headof__', `__signature__', `__sigof__', and `__typeof__' 761: instead. `-ansi' implies `-fno-gnu-keywords'. 762: 1.1.1.7 root 763: `-fno-implicit-templates' 764: Never emit code for templates which are instantiated implicitly 765: (i.e. by use); only emit code for explicit instantiations. *Note 766: Template Instantiation::, for more information. 767: 768: `-fhandle-signatures' 769: Recognize the `signature' and `sigof' keywords for specifying 770: abstract types. The default (`-fno-handle-signatures') is not to 771: recognize them. *Note Type Abstraction using Signatures: C++ 772: Signatures. 773: 774: `-fhuge-objects' 775: Support virtual function calls for objects that exceed the size 776: representable by a `short int'. Users should not use this flag by 777: default; if you need to use it, the compiler will tell you so. If 778: you compile any of your code with this flag, you must compile 779: *all* of your code with this flag (including libg++, if you use 780: it). 781: 782: This flag is not useful when compiling with -fvtable-thunks. 783: 784: `-fno-implement-inlines' 785: To save space, do not emit out-of-line copies of inline functions 786: controlled by `#pragma implementation'. This will cause linker 787: errors if these functions are not inlined everywhere they are 788: called. 1.1.1.6 root 789: 1.1.1.5 root 790: `-fmemoize-lookups' 791: `-fsave-memoized' 792: Use heuristics to compile faster. These heuristics are not 793: enabled by default, since they are only effective for certain 794: input files. Other input files compile more slowly. 795: 796: The first time the compiler must build a call to a member function 797: (or reference to a data member), it must (1) determine whether the 798: class implements member functions of that name; (2) resolve which 799: member function to call (which involves figuring out what sorts of 800: type conversions need to be made); and (3) check the visibility of 801: the member function to the caller. All of this adds up to slower 802: compilation. Normally, the second time a call is made to that 803: member function (or reference to that data member), it must go 804: through the same lengthy process again. This means that code like 805: this: 806: 807: cout << "This " << p << " has " << n << " legs.\n"; 808: 809: makes six passes through all three steps. By using a software 810: cache, a "hit" significantly reduces this cost. Unfortunately, 811: using the cache introduces another layer of mechanisms which must 812: be implemented, and so incurs its own overhead. 813: `-fmemoize-lookups' enables the software cache. 814: 815: Because access privileges (visibility) to members and member 816: functions may differ from one function context to the next, G++ 817: may need to flush the cache. With the `-fmemoize-lookups' flag, 818: the cache is flushed after every function that is compiled. The 819: `-fsave-memoized' flag enables the same software cache, but when 820: the compiler determines that the context of the last function 821: compiled would yield the same access privileges of the next 822: function to compile, it preserves the cache. This is most helpful 823: when defining many member functions for the same class: with the 824: exception of member functions which are friends of other classes, 825: each member function has exactly the same access privileges as 826: every other, and the cache need not be flushed. 827: 1.1.1.8 root 828: The code that implements these flags has rotted; you should 829: probably avoid using them. 1.1.1.5 root 830: 1.1.1.8 root 831: `-fstrict-prototype' 832: Within an `extern "C"' linkage specification, treat a function 833: declaration with no arguments, such as `int foo ();', as declaring 834: the function to take no arguments. Normally, such a declaration 835: means that the function `foo' can take any combination of 836: arguments, as in C. `-pedantic' implies `-fstrict-prototype' 837: unless overridden with `-fno-strict-prototype'. 838: 839: This flag no longer affects declarations with C++ linkage. 840: 841: `-fno-nonnull-objects' 842: Don't assume that a reference is initialized to refer to a valid 843: object. Although the current C++ Working Paper prohibits null 844: references, some old code may rely on them, and you can use 845: `-fno-nonnull-objects' to turn on checking. 846: 847: At the moment, the compiler only does this checking for 848: conversions to virtual base classes. 849: 850: `-foperator-names' 851: Recognize the operator name keywords `and', `bitand', `bitor', 852: `compl', `not', `or' and `xor' as synonyms for the symbols they 853: refer to. `-ansi' implies `-foperator-names'. 1.1.1.7 root 854: 1.1.1.5 root 855: `-fthis-is-variable' 856: Permit assignment to `this'. The incorporation of user-defined 857: free store management into C++ has made assignment to `this' an 858: anachronism. Therefore, by default it is invalid to assign to 1.1.1.7 root 859: `this' within a class member function; that is, GNU C++ treats 860: `this' in a member function of class `X' as a non-lvalue of type 861: `X *'. However, for backwards compatibility, you can make it 862: valid with `-fthis-is-variable'. 863: 864: `-fvtable-thunks' 865: Use `thunks' to implement the virtual function dispatch table 866: (`vtable'). The traditional (cfront-style) approach to 867: implementing vtables was to store a pointer to the function and two 868: offsets for adjusting the `this' pointer at the call site. Newer 869: implementations store a single pointer to a `thunk' function which 870: does any necessary adjustment and then calls the target function. 871: 872: This option also enables a heuristic for controlling emission of 873: vtables; if a class has any non-inline virtual functions, the 874: vtable will be emitted in the translation unit containing the 875: first one of those. 1.1.1.5 root 876: 877: `-nostdinc++' 878: Do not search for header files in the standard directories 879: specific to C++, but do still search the other standard 880: directories. (This option is used when building libg++.) 881: 882: `-traditional' 883: For C++ programs (in addition to the effects that apply to both C 884: and C++), this has the same effect as `-fthis-is-variable'. *Note 885: Options Controlling C Dialect: C Dialect Options. 886: 887: In addition, these optimization, warning, and code generation options 888: have meanings only for C++ programs: 889: 890: `-fno-default-inline' 891: Do not assume `inline' for functions defined inside a class scope. 892: *Note Options That Control Optimization: Optimize Options. 893: 894: `-Wenum-clash' 895: `-Woverloaded-virtual' 896: `-Wtemplate-debugging' 897: Warnings that apply only to C++ programs. *Note Options to 898: Request or Suppress Warnings: Warning Options. 899: 900: `+eN' 901: Control how virtual function definitions are used, in a fashion 902: compatible with `cfront' 1.x. *Note Options for Code Generation 903: Conventions: Code Gen Options. 904:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.