Return to gcc.info-3 CVS log

Up to [GCC 2.x] / gcc

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

1.1.1.5 ! root        1: This is Info file gcc.info, produced by Makeinfo-1.54 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: 
        !             9:    Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
1.1       root       10: 
1.1.1.3   root       11:    Permission is granted to make and distribute verbatim copies of this
                     12: manual provided the copyright notice and this permission notice are
                     13: preserved on all copies.
1.1       root       14: 
                     15:    Permission is granted to copy and distribute modified versions of
                     16: this manual under the conditions for verbatim copying, provided also
1.1.1.4   root       17: that the sections entitled "GNU General Public License" and "Protect
                     18: Your Freedom--Fight `Look And Feel'" are included exactly as in the
                     19: original, and provided that the entire resulting derived work is
                     20: distributed under the terms of a permission notice identical to this
                     21: one.
1.1       root       22: 
                     23:    Permission is granted to copy and distribute translations of this
                     24: manual into another language, under the above conditions for modified
1.1.1.3   root       25: versions, except that the sections entitled "GNU General Public
1.1.1.4   root       26: License" and "Protect Your Freedom--Fight `Look And Feel'", and this
                     27: permission notice, may be included in translations approved by the Free
                     28: Software Foundation instead of in the original English.
                     29: 
                     30: 
1.1.1.5 ! root       31: File: gcc.info,  Node: Preprocessor Options,  Next: Assembler Options,  Prev: Optimize Options,  Up: Invoking GCC
        !            32: 
        !            33: Options Controlling the Preprocessor
        !            34: ====================================
        !            35: 
        !            36:    These options control the C preprocessor, which is run on each C
        !            37: source file before actual compilation.
        !            38: 
        !            39:    If you use the `-E' option, nothing is done except preprocessing.
        !            40: Some of these options make sense only together with `-E' because they
        !            41: cause the preprocessor output to be unsuitable for actual compilation.
        !            42: 
        !            43: `-include FILE'
        !            44:      Process FILE as input before processing the regular input file.
        !            45:      In effect, the contents of FILE are compiled first.  Any `-D' and
        !            46:      `-U' options on the command line are always processed before
        !            47:      `-include FILE', regardless of the order in which they are
        !            48:      written.  All the `-include' and `-imacros' options are processed
        !            49:      in the order in which they are written.
        !            50: 
        !            51: `-imacros FILE'
        !            52:      Process FILE as input, discarding the resulting output, before
        !            53:      processing the regular input file.  Because the output generated
        !            54:      from FILE is discarded, the only effect of `-imacros FILE' is to
        !            55:      make the macros defined in FILE available for use in the main
        !            56:      input.
        !            57: 
        !            58:      Any `-D' and `-U' options on the command line are always processed
        !            59:      before `-imacros FILE', regardless of the order in which they are
        !            60:      written.  All the `-include' and `-imacros' options are processed
        !            61:      in the order in which they are written.
        !            62: 
        !            63: `-idirafter DIR'
        !            64:      Add the directory DIR to the second include path.  The directories
        !            65:      on the second include path are searched when a header file is not
        !            66:      found in any of the directories in the main include path (the one
        !            67:      that `-I' adds to).
        !            68: 
        !            69: `-iprefix PREFIX'
        !            70:      Specify PREFIX as the prefix for subsequent `-iwithprefix' options.
        !            71: 
        !            72: `-iwithprefix DIR'
        !            73:      Add a directory to the second include path.  The directory's name
        !            74:      is made by concatenating PREFIX and DIR, where PREFIX was
        !            75:      specified previously with `-iprefix'.
        !            76: 
        !            77: `-nostdinc'
        !            78:      Do not search the standard system directories for header files.
        !            79:      Only the directories you have specified with `-I' options (and the
        !            80:      current directory, if appropriate) are searched.  *Note Directory
        !            81:      Options::, for information on `-I'.
        !            82: 
        !            83:      By using both `-nostdinc' and `-I-', you can limit the include-file
        !            84:      search path to only those directories you specify explicitly.
        !            85: 
        !            86: `-undef'
        !            87:      Do not predefine any nonstandard macros.  (Including architecture
        !            88:      flags).
        !            89: 
        !            90: `-E'
        !            91:      Run only the C preprocessor.  Preprocess all the C source files
        !            92:      specified and output the results to standard output or to the
        !            93:      specified output file.
        !            94: 
        !            95: `-C'
        !            96:      Tell the preprocessor not to discard comments.  Used with the `-E'
        !            97:      option.
        !            98: 
        !            99: `-P'
        !           100:      Tell the preprocessor not to generate `#line' commands.  Used with
        !           101:      the `-E' option.
        !           102: 
        !           103: `-M'
        !           104:      Tell the preprocessor to output a rule suitable for `make'
        !           105:      describing the dependencies of each object file.  For each source
        !           106:      file, the preprocessor outputs one `make'-rule whose target is the
        !           107:      object file name for that source file and whose dependencies are
        !           108:      all the `#include' header files it uses.  This rule may be a
        !           109:      single line or may be continued with `\'-newline if it is long.
        !           110:      The list of rules is printed on standard output instead of the
        !           111:      preprocessed C program.
        !           112: 
        !           113:      `-M' implies `-E'.
        !           114: 
        !           115:      Another way to specify output of a `make' rule is by setting the
        !           116:      environment variable `DEPENDENCIES_OUTPUT' (*note Environment
        !           117:      Variables::.).
        !           118: 
        !           119: `-MM'
        !           120:      Like `-M' but the output mentions only the user header files
        !           121:      included with `#include "FILE"'.  System header files included
        !           122:      with `#include <FILE>' are omitted.
        !           123: 
        !           124: `-MD'
        !           125:      Like `-M' but the dependency information is written to files with
        !           126:      names made by replacing `.o' with `.d' at the end of the output
        !           127:      file names.  This is in addition to compiling the input files as
        !           128:      specified--`-MD' does not inhibit ordinary compilation the way
        !           129:      `-M' does.
        !           130: 
        !           131:      The Mach utility `md' can be used to merge the `.d' files into a
        !           132:      single dependency file suitable for using with the `make' command.
        !           133: 
        !           134: `-MMD'
        !           135:      Like `-MD' except mention only user header files, not system
        !           136:      header files.
        !           137: 
        !           138: `-H'
        !           139:      Print the name of each header file used, in addition to other
        !           140:      normal activities.
        !           141: 
        !           142: `-AQUESTION(ANSWER)'
        !           143:      Assert the answer ANSWER for QUESTION, in case it is tested with a
        !           144:      preprocessor conditional such as `#if #QUESTION(ANSWER)'.  `-A-'
        !           145:      disables the standard assertions that normally describe the target
        !           146:      machine.
        !           147: 
        !           148: `-DMACRO'
        !           149:      Define macro MACRO with the string `1' as its definition.
        !           150: 
        !           151: `-DMACRO=DEFN'
        !           152:      Define macro MACRO as DEFN.  All instances of `-D' on the command
        !           153:      line are processed before any `-U' options.
        !           154: 
        !           155: `-UMACRO'
        !           156:      Undefine macro MACRO.  `-U' options are evaluated after all `-D'
        !           157:      options, but before any `-include' and `-imacros' options.
        !           158: 
        !           159: `-dM'
        !           160:      Tell the preprocessor to output only a list of the macro
        !           161:      definitions that are in effect at the end of preprocessing.  Used
        !           162:      with the `-E' option.
        !           163: 
        !           164: `-dD'
        !           165:      Tell the preprocessing to pass all macro definitions into the
        !           166:      output, in their proper sequence in the rest of the output.
        !           167: 
        !           168: `-dN'
        !           169:      Like `-dD' except that the macro arguments and contents are
        !           170:      omitted.  Only `#define NAME' is included in the output.
        !           171: 
        !           172: `-trigraphs'
        !           173:      Support ANSI C trigraphs.  You don't want to know about this
        !           174:      brain-damage.  The `-ansi' option also has this effect.
        !           175: 
        !           176: 
        !           177: File: gcc.info,  Node: Assembler Options,  Next: Link Options,  Prev: Preprocessor Options,  Up: Invoking GCC
        !           178: 
        !           179: Passing Options to the Assembler
        !           180: ================================
        !           181: 
        !           182: `-Wa,OPTION'
        !           183:      Pass OPTION as an option to the assembler.  If OPTION contains
        !           184:      commas, it is split into multiple options at the commas.
        !           185: 
        !           186: 
1.1.1.4   root      187: File: gcc.info,  Node: Link Options,  Next: Directory Options,  Prev: Assembler Options,  Up: Invoking GCC
                    188: 
                    189: Options for Linking
                    190: ===================
                    191: 
                    192:    These options come into play when the compiler links object files
                    193: into an executable output file.  They are meaningless if the compiler is
                    194: not doing a link step.
                    195: 
                    196: `OBJECT-FILE-NAME'
                    197:      A file name that does not end in a special recognized suffix is
                    198:      considered to name an object file or library.  (Object files are
                    199:      distinguished from libraries by the linker according to the file
                    200:      contents.)  If linking is done, these object files are used as
                    201:      input to the linker.
                    202: 
                    203: `-c'
                    204: `-S'
                    205: `-E'
                    206:      If any of these options is used, then the linker is not run, and
                    207:      object file names should not be used as arguments.  *Note Overall
                    208:      Options::.
                    209: 
                    210: `-lLIBRARY'
                    211:      Search the library named LIBRARY when linking.
                    212: 
                    213:      It makes a difference where in the command you write this option;
                    214:      the linker searches processes libraries and object files in the
                    215:      order they are specified.  Thus, `foo.o -lz bar.o' searches
                    216:      library `z' after file `foo.o' but before `bar.o'.  If `bar.o'
                    217:      refers to functions in `z', those functions may not be loaded.
                    218: 
                    219:      The linker searches a standard list of directories for the library,
                    220:      which is actually a file named `libLIBRARY.a'.  The linker then
                    221:      uses this file as if it had been specified precisely by name.
                    222: 
                    223:      The directories searched include several standard system
                    224:      directories plus any that you specify with `-L'.
                    225: 
                    226:      Normally the files found this way are library files--archive files
                    227:      whose members are object files.  The linker handles an archive
                    228:      file by scanning through it for members which define symbols that
                    229:      have so far been referenced but not defined.  But if the file that
                    230:      is found is an ordinary object file, it is linked in the usual
                    231:      fashion.  The only difference between using an `-l' option and
                    232:      specifying a file name is that `-l' surrounds LIBRARY with `lib'
                    233:      and `.a' and searches several directories.
                    234: 
                    235: `-lobjc'
1.1.1.5 ! root      236:      You need this special case of the `-l' option in order to link an
        !           237:      Objective C program.
        !           238: 
        !           239: `-nostartfiles'
        !           240:      Do not use the standard system startup files when linking.  The
        !           241:      standard libraries are used normally.
1.1.1.4   root      242: 
                    243: `-nostdlib'
                    244:      Don't use the standard system libraries and startup files when
1.1.1.5 ! root      245:      linking.  Only the files you specify will be passed to the linker.
1.1.1.4   root      246: 
                    247: `-static'
                    248:      On systems that support dynamic linking, this prevents linking
                    249:      with the shared libraries.  On other systems, this option has no
                    250:      effect.
                    251: 
                    252: `-shared'
                    253:      Produce a shared object which can then be linked with other
                    254:      objects to form an executable.  Only a few systems support this
                    255:      option.
                    256: 
                    257: `-symbolic'
1.1.1.5 ! root      258:      Bind references to global symbols when building a shared object.
1.1.1.4   root      259:      Warn about any unresolved references (unless overridden by the
                    260:      link editor option `-Xlinker -z -Xlinker defs').  Only a few
                    261:      systems support this option.
                    262: 
                    263: `-Xlinker OPTION'
                    264:      Pass OPTION as an option to the linker.  You can use this to
                    265:      supply system-specific linker options which GNU CC does not know
                    266:      how to recognize.
                    267: 
                    268:      If you want to pass an option that takes an argument, you must use
                    269:      `-Xlinker' twice, once for the option and once for the argument.
                    270:      For example, to pass `-assert definitions', you must write
                    271:      `-Xlinker -assert -Xlinker definitions'.  It does not work to write
                    272:      `-Xlinker "-assert definitions"', because this passes the entire
                    273:      string as a single argument, which is not what the linker expects.
                    274: 
                    275: `-Wl,OPTION'
                    276:      Pass OPTION as an option to the linker.  If OPTION contains
                    277:      commas, it is split into multiple options at the commas.
                    278: 
                    279: `-u SYMBOL'
                    280:      Pretend the symbol SYMBOL is undefined, to force linking of
                    281:      library modules to define it.  You can use `-u' multiple times with
                    282:      different symbols to force loading of additional library modules.
                    283: 
                    284: 
                    285: File: gcc.info,  Node: Directory Options,  Next: Target Options,  Prev: Link Options,  Up: Invoking GCC
                    286: 
                    287: Options for Directory Search
                    288: ============================
                    289: 
                    290:    These options specify directories to search for header files, for
                    291: libraries and for parts of the compiler:
                    292: 
                    293: `-IDIR'
                    294:      Append directory DIR to the list of directories searched for
                    295:      include files.
                    296: 
                    297: `-I-'
                    298:      Any directories you specify with `-I' options before the `-I-'
                    299:      option are searched only for the case of `#include "FILE"'; they
                    300:      are not searched for `#include <FILE>'.
                    301: 
                    302:      If additional directories are specified with `-I' options after
                    303:      the `-I-', these directories are searched for all `#include'
                    304:      directives.  (Ordinarily *all* `-I' directories are used this way.)
                    305: 
                    306:      In addition, the `-I-' option inhibits the use of the current
                    307:      directory (where the current input file came from) as the first
                    308:      search directory for `#include "FILE"'.  There is no way to
                    309:      override this effect of `-I-'.  With `-I.' you can specify
                    310:      searching the directory which was current when the compiler was
                    311:      invoked.  That is not exactly the same as what the preprocessor
                    312:      does by default, but it is often satisfactory.
                    313: 
                    314:      `-I-' does not inhibit the use of the standard system directories
                    315:      for header files.  Thus, `-I-' and `-nostdinc' are independent.
                    316: 
                    317: `-LDIR'
                    318:      Add directory DIR to the list of directories to be searched for
                    319:      `-l'.
                    320: 
                    321: `-BPREFIX'
                    322:      This option specifies where to find the executables, libraries and
                    323:      data files of the compiler itself.
                    324: 
                    325:      The compiler driver program runs one or more of the subprograms
                    326:      `cpp', `cc1', `as' and `ld'.  It tries PREFIX as a prefix for each
                    327:      program it tries to run, both with and without `MACHINE/VERSION/'
                    328:      (*note Target Options::.).
                    329: 
                    330:      For each subprogram to be run, the compiler driver first tries the
                    331:      `-B' prefix, if any.  If that name is not found, or if `-B' was
                    332:      not specified, the driver tries two standard prefixes, which are
                    333:      `/usr/lib/gcc/' and `/usr/local/lib/gcc-lib/'.  If neither of
                    334:      those results in a file name that is found, the unmodified program
                    335:      name is searched for using the directories specified in your
                    336:      `PATH' environment variable.
                    337: 
                    338:      `-B' prefixes that effectively specify directory names also apply
                    339:      to libraries in the linker, because the compiler translates these
                    340:      options into `-L' options for the linker.
                    341: 
                    342:      The run-time support file `libgcc.a' can also be searched for using
                    343:      the `-B' prefix, if needed.  If it is not found there, the two
                    344:      standard prefixes above are tried, and that is all.  The file is
                    345:      left out of the link if it is not found by those means.
                    346: 
                    347:      Another way to specify a prefix much like the `-B' prefix is to use
                    348:      the environment variable `GCC_EXEC_PREFIX'.  *Note Environment
                    349:      Variables::.
                    350: 
                    351: 
                    352: File: gcc.info,  Node: Target Options,  Next: Submodel Options,  Prev: Directory Options,  Up: Invoking GCC
                    353: 
                    354: Specifying Target Machine and Compiler Version
                    355: ==============================================
                    356: 
                    357:    By default, GNU CC compiles code for the same type of machine that
                    358: you are using.  However, it can also be installed as a cross-compiler,
                    359: to compile for some other type of machine.  In fact, several different
                    360: configurations of GNU CC, for different target machines, can be
                    361: installed side by side.  Then you specify which one to use with the
                    362: `-b' option.
                    363: 
                    364:    In addition, older and newer versions of GNU CC can be installed side
                    365: by side.  One of them (probably the newest) will be the default, but
                    366: you may sometimes wish to use another.
                    367: 
                    368: `-b MACHINE'
                    369:      The argument MACHINE specifies the target machine for compilation.
                    370:      This is useful when you have installed GNU CC as a cross-compiler.
                    371: 
                    372:      The value to use for MACHINE is the same as was specified as the
                    373:      machine type when configuring GNU CC as a cross-compiler.  For
                    374:      example, if a cross-compiler was configured with `configure
                    375:      i386v', meaning to compile for an 80386 running System V, then you
                    376:      would specify `-b i386v' to run that cross compiler.
                    377: 
                    378:      When you do not specify `-b', it normally means to compile for the
                    379:      same type of machine that you are using.
                    380: 
                    381: `-V VERSION'
                    382:      The argument VERSION specifies which version of GNU CC to run.
                    383:      This is useful when multiple versions are installed.  For example,
                    384:      VERSION might be `2.0', meaning to run GNU CC version 2.0.
                    385: 
                    386:      The default version, when you do not specify `-V', is controlled
                    387:      by the way GNU CC is installed.  Normally, it will be a version
                    388:      that is recommended for general use.
                    389: 
                    390:    The `-b' and `-V' options actually work by controlling part of the
                    391: file name used for the executable files and libraries used for
                    392: compilation.  A given version of GNU CC, for a given target machine, is
                    393: normally kept in the directory `/usr/local/lib/gcc-lib/MACHINE/VERSION'.
                    394: 
1.1.1.5 ! root      395:    Thus, sites can customize the effect of `-b' or `-V' either by
        !           396: changing the names of these directories or adding alternate names (or
        !           397: symbolic links).  If in directory `/usr/local/lib/gcc-lib/' the file
        !           398: `80386' is a link to the file `i386v', then `-b 80386' becomes an alias
        !           399: for `-b i386v'.
1.1.1.4   root      400: 
                    401:    In one respect, the `-b' or `-V' do not completely change to a
                    402: different compiler: the top-level driver program `gcc' that you
                    403: originally invoked continues to run and invoke the other executables
                    404: (preprocessor, compiler per se, assembler and linker) that do the real
                    405: work.  However, since no real work is done in the driver program, it
                    406: usually does not matter that the driver program in use is not the one
                    407: for the specified target and version.
                    408: 
                    409:    The only way that the driver program depends on the target machine is
                    410: in the parsing and handling of special machine-specific options.
                    411: However, this is controlled by a file which is found, along with the
                    412: other executables, in the directory for the specified version and
                    413: target machine.  As a result, a single installed driver program adapts
                    414: to any specified target machine and compiler version.
                    415: 
                    416:    The driver program executable does control one significant thing,
                    417: however: the default version and target machine.  Therefore, you can
                    418: install different instances of the driver program, compiled for
                    419: different targets or versions, under different names.
                    420: 
                    421:    For example, if the driver for version 2.0 is installed as `ogcc'
                    422: and that for version 2.1 is installed as `gcc', then the command `gcc'
1.1.1.5 ! root      423: will use version 2.1 by default, while `ogcc' will use 2.0 by default.
1.1.1.4   root      424: However, you can choose either version with either command with the
                    425: `-V' option.
                    426: 
                    427: 
                    428: File: gcc.info,  Node: Submodel Options,  Next: Code Gen Options,  Prev: Target Options,  Up: Invoking GCC
                    429: 
1.1.1.5 ! root      430: Hardware Models and Configurations
        !           431: ==================================
1.1.1.4   root      432: 
                    433:    Earlier we discussed the standard option `-b' which chooses among
                    434: different installed compilers for completely different target machines,
                    435: such as Vax vs. 68000 vs. 80386.
                    436: 
                    437:    In addition, each of these target machine types can have its own
                    438: special options, starting with `-m', to choose among various hardware
                    439: models or configurations--for example, 68010 vs 68020, floating
                    440: coprocessor or none.  A single installed version of the compiler can
                    441: compile for any model or configuration, according to the options
                    442: specified.
                    443: 
                    444:    Some configurations of the compiler also support additional special
                    445: options, usually for compatibility with other compilers on the same
                    446: platform.
                    447: 
                    448:    These options are defined by the macro `TARGET_SWITCHES' in the
                    449: machine description.  The default for the options is also defined by
                    450: that macro, which enables you to change the defaults.
                    451: 
                    452: * Menu:
                    453: 
                    454: * M680x0 Options::
                    455: * VAX Options::
                    456: * SPARC Options::
                    457: * Convex Options::
                    458: * AMD29K Options::
                    459: * M88K Options::
                    460: * RS/6000 Options::
                    461: * RT Options::
                    462: * MIPS Options::
                    463: * i386 Options::
                    464: * HPPA Options::
                    465: * Intel 960 Options::
                    466: * DEC Alpha Options::
                    467: * System V Options::
                    468: 
                    469: 
                    470: File: gcc.info,  Node: M680x0 Options,  Next: VAX Options,  Up: Submodel Options
                    471: 
                    472: M680x0 Options
                    473: --------------
                    474: 
                    475:    These are the `-m' options defined for the 68000 series.  The default
                    476: values for these options depends on which style of 68000 was selected
                    477: when the compiler was configured; the defaults for the most common
                    478: choices are given below.
                    479: 
                    480: `-m68000'
                    481: `-mc68000'
                    482:      Generate output for a 68000.  This is the default when the
                    483:      compiler is configured for 68000-based systems.
                    484: 
                    485: `-m68020'
                    486: `-mc68020'
                    487:      Generate output for a 68020.  This is the default when the
                    488:      compiler is configured for 68020-based systems.
                    489: 
                    490: `-m68881'
                    491:      Generate output containing 68881 instructions for floating point.
                    492:      This is the default for most 68020 systems unless `-nfp' was
                    493:      specified when the compiler was configured.
                    494: 
                    495: `-m68030'
                    496:      Generate output for a 68030.  This is the default when the
                    497:      compiler is configured for 68030-based systems.
                    498: 
                    499: `-m68040'
                    500:      Generate output for a 68040.  This is the default when the
                    501:      compiler is configured for 68040-based systems.
                    502: 
                    503: `-m68020-40'
                    504:      Generate output for a 68040, without using any of the new
1.1.1.5 ! root      505:      instructions.  This results in code which can run relatively
1.1.1.4   root      506:      efficiently on either a 68020/68881 or a 68030 or a 68040.
                    507: 
                    508: `-mfpa'
                    509:      Generate output containing Sun FPA instructions for floating point.
                    510: 
                    511: `-msoft-float'
                    512:      Generate output containing library calls for floating point.
                    513:      *Warning:* the requisite libraries are not part of GNU CC.
                    514:      Normally the facilities of the machine's usual C compiler are
                    515:      used, but this can't be done directly in cross-compilation.  You
                    516:      must make your own arrangements to provide suitable library
                    517:      functions for cross-compilation.
                    518: 
                    519: `-mshort'
                    520:      Consider type `int' to be 16 bits wide, like `short int'.
                    521: 
                    522: `-mnobitfield'
1.1.1.5 ! root      523:      Do not use the bit-field instructions.  The `-m68000' option
        !           524:      implies `-mnobitfield'.
1.1.1.4   root      525: 
                    526: `-mbitfield'
1.1.1.5 ! root      527:      Do use the bit-field instructions.  The `-m68020' option implies
        !           528:      `-mbitfield'.  This is the default if you use a configuration
        !           529:      designed for a 68020.
1.1.1.4   root      530: 
                    531: `-mrtd'
                    532:      Use a different function-calling convention, in which functions
                    533:      that take a fixed number of arguments return with the `rtd'
                    534:      instruction, which pops their arguments while returning.  This
                    535:      saves one instruction in the caller since there is no need to pop
                    536:      the arguments there.
                    537: 
                    538:      This calling convention is incompatible with the one normally used
                    539:      on Unix, so you cannot use it if you need to call libraries
                    540:      compiled with the Unix compiler.
                    541: 
                    542:      Also, you must provide function prototypes for all functions that
                    543:      take variable numbers of arguments (including `printf'); otherwise
                    544:      incorrect code will be generated for calls to those functions.
                    545: 
                    546:      In addition, seriously incorrect code will result if you call a
                    547:      function with too many arguments.  (Normally, extra arguments are
                    548:      harmlessly ignored.)
                    549: 
                    550:      The `rtd' instruction is supported by the 68010 and 68020
                    551:      processors, but not by the 68000.
                    552: 
                    553: 
                    554: File: gcc.info,  Node: VAX Options,  Next: SPARC Options,  Prev: M680x0 Options,  Up: Submodel Options
                    555: 
                    556: VAX Options
                    557: -----------
                    558: 
                    559:    These `-m' options are defined for the Vax:
                    560: 
                    561: `-munix'
                    562:      Do not output certain jump instructions (`aobleq' and so on) that
                    563:      the Unix assembler for the Vax cannot handle across long ranges.
                    564: 
                    565: `-mgnu'
                    566:      Do output those jump instructions, on the assumption that you will
                    567:      assemble with the GNU assembler.
                    568: 
                    569: `-mg'
                    570:      Output code for g-format floating point numbers instead of
                    571:      d-format.
                    572: 
                    573: 
1.1.1.5 ! root      574: File: gcc.info,  Node: SPARC Options,  Next: Convex Options,  Prev: VAX Options,  Up: Submodel Options
1.1.1.4   root      575: 
                    576: SPARC Options
                    577: -------------
                    578: 
1.1.1.5 ! root      579:    These `-m' switches are supported on the SPARC:
1.1.1.4   root      580: 
1.1.1.5 ! root      581: `-mfpu'
        !           582: `-mhard-float'
        !           583:      Generate output containing floating point instructions.  This is
        !           584:      the default.
        !           585: 
        !           586: `-mno-fpu'
        !           587: `-msoft-float'
        !           588:      Generate output containing library calls for floating point.
        !           589:      *Warning:* there is no GNU floating-point library for SPARC.
        !           590:      Normally the facilities of the machine's usual C compiler are
        !           591:      used, but this cannot be done directly in cross-compilation.  You
        !           592:      must make your own arrangements to provide suitable library
        !           593:      functions for cross-compilation.
        !           594: 
        !           595:      `-msoft-float' changes the calling convention in the output file;
        !           596:      therefore, it is only useful if you compile *all* of a program with
        !           597:      this option.  In particular, you need to compile `libgcc.a', the
        !           598:      library that comes with GNU CC, with `-msoft-float' in order for
        !           599:      this to work.
1.1.1.4   root      600: 
                    601: `-mno-epilogue'
1.1.1.5 ! root      602: `-mepilogue'
        !           603:      With `-mepilogue' (the default), the compiler always emits code for
        !           604:      function exit at the end of each function.  Any function exit in
        !           605:      the middle of the function (such as a return statement in C) will
        !           606:      generate a jump to the exit code at the end of the function.
        !           607: 
        !           608:      With `-mno-epilogue', the compiler tries to emit exit code inline
        !           609:      at every function exit.
        !           610: 
        !           611: `-mv8'
        !           612: `-msparclite'
        !           613:      These two options select variations on the SPARC architecture.
        !           614: 
        !           615:      By default (unless specifically configured for the Fujitsu
        !           616:      SPARClite), GCC generates code for the v7 variant of the SPARC
        !           617:      architecture.
        !           618: 
        !           619:      `-mv8' will give you SPARC v8 code.  The only difference from v7
        !           620:      code is that the compiler emits the integer multiply and integer
        !           621:      divide instructions which exist in SPARC v8 but not in SPARC v7.
        !           622: 
        !           623:      `-msparclite' will give you SPARClite code.  This adds the integer
        !           624:      multiply, integer divide step and scan (`ffs') instructions which
        !           625:      exist in SPARClite but not in SPARC v7.
1.1.1.4   root      626: 
                    627: 
                    628: File: gcc.info,  Node: Convex Options,  Next: AMD29K Options,  Prev: SPARC Options,  Up: Submodel Options
                    629: 
                    630: Convex Options
                    631: --------------
                    632: 
1.1.1.5 ! root      633:    These `-m' options are defined for Convex:
1.1.1.4   root      634: 
                    635: `-mc1'
1.1.1.5 ! root      636:      Generate output for C1.  The code will run on any Convex machine.
        !           637:      The preprocessor symbol `__convex__c1__' is defined.
1.1.1.4   root      638: 
                    639: `-mc2'
1.1.1.5 ! root      640:      Generate output for C2.  Uses instructions not available on C1.
        !           641:      Scheduling and other optimizations are chosen for max performance
        !           642:      on C2.  The preprocessor symbol `__convex_c2__' is defined.
        !           643: 
        !           644: `-mc32'
        !           645:      Generate output for C32xx.  Uses instructions not available on C1.
        !           646:      Scheduling and other optimizations are chosen for max performance
        !           647:      on C32.  The preprocessor symbol `__convex_c32__' is defined.
        !           648: 
        !           649: `-mc34'
        !           650:      Generate output for C34xx.  Uses instructions not available on C1.
        !           651:      Scheduling and other optimizations are chosen for max performance
        !           652:      on C34.  The preprocessor symbol `__convex_c34__' is defined.
        !           653: 
        !           654: `-mc38'
        !           655:      Generate output for C38xx.  Uses instructions not available on C1.
        !           656:      Scheduling and other optimizations are chosen for max performance
        !           657:      on C38.  The preprocessor symbol `__convex_c38__' is defined.
1.1.1.4   root      658: 
                    659: `-margcount'
                    660:      Generate code which puts an argument count in the word preceding
1.1.1.5 ! root      661:      each argument list.  This is compatible with regular CC, and a few
        !           662:      programs may need the argument count word.  GDB and other
        !           663:      source-level debuggers do not need it; this info is in the symbol
        !           664:      table.
1.1.1.4   root      665: 
                    666: `-mnoargcount'
1.1.1.5 ! root      667:      Omit the argument count word.  This is the default.
        !           668: 
        !           669: `-mvolatile-cache'
        !           670:      Allow volatile references to be cached.  This is the default.
        !           671: 
        !           672: `-mvolatile-nocache'
        !           673:      Volatile references bypass the data cache, going all the way to
        !           674:      memory.  This is only needed for multi-processor code that does
        !           675:      not use standard synchronization instructions.  Making
        !           676:      non-volatile references to volatile locations will not necessarily
        !           677:      work.
        !           678: 
        !           679: `-mlong32'
        !           680:      Type long is 32 bits, the same as type int.  This is the default.
        !           681: 
        !           682: `-mlong64'
        !           683:      Type long is 64 bits, the same as type long long.  This option is
        !           684:      useless, because no library support exists for it.
1.1.1.4   root      685: 
                    686: 
                    687: File: gcc.info,  Node: AMD29K Options,  Next: M88K Options,  Prev: Convex Options,  Up: Submodel Options
                    688: 
                    689: AMD29K Options
                    690: --------------
                    691: 
                    692:    These `-m' options are defined for the AMD Am29000:
                    693: 
                    694: `-mdw'
                    695:      Generate code that assumes the `DW' bit is set, i.e., that byte and
                    696:      halfword operations are directly supported by the hardware.  This
                    697:      is the default.
                    698: 
                    699: `-mnodw'
                    700:      Generate code that assumes the `DW' bit is not set.
                    701: 
                    702: `-mbw'
                    703:      Generate code that assumes the system supports byte and halfword
                    704:      write operations.  This is the default.
                    705: 
                    706: `-mnbw'
                    707:      Generate code that assumes the systems does not support byte and
                    708:      halfword write operations.  `-mnbw' implies `-mnodw'.
                    709: 
                    710: `-msmall'
                    711:      Use a small memory model that assumes that all function addresses
                    712:      are either within a single 256 KB segment or at an absolute
1.1.1.5 ! root      713:      address of less than 256k.  This allows the `call' instruction to
1.1.1.4   root      714:      be used instead of a `const', `consth', `calli' sequence.
                    715: 
                    716: `-mlarge'
                    717:      Do not assume that the `call' instruction can be used; this is the
                    718:      default.
                    719: 
                    720: `-m29050'
                    721:      Generate code for the Am29050.
                    722: 
                    723: `-m29000'
                    724:      Generate code for the Am29000.  This is the default.
                    725: 
                    726: `-mkernel-registers'
1.1.1.5 ! root      727:      Generate references to registers `gr64-gr95' instead of to
        !           728:      registers `gr96-gr127'.  This option can be used when compiling
        !           729:      kernel code that wants a set of global registers disjoint from
        !           730:      that used by user-mode code.
1.1.1.4   root      731: 
                    732:      Note that when this option is used, register names in `-f' flags
                    733:      must use the normal, user-mode, names.
                    734: 
                    735: `-muser-registers'
                    736:      Use the normal set of global registers, `gr96-gr127'.  This is the
                    737:      default.
                    738: 
                    739: `-mstack-check'
                    740:      Insert a call to `__msp_check' after each stack adjustment.  This
                    741:      is often used for kernel code.
1.1       root      742: 
                    743: 
                    744: File: gcc.info,  Node: M88K Options,  Next: RS/6000 Options,  Prev: AMD29K Options,  Up: Submodel Options
                    745: 
                    746: M88K Options
                    747: ------------
                    748: 
1.1.1.5 ! root      749:    These `-m' options are defined for Motorola 88k architectures:
1.1       root      750: 
                    751: `-m88000'
                    752:      Generate code that works well on both the m88100 and the m88110.
                    753: 
                    754: `-m88100'
1.1.1.4   root      755:      Generate code that works best for the m88100, but that also runs
                    756:      on the m88110.
1.1       root      757: 
                    758: `-m88110'
                    759:      Generate code that works best for the m88110, and may not run on
                    760:      the m88100.
                    761: 
1.1.1.5 ! root      762: `-mbig-pic'
        !           763:      Obsolete option to be removed from the next revision.  Use `-fPIC'.
        !           764: 
1.1       root      765: `-midentify-revision'
                    766:      Include an `ident' directive in the assembler output recording the
                    767:      source file name, compiler name and version, timestamp, and
                    768:      compilation flags used.
                    769: 
                    770: `-mno-underscores'
1.1.1.3   root      771:      In assembler output, emit symbol names without adding an underscore
                    772:      character at the beginning of each name.  The default is to use an
                    773:      underscore as prefix on each name.
1.1       root      774: 
                    775: `-mocs-debug-info'
                    776: `-mno-ocs-debug-info'
                    777:      Include (or omit) additional debugging information (about
                    778:      registers used in each stack frame) as specified in the 88open
                    779:      Object Compatibility Standard, "OCS".  This extra information
                    780:      allows debugging of code that has had the frame pointer
                    781:      eliminated.  The default for DG/UX, SVr4, and Delta 88 SVr3.2 is
                    782:      to include this information; other 88k configurations omit this
                    783:      information by default.
                    784: 
                    785: `-mocs-frame-position'
                    786:      When emitting COFF debugging information for automatic variables
                    787:      and parameters stored on the stack, use the offset from the
                    788:      canonical frame address, which is the stack pointer (register 31)
                    789:      on entry to the function.  The DG/UX, SVr4, Delta88 SVr3.2, and
                    790:      BCS configurations use `-mocs-frame-position'; other 88k
                    791:      configurations have the default `-mno-ocs-frame-position'.
                    792: 
                    793: `-mno-ocs-frame-position'
                    794:      When emitting COFF debugging information for automatic variables
                    795:      and parameters stored on the stack, use the offset from the frame
                    796:      pointer register (register 30).  When this option is in effect,
                    797:      the frame pointer is not eliminated when debugging information is
                    798:      selected by the -g switch.
                    799: 
                    800: `-moptimize-arg-area'
                    801: `-mno-optimize-arg-area'
1.1.1.5 ! root      802:      Control how function arguments are stored in stack frames.
        !           803:      `-moptimize-arg-area' saves space by optimizing them, but this
        !           804:      conflicts with the 88open specifications.  The opposite
        !           805:      alternative, `-mno-optimize-arg-area', agrees with 88open
1.1.1.4   root      806:      standards.  By default GNU CC does not optimize the argument area.
1.1       root      807: 
                    808: `-mshort-data-NUM'
                    809:      Generate smaller data references by making them relative to `r0',
                    810:      which allows loading a value using a single instruction (rather
                    811:      than the usual two).  You control which data references are
                    812:      affected by specifying NUM with this option.  For example, if you
                    813:      specify `-mshort-data-512', then the data references affected are
1.1.1.3   root      814:      those involving displacements of less than 512 bytes.
1.1.1.5 ! root      815:      `-mshort-data-NUM' is not effective for NUM greater than 64k.
1.1       root      816: 
1.1.1.4   root      817: `-mserialize-volatile'
                    818: `-mno-serialize-volatile'
1.1.1.5 ! root      819:      Do, or do not, generate code to guarantee sequential consistency of
1.1.1.4   root      820:      volatile memory references.
                    821: 
                    822:      GNU CC always guarantees consistency by default, for the preferred
                    823:      processor submodel.  How this is done depends on the submodel.
                    824: 
                    825:      The m88100 processor does not reorder memory references and so
                    826:      always provides sequential consistency.  If you use `-m88100', GNU
                    827:      CC does not generate any special instructions for sequential
                    828:      consistency.
                    829: 
                    830:      The order of memory references made by the m88110 processor does
                    831:      not always match the order of the instructions requesting those
1.1.1.5 ! root      832:      references.  In particular, a load instruction may execute before
        !           833:      a preceding store instruction.  Such reordering violates
        !           834:      sequential consistency of volatile memory references, when there
        !           835:      are multiple processors.  When you use `-m88000' or `-m88110', GNU
        !           836:      CC generates special instructions when appropriate, to force
        !           837:      execution in the proper order.
1.1.1.4   root      838: 
                    839:      The extra code generated to guarantee consistency may affect the
                    840:      performance of your application.  If you know that you can safely
1.1.1.5 ! root      841:      forgo this guarantee, you may use the option
        !           842:      `-mno-serialize-volatile'.
1.1.1.4   root      843: 
1.1.1.5 ! root      844:      If you use the `-m88100' option but require sequential consistency
        !           845:      when running on the m88110 processor, you should use
1.1.1.4   root      846:      `-mserialize-volatile'.
                    847: 
1.1       root      848: `-msvr4'
                    849: `-msvr3'
                    850:      Turn on (`-msvr4') or off (`-msvr3') compiler extensions related
                    851:      to System V release 4 (SVr4).  This controls the following:
                    852: 
                    853:        1. Which variant of the assembler syntax to emit (which you can
                    854:           select independently using `-mversion-03.00').
                    855: 
                    856:        2. `-msvr4' makes the C preprocessor recognize `#pragma weak'
                    857:           that is used on System V release 4.
                    858: 
1.1.1.3   root      859:        3. `-msvr4' makes GNU CC issue additional declaration directives
                    860:           used in SVr4.
1.1       root      861: 
1.1.1.5 ! root      862:      `-msvr3' is the default for all m88k configurations except the
1.1       root      863:      SVr4 configuration.
                    864: 
                    865: `-mversion-03.00'
                    866:      In the DG/UX configuration, there are two flavors of SVr4.  This
                    867:      option modifies `-msvr4' to select whether the hybrid-COFF or
                    868:      real-ELF flavor is used.  All other configurations ignore this
                    869:      option.
                    870: 
                    871: `-mno-check-zero-division'
                    872: `-mcheck-zero-division'
1.1.1.5 ! root      873:      Early models of the 88k architecture had problems with division by
1.1.1.3   root      874:      zero; in particular, many of them didn't trap.  Use these options
                    875:      to avoid including (or to include explicitly) additional code to
                    876:      detect division by zero and signal an exception.  All GNU CC
1.1.1.5 ! root      877:      configurations for the 88k use `-mcheck-zero-division' by default.
1.1       root      878: 
                    879: `-muse-div-instruction'
                    880:      Do not emit code to check both the divisor and dividend when doing
                    881:      signed integer division to see if either is negative, and adjust
1.1.1.5 ! root      882:      the signs so the divide is done using non-negative numbers.
1.1       root      883:      Instead, rely on the operating system to calculate the correct
1.1.1.3   root      884:      value when the `div' instruction traps.  This results in different
                    885:      behavior when the most negative number is divided by -1, but is
                    886:      useful when most or all signed integer divisions are done with
                    887:      positive numbers.
1.1       root      888: 
                    889: `-mtrap-large-shift'
                    890: `-mhandle-large-shift'
                    891:      Include code to detect bit-shifts of more than 31 bits;
                    892:      respectively, trap such shifts or emit code to handle them
                    893:      properly.  By default GNU CC makes no special provision for large
                    894:      bit shifts.
                    895: 
                    896: `-mwarn-passed-structs'
1.1.1.3   root      897:      Warn when a function passes a struct as an argument or result.
                    898:      Structure-passing conventions have changed during the evolution of
1.1.1.5 ! root      899:      the C language, and are often the source of portability problems.
1.1.1.3   root      900:      By default, GNU CC issues no such warning.
1.1       root      901: 
                    902: 
                    903: File: gcc.info,  Node: RS/6000 Options,  Next: RT Options,  Prev: M88K Options,  Up: Submodel Options
                    904: 
                    905: IBM RS/6000 Options
                    906: -------------------
                    907: 
                    908:    Only one pair of `-m' options is defined for the IBM RS/6000:
                    909: 
                    910: `-mfp-in-toc'
                    911: `-mno-fp-in-toc'
                    912:      Control whether or not floating-point constants go in the Table of
                    913:      Contents (TOC), a table of all global variable and function
1.1.1.3   root      914:      addresses.  By default GNU CC puts floating-point constants there;
                    915:      if the TOC overflows, `-mno-fp-in-toc' will reduce the size of the
                    916:      TOC, which may avoid the overflow.
1.1       root      917: 
                    918: 
                    919: File: gcc.info,  Node: RT Options,  Next: MIPS Options,  Prev: RS/6000 Options,  Up: Submodel Options
                    920: 
                    921: IBM RT Options
                    922: --------------
                    923: 
                    924:    These `-m' options are defined for the IBM RT PC:
                    925: 
                    926: `-min-line-mul'
                    927:      Use an in-line code sequence for integer multiplies.  This is the
                    928:      default.
                    929: 
                    930: `-mcall-lib-mul'
                    931:      Call `lmul$$' for integer multiples.
                    932: 
                    933: `-mfull-fp-blocks'
                    934:      Generate full-size floating point data blocks, including the
                    935:      minimum amount of scratch space recommended by IBM.  This is the
                    936:      default.
                    937: 
                    938: `-mminimum-fp-blocks'
1.1.1.5 ! root      939:      Do not include extra scratch space in floating point data blocks.
1.1.1.3   root      940:      This results in smaller code, but slower execution, since scratch
                    941:      space must be allocated dynamically.
1.1       root      942: 
                    943: `-mfp-arg-in-fpregs'
                    944:      Use a calling sequence incompatible with the IBM calling
                    945:      convention in which floating point arguments are passed in
1.1.1.5 ! root      946:      floating point registers.  Note that `varargs.h' and `stdargs.h'
1.1       root      947:      will not work with floating point operands if this option is
                    948:      specified.
                    949: 
                    950: `-mfp-arg-in-gregs'
1.1.1.5 ! root      951:      Use the normal calling convention for floating point arguments.
1.1       root      952:      This is the default.
                    953: 
                    954: `-mhc-struct-return'
1.1.1.3   root      955:      Return structures of more than one word in memory, rather than in a
                    956:      register.  This provides compatibility with the MetaWare HighC (hc)
1.1.1.5 ! root      957:      compiler.  Use the option `-fpcc-struct-return' for compatibility
        !           958:      with the Portable C Compiler (pcc).
1.1       root      959: 
                    960: `-mnohc-struct-return'
                    961:      Return some structures of more than one word in registers, when
                    962:      convenient.  This is the default.  For compatibility with the
1.1.1.5 ! root      963:      IBM-supplied compilers, use the option `-fpcc-struct-return' or the
        !           964:      option `-mhc-struct-return'.
1.1       root      965: 
                    966: 
1.1.1.2   root      967: File: gcc.info,  Node: MIPS Options,  Next: i386 Options,  Prev: RT Options,  Up: Submodel Options
1.1       root      968: 
                    969: MIPS Options
                    970: ------------
                    971: 
                    972:    These `-m' options are defined for the MIPS family of computers:
                    973: 
                    974: `-mcpu=CPU TYPE'
                    975:      Assume the defaults for the machine type CPU TYPE when scheduling
1.1.1.2   root      976:      instructions.  The default CPU TYPE is `default', which picks the
1.1       root      977:      longest cycles times for any of the machines, in order that the
1.1.1.3   root      978:      code run at reasonable rates on all MIPS cpu's.  Other choices for
                    979:      CPU TYPE are `r2000', `r3000', `r4000', and `r6000'.  While
                    980:      picking a specific CPU TYPE will schedule things appropriately for
                    981:      that particular chip, the compiler will not generate any code that
                    982:      does not meet level 1 of the MIPS ISA (instruction set
                    983:      architecture) without the `-mips2' or `-mips3' switches being used.
1.1       root      984: 
                    985: `-mips2'
                    986:      Issue instructions from level 2 of the MIPS ISA (branch likely,
                    987:      square root instructions).  The `-mcpu=r4000' or `-mcpu=r6000'
1.1.1.3   root      988:      switch must be used in conjunction with `-mips2'.
1.1       root      989: 
                    990: `-mips3'
                    991:      Issue instructions from level 3 of the MIPS ISA (64 bit
1.1.1.5 ! root      992:      instructions).  You must use the `-mcpu=r4000' switch along with
1.1       root      993:      `-mips3'.
                    994: 
                    995: `-mint64'
                    996: `-mlong64'
                    997: `-mlonglong128'
                    998:      These options don't work at present.
                    999: 
                   1000: `-mmips-as'
                   1001:      Generate code for the MIPS assembler, and invoke `mips-tfile' to
                   1002:      add normal debug information.  This is the default for all
                   1003:      platforms except for the OSF/1 reference platform, using the
                   1004:      OSF/rose object format.  If the either of the `-gstabs' or
                   1005:      `-gstabs+' switches are used, the `mips-tfile' program will
                   1006:      encapsulate the stabs within MIPS ECOFF.
                   1007: 
                   1008: `-mgas'
                   1009:      Generate code for the GNU assembler.  This is the default on the
                   1010:      OSF/1 reference platform, using the OSF/rose object format.
                   1011: 
                   1012: `-mrnames'
                   1013: `-mno-rnames'
                   1014:      The `-mrnames' switch says to output code using the MIPS software
                   1015:      names for the registers, instead of the hardware names (ie, A0
1.1.1.3   root     1016:      instead of $4).  The GNU assembler does not support the `-mrnames'
                   1017:      switch, and the MIPS assembler will be instructed to run the MIPS
                   1018:      C preprocessor over the source file.  The `-mno-rnames' switch is
                   1019:      default.
1.1       root     1020: 
                   1021: `-mgpopt'
                   1022: `-mno-gpopt'
                   1023:      The `-mgpopt' switch says to write all of the data declarations
1.1.1.2   root     1024:      before the instructions in the text section, this allows the MIPS
1.1       root     1025:      assembler to generate one word memory references instead of using
                   1026:      two words for short global or static data items.  This is on by
                   1027:      default if optimization is selected.
                   1028: 
                   1029: `-mstats'
                   1030: `-mno-stats'
                   1031:      For each non-inline function processed, the `-mstats' switch
                   1032:      causes the compiler to emit one line to the standard error file to
                   1033:      print statistics about the program (number of registers saved,
                   1034:      stack size, etc.).
                   1035: 
                   1036: `-mmemcpy'
                   1037: `-mno-memcpy'
                   1038:      The `-mmemcpy' switch makes all block moves call the appropriate
                   1039:      string function (`memcpy' or `bcopy') instead of possibly
                   1040:      generating inline code.
                   1041: 
                   1042: `-mmips-tfile'
                   1043: `-mno-mips-tfile'
                   1044:      The `-mno-mips-tfile' switch causes the compiler not postprocess
                   1045:      the object file with the `mips-tfile' program, after the MIPS
                   1046:      assembler has generated it to add debug support.  If `mips-tfile'
                   1047:      is not run, then no local variables will be available to the
                   1048:      debugger.  In addition, `stage2' and `stage3' objects will have
                   1049:      the temporary file names passed to the assembler embedded in the
1.1.1.5 ! root     1050:      object file, which means the objects will not compare the same.
1.1.1.2   root     1051:      The `-mno-mips-tfile' switch should only be used when there are
                   1052:      bugs in the `mips-tfile' program that prevents compilation.
1.1       root     1053: 
                   1054: `-msoft-float'
1.1.1.3   root     1055:      Generate output containing library calls for floating point.
                   1056:      *Warning:* the requisite libraries are not part of GNU CC.
1.1       root     1057:      Normally the facilities of the machine's usual C compiler are
                   1058:      used, but this can't be done directly in cross-compilation.  You
                   1059:      must make your own arrangements to provide suitable library
                   1060:      functions for cross-compilation.
                   1061: 
                   1062: `-mhard-float'
                   1063:      Generate output containing floating point instructions.  This is
                   1064:      the default if you use the unmodified sources.
                   1065: 
                   1066: `-mfp64'
                   1067:      Assume that the FR bit in the status word is on, and that there
                   1068:      are 32 64-bit floating point registers, instead of 32 32-bit
1.1.1.3   root     1069:      floating point registers.  You must also specify the `-mcpu=r4000'
                   1070:      and `-mips3' switches.
1.1       root     1071: 
                   1072: `-mfp32'
1.1.1.3   root     1073:      Assume that there are 32 32-bit floating point registers.  This is
                   1074:      the default.
1.1       root     1075: 
                   1076: `-mabicalls'
                   1077: `-mno-abicalls'
1.1.1.5 ! root     1078:      Emit (or do not emit) the pseudo operations `.abicalls',
        !          1079:      `.cpload', and `.cprestore' that some System V.4 ports use for
        !          1080:      position independent code.
        !          1081: 
        !          1082: `-mlong-calls'
        !          1083: `-mlong-calls'
        !          1084:      Do all calls with the `JALR' instruction, which requires loading
        !          1085:      up a function's address into a register before the call.  You need
        !          1086:      to use this switch, if you call outside of the current 512
        !          1087:      megabyte segment to functions that are not through pointers.
1.1       root     1088: 
                   1089: `-mhalf-pic'
                   1090: `-mno-half-pic'
                   1091:      Put pointers to extern references into the data section and load
1.1.1.5 ! root     1092:      them up, rather than put the references in the text section.
1.1       root     1093: 
                   1094: `-G NUM'
                   1095:      Put global and static items less than or equal to NUM bytes into
                   1096:      the small data or bss sections instead of the normal data or bss
                   1097:      section.  This allows the assembler to emit one word memory
                   1098:      reference instructions based on the global pointer (GP or $28),
                   1099:      instead of the normal two words used.  By default, NUM is 8 when
1.1.1.5 ! root     1100:      the MIPS assembler is used, and 0 when the GNU assembler is used.
1.1.1.3   root     1101:      The `-G NUM' switch is also passed to the assembler and linker.
1.1       root     1102:      All modules should be compiled with the same `-G NUM' value.
                   1103: 
1.1.1.2   root     1104: `-nocpp'
                   1105:      Tell the MIPS assembler to not run it's preprocessor over user
                   1106:      assembler files (with a `.s' suffix) when assembling them.
                   1107: 
1.1       root     1108:    These options are defined by the macro `TARGET_SWITCHES' in the
                   1109: machine description.  The default for the options is also defined by
                   1110: that macro, which enables you to change the defaults.
                   1111: 
                   1112: 
1.1.1.4   root     1113: File: gcc.info,  Node: i386 Options,  Next: HPPA Options,  Prev: MIPS Options,  Up: Submodel Options
1.1.1.2   root     1114: 
                   1115: Intel 386 Options
                   1116: -----------------
                   1117: 
                   1118:    These `-m' options are defined for the i386 family of computers:
                   1119: 
                   1120: `-m486'
1.1.1.4   root     1121: `-mno-486'
1.1.1.2   root     1122:      Control whether or not code is optimized for a 486 instead of an
                   1123:      386.  Code generated for an 486 will run on a 386 and vice versa.
                   1124: 
                   1125: `-msoft-float'
1.1.1.3   root     1126:      Generate output containing library calls for floating point.
                   1127:      *Warning:* the requisite libraries are not part of GNU CC.
1.1.1.2   root     1128:      Normally the facilities of the machine's usual C compiler are
                   1129:      used, but this can't be done directly in cross-compilation.  You
                   1130:      must make your own arrangements to provide suitable library
                   1131:      functions for cross-compilation.
                   1132: 
1.1.1.4   root     1133:      On machines where a function returns floating point results in the
1.1.1.3   root     1134:      80387 register stack, some floating point opcodes may be emitted
                   1135:      even if `-msoft-float' is used.
1.1.1.2   root     1136: 
1.1.1.4   root     1137: `-mno-fp-ret-in-387'
1.1.1.5 ! root     1138:      Do not use the FPU registers for return values of functions.
1.1.1.4   root     1139: 
                   1140:      The usual calling convention has functions return values of types
1.1.1.5 ! root     1141:      `float' and `double' in an FPU register, even if there is no FPU.
1.1.1.4   root     1142:      The idea is that the operating system should emulate an FPU.
                   1143: 
                   1144:      The option `-mno-fp-ret-in-387' causes such values to be returned
                   1145:      in ordinary CPU registers instead.
                   1146: 
                   1147: 
                   1148: File: gcc.info,  Node: HPPA Options,  Next: Intel 960 Options,  Prev: i386 Options,  Up: Submodel Options
                   1149: 
                   1150: HPPA Options
                   1151: ------------
                   1152: 
1.1.1.5 ! root     1153:    These `-m' options are defined for the HPPA family of computers:
1.1.1.4   root     1154: 
                   1155: `-mpa-risc-1-0'
                   1156:      Generate code for a PA 1.0 processor.
                   1157: 
                   1158: `-mpa-risc-1-1'
                   1159:      Generate code for a PA 1.1 processor.
                   1160: 
                   1161: `-mkernel'
                   1162:      Generate code which is suitable for use in kernels.  Specifically,
                   1163:      avoid `add' instructions in which one of the arguments is the DP
                   1164:      register; generate `addil' instructions instead.  This avoids a
                   1165:      rather serious bug in the HP-UX linker.
                   1166: 
                   1167: `-mshared-libs'
1.1.1.5 ! root     1168:      Generate code that can be linked against HP-UX shared libraries.
1.1.1.4   root     1169:      This option is not fully function yet, and is not on by default
1.1.1.5 ! root     1170:      for any PA target.  Using this option can cause incorrect code to
        !          1171:      be generated by the compiler.
1.1.1.4   root     1172: 
                   1173: `-mno-shared-libs'
1.1.1.5 ! root     1174:      Don't generate code that will be linked against shared libraries.
1.1.1.4   root     1175:      This is the default for all PA targets.
                   1176: 
                   1177: `-mlong-calls'
1.1.1.5 ! root     1178:      Generate code which allows calls to functions greater than 256k
1.1.1.4   root     1179:      away from the caller when the caller and callee are in the same
                   1180:      source file.  Do not turn this option on unless code refuses to
                   1181:      link with "branch out of range errors" from the linker.
                   1182: 
1.1.1.5 ! root     1183: `-mdisable-fpregs'
        !          1184:      Prevent floating point registers from being used in any manner.
        !          1185:      This is necessary for compiling kernels which perform lazy context
        !          1186:      switching of floating point registers.  If you use this option and
        !          1187:      attempt to perform floating point operations, the compiler will
        !          1188:      abort.
        !          1189: 
        !          1190: `-mdisable-indexing'
        !          1191:      Prevent the compiler from using indexing address modes.  This
        !          1192:      avoids some rather obscure problems when compiling MIG generated
        !          1193:      code under MACH.
        !          1194: 
        !          1195: `-mtrailing-colon'
        !          1196:      Add a colon to the end of label definitions (for ELF assemblers).
        !          1197: 
1.1.1.4   root     1198: 
                   1199: File: gcc.info,  Node: Intel 960 Options,  Next: DEC Alpha Options,  Prev: HPPA Options,  Up: Submodel Options
                   1200: 
                   1201: Intel 960 Options
                   1202: -----------------
                   1203: 
                   1204:    These `-m' options are defined for the Intel 960 implementations:
                   1205: 
                   1206: `-mCPU TYPE'
                   1207:      Assume the defaults for the machine type CPU TYPE for some of the
                   1208:      other options, including instruction scheduling, floating point
                   1209:      support, and addressing modes.  The choices for CPU TYPE are `ka',
1.1.1.5 ! root     1210:      `kb', `mc', `ca', `cf', `sa', and `sb'.  The default is `kb'.
1.1.1.4   root     1211: 
                   1212: `-mnumerics'
                   1213: `-msoft-float'
                   1214:      The `-mnumerics' option indicates that the processor does support
                   1215:      floating-point instructions.  The `-msoft-float' option indicates
                   1216:      that floating-point support should not be assumed.
                   1217: 
                   1218: `-mleaf-procedures'
                   1219: `-mno-leaf-procedures'
                   1220:      Do (or do not) attempt to alter leaf procedures to be callable
                   1221:      with the `bal' instruction as well as `call'.  This will result in
                   1222:      more efficient code for explicit calls when the `bal' instruction
                   1223:      can be substituted by the assembler or linker, but less efficient
                   1224:      code in other cases, such as calls via function pointers, or using
                   1225:      a linker that doesn't support this optimization.
                   1226: 
                   1227: `-mtail-call'
                   1228: `-mno-tail-call'
                   1229:      Do (or do not) make additional attempts (beyond those of the
                   1230:      machine-independent portions of the compiler) to optimize
                   1231:      tail-recursive calls into branches.  You may not want to do this
                   1232:      because the detection of cases where this is not valid is not
                   1233:      totally complete.  The default is `-mno-tail-call'.
                   1234: 
                   1235: `-mcomplex-addr'
                   1236: `-mno-complex-addr'
                   1237:      Assume (or do not assume) that the use of a complex addressing
                   1238:      mode is a win on this implementation of the i960.  Complex
                   1239:      addressing modes may not be worthwhile on the K-series, but they
1.1.1.5 ! root     1240:      definitely are on the C-series.  The default is currently
1.1.1.4   root     1241:      `-mcomplex-addr' for all processors except the CB and CC.
                   1242: 
                   1243: `-mcode-align'
                   1244: `-mno-code-align'
                   1245:      Align code to 8-byte boundaries for faster fetching (or don't
1.1.1.5 ! root     1246:      bother).  Currently turned on by default for C-series
1.1.1.4   root     1247:      implementations only.
                   1248: 
                   1249: `-mic-compat'
                   1250: `-mic2.0-compat'
                   1251: `-mic3.0-compat'
                   1252:      Enable compatibility with iC960 v2.0 or v3.0.
                   1253: 
                   1254: `-masm-compat'
                   1255: `-mintel-asm'
                   1256:      Enable compatibility with the iC960 assembler.
                   1257: 
                   1258: `-mstrict-align'
                   1259: `-mno-strict-align'
                   1260:      Do not permit (do permit) unaligned accesses.
                   1261: 
                   1262: `-mold-align'
                   1263:      Enable structure-alignment compatibility with Intel's gcc release
                   1264:      version 1.3 (based on gcc 1.37).  Currently this is buggy in that
                   1265:      `#pragma align 1' is always assumed as well, and cannot be turned
                   1266:      off.
                   1267: 

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