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