![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-3 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-3 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: 1.1.1.8 root 33: File: gcc.info, Node: Warning Options, Next: Debugging Options, Prev: C++ Dialect Options, Up: Invoking GCC 34: 35: Options to Request or Suppress Warnings 36: ======================================= 37: 38: Warnings are diagnostic messages that report constructions which are 39: not inherently erroneous but which are risky or suggest there may have 40: been an error. 41: 42: You can request many specific warnings with options beginning `-W', 43: for example `-Wimplicit' to request warnings on implicit declarations. 44: Each of these specific warning options also has a negative form 45: beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'. 46: This manual lists only one of the two forms, whichever is not the 47: default. 48: 49: These options control the amount and kinds of warnings produced by 50: GNU CC: 51: 52: `-fsyntax-only' 53: Check the code for syntax errors, but don't do anything beyond 54: that. 55: 56: `-pedantic' 57: Issue all the warnings demanded by strict ANSI standard C; reject 58: all programs that use forbidden extensions. 59: 60: Valid ANSI standard C programs should compile properly with or 61: without this option (though a rare few will require `-ansi'). 62: However, without this option, certain GNU extensions and 63: traditional C features are supported as well. With this option, 64: they are rejected. 65: 66: `-pedantic' does not cause warning messages for use of the 67: alternate keywords whose names begin and end with `__'. Pedantic 68: warnings are also disabled in the expression that follows 69: `__extension__'. However, only system header files should use 70: these escape routes; application programs should avoid them. 71: *Note Alternate Keywords::. 72: 73: This option is not intended to be useful; it exists only to satisfy 74: pedants who would otherwise claim that GNU CC fails to support the 75: ANSI standard. 76: 77: Some users try to use `-pedantic' to check programs for strict ANSI 78: C conformance. They soon find that it does not do quite what they 79: want: it finds some non-ANSI practices, but not all--only those 80: for which ANSI C *requires* a diagnostic. 81: 82: A feature to report any failure to conform to ANSI C might be 83: useful in some instances, but would require considerable 84: additional work and would be quite different from `-pedantic'. We 85: recommend, rather, that users take advantage of the extensions of 86: GNU C and disregard the limitations of other compilers. Aside 87: from certain supercomputers and obsolete small machines, there is 88: less and less reason ever to use any other C compiler other than 89: for bootstrapping GNU CC. 90: 91: `-pedantic-errors' 92: Like `-pedantic', except that errors are produced rather than 93: warnings. 94: 95: `-w' 96: Inhibit all warning messages. 97: 98: `-Wno-import' 99: Inhibit warning messages about the use of `#import'. 100: 101: `-Wchar-subscripts' 102: Warn if an array subscript has type `char'. This is a common cause 103: of error, as programmers often forget that this type is signed on 104: some machines. 105: 106: `-Wcomment' 107: Warn whenever a comment-start sequence `/*' appears in a comment. 108: 109: `-Wformat' 110: Check calls to `printf' and `scanf', etc., to make sure that the 111: arguments supplied have types appropriate to the format string 112: specified. 113: 114: `-Wimplicit' 115: Warn whenever a function or parameter is implicitly declared. 116: 117: `-Wparentheses' 118: Warn if parentheses are omitted in certain contexts, such as when 119: there is an assignment in a context where a truth value is 120: expected, or when operators are nested whose precedence people 121: often get confused about. 122: 123: `-Wreturn-type' 124: Warn whenever a function is defined with a return-type that 125: defaults to `int'. Also warn about any `return' statement with no 126: return-value in a function whose return-type is not `void'. 127: 128: `-Wswitch' 129: Warn whenever a `switch' statement has an index of enumeral type 130: and lacks a `case' for one or more of the named codes of that 131: enumeration. (The presence of a `default' label prevents this 132: warning.) `case' labels outside the enumeration range also 133: provoke warnings when this option is used. 134: 135: `-Wtrigraphs' 136: Warn if any trigraphs are encountered (assuming they are enabled). 137: 138: `-Wunused' 139: Warn whenever a variable is unused aside from its declaration, 140: whenever a function is declared static but never defined, whenever 141: a label is declared but not used, and whenever a statement 142: computes a result that is explicitly not used. 143: 144: To suppress this warning for an expression, simply cast it to 145: void. For unused variables and parameters, use the `unused' 146: attribute (*note Variable Attributes::.). 147: 148: `-Wuninitialized' 149: An automatic variable is used without first being initialized. 150: 151: These warnings are possible only in optimizing compilation, 152: because they require data flow information that is computed only 153: when optimizing. If you don't specify `-O', you simply won't get 154: these warnings. 155: 156: These warnings occur only for variables that are candidates for 157: register allocation. Therefore, they do not occur for a variable 158: that is declared `volatile', or whose address is taken, or whose 159: size is other than 1, 2, 4 or 8 bytes. Also, they do not occur for 160: structures, unions or arrays, even when they are in registers. 161: 162: Note that there may be no warning about a variable that is used 163: only to compute a value that itself is never used, because such 164: computations may be deleted by data flow analysis before the 165: warnings are printed. 166: 167: These warnings are made optional because GNU CC is not smart 168: enough to see all the reasons why the code might be correct 169: despite appearing to have an error. Here is one example of how 170: this can happen: 171: 172: { 173: int x; 174: switch (y) 175: { 176: case 1: x = 1; 177: break; 178: case 2: x = 4; 179: break; 180: case 3: x = 5; 181: } 182: foo (x); 183: } 184: 185: If the value of `y' is always 1, 2 or 3, then `x' is always 186: initialized, but GNU CC doesn't know this. Here is another common 187: case: 188: 189: { 190: int save_y; 191: if (change_y) save_y = y, y = new_y; 192: ... 193: if (change_y) y = save_y; 194: } 195: 196: This has no bug because `save_y' is used only if it is set. 197: 198: Some spurious warnings can be avoided if you declare all the 199: functions you use that never return as `noreturn'. *Note Function 200: Attributes::. 201: 202: `-Wenum-clash' 203: Warn about conversion between different enumeration types. (C++ 204: only). 205: 206: `-Wreorder (C++ only)' 207: Warn when the order of member initializers given in the code does 208: not match the order in which they must be executed. For instance: 209: 210: struct A { 211: int i; 212: int j; 213: A(): j (0), i (1) { } 214: }; 215: 216: Here the compiler will warn that the member initializers for `i' 217: and `j' will be rearranged to match the declaration order of the 218: members. 219: 220: `-Wtemplate-debugging' 221: When using templates in a C++ program, warn if debugging is not yet 222: fully available (C++ only). 223: 224: `-Wall' 225: All of the above `-W' options combined. These are all the options 226: which pertain to usage that we recommend avoiding and that we 227: believe is easy to avoid, even in conjunction with macros. 228: 229: The remaining `-W...' options are not implied by `-Wall' because 230: they warn about constructions that we consider reasonable to use, on 231: occasion, in clean programs. 232: 233: `-W' 234: Print extra warning messages for these events: 235: 236: * A nonvolatile automatic variable might be changed by a call to 237: `longjmp'. These warnings as well are possible only in 238: optimizing compilation. 239: 240: The compiler sees only the calls to `setjmp'. It cannot know 241: where `longjmp' will be called; in fact, a signal handler 242: could call it at any point in the code. As a result, you may 243: get a warning even when there is in fact no problem because 244: `longjmp' cannot in fact be called at the place which would 245: cause a problem. 246: 247: * A function can return either with or without a value. 248: (Falling off the end of the function body is considered 249: returning without a value.) For example, this function would 250: evoke such a warning: 251: 252: foo (a) 253: { 254: if (a > 0) 255: return a; 256: } 257: 258: * An expression-statement or the left-hand side of a comma 259: expression contains no side effects. To suppress the 260: warning, cast the unused expression to void. For example, an 261: expression such as `x[i,j]' will cause a warning, but 262: `x[(void)i,j]' will not. 263: 264: * An unsigned value is compared against zero with `<' or `<='. 265: 266: * A comparison like `x<=y<=z' appears; this is equivalent to 267: `(x<=y ? 1 : 0) <= z', which is a different interpretation 268: from that of ordinary mathematical notation. 269: 270: * Storage-class specifiers like `static' are not the first 271: things in a declaration. According to the C Standard, this 272: usage is obsolescent. 273: 274: * If `-Wall' or `-Wunused' is also specified, warn about unused 275: arguments. 276: 277: * An aggregate has a partly bracketed initializer. For 278: example, the following code would evoke such a warning, 279: because braces are missing around the initializer for `x.h': 280: 281: struct s { int f, g; }; 282: struct t { struct s h; int i; }; 283: struct t x = { 1, 2, 3 }; 284: 285: `-Wtraditional' 286: Warn about certain constructs that behave differently in 287: traditional and ANSI C. 288: 289: * Macro arguments occurring within string constants in the 290: macro body. These would substitute the argument in 291: traditional C, but are part of the constant in ANSI C. 292: 293: * A function declared external in one block and then used after 294: the end of the block. 295: 296: * A `switch' statement has an operand of type `long'. 297: 298: `-Wshadow' 299: Warn whenever a local variable shadows another local variable. 300: 301: `-Wid-clash-LEN' 302: Warn whenever two distinct identifiers match in the first LEN 303: characters. This may help you prepare a program that will compile 304: with certain obsolete, brain-damaged compilers. 305: 306: `-Wlarger-than-LEN' 307: Warn whenever an object of larger than LEN bytes is defined. 308: 309: `-Wpointer-arith' 310: Warn about anything that depends on the "size of" a function type 311: or of `void'. GNU C assigns these types a size of 1, for 312: convenience in calculations with `void *' pointers and pointers to 313: functions. 314: 315: `-Wbad-function-cast' 316: Warn whenever a function call is cast to a non-matching type. For 317: example, warn if `int malloc()' is cast to `anything *'. 318: 319: `-Wcast-qual' 320: Warn whenever a pointer is cast so as to remove a type qualifier 321: from the target type. For example, warn if a `const char *' is 322: cast to an ordinary `char *'. 323: 324: `-Wcast-align' 325: Warn whenever a pointer is cast such that the required alignment 326: of the target is increased. For example, warn if a `char *' is 327: cast to an `int *' on machines where integers can only be accessed 328: at two- or four-byte boundaries. 329: 330: `-Wwrite-strings' 331: Give string constants the type `const char[LENGTH]' so that 332: copying the address of one into a non-`const' `char *' pointer 333: will get a warning. These warnings will help you find at compile 334: time code that can try to write into a string constant, but only 335: if you have been very careful about using `const' in declarations 336: and prototypes. Otherwise, it will just be a nuisance; this is 337: why we did not make `-Wall' request these warnings. 338: 339: `-Wconversion' 340: Warn if a prototype causes a type conversion that is different 341: from what would happen to the same argument in the absence of a 342: prototype. This includes conversions of fixed point to floating 343: and vice versa, and conversions changing the width or signedness 344: of a fixed point argument except when the same as the default 345: promotion. 346: 347: Also, warn if a negative integer constant expression is implicitly 348: converted to an unsigned type. For example, warn about the 349: assignment `x = -1' if `x' is unsigned. But do not warn about 350: explicit casts like `(unsigned) -1'. 351: 352: `-Waggregate-return' 353: Warn if any functions that return structures or unions are defined 354: or called. (In languages where you can return an array, this also 355: elicits a warning.) 356: 357: `-Wstrict-prototypes' 358: Warn if a function is declared or defined without specifying the 359: argument types. (An old-style function definition is permitted 360: without a warning if preceded by a declaration which specifies the 361: argument types.) 362: 363: `-Wmissing-prototypes' 364: Warn if a global function is defined without a previous prototype 365: declaration. This warning is issued even if the definition itself 366: provides a prototype. The aim is to detect global functions that 367: fail to be declared in header files. 368: 369: `-Wmissing-declarations' 370: Warn if a global function is defined without a previous 371: declaration. Do so even if the definition itself provides a 372: prototype. Use this option to detect global functions that are 373: not declared in header files. 374: 375: `-Wredundant-decls' 376: Warn if anything is declared more than once in the same scope, 377: even in cases where multiple declaration is valid and changes 378: nothing. 379: 380: `-Wnested-externs' 381: Warn if an `extern' declaration is encountered within an function. 382: 383: `-Winline' 384: Warn if a function can not be inlined, and either it was declared 385: as inline, or else the `-finline-functions' option was given. 386: 387: `-Woverloaded-virtual' 388: Warn when a derived class function declaration may be an error in 389: defining a virtual function (C++ only). In a derived class, the 390: definitions of virtual functions must match the type signature of a 391: virtual function declared in the base class. With this option, the 392: compiler warns when you define a function with the same name as a 393: virtual function, but with a type signature that does not match any 394: declarations from the base class. 395: 396: `-Wsynth (C++ only)' 397: Warn when g++'s synthesis behavior does not match that of cfront. 398: For instance: 399: 400: struct A { 401: operator int (); 402: A& operator = (int); 403: }; 404: 405: main () 406: { 407: A a,b; 408: a = b; 409: } 410: 411: In this example, g++ will synthesize a default `A& operator = 412: (const A&);', while cfront will use the user-defined `operator ='. 413: 414: `-Werror' 415: Make all warnings into errors. 416: 417: 1.1.1.7 root 418: File: gcc.info, Node: Debugging Options, Next: Optimize Options, Prev: Warning Options, Up: Invoking GCC 419: 420: Options for Debugging Your Program or GNU CC 421: ============================================ 422: 423: GNU CC has various special options that are used for debugging 424: either your program or GCC: 425: 426: `-g' 427: Produce debugging information in the operating system's native 428: format (stabs, COFF, XCOFF, or DWARF). GDB can work with this 429: debugging information. 430: 431: On most systems that use stabs format, `-g' enables use of extra 432: debugging information that only GDB can use; this extra information 433: makes debugging work better in GDB but will probably make other 434: debuggers crash or refuse to read the program. If you want to 435: control for certain whether to generate the extra information, use 436: `-gstabs+', `-gstabs', `-gxcoff+', `-gxcoff', `-gdwarf+', or 437: `-gdwarf' (see below). 438: 439: Unlike most other C compilers, GNU CC allows you to use `-g' with 440: `-O'. The shortcuts taken by optimized code may occasionally 441: produce surprising results: some variables you declared may not 442: exist at all; flow of control may briefly move where you did not 443: expect it; some statements may not be executed because they 444: compute constant results or their values were already at hand; 445: some statements may execute in different places because they were 446: moved out of loops. 447: 448: Nevertheless it proves possible to debug optimized output. This 449: makes it reasonable to use the optimizer for programs that might 450: have bugs. 451: 452: The following options are useful when GNU CC is generated with the 453: capability for more than one debugging format. 454: 455: `-ggdb' 456: Produce debugging information in the native format (if that is 457: supported), including GDB extensions if at all possible. 458: 459: `-gstabs' 460: Produce debugging information in stabs format (if that is 461: supported), without GDB extensions. This is the format used by 462: DBX on most BSD systems. On MIPS, Alpha and System V Release 4 463: systems this option produces stabs debugging output which is not 464: understood by DBX or SDB. On System V Release 4 systems this 465: option requires the GNU assembler. 466: 467: `-gstabs+' 468: Produce debugging information in stabs format (if that is 469: supported), using GNU extensions understood only by the GNU 470: debugger (GDB). The use of these extensions is likely to make 471: other debuggers crash or refuse to read the program. 472: 473: `-gcoff' 474: Produce debugging information in COFF format (if that is 475: supported). This is the format used by SDB on most System V 476: systems prior to System V Release 4. 477: 478: `-gxcoff' 479: Produce debugging information in XCOFF format (if that is 480: supported). This is the format used by the DBX debugger on IBM 481: RS/6000 systems. 482: 483: `-gxcoff+' 484: Produce debugging information in XCOFF format (if that is 485: supported), using GNU extensions understood only by the GNU 486: debugger (GDB). The use of these extensions is likely to make 1.1.1.8 root 487: other debuggers crash or refuse to read the program, and may cause 488: assemblers other than the GNU assembler (GAS) to fail with an 489: error. 1.1.1.7 root 490: 491: `-gdwarf' 492: Produce debugging information in DWARF format (if that is 493: supported). This is the format used by SDB on most System V 494: Release 4 systems. 495: 496: `-gdwarf+' 497: Produce debugging information in DWARF format (if that is 498: supported), using GNU extensions understood only by the GNU 499: debugger (GDB). The use of these extensions is likely to make 500: other debuggers crash or refuse to read the program. 501: 502: `-gLEVEL' 503: `-ggdbLEVEL' 504: `-gstabsLEVEL' 505: `-gcoffLEVEL' 506: `-gxcoffLEVEL' 507: `-gdwarfLEVEL' 508: Request debugging information and also use LEVEL to specify how 509: much information. The default level is 2. 510: 511: Level 1 produces minimal information, enough for making backtraces 512: in parts of the program that you don't plan to debug. This 513: includes descriptions of functions and external variables, but no 514: information about local variables and no line numbers. 515: 516: Level 3 includes extra information, such as all the macro 517: definitions present in the program. Some debuggers support macro 518: expansion when you use `-g3'. 519: 520: `-p' 521: Generate extra code to write profile information suitable for the 522: analysis program `prof'. You must use this option when compiling 523: the source files you want data about, and you must also use it when 524: linking. 525: 526: `-pg' 527: Generate extra code to write profile information suitable for the 528: analysis program `gprof'. You must use this option when compiling 529: the source files you want data about, and you must also use it when 530: linking. 531: 532: `-a' 533: Generate extra code to write profile information for basic blocks, 534: which will record the number of times each basic block is 535: executed, the basic block start address, and the function name 536: containing the basic block. If `-g' is used, the line number and 537: filename of the start of the basic block will also be recorded. 538: If not overridden by the machine description, the default action is 539: to append to the text file `bb.out'. 540: 541: This data could be analyzed by a program like `tcov'. Note, 542: however, that the format of the data is not what `tcov' expects. 543: Eventually GNU `gprof' should be extended to process this data. 544: 545: `-dLETTERS' 546: Says to make debugging dumps during compilation at times specified 547: by LETTERS. This is used for debugging the compiler. The file 548: names for most of the dumps are made by appending a word to the 549: source file name (e.g. `foo.c.rtl' or `foo.c.jump'). Here are the 550: possible letters for use in LETTERS, and their meanings: 551: 552: `M' 553: Dump all macro definitions, at the end of preprocessing, and 554: write no output. 555: 556: `N' 557: Dump all macro names, at the end of preprocessing. 558: 559: `D' 560: Dump all macro definitions, at the end of preprocessing, in 561: addition to normal output. 562: 563: `y' 564: Dump debugging information during parsing, to standard error. 565: 566: `r' 567: Dump after RTL generation, to `FILE.rtl'. 568: 569: `x' 570: Just generate RTL for a function instead of compiling it. 571: Usually used with `r'. 572: 573: `j' 574: Dump after first jump optimization, to `FILE.jump'. 575: 576: `s' 577: Dump after CSE (including the jump optimization that sometimes 578: follows CSE), to `FILE.cse'. 579: 580: `L' 581: Dump after loop optimization, to `FILE.loop'. 582: 583: `t' 584: Dump after the second CSE pass (including the jump 585: optimization that sometimes follows CSE), to `FILE.cse2'. 586: 587: `f' 588: Dump after flow analysis, to `FILE.flow'. 589: 590: `c' 591: Dump after instruction combination, to the file 592: `FILE.combine'. 593: 594: `S' 595: Dump after the first instruction scheduling pass, to 596: `FILE.sched'. 597: 598: `l' 599: Dump after local register allocation, to `FILE.lreg'. 600: 601: `g' 602: Dump after global register allocation, to `FILE.greg'. 603: 604: `R' 605: Dump after the second instruction scheduling pass, to 606: `FILE.sched2'. 607: 608: `J' 609: Dump after last jump optimization, to `FILE.jump2'. 610: 611: `d' 612: Dump after delayed branch scheduling, to `FILE.dbr'. 613: 614: `k' 615: Dump after conversion from registers to stack, to 616: `FILE.stack'. 617: 618: `a' 619: Produce all the dumps listed above. 620: 621: `m' 622: Print statistics on memory usage, at the end of the run, to 623: standard error. 624: 625: `p' 626: Annotate the assembler output with a comment indicating which 627: pattern and alternative was used. 628: 629: `-fpretend-float' 630: When running a cross-compiler, pretend that the target machine 631: uses the same floating point format as the host machine. This 632: causes incorrect output of the actual floating constants, but the 633: actual instruction sequence will probably be the same as GNU CC 634: would make when running on the target machine. 635: 636: `-save-temps' 637: Store the usual "temporary" intermediate files permanently; place 638: them in the current directory and name them based on the source 639: file. Thus, compiling `foo.c' with `-c -save-temps' would produce 640: files `foo.i' and `foo.s', as well as `foo.o'. 641: 642: `-print-file-name=LIBRARY' 643: Print the full absolute name of the library file LIBRARY that 644: would be used when linking--and don't do anything else. With this 645: option, GNU CC does not compile or link anything; it just prints 646: the file name. 647: 648: `-print-prog-name=PROGRAM' 649: Like `-print-file-name', but searches for a program such as `cpp'. 650: 651: `-print-libgcc-file-name' 652: Same as `-print-file-name=libgcc.a'. 653: 1.1.1.8 root 654: This is useful when you use `-nostdlib' or `-nodefaultlibs' but 655: you do want to link with `libgcc.a'. You can do 1.1.1.7 root 656: 657: gcc -nostdlib FILES... `gcc -print-libgcc-file-name` 1.1.1.4 root 658: 1.1.1.8 root 659: `-print-search-dirs' 660: Print the name of the configured installation directory and a list 661: of program and library directories gcc will search--and don't do 662: anything else. 663: 664: This is useful when gcc prints the error message `installation 665: problem, cannot exec cpp: No such file or directory'. To resolve 666: this you either need to put `cpp' and the other compiler 667: components where gcc expects to find them, or you can set the 668: environment variable `GCC_EXEC_PREFIX' to the directory where you 669: installed them. Don't forget the trailing '/'. *Note Environment 670: Variables::. 671: 1.1.1.4 root 672: 1.1.1.6 root 673: File: gcc.info, Node: Optimize Options, Next: Preprocessor Options, Prev: Debugging Options, Up: Invoking GCC 674: 675: Options That Control Optimization 676: ================================= 677: 678: These options control various sorts of optimizations: 679: 680: `-O' 681: `-O1' 682: Optimize. Optimizing compilation takes somewhat more time, and a 683: lot more memory for a large function. 684: 685: Without `-O', the compiler's goal is to reduce the cost of 686: compilation and to make debugging produce the expected results. 687: Statements are independent: if you stop the program with a 688: breakpoint between statements, you can then assign a new value to 689: any variable or change the program counter to any other statement 690: in the function and get exactly the results you would expect from 691: the source code. 692: 1.1.1.7 root 693: Without `-O', the compiler only allocates variables declared 694: `register' in registers. The resulting compiled code is a little 695: worse than produced by PCC without `-O'. 1.1.1.6 root 696: 697: With `-O', the compiler tries to reduce code size and execution 698: time. 699: 1.1.1.7 root 700: When you specify `-O', the compiler turns on `-fthread-jumps' and 701: `-fdefer-pop' on all machines. The compiler turns on 702: `-fdelayed-branch' on machines that have delay slots, and 703: `-fomit-frame-pointer' on machines that can support debugging even 704: without a frame pointer. On some machines the compiler also turns 705: on other flags. 1.1.1.6 root 706: 707: `-O2' 1.1.1.7 root 708: Optimize even more. GNU CC performs nearly all supported 709: optimizations that do not involve a space-speed tradeoff. The 710: compiler does not perform loop unrolling or function inlining when 711: you specify `-O2'. As compared to `-O', this option increases 712: both compilation time and the performance of the generated code. 1.1.1.6 root 713: 714: `-O2' turns on all optional optimizations except for loop unrolling 1.1.1.8 root 715: and function inlining. It also turns on the `-fforce-mem' option 716: on all machines and frame pointer elimination on machines where 717: doing so does not interfere with debugging. 1.1.1.7 root 718: 719: `-O3' 720: Optimize yet more. `-O3' turns on all optimizations specified by 721: `-O2' and also turns on the `inline-functions' option. 1.1.1.6 root 722: 723: `-O0' 724: Do not optimize. 725: 726: If you use multiple `-O' options, with or without level numbers, 727: the last such option is the one that is effective. 728: 729: Options of the form `-fFLAG' specify machine-independent flags. 730: Most flags have both positive and negative forms; the negative form of 731: `-ffoo' would be `-fno-foo'. In the table below, only one of the forms 732: is listed--the one which is not the default. You can figure out the 733: other form by either removing `no-' or adding it. 734: 735: `-ffloat-store' 736: Do not store floating point variables in registers, and inhibit 737: other options that might change whether a floating point value is 738: taken from a register or memory. 739: 740: This option prevents undesirable excess precision on machines such 741: as the 68000 where the floating registers (of the 68881) keep more 742: precision than a `double' is supposed to have. For most programs, 743: the excess precision does only good, but a few programs rely on the 744: precise definition of IEEE floating point. Use `-ffloat-store' for 745: such programs. 746: 747: `-fno-default-inline' 748: Do not make member functions inline by default merely because they 749: are defined inside the class scope (C++ only). Otherwise, when 750: you specify `-O', member functions defined inside class scope are 751: compiled inline by default; i.e., you don't need to add `inline' 752: in front of the member function name. 753: 754: `-fno-defer-pop' 755: Always pop the arguments to each function call as soon as that 756: function returns. For machines which must pop arguments after a 757: function call, the compiler normally lets arguments accumulate on 758: the stack for several function calls and pops them all at once. 759: 760: `-fforce-mem' 761: Force memory operands to be copied into registers before doing 1.1.1.8 root 762: arithmetic on them. This produces better code by making all memory 763: references potential common subexpressions. When they are not 764: common subexpressions, instruction combination should eliminate 765: the separate register-load. The `-O2' option turns on this option. 1.1.1.6 root 766: 767: `-fforce-addr' 768: Force memory address constants to be copied into registers before 769: doing arithmetic on them. This may produce better code just as 1.1.1.8 root 770: `-fforce-mem' may. 1.1.1.6 root 771: 772: `-fomit-frame-pointer' 773: Don't keep the frame pointer in a register for functions that 774: don't need one. This avoids the instructions to save, set up and 775: restore frame pointers; it also makes an extra register available 776: in many functions. *It also makes debugging impossible on some 777: machines.* 778: 779: On some machines, such as the Vax, this flag has no effect, because 780: the standard calling sequence automatically handles the frame 781: pointer and nothing is saved by pretending it doesn't exist. The 782: machine-description macro `FRAME_POINTER_REQUIRED' controls 783: whether a target machine supports this flag. *Note Registers::. 784: 785: `-fno-inline' 786: Don't pay attention to the `inline' keyword. Normally this option 787: is used to keep the compiler from expanding any functions inline. 788: Note that if you are not optimizing, no functions can be expanded 789: inline. 790: 791: `-finline-functions' 792: Integrate all simple functions into their callers. The compiler 793: heuristically decides which functions are simple enough to be worth 794: integrating in this way. 795: 796: If all calls to a given function are integrated, and the function 797: is declared `static', then the function is normally not output as 798: assembler code in its own right. 799: 800: `-fkeep-inline-functions' 801: Even if all calls to a given function are integrated, and the 802: function is declared `static', nevertheless output a separate 803: run-time callable version of the function. 804: 805: `-fno-function-cse' 806: Do not put function addresses in registers; make each instruction 807: that calls a constant function contain the function's address 808: explicitly. 809: 810: This option results in less efficient code, but some strange hacks 811: that alter the assembler output may be confused by the 812: optimizations performed when this option is not used. 813: 814: `-ffast-math' 815: This option allows GCC to violate some ANSI or IEEE rules and/or 816: specifications in the interest of optimizing code for speed. For 817: example, it allows the compiler to assume arguments to the `sqrt' 1.1.1.7 root 818: function are non-negative numbers and that no floating-point values 819: are NaNs. 1.1.1.6 root 820: 821: This option should never be turned on by any `-O' option since it 822: can result in incorrect output for programs which depend on an 823: exact implementation of IEEE or ANSI rules/specifications for math 824: functions. 825: 826: The following options control specific optimizations. The `-O2' 827: option turns on all of these optimizations except `-funroll-loops' and 828: `-funroll-all-loops'. On most machines, the `-O' option turns on the 829: `-fthread-jumps' and `-fdelayed-branch' options, but specific machines 830: may handle it differently. 831: 832: You can use the following flags in the rare cases when "fine-tuning" 833: of optimizations to be performed is desired. 834: 835: `-fstrength-reduce' 836: Perform the optimizations of loop strength reduction and 837: elimination of iteration variables. 838: 839: `-fthread-jumps' 840: Perform optimizations where we check to see if a jump branches to a 841: location where another comparison subsumed by the first is found. 842: If so, the first branch is redirected to either the destination of 843: the second branch or a point immediately following it, depending 844: on whether the condition is known to be true or false. 845: 846: `-fcse-follow-jumps' 847: In common subexpression elimination, scan through jump instructions 848: when the target of the jump is not reached by any other path. For 849: example, when CSE encounters an `if' statement with an `else' 850: clause, CSE will follow the jump when the condition tested is 851: false. 852: 853: `-fcse-skip-blocks' 854: This is similar to `-fcse-follow-jumps', but causes CSE to follow 855: jumps which conditionally skip over blocks. When CSE encounters a 856: simple `if' statement with no else clause, `-fcse-skip-blocks' 857: causes CSE to follow the jump around the body of the `if'. 858: 859: `-frerun-cse-after-loop' 860: Re-run common subexpression elimination after loop optimizations 861: has been performed. 862: 863: `-fexpensive-optimizations' 864: Perform a number of minor optimizations that are relatively 865: expensive. 866: 867: `-fdelayed-branch' 868: If supported for the target machine, attempt to reorder 869: instructions to exploit instruction slots available after delayed 870: branch instructions. 871: 872: `-fschedule-insns' 873: If supported for the target machine, attempt to reorder 874: instructions to eliminate execution stalls due to required data 875: being unavailable. This helps machines that have slow floating 876: point or memory load instructions by allowing other instructions 877: to be issued until the result of the load or floating point 878: instruction is required. 879: 880: `-fschedule-insns2' 881: Similar to `-fschedule-insns', but requests an additional pass of 882: instruction scheduling after register allocation has been done. 883: This is especially useful on machines with a relatively small 884: number of registers and where memory load instructions take more 885: than one cycle. 886: 887: `-fcaller-saves' 888: Enable values to be allocated in registers that will be clobbered 889: by function calls, by emitting extra instructions to save and 890: restore the registers around such calls. Such allocation is done 891: only when it seems to result in better code than would otherwise 892: be produced. 893: 894: This option is enabled by default on certain machines, usually 895: those which have no call-preserved registers to use instead. 896: 897: `-funroll-loops' 898: Perform the optimization of loop unrolling. This is only done for 899: loops whose number of iterations can be determined at compile time 900: or run time. `-funroll-loop' implies both `-fstrength-reduce' and 901: `-frerun-cse-after-loop'. 902: 903: `-funroll-all-loops' 904: Perform the optimization of loop unrolling. This is done for all 905: loops and usually makes programs run more slowly. 906: `-funroll-all-loops' implies `-fstrength-reduce' as well as 907: `-frerun-cse-after-loop'. 908: 909: `-fno-peephole' 910: Disable any machine-specific peephole optimizations. 911: 912: 1.1.1.5 root 913: File: gcc.info, Node: Preprocessor Options, Next: Assembler Options, Prev: Optimize Options, Up: Invoking GCC 914: 915: Options Controlling the Preprocessor 916: ==================================== 917: 918: These options control the C preprocessor, which is run on each C 919: source file before actual compilation. 920: 921: If you use the `-E' option, nothing is done except preprocessing. 922: Some of these options make sense only together with `-E' because they 923: cause the preprocessor output to be unsuitable for actual compilation. 924: 925: `-include FILE' 926: Process FILE as input before processing the regular input file. 927: In effect, the contents of FILE are compiled first. Any `-D' and 928: `-U' options on the command line are always processed before 929: `-include FILE', regardless of the order in which they are 930: written. All the `-include' and `-imacros' options are processed 931: in the order in which they are written. 932: 933: `-imacros FILE' 934: Process FILE as input, discarding the resulting output, before 935: processing the regular input file. Because the output generated 936: from FILE is discarded, the only effect of `-imacros FILE' is to 937: make the macros defined in FILE available for use in the main 938: input. 939: 940: Any `-D' and `-U' options on the command line are always processed 941: before `-imacros FILE', regardless of the order in which they are 942: written. All the `-include' and `-imacros' options are processed 943: in the order in which they are written. 944: 945: `-idirafter DIR' 946: Add the directory DIR to the second include path. The directories 947: on the second include path are searched when a header file is not 948: found in any of the directories in the main include path (the one 949: that `-I' adds to). 950: 951: `-iprefix PREFIX' 952: Specify PREFIX as the prefix for subsequent `-iwithprefix' options. 953: 954: `-iwithprefix DIR' 955: Add a directory to the second include path. The directory's name 956: is made by concatenating PREFIX and DIR, where PREFIX was 1.1.1.6 root 957: specified previously with `-iprefix'. If you have not specified a 958: prefix yet, the directory containing the installed passes of the 959: compiler is used as the default. 960: 961: `-iwithprefixbefore DIR' 962: Add a directory to the main include path. The directory's name is 963: made by concatenating PREFIX and DIR, as in the case of 964: `-iwithprefix'. 1.1.1.5 root 965: 1.1.1.7 root 966: `-isystem DIR' 967: Add a directory to the beginning of the second include path, 968: marking it as a system directory, so that it gets the same special 969: treatment as is applied to the standard system directories. 970: 1.1.1.5 root 971: `-nostdinc' 972: Do not search the standard system directories for header files. 973: Only the directories you have specified with `-I' options (and the 974: current directory, if appropriate) are searched. *Note Directory 975: Options::, for information on `-I'. 976: 977: By using both `-nostdinc' and `-I-', you can limit the include-file 978: search path to only those directories you specify explicitly. 979: 980: `-undef' 981: Do not predefine any nonstandard macros. (Including architecture 982: flags). 983: 984: `-E' 985: Run only the C preprocessor. Preprocess all the C source files 986: specified and output the results to standard output or to the 987: specified output file. 988: 989: `-C' 990: Tell the preprocessor not to discard comments. Used with the `-E' 991: option. 992: 993: `-P' 1.1.1.8 root 994: Tell the preprocessor not to generate `#line' directives. Used 995: with the `-E' option. 1.1.1.5 root 996: 997: `-M' 998: Tell the preprocessor to output a rule suitable for `make' 999: describing the dependencies of each object file. For each source 1000: file, the preprocessor outputs one `make'-rule whose target is the 1001: object file name for that source file and whose dependencies are 1002: all the `#include' header files it uses. This rule may be a 1003: single line or may be continued with `\'-newline if it is long. 1004: The list of rules is printed on standard output instead of the 1005: preprocessed C program. 1006: 1007: `-M' implies `-E'. 1008: 1009: Another way to specify output of a `make' rule is by setting the 1010: environment variable `DEPENDENCIES_OUTPUT' (*note Environment 1011: Variables::.). 1012: 1013: `-MM' 1014: Like `-M' but the output mentions only the user header files 1015: included with `#include "FILE"'. System header files included 1016: with `#include <FILE>' are omitted. 1017: 1018: `-MD' 1.1.1.7 root 1019: Like `-M' but the dependency information is written to a file made 1020: by replacing ".c" with ".d" at the end of the input file names. 1021: This is in addition to compiling the file as specified--`-MD' does 1022: not inhibit ordinary compilation the way `-M' does. 1023: 1024: In Mach, you can use the utility `md' to merge multiple dependency 1025: files into a single dependency file suitable for using with the 1026: `make' command. 1.1.1.5 root 1027: 1028: `-MMD' 1029: Like `-MD' except mention only user header files, not system 1030: header files. 1031: 1.1.1.7 root 1032: `-MG' 1033: Treat missing header files as generated files and assume they live 1034: in the same directory as the source file. If you specify `-MG', 1035: you must also specify either `-M' or `-MM'. `-MG' is not 1036: supported with `-MD' or `-MMD'. 1037: 1.1.1.5 root 1038: `-H' 1039: Print the name of each header file used, in addition to other 1040: normal activities. 1041: 1042: `-AQUESTION(ANSWER)' 1043: Assert the answer ANSWER for QUESTION, in case it is tested with a 1.1.1.8 root 1044: preprocessing conditional such as `#if #QUESTION(ANSWER)'. `-A-' 1.1.1.5 root 1045: disables the standard assertions that normally describe the target 1046: machine. 1047: 1048: `-DMACRO' 1049: Define macro MACRO with the string `1' as its definition. 1050: 1051: `-DMACRO=DEFN' 1052: Define macro MACRO as DEFN. All instances of `-D' on the command 1053: line are processed before any `-U' options. 1054: 1055: `-UMACRO' 1056: Undefine macro MACRO. `-U' options are evaluated after all `-D' 1057: options, but before any `-include' and `-imacros' options. 1058: 1059: `-dM' 1060: Tell the preprocessor to output only a list of the macro 1061: definitions that are in effect at the end of preprocessing. Used 1062: with the `-E' option. 1063: 1064: `-dD' 1065: Tell the preprocessing to pass all macro definitions into the 1066: output, in their proper sequence in the rest of the output. 1067: 1068: `-dN' 1069: Like `-dD' except that the macro arguments and contents are 1070: omitted. Only `#define NAME' is included in the output. 1071: 1072: `-trigraphs' 1.1.1.7 root 1073: Support ANSI C trigraphs. The `-ansi' option also has this effect. 1074: 1075: `-Wp,OPTION' 1076: Pass OPTION as an option to the preprocessor. If OPTION contains 1077: commas, it is split into multiple options at the commas. 1.1.1.5 root 1078: 1079: 1080: File: gcc.info, Node: Assembler Options, Next: Link Options, Prev: Preprocessor Options, Up: Invoking GCC 1081: 1082: Passing Options to the Assembler 1083: ================================ 1084: 1.1.1.7 root 1085: You can pass options to the assembler. 1086: 1.1.1.5 root 1087: `-Wa,OPTION' 1088: Pass OPTION as an option to the assembler. If OPTION contains 1089: commas, it is split into multiple options at the commas. 1090: 1091: 1.1.1.4 root 1092: File: gcc.info, Node: Link Options, Next: Directory Options, Prev: Assembler Options, Up: Invoking GCC 1093: 1094: Options for Linking 1095: =================== 1096: 1097: These options come into play when the compiler links object files 1098: into an executable output file. They are meaningless if the compiler is 1099: not doing a link step. 1100: 1101: `OBJECT-FILE-NAME' 1102: A file name that does not end in a special recognized suffix is 1103: considered to name an object file or library. (Object files are 1104: distinguished from libraries by the linker according to the file 1105: contents.) If linking is done, these object files are used as 1106: input to the linker. 1107: 1108: `-c' 1109: `-S' 1110: `-E' 1111: If any of these options is used, then the linker is not run, and 1112: object file names should not be used as arguments. *Note Overall 1113: Options::. 1114: 1115: `-lLIBRARY' 1116: Search the library named LIBRARY when linking. 1117: 1118: It makes a difference where in the command you write this option; 1119: the linker searches processes libraries and object files in the 1120: order they are specified. Thus, `foo.o -lz bar.o' searches 1121: library `z' after file `foo.o' but before `bar.o'. If `bar.o' 1122: refers to functions in `z', those functions may not be loaded. 1123: 1124: The linker searches a standard list of directories for the library, 1125: which is actually a file named `libLIBRARY.a'. The linker then 1126: uses this file as if it had been specified precisely by name. 1127: 1128: The directories searched include several standard system 1129: directories plus any that you specify with `-L'. 1130: 1131: Normally the files found this way are library files--archive files 1132: whose members are object files. The linker handles an archive 1133: file by scanning through it for members which define symbols that 1134: have so far been referenced but not defined. But if the file that 1135: is found is an ordinary object file, it is linked in the usual 1136: fashion. The only difference between using an `-l' option and 1137: specifying a file name is that `-l' surrounds LIBRARY with `lib' 1138: and `.a' and searches several directories. 1139: 1140: `-lobjc' 1.1.1.5 root 1141: You need this special case of the `-l' option in order to link an 1142: Objective C program. 1143: 1144: `-nostartfiles' 1145: Do not use the standard system startup files when linking. The 1.1.1.8 root 1146: standard system libraries are used normally, unless `-nostdlib' or 1147: `-nodefaultlibs' is used. 1.1.1.4 root 1148: 1.1.1.8 root 1149: `-nodefaultlibs' 1150: Do not use the standard system libraries when linking. Only the 1151: libraries you specify will be passed to the linker. The standard 1152: startup files are used normally, unless `-nostartfiles' is used. 1.1.1.4 root 1153: 1.1.1.8 root 1154: `-nostdlib' 1155: Do not use the standard system startup files or libraries when 1156: linking. No startup files and only the libraries you specify will 1157: be passed to the linker. 1158: 1159: One of the standard libraries bypassed by `-nostdlib' and 1160: `-nodefaultlibs' is `libgcc.a', a library of internal subroutines 1161: that GNU CC uses to overcome shortcomings of particular machines, 1162: or special needs for some languages. (*Note Interfacing to GNU CC 1163: Output: Interface, for more discussion of `libgcc.a'.) In most 1164: cases, you need `libgcc.a' even when you want to avoid other 1165: standard libraries. In other words, when you specify `-nostdlib' 1166: or `-nodefaultlibs' you should usually specify `-lgcc' as well. 1167: This ensures that you have no unresolved references to internal 1168: GNU CC library subroutines. (For example, `__main', used to 1169: ensure C++ constructors will be called; *note `collect2': 1170: Collect2..) 1.1.1.7 root 1171: 1172: `-s' 1173: Remove all symbol table and relocation information from the 1174: executable. 1175: 1.1.1.4 root 1176: `-static' 1177: On systems that support dynamic linking, this prevents linking 1178: with the shared libraries. On other systems, this option has no 1179: effect. 1180: 1181: `-shared' 1182: Produce a shared object which can then be linked with other 1183: objects to form an executable. Only a few systems support this 1184: option. 1185: 1186: `-symbolic' 1.1.1.5 root 1187: Bind references to global symbols when building a shared object. 1.1.1.4 root 1188: Warn about any unresolved references (unless overridden by the 1189: link editor option `-Xlinker -z -Xlinker defs'). Only a few 1190: systems support this option. 1191: 1192: `-Xlinker OPTION' 1193: Pass OPTION as an option to the linker. You can use this to 1194: supply system-specific linker options which GNU CC does not know 1195: how to recognize. 1196: 1197: If you want to pass an option that takes an argument, you must use 1198: `-Xlinker' twice, once for the option and once for the argument. 1199: For example, to pass `-assert definitions', you must write 1200: `-Xlinker -assert -Xlinker definitions'. It does not work to write 1201: `-Xlinker "-assert definitions"', because this passes the entire 1202: string as a single argument, which is not what the linker expects. 1203: 1204: `-Wl,OPTION' 1205: Pass OPTION as an option to the linker. If OPTION contains 1206: commas, it is split into multiple options at the commas. 1207: 1208: `-u SYMBOL' 1209: Pretend the symbol SYMBOL is undefined, to force linking of 1210: library modules to define it. You can use `-u' multiple times with 1211: different symbols to force loading of additional library modules. 1212:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.