This is Info file gcc.info, produced by Makeinfo-1.54 from the input file gcc.texi. This file documents the use and the internals of the GNU compiler. Published by the Free Software Foundation 675 Massachusetts Avenue Cambridge, MA 02139 USA Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the sections entitled "GNU General Public License" and "Protect Your Freedom--Fight `Look And Feel'" are included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that the sections entitled "GNU General Public License" and "Protect Your Freedom--Fight `Look And Feel'", and this permission notice, may be included in translations approved by the Free Software Foundation instead of in the original English.  File: gcc.info, Node: Optimize Options, Next: Preprocessor Options, Prev: Debugging Options, Up: Invoking GCC Options That Control Optimization ================================= These options control various sorts of optimizations: `-O' `-O1' Optimize. Optimizing compilation takes somewhat more time, and a lot more memory for a large function. Without `-O', the compiler's goal is to reduce the cost of compilation and to make debugging produce the expected results. Statements are independent: if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the function and get exactly the results you would expect from the source code. Without `-O', only variables declared `register' are allocated in registers. The resulting compiled code is a little worse than produced by PCC without `-O'. With `-O', the compiler tries to reduce code size and execution time. When `-O' is specified, the two options `-fthread-jumps' and `-fdelayed-branch' are turned on. On some machines other flags may also be turned on. `-O2' Optimize even more. Nearly all supported optimizations that do not involve a space-speed tradeoff are performed. As compared to `-O', this option increases both compilation time and the performance of the generated code. `-O2' turns on all optional optimizations except for loop unrolling and frame pointer elimination. `-O0' Do not optimize. If you use multiple `-O' options, with or without level numbers, the last such option is the one that is effective. Options of the form `-fFLAG' specify machine-independent flags. Most flags have both positive and negative forms; the negative form of `-ffoo' would be `-fno-foo'. In the table below, only one of the forms is listed--the one which is not the default. You can figure out the other form by either removing `no-' or adding it. `-ffloat-store' Do not store floating point variables in registers, and inhibit other options that might change whether a floating point value is taken from a register or memory. This option prevents undesirable excess precision on machines such as the 68000 where the floating registers (of the 68881) keep more precision than a `double' is supposed to have. For most programs, the excess precision does only good, but a few programs rely on the precise definition of IEEE floating point. Use `-ffloat-store' for such programs. `-fno-default-inline' Do not make member functions inline by default merely because they are defined inside the class scope (C++ only). Otherwise, when you specify `-O', member functions defined inside class scope are compiled inline by default; i.e., you don't need to add `inline' in front of the member function name. `-fno-defer-pop' Always pop the arguments to each function call as soon as that function returns. For machines which must pop arguments after a function call, the compiler normally lets arguments accumulate on the stack for several function calls and pops them all at once. `-fforce-mem' Force memory operands to be copied into registers before doing arithmetic on them. This may produce better code by making all memory references potential common subexpressions. When they are not common subexpressions, instruction combination should eliminate the separate register-load. I am interested in hearing about the difference this makes. `-fforce-addr' Force memory address constants to be copied into registers before doing arithmetic on them. This may produce better code just as `-fforce-mem' may. I am interested in hearing about the difference this makes. `-fomit-frame-pointer' Don't keep the frame pointer in a register for functions that don't need one. This avoids the instructions to save, set up and restore frame pointers; it also makes an extra register available in many functions. *It also makes debugging impossible on some machines.* On some machines, such as the Vax, this flag has no effect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesn't exist. The machine-description macro `FRAME_POINTER_REQUIRED' controls whether a target machine supports this flag. *Note Registers::. `-fno-inline' Don't pay attention to the `inline' keyword. Normally this option is used to keep the compiler from expanding any functions inline. Note that if you are not optimizing, no functions can be expanded inline. `-finline-functions' Integrate all simple functions into their callers. The compiler heuristically decides which functions are simple enough to be worth integrating in this way. If all calls to a given function are integrated, and the function is declared `static', then the function is normally not output as assembler code in its own right. `-fkeep-inline-functions' Even if all calls to a given function are integrated, and the function is declared `static', nevertheless output a separate run-time callable version of the function. `-fno-function-cse' Do not put function addresses in registers; make each instruction that calls a constant function contain the function's address explicitly. This option results in less efficient code, but some strange hacks that alter the assembler output may be confused by the optimizations performed when this option is not used. `-ffast-math' This option allows GCC to violate some ANSI or IEEE rules and/or specifications in the interest of optimizing code for speed. For example, it allows the compiler to assume arguments to the `sqrt' function are non-negative numbers. This option should never be turned on by any `-O' option since it can result in incorrect output for programs which depend on an exact implementation of IEEE or ANSI rules/specifications for math functions. The following options control specific optimizations. The `-O2' option turns on all of these optimizations except `-funroll-loops' and `-funroll-all-loops'. On most machines, the `-O' option turns on the `-fthread-jumps' and `-fdelayed-branch' options, but specific machines may handle it differently. You can use the following flags in the rare cases when "fine-tuning" of optimizations to be performed is desired. `-fstrength-reduce' Perform the optimizations of loop strength reduction and elimination of iteration variables. `-fthread-jumps' Perform optimizations where we check to see if a jump branches to a location where another comparison subsumed by the first is found. If so, the first branch is redirected to either the destination of the second branch or a point immediately following it, depending on whether the condition is known to be true or false. `-fcse-follow-jumps' In common subexpression elimination, scan through jump instructions when the target of the jump is not reached by any other path. For example, when CSE encounters an `if' statement with an `else' clause, CSE will follow the jump when the condition tested is false. `-fcse-skip-blocks' This is similar to `-fcse-follow-jumps', but causes CSE to follow jumps which conditionally skip over blocks. When CSE encounters a simple `if' statement with no else clause, `-fcse-skip-blocks' causes CSE to follow the jump around the body of the `if'. `-frerun-cse-after-loop' Re-run common subexpression elimination after loop optimizations has been performed. `-fexpensive-optimizations' Perform a number of minor optimizations that are relatively expensive. `-fdelayed-branch' If supported for the target machine, attempt to reorder instructions to exploit instruction slots available after delayed branch instructions. `-fschedule-insns' If supported for the target machine, attempt to reorder instructions to eliminate execution stalls due to required data being unavailable. This helps machines that have slow floating point or memory load instructions by allowing other instructions to be issued until the result of the load or floating point instruction is required. `-fschedule-insns2' Similar to `-fschedule-insns', but requests an additional pass of instruction scheduling after register allocation has been done. This is especially useful on machines with a relatively small number of registers and where memory load instructions take more than one cycle. `-fcaller-saves' Enable values to be allocated in registers that will be clobbered by function calls, by emitting extra instructions to save and restore the registers around such calls. Such allocation is done only when it seems to result in better code than would otherwise be produced. This option is enabled by default on certain machines, usually those which have no call-preserved registers to use instead. `-funroll-loops' Perform the optimization of loop unrolling. This is only done for loops whose number of iterations can be determined at compile time or run time. `-funroll-loop' implies both `-fstrength-reduce' and `-frerun-cse-after-loop'. `-funroll-all-loops' Perform the optimization of loop unrolling. This is done for all loops and usually makes programs run more slowly. `-funroll-all-loops' implies `-fstrength-reduce' as well as `-frerun-cse-after-loop'. `-fno-peephole' Disable any machine-specific peephole optimizations.  File: gcc.info, Node: Preprocessor Options, Next: Assembler Options, Prev: Optimize Options, Up: Invoking GCC Options Controlling the Preprocessor ==================================== These options control the C preprocessor, which is run on each C source file before actual compilation. If you use the `-E' option, nothing is done except preprocessing. Some of these options make sense only together with `-E' because they cause the preprocessor output to be unsuitable for actual compilation. `-include FILE' Process FILE as input before processing the regular input file. In effect, the contents of FILE are compiled first. Any `-D' and `-U' options on the command line are always processed before `-include FILE', regardless of the order in which they are written. All the `-include' and `-imacros' options are processed in the order in which they are written. `-imacros FILE' Process FILE as input, discarding the resulting output, before processing the regular input file. Because the output generated from FILE is discarded, the only effect of `-imacros FILE' is to make the macros defined in FILE available for use in the main input. Any `-D' and `-U' options on the command line are always processed before `-imacros FILE', regardless of the order in which they are written. All the `-include' and `-imacros' options are processed in the order in which they are written. `-idirafter DIR' Add the directory DIR to the second include path. The directories on the second include path are searched when a header file is not found in any of the directories in the main include path (the one that `-I' adds to). `-iprefix PREFIX' Specify PREFIX as the prefix for subsequent `-iwithprefix' options. `-iwithprefix DIR' Add a directory to the second include path. The directory's name is made by concatenating PREFIX and DIR, where PREFIX was specified previously with `-iprefix'. If you have not specified a prefix yet, the directory containing the installed passes of the compiler is used as the default. `-iwithprefixbefore DIR' Add a directory to the main include path. The directory's name is made by concatenating PREFIX and DIR, as in the case of `-iwithprefix'. `-nostdinc' Do not search the standard system directories for header files. Only the directories you have specified with `-I' options (and the current directory, if appropriate) are searched. *Note Directory Options::, for information on `-I'. By using both `-nostdinc' and `-I-', you can limit the include-file search path to only those directories you specify explicitly. `-undef' Do not predefine any nonstandard macros. (Including architecture flags). `-E' Run only the C preprocessor. Preprocess all the C source files specified and output the results to standard output or to the specified output file. `-C' Tell the preprocessor not to discard comments. Used with the `-E' option. `-P' Tell the preprocessor not to generate `#line' commands. Used with the `-E' option. `-M' Tell the preprocessor to output a rule suitable for `make' describing the dependencies of each object file. For each source file, the preprocessor outputs one `make'-rule whose target is the object file name for that source file and whose dependencies are all the `#include' header files it uses. This rule may be a single line or may be continued with `\'-newline if it is long. The list of rules is printed on standard output instead of the preprocessed C program. `-M' implies `-E'. Another way to specify output of a `make' rule is by setting the environment variable `DEPENDENCIES_OUTPUT' (*note Environment Variables::.). `-MM' Like `-M' but the output mentions only the user header files included with `#include "FILE"'. System header files included with `#include ' are omitted. `-MD' Like `-M' but the dependency information is written to files with names made by replacing `.o' with `.d' at the end of the output file names. This is in addition to compiling the input files as specified--`-MD' does not inhibit ordinary compilation the way `-M' does. The Mach utility `md' can be used to merge the `.d' files into a single dependency file suitable for using with the `make' command. `-MMD' Like `-MD' except mention only user header files, not system header files. `-H' Print the name of each header file used, in addition to other normal activities. `-AQUESTION(ANSWER)' Assert the answer ANSWER for QUESTION, in case it is tested with a preprocessor conditional such as `#if #QUESTION(ANSWER)'. `-A-' disables the standard assertions that normally describe the target machine. `-DMACRO' Define macro MACRO with the string `1' as its definition. `-DMACRO=DEFN' Define macro MACRO as DEFN. All instances of `-D' on the command line are processed before any `-U' options. `-UMACRO' Undefine macro MACRO. `-U' options are evaluated after all `-D' options, but before any `-include' and `-imacros' options. `-dM' Tell the preprocessor to output only a list of the macro definitions that are in effect at the end of preprocessing. Used with the `-E' option. `-dD' Tell the preprocessing to pass all macro definitions into the output, in their proper sequence in the rest of the output. `-dN' Like `-dD' except that the macro arguments and contents are omitted. Only `#define NAME' is included in the output. `-trigraphs' Support ANSI C trigraphs. You don't want to know about this brain-damage. The `-ansi' option also has this effect.  File: gcc.info, Node: Assembler Options, Next: Link Options, Prev: Preprocessor Options, Up: Invoking GCC Passing Options to the Assembler ================================ `-Wa,OPTION' Pass OPTION as an option to the assembler. If OPTION contains commas, it is split into multiple options at the commas.  File: gcc.info, Node: Link Options, Next: Directory Options, Prev: Assembler Options, Up: Invoking GCC Options for Linking =================== These options come into play when the compiler links object files into an executable output file. They are meaningless if the compiler is not doing a link step. `OBJECT-FILE-NAME' A file name that does not end in a special recognized suffix is considered to name an object file or library. (Object files are distinguished from libraries by the linker according to the file contents.) If linking is done, these object files are used as input to the linker. `-c' `-S' `-E' If any of these options is used, then the linker is not run, and object file names should not be used as arguments. *Note Overall Options::. `-lLIBRARY' Search the library named LIBRARY when linking. It makes a difference where in the command you write this option; the linker searches processes libraries and object files in the order they are specified. Thus, `foo.o -lz bar.o' searches library `z' after file `foo.o' but before `bar.o'. If `bar.o' refers to functions in `z', those functions may not be loaded. The linker searches a standard list of directories for the library, which is actually a file named `libLIBRARY.a'. The linker then uses this file as if it had been specified precisely by name. The directories searched include several standard system directories plus any that you specify with `-L'. Normally the files found this way are library files--archive files whose members are object files. The linker handles an archive file by scanning through it for members which define symbols that have so far been referenced but not defined. But if the file that is found is an ordinary object file, it is linked in the usual fashion. The only difference between using an `-l' option and specifying a file name is that `-l' surrounds LIBRARY with `lib' and `.a' and searches several directories. `-lobjc' You need this special case of the `-l' option in order to link an Objective C program. `-nostartfiles' Do not use the standard system startup files when linking. The standard libraries are used normally. `-nostdlib' Don't use the standard system libraries and startup files when linking. Only the files you specify will be passed to the linker. `-static' On systems that support dynamic linking, this prevents linking with the shared libraries. On other systems, this option has no effect. `-shared' Produce a shared object which can then be linked with other objects to form an executable. Only a few systems support this option. `-symbolic' Bind references to global symbols when building a shared object. Warn about any unresolved references (unless overridden by the link editor option `-Xlinker -z -Xlinker defs'). Only a few systems support this option. `-Xlinker OPTION' Pass OPTION as an option to the linker. You can use this to supply system-specific linker options which GNU CC does not know how to recognize. If you want to pass an option that takes an argument, you must use `-Xlinker' twice, once for the option and once for the argument. For example, to pass `-assert definitions', you must write `-Xlinker -assert -Xlinker definitions'. It does not work to write `-Xlinker "-assert definitions"', because this passes the entire string as a single argument, which is not what the linker expects. `-Wl,OPTION' Pass OPTION as an option to the linker. If OPTION contains commas, it is split into multiple options at the commas. `-u SYMBOL' Pretend the symbol SYMBOL is undefined, to force linking of library modules to define it. You can use `-u' multiple times with different symbols to force loading of additional library modules.  File: gcc.info, Node: Directory Options, Next: Target Options, Prev: Link Options, Up: Invoking GCC Options for Directory Search ============================ These options specify directories to search for header files, for libraries and for parts of the compiler: `-IDIR' Append directory DIR to the list of directories searched for include files. `-I-' Any directories you specify with `-I' options before the `-I-' option are searched only for the case of `#include "FILE"'; they are not searched for `#include '. If additional directories are specified with `-I' options after the `-I-', these directories are searched for all `#include' directives. (Ordinarily *all* `-I' directories are used this way.) In addition, the `-I-' option inhibits the use of the current directory (where the current input file came from) as the first search directory for `#include "FILE"'. There is no way to override this effect of `-I-'. With `-I.' you can specify searching the directory which was current when the compiler was invoked. That is not exactly the same as what the preprocessor does by default, but it is often satisfactory. `-I-' does not inhibit the use of the standard system directories for header files. Thus, `-I-' and `-nostdinc' are independent. `-LDIR' Add directory DIR to the list of directories to be searched for `-l'. `-BPREFIX' This option specifies where to find the executables, libraries and data files of the compiler itself. The compiler driver program runs one or more of the subprograms `cpp', `cc1', `as' and `ld'. It tries PREFIX as a prefix for each program it tries to run, both with and without `MACHINE/VERSION/' (*note Target Options::.). For each subprogram to be run, the compiler driver first tries the `-B' prefix, if any. If that name is not found, or if `-B' was not specified, the driver tries two standard prefixes, which are `/usr/lib/gcc/' and `/usr/local/lib/gcc-lib/'. If neither of those results in a file name that is found, the unmodified program name is searched for using the directories specified in your `PATH' environment variable. `-B' prefixes that effectively specify directory names also apply to libraries in the linker, because the compiler translates these options into `-L' options for the linker. The run-time support file `libgcc.a' can also be searched for using the `-B' prefix, if needed. If it is not found there, the two standard prefixes above are tried, and that is all. The file is left out of the link if it is not found by those means. Another way to specify a prefix much like the `-B' prefix is to use the environment variable `GCC_EXEC_PREFIX'. *Note Environment Variables::.  File: gcc.info, Node: Target Options, Next: Submodel Options, Prev: Directory Options, Up: Invoking GCC Specifying Target Machine and Compiler Version ============================================== By default, GNU CC compiles code for the same type of machine that you are using. However, it can also be installed as a cross-compiler, to compile for some other type of machine. In fact, several different configurations of GNU CC, for different target machines, can be installed side by side. Then you specify which one to use with the `-b' option. In addition, older and newer versions of GNU CC can be installed side by side. One of them (probably the newest) will be the default, but you may sometimes wish to use another. `-b MACHINE' The argument MACHINE specifies the target machine for compilation. This is useful when you have installed GNU CC as a cross-compiler. The value to use for MACHINE is the same as was specified as the machine type when configuring GNU CC as a cross-compiler. For example, if a cross-compiler was configured with `configure i386v', meaning to compile for an 80386 running System V, then you would specify `-b i386v' to run that cross compiler. When you do not specify `-b', it normally means to compile for the same type of machine that you are using. `-V VERSION' The argument VERSION specifies which version of GNU CC to run. This is useful when multiple versions are installed. For example, VERSION might be `2.0', meaning to run GNU CC version 2.0. The default version, when you do not specify `-V', is controlled by the way GNU CC is installed. Normally, it will be a version that is recommended for general use. The `-b' and `-V' options actually work by controlling part of the file name used for the executable files and libraries used for compilation. A given version of GNU CC, for a given target machine, is normally kept in the directory `/usr/local/lib/gcc-lib/MACHINE/VERSION'. Thus, sites can customize the effect of `-b' or `-V' either by changing the names of these directories or adding alternate names (or symbolic links). If in directory `/usr/local/lib/gcc-lib/' the file `80386' is a link to the file `i386v', then `-b 80386' becomes an alias for `-b i386v'. In one respect, the `-b' or `-V' do not completely change to a different compiler: the top-level driver program `gcc' that you originally invoked continues to run and invoke the other executables (preprocessor, compiler per se, assembler and linker) that do the real work. However, since no real work is done in the driver program, it usually does not matter that the driver program in use is not the one for the specified target and version. The only way that the driver program depends on the target machine is in the parsing and handling of special machine-specific options. However, this is controlled by a file which is found, along with the other executables, in the directory for the specified version and target machine. As a result, a single installed driver program adapts to any specified target machine and compiler version. The driver program executable does control one significant thing, however: the default version and target machine. Therefore, you can install different instances of the driver program, compiled for different targets or versions, under different names. For example, if the driver for version 2.0 is installed as `ogcc' and that for version 2.1 is installed as `gcc', then the command `gcc' will use version 2.1 by default, while `ogcc' will use 2.0 by default. However, you can choose either version with either command with the `-V' option.  File: gcc.info, Node: Submodel Options, Next: Code Gen Options, Prev: Target Options, Up: Invoking GCC Hardware Models and Configurations ================================== Earlier we discussed the standard option `-b' which chooses among different installed compilers for completely different target machines, such as Vax vs. 68000 vs. 80386. In addition, each of these target machine types can have its own special options, starting with `-m', to choose among various hardware models or configurations--for example, 68010 vs 68020, floating coprocessor or none. A single installed version of the compiler can compile for any model or configuration, according to the options specified. Some configurations of the compiler also support additional special options, usually for compatibility with other compilers on the same platform. These options are defined by the macro `TARGET_SWITCHES' in the machine description. The default for the options is also defined by that macro, which enables you to change the defaults. * Menu: * M680x0 Options:: * VAX Options:: * SPARC Options:: * Convex Options:: * AMD29K Options:: * M88K Options:: * RS/6000 and PowerPC Options:: * RT Options:: * MIPS Options:: * i386 Options:: * HPPA Options:: * Intel 960 Options:: * DEC Alpha Options:: * Clipper Options:: * System V Options::  File: gcc.info, Node: M680x0 Options, Next: VAX Options, Up: Submodel Options M680x0 Options -------------- These are the `-m' options defined for the 68000 series. The default values for these options depends on which style of 68000 was selected when the compiler was configured; the defaults for the most common choices are given below. `-m68000' `-mc68000' Generate output for a 68000. This is the default when the compiler is configured for 68000-based systems. `-m68020' `-mc68020' Generate output for a 68020. This is the default when the compiler is configured for 68020-based systems. `-m68881' Generate output containing 68881 instructions for floating point. This is the default for most 68020 systems unless `-nfp' was specified when the compiler was configured. `-m68030' Generate output for a 68030. This is the default when the compiler is configured for 68030-based systems. `-m68040' Generate output for a 68040. This is the default when the compiler is configured for 68040-based systems. This option inhibits the use of 68881/68882 instructions that have to be emulated by software on the 68040. If your 68040 does not have code to emulate those instructions, use `-m68040'. `-m68020-40' Generate output for a 68040, without using any of the new instructions. This results in code which can run relatively efficiently on either a 68020/68881 or a 68030 or a 68040. The generated code does use the 68881 instructions that are emulated on the 68040. `-mfpa' Generate output containing Sun FPA instructions for floating point. `-msoft-float' Generate output containing library calls for floating point. *Warning:* the requisite libraries are not part of GNU CC. Normally the facilities of the machine's usual C compiler are used, but this can't be done directly in cross-compilation. You must make your own arrangements to provide suitable library functions for cross-compilation. `-mshort' Consider type `int' to be 16 bits wide, like `short int'. `-mnobitfield' Do not use the bit-field instructions. The `-m68000' option implies `-mnobitfield'. `-mbitfield' Do use the bit-field instructions. The `-m68020' option implies `-mbitfield'. This is the default if you use a configuration designed for a 68020. `-mrtd' Use a different function-calling convention, in which functions that take a fixed number of arguments return with the `rtd' instruction, which pops their arguments while returning. This saves one instruction in the caller since there is no need to pop the arguments there. This calling convention is incompatible with the one normally used on Unix, so you cannot use it if you need to call libraries compiled with the Unix compiler. Also, you must provide function prototypes for all functions that take variable numbers of arguments (including `printf'); otherwise incorrect code will be generated for calls to those functions. In addition, seriously incorrect code will result if you call a function with too many arguments. (Normally, extra arguments are harmlessly ignored.) The `rtd' instruction is supported by the 68010 and 68020 processors, but not by the 68000.  File: gcc.info, Node: VAX Options, Next: SPARC Options, Prev: M680x0 Options, Up: Submodel Options VAX Options ----------- These `-m' options are defined for the Vax: `-munix' Do not output certain jump instructions (`aobleq' and so on) that the Unix assembler for the Vax cannot handle across long ranges. `-mgnu' Do output those jump instructions, on the assumption that you will assemble with the GNU assembler. `-mg' Output code for g-format floating point numbers instead of d-format.  File: gcc.info, Node: SPARC Options, Next: Convex Options, Prev: VAX Options, Up: Submodel Options SPARC Options ------------- These `-m' switches are supported on the SPARC: `-mfpu' `-mhard-float' Generate output containing floating point instructions. This is the default. `-mno-fpu' `-msoft-float' Generate output containing library calls for floating point. *Warning:* there is no GNU floating-point library for SPARC. Normally the facilities of the machine's usual C compiler are used, but this cannot be done directly in cross-compilation. You must make your own arrangements to provide suitable library functions for cross-compilation. `-msoft-float' changes the calling convention in the output file; therefore, it is only useful if you compile *all* of a program with this option. In particular, you need to compile `libgcc.a', the library that comes with GNU CC, with `-msoft-float' in order for this to work. `-mno-epilogue' `-mepilogue' With `-mepilogue' (the default), the compiler always emits code for function exit at the end of each function. Any function exit in the middle of the function (such as a return statement in C) will generate a jump to the exit code at the end of the function. With `-mno-epilogue', the compiler tries to emit exit code inline at every function exit. `-mv8' `-msparclite' These two options select variations on the SPARC architecture. By default (unless specifically configured for the Fujitsu SPARClite), GCC generates code for the v7 variant of the SPARC architecture. `-mv8' will give you SPARC v8 code. The only difference from v7 code is that the compiler emits the integer multiply and integer divide instructions which exist in SPARC v8 but not in SPARC v7. `-msparclite' will give you SPARClite code. This adds the integer multiply, integer divide step and scan (`ffs') instructions which exist in SPARClite but not in SPARC v7.  File: gcc.info, Node: Convex Options, Next: AMD29K Options, Prev: SPARC Options, Up: Submodel Options Convex Options -------------- These `-m' options are defined for Convex: `-mc1' Generate output for C1. The code will run on any Convex machine. The preprocessor symbol `__convex__c1__' is defined. `-mc2' Generate output for C2. Uses instructions not available on C1. Scheduling and other optimizations are chosen for max performance on C2. The preprocessor symbol `__convex_c2__' is defined. `-mc32' Generate output for C32xx. Uses instructions not available on C1. Scheduling and other optimizations are chosen for max performance on C32. The preprocessor symbol `__convex_c32__' is defined. `-mc34' Generate output for C34xx. Uses instructions not available on C1. Scheduling and other optimizations are chosen for max performance on C34. The preprocessor symbol `__convex_c34__' is defined. `-mc38' Generate output for C38xx. Uses instructions not available on C1. Scheduling and other optimizations are chosen for max performance on C38. The preprocessor symbol `__convex_c38__' is defined. `-margcount' Generate code which puts an argument count in the word preceding each argument list. This is compatible with regular CC, and a few programs may need the argument count word. GDB and other source-level debuggers do not need it; this info is in the symbol table. `-mnoargcount' Omit the argument count word. This is the default. `-mvolatile-cache' Allow volatile references to be cached. This is the default. `-mvolatile-nocache' Volatile references bypass the data cache, going all the way to memory. This is only needed for multi-processor code that does not use standard synchronization instructions. Making non-volatile references to volatile locations will not necessarily work. `-mlong32' Type long is 32 bits, the same as type int. This is the default. `-mlong64' Type long is 64 bits, the same as type long long. This option is useless, because no library support exists for it.  File: gcc.info, Node: AMD29K Options, Next: M88K Options, Prev: Convex Options, Up: Submodel Options AMD29K Options -------------- These `-m' options are defined for the AMD Am29000: `-mdw' Generate code that assumes the `DW' bit is set, i.e., that byte and halfword operations are directly supported by the hardware. This is the default. `-mnodw' Generate code that assumes the `DW' bit is not set. `-mbw' Generate code that assumes the system supports byte and halfword write operations. This is the default. `-mnbw' Generate code that assumes the systems does not support byte and halfword write operations. `-mnbw' implies `-mnodw'. `-msmall' Use a small memory model that assumes that all function addresses are either within a single 256 KB segment or at an absolute address of less than 256k. This allows the `call' instruction to be used instead of a `const', `consth', `calli' sequence. `-mnormal' Use the normal memory model: Generate `call' instructions only when calling functions in the same file and `calli' instructions otherwise. This works if each file occupies less than 256 KB but allows the entire executable to be larger than 256 KB. This is the default. `-mlarge' Always use `calli' instructions. Specify this option if you expect a single file to compile into more than 256 KB of code. `-m29050' Generate code for the Am29050. `-m29000' Generate code for the Am29000. This is the default. `-mkernel-registers' Generate references to registers `gr64-gr95' instead of to registers `gr96-gr127'. This option can be used when compiling kernel code that wants a set of global registers disjoint from that used by user-mode code. Note that when this option is used, register names in `-f' flags must use the normal, user-mode, names. `-muser-registers' Use the normal set of global registers, `gr96-gr127'. This is the default. `-mstack-check' Insert a call to `__msp_check' after each stack adjustment. This is often used for kernel code.  File: gcc.info, Node: M88K Options, Next: RS/6000 and PowerPC Options, Prev: AMD29K Options, Up: Submodel Options M88K Options ------------ These `-m' options are defined for Motorola 88k architectures: `-m88000' Generate code that works well on both the m88100 and the m88110. `-m88100' Generate code that works best for the m88100, but that also runs on the m88110. `-m88110' Generate code that works best for the m88110, and may not run on the m88100. `-mbig-pic' Obsolete option to be removed from the next revision. Use `-fPIC'. `-midentify-revision' Include an `ident' directive in the assembler output recording the source file name, compiler name and version, timestamp, and compilation flags used. `-mno-underscores' In assembler output, emit symbol names without adding an underscore character at the beginning of each name. The default is to use an underscore as prefix on each name. `-mocs-debug-info' `-mno-ocs-debug-info' Include (or omit) additional debugging information (about registers used in each stack frame) as specified in the 88open Object Compatibility Standard, "OCS". This extra information allows debugging of code that has had the frame pointer eliminated. The default for DG/UX, SVr4, and Delta 88 SVr3.2 is to include this information; other 88k configurations omit this information by default. `-mocs-frame-position' When emitting COFF debugging information for automatic variables and parameters stored on the stack, use the offset from the canonical frame address, which is the stack pointer (register 31) on entry to the function. The DG/UX, SVr4, Delta88 SVr3.2, and BCS configurations use `-mocs-frame-position'; other 88k configurations have the default `-mno-ocs-frame-position'. `-mno-ocs-frame-position' When emitting COFF debugging information for automatic variables and parameters stored on the stack, use the offset from the frame pointer register (register 30). When this option is in effect, the frame pointer is not eliminated when debugging information is selected by the -g switch. `-moptimize-arg-area' `-mno-optimize-arg-area' Control how function arguments are stored in stack frames. `-moptimize-arg-area' saves space by optimizing them, but this conflicts with the 88open specifications. The opposite alternative, `-mno-optimize-arg-area', agrees with 88open standards. By default GNU CC does not optimize the argument area. `-mshort-data-NUM' Generate smaller data references by making them relative to `r0', which allows loading a value using a single instruction (rather than the usual two). You control which data references are affected by specifying NUM with this option. For example, if you specify `-mshort-data-512', then the data references affected are those involving displacements of less than 512 bytes. `-mshort-data-NUM' is not effective for NUM greater than 64k. `-mserialize-volatile' `-mno-serialize-volatile' Do, or do not, generate code to guarantee sequential consistency of volatile memory references. GNU CC always guarantees consistency by default. The order of memory references made by the m88110 processor does not always match the order of the instructions requesting those references. In particular, a load instruction may execute before a preceding store instruction. Such reordering violates sequential consistency of volatile memory references, when there are multiple processors. The extra code generated to guarantee consistency may affect the performance of your application. If you know that you can safely forgo this guarantee, you may use the option `-mno-serialize-volatile'. `-msvr4' `-msvr3' Turn on (`-msvr4') or off (`-msvr3') compiler extensions related to System V release 4 (SVr4). This controls the following: 1. Which variant of the assembler syntax to emit (which you can select independently using `-mversion-03.00'). 2. `-msvr4' makes the C preprocessor recognize `#pragma weak' that is used on System V release 4. 3. `-msvr4' makes GNU CC issue additional declaration directives used in SVr4. `-msvr3' is the default for all m88k configurations except the SVr4 configuration. `-mversion-03.00' In the DG/UX configuration, there are two flavors of SVr4. This option modifies `-msvr4' to select whether the hybrid-COFF or real-ELF flavor is used. All other configurations ignore this option. `-mno-check-zero-division' `-mcheck-zero-division' Early models of the 88k architecture had problems with division by zero; in particular, many of them didn't trap. Use these options to avoid including (or to include explicitly) additional code to detect division by zero and signal an exception. All GNU CC configurations for the 88k use `-mcheck-zero-division' by default. `-muse-div-instruction' Do not emit code to check both the divisor and dividend when doing signed integer division to see if either is negative, and adjust the signs so the divide is done using non-negative numbers. Instead, rely on the operating system to calculate the correct value when the `div' instruction traps. This results in different behavior when the most negative number is divided by -1, but is useful when most or all signed integer divisions are done with positive numbers. `-mtrap-large-shift' `-mhandle-large-shift' Include code to detect bit-shifts of more than 31 bits; respectively, trap such shifts or emit code to handle them properly. By default GNU CC makes no special provision for large bit shifts. `-mwarn-passed-structs' Warn when a function passes a struct as an argument or result. Structure-passing conventions have changed during the evolution of the C language, and are often the source of portability problems. By default, GNU CC issues no such warning.