3.7.2 Общие предопределённые макросы

Общие предопределённые макросы являются расширениями GNU C. Они доступны с одинаковым значением независимо от машины или операционной системы, на которой вы используете GNU C или GNU Fortran. Их имена начинаются с двойных подчёркиваний.

__COUNTER__

This macro expands to sequential integral values starting from 0. In conjunction with the ## operator, this provides a convenient means to generate unique identifiers. Care must be taken to ensure that __COUNTER__ is not expanded prior to inclusion of precompiled headers which use it. Otherwise, the precompiled headers will not be used.

__GFORTRAN__

The GNU Fortran compiler defines this.

__GNUC__

__GNUC_MINOR__

__GNUC_PATCHLEVEL__

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 __GNUC__ to 3, __GNUC_MINOR__ to 2, and __GNUC_PATCHLEVEL__ to 1. These macros are also defined if you invoke the preprocessor directly.

__GNUC_PATCHLEVEL__ 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).

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 __GNUC__. 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:

/* Test for GCC > 3.2.0 */
#if __GNUC__ > 3 || \
    (__GNUC__ == 3 && (__GNUC_MINOR__ > 2 || \
                       (__GNUC_MINOR__ == 2 && \
                        __GNUC_PATCHLEVEL__ > 0))

Another approach is to use the predefined macros to calculate a single number, then compare that against a threshold:

#define GCC_VERSION (__GNUC__ * 10000 \
                     + __GNUC_MINOR__ * 100 \
                     + __GNUC_PATCHLEVEL__)
…
/* Test for GCC > 3.2.0 */
#if GCC_VERSION > 30200

Many people find this form easier to understand.

__GNUG__

The GNU C++ compiler defines this. Testing it is equivalent to testing (__GNUC__ && __cplusplus).

__STRICT_ANSI__

GCC defines this macro if and only if the -ansi switch, or a -std switch specifying strict conformance to some version of ISO C or ISO C++, was specified when GCC was invoked. It is defined to ‘1’. 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.

__BASE_FILE__

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.

__INCLUDE_LEVEL__

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 ‘#include’ 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.

__ELF__

This macro is defined if the target uses the ELF object format.

__VERSION__

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.

__OPTIMIZE__

__OPTIMIZE_SIZE__

__NO_INLINE__

These macros describe the compilation mode. __OPTIMIZE__ is defined in all optimizing compilations. __OPTIMIZE_SIZE__ is defined if the compiler is optimizing for size, not speed. __NO_INLINE__ is defined if no functions will be inlined into their callers (when not optimizing, or when inlining has been specifically disabled by -fno-inline).

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.

__GNUC_GNU_INLINE__

GCC defines this macro if functions declared inline will be handled in GCC’s traditional gnu90 mode. Object files will contain externally visible definitions of all functions declared inline without extern or static. They will not contain any definitions of any functions declared extern inline.

__GNUC_STDC_INLINE__

GCC defines this macro if functions declared inline will be handled according to the ISO C99 standard. Object files will contain externally visible definitions of all functions declared extern inline. They will not contain definitions of any functions declared inline without extern.

If this macro is defined, GCC supports the gnu_inline function attribute as a way to always get the gnu90 behavior. Support for this and __GNUC_GNU_INLINE__ was added in GCC 4.1.3. If neither macro is defined, an older version of GCC is being used: inline functions will be compiled in gnu90 mode, and the gnu_inline function attribute will not be recognized.

__CHAR_UNSIGNED__

GCC defines this macro if and only if the data type char is unsigned on the target machine. It exists to cause the standard header file limits.h to work correctly. You should not use this macro yourself; instead, refer to the standard macros defined in limits.h.

__WCHAR_UNSIGNED__

Like __CHAR_UNSIGNED__, this macro is defined if and only if the data type wchar_t is unsigned and the front-end is in C++ mode.

__REGISTER_PREFIX__

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 m68k-aout environment it expands to nothing, but in the m68k-coff environment it expands to a single ‘%’.

__USER_LABEL_PREFIX__

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 m68k-aout environment it expands to an ‘_’, but in the m68k-coff environment it expands to nothing.

This macro will have the correct definition even if -f(no-)underscores is in use, but it will not be correct if target-specific options that adjust this prefix are used (e.g. the OSF/rose -mno-underscores option).

__SIZE_TYPE__

__PTRDIFF_TYPE__

__WCHAR_TYPE__

__WINT_TYPE__

__INTMAX_TYPE__

__UINTMAX_TYPE__

__SIG_ATOMIC_TYPE__

__INT8_TYPE__

__INT16_TYPE__

__INT32_TYPE__

__INT64_TYPE__

__UINT8_TYPE__

__UINT16_TYPE__

__UINT32_TYPE__

__UINT64_TYPE__

__INT_LEAST8_TYPE__

__INT_LEAST16_TYPE__

__INT_LEAST32_TYPE__

__INT_LEAST64_TYPE__

__UINT_LEAST8_TYPE__

__UINT_LEAST16_TYPE__

__UINT_LEAST32_TYPE__

__UINT_LEAST64_TYPE__

__INT_FAST8_TYPE__

__INT_FAST16_TYPE__

__INT_FAST32_TYPE__

__INT_FAST64_TYPE__

__UINT_FAST8_TYPE__

__UINT_FAST16_TYPE__

__UINT_FAST32_TYPE__

__UINT_FAST64_TYPE__

__INTPTR_TYPE__

__UINTPTR_TYPE__

These macros are defined to the correct underlying types for the size_t, ptrdiff_t, wchar_t, wint_t, intmax_t, uintmax_t, sig_atomic_t, int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, int_least8_t, int_least16_t, int_least32_t, int_least64_t, uint_least8_t, uint_least16_t, uint_least32_t, uint_least64_t, int_fast8_t, int_fast16_t, int_fast32_t, int_fast64_t, uint_fast8_t, uint_fast16_t, uint_fast32_t, uint_fast64_t, intptr_t, and uintptr_t typedefs, respectively. They exist to make the standard header files stddef.h, stdint.h, and wchar.h 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 stdint.h header on those systems.

__CHAR_BIT__

Defined to the number of bits used in the representation of the char 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.

__SCHAR_MAX__

__WCHAR_MAX__

__SHRT_MAX__

__INT_MAX__

__LONG_MAX__

__LONG_LONG_MAX__

__WINT_MAX__

__SIZE_MAX__

__PTRDIFF_MAX__

__INTMAX_MAX__

__UINTMAX_MAX__

__SIG_ATOMIC_MAX__

__INT8_MAX__

__INT16_MAX__

__INT32_MAX__

__INT64_MAX__

__UINT8_MAX__

__UINT16_MAX__

__UINT32_MAX__

__UINT64_MAX__

__INT_LEAST8_MAX__

__INT_LEAST16_MAX__

__INT_LEAST32_MAX__

__INT_LEAST64_MAX__

__UINT_LEAST8_MAX__

__UINT_LEAST16_MAX__

__UINT_LEAST32_MAX__

__UINT_LEAST64_MAX__

__INT_FAST8_MAX__

__INT_FAST16_MAX__

__INT_FAST32_MAX__

__INT_FAST64_MAX__

__UINT_FAST8_MAX__

__UINT_FAST16_MAX__

__UINT_FAST32_MAX__

__UINT_FAST64_MAX__

__INTPTR_MAX__

__UINTPTR_MAX__

__WCHAR_MIN__

__WINT_MIN__

__SIG_ATOMIC_MIN__

Определено максимальным значением типов signed char, wchar_t, signed short, signed int, signed long, signed long long, wint_t, size_t, ptrdiff_t, intmax_t, uintmax_t, sig_atomic_t, int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, int_least8_t, int_least16_t, int_least32_t, int_least64_t, uint_least8_t, uint_least16_t, uint_least32_t, uint_least64_t, int_fast8_t, int_fast16_t, int_fast32_t, int_fast64_t, uint_fast8_t, uint_fast16_t, uint_fast32_t, uint_fast64_t, intptr_t, и uintptr_t типов и минимальным значением типов wchar_t, wint_t, и sig_atomic_t соответственно. Они существуют, чтобы стандартные заголовки с числовыми ограничениями работали корректно. Вы не должны использовать эти макросы напрямую; вместо этого используйте соответствующие заголовки. Некоторые из этих макросов могут не быть определены на определённых системах, если GCC не предоставляет заголовок stdint.h на этих системах.

__INT8_C

__INT16_C

__INT32_C

__INT64_C

__UINT8_C

__UINT16_C

__UINT32_C

__UINT64_C

__INTMAX_C

__UINTMAX_C

Определены для реализаций стандартных макросов stdint.h с такими же именами без ведущего __. Они существуют, чтобы реализация этого заголовка работала корректно. Вы не должны использовать эти макросы напрямую; вместо этого используйте соответствующие заголовки. Некоторые из этих макросов могут не быть определены на определённых системах, если GCC не предоставляет заголовок stdint.h на этих системах.

__SIZEOF_INT__

__SIZEOF_LONG__

__SIZEOF_LONG_LONG__

__SIZEOF_SHORT__

__SIZEOF_POINTER__

__SIZEOF_FLOAT__

__SIZEOF_DOUBLE__

__SIZEOF_LONG_DOUBLE__

__SIZEOF_SIZE_T__

__SIZEOF_WCHAR_T__

__SIZEOF_WINT_T__

__SIZEOF_PTRDIFF_T__

Определены для количества байтов стандартных типов данных C: int, long, long long, short, void *, float, double, long double, size_t, wchar_t, wint_t и ptrdiff_t.

__BYTE_ORDER__

__ORDER_LITTLE_ENDIAN__

__ORDER_BIG_ENDIAN__

__ORDER_PDP_ENDIAN__

__BYTE_ORDER__ определяется одним из значений __ORDER_LITTLE_ENDIAN__, __ORDER_BIG_ENDIAN__, или __ORDER_PDP_ENDIAN__, чтобы отразить расположение многобайтовых и многословных величин в памяти. Если __BYTE_ORDER__ равно __ORDER_LITTLE_ENDIAN__ или __ORDER_BIG_ENDIAN__, многобайтовые и многословные величины выстраиваются одинаково: байт (слово) с наименьшим адресом является наименее значимым или наиболее значимым байтом (словом) величины соответственно. Если __BYTE_ORDER__ равно __ORDER_PDP_ENDIAN__, байты в 16-битных словах выстраиваются в порядке little-endian, а 16-битные подслова 32-битной величины — в порядке big-endian.

Вы должны использовать эти макросы для тестирования так:

/* Test for a little-endian machine */
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

__FLOAT_WORD_ORDER__

__FLOAT_WORD_ORDER__ определяется одним из значений __ORDER_LITTLE_ENDIAN__ или __ORDER_BIG_ENDIAN__, чтобы отразить расположение слов многословных чисел с плавающей запятой.

__DEPRECATED

Этот макрос определён со значением 1 при компиляции исходного файла C++ с включёнными предупреждениями о устаревших конструкциях. Эти предупреждения включены по умолчанию, но могут быть отключены с помощью -Wno-deprecated.

__EXCEPTIONS

Этот макрос определён со значением 1 при компиляции исходного файла C++ с включёнными исключениями. Если при компиляции файла используется -fno-exceptions, то этот макрос не определён.

__GXX_RTTI

Этот макрос определён со значением 1 при компиляции исходного файла C++ с включенной идентификацией типов во время выполнения. Если при компиляции файла используется -fno-rtti, то этот макрос не определён.

__USING_SJLJ_EXCEPTIONS__

Этот макрос определён со значением 1, если компилятор использует старую механику на основе setjmp и longjmp для обработки исключений.

__GXX_EXPERIMENTAL_CXX0X__

Этот макрос определён при компиляции исходного файла C++ с опцией -std=c++0x или -std=gnu++0x. Он указывает, что некоторые функции, вероятно, включенные в C++0x, доступны. Обратите внимание, что эти функции являются экспериментальными и могут измениться или быть удалены в будущих версиях GCC.

__GXX_WEAK__

Этот макрос определён при компиляции исходного файла C++. Он имеет значение 1, если компилятор будет использовать слабые символы, секции COMDAT или другие подобные методы для объединения символов с «неясными ссылками», которые определены в нескольких единицах трансляции. Если компилятор не будет объединять такие символы, этот макрос определён со значением 0. В общем случае коду пользователя не нужно использовать этот макрос; цель этого макроса — облегчить реализацию библиотеки времени выполнения C++, поставляемой с G++.

__NEXT_RUNTIME__

Этот макрос определён со значением 1, если (и только если) используется NeXT runtime (как в -fnext-runtime) для Objective-C. Если используется GNU runtime, этот макрос не определён, чтобы вы могли использовать этот макрос для определения используемого времени выполнения (NeXT или GNU).

__LP64__

_LP64

Эти макросы определены со значением 1, если (и только если) компиляция ведётся для целевой системы, где long int и указатели используют 64 бита, а int использует 32 бита.

__SSP__

Этот макрос определён со значением 1, когда используется -fstack-protector.

__SSP_ALL__

Этот макрос определён со значением 2, когда используется -fstack-protector-all.

__SSP_STRONG__

Этот макрос определён со значением 3, когда используется -fstack-protector-strong.

__SSP_EXPLICIT__

Этот макрос определён со значением 4, когда используется -fstack-protector-explicit.

__SANITIZE_ADDRESS__

Этот макрос определён со значением 1, когда используются -fsanitize=address или -fsanitize=kernel-address.

__TIMESTAMP__

Этот макрос расширяется до строковой константы, описывающей дату и время последней модификации текущего исходного файла. Строковая константа содержит аббревиатуру дня недели, месяца, числа, время в формате чч:мм:сс, год и выглядит как "Sun Sep 16 01:03:52 1973". Если число меньше 10, оно дополняется пробелом слева.

Если GCC не может определить текущую дату, он выведет сообщение об ошибке (один раз за компиляцию) и __TIMESTAMP__ будет расширяться до "??? ??? ?? ??:??:?? ????".

__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1

__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2

__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4

__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8

__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16

Эти макросы определены со значением 1, если целевой процессор поддерживает атомарные операции сравнения и обмена для операндов длиной 1, 2, 4, 8 или 16 байт соответственно.

__GCC_HAVE_DWARF2_CFI_ASM

Этот макрос определён, когда компилятор генерирует директивы DWARF CFI для ассемблера. При этом определении можно генерировать те же самые директивы в ассемблерной вставке.

__FP_FAST_FMA

__FP_FAST_FMAF

__FP_FAST_FMAL

Эти макросы определены со значением 1, если бэкенд поддерживает встроенные функции fma, fmaf, и fmal, чтобы файл включения math.h мог определить макросы FP_FAST_FMA, FP_FAST_FMAF, и FP_FAST_FMAL для совместимости со стандартом C 1999.

__GCC_IEC_559

Этот макрос определён, чтобы указать предполагаемый уровень поддержки арифметики с плавающей запятой IEEE 754 (IEC 60559). Он расширяется до целого неотрицательного значения. Если 0, это указывает, что комбинация конфигурации компилятора и опций командной строки не предназначена для поддержки арифметики IEEE 754 для float и double, как определено в C99 и C11 Приложение F (например, что стандартные режимы округления и исключения не поддерживаются или что оптимизации включены, что конфликтует с семантикой IEEE 754). Если 1, это указывает, что арифметика IEEE 754 предназначена для поддержки; это не означает, что все соответствующие функции языка поддерживаются GCC. Если 2 или больше, это дополнительно указывает поддержку IEEE 754-2008 (в частности, что двоичные кодирования для тихих и сигнализирующих NaN совпадают со спецификациями в IEEE 754-2008).

Этот макрос не указывает состояние по умолчанию опций командной строки, которые контролируют оптимизации, которые C99 и C11 разрешают контролировать стандартными директивами, где эти стандарты не требуют определённого состояния по умолчанию. Он не указывает, соблюдают ли оптимизации семантику сигнализирующих NaN (макрос для этого __SUPPORT_SNAN__). Он не указывает поддержку десятичной арифметики с плавающей запятой или типов IEEE 754 binary16 и binary128.

__GCC_IEC_559_COMPLEX

Этот макрос определён, чтобы указать предполагаемый уровень поддержки арифметики с плавающей запятой IEEE 754 (IEC 60559) для комплексных чисел, как определено в C99 и C11 Приложении G. Он расширяется до целого неотрицательного значения. Если 0, это указывает, что комбинация конфигурации компилятора и опций командной строки не предназначена для поддержки требований Приложения G (например, потому что использовалась -fcx-limited-range). Если 1 или больше, это указывает, что предполагается поддержка этих требований; это не означает, что все соответствующие функции языка поддерживаются GCC.

__NO_MATH_ERRNO__

Этот макрос определён, если используется -fno-math-errno или включён другой опцией, такой как -ffast-math, или по умолчанию.

Далее: Системно-специфические предопределённые макросы, Предыдущее: Стандартные предопределённые макросы, Вверх: Предопределённые макросы [Оглавление][Индекс]