<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-2015 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.3 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>
</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-102"></a><a name="index-language-dialect-options-103"></a><a name="index-options_002c-dialect-104"></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-105"></a>
<a name="index-ISO-support-106"></a>
<dl><dt><code>-ansi</code><dd><a name="index-ansi-107"></a>In C mode, this is equivalent to <samp><span class="option">-std=c90</span></samp>. In C++ mode, it is
equivalent to <samp><span class="option">-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">-Wpedantic</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 are normally 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-108"></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>’. When a base standard is specified, the
compiler accepts all programs following that standard plus those
using GNU extensions that do not contradict it. For example,
<samp><span class="option">-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, when a GNU dialect of a standard is
specified, all features supported by the compiler are enabled, even when
those features change the meaning of the base standard. As a result, some
strict-conforming programs may be rejected. The particular standard
is used by <samp><span class="option">-Wpedantic</span></samp> to identify which features are GNU
extensions given that version of the standard. For example
<samp><span class="option">-std=gnu90 -Wpedantic</span></samp> warns about C++ style ‘<samp><span class="samp">//</span></samp>’
comments, while <samp><span class="option">-std=gnu99 -Wpedantic</span></samp> does 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. This standard is substantially completely supported, modulo
bugs and floating-point issues
(mainly but not entirely relating to optional C99 features from
Annexes F and G). See
<a href="http://gcc.gnu.org/c99status.html">http://gcc.gnu.org/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">c11</span></samp>’<dt>‘<samp><span class="samp">c1x</span></samp>’<dt>‘<samp><span class="samp">iso9899:2011</span></samp>’<dd>ISO C11, the 2011 revision of the ISO C standard. This standard is
substantially completely supported, modulo bugs, floating-point issues
(mainly but not entirely relating to optional C11 features from
Annexes F and G) and the optional Annexes K (Bounds-checking
interfaces) and L (Analyzability). The name ‘<samp><span class="samp">c1x</span></samp>’ is 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).
<br><dt>‘<samp><span class="samp">gnu99</span></samp>’<dt>‘<samp><span class="samp">gnu9x</span></samp>’<dd>GNU dialect of ISO C99. The name ‘<samp><span class="samp">gnu9x</span></samp>’ is deprecated.
<br><dt>‘<samp><span class="samp">gnu11</span></samp>’<dt>‘<samp><span class="samp">gnu1x</span></samp>’<dd>GNU dialect of ISO C11. This is the default for C code.
The name ‘<samp><span class="samp">gnu1x</span></samp>’ is deprecated.
<br><dt>‘<samp><span class="samp">c++98</span></samp>’<dt>‘<samp><span class="samp">c++03</span></samp>’<dd>The 1998 ISO C++ standard plus the 2003 technical corrigendum and some
additional defect reports. Same as <samp><span class="option">-ansi</span></samp> for C++ code.
<br><dt>‘<samp><span class="samp">gnu++98</span></samp>’<dt>‘<samp><span class="samp">gnu++03</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++11</span></samp>’<dt>‘<samp><span class="samp">c++0x</span></samp>’<dd>The 2011 ISO C++ standard plus amendments.
The name ‘<samp><span class="samp">c++0x</span></samp>’ is deprecated.
<br><dt>‘<samp><span class="samp">gnu++11</span></samp>’<dt>‘<samp><span class="samp">gnu++0x</span></samp>’<dd>GNU dialect of <samp><span class="option">-std=c++11</span></samp>.
The name ‘<samp><span class="samp">gnu++0x</span></samp>’ is deprecated.
<br><dt>‘<samp><span class="samp">c++14</span></samp>’<dt>‘<samp><span class="samp">c++1y</span></samp>’<dd>The 2014 ISO C++ standard plus amendments.
The name ‘<samp><span class="samp">c++1y</span></samp>’ is deprecated.
<br><dt>‘<samp><span class="samp">gnu++14</span></samp>’<dt>‘<samp><span class="samp">gnu++1y</span></samp>’<dd>GNU dialect of <samp><span class="option">-std=c++14</span></samp>.
The name ‘<samp><span class="samp">gnu++1y</span></samp>’ is deprecated.
<br><dt>‘<samp><span class="samp">c++1z</span></samp>’<dd>The next revision of the ISO C++ standard, tentatively planned for
2017. Support is highly experimental, and will almost certainly
change in incompatible ways in future releases.
<br><dt>‘<samp><span class="samp">gnu++1z</span></samp>’<dd>GNU dialect of <samp><span class="option">-std=c++1z</span></samp>. Support is highly experimental,
and will almost certainly change in incompatible ways in future
releases.
</dl>
<br><dt><code>-fgnu89-inline</code><dd><a name="index-fgnu89_002dinline-109"></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>.
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 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-110"></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>-fallow-parameterless-variadic-functions</code><dd><a name="index-fallow_002dparameterless_002dvariadic_002dfunctions-111"></a>Accept variadic functions without named parameters.
<p>Although it is possible to define such a function, this is not very
useful as it is not possible to read the arguments. This is only
supported for C as this construct is allowed by C++.
<br><dt><code>-fno-asm</code><dd><a name="index-fno_002dasm-112"></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-113"></a><a name="index-built_002din-functions-114"></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 which 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-115"></a><a name="index-hosted-environment-116"></a>
Assert that compilation targets 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-117"></a><a name="index-hosted-environment-118"></a>
Assert that compilation targets 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>-fopenacc</code><dd><a name="index-fopenacc-119"></a><a name="index-OpenACC-accelerator-programming-120"></a>Enable handling of OpenACC directives <code>#pragma acc</code> in C/C++ and
<code>!$acc</code> in Fortran. When <samp><span class="option">-fopenacc</span></samp> is specified, the
compiler generates accelerated code according to the OpenACC Application
Programming Interface v2.0 <a href="http://www.openacc.org/">http://www.openacc.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>.
<p>Note that this is an experimental feature, incomplete, and subject to
change in future versions of GCC. See
<a href="https://gcc.gnu.org/wiki/OpenACC">https://gcc.gnu.org/wiki/OpenACC</a><!-- /@w --> for more information.
<br><dt><code>-fopenmp</code><dd><a name="index-fopenmp-121"></a><a name="index-OpenMP-parallel-122"></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 v4.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>. <samp><span class="option">-fopenmp</span></samp> implies
<samp><span class="option">-fopenmp-simd</span></samp>.
<br><dt><code>-fopenmp-simd</code><dd><a name="index-fopenmp_002dsimd-123"></a><a name="index-OpenMP-SIMD-124"></a><a name="index-SIMD-125"></a>Enable handling of OpenMP's SIMD directives with <code>#pragma omp</code>
in C/C++ and <code>!$omp</code> in Fortran. Other OpenMP directives
are ignored.
<br><dt><code>-fcilkplus</code><dd><a name="index-fcilkplus-126"></a><a name="index-Enable-Cilk-Plus-127"></a>Enable the usage of Cilk Plus language extension features for C/C++.
When the option <samp><span class="option">-fcilkplus</span></samp> is specified, enable the usage of
the Cilk Plus Language extension features for C/C++. The present
implementation follows ABI version 1.2. This is an experimental
feature that is only partially complete, and whose interface may
change in future versions of GCC as the official specification
changes. Currently, all features but <code>_Cilk_for</code> have been
implemented.
<br><dt><code>-fgnu-tm</code><dd><a name="index-fgnu_002dtm-128"></a>When the option <samp><span class="option">-fgnu-tm</span></samp> is specified, the compiler
generates code for the Linux variant of Intel's current Transactional
Memory ABI specification document (Revision 1.1, May 6 2009). This is
an experimental feature whose interface may change in future versions
of GCC, as the official specification changes. Please note that not
all architectures are supported for this feature.
<p>For more information on GCC's support for transactional memory,
See <a href="../libitm/Enabling-libitm.html#Enabling-libitm">The GNU Transactional Memory Library</a>.
<p>Note that the transactional memory feature is not supported with
non-call exceptions (<samp><span class="option">-fnon-call-exceptions</span></samp>).
<br><dt><code>-fms-extensions</code><dd><a name="index-fms_002dextensions-129"></a>Accept some non-standard constructs used in Microsoft header files.
<p>In C++ code, this allows member names in structures to be similar
to previous types declarations.
<pre class="smallexample"> typedef int UOW;
struct ABC {
UOW UOW;
};
</pre>
<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.
<p>Note that this option is off for all targets but x86
targets using ms-abi.
<br><dt><code>-fplan9-extensions</code><dd><a name="index-fplan9_002dextensions-130"></a>Accept some non-standard constructs used in Plan 9 code.
<p>This enables <samp><span class="option">-fms-extensions</span></samp>, permits passing pointers to
structures with anonymous fields to functions that expect pointers to
elements of the type of the field, and permits referring to anonymous
fields declared using a typedef. See <a href="Unnamed-Fields.html#Unnamed-Fields">Unnamed struct/union fields within structs/unions</a>, for details. This is only
supported for C, not C++.
<br><dt><code>-trigraphs</code><dd><a name="index-trigraphs-131"></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>.
<p><a name="index-traditional-C-language-132"></a><a name="index-C-language_002c-traditional-133"></a><br><dt><code>-traditional</code><dt><code>-traditional-cpp</code><dd><a name="index-traditional_002dcpp-134"></a><a name="index-traditional-135"></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-136"></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-137"></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-138"></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-139"></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-140"></a><a name="index-funsigned_002dbitfields-141"></a><a name="index-fno_002dsigned_002dbitfields-142"></a><a name="index-fno_002dunsigned_002dbitfields-143"></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>