The following options control
the dialect of C (or languages derived from C, such as C++ and Objective
C) that the compiler accepts.
-ansi
Support all ANSI standard
C programs.
This turns off certain features
of GNU C that are incompatible with ANSI C, such as the asm,
inline
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 ANSI trigraph
feature, disallows the dollar sign symbol ($)
as part of identifiers, and disables recognition of C++ style comments
with double forward-slash (//).
The alternate keywords, __asm__,
__extension__,
__inline__
and __typeof__,
continue to work despite -ansi.
You would not want to use them in an ANSI 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 -ans
ffb
i
option does not cause non-ANSI programs to be rejected gratuitously. For
that, -pedantic
is required in addition to -ansi.
See also Options to
request or suppress warnings. 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 ANSI standard
doesnt call for; this is to avoid interfering with any programs that might
use these names for other things. The functions, alloca,
abort,
exit,
and _exit,
are not built-in functions when -ansi
is used.
-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, as it also disables the other, C++-specific, extension keywords
such as headof.
-fno-builtin
Dont recognize built-in
functions that do not begin with two leading underscores. Currently, the
functions affected
ffb
include abort,
abs,
alloca,
cos,
exit,
fabs,
ffs,
labs,
memcmp,
memcpy,
sin,
sqrt,
strcmp,
strcpy,
and strlen.
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.
-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.
-trigraphs
Support ANSI C trigraphs.
You dont want to know about this brain-damage.
The -ansi
option implies -trigraphs.
-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 ANSI
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 ANSI C: automatic variables not declared volatile
ffb
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.
In C++ programs, assignment
to this
is permitted with
-traditional.
(The -fthis-is-variable
option also has this effect.)
You may wish to use -fno-builtin
as well as -traditional
if your program uses names that are normally GNU C builtin functions for
other purposes of its own.
You cannot use -traditional
if you include any header files that rely on ANSI C features. Some vendors
are starting to ship systems with ANSI C header files and you cannot use
-traditional
on such systems to compile files that include any system headers.
The -traditional
option also enables the -traditional-cpp
option which is described in the following discussion.
-traditional-cpp
Attempt to support some
aspects of traditional C preprocessors. Specifically:
Comments convert to nothing
at all rather than to a space. This allows traditional token concatenation.
In a preprocessing directive,
the pound/number symbol (#)
must appear as the first character of a line.
Macro arguments are recognized
within string constants in a macro definition (an
ffb
d their values are stringified,
though without additional quote marks, when they appear in such a context).
The preprocessor always considers a string constant to end at a newline.
The predefined macro, __STDC__,
is not defined when you use -traditional,
but __GNUC__
is (since the GNU extensions which __GNUC__
indicates are not affected by -traditional).
If you need to write header files that work differently depending on whether
-traditional
is in use, by testing both of these predefined macros you can distinguish
four situations: GNU C, traditional GNU C, other ANSI C compilers, and
other old C compilers. The predefined macro, __STDC_VERSION__,
is also not defined when you use -traditional.
For more discussion of these and other predefined macros, see the Standard
predefined macros in The
C Preprocessor in GNUPro Compiler Tools.
The preprocessor considers a
string constant to end at a newline (unless the newline is escaped with
a backslash). (Without -traditional,
string constants can contain the newline backslash character.)
-fcond-mismatch
Allow conditional expressions
with mismatched types in the second and third arguments.
The value of such an expression
is void.
-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
ffb
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 for which they were written. 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 dialect options.
-fsigned-char
Let the type char
be signed,
like signed
char.
Note: 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.
You may wish to use -fno-builtin
as well as -traditional
if your program uses names that are normally GNU C builtin functions for
other purposes of its own.
You cannot use -traditional
if you include any header files that rely on ANSI C features. Some vendors
are starting to ship systems with ANSI C header files and you cannot use
-traditional
on such systems to compile files that include any system headers.
-fsigned-bitfields
-funsigned-bitfields
-fno-signed-bitfields
-fno-unsigned-bitfields
These options control whether
a bitfield is signed or unsigned, when the declaration does not use either
signed
or unsigned.
By default, such a bitfield is signed, because this is consistent: the
basic integer types such as int
are signed types. However, when -traditional
is used, bitfields are all unsigned no matter what.
-fwritable-strings
Store string constants in
the writable data segment and dont uniquize them. This is for compatibility
with old programs which assume they can write into string constants. The
-traditional
option 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
ANSI or GNU C conventions (the default).