+\1f
+File: gcc.info, Node: C Dialect Options, Next: C++ Dialect Options, Prev: Invoking G++, Up: Invoking GCC
+
+3.4 Options Controlling C Dialect
+=================================
+
+The following options control the dialect of C (or languages derived
+from C, such as C++ and Objective-C) that the compiler accepts:
+
+`-ansi'
+ In C mode, support all ISO C89 programs. In C++ mode, remove GNU
+ extensions that conflict with ISO C++.
+
+ This turns off certain features of GCC that are incompatible with
+ ISO C89 (when compiling C code), or of standard C++ (when
+ compiling C++ code), such as the `asm' and `typeof' keywords, and
+ predefined macros such as `unix' and `vax' that identify the type
+ of system you are using. It also enables the undesirable and
+ rarely used ISO trigraph feature. For the C compiler, it disables
+ recognition of C++ style `//' comments as well as the `inline'
+ keyword.
+
+ The alternate keywords `__asm__', `__extension__', `__inline__'
+ and `__typeof__' continue to work despite `-ansi'. You would not
+ want to use them in an ISO C program, of course, but it is useful
+ to put them in header files that might be included in compilations
+ done with `-ansi'. Alternate predefined macros such as `__unix__'
+ and `__vax__' are also available, with or without `-ansi'.
+
+ The `-ansi' option does not cause non-ISO programs to be rejected
+ gratuitously. For that, `-pedantic' is required in addition to
+ `-ansi'. *Note Warning Options::.
+
+ The macro `__STRICT_ANSI__' is predefined when the `-ansi' option
+ is used. Some header files may notice this macro and refrain from
+ declaring certain functions or defining certain macros that the
+ ISO standard doesn't call for; this is to avoid interfering with
+ any programs that might use these names for other things.
+
+ Functions which would normally be built in but do not have
+ semantics defined by ISO C (such as `alloca' and `ffs') are not
+ built-in functions with `-ansi' is used. *Note Other built-in
+ functions provided by GCC: Other Builtins, for details of the
+ functions affected.
+
+`-std='
+ Determine the language standard. This option is currently only
+ supported when compiling C. A value for this option must be
+ provided; possible values are
+
+ `c89'
+ `iso9899:1990'
+ ISO C89 (same as `-ansi').
+
+ `iso9899:199409'
+ ISO C89 as modified in amendment 1.
+
+ `c99'
+ `c9x'
+ `iso9899:1999'
+ `iso9899:199x'
+ ISO C99. Note that this standard is not yet fully supported;
+ see `http://gcc.gnu.org/gcc-3.1/c99status.html' for more
+ information. The names `c9x' and `iso9899:199x' are
+ deprecated.
+
+ `gnu89'
+ Default, ISO C89 plus GNU extensions (including some C99
+ features).
+
+ `gnu99'
+
+ `gnu9x'
+ ISO C99 plus GNU extensions. When ISO C99 is fully
+ implemented in GCC, this will become the default. The name
+ `gnu9x' is deprecated.
+
+
+ Even when this option is not specified, you can still use some of
+ the features of newer standards in so far as they do not conflict
+ with previous C standards. For example, you may use
+ `__restrict__' even when `-std=c99' is not specified.
+
+ The `-std' options specifying some version of ISO C have the same
+ effects as `-ansi', except that features that were not in ISO C89
+ but are in the specified version (for example, `//' comments and
+ the `inline' keyword in ISO C99) are not disabled.
+
+ *Note Language Standards Supported by GCC: Standards, for details
+ of these standard versions.
+
+`-aux-info FILENAME'
+ Output to the given filename prototyped declarations for all
+ functions declared and/or defined in a translation unit, including
+ those in header files. This option is silently ignored in any
+ language other than C.
+
+ Besides declarations, the file indicates, in comments, the origin
+ of each declaration (source file and line), whether the
+ declaration was implicit, prototyped or unprototyped (`I', `N' for
+ new or `O' for old, respectively, in the first character after the
+ line number and the colon), and whether it came from a declaration
+ or a definition (`C' or `F', respectively, in the following
+ character). In the case of function definitions, a K&R-style list
+ of arguments followed by their declarations is also provided,
+ inside comments, after the declaration.
+
+`-fno-asm'
+ Do not recognize `asm', `inline' or `typeof' as a keyword, so that
+ code can use these words as identifiers. You can use the keywords
+ `__asm__', `__inline__' and `__typeof__' instead. `-ansi' implies
+ `-fno-asm'.
+
+ In C++, this switch only affects the `typeof' keyword, since `asm'
+ and `inline' are standard keywords. You may want to use the
+ `-fno-gnu-keywords' flag instead, which has the same effect. In
+ C99 mode (`-std=c99' or `-std=gnu99'), this switch only affects
+ the `asm' and `typeof' keywords, since `inline' is a standard
+ keyword in ISO C99.
+
+`-fno-builtin'
+`-fno-builtin-FUNCTION (C and Objective-C only)'
+ Don't recognize built-in functions that do not begin with
+ `__builtin_' as prefix. *Note Other built-in functions provided
+ by GCC: Other Builtins, for details of the functions affected,
+ including those which are not built-in functions when `-ansi' or
+ `-std' options for strict ISO C conformance are used because they
+ do not have an ISO standard meaning.
+
+ GCC normally generates special code to handle certain built-in
+ functions more efficiently; for instance, calls to `alloca' may
+ become single instructions that adjust the stack directly, and
+ calls to `memcpy' may become inline copy loops. The resulting
+ code is often both smaller and faster, but since the function
+ calls no longer appear as such, you cannot set a breakpoint on
+ those calls, nor can you change the behavior of the functions by
+ linking with a different library.
+
+ In C++, `-fno-builtin' is always in effect. The `-fbuiltin'
+ option has no effect. Therefore, in C++, the only way to get the
+ optimization benefits of built-in functions is to call the function
+ using the `__builtin_' prefix. The GNU C++ Standard Library uses
+ built-in functions to implement many functions (like
+ `std::strchr'), so that you automatically get efficient code.
+
+ With the `-fno-builtin-FUNCTION' option, not available when
+ compiling C++, only the built-in function FUNCTION is disabled.
+ FUNCTION must not begin with `__builtin_'. If a function is named
+ this is not built-in in this version of GCC, this option is
+ ignored. There is no corresponding `-fbuiltin-FUNCTION' option;
+ if you wish to enable built-in functions selectively when using
+ `-fno-builtin' or `-ffreestanding', you may define macros such as:
+
+ #define abs(n) __builtin_abs ((n))
+ #define strcpy(d, s) __builtin_strcpy ((d), (s))
+
+`-fhosted'
+ Assert that compilation takes place in a hosted environment. This
+ implies `-fbuiltin'. A hosted environment is one in which the
+ entire standard library is available, and in which `main' has a
+ return type of `int'. Examples are nearly everything except a
+ kernel. This is equivalent to `-fno-freestanding'.
+
+`-ffreestanding'
+ Assert that compilation takes place in a freestanding environment.
+ This implies `-fno-builtin'. A freestanding environment is one in
+ which the standard library may not exist, and program startup may
+ not necessarily be at `main'. The most obvious example is an OS
+ kernel. This is equivalent to `-fno-hosted'.
+
+ *Note Language Standards Supported by GCC: Standards, for details
+ of freestanding and hosted environments.
+
+`-trigraphs'
+ Support ISO C trigraphs. The `-ansi' option (and `-std' options
+ for strict ISO C conformance) implies `-trigraphs'.
+
+`-no-integrated-cpp'
+ Invoke the external cpp during compilation. The default is to use
+ the integrated cpp (internal cpp). This option also allows a
+ user-supplied cpp via the `-B' option. This flag is applicable in
+ both C and C++ modes.
+
+ We do not guarantee to retain this option in future, and we may
+ change its semantics.
+
+`-traditional'
+ Attempt to support some aspects of traditional C compilers.
+ Specifically:
+
+ * All `extern' declarations take effect globally even if they
+ are written inside of a function definition. This includes
+ implicit declarations of functions.
+
+ * The newer keywords `typeof', `inline', `signed', `const' and
+ `volatile' are not recognized. (You can still use the
+ alternative keywords such as `__typeof__', `__inline__', and
+ so on.)
+
+ * Comparisons between pointers and integers are always allowed.
+
+ * Integer types `unsigned short' and `unsigned char' promote to
+ `unsigned int'.
+
+ * Out-of-range floating point literals are not an error.
+
+ * Certain constructs which ISO regards as a single invalid
+ preprocessing number, such as `0xe-0xd', are treated as
+ expressions instead.
+
+ * String "constants" are not necessarily constant; they are
+ stored in writable space, and identical looking constants are
+ allocated separately. (This is the same as the effect of
+ `-fwritable-strings'.)
+
+ * All automatic variables not declared `register' are preserved
+ by `longjmp'. Ordinarily, GNU C follows ISO C: automatic
+ variables not declared `volatile' may be clobbered.
+
+ * The character escape sequences `\x' and `\a' evaluate as the
+ literal characters `x' and `a' respectively. Without
+ `-traditional', `\x' is a prefix for the hexadecimal
+ representation of a character, and `\a' produces a bell.
+
+ This option is deprecated and may be removed.
+
+ You may wish to use `-fno-builtin' as well as `-traditional' if
+ your program uses names that are normally GNU C built-in functions
+ for other purposes of its own.
+
+ You cannot use `-traditional' if you include any header files that
+ rely on ISO C features. Some vendors are starting to ship systems
+ with ISO C header files and you cannot use `-traditional' on such
+ systems to compile files that include any system headers.
+
+ The `-traditional' option also enables `-traditional-cpp'.
+
+`-traditional-cpp'
+ Attempt to support some aspects of traditional C preprocessors.
+ See the GNU CPP manual for details.
+
+`-fcond-mismatch'
+ Allow conditional expressions with mismatched types in the second
+ and third arguments. The value of such an expression is void.
+ This option is not supported for C++.
+
+`-funsigned-char'
+ Let the type `char' be unsigned, like `unsigned char'.
+
+ Each kind of machine has a default for what `char' should be. It
+ is either like `unsigned char' by default or like `signed char' by
+ default.
+
+ Ideally, a portable program should always use `signed char' or
+ `unsigned char' when it depends on the signedness of an object.
+ But many programs have been written to use plain `char' and expect
+ it to be signed, or expect it to be unsigned, depending on the
+ machines they were written for. This option, and its inverse, let
+ you make such a program work with the opposite default.
+
+ The type `char' is always a distinct type from each of `signed
+ char' or `unsigned char', even though its behavior is always just
+ like one of those two.
+
+`-fsigned-char'
+ Let the type `char' be signed, like `signed char'.
+
+ Note that this is equivalent to `-fno-unsigned-char', which is the
+ negative form of `-funsigned-char'. Likewise, the option
+ `-fno-signed-char' is equivalent to `-funsigned-char'.
+
+`-fsigned-bitfields'
+`-funsigned-bitfields'
+`-fno-signed-bitfields'
+`-fno-unsigned-bitfields'
+ These options control whether a bit-field is signed or unsigned,
+ when the declaration does not use either `signed' or `unsigned'.
+ By default, such a bit-field is signed, because this is
+ consistent: the basic integer types such as `int' are signed types.
+
+ However, when `-traditional' is used, bit-fields are all unsigned
+ no matter what.
+
+`-fwritable-strings'
+ Store string constants in the writable data segment and don't
+ uniquize them. This is for compatibility with old programs which
+ assume they can write into string constants. The option
+ `-traditional' also has this effect.
+
+ Writing into string constants is a very bad idea; "constants"
+ should be constant.
+
+`-fallow-single-precision'
+ Do not promote single precision math operations to double
+ precision, even when compiling with `-traditional'.
+
+ Traditional K&R C promotes all floating point operations to double
+ precision, regardless of the sizes of the operands. On the
+ architecture for which you are compiling, single precision may be
+ faster than double precision. If you must use `-traditional',
+ but want to use single precision operations when the operands are
+ single precision, use this option. This option has no effect
+ when compiling with ISO or GNU C conventions (the default).
+
+\1f
+File: gcc.info, Node: C++ Dialect Options, Next: Objective-C Dialect Options, Prev: C Dialect Options, Up: Invoking GCC
+
+3.5 Options Controlling C++ Dialect
+===================================
+
+This section describes the command-line options that are only meaningful
+for C++ programs; but you can also use most of the GNU compiler options
+regardless of what language your program is in. For example, you might
+compile a file `firstClass.C' like this:
+
+ g++ -g -frepo -O -c firstClass.C
+
+In this example, only `-frepo' is an option meant only for C++
+programs; you can use the other options with any language supported by
+GCC.
+
+ Here is a list of options that are _only_ for compiling C++ programs:
+
+`-fno-access-control'
+ Turn off all access checking. This switch is mainly useful for
+ working around bugs in the access control code.
+
+`-fcheck-new'
+ Check that the pointer returned by `operator new' is non-null
+ before attempting to modify the storage allocated. The current
+ Working Paper requires that `operator new' never return a null
+ pointer, so this check is normally unnecessary.
+
+ An alternative to using this option is to specify that your
+ `operator new' does not throw any exceptions; if you declare it
+ `throw()', G++ will check the return value. See also `new
+ (nothrow)'.
+
+`-fconserve-space'
+ Put uninitialized or runtime-initialized global variables into the
+ common segment, as C does. This saves space in the executable at
+ the cost of not diagnosing duplicate definitions. If you compile
+ with this flag and your program mysteriously crashes after
+ `main()' has completed, you may have an object that is being
+ destroyed twice because two definitions were merged.
+
+ This option is no longer useful on most targets, now that support
+ has been added for putting variables into BSS without making them
+ common.
+
+`-fno-const-strings'
+ Give string constants type `char *' instead of type `const char
+ *'. By default, G++ uses type `const char *' as required by the
+ standard. Even if you use `-fno-const-strings', you cannot
+ actually modify the value of a string constant, unless you also use
+ `-fwritable-strings'.
+
+ This option might be removed in a future release of G++. For
+ maximum portability, you should structure your code so that it
+ works with string constants that have type `const char *'.
+
+`-fdollars-in-identifiers'
+ Accept `$' in identifiers. You can also explicitly prohibit use of
+ `$' with the option `-fno-dollars-in-identifiers'. (GNU C allows
+ `$' by default on most target systems, but there are a few
+ exceptions.) Traditional C allowed the character `$' to form part
+ of identifiers. However, ISO C and C++ forbid `$' in identifiers.
+
+`-fno-elide-constructors'
+ The C++ standard allows an implementation to omit creating a
+ temporary which is only used to initialize another object of the
+ same type. Specifying this option disables that optimization, and
+ forces G++ to call the copy constructor in all cases.
+
+`-fno-enforce-eh-specs'
+ Don't check for violation of exception specifications at runtime.
+ This option violates the C++ standard, but may be useful for
+ reducing code size in production builds, much like defining
+ `NDEBUG'. The compiler will still optimize based on the exception
+ specifications.
+
+`-fexternal-templates'
+ Cause `#pragma interface' and `implementation' to apply to
+ template instantiation; template instances are emitted or not
+ according to the location of the template definition. *Note
+ Template Instantiation::, for more information.
+
+ This option is deprecated.
+
+`-falt-external-templates'
+ Similar to `-fexternal-templates', but template instances are
+ emitted or not according to the place where they are first
+ instantiated. *Note Template Instantiation::, for more
+ information.
+
+ This option is deprecated.
+
+`-ffor-scope'
+`-fno-for-scope'
+ If `-ffor-scope' is specified, the scope of variables declared in
+ a for-init-statement is limited to the `for' loop itself, as
+ specified by the C++ standard. If `-fno-for-scope' is specified,
+ the scope of variables declared in a for-init-statement extends to
+ the end of the enclosing scope, as was the case in old versions of
+ G++, and other (traditional) implementations of C++.
+
+ The default if neither flag is given to follow the standard, but
+ to allow and give a warning for old-style code that would
+ otherwise be invalid, or have different behavior.
+
+`-fno-gnu-keywords'
+ Do not recognize `typeof' as a keyword, so that code can use this
+ word as an identifier. You can use the keyword `__typeof__'
+ instead. `-ansi' implies `-fno-gnu-keywords'.
+
+`-fno-implicit-templates'
+ Never emit code for non-inline templates which are instantiated
+ implicitly (i.e. by use); only emit code for explicit
+ instantiations. *Note Template Instantiation::, for more
+ information.
+
+`-fno-implicit-inline-templates'
+ Don't emit code for implicit instantiations of inline templates,
+ either. The default is to handle inlines differently so that
+ compiles with and without optimization will need the same set of
+ explicit instantiations.
+
+`-fno-implement-inlines'
+ To save space, do not emit out-of-line copies of inline functions
+ controlled by `#pragma implementation'. This will cause linker
+ errors if these functions are not inlined everywhere they are
+ called.
+
+`-fms-extensions'
+ Disable pedantic warnings about constructs used in MFC, such as
+ implicit int and getting a pointer to member function via
+ non-standard syntax.
+
+`-fno-nonansi-builtins'
+ Disable built-in declarations of functions that are not mandated by
+ ANSI/ISO C. These include `ffs', `alloca', `_exit', `index',
+ `bzero', `conjf', and other related functions.
+
+`-fno-operator-names'
+ Do not treat the operator name keywords `and', `bitand', `bitor',
+ `compl', `not', `or' and `xor' as synonyms as keywords.
+
+`-fno-optional-diags'
+ Disable diagnostics that the standard says a compiler does not
+ need to issue. Currently, the only such diagnostic issued by G++
+ is the one for a name having multiple meanings within a class.
+
+`-fpermissive'
+ Downgrade messages about nonconformant code from errors to
+ warnings. By default, G++ effectively sets `-pedantic-errors'
+ without `-pedantic'; this option reverses that. This behavior and
+ this option are superseded by `-pedantic', which works as it does
+ for GNU C.
+
+`-frepo'
+ Enable automatic template instantiation at link time. This option
+ also implies `-fno-implicit-templates'. *Note Template
+ Instantiation::, for more information.
+
+`-fno-rtti'
+ Disable generation of information about every class with virtual
+ functions for use by the C++ runtime type identification features
+ (`dynamic_cast' and `typeid'). If you don't use those parts of
+ the language, you can save some space by using this flag. Note
+ that exception handling uses the same information, but it will
+ generate it as needed.
+
+`-fstats'
+ Emit statistics about front-end processing at the end of the
+ compilation. This information is generally only useful to the G++
+ development team.
+
+`-ftemplate-depth-N'
+ Set the maximum instantiation depth for template classes to N. A
+ limit on the template instantiation depth is needed to detect
+ endless recursions during template class instantiation. ANSI/ISO
+ C++ conforming programs must not rely on a maximum depth greater
+ than 17.
+
+`-fuse-cxa-atexit'
+ Register destructors for objects with static storage duration with
+ the `__cxa_atexit' function rather than the `atexit' function.
+ This option is required for fully standards-compliant handling of
+ static destructors, but will only work if your C library supports
+ `__cxa_atexit'.
+
+`-fvtable-gc'
+ Emit special relocations for vtables and virtual function
+ references so that the linker can identify unused virtual
+ functions and zero out vtable slots that refer to them. This is
+ most useful with `-ffunction-sections' and `-Wl,--gc-sections', in
+ order to also discard the functions themselves.
+
+ This optimization requires GNU as and GNU ld. Not all systems
+ support this option. `-Wl,--gc-sections' is ignored without
+ `-static'.
+
+`-fno-weak'
+ Do not use weak symbol support, even if it is provided by the
+ linker. By default, G++ will use weak symbols if they are
+ available. This option exists only for testing, and should not be
+ used by end-users; it will result in inferior code and has no
+ benefits. This option may be removed in a future release of G++.
+
+`-nostdinc++'
+ Do not search for header files in the standard directories
+ specific to C++, but do still search the other standard
+ directories. (This option is used when building the C++ library.)
+
+ In addition, these optimization, warning, and code generation options
+have meanings only for C++ programs:
+
+`-fno-default-inline'
+ Do not assume `inline' for functions defined inside a class scope.
+ *Note Options That Control Optimization: Optimize Options. Note
+ that these functions will have linkage like inline functions; they
+ just won't be inlined by default.
+
+`-Wabi (C++ only)'
+ Warn when G++ generates code that is probably not compatible with
+ the vendor-neutral C++ ABI. Although an effort has been made to
+ warn about all such cases, there are probably some cases that are
+ not warned about, even though G++ is generating incompatible code.
+ There may also be cases where warnings are emitted even though the
+ code that is generated will be compatible.
+
+ You should rewrite your code to avoid these warnings if you are
+ concerned about the fact that code generated by G++ may not be
+ binary compatible with code generated by other compilers.
+
+ The known incompatibilites at this point include:
+
+ * Incorrect handling of tail-padding for bit-fields. G++ may
+ attempt to pack data into the same byte as a base class. For
+ example:
+
+ struct A { virtual void f(); int f1 : 1; };
+ struct B : public A { int f2 : 1; };
+
+ In this case, G++ will place `B::f2' into the same byte
+ as`A::f1'; other compilers will not. You can avoid this
+ problem by explicitly padding `A' so that its size is a
+ multiple of the byte size on your platform; that will cause
+ G++ and other compilers to layout `B' identically.
+
+ * Incorrect handling of tail-padding for virtual bases. G++
+ does not use tail padding when laying out virtual bases. For
+ example:
+
+ struct A { virtual void f(); char c1; };
+ struct B { B(); char c2; };
+ struct C : public A, public virtual B {};
+
+ In this case, G++ will not place `B' into the tail-padding for
+ `A'; other compilers will. You can avoid this problem by
+ explicitly padding `A' so that its size is a multiple of its
+ alignment (ignoring virtual base classes); that will cause
+ G++ and other compilers to layout `C' identically.
+
+
+`-Wctor-dtor-privacy (C++ only)'
+ Warn when a class seems unusable, because all the constructors or
+ destructors in a class are private and the class has no friends or
+ public static member functions.
+
+`-Wnon-virtual-dtor (C++ only)'
+ Warn when a class declares a non-virtual destructor that should
+ probably be virtual, because it looks like the class will be used
+ polymorphically.
+
+`-Wreorder (C++ only)'
+ Warn when the order of member initializers given in the code does
+ not match the order in which they must be executed. For instance:
+
+ struct A {
+ int i;
+ int j;
+ A(): j (0), i (1) { }
+ };
+
+ Here the compiler will warn that the member initializers for `i'
+ and `j' will be rearranged to match the declaration order of the
+ members.
+
+ The following `-W...' options are not affected by `-Wall'.
+
+`-Weffc++ (C++ only)'
+ Warn about violations of the following style guidelines from Scott
+ Meyers' `Effective C++' book:
+
+ * Item 11: Define a copy constructor and an assignment
+ operator for classes with dynamically allocated memory.
+
+ * Item 12: Prefer initialization to assignment in constructors.
+
+ * Item 14: Make destructors virtual in base classes.
+
+ * Item 15: Have `operator=' return a reference to `*this'.
+
+ * Item 23: Don't try to return a reference when you must
+ return an object.
+
+
+ and about violations of the following style guidelines from Scott
+ Meyers' `More Effective C++' book:
+
+ * Item 6: Distinguish between prefix and postfix forms of
+ increment and decrement operators.
+
+ * Item 7: Never overload `&&', `||', or `,'.
+
+
+ If you use this option, you should be aware that the standard
+ library headers do not obey all of these guidelines; you can use
+ `grep -v' to filter out those warnings.
+
+`-Wno-deprecated (C++ only)'
+ Do not warn about usage of deprecated features. *Note Deprecated
+ Features::.
+
+`-Wno-non-template-friend (C++ only)'
+ Disable warnings when non-templatized friend functions are declared
+ within a template. With the advent of explicit template
+ specification support in G++, if the name of the friend is an
+ unqualified-id (i.e., `friend foo(int)'), the C++ language
+ specification demands that the friend declare or define an
+ ordinary, nontemplate function. (Section 14.5.3). Before G++
+ implemented explicit specification, unqualified-ids could be
+ interpreted as a particular specialization of a templatized
+ function. Because this non-conforming behavior is no longer the
+ default behavior for G++, `-Wnon-template-friend' allows the
+ compiler to check existing code for potential trouble spots, and
+ is on by default. This new compiler behavior can be turned off
+ with `-Wno-non-template-friend' which keeps the conformant
+ compiler code but disables the helpful warning.
+
+`-Wold-style-cast (C++ only)'
+ Warn if an old-style (C-style) cast to a non-void type is used
+ within a C++ program. The new-style casts (`static_cast',
+ `reinterpret_cast', and `const_cast') are less vulnerable to
+ unintended effects, and much easier to grep for.
+
+`-Woverloaded-virtual (C++ only)'
+ Warn when a function declaration hides virtual functions from a
+ base class. For example, in:
+
+ struct A {
+ virtual void f();
+ };
+
+ struct B: public A {
+ void f(int);
+ };
+
+ the `A' class version of `f' is hidden in `B', and code like this:
+
+ B* b;
+ b->f();
+
+ will fail to compile.
+
+`-Wno-pmf-conversions (C++ only)'
+ Disable the diagnostic for converting a bound pointer to member
+ function to a plain pointer.
+
+`-Wsign-promo (C++ only)'
+ Warn when overload resolution chooses a promotion from unsigned or
+ enumeral type to a signed type over a conversion to an unsigned
+ type of the same size. Previous versions of G++ would try to
+ preserve unsignedness, but the standard mandates the current
+ behavior.
+
+`-Wsynth (C++ only)'
+ Warn when G++'s synthesis behavior does not match that of cfront.
+ For instance:
+
+ struct A {
+ operator int ();
+ A& operator = (int);
+ };
+
+ main ()
+ {
+ A a,b;
+ a = b;
+ }
+
+ In this example, G++ will synthesize a default `A& operator =
+ (const A&);', while cfront will use the user-defined `operator ='.
+
+\1f
+File: gcc.info, Node: Objective-C Dialect Options, Next: Language Independent Options, Prev: C++ Dialect Options, Up: Invoking GCC
+
+3.6 Options Controlling Objective-C Dialect
+===========================================
+
+This section describes the command-line options that are only meaningful
+for Objective-C programs; but you can also use most of the GNU compiler
+options regardless of what language your program is in. For example,
+you might compile a file `some_class.m' like this:
+
+ gcc -g -fgnu-runtime -O -c some_class.m
+
+In this example, only `-fgnu-runtime' is an option meant only for
+Objective-C programs; you can use the other options with any language
+supported by GCC.
+
+ Here is a list of options that are _only_ for compiling Objective-C
+programs:
+
+`-fconstant-string-class=CLASS-NAME'
+ Use CLASS-NAME as the name of the class to instantiate for each
+ literal string specified with the syntax `@"..."'. The default
+ class name is `NXConstantString'.
+
+`-fgnu-runtime'
+ Generate object code compatible with the standard GNU Objective-C
+ runtime. This is the default for most types of systems.
+
+`-fnext-runtime'
+ Generate output compatible with the NeXT runtime. This is the
+ default for NeXT-based systems, including Darwin and Mac OS X.
+
+`-gen-decls'
+ Dump interface declarations for all classes seen in the source
+ file to a file named `SOURCENAME.decl'.
+
+`-Wno-protocol'
+ Do not warn if methods required by a protocol are not implemented
+ in the class adopting it.
+
+`-Wselector'
+ Warn if a selector has multiple methods of different types defined.
+
+
+\1f
+File: gcc.info, Node: Language Independent Options, Next: Warning Options, Prev: Objective-C Dialect Options, Up: Invoking GCC
+
+3.7 Options to Control Diagnostic Messages Formatting
+=====================================================
+
+Traditionally, diagnostic messages have been formatted irrespective of
+the output device's aspect (e.g. its width, ...). The options described
+below can be used to control the diagnostic messages formatting
+algorithm, e.g. how many characters per line, how often source location
+information should be reported. Right now, only the C++ front end can
+honor these options. However it is expected, in the near future, that
+the remaining front ends would be able to digest them correctly.
+
+`-fmessage-length=N'
+ Try to format error messages so that they fit on lines of about N
+ characters. The default is 72 characters for `g++' and 0 for the
+ rest of the front ends supported by GCC. If N is zero, then no
+ line-wrapping will be done; each error message will appear on a
+ single line.
+
+`-fdiagnostics-show-location=once'
+ Only meaningful in line-wrapping mode. Instructs the diagnostic
+ messages reporter to emit _once_ source location information; that
+ is, in case the message is too long to fit on a single physical
+ line and has to be wrapped, the source location won't be emitted
+ (as prefix) again, over and over, in subsequent continuation
+ lines. This is the default behavior.
+
+`-fdiagnostics-show-location=every-line'
+ Only meaningful in line-wrapping mode. Instructs the diagnostic
+ messages reporter to emit the same source location information (as
+ prefix) for physical lines that result from the process of breaking
+ a message which is too long to fit on a single line.
+
+
+\1f
+File: gcc.info, Node: Warning Options, Next: Debugging Options, Prev: Language Independent Options, Up: Invoking GCC
+
+3.8 Options to Request or Suppress Warnings
+===========================================
+
+Warnings are diagnostic messages that report constructions which are
+not inherently erroneous but which are risky or suggest there may have
+been an error.
+
+ You can request many specific warnings with options beginning `-W',
+for example `-Wimplicit' to request warnings on implicit declarations.
+Each of these specific warning options also has a negative form
+beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'.
+This manual lists only one of the two forms, whichever is not the
+default.
+
+ The following options control the amount and kinds of warnings
+produced by GCC; for further, language-specific options also refer to
+*note C++ Dialect Options:: and *note Objective-C Dialect Options::.
+
+`-fsyntax-only'
+ Check the code for syntax errors, but don't do anything beyond
+ that.
+
+`-pedantic'
+ Issue all the warnings demanded by strict ISO C and ISO C++;
+ reject all programs that use forbidden extensions, and some other
+ programs that do not follow ISO C and ISO C++. For ISO C, follows
+ the version of the ISO C standard specified by any `-std' option
+ used.
+
+ Valid ISO C and ISO C++ programs should compile properly with or
+ without this option (though a rare few will require `-ansi' or a
+ `-std' option specifying the required version of ISO C). However,
+ without this option, certain GNU extensions and traditional C and
+ C++ features are supported as well. With this option, they are
+ rejected.
+
+ `-pedantic' does not cause warning messages for use of the
+ alternate keywords whose names begin and end with `__'. Pedantic
+ warnings are also disabled in the expression that follows
+ `__extension__'. However, only system header files should use
+ these escape routes; application programs should avoid them.
+ *Note Alternate Keywords::.
+
+ Some users try to use `-pedantic' to check programs for strict ISO
+ C conformance. They soon find that it does not do quite what they
+ want: it finds some non-ISO practices, but not all--only those for
+ which ISO C _requires_ a diagnostic, and some others for which
+ diagnostics have been added.
+
+ A feature to report any failure to conform to ISO C might be
+ useful in some instances, but would require considerable
+ additional work and would be quite different from `-pedantic'. We
+ don't have plans to support such a feature in the near future.
+
+ Where the standard specified with `-std' represents a GNU extended
+ dialect of C, such as `gnu89' or `gnu99', there is a corresponding
+ "base standard", the version of ISO C on which the GNU extended
+ dialect is based. Warnings from `-pedantic' are given where they
+ are required by the base standard. (It would not make sense for
+ such warnings to be given only for features not in the specified
+ GNU C dialect, since by definition the GNU dialects of C include
+ all features the compiler supports with the given option, and
+ there would be nothing to warn about.)
+
+`-pedantic-errors'
+ Like `-pedantic', except that errors are produced rather than
+ warnings.
+
+`-w'
+ Inhibit all warning messages.
+
+`-Wno-import'
+ Inhibit warning messages about the use of `#import'.
+
+`-Wchar-subscripts'
+ Warn if an array subscript has type `char'. This is a common cause
+ of error, as programmers often forget that this type is signed on
+ some machines.
+
+`-Wcomment'
+ Warn whenever a comment-start sequence `/*' appears in a `/*'
+ comment, or whenever a Backslash-Newline appears in a `//' comment.
+
+`-Wformat'
+ Check calls to `printf' and `scanf', etc., to make sure that the
+ arguments supplied have types appropriate to the format string
+ specified, and that the conversions specified in the format string
+ make sense. This includes standard functions, and others
+ specified by format attributes (*note Function Attributes::), in
+ the `printf', `scanf', `strftime' and `strfmon' (an X/Open
+ extension, not in the C standard) families.
+
+ The formats are checked against the format features supported by
+ GNU libc version 2.2. These include all ISO C89 and C99 features,
+ as well as features from the Single Unix Specification and some
+ BSD and GNU extensions. Other library implementations may not
+ support all these features; GCC does not support warning about
+ features that go beyond a particular library's limitations.
+ However, if `-pedantic' is used with `-Wformat', warnings will be
+ given about format features not in the selected standard version
+ (but not for `strfmon' formats, since those are not in any version
+ of the C standard). *Note Options Controlling C Dialect: C
+ Dialect Options.
+
+ `-Wformat' is included in `-Wall'. For more control over some
+ aspects of format checking, the options `-Wno-format-y2k',
+ `-Wno-format-extra-args', `-Wformat-nonliteral',
+ `-Wformat-security' and `-Wformat=2' are available, but are not
+ included in `-Wall'.
+
+`-Wno-format-y2k'
+ If `-Wformat' is specified, do not warn about `strftime' formats
+ which may yield only a two-digit year.
+
+`-Wno-format-extra-args'
+ If `-Wformat' is specified, do not warn about excess arguments to a
+ `printf' or `scanf' format function. The C standard specifies
+ that such arguments are ignored.
+
+ Where the unused arguments lie between used arguments that are
+ specified with `$' operand number specifications, normally
+ warnings are still given, since the implementation could not know
+ what type to pass to `va_arg' to skip the unused arguments.
+ However, in the case of `scanf' formats, this option will suppress
+ the warning if the unused arguments are all pointers, since the
+ Single Unix Specification says that such unused arguments are
+ allowed.
+
+`-Wformat-nonliteral'
+ If `-Wformat' is specified, also warn if the format string is not a
+ string literal and so cannot be checked, unless the format function
+ takes its format arguments as a `va_list'.
+
+`-Wformat-security'
+ If `-Wformat' is specified, also warn about uses of format
+ functions that represent possible security problems. At present,
+ this warns about calls to `printf' and `scanf' functions where the
+ format string is not a string literal and there are no format
+ arguments, as in `printf (foo);'. This may be a security hole if
+ the format string came from untrusted input and contains `%n'.
+ (This is currently a subset of what `-Wformat-nonliteral' warns
+ about, but in future warnings may be added to `-Wformat-security'
+ that are not included in `-Wformat-nonliteral'.)
+
+`-Wformat=2'
+ Enable `-Wformat' plus format checks not included in `-Wformat'.
+ Currently equivalent to `-Wformat -Wformat-nonliteral
+ -Wformat-security'.
+
+`-Wimplicit-int'
+ Warn when a declaration does not specify a type.
+
+`-Wimplicit-function-declaration'
+`-Werror-implicit-function-declaration'
+ Give a warning (or error) whenever a function is used before being
+ declared.
+
+`-Wimplicit'
+ Same as `-Wimplicit-int' and `-Wimplicit-function-declaration'.
+
+`-Wmain'
+ Warn if the type of `main' is suspicious. `main' should be a
+ function with external linkage, returning int, taking either zero
+ arguments, two, or three arguments of appropriate types.
+
+`-Wmissing-braces'
+ Warn if an aggregate or union initializer is not fully bracketed.
+ In the following example, the initializer for `a' is not fully
+ bracketed, but that for `b' is fully bracketed.
+
+ int a[2][2] = { 0, 1, 2, 3 };
+ int b[2][2] = { { 0, 1 }, { 2, 3 } };
+
+`-Wparentheses'
+ Warn if parentheses are omitted in certain contexts, such as when
+ there is an assignment in a context where a truth value is
+ expected, or when operators are nested whose precedence people
+ often get confused about.
+
+ Also warn about constructions where there may be confusion to which
+ `if' statement an `else' branch belongs. Here is an example of
+ such a case:
+
+ {
+ if (a)
+ if (b)
+ foo ();
+ else
+ bar ();
+ }
+
+ In C, every `else' branch belongs to the innermost possible `if'
+ statement, which in this example is `if (b)'. This is often not
+ what the programmer expected, as illustrated in the above example
+ by indentation the programmer chose. When there is the potential
+ for this confusion, GCC will issue a warning when this flag is
+ specified. To eliminate the warning, add explicit braces around
+ the innermost `if' statement so there is no way the `else' could
+ belong to the enclosing `if'. The resulting code would look like
+ this:
+
+ {
+ if (a)
+ {
+ if (b)
+ foo ();
+ else
+ bar ();
+ }
+ }
+
+`-Wsequence-point'
+ Warn about code that may have undefined semantics because of
+ violations of sequence point rules in the C standard.
+
+ The C standard defines the order in which expressions in a C
+ program are evaluated in terms of "sequence points", which
+ represent a partial ordering between the execution of parts of the
+ program: those executed before the sequence point, and those
+ executed after it. These occur after the evaluation of a full
+ expression (one which is not part of a larger expression), after
+ the evaluation of the first operand of a `&&', `||', `? :' or `,'
+ (comma) operator, before a function is called (but after the
+ evaluation of its arguments and the expression denoting the called
+ function), and in certain other places. Other than as expressed
+ by the sequence point rules, the order of evaluation of
+ subexpressions of an expression is not specified. All these rules
+ describe only a partial order rather than a total order, since,
+ for example, if two functions are called within one expression
+ with no sequence point between them, the order in which the
+ functions are called is not specified. However, the standards
+ committee have ruled that function calls do not overlap.
+
+ It is not specified when between sequence points modifications to
+ the values of objects take effect. Programs whose behavior
+ depends on this have undefined behavior; the C standard specifies
+ that "Between the previous and next sequence point an object shall
+ have its stored value modified at most once by the evaluation of
+ an expression. Furthermore, the prior value shall be read only to
+ determine the value to be stored.". If a program breaks these
+ rules, the results on any particular implementation are entirely
+ unpredictable.
+
+ Examples of code with undefined behavior are `a = a++;', `a[n] =
+ b[n++]' and `a[i++] = i;'. Some more complicated cases are not
+ diagnosed by this option, and it may give an occasional false
+ positive result, but in general it has been found fairly effective
+ at detecting this sort of problem in programs.
+
+ The present implementation of this option only works for C
+ programs. A future implementation may also work for C++ programs.
+
+ The C standard is worded confusingly, therefore there is some
+ debate over the precise meaning of the sequence point rules in
+ subtle cases. Links to discussions of the problem, including
+ proposed formal definitions, may be found on our readings page, at
+ `http://gcc.gnu.org/readings.html'.
+
+`-Wreturn-type'
+ Warn whenever a function is defined with a return-type that
+ defaults to `int'. Also warn about any `return' statement with no
+ return-value in a function whose return-type is not `void'.
+
+ For C++, a function without return type always produces a
+ diagnostic message, even when `-Wno-return-type' is specified.
+ The only exceptions are `main' and functions defined in system
+ headers.
+
+`-Wswitch'
+ Warn whenever a `switch' statement has an index of enumeral type
+ and lacks a `case' for one or more of the named codes of that
+ enumeration. (The presence of a `default' label prevents this
+ warning.) `case' labels outside the enumeration range also
+ provoke warnings when this option is used.
+
+`-Wtrigraphs'
+ Warn if any trigraphs are encountered that might change the
+ meaning of the program (trigraphs within comments are not warned
+ about).
+
+`-Wunused-function'
+ Warn whenever a static function is declared but not defined or a
+ non\-inline static function is unused.
+
+`-Wunused-label'
+ Warn whenever a label is declared but not used.
+
+ To suppress this warning use the `unused' attribute (*note
+ Variable Attributes::).
+
+`-Wunused-parameter'
+ Warn whenever a function parameter is unused aside from its
+ declaration.
+
+ To suppress this warning use the `unused' attribute (*note
+ Variable Attributes::).
+
+`-Wunused-variable'
+ Warn whenever a local variable or non-constant static variable is
+ unused aside from its declaration
+
+ To suppress this warning use the `unused' attribute (*note
+ Variable Attributes::).
+
+`-Wunused-value'
+ Warn whenever a statement computes a result that is explicitly not
+ used.
+
+ To suppress this warning cast the expression to `void'.
+
+`-Wunused'
+ All all the above `-Wunused' options combined.
+
+ In order to get a warning about an unused function parameter, you
+ must either specify `-W -Wunused' or separately specify
+ `-Wunused-parameter'.
+
+`-Wuninitialized'
+ Warn if an automatic variable is used without first being
+ initialized or if a variable may be clobbered by a `setjmp' call.
+
+ These warnings are possible only in optimizing compilation,
+ because they require data flow information that is computed only
+ when optimizing. If you don't specify `-O', you simply won't get
+ these warnings.
+
+ These warnings occur only for variables that are candidates for
+ register allocation. Therefore, they do not occur for a variable
+ that is declared `volatile', or whose address is taken, or whose
+ size is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
+ structures, unions or arrays, even when they are in registers.
+
+ Note that there may be no warning about a variable that is used
+ only to compute a value that itself is never used, because such
+ computations may be deleted by data flow analysis before the
+ warnings are printed.
+
+ These warnings are made optional because GCC is not smart enough
+ to see all the reasons why the code might be correct despite
+ appearing to have an error. Here is one example of how this can
+ happen:
+
+ {
+ int x;
+ switch (y)
+ {
+ case 1: x = 1;
+ break;
+ case 2: x = 4;
+ break;
+ case 3: x = 5;
+ }
+ foo (x);
+ }
+
+ If the value of `y' is always 1, 2 or 3, then `x' is always
+ initialized, but GCC doesn't know this. Here is another common
+ case:
+
+ {
+ int save_y;
+ if (change_y) save_y = y, y = new_y;
+ ...
+ if (change_y) y = save_y;
+ }
+
+ This has no bug because `save_y' is used only if it is set.
+
+ This option also warns when a non-volatile automatic variable
+ might be changed by a call to `longjmp'. These warnings as well
+ are possible only in optimizing compilation.
+
+ The compiler sees only the calls to `setjmp'. It cannot know
+ where `longjmp' will be called; in fact, a signal handler could
+ call it at any point in the code. As a result, you may get a
+ warning even when there is in fact no problem because `longjmp'
+ cannot in fact be called at the place which would cause a problem.
+
+ Some spurious warnings can be avoided if you declare all the
+ functions you use that never return as `noreturn'. *Note Function
+ Attributes::.
+
+`-Wreorder (C++ only)'
+ Warn when the order of member initializers given in the code does
+ not match the order in which they must be executed. For instance:
+
+`-Wunknown-pragmas'
+ Warn when a #pragma directive is encountered which is not
+ understood by GCC. If this command line option is used, warnings
+ will even be issued for unknown pragmas in system header files.
+ This is not the case if the warnings were only enabled by the
+ `-Wall' command line option.
+
+`-Wall'
+ All of the above `-W' options combined. This enables all the
+ warnings about constructions that some users consider
+ questionable, and that are easy to avoid (or modify to prevent the
+ warning), even in conjunction with macros.
+
+`-Wdiv-by-zero'
+ Warn about compile-time integer division by zero. This is
+ default. To inhibit the warning messages, use `-Wno-div-by-zero'.
+ Floating point division by zero is not warned about, as it can be
+ a legitimate way of obtaining infinities and NaNs.
+
+`-Wmultichar'
+ Warn if a multicharacter constant (`'FOOF'') is used. This is
+ default. To inhibit the warning messages, use `-Wno-multichar'.
+ Usually they indicate a typo in the user's code, as they have
+ implementation-defined values, and should not be used in portable
+ code.
+
+`-Wsystem-headers'
+ Print warning messages for constructs found in system header files.
+ Warnings from system headers are normally suppressed, on the
+ assumption that they usually do not indicate real problems and
+ would only make the compiler output harder to read. Using this
+ command line option tells GCC to emit warnings from system headers
+ as if they occurred in user code. However, note that using
+ `-Wall' in conjunction with this option will _not_ warn about
+ unknown pragmas in system headers--for that, `-Wunknown-pragmas'
+ must also be used.
+
+ The following `-W...' options are not implied by `-Wall'. Some of
+them warn about constructions that users generally do not consider
+questionable, but which occasionally you might wish to check for;
+others warn about constructions that are necessary or hard to avoid in
+some cases, and there is no simple way to modify the code to suppress
+the warning.
+
+`-W'
+ Print extra warning messages for these events:
+
+ * A function can return either with or without a value.
+ (Falling off the end of the function body is considered
+ returning without a value.) For example, this function would
+ evoke such a warning:
+
+ foo (a)
+ {
+ if (a > 0)
+ return a;
+ }
+
+ * An expression-statement or the left-hand side of a comma
+ expression contains no side effects. To suppress the
+ warning, cast the unused expression to void. For example, an
+ expression such as `x[i,j]' will cause a warning, but
+ `x[(void)i,j]' will not.
+
+ * An unsigned value is compared against zero with `<' or `<='.
+
+ * A comparison like `x<=y<=z' appears; this is equivalent to
+ `(x<=y ? 1 : 0) <= z', which is a different interpretation
+ from that of ordinary mathematical notation.
+
+ * Storage-class specifiers like `static' are not the first
+ things in a declaration. According to the C Standard, this
+ usage is obsolescent.
+
+ * The return type of a function has a type qualifier such as
+ `const'. Such a type qualifier has no effect, since the
+ value returned by a function is not an lvalue. (But don't
+ warn about the GNU extension of `volatile void' return types.
+ That extension will be warned about if `-pedantic' is
+ specified.)
+
+ * If `-Wall' or `-Wunused' is also specified, warn about unused
+ arguments.
+
+ * A comparison between signed and unsigned values could produce
+ an incorrect result when the signed value is converted to
+ unsigned. (But don't warn if `-Wno-sign-compare' is also
+ specified.)
+
+ * An aggregate has a partly bracketed initializer. For
+ example, the following code would evoke such a warning,
+ because braces are missing around the initializer for `x.h':
+
+ struct s { int f, g; };
+ struct t { struct s h; int i; };
+ struct t x = { 1, 2, 3 };
+
+ * An aggregate has an initializer which does not initialize all
+ members. For example, the following code would cause such a
+ warning, because `x.h' would be implicitly initialized to
+ zero:
+
+ struct s { int f, g, h; };
+ struct s x = { 3, 4 };
+
+`-Wfloat-equal'
+ Warn if floating point values are used in equality comparisons.
+
+ The idea behind this is that sometimes it is convenient (for the
+ programmer) to consider floating-point values as approximations to
+ infinitely precise real numbers. If you are doing this, then you
+ need to compute (by analysing the code, or in some other way) the
+ maximum or likely maximum error that the computation introduces,
+ and allow for it when performing comparisons (and when producing
+ output, but that's a different problem). In particular, instead
+ of testing for equality, you would check to see whether the two
+ values have ranges that overlap; and this is done with the
+ relational operators, so equality comparisons are probably
+ mistaken.
+
+`-Wtraditional (C only)'
+ Warn about certain constructs that behave differently in
+ traditional and ISO C. Also warn about ISO C constructs that have
+ no traditional C equivalent, and/or problematic constructs which
+ should be avoided.
+
+ * Macro parameters that appear within string literals in the
+ macro body. In traditional C macro replacement takes place
+ within string literals, but does not in ISO C.
+
+ * In traditional C, some preprocessor directives did not exist.
+ Traditional preprocessors would only consider a line to be a
+ directive if the `#' appeared in column 1 on the line.
+ Therefore `-Wtraditional' warns about directives that
+ traditional C understands but would ignore because the `#'
+ does not appear as the first character on the line. It also
+ suggests you hide directives like `#pragma' not understood by
+ traditional C by indenting them. Some traditional
+ implementations would not recognize `#elif', so it suggests
+ avoiding it altogether.
+
+ * A function-like macro that appears without arguments.
+
+ * The unary plus operator.
+
+ * The `U' integer constant suffix, or the `F' or `L' floating
+ point constant suffixes. (Traditional C does support the `L'
+ suffix on integer constants.) Note, these suffixes appear in
+ macros defined in the system headers of most modern systems,
+ e.g. the `_MIN'/`_MAX' macros in `<limits.h>'. Use of these
+ macros in user code might normally lead to spurious warnings,
+ however gcc's integrated preprocessor has enough context to
+ avoid warning in these cases.
+
+ * A function declared external in one block and then used after
+ the end of the block.
+
+ * A `switch' statement has an operand of type `long'.
+
+ * A non-`static' function declaration follows a `static' one.
+ This construct is not accepted by some traditional C
+ compilers.
+
+ * The ISO type of an integer constant has a different width or
+ signedness from its traditional type. This warning is only
+ issued if the base of the constant is ten. I.e. hexadecimal
+ or octal values, which typically represent bit patterns, are
+ not warned about.
+
+ * Usage of ISO string concatenation is detected.
+
+ * Initialization of automatic aggregates.
+
+ * Identifier conflicts with labels. Traditional C lacks a
+ separate namespace for labels.
+
+ * Initialization of unions. If the initializer is zero, the
+ warning is omitted. This is done under the assumption that
+ the zero initializer in user code appears conditioned on e.g.
+ `__STDC__' to avoid missing initializer warnings and relies
+ on default initialization to zero in the traditional C case.
+
+ * Conversions by prototypes between fixed/floating point values
+ and vice versa. The absence of these prototypes when
+ compiling with traditional C would cause serious problems.
+ This is a subset of the possible conversion warnings, for the
+ full set use `-Wconversion'.
+
+`-Wundef'
+ Warn if an undefined identifier is evaluated in an `#if' directive.
+
+`-Wshadow'
+ Warn whenever a local variable shadows another local variable,
+ parameter or global variable or whenever a built-in function is
+ shadowed.
+
+`-Wlarger-than-LEN'
+ Warn whenever an object of larger than LEN bytes is defined.
+
+`-Wpointer-arith'
+ Warn about anything that depends on the "size of" a function type
+ or of `void'. GNU C assigns these types a size of 1, for
+ convenience in calculations with `void *' pointers and pointers to
+ functions.
+
+`-Wbad-function-cast (C only)'
+ Warn whenever a function call is cast to a non-matching type. For
+ example, warn if `int malloc()' is cast to `anything *'.
+
+`-Wcast-qual'
+ Warn whenever a pointer is cast so as to remove a type qualifier
+ from the target type. For example, warn if a `const char *' is
+ cast to an ordinary `char *'.
+
+`-Wcast-align'
+ Warn whenever a pointer is cast such that the required alignment
+ of the target is increased. For example, warn if a `char *' is
+ cast to an `int *' on machines where integers can only be accessed
+ at two- or four-byte boundaries.
+
+`-Wwrite-strings'
+ When compiling C, give string constants the type `const
+ char[LENGTH]' so that copying the address of one into a
+ non-`const' `char *' pointer will get a warning; when compiling
+ C++, warn about the deprecated conversion from string constants to
+ `char *'. These warnings will help you find at compile time code
+ that can try to write into a string constant, but only if you have
+ been very careful about using `const' in declarations and
+ prototypes. Otherwise, it will just be a nuisance; this is why we
+ did not make `-Wall' request these warnings.
+
+`-Wconversion'
+ Warn if a prototype causes a type conversion that is different
+ from what would happen to the same argument in the absence of a
+ prototype. This includes conversions of fixed point to floating
+ and vice versa, and conversions changing the width or signedness
+ of a fixed point argument except when the same as the default
+ promotion.
+
+ Also, warn if a negative integer constant expression is implicitly
+ converted to an unsigned type. For example, warn about the
+ assignment `x = -1' if `x' is unsigned. But do not warn about
+ explicit casts like `(unsigned) -1'.
+
+`-Wsign-compare'
+ Warn when a comparison between signed and unsigned values could
+ produce an incorrect result when the signed value is converted to
+ unsigned. This warning is also enabled by `-W'; to get the other
+ warnings of `-W' without this warning, use `-W -Wno-sign-compare'.
+
+`-Waggregate-return'
+ Warn if any functions that return structures or unions are defined
+ or called. (In languages where you can return an array, this also
+ elicits a warning.)
+
+`-Wstrict-prototypes (C only)'
+ Warn if a function is declared or defined without specifying the
+ argument types. (An old-style function definition is permitted
+ without a warning if preceded by a declaration which specifies the
+ argument types.)
+
+`-Wmissing-prototypes (C only)'
+ Warn if a global function is defined without a previous prototype
+ declaration. This warning is issued even if the definition itself
+ provides a prototype. The aim is to detect global functions that
+ fail to be declared in header files.
+
+`-Wmissing-declarations'
+ Warn if a global function is defined without a previous
+ declaration. Do so even if the definition itself provides a
+ prototype. Use this option to detect global functions that are
+ not declared in header files.
+
+`-Wmissing-noreturn'
+ Warn about functions which might be candidates for attribute
+ `noreturn'. Note these are only possible candidates, not absolute
+ ones. Care should be taken to manually verify functions actually
+ do not ever return before adding the `noreturn' attribute,
+ otherwise subtle code generation bugs could be introduced. You
+ will not get a warning for `main' in hosted C environments.
+
+`-Wmissing-format-attribute'
+ If `-Wformat' is enabled, also warn about functions which might be
+ candidates for `format' attributes. Note these are only possible
+ candidates, not absolute ones. GCC will guess that `format'
+ attributes might be appropriate for any function that calls a
+ function like `vprintf' or `vscanf', but this might not always be
+ the case, and some functions for which `format' attributes are
+ appropriate may not be detected. This option has no effect unless
+ `-Wformat' is enabled (possibly by `-Wall').
+
+`-Wno-deprecated-declarations'
+ Do not warn about uses of functions, variables, and types marked as
+ deprecated by using the `deprecated' attribute. (*note Function
+ Attributes::, *note Variable Attributes::, *note Type
+ Attributes::.)
+
+`-Wpacked'
+ Warn if a structure is given the packed attribute, but the packed
+ attribute has no effect on the layout or size of the structure.
+ Such structures may be mis-aligned for little benefit. For
+ instance, in this code, the variable `f.x' in `struct bar' will be
+ misaligned even though `struct bar' does not itself have the
+ packed attribute:
+
+ struct foo {
+ int x;
+ char a, b, c, d;
+ } __attribute__((packed));
+ struct bar {
+ char z;
+ struct foo f;
+ };
+
+`-Wpadded'
+ Warn if padding is included in a structure, either to align an
+ element of the structure or to align the whole structure.
+ Sometimes when this happens it is possible to rearrange the fields
+ of the structure to reduce the padding and so make the structure
+ smaller.
+
+`-Wredundant-decls'
+ Warn if anything is declared more than once in the same scope,
+ even in cases where multiple declaration is valid and changes
+ nothing.
+
+`-Wnested-externs (C only)'
+ Warn if an `extern' declaration is encountered within a function.
+
+`-Wunreachable-code'
+ Warn if the compiler detects that code will never be executed.
+
+ This option is intended to warn when the compiler detects that at
+ least a whole line of source code will never be executed, because
+ some condition is never satisfied or because it is after a
+ procedure that never returns.
+
+ It is possible for this option to produce a warning even though
+ there are circumstances under which part of the affected line can
+ be executed, so care should be taken when removing
+ apparently-unreachable code.
+
+ For instance, when a function is inlined, a warning may mean that
+ the line is unreachable in only one inlined copy of the function.
+
+ This option is not made part of `-Wall' because in a debugging
+ version of a program there is often substantial code which checks
+ correct functioning of the program and is, hopefully, unreachable
+ because the program does work. Another common use of unreachable
+ code is to provide behavior which is selectable at compile-time.
+
+`-Winline'
+ Warn if a function can not be inlined and it was declared as
+ inline.
+
+`-Wlong-long'
+ Warn if `long long' type is used. This is default. To inhibit
+ the warning messages, use `-Wno-long-long'. Flags `-Wlong-long'
+ and `-Wno-long-long' are taken into account only when `-pedantic'
+ flag is used.
+
+`-Wdisabled-optimization'
+ Warn if a requested optimization pass is disabled. This warning
+ does not generally indicate that there is anything wrong with your
+ code; it merely indicates that GCC's optimizers were unable to
+ handle the code effectively. Often, the problem is that your code
+ is too big or too complex; GCC will refuse to optimize programs
+ when the optimization itself is likely to take inordinate amounts
+ of time.
+
+`-Werror'
+ Make all warnings into errors.
+
+\1f
+File: gcc.info, Node: Debugging Options, Next: Optimize Options, Prev: Warning Options, Up: Invoking GCC
+
+3.9 Options for Debugging Your Program or GCC
+=============================================
+
+GCC has various special options that are used for debugging either your
+program or GCC:
+
+`-g'
+ Produce debugging information in the operating system's native
+ format (stabs, COFF, XCOFF, or DWARF). GDB can work with this
+ debugging information.
+
+ On most systems that use stabs format, `-g' enables use of extra
+ debugging information that only GDB can use; this extra information
+ makes debugging work better in GDB but will probably make other
+ debuggers crash or refuse to read the program. If you want to
+ control for certain whether to generate the extra information, use
+ `-gstabs+', `-gstabs', `-gxcoff+', `-gxcoff', `-gdwarf-1+',
+ `-gdwarf-1', or `-gvms' (see below).
+
+ Unlike most other C compilers, GCC allows you to use `-g' with
+ `-O'. The shortcuts taken by optimized code may occasionally
+ produce surprising results: some variables you declared may not
+ exist at all; flow of control may briefly move where you did not
+ expect it; some statements may not be executed because they
+ compute constant results or their values were already at hand;
+ some statements may execute in different places because they were
+ moved out of loops.
+
+ Nevertheless it proves possible to debug optimized output. This
+ makes it reasonable to use the optimizer for programs that might
+ have bugs.
+
+ The following options are useful when GCC is generated with the
+ capability for more than one debugging format.
+
+`-ggdb'
+ Produce debugging information for use by GDB. This means to use
+ the most expressive format available (DWARF 2, stabs, or the
+ native format if neither of those are supported), including GDB
+ extensions if at all possible.
+
+`-gstabs'
+ Produce debugging information in stabs format (if that is
+ supported), without GDB extensions. This is the format used by
+ DBX on most BSD systems. On MIPS, Alpha and System V Release 4
+ systems this option produces stabs debugging output which is not
+ understood by DBX or SDB. On System V Release 4 systems this
+ option requires the GNU assembler.
+
+`-gstabs+'
+ Produce debugging information in stabs format (if that is
+ supported), using GNU extensions understood only by the GNU
+ debugger (GDB). The use of these extensions is likely to make
+ other debuggers crash or refuse to read the program.
+
+`-gcoff'
+ Produce debugging information in COFF format (if that is
+ supported). This is the format used by SDB on most System V
+ systems prior to System V Release 4.
+
+`-gxcoff'
+ Produce debugging information in XCOFF format (if that is
+ supported). This is the format used by the DBX debugger on IBM
+ RS/6000 systems.
+
+`-gxcoff+'
+ Produce debugging information in XCOFF format (if that is
+ supported), using GNU extensions understood only by the GNU
+ debugger (GDB). The use of these extensions is likely to make
+ other debuggers crash or refuse to read the program, and may cause
+ assemblers other than the GNU assembler (GAS) to fail with an
+ error.
+
+`-gdwarf'
+ Produce debugging information in DWARF version 1 format (if that is
+ supported). This is the format used by SDB on most System V
+ Release 4 systems.
+
+`-gdwarf+'
+ Produce debugging information in DWARF version 1 format (if that is
+ supported), using GNU extensions understood only by the GNU
+ debugger (GDB). The use of these extensions is likely to make
+ other debuggers crash or refuse to read the program.
+
+`-gdwarf-2'
+ Produce debugging information in DWARF version 2 format (if that is
+ supported). This is the format used by DBX on IRIX 6.
+
+`-gvms'
+ Produce debugging information in VMS debug format (if that is
+ supported). This is the format used by DEBUG on VMS systems.
+
+`-gLEVEL'
+`-ggdbLEVEL'
+`-gstabsLEVEL'
+`-gcoffLEVEL'
+`-gxcoffLEVEL'
+`-gvmsLEVEL'
+ Request debugging information and also use LEVEL to specify how
+ much information. The default level is 2.
+
+ Level 1 produces minimal information, enough for making backtraces
+ in parts of the program that you don't plan to debug. This
+ includes descriptions of functions and external variables, but no
+ information about local variables and no line numbers.
+
+ Level 3 includes extra information, such as all the macro
+ definitions present in the program. Some debuggers support macro
+ expansion when you use `-g3'.
+
+ Note that in order to avoid confusion between DWARF1 debug level 2,
+ and DWARF2, neither `-gdwarf' nor `-gdwarf-2' accept a
+ concatenated debug level. Instead use an additional `-gLEVEL'
+ option to change the debug level for DWARF1 or DWARF2.
+
+`-p'
+ Generate extra code to write profile information suitable for the
+ analysis program `prof'. You must use this option when compiling
+ the source files you want data about, and you must also use it when
+ linking.
+
+`-pg'
+ Generate extra code to write profile information suitable for the
+ analysis program `gprof'. You must use this option when compiling
+ the source files you want data about, and you must also use it when
+ linking.
+
+`-Q'
+ Makes the compiler print out each function name as it is compiled,
+ and print some statistics about each pass when it finishes.
+
+`-ftime-report'
+ Makes the compiler print some statistics about the time consumed
+ by each pass when it finishes.
+
+`-fmem-report'
+ Makes the compiler print some statistics about permanent memory
+ allocation when it finishes.
+
+`-fprofile-arcs'
+ Instrument "arcs" during compilation to generate coverage data or
+ for profile-directed block ordering. During execution the program
+ records how many times each branch is executed and how many times
+ it is taken. When the compiled program exits it saves this data
+ to a file called `SOURCENAME.da' for each source file.
+
+ For profile-directed block ordering, compile the program with
+ `-fprofile-arcs' plus optimization and code generation options,
+ generate the arc profile information by running the program on a
+ selected workload, and then compile the program again with the same
+ optimization and code generation options plus
+ `-fbranch-probabilities' (*note Options that Control Optimization:
+ Optimize Options.).
+
+ The other use of `-fprofile-arcs' is for use with `gcov', when it
+ is used with the `-ftest-coverage' option.
+
+ With `-fprofile-arcs', for each function of your program GCC
+ creates a program flow graph, then finds a spanning tree for the
+ graph. Only arcs that are not on the spanning tree have to be
+ instrumented: the compiler adds code to count the number of times
+ that these arcs are executed. When an arc is the only exit or
+ only entrance to a block, the instrumentation code can be added to
+ the block; otherwise, a new basic block must be created to hold
+ the instrumentation code.
+
+`-ftest-coverage'
+ Create data files for the `gcov' code-coverage utility (*note
+ `gcov'--a Test Coverage Program: Gcov.). The data file names
+ begin with the name of your source file:
+
+ `SOURCENAME.bb'
+ A mapping from basic blocks to line numbers, which `gcov'
+ uses to associate basic block execution counts with line
+ numbers.
+
+ `SOURCENAME.bbg'
+ A list of all arcs in the program flow graph. This allows
+ `gcov' to reconstruct the program flow graph, so that it can
+ compute all basic block and arc execution counts from the
+ information in the `SOURCENAME.da' file.
+
+ Use `-ftest-coverage' with `-fprofile-arcs'; the latter option
+ adds instrumentation to the program, which then writes execution
+ counts to another data file:
+
+ `SOURCENAME.da'
+ Runtime arc execution counts, used in conjunction with the arc
+ information in the file `SOURCENAME.bbg'.
+
+ Coverage data will map better to the source files if
+ `-ftest-coverage' is used without optimization.
+
+`-dLETTERS'
+ Says to make debugging dumps during compilation at times specified
+ by LETTERS. This is used for debugging the compiler. The file
+ names for most of the dumps are made by appending a pass number
+ and a word to the source file name (e.g. `foo.c.00.rtl' or
+ `foo.c.01.sibling'). Here are the possible letters for use in
+ LETTERS, and their meanings:
+
+ `A'
+ Annotate the assembler output with miscellaneous debugging
+ information.
+
+ `b'
+ Dump after computing branch probabilities, to `FILE.14.bp'.
+
+ `B'
+ Dump after block reordering, to `FILE.29.bbro'.
+
+ `c'
+ Dump after instruction combination, to the file
+ `FILE.16.combine'.
+
+ `C'
+ Dump after the first if conversion, to the file `FILE.17.ce'.
+
+ `d'
+ Dump after delayed branch scheduling, to `FILE.31.dbr'.
+
+ `D'
+ Dump all macro definitions, at the end of preprocessing, in
+ addition to normal output.
+
+ `e'
+ Dump after SSA optimizations, to `FILE.04.ssa' and
+ `FILE.07.ussa'.
+
+ `E'
+ Dump after the second if conversion, to `FILE.26.ce2'.
+
+ `f'
+ Dump after life analysis, to `FILE.15.life'.
+
+ `F'
+ Dump after purging `ADDRESSOF' codes, to `FILE.09.addressof'.
+
+ `g'
+ Dump after global register allocation, to `FILE.21.greg'.
+
+ `h'
+ Dump after finalization of EH handling code, to `FILE.02.eh'.
+
+ `k'
+ Dump after reg-to-stack conversion, to `FILE.28.stack'.
+
+ `o'
+ Dump after post-reload optimizations, to `FILE.22.postreload'.
+
+ `G'
+ Dump after GCSE, to `FILE.10.gcse'.
+
+ `i'
+ Dump after sibling call optimizations, to `FILE.01.sibling'.
+
+ `j'
+ Dump after the first jump optimization, to `FILE.03.jump'.
+
+ `k'
+ Dump after conversion from registers to stack, to
+ `FILE.32.stack'.
+
+ `l'
+ Dump after local register allocation, to `FILE.20.lreg'.
+
+ `L'
+ Dump after loop optimization, to `FILE.11.loop'.
+
+ `M'
+ Dump after performing the machine dependent reorganisation
+ pass, to `FILE.30.mach'.
+
+ `n'
+ Dump after register renumbering, to `FILE.25.rnreg'.
+
+ `N'
+ Dump after the register move pass, to `FILE.18.regmove'.
+
+ `r'
+ Dump after RTL generation, to `FILE.00.rtl'.
+
+ `R'
+ Dump after the second scheduling pass, to `FILE.27.sched2'.
+
+ `s'
+ Dump after CSE (including the jump optimization that
+ sometimes follows CSE), to `FILE.08.cse'.
+
+ `S'
+ Dump after the first scheduling pass, to `FILE.19.sched'.
+
+ `t'
+ Dump after the second CSE pass (including the jump
+ optimization that sometimes follows CSE), to `FILE.12.cse2'.
+
+ `w'
+ Dump after the second flow pass, to `FILE.23.flow2'.
+
+ `X'
+ Dump after SSA dead code elimination, to `FILE.06.ssadce'.
+
+ `z'
+ Dump after the peephole pass, to `FILE.24.peephole2'.
+
+ `a'
+ Produce all the dumps listed above.
+
+ `m'
+ Print statistics on memory usage, at the end of the run, to
+ standard error.
+
+ `p'
+ Annotate the assembler output with a comment indicating which
+ pattern and alternative was used. The length of each
+ instruction is also printed.
+
+ `P'
+ Dump the RTL in the assembler output as a comment before each
+ instruction. Also turns on `-dp' annotation.
+
+ `v'
+ For each of the other indicated dump files (except for
+ `FILE.00.rtl'), dump a representation of the control flow
+ graph suitable for viewing with VCG to `FILE.PASS.vcg'.
+
+ `x'
+ Just generate RTL for a function instead of compiling it.
+ Usually used with `r'.
+
+ `y'
+ Dump debugging information during parsing, to standard error.
+
+`-fdump-unnumbered'
+ When doing debugging dumps (see `-d' option above), suppress
+ instruction numbers and line number note output. This makes it
+ more feasible to use diff on debugging dumps for compiler
+ invocations with different options, in particular with and without
+ `-g'.
+
+`-fdump-translation-unit (C and C++ only)'
+`-fdump-translation-unit-OPTIONS (C and C++ only)'
+ Dump a representation of the tree structure for the entire
+ translation unit to a file. The file name is made by appending
+ `.tu' to the source file name. If the `-OPTIONS' form is used,
+ OPTIONS controls the details of the dump as described for the
+ `-fdump-tree' options.
+
+`-fdump-class-hierarchy (C++ only)'
+`-fdump-class-hierarchy-OPTIONS (C++ only)'
+ Dump a representation of each class's hierarchy and virtual
+ function table layout to a file. The file name is made by
+ appending `.class' to the source file name. If the `-OPTIONS'
+ form is used, OPTIONS controls the details of the dump as
+ described for the `-fdump-tree' options.
+
+`-fdump-tree-SWITCH (C++ only)'
+`-fdump-tree-SWITCH-OPTIONS (C++ only)'
+ Control the dumping at various stages of processing the
+ intermediate language tree to a file. The file name is generated
+ by appending a switch specific suffix to the source file name. If
+ the `-OPTIONS' form is used, OPTIONS is a list of `-' separated
+ options that control the details of the dump. Not all options are
+ applicable to all dumps, those which are not meaningful will be
+ ignored. The following options are available
+
+ `address'
+ Print the address of each node. Usually this is not
+ meaningful as it changes according to the environment and
+ source file. Its primary use is for tying up a dump file with
+ a debug environment.
+
+ `slim'
+ Inhibit dumping of members of a scope or body of a function
+ merely because that scope has been reached. Only dump such
+ items when they are directly reachable by some other path.
+
+ `all'
+ Turn on all options.
+
+ The following tree dumps are possible:
+ `original'
+ Dump before any tree based optimization, to `FILE.original'.
+
+ `optimized'
+ Dump after all tree based optimization, to `FILE.optimized'.
+
+ `inlined'
+ Dump after function inlining, to `FILE.inlined'.
+
+`-fsched-verbose=N'
+ On targets that use instruction scheduling, this option controls
+ the amount of debugging output the scheduler prints. This
+ information is written to standard error, unless `-dS' or `-dR' is
+ specified, in which case it is output to the usual dump listing
+ file, `.sched' or `.sched2' respectively. However for N greater
+ than nine, the output is always printed to standard error.
+
+ For N greater than zero, `-fsched-verbose' outputs the same
+ information as `-dRS'. For N greater than one, it also output
+ basic block probabilities, detailed ready list information and
+ unit/insn info. For N greater than two, it includes RTL at abort
+ point, control-flow and regions info. And for N over four,
+ `-fsched-verbose' also includes dependence info.
+
+`-fpretend-float'
+ When running a cross-compiler, pretend that the target machine
+ uses the same floating point format as the host machine. This
+ causes incorrect output of the actual floating constants, but the
+ actual instruction sequence will probably be the same as GCC would
+ make when running on the target machine.
+
+`-save-temps'
+ Store the usual "temporary" intermediate files permanently; place
+ them in the current directory and name them based on the source
+ file. Thus, compiling `foo.c' with `-c -save-temps' would produce
+ files `foo.i' and `foo.s', as well as `foo.o'. This creates a
+ preprocessed `foo.i' output file even though the compiler now
+ normally uses an integrated preprocessor.
+
+`-time'
+ Report the CPU time taken by each subprocess in the compilation
+ sequence. For C source files, this is the compiler proper and
+ assembler (plus the linker if linking is done). The output looks
+ like this:
+
+ # cc1 0.12 0.01
+ # as 0.00 0.01
+
+ The first number on each line is the "user time," that is time
+ spent executing the program itself. The second number is "system
+ time," time spent executing operating system routines on behalf of
+ the program. Both numbers are in seconds.
+
+`-print-file-name=LIBRARY'
+ Print the full absolute name of the library file LIBRARY that
+ would be used when linking--and don't do anything else. With this
+ option, GCC does not compile or link anything; it just prints the
+ file name.
+
+`-print-multi-directory'
+ Print the directory name corresponding to the multilib selected by
+ any other switches present in the command line. This directory is
+ supposed to exist in `GCC_EXEC_PREFIX'.
+
+`-print-multi-lib'
+ Print the mapping from multilib directory names to compiler
+ switches that enable them. The directory name is separated from
+ the switches by `;', and each switch starts with an `@' instead of
+ the `-', without spaces between multiple switches. This is
+ supposed to ease shell-processing.
+
+`-print-prog-name=PROGRAM'
+ Like `-print-file-name', but searches for a program such as `cpp'.
+
+`-print-libgcc-file-name'
+ Same as `-print-file-name=libgcc.a'.
+
+ This is useful when you use `-nostdlib' or `-nodefaultlibs' but
+ you do want to link with `libgcc.a'. You can do
+
+ gcc -nostdlib FILES... `gcc -print-libgcc-file-name`
+
+`-print-search-dirs'
+ Print the name of the configured installation directory and a list
+ of program and library directories gcc will search--and don't do
+ anything else.
+
+ This is useful when gcc prints the error message `installation
+ problem, cannot exec cpp0: No such file or directory'. To resolve
+ this you either need to put `cpp0' and the other compiler
+ components where gcc expects to find them, or you can set the
+ environment variable `GCC_EXEC_PREFIX' to the directory where you
+ installed them. Don't forget the trailing '/'. *Note Environment
+ Variables::.
+
+`-dumpmachine'
+ Print the compiler's target machine (for example,
+ `i686-pc-linux-gnu')--and don't do anything else.
+
+`-dumpversion'
+ Print the compiler version (for example, `3.0')--and don't do
+ anything else.
+
+`-dumpspecs'
+ Print the compiler's built-in specs--and don't do anything else.
+ (This is used when GCC itself is being built.) *Note Spec Files::.
+
+\1f
+File: gcc.info, Node: Optimize Options, Next: Preprocessor Options, Prev: Debugging Options, Up: Invoking GCC
+
+3.10 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.
+
+ With `-O', the compiler tries to reduce code size and execution
+ time, without performing any optimizations that take a great deal
+ of compilation time.
+
+`-O2'
+ Optimize even more. GCC performs nearly all supported
+ optimizations that do not involve a space-speed tradeoff. The
+ compiler does not perform loop unrolling or function inlining when
+ you specify `-O2'. 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, function inlining, and register renaming. It also
+ turns on the `-fforce-mem' option on all machines and frame
+ pointer elimination on machines where doing so does not interfere
+ with debugging.
+
+ Please note the warning under `-fgcse' about invoking `-O2' on
+ programs that use computed gotos.
+
+`-O3'
+ Optimize yet more. `-O3' turns on all optimizations specified by
+ `-O2' and also turns on the `-finline-functions' and
+ `-frename-registers' options.
+
+`-O0'
+ Do not optimize.
+
+`-Os'
+ Optimize for size. `-Os' enables all `-O2' optimizations that do
+ not typically increase code size. It also performs further
+ optimizations designed to reduce code size.
+
+ 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. Similarly for the
+ x86 architecture. 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, after
+ modifying them to store all pertinent intermediate computations
+ into variables.
+
+`-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 produces better code by making all memory
+ references potential common subexpressions. When they are not
+ common subexpressions, instruction combination should eliminate
+ the separate register-load. The `-O2' option turns on this option.
+
+`-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.
+
+`-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 Register
+ Usage: (gccint)Registers.
+
+`-foptimize-sibling-calls'
+ Optimize sibling and tail recursive calls.
+
+`-ftrapv'
+ This option generates traps for signed overflow on addition,
+ subtraction, multiplication operations.
+
+`-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.
+
+`-finline-limit=N'
+ By default, gcc limits the size of functions that can be inlined.
+ This flag allows the control of this limit for functions that are
+ explicitly marked as inline (ie marked with the inline keyword or
+ defined within the class definition in c++). N is the size of
+ functions that can be inlined in number of pseudo instructions
+ (not counting parameter handling). The default value of N is 600.
+ Increasing this value can result in more inlined code at the cost
+ of compilation time and memory consumption. Decreasing usually
+ makes the compilation faster and less code will be inlined (which
+ presumably means slower programs). This option is particularly
+ useful for programs that use inlining heavily such as those based
+ on recursive templates with C++.
+
+ _Note:_ pseudo instruction represents, in this particular context,
+ an abstract measurement of function's size. In no way, it
+ represents a count of assembly instructions and as such its exact
+ meaning might change from one release to an another.
+
+`-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. This switch does not
+ affect `extern inline' functions.
+
+`-fkeep-static-consts'
+ Emit variables declared `static const' when optimization isn't
+ turned on, even if the variables aren't referenced.
+
+ GCC enables this option by default. If you want to force the
+ compiler to check if the variable was referenced, regardless of
+ whether or not optimization is turned on, use the
+ `-fno-keep-static-consts' option.
+
+`-fmerge-constants'
+ Attempt to merge identical constants (string constants and
+ floating point constants) accross compilation units.
+
+ This option is default for optimized compilation if assembler and
+ linker support it. Use `-fno-merge-constants' to inhibit this
+ behavior.
+
+`-fmerge-all-constants'
+ Attempt to merge identical constants and identical variables.
+
+ This option implies `-fmerge-constants'. In addition to
+ `-fmerge-constants' this considers e.g. even constant initialized
+ arrays or initialized constant variables with integral or floating
+ point types. Languages like C or C++ require each non-automatic
+ variable to have distinct location, so using this option will
+ result in non-conforming behavior.
+
+`-fno-branch-count-reg'
+ Do not use "decrement and branch" instructions on a count register,
+ but instead generate a sequence of instructions that decrement a
+ register, compare it against zero, then branch based upon the
+ result. This option is only meaningful on architectures that
+ support such instructions, which include x86, PowerPC, IA-64 and
+ S/390.
+
+`-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'
+ Sets `-fno-math-errno', `-funsafe-math-optimizations', and
+ `-fno-trapping-math'.
+
+ This option causes the preprocessor macro `__FAST_MATH__' to be
+ defined.
+
+ 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 ISO rules/specifications for math
+ functions.
+
+`-fno-math-errno'
+ Do not set ERRNO after calling math functions that are executed
+ with a single instruction, e.g., sqrt. A program that relies on
+ IEEE exceptions for math error handling may want to use this flag
+ for speed while maintaining IEEE arithmetic compatibility.
+
+ 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 ISO rules/specifications for math
+ functions.
+
+ The default is `-fmath-errno'.
+
+`-funsafe-math-optimizations'
+ Allow optimizations for floating-point arithmetic that (a) assume
+ that arguments and results are valid and (b) may violate IEEE or
+ ANSI standards. When used at link-time, it may include libraries
+ or startup files that change the default FPU control word or other
+ similar optimizations.
+
+ 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 ISO rules/specifications for math
+ functions.
+
+ The default is `-fno-unsafe-math-optimizations'.
+
+`-fno-trapping-math'
+ Compile code assuming that floating-point operations cannot
+ generate user-visible traps. Setting this option may allow faster
+ code if one relies on "non-stop" IEEE arithmetic, for example.
+
+ 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 ISO rules/specifications for math
+ functions.
+
+ The default is `-ftrapping-math'.
+
+`-fbounds-check'
+ For front-ends that support it, generate additional code to check
+ that indices used to access arrays are within the declared range.
+ This is currenly only supported by the Java and Fortran 77
+ front-ends, where this option defaults to true and false
+ respectively.
+
+
+ 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.
+
+ Not all of the optimizations performed by GCC have `-f' options to
+control them.
+
+`-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.
+
+`-frerun-loop-opt'
+ Run the loop optimizer twice.
+
+`-fgcse'
+ Perform a global common subexpression elimination pass. This pass
+ also performs global constant and copy propagation.
+
+ _Note:_ When compiling a program using computed gotos, a GCC
+ extension, you may get better runtime performance if you disable
+ the global common subexpression elmination pass by adding
+ `-fno-gcse' to the command line.
+
+`-fgcse-lm'
+ When `-fgcse-lm' is enabled, global common subexpression
+ elimination will attempt to move loads which are only killed by
+ stores into themselves. This allows a loop containing a
+ load/store sequence to be changed to a load outside the loop, and
+ a copy/store within the loop.
+
+`-fgcse-sm'
+ When `-fgcse-sm' is enabled, A store motion pass is run after
+ global common subexpression elimination. This pass will attempt
+ to move stores out of loops. When used in conjunction with
+ `-fgcse-lm', loops containing a load/store sequence can be changed
+ to a load before the loop and a store after the loop.
+
+`-fdelete-null-pointer-checks'
+ Use global dataflow analysis to identify and eliminate useless
+ checks for null pointers. The compiler assumes that dereferencing
+ a null pointer would have halted the program. If a pointer is
+ checked after it has already been dereferenced, it cannot be null.
+
+ In some environments, this assumption is not true, and programs can
+ safely dereference null pointers. Use
+ `-fno-delete-null-pointer-checks' to disable this optimization for
+ programs which depend on that behavior.
+
+`-fexpensive-optimizations'
+ Perform a number of minor optimizations that are relatively
+ expensive.
+
+`-foptimize-register-move'
+`-fregmove'
+ Attempt to reassign register numbers in move instructions and as
+ operands of other simple instructions in order to maximize the
+ amount of register tying. This is especially helpful on machines
+ with two-operand instructions. GCC enables this optimization by
+ default with `-O2' or higher.
+
+ Note `-fregmove' and `-foptimize-register-move' are the same
+ optimization.
+
+`-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.
+
+`-fno-sched-interblock'
+ Don't schedule instructions across basic blocks. This is normally
+ enabled by default when scheduling before register allocation, i.e.
+ with `-fschedule-insns' or at `-O2' or higher.
+
+`-fno-sched-spec'
+ Don't allow speculative motion of non-load instructions. This is
+ normally enabled by default when scheduling before register
+ allocation, i.e. with `-fschedule-insns' or at `-O2' or higher.
+
+`-fsched-spec-load'
+ Allow speculative motion of some load instructions. This only
+ makes sense when scheduling before register allocation, i.e. with
+ `-fschedule-insns' or at `-O2' or higher.
+
+`-fsched-spec-load-dangerous'
+ Allow speculative motion of more load instructions. This only
+ makes sense when scheduling before register allocation, i.e. with
+ `-fschedule-insns' or at `-O2' or higher.
+
+`-ffunction-sections'
+`-fdata-sections'
+ Place each function or data item into its own section in the output
+ file if the target supports arbitrary sections. The name of the
+ function or the name of the data item determines the section's name
+ in the output file.
+
+ Use these options on systems where the linker can perform
+ optimizations to improve locality of reference in the instruction
+ space. HPPA processors running HP-UX and Sparc processors running
+ Solaris 2 have linkers with such optimizations. Other systems
+ using the ELF object format as well as AIX may have these
+ optimizations in the future.
+
+ Only use these options when there are significant benefits from
+ doing so. When you specify these options, the assembler and
+ linker will create larger object and executable files and will
+ also be slower. You will not be able to use `gprof' on all
+ systems if you specify this option and you may have problems with
+ debugging if you specify both this option and `-g'.
+
+`-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 always enabled by default on certain machines,
+ usually those which have no call-preserved registers to use
+ instead.
+
+ For all machines, optimization level 2 and higher enables this
+ flag by default.
+
+`-funroll-loops'
+ Unroll loops whose number of iterations can be determined at
+ compile time or upon entry to the loop. `-funroll-loops' implies
+ both `-fstrength-reduce' and `-frerun-cse-after-loop'. This
+ option makes code larger, and may or may not make it run faster.
+
+`-funroll-all-loops'
+ Unroll all loops, even if their number of iterations is uncertain
+ when the loop is entered. This usually makes programs run more
+ slowly. `-funroll-all-loops' implies the same options as
+ `-funroll-loops',
+
+`-fprefetch-loop-arrays'
+ If supported by the target machine, generate instructions to
+ prefetch memory to improve the performance of loops that access
+ large arrays.
+
+`-fmove-all-movables'
+ Forces all invariant computations in loops to be moved outside the
+ loop.
+
+`-freduce-all-givs'
+ Forces all general-induction variables in loops to be
+ strength-reduced.
+
+ _Note:_ When compiling programs written in Fortran,
+ `-fmove-all-movables' and `-freduce-all-givs' are enabled by
+ default when you use the optimizer.
+
+ These options may generate better or worse code; results are highly
+ dependent on the structure of loops within the source code.
+
+ These two options are intended to be removed someday, once they
+ have helped determine the efficacy of various approaches to
+ improving loop optimizations.
+
+ Please let us (<gcc@gcc.gnu.org> and <fortran@gnu.org>) know how
+ use of these options affects the performance of your production
+ code. We're very interested in code that runs _slower_ when these
+ options are _enabled_.
+
+`-fno-peephole'
+`-fno-peephole2'
+ Disable any machine-specific peephole optimizations. The
+ difference between `-fno-peephole' and `-fno-peephole2' is in how
+ they are implemented in the compiler; some targets use one, some
+ use the other, a few use both.
+
+`-fbranch-probabilities'
+ After running a program compiled with `-fprofile-arcs' (*note
+ Options for Debugging Your Program or `gcc': Debugging Options.),
+ you can compile it a second time using `-fbranch-probabilities',
+ to improve optimizations based on the number of times each branch
+ was taken. When the program compiled with `-fprofile-arcs' exits
+ it saves arc execution counts to a file called `SOURCENAME.da' for
+ each source file The information in this data file is very
+ dependent on the structure of the generated code, so you must use
+ the same source code and the same optimization options for both
+ compilations.
+
+ With `-fbranch-probabilities', GCC puts a `REG_EXEC_COUNT' note on
+ the first instruction of each basic block, and a `REG_BR_PROB'
+ note on each `JUMP_INSN' and `CALL_INSN'. These can be used to
+ improve optimization. Currently, they are only used in one place:
+ in `reorg.c', instead of guessing which path a branch is mostly to
+ take, the `REG_BR_PROB' values are used to exactly determine which
+ path is taken more often.
+
+`-fno-guess-branch-probability'
+ Do not guess branch probabilities using a randomized model.
+
+ Sometimes gcc will opt to use a randomized model to guess branch
+ probabilities, when none are available from either profiling
+ feedback (`-fprofile-arcs') or `__builtin_expect'. This means that
+ different runs of the compiler on the same program may produce
+ different object code.
+
+ In a hard real-time system, people don't want different runs of the
+ compiler to produce code that has different behavior; minimizing
+ non-determinism is of paramount import. This switch allows users
+ to reduce non-determinism, possibly at the expense of inferior
+ optimization.
+
+`-fstrict-aliasing'
+ Allows the compiler to assume the strictest aliasing rules
+ applicable to the language being compiled. For C (and C++), this
+ activates optimizations based on the type of expressions. In
+ particular, an object of one type is assumed never to reside at
+ the same address as an object of a different type, unless the
+ types are almost the same. For example, an `unsigned int' can
+ alias an `int', but not a `void*' or a `double'. A character type
+ may alias any other type.
+
+ Pay special attention to code like this:
+ union a_union {
+ int i;
+ double d;
+ };
+
+ int f() {
+ a_union t;
+ t.d = 3.0;
+ return t.i;
+ }
+ The practice of reading from a different union member than the one
+ most recently written to (called "type-punning") is common. Even
+ with `-fstrict-aliasing', type-punning is allowed, provided the
+ memory is accessed through the union type. So, the code above
+ will work as expected. However, this code might not:
+ int f() {
+ a_union t;
+ int* ip;
+ t.d = 3.0;
+ ip = &t.i;
+ return *ip;
+ }
+
+ Every language that wishes to perform language-specific alias
+ analysis should define a function that computes, given an `tree'
+ node, an alias set for the node. Nodes in different alias sets
+ are not allowed to alias. For an example, see the C front-end
+ function `c_get_alias_set'.
+
+`-falign-functions'
+`-falign-functions=N'
+ Align the start of functions to the next power-of-two greater than
+ N, skipping up to N bytes. For instance, `-falign-functions=32'
+ aligns functions to the next 32-byte boundary, but
+ `-falign-functions=24' would align to the next 32-byte boundary
+ only if this can be done by skipping 23 bytes or less.
+
+ `-fno-align-functions' and `-falign-functions=1' are equivalent
+ and mean that functions will not be aligned.
+
+ Some assemblers only support this flag when N is a power of two;
+ in that case, it is rounded up.
+
+ If N is not specified, use a machine-dependent default.
+
+`-falign-labels'
+`-falign-labels=N'
+ Align all branch targets to a power-of-two boundary, skipping up to
+ N bytes like `-falign-functions'. This option can easily make
+ code slower, because it must insert dummy operations for when the
+ branch target is reached in the usual flow of the code.
+
+ If `-falign-loops' or `-falign-jumps' are applicable and are
+ greater than this value, then their values are used instead.
+
+ If N is not specified, use a machine-dependent default which is
+ very likely to be `1', meaning no alignment.
+
+`-falign-loops'
+`-falign-loops=N'
+ Align loops to a power-of-two boundary, skipping up to N bytes
+ like `-falign-functions'. The hope is that the loop will be
+ executed many times, which will make up for any execution of the
+ dummy operations.
+
+ If N is not specified, use a machine-dependent default.
+
+`-falign-jumps'
+`-falign-jumps=N'
+ Align branch targets to a power-of-two boundary, for branch targets
+ where the targets can only be reached by jumping, skipping up to N
+ bytes like `-falign-functions'. In this case, no dummy operations
+ need be executed.
+
+ If N is not specified, use a machine-dependent default.
+
+`-fssa'
+ Perform optimizations in static single assignment form. Each
+ function's flow graph is translated into SSA form, optimizations
+ are performed, and the flow graph is translated back from SSA
+ form. Users should not specify this option, since it is not yet
+ ready for production use.
+
+`-fssa-ccp'
+ Perform Sparse Conditional Constant Propagation in SSA form.
+ Requires `-fssa'. Like `-fssa', this is an experimental feature.
+
+`-fssa-dce'
+ Perform aggressive dead-code elimination in SSA form. Requires
+ `-fssa'. Like `-fssa', this is an experimental feature.
+
+`-fsingle-precision-constant'
+ Treat floating point constant as single precision constant instead
+ of implicitly converting it to double precision constant.
+
+`-frename-registers'
+ Attempt to avoid false dependencies in scheduled code by making use
+ of registers left over after register allocation. This
+ optimization will most benefit processors with lots of registers.
+ It can, however, make debugging impossible, since variables will
+ no longer stay in a "home register".
+
+`-fno-cprop-registers'
+ After register allocation and post-register allocation instruction
+ splitting, we perform a copy-propagation pass to try to reduce
+ scheduling dependencies and occasionally eliminate the copy.
+
+`--param NAME=VALUE'
+ In some places, GCC uses various constants to control the amount of
+ optimization that is done. For example, GCC will not inline
+ functions that contain more that a certain number of instructions.
+ You can control some of these constants on the command-line using
+ the `--param' option.
+
+ In each case, the VALUE is an integer. The allowable choices for
+ NAME are given in the following table:
+
+ `max-delay-slot-insn-search'
+ The maximum number of instructions to consider when looking
+ for an instruction to fill a delay slot. If more than this
+ arbitrary number of instructions is searched, the time
+ savings from filling the delay slot will be minimal so stop
+ searching. Increasing values mean more aggressive
+ optimization, making the compile time increase with probably
+ small improvement in executable run time.
+
+ `max-delay-slot-live-search'
+ When trying to fill delay slots, the maximum number of
+ instructions to consider when searching for a block with
+ valid live register information. Increasing this arbitrarily
+ chosen value means more aggressive optimization, increasing
+ the compile time. This parameter should be removed when the
+ delay slot code is rewritten to maintain the control-flow
+ graph.
+
+ `max-gcse-memory'
+ The approximate maximum amount of memory that will be
+ allocated in order to perform the global common subexpression
+ elimination optimization. If more memory than specified is
+ required, the optimization will not be done.
+
+ `max-gcse-passes'
+ The maximum number of passes of GCSE to run.
+
+ `max-pending-list-length'
+ The maximum number of pending dependencies scheduling will
+ allow before flushing the current state and starting over.
+ Large functions with few branches or calls can create
+ excessively large lists which needlessly consume memory and
+ resources.
+
+ `max-inline-insns'
+ If an function contains more than this many instructions, it
+ will not be inlined. This option is precisely equivalent to
+ `-finline-limit'.
+
+
+\1f
+File: gcc.info, Node: Preprocessor Options, Next: Assembler Options, Prev: Optimize Options, Up: Invoking GCC
+
+3.11 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.
+
+ You can use `-Wp,OPTION' to bypass the compiler driver and pass
+OPTION directly through to the preprocessor. If OPTION contains
+commas, it is split into multiple options at the commas. However, many
+options are modified, translated or interpreted by the compiler driver
+before being passed to the preprocessor, and `-Wp' forcibly bypasses
+this phase. The preprocessor's direct interface is undocumented and
+subject to change, so whenever possible you should avoid using `-Wp'
+and let the driver handle the options instead.
+
+`-D NAME'
+ Predefine NAME as a macro, with definition `1'.
+
+`-D NAME=DEFINITION'
+ Predefine NAME as a macro, with definition DEFINITION. There are
+ no restrictions on the contents of DEFINITION, but if you are
+ invoking the preprocessor from a shell or shell-like program you
+ may need to use the shell's quoting syntax to protect characters
+ such as spaces that have a meaning in the shell syntax.
+
+ If you wish to define a function-like macro on the command line,
+ write its argument list with surrounding parentheses before the
+ equals sign (if any). Parentheses are meaningful to most shells,
+ so you will need to quote the option. With `sh' and `csh',
+ `-D'NAME(ARGS...)=DEFINITION'' works.
+
+ `-D' and `-U' options are processed in the order they are given on
+ the command line. All `-imacros FILE' and `-include FILE' options
+ are processed after all `-D' and `-U' options.
+
+`-U NAME'
+ Cancel any previous definition of NAME, either built in or
+ provided with a `-D' option.
+
+`-undef'
+ Do not predefine any system-specific macros. The common predefined
+ macros remain defined.
+
+`-I DIR'
+ Add the directory DIR to the list of directories to be searched
+ for header files. Directories named by `-I' are searched before
+ the standard system include directories.
+
+ It is dangerous to specify a standard system include directory in
+ an `-I' option. This defeats the special treatment of system
+ headers . It can also defeat the repairs to buggy system headers
+ which GCC makes when it is installed.
+
+`-o FILE'
+ Write output to FILE. This is the same as specifying FILE as the
+ second non-option argument to `cpp'. `gcc' has a different
+ interpretation of a second non-option argument, so you must use
+ `-o' to specify the output file.
+
+`-Wall'
+ Turns on all optional warnings which are desirable for normal
+ code. At present this is `-Wcomment' and `-Wtrigraphs'. Note that
+ many of the preprocessor's warnings are on by default and have no
+ options to control them.
+
+`-Wcomment'
+`-Wcomments'
+ Warn whenever a comment-start sequence `/*' appears in a `/*'
+ comment, or whenever a backslash-newline appears in a `//' comment.
+ (Both forms have the same effect.)
+
+`-Wtrigraphs'
+ Warn if any trigraphs are encountered. This option used to take
+ effect only if `-trigraphs' was also specified, but now works
+ independently. Warnings are not given for trigraphs within
+ comments, as they do not affect the meaning of the program.
+
+`-Wtraditional'
+ Warn about certain constructs that behave differently in
+ traditional and ISO C. Also warn about ISO C constructs that have
+ no traditional C equivalent, and problematic constructs which
+ should be avoided.
+
+`-Wimport'
+ Warn the first time `#import' is used.
+
+`-Wundef'
+ Warn whenever an identifier which is not a macro is encountered in
+ an `#if' directive, outside of `defined'. Such identifiers are
+ replaced with zero.
+
+`-Werror'
+ Make all warnings into hard errors. Source code which triggers
+ warnings will be rejected.
+
+`-Wsystem-headers'
+ Issue warnings for code in system headers. These are normally
+ unhelpful in finding bugs in your own code, therefore suppressed.
+ If you are responsible for the system library, you may want to see
+ them.
+
+`-w'
+ Suppress all warnings, including those which GNU CPP issues by
+ default.
+
+`-pedantic'
+ Issue all the mandatory diagnostics listed in the C standard.
+ Some of them are left out by default, since they trigger
+ frequently on harmless code.
+
+`-pedantic-errors'
+ Issue all the mandatory diagnostics, and make all mandatory
+ diagnostics into errors. This includes mandatory diagnostics that
+ GCC issues without `-pedantic' but treats as warnings.
+
+`-M'
+ Instead of outputting the result of preprocessing, output a rule
+ suitable for `make' describing the dependencies of the main source
+ file. The preprocessor outputs one `make' rule containing the
+ object file name for that source file, a colon, and the names of
+ all the included files, including those coming from `-include' or
+ `-imacros' command line options.
+
+ Unless specified explicitly (with `-MT' or `-MQ'), the object file
+ name consists of the basename of the source file with any suffix
+ replaced with object file suffix. If there are many included
+ files then the rule is split into several lines using `\'-newline.
+ The rule has no commands.
+
+ This option does not suppress the preprocessor's debug output,
+ such as `-dM'. To avoid mixing such debug output with the
+ dependency rules you should explicitly specify the dependency
+ output file with `-MF', or use an environment variable like
+ `DEPENDENCIES_OUTPUT' (*note DEPENDENCIES_OUTPUT::). Debug output
+ will still be sent to the regular output stream as normal.
+
+ Passing `-M' to the driver implies `-E'.
+
+`-MM'
+ Like `-M' but do not mention header files that are found in system
+ header directories, nor header files that are included, directly
+ or indirectly, from such a header.
+
+ This implies that the choice of angle brackets or double quotes in
+ an `#include' directive does not in itself determine whether that
+ header will appear in `-MM' dependency output. This is a slight
+ change in semantics from GCC versions 3.0 and earlier.
+
+`-MF FILE'
+ When used with `-M' or `-MM', specifies a file to write the
+ dependencies to. If no `-MF' switch is given the preprocessor
+ sends the rules to the same place it would have sent preprocessed
+ output.
+
+ When used with the driver options `-MD' or `-MMD', `-MF' overrides
+ the default dependency output file.
+
+`-MG'
+ When used with `-M' or `-MM', `-MG' says to treat missing header
+ files as generated files and assume they live in the same
+ directory as the source file. It suppresses preprocessed output,
+ as a missing header file is ordinarily an error.
+
+ This feature is used in automatic updating of makefiles.
+
+`-MP'
+ This option instructs CPP to add a phony target for each dependency
+ other than the main file, causing each to depend on nothing. These
+ dummy rules work around errors `make' gives if you remove header
+ files without updating the `Makefile' to match.
+
+ This is typical output:
+
+ test.o: test.c test.h
+
+ test.h:
+
+`-MT TARGET'
+ Change the target of the rule emitted by dependency generation. By
+ default CPP takes the name of the main input file, including any
+ path, deletes any file suffix such as `.c', and appends the
+ platform's usual object suffix. The result is the target.
+
+ An `-MT' option will set the target to be exactly the string you
+ specify. If you want multiple targets, you can specify them as a
+ single argument to `-MT', or use multiple `-MT' options.
+
+ For example, `-MT '$(objpfx)foo.o'' might give
+
+ $(objpfx)foo.o: foo.c
+
+`-MQ TARGET'
+ Same as `-MT', but it quotes any characters which are special to
+ Make. `-MQ '$(objpfx)foo.o'' gives
+
+ $$(objpfx)foo.o: foo.c
+
+ The default target is automatically quoted, as if it were given
+ with `-MQ'.
+
+`-MD'
+ `-MD' is equivalent to `-M -MF FILE', except that `-E' is not
+ implied. The driver determines FILE based on whether an `-o'
+ option is given. If it is, the driver uses its argument but with
+ a suffix of `.d', otherwise it take the basename of the input file
+ and applies a `.d' suffix.
+
+ If `-MD' is used in conjunction with `-E', any `-o' switch is
+ understood to specify the dependency output file (but *note
+ -MF::), but if used without `-E', each `-o' is understood to
+ specify a target object file.
+
+ Since `-E' is not implied, `-MD' can be used to generate a
+ dependency output file as a side-effect of the compilation process.
+
+`-MMD'
+ Like `-MD' except mention only user header files, not system
+ -header files.
+
+`-x c'
+`-x c++'
+`-x objective-c'
+`-x assembler-with-cpp'
+ Specify the source language: C, C++, Objective-C, or assembly.
+ This has nothing to do with standards conformance or extensions;
+ it merely selects which base syntax to expect. If you give none
+ of these options, cpp will deduce the language from the extension
+ of the source file: `.c', `.cc', `.m', or `.S'. Some other common
+ extensions for C++ and assembly are also recognized. If cpp does
+ not recognize the extension, it will treat the file as C; this is
+ the most generic mode.
+
+ *Note_* Previous versions of cpp accepted a `-lang' option which
+ selected both the language and the standards conformance level.
+ This option has been removed, because it conflicts with the `-l'
+ option.
+
+`-std=STANDARD'
+`-ansi'
+ Specify the standard to which the code should conform. Currently
+ cpp only knows about the standards for C; other language standards
+ will be added in the future.
+
+ STANDARD may be one of:
+ `iso9899:1990'
+ `c89'
+ The ISO C standard from 1990. `c89' is the customary
+ shorthand for this version of the standard.
+
+ The `-ansi' option is equivalent to `-std=c89'.
+
+ `iso9899:199409'
+ The 1990 C standard, as amended in 1994.
+
+ `iso9899:1999'
+ `c99'
+ `iso9899:199x'
+ `c9x'
+ The revised ISO C standard, published in December 1999.
+ Before publication, this was known as C9X.
+
+ `gnu89'
+ The 1990 C standard plus GNU extensions. This is the default.
+
+ `gnu99'
+ `gnu9x'
+ The 1999 C standard plus GNU extensions.
+
+`-I-'
+ Split the include path. Any directories specified with `-I'
+ options before `-I-' are searched only for headers requested with
+ `#include "FILE"'; they are not searched for `#include <FILE>'.
+ If additional directories are specified with `-I' options after
+ the `-I-', those directories are searched for all `#include'
+ directives.
+
+ In addition, `-I-' inhibits the use of the directory of the current
+ file directory as the first search directory for `#include "FILE"'.
+
+`-nostdinc'
+ Do not search the standard system directories for header files.
+ Only the directories you have specified with `-I' options (and the
+ directory of the current file, if appropriate) are searched.
+
+`-nostdinc++'
+ Do not search for header files in the C++-specific standard
+ directories, but do still search the other standard directories.
+ (This option is used when building the C++ library.)
+
+`-include FILE'
+ Process FILE as if `#include "file"' appeared as the first line of
+ the primary source file. However, the first directory searched
+ for FILE is the preprocessor's working directory _instead of_ the
+ directory containing the main source file. If not found there, it
+ is searched for in the remainder of the `#include "..."' search
+ chain as normal.
+
+ If multiple `-include' options are given, the files are included
+ in the order they appear on the command line.
+
+`-imacros FILE'
+ Exactly like `-include', except that any output produced by
+ scanning FILE is thrown away. Macros it defines remain defined.
+ This allows you to acquire all the macros from a header without
+ also processing its declarations.
+
+ All files specified by `-imacros' are processed before all files
+ specified by `-include'.
+
+`-idirafter DIR'
+ Search DIR for header files, but do it _after_ all directories
+ specified with `-I' and the standard system directories have been
+ exhausted. DIR is treated as a system include directory.
+
+`-iprefix PREFIX'
+ Specify PREFIX as the prefix for subsequent `-iwithprefix'
+ options. If the prefix represents a directory, you should include
+ the final `/'.
+
+`-iwithprefix DIR'
+`-iwithprefixbefore DIR'
+ Append DIR to the prefix specified previously with `-iprefix', and
+ add the resulting directory to the include search path.
+ `-iwithprefixbefore' puts it in the same place `-I' would;
+ `-iwithprefix' puts it where `-idirafter' would.
+
+ Use of these options is discouraged.
+
+`-isystem DIR'
+ Search DIR for header files, after all directories specified by
+ `-I' but before the standard system directories. Mark it as a
+ system directory, so that it gets the same special treatment as is
+ applied to the standard system directories.
+
+`-fpreprocessed'
+ Indicate to the preprocessor that the input file has already been
+ preprocessed. This suppresses things like macro expansion,
+ trigraph conversion, escaped newline splicing, and processing of
+ most directives. The preprocessor still recognizes and removes
+ comments, so that you can pass a file preprocessed with `-C' to
+ the compiler without problems. In this mode the integrated
+ preprocessor is little more than a tokenizer for the front ends.
+
+ `-fpreprocessed' is implicit if the input file has one of the
+ extensions `.i', `.ii' or `.mi'. These are the extensions that
+ GCC uses for preprocessed files created by `-save-temps'.
+
+`-ftabstop=WIDTH'
+ Set the distance between tab stops. This helps the preprocessor
+ report correct column numbers in warnings or errors, even if tabs
+ appear on the line. If the value is less than 1 or greater than
+ 100, the option is ignored. The default is 8.
+
+`-fno-show-column'
+ Do not print column numbers in diagnostics. This may be necessary
+ if diagnostics are being scanned by a program that does not
+ understand the column numbers, such as `dejagnu'.
+
+`-A PREDICATE=ANSWER'
+ Make an assertion with the predicate PREDICATE and answer ANSWER.
+ This form is preferred to the older form `-A PREDICATE(ANSWER)',
+ which is still supported, because it does not use shell special
+ characters.
+
+`-A -PREDICATE=ANSWER'
+ Cancel an assertion with the predicate PREDICATE and answer ANSWER.
+
+`-A-'
+ Cancel all predefined assertions and all assertions preceding it on
+ the command line. Also, undefine all predefined macros and all
+ macros preceding it on the command line. (This is a historical
+ wart and may change in the future.)
+
+`-dCHARS'
+ CHARS is a sequence of one or more of the following characters,
+ and must not be preceded by a space. Other characters are
+ interpreted by the compiler proper, or reserved for future
+ versions of GCC, and so are silently ignored. If you specify
+ characters whose behavior conflicts, the result is undefined.
+
+ `M'
+ Instead of the normal output, generate a list of `#define'
+ directives for all the macros defined during the execution of
+ the preprocessor, including predefined macros. This gives
+ you a way of finding out what is predefined in your version
+ of the preprocessor. Assuming you have no file `foo.h', the
+ command
+
+ touch foo.h; cpp -dM foo.h
+
+ will show all the predefined macros.
+
+ `D'
+ Like `M' except in two respects: it does _not_ include the
+ predefined macros, and it outputs _both_ the `#define'
+ directives and the result of preprocessing. Both kinds of
+ output go to the standard output file.
+
+ `N'
+ Like `D', but emit only the macro names, not their expansions.
+
+ `I'
+ Output `#include' directives in addition to the result of
+ preprocessing.
+
+`-P'
+ Inhibit generation of linemarkers in the output from the
+ preprocessor. This might be useful when running the preprocessor
+ on something that is not C code, and will be sent to a program
+ which might be confused by the linemarkers.
+
+`-C'
+ Do not discard comments. All comments are passed through to the
+ output file, except for comments in processed directives, which
+ are deleted along with the directive.
+
+ You should be prepared for side effects when using `-C'; it causes
+ the preprocessor to treat comments as tokens in their own right.
+ For example, comments appearing at the start of what would be a
+ directive line have the effect of turning that line into an
+ ordinary source line, since the first token on the line is no
+ longer a `#'.
+
+`-gcc'
+ Define the macros __GNUC__, __GNUC_MINOR__ and
+ __GNUC_PATCHLEVEL__. These are defined automatically when you use
+ `gcc -E'; you can turn them off in that case with `-no-gcc'.
+
+`-traditional'
+ Try to imitate the behavior of old-fashioned C, as opposed to ISO
+ C.
+
+`-trigraphs'
+ Process trigraph sequences. These are three-character sequences,
+ all starting with `??', that are defined by ISO C to stand for
+ single characters. For example, `??/' stands for `\', so `'??/n''
+ is a character constant for a newline. By default, GCC ignores
+ trigraphs, but in standard-conforming modes it converts them. See
+ the `-std' and `-ansi' options.
+
+ The nine trigraphs and their replacements are
+
+ Trigraph: ??( ??) ??< ??> ??= ??/ ??' ??! ??-
+ Replacement: [ ] { } # \ ^ | ~
+
+`-remap'
+ Enable special code to work around file systems which only permit
+ very short file names, such as MS-DOS.
+
+`-$'
+ Forbid the use of `$' in identifiers. The C standard allows
+ implementations to define extra characters that can appear in
+ identifiers. By default GNU CPP permits `$', a common extension.
+
+`-h'
+`--help'
+`--target-help'
+ Print text describing all the command line options instead of
+ preprocessing anything.
+
+`-v'
+ Verbose mode. Print out GNU CPP's version number at the beginning
+ of execution, and report the final form of the include path.
+
+`-H'
+ Print the name of each header file used, in addition to other
+ normal activities. Each name is indented to show how deep in the
+ `#include' stack it is.
+
+`-version'
+`--version'
+ Print out GNU CPP's version number. With one dash, proceed to
+ preprocess as normal. With two dashes, exit immediately.
+
+\1f
+File: gcc.info, Node: Assembler Options, Next: Link Options, Prev: Preprocessor Options, Up: Invoking GCC
+
+3.12 Passing Options to the Assembler
+=====================================
+
+You can pass 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.
+
+\1f
+File: gcc.info, Node: Link Options, Next: Directory Options, Prev: Assembler Options, Up: Invoking GCC
+
+3.13 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'
+`-l LIBRARY'
+ Search the library named LIBRARY when linking. (The second
+ alternative with the library as a separate argument is only for
+ POSIX compliance and is not recommended.)
+
+ It makes a difference where in the command you write this option;
+ the linker searches and 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 system libraries are used normally, unless `-nostdlib' or
+ `-nodefaultlibs' is used.
+
+`-nodefaultlibs'
+ Do not use the standard system libraries when linking. Only the
+ libraries you specify will be passed to the linker. The standard
+ startup files are used normally, unless `-nostartfiles' is used.
+ The compiler may generate calls to memcmp, memset, and memcpy for
+ System V (and ISO C) environments or to bcopy and bzero for BSD
+ environments. These entries are usually resolved by entries in
+ libc. These entry points should be supplied through some other
+ mechanism when this option is specified.
+
+`-nostdlib'
+ Do not use the standard system startup files or libraries when
+ linking. No startup files and only the libraries you specify will
+ be passed to the linker. The compiler may generate calls to
+ memcmp, memset, and memcpy for System V (and ISO C) environments
+ or to bcopy and bzero for BSD environments. These entries are
+ usually resolved by entries in libc. These entry points should be
+ supplied through some other mechanism when this option is
+ specified.
+
+ One of the standard libraries bypassed by `-nostdlib' and
+ `-nodefaultlibs' is `libgcc.a', a library of internal subroutines
+ that GCC uses to overcome shortcomings of particular machines, or
+ special needs for some languages. (*Note Interfacing to GCC
+ Output: (gccint)Interface, for more discussion of `libgcc.a'.) In
+ most cases, you need `libgcc.a' even when you want to avoid other
+ standard libraries. In other words, when you specify `-nostdlib'
+ or `-nodefaultlibs' you should usually specify `-lgcc' as well.
+ This ensures that you have no unresolved references to internal GCC
+ library subroutines. (For example, `__main', used to ensure C++
+ constructors will be called; *note `collect2': (gccint)Collect2.)
+
+`-s'
+ Remove all symbol table and relocation information from the
+ executable.
+
+`-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. Not all systems support this
+ option. For predictable results, you must also specify the same
+ set of options that were used to generate code (`-fpic', `-fPIC',
+ or model suboptions) when you specify this option.(1)
+
+`-shared-libgcc'
+`-static-libgcc'
+ On systems that provide `libgcc' as a shared library, these options
+ force the use of either the shared or static version respectively.
+ If no shared version of `libgcc' was built when the compiler was
+ configured, these options have no effect.
+
+ There are several situations in which an application should use the
+ shared `libgcc' instead of the static version. The most common of
+ these is when the application wishes to throw and catch exceptions
+ across different shared libraries. In that case, each of the
+ libraries as well as the application itself should use the shared
+ `libgcc'.
+
+ Therefore, the G++ and GCJ drivers automatically add
+ `-shared-libgcc' whenever you build a shared library or a main
+ executable, because C++ and Java programs typically use
+ exceptions, so this is the right thing to do.
+
+ If, instead, you use the GCC driver to create shared libraries,
+ you may find that they will not always be linked with the shared
+ `libgcc'. If GCC finds, at its configuration time, that you have
+ a GNU linker that does not support option `--eh-frame-hdr', it
+ will link the shared version of `libgcc' into shared libraries by
+ default. Otherwise, it will take advantage of the linker and
+ optimize away the linking with the shared version of `libgcc',
+ linking with the static version of libgcc by default. This allows
+ exceptions to propagate through such shared libraries, without
+ incurring relocation costs at library load time.
+
+ However, if a library or main executable is supposed to throw or
+ catch exceptions, you must link it using the G++ or GCJ driver, as
+ appropriate for the languages used in the program, or using the
+ option `-shared-libgcc', such that it is linked with the shared
+ `libgcc'.
+
+`-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 GCC 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.
+
+ ---------- Footnotes ----------
+
+ (1) On some systems, `gcc -shared' needs to build supplementary stub
+code for constructors to work. On multi-libbed systems, `gcc -shared'
+must select the correct support libraries to link against. Failing to
+supply the correct flags may lead to subtle defects. Supplying them in
+cases where they are not necessary is innocuous.
+
+\1f
+File: gcc.info, Node: Directory Options, Next: Spec Files, Prev: Link Options, Up: Invoking GCC
+
+3.14 Options for Directory Search
+=================================
+
+These options specify directories to search for header files, for
+libraries and for parts of the compiler:
+
+`-IDIR'
+ Add the directory DIR to the head of the list of directories to be
+ searched for header files. This can be used to override a system
+ header file, substituting your own version, since these
+ directories are searched before the system header file
+ directories. However, you should not use this option to add
+ directories that contain vendor-supplied system header files (use
+ `-isystem' for that). If you use more than one `-I' option, the
+ directories are scanned in left-to-right order; the standard
+ system directories come after.
+
+ If a standard system include directory, or a directory specified
+ with `-isystem', is also specified with `-I', the `-I' option will
+ be ignored. The directory will still be searched but as a system
+ directory at its normal position in the system include chain.
+ This is to ensure that GCC's procedure to fix buggy system headers
+ and the ordering for the include_next directive are not
+ inadvertantly changed. If you really need to change the search
+ order for system directories, use the `-nostdinc' and/or
+ `-isystem' options.
+
+`-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 <FILE>'.
+
+ 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,
+ include files, 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.
+
+ The compiler will check to see if the path provided by the `-B'
+ refers to a directory, and if necessary it will add a directory
+ separator character at the end of the path.
+
+ `-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. They also apply to
+ includes files in the preprocessor, because the compiler
+ translates these options into `-isystem' options for the
+ preprocessor. In this case, the compiler appends `include' to the
+ prefix.
+
+ 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::.
+
+ As a special kludge, if the path provided by `-B' is
+ `[dir/]stageN/', where N is a number in the range 0 to 9, then it
+ will be replaced by `[dir/]include'. This is to help with
+ boot-strapping the compiler.
+
+`-specs=FILE'
+ Process FILE after the compiler reads in the standard `specs'
+ file, in order to override the defaults that the `gcc' driver
+ program uses when determining what switches to pass to `cc1',
+ `cc1plus', `as', `ld', etc. More than one `-specs=FILE' can be
+ specified on the command line, and they are processed in order,
+ from left to right.
+
+\1f
+File: gcc.info, Node: Spec Files, Next: Target Options, Prev: Directory Options, Up: Invoking GCC
+
+3.15 Specifying subprocesses and the switches to pass to them
+=============================================================
+
+`gcc' is a driver program. It performs its job by invoking a sequence
+of other programs to do the work of compiling, assembling and linking.
+GCC interprets its command-line parameters and uses these to deduce
+which programs it should invoke, and which command-line options it
+ought to place on their command lines. This behavior is controlled by
+"spec strings". In most cases there is one spec string for each
+program that GCC can invoke, but a few programs have multiple spec
+strings to control their behavior. The spec strings built into GCC can
+be overridden by using the `-specs=' command-line switch to specify a
+spec file.
+
+ "Spec files" are plaintext files that are used to construct spec
+strings. They consist of a sequence of directives separated by blank
+lines. The type of directive is determined by the first non-whitespace
+character on the line and it can be one of the following:
+
+`%COMMAND'
+ Issues a COMMAND to the spec file processor. The commands that can
+ appear here are:
+
+ `%include <FILE>'
+ Search for FILE and insert its text at the current point in
+ the specs file.
+
+ `%include_noerr <FILE>'
+ Just like `%include', but do not generate an error message if
+ the include file cannot be found.
+
+ `%rename OLD_NAME NEW_NAME'
+ Rename the spec string OLD_NAME to NEW_NAME.
+
+
+`*[SPEC_NAME]:'
+ This tells the compiler to create, override or delete the named
+ spec string. All lines after this directive up to the next
+ directive or blank line are considered to be the text for the spec
+ string. If this results in an empty string then the spec will be
+ deleted. (Or, if the spec did not exist, then nothing will
+ happened.) Otherwise, if the spec does not currently exist a new
+ spec will be created. If the spec does exist then its contents
+ will be overridden by the text of this directive, unless the first
+ character of that text is the `+' character, in which case the
+ text will be appended to the spec.
+
+`[SUFFIX]:'
+ Creates a new `[SUFFIX] spec' pair. All lines after this directive
+ and up to the next directive or blank line are considered to make
+ up the spec string for the indicated suffix. When the compiler
+ encounters an input file with the named suffix, it will processes
+ the spec string in order to work out how to compile that file.
+ For example:
+
+ .ZZ:
+ z-compile -input %i
+
+ This says that any input file whose name ends in `.ZZ' should be
+ passed to the program `z-compile', which should be invoked with the
+ command-line switch `-input' and with the result of performing the
+ `%i' substitution. (See below.)
+
+ As an alternative to providing a spec string, the text that
+ follows a suffix directive can be one of the following:
+
+ `@LANGUAGE'
+ This says that the suffix is an alias for a known LANGUAGE.
+ This is similar to using the `-x' command-line switch to GCC
+ to specify a language explicitly. For example:
+
+ .ZZ:
+ @c++
+
+ Says that .ZZ files are, in fact, C++ source files.
+
+ `#NAME'
+ This causes an error messages saying:
+
+ NAME compiler not installed on this system.
+
+ GCC already has an extensive list of suffixes built into it. This
+ directive will add an entry to the end of the list of suffixes, but
+ since the list is searched from the end backwards, it is
+ effectively possible to override earlier entries using this
+ technique.
+
+
+ GCC has the following spec strings built into it. Spec files can
+override these strings or create their own. Note that individual
+targets can also add their own spec strings to this list.
+
+ asm Options to pass to the assembler
+ asm_final Options to pass to the assembler post-processor
+ cpp Options to pass to the C preprocessor
+ cc1 Options to pass to the C compiler
+ cc1plus Options to pass to the C++ compiler
+ endfile Object files to include at the end of the link
+ link Options to pass to the linker
+ lib Libraries to include on the command line to the linker
+ libgcc Decides which GCC support library to pass to the linker
+ linker Sets the name of the linker
+ predefines Defines to be passed to the C preprocessor
+ signed_char Defines to pass to CPP to say whether `char' is signed
+ by default
+ startfile Object files to include at the start of the link
+
+ Here is a small example of a spec file:
+
+ %rename lib old_lib
+
+ *lib:
+ --start-group -lgcc -lc -leval1 --end-group %(old_lib)
+
+ This example renames the spec called `lib' to `old_lib' and then
+overrides the previous definition of `lib' with a new one. The new
+definition adds in some extra command-line options before including the
+text of the old definition.
+
+ "Spec strings" are a list of command-line options to be passed to
+their corresponding program. In addition, the spec strings can contain
+`%'-prefixed sequences to substitute variable text or to conditionally
+insert text into the command line. Using these constructs it is
+possible to generate quite complex command lines.
+
+ Here is a table of all defined `%'-sequences for spec strings. Note
+that spaces are not generated automatically around the results of
+expanding these sequences. Therefore you can concatenate them together
+or combine them with constant text in a single argument.
+
+`%%'
+ Substitute one `%' into the program name or argument.
+
+`%i'
+ Substitute the name of the input file being processed.
+
+`%b'
+ Substitute the basename of the input file being processed. This
+ is the substring up to (and not including) the last period and not
+ including the directory.
+
+`%B'
+ This is the same as `%b', but include the file suffix (text after
+ the last period).
+
+`%d'
+ Marks the argument containing or following the `%d' as a temporary
+ file name, so that that file will be deleted if GCC exits
+ successfully. Unlike `%g', this contributes no text to the
+ argument.
+
+`%gSUFFIX'
+ Substitute a file name that has suffix SUFFIX and is chosen once
+ per compilation, and mark the argument in the same way as `%d'.
+ To reduce exposure to denial-of-service attacks, the file name is
+ now chosen in a way that is hard to predict even when previously
+ chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
+ might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX
+ matches the regexp `[.A-Za-z]*' or the special string `%O', which
+ is treated exactly as if `%O' had been preprocessed. Previously,
+ `%g' was simply substituted with a file name chosen once per
+ compilation, without regard to any appended suffix (which was
+ therefore treated just like ordinary text), making such attacks
+ more likely to succeed.
+
+`%uSUFFIX'
+ Like `%g', but generates a new temporary file name even if
+ `%uSUFFIX' was already seen.
+
+`%USUFFIX'
+ Substitutes the last file name generated with `%uSUFFIX',
+ generating a new one if there is no such last file name. In the
+ absence of any `%uSUFFIX', this is just like `%gSUFFIX', except
+ they don't share the same suffix _space_, so `%g.s ... %U.s ...
+ %g.s ... %U.s' would involve the generation of two distinct file
+ names, one for each `%g.s' and another for each `%U.s'.
+ Previously, `%U' was simply substituted with a file name chosen
+ for the previous `%u', without regard to any appended suffix.
+
+`%jSUFFIX'
+ Substitutes the name of the `HOST_BIT_BUCKET', if any, and if it is
+ writable, and if save-temps is off; otherwise, substitute the name
+ of a temporary file, just like `%u'. This temporary file is not
+ meant for communication between processes, but rather as a junk
+ disposal mechanism.
+
+`%.SUFFIX'
+ Substitutes .SUFFIX for the suffixes of a matched switch's args
+ when it is subsequently output with `%*'. SUFFIX is terminated by
+ the next space or %.
+
+`%w'
+ Marks the argument containing or following the `%w' as the
+ designated output file of this compilation. This puts the argument
+ into the sequence of arguments that `%o' will substitute later.
+
+`%o'
+ Substitutes the names of all the output files, with spaces
+ automatically placed around them. You should write spaces around
+ the `%o' as well or the results are undefined. `%o' is for use in
+ the specs for running the linker. Input files whose names have no
+ recognized suffix are not compiled at all, but they are included
+ among the output files, so they will be linked.
+
+`%O'
+ Substitutes the suffix for object files. Note that this is
+ handled specially when it immediately follows `%g, %u, or %U',
+ because of the need for those to form complete file names. The
+ handling is such that `%O' is treated exactly as if it had already
+ been substituted, except that `%g, %u, and %U' do not currently
+ support additional SUFFIX characters following `%O' as they would
+ following, for example, `.o'.
+
+`%p'
+ Substitutes the standard macro predefinitions for the current
+ target machine. Use this when running `cpp'.
+
+`%P'
+ Like `%p', but puts `__' before and after the name of each
+ predefined macro, except for macros that start with `__' or with
+ `_L', where L is an uppercase letter. This is for ISO C.
+
+`%I'
+ Substitute a `-iprefix' option made from `GCC_EXEC_PREFIX'.
+
+`%s'
+ Current argument is the name of a library or startup file of some
+ sort. Search for that file in a standard list of directories and
+ substitute the full name found.
+
+`%eSTR'
+ Print STR as an error message. STR is terminated by a newline.
+ Use this when inconsistent options are detected.
+
+`%|'
+ Output `-' if the input for the current command is coming from a
+ pipe.
+
+`%(NAME)'
+ Substitute the contents of spec string NAME at this point.
+
+`%[NAME]'
+ Like `%(...)' but put `__' around `-D' arguments.
+
+`%x{OPTION}'
+ Accumulate an option for `%X'.
+
+`%X'
+ Output the accumulated linker options specified by `-Wl' or a `%x'
+ spec string.
+
+`%Y'
+ Output the accumulated assembler options specified by `-Wa'.
+
+`%Z'
+ Output the accumulated preprocessor options specified by `-Wp'.
+
+`%v1'
+ Substitute the major version number of GCC. (For version 2.9.5,
+ this is 2.)
+
+`%v2'
+ Substitute the minor version number of GCC. (For version 2.9.5,
+ this is 9.)
+
+`%v3'
+ Substitute the patch level number of GCC. (For version 2.9.5,
+ this is 5.)
+
+`%a'
+ Process the `asm' spec. This is used to compute the switches to
+ be passed to the assembler.
+
+`%A'
+ Process the `asm_final' spec. This is a spec string for passing
+ switches to an assembler post-processor, if such a program is
+ needed.
+
+`%l'
+ Process the `link' spec. This is the spec for computing the
+ command line passed to the linker. Typically it will make use of
+ the `%L %G %S %D and %E' sequences.
+
+`%D'
+ Dump out a `-L' option for each directory that GCC believes might
+ contain startup files. If the target supports multilibs then the
+ current multilib directory will be prepended to each of these
+ paths.
+
+`%M'
+ Output the multilib directory with directory separators replaced
+ with `_'. If multilib directories are not set, or the multilib
+ directory is `.' then this option emits nothing.
+
+`%L'
+ Process the `lib' spec. This is a spec string for deciding which
+ libraries should be included on the command line to the linker.
+
+`%G'
+ Process the `libgcc' spec. This is a spec string for deciding
+ which GCC support library should be included on the command line
+ to the linker.
+
+`%S'
+ Process the `startfile' spec. This is a spec for deciding which
+ object files should be the first ones passed to the linker.
+ Typically this might be a file named `crt0.o'.
+
+`%E'
+ Process the `endfile' spec. This is a spec string that specifies
+ the last object files that will be passed to the linker.
+
+`%C'
+ Process the `cpp' spec. This is used to construct the arguments
+ to be passed to the C preprocessor.
+
+`%c'
+ Process the `signed_char' spec. This is intended to be used to
+ tell cpp whether a char is signed. It typically has the
+ definition:
+ %{funsigned-char:-D__CHAR_UNSIGNED__}
+
+`%1'
+ Process the `cc1' spec. This is used to construct the options to
+ be passed to the actual C compiler (`cc1').
+
+`%2'
+ Process the `cc1plus' spec. This is used to construct the options
+ to be passed to the actual C++ compiler (`cc1plus').
+
+`%*'
+ Substitute the variable part of a matched option. See below.
+ Note that each comma in the substituted string is replaced by a
+ single space.
+
+`%{`S'}'
+ Substitutes the `-S' switch, if that switch was given to GCC. If
+ that switch was not specified, this substitutes nothing. Note that
+ the leading dash is omitted when specifying this option, and it is
+ automatically inserted if the substitution is performed. Thus the
+ spec string `%{foo}' would match the command-line option `-foo'
+ and would output the command line option `-foo'.
+
+`%W{`S'}'
+ Like %{`S'} but mark last argument supplied within as a file to be
+ deleted on failure.
+
+`%{`S'*}'
+ Substitutes all the switches specified to GCC whose names start
+ with `-S', but which also take an argument. This is used for
+ switches like `-o', `-D', `-I', etc. GCC considers `-o foo' as
+ being one switch whose names starts with `o'. %{o*} would
+ substitute this text, including the space. Thus two arguments
+ would be generated.
+
+`%{^`S'*}'
+ Like %{`S'*}, but don't put a blank between a switch and its
+ argument. Thus %{^o*} would only generate one argument, not two.
+
+`%{`S'*&`T'*}'
+ Like %{`S'*}, but preserve order of `S' and `T' options (the order
+ of `S' and `T' in the spec is not significant). There can be any
+ number of ampersand-separated variables; for each the wild card is
+ optional. Useful for CPP as `%{D*&U*&A*}'.
+
+`%{<`S'}'
+ Remove all occurrences of `-S' from the command line. Note--this
+ command is position dependent. `%' commands in the spec string
+ before this option will see `-S', `%' commands in the spec string
+ after this option will not.
+
+`%{`S'*:`X'}'
+ Substitutes `X' if one or more switches whose names start with
+ `-S' are specified to GCC. Note that the tail part of the `-S'
+ option (i.e. the part matched by the `*') will be substituted for
+ each occurrence of `%*' within `X'.
+
+`%{`S':`X'}'
+ Substitutes `X', but only if the `-S' switch was given to GCC.
+
+`%{!`S':`X'}'
+ Substitutes `X', but only if the `-S' switch was _not_ given to
+ GCC.
+
+`%{|`S':`X'}'
+ Like %{`S':`X'}, but if no `S' switch, substitute `-'.
+
+`%{|!`S':`X'}'
+ Like %{!`S':`X'}, but if there is an `S' switch, substitute `-'.
+
+`%{.`S':`X'}'
+ Substitutes `X', but only if processing a file with suffix `S'.
+
+`%{!.`S':`X'}'
+ Substitutes `X', but only if _not_ processing a file with suffix
+ `S'.
+
+`%{`S'|`P':`X'}'
+ Substitutes `X' if either `-S' or `-P' was given to GCC. This may
+ be combined with `!' and `.' sequences as well, although they have
+ a stronger binding than the `|'. For example a spec string like
+ this:
+
+ %{.c:-foo} %{!.c:-bar} %{.c|d:-baz} %{!.c|d:-boggle}
+
+ will output the following command-line options from the following
+ input command-line options:
+
+ fred.c -foo -baz
+ jim.d -bar -boggle
+ -d fred.c -foo -baz -boggle
+ -d jim.d -bar -baz -boggle
+
+
+ The conditional text `X' in a %{`S':`X'} or %{!`S':`X'} construct
+may contain other nested `%' constructs or spaces, or even newlines.
+They are processed as usual, as described above.
+
+ The `-O', `-f', `-m', and `-W' switches are handled specifically in
+these constructs. If another value of `-O' or the negated form of a
+`-f', `-m', or `-W' switch is found later in the command line, the
+earlier switch value is ignored, except with {`S'*} where `S' is just
+one letter, which passes all matching options.
+
+ The character `|' at the beginning of the predicate text is used to
+indicate that a command should be piped to the following command, but
+only if `-pipe' is specified.
+
+ It is built into GCC which switches take arguments and which do not.
+(You might think it would be useful to generalize this to allow each
+compiler's spec to say which switches take arguments. But this cannot
+be done in a consistent fashion. GCC cannot even decide which input
+files have been specified without knowing which switches take arguments,
+and it must know which input files to compile in order to tell which
+compilers to run).
+
+ GCC also knows implicitly that arguments starting in `-l' are to be
+treated as compiler output files, and passed to the linker in their
+proper position among the other output files.
+
+\1f
+File: gcc.info, Node: Target Options, Next: Submodel Options, Prev: Spec Files, Up: Invoking GCC
+
+3.16 Specifying Target Machine and Compiler Version
+===================================================
+
+By default, GCC 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 GCC, 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 GCC 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 GCC as a cross-compiler.
+
+ The value to use for MACHINE is the same as was specified as the
+ machine type when configuring GCC 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 GCC to run. This
+ is useful when multiple versions are installed. For example,
+ VERSION might be `2.0', meaning to run GCC version 2.0.
+
+ The default version, when you do not specify `-V', is the last
+ version of GCC that you installed.
+
+ 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 GCC, 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. It is common for the interface to the other
+executables to change incompatibly between compiler versions, so unless
+the version specified is very close to that of the driver (for example,
+`-V 3.0' with a driver program from GCC version 3.0.1), use of `-V' may
+not work; for example, using `-V 2.95.2' will not work with a driver
+program from GCC 3.0.
+
+ 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 sufficiently similar compiler
+versions.
+
+ 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.
+
+\1f
+File: gcc.info, Node: Submodel Options, Next: Code Gen Options, Prev: Target Options, Up: Invoking GCC
+
+3.17 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::
+* M68hc1x Options::
+* VAX Options::
+* SPARC Options::
+* Convex Options::
+* AMD29K Options::
+* ARM Options::
+* MN10200 Options::
+* MN10300 Options::
+* M32R/D Options::
+* M88K Options::
+* RS/6000 and PowerPC Options::
+* RT Options::
+* MIPS Options::
+* i386 and x86-64 Options::
+* HPPA Options::
+* Intel 960 Options::
+* DEC Alpha Options::
+* DEC Alpha/VMS Options::
+* Clipper Options::
+* H8/300 Options::
+* SH Options::
+* System V Options::
+* TMS320C3x/C4x Options::
+* V850 Options::
+* ARC Options::
+* NS32K Options::
+* AVR Options::
+* MCore Options::
+* IA-64 Options::
+* D30V Options::
+* S/390 and zSeries Options::
+* CRIS Options::
+* MMIX Options::
+* PDP-11 Options::
+* Xstormy16 Options::
+* Xtensa Options::
+
+\1f
+File: gcc.info, Node: M680x0 Options, Next: M68hc1x Options, Up: Submodel Options
+
+3.17.1 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.
+
+ Use this option for microcontrollers with a 68000 or EC000 core,
+ including the 68008, 68302, 68306, 68307, 68322, 68328 and 68356.
+
+`-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. Use this option if your
+ 68040 does not have code to emulate those instructions.
+
+`-m68060'
+ Generate output for a 68060. This is the default when the
+ compiler is configured for 68060-based systems.
+
+ This option inhibits the use of 68020 and 68881/68882 instructions
+ that have to be emulated by software on the 68060. Use this
+ option if your 68060 does not have code to emulate those
+ instructions.
+
+`-mcpu32'
+ Generate output for a CPU32. This is the default when the
+ compiler is configured for CPU32-based systems.
+
+ Use this option for microcontrollers with a CPU32 or CPU32+ core,
+ including the 68330, 68331, 68332, 68333, 68334, 68336, 68340,
+ 68341, 68349 and 68360.
+
+`-m5200'
+ Generate output for a 520X "coldfire" family cpu. This is the
+ default when the compiler is configured for 520X-based systems.
+
+ Use this option for microcontroller with a 5200 core, including
+ the MCF5202, MCF5203, MCF5204 and MCF5202.
+
+`-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.
+
+`-m68020-60'
+ Generate output for a 68060, 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 68060.
+
+`-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 available for all m68k
+ targets. 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. The embedded
+ targets `m68k-*-aout' and `m68k-*-coff' do provide software
+ floating point support.
+
+`-mshort'
+ Consider type `int' to be 16 bits wide, like `short int'.
+
+`-mnobitfield'
+ Do not use the bit-field instructions. The `-m68000', `-mcpu32'
+ and `-m5200' options imply `-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, 68020, 68030,
+ 68040, 68060 and CPU32 processors, but not by the 68000 or 5200.
+
+`-malign-int'
+`-mno-align-int'
+ Control whether GCC aligns `int', `long', `long long', `float',
+ `double', and `long double' variables on a 32-bit boundary
+ (`-malign-int') or a 16-bit boundary (`-mno-align-int'). Aligning
+ variables on 32-bit boundaries produces code that runs somewhat
+ faster on processors with 32-bit busses at the expense of more
+ memory.
+
+ *Warning:* if you use the `-malign-int' switch, GCC will align
+ structures containing the above types differently than most
+ published application binary interface specifications for the m68k.
+
+`-mpcrel'
+ Use the pc-relative addressing mode of the 68000 directly, instead
+ of using a global offset table. At present, this option implies
+ `-fpic', allowing at most a 16-bit offset for pc-relative
+ addressing. `-fPIC' is not presently supported with `-mpcrel',
+ though this could be supported for 68020 and higher processors.
+
+`-mno-strict-align'
+`-mstrict-align'
+ Do not (do) assume that unaligned memory references will be
+ handled by the system.
+
+
+\1f
+File: gcc.info, Node: M68hc1x Options, Next: VAX Options, Prev: M680x0 Options, Up: Submodel Options
+
+3.17.2 M68hc1x Options
+----------------------
+
+These are the `-m' options defined for the 68hc11 and 68hc12
+microcontrollers. The default values for these options depends on
+which style of microcontroller was selected when the compiler was
+configured; the defaults for the most common choices are given below.
+
+`-m6811'
+`-m68hc11'
+ Generate output for a 68HC11. This is the default when the
+ compiler is configured for 68HC11-based systems.
+
+`-m6812'
+`-m68hc12'
+ Generate output for a 68HC12. This is the default when the
+ compiler is configured for 68HC12-based systems.
+
+`-mauto-incdec'
+ Enable the use of 68HC12 pre and post auto-increment and
+ auto-decrement addressing modes.
+
+`-mshort'
+ Consider type `int' to be 16 bits wide, like `short int'.
+
+`-msoft-reg-count=COUNT'
+ Specify the number of pseudo-soft registers which are used for the
+ code generation. The maximum number is 32. Using more pseudo-soft
+ register may or may not result in better code depending on the
+ program. The default is 4 for 68HC11 and 2 for 68HC12.
+
+
+\1f
+File: gcc.info, Node: VAX Options, Next: SPARC Options, Prev: M68hc1x Options, Up: Submodel Options
+
+3.17.3 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.
+
+\1f
+File: gcc.info, Node: SPARC Options, Next: Convex Options, Prev: VAX Options, Up: Submodel Options
+
+3.17.4 SPARC Options
+--------------------
+
+These `-m' switches are supported on the SPARC:
+
+`-mno-app-regs'
+`-mapp-regs'
+ Specify `-mapp-regs' to generate output using the global registers
+ 2 through 4, which the SPARC SVR4 ABI reserves for applications.
+ This is the default.
+
+ To be fully SVR4 ABI compliant at the cost of some performance
+ loss, specify `-mno-app-regs'. You should compile libraries and
+ system software with this option.
+
+`-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:* the requisite libraries are not available for all SPARC
+ targets. 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. The embedded
+ targets `sparc-*-aout' and `sparclite-*-*' do provide software
+ floating point support.
+
+ `-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 GCC, with `-msoft-float' in order for this
+ to work.
+
+`-mhard-quad-float'
+ Generate output containing quad-word (long double) floating point
+ instructions.
+
+`-msoft-quad-float'
+ Generate output containing library calls for quad-word (long
+ double) floating point instructions. The functions called are
+ those specified in the SPARC ABI. This is the default.
+
+ As of this writing, there are no sparc implementations that have
+ hardware support for the quad-word floating point instructions.
+ They all invoke a trap handler for one of these instructions, and
+ then the trap handler emulates the effect of the instruction.
+ Because of the trap handler overhead, this is much slower than
+ calling the ABI library routines. Thus the `-msoft-quad-float'
+ option is the default.
+
+`-mno-flat'
+`-mflat'
+ With `-mflat', the compiler does not generate save/restore
+ instructions and will use a "flat" or single register window
+ calling convention. This model uses %i7 as the frame pointer and
+ is compatible with the normal register window model. Code from
+ either may be intermixed. The local registers and the input
+ registers (0-5) are still treated as "call saved" registers and
+ will be saved on the stack as necessary.
+
+ With `-mno-flat' (the default), the compiler emits save/restore
+ instructions (except for leaf functions) and is the normal mode of
+ operation.
+
+`-mno-unaligned-doubles'
+`-munaligned-doubles'
+ Assume that doubles have 8 byte alignment. This is the default.
+
+ With `-munaligned-doubles', GCC assumes that doubles have 8 byte
+ alignment only if they are contained in another type, or if they
+ have an absolute address. Otherwise, it assumes they have 4 byte
+ alignment. Specifying this option avoids some rare compatibility
+ problems with code generated by other compilers. It is not the
+ default because it results in a performance loss, especially for
+ floating point code.
+
+`-mno-faster-structs'
+`-mfaster-structs'
+ With `-mfaster-structs', the compiler assumes that structures
+ should have 8 byte alignment. This enables the use of pairs of
+ `ldd' and `std' instructions for copies in structure assignment,
+ in place of twice as many `ld' and `st' pairs. However, the use
+ of this changed alignment directly violates the Sparc ABI. Thus,
+ it's intended only for use on targets where the developer
+ acknowledges that their resulting code will not be directly in
+ line with the rules of the ABI.
+
+`-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.
+
+ These options are deprecated and will be deleted in a future GCC
+ release. They have been replaced with `-mcpu=xxx'.
+
+`-mcypress'
+`-msupersparc'
+ These two options select the processor for which the code is
+ optimized.
+
+ With `-mcypress' (the default), the compiler optimizes code for the
+ Cypress CY7C602 chip, as used in the SparcStation/SparcServer 3xx
+ series. This is also appropriate for the older SparcStation 1, 2,
+ IPX etc.
+
+ With `-msupersparc' the compiler optimizes code for the SuperSparc
+ cpu, as used in the SparcStation 10, 1000 and 2000 series. This
+ flag also enables use of the full SPARC v8 instruction set.
+
+ These options are deprecated and will be deleted in a future GCC
+ release. They have been replaced with `-mcpu=xxx'.
+
+`-mcpu=CPU_TYPE'
+ Set the instruction set, register set, and instruction scheduling
+ parameters for machine type CPU_TYPE. Supported values for
+ CPU_TYPE are `v7', `cypress', `v8', `supersparc', `sparclite',
+ `hypersparc', `sparclite86x', `f930', `f934', `sparclet',
+ `tsc701', `v9', and `ultrasparc'.
+
+ Default instruction scheduling parameters are used for values that
+ select an architecture and not an implementation. These are `v7',
+ `v8', `sparclite', `sparclet', `v9'.
+
+ Here is a list of each supported architecture and their supported
+ implementations.
+
+ v7: cypress
+ v8: supersparc, hypersparc
+ sparclite: f930, f934, sparclite86x
+ sparclet: tsc701
+ v9: ultrasparc
+
+`-mtune=CPU_TYPE'
+ Set the instruction scheduling parameters for machine type
+ CPU_TYPE, but do not set the instruction set or register set that
+ the option `-mcpu=CPU_TYPE' would.
+
+ The same values for `-mcpu=CPU_TYPE' can be used for
+ `-mtune=CPU_TYPE', but the only useful values are those that
+ select a particular cpu implementation. Those are `cypress',
+ `supersparc', `hypersparc', `f930', `f934', `sparclite86x',
+ `tsc701', and `ultrasparc'.
+
+
+ These `-m' switches are supported in addition to the above on the
+SPARCLET processor.
+
+`-mlittle-endian'
+ Generate code for a processor running in little-endian mode.
+
+`-mlive-g0'
+ Treat register `%g0' as a normal register. GCC will continue to
+ clobber it as necessary but will not assume it always reads as 0.
+
+`-mbroken-saverestore'
+ Generate code that does not use non-trivial forms of the `save' and
+ `restore' instructions. Early versions of the SPARCLET processor
+ do not correctly handle `save' and `restore' instructions used with
+ arguments. They correctly handle them used without arguments. A
+ `save' instruction used without arguments increments the current
+ window pointer but does not allocate a new stack frame. It is
+ assumed that the window overflow trap handler will properly handle
+ this case as will interrupt handlers.
+
+ These `-m' switches are supported in addition to the above on SPARC
+V9 processors in 64-bit environments.
+
+`-mlittle-endian'
+ Generate code for a processor running in little-endian mode.
+
+`-m32'
+`-m64'
+ Generate code for a 32-bit or 64-bit environment. The 32-bit
+ environment sets int, long and pointer to 32 bits. The 64-bit
+ environment sets int to 32 bits and long and pointer to 64 bits.
+
+`-mcmodel=medlow'
+ Generate code for the Medium/Low code model: the program must be
+ linked in the low 32 bits of the address space. Pointers are 64
+ bits. Programs can be statically or dynamically linked.
+
+`-mcmodel=medmid'
+ Generate code for the Medium/Middle code model: the program must
+ be linked in the low 44 bits of the address space, the text
+ segment must be less than 2G bytes, and data segment must be
+ within 2G of the text segment. Pointers are 64 bits.
+
+`-mcmodel=medany'
+ Generate code for the Medium/Anywhere code model: the program may
+ be linked anywhere in the address space, the text segment must be
+ less than 2G bytes, and data segment must be within 2G of the text
+ segment. Pointers are 64 bits.
+
+`-mcmodel=embmedany'
+ Generate code for the Medium/Anywhere code model for embedded
+ systems: assume a 32-bit text and a 32-bit data segment, both
+ starting anywhere (determined at link time). Register %g4 points
+ to the base of the data segment. Pointers are still 64 bits.
+ Programs are statically linked, PIC is not supported.
+
+`-mstack-bias'
+`-mno-stack-bias'
+ With `-mstack-bias', GCC assumes that the stack pointer, and frame
+ pointer if present, are offset by -2047 which must be added back
+ when making stack frame references. Otherwise, assume no such
+ offset is present.
+
+\1f
+File: gcc.info, Node: Convex Options, Next: AMD29K Options, Prev: SPARC Options, Up: Submodel Options
+
+3.17.5 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.
+
+\1f
+File: gcc.info, Node: AMD29K Options, Next: ARM Options, Prev: Convex Options, Up: Submodel Options
+
+3.17.6 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.
+
+`-mndw'
+ 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 `-mndw'.
+
+`-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'
+`-mno-stack-check'
+ Insert (or do not insert) a call to `__msp_check' after each stack
+ adjustment. This is often used for kernel code.
+
+`-mstorem-bug'
+`-mno-storem-bug'
+ `-mstorem-bug' handles 29k processors which cannot handle the
+ separation of a mtsrim insn and a storem instruction (most 29000
+ chips to date, but not the 29050).
+
+`-mno-reuse-arg-regs'
+`-mreuse-arg-regs'
+ `-mno-reuse-arg-regs' tells the compiler to only use incoming
+ argument registers for copying out arguments. This helps detect
+ calling a function with fewer arguments than it was declared with.
+
+`-mno-impure-text'
+`-mimpure-text'
+ `-mimpure-text', used in addition to `-shared', tells the compiler
+ to not pass `-assert pure-text' to the linker when linking a
+ shared object.
+
+`-msoft-float'
+ Generate output containing library calls for floating point.
+ *Warning:* the requisite libraries are not part of GCC. 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.
+
+`-mno-multm'
+ Do not generate multm or multmu instructions. This is useful for
+ some embedded systems which do not have trap handlers for these
+ instructions.
+
+\1f
+File: gcc.info, Node: ARM Options, Next: MN10200 Options, Prev: AMD29K Options, Up: Submodel Options
+
+3.17.7 ARM Options
+------------------
+
+These `-m' options are defined for Advanced RISC Machines (ARM)
+architectures:
+
+`-mapcs-frame'
+ Generate a stack frame that is compliant with the ARM Procedure
+ Call Standard for all functions, even if this is not strictly
+ necessary for correct execution of the code. Specifying
+ `-fomit-frame-pointer' with this option will cause the stack
+ frames not to be generated for leaf functions. The default is
+ `-mno-apcs-frame'.
+
+`-mapcs'
+ This is a synonym for `-mapcs-frame'.
+
+`-mapcs-26'
+ Generate code for a processor running with a 26-bit program
+ counter, and conforming to the function calling standards for the
+ APCS 26-bit option. This option replaces the `-m2' and `-m3'
+ options of previous releases of the compiler.
+
+`-mapcs-32'
+ Generate code for a processor running with a 32-bit program
+ counter, and conforming to the function calling standards for the
+ APCS 32-bit option. This option replaces the `-m6' option of
+ previous releases of the compiler.
+
+`-mthumb-interwork'
+ Generate code which supports calling between the ARM and Thumb
+ instruction sets. Without this option the two instruction sets
+ cannot be reliably used inside one program. The default is
+ `-mno-thumb-interwork', since slightly larger code is generated
+ when `-mthumb-interwork' is specified.
+
+`-mno-sched-prolog'
+ Prevent the reordering of instructions in the function prolog, or
+ the merging of those instruction with the instructions in the
+ function's body. This means that all functions will start with a
+ recognizable set of instructions (or in fact one of a choice from
+ a small set of different function prologues), and this information
+ can be used to locate the start if functions inside an executable
+ piece of code. The default is `-msched-prolog'.
+
+`-mhard-float'
+ Generate output containing floating point instructions. This is
+ the default.
+
+`-msoft-float'
+ Generate output containing library calls for floating point.
+ *Warning:* the requisite libraries are not available for all ARM
+ targets. 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 GCC, with `-msoft-float' in order for this
+ to work.
+
+`-mlittle-endian'
+ Generate code for a processor running in little-endian mode. This
+ is the default for all standard configurations.
+
+`-mbig-endian'
+ Generate code for a processor running in big-endian mode; the
+ default is to compile code for a little-endian processor.
+
+`-mwords-little-endian'
+ This option only applies when generating code for big-endian
+ processors. Generate code for a little-endian word order but a
+ big-endian byte order. That is, a byte order of the form
+ `32107654'. Note: this option should only be used if you require
+ compatibility with code for big-endian ARM processors generated by
+ versions of the compiler prior to 2.8.
+
+`-malignment-traps'
+ Generate code that will not trap if the MMU has alignment traps
+ enabled. On ARM architectures prior to ARMv4, there were no
+ instructions to access half-word objects stored in memory.
+ However, when reading from memory a feature of the ARM
+ architecture allows a word load to be used, even if the address is
+ unaligned, and the processor core will rotate the data as it is
+ being loaded. This option tells the compiler that such misaligned
+ accesses will cause a MMU trap and that it should instead
+ synthesise the access as a series of byte accesses. The compiler
+ can still use word accesses to load half-word data if it knows
+ that the address is aligned to a word boundary.
+
+ This option is ignored when compiling for ARM architecture 4 or
+ later, since these processors have instructions to directly access
+ half-word objects in memory.
+
+`-mno-alignment-traps'
+ Generate code that assumes that the MMU will not trap unaligned
+ accesses. This produces better code when the target instruction
+ set does not have half-word memory operations (i.e.
+ implementations prior to ARMv4).
+
+ Note that you cannot use this option to access unaligned word
+ objects, since the processor will only fetch one 32-bit aligned
+ object from memory.
+
+ The default setting for most targets is `-mno-alignment-traps',
+ since this produces better code when there are no half-word memory
+ instructions available.
+
+`-mshort-load-bytes'
+`-mno-short-load-words'
+ These are deprecated aliases for `-malignment-traps'.
+
+`-mno-short-load-bytes'
+`-mshort-load-words'
+ This are deprecated aliases for `-mno-alignment-traps'.
+
+`-mbsd'
+ This option only applies to RISC iX. Emulate the native BSD-mode
+ compiler. This is the default if `-ansi' is not specified.
+
+`-mxopen'
+ This option only applies to RISC iX. Emulate the native
+ X/Open-mode compiler.
+
+`-mno-symrename'
+ This option only applies to RISC iX. Do not run the assembler
+ post-processor, `symrename', after code has been assembled.
+ Normally it is necessary to modify some of the standard symbols in
+ preparation for linking with the RISC iX C library; this option
+ suppresses this pass. The post-processor is never run when the
+ compiler is built for cross-compilation.
+
+`-mcpu=NAME'
+ This specifies the name of the target ARM processor. GCC uses
+ this name to determine what kind of instructions it can emit when
+ generating assembly code. Permissible names are: `arm2', `arm250',
+ `arm3', `arm6', `arm60', `arm600', `arm610', `arm620', `arm7',
+ `arm7m', `arm7d', `arm7dm', `arm7di', `arm7dmi', `arm70', `arm700',
+ `arm700i', `arm710', `arm710c', `arm7100', `arm7500', `arm7500fe',
+ `arm7tdmi', `arm8', `strongarm', `strongarm110', `strongarm1100',
+ `arm8', `arm810', `arm9', `arm9e', `arm920', `arm920t', `arm940t',
+ `arm9tdmi', `arm10tdmi', `arm1020t', `xscale'.
+
+`-mtune=NAME'
+ This option is very similar to the `-mcpu=' option, except that
+ instead of specifying the actual target processor type, and hence
+ restricting which instructions can be used, it specifies that GCC
+ should tune the performance of the code as if the target were of
+ the type specified in this option, but still choosing the
+ instructions that it will generate based on the cpu specified by a
+ `-mcpu=' option. For some ARM implementations better performance
+ can be obtained by using this option.
+
+`-march=NAME'
+ This specifies the name of the target ARM architecture. GCC uses
+ this name to determine what kind of instructions it can emit when
+ generating assembly code. This option can be used in conjunction
+ with or instead of the `-mcpu=' option. Permissible names are:
+ `armv2', `armv2a', `armv3', `armv3m', `armv4', `armv4t', `armv5',
+ `armv5t', `armv5te'.
+
+`-mfpe=NUMBER'
+`-mfp=NUMBER'
+ This specifies the version of the floating point emulation
+ available on the target. Permissible values are 2 and 3. `-mfp='
+ is a synonym for `-mfpe=', for compatibility with older versions
+ of GCC.
+
+`-mstructure-size-boundary=N'
+ The size of all structures and unions will be rounded up to a
+ multiple of the number of bits set by this option. Permissible
+ values are 8 and 32. The default value varies for different
+ toolchains. For the COFF targeted toolchain the default value is
+ 8. Specifying the larger number can produce faster, more
+ efficient code, but can also increase the size of the program.
+ The two values are potentially incompatible. Code compiled with
+ one value cannot necessarily expect to work with code or libraries
+ compiled with the other value, if they exchange information using
+ structures or unions.
+
+`-mabort-on-noreturn'
+ Generate a call to the function `abort' at the end of a `noreturn'
+ function. It will be executed if the function tries to return.
+
+`-mlong-calls'
+`-mno-long-calls'
+ Tells the compiler to perform function calls by first loading the
+ address of the function into a register and then performing a
+ subroutine call on this register. This switch is needed if the
+ target function will lie outside of the 64 megabyte addressing
+ range of the offset based version of subroutine call instruction.
+
+ Even if this switch is enabled, not all function calls will be
+ turned into long calls. The heuristic is that static functions,
+ functions which have the `short-call' attribute, functions that
+ are inside the scope of a `#pragma no_long_calls' directive and
+ functions whose definitions have already been compiled within the
+ current compilation unit, will not be turned into long calls. The
+ exception to this rule is that weak function definitions,
+ functions with the `long-call' attribute or the `section'
+ attribute, and functions that are within the scope of a `#pragma
+ long_calls' directive, will always be turned into long calls.
+
+ This feature is not enabled by default. Specifying
+ `-mno-long-calls' will restore the default behavior, as will
+ placing the function calls within the scope of a `#pragma
+ long_calls_off' directive. Note these switches have no effect on
+ how the compiler generates code to handle function calls via
+ function pointers.
+
+`-mnop-fun-dllimport'
+ Disable support for the `dllimport' attribute.
+
+`-msingle-pic-base'
+ Treat the register used for PIC addressing as read-only, rather
+ than loading it in the prologue for each function. The run-time
+ system is responsible for initializing this register with an
+ appropriate value before execution begins.
+
+`-mpic-register=REG'
+ Specify the register to be used for PIC addressing. The default
+ is R10 unless stack-checking is enabled, when R9 is used.
+
+`-mpoke-function-name'
+ Write the name of each function into the text section, directly
+ preceding the function prologue. The generated code is similar to
+ this:
+
+ t0
+ .ascii "arm_poke_function_name", 0
+ .align
+ t1
+ .word 0xff000000 + (t1 - t0)
+ arm_poke_function_name
+ mov ip, sp
+ stmfd sp!, {fp, ip, lr, pc}
+ sub fp, ip, #4
+
+ When performing a stack backtrace, code can inspect the value of
+ `pc' stored at `fp + 0'. If the trace function then looks at
+ location `pc - 12' and the top 8 bits are set, then we know that
+ there is a function name embedded immediately preceding this
+ location and has length `((pc[-3]) & 0xff000000)'.
+
+`-mthumb'
+ Generate code for the 16-bit Thumb instruction set. The default
+ is to use the 32-bit ARM instruction set.
+
+`-mtpcs-frame'
+ Generate a stack frame that is compliant with the Thumb Procedure
+ Call Standard for all non-leaf functions. (A leaf function is one
+ that does not call any other functions.) The default is
+ `-mno-tpcs-frame'.
+
+`-mtpcs-leaf-frame'
+ Generate a stack frame that is compliant with the Thumb Procedure
+ Call Standard for all leaf functions. (A leaf function is one
+ that does not call any other functions.) The default is
+ `-mno-apcs-leaf-frame'.
+
+`-mcallee-super-interworking'
+ Gives all externally visible functions in the file being compiled
+ an ARM instruction set header which switches to Thumb mode before
+ executing the rest of the function. This allows these functions
+ to be called from non-interworking code.
+
+`-mcaller-super-interworking'
+ Allows calls via function pointers (including virtual functions) to
+ execute correctly regardless of whether the target code has been
+ compiled for interworking or not. There is a small overhead in
+ the cost of executing a function pointer if this option is enabled.
+
+
+\1f
+File: gcc.info, Node: MN10200 Options, Next: MN10300 Options, Prev: ARM Options, Up: Submodel Options
+
+3.17.8 MN10200 Options
+----------------------
+
+These `-m' options are defined for Matsushita MN10200 architectures:
+`-mrelax'
+ Indicate to the linker that it should perform a relaxation
+ optimization pass to shorten branches, calls and absolute memory
+ addresses. This option only has an effect when used on the
+ command line for the final link step.
+
+ This option makes symbolic debugging impossible.
+
+\1f
+File: gcc.info, Node: MN10300 Options, Next: M32R/D Options, Prev: MN10200 Options, Up: Submodel Options
+
+3.17.9 MN10300 Options
+----------------------
+
+These `-m' options are defined for Matsushita MN10300 architectures:
+
+`-mmult-bug'
+ Generate code to avoid bugs in the multiply instructions for the
+ MN10300 processors. This is the default.
+
+`-mno-mult-bug'
+ Do not generate code to avoid bugs in the multiply instructions
+ for the MN10300 processors.
+
+`-mam33'
+ Generate code which uses features specific to the AM33 processor.
+
+`-mno-am33'
+ Do not generate code which uses features specific to the AM33
+ processor. This is the default.
+
+`-mno-crt0'
+ Do not link in the C run-time initialization object file.
+
+`-mrelax'
+ Indicate to the linker that it should perform a relaxation
+ optimization pass to shorten branches, calls and absolute memory
+ addresses. This option only has an effect when used on the
+ command line for the final link step.
+
+ This option makes symbolic debugging impossible.
+
+\1f
+File: gcc.info, Node: M32R/D Options, Next: M88K Options, Prev: MN10300 Options, Up: Submodel Options
+
+3.17.10 M32R/D Options
+----------------------
+
+These `-m' options are defined for Mitsubishi M32R/D architectures:
+
+`-m32rx'
+ Generate code for the M32R/X.
+
+`-m32r'
+ Generate code for the M32R. This is the default.
+
+`-mcode-model=small'
+ Assume all objects live in the lower 16MB of memory (so that their
+ addresses can be loaded with the `ld24' instruction), and assume
+ all subroutines are reachable with the `bl' instruction. This is
+ the default.
+
+ The addressability of a particular object can be set with the
+ `model' attribute.
+
+`-mcode-model=medium'
+ Assume objects may be anywhere in the 32-bit address space (the
+ compiler will generate `seth/add3' instructions to load their
+ addresses), and assume all subroutines are reachable with the `bl'
+ instruction.
+
+`-mcode-model=large'
+ Assume objects may be anywhere in the 32-bit address space (the
+ compiler will generate `seth/add3' instructions to load their
+ addresses), and assume subroutines may not be reachable with the
+ `bl' instruction (the compiler will generate the much slower
+ `seth/add3/jl' instruction sequence).
+
+`-msdata=none'
+ Disable use of the small data area. Variables will be put into
+ one of `.data', `bss', or `.rodata' (unless the `section'
+ attribute has been specified). This is the default.
+
+ The small data area consists of sections `.sdata' and `.sbss'.
+ Objects may be explicitly put in the small data area with the
+ `section' attribute using one of these sections.
+
+`-msdata=sdata'
+ Put small global and static data in the small data area, but do not
+ generate special code to reference them.
+
+`-msdata=use'
+ Put small global and static data in the small data area, and
+ generate special instructions to reference them.
+
+`-G NUM'
+ Put global and static objects less than or equal to NUM bytes into
+ the small data or bss sections instead of the normal data or bss
+ sections. The default value of NUM is 8. The `-msdata' option
+ must be set to one of `sdata' or `use' for this option to have any
+ effect.
+
+ All modules should be compiled with the same `-G NUM' value.
+ Compiling with different values of NUM may or may not work; if it
+ doesn't the linker will give an error message--incorrect code will
+ not be generated.
+
+
+\1f
+File: gcc.info, Node: M88K Options, Next: RS/6000 and PowerPC Options, Prev: M32R/D Options, Up: Submodel Options
+
+3.17.11 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'
+ Save space by reorganizing the stack frame. This option generates
+ code that does not agree with the 88open specifications, but uses
+ less memory.
+
+`-mno-optimize-arg-area'
+ Do not reorganize the stack frame to save space. This is the
+ default. The generated conforms to the specification, but uses
+ more memory.
+
+`-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 don't, generate code to guarantee sequential consistency of
+ volatile memory references. By default, consistency is guaranteed.
+
+ The order of memory references made by the MC88110 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. When consistency must be guaranteed,
+ GCC generates special instructions, as needed, to force execution
+ in the proper order.
+
+ The MC88100 processor does not reorder memory references and so
+ always provides sequential consistency. However, by default, GCC
+ generates the special instructions to guarantee consistency even
+ when you use `-m88100', so that the code may be run on an MC88110
+ processor. If you intend to run your code only on the MC88100
+ processor, you may use `-mno-serialize-volatile'.
+
+ 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 `-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.
+
+ 2. `-msvr4' makes the C preprocessor recognize `#pragma weak'
+ that is used on System V release 4.
+
+ 3. `-msvr4' makes GCC issue additional declaration directives
+ used in SVr4.
+
+ `-msvr4' is the default for the m88k-motorola-sysv4 and
+ m88k-dg-dgux m88k configurations. `-msvr3' is the default for all
+ other m88k configurations.
+
+`-mversion-03.00'
+ This option is obsolete, and is ignored.
+
+`-mno-check-zero-division'
+`-mcheck-zero-division'
+ Do, or don't, generate code to guarantee that integer division by
+ zero will be detected. By default, detection is guaranteed.
+
+ Some models of the MC88100 processor fail to trap upon integer
+ division by zero under certain conditions. By default, when
+ compiling code that might be run on such a processor, GCC
+ generates code that explicitly checks for zero-valued divisors and
+ traps with exception number 503 when one is detected. Use of
+ `-mno-check-zero-division' suppresses such checking for code
+ generated to run on an MC88100 processor.
+
+ GCC assumes that the MC88110 processor correctly detects all
+ instances of integer division by zero. When `-m88110' is
+ specified, no explicit checks for zero-valued divisors are
+ generated, and both `-mcheck-zero-division' and
+ `-mno-check-zero-division' are ignored.
+
+`-muse-div-instruction'
+ Use the div instruction for signed integer division on the MC88100
+ processor. By default, the div instruction is not used.
+
+ On the MC88100 processor the signed integer division instruction
+ div) traps to the operating system on a negative operand. The
+ operating system transparently completes the operation, but at a
+ large cost in execution time. By default, when compiling code
+ that might be run on an MC88100 processor, GCC emulates signed
+ integer division using the unsigned integer division instruction
+ divu), thereby avoiding the large penalty of a trap to the
+ operating system. Such emulation has its own, smaller, execution
+ cost in both time and space. To the extent that your code's
+ important signed integer division operations are performed on two
+ nonnegative operands, it may be desirable to use the div
+ instruction directly.
+
+ On the MC88110 processor the div instruction (also known as the
+ divs instruction) processes negative operands without trapping to
+ the operating system. When `-m88110' is specified,
+ `-muse-div-instruction' is ignored, and the div instruction is used
+ for signed integer division.
+
+ Note that the result of dividing `INT_MIN' by -1 is undefined. In
+ particular, the behavior of such a division with and without
+ `-muse-div-instruction' may differ.
+
+`-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 GCC 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, GCC issues no such warning.
+
+\1f
+File: gcc.info, Node: RS/6000 and PowerPC Options, Next: RT Options, Prev: M88K Options, Up: Submodel Options
+
+3.17.12 IBM RS/6000 and PowerPC Options
+---------------------------------------
+
+These `-m' options are defined for the IBM RS/6000 and PowerPC:
+`-mpower'
+`-mno-power'
+`-mpower2'
+`-mno-power2'
+`-mpowerpc'
+`-mno-powerpc'
+`-mpowerpc-gpopt'
+`-mno-powerpc-gpopt'
+`-mpowerpc-gfxopt'
+`-mno-powerpc-gfxopt'
+`-mpowerpc64'
+`-mno-powerpc64'
+ GCC supports two related instruction set architectures for the
+ RS/6000 and PowerPC. The "POWER" instruction set are those
+ instructions supported by the `rios' chip set used in the original
+ RS/6000 systems and the "PowerPC" instruction set is the
+ architecture of the Motorola MPC5xx, MPC6xx, MPC8xx
+ microprocessors, and the IBM 4xx microprocessors.
+
+ Neither architecture is a subset of the other. However there is a
+ large common subset of instructions supported by both. An MQ
+ register is included in processors supporting the POWER
+ architecture.
+
+ You use these options to specify which instructions are available
+ on the processor you are using. The default value of these
+ options is determined when configuring GCC. Specifying the
+ `-mcpu=CPU_TYPE' overrides the specification of these options. We
+ recommend you use the `-mcpu=CPU_TYPE' option rather than the
+ options listed above.
+
+ The `-mpower' option allows GCC to generate instructions that are
+ found only in the POWER architecture and to use the MQ register.
+ Specifying `-mpower2' implies `-power' and also allows GCC to
+ generate instructions that are present in the POWER2 architecture
+ but not the original POWER architecture.
+
+ The `-mpowerpc' option allows GCC to generate instructions that
+ are found only in the 32-bit subset of the PowerPC architecture.
+ Specifying `-mpowerpc-gpopt' implies `-mpowerpc' and also allows
+ GCC to use the optional PowerPC architecture instructions in the
+ General Purpose group, including floating-point square root.
+ Specifying `-mpowerpc-gfxopt' implies `-mpowerpc' and also allows
+ GCC to use the optional PowerPC architecture instructions in the
+ Graphics group, including floating-point select.
+
+ The `-mpowerpc64' option allows GCC to generate the additional
+ 64-bit instructions that are found in the full PowerPC64
+ architecture and to treat GPRs as 64-bit, doubleword quantities.
+ GCC defaults to `-mno-powerpc64'.
+
+ If you specify both `-mno-power' and `-mno-powerpc', GCC will use
+ only the instructions in the common subset of both architectures
+ plus some special AIX common-mode calls, and will not use the MQ
+ register. Specifying both `-mpower' and `-mpowerpc' permits GCC
+ to use any instruction from either architecture and to allow use
+ of the MQ register; specify this for the Motorola MPC601.
+
+`-mnew-mnemonics'
+`-mold-mnemonics'
+ Select which mnemonics to use in the generated assembler code.
+ With `-mnew-mnemonics', GCC uses the assembler mnemonics defined
+ for the PowerPC architecture. With `-mold-mnemonics' it uses the
+ assembler mnemonics defined for the POWER architecture.
+ Instructions defined in only one architecture have only one
+ mnemonic; GCC uses that mnemonic irrespective of which of these
+ options is specified.
+
+ GCC defaults to the mnemonics appropriate for the architecture in
+ use. Specifying `-mcpu=CPU_TYPE' sometimes overrides the value of
+ these option. Unless you are building a cross-compiler, you
+ should normally not specify either `-mnew-mnemonics' or
+ `-mold-mnemonics', but should instead accept the default.
+
+`-mcpu=CPU_TYPE'
+ Set architecture type, register usage, choice of mnemonics, and
+ instruction scheduling parameters for machine type CPU_TYPE.
+ Supported values for CPU_TYPE are `rios', `rios1', `rsc', `rios2',
+ `rs64a', `601', `602', `603', `603e', `604', `604e', `620', `630',
+ `740', `7400', `7450', `750', `power', `power2', `powerpc', `403',
+ `505', `801', `821', `823', and `860' and `common'.
+
+ `-mcpu=common' selects a completely generic processor. Code
+ generated under this option will run on any POWER or PowerPC
+ processor. GCC will use only the instructions in the common
+ subset of both architectures, and will not use the MQ register.
+ GCC assumes a generic processor model for scheduling purposes.
+
+ `-mcpu=power', `-mcpu=power2', `-mcpu=powerpc', and
+ `-mcpu=powerpc64' specify generic POWER, POWER2, pure 32-bit
+ PowerPC (i.e., not MPC601), and 64-bit PowerPC architecture machine
+ types, with an appropriate, generic processor model assumed for
+ scheduling purposes.
+
+ The other options specify a specific processor. Code generated
+ under those options will run best on that processor, and may not
+ run at all on others.
+
+ The `-mcpu' options automatically enable or disable other `-m'
+ options as follows:
+
+ `common'
+ `-mno-power', `-mno-powerc'
+
+ `power'
+ `power2'
+ `rios1'
+ `rios2'
+ `rsc'
+ `-mpower', `-mno-powerpc', `-mno-new-mnemonics'
+
+ `powerpc'
+ `rs64a'
+ `602'
+ `603'
+ `603e'
+ `604'
+ `620'
+ `630'
+ `740'
+ `7400'
+ `7450'
+ `750'
+ `505'
+ `-mno-power', `-mpowerpc', `-mnew-mnemonics'
+
+ `601'
+ `-mpower', `-mpowerpc', `-mnew-mnemonics'
+
+ `403'
+ `821'
+ `860'
+ `-mno-power', `-mpowerpc', `-mnew-mnemonics', `-msoft-float'
+
+`-mtune=CPU_TYPE'
+ Set the instruction scheduling parameters for machine type
+ CPU_TYPE, but do not set the architecture type, register usage, or
+ choice of mnemonics, as `-mcpu=CPU_TYPE' would. The same values
+ for CPU_TYPE are used for `-mtune' as for `-mcpu'. If both are
+ specified, the code generated will use the architecture,
+ registers, and mnemonics set by `-mcpu', but the scheduling
+ parameters set by `-mtune'.
+
+`-maltivec'
+`-mno-altivec'
+ These switches enable or disable the use of built-in functions that
+ allow access to the AltiVec instruction set. You may also need to
+ set `-mabi=altivec' to adjust the current ABI with AltiVec ABI
+ enhancements.
+
+`-mfull-toc'
+`-mno-fp-in-toc'
+`-mno-sum-in-toc'
+`-mminimal-toc'
+ Modify generation of the TOC (Table Of Contents), which is created
+ for every executable file. The `-mfull-toc' option is selected by
+ default. In that case, GCC will allocate at least one TOC entry
+ for each unique non-automatic variable reference in your program.
+ GCC will also place floating-point constants in the TOC. However,
+ only 16,384 entries are available in the TOC.
+
+ If you receive a linker error message that saying you have
+ overflowed the available TOC space, you can reduce the amount of
+ TOC space used with the `-mno-fp-in-toc' and `-mno-sum-in-toc'
+ options. `-mno-fp-in-toc' prevents GCC from putting floating-point
+ constants in the TOC and `-mno-sum-in-toc' forces GCC to generate
+ code to calculate the sum of an address and a constant at run-time
+ instead of putting that sum into the TOC. You may specify one or
+ both of these options. Each causes GCC to produce very slightly
+ slower and larger code at the expense of conserving TOC space.
+
+ If you still run out of space in the TOC even when you specify
+ both of these options, specify `-mminimal-toc' instead. This
+ option causes GCC to make only one TOC entry for every file. When
+ you specify this option, GCC will produce code that is slower and
+ larger but which uses extremely little TOC space. You may wish to
+ use this option only on files that contain less frequently
+ executed code.
+
+`-maix64'
+`-maix32'
+ Enable 64-bit AIX ABI and calling convention: 64-bit pointers,
+ 64-bit `long' type, and the infrastructure needed to support them.
+ Specifying `-maix64' implies `-mpowerpc64' and `-mpowerpc', while
+ `-maix32' disables the 64-bit ABI and implies `-mno-powerpc64'.
+ GCC defaults to `-maix32'.
+
+`-mxl-call'
+`-mno-xl-call'
+ On AIX, pass floating-point arguments to prototyped functions
+ beyond the register save area (RSA) on the stack in addition to
+ argument FPRs. The AIX calling convention was extended but not
+ initially documented to handle an obscure K&R C case of calling a
+ function that takes the address of its arguments with fewer
+ arguments than declared. AIX XL compilers access floating point
+ arguments which do not fit in the RSA from the stack when a
+ subroutine is compiled without optimization. Because always
+ storing floating-point arguments on the stack is inefficient and
+ rarely needed, this option is not enabled by default and only is
+ necessary when calling subroutines compiled by AIX XL compilers
+ without optimization.
+
+`-mpe'
+ Support "IBM RS/6000 SP" "Parallel Environment" (PE). Link an
+ application written to use message passing with special startup
+ code to enable the application to run. The system must have PE
+ installed in the standard location (`/usr/lpp/ppe.poe/'), or the
+ `specs' file must be overridden with the `-specs=' option to
+ specify the appropriate directory location. The Parallel
+ Environment does not support threads, so the `-mpe' option and the
+ `-pthread' option are incompatible.
+
+`-msoft-float'
+`-mhard-float'
+ Generate code that does not use (uses) the floating-point register
+ set. Software floating point emulation is provided if you use the
+ `-msoft-float' option, and pass the option to GCC when linking.
+
+`-mmultiple'
+`-mno-multiple'
+ Generate code that uses (does not use) the load multiple word
+ instructions and the store multiple word instructions. These
+ instructions are generated by default on POWER systems, and not
+ generated on PowerPC systems. Do not use `-mmultiple' on little
+ endian PowerPC systems, since those instructions do not work when
+ the processor is in little endian mode. The exceptions are PPC740
+ and PPC750 which permit the instructions usage in little endian
+ mode.
+
+`-mstring'
+`-mno-string'
+ Generate code that uses (does not use) the load string instructions
+ and the store string word instructions to save multiple registers
+ and do small block moves. These instructions are generated by
+ default on POWER systems, and not generated on PowerPC systems.
+ Do not use `-mstring' on little endian PowerPC systems, since those
+ instructions do not work when the processor is in little endian
+ mode. The exceptions are PPC740 and PPC750 which permit the
+ instructions usage in little endian mode.
+
+`-mupdate'
+`-mno-update'
+ Generate code that uses (does not use) the load or store
+ instructions that update the base register to the address of the
+ calculated memory location. These instructions are generated by
+ default. If you use `-mno-update', there is a small window
+ between the time that the stack pointer is updated and the address
+ of the previous frame is stored, which means code that walks the
+ stack frame across interrupts or signals may get corrupted data.
+
+`-mfused-madd'
+`-mno-fused-madd'
+ Generate code that uses (does not use) the floating point multiply
+ and accumulate instructions. These instructions are generated by
+ default if hardware floating is used.
+
+`-mno-bit-align'
+`-mbit-align'
+ On System V.4 and embedded PowerPC systems do not (do) force
+ structures and unions that contain bit-fields to be aligned to the
+ base type of the bit-field.
+
+ For example, by default a structure containing nothing but 8
+ `unsigned' bit-fields of length 1 would be aligned to a 4 byte
+ boundary and have a size of 4 bytes. By using `-mno-bit-align',
+ the structure would be aligned to a 1 byte boundary and be one
+ byte in size.
+
+`-mno-strict-align'
+`-mstrict-align'
+ On System V.4 and embedded PowerPC systems do not (do) assume that
+ unaligned memory references will be handled by the system.
+
+`-mrelocatable'
+`-mno-relocatable'
+ On embedded PowerPC systems generate code that allows (does not
+ allow) the program to be relocated to a different address at
+ runtime. If you use `-mrelocatable' on any module, all objects
+ linked together must be compiled with `-mrelocatable' or
+ `-mrelocatable-lib'.
+
+`-mrelocatable-lib'
+`-mno-relocatable-lib'
+ On embedded PowerPC systems generate code that allows (does not
+ allow) the program to be relocated to a different address at
+ runtime. Modules compiled with `-mrelocatable-lib' can be linked
+ with either modules compiled without `-mrelocatable' and
+ `-mrelocatable-lib' or with modules compiled with the
+ `-mrelocatable' options.
+
+`-mno-toc'
+`-mtoc'
+ On System V.4 and embedded PowerPC systems do not (do) assume that
+ register 2 contains a pointer to a global area pointing to the
+ addresses used in the program.
+
+`-mlittle'
+`-mlittle-endian'
+ On System V.4 and embedded PowerPC systems compile code for the
+ processor in little endian mode. The `-mlittle-endian' option is
+ the same as `-mlittle'.
+
+`-mbig'
+`-mbig-endian'
+ On System V.4 and embedded PowerPC systems compile code for the
+ processor in big endian mode. The `-mbig-endian' option is the
+ same as `-mbig'.
+
+`-mcall-sysv'
+ On System V.4 and embedded PowerPC systems compile code using
+ calling conventions that adheres to the March 1995 draft of the
+ System V Application Binary Interface, PowerPC processor
+ supplement. This is the default unless you configured GCC using
+ `powerpc-*-eabiaix'.
+
+`-mcall-sysv-eabi'
+ Specify both `-mcall-sysv' and `-meabi' options.
+
+`-mcall-sysv-noeabi'
+ Specify both `-mcall-sysv' and `-mno-eabi' options.
+
+`-mcall-aix'
+ On System V.4 and embedded PowerPC systems compile code using
+ calling conventions that are similar to those used on AIX. This
+ is the default if you configured GCC using `powerpc-*-eabiaix'.
+
+`-mcall-solaris'
+ On System V.4 and embedded PowerPC systems compile code for the
+ Solaris operating system.
+
+`-mcall-linux'
+ On System V.4 and embedded PowerPC systems compile code for the
+ Linux-based GNU system.
+
+`-mcall-gnu'
+ On System V.4 and embedded PowerPC systems compile code for the
+ Hurd-based GNU system.
+
+`-mcall-netbsd'
+ On System V.4 and embedded PowerPC systems compile code for the
+ NetBSD operating system.
+
+`-maix-struct-return'
+ Return all structures in memory (as specified by the AIX ABI).
+
+`-msvr4-struct-return'
+ Return structures smaller than 8 bytes in registers (as specified
+ by the SVR4 ABI).
+
+`-mabi=altivec'
+ Extend the current ABI with AltiVec ABI extensions. This does not
+ change the default ABI, instead it adds the AltiVec ABI extensions
+ to the current ABI.
+
+`-mabi=no-altivec'
+ Disable AltiVec ABI extensions for the current ABI.
+
+`-mprototype'
+`-mno-prototype'
+ On System V.4 and embedded PowerPC systems assume that all calls to
+ variable argument functions are properly prototyped. Otherwise,
+ the compiler must insert an instruction before every non
+ prototyped call to set or clear bit 6 of the condition code
+ register (CR) to indicate whether floating point values were
+ passed in the floating point registers in case the function takes
+ a variable arguments. With `-mprototype', only calls to
+ prototyped variable argument functions will set or clear the bit.
+
+`-msim'
+ On embedded PowerPC systems, assume that the startup module is
+ called `sim-crt0.o' and that the standard C libraries are
+ `libsim.a' and `libc.a'. This is the default for
+ `powerpc-*-eabisim'. configurations.
+
+`-mmvme'
+ On embedded PowerPC systems, assume that the startup module is
+ called `crt0.o' and the standard C libraries are `libmvme.a' and
+ `libc.a'.
+
+`-mads'
+ On embedded PowerPC systems, assume that the startup module is
+ called `crt0.o' and the standard C libraries are `libads.a' and
+ `libc.a'.
+
+`-myellowknife'
+ On embedded PowerPC systems, assume that the startup module is
+ called `crt0.o' and the standard C libraries are `libyk.a' and
+ `libc.a'.
+
+`-mvxworks'
+ On System V.4 and embedded PowerPC systems, specify that you are
+ compiling for a VxWorks system.
+
+`-memb'
+ On embedded PowerPC systems, set the PPC_EMB bit in the ELF flags
+ header to indicate that `eabi' extended relocations are used.
+
+`-meabi'
+`-mno-eabi'
+ On System V.4 and embedded PowerPC systems do (do not) adhere to
+ the Embedded Applications Binary Interface (eabi) which is a set of
+ modifications to the System V.4 specifications. Selecting `-meabi'
+ means that the stack is aligned to an 8 byte boundary, a function
+ `__eabi' is called to from `main' to set up the eabi environment,
+ and the `-msdata' option can use both `r2' and `r13' to point to
+ two separate small data areas. Selecting `-mno-eabi' means that
+ the stack is aligned to a 16 byte boundary, do not call an
+ initialization function from `main', and the `-msdata' option will
+ only use `r13' to point to a single small data area. The `-meabi'
+ option is on by default if you configured GCC using one of the
+ `powerpc*-*-eabi*' options.
+
+`-msdata=eabi'
+ On System V.4 and embedded PowerPC systems, put small initialized
+ `const' global and static data in the `.sdata2' section, which is
+ pointed to by register `r2'. Put small initialized non-`const'
+ global and static data in the `.sdata' section, which is pointed
+ to by register `r13'. Put small uninitialized global and static
+ data in the `.sbss' section, which is adjacent to the `.sdata'
+ section. The `-msdata=eabi' option is incompatible with the
+ `-mrelocatable' option. The `-msdata=eabi' option also sets the
+ `-memb' option.
+
+`-msdata=sysv'
+ On System V.4 and embedded PowerPC systems, put small global and
+ static data in the `.sdata' section, which is pointed to by
+ register `r13'. Put small uninitialized global and static data in
+ the `.sbss' section, which is adjacent to the `.sdata' section.
+ The `-msdata=sysv' option is incompatible with the `-mrelocatable'
+ option.
+
+`-msdata=default'
+`-msdata'
+ On System V.4 and embedded PowerPC systems, if `-meabi' is used,
+ compile code the same as `-msdata=eabi', otherwise compile code the
+ same as `-msdata=sysv'.
+
+`-msdata-data'
+ On System V.4 and embedded PowerPC systems, put small global and
+ static data in the `.sdata' section. Put small uninitialized
+ global and static data in the `.sbss' section. Do not use
+ register `r13' to address small data however. This is the default
+ behavior unless other `-msdata' options are used.
+
+`-msdata=none'
+`-mno-sdata'
+ On embedded PowerPC systems, put all initialized global and static
+ data in the `.data' section, and all uninitialized data in the
+ `.bss' section.
+
+`-G NUM'
+ On embedded PowerPC systems, put global and static items less than
+ or equal to NUM bytes into the small data or bss sections instead
+ of the normal data or bss section. By default, NUM is 8. The `-G
+ NUM' switch is also passed to the linker. All modules should be
+ compiled with the same `-G NUM' value.
+
+`-mregnames'
+`-mno-regnames'
+ On System V.4 and embedded PowerPC systems do (do not) emit
+ register names in the assembly language output using symbolic
+ forms.
+
+`-pthread'
+ Adds support for multithreading with the "pthreads" library. This
+ option sets flags for both the preprocessor and linker.
+
+
+\1f
+File: gcc.info, Node: RT Options, Next: MIPS Options, Prev: RS/6000 and PowerPC Options, Up: Submodel Options
+
+3.17.13 IBM RT Options
+----------------------
+
+These `-m' options are defined for the IBM RT PC:
+
+`-min-line-mul'
+ Use an in-line code sequence for integer multiplies. This is the
+ default.
+
+`-mcall-lib-mul'
+ Call `lmul$$' for integer multiples.
+
+`-mfull-fp-blocks'
+ Generate full-size floating point data blocks, including the
+ minimum amount of scratch space recommended by IBM. This is the
+ default.
+
+`-mminimum-fp-blocks'
+ Do not include extra scratch space in floating point data blocks.
+ This results in smaller code, but slower execution, since scratch
+ space must be allocated dynamically.
+
+`-mfp-arg-in-fpregs'
+ Use a calling sequence incompatible with the IBM calling
+ convention in which floating point arguments are passed in
+ floating point registers. Note that `varargs.h' and `stdarg.h'
+ will not work with floating point operands if this option is
+ specified.
+
+`-mfp-arg-in-gregs'
+ Use the normal calling convention for floating point arguments.
+ This is the default.
+
+`-mhc-struct-return'
+ Return structures of more than one word in memory, rather than in a
+ register. This provides compatibility with the MetaWare HighC (hc)
+ compiler. Use the option `-fpcc-struct-return' for compatibility
+ with the Portable C Compiler (pcc).
+
+`-mnohc-struct-return'
+ Return some structures of more than one word in registers, when
+ convenient. This is the default. For compatibility with the
+ IBM-supplied compilers, use the option `-fpcc-struct-return' or the
+ option `-mhc-struct-return'.
+
+\1f
+File: gcc.info, Node: MIPS Options, Next: i386 and x86-64 Options, Prev: RT Options, Up: Submodel Options
+
+3.17.14 MIPS Options
+--------------------
+
+These `-m' options are defined for the MIPS family of computers:
+
+`-march=CPU-TYPE'
+ Assume the defaults for the machine type CPU-TYPE when generating
+ instructions. The choices for CPU-TYPE are `r2000', `r3000',
+ `r3900', `r4000', `r4100', `r4300', `r4400', `r4600', `r4650',
+ `r5000', `r6000', `r8000', and `orion'. Additionally, the
+ `r2000', `r3000', `r4000', `r5000', and `r6000' can be abbreviated
+ as `r2k' (or `r2K'), `r3k', etc.
+
+`-mtune=CPU-TYPE'
+ Assume the defaults for the machine type CPU-TYPE when scheduling
+ instructions. The choices for CPU-TYPE are `r2000', `r3000',
+ `r3900', `r4000', `r4100', `r4300', `r4400', `r4600', `r4650',
+ `r5000', `r6000', `r8000', and `orion'. Additionally, the
+ `r2000', `r3000', `r4000', `r5000', and `r6000' can be abbreviated
+ as `r2k' (or `r2K'), `r3k', etc. While picking a specific
+ CPU-TYPE will schedule things appropriately for that particular
+ chip, the compiler will not generate any code that does not meet
+ level 1 of the MIPS ISA (instruction set architecture) without a
+ `-mipsX' or `-mabi' switch being used.
+
+`-mcpu=CPU-TYPE'
+ This is identical to specifying both `-march' and `-mtune'.
+
+`-mips1'
+ Issue instructions from level 1 of the MIPS ISA. This is the
+ default. `r3000' is the default CPU-TYPE at this ISA level.
+
+`-mips2'
+ Issue instructions from level 2 of the MIPS ISA (branch likely,
+ square root instructions). `r6000' is the default CPU-TYPE at this
+ ISA level.
+
+`-mips3'
+ Issue instructions from level 3 of the MIPS ISA (64-bit
+ instructions). `r4000' is the default CPU-TYPE at this ISA level.
+
+`-mips4'
+ Issue instructions from level 4 of the MIPS ISA (conditional move,
+ prefetch, enhanced FPU instructions). `r8000' is the default
+ CPU-TYPE at this ISA level.
+
+`-mfp32'
+ Assume that 32 32-bit floating point registers are available.
+ This is the default.
+
+`-mfp64'
+ Assume that 32 64-bit floating point registers are available.
+ This is the default when the `-mips3' option is used.
+
+`-mfused-madd'
+`-mno-fused-madd'
+ Generate code that uses (does not use) the floating point multiply
+ and accumulate instructions, when they are available. These
+ instructions are generated by default if they are available, but
+ this may be undesirable if the extra precision causes problems or
+ on certain chips in the mode where denormals are rounded to zero
+ where denormals generated by multiply and accumulate instructions
+ cause exceptions anyway.
+
+`-mgp32'
+ Assume that 32 32-bit general purpose registers are available.
+ This is the default.
+
+`-mgp64'
+ Assume that 32 64-bit general purpose registers are available.
+ This is the default when the `-mips3' option is used.
+
+`-mint64'
+ Force int and long types to be 64 bits wide. See `-mlong32' for an
+ explanation of the default, and the width of pointers.
+
+`-mlong64'
+ Force long types to be 64 bits wide. See `-mlong32' for an
+ explanation of the default, and the width of pointers.
+
+`-mlong32'
+ Force long, int, and pointer types to be 32 bits wide.
+
+ If none of `-mlong32', `-mlong64', or `-mint64' are set, the size
+ of ints, longs, and pointers depends on the ABI and ISA chosen.
+ For `-mabi=32', and `-mabi=n32', ints and longs are 32 bits wide.
+ For `-mabi=64', ints are 32 bits, and longs are 64 bits wide. For
+ `-mabi=eabi' and either `-mips1' or `-mips2', ints and longs are
+ 32 bits wide. For `-mabi=eabi' and higher ISAs, ints are 32 bits,
+ and longs are 64 bits wide. The width of pointer types is the
+ smaller of the width of longs or the width of general purpose
+ registers (which in turn depends on the ISA).
+
+`-mabi=32'
+`-mabi=o64'
+`-mabi=n32'
+`-mabi=64'
+`-mabi=eabi'
+ Generate code for the indicated ABI. The default instruction
+ level is `-mips1' for `32', `-mips3' for `n32', and `-mips4'
+ otherwise. Conversely, with `-mips1' or `-mips2', the default ABI
+ is `32'; otherwise, the default ABI is `64'.
+
+`-mmips-as'
+ Generate code for the MIPS assembler, and invoke `mips-tfile' to
+ add normal debug information. This is the default for all
+ platforms except for the OSF/1 reference platform, using the
+ OSF/rose object format. If the either of the `-gstabs' or
+ `-gstabs+' switches are used, the `mips-tfile' program will
+ encapsulate the stabs within MIPS ECOFF.
+
+`-mgas'
+ Generate code for the GNU assembler. This is the default on the
+ OSF/1 reference platform, using the OSF/rose object format. Also,
+ this is the default if the configure option `--with-gnu-as' is
+ used.
+
+`-msplit-addresses'
+`-mno-split-addresses'
+ Generate code to load the high and low parts of address constants
+ separately. This allows GCC to optimize away redundant loads of
+ the high order bits of addresses. This optimization requires GNU
+ as and GNU ld. This optimization is enabled by default for some
+ embedded targets where GNU as and GNU ld are standard.
+
+`-mrnames'
+`-mno-rnames'
+ The `-mrnames' switch says to output code using the MIPS software
+ names for the registers, instead of the hardware names (ie, A0
+ instead of $4). The only known assembler that supports this option
+ is the Algorithmics assembler.
+
+`-mgpopt'
+`-mno-gpopt'
+ The `-mgpopt' switch says to write all of the data declarations
+ before the instructions in the text section, this allows the MIPS
+ assembler to generate one word memory references instead of using
+ two words for short global or static data items. This is on by
+ default if optimization is selected.
+
+`-mstats'
+`-mno-stats'
+ For each non-inline function processed, the `-mstats' switch
+ causes the compiler to emit one line to the standard error file to
+ print statistics about the program (number of registers saved,
+ stack size, etc.).
+
+`-mmemcpy'
+`-mno-memcpy'
+ The `-mmemcpy' switch makes all block moves call the appropriate
+ string function (`memcpy' or `bcopy') instead of possibly
+ generating inline code.
+
+`-mmips-tfile'
+`-mno-mips-tfile'
+ The `-mno-mips-tfile' switch causes the compiler not postprocess
+ the object file with the `mips-tfile' program, after the MIPS
+ assembler has generated it to add debug support. If `mips-tfile'
+ is not run, then no local variables will be available to the
+ debugger. In addition, `stage2' and `stage3' objects will have
+ the temporary file names passed to the assembler embedded in the
+ object file, which means the objects will not compare the same.
+ The `-mno-mips-tfile' switch should only be used when there are
+ bugs in the `mips-tfile' program that prevents compilation.
+
+`-msoft-float'
+ Generate output containing library calls for floating point.
+ *Warning:* the requisite libraries are not part of GCC. 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.
+
+`-mhard-float'
+ Generate output containing floating point instructions. This is
+ the default if you use the unmodified sources.
+
+`-mabicalls'
+`-mno-abicalls'
+ Emit (or do not emit) the pseudo operations `.abicalls',
+ `.cpload', and `.cprestore' that some System V.4 ports use for
+ position independent code.
+
+`-mlong-calls'
+`-mno-long-calls'
+ Do all calls with the `JALR' instruction, which requires loading
+ up a function's address into a register before the call. You need
+ to use this switch, if you call outside of the current 512
+ megabyte segment to functions that are not through pointers.
+
+`-mhalf-pic'
+`-mno-half-pic'
+ Put pointers to extern references into the data section and load
+ them up, rather than put the references in the text section.
+
+`-membedded-pic'
+`-mno-embedded-pic'
+ Generate PIC code suitable for some embedded systems. All calls
+ are made using PC relative address, and all data is addressed
+ using the $gp register. No more than 65536 bytes of global data
+ may be used. This requires GNU as and GNU ld which do most of the
+ work. This currently only works on targets which use ECOFF; it
+ does not work with ELF.
+
+`-membedded-data'
+`-mno-embedded-data'
+ Allocate variables to the read-only data section first if
+ possible, then next in the small data section if possible,
+ otherwise in data. This gives slightly slower code than the
+ default, but reduces the amount of RAM required when executing,
+ and thus may be preferred for some embedded systems.
+
+`-muninit-const-in-rodata'
+`-mno-uninit-const-in-rodata'
+ When used together with `-membedded-data', it will always store
+ uninitialized const variables in the read-only data section.
+
+`-msingle-float'
+`-mdouble-float'
+ The `-msingle-float' switch tells gcc to assume that the floating
+ point coprocessor only supports single precision operations, as on
+ the `r4650' chip. The `-mdouble-float' switch permits gcc to use
+ double precision operations. This is the default.
+
+`-mmad'
+`-mno-mad'
+ Permit use of the `mad', `madu' and `mul' instructions, as on the
+ `r4650' chip.
+
+`-m4650'
+ Turns on `-msingle-float', `-mmad', and, at least for now,
+ `-mcpu=r4650'.
+
+`-mips16'
+`-mno-mips16'
+ Enable 16-bit instructions.
+
+`-mentry'
+ Use the entry and exit pseudo ops. This option can only be used
+ with `-mips16'.
+
+`-EL'
+ Compile code for the processor in little endian mode. The
+ requisite libraries are assumed to exist.
+
+`-EB'
+ Compile code for the processor in big endian mode. The requisite
+ libraries are assumed to exist.
+
+`-G NUM'
+ Put global and static items less than or equal to NUM bytes into
+ the small data or bss sections instead of the normal data or bss
+ section. This allows the assembler to emit one word memory
+ reference instructions based on the global pointer (GP or $28),
+ instead of the normal two words used. By default, NUM is 8 when
+ the MIPS assembler is used, and 0 when the GNU assembler is used.
+ The `-G NUM' switch is also passed to the assembler and linker.
+ All modules should be compiled with the same `-G NUM' value.
+
+`-nocpp'
+ Tell the MIPS assembler to not run its preprocessor over user
+ assembler files (with a `.s' suffix) when assembling them.
+
+`-mfix7000'
+ Pass an option to gas which will cause nops to be inserted if the
+ read of the destination register of an mfhi or mflo instruction
+ occurs in the following two instructions.
+
+`-no-crt0'
+ Do not include the default crt0.
+
+`-mflush-func=FUNC'
+`-mno-flush-func'
+ Specifies the function to call to flush the I and D caches, or to
+ not call any such function. If called, the function must take the
+ same arguments as the common `_flush_func()', that is, the address
+ of the memory range for which the cache is being flushed, the size
+ of the memory range, and the number 3 (to flush both caches). The
+ default depends on the target gcc was configured for, but commonly
+ is either `_flush_func' or `__cpu_flush'.
+
+ 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.
+