| <html lang="en"> |
| <head> |
| <title>C Dialect Options - Using the GNU Compiler Collection (GCC)</title> |
| <meta http-equiv="Content-Type" content="text/html"> |
| <meta name="description" content="Using the GNU Compiler Collection (GCC)"> |
| <meta name="generator" content="makeinfo 4.13"> |
| <link title="Top" rel="start" href="index.html#Top"> |
| <link rel="up" href="Invoking-GCC.html#Invoking-GCC" title="Invoking GCC"> |
| <link rel="prev" href="Invoking-G_002b_002b.html#Invoking-G_002b_002b" title="Invoking G++"> |
| <link rel="next" href="C_002b_002b-Dialect-Options.html#C_002b_002b-Dialect-Options" title="C++ Dialect Options"> |
| <link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage"> |
| <!-- |
| Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
| 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, |
| 2008 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.2 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being ``Funding Free Software'', the Front-Cover |
| Texts being (a) (see below), and with the Back-Cover Texts being (b) |
| (see below). A copy of the license is included in the section entitled |
| ``GNU Free Documentation License''. |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| You have freedom to copy and modify this GNU Manual, like GNU |
| software. Copies published by the Free Software Foundation raise |
| funds for GNU development.--> |
| <meta http-equiv="Content-Style-Type" content="text/css"> |
| <style type="text/css"><!-- |
| pre.display { font-family:inherit } |
| pre.format { font-family:inherit } |
| pre.smalldisplay { font-family:inherit; font-size:smaller } |
| pre.smallformat { font-family:inherit; font-size:smaller } |
| pre.smallexample { font-size:smaller } |
| pre.smalllisp { font-size:smaller } |
| span.sc { font-variant:small-caps } |
| span.roman { font-family:serif; font-weight:normal; } |
| span.sansserif { font-family:sans-serif; font-weight:normal; } |
| --></style> |
| <link rel="stylesheet" type="text/css" href="../cs.css"> |
| </head> |
| <body> |
| <div class="node"> |
| <a name="C-Dialect-Options"></a> |
| <p> |
| Next: <a rel="next" accesskey="n" href="C_002b_002b-Dialect-Options.html#C_002b_002b-Dialect-Options">C++ Dialect Options</a>, |
| Previous: <a rel="previous" accesskey="p" href="Invoking-G_002b_002b.html#Invoking-G_002b_002b">Invoking G++</a>, |
| Up: <a rel="up" accesskey="u" href="Invoking-GCC.html#Invoking-GCC">Invoking GCC</a> |
| <hr> |
| </div> |
| |
| <h3 class="section">3.4 Options Controlling C Dialect</h3> |
| |
| <p><a name="index-dialect-options-93"></a><a name="index-language-dialect-options-94"></a><a name="index-options_002c-dialect-95"></a> |
| The following options control the dialect of C (or languages derived |
| from C, such as C++, Objective-C and Objective-C++) that the compiler |
| accepts: |
| |
| |
| <a name="index-ANSI-support-96"></a> |
| <a name="index-ISO-support-97"></a> |
| <dl><dt><code>-ansi</code><dd><a name="index-ansi-98"></a>In C mode, this is equivalent to ‘<samp><span class="samp">-std=c90</span></samp>’. In C++ mode, it is |
| equivalent to ‘<samp><span class="samp">-std=c++98</span></samp>’. |
| |
| <p>This turns off certain features of GCC that are incompatible with ISO |
| C90 (when compiling C code), or of standard C++ (when compiling C++ code), |
| such as the <code>asm</code> and <code>typeof</code> keywords, and |
| predefined macros such as <code>unix</code> and <code>vax</code> 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 ‘<samp><span class="samp">//</span></samp>’ comments as well as |
| the <code>inline</code> keyword. |
| |
| <p>The alternate keywords <code>__asm__</code>, <code>__extension__</code>, |
| <code>__inline__</code> and <code>__typeof__</code> continue to work despite |
| <samp><span class="option">-ansi</span></samp>. 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 <samp><span class="option">-ansi</span></samp>. Alternate predefined macros |
| such as <code>__unix__</code> and <code>__vax__</code> are also available, with or |
| without <samp><span class="option">-ansi</span></samp>. |
| |
| <p>The <samp><span class="option">-ansi</span></samp> option does not cause non-ISO programs to be |
| rejected gratuitously. For that, <samp><span class="option">-pedantic</span></samp> is required in |
| addition to <samp><span class="option">-ansi</span></samp>. See <a href="Warning-Options.html#Warning-Options">Warning Options</a>. |
| |
| <p>The macro <code>__STRICT_ANSI__</code> is predefined when the <samp><span class="option">-ansi</span></samp> |
| 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. |
| |
| <p>Functions that would normally be built in but do not have semantics |
| defined by ISO C (such as <code>alloca</code> and <code>ffs</code>) are not built-in |
| functions when <samp><span class="option">-ansi</span></samp> is used. See <a href="Other-Builtins.html#Other-Builtins">Other built-in functions provided by GCC</a>, for details of the functions |
| affected. |
| |
| <br><dt><code>-std=</code><dd><a name="index-std-99"></a>Determine the language standard. See <a href="Standards.html#Standards">Language Standards Supported by GCC</a>, for details of these standard versions. This option |
| is currently only supported when compiling C or C++. |
| |
| <p>The compiler can accept several base standards, such as ‘<samp><span class="samp">c90</span></samp>’ or |
| ‘<samp><span class="samp">c++98</span></samp>’, and GNU dialects of those standards, such as |
| ‘<samp><span class="samp">gnu90</span></samp>’ or ‘<samp><span class="samp">gnu++98</span></samp>’. By specifying a base standard, the |
| compiler will accept all programs following that standard and those |
| using GNU extensions that do not contradict it. For example, |
| ‘<samp><span class="samp">-std=c90</span></samp>’ turns off certain features of GCC that are |
| incompatible with ISO C90, such as the <code>asm</code> and <code>typeof</code> |
| keywords, but not other GNU extensions that do not have a meaning in |
| ISO C90, such as omitting the middle term of a <code>?:</code> |
| expression. On the other hand, by specifying a GNU dialect of a |
| standard, all features the compiler support are enabled, even when |
| those features change the meaning of the base standard and some |
| strict-conforming programs may be rejected. The particular standard |
| is used by <samp><span class="option">-pedantic</span></samp> to identify which features are GNU |
| extensions given that version of the standard. For example |
| ‘<samp><span class="samp">-std=gnu90 -pedantic</span></samp>’ would warn about C++ style ‘<samp><span class="samp">//</span></samp>’ |
| comments, while ‘<samp><span class="samp">-std=gnu99 -pedantic</span></samp>’ would not. |
| |
| <p>A value for this option must be provided; possible values are |
| |
| <dl> |
| <dt>‘<samp><span class="samp">c90</span></samp>’<dt>‘<samp><span class="samp">c89</span></samp>’<dt>‘<samp><span class="samp">iso9899:1990</span></samp>’<dd>Support all ISO C90 programs (certain GNU extensions that conflict |
| with ISO C90 are disabled). Same as <samp><span class="option">-ansi</span></samp> for C code. |
| |
| <br><dt>‘<samp><span class="samp">iso9899:199409</span></samp>’<dd>ISO C90 as modified in amendment 1. |
| |
| <br><dt>‘<samp><span class="samp">c99</span></samp>’<dt>‘<samp><span class="samp">c9x</span></samp>’<dt>‘<samp><span class="samp">iso9899:1999</span></samp>’<dt>‘<samp><span class="samp">iso9899:199x</span></samp>’<dd>ISO C99. Note that this standard is not yet fully supported; see |
| <a href="http://gcc.gnu.org/gcc-4.5/c99status.html">http://gcc.gnu.org/gcc-4.5/c99status.html</a><!-- /@w --> for more information. The |
| names ‘<samp><span class="samp">c9x</span></samp>’ and ‘<samp><span class="samp">iso9899:199x</span></samp>’ are deprecated. |
| |
| <br><dt>‘<samp><span class="samp">gnu90</span></samp>’<dt>‘<samp><span class="samp">gnu89</span></samp>’<dd>GNU dialect of ISO C90 (including some C99 features). This |
| is the default for C code. |
| |
| <br><dt>‘<samp><span class="samp">gnu99</span></samp>’<dt>‘<samp><span class="samp">gnu9x</span></samp>’<dd>GNU dialect of ISO C99. When ISO C99 is fully implemented in GCC, |
| this will become the default. The name ‘<samp><span class="samp">gnu9x</span></samp>’ is deprecated. |
| |
| <br><dt>‘<samp><span class="samp">c++98</span></samp>’<dd>The 1998 ISO C++ standard plus amendments. Same as <samp><span class="option">-ansi</span></samp> for |
| C++ code. |
| |
| <br><dt>‘<samp><span class="samp">gnu++98</span></samp>’<dd>GNU dialect of <samp><span class="option">-std=c++98</span></samp>. This is the default for |
| C++ code. |
| |
| <br><dt>‘<samp><span class="samp">c++0x</span></samp>’<dd>The working draft of the upcoming ISO C++0x standard. This option |
| enables experimental features that are likely to be included in |
| C++0x. The working draft is constantly changing, and any feature that is |
| enabled by this flag may be removed from future versions of GCC if it is |
| not part of the C++0x standard. |
| |
| <br><dt>‘<samp><span class="samp">gnu++0x</span></samp>’<dd>GNU dialect of <samp><span class="option">-std=c++0x</span></samp>. This option enables |
| experimental features that may be removed in future versions of GCC. |
| </dl> |
| |
| <br><dt><code>-fgnu89-inline</code><dd><a name="index-fgnu89_002dinline-100"></a>The option <samp><span class="option">-fgnu89-inline</span></samp> tells GCC to use the traditional |
| GNU semantics for <code>inline</code> functions when in C99 mode. |
| See <a href="Inline.html#Inline">An Inline Function is As Fast As a Macro</a>. This option |
| is accepted and ignored by GCC versions 4.1.3 up to but not including |
| 4.3. In GCC versions 4.3 and later it changes the behavior of GCC in |
| C99 mode. Using this option is roughly equivalent to adding the |
| <code>gnu_inline</code> function attribute to all inline functions |
| (see <a href="Function-Attributes.html#Function-Attributes">Function Attributes</a>). |
| |
| <p>The option <samp><span class="option">-fno-gnu89-inline</span></samp> explicitly tells GCC to use the |
| C99 semantics for <code>inline</code> when in C99 or gnu99 mode (i.e., it |
| specifies the default behavior). This option was first supported in |
| GCC 4.3. This option is not supported in <samp><span class="option">-std=c90</span></samp> or |
| <samp><span class="option">-std=gnu90</span></samp> mode. |
| |
| <p>The preprocessor macros <code>__GNUC_GNU_INLINE__</code> and |
| <code>__GNUC_STDC_INLINE__</code> may be used to check which semantics are |
| in effect for <code>inline</code> functions. See <a href="../cpp/Common-Predefined-Macros.html#Common-Predefined-Macros">Common Predefined Macros</a>. |
| |
| <br><dt><code>-aux-info </code><var>filename</var><dd><a name="index-aux_002dinfo-101"></a>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. |
| |
| <p>Besides declarations, the file indicates, in comments, the origin of |
| each declaration (source file and line), whether the declaration was |
| implicit, prototyped or unprototyped (‘<samp><span class="samp">I</span></samp>’, ‘<samp><span class="samp">N</span></samp>’ for new or |
| ‘<samp><span class="samp">O</span></samp>’ for old, respectively, in the first character after the line |
| number and the colon), and whether it came from a declaration or a |
| definition (‘<samp><span class="samp">C</span></samp>’ or ‘<samp><span class="samp">F</span></samp>’, 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. |
| |
| <br><dt><code>-fno-asm</code><dd><a name="index-fno_002dasm-102"></a>Do not recognize <code>asm</code>, <code>inline</code> or <code>typeof</code> as a |
| keyword, so that code can use these words as identifiers. You can use |
| the keywords <code>__asm__</code>, <code>__inline__</code> and <code>__typeof__</code> |
| instead. <samp><span class="option">-ansi</span></samp> implies <samp><span class="option">-fno-asm</span></samp>. |
| |
| <p>In C++, this switch only affects the <code>typeof</code> keyword, since |
| <code>asm</code> and <code>inline</code> are standard keywords. You may want to |
| use the <samp><span class="option">-fno-gnu-keywords</span></samp> flag instead, which has the same |
| effect. In C99 mode (<samp><span class="option">-std=c99</span></samp> or <samp><span class="option">-std=gnu99</span></samp>), this |
| switch only affects the <code>asm</code> and <code>typeof</code> keywords, since |
| <code>inline</code> is a standard keyword in ISO C99. |
| |
| <br><dt><code>-fno-builtin</code><dt><code>-fno-builtin-</code><var>function</var><dd><a name="index-fno_002dbuiltin-103"></a><a name="index-built_002din-functions-104"></a>Don't recognize built-in functions that do not begin with |
| ‘<samp><span class="samp">__builtin_</span></samp>’ as prefix. See <a href="Other-Builtins.html#Other-Builtins">Other built-in functions provided by GCC</a>, for details of the functions affected, |
| including those which are not built-in functions when <samp><span class="option">-ansi</span></samp> or |
| <samp><span class="option">-std</span></samp> options for strict ISO C conformance are used because they |
| do not have an ISO standard meaning. |
| |
| <p>GCC normally generates special code to handle certain built-in functions |
| more efficiently; for instance, calls to <code>alloca</code> may become single |
| instructions that adjust the stack directly, and calls to <code>memcpy</code> |
| 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 addition, |
| when a function is recognized as a built-in function, GCC may use |
| information about that function to warn about problems with calls to |
| that function, or to generate more efficient code, even if the |
| resulting code still contains calls to that function. For example, |
| warnings are given with <samp><span class="option">-Wformat</span></samp> for bad calls to |
| <code>printf</code>, when <code>printf</code> is built in, and <code>strlen</code> is |
| known not to modify global memory. |
| |
| <p>With the <samp><span class="option">-fno-builtin-</span><var>function</var></samp> option |
| only the built-in function <var>function</var> is |
| disabled. <var>function</var> must not begin with ‘<samp><span class="samp">__builtin_</span></samp>’. If a |
| function is named that is not built-in in this version of GCC, this |
| option is ignored. There is no corresponding |
| <samp><span class="option">-fbuiltin-</span><var>function</var></samp> option; if you wish to enable |
| built-in functions selectively when using <samp><span class="option">-fno-builtin</span></samp> or |
| <samp><span class="option">-ffreestanding</span></samp>, you may define macros such as: |
| |
| <pre class="smallexample"> #define abs(n) __builtin_abs ((n)) |
| #define strcpy(d, s) __builtin_strcpy ((d), (s)) |
| </pre> |
| <br><dt><code>-fhosted</code><dd><a name="index-fhosted-105"></a><a name="index-hosted-environment-106"></a> |
| Assert that compilation takes place in a hosted environment. This implies |
| <samp><span class="option">-fbuiltin</span></samp>. A hosted environment is one in which the |
| entire standard library is available, and in which <code>main</code> has a return |
| type of <code>int</code>. Examples are nearly everything except a kernel. |
| This is equivalent to <samp><span class="option">-fno-freestanding</span></samp>. |
| |
| <br><dt><code>-ffreestanding</code><dd><a name="index-ffreestanding-107"></a><a name="index-hosted-environment-108"></a> |
| Assert that compilation takes place in a freestanding environment. This |
| implies <samp><span class="option">-fno-builtin</span></samp>. A freestanding environment |
| is one in which the standard library may not exist, and program startup may |
| not necessarily be at <code>main</code>. The most obvious example is an OS kernel. |
| This is equivalent to <samp><span class="option">-fno-hosted</span></samp>. |
| |
| <p>See <a href="Standards.html#Standards">Language Standards Supported by GCC</a>, for details of |
| freestanding and hosted environments. |
| |
| <br><dt><code>-fopenmp</code><dd><a name="index-fopenmp-109"></a><a name="index-openmp-parallel-110"></a>Enable handling of OpenMP directives <code>#pragma omp</code> in C/C++ and |
| <code>!$omp</code> in Fortran. When <samp><span class="option">-fopenmp</span></samp> is specified, the |
| compiler generates parallel code according to the OpenMP Application |
| Program Interface v3.0 <a href="http://www.openmp.org/">http://www.openmp.org/</a><!-- /@w -->. This option |
| implies <samp><span class="option">-pthread</span></samp>, and thus is only supported on targets that |
| have support for <samp><span class="option">-pthread</span></samp>. |
| |
| <br><dt><code>-fms-extensions</code><dd><a name="index-fms_002dextensions-111"></a>Accept some non-standard constructs used in Microsoft header files. |
| |
| <p>Some cases of unnamed fields in structures and unions are only |
| accepted with this option. See <a href="Unnamed-Fields.html#Unnamed-Fields">Unnamed struct/union fields within structs/unions</a>, for details. |
| |
| <br><dt><code>-trigraphs</code><dd><a name="index-trigraphs-112"></a>Support ISO C trigraphs. The <samp><span class="option">-ansi</span></samp> option (and <samp><span class="option">-std</span></samp> |
| options for strict ISO C conformance) implies <samp><span class="option">-trigraphs</span></samp>. |
| |
| <br><dt><code>-no-integrated-cpp</code><dd><a name="index-no_002dintegrated_002dcpp-113"></a>Performs a compilation in two passes: preprocessing and compiling. This |
| option allows a user supplied "cc1", "cc1plus", or "cc1obj" via the |
| <samp><span class="option">-B</span></samp> option. The user supplied compilation step can then add in |
| an additional preprocessing step after normal preprocessing but before |
| compiling. The default is to use the integrated cpp (internal cpp) |
| |
| <p>The semantics of this option will change if "cc1", "cc1plus", and |
| "cc1obj" are merged. |
| |
| <p><a name="index-traditional-C-language-114"></a><a name="index-C-language_002c-traditional-115"></a><br><dt><code>-traditional</code><dt><code>-traditional-cpp</code><dd><a name="index-traditional_002dcpp-116"></a><a name="index-traditional-117"></a>Formerly, these options caused GCC to attempt to emulate a pre-standard |
| C compiler. They are now only supported with the <samp><span class="option">-E</span></samp> switch. |
| The preprocessor continues to support a pre-standard mode. See the GNU |
| CPP manual for details. |
| |
| <br><dt><code>-fcond-mismatch</code><dd><a name="index-fcond_002dmismatch-118"></a>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++. |
| |
| <br><dt><code>-flax-vector-conversions</code><dd><a name="index-flax_002dvector_002dconversions-119"></a>Allow implicit conversions between vectors with differing numbers of |
| elements and/or incompatible element types. This option should not be |
| used for new code. |
| |
| <br><dt><code>-funsigned-char</code><dd><a name="index-funsigned_002dchar-120"></a>Let the type <code>char</code> be unsigned, like <code>unsigned char</code>. |
| |
| <p>Each kind of machine has a default for what <code>char</code> should |
| be. It is either like <code>unsigned char</code> by default or like |
| <code>signed char</code> by default. |
| |
| <p>Ideally, a portable program should always use <code>signed char</code> or |
| <code>unsigned char</code> when it depends on the signedness of an object. |
| But many programs have been written to use plain <code>char</code> 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. |
| |
| <p>The type <code>char</code> is always a distinct type from each of |
| <code>signed char</code> or <code>unsigned char</code>, even though its behavior |
| is always just like one of those two. |
| |
| <br><dt><code>-fsigned-char</code><dd><a name="index-fsigned_002dchar-121"></a>Let the type <code>char</code> be signed, like <code>signed char</code>. |
| |
| <p>Note that this is equivalent to <samp><span class="option">-fno-unsigned-char</span></samp>, which is |
| the negative form of <samp><span class="option">-funsigned-char</span></samp>. Likewise, the option |
| <samp><span class="option">-fno-signed-char</span></samp> is equivalent to <samp><span class="option">-funsigned-char</span></samp>. |
| |
| <br><dt><code>-fsigned-bitfields</code><dt><code>-funsigned-bitfields</code><dt><code>-fno-signed-bitfields</code><dt><code>-fno-unsigned-bitfields</code><dd><a name="index-fsigned_002dbitfields-122"></a><a name="index-funsigned_002dbitfields-123"></a><a name="index-fno_002dsigned_002dbitfields-124"></a><a name="index-fno_002dunsigned_002dbitfields-125"></a>These options control whether a bit-field is signed or unsigned, when the |
| declaration does not use either <code>signed</code> or <code>unsigned</code>. By |
| default, such a bit-field is signed, because this is consistent: the |
| basic integer types such as <code>int</code> are signed types. |
| </dl> |
| |
| </body></html> |
| |
