home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / programm / language / gcc222.lha / info / gcc.info-2 < prev    next >
Encoding:
GNU Info File  |  1992-07-19  |  49.5 KB  |  1,299 lines

  1. This is Info file gcc.info, produced by Makeinfo-1.47 from the input
  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.  
  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.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  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.
  18.  
  19.    Permission is granted to copy and distribute translations of this
  20. manual into another language, under the above conditions for modified
  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.
  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.  
  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.
  35.  
  36.    You can request many specific warnings with options beginning `-W',
  37. for example `-Wimplicit' to request warnings on implicit declarations. 
  38. Each of these specific warning options also has a negative form
  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.  
  52. `-Wno_import'
  53.      Inhibit warning messages about the use of `#import'.
  54.  
  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
  69.      these escape routes; application programs should avoid them. *Note
  70.      Alternate Keywords::.
  71.  
  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.
  80.  
  81.      A feature to report any failure to conform to ANSI C might be
  82.      useful in some instances, but would require considerable
  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
  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.  
  97.         * A nonvolatile automatic variable might be changed by a call to
  98.           `longjmp'.  These warnings as well are possible only in
  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
  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.
  107.  
  108.         * A function can return either with or without a value. 
  109.           (Falling off the end of the function body is considered
  110.           returning without a value.)  For example, this function would
  111.           evoke such a warning:
  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'
  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.
  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
  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.
  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
  198.      initialized, but GNU CC doesn't know this.  Here is another common
  199.      case:
  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.  
  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::.
  213.  
  214. `-Wparentheses'
  215.      Warn if parentheses are omitted in certain contexts.
  216.  
  217. `-Wall'
  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.
  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
  231.           macro body. These would substitute the argument in
  232.           traditional C, but are part of the constant in ANSI C.
  233.  
  234.         * A function declared external in one block and then used after
  235.           the end of the block.
  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
  250.      convenience in calculations with `void *' pointers and pointers to
  251.      functions.
  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
  261.      cast to an `int *' on machines where integers can only be accessed
  262.      at two- or four-byte boundaries.
  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'
  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.)
  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
  289.      without a warning if preceded by a declaration which specifies the
  290.      argument types.)
  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.  
  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.
  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
  324.      format (stabs, COFF, XCOFF, or DWARF).  GDB can work with this
  325.      debugging information.
  326.  
  327.      On most systems that use stabs format, `-g' enables use of extra
  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).
  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
  366.      supported). This is the format used by SDB on COFF systems.
  367.  
  368. `-gxcoff'
  369.      Produce debugging information in XCOFF format (if that is
  370.      supported). This is the format used on IBM RS/6000 systems.
  371.  
  372. `-gdwarf'
  373.      Produce debugging information in DWARF format (if that is
  374.      supported). This is the format used by SDB on systems that use
  375.      DWARF.
  376.  
  377. `-gLEVEL'
  378. `-ggdbLEVEL'
  379. `-gstabsLEVEL'
  380. `-gcoffLEVEL'
  381. `-gxcoffLEVEL'
  382. `-gdwarfLEVEL'
  383.      Request debugging information and also use LEVEL to specify how
  384.      much information.  The default level is 2.
  385.  
  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.
  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,
  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.
  409.  
  410. `-dLETTERS'
  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:
  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'
  442.           Dump after CSE (including the jump optimization that sometimes
  443.           follows CSE), to `FILE.cse'.
  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
  503.      file.  Thus, compiling `foo.c' with `-c -save-temps' would produce
  504.      files `foo.i' and `foo.s', as well as `foo.o'.
  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
  519.      compilation and to make debugging produce the expected results.
  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'
  534.      are turned on.  On some machines other flags may also be turned on.
  535.  
  536. `-O2'
  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'.
  545.  
  546.    Options of the form `-fFLAG' specify machine-independent flags. 
  547. Most flags have both positive and negative forms; the negative form of
  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.
  551.  
  552. `-ffloat-store'
  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.
  557.  
  558.      For most programs, the excess precision does only good, but a few
  559.      programs rely on the precise definition of IEEE floating point.
  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.  
  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.
  598.  
  599. `-finline-functions'
  600.      Integrate all simple functions into their callers.  The compiler
  601.      heuristically decides which functions are simple enough to be worth
  602.      integrating in this way.
  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.  
  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.  
  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'
  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.
  652.  
  653. `-fcse-follow-jumps'
  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'.
  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.  
  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.  
  704. `-funroll-loops'
  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
  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.  
  728.    If you use the `-E' option, nothing is done except preprocessing.
  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'
  733.      Process FILE as input before processing the regular input file. In
  734.      effect, the contents of FILE are compiled first.  Any `-D' and
  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.  
  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.
  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.  
  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++'.)
  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'
  776.      Tell the preprocessor not to discard comments.  Used with the `-E'
  777.      option.
  778.  
  779. `-P'
  780.      Tell the preprocessor not to generate `#line' commands. Used with
  781.      the `-E' option.
  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
  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.
  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
  844.      omitted. Only `#define NAME' is included in the output.
  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
  857. into an executable output file.  They are meaningless if the compiler is
  858. not doing a link step.
  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
  879.      order they are specified.  Thus, `foo.o -lz bar.o' searches
  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.  
  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.
  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
  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.
  898.  
  899. `-nostdlib'
  900.      Don't use the standard system libraries and startup files when
  901.      linking. Only the files you specify will be passed to the linker.
  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
  925.      `-Xlinker' twice, once for the option and once for the argument.
  926.      For example, to pass `-assert definitions', you must write
  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.
  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'
  951.      directives.  (Ordinarily *all* `-I' directories are used this way.)
  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
  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::.).
  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
  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.
  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.  
  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::.
  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.  
  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.
  1014.  
  1015. `-b MACHINE'
  1016.      The argument MACHINE specifies the target machine for compilation.
  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.  
  1025.      When you do not specify `-b', it normally means to compile for the
  1026.      same type of machine that you are using.
  1027.  
  1028. `-V VERSION'
  1029.      The argument VERSION specifies which version of GNU CC to run.
  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
  1040. normally kept in the directory `/usr/local/lib/gcc-lib/MACHINE/VERSION'.
  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
  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'.
  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.  
  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.
  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'
  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
  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
  1081. different installed compilers for completely different target machines,
  1082. such as Vax vs. 68000 vs. 80386.
  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::
  1106. * i386 Options::
  1107.  
  1108. 
  1109. File: gcc.info,  Node: M680x0 Options,  Next: Vax Options,  Prev: Submodel Options,  Up: Submodel Options
  1110.  
  1111. M680x0 Options
  1112. --------------
  1113.  
  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.
  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'
  1130.      Generate output containing 68881 instructions for floating point.
  1131.      This is the default for most 68020 systems unless `-nfp' was
  1132.      specified when the compiler was configured.
  1133.  
  1134. `-mfpa'
  1135.      Generate output containing Sun FPA instructions for floating point.
  1136.  
  1137. `-msoft-float'
  1138.      Generate output containing library calls for floating point.
  1139.      *Warning:* the requisite libraries are not part of GNU CC.
  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.  
  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
  1166.      compiled with the Unix compiler.
  1167.  
  1168.      Also, you must provide function prototypes for all functions that
  1169.      take variable numbers of arguments (including `printf'); otherwise
  1170.      incorrect code will be generated for calls to those functions.
  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'
  1192.      Do output those jump instructions, on the assumption that you will
  1193.      assemble with the GNU assembler.
  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.  
  1207. `-mforce-align'
  1208.      Make sure all objects of type `double' are 8-byte aligned in memory
  1209.      and use double-word instructions to reference them.
  1210.  
  1211. `-mno-epilogue'
  1212.      Generate separate return instructions for `return' statements.
  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'
  1225.      Generate output for a C1.  This is the default when the compiler is
  1226.      configured for a C1.
  1227.  
  1228. `-mc2'
  1229.      Generate output for a C2.  This is the default when the compiler is
  1230.      configured for a C2.
  1231.  
  1232. `-margcount'
  1233.      Generate code which puts an argument count in the word preceding
  1234.      each argument list.  Some nonportable Convex and Vax programs need
  1235.      this word. (Debuggers don't, except for functions with
  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'
  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.
  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.