You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
27 KiB
HTML
390 lines
27 KiB
HTML
4 years ago
|
<html lang="en">
|
||
|
|
<head>
|
||
|
|
<title>Common Predefined Macros - The C Preprocessor</title>
|
||
|
|
<meta http-equiv="Content-Type" content="text/html">
|
||
|
|
<meta name="description" content="The C Preprocessor">
|
||
|
|
<meta name="generator" content="makeinfo 4.13">
|
||
|
|
<link title="Top" rel="start" href="index.html#Top">
|
||
|
|
<link rel="up" href="Predefined-Macros.html#Predefined-Macros" title="Predefined Macros">
|
||
|
|
<link rel="prev" href="Standard-Predefined-Macros.html#Standard-Predefined-Macros" title="Standard Predefined Macros">
|
||
|
|
<link rel="next" href="System_002dspecific-Predefined-Macros.html#System_002dspecific-Predefined-Macros" title="System-specific Predefined Macros">
|
||
|
|
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
|
||
|
|
<!--
|
||
|
|
Copyright (C) 1987-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. A copy of
|
||
|
|
the license is included in the
|
||
|
|
section entitled ``GNU Free Documentation License''.
|
||
|
|
|
||
|
|
This manual contains no Invariant Sections. The Front-Cover Texts are
|
||
|
|
(a) (see below), and the Back-Cover Texts are (b) (see below).
|
||
|
|
|
||
|
|
(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="Common-Predefined-Macros"></a>
|
||
|
|
<p>
|
||
|
|
Next: <a rel="next" accesskey="n" href="System_002dspecific-Predefined-Macros.html#System_002dspecific-Predefined-Macros">System-specific Predefined Macros</a>,
|
||
|
|
Previous: <a rel="previous" accesskey="p" href="Standard-Predefined-Macros.html#Standard-Predefined-Macros">Standard Predefined Macros</a>,
|
||
|
|
Up: <a rel="up" accesskey="u" href="Predefined-Macros.html#Predefined-Macros">Predefined Macros</a>
|
||
|
|
<hr>
|
||
|
|
</div>
|
||
|
|
|
||
|
|
<h4 class="subsection">3.7.2 Common Predefined Macros</h4>
|
||
|
|
|
||
|
|
<p><a name="index-common-predefined-macros-61"></a>
|
||
|
|
The common predefined macros are GNU C extensions. They are available
|
||
|
|
with the same meanings regardless of the machine or operating system on
|
||
|
|
which you are using GNU C or GNU Fortran. Their names all start with
|
||
|
|
double underscores.
|
||
|
|
|
||
|
|
<dl>
|
||
|
|
<dt><code>__COUNTER__</code><dd>This macro expands to sequential integral values starting from 0. In
|
||
|
|
conjunction with the <code>##</code> operator, this provides a convenient means to
|
||
|
|
generate unique identifiers. Care must be taken to ensure that
|
||
|
|
<code>__COUNTER__</code> is not expanded prior to inclusion of precompiled headers
|
||
|
|
which use it. Otherwise, the precompiled headers will not be used.
|
||
|
|
|
||
|
|
<br><dt><code>__GFORTRAN__</code><dd>The GNU Fortran compiler defines this.
|
||
|
|
|
||
|
|
<br><dt><code>__GNUC__</code><dt><code>__GNUC_MINOR__</code><dt><code>__GNUC_PATCHLEVEL__</code><dd>These macros are defined by all GNU compilers that use the C
|
||
|
|
preprocessor: C, C++, Objective-C and Fortran. Their values are the major
|
||
|
|
version, minor version, and patch level of the compiler, as integer
|
||
|
|
constants. For example, GCC 3.2.1 will define <code>__GNUC__</code> to 3,
|
||
|
|
<code>__GNUC_MINOR__</code> to 2, and <code>__GNUC_PATCHLEVEL__</code> to 1. These
|
||
|
|
macros are also defined if you invoke the preprocessor directly.
|
||
|
|
|
||
|
|
<p><code>__GNUC_PATCHLEVEL__</code> is new to GCC 3.0; it is also present in the
|
||
|
|
widely-used development snapshots leading up to 3.0 (which identify
|
||
|
|
themselves as GCC 2.96 or 2.97, depending on which snapshot you have).
|
||
|
|
|
||
|
|
<p>If all you need to know is whether or not your program is being compiled
|
||
|
|
by GCC, or a non-GCC compiler that claims to accept the GNU C dialects,
|
||
|
|
you can simply test <code>__GNUC__</code>. If you need to write code
|
||
|
|
which depends on a specific version, you must be more careful. Each
|
||
|
|
time the minor version is increased, the patch level is reset to zero;
|
||
|
|
each time the major version is increased (which happens rarely), the
|
||
|
|
minor version and patch level are reset. If you wish to use the
|
||
|
|
predefined macros directly in the conditional, you will need to write it
|
||
|
|
like this:
|
||
|
|
|
||
|
|
<pre class="smallexample"> /* <span class="roman">Test for GCC > 3.2.0</span> */
|
||
|
|
#if __GNUC__ > 3 || \
|
||
|
|
(__GNUC__ == 3 && (__GNUC_MINOR__ > 2 || \
|
||
|
|
(__GNUC_MINOR__ == 2 && \
|
||
|
|
__GNUC_PATCHLEVEL__ > 0))
|
||
|
|
</pre>
|
||
|
|
<p class="noindent">Another approach is to use the predefined macros to
|
||
|
|
calculate a single number, then compare that against a threshold:
|
||
|
|
|
||
|
|
<pre class="smallexample"> #define GCC_VERSION (__GNUC__ * 10000 \
|
||
|
|
+ __GNUC_MINOR__ * 100 \
|
||
|
|
+ __GNUC_PATCHLEVEL__)
|
||
|
|
...
|
||
|
|
/* <span class="roman">Test for GCC > 3.2.0</span> */
|
||
|
|
#if GCC_VERSION > 30200
|
||
|
|
</pre>
|
||
|
|
<p class="noindent">Many people find this form easier to understand.
|
||
|
|
|
||
|
|
<br><dt><code>__GNUG__</code><dd>The GNU C++ compiler defines this. Testing it is equivalent to
|
||
|
|
testing <code>(__GNUC__ && __cplusplus)<!-- /@w --></code>.
|
||
|
|
|
||
|
|
<br><dt><code>__STRICT_ANSI__</code><dd>GCC defines this macro if and only if the <samp><span class="option">-ansi</span></samp> switch, or a
|
||
|
|
<samp><span class="option">-std</span></samp> switch specifying strict conformance to some version of ISO C
|
||
|
|
or ISO C++, was specified when GCC was invoked. It is defined to ‘<samp><span class="samp">1</span></samp>’.
|
||
|
|
This macro exists primarily to direct GNU libc's header files to
|
||
|
|
restrict their definitions to the minimal set found in the 1989 C
|
||
|
|
standard.
|
||
|
|
|
||
|
|
<br><dt><code>__BASE_FILE__</code><dd>This macro expands to the name of the main input file, in the form
|
||
|
|
of a C string constant. This is the source file that was specified
|
||
|
|
on the command line of the preprocessor or C compiler.
|
||
|
|
|
||
|
|
<br><dt><code>__INCLUDE_LEVEL__</code><dd>This macro expands to a decimal integer constant that represents the
|
||
|
|
depth of nesting in include files. The value of this macro is
|
||
|
|
incremented on every ‘<samp><span class="samp">#include</span></samp>’ directive and decremented at the
|
||
|
|
end of every included file. It starts out at 0, its value within the
|
||
|
|
base file specified on the command line.
|
||
|
|
|
||
|
|
<br><dt><code>__ELF__</code><dd>This macro is defined if the target uses the ELF object format.
|
||
|
|
|
||
|
|
<br><dt><code>__VERSION__</code><dd>This macro expands to a string constant which describes the version of
|
||
|
|
the compiler in use. You should not rely on its contents having any
|
||
|
|
particular form, but it can be counted on to contain at least the
|
||
|
|
release number.
|
||
|
|
|
||
|
|
<br><dt><code>__OPTIMIZE__</code><dt><code>__OPTIMIZE_SIZE__</code><dt><code>__NO_INLINE__</code><dd>These macros describe the compilation mode. <code>__OPTIMIZE__</code> is
|
||
|
|
defined in all optimizing compilations. <code>__OPTIMIZE_SIZE__</code> is
|
||
|
|
defined if the compiler is optimizing for size, not speed.
|
||
|
|
<code>__NO_INLINE__</code> is defined if no functions will be inlined into
|
||
|
|
their callers (when not optimizing, or when inlining has been
|
||
|
|
specifically disabled by <samp><span class="option">-fno-inline</span></samp>).
|
||
|
|
|
||
|
|
<p>These macros cause certain GNU header files to provide optimized
|
||
|
|
definitions, using macros or inline functions, of system library
|
||
|
|
functions. You should not use these macros in any way unless you make
|
||
|
|
sure that programs will execute with the same effect whether or not they
|
||
|
|
are defined. If they are defined, their value is 1.
|
||
|
|
|
||
|
|
<br><dt><code>__GNUC_GNU_INLINE__</code><dd>GCC defines this macro if functions declared <code>inline</code> will be
|
||
|
|
handled in GCC's traditional gnu90 mode. Object files will contain
|
||
|
|
externally visible definitions of all functions declared <code>inline</code>
|
||
|
|
without <code>extern</code> or <code>static</code>. They will not contain any
|
||
|
|
definitions of any functions declared <code>extern inline</code>.
|
||
|
|
|
||
|
|
<br><dt><code>__GNUC_STDC_INLINE__</code><dd>GCC defines this macro if functions declared <code>inline</code> will be
|
||
|
|
handled according to the ISO C99 standard. Object files will contain
|
||
|
|
externally visible definitions of all functions declared <code>extern
|
||
|
|
inline</code>. They will not contain definitions of any functions declared
|
||
|
|
<code>inline</code> without <code>extern</code>.
|
||
|
|
|
||
|
|
<p>If this macro is defined, GCC supports the <code>gnu_inline</code> function
|
||
|
|
attribute as a way to always get the gnu90 behavior. Support for
|
||
|
|
this and <code>__GNUC_GNU_INLINE__</code> was added in GCC 4.1.3. If
|
||
|
|
neither macro is defined, an older version of GCC is being used:
|
||
|
|
<code>inline</code> functions will be compiled in gnu90 mode, and the
|
||
|
|
<code>gnu_inline</code> function attribute will not be recognized.
|
||
|
|
|
||
|
|
<br><dt><code>__CHAR_UNSIGNED__</code><dd>GCC defines this macro if and only if the data type <code>char</code> is
|
||
|
|
unsigned on the target machine. It exists to cause the standard header
|
||
|
|
file <samp><span class="file">limits.h</span></samp> to work correctly. You should not use this macro
|
||
|
|
yourself; instead, refer to the standard macros defined in <samp><span class="file">limits.h</span></samp>.
|
||
|
|
|
||
|
|
<br><dt><code>__WCHAR_UNSIGNED__</code><dd>Like <code>__CHAR_UNSIGNED__</code>, this macro is defined if and only if the
|
||
|
|
data type <code>wchar_t</code> is unsigned and the front-end is in C++ mode.
|
||
|
|
|
||
|
|
<br><dt><code>__REGISTER_PREFIX__</code><dd>This macro expands to a single token (not a string constant) which is
|
||
|
|
the prefix applied to CPU register names in assembly language for this
|
||
|
|
target. You can use it to write assembly that is usable in multiple
|
||
|
|
environments. For example, in the <code>m68k-aout</code> environment it
|
||
|
|
expands to nothing, but in the <code>m68k-coff</code> environment it expands
|
||
|
|
to a single ‘<samp><span class="samp">%</span></samp>’.
|
||
|
|
|
||
|
|
<br><dt><code>__USER_LABEL_PREFIX__</code><dd>This macro expands to a single token which is the prefix applied to
|
||
|
|
user labels (symbols visible to C code) in assembly. For example, in
|
||
|
|
the <code>m68k-aout</code> environment it expands to an ‘<samp><span class="samp">_</span></samp>’, but in the
|
||
|
|
<code>m68k-coff</code> environment it expands to nothing.
|
||
|
|
|
||
|
|
<p>This macro will have the correct definition even if
|
||
|
|
<samp><span class="option">-f(no-)underscores</span></samp> is in use, but it will not be correct if
|
||
|
|
target-specific options that adjust this prefix are used (e.g. the
|
||
|
|
OSF/rose <samp><span class="option">-mno-underscores</span></samp> option).
|
||
|
|
|
||
|
|
<br><dt><code>__SIZE_TYPE__</code><dt><code>__PTRDIFF_TYPE__</code><dt><code>__WCHAR_TYPE__</code><dt><code>__WINT_TYPE__</code><dt><code>__INTMAX_TYPE__</code><dt><code>__UINTMAX_TYPE__</code><dt><code>__SIG_ATOMIC_TYPE__</code><dt><code>__INT8_TYPE__</code><dt><code>__INT16_TYPE__</code><dt><code>__INT32_TYPE__</code><dt><code>__INT64_TYPE__</code><dt><code>__UINT8_TYPE__</code><dt><code>__UINT16_TYPE__</code><dt><code>__UINT32_TYPE__</code><dt><code>__UINT64_TYPE__</code><dt><code>__INT_LEAST8_TYPE__</code><dt><code>__INT_LEAST16_TYPE__</code><dt><code>__INT_LEAST32_TYPE__</code><dt><code>__INT_LEAST64_TYPE__</code><dt><code>__UINT_LEAST8_TYPE__</code><dt><code>__UINT_LEAST16_TYPE__</code><dt><code>__UINT_LEAST32_TYPE__</code><dt><code>__UINT_LEAST64_TYPE__</code><dt><code>__INT_FAST8_TYPE__</code><dt><code>__INT_FAST16_TYPE__</code><dt><code>__INT_FAST32_TYPE__</code><dt><code>__INT_FAST64_TYPE__</code><dt><code>__UINT_FAST8_TYPE__</code><dt><code>__UINT_FAST16_TYPE__</code><dt><code>__UINT_FAST32_TYPE__</code><dt><code>__UINT_FAST64_TYPE__</code><dt><code>__INTPTR_TYPE__</code><dt><code>__UINTPTR_TYPE__</code><dd>These macros are defined to the correct underlying types for the
|
||
|
|
<code>size_t</code>, <code>ptrdiff_t</code>, <code>wchar_t</code>, <code>wint_t</code>,
|
||
|
|
<code>intmax_t</code>, <code>uintmax_t</code>, <code>sig_atomic_t</code>, <code>int8_t</code>,
|
||
|
|
<code>int16_t</code>, <code>int32_t</code>, <code>int64_t</code>, <code>uint8_t</code>,
|
||
|
|
<code>uint16_t</code>, <code>uint32_t</code>, <code>uint64_t</code>,
|
||
|
|
<code>int_least8_t</code>, <code>int_least16_t</code>, <code>int_least32_t</code>,
|
||
|
|
<code>int_least64_t</code>, <code>uint_least8_t</code>, <code>uint_least16_t</code>,
|
||
|
|
<code>uint_least32_t</code>, <code>uint_least64_t</code>, <code>int_fast8_t</code>,
|
||
|
|
<code>int_fast16_t</code>, <code>int_fast32_t</code>, <code>int_fast64_t</code>,
|
||
|
|
<code>uint_fast8_t</code>, <code>uint_fast16_t</code>, <code>uint_fast32_t</code>,
|
||
|
|
<code>uint_fast64_t</code>, <code>intptr_t</code>, and <code>uintptr_t</code> typedefs,
|
||
|
|
respectively. They exist to make the standard header files
|
||
|
|
<samp><span class="file">stddef.h</span></samp>, <samp><span class="file">stdint.h</span></samp>, and <samp><span class="file">wchar.h</span></samp> work correctly.
|
||
|
|
You should not use these macros directly; instead, include the
|
||
|
|
appropriate headers and use the typedefs. Some of these macros may
|
||
|
|
not be defined on particular systems if GCC does not provide a
|
||
|
|
<samp><span class="file">stdint.h</span></samp> header on those systems.
|
||
|
|
|
||
|
|
<br><dt><code>__CHAR_BIT__</code><dd>Defined to the number of bits used in the representation of the
|
||
|
|
<code>char</code> data type. It exists to make the standard header given
|
||
|
|
numerical limits work correctly. You should not use
|
||
|
|
this macro directly; instead, include the appropriate headers.
|
||
|
|
|
||
|
|
<br><dt><code>__SCHAR_MAX__</code><dt><code>__WCHAR_MAX__</code><dt><code>__SHRT_MAX__</code><dt><code>__INT_MAX__</code><dt><code>__LONG_MAX__</code><dt><code>__LONG_LONG_MAX__</code><dt><code>__WINT_MAX__</code><dt><code>__SIZE_MAX__</code><dt><code>__PTRDIFF_MAX__</code><dt><code>__INTMAX_MAX__</code><dt><code>__UINTMAX_MAX__</code><dt><code>__SIG_ATOMIC_MAX__</code><dt><code>__INT8_MAX__</code><dt><code>__INT16_MAX__</code><dt><code>__INT32_MAX__</code><dt><code>__INT64_MAX__</code><dt><code>__UINT8_MAX__</code><dt><code>__UINT16_MAX__</code><dt><code>__UINT32_MAX__</code><dt><code>__UINT64_MAX__</code><dt><code>__INT_LEAST8_MAX__</code><dt><code>__INT_LEAST16_MAX__</code><dt><code>__INT_LEAST32_MAX__</code><dt><code>__INT_LEAST64_MAX__</code><dt><code>__UINT_LEAST8_MAX__</code><dt><code>__UINT_LEAST16_MAX__</code><dt><code>__UINT_LEAST32_MAX__</code><dt><code>__UINT_LEAST64_MAX__</code><dt><code>__INT_FAST8_MAX__</code><dt><code>__INT_FAST16_MAX__</code><dt><code>__INT_FAST32_MAX__</code><dt><code>__INT_FAST64_MAX__</code><dt><code>__UINT_FAST8_MAX__</code><dt><code>__UINT_FAST16_MAX__</code><dt><code>__UINT_FAST32_MAX__</code><dt><code>__UINT_FAST64_MAX__</code><dt><code>__INTPTR_MAX__</code><dt><code>__UINTPTR_MAX__</code><dt><code>__WCHAR_MIN__</code><dt><code>__WINT_MIN__</code><dt><code>__SIG_ATOMIC_MIN__</code><dd>Defined to the maximum value of the <code>signed char</code>, <code>wchar_t</code>,
|
||
|
|
<code>signed short</code>,
|
||
|
|
<code>signed int</code>, <code>signed long</code>, <code>signed long long</code>,
|
||
|
|
<code>wint_t</code>, <code>size_t</code>, <code>ptrdiff_t</code>,
|
||
|
|
<code>intmax_t</code>, <code>uintmax_t</code>, <code>sig_atomic_t</code>, <code>int8_t</code>,
|
||
|
|
<code>int16_t</code>, <code>int32_t</code>, <code>int64_t</code>, <code>uint8_t</code>,
|
||
|
|
<code>uint16_t</code>, <code>uint32_t</code>, <code>uint64_t</code>,
|
||
|
|
<code>int_least8_t</code>, <code>int_least16_t</code>, <code>int_least32_t</code>,
|
||
|
|
<code>int_least64_t</code>, <code>uint_least8_t</code>, <code>uint_least16_t</code>,
|
||
|
|
<code>uint_least32_t</code>, <code>uint_least64_t</code>, <code>int_fast8_t</code>,
|
||
|
|
<code>int_fast16_t</code>, <code>int_fast32_t</code>, <code>int_fast64_t</code>,
|
||
|
|
<code>uint_fast8_t</code>, <code>uint_fast16_t</code>, <code>uint_fast32_t</code>,
|
||
|
|
<code>uint_fast64_t</code>, <code>intptr_t</code>, and <code>uintptr_t</code> types and
|
||
|
|
to the minimum value of the <code>wchar_t</code>, <code>wint_t</code>, and
|
||
|
|
<code>sig_atomic_t</code> types respectively. They exist to make the
|
||
|
|
standard header given numerical limits work correctly. You should not
|
||
|
|
use these macros directly; instead, include the appropriate headers.
|
||
|
|
Some of these macros may not be defined on particular systems if GCC
|
||
|
|
does not provide a <samp><span class="file">stdint.h</span></samp> header on those systems.
|
||
|
|
|
||
|
|
<br><dt><code>__INT8_C</code><dt><code>__INT16_C</code><dt><code>__INT32_C</code><dt><code>__INT64_C</code><dt><code>__UINT8_C</code><dt><code>__UINT16_C</code><dt><code>__UINT32_C</code><dt><code>__UINT64_C</code><dt><code>__INTMAX_C</code><dt><code>__UINTMAX_C</code><dd>Defined to implementations of the standard <samp><span class="file">stdint.h</span></samp> macros with
|
||
|
|
the same names without the leading <code>__</code>. They exist the make the
|
||
|
|
implementation of that header work correctly. You should not use
|
||
|
|
these macros directly; instead, include the appropriate headers. Some
|
||
|
|
of these macros may not be defined on particular systems if GCC does
|
||
|
|
not provide a <samp><span class="file">stdint.h</span></samp> header on those systems.
|
||
|
|
|
||
|
|
<br><dt><code>__SIZEOF_INT__</code><dt><code>__SIZEOF_LONG__</code><dt><code>__SIZEOF_LONG_LONG__</code><dt><code>__SIZEOF_SHORT__</code><dt><code>__SIZEOF_POINTER__</code><dt><code>__SIZEOF_FLOAT__</code><dt><code>__SIZEOF_DOUBLE__</code><dt><code>__SIZEOF_LONG_DOUBLE__</code><dt><code>__SIZEOF_SIZE_T__</code><dt><code>__SIZEOF_WCHAR_T__</code><dt><code>__SIZEOF_WINT_T__</code><dt><code>__SIZEOF_PTRDIFF_T__</code><dd>Defined to the number of bytes of the C standard data types: <code>int</code>,
|
||
|
|
<code>long</code>, <code>long long</code>, <code>short</code>, <code>void *</code>, <code>float</code>,
|
||
|
|
<code>double</code>, <code>long double</code>, <code>size_t</code>, <code>wchar_t</code>, <code>wint_t</code>
|
||
|
|
and <code>ptrdiff_t</code>.
|
||
|
|
|
||
|
|
<br><dt><code>__BYTE_ORDER__</code><dt><code>__ORDER_LITTLE_ENDIAN__</code><dt><code>__ORDER_BIG_ENDIAN__</code><dt><code>__ORDER_PDP_ENDIAN__</code><dd><code>__BYTE_ORDER__</code> is defined to one of the values
|
||
|
|
<code>__ORDER_LITTLE_ENDIAN__</code>, <code>__ORDER_BIG_ENDIAN__</code>, or
|
||
|
|
<code>__ORDER_PDP_ENDIAN__</code> to reflect the layout of multi-byte and
|
||
|
|
multi-word quantities in memory. If <code>__BYTE_ORDER__</code> is equal to
|
||
|
|
<code>__ORDER_LITTLE_ENDIAN__</code> or <code>__ORDER_BIG_ENDIAN__</code>, then
|
||
|
|
multi-byte and multi-word quantities are laid out identically: the
|
||
|
|
byte (word) at the lowest address is the least significant or most
|
||
|
|
significant byte (word) of the quantity, respectively. If
|
||
|
|
<code>__BYTE_ORDER__</code> is equal to <code>__ORDER_PDP_ENDIAN__</code>, then
|
||
|
|
bytes in 16-bit words are laid out in a little-endian fashion, whereas
|
||
|
|
the 16-bit subwords of a 32-bit quantity are laid out in big-endian
|
||
|
|
fashion.
|
||
|
|
|
||
|
|
<p>You should use these macros for testing like this:
|
||
|
|
|
||
|
|
<pre class="smallexample"> /* <span class="roman">Test for a little-endian machine</span> */
|
||
|
|
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
||
|
|
</pre>
|
||
|
|
<br><dt><code>__FLOAT_WORD_ORDER__</code><dd><code>__FLOAT_WORD_ORDER__</code> is defined to one of the values
|
||
|
|
<code>__ORDER_LITTLE_ENDIAN__</code> or <code>__ORDER_BIG_ENDIAN__</code> to reflect
|
||
|
|
the layout of the words of multi-word floating-point quantities.
|
||
|
|
|
||
|
|
<br><dt><code>__DEPRECATED</code><dd>This macro is defined, with value 1, when compiling a C++ source file
|
||
|
|
with warnings about deprecated constructs enabled. These warnings are
|
||
|
|
enabled by default, but can be disabled with <samp><span class="option">-Wno-deprecated</span></samp>.
|
||
|
|
|
||
|
|
<br><dt><code>__EXCEPTIONS</code><dd>This macro is defined, with value 1, when compiling a C++ source file
|
||
|
|
with exceptions enabled. If <samp><span class="option">-fno-exceptions</span></samp> is used when
|
||
|
|
compiling the file, then this macro is not defined.
|
||
|
|
|
||
|
|
<br><dt><code>__GXX_RTTI</code><dd>This macro is defined, with value 1, when compiling a C++ source file
|
||
|
|
with runtime type identification enabled. If <samp><span class="option">-fno-rtti</span></samp> is
|
||
|
|
used when compiling the file, then this macro is not defined.
|
||
|
|
|
||
|
|
<br><dt><code>__USING_SJLJ_EXCEPTIONS__</code><dd>This macro is defined, with value 1, if the compiler uses the old
|
||
|
|
mechanism based on <code>setjmp</code> and <code>longjmp</code> for exception
|
||
|
|
handling.
|
||
|
|
|
||
|
|
<br><dt><code>__GXX_EXPERIMENTAL_CXX0X__</code><dd>This macro is defined when compiling a C++ source file with the option
|
||
|
|
<samp><span class="option">-std=c++0x</span></samp> or <samp><span class="option">-std=gnu++0x</span></samp>. It indicates that some
|
||
|
|
features likely to be included in C++0x are available. Note that these
|
||
|
|
features are experimental, and may change or be removed in future
|
||
|
|
versions of GCC.
|
||
|
|
|
||
|
|
<br><dt><code>__GXX_WEAK__</code><dd>This macro is defined when compiling a C++ source file. It has the
|
||
|
|
value 1 if the compiler will use weak symbols, COMDAT sections, or
|
||
|
|
other similar techniques to collapse symbols with “vague linkage”
|
||
|
|
that are defined in multiple translation units. If the compiler will
|
||
|
|
not collapse such symbols, this macro is defined with value 0. In
|
||
|
|
general, user code should not need to make use of this macro; the
|
||
|
|
purpose of this macro is to ease implementation of the C++ runtime
|
||
|
|
library provided with G++.
|
||
|
|
|
||
|
|
<br><dt><code>__NEXT_RUNTIME__</code><dd>This macro is defined, with value 1, if (and only if) the NeXT runtime
|
||
|
|
(as in <samp><span class="option">-fnext-runtime</span></samp>) is in use for Objective-C. If the GNU
|
||
|
|
runtime is used, this macro is not defined, so that you can use this
|
||
|
|
macro to determine which runtime (NeXT or GNU) is being used.
|
||
|
|
|
||
|
|
<br><dt><code>__LP64__</code><dt><code>_LP64</code><dd>These macros are defined, with value 1, if (and only if) the compilation
|
||
|
|
is for a target where <code>long int</code> and pointer both use 64-bits and
|
||
|
|
<code>int</code> uses 32-bit.
|
||
|
|
|
||
|
|
<br><dt><code>__SSP__</code><dd>This macro is defined, with value 1, when <samp><span class="option">-fstack-protector</span></samp> is in
|
||
|
|
use.
|
||
|
|
|
||
|
|
<br><dt><code>__SSP_ALL__</code><dd>This macro is defined, with value 2, when <samp><span class="option">-fstack-protector-all</span></samp> is
|
||
|
|
in use.
|
||
|
|
|
||
|
|
<br><dt><code>__SSP_STRONG__</code><dd>This macro is defined, with value 3, when <samp><span class="option">-fstack-protector-strong</span></samp> is
|
||
|
|
in use.
|
||
|
|
|
||
|
|
<br><dt><code>__SSP_EXPLICIT__</code><dd>This macro is defined, with value 4, when <samp><span class="option">-fstack-protector-explicit</span></samp> is
|
||
|
|
in use.
|
||
|
|
|
||
|
|
<br><dt><code>__SANITIZE_ADDRESS__</code><dd>This macro is defined, with value 1, when <samp><span class="option">-fsanitize=address</span></samp>
|
||
|
|
or <samp><span class="option">-fsanitize=kernel-address</span></samp> are in use.
|
||
|
|
|
||
|
|
<br><dt><code>__TIMESTAMP__</code><dd>This macro expands to a string constant that describes the date and time
|
||
|
|
of the last modification of the current source file. The string constant
|
||
|
|
contains abbreviated day of the week, month, day of the month, time in
|
||
|
|
hh:mm:ss form, year and looks like <code>"Sun Sep 16 01:03:52 1973"<!-- /@w --></code>.
|
||
|
|
If the day of the month is less than 10, it is padded with a space on the left.
|
||
|
|
|
||
|
|
<p>If GCC cannot determine the current date, it will emit a warning message
|
||
|
|
(once per compilation) and <code>__TIMESTAMP__</code> will expand to
|
||
|
|
<code>"??? ??? ?? ??:??:?? ????"<!-- /@w --></code>.
|
||
|
|
|
||
|
|
<br><dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1</code><dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2</code><dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4</code><dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8</code><dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16</code><dd>These macros are defined when the target processor supports atomic compare
|
||
|
|
and swap operations on operands 1, 2, 4, 8 or 16 bytes in length, respectively.
|
||
|
|
|
||
|
|
<br><dt><code>__GCC_HAVE_DWARF2_CFI_ASM</code><dd>This macro is defined when the compiler is emitting Dwarf2 CFI directives
|
||
|
|
to the assembler. When this is defined, it is possible to emit those same
|
||
|
|
directives in inline assembly.
|
||
|
|
|
||
|
|
<br><dt><code>__FP_FAST_FMA</code><dt><code>__FP_FAST_FMAF</code><dt><code>__FP_FAST_FMAL</code><dd>These macros are defined with value 1 if the backend supports the
|
||
|
|
<code>fma</code>, <code>fmaf</code>, and <code>fmal</code> builtin functions, so that
|
||
|
|
the include file <samp><span class="file">math.h</span></samp> can define the macros
|
||
|
|
<code>FP_FAST_FMA</code>, <code>FP_FAST_FMAF</code>, and <code>FP_FAST_FMAL</code>
|
||
|
|
for compatibility with the 1999 C standard.
|
||
|
|
|
||
|
|
<br><dt><code>__GCC_IEC_559</code><dd>This macro is defined to indicate the intended level of support for
|
||
|
|
IEEE 754 (IEC 60559) floating-point arithmetic. It expands to a
|
||
|
|
nonnegative integer value. If 0, it indicates that the combination of
|
||
|
|
the compiler configuration and the command-line options is not
|
||
|
|
intended to support IEEE 754 arithmetic for <code>float</code> and
|
||
|
|
<code>double</code> as defined in C99 and C11 Annex F (for example, that the
|
||
|
|
standard rounding modes and exceptions are not supported, or that
|
||
|
|
optimizations are enabled that conflict with IEEE 754 semantics). If
|
||
|
|
1, it indicates that IEEE 754 arithmetic is intended to be supported;
|
||
|
|
this does not mean that all relevant language features are supported
|
||
|
|
by GCC. If 2 or more, it additionally indicates support for IEEE
|
||
|
|
754-2008 (in particular, that the binary encodings for quiet and
|
||
|
|
signaling NaNs are as specified in IEEE 754-2008).
|
||
|
|
|
||
|
|
<p>This macro does not indicate the default state of command-line options
|
||
|
|
that control optimizations that C99 and C11 permit to be controlled by
|
||
|
|
standard pragmas, where those standards do not require a particular
|
||
|
|
default state. It does not indicate whether optimizations respect
|
||
|
|
signaling NaN semantics (the macro for that is
|
||
|
|
<code>__SUPPORT_SNAN__</code>). It does not indicate support for decimal
|
||
|
|
floating point or the IEEE 754 binary16 and binary128 types.
|
||
|
|
|
||
|
|
<br><dt><code>__GCC_IEC_559_COMPLEX</code><dd>This macro is defined to indicate the intended level of support for
|
||
|
|
IEEE 754 (IEC 60559) floating-point arithmetic for complex numbers, as
|
||
|
|
defined in C99 and C11 Annex G. It expands to a nonnegative integer
|
||
|
|
value. If 0, it indicates that the combination of the compiler
|
||
|
|
configuration and the command-line options is not intended to support
|
||
|
|
Annex G requirements (for example, because <samp><span class="option">-fcx-limited-range</span></samp>
|
||
|
|
was used). If 1 or more, it indicates that it is intended to support
|
||
|
|
those requirements; this does not mean that all relevant language
|
||
|
|
features are supported by GCC.
|
||
|
|
|
||
|
|
<br><dt><code>__NO_MATH_ERRNO__</code><dd>This macro is defined if <samp><span class="option">-fno-math-errno</span></samp> is used, or enabled
|
||
|
|
by another option such as <samp><span class="option">-ffast-math</span></samp> or by default.
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
</body></html>
|
||
|
|
|