void arc_cpu_cpp_builtins (cpp_reader * pfile) { builtin_assert ("cpu=arc"); builtin_assert ("machine=arc"); builtin_define ("__arc__"); #undef ARC_C_DEF #define ARC_C_DEF(NAME, CONDITION) \ def_or_undef_macro (pfile, NAME, CONDITION); #include "arc-c.def" #undef ARC_C_DEF builtin_define_with_int_value ("__ARC_TLS_REGNO__", arc_tp_regno); builtin_define_with_int_value ("__ARC_LPC_WIDTH__", arc_lpcwidth); builtin_define (TARGET_BIG_ENDIAN ? "__BIG_ENDIAN__" : "__LITTLE_ENDIAN__"); if (TARGET_BIG_ENDIAN) builtin_define ("__big_endian__"); }
static void aarch64_update_cpp_builtins (cpp_reader *pfile) { aarch64_def_or_undef (flag_unsafe_math_optimizations, "__ARM_FP_FAST", pfile); builtin_define_with_int_value ("__ARM_ARCH", aarch64_architecture_version); builtin_define_with_int_value ("__ARM_SIZEOF_MINIMAL_ENUM", flag_short_enums ? 1 : 4); aarch64_def_or_undef (TARGET_BIG_END, "__AARCH64EB__", pfile); aarch64_def_or_undef (TARGET_BIG_END, "__ARM_BIG_ENDIAN", pfile); aarch64_def_or_undef (!TARGET_BIG_END, "__AARCH64EL__", pfile); aarch64_def_or_undef (TARGET_FLOAT, "__ARM_FEATURE_FMA", pfile); if (TARGET_FLOAT || TARGET_SIMD) { builtin_define_with_int_value ("__ARM_FP", 0x0E); builtin_define ("__ARM_FP16_FORMAT_IEEE"); builtin_define ("__ARM_FP16_ARGS"); } else cpp_undef (pfile, "__ARM_FP"); aarch64_def_or_undef (TARGET_SIMD, "__ARM_FEATURE_NUMERIC_MAXMIN", pfile); aarch64_def_or_undef (TARGET_SIMD, "__ARM_NEON", pfile); aarch64_def_or_undef (TARGET_CRC32, "__ARM_FEATURE_CRC32", pfile); cpp_undef (pfile, "__AARCH64_CMODEL_TINY__"); cpp_undef (pfile, "__AARCH64_CMODEL_SMALL__"); cpp_undef (pfile, "__AARCH64_CMODEL_LARGE__"); switch (aarch64_cmodel) { case AARCH64_CMODEL_TINY: case AARCH64_CMODEL_TINY_PIC: builtin_define ("__AARCH64_CMODEL_TINY__"); break; case AARCH64_CMODEL_SMALL: case AARCH64_CMODEL_SMALL_PIC: builtin_define ("__AARCH64_CMODEL_SMALL__"); break; case AARCH64_CMODEL_LARGE: builtin_define ("__AARCH64_CMODEL_LARGE__"); break; default: break; } aarch64_def_or_undef (TARGET_ILP32, "_ILP32", pfile); aarch64_def_or_undef (TARGET_ILP32, "__ILP32__", pfile); aarch64_def_or_undef (TARGET_CRYPTO, "__ARM_FEATURE_CRYPTO", pfile); }
/* Implement TARGET_CPU_CPP_BUILTINS. */ void tilepro_cpu_cpp_builtins (struct cpp_reader *pfile) { builtin_define ("__tile__"); builtin_define ("__tilepro__"); builtin_assert ("cpu=tile"); builtin_assert ("machine=tile"); builtin_define ("__tile_chip__=1"); builtin_define ("__tile_chip_rev__=0"); builtin_define ("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); builtin_define ("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); builtin_define ("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); builtin_define ("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); TILEPRO_CPU_CPP_ENDIAN_BUILTINS (); GNU_USER_TARGET_OS_CPP_BUILTINS (); }
static void aarch64_define_unconditional_macros (cpp_reader *pfile) { builtin_define ("__aarch64__"); builtin_define ("__ARM_64BIT_STATE"); builtin_define ("__ARM_ARCH_ISA_A64"); builtin_define_with_int_value ("__ARM_ALIGN_MAX_PWR", 28); builtin_define_with_int_value ("__ARM_ALIGN_MAX_STACK_PWR", 16); /* __ARM_ARCH_8A is not mandated by ACLE but we define it unconditionally as interoperability with the same arm macro. */ builtin_define ("__ARM_ARCH_8A"); builtin_define_with_int_value ("__ARM_ARCH_PROFILE", 'A'); builtin_define ("__ARM_FEATURE_CLZ"); builtin_define ("__ARM_FEATURE_IDIV"); builtin_define ("__ARM_FEATURE_UNALIGNED"); builtin_define ("__ARM_PCS_AAPCS64"); builtin_define_with_int_value ("__ARM_SIZEOF_WCHAR_T", WCHAR_TYPE_SIZE / 8); }
/* Implement TARGET_CPU_CPP_BUILTINS. */ void tilegx_cpu_cpp_builtins (struct cpp_reader *pfile) { builtin_define ("__tile__"); builtin_define ("__tilegx__"); builtin_define ("__tile_chip__=10"); builtin_define ("__tile_chip_rev__=0"); builtin_assert ("cpu=tilegx"); builtin_assert ("machine=tilegx"); if (TARGET_32BIT) builtin_define ("__tilegx32__"); builtin_define ("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); builtin_define ("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); TILEGX_CPU_CPP_ENDIAN_BUILTINS (); GNU_USER_TARGET_OS_CPP_BUILTINS (); }
/* Hook that registers front end and target-specific built-ins. */ void c_cpp_builtins (cpp_reader *pfile) { /* -undef turns off target-specific built-ins. */ if (flag_undef) return; define__GNUC__ (); /* For stddef.h. They require macros defined in c-common.c. */ c_stddef_cpp_builtins (); if (c_dialect_cxx ()) { if (flag_weak && SUPPORTS_ONE_ONLY) cpp_define (pfile, "__GXX_WEAK__=1"); else cpp_define (pfile, "__GXX_WEAK__=0"); if (warn_deprecated) cpp_define (pfile, "__DEPRECATED"); } /* Note that we define this for C as well, so that we know if __attribute__((cleanup)) will interface with EH. */ if (flag_exceptions) cpp_define (pfile, "__EXCEPTIONS"); /* Represents the C++ ABI version, always defined so it can be used while preprocessing C and assembler. */ if (flag_abi_version == 0) /* Use a very large value so that: #if __GXX_ABI_VERSION >= <value for version X> will work whether the user explicitly says "-fabi-version=x" or "-fabi-version=0". Do not use INT_MAX because that will be different from system to system. */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999); else if (flag_abi_version == 1) /* Due to a historical accident, this version had the value "102". */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); else /* Newer versions have values 1002, 1003, .... */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 1000 + flag_abi_version); /* libgcc needs to know this. */ if (USING_SJLJ_EXCEPTIONS) cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); /* limits.h needs to know these. */ builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0); builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0); builtin_define_type_max ("__INT_MAX__", integer_type_node, 0); builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1); builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2); builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0); builtin_define_type_precision ("__CHAR_BIT__", char_type_node); /* stdint.h (eventually) and the testsuite need to know these. */ builtin_define_stdint_macros (); /* float.h needs to know these. */ builtin_define_with_int_value ("__FLT_EVAL_METHOD__", TARGET_FLT_EVAL_METHOD); /* And decfloat.h needs this. */ builtin_define_with_int_value ("__DEC_EVAL_METHOD__", TARGET_DEC_EVAL_METHOD); builtin_define_float_constants ("FLT", "F", "%s", float_type_node); /* Cast the double precision constants when single precision constants are specified. The correct result is computed by the compiler when using macros that include a cast. This has the side-effect of making the value unusable in const expressions. */ if (flag_single_precision_constant) builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node); else builtin_define_float_constants ("DBL", "", "%s", double_type_node); builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node); /* For decfloat.h. */ builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); /* For use in assembly language. */ builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); /* Misc. */ builtin_define_with_value ("__VERSION__", version_string, 1); cpp_define (pfile, "__GNUC_GNU_INLINE__"); /* Definitions for LP64 model. */ if (TYPE_PRECISION (long_integer_type_node) == 64 && POINTER_SIZE == 64 && TYPE_PRECISION (integer_type_node) == 32) { cpp_define (pfile, "_LP64"); cpp_define (pfile, "__LP64__"); } /* Other target-independent built-ins determined by command-line options. */ if (optimize_size) cpp_define (pfile, "__OPTIMIZE_SIZE__"); if (optimize) cpp_define (pfile, "__OPTIMIZE__"); if (fast_math_flags_set_p ()) cpp_define (pfile, "__FAST_MATH__"); if (flag_really_no_inline) cpp_define (pfile, "__NO_INLINE__"); if (flag_signaling_nans) cpp_define (pfile, "__SUPPORT_SNAN__"); if (flag_finite_math_only) cpp_define (pfile, "__FINITE_MATH_ONLY__=1"); else cpp_define (pfile, "__FINITE_MATH_ONLY__=0"); if (flag_pic) { builtin_define_with_int_value ("__pic__", flag_pic); builtin_define_with_int_value ("__PIC__", flag_pic); } if (flag_iso) cpp_define (pfile, "__STRICT_ANSI__"); if (!flag_signed_char) cpp_define (pfile, "__CHAR_UNSIGNED__"); if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) cpp_define (pfile, "__WCHAR_UNSIGNED__"); /* Make the choice of ObjC runtime visible to source code. */ if (c_dialect_objc () && flag_next_runtime) cpp_define (pfile, "__NEXT_RUNTIME__"); /* Show the availability of some target pragmas. */ if (flag_mudflap || targetm.handle_pragma_redefine_extname) cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); if (targetm.handle_pragma_extern_prefix) cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX"); /* Make the choice of the stack protector runtime visible to source code. The macro names and values here were chosen for compatibility with an earlier implementation, i.e. ProPolice. */ if (flag_stack_protect == 2) cpp_define (pfile, "__SSP_ALL__=2"); else if (flag_stack_protect == 1) cpp_define (pfile, "__SSP__=1"); if (flag_openmp) cpp_define (pfile, "_OPENMP=200505"); /* A straightforward target hook doesn't work, because of problems linking that hook's body when part of non-C front ends. */ # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) # define builtin_define(TXT) cpp_define (pfile, TXT) # define builtin_assert(TXT) cpp_assert (pfile, TXT) TARGET_CPU_CPP_BUILTINS (); TARGET_OS_CPP_BUILTINS (); TARGET_OBJFMT_CPP_BUILTINS (); /* Support the __declspec keyword by turning them into attributes. Note that the current way we do this may result in a collision with predefined attributes later on. This can be solved by using one attribute, say __declspec__, and passing args to it. The problem with that approach is that args are not accumulated: each new appearance would clobber any existing args. */ if (TARGET_DECLSPEC) builtin_define ("__declspec(x)=__attribute__((x))"); }
/* Hook that registers front end and target-specific built-ins. */ void c_cpp_builtins (cpp_reader *pfile) { /* -undef turns off target-specific built-ins. */ if (flag_undef) return; define_language_independent_builtin_macros (pfile); if (c_dialect_cxx ()) { int major; parse_basever (&major, NULL, NULL); cpp_define_formatted (pfile, "__GNUG__=%d", major); } /* For stddef.h. They require macros defined in c-common.c. */ c_stddef_cpp_builtins (); /* Set include test macros for all C/C++ (not for just C++11 etc.) the builtins __has_include__ and __has_include_next__ are defined in libcpp. */ cpp_define (pfile, "__has_include(STR)=__has_include__(STR)"); cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)"); if (c_dialect_cxx ()) { if (flag_weak && SUPPORTS_ONE_ONLY) cpp_define (pfile, "__GXX_WEAK__=1"); else cpp_define (pfile, "__GXX_WEAK__=0"); if (warn_deprecated) cpp_define (pfile, "__DEPRECATED"); if (flag_rtti) cpp_define (pfile, "__GXX_RTTI"); if (cxx_dialect >= cxx11) cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__"); /* Binary literals have been allowed in g++ before C++11 and were standardized for C++14. */ if (!pedantic || cxx_dialect > cxx11) cpp_define (pfile, "__cpp_binary_literals=201304"); if (cxx_dialect >= cxx11) { /* Set feature test macros for C++11 */ cpp_define (pfile, "__cpp_unicode_characters=200704"); cpp_define (pfile, "__cpp_raw_strings=200710"); cpp_define (pfile, "__cpp_unicode_literals=200710"); cpp_define (pfile, "__cpp_user_defined_literals=200809"); cpp_define (pfile, "__cpp_lambdas=200907"); cpp_define (pfile, "__cpp_constexpr=200704"); cpp_define (pfile, "__cpp_static_assert=200410"); cpp_define (pfile, "__cpp_decltype=200707"); cpp_define (pfile, "__cpp_attributes=200809"); cpp_define (pfile, "__cpp_rvalue_reference=200610"); cpp_define (pfile, "__cpp_variadic_templates=200704"); cpp_define (pfile, "__cpp_alias_templates=200704"); } if (cxx_dialect > cxx11) { /* Set feature test macros for C++14 */ cpp_define (pfile, "__cpp_return_type_deduction=201304"); cpp_define (pfile, "__cpp_init_captures=201304"); cpp_define (pfile, "__cpp_generic_lambdas=201304"); //cpp_undef (pfile, "__cpp_constexpr"); //cpp_define (pfile, "__cpp_constexpr=201304"); cpp_define (pfile, "__cpp_decltype_auto=201304"); //cpp_define (pfile, "__cpp_aggregate_nsdmi=201304"); //cpp_define (pfile, "__cpp_variable_templates=201304"); cpp_define (pfile, "__cpp_digit_separators=201309"); cpp_define (pfile, "__cpp_attribute_deprecated=201309"); //cpp_define (pfile, "__cpp_sized_deallocation=201309"); /* We'll have to see where runtime arrays wind up. Let's put it in C++14 for now. */ cpp_define (pfile, "__cpp_runtime_arrays=201304"); } } /* Note that we define this for C as well, so that we know if __attribute__((cleanup)) will interface with EH. */ if (flag_exceptions) cpp_define (pfile, "__EXCEPTIONS"); /* Represents the C++ ABI version, always defined so it can be used while preprocessing C and assembler. */ if (flag_abi_version == 0) /* Use a very large value so that: #if __GXX_ABI_VERSION >= <value for version X> will work whether the user explicitly says "-fabi-version=x" or "-fabi-version=0". Do not use INT_MAX because that will be different from system to system. */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999); else if (flag_abi_version == 1) /* Due to a historical accident, this version had the value "102". */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); else /* Newer versions have values 1002, 1003, .... */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 1000 + flag_abi_version); /* libgcc needs to know this. */ if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); /* limits.h and stdint.h need to know these. */ builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node); builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node); builtin_define_type_max ("__INT_MAX__", integer_type_node); builtin_define_type_max ("__LONG_MAX__", long_integer_type_node); builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node); builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__", underlying_wchar_type_node); builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node); builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node); builtin_define_type_max ("__SIZE_MAX__", size_type_node); /* stdint.h and the testsuite need to know these. */ builtin_define_stdint_macros (); /* Provide information for library headers to determine whether to define macros such as __STDC_IEC_559__ and __STDC_IEC_559_COMPLEX__. */ builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ()); builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX", cpp_iec_559_complex_value ()); /* float.h needs to know this. */ builtin_define_with_int_value ("__FLT_EVAL_METHOD__", TARGET_FLT_EVAL_METHOD); /* And decfloat.h needs this. */ builtin_define_with_int_value ("__DEC_EVAL_METHOD__", TARGET_DEC_EVAL_METHOD); builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node); /* Cast the double precision constants. This is needed when single precision constants are specified or when pragma FLOAT_CONST_DECIMAL64 is used. The correct result is computed by the compiler when using macros that include a cast. We use a different cast for C++ to avoid problems with -Wold-style-cast. */ builtin_define_float_constants ("DBL", "L", (c_dialect_cxx () ? "double(%s)" : "((double)%s)"), "", double_type_node); builtin_define_float_constants ("LDBL", "L", "%s", "L", long_double_type_node); /* For decfloat.h. */ builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); /* For fixed-point fibt, ibit, max, min, and epsilon. */ if (targetm.fixed_point_supported_p ()) { builtin_define_fixed_point_constants ("SFRACT", "HR", short_fract_type_node); builtin_define_fixed_point_constants ("USFRACT", "UHR", unsigned_short_fract_type_node); builtin_define_fixed_point_constants ("FRACT", "R", fract_type_node); builtin_define_fixed_point_constants ("UFRACT", "UR", unsigned_fract_type_node); builtin_define_fixed_point_constants ("LFRACT", "LR", long_fract_type_node); builtin_define_fixed_point_constants ("ULFRACT", "ULR", unsigned_long_fract_type_node); builtin_define_fixed_point_constants ("LLFRACT", "LLR", long_long_fract_type_node); builtin_define_fixed_point_constants ("ULLFRACT", "ULLR", unsigned_long_long_fract_type_node); builtin_define_fixed_point_constants ("SACCUM", "HK", short_accum_type_node); builtin_define_fixed_point_constants ("USACCUM", "UHK", unsigned_short_accum_type_node); builtin_define_fixed_point_constants ("ACCUM", "K", accum_type_node); builtin_define_fixed_point_constants ("UACCUM", "UK", unsigned_accum_type_node); builtin_define_fixed_point_constants ("LACCUM", "LK", long_accum_type_node); builtin_define_fixed_point_constants ("ULACCUM", "ULK", unsigned_long_accum_type_node); builtin_define_fixed_point_constants ("LLACCUM", "LLK", long_long_accum_type_node); builtin_define_fixed_point_constants ("ULLACCUM", "ULLK", unsigned_long_long_accum_type_node); builtin_define_fixed_point_constants ("QQ", "", qq_type_node); builtin_define_fixed_point_constants ("HQ", "", hq_type_node); builtin_define_fixed_point_constants ("SQ", "", sq_type_node); builtin_define_fixed_point_constants ("DQ", "", dq_type_node); builtin_define_fixed_point_constants ("TQ", "", tq_type_node); builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node); builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node); builtin_define_fixed_point_constants ("USQ", "", usq_type_node); builtin_define_fixed_point_constants ("UDQ", "", udq_type_node); builtin_define_fixed_point_constants ("UTQ", "", utq_type_node); builtin_define_fixed_point_constants ("HA", "", ha_type_node); builtin_define_fixed_point_constants ("SA", "", sa_type_node); builtin_define_fixed_point_constants ("DA", "", da_type_node); builtin_define_fixed_point_constants ("TA", "", ta_type_node); builtin_define_fixed_point_constants ("UHA", "", uha_type_node); builtin_define_fixed_point_constants ("USA", "", usa_type_node); builtin_define_fixed_point_constants ("UDA", "", uda_type_node); builtin_define_fixed_point_constants ("UTA", "", uta_type_node); } /* For libgcc-internal use only. */ if (flag_building_libgcc) /* For libgcc enable-execute-stack.c. */ builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__", TRAMPOLINE_SIZE); /* For use in assembly language. */ builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); /* Misc. */ if (flag_gnu89_inline) cpp_define (pfile, "__GNUC_GNU_INLINE__"); else cpp_define (pfile, "__GNUC_STDC_INLINE__"); if (flag_no_inline) cpp_define (pfile, "__NO_INLINE__"); if (flag_iso) cpp_define (pfile, "__STRICT_ANSI__"); if (!flag_signed_char) cpp_define (pfile, "__CHAR_UNSIGNED__"); if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) cpp_define (pfile, "__WCHAR_UNSIGNED__"); /* Tell source code if the compiler makes sync_compare_and_swap builtins available. */ #ifdef HAVE_sync_compare_and_swapqi if (HAVE_sync_compare_and_swapqi) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); #endif #ifdef HAVE_sync_compare_and_swaphi if (HAVE_sync_compare_and_swaphi) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); #endif #ifdef HAVE_sync_compare_and_swapsi if (HAVE_sync_compare_and_swapsi) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); #endif #ifdef HAVE_sync_compare_and_swapdi if (HAVE_sync_compare_and_swapdi) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); #endif #ifdef HAVE_sync_compare_and_swapti if (HAVE_sync_compare_and_swapti) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"); #endif cpp_atomic_builtins (pfile); #ifdef DWARF2_UNWIND_INFO if (dwarf2out_do_cfi_asm ()) cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM"); #endif /* Make the choice of ObjC runtime visible to source code. */ if (c_dialect_objc () && flag_next_runtime) cpp_define (pfile, "__NEXT_RUNTIME__"); /* Show the availability of some target pragmas. */ cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); /* Make the choice of the stack protector runtime visible to source code. The macro names and values here were chosen for compatibility with an earlier implementation, i.e. ProPolice. */ if (flag_stack_protect == 3) cpp_define (pfile, "__SSP_STRONG__=3"); if (flag_stack_protect == 2) cpp_define (pfile, "__SSP_ALL__=2"); else if (flag_stack_protect == 1) cpp_define (pfile, "__SSP__=1"); if (flag_openmp) cpp_define (pfile, "_OPENMP=201307"); if (int128_integer_type_node != NULL_TREE) builtin_define_type_sizeof ("__SIZEOF_INT128__", int128_integer_type_node); builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node); builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node); builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__", unsigned_ptrdiff_type_node); /* A straightforward target hook doesn't work, because of problems linking that hook's body when part of non-C front ends. */ # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) # define builtin_define(TXT) cpp_define (pfile, TXT) # define builtin_assert(TXT) cpp_assert (pfile, TXT) TARGET_CPU_CPP_BUILTINS (); TARGET_OS_CPP_BUILTINS (); TARGET_OBJFMT_CPP_BUILTINS (); /* Support the __declspec keyword by turning them into attributes. Note that the current way we do this may result in a collision with predefined attributes later on. This can be solved by using one attribute, say __declspec__, and passing args to it. The problem with that approach is that args are not accumulated: each new appearance would clobber any existing args. */ if (TARGET_DECLSPEC) builtin_define ("__declspec(x)=__attribute__((x))"); /* If decimal floating point is supported, tell the user if the alternate format (BID) is used instead of the standard (DPD) format. */ if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT) cpp_define (pfile, "__DECIMAL_BID_FORMAT__"); if (c_dialect_cxx () && flag_sized_delete) cpp_define (pfile, "__GXX_DELETE_WITH_SIZE__"); }
void microblaze_cpp_define (cpp_reader *pfile) { builtin_assert ("cpu=microblaze"); builtin_assert ("machine=microblaze"); builtin_define ("__MICROBLAZE__"); builtin_define ("__microblaze__"); if (TARGET_LITTLE_ENDIAN) { builtin_define ("_LITTLE_ENDIAN"); builtin_define ("__LITTLE_ENDIAN__"); builtin_define ("__MICROBLAZEEL__"); } else { builtin_define ("_BIG_ENDIAN"); builtin_define ("__BIG_ENDIAN__"); builtin_define ("__MICROBLAZEEB__"); } if (!TARGET_SOFT_MUL) { if (!flag_iso) builtin_define ("HAVE_HW_MUL"); builtin_define ("__HAVE_HW_MUL__"); } if (TARGET_MULTIPLY_HIGH) { if (!flag_iso) builtin_define ("HAVE_HW_MUL_HIGH"); builtin_define ("__HAVE_HW_MUL_HIGH__"); } if (!TARGET_SOFT_DIV) { if (!flag_iso) builtin_define ("HAVE_HW_DIV"); builtin_define ("__HAVE_HW_DIV__"); } if (TARGET_BARREL_SHIFT) { if (!flag_iso) builtin_define ("HAVE_HW_BSHIFT"); builtin_define ("__HAVE_HW_BSHIFT__"); } if (TARGET_PATTERN_COMPARE) { if (!flag_iso) builtin_define ("HAVE_HW_PCMP"); builtin_define ("__HAVE_HW_PCMP__"); } if (TARGET_HARD_FLOAT) { if (!flag_iso) builtin_define ("HAVE_HW_FPU"); builtin_define ("__HAVE_HW_FPU__"); } if (TARGET_FLOAT_CONVERT) { if (!flag_iso) builtin_define ("HAVE_HW_FPU_CONVERT"); builtin_define ("__HAVE_HW_FPU_CONVERT__"); } if (TARGET_FLOAT_SQRT) { if (!flag_iso) builtin_define ("HAVE_HW_FPU_SQRT"); builtin_define ("__HAVE_HW_FPU_SQRT__"); } }
void riscv_cpu_cpp_builtins (cpp_reader *pfile) { builtin_define ("__riscv"); if (TARGET_RVC) builtin_define ("__riscv_compressed"); if (TARGET_ATOMIC) builtin_define ("__riscv_atomic"); if (TARGET_MUL) builtin_define ("__riscv_mul"); if (TARGET_DIV) builtin_define ("__riscv_div"); if (TARGET_DIV && TARGET_MUL) builtin_define ("__riscv_muldiv"); builtin_define_with_int_value ("__riscv_xlen", UNITS_PER_WORD * 8); if (TARGET_HARD_FLOAT) builtin_define_with_int_value ("__riscv_flen", UNITS_PER_FP_REG * 8); if (TARGET_HARD_FLOAT && TARGET_FDIV) { builtin_define ("__riscv_fdiv"); builtin_define ("__riscv_fsqrt"); } switch (riscv_abi) { case ABI_ILP32: case ABI_LP64: builtin_define ("__riscv_float_abi_soft"); break; case ABI_ILP32F: case ABI_LP64F: builtin_define ("__riscv_float_abi_single"); break; case ABI_ILP32D: case ABI_LP64D: builtin_define ("__riscv_float_abi_double"); break; } switch (riscv_cmodel) { case CM_MEDLOW: builtin_define ("__riscv_cmodel_medlow"); break; case CM_MEDANY: builtin_define ("__riscv_cmodel_medany"); break; case CM_PIC: builtin_define ("__riscv_cmodel_pic"); break; } }
static void arm_cpu_builtins (struct cpp_reader* pfile) { def_or_undef_macro (pfile, "__ARM_FEATURE_DSP", TARGET_DSP_MULTIPLY); def_or_undef_macro (pfile, "__ARM_FEATURE_QBIT", TARGET_ARM_QBIT); def_or_undef_macro (pfile, "__ARM_FEATURE_SAT", TARGET_ARM_SAT); def_or_undef_macro (pfile, "__ARM_FEATURE_CRYPTO", TARGET_CRYPTO); def_or_undef_macro (pfile, "__ARM_FEATURE_UNALIGNED", unaligned_access); def_or_undef_macro (pfile, "__ARM_FEATURE_QRDMX", TARGET_NEON_RDMA); if (TARGET_CRC32) builtin_define ("__ARM_FEATURE_CRC32"); def_or_undef_macro (pfile, "__ARM_32BIT_STATE", TARGET_32BIT); if (TARGET_ARM_FEATURE_LDREX) builtin_define_with_int_value ("__ARM_FEATURE_LDREX", TARGET_ARM_FEATURE_LDREX); else cpp_undef (pfile, "__ARM_FEATURE_LDREX"); def_or_undef_macro (pfile, "__ARM_FEATURE_CLZ", ((TARGET_ARM_ARCH >= 5 && !TARGET_THUMB) || TARGET_ARM_ARCH_ISA_THUMB >=2)); def_or_undef_macro (pfile, "__ARM_FEATURE_NUMERIC_MAXMIN", TARGET_ARM_ARCH >= 8 && TARGET_NEON && TARGET_FPU_ARMV8); def_or_undef_macro (pfile, "__ARM_FEATURE_SIMD32", TARGET_INT_SIMD); builtin_define_with_int_value ("__ARM_SIZEOF_MINIMAL_ENUM", flag_short_enums ? 1 : 4); builtin_define_type_sizeof ("__ARM_SIZEOF_WCHAR_T", wchar_type_node); if (TARGET_ARM_ARCH_PROFILE) builtin_define_with_int_value ("__ARM_ARCH_PROFILE", TARGET_ARM_ARCH_PROFILE); /* Define __arm__ even when in thumb mode, for consistency with armcc. */ builtin_define ("__arm__"); if (TARGET_ARM_ARCH) builtin_define_with_int_value ("__ARM_ARCH", TARGET_ARM_ARCH); if (arm_arch_notm) builtin_define ("__ARM_ARCH_ISA_ARM"); builtin_define ("__APCS_32__"); def_or_undef_macro (pfile, "__thumb__", TARGET_THUMB); def_or_undef_macro (pfile, "__thumb2__", TARGET_THUMB2); if (TARGET_BIG_END) def_or_undef_macro (pfile, "__THUMBEB__", TARGET_THUMB); else def_or_undef_macro (pfile, "__THUMBEL__", TARGET_THUMB); if (TARGET_ARM_ARCH_ISA_THUMB) builtin_define_with_int_value ("__ARM_ARCH_ISA_THUMB", TARGET_ARM_ARCH_ISA_THUMB); if (TARGET_BIG_END) { builtin_define ("__ARMEB__"); builtin_define ("__ARM_BIG_ENDIAN"); } else { builtin_define ("__ARMEL__"); } if (TARGET_SOFT_FLOAT) builtin_define ("__SOFTFP__"); builtin_define ("__VFP_FP__"); if (TARGET_ARM_FP) builtin_define_with_int_value ("__ARM_FP", TARGET_ARM_FP); else cpp_undef (pfile, "__ARM_FP"); def_or_undef_macro (pfile, "__ARM_FP16_FORMAT_IEEE", arm_fp16_format == ARM_FP16_FORMAT_IEEE); def_or_undef_macro (pfile, "__ARM_FP16_FORMAT_ALTERNATIVE", arm_fp16_format == ARM_FP16_FORMAT_ALTERNATIVE); def_or_undef_macro (pfile, "__ARM_FP16_ARGS", arm_fp16_format != ARM_FP16_FORMAT_NONE); def_or_undef_macro (pfile, "__ARM_FEATURE_FP16_SCALAR_ARITHMETIC", TARGET_VFP_FP16INST); def_or_undef_macro (pfile, "__ARM_FEATURE_FP16_VECTOR_ARITHMETIC", TARGET_NEON_FP16INST); def_or_undef_macro (pfile, "__ARM_FEATURE_FMA", TARGET_FMA); def_or_undef_macro (pfile, "__ARM_NEON__", TARGET_NEON); def_or_undef_macro (pfile, "__ARM_NEON", TARGET_NEON); if (TARGET_NEON_FP) builtin_define_with_int_value ("__ARM_NEON_FP", TARGET_NEON_FP); else cpp_undef (pfile, "__ARM_NEON_FP"); /* Add a define for interworking. Needed when building libgcc.a. */ if (arm_cpp_interwork) builtin_define ("__THUMB_INTERWORK__"); builtin_define (arm_arch_name); if (arm_arch_xscale) builtin_define ("__XSCALE__"); if (arm_arch_iwmmxt) { builtin_define ("__IWMMXT__"); builtin_define ("__ARM_WMMX"); } if (arm_arch_iwmmxt2) builtin_define ("__IWMMXT2__"); /* ARMv6KZ was originally identified as the misspelled __ARM_ARCH_6ZK__. To preserve the existing behavior, the misspelled feature macro must still be defined. */ if (arm_arch6kz) builtin_define ("__ARM_ARCH_6ZK__"); if (TARGET_AAPCS_BASED) { if (arm_pcs_default == ARM_PCS_AAPCS_VFP) builtin_define ("__ARM_PCS_VFP"); else if (arm_pcs_default == ARM_PCS_AAPCS) builtin_define ("__ARM_PCS"); builtin_define ("__ARM_EABI__"); } def_or_undef_macro (pfile, "__ARM_ARCH_EXT_IDIV__", TARGET_IDIV); def_or_undef_macro (pfile, "__ARM_FEATURE_IDIV", TARGET_IDIV); def_or_undef_macro (pfile, "__ARM_ASM_SYNTAX_UNIFIED__", inline_asm_unified); }
/* Hook that registers front end and target-specific built-ins. */ void c_cpp_builtins (cpp_reader *pfile) { /* -undef turns off target-specific built-ins. */ if (flag_undef) return; define__GNUC__ (); /* For stddef.h. They require macros defined in c-common.c. */ c_stddef_cpp_builtins (); if (c_dialect_cxx ()) { if (flag_weak && SUPPORTS_ONE_ONLY) cpp_define (pfile, "__GXX_WEAK__=1"); else cpp_define (pfile, "__GXX_WEAK__=0"); if (warn_deprecated) cpp_define (pfile, "__DEPRECATED"); if (flag_rtti) cpp_define (pfile, "__GXX_RTTI"); if (cxx_dialect == cxx0x) cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__"); } /* Note that we define this for C as well, so that we know if __attribute__((cleanup)) will interface with EH. */ if (flag_exceptions) cpp_define (pfile, "__EXCEPTIONS"); /* Represents the C++ ABI version, always defined so it can be used while preprocessing C and assembler. */ if (flag_abi_version == 0) /* Use a very large value so that: #if __GXX_ABI_VERSION >= <value for version X> will work whether the user explicitly says "-fabi-version=x" or "-fabi-version=0". Do not use INT_MAX because that will be different from system to system. */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999); else if (flag_abi_version == 1) /* Due to a historical accident, this version had the value "102". */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); else /* Newer versions have values 1002, 1003, .... */ builtin_define_with_int_value ("__GXX_ABI_VERSION", 1000 + flag_abi_version); /* libgcc needs to know this. */ if (USING_SJLJ_EXCEPTIONS) cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); /* limits.h needs to know these. */ builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0); builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0); builtin_define_type_max ("__INT_MAX__", integer_type_node, 0); builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1); builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2); builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0); builtin_define_type_precision ("__CHAR_BIT__", char_type_node); /* stdint.h (eventually) and the testsuite need to know these. */ builtin_define_stdint_macros (); /* float.h needs to know these. */ builtin_define_with_int_value ("__FLT_EVAL_METHOD__", TARGET_FLT_EVAL_METHOD); /* And decfloat.h needs this. */ builtin_define_with_int_value ("__DEC_EVAL_METHOD__", TARGET_DEC_EVAL_METHOD); builtin_define_float_constants ("FLT", "F", "%s", float_type_node); /* Cast the double precision constants when single precision constants are specified. The correct result is computed by the compiler when using macros that include a cast. This has the side-effect of making the value unusable in const expressions. */ if (flag_single_precision_constant) builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node); else builtin_define_float_constants ("DBL", "", "%s", double_type_node); builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node); /* For decfloat.h. */ builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); /* For fixed-point fibt, ibit, max, min, and epsilon. */ if (targetm.fixed_point_supported_p ()) { builtin_define_fixed_point_constants ("SFRACT", "HR", short_fract_type_node); builtin_define_fixed_point_constants ("USFRACT", "UHR", unsigned_short_fract_type_node); builtin_define_fixed_point_constants ("FRACT", "R", fract_type_node); builtin_define_fixed_point_constants ("UFRACT", "UR", unsigned_fract_type_node); builtin_define_fixed_point_constants ("LFRACT", "LR", long_fract_type_node); builtin_define_fixed_point_constants ("ULFRACT", "ULR", unsigned_long_fract_type_node); builtin_define_fixed_point_constants ("LLFRACT", "LLR", long_long_fract_type_node); builtin_define_fixed_point_constants ("ULLFRACT", "ULLR", unsigned_long_long_fract_type_node); builtin_define_fixed_point_constants ("SACCUM", "HK", short_accum_type_node); builtin_define_fixed_point_constants ("USACCUM", "UHK", unsigned_short_accum_type_node); builtin_define_fixed_point_constants ("ACCUM", "K", accum_type_node); builtin_define_fixed_point_constants ("UACCUM", "UK", unsigned_accum_type_node); builtin_define_fixed_point_constants ("LACCUM", "LK", long_accum_type_node); builtin_define_fixed_point_constants ("ULACCUM", "ULK", unsigned_long_accum_type_node); builtin_define_fixed_point_constants ("LLACCUM", "LLK", long_long_accum_type_node); builtin_define_fixed_point_constants ("ULLACCUM", "ULLK", unsigned_long_long_accum_type_node); builtin_define_fixed_point_constants ("QQ", "", qq_type_node); builtin_define_fixed_point_constants ("HQ", "", hq_type_node); builtin_define_fixed_point_constants ("SQ", "", sq_type_node); builtin_define_fixed_point_constants ("DQ", "", dq_type_node); builtin_define_fixed_point_constants ("TQ", "", tq_type_node); builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node); builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node); builtin_define_fixed_point_constants ("USQ", "", usq_type_node); builtin_define_fixed_point_constants ("UDQ", "", udq_type_node); builtin_define_fixed_point_constants ("UTQ", "", utq_type_node); builtin_define_fixed_point_constants ("HA", "", ha_type_node); builtin_define_fixed_point_constants ("SA", "", sa_type_node); builtin_define_fixed_point_constants ("DA", "", da_type_node); builtin_define_fixed_point_constants ("TA", "", ta_type_node); builtin_define_fixed_point_constants ("UHA", "", uha_type_node); builtin_define_fixed_point_constants ("USA", "", usa_type_node); builtin_define_fixed_point_constants ("UDA", "", uda_type_node); builtin_define_fixed_point_constants ("UTA", "", uta_type_node); } /* For use in assembly language. */ builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); /* Misc. */ builtin_define_with_value ("__VERSION__", version_string, 1); if (flag_gnu89_inline) cpp_define (pfile, "__GNUC_GNU_INLINE__"); else cpp_define (pfile, "__GNUC_STDC_INLINE__"); /* Definitions for LP64 model. */ if (TYPE_PRECISION (long_integer_type_node) == 64 && POINTER_SIZE == 64 && TYPE_PRECISION (integer_type_node) == 32) { cpp_define (pfile, "_LP64"); cpp_define (pfile, "__LP64__"); } /* Other target-independent built-ins determined by command-line options. */ if (optimize_size) cpp_define (pfile, "__OPTIMIZE_SIZE__"); if (optimize) cpp_define (pfile, "__OPTIMIZE__"); if (fast_math_flags_set_p ()) cpp_define (pfile, "__FAST_MATH__"); if (flag_no_inline) cpp_define (pfile, "__NO_INLINE__"); if (flag_signaling_nans) cpp_define (pfile, "__SUPPORT_SNAN__"); if (flag_finite_math_only) cpp_define (pfile, "__FINITE_MATH_ONLY__=1"); else cpp_define (pfile, "__FINITE_MATH_ONLY__=0"); if (flag_pic) { builtin_define_with_int_value ("__pic__", flag_pic); builtin_define_with_int_value ("__PIC__", flag_pic); } if (flag_pie) { builtin_define_with_int_value ("__pie__", flag_pie); builtin_define_with_int_value ("__PIE__", flag_pie); } if (flag_iso) cpp_define (pfile, "__STRICT_ANSI__"); if (!flag_signed_char) cpp_define (pfile, "__CHAR_UNSIGNED__"); if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) cpp_define (pfile, "__WCHAR_UNSIGNED__"); /* Define a macro indicating whether the thread safety attributes/analysis is supported. */ if (warn_thread_safety) { cpp_define (pfile, "__SUPPORT_TS_ANNOTATION__"); cpp_define (pfile, "__SUPPORT_DYN_ANNOTATION__"); } /* Tell source code if the compiler makes sync_compare_and_swap builtins available. */ #ifdef HAVE_sync_compare_and_swapqi if (HAVE_sync_compare_and_swapqi) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); #endif #ifdef HAVE_sync_compare_and_swaphi if (HAVE_sync_compare_and_swaphi) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); #endif #ifdef HAVE_sync_compare_and_swapsi if (HAVE_sync_compare_and_swapsi) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); #endif #ifdef HAVE_sync_compare_and_swapdi if (HAVE_sync_compare_and_swapdi) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); #endif #ifdef HAVE_sync_compare_and_swapti if (HAVE_sync_compare_and_swapti) cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"); #endif #ifdef DWARF2_UNWIND_INFO if (dwarf2out_do_cfi_asm ()) cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM"); #endif /* Make the choice of ObjC runtime visible to source code. */ if (c_dialect_objc () && flag_next_runtime) cpp_define (pfile, "__NEXT_RUNTIME__"); /* Show the availability of some target pragmas. */ if (flag_mudflap || targetm.handle_pragma_redefine_extname) cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); if (targetm.handle_pragma_extern_prefix) cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX"); /* Make the choice of the stack protector runtime visible to source code. The macro names and values here were chosen for compatibility with an earlier implementation, i.e. ProPolice. */ if (flag_stack_protect == 2) cpp_define (pfile, "__SSP_ALL__=2"); else if (flag_stack_protect == 1) cpp_define (pfile, "__SSP__=1"); if (flag_openmp) cpp_define (pfile, "_OPENMP=200805"); builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node); builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node); builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__", long_long_integer_type_node); builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node); builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node); builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node); builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node); builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node); builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node); builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node); builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__", unsigned_ptrdiff_type_node); /* ptr_type_node can't be used here since ptr_mode is only set when toplev calls backend_init which is not done with -E switch. */ builtin_define_with_int_value ("__SIZEOF_POINTER__", POINTER_SIZE / BITS_PER_UNIT); /* A straightforward target hook doesn't work, because of problems linking that hook's body when part of non-C front ends. */ # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) # define builtin_define(TXT) cpp_define (pfile, TXT) # define builtin_assert(TXT) cpp_assert (pfile, TXT) TARGET_CPU_CPP_BUILTINS (); TARGET_OS_CPP_BUILTINS (); TARGET_OBJFMT_CPP_BUILTINS (); /* Support the __declspec keyword by turning them into attributes. Note that the current way we do this may result in a collision with predefined attributes later on. This can be solved by using one attribute, say __declspec__, and passing args to it. The problem with that approach is that args are not accumulated: each new appearance would clobber any existing args. */ if (TARGET_DECLSPEC) builtin_define ("__declspec(x)=__attribute__((x))"); /* If decimal floating point is supported, tell the user if the alternate format (BID) is used instead of the standard (DPD) format. */ if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT) cpp_define (pfile, "__DECIMAL_BID_FORMAT__"); builtin_define_with_int_value ("__BIGGEST_ALIGNMENT__", BIGGEST_ALIGNMENT / BITS_PER_UNIT); }