Return to gcc.info-3 CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/gcc.info-3, revision 1.1.1.7

1.1.1.7 ! root        1: This is Info file gcc.info, produced by Makeinfo-1.55 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: 
1.1.1.5   root        6:    Published by the Free Software Foundation 675 Massachusetts Avenue
                      7: Cambridge, MA 02139 USA
                      8: 
1.1.1.7 ! root        9:    Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation,
        !            10: Inc.
1.1       root       11: 
1.1.1.3   root       12:    Permission is granted to make and distribute verbatim copies of this
                     13: manual provided the copyright notice and this permission notice are
                     14: preserved on all copies.
1.1       root       15: 
                     16:    Permission is granted to copy and distribute modified versions of
                     17: this manual under the conditions for verbatim copying, provided also
1.1.1.7 ! root       18: that the sections entitled "GNU General Public License," "Funding for
        !            19: Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
        !            20: included exactly as in the original, and provided that the entire
        !            21: resulting derived work is distributed under the terms of a permission
        !            22: notice identical to this one.
1.1       root       23: 
                     24:    Permission is granted to copy and distribute translations of this
                     25: manual into another language, under the above conditions for modified
1.1.1.3   root       26: versions, except that the sections entitled "GNU General Public
1.1.1.7 ! root       27: License," "Funding for Free Software," and "Protect Your Freedom--Fight
        !            28: `Look And Feel'", and this permission notice, may be included in
        !            29: translations approved by the Free Software Foundation instead of in the
        !            30: original English.
        !            31: 
        !            32: 
        !            33: File: gcc.info,  Node: Debugging Options,  Next: Optimize Options,  Prev: Warning Options,  Up: Invoking GCC
        !            34: 
        !            35: Options for Debugging Your Program or GNU CC
        !            36: ============================================
        !            37: 
        !            38:    GNU CC has various special options that are used for debugging
        !            39: either your program or GCC:
        !            40: 
        !            41: `-g'
        !            42:      Produce debugging information in the operating system's native
        !            43:      format (stabs, COFF, XCOFF, or DWARF).  GDB can work with this
        !            44:      debugging information.
        !            45: 
        !            46:      On most systems that use stabs format, `-g' enables use of extra
        !            47:      debugging information that only GDB can use; this extra information
        !            48:      makes debugging work better in GDB but will probably make other
        !            49:      debuggers crash or refuse to read the program.  If you want to
        !            50:      control for certain whether to generate the extra information, use
        !            51:      `-gstabs+', `-gstabs', `-gxcoff+', `-gxcoff', `-gdwarf+', or
        !            52:      `-gdwarf' (see below).
        !            53: 
        !            54:      Unlike most other C compilers, GNU CC allows you to use `-g' with
        !            55:      `-O'.  The shortcuts taken by optimized code may occasionally
        !            56:      produce surprising results: some variables you declared may not
        !            57:      exist at all; flow of control may briefly move where you did not
        !            58:      expect it; some statements may not be executed because they
        !            59:      compute constant results or their values were already at hand;
        !            60:      some statements may execute in different places because they were
        !            61:      moved out of loops.
        !            62: 
        !            63:      Nevertheless it proves possible to debug optimized output.  This
        !            64:      makes it reasonable to use the optimizer for programs that might
        !            65:      have bugs.
        !            66: 
        !            67:      The following options are useful when GNU CC is generated with the
        !            68:      capability for more than one debugging format.
        !            69: 
        !            70: `-ggdb'
        !            71:      Produce debugging information in the native format (if that is
        !            72:      supported), including GDB extensions if at all possible.
        !            73: 
        !            74: `-gstabs'
        !            75:      Produce debugging information in stabs format (if that is
        !            76:      supported), without GDB extensions.  This is the format used by
        !            77:      DBX on most BSD systems.  On MIPS, Alpha and System V Release 4
        !            78:      systems this option produces stabs debugging output which is not
        !            79:      understood by DBX or SDB.  On System V Release 4 systems this
        !            80:      option requires the GNU assembler.
        !            81: 
        !            82: `-gstabs+'
        !            83:      Produce debugging information in stabs format (if that is
        !            84:      supported), using GNU extensions understood only by the GNU
        !            85:      debugger (GDB).  The use of these extensions is likely to make
        !            86:      other debuggers crash or refuse to read the program.
        !            87: 
        !            88: `-gcoff'
        !            89:      Produce debugging information in COFF format (if that is
        !            90:      supported).  This is the format used by SDB on most System V
        !            91:      systems prior to System V Release 4.
        !            92: 
        !            93: `-gxcoff'
        !            94:      Produce debugging information in XCOFF format (if that is
        !            95:      supported).  This is the format used by the DBX debugger on IBM
        !            96:      RS/6000 systems.
        !            97: 
        !            98: `-gxcoff+'
        !            99:      Produce debugging information in XCOFF format (if that is
        !           100:      supported), using GNU extensions understood only by the GNU
        !           101:      debugger (GDB).  The use of these extensions is likely to make
        !           102:      other debuggers crash or refuse to read the program.
        !           103: 
        !           104: `-gdwarf'
        !           105:      Produce debugging information in DWARF format (if that is
        !           106:      supported).  This is the format used by SDB on most System V
        !           107:      Release 4 systems.
        !           108: 
        !           109: `-gdwarf+'
        !           110:      Produce debugging information in DWARF format (if that is
        !           111:      supported), using GNU extensions understood only by the GNU
        !           112:      debugger (GDB).  The use of these extensions is likely to make
        !           113:      other debuggers crash or refuse to read the program.
        !           114: 
        !           115: `-gLEVEL'
        !           116: `-ggdbLEVEL'
        !           117: `-gstabsLEVEL'
        !           118: `-gcoffLEVEL'
        !           119: `-gxcoffLEVEL'
        !           120: `-gdwarfLEVEL'
        !           121:      Request debugging information and also use LEVEL to specify how
        !           122:      much information.  The default level is 2.
        !           123: 
        !           124:      Level 1 produces minimal information, enough for making backtraces
        !           125:      in parts of the program that you don't plan to debug.  This
        !           126:      includes descriptions of functions and external variables, but no
        !           127:      information about local variables and no line numbers.
        !           128: 
        !           129:      Level 3 includes extra information, such as all the macro
        !           130:      definitions present in the program.  Some debuggers support macro
        !           131:      expansion when you use `-g3'.
        !           132: 
        !           133: `-p'
        !           134:      Generate extra code to write profile information suitable for the
        !           135:      analysis program `prof'.  You must use this option when compiling
        !           136:      the source files you want data about, and you must also use it when
        !           137:      linking.
        !           138: 
        !           139: `-pg'
        !           140:      Generate extra code to write profile information suitable for the
        !           141:      analysis program `gprof'.  You must use this option when compiling
        !           142:      the source files you want data about, and you must also use it when
        !           143:      linking.
        !           144: 
        !           145: `-a'
        !           146:      Generate extra code to write profile information for basic blocks,
        !           147:      which will record the number of times each basic block is
        !           148:      executed, the basic block start address, and the function name
        !           149:      containing the basic block.  If `-g' is used, the line number and
        !           150:      filename of the start of the basic block will also be recorded.
        !           151:      If not overridden by the machine description, the default action is
        !           152:      to append to the text file `bb.out'.
        !           153: 
        !           154:      This data could be analyzed by a program like `tcov'.  Note,
        !           155:      however, that the format of the data is not what `tcov' expects.
        !           156:      Eventually GNU `gprof' should be extended to process this data.
        !           157: 
        !           158: `-dLETTERS'
        !           159:      Says to make debugging dumps during compilation at times specified
        !           160:      by LETTERS.  This is used for debugging the compiler.  The file
        !           161:      names for most of the dumps are made by appending a word to the
        !           162:      source file name (e.g.  `foo.c.rtl' or `foo.c.jump').  Here are the
        !           163:      possible letters for use in LETTERS, and their meanings:
        !           164: 
        !           165:     `M'
        !           166:           Dump all macro definitions, at the end of preprocessing, and
        !           167:           write no output.
        !           168: 
        !           169:     `N'
        !           170:           Dump all macro names, at the end of preprocessing.
        !           171: 
        !           172:     `D'
        !           173:           Dump all macro definitions, at the end of preprocessing, in
        !           174:           addition to normal output.
        !           175: 
        !           176:     `y'
        !           177:           Dump debugging information during parsing, to standard error.
        !           178: 
        !           179:     `r'
        !           180:           Dump after RTL generation, to `FILE.rtl'.
        !           181: 
        !           182:     `x'
        !           183:           Just generate RTL for a function instead of compiling it.
        !           184:           Usually used with `r'.
        !           185: 
        !           186:     `j'
        !           187:           Dump after first jump optimization, to `FILE.jump'.
        !           188: 
        !           189:     `s'
        !           190:           Dump after CSE (including the jump optimization that sometimes
        !           191:           follows CSE), to `FILE.cse'.
        !           192: 
        !           193:     `L'
        !           194:           Dump after loop optimization, to `FILE.loop'.
        !           195: 
        !           196:     `t'
        !           197:           Dump after the second CSE pass (including the jump
        !           198:           optimization that sometimes follows CSE), to `FILE.cse2'.
        !           199: 
        !           200:     `f'
        !           201:           Dump after flow analysis, to `FILE.flow'.
        !           202: 
        !           203:     `c'
        !           204:           Dump after instruction combination, to the file
        !           205:           `FILE.combine'.
        !           206: 
        !           207:     `S'
        !           208:           Dump after the first instruction scheduling pass, to
        !           209:           `FILE.sched'.
        !           210: 
        !           211:     `l'
        !           212:           Dump after local register allocation, to `FILE.lreg'.
        !           213: 
        !           214:     `g'
        !           215:           Dump after global register allocation, to `FILE.greg'.
        !           216: 
        !           217:     `R'
        !           218:           Dump after the second instruction scheduling pass, to
        !           219:           `FILE.sched2'.
        !           220: 
        !           221:     `J'
        !           222:           Dump after last jump optimization, to `FILE.jump2'.
        !           223: 
        !           224:     `d'
        !           225:           Dump after delayed branch scheduling, to `FILE.dbr'.
        !           226: 
        !           227:     `k'
        !           228:           Dump after conversion from registers to stack, to
        !           229:           `FILE.stack'.
        !           230: 
        !           231:     `a'
        !           232:           Produce all the dumps listed above.
        !           233: 
        !           234:     `m'
        !           235:           Print statistics on memory usage, at the end of the run, to
        !           236:           standard error.
        !           237: 
        !           238:     `p'
        !           239:           Annotate the assembler output with a comment indicating which
        !           240:           pattern and alternative was used.
        !           241: 
        !           242: `-fpretend-float'
        !           243:      When running a cross-compiler, pretend that the target machine
        !           244:      uses the same floating point format as the host machine.  This
        !           245:      causes incorrect output of the actual floating constants, but the
        !           246:      actual instruction sequence will probably be the same as GNU CC
        !           247:      would make when running on the target machine.
        !           248: 
        !           249: `-save-temps'
        !           250:      Store the usual "temporary" intermediate files permanently; place
        !           251:      them in the current directory and name them based on the source
        !           252:      file.  Thus, compiling `foo.c' with `-c -save-temps' would produce
        !           253:      files `foo.i' and `foo.s', as well as `foo.o'.
        !           254: 
        !           255: `-print-file-name=LIBRARY'
        !           256:      Print the full absolute name of the library file LIBRARY that
        !           257:      would be used when linking--and don't do anything else.  With this
        !           258:      option, GNU CC does not compile or link anything; it just prints
        !           259:      the file name.
        !           260: 
        !           261: `-print-prog-name=PROGRAM'
        !           262:      Like `-print-file-name', but searches for a program such as `cpp'.
        !           263: 
        !           264: `-print-libgcc-file-name'
        !           265:      Same as `-print-file-name=libgcc.a'.
        !           266: 
        !           267:      This is useful when you use `-nostdlib' but you do want to link
        !           268:      with `libgcc.a'.  You can do
        !           269: 
        !           270:           gcc -nostdlib FILES... `gcc -print-libgcc-file-name`
1.1.1.4   root      271: 
                    272: 
1.1.1.6   root      273: File: gcc.info,  Node: Optimize Options,  Next: Preprocessor Options,  Prev: Debugging Options,  Up: Invoking GCC
                    274: 
                    275: Options That Control Optimization
                    276: =================================
                    277: 
                    278:    These options control various sorts of optimizations:
                    279: 
                    280: `-O'
                    281: `-O1'
                    282:      Optimize.  Optimizing compilation takes somewhat more time, and a
                    283:      lot more memory for a large function.
                    284: 
                    285:      Without `-O', the compiler's goal is to reduce the cost of
                    286:      compilation and to make debugging produce the expected results.
                    287:      Statements are independent: if you stop the program with a
                    288:      breakpoint between statements, you can then assign a new value to
                    289:      any variable or change the program counter to any other statement
                    290:      in the function and get exactly the results you would expect from
                    291:      the source code.
                    292: 
1.1.1.7 ! root      293:      Without `-O', the compiler only allocates variables declared
        !           294:      `register' in registers.  The resulting compiled code is a little
        !           295:      worse than produced by PCC without `-O'.
1.1.1.6   root      296: 
                    297:      With `-O', the compiler tries to reduce code size and execution
                    298:      time.
                    299: 
1.1.1.7 ! root      300:      When you specify `-O', the compiler turns on `-fthread-jumps' and
        !           301:      `-fdefer-pop' on all machines.  The compiler turns on
        !           302:      `-fdelayed-branch' on machines that have delay slots, and
        !           303:      `-fomit-frame-pointer' on machines that can support debugging even
        !           304:      without a frame pointer.  On some machines the compiler also turns
        !           305:      on other flags.
1.1.1.6   root      306: 
                    307: `-O2'
1.1.1.7 ! root      308:      Optimize even more.  GNU CC performs nearly all supported
        !           309:      optimizations that do not involve a space-speed tradeoff.  The
        !           310:      compiler does not perform loop unrolling or function inlining when
        !           311:      you specify `-O2'.  As compared to `-O', this option increases
        !           312:      both compilation time and the performance of the generated code.
1.1.1.6   root      313: 
                    314:      `-O2' turns on all optional optimizations except for loop unrolling
1.1.1.7 ! root      315:      and function inlining.  It also turns on frame pointer elimination
        !           316:      on machines where doing so does not interfer with debugging.
        !           317: 
        !           318: `-O3'
        !           319:      Optimize yet more.  `-O3' turns on all optimizations specified by
        !           320:      `-O2' and also turns on the `inline-functions' option.
1.1.1.6   root      321: 
                    322: `-O0'
                    323:      Do not optimize.
                    324: 
                    325:      If you use multiple `-O' options, with or without level numbers,
                    326:      the last such option is the one that is effective.
                    327: 
                    328:    Options of the form `-fFLAG' specify machine-independent flags.
                    329: Most flags have both positive and negative forms; the negative form of
                    330: `-ffoo' would be `-fno-foo'.  In the table below, only one of the forms
                    331: is listed--the one which is not the default.  You can figure out the
                    332: other form by either removing `no-' or adding it.
                    333: 
                    334: `-ffloat-store'
                    335:      Do not store floating point variables in registers, and inhibit
                    336:      other options that might change whether a floating point value is
                    337:      taken from a register or memory.
                    338: 
                    339:      This option prevents undesirable excess precision on machines such
                    340:      as the 68000 where the floating registers (of the 68881) keep more
                    341:      precision than a `double' is supposed to have.  For most programs,
                    342:      the excess precision does only good, but a few programs rely on the
                    343:      precise definition of IEEE floating point.  Use `-ffloat-store' for
                    344:      such programs.
                    345: 
                    346: `-fno-default-inline'
                    347:      Do not make member functions inline by default merely because they
                    348:      are defined inside the class scope (C++ only).  Otherwise, when
                    349:      you specify `-O', member functions defined inside class scope are
                    350:      compiled inline by default; i.e., you don't need to add `inline'
                    351:      in front of the member function name.
                    352: 
                    353: `-fno-defer-pop'
                    354:      Always pop the arguments to each function call as soon as that
                    355:      function returns.  For machines which must pop arguments after a
                    356:      function call, the compiler normally lets arguments accumulate on
                    357:      the stack for several function calls and pops them all at once.
                    358: 
                    359: `-fforce-mem'
                    360:      Force memory operands to be copied into registers before doing
                    361:      arithmetic on them.  This may produce better code by making all
                    362:      memory references potential common subexpressions.  When they are
                    363:      not common subexpressions, instruction combination should
                    364:      eliminate the separate register-load.  I am interested in hearing
                    365:      about the difference this makes.
                    366: 
                    367: `-fforce-addr'
                    368:      Force memory address constants to be copied into registers before
                    369:      doing arithmetic on them.  This may produce better code just as
                    370:      `-fforce-mem' may.  I am interested in hearing about the
                    371:      difference this makes.
                    372: 
                    373: `-fomit-frame-pointer'
                    374:      Don't keep the frame pointer in a register for functions that
                    375:      don't need one.  This avoids the instructions to save, set up and
                    376:      restore frame pointers; it also makes an extra register available
                    377:      in many functions.  *It also makes debugging impossible on some
                    378:      machines.*
                    379: 
                    380:      On some machines, such as the Vax, this flag has no effect, because
                    381:      the standard calling sequence automatically handles the frame
                    382:      pointer and nothing is saved by pretending it doesn't exist.  The
                    383:      machine-description macro `FRAME_POINTER_REQUIRED' controls
                    384:      whether a target machine supports this flag.  *Note Registers::.
                    385: 
                    386: `-fno-inline'
                    387:      Don't pay attention to the `inline' keyword.  Normally this option
                    388:      is used to keep the compiler from expanding any functions inline.
                    389:      Note that if you are not optimizing, no functions can be expanded
                    390:      inline.
                    391: 
                    392: `-finline-functions'
                    393:      Integrate all simple functions into their callers.  The compiler
                    394:      heuristically decides which functions are simple enough to be worth
                    395:      integrating in this way.
                    396: 
                    397:      If all calls to a given function are integrated, and the function
                    398:      is declared `static', then the function is normally not output as
                    399:      assembler code in its own right.
                    400: 
                    401: `-fkeep-inline-functions'
                    402:      Even if all calls to a given function are integrated, and the
                    403:      function is declared `static', nevertheless output a separate
                    404:      run-time callable version of the function.
                    405: 
                    406: `-fno-function-cse'
                    407:      Do not put function addresses in registers; make each instruction
                    408:      that calls a constant function contain the function's address
                    409:      explicitly.
                    410: 
                    411:      This option results in less efficient code, but some strange hacks
                    412:      that alter the assembler output may be confused by the
                    413:      optimizations performed when this option is not used.
                    414: 
                    415: `-ffast-math'
                    416:      This option allows GCC to violate some ANSI or IEEE rules and/or
                    417:      specifications in the interest of optimizing code for speed.  For
                    418:      example, it allows the compiler to assume arguments to the `sqrt'
1.1.1.7 ! root      419:      function are non-negative numbers and that no floating-point values
        !           420:      are NaNs.
1.1.1.6   root      421: 
                    422:      This option should never be turned on by any `-O' option since it
                    423:      can result in incorrect output for programs which depend on an
                    424:      exact implementation of IEEE or ANSI rules/specifications for math
                    425:      functions.
                    426: 
                    427:    The following options control specific optimizations.  The `-O2'
                    428: option turns on all of these optimizations except `-funroll-loops' and
                    429: `-funroll-all-loops'.  On most machines, the `-O' option turns on the
                    430: `-fthread-jumps' and `-fdelayed-branch' options, but specific machines
                    431: may handle it differently.
                    432: 
                    433:    You can use the following flags in the rare cases when "fine-tuning"
                    434: of optimizations to be performed is desired.
                    435: 
                    436: `-fstrength-reduce'
                    437:      Perform the optimizations of loop strength reduction and
                    438:      elimination of iteration variables.
                    439: 
                    440: `-fthread-jumps'
                    441:      Perform optimizations where we check to see if a jump branches to a
                    442:      location where another comparison subsumed by the first is found.
                    443:      If so, the first branch is redirected to either the destination of
                    444:      the second branch or a point immediately following it, depending
                    445:      on whether the condition is known to be true or false.
                    446: 
                    447: `-fcse-follow-jumps'
                    448:      In common subexpression elimination, scan through jump instructions
                    449:      when the target of the jump is not reached by any other path.  For
                    450:      example, when CSE encounters an `if' statement with an `else'
                    451:      clause, CSE will follow the jump when the condition tested is
                    452:      false.
                    453: 
                    454: `-fcse-skip-blocks'
                    455:      This is similar to `-fcse-follow-jumps', but causes CSE to follow
                    456:      jumps which conditionally skip over blocks.  When CSE encounters a
                    457:      simple `if' statement with no else clause, `-fcse-skip-blocks'
                    458:      causes CSE to follow the jump around the body of the `if'.
                    459: 
                    460: `-frerun-cse-after-loop'
                    461:      Re-run common subexpression elimination after loop optimizations
                    462:      has been performed.
                    463: 
                    464: `-fexpensive-optimizations'
                    465:      Perform a number of minor optimizations that are relatively
                    466:      expensive.
                    467: 
                    468: `-fdelayed-branch'
                    469:      If supported for the target machine, attempt to reorder
                    470:      instructions to exploit instruction slots available after delayed
                    471:      branch instructions.
                    472: 
                    473: `-fschedule-insns'
                    474:      If supported for the target machine, attempt to reorder
                    475:      instructions to eliminate execution stalls due to required data
                    476:      being unavailable.  This helps machines that have slow floating
                    477:      point or memory load instructions by allowing other instructions
                    478:      to be issued until the result of the load or floating point
                    479:      instruction is required.
                    480: 
                    481: `-fschedule-insns2'
                    482:      Similar to `-fschedule-insns', but requests an additional pass of
                    483:      instruction scheduling after register allocation has been done.
                    484:      This is especially useful on machines with a relatively small
                    485:      number of registers and where memory load instructions take more
                    486:      than one cycle.
                    487: 
                    488: `-fcaller-saves'
                    489:      Enable values to be allocated in registers that will be clobbered
                    490:      by function calls, by emitting extra instructions to save and
                    491:      restore the registers around such calls.  Such allocation is done
                    492:      only when it seems to result in better code than would otherwise
                    493:      be produced.
                    494: 
                    495:      This option is enabled by default on certain machines, usually
                    496:      those which have no call-preserved registers to use instead.
                    497: 
                    498: `-funroll-loops'
                    499:      Perform the optimization of loop unrolling.  This is only done for
                    500:      loops whose number of iterations can be determined at compile time
                    501:      or run time.  `-funroll-loop' implies both `-fstrength-reduce' and
                    502:      `-frerun-cse-after-loop'.
                    503: 
                    504: `-funroll-all-loops'
                    505:      Perform the optimization of loop unrolling.  This is done for all
                    506:      loops and usually makes programs run more slowly.
                    507:      `-funroll-all-loops' implies `-fstrength-reduce' as well as
                    508:      `-frerun-cse-after-loop'.
                    509: 
                    510: `-fno-peephole'
                    511:      Disable any machine-specific peephole optimizations.
                    512: 
                    513: 
1.1.1.5   root      514: File: gcc.info,  Node: Preprocessor Options,  Next: Assembler Options,  Prev: Optimize Options,  Up: Invoking GCC
                    515: 
                    516: Options Controlling the Preprocessor
                    517: ====================================
                    518: 
                    519:    These options control the C preprocessor, which is run on each C
                    520: source file before actual compilation.
                    521: 
                    522:    If you use the `-E' option, nothing is done except preprocessing.
                    523: Some of these options make sense only together with `-E' because they
                    524: cause the preprocessor output to be unsuitable for actual compilation.
                    525: 
                    526: `-include FILE'
                    527:      Process FILE as input before processing the regular input file.
                    528:      In effect, the contents of FILE are compiled first.  Any `-D' and
                    529:      `-U' options on the command line are always processed before
                    530:      `-include FILE', regardless of the order in which they are
                    531:      written.  All the `-include' and `-imacros' options are processed
                    532:      in the order in which they are written.
                    533: 
                    534: `-imacros FILE'
                    535:      Process FILE as input, discarding the resulting output, before
                    536:      processing the regular input file.  Because the output generated
                    537:      from FILE is discarded, the only effect of `-imacros FILE' is to
                    538:      make the macros defined in FILE available for use in the main
                    539:      input.
                    540: 
                    541:      Any `-D' and `-U' options on the command line are always processed
                    542:      before `-imacros FILE', regardless of the order in which they are
                    543:      written.  All the `-include' and `-imacros' options are processed
                    544:      in the order in which they are written.
                    545: 
                    546: `-idirafter DIR'
                    547:      Add the directory DIR to the second include path.  The directories
                    548:      on the second include path are searched when a header file is not
                    549:      found in any of the directories in the main include path (the one
                    550:      that `-I' adds to).
                    551: 
                    552: `-iprefix PREFIX'
                    553:      Specify PREFIX as the prefix for subsequent `-iwithprefix' options.
                    554: 
                    555: `-iwithprefix DIR'
                    556:      Add a directory to the second include path.  The directory's name
                    557:      is made by concatenating PREFIX and DIR, where PREFIX was
1.1.1.6   root      558:      specified previously with `-iprefix'.  If you have not specified a
                    559:      prefix yet, the directory containing the installed passes of the
                    560:      compiler is used as the default.
                    561: 
                    562: `-iwithprefixbefore DIR'
                    563:      Add a directory to the main include path.  The directory's name is
                    564:      made by concatenating PREFIX and DIR, as in the case of
                    565:      `-iwithprefix'.
1.1.1.5   root      566: 
1.1.1.7 ! root      567: `-isystem DIR'
        !           568:      Add a directory to the beginning of the second include path,
        !           569:      marking it as a system directory, so that it gets the same special
        !           570:      treatment as is applied to the standard system directories.
        !           571: 
1.1.1.5   root      572: `-nostdinc'
                    573:      Do not search the standard system directories for header files.
                    574:      Only the directories you have specified with `-I' options (and the
                    575:      current directory, if appropriate) are searched.  *Note Directory
                    576:      Options::, for information on `-I'.
                    577: 
                    578:      By using both `-nostdinc' and `-I-', you can limit the include-file
                    579:      search path to only those directories you specify explicitly.
                    580: 
                    581: `-undef'
                    582:      Do not predefine any nonstandard macros.  (Including architecture
                    583:      flags).
                    584: 
                    585: `-E'
                    586:      Run only the C preprocessor.  Preprocess all the C source files
                    587:      specified and output the results to standard output or to the
                    588:      specified output file.
                    589: 
                    590: `-C'
                    591:      Tell the preprocessor not to discard comments.  Used with the `-E'
                    592:      option.
                    593: 
                    594: `-P'
                    595:      Tell the preprocessor not to generate `#line' commands.  Used with
                    596:      the `-E' option.
                    597: 
                    598: `-M'
                    599:      Tell the preprocessor to output a rule suitable for `make'
                    600:      describing the dependencies of each object file.  For each source
                    601:      file, the preprocessor outputs one `make'-rule whose target is the
                    602:      object file name for that source file and whose dependencies are
                    603:      all the `#include' header files it uses.  This rule may be a
                    604:      single line or may be continued with `\'-newline if it is long.
                    605:      The list of rules is printed on standard output instead of the
                    606:      preprocessed C program.
                    607: 
                    608:      `-M' implies `-E'.
                    609: 
                    610:      Another way to specify output of a `make' rule is by setting the
                    611:      environment variable `DEPENDENCIES_OUTPUT' (*note Environment
                    612:      Variables::.).
                    613: 
                    614: `-MM'
                    615:      Like `-M' but the output mentions only the user header files
                    616:      included with `#include "FILE"'.  System header files included
                    617:      with `#include <FILE>' are omitted.
                    618: 
                    619: `-MD'
1.1.1.7 ! root      620:      Like `-M' but the dependency information is written to a file made
        !           621:      by replacing ".c" with ".d" at the end of the input file names.
        !           622:      This is in addition to compiling the file as specified--`-MD' does
        !           623:      not inhibit ordinary compilation the way `-M' does.
        !           624: 
        !           625:      In Mach, you can use the utility `md' to merge multiple dependency
        !           626:      files into a single dependency file suitable for using with the
        !           627:      `make' command.
1.1.1.5   root      628: 
                    629: `-MMD'
                    630:      Like `-MD' except mention only user header files, not system
                    631:      header files.
                    632: 
1.1.1.7 ! root      633: `-MG'
        !           634:      Treat missing header files as generated files and assume they live
        !           635:      in the same directory as the source file.  If you specify `-MG',
        !           636:      you must also specify either `-M' or `-MM'.  `-MG' is not
        !           637:      supported with `-MD' or `-MMD'.
        !           638: 
1.1.1.5   root      639: `-H'
                    640:      Print the name of each header file used, in addition to other
                    641:      normal activities.
                    642: 
                    643: `-AQUESTION(ANSWER)'
                    644:      Assert the answer ANSWER for QUESTION, in case it is tested with a
                    645:      preprocessor conditional such as `#if #QUESTION(ANSWER)'.  `-A-'
                    646:      disables the standard assertions that normally describe the target
                    647:      machine.
                    648: 
                    649: `-DMACRO'
                    650:      Define macro MACRO with the string `1' as its definition.
                    651: 
                    652: `-DMACRO=DEFN'
                    653:      Define macro MACRO as DEFN.  All instances of `-D' on the command
                    654:      line are processed before any `-U' options.
                    655: 
                    656: `-UMACRO'
                    657:      Undefine macro MACRO.  `-U' options are evaluated after all `-D'
                    658:      options, but before any `-include' and `-imacros' options.
                    659: 
                    660: `-dM'
                    661:      Tell the preprocessor to output only a list of the macro
                    662:      definitions that are in effect at the end of preprocessing.  Used
                    663:      with the `-E' option.
                    664: 
                    665: `-dD'
                    666:      Tell the preprocessing to pass all macro definitions into the
                    667:      output, in their proper sequence in the rest of the output.
                    668: 
                    669: `-dN'
                    670:      Like `-dD' except that the macro arguments and contents are
                    671:      omitted.  Only `#define NAME' is included in the output.
                    672: 
                    673: `-trigraphs'
1.1.1.7 ! root      674:      Support ANSI C trigraphs.  The `-ansi' option also has this effect.
        !           675: 
        !           676: `-Wp,OPTION'
        !           677:      Pass OPTION as an option to the preprocessor.  If OPTION contains
        !           678:      commas, it is split into multiple options at the commas.
1.1.1.5   root      679: 
                    680: 
                    681: File: gcc.info,  Node: Assembler Options,  Next: Link Options,  Prev: Preprocessor Options,  Up: Invoking GCC
                    682: 
                    683: Passing Options to the Assembler
                    684: ================================
                    685: 
1.1.1.7 ! root      686:    You can pass options to the assembler.
        !           687: 
1.1.1.5   root      688: `-Wa,OPTION'
                    689:      Pass OPTION as an option to the assembler.  If OPTION contains
                    690:      commas, it is split into multiple options at the commas.
                    691: 
                    692: 
1.1.1.4   root      693: File: gcc.info,  Node: Link Options,  Next: Directory Options,  Prev: Assembler Options,  Up: Invoking GCC
                    694: 
                    695: Options for Linking
                    696: ===================
                    697: 
                    698:    These options come into play when the compiler links object files
                    699: into an executable output file.  They are meaningless if the compiler is
                    700: not doing a link step.
                    701: 
                    702: `OBJECT-FILE-NAME'
                    703:      A file name that does not end in a special recognized suffix is
                    704:      considered to name an object file or library.  (Object files are
                    705:      distinguished from libraries by the linker according to the file
                    706:      contents.)  If linking is done, these object files are used as
                    707:      input to the linker.
                    708: 
                    709: `-c'
                    710: `-S'
                    711: `-E'
                    712:      If any of these options is used, then the linker is not run, and
                    713:      object file names should not be used as arguments.  *Note Overall
                    714:      Options::.
                    715: 
                    716: `-lLIBRARY'
                    717:      Search the library named LIBRARY when linking.
                    718: 
                    719:      It makes a difference where in the command you write this option;
                    720:      the linker searches processes libraries and object files in the
                    721:      order they are specified.  Thus, `foo.o -lz bar.o' searches
                    722:      library `z' after file `foo.o' but before `bar.o'.  If `bar.o'
                    723:      refers to functions in `z', those functions may not be loaded.
                    724: 
                    725:      The linker searches a standard list of directories for the library,
                    726:      which is actually a file named `libLIBRARY.a'.  The linker then
                    727:      uses this file as if it had been specified precisely by name.
                    728: 
                    729:      The directories searched include several standard system
                    730:      directories plus any that you specify with `-L'.
                    731: 
                    732:      Normally the files found this way are library files--archive files
                    733:      whose members are object files.  The linker handles an archive
                    734:      file by scanning through it for members which define symbols that
                    735:      have so far been referenced but not defined.  But if the file that
                    736:      is found is an ordinary object file, it is linked in the usual
                    737:      fashion.  The only difference between using an `-l' option and
                    738:      specifying a file name is that `-l' surrounds LIBRARY with `lib'
                    739:      and `.a' and searches several directories.
                    740: 
                    741: `-lobjc'
1.1.1.5   root      742:      You need this special case of the `-l' option in order to link an
                    743:      Objective C program.
                    744: 
                    745: `-nostartfiles'
                    746:      Do not use the standard system startup files when linking.  The
                    747:      standard libraries are used normally.
1.1.1.4   root      748: 
                    749: `-nostdlib'
1.1.1.7 ! root      750:      Do not use the standard system libraries and startup files when
1.1.1.5   root      751:      linking.  Only the files you specify will be passed to the linker.
1.1.1.4   root      752: 
1.1.1.7 ! root      753:      One of the standard libraries bypassed by `-nostdlib' is
        !           754:      `libgcc.a', a library of internal subroutines that GNU CC uses to
        !           755:      overcome shortcomings of particular machines, or special needs for
        !           756:      some languages.  (*Note Interfacing to GNU CC Output: Interface,
        !           757:      for more discussion of `libgcc.a'.) In most cases, you need
        !           758:      `libgcc.a' even when you want to avoid other standard libraries.
        !           759:      In other words, when you specify `-nostdlib' you should usually
        !           760:      specify `-lgcc' as well.  This ensures that you have no unresolved
        !           761:      references to internal GNU CC library subroutines.  (For example,
        !           762:      `__main', used to ensure C++ constructors will be called; *note
        !           763:      `collect2': Collect2..)
        !           764: 
        !           765: `-s'
        !           766:      Remove all symbol table and relocation information from the
        !           767:      executable.
        !           768: 
1.1.1.4   root      769: `-static'
                    770:      On systems that support dynamic linking, this prevents linking
                    771:      with the shared libraries.  On other systems, this option has no
                    772:      effect.
                    773: 
                    774: `-shared'
                    775:      Produce a shared object which can then be linked with other
                    776:      objects to form an executable.  Only a few systems support this
                    777:      option.
                    778: 
                    779: `-symbolic'
1.1.1.5   root      780:      Bind references to global symbols when building a shared object.
1.1.1.4   root      781:      Warn about any unresolved references (unless overridden by the
                    782:      link editor option `-Xlinker -z -Xlinker defs').  Only a few
                    783:      systems support this option.
                    784: 
                    785: `-Xlinker OPTION'
                    786:      Pass OPTION as an option to the linker.  You can use this to
                    787:      supply system-specific linker options which GNU CC does not know
                    788:      how to recognize.
                    789: 
                    790:      If you want to pass an option that takes an argument, you must use
                    791:      `-Xlinker' twice, once for the option and once for the argument.
                    792:      For example, to pass `-assert definitions', you must write
                    793:      `-Xlinker -assert -Xlinker definitions'.  It does not work to write
                    794:      `-Xlinker "-assert definitions"', because this passes the entire
                    795:      string as a single argument, which is not what the linker expects.
                    796: 
                    797: `-Wl,OPTION'
                    798:      Pass OPTION as an option to the linker.  If OPTION contains
                    799:      commas, it is split into multiple options at the commas.
                    800: 
                    801: `-u SYMBOL'
                    802:      Pretend the symbol SYMBOL is undefined, to force linking of
                    803:      library modules to define it.  You can use `-u' multiple times with
                    804:      different symbols to force loading of additional library modules.
                    805: 
                    806: 
                    807: File: gcc.info,  Node: Directory Options,  Next: Target Options,  Prev: Link Options,  Up: Invoking GCC
                    808: 
                    809: Options for Directory Search
                    810: ============================
                    811: 
                    812:    These options specify directories to search for header files, for
                    813: libraries and for parts of the compiler:
                    814: 
                    815: `-IDIR'
                    816:      Append directory DIR to the list of directories searched for
                    817:      include files.
                    818: 
                    819: `-I-'
                    820:      Any directories you specify with `-I' options before the `-I-'
                    821:      option are searched only for the case of `#include "FILE"'; they
                    822:      are not searched for `#include <FILE>'.
                    823: 
                    824:      If additional directories are specified with `-I' options after
                    825:      the `-I-', these directories are searched for all `#include'
                    826:      directives.  (Ordinarily *all* `-I' directories are used this way.)
                    827: 
                    828:      In addition, the `-I-' option inhibits the use of the current
                    829:      directory (where the current input file came from) as the first
                    830:      search directory for `#include "FILE"'.  There is no way to
                    831:      override this effect of `-I-'.  With `-I.' you can specify
                    832:      searching the directory which was current when the compiler was
                    833:      invoked.  That is not exactly the same as what the preprocessor
                    834:      does by default, but it is often satisfactory.
                    835: 
                    836:      `-I-' does not inhibit the use of the standard system directories
                    837:      for header files.  Thus, `-I-' and `-nostdinc' are independent.
                    838: 
                    839: `-LDIR'
                    840:      Add directory DIR to the list of directories to be searched for
                    841:      `-l'.
                    842: 
                    843: `-BPREFIX'
1.1.1.7 ! root      844:      This option specifies where to find the executables, libraries,
        !           845:      include files, and data files of the compiler itself.
1.1.1.4   root      846: 
                    847:      The compiler driver program runs one or more of the subprograms
                    848:      `cpp', `cc1', `as' and `ld'.  It tries PREFIX as a prefix for each
                    849:      program it tries to run, both with and without `MACHINE/VERSION/'
                    850:      (*note Target Options::.).
                    851: 
                    852:      For each subprogram to be run, the compiler driver first tries the
                    853:      `-B' prefix, if any.  If that name is not found, or if `-B' was
                    854:      not specified, the driver tries two standard prefixes, which are
                    855:      `/usr/lib/gcc/' and `/usr/local/lib/gcc-lib/'.  If neither of
                    856:      those results in a file name that is found, the unmodified program
                    857:      name is searched for using the directories specified in your
                    858:      `PATH' environment variable.
                    859: 
                    860:      `-B' prefixes that effectively specify directory names also apply
                    861:      to libraries in the linker, because the compiler translates these
1.1.1.7 ! root      862:      options into `-L' options for the linker.  They also apply to
        !           863:      includes files in the preprocessor, because the compiler
        !           864:      translates these options into `-isystem' options for the
        !           865:      preprocessor.  In this case, the compiler appends `include' to the
        !           866:      prefix.
1.1.1.4   root      867: 
                    868:      The run-time support file `libgcc.a' can also be searched for using
                    869:      the `-B' prefix, if needed.  If it is not found there, the two
                    870:      standard prefixes above are tried, and that is all.  The file is
                    871:      left out of the link if it is not found by those means.
                    872: 
                    873:      Another way to specify a prefix much like the `-B' prefix is to use
                    874:      the environment variable `GCC_EXEC_PREFIX'.  *Note Environment
                    875:      Variables::.
                    876: 
                    877: 
                    878: File: gcc.info,  Node: Target Options,  Next: Submodel Options,  Prev: Directory Options,  Up: Invoking GCC
                    879: 
                    880: Specifying Target Machine and Compiler Version
                    881: ==============================================
                    882: 
                    883:    By default, GNU CC compiles code for the same type of machine that
                    884: you are using.  However, it can also be installed as a cross-compiler,
                    885: to compile for some other type of machine.  In fact, several different
                    886: configurations of GNU CC, for different target machines, can be
                    887: installed side by side.  Then you specify which one to use with the
                    888: `-b' option.
                    889: 
                    890:    In addition, older and newer versions of GNU CC can be installed side
                    891: by side.  One of them (probably the newest) will be the default, but
                    892: you may sometimes wish to use another.
                    893: 
                    894: `-b MACHINE'
                    895:      The argument MACHINE specifies the target machine for compilation.
                    896:      This is useful when you have installed GNU CC as a cross-compiler.
                    897: 
                    898:      The value to use for MACHINE is the same as was specified as the
                    899:      machine type when configuring GNU CC as a cross-compiler.  For
                    900:      example, if a cross-compiler was configured with `configure
                    901:      i386v', meaning to compile for an 80386 running System V, then you
                    902:      would specify `-b i386v' to run that cross compiler.
                    903: 
                    904:      When you do not specify `-b', it normally means to compile for the
                    905:      same type of machine that you are using.
                    906: 
                    907: `-V VERSION'
                    908:      The argument VERSION specifies which version of GNU CC to run.
                    909:      This is useful when multiple versions are installed.  For example,
                    910:      VERSION might be `2.0', meaning to run GNU CC version 2.0.
                    911: 
                    912:      The default version, when you do not specify `-V', is controlled
                    913:      by the way GNU CC is installed.  Normally, it will be a version
                    914:      that is recommended for general use.
                    915: 
                    916:    The `-b' and `-V' options actually work by controlling part of the
                    917: file name used for the executable files and libraries used for
                    918: compilation.  A given version of GNU CC, for a given target machine, is
                    919: normally kept in the directory `/usr/local/lib/gcc-lib/MACHINE/VERSION'.
                    920: 
1.1.1.5   root      921:    Thus, sites can customize the effect of `-b' or `-V' either by
                    922: changing the names of these directories or adding alternate names (or
                    923: symbolic links).  If in directory `/usr/local/lib/gcc-lib/' the file
                    924: `80386' is a link to the file `i386v', then `-b 80386' becomes an alias
                    925: for `-b i386v'.
1.1.1.4   root      926: 
                    927:    In one respect, the `-b' or `-V' do not completely change to a
                    928: different compiler: the top-level driver program `gcc' that you
                    929: originally invoked continues to run and invoke the other executables
                    930: (preprocessor, compiler per se, assembler and linker) that do the real
                    931: work.  However, since no real work is done in the driver program, it
                    932: usually does not matter that the driver program in use is not the one
                    933: for the specified target and version.
                    934: 
                    935:    The only way that the driver program depends on the target machine is
                    936: in the parsing and handling of special machine-specific options.
                    937: However, this is controlled by a file which is found, along with the
                    938: other executables, in the directory for the specified version and
                    939: target machine.  As a result, a single installed driver program adapts
                    940: to any specified target machine and compiler version.
                    941: 
                    942:    The driver program executable does control one significant thing,
                    943: however: the default version and target machine.  Therefore, you can
                    944: install different instances of the driver program, compiled for
                    945: different targets or versions, under different names.
                    946: 
                    947:    For example, if the driver for version 2.0 is installed as `ogcc'
                    948: and that for version 2.1 is installed as `gcc', then the command `gcc'
1.1.1.5   root      949: will use version 2.1 by default, while `ogcc' will use 2.0 by default.
1.1.1.4   root      950: However, you can choose either version with either command with the
                    951: `-V' option.
                    952: 
                    953: 
                    954: File: gcc.info,  Node: Submodel Options,  Next: Code Gen Options,  Prev: Target Options,  Up: Invoking GCC
                    955: 
1.1.1.5   root      956: Hardware Models and Configurations
                    957: ==================================
1.1.1.4   root      958: 
                    959:    Earlier we discussed the standard option `-b' which chooses among
                    960: different installed compilers for completely different target machines,
                    961: such as Vax vs. 68000 vs. 80386.
                    962: 
                    963:    In addition, each of these target machine types can have its own
                    964: special options, starting with `-m', to choose among various hardware
                    965: models or configurations--for example, 68010 vs 68020, floating
                    966: coprocessor or none.  A single installed version of the compiler can
                    967: compile for any model or configuration, according to the options
                    968: specified.
                    969: 
                    970:    Some configurations of the compiler also support additional special
                    971: options, usually for compatibility with other compilers on the same
                    972: platform.
                    973: 
                    974:    These options are defined by the macro `TARGET_SWITCHES' in the
                    975: machine description.  The default for the options is also defined by
                    976: that macro, which enables you to change the defaults.
                    977: 
                    978: * Menu:
                    979: 
                    980: * M680x0 Options::
                    981: * VAX Options::
                    982: * SPARC Options::
                    983: * Convex Options::
                    984: * AMD29K Options::
1.1.1.7 ! root      985: * ARM Options::
1.1.1.4   root      986: * M88K Options::
1.1.1.6   root      987: * RS/6000 and PowerPC Options::
1.1.1.4   root      988: * RT Options::
                    989: * MIPS Options::
                    990: * i386 Options::
                    991: * HPPA Options::
                    992: * Intel 960 Options::
                    993: * DEC Alpha Options::
1.1.1.6   root      994: * Clipper Options::
1.1.1.7 ! root      995: * H8/300 Options::
1.1.1.4   root      996: * System V Options::
                    997: 
                    998: 
                    999: File: gcc.info,  Node: M680x0 Options,  Next: VAX Options,  Up: Submodel Options
                   1000: 
                   1001: M680x0 Options
                   1002: --------------
                   1003: 
                   1004:    These are the `-m' options defined for the 68000 series.  The default
                   1005: values for these options depends on which style of 68000 was selected
                   1006: when the compiler was configured; the defaults for the most common
                   1007: choices are given below.
                   1008: 
                   1009: `-m68000'
                   1010: `-mc68000'
                   1011:      Generate output for a 68000.  This is the default when the
                   1012:      compiler is configured for 68000-based systems.
                   1013: 
                   1014: `-m68020'
                   1015: `-mc68020'
                   1016:      Generate output for a 68020.  This is the default when the
                   1017:      compiler is configured for 68020-based systems.
                   1018: 
                   1019: `-m68881'
                   1020:      Generate output containing 68881 instructions for floating point.
                   1021:      This is the default for most 68020 systems unless `-nfp' was
                   1022:      specified when the compiler was configured.
                   1023: 
                   1024: `-m68030'
                   1025:      Generate output for a 68030.  This is the default when the
                   1026:      compiler is configured for 68030-based systems.
                   1027: 
                   1028: `-m68040'
                   1029:      Generate output for a 68040.  This is the default when the
                   1030:      compiler is configured for 68040-based systems.
                   1031: 
1.1.1.6   root     1032:      This option inhibits the use of 68881/68882 instructions that have
                   1033:      to be emulated by software on the 68040.  If your 68040 does not
                   1034:      have code to emulate those instructions, use `-m68040'.
                   1035: 
1.1.1.4   root     1036: `-m68020-40'
                   1037:      Generate output for a 68040, without using any of the new
1.1.1.5   root     1038:      instructions.  This results in code which can run relatively
1.1.1.6   root     1039:      efficiently on either a 68020/68881 or a 68030 or a 68040.  The
                   1040:      generated code does use the 68881 instructions that are emulated
                   1041:      on the 68040.
1.1.1.4   root     1042: 
                   1043: `-mfpa'
                   1044:      Generate output containing Sun FPA instructions for floating point.
                   1045: 
                   1046: `-msoft-float'
                   1047:      Generate output containing library calls for floating point.
                   1048:      *Warning:* the requisite libraries are not part of GNU CC.
                   1049:      Normally the facilities of the machine's usual C compiler are
                   1050:      used, but this can't be done directly in cross-compilation.  You
                   1051:      must make your own arrangements to provide suitable library
                   1052:      functions for cross-compilation.
                   1053: 
                   1054: `-mshort'
                   1055:      Consider type `int' to be 16 bits wide, like `short int'.
                   1056: 
                   1057: `-mnobitfield'
1.1.1.5   root     1058:      Do not use the bit-field instructions.  The `-m68000' option
                   1059:      implies `-mnobitfield'.
1.1.1.4   root     1060: 
                   1061: `-mbitfield'
1.1.1.5   root     1062:      Do use the bit-field instructions.  The `-m68020' option implies
                   1063:      `-mbitfield'.  This is the default if you use a configuration
                   1064:      designed for a 68020.
1.1.1.4   root     1065: 
                   1066: `-mrtd'
                   1067:      Use a different function-calling convention, in which functions
                   1068:      that take a fixed number of arguments return with the `rtd'
                   1069:      instruction, which pops their arguments while returning.  This
                   1070:      saves one instruction in the caller since there is no need to pop
                   1071:      the arguments there.
                   1072: 
                   1073:      This calling convention is incompatible with the one normally used
                   1074:      on Unix, so you cannot use it if you need to call libraries
                   1075:      compiled with the Unix compiler.
                   1076: 
                   1077:      Also, you must provide function prototypes for all functions that
                   1078:      take variable numbers of arguments (including `printf'); otherwise
                   1079:      incorrect code will be generated for calls to those functions.
                   1080: 
                   1081:      In addition, seriously incorrect code will result if you call a
                   1082:      function with too many arguments.  (Normally, extra arguments are
                   1083:      harmlessly ignored.)
                   1084: 
                   1085:      The `rtd' instruction is supported by the 68010 and 68020
                   1086:      processors, but not by the 68000.
                   1087: 
                   1088: 
                   1089: File: gcc.info,  Node: VAX Options,  Next: SPARC Options,  Prev: M680x0 Options,  Up: Submodel Options
                   1090: 
                   1091: VAX Options
                   1092: -----------
                   1093: 
                   1094:    These `-m' options are defined for the Vax:
                   1095: 
                   1096: `-munix'
                   1097:      Do not output certain jump instructions (`aobleq' and so on) that
                   1098:      the Unix assembler for the Vax cannot handle across long ranges.
                   1099: 
                   1100: `-mgnu'
                   1101:      Do output those jump instructions, on the assumption that you will
                   1102:      assemble with the GNU assembler.
                   1103: 
                   1104: `-mg'
                   1105:      Output code for g-format floating point numbers instead of
                   1106:      d-format.
                   1107: 
                   1108: 
1.1.1.5   root     1109: File: gcc.info,  Node: SPARC Options,  Next: Convex Options,  Prev: VAX Options,  Up: Submodel Options
1.1.1.4   root     1110: 
                   1111: SPARC Options
                   1112: -------------
                   1113: 
1.1.1.5   root     1114:    These `-m' switches are supported on the SPARC:
1.1.1.4   root     1115: 
1.1.1.7 ! root     1116: `-mno-app-regs'
        !          1117: `-mapp-regs'
        !          1118:      Specify `-mapp-regs' to generate output using the global registers
        !          1119:      2 through 4, which the SPARC SVR4 ABI reserves for applications.
        !          1120:      This is the default.
        !          1121: 
        !          1122:      To be fully SVR4 ABI compliant at the cost of some performance
        !          1123:      loss, specify `-mno-app-regs'.  You should compile libraries and
        !          1124:      system software with this option.
        !          1125: 
1.1.1.5   root     1126: `-mfpu'
                   1127: `-mhard-float'
                   1128:      Generate output containing floating point instructions.  This is
                   1129:      the default.
                   1130: 
                   1131: `-mno-fpu'
                   1132: `-msoft-float'
                   1133:      Generate output containing library calls for floating point.
                   1134:      *Warning:* there is no GNU floating-point library for SPARC.
                   1135:      Normally the facilities of the machine's usual C compiler are
                   1136:      used, but this cannot be done directly in cross-compilation.  You
                   1137:      must make your own arrangements to provide suitable library
                   1138:      functions for cross-compilation.
                   1139: 
                   1140:      `-msoft-float' changes the calling convention in the output file;
                   1141:      therefore, it is only useful if you compile *all* of a program with
                   1142:      this option.  In particular, you need to compile `libgcc.a', the
                   1143:      library that comes with GNU CC, with `-msoft-float' in order for
                   1144:      this to work.
1.1.1.4   root     1145: 
1.1.1.7 ! root     1146: `-mhard-quad-float'
        !          1147:      Generate output containing quad-word (long double) floating point
        !          1148:      instructions.
        !          1149: 
        !          1150: `-msoft-quad-float'
        !          1151:      Generate output containing library calls for quad-word (long
        !          1152:      double) floating point instructions.  The functions called are
        !          1153:      those specified in the SPARC ABI.  This is the default.
        !          1154: 
        !          1155:      As of this writing, there are no sparc implementations that have
        !          1156:      hardware support for the quad-word floating point instructions.
        !          1157:      They all invoke a trap handler for one of these instructions, and
        !          1158:      then the trap handler emulates the effect of the instruction.
        !          1159:      Because of the trap handler overhead, this is much slower than
        !          1160:      calling the ABI library routines.  Thus the `-msoft-quad-float'
        !          1161:      option is the default.
        !          1162: 
1.1.1.4   root     1163: `-mno-epilogue'
1.1.1.5   root     1164: `-mepilogue'
                   1165:      With `-mepilogue' (the default), the compiler always emits code for
                   1166:      function exit at the end of each function.  Any function exit in
                   1167:      the middle of the function (such as a return statement in C) will
                   1168:      generate a jump to the exit code at the end of the function.
                   1169: 
                   1170:      With `-mno-epilogue', the compiler tries to emit exit code inline
                   1171:      at every function exit.
                   1172: 
1.1.1.7 ! root     1173: `-mno-flat'
        !          1174: `-mflat'
        !          1175:      With `-mflat', the compiler does not generate save/restore
        !          1176:      instructions and will use a "flat" or single register window
        !          1177:      calling convention.  This model uses %i7 as the frame pointer and
        !          1178:      is compatible with the normal register window model.  Code from
        !          1179:      either may be intermixed although debugger support is still
        !          1180:      incomplete.  The local registers and the input registers (0-5) are
        !          1181:      still treated as "call saved" registers and will be saved on the
        !          1182:      stack as necessary.
        !          1183: 
        !          1184:      With `-mno-flat' (the default), the compiler emits save/restore
        !          1185:      instructions (except for leaf functions) and is the normal mode of
        !          1186:      operation.
        !          1187: 
        !          1188: `-mno-unaligned-doubles'
        !          1189: `-munaligned-doubles'
        !          1190:      Assume that doubles have 8 byte alignment.  This is the default.
        !          1191: 
        !          1192:      With `-munaligned-doubles', GNU CC assumes that doubles have 8 byte
        !          1193:      alignment only if they are contained in another type, or if they
        !          1194:      have an absolute address.  Otherwise, it assumes they have 4 byte
        !          1195:      alignment.  Specifying this option avoids some rare compatibility
        !          1196:      problems with code generated by other compilers.  It is not the
        !          1197:      default because it results in a performance loss, especially for
        !          1198:      floating point code.
        !          1199: 
1.1.1.5   root     1200: `-mv8'
                   1201: `-msparclite'
                   1202:      These two options select variations on the SPARC architecture.
                   1203: 
                   1204:      By default (unless specifically configured for the Fujitsu
                   1205:      SPARClite), GCC generates code for the v7 variant of the SPARC
                   1206:      architecture.
                   1207: 
                   1208:      `-mv8' will give you SPARC v8 code.  The only difference from v7
                   1209:      code is that the compiler emits the integer multiply and integer
                   1210:      divide instructions which exist in SPARC v8 but not in SPARC v7.
                   1211: 
                   1212:      `-msparclite' will give you SPARClite code.  This adds the integer
                   1213:      multiply, integer divide step and scan (`ffs') instructions which
                   1214:      exist in SPARClite but not in SPARC v7.
1.1.1.4   root     1215: 
1.1.1.7 ! root     1216: `-mcypress'
        !          1217: `-msupersparc'
        !          1218:      These two options select the processor for which the code is
        !          1219:      optimised.
        !          1220: 
        !          1221:      With `-mcypress' (the default), the compiler optimizes code for the
        !          1222:      Cypress CY7C602 chip, as used in the SparcStation/SparcServer 3xx
        !          1223:      series.  This is also apropriate for the older SparcStation 1, 2,
        !          1224:      IPX etc.
        !          1225: 
        !          1226:      With `-msupersparc' the compiler optimizes code for the SuperSparc
        !          1227:      cpu, as used in the SparcStation 10, 1000 and 2000 series. This
        !          1228:      flag also enables use of the full SPARC v8 instruction set.
        !          1229: 
        !          1230:    In a future version of GCC, these options will very likely be
        !          1231: renamed to `-mcpu=cypress' and `-mcpu=supersparc'.
        !          1232: 
        !          1233:    These `-m' switches are supported in addition to the above on SPARC
        !          1234: V9 processors:
        !          1235: 
        !          1236: `-mmedlow'
        !          1237:      Generate code for the Medium/Low code model: assume a 32 bit
        !          1238:      address space.  Programs are statically linked, PIC is not
        !          1239:      supported.  Pointers are still 64 bits.
1.1.1.4   root     1240: 
1.1.1.7 ! root     1241:      It is very likely that a future version of GCC will rename this
        !          1242:      option.
1.1.1.4   root     1243: 
1.1.1.7 ! root     1244: `-mmedany'
        !          1245:      Generate code for the Medium/Anywhere code model: assume a 32 bit
        !          1246:      text segment starting at offset 0, and a 32 bit data segment
        !          1247:      starting anywhere (determined at link time).  Programs are
        !          1248:      statically linked, PIC is not supported.  Pointers are still 64
        !          1249:      bits.
        !          1250: 
        !          1251:      It is very likely that a future version of GCC will rename this
        !          1252:      option.
1.1.1.4   root     1253: 
1.1.1.7 ! root     1254: `-mint64'
        !          1255:      Types long and int are 64 bits.
1.1.1.5   root     1256: 
                   1257: `-mlong32'
1.1.1.7 ! root     1258:      Types long and int are 32 bits.
1.1.1.5   root     1259: 
                   1260: `-mlong64'
1.1.1.7 ! root     1261: `-mint32'
        !          1262:      Type long is 64 bits, and type int is 32 bits.
1.1       root     1263: 
1.1.1.7 ! root     1264: `-mstack-bias'
        !          1265: `-mno-stack-bias'
        !          1266:      With `-mstack-bias', GNU CC assumes that the stack pointer, and
        !          1267:      frame pointer if present, are offset by -2047 which must be added
        !          1268:      back when making stack frame references.  Otherwise, assume no
        !          1269:      such offset is present.
1.1       root     1270: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.